From 617aed9f3ef8fa3783f5871364f131c1be05ad4c Mon Sep 17 00:00:00 2001 From: Zhaoyilunnn Date: Sat, 1 Apr 2023 14:08:28 +0000 Subject: [PATCH 01/70] 1. Optimized data convertion between python and cpp 2. Fixed set_num bug when initialized from statevector --- src/qfvm/qfvm.cpp | 38 +++++---- src/qfvm/simulator.hpp | 8 +- src/qfvm/statevector.hpp | 174 +++++++++++++++++++++------------------ src/qfvm/types.hpp | 3 +- 4 files changed, 122 insertions(+), 101 deletions(-) diff --git a/src/qfvm/qfvm.cpp b/src/qfvm/qfvm.cpp index 741cfea..c56ec5e 100644 --- a/src/qfvm/qfvm.cpp +++ b/src/qfvm/qfvm.cpp @@ -5,32 +5,42 @@ namespace py = pybind11; template -py::array_t to_numpy(std::vector &&src) { - vector* src_ptr = new std::vector(std::move(src)); - auto capsule = py::capsule(src_ptr, [](void* p) { delete reinterpret_cast*>(p); }); - return py::array_t( - src_ptr->size(), // shape of array - src_ptr->data(), // c-style contiguous strides for vector - capsule // numpy array references this parent - ); +py::array_t to_numpy(const std::tuple &src) { + auto src_ptr = *std::get<0>(src); + auto src_size = std::get<1>(src); + + auto capsule = py::capsule(src_ptr, [](void* p) { + delete [] reinterpret_cast(p); + }); + return py::array_t( + src_size, + src_ptr, + capsule + ); } - py::object execute(string qasm){ return to_numpy(simulate(qasm).move_data()); } -py::object simulate_circuit(py::object const&pycircuit, vector> const&inputstate){ - auto circuit = Circuit(pycircuit); - if (inputstate.size() == 0){ +py::object simulate_circuit(py::object const&pycircuit, py::array_t> &np_inputstate){ + auto circuit = Circuit(pycircuit); + + py::buffer_info buf = np_inputstate.request(); + auto* data_ptr = reinterpret_cast*>(buf.ptr); + size_t data_size = buf.size; + + + if (data_size == 0){ StateVector state; simulate(circuit, state); return to_numpy(state.move_data()); } else{ - StateVector state{inputstate}; + StateVector state(data_ptr, buf.size); simulate(circuit, state); - return to_numpy(state.move_data()); + //return to_numpy(state.move_data()); + return np_inputstate; } } diff --git a/src/qfvm/simulator.hpp b/src/qfvm/simulator.hpp index 49e19d7..568e895 100644 --- a/src/qfvm/simulator.hpp +++ b/src/qfvm/simulator.hpp @@ -66,11 +66,11 @@ void simulate(Circuit const& circuit, StateVector & state){ state.apply_rz(op.positions()[1], op.paras()[0]); state.apply_cnot(op.positions()[0], op.positions()[1]); break; - + //Other general gate - default: - { + default: + { if (op.targe_num() == 1){ auto mat_temp = op.mat(); complex *mat = mat_temp.data(); @@ -176,7 +176,7 @@ void simulate(string qasm, StateVector & state){ StateVector simulate(string qasm){ StateVectorstate; simulate(qasm, state); - return std::move(state); + return std::move(state); } diff --git a/src/qfvm/statevector.hpp b/src/qfvm/statevector.hpp index 977659c..eb06b9b 100644 --- a/src/qfvm/statevector.hpp +++ b/src/qfvm/statevector.hpp @@ -20,13 +20,13 @@ class StateVector{ private: uint num_; size_t size_; - vector> data_; + complex* data_; public: //construct function StateVector(); explicit StateVector(uint num); - explicit StateVector(vector> const&data); + explicit StateVector(complex *data, size_t data_size); //Named gate function void apply_x(pos_t pos); @@ -48,7 +48,7 @@ class StateVector{ void apply_cry(pos_t control, pos_t targe, real_t theta); void apply_ccx(pos_t control1, pos_t control2, pos_t targe); void apply_swap(pos_t q1, pos_t q2); - + //General implementation //One-target gate, ctrl_num equal 2 represent multi-controlled gate template @@ -65,19 +65,19 @@ class StateVector{ complex operator[] (size_t j) const ; void set_num(uint num); - vector> move_data(){ return std::move(data_); } - void print_state(); + void print_state(); + std::tuple**, size_t> move_data() {return std::make_tuple(&data_, size_);} }; //////// constructors /////// template -StateVector::StateVector(uint num) -: num_(num), -size_(std::pow(2, num)), -data_(size_) -{ +StateVector::StateVector(uint num) +: num_(num), +size_(std::pow(2, num)) +{ + data_ = new complex[size_]; data_[0] = complex(1., 0); }; @@ -85,10 +85,10 @@ template StateVector::StateVector() : StateVector(0){ } template -StateVector::StateVector(vector> const&data) +StateVector::StateVector(complex *data, size_t data_size) : -size_(data.size()), -data_(data) +data_(data), +size_(data_size) { num_ = static_cast(std::log2(size_)); } @@ -101,10 +101,20 @@ std::complex StateVector::operator[] (size_t j) const{ template void StateVector::set_num(uint num){ - num_ = num; - size_ = std::pow(2, num_); - data_.resize(size_); - } + if (num_ > 0) { + // Initialized from statevector, + // should not resize + return; + } + num_ = num; + + if (size_ != 1ULL << num) { + delete [] data_; + size_ = 1ULL << num; + data_ = new complex[size_]; + data_[0] = complex(1, 0); + } +} template void StateVector::print_state(){ @@ -121,12 +131,12 @@ void StateVector::apply_x(pos_t pos){ const size_t offset = 1<>1; if (pos == 0){ //single step -#ifdef USE_SIMD +#ifdef USE_SIMD #pragma omp parallel for for(omp_i j = 0;j < size_;j+=2){ - double* ptr = (double*)(data_.data() + j); + double* ptr = (double*)(data_ + j); __m256d data = _mm256_loadu_pd(ptr); - data = _mm256_permute4x64_pd(data, 78); + data = _mm256_permute4x64_pd(data, 78); _mm256_storeu_pd(ptr, data); } #else @@ -141,8 +151,8 @@ void StateVector::apply_x(pos_t pos){ #pragma omp parallel for for(omp_i j = 0;j < rsize;j += 2){ size_t i = (j&(offset-1)) | (j>>pos<::apply_y(pos_t pos){ __m256d minus_half = _mm256_set_pd(1, -1, -1, 1); #pragma omp parallel for for(omp_i j = 0;j < size_;j+=2){ - double* ptr = (double*)(data_.data() + j); + double* ptr = (double*)(data_ + j); __m256d data = _mm256_loadu_pd(ptr); data = _mm256_permute4x64_pd(data, 27); data = _mm256_mul_pd(data, minus_half); @@ -179,7 +189,7 @@ void StateVector::apply_y(pos_t pos){ #else #pragma omp parallel for for(omp_i j = 0;j < size_;j+=2){ - complex temp = data_[j]; + complex temp = data_[j]; data_[j] = -im*data_[j+1]; data_[j+1] = im*temp; } @@ -189,16 +199,16 @@ void StateVector::apply_y(pos_t pos){ #ifdef USE_SIMD __m256d minus_even = _mm256_set_pd(1, -1, 1, -1); __m256d minus_odd = _mm256_set_pd(-1, 1, -1, 1); - + #pragma omp parallel for for(omp_i j = 0;j < rsize;j += 2){ size_t i = (j&(offset-1)) | (j>>pos<::apply_y(pos_t pos){ for(omp_i j = 0;j < rsize;j += 2){ size_t i = (j&(offset-1)) | (j>>pos< temp = data_[i]; + complex temp = data_[i]; data_[i] = -im*data_[i+offset]; data_[i+offset] = im*temp; - complex temp1 = data_[i1]; + complex temp1 = data_[i1]; data_[i1] = -im*data_[i1+offset]; data_[i1+offset] = im*temp1; } @@ -237,7 +247,7 @@ void StateVector::apply_z(pos_t pos){ #pragma omp parallel for for(omp_i j = 0;j < rsize;j += 2){ size_t i = (j&(offset-1)) | (j>>pos<::apply_cp(pos_t control, pos_t targe, real_t phase){ template void StateVector::apply_crx(pos_t control, pos_t targe, real_t theta){ complex mat[4] = {std::cos(theta/2), -imag_I*std::sin(theta/2), -imag_I*std::sin(theta/2), std::cos(theta/2)}; - + apply_one_targe_gate_general<1>(vector{control, targe}, mat); } template void StateVector::apply_cry(pos_t control, pos_t targe, real_t theta){ complex mat[4] = {std::cos(theta/2), -std::sin(theta/2),std::sin(theta/2), std::cos(theta/2)}; - + apply_one_targe_gate_real<1>(vector{control, targe}, mat); } @@ -361,7 +371,7 @@ void StateVector::apply_ccx(pos_t control1, pos_t control2, pos_t targe) template template void StateVector::apply_one_targe_gate_general(vector const& posv, complex *mat) -{ +{ std::function getind_func_near; std::function getind_func; size_t rsize; @@ -378,14 +388,14 @@ void StateVector::apply_one_targe_gate_general(vector const& posv getind_func_near = [&](size_t j)-> size_t { return 2*j; }; - + getind_func = [&](size_t j)-> size_t { return (j&(offset-1)) | (j>>targe<::apply_one_targe_gate_general(vector const& posv getind_func_near = getind_func; - + } else if(ctrl_num == 2){ has_control = true; @@ -426,14 +436,14 @@ void StateVector::apply_one_targe_gate_general(vector const& posv } return i; }; - getind_func_near = getind_func; + getind_func_near = getind_func; } - + const complex mat00 = mat[0]; const complex mat01 = mat[1]; const complex mat10 = mat[2]; const complex mat11 = mat[3]; - if (targe == 0){ + if (targe == 0){ #pragma omp parallel for for(omp_i j = 0;j < rsize;j++){ size_t i = getind_func_near(j); @@ -462,11 +472,11 @@ void StateVector::apply_one_targe_gate_general(vector const& posv __m256d m_11re = _mm256_set_pd(mat[3].real(), mat[3].real(), mat[3].real(), mat[3].real()); __m256d m_11im = _mm256_set_pd(mat[3].imag(), -mat[3].imag(), mat[3].imag(), -mat[3].imag()); #pragma omp parallel for - for(omp_i j = 0;j < rsize; j+= 2){ + for(omp_i j = 0;j < rsize; j+= 2){ size_t i = getind_func(j); - - double* p0 = (double*)(data_.data()+i); - double* p1 = (double*)(data_.data()+i+offset); + + double* p0 = (double*)(data_+i); + double* p1 = (double*)(data_+i+offset); //load data __m256d data0 = _mm256_loadu_pd(p0); //lre_0, lim_0, rre_0, rim_0 __m256d data1 = _mm256_loadu_pd(p1); //lre_1, lim_1, rre_1, rim_1 @@ -508,7 +518,7 @@ void StateVector::apply_one_targe_gate_general(vector const& posv } #endif } -} +} template @@ -532,7 +542,7 @@ void StateVector::apply_one_targe_gate_x(vector const& posv) getind_func_near = [&](size_t j)-> size_t { return 2*j; }; - + getind_func = [&](size_t j)-> size_t { return (j&(offset-1)) | (j>>targe<::apply_one_targe_gate_x(vector const& posv) } return i; }; - getind_func_near = getind_func; + getind_func_near = getind_func; } - + if (targe == 0){ -#ifdef USE_SIMD +#ifdef USE_SIMD #pragma omp parallel for for(omp_i j = 0;j < rsize;j++){ size_t i = getind_func_near(j); - double* ptr = (double*)(data_.data() + i); + double* ptr = (double*)(data_ + i); __m256d data = _mm256_loadu_pd(ptr); - data = _mm256_permute4x64_pd(data, 78); + data = _mm256_permute4x64_pd(data, 78); _mm256_storeu_pd(ptr, data); } #else @@ -594,7 +604,7 @@ void StateVector::apply_one_targe_gate_x(vector const& posv) size_t i = getind_func(j); std::swap(data_[i], data_[i+1]); } -#endif +#endif }else if (has_control && control == 0){ //single step #pragma omp parallel for for(omp_i j = 0;j < rsize;j++){ @@ -605,10 +615,10 @@ void StateVector::apply_one_targe_gate_x(vector const& posv) }else{//unroll to 2 #ifdef USE_SIMD #pragma omp parallel for - for(omp_i j = 0;j < rsize; j+= 2){ + for(omp_i j = 0;j < rsize; j+= 2){ size_t i = getind_func(j); - double* ptr0 = (double*)(data_.data() + i); - double* ptr1 = (double*)(data_.data() + i + offset); + double* ptr0 = (double*)(data_ + i); + double* ptr1 = (double*)(data_ + i + offset); __m256d data0 = _mm256_loadu_pd(ptr0); __m256d data1 = _mm256_loadu_pd(ptr1); _mm256_storeu_pd(ptr1, data0); @@ -624,7 +634,7 @@ void StateVector::apply_one_targe_gate_x(vector const& posv) } #endif } -} +} template template @@ -646,14 +656,14 @@ void StateVector::apply_one_targe_gate_real(vector const& posv, c getind_func_near = [&](size_t j)-> size_t { return 2*j; }; - + getind_func = [&](size_t j)-> size_t { return (j&(offset-1)) | (j>>targe<::apply_one_targe_gate_real(vector const& posv, c } return i; }; - getind_func_near = getind_func; + getind_func_near = getind_func; } - + const double mat00 = mat[0].real(); const double mat01 = mat[1].real(); const double mat10 = mat[2].real(); const double mat11 = mat[3].real(); - if (targe == 0){ + if (targe == 0){ #pragma omp parallel for for(omp_i j = 0;j < rsize;j++){ size_t i = getind_func_near(j); @@ -706,9 +716,9 @@ void StateVector::apply_one_targe_gate_real(vector const& posv, c data_[i] = mat00*data_[i] + mat01*data_[i+1]; data_[i+1] = mat10*temp + mat11*data_[i+1]; } - + }else if (has_control && control == 0){ //single step - + #pragma omp parallel for for(omp_i j = 0;j < rsize;j++){ size_t i = getind_func(j); @@ -723,11 +733,11 @@ void StateVector::apply_one_targe_gate_real(vector const& posv, c __m256d m_10re = _mm256_set_pd(mat[2].real(), mat[2].real(), mat[2].real(), mat[2].real()); __m256d m_11re = _mm256_set_pd(mat[3].real(), mat[3].real(), mat[3].real(), mat[3].real()); #pragma omp parallel for - for(omp_i j = 0;j < rsize; j+= 2){ + for(omp_i j = 0;j < rsize; j+= 2){ size_t i = getind_func(j); - - double* p0 = (double*)(data_.data()+i); - double* p1 = (double*)(data_.data()+i+offset); + + double* p0 = (double*)(data_+i); + double* p1 = (double*)(data_+i+offset); //load data __m256d data0 = _mm256_loadu_pd(p0); //lre_0, lim_0, rre_0, rim_0 __m256d data1 = _mm256_loadu_pd(p1); //lre_1, lim_1, rre_1, rim_1 @@ -761,7 +771,7 @@ void StateVector::apply_one_targe_gate_real(vector const& posv, c } #endif } -} +} template @@ -784,14 +794,14 @@ void StateVector::apply_one_targe_gate_diag(vector const& posv, c getind_func_near = [&](size_t j)-> size_t { return 2*j; }; - + getind_func = [&](size_t j)-> size_t { return (j&(offset-1)) | (j>>targe<::apply_one_targe_gate_diag(vector const& posv, c }; getind_func_near = getind_func; - + } else if(ctrl_num == 2){ has_control = true; @@ -831,19 +841,19 @@ void StateVector::apply_one_targe_gate_diag(vector const& posv, c } return i; }; - getind_func_near = getind_func; + getind_func_near = getind_func; } - - if (targe == 0){ + + if (targe == 0){ #pragma omp parallel for for(omp_i j = 0;j < rsize;j++){ size_t i = getind_func_near(j); data_[i] *= mat[0]; data_[i+1] *= mat[1]; } - + }else if (has_control && control == 0){ //single step - + #pragma omp parallel for for(omp_i j = 0;j < rsize;j++){ size_t i = getind_func(j); @@ -859,11 +869,11 @@ void StateVector::apply_one_targe_gate_diag(vector const& posv, c __m256d m_11re = _mm256_set_pd(mat[1].real(), mat[1].real(), mat[1].real(), mat[1].real()); __m256d m_11im = _mm256_set_pd(mat[1].imag(), -mat[1].imag(), mat[1].imag(), -mat[1].imag()); #pragma omp parallel for - for(omp_i j = 0;j < rsize; j+= 2){ + for(omp_i j = 0;j < rsize; j+= 2){ size_t i = getind_func(j); - - double* p0 = (double*)(data_.data()+i); - double* p1 = (double*)(data_.data()+i+offset); + + double* p0 = (double*)(data_+i); + double* p1 = (double*)(data_+i+offset); //load data __m256d data0 = _mm256_loadu_pd(p0); //lre_0, lim_0, rre_0, rim_0 @@ -896,7 +906,7 @@ void StateVector::apply_one_targe_gate_diag(vector const& posv, c } #endif } -} +} template void StateVector::apply_multi_targe_gate_general(vector const& posv, uint control_num, RowMatrixXcd const& mat) @@ -920,7 +930,7 @@ void StateVector::apply_multi_targe_gate_general(vector const& po } //apply matrix -//TODO: Disalbe Parallel when matsize is very large +//TODO: Disalbe Parallel when matsize is very large #pragma omp parallel for for (omp_i j = 0;j < rsize;j++){ size_t i = j; diff --git a/src/qfvm/types.hpp b/src/qfvm/types.hpp index c6d581b..5ece0f7 100644 --- a/src/qfvm/types.hpp +++ b/src/qfvm/types.hpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #ifdef _MSC_VER @@ -29,4 +30,4 @@ using std::string; using RowMatrixXcd = Eigen::Matrix, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>; const complex imag_I = complex(0, 1.); -const double PI = 3.14159265358979323846; \ No newline at end of file +const double PI = 3.14159265358979323846; From b34b40ad0d8d1b4b65f961c42840688ddddc9f0e Mon Sep 17 00:00:00 2001 From: Zhaoyilunnn Date: Sun, 2 Apr 2023 06:20:29 +0000 Subject: [PATCH 02/70] Add destructor to Statevector --- src/qfvm/statevector.hpp | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/src/qfvm/statevector.hpp b/src/qfvm/statevector.hpp index eb06b9b..dc236c0 100644 --- a/src/qfvm/statevector.hpp +++ b/src/qfvm/statevector.hpp @@ -21,6 +21,7 @@ class StateVector{ uint num_; size_t size_; complex* data_; + uint count_; // Reference count of current statevector public: //construct function @@ -28,6 +29,9 @@ class StateVector{ explicit StateVector(uint num); explicit StateVector(complex *data, size_t data_size); + //destruct function + ~StateVector(); + //Named gate function void apply_x(pos_t pos); void apply_y(pos_t pos); @@ -66,7 +70,10 @@ class StateVector{ complex operator[] (size_t j) const ; void set_num(uint num); void print_state(); - std::tuple**, size_t> move_data() {return std::make_tuple(&data_, size_);} + std::tuple**, size_t> move_data() { + count_++; + return std::make_tuple(&data_, size_); + } }; @@ -79,6 +86,7 @@ size_(std::pow(2, num)) { data_ = new complex[size_]; data_[0] = complex(1., 0); + count_ = 0; }; template @@ -93,6 +101,17 @@ size_(data_size) num_ = static_cast(std::log2(size_)); } + +template +StateVector::~StateVector() { + // If ownership is moved to python, do nothing + // Other wise we need to release statevector's memory + if (data_ && count_ == 0) { + delete [] data_; + } +} + + //// useful functions ///// template std::complex StateVector::operator[] (size_t j) const{ From ad5ef8cabc85f696bdf386f6895eedcff6190c29 Mon Sep 17 00:00:00 2001 From: lss0208 <382715246@qq.com> Date: Mon, 3 Apr 2023 20:55:28 +0800 Subject: [PATCH 03/70] add GPU support --- .github/workflows/wheels.yml | 2 +- CMakeLists.txt | 55 +++++++++++++++++++++--- README.md | 12 ++++++ src/qfvm/circuit.hpp | 12 +++++- src/qfvm/qfvm.cpp | 61 +++++++++++++++++++++++++++ src/qfvm/statevector.hpp | 30 +++++++++++-- src/qfvm_gpu | 1 + src/quafu/elements/quantum_element.py | 47 +++++++++++++-------- src/quafu/simulators/simulator.py | 20 +++++++-- 9 files changed, 206 insertions(+), 34 deletions(-) create mode 160000 src/qfvm_gpu diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml index c647ca1..0956ad1 100644 --- a/.github/workflows/wheels.yml +++ b/.github/workflows/wheels.yml @@ -10,7 +10,7 @@ on: pull_request_review: types: [submitted, edited] workflow_dispatch: - release: + jobs: diff --git a/CMakeLists.txt b/CMakeLists.txt index cf6b53c..40d6511 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2,10 +2,11 @@ cmake_minimum_required(VERSION 3.14...3.22) -project(qfvm LANGUAGES CXX C) +project(qfvm LANGUAGES CXX C CUDA) set (CMAKE_BUILD_TYPE Release) - +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CUDA_ARCHITECTURES 70;75;80;90) if(SKBUILD) execute_process( @@ -42,9 +43,6 @@ ExternalProject_Add(Eigen3 PREFIX ${EIGEN3_ROOT} GIT_REPOSITORY https://gitlab.com/libeigen/eigen.git GIT_TAG 3.3.9 - # CONFIGURE_COMMAND cd ${EIGEN3_ROOT}/src/Eigen3 && cmake -B build -DCMAKE_INSTALL_PREFIX=${EIGEN3_ROOT} - # BUILD_COMMAND "" - # INSTALL_COMMAND cd ${EIGEN3_ROOT}/src/Eigen3 && cmake --build build --target install CONFIGURE_COMMAND "" BUILD_COMMAND "" @@ -72,6 +70,7 @@ if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "x86_64" OR CMAKE_HOST_SYSTEM_PROCESSOR endif() endif() +list (APPEND PRJ_INCLUDE_DIRS src/qfvm) pybind11_add_module(${PROJECT_NAME} MODULE src/${PROJECT_NAME}/${PROJECT_NAME}.cpp) add_dependencies(${PROJECT_NAME} Eigen3) #must add dependence for ninja target_compile_options(${PROJECT_NAME} PUBLIC ${PRJ_COMPILE_OPTIONS}) @@ -80,4 +79,48 @@ target_link_libraries(${PROJECT_NAME} PUBLIC ${PRJ_LIBRARIES}) set_target_properties(${PROJECT_NAME} PROPERTIES SUFFIX ${PYTHON_MODULE_EXTENSION}) target_compile_definitions(${PROJECT_NAME} PRIVATE VERSION_INFO=${PROJECT_VERSION}) -install(TARGETS ${PROJECT_NAME} DESTINATION .) +#GPU version +if (USE_GPU) + add_compile_definitions(_USE_GPU) + set_source_files_properties(src/${PROJECT_NAME}/${PROJECT_NAME}.cpp PROPERTIES LANGUAGE CUDA) + target_link_libraries(${PROJECT_NAME} PUBLIC cudart) + target_compile_options(${PROJECT_NAME} PUBLIC $<$:--extended-lambda> ) + target_include_directories(${PROJECT_NAME} PUBLIC src/qfvm_gpu) + target_include_directories(${PROJECT_NAME} PUBLIC src/qfvm_gpu/cuda_utils) + target_include_directories(${PROJECT_NAME} PUBLIC ${CUDA_INCLUDE_DIRS}) + message("cuda_include" ${CUDA_INCLUDE_DIRS}) + if (USE_CUQUANTUM) + add_compile_definitions(_USE_CUQUANTUM) + function(set_with_fallback VARIABLE FALLBACK) + if (NOT DEFINED ${VARIABLE} OR ${VARIABLE} STREQUAL "") + set(${VARIABLE} $ENV{${VARIABLE}} CACHE INTERNAL ${VARIABLE}) + if (${VARIABLE} STREQUAL "") + if (NOT ${FALLBACK} STREQUAL "") + set(${VARIABLE} $ENV{${FALLBACK}} CACHE INTERNAL ${VARIABLE}) + endif () + endif () + endif () + endfunction() + + set_with_fallback(CUSTATEVEC_ROOT CUQUANTUM_ROOT) + + if (CUSTATEVEC_ROOT STREQUAL "") + message(FATAL_ERROR "Please set the environment variables CUSTATEVEC_ROOT or CUQUANTUM_ROOT to the path of the cuQuantum installation.") + endif () + + message(STATUS "Using CUSTATEVEC_ROOT = ${CUSTATEVEC_ROOT}") + + set(CMAKE_CUDA_FLAGS_ARCH_SM70 "-gencode arch=compute_70,code=sm_70") + set(CMAKE_CUDA_FLAGS_ARCH_SM75 "-gencode arch=compute_75,code=sm_75") + set(CMAKE_CUDA_FLAGS_ARCH_SM80 "-gencode arch=compute_80,code=sm_80 -gencode arch=compute_80,code=compute_80") + set(CMAKE_CUDA_FLAGS_ARCH_SM90 "-gencode arch=compute_90,code=sm_90 -gencode arch=compute_90,code=compute_90") + set(CMAKE_CUDA_FLAGS_ARCH "${CMAKE_CUDA_FLAGS_ARCH_SM70} ${CMAKE_CUDA_FLAGS_ARCH_SM75} ${CMAKE_CUDA_FLAGS_ARCH_SM80} ${CMAKE_CUDA_FLAGS_ARCH_SM90}") + set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} ${CMAKE_CUDA_FLAGS_ARCH}") + + target_include_directories(${PROJECT_NAME} PUBLIC ${CUDA_INCLUDE_DIRS} ${CUSTATEVEC_ROOT}/include) + target_link_directories(${PROJECT_NAME} PUBLIC ${CUSTATEVEC_ROOT}/lib ${CUSTATEVEC_ROOT}/lib64) + target_link_libraries(${PROJECT_NAME} PUBLIC -lcustatevec_static -lcublas ) + endif() +endif() + +install(TARGETS ${PROJECT_NAME} DESTINATION .) \ No newline at end of file diff --git a/README.md b/README.md index 30d92e6..caecdc0 100644 --- a/README.md +++ b/README.md @@ -22,6 +22,18 @@ pip install -r requirements.txt python setup.py install ``` +## GPU support +To install PyQuafu with GPU-based circuit simulator, you need build from the source and make sure that [CUDA Toolkit](https://developer.nvidia.com/cuda-downloads) is installed. You can run + +``` +python setup.py install -DUSE_GPU=ON +``` +to install the GPU version. If you further have [cuQuantum](https://developer.nvidia.com/cuquantum-sdk) installed, you can install PyQuafu with cuQuantum support. +``` +python setup.py install -DUSE_GPU=ON -DUSE_CUQUANTUM=ON +``` + + ## Document Please see the website [docs](https://scq-cloud.github.io/). diff --git a/src/qfvm/circuit.hpp b/src/qfvm/circuit.hpp index 214da35..4d576ee 100644 --- a/src/qfvm/circuit.hpp +++ b/src/qfvm/circuit.hpp @@ -89,7 +89,7 @@ class Circuit{ private: uint qubit_num_; vector gates_{0}; - + uint max_targe_num_; public: Circuit(); explicit Circuit(uint qubit_num); @@ -99,6 +99,7 @@ class Circuit{ void add_gate(QuantumOperator &gate); void compress_gates(); uint qubit_num() const { return qubit_num_; } + uint max_targe_num() const {return max_targe_num_;} vectorgates() const { return gates_; } }; @@ -121,16 +122,21 @@ void Circuit::add_gate(QuantumOperator &gate){ Circuit::Circuit(vector &gates) : - gates_(gates){ + gates_(gates), + max_targe_num_(0){ qubit_num_ = 0; for (auto gate : gates){ for (pos_t pos : gate.positions()){ + if (gate.targe_num() > max_targe_num_) + max_targe_num_ = gate.targe_num(); if (pos+1 > qubit_num_){ qubit_num_ = pos+1; } } } } Circuit::Circuit(py::object const&pycircuit) +: +max_targe_num_(0) { auto pygates = pycircuit.attr("gates"); auto used_qubits = pycircuit.attr("used_qubits").cast>(); @@ -139,6 +145,8 @@ Circuit::Circuit(py::object const&pycircuit) py::object pygate = py::reinterpret_borrow(pygate_h); QuantumOperator gate = from_pyops(pygate); if (gate){ + if (gate.targe_num() > max_targe_num_) + max_targe_num_ = gate.targe_num(); gates_.push_back(std::move(gate)); } } diff --git a/src/qfvm/qfvm.cpp b/src/qfvm/qfvm.cpp index c56ec5e..fdd3ade 100644 --- a/src/qfvm/qfvm.cpp +++ b/src/qfvm/qfvm.cpp @@ -2,6 +2,14 @@ #include #include "simulator.hpp" +#ifdef _USE_GPU +#include +#endif + +#ifdef _USE_CUQUANTUM +#include +#endif + namespace py = pybind11; template @@ -44,10 +52,63 @@ py::object simulate_circuit(py::object const&pycircuit, py::array_t> &np_inputstate){ + auto circuit = Circuit(pycircuit); + py::buffer_info buf = np_inputstate.request(); + auto* data_ptr = reinterpret_cast*>(buf.ptr); + size_t data_size = buf.size; + + + if (data_size == 0){ + StateVector state; + simulate_gpu(circuit, state); + return to_numpy(state.move_data()); + } + else{ + StateVector state(data_ptr, buf.size); + simulate_gpu(circuit, state); + //return to_numpy(state.move_data()); + return np_inputstate; + } +} +#endif + +#ifdef _USE_CUQUANTUM +py::object simulate_circuit_custate(py::object const&pycircuit, py::array_t> &np_inputstate){ + auto circuit = Circuit(pycircuit); + py::buffer_info buf = np_inputstate.request(); + auto* data_ptr = reinterpret_cast*>(buf.ptr); + size_t data_size = buf.size; + + + if (data_size == 0){ + StateVector state; + simulate_custate(circuit, state); + return to_numpy(state.move_data()); + } + else{ + StateVector state(data_ptr, buf.size); + simulate_custate(circuit, state); + //return to_numpy(state.move_data()); + return np_inputstate; + } +} +#endif + + PYBIND11_MODULE(qfvm, m) { m.doc() = "Qfvm simulator"; m.def("execute", &execute, "Simulate with qasm"); m.def("simulate_circuit", &simulate_circuit, "Simulate with circuit", py::arg("circuit"), py::arg("inputstate")= py::array_t>(0)); + + #ifdef _USE_GPU + m.def("simulate_circuit_gpu", &simulate_circuit_gpu, "Simulate with circuit", py::arg("circuit"), py::arg("inputstate")= py::array_t>(0)); + #endif + + #ifdef _USE_CUQUANTUM + m.def("simulate_circuit_custate", &simulate_circuit_custate, "Simulate with circuit", py::arg("circuit"), py::arg("inputstate")= py::array_t>(0)); + #endif } diff --git a/src/qfvm/statevector.hpp b/src/qfvm/statevector.hpp index dc236c0..db3956d 100644 --- a/src/qfvm/statevector.hpp +++ b/src/qfvm/statevector.hpp @@ -29,6 +29,26 @@ class StateVector{ explicit StateVector(uint num); explicit StateVector(complex *data, size_t data_size); + //Disable copy construct + StateVector(StateVector const &other) = delete; + StateVector &operator=(StateVector const &other) = delete; + + //Move construct + StateVector(StateVector &&other) : + num_(other.num()), + size_(other.size()), + data_(other.data()), + count_(other.count_) + { + other.data_ = nullptr; + } + + StateVector &operator=(StateVector &&other){ + this->~StateVector(); + new (this) StateVector(std::move(other)); + return *this; + } + //destruct function ~StateVector(); @@ -74,6 +94,9 @@ class StateVector{ count_++; return std::make_tuple(&data_, size_); } + complex* data(){ return data_; } + size_t size(){ return size_; } + uint num(){ return num_; } }; @@ -931,18 +954,17 @@ template void StateVector::apply_multi_targe_gate_general(vector const& posv, uint control_num, RowMatrixXcd const& mat) { auto posv_sorted = posv; - auto targ_sorted = vector(posv.begin()+control_num, posv.end()); + auto targs = vector(posv.begin()+control_num, posv.end()); sort(posv_sorted.begin(), posv_sorted.end()); - sort(targ_sorted.begin(), targ_sorted.end()); size_t rsize = size_ >> posv.size(); - uint targe_num = targ_sorted.size(); + uint targe_num = targs.size(); size_t matsize= 1<< targe_num; std::vector targ_mask(matsize); //create target mask for (size_t m = 0; m < matsize;m++){ for (size_t j = 0; j < targe_num; j++){ if ((m>>j)&1){ - auto mask_pos = targ_sorted[j]; + auto mask_pos = targs[j]; targ_mask[m] |= 1ll< 1): qnum = len(self.pos) order = np.array(range(len(self.pos))[::-1]) order = np.concatenate([order, order+qnum]) dim = 2**qnum - tensorm = self._matrix.reshape([2]*2*qnum) + tensorm = targ_matrix.reshape([2]*2*qnum) targ_matrix = np.transpose(tensorm, order).reshape([dim, dim]) return targ_matrix @@ -212,16 +214,16 @@ def matrix(self): def matrix(self, matrix): if isinstance(matrix, Callable): self._matrix = matrix(self.paras) - self.reorder_matrix() + self._matrix = reorder_matrix(self._matrix, self.pos) elif isinstance(matrix, (np.ndarray, List)): self._matrix = matrix - self.reorder_matrix() + self._matrix = reorder_matrix(self._matrix, self.pos) else: raise TypeError("Unsupported `matrix` type") class ControlledGate(MultiQubitGate): - """ Controlled gate class, where the matrix act non-trivallly on target qubits""" + """ Controlled gate class, where the matrix act non-trivaly on target qubits""" def __init__(self, name, targe_name, ctrls: List[int], targs: List[int], paras, matrix): self.ctrls = ctrls self.targs = targs @@ -259,11 +261,20 @@ def matrix(self, matrix : Union[np.ndarray, Callable]): self._matrix[i, i] = 1. self._matrix[control_dim:, control_dim:] = matrix - self.reorder_matrix() - self._targ_matrix = matrix + self._matrix = reorder_matrix(self._matrix, self.pos) + # self._targ_matrix = reorder_matrix(matrix, self.targs) def get_targ_matrix(self, reverse_order=False): - return self._targ_matrix + targ_matrix = self._targ_matrix + if reverse_order and (len(self.targs) > 1): + qnum = len(self.targs) + order = np.array(range(len(self.targs))[::-1]) + order = np.concatenate([order, order+qnum]) + dim = 2**qnum + tensorm = targ_matrix.reshape([2]*2*qnum) + targ_matrix = np.transpose(tensorm, order).reshape([dim, dim]) + + return targ_matrix class ControlledU(ControlledGate): def __init__(self, name, ctrls: List[int], U: Union[SingleQubitGate, MultiQubitGate]): @@ -272,7 +283,7 @@ def __init__(self, name, ctrls: List[int], U: Union[SingleQubitGate, MultiQubitG if isinstance(targs, int): targs = [targs] - super().__init__(name, U.name, ctrls, targs, U.paras, matrix=self.targ_gate.matrix) + super().__init__(name, U.name, ctrls, targs, U.paras, matrix=self.targ_gate.get_targ_matrix()) def get_targ_matrix(self, reverse_order=False): return self.targ_gate.get_targ_matrix(reverse_order) diff --git a/src/quafu/simulators/simulator.py b/src/quafu/simulators/simulator.py index 8bb2dfe..9a4f3fb 100644 --- a/src/quafu/simulators/simulator.py +++ b/src/quafu/simulators/simulator.py @@ -7,12 +7,12 @@ import numpy as np import time -def simulate(qc : Union[QuantumCircuit, str], psi : np.ndarray= np.array([]), simulator:str="qfvm_circ", output: str="probabilities")-> SimuResult: +def simulate(qc : Union[QuantumCircuit, str], psi : np.ndarray= np.array([]), simulator:str="qfvm_circ", output: str="probabilities", use_gpu=False, use_custatevec=False)-> SimuResult: """Simulate quantum circuit Args: qc: quantum circuit or qasm string that need to be simulated. psi : Input state vector - simulator:`"qfvm_circ"`: The high performance C++ circuit simulator. + simulator:`"qfvm_circ"`: The high performance C++ circuit simulator with GPU support. `"py_simu"`: Python implemented simulator by sparse matrix with low performace for large scale circuit. `"qfvm_qasm"`: The high performance C++ qasm simulator with limited gate set. @@ -36,7 +36,21 @@ def simulate(qc : Union[QuantumCircuit, str], psi : np.ndarray= np.array([]), si if simulator == "qfvm_circ": num = max(qc.used_qubits)+1 measures = list(qc.measures.keys()) - psi = simulate_circuit(qc, psi) + if use_gpu: + if use_custatevec: + try: + from .qfvm import simulate_circuit_custate + except ImportError: + raise(" pyquafu is installed with cuquantum support") + psi = simulate_circuit_custate(qc, psi) + else: + try: + from .qfvm import simulate_circuit_gpu + except ImportError: + raise("you are not using the GPU version of pyquafu") + psi = simulate_circuit_gpu(qc, psi) + else: + psi = simulate_circuit(qc, psi) elif simulator == "py_simu": psi = py_simulate(qc, psi) From 62c759c254151ff9faa3f278c17f3b3410eddcd2 Mon Sep 17 00:00:00 2001 From: lss0208 <382715246@qq.com> Date: Mon, 3 Apr 2023 21:00:14 +0800 Subject: [PATCH 04/70] rm submodule --- src/qfvm_gpu | 1 - src/qfvm_gpu/apply_gate_custate.cuh | 46 + src/qfvm_gpu/apply_gate_gpu.cuh | 411 ++++++++ src/qfvm_gpu/cuda_simulator.cuh | 91 ++ src/qfvm_gpu/cuda_statevector.cuh | 58 ++ src/qfvm_gpu/cuda_utils/CudaTexture.h | 39 + src/qfvm_gpu/cuda_utils/helper_cuda.h | 953 ++++++++++++++++++ src/qfvm_gpu/cuda_utils/helper_custatevec.hpp | 31 + src/qfvm_gpu/cuda_utils/helper_string.h | 683 +++++++++++++ src/qfvm_gpu/cuda_utils/ticktock.h | 9 + src/qfvm_gpu/custate_simu.cuh | 35 + 11 files changed, 2356 insertions(+), 1 deletion(-) delete mode 160000 src/qfvm_gpu create mode 100644 src/qfvm_gpu/apply_gate_custate.cuh create mode 100644 src/qfvm_gpu/apply_gate_gpu.cuh create mode 100644 src/qfvm_gpu/cuda_simulator.cuh create mode 100644 src/qfvm_gpu/cuda_statevector.cuh create mode 100644 src/qfvm_gpu/cuda_utils/CudaTexture.h create mode 100644 src/qfvm_gpu/cuda_utils/helper_cuda.h create mode 100644 src/qfvm_gpu/cuda_utils/helper_custatevec.hpp create mode 100644 src/qfvm_gpu/cuda_utils/helper_string.h create mode 100644 src/qfvm_gpu/cuda_utils/ticktock.h create mode 100644 src/qfvm_gpu/custate_simu.cuh diff --git a/src/qfvm_gpu b/src/qfvm_gpu deleted file mode 160000 index 6dcb8e6..0000000 --- a/src/qfvm_gpu +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 6dcb8e6cce5aade1cc0e037d4d3fec1951b3caa4 diff --git a/src/qfvm_gpu/apply_gate_custate.cuh b/src/qfvm_gpu/apply_gate_custate.cuh new file mode 100644 index 0000000..2d9c2e7 --- /dev/null +++ b/src/qfvm_gpu/apply_gate_custate.cuh @@ -0,0 +1,46 @@ + +#pragma once +#include +#include + + +void apply_gate_custate(cuDoubleComplex *psi_d, QuantumOperator &op, int n) +{ + + //get information form op + auto pos = op.positions(); + const int nTargets = op.targe_num(); + const int nControls = op.control_num(); + const int adjoint = 0; + + vector targets{pos.begin()+nControls, pos.end()}; + vector controls{pos.begin(), pos.begin()+nControls}; + + auto mat_temp = op.mat(); + cuDoubleComplex *mat = + reinterpret_cast(mat_temp.data()); + + // custatevec handle initialization + custatevecHandle_t handle; + custatevecCreate(&handle) ; + void* extraWorkspace = nullptr; + size_t extraWorkspaceSizeInBytes = 0; + + // check the size of external workspace + custatevecApplyMatrixGetWorkspaceSize( + handle, CUDA_C_64F, n, mat, CUDA_C_64F, CUSTATEVEC_MATRIX_LAYOUT_ROW, + adjoint, nTargets, nControls, CUSTATEVEC_COMPUTE_64F, &extraWorkspaceSizeInBytes) ; + + // allocate external workspace if necessary + if (extraWorkspaceSizeInBytes > 0) + cudaMalloc(&extraWorkspace, extraWorkspaceSizeInBytes); + + custatevecApplyMatrix( + handle, psi_d, CUDA_C_64F, n, mat, CUDA_C_64F, + CUSTATEVEC_MATRIX_LAYOUT_ROW, adjoint, targets.data(), nTargets, controls.data(), nullptr, + nControls, CUSTATEVEC_COMPUTE_64F, extraWorkspace, extraWorkspaceSizeInBytes); + + // destroy handle + custatevecDestroy(handle); +} + \ No newline at end of file diff --git a/src/qfvm_gpu/apply_gate_gpu.cuh b/src/qfvm_gpu/apply_gate_gpu.cuh new file mode 100644 index 0000000..e2d7be0 --- /dev/null +++ b/src/qfvm_gpu/apply_gate_gpu.cuh @@ -0,0 +1,411 @@ +#pragma once +#include +#include +#include +#include +#include + +struct targeIndex +{ + size_t ind0; + size_t ind1; +}; + + +__constant__ uint posv_d[50]; +__constant__ uint posv_sorted_d[50]; +__constant__ cuDoubleComplex mat_d_const[32*32]; //If target qubit < 5, use const memory; +__constant__ uint mat_mask_d_const[32]; + + +//-------------Single-target gate------------------------------- +template +__global__ void apply_one_targe_gate_kernel(cuDoubleComplex *psi_d, Func get_index, int rsize){ + cuDoubleComplex mat00 = mat_d_const[0]; + cuDoubleComplex mat01 = mat_d_const[1]; + cuDoubleComplex mat10 = mat_d_const[2]; + cuDoubleComplex mat11 = mat_d_const[3]; + + unsigned int gridSize = blockDim.x*gridDim.x; + for (int j = blockDim.x * blockIdx.x + threadIdx.x; j < rsize;j+= gridSize){ + targeIndex ind = get_index(j); + cuDoubleComplex temp = psi_d[ind.ind0]; + psi_d[ind.ind0] = cuCadd(cuCmul(mat00, psi_d[ind.ind0]), cuCmul(mat01, psi_d[ind.ind1])); + psi_d[ind.ind1] = cuCadd(cuCmul(mat10, temp), cuCmul(mat11, psi_d[ind.ind1])); + } +} + +template +void apply_one_targe_gate_gpu(cuDoubleComplex *psi_d, QuantumOperator &op, size_t size){ + //copy mat to device + auto mat_temp = op.mat(); + cuDoubleComplex *mat = + reinterpret_cast(mat_temp.data()); + checkCudaErrors(cudaMemcpyToSymbol(mat_d_const, mat, 4*sizeof(cuDoubleComplex))); + size_t rsize; + size_t offset; + size_t targe; + size_t control; + size_t setbit; + size_t poffset; + if (ctrl_num == 0){ + targe = op.positions()[0]; + offset = 1ll<>1; + auto getind_func = [offset, targe] __device__ (size_t j)-> targeIndex { + size_t ind0 = (j&(offset-1)) | (j>>targe<>>(psi_d, getind_func, rsize); + } + else if(ctrl_num == 1){ + control = op.positions()[0]; + targe = op.positions()[1]; + offset = 1ll<targe) { + control--; + } + poffset=1ll<>2; + auto getind_func = [control, targe, poffset, offset, setbit] __device__ (size_t j) -> targeIndex { + size_t ind0 = (j>>control<<(control+1))|(j&(poffset-1)); + ind0 = (ind0 >> targe << (targe+1))|(ind0 &(offset-1))|setbit; + size_t ind1 = ind0 + offset; + return {ind0, ind1}; + }; + + + size_t blockdim = rsize <= 1024 ? rsize : 1024; + size_t griddim = rsize / blockdim; + + apply_one_targe_gate_kernel<<>>(psi_d, getind_func, rsize); + } + else if(ctrl_num == 2){ + targe = op.positions().back(); + offset = 1ll<>psize; + + vector posv_sorted = op.positions(); + std::sort(posv_sorted.begin(), posv_sorted.end()); + //Copy pos to device + checkCudaErrors(cudaMemcpyToSymbol(posv_d, op.positions().data(), psize*sizeof(uint))); + checkCudaErrors(cudaMemcpyToSymbol(posv_sorted_d, posv_sorted.data(), psize*sizeof(uint))); + + auto getind_func = [offset, psize] __device__ (size_t j)-> targeIndex{ + size_t ind0 = j; + for (pos_t k=0;k < psize;k++) + { + pos_t _pos = posv_sorted_d[k]; + ind0 = (ind0&((1ll<<_pos)-1)) | (ind0>>_pos<<_pos<<1); + } + for (pos_t k=0;k < psize-1;k++){ + ind0 |= 1ll<>>(psi_d, getind_func, rsize); + } +} + +template +__global__ void apply_2to4_targe_gate_kernel(cuDoubleComplex *psi_d, uint ctrlnum, int psize){ + constexpr uint matlen = 1<>_pos<<_pos<<1); + } + // Set control + for (size_t k=0; k < ctrlnum;k++){ + i |= 1ll< +void apply_2to4_targe_gate_gpu_const(cuDoubleComplex *psi_d, QuantumOperator &op, size_t size){ + // uint targe_num = op.targe_num(); + uint matlen = 1<(pos.begin()+op.control_num(), pos.end()); + vector targ_mask(matlen); + //create target mask + for (size_t m = 0; m < matlen;m++){ + for (size_t j = 0; j < targe_num; j++){ + if ((m>>j)&1){ + auto mask_pos = targs[j]; + targ_mask[m] |= 1ll< posv_sorted = op.positions(); + uint psize = pos.size(); + std::sort(posv_sorted.begin(),posv_sorted.end()); + //Copy pos to device + checkCudaErrors(cudaMemcpyToSymbol(posv_d, pos.data(), psize*sizeof(uint))); + checkCudaErrors(cudaMemcpyToSymbol(posv_sorted_d, posv_sorted.data(), psize*sizeof(uint))); + + //copy mat to const memory + auto mat_temp = op.mat(); + cuDoubleComplex *mat = reinterpret_cast(mat_temp.data()); + + checkCudaErrors(cudaMemcpyToSymbol(mat_d_const, mat, matlen*matlen*sizeof(cuDoubleComplex))); + checkCudaErrors(cudaMemcpyToSymbol(mat_mask_d_const, targ_mask.data(), matlen*sizeof(uint))); + size_t rsize = size>>psize; + + uint max_thread_num = targe_num < 4 ? 1024 : 512; + size_t blockdim = rsize <= max_thread_num ? rsize : max_thread_num; + size_t griddim = rsize / blockdim; + apply_2to4_targe_gate_kernel<<>>(psi_d, op.control_num(), psize); +} + + + +// ------------Large target number gate--------------- + +__global__ void apply_5_targe_gate_kernel_const(cuDoubleComplex *psi_d, uint ctrlnum, int psize, size_t size){ + uint rsize = size>>psize; + uint targnum = psize-ctrlnum; + uint matlen = (1<>_pos<<_pos<<1); + } + // Set control + for (size_t k=0; k < ctrlnum;k++){ + i |= 1ll<>1;offset > 0;offset >>=1){ + v.x += __shfl_down_sync(0xFFFFFFFF, v.x, offset); + v.y += __shfl_down_sync(0xFFFFFFFF, v.y, offset); + } + __syncthreads(); + if (!idx) psi_d[ i | mat_mask_d_const[idy]] = v; +} + + +void apply_5_targe_gate_gpu_const(cuDoubleComplex *psi_d, QuantumOperator &op, size_t size){ + uint targe_num = op.targe_num(); + uint matlen = 1<(pos.begin()+op.control_num(), pos.end()); + vector targ_mask(matlen); + //create target mask + for (size_t m = 0; m < matlen;m++){ + for (size_t j = 0; j < targe_num; j++){ + if ((m>>j)&1){ + auto mask_pos = targs[j]; + targ_mask[m] |= 1ll< posv_sorted = op.positions(); + uint psize = pos.size(); + std::sort(posv_sorted.begin(),posv_sorted.end()); + //Copy pos to device + checkCudaErrors(cudaMemcpyToSymbol(posv_d, pos.data(), psize*sizeof(uint))); + checkCudaErrors(cudaMemcpyToSymbol(posv_sorted_d, posv_sorted.data(), psize*sizeof(uint))); + + //copy mat to const memory + auto mat_temp = op.mat(); + cuDoubleComplex *mat = reinterpret_cast(mat_temp.data()); + + checkCudaErrors(cudaMemcpyToSymbol(mat_d_const, mat, matlen*matlen*sizeof(cuDoubleComplex))); + checkCudaErrors(cudaMemcpyToSymbol(mat_mask_d_const, targ_mask.data(), matlen*sizeof(uint))); + size_t rsize = size>>psize; + uint thread_num = matlen > 32 ? 32 : matlen; + dim3 blockdim = dim3(thread_num, thread_num); + apply_5_targe_gate_kernel_const<<>>(psi_d, op.control_num(), psize, size); +} + + +//For target number 6-10 +__global__ void apply_multi_targe_gate_kernel_shared(cuDoubleComplex *psi_d, uint ctrlnum, cuDoubleComplex *mat_d, uint *mat_mask_d, int psize, size_t size){ + + uint rsize = size>>psize; + uint targnum = psize-ctrlnum; + uint matlen = (1<>_pos<<_pos<<1); + } + // Set control + for (size_t k=0; k < ctrlnum;k++){ + i |= 1ll<>1;offset > 0;offset >>=1){ + v.x += __shfl_down_sync(0xFFFFFFFF, v.x, offset); + v.y += __shfl_down_sync(0xFFFFFFFF, v.y, offset); + } + __syncthreads(); + if (!idx) local_sum[y] = cuCadd(local_sum[y], v); + } + } + + for (int y = idy; y < matlen;y+=blockDim.y){ + if (!idx) psi_d[ i | mat_mask_d[y]] = local_sum[y]; + } +} + + +void apply_multi_targe_gate_gpu_shared(cuDoubleComplex *psi_d, QuantumOperator &op, cuDoubleComplex *mat_d, uint *mat_mask_d, size_t size){ + uint targe_num = op.targe_num(); + uint matlen = 1<(pos.begin()+op.control_num(), pos.end()); + vector targ_mask(matlen); + //create target mask + for (size_t m = 0; m < matlen;m++){ + for (size_t j = 0; j < targe_num; j++){ + if ((m>>j)&1){ + auto mask_pos = targs[j]; + targ_mask[m] |= 1ll< posv_sorted = pos; + std::sort(posv_sorted.begin(),posv_sorted.end()); + //Copy pos to device + checkCudaErrors(cudaMemcpyToSymbol(posv_d, pos.data(), psize*sizeof(uint))); + checkCudaErrors(cudaMemcpyToSymbol(posv_sorted_d, posv_sorted.data(), psize*sizeof(uint))); + + + //copy mat to global memory + auto mat_temp = op.mat(); + cuDoubleComplex *mat = reinterpret_cast(mat_temp.data()); + checkCudaErrors(cudaMemcpy(mat_d, mat, matlen*matlen*sizeof(cuDoubleComplex), cudaMemcpyHostToDevice)); + checkCudaErrors(cudaMemcpy(mat_mask_d, targ_mask.data(), matlen*sizeof(uint), cudaMemcpyHostToDevice)); + + size_t rsize = size>>psize; + uint thread_num = matlen > 32 ? 32 : matlen; + dim3 blockdim = dim3(thread_num, thread_num); + + apply_multi_targe_gate_kernel_shared<<>>(psi_d, op.control_num(), mat_d, mat_mask_d, psize, size); +} + +//For target number > 10 +__global__ void apply_multi_targe_gate_kernel_global(cuDoubleComplex *psi_d, cuDoubleComplex *psi_d_copy, uint ctrlnum, cuDoubleComplex *mat_d, uint *mat_mask_d, int psize, size_t size){ + uint rsize = size>>psize; + uint targnum = psize-ctrlnum; + uint matlen = (1<>_pos<<_pos<<1); + } + // Set control + for (size_t k=0; k < ctrlnum;k++){ + i |= 1ll<>1;offset > 0;offset >>=1){ + v.x += __shfl_down_sync(0xFFFFFFFF, v.x, offset); + v.y += __shfl_down_sync(0xFFFFFFFF, v.y, offset); + } + __syncthreads(); + if (!idx) v_sum = cuCadd(v_sum, v); + } + if (!idx) psi_d[ i | mat_mask_d[y]] = v_sum; + } +} + +void apply_multi_targe_gate_gpu_global(cuDoubleComplex *psi_d, cuDoubleComplex *psi_d_copy, QuantumOperator &op, cuDoubleComplex *mat_d, uint *mat_mask_d, size_t size){ + uint targe_num = op.targe_num(); + uint matlen = 1<(pos.begin()+op.control_num(), pos.end()); + vector targ_mask(matlen); + //create target mask + for (size_t m = 0; m < matlen;m++){ + for (size_t j = 0; j < targe_num; j++){ + if ((m>>j)&1){ + auto mask_pos = targs[j]; + targ_mask[m] |= 1ll< posv_sorted = pos; + std::sort(posv_sorted.begin(),posv_sorted.end()); + //Copy pos to device + checkCudaErrors(cudaMemcpyToSymbol(posv_d, pos.data(), psize*sizeof(uint))); + checkCudaErrors(cudaMemcpyToSymbol(posv_sorted_d, posv_sorted.data(), psize*sizeof(uint))); + + + //copy mat to global memory + auto mat_temp = op.mat(); + cuDoubleComplex *mat = reinterpret_cast(mat_temp.data()); + checkCudaErrors(cudaMemcpy(mat_d, mat, matlen*matlen*sizeof(cuDoubleComplex), cudaMemcpyHostToDevice)); + checkCudaErrors(cudaMemcpy(mat_mask_d, targ_mask.data(), matlen*sizeof(uint), cudaMemcpyHostToDevice)); + + size_t rsize = size>>psize; + uint thread_num = matlen > 32 ? 32 : matlen; + dim3 blockdim = dim3(thread_num, thread_num); + + apply_multi_targe_gate_kernel_global<<>>(psi_d, psi_d_copy, op.control_num(), mat_d, mat_mask_d, psize, size); + checkCudaErrors(cudaMemcpy(psi_d_copy, psi_d, size*sizeof(cuDoubleComplex), cudaMemcpyDeviceToDevice)); +} \ No newline at end of file diff --git a/src/qfvm_gpu/cuda_simulator.cuh b/src/qfvm_gpu/cuda_simulator.cuh new file mode 100644 index 0000000..99ee5e4 --- /dev/null +++ b/src/qfvm_gpu/cuda_simulator.cuh @@ -0,0 +1,91 @@ +#pragma once +#include "cuda_statevector.cuh" +#include +#include +#include +#include +#include "apply_gate_gpu.cuh" + +void simulate_gpu(Circuit & circuit, CudaStateVector & psi_d){ + size_t size = psi_d.size(); + //initialize mat + cuDoubleComplex *mat_d; + uint *mat_mask_d; + CudaStateVector psi_d_copy{}; + if (circuit.max_targe_num() > 5) + { + uint max_matlen = 1< 10){ + psi_d_copy = psi_d; + } + } + + //apply_gate + for (auto gate : circuit.gates()){ + uint targnum = gate.targe_num(); + uint ctrlnum = gate.control_num(); + + if (targnum == 1){ + if (ctrlnum == 0){ + apply_one_targe_gate_gpu<0>(psi_d.data(), gate, size); + } + else if (ctrlnum == 1){ + apply_one_targe_gate_gpu<1>(psi_d.data(), gate, size); + } + else{ + apply_one_targe_gate_gpu<2>(psi_d.data(), gate, size); + } + } + else if(targnum > 1){ + if (targnum == 2){ + apply_2to4_targe_gate_gpu_const<2>(psi_d.data(), gate, size); + } + else if(targnum == 3){ + apply_2to4_targe_gate_gpu_const<3>(psi_d.data(), gate, size); + } + else if(targnum == 4){ + apply_2to4_targe_gate_gpu_const<4>(psi_d.data(), gate, size); + } + else if (targnum == 5){ + apply_5_targe_gate_gpu_const(psi_d.data(), gate, size); + }else if (targnum > 5 && targnum <= 10){ + apply_multi_targe_gate_gpu_shared(psi_d.data(), gate, mat_d, mat_mask_d, size); + } + else{ + apply_multi_targe_gate_gpu_global(psi_d.data(), psi_d_copy.data(), gate, mat_d, mat_mask_d, size); + } + } + else{ + throw "Invalid target number"; + } + } + + //free source + if (circuit.max_targe_num() > 5){ + checkCudaErrors(cudaFree(mat_d)); + checkCudaErrors(cudaFree(mat_mask_d)); + } +} + +void simulate_gpu(Circuit & circuit, StateVector & state){ + //initialize psi + state.set_num(circuit.qubit_num()); + size_t size = state.size(); + CudaStateVector psi_d(state); + + simulate_gpu(circuit, psi_d); + cudaDeviceSynchronize(); + + //copy back + complex* psi = reinterpret_cast*>(psi_d.data()); + checkCudaErrors(cudaMemcpy(state.data(), psi, size*sizeof(complex), cudaMemcpyDeviceToHost)); + psi=nullptr; +} + +StateVector simulate_gpu(Circuit & circuit){ + StateVector state(circuit.qubit_num()); + simulate_gpu(circuit, state); + return std::move(state); +} \ No newline at end of file diff --git a/src/qfvm_gpu/cuda_statevector.cuh b/src/qfvm_gpu/cuda_statevector.cuh new file mode 100644 index 0000000..19e8cb4 --- /dev/null +++ b/src/qfvm_gpu/cuda_statevector.cuh @@ -0,0 +1,58 @@ + +#pragma once +#include +#include +#include +#include + +class CudaStateVector +{ + protected: + uint num_; + size_t size_; + cuDoubleComplex *data_; + + public: + //construct function + CudaStateVector(){checkCudaErrors(cudaMalloc(&data_, 0));} + CudaStateVector(CudaStateVector const &other); + + explicit CudaStateVector(StateVector &sv); + ~CudaStateVector() { + checkCudaErrors(cudaFree(data_)); + } + + CudaStateVector &operator=(CudaStateVector const &other) + { + num_ = other.num(); + size_ = other.size(); + checkCudaErrors(cudaMalloc(&data_, size_*sizeof(cuDoubleComplex))); + checkCudaErrors(cudaMemcpy(data_, other.data(), size_*sizeof(cuDoubleComplex), cudaMemcpyDeviceToDevice)); + return *this; + } + + cuDoubleComplex* data() const { return data_;} + size_t size() const { return size_; } + uint num() const { return num_; } +}; + + +CudaStateVector::CudaStateVector(StateVector &sv) +: +num_(sv.num()), +size_(sv.size()) +{ + cuDoubleComplex *psi_h = reinterpret_cast(sv.data()); + checkCudaErrors(cudaMalloc(&data_, size_*sizeof(cuDoubleComplex))); + checkCudaErrors(cudaMemcpy(data_, psi_h, size_*sizeof(cuDoubleComplex), cudaMemcpyHostToDevice)); +} + +CudaStateVector::CudaStateVector(CudaStateVector const &other) +: +num_(other.num()), +size_(other.size()) +{ + checkCudaErrors(cudaMalloc(&data_, size_*sizeof(cuDoubleComplex))); + checkCudaErrors(cudaMemcpy(data_, other.data(), size_*sizeof(cuDoubleComplex), cudaMemcpyDeviceToDevice)); +} + diff --git a/src/qfvm_gpu/cuda_utils/CudaTexture.h b/src/qfvm_gpu/cuda_utils/CudaTexture.h new file mode 100644 index 0000000..0661d0d --- /dev/null +++ b/src/qfvm_gpu/cuda_utils/CudaTexture.h @@ -0,0 +1,39 @@ +#pragma once + + +#include "helper_cuda.h" +#include + + +struct CudaTexture { + cudaTextureObject_t tex; + + CudaTexture(CudaTexture const &) = delete; + CudaTexture(CudaTexture &&) = default; + CudaTexture &operator=(CudaTexture const &) = delete; + CudaTexture &operator=(CudaTexture &&) = default; + + template + CudaTexture(T *dataDev, int width, int height) { + cudaTextureObject_t tex; + cudaResourceDesc resDesc; + memset(&resDesc, 0, sizeof(resDesc)); + resDesc.resType = cudaResourceTypePitch2D; + resDesc.res.pitch2D.devPtr = dataDev; + resDesc.res.pitch2D.width = width; + resDesc.res.pitch2D.height = height; + resDesc.res.pitch2D.desc = cudaCreateChannelDesc(); + resDesc.res.pitch2D.pitchInBytes = width * sizeof(T); + cudaTextureDesc texDesc; + memset(&texDesc, 0, sizeof(texDesc)); + checkCudaErrors(cudaCreateTextureObject(&tex, &resDesc, &texDesc, NULL)); + } + + ~CudaTexture() { + checkCudaErrors(cudaDestroyTextureObject(tex)); + } + + constexpr operator cudaTextureObject_t() const { + return tex; + } +}; diff --git a/src/qfvm_gpu/cuda_utils/helper_cuda.h b/src/qfvm_gpu/cuda_utils/helper_cuda.h new file mode 100644 index 0000000..516dd57 --- /dev/null +++ b/src/qfvm_gpu/cuda_utils/helper_cuda.h @@ -0,0 +1,953 @@ +/** + * Copyright 1993-2017 NVIDIA Corporation. All rights reserved. + * + * Please refer to the NVIDIA end user license agreement (EULA) associated + * with this source code for terms and conditions that govern your use of + * this software. Any use, reproduction, disclosure, or distribution of + * this software and related documentation outside the terms of the EULA + * is strictly prohibited. + * + */ + +//////////////////////////////////////////////////////////////////////////////// +// These are CUDA Helper functions for initialization and error checking + +#ifndef COMMON_HELPER_CUDA_H_ +#define COMMON_HELPER_CUDA_H_ + +#pragma once + +#include +#include +#include +#include + +#include "helper_string.h" + +#ifndef EXIT_WAIVED +#define EXIT_WAIVED 2 +#endif + +// Note, it is required that your SDK sample to include the proper header +// files, please refer the CUDA examples for examples of the needed CUDA +// headers, which may change depending on which CUDA functions are used. + +// CUDA Runtime error messages +#ifdef __DRIVER_TYPES_H__ +static const char *_cudaGetErrorEnum(cudaError_t error) { + return cudaGetErrorName(error); +} +#endif + +#ifdef CUDA_DRIVER_API +// CUDA Driver API errors +static const char *_cudaGetErrorEnum(CUresult error) { + static char unknown[] = ""; + const char *ret = NULL; + cuGetErrorName(error, &ret); + return ret ? ret : unknown; +} +#endif + +#ifdef CUBLAS_API_H_ +// cuBLAS API errors +static const char *_cudaGetErrorEnum(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"; + + case CUBLAS_STATUS_NOT_SUPPORTED: + return "CUBLAS_STATUS_NOT_SUPPORTED"; + + case CUBLAS_STATUS_LICENSE_ERROR: + return "CUBLAS_STATUS_LICENSE_ERROR"; + } + + return ""; +} +#endif + +#ifdef _CUFFT_H_ +// cuFFT API errors +static const char *_cudaGetErrorEnum(cufftResult error) { + switch (error) { + case CUFFT_SUCCESS: + return "CUFFT_SUCCESS"; + + case CUFFT_INVALID_PLAN: + return "CUFFT_INVALID_PLAN"; + + case CUFFT_ALLOC_FAILED: + return "CUFFT_ALLOC_FAILED"; + + case CUFFT_INVALID_TYPE: + return "CUFFT_INVALID_TYPE"; + + case CUFFT_INVALID_VALUE: + return "CUFFT_INVALID_VALUE"; + + case CUFFT_INTERNAL_ERROR: + return "CUFFT_INTERNAL_ERROR"; + + case CUFFT_EXEC_FAILED: + return "CUFFT_EXEC_FAILED"; + + case CUFFT_SETUP_FAILED: + return "CUFFT_SETUP_FAILED"; + + case CUFFT_INVALID_SIZE: + return "CUFFT_INVALID_SIZE"; + + case CUFFT_UNALIGNED_DATA: + return "CUFFT_UNALIGNED_DATA"; + + case CUFFT_INCOMPLETE_PARAMETER_LIST: + return "CUFFT_INCOMPLETE_PARAMETER_LIST"; + + case CUFFT_INVALID_DEVICE: + return "CUFFT_INVALID_DEVICE"; + + case CUFFT_PARSE_ERROR: + return "CUFFT_PARSE_ERROR"; + + case CUFFT_NO_WORKSPACE: + return "CUFFT_NO_WORKSPACE"; + + case CUFFT_NOT_IMPLEMENTED: + return "CUFFT_NOT_IMPLEMENTED"; + + case CUFFT_LICENSE_ERROR: + return "CUFFT_LICENSE_ERROR"; + + case CUFFT_NOT_SUPPORTED: + return "CUFFT_NOT_SUPPORTED"; + } + + return ""; +} +#endif + +#ifdef CUSPARSEAPI +// cuSPARSE API errors +static const char *_cudaGetErrorEnum(cusparseStatus_t error) { + switch (error) { + case CUSPARSE_STATUS_SUCCESS: + return "CUSPARSE_STATUS_SUCCESS"; + + case CUSPARSE_STATUS_NOT_INITIALIZED: + return "CUSPARSE_STATUS_NOT_INITIALIZED"; + + case CUSPARSE_STATUS_ALLOC_FAILED: + return "CUSPARSE_STATUS_ALLOC_FAILED"; + + case CUSPARSE_STATUS_INVALID_VALUE: + return "CUSPARSE_STATUS_INVALID_VALUE"; + + case CUSPARSE_STATUS_ARCH_MISMATCH: + return "CUSPARSE_STATUS_ARCH_MISMATCH"; + + case CUSPARSE_STATUS_MAPPING_ERROR: + return "CUSPARSE_STATUS_MAPPING_ERROR"; + + case CUSPARSE_STATUS_EXECUTION_FAILED: + return "CUSPARSE_STATUS_EXECUTION_FAILED"; + + case CUSPARSE_STATUS_INTERNAL_ERROR: + return "CUSPARSE_STATUS_INTERNAL_ERROR"; + + case CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED: + return "CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED"; + } + + return ""; +} +#endif + +#ifdef CUSOLVER_COMMON_H_ +// cuSOLVER API errors +static const char *_cudaGetErrorEnum(cusolverStatus_t error) { + switch (error) { + case CUSOLVER_STATUS_SUCCESS: + return "CUSOLVER_STATUS_SUCCESS"; + case CUSOLVER_STATUS_NOT_INITIALIZED: + return "CUSOLVER_STATUS_NOT_INITIALIZED"; + case CUSOLVER_STATUS_ALLOC_FAILED: + return "CUSOLVER_STATUS_ALLOC_FAILED"; + case CUSOLVER_STATUS_INVALID_VALUE: + return "CUSOLVER_STATUS_INVALID_VALUE"; + case CUSOLVER_STATUS_ARCH_MISMATCH: + return "CUSOLVER_STATUS_ARCH_MISMATCH"; + case CUSOLVER_STATUS_MAPPING_ERROR: + return "CUSOLVER_STATUS_MAPPING_ERROR"; + case CUSOLVER_STATUS_EXECUTION_FAILED: + return "CUSOLVER_STATUS_EXECUTION_FAILED"; + case CUSOLVER_STATUS_INTERNAL_ERROR: + return "CUSOLVER_STATUS_INTERNAL_ERROR"; + case CUSOLVER_STATUS_MATRIX_TYPE_NOT_SUPPORTED: + return "CUSOLVER_STATUS_MATRIX_TYPE_NOT_SUPPORTED"; + case CUSOLVER_STATUS_NOT_SUPPORTED: + return "CUSOLVER_STATUS_NOT_SUPPORTED "; + case CUSOLVER_STATUS_ZERO_PIVOT: + return "CUSOLVER_STATUS_ZERO_PIVOT"; + case CUSOLVER_STATUS_INVALID_LICENSE: + return "CUSOLVER_STATUS_INVALID_LICENSE"; + } + + return ""; +} +#endif + +#ifdef CURAND_H_ +// cuRAND API errors +static const char *_cudaGetErrorEnum(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 ""; +} +#endif + +#ifdef NVJPEGAPI +// nvJPEG API errors +static const char *_cudaGetErrorEnum(nvjpegStatus_t error) { + switch (error) { + case NVJPEG_STATUS_SUCCESS: + return "NVJPEG_STATUS_SUCCESS"; + + case NVJPEG_STATUS_NOT_INITIALIZED: + return "NVJPEG_STATUS_NOT_INITIALIZED"; + + case NVJPEG_STATUS_INVALID_PARAMETER: + return "NVJPEG_STATUS_INVALID_PARAMETER"; + + case NVJPEG_STATUS_BAD_JPEG: + return "NVJPEG_STATUS_BAD_JPEG"; + + case NVJPEG_STATUS_JPEG_NOT_SUPPORTED: + return "NVJPEG_STATUS_JPEG_NOT_SUPPORTED"; + + case NVJPEG_STATUS_ALLOCATOR_FAILURE: + return "NVJPEG_STATUS_ALLOCATOR_FAILURE"; + + case NVJPEG_STATUS_EXECUTION_FAILED: + return "NVJPEG_STATUS_EXECUTION_FAILED"; + + case NVJPEG_STATUS_ARCH_MISMATCH: + return "NVJPEG_STATUS_ARCH_MISMATCH"; + + case NVJPEG_STATUS_INTERNAL_ERROR: + return "NVJPEG_STATUS_INTERNAL_ERROR"; + } + + return ""; +} +#endif + +#ifdef NV_NPPIDEFS_H +// NPP API errors +static const char *_cudaGetErrorEnum(NppStatus error) { + switch (error) { + case NPP_NOT_SUPPORTED_MODE_ERROR: + return "NPP_NOT_SUPPORTED_MODE_ERROR"; + + case NPP_ROUND_MODE_NOT_SUPPORTED_ERROR: + return "NPP_ROUND_MODE_NOT_SUPPORTED_ERROR"; + + case NPP_RESIZE_NO_OPERATION_ERROR: + return "NPP_RESIZE_NO_OPERATION_ERROR"; + + case NPP_NOT_SUFFICIENT_COMPUTE_CAPABILITY: + return "NPP_NOT_SUFFICIENT_COMPUTE_CAPABILITY"; + +#if ((NPP_VERSION_MAJOR << 12) + (NPP_VERSION_MINOR << 4)) <= 0x5000 + + case NPP_BAD_ARG_ERROR: + return "NPP_BAD_ARGUMENT_ERROR"; + + case NPP_COEFF_ERROR: + return "NPP_COEFFICIENT_ERROR"; + + case NPP_RECT_ERROR: + return "NPP_RECTANGLE_ERROR"; + + case NPP_QUAD_ERROR: + return "NPP_QUADRANGLE_ERROR"; + + case NPP_MEM_ALLOC_ERR: + return "NPP_MEMORY_ALLOCATION_ERROR"; + + case NPP_HISTO_NUMBER_OF_LEVELS_ERROR: + return "NPP_HISTOGRAM_NUMBER_OF_LEVELS_ERROR"; + + case NPP_INVALID_INPUT: + return "NPP_INVALID_INPUT"; + + case NPP_POINTER_ERROR: + return "NPP_POINTER_ERROR"; + + case NPP_WARNING: + return "NPP_WARNING"; + + case NPP_ODD_ROI_WARNING: + return "NPP_ODD_ROI_WARNING"; +#else + + // These are for CUDA 5.5 or higher + case NPP_BAD_ARGUMENT_ERROR: + return "NPP_BAD_ARGUMENT_ERROR"; + + case NPP_COEFFICIENT_ERROR: + return "NPP_COEFFICIENT_ERROR"; + + case NPP_RECTANGLE_ERROR: + return "NPP_RECTANGLE_ERROR"; + + case NPP_QUADRANGLE_ERROR: + return "NPP_QUADRANGLE_ERROR"; + + case NPP_MEMORY_ALLOCATION_ERR: + return "NPP_MEMORY_ALLOCATION_ERROR"; + + case NPP_HISTOGRAM_NUMBER_OF_LEVELS_ERROR: + return "NPP_HISTOGRAM_NUMBER_OF_LEVELS_ERROR"; + + case NPP_INVALID_HOST_POINTER_ERROR: + return "NPP_INVALID_HOST_POINTER_ERROR"; + + case NPP_INVALID_DEVICE_POINTER_ERROR: + return "NPP_INVALID_DEVICE_POINTER_ERROR"; +#endif + + case NPP_LUT_NUMBER_OF_LEVELS_ERROR: + return "NPP_LUT_NUMBER_OF_LEVELS_ERROR"; + + case NPP_TEXTURE_BIND_ERROR: + return "NPP_TEXTURE_BIND_ERROR"; + + case NPP_WRONG_INTERSECTION_ROI_ERROR: + return "NPP_WRONG_INTERSECTION_ROI_ERROR"; + + case NPP_NOT_EVEN_STEP_ERROR: + return "NPP_NOT_EVEN_STEP_ERROR"; + + case NPP_INTERPOLATION_ERROR: + return "NPP_INTERPOLATION_ERROR"; + + case NPP_RESIZE_FACTOR_ERROR: + return "NPP_RESIZE_FACTOR_ERROR"; + + case NPP_HAAR_CLASSIFIER_PIXEL_MATCH_ERROR: + return "NPP_HAAR_CLASSIFIER_PIXEL_MATCH_ERROR"; + +#if ((NPP_VERSION_MAJOR << 12) + (NPP_VERSION_MINOR << 4)) <= 0x5000 + + case NPP_MEMFREE_ERR: + return "NPP_MEMFREE_ERR"; + + case NPP_MEMSET_ERR: + return "NPP_MEMSET_ERR"; + + case NPP_MEMCPY_ERR: + return "NPP_MEMCPY_ERROR"; + + case NPP_MIRROR_FLIP_ERR: + return "NPP_MIRROR_FLIP_ERR"; +#else + + case NPP_MEMFREE_ERROR: + return "NPP_MEMFREE_ERROR"; + + case NPP_MEMSET_ERROR: + return "NPP_MEMSET_ERROR"; + + case NPP_MEMCPY_ERROR: + return "NPP_MEMCPY_ERROR"; + + case NPP_MIRROR_FLIP_ERROR: + return "NPP_MIRROR_FLIP_ERROR"; +#endif + + case NPP_ALIGNMENT_ERROR: + return "NPP_ALIGNMENT_ERROR"; + + case NPP_STEP_ERROR: + return "NPP_STEP_ERROR"; + + case NPP_SIZE_ERROR: + return "NPP_SIZE_ERROR"; + + case NPP_NULL_POINTER_ERROR: + return "NPP_NULL_POINTER_ERROR"; + + case NPP_CUDA_KERNEL_EXECUTION_ERROR: + return "NPP_CUDA_KERNEL_EXECUTION_ERROR"; + + case NPP_NOT_IMPLEMENTED_ERROR: + return "NPP_NOT_IMPLEMENTED_ERROR"; + + case NPP_ERROR: + return "NPP_ERROR"; + + case NPP_SUCCESS: + return "NPP_SUCCESS"; + + case NPP_WRONG_INTERSECTION_QUAD_WARNING: + return "NPP_WRONG_INTERSECTION_QUAD_WARNING"; + + case NPP_MISALIGNED_DST_ROI_WARNING: + return "NPP_MISALIGNED_DST_ROI_WARNING"; + + case NPP_AFFINE_QUAD_INCORRECT_WARNING: + return "NPP_AFFINE_QUAD_INCORRECT_WARNING"; + + case NPP_DOUBLE_SIZE_WARNING: + return "NPP_DOUBLE_SIZE_WARNING"; + + case NPP_WRONG_INTERSECTION_ROI_WARNING: + return "NPP_WRONG_INTERSECTION_ROI_WARNING"; + +#if ((NPP_VERSION_MAJOR << 12) + (NPP_VERSION_MINOR << 4)) >= 0x6000 + /* These are 6.0 or higher */ + case NPP_LUT_PALETTE_BITSIZE_ERROR: + return "NPP_LUT_PALETTE_BITSIZE_ERROR"; + + case NPP_ZC_MODE_NOT_SUPPORTED_ERROR: + return "NPP_ZC_MODE_NOT_SUPPORTED_ERROR"; + + case NPP_QUALITY_INDEX_ERROR: + return "NPP_QUALITY_INDEX_ERROR"; + + case NPP_CHANNEL_ORDER_ERROR: + return "NPP_CHANNEL_ORDER_ERROR"; + + case NPP_ZERO_MASK_VALUE_ERROR: + return "NPP_ZERO_MASK_VALUE_ERROR"; + + case NPP_NUMBER_OF_CHANNELS_ERROR: + return "NPP_NUMBER_OF_CHANNELS_ERROR"; + + case NPP_COI_ERROR: + return "NPP_COI_ERROR"; + + case NPP_DIVISOR_ERROR: + return "NPP_DIVISOR_ERROR"; + + case NPP_CHANNEL_ERROR: + return "NPP_CHANNEL_ERROR"; + + case NPP_STRIDE_ERROR: + return "NPP_STRIDE_ERROR"; + + case NPP_ANCHOR_ERROR: + return "NPP_ANCHOR_ERROR"; + + case NPP_MASK_SIZE_ERROR: + return "NPP_MASK_SIZE_ERROR"; + + case NPP_MOMENT_00_ZERO_ERROR: + return "NPP_MOMENT_00_ZERO_ERROR"; + + case NPP_THRESHOLD_NEGATIVE_LEVEL_ERROR: + return "NPP_THRESHOLD_NEGATIVE_LEVEL_ERROR"; + + case NPP_THRESHOLD_ERROR: + return "NPP_THRESHOLD_ERROR"; + + case NPP_CONTEXT_MATCH_ERROR: + return "NPP_CONTEXT_MATCH_ERROR"; + + case NPP_FFT_FLAG_ERROR: + return "NPP_FFT_FLAG_ERROR"; + + case NPP_FFT_ORDER_ERROR: + return "NPP_FFT_ORDER_ERROR"; + + case NPP_SCALE_RANGE_ERROR: + return "NPP_SCALE_RANGE_ERROR"; + + case NPP_DATA_TYPE_ERROR: + return "NPP_DATA_TYPE_ERROR"; + + case NPP_OUT_OFF_RANGE_ERROR: + return "NPP_OUT_OFF_RANGE_ERROR"; + + case NPP_DIVIDE_BY_ZERO_ERROR: + return "NPP_DIVIDE_BY_ZERO_ERROR"; + + case NPP_RANGE_ERROR: + return "NPP_RANGE_ERROR"; + + case NPP_NO_MEMORY_ERROR: + return "NPP_NO_MEMORY_ERROR"; + + case NPP_ERROR_RESERVED: + return "NPP_ERROR_RESERVED"; + + case NPP_NO_OPERATION_WARNING: + return "NPP_NO_OPERATION_WARNING"; + + case NPP_DIVIDE_BY_ZERO_WARNING: + return "NPP_DIVIDE_BY_ZERO_WARNING"; +#endif + +#if ((NPP_VERSION_MAJOR << 12) + (NPP_VERSION_MINOR << 4)) >= 0x7000 + /* These are 7.0 or higher */ + case NPP_OVERFLOW_ERROR: + return "NPP_OVERFLOW_ERROR"; + + case NPP_CORRUPTED_DATA_ERROR: + return "NPP_CORRUPTED_DATA_ERROR"; +#endif + } + + return ""; +} +#endif + +template +void check(T result, char const *const func, const char *const file, + int const line) { + if (result) { + fprintf(stderr, "CUDA error at %s:%d code=%d(%s) \"%s\" \n", file, line, + static_cast(result), _cudaGetErrorEnum(result), func); + exit(EXIT_FAILURE); + } +} + +#ifdef __DRIVER_TYPES_H__ +// This will output the proper CUDA error strings in the event +// that a CUDA host call returns an error +#define checkCudaErrors(val) check((val), #val, __FILE__, __LINE__) + +// This will output the proper error string when calling cudaGetLastError +#define getLastCudaError(msg) __getLastCudaError(msg, __FILE__, __LINE__) + +inline void __getLastCudaError(const char *errorMessage, const char *file, + const int line) { + cudaError_t err = cudaGetLastError(); + + if (cudaSuccess != err) { + fprintf(stderr, + "%s(%i) : getLastCudaError() CUDA error :" + " %s : (%d) %s.\n", + file, line, errorMessage, static_cast(err), + cudaGetErrorString(err)); + exit(EXIT_FAILURE); + } +} + +// This will only print the proper error string when calling cudaGetLastError +// but not exit program incase error detected. +#define printLastCudaError(msg) __printLastCudaError(msg, __FILE__, __LINE__) + +inline void __printLastCudaError(const char *errorMessage, const char *file, + const int line) { + cudaError_t err = cudaGetLastError(); + + if (cudaSuccess != err) { + fprintf(stderr, + "%s(%i) : getLastCudaError() CUDA error :" + " %s : (%d) %s.\n", + file, line, errorMessage, static_cast(err), + cudaGetErrorString(err)); + } +} +#endif + +#ifndef MAX +#define MAX(a, b) (a > b ? a : b) +#endif + +// Float To Int conversion +inline int ftoi(float value) { + return (value >= 0 ? static_cast(value + 0.5) + : static_cast(value - 0.5)); +} + +// Beginning of GPU Architecture definitions +inline int _ConvertSMVer2Cores(int major, int minor) { + // Defines for GPU Architecture types (using the SM version to determine + // the # of cores per SM + typedef struct { + int SM; // 0xMm (hexidecimal notation), M = SM Major version, + // and m = SM minor version + int Cores; + } sSMtoCores; + + sSMtoCores nGpuArchCoresPerSM[] = { + {0x30, 192}, + {0x32, 192}, + {0x35, 192}, + {0x37, 192}, + {0x50, 128}, + {0x52, 128}, + {0x53, 128}, + {0x60, 64}, + {0x61, 128}, + {0x62, 128}, + {0x70, 64}, + {0x72, 64}, + {0x75, 64}, + {0x80, 64}, + {0x86, 128}, + {0x87, 128}, + {-1, -1}}; + + int index = 0; + + while (nGpuArchCoresPerSM[index].SM != -1) { + if (nGpuArchCoresPerSM[index].SM == ((major << 4) + minor)) { + return nGpuArchCoresPerSM[index].Cores; + } + + index++; + } + + // If we don't find the values, we default use the previous one + // to run properly + printf( + "MapSMtoCores for SM %d.%d is undefined." + " Default to use %d Cores/SM\n", + major, minor, nGpuArchCoresPerSM[index - 1].Cores); + return nGpuArchCoresPerSM[index - 1].Cores; +} + +inline const char* _ConvertSMVer2ArchName(int major, int minor) { + // Defines for GPU Architecture types (using the SM version to determine + // the GPU Arch name) + typedef struct { + int SM; // 0xMm (hexidecimal notation), M = SM Major version, + // and m = SM minor version + const char* name; + } sSMtoArchName; + + sSMtoArchName nGpuArchNameSM[] = { + {0x30, "Kepler"}, + {0x32, "Kepler"}, + {0x35, "Kepler"}, + {0x37, "Kepler"}, + {0x50, "Maxwell"}, + {0x52, "Maxwell"}, + {0x53, "Maxwell"}, + {0x60, "Pascal"}, + {0x61, "Pascal"}, + {0x62, "Pascal"}, + {0x70, "Volta"}, + {0x72, "Xavier"}, + {0x75, "Turing"}, + {0x80, "Ampere"}, + {0x86, "Ampere"}, + {0x87, "Ampere"}, + {-1, "Graphics Device"}}; + + int index = 0; + + while (nGpuArchNameSM[index].SM != -1) { + if (nGpuArchNameSM[index].SM == ((major << 4) + minor)) { + return nGpuArchNameSM[index].name; + } + + index++; + } + + // If we don't find the values, we default use the previous one + // to run properly + printf( + "MapSMtoArchName for SM %d.%d is undefined." + " Default to use %s\n", + major, minor, nGpuArchNameSM[index - 1].name); + return nGpuArchNameSM[index - 1].name; +} + // end of GPU Architecture definitions + +#ifdef __CUDA_RUNTIME_H__ +// General GPU Device CUDA Initialization +inline int gpuDeviceInit(int devID) { + int device_count; + checkCudaErrors(cudaGetDeviceCount(&device_count)); + + if (device_count == 0) { + fprintf(stderr, + "gpuDeviceInit() CUDA error: " + "no devices supporting CUDA.\n"); + exit(EXIT_FAILURE); + } + + if (devID < 0) { + devID = 0; + } + + if (devID > device_count - 1) { + fprintf(stderr, "\n"); + fprintf(stderr, ">> %d CUDA capable GPU device(s) detected. <<\n", + device_count); + fprintf(stderr, + ">> gpuDeviceInit (-device=%d) is not a valid" + " GPU device. <<\n", + devID); + fprintf(stderr, "\n"); + return -devID; + } + + int computeMode = -1, major = 0, minor = 0; + checkCudaErrors(cudaDeviceGetAttribute(&computeMode, cudaDevAttrComputeMode, devID)); + checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, devID)); + checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, devID)); + if (computeMode == cudaComputeModeProhibited) { + fprintf(stderr, + "Error: device is running in , no threads can use cudaSetDevice().\n"); + return -1; + } + + if (major < 1) { + fprintf(stderr, "gpuDeviceInit(): GPU device does not support CUDA.\n"); + exit(EXIT_FAILURE); + } + + checkCudaErrors(cudaSetDevice(devID)); + printf("gpuDeviceInit() CUDA Device [%d]: \"%s\n", devID, _ConvertSMVer2ArchName(major, minor)); + + return devID; +} + +// This function returns the best GPU (with maximum GFLOPS) +inline int gpuGetMaxGflopsDeviceId() { + int current_device = 0, sm_per_multiproc = 0; + int max_perf_device = 0; + int device_count = 0; + int devices_prohibited = 0; + + uint64_t max_compute_perf = 0; + checkCudaErrors(cudaGetDeviceCount(&device_count)); + + if (device_count == 0) { + fprintf(stderr, + "gpuGetMaxGflopsDeviceId() CUDA error:" + " no devices supporting CUDA.\n"); + exit(EXIT_FAILURE); + } + + // Find the best CUDA capable GPU device + current_device = 0; + + while (current_device < device_count) { + int computeMode = -1, major = 0, minor = 0; + checkCudaErrors(cudaDeviceGetAttribute(&computeMode, cudaDevAttrComputeMode, current_device)); + checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, current_device)); + checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, current_device)); + + // If this GPU is not running on Compute Mode prohibited, + // then we can add it to the list + if (computeMode != cudaComputeModeProhibited) { + if (major == 9999 && minor == 9999) { + sm_per_multiproc = 1; + } else { + sm_per_multiproc = + _ConvertSMVer2Cores(major, minor); + } + int multiProcessorCount = 0, clockRate = 0; + checkCudaErrors(cudaDeviceGetAttribute(&multiProcessorCount, cudaDevAttrMultiProcessorCount, current_device)); + cudaError_t result = cudaDeviceGetAttribute(&clockRate, cudaDevAttrClockRate, current_device); + if (result != cudaSuccess) { + // If cudaDevAttrClockRate attribute is not supported we + // set clockRate as 1, to consider GPU with most SMs and CUDA Cores. + if(result == cudaErrorInvalidValue) { + clockRate = 1; + } + else { + fprintf(stderr, "CUDA error at %s:%d code=%d(%s) \n", __FILE__, __LINE__, + static_cast(result), _cudaGetErrorEnum(result)); + exit(EXIT_FAILURE); + } + } + uint64_t compute_perf = (uint64_t)multiProcessorCount * sm_per_multiproc * clockRate; + + if (compute_perf > max_compute_perf) { + max_compute_perf = compute_perf; + max_perf_device = current_device; + } + } else { + devices_prohibited++; + } + + ++current_device; + } + + if (devices_prohibited == device_count) { + fprintf(stderr, + "gpuGetMaxGflopsDeviceId() CUDA error:" + " all devices have compute mode prohibited.\n"); + exit(EXIT_FAILURE); + } + + return max_perf_device; +} + +// Initialization code to find the best CUDA Device +inline int findCudaDevice(int argc, const char **argv) { + int devID = 0; + + // If the command-line has a device number specified, use it + if (checkCmdLineFlag(argc, argv, "device")) { + devID = getCmdLineArgumentInt(argc, argv, "device="); + + if (devID < 0) { + printf("Invalid command line parameter\n "); + exit(EXIT_FAILURE); + } else { + devID = gpuDeviceInit(devID); + + if (devID < 0) { + printf("exiting...\n"); + exit(EXIT_FAILURE); + } + } + } else { + // Otherwise pick the device with highest Gflops/s + devID = gpuGetMaxGflopsDeviceId(); + checkCudaErrors(cudaSetDevice(devID)); + int major = 0, minor = 0; + checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, devID)); + checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, devID)); + printf("GPU Device %d: \"%s\" with compute capability %d.%d\n\n", + devID, _ConvertSMVer2ArchName(major, minor), major, minor); + + } + + return devID; +} + +inline int findIntegratedGPU() { + int current_device = 0; + int device_count = 0; + int devices_prohibited = 0; + + checkCudaErrors(cudaGetDeviceCount(&device_count)); + + if (device_count == 0) { + fprintf(stderr, "CUDA error: no devices supporting CUDA.\n"); + exit(EXIT_FAILURE); + } + + // Find the integrated GPU which is compute capable + while (current_device < device_count) { + int computeMode = -1, integrated = -1; + checkCudaErrors(cudaDeviceGetAttribute(&computeMode, cudaDevAttrComputeMode, current_device)); + checkCudaErrors(cudaDeviceGetAttribute(&integrated, cudaDevAttrIntegrated, current_device)); + // If GPU is integrated and is not running on Compute Mode prohibited, + // then cuda can map to GLES resource + if (integrated && (computeMode != cudaComputeModeProhibited)) { + checkCudaErrors(cudaSetDevice(current_device)); + + int major = 0, minor = 0; + checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, current_device)); + checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, current_device)); + printf("GPU Device %d: \"%s\" with compute capability %d.%d\n\n", + current_device, _ConvertSMVer2ArchName(major, minor), major, minor); + + return current_device; + } else { + devices_prohibited++; + } + + current_device++; + } + + if (devices_prohibited == device_count) { + fprintf(stderr, + "CUDA error:" + " No GLES-CUDA Interop capable GPU found.\n"); + exit(EXIT_FAILURE); + } + + return -1; +} + +// General check for CUDA GPU SM Capabilities +inline bool checkCudaCapabilities(int major_version, int minor_version) { + int dev; + int major = 0, minor = 0; + + checkCudaErrors(cudaGetDevice(&dev)); + checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, dev)); + checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, dev)); + + if ((major > major_version) || + (major == major_version && + minor >= minor_version)) { + printf(" Device %d: <%16s >, Compute SM %d.%d detected\n", dev, + _ConvertSMVer2ArchName(major, minor), major, minor); + return true; + } else { + printf( + " No GPU device was found that can support " + "CUDA compute capability %d.%d.\n", + major_version, minor_version); + return false; + } +} +#endif + + // end of CUDA Helper Functions + +#endif // COMMON_HELPER_CUDA_H_ diff --git a/src/qfvm_gpu/cuda_utils/helper_custatevec.hpp b/src/qfvm_gpu/cuda_utils/helper_custatevec.hpp new file mode 100644 index 0000000..59fdbc3 --- /dev/null +++ b/src/qfvm_gpu/cuda_utils/helper_custatevec.hpp @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2021-2022, NVIDIA CORPORATION & AFFILIATES. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#define HANDLE_ERROR(x) \ +{ const auto err = x; \ + if (err != CUSTATEVEC_STATUS_SUCCESS ) { \ + printf("Error: %s in line %d\n", \ + custatevecGetErrorString(err), __LINE__); return err; } \ +}; + +#define HANDLE_CUDA_ERROR(x) \ +{ const auto err = x; \ + if (err != cudaSuccess ) { \ + printf("Error: %s in line %d\n", \ + cudaGetErrorString(err), __LINE__); return err; } \ +}; + +bool almost_equal(cuDoubleComplex x, cuDoubleComplex y) { + const double eps = 1.0e-5; + const cuDoubleComplex diff = cuCsub(x, y); + return (cuCabs(diff) < eps); +} + +bool almost_equal(double x, double y) { + const double eps = 1.0e-5; + const double diff = x - y; + return (abs(diff) < eps); +} diff --git a/src/qfvm_gpu/cuda_utils/helper_string.h b/src/qfvm_gpu/cuda_utils/helper_string.h new file mode 100644 index 0000000..77864b8 --- /dev/null +++ b/src/qfvm_gpu/cuda_utils/helper_string.h @@ -0,0 +1,683 @@ +/** + * Copyright 1993-2013 NVIDIA Corporation. All rights reserved. + * + * Please refer to the NVIDIA end user license agreement (EULA) associated + * with this source code for terms and conditions that govern your use of + * this software. Any use, reproduction, disclosure, or distribution of + * this software and related documentation outside the terms of the EULA + * is strictly prohibited. + * + */ + +// These are helper functions for the SDK samples (string parsing, timers, etc) +#ifndef COMMON_HELPER_STRING_H_ +#define COMMON_HELPER_STRING_H_ + +#include +#include +#include +#include + +#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) +#ifndef _CRT_SECURE_NO_DEPRECATE +#define _CRT_SECURE_NO_DEPRECATE +#endif +#ifndef STRCASECMP +#define STRCASECMP _stricmp +#endif +#ifndef STRNCASECMP +#define STRNCASECMP _strnicmp +#endif +#ifndef STRCPY +#define STRCPY(sFilePath, nLength, sPath) strcpy_s(sFilePath, nLength, sPath) +#endif + +#ifndef FOPEN +#define FOPEN(fHandle, filename, mode) fopen_s(&fHandle, filename, mode) +#endif +#ifndef FOPEN_FAIL +#define FOPEN_FAIL(result) (result != 0) +#endif +#ifndef SSCANF +#define SSCANF sscanf_s +#endif +#ifndef SPRINTF +#define SPRINTF sprintf_s +#endif +#else // Linux Includes +#include +#include + +#ifndef STRCASECMP +#define STRCASECMP strcasecmp +#endif +#ifndef STRNCASECMP +#define STRNCASECMP strncasecmp +#endif +#ifndef STRCPY +#define STRCPY(sFilePath, nLength, sPath) strcpy(sFilePath, sPath) +#endif + +#ifndef FOPEN +#define FOPEN(fHandle, filename, mode) (fHandle = fopen(filename, mode)) +#endif +#ifndef FOPEN_FAIL +#define FOPEN_FAIL(result) (result == NULL) +#endif +#ifndef SSCANF +#define SSCANF sscanf +#endif +#ifndef SPRINTF +#define SPRINTF sprintf +#endif +#endif + +#ifndef EXIT_WAIVED +#define EXIT_WAIVED 2 +#endif + +// CUDA Utility Helper Functions +inline int stringRemoveDelimiter(char delimiter, const char *string) { + int string_start = 0; + + while (string[string_start] == delimiter) { + string_start++; + } + + if (string_start >= static_cast(strlen(string) - 1)) { + return 0; + } + + return string_start; +} + +inline int getFileExtension(char *filename, char **extension) { + int string_length = static_cast(strlen(filename)); + + while (filename[string_length--] != '.') { + if (string_length == 0) break; + } + + if (string_length > 0) string_length += 2; + + if (string_length == 0) + *extension = NULL; + else + *extension = &filename[string_length]; + + return string_length; +} + +inline bool checkCmdLineFlag(const int argc, const char **argv, + const char *string_ref) { + bool bFound = false; + + if (argc >= 1) { + for (int i = 1; i < argc; i++) { + int string_start = stringRemoveDelimiter('-', argv[i]); + const char *string_argv = &argv[i][string_start]; + + const char *equal_pos = strchr(string_argv, '='); + int argv_length = static_cast( + equal_pos == 0 ? strlen(string_argv) : equal_pos - string_argv); + + int length = static_cast(strlen(string_ref)); + + if (length == argv_length && + !STRNCASECMP(string_argv, string_ref, length)) { + bFound = true; + continue; + } + } + } + + return bFound; +} + +// This function wraps the CUDA Driver API into a template function +template +inline bool getCmdLineArgumentValue(const int argc, const char **argv, + const char *string_ref, T *value) { + bool bFound = false; + + if (argc >= 1) { + for (int i = 1; i < argc; i++) { + int string_start = stringRemoveDelimiter('-', argv[i]); + const char *string_argv = &argv[i][string_start]; + int length = static_cast(strlen(string_ref)); + + if (!STRNCASECMP(string_argv, string_ref, length)) { + if (length + 1 <= static_cast(strlen(string_argv))) { + int auto_inc = (string_argv[length] == '=') ? 1 : 0; + *value = (T)atoi(&string_argv[length + auto_inc]); + } + + bFound = true; + i = argc; + } + } + } + + return bFound; +} + +inline int getCmdLineArgumentInt(const int argc, const char **argv, + const char *string_ref) { + bool bFound = false; + int value = -1; + + if (argc >= 1) { + for (int i = 1; i < argc; i++) { + int string_start = stringRemoveDelimiter('-', argv[i]); + const char *string_argv = &argv[i][string_start]; + int length = static_cast(strlen(string_ref)); + + if (!STRNCASECMP(string_argv, string_ref, length)) { + if (length + 1 <= static_cast(strlen(string_argv))) { + int auto_inc = (string_argv[length] == '=') ? 1 : 0; + value = atoi(&string_argv[length + auto_inc]); + } else { + value = 0; + } + + bFound = true; + continue; + } + } + } + + if (bFound) { + return value; + } else { + return 0; + } +} + +inline float getCmdLineArgumentFloat(const int argc, const char **argv, + const char *string_ref) { + bool bFound = false; + float value = -1; + + if (argc >= 1) { + for (int i = 1; i < argc; i++) { + int string_start = stringRemoveDelimiter('-', argv[i]); + const char *string_argv = &argv[i][string_start]; + int length = static_cast(strlen(string_ref)); + + if (!STRNCASECMP(string_argv, string_ref, length)) { + if (length + 1 <= static_cast(strlen(string_argv))) { + int auto_inc = (string_argv[length] == '=') ? 1 : 0; + value = static_cast(atof(&string_argv[length + auto_inc])); + } else { + value = 0.f; + } + + bFound = true; + continue; + } + } + } + + if (bFound) { + return value; + } else { + return 0; + } +} + +inline bool getCmdLineArgumentString(const int argc, const char **argv, + const char *string_ref, + char **string_retval) { + bool bFound = false; + + if (argc >= 1) { + for (int i = 1; i < argc; i++) { + int string_start = stringRemoveDelimiter('-', argv[i]); + char *string_argv = const_cast(&argv[i][string_start]); + int length = static_cast(strlen(string_ref)); + + if (!STRNCASECMP(string_argv, string_ref, length)) { + *string_retval = &string_argv[length + 1]; + bFound = true; + continue; + } + } + } + + if (!bFound) { + *string_retval = NULL; + } + + return bFound; +} + +////////////////////////////////////////////////////////////////////////////// +//! Find the path for a file assuming that +//! files are found in the searchPath. +//! +//! @return the path if succeeded, otherwise 0 +//! @param filename name of the file +//! @param executable_path optional absolute path of the executable +////////////////////////////////////////////////////////////////////////////// +inline char *sdkFindFilePath(const char *filename, + const char *executable_path) { + // defines a variable that is replaced with the name of the + // executable + + // Typical relative search paths to locate needed companion files (e.g. sample + // input data, or JIT source files) The origin for the relative search may be + // the .exe file, a .bat file launching an .exe, a browser .exe launching the + // .exe or .bat, etc + const char *searchPath[] = { + "./", // same dir + "./_data_files/", + "./common/", // "/common/" subdir + "./common/data/", // "/common/data/" subdir + "./data/", // "/data/" subdir + "./src/", // "/src/" subdir + "./src//data/", // "/src//data/" subdir + "./inc/", // "/inc/" subdir + "./0_Simple/", // "/0_Simple/" subdir + "./1_Utilities/", // "/1_Utilities/" subdir + "./2_Graphics/", // "/2_Graphics/" subdir + "./3_Imaging/", // "/3_Imaging/" subdir + "./4_Finance/", // "/4_Finance/" subdir + "./5_Simulations/", // "/5_Simulations/" subdir + "./6_Advanced/", // "/6_Advanced/" subdir + "./7_CUDALibraries/", // "/7_CUDALibraries/" subdir + "./8_Android/", // "/8_Android/" subdir + "./samples/", // "/samples/" subdir + + "./0_Simple//data/", // "/0_Simple//data/" + // subdir + "./1_Utilities//data/", // "/1_Utilities//data/" + // subdir + "./2_Graphics//data/", // "/2_Graphics//data/" + // subdir + "./3_Imaging//data/", // "/3_Imaging//data/" + // subdir + "./4_Finance//data/", // "/4_Finance//data/" + // subdir + "./5_Simulations//data/", // "/5_Simulations//data/" + // subdir + "./6_Advanced//data/", // "/6_Advanced//data/" + // subdir + "./7_CUDALibraries//", // "/7_CUDALibraries//" + // subdir + "./7_CUDALibraries//data/", // "/7_CUDALibraries//data/" + // subdir + + "../", // up 1 in tree + "../common/", // up 1 in tree, "/common/" subdir + "../common/data/", // up 1 in tree, "/common/data/" subdir + "../data/", // up 1 in tree, "/data/" subdir + "../src/", // up 1 in tree, "/src/" subdir + "../inc/", // up 1 in tree, "/inc/" subdir + + "../0_Simple//data/", // up 1 in tree, + // "/0_Simple//" + // subdir + "../1_Utilities//data/", // up 1 in tree, + // "/1_Utilities//" + // subdir + "../2_Graphics//data/", // up 1 in tree, + // "/2_Graphics//" + // subdir + "../3_Imaging//data/", // up 1 in tree, + // "/3_Imaging//" + // subdir + "../4_Finance//data/", // up 1 in tree, + // "/4_Finance//" + // subdir + "../5_Simulations//data/", // up 1 in tree, + // "/5_Simulations//" + // subdir + "../6_Advanced//data/", // up 1 in tree, + // "/6_Advanced//" + // subdir + "../7_CUDALibraries//data/", // up 1 in tree, + // "/7_CUDALibraries//" + // subdir + "../8_Android//data/", // up 1 in tree, + // "/8_Android//" + // subdir + "../samples//data/", // up 1 in tree, + // "/samples//" + // subdir + "../../", // up 2 in tree + "../../common/", // up 2 in tree, "/common/" subdir + "../../common/data/", // up 2 in tree, "/common/data/" subdir + "../../data/", // up 2 in tree, "/data/" subdir + "../../src/", // up 2 in tree, "/src/" subdir + "../../inc/", // up 2 in tree, "/inc/" subdir + "../../sandbox//data/", // up 2 in tree, + // "/sandbox//" + // subdir + "../../0_Simple//data/", // up 2 in tree, + // "/0_Simple//" + // subdir + "../../1_Utilities//data/", // up 2 in tree, + // "/1_Utilities//" + // subdir + "../../2_Graphics//data/", // up 2 in tree, + // "/2_Graphics//" + // subdir + "../../3_Imaging//data/", // up 2 in tree, + // "/3_Imaging//" + // subdir + "../../4_Finance//data/", // up 2 in tree, + // "/4_Finance//" + // subdir + "../../5_Simulations//data/", // up 2 in tree, + // "/5_Simulations//" + // subdir + "../../6_Advanced//data/", // up 2 in tree, + // "/6_Advanced//" + // subdir + "../../7_CUDALibraries//data/", // up 2 in tree, + // "/7_CUDALibraries//" + // subdir + "../../8_Android//data/", // up 2 in tree, + // "/8_Android//" + // subdir + "../../samples//data/", // up 2 in tree, + // "/samples//" + // subdir + "../../../", // up 3 in tree + "../../../src//", // up 3 in tree, + // "/src//" subdir + "../../../src//data/", // up 3 in tree, + // "/src//data/" + // subdir + "../../../src//src/", // up 3 in tree, + // "/src//src/" + // subdir + "../../../src//inc/", // up 3 in tree, + // "/src//inc/" + // subdir + "../../../sandbox//", // up 3 in tree, + // "/sandbox//" + // subdir + "../../../sandbox//data/", // up 3 in tree, + // "/sandbox//data/" + // subdir + "../../../sandbox//src/", // up 3 in tree, + // "/sandbox//src/" + // subdir + "../../../sandbox//inc/", // up 3 in tree, + // "/sandbox//inc/" + // subdir + "../../../0_Simple//data/", // up 3 in tree, + // "/0_Simple//" + // subdir + "../../../1_Utilities//data/", // up 3 in tree, + // "/1_Utilities//" + // subdir + "../../../2_Graphics//data/", // up 3 in tree, + // "/2_Graphics//" + // subdir + "../../../3_Imaging//data/", // up 3 in tree, + // "/3_Imaging//" + // subdir + "../../../4_Finance//data/", // up 3 in tree, + // "/4_Finance//" + // subdir + "../../../5_Simulations//data/", // up 3 in tree, + // "/5_Simulations//" + // subdir + "../../../6_Advanced//data/", // up 3 in tree, + // "/6_Advanced//" + // subdir + "../../../7_CUDALibraries//data/", // up 3 in tree, + // "/7_CUDALibraries//" + // subdir + "../../../8_Android//data/", // up 3 in tree, + // "/8_Android//" + // subdir + "../../../0_Simple//", // up 3 in tree, + // "/0_Simple//" + // subdir + "../../../1_Utilities//", // up 3 in tree, + // "/1_Utilities//" + // subdir + "../../../2_Graphics//", // up 3 in tree, + // "/2_Graphics//" + // subdir + "../../../3_Imaging//", // up 3 in tree, + // "/3_Imaging//" + // subdir + "../../../4_Finance//", // up 3 in tree, + // "/4_Finance//" + // subdir + "../../../5_Simulations//", // up 3 in tree, + // "/5_Simulations//" + // subdir + "../../../6_Advanced//", // up 3 in tree, + // "/6_Advanced//" + // subdir + "../../../7_CUDALibraries//", // up 3 in tree, + // "/7_CUDALibraries//" + // subdir + "../../../8_Android//", // up 3 in tree, + // "/8_Android//" + // subdir + "../../../samples//data/", // up 3 in tree, + // "/samples//" + // subdir + "../../../common/", // up 3 in tree, "../../../common/" subdir + "../../../common/data/", // up 3 in tree, "../../../common/data/" subdir + "../../../data/", // up 3 in tree, "../../../data/" subdir + "../../../../", // up 4 in tree + "../../../../src//", // up 4 in tree, + // "/src//" subdir + "../../../../src//data/", // up 4 in tree, + // "/src//data/" + // subdir + "../../../../src//src/", // up 4 in tree, + // "/src//src/" + // subdir + "../../../../src//inc/", // up 4 in tree, + // "/src//inc/" + // subdir + "../../../../sandbox//", // up 4 in tree, + // "/sandbox//" + // subdir + "../../../../sandbox//data/", // up 4 in tree, + // "/sandbox//data/" + // subdir + "../../../../sandbox//src/", // up 4 in tree, + // "/sandbox//src/" + // subdir + "../../../../sandbox//inc/", // up 4 in tree, + // "/sandbox//inc/" + // subdir + "../../../../0_Simple//data/", // up 4 in tree, + // "/0_Simple//" + // subdir + "../../../../1_Utilities//data/", // up 4 in tree, + // "/1_Utilities//" + // subdir + "../../../../2_Graphics//data/", // up 4 in tree, + // "/2_Graphics//" + // subdir + "../../../../3_Imaging//data/", // up 4 in tree, + // "/3_Imaging//" + // subdir + "../../../../4_Finance//data/", // up 4 in tree, + // "/4_Finance//" + // subdir + "../../../../5_Simulations//data/", // up 4 in tree, + // "/5_Simulations//" + // subdir + "../../../../6_Advanced//data/", // up 4 in tree, + // "/6_Advanced//" + // subdir + "../../../../7_CUDALibraries//data/", // up 4 in tree, + // "/7_CUDALibraries//" + // subdir + "../../../../8_Android//data/", // up 4 in tree, + // "/8_Android//" + // subdir + "../../../../0_Simple//", // up 4 in tree, + // "/0_Simple//" + // subdir + "../../../../1_Utilities//", // up 4 in tree, + // "/1_Utilities//" + // subdir + "../../../../2_Graphics//", // up 4 in tree, + // "/2_Graphics//" + // subdir + "../../../../3_Imaging//", // up 4 in tree, + // "/3_Imaging//" + // subdir + "../../../../4_Finance//", // up 4 in tree, + // "/4_Finance//" + // subdir + "../../../../5_Simulations//", // up 4 in tree, + // "/5_Simulations//" + // subdir + "../../../../6_Advanced//", // up 4 in tree, + // "/6_Advanced//" + // subdir + "../../../../7_CUDALibraries//", // up 4 in tree, + // "/7_CUDALibraries//" + // subdir + "../../../../8_Android//", // up 4 in tree, + // "/8_Android//" + // subdir + "../../../../samples//data/", // up 4 in tree, + // "/samples//" + // subdir + "../../../../common/", // up 4 in tree, "../../../common/" subdir + "../../../../common/data/", // up 4 in tree, "../../../common/data/" + // subdir + "../../../../data/", // up 4 in tree, "../../../data/" subdir + "../../../../../", // up 5 in tree + "../../../../../src//", // up 5 in tree, + // "/src//" + // subdir + "../../../../../src//data/", // up 5 in tree, + // "/src//data/" + // subdir + "../../../../../src//src/", // up 5 in tree, + // "/src//src/" + // subdir + "../../../../../src//inc/", // up 5 in tree, + // "/src//inc/" + // subdir + "../../../../../sandbox//", // up 5 in tree, + // "/sandbox//" + // subdir + "../../../../../sandbox//data/", // up 5 in tree, + // "/sandbox//data/" + // subdir + "../../../../../sandbox//src/", // up 5 in tree, + // "/sandbox//src/" + // subdir + "../../../../../sandbox//inc/", // up 5 in tree, + // "/sandbox//inc/" + // subdir + "../../../../../0_Simple//data/", // up 5 in tree, + // "/0_Simple//" + // subdir + "../../../../../1_Utilities//data/", // up 5 in tree, + // "/1_Utilities//" + // subdir + "../../../../../2_Graphics//data/", // up 5 in tree, + // "/2_Graphics//" + // subdir + "../../../../../3_Imaging//data/", // up 5 in tree, + // "/3_Imaging//" + // subdir + "../../../../../4_Finance//data/", // up 5 in tree, + // "/4_Finance//" + // subdir + "../../../../../5_Simulations//data/", // up 5 in tree, + // "/5_Simulations//" + // subdir + "../../../../../6_Advanced//data/", // up 5 in tree, + // "/6_Advanced//" + // subdir + "../../../../../7_CUDALibraries//data/", // up 5 in + // tree, + // "/7_CUDALibraries//" + // subdir + "../../../../../8_Android//data/", // up 5 in tree, + // "/8_Android//" + // subdir + "../../../../../samples//data/", // up 5 in tree, + // "/samples//" + // subdir + "../../../../../common/", // up 5 in tree, "../../../common/" subdir + "../../../../../common/data/", // up 5 in tree, "../../../common/data/" + // subdir + }; + + // Extract the executable name + std::string executable_name; + + if (executable_path != 0) { + executable_name = std::string(executable_path); + +#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) + // Windows path delimiter + size_t delimiter_pos = executable_name.find_last_of('\\'); + executable_name.erase(0, delimiter_pos + 1); + + if (executable_name.rfind(".exe") != std::string::npos) { + // we strip .exe, only if the .exe is found + executable_name.resize(executable_name.size() - 4); + } + +#else + // Linux & OSX path delimiter + size_t delimiter_pos = executable_name.find_last_of('/'); + executable_name.erase(0, delimiter_pos + 1); +#endif + } + + // Loop over all search paths and return the first hit + for (unsigned int i = 0; i < sizeof(searchPath) / sizeof(char *); ++i) { + std::string path(searchPath[i]); + size_t executable_name_pos = path.find(""); + + // If there is executable_name variable in the searchPath + // replace it with the value + if (executable_name_pos != std::string::npos) { + if (executable_path != 0) { + path.replace(executable_name_pos, strlen(""), + executable_name); + } else { + // Skip this path entry if no executable argument is given + continue; + } + } + +#ifdef _DEBUG + printf("sdkFindFilePath <%s> in %s\n", filename, path.c_str()); +#endif + + // Test if the file exists + path.append(filename); + FILE *fp; + FOPEN(fp, path.c_str(), "rb"); + + if (fp != NULL) { + fclose(fp); + // File found + // returning an allocated array here for backwards compatibility reasons + char *file_path = reinterpret_cast(malloc(path.length() + 1)); + STRCPY(file_path, path.length() + 1, path.c_str()); + return file_path; + } + + if (fp) { + fclose(fp); + } + } + + // File not found + return 0; +} + +#endif // COMMON_HELPER_STRING_H_ diff --git a/src/qfvm_gpu/cuda_utils/ticktock.h b/src/qfvm_gpu/cuda_utils/ticktock.h new file mode 100644 index 0000000..1adb8a9 --- /dev/null +++ b/src/qfvm_gpu/cuda_utils/ticktock.h @@ -0,0 +1,9 @@ +#pragma once + +//#include +//#define TICK(x) auto bench_##x = std::chrono::steady_clock::now(); +//#define TOCK(x) std::cout << #x ": " << std::chrono::duration_cast>(std::chrono::steady_clock::now() - bench_##x).count() << "s" << std::endl; + +#include +#define TICK(x) auto bench_##x = tbb::tick_count::now(); +#define TOCK(x) std::cout << #x ": " << (tbb::tick_count::now() - bench_##x).seconds() << "s" << std::endl; diff --git a/src/qfvm_gpu/custate_simu.cuh b/src/qfvm_gpu/custate_simu.cuh new file mode 100644 index 0000000..6456c7e --- /dev/null +++ b/src/qfvm_gpu/custate_simu.cuh @@ -0,0 +1,35 @@ +#pragma once +#include "cuda_statevector.cuh" +#include +#include +#include +#include "apply_gate_custate.cuh" + +void simulate_custate(Circuit & circuit, CudaStateVector & psi_d){ + size_t size = psi_d.size(); + int n = psi_d.num(); + for (auto gate : circuit.gates()){ + apply_gate_custate(psi_d.data(), gate, n); + } +} + +void simulate_custate(Circuit & circuit, StateVector & state){ + //initialize psi + state.set_num(circuit.qubit_num()); + size_t size = state.size(); + CudaStateVector psi_d(state); + + simulate_custate(circuit, psi_d); + cudaDeviceSynchronize(); + + //copy back + complex* psi = reinterpret_cast*>(psi_d.data()); + checkCudaErrors(cudaMemcpy(state.data(), psi, size*sizeof(complex), cudaMemcpyDeviceToHost)); + psi=nullptr; +} + +StateVector simulate_custate(Circuit & circuit){ + StateVector state(circuit.qubit_num()); + simulate_custate(circuit, state); + return std::move(state); +} \ No newline at end of file From 23bfc07bc59debba0e4a744a193eed7b7c64249c Mon Sep 17 00:00:00 2001 From: lss0208 <382715246@qq.com> Date: Mon, 3 Apr 2023 21:21:42 +0800 Subject: [PATCH 05/70] add func doc --- src/quafu/simulators/simulator.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/quafu/simulators/simulator.py b/src/quafu/simulators/simulator.py index 9a4f3fb..11998f9 100644 --- a/src/quafu/simulators/simulator.py +++ b/src/quafu/simulators/simulator.py @@ -7,18 +7,21 @@ import numpy as np import time -def simulate(qc : Union[QuantumCircuit, str], psi : np.ndarray= np.array([]), simulator:str="qfvm_circ", output: str="probabilities", use_gpu=False, use_custatevec=False)-> SimuResult: +def simulate(qc : Union[QuantumCircuit, str], psi : np.ndarray= np.array([]), simulator:str ="qfvm_circ", output: str="probabilities", use_gpu: bool=False, use_custatevec: bool=False)-> SimuResult: """Simulate quantum circuit Args: qc: quantum circuit or qasm string that need to be simulated. psi : Input state vector - simulator:`"qfvm_circ"`: The high performance C++ circuit simulator with GPU support. + simulator:`"qfvm_circ"`: The high performance C++ circuit simulator with optional GPU support. `"py_simu"`: Python implemented simulator by sparse matrix with low performace for large scale circuit. `"qfvm_qasm"`: The high performance C++ qasm simulator with limited gate set. output: `"probabilities"`: Return probabilities on measured qubits, ordered in big endian convention. `"density_matrix"`: Return reduced density_amtrix on measured qubits, ordered in big endian convention. `"state_vector`: Return original full statevector. The statevector returned by `qfvm` backend is ordered in little endian convention (same as qiskit), while `py_simu` backend is orderd in big endian convention. + use_gpu: Use the GPU version of `qfvm_circ` simulator. + use_custatevec: Use cuStateVec-based `qfvm_circ` simulator. The argument `use_gpu` must also be True. + Returns: SimuResult object that contain the results. """ From 470891e4bf581666fe6e3aeb87f259bf7a66134e Mon Sep 17 00:00:00 2001 From: lss0208 <382715246@qq.com> Date: Mon, 3 Apr 2023 21:34:14 +0800 Subject: [PATCH 06/70] fix exceptions --- src/quafu/simulators/simulator.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/quafu/simulators/simulator.py b/src/quafu/simulators/simulator.py index 11998f9..004afd0 100644 --- a/src/quafu/simulators/simulator.py +++ b/src/quafu/simulators/simulator.py @@ -5,7 +5,7 @@ from quafu import QuantumCircuit from ..results.results import SimuResult import numpy as np -import time +from ..exceptions import QuafuError def simulate(qc : Union[QuantumCircuit, str], psi : np.ndarray= np.array([]), simulator:str ="qfvm_circ", output: str="probabilities", use_gpu: bool=False, use_custatevec: bool=False)-> SimuResult: """Simulate quantum circuit @@ -44,13 +44,13 @@ def simulate(qc : Union[QuantumCircuit, str], psi : np.ndarray= np.array([]), si try: from .qfvm import simulate_circuit_custate except ImportError: - raise(" pyquafu is installed with cuquantum support") + raise QuafuError(" pyquafu is installed with cuquantum support") psi = simulate_circuit_custate(qc, psi) else: try: from .qfvm import simulate_circuit_gpu except ImportError: - raise("you are not using the GPU version of pyquafu") + raise QuafuError("you are not using the GPU version of pyquafu") psi = simulate_circuit_gpu(qc, psi) else: psi = simulate_circuit(qc, psi) From e023a88cb966e21bd9205f4c51ed72bac470da61 Mon Sep 17 00:00:00 2001 From: lss0208 <382715246@qq.com> Date: Fri, 7 Apr 2023 15:44:03 +0800 Subject: [PATCH 07/70] use unique_ptr --- src/qfvm/qfvm.cpp | 20 ++++----- src/qfvm/statevector.hpp | 91 +++++++++++++--------------------------- 2 files changed, 38 insertions(+), 73 deletions(-) diff --git a/src/qfvm/qfvm.cpp b/src/qfvm/qfvm.cpp index fdd3ade..e33245a 100644 --- a/src/qfvm/qfvm.cpp +++ b/src/qfvm/qfvm.cpp @@ -13,8 +13,8 @@ namespace py = pybind11; template -py::array_t to_numpy(const std::tuple &src) { - auto src_ptr = *std::get<0>(src); +py::array_t to_numpy(const std::tuple &src) { + auto src_ptr = std::get<0>(src); auto src_size = std::get<1>(src); auto capsule = py::capsule(src_ptr, [](void* p) { @@ -28,26 +28,24 @@ py::array_t to_numpy(const std::tuple &src) { } py::object execute(string qasm){ - return to_numpy(simulate(qasm).move_data()); + return to_numpy(simulate(qasm).move_data_to_python()); } py::object simulate_circuit(py::object const&pycircuit, py::array_t> &np_inputstate){ auto circuit = Circuit(pycircuit); - py::buffer_info buf = np_inputstate.request(); auto* data_ptr = reinterpret_cast*>(buf.ptr); size_t data_size = buf.size; - if (data_size == 0){ StateVector state; simulate(circuit, state); - return to_numpy(state.move_data()); + return to_numpy(state.move_data_to_python()); } else{ StateVector state(data_ptr, buf.size); simulate(circuit, state); - //return to_numpy(state.move_data()); + state.move_data_to_python(); return np_inputstate; } } @@ -63,12 +61,12 @@ py::object simulate_circuit_gpu(py::object const&pycircuit, py::array_t state; simulate_gpu(circuit, state); - return to_numpy(state.move_data()); + return to_numpy(state.move_data_to_python()); } else{ StateVector state(data_ptr, buf.size); simulate_gpu(circuit, state); - //return to_numpy(state.move_data()); + state.move_data_to_python(); return np_inputstate; } } @@ -85,12 +83,12 @@ py::object simulate_circuit_custate(py::object const&pycircuit, py::array_t state; simulate_custate(circuit, state); - return to_numpy(state.move_data()); + return to_numpy(state.move_data_to_python()); } else{ StateVector state(data_ptr, buf.size); simulate_custate(circuit, state); - //return to_numpy(state.move_data()); + state.move_data_to_python(); return np_inputstate; } } diff --git a/src/qfvm/statevector.hpp b/src/qfvm/statevector.hpp index db3956d..a8a7f83 100644 --- a/src/qfvm/statevector.hpp +++ b/src/qfvm/statevector.hpp @@ -20,8 +20,7 @@ class StateVector{ private: uint num_; size_t size_; - complex* data_; - uint count_; // Reference count of current statevector + std::unique_ptr[]> data_; public: //construct function @@ -29,28 +28,6 @@ class StateVector{ explicit StateVector(uint num); explicit StateVector(complex *data, size_t data_size); - //Disable copy construct - StateVector(StateVector const &other) = delete; - StateVector &operator=(StateVector const &other) = delete; - - //Move construct - StateVector(StateVector &&other) : - num_(other.num()), - size_(other.size()), - data_(other.data()), - count_(other.count_) - { - other.data_ = nullptr; - } - - StateVector &operator=(StateVector &&other){ - this->~StateVector(); - new (this) StateVector(std::move(other)); - return *this; - } - - //destruct function - ~StateVector(); //Named gate function void apply_x(pos_t pos); @@ -90,11 +67,12 @@ class StateVector{ complex operator[] (size_t j) const ; void set_num(uint num); void print_state(); - std::tuple**, size_t> move_data() { - count_++; - return std::make_tuple(&data_, size_); + std::tuple*, size_t> move_data_to_python() { + auto data_ptr = data_.release(); + return std::make_tuple(std::move(data_ptr), size_); } - complex* data(){ return data_; } + + complex* data(){ return data_.get(); } size_t size(){ return size_; } uint num(){ return num_; } }; @@ -105,11 +83,9 @@ class StateVector{ template StateVector::StateVector(uint num) : num_(num), -size_(std::pow(2, num)) -{ - data_ = new complex[size_]; +size_(1ULL<[]>(size_); data_[0] = complex(1., 0); - count_ = 0; }; template @@ -120,20 +96,11 @@ StateVector::StateVector(complex *data, size_t data_size) : data_(data), size_(data_size) -{ +{ num_ = static_cast(std::log2(size_)); } -template -StateVector::~StateVector() { - // If ownership is moved to python, do nothing - // Other wise we need to release statevector's memory - if (data_ && count_ == 0) { - delete [] data_; - } -} - //// useful functions ///// template @@ -151,17 +118,17 @@ void StateVector::set_num(uint num){ num_ = num; if (size_ != 1ULL << num) { - delete [] data_; + data_.reset(); size_ = 1ULL << num; - data_ = new complex[size_]; + data_ = std::make_unique[]>(size_); data_[0] = complex(1, 0); } } template void StateVector::print_state(){ - for (auto i : data_){ - std::cout << i << std::endl; + for (auto i=0;i::apply_x(pos_t pos){ #ifdef USE_SIMD #pragma omp parallel for for(omp_i j = 0;j < size_;j+=2){ - double* ptr = (double*)(data_ + j); + double* ptr = (double*)(data_.get() + j); __m256d data = _mm256_loadu_pd(ptr); data = _mm256_permute4x64_pd(data, 78); _mm256_storeu_pd(ptr, data); @@ -193,8 +160,8 @@ void StateVector::apply_x(pos_t pos){ #pragma omp parallel for for(omp_i j = 0;j < rsize;j += 2){ size_t i = (j&(offset-1)) | (j>>pos<::apply_y(pos_t pos){ __m256d minus_half = _mm256_set_pd(1, -1, -1, 1); #pragma omp parallel for for(omp_i j = 0;j < size_;j+=2){ - double* ptr = (double*)(data_ + j); + double* ptr = (double*)(data_.get() + j); __m256d data = _mm256_loadu_pd(ptr); data = _mm256_permute4x64_pd(data, 27); data = _mm256_mul_pd(data, minus_half); @@ -246,8 +213,8 @@ void StateVector::apply_y(pos_t pos){ for(omp_i j = 0;j < rsize;j += 2){ size_t i = (j&(offset-1)) | (j>>pos<::apply_z(pos_t pos){ #pragma omp parallel for for(omp_i j = 0;j < rsize;j += 2){ size_t i = (j&(offset-1)) | (j>>pos<::apply_one_targe_gate_general(vector const& posv for(omp_i j = 0;j < rsize; j+= 2){ size_t i = getind_func(j); - double* p0 = (double*)(data_+i); - double* p1 = (double*)(data_+i+offset); + double* p0 = (double*)(data_.get()+i); + double* p1 = (double*)(data_.get()+i+offset); //load data __m256d data0 = _mm256_loadu_pd(p0); //lre_0, lim_0, rre_0, rim_0 __m256d data1 = _mm256_loadu_pd(p1); //lre_1, lim_1, rre_1, rim_1 @@ -635,7 +602,7 @@ void StateVector::apply_one_targe_gate_x(vector const& posv) #pragma omp parallel for for(omp_i j = 0;j < rsize;j++){ size_t i = getind_func_near(j); - double* ptr = (double*)(data_ + i); + double* ptr = (double*)(data_.get() + i); __m256d data = _mm256_loadu_pd(ptr); data = _mm256_permute4x64_pd(data, 78); _mm256_storeu_pd(ptr, data); @@ -659,8 +626,8 @@ void StateVector::apply_one_targe_gate_x(vector const& posv) #pragma omp parallel for for(omp_i j = 0;j < rsize; j+= 2){ size_t i = getind_func(j); - double* ptr0 = (double*)(data_ + i); - double* ptr1 = (double*)(data_ + i + offset); + double* ptr0 = (double*)(data_.get() + i); + double* ptr1 = (double*)(data_.get() + i + offset); __m256d data0 = _mm256_loadu_pd(ptr0); __m256d data1 = _mm256_loadu_pd(ptr1); _mm256_storeu_pd(ptr1, data0); @@ -778,8 +745,8 @@ void StateVector::apply_one_targe_gate_real(vector const& posv, c for(omp_i j = 0;j < rsize; j+= 2){ size_t i = getind_func(j); - double* p0 = (double*)(data_+i); - double* p1 = (double*)(data_+i+offset); + double* p0 = (double*)(data_.get()+i); + double* p1 = (double*)(data_.get()+i+offset); //load data __m256d data0 = _mm256_loadu_pd(p0); //lre_0, lim_0, rre_0, rim_0 __m256d data1 = _mm256_loadu_pd(p1); //lre_1, lim_1, rre_1, rim_1 @@ -914,8 +881,8 @@ void StateVector::apply_one_targe_gate_diag(vector const& posv, c for(omp_i j = 0;j < rsize; j+= 2){ size_t i = getind_func(j); - double* p0 = (double*)(data_+i); - double* p1 = (double*)(data_+i+offset); + double* p0 = (double*)(data_.get()+i); + double* p1 = (double*)(data_.get()+i+offset); //load data __m256d data0 = _mm256_loadu_pd(p0); //lre_0, lim_0, rre_0, rim_0 From fd26486dec9b195e0bb8e74948f37c3d66439637 Mon Sep 17 00:00:00 2001 From: lss0208 <382715246@qq.com> Date: Fri, 7 Apr 2023 17:11:41 +0800 Subject: [PATCH 08/70] fix cmake --- CMakeLists.txt | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 40d6511..73da6f7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.14...3.22) -project(qfvm LANGUAGES CXX C CUDA) +project(qfvm LANGUAGES CXX C) set (CMAKE_BUILD_TYPE Release) set(CMAKE_CXX_STANDARD 17) @@ -81,7 +81,8 @@ target_compile_definitions(${PROJECT_NAME} PRIVATE VERSION_INFO=${PROJECT_VERSIO #GPU version if (USE_GPU) - add_compile_definitions(_USE_GPU) + add_compile_definitions(_USE_GPU) + enable_language(CUDA) set_source_files_properties(src/${PROJECT_NAME}/${PROJECT_NAME}.cpp PROPERTIES LANGUAGE CUDA) target_link_libraries(${PROJECT_NAME} PUBLIC cudart) target_compile_options(${PROJECT_NAME} PUBLIC $<$:--extended-lambda> ) From 0d9edcd8559bd3a4d190f9d59d386605c6dd9305 Mon Sep 17 00:00:00 2001 From: fatboy1994 Date: Mon, 24 Apr 2023 22:23:40 +0800 Subject: [PATCH 09/70] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E4=BA=86dag?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/quafu/dagcircuits/__init__.py | 1 + src/quafu/dagcircuits/circuit_dag.py | 341 ++++++++++++++++ src/quafu/dagcircuits/dag_test.ipynb | 458 ++++++++++++++++++++++ src/quafu/dagcircuits/instruction_node.py | 38 ++ 4 files changed, 838 insertions(+) create mode 100755 src/quafu/dagcircuits/__init__.py create mode 100644 src/quafu/dagcircuits/circuit_dag.py create mode 100644 src/quafu/dagcircuits/dag_test.ipynb create mode 100644 src/quafu/dagcircuits/instruction_node.py diff --git a/src/quafu/dagcircuits/__init__.py b/src/quafu/dagcircuits/__init__.py new file mode 100755 index 0000000..8b13789 --- /dev/null +++ b/src/quafu/dagcircuits/__init__.py @@ -0,0 +1 @@ + diff --git a/src/quafu/dagcircuits/circuit_dag.py b/src/quafu/dagcircuits/circuit_dag.py new file mode 100644 index 0000000..fc6306c --- /dev/null +++ b/src/quafu/dagcircuits/circuit_dag.py @@ -0,0 +1,341 @@ +import numpy as np +from quafu import QuantumCircuit + +from quafu.elements.element_gates import * +from quafu.elements.quantum_element import Barrier, Delay, ControlledGate, MultiQubitGate, ParaMultiQubitGate, QuantumGate, SingleQubitGate, XYResonance + +import networkx as nx +from typing import Dict, Any, List, Union +import copy + +from instruction_node import InstructionNode # gate_wrapper.py in the same folder as circuit_dag.py now + +import pygraphviz as pgv +from networkx.drawing.nx_pydot import write_dot +from IPython.display import Image, SVG + + + +# transform a gate in quantumcircuit of quafu(not include measure_gate), +# into a node in the graph, with specific label. +def gate_to_node(input_gate,specific_label: str): + ''' + transform a gate in quantumcircuit of quafu(not include measure_gate), + into a node in the graph, with specific label. + + Args: + inputgate: a gate in quantumcircuit of quafu(not include measure_gate) + label: the label of the node in the graph + + Returns: + node: a node in the graph, with specific label. A GateWrapper object + + ''' + + import copy + gate = copy.deepcopy(input_gate) # avoid modifying the original gate + if type(gate.pos) != list: # if gate.pos is not a list, make it a list + gate.pos = [gate.pos] + + + # use getattr check 'paras' and other attributes if exist. if the attr doesn't exist,return None + paras = getattr(gate, 'paras', None) + # matrix = getattr(gate, 'matrix', None) + duration = getattr(gate, 'duration', None) + unit = getattr(gate, 'unit', None) + if paras is None: + gate.paras = None + elif type(gate.paras) != list: # if paras is not a list, make it a list + gate.paras = [gate.paras] + # if matrix is None: + # gate.matrix = None + if duration is None: + gate.duration = None + if unit is None: + gate.unit = None + + # hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.matrix,gate.duration,gate.unit, label=i) + hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.duration,gate.unit, label=specific_label) + return hashable_gate + + +# Building a DAG Graph using NetworkX from a QuantumCircuit +def circuit_to_dag(circuit): + ''' + Building a DAG Graph using NetworkX from a QuantumCircuit + + Args: + circuit: a QuantumCircuit object + + Returns: + g: a networkx MultiDiGraph object + + example: + .. jupyter-execute:: + + from circuit_dag import circuit_to_dag, dag_to_circuit, draw_dag + from quafu import QuantumCircuit + + # Create a quantum circuit as an example that you can modify as needed + circuit = QuantumCircuit(2) + circuit.h(0) + circuit.cnot(0, 1) + + # Build the dag graph + dep_graph = circuit_to_dag(circuit) # dag graph + ''' + + # Starting Label Index + i = 0 + + # A dictionary to store the last use of any qubit + qubit_last_use = {} + + g = nx.MultiDiGraph() # two nodes can have multiple edges + # g = nx.DiGraph() # two nodes can only have one edge + + # Add the start node + # g.add_node(-1,{"color": "green"}) + g.add_nodes_from([(-1, {"color": "green"})]) + + # deepcopy the circuit to avoid modifying the original circuit + # gates = copy.deepcopy(circuit.gates) # need to import copy + # change to: gate = copy.deepcopy(input_gate) in gate_to_node() + + for gate in circuit.gates: + # transform gate to node + hashable_gate = gate_to_node(gate,specific_label=i) + i += 1 + + g.add_node(hashable_gate,color="blue") + + # Add edges based on qubit_last_use; update last use + for qubit in hashable_gate.pos: + if qubit in qubit_last_use: + g.add_edge(qubit_last_use[qubit], hashable_gate,label=f'q{qubit}') + else: + g.add_edge(-1, hashable_gate,label=f'q{qubit}',color="green") + + qubit_last_use[qubit] = hashable_gate + + # Add measure_gate node + qm = Any + qm.name = "measure" + qm.paras, qm.duration, qm.unit = [None,None,None] + qm.pos = copy.deepcopy(circuit.measures) # circuit.measures is a dict + measure_gate = InstructionNode(qm.name, qm.pos, qm.paras, qm.duration, qm.unit, label="m") + g.add_node(measure_gate,color="blue") + # Add edges from qubit_last_use[qubit] to measure_gate + for qubit in measure_gate.pos.keys(): + if qubit in qubit_last_use: + g.add_edge(qubit_last_use[qubit], measure_gate,label=f'q{qubit}') + else: + g.add_edge(-1, measure_gate,label=f'q{qubit}',color="green") + + qubit_last_use[qubit] = measure_gate + + # Add the end node + # g.add_node(float('inf'),{"color": "red"}) + g.add_nodes_from([(float('inf'), {"color": "red"})]) + + for qubit in qubit_last_use: + g.add_edge(qubit_last_use[qubit], float('inf'),label=f'q{qubit}',color="red") + + return g + + +# transform gate in dag nodes to gate in circuit which can be added to circuit +gate_classes = { + "x": XGate, + "y": YGate, + "z": ZGate, + "h": HGate, + "s": SGate, + "sdg": SdgGate, + "t": TGate, + "tdg": TdgGate, + "rx": RXGate, + "ry": RYGate, + "rz": RZGate, + "id": IdGate, + "sx": SXGate, + "sy": SYGate, + "w": WGate, + "sw": SWGate, + "p": PhaseGate, + "delay": Delay, + "barrier": Barrier, + "cx": CXGate, + "cp": CPGate, + "swap": SwapGate, + "rxx": RXXGate, + "ryy": RYYGate, + "rzz": RZZGate, + "cy": CYGate, + "cz": CZGate, + "cs": CSGate, + "ct": CTGate, + "xy": XYResonance, + "ccx": ToffoliGate, + "cswap": FredkinGate, + "mcx": MCXGate, + "mcy": MCYGate, + "mcz": MCZGate, +} + +def node_to_gate(gate_in_dag): + """ + transform gate in dag graph, to gate in circuit which can be added to circuit + + Args: + gate_in_dag: a node in dag graph , gate_in_dag is a GateWrapper object. + in GateWrapper, gate_in_dag.name is uppercase, gate_in_dag.pos is a list or a dict + gate_transform support gate with one qubit or more qubits, not measures! + and you should exculde nodes [-1 ,float('inf') , measure_gate] in dag graph + + Returns: + gate: gate which can be added to circuit in quafu + + example: + import networkx as nx + from quafu import QuantumCircuit + qcircuit = QuantumCircuit(n) + + for gate in nx.topological_sort(dep_graph): + + if gate not in [-1, float('inf')]: + # measure gate to do + if gate.name == "measure": + qcircuit.measures = gate.pos + + else: + # use gate_transform to transform gate in dag graph to gate in circuit + qcircuit.gates.append(node_to_gate(gate)) + return qcircuit + + """ + + gate_name = gate_in_dag.name.lower() + gate_class = gate_classes.get(gate_name) + + if not gate_class: + raise ValueError("gate is not supported") + + if gate_name == "barrier": + return gate_class(gate_in_dag.pos) + + # 从gate_in_dag获取参数列表 + args = gate_in_dag.pos + if gate_in_dag.paras: + args += gate_in_dag.paras + + # 处理 gate.duration 和 gate.unit + if gate_name in ["delay", "xy"]: + args.append(gate_in_dag.duration) + args.append(gate_in_dag.unit) + + # 处理多量子比特门 + if gate_name in ["mcx", "mcy", "mcz"]: + control_qubits = gate_in_dag.pos[:-1] + target_qubit = gate_in_dag.pos[-1] + return gate_class(control_qubits, target_qubit) + + return gate_class(*args) + + + +# From DAG with Hashable Gates to quafu Gates added to circuit +def dag_to_circuit(dep_graph, n: int): + ''' + From DAG with Hashable Gates to quafu Gates added to circuit + + Args: + dep_graph (DAG): DAG with Hashable Gates + n (int): number of qubits + + Returns: + qcircuit (QuantumCircuit): quafu QuantumCircuit + + example: + .. jupyter-execute:: + + from circuit_dag import circuit_to_dag, dag_to_circuit, draw_dag + from quafu import QuantumCircuit + + # Create a quantum circuit as an example that you can modify as needed + circuit = QuantumCircuit(2) + circuit.h(0) + circuit.cnot(0, 1) + + # Build the dag graph + dep_graph = circuit_to_dag(circuit) # dag graph + + # use dag_to_circuit to transform dag graph to a new circuit + reconstructed_circuit = dag_to_circuit(dep_graph, circuit.num) + + + ''' + + qcircuit = QuantumCircuit(n) + + for gate in nx.topological_sort(dep_graph): + + if gate not in [-1, float('inf')]: + # measure gate to do + if gate.name == "measure": + qcircuit.measures = gate.pos + + else: + # use gate_transform to transform gate in dag graph to gate in circuit + qcircuit.gates.append(node_to_gate(gate)) + return qcircuit + +# Helper function to visualize the DAG,check the example in the docstring +def draw_dag(dep_g, output_format="png"): + ''' + Helper function to visualize the DAG + + Args: + dep_g (DAG): DAG with Hashable Gates + output_format (str): output format, "png" or "svg" + + Returns: + img (Image or SVG): show the image of DAG, which is Image(filename="dag.png") or SVG(filename="dag.svg") + + example: + .. jupyter-execute:: + ex1: + # directly draw PNG picture + draw_dag(dep_g, output_format="png") # save a png picture "dag.png" and show it in jupyter notebook + + # directly draw SVG picture + draw_dag(dep_g, output_format="svg") # save a svg picture "dag.svg" and show it in jupyter notebook + + ex2: + # generate PNG picture + img_png = draw_dag(dep_g, output_format="png") + + # generate SVG picture + img_svg = draw_dag(dep_g, output_format="svg") + + # show PNG picture + img_png + + # show SVG picture + img_svg + + + ''' + write_dot(dep_g, "dag.dot") + G = pgv.AGraph("dag.dot") + G.layout(prog="dot") + + if output_format == "png": + G.draw("dag.png") + return Image(filename="dag.png") + elif output_format == "svg": + G.draw("dag.svg") + return SVG(filename="dag.svg") + else: + raise ValueError("Unsupported output format: choose either 'png' or 'svg'") + diff --git a/src/quafu/dagcircuits/dag_test.ipynb b/src/quafu/dagcircuits/dag_test.ipynb new file mode 100644 index 0000000..2fa1da2 --- /dev/null +++ b/src/quafu/dagcircuits/dag_test.ipynb @@ -0,0 +1,458 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DAG examples" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "you should install `pygraphviz` ,`pydot` package for visualization \n", + "`pip install pygraphviz ` \n", + "`pip install pydot`" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from circuit_dag import circuit_to_dag, dag_to_circuit, draw_dag # gate_wrapper.py in the same folder as circuit_dag.py\n", + "from quafu import QuantumCircuit" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Transform circuit into dag" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 创建一个量子电路作为示例，您可以根据需要修改这个电路\n", + "simple = QuantumCircuit(3)\n", + "simple.cnot(0, 1)\n", + "simple.cnot(1, 0)\n", + "simple.x(2)\n", + "simple.cnot(2, 1)\n", + "simple.cp(1, 0,np.pi / 2)\n", + "simple.barrier([0, 1, 2])\n", + "simple.rxx(0, 1, np.pi / 2)\n", + "simple.delay(0, 100)\n", + "simple.fredkin(0,1, 2)\n", + "simple.mcx([0, 1], 2)\n", + "# simple.measure([0], [0])\n", + "# simple.measure([1], [2])\n", + "simple.measure([2], [1])\n", + "\n", + "\n", + "\n", + "# 构建dag\n", + "dep_graph = circuit_to_dag(simple) # 更新为新的函数名\n", + "\n", + "# 可视化dag\n", + "draw_dag(dep_graph, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "# 在此处添加您的其它代码，例如模拟电路，分析结果等" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q[0] --*----+---------P(1.571)----||-------#---------Delay(100ns)----*----*--\n", + " | | | || RXX(1.571) | | \n", + "q[1] --+----*----+-------*--------||-------#-------------------------x----*--\n", + " | || | | \n", + "q[2] --X---------*----------------||---------------------------------x----X-- M->c[1]\n" + ] + } + ], + "source": [ + "simple.draw_circuit()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Transform dag into circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "%3\n", + "\n", + "\n", + "\n", + "-1\n", + "\n", + "-1\n", + "\n", + "\n", + "\n", + "0{CX(0,1)}\n", + "\n", + "0{CX(0,1)}\n", + "\n", + "\n", + "\n", + "-1->0{CX(0,1)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "-1->0{CX(0,1)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "1{X(2)}\n", + "\n", + "1{X(2)}\n", + "\n", + "\n", + "\n", + "-1->1{X(2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "2{CX(1,0)}\n", + "\n", + "2{CX(1,0)}\n", + "\n", + "\n", + "\n", + "0{CX(0,1)}->2{CX(1,0)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "0{CX(0,1)}->2{CX(1,0)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "3{CX(2,1)}\n", + "\n", + "3{CX(2,1)}\n", + "\n", + "\n", + "\n", + "1{X(2)}->3{CX(2,1)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "2{CX(1,0)}->3{CX(2,1)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "4{CP(1,0)}(1.571)\n", + "\n", + "4{CP(1,0)}(1.571)\n", + "\n", + "\n", + "\n", + "2{CX(1,0)}->4{CP(1,0)}(1.571)\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "3{CX(2,1)}->4{CP(1,0)}(1.571)\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "5{barrier(0,1,2)}\n", + "\n", + "5{barrier(0,1,2)}\n", + "\n", + "\n", + "\n", + "3{CX(2,1)}->5{barrier(0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "4{CP(1,0)}(1.571)->5{barrier(0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "4{CP(1,0)}(1.571)->5{barrier(0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "6{RXX(0,1)}(1.571)\n", + "\n", + "6{RXX(0,1)}(1.571)\n", + "\n", + "\n", + "\n", + "5{barrier(0,1,2)}->6{RXX(0,1)}(1.571)\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "5{barrier(0,1,2)}->6{RXX(0,1)}(1.571)\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "8{CSWAP(0,1,2)}\n", + "\n", + "8{CSWAP(0,1,2)}\n", + "\n", + "\n", + "\n", + "5{barrier(0,1,2)}->8{CSWAP(0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "6{RXX(0,1)}(1.571)->8{CSWAP(0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "7{delay(0)}\n", + "\n", + "7{delay(0)}\n", + "\n", + "\n", + "\n", + "6{RXX(0,1)}(1.571)->7{delay(0)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "9{MCX(0,1,2)}\n", + "\n", + "9{MCX(0,1,2)}\n", + "\n", + "\n", + "\n", + "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "7{delay(0)}->8{CSWAP(0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "m{measure(2=>1)}\n", + "\n", + "m{measure(2=>1)}\n", + "\n", + "\n", + "\n", + "9{MCX(0,1,2)}->m{measure(2=>1)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "inf\n", + "\n", + "inf\n", + "\n", + "\n", + "\n", + "9{MCX(0,1,2)}->inf\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "9{MCX(0,1,2)}->inf\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "m{measure(2=>1)}->inf\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 从dag中重建量子电路\n", + "reconstructed_circuit = dag_to_circuit(dep_graph, simple.num) # 更新为新的函数名\n", + "\n", + "# 构建dag\n", + "dep_graph = circuit_to_dag(reconstructed_circuit) # 更新为新的函数名\n", + "\n", + "# 可视化dag\n", + "draw_dag(dep_graph, output_format=\"svg\") # 或者使用 \"png\" 作为输出格式\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q[0] --*----+---------P(1.571)----||-------#---------Delay(100ns)----*----*--\n", + " | | | || RXX(1.571) | | \n", + "q[1] --+----*----+-------*--------||-------#-------------------------x----*--\n", + " | || | | \n", + "q[2] --X---------*----------------||---------------------------------x----X-- M->c[1]\n" + ] + } + ], + "source": [ + "reconstructed_circuit.draw_circuit()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ycquafu", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/quafu/dagcircuits/instruction_node.py b/src/quafu/dagcircuits/instruction_node.py new file mode 100644 index 0000000..24294b5 --- /dev/null +++ b/src/quafu/dagcircuits/instruction_node.py @@ -0,0 +1,38 @@ +from typing import Dict, Any, List, Union +import dataclasses + +@dataclasses.dataclass +class InstructionNode: + name:Any # gate.name + pos:Union[List[Any], Dict[Any,Any]] # gate.pos | Dict[Any,Any] for measure + paras:List[Any] # gate.paras + # matrix:List[Any] # for gate in [QuantumGate] + duration:int # for gate in [Delay,XYResonance] in quafu + unit:str # for gate in [Delay,XYResonance] in quafu + label:str + + def __hash__(self): + return hash((type(self.name), tuple(self.pos) ,self.label)) + + def __str__(self): + if self.name == 'measure': + args = ','.join(str(q) for q in self.pos.keys()) + args += f'=>{",".join(str(c) for c in self.pos.values())}' + else: + args = ','.join(str(q) for q in self.pos) + + if self.paras == None: + return f'{self.label}{{{self.name}({args})}}' + else: + # if self.paras not a list, then make it a list of str of .3f float + if not isinstance(self.paras, list): + formatted_paras = [f'{self.paras:.3f}'] + else: + formatted_paras = [f'{p:.3f}' for p in self.paras] + + formatted_paras_str = ','.join(formatted_paras) + + return f'{self.label}{{{self.name}({args})}}({formatted_paras_str})' + + def __repr__(self): + return str(self) \ No newline at end of file From 4a1c6bbdcb78741639df0190d350d0d121134b86 Mon Sep 17 00:00:00 2001 From: fatboy1994 Date: Mon, 24 Apr 2023 22:59:21 +0800 Subject: [PATCH 10/70] add dag --- src/quafu/dagcircuits/circuit_dag.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/quafu/dagcircuits/circuit_dag.py b/src/quafu/dagcircuits/circuit_dag.py index fc6306c..216564e 100644 --- a/src/quafu/dagcircuits/circuit_dag.py +++ b/src/quafu/dagcircuits/circuit_dag.py @@ -8,7 +8,7 @@ from typing import Dict, Any, List, Union import copy -from instruction_node import InstructionNode # gate_wrapper.py in the same folder as circuit_dag.py now +from instruction_node import InstructionNode # instruction_node.py in the same folder as circuit_dag.py now import pygraphviz as pgv from networkx.drawing.nx_pydot import write_dot From 53b00a2970d1f478f5f5e22204fb8d0c09f204b4 Mon Sep 17 00:00:00 2001 From: fatboy1994 Date: Mon, 24 Apr 2023 23:43:26 +0800 Subject: [PATCH 11/70] add dag , modify the test book Co-authored-by: fatboy1994 --- src/quafu/dagcircuits/dag_test.ipynb | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/quafu/dagcircuits/dag_test.ipynb b/src/quafu/dagcircuits/dag_test.ipynb index 2fa1da2..5ae4182 100644 --- a/src/quafu/dagcircuits/dag_test.ipynb +++ b/src/quafu/dagcircuits/dag_test.ipynb @@ -15,7 +15,8 @@ "source": [ "you should install `pygraphviz` ,`pydot` package for visualization \n", "`pip install pygraphviz ` \n", - "`pip install pydot`" + "`pip install pydot`\n", + "before you install `pygraphviz` ,you should install `graphviz` first." ] }, { From 8344afe57badbdbd269695b73e2080848af71d82 Mon Sep 17 00:00:00 2001 From: fatboy1994 Date: Mon, 24 Apr 2023 23:46:22 +0800 Subject: [PATCH 12/70] change the explaination --- src/quafu/dagcircuits/circuit_dag.py | 2 +- src/quafu/dagcircuits/instruction_node.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/quafu/dagcircuits/circuit_dag.py b/src/quafu/dagcircuits/circuit_dag.py index 216564e..78c1cad 100644 --- a/src/quafu/dagcircuits/circuit_dag.py +++ b/src/quafu/dagcircuits/circuit_dag.py @@ -17,7 +17,7 @@ # transform a gate in quantumcircuit of quafu(not include measure_gate), -# into a node in the graph, with specific label. +# to a node in the graph, with specific label. def gate_to_node(input_gate,specific_label: str): ''' transform a gate in quantumcircuit of quafu(not include measure_gate), diff --git a/src/quafu/dagcircuits/instruction_node.py b/src/quafu/dagcircuits/instruction_node.py index 24294b5..97cdc41 100644 --- a/src/quafu/dagcircuits/instruction_node.py +++ b/src/quafu/dagcircuits/instruction_node.py @@ -1,5 +1,5 @@ from typing import Dict, Any, List, Union -import dataclasses +import dataclasses @dataclasses.dataclass class InstructionNode: @@ -22,7 +22,7 @@ def __str__(self): args = ','.join(str(q) for q in self.pos) if self.paras == None: - return f'{self.label}{{{self.name}({args})}}' + return f'{self.label}{{{self.name}({args})}}' # no paras else: # if self.paras not a list, then make it a list of str of .3f float if not isinstance(self.paras, list): From ce0d2f4daa424fecc55a232c4619f382404971da Mon Sep 17 00:00:00 2001 From: lss0208 <382715246@qq.com> Date: Tue, 25 Apr 2023 11:50:55 +0800 Subject: [PATCH 13/70] optimize base --- src/quafu/backends/backends.py | 38 +--- src/quafu/circuits/quantum_circuit.py | 84 ++++---- src/quafu/elements/element_gates.py | 14 ++ src/quafu/elements/quantum_element.py | 25 +++ src/quafu/pulses/__init__.py | 9 + src/quafu/pulses/quantum_pulse.py | 266 ++++++++++++++++++++++++++ src/quafu/qfasm/__init__.py | 0 src/quafu/qfasm/qfasm_parser.py | 69 +++++++ src/quafu/qfasm/qfasmlex.py | 81 ++++++++ src/quafu/qfasm/qfasmlex_test.py | 2 + src/quafu/tasks/tasks.py | 37 ++-- src/quafu/users/userapi.py | 75 +++++--- 12 files changed, 590 insertions(+), 110 deletions(-) create mode 100644 src/quafu/pulses/__init__.py create mode 100644 src/quafu/pulses/quantum_pulse.py create mode 100644 src/quafu/qfasm/__init__.py create mode 100644 src/quafu/qfasm/qfasm_parser.py create mode 100644 src/quafu/qfasm/qfasmlex.py create mode 100644 src/quafu/qfasm/qfasmlex_test.py diff --git a/src/quafu/backends/backends.py b/src/quafu/backends/backends.py index cd30609..6c6eabd 100644 --- a/src/quafu/backends/backends.py +++ b/src/quafu/backends/backends.py @@ -2,9 +2,9 @@ import json import re import networkx as nx -from quafu.users.userapi import load_account import numpy as np import matplotlib.pyplot as plt +from quafu.users.userapi import User class Backend(object): def __init__(self, backend_info : dict): @@ -12,12 +12,16 @@ def __init__(self, backend_info : dict): self._valid_gates = backend_info['valid_gates'] self.qubit_num = backend_info['qubits'] self.system_id = backend_info['system_id'] - - def get_chip_info(self): - api_token, url = load_account() + self.status = backend_info['status'] + self.qv = backend_info["QV"] + # self.task_in_queue = backend_info["task_in_queue"] + + def get_chip_info(self, user=User()): + api_token = user.apitoken + url = user._url data = {"system_name": self.name.lower()} headers={"api_token": api_token} - chip_info = requests.post(url = url + "qbackend/scq_get_chip_info/", data=data, + chip_info = requests.post(url = url + user.chip_api, data=data, headers=headers) chip_info = json.loads(chip_info.text) json_topo_struct = chip_info["topological_structure"] @@ -92,26 +96,4 @@ def get_valid_gates(self): return self._valid_gates - - - -# class ScQ_P10(Backend): -# def __init__(self): -# super().__init__("ScQ-P10") -# self.valid_gates = ["cx", "cz", "rx", "ry", "rz", "x", "y", "z", "h", "sx", "sy", "id", "delay", "barrier", "cy", "cnot", "swap"] - -# class ScQ_P20(Backend): -# def __init__(self): -# super().__init__("ScQ-P20") -# self.valid_gates = ["cx", "cz", "rx", "ry", "rz", "x", "y", "z", "h", "sx", "sy", "id", "delay", "barrier", "cy", "cnot", "swap"] - -# class ScQ_P50(Backend): -# def __init__(self): -# super().__init__("ScQ-P50") -# self.valid_gates = ["cx", "cz", "rx", "ry", "rz", "x", "y", "z", "h"] - -# class ScQ_S41(Backend): -# def __init__(self): -# super().__init__("ScQ-S41") -# self.valid_gates = [ "rx", "ry", "rz", "x", "y", "z", "h", "sx", "sy", "id", "delay", "barrier", "xy"] - \ No newline at end of file + \ No newline at end of file diff --git a/src/quafu/circuits/quantum_circuit.py b/src/quafu/circuits/quantum_circuit.py index 827587f..dca37a1 100644 --- a/src/quafu/circuits/quantum_circuit.py +++ b/src/quafu/circuits/quantum_circuit.py @@ -1,6 +1,7 @@ from typing import Iterable import numpy as np from ..elements.quantum_element import Barrier, Delay, ControlledGate, MultiQubitGate, ParaMultiQubitGate, QuantumGate, SingleQubitGate, XYResonance +from quafu.pulses.quantum_pulse import QuantumPulse, gaussian, flattop, rect from ..elements.element_gates import * from ..exceptions import CircuitError @@ -39,7 +40,7 @@ def layered_circuit(self) -> np.ndarray: gateQlist = [[] for i in range(num)] used_qubits = [] for gate in gatelist: - if isinstance(gate, SingleQubitGate) or isinstance(gate, Delay): + if isinstance(gate, SingleQubitGate) or isinstance(gate, Delay) or isinstance(gate, QuantumPulse): gateQlist[gate.pos].append(gate) if gate.pos not in used_qubits: used_qubits.append(gate.pos) @@ -107,7 +108,7 @@ def draw_circuit(self, width : int=4, return_str : bool=False): maxlen = 1 + width for i in range(num): gate = layergates[i] - if isinstance(gate, SingleQubitGate) or isinstance(gate, Delay): + if isinstance(gate, SingleQubitGate) or isinstance(gate, Delay) or (isinstance(gate, QuantumPulse)): printlist[i * 2, l] = gate.symbol maxlen = max(maxlen, len(gate.symbol) + width) @@ -222,12 +223,40 @@ def from_openqasm(self, openqasm : str): else: sp_op = operations.split("(") + # print("sp_op: ", sp_op) gatename = sp_op[0] - if gatename == "delay": + if gatename == "delay" : paras = sp_op[1].strip("()") duration = int(re.findall("\d+", paras)[0]) unit = re.findall("[a-z]+", paras)[0] self.delay(inds[0], duration, unit) + + elif gatename in ["Rect", "Flattop", "Gaussian"]: + paras = sp_op[1].strip("()") + print(paras) + parastr = paras.split(",") + duration = int(re.findall("\d+", parastr[0])[0]) + unit = re.findall("[a-z]+", parastr[0])[0] + + extra_para = line.split(",")[1:] + para_e, indstr = extra_para[-1].split(")") + parastr = extra_para[:-1] + parastr.append(para_e) + ind = int(re.findall("\d+", indstr)[0]) + + paras = [eval(parai, {"pi": pi}) for parai in parastr] + + if gatename == "Rect": + pulse = rect(ind, duration=duration, amp=paras[0] ,unit=unit) + self.add_pulse(pulse) + elif gatename == "Flattop": + pulse = flattop(ind, duration=duration, amp=paras[0], fwhm=paras[1], unit=unit) + self.add_pulse(pulse) + + elif gatename == "Gaussian": + pulse = gaussian(ind, duration=duration, amp=paras[0], fwhm=paras[1], phase=paras[2], unit=unit) + self.add_pulse(pulse) + elif gatename == "xy": paras = sp_op[1].strip("()") duration = int(re.findall("\d+", paras)[0]) @@ -317,43 +346,7 @@ def to_openqasm(self) -> str: qasm += "qreg q[%d];\n" % self.num qasm += "creg meas[%d];\n" % len(self.measures) for gate in self.gates: - if isinstance(gate, SingleQubitGate): - if isinstance(gate, ParaSingleQubitGate): - if isinstance(gate.paras, Iterable): - qasm += "%s(" %gate.name.lower() + ",".join(["%s" %para for para in gate.paras]) + ") q[%d];\n" % (gate.pos) - else: - qasm += "%s(%s) " %(gate.name.lower(), gate.paras) + "q[%d];\n" % (gate.pos) - else: - if gate.name == "SY": - qasm += "ry(pi/2) q[%d];\n" %(gate.pos) - elif gate.name == "W": - qasm += "rz(-pi/4) q[%d];\nrx(pi) q[%d];\nrz(pi/4) q[%d];\n" %(gate.pos, gate.pos, gate.pos) - elif gate.name == "SW": - qasm += "rz(-pi/4) q[%d];\nrx(pi/2) q[%d];\nrz(pi/4) q[%d];\n" %(gate.pos, gate.pos, gate.pos) - else: - qasm += "%s q[%d];\n" % (gate.name.lower(), gate.pos) - - elif isinstance(gate, Delay): - qasm += "delay(%d%s) q[%d];\n" % (gate.duration, gate.unit, gate.pos) - elif isinstance(gate, XYResonance): - qasm += "xy(%d%s) " %(gate.duration, gate.unit) + ",".join(["q[%d]" % p for p in range(min(gate.pos), max(gate.pos)+1)]) + ";\n" - - elif isinstance(gate, Barrier) or isinstance(gate, MultiQubitGate): - if isinstance(gate, ParaMultiQubitGate) or (isinstance(gate, ControlledGate) and bool(gate.paras)): - if isinstance(gate.paras, Iterable): - qasm += "%s(" %gate.name.lower() + ",".join(["%s" %para for para in gate.paras]) + ") " + ",".join(["q[%d]" % p for p in gate.pos]) + ";\n" - else: - qasm += "%s(%s) " %(gate.name.lower(), gate.paras) + ",".join(["q[%d]" % p for p in gate.pos]) + ";\n" - - else: - if gate.name == "CS": - qasm += "cp(pi/2) " + "q[%d],q[%d];\n" % (gate.pos[0], gate.pos[1]) - elif gate.name == "CT": - qasm += "cp(pi/4) " + "q[%d],q[%d];\n" % (gate.pos[0], gate.pos[1]) - elif gate.name == "barrier": - qasm += "barrier " + ",".join(["q[%d]" % p for p in range(min(gate.pos), max(gate.pos)+1)]) + ";\n" - else: - qasm += "%s " %(gate.name.lower()) + ",".join(["q[%d]" % p for p in gate.pos]) + ";\n" + qasm += gate.to_qasm() + ";\n" for key in self.measures: qasm += "measure q[%d] -> meas[%d];\n" % (key, self.measures[key]) @@ -748,5 +741,14 @@ def measure(self, pos: List[int], cbits: List[int] = []) -> None: else: raise CircuitError("Number of measured bits should equal to the number of classical bits") - + def add_pulse(self, + pulse: QuantumPulse, + pos: int = None) -> "QuantumCircuit": + """ + Add quantum gate from pulse. + """ + if pos is not None: + pulse.set_pos(pos) + self.gates.append(pulse) + return self diff --git a/src/quafu/elements/element_gates.py b/src/quafu/elements/element_gates.py index bef02d1..452d790 100644 --- a/src/quafu/elements/element_gates.py +++ b/src/quafu/elements/element_gates.py @@ -113,6 +113,9 @@ def __init__(self, pos: int): super().__init__("W", pos, matrix=np.zeros((2, 2), dtype=complex)) self.matrix = (XGate(0).matrix + YGate(0).matrix)/np.sqrt(2) + def to_qasm(self): + return "rz(-pi/4) q[%d];\nrx(pi) q[%d];\nrz(pi/4) q[%d]" %(self.pos, self.pos, self.pos) + class SXGate(FixedSingleQubitGate): def __init__(self, pos: int): super().__init__("SX", pos, matrix=np.zeros((2, 2), dtype=complex)) @@ -125,6 +128,9 @@ def __init__(self, pos: int): self.matrix = sqrtm(YGate(0).matrix) self.symbol = "√Y" + def to_qasm(self): + return "ry(pi/2) q[%d]" %(self.pos) + class SWGate(FixedSingleQubitGate): def __init__(self, pos: int): super().__init__("SW", pos, matrix=np.zeros((2, 2), dtype=complex)) @@ -133,6 +139,9 @@ def __init__(self, pos: int): [np.sqrt(0.5), 0.5+ 0.5j]], dtype=complex) self.symbol = "√W" + def to_qasm(self): + return "rz(-pi/4) q[%d];\nrx(pi/2) q[%d];\nrz(pi/4) q[%d]" %(self.pos, self.pos, self.pos) + class RXGate(ParaSingleQubitGate): def __init__(self, pos: int, paras): super().__init__("RX", pos, paras, matrix=_rxmatrix) @@ -194,11 +203,16 @@ class CSGate(ControlledGate): def __init__(self, ctrl:int, targ:int): super().__init__("CS", "S", [ctrl], [targ], None, matrix=SGate(0).matrix) + def to_qasm(self): + return "cp(pi/2) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) class CTGate(ControlledGate): def __init__(self, ctrl:int, targ:int): super().__init__("CT", "T", [ctrl], [targ], None, matrix=TGate(0).matrix) + def to_qasm(self): + return "cp(pi/4) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) + class CPGate(ControlledGate): def __init__(self, ctrl:int, targ:int, paras): super().__init__("CP", "P", [ctrl], [targ], paras, matrix=PhaseGate(0, paras).matrix) diff --git a/src/quafu/elements/quantum_element.py b/src/quafu/elements/quantum_element.py index 9c83d0c..7bbb03d 100644 --- a/src/quafu/elements/quantum_element.py +++ b/src/quafu/elements/quantum_element.py @@ -30,6 +30,9 @@ def pos(self, pos): def __repr__(self): return f"{self.__class__.__name__}" + def to_qasm(self): + return "barrier " + ",".join(["q[%d]" % p for p in range(min(self.pos), max(self.pos)+1)]) + class Delay(object): def __init__(self, pos : int, duration : int, unit="ns"): self.name = "delay" @@ -44,6 +47,9 @@ def __init__(self, pos : int, duration : int, unit="ns"): def __repr__(self): return f"{self.__class__.__name__}" + def to_qasm(self): + return "delay(%d%s) q[%d]" % (self.duration, self.unit, self.pos) + class XYResonance(object): def __init__(self, qs : int, qe : int, duration : int, unit="ns"): self.name = "XY" @@ -55,6 +61,9 @@ def __init__(self, qs : int, qe : int, duration : int, unit="ns"): self.pos=list(range(qs, qe+1)) self.symbol = "XY(%d%s)" %(duration, unit) + def to_qasm(self): + return "xy(%d%s) " %(self.duration, self.unit) + ",".join(["q[%d]" % p for p in range(min(self.pos), max(self.pos)+1)]) + class QuantumGate(object): def __init__(self, name: str, pos: Union[int, List[int]], paras: Union[None,float, List[float]], matrix): self.name = name @@ -111,6 +120,21 @@ def __str__(self): def __repr__(self): return f"{self.__class__.__name__}" + def to_qasm(self): + qstr = "%s" %self.name.lower() + + if self.paras: + if isinstance(self.paras, Iterable): + qstr += "(" + ",".join(["%s" %para for para in self.paras]) + ")" + else: + qstr += "(%s)" %self.paras + qstr += " " + if isinstance(self.pos, Iterable): + qstr += ",".join(["q[%d]" % p for p in self.pos]) + else: + qstr += "q[%d]" %self.pos + + return qstr class SingleQubitGate(QuantumGate): def __init__(self, name: str, pos: int, paras, matrix): @@ -134,6 +158,7 @@ def matrix(self, matrix): def get_targ_matrix(self, reverse_order=False): return self.matrix + class FixedSingleQubitGate(SingleQubitGate): def __init__(self, name, pos, matrix): diff --git a/src/quafu/pulses/__init__.py b/src/quafu/pulses/__init__.py new file mode 100644 index 0000000..44e297c --- /dev/null +++ b/src/quafu/pulses/__init__.py @@ -0,0 +1,9 @@ +# !/usr/bin/env python +# -*- coding:utf-8 -*- + +# @File: __init__.py.py +# @Version: 1.0 +# @Author: Yun-Hao Shi +# @Email: yhshi@iphy.ac.cn +# @Reminders: |0> has been in the past, |1> is still in the future +# @License: Copyright (c) 2023, IOP, CAS diff --git a/src/quafu/pulses/quantum_pulse.py b/src/quafu/pulses/quantum_pulse.py new file mode 100644 index 0000000..e4b7854 --- /dev/null +++ b/src/quafu/pulses/quantum_pulse.py @@ -0,0 +1,266 @@ +# !/usr/bin/env python +# -*- coding:utf-8 -*- + +# @File: quantum_pulse.py +# @Version: 1.0 +# @Author: Yun-Hao Shi +# @Email: yhshi@iphy.ac.cn +# @Reminders: |0> has been in the past, |1> is still in the future +# @License: Copyright (c) 2023, IOP, CAS + +""" + +""" +from typing import Union, Optional, Callable, Dict +import matplotlib.pyplot as plt +import numpy as np +from copy import deepcopy +import scipy.special + + +class QuantumPulse(object): + def __init__(self, + pos: int, + duration: Union[float, int], + unit="ns", + name: str = "Pulse", + time_func: Optional[Callable] = None, + args: Optional[Dict] = None + ): + """ + Quantum Pulse for generating a quantum gate. + + Args: + pos (int): Qubit position. + duration (float, int): Pulse duration. + unit (str): Duration unit. + name (str): Pulse name. + time_func (callable): Time function of the pulse. + Where t=0 is the start, t=duration is the end of the pulse. + args (dict, optional): Other parameters of the pulse. + """ + self.pos = pos + self.duration = duration + self.unit = unit + self.name = name + self.time_func = time_func + self.args = args + self.paras = [1, None, 0.] + for v in self.args: + if v == "amp": + self.paras[0] = self.args["amp"] + elif v == "fwhm": + self.paras[1] = self.args["fwhm"] + elif v == "phase": + self.paras[2] = self.args["phase"] + + @property + def pos(self) -> int: + return self.__pos + + @pos.setter + def pos(self, _pos: int): + self.__pos = _pos + + @property + def name(self) -> str: + return self.__name + + @name.setter + def name(self, _name: str): + self.__name = str(_name) + + @property + def unit(self) -> str: + return self.__unit + + @unit.setter + def unit(self, _unit: str): + self.__unit = str(_unit) + + @property + def symbol(self): + return "%s(%d%s)" % (self.name, self.duration, self.unit) + + def __repr__(self): + return self.__str__() + + def __str__(self): + symbol = "%s(%d%s" % (self.name, self.duration, self.unit) + for para in self.paras: + symbol += ", %s" %para + symbol += ")" + return symbol + + def __call__(self, + t: Union[np.ndarray, float, int], + shift: Union[float, int] = 0., + offset: Union[float, int] = 0.): + """ + Return pulse data. + + Args: + t (np.ndarray, float, int): Time list. + shift (float, int): Time shift. + offset (float, int): Pulse amplitude offset. + """ + window = np.logical_and(0 <= t, t <= self.duration) + if self.args is None: + return window * self.time_func(t - shift) + else: + return window * self.time_func(t - shift, **self.args) + + def __copy__(self): + """ Return a deepcopy of the pulse """ + return deepcopy(self) + + def to_qasm(self): + return self.__str__() + " q[%d]" %self.pos + + def plot(self, + t: Optional[np.ndarray] = None, + shift: Union[float, int] = 0., + offset: Union[float, int] = 0., + plot_real: bool = True, + plot_imag: bool = True, + fig=None, + ax=None, + **plot_kws): + """ + Plot the pulse waveform. + + Args: + t (np.ndarray): Time list of the plot. + shift (float, int): Time shift of the pulse. + offset (float, int): Offset of the pulse. + plot_real (bool): Plot real of the pulse. + plot_imag (bool): Plot imag of the pulse. + fig (Figure): Figure of the plot. + ax (Axes): Axes of the plot. + plot_kws (dict, optional): Plot kwargs of `ax.plot`. + """ + if t is None: + t = np.linspace(0, self.duration, 101) + if ax is None: + fig, ax = plt.subplots(1, 1, num=fig) + pulse_data = self(t, shift=shift, offset=offset) + if plot_real: + ax.plot(np.real(pulse_data), label='real', **plot_kws) + if plot_imag: + ax.plot(np.imag(pulse_data), label='imag', **plot_kws) + ax.set_xlabel("Time (%s)" % self.unit) + ax.set_ylabel("Pulse Amp (a.u.)") + ax.legend() + plt.show() + + def set_pos(self, pos: int): + """ Set qubit position """ + self.pos = pos + return self + + def set_unit(self, unit="ns"): + """ Set duration unit """ + self.unit = unit + return self + + +def rect(pos: int, + duration: Union[int, float], + amp: Union[float, int], + unit: str = "ns"): + """ + Rectangular pulse. + + Args: + pos (int): Qubit position. + duration (float, int): Pulse duration. + amp (float, int): Amplitude of the pulse. + unit (str): Duration unit. + """ + + def rect_time_func(t, **kws): + amp_ = kws["amp"] + return amp_ * np.ones(np.array(t).shape) + + return QuantumPulse(pos=pos, + duration=duration, + unit=unit, + name="Rect", + time_func=rect_time_func, + args={"amp": float(amp)}) + + +def flattop(pos: int, + duration: Union[int, float], + amp: Union[float, int], + fwhm: Union[float, int] = 2, + unit: str = "ns"): + """ + Rectangular pulse with smooth (error-function-type) rise and fall. + + Args: + pos (int): Qubit position. + duration (float, int): Pulse duration. + amp (float, int): Amplitude of the pulse. + fwhm (float, int): Full width at half maximum. + unit (str): Duration unit. + """ + + def flattop_time_func(t, **kws): + amp_, fwhm_ = kws["amp"], kws["fwhm"] + sigma_ = fwhm_ / (2 * np.sqrt(np.log(2))) + return amp_ * (scipy.special.erf((duration - t) / sigma_) + + scipy.special.erf(t / sigma_) - 1.) + + return QuantumPulse(pos=pos, + duration=duration, + unit=unit, + name="Flattop", + time_func=flattop_time_func, + args={"amp": float(amp), "fwhm": float(fwhm)}) + + +def gaussian(pos: int, + duration: Union[int, float], + amp: Union[float, int], + fwhm: Optional[Union[float, int]] = None, + phase: Union[float, int] = 0., + unit: str = "ns"): + """ + Gaussian pulse. + + Args: + pos (int): Qubit position. + duration (float, int): Pulse duration. + amp (float, int): Amplitude of the pulse. + fwhm (float, int): Full width at half maximum, default: duration/2. + phase (int, float): pulse phase. + unit (str): Duration unit. + """ + amp = float(amp) + if fwhm is None: + fwhm = 0.5 * duration + + def gaussian_time_func(t, **kws): + amp_, fwhm_, phase_ = kws["amp"], kws["fwhm"], kws["phase"] + # start: t = 0, center: t = 0.5 * duration, end: t = duration + sigma_ = fwhm_ / np.sqrt(8 * np.log(2)) # fwhm to std. deviation + return amp_ * np.exp( + -(t - 0.5 * duration) ** 2 / (2 * sigma_ ** 2) + 1j * phase_) + + return QuantumPulse(pos=pos, + duration=duration, + unit=unit, + name="Gaussian", + time_func=gaussian_time_func, + args={"amp": amp, "fwhm": fwhm, "phase": phase}) + + +# def main(): +# # g = gaussian(0, 60, 1.2, phase=np.pi / 3) +# g = flattop(pos=0, duration=60, amp=1., fwhm=10) +# g.plot(shift=0) + + +# if __name__ == '__main__': +# main() diff --git a/src/quafu/qfasm/__init__.py b/src/quafu/qfasm/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/quafu/qfasm/qfasm_parser.py b/src/quafu/qfasm/qfasm_parser.py new file mode 100644 index 0000000..e49a7fc --- /dev/null +++ b/src/quafu/qfasm/qfasm_parser.py @@ -0,0 +1,69 @@ +import ply.yacc as yacc + +from quafu.elements.element_gates import * +from quafu.elements.quantum_element import * + +from qfasmlex import QfasmLexer +tokens = QfasmLexer.tokens + +instructions_map = { + "x": XGate, + "y": YGate, + "z": ZGate, + "h": HGate, + "s": SGate, + "sdg": SdgGate, + "t": TGate, + "tdg": TdgGate, + "rx": RXGate, + "ry": RYGate, + "rz": RZGate, + "id": IdGate, + "sx": SXGate, + "sy": SYGate, + "w": WGate, + "sw": SWGate, + "p": PhaseGate, + "delay": Delay, + "barrier": Barrier, + "cx": CXGate, + "cp": CPGate, + "swap": SwapGate, + "rxx": RXXGate, + "ryy": RYYGate, + "rzz": RZZGate, + "cy": CYGate, + "cz": CZGate, + "cs": CSGate, + "ct": CTGate, + "xy": XYResonance, + "ccx": ToffoliGate, + "cswap": FredkinGate, + "mcx": MCXGate, + "mcy": MCYGate, + "mcz": MCZGate, +} + + + +def p_id(p): + ''' id : ID''' + p[0] = p[1] + + +# def p_gate_like(p): +# '''gate : id qubit_list +# | id'('arg_list') qubit_list' +# ''' +# #initialize the gate +# instruction = instructions_map[p[1]] +# p[0] = instruction() + +# def p_pulse_like(p): + +# def p_arg(p): +# """ +# arg : expression +# | arg, expression +# """ +# p[0] \ No newline at end of file diff --git a/src/quafu/qfasm/qfasmlex.py b/src/quafu/qfasm/qfasmlex.py new file mode 100644 index 0000000..06baad6 --- /dev/null +++ b/src/quafu/qfasm/qfasmlex.py @@ -0,0 +1,81 @@ +# Qfasm is modified OPENQASM 2.0. Currently it is mainly used to +# transfer circuit data to backends. Further it will +# support more instructions (classical or quantum) to enable +# interaction with quantum hardware + +import ply.lex as lex +import numpy as np + +class QfasmLexer(object): + literals = r'=()[]{};<>,.+-/*^"' + + reserved = { + "creg" : "CREG", + "qreg" : "QREG", + "pi" : "PI", + "measure" : "MEASURE", + "none" : "NONE" + } + + tokens = [ + "FLOAT", + "INT", + "ASSIGN", + "MATCHES", + "ID", + "UNIT", + ] + list(reserved.values()) + + def t_FLOAT(self, t): + r"(([1-9]\d*\.\d*)|(0\.\d*[1-9]\d*))" + t.value = float(t.value) + return t + + def t_INT(self, t): + r"\d+" + t.value = int(t.value) + return t + + + def ASSIGN(self, t): + r"->" + return t + + def t_MATCHES(self, t): + r"==" + return t + + def t_UNIT(self, t): + r"ns|us" + return t + + def t_ID(self, t): + r"[a-z][a-zA-Z0-9_]*" + t.type = self.reserved.get(t.value, "ID") + return t + + t_ignore=" \t\r" + + def t_error(self, t): + print("Illegal character '%s'" %t.value[0]) + t.lexer.skip(1) + + def t_newline(self, t): + r"\n+" + t.lexer.lineno += len(t.value) + + def build(self, **kwargs): + self.lexer = lex.lex(module=self, **kwargs) + + def test(self, data): + self.lexer.input(data) + while True: + tok = self.lexer.token() + if not tok: + break + print(tok) + +if __name__ == "__main__": + m = QfasmLexer() + m.build() + m.test("rx(21ns, pi) q[0], q[1]") \ No newline at end of file diff --git a/src/quafu/qfasm/qfasmlex_test.py b/src/quafu/qfasm/qfasmlex_test.py new file mode 100644 index 0000000..acd4b74 --- /dev/null +++ b/src/quafu/qfasm/qfasmlex_test.py @@ -0,0 +1,2 @@ +from qfasmlex import QfasmLexer + diff --git a/src/quafu/tasks/tasks.py b/src/quafu/tasks/tasks.py index 7221153..c0db6c7 100644 --- a/src/quafu/tasks/tasks.py +++ b/src/quafu/tasks/tasks.py @@ -1,40 +1,41 @@ -import os from typing import Dict, List, Tuple - from quafu.circuits.quantum_circuit import QuantumCircuit -from quafu.users.userapi import load_account, get_backends_info from ..exceptions import CircuitError, ServerError, CompileError from ..results.results import ExecResult, merge_measure -from ..backends.backends import Backend from ..users.exceptions import UserError import numpy as np import json import requests from urllib import parse -import re +from quafu.users.userapi import User +from quafu.backends.backends import Backend import copy -import networkx as nx -import matplotlib.pyplot as plt class Task(object): """ Class for submitting quantum computation task to the backend. Attributes: - token (str): Apitoken that associate to your Quafu account. shots (int): Numbers of single shot measurement. compile (bool): Whether compile the circuit on the backend tomo (bool): Whether do tomography (Not support yet) + user (User): User object corresponding to Quafu account + priority (int): priority level of the task + submit_history (dict): circuit submitted with this task + backend (dict): quantum backend that execute the task. + """ - def __init__(self): + def __init__(self, user = User()): + self.user = user self.shots = 1000 self.tomo = False self.compile = True - self.priority = 2 + self.priority = self.user.priority self.submit_history = { } - self.token, self._url = load_account() - self._available_backends = {info["system_name"]:Backend(info) for info in get_backends_info()} + self._available_backends = self.user.get_available_backends(print_info=False) self.backend = self._available_backends[list(self._available_backends.keys())[0]] + + def config(self, backend: str="ScQ-P10", @@ -70,6 +71,8 @@ def get_history(self) -> Dict: """ return self.submit_history + + def get_backend_info(self) -> Dict: """ Get the calibration information of the experimental backend. @@ -77,7 +80,7 @@ def get_backend_info(self) -> Dict: Returns: Backend information dictionary containing the mapping from the indices to the names of physical bits `'mapping'`, backend topology `'topology_diagram'` and full calibration inforamtion `'full_info'`. """ - return self.backend.get_chip_info() + return self.backend.get_chip_info(self.user) def submit(self, qc: QuantumCircuit, @@ -186,11 +189,11 @@ def send(self, "compile": int(self.compile), "priority": self.priority, "task_name": name, "pyquafu_version": version} if wait: - url = self._url + "qbackend/scq_kit/" + url = self.user._url + self.user.exec_api else: - url = self._url + "qbackend/scq_kit_asyc/" + url = self.user._url + self.user.exec_async_api - headers = {'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8', 'api_token': self.token} + headers = {'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8', 'api_token': self.user.apitoken} data = parse.urlencode(data) data = data.replace("%27", "'") res = requests.post(url, headers=headers, data=data) @@ -222,7 +225,7 @@ def retrieve(self, taskid: str) -> ExecResult: taskid: The taskid of the task need to be retrieved. """ data = {"task_id" : taskid} - url = self._url + "qbackend/scq_task_recall/" + url = self.user._url + self.user.exec_recall_api headers = {'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8', 'api_token': self.token} res = requests.post(url, headers=headers, data=data) diff --git a/src/quafu/users/userapi.py b/src/quafu/users/userapi.py index 071cfae..e899446 100644 --- a/src/quafu/users/userapi.py +++ b/src/quafu/users/userapi.py @@ -5,10 +5,21 @@ from urllib import parse from .exceptions import UserError + class User(object): def __init__(self): self.apitoken = "" - + self._url = "http://quafu.baqis.ac.cn/" + self.load_account() + + self.backends_api = "qbackend/get_backends/" + self.chip_api = "qbackend/scq_get_chip_info/" + self.exec_api = "qbackend/scq_kit/" + self.exec_async_api = "qbackend/scq_kit_asyc/" + self.exec_recall_api = "qbackend/scq_task_recall/" + self.priority = 2 + + def save_apitoken(self, apitoken): """ Save your apitoken associate your Quafu account. @@ -22,26 +33,42 @@ def save_apitoken(self, apitoken): f.write(self.apitoken+"\n") f.write("http://quafu.baqis.ac.cn/") -def load_account(): - """ - Load Quafu account. - """ - homedir = get_homedir() - file_dir = homedir + "/.quafu/" - try: - f = open(file_dir + "api", "r") - data = f.readlines() - token = data[0].strip("\n") - url = data[1].strip("\n") - return token, url - except: - raise UserError("User configure error. Please set up your token.") - -def get_backends_info(): - """ - Get available backends information - """ - token, _url = load_account() - backends_info = requests.post(url=_url+"qbackend/get_backends/", headers={"api_token" : token}) - backends_dict = json.loads(backends_info.text) - return backends_dict["data"] + def load_account(self): + """ + Load Quafu account. + """ + homedir = get_homedir() + file_dir = homedir + "/.quafu/" + try: + f = open(file_dir + "api", "r") + data = f.readlines() + token = data[0].strip("\n") + url = data[1].strip("\n") + self.apitoken = token + return token, url + except: + raise UserError("User configure error. Please set up your token.") + + def get_backends_info(self): + """ + Get available backends information + """ + + backends_info = requests.post(url=self._url+self.backends_api, headers={"api_token" : self.apitoken}) + backends_info_dict = json.loads(backends_info.text) + if backends_info_dict["status"] == 201: + raise UserError(backends_info_dict["message"]) + else: + return backends_info_dict["data"] + + def get_available_backends(self, print_info=True): + from quafu.backends.backends import Backend + backends_info = self.get_backends_info() + self._available_backends = {info["system_name"]:Backend(info) for info in backends_info} + + if print_info: + print((" "*5).join(["system_name".ljust(10), "qubits".ljust(10), "status".ljust(10)])) + for backend in self._available_backends.values(): + print((" "*5).join([backend.name.ljust(10), str(backend.qubit_num).ljust(10), backend.status.ljust(10)])) + + return self._available_backends \ No newline at end of file From 745b73164cc9cf8522e6d534d68b4cc42a4c0422 Mon Sep 17 00:00:00 2001 From: YuChen Date: Tue, 25 Apr 2023 15:34:54 +0800 Subject: [PATCH 14/70] =?UTF-8?q?=E4=BC=98=E5=8C=96=E4=BA=86gate=5Fto=5Fno?= =?UTF-8?q?de=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/quafu/dagcircuits/circuit_dag.py | 27 +++++++++------------------ 1 file changed, 9 insertions(+), 18 deletions(-) diff --git a/src/quafu/dagcircuits/circuit_dag.py b/src/quafu/dagcircuits/circuit_dag.py index 78c1cad..0d24d6c 100644 --- a/src/quafu/dagcircuits/circuit_dag.py +++ b/src/quafu/dagcircuits/circuit_dag.py @@ -8,7 +8,7 @@ from typing import Dict, Any, List, Union import copy -from instruction_node import InstructionNode # instruction_node.py in the same folder as circuit_dag.py now +from instruction_node import InstructionNode # instruction_node.py in the same folder as circuit_dag.py now import pygraphviz as pgv from networkx.drawing.nx_pydot import write_dot @@ -17,7 +17,7 @@ # transform a gate in quantumcircuit of quafu(not include measure_gate), -# to a node in the graph, with specific label. +# into a node in the graph, with specific label. def gate_to_node(input_gate,specific_label: str): ''' transform a gate in quantumcircuit of quafu(not include measure_gate), @@ -34,25 +34,16 @@ def gate_to_node(input_gate,specific_label: str): import copy gate = copy.deepcopy(input_gate) # avoid modifying the original gate - if type(gate.pos) != list: # if gate.pos is not a list, make it a list + if not isinstance(gate.pos, list): # if gate.pos is not a list, make it a list gate.pos = [gate.pos] - # use getattr check 'paras' and other attributes if exist. if the attr doesn't exist,return None - paras = getattr(gate, 'paras', None) - # matrix = getattr(gate, 'matrix', None) - duration = getattr(gate, 'duration', None) - unit = getattr(gate, 'unit', None) - if paras is None: - gate.paras = None - elif type(gate.paras) != list: # if paras is not a list, make it a list - gate.paras = [gate.paras] - # if matrix is None: - # gate.matrix = None - if duration is None: - gate.duration = None - if unit is None: - gate.unit = None + gate.paras = getattr(gate, 'paras', None) or None + gate.duration = getattr(gate, 'duration', None) or None + gate.unit = getattr(gate, 'unit', None) or None + + if gate.paras and not isinstance(gate.paras, list): # if paras is True and not a list, make it a list + gate.paras = [gate.paras] # hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.matrix,gate.duration,gate.unit, label=i) hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.duration,gate.unit, label=specific_label) From 4c090c0cea9407902b898487864d3a003451816f Mon Sep 17 00:00:00 2001 From: lss0208 <382715246@qq.com> Date: Thu, 27 Apr 2023 17:55:00 +0800 Subject: [PATCH 15/70] add parser;modify pulse --- src/quafu/circuits/quantum_circuit.py | 165 +------------ src/quafu/dagcircuits/circuit_dag.py | 30 ++- src/quafu/elements/quantum_element.py | 8 +- src/quafu/pulses/quantum_pulse.py | 224 ++++++------------ src/quafu/qfasm/qfasm_convertor.py | 31 +++ src/quafu/qfasm/qfasm_parser.py | 324 +++++++++++++++++++++----- src/quafu/qfasm/qfasmlex.py | 38 ++- src/quafu/qfasm/qfasmlex_test.py | 2 - 8 files changed, 436 insertions(+), 386 deletions(-) create mode 100644 src/quafu/qfasm/qfasm_convertor.py delete mode 100644 src/quafu/qfasm/qfasmlex_test.py diff --git a/src/quafu/circuits/quantum_circuit.py b/src/quafu/circuits/quantum_circuit.py index dca37a1..99c9cea 100644 --- a/src/quafu/circuits/quantum_circuit.py +++ b/src/quafu/circuits/quantum_circuit.py @@ -1,7 +1,7 @@ from typing import Iterable import numpy as np from ..elements.quantum_element import Barrier, Delay, ControlledGate, MultiQubitGate, ParaMultiQubitGate, QuantumGate, SingleQubitGate, XYResonance -from quafu.pulses.quantum_pulse import QuantumPulse, gaussian, flattop, rect +from quafu.pulses.quantum_pulse import QuantumPulse from ..elements.element_gates import * from ..exceptions import CircuitError @@ -172,168 +172,7 @@ def draw_circuit(self, width : int=4, return_str : bool=False): return circuitstr else: print(circuitstr) - - def from_openqasm(self, openqasm : str): - """ - Initialize the circuit from openqasm text. - Args: - openqasm: input openqasm str. - """ - from numpy import pi - import re - self.openqasm = openqasm - # lines = self.openqasm.strip("\n").splitlines(";") - lines = self.openqasm.splitlines() - lines = [line for line in lines if line] - self.gates = [] - self.measures = {} - measured_qubits = [] - global_valid = True - for line in lines[2:]: - if line: - operations_qbs = line.split(" ", 1) - operations = operations_qbs[0] - if operations == "qreg": - qbs = operations_qbs[1] - self.num = int(re.findall("\d+", qbs)[0]) - elif operations == "creg": - pass - elif operations == "measure": - qbs = operations_qbs[1] - indstr = re.findall("\d+", qbs) - inds = [int(indst) for indst in indstr] - mb = inds[0] - cb = inds[1] - self.measures[mb] = cb - measured_qubits.append(mb) - else: - qbs = operations_qbs[1] - indstr = re.findall("\d+", qbs) - inds = [int(indst) for indst in indstr] - valid = True - for pos in inds: - if pos in measured_qubits: - valid = False - global_valid = False - break - - if valid: - if operations == "barrier": - self.barrier(inds) - - else: - sp_op = operations.split("(") - # print("sp_op: ", sp_op) - gatename = sp_op[0] - if gatename == "delay" : - paras = sp_op[1].strip("()") - duration = int(re.findall("\d+", paras)[0]) - unit = re.findall("[a-z]+", paras)[0] - self.delay(inds[0], duration, unit) - - elif gatename in ["Rect", "Flattop", "Gaussian"]: - paras = sp_op[1].strip("()") - print(paras) - parastr = paras.split(",") - duration = int(re.findall("\d+", parastr[0])[0]) - unit = re.findall("[a-z]+", parastr[0])[0] - - extra_para = line.split(",")[1:] - para_e, indstr = extra_para[-1].split(")") - parastr = extra_para[:-1] - parastr.append(para_e) - ind = int(re.findall("\d+", indstr)[0]) - - paras = [eval(parai, {"pi": pi}) for parai in parastr] - - if gatename == "Rect": - pulse = rect(ind, duration=duration, amp=paras[0] ,unit=unit) - self.add_pulse(pulse) - elif gatename == "Flattop": - pulse = flattop(ind, duration=duration, amp=paras[0], fwhm=paras[1], unit=unit) - self.add_pulse(pulse) - - elif gatename == "Gaussian": - pulse = gaussian(ind, duration=duration, amp=paras[0], fwhm=paras[1], phase=paras[2], unit=unit) - self.add_pulse(pulse) - - elif gatename == "xy": - paras = sp_op[1].strip("()") - duration = int(re.findall("\d+", paras)[0]) - unit = re.findall("[a-z]+", paras)[0] - self.xy(min(inds), max(inds), duration, unit) - else: - if len(sp_op) > 1: - paras = sp_op[1].strip("()") - parastr = paras.split(",") - paras = [eval(parai, {"pi": pi}) for parai in parastr] - - if gatename == "cx": - self.cnot(inds[0], inds[1]) - elif gatename == "cy": - self.cy(inds[0], inds[1]) - elif gatename == "cz": - self.cz(inds[0], inds[1]) - elif gatename == "cp": - self.cp(inds[0], inds[1], paras[0]) - elif gatename == "swap": - self.swap(inds[0], inds[1]) - elif gatename == "rx": - self.rx(inds[0], paras[0]) - elif gatename == "ry": - self.ry(inds[0], paras[0]) - elif gatename == "rz": - self.rz(inds[0], paras[0]) - elif gatename == "p": - self.p(inds[0], paras[0]) - elif gatename == "x": - self.x(inds[0]) - elif gatename == "y": - self.y(inds[0]) - elif gatename == "z": - self.z(inds[0]) - elif gatename == "h": - self.h(inds[0]) - elif gatename == "id": - self.id(inds[0]) - elif gatename == "s": - self.s(inds[0]) - elif gatename == "sdg": - self.sdg(inds[0]) - elif gatename == "t": - self.t(inds[0]) - elif gatename == "tdg": - self.tdg(inds[0]) - elif gatename == "sx": - self.sx(inds[0]) - elif gatename == "ccx": - self.toffoli(inds[0], inds[1], inds[2]) - elif gatename == "cswap": - self.fredkin(inds[0], inds[1], inds[2]) - elif gatename == "u1": - self.rz(inds[0], paras[0]) - elif gatename == "u2": - self.rz(inds[0], paras[1]) - self.ry(inds[0], pi / 2) - self.rz(inds[0], paras[0]) - elif gatename == "u3": - self.rz(inds[0], paras[2]) - self.ry(inds[0], paras[0]) - self.rz(inds[0], paras[1]) - elif gatename == "rxx": - self.rxx(inds[0], inds[1], paras[0]) - elif gatename == "ryy": - self.ryy(inds[0], inds[1], paras[0]) - elif gatename == "rzz": - self.rzz(inds[0], inds[1], paras[0]) - else: - print( - "Warning: Operations %s may be not supported by QuantumCircuit class currently." % gatename) - - if not self.measures: - self.measures = dict(zip(range(self.num), range(self.num))) - if not global_valid: - print("Warning: All operations after measurement will be removed for executing on experiment") + def to_openqasm(self) -> str: """ diff --git a/src/quafu/dagcircuits/circuit_dag.py b/src/quafu/dagcircuits/circuit_dag.py index 78c1cad..2d2a8f0 100644 --- a/src/quafu/dagcircuits/circuit_dag.py +++ b/src/quafu/dagcircuits/circuit_dag.py @@ -2,15 +2,16 @@ from quafu import QuantumCircuit from quafu.elements.element_gates import * -from quafu.elements.quantum_element import Barrier, Delay, ControlledGate, MultiQubitGate, ParaMultiQubitGate, QuantumGate, SingleQubitGate, XYResonance +from quafu.elements.quantum_element import Barrier, Delay, Measure, XYResonance +from quafu.pulses.quantum_pulse import GaussianPulse, RectPulse, FlattopPulse import networkx as nx from typing import Dict, Any, List, Union import copy -from instruction_node import InstructionNode # instruction_node.py in the same folder as circuit_dag.py now +from .instruction_node import InstructionNode # instruction_node.py in the same folder as circuit_dag.py now -import pygraphviz as pgv +# import pygraphviz as pgv from networkx.drawing.nx_pydot import write_dot from IPython.display import Image, SVG @@ -55,7 +56,7 @@ def gate_to_node(input_gate,specific_label: str): gate.unit = None # hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.matrix,gate.duration,gate.unit, label=i) - hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.duration,gate.unit, label=specific_label) + hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.duration, gate.unit, label=specific_label) return hashable_gate @@ -166,6 +167,7 @@ def circuit_to_dag(circuit): "delay": Delay, "barrier": Barrier, "cx": CXGate, + "cnot": CXGate, "cp": CPGate, "swap": SwapGate, "rxx": RXXGate, @@ -177,10 +179,16 @@ def circuit_to_dag(circuit): "ct": CTGate, "xy": XYResonance, "ccx": ToffoliGate, + "toffoli": ToffoliGate, "cswap": FredkinGate, + "fredkin": FredkinGate, "mcx": MCXGate, "mcy": MCYGate, "mcz": MCZGate, + "gaussian": GaussianPulse, + "rect" : RectPulse, + "flattop" : FlattopPulse, + "measure" : Measure } def node_to_gate(gate_in_dag): @@ -240,6 +248,20 @@ def node_to_gate(gate_in_dag): target_qubit = gate_in_dag.pos[-1] return gate_class(control_qubits, target_qubit) + # pulse node + if gate_name in ["gaussian", "rect", "flattop"]: + duration = gate_in_dag.duration + unit = gate_in_dag.unit + paras = gate_in_dag.paras + pos = gate_in_dag.pos[0] + channel = gate_in_dag.label + + return gate_class(pos, *paras, duration, unit, channel) + + # measure node + if gate_name == "measure": + return gate_class(gate_in_dag.pos) + return gate_class(*args) diff --git a/src/quafu/elements/quantum_element.py b/src/quafu/elements/quantum_element.py index 7bbb03d..a04e639 100644 --- a/src/quafu/elements/quantum_element.py +++ b/src/quafu/elements/quantum_element.py @@ -13,6 +13,7 @@ def reorder_matrix(matrix : np.ndarray, pos : List): tensorm = matrix.reshape([2]*2*qnum) return np.transpose(tensorm, inds).reshape([dim, dim]) + class Barrier(object): def __init__(self, pos): self.name = "barrier" @@ -63,7 +64,12 @@ def __init__(self, qs : int, qe : int, duration : int, unit="ns"): def to_qasm(self): return "xy(%d%s) " %(self.duration, self.unit) + ",".join(["q[%d]" % p for p in range(min(self.pos), max(self.pos)+1)]) - + +class Measure(object): + def __init__(self, bitmap : dict): + self.qbits = bitmap.keys() + self.cbits = bitmap.values() + class QuantumGate(object): def __init__(self, name: str, pos: Union[int, List[int]], paras: Union[None,float, List[float]], matrix): self.name = name diff --git a/src/quafu/pulses/quantum_pulse.py b/src/quafu/pulses/quantum_pulse.py index e4b7854..407ad4e 100644 --- a/src/quafu/pulses/quantum_pulse.py +++ b/src/quafu/pulses/quantum_pulse.py @@ -1,83 +1,45 @@ -# !/usr/bin/env python -# -*- coding:utf-8 -*- - -# @File: quantum_pulse.py -# @Version: 1.0 -# @Author: Yun-Hao Shi -# @Email: yhshi@iphy.ac.cn -# @Reminders: |0> has been in the past, |1> is still in the future -# @License: Copyright (c) 2023, IOP, CAS - -""" - -""" from typing import Union, Optional, Callable, Dict import matplotlib.pyplot as plt import numpy as np from copy import deepcopy import scipy.special - class QuantumPulse(object): def __init__(self, - pos: int, - duration: Union[float, int], - unit="ns", - name: str = "Pulse", - time_func: Optional[Callable] = None, - args: Optional[Dict] = None + name:str, + pos: Union[int, list], + paras: list, + duration: Union[float,int], + unit: str, + channel: str, + time_func: Optional[Callable] = None, ): """ Quantum Pulse for generating a quantum gate. Args: + name (str): Pulse name pos (int): Qubit position. + paras (list): Parameters of the pulse. duration (float, int): Pulse duration. unit (str): Duration unit. name (str): Pulse name. time_func (callable): Time function of the pulse. Where t=0 is the start, t=duration is the end of the pulse. - args (dict, optional): Other parameters of the pulse. + """ + + self.name = name self.pos = pos + self.paras = paras self.duration = duration self.unit = unit - self.name = name self.time_func = time_func - self.args = args - self.paras = [1, None, 0.] - for v in self.args: - if v == "amp": - self.paras[0] = self.args["amp"] - elif v == "fwhm": - self.paras[1] = self.args["fwhm"] - elif v == "phase": - self.paras[2] = self.args["phase"] - - @property - def pos(self) -> int: - return self.__pos - - @pos.setter - def pos(self, _pos: int): - self.__pos = _pos - - @property - def name(self) -> str: - return self.__name - - @name.setter - def name(self, _name: str): - self.__name = str(_name) - - @property - def unit(self) -> str: - return self.__unit - - @unit.setter - def unit(self, _unit: str): - self.__unit = str(_unit) - + if channel in ["XY", "Z"]: + self.channel = channel + else: + raise ValueError("channel must be 'XY' or 'Z'") + @property def symbol(self): return "%s(%d%s)" % (self.name, self.duration, self.unit) @@ -89,13 +51,16 @@ def __str__(self): symbol = "%s(%d%s" % (self.name, self.duration, self.unit) for para in self.paras: symbol += ", %s" %para + symbol += ", %s" %self.channel symbol += ")" return symbol def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0., - offset: Union[float, int] = 0.): + offset: Union[float, int] = 0., + args : dict = None + ): """ Return pulse data. @@ -105,10 +70,10 @@ def __call__(self, offset (float, int): Pulse amplitude offset. """ window = np.logical_and(0 <= t, t <= self.duration) - if self.args is None: + if args is None: return window * self.time_func(t - shift) else: - return window * self.time_func(t - shift, **self.args) + return window * self.time_func(t - shift, **args) def __copy__(self): """ Return a deepcopy of the pulse """ @@ -164,103 +129,64 @@ def set_unit(self, unit="ns"): return self -def rect(pos: int, - duration: Union[int, float], - amp: Union[float, int], - unit: str = "ns"): - """ - Rectangular pulse. - - Args: - pos (int): Qubit position. - duration (float, int): Pulse duration. - amp (float, int): Amplitude of the pulse. - unit (str): Duration unit. - """ - - def rect_time_func(t, **kws): - amp_ = kws["amp"] - return amp_ * np.ones(np.array(t).shape) - - return QuantumPulse(pos=pos, - duration=duration, - unit=unit, - name="Rect", - time_func=rect_time_func, - args={"amp": float(amp)}) +class RectPulse(QuantumPulse): + def __init__(self, pos, amp, duration, unit ,channel): + self.amp = amp + def rect_time_func(t, **kws): + amp_ = kws["amp"] + return amp_ * np.ones(np.array(t).shape) -def flattop(pos: int, - duration: Union[int, float], - amp: Union[float, int], - fwhm: Union[float, int] = 2, - unit: str = "ns"): - """ - Rectangular pulse with smooth (error-function-type) rise and fall. + super().__init__("rect", pos, [amp], duration, unit, channel, rect_time_func) - Args: - pos (int): Qubit position. - duration (float, int): Pulse duration. - amp (float, int): Amplitude of the pulse. - fwhm (float, int): Full width at half maximum. - unit (str): Duration unit. - """ - def flattop_time_func(t, **kws): - amp_, fwhm_ = kws["amp"], kws["fwhm"] - sigma_ = fwhm_ / (2 * np.sqrt(np.log(2))) - return amp_ * (scipy.special.erf((duration - t) / sigma_) - + scipy.special.erf(t / sigma_) - 1.) + def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): + args = {"amp": self.amp} + return super().__call__(t, shift, offset, args) - return QuantumPulse(pos=pos, - duration=duration, - unit=unit, - name="Flattop", - time_func=flattop_time_func, - args={"amp": float(amp), "fwhm": float(fwhm)}) +class FlattopPulse(QuantumPulse): + def __init__(self, pos, amp, fwhm, duration, unit ,channel): + self.amp = amp + self.fwhm = fwhm + def flattop_time_func(t, **kws): + amp_, fwhm_ = kws["amp"], kws["fwhm"] + sigma_ = fwhm_ / (2 * np.sqrt(np.log(2))) + return amp_ * (scipy.special.erf((duration - t) / sigma_) + + scipy.special.erf(t / sigma_) - 1.) -def gaussian(pos: int, - duration: Union[int, float], - amp: Union[float, int], - fwhm: Optional[Union[float, int]] = None, - phase: Union[float, int] = 0., - unit: str = "ns"): - """ - Gaussian pulse. + super().__init__("flattop", pos, [amp, fwhm], duration, unit, channel, flattop_time_func) - Args: - pos (int): Qubit position. - duration (float, int): Pulse duration. - amp (float, int): Amplitude of the pulse. - fwhm (float, int): Full width at half maximum, default: duration/2. - phase (int, float): pulse phase. - unit (str): Duration unit. - """ - amp = float(amp) - if fwhm is None: - fwhm = 0.5 * duration - def gaussian_time_func(t, **kws): - amp_, fwhm_, phase_ = kws["amp"], kws["fwhm"], kws["phase"] - # start: t = 0, center: t = 0.5 * duration, end: t = duration - sigma_ = fwhm_ / np.sqrt(8 * np.log(2)) # fwhm to std. deviation - return amp_ * np.exp( - -(t - 0.5 * duration) ** 2 / (2 * sigma_ ** 2) + 1j * phase_) + def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): + args = {"amp": self.amp, "fwhm": self.fwhm} + return super().__call__(t, shift, offset, args) - return QuantumPulse(pos=pos, - duration=duration, - unit=unit, - name="Gaussian", - time_func=gaussian_time_func, - args={"amp": amp, "fwhm": fwhm, "phase": phase}) - - -# def main(): -# # g = gaussian(0, 60, 1.2, phase=np.pi / 3) -# g = flattop(pos=0, duration=60, amp=1., fwhm=10) -# g.plot(shift=0) - - -# if __name__ == '__main__': -# main() +class GaussianPulse(QuantumPulse): + def __init__(self, pos, amp, fwhm, phase, duration, unit ,channel): + self.amp = amp + if fwhm == None: + self.fwhm = 0.5 * duration + else: + self.fwhm = fwhm + + self.phase = phase + + def gaussian_time_func(t, **kws): + amp_, fwhm_, phase_ = kws["amp"], kws["fwhm"], kws["phase"] + # start: t = 0, center: t = 0.5 * duration, end: t = duration + sigma_ = fwhm_ / np.sqrt(8 * np.log(2)) # fwhm to std. deviation + return amp_ * np.exp( + -(t - 0.5 * duration) ** 2 / (2 * sigma_ ** 2) + 1j * phase_) + + super().__init__("gaussian", pos, [amp, fwhm, phase], duration, unit, channel, gaussian_time_func) + + def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): + args = {"amp": self.amp, "fwhm": self.fwhm, "phase":self.phase} + return super().__call__(t, shift, offset, args) + +if __name__ == '__main__': + p = GaussianPulse(0, amp=1.2, fwhm=None, phase=np.pi/3, duration=60, unit="ns", channel="XY") + # p = FlattopPulse(0, amp=1., fwhm=10, duration=60, unit="ns", channel="XY") + p.plot(shift=0) + print(p.to_qasm()) \ No newline at end of file diff --git a/src/quafu/qfasm/qfasm_convertor.py b/src/quafu/qfasm/qfasm_convertor.py new file mode 100644 index 0000000..4e6ddb0 --- /dev/null +++ b/src/quafu/qfasm/qfasm_convertor.py @@ -0,0 +1,31 @@ + +from .qfasm_parser import QfasmParser, QregNode +from quafu.dagcircuits.circuit_dag import node_to_gate +from quafu.dagcircuits.instruction_node import InstructionNode +from quafu import QuantumCircuit + + +def qasm_to_circuit(qasm): + parser = QfasmParser() + parser.parse(qasm) + nodes = parser.parsed_nodes + + n = 0 + gates = [] + measures = {} + for node in nodes: + if isinstance(node, QregNode): + n = node.n + if isinstance(node, InstructionNode): + if node.name == "measure": + for q, c in zip(node.pos.keys(), node.pos.values()): + measures[q] = c + else: + gates.append(node_to_gate(node)) + + q = QuantumCircuit(n) + q.gates = gates + q.openqasm = qasm + q.measures = measures + return q + diff --git a/src/quafu/qfasm/qfasm_parser.py b/src/quafu/qfasm/qfasm_parser.py index e49a7fc..a7d1eaf 100644 --- a/src/quafu/qfasm/qfasm_parser.py +++ b/src/quafu/qfasm/qfasm_parser.py @@ -1,69 +1,267 @@ + import ply.yacc as yacc from quafu.elements.element_gates import * from quafu.elements.quantum_element import * +from quafu.dagcircuits.instruction_node import InstructionNode +from .qfasmlex import QfasmLexer + +# import numpy as np + +class DeclarationNode(object): + pass + +class QregNode(DeclarationNode): + def __init__(self, n): + self.n = n + + def __repr__(self): + return self.__str__() + + def __str__(self): + return "qreg[%d]" %self.n + +class CregNode(DeclarationNode): + def __init__(self, n): + self.n = n + + def __repr__(self): + return self.__str__() + + def __str__(self): + return "creg[%d]" %self.n + +class IncludeNode(DeclarationNode): + def __init__(self, filename): + self.file = filename + + def __repr__(self): + return self.__str__() + + def __str__(self): + return "include %s" %self.file + +class OPENQASMNode(DeclarationNode): + def __init__(self, version): + self.version = version + + def __repr__(self): + return self.__str__() + + def __str__(self): + return "OPENQASM %.1f" %self.version + + +class QfasmParser(object): + tokens = QfasmLexer.tokens + def __init__(self, debug=False): + self.parser = yacc.yacc(module=self, debug=debug) + self.parsed_nodes = [] + self.lexer = QfasmLexer() + + def parse(self, input : str): + self.parsed_nodes = self.parser.parse(input, lexer=QfasmLexer()) + + def p_main_0(self, p): + """ + main : program + """ + p[0] = [p[1]] + + def p_main_1(self, p): + """ + main : main program + """ + p[1].append(p[2]) + p[0] = p[1] + + def p_program(self, p): + """ + program : instruction + | declaration + """ + p[0] = p[1] + + def p_declaration(self, p): + """ + declaration : openqasm + | include + | qreg + | creg + """ + p[0] = p[1] + + def p_openqasm(self, p): + """ + openqasm : OPENQASM FLOAT ';' + """ + p[0] = OPENQASMNode(p[2]) + + def p_include(self, p): + """ + include : INCLUDE STRING ';' + """ + p[0] = IncludeNode(p[2]) + + def p_qreg(self, p): #TODO:verify register name + """ + qreg : QREG bitreg ';' + """ + p[0] = QregNode(p[2]) + + def p_creg(self, p): + """ + creg : CREG bitreg ';' + """ + p[0] = CregNode(p[2]) + + def p_instruction(self, p): + """ + instruction : gate ';' + | pulse ';' + | measure ';' + """ + p[0] = p[1] + + + def p_arg_list_0(self, p): + """ + arg_list : expression + """ + p[0] = [p[1]] + + def p_arg_list_1(self, p): + """ + arg_list : arg_list ',' expression + """ + p[1].append(p[3]) + p[0] = p[1] + + def p_gate_like_0(self, p): + ''' + gate : id qubit_list + ''' + p[0] = InstructionNode(p[1], p[2], None, None, None, "") + + def p_gate_like_1(self, p): + ''' + gate : id '(' arg_list ')' qubit_list + ''' + p[0] = InstructionNode(p[1], p[5], p[3], None, None, "") + + def p_pulse_like_0(self, p): + ''' + pulse : id '(' time ',' arg_list ')' qubit_list + ''' + p[0] = InstructionNode(p[1], p[7], p[5], p[3][0], p[3][1], "") + + def p_measure_0(self, p): + ''' + measure : MEASURE bitreg ASSIGN bitreg + ''' + p[0] = InstructionNode("measure", {p[2] : p[4]}, None, None, None, "") + + def p_pulse_like_1(self, p): + ''' + pulse : id '(' time ',' arg_list ',' channel ')' qubit_list + ''' + p[0] = InstructionNode(p[1], p[9], p[5], p[3][0], p[3][1], p[7]) + + def p_bitreg(self, p): + """ + bitreg : id '[' INT ']' + """ + p[0] = p[3] + + def p_qubit_list_0(self, p): + """ + qubit_list : bitreg + """ + p[0] = [p[1]] + + def p_qubit_list_1(self, p): + """ + qubit_list : qubit_list ',' bitreg + """ + p[1].append(p[3]) + p[0] = p[1] + + def p_channel(self, p): + """ + channel : CHANNEL + """ + p[0] = p[1] + + def p_time(self, p): + """ + time : INT UNIT + """ + p[0] = (p[1], p[2]) + + def p_expression_none(self, p): + """ + expression : NONE + """ + p[0] = p[1] + + def p_expression_term(self, p): + 'expression : term' + p[0] = p[1] + + def p_expression_m(self, p): + """ + expression : '-' expression + """ + p[0] = -p[2] + + def p_term_factor(self, p): + """ + term : factor + """ + p[0] = p[1] + + def p_binary_operators(self, p): + '''expression : expression '+' term + | expression '-' term + term : term '*' factor + | term '/' factor''' + if p[2] == '+': + p[0] = p[1] + p[3] + elif p[2] == '-': + p[0] = p[1] - p[3] + elif p[2] == '*': + p[0] = p[1] * p[3] + elif p[2] == '/': + p[0] = p[1] / p[3] + + def p_factor_0(self, p): + ''' + factor : FLOAT + | INT + ''' + p[0] = p[1] + + def p_factor_1(self, p): + ''' + factor : '(' expression ')' + ''' + p[0] = p[2] + + def p_factor_pi(self, p): + ''' + factor : PI + ''' + p[0] = np.pi + + def p_id(self, p): + ''' id : ID''' + p[0] = p[1] -from qfasmlex import QfasmLexer -tokens = QfasmLexer.tokens - -instructions_map = { - "x": XGate, - "y": YGate, - "z": ZGate, - "h": HGate, - "s": SGate, - "sdg": SdgGate, - "t": TGate, - "tdg": TdgGate, - "rx": RXGate, - "ry": RYGate, - "rz": RZGate, - "id": IdGate, - "sx": SXGate, - "sy": SYGate, - "w": WGate, - "sw": SWGate, - "p": PhaseGate, - "delay": Delay, - "barrier": Barrier, - "cx": CXGate, - "cp": CPGate, - "swap": SwapGate, - "rxx": RXXGate, - "ryy": RYYGate, - "rzz": RZZGate, - "cy": CYGate, - "cz": CZGate, - "cs": CSGate, - "ct": CTGate, - "xy": XYResonance, - "ccx": ToffoliGate, - "cswap": FredkinGate, - "mcx": MCXGate, - "mcy": MCYGate, - "mcz": MCZGate, -} - - - -def p_id(p): - ''' id : ID''' - p[0] = p[1] - - -# def p_gate_like(p): -# '''gate : id qubit_list -# | id'('arg_list') qubit_list' -# ''' -# #initialize the gate -# instruction = instructions_map[p[1]] -# p[0] = instruction() - -# def p_pulse_like(p): + def p_error(self, p): + if p: + print("Syntax error at token", p.type) + # Just discard the token and tell the parser it's okay. + self.parser.errok() + else: + print("Syntax error at EOF") -# def p_arg(p): -# """ -# arg : expression -# | arg, expression -# """ -# p[0] \ No newline at end of file diff --git a/src/quafu/qfasm/qfasmlex.py b/src/quafu/qfasm/qfasmlex.py index 06baad6..e456d8c 100644 --- a/src/quafu/qfasm/qfasmlex.py +++ b/src/quafu/qfasm/qfasmlex.py @@ -7,6 +7,18 @@ import numpy as np class QfasmLexer(object): + + def __init__(self): + self.build() + + def input(self, data): + self.data = data + self.lexer.input(data) + + def token(self): + ret = self.lexer.token() + return ret + literals = r'=()[]{};<>,.+-/*^"' reserved = { @@ -14,16 +26,20 @@ class QfasmLexer(object): "qreg" : "QREG", "pi" : "PI", "measure" : "MEASURE", - "none" : "NONE" + "include" : "INCLUDE" } tokens = [ "FLOAT", "INT", + "STRING", "ASSIGN", "MATCHES", "ID", "UNIT", + "CHANNEL", + "OPENQASM", + "NONE" ] + list(reserved.values()) def t_FLOAT(self, t): @@ -36,8 +52,11 @@ def t_INT(self, t): t.value = int(t.value) return t - - def ASSIGN(self, t): + def t_STRING(self, t): + r"\"([^\\\"]|\\.)*\"" + return t + + def t_ASSIGN(self, t): r"->" return t @@ -49,6 +68,18 @@ def t_UNIT(self, t): r"ns|us" return t + def t_CHANNEL(self, t): + r"XY|Z" + return t + + def t_OPENQASM(self, t): + r"OPENQASM" + return t + + def t_NONE(self, t): + r"None" + return t + def t_ID(self, t): r"[a-z][a-zA-Z0-9_]*" t.type = self.reserved.get(t.value, "ID") @@ -58,7 +89,6 @@ def t_ID(self, t): def t_error(self, t): print("Illegal character '%s'" %t.value[0]) - t.lexer.skip(1) def t_newline(self, t): r"\n+" diff --git a/src/quafu/qfasm/qfasmlex_test.py b/src/quafu/qfasm/qfasmlex_test.py deleted file mode 100644 index acd4b74..0000000 --- a/src/quafu/qfasm/qfasmlex_test.py +++ /dev/null @@ -1,2 +0,0 @@ -from qfasmlex import QfasmLexer - From a582cf78016f7ebc802280bededaff2d10792393 Mon Sep 17 00:00:00 2001 From: lss0208 <382715246@qq.com> Date: Thu, 27 Apr 2023 20:35:39 +0800 Subject: [PATCH 16/70] small fix --- src/quafu/pulses/quantum_pulse.py | 7 +------ src/quafu/qfasm/qfasm_convertor.py | 3 +-- src/quafu/qfasm/qfasm_parser.py | 3 ++- 3 files changed, 4 insertions(+), 9 deletions(-) diff --git a/src/quafu/pulses/quantum_pulse.py b/src/quafu/pulses/quantum_pulse.py index 407ad4e..4d8cda0 100644 --- a/src/quafu/pulses/quantum_pulse.py +++ b/src/quafu/pulses/quantum_pulse.py @@ -42,7 +42,7 @@ def __init__(self, @property def symbol(self): - return "%s(%d%s)" % (self.name, self.duration, self.unit) + return "%s(%d%s, %s)" % (self.name, self.duration, self.unit, self.channel) def __repr__(self): return self.__str__() @@ -185,8 +185,3 @@ def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = args = {"amp": self.amp, "fwhm": self.fwhm, "phase":self.phase} return super().__call__(t, shift, offset, args) -if __name__ == '__main__': - p = GaussianPulse(0, amp=1.2, fwhm=None, phase=np.pi/3, duration=60, unit="ns", channel="XY") - # p = FlattopPulse(0, amp=1., fwhm=10, duration=60, unit="ns", channel="XY") - p.plot(shift=0) - print(p.to_qasm()) \ No newline at end of file diff --git a/src/quafu/qfasm/qfasm_convertor.py b/src/quafu/qfasm/qfasm_convertor.py index 4e6ddb0..9b2f419 100644 --- a/src/quafu/qfasm/qfasm_convertor.py +++ b/src/quafu/qfasm/qfasm_convertor.py @@ -7,8 +7,7 @@ def qasm_to_circuit(qasm): parser = QfasmParser() - parser.parse(qasm) - nodes = parser.parsed_nodes + nodes = parser.parse(qasm) n = 0 gates = [] diff --git a/src/quafu/qfasm/qfasm_parser.py b/src/quafu/qfasm/qfasm_parser.py index a7d1eaf..2376148 100644 --- a/src/quafu/qfasm/qfasm_parser.py +++ b/src/quafu/qfasm/qfasm_parser.py @@ -61,7 +61,8 @@ def __init__(self, debug=False): def parse(self, input : str): self.parsed_nodes = self.parser.parse(input, lexer=QfasmLexer()) - + return self.parsed_nodes + def p_main_0(self, p): """ main : program From c5932625a3f1fea67cd2a6fcec30434f43bb2cf2 Mon Sep 17 00:00:00 2001 From: YuChenSSR Date: Sat, 6 May 2023 14:47:45 +0800 Subject: [PATCH 17/70] Added parameters for the pulse gate --- src/quafu/dagcircuits/circuit_dag.py | 16 ++++++++++------ src/quafu/dagcircuits/dag_test.ipynb | 14 +++++++------- src/quafu/dagcircuits/instruction_node.py | 6 ++++-- 3 files changed, 21 insertions(+), 15 deletions(-) diff --git a/src/quafu/dagcircuits/circuit_dag.py b/src/quafu/dagcircuits/circuit_dag.py index f84f1ce..b499996 100644 --- a/src/quafu/dagcircuits/circuit_dag.py +++ b/src/quafu/dagcircuits/circuit_dag.py @@ -9,7 +9,7 @@ from typing import Dict, Any, List, Union import copy -from .instruction_node import InstructionNode # instruction_node.py in the same folder as circuit_dag.py now +from quafu.dagcircuits.instruction_node import InstructionNode # instruction_node.py in the same folder as circuit_dag.py now # import pygraphviz as pgv from networkx.drawing.nx_pydot import write_dot @@ -42,12 +42,14 @@ def gate_to_node(input_gate,specific_label: str): gate.paras = getattr(gate, 'paras', None) or None gate.duration = getattr(gate, 'duration', None) or None gate.unit = getattr(gate, 'unit', None) or None + gate.channel = getattr(gate, 'channel', None) or None + gate.time_func = getattr(gate, 'time_func', None) or None if gate.paras and not isinstance(gate.paras, list): # if paras is True and not a list, make it a list gate.paras = [gate.paras] # hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.matrix,gate.duration,gate.unit, label=i) - hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.duration, gate.unit, label=specific_label) + hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.duration, gate.unit,gate.channel,gate.time_func, label=specific_label) return hashable_gate @@ -113,9 +115,9 @@ def circuit_to_dag(circuit): # Add measure_gate node qm = Any qm.name = "measure" - qm.paras, qm.duration, qm.unit = [None,None,None] + qm.paras, qm.duration, qm.unit,qm.channel,qm.time_func = [None,None,None,None,None] qm.pos = copy.deepcopy(circuit.measures) # circuit.measures is a dict - measure_gate = InstructionNode(qm.name, qm.pos, qm.paras, qm.duration, qm.unit, label="m") + measure_gate = InstructionNode(qm.name, qm.pos, qm.paras, qm.duration, qm.unit,qm.channel,qm.time_func, label="m") g.add_node(measure_gate,color="blue") # Add edges from qubit_last_use[qubit] to measure_gate for qubit in measure_gate.pos.keys(): @@ -245,7 +247,8 @@ def node_to_gate(gate_in_dag): unit = gate_in_dag.unit paras = gate_in_dag.paras pos = gate_in_dag.pos[0] - channel = gate_in_dag.label + channel = gate_in_dag.channel + # time_func = gate_in_dag.time_func return gate_class(pos, *paras, duration, unit, channel) @@ -339,8 +342,9 @@ def draw_dag(dep_g, output_format="png"): ''' + import pygraphviz write_dot(dep_g, "dag.dot") - G = pgv.AGraph("dag.dot") + G = pygraphviz.AGraph("dag.dot") G.layout(prog="dot") if output_format == "png": diff --git a/src/quafu/dagcircuits/dag_test.ipynb b/src/quafu/dagcircuits/dag_test.ipynb index 5ae4182..ce9ef10 100644 --- a/src/quafu/dagcircuits/dag_test.ipynb +++ b/src/quafu/dagcircuits/dag_test.ipynb @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -58,7 +58,7 @@ "" ] }, - "execution_count": 7, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -97,7 +97,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -126,7 +126,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -396,7 +396,7 @@ "" ] }, - "execution_count": 9, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -414,7 +414,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "metadata": {}, "outputs": [ { diff --git a/src/quafu/dagcircuits/instruction_node.py b/src/quafu/dagcircuits/instruction_node.py index 97cdc41..3c55778 100644 --- a/src/quafu/dagcircuits/instruction_node.py +++ b/src/quafu/dagcircuits/instruction_node.py @@ -7,9 +7,11 @@ class InstructionNode: pos:Union[List[Any], Dict[Any,Any]] # gate.pos | Dict[Any,Any] for measure paras:List[Any] # gate.paras # matrix:List[Any] # for gate in [QuantumGate] - duration:int # for gate in [Delay,XYResonance] in quafu + duration: Union[float,int] # for gate in [Delay,XYResonance,QuantumPulse] in quafu unit:str # for gate in [Delay,XYResonance] in quafu - label:str + channel:str # for gate in [QuantumPulse] in quafu + time_func: Any # for gate in [QuantumPulse] in quafu + label:str # used for specifying the instruction node def __hash__(self): return hash((type(self.name), tuple(self.pos) ,self.label)) From 768d61afed51d0c2e057229ee99a547a268ed314 Mon Sep 17 00:00:00 2001 From: Zhaoyilunnn Date: Fri, 26 May 2023 01:41:42 +0000 Subject: [PATCH 18/70] Add runtime job id in task object --- src/quafu/tasks/tasks.py | 71 ++++++++++++++++++++-------------------- 1 file changed, 36 insertions(+), 35 deletions(-) diff --git a/src/quafu/tasks/tasks.py b/src/quafu/tasks/tasks.py index c0db6c7..ad25fa6 100644 --- a/src/quafu/tasks/tasks.py +++ b/src/quafu/tasks/tasks.py @@ -11,7 +11,7 @@ from quafu.backends.backends import Backend import copy -class Task(object): +class Task(object): """ Class for submitting quantum computation task to the backend. @@ -26,20 +26,20 @@ class Task(object): """ def __init__(self, user = User()): - self.user = user + self.user = user self.shots = 1000 self.tomo = False self.compile = True self.priority = self.user.priority + self.runtime_job_id = None self.submit_history = { } self._available_backends = self.user.get_available_backends(print_info=False) self.backend = self._available_backends[list(self._available_backends.keys())[0]] - - - def config(self, - backend: str="ScQ-P10", - shots: int=1000, + + def config(self, + backend: str="ScQ-P10", + shots: int=1000, compile: bool=True, tomo: bool=False, priority: int=2) -> None: @@ -62,26 +62,26 @@ def config(self, self.compile = compile self.priority = priority - + def get_history(self) -> Dict: """ Get the history of submitted task. Returns: - A dict of history. The key is the group name and the value is a list of task id in the group. + A dict of history. The key is the group name and the value is a list of task id in the group. """ return self.submit_history - + def get_backend_info(self) -> Dict: """ Get the calibration information of the experimental backend. - Returns: + Returns: Backend information dictionary containing the mapping from the indices to the names of physical bits `'mapping'`, backend topology `'topology_diagram'` and full calibration inforamtion `'full_info'`. """ return self.backend.get_chip_info(self.user) - + def submit(self, qc: QuantumCircuit, obslist: List=[])\ @@ -92,15 +92,15 @@ def submit(self, qc (QuantumCircuit): Quantum circuit that need to be executed on backend. obslist (list[str, list[int]]): List of pauli string and its position. - Returns: + Returns: List of executed results and list of measured observable - Examples: + Examples: 1) input [["XYX", [0, 1, 2]], ["Z", [1]]] measure pauli operator XYX at 0, 1, 2 qubit, and Z at 1 qubit.\n 2) Measure 5-qubit Ising Hamiltonian we can use\n obslist = [["X", [i]] for i in range(5)]]\n obslist.extend([["ZZ", [i, i+1]] for i in range(4)])\n - + For the energy expectation of Ising Hamiltonian \n res, obsexp = q.submit_task(obslist)\n E = sum(obsexp) @@ -136,8 +136,8 @@ def submit(self, return exec_res, measure_results - def run(self, - qc: QuantumCircuit, + def run(self, + qc: QuantumCircuit, measure_base: List=[]) -> ExecResult: """Single run for measurement task. @@ -161,9 +161,9 @@ def run(self, return res - def send(self, - qc: QuantumCircuit, - name: str="", + def send(self, + qc: QuantumCircuit, + name: str="", group: str="", wait: bool=True) -> ExecResult: """ @@ -174,7 +174,7 @@ def send(self, name: Task name. group: The task belong which group. wait: Whether wait until the execution return. - Returns: + Returns: ExecResult object that contain the dict return from quantum device. """ from quafu import get_version @@ -186,13 +186,14 @@ def send(self, qc.to_openqasm() data = {"qtasm": qc.openqasm, "shots": self.shots, "qubits": qc.num, "scan": 0, "tomo": int(self.tomo), "selected_server": self.backend.system_id, - "compile": int(self.compile), "priority": self.priority, "task_name": name, "pyquafu_version": version} - + "compile": int(self.compile), "priority": self.priority, "task_name": name, + "pyquafu_version": version, "runtime_job_id": self.runtime_job_id} + if wait: url = self.user._url + self.user.exec_api else: url = self.user._url + self.user.exec_async_api - + headers = {'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8', 'api_token': self.user.apitoken} data = parse.urlencode(data) data = data.replace("%27", "'") @@ -206,10 +207,10 @@ def send(self, elif res.json()["status"] == 5003: raise ServerError(res_dict["message"]) elif res.json()["status"] == 5004: - raise CompileError(res_dict["message"]) + raise CompileError(res_dict["message"]) else: task_id = res_dict["task_id"] - + if not (group in self.submit_history): self.submit_history[group] = [task_id] else: @@ -220,7 +221,7 @@ def send(self, def retrieve(self, taskid: str) -> ExecResult: """ Retrieve the results of submited task by taskid. - + Args: taskid: The taskid of the task need to be retrieved. """ @@ -232,12 +233,12 @@ def retrieve(self, taskid: str) -> ExecResult: res_dict = json.loads(res.text) measures = eval(res_dict["measure"]) - + return ExecResult(res_dict, measures) - def retrieve_group(self, + def retrieve_group(self, group: str, - history: Dict={}, + history: Dict={}, verbose: bool=True) -> List[ExecResult]: """ Retrieve the results of submited task by group name. @@ -247,7 +248,7 @@ def retrieve_group(self, history: History from which to retrieve the results. If not provided, the history will be the submit history of saved by current task. verbose: Whether print the task status in the group. Returns: - A list of execution results in the retrieved group. Only completed task will be added. + A list of execution results in the retrieved group. Only completed task will be added. """ history = history if history else self.submit_history taskids = history[group] @@ -267,8 +268,8 @@ def retrieve_group(self, group_res.append(res) return group_res - - + + def check_valid_gates(self, qc: QuantumCircuit) -> None: """ Check the validity of the quantum circuit. @@ -280,7 +281,7 @@ def check_valid_gates(self, qc: QuantumCircuit) -> None: for gate in qc.gates: if gate.name.lower() not in valid_gates: raise CircuitError("Invalid operations '%s' for backend '%s'" %(gate.name, self.backend.name)) - + else: if self.backend.name == "ScQ-S41": raise CircuitError("Backend ScQ-S41 must be used without compilation") @@ -288,4 +289,4 @@ def check_valid_gates(self, qc: QuantumCircuit) -> None: for gate in qc.gates: if gate.name.lower() in ["xy"]: raise CircuitError("Invalid operations '%s' for backend '%s'" %(gate.name, self.backend.name)) - + From 36887fe43dd753f04ee5604aac86c079458ded74 Mon Sep 17 00:00:00 2001 From: Zhaoyilunnn Date: Wed, 7 Jun 2023 06:47:21 +0000 Subject: [PATCH 19/70] fix: load account should use url from configuration file --- src/quafu/users/userapi.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/quafu/users/userapi.py b/src/quafu/users/userapi.py index e899446..e51fa1a 100644 --- a/src/quafu/users/userapi.py +++ b/src/quafu/users/userapi.py @@ -32,19 +32,20 @@ def save_apitoken(self, apitoken): with open(file_dir + "api", "w") as f: f.write(self.apitoken+"\n") f.write("http://quafu.baqis.ac.cn/") - + def load_account(self): """ Load Quafu account. """ homedir = get_homedir() file_dir = homedir + "/.quafu/" - try: + try: f = open(file_dir + "api", "r") data = f.readlines() token = data[0].strip("\n") url = data[1].strip("\n") self.apitoken = token + self._url = url return token, url except: raise UserError("User configure error. Please set up your token.") @@ -52,8 +53,8 @@ def load_account(self): def get_backends_info(self): """ Get available backends information - """ - + """ + backends_info = requests.post(url=self._url+self.backends_api, headers={"api_token" : self.apitoken}) backends_info_dict = json.loads(backends_info.text) if backends_info_dict["status"] == 201: @@ -71,4 +72,4 @@ def get_available_backends(self, print_info=True): for backend in self._available_backends.values(): print((" "*5).join([backend.name.ljust(10), str(backend.qubit_num).ljust(10), backend.status.ljust(10)])) - return self._available_backends \ No newline at end of file + return self._available_backends From b4327d493c1bb783fdca2effd9d84e0e8528b66a Mon Sep 17 00:00:00 2001 From: Zhaoyilunnn Date: Wed, 7 Jun 2023 07:58:24 +0000 Subject: [PATCH 20/70] fix 0: parser error: TypeError: InstructionNode.__init__() missing 2 required positional arguments: 'time_func' and 'label' fix 1: add back from_openqasm --- src/quafu/circuits/quantum_circuit.py | 198 +++++++++++++++++++++----- src/quafu/qfasm/qfasm_parser.py | 31 ++-- 2 files changed, 181 insertions(+), 48 deletions(-) diff --git a/src/quafu/circuits/quantum_circuit.py b/src/quafu/circuits/quantum_circuit.py index 99c9cea..58ab7aa 100644 --- a/src/quafu/circuits/quantum_circuit.py +++ b/src/quafu/circuits/quantum_circuit.py @@ -9,8 +9,8 @@ class QuantumCircuit(object): def __init__(self, num: int): """ Initialize a QuantumCircuit object - - Args: + + Args: num (int): Total qubit number used """ self.num = num @@ -32,7 +32,7 @@ def layered_circuit(self) -> np.ndarray: """ Make layered circuit from the gate sequence self.gates. - Returns: + Returns: A layered list with left justed circuit. """ num = self.num @@ -121,7 +121,7 @@ def draw_circuit(self, width : int=4, return_str : bool=False): if isinstance(gate, ControlledGate): #Controlled-Multiqubit gate for ctrl in gate.ctrls: printlist[reduce_map[ctrl] * 2, l] = "*" - + if gate.targ_name == "SWAP": printlist[reduce_map[gate.targs[0]] * 2, l] = "x" printlist[reduce_map[gate.targs[1]] * 2, l] = "x" @@ -135,7 +135,7 @@ def draw_circuit(self, width : int=4, return_str : bool=False): else: printlist[tq1 + tq2, l] = gate.symbol maxlen = max(maxlen, len(gate.symbol) + width) - + else: #Multiqubit gate if gate.name == "SWAP": printlist[q1 * 2, l] = "x" @@ -151,7 +151,7 @@ def draw_circuit(self, width : int=4, return_str : bool=False): q2 = reduce_map[max(pos)] printlist[2 * q1:2 * q2 + 1, l] = "||" maxlen = max(maxlen, len("||")) - + printlist[-1, l] = maxlen @@ -167,18 +167,153 @@ def draw_circuit(self, width : int=4, return_str : bool=False): circuitstr.append("".ljust(6) + "".join( [printlist[j, l].center(int(printlist[-1, l]), " ") for l in range(depth)])) circuitstr = "\n".join(circuitstr) - + if return_str: return circuitstr else: print(circuitstr) - + + + def from_openqasm(self, openqasm : str): + """ + Initialize the circuit from openqasm text. + Args: + openqasm: input openqasm str. + """ + from numpy import pi + import re + self.openqasm = openqasm + # lines = self.openqasm.strip("\n").splitlines(";") + lines = self.openqasm.splitlines() + lines = [line for line in lines if line] + self.gates = [] + self.measures = {} + measured_qubits = [] + global_valid = True + for line in lines[2:]: + if line: + operations_qbs = line.split(" ", 1) + operations = operations_qbs[0] + if operations == "qreg": + qbs = operations_qbs[1] + self.num = int(re.findall("\d+", qbs)[0]) + elif operations == "creg": + pass + elif operations == "measure": + qbs = operations_qbs[1] + indstr = re.findall("\d+", qbs) + inds = [int(indst) for indst in indstr] + mb = inds[0] + cb = inds[1] + self.measures[mb] = cb + measured_qubits.append(mb) + else: + qbs = operations_qbs[1] + indstr = re.findall("\d+", qbs) + inds = [int(indst) for indst in indstr] + valid = True + for pos in inds: + if pos in measured_qubits: + valid = False + global_valid = False + break + + if valid: + if operations == "barrier": + self.barrier(inds) + + else: + sp_op = operations.split("(") + gatename = sp_op[0] + if gatename == "delay": + paras = sp_op[1].strip("()") + duration = int(re.findall("\d+", paras)[0]) + unit = re.findall("[a-z]+", paras)[0] + self.delay(inds[0], duration, unit) + elif gatename == "xy": + paras = sp_op[1].strip("()") + duration = int(re.findall("\d+", paras)[0]) + unit = re.findall("[a-z]+", paras)[0] + self.xy(min(inds), max(inds), duration, unit) + else: + if len(sp_op) > 1: + paras = sp_op[1].strip("()") + parastr = paras.split(",") + paras = [eval(parai, {"pi": pi}) for parai in parastr] + + if gatename == "cx": + self.cnot(inds[0], inds[1]) + elif gatename == "cy": + self.cy(inds[0], inds[1]) + elif gatename == "cz": + self.cz(inds[0], inds[1]) + elif gatename == "cp": + self.cp(inds[0], inds[1], paras[0]) + elif gatename == "swap": + self.swap(inds[0], inds[1]) + elif gatename == "rx": + self.rx(inds[0], paras[0]) + elif gatename == "ry": + self.ry(inds[0], paras[0]) + elif gatename == "rz": + self.rz(inds[0], paras[0]) + elif gatename == "p": + self.p(inds[0], paras[0]) + elif gatename == "x": + self.x(inds[0]) + elif gatename == "y": + self.y(inds[0]) + elif gatename == "z": + self.z(inds[0]) + elif gatename == "h": + self.h(inds[0]) + elif gatename == "id": + self.id(inds[0]) + elif gatename == "s": + self.s(inds[0]) + elif gatename == "sdg": + self.sdg(inds[0]) + elif gatename == "t": + self.t(inds[0]) + elif gatename == "tdg": + self.tdg(inds[0]) + elif gatename == "sx": + self.sx(inds[0]) + elif gatename == "ccx": + self.toffoli(inds[0], inds[1], inds[2]) + elif gatename == "cswap": + self.fredkin(inds[0], inds[1], inds[2]) + elif gatename == "u1": + self.rz(inds[0], paras[0]) + elif gatename == "u2": + self.rz(inds[0], paras[1]) + self.ry(inds[0], pi / 2) + self.rz(inds[0], paras[0]) + elif gatename == "u3": + self.rz(inds[0], paras[2]) + self.ry(inds[0], paras[0]) + self.rz(inds[0], paras[1]) + elif gatename == "rxx": + self.rxx(inds[0], inds[1], paras[0]) + elif gatename == "ryy": + self.ryy(inds[0], inds[1], paras[0]) + elif gatename == "rzz": + self.rzz(inds[0], inds[1], paras[0]) + else: + print( + "Warning: Operations %s may be not supported by QuantumCircuit class currently." % gatename) + + if not self.measures: + self.measures = dict(zip(range(self.num), range(self.num))) + if not global_valid: + print("Warning: All operations after measurement will be removed for executing on experiment") + def to_openqasm(self) -> str: """ Convert the circuit to openqasm text. - Returns: + Returns: openqasm text. """ qasm = "OPENQASM 2.0;\ninclude \"qelib1.inc\";\n" @@ -200,7 +335,7 @@ def id(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. - """ + """ self.gates.append(IdGate(pos)) return self @@ -253,7 +388,7 @@ def t(self, pos: int) -> "QuantumCircuit": """ self.gates.append(TGate(pos)) return self - + def tdg(self, pos: int) -> "QuantumCircuit": """ Tdg gate. (Inverse of T gate) @@ -312,7 +447,7 @@ def w(self, pos: int) -> "QuantumCircuit": """ self.gates.append(WGate(pos)) return self - + def sw(self, pos: int) -> "QuantumCircuit": """ √W gate. @@ -322,7 +457,7 @@ def sw(self, pos: int) -> "QuantumCircuit": """ self.gates.append(SWGate(pos)) return self - + def rx(self, pos: int, para: float) -> "QuantumCircuit": """ Single qubit rotation Rx gate. @@ -337,7 +472,7 @@ def rx(self, pos: int, para: float) -> "QuantumCircuit": def ry(self, pos: int, para: float) -> "QuantumCircuit": """ Single qubit rotation Ry gate. - + Args: pos (int): qubit the gate act. para (float): rotation angle @@ -348,7 +483,7 @@ def ry(self, pos: int, para: float) -> "QuantumCircuit": def rz(self, pos: int, para: float) -> "QuantumCircuit": """ Single qubit rotation Rz gate. - + Args: pos (int): qubit the gate act. para (float): rotation angle @@ -359,7 +494,7 @@ def rz(self, pos: int, para: float) -> "QuantumCircuit": def p(self, pos: int, para: float) -> "QuantumCircuit": """ Phase gate - + Args: pos (int): qubit the gate act. para (float): rotation angle @@ -369,7 +504,7 @@ def p(self, pos: int, para: float) -> "QuantumCircuit": def cnot(self, ctrl: int, tar: int) -> "QuantumCircuit": """ CNOT gate. - + Args: ctrl (int): control qubit. tar (int): target qubit. @@ -391,7 +526,7 @@ def cy(self, ctrl: int, tar: int) -> "QuantumCircuit": def cz(self, ctrl: int, tar: int) -> "QuantumCircuit": """ Control-Z gate. - + Args: ctrl (int): control qubit. tar (int): target qubit. @@ -416,7 +551,7 @@ def ct(self, ctrl: int, tar: int) -> "QuantumCircuit": ctrl (int): control qubit. tar (int): target qubit. """ - + self.gates.append(CTGate(ctrl, tar)) return self @@ -430,12 +565,12 @@ def cp(self, ctrl: int, tar: int, para) -> "QuantumCircuit": """ self.gates.append(CPGate(ctrl, tar, para)) return self - + def swap(self, q1: int, q2: int) -> "QuantumCircuit": """ SWAP gate - + Args: q1 (int): qubit the gate act. q2 (int): qubit the gate act. @@ -454,11 +589,11 @@ def toffoli(self, ctrl1: int, ctrl2: int, targ: int) -> "QuantumCircuit": """ self.gates.append(ToffoliGate(ctrl1, ctrl2, targ)) return self - + def fredkin(self, ctrl: int, targ1:int , targ2: int) -> "QuantumCircuit": """ Fredkin gate - + Args: ctrl (int): control qubit targ1 (int): target qubit @@ -470,7 +605,7 @@ def fredkin(self, ctrl: int, targ1:int , targ2: int) -> "QuantumCircuit": def barrier(self, qlist: List[int]) -> "QuantumCircuit": """ Add barrier for qubits in qlist. - + Args: qlist (list[int]): A list contain the qubit need add barrier. When qlist contain at least two qubit, the barrier will be added from minimum qubit to maximum qubit. For example: barrier([0, 2]) create barrier for qubits 0, 1, 2. To create discrete barrier, using barrier([0]), barrier([2]). """ @@ -484,7 +619,7 @@ def delay(self, pos, duration, unit="ns") -> "QuantumCircuit": Args: pos (int): qubit need delay. duration (int): duration of qubit delay, which represents integer times of unit. - unit (str): time unit for the duration. Can be "ns" and "us". + unit (str): time unit for the duration. Can be "ns" and "us". """ self.gates.append(Delay(pos, duration, unit=unit)) return self @@ -512,7 +647,7 @@ def rxx(self, q1: int, q2: int, theta): """ self.gates.append(RXXGate(q1, q2, theta)) - + def ryy(self, q1: int, q2: int, theta): """ Rotation about 2-qubit YY axis. @@ -534,7 +669,7 @@ def rzz(self, q1: int, q2: int, theta): """ self.gates.append(RZZGate(q1, q2, theta)) - + def mcx(self, ctrls: List[int], targ: int): """ Multi-controlled X gate. @@ -543,7 +678,7 @@ def mcx(self, ctrls: List[int], targ: int): targ: Target qubits. """ self.gates.append(MCXGate(ctrls, targ)) - + def mcy(self, ctrls: List[int], targ: int): """ Multi-controlled Y gate. @@ -552,7 +687,7 @@ def mcy(self, ctrls: List[int], targ: int): targ: Target qubits. """ self.gates.append(MCYGate(ctrls, targ)) - + def mcz(self, ctrls: List[int], targ: int): """ Multi-controlled Z gate. @@ -561,12 +696,12 @@ def mcz(self, ctrls: List[int], targ: int): targ: Target qubits. """ self.gates.append(MCZGate(ctrls, targ)) - + def measure(self, pos: List[int], cbits: List[int] = []) -> None: """ Measurement setting for experiment device. - + Args: pos: Qubits need measure. cbits: Classical bits keeping the measure results. @@ -590,4 +725,3 @@ def add_pulse(self, pulse.set_pos(pos) self.gates.append(pulse) return self - diff --git a/src/quafu/qfasm/qfasm_parser.py b/src/quafu/qfasm/qfasm_parser.py index 2376148..40ac2ad 100644 --- a/src/quafu/qfasm/qfasm_parser.py +++ b/src/quafu/qfasm/qfasm_parser.py @@ -17,7 +17,7 @@ def __init__(self, n): def __repr__(self): return self.__str__() - + def __str__(self): return "qreg[%d]" %self.n @@ -27,27 +27,27 @@ def __init__(self, n): def __repr__(self): return self.__str__() - + def __str__(self): return "creg[%d]" %self.n - + class IncludeNode(DeclarationNode): def __init__(self, filename): self.file = filename def __repr__(self): return self.__str__() - + def __str__(self): return "include %s" %self.file - -class OPENQASMNode(DeclarationNode): + +class OPENQASMNode(DeclarationNode): def __init__(self, version): self.version = version def __repr__(self): return self.__str__() - + def __str__(self): return "OPENQASM %.1f" %self.version @@ -58,11 +58,11 @@ def __init__(self, debug=False): self.parser = yacc.yacc(module=self, debug=debug) self.parsed_nodes = [] self.lexer = QfasmLexer() - + def parse(self, input : str): self.parsed_nodes = self.parser.parse(input, lexer=QfasmLexer()) return self.parsed_nodes - + def p_main_0(self, p): """ main : program @@ -91,7 +91,7 @@ def p_declaration(self, p): | creg """ p[0] = p[1] - + def p_openqasm(self, p): """ openqasm : OPENQASM FLOAT ';' @@ -142,31 +142,31 @@ def p_gate_like_0(self, p): ''' gate : id qubit_list ''' - p[0] = InstructionNode(p[1], p[2], None, None, None, "") + p[0] = InstructionNode(p[1], p[2], None, None, None, "", None, "") def p_gate_like_1(self, p): ''' gate : id '(' arg_list ')' qubit_list ''' - p[0] = InstructionNode(p[1], p[5], p[3], None, None, "") + p[0] = InstructionNode(p[1], p[5], p[3], None, None, "", None, "") def p_pulse_like_0(self, p): ''' pulse : id '(' time ',' arg_list ')' qubit_list ''' - p[0] = InstructionNode(p[1], p[7], p[5], p[3][0], p[3][1], "") + p[0] = InstructionNode(p[1], p[7], p[5], p[3][0], p[3][1], "", None, "") def p_measure_0(self, p): ''' measure : MEASURE bitreg ASSIGN bitreg ''' - p[0] = InstructionNode("measure", {p[2] : p[4]}, None, None, None, "") + p[0] = InstructionNode("measure", {p[2] : p[4]}, None, None, None, "", None, "") def p_pulse_like_1(self, p): ''' pulse : id '(' time ',' arg_list ',' channel ')' qubit_list ''' - p[0] = InstructionNode(p[1], p[9], p[5], p[3][0], p[3][1], p[7]) + p[0] = InstructionNode(p[1], p[9], p[5], p[3][0], p[3][1], p[7], None, "") def p_bitreg(self, p): """ @@ -265,4 +265,3 @@ def p_error(self, p): self.parser.errok() else: print("Syntax error at EOF") - From a32de952613959759c154d231b2c1c9171b53a9d Mon Sep 17 00:00:00 2001 From: Zhaoyilunnn Date: Thu, 8 Jun 2023 08:34:27 +0000 Subject: [PATCH 21/70] fix: default runtime_job_id should be empty string --- src/quafu/tasks/tasks.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/quafu/tasks/tasks.py b/src/quafu/tasks/tasks.py index ad25fa6..e6818f6 100644 --- a/src/quafu/tasks/tasks.py +++ b/src/quafu/tasks/tasks.py @@ -31,7 +31,7 @@ def __init__(self, user = User()): self.tomo = False self.compile = True self.priority = self.user.priority - self.runtime_job_id = None + self.runtime_job_id = "" self.submit_history = { } self._available_backends = self.user.get_available_backends(print_info=False) self.backend = self._available_backends[list(self._available_backends.keys())[0]] @@ -289,4 +289,3 @@ def check_valid_gates(self, qc: QuantumCircuit) -> None: for gate in qc.gates: if gate.name.lower() in ["xy"]: raise CircuitError("Invalid operations '%s' for backend '%s'" %(gate.name, self.backend.name)) - From 7c8a43a572155c6f39d9486594a9363c7368cd98 Mon Sep 17 00:00:00 2001 From: YuChenSSR Date: Thu, 29 Jun 2023 17:36:41 +0800 Subject: [PATCH 22/70] update DAGCircuit class and some tests --- src/quafu/dagcircuits/circuit_dag.py | 161 +- src/quafu/dagcircuits/dag.dot | 53 + src/quafu/dagcircuits/dag_circuit.py | 286 ++ src/quafu/dagcircuits/dag_test.ipynb | 5 +- src/quafu/dagcircuits/dagcircuit_test.ipynb | 2976 +++++++++++++++++++ 5 files changed, 3455 insertions(+), 26 deletions(-) create mode 100644 src/quafu/dagcircuits/dag.dot create mode 100644 src/quafu/dagcircuits/dag_circuit.py create mode 100644 src/quafu/dagcircuits/dagcircuit_test.ipynb diff --git a/src/quafu/dagcircuits/circuit_dag.py b/src/quafu/dagcircuits/circuit_dag.py index b499996..172472c 100644 --- a/src/quafu/dagcircuits/circuit_dag.py +++ b/src/quafu/dagcircuits/circuit_dag.py @@ -10,6 +10,7 @@ import copy from quafu.dagcircuits.instruction_node import InstructionNode # instruction_node.py in the same folder as circuit_dag.py now +from dag_circuit import DAGCircuit # dag_circuit.py in the same folder as circuit_dag.py now # import pygraphviz as pgv from networkx.drawing.nx_pydot import write_dot @@ -52,17 +53,17 @@ def gate_to_node(input_gate,specific_label: str): hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.duration, gate.unit,gate.channel,gate.time_func, label=specific_label) return hashable_gate - -# Building a DAG Graph using NetworkX from a QuantumCircuit -def circuit_to_dag(circuit): +# Building a DAG Graph using DAGCircuit from a QuantumCircuit +def circuit_to_dag(circuit, measure_flag = True): ''' - Building a DAG Graph using NetworkX from a QuantumCircuit + Building a DAG Graph using DAGCircui from a QuantumCircuit Args: circuit: a QuantumCircuit object + measure_flag: whether to add measure_gate node to the dag graph Returns: - g: a networkx MultiDiGraph object + g: a DAGCircuit object example: .. jupyter-execute:: @@ -85,8 +86,9 @@ def circuit_to_dag(circuit): # A dictionary to store the last use of any qubit qubit_last_use = {} - g = nx.MultiDiGraph() # two nodes can have multiple edges + # g = nx.MultiDiGraph() # two nodes can have multiple edges # g = nx.DiGraph() # two nodes can only have one edge + g = DAGCircuit() # two nodes can only have one edge # Add the start node # g.add_node(-1,{"color": "green"}) @@ -111,22 +113,24 @@ def circuit_to_dag(circuit): g.add_edge(-1, hashable_gate,label=f'q{qubit}',color="green") qubit_last_use[qubit] = hashable_gate - - # Add measure_gate node - qm = Any - qm.name = "measure" - qm.paras, qm.duration, qm.unit,qm.channel,qm.time_func = [None,None,None,None,None] - qm.pos = copy.deepcopy(circuit.measures) # circuit.measures is a dict - measure_gate = InstructionNode(qm.name, qm.pos, qm.paras, qm.duration, qm.unit,qm.channel,qm.time_func, label="m") - g.add_node(measure_gate,color="blue") - # Add edges from qubit_last_use[qubit] to measure_gate - for qubit in measure_gate.pos.keys(): - if qubit in qubit_last_use: - g.add_edge(qubit_last_use[qubit], measure_gate,label=f'q{qubit}') - else: - g.add_edge(-1, measure_gate,label=f'q{qubit}',color="green") - - qubit_last_use[qubit] = measure_gate + + if measure_flag: + # Add measure_gate node + qm = Any + qm.name = "measure" + qm.paras, qm.duration, qm.unit = [None,None,None] + qm.channel, qm.time_func = [None,None] + qm.pos = copy.deepcopy(circuit.measures) # circuit.measures is a dict + measure_gate = InstructionNode(qm.name, qm.pos, qm.paras, qm.duration, qm.unit, qm.channel, qm.time_func, label="m") + g.add_node(measure_gate,color="blue") + # Add edges from qubit_last_use[qubit] to measure_gate + for qubit in measure_gate.pos: + if qubit in qubit_last_use: + g.add_edge(qubit_last_use[qubit], measure_gate,label=f'q{qubit}') + else: + g.add_edge(-1, measure_gate,label=f'q{qubit}',color="green") + + qubit_last_use[qubit] = measure_gate # Add the end node # g.add_node(float('inf'),{"color": "red"}) @@ -135,6 +139,11 @@ def circuit_to_dag(circuit): for qubit in qubit_last_use: g.add_edge(qubit_last_use[qubit], float('inf'),label=f'q{qubit}',color="red") + # update qubits_used, cbits_used, num_instruction_nodes + g.update_qubits_used() + g.update_cbits_used() + g.update_num_instruction_nodes() + return g @@ -190,7 +199,7 @@ def node_to_gate(gate_in_dag): Args: gate_in_dag: a node in dag graph , gate_in_dag is a GateWrapper object. - in GateWrapper, gate_in_dag.name is uppercase, gate_in_dag.pos is a list or a dict + in instruction_node, gate_in_dag.name is uppercase, gate_in_dag.pos is a list or a dict gate_transform support gate with one qubit or more qubits, not measures! and you should exculde nodes [-1 ,float('inf') , measure_gate] in dag graph @@ -356,3 +365,109 @@ def draw_dag(dep_g, output_format="png"): else: raise ValueError("Unsupported output format: choose either 'png' or 'svg'") + +def nodelist_to_dag(op_nodes: List[Any]) -> DAGCircuit: + # Starting Label Index + i = 0 + + # A dictionary to store the last use of any qubit + qubit_last_use = {} + + # g = nx.MultiDiGraph() # two nodes can have multiple edges + # g = nx.DiGraph() # two nodes can only have one edge + g = DAGCircuit() + + # Add the start node + # g.add_node(-1,{"color": "green"}) + g.add_nodes_from([(-1, {"color": "green"})]) + + # deepcopy the circuit to avoid modifying the original circuit + # gates = copy.deepcopy(circuit.gates) # need to import copy + # change to: gate = copy.deepcopy(input_gate) in gate_to_node() + + for op_node in op_nodes: + # transform gate to node + hashable_gate = copy.deepcopy(op_node) + g.add_node(hashable_gate,color="blue") + + # Add edges based on qubit_last_use; update last use + for qubit in hashable_gate.pos: + if qubit in qubit_last_use: + g.add_edge(qubit_last_use[qubit], hashable_gate,label=f'q{qubit}') + else: + g.add_edge(-1, hashable_gate,label=f'q{qubit}',color="green") + + qubit_last_use[qubit] = hashable_gate + + + # Add the end node + # g.add_node(float('inf'),{"color": "red"}) + g.add_nodes_from([(float('inf'), {"color": "red"})]) + + for qubit in qubit_last_use: + g.add_edge(qubit_last_use[qubit], float('inf'),label=f'q{qubit}',color="red") + + # update the qubits_used, cbits_used, num_instruction_nodes + g.qubits_used = g.update_qubits_used() + g.cbits_used = g.update_cbits_used() + g.num_instruction_nodes = g.update_num_instruction_nodes() + + return g + +# nodes_qubit_mapping_dict +def nodelist_qubit_mapping_dict(nodes_list): + ''' + Args: + nodes_list: a list of nodes + Returns: + nodes_qubit_mapping_dict: a dict about keys are the qubits used by the nodes and values are the new qubits + ''' + nodes_list_qubits_used = set() + for node in nodes_list: + if hasattr(node, 'pos') and node.pos is not None: + nodes_list_qubits_used = nodes_list_qubits_used | set(node.pos) + + mapping_pos = list(range(len(nodes_list_qubits_used))) + # mapping, get a dict + nodes_qubit_mapping_dict = dict(zip(sorted(list(nodes_list_qubits_used)), mapping_pos)) + nodes_qubit_mapping_dict + + return nodes_qubit_mapping_dict + +def nodelist_qubit_mapping_dict_reverse(nodes_list): + ''' + Args: + nodes_list: a list of nodes + Returns: + nodes_qubit_mapping_dict_reverse: a dict about keys are the new qubits and values are the qubits used by the nodes + ''' + nodes_qubit_mapping_dict = nodelist_qubit_mapping_dict(nodes_list) + # reverse mapping, get a dict + nodes_qubit_mapping_dict_reverse = {value: key for key, value in nodes_qubit_mapping_dict.items()} + + return nodes_qubit_mapping_dict_reverse + +# a function to map nodes_list +def nodes_list_mapping(nodes_list, nodes_qubit_mapping_dict): + ''' + Args: + nodes_list: the nodes list of instruction nodes + nodes_qubit_mapping_dict: the dict of the mapping qubits + + return: + nodes_list_mapping: the nodes_list after mapping qubits + ''' + nodes_qubit_mapping_dict + nodes_list_mapping = [] + for node in nodes_list: + node_new = copy.deepcopy(node) + if hasattr(node, 'pos') and node.pos is not None: + if isinstance(node.pos, list): + node_new.pos = [nodes_qubit_mapping_dict[qubit] for qubit in node.pos] + elif isinstance(node.pos, dict): + node_new.pos = {} + # the values of the dict are void, so we need to copy the values from the original dict + for qubit in node.pos: + node_new.pos[nodes_qubit_mapping_dict[qubit]] = copy.deepcopy(node.pos[qubit]) + nodes_list_mapping.append(node_new) + return nodes_list_mapping \ No newline at end of file diff --git a/src/quafu/dagcircuits/dag.dot b/src/quafu/dagcircuits/dag.dot new file mode 100644 index 0000000..107d185 --- /dev/null +++ b/src/quafu/dagcircuits/dag.dot @@ -0,0 +1,53 @@ +digraph { +"-1" [color=green]; +"0{CX(0,1)}" [color=blue]; +"1{X(2)}" [color=blue]; +"2{CX(1,0)}" [color=blue]; +"3{CX(2,1)}" [color=blue]; +"4{CP(1,0)}(1.571)" [color=blue]; +"5{barrier(0,1,2)}" [color=blue]; +"6{RXX(0,1)}(1.571)" [color=blue]; +"7{delay(0)}" [color=blue]; +"8{CSWAP(0,1,2)}" [color=blue]; +"9{MCX(0,1,2)}" [color=blue]; +"10{MCY(0,1,2)}" [color=blue]; +"11{MCZ(0,1,2)}" [color=blue]; +"12{CT(2,1)}" [color=blue]; +"m{measure(0,1,2=>0,1,2)}" [color=blue]; +inf [color=red]; +"-1" -> "0{CX(0,1)}" [color=green, key=0, label=q0]; +"-1" -> "0{CX(0,1)}" [color=green, key=1, label=q1]; +"-1" -> "1{X(2)}" [color=green, key=0, label=q2]; +"0{CX(0,1)}" -> "2{CX(1,0)}" [key=0, label=q1]; +"0{CX(0,1)}" -> "2{CX(1,0)}" [key=1, label=q0]; +"1{X(2)}" -> "3{CX(2,1)}" [key=0, label=q2]; +"2{CX(1,0)}" -> "3{CX(2,1)}" [key=0, label=q1]; +"2{CX(1,0)}" -> "4{CP(1,0)}(1.571)" [key=0, label=q0]; +"3{CX(2,1)}" -> "4{CP(1,0)}(1.571)" [key=0, label=q1]; +"3{CX(2,1)}" -> "5{barrier(0,1,2)}" [key=0, label=q2]; +"4{CP(1,0)}(1.571)" -> "5{barrier(0,1,2)}" [key=0, label=q0]; +"4{CP(1,0)}(1.571)" -> "5{barrier(0,1,2)}" [key=1, label=q1]; +"5{barrier(0,1,2)}" -> "6{RXX(0,1)}(1.571)" [key=0, label=q0]; +"5{barrier(0,1,2)}" -> "6{RXX(0,1)}(1.571)" [key=1, label=q1]; +"5{barrier(0,1,2)}" -> "8{CSWAP(0,1,2)}" [key=0, label=q2]; +"6{RXX(0,1)}(1.571)" -> "7{delay(0)}" [key=0, label=q0]; +"6{RXX(0,1)}(1.571)" -> "8{CSWAP(0,1,2)}" [key=0, label=q1]; +"7{delay(0)}" -> "8{CSWAP(0,1,2)}" [key=0, label=q0]; +"8{CSWAP(0,1,2)}" -> "9{MCX(0,1,2)}" [key=0, label=q0]; +"8{CSWAP(0,1,2)}" -> "9{MCX(0,1,2)}" [key=1, label=q1]; +"8{CSWAP(0,1,2)}" -> "9{MCX(0,1,2)}" [key=2, label=q2]; +"9{MCX(0,1,2)}" -> "10{MCY(0,1,2)}" [key=0, label=q0]; +"9{MCX(0,1,2)}" -> "10{MCY(0,1,2)}" [key=1, label=q1]; +"9{MCX(0,1,2)}" -> "10{MCY(0,1,2)}" [key=2, label=q2]; +"10{MCY(0,1,2)}" -> "11{MCZ(0,1,2)}" [key=0, label=q0]; +"10{MCY(0,1,2)}" -> "11{MCZ(0,1,2)}" [key=1, label=q1]; +"10{MCY(0,1,2)}" -> "11{MCZ(0,1,2)}" [key=2, label=q2]; +"11{MCZ(0,1,2)}" -> "12{CT(2,1)}" [key=0, label=q2]; +"11{MCZ(0,1,2)}" -> "12{CT(2,1)}" [key=1, label=q1]; +"11{MCZ(0,1,2)}" -> "m{measure(0,1,2=>0,1,2)}" [key=0, label=q0]; +"12{CT(2,1)}" -> "m{measure(0,1,2=>0,1,2)}" [key=0, label=q1]; +"12{CT(2,1)}" -> "m{measure(0,1,2=>0,1,2)}" [key=1, label=q2]; +"m{measure(0,1,2=>0,1,2)}" -> inf [color=red, key=0, label=q0]; +"m{measure(0,1,2=>0,1,2)}" -> inf [color=red, key=1, label=q1]; +"m{measure(0,1,2=>0,1,2)}" -> inf [color=red, key=2, label=q2]; +} diff --git a/src/quafu/dagcircuits/dag_circuit.py b/src/quafu/dagcircuits/dag_circuit.py new file mode 100644 index 0000000..58941ce --- /dev/null +++ b/src/quafu/dagcircuits/dag_circuit.py @@ -0,0 +1,286 @@ +import networkx as nx +from typing import Dict, Any, List + +from instruction_node import InstructionNode + +from networkx.classes.multidigraph import MultiDiGraph + +class DAGCircuit(MultiDiGraph): + def __init__(self,qubits_used=None, cbits_used=None, incoming_graph_data=None, **attr): + super().__init__(incoming_graph_data, **attr) + + if qubits_used is None: + self.qubits_used = set() + elif isinstance(qubits_used, set): + self.qubits_used = qubits_used + else: + raise ValueError('qubits_used should be a set or None') + + if cbits_used is None: + self.cbits_used = set() + elif isinstance(cbits_used, set): + self.cbits_used = cbits_used + else: + raise ValueError('cbits_used should be a set or None') + + # num of instruction nodes + self.num_instruction_nodes = 0 + + + # add new methods or override existing methods here. + + def update_qubits_used(self): + ''' + qubits_used is a set of qubits used in DAGCircuit + based on node -1's edges' labels, the qubits is the integer part of the label + + return: + qubits_used: set of qubits used in DAGCircuit + ''' + if -1 not in self.nodes: + raise ValueError('-1 should be in DAGCircuit, please add it first') + self.qubits_used = set([int(edge[2]['label'][1:]) for edge in self.out_edges(-1, data=True)]) + return self.qubits_used + + def update_cbits_used(self): + ''' + cbits_used is a set of cbits used in DAGCircuit + calculated by measurenode's cbits + return: + cbits_used: set of cbits used in DAGCircuit + ''' + for node in self.nodes: + # if node.has a attribute 'name' and node.name == 'measure' + if hasattr(node, 'name') and node.name == 'measure': + self.cbits_used = set(node.pos.values()) + return self.cbits_used + + def update_num_instruction_nodes(self): + ''' + num_instruction_nodes is the number of instruction nodes in DAGCircuit + ''' + if -1 not in self.nodes: + raise ValueError('-1 should be in DAGCircuit, please add it first') + if float('inf') not in self.nodes: + raise ValueError('float("inf") should be in DAGCircuit, please add it first') + self.num_instruction_nodes = len(self.nodes) - 2 + + for node in self.nodes: + if hasattr(node, 'name') and node.name == 'measure': + self.num_instruction_nodes -= 1 + return self.num_instruction_nodes + + + + def nodes_dict(self): + ''' + nodes_dict is a dictionary of nodes with the node label as key and the node as value. + without -1 and float('inf') + ''' + nodes_dict = {} + for node in nx.topological_sort(self): + if node != -1 and node != float('inf'): + nodes_dict[node.label] = node + return nodes_dict + + + def nodes_list(self): + ''' + nodes_list is a list of nodes without -1 and float('inf') + ''' + nodes_list = [] + for node in nx.topological_sort(self): + if node != -1 and node != float('inf'): + nodes_list.append(node) + return nodes_list + + def node_qubits_predecessors(self, node:InstructionNode): + ''' + node_qubits_predecessors is a dict of {qubits -> predecessors }of node + Args: + node in DAGCircuit, node should not be -1 + Returns: + node_qubits_predecessors: dict of {qubits -> predecessors }of node + ''' + # for edge in self.in_edges(node, data=True): + # print(edge[0], edge[1], edge[2]) + + if node not in self.nodes: + raise ValueError('node should be in DAGCircuit') + if node in [-1]: + raise ValueError('-1 has no predecessors') + + predecessor_nodes = [edge[0] for edge in self.in_edges(node, data=True)] + qubits_labels = [int(edge[2]['label'][1:]) for edge in self.in_edges(node, data=True)] + node_qubits_predecessors = dict(zip(qubits_labels, predecessor_nodes)) + return node_qubits_predecessors + + def node_qubits_successors(self, node:InstructionNode): + ''' + node_qubits_successors is a dict of {qubits -> successors }of node + Args: + node in DAGCircuit, node should not be float('inf') + Returns: + node_qubits_successors: dict of {qubits -> successors }of node + + + ''' + if node not in self.nodes: + raise ValueError('node should be in DAGCircuit') + if node in [float('inf')]: + raise ValueError('float("inf") has no successors') + successor_nodes = [edge[1] for edge in self.out_edges(node, data=True)] + qubits_labels = [int(edge[2]['label'][1:]) for edge in self.out_edges(node, data=True)] + node_qubits_successors = dict(zip(qubits_labels, successor_nodes)) + return node_qubits_successors + + def node_qubits_inedges(self, node:InstructionNode): + ''' + node_qubits_inedges is a dict of {qubits -> inedges }of node + Args: + node in DAGCircuit, node should not be -1 + Returns: + node_qubits_inedges: dict of {qubits -> inedges }of node + ''' + if node not in self.nodes: + raise ValueError('node should be in DAGCircuit') + if node in [-1]: + raise ValueError('-1 has no predecessors') + + inedges = [edge for edge in self.in_edges(node)] + qubits_labels = [int(edge[2]['label'][1:]) for edge in self.in_edges(node, data=True)] + node_qubits_inedges = dict(zip(qubits_labels, inedges)) + return node_qubits_inedges + + def node_qubits_outedges(self, node:InstructionNode): + ''' + node_qubits_outedges is a dict of {qubits -> outedges }of node + Args: + node in DAGCircuit, node should not be float('inf') + Returns: + node_qubits_outedges: dict of {qubits -> outedges }of node + ''' + if node not in self.nodes: + raise ValueError('node should be in DAGCircuit') + if node in [float('inf')]: + raise ValueError('float("inf") has no successors') + outedges = [edge for edge in self.out_edges(node)] + qubits_labels = [int(edge[2]['label'][1:]) for edge in self.out_edges(node, data=True)] + node_qubits_outedges = dict(zip(qubits_labels, outedges)) + return node_qubits_outedges + + def remove_instruction_node(self, gate:InstructionNode): + ''' + remove a gate from DAGCircuit, and all edges connected to it. + add new edges about qubits of removed gate between all predecessors and successors of removed gate. + Args: + gate: InstructionNode, gate should be in DAGCircuit, gate should not be -1 or float('inf') + ''' + + if gate not in self.nodes: + raise ValueError('gate should be in DAGCircuit') + if gate in [-1, float('inf')]: + raise ValueError('gate should not be -1 or float("inf")') + + qubits_predecessors = self.node_qubits_predecessors(gate) + qubits_successors = self.node_qubits_successors(gate) + for qubit in gate.pos: + if qubits_predecessors[qubit] != -1 and qubits_successors[qubit] != float('inf'): + self.add_edge(qubits_predecessors[qubit], qubits_successors[qubit], label=f'q{qubit}') + elif qubits_predecessors[qubit] == -1 and qubits_successors[qubit] != float('inf'): + self.add_edge(qubits_predecessors[qubit], qubits_successors[qubit], label=f'q{qubit}',color='green') + else: + self.add_edge(qubits_predecessors[qubit], qubits_successors[qubit], label=f'q{qubit}',color='red') + + self.remove_node(gate) + + # update qubits + self.qubits_used = self.update_qubits_used() + + + def merge_dag(self, other_dag): + ''' + merge other_dag into self + Args: + other_dag: DAGCircuit + Returns: + self: DAGCircuit + ''' + if not isinstance(other_dag, DAGCircuit): + raise ValueError('other_dag should be a DAGCircuit') + if other_dag == None: + return self + if self == None: + return other_dag + + # for the same qubits (intersection), + # remove the outgoing edges from the final node of the original DAG and the incoming edges from the initial node of the other DAG, + # then connect the corresponding tail and head nodes by adding edges + other_dag_qubits_used = other_dag.update_qubits_used() + self_qubits_used = self.update_qubits_used() + + insect_qubits = self_qubits_used & other_dag_qubits_used + end_edges_labels_1 = self.node_qubits_inedges(float('inf')) + start_edges_labels_2 = other_dag.node_qubits_outedges(-1) + + if len(insect_qubits) != 0: + for insect_qubit in insect_qubits: + self.remove_edges_from([end_edges_labels_1[insect_qubit]]) + other_dag.remove_edges_from([start_edges_labels_2[insect_qubit]]) + self.add_edge(end_edges_labels_1[insect_qubit][0], start_edges_labels_2[insect_qubit][1], label=f'q{insect_qubit}') + + # add other_dag's nodes and edges into self + # ！if we add edges, we don't need to add nodes again + self.add_edges_from(other_dag.edges(data=True)) + + # remove the edges between -1 and float('inf') + self.remove_edges_from([edge for edge in self.edges(data=True) if edge[0] == -1 and edge[1] == float('inf')]) + + # update qubits + self.qubits_used = self.update_qubits_used() + + def add_instruction_node(self, gate:InstructionNode,predecessors_dict:Dict[int,InstructionNode],successors_dict:Dict[int,InstructionNode]): + ''' + add a gate into DAGCircuit, and all edges connected to it. + add new edges about qubits of new gate between all predecessors and successors of new gate. + Args: + gate: InstructionNode, gate should not be -1 or float('inf') + predecessors_dict: dict of {qubits -> predecessors }of gate + successors_dict: dict of {qubits -> successors }of gate + ''' + if gate in [-1, float('inf')]: + raise ValueError('gate should not be -1 or float("inf")') + + #remove the edges between the predessors,successors about the qubits used by the added node + qubits_pre_out_edges = [] + qubits_suc_in_edges = [] + for qubit in gate.pos: + pre_out_edges = self.node_qubits_outedges(predecessors_dict[qubit]) + qubits_pre_out_edges.append(pre_out_edges[qubit]) + + suc_in_edges = self.node_qubits_inedges(successors_dict[qubit]) + qubits_suc_in_edges.append(suc_in_edges[qubit]) + + self.remove_edges_from(qubits_pre_out_edges) + self.remove_edges_from(qubits_suc_in_edges) + + # add the new node and edges + for qubit in gate.pos: + if predecessors_dict[qubit] == -1: + self.add_edge(predecessors_dict[qubit], gate, label=f'q{qubit}',color='green') + else: + self.add_edge(predecessors_dict[qubit], gate, label=f'q{qubit}') + if successors_dict[qubit] == float('inf'): + self.add_edge(gate, successors_dict[qubit], label=f'q{qubit}',color='red') + else: + self.add_edge(gate, successors_dict[qubit], label=f'q{qubit}') + + # update qubits + self.qubits_used = self.update_qubits_used() + + + def is_dag(self): + ''' + is_dag is a bool value to check if DAGCircuit is a DAG + ''' + return nx.is_directed_acyclic_graph(self) \ No newline at end of file diff --git a/src/quafu/dagcircuits/dag_test.ipynb b/src/quafu/dagcircuits/dag_test.ipynb index ce9ef10..2135d85 100644 --- a/src/quafu/dagcircuits/dag_test.ipynb +++ b/src/quafu/dagcircuits/dag_test.ipynb @@ -15,8 +15,7 @@ "source": [ "you should install `pygraphviz` ,`pydot` package for visualization \n", "`pip install pygraphviz ` \n", - "`pip install pydot`\n", - "before you install `pygraphviz` ,you should install `graphviz` first." + "`pip install pydot`" ] }, { @@ -34,7 +33,7 @@ "metadata": {}, "outputs": [], "source": [ - "from circuit_dag import circuit_to_dag, dag_to_circuit, draw_dag # gate_wrapper.py in the same folder as circuit_dag.py\n", + "from circuit_dag import circuit_to_dag, dag_to_circuit, draw_dag # instruction_node.py in the same folder as circuit_dag.py\n", "from quafu import QuantumCircuit" ] }, diff --git a/src/quafu/dagcircuits/dagcircuit_test.ipynb b/src/quafu/dagcircuits/dagcircuit_test.ipynb new file mode 100644 index 0000000..7ec063a --- /dev/null +++ b/src/quafu/dagcircuits/dagcircuit_test.ipynb @@ -0,0 +1,2976 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# `DAG`\n", + "- circuit in quafu to dag\n", + "- dag visualization briefly\n", + "- dag to circuit in quafu" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from quafu import User,QuantumCircuit,Task ,simulate\n", + "import quafu\n", + "import networkx as nx\n", + "from typing import Dict, Any, List" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + " you should install `pygraphviz` ,`pydot` package for visualization \n", + " `pip install pygraphviz ` \n", + " `pip install pydot`\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import pygraphviz as pgv\n", + "from networkx.drawing.nx_pydot import write_dot" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from networkx import MultiDiGraph" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# user = User()\n", + "# # user.save_apitoken(\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# task = Task()\n", + "# task.config(backend=\"ScQ-P18\", shots=2000, compile=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Dict, Any, List, Union\n", + "import dataclasses\n", + "\n", + "@dataclasses.dataclass\n", + "class InstructionNode: \n", + " name:Any # gate.name\n", + " pos:Union[List[Any], Dict[Any,Any]] # gate.pos | Dict[Any,Any] for measure\n", + " paras:List[Any] # gate.paras\n", + " # matrix:List[Any] # for gate in [QuantumGate]\n", + " duration:Union[int,float] # for gate in [Delay,XYResonance] in quafu \n", + " unit:str # for gate in [Delay,XYResonance] in quafu\n", + " label:str\n", + " \n", + " def __hash__(self):\n", + " return hash((type(self.name), tuple(self.pos) ,self.label))\n", + " \n", + " def __str__(self):\n", + " if self.name == 'measure':\n", + " args = ','.join(str(q) for q in self.pos.keys())\n", + " args += f'=>{\",\".join(str(c) for c in self.pos.values())}'\n", + " else: \n", + " args = ','.join(str(q) for q in self.pos)\n", + " \n", + " if self.paras == None:\n", + " return f'{self.label}{{{self.name}({args})}}'\n", + " else:\n", + " # if self.paras not a list, then make it a list of str of .3f float\n", + " if not isinstance(self.paras, list):\n", + " formatted_paras = [f'{self.paras:.3f}']\n", + " else:\n", + " formatted_paras = [f'{p:.3f}' for p in self.paras] \n", + " \n", + " formatted_paras_str = ','.join(formatted_paras)\n", + " \n", + " return f'{self.label}{{{self.name}({args})}}({formatted_paras_str})'\n", + " \n", + " def __repr__(self): \n", + " return str(self)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## dagcircuit class" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import networkx as nx\n", + "\n", + "from networkx.classes.multidigraph import MultiDiGraph\n", + "\n", + "class DAGCircuit(MultiDiGraph):\n", + " def __init__(self,qubits_used=None, cbits_used=None, incoming_graph_data=None, **attr):\n", + " super().__init__(incoming_graph_data, **attr)\n", + " \n", + " if qubits_used is None:\n", + " self.qubits_used = set()\n", + " elif isinstance(qubits_used, set):\n", + " self.qubits_used = qubits_used\n", + " else:\n", + " raise ValueError('qubits_used should be a set or None')\n", + "\n", + " if cbits_used is None:\n", + " self.cbits_used = set()\n", + " elif isinstance(cbits_used, set):\n", + " self.cbits_used = cbits_used\n", + " else:\n", + " raise ValueError('cbits_used should be a set or None')\n", + " \n", + " # num of instruction nodes\n", + " self.num_instruction_nodes = 0\n", + "\n", + "\n", + " # add new methods or override existing methods here.\n", + "\n", + " def update_qubits_used(self):\n", + " '''\n", + " qubits_used is a set of qubits used in DAGCircuit\n", + " based on node -1's edges' labels, the qubits is the integer part of the label\n", + "\n", + " return:\n", + " qubits_used: set of qubits used in DAGCircuit\n", + " '''\n", + " if -1 not in self.nodes:\n", + " raise ValueError('-1 should be in DAGCircuit, please add it first')\n", + " self.qubits_used = set([int(edge[2]['label'][1:]) for edge in self.out_edges(-1, data=True)])\n", + " return self.qubits_used\n", + " \n", + " def update_cbits_used(self):\n", + " '''\n", + " cbits_used is a set of cbits used in DAGCircuit\n", + " calculated by measurenode's cbits \n", + " return:\n", + " cbits_used: set of cbits used in DAGCircuit\n", + " '''\n", + " for node in self.nodes:\n", + " # if node.has a attribute 'name' and node.name == 'measure'\n", + " if hasattr(node, 'name') and node.name == 'measure':\n", + " self.cbits_used = set(node.pos.values()) \n", + " return self.cbits_used\n", + " \n", + " def update_num_instruction_nodes(self):\n", + " '''\n", + " num_instruction_nodes is the number of instruction nodes in DAGCircuit\n", + " '''\n", + " if -1 not in self.nodes:\n", + " raise ValueError('-1 should be in DAGCircuit, please add it first')\n", + " if float('inf') not in self.nodes:\n", + " raise ValueError('float(\"inf\") should be in DAGCircuit, please add it first')\n", + " self.num_instruction_nodes = len(self.nodes) - 2\n", + "\n", + " for node in self.nodes:\n", + " if hasattr(node, 'name') and node.name == 'measure':\n", + " self.num_instruction_nodes -= 1\n", + " return self.num_instruction_nodes\n", + "\n", + " \n", + "\n", + " def nodes_dict(self):\n", + " '''\n", + " nodes_dict is a dictionary of nodes with the node label as key and the node as value.\n", + " without -1 and float('inf')\n", + " '''\n", + " nodes_dict = {}\n", + " for node in self.nodes:\n", + " if node != -1 and node != float('inf'):\n", + " nodes_dict[node.label] = node\n", + " return nodes_dict\n", + " \n", + "\n", + " def nodes_list(self):\n", + " ''' \n", + " nodes_list is a list of nodes without -1 and float('inf')\n", + " ''' \n", + " nodes_list = []\n", + " for node in self.nodes:\n", + " if node != -1 and node != float('inf'):\n", + " nodes_list.append(node)\n", + " return nodes_list\n", + " \n", + " def node_qubits_predecessors(self, node:InstructionNode):\n", + " '''\n", + " node_qubits_predecessors is a dict of {qubits -> predecessors }of node\n", + " Args:\n", + " node in DAGCircuit, node should not be -1\n", + " Returns:\n", + " node_qubits_predecessors: dict of {qubits -> predecessors }of node\n", + " '''\n", + " # for edge in self.in_edges(node, data=True):\n", + " # print(edge[0], edge[1], edge[2])\n", + "\n", + " if node not in self.nodes:\n", + " raise ValueError('node should be in DAGCircuit')\n", + " if node in [-1]:\n", + " raise ValueError('-1 has no predecessors')\n", + "\n", + " predecessor_nodes = [edge[0] for edge in self.in_edges(node, data=True)]\n", + " qubits_labels = [int(edge[2]['label'][1:]) for edge in self.in_edges(node, data=True)]\n", + " node_qubits_predecessors = dict(zip(qubits_labels, predecessor_nodes))\n", + " return node_qubits_predecessors\n", + " \n", + " def node_qubits_successors(self, node:InstructionNode):\n", + " '''\n", + " node_qubits_successors is a dict of {qubits -> successors }of node\n", + " Args: \n", + " node in DAGCircuit, node should not be float('inf')\n", + " Returns:\n", + " node_qubits_successors: dict of {qubits -> successors }of node\n", + "\n", + "\n", + " '''\n", + " if node not in self.nodes:\n", + " raise ValueError('node should be in DAGCircuit')\n", + " if node in [float('inf')]:\n", + " raise ValueError('float(\"inf\") has no successors')\n", + " successor_nodes = [edge[1] for edge in self.out_edges(node, data=True)]\n", + " qubits_labels = [int(edge[2]['label'][1:]) for edge in self.out_edges(node, data=True)]\n", + " node_qubits_successors = dict(zip(qubits_labels, successor_nodes))\n", + " return node_qubits_successors\n", + "\n", + " def node_qubits_inedges(self, node:InstructionNode):\n", + " '''\n", + " node_qubits_inedges is a dict of {qubits -> inedges }of node\n", + " Args:\n", + " node in DAGCircuit, node should not be -1\n", + " Returns:\n", + " node_qubits_inedges: dict of {qubits -> inedges }of node\n", + " '''\n", + " if node not in self.nodes:\n", + " raise ValueError('node should be in DAGCircuit')\n", + " if node in [-1]:\n", + " raise ValueError('-1 has no predecessors')\n", + "\n", + " inedges = [edge for edge in self.in_edges(node)]\n", + " qubits_labels = [int(edge[2]['label'][1:]) for edge in self.in_edges(node, data=True)]\n", + " node_qubits_inedges = dict(zip(qubits_labels, inedges))\n", + " return node_qubits_inedges\n", + " \n", + " def node_qubits_outedges(self, node:InstructionNode):\n", + " '''\n", + " node_qubits_outedges is a dict of {qubits -> outedges }of node\n", + " Args:\n", + " node in DAGCircuit, node should not be float('inf')\n", + " Returns:\n", + " node_qubits_outedges: dict of {qubits -> outedges }of node\n", + " '''\n", + " if node not in self.nodes:\n", + " raise ValueError('node should be in DAGCircuit')\n", + " if node in [float('inf')]:\n", + " raise ValueError('float(\"inf\") has no successors')\n", + " outedges = [edge for edge in self.out_edges(node)]\n", + " qubits_labels = [int(edge[2]['label'][1:]) for edge in self.out_edges(node, data=True)]\n", + " node_qubits_outedges = dict(zip(qubits_labels, outedges))\n", + " return node_qubits_outedges\n", + " \n", + " def remove_instruction_node(self, gate:InstructionNode):\n", + " '''\n", + " remove a gate from DAGCircuit, and all edges connected to it.\n", + " add new edges about qubits of removed gate between all predecessors and successors of removed gate.\n", + " Args:\n", + " gate: InstructionNode, gate should be in DAGCircuit, gate should not be -1 or float('inf')\n", + " '''\n", + "\n", + " if gate not in self.nodes:\n", + " raise ValueError('gate should be in DAGCircuit')\n", + " if gate in [-1, float('inf')]:\n", + " raise ValueError('gate should not be -1 or float(\"inf\")')\n", + "\n", + " qubits_predecessors = self.node_qubits_predecessors(gate)\n", + " qubits_successors = self.node_qubits_successors(gate)\n", + " for qubit in gate.pos:\n", + " if qubits_predecessors[qubit] != -1 and qubits_successors[qubit] != float('inf'):\n", + " self.add_edge(qubits_predecessors[qubit], qubits_successors[qubit], label=f'q{qubit}')\n", + " elif qubits_predecessors[qubit] == -1 and qubits_successors[qubit] != float('inf'):\n", + " self.add_edge(qubits_predecessors[qubit], qubits_successors[qubit], label=f'q{qubit}',color='green')\n", + " else:\n", + " self.add_edge(qubits_predecessors[qubit], qubits_successors[qubit], label=f'q{qubit}',color='red')\n", + "\n", + " self.remove_node(gate)\n", + "\n", + " # update qubits\n", + " self.qubits_used = self.update_qubits_used()\n", + "\n", + "\n", + " def merge_dag(self, other_dag):\n", + " '''\n", + " merge other_dag into self\n", + " Args:\n", + " other_dag: DAGCircuit\n", + " Returns:\n", + " self: DAGCircuit\n", + " '''\n", + " if not isinstance(other_dag, DAGCircuit):\n", + " raise ValueError('other_dag should be a DAGCircuit')\n", + " if other_dag == None:\n", + " return self\n", + " if self == None:\n", + " return other_dag\n", + " \n", + " # for the same qubits (intersection), \n", + " # remove the outgoing edges from the final node of the original DAG and the incoming edges from the initial node of the other DAG,\n", + " # then connect the corresponding tail and head nodes by adding edges\n", + " other_dag_qubits_used = other_dag.update_qubits_used()\n", + " self_qubits_used = self.update_qubits_used()\n", + "\n", + " insect_qubits = self_qubits_used & other_dag_qubits_used\n", + " end_edges_labels_1 = self.node_qubits_inedges(float('inf'))\n", + " start_edges_labels_2 = other_dag.node_qubits_outedges(-1)\n", + "\n", + " if len(insect_qubits) != 0:\n", + " for insect_qubit in insect_qubits:\n", + " self.remove_edges_from([end_edges_labels_1[insect_qubit]])\n", + " other_dag.remove_edges_from([start_edges_labels_2[insect_qubit]])\n", + " self.add_edge(end_edges_labels_1[insect_qubit][0], start_edges_labels_2[insect_qubit][1], label=f'q{insect_qubit}')\n", + " \n", + " # add other_dag's nodes and edges into self\n", + " # ！if we add edges, we don't need to add nodes again\n", + " self.add_edges_from(other_dag.edges(data=True))\n", + "\n", + " # remove the edges between -1 and float('inf')\n", + " self.remove_edges_from([edge for edge in self.edges(data=True) if edge[0] == -1 and edge[1] == float('inf')])\n", + " \n", + " # update qubits \n", + " self.qubits_used = self.update_qubits_used()\n", + " \n", + " def add_instruction_node(self, gate:InstructionNode,predecessors_dict:Dict[int,InstructionNode],successors_dict:Dict[int,InstructionNode]):\n", + " '''\n", + " add a gate into DAGCircuit, and all edges connected to it.\n", + " add new edges about qubits of new gate between all predecessors and successors of new gate.\n", + " Args:\n", + " gate: InstructionNode, gate should not be -1 or float('inf')\n", + " predecessors_dict: dict of {qubits -> predecessors }of gate\n", + " successors_dict: dict of {qubits -> successors }of gate\n", + " '''\n", + " if gate in [-1, float('inf')]:\n", + " raise ValueError('gate should not be -1 or float(\"inf\")')\n", + " \n", + " #remove the edges between the predessors,successors about the qubits used by the added node\n", + " qubits_pre_out_edges = []\n", + " qubits_suc_in_edges = []\n", + " for qubit in gate.pos:\n", + " pre_out_edges = self.node_qubits_outedges(predecessors_dict[qubit])\n", + " qubits_pre_out_edges.append(pre_out_edges[qubit])\n", + "\n", + " suc_in_edges = self.node_qubits_inedges(successors_dict[qubit])\n", + " qubits_suc_in_edges.append(suc_in_edges[qubit])\n", + "\n", + " self.remove_edges_from(qubits_pre_out_edges)\n", + " self.remove_edges_from(qubits_suc_in_edges)\n", + "\n", + " # add the new node and edges\n", + " for qubit in gate.pos:\n", + " if predecessors_dict[qubit] == -1:\n", + " self.add_edge(predecessors_dict[qubit], gate, label=f'q{qubit}',color='green')\n", + " else:\n", + " self.add_edge(predecessors_dict[qubit], gate, label=f'q{qubit}')\n", + " if successors_dict[qubit] == float('inf'):\n", + " self.add_edge(gate, successors_dict[qubit], label=f'q{qubit}',color='red')\n", + " else:\n", + " self.add_edge(gate, successors_dict[qubit], label=f'q{qubit}')\n", + "\n", + " # update qubits\n", + " self.qubits_used = self.update_qubits_used()\n", + "\n", + "\n", + " def is_dag(self):\n", + " '''\n", + " is_dag is a bool value to check if DAGCircuit is a DAG\n", + " '''\n", + " return nx.is_directed_acyclic_graph(self)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from quafu import QuantumCircuit\n", + "\n", + "from quafu.elements.element_gates import * \n", + "from quafu.elements.quantum_element import Barrier, Delay, ControlledGate, MultiQubitGate, ParaMultiQubitGate, QuantumGate, SingleQubitGate, XYResonance\n", + "\n", + "import networkx as nx\n", + "from typing import Dict, Any, List, Union\n", + "import copy\n", + "\n", + "# from instruction_node import InstructionNode # instruction_node.py in the same folder as circuit_dag.py now\n", + "\n", + "# import pygraphviz as pgv\n", + "from networkx.drawing.nx_pydot import write_dot\n", + "from IPython.display import Image, SVG\n", + "\n", + "\n", + "\n", + "# transform a gate in quantumcircuit of quafu(not include measure_gate),\n", + "# into a node in the graph, with specific label.\n", + "def gate_to_node(input_gate,specific_label: str):\n", + " ''' \n", + " transform a gate in quantumcircuit of quafu(not include measure_gate),\n", + " into a node in the graph, with specific label.\n", + "\n", + " Args:\n", + " inputgate: a gate in quantumcircuit of quafu(not include measure_gate)\n", + " label: the label of the node in the graph\n", + "\n", + " Returns:\n", + " node: a node in the graph, with specific label. A GateWrapper object\n", + " \n", + " '''\n", + "\n", + " import copy\n", + " gate = copy.deepcopy(input_gate) # avoid modifying the original gate\n", + " if not isinstance(gate.pos, list): # if gate.pos is not a list, make it a list\n", + " gate.pos = [gate.pos]\n", + "\n", + " # use getattr check 'paras' and other attributes if exist. if the attr doesn't exist,return None\n", + " gate.paras = getattr(gate, 'paras', None) or None\n", + " gate.duration = getattr(gate, 'duration', None) or None\n", + " gate.unit = getattr(gate, 'unit', None) or None \n", + "\n", + " if gate.paras and not isinstance(gate.paras, list): # if paras is True and not a list, make it a list\n", + " gate.paras = [gate.paras]\n", + " \n", + " # hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.matrix,gate.duration,gate.unit, label=i)\n", + " hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.duration,gate.unit, label=specific_label)\n", + " return hashable_gate\n", + "\n", + "\n", + "# Building a DAG Graph using NetworkX from a QuantumCircuit\n", + "def circuit_to_dag(circuit,measure_flag = True):\n", + " '''\n", + " Building a DAG Graph using NetworkX from a QuantumCircuit\n", + " \n", + " Args:\n", + " circuit: a QuantumCircuit object\n", + " \n", + " Returns:\n", + " g: a networkx MultiDiGraph object\n", + " \n", + " example:\n", + " .. jupyter-execute::\n", + " \n", + " from circuit_dag import circuit_to_dag, dag_to_circuit, draw_dag\n", + " from quafu import QuantumCircuit\n", + "\n", + " # Create a quantum circuit as an example that you can modify as needed\n", + " circuit = QuantumCircuit(2)\n", + " circuit.h(0)\n", + " circuit.cnot(0, 1)\n", + "\n", + " # Build the dag graph\n", + " dep_graph = circuit_to_dag(circuit) # dag graph \n", + " '''\n", + " \n", + " # Starting Label Index\n", + " i = 0\n", + " \n", + " # A dictionary to store the last use of any qubit\n", + " qubit_last_use = {}\n", + " \n", + " # g = nx.MultiDiGraph() # two nodes can have multiple edges\n", + " # g = nx.DiGraph() # two nodes can only have one edge\n", + " g = DAGCircuit() # two nodes can only have one edge\n", + " \n", + " # Add the start node \n", + " # g.add_node(-1,{\"color\": \"green\"})\n", + " g.add_nodes_from([(-1, {\"color\": \"green\"})])\n", + " \n", + " # deepcopy the circuit to avoid modifying the original circuit\n", + " # gates = copy.deepcopy(circuit.gates) # need to import copy\n", + " # change to: gate = copy.deepcopy(input_gate) in gate_to_node()\n", + "\n", + " for gate in circuit.gates:\n", + " # transform gate to node\n", + " hashable_gate = gate_to_node(gate,specific_label=i)\n", + " i += 1\n", + " \n", + " g.add_node(hashable_gate,color=\"blue\")\n", + " \n", + " # Add edges based on qubit_last_use; update last use\n", + " for qubit in hashable_gate.pos:\n", + " if qubit in qubit_last_use:\n", + " g.add_edge(qubit_last_use[qubit], hashable_gate,label=f'q{qubit}')\n", + " else:\n", + " g.add_edge(-1, hashable_gate,label=f'q{qubit}',color=\"green\")\n", + " \n", + " qubit_last_use[qubit] = hashable_gate\n", + "\n", + " if measure_flag: \n", + " # Add measure_gate node\n", + " qm = Any\n", + " qm.name = \"measure\" \n", + " qm.paras, qm.duration, qm.unit = [None,None,None]\n", + " qm.pos = copy.deepcopy(circuit.measures) # circuit.measures is a dict\n", + " measure_gate = InstructionNode(qm.name, qm.pos, qm.paras, qm.duration, qm.unit, label=\"m\")\n", + " g.add_node(measure_gate,color=\"blue\")\n", + " # Add edges from qubit_last_use[qubit] to measure_gate\n", + " for qubit in measure_gate.pos:\n", + " if qubit in qubit_last_use:\n", + " g.add_edge(qubit_last_use[qubit], measure_gate,label=f'q{qubit}')\n", + " else:\n", + " g.add_edge(-1, measure_gate,label=f'q{qubit}',color=\"green\")\n", + "\n", + " qubit_last_use[qubit] = measure_gate\n", + " \n", + " # Add the end node\n", + " # g.add_node(float('inf'),{\"color\": \"red\"})\n", + " g.add_nodes_from([(float('inf'), {\"color\": \"red\"})])\n", + " \n", + " for qubit in qubit_last_use:\n", + " g.add_edge(qubit_last_use[qubit], float('inf'),label=f'q{qubit}',color=\"red\")\n", + " \n", + " # update qubits_used, cbits_used, num_instruction_nodes\n", + " g.update_qubits_used()\n", + " g.update_cbits_used()\n", + " g.update_num_instruction_nodes()\n", + "\n", + " return g\n", + "\n", + "\n", + "# transform gate in dag nodes to gate in circuit which can be added to circuit\n", + "gate_classes = {\n", + " \"x\": XGate,\n", + " \"y\": YGate,\n", + " \"z\": ZGate,\n", + " \"h\": HGate,\n", + " \"s\": SGate,\n", + " \"sdg\": SdgGate,\n", + " \"t\": TGate,\n", + " \"tdg\": TdgGate,\n", + " \"rx\": RXGate,\n", + " \"ry\": RYGate,\n", + " \"rz\": RZGate,\n", + " \"id\": IdGate,\n", + " \"sx\": SXGate,\n", + " \"sy\": SYGate,\n", + " \"w\": WGate,\n", + " \"sw\": SWGate,\n", + " \"p\": PhaseGate,\n", + " \"delay\": Delay,\n", + " \"barrier\": Barrier,\n", + " \"cx\": CXGate,\n", + " \"cp\": CPGate,\n", + " \"swap\": SwapGate,\n", + " \"rxx\": RXXGate,\n", + " \"ryy\": RYYGate,\n", + " \"rzz\": RZZGate,\n", + " \"cy\": CYGate,\n", + " \"cz\": CZGate,\n", + " \"cs\": CSGate,\n", + " \"ct\": CTGate,\n", + " \"xy\": XYResonance,\n", + " \"ccx\": ToffoliGate,\n", + " \"cswap\": FredkinGate,\n", + " \"mcx\": MCXGate,\n", + " \"mcy\": MCYGate,\n", + " \"mcz\": MCZGate,\n", + "}\n", + "\n", + "def node_to_gate(gate_in_dag):\n", + " \"\"\"\n", + " transform gate in dag graph, to gate in circuit which can be added to circuit\n", + "\n", + " Args:\n", + " gate_in_dag: a node in dag graph , gate_in_dag is a GateWrapper object. \n", + " in GateWrapper, gate_in_dag.name is uppercase, gate_in_dag.pos is a list or a dict\n", + " gate_transform support gate with one qubit or more qubits, not measures!\n", + " and you should exculde nodes [-1 ,float('inf') , measure_gate] in dag graph\n", + "\n", + " Returns:\n", + " gate: gate which can be added to circuit in quafu\n", + "\n", + " example:\n", + " import networkx as nx\n", + " from quafu import QuantumCircuit\n", + " qcircuit = QuantumCircuit(n)\n", + "\n", + " for gate in nx.topological_sort(dep_graph):\n", + " \n", + " if gate not in [-1, float('inf')]:\n", + " # measure gate to do\n", + " if gate.name == \"measure\":\n", + " qcircuit.measures = gate.pos\n", + "\n", + " else:\n", + " # use gate_transform to transform gate in dag graph to gate in circuit\n", + " qcircuit.gates.append(node_to_gate(gate))\n", + " return qcircuit\n", + " \n", + " \"\"\"\n", + "\n", + " gate_name = gate_in_dag.name.lower()\n", + " gate_class = gate_classes.get(gate_name)\n", + "\n", + " if not gate_class:\n", + " raise ValueError(\"gate is not supported\")\n", + "\n", + " if gate_name == \"barrier\":\n", + " return gate_class(gate_in_dag.pos)\n", + "\n", + " # 从gate_in_dag获取参数列表\n", + " args = gate_in_dag.pos\n", + " if gate_in_dag.paras:\n", + " args += gate_in_dag.paras\n", + "\n", + " # 处理 gate.duration 和 gate.unit\n", + " if gate_name in [\"delay\", \"xy\"]:\n", + " args.append(gate_in_dag.duration)\n", + " args.append(gate_in_dag.unit)\n", + "\n", + " # 处理多量子比特门\n", + " if gate_name in [\"mcx\", \"mcy\", \"mcz\"]:\n", + " control_qubits = gate_in_dag.pos[:-1]\n", + " target_qubit = gate_in_dag.pos[-1]\n", + " return gate_class(control_qubits, target_qubit)\n", + "\n", + " return gate_class(*args)\n", + "\n", + "\n", + "\n", + "# From DAG with Hashable Gates to quafu Gates added to circuit \n", + "def dag_to_circuit(dep_graph, n: int):\n", + " '''\n", + " From DAG with Hashable Gates to quafu Gates added to circuit\n", + " \n", + " Args:\n", + " dep_graph (DAG): DAG with Hashable Gates\n", + " n (int): number of qubits\n", + " \n", + " Returns:\n", + " qcircuit (QuantumCircuit): quafu QuantumCircuit\n", + " \n", + " example:\n", + " .. jupyter-execute::\n", + "\n", + " from circuit_dag import circuit_to_dag, dag_to_circuit, draw_dag\n", + " from quafu import QuantumCircuit\n", + "\n", + " # Create a quantum circuit as an example that you can modify as needed\n", + " circuit = QuantumCircuit(2)\n", + " circuit.h(0)\n", + " circuit.cnot(0, 1)\n", + "\n", + " # Build the dag graph\n", + " dep_graph = circuit_to_dag(circuit) # dag graph \n", + " \n", + " # use dag_to_circuit to transform dag graph to a new circuit\n", + " reconstructed_circuit = dag_to_circuit(dep_graph, circuit.num)\n", + " \n", + " \n", + " '''\n", + " \n", + " qcircuit = QuantumCircuit(n)\n", + "\n", + " for gate in nx.topological_sort(dep_graph):\n", + " \n", + " if gate not in [-1, float('inf')]:\n", + " # measure gate to do\n", + " if gate.name == \"measure\":\n", + " qcircuit.measures = gate.pos\n", + "\n", + " else:\n", + " # use gate_transform to transform gate in dag graph to gate in circuit\n", + " qcircuit.gates.append(node_to_gate(gate))\n", + " return qcircuit\n", + "\n", + "# Helper function to visualize the DAG,check the example in the docstring\n", + "def draw_dag(dep_g, output_format=\"png\"):\n", + " '''\n", + " Helper function to visualize the DAG\n", + "\n", + " Args:\n", + " dep_g (DAG): DAG with Hashable Gates\n", + " output_format (str): output format, \"png\" or \"svg\"\n", + "\n", + " Returns:\n", + " img (Image or SVG): show the image of DAG, which is Image(filename=\"dag.png\") or SVG(filename=\"dag.svg\")\n", + "\n", + " example:\n", + " .. jupyter-execute::\n", + " ex1:\n", + " # directly draw PNG picture\n", + " draw_dag(dep_g, output_format=\"png\") # save a png picture \"dag.png\" and show it in jupyter notebook\n", + "\n", + " # directly draw SVG picture\n", + " draw_dag(dep_g, output_format=\"svg\") # save a svg picture \"dag.svg\" and show it in jupyter notebook\n", + " \n", + " ex2:\n", + " # generate PNG picture\n", + " img_png = draw_dag(dep_g, output_format=\"png\") \n", + "\n", + " # generate SVG picture\n", + " img_svg = draw_dag(dep_g, output_format=\"svg\") \n", + " \n", + " # show PNG picture\n", + " img_png\n", + " \n", + " # show SVG picture\n", + " img_svg \n", + "\n", + " \n", + " '''\n", + " import pygraphviz \n", + "\n", + " write_dot(dep_g, \"dag.dot\")\n", + " G = pygraphviz.AGraph(\"dag.dot\")\n", + " G.layout(prog=\"dot\")\n", + "\n", + " if output_format == \"png\":\n", + " G.draw(\"dag.png\")\n", + " return Image(filename=\"dag.png\")\n", + " elif output_format == \"svg\":\n", + " G.draw(\"dag.svg\")\n", + " return SVG(filename=\"dag.svg\")\n", + " else:\n", + " raise ValueError(\"Unsupported output format: choose either 'png' or 'svg'\")\n", + "\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Transforming QuantumCircuit into DAG" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from circuit_dag import circuit_to_dag, dag_to_circuit, draw_dag\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAY7CAYAAAARbWiHAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeVxU1f/48dfAIIssCm4IlBaaimua4ZapuKBpLqGZlWYW7rZZLtXXT339tlhambtWftwNTdPMJfXnviu45Z4byiYggoDAnN8fJ1BkkWVm7sxwnjzuA7z3zjnvQT3vueeee45OCCFQFEVRypqZdlpHoCiKomhDJQBFUZQySiUARVGUMkqvdQCKYk0yyCCGGKKJJpFEDBhIIokssihPecpRDhdcqEAFfPDBAw+tQ1aUAqkEoCj5SCaZgxzkBCc4xSlOcILLXCaaaARFHzfhggu++FKXutSjHg1oQFOaUpvaJoxeUYpGp0YBKQpkkcUudvEnf7KTnRzmMJlkUpnKNKABAQTgjz8++OCNN1WpSkUqokOHO+7YY08yyWSQQSqpxBPPda4TRRRXucppTnOSk5zjHBlk4I03bWlLO9rRgx5Uo5rWvwKl7JmpEoBSZgkE29jGMpbxO78TSyx1qEM72vHcv1/VqW7UOjPI4DCH2fnv1w52kEoqLWhBH/rwKq9SmcpGrVNRCqASgFL2JJLIT/zEHOZwjnM8wzP0/vfL3F0zqaSymc38xm+sZS2ppNKb3gxjGG1oY9ZYlDJHJQCl7EgiiVnM4ku+xICBl3mZYQyjMY21Dg2AdNL5nd+Zy1z+4i9a0YqP+IjudNc6NMU2qQfBFNuXQQZTmIIffkxhCmMZy3WuM4c5FtP4AzjiSAghbGELu9iFCy70oAftac9JTmodnmKDVAJQbNoudtGEJvwP/8N7vMc//MMEJuCGm9ahFao1rdnMZvawh2SSeZqnGctYUkjROjTFhqgEoNikTDL5mI95nud5jMc4wQn+h/+x+Ib/YS1pyX728wM/sIAFNKMZEURoHZZiI1QCUGzOTW7SlrZMZSqzmMUGNvAkT2odVonZYcdQhnKc41SlKoEEMo95Woel2AD1IJhiU85ylmCCKUc5DnGIAAK0DslofPFlK1v5D/8hlFCucIXP+RwdOq1DU6yUSgCKzQgnnI50pBa1WMc6vPDSOiSjs8eez/iMJ3iCt3mbGGKYwxyVBJQSUQlAsQkXuUgwwTSmMWtZiwsuWodkUoMYRCUq0ZveVKQiX/GV1iEpVkjdA1CsXgIJdKYzvviymtU23/hne4EX+Jmf+YZv+JEftQ5HsULqCkCxem/zNmmksYENVjfKp7QGMIDLXOYDPqAVrWhCE61DUqyIehJYsWq/8Atv8iZ/8RftaKd1OJowYKAjHbnBDY5xDCectA5JsQ7qSWDFet3hDh/xEaMYZRGN/4YNG6hduzZ6vXkvrO2wYyELucY1fuAHs9atWDeVABSr9RVfkUEGn/KppnFcvHiRHj16MH78eKKjozWJwRdf3ud9vuALbnFLkxgU66MSgGKVUkllBjMYy1g88dQ0lk8++YSWLVty5MgR3Ny0uwfxAR+gQ8cCFmgWg2Jd1D0AxSotZSkDGcg1rmm+mEpqairOzs4A+Pr6EhUVRWZmpiaxjGQkW9jCGc6oZwOUR1H3ABTrtJzlBBOseeMP5DT+lmAwgznHOY5xTOtQFCugEoBidQSCPeyhIx21DsXiNKEJlajEbnZrHYpiBVQCUKzOWc4STzwtaKF1KBZHh45neZa97NU6FMUKqASgWJ0rXAHgKZ7SOBLLVJvaOb8jRSmMSgCK1YkjDgcccMXVLPWdPHkSnU6Xaxs5cqRZ6i4JL7zUUFClSNRUEIrVSSUVF1zMNsqlfv36WNNgOVdcSSZZ6zAUK6CuABSrU5GKJJFEJtoMtbR08cTb5FTYivGpBKBYHS+8EAjVzVGAGGJUAlCKRCUAxerUpz46dGqsewGOcpQGNNA6DMUKqASgWJ1KVKIWtSxmqOP69etzbg5HRkaSlZWV8+f58+ebNZZUUgknXA2RVYpETQWhWKVhDGMPezjOca1DsSirWEU/+nGVq1SnutbhKJZNTQWhWKeBDOQEJzjMYa1DsSgLWEAnOqnGXykSlQAUqxRIIPWpzzSmaR2KxTjNaTazmSEM0ToUxUqoLiDFaq1iFSGEcJCDNKOZ1uForjvducY1jnIUO/XZTnm0mSoBKFZLIGhNawB2shN77DWOSDt/8idd6comNtGJTlqHo1gHdQ9AsV46dMxlLsc4xmQmax2OZmKIYTCD6Utf1fgrxaISgGLVAgjga77mcz5nM5u1Dsfs7nGP/vSnPOWZxzytw1GsjEoAitUbwQj6058+9OEQh7QOx2wMGHid1znMYcIIwx13rUNSrIxKAIrVy14H9zmeoytdy8TQ0EwyGcIQ1vz71ZjGWoekWCGVABSb4IADv/Irz/AM7WjHn/ypdUgmk0IKPenJClawilW0o53WISlWSiUAxWa44MLv/E4IIfSgB1/wBQYMWodlVGc4QytacZCDbGMb3eimdUiKFVMJQLEpevQsYAFf8zWf8imd6EQkkVqHZRQ/8zPNaIYjjhzgAM/yrNYhKVZOJQDF5tzhDgc4gAED5zhHXeoyjWlWu37AaU7TnvYMYQjDGMZudlOTmlqHpdgAlQAUm3KMYzSjGdvYxgY2cJazvMu7TGACTWjCb/yGwDqefYwkktGMpjGNucMd9rGPKUzBAQetQ1NshEoAis2Yy1xa0hI//DjOcTrTGWec+Q//4QQnqEtdXuIlmtCEFawggwytQ87XBS4wilH4488a1vAjP3KAAzSnudahKTZGJQDF6mWQwTCGMZShfMiHbGYz1aiW6xx//FnJSiKIoA51GMAA/PBjPOM5z3mNIr8vnXRWsYpOdKI2tfmd3/mWbznPed7mbTW3j2ISai4gxard4hZ96ctBDrKQhfSmd5Fed41rzGc+C1hAJJE0ohG96c2LvEhDGpplwflEEvmLv1jFKjawgRRS6EIXQgmlK13L9NxGilmoyeAU6xVBBD3piQ4da1lbomUQM8lkBztYzWrWsIYb3MALL1rTmud4jkY0ogENqEKVUsV6j3uc5SwnOcl+9rOTnRznODp0PMdz9KEPveil5vFXzEklAMU6bWELfehDM5qxkpVUolKpyzRgIIIIdrKTHexgD3uIIQaQy1DWpjbeeOODD1WpijvulKMc5SlPOcqRRBJZZJFEEre5zTWuEUUUV7nKBS6QQQb22FOe8gxmMG1pSxvaqAXcFa2oBKBYn8UsZjCD6Uc/FrCAcpQzWV2BBNKKVjzGY/zDP9z49yuGGJJI4h73SCaZDDJwww09ejzwwA03/PCjKlXxw4+61CWAAGKJpQMd2MWunKmsFUUjKgEo1uV7vuc93mMkI5nGNJPeHN3DHlrTmv3sN+pDV61pTUUqso51RitTUUpArQegWAeB4L1/v6Yxje/53uQjY6YznaY0NfoTtx/xEX/wB+GEG7VcRSkulQAUiycQjGY0P/IjS1nKaEabvM4b3GA1q3mXd41e9gu8QAABfMu3Ri9bUYpDJQDFomU3/nOYw3KW049+Zql3JjOpSEVe4iWjl61Dx4d8yDKWcZGLRi9fUYpKJQDFYgkEoxjFHOawghVFHuNfWumkM5/5DGMYjjiapI6XeRlffPme701SvqIUhUoAisUaxSjmMY+VrKQXvcxW71KWkkACQxlqsjoccOA93mMBC4gl1mT1KEphVAJQLNJkJjOb2SxlKT3pada6ZzKTvvTNM52EsQ1hCOUpz3Smm7QeRSmISgCKxVnMYj7hE6YylT70MWvdu9jFYQ4zilEmr8sFF0Yykh/5kTvcMXl9ivIwlQAUi7KBDbzBG3zMx2YZ7fOw6UwnkECzzbw5kpFkksk85pmlPkV5kEoAisU4xjH60pfXeZ3/8B+z13+Na/zGb2b59J/NE0+GMISpTOUe98xWr6KASgCKhYgnnj70IZBA5jDHLLNxPmw606lCFZMM/SzMe7xHLLEsZrFZ61UUlQAUzRkw8BqvkUkmy1iGHr3ZY0ghhQUsYBSjTDq3UH588WUAA/iar21uEXvFsqkEoGjucz5nC1tYxjIqU1mTGH7iJ9JI4y3e0qT+j/iI85xnLWs1qV8pm9RkcIqmNrOZYIKZznSGM1yTGAwYeIqn6EQnZjBDkxgAetGLaKLZy17NYlDKFDUbqKKdRBIJIIC2tGUpSzWLYw1r6E1vTnOaOtTRLI5d7OI5nmMve2lBC83iUMoMlQAU7bzBG2xkI6c4hSeemsXRlrZ44MHv/K5ZDNkCCeQxHmMlK7UORbF9M81/t01RgL/4i4UsJIwwTRv/oxxlJzvZxjbNYnjQGMbwGq9xiUs8wRNah6PYOHUFoJhdEknUpz5taMMSlmgay6u8ynGOE0GEJkNPH5ZJJk/yJH3ow1Smah2OYtvUgjCK+X3Mx6STrvlMmDe4wa/8yvu8bxGNP4AePaMYxXzmc5vbWoej2DiVABSz+od/mMMcJjPZKAu5l8Z0plOBCmZbY6Co3uZt7LBjPvO1DkWxcSoBKGY1gQnUoAaDGKRpHCmkMJe5jGQkTjhpGsvD3HHnDd7gO74jgwytw1FsmEoAitlEEMFKVvIFX2jytO+DFrCANNIYxjBN4yjIGMYQRRSrWKV1KIoNUzeBFbPpTGcSSWQ/+zXtc88kE3/86UEPfuAHzeJ4lBBCuMxlDnFI61AU26RuAivmcYhDbGYzX/CF5jdcl7Oc61xnDGM0jeNR3uVdDnOY3ezWOhTFRqkEoJjF93xPE5rQnvYlLiM8PJxu3bpRoUIF3NzcCAoKYs+ePcUuZypT6Uc/nuTJEseSbcOGDdSuXRu93vhdWi1pSSCBTGOa0ctOSEhg9uzZtG/fHk9PT5ydnalVqxYDBgwgIiLC6PUplkklAMXkYoghjLBSLfBy4MABWrZsiZubG3///Tf//PMPTzzxBM8//zybN28ucjl/8ifHOMb7vF/iWAAuXrxIjx49GD9+PNHR0aUqqzDv8i5rWMNFLhq13LFjxzJq1ChefPFFTp8+za1bt/jpp58IDw+nadOmrFmzxqj1KZZJ3QNQTO4zPuNHfuQqV0s04sZgMNCwYUPi4+O5ePEizs7OAGRlZREQEMDdu3c5f/48jo6OjyyrPe0pRzk2srHYcTzolVdeoWHDhnzwwQfUqFGDqKgoMjMzS1VmfrLIoja1eYEXjPrcxJAhQ7C3t2fOnDm59kdERNC4cWNq1arFuXPnjFafYpFmIhTFxGqJWuI98V6JX799+3YBiFGjRuU5NmnSJAGIsLCwR5ZzSBwSCMRWsbXEsWS7e/duzs8+Pj7C3t6+1GUW5FvxrSgvyos4EWeyOh7k7Ows7OzshMFgMEt9imZmqC4gxaQOc5jznKc//UtcxrZtcp6eZs2a5TmWvW/r1q2PLOcrvqIxjUt1HyJb9lWIObzFW+jRm+XBsJSUFFJTU6lfvz46nWU8Ha2YjkoAikmtYAVP8iRNaZpr/5kzZ+jZsyceHh64uLjQvHlz1q9fT1BQEDqdDp1Ox5AhQ3LOBfD19c1Tvo+PD8AjuysucYnf+I3xjM/3eHHiMTc33HiTN5nO9ELXDTbGe/j1118BmDhxolHfg2KhtL4GUWxbDVFDTBATcu07f/68qFChgvDx8RGbN28Wd+7cESdPnhRBQUGicuXKwtHRMdf5HTt2FIDYv39/nvLPnz8vAPH0008XGsdQMVQ8IZ4QGSIj3zKKE8/DTN0FJIQQl8VloRd6sVQszfd4ad+DEEJERUWJqlWriiFDhhg7fMUyzVAJQDGZM+KMQCD2iD259oeEhOTbbx8TEyNcXFyKlQDOnTsnANG0adMC44gW0cJZOIsZYka+x4sbz8PMkQCEEKKX6CVai9b5Hivte4iLixONGzcW/fr1E5mZmUaLWbFo6h6AYjpb2II77jzDM7n2b9woR+B07tw51/7KlStTp07eFbkqVKgAyP7ph2Xvyz4nP9OYhhtuvMEb+R4vbjxaGc5wdrOboxzNc6w07yElJYXOnTtTr149lixZgr29vfGCViyaSgCKyWxhC+1pjwMOOfvS09O5c+cOTk5OuLq65nlNxYoV8+zLbsCuX7+e51hkZCQAtWvXzjeGeOKZwQze532cyXvjtiTxaCWIIAIIYA65h26W5j1kZmYSEhKCj48PCxcuVI1/GaMSgGISBgzsZCcd6JBrv6OjI25ubqSlpZGcnJzndTExMXn2tWvXDoAjR47kOZa9r0OHDnmOAXzHdzjgUOCkbyWJR0tv8zaLWUwCCTn7SvMeQkNDSU9PZ+XKlbmeZvb392f//v3GDV6xOCoBKCZxjnMkkkgggXmOBQcHA/e7LbJFRUXlO5qnbdu21KtXj7CwMNLS0nL2Z2VlsXz5cvz8/OjWrVue1yWRxI/8yLu8ixtuBcZa3Hi09AZvYI89i1iUa39J3sOkSZM4deoUa9euLdJDdIoN0vouhGKbFoqFwlE4ijSRlufYhQsXhKenZ64RKydOnBBdunQRjz/+eL43LPft2yecnJzEyy+/LG7evCni4uJEaGio0Ov1YuPGjfnG8Ln4XHgID5EgEgqNtSTxPMhcN4GzhYpQUUvUEgZx/0Gt4r6Hn3/+WQCFbvv27TPbe1I0oUYBKaYxUowUzUXzAo+fPXtW9OzZU7i7uwsXFxfRsmVLsWPHDtGhQ4cCG9yjR4+K4OBg4e7uLlxdXUX79u3F7t278z03WSSLyqKy+ER8UqR4ixvPunXrCmw4582bV6Q6S+qkOCkQiC1iS4nfQ7du3VQCUGaouYAUk3iO5wgggFnMKtbrgoKC2L17d66unpL4mq/5jM+4zOVSLT1prHiMrQ1tqExlVrP6keda6ntQNKfWA1BM4wxnqEtdTepOI43v+I6RjNR83WFTGc5wfud3rnBF61AUK6YSgGJ08cQTSyx10GYM/Wxmc5vbvMd7mtRvDi/xElWpyjzmaR2KYsVUAlCM7m/+BihWAli+fDk6nY6tW7eSnp5e4rl30knnG74hlFCqUKXYrzd2PKbigAODGcxc5pJOer7nWPp7ULSn7gEoRreYxQxhCKmkmn35x5nM5D3e4yIX8cHHrHWb2w1uUIMaLGRhqWZbVcosdQ9AMb7rXMcHH7M3/mmk8SVf8hZv2XzjD1Cd6rzAC8xghtahKFZKJQDF6CKJ1KQBnslM4ohjHOPMXrdWRjCCPezJd34gRXkUlQAUo9MiASSTzFd8xRjGlIlP/9k60CHf+YEUpShUAlCMLpZYKlPZrHV+y7ekk85Yxpq1XkuQ3/xAilIUKgEoRhdPPJ54mq2+OOKYylTGMtas9VqK7PmB/st/tQ5FsTIqAShGl0giFSh4fn5j+5IvccSR0Yw2W52WxA03XuEVZjELgRrUpxSdSgCK0d3mNh54mKWuG9xgFrP4hE8KnfHT1g1lKGc5yy52aR2KYkVUAlCMSiBIIQVX8i5MYgr/4T9UpjJv87ZZ6rNUjWlMU5qygAVah6JYEZUAFKO6xz0AylHO5HWd5zw/8zOTmIQjaj77N3mTX/mVRBK1DkWxEioBKEZligRwlatcJ+9ykJ/yKU/wBK/yqtHqsmav8Ao6dCxjmdahKFZCTQWhlMpP/EQccaSQwl3uEkccYYTRiEbo0RNPPHe5i0AQTniJ+ulnM5t3eZeP+IixjKU85TnBCRrTmJWspA99TPDOrNPrvM5pTnOYw1qHoli+mSoBKKXShz78xm85n/gNGMgkM89olNa0LvENyhGMYDazscMOTzz5mq9ZyUqiieYQh8w+5YQl28EOnud5jnKUJjTROhzFsqm5gJTSCSUUgSD9368MMvI0/g440IteJa7jEIdyEksssbzBG+xjH/3prxr/h7SlLXWow0/8pHUoihVQCUAplY505HEeL/ScDDJ4gRdKVL5AcIpTuf4sECSRxAd8QFe6cpGLJSrbVg1kIItZzF3uah2KYuFUAlBKRYeOYQxDj77Acx7ncWpTu0TlX+FKvg1ZFlkAbGELdajDWMaq0S//GsQgUkjhN37TOhTFwqkEoJTam7xZYFeMAw68xEslLvs4xws9nkkmWWSxilXEEVfiemxJNarRla78wi9ah6JYOJUAlFKrRCV60hMHHPIcyyCDbnQrcdkRRBQ6xt8BB5rQhP3sxx//Etdja17jNbaxLd/hs4qSTSUAxSiGMYwMMvLsL095WtO6xOUe53i+5QLYY08XurCLXaVa/tEWdac7FanIUpZqHYpiwVQCUIyiHe3wxz9XV5AePV3pmu+VQVEd5jAGDHn269AxnOGsYQ0uuJS4fFtVjnKEEMJCFmodimLBVAJQjGYYw7DHPufPBgz0oEeJy0sllatczbNfh45P+ZQf+AE79U+4QK/xGqc5zTGOaR2KYqHU/x7FaAYzOFcCAOhClxKXd5KTuT7922GHAw4sZSmTmFTicsuKlrSkNrVZxCKtQ1EslEoAitFUoAIhhOCAAzp0PMMzVKJSics7zvGchKJHjyuubGUrL/OysUK2ea/wCktYUuB9FKVsUwlAMaqhDCWDDHTo6EnPUpV1kpOAHOlTneoc4hBtaGOMMMuMgQwkllg2s1nrUBQLVPDTO4pSgLt3IS0NEhMhNVX+nJEByckArfBrUYdr5c/gsbM7v0bnfq2dHXg8tFaMvT24u8ufK1QAJydwcYEjFY6QpcuiEY34kz/VSJ8SqEENWtOaRSwq1XBcxTapyeDKsOhouHlTbrduQXz8/e8P/nzrFqSkyIb+9u0iFDzyR/jgG6hxuXQBxlXC7kAL3N9aQYVyLpQvD56e4OV1/3v25ukJlStD9erg4yOTiCLNZS7v8A4xxJhtoR7FKqjZQG1VcjJcvCi3y5fh2jW4cQMiI+H6ddno37t3//xy5XI3rA9/L19eNqoeHvLTuaMjVKwo9zk7g04nP70DJOluM83pCz6792XOJ/ts968U7ktPl1cVAAkJMtFcM0Qy33cSr+2dRXqKnqQk+bqHE1NcnPyelJS7TC8v8PaGxx6T3319wc8PnnxSbj4+8mqkLLjFLapRjUUsUvdPlAepBGDNMjLg7Fk4eRLOnLnf4F+8CDEx8hydTn4qfvxx2RD6+MitenXZKHp7y5/djLycbgoplKd8iV9/j3vFWlQmMxNiY2WCu3HjfpK7dk1+j4yEK1fuJx9HR6hZ835C8PeHgABo0EBeSdiaTnTCDTdWsUrrUBTLoRKAtYiMhKNHZWN/4sT9Rj8jA/T6+w3Zw9sTT8jGTpGio3Mnyuzt3Dl5JQFQtapMBPXry6TQqJHcypl+lUuTmcc8RjOaGGJKtCiPYpNUArBEyckQHg5HjtzfTp+Wx7y9ZaNUr979702bym4YpXQSEuDUKfm7PnVK/t4jIuTfh14PtWtD69bQqpX8nderJ6+wrEEccXjjzWIW049+WoejWAaVACxBUhLs2AHbtsnt1CnIypJdM82by+3ZZ2Wj8/AIGsW0DAZ5dXDw4P0tPFxeeXl5yYTQvj106CATsiXrSEc88CCMMK1DUSyDSgBayMyE3bvhr79g61Y4fFg2+A0bysakdWvZ6Pv6ah2pkp/0dDh2DA4cgO3bZfJOTIRq1eTfX/v2EBwsE7glmctc3uVdoolWo4EUUAnAfFJTZYO/fj2sXSv7op94AoKCZJdChw7y5qxifbKy5FXB7t2wZw9s2iSv6urVg5AQ6N5dXr1pTXUDKQ9RCcCU0tPh999h6VLYvFkOb2zRAnr2lJu/mr7eJqWlyWS/Zg2sWydHZD31FLz0EgwcCLVqaReb6gZSHqASgClERMBPP8GSJbJroFMn6N0bevSAKuph1jIlKwv27pVXfStWyNFcrVvDm2/KhFC+5CNlS0R1AykPUAnAWDIz5X/wqVPlcM1ateCNN+D111XXjiJlZckrwZ9/lleG5crBq6/CBx/I7kBzyO4GWsIS+tLXPJUqlkolgNJKTZWf9r/5Rj581LcvDB0qP+VZyxBBxfxu3YLFi+GHH+QDan37wkcfyecNTC2IICpSkV/51fSVKZZsZhl5GN74srLgxx+hRg0YOxa6dZPDBZcsgTZtVOOvFM7LC8aMkf9mFi2Szx40aSK7Cc+dM23dIYSwgQ2kkGLaihSLpxJACezaJUd1vP++vKl3+bJMBjVrah2ZYm3s7aF/fzmsdP16uHpVPoU8fnzeOZOMpQ99uMc9NrDBNBUoVkMlgGJIToZBg6BtW/lE7okT8PXX6sauUno6HXTtKp8J+fZbmDMH6tSBjRuNX1clKtGWtqoLSFEJoKj+/ls+nPXnn7B6tfxeu7Zp6wwPD6dbt25UqFABNzc3goKC2LNnzyNfl5WVxfjx46lVqxZOTk4EBwcXeO6hQ4cYNGgQNWvWxNnZGU9PT+rXr0+fPn2YNWsWFy9eBKB+/frodLpc28sv359ZMigoKNexZs2a5anrypUr9OjRg6SHpu4s6fvMz4YNG6hduzZ6fcFLXYwbN44VK1YUePyNN97A0dGRmjVrMmbMGNLS0koUS0no9TBypJzk7/nnZdfif/4jn0g2pl70YiMbSSfduAUr1kUojxQWJoSrqxAtWwpx/bp56ty/f79wdnYW/fr1Ezdu3BCxsbHirbfeEnq9XmzatKnQ186ZM0cA4rPPPhMJCQn5npOVlSU++OADodfrxdixY8Xff/8t0tLSRFRUlNi8ebMICgoSgABERkaGEEKIqKgo4eXlJQCxePHiPGX+8ccfolatWiIlJSXPsWPHjolKlSqJ6dOnG+19PujChQuie/fuomHDhsLd3V3Y29sXem7NmjXFxx9/XOA5SUlJYvbs2QIQkydPLnIcxjZrlhCOjkJ07SrE7dvGK/eKuCJ0Qic2iaL/jhWbM0MlgEdYskQIe3shhg8X4t4989SZlZUlAgIChLe3t7h7927O/szMTPHUU08JPz8/kZaWVuDr+/fvLwCRlJRU4DkTJkwQgJg7d26+xzMzM0VwcHCuBCCEEEuWLBGA8PLyElFRUTn74+PjhZ+fn9izZ0+esm7fvi18fX1FaGioUd/nw+/5iy++EBkZGcLHx6fQBOkShyYAACAASURBVCCEEOHh4UKn04kVK1YUep6Li4vo1KlTkWIwlQMHhPD2FqJFC+MmgYaioRglRhmvQMXaqARQmJ07hXBwEOKDD8xb7/bt2wUgRo3K+59z0qRJAhBhYWEFvr5Tp06FNoB///23sLOzE02bNi00jr179+ZJAEII0aNHDwGIPn365OwbMGCA+PDDD/MtZ+LEiUKv14vIyMhc+0v7Ph/0YAIpSgIQQoiQkBDh6+ub5/09qHr16o/8PZnDmTNCVKsmRLduQmRlGafMiWKieFw8bpzCFGs0Q90DKEBSkhyd8cIL8kavOW3btg0g33707H1bt24t8PVZWVmFlj937lwMBgMhISGFnteiRQuEEHn602fPnk3FihVZtWoVYWFhrFmzhvDwcD777LM8ZQghmD9/Ps8++yzVH5odrbTv80HOJZgPu1evXly/fp0//vijwHN0Oh2ZmZnFLtvYnnoKfvtNTjHx3XfGKfMFXuAKVzjJSeMUqFgdlQAK8PnncsnEefPMP6b/zJkzAPjmMx2oz7+PFZ8rxWDxnTt3AtCwYcMSvd7b25tp06YBMGLECEaOHMnChQtxzGflmYiICKKjo2mUzxNOpn6fj9K4cWMANm3aZLI6jCkwECZMgP/5H7n6WWk1pznVqMY61pW+MMUqqQSQj5QUmDtXPuDl5WX++hMTEwEon89EMa6ucv6WhISEAl9/7969fBvjbDdu3ADAqxRvbuDAgXTt2pWYmBj8/f1pWsB0lydPyk+X+TXypX2fpZWdZLJjzI+joyMZGRkmi6G4PvhArvA2Z07py7LDjmCCWc/60hemWCWVAPKxcyfcuQOvvaZ1JHmJf2fu0BVyWXL16tV8G9yHFVZGUdT6d1rLHTt2sHbt2nzPuXnzJgAexVzJpijvs7Tc3d3R6XQ5MeanevXqREZGWkQ3EICLi5w2Yp2RPrS/wAvsZz/RRBunQMWqqASQj5Mn4bHH5AIfWqhQoQIAKSl5H9XP3pd9zoPi4+OZMmUKV65cYfjw4QWWn90XHxcXV+IYd+3axerVq5k6dSoAQ4cOzffTevYYegcHhzzHSvo+jUmv15Oamlrg8dDQUJKSkvj0009L9fsypubN5b9RY+hEJ8pRjo2Y4IkzxeKpBJCP5GRw03Dd7Dp16gBw/fr1PMciIyMBqP3QU2iDBg3Cy8uLcePG8eGHHzJ69OgCy2/bti0Ax48fL1F8ycnJDBo0iLlz5/Luu+8SHBxMVFQUY8aMyXOuk5MTQL7dKCV5n8aWmZlZ6A3kV199lcmTJzNlyhQqV65Mly5dTBpPUbi7y0kIjXFR4oorbWmruoHKKJUA8lGlCty8CVrNk9quXTsAjhw5kudY9r4OHTrk2v/LL79w+/Ztli9fztSpUwkNDS2w/NDQUPR6PWFhhS8K8uGHH2JnZ5dzszbb+++/T1BQUE5jOGfOHNzd3Vm0aBHr1+duSLy9vQG4ffu2Ud6nMSUlJSGEyIkxPxMnTmTChAnMmjWLxMRENppiboZiun5d3psq5GHnYnmBF9RTwWWVpqNQLdSRI0KA/K6FrKwsUa9ePVG9enWRmpqasz8zM1PUrVtX+Pn55dr/sGeeeUZUrFix0Do+//xzAYgFCxbke/zMmTPC3d1d9OvXL9f+jRs3ipo1a+Z5yGzu3LkCENWrV8/19PGxY8cEIIYPH27091mQoj4HcPr0aQGIYcOGFXhOnTp1RM2aNYsdgyl17y43Y7kirggEYrPYbLxCFWugHgTLj8EgRN26QgwapF0M+/btE05OTuLll18WN2/eFHFxcSI0NFTo9XqxcePGQl/boUOHIjWA48aNEw4ODuKjjz4SZ8+eFenp6eL69eti/vz5wtvbW7Ru3VokJyfnnJ+QkCD8/PzE9u3b8y0ve/qIQQ/84gwGg6hSpYpo1aqVUd7ngAEDBCAuXbpU4PsqagJYunSpAMRvv/1WaFmNGjV6ZFnmcv68fDJ9+XLjlttANBCjxWjjFqpYOpUACrJ4sRB2dkLs3atdDEePHhXBwcHC3d1duLq6ivbt24vdu3c/8nVBQUFFagCFEOLgwYPitddeE35+fsLBwUG4ubmJwMBA8f3334v09PSc83x8fHLmBgLEiy++mHMsISEh17Hsbdq0aUIIOe1Efk8Cl+R9tm/fXri6uorMzMxc+9etW5dvDICYN29evmWFhIQIHx8fca+QOT58fHxE48aNCzxuTgaDEMHBQtSrJ0QhDy+XyAQxQT0VXPaoBFCYLl2EeOwxIaKjtY6keLp16yZ0Op3WYeRITEwUPj4+eeYCKq6EhATh7OwshgwZUuqYsucCWrZsWaHnVa1aVQQGBpa6PmP4v/8TQq8XYtcu45e9V+wVCMRJcdL4hSuWSk0FUZjFi8HBQS7qfuuW1tEUna+vL0IIoqMtY2y3h4cH69atIywsjBkzZpSoDCEEo0ePxt3dnc8//7xU8Vy6dInevXszfvz4XFNaPywjI4P4+PgiPVNhanPmwMSJcs3p1q2NX/6zPEslKqnhoGWMSgCF8PKCrVvlvECBgVDCUZNmlz0658svv+SWhWSuJk2acPjwYf7888886wEURXR0NJcuXWLr1q1UK+UDGnPmzGHy5MlMnjy5wHNu377N1KlTycjI0HToZ1aWXCt42DA5PcmoUaapxw47OtCBLWwxTQWKZdL6GsQaxMYKERQkhJOTEAUMmrE4X331lahbt65wdHQUXbp00TocqzJw4EDh4OAg/P39xSeffJLnfoO5xMYK0bGj+f7dLRALhJNwEnfF3UefrNiCGTohtBrtbl0yM+U6rd9+C/36wTffwL9TySiKUQkBS5bAhx+CszOsWgX/zltnUpFE4osvm9hEJzqZvkJFazNVF1AR6fUwZYqcg+XQIble65dfyhlDFcVYwsPhuedg4EDo0UOuEWyOxh/ABx/qUU91A5UhKgEUU7duch6Wjz6SfbL16skpo9PVQ5RKKZw6Ba+/Ds2ayfV/Dx2C2bOhYkXzxtGJTmzCOqbHVkpPJYAScHKCjz+WC8W3by9vzNWsKa8Q7tzROjrFmuzbBy++CA0awNGj8N//wu7d8PTT2sTTiU6c5CQ3uKFNAIpZqQRQCo89JtcNuHQJBgyQVwSPPQYjRshLd0XJT1ISzJ8PLVvKLTYW1qyBEyfglVfMvwDRg57neRxxVN1AZYS6CWxECQnyP/bPP8urgwYNYPBgmRwqV9Y6OkVLQsh1Jn76CcLCZDdP794QGir7/C1JEEFUpSpLWKJ1KIppzVQJwESOHJGX84sXw+3b8jmC7t2hTx/w99c6OsUcsrJkF8+vv8Lq1XIWz3r1ZF//m29CpUpaR5i/r/maKUwhmmjsVCeBLVMJwNTu3pUjh377Df78U94jaNoUevaE4GA5wsNO/R+zGbduwbZt8Pvv8Mcf8qqwcWP59/3SSxAQoHWEjxZOOE1owhGO8DQa3YxQzEElAHNKT5eNw5o1soGIigJPT3j+eXkzuX17qFtX6yiV4rhzR3btbNsmt+PHZR9+q1ay0e/ZUw4QsCYCgQ8+jGY04xindTiK6agEoBUh5HDSbdvkdBM7d8quIm9v2Xg8+6xc+q9pU8hnzXRFIxcuwMGDcOCA/H74sOzqqV//fhJv2xaKuQSyxXmd17nOdbaxTetQFNNRCcBSZGXJxmT7dtlvfPCgvEKwt5fdBs2bwzPPyBvLAQFyWUDFdAwG+OcfOTInPFz+fRw8KLt4HBygUSOZpNu0gXbt5CpytmQRixjCEG5xC1dctQ5HMQ2VACzZ1avyk2b2p81jx+R6xQA1ashEUL++3OrVgyeftP5PnuaWlSV/z+fPy8b+1Cn5/fRpef9Gp4MnnpAJuHlz2eg3aSKfBbFl0UTjjTe/8zsv8ILW4SimoRKANRECLl/O3VCdOgVnztyfkqJyZZkIsjd/f9mA+flBtWpQrpymb0ETCQlw44b83V24ABcv3v9++fL9313VqvIKq359mVwbNpSJ1bWMfgBuSEM60pFv+VbrUBTTUAnAFmRkyIfRLl68v2U3cP/8k3uaimrV5ObrC9Wry61aNZk4PD3lFNheXvJnS/6Um5Agu2Oyt/h4iIuDa9dk19m1a3DzJkRGQmrq/ddVrZo7OWb/XKuWfN/Kfe/wDjvYwTGOaR2KYhoqAdg6g0E2hFevyobx+nX5aTgyUm43b8otMfEGMB6YDsgbDOXL308GLi5y8/CQiaF8eXBzkz+7ucm6HB3lOQ/y8Mg9zDUlJfcEekJAYqL8OSNDdnElJ0NamnxiNiVFJrDERPlzdoNvMOSux9FRxurrK2+kZ1/xZCc6Hx/5lHZZ/TRfEmtZS296E000lbDQhxaU0lAJQJErX7Vv34GbN6NZuvQgGRkeOZ+qs7/fvSu327dl45ySIhvotLT79yUebtwzMraQnLwU+Dlnn5OTnOL4QdlJwt5e3twuX16e5+GR9+fshOTlJR+kyv6zatiNL5FEKlGJFaygD320Dkcxvpl6rSNQtPfOO+8QHn6M/fv3ExBgvLvI3357nO+/38rVq0YrUjGjClSgCU3YznaVAGyUSgBl3JIlS5g1axbLly8nwMiPqcbGxlLF1sZHljHtaMcf/KF1GIqJqEkIyrCIiAjefvttxo4dS9++fY1efkxMDJXVLHhWrR3tOM1pNT20jVIJoIxKSEigV69eBAYGFro4emnExMSoKwAr14Y2OODADnZoHYpiAioBlFEjR44kPT2d5cuXo9ebpidQdQFZP1dceYZn2M52rUNRTEDdAyiD1q5dy7Jly1i/fr1Ju2hUF5BtaEc7lrNc6zAUE1BXAGVMXFwcoaGhDB48mK5du5q0LpUAbEM72nGRi1zhitahKEamEkAZM3z4cPR6Pd98841J60lJSeHu3buqC8gGtKIVTjipbiAbpBJAGbJs2TLCwsJYsGABFSpUMGldMTExACoB2AAnnAgkMCcB3OQmK1jBCEbwJV9qHJ1SGuoeQBkRFRXFqFGjGDp0KJ07dzZ5fSoB2I4rXMELL7axjZrU5DKXscMOgeBjPtY6PKUUVAIoI8aOHYubmxtff/21WeqLjY0FUPcArFAyySxnOTvYwVa2cpOb2GGHPfZkkAGAAQMOOOCNt8bRKqWhEkAZsHfvXpYsWcLq1atxNdOkOTExMbi6uuLy8OxwisVzwYV5zOMgB3P2Gf79elAGGSoBWDl1D8DGGQwGxowZQ4cOHejZs6fZ6lUjgKyXHXYsZCEOODzy3OpUN0NEiqmoBGDjFi5cSEREBNOnTzdrveohMOtWhzp8zMfYY1/oeeoKwLqpBGDD7t27x+eff87gwYOpU6eOWetWCcD6TWACdamLvoCeYh06qlLVzFEpxqQSgA2bM2cON2/eZOLEiWavW3UBWT89ev7Lf/P0/WfzwINylME1Rm2ISgA2Ki0tjS+++ILhw4fj5+dn9vrVRHC2oQlNeI/38r0KUJ/+rZ9KADZq0aJFxMfH88EHH2hSv7oCsB2f8Rk++OS5H+CH+T9YKMalEoANEkIwbdo0XnvtNby9tblJFxcXp64AbIQzzixkYa6uIHvs8cVXw6gUY1AJwAatX7+eM2fO8N5772lSf2JiIunp6SoB2JC2tGUIQ3K6gvTo1RBQG6ASgA2aO3cunTp1om7duprUr54Ctk3f8A1eeGGHHQYMagioDVAJwMZERUWxceNGBg8erFkMah4g2+SOO/OYhwEDGWRQjWpah6SUkpoKwsb8/PPPuLu78+KLL2oWQ3YCUFcAtsFggNu3ITER/G53J+ixvvzluZLIw978lQjp6XD37v3zHR3hwRlAXF3BwQEqVgQPD3B3l39WtKcSgI1ZsmQJr7zyCo6OjprFEBsbS4UKFShXTo0Rt2RRUXDxIly/Ln++eVNuUVFw4wYkJEBSEty589ALq0yHU9t4p583XCpZ3S4uMhFUrAhVq4KPT+7vvr5Qs6b8bqf6KUxGJQAbcu7cOU6dOsXMmTM1jUM9A2A5UlPh1CmIiIBz5+DCBdnoX7gAKSnyHHt7qFIFvL3l5ucHzz6b+xN7hQoPfnqvwhan7+hxxBsnAXo9uLndr/PuXXlVkC0xEbKy7l9FJCXJn5OSZJLJTjgXLkBkJMTEwL178rWOjvDEE/Dkk+DvD7VrQ4MG0LChjEUpHZUAbEhYWBhVqlShVatWmsYRGxurun80kJICBw7ILTwcjh+H8+dl4+viAk89JRvS4GDZmGY3qtWrF/9TdigDCjzm4pK7C6hixeK/l+houHRJJoXsbe9e+PlnmTxAXiE0aiSTwTPPQMuW4OlZ/LrKMpUAbMjq1avp2bMn9vaFT+BlauoKwDxiY+H//T/Ys0du4eGQmQmPPQaNG8NLL8nGsVEj2dhr/M+iWKpWlVuLFnmPXb4sk9uJE/LKZvly+PxzeaxePWjVSm5t28Ljj5s1bKujEoCNuHLlCkePHmXy5Mlah0JsbCz+/v5ah2FzsrJkI//XX7BuHezbBzqd/GTfujWMGgVt2shPxrasRg259ehxf19SEhw8CLt3y2S4aJHs/nriCQgKghdegI4dwclJq6gtk0oANmL16tV4eHjQrl07rUMhJiaGli1bah2GTcjMlA3+8uXw+++yz7xGDejSBcaOhQ4d5Cibss7dXTb0QUHyz+npMhls3Ci3uXNlt1TnzvDyyzIhqLWKVAKwGatXr6Z79+4WMfJGzQNUert3w9Kl8OuvEBcnb8p+/DF06yY/8SuFc3SUybFDB5gyBa5dk4ng11/hlVfA2VleQfTvL++JWFP3mDGpAVY2IDExkX379mk69j+bwWDg1q1bKgGUQHKy/KTauLHsytmxA0aMkKN39u+H995TjX9J+fnBW2/B5s1ylNGMGfJ7jx7ynsm4cXIEUlmjEoAN2L17NwaDgTZt2mgdCvHx8WRmZqqbwMUQGQljxsgx8O+8A08/LfuzT52CSZOgVi2tI7Qtnp7w+uuwZQucPSu7hObOlTfKX3sNTp/WOkLzUQnABuzatYt69epZRKOrpoEoups3ZcPv7w9r1sCnn8qHsn76SQ5rVEyvVi349luZhGfOlKOKGjSAAQNkcrB1KgHYgF27dvHcc89pHQagJoIritRUmDhRfuJctQq++UZ287z/vhrHrhVnZxg8WI6yWrZMfg8IgCFD5D0YW6USgJW7e/cuR44csYjuH5BXAHZ2dnh5eWkdikXatAnq14cff4T//V/5gNOIEfKmpaI9Ozvo21c+Y7BwobxxXLcu/PILCKF1dManEoCV27dvH/fu3aN169ZahwLIBODp6YlerwaYPSglBQYOlMM3mzaFv/+WN3XVuHTLZGcnu4H+/luOGhoyRA4xjYrSOjLjUgnAyu3fv58aNWposu5vfmJjY1X//0MuXpTTFGzYIB/gWrlSTr+gWD43N/j+ezkK69o1mbz37tU6KuNRCcDKnThxgoYNG2odRg6VAHLbvh2aNZPTHx8+LB9AUqxPs2Zw6JD83q6dnJPIFqgEYOVOnTpFQECA0coLDw+nW7duVKhQATc3N4KCgtizZ0+RX2+sh8A2bNhA7dq1rboradcu6N5dPn26e7fx56VJSEhg9uzZtG/fHk9PT5ydnalVqxYDBgwgIiLika/Pyspi/Pjx1KpVCycnJ4KDg3OO1a9fH51Ol2t7+eWXc44HBQXlOtasWbM85V+5coUePXqQlJRUonjHjRvHihUrCoz/jTfewNHRkZo1azJmzBjS0tIe+Z5Lw8NDjtYaO1Z2Cf33vyatzjyEYrUMBoNwcnISv/zyi1HK279/v3B2dhb9+vUTN27cELGxseKtt94Ser1ebNq0qUhlPPfcc2LEiBEljuHChQuie/fuomHDhsLd3V3Y29uXuCwtHTwohLu7EC+9JERGhmnqePPNN4VerxffffeduHnzpkhJSRE7d+4U9erVE/b29uK3334r9PVz5swRgPjss89EQkJCnuNRUVHCy8tLAGLx4sV5jv/xxx+iVq1aIiUlJc+xY8eOiUqVKonp06eXON4LFy6ImjVrio8//rjA95CUlCRmz54tADF58uRC368xTZgghL29ECtXmq1KU5ihEoAVi46OFoDYtm1bqcvKysoSAQEBwtvbW9y9ezdnf2ZmpnjqqaeEn5+fSEtLe2Q5derUEZMmTSpxHP379xdffPGFyMjIED4+PlaZAO7cEaJmTSG6dBHi3j3T1fPmm2+Kt99+O8/+8PBwAYhatWoV+vr+/fsLQCQlJRV4zpIlSwQgvLy8RFRUVM7++Ph44efnJ/bs2ZPnNbdv3xa+vr4iNDS01PGGh4cLnU4nVqxYUeh7cXFxEZ06dSr0HGMbNUoIV1chLl0ya7XGpBKANTty5IgAxLlz50pd1vbt2wUgRo0alefYpEmTBCDCwsIeWY6Xl5eYOXNmieN4MPlYawJ4+20hKlUS4oH20uycnZ2FnZ2dMBgMBZ7TqVOnIv1+e/ToIQDRp0+fnH0DBgwQH374Yb7nT5w4Uej1ehEZGWmUeENCQoSvr6/IKORSqnr16qJp06ZFrs8Y7t0TomlTIVq1EiIz06xVG8sMdQ/Ait26dQswzkNX27ZtA8i3Lzd739atWwstIzMzk4SEhFLdBHZ2di7xay3B4cMwb558qrRqVW1iSElJITU1NacfvyBZWVlFKm/27NlUrFiRVatWERYWxpo1awgPD+ezzz7Lc64Qgvnz5/Pss89SvYhDnR4Vb69evbh+/Tp//PFHgWXodDoyMzOLVJ+xODjAggVy2o4lS8xatdGoBGDFsm+uuRYwH/CZM2fo2bMnHh4euLi40Lx5c9avX5/rBt6QIUNyzgXw9fXNU46Pjw8gl5wsTFxcHAaDIVdCKk4MtuDbb+VIkZAQ7WL49ddfAZg4caJRyvP29mbatGkAjBgxgpEjR7Jw4cJ8152OiIggOjqaRo0aGS3exo0bA7Bp06bihm5yjRrJ5wS+/VbrSErGeodYKCQnJ+Ps7JzvSJkLFy7QokULypcvT1hYGC1atODKlSu88847HD9+HEdHx1yjJhITEwEoX758nrKyE0xCQkKh8Tw8D1BxY7B2qalynP/UqdrFEB0dzbhx4xgyZAh9+/Yt9Nx79+7l24jnZ+DAgaxcuZINGzbQtm1bmjZtmu95J0+eBPL/IFHSeLM/gGSXnR9HR0cyMjKKVKexDRkiZ2/9+2/51LA1UVcAVkwIUeAl/oQJE0hMTOT777+nY8eOuLq6EhAQwNKlS0nJXg28GPUAhXYnQN4EYMwYrMGxY/KJ344dtan/1q1bdOnSheeff57Zs2c/8vyrV68WuaEGqPXvtKQ7duxg7dq1+Z5z8+ZNADw8PIwWr7u7OzqdLqfs/FSvXp3IyEizdwOBXLbS1VUO9bU2KgFYMTs7OwwGQ77HNm7cCEDnzp1z7a9cuTJ16tTJc36FChUA8m2Ys/dln1OQ2NhY9Hp9znnFjcHaXbok5/SpUcP8daekpNC5c2fq1avHkiVLCl0XOj4+nilTpnDlyhWGDx9epPJ37drF6tWrmfrv5c3QoUPzvSLMvqJzcHAwWrwAer2e1NTUAo+HhoaSlJTEp59+SpyZZ2+zt4fateXfv7VRCcCKOTs7c+/evTw389LT07lz5w5OTk753h+oWLFinn3ZDfL169fzHIv8d6WM2rVrFxpP9kNgdnZ2JYrB2qWmyrl9HnGhZHSZmZmEhITg4+PDwoULC21MBw0ahJeXF+PGjePDDz9k9OjRjyw/OTmZQYMGMXfuXN59912Cg4OJiopizJgxec51+ndyo8K6Y4oT74OvKWyAwKuvvsrkyZOZMmUKlStXpkuXLo8s05hcXODuXbNWaRQqAVixKlWqYDAY8nzicXR0xM3NjbS0NJKTk/O8Lrur5kHZawkfOXIkz7HsfR06dCg0ntjY2JwbwCWJwdpVrChX9bp3z7z1hoaGkp6ezsqVK3PdD/L392f//v25zv3ll1+4ffs2y5cvZ+rUqYSGhj6y/Pfff5+goKCcRnXOnDm4u7uzaNEi1q9fn+tcb29vAG7fvm2UeEEOdhBC5JSdn4kTJzJhwgRmzZpFYmJiztWnucTFWedU3ioBWLHsxja/xjT7sf6H/yNERUXlO5qnbdu21KtXj7CwsFw3ZrOysli+fDl+fn5069at0HhiYmJyDQEtbgzWrn59yMqSc8mby6RJkzh16hRr164t8g1dd3d3QkJCaNKkCWFhYYWeu2nTJrZs2cI333yTs8/Pzy/nz6GhoTkDCEBOIQH5X0mWNN7sK9DssvOzevVqatasyZAhQ4p0/8GYkpLg/Hn59291tH0OQSmN2NhYAYitW7fmOXbhwgXh6ekpfHx8xObNm8WdO3fEiRMnRJcuXcTjjz8uHB0d87xm3759wsnJSbz88svi5s2bIi4uToSGhgq9Xi82btz4yHhefPFF8corr5QqhgdZ24NgBoMQjz0mpwkwh59//lkAhW779u0r8PUdOnQo9PebkJAg/Pz8xPbt2/M9HhQUJAAxaNCgnH0Gg0FUqVJFtGrVymjxLl26VACFTm3h4+MjGjVqVOBxU1q8WAgHByFu3dKk+tJQTwJbM4PBIPR6vVi2bFm+x8+ePSt69uwp3N3dhYuLi2jZsqXYsWOH6NChQ4GN79GjR0VwcLBwd3cXrq6uon379mL37t1Fiqdly5binXfeKVUM69atK7BxmDdvXpHi0NInnwhRubIQycmmr6tbt26lSgBBQUEFJgAfH59c5bz44os5xxISEvKta9q0aUIIISZMmJDvk8AljTckJET4+PiIe4XMq+Hj4yMaN25c6O/LFAwGIZo3F+KBh6StiUoA1s7Hx0d88803xXpNYQmgNPz9/Ys8IZepYtBaTIwQFSsKMWaM1pE8Wrdu3YROpzN6uYmJicLHxyfPXEAlkT0XUEEfcrJVrVpVBAYGlrq+4po7V04Kd+SI2as2BjUVhLWrDthP+wAAIABJREFUW7cup0+f1joMwHhTQVuzypXhhx9g+nT4f/9P62gK5+vrixCC6Ohoo5br4eHBunXrCAsLY8aMGSUu59KlS/Tu3Zvx48fnmor6YRkZGcTHxxfrmQZjuHxZruP80Ufw9NNmrdpoVAKwcg0aNODEiRNah0F6ejpJSUlqMRjg1VehZ0/o318u9m6pskf1fPnllznzShlLkyZNOHz4MH/++WfOlCXFNWfOHCZPnszkyZMLPOf27dtMnTqVjIwMsw79jI+HF1+EmjXh00/NVq3xaX0NopTO/PnzhYuLi8jKynrkucuWLcvT5/rmm28aJY6rV68KQOzdu1ezGCxJcrIQbdoI4esrxMWLWkdTsK+++krUrVtXODo6ii5dumgdTrEMHDhQODg4CH9/f/HJJ5+ITDNNyXn7thDPPCOEn58Q//xjlipNZYZOCFtc677sOHDgAIGBgVy4cIEnn3xSsziOHj1K06ZNOX/+PP7+/prFYUkSE+VC4jExsHq1nCROsW5XrkDv3hAdDTt2gIb/5YxhpuoCsnIBAQHodLpCJ8oyh4fnAVKgQgXYvBnq1ZOThS1YoHVESmls2SKTeEaGTTT+gLoHYPVcXV156qmnOHjwoKZxxMTE4OjoiLu7u6ZxWBpPT/jjD3mz8K23YMAAeUWgWI+7d+WN3uBgub7z/v220fiDSgA2oWXLluzbt0/TGGJjY9Wn/wLY28P//i+sXy8Xiq9bF+bPB9X5avk2bICAAJg7F2bNgsWL5bw/tkIlABvQokULDh48qNl86KASQFF07QqnT8PAgTBsmJxGePNmraNS8nP0KHTvDt26QWCgnOv/rbe0jsr4VAKwAS1btiQlJYWIiAjNYlDPABSNq6tcMObgQdk91LmzvD/w74qcisYiIqBXL9nXHx0tE/SyZVCtmtaRmYZKADagbt26eHp6snfvXs1ieHgiOKVwTZrI7oV9++TN4g4doGlT2dVgjdMKWzODAf76S37ib9IELl6EFSvgwAHtFvcxF5UAbIBOpyMwMFDT+wAqAZRMYKBcRnLfPqhTB0aNAj8/GDtWdhcppnPtGvzf/8mHuTp3ljO5rl8vrwJCQsy/roMWVAKwEa1atWLXrl2a1f/gWgBK8QUGwpIlcPWqHDG0cqW8+dioEXzxhXWuNmWJoqNhxgzZ7VajhlzMPSREPrG9YYO8T1MWGv5sKgHYiLZt2xIZGcn58+c1qV9dARhH1aowYQL884+cS6hlS3nP4MknoXlzmDRJDkN8aBE4pRAnTsCUKdC+Pfj4wLhx8Nhj/5+9O4+Lqvr/B/4amGHYVwXZVBBQwR1FQEtDXHAlTdNwKy3KUutjH/fST2bLz08an3K3zNTKxLSvuJaaC+KC5g4qmCi7yo4sM8P5/XEchmVAtpnLMO/n43EfA/feufc9I573Peeeew6wbx+Qmgr8978tp1tnfdGTwC2ETCaDjY0N1qxZgze13F2hsLAQ5ubmiIqKeu6kMaT+5HLeRr13L3D4MK8l2NkBQ4bwNup+/fictIRLTgaio4Fjx4BDh/jvrVvz72vMGGDkSKCW2SX1yTpKAC3IkCFDYG9vjx07dmj1vP/88w/c3d1x4cIF9OnTR6vn1ke3bvGC7fBhXtAVFQH29rxbaf/+/LVbN8DCQuhINa+4GLhxg9eKzp7l38eDB4BYDPTpwx/eGjaM32A3oPaOqtaJn78P0RUDBw7Et99+q/Xz0jAQ2uXtzZd58/j8w5cv88LvzBnepp2eztux3d2BHj14MujWjb+nfXvAyEjoT1B/CgUv2G/f5jdpr14Frl3jv8vlvCdVQADvq9+vH28uMzMTOurmj2oALcjZs2fRr18/3LlzB56enlo7b1RUFEaNGoXCwkKYtqTHJHXU/fuVC8krV/hNZMb4U8lt2/I27w4dAA8P3i7u7MzvPzg782cVtK2oCEhL40t6Om+2SUzkS0IC/0ylpXxfFxee0Lp3VyU4Ly+6wm8AqgG0JH5+frCwsMCJEye0mgAyMzNhbm5OhX8z0b49X8aMUa3Lz+c9XZSFamIiv3o+eJAXunK5al8zM54IrK0BKyvVq6UlX4yN+VKxHd3GRvVzXp7qJnVJCX+uQSbj63Nz+Sipubn895wcfiM2N1f1fpGIJyN3d56k+vZVJSxPT37/gzQNSgAtiFgsRr9+/XD8+HG89dZbWjsvPQXc/FlY8HZwX9/q2xjj3SMzMoCUFD5YXXIyL5yVhXRSkqoALy0FCgtVV+QKBZ5N+jITwDKYm/tAIuHbxGJ+bkPDysnE2ZmPiWRtDTg6qhYnJ34/Q0wlk1bQ19zCDB48GJ9++ikUCgUMDQ21ck4aB0i3iUR8qIM2bXizSkM8elQCe/vdOH78Hbz0kk/TBkg0hlrNWpihQ4ciOzsbly5d0to56RkAQnQTJYAWxsfHB66urjhw4IDWzkk1AEJ0EyWAFujll1/Gnj17tHY+ugdAiG6iBNACjRs3Djdv3kRcXJxWzkcJgBDdRAmgBerfvz8cHR3x888/a+V8jx8/piYgQnQQJYAWyMDAAFOnTsXWrVuh0PCoYTk5OSgpKaEEQIgOogTQQr311ltISUnBkSNHNHqeR48eAQA1ARGig+g5gBbK3d0dAwYMwObNmzF8+PBK2+7fv4+2bdvCoJ7Pzufm5uJ///sfHBwc4ODggFatWuHhw4cAaBwgQnQRJYAW7M0338S0adOQmpoKJycn3L9/H59++im2bduGpKQkODk51et4lpaWiIiIQFZWFqoOIeXm5gYbGxu0bt0azs7O6NKlC7766qum/DiEkCZGTUAt2Lhx42BtbY2IiAjMmDEDHh4e2LZtG+RyOf755596H08kEiE4OFjtE8YymQyZmZm4efMmjh49CnMhRhQjhNQLJYAWLD09Hd26dcNXX32F7du3Q6FQQC6Xw8DAAPfv32/QMYOCgqpd/VclkUjwzjvvNOj4hBDtoQTQAiUlJWHOnDnw9PTE6dOnoVAoIJPJyrdLJJJGJYDaehZJJBJMmzYNbdq0adDxCSHaQ/cAWpi5c+di7dq1MDAwqFToV6RQKBqcADw8PODo6Ii0tDS12+VyOT744IMGHZsQol1UA2hhJk6cCGNj41qbaeRyORISEhp8jsGDB0OiHO+3ArFYjCFDhsDb27vBxyaEaA8lgBYmICAAp06dgpmZWa3DQScmJjb4HDU1A8nlcixYsKDBxyWEaBclgBaoV69e+Ouvv2BpaQlxDTNrpKWloaysrEHHDwoKqvZeAwMDdO7cGQMHDmzQMQkh2kcJoIXq0aMHzp49CxsbG7XNNXK5HKmpqQ06tqurK9q2bVtt/ZIlSyASiRp0TEKI9lECaME6deqE06dPw9bWVm0SaMizAErDhg2rdMxWrVph/PjxDT4eIUT7KAG0cB07dsS5c+fg4OBQqcBuzLMAAPDSSy9B/mwmcbFYjA8//BBGRkaNDZcQokWUAPRA+/btER0dDUdHx/J7Ao15FgDgCUBJIpHgzTffbGyYhBAtowSgJ9q2bYszZ87AxcUFEokEMpmsUU1ADg4O8PDwAACEh4fD2tq6qUIlhGgJPQimR1xdXXHu3DkMGDAAt2/fLn8W4OlToLgYyMkBior4zzIZUFBQ+f0lJXxfJQ+PYUhISISv7xz8+adqvaEhYGnJf7a2BoyNAVNTwMoKqOcApIQQDaIE0IJkZABpaXx58gTIylK9qn52QHHxSYjFAxEdnYTGddp5CUAGpkxxq/M7pFJVMjAzA2xtATs71atysbUFWrcGnJwAZ2eeRAghTYsSgI4oKAASE/ly/z7w8CGQmgqkpADJybzQLy1V7W9kVLlgtbUFXFyAbt0AOzsHiERnsWnTCHz6qRwWFmJIpYCNDS9oTUwAkYhfvVdU8coeALKzByIuzhmdO1fer2JNITub1yiKingNo7iYb8vL459JmZhSU4Hr14HHj/nveXmVj2lnBzg6Am3b8lcXF8DVFejQgS/OzlS7IKS+ROx5QzsSrZHJgNu3gRs3gPh4VYGfmAhkZvJ9RCJ+VdyuHS8InZ354uTEC0VHR/6zhcXzz5ednQ1jY2OYmJho9oM1gFwOPHrEE1xqqirJPXzIX1NSgKQkVTOVVAq4uakSgocH4OMDdO3KaxJEsx49egR7e3scP368UgcB0qytoxqAQFJSgMuXeWF//bqq0JfJALFYVZD17g28+qrqd3d3Xtg1BRsbm6Y5kAaIxTyZOTrWvl9GRuVEmZgIXLwI7NzJaxIA4ODAE0GXLjwpdO/OF+q1SvQdJQAtKCgArlwBLl1SLbdu8W2OjrxQeukl4L33AG9vwNeXN8OQ53Nw4EtgYPVt2dnAzZv8u755kyeGLVv4v4dYDHh5Af37A/368e/c2xuNvCdCiG6hBKABeXnAyZPA8eN8uXkTUCh404yfHzB5MtC3Ly90rKyEjrblsrHhBXz//qp1ZWXAnTvAhQuqZetWXvOys+P7BgUBgwbxxExIS0b3AJqAXA6cOQP8+Sdw7BgQG8sL/G7deGHSvz8v+F1chI6UqFNSAvz9N3D+PHDiBE/eOTlAmzb83y8oCAgJ4QmcqEf3AHTSOkoADVRUxAv8qCjg9995W7S7OxAczJsUBg3iN2eJ7lEoeJPdmTNAdDRw5Aiv1Xl7A+PHA6NG8dobUaEEoJMoAdRHSQnwf/8H/PQTcPQo79IYEACEhvLl2YOxpIUpLubJft8+YP9+3iOrY0fglVeAadMAT0+hIxQeJQCdtI56TtfB1avA3Ln8in7SJJ4IIiJ4d8QzZ4APP6TCvyUzNgZGjuQ3kFNTgVOn+O/btvFE8OKL/OfCQqEjJaR+KAHUQC7nXQl9fYEePYBDh4B583jf84MHgZkzAXt7oaMk2mZoCLzwAvDf//IH8g4c4PcKwsN5j65Zs4B794SOkpC6oQRQRVERsHYtr9ZPnw506sSv+G7fBhYtonZ9omJoyG8O//orf65jxQp+v8DLC3jtNV5zJKQ5owTwjEIBfPst0L498O9/AyNG8O6CO3fyKz7qH05qY2fHmwnv3AG2b+fPHvTsCYwezdcR0hxRAgBw+jRv6pk3j9/Uu3+fJwO3uo9xRggAXiuYNIl3K42KAh484E8hL1pUfXRVQoSm1wmgoIA38wwYwNtvr18H/t//o7Z90ngiETB8OH8m5KuvgI0beXPi4cNCR0aIit4mgLg4/nDWoUPAb7/xVy8vzZ/34MGD8PLyKp+Zqy4UCgUWLVoET09PGBsbIyQkpMZ9L168iOnTp8PNzQ0mJiawtbVFly5dMG7cOKxfvx6JiYkAgC5dukAkElVaJk6cWH6c4ODgStt69+5d7VxJSUkYPXo08qoO3dnAz1nVlStXMGLECFhbW8PCwgLBwcGIjo6utt/ChQuxa9euGo/z+uuvQyqVws3NDXPnzkVxcXGDY6ovsZgP8XH7NjBwIG9a/M9/+BPJhMvOzsaGDRsQFBQEW1tbmJiYwNPTE2FhYbhKN1I0i+mhyEjGzM0ZCwxkLDlZO+dMSEhgo0aNYt26dWOWlpbM0NCwzu/duHEjA8A++eQTlp2drXYfhULBPvzwQyYWi9m///1vFhcXx4qLi1l6ejo7evQoCw4OZgAYACaTyRhjjKWnpzM7OzsGgO3YsaPaMQ8cOMA8PT1ZYWFhtW1///03a9WqFfvmm2+a7HNWdO7cOWZiYsJeffVVlpqayh49esTefPNNJhaL2ZEjR6qd083NjS1durTG4+Xl5bENGzYwAGzlypUNiqkprF/PmFTK2PDhjOXmChZGk8vMzGQA2PHjx+v93hkzZjCxWMy+/vprlpaWxgoLC9mpU6eYt7c3MzQ0ZHv37tVAxIQxtlbvEsDOnYwZGjI2axZjpaXaO++kSZPY559/zmQyGXN2dq5XwThp0iQGgOXl5dW4z+LFixkAtmnTJrXb5XI5CwkJqZQAGGNs586dDACzs7Nj6enp5euzsrKYq6sri46Ornas3Nxc5uLiwsLDw5v0cyopFArm4+PDHB0d2dOnTyt9ho4dOzJXV1dWXFxc6T1XrlxhIpGI7dq1q9Zjm5qasiFDhtQ7pqZ0/jxjjo6MBQS0nCTQ2ATw1ltvVVt/5coVBoB5eno2RYikOv1KAKdOMSaRMPbhh9o/d8WCrL4F45AhQ2rdPy4ujhkYGDBfX99aj3P27NlqCYAxxkaPHs0AsHHjxpWvCwsLY/Pnz1d7nCVLljCxWMxSUlKqbWvM51Q6ceIEA8Bmz55dbdvy5csZABYZGVlt2/jx45mLi0u1z1eRk5PTc78nbYiPZ6xNG8ZGjGBMoRA6msZrTAKojYmJCTMwMGBlZWVNelzCGGNsrd7cA8jL470zRo7kN3q1rTGTrigUilq3b9q0CWVlZRg/fnyt+wUEBIAxVq1dfsOGDbCxscGePXsQGRmJffv24cqVK/jkk0+qHYMxhi1btqBv375wUjM6WlNMLnP8+HEAUHvfQbnu2LFj1ba9/PLLSE5OxoEDB2o8tkgkglwub3SMjdWxI7B3Lx9i4uuvhY6meSosLERRUVH5/SrS9PQmAaxYwadM3Ly55fXpP3XqFACgW7duDXq/o6Mj1qxZAwB499138d5772Hbtm2Qqpl55urVq8jIyED37t0bHvBzxMfHAwBc1Ayf6vzsSbw7ajrX9+jRAwBw5MgRjcXWlPz9gcWLgWXL+OxnLUl8fDxCQ0NhZWUFU1NT+Pn5ISoqqlLngpkzZ9Z6jN27dwMAlixZoo2Q9ZJeJIDCQmDTJv6Al52d0NHUX2lpqdrCWCk1NRUAYNeIDzdt2jQMHz4cmZmZ8PDwgG8Nw13euHEDgPrCuank5OQAAMzMzKptMzc3B8B7jlSlTA7KGNWRSqWQyWRNEWaT+PBDPsPbxo1CR9J0EhISEBAQgNjYWERGRiIzMxNbt25FREQErl27BqlUWl6TrElGRgYWLlyImTNnYsKECVqMXr/oRQI4dQrIzwemTBE6koZ58OBBnQrcxlaTPZ8Na3ny5En8/vvvavdJS0sDAFgJNJMNezZ4rbrPamlpCZFIVB6jOk5OTkhJSWkWzUAAYGoKTJjARxltKRYvXoycnBxERERg8ODBMDc3h4+PD3766ScU1mHEvCdPnmDYsGEYOHAgNmzYoIWI9ZdeJIAbN4C2bfmgXbokKysLq1atQlJSEmbNmlXjfsq2+MePHzf4XKdPn8Zvv/2G1atXAwDefvtttVfZyj70Eomkwed6HmtrawBQW1go1yn3qUosFqOoqKjGY4eHhyMvLw8ff/xxo76vpuTnx/9GW4rDz552Gzp0aKX1rVu3RqdOnWp9b2FhIYYOHQpvb2/s3LkThoaGGouT6EkCKCgALCyEjqJ+pk+fDjs7OyxcuBDz58/HnDlzatx3wIABAIBr16416FwFBQWYPn06Nm3ahA8++AAhISFIT0/H3Llzq+1rbGwMABptRlEWEsnJydW2paSkAAC8anhqTy6X13ojevLkyVi5ciVWrVqF1q1bY9iwYU0QceNYWvJBCJtJpaRRZDIZ8vPzYWxsXN5cV5GNjU2N75XL5Rg/fjycnZ2xbds2Kvy1QC8SgL09H7tfl6a++eGHH5Cbm4tffvkFq1evRnh4eI37hoeHQywWIzIystZjzp8/HwYGBuU3WZXmzZuH4ODg8sJw48aNsLS0xPbt2xEVFVVpX0dHRwBAbm5uQz5WnSgnFLl06VK1bcp1gwYNqrYtLy8PjLHyGNVZsmQJFi9ejPXr1yMnJ6f8alVIycn83lQjHppuNiQSCSwsLFBcXIwCNYMfZWZm1vje8PBwlJSU4Ndff63UU83DwwPnzp3TSLx6T9BeqFpy6RJjAH9tDurbP75Pnz7Mxsam1n1WrFjBALDvvvtO7fb4+HhmaWnJXn311UrrDx8+zNzc3Ko9ZLZp0yYGgDk5OVV6+vjvv/9mANisWbOeG3djHgTz9vZmTk5OrKioqHy9XC5nnTt3Zq6urpXWK926dYsBYO+8806Nx+7UqRNzc3Ord0yaNGoUX3RZxecAJkyYwACw3bt3V9onLS2NSaVSJpVKq71/2bJlrG/fviw/P7/atg4dOrCYmBiNxa7H9ONBsLIyxjp3Zmz6dKEj4epbMA4aNKhO+y9cuJBJJBK2YMECdvv2bVZSUsKSk5PZli1bmKOjI+vfvz8rKCgo3z87O5u5urqyEydOqD2ecviI6RW+uLKyMmZvb8/69ev33Hjq8jnDwsIYAHbv3r1K62NiYpixsTGbOHEiS0tLY48fP2bh4eFMLBazw4cPqz3WTz/9xADUOnSAs7Mz6969+3Nj15a7d/mT6b/8InQkjVMxASQkJDBbW1vm7OzMjh49yvLz89n169fZsGHDWLt27aolgK1bt5YPU1LTQglAI/QjATDG2I4djBkYMHb2rDDn379/f41/3Js3b671vcHBwXVOGBcuXGBTpkxhrq6uTCKRMAsLC+bv788iIiJYSUlJ+X7Ozs6VYhgzZkz5tuzsbLVxrlmzhjHGh52o6Ung+n7OoKAgZm5uzuRyebVtly9fZiEhIczS0pKZm5uzoKAgdubMmRo/+/jx45mzszMrrWWMD2dnZ9ajR48at2tTWRljISGMeXszVsvDyzqh6pPAt2/fZqGhoczS0pKZmpqywMBAdvLkSTZo0KBqCWDEiBGUAIShPwmAMcaGDWOsbVvGMjKEjqR+RowYwUQikdBhlMvJyWHOzs5qxwKqj+zsbGZiYsJmzpzZ6JiUYwH9/PPPte7n4ODA/P39G32+pvDZZ4yJxYydPi10JI1X16Eg1CUAIhj9GQoCAHbsACQSYMgQ4MkToaOpOxcXFzDGkJGRIXQoAPgzAPv370dkZCTWrl3boGMwxjBnzhxYWlpixYoVjYrn3r17GDt2LBYtWlRpSOuqZDIZsrKyNPoQW11t3AgsWQKsXg307y90NERf6VUCsLMDjh3j4wL5+wMN7DWpdcreOV988QWeNJPM1bNnT8TGxuLQoUNq5wN4noyMDNy7dw/Hjh1Dm0Y+oLFx40asXLkSK1eurHGf3NxcrF69GjKZTNCunwoFsGAB8M47fHiS2bMFC4UQ/egFVNWjR4wFBzNmbMxYDZ1mmp0vv/ySde7cmUmlUjZs2DChw9Ep06ZNYxKJhHl4eLCPPvpI7f0GbXj0iLHBg3Xr766untcE9PPPP1dr158xY4aWoyRVrBUxpku945uOXM7naf3qK+DVV4H//hd4NpQMIU2KMWDnTmD+fMDEBNizB3g2bl2L8ejRI9jb2+P48ePlz3GQZm+dXjUBVSQWA6tW8TFYLl7k87V+8QUfMZSQpnLlCvDii8C0acDo0XyO4JZW+BPdpbcJQGnECD4Oy4IFvE3W25sPGV1SInRkRJfdvAlMnQr07s3n/714EdiwAahlJARCtE7vEwAAGBsDS5fyieKDgviNOTc3XkPIzxc6OqJLYmKAMWOArl2By5eBH38EzpwBevUSOjJCqqMEUEHbtnzegHv3gLAwXiNo2xZ4911edSdEnbw8YMsWIDCQL48eAfv2AdevA6+91vImICItByUANZyc+NV/UhKfsenECaBPH6BbNz59X0ubvYnUH2PAyZO8bd/RUVVrPHkSOHuWt/dTwU+aO0oAtbCx4bOI3brFawAvvcRrBY6O/OGdL78EEhKEjpJoi0LBm3PmzuU1w4ED+d/Fxx8DDx/ynj4vvih0lITUnd52A22op095z6G9e4FDh/g9Al9fIDQUCAnhPTwMKK22GE+eAMePA//3f8CBA0B2Nv83Dg0FXnkF8PEROsLmgbqB6qR1lAAaoaSEFw779vECIj0dsLXlV4ZBQXzp3FnoKEl95OfzKUSPH+fLtWu8KadfP17oh4byph5SGSUAnUQJoKkwxruTHj/Oh5s4dQrIzeXNRf36AX378qn/fH0BNXOdE4EkJAAXLgDnz/PX2Fje1NOliyqJDxgACDQFss6gBKCT1rWAOYiaB5GId/3r2pW3ESsUvDA5cYJ3DfzqK15DMDTkzQZ+fvzGcteu/HdLS6E/QctWVgb88w/vmXPlCi/sL1zgTTwSCdC9O0/S77/P7/XY2wsdMSGaRwlAQwwNeYHSt69q3YMH/EpTebX5yy98vmIAaN+eJ4IuXfji7Q106EBXnvWlUPDv+e5dXtjfvMlfb93i929EIsDdnSfgpUv5v0/PnvxZEEL0DTUBCYgx4P79ygXVzZtAfLxqSIrWrXkiUC4eHrwAc3UF2rQBjIwE/QiCyM4GUlP5d5eQACQmql7v31d9dw4OvIbVpQtPrt268cSqZq5y0kjUBKSTqAlISCIRv6Ho5sb7jSvJZPxhtMRE1ZKQAPz6K2/GqDhMRZs2fHFx4c8vODnx31u35jek7ez4YmvbvK9ys7N5c4xyycoCHj/m3SvT0/lrWhqQkgIUFane5+CgSo7+/qqfPT355yaE1IwSQDMkkQAdO/KlqrIyXhA+eMALxuRkfjWcksKTxOnTfHtOTvX3mpmpkoGpKV+srHhiMDMDLCz4zxYWfH+plO9TkZVV5W6uhYWVB9BjTHVumYw3cRUUAMXF/InZwkKewHJy+M/KAr+srPJ5pFLA2joFRUWT0afPRnTv7oWhQ1WJztmZ98Wnq3lCGo4SgI4xMOCF3/OGrlYoKl9NV319+pQvubm8gM7I4AV0cbHqvkTNhfs5AH8A+AjGxnyI44qUScLQkN/cNjPjicXKit9cVf5cMSHZ2QGtWql+NzcHUlNFGD06H1euBOLjj3/Di/SUFSFNihJAC2VoyAtbTfRmWbfuMpYt+x8ePfqo6Q9egZOTE06ePImwsDAMGTIEmzdvxpQpUzR6TkL0CT2zSpo1MzMz7N27FwsXLsS0adOwcOFCUL8FQpoG1QBIsycSibB8+XK4uLhg1qxZuHfvHrZt2waTqm1PhJB6oRoA0RkzZ87EwYMH8ccffyBiAljcAAAgAElEQVQoKAiZmZlCh0SITqMEQHRKcHAwLly4gKysLPj7++PWrVtCh0SIzqIEQHSOp6cnzp49C1dXV/j7++PgwYNCh0SITqIEQHSSnZ0djh49ijFjxmDMmDFYu3at0CERonPoJjDRWVKpFD/++CO6dOmC2bNn486dO1izZg0MaEIGQuqEEgDRaSKRCAsWLICbmxumT5+Ou3fv4pdffoElDa9KyHPRpRJpESZMmIBjx47h0qVLeOGFF/DgwQOhQyKk2aMEQFqMgIAAnDt3DnK5HAEBAYiNjRU6JEKaNUoApEVxc3PDuXPn0KNHDwwcOBD79u0TOiRCmi1KAKTFsbCwwO+//47p06dj7NixWL58udAhEdIs0U1g0iKJxWJ8++238PT0xL/+9S8kJydj/fr1kEgkQodGSLNBNQDSos2dOxdRUVHYvXs3hg8fjhx1EyUQoqcoAZAWLyQkBKdPn8adO3fg5+eHO3fuCB0SIc0CJQCiF7p164aYmBhYWloiMDAQp06dEjokQgRHCYDoDeUEM/3798eQIUOwfft2oUMiRFCUAIheoQlmCFGhXkBE79AEM4RwVAMgeqvqBDMZGRlCh0SIVlECIHqt4gQzAQEBNMEM0SuUAIjeowlmiL6iBEAIaIIZop8oARDyjHKCmU8//RSzZ8/G3LlzoVAohA4LBw8ehJeXF8Ri6rNBmhb9RRFSgXKCGXd3d0ybNg137tzBrl27BJlgJjExER988AGSkpLoBjXRCKoBEKLG+PHjcfz4cVy+fFmwCWY++ugjBAYG4tKlS7CwsND6+UnLRwmAkBr4+/uXTzDj7++v9QlmvvvuOyxcuJCafojGUAIgpBbKCWZ69uyp9Qlm6ME0ommUAAh5jqaaYCY+Ph6hoaGwsrKCqakp/Pz8EBUVheDgYIhEIohEIsycObNpgyekFlS3JKQOGjvBTEJCAgICAmBmZobIyEgEBAQgKSkJ77//Pq5duwapVIri4mINfwpCKqMaACH1UHGCmZCQkDpPMLN48WLk5OQgIiICgwcPhrm5OXx8fPDTTz+hsLBQw1EToh4lAELqSTnBzN27d+s8wczhw4cBAEOHDq20vnXr1ujUqZNG4iTkeSgBENIAyglmrKysnjvBTElJCfLz82FsbAxzc/Nq221sbDQZKiE1ogRASAM5OTnhr7/+wgsvvFDrBDNSqRQWFhYoLi5GQUFBte2ZmZmaDpUQtSgBENIIZmZm+O233ypNMFNWVlZtv5CQEACqpiCl9PR0mqOYCIYSACGNpJxgZvPmzVi9ejUmTpyIoqKiSvt89tlnsLW1xfvvv48//vgDBQUFuHHjBl5//XW0adNGoMiJvqMEQEgTmTFjRo0TzHTo0AExMTHo06cPXnnlFTg4OCA8PByLFi2Ch4eH2uNFRUWVPx+QkpIChUJR/vuWLVu09bFIC0bPARDShJQTzIwcORIBAQGIioqCt7c3AMDLywt79+6t87FGjhxJ8xUTjaIaACFNrOoEMwcOHBA6JELUogRAiAYoJ5gJDQ2lCWZIs0UJgBANkUql2LZtG1auXKl2gplffvkFIpEIx44dQ0lJCY0FRLSO7gEQokG1TTAzceJETJw4UegQiR6jGgAhWqCcYObvv/8WbIIZQqqiBECIlvj7+yMmJkawCWYIqYoSACFaJOQEM4RURQmAEC1rqglmCGksuglMiAAaO8EMIU2BagCECKihE8wQ0hQoARAisIoTzPTp04dGByVaQwmAkGZAOcGMtbU1AgMDcfLkSaFDInqAEgAhzUTFCWaGDh1a4wQzhDQVSgCENCN1nWCGkKZAvYAIaWaUE8y4urrinXfewb1797Bt2zaYmJgIHVq5Xr164e7du5XWmZiYYPTo0ZXWmZqa4s6dO7CystJmeKSOqAZASDM1Y8YMHDp0SO0EM1VVHGROG0JCQlBYWIiCgoLypaioqNLvhYWF6N27NxX+zRglAEKasUGDBuHChQvIyspCQEAAbt26pXa/9957DwcPHtRaXJMnT37uZDUikQhTpkzRUkSkISgBENLMPW+CmVWrVmHDhg149913UVpaqpWYOnfujE6dOtW6j5GREUaOHKmVeEjDUAIgRAfUNMHM3r17sWDBAgDAw4cPERERobWYpk6dWuOTy2KxGC+//DLMzc21Fg+pP0oAhOgI5QQzH330EWbPno1Zs2bhtddeg0gkAsDvAyxbtgypqalaiee1116DXC5Xu00ulyMsLEwrcZCGowRAiA4RiURYtmwZvv32W+zatQtyubxSN1G5XI6FCxdqJZZ27drB19e3PAFVZGlpicGDB2slDtJwlAAI0TEFBQVYt24d8vPzq12By2Qy7NixA2fOnNFKLFOnToWhoWGldRKJBBMnToSRkZFWYiANRwmAEB1SVlaGSZMm4fbt25DJZGr3MTQ0xKxZs7TyANnEiROr9QaSyWR47bXXNH5u0niUAAjRIfPmzcOBAwdqbHsHeDPQzZs3sXXrVo3H07p1awwYMKBSLaB169Z44YUXNH5u0niUAAjRERkZGbhy5QoAPHfeAMYY/v3vfyM3N1fjcU2ZMqW8FmBkZIRp06bBwICKFl1A/0qE6AgHBwecOHECDx48wIoVK+Di4gKAd7msijGG/Px8rcw2Nnbs2PIYSktLMWnSJI2fkzQNSgCE6BgXFxcsWLAASUlJ+OOPPzBhwgQYGRlBLBZX6pEjl8vxzTff4MaNGxqNx9LSEsOHDwfA5zzu1auXRs9Hmg4NBkeIjjIwMEBwcDCCg4MRERGBHTt2YOPGjYiPj4eRkVH5U8Fz587FsWPH6nVsmQwoKADy84HiYv4KADk5QMV7vozxdR06TAawD717T8Xu3YCFBVC1YmJlBRgYAKamgIkJ/93UFJBKG/ElkEYRsecN6EFIFevWrcOyZcvw6NEjoUMhaly8eBFbtmzBzp07UVhYCABYsWIvvLxCkZUFPHkCta+FhapCv5Z7zDUoBtAGwAUAXvV6p0gEWFvzpGBmBtjaAnZ26l9btQKcnPhiY1PfGEkV66gGQIiOksmABw+AxES+JCfzJTW1D1JS+kAkWgNgD4BN+OijDwEMg52dcXmBqixUO3Tgr+bmvAC2sACMjfmruTn/2dKSn7PmK3tjfPvtp3jvPV74Z2dX3qesDFDejy4oAEpK+O9Pn/IaRk4OUFTEk1DFxPTPP5V/rzjoqYkJ4OICODoCbdvyVxcX/nnc3flCtYvaUQIgpJl78AC4eRO4cQO4d09V4D94oLpSt7EBXF354uYG9O8PODubwtFxClxdp6CoKAGtW6fB3d1NY3G+++675T+ruzq3s2v8ObKygLQ0ICWFvz58yF+Tk4H4eP67ctRskYgnBHd3nhQ6dAA6dwa6duXrqKMSJQBCmo2CAuDyZV7QX7/OX2/c4FfHAG/28PTkBdnAgapCzd2dX8HXzkPD0UPtkBBNzdaWLz4+Ne9TUKBKkhWXEyeA+/f5fQtTU8DbmyeDLl34q69vXb7HloUSACECUCj4FeulS6rl4kWgtJQ3qXh48ALqlVd4Yde1K+DgIHTUusHcHOjenS9VlZYCd+/y7/vWLV6zWruW16wA3ozk68trUP368Z+b0URsTY4SACFaoFAAsbHA8eN8OXeOX6mamfFCJiAAeP99oE8foF07oaNtuYyMeEKtWoPIyOAJ+MIFvnz5Jb+PYWQE9O4NBAXxJSCA3xNpKSgBEKIhd+4Ahw8Dx44BJ0/ym56OjsCgQcDq1UDfvrwgqjKWGhGAgwMwciRfAN5MdPcuTwanTwO//AJ8+imvDQQG8mQwdCjQqxe/16CrKAEQ0oRu3gR27waiongzg7k54O8PLFoEBAfrfoGhL0QiwMuLL5Mn83VpacCZM8CffwIbNwJLlvCb7iEhPHEMHcprDLqEEgAhjXTxIvDjj8Devbx3ipsbEBoKfPUVb0umK/yWwdERGD+eLwC/Yf/778C+fcCmTbzn08iRwJQpvJanC72MKAEQ0gCPHgE7dwLff8977Hh7A2++yQt+dTcfScvTqxdf/vMffhN53z4gMhIYMoTfx5k+nS/t2wscaC10IEcR0nzExgITJvD+5cuW8ZuCMTG86WfZMir89ZW7O/CvfwFnzwJxccCrr/Jmog4dgMGDgSNHhI5QPUoAhNTBsWP8P3KfPvxqb/Nm3ia8cSNv4ydEqVMn3ovo4UNeKzA0BIYN47WFXbsqP80sNEoAhNQiOpr31gkO5j1Djh7ltYCpU/nDRITURCwGRo3iPcEuX+Y3lMPCeIL47Teho+MoARCiRno6MG0a8MIL/MGsixd57w+a55w0RM+evCtpfDxvNnzlFX6vID5e2LgoARBSxaZNQMeOvO9+ZCS/6u/dW+ioSEvg4cF7jJ05Azx+DHTrBixd2pDRV5sGJQCidVeuXMGIESNgbW0NCwsLBAcHIzo6Wuiw8PQpv+p/5x3g3Xf5UAFjx2rufIwxREdH491334WXlxekUins7e3Rv39/7Nixo9pk61UpFAosWrQInp6eMDY2RkhISI37Xrx4EdOnT4ebmxtMTExga2uLLl26YNy4cVi/fj0SExMBAF26dIFIJKq0TJw4sfw4wcHBlbb1VpMZk5KSMHr0aOTl5QEAsrOzsWHDBgQFBcHW1hYmJibw9PREWFgYrl692pCvDgcPHoSXl5fa2dCUFi5ciF27dtW4/fXXX4dUKoWbmxvmzp2L4uLiBsXSEIGBvFa5Zg1/KHDIECAzU2unV2GE1NPatWtZq1atGvTec+fOMRMTE/bqq6+y1NRU9ujRI/bmm28ysVjMjhw50sSR1t0//zDWvTtjdnaMHTqknXPGxcUxACw4OJhdvXqVFRUVscTERDZp0iQGgM2bN6/W92/cuJEBYJ988gnLzs5Wu49CoWAffvghE4vF7N///jeLi4tjxcXFLD09nR09epQFBwczAAwAk8lkjDHG0tPTmZ2dHQPAduzYUe2YBw4cYJ6enqywsLDatr///pu1atWKffPNN+XrZsyYwcRiMfv6669ZWloaKywsZKdOnWLe3t7M0NCQ7d27t87fWUJCAhs1ahTr1q0bs7S0ZIaGhrXu6+bmxpYuXVrjPnl5eWzDhg0MAFu5cmWd42hKV64w1qEDY87OjJ0/r9VTr6UEQOqtoQlAoVAwHx8f5ujoyJ4+fVq+Xi6Xs44dOzJXV1dWXFzclKHWyb17jLVty1iPHjwRaEtcXBwTi8UsKyur0vqSkhJmZ2fHpFJprd+HMlHk5eXVuM/ixYsZALZp0ya12+VyOQsJCamUABhjbOfOnQwAs7OzY+np6eXrs7KymKurK4uOjq52rNzcXObi4sLCw8MrrZ8xYwZ76623qu1/5coVBoB5enrWGH9VkyZNYp9//jmTyWTM2dm51gSgPIdIJGK7du2qdT9TU1M2ZMiQOsfR1LKzGQsJYczSkrGYGK2dlhIAqb+GJoATJ04wAGz27NnVti1fvpwBYJGRkU0RYp3l5THm7c1Yz56MVSmHBdWjRw8GgOXk5NS4z5AhQ2otAOPi4piBgQHz9fWt9Vxnz56tlgAYY2z06NEMABs3blz5urCwMDZ//ny1x1myZAkTi8UsJSWl1vNVZGJiwgwMDFhZWVmd9q944VCXBMAYY+PHj2cuLi7VPl9FTk5Oz/2eNK2khLFRoxhr1UprFyJr6R4A0Zrjx48DgNp2Y+W6+s5d21hz5/KZpv7v/5rPFIM5OTm4e/cuevbsCSsrqxr3UzynQ/mmTZtQVlaG8cqxC2oQEBAAxli19vQNGzbAxsYGe/bsQWRkJPbt24crV67gk08+qXYMxhi2bNmCvn37wsnJqdbzKRUWFqKoqKj8vkNdmDRgbOaXX34ZycnJOHDgQI37iEQiyIW6E/uMkRHvKeTsDLz2Gp9FTdMoAZBGiY+PR2hoKKysrGBqago/Pz9ERUVVulk4c+bM8n0BwMXFpdpxnJ2dAQB37tzRWuznzwM//ACsW8ef7BVaXl4eoqOjMXr0aLRp0wY//vhjo4536tQpAEC3bt0a9H5HR0esWbMGAJ/t67333sO2bdsgVTPP4tWrV5GRkYHu9XgUevfu3QCAJUuWNCi+uurRowcA4EhzfRy3AlNTYPt2/qzJ9u2aPx8lANJgCQkJCAgIQGxsLCIjI5GZmYmtW7ciIiIC165dg1QqLb8yBPiVLQCYmZlVO5a5uTkA3mNEW77+mj/Zq8mePnX16aefwsrKCv3794ehoSH27t2LLl261Pqe0tJStYWxUmpqKgDArhFzMU6bNg3Dhw9HZmYmPDw84Ovrq3a/GzduAFCf3NXJyMjAwoULMXPmTEyYMKHB8dWF8uJCGaM6UqkUMplMo3HUVdeuvAbw1VeaPxclANJgixcvRk5ODiIiIjB48GCYm5vDx8cHP/30EwoLC+t1LPasy6M2phUEeL/rQ4f4E73NwdKlS1FSUoK4uDh06tQJPXv2xIoVK2p9z4MHD+pU4Db2O/X09AQAnDx5Er///rvafdLS0gCg1iYrpSdPnmDYsGEYOHAgNmzY0KjY6sLS0hIikag8RnWcnJyQkpIieDOQ0vTpfJDB+/c1ex5KAKTBDh8+DAAYOnRopfWtW7dGp06dqu1vbW0NAGqTg3Kdch9NS07mE7T06aOV09WJkZEROnXqhPXr12P06NH4+OOP8eeff1bbLysrC6tWrUJSUhJmzZpV4/GUbfGPHz9ucEynT5/Gb7/9htWrVwMA3n77bbW1NGUfeolEUuvxCgsLMXToUHh7e2Pnzp0w1NJY2WKxGEVFRTVuDw8PR15eHj7++ONGfV9Nxc+Pv9ZSaWkSlABIgzDGkJ+fD2Nj4/Lmm4ps1NxRVSaF5OTkattSUlIAAF5eXk0cqXr5+fzVwkIrp6u3UaNGAQCioqIqrZ8+fTrs7OywcOFCzJ8/H3PmzKnxGAMGDAAAXLt2rUExFBQUYPr06di0aRM++OADhISEID09HXPnzq22r/GzeRJra0aRy+UYP348nJ2dsW3bNq0V/spz13YDefLkyVi5ciVWrVqF1q1bY9iwYVqLTR0TEz6WkPLvVFMoAZAGEYlEsLCwQHFxMQoKCqptz1TzWONLL70EALh06VK1bcp1gwYNauJI1VNOsP6smbzZUbbtZ2VlVVr/ww8/IDc3F7/88gtWr16N8PDwGo8RHh4OsViMyMjIWs81f/58GBgYlN+kV5o3bx6Cg4PLC8ONGzfC0tIS27dvr5aYHB0dAQC5ubm1xlNSUoJff/21Uo8jDw8PnDt3rtYYGyMvLw+MsfIY1VmyZAkWL16M9evXIycnp7x2K5SMDN5Mqfw71Rit9DYlLYryOYAJEyYwAGz37t2VtqelpTGpVMqkUmml9QqFgnl7ezMnJydWVFRUvl4ul7POnTszV1fXSus1rUMHxhYu1Nrpqpk3bx4LCwtTu23y5MkMAPvf//5X4/v79OnDbGxsaj3HihUrGAD23Xffqd0eHx/PLC0t2auvvlpp/eHDh5mbm1u1h8w2bdrEADAnJ6dKTx///fffDACbNWuW2vMsW7aM9e3bl+Xn51fb1qFDBxbTgKef6vocwK1btxgA9s4779S4T6dOnZibm1u9Y9CU7dsZk0j4cyoaRA+CkfpTJoCEhARma2vLnJ2d2dGjR1l+fj67fv06GzZsGGvXrl21BMAYYzExMczY2JhNnDiRpaWlscePH7Pw8HAmFovZ4cOHtfo5li5lzN6esYICrZ623Lx585hIJGL/+c9/2D///MOKi4vZP//8w+bPn88AMF9f30oPPlU1aNCgOhWACxcuZBKJhC1YsIDdvn2blZSUsOTkZLZlyxbm6OjI+vfvzwoqfAnZ2dnM1dWVnThxQu3xlMNHTJ8+vXxdWVkZs7e3Z/369au2/9atW8uHm6hpqZoAwsLCGAB27969Gj9XXRPATz/9xADUOuSEs7Mz6969+3OPpQ1lZYz5+TE2dqzGT0UJgNRfxSeBb9++zUJDQ5mlpSUzNTVlgYGB7OTJk2zQoEFqEwBjjF2+fJmFhIQwS0tLZm5uzoKCgtiZM2e0+REYY4xlZDBmbc3Yc4bc0Zjc3Fy2ZcsWNnToUNa+fXtmZGTEzM3Nma+vL/v8889rLfwZ4wVxXQpAxhi7cOECmzJlCnN1dWUSiYRZWFgwf39/FhERwUpKSsr3c3Z2rlQwjxkzpnxbdna22sJ7zZo1jDE+7IS6J4FHjBhR7wQQFBTEzM3NmVwur7R+//79NR5j8+bNaj/7+PHjmbOzMystLa3x+3F2dmY9evSo03epad9/z5ihIWOXLmn8VJQASP3VZSiI2hJAc7JlC2MGBoz9/rvQkdTfiBEjmEgkEjqMcjk5OczZ2bnaWED1lZ2dzUxMTNjMmTMbHZNyLKCff/651v0cHByYv79/o8/XWFeuMGZmxti//qWV09FQEES/zZjBl0mTgGcjVegMFxcXMMaQkZEhdCgA+DMA+/fvR2RkJNauXdugYzDGMGfOHFhaWj73OYjnuXfvHsaOHYtFixZVGtK6KplMhqysrDo/xKYp8fF86kg/P+CLL7RzTkoARO+tXw+EhgLDh/PJYHSFsnfOF198gSdPnggcDdezZ0/Exsbi0KFD5fMB1EdGRgbu3buHY8eOoU2bNo2KZePGjVi5ciVWrlxZ4z65ublYvXo1ZDKZoF0/Dx8G+vXjk8j//jvwnMcpmo5WKhqkRamtCejnn3+u1jY7Y8YMLUdYf2VljH3xBW8OmjyZMTVD3TdLX375JevcuTOTSqVs2LBhQoejU6ZNm8YkEgnz8PBgH330UbX7Ddqg/LszNGQsLEzrf3drRYw9Z9ohQqpYt24dli1bhkePHgkdSpM7cACYMgVwdAS++QYIChI6ItJSXb8OzJ4NxMTwmcFqeahbU9ZRExAhFYwYAVy+zKvigwYBEyYADx8KHRVpSXJy+DDkvXoBRUXA2bOCFP4A6B4AIdW0b8/nBzhwALhyBejcGZg3D3g2WgUhDZKTA3z2GeDlxcf937iRX/3XMMCqVlACIKQGw4fzavqKFcCuXYC7O+8xdPu20JERXZKeDixYALRrB6xaBbz5Jv8beuMNwEDgEpgSACG1kEqBDz4A7t3jE8ecOQN4e/OmoshIoLRU6AhJc1RWBvz5JxAWxmuUP/4ILFkCJCUBK1cCWhr09rkoARBSB0ZG/Oo/Lg7YvRtgDJg4kU/f9/77wNWrQkdImoP794Hly3ltcfBg4J9/gLVr+fr58wFLS4EDrEL8/F0IIUoGBnwGsbFj+Uii27cD330HRETw//QjRwLjxwOBgcJX74l23LsH7N/PLwzOnuUjeE6YwJt46jFDpiDoT5SQBnJy4m27t2/zpqHQUCAqCnjhBaBtW96z49AhQM1o2USHlZYCp08DCxcCHTvyHmOff86bBg8c4L3GIiKaf+EPUA2AkEYTifhTnP368Xlcr10D9u3jy/r1/KnOvn35MwVBQYC/P7+3QHSDQsG7Bp84wYcLOXMGKCzkBf/LL/PEHxCgmzU+SgCENLFu3fjy8ce8B8jx43zZvh345BPA1JQnBH9/Pu6Lnx+vTZDmISsLuHBBtURH8y6cDg48gX/9NfDSSzwB6DpKAIRoUJs2wGuv8QXgNwWVV5G//w58+SXvMeLiokoGPXoAPj58HdGsx495je3GDeDiReD8eeDuXb7N3Z0n6k8+4QW/j4+wsWoCJQBCtMjNTTUCKQDk5QGxscC5c/xq83//U01TaW0NdOnCl65deRuzpyfveUTq59EjIDGRF/QVF+VAqra2QJ8+vGeXnx8v+Fu3FjZmbaAEQIiALC1V9waUsrL4A2g3b/LXGzf4k6M5OXy7iQlvfvDw4K/KxdWVL+bmwnwWIRUV8cT58CEv6BMTgYQE1c/KqYrNzHgi7dqVP+jXtSu/stfXJjhKAIQ0M7a2wIABfKkoNVVVqClfT54Evv8eyM5W7WdhwZuPHB15bcHZmRdwrVrxY9vZ8Z/t7Pi+zVVhIU+GT57w5fFjvmRk8II+PR1ITubfS1aW6n3m5qqkOGgQ8NZbqt/btdPNm7WaQgmAEB3h5MSXF1+svi0rixeGVQvGW7fOY9++JTAx2YOsLCvI5ZXfJ5HwRGBnx29OW1nxGoaxMWBjw19NTPh6AwO+WFlVPoZyfyWZrHrX14ICvh7gNZniYuDpU94EVlzMt+fn83XKQr+4uPIxRCKeuBwceIJr04Y32zg68t+dnPirg0PDvl99RAmAkBbA1pYv3bqp1u3Zswc7dkxF//798euvvODOzVVdTSsLWuVrUREvnIuK+HLvHn8tLlbVMJ5XuAPVkwRjTyASHYSNzWQAIlha8qRhZsabwExNAXt7XhsxMVElJGVtpeKrSKSxr1AvUQIgpAWKiIjAv/71L8ycORNr166FWMz/q1tZ8cXdXXuxnD+fAH//qYiJ8UPHjh21d2LyXNQaRkgLUlpaiunTp2PevHlYs2YNNm7cWF74C6VXr14wNTXF2bNnBY2DVEcJgJAWIisrC0OHDsWePXuwb98+zJkzR+iQAAASiQS+vr6IiYkROhRSBTUBEdICJCQkYOTIkSgoKMCpU6fQs2dPoUOqJDAwEPv37xc6DFIF1QAI0XHR0dEIDAyElZUVYmNjm13hDwABAQGIi4tDVsX+mkRwlAAI0WFbt25FUFAQXnzxRZw4cQJt2rQROiS1+vXrBwA4d+6cwJGQiigBEKKDGGNYvnw53njjDbz99tv49ddfYWpqKnRYNWrVqhU8PT3pPkAzQ/cACNExxcXFeOONN7Bnzx788MMPmDZtmtAh1UlgYCD1BGpmKAEQokPS0tIwZswYJCYm4siRIxg4cKDQIdVZQEAAdu/eDblcLnjXVMJRExAhOuL69esICAhAVlYWoqOjdarwB3gNoLCwENeuXRM6FPIMJQBCdMCRI0fwwgsvwMXFBTExMejUqU4BfRgAACAASURBVJPQIdWbj48PbG1tqRmoGaEEQEgzt2nTJowcORJjx47F8ePH0VpHB6oXiUTo06cPzp8/L3Qo5BlKAIQ0UwqFAnPmzMHbb7+NJUuW4Pvvv4eRkZHQYTWKr68vLl++LHQY5BlKAIQ0QwUFBQgNDcXmzZuxc+dOLF++XOiQmkSvXr0QHx+PgqpDihJBUAIgpJlJSUnBiy++iNjYWJw6dQqTJk0SOqQm06tXL5SVleHq1atCh0JACYCQZuX8+fPo3bs35HI5zp07hz59+ggdUpNq37497OzsqBmomaAEQEgzERkZiaCgIHTv3h2nT59Gu3bthA6pyYlEIvTs2ZMSQDNBCYCQZiAiIgKvvvoqJk+ejKioKFhVnXexBenVqxclgGaCEgAhAmqOE7hoWrdu3RAfH4/S0lKhQ9F7LfsvjZBmLCsrC+PGjUNsbCz27duHkSNHCh2SVnTt2hWlpaW4e/cufHx8hA5Hr1ENgBABJCQkIDAwEHfv3sWpU6f0pvAHgE6dOkEikeD69etCh6L3KAEQomXKCVysra2b7QQummRkZARPT09KAM0AJQBCtKjiBC7Hjx9vthO4aFrXrl1x48YNocPQe5QACNECXZvARdO6du1KNYBmgBIAIRpWXFyMsLAwfP755/jhhx8QEREBA4O6/9c7ePAgvLy8WlTvoC5duuD+/fsoLCwUOhS91nL+oghphhozgUtiYiI++OADJCUlISMjQ3NBCqBjx45gjOHu3bvo0aOH0OHoLaoBEKIhyglcsrOzcfbs2XpP4PLRRx8hMDAQly5dgoWFhWaCFEiHDh0gkUhw+/ZtoUPRa1QDIEQDjhw5ggkTJqBr167Yu3dvg8bw/+6772BiYqKB6IQnkUjQvn173LlzR+hQ9BrVAAhpYsoJXMaNG9eoCVxaauGv5OXlRTUAgVECIKSJPG8Cl/j4eISGhsLKygqmpqbw8/NDVFQUgoODIRKJIBKJMHPmTAE/gXZ17NiREoDAqAmIkCZQUFCASZMm4c8//8TOnTurjeGfkJCAgIAAmJmZITIyEgEBAUhKSsL777+Pa9euQSqVori4WKDoheHl5YXNmzcLHYZeowRASCMlJydj9OjRSE9Px6lTp9SO4b948WLk5ORgy5YtGDx4MAA+SfpPP/2E9u3bazni5sHLywv5+fnIyMiAg4OD0OHoJWoCIqQRKk7gEhMTU+MELocPHwYADB06tNL61q1bo1OnThqPszlSJr779+8LGoc+owRASAMpJ3Dp0aNHrRO4lJSUID8/H8bGxjA3N6+23cbGRtOhNkuurq4Qi8WUAARECYCQBqjPBC5SqRQWFhYoLi5WOxl6ZmamJkNttsRiMZycnCgBCIgSACH10NAJXEJCQgComoKU0tPT9bovfPv27ZGUlCR0GHqLEgAhdZSVlYWhQ4diz5492LdvH+bMmVPn93722WewtbXF+++/jz/++AMFBQW4ceMGXn/9db0dERTgCYBqAMKhBEBIHTR2ApcOHTqU3yR+5ZVX4ODggPDwcCxatAgeHh5q3xMVFVX+fEBKSgoUCkX571u2bGmKjyU4SgDCom6ghDxHdHQ0QkND0aFDB/z1118NvmL38vLC3r1767z/yJEjwRhr0Ll0BTUBCYtqAITUQjmBy4ABA/R6AhdNcXJywtOnT5GTkyN0KHqJEgAhatAELtrh6OgIgN8MJ9pHCYCQKho7gUtd/fLLLxCJRDh27BhKSkr0biwgAOU1qrS0NIEj0U90D4CQChozgUt9TZw4ERMnTtTY8XVBq1atIJFIqAYgEEoAhDxz/fp1jBo1ChKJBGfPnkXHjh2FDqnFMzAwgL29PdUABEJNQISAT+DSv39/uLi4UOGvZY6OjlQDEAglAKL3mmoCF9Iwbdq0oRqAQCgBEL31vAlciHbY29vj8ePHQoehl+geANFLz5vAhWiPjY0Nbt68KXQYeokSANE7ycnJGDVqFDIyMmqcwIVoj42NDbKzs4UOQy9RExDRK8oJXBQKRa0TuBDtsba2pgQgEEoARG/UdQIXol02NjbIyclp8eMeNUeUAIheqM8ELkS7bGxsIJPJUFhYKHQoeofuAZAWrbS0FG+++SZ27tyJr7/+GrNnzxY6JFKFckrMnJwctVNmEs2hBEBqFRcXh/feew8KhaJ8XXZ2NsRicaVhEkQiEfz8/PDll18KEKV6WVlZGDduHGJjY7Fv3756j+FPtEOZALKzs+Hi4iJwNPqFEgCplZeXF65evYonT55U21b16c2xY8dqKywAwNWrV9G9e3e12xISEjBy5EgUFBTg1KlT6Nmzp1ZjI3VnYmICAHj69KnAkegfugdAamVoaIjJkyc/9wEpAwMDTJgwQUtRAefOnYOfnx9OnDhRbVt0dDQCAgJgbW2N2NhYKvybOWNjYwB8FFaiXZQAyHNNmjQJpaWlNW43NDTESy+9BAcHB63EU1ZWhnfeeQcymQxjxoypNKn6999/j6CgIAwcOJAmcNERygRQUlIicCT6hxIAea6+ffs+t8vklClTtBQNL+SvXbsGxhiKiooQHByMzMxMLF++HDNmzMDbb7+NXbt20QQuOkIqlQKgGoAQKAGQOpk8eTIkEonabQYGBggNDdVKHHl5eVi4cGF5n3G5XI709HS8+OKL+Pzzz7Ft2zaNTeBCNEMqlUIkElECEAD9LyF1EhYWBplMVm29WCzGiBEjtNavftmyZcjNza300JBMJkNiYiJCQkIwdepUrcRBmpZUKqUEIABKAKROOnfuDG9vb4hEokrrFQoFJk+erJUY4uLi8M0330Aul1fbJpfLsX//fnz22WdaiYU0LWNjY0oAAqAEQOps6tSpMDQ0rLTOxMQEw4cP18r5Z8+eXWvTTllZGZYuXYqff/5ZK/GQpiOVSmvtaEA0gxIAqbNJkyZVeiBMIpHglVdeKe/HrUl79+7FsWPH1DZDVcQYw+uvv47z589rPCbSdGgcIGFQAiB11rZtW/Tp06f8KlwmkyEsLEzj5y0uLsacOXOq1T4qUt6gbteuHZYvXw5XV1eNx0WaTllZGd24FwA9CUzqZerUqbh06RIAPoxvUFCQxs+5atUqpKWlVap9AHz4CQMDAxgYGGD06NF4++23MWjQoGr3KUjzRwlAGPSNk3oZP348AF74Tp48GWKxZq8hkpOT8dlnn1VregKArl274quvvkJ6ejoiIyMRHBxMhb+OogQgDKoB6ImSEuDpU4AxICeHrysoAJRN6jIZ/70m+fkA73xjD2/vl3D9+p9o0+Y17N7Nt5ubAzU8JgCxGLCwUP1uYcHXSaWAqSkgEgHW1urfO2/ePBQXF8PAwACMMVhaWmLGjBl444034OPjU5+vgDRjlACEQQmgmSktBbKzgaws/pqXxwvfvDygsJAX4jk5/OfCQl5o5+aqtuXmAmVl/BWoWHA3pSkA7mLpUv+mPnB5IpFKAQODU0hN3Q3AADY2g+Hu/hbc3UeioMAIP/wAmJnxBGJtzX82M+PJxdYWsLHhr5aWTR4i0QDGGNXeBEAJQIOKi4HMTCAtDXj0iP+cmckLd2UBX/W1pqtwS0te2JmZqQo8U1Ne4Lm6Vt4G8AIQ4OuMjHihqhxq3dqaX3WbmvKCVkm5Xh1jY0DZ2Sc//2VERDzA0qWqnWub0a+oiH8XSsokpVwvl/NEVXFbYaEC33//P3Tu/Ck6dpwGudy5POndu8f3e/q0ckJU14vQ0JAngopJoeqrvT3g6MhfW7fmC9EuqgEIQ8So/1W95ecDDx7wJTkZSE3lBXxaGi/gHz3i65SFmpK5OS9k7OxqLoyUr8qfLS0rN580FyUlJeVjuGiCXC6HoaFhva4KZTL+ndeWYKu+PnnC/80q3l+WSHgSUCYG5c9OTnxxdQXatQPatOEJhjSesbExNm/erNUxpQjWUQ2girIy4OFDfpX58KGqkH/4EEhK4j8rm1cAXji7uPBCok0boGdP/rPyitLenq93cFBdQbcEmiz8ATTo5rJEokqe9cFY5RqassaWkQGkp/Ofb97kP6enq5KFWMz/ndu25YuLC1/ateO/e3g0z+Td3MhkMpSUlNBsYALQywQgk6kK+apLfDxvTgB484izM/9P7uQEjByp+tndXfUz0W0ikSpZ10V2turvJTWVJ4x794CzZ/nP9+/zCwmA1+Lc3WteCFDwrN3TgrKl1rXoJqDiYiAujl+93bjBX2/d4lfyyqu4Vq34lVqHDvxVubi7171AIKSi4mL+N5aYCCQkqJbERJ4clPcqrK0BLy+ga1fA2xvo0gXw8eEXHfrkwYMHaNeuHWJiYuDv3/QdC0iNWkYTEGP8P9fly6qC/sYNvk6h4DdBO3Xi/8neeAPw9FQV+FoaxJLoEWNjoGNHvlSlUPBmRWVSiI/nf69RUbzJCeC1Bh8fvnTpAnTrBvTqpbqJ39JQDUA4OpkAUlOBS5dUy/nzvJ3W0JC3v3p7Ay+/zF+V/5GeTTpEiKAMDQE3N74MHlx5W04Ov3C5dUtVW923T5UY3N2Bfv0AX1/V0hLuKykTAN0D0L5m3wRUWgpcuAD89RcQEwPExvIbdQYG/Kq+d2++9OkDdO/eMv5DEFLRgwf87z42Frh4kb/m5PCb3l26AH5+wAsv4P+zd95hUR1tG78XFulFFAtrwyAKWGOvCGJBLNh7LyT6aYwxiiWJ0dgSX7uisceuqFFQsZdgxYIYoxRrRBCkdynP98dkgXWXvrtngfld17l2OTNn5j6Hs/NMfQaOjmVzTOry5ctwdnZGdHQ0zIs7gs8pDZrXBZSRkVvgX7vGBtZSUli/aOfOwLx5rMBv0YLPsOBUDKSzjAYOzD0XGpprEO7eBXbvZpWlBg2Arl0BBwf2WRbGE3gLQDg0wgC8fQucPg14ewN+frkFvqMjsH49e5GtrYVWyeFoDtLJCsOHs79TUlhlSVpx2rOHVaYaNAB69gT692dGIT93HUISFxcHfX19VKpUSWgpFQ7BDMDDh6zQP30aePSILXjq1QvYsIG9qLzA53CKjoEB4OzMDoBNZb51C7h6FThzBti0iU14cHFhxsDFRXMmQISHh6NmzZpCy6iQqHUMICgI2LULOHSIzcOvXRvo25e9kF27stk6HA5H+bx6ldvKvn6drX3o1g0YPx5wc5N1CaJuZs2aBX9/f9y8eVM4ERWTLSo3ACkpwLFjwM6drHunTh1g7Fj20n35pSpz5nA4ioiNBc6dAw4fZp+mpsDo0cCkSWxNgroZPnw4MjMz4eXlpf7MKzZbVOZ96eVLYPp0Nith6lTmDuHcOXZ+yRJe+HM4QlG5MjByJGsRvHkDfPcdcPYsW2/Qti1w8KAqPMjmT0REBGrUqKG+DDk5KN0AhIay2kTDhoCvL/DTT0BYGHD0KBuMEtrhX79+/SASifDLL78UGjcrKwvz589HgwYNoKenBxcXl3zj+vv7Y/z48bCysoK+vj7Mzc3RuHFjDBo0CJ6ennjx4kVOXCMjI4hEIrlDS0sLFhYWcHNzg7+/f755vXnzBv369UNCQoJc2NmzZ2FjY1OqjVoCAgLg6uoKMzMzGBsbw9nZWWHz3MPDA0eOHMk3nQkTJkBXVxdWVlb45ptvkJbXJWgBqPL+OnXqpPDZi0QizJo1Sybu1q1b840rPfJ7J4qis7Dnpw4sLYH581n37LVrbK3BuHHs97tzp6yTPFURERGB6tWrF/u62NhYbN26FU5OTjA3N4e+vj4aNGiAUaNG4fHjxypQWg4hJREfTzRrFlGlSkS2tkQHDhBlZCgrdeWwd+9eAkAAaOnSpYXG37ZtGwGgJUuWUGxsrMI4WVlZNGfOHBKLxfT999/Ts2fPKC0tjSIiIujChQvk7Oyck2dGngfy6NEjAkD9+/fPORcXF0cnTpygatWqkY6ODl28eFEuv0ePHlHVqlVp48aNMudDQ0Opb9++1LRpUzIxMSFtbe2iPhYZ7ty5Q/r6+jRs2DB6//49RUVF0ZQpU0gsFtP58+fl8rSysqJFixblm15CQgJt3bqVANCyZcsKzV/V99exY8ec/8fnxzfffCMT19PTM9+40mPJkiUl1lmU5ycEL14QTZ1KpKND1Lgx0aVLqs3PxMSEtm/fXuzrJk2aRGKxmNatW0fh4eGUnJxMN27cIDs7O9LW1qaTJ0+qQG25YrNSDMC5c0S1axNVq0a0davmFfxERGFhYVS5cmUaM2ZMkQ3AiBEjCAAlJCTkG2fBggUEgH7//XeF4ZmZmeTi4lIkAyBl//79BIDs7e1lzsfHx1OtWrXI3d1dodYVK1ZQRkYGSSSSEhWQWVlZZG9vTzVr1qSUlBSZe2jYsCHVrl2b0tLSZK4JCAggkUhER44cKTBtAwMD6tGjR4FxVH1/RMwA+Pv7Fymup6enwv8PEVFwcDDp6upSeHh4qXQW9fkJQVAQUf/+RCIR0aRJrJKnbFJSUggAeXt7F/vaSZMm0dSpU+XOBwQEEABq0KCBMiSWZ0pnALKziZYuJdLSIhoxgigqSlm6lE/v3r1p6tSptG/fviIbgB49ehT4A3727BlpaWlRy5YtC0zn1q1bxTIAYWFhOTXMvC2PhQsXklgsprCwMLlr8hbYJS0gr169SgBoxowZcmGLFy8mAOTl5SUXNmTIEKpVq5bM/X2OpaVloc9J1fdHVDwDcPHiRVq9erXCsBkzZtCwYcOUorMoz09IvLxY5c7Wlig4WLlpP3v2jADQo0ePlJquvr4+aWlpUXZ2tlLTLWdsLlWP/PffAz//DCxfzgaOqlYtTWqqY9euXXj69ClWr15drOuyCukA/f3335GdnZ2zUXp+tG/fHkRU5H5ryjMxS7ohChFhx44daNu2LSwVrPfXV4IPjCtXrgAAWrVqJRcmPXf58mW5sAEDBuDdu3c4c+ZMvmmLRCJkFjCyqI77Ky7Ozs747rvv5M4nJiZi7969mDZtmlxYSXQW5fkJyaBBuWt1OnZkPoqURVBQEEQiEayVuPAnOTkZqampaNy4Md9mshBKbAB+/ZWt0j1yhLln0FTevXuH7777Drt27VK6t8EbN24AAJo2barUdK9duwYAsLe3h+l/q3UeP36MDx8+oFmzZkrNKy/Pnz8HANSqVUsuTPKfT4Hg4GC5sObNmwMAzp8/X+K81XF/Uvbt24fmzZvD0NAQpqam6Ny5Mw4ePFjk63fv3o06deqgS5cuStGjjOenaiwtgcuX2eBwr14FbwFaHIKDgyGRSHLcQDx//hxubm4wNTWFgYEB2rRpAx8fHzg7O+cMvE+ePLnANI8dOwYAWLhwoXJElmNKZACCg4Eff2Q1/7z+STSRyZMnY+TIkXBycir2tZ8+fSpw56v3798DAKpUqVJifXlJSEjAyZMnMXv2bOjo6GDdunU5YX///TcAxYWzsoiLiwMAGBoayoVJf6CxCn75UuMg1agIXV1dZGRk5BuujvuTEhsbi127diEyMhL37t2DlZUVRo0ahZkzZxZ6LRFh8+bNCmv/JaUoz08TMDRkU0ezs9nUUWUQEhICGxsbAEBoaCjat2+P+/fvw8vLC5GRkdi9ezfWr1+PwMBA6Orq5rQU8+PDhw/w8PDA5MmTMXToUOWILMeUaC7d5s1sFe/s2cqWo1y2b9+OkJAQHD9+vETXv337tkgFUmmamadOncq5XiQSwdzcHB07dsSiRYvQunXrnHjh4eEAkNMiUDfSbilF92piYgKRSJSjURGWlpZ48uQJMjMzFXaFqev+/Pz8ZP5u2LAh/vjjDwQFBWHjxo0YNWoU2rZtm+/1586dQ3h4uFL3ri3K89MUKldmFb8pU4AVK9hWp6UhODgYtra2AIAFCxYgLi4OO3bsQPf/fGXb29vj4MGDqFevXqFpRUdHo1evXujatSu2bt1aOmEVhBK1AK5fBwYP1uwNsd++fYvvv/8eu3btUlijLYiYmBj89ttvePPmTYE1PWlf9cePH0uss3///iAiEBGys7Px8eNHnDp1SqbwB5Azh15Hhd68zMzMALA+1M+RnpPG+RyxWIzU1NR803Z3d0dCQgJ+/PFHhc9LHfdXEIMHDwYAeHt7Fxhvw4YNGDt2rNI9Vxb2/DSJIUPYQrFbt0qfVkhICBo0aAAA8PX1BQD07NlTJo6FhQUaNWpUYDrJycno2bMn7OzscODAAWhrcuGkQZTIAERHs43PNRlvb2/Ex8eja9euMgt3pDW3H374IedcaGhoznXjx49HlSpV4OHhgblz5xbYLeDg4AAACAwMVO3NAND7b0ebgrpRSov0R/bu3Tu5sLCwMADIaa5/TmZmZoEDoKNHj8ayZcvw22+/wcLCAr169ZIJV8f9FYTUGVlkZGS+cYKDg3HhwgWldv9IKez5aRL6+swVeynqPQCYG+jw8HDY2NggPT0diYmJ0NPTU2hcK1eunG86mZmZGDJkCCQSCfbu3csL/2JQIgNgZcV2LNJkpk+fnlOzznvs27cPALB06dKcc3lnIOzZswfx8fE4fPgw1qxZA3d393zzcHd3h1gsLtSHydy5c6GlpZUzyFoSpAVUfHx8idMoDEdHRwDAgwcP5MKk57p16yYXlpCQACIq0KPjwoULsWDBAnh6eiIuLi6ntidFHfdXENLxnGoFbAS9YcMGdOnSBXZ2dkrNuyjPT5P4918gPr70m9oHBweDiNCgQQPo6urC2NgYaWlpOfsD5KUgw+zu7o709HQcPXpUpnvR2toad+7cKZ3Ick6JDMCQIczBW0SEsuVoBiYmJhgyZAhatGhRYOFuY2ODn376Cffv38euXbsUxgkKCsK2bdswdOjQQpuxBdG4cWMAimvnysLBwQF2dnbw8vKScduQlZWFw4cPo3bt2nB1dZW7Tto6kGpUxIkTJ2BlZYXJkycr7OdXx/3t2LEDLVu2lDtPRDh69CgAoG/fvgqvTUhIwB9//IHp06crXVdRnp8msWED8+1V2klQDx8+hIGBAb744gsAyHGr8XnlICIiQuHsMwBYvHgxnj59ilOnThU4YYOTDyVZPZCYSFS/PlHv3kSZmaVZh6B+irMQrFu3bkVayOPh4UE6Ojo0b948CgoKovT0dHr37h3t2LGDatasSZ06daKkpCSZawpaCKaI7OxsqlatGnXs2LHQuEVZgDRq1CgCQC9fvpQ5f/v2bdLT06Phw4dTeHg4ffz4kdzd3UksFpOvr6/CtA4ePEgAClx6L5FIqFmzZvmGK/P+Xr16RVpaWgSAHjx4kHN++/btBICmTZtGISEhlJqaSs+fP895FooWwElZu3Yt1axZs1iLtYq6EKwoz09TuH6dSCwm8vQsfVru7u7UqVOnnL9DQ0PJ3NycJBIJXbhwgRITE+nJkyfUq1cvqlu3Lunq6spcv3v37kJdddy+fbv0QssvJV8JfPs2kYEB0Zgxmun64XPc3d0VviA9e/bM9xpnZ+cirzi9d+8ejRkzhmrXrk06OjpkbGxM7dq1o/Xr11N6erpMXENDQzkdDRs2LDSPBQsW5LtS1tvbO98fgSI/K05OTmRkZESZCiz4w4cPycXFhUxMTMjIyIicnJzIz88vX11DhgwhiURCnz59yjeORCKh5s2bq+X+pAZAJBJRYGBgzvm0tDQ6duwYDRgwgL744gvS1dUlU1NT6tq1Kx08eDBfXdnZ2WRtbU0//vhjgfqLq1NKUZ6fJnD3LpGpKdHgwcwLQGn58ssv6dtvv5U5FxQURG5ubmRiYkIGBgbUoUMHun79OnXr1k3OALi6unIDUDpK5wri/HkiQ0MiR0eiyEhladIcXF1dSSQSCS0jh7i4OJJIJAp95RSH2NhY0tfXp8mTJ5dak9SXzaFDhwqMV716dWrXrl2BcZR1f2WJoj4/odm7l0hfn8jVleiz+kyJSEtLo0qVKtGBAweKFF+RAeCUmtI7gwsIILKyIrKwINLwd7jYSFsNERERQkvJ4eHDh1SlShXatGlTia7Pzs6mMWPGUPXq1eUcmRWXFy9eUP369WnBggUFxvv06RPp6OjQ4MGDC02ztPdXlijq8xOS8HCigQOZQ7jvv1del++dO3cIAAUX0bkQNwAqoXS+gACgWTPg77+BiROBUaOA9u2B8rKzm3Sq4sqVKxEdHS2wGkaLFi1w//59nDt3TqG//ML48OEDXr58icuXL5d6E45t27Zh2bJlWLZsWb5x4uPjsWbNGmRkZMhN/VREae+vLFGU5ycUKSnAqlVAo0Zs/+4LF5j7F2XNsLx//z5MTU2V6gOIUwKUaU7u3SNycCACiJydiW7eVGbqwrBq1SqytbUlXV1d6tWrl9ByyhTjxo0jHR0dsra2ph9++EHheANHs0hMJFq3jsjSknXvzptHVIA39BIzfvx4cnZ2LjTeoUOH5Pr1J02apHxBFZPNKtkT2MeHLRO/dYttMTdpEjBsGPMmyOFwNI/799kOYIcOAUTA118zVy8FLIsoFba2tnBzc8OKFStUkwGnKKhmT+A+fVg30I0bgLU1MHMm8yY4YQLbGJ7D4QhPTAyb09+sGdC6Nfu9/vgj8Po1sHKl6gr/sLAwPH/+vEQOGjnKRSUtgM+Ji2P7BezcyfoTra2BAQOAfv3YmAFfuc3hqIeICNZCP3UKuHgRqFSJtc4nTmS/RXWwa9cuTJ8+HTExMWXG/UU5ZYtaDEBeHj0CDh9mL2BQEPMp1KcPMwY9egAGBupUw+GUf/75h7lxPnUKuHcP0NMDundnlbDBg5mbZ3UyYsQIxMbGyq345agd9RuAvAQFsZfy1Cngzh1AV5ftOOTgAHTtCrRpw2ooHA6n6Pz7L3DtGjuuXgVevWLdOX36AP37s8JfqIp3dnY2atSogXnz5incbY2jVoQ1AHmJjATOnGEv7LVr7CU2MGDN0q5duUHgcPIjb4F//Trw4gWrTLVpw343PXuy35GWSkb8isf9+/fRunVrBAYGokmTJkLLqehojgH4nPfv2UDypUusAw1/DQAAIABJREFUr/LVK0AsBmxsgJYtcw9uFDgVifh44MkT4MEDdty8Cbx8yX4bzZoBzs65rWhNnHW3YsUKbNiwAe/fv+f79QqP5hqAz3n5kk0rvX8f8PcHAgLYYhVDQ6BFC6BVK2YQGjcGbG1ZDYjDKcu8f8/crgcE5L73r16xsHr12Myd1q1ZJahNG+G6dYqDk5MTatWqhT/++ENoKZyyZAA+JzOT/Tju38/9cQQGAhkZrDZUvz7QpAlgZ8eMgr09az0ItOEUh5MvUVGsVv/PP2xVvfRTuv1yzZqsgtO6de5n1arCai4JkZGRkEgkOHDgAN+vVzMouwZAERkZbMP6p09lf0gvXjCDoaPDjECDBmwq6hdfsE9ra7bHMZ+OylEV8fHsPQwNZYf0+7NnzAAAgLk5q6jY27NKi50dq8SUxcJeEZs2bYKHhwc+fPhQ7G1aOSqhfBmA/EhPZz+0f/5hxiHvD1C6AVWlSmynM6lBqF8fqFsXqFWLHaXd/JpTvklLA96+BcLC2KDs69dASEjueyYt5LW1gTp1cisgDRvmFvr/bTFdbunYsSPq16+fsysfR3AqhgEoiI8fZQ2C9PvLl8CHD7nxdHVzjUGdOqzFUKsW+5RImIGwsOBdTOWRhAQgPJzNVHv7Fnj3jh1v3uR+lxbwAJtnX7eubAtTWuDXq1cxJy28ffsW9erVg4+PD3r37i20HA5ji7jwOOWbqlXZ0a6dfFh6OqvNvXvHPvP++AMC2Ke0n1aKhQWbc12tGuu7rVaNGYcaNdh3CwvW1Dc3BwrY55qjQtLSmBuE2Fj2GRHBjqgoVtB/+MC+v3/PCv08u2NCR4fV1GvXZoV8jx7ylQILC+HuTVM5dOgQKleuDGdnZ6GlcPJQ4VsApSUlhRmHqChWWEhrih8+sEIl7/eUFPnrpYZA+pn3u7k5YGwMmJmxNRGGhmxqn7Fx7t8VzYikprLnGB8PJCUBycnsiItjn0lJuQV73s+831NTZdPU0so13FJjbWHBDLi0ZWdpyT5r1NCM+fRljebNm6N9+/bw9PQUWgonF94FpE6Sk5lB+LxwUlRISb8nJrLCraD/ktQYGBszA6Gtzc7p6rIaq5ERi2dmBohEuWFiMbsmLwUZlPzCUlNla8kFhWVmsnsCcu8rJYW1tvKGxccD2dmsQE9JYZ/ScwU9ByOj/A2qou/m5qxg5xMAVMfz589ha2uL69evo0tpd5LnKBPeBaRODA3ZQLOVVfGvTU1lBiQhgR0pKbI1X2ntV1qoJiayAjU9ncUlyp1DnpTEZkx9+sSuk5KRwcIAICvrb6Sl/Q8GBhsgEhnLFM6fo8iQKArLyopESsox1KkzHQA7LxazPnN9fdY3Xr8+ZMI+N26GhuycmRkr7A0N2SE1bhzNY9euXahduzY6deoktBTOZ3ADUEbQ12eHuqYEbt9+G99+ewzR0TuV1uVx5crf6Nbt/3DggA26d++unEQ5Gk1qaip27dqFb7/9Flq870zj4P8RjkICAwPRtGlTpf5onZyc4Orqiu+//x5ZWVlKS5ejuRw6dAiJiYmYPHmy0FI4CuAGgKMQqQFQNqtXr8Y///yDPXv2KD1tjubh6emJIUOGoDpfSKORcAPAkYOI8OTJE5V4a2zUqBGmTp2KhQsXlvtN3ys6t27dwv379zFt2jShpXDygRsAjhxhYWGIjY1VmbveJUuWICMjA6tXr1ZJ+hzNYOXKlWjbti06dOggtBROPnADwJHjxYsXAIAGDRqoJH1zc3N4eHhg9erVePv2rUry4AjLs2fPcObMGSxYsEBoKZwC4AaAI8erV6+gp6eHGjVqqCyPb775BhKJBIsWLVJZHhzhWLFiBRo2bIg+ffoILYVTANwAcOR49eoVrKysVLphR6VKlbB8+XLs378f/v7+KsuHo35evXqFw4cPw8PDg0/91HD4SmCOHGPGjEFsbCx8fHxUnleXLl2QmZmJmzdv8h2iygkTJkzAX3/9hWfPnkGHe0fUZLZw88yR49WrV6hXr55a8lq9ejXu3LmDEydOqCU/jmoJDg7G/v37sXjxYl74lwG4AeDIER4ejlq1aqklrzZt2mDkyJGYO3cu0tPT1ZInR3UsWrQIDRs2xMiRI4WWwikC3ABw5IiKikJVNW5DtXz5crx//x5bt25VW54c5fPo0SN4eXlhyZIlvO+/jMD/SxwZMjIykJSUhCpVqqgtzzp16mD69OlYtmwZEvPzOMfReObMmYPWrVtjwIABQkvhFBFuADgyREdHg4jUagAAYP78+UhPT8f69evVmi9HOfz555+4evUq/ve///HB/DIENwAcGT5+/AgAau0CAoAqVargu+++w+rVqxEdHa3WvDml49OnT5g3bx6GDx/OXT6XMbgB4MgQ+98el2ZmZmrPe/bs2dDT08OqVavUnjen5GzatAn//vsvVqxYIbQUTjHhBoAjQ0ZGBgBAV1dX7XkbGRnBw8MDGzduxLt379SeP6f4hIWF4eeff8acOXNQt25doeVwigk3ABwZpH76hZrFMW3aNNSsWRO//PKLIPlzisesWbNgbm6OefPmCS2FUwK4AeDIkP3fprtCGYBKlSrhhx9+wI4dO/D8+XNBNHCKhq+vL7y8vLBp0yYYGhoKLYdTArgB4MggNQDaAu6SPnbsWDRs2BA///yzYBo4BZOSkoJp06Zh6NChcHV1FVoOp4RwA8CRQegWAMCMz5IlS3DkyBE8evRIMB2c/Fm0aBFiY2Oxdu1aoaVwSgE3ABwZpAW/0Hv2Dhw4EG3atOHuojWQO3fuYMOGDVi7di0sLS2FlsMpBdwAcGSQTv+Mi4sTVIdIJMLSpUtx9uxZXLt2TVAtnFzS09MxadIkODo6Yty4cULL4ZQSbgA4MlSuXBlA7noAIenevTscHR2xdOlSoaVw/mPRokV49+4ddu3axVf8lgO4AeDIYG5uDkD5BuDs2bOwsbGBWCwu1nU//PADrly5gps3bypVjyICAgLg6uoKMzMzGBsbw9nZWS35lhUuX76MNWvWYO3atahdu7bQcjhKgBsAjgzSLiBlGYAXL16gX79+mD9/Pj58+FDs6x0dHdGxY0esXLlSKXry4+7du+jQoQOMjY3x7NkzvHr1CvXr10fXrl1x4cIFleZdFoiKisLYsWMxYMAATJw4UWg5HCXBdwTjyGFkZISNGzdiwoQJpU5r5MiRaNq0KebMmYN69eohIiICmZmZxUrjzJkz6NOnD+7fv4+WLVuWWtPnZGdno2nTpoiJicGLFy+gr68PgA2E29vbIyUlBSEhIYKsjtYEiAhubm549OgRAgICclqJnDIP3xGMI49EIsGbN2+UktbOnTvh4eFR7K6fvLi6uqJly5Yq8xF048YNPH36FIMHD84p/AE2HXXEiBH4999/1bI9pqayfv16nD17FocPH+aFfzmDGwCOHI0aNUJQUJBS0spboJYGDw8PHD9+HE+fPlVKenm5cuUKAKBVq1ZyYdJzly9fVnq+ZYEnT55g/vz5WLx4MTp06CC0HI6S4QaAI4etrS2ePXumMOz58+dwc3ODqakpDAwM0KZNG/j4+MDZ2RkikQgikQiTJ09WuqaBAwfCzs4Ov/76a5HiF0en1OWEom0wJRIJALbXbUUjOTkZQ4cORdu2beHh4SG0HI4KKHm7nFNuadSoEdavX4+srCwZlxChoaFo3749DA0N4eXlhfbt2+PNmzeYNWsWAgMDoauri7S0NJVo0tLSwty5czFhwgT88MMPsLa2zjducXVK1zwo8mdjZGQEQDOmxaqbGTNm4MOHDzh//rygrkE4qoO3ADhy2NraIi0tTW4cYMGCBYiLi8P69evRvXt3GBkZwd7eHgcPHkRycrLKdY0cORJWVlZYvXp1gfGUqVM6R6KizXnft28f9uzZg71796JOnTpCy+GoCG4AOHLY2tpCJBLJ9bf7+voCAHr27Clz3sLCAo0aNVK5Lm1tbcyZMwd79uxBWFhYvvGKq1M69VWRcZCeE2KDHKHw9/fH1KlTMWfOHPTt21doORwVwg0ARw4TExM0bNgQt27dyjmXnp6OxMRE6Onp5XSL5EW6gljVTJw4EdWrV8+3FVASnVKjoGgTGqmhsbGxKY3sMkNERAQGDhyILl268B2+KgDcAHAU0rlzZ/z11185f+vq6sLY2BhpaWlISkqSix8ZGakWXTo6Ovj222/x+++/K8yzJDodHR0BAA8ePJALk57r1q1baaVrPBkZGRg6dCgMDAxw5MgR3u9fAeAGgKMQBwcH+Pv7IzExMeeci4sLgNwuFikRERFqnSUzdepUGBkZYd26dQrDi6vTwcEBdnZ28PLykhkczsrKwuHDh1G7du0K4fN++vTpCAgIwIkTJypUl1eFhjgcBURHR5NYLKZjx47lnAsNDSVzc3OSSCR04cIFSkxMpCdPnlCvXr2obt26pKurW2CaEomEtLW1laJv+fLlZGJiQjExMXJhJdF5+/Zt0tPTo+HDh1N4eDh9/PiR3N3dSSwWk6+vr1I0azLr1q0jLS0t8vb2FloKR31s5gaAky+dO3emsWPHypwLCgoiNzc3MjExIQMDA+rQoQNdv36dunXrprBg9fb2JgAKj+3bt5dYW3x8PFWuXJmWLFmiMLy4OomIHj58SC4uLmRiYkJGRkbk5OREfn5+JdZYVrh06RKJxWJavny50FI46mUz9wXEyZe1a9fi559/Rnh4eKErep2dneHn56eydQCK+PHHH7Flyxa8efOmyHvSCqFTk3nx4gXatm2Lbt264fDhwxVuumsFh/sC4uTPqFGjkJKSglOnTgktRSEzZ85Eamoqdu3aJbSUMklUVBRcXFxQr1497N69mxf+FRBuADj5Uq1aNfTo0QO7d+8WWopCqlatinHjxmHt2rWCb2FZ1khJSUH//v2RmZkJHx8fGBgYCC2JIwDcAHAK5Ouvv8bFixcRGBioMFzabXD58mWkp6erzBdQfsyZMwdv377Fn3/+WWA8oXVqEllZWRg5ciRCQkJw7tw51KhRQ2hJHIHgYwCcAiEi2Nvbo0OHDtixY4fQchQyYMAAhIWF4d69e0JL0XiICFOmTMHBgwdx6dIl7uGzYsPHADgFIxKJMHv2bOzfvx+vXr0SWo5CvvvuO/j7+8usXOYo5qeffsKePXtw8OBBXvhzeAuAUziZmZlo2rQpWrRogQMHDggtRyHt27eHpaUljh8/LrQUjWX79u1wd3fH9u3bMWnSJKHlcISHtwA4hSMWi/HLL7/g0KFDuH//vtByFDJ79mz8+eefCA0NFVqKRnLq1Cl8/fXXWLx4MS/8OTnwFgCnyHTq1AlisRjXrl0TWoocWVlZaNiwIVxcXLBx40ah5WgUvr6+cHNzw4QJE+Dp6Sm0HI7mwFsAnKLz66+/4saNGxrZzaKtrY0ZM2Zg165diI6OFlqOxuDn54fBgwdj+PDh2Lx5s9ByOBoGNwCcItOhQwdMnDgRX331ldq8fxaHyZMnQ19fH9u2bRNaikZw69YtuLi4wMXFBTt27ICWFv+5c2ThbwSnWKxZswb6+vqYNWuW0FLkMDQ0xJQpU7Bhw4YK7+rh7t27cHFxQffu3XHo0CGIxXz3V4483ABwioWJiQl27dqFw4cP48SJE0LLkWPGjBmIjY3FoUOHhJYiGI8fP0bv3r3RoUMHXvhzCoQPAnNKxIQJE3Du3Dk8fPgQlpaWQsuRYdy4cXj48CECAwPl/NukpKSUa7cHT548gZOTE1q0aIHTp09DT09PaEkczYUPAnNKxsaNG2Fubo5Bgwbh06dPQsuRYc6cOXj69CkuXLgAgG0TuW/fPrRs2RJbt24VWJ3qePz4MZydndGkSROcOnWKF/6cQuEGgFMijIyMcPLkSTx9+hRz584VWo4MTZo0gbOzM5YvX46ffvoJlpaWGD9+PAICAhATEyO0PJXg7+8PJycnNG7cGN7e3oW67+ZwAG4AOKWgYcOG+P3337F+/Xrs27dPYZygoCCou5fxwYMH0NHRgZ+fH1auXImYmBhkZ2dDW1sbsbGxatWiLB4/foyEhASFYTdv3oSzszPatm0LHx+fIu+NwOFwA8ApFcOHD8eMGTPw9ddfyzljCwoKQseOHXHy5EmV68jIyMCxY8fg4OCAVq1a4eLFi8jOzpbpnsrMzCyTLQAiwoQJE9CvXz+57rbr16/DxcUFXbp0wYkTJ3jNn1M8hNiHjFO+yMzMpP79+1PVqlXp+fPnRET07t07srS0JJFIRF988QVlZGSoVMOMGTMIAGlpaeW7BSUAcnJyUqkOVbB//34SiUSkra1NI0aMoOzsbCIiOnv2LOnr69OwYcPo06dPAqvklEH4nsAc5ZCcnEzt27cnKysrCgoKIjs7O9LR0ckplLdt26bS/NPT08nR0TEnz/yOJk2aqFSHsklJSSFLS8scw6alpUXz588nb29v0tPTo1GjRqncuHLKLXxPYI7yiIqKQvv27fHx40ekpKQgIyMjJ6xq1ap4/fq1SvunU1JS0LVrVwQEBMjknReJRIJ3796pTIOyWbZsGX766Se5Hc/q16+PXr16YdOmTXwrR05J4dNAOcrD3Nwc9erVQ3JyslwBHBcXh3Xr1qk0fwMDA5w7dw716tWDjo6Owjjx8fEq1aBMIiMjsXz5coXbXb5+/RpOTk688OeUCm4AOEqBiDB58mRcu3YNmZmZcuGZmZlYvny5yn0IValSBVevXoWFhYVCI5CcnKxQnyayaNGifFsyRISRI0fyTXA4pYIbAI5SmDdvHv74448CN2f/9OkTli1bpnItEokE165dg7GxMbS1tWXCiAhxcXEq11Banj59ip07dxZoALKysuDq6oqQkBA1q+OUF7gB4JSabdu24bfffit0vn9mZiY8PT3VsrVkgwYN4OvrC11dXTkvmGVhKui3334rZ7w+JysrC3FxcejTpw9SUlLUpIxTnuAGgFNqJkyYgKNHj6Jz584AkG//u5QFCxaoQxZat24NHx8faGtry/SVa7oBuHLlCi5evJhv7V9LSwsikQiVK1fGvHnz4OvrW679G3FUB58FxFEqDx8+xNatW7F3715kZ2cr7G8XiUS4f/8+vvzyS7Vo+vPPPzFo0CBkZ2cDAM6cOYPevXurJe/ikpWVhcaNGyMkJESuO01HRwcZGRlo1qwZpk2bhjFjxvCFX5zSwGcBcZTLl19+id9//x3//vsvfvnlF9SsWRMikUimO0MsFuP7779XmyY3Nzds2bIlpxWgye4gdu7cieDg4JzCX0tLC9ra2jA0NMSECRMQGBiIgIAATJ06lRf+nFLDWwAclZKZmYmTJ09i3bp1uHXrVk4tFgAuXbqEbt26KS2vT5+A5GQgOxuQzvaMj2d/A8DWrcuwY8ciTJ++AW5uM2SuTU0FCtpDxswMyG/GpakpIB1mMDAAdHXZYWAAaGsDJiZF05+YmAgrKytER0fnPKfmzZtj5syZGDZsGO/m4SibLdwAcNTG48ePsXHjRuzfvx/p6emwt2+KEycCEBMjQkICK6wTEoCkJFaQS88lJeUesbEs7NMnIDERyMwsvPCW5TsAxgAWq+w+80NqRIyNAbGYGQYjI3YYGwOhoT/g0aNfIBbroUWL0ejR42vY2X0JIyMWt0oVwNycHbzyz1EC3ABwlEN6OvDhA/D+PRAZyT6jooCYGCA6mn1Kv0dHxyAmZieIPAEsBzA8Jx0TE8DQEDmF3ueFpKkp+y6tYedX265cmX1KC1sAqFQJMDAg3L17E+3adZLRr6PD0lVEZiYzNorIymKGSkpSEpCRkWuUMjLYOUWtkri4XGMXGfkv/vprEKpUGQd9/dFISzNFbGxuep9jYMAMgdQoVKkie1SrBtSsCdSoAVSvDlStWvD/j1Mh4QaAUzBEQHg48OYNO969yy3kw8LYZ3g4q5nnpXJlVgjlLaCktdfc71mIjf0b7do1g6kpK9wrKomJiTA2NlYY9ukTMxpSQ6roU3rExAAfP7L/S17HoZUqsf+HRCJrHCwtgbp1gTp1gHr1mGHhVBi4AajoELFCPTQ0t5CXHm/fskNakIjFrNCoVUu+hmlpKVvA8M2ohOfjR9YqCw8HIiLY97xGOyKC/Z3XO4aFBTMGeY1C3brs08aGG4hyBjcAFYXYWODly9zj6VPgn3+AoCDWzQCwrhSJBKhfnxXulpbsu/SoUye3O4VTfkhNZQYh7/vx/n3uudevcwfSK1dm74KdHWBvn/tu2NnxcYkyCDcA5Y3ERODJE3Y8fgwEBgLPnrGuAYDVzG1sgAYNcg/p39WrC6udo5mkpQGvXgHBwUBIiOzn+/csjlgMWFkBTZsCTZqwz2bN2Dnur05j4QagLPPvv4C/PyvopQX+q1esW8fUNPeH2LhxbmFfpw7/QXKUR1JSrkF4/jz3PXz5krUajI3Z+yc1CM2bAy1a8C5CDYEbgLJCcjLw6BHw4AE7/PxYYQ+w7pqWLdlhb8+a47a2uXPTORx18+kTMwoPHrCuxqdPgXv32PiDWMxanZ06AR07svfWzo5XTASAGwBN5eNH4OpV4MoV4PZt4O+/2ZRDS0ugbVugXTv22aoVmzbJ4ZQFQkOBu3dzj0eP2DTXqlXZ+9y5M+DszFoJvAKjcrgB0BRSUlit/vJl4NIlICCA1YhatwY6dGAFfrt2QO3aQivlcJRHWhrw8CEzBnfuANevs9lKVaoAjo7MGHTrBlhbC620XMINgJC8fw+cPMkOPz+2mMrWlr3wzs5A164Ve248p+JBxMYRpBWhGzfYOEO9ekDv3sCgQYCDA1v0xyk13AComzdvgBMngOPHWdeOoSF7sV1cWKEvkQitkMPRHDIyWMvg4kXg1Ck2q83CAnBzY8bAyYmt4uaUCG4A1EFyMnDwILBjB5u1Y2YG9O3LXuAePfiMCA6nqISEsMrT8eNsgNnMDBg6FPjqKzbDiFMsuAFQJf/8A3h6Avv2se6doUOBkSN5rYXDUQZv3jBDsHMn+621b88MwdChvFJVRLgBUAVXrwJLlgDXrrHBK3d3YMIENrDF4XCUz7VrrLJ18iRzCDh1KjB7NneCVwh8Qxhl8vgx6893cmLOt3x9mauFOXPUX/h36tQJIpFI4TFr1qwCr83KysL8+fPRoEED6OnpwcXFJSds9erVOenUqlVL1bdRpnjz5g369euHhLzuQQEEBATA1dUVZmZmMDY2hrOzM27evFmiPM6ePQsbGxuIS+CTIzY2Flu3boWTkxPMzc2hr6+PBg0aYNSoUXj8+LFcfA8PDxw5ciTf9CZMmABdXV1YWVnhm2++QVrRfXIrna5dgSNHmO+qWbNYd6uVFbBoUa6rE44CiFNqwsOJxowh0tIiat2a6PJloRURdezYkQAoPL755psCr922bRsBoCVLllBsbKzCOM2aNSOJRKIK6UohMTGRrK2tydXVVS35PXr0iKpWrUobN26UOX/nzh3S19enYcOG0fv37ykqKoqmTJlCYrGYzp8/X+T0Q0NDqW/fvtS0aVMyMTEhbW3tYmucNGkSicViWrduHYWHh1NycjLduHGD7OzsSFtbm06ePCmXp5WVFS1atCjfNBMSEmjr1q0EgJYtW1ZsTaoiKYlo1SqiypWJLC2JDh4UWpFGspkbgFJy/DhR1apE9esTHT1KlJ0ttCJGx44dyd/fv0TXjhgxggBQQkJCvnE03QAkJCRQ/fr1ycXFReV5xcfHU61atcjd3V3mfFZWFtnb21PNmjUpJSUl53xmZiY1bNiQateuTWlpaUXKY8SIEbRixQrKyMggiURSYgMwdepUufMBAQEEgBo0aKAwTCQS0ZEjRwpM28DAgHr06FFsTaomKopo6lQikYhoyBCimBihFWkU3ACUhiVL2Is1eTJRYqLQamQpjQHo0aNHoQWMphsAdbJw4UISi8UUFhYmc/7q1asEgGbMmCF3zeLFiwkAeXl5FSmPvAakpAagIPT19UlLS4uyFdRghgwZQrVq1aKMjIx8r7e0tKSWLVsqVZMyuXiRSCIhatiQKDRUaDUaw2Y+BlBCFiwAfv4Z2LgR2L49/92kyiLSDck5hUNE2LFjB9q2bQtLS0uZsCtXrgAAWrVqJXed9Nzly5eLlI8qN4BPTk5GamoqGjduDJEChzwDBgzAu3fvcObMmXzTEIlEyMzMVJnG0uLsDNy/zwaIu3RhLq45ADcAJeDAAWDlSmDXLmD6dKHV5M++ffvQvHlzGBoawtTUFJ07d8bBgweVmsfz58/h6uoKU1NTGBgYwNHRUW6AMzMzE0eOHEH37t1Ro0YN6Ovro0mTJli/fj2ypY7mAfz5558yg9VBQUEYOnQoqlSpknNux44dxY7z+eBkVFQUZs6ciXr16qFSpUqwsLDAwIEDERAQUCwtHz9+xOPHj/Hhwwc0a9ZM4bMBoHCwXPLfir/g4OCSP3wlcezYMQDAwoULFYY3/2+C/fnz59WmSRXUqMFWF1erBvTpw6ZmV3iEboOUNeLiWJ//zJlCKymYjh070pgxY+jBgweUlJREz58/pzFjxuTbJZGXzp07k4GBQYFxmjVrRqampuTo6Eh+fn6UmJhI/v7+1LRpU6pUqRJdu3YtJ663tzcBoOXLl1NMTAxFRUXRhg0bSEtLi+bMmSOXdv/+/QkAOTg40NWrVyk5OZnu3LlD2traFBUVVew4qampOWm/f/+e6tatS9WrV6czZ85QYmIi/f333+Tg4EB6enp069atYmnZt29fzr19Tvfu3QkA3blzRy4sJCSEANCXX35Z4HNWhDK7gCIiIqh69eo0efLkfOPEx8cTAOrcuXO+cerXr092dnZK0aRqXr8mMjYm+uUXoZUIDh8DKC6enkSGhswQlEXatGmTb6EkpW7dumRjY1NgOs2aNSMAdPv2bZnzgYGBBICaNWuWc87b25u6du0ql8bo0aNJR0eH4uPjZc5LC92zZ8/mm39x4uTu5MSPAAAgAElEQVQ1AOPGjSMAdODAAZm44eHhpKurK9ePXVg+v/76KwGgzZs3y4UVZACCg4MJQIn6zZVlAD5+/EjNmzenYcOGUWZmZoFxRSIRWVtb5xveqVMnMjU1LXCcQJNYtIiNCRRy2+UdPgZQXPz82Dz/suqkbfDgwQAAb29vubCYmBj89ttvePPmDaZNm1ZoWnp6emjbtq3MuSZNmsDS0hKPHz9GeHg4AKBPnz64evWq3PXNmjVDRkYGnj59qjD9Nm3aFKqhKHHy8ueff0JLSwt9+vSROV+jRg3Y29vjwYMHePfuXZHzkXYv6ShY2m1mZgaA9bF/jvScNI66SU5ORs+ePWFnZ4cDBw5AuxDvamKxGKmpqfmGu7u7IyEhAT/++CM+fvyobLlKZ8AAth/yy5dCKxEWbgCKSWxs2V7RW7NmTQBAZGSkzPnx48ejSpUq8PDwwNy5czFz5sxC05L2h39OtWrVZPKIj4/Hjz/+iCZNmqBy5co5fejff/89ACAlJUVh+oZF2OigKHGkpKenIz4+HtnZ2TA1NZVbIPfw4UMAQEhISJHz0fvP50BGRoZcWKNGjQBAoUEJCwsDANjY2BRZv7LIzMzEkCFDIJFIsHfv3kILf+k1BQ1Ejx49GsuWLcNvv/0GCwsL9OrVS5mSlY50hbB0q9SKCjcAxaROHbb1XVnl/X+buEoLaSl79uxBfHw8Dh8+jDVr1sDd3b3QtOLj4xWelxb80jz69u2LpUuXYsqUKQgODkZ2djaICGvXrgXAZtKoA11dXZiZmUEsFiMjIwNEpPBwdHQscppSg6roWUjTefDggVyY9Fy3bt1Kciulwt3dHenp6Th69KjMimJra2vcuXNHLn5CQgKIKOdeFbFw4UIsWLAAnp6eiIuLg6+vr0q0K4tnz9hn3brC6hAabgCKyYABbPMKBSvnNYYdO3agZcuWcueJCEePHgXACuXPMTExwZAhQ9CiRQt4eXkVmk9SUpKcC4EnT57g/fv3aNasGWrWrImsrCzcvHkTNWrUwMyZM2FhYZHTaiioS0FVDBw4EJmZmQpdMaxatQp16tQp1nTGxo0bA1Bcy3dwcICdnR28vLxkZiJlZWXh8OHDqF27NlxdXUtwFyVn8eLFePr0KU6dOgVdXd0iXSNtrUjvVREnTpyAlZUVJk+eDNMy0D+6bRtzHlejhtBKBEao0YeySlYWUfv2zOVDERdxqp3t27cTAJo2bRqFhIRQamoqPX/+nEaNGlWkWUDdunUr0kIwQ0ND6tSpE925c4eSkpLynQXk5OREAOjXX3+lqKgoSklJoStXrlCdOnUIAF28eFEmbUWDt59T0jgfPnygL774gurXr09nz56luLg4io6Opq1bt5KBgYHcitfC8snOzqZq1apRx44dFYbfvn2b9PT0aPjw4RQeHk4fP34kd3d3EovF5OvrKxdf+j96+fJlvvdVlEFgRens3r07X/cg0uPzQX0iooMHDxIAOVcRn2vKO/CvyRw/TgQQFTB/oKLAZwGVhGfPiMzMiAYPJvr0SWg18qSlpdGxY8dowIAB9MUXX5Curi6ZmppS165d6WARnKI4OzvnW8D89ttvOYWFRCKhe/fukaOjIxkZGZG+vj45ODiQn5+fzDVRUVHk7u5OtWvXJh0dHapevTqNHz+ePDw8ctJq2bIl3b59W2GhlJeixDl58qRc+KhRo3LCo6Ojafbs2VS/fn3S0dEhCwsL6tGjh4whKko+UhYsWKBwJbCUhw8fkouLC5mYmJCRkRE5OTnJPSMpTk5OZGRkJDcrRzqVVtGxffv2IqXj6upaIgMwZMgQkkgk9KmAl10ikVDz5s3zDdcU/PyIDAyIvvpKaCUaATcAJeXGDSIjIyJn5/LnX8TV1ZVEIpHQMsoMcXFxJJFI5HwBFZfY2FjS19cvcE6+OtMhyvUFdOjQoQLjVa9endq1a1fq/FTJ4cNE+vpEAwcSlZHZqqqGTwMtKZ07A3/9xQaEmzZlKwzLC7Vq1QIR4cOHD0JLKROYmprC29sbXl5e2Lx5c4nSICLMnDkTJiYmWLp0aYm1KCsdAHj58iUGDhyI+fPnY/jw4fnGy8jIQExMjMa6B09MBCZPBoYPZ3tzHD0KlMCbdrmEG4BS0Lw528DawQHo3p0dgYFCqyo90il8K1euRHR0tMBqygYtWrTA/fv3ce7cObn9AIrChw8f8PLlS1y+fBk1SjEyqax0AGDbtm1YtmwZli1blm+c+Ph4rFmzBhkZGRo39ZMIOHYMaNwYOH2a7cW9di3fUF4GgZsg5YaLF4maN2d7AowZQ5RPd3CZYdWqVWRra0u6urrUq1cvoeVwNJBx48aRjo4OWVtb0w8//FDoamJ1cvEiUatWub/HDx+EVqSRbOZbQiqR7Gy2/++PPwJRUazJ+fXXQOvWQivjcMo/CQnA/v3A1q3A338D/fszj71NmwqtTGPhW0IqEy0tYNw4tg3kmjXAgwdAmzbMAOzcCeSz4JXD4ZSCx4/ZZvASCfD99+z39vAh2x+YF/4Fw1sAKubmTVYjOXYM0NdntZJBg9h4wX9eBDgcTjEJDQWOHwe8vJiff1tbNsA7bhwgkHulssgWbgDUxMePrHl67Bhw5w7bQMbVlRkDFxfAwEBohRyOZvPPP6zQP36c1fqrVmUr80eOZBMxFLil4hQMNwBCEBbGmqfHj7OppLq67AXu1o0dzZrxl5nDiY0Frl4FLl9m06yDg4GaNVmhP2gQ+83wGT2lghsAoYmMBE6dYi/4lSuspWBhwVxOOzszg2BlJbRKDkf1pKWxLlNpgf/wIZvK+eWX7LfQuzfQsSMba+MoBW4ANI2XL9nLf+kScP48m9lQsybQsmXu0bkz7+fklH3ev2cTJW7eZPtsPHjAjED9+qzAd3ZmFaGy7H5dw+EGQJNJT2eeR2/fZuMGd+8C4eFsFWOTJkC7dkDbtqzLyM4OqFRJaMUcjmLCw9miSX9/9h7fvctavzo6bEFl27bsfe7cmblc56gFbgDKGm/fMmMgNQgPH7Jak44O0LAhMwzNmrHPpk0BDV2dzymnpKUBT5+yFfFPnrDPx49Z1ybACndpxaVtW9ai5bPhBIMbgLJOZiYbHHvyhP3Qnjxhx5s3LNzcHLC3B2xsgAYN2KeNDWBtzQafOZySEBHB1ruEhLD3LySEbbISGgpkZbFZbfb2rBLStGluxcTcXGjlnDxwA1BeiYvLrYX980/uj/TtWzawpqXFamNSw9CgARtsrlOHHfyHWrHJyADevWMVibdvgRcvct+hkBA2NgUAxsa574+0Bdq0KfDFF3yGThmAG4CKRlqabK0tOJgdoaFAXuefRkZsu7y6dZlByPtZowYbmOZrF8omROx/HRnJCvfPj9evWZ99djaLr6cH1KvHCnhpK1L6aWkp5J1wSgk3AJxc0tJYjU9a63v7NvfvN2/Y+oW8e58bG7Pl99WqsYKgenVmGGrWZN9r1GAtCXNzoBh7t3NKQHY2EB3NNjmPjmYFfFgYK+TDwtjf4eGs6yYyknUdSjE3z2351asna/Dr1OHbJpZjuAHgFJ2sLFaAvH/PPiMiWKGSt5B5/5595tkCFwAbb6hSJdcg5P1etSqb1mpqygyFkREzLmZmuX8bGQlzz+oiM5P5rY+PB5KSco+4OPaZkMAKd2kBn/d7dDSL9zkWFrlGuUYNdlhaMoMtNdy1a5f/Z8vJF24AOKohLo4ZBkUFlvR73gIsKuokkpONQNQ93zQrV841CIaGbOaTkRFbNS1dF2FqysY3DA3ZtFhdXdmuqs//zouxseKNQpKSZFs+UrKzWYEthSi3II6PZ+HJycCnT8wgpqbmFvRZWaxQT0hg6X9uMHNZBn39oTA1bZCvAa1SRf7vatX4tGBOoXADwBGeTZs2YdasWfjuu++wePEqJCWxQlJa+81bG05MZN9TU9k6iZSU3MIUYO4DABYvM5PFy1u4RkefhpZWLwCypWPewvtzCjIaJiayg51mZswgSY2Jvj7rQ5caKy0tZqSkRsvYOLeFY2LCDunf2trJGDDAEcHBwdizZw/c3NxK9oA5HMVs4RvCcAQjOzub5s6dSyKRiFauXKny/K5evUoAyN/fX+V5KYu0tDSaOXMmiUQimjlzZoEbs3M4xYRvCMMRhuzsbLi7u+OPP/7Azp07MXr0aJXnOWjQIERGRuKvv/5SeV7KZv/+/XB3d0fr1q1x+PDhUm/3yOGAbwjDEYKsrCxMnDgR+/btw5EjR9RS+L99+xanT5/GjBkzVJ6XKhg9ejRu3ryJf//9F61atcLt27eFlsQpB3ADwFErGRkZGD58OI4dOwYfHx+19Wtv3rwZ1apVw4ABA9SSnypo3rw5Hj16hNatW6NLly5YtWqV0JI4ZRxuADhqIysrC2PHjoWvry98fX3h7OyslnxTU1Oxc+dOTJ8+HTo6OmrJU1WYmJjg+PHjWLRoERYsWICxY8ciLf8pRBxOgXADwFELRISvv/4ap06dwunTp9G5c2e15b1v3z4kJSVh8uTJastTlWhpaeGnn36Cj48PfHx84OjoiA95l3FzOEWEGwCOWpg5cyb27t2L48ePw9HRUa15b968GaNGjUK1atXUmq+qcXFxwb179xAbG4uWLVvi0aNHQkvilDG4AeConF9//RVbtmzBwYMH4eLiota8r1y5gsDAQEybNk2t+aoLa2tr3Lp1CzY2NujSpQu8vb2FlsQpQ3ADwFEpx44dw/z587FmzRoMGjRI7flv3LgRXbp0QcuWLdWet7owNzfHhQsXMHr0aAwYMIAPDnOKjIKF7xyOcrh16xbGjh2LGTNm4JtvvlF7/q9fv4a3tzcOHTqk9rzVjVgshqenJxo1aoTZs2fjxYsX2Lx5c5kf9OaoFr4QjKMSwsPD0bJlS7Ru3RonT56ElgA7ec+ePRvHjx/HixcvIFbk5KeccvbsWQwfPhxt27bFsWPHYMY3kOYohi8E4yifjIwMDBs2DMbGxvjjjz8EKfwTExOxa9cuzJgxo0IV/gDQu3dvXLt2Dc+ePUOHDh3w8uVLoSVxNBRuADhKZ/bs2Xj06BFOnDgBU1NTQTRs374d2dnZ5WbqZ3H58ssvcffuXejr66Njx44IDAwUWhJHA+EGgKNUvL29sWnTJuzcuRP29vaCaMjKysLmzZsxceLECt39IZFIcP36dTRp0gQODg7w8/MTWhJHw+AGgKM0oqKiMGXKFIwfPx5Dhw4VTMeJEyfw+vXrMuv3R5kYGRnB29sbzs7OcHZ2xsmTJ4WWxNEg+CAwR2n069cPT548wePHj2FiYiKYjg4dOqBGjRo4ceKEYBo0jaysLHz99dfYvXs3fv/9d0yYMEFoSRzh2VKxRsc4KuPAgQM4c+YMrl69Kmjh7+/vj9u3b+PGjRuCadBEtLW1sW3bNlSuXBmTJk1CbGwsZs+eLbQsjsDwFgCn1CQkJMDW1hb9+vWDp6enoFqGDRuGFy9e4P79+4Lq0GTWr1+Pb7/9FnPnzsXKlSuFlsMRDt4C4JSehQsXIj09HUuXLhVUx5s3b3DixAns3btXUB2azjfffJPTEkhISMCmTZsEmarLER5uADilIiAgAJ6entixYweqVq0qqJaNGzeievXqGDJkiKA6ygJjx46FoaEhRo0ahfj4eOzdu7fCrZfg8C4gTinp27cvIiIicO/ePYhEIsF0JCYmonbt2vDw8ICHh4dgOsoaly5dQv/+/dGnTx8cOHCAG4GKBV8JzCk5/v7+OHPmDJYuXSpo4Q+whV9ZWVmYOnWqoDrKGs7Ozjh//jzOnj2LESNGICMjQ2hJHDXCWwCcEtO9e3ekpqYKvsAoIyMD1tbWGDRoENasWSOolrKKn58fevfujR49euDQoUPciVzFgLcAOCXD398fly5dEnzgF2BTUMPDwzFr1iyhpZRZOnXqBB8fH/j6+mLkyJHIzMwUWhJHDXADwCkR69evR4sWLUq1u1dAQABcXV1hZmYGY2NjODs74+bNm8VKg4jwv//9DyNGjECdOnVKrEXK2bNnYWNjUyH7wrt06YKzZ8/i3LlzmDhxIrKzs4WWxFEx3ABwik1kZCS8vLwwc+bMEqdx9+5ddOjQAcbGxnj27BlevXqF+vXro2vXrrhw4UKR0zlz5gyePn2Kb7/9tsRaAODFixfo168f5s+fX6H31+3SpQtOnTqFY8eOYcqUKeA9xOUbPgbAKTZLly7Fxo0b8fbtW+jp6RX7+uzsbDRt2hQxMTF48eIF9PX1ATB3Bfb29khJSUFISAh0dXULTatLly4wMTGBj49PsXXkZeTIkWjatCnmzJmDevXqISIiokJ3g5w+fRqDBw/GtGnTsG7dOqHlcFTDFhCHU0xsbGxo9uzZJb7+6tWrBIBmzJghF7Z48WICQF5eXoWmc/fuXQJA165dK7EWKSkpKTnfJRIJaWtrlzrNss6BAwdIS0uLlixZIrQUjmrYXPE6Ojml4sGDBwgODsbw4cNLnMaVK1cAAK1atZILk567fPlyoXsIr1y5Eq1bt4aDg0OJtUiRtkI4uYwcORJJSUn46quvYGFhga+++kpoSRwlw8cAOMXiyJEjqF+/vlzh/fz5c7i5ucHU1BQGBgZo06YNfHx84OzsDJFIBJFIlLM5y/PnzwEAtWrVkktfIpEAAIKDgwvUERQUhFOnTuW76Ks4ejj5M3XqVCxZsgTTp0/H8ePHhZbDUTK8BcApFl5eXhg+fLjMwq/Q0FC0b98ehoaG8PLyQvv27fHmzRvMmjULgYGB0NXVRVpaWk78uLg4AIChoaFc+kZGRgCA2NjYAnWsXr0a1tbWcHNzkwsrrh5OwSxatAiRkZEYPXo0qlevjk6dOgktiaMshO6E4pQdgoKCCADdvHlT5vyQIUMU9ttHRkaSgYEB6erqypzv3r07AaA7d+7I5REcHEwAqGXLlvnqiIiIID09Pfr9998VhhdXz+fwMQB5srKyaODAgWRqakqBgYFCy+Eoh828C4hTZC5evAhjY2O0bt1a5ryvry8AoGfPnjLnLSws0KhRI7l0pNs0Jicny4VJzxW0leOaNWtgZmaGMWPGKAwvrh5O4WhpaWH//v2wt7dH3759K/RU2fIENwCcInPx4kV069ZNxk1Aeno6EhMToaenl9N9k5fKlSvLnZMWwu/evZMLCwsLAwDY2Ngo1BAdHQ1PT0/MmTNH4RTUkujhFA19fX2cPn0aOjo6GDBgAO9GKwdwA8ApEkSE69evo1u3bjLndXV1YWxsjLS0NCQlJcldFxkZKXdOunr4wYMHcmHSc5/nI2XdunWoVKkS3N3dFYaXRA+n6FSpUgU+Pj549uwZxo0bxxeKlXG4AeAUiaCgIMTFxaFdu3ZyYS4uLgByu16kREREKJzN4+DgADs7O3h5ecnUIrOysnD48GHUrl0brq6uctfFx8dj06ZNmD17tsLafUn1cIpHw4YNcfToUZw4cQIrVqwQWg6nNAg9CsEpG/zxxx9UqVIlSktLkwsLDQ0lc3NzkkgkdOHCBUpMTKQnT55Qr169qG7dugoHXW/fvk16eno0fPhwCg8Pp48fP5K7uzuJxWLy9fVVqGHJkiVkampKsbGxBWotiZ688EHgorFx40bS0tKiEydOCC2FUzI2cwPAKRIzZsyg1q1b5xseFBREbm5uZGJiQgYGBtShQwe6fv06devWLd8C9+HDh+Ti4kImJiZkZGRETk5O5OfnpzBuUlISVa1alX766aci6S2uHm9vbwKg8Ni+fXuR8qyIfPXVV2RkZET//POP0FI4xWcz9wXEKRIODg6wtbXF1q1bi3Wds7Mz/Pz8Sj1guGrVKvzyyy949epVqbaeVJYeDiMjIwNOTk6IjIyEv78/TExMhJbEKTp8PwBO0Xj+/DlsbW0FyTstLQ3r16/H//3f/wm+7zBHFh0dHRw7dgyJiYl8ULgMwg0Ap1BiYmIQGRkp2Bz6rVu3Ij4+vtQunzmqoUaNGjhw4AB8fHy459AyBjcAnEKR+u4pjgE4fPgwRCIRLl++jPT09BL73klPT8fq1avx1VdfoVq1asW+Xtl6OIpxdHTE0qVLMW/evGJv6sMRDj4GwCmU/fv3Y/LkyUhJSYGWlnrrDFu2bMF3332HFy9ewNLSUq15c4oHEaFfv3548v/snXdYFFfbxu+FhaWDCCItCGJDY+89ipUY0VijRn3V12i+xJLEYE1iYomaGDV2Y0yzRF81orHXYFRsGDuoqEjvve/z/XGywLKFtuxsOb/rmmuGmTNz7llmzj2n372LsLAwtb25OToBrwPgVMyrV6/g5uam9cQ/Ly8PK1euxNSpU3nirweIRCL8+OOPKCgowLRp04SWw6kE3AA4FRIdHV0yTLM22bRpE5KSklQO+czRPZycnPDTTz/hf//7H37++Weh5XAqgBsAp0KEMICsrCx8/fXXmDVrliDmw6k+/fr1w5w5c/D+++/zntc6DjcAToUkJibWqAK2OqxZswb5+fn45JNPtBovRzMsX74cvr6+mDhxIoqLi4WWw1EBNwBOhaSmpsLR0VFr8SUlJWHt2rWYN2+eVuPlaA6JRILffvsNt2/f5k1DdRhuAJwKSUtLg729vdbiW758OSQSCT744AOtxcnRPH5+fli0aBEWL16MiIgIoeVwlMANgFMhqampWmvSFx0djS1btmDJkiWwtbXVSpyc2iMoKAjNmjXDtGnTeC9hHYQbAEctRITc3Fyl8/fWBp9//jnq1avHmxEaCGKxGDt37sTff/+NrVu3Ci2HUw5uABy1FBYWgohgbm5e63FFRERg165d+OKLLyCRSGo9Po52aNWqFT766CN8+umnJTO+cXQDbgActRQUFACARg0gJSUFI0aMwNOnT+X2L1q0CA0bNsS4ceM0FhdHN/jss8/g5OSEefPmCS2FUwY+FARHjp07dyIpKQnZ2dnIyclBUlISdu/ejfbt28PMzAwpKSnIyckBAISFhamdmUsVFy9eRO/evSEWizFr1iwsWrQIL1++RJs2bXDgwAEMGzZM07fF0QH++OMPBAYG4sKFC+jVq5fQcjjAJm4AHDnefvttHDp0qOSLXyqVoqioSK4CTyQSoXv37rh06VK14pBN61hYWAixWAxra2u4u7vD0tIS169fh0gk0si9cHSPwYMHIyoqCrdv34ZYLBZajrHDxwLiyDN9+nQQEfLz85Gfn19SB1AWU1PTGn2l37lzp2S7qKgI6enpePToEWJjY3HgwIFqX5ej+6xfvx4RERHYtm2b0FI44HUAnHL069cPXl5easMUFRXhzTffrHYcN2/eRGFhodw+qVSKuLg4jBo1Cr169UJYWFi1r8/RXXx9fTFr1iwsXrwYKSkpQssxergBcOQQiUSYMWOG2uy5t7c3GjVqVK3rS6XSkvkFlB0DgMuXL6Ndu3bYvHlzteLg6DaLFi2CqakpVq1aJbQUo4cbAEeBKVOmqCyHNzc3x/Dhw6t97cjISOTm5qoNIxtXfvLkydWOh6O72NraIigoCOvXr+fNQgWGGwBHAScnJwQGBsLMzEzhWEFBQY2Kf+7cuaO2klckEuH999/H//73P1hYWFQ7Ho5uM3PmTDg5OWHFihVCSzFquAFwlDJjxgyFcnoAsLa2Rrdu3ap93bt37yo1FoAl/itWrMD69eu1PvkMR7tYWFhg8eLF2LZtm0J/EI724G8ZRylvvPEGfH195b7WxWIxAgICVCbgleHOnTsoKiqS22diYgIzMzPs2bMHn376abWvzdEvJk+eDG9vbyxdulRoKUYLNwCOSmbMmAFTU9OSv6VSKYYMGVKja968ebOkshdgpmJjY4OzZ89i9OjRNbo2R78Qi8VYvHgxdu/ejefPnwstxyjhHcE4KklOToarq2tJUZCJiQni4+Ph5ORUrevl5OTAxsampF+BmZkZXFxccPr0aTRt2lRjujn6Q1FREXx9fREYGMjnDdA+vCMYRzV169bFqFGjYGZmBpFIhA4dOlQ78QeAe/fuySX+zZs3x40bN3jib8SIxWLMnj0bO3bsQHJystByjA5uABy1yCqDRSIRAgMDa3Ste/fuAWA5iX79+iEkJAQuLi6akMnRY6ZNmwYLCws+XLQA8ME4jIDMTKCoiC2ZmfL7AIAISEtTdXY3eHg0watXj2FuPgT79ysPZWEBWFqq1mBhAZw9excAEBg4DV99tRHx8aYQiwHZvC+2tgAfHsb4sLa2xn//+1+sW7cOc+fO5c1/tQivA9ABpFIgNZUlwmlpbDsrC8jNZQl1ZibbzsoCMjLYdnY2kJ7OtnNy2LZUqjyxrznfA1gD4HkNr+P/7xKkNpQyU7CyYgZjbw9YW7NtOzvAxoZt29rKb8v+rlMHcHBgayurGsrn1BqxsbFo0KABduzYgQkTJggtx1jgo4FqkuJiICkJSExk67g4ti1L3MuvZdsZGcqvZ2bGEjFbW5awld+2s2Nf1rJtU1OWyEkkgIkJSywB9ftk2Niw+JSRkZGOjRtXYNWqlSrvvWyOQtXx8+dPoUeP/gBKDSs/nxlYRfuysoC8PPZblTVHVdvKMDcvNQMHB/ntOnXY4uQEODuztYsLUK8eMxxO7TNy5EgkJCTg4sWLQksxFrgBVAQREB8PREez5dUrICGBJezx8WwtS/CTklh4GSYmLDFxdFSf8Cg7pmvFIdnZ2VqbFlITyAyhvNmqM+KUFPY/zM6Wv5alJfs/uriUmoOzM1C/Pls8PQFXV7ZWVwzGUc/JkycxcOBAPHjwAM2aNRNajjFg3AZABMTEAJGRLGGPiQGiotg6Opptx8YCZTvE1q1bmhDUq8eW8l+MTk6liQQf2l7/yMlhRlDe4GU5OlkuLzaWhfl30jQAzOzd3JgZuLkBHh6Auzvb9vICfHx4UZQqpFIpfHx8MGrUKD5QnHYwfAPIy2MJ+rNnisujR/Jfe3XqsBfU1ZW9sLK1bJ+nJ1+2li8AACAASURBVCtq4XDKkprKnrHY2NL1s2eK+2TInjNly2uv6VbOT9ssXboUGzZswKtXr/i80LWPYRhAURF74R48YIn6w4dsefKEvZwAK45xdwe8vdni4yO/Xb8+C8Ph1AbZ2cDz5+w5jYxkS9ntrCwWTixmJtCkCeDnBzRtCjRrxhZHR0FvQSu8evUKDRo0wN69ezFixAih5Rg6+mUARUUsgf/nH/nE/skTlg0XiVg2W/byNGpUmtB7eclXenI4ukRCQqkpyHKnDx8Cjx+XmoOzM9C8OXu+mzVjz3ibNqy40ZAICAhAcXExTpw4IbQUQ0d3DaCwEAgPB27eLF1u32bls2ZmrDjGz4+9ED4+bLt1a9aahcMxJFJTgfv32UePbC0zCoAVT7Zrx94FPz+27eenv/VPBw8exMiRIxEVFQU3Nzeh5RgyumEAUilw7x7w11/A1assoX/0iDWrtLNjCXubNmxp3Zo93DUYkJLDMQgSEti7UnZ58oQ1bnB0BNq2Bdq3B7p1Y0udOkIrrhz5+flwcXHB0qVL8eGHHwotx5ARxgByc4Hr14GQEODyZbakp7PEvksX9uDKEvyGDfX3S4bD0TaZmUBYWKkhhIayoiSRiH04de/OzKBHD1Ysqqu8++67ePbsGUJCQoSWYshoxwCkUlaEc/w4cPIkcOMGK7N3d2cPouyBbNGCdWbicDiaIzmZfWTJPrhk75+HB/DGG8CgQUD//qyJs65w9OhRvPXWW4iMjISXLjuVflN7BpCSApw6xRL9EydYdtXDgz1sPXuyL5EGDWojZg6Ho46yOfAzZ9haKgU6dgQCAtg72qaNsDnvwsJC1K9fHwsXLsTcuXOFE2LYaNYAUlKAffuAPXuAv/9mD1D37sDAgeyhatlSUzFxOBxNkZEBnD5d+rEWHc2aRQ8bBowfz4plhTCDyZMn4+HDh7h69ar2IzcOam4A+fnAn38CP//M1mZm7MEJDAT8/UvHnuFwOLoPEXDnDnuX9+xhjTN8fYFx45gZ+PpqT8vx48cxePBgPHnyBA0bNtRexMZD9Q0gPBzYsAHYvZuNpdKnDzBhAjB8OG+KyeEYCmFhwC+/MDOIi2O5gRkzgFGj2OB6tUlhYSFcXFywePFizJkzp3YjM06qPiPYtWvAW2+xjijHjwOffgq8fMmykO++K2ziX1hYiLVr16Jdu3awtbVFvXr1MGjQIAQHB0OdzxUXF2P+/Plo1KgRLCwsMGjQILnjNjY2EIlEShcLCwu0bNkSGzdulIujRYsWCmHHjBlTctzf31/uWPv27at1TnlevHiBt956CxnlhhgNCwtDQEAAHBwcYGtrC39/f1y+fLnKvzEA/Pnnn2jcuDHEasYsCAoKwr59+1Qenzx5MiQSCby9vTFr1izk5eVVKm5V91dZXero3r27yv/z7Nmz5cJu2bJFZVjZUv45qorOin4/bdG6NfDNN2xcrD//ZP1v/vMf1rly1SrFgfM0iZmZGfr374/jx4/XXiTGDlWS+/eJhgwhAoi6diU6dIiouLiyZ9c+WVlZ1L17d2rZsiVdvHiRcnJy6MWLFzRixAgCQHfv3lV57tatWwkALV26lFJTU5WGuX37NgGgoUOHluzLz8+n27dvU7du3QgAffLJJ3LnxMXFUd26dQkA/frrrwrXPHbsGDVq1Iiys7NrdE5ZjU5OTrRhwwa5/VevXiVLS0saPXo0xcTEUGJiIk2bNo3EYjGdPHlS5e9SnidPntCQIUOoZcuWZGdnR6ampmrDent706JFi1SGycjIoC1bthAAWrZsWYXxq7q/quhSh+z/qGyZNWuWXNjNmzerDCtbli5dWm2dlfn9hOLlS6J584hsbYlcXIjWrycqLKyduHbt2kUSiYQyMzNrJwLjZmOFBpCbSzR/PpGZGVGbNkR//qkNXVVnxowZZGdnR3FxcXL7s7KySCKRqDWAsWPHEgDKyMhQGUaZAch4+fIlmZiYkFgspuTkZLljv/32GwGgunXrymlLSUkhT09Punz5ssL1qnNOeno6eXh40PTp0+X2FxcXU/PmzcnV1ZVycnJK9hcVFVGTJk3I09OT8vLyVN53WcaOHUsrVqygwsJCcnd3rzChDQsLI5FIRPv27VMbzsrKivr37682jKr7q44uVXTr1o2uX79eqbCbN29W+iwQEYWHh5NEIqHY2Nga6azs7ycUCQlEH31EJJEQtWpFdPWq5uOIjY0lkUhEwcHBmr84R70BPH1K1LYtkb090YYNREVF2tJVNeLi4sjU1JRmzJhRrfP79+9f4cuozgCIiNzd3QkAnTt3TuHYW2+9RQDo7bffLtk3btw4mjdvnsr4qnrOwoULSSwWU3R0tNz+8+fPEwD64IMPFM75/PPPCQAdOHBApY6ylDWQyia0I0eOJA8PDypU84no5uZG7dq1U3sdVfdXXV3KqIoBnD59mtasWaP02AcffECjR4/WiM7K/H5C8/gxkb8/+0hcs4ZIKtXs9du2bUszZ87U7EU5ROoM4PZtImdnotatiSIitKmp6mzbto0A0G+//Vat8/v27VtjA3BzcyMA9Pfffysci4mJoTp16hAA2r9/Px06dIiaN2+u9su7KudIpVJycXGhbt26KRxbvHgxAaCffvpJ4djRo0cJQLWMs7IJ2O7duwkAHT58WO21WrVqpfK4uvurri5lVMUAVJGRkUF2dnZ08eJFteE0+fvpAlIp0XffMROYNk2zxcMLFy4kb29vzV2QI2Oj0krgqCigXz/Wbj8kRLtNv6rDrVu3AAB16tTBRx99BE9PT5ibm8PLywsffvghUlJSajX+ly9fIjY2FnZ2dmjevLnCcVdXV6xduxYA8P777+P//u//8NNPP6kd77wq59y5cwfx8fFo1aqVwrFHjx4BADw8PBSOubu7AwDCw8MrcZfVo3Xr1gDYbE/VRd39aZpffvkFrVu3hrW1Nezt7dGjRw/s3r270uf/+OOPeO2119CzZ0+N6NHE76cNRCJg1izgwAHWJHzBAs1de9CgQYiMjMTjx481d1EOAECpAUyezGa3OnJEP+ZDjf13to3//Oc/iI+Px8WLF5GQkIAvv/wSO3fuRJcuXZCenq7y/IKCgmpNPlFYWIiwsDC88847MDMzw/fffw87FTPGTJw4EYMHD0ZCQgJ8fX3Rrl27Cq9f2XPu3bsHQHkin5aWBgBKp3O0+bfJVqps0oRaQGYyMo3KkEgkKCw77Vo51N2fpklNTcXOnTuRkJCA0NBQeHt7Y9y4cZUalIyIsHHjRsycOVNjeirz++kSb70FbN0KrF4NXLqkmWt27twZderU0XkT1EcUDOD6deDsWWDLFv2Zuk7WhNDS0hK7du2Cj48PHBwc8O6772L+/PkIDw/HN998o/L8ly9fVjpx+eOPP0qa+Zmbm6NNmzaoV68eHjx4gAkTJqg9t1GjRgCAixcv4o8//qhUfJU5R2aA9lXsdUf/NlsV1WI3Tzs7O4hEohKNynBzc0N0dDSKVMwqX937qyohISH4+eef0bZtW1hbW6NJkyb4+eef0bFjR2zYsAHXrl1Te/7x48cRGxtb4XNQFSrz++kaEyeyMYa+/loz1zM1NUX37t1xSVOOwilBwQDOnmVj9HTvLoCaaiL7uvX391doWz1kyBAAyrPQKSkpWL16NV68eFHpr7ahQ4eCiEBEePXqFUaPHo1Dhw5h27Ztas/766+/cPDgQXz77bcAgPfee6/CL+/KniMzQDMlY2Q7ODgAYJO6l0e2TxamthCLxcjNzVV5fPr06cjIyMCSJUuQlJSkcFzd/WkD2cxUwcHBasOtX78e7777bknOSlNU9PvpIhMmAOfOsTGGNEGPHj1w6dIltf15OFVHwQCSkljxjz7R4N9R5eoqGc6wXr16AIDExES5/ZMmTULdunURFBSEefPmVWvccXd3d+zatQsNGzbE6tWrcePGDaXhsrKyMGnSJGzbtg1z5szBoEGDEBcXh1mzZqm8dlXOsbCwAAClxShNmzYFwKbaK090dDQAoHHjxhXfbA0oKiqCpaWlyuPjx4/HsmXLsHr1ajg7O2PgwIFyx9XdnzZwdXUFACQkJKgMEx4ejlOnTmm0+EdGRb+fLlK/PpuPWzabWU3p0aMHEhMTERERoZkLcgAoMYCGDdk0dJXsmKkTdP83u6Ismyx7aV3KudquXbuQnp6OvXv34ttvv8X06dOrFbeFhQWWL18OIkJQUJDSMB999BH8/f1LEratW7fCzs4Ov/zyC44ePVrjc2QJlLJ6jjfeeAMAcPPmTYVjsn19+/atzK1Wi4yMDBBRiUZlLFy4EAsWLMDmzZuRlpamMBWguvvTBjExMQBKPyaUsX79evTs2RN+fn4ajbsyv58uEhYG1KvH5vjQBO3atYO1tTUvBtI05dsFxcWxjh3lOlvqNHl5eeTu7k4uLi6Um5srd+yrr74iALRy5UqV53fo0IHq1KmjNg51zUClUim1adOGANCpU6fkjp04cYK8vb0VOpnJmq66ubkp9D6u6jkybcraShcXF5Ofnx+5ubnJ/TZFRUXUrFkz8vT0VPjNKkNlmzE+ePCgwqamTZs2VdvMT939VVdXebZv305t27ZV2C+VSqldu3YEgK6q6OmUnp5Otra29Pvvv1c6Pk3+frpGZiaRlxfR7NmavW6fPn3o3Xff1exFjRvl/QAWLSKysiK6eVPbeqrP8ePHSSwW09ChQyk8PJxSU1Pp559/Jmtra+rUqZNcJ5zyaKIfwLFjxwgAtW3blqT/9oRJTU0lT09POn/+vNJz/P39CQBNmjSpZF91zpFKpVSvXj2V7eSvXLlCFhYWNGbMGIqNjaWkpCSaPn06icViOnHihEL4cePGEQB69uyZ0usRVb0d+6FDh9Req6J+AOruryq6IiMjycTEhADQzTIP+Pbt20tMJiIignJzc+nRo0clv4WyjnQy1q5dS66urlXqrKXJ30+XKC4meucdonr1iGJiNHvtzz77jPcH0CzKDaCwkKh/fyJHR6IrV7Stqfr8/fffNGDAALK3tydzc3Nq2rQpff7552oTfyKWqKp7Ga2trRXGeVHW07N79+4qx4UpaxypqakVjiNT2XPWrl1LREQLFixQ2VOWiOjWrVs0aNAgsrOzIxsbG+rTpw+FhIQoDdunTx+ysbGhonJdv4ODg1Vq3b59u9JrjRw5ktzd3amgoEDl7+vu7k6tW7dWebyi+6uKLpkBiEQi+ueff0r25+Xl0f79+2nYsGHUsGFDkkgkZG9vT71796bdu3er1CWVSsnX15eWLFmiVn9VdcqozO+nK+TnE02cSGRhQXT6tOavf+bMGQJAUVFRmr+4caK6J3BuLtGbbxKZmxOtW6f57t26REBAAIlEIqFl1Ii0tDRyd3dXOlZOVUhNTSVLS0uaOnVqjTXJxrLZs2eP2nAuLi7UuXNntWE0dX/6RGV/P13g2TOiTp2IbGyIlGQqNUJmZiaZmJjoTW5ID1A/FlBxMdGXXxKJxUTduhHduaMtXdpl+vTpBEBhIDl949atW1S3bl36/vvvq3W+VCqlCRMmkIuLi8JAZlXl6dOn5OPjQwsWLFAbrqCggMzMzGjEiBEVXrOm96dPVPb3E5r8fKIVK1iRccuWRI8e1W58jRo1qlRui1MpKh4NlIgoLIyoSxciExOikSOJwsNrW5d2OXToEAGg2bNnU1JSktByakRkZCQFBARQenp6lc+NjY2lbt260b1792qsY968eRV+uaalpdHKlSsJAO3YsaNS163J/ekTlfn9hKS4mOj334kaNiSytCT67DOiSg4qWyNGjx5NQ4YMqf2IjIPKGQAR+4fv3k3UpAnLEYwaVTvDvwrF119/Tc2aNSOJREIDBw4UWo7BM3HiRDIzMyNfX19avHixQn0DRzfJyCD69luiBg1KB357+VJ78a9cuZI8PDy0F6Fhs7HKU0IWFQH79wPffgvcuAG0bct6/Y0dq38dyDgcTsVIpcCFC2xqyP/9j80bPHkyMHs24OOjXS2nTp3CgAEDEBcXp9C3h1NlajYpfEgI8OOP7KHIzgb692eTRwcG6s84QhwORzn37gG//gr89hvw6hXQvj2bGP7dd4E6dYTRlJycDCcnJ5w8eRL9+/cXRoThUPU5gcvSvTvwww9AbCx7UExMgEmTWDfwESPYsX87UXI4HB2nqAi4eBEICgJef50t+/axwd0ePmQDRc6aJVziD7DhXjw9PUuGgOfUjBrlAJSRmMjGBD96FDh/ng0p0bo1MGgQW7p0AUxNNRkjh8OpLnFxwPHjbDl9GkhLAxo3BgYPBoYPZx95tThYbLV488034eDggF9//VVoKfpOzYqAKiI3l5Ud/vkne8CePgUcHNhD1a0bW7dvD/w71heHw6llXr4E/voL+Ptvtr53j71/vXqxRH/wYDYemC7z0Ucf4dKlS7h+/brQUvSd2jWA8oSHAydPsrqDkBBWPCSRMBOQmULXroCSQT05HE4VKS5mCXxICHD5MkvwX70CzMzYO9e1K9CnD9C7t37V2W3btg0ff/wx0tPTa3UuCyNAuwZQnpgY9mDKHtDbt1mLA1dXoF270qV5c+23NuBw9ImiIjaK782bpUtYGGucYWMDdO5cmuvu1g3Qs9Gl5bh48SJ69+6NmJgYvRslVccQ1gDKk5wMXLsG3LrFzOD2bSAykh1zcQHatGHNTlu3Bpo2ZWWV1ZjJkcPRa+LiWKXs/ful78r9+0BhIZvCtVUr9q60aQN06AC0aMEaaBgKcXFxcHV1xfnz59G7d2+h5egzumUAykhLKzUD2cP++DHL3pqaAt7eQLNmzBCaNgX8/Ni6lie54nBqleJi9vHz8CFbHj8GHjwAHj1i7wQAODqWJvSypXFj42hkUadOHaxcubLa83hwAOiDASijoIC9EI8eseXhQ7Z+/BjIyWFh6tdnL4O3N1t8fErXbm7C6udwAPasRkYCz57Jr58+BSIi2HMOAJ6e8h84TZqwj5769YXVLyQdO3ZE9+7dS6ZL5VSLTeKKw+ge5ual7ZTLQgQ8f176tfT0KXuprl5l+/PzWTgLC0Vj8PAA3N3Z4ubG4uBwakJyMqvniopifWWeP5dP6OPiSsPWq1f6LAYGlibyTZoAtraC3YLO0qRJE4SHhwstQ+/RSwNQhUhUmrCXm1YWREB0NHvxyr6EYWHAoUPsZSwuLg3v4sIqo2XG4ObGvsRcXdm2kxPg7MxaVHCMi4wM9rwkJrIEvmwiL1u/eiU/raqtLeDlxZ7Njh2B0aPlP0CsrYW7H33Ey8sLd+7cEVqG3mNQBqAOkYgl5h4eQI8eiseLi4H4ePkXOSaGmUZ4OOvPEBVVWsQkw9GRfb3JDKF+fbaWLfXrs56TDg5s0dQcqRzNUFjIytRTU9mSmAgkJQEJCex5kP0tS/ATE0tzkgCrXHVxKf1IaNmSfXyU/3CwsRHuHg0RT09PREVFCS1D7zEaA6gIU1P2slZUP5CezgwiKYklBrKEQZZoPHwIXLpUelwqVYxHZgYODswcyhqEbJ+1NWuq5+DA1paWbL+lJSvCErI7vi6Ql8c6GqamsnVeXul2bi5L1LOy2FqWwMu2y/6dna14bWtrZt4uLqUm3rIlM3qZscuOubjwXKAQeHh4IC0tDZmZmbDlZWTVhhtAFbG3Z0tlkEqZEcgSm/KJUNkvz+fP5ffl5CjmNsojMwYHB9aRRyIBxOLSMmMbG5Y4VbRPhrW16roPU1PVuZfCQpbYqiIjQ754rWz4zEzWhr38vpycBIhE9Ur2paXJJ+7qmi6IROw3sbGRN1VHR1bkIvu7vOk6OLBEXZ86RRkrnp6eAIBXr16hWbNmAqvRX7gB1CImJuyrsV696l+jbMJX/gs3J4dtp6ezL9mCArbIvmrT05kJ5eSw3AhQmhiXDScjNVUx/uLihyguvgap9F3k5qpuTK4uRyLLtcgoayYy0ym7z8oqHGfPtkOvXtvg7z8WADtmacnC29uzbSsr1TkkjmHDDUAzcAPQcWRfqEKxfPkhbNmyBS9fTtJirI3x6acz8c03EzBtmilGjRqlxbg5+kCdOnVgY2PD6wFqCDcAjlquX7+Ojh07aj3elStXIisrCxMmTIC1tTUCAgK0roGj23h4eHADqCEG1EGcUxuEhoYKYgAikQjff/89Jk6ciJEjR+L8+fNa18DRbVxdXRFXtjMFp8pwA+CoJCoqCjExMYIYAMBMYPPmzRg2bBjefPNNXLp0SRAdHN3EyckJycnJQsvQa7gBcFQSGhoKExMTtG3bVjANpqam+PnnnxEQEIAhQ4bwMeA5JdStWxdJSUlCy9BruAFwVHL9+nX4+fnBTuDea6ampvjll1/QtWtXDBo0CPfu3RNUD0c34DmAmsMNgKOSa9euCVb8Ux6JRIKDBw+iRYsWGDBgACJl44RzjBaeA6g53AA4SpFKpbh165bOGAAAWFpa4siRI6hfvz769evHKwCNHJ4DqDncADhKefDgATIyMnTKAADAzs4OJ06cgFgsRv/+/ZGqrPcaxyioW7cu8vPzkaWuGzpHLdwAOEoJDQ2FhYUFWrRoIbQUBZydnXH69GmkpaUhICAAORWNmcExSOr+O3k4zwVUH24AHKVcv34d7dq1g5mOjnTm6emJ48eP4/HjxxgzZgyKioqElsTRMjb/DrGarWxEP06l4AbAUcq1a9fQqVMnoWWopXnz5vjzzz9x/vx5TJ48GXo4uR2nBlj9O2ofN4Dqww2Ao0Bubi7u3buHDh06CC2lQjp16oRDhw5h//79mDVrltByOFrE+t9ZdLgBVB9uABwFbt26hcLCQp2rAFaFv78/fvjhB2zcuBHr1q0TWg5HS8hyALwOqPrwweA4CoSGhqJu3brw9vYWWkqlGTduHKKjozF37lx4enpi+PDhQkvi1DJWVlYQiUQ8B1ADuAFwFAgNDUWnTp0gEomEllIl5s2bh6ioKIwfPx5nzpxB165dhZbEqUVEIhEsLCx4DqAG8CIgjgJCjQCqCb777jsMGDAAQ4cORUREhNByOLWMtbU1zwHUAG4AHDmSk5MRGRmptwZgamqK3bt3w9fXF4MGDUJCQoLQkji1iIWFBfLz84WWobdwA+DIce3aNQDQixZAqpANGSESiTBkyBBeRGDAmJiYoLjshNOcKsENgCNHaGgofHx84OTkJLSUGuHs7IwjR44gIiICkyZNglQqFVoSpxYwMTHh/9sawA2AI4esAtgQaNasGQ4fPowjR44gKChIaDmcWoAbQM3gBsApgYhw/fp1vS7+KU/Pnj2xc+dOrFmzBtu3bxdaDkfDmJqa8iKgGsCbgXJKePbsGZKSkvS2AlgV77zzDh4/foz3338fjRo1Qu/evYWWxNEQPAdQM3gOgFNCaGgozMzM0KZNG6GlaJzPP/8cw4YNw4gRI/Ds2TOh5XA0BM8B1AxuAJwSrl+/jtdffx2WlpbVvkZYWBgCAgLg4OAAW1tb+Pv74/LlyxpUWT1EIhF++OEHuLu7Y/jw4bztuIFQnRxAamoqtmzZgj59+sDR0RGWlpZo1KgRxo0bhzt37tSSUt2EGwCnhJqOAHrt2jV07doVtra2ePjwISIjI+Hj44PevXvj1KlTGlRaPWxsbHDkyBHExsZiwoQJvOjAACgqKoJYXLWS7E8++QQffPABhg4digcPHiA5ORk7d+5EWFgY2rVrh8OHD9eSWh2EOBwiKigoIEtLS9q5c2e1zi8uLqbmzZuTq6sr5eTklOwvKiqiJk2akKenJ+Xl5WlKbo0ICQkhc3Nz+uyzz4SWwqkhPj4+tGLFiiqdM2XKFPrvf/+rsD8sLIwAUKNGjTQlT9fZyHMAHADA3bt3kZubW+0K4EuXLuH+/fsYMWKEXBGSqakpxo4di6ioKBw9elRTcmtEt27dsGXLFixduhT79u0TWg6nBhQWFlZ50qIdO3Zg69atCvtbtWoFS0tLPH361GjmluAGwAHAKoBtbW3RtGnTap1/7tw5AED79u0Vjsn2nT17tvoCNczkyZMxc+ZMTJ48GTdu3BBaDqeaFBQUwNzcXCPXys7ORm5uLlq0aKF3AyFWF24AHADMADp06ABTU9OSfY8ePUJgYCDs7e1hZWWFjh074ujRo/D394dIJIJIJMLUqVNLwgKAh4eHwrXd3d0BAOHh4Vq4k8rz3XffoUuXLnj77beRmJgotBxONSgoKICZmVmVnlVV7N+/HwCwcOFCbUjXCXg/AA4AZgBDhgwp+fvJkyfo0qULrK2tceDAAXTp0gUvXrzA7Nmz8c8//0AikSAvL68kfFpaGoDSWZrKIpu7NTU1tZbvomqIxWLs378f7dq1w7hx43DixAmYmPBvIn2isLAQaWlpVXpWlREfH4+goCBMnToVo0aN0pJ64eFPOweZmZl49OiRXA/gBQsWIC0tDevWrUO/fv1gY2OD5s2bY/fu3VVuQikrT9XFbLWjoyMOHz6MkJAQLF26VGg5nCpSUFCAQ4cO1ehZTU5OxsCBA9G7d29s2bJFC6p1B24AHNy4cQPFxcVyFcAnTpwAAAwYMEAurLOzs9J6AgcHBwDK52eV7ZOF0TVatWqFb775Bl9++WXJfXN0H6lUisLCQty9exdA5Z/VsmRnZ2PAgAHw8/PDb7/9JlcEagxwA+AgNDQUrq6uJeX3+fn5yMzMhIWFRUnxTVnq1KmjsE/2or169UrhWHR0NACgcePGmpStUWbMmIHx48dj3LhxeP78udByOJUgKysLRITc3NwqPasyioqKMHLkSLi7u+Onn34yusQf4AbAATOAzp07l/wtkUhga2uLvLw8ZGVlKYRXNsnKG2+8AQC4efOmwjHZvr59+2pKcq2wadMmuLq6YsyYMSgoKBBaDqcCZM+mlZVVlZ5VGdOnT0d+fj5+//13uc5kvr6+uHr1quYF6yDcADglLYDKMmjQIABQKBKJi4tT2pqnmfC6WQAAIABJREFUV69e8PPzw4EDB+Qq3IqLi7F37154enoiICCgFtRrDmtraxw8eBAPHz7Ep59+KrQcTgVkZmYCALp37w6g8s8qwMaGun//Pv744w9IJJLaFarLCNwTjSMwMTExBIDOnDkjt//Jkyfk6OhI7u7udOrUKcrMzKS7d+/SwIEDycvLiyQSicK1rly5QhYWFjRmzBiKjY2lpKQkmj59OonFYjpx4oS2bqnG7N27l0QiEf3+++9CS+Go4fr16wSALly4UKVn9ccffyQAapcrV64IdFdaZSM3ACPn0KFDJBKJKDU1VeHY48ePKTAwkOzs7MjKyoq6du1KFy9epL59+yo1ACKiW7du0aBBg8jOzo5sbGyoT58+FBISUtu3oXHef/99srGxoYcPHwothaOC8+fPEwBKTEys0rMaEBDADYCxUURkJH2eOUpZsGABDh8+jAcPHlT6HH9/f4SEhFTYtlqfyc/PR48ePZCfn49r167BwsJCaEmccgQHB+Ott95CXl6eymIcY3hWa8AmXgdg5BjSFJCaRCKR4Pfff8eLFy8wf/58oeVwlJCZmQkzMzPjLsOvIdwAjBgiws2bNw1qCkhN0qBBA2zYsAHr1q3D8ePHhZbDKUdycjIcHR2FlqHXcAMwYh49eoS0tLRKjwC6d+9eiEQinD17Fvn5+ZUaX0XfmTBhAkaPHo2pU6ciOTlZaDmcMiQlJcHJyUnpMWN8VqsDrwMwYn766Se89957SE9P19iIioZIWloaWrVqhXbt2uHgwYNCy+H8y/vvv48HDx7g/PnzQkvRV3gdgDETGhqKNm3a8MS/AhwcHPDLL7/gjz/+wK5du4SWw/kXdTkATuXgBmDEhIaGVnsCGGOjZ8+emDNnDj744ANEREQILYcDbgCagBuAkZKfn4+7d+/yCuAqsGzZMjRs2BCTJk1CcXGx0HKMHm4ANYcbgJFy+/Zt5Ofn8xxAFZBIJNi9ezdu376N5cuXCy3H6ElMTETdunWFlqHXcAMwUkJDQ+Ho6AhfX1+hpegVfn5+WL58Ob788kuEhoYKLcdoISIkJyfD2dlZaCl6DTcAI0VW/q+Lk7ToOrNmzUKvXr0wefJk5OfnCy3HKElISEBBQUHJdKOc6sENwEjhFcDVRyQSYceOHYiKisJXX30ltByjJCYmBgDg5uYmsBL9hhuAEZKSkoInT57wCuAa4OXlhWXLlmHlypW4deuW0HKMDtkkQ9wAagY3ACPk+vXrICJuADXk/fffR+fOnTFlyhQUFhYKLceoiImJgb29vdJZwDiVhxuAgRMcHIw5c+Zgz549ePr0KQBW/OPt7Q0XFxeB1ek3JiYm2L59Ox49eoS1a9cKLceoiImJ4V//GkBccRCOPlNcXIzvvvsOIpEIRAR7e3u4u7vDw8MDx48fR4cOHXhb6hrQtGlTLFq0CF988QVGjRqFBg0aCC3JKIiOjuYVwBqA5wAMHG9vbwCs2RwApKen4+HDh7h27RoGDx4MZ2dneHh4YMyYMbhz546QUvWWTz75BF5eXpg5c6bQUoyGmJgYuLq6Ci1D7+EGYOAo+yIlIrlJz2NiYvDXX3+hUaNGWlRmOJibm2PLli04ceIEDh06JLQco+D58+fw8vISWobeww3AwLG3t4etra3aMESEjRs3wsrKSkuqDI+ePXtiwoQJmDVrFrKysoSWY/C8ePGiJHfLqT7cAIwAdV9KZmZm8Pf3R2BgoBYVGSarV69GdnY2vvjiC6GlGDTx8fHIzs7mBqABuAEYAY0bN1bZ41ckEmHr1q1aVmSY1KtXD0uXLsX69esRHh4utByD5fnz5wDADUADcAMwAnx8fGBmZqaw39TUFAsXLoSPj48AqgyT9957D02bNsXHH38stBSDJTIyEmKxGB4eHkJL0Xu4ARgB3t7eKD/xm4mJCTw8PDBv3jyBVBkmpqamWLt2LYKDg3HixAmh5RgkkZGR8PT0hFjMW7HXFG4ARoC3t7dCT1WpVIpNmzbBwsJCIFWGS58+fRAYGIi5c+fyHsK1QGRkJC/+0RDcAIyA8i+LmZkZhg0bhsGDBwukyPBZs2YNnj17hu3btwstxeB49uwZL7bUENwAjIAGDRrIVQKbmJjwoQtqmYYNG2LGjBn44osvkJmZKbQcg+Lx48do3Lix0DIMAm4ARoCFhQUcHR0BsDLqL7/8knei0QILFy5Efn4+vvvuO6GlGAzZ2dmIjo5GkyZNhJZiEHADMBJkxUA+Pj6YPXu2wGqMAycnJ3z88cdYtWoV4uPjhZZjEISHh4OIuAFoCF6NruMUFwMZGUBODpCfD6Smsv3Z2UCZ0RwAALm5QF6e4jXq1AHs7JoAuInp07fh4kUz2NsDJiaApSVgYQE4OAASCWBtXeu3ZFTMmTMHmzZtwooVK3hOQAM8fvwYYrGYVwJrCG4AWqC4GIiPB2Jj2TolhS2pqaXbZffl5ABZWWzRXCMSbwDj8PHHvSsMaWvLzMDOjm07OpYudeoAdeuW/u3kBNSrB3h6cvNQhrW1NRYtWoS5c+fi448/5m3Xa0h4eDh8fHxgbm4utBSDQETlG4hzqkRxMRAdDURGAs+eAS9fsoQ+JqZ0HR/PwskwN5dPVMsmro6OLCG1tgZsbFhCbG9f+qUu+3KXSIDyQ/eYmbFzyuvLyAD++GM/OnXqhvr13SCVAunp7HjZnEVBActZZGayfRkZbLu8SSUns/Cya8iwsQE8PAAXl9K1pyfQoAHg7Q34+DBDMTYKCgrQuHFjDB06FOvWrRNajl4zbtw4ZGRkIDg4WGgphsAmbgCVQCoFnj8H7t8HHj4sTewjI4EXL0qLYiwsWGJXvz5LAOvXB9zdS9eurmzbUCYxKi4GEhOBuDhmgrJ1bKziWoaTEzMCmSE0bAi0aAE0a8ZyHIbK999/j08++QRPnz7lE5nUgA4dOqBXr15Ys2aN0FIMAW4A5Xn1Crh9G3jwgCX4Dx6wRD8nhx339JRPwLy9S7f58OTKyc1lZlnWOGXbT56U/rZeXkDTpsDrrzNDeP11oGVLltvRd/Lz89GwYUOMHj0a33zzjdBy9BKpVAo7Ozts2LABkydPFlqOIWDcBpCWBty7B1y+DISEADdusK9YgBXH+PkBzZuXrlu1ApydhdVsiMTEyBvu/fvAnTusDkQsBho3Btq1K106dNBPU/juu+8wf/58PHv2jE9mUg0iIiLQuHFjXL9+He3btxdajiFgXAYQEQFcvAhcuAD89RcrrwdYMUT79qVL27aGXRyhD0ilLHdw40bpcvs2MwULC2YEvXsDvXoBXbvqRwV0Xl4eGjZsiPHjx+Prr78WWo7ecfDgQYwcORIZGRmw1od/uO5j2Abw4gVw6hRL9M+fZ1+a1tYswejVC+jYkSX4deoIrZRTGYqLgUePmBlcvsyMPCKCVX537Mj+p2+8AfTsySradZFvvvkGn3/+OV68eFHSOY9TOb744gv8+uuviIiIEFqKoWBYBiCVsq/E4GDg6FHg1i3WeqZNG6B7d8DfH+jRQz+LDzjKiY8HLl1iRXiXL5f+z/v0AYYMYYsulbZkZ2fDy8sLc+fOxYIFC4SWo1eMGDECUqkUBw8eFFqKoaD/BiCVsi/B3btZwp+QwCpl33yTLb168QTfmHj+nJl/cDDL+RUVAZ07A2+/DYwdy1phCc38+fOxc+dOvHjxgo/GWgWaNGmCMWPG8BnXNIf+GsDDh8AvvwC//gpERbGKweHDWaLfooXQ6ji6QGYmKwIMDgYOH2Z9HPr3ByZMAIYOZTkFIYiPj0eDBg3w/fffY8qUKcKI0DNyc3Nha2uLPXv2YOTIkULLMRT0ywAKC4G9e4HvvwdCQ1mTzAkT2NK0qdDqOLpMbi5w5Aj7aDh5ktUFvfMOMGcO0KiR9vX85z//wd9//40HDx7AxIQPyVUR169fR8eOHflIoJplk148eWlpwKpVrGhnyhTWaufsWZbdX7aMJ/6cirG0BEaPZsVDr14Bn30GnD7Nnp1hw1irMG0yb948hIeH4/jx49qNWE+5efMm7Ozs4OvrK7QUg0KnDSAzE1iwAHjtNWD5claG+/QpK+/v04cNicDhVBUXF/bl//gxsH8/683csyfQpQurUNYGTZs2xcCBA3mnsEpy+/ZttGnThueWNIxO/ppSKfDDD6wD0NatwJIlrM3+6tWs2IfD0QQmJqzeKCQEuHKFjbPUqxcwciTrqVzbzJkzB+fPn8e9e/dqPzI959atW2jbtq3QMgwOnTOAf/5hbfPfe4+9iOHhwMcf845ZnNqlc2fgxAng2DHWE7lZM1ZMVFRUe3H6+/ujadOm2LhxY+1FYgAUFhbi3r17aNOmjdBSDA6dMoCtW9mLaGvLjGD9ejb0cG2xZcsWiEQitcugQYNUnl9cXIz58+ejUaNGsLCwUBtWxt69e0uuXd0mgGvWrCm5hhDDC7948QJvvfUWMjIy5PaHhYUhICAADg4OsLW1hb+/Py5fvqxwflBQEPbt26fy+pMnT4ZEIoG3tzdmzZqFPGWTHNQSgwezZ2/VKmDNGlbU+OpV7cQlEokwY8YM/Prrr0gvP7RqLfLnn3+icePGEIv1YzT4+/fvIy8vj+cAagPSAbKziUaPJjIxIVq8mKioSDvxbt68mQCoXZYuXary/K1bt5aESU1NrVLcffv2JYlEUiP9rVq1Ind39xpdo6rcvn2bnJycaMOGDXL7r169SpaWljR69GiKiYmhxMREmjZtGonFYjp58qRc2CdPnpC3tzctWrRIZTwZGRm0ZcsWAkDLli2rlXupiLt3iZo1I3JyIip3CxojIyODbG1tad26dbUTQRmePHlCQ4YMoZYtW5KdnR2ZmprWepya4IcffiArKysqLCwUWoqhsVFwA8jIIOrZk71kZ85oN+7NmzfT0KFDlR4LDw8niURCsbGxKs8fO3YsAaCMjIwqx62PBpCenk4eHh40ffp0uf3FxcXUvHlzcnV1pZycnJL9RUVF1KRJE/L09KS8vDy5c8LCwkgkEtG+ffvUxmllZUX9+/fX3E1UkawsonHjiMzNiQ4cqJ043nvvPWrUqBFJpdLaieBfxo4dSytWrKDCwkJyd3fXGwOYOXMmdenSRWgZhshGQYuAiouBMWNYa4wLF4C+fbUbv6+vL3r06KH02IYNGxAYGIj6arqOJicnw9TUFLZGMsvJqlWrEBcXhyVLlsjtv3TpEu7fv48RI0bAskzvKlNTU4wdOxZRUVE4evSo3DmtWrXCiBEj8NFHH6FITUG7g4MDkpOTNXsjVcDamvUd+O9/Wb+B2mgl9MEHH+DJkyc4c+aM5i9ehh9++AFBQUF6U/Qj4/Lly+jatavQMgwSQQ1g5Urg3DnWQad5c+3H7+/vj48++khhf2ZmJn766SfMnDlT7fnFZaf5MnCICDt27ECnTp0UJjQ5d+4cACgdole27+zZswrHhg0bhlevXuHYsWMq4xWJRGoNQhuIRMC6dWxcoVGj2IxomsTPzw89evTAli1bNHvhclgK1fW5BmRmZuLevXvo0qWL0FIMEsEM4Plz4Msv2dKxo1AqlPPjjz/itddeQ8+ePWt8rUePHiEwMBD29vawtrZGjx49EBISojJ8YmIiPvzwQzRo0ADm5uZwdnbG8OHDERYWVqn4ioqKsG/fPvTr1w/169eHpaUlXn/9daxbtw5SqRQAkJaWplDZ/dVXX5WcX3b/iBEjAAB37txBfHw8WrVqpfQeASitkHZ3dwfA5nItT+vWrQEAJ0+erNS9CYmJCWuaLBYDCxdq/vpTp07FkSNHECebkKISlH22rKys0LFjRxw9ehT+/v4l/7+pU6dqXqwWuXbtGoqLi9G5c2ehpRgmQhU+zZ5N5OVFVFAglALlSKVSaty4MW3atKnCsD169CArKyuVxyMiIsjBwYHc3d3p1KlTlJmZSf/88w/179+fGjRooFAHEBMTQ15eXuTi4kLHjh2jzMxMunfvHvXq1YssLCzo77//lguvrA4gODiYANDy5cspJSWFEhMTaf369WRiYkIff/yxXNgBAwaQiYkJPXnyREF7ly5d6Lfffiv5+5dffim5bnn69etHAOjq1atKfwMA1LZtW4Vj6enpBIB69Oih5Ndj+Pj4kJ+fn8rj2mb7diKJhCguTrPXzcnJIQcHB1qzZk2lwit7tu7du0f+/v7k7OxcYf2SvtQBfPHFF9SgQQOhZRgqwlUCe3kRffaZULGr5tixY2Rra0uZmZkVhvXy8qLGjRurPD5y5EgCQAfK1R5GR0eTRCJReEknTpxIAOQSXiKi2NhYkkgk1K5dO7n9qgygd+/eClrGjx9PZmZmlJ6eXrLv5MmTBIBmzpwpFzYkJITc3d2poIw7r1q1igDQxo0bFa6tzgDCw8MJgIJ2GSKRiHx9fZUeIyLq3r072dvb60wLkJwcIktLop07NX/tGTNmUJMmTSpVGazq2UpISCArKyuDMYCBAwfSO++8I7QMQ0WYSuCMDDZZS6dOQsSunvXr1+Pdd9+FjZqZ21NSUrB69Wq8ePFCbT3BiRMnAAADBgyQ2+/m5qZ0QKvDhw/DxMQEb775ptz++vXro3nz5rh58yZeVdAo/c0338T58+cV9rdq1QqFhYW4f/9+yb7+/fvj9ddfx65du+QqWlevXo0PPvgAZmZmJftkbfHL7pPh4OAAgI11Xx7ZPlmY8ojFYuTm5qq8n+nTpyMjIwNLlixBUlKSynDawtISaN2a9RXQNFOmTMHjx49x5cqVCsOqeracnZ3R1EAGxyIiXLt2jZf/1yKCGEBmJlvrWu/e8PBwnDp1Sm2iPmnSJNStWxdBQUGYN28ePvzwQ6Xh8vPzkZmZCQsLC6VmUq9ePYXw6enpkEqlsLe3Vyijv3XrFgBUOBtSeno6lixZgtdffx116tQpOf+TTz4BAOTIZmD/l9mzZyMnJwebNm0q+Q3OnTuH//73v3LhZJ3WCgsLFeKUJTjKzCk6OhoAVI7gWFRUpLZycvz48Vi2bBlWr14NZ2dnDBw4UGVYbWFnxz5iNE27du3QunVr/PDDD2rDVfRs1TGQKe7u37+P1NRU3gKoFhHEAJycAFPT2uthWV3Wr1+Pnj17ws/PT2WYXbt2IT09HXv37sW3336L6dOnKw0nkUhga2uLvLw8ZGVlKRxPSUlRCO/g4ACxWIzCwkIQkdLljTfeUHsPQ4YMwZdffolp06YhPDwcUqkURIS1a9cCYF9VZRk3bhxcXFzw/fffIz8/H9988w0mTpyokIjIJjFX1mNVpunmzZsKx2T7+ipp45uRkQEiUjtB+sKFC7FgwQJs3rwZaWlpJV++QhIVVXsTy0yZMgX79u1DpuwrSQkVPVsJCQm1I07LXLlyBdbW1mjZsqXQUgwXoQqfOncmmjxZqNgVSU9PJ1tbW/r9998rfU6HDh2oTp06Ko+PGjWKAND+/fvl9icmJiotp/3Pf/5DAOjChQsK11q5ciV5enrKlYWXrwMoKioiExMTql+/vsL5y5cvJwB0+vRphWNffPFFSY9ba2trioiIUAhz+/ZtpfUFRKwjmJ+fH7m5uVFubq6cnmbNmpGnp6fcfhkPHjwgADRjxgyFYzKaNm1K3t7eKo9rmxcviEQioj//rJ3rJycnk0QioR9//FFtOFXPlqy+yBDqACZPnkxvvPGG0DIMGeEqgTdvJrKwIIqOFkqBPGvXriVXV9cqVTb27dtX7Uv05MkTcnR0lGupcf/+fRowYADVq1dP4SWNj4+nhg0bko+PD/3555+UlpZGycnJtGXLFrKyslLoNausErhPnz4EgFatWkWJiYmUk5ND586do9dee02lASQmJpKlpSWJRCKVPaOlUinVq1ePunXrpvT4lStXyMLCgsaMGUOxsbGUlJRE06dPJ7FYTCdOnFB6zu7duwkAHTp0SOVv6O7uTq1atVJ5XNt8+CGRhwdRfn7txTFs2DDy9/dXG0bZs3X37l0aOHAgeXl5GYQBNGnShBYuXCi0DENGOAPIzSXy8SEKDBRKQSlSqZR8fX1pyZIlVTrP39+/wpfo8ePHFBgYSHZ2dmRpaUkdOnSgo0ePUt++fUvGG5oyZUpJ+OTkZJo7dy75+PiQmZkZOTs7U//+/eUS7tWrVyuMWSR7URITE2n69Onk6elJZmZm5OLiQpMmTaKgoKCSsMpa5EybNo0A0MWLF1Xey4IFC0gsFlO0Cte+desWDRo0iOzs7MjGxob69OlDISEhKq83cuRIhdZG5XF3d6fWrVurPK5NbtwgEouJtm6t3XgOHDhAJiYmFBUVpTZc2WfLysqKunbtShcvXlQ5zIisibCyZfv27bV1O9UiKSmJRCIRHT16VGgphoywYwGdP89eqBUrhFRRfQICAkgkEgktQyPs3LlTZVNNGWlpaeTu7q4wFlB1kI0FtGfPHrXhXFxcqHPnzjWOr6bExhK99hqRvz9RLQ/ZQ/n5+eTo6EirV6+u1vmaGGdKaI4cOUIikYgSExOFlmLICDsWUO/ewNq1bNav774TUkn18PDwABEhPj5eaCk1ZsuWLZg7d67aMPb29ggODsaBAwdqNIb9s2fPMHz4cMyfPx9jxoxRGa6wsBApKSmCDHldlpgYNiy0pSWwbx8bGqI2MTc3x9tvv43ffvutdiPSYa5cuYImTZrAyclJaCkGjeDzAfzf/7Fx1+fOZQNuqWkSrnPImiSuXLlS0AHLqsOOHTswbNgwZGVlYcuWLUhNTcWoUaMqPK9Nmza4ceMGjh8/rjAfQGXZunUrli1bhmXLlqkMk56ejm+//RaFhYWCNv28dKl0qJJz5wBHR+3EO378eISFheHu3bvaiVDHuHz5Mm//rw2EzoPI+OMPIkdHNv763btCq6k8X3/9NTVr1owkEgkNHDhQaDmVZvv27QSAxGIxtWzZkm7evCm0pBImTpxIZmZm5OvrS4sXL6YibU0QUQaplOi774jMzIiGDiVKSdF2/FJq0KABffrpp5U+Z8+ePQpl+2Xrl/SF7Oxskkgk9PPPPwstxdDZKCIq1zBcQJ4/Z8ND37sHzJ/PcgV6OIAhR8+5cYNNGh8ayuah/uCD2i/2UUZQUBB+//13PH36FCIhBAjEyZMnMXDgQLx69apkMEFOrbBJ8CKgsjRowLLcCxcCX38NNG0K7NkD6I5FcQyZV6+AiRPZECUmJsC1a8CHHwqT+APAyJEjERkZiRs3bggjQCDOnj2LZs2a8cRfC+iUAQCAuTn7+g8PB/r1A8aPBzp0YJVvAg8LzzFQIiOBWbOAJk2AkBDg99+BixfZmD9C0q5dO/j6+mL//v3CCtEyZ86cgb+/v9AyjAKdMwAZ9esDO3YAN28CPj7AuHFAo0astZCaXvIcTqW5do1N8NKoEZuUaPly4MED4O23hVZWysiRI7F3716FITwMleTkZNy5c0fp0CEczaOzBiCjdWv2RRYRAbz1FrB4MeDpyVoMhYTw4iFO1UhOBjZuZMU8nTuzr//ffmPP16xZgEQitEJ5Ro4ciaioKISGhgotRSucP38eIpFII5MxcSpG5w1Ahrc3m5bv5UtgyRJWQdejB+DrC3z2GfDkidAKObpKfj5w8CAQGAi4uQFBQay45+JF4Pp1YPRoNtOXLtKmTRs0bdrUaIqBzp49i/bt2xvMiKa6jt4YgIw6dVjroLAw1lpowgTgp59YNr5hQ/YVd+YMry8wdlJSgP37gXffBVxcgJEjgaQkYMMG1rHr558BffnIHD58OP73v/8JLUMrnDlzhhf/aBGdagZaXYqLgfPnWTlucDBrTuriAgQEAIMHsx7HdesKrZJTmxQXs0laTp9mz8CVK+yrvlcvVnQYGAjoa6OS0NBQdOrUCf/88w9ef/11oeXUGi9fvoSXlxfOnj2LPn36CC3HGNhkEAZQnrt3gaNHmSGEhrJ6ghYtmBH07s2+/HgPc/2muJjlAi9eBC5cAP76C0hLA5ydmem/+SYwYABgayu00ppDRPD09MSMGTOwsDZmpNcRfvzxR8ycORMpKSlqJwniaAzDNICypKayyuILF1hiERYGSKWAnx+rCGzfni0tW+peBSCnlOho1kHrxg1Wbn/1KpCezhL8Hj3Yl37v3szoTfSuYLNipk2bhrt37+Lq1atCS6k1xo8fj/j4eJw+fVpoKcaC4RtAedLT2ddiSAhLSG7eZPvMzJgJdOgAtG3LDMLPj9U5cLRHcTHw7Bmr37l7tzTRj41lCXvjxsywO3dmiX7z5sJ11NImR44cwbBhwxAdHY36tTUdmYAQEdzd3fHhhx8iKChIaDnGgvEZQHmIWKezsl+Xd+4Aspn23NxKzaB5c9Y72deX7edUn9xcltA/fgw8fMgS/IcPgUePWKsdkYi1/JLl0GTGrGvzSGuL3NxcODk5Yf369ZgyZYrQcjTO/fv30aJFC4SGhqJDhw5CyzEWuAEogwh48YIlSPfvyydQsk5oFhYsgfLxKV28vdlwFvXrA/XqGceXqSpyc1lrm+holtBHRrK1bImLY+FMTNhvJjNYmdk2awZYWwt6CzrHkCFDYGpqisOHDwstReOsXbsWX331FRISEmBqaiq0HGOBG0BVefVKPiErm7jJEjWAFSm5uAAeHvLr+vVZiyRHR/nFykq4e6oMUilrWll+SU5mCX1srPw6La303LJmWd40GzbU/XvXFbZt24Y5c+YgMTERVgb2o/Xp0wdubm749ddfhZZiTHAD0CQ5OSznEB/PjKLsOjqaGURcHKBsGH0Li1IzsLQE7O3ZPtm2uTlr0WJtzbYBwMaGGU1ZHBzkcx65uUBennyYzMzSfhLp6UBBAduXnc22U1NZMUxODkvIU1LYvvKYmwPm5p/D2joP7dsvh6urCdzdmcmVXbu6GnduSFPExsbC3d0dwcHBCAgIEFqOxsjIyICzszN27dqFsWPHCi3HmNiko/0f9RMrK1Z00ayZ+nBFRSxBVfZ1cDdiAAAgAElEQVRFnZLCEuy0NLbOzWW9n/PzWb1EVhZQWMiuk5YmPxSGVMoS9LKYmysWpVhaMnMBmKlIJKxs3cqKbfv4sLWVFTOU8rkV2WJjA+zY4YGZM2fCyuoZ1q3bZXBfprqEq6sr2rdvb3AGcOLECRQXF6N///5CSzE6eA6AU2NCQkIwfPhwuLu7448//sBrr70mtCSD5csvv8TmzZsRHR1tMHMETJw4ES9evMCFCxeElmJs6NZ8ABz9pHv37rhy5QoKCgrQpUsXXL9+XWhJBsuQIUMQGxuLmzdvCi1FI0ilUpw4ccKgcjT6BDcAjkZo2LAhrl69irZt26Jnz55GPaF5bdK6dWs0aNAAwcHBQkvRCFevXkVCQgI3AIHgBsDRGLa2tjh8+DBmzZqFCRMmICgoCFKpVGhZBkdAQIDBGMCxY8fg7e0NPz8/oaUYJdwAOBrF1NQUK1euxLZt2/Dtt99izJgxyMnJEVqWQTFw4ECEhYUhISFBaCk15ujRoxgyZIjQMowWbgCcWmHq1Kk4d+4cLly4gG7duuHly5dCSzIYevXqBbFYjHPnzgktpUZERUXh7t27vPhHQLgBcGoNXjlcO9ja2qJjx444e/as0FJqRHBwMKytrdGrVy+hpRgt3AA4tQqvHK4d/P399X7UzGPHjqF///6Q8GF4BYMbAKfW4ZXDmqdv37548eIFnj59KrSUapGbm4sLFy7w4h+B4QbA0Qq8clizdOnSBba2tjhz5ozQUqrF6dOnkZeXh0GDBgktxajhBsDRKuUrh6OiooSWpJeIxWL06NFDb+sBDhw4gK5du8LV1VVoKUYNNwCO1ilbOdy5c2deOVxN+vbti3PnzuldcVphYSGOHj2Kt99+W2gpRg83AI4g8MrhmuPv74/k5GTcvn1baClV4tSp/2fvzuOiqt4/gH8GZth3UHZLEURU1HDNHXHFLQPDzNTS+FZWVmouLVY/W02zctfUFMXEzDTX3DV3E/cF3GUR2fdl5vn9cRpgmBlkYGCGfN6v130Bdzn3uTpznnvPuffc3cjIyMDw4cMNHcoTjxMAMxjuHK6ZVq1awc3Nrd41A8XExKBjx448aKAR4ATADIo7h6tPIpGgV69e9SoBFBcX448//kBYWJihQ2HgBMCMBHcOV0/v3r1x6NAh5OfnGzqUKtm7dy/S0tLw3HPPGToUBk4AzIhw57DuQkJCUFBQgGPHjhk6lCrZtGkT2rdvjyZNmhg6FAZOAMzIcOewbp566ik0adKkXrxMRS6XY8uWLXz3jxHhBMCMDncO66Zbt244evSoocN4rP379yMlJYUTgBHhBMCMkrJzeMmSJdw5/BhdunTB8ePHUVRUZOhQKrVp0ya0bdsWTZs2NXQo7F+cAJhRmzBhAncOP0bXrl2Rl5eH2NhYQ4eilUKh4OYfI8QJgBk97hyunL+/Pxo0aIAjR44YOhStDh8+jMTERL7908hwAmD1AncOayeRSNCpUyej7geIjo5G69at0axZM0OHwsrhBMDqDe4c1q5Lly5GewVQXFyMjRs3YtSoUYYOhVXACYDVK8bcOXzu3DmEhobCwcEBtra2CAkJqbOz8q5duyI5ORlxcXF1sj9dbN++Henp6YiIiDB0KKwCTgCsXjK2zuETJ07g2Wefha2tLa5cuYJbt26hSZMm6NmzJ3bv3l3r+2/Xrh0sLCyMshkoKioK3bt3h7e3t6FDYRVIiIgMHQRj1RUfH48hQ4YgIyMDv//+O9q3b1/nMSgUCgQGBiItLQ3x8fGwtLQEIB58atGiBfLy8nDjxo1af/Vht27d0Lx5cyxdurRW96OLrKwsuLm54YcffsD48eMNHQ5TtZCvAFi9Zgydw4cOHcKlS5cQFhZWWvkDorlq5MiRuHfvHrZt21brcXTt2tXo+gF+++03yOVyHvrZSHECYPWeoTuH9+3bB0A0w1SknFcXI3Z26dIFV69eRUpKSq3vq6qioqIwaNAgODk5GToUpgEnAPafoO/O4atXr2LYsGGwt7eHlZUVOnTogG3btiEkJAQSiQQSiaS0SePq1asAAC8vL7VyPD09AQDXr1+vdixV1aVLF0gkEqMZGC4xMRH79+/nu3+MmNTQATCmTxMmTEDz5s0xfPhwdOnSBX/88YfOnY9xcXHo3LkzrK2tERMTg86dO+POnTuYNGkSzp8/D3NzcxQUFJSun5GRAQCwtrZWK8vGxgYAkJ6eXoOjqhpHR0c0a9YMJ06cwJAhQ2p9f4+zfv16WFtb84vfjRhfAbD/nJo+OTxjxgxkZGRg/vz56NOnD2xsbNCiRQusW7cOubm5OpWlvMdCIpHotF11tWvXzmielI6KisKIESNU+kWYceEEwP6TatI5vHPnTgBAv379VOY3aNAA/v7+aus7ODgAgMbkoJynXKe2tW/fHqdPn4ahb+67evUqzp49y80/Ro4TAPvPqk7ncGFhIbKzs2FhYVHafFOeo6Oj2jxlUrh//77asgcPHgAA/Pz8qnMIOmvXrh3S09Nx8+bNOtmfNmvXroWXlxe6d+9u0DhY5TgBsP80XTuHzc3NYWtri4KCAuTk5Kgtf/jwodq8Xr16AQDOnDmjtkw5r3fv3tU9BJ20bdsWMpnMoM1Acrkcv/zyC1566SWYmHAVY8z4f4c9EXR5cljZaalsClJKSkrSeDdPjx49EBAQgJiYGJXOYblcjujoaHh7eyM0NFRPR1I5CwsLtGjRAqdPn66T/WmyZ88e3Lt3D2PGjDFYDKxqOAGwJ0ZVO4e/+OILODk5YdKkSdizZw9ycnJw8eJFjBs3Dm5ubmrrm5iYYMWKFUhLS8O4ceOQlJSE1NRUvPnmm7hx4waWLVsGCwuL2j68UobuCF65ciW6deumsb+EGRdOAOyJUpXOYR8fHxw7dgzt27dHWFgYXF1dERkZienTp2t9m1WnTp3w999/IzMzE82aNcPTTz+NGzdu4MCBA2qdybWtffv2OHv2LORyeZ3uFwDS0tKwZcsWjBs3rs73zXTHzwGwJ46yc3jmzJkYPXo0Lly4gC+++EKlvdrPzw+bN2/Wqdy2bdti+/bt+g5XZ+3atUNOTg6uXr2KFi1a1Om+165dC5lMxi9+qSf4CoA9kYx5WOmaatWqFSwtLQ3SD7By5Uq88MILsLW1rfN9M91xAmBPNGMbVlofZDIZAgMD6zwBnDlzBufOnePmn3qEEwB74lWlczg6OhoSiQR79+5FYWGhylhAxsgQHcErV66En58fnn322TrdL6s+TgCM4fGdwxERESAilWn58uUGivbx2rVrh9jYWJSUlNTJ/goKCrBu3Tq88sordTbsBas5TgCM/cvQw0rrU+vWrVFQUFAno5ACwObNm5GdnY3Ro0fXyf6YfnACYKyc/0rncEBAAGQyGWJjY+tkfz///DP69+8PDw+POtkf0w9OAIxpUN87h83NzdGsWTOcP3++1vcVHx+Pffv2YcKECbW+L6ZfnAAY00LZOVxYWFitYaUNrXXr1nVyBbB48WJ4enrW2XAXTH84ATBWCR8fH5w4ccKg7xyurrpIAIWFhVi9ejUmTJgAU1PTWt0X0z9OAIw9Rn3tHA4MDERCQoLGEUz1ZePGjUhPT8crr7xSa/tgtYcTAGNVUB87h1u3bg0AuHDhQq3tY/HixRg2bFjpu49Z/cIJgDEd1KfOYTc3N7i6utZaR/Dly5dx9OhRREZG1kr5rPZxAmBMR/WpczgwMLDW+gEWLlwIHx8fBAcH10r5rPZxAmCsGupL53Dr1q1VrgBycnJw5swZtZfdVObKlSt47bXXcOnSpdJ5ubm5WLt2LV5//XV+61c9xv9zjFWTMXcOJyYmYv/+/cjOzkZGRgaCg4Ph7u4OW1tbtGvXDosXL65yWUlJSVi2bBlatWqF4OBgbN++HVFRUSgoKMDLL79ci0fBahu/D4CxGlB2Dvv4+ODNN9/EzZs3sWrVKlhZWWlcPz4+Hj4+PrUSS05ODvr27YsLFy6Uvs9YKpXCxMQEt27dKl1PJpOVdhBXRWpqKiQSCYgIhw8fxv79++Ho6Ih27drB0tJS78fB6g5fATCmB1XpHP7jjz8QFBSExMTEWonBxsYGrVq1Qm5ubum8kpISFBUVqaxXUlKCwMDAKpf76NEjSKXS0m0BICMjA8ePH4erqyveeecd3L59u+YHwOocJwDG9KSyzuHz588jIiICWVlZeO+992othlmzZsHc3LzSdYgIbdq0qXKZqampau38RAS5XI68vDwsWrQIPj4+GD16tEFeQ8mqjxMAY3qkqXM4NTUVgwcPRnFxMYgI0dHR2L9/f63s393dHe+//37pGbsmlpaWaNy4cZXLTE1NBRFpXV5cXAwAGDFiBD8NXM9wAmBMz2xtbbF582ZMmDABr776Kvr374/ExMTS5hNTU1P873//K6049e2DDz6o9JWMLVu21OnOnUePHlV6Zi+RSLB8+XIMHjxYpziZ4XECYKwWSKVS/PDDDxg8eDD++ecflcpeLpcjPj4eP/30U63s29bWFh9++KHGs3GZTIagoCCdynv48GGlCeC7777j10DWU5wAGKsl33zzDTZt2qSx8pTL5Zg5cyYSEhJqZd8TJ06Eh4eHxrZ7Xe4AAqB1LCETExPMmjUL7777brXjZIbFCYCxWrBjxw5Mnz690rbzkpISTJ48uVb2b2Zmhs8//1xt/7reAQSIJqCKTExMEBkZiU8++aRGcTLDklBln1DGmM4uXLiATp06IT8/v9IEAIj28wMHDqB79+56j0OhUCAwMBBXr14tvQqRSCTIyMiAnZ1dlcuxtbUtfa4AEH0Y4eHhiIqK4qeA67eF/L/HmJ4VFRUhLCwMFhYWMDExqfTOGOWZdG28vN3ExARfffWVShOUl5eXTpW/XC5Xea5AKpWib9++WLNmDVf+/wH8P8iYngUFBWH16tVIS0tDdHQ0+vTpAxMTE8hkMrV15XI5bty4gQULFtRKLIMGDUK3bt1Knwh+5plndNo+LS2t9CpGJpPhmWeewcaNGyu9zZTVH5wAGKslFhYWCA8Px44dO3Dnzh18/vnnaNSoEQCoJAO5XI4ZM2bUWofw119/jZKSEp0fAANEAgDE1YS/vz92794Na2vr2giTGQD3ATBWh4gIR44cwcqVK7FhwwYUFBRAIpFALpfjxRdfrHRU0ZwcoLgYKCgA8vOBkhIgO7tseWYmoG0supkzh+LkyT8wefJv6NDhObXl9vaAphadS5f+xqRJXeDp2QQrVx6Dq2tD2NgAEgng4CDWsbUF+IKgXlrICYCxWpCZCaSlAampQEaG+DsnB8jNFZV2ZiaQmZmHS5d+w+XLy5GScggA0LTpQSgU3VQq9/R0fUR0BUArANcA6DIY3VYAbwI4AqBRpWtaWgIWFiIZ2NoCMhlgYyMShY0NYG1d9rfy9/J/29sDTk5lk5lZdY+VVREnAMYeJy8PSEoS08OHQEKCqNjT0lSn8vM0PTdlZSUqOltbUdlZW4vJzg4wMbmLu3fXIC3tH4wZEw2pVAp7e7Gd8uzcygowNxcVo7W1mKdcByirgDUxMwM++ug9fPfdd5BIJCrLFAqRkDTZuXMrXFyawsenOQCgsFD8e8jlQFaWWEd55ZGbCxQVla1TWCjmZWSUJb/cXJHQlL/n5IjlmmohGxvVhODkBDg7l/1s2BBwdQXc3cXvDRuKKxNWZZwA2JOrsBC4dw+4e1dM9+4BKSlAYqJqZV/uDkgAovJp0EC9ctJWUTk4iKmqlZNcLq+VMXUKCwsfO1CcoeTllV01aZtSU8uSbGqq+P8pLCwrQyoV/y+uroCHh/jd3R1wcwMaNSqbGjQw3HEaGU4A7L8rNxe4cQO4c6dsKl/hlx+V2cIC8PYWlYebm5gaNhQViatr2e8NG3LThDFJTy9L1g8eiASelCT+b5UJPDlZzFOytASeekokA29v8fPpp8XPJk3EvCfkSoITAKvfioqA+/eBmzeBS5eAy5fF7zdvArdvl3WKOjqKL7e7u6jImzRR/fvppzV3grL/BuXnJCFBJAflZ0T59/XrZX0uZmaAl5f4fAQEAC1alH1e/mOfE04ArH4oLBSV+4ULwMWLwPnz4u/790X7sUQiztx8fcXUtKn46ecnvrTa2sYZU0pOBuLixFWjclL+rWwGtLICmjUDWrUCWrYEWrcWPz08DBt7NXECYMYnMRE4fVpU8ufPiwr/+nVx26OZmTgra9lSTH5+ZRU+V/KstiQklCWFq1fLPpfKZkRnZyAwUHwmW7UC2rYVyUHDs3/GhBMAM6zcXOCff4AzZ8qmy5fFMnd3cfkdEAAEBYnfW7Tgip4Zj4wMkQguXxZNkGfOALGx4opBJhMnJ127Al26iM9wQIBR9S9wAmB1KykJ2LcPOHAAOH5cfHHkctHp2qGD6lT+FkfG6guFArh2DTh5UkwnTogrhuJicaXQoYNICMHBQPv2Bn2IjhMAq13p6cDBg8DevaLiv3xZnBl17Ah07lxW2Teq/Bkjxuq1ggJxpatMCgcPiruWbG2BHj1EMggOFs1IdXiFwAmA6d+FC8DmzcDWreJDTyTaRJUf8m7dxINMjD3Jrl0TJ0X79gH794tnG1xcgD59gOeeAwYMEA/D1SJOAKzmFApxmbt5s5ji4sRdEUOGAH37ijMcJydDR8mY8VIoRN/Bvn3An38Chw6JK2VlMhgyRDQf6RknAFZ9N24AS5cC69aJuySaNgWGDxcf2A4d/lP3SzNWpx49Av74Q5xQ/fWXuAOuVy/g1VfF90tPDyNyAmC6KSoCfv9dVPz79ol778eNA55/Xtz+xhjTr+xsYMcOICpKXB04O4vv3IQJgI8u4/qp4wTAqiYtDZg/H1iyRJydDBwIREYC/fsDtTBsDWNMg/v3gRUrgOXLRSdySAgwdar4WQ38SkhWuawsYMYM8TTtwoWi0r99W1yehobWfeVfUlKCFStWoEOHDnB2doajoyOCgoLw008/oaioqNJt5XI5pk+fDl9fX1hYWGDAgAFa1z116hTGjh2Lxo0bw9LSEk5OTmjZsiWef/55LFq0CPHx8WplL168GM8++yzs7e0hk8ng4eGBgQMH4qeffsLt27dL13Vzc4NEIlGZrl69qlJeWFgYJBIJHjx4oDL/ww8/VNnuq6++Ull+48YNSCQSdOrUSeux2djYqO1fIpHAxMQEDRo0wLBhw3Dq1Cmt29+5cwdDhgxBlnI40H+dO3cOoaGhcHBwgK2tLUJCQnD06FGt5VRm+/bt8PPzq9abx9LT07F48WIEBwfDyckJlpaW8PX1xahRoxAbG6u2/rRp07Bhwwat5Y0bNw7m5uZo3Lgx3nnnHRQUFOgck754eQGffCK+g1u2iHl9+gDPPiturdYZMaaBQkG0YgWRqyuRszPRN98QZWcbOiqil156iQDQ9OnTKTk5mR49ekRff/01AaBBgwZVuu2SJUsIAH322WeUnp6ucR25XE6TJ08mqVRKU6ZMoStXrlBBQQElJSXR7t27KSQkhAAQACouLi7dbuTIkWRiYkJff/013bt3j/Lz8ykuLo5mzJhBEomEnJ2dVfazdOlSAkCTJk1Si6GkpIQcHBwIAK1YsUJteWpqKjk4OFBRUZHasunTp5fGd+nSJa3/Fv/88w8BoKFDh5bOy8jIoN9++40aNmxIMpmM9uzZo3E7FxcX+vHHH1XmHz9+nCwtLemFF16ghIQESklJoQkTJpBUKqVdu3ZpjaOiuLg4Gjx4MAUGBpKdnR2ZmppWeVulV199laRSKX3//feUmJhIubm5dOjQIQoICCBTU1PavHmz2j4bN25MH374odYys7KyaPHixQSAZs+erXNMtenYMaK+fYkAouHDie7erfKmCzgBMDUPHhD1709kakr09ttEqamGjkiIj48nANS2bVu1ZX369CEAdPLkSa3bjxw5kgBQVlaW1nVmzJhBAGjp0qUal5eUlNCAAQNUEsDJkycJAE2YMEHjNm+88YZaArh79y4BIH9/f7X1jx49SlZWVgSAwsPD1ZZHR0erVNxKcrmcPD09qW3btgSAJk+erPU4NSUApbVr1xIAatGihcr8zMxM8vLyosjISLX9tmjRgtzd3SkvL690fklJCTVr1oy8vb2poKBAayzljRw5kr788ksqLi4mT0/PaieA1157TW3+uXPnCAD5+vpqXCaRSGjDhg2Vlm1lZUV9+/bVOaa6sH07UbNmRPb2RKtXV2kTTgBM1ZkzRJ6eRL6+RH//behoVB04cIAA0Isvvqi27K233iIAFBMTo3X7vn37VlqhXLlyhUxMTCgoKKjSOP7++2+VBLBy5UoCQHPmzNEad8UEQETUvHlzAkB37txRmf/xxx/Te++9RzY2NuTo6EglJSUqy8eNG0cLFy5UK2/Hjh301FNP0alTpwgAubq6qlyllFdZAnjw4EHpVUT5K6WZM2eSVCqlBw8eqKy/f/9+AkBvvfWWWlmzZs167P9LeeUTSHUTQGUsLS3JxMSEFAqF2rLw8HDy8vLS+m9GROTh4fHYz4ch5eURvfsukURC9NZbRBU+OhUt4D4AVio2FujdG2jeXDyt2LmzoSNS5e/vD5lMptZeDgBXr16FRCJBq0puRZJrek1XOUuXLoVCoUB4eHil63Xu3BlEVNo+7erqCgDYs2ePxvV79OiBR48eqc3v378/AGDnzp0q83fu3InBgwcjODgY6enpOHnypMry3bt3l25b3s8//4yxY8eiXbt2CAwMRHJyMrZv317psWhC5e4LUb49jIiwfPlydOzYER4Vhr7ct28fAKBdu3ZqZSnn7d27t0r7trS01DneqsrNzUV+fj5atmyp9lY0AHjuuedw//59/Pnnn1rLkEgkKCkpqbUYa8rSEpg7F/j1V9FZ/PLL2t8TDQCcABgA8fKMvn2BTp3ErWbKF34bE1dXV8yZMwexsbGYMWMGUlJSkJaWhm+++QZ//fUXPv74Y/j5+VW7/EOHxHt5AwMDddquW7ducHNzw65duzBgwAAcOHAAisq+df/q168fAGDXrl2l89LS0nD16lU8++yzGpdfvHgRVlZWaNy4sUpZaWlp2Lp1K8aMGQNAdFwCIino6sC/vYktWrSA/b8DMsXGxiI5ORmtW7dWW1+ZkL28vNSWeXp6AgCuX7+ucxz6tnHjRgDAzJkzNS5v06YNANV/7/oqLEzcrr1pEzB7diUr1sVlCTN+o0cTPfUUUSXN40bj119/JS8vr9JmChcXF42dpRV169aNrKystC53d3cnAHTixAmdYzp8+DB5e3uXxtSwYUMaNWoUrVu3jnJzczVuk5+fT5aWlmRvb1/a7BAdHU2DBw8mItE5CYA6duxYus2cOXNo4sSJamX9+OOP1KtXr9K/U1JSSCaTkVQqpeTkZLX1NTUBZWZmau0EXrNmDQGgL774Qq0sZf/L8ePH1ZbduHGDANAzzzyj8d+gMvpsAkpKSiJXV1caP3681nUyMzMJAHXr1k3rOk2aNKGAgAC9xFQX5s8nMjMjunJF42JuAmLiRRjR0eJMwdbW0NFoR0R47bXXMGrUKLz33ntISkpCSkoKZs+ejYkTJyIiIqLSy/O7d+9qPEutSFPzwON07doVN27cwOrVqzF06FDk5+cjKioKL774Iho1aoTo6Gi1bSwsLNC9e3dkZmbi+PHjAMTZp/LM38fHBz4+Pjh16hTS0tJKl2tq/lm5cmXpWT8AuLi4YNCgQSgpKcGaNWu0xr1ly5bS20AdHBwwYcIEdOrUCUePHkVIuZvLE/8d+N5exyFa6d/mpOr8m+pLamoq+vfvj549e2Lx4sVa17Ozs4NEIik9Vk08PDzw4MEDo24GKm/iRHEL96JFWlao03TEjNLvv4tOIy0nqkZj9erVWjsbP/30UwJA8+bNU1uWmppK33zzDQGg77//Xmv5QUFBBIC2b99e41iLi4tp7969FBERQQDI1NSUzp49q7be3LlzCQDNnDmTiMRZb1xcXOnyN998kwBQdHQ05eXlkb29PeXk5KiUERsbS7a2tmpXGn/88YfGu3mIKu8E1uSzzz7TendUeHg4AaC9e/dq3U/v3r2rtJ/y9HEFkJOTQ0FBQfTiiy+qdaZrIpPJyNPTU+vyNWvWkEQioenTp1NKSkqNYqsrH3xA1KaNxkV8BcDEkM1WVmIyZsrO0hANjz327t0bALBjxw6V+WPHjoWzszOmTZuGqVOn4u2339Zafo8ePQAA58+fr3GsUqkUwcHBWL9+PT744API5XLExMSorac8m9+1axcuXLgACwsL+JR7vr98P8DBgwfRrl07WFcYSvXnn39GdnY2rK2tVR7sGjJkCADg0qVLah3JurL49y08xcXFasv8/f0BAPfv31dbpnyQrSZ9M9VVUlKC8PBweHp6YvXq1TCtwlOLJSUllXZEv/TSS5g9eza+/fZbNGjQQOPVmLFp0ECMNKoJJwCGp54Sb+a6e9fQkVQuNzf3sevkKF/e+q9Vq1YhMzMT0dHRmDt3LiIjI7VuGxkZCalUqrGiLm/q1KkwMTEp7fw8evRo6Z1AmvTq1QuAeEK1oubNm8Pb2xtnzpzB2rVrSyv88tuamZlh165d2Llzp9ry4uJiREVF4ejRoyAitWnSpEkARBNRTbi7uwMAMjMztR7fmTNn1JYp5ykTdF2KjIxEYWEhfv31V5Unips2bVra5FZeVlYWiKj0WDWZOXMmZsyYgUWLFiEjI0PtDi5jdOkSUOGegVKcABi6dgVcXStpJzQSHTt2BKD5lkLlrYiahkCws7NDeHg42rZtW2nl7ufnh08++QSnT5/WevfMtWvXsGTJEowYMaL0zJeI8PDhQ42VCgCcPn0aANC2bVuNy/v16wciwg8//KB2RmljY4MuXbogISEBq1atUksAW7duhYuLC5599lmNZb/66qsAgPXr1yM/P1/LkT9ey5YtAWg+y+/Ro4QTMJAAACAASURBVAcCAgIQExOjMkyCXC5HdHQ0vL29ERoaWu19V8esWbNw6dIlbNmyBebm5lXaRnm1ojxWTX777Tc0btwY48eP17k/xBBSUoCYGDFYo0Z11AzFjJzyboHTpw0diXbp6enk6+tLMpmM5s+fXzoUxPLly8nKyoo8PT0pISFB6/a9e/euUpvytGnTSCaT0QcffEDXrl2jwsJCun//Pi1fvpzc3d2pa9euKu3whw8fJgDk7e1NUVFR9ODBAyooKKBbt27Rt99+S2ZmZhQUFKT1adiYmBgCQDKZjLI1jLfx1VdfEQByd3dXWzZo0CD65ptvKj2eDh06EABau3Zt6Txd+wAUCgU1bNiQunTponH5sWPHyMLCgiIiIigxMZEePXpEkZGRJJVKaefOnWrrjxo1igDQzZs3te6zKn0AmspRPphX2XTs2DG1statW0cA1IaKqBhT69atK43JWCgUYmiISu7u4yeBmSCXi+EfGjYkunzZ0NFol5aWRlOmTCF/f38yNzcnMzMz8vHxoYkTJ1JSUlKl24aEhFS5U/HkyZM0evRo8vb2JplMRra2ttSpUyeaP38+FRYWqqwrl8vpyJEjNHnyZOrYsSN5eHiQVColW1tbateuHX3xxRdabwUlEmPwSKVS6tmzp8blysp67NixpfPu3bunUqGVv1VU6datW2oVn6urK1lbW6vNb9as2WP/TWbMmKHxSWCls2fP0oABA8jOzo5sbGwoODiYjhw5onHd4OBgsrGxUeuY3bp1q9ZKe9myZVUqJzQ0tFoJIDw8nDw9PTWOsaTk6elJbbT0qBoThUI8CWxuTnTggNbVOAGwMjk5RF27Ejk4EOkwfle9ERoaShKJxNBh1FsZGRnk6empNhaQrtLT08nS0rLSe/LrshyisrGA1q9fX+l6rq6u1KlTpxrvrzZlZxOFhYkr+o0bK12V7wJiZaytgT17xDDPAwYAkyYBeXmGjkp/vLy8QERITk42dCj1kr29PbZu3YqYmBgsWLCgWmUQEd5++23Y2dnh888/r3Ys+ioHAG7evInhw4dj+vTpiIiI0LpecXEx0tLSqvQsiaEcPgy0aSOGht6zRzwRXBlOAEyFhQWwdq14MGzNGsDPD/jlF/Fi9/pO2cH61VdfIVXbfXGsUm3btsXp06exY8cOtfcBVEVycjJu3ryJvXv3ws3Nrdpx6KscAFiyZAlmz56N2ZWMmZCZmYm5c+eiuLjYKG/9fPBAvKujZ0/A1xc4dw7o3r0KG9bFJQmrn1JSxHDQpqZErVqJIWblckNHVTNff/01NW/enMzNzal///6GDofVA2PGjCGZTEZNmzaljz76qEoPlNWV5GTxoJelJZG3t/iOahjoVJsF/EpI9lixscBnn4kXVDdrBrz2GjBmDODkZOjIGHsyHTok3ssdEwO4uAAffCC+l1W841WJ3wnMqu7iRWDBAmDdOvFy+LAw8aHr1s3QkTH235eWBqxeDSxbBly5ArRvL5p9XnpJ54pfiRMA011ODrB+vTgDOX1aXBUMHy6moCDAgON+Mfafkp4ObN0qrr537gTMzIAXXxQnXlqeK9QFJwBWM2fOAFFR4gN6+zbQqBEwbJhIBl271v1L4xmr7xITxQvff/tN3M0jkYgXNYWFASNGADY2etsVJwCmP2fPikSwebMYf8TFBQgOLpt8fQ0dIWPGJzcXOHIE2LdPTGfPijd7DRggTqQGDgRqadQJTgCsdly/Li5d9+0THVY5OYC3t2pCMOLbqRmrNUVFwIkTwN694vtx4oSY17y5+F707Qv06SOSQC3jBMBqn1wu7kv+6y8xHTkCFBQA7u6iz0A5de0KODoaOlrG9CshQTSVHj0qPvtnzwL5+eLz37UrEBIC9O8vmk/rGCcAVvfy84Hjx4Fjx8TL50+eFO2epqZAQADQoYOY2rQBWrQQTygzVh/cuiXuljtzpuyznZoKyGTi86z8bHfpApR77YOhcAJgxuHePfFlOX5c/Dx7VjQbmZiIscxbtQJatgQCA8VPX1+g3BDvjNWptDTg/HlR2V+4IKZLlwDlw9E+PkDHjmUVftu24il7I8MJgBknhQK4eVP9SxYXJ5qUzM1Fm6mfH9C0qUgIfn7iZ4MGho6e/RcUFYkz+uvXgRs3yqYrV0SzDiCaLCuenLRsWWudtvrGCYDVLwUF4kzr4kXxU/mljI8XywDAwUEkgqZNRVJo0kS0r3p7i47naj40w/6DUlLE1ee9e+I25ri4ss/UnTviZAMQ7fW+vmUnGsrKvp7fyMAJgP03KBTiS1z+C6ycbt8uSw4SCeDmVpYQGjUS01NPAR4eYmrYUDxww+q39HQgKUn0LykreGVlf/euqODLvyTNzU2cLCivJJVXlr6+er333phwAmBPhuTksi9++cpA+XdSkur6Li7iNZmuriIpNGgAeHqK5ODmJn46OYmJO6nrhlwu2t6V08OHYhTMhw/LKvry8woLy7a1sBBJvmLSV/7t7W2UbfS1jRMAY4C4QkhIEBVJ+UokMbFsXkKCesUCiCYlZTLQNtnaikRhYyOaqJS/K/9+EobPyMsTDz1lZwOZmeL3nJyyv7OzVSt45ZSaKn5qeB89nJ1VE3XDhqK5pvw8V1cxn6nhBMCYrtLSgEePNFdW2qbMzK9QUtIDQGeNZVpZiaRgays6EE1MxO9SqXggyMJC/G5rK9ZXPi+hXEfJ2lp785Wy3Ipyc0WHpyaZmaJ5TSk7GygpEU0nBQXi9+xssSw9XXWdvDxRwefkABkZlb9Twt5eHMvjEqlycnYWV2Xcn1MjC/lGOsZ0pKyEqkIul2PixIlYtmwZli5dirCwzsjIEJWi8gw4Pb3s99zcsopUWfkqK+i8PNFpqVCUnQ1XrKAr/q1UfhvgMoDTAF4GIBKGtmYsKyvVStbaGjA1zcSdO6Pg5/d/sLdvU3rHy9NPiwSj3MbCQlzh2NmJycZGbG9nJyp85VWQMqmxusdXAIzVkvz8fIwcORK7d+/G+vXrMXToUEOHBABYuHAhPvnkE6SkpFRreyJCt27dIJPJsH//fj1Hx+rQQn4lJGO1ICcnBwMHDsSRI0ewd+9eo6n89UEikWDOnDk4ePAgtm3bZuhwWA1wAmBMzzIzM9GvXz9cvnwZ+/btQ+fOmtv967NOnTph+PDhmDx5MoqLiw0dDqsmTgCM6VFGRgb69OmDO3fu4ODBgwgMDDR0SLXmm2++we3bt7F8+XJDh8KqiRMAY3qibPZJSkrCwYMH4e/vb+iQalWTJk3wxhtvYNasWchSDoLD6hVOAIzpQX5+PoYMGYK4uDjs2rULPkYw1GNd+PDDD1FQUICffvrJ0KGwauAEwFgNlZSUICwsDLGxsdi7dy+aN29u6JDqjJOTE9566y3MnTsX2coHAli9wQmAsRp64403cPDgQezYsQOtWrUydDh17t1330VRURGWLFli6FCYjjgBMFYDX331FVasWIG1a9eiQ4cOhg7HIJydnfH6669jzpw5yMvLM3Q4TAecABirpo0bN2LGjBn4/vvvMWzYMEOHY1BTpkxBbm4uli1bZuhQmA44ATBWDZcuXcIrr7yCN998E2+99ZahwzE4FxcXvPbaa/jmm29QWHG0PGa0OAEwpqPs7GyEh4ejVatW+O677wwdjtF4//33kZKSgk2bNhk6FFZFnAAY09HYsWORnp6OTZs2wYzfHFPKw8MDQ4cOxaJFiwwdCqsiTgCM6WDZsmXYsmULNmzYAHd3d0OHY3Ref/11HDlyBOfPnzd0KKwKOAEwVkW3bt3C+++/j6lTp6J79+6GDscoBQcHIyAgAIsXLzZ0KKwKOAEwVgUKhQLjxo1Do0aN8PHHHxs6HKM2YcIErFmzhoeHqAc4ATBWBQsXLsSxY8ewbt06WDyBL4/VxZgxYyCXy7Fu3TpDh8IegxMAY4/x8OFDfPTRR3j//ff/06N76oujoyPCwsKwevVqQ4fCHoMTAGOP8cEHH8DGxgYzZswwdCj1xsiRI3HixAncunXL0KGwSnACYKwSJ06cwOrVqzFv3jzY2NgYOpx6o0+fPnBxccGGDRsMHQqrBCcAxirx0UcfoUuXLggLCzN0KPWKVCrF0KFDsXnzZkOHwirBCYAxLf7++2/s2bMHn332maFDqZcGDRqE06dPIzk52dChMC04ATCmxUcffYSuXbuiV69ehg6lXgoJCYGZmRl27txp6FCYFpwAGNPgzJkz2LdvH5/914C1tTW6du2KvXv3GjoUpgUnAMY0WLRoEQICAtCzZ89ql3Hu3DmEhobCwcEBtra2CAkJwdGjR/UXpAFt374dfn5+kEqlla7XsWNHnDp1Sufy09PTsXjxYgQHB8PJyQmWlpbw9fXFqFGjEBsbW92wWQWcABirICcnB9HR0XjjjTcgkUiqVcaJEyfw7LPPwtbWFleuXMGtW7fQpEkT9OzZE7t379ZzxHUnPj4eQ4YMwfTp06vUtt+uXTtcu3YNmZmZOu1nypQpeOuttzB06FBcvnwZqamp+Pnnn3Hu3DkEBQXh999/r+4hsHI4ATBWwe7du5Gfn4/w8PBqba9QKPDqq6/CwcEBK1euhLu7O1xcXLBo0SL4+Phg/Pjx9XbM/I8++gjPPvsszpw5A1tb28eu3759exAR/vnnH5339corr+Cdd96Bm5sbrKys0K1bN6xbtw5yuRxTp06tTvisAk4AjFXw559/omPHjmjYsGG1tj906BAuXbqEsLAwWFpals43NTXFyJEjce/ePWzbtk1f4dapFStWYNq0aY9t+lHy9PSEi4sLLl68qNN+li9frvEdw61bt4alpSXi4+NBRDqVydRxAmCsgiNHjiAkJKTa2+/btw+AaP6oSDmvvnaMlk9oVeXh4YGkpCS97D83Nxf5+flo2bJltZvnWBlOAIyVk52djbi4OAQFBanMv3r1KoYNGwZ7e3tYWVmhQ4cO2LZtG0JCQiCRSCCRSDB+/PjSdQHAy8tLrXxPT08AwPXr12v5SKpGl+OqLjc3NyQmJuplXxs3bgQAzJw5s0YxMaFq13GMPSEuXboEhUKhMuhbXFwcOnfuDGtra8TExKBz5864c+cOJk2ahPPnz8Pc3BwFBQWl62dkZAAQt0FWpBxOIj09vZaP5PF0Pa7qcnd3R3x8fI33lZycjGnTpmH8+PEYMWJEjeNifAXAmIqEhARIJJLSM3UAmDFjBjIyMjB//nz06dMHNjY2aNGiBdatW4fc3Fydyle2WxtD84U+j6syTk5OuHjxYo32lZqaiv79+6Nnz578shk94gTAWDkpKSmwt7dXedev8knWfv36qazboEED+Pv7q5Xh4OAAABorNuU85TqGpOtxVZdEIim9KqrOvnJzc9GvXz8EBAQgKioKpqameovtSccJgLFyCgoKVDo6CwsLkZ2dDQsLC42jgTo6OqrNU1Zo9+/fV1v24MEDAICfn5++Qq4WItL5uKqrpKQEcrm8WvsqKSlBeHg4PD09sXr1aq789YwTAGPlmJqaqtxeaG5uDltbWxQUFCAnJ0dt/YcPH6rNU44ddObMGbVlynm9e/fWV8jVIpFIdD6u6jI1NYWpqWm19hUZGYnCwkL8+uuvKreeNm3aFMePH9dbjE8qTgCMlWNpaYm8vDyVeQMGDAAAtUHNkpKSNN7N06NHDwQEBCAmJkalY1MulyM6Ohre3t4IDQ2theh1o+txVVdhYSGcnZ113tesWbNw6dIlbNmyBebm5nqLh5XhBMBYOe7u7sjKykJ2dnbpvC+++AJOTk6YNGkS9uzZg5ycHFy8eBHjxo2Dm5ubWhkmJiZYsWIF0tLSMG7cOCQlJSE1NRVvvvkmbty4gWXLlhnFe4V1Pa7qSk5ORvv27XXa16pVq/Dpp5/ixIkTsLW1Lb1NVDnFx8frLb4nGScAxspR3rt/9+7d0nk+Pj44duwY2rdvj7CwMLi6uiIyMhLTp09H06ZNNZbTqVMn/P3338jMzESzZs3w9NNP48aNGzhw4IBaR6ihVOe4tm3bVloJP3jwAHK5vPTv5cuXa9wmKSlJ533FxMTo9ViZZvwcAGPl+Pv7w8zMDLGxsWjRokXpfD8/P53fbtW2bVts375d3yHqla7HNWjQIJ2HYEhOToarq6tO+6qvQ2XUN3wFwFg5ZmZmaNGihcYOXKY7hUKBhIQEeHh4GDoUpgEnAMYq6Nq1a+l4Pqxm4uPjkZeXp3I1xYwHJwDGKujfvz9iY2ORkJCgdZ3o6GhIJBLs3bsXhYWFehkzxxjo+7guXLgAExMTBAQE1Pq+mO4kxGOqMqYiPz8fDRs2xJdffomJEycaOhy9W7hwIT755BOkpKTU+r4+++wzrFmzBjdu3Kj1fTGdLeQrAMYqsLS0xPPPP49ffvnF0KHUe2fPnkXr1q0NHQbTghMAYxqMGTMGp06dwrlz5wwdSr2lUChw5MgRdO/e3dChMC04ATCmQa9evdC6dWvMnTvX0KHUW+fPn0dqaip69Ohh6FCYFpwAGNNi0qRJiI6Oxq1btwwdSr104MABODk5oVWrVoYOhWnBCYAxLV566SX4+fnxC8iraffu3ejZsydMTLiaMVb8P8OYFlKpFN988w1iYmJw8OBBQ4dTr2RnZ2Pfvn0YNmyYoUNhleAEwFglBg4ciP79+2PSpElQKBSGDqfe2LZtGxQKhVGMesq04wTA2GN89913uHjxIn7++WdDh1Jv/P777+jRowecnJwMHQqrBCcAxh4jICAAb7/9Nt5//33cvHnT0OEYvaysLGzbtg1hYWGGDoU9BicAxqrgiy++QJMmTRAREYHi4mJDh2M0fvjhB0RGRqoMm7FhwwYoFAqMGDHCgJGxquAEwFgVmJubY926dbh06RI+/fRTQ4dTZefPn4eDgwNsbW1Lp8mTJyMzM1Nlnp2dHSIiInQu//r161i6dCkaN26Md999F4mJiVi1ahWee+45vb5XmNUOTgCMVVHz5s0xd+5cfPnllzhw4IDGdYxtaK3AwEA4OjoiJyendMrPz0dxcbHKvOzsbAwcOFDn8uPi4gAARUVFWLBgAby9vXHy5EkMGjRI34fCagEnAMZ0EBkZieeeew4jRozQ2B/w/vvv46+//jJAZNq9/PLLkMlkla5jZmZWrVs2lQkAAIqLiyGXywGIoTRee+01PHjwQOcyWd3hBMCYjn755Rc0btwYoaGhSE9PL53/2WefYd68eZgyZYpRXQmMHDmy0n4LqVSKIUOGwM7OTqdyiQj3799Xm19SUoKSkhKsWrUKjRs3xttvv13p0NrMcDgBMKYjKysr/P7778jLy8OwYcNQWFhYOsQyAMTGxmLTpk0GjrKMv78/WrZsCYlEonG5XC7HqFGjdC734cOHKCws1Lq8uLgYJSUlWLNmDRITE3Uun9U+TgCMVYO7uzu2bduGc+fOoW/fvirvDZBIJJg6dSpKSkoMGKGql19+GaamphqXWVpaon///jqXefv27UqXS6VSODg44MCBAwgKCtK5fFb7OAEwVk2tWrXC9OnTcfToUZX5CoUCd+7cwapVqwwTmAYRERGl7fPlyWQyREREwMLCQucyb926pfWqQiqVws7ODocOHeL3ARgxTgCMVdOJEyfw6aefgojU2vyJCDNmzEBeXp6BolPl7e2Nzp07qw3MVlxcjBdffLFaZd6+fRtmZmZq82UyGRwcHHD48GG0bNmyWmWzusEJgLFquHjxIvr27Yvi4mKNYwQREdLS0rBw4UIDRKfZ6NGj1c7YnZ2d0bNnz2qVd/v2bbVjl8lkcHFxwbFjxzS+B5gZF04AjOno5s2bCA4ORk5OjsZmFSW5XI7/+7//Q2ZmZh1Gp92IESNUEoCZmRlGjx6ttW/gceLi4lTuLpLJZGjYsCGOHDmCpk2b1jheVvs4ATCmo6ysLHTv3h0SieSx99fn5ubi22+/raPIKufk5ISQkBBIpVIA4uGtkSNHVru88s8AyGQyeHl54fjx42jSpEmNY2V1Q0LGdMMyY/VIYmIilixZgvnz5yMrK0tjXwAAWFhY4NatW3BzczNAlKqioqLw8ssvQ6FQwNvbG3fu3NHakVsZIoKFhQWKioogk8nQqFEjHDp0CB4eHrUQNaslC/kKgLFqcnd3x6xZs5CUlISVK1fC398fAErPsJWUTUHGYOjQoaVXLS+//HK1Kn9AJL+ioiJIJBL4+vri2LFjXPnXQ3wFwJgeHTlyBN9//z02b94MExOT0mcBTE1Nce3aNfj4+NR4H0VFQG5u2c/CQkB5s1FBAZCfr76NXA5kZYnf580bgWPHNuK77y7C27sFzMwAa2vN+1KO52ZiAtjbl/08ffpv9O3bBYGBgdi/fz+P+18/LeQEwFgtiIuLw08//YTly5cjPz8fCoUCYWEv4v/+LwqPHgEZGaJCzsoSv2dmlv1dfkpPB0pKgOxsoLgYyMnRR3RbAHwC4FwNyogC8BOk0h2wtXWAVArY2gKWloCdnfjd3h5wcBB/V5wcHQEXl7LJ3Fwfx8V0xAmAseoiApKTgYQE4MEDMSUnA48eASkpwMOHwMOHWbh3byWysuYBuAfgHwCBAACpVFSGDg6islRWjuV/d3AAZDLAxgalZ+rafirLtLXVHK/yDL6oqAi//PILxo8fD0BcPWga0aF8wlFeQSh/nj27H25u7WBmZqsyv6CgLHllZqomOuWUna2+L1tboGFDoEGDsqTQoAHg6gq4uQHe3oC7O+DlJZIM0wtOAIxpk5UF3Lwpplu3gPv3RSWfkADcuwckJYlmGCVHR1FZKSswV9eyCs3ZWYGbN/9EdnY83nlnEhwdASsrwx0bEVW7/b/m+xZXNspE+eiRmJTJUzk9fCjmJSeLZKTk5AR4eJQlBW9vMTVpIiZvb5Ho2GNxAmBPtpQU4PJlUcnHx5dV+PHxohICRGXi4QE0alR2FurpWVb5KH/ymWntqHildf8+kJgoknBiovj7zp2yqxUzM+Dpp0Uy8PEpSwx+foCvr7iiYgA4AbAnRXo6cOmSqOzL/1QOUmluLip1ZWVRfvL3195JyoxHenpZAq843b4NKBSiiaxRIyAgAGjRouxn8+aGvSIzEE4A7L+FCIiLA86cEdPp00BsrKgcANF8oPziK6fmzUXlz/678vOBa9eAK1dE4lf+jI8XnexSKdC0KRAUVDa1bau9P+U/ghMAq98SEoCjR0VFf/o0cPas6HiUSkVFHxQEPPOMqORbtBDt8owpFRWVJYbz58tOHFJSRNNfs2ZlCaFDB6B9+/9UExInAFa/KCv8v/4CjhwRX9yKX1Rlpf8EXtIzPUlIKEsGZ84AJ0+KTmkrK3Fl0LUrEBICdOlSr/t+OAEw45aSAuzYAezaBRw8KDoBLSzE2ViPHkC3bkDnzuI2ScZq07VrwOHDwKFDYrpzR3Q4t28P9OoFDBokfq9HdyBxAmDGJzYW+PNPYNs24MQJccndvbuo8Lt3F5U/PzjEDO3u3bJksHu3SAgNGwIDBwKhoUDfvuJZDiPGCYAZh7NngTVrgE2bxO19bm7iSxQaCvTpw2f4zPhdvFh24nLsGGBqKk5aXnwReP55o+xQ5gTADOfePSAqSlT8ly+L+7QjIoDBg0U7voGeU2KsxlJTRbPlpk0iKZiaAsOGAaNGiSuDCuMFGgonAFa3iESb/rx5wL594unZiAjgpZeATp0MHR1j+peeDvz6qzjR+ftv0Uw0YQIwcaLB70rjBMDqRnExsH49MGeOuFTu1w94/XWgf3/RkcbYk+DmTeCXX4BFi8RQI2PGAO+/L55QNgB+HwCrXQoFsHSpeCR//HigTRvg3DlxFTBkCFf+7MnSpAkwa5Z4MnnePGDvXvGkeXi4SA51jRMAqzWnTolmnYkTgeeeE09d/vILEBhYdzHI5XJ8//33aNOmDaysrGBvb4/g4GD89ddfVdp2+vTp8PX1hYWFBQYMGFC6LCcnBxKJRGU6duzYY8ucMmWKyjaaXhRz6tQpjB07Fo0bN4alpSWcnJzQsmVLPP/881i0aBHi4+MBAC1btlSLISIiorSckJAQlWXt2rVT29edO3cwZMgQZClfFvCvc+fOITQ0FA4ODrC1tUVISAiOHj362OPTZPv27fDz81N7UU5VpKenY/HixQgODoaTkxMsLS3h6+uLUaNGITY2Vm39adOmYcOGDVrLGzduHMzNzdG4cWO88847KCgo0DkmfbC0BP73P3Fr6a+/iudZWrQAPv1UjKhaZ4gxPcvKIoqMJDIxIerZk+jiRcPEUVJSQoMGDSKZTEY//vgjPXr0iG7evEnjxo0jiURC69evr3T7JUuWEAD67LPPKD09XeM6//zzDwEgADRgwIBKy3v06BHZ2NgQABo1apTacrlcTpMnTyapVEpTpkyhK1euUEFBASUlJdHu3bspJCSkdF/FxcVERJSUlETOzs4EgNauXatW5p9//km+vr6Um5urMXYXFxf68ccfVeYfP36cLC0t6YUXXqCEhARKSUmhCRMmkFQqpV27dlV6jOXFxcXR4MGDKTAwkOzs7MjU1LTK2yq9+uqrJJVK6fvvv6fExETKzc2lQ4cOUUBAAJmamtLmzZvV9tm4cWP68MMPtZaZlZVFixcvJgA0e/ZsnWOqDUVFRHPmENnaEvn4EO3eXSe7XcAJgOnV5ctE/v5EDRsSRUURKRSGi2XVqlUEgN566y2V+QqFgvz9/cnR0VFrxU5ENHLkSAJAWVlZWtf5559/yNLSkp566ikCQKdOndK67syZM6l58+ZaE8CMGTMIAC1dulTj9iUlJTRgwACVBEBEFBUVRQDI2dmZkpKSSuenpaWRt7c3HT16VK2szMxM8vLyosjISJX5crmcWrRoQe7u7pSXl6ey72bNmpG3tzcVFBRoPcbyRo4cSV9++SUVFxeTp6dntRPAa6+9pjb/3LlzBIB8fX01LpNIJLRhw4ZKy7aysqK+ffvqHFNtNP9+RgAAIABJREFUevCAKDxcnDx9+mmtf384ATD9OX2ayNmZqHNnovv3DR0N0dChQwkA7dZwOvXBBx8QAFq2bJnW7fv27fvYSuuff/4ha2trWrRoEQGgoUOHalwvPT2dnJycSpNSxQRw5coVMjExoaCgoEr39/fff6slACKiIUOGEAB6/vnnS+eNGjWKpk6dqrGcmTNnklQqpQcPHqjM379/v8akSUQ0a9YsAkAxMTGVxqhUPoFUNwFUxtLSkkxMTEihoZYMDw8nLy8vtX+n8jw8PB77720oixYRmZkRjR9PVFJSa7tZwH0ATC9u3RJ39gQFiY4tYxhdMzk5GQDQsGFDtWXu7u4AxDt8tZHL5VXe17hx4+Dp6Yk//vgD58+fV1v+ww8/YODAgVrfCbx06VIoFAqEh4dXup/OnTuDiNTa0xcvXgxHR0ds2rQJMTEx+P3333Hu3Dl89tlnamUQEZYvX46OHTuqvch93759AKCxv0A5b+/evZXGqGRZi4Pk5ObmIj8/v7QfpKLnnnsO9+/fx59//qm1DIlEUvrOZmPzv/8Bv/0GrF0LTJlSe/vhBMBqTKEARowQ46xv3mw8g2O5uLgAKEsE5aWkpAAAbt++rZd9mZubY8qUKSAizJ49W2VZTk4OfvzxR8yYMUPr9ocOHQIABFazh9zd3R3z5s0DALz55puYOHEiVq9eDXMNY2bExsYiOTkZrVu3Vlt29epVAICXl5faMs9/s/r169erFaM+bdy4EQAwc+ZMjcvbtGkDANi1a1edxaRvoaHAihXA998DW7fWzj44AbAaW7tWjN+zbp1xjcDZr18/AMC2bdvUlu3cuROAOJPUpqioSGMFqs1rr70GV1dXxMTE4MqVK6XzFyxYgODgYDRv3lzrtgkJCQAAZ2fnKu+vojFjxmDgwIF4+PAhmjZtiqCgII3rXbx4EYDmSj4jIwMAYK3hDTg2/47Hka58uYKBJCcnY9q0aRg/fjxGjBihcR1lslIeqybm5uYoLv+uSSP04ovAyJHAe++JEy194wTAauznn4GwMHE/szEZP348goKCsHjxYixYsACpqam4e/cuJk6ciAcPHgCovJni7t27GitJbSwtLfHee+9BoVDgiy++AADk5eVh3rx5Ws9UK6rpe3p9/32i6ODBg9iyZYvGdRL/fQ2avb29TmXTv8+MGupdwgCQmpqK/v37o2fPnli8eLHW9ezs7CCRSEqPVRMPDw88ePDAaJuBlD7+WLzk6OBB/ZfNCYDVCJEYK71/f0NHos7CwgL79+/HO++8gzlz5sDd3R0dO3YEEZU2Ibi5ualtl5aWhm+//RZ37tzBG2+8odM+33jjDTg7O2P9+vWIi4vDkiVL0KlTp8c27Sjb4h8pX0RcDYcPH8Zvv/2GuXPnAgD+97//aTxbV977LtPwZhMHBwcAmq+MlPOU69S13Nxc9OvXDwEBAYiKioKpqWml60ulUuTn52tdHhkZiaysLHz88cc1+nevbc2aiQfIjh/Xf9mcAFiNFBaK1+0ZqE54LFtbW3z77be4desWioqKkJiYiAULFpRWZs8884zK+mPHjoWzszOmTZuGqVOn4u2339ZpfzY2Npg0aRLkcjk++eQTzJkzBx9++OFjt+vRowcAaOxAroqcnByMHTsWS5cuxbvvvosBAwYgKSkJ77zzjtq6FhYWAKCx+cP/38u4+/fvqy1TXjX5+flVK8aaKCkpQXh4ODw9PbF69erHVv7KbSq7wnvppZcwe/ZsfPvtt2jQoAH6G+NZzL8cHcWb7vSNEwCrEQsLwMVFPOVbnyjv/hk+fLjK/FWrViEzMxPR0dGYO3cuIiMjdS77rbfegr29PdatW4fWrVtrvKOmosjISEilUsTExFS63tSpU2FiYlLaWav0/vvvIyQkpLQSW7JkCezs7LBmzRq1PhDlHVCZmZlq5ffq1QsAcObMGbVlynm9e/d+7PHoW2RkJAoLC/Hrr7+q3AHVtGlTHNdwapyVlQUiKj1WTWbOnIkZM2Zg0aJFyMjIKO0XMjZyubjLztu7FgqvtTtM2RNj9Giidu0M+9CXJikpKSSRSNTudc/MzCQ3NzeKiIiodPv27duTo6NjpesonwOo6NNPPyV7e3u1h7AOHz6s9UGwzz//nADQihUrNO7r6tWrZGdnRy+88ILK/J07d1Ljxo3VHlhbunQpASAPDw+VB96UTy+/8cYbavuQy+UUEBBAHh4elJ+fXzq/pKSEmjdvTt7e3irzq6omzwF88skn1LFjR8rOzlZb5uPjQ8eOHVObf/nyZQJAr7/+utZy/f39qXHjxtWKqS5t3UokkRDFxem9aH4QjNXc6dPiycU1awwdiaqUlBQCQH379qUbN25QQUEBnThxgjp37kytW7em1NTUSrfv3bt3lR8Eq6rKEgAR0bRp00gmk9EHH3xA165do8LCQrp//z4tX76c3N3dqWvXrpSTk1O6fnp6Onl7e9P+/fs1lqccPmLs2LGl8xQKBTVs2JC6dOmicZtjx46RhYUFRUREUGJiIj169IgiIyNJKpXSzp071dYfNWoUAaCbN29qPe6qJABN5axcubJ0+Attk6YEsG7dOgKgNlRExZhat25daUyGlp9PFBBANGxYrRTPCYDpx9tvE9nYEJ07Z+hIVO3Zs4eGDBlCbm5uZGlpSS1btqTPP/9c5SlVbUJCQiqttKytrVUqon79+lVanqbKq+I4PEREJ0+epNGjR5O3tzfJZDKytbWlTp060fz586mwsLB0PU9PT5Wyyj+FnJ6ernF/8+bNIyIx7ISmJ4GVzp49SwMGDCA7OzuysbGh4OBgOnLkiMZ1g4ODycbGhkoqPLK6detWrZW2piewNZUTGhparQQQHh5Onp6eVFRUpDFm5b9fmzZttC43NIVCXF07OhJVkltrghMA04+iIqLevYlcXMQVwX9BaGgoSSQSQ4dRKzIyMsjT01NtLCBdpaenk6WlJY0fP94oyiEqGwvocYP9ubq6UqdOnWq8v9pQXEz0yitiOAgNF136wkNBMP2QyYA//gDatRMvbv/lF0NHVHNeXl4gIo1PEtd39vb22Lp1K2JiYrBgwYJqlUFEePvtt2FnZ4fPP/+82rHoqxwAuHnzJoYPH47p06erDI1dUXFxMdLS0nR6zqOuJCeL10ZGRwO//y6GWKktnACY3lhZiRdiT5kCjBsn3u1765aho6o+5R01X331FVJTUw0cjf61bdsWp0+fxo4dO9TeB1AVycnJuHnzJvbu3avxeYq6LgcQdz/Nnj1bbTiO8jIzMzF37lwUFxcb1a2fROLEqVUr8b7sY8eAcq+gqK2dMqZ/Bw8StWxJZGlJ9MknojOrPvr666+pefPmZG5uTv379zd0OKyGxowZQzKZjJo2bUofffSRWr+FoZw9K0bRlUpFf1pmZp3sdgG/E5jVmuJiYP588ZYjZ2fg3XeBV18F/h1ShrEn3qlTwLffAps2AV27AgsWAC1b1tnu+Z3ArPbIZMDkycDVq8DQocDMmWLE0JkzgaQkQ0fHmGEQAX/+CfTsCXToIJpJN2wADhyo08ofAMBXAKzOpKUBixYBP/4oHmt/7jngpZdEJ1c1XhfLWL1y964YOfeXX4Dr10X7/uTJwL8PXxvCQk4ArM4VFABRUcDq1cCRI0DDhkBEBDB6tHihDGP/FVlZQEwMsGYNcOgQ4OQkPuuRkXV/tq8BJwBmWLduibOitWvFWZGfn7h7KDRUtIlqGLCSMaN27x6wfbu4I27vXtHkM3iwOMHp39+oPtOcAJjxOH5cvAZv2zbgyhXA3l40D4WGisvlBg0MHSFj6uRyMST6tm2i4j93DrC2Bvr0ERX/8OFGO1ouJwBmnG7/P3t3HhdV1f8B/DMwLCP7ouwWCsrmUmauuSAKLmkZmD6kaZEUpWluuGVZWk9ZtrlruTyaJv1s8TG1xwVF0VxAwx1cQUBA9nWW8/vjNMAwM8AMA3fQ7/v1uq+Be++c+70Dc753O+fcBg4e5EPh/fkn73a6QwcgJATo1w8YOBB44gmhoySPI7mcV/IJCcCJE/wo/+FD4MkneQOuUaN45f9Pr9vGjBIAMX4lJcCRI3xEpOPHgfPnAZkM8PXlrY6few7o2ZMPnNGIbuIJ0Ul+PnDuHHDyJP//S0wESksBV1f+vzdgADBkCFDPiJ/GihIAaX1KSviR1/HjPCmcOcPPEKytge7d+Y3kZ57hr507Ayb0sDNppIICXtnXnpRjXXh58TNP5UGHsQ2BqgdKAKT1k0qBv//mX9azZ/nr338DVVU8KXTrBgQE8CkwkB+pGWEXMKQFlZfz9imXLwOXLvF7Tn//XVPZu7vzA4jaUz1jy7RWlADIo6mqqiYpJCfzL3tKCpCTw5fb2dUkBD8/wMeH32Po2JH3aURaP8aAjAzg5k0+XbtWU+HfugUoFIC5Ob+UGBDAH8t8+ulHtrLXhBIAebzk5tYc8V26xCuEK1eAzMyadVxdeTJQJgTlz56evGKwsBAufqIqN5f/7W7f5kfvysr+5k1eyVdU8PUsLfkjxv7+POkrzwh9fIzqscyWRgmAEAAoK1OtPLRVJADg4sIvEXh41CSF9u35PDc3Pkays/NjXbE0WVER7xY5J4dX8OnpfMrM5C1qlfNq/11cXVUTdu3J3V24fTFilAAIaQhjNRXO/fu8oc/9+/zygvLn9HSeRGqzs+PJwtmZd4YnkdyDt7cX2rblz4Xb2gIODvzVzo6/2tryZ8gfBXI5r8jz8/lr7amggB+9K6cHD3hlr/y9qqqmHJGIV+7KpOvlxX/29OS/u7vzRzAlEsF2tbWiBECIoeTn807ulJVYTk5NpXbkyEdISfkUAQHXUFDgicJCXhFqYmqqmhxMTfnPQMOvAL9Epek+hqWl5koyP199nkIBFBbW/F5RwW+cNvRaWsr3q7CQ/6yJmRlPgMozJWdn3sivbVvVee3a8XmurnQ21UxWUxdchBiIg4NqRQwAcrkc77zzDlJSNuCbb75BTIzq40e1j46VSUE5KZfJ5fyImbGayvrmTf57QYF6ZV1aqnoErVRSwp+YAi4DOAtgEgDAxkZzZ3zK5APUJBULC8DcvBCXL0eiW7eP4ebWHW5uPLFYWvKnrpRnMspJmciUEx2pGw86AyCkmZSXlyM8PBzx8fHYuXMnRo0aJXRIAIDVq1djyZIlyFE+EqUjxhiee+45mJmZ4ciRIwaOjrQgGg+AkOZQXFyMESNG4PTp0zh8+LDRVP6GIBKJsGLFCsTHx2Pv3r1Ch0OagBIAIQZWUFCA0NBQXLlyBYcPH8azzz4rdEgG17t3b4wdOxazZ8+GlF9XIq0QJQBCDKigoABDhgxBeno6jh07hq5duwodUrP57LPPcPv2bWzcuFHoUIieKAEQYiDFxcUYPnw4cnJyEB8fj06dOgkdUrPq0KEDYmJi8MEHH6BI2yNNxKhRAiDEAMrKyjB69GjcvHkTBw4cgLe3t9AhtYhFixahoqIC3333ndChED1QAiCkiWQyGcLDw5GSkoLDhw/DvxX2C6wvR0dHTJs2DV9++SWKi4uFDofoiBIAIU0UExODY8eOYd++fQgMDBQ6nBY3c+ZMVFVVYd26dUKHQnRECYCQJli+fDm+//57/Oc//0HPnj2FDkcQTk5OeOutt7BixQqU1e0Pgxg1SgCE6CkuLg6LFi3CN998gxdeeEHocAQ1Z84clJaWYsOGDUKHQnRACYAQPVy+fBlTpkzB22+/jZiYGKHDEZyzszOmTp2Kzz77DJWVlUKHQxqJEgAhOiouLkZ4eDi6dOmCL774QuhwjMasWbOQk5ODn3/+WehQSCNRAiBER5MnT0ZBQQF+/vlnmJubCx2O0XB3d8eYMWOwZs0aoUMhjUQJgBAdbNq0Cb/88gt27twJt8dk3EBdvPXWW0hISMDFixeFDoU0AiUAQhrp1q1bmDlzJubMmYMBAwYIHY5RCg4ORkBAANauXSt0KKQRKAEQ0ghyuRwTJ05Ehw4d8OGHHwodjlF74403sG3bNuoeohWgBEBII6xbtw5nzpzBtm3bYEGjwtfr1VdfhVwux44dO4QOhTSAEgAhDXjw4AEWLVqEmTNnokuXLkKHY/QcHBwQHh6OLVu2CB0KaQAlAEIaMG/ePFhZWWHRokVCh9JqTJgwAadPn8atW7eEDoXUgxIAIfU4ffo0tmzZgpUrV8La2lrocFqNoUOHwtnZGbt27RI6FFIPSgCE1OP9999H3759ER4eLnQorYpYLMaYMWOwZ88eoUMh9aAEQIgWJ0+exMGDB7F06VKhQ2mVRo0ahbNnzyI7O1voUIgWlAAI0WLx4sXo168fgoODhQ6lVQoJCYG5uTn2798vdChEC0oAhGhw9uxZHD58GB999JHQobRaVlZW6N+/Pw4dOiR0KEQLSgCEaLB27VoEBARg0KBBepeRnJyMkSNHwt7eHjY2NggJCcGJEycMF6SA9u3bh06dOkEsFte7Xq9evXDmzBmdy8/Pz8fatWsRHBwMR0dHSCQS+Pr6IjIyEhcuXNA3bFIHJQBC6igpKcHOnTsRExMDkUikVxmnT59G3759YWNjgytXruDWrVvo0KEDBg0ahIMHDxo44paTlpaG0aNHY/78+Y26tv/MM8/g2rVrKCws1Gk7c+bMwbRp0zBmzBhcvnwZeXl5+P7775GcnIwePXrgl19+0XcXSC2UAAip4+DBgygvL0dERIRe71coFHj99ddhb2+PH374AW5ubnB2dsaaNWvQsWNHREVFtdo+8xcvXoy+ffvi3LlzsLGxaXD9nj17gjGGpKQknbf12muv4d1334WrqyvatGmD5557Djt27IBcLsfcuXP1CZ/UQQmAkDr27duHXr16oV27dnq9/9ixY7h06RLCw8MhkUiq55uammLChAm4d+8e9u7da6hwW9SmTZsQGxvb4KUfJQ8PDzg7OyMlJUWn7WzcuFHjGMPdunWDRCJBWloaGGM6lUnUUQIgpI5jx44hJCRE7/cfPnwYAL/8UZdyXmu9MVo7oTWWu7s7srKyDLL90tJSlJeXIygoSO/Lc6QGJQBCaikqKkJaWppa5X316lW88MILsLOzQ5s2bfDss89i7969CAkJgUgkgkgkQlRUVPW6AODp6alWvoeHBwDg+vXrzbwnjaPLfunL1dUVmZmZBtnW7t27AQALFy5sUkyEa9x5HCGPiUuXLkGhUKBbt27V81JTU9GnTx9YWVkhLi4Offr0wZ07dzBjxgxcvHgRFhYWqKioqF6/oKAAAH8Msi5ldxL5+fnNvCcN03W/9OXm5oa0tLQmbys7OxuxsbGIiorCuHHjmhwXoTMAQlRkZmZCJBLB3d29et6CBQtQUFCAr7/+GkOHDoW1tTUCAwOxY8cOlJaW6lS+8rq1MVy+MOR+1cfR0REpKSlN2lZeXh7CwsIwaNAgGmzGgCgBEFJLTk4OHBwcYGZmVj1P2ZI1NDRUZd22bdvCz89PrQx7e3sA0FixKecp1xGSrvulL5FIVH1WpM+2SktLERoaioCAAGzfvh2mpqYGi+1xRwmAkFoqKythaWmp8ntxcTEsLS019gbq4OCgNk9ZoaWnp6sty8jIAAB06tTJUCHrhTGm837pSyaTQS6X67UtmUyGiIgIeHh4YMuWLVT5GxglAEJqEYlEKo8XWlhYwMbGBhUVFSgpKVFb/8GDB2rzBg8eDAA4d+6c2jLlvCFDhhgqZL2IRCKd90tfpqamMDU11Wtb0dHRqKysxE8//aTy6KmPjw9OnTplsBgfV5QACKmlTZs2apduhg8fDgBqnZplZWVpfJpn4MCBCAgIQFxcnMqNTblcjp07d8LLywsjR45shuh1o+t+6auyshJOTk46b+uDDz7ApUuX8Ouvv9IwnM2EEgAhtbi5uaGoqEjlSHX58uVwdHTEjBkz8Oeff6KkpAQpKSmYMmUKXF1d1cowMTHBpk2b8PDhQ0yZMgVZWVnIy8vD22+/jRs3bmDDhg0ql5mEout+6Ss7Oxs9e/bUaVubN2/Ghx9+iNOnT8PGxqb6MVHllJaWZrD4HmeUAAipRfmc/t27d6vndezYEYmJiejZsyfCw8Ph4uKC6OhozJ8/Hz4+PhrL6d27N06ePInCwkJ07twZTz75JG7cuIGjR4+q3QgVij77tXfv3upKOCMjA3K5vPr3jRs3anxPVlaWztuKi4sz6L4SzagdACG1+Pv7w9zcHBcuXEBAQED1/E6dOuk8utVTTz2Fffv2GTpEg9J1v0aNGqVzFwzZ2dlwcXHRaVuttauM1obOAAipxdzcHP7+/jh//rzQoTwSFAoF7t+/r9KughgPSgCE1DFgwIDq/nxI06SlpaGsrAyBgYFCh0I0oARASB1hYWFISkqqtwOznTt3QiQS4dChQ6isrDRInznGwND79ffff8PExETlclpzbYvoTsSoT1VCVJSXl8PFxQXLly/HO++8I3Q4Brd69WosWbIEOTk5zb6tpUuXYtu2bbhx40azb4vobDWdARBSh0QiwdixY7Ft2zahQ2n1zp8/r9KxHjEulAAI0eDVV1/FX3/9pddIVoRTKBRISEjAgAEDhA6FaEEJgBANBg8ejO7du2PlypVCh9JqXbx4EXl5eRg4cKDQoRAtKAEQosXMmTOxc+dOpKamCh1Kq3T06FE4OjqiS5cuQodCtKAEQIgWkZGR8PPzowHI9XTw4EEMGjQIJiZUzRgr+ssQooWpqSlWrlyJPXv2tNoxfIVSXFyMw4cP44UXXhA6FFIPSgCE1GPIkCEICwvD7NmzoVAohA6n1di7dy8UCoVR9HpKtKMEQEgDVqxYgZSUFGzatEnoUFqNX375BQMHDoSjo6PQoZB6UAIgpAGBgYGYMWMGZs2aRTeEG6GoqAh79+5FeHi40KGQBlACIKQRPv74Y/j4+GDChAmQSqVCh2M0vvnmG0RHR+P+/fvV83bt2gWFQoFx48YJGBlpDEoAhDSChYUFtm/fjsuXL2Pp0qVCh9NoFy9ehL29PWxsbKqn2bNno7CwUGWera0txo8fr3P5169fx/r16+Ht7Y2ZM2ciMzMTmzdvxosvvmjQcYVJ86AEQEgj+fv744svvsAnn3yCo0ePalxH00DwQuratSscHBxQUlJSPZWXl0MqlarMKy4uxogRI3QuX3lJrKqqCqtWrYKXlxf++usvjBo1ytC7QpoBJQBCdPDmm2/ixRdfRHh4uNr9gNOnTyMoKMjoOj6bNGkSzMzM6l3H3Nxcr0c2a38GUqkUcrkcAO9KY+rUqcjIyNC5TNJyKAEQoqOtW7fC19cXYWFhyM3NBQCkpKRg2LBhKCwsxKJFiwSOUFVD9y3EYjFGjx4NW1tbncpljGk845HJZJDJZNi8eTO8vb0xffp0lXsExHhQAiBERxKJBHv27IFUKsXYsWNx9epVBAcHo6ysDACwe/duo+pEzs/PD0FBQRCJRBqXy+VyREZG6lzugwcPUFlZqXW5VCqFTCbDtm3bkJmZqXP5pPlRAiBED66urti7dy+Sk5PRq1cv5OfnQyaTAeBH1PPnzxc4QlWTJk2CqampxmUSiQRhYWE6l3n79u16l4vFYtjb2+Po0aPo0aOHzuWT5kcJgBA9eXl5wdnZGWVlZdWVP8CPfA8cOID4+HgBo1M1fvz46uvztZmZmWH8+PGwtLTUucxbt25pPasQi8WwtbXFsWPHaDwAI0YJgBA9lJWVITQ0FOnp6SqVv5JYLEZsbKwAkWnm5eWFPn36qHXMJpVK8a9//UuvMm/fvg1zc3O1+WZmZrC3t8fx48cRFBSkV9mkZVACIERHlZWVGDFiBJKSkrTeXJXJZDh16hT++OOPFo5Ou4kTJ6odsTs5OWHQoEF6lXf79m21/pHMzMzg7OyMxMREjeMAE+NCCYAQHUVFRSE+Pr7BFsGmpqaYN28ejGXY7XHjxqkkAHNzc0ycOFHrvYGGpKamqnwGZmZmaNeuHRISEuDj49PkeEnzowRAiI5WrVqFr776Cu7u7hCJRForULlcjpSUFMTFxbVwhJo5OjoiJCQEYrEYAG+8NWHCBL3Lq90GwMzMDJ6enjh16hQ6dOjQ5FhJy6AEQIiObG1t8e677+LevXv49ddf0a9fPwDQ2NhKJBJh3rx5Gu8TCOGVV16pvmzj5eWFnj176lUOY6z60U4zMzO0b98eCQkJ8PT0NFispPlRAiBETyYmJnj++ecRHx+Ps2fPYty4cTA1NVVJBAqFAnfu3MHWrVsFjLTGmDFjquObNGmS1qd4GpKZmYmqqiqIRCL4+voiMTER7u7uhgyVtAARM5YLlIQ8AtLT0/Hdd99hzZo1KC0tBWMMCoUCrq6uuHXrll6PW9ZWWQmUlQFSKVBSAsjlQFERX8YYUFCg+X1VVUBpKf955cpxSEzcjS++SIGXVyBMTAA7O83vs7AA2rThP5uZAdbWgKkpcPXqSYSF9UPXrl1x5MgR6ve/dVpNCYCQZlBWVoatW7dixYoVSEtLAwBMn74SoaEzUFwMFBbyqbi4Zioq4hV4cTGv3MvK+FRZCZSXAxUVhoruVwBLACQ3oYztAL4D8AcAeyg7/rSz4wnC3h6wtQVsbGomOzs+WVvXzLO3B5ycaiZlsiEtghIAIbrKywOysoD794HMTCA7G3jwgM9XTrm5yp8ZGNsPYAWAFACpMDGx0VgZ2tmpVppWVoClJSCR1ByJ1z4Kt7WF2tG7rS1fVlft9aqqqrB161ZERUUBqDmr0KSkhJ9t1F5PKgUSEo6gY8dnIJPZQKHgyQwA8vNrzkpqJ7iSEtWkV1JSc0ZSm0QCODvzZODsDLRtW5McnJ0BT0/AxQXw8ABcXQENzRBI41ECIESJMV6h37oF3L4N3LnDK/qMjJoKPytL9Ujc0pJXSO3a1VRStY9oa1dieXmXYGUlx7PPdhVsH5UYY3pf/zcUhYKf8agmzJqpdlLNzQVFOkk3AAAgAElEQVRycvhUW9u2/POvnRjc3YEnnwS8vfkkkQiye60BJQDyeCkqAq5dA27e5JX87ds1Ff7t2/woF+BH2p6evDJxdwfc3Pik/Fn5Spe+W1ZVVU1Szs4G0tPVXzMygIcPa97j4lKTEJ58suZnX1/giSf42dFjihIAeTTl5wOXLgGXL/PKXvnzrVv8SB8AHByADh00T+3bA/88Lk9aoYoKfsZ286b6lJZWc7Pc3Jwn+oAAIDCQ/+0DAoBu3fhluEccJQDSupWUABcuAMnJfEpKAq5cqbmm3bYt4OfHp06dAH9/oHNnfuTXwBgp5BH28CFw4wb/X7l2jU9XrvDkoLzn0b490KUL8NRTQPfu/NXbGxD4ypkhUQIgrUdhIXD6NHD+PK/ok5OB1FR+LdnBoeZLGhhYU+nTJRqiC5mMnyVcvcoTwoUL/H/txg1+c9vOjp8dKP/Xnn2WH1S00qRACYAYr/v3gRMngIQE/pqUxCt7NzdeyQcEAD168CkgoNV+CUkrUFXFk8C5czVTUhI/07SxAXr1Avr14/+LAwZob1dhZCgBEONx4wZw4ABw6BCQmMhv6llY8C9Vnz5A//781cVF6EgJ4WcLFy7wg5PERH6gkp7O7x099RT/fx02DBg40GifRKIEQIRTXAwcPswr/QMH+Km3rS0waBD/8vTtCzzzDE8ChLQG9+7VJISjR4GLF3nl/9xzQGgoEBbGz1aNBCUA0rIePAB+/hnYvZsfMcnlwNNP8y/HsGG80qenb8ij4v79mgOc//2Pt2nw8gJGjwZefplfNhLwMVRKAKT55ecDe/YAO3fyI35LS+D55/k0dCh/UoeQR51cDpw9C+zfzw+C/v6bP4IaEcGTQa9eLR4SJQDSfA4dAr77Dti3jx/ljBjB/9FHjaI+Xwi5dAnYtYtP16/zNghRUcAbb/AW5C2AEgAxrPJy4D//Ab75BkhJ4TfAoqKAMWMei4Y1hOglKQnYvh34/nveiC0yEpg2DejavL2GUAIghlFaCqxYAXz7LW+c9a9/AdOn8+elCSGNU1oKbNvGv0eXLwPBwcDHH/On35rB6se3FwxiEAoFsGULb127ciWv9O/e5UcyQlT++/btQ6dOnaqHPaxPcnIyRo4cCXt7e9jY2CAkJAQnTpxo8H1yuRzz58+Hr68vLC0tMXz48OplJSUlEIlEKlNiYmKDZc6ZM0flPR9//LHaOmfOnMHkyZPh7e0NiUQCR0dHBAUF4aWXXsKaNWuQlpaGU6dOqW3f3t5epZxffvlFZfmoUaNUlt+5cwejR49GkXKggSZ+Xpro8neqKz8/H2vXrkVwcDAcHR0hkUjg6+uLyMhIXLhwQW392NhY7Nq1S2t5U6ZMgYWFBby9vfHuu++iwnD9buvMygp4801+9nzwIO+2pF8/YMIE/r0yOEaInk6dYqxHD8ZMTRl7803GHjwQLpbU1FT2/PPPs65duzJbW1tmampa7/qnTp1iEomEvfzyy+z+/fssJyeHvfHGG0wsFrMDBw7U+95169YxAGzp0qUsPz9f4zpJSUkMAAPAhg8fXm95ubm5zNramgFgkZGRasvlcjmbPXs2E4vFbM6cOezKlSusoqKCZWVlsYMHD7KQkJDqbUmlUsYYY1OmTGEA2KRJkzRuMz09nbm4uLDbt2+rxe3s7My+/fZblflN+bxq0/XvpMnrr7/OxGIx++qrr1hmZiYrLS1lx44dYwEBAczU1JTt2bNHbZve3t5s0aJFWsssKipia9euZQDYsmXLdI6pOf3yC2O+voxJJIwtWsRYRYXBil5FCYDoTKFg7NNPGTMzY2zIEMb+/lvoiBibMGEC++STT5hUKmUeHh71VixyuZwFBgYyNzc3VlZWVj1fJpOxzp07My8vL1ZRz7dswoQJDAArKirSuk5SUhKTSCTsiSeeYADYmTNntK67cOFC5u/vrzUBLFiwgAFg69ev1/h+mUzGhg8frpIAcnNzmZOTEwPA4uPj1d4THh7OPvnkE5V5hYWFzNPTk0VHR6vMb+rnVZsufydtXn/9dTZ16lS1+cnJyQwA8/X11bhMJBKxXbt21Vt2mzZt2LBhw3SOqblVVjL25ZeM2dgw9vTTjN24YZBiKQEQ3UiljE2ezCv/FSt4MjAGtSumhiqWI0eOMABs2rRpass++OADBoDFxcVpff+wYcMarLiSkpKYlZUVW7NmDQPAxowZo3G9/Px85ujoyDZv3qwxAVy5coWZmJiwHj161Lu9kydPqiQAxhjbuHEjA8ACAwNZVVVV9fw//viDBQQEqMxjjCcisVjMMjIyVOY39fOqTZe/kz4kEgkzMTFhCg3/mBEREczT01PlM6rL3d29wc9aSNev8wTg7MzY6dNNLm4V3QMgjcYYf0Rt927gt9+AWbOMp/8diQ5t7Q8fPgwAeOaZZ9SWKecdOnRI6/vlcnmjtzVlyhR4eHjgt99+w8WLF9WWf/PNNxgxYgQ6duyo8f3r16+HQqFAREREvdvp06cPGGMq19Rfe+019OvXD5cuXcLKlSsBABUVFZg2bRpWr16tMng9YwwbN25Er1691AZ3b+rnVZsufyddlZaWory8HEFBQRoHu3nxxReRnp6O//73v1rLEIlEkMlkzRZjU/n6AseP8zYDQ4fytgRNQQmANNqqVfwRz7g43qS9tbp69SoAwNPTU22Zh4cHAOD69esG2ZaFhQXmzJkDxhiWLVumsqykpATffvstFixYoPX9x44dAwB01eN5QJFIhDVr1kAsFmPp0qW4e/culi9fjr59+2LgwIEq6164cAHZ2dno1q2bWjkt+Xk1xe7duwEACxcu1Li8+z9PJRw4cKDFYmoObdoA//d/vAX9mDGah9ZsLEoApFFyc4GFC4HY2NZd+QNAwT+jgVhZWakts7a2BsCfNNGmqqoKFjp0UDR16lS4uLggLi4OV65cqZ6/atUqBAcHw9/fX+t779+/DwBwcnJq9PZq69KlC2bMmIHS0lJERkZiw4YN+Pzzz9XWS0lJAaC5km/q59USsrOzERsbi6ioKIwbN07jOspkpdxXTSwsLCBVDghgxMzNeQOyggLgk0/0L4cSAGmUnTv5JaDYWKEjaV7sn2Yx9Y2Xe/fuXY0VpTYSiQTvvfceFAoFli9fDgAoKyvDypUrtR6t1tWU8Xs/+OADeHl5ISEhAYsWLUK7du3U1snMzAQA2OnYj3FjPq/mlpeXh7CwMAwaNAhr167Vup6trS1EIlH1vmri7u6OjIwMo74MpNSuHTBjBrBxI++ZVB+UAEijJCYCgwfz55RbO+Vz8aUazp2V8+o+Ow8ADx8+xOeff447d+4gJiZGp23GxMTAyckJP/74I1JTU7Fu3Tr07t27wUs7yuvxubm5Om2vNisrKwwYMAAANF7iAVD97LuZhmHS9P28WkJpaSlCQ0MREBCA7du3w9TUtN71xWIxysvLtS6Pjo5GUVER3n///SZ95i3l+ed5t+lpafq9nxIAaZT8/EdndC0/Pz8AQHp6utqyjIwMAECnTp1U5k+ePBlOTk6IjY3F3LlzMX36dJ22aW1tjRkzZkAul2PJkiVYsWIFFi1a1OD7lNfqNd1ANiRLS0sA0Hj5Q5/PqyXIZDJERETAw8MDW7ZsabDyV76nvhvRr7zyCpYtW4bPP/8cbdu2RZiRX+9UXhnU9wocJQDSKF5efMCWR8HgwYMBAOfOnVNbppw3ZMgQlfmbN29GYWEhdu7ciS+//BLR0dE6b3fatGmws7PDjh070K1bN41P1dQVHR0NsViMuLi4etebO3cuTExMqm/Y6srNzQ0AUFhYqLZMn8+rJURHR6OyshI//fSTytNPPj4+OHXqlNr6RUVFYIxV76smCxcuxIIFC7BmzRoUFBRg//79zRK7oVy7xl/bt9ezgCY/SUoeC7//zpiJCWNXrggdScMa0xAsICCAubu7s/Ly8ur5MpmM+fv7My8vL5X5dfXs2ZM5ODjUG4OyHUBdH374IbOzs2MnTpxQmX/8+HGtDcE++ugjBoBt2rRJ47auXr3KbG1t2csvv6w1nsjISAaAHT9+XGu8AFhMTIzasqZ+Xto0pR3AkiVLWK9evVhxcbHaso4dO7LExES1+ZcvX2YA2FtvvaW1XD8/P+bt7a1XTEL4178Ye+YZvd9ODcFI40iljHXrxlv+ymRCR1O/xlQsiYmJzNLSko0fP55lZmay3NxcFh0dzcRiMdu/f3+97x0yZEijG4I1Vn0JgDHGYmNjmZmZGZs3bx67du0aq6ysZOnp6Wzjxo3Mzc2N9e/fn5WUlGgtv6EEoFAoWLt27Vi/fv00Ltf181Ju7+bNm1pjaszfSVM5P/zwQ3XXF9omTQlgx44dDIBaVxF1Y+rWrVu9MRmLQ4cYE4kYa2QbPE0oAZDGO3OG90fyzjvG0wJY6ffff9daGWzYsEHje86fP8+GDx/ObG1tmbW1NQsODmYJCQkNbiskJKTeisvKykpl+6GhofWWpynmun3xMMbYX3/9xSZOnMi8vLyYmZkZs7GxYb1792Zff/01q6ys1Fi2siVy3UlTa9gFCxZobAmspMvnFRwczKytrZmsztGCrn8nTeWMHDlSrwQQERHBPDw81FpA1+bh4cG6d++udbmxuHqVMScnxsaNa1IxlACIbuLiGBOLGXv9dcbq+R490kaOHMlEIpHQYRhcQUEB8/DwUOsLSFf5+flMIpGwqKgooyiHsZq+gH788cd613NxcWG9e/du8vaaU2IiY23bMtavH2O1etbQB3UFQXTz0kvAL7/wdgHPPQfcuiV0RC3P09MTjDFkZ2cLHYpB2dnZ4ffff0dcXBxWrVqlVxmMMUyfPh22trb46KOP9I7FUOUAwM2bNzF27FjMnz8f48eP17qeVCrFw4cPdWrj0ZIY412uDxzIu4I4eJAPON8UlACIzkaOBM6dAyorgcBA3jisuFjoqFqO8tHATz/9FHl5eQJHY1hPPfUUzp49iz/++ENtPIDGyM7Oxs2bN3Ho0CG4urrqHYehygGAdevWYdmyZWpdcdRWWFiIL7/8ElKp1Cgf/TxzBujfH5g7F5g/H/j1VwMNq2qIUxLyeKqqYuyrrxizt2fM3Z2xdesYk8uFjqpl/Pvf/2b+/v7MwsKChYWFCR0OaYJXX32VmZmZMR8fH7Z48WK1+xZCunePsYkT+c3e4GDGkpMNWvwqGhKSNFlODvD++8CGDYC/Px8V7JVXmn56Ssjj6sIFPizk9u28Dc6KFcDo0QbfDA0JSZqubVtgzRr+T9uzJ08AXl780lCzDGNHyCNILue9fA4ezIdTPXUK+PprPjxkM1T+AAA6AyAGl5MDrF8PrF4NPHgADBsGjB/Pu661tRU6OkKMy/nz/KGKnTuBjAx+j236dGDIkGYfb2M1JQDSbKRSYM8ePobAgQOAiQkwfDjw8su8EyuD3MQipBW6dIl357xzJ+9ipUMHfpD02muAlrGBmgMlANIy8vNrHh89fBiwsACCg4HQUD75+AgdISHNp7wciI/nB0L79wNXrwKensC4cfyA6NlnBQmLEgBpeTk5/Mxg/37g0CGgqIgf9SiTQXAw8M84I4S0Wpcu8Qr/wAHg2DGgogLo2pX/jz//PNCvHz8rFhAlACIsuRxITgb+9z/g99/5uAMiEdC5M3/uuV8/oEcP3t6AEGMlk/GHIBISgBMn+NH+gwe8u+bgYCAkhF/+9PISOlIVlACIccnJAY4e5V+ikyeBpCT+5fLy4smgb1+eELp2pbMEIpybN/mBS2Ii/z9VNox0deX/o/3786lHD8GP8utDCYAYt7Iy3goyIYF/0RIT+f0EExPA15c/Lte9O/DUU/zVxUXoiMmjRCrll3KSk1WnwkL+PxgQwA9MlAcnLXgD1xAoAZDW59YtfmZQ+wt57x5f5uYGBAXxS0j+/vy1c2d+w40QbcrL+eAq167xG7TK6fJloKqKN2oMCqo50OjeHejSpdWfhVICII+GvLyapHDlCp+uXQMePuTLbWxqkoG/P3/s7skn+VTPAFHkEVJeDty+XTMpK/tr14A7d3hna2Ix/9/w8+NT1668su/cmS97xFACII+2nJyaZHDtWs3Pd+/y03sAsLSsSQa1p/bt+ZmDiwtgbi7YLpBGevgQyMwE0tNVK3rllJVVs66DA7+EWPss0d+fX8J5jP7WlADI40kuV60obt1S/Tkjg6+j5OLCJ2VC8PTkN/w8PYF27Xh3GG3bUktnQ6uq4md3eXn8qZqMDF7J379f86qcKipq3mdnp5rMvb1Vf7ezE2JvjA4lAEI0kUp5pZKRwY8c61Y8yvl1e4M2M+OP/tWd2rblr3Z2NZONDb+GbGNTM8+InxjRW2kpUFLCuwwvLORTcTGfiopqKvi8PCA3l7/m5PDXut2MW1ioJmAPD/VXDw9+hE8aRAmAkKaoqACys3nFpay8NFVoKSmfQqEYiIqKPigs1F6elVVNYrCzA0xN+VmFSATY2/N17O3578qEYWOjen1auVxT2ZoubxQVqZ7tKJWV8UcblYqL+SO5paX8yLy8nO9/RQX/uaqqZlntyl6h0LyvFhZ83zQlTGdnPtVNom3bav/siM5WP3q3NQhpQZaWwBNP8EkTuVyOd955B4cPb8D69evx2mt9AKgeBSuPhAsKVOcVF/MzkZISXkEXFfEblcpR2PLzUV2WspJVrqdJzXqXAZwFMAkA75PJwkJ9fTMz1adclAnEzKwQqamR8Pf/GK6u3WFjw2+ki8U1ycjGhh+F29jwydZW9UzHxuaxutZutOgMgJBmUl5ejgkTJuDgwYP48ccfMWbMGKFDAgCsXr0aS5YsQU5Ojl7vZ4zhueeeg5mZGY4cOWLg6EgLovEACGkOJSUlGDFiBBISEnDo0CGjqfwNQSQSYcWKFYiPj8fevXuFDoc0ASUAQgyssLAQoaGhuHz5Mg4fPow+ffoIHZLB9e7dG2PHjsXs2bMhVT5PS1odSgCEGFBBQQGGDh2KO3fuID4+Hl27dhU6pGbz2Wef4fbt29i4caPQoRA9UQIgxECUl32ysrIQHx8PPz8/oUNqVh06dEBMTAw++OADFGm780yMGiUAQgygvLwco0ePRmpqKg4cOICOraxXMH0tWrQIFRUV+O6774QOheiBEgAhTSSTyRAeHo4LFy7g0KFD8Pf3FzqkFuPo6Ihp06bhyy+/RHHdVlvE6FECIKSJYmJiEB8fjz/++ANdunQROpwWN3PmTFRVVWHdunVCh0J0RAmAkCb49NNPsWnTJvznP//BswIN7Co0JycnvPXWW1ixYgXKysqEDofogBIAIXravXs3FixYgK+++govvPCC0OEIas6cOSgtLcWGDRuEDoXogBIAIXq4dOkSXnvtNbz99tuYNm2a0OEIztnZGVOnTsVnn32GytodCBGjRgmAEB0VFxcjIiICXbp0wRdffCF0OEZj1qxZyMnJwc8//yx0KKSRKAEQoqPJkycjPz8fP//8M8ypR7Nq7u7uGDNmDNasWSN0KKSRKAEQooMNGzbg119/xa5du+BGY0mqeeutt5CQkICLFy8KHQppBEoAhDTSrVu3MGvWLMydOxcDBgwQOhyjFBwcjICAAKxdu1boUEgjUAIgpBEUCgWmTJmC9u3b4/333xc6HKP2xhtvYNu2bdQ9RCtACYCQRli9ejUSExOxY8cOWFpaCh2OUXv11Vchl8uxY8cOoUMhDaAEQEgDHjx4gMWLF2PWrFmPdO+ehuLg4IDw8HBs2bJF6FBIAygBENKAefPmwdraGgsWLBA6lFZjwoQJOH36NG4px68kRokSACH1OH36NLZs2YKVK1fCuvYAuaReQ4cOhbOzM3bt2iV0KKQelAAIqcfixYvRr18/hIeHCx1KqyIWizFmzBjs2bNH6FBIPSgBEKLFyZMn8eeff2Lp0qVCh9IqjRo1CmfPnkV2drbQoRAtKAEQosXixYvRv39/DB48WOhQWqWQkBCYm5tj//79QodCtKAEQIgGZ8+exeHDh+novwmsrKzQv39/HDp0SOhQiBaUAAjRYO3atQgICMCgQYP0LiM5ORkjR46Evb09bGxsEBISghMnThguSAHt27cPnTp1glgsrne9Xr164cyZMzqXn5+fj7Vr1yI4OBiOjo6QSCTw9fVFZGQkLly4oG/YpA5KAITUUVJSgp07dyImJgYikUivMk6fPo2+ffvCxsYGV65cwa1bt9ChQwcMGjQIBw8eNHDELSctLQ2jR4/G/PnzG3Vt/5lnnsG1a9dQWFio03bmzJmDadOmYcyYMbh8+TLy8vLw/fffIzk5GT169MAvv/yi7y6QWigBEFLHwYMHUV5ejoiICL3er1Ao8Prrr8Pe3h4//PAD3Nzc4OzsjDVr1qBjx46IiopqtX3mL168GH379sW5c+dgY2PT4Po9e/YEYwxJSUk6b+u1117Du+++C1dXV7Rp0wbPPfccduzYAblcjrlz5+oTPqmDEgAhdezbtw+9evVCu3bt9Hr/sWPHcOnSJYSHh0MikVTPNzU1xYQJE3Dv3j3s3bvXUOG2qE2bNiE2NrbBSz9KHh4ecHZ2RkpKik7b2bhxo8Yxhrt16waJRIK0tDQwxnQqk6ijBEBIHceOHUNISIje7z98+DAAfvmjLuW81npjtHZCayx3d3dkZWUZZPulpaUoLy9HUFCQ3pfnSA1KAITUUlRUhLS0NLXK++rVq3jhhRdgZ2eHNm3a4Nlnn8XevXsREhICkUgEkUiEqKio6nUBwNPTU618Dw8PAMD169ebeU8aR5f90perqysyMzMNsq3du3cDABYuXNikmAjXuPM4Qh4Tly5dgkKhQLdu3arnpaamok+fPrCyskJcXBz69OmDO3fuYMaMGbh48SIsLCxQUVFRvX5BQQEA/hhkXcruJPLz85t5Txqm637py83NDWlpaU3eVnZ2NmJjYxEVFYVx48Y1OS5CZwCEqMjMzIRIJIK7u3v1vAULFqCgoABff/01hg4dCmtrawQGBmLHjh0oLS3VqXzldWtjuHxhyP2qj6OjI1JSUpq0rby8PISFhWHQoEE02IwBUQIgpJacnBw4ODjAzMysep6yJWtoaKjKum3btoWfn59aGfb29gCgsWJTzlOuIyRd90tfIpGo+qxIn22VlpYiNDQUAQEB2L59O0xNTQ0W2+OOEgAhtVRWVqoM+FJZWYni4mJYWlpq7A3UwcFBbZ6yQktPT1dblpGRAQDo1KmToULWC2NM5/3Sl0wmg1wu12tbMpkMERER8PDwwJYtW6jyNzBKAITUIhKJVB4vtLCwgI2NDSoqKlBSUqK2/oMHD9TmKfsOOnfunNoy5bwhQ4YYKmS9iEQinfdLX6ampjA1NdVrW9HR0aisrMRPP/2k8uipj48PTp06ZbAYH1eUAAippU2bNmqXboYPHw4Aap2aZWVlaXyaZ+DAgQgICEBcXJzKjU25XI6dO3fCy8sLI0eObIbodaPrfumrsrISTk5OOm/rgw8+wKVLl/Drr7/CwsLCYPGQGpQACKnFzc0NRUVFKkeqy5cvh6OjI2bMmIE///wTJSUlSElJwZQpU+Dq6qpWhomJCTZt2oSHDx9iypQpyMrKQl5eHt5++23cuHEDGzZsMIpxhXXdL31lZ2ejZ8+eOm1r8+bN+PDDD3H69GnY2NhUPyaqnNLS0gwW3+OMEgAhtSif07979271vI4dOyIxMRE9e/ZEeHg4XFxcEB0djfnz58PHx0djOb1798bJkydRWFiIzp0748knn8SNGzdw9OhRtRuhQtFnv/bu3VtdCWdkZEAul1f/vnHjRo3vycrK0nlbcXFxBt1Xohm1AyCkFn9/f5ibm+PChQsICAiont+pUyedR7d66qmnsG/fPkOHaFC67teoUaN07oIhOzsbLi4uOm2rtXaV0drQGQAhtZibm8Pf3x/nz58XOpRHgkKhwP3791XaVRDjQQmAkDoGDBhQ3Z8PaZq0tDSUlZUhMDBQ6FCIBpQACKkjLCwMSUlJ9XZgtnPnTohEIhw6dAiVlZUG6TPHGBh6v/7++2+YmJioXE5rrm0R3YkY9alKiIry8nK4uLhg+fLleOedd4QOx+BWr16NJUuWICcnp9m3tXTpUmzbtg03btxo9m0Rna2mMwBC6pBIJBg7diy2bdsmdCit3vnz51U61iPGhRIAIRq8+uqr+Ouvv/QayYpwCoUCCQkJGDBggNChEC0oARCiweDBg9G9e3esXLlS6FBarYsXLyIvLw8DBw4UOhSiBSUAQrSYOXMmdu7cidTUVKFDaZWOHj0KR0dHdOnSRehQiBaUAAjRIjIyEn5+fjQAuZ4OHjyIQYMGwcSEqhljRX8ZQrQwNTXFypUrsWfPnlY7hq9QiouLcfjwYbzwwgtCh0LqQQmAkHoMGTIEYWFhmD17NhQKhdDhtBp79+6FQqEwil5PiXaUAAhpwIoVK5CSkoJNmzYJHUqr8csvv2DgwIFwdHQUOhRSD0oAhDQgMDAQM2bMwKxZs+iGcCMUFRVh7969CA8PFzoU0gBKAIQ0wscffwwfHx9MmDABUqlU6HCMxjfffIPo6Gjcv3+/et6uXbugUCgwbtw4ASMjjUEJgJBGsLCwwPbt23H58mUsXbpU6HAa7eLFi7C3t4eNjU31NHv2bBQWFqrMs7W1xfjx43Uu//r161i/fj28vb0xc+ZMZGZmYvPmzXjxxRcNOq4waR6UAAhpJH9/f3zxxRf45JNPcPToUY3raBoIXkhdu3aFg4MDSkpKqqfy8nJIpVKVecXFxRgxYoTO5SsviVVVVWHVqlXw8vLCX3/9hVGjRhl6V0gzoARAiA7efPNNvPjiiwgPD1e7H3D69GkEBQUZXcdnkyZNgpmZWb3rmJub6/XIZu3PQCqVQi6XA+BdaUydOhUZGRk6l0laDiUAQnS0detW+Pr6IiwsDLm5uQCAlJQUDBs2DIWFhVi0aOnvC1MAACAASURBVJHAEapq6L6FWCzG6NGjYWtrq1O5jDGNZzwymQwymQybN2+Gt7c3pk+frnKPgBgPSgCE6EgikWDPnj2QSqUYO3Ysrl69iuDgYJSVlQEAdu/ebVSdyPn5+SEoKAgikUjjcrlcjsjISJ3LffDgASorK7Uul0qlkMlk2LZtGzIzM3UunzQ/SgCE6MHV1RV79+5FcnIyevXqhfz8fMhkMgD8iHr+/PkCR6hq0qRJMDU11bhMIpEgLCxM5zJv375d73KxWAx7e3scPXoUPXr00Ll80vwoARCiJy8vLzg7O6OsrKy68gf4ke+BAwcQHx8vYHSqxo8fX319vjYzMzOMHz8elpaWOpd569YtrWcVYrEYtra2OHbsGI0HYMQoARCih7KyMoSGhiI9PV2l8lcSi8WIjY0VIDLNvLy80KdPH7WO2aRSKf71r3/pVebt27dhbm6uNt/MzAz29vY4fvw4goKC9CqbtAxKAIToqLKyEiNGjEBSUpLWm6symQynTp3CH3/80cLRaTdx4kS1I3YnJycMGjRIr/Ju376t1j+SmZkZnJ2dkZiYqHEcYGJcKAEQoqOoqCjEx8c32CLY1NQU8+bNg7EMuz1u3DiVBGBubo6JEydqvTfQkNTUVJXPwMzMDO3atUNCQgJ8fHyaHC9pfpQACNHRqlWr8NVXX8Hd3R0ikUhrBSqXy5GSkoK4uLgWjlAzR0dHhISEQCwWA+CNtyZMmKB3ebXbAJiZmcHT0xOnTp1Chw4dmhwraRmUAAjRka2tLd59913cu3cPv/76K/r16wcAGhtbiUQizJs3T+N9AiG88sor1ZdtvLy80LNnT73KYYxVP9ppZmaG9u3bIyEhAZ6engaLlTQ/SgCE6MnExATPP/884uPjcfbsWYwbNw6mpqYqiUChUODOnTvYunWrgJHWGDNmTHV8kyZN0voUT0MyMzNRVVUFkUgEX19fJCYmwt3d3ZChkhYgYsZygZKQR0B6ejq+++47rFmzBqWlpWCMQaFQwNXVFbdu3dLrccvaysuBigqgshIoKwOkUqCkhC+Ty4GiIs3vU64PACtXjkNi4m588UUKvLwCYWIC2Nlpfp+5OWBlxX82NQVsbQGRCLh+/STCwvqha9euOHLkCPX73zqtpgRASDMoKyvD1q1b8fnnK3DzZhoA4O23V2Lo0BkoLuaVdmEhn4qLoXFeVRV/lcmA0lL+u2H8CmAJgOQmlLEdwHcA/gBgD1tbniCsrQEzM55QbGz47zY2/Hc7u5rfa8+zswOcnIC2bbUnItIsKAEQogupFHjwAMjIALKygPv3+e95eapTTg5/LS5mAPYDWAEgBUAqLCxsYG2tWikqK0Z7+5oK0tKSH32bmwMSCf/dwgJo04ZXstbWNUflSnZ2gKYx2Gsf5VdVVWHr1q2Iior653eeYDSpnXiUZxtyOXDs2BF06vQMKittAAAFBQBj/AxELgfy8/m6ysRWVMTXqT2vsFB9e2IxTwZOToCzc83Pbdvy39u1Azw8AFdXwN2dEkYTUQIgRKm8HLh9u2a6fx9IT+cVfHo6kJ3Nf679jXFwAFxcaiqquhVW7Xm5uZfQpo0cPXp0FWgPazDG9L7+b0jKM57c3JqkWXdSLsvN5Z9/7TMhiYQnAje3msndHWjfHnjyST65uQm1d0aPEgB5fCgUvGK/cUO1oldOWVk16zo48CPN2kebytfaFU0TL+kTPSgTsTIpZ2TUvGZl8deMDH7pDOB/I2UyqD116AB07qx6BvWYoQRAHj2VlUBqKnD5MnDzJnDpEv/56tWaSx2WlrwC79BB80SDWbV++fn8769punu3JkE4OPC/eUAAEBhY87OfH7/E9gijBEBaL7mcH80nJ9dMf//NL90A/Nq5ry8/ylNOfn5Ap05UwT/upFLgzh3g2jV+YHD9Ov/5yhV+dgHwgwQ/P6BbN6B795rJ3l7Y2A2IEgBpHWQy4OJF4OxZICmpprIvLeU3RP38+Jeza1fA359X9t7ej/wRHGkG+fk8IVy9ys8elQcXOTl8ubd3TVJ46imgd29+c7oVogRAjFNREfDXX0BCAnDuHH8tKOBPx3TqxE/Re/SomSQSoSMmj7r8fJ4Qzp2rma5e5feW3NyA/v2Bfv34/2OvXvzAxMhRAiDGIS8P+PNP4H//A06e5F8sxviRfJ8+/IvVpw8/utf0mCMhQigsBBIT+XTyJHD6NH/M1daWJ4GBA4HQUODpp43y/5YSABGGTAacOgUcOMCnc+f4F6R3b+C553hl36cPf5SSkNZCLueXJk+c4P/fhw4BmZn8/3joUGDYMJ4QjOTRVEoApOWUlQH//S/w00/8aL+wkF9PDQ3lX4zgYGrYQx4tjPGEcOAAcPAgv5RZWQl06QK8+CIwbhy/nCkQSgCkeVVUAH/8wSv933/nvw8eDIwZwyt+X1+hIySk5ZSVAfHx/Dvx88/8ibUuXXgiePnlFv8+UAIgzePCBeDbb4Hdu3mz/+ee4//k4eGt9okJQgxKoeBnBLt2AXFx/PHTp58G3nwTiIzkXX40M0oAxHDkcuDXX3nFf/Qov2EbHQ1ERPBGV4QQzeRy/p3ZupUnBCsrICoKiIkBnnii2Ta72vjuS5NWRyYD1qwBOnbklb2NDb/eeekS8O67VPkT0hBTU2DIEGDLFt5K+b33gO3b+Xdq3DjeSK05UAIgTbJvH28UM2MGv65//Trw22/8iQch+hrbt28fOnXqVD3soaHXB/hQj/Pnz4evry8sLS0xfPjw6mUlJSUQiUQqU2JiYoNlzpkzR+U9H3/8sdo6Z86cweTJk+Ht7Q2JRAJHR0cEBQXhpZdewpo1a5CWlla9blBQkFocmiYTExNk1e4E6R937tzB6NGjUVRngIHk5GSMHDkS9vb2sLGxQUhICE6cONHoz642fT57pfz8fKxduxbBwcFwdHSERCKBr68vIiMjceHCBbX1Y2NjsWvXLq3lTZkyBRYWFvD29sa7776LiooKnWMylHbtgIULgVu3eBK4do3fJ5g+nT8ubVCMED1cu8bY0KGMAYyFhzOWmipsPKmpqez5559nXbt2Zba2tszU1NSg69e2bt06BoAtXbqU5efna1wnKSmJAWAA2PDhw+stLzc3l1lbWzMALDIyUm25XC5ns2fPZmKxmM2ZM4dduXKFVVRUsKysLHbw4EEWEhJSvS2pVMoYYywwMJDt2bNH4/bKy8tZQEAAA8Dee+89jbE7Ozuzb7/9VmX+qVOnmEQiYS+//DK7f/8+y8nJYW+88QYTi8XswIED9e5jbU357JVef/11JhaL2VdffcUyMzNZaWkpO3bsGAsICGCmpqZq+56amsq8vb3ZokWLtJZZVFTE1q5dywCwZcuW6RxTc5HJGNuwgTFXV8YcHBj76ivG5HKDFL2KEgDR2Q8/MGZlxdjTTzN2/LjQ0XATJkxgn3zyCZNKpczDw6PBSkXX9eu+FwArKirSuk5SUhKTSCTsiSeeYADYmTNntK67cOFC5u/vrzUBLFiwgAFg69ev1/h+mUzGhg8f3ugEMH36dAaABQUFsYqKCpVlhYWFzNPTk0VHR6vMl8vlLDAwkLm5ubGysjKVbXfu3Jl5eXmplaVNUz57pddff51NnTpVbX5ycjIDwHx9fTUuE4lEbNeuXfWW3aZNGzZs2DCdY2puxcWMLVzImLk5YyEhjGVmNrlISgCk8RQKxubPZ0wkYmzuXMaqqoSOqEbtSqkxlYqu69c2bNiwBtdPSkpiVlZWbM2aNQwAGzNmjMb18vPzmaOjI9u8ebPGBHDlyhVmYmLCevToUe/2Tp48qZIAtDl48CATiUTMwsKCXbhwQW35woULmVgsZhkZGSrzjxw5wgCwadOmqb3ngw8+YABYXFxcvdtWaspn3xgSiYSZmJgwhUKhtiwiIoJ5enrW+zm5u7s3+HkL6exZxnx8GPP2Zuzq1SYVtYruAZBGW7QIWLEC2LwZ+Pe/jauvE4mOnQHpun5tcrm80etOmTIFHh4e+O2333Dx4kW15d988w1GjBiBjh07anz/+vXroVAoEBERUe92+vTpA8ZYvdfTHz58iMmTJ4MxhmXLlqFrV9WBaRhj2LhxI3r16qU2wPvhw4cBAM8884xaucp5hw4dqjdGpaZ89g0pLS1FeXl59T2Qul588UWkp6fjv//9r9YyRCIRZMq+oo1Qjx68lbGLC29Tc/eu/mVRAiCN8vPPwCefABs2AJMmCR1N62FhYYE5c+ZUV7q1lZSU4Ntvv8WCBQu0vv/YsWMAoFZZ6yM6Ohr379/HoEGD8N5776ktv3DhArKzs9GtWze1ZVevXgUAeHp6qi3z8PAAAFy/fr3JMTbV7t27AQALFy7UuLx79+4AgAMHDrRYTM3ByYm3Lm7blrco1jdfUQIgDaqo4I9zvvYa8OqrQkcjvKqqKlhYWDR6/alTp8LFxQVxcXG4cuVK9fxVq1YhODgY/v7+Wt97/5/BDZycnPQPGMDWrVsRFxcHe3t7bN26VePRcUpKCgDNlXxBQQEAwMrKSm2ZtbU1AP5kjpCys7MRGxuLqKgojBs3TuM6ymSl3FdNLCwsIJVKmyVGQ7K15Q3ILl8G1q7VrwxKAKRBv//Oh9z76COhIzEOd+/e1VhJaiORSPDee+9BoVBg+fLlAICysjKsXLlS65FqXU0Zv/f27duYNm0aAGD16tXw8vLSuF5mZiYAwE7HDpnYP21JhRxjOC8vD2FhYRg0aBDW1lMb2traQiQSVe+rJu7u7sjIyDDqy0BKvr78wIwSAGk2J08CzzxjND0YCubhw4f4/PPPcefOHcTExOj03piYGDg5OeHHH39Eamoq1q1bh969ezd4aUd5LT43N1evmBUKBSZNmoSioiJMmDABEyZM0Lqu8tl3Mw03d+z/GQarVDmmZi3KefYCDZVVWlqK0NBQBAQEYPv27TBtYBQgsViM8vJyrcujo6NRVFSE999/X+/PvSU9/zxvdPnPSZpOKAGQBuXnA46OQkchrMmTJ8PJyQmxsbGYO3cupk+frtP7ra2tMWPGDMjlcixZsgQrVqzAokWLGnzfwIEDAUDjDeTG+Oyzz3D8+HF4eXlh9erV9a5r+c8I95ouf/j5+QEA0tPT1ZZlZGQAADp16qRXjE0hk8kQEREBDw8PbNmypcHKX/me+m5Ev/LKK1i2bBk+//xztG3bFmFhYYYM2eCUXaY/fKj7eykBkAa1b89b+D7ONm/ejMLCQuzcuRNffvkloqOjdS5j2rRpsLOzw44dO9CtWzeNT9TUFR0dDbFYjLi4uHrXmzt3LkxMTKpv1gJAUlIS3n//fYhEImzZsqXBI3S3f07xCgsL1ZYNHjwYAHDu3Dm1Zcp5Q4YMqX9nmkF0dDQqKyvx008/qTwB5ePjg1OnTqmtX1RUBMZY9b5qsnDhQixYsABr1qxBQUEB9u/f3yyxG8rVq4BYDPxze0M3TX4olTzyzpzhLX6PHRM6ksbR9dlyXdfv2bMnc3BwqHcdZTuAuj788ENmZ2fHTpw4oTL/+PHjWhuCffTRRwwA27Rpk8ZtXb16ldna2rKXX365el55eXl147JZs2ZpjfOll15in3/+eXXMAFhMTIzaenK5nAUEBDB3d3dWXl5ePV8mkzF/f3/m5eWlMr+xmtIOYMmSJaxXr16suLhYbVnHjh1ZYmKi2vzLly8zAOytt97SWq6fnx/z9vbWKyYhBAczNnKkXm+lhmCkcYYOZaxbN8b0+I63uOZOAEOGDGl0Q7DGqi8BMMZYbGwsMzMzY/PmzWPXrl1jlZWVLD09nW3cuJG5ubmx/v37s5KSkur1p02bxgCwLl261NtCt3YCUCgUrF27dqxfv34a101MTGSWlpZs/PjxLDMzk+Xm5rLo6GgmFovZ/v371daPjIxkANjNmze1br8xn72mcn744Yfq7i+0TZoSwI4dOxgAra2klTF169at3piMxY4dvGGmni3yKQGQxklNZczRkbGICMYaaGwqiN9//11rRbBhw4Ymr19bSEhIvZWWlZWVSnmhoaH1lqcphrr98DDG2F9//cUmTpzIvLy8mJmZGbOxsWG9e/dmX3/9NausrKxe7969e0wkEjVYQSonZQJgjHc7oaklsNL58+fZ8OHDma2tLbO2tmbBwcEsISFB47rBwcHM2tqayWQylfm6fvaayhk5cqReCSAiIoJ5eHiwqnqasXt4eLDu3btrXW4sTp5krE0bxt59V+8iKAGQxouP5/9wzz/PWK2DzcfOyJEjmUgkEjqMZlFQUMA8PDzU+gLSVX5+PpNIJCwqKsooymGspi+gH3/8sd71XFxcWO/evZu8vea0dy/vj2vMGN5ZnJ6oKwjSeAMG8EGuT53ij4UmJQkdkTA8PT3BGEN2drbQoRicnZ0dfv/9d8TFxWHVqlV6lcEYw/Tp02Fra4uPmtB4xFDlAMDNmzcxduxYzJ8/H+PHj9e6nlQqxcOHD3Vq59GSpFJg/nxg9Gg+hGRcHB9LQF+UAIhOevfmg1w/8QTw7LN8xK8HD4SOqmUpHwv89NNPkWfwDtqF99RTT+Hs2bP4448/1MYDaIzs7GzcvHkThw4dgqurq95xGKocAFi3bh2WLVum1h1HbYWFhfjyyy8hlUqN8tHP//0PeOop4OuvgS+/BDZt4k//NImhTknI40WhYOynnxhr354xa2vGlixpHTeIDeXf//438/f3ZxYWFiwsLEzocEgTvfrqq8zMzIz5+PiwxYsXq923ENLly4yNGMGfxBs1irG0NIMVvYrGBCZNUlrKewb94gveQVVMDB/LVNk4hRCin8OH+fjav/3GewBduRLo18+gm6AxgUnTWFkBS5fyYevGjePJwMsLeP11IDlZ6OgIaV1KS4F164CgID5G8P+3d99hTZ7dH8C/kT1FHKBILQoI7l23r4qKFXepq3Yolde2VOuoq8Nfra+tto7WbZXa1lWsE62zrThQsQruhZuhIBshQLh/fxwjIGGFJE9Czue6cgUznvskwn2e554JCbRJ/JkzGq/8AQB8BcA0KjMT+PVXOnO5ehV47TVg5EjaLF6tmYqMVXEKBZ3tb9tGy65nZ9PfTFAQ0KaNVoteyQmAaYUQ9Ev9yy/A7t1AejqdwYwYAbzxBm1mwZixys8HwsKA33+nkTwJCdTMM3IkLbleu7ZOwuAEwLRPLgcOHKAznL17gawsGk3Urx/Qty8NKa3MUDbGDMGTJzSS5+BBuj1+DLRoQSdFI0YAJWwKp02cAJhuZWUB+/fT7dAh4NEjWmnUx4eSQd++1IfAmKHLyaGl1A8epN/1yEg60encmU5+hg4Fni+yKhVOAExad+7QWdGRI3SVkJ5O+w507UpNRm3b0nwDc3OpI2WsdGlpwNmzwIkTwMmTdMvKAho2pBMc5UlOBffb0SZOAEx/ZGUV/OGEh9OM49RUwNaWOpO7dKFk0KoVdygzacnlwOXLwPnzdJYfHk4j4WQywNsb6NSJfl979KAEoKc4ATD9lZ9POx2dOlXwR3brFj1XuzbQsiXNjGzZkpJC48YamBnJ2EuePqXmm8hIICqK7q9do43YbWzopKRLF6r0O3UCatSQOuJy4wTADEtKStE/xMhIGm6akwNYWgJNm1K7qpcXJYTGjQFPT3qOsdLExtLmKjdv0v316/S79fAhPe/sTCcaylvLlrQnrwEPYOAEwAxfbi5dKURF0TpF167R5fi9ezTGulo1WruocWO6PPfwAF59teBWyu6ArIqJi6Pfi3v3qP/p+nX6Xblxg9rwAcDBgX5XvLzo90VZ4VfBocucAFjVJZdTk5HyD1z5x37rFu1zrOTkVJAMGjQo+NnVlc76eFkLwyCXA/HxQEwMcP9+QUWv/Pn+fZpkBQBmZrTVqacnVfLKq0UvrypZ0ZeEEwAzTqmpBZXC3bsFlYXylpJS8FoLC0oELi6q752daR2kmjX5akIbnj6lW2JiQQWv6j4xseA9pqaUwAsndDe3gp9dXAy66UZTOAEwpkpqKs1RiIujtuHC94V/zsoq+j5r64JkUKsW3ZT/rlmThgDa2tK98mc7O7rp0fBAjZLLaXhvWhp9r+npQEYG3aemAklJBZW8qlt+ftHjOTnRrX79gvs6dajCV947O/OAgHLgBMBYZSQn0wxPVRVXYiLdnj4F7t7dicxMW2Rn98GzZyUfz96+ICHY2ND8Bxsbqszs7Kg/Q5kolKNNqlenx5VKGoWiPN7L0tKor+RlWVkFTSYArfOUk1PwuFwOPHtGfTAZGXQM5bHS0ugqKiOD3qOK8rPUqFE8URa+KZ+rVYsqfDOzkr8/ViErOUcyVgk1apQ97G/58uWYPHkypk6dim+/7YP8fDrzVZ4NK2+FK830dKpcs7Opws3JKaiA79zBi2MARfsz0tL2QKHwBVC8pk9JoTWaXmZtTc1cL1MmHSUrKxpNNSJ5Ndo9C8Oi1ptha0uP1alDY+AdHAruCycz5RVO4aseG5uyv1+mXXwFwJiWCCEwc+ZMLFq0CAsWLMCMGTO0Wt4///yDnj17IiIiAu3atdNeQYcP05TWvXsBPz/tlcO0jZuAGNOG/Px8BAYG4pdffsH69evx1ltvab3M4cOH48mTJzh+/LjWy8KoUTQz78oVPpU3XLwhDGOaplAoMG7cOPz666/Ytm2bTir/Bw8eYM+ePQgKCtJ6WQBoe6rUVGDBAt2Ux7SCEwBjGpSbm4uRI0ciJCQEoaGhGDJkiE7KXbFiBerUqYOhQ4fqpDw4O9NWcIsW0cw7ZpA4ATCmIQqFAm+//TYOHDiAAwcOwMfHRyflZmVlYf369fjwww9hpsshMh9+SFNk//tf1b3LTO9xAmBMA4QQmDhxInbv3o09e/agW7duOiv7119/RUZGBgICAnRWJgAax7l8Oa1//Ntvui2baQR3AjOmAUFBQVi7di127dqF/v3767Tsli1bol27dli/fr1Oy33hgw+AnTtpnQ17e2liYOrgTmDGKmvhwoVYuXIlNm/erPPK/6+//sLFixfxwQcf6LTcIubPp7WRv/5auhiYWvgKgLFKCAkJwciRI7F48WJMmjRJ5+UPHToUSUlJOHbsmM7LLmLFCmDKFODiRVpVjRkCngfAmLpOnTqF3r17IzAwEEuXLtV5+ffu3YO7uzu2bNkCf39/nZdfhEIBtGlDC/GEhkobCysvTgCMqSMuLg5t27ZF+/btsXPnTlSrpvvW1ClTpuCPP/5AdHQ0TPVh5bO//wZ69QL27QNef13qaFjZuA+AsYrKzc3FiBEjYGdnh19++UWSyj89PR0bNmxAUFCQflT+ANCzJzB8ODBpEq0Ux/QeJwDGKmjKlCm4cOECduzYgeoSreG8bt065Ofn637oZ1mWLKG1spcvlzoSVg6cABirgL1792L58uVYv349mjZtKkkMCoUCK1aswLhx4+Dg4CBJDCVydQWmTqVZwk+eSB0NKwP3ATBWTgkJCWjevDn69++P4OBgyeJQjjy6efMmGjVqJFkcJcrMpL0Whw7lKwH9xp3AjJXXoEGDcOnSJURFRcFewglPnTt3hrOzM3bs2CFZDGVat44miF28SJvuMn3EncCMlcemTZuwb98+bNy4UdLKPyIiAuHh4fjkk08ki6Fcxo2j+QBffCF1JKwUfAXAWBnS0tLg7e2NQYMGYdWqVZLGMmLECERHR+PcuXOSxlEue/cCgwYBJ08CnTtLHQ0rjpuAGCtLUFAQtmzZguvXr6NWrVqSxXH//n24u7tj48aNGD16tGRxVEjv3rRpcFiY1JGw4rgJiLHSREZGYtWqVfjuu+8krfwB4Mcff4STk5P0s34rYsECWi10zx6pI2Eq8BUAY6UYOHAg4uPjcfbsWchkMsniSE9Ph6urK2bOnImZM2dKFoda3nyTOoMvX6ad5pm+4CsAxkoSERGBffv2Yd68eZJW/gBN/FIoFJgwYYKkcahl/nzgzh3g55+ljoS9hK8AGCtBnz59kJWVhRMnTkgaR25uLtzd3TF8+HAsXrxY0ljU9uGHtEjcrVuAubnU0TDCVwCMqRIREYEjR45g3rx5UoeCTZs2IS4uDpMnT5Y6FPV99hmQkABItWkNU4kTAGMqLFu2DK1bt0bPnj0r/N7k5GSsXr0avXr1gqOjI6ysrODh4YExY8YgKiqqQscSQuD777/HqFGj8Morr1Q4lpft378fnp6eul9Arm5dYPx42jQmK0u3ZbOSCcZYEY8fPxYWFhYiODhYrfePHz9emJqaiqVLl4q4uDiRmZkpwsLCRJMmTYSJiYnYuXNnuY+1d+9eIZPJxIULF9SKRen27dti4MCBokWLFsLe3l6YmJhU6nhqiY0VwspKiOXLdV82U2UF9wEw9pJ58+bhxx9/xIMHD2BpaVnh9wcEBMDExARr1qwp8nhUVBRatWoFDw8P3Lx5s1zH6t69O+zt7RFayU1WRo8ejRYtWmDatGl49dVXER8fj7y8vEodUy2TJgEhIUB0NGBlpfvyWWE8EYyxlzVu3Bh+fn74/vvvNX5sa2tryOVy5OXllTmy6OzZs3jttdfwzz//oEePHpUqNysrC1bPK9z69etLlwDi44FGjWh+wMcf6758Vhh3AjNW2L///oubN29i5MiRGj92ZmYmsrKy0KxZs3INK/3mm2/Qvn37Slf+AF5U/pJzdgYmTKAE8OyZ1NEYPU4AjBWybds2NGzYEO3atSvy+PXr1zFkyBBUr14d1tbW6NChA0JDQ+Hj4wOZTAaZTFbm5iwhISEAgDlz5pQZx40bN7B79+4SJ31pIh7JzJgBpKUBa9dKHQmTtg+CMf3i5uYmZs2aVeSxW7duCQcHB+Hi4iIOHTok0tPTxeXLl4WPj4+oXbu2sLCwKPO48fHxwsnJSQQEBJQrjoCAAOHp6SkUCkWx5yobj4uLizSdwIVNnSqEs7MQWVnSxmHcVnACYOy5GzduCADi5MmTfa1RqAAAIABJREFURR739/cXAMT27duLPP7kyRNhbW1dZoWbmJgoWrVqJUaMGCHy8vLKjCM+Pl5YWlqKtWvXqny+svHoRQKIjxfC0lKIEj4j04kV3ATE2HOHDx+GnZ0d2rdvX+TxAwcOAAD69etX5PHatWvDy8ur1GNmZmaiX79+aNKkCTZt2gQTE5My41i8eDEcHBwwduxYlc9XJh694eQEjBkDfPcdkJ8vdTRGixMAY88dPnwYvXv3hpmZ2YvH5HI50tPTYWlpCVtb22LvqVGjRonHy8vLg7+/P1xcXLBx48ZyVf5Pnz7FqlWrMG3aNJVDUCsTj96ZPh24fZtXCpUQJwDGQDNujx07ht69exd53MLCAnZ2dsjOzkZGRkax9z0pZePzwMBAyOVy/P7770Vm3rq7u+P06dMq37N06VKYm5sjMDBQ5fOViUfvNG4MDBhAI4KYJDgBMAYadZOSkoKOHTsWe65///4ACppelOLj40uc0DV37lxcuXIFu3fvhoWFRbliSE1NxfLlyzFlyhSVZ/eViUdvTZ8OnD0LnDoldSTGSepeCMb0wS+//CLMzc1FdnZ2sedu374tHB0di4y6uXTpkvD19RUNGjQo1ukaHBwsAJR6Cw8PL1bOV199JapXry6Sk5NLjbWi8bxMLzqBC+vUSYghQ6SOwhhxJzBjAK3+2bJlS5Vn640aNUJ4eDjat2+PN954A05OTggMDMSsWbPg7u5e7PXbt2+vcPmZmZn44YcfMHnyZDg4OJT62orGAwChoaEv5gfExMRAoVC8+PdPP/1U4Xg1aupUYPdu4No1aeMwQrw9D2OgdXratGlT4vOenp7YuXNnuY6lzro9y5cvR3Z2Nj766KNyvb4i8QCAn58fhL6u+jJ0KODuDixZwpPDdIyvABgDzaz19vaWpOzs7GwsW7YMH330keT7DkuiWjXgk0+AX38FEhOljsaocAJgRi8pKQlPnjyRbAz96tWrkZqaik8++USS8vXCO+8AlpZAcLDUkRgVTgDM6F2/fh0AKpQAtm7dCplMhqNHj0Iul6u99o5cLsd3332H//73v6hTp06F36/peCRjbU0Tw9as4YlhOsTLQTOj99tvvyEgIADPnj1DtWq6PSdauXIlpk6diujoaNSrV0+nZeuda9eApk2BgweBPn2kjsYY8HLQjD169Aj16tXTeeWfnZ2Nb775BgEBAVz5A4C3N9ClC10FMJ3gBMCMXkxMDFxcXHRe7ooVK5CYmFjiks9GKTCQhoTGxEgdiVHgBMCMnhQJICMjAwsXLsTkyZMlST56y98fcHQENmyQOhKjwAmAGb2EhIRKdcCqY9GiRcjJycG0adN0Wq7es7CgEUHr1gEKhdTRVHmcAJjRS05OhqOjo87KS0xMxNKlSzFjxgydlmswAgOpCWjfPqkjqfI4ATCjl5KSgurVq+usvK+//ho2NjYICgrSWZkGpVEjoHdvnhWsA5wAmNFLTk4uc/0dTXnw4AFWr16Nzz77DDY2Njop0yC9+y4NBzWk5a0NECcAZtSEEMjKytJZZTx37lzUrVvXsCZpSWHwYOoP2LFD6kiqNE4AzKjl5ORACFHuNfsr4+bNm/j1118xb948mJuba708g2ZjA/j5AVu2SB1JlcYJgBm1nJwcANBohXzv3j3Ex8cXe3z27Nnw8vLC6NGjNVZWlTZqFHDiBPDokdSRVFm8FAQzGkIIBAcHIyEhAc+ePcOzZ8+QkJCALVu2oF27djAzM0NSUhKePXsGAIiMjCx1Z66SLFu2DHPmzMGsWbMwZcoUWFlZ4dy5c+jQoQN27dqFQYMGafqjVU05OUDdusDs2bRnANO0lZwAmFEZNmwYdu3a9eKMPz8/H3l5eUXWypfJZOjatSvCwsLUKiMgIADBwcGQyWSoU6cOFi1ahJ9//hlpaWk4ffo0ZDKZRj6LURg/Hrh4EYiIkDqSqojXAmLGJTAwEEIIyOVyyOVy5ObmFtsoxcTEBEOHDlW7jHPnziE/Px8KhQLx8fEYO3YsIiMjMWbMGK78K2rUKODcOcDQ9jo2EJwAmFHp27cvXnnllVJfk5eXBz8/P7WOn5+fjxs3brz4txACQggkJydj0qRJGDBgAKKjo9U6tlHq1QuoVw/Ytk3qSKokTgDMqMhkMkycOBGmpiXvhurm5gYPDw+1jh8dHY3s7OxijyueL2tw6NAheHl5Yfr06UhJSVGrDKNSrRowfDiPBtISTgDM6IwfP77Ephhzc3MMGzZM7WNfunSp1GaevLw8KBQK7Ny5E8nJyWqXY1T8/WmvgEJXVkwzOAEwo1O7dm0MHjwYZmZmxZ7LyclRu/kHAC5evFjqkFJTU1O0bdsW4eHhcHNzU7sco9K5M1CzJhAaKnUkVQ4nAGaUJk6ciNzc3GKP29jYoEuXLmofNyoqSuVxAepcfv311xEWFobatWurXYbRMTEBfH15cTgt4ATAjFKvXr3g7u5epLnG1NQUAwYMUHllUF7nz59Hvoo9bWUyGT744APs3LkTVlZWah/faPn5AcePA9xsplGcAJjRmjhxIkxMTF78Oz8/HwMHDlT7eJmZmXj48GGxx2UyGRYsWIAffvhB59tOVhm+vnR/+LC0cVQx/NvIjNY777xTrMPWV1nRqOHKlStF5hRUq1YNZmZm2Lx5M2bMmKH2cRkABwegQwfgyBGpI6lSOAEwo1WzZk28+eabMDMzg0wmQ4cOHVCrVi21j3fp0qUXVxSmpqawtbXF0aNHMXLkSE2FbNx69waOHpU6iiqFEwAzasrOYJlMhsGDB1fqWJcvXwYAmJmZwdnZGWfPnkW3bt00ESYDKAHcuQPcvSt1JFVGybNhGKsCMjJoTbGUFEAuB56v84aUFIBaa7rA1bUxHj68AVvbgQgJKX6M6tVpPlJh1ta0XH21avS8pSVw5sy/UCgUaN68OQ4cOAAnJydtfzzj0qkTLRN99CjA+yloBC8Gx/RaTg5tChUbCyQk0CCQl29JSQU/Z2XRfU4OkJlZ3lKWA/gOwL1KRlsbQDuYmGyHvb0NrKwAKyugRo3iN0fHgp9r1gTq1KEVD3S0MZnh6tuXvqzffpM6kqpgJV8BMMmkpQH37hXcYmOBuDggPp5+fvKk+I6A5uZFK0/lzc2N7pUVrrk5nSza2NDPNWoAZmaAcnVnW1v6N8UxFkuXxmD+fDqzLyw/H0hNVR27QkG3tDTg0aM4rF49COPGrYFCYYq0NCA7m644CierW7eK/vvlY1taAs7OlAycnAAXF6rvGjQAXn2Vbi4uNDTeKHXtCgQHSx1FlcFXAEyrYmNpFv/169R8W7jCT0oqeJ3yDLhwxefkRP92dqZl4evUoQpdGzIzMyu1LaRcLldrV7H8fCAxEXj8mL4r5b0yEcbF0e3hQ2rCAihxuboWJAQ3N8DTE/DyAho3pqapKuvIEaBPH/pC6teXOhpDx/sBMM148ICWbVdW9leu0NItyvXOHB2BRo0KKq1XX6WzWjc3+vnlM29WlBCUCO7eLUig9+/TvfKxvDy6MnBzA7y96eblBTRtCjRvTldHBi8jgy7nNm+mNYJYZXACYBUXGwv8+2/BLSKCzlwB+tts0oQqHeV9w4Z0Y9qTm0snxVeuAFev0tXWlStAZCT1hZiY0NVB27Z0a9oUaNOGErPBadMG6NEDWLJE6kgMHScAVrrsbKrgjx2j7VlPn6Z2axMTOrts04YqlDZtgJYtAXt7qSNmheXnA9HRwPnzRW9JSTSCycuLmtW7dgW6d6erMr0XFAScOQOcPSt1JIaOEwArKjsbCAujCj8sjCp/uZyaW7t3p4UZlZU9N9sYrnv3KBGcPUuJPSKCRk698gr9P3ftCvj4ULOd3tmyBXjnHWpf5F/CyuAEwKgN+fBh6l87cABIT6cmmy5dqCLo0oWaDFjVlZtLfThHjlBCOHGC6teGDSkR+PlR36ulpdSRgjo/Xn2VzlB4ol1lcAIwVufP04lUaCh12trZ0R94//50c3GROkImpbw8SgJ//km3S5doBFavXrRB19ChEjf31a4NfPYZMGmShEEYPE4AxuT2bRo8sWULVfqNGtEfcv/+dKZfyj4mzMg9eECJIDQUOHSI+oD8/IDRo+n3R+dDT/v2pTHCP/+s44KrFE4AVZ1cDmzdCqxaRf1mTk7AiBHAqFFAx45SR8cMUXIysH07nUyEhdGVwKhR1Dfr7a2jIGbMoPbKqCgdFVglcQKoquLiqNJfs4b+YN94A3j3XVpPy2hnkTKNi4mhE4zVq2m0UZ8+1Crj61t8/SSN2roVGDuWOqz0omPCIK3k1UCrmIcPgXHjqI9szRpgwgQa8bF5M101c+XPNMnFBZg6lSb97d1LE9b8/OhKYPNm5YJ7WtC6NXVUXLmipQKMAyeAKiI1FZg1iyb7/PMPnZE9eADMm0dNpYxpU7VqwIAB1D9w+TINFx47FmjfHvjrLy0U6OFBCzpxE1ClcAKoAtavpw7ddeuA//2POnjfe6+KrwnD9FaTJrReW2Qkrd/UuzddFTx6pMFCqlWjMarR0Ro8qPHhBGDAkpJoSN6ECTQv5vZtYPJk3Y3m2b9/Pzw9PWFqWvKissnJyVi9ejV69eoFR0dHWFlZwcPDA2PGjEFUOc7eFAoFZs2aBQ8PD1haWqJ///4lvjYiIgLvvvsu3NzcYGVlBUdHRzRr1gzDhw/HqlWrEP28smjVqhVkMlm5b19//XWRcu7fv49BgwYhLS1NI59RlfJ8tzNnzsS2bdtKfP69996DhYUF3NzcMGnSJGRnZ6sVi7qaNwf276fl+6OjafLgjh0aLMDNrVKbw0RGRmLAgAFwcHCAnZ0dfHx8cPLkSQ0GaAAEM0hhYULUr0+3v//Wbdm3b98WAwcOFC1atBD29vbCxMSkxNeOHz9emJqaiqVLl4q4uDiRmZkpwsLCRJMmTYSJiYnYuXNnqWWtWbNGABBfffWVSE5OVvkahUIhpk2bJkxNTcX06dPFtWvXRHZ2toiPjxeHDh0SPj4+AoAAIHJzc0XLli1FSEhIkWMEBgYKAOLPP/8s8viIESPEvHnzXvz7woULolatWuLHH3/U2GcsrCLf7e3bt4Wbm5v47LPPSnxNWlqaWL16tQAg5s+fX+44NC0zU4gJE4QAhHj/fSGyszVw0EmThOjYUa23nj59WlhZWYkRI0aI2NhYkZCQIN5//31hamoqDh48qIHgDMIKTgAGaNcuISwthRgyRIinT3Vf/qhRo8SCBQtEbm6ucHFxKTMBTJgwodjjkZGRAoDw8PAosywAIi0trcTXzJ49WwAQa9euVfl8Xl6e6N+/f6UTQGpqqqhfv74IDAzU6GcsrCLfrbIMmUwmtm3bVurrrK2tRd++fcsdh7bs2CFE9epC+PgIkZ5eyYMtXSqEs3OF36ZQKETTpk1F3bp1xbNnz148npeXJxo3bixcXV1FtkYylN7jBGBo/vpLCHNzIf77XyEUCmliKPxHU55KqiRWVlaiWrVqIj8/v8TX9O3bt9TjX7t2TVSrVk20bdu21LJOnTr1IgGoUlICKGzOnDnC1NRUxMTElFpWYeX5jIWp8936+/uL+vXrl/jZhBCiXr16ZX5HunL+vBB16gjh6ytEKSGXbdcuIWQyuryogL///lsAEEFBQcWemzt3rgAgtm/fXonADMYK7gMwIHFxtAT60KHAypVaHmddCisNLCyfmZmJrKwsNGvWDDKZrMTXKRSKUo+zdu1a5Ofnw7+MteE7deoEIUSpbeqlEULgp59+wmuvvYZ65RxWVd7PWJg63+3QoUPx6NEj7Nu3r8TXyGQy5OXlVfjY2tC6Nc0oPn4c+OKLShzIxYXGmcbHV+htfz0fltSuXbtizykfO3r0aCUCMxycAAzIpEm03v769UA56xO9FfJ89/U5c+ZU6jhhYWEAgBYtWlQ6ptJERUXh8ePHaNmyZbnfo6nPWJZWrVoBAA4ePKjVcjSpfXvg+++BhQtpnSG1KPf3zMzE9evXMWTIEFSvXh3W1tbo0KEDQkND4ePj86IzP+D5RvLXr18HANRXsaOYy/NFsG7evKlmUIaF9wQ2EDdvAn/8QVPwtbUtoq48fvwYM2fOREBAAN58881SX5uTk1PqVouxsbEAgJo1a2o0xpddvnwZgOpKQ5WKfMbKUlZayhhVsbCwQG5urlbjqKgJE2i2+jffAJs2qXGA5wng9vXr6DRhAmxsbLB9+3Z06tQJ9+/fx+TJk3Hx4kVYWFgUGQGV8nybOlVbgNo+P2ZycrIaARkevgIwEDt20JjqwYOljqRynj59Cl9fX/znP//B6tWry3z9gwcPylXplreJRV1xcXEAgOrVq5f52op+xsqyt7eHTCZ7EaMq9erVQ0xMjN40AwF0Ffvf/9IM4pwcNQ7wvLKevXw5UlJSsGzZMvTp0we2trZo2rQpNm/ejMzMzAodUjyfuqzt3yd9wQnAQERF0eJtUrX7a0JmZib69euHJk2aYNOmTTApZV2KpKQkLFq0CPfv38cHH3xQ4uuU7fGJiYkaj7cw5RmkmZlZqa+ryGfUJFNTU2RlZZX4fGBgINLS0vDFF19o/buqiM6daTkfteZzPU8AByIiAAD9+vUr8nTt2rXh5eVV7G0ODg4AoDI5KB9TvqaqM+DqxLikpxv2dot5eXnw9/eHi4sLNm7cWGrF+O6776JmzZqYOXMmPv30U3z88cclvrZHjx4AgIsXL2o85sIsny84VlozSkU+o6bl5eWV2oH81ltvYf78+Vi0aBFq164NX19fncVWGuUF1fM5dRVjagq5iQnSs7JgaWn5ovmmsBo1ahR7TJkUHqmYmhwTEwMA8PT0VCMgw8MJwEA4O2t4Kr2OBQYGQi6X4/fffy8yEsfd3R2nT58u8tqff/4Zqamp2Lp1KxYvXozAwMBSj2tqaort27eXWv6nn36KatWqvegArKi6desCAFJTU0uNpbyfUZPS0tIghHgRoypz5szB7NmzsWrVKqSkpODAgQNai6ciHjyg+1JCL1l2NiwUCthZWSE7OxsZGRnFXvLkyZNij/Xs2RMA8O+//xZ7TvlY79691QjI8HACMBDduwOnTtE2fYZm7ty5uHLlCnbv3l1qh25h9vb28Pf3R+vWrUut3D09PfHll1/i3Llz2LBhg8rX3LhxA2vWrMGbb76pskmgPJo1awZA9VkjoN5n1BTlWasyRlV27NgBNzc3BAQElKsfQ1f276eVa195RY03P6/w+7/2GgAUS2rx8fEqR/P06NEDTZo0wfbt24t0DisUCmzduhWurq4YMGCAGgEZIGnnIbDySk0VokYNIebOlTqSosqarBQcHPxiGYaSbuHh4SW+v3fv3uWaDDVz5kxhZmYmZsyYIW7cuCHkcrl49OiR+Omnn0TdunVF165dRUZGRonvL2siWH5+vqhTp47o0qWLRj7jmDFjBABx586dEmMq70SwzZs3CwClLjnh4uIiWrZsWeaxdCkpiX6nv/pKzQPcvSsEIG7v2CEcHR2Fi4uLOHTokEhPTxeXLl0Svr6+okGDBsLCwqLYW8PDw4WlpaUYOXKkiIuLE4mJiSIwMFCYmpqKAwcOVOpzGRCeCWxIFi4UwsJCiIsXpY1j7969JVZ069atK/LaAQMGVCoB+Pj4lHum8dmzZ8XYsWOFq6urMDMzE3Z2dqJjx45i2bJlQi6Xq3xPSZV3uop1CmbPnq1yJrA6n7FXr17C1tZW5OXlFXm8It+tkr+/v3BxcRE5OTklfjcuLi6iVatWJT4vhdGjhahXT4iUFDUPcOkSLS509aq4ceOGGDJkiLC3txfW1taic+fO4tixY6J3794qE4AQQpw/f170799f2NvbC1tbW9GrVy9x4sQJ9T+Q4eEEYEjy8oTo1k2IV18VIjZW6mh0Y8CAAUImk0kdhhBCiJSUFOHi4lJsLaCKSk5OFlZWViIgIKDSMSnXAtqyZUupr3NychId1Vw4TRsWLBDCxESIUlbeKNuJE5QAHj0q8SWlJQDGS0EYFBMTYOdOWue/Rw/a6auqq1+/PoQQePz4sdShoHr16ti7dy+2b9+OFStWqHUMIQQ+/vhj2NvbY968eZWK586dOxg2bBhmzZqFkSNHlvi63NxcJCUllXsSm7bNnw/Mng0sW0ZbR6rt/n3AzIxGSDC1cAIwMDVrAseO0Wzg1q2BUpaDrxKUwxW/+eYbPH36VOJogNatW+PcuXP4888/X+wHUBGPHz/GnTt3cPToUThXsuJas2YN5s+fj/nz55f4mtTUVCxevBi5ubmSD/1MSwPGjAE+/xxYvBj48MNKHvDuXeo95n1O1Sf1NQhTz7NnQnz8MV0Bjx0rRCn9mwbv22+/Fd7e3sLCwkL4+vpKHY7BeOedd4SZmZlwd3cXn3/+ebH+Bl0KDxeiYUMhnJwq2exTWEAArSutwpYtW4r1oYwfP15DBVcZK2RCaG3bZqYDISFAYCBQqxZtBzl8uOEvFMeqjrg4YO5cWsBwwAC6r1VLQwf38aFdwdat09ABjc5KbgIycP7+tExEhw7AiBE0tf74camjYsYuPZ2aejw8gD//pD2Cd+3SYOUPUCeYm5sGD2h8OAFUAa6uwG+/ARERtDxK9+5Av340ySY/X+romDGJi6M1/hs1AlasoJ9v3gTGjtXwlemzZ5QAGjfW4EGNDyeAKqRNG+DwYeDQIdonw88P8PYGli+nMzLGtCUiAnjrLZrVu2YNrfJ5+zbw6afA82WUNCsqClAo6JeeqY0TQBXUpw8lgcuXgZ49gRkzgPr1gXHjgCNH6O+GscqKjQWWLKHNXTp0AK5cAVavptGZX30FODpqsfALFwAHB8o4TG3cCWwEkpOBjRuBzZvpTK1uXeDNN4FRo4Dny6gwVi7JybQ3xaZNNBzZzg4YNgx4911qetSZ99+nS4y//9ZhoVXOSk4ARub+fWDrVuqUu3GDNpnp1w8YOBDo27dgeV7GlO7coU1bQkOBsDBqy+/ThwYgDB8u0Q517dpRxlm8WILCqwxOAMbs/Hn6w96/Hzh3DjA1pb+p/v2BXr2A5s15jo0xevoUOHECOHiQfjfu36fRO76+wOuv003SE4XcXNocY+1a6l1m6uIEwEhCAnDgAP3BHzoEJCXRH3mXLkDXrkC3btTWq+OVjpkOPHxIZ/YnTtAQ4qtX6Sy/dWuq7AcMoP97vdmN7t9/6Qrg8mWgaVOpozFknABYcfn59LdVuFKIjaXRHG3b0q1NG7p5e9OVAzMMiYl05ae8nTlDm7KYmVGdqkz2XbpouRO3Mn74AfjyS7pU0ZusZJA4AbDyiY6mZBAeThXHpUtAdjZgZQW0bEnJoFUrSgje3rRmEZNObi79n127RqNzzp+nE2flDlyurvR/1rYtVfqvvQZYW0sbc7mNHEnjmvftkzoSQ8cJgKknN5eaCgqfTV68+GKTJtSqBTRpAnh5FSSFhg2BBg0Ac3NpY69KEhJoPtSNG1TZX79O97dv0/+RTEYjJZVXbMpbnTpSR14Jr7xCEw1mz5Y6EkPHCYBp1oMHBZWRskK6ehVQbs1arRpQrx5VSm5udHv1VbrVrUvzFVTs7W2U8vLoe4uLo+/13j1aALPwvTLhmpsDnp6UcL28CpJv48YGdGZfHg8e0FnE338D//mP1NEYOk4ATDeSk2k4obLierkyy8oqeK21NSUJZ2e61a1L905OQI0adHN0LPjZzk6iD1VBeXnUuZ6cTDflz0+fAo8fUz/L48dATAxV/E+eFF3Ko27dgoT58n2DBkbSF7NlC/D22/TF8ZlCZXECYPohPp5uL1eCsbEFzyUk0JryLzMzK0gGtraUEMzMaKKohQUlFFtbOkt2cCh4X40aRY8jkxV9HqB+jsLJ6eXHlD+npwM5OUBmcg4yc83x7BmdnWdnF1T0qpbjMDOj/pI6dQAXF7p/Ofk5OVGrh1aWVDA0QUHUc332rNSRVAUrjeGcgRkAZYXXqlXpr1Moip5FFz6TTk6mSjcjgyrjlBRKGPHxBRV0aiodxy3rKt57+h1mWy9FusweAJ2hv1xJm5oWv8IwMys4+TQ3p4lQtrbAhAefobH8Ipb22gNnZ3qfhUXRq5WXr174JLaCjh+n9U2YRvAVADNO69cDkyZRhtDUUMK//6YZdIcO0VRZplmPH9MlUWgoTVBglcX7ATAjdfEi0KyZZseR9+xJS7BOn84r7mnDoUN0+aXTRYeqNk4AzDhFRQEtWmj+uN99R8OegoM1f2xjd+gQTVrgdjON4QTAjNPly9pJAI0b0x6dc+ao7rFm6hECOHqUm9Y0jBMAMz4xMTT2snlz7Rz///6PepQXLdLO8Y1RVBRNiOjbV+pIqhROAMz4REfTvYeHdo7v6AjMmgV8/z0tpckq79Ahml5e1jAxViGcAJjxuXuXBtU7O2uvjI8/pmnNn32mvTKMyeHDdPbPi79pFH+bzPjcvUvTZ7VZmZibA//7H22dxZOWKic5mZam5aGfGscJgBmfO3doZTpte+MNGrUyeTJ1YjL17NpF07QHDpQ6kiqHEwAzPsorAF1YtoyWLvjjD92UVxWFhNC+pfb2UkdS5XACYMYnLo7a53WhdWtg9GhgxgxALtdNmVVJSgoN//T3lzqSKokTADM+CQk0okRX/vc/WtVuzRrdlVlV7N5N9wMGSBtHFcUJgBmX3Fxa8U2XW5a5ugIffAB8/bXqJUFZyUJCaPTPy0u3Mo3gBMCMy9On1CGryysAgOYFyOXUJ8DKJyUFOHKEm3+0iBMAMy6JiXSv602La9UCpk6ltYKePtVt2YZq925K1jz6R2s4ATDjkpxM91I0KUyZQhPQvv1W92Ubop9/ptVVuflHazgBMOOSm0v3Fha6L9vWFpg5E/jxR+DRI92Xb0ju3gWOHQPee0/qSKo0TgDMuCjX6ZdqSYEPPqBNTb7+WpryDcWGDbQXpq+v1JFUaZwAmHFR7rIuVQLM4wn9AAAUeUlEQVQwN6f1gdavB27ckCYGfZefD/zyC/Duu0ay0710OAEw46JMACYm0sXwzjuApyctG82KO3wYePCAviemVZwAmHGR+goAoOTz1VfA1q3AhQvSxaGvgoNpDSUvL6kjqfI4ATDjoqz4pd6zd9gwoEMHXi76ZUlJNPyTO391ghMAMy4ODnSfkiJtHDIZMG8esH8/8M8/0saiTzZupI3f33xT6kiMAicAZlyUY8qV8wGk1KcP0LMnNQcxap5bsYI6f3njd53gBMCMiwYTQHJyMlavXo1evXrB0dERVlZW8PDwwJgxYxAVFVW+g3z5JfD338Dx45WOpzz2798PT09PmOrj6Jp9+2ivhg8+kDoSo8EJgBkXDSaA6dOnIygoCIMHD8bVq1fx9OlTbNiwAZGRkWjbti127dpV9kF69AC6d9f6vIDo6GgMGjQIs2bNwuPHj7Valtp+/JEWfuPOX53hBMCMi7k5YGOjsSagcePGYdKkSXB2doa1tTW6deuGzZs3Q6FQ4NNPPy3fQT7/nDY9P3lSIzGpLuJzdO7cGf/++y/s7Oy0Vo7abt2ihd+CgqSOxKjIhOC96piRadyYNmn58kutFWFtbQ25XI68vDzIZLKy39CtG+14tW+fVuLJysqClZUVAKB+/fqIj49HXl6eVspSy0cfAQcOADdv8sbvurOSv2lmfLy8gOvXtXb4zMxMZGVloVmzZuWr/AFg9mwaERQRoZWYlJW/XkpPB379FfjwQ678dYy/bWZ8vL2Ba9dUPnX9+nUMGTIE1atXh7W1NTp06IDQ0FD4+PhAJpNBJpMhICCg1MOHhIQAAObMmVP+mPr3p3kB8+eX6+WaiFNvrF9P8zJ47L/uCcaMTXCwEJaWQuTlFXn41q1bwsHBQbi4uIhDhw6J9PR0cfnyZeHj4yNq164tLCwsyjx0fHy8cHJyEgEBARWPa88eIWQyIS5cKPVllY3TxcVFmJiYVDw+bcjJEeKVV4QICpI6EmO0ghMAMz6nTwsBCBEdXeRhf39/AUBs3769yONPnjwR1tbWZVasiYmJolWrVmLEiBEi76XkUi75+UK0bi2Ev3+pL6tsnHqVAH7+WQgzMyHu3ZM6EmO0gpuAmPHx9qaZuFeuFHn4wIEDAIB+/foVebx27drwKmNoYmZmJvr164cmTZpg06ZNMFFnsTmZDJgxA9ixgzpDS1CZOPWKELRD2qhRQIMGUkdjlDgBMONjb08jgU6devGQXC5Heno6LC0tYatiFmqNUnalysvLg7+/P1xcXLBx40b1Kn+lN94AGjYEFi1S+XRl4tQ7e/ZQEp4+XepIjBYnAGacunUrMvvWwsICdnZ2yM7ORkZGRrGXP3nypMRDBQYGQi6X4/fffy8yw9bd3R2nT5+uWFwmJlQhbtxISyK/pDJx6p2FC4FBg4BmzaSOxGhxAmDGqUcPGnKZnv7iof79+wMoaGJRio+Px80SmmTmzp2LK1euYPfu3bDQ1DaTb78N1KkDLFum8ml14tQ7//xDV2DlnSzHtEPqXgjGJPH0qRCmpkKEhLx46Pbt28LR0bHI6JpLly4JX19f0aBBg2Kdq8HBwQJAqbfw8HD14lu0SAgbGyESEoo9VdE4X6YXncC+vkL06CFtDIw7gZmRcnQEOnUC9u598VCjRo0QHh6O9u3b44033oCTkxMCAwMxa9YsuLu7FzvE9u3btRffxImApSWwcmWxpyoaJwCEhoa+mB8QExMDhULx4t8//fST9j6HKmfP0qzfWbN0Wy4rhpeCYMZryRLaljEuDihjpqyPjw9OnDiB7OxsHQUHWqpixQrg/n1av6gcJImzovr3B1JTi3TCM0nwUhDMiI0ZAzx7RjtQ6aOgICArC9iwQepINCc8nM7+eQ8EvcAJgBmvOnVo+eHgYKkjUa1WLdoYfckS6bew1JQvvwQ6dwZ8fKSOhIETADN2EycChw8DFy+qfHrr1q2QyWQ4evQo5HK57tfYmTaNhoOWsbeA5HGWx6lT9F3Pmyd1JOw57gNgxk0IoGlTOivVdWdoeQ0dCsTEUOepIfPxAbKzgRMnpI6EEe4DYEZOJgOmTAF++w24d0/qaFSbOpXmLBhyp+nx48DRo1rf+YxVDF8BMJaXBzRvDrRvD/zyi9TRqNapE1CvHvDHH1JHop6uXQELC0oCTF/wFQBjMDWl4aCbNgGRkVJHo9qUKdQPcPu21JFU3K5ddPVSzr0OmO7wFQBjAPUFdOhAI2/+/FPqaIpTKGgBu/79afN0Q6FQAC1bUj/Ltm1SR8OK4isAxgBQX8CSJcDBg/pZUZmY0LyADRuAp0+ljqb8goNpaWtu+9dLnAAYU+raFQgIACZPBpKTpY6muIAAmrG8Zo3UkZRPdjZN+JowAfDwkDoapgInAMYK+/Zbup8xQ9o4VLGxoSTwww9Uueq7pUspkX72mdSRsBJwAmCssBo1qI39p5+KLBSnNz7+mCrVrVuljqR0SUmUTD/5BHB2ljoaVgLuBGZMlXHjaPRKZCTwyitSR1PUO+8A58/T7GWZTOpoVJs0ifpSbt0C7Oykjoapxp3AjKn044+AkxNtzqJv6/BMm0ZbKR4+XPTx+Hhg3z5pYirs+nVg1Srq+OXKX69xAmBMFRsbYPNm4PRp4PPPpY6mqObNgd69ge+/p39HRNDKpq6uJe4lrFNTpwJNmgDvvSd1JKwMpmW/hDEj1bo1sG4dNbk0awaMHi11RAUmTaL9dFu2pKYgc3Oa0azLPYGXLQMCA2njGqWjR4H9++nqxMREd7EwtXAfAGNlmTqVduY6dowmi0npyRMaW79kCf1crVrRJipnZ9rgRtvi44G6dal/ZM0awNeX4mjdGnB3B3bs0H4MrLJW8hUAY2VZuBC4fBkYMgQ4eRJwc9N9DFevUhybN9O/c3Pp/uX+idRU3cRz5gx1QD96RLOThw4F2rUDbtww3PWKjBD3ATBWFhMTICSEznj79AEeP9Z9DJaW1LSiUBRU/qpkZQE5OdqP5/RpwMwMyM+nf4eG0npK/foBDRpov3ymEZwAGCsPe3vaytDUlHYRS0nRbfkNGwJ//UWd02W1rSclaT+ekyeLJqLcXEo8+/YBrVrR80zvcQJgrLxq16az8CdPgIEDgYwM3ZbfrBlw6BCdeZc2/l/by1jk5wPnztECeqqeu3mTltUYP96w1i0yQpwAGKuIhg2Bf/4B7tyh5o60NN2W37EjNUdVK+VPV9tXAFevUlNTSRQKim/zZr4S0HOcABirqMaNgSNHKAm8/rruk4CfH7BxY8lXAdpOAKdPl94MZW5OV0vHj9NQVaa3OAEwpg5vb2qTv3MH6NlTt+PvAZr49cMPxR83MdF+AjhzpuQrEFNTGgoaFUWjgphe4wTAmLq8vWmnq4wMapopabeu4GBqttG0jz4CZs4seiWgiwRw/LjqkUgyGU2aCwujZTSY3uMEwFhlvPoqVXg1agDduwMXLhR9/tYt4MMPaU38+HjNl/+//1Fnq7JJRibTbidwejp9psJMTOiKYMECWkXV3Fx75TON4gTAWGU5OQF//02jdLp1A3bupMdzc4ERI2iJhsxMWlhO0xPvZTJg9WrqFzA1pbK0eQVw7lzB2H+ARiTZ2tLoJH3cQ4GVimcCM6YJ9va0l/AnnwDDhwNffAHI5bROj3K27tGjtKTEhx9qtmwTE+D332lG7l9/FU0AubnUP/H4Mc1dyM+nTmuFguYUmJsD1taAgwPg4gJUr156WWfO0HtycijhNGpEQ2OlmB3NKo3XAmJM09auBTZtAk6cKHq2DNAZ8/nzdLWgSRkZNDw1MJCaY+rXB+7do4q/In/i1tb0Xm9vWtGzeXOgbVvA05OeHzIE2LOHrjwGDgR++42uAJghWskJgDFNS04GmjalM++X1+oxNQW8vIB//61cW7lCQZ2xf/5JfRDnzlHzT82alGT8/WlRNhcXWsLCyYn6KWQyuloxMaGkkZtLY/qTkmhdn/h44MEDGut/+TJN6srNpWP06EFLPmRkAF9+STd93ZCGlQcvBseYxk2YACQmqt5IJi+PNkz5v/8D5s+v2HGFoCaeLVvoLDwhgZJJz560PHT37kC9etTEY29f9vGUZ+41atD7VF2V5OZScgkLo3b+zEyq9I8coeait96iMf/MIPEVAGOatGYNMHFi2c0uMhl1HPfoUfYxU1KADRvo2DdvAu3bA8OG0U3ZNKMLZ89S3LGx1NG9ezddPQwbRp+5WzfdxcI0gZuAGNOY69dpEpRcXnYCMDGhZpUrV0o+W09Lo60Vv/mG+hJGjqSKtlUrzceuDrmcrkTWrqUrgi5daCTQwIFSR8bKh/cEZkxjbG1pLPx//kNt/TJZye38CgW1t3/0UfHncnNpa0flFo/Tp1P7/Jo1+lP5A4CFBfU1HD5M/RHW1rT0Q69e1H/A9B5fATCmDc+e0bDP0FBg1y7qEDYzoz6Al//ktm6l+QIAVaQTJ9ISEzNmAFOmGNbG6qdOAZMnA5GR1C8xdy4NN2X6iJuAGNM6IWjUz7591G4eGUlDNWUySgj29sClS9SUsmABrTL64480xt4Q5efTZ5k9m0Yfbd1KexczfcMJgDGde/yYJk+FhtImM8+e0UQsuRxYupRGEVUFjx7RKKEzZ2jhuvfflzoiVhQnAMYkdeUK4ONDlf/8+dT8U5UoFDTk9euv6Ypg3jyeO6A/eB4AY5KJjKQ9hj08gL17aRJXVWNiAnz1FW2kM2EC9YWsWcNJQE9wAmBMCtHRtHZPq1bUL2BtLXVE2vXuu0CtWjRnoEYN4NtvpY6IgVcDZUz3kpOpo7d+fWDHjqpf+Sv5+dHeCN99ByxfLnU0DHwFwJjuTZgAZGdTR7AhDfHUhDFjaJG6adNo4ljr1lJHZNS4E5gxXfr5Z9rA5cgRWsPHGOXnU99HbCxtoGNpKXVExopnAjOmM+npNLkrKMggKv9t27ahVatWsLKygkwmg0wmw2VNzPCtVo02tX/4UPW+xkxnOAEwpivffkvLPHzxhVYOn5GRAQ8PD/j5+VX6WCdPnsSoUaPQt29fJCQk4Pbt26hfv74Gonyufn1g6lSa+Pb0qeaOyyqEEwBjupCVBaxYQev6ODpqpQghBPLz85H/8iY0aggJCYEQApMmTYKtrS0aNWqEhw8fopkmN7KZNo2Gg65fr7ljsgrhBMCYLuzcSRupvPee1oqws7NDdHQ09u/fX+ljPXz4EABQU5tzE+zsgNGjKQFwV6QkOAEwpgtbt9K4f2dnqSMpF4WqzWy0Ydw42uPgwgXdlMeK4ATAmLYJAZw8SSNftGTXrl0vOmplMhmys7NVPn7v3j2MGDECDg4OqFmzJvz8/BAdHV3sOLt37waAFx3AHTt21E7grVvTBLETJ7RzfFYqTgCMaduNG7TnbqdOWitiyJAhEEJg8ODBpT4+efJkTJ48GTExMdi2bRv++usvjBo1qsTXZ2VlQQiB06dPaydwmQx47TVaRprpHCcAxrTt/n26b9xY2jgABAQEoFOnTrCxsYGPjw8GDBiAiIgIJCYmSheUp2fBd8R0ihMAY9qWmEibwSg3YZdQ+/bti/zb1dUVABAbGytFOKRmTR4KKhFOAIxpW1YWrfejBytgVq9evci/zZ9vWamJoaNqs7WlEVJM5zgBMKZtNWrQBu95eVJHop+SkqrmUtgGgBMAY9pWsyaNBOJmDtWePOEEIBFOAIxpW7Nm1PzDY91VO38eaN5c6iiMEicAxrStVi3a9UuLQx1Vjd9/6623cPr06WKPf/bZZwAAmUyGb59vzNK6dWv4+fmVOA9Aa8NAs7JoZzQtDpFlJePloBnThYkTaTLYxYtSR6Jf/vgDGDECePAAqFdP6miMDS8HzZhOvPMOcOkScO6c1JHol/Xrgb59ufKXCCcAxnShY0fqC1iyROpI9MfVq8ChQ0BAgNSRGC1uAmJMV/74A/D3B86eBdq1kzoa6Q0cSJvCnD9Pm8QwXVvJCYAxXREC6NqVfg4LA0xMpI1HSn/+Cbz+OnDwIDUBMSlwHwBjOiOTAWvX0nDQ+fOljkY6T57QMtBvvsmVv8Q4ATCmS02bAgsXAvPmUfu3scnJAUaNAmxsgHXrpI7G6HECYEzXPvyQKsHhw4GICKmj0Z38fODtt2kk1PbtgL291BEZPU4AjOmach/c7t2pHdwYhobm5dFon1276NaqldQRMXACYEwaZmZASAjQvj3Qsyd1ilZVmZnAkCHAtm00EqpnT6kjYs9xAmBMKtbWwJ49NDR00CBgwQJqJqlKrl8HunShoa9//QUMGCB1RKwQTgCMScnUlJqDFi4E5s6lUTExMVJHpRnBwTTfwcICOHOGtn5keoUTAGNSk8mATz6hxeIePAC8vWnGsKHuH3D1KtCrF7X5T5xIG767uUkdFVOBEwBj+qJtWyAqipLB7NlA69bAzp00gcwQxMQAH39MHbzp6UB4OLBoEfV3ML3ECYAxfWJlBfzf/9HCcd7ewBtvUCLYtg3IzZU6OtVu3waCggB3dxrhs3w5Nfl06CB1ZKwMnAAY00fu7sDvv9MVgZcXMGYM4OoKzJoF3LoldXSAXE4jevr2BTw9qTP7++8ptgkTeG0fA8FrATFmCB4+BH76iTqMY2KAli2BYcOAwYOBFi10s+F8Sgpw5AhV/Pv30/BOX18gMJDmMxjz2kaGiReDY8yg5OUBx44BO3ZQc0tsLO2n27UrTSxr2ZK2V6xTp3Ll5OQAN24Aly8Dp0/T4nUXL1Ki6d6dZjEPHcrr+Bs2TgCMGaz8fGoiCgujpHDyJC20BtA2lJ6eQN26gIsL4ORESy+Ym9M6PObmQFoaoFDQfWoqXWXEx9NIpNu3qc/BzIyuMLp1A3r0oHvewL2q4ATAWJXy+DGdtV++DNy9S1cIsbGUGNLS6Mw+I4Mqdzs7modQvTr97OpKicLVlTqgmzYFGjemZMGqIk4AjDFmpHg/AMYYM1acABhjzEhxAmCMMSNlCiBE6iAYY4zp3IX/B0UsbprN5uL3AAAAAElFTkSuQmCC", + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 创建一个量子电路作为示例，您可以根据需要修改这个电路\n", + "simple = QuantumCircuit(3)\n", + "simple.measure([2], [1])\n", + "simple.cnot(0, 1)\n", + "simple.cnot(1, 0)\n", + "simple.x(2)\n", + "simple.cnot(2, 1)\n", + "simple.cp(1, 0,np.pi / 2)\n", + "simple.barrier([0, 1, 2])\n", + "simple.rxx(0, 1, np.pi / 2)\n", + "simple.delay(0, 100)\n", + "simple.fredkin(0,1, 2)\n", + "simple.mcx([0, 1], 2)\n", + "simple.mcy([0, 1], 2)\n", + "simple.mcz([0, 1], 2)\n", + "simple.ct(2,1)\n", + "# simple.measure([0], [0])\n", + "# simple.measure([1], [2])\n", + "simple.measure([1,2], [1,2])\n", + "\n", + "\n", + "\n", + "# 构建dag\n", + "dep_graph = circuit_to_dag(simple, measure_flag = False) # dag graph\n", + "\n", + "# 可视化dag\n", + "draw_dag(dep_graph, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "# 在此处添加您的其它代码，例如模拟电路，分析结果等" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dag_circuit.DAGCircuit" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(dep_graph)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## remove node" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "dep_graph_copy = copy.deepcopy(dep_graph)\n", + "nodes = copy.deepcopy(list(dep_graph_copy.nodes()))\n", + "nogate_nodes = [nodes[0],nodes[-2],nodes[-1]] # -1,inf,measure node\n", + "# dep_graph_copy.remove_nodes_from(nogate_nodes) # remove -1,inf,measure node\n", + "# dep_graph_copy.remove_nodes_from([nodes[6]]) # remove -1,inf,measure node" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# i = 14\n", + "# nodes[i].name, nodes[i].pos, nodes[i].paras, nodes[i].duration, nodes[i].unit,nodes[i].label\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# for predecessor in dep_graph_copy.predecessors(nodes[i]):\n", + "# print(predecessor.name, predecessor.pos, predecessor.paras, predecessor.duration, predecessor.unit, predecessor.label)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# for successor in dep_graph_copy.successors(nodes[i]):\n", + "# print(successor.name, successor.pos, successor.paras, successor.duration, successor.unit, successor.label)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# for edge in dep_graph_copy.in_edges(nodes[i], data=True):\n", + "# print(edge[0], edge[1], edge[2])\n", + "# predecessor_nodes = [edge[0] for edge in dep_graph_copy.in_edges(nodes[i], data=True)]\n", + "# labels = [int(edge[2]['label'][1:]) for edge in dep_graph_copy.in_edges(nodes[i], data=True)]\n", + "# labels\n", + "# # get a dict about keys are the predecessors of the node and values are the labels of the edges\n", + "# predecessor_labels = dict(zip(labels,predecessor_nodes))\n", + "# predecessor_labels,predecessor_labels.keys(),predecessor_labels.values()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# successor_nodes = [edge[1] for edge in dep_graph_copy.out_edges(nodes[i], data=True)]\n", + "# labels = [int(edge[2]['label'][1:]) for edge in dep_graph_copy.out_edges(nodes[i], data=True)]\n", + "# labels\n", + "# # get a dict about keys are the successors of the node and values are the labels of the edges\n", + "# successor_labels = dict(zip(labels,successor_nodes))\n", + "# successor_labels,successor_labels.keys(),successor_labels.values()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# successors = list(dep_graph_copy.successors(nodes[i]))\n", + "# predecessors = list(dep_graph_copy.predecessors(nodes[i]))\n", + "\n", + "# # for successor in successors:\n", + "# # self.remove_edge(node, successor)\n", + "# # for predecessor in predecessors:\n", + "# # self.add_edge(predecessor, successor, label=None, color='black')\n", + "# # self.remove_node(node)\n", + "# for successor in successors:\n", + "# dep_graph_copy.remove_edge(nodes[i], successor)\n", + "# # for predecessor in predecessors:\n", + "# for qubit in nodes[i].pos:\n", + "# if predecessor_labels[qubit] != -1 and successor_labels[qubit] != float('inf'):\n", + "# dep_graph_copy.add_edge(predecessor_labels[qubit], successor_labels[qubit], label=f\"q{qubit}\")\n", + "# elif predecessor_labels[qubit] == -1 and successor_labels[qubit] != float('inf'):\n", + "# dep_graph_copy.add_edge(predecessor_labels[qubit], successor_labels[qubit], label=f\"q{qubit}\", color='green')\n", + "# else:\n", + "# dep_graph_copy.add_edge(predecessor_labels[qubit], successor_labels[qubit], label=f\"q{qubit}\", color='red')\n", + "# dep_graph_copy.remove_node(nodes[i])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(-1, {'color': 'green'}),\n", + " (0{CX(0,1)}, {'color': 'blue'}),\n", + " (1{CX(1,0)}, {'color': 'blue'}),\n", + " (2{X(2)}, {'color': 'blue'}),\n", + " (3{CX(2,1)}, {'color': 'blue'}),\n", + " (4{CP(1,0)}(1.571), {'color': 'blue'}),\n", + " (5{barrier(0,1,2)}, {'color': 'blue'}),\n", + " (6{RXX(0,1)}(1.571), {'color': 'blue'}),\n", + " (7{delay(0)}, {'color': 'blue'}),\n", + " (8{CSWAP(0,1,2)}, {'color': 'blue'}),\n", + " (9{MCX(0,1,2)}, {'color': 'blue'}),\n", + " (10{MCY(0,1,2)}, {'color': 'blue'}),\n", + " (11{MCZ(0,1,2)}, {'color': 'blue'}),\n", + " (12{CT(2,1)}, {'color': 'blue'}),\n", + " (inf, {'color': 'red'})]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(dep_graph_copy.nodes(data=True))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "%3\n", + "\n", + "\n", + "\n", + "-1\n", + "\n", + "-1\n", + "\n", + "\n", + "\n", + "0{CX(0,1)}\n", + "\n", + "0{CX(0,1)}\n", + "\n", + "\n", + "\n", + "-1->0{CX(0,1)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "-1->0{CX(0,1)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "2{X(2)}\n", + "\n", + "2{X(2)}\n", + "\n", + "\n", + "\n", + "-1->2{X(2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "1{CX(1,0)}\n", + "\n", + "1{CX(1,0)}\n", + "\n", + "\n", + "\n", + "0{CX(0,1)}->1{CX(1,0)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "0{CX(0,1)}->1{CX(1,0)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "3{CX(2,1)}\n", + "\n", + "3{CX(2,1)}\n", + "\n", + "\n", + "\n", + "2{X(2)}->3{CX(2,1)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "1{CX(1,0)}->3{CX(2,1)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "4{CP(1,0)}(1.571)\n", + "\n", + "4{CP(1,0)}(1.571)\n", + "\n", + "\n", + "\n", + "1{CX(1,0)}->4{CP(1,0)}(1.571)\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "3{CX(2,1)}->4{CP(1,0)}(1.571)\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "5{barrier(0,1,2)}\n", + "\n", + "5{barrier(0,1,2)}\n", + "\n", + "\n", + "\n", + "3{CX(2,1)}->5{barrier(0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "4{CP(1,0)}(1.571)->5{barrier(0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "4{CP(1,0)}(1.571)->5{barrier(0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "6{RXX(0,1)}(1.571)\n", + "\n", + "6{RXX(0,1)}(1.571)\n", + "\n", + "\n", + "\n", + "5{barrier(0,1,2)}->6{RXX(0,1)}(1.571)\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "5{barrier(0,1,2)}->6{RXX(0,1)}(1.571)\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "8{CSWAP(0,1,2)}\n", + "\n", + "8{CSWAP(0,1,2)}\n", + "\n", + "\n", + "\n", + "5{barrier(0,1,2)}->8{CSWAP(0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "6{RXX(0,1)}(1.571)->8{CSWAP(0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "7{delay(0)}\n", + "\n", + "7{delay(0)}\n", + "\n", + "\n", + "\n", + "6{RXX(0,1)}(1.571)->7{delay(0)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "9{MCX(0,1,2)}\n", + "\n", + "9{MCX(0,1,2)}\n", + "\n", + "\n", + "\n", + "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "7{delay(0)}->8{CSWAP(0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "10{MCY(0,1,2)}\n", + "\n", + "10{MCY(0,1,2)}\n", + "\n", + "\n", + "\n", + "9{MCX(0,1,2)}->10{MCY(0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "9{MCX(0,1,2)}->10{MCY(0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "9{MCX(0,1,2)}->10{MCY(0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "11{MCZ(0,1,2)}\n", + "\n", + "11{MCZ(0,1,2)}\n", + "\n", + "\n", + "\n", + "10{MCY(0,1,2)}->11{MCZ(0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "10{MCY(0,1,2)}->11{MCZ(0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "10{MCY(0,1,2)}->11{MCZ(0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "12{CT(2,1)}\n", + "\n", + "12{CT(2,1)}\n", + "\n", + "\n", + "\n", + "11{MCZ(0,1,2)}->12{CT(2,1)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "11{MCZ(0,1,2)}->12{CT(2,1)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "inf\n", + "\n", + "inf\n", + "\n", + "\n", + "\n", + "11{MCZ(0,1,2)}->inf\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "12{CT(2,1)}->inf\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "12{CT(2,1)}->inf\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# # get the dag nodes\n", + "# nodes = list(dep_graph.nodes(data=True))\n", + "# print(\"dag nodes:\", nodes)\n", + "\n", + "# # get the dag edges\n", + "# edges = list(dep_graph.edges(data=True))\n", + "# print(\"dag edges:\", edges)\n", + "\n", + "draw_dag(dep_graph, output_format=\"svg\") # 或者使用 \"svg\" 作为输出格式,默认为png" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 0{CX(0,1)},\n", + " 2: 2{X(2)},\n", + " 1: 1{CX(1,0)},\n", + " 3: 3{CX(2,1)},\n", + " 4: 4{CP(1,0)}(1.571),\n", + " 5: 5{barrier(0,1,2)},\n", + " 6: 6{RXX(0,1)}(1.571),\n", + " 7: 7{delay(0)},\n", + " 8: 8{CSWAP(0,1,2)},\n", + " 9: 9{MCX(0,1,2)},\n", + " 10: 10{MCY(0,1,2)},\n", + " 11: 11{MCZ(0,1,2)},\n", + " 12: 12{CT(2,1)}}" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mynodes_dict = dep_graph_copy.nodes_dict()\n", + "mynodes_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "dep_graph_copy.remove_instruction_node(mynodes_dict[5])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "draw_dag(dep_graph_copy, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0, 1, 2}" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dep_graph_copy.qubits_used = dep_graph_copy.update_qubits_used()\n", + "dep_graph_copy.qubits_used" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[-1,\n", + " 0{CX(0,1)},\n", + " 1{CX(1,0)},\n", + " 2{X(2)},\n", + " 3{CX(2,1)},\n", + " 4{CP(1,0)}(1.571),\n", + " 5{barrier(0,1,2)},\n", + " 6{RXX(0,1)}(1.571),\n", + " 7{delay(0)},\n", + " 8{CSWAP(0,1,2)},\n", + " 9{MCX(0,1,2)},\n", + " 10{MCY(0,1,2)},\n", + " 11{MCZ(0,1,2)},\n", + " 12{CT(2,1)},\n", + " inf]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nodes" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## node_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12{CT(2,1)}" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dep_graph.nodes_dict() \n", + "dep_graph.nodes_dict()[12]" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6{RXX(0,1)}(1.571)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dep_graph.nodes_list()[6]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 0{CX(0,1)},\n", + " 1: 1{CX(1,0)},\n", + " 2: 2{X(2)},\n", + " 3: 3{CX(2,1)},\n", + " 4: 4{CP(1,0)}(1.571),\n", + " 5: 5{barrier(0,1,2)},\n", + " 6: 6{RXX(0,1)}(1.571),\n", + " 7: 7{delay(0)},\n", + " 8: 8{CSWAP(0,1,2)},\n", + " 9: 9{MCX(0,1,2)},\n", + " 10: 10{MCY(0,1,2)},\n", + " 11: 11{MCZ(0,1,2)},\n", + " 12: 12{CT(2,1)}}" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# make a node_dict\n", + "node_dict = {}\n", + "for node in nodes:\n", + " if node != -1 and node != float('inf'):\n", + " node_dict[node.label] = node\n", + "\n", + "node_dict \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5{barrier(0,1,2)}" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# test the node_dict\n", + "node_dict[5]" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q[0] --*----+---------P(1.571)----||-------#---------Delay(100ns)----*----*----*----*-------\n", + " | | | || RXX(1.571) | | | | \n", + "q[1] --+----*----+-------*--------||-------#-------------------------x----*----*----*----T-- M->c[1]\n", + " | || | | | | | \n", + "q[2] --X---------*----------------||---------------------------------x----X----Y----Z----*-- M->c[2]\n" + ] + } + ], + "source": [ + "simple.draw_circuit()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 计算qubit used 依据 -1或者inf对应的边的label" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1 0{CX(0,1)} {'label': 'q0', 'color': 'green'}\n", + "-1 0{CX(0,1)} {'label': 'q1', 'color': 'green'}\n", + "-1 2{X(2)} {'label': 'q2', 'color': 'green'}\n" + ] + }, + { + "data": { + "text/plain": [ + "{0, 1, 2}" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# make a qubit_used dict\n", + "qubit_used = {}\n", + "# 依据 -1或者inf对应的边的label\n", + "nodes[0]\n", + "for edge in dep_graph_copy.out_edges(nodes[0], data=True):\n", + " print(edge[0], edge[1], edge[2])\n", + "\n", + "qubit_used = set([int(edge[2]['label'][1:]) for edge in dep_graph_copy.out_edges(nodes[0], data=True)])\n", + "qubit_used\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "set" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dep_graph_copy.update_qubits_used()\n", + "type(dep_graph_copy.qubits_used)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## dag 拼接" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q[0] --------------- M->c[0]\n", + " \n", + "q[1] ------------*-- M->c[1]\n", + " | \n", + "q[2] --H----*----+-- M->c[2]\n", + " | \n", + "q[3] -------+------- M->c[3]\n" + ] + } + ], + "source": [ + "# other circuit to compose\n", + "simple2 = QuantumCircuit(4)\n", + "simple2.h(2)\n", + "simple2.cnot(2, 3)\n", + "simple2.cnot(1, 2)\n", + "\n", + "simple2.draw_circuit()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVAAAAILCAYAAAC+ScRwAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeVxU1f/H8dewDSCggigKlgvghqC5m6UhoWYuLWp9tdQ07WsqlmUu1bdFs372te1bLplpqWVSau4omlvagruiKbiCoLIKArKc3x/XQZFFYO7MHYbz5HEf6Mydez9s77n33HPu0QkhBJIkSVJFRdhoXYEkSVJVJQNUkiSpkmSASpIkVZKd1gVIkhqSSeYyl0kllSyyyCGHG9zADjtcccUWW2pRi3q3Pmyx1bpkyQrIAJWqDIHgBCc4wAGO3fo4xSniiCOb7HJvxxZb6lGPJjQh4NZHIIF0oAOOOJrwK5CsjU5ehZcs2XnOs451bGc7u9nNNa6hR08LWtCKVrSgBQ1pSH3q04AGuOOOI47o0eOMM7nkkkEGBRSQTDKJJBJ/6+MUpzjBCY5xjGSS0aOnIx3pQQ8e4zE60QkdOq2/BZLlipABKlmcOOJYylJ+4ReiiKImNelOd3rQg4d5mCCCsFP55Ok859nJTnaxix3sIJZYvPFmIAMZylC60EXV/UlWQQaoZBkEgq1sZR7zWM96alGLJ3mSJ3iCYIJxwMGs9RzlKKtZzc/8zBGOEEQQYxnLczyHCy5mrUWyWDJAJe1tYxvTmc5f/EU72jGGMTzHczjhpHVpAEQRxUIWspzlOOLIeMbzCq9Qk5palyZpS3akl7TzB3/QgQ6EEoo33hzkIH/zN2MYYzHhCdCOdixgAec4xxjGMJe5+OLLAhZQQIHW5UkakgEqmV0qqbzES3SlK664coADrGY1bWijdWllqkMdPuADznKW4QxnAhPoQhcOcEDr0iSNyACVzGovewkiiLWs5Tu+YzvbLT447+aBBx/zMQc4gB49nenMHOYgkK1h1Y0MUMlsPuRDetCDQAI5ylGGMlTrkowSQAA72clMZjKDGTzGY6SSqnVZkhnJi0iSyeWTzzjG8Q3f8DEfE0aY1fWv/IM/eJqnqUUtNrEJH3y0LkkyPXkVXjKtPPIYzGC2sIUf+IH+9Ne6JJO5yEX60Id00tnBDprSVOuSJNOSV+El0xEIRjOaiFsf1hyeAA1pyG52U4969KIXiSRqXZJkYjJAJZN5i7f4gR/4mZ95kAe1LscsalObjWzEFlse47EKjdGXqh4ZoJJJRBLJbGbzJV/Si15al2NWnniyiU3EEstrvKZ1OZIJyTZQSXUppBBAAN3oxkpWal2OZn7iJ57hGdaxjr701bocSX2yDVRS3yxmkUceC1igdSls3LgRf39/7OzMf+fGwQzmGZ7hFV4hl1yz718yPRmgkqrOcpb/8T/+w3+oRS3N6oiJiaF///5MmzaNxETtLubMZjYXuWgRbyaS+mSASqr6gi9oQANe5EVN63jrrbfo2rUrUVFRuLq6albH/dxfOH5ejpu3PrINVFJNLrl4481EJvImb2paS1ZWFk5Oyg1JfHx8SEhIIC8vT5NaTnKSFrQgkkiCCdakBskkZBuopJ5IIrnGNYYzXOtSCsPTEjSnOZ3oxApWaF2KpDIZoJJqdrObZjSjIQ21LsXihBDCHvZoXYakMhmgkmr2s19OfVGKrnTlH/4hiSStS5FUJANUUs05ztGMZlqXYZH88UcguMAFrUuRVCQDVFJNEkl44GGWfR07dgydTldkGT9+vFn2XRmG78s1rmlciaQmOS+8pJob3DDbVBwBAQFUpQ4kNagBQCaZGlciqUkegUqqqU1tUkjRugyLlEwyAO64a1yJpCYZoJJq6lCHq1zVugyLZPi+1KGOxpVIapIBKqmmFa04yEGty7BIhvmT5E2WrYsMUEk1XenKPvZZxORq69evL7y4FBcXR35+fuH/Fy1aZPZ69rGP9rRHj97s+5ZMRw7llFRzlKMEEshudtONblqXYzHyyON+7mc0o3mXd7UuR1KPHMopqac1rWlLWxazWOtSLMomNnGZyzzP81qXIqlMBqikqtGMZiUriSde61Isxqd8SjDBsv3TCskAlVT1Ai/giSf/4T9al2IRNrGJ7WznHd7RuhTJBGQbqKS6ZSxjBCP4nd/pSEety9FMFlm0pz1++LGGNVqXI6lPzgsvqU8g6Ec/TnKSAxzADTetS9LEOMbxAz9wkIM0opHW5UjqkxeRJPXp0LGIRVznOqMZXS3vxL6CFcxnPgtZKMPTiskAlUzCCy9WspJf+ZVJTNK6HLOKIIKRjGQykxnEIK3LkUxI3kxEMpke9GA5yxnCEJxw4kM+RIdO67JMahvbeIqnGMIQ/o//07ocycTkEahkUk/xFEtYwid8wnCGW/X0vstZTl/60p/+fMM3Vv9mIckAlcxgGMNYz3rWsIZggq3upsK55DKFKTzHc0xkIstYhj32WpclmYEMUMksQgnld34nmWTa0paf+VnrklRxhjM8xEN8xVcsZjFzmCOPPKsRGaCS2QQQwF/8xVM8xdM8zQAGcI5zWpdVKdlk8y7v0prWZJPN3/zNCEZoXZZkZjJAJbNyxpmFLGQ72znNaVrRiulMrzJTXeSTz3d8RwAB/Jf/MpOZ/MVfNKe51qVJGpABKmniER7hMId5n/f5hm9oTGOmMY1LXNK6tBJlkcViFtOCFoxiFA/zMNFEM5nJsr2zGpMjkSTNZZLJPObxER+RQgp96csYxhBKqObhdIxjfMM3LGUpmWTyL/7Fm7wpbwwigRzKKVmKwxymJz1pQQvssec3fqM2telHP57kSYIJxgUXk9eRTz4HOchqVvMLv3CSkzShCS/yIiMZST3qmbwGqcqQASpp7zCHCSGEFrRgIxtxwYWznOWXWx/72Y8NNjzAAzzEQ3SiEwEE4IcfdkaOBYkjjuMcJ4oo9tz6SCedRjTiyVsfXeiCjWztkoqTASppq6TwvFsiiexkJ7vZzW/8RjTR5JOPAw7448993IcXXvjggxtuuOKKHXa44koOOdzgBjnkkEYaiSRyiUskkMApThXOIuqNN93oxsO3PgIIMPe3Qqp6ZIBK2ilPeJYkm2yiieY4xznJSTawgWyyscOOdNK5znVyySWDDBxwoAY1cMSRbLLxxJMHeAAvvPDDj1a0IoAAPPAw8VcrWSEZoJI2KhueJfHFl2d5lvd5v8z1BjIQPXpWsrLS+5KkO8jb2Unmp2Z4XuISMcTQne73XDeIIA5zuNL7kqS7yQCVzErN8ATYwQ4ccKALXe65bmtac4Yz3OCGUfuUJAMZoJLZqB2eADvZSSc6UYMa91w3iCDyyec4x43erySBDFDJTEwRngC/8Rs96FGudZvSFBdc5Gm8pBoZoJLJmSo8K9L+CWCDDa1oxRGOqLJ/SZIBKpmUqcITKtb+aRBEkAxQSTUyQCWTMWV4gnL63olOOONc7tcEEshhDiOQvfck48kAlUzC1OEJSoA+wiMVek0ggaSSykUuql6PVP3IAJVUZ47wvMhFYoktd/unQSCB6NDJ03hJFTJAJVWZIzzhdvtnZzpX6HU1qcn93C+vxEuqkAEqqcZc4QlK/8/OdK5Q+6dBIIEc5agJqpKqGxmgkirMGZ5Qsf6fd5NDOiW1yACVjGbu8DS0f1Y2QFvTmtOclkM6JaPJAJWMYu7wBKX9U4++wu2fBoYhnSc4oXJlUnUjA1SqNC3CE263fzrhVKnX++JLDWrI03jJaDJApUrRKjxBOQKt7Ok7yCGdknpkgEoVpmV4XuQiZzlb4f6fd5NDOiU1yACVKkTL8ATYznaj2j8NAgmUASoZTQaoVG5ahycY3/5pEEggySTLIZ2SUWSASuViCeEJxvX/vJMc0impQQaodE+WEp6G9k81ArQWtbiP++SVeMkoMkClMllKeMLt9s9OdFJle3JIp2QsGaBSqSwpPEE5fe9CF6PbPw3kkE7JWDJApRJVJjxTUlKYP38+wcHBuLu74+TkhJ+fH0OHDuXwYeODagc7Knz/z7K0pjX/8A9ZZKm2Tal6kQEqFVPZI8/XX3+dCRMmMGDAAE6cOEFSUhKLFy/m0KFDtGvXjjVr1lS6phhiOM95ggmu9DbuJod0SsaSASoVYexp+wsvvEBYWBheXl44Ozvz0EMPsWLFCvLz85kyZUql69rBDpxxpgMdKr2Nu/niizPO8jReqjSdEEJODiMBt8OzJS3ZwAZV2zydnZ3JyckhLy8PnU5X4dcPZSjXuMYWtqhWE0BHOtKVrnzKp6puV6oWIuQRqASYNjwzMzPJysoiICCgUuEJlZv/qDzkkE7JGDJApTLD8+TJkwwcOJCaNWvi7OxMx44dWb9+PSEhIeh0OnQ6HaNHjy5z+6tWrQJgxowZlaovmmjiiVe1/dPAMEunJFWGndYFSNoqKzzPnDlDly5dqFGjBuHh4XTp0oXz588zadIkjhw5gl6vJzs7u8ztJyYmMnXqVEaPHs3gwYMrVeN2tuOKKw/wQKVeXxbDkM5LXMIHH9W3L1k32QZajd3rtH3w4MGsWrWK8PBwnnrqqcLHr169SqNGjcjPzy8zQJOSkggJCaFZs2YsX74cW1vbStX5NE+TQw7rWFep15cllVTccWc963mMx1TfvmTVZBtodVWeNs/NmzcD0KtXryKPe3p60rx58zK3n5mZSa9evWjZsqVR4SkQ7GSnSdo/QRnS2ZCG8jReqhQZoNVQecIzJyeH69ev4+joiItL8edr165d6vbz8vIYNGgQ3t7eLF26tNLhCXCEI1zjmknaPw3kkE6psmSAVjPlvdqu1+txdXUlOzubjIyMYs9fuXKl1H2MHTuWnJwcfvrpJ+zsbjez+/r6sn///grVu53tuONOIIEVel1FyCGdUmXJAK1GKtpVqU+fPsDtU3mDhIQE/vnnnxJf884773D8+HHWrl2LXq83umbD8E0bE/6qGoZ0ZlP2BTFJupsM0GqiMv08P/jgA9zd3Zk0aRJbt24lIyODY8eOMXLkSLy8vIqtv2TJEt59913++OMPXF1dC7s5GZaYmJgK1ZxPPrvZbbL2T4MggsgjTw7plCpMBmg1UNlO8k2bNmXfvn106NCBp59+mnr16jF27FimTZuGr69vsfXDw8NVrTuKKFJJNXmA+uEnh3RKlSL7gVo5Y0cY+fv7s3r16nKtu379+sqUWKod7KAudWlBC1W3ezdbbGlJSzkiSaoweQRqxUw5PNMcdrCDnvRER+WGf1aEHNIpVYYMUCtV1cMzl1z2sMfkp+8GckinVBkyQK2QKcPzxx9/RKfTERkZSU5OTrnGwlfGH/xBJplmDdAkkogjziz7k6yDHMppZar6kafB+7zP13zNBS6YZX/JJOOBBxvZSB/6mGWfUpUnh3JaE2sJT1DaP005+uhu7rjLIZ1ShckAtRLWFJ7ZZLOPfWY7fTeQQzqlipIBagWsKTwBfud3sslWZf73ipBDOqWKkgFaxVlbeIJy+u6LL/dzv1n325rWnOKUHNIplZsM0CrMGsMTlBuImPv0HW4P6Ywm2uz7lqomGaBVlLWGZwYZ/MVfmgSoP/444SRP46VykwFaBVlreALsYQ955GkSoHJIp1RRMkCrGGsOT1DaP1vQAi+K3+3JHOSQTqkiZIBWIdYenqC0f5qz/+fd5JBOqSJkgFYR1SE8U0jhIAfN3n3pToEEco1rxBOvWQ1S1SEDtAqoDuEJ8Bu/AWjS/mkQRBCAPI2XykUGqAWIJ54rlDzHUHUJT4BIImlLW9xx16wGd9zxwUeexkvlIgPUAnzIh3Sne7EQrU7hCbCNbYQQonUZckinVG4yQDWWSCILWMApTvEQDxWGaHULzzjiOMUpetJT61LkkE6p3GSAamwucxG3Ps5ylq50JZJIetKTQALZxCarD0+ArWzFEUce5EGtS6E1rTnJSXLI0boUycLJANVQMsl8wRfkkgsod2G/wAVGMYoQQljHOpxx1rhK84gkkgd5ECectC5FDumUyk0GqIY+5/PC8DTIJZc44vibv0knXaPKzM8w/5El8McfRxzlabx0TzJANZJBBp/yKXnkFXsujzzOc55udCOBBA2qM6/jHCeOOIu4gARgh50c0imViwxQjXzFV2SSWerzhhDtTneuctWMlZnfNrZRi1o8wANal1JIDumUykMGqAayyOIjPirx6PNOOnSc4xwrWGGmyrQRSSSP8Ai22GpdSiE5pFMqDxmgGviar0kltdTn7bHHEUf+zb+JJZYwwsxYnXnlkccudllM+6dBIIFc5SqXuax1KZIFs9O6gOoml1w+4iMExSdDtcMOe+x5kReZxjTN7khkTn/yJ2mkWUz7p8GdQzrrU1/jaiRLJY9AzWwpS0kgoUiA2mJLLWoxgxnEE89nfFYtwhOU03dvvGlGM61LKcIDD7zxlu2gUpmq3RFoZiakpytLRgZkZUH2HVPgZGRA7h09i5ydQa+//X83N7Czg1q1oGZN5f/29uXbdz75zGQmAoHu1ocHHkxnOmMYU236fN4pkkge5VGtyyhRIIEyQKUyWUWAXr0KMTEQH68sV64onxMTleXaNUhNVUIzP1/9/Ts5gasr1K4Nnp5Qvz54eUHduuDtrXxu1Aj+8lvJeYfzADSkITOYwQhGoEdf9g6s1A1usJ/9jGa01qWUKIggNrBB6zIkC1ZlAjQjA44fhyNH4PRpiI1VQjM2VglGA09PqFdPCbD69aFZM+Wx2rWVo0VXV+Wz4d8ODlCjxu3X333Eef065N1xsTwlBQoKIC1NCeXr128f0aam3g7vgwchIUH5940bgE0BHPkAO2c/mix/i85nn+VKIzt+bQ6BgeDrC7aWcxHaLHaxixxyNL19XVla05qP+Zgccqrtm5xUNosM0CtXYN8++PtvOHZMCc2zZ0EIJez8/aFpUwgNVT43aaJ89vEp/+l0ebm6Fv1/7doV38b16xAZf4rf096h7pYnOXvZhpg4+H2X8nXl54OjI7RqBa1bK0unTtCunfK4tYokkla0whtvrUspkWFI50lOFl5UkqQ76YQQxS8Hm5EQcPQo7NmjhOa+fcqRpY2NEpSBgUqgBAQonxs3Vp6zFllZcOKE8j0wvFkcPqy8iTg4wAMPQOfO0KULdO+uHF1bi7a0pTvd+ZRPtS6lRHnk4YorC1jA8zyvdTmS5YnQJECvXoXffoNt22DjRrh0CVxcICgIunWDBx+Erl3Bw8PclVmO+HjYu1d5Y4mKgr/+gps3laPtxx+Hfv2U71VVPUJNIom61GUNa+hHP63LKdUDPEAwwXzMx1qXIlke8wVoTAysWqUsBw8qp9oPPqichj/6KLRta11HlmrLyFDedCIilOXUKaW9NjQUBg1SAvXu5gZLtpKVDGMY17hGTWpqXU6pRjKSOOKIIELrUiTLY9oAvXgRVqxQQjMqSrmY8+STyh97jx5FL95IFXPhAmzZAr/8ApGRygWoPn1g8GAYONDyj0zHMIbjHGcve7UupUyf8AmzmV3qlCtStaZ+gBYUwPbtsHAhrF6tHBU9/rhylNS7t/oXeSSlZ8C6dcobVUSE0q1qyBAYP15pN7ZETWjCMIbxHu9pXUqZIokkhBAuc7naDG6Qyi1CtZPm9HSYPVvp7xgaqvxRr1ih9MP87jvlqFOGp2nUrg3PP6+E6Pnz8MYbsHWr0qb8yCPK49peKizqHOc4y1mLG/9eEjlLp1QWowM0NRXefVcJzo8+gmeegX/+Uf6ABw2SoWluXl4wbRqcOaNcoHN1hQEDlC5Rq1dbRpBGEIEzznSms9al3FMd6tCABjJApRJVOkBv3rx9xPnZZxAWBufOwf/9n9IpXNKWjY3SZPLrr8pFuyZN4OmnoU0b2LFD29oiieRhHq4yndPlkE6pNJUK0G3blP6ZM2fCq68qwfmf/yjjwyXLExQE4eFK/9JGjSA4GP71L6WrlLkJhEVN31Ee8t6gUmkqFKDXr8Nzzyndjlq0UDqAv/22MixSsnwBAbB2rdIm+scfys9w8WLz1nCIQ1zlqsXdvq4sgQQSTTQ3ual1KZKFKXeAHjsGHTooV3nXr1fa0+6/35SlSaby+OPKz/Pf/4bRo2HkyFvj9c0gkkg88CCQQPPsUAVBBJFLLic5qXUpkoUpV4D+/LMyNtvTU2lP69vX1GVJpubkBB9+qLwZ/vqrMlz00iXT79fQLcimCt2KtjnN0aOXp/FSMff8LV61SrmyPmKEcvGhQQPTFHLo0CH69u1LrVq1cHV1JSQkhL17793JOj8/n2nTpuHn54ejoyN9+vQp8ryLiws6na7I8vHHRYfl+fj4FFvnzTffLLav8+fP079/f9Jv3f4pJSWF+fPnExwcjLu7O05OTvj5+TF06FAOHy7+xzZ16lRWrlxZ6tcycuRI9Ho9jRs3JiwsjOw7b1RqIo89BgcOKP13H3kE4uJMt6+b3GQ3u1Vp/xRCsHfvXl5++WX8/f3R6/XUrVuXbt26sWzZMtTs3myHHS1oIS8kScWJMoSHC2FnJ8SkSWWtZbz9+/cLJycnMWTIEBEfHy+uXr0qXnzxRWFnZye2bNlS5msXLFggAPHee++JlJSUEtc5ePCgAMSAAQNK3c7Zs2cFIB588MFSt1GnTh3xxRdfFD42atQoYWdnJz799FNx+fJlkZmZKXbt2iVatmwpbG1txerVq4ts48yZM6Jx48bizTffLLWO9PR0MX/+fAGIWbNmlfWlqyoxUYiAACH8/ISIjzfNPn4TvwkEIkbEGL2t6OhoAYiQkBBx+PBhkZWVJWJiYsSzzz4rADF58mQVKr5tuBguQkWoqtuUqrwtpQbo6dNCuLgI8fLLpq0gPz9ftGrVStSvX1/cuHGj8PG8vDzRrFkz0bBhQ5GdnV3q6w1/MOnp6aWuY2yApqWlCR8fHzF27Ngij48aNUqMGTOm2PqHDh0SgPDz8yvxOZ1OJ1auXFlqLUII4ezsLEJDzfsHm5gohL+/ECEhQhQUqL/9GWKGaCKaqLKt6OhoYWdnJ5KTk4s8npOTIzw8PIRery/z96ai/iv+K+qKuqptT7IKJQdobq4QXboI0batEDk5pq1gx44dAhATJkwo9tw777wjABEeHl7q60NDQ4WtrW2Z+zA2QGfMmCHs7OxEXFxcmfu5k5OTk7CxsREFJSTRoEGDhI+Pj8jNzS319Q0aNBDt2rUr9/7UcuCAEA4OQnzyifrbbi/ai3+Lf6u/4bu0adNGACI1NVW1bW4VWwUCkSASVNumVOVtKbENdMEC5WLR8uXKPSlNafv27QC0b9++2HOGxyIjI0t9fb4p5ui4gxCCRYsW0alTJxqUswE4MzOTrKwsAgIC0Ol0xZ5/4oknuHTpEhs2lD5dhE6nIy+v7HnjTaFtW6Vr2vTpcFnFGX2vcY0DHKAXvdTbaAlSU1M5ffo0bdu2pWZN9e7yJId0SiUpFqAFBTBnDrz4otJP0NROnlS6hvj4+BR7zttbuVP5P//8Y/pCSnH48GESExMJCir/HclXrVoFwIwZM0p8vk2bNgBs2bLF+AJNYPJkZXz955+rt82tbMUGG3rQo9R1Tp48ycCBA6lZsybOzs507NiR9evXExISUnhxb/TokudPSk9PZ+/evfTv3x8vLy++++479YoHPPGkPvVlgEpFFJvS4/fflRtSvPSSeQpITU0FoEYJ97ZzcXEBlKvdpbl58yZ6ffmGBK5du7bEI8KyHDt2DCg54EuSmJjI1KlTGT16NIMHDy5xHcMbg2HbJdHr9eTeOT2oGTk6Kr0uli1ThuuqIYIIutCl1Ht/njlzhi5dulCjRg3Cw8Pp0qUL58+fZ9KkSRw5cgS9Xl9qr4SZM2fy1ltvAdCjRw9Wr15NQECAOoXfQQ7plO5W7Ah0zx5o2BBattSinKLEra4oZYXehQsXyh1uAwYMQAhR4nL27NkSX3P51nlseU4Hk5KS6N27Nz169GD+/Pmlrufm5oZOpyvcdkkaNGhAXFycJqfxoIyjv3BBeTNVwza2EUpoqc9Pnz6d1NRUPvvsMx599FFcXFxo1aoVK1asIDMzs8xtv/nmm+Tk5BAdHU3z5s1p27Yt77//vjqF30EO6ZTuVixAY2KgeXPzFVDr1gD6kv5IDI/VKmGQfXJyMnPmzOH8+fOMGzfOZPUZjnrs73FbqczMTHr16kXLli1Zvnw5tveYYtPOzo6srKxSnx87dizp6em8/fbbXLt2reKFG8nQfBMTY/y2jnKUS1wqs/1z8+bNAPTqVXQdT09PmpfjF9LBwYHmzZszb948+vfvz9tvv822bduMK/wuckindLdiAZqVpUwVYS6GP45LJQyDibvVq9vf37/I4yNGjMDDw4OpU6cyZcoUJk6caLL6HG/d2r2s0+m8vDwGDRqEt7c3S5cuvWd4Gl7j5ORU6vPDhg1j1qxZzJkzB09PT3r37l3x4o1gaFFRY4hnBBF44EE72pX4fE5ODtevX8fR0bGw2eZOtSs4FWq/fsocS+vXr694sWUIIoib3OQUp1TdrlR1FQvQ2rXBnAc8jzyizAkeFRVV7DnDYz17Fh25smTJEtLS0vjxxx+ZO3cuY8eONVl99evXByAtLa3UdcaOHUtOTg4//fQTdna3m5V9fX3Zv39/sfXT09MRQhRuuyQzZsxg+vTpzJs3j9TU1MIjNHO5elX57O5u/La2sIVHebTU4Zt6vR5XV1eys7PJyMgo9vyVKxWbTsPQJp6cnFzxYsvQghZySKdURLHf6Natlal1zXX9onv37rRs2ZLw8PAiFwny8/P58ccfadiwIX1LGHzv5ubGoEGDaNu2LeHh4Sarz3AxoqQjZIB33nmH48ePs3bt2nJfzDIcWZd1oeOXX36hcePGjB49WtXuOOUVFaXcU9TYazHZZLOHPWW2fwKFQ3DvfqNISEgosRfGa6+9xrBhw0rc1qZNmwDo0KFDZUoulR12NKe5vJAkFSoWoKGhygyQW7eaqQAbG7755huSk5MZOXIkCQkJJCUl8fLLL3P69Gm+/vrrwtPokri5uRWOTTeFoKAg6tatW+LY9iVLlvDuu+/yxx9/4OrqWmw8fUwpDYiHDhlKk6EAACAASURBVB0CIDS09FC5fv06bhreJzA8XJmL3tgSdrKTLLLuefu6Dz74AHd3dyZNmsTWrVvJyMjg2LFjjBw5Ei+vkuciWrFiBe+99x7nzp0jJyeHc+fO8cYbb7Bs2TLatWtXapcnYwQRJANUuq2k7vU9ewrxyCNm6st/y4EDB0SfPn2Em5ubcHFxEcHBwWLPnj33fF1ISEiZI5Fq1KghgCLLnDlziqzj7e1dbJ0ZM2YUPj99+vQSRyL17du32OvuXvbt21espkGDBglvb29x8+bNUuv29vYWbdq0uefXbwrnzyujkRYvNn5br4pXRYAIKNe6p06dEgMHDhRubm7C2dlZdO3aVezcuVP07NlT6PX6IuumpaWJRYsWiV69eolGjRoJBwcH4eLiItq1aydmz55dZFiwmj4WHwsv4WWSbUtVTslDOffsEcLGRoilS81dT8X17dtX6HQ6k+4jNTVVeHt7FxsLXxmGsfA//PBDmevVq1dPdO7c2ej9VVRBgRC9eytj4svI93JrJVqJV8WrRm2jpADVSoSIEAhEokjUuhRJeyUP5XzwQXjlFXj5ZWVyMkvm4+ODEILExEST7aNmzZqsW7eO8PBwvvzyy0pvJzY2lieffJJp06bxzDPPlLpebm4uycnJ5e7fqqb//U+ZsuW774yfEDCOOE5w4p7tn1VJG5RRZPI0XoIy7gc6a5YyEdkTT9y+ImuJDN17PvzwQ5KSkky2n7Zt2/L333+zadOmSre5LliwgFmzZjFr1qxS10lLS2Pu3Lnk5uaavevSxo3w+uvKWPhOnYzf3ha2oEfPQzxk/MYshCeeeOElA1RSlHV8evGiEL6+QjRvLsTly2Y6KK6Ejz76SLRo0ULo9XrRu3dvrcuptOHDhwt7e3vh6+sr3nrrLZGXl2e2fW/eLISjoxAvvCBEfr462xwihhh1D80ffvihWJvyqFGj1CnOCKEiVAwXw7UuQ9LeFp0QZd+6++JF5U7l9vbK1B6WMMRTUteiRTB+PAwdCl9/rXRfMlYBBXjhxRu8wWQmG79BC/I6r7ONbRzkoNalSNqKuOefSsOGsHMneHhAx47KDSYk65CZCcOHw5gx8Npr6oUnQBRRXOWqyW9fp4VAAjnBCTmkUyrfzF7e3sp8SGPHwvPPK1MbJySYujTJlH77Ddq3hw0blGXmTPXCE5T2z/rUpxWt1NuohTAM6fwH7W6zKFmGcv/J2NvDf/+rzOC4e7dyw5EvvgAT389YUtnlyzBsGAQHg6+vcuPsu+bhU0UEEfSmNzoqdvvAqqAFLXDAQQ7plCo+t+zjj8OJEzBunHLa16aNMnNnQYEpypPUkpysXF1v3hz27oU1a2DdOqWJRm3Xuc5+9ltV96U72WMvh3RKQCUCFJS7NX3wgTJmvlUrZdrj1q3hhx/kEamluXoVpk2DRo3gq6/gjTfg+HHo3990+4wkknzyVZm+2FLJIZ0SVDJADZo1gx9/hNOnoVs3pX30/vth6lTl6r2knagopc26cWPlKvurryr39pw+3fS3K4wgggd4AE88TbsjDcmbK0tgZIAaNGmiTEQXHa0cjS5aBE2bwtNPw+bN5ruzU3V37ZpylNmmjXKB6M8/lXbrc+fgnXfAXDd1iiDCKq++3ymQQC5zmStU7FZ7knVR8bqrclHi44/h0iVYvBgSE5ULFPXrw+jRsGULaDRDhdW6dk3pfhQaqnyfX38dHngA9u9XLhCNHXv75sjmcIYzxBBjte2fBoYhnUc5qnElkpZUDVADR0flSu/u3XD2rNLuduSIMs+Ol5fy3Hffya5QlSGEEowffQQ9eyqhOWmSctu5ZcvgyhXlzUuNoZiVEUEErrjShS7aFGAmdalLPerJdtBq7p4jkdR09qwymmnTJuVK8M2bEBioHD09/LBy/0kPD3NVUzUIAadOKUeU27Yp92m9cgXq1YNHH4V+/aBvX/MeZZZlAAPQoWMNa7QuxeRCCcUbb77lW61LkbQRYdYAvVNmpjLCKSJCWU6eVMKiWTPo3FkJ044dlaGj5bzRu1VISlKOMPfvV5Z9+5QuSI6O0LWr8mYTGqq0c1ZwhmaTyyMPDzyYzWzGYbqJ/izFa7zGdrZzgANalyJpQ7sAvVtSUtHQ+PNPuH4d7OzA31/pJhUYqHxu1kzpluPgoHXVlZeaCrGxSpeio0fh8GE4dgzi45Xn77tPCczOnZXlgQeMv72cqe1iF93pzhnO0JSmWpdjct/xHWMYw3WuY4+F/3AkU7CcAL1bfj7880/RcDl6VGkGALC1BR8fpQeAYWnYUGljrV9fOcX11KgXzc2byml2fLxyIe3yZeVKeGzs7cVw5z0HB6UvbevWyvxDQUHKG0Ups1hYtDd5kxWsIJZYrUsxi8Mcpg1tOMYxqxyyKt2T5QZoadLTlX6nhiCKibn977g4JbwMHBygbl1lqVlTudDi6qp8dnMDw3TzNWveHgdubw+GmXWFUI4UDbKzlWmfc3OVOtLSlOevX7/9/8TE4vdPdXNT+sc2aaJ077oz9Js2VY6yrUGHWx9f8ZXWpZjFTW7iiivf8i3/4l9alyOZX9UL0HtJSlKu7icmKkeAV64oS3p68SUtrfSQNCgpXO3slFB0cUnn2rUvadNmPB4erri5KWHt7a18rl9fWcqY/t1qXOEK9anPL/zCAAZoXY7ZBBLIYzzGh3yodSmS+UVYybHPbR4eytLKDGdUqakF+PjMYuxYV8aPH2/6HVqwjWzEHnurHr5ZEjmks3ozST/Q6qJWrVo8//zzfP755xRU87upbGADPeiBCy5al2JWckhn9SYD1EiTJk0iJiaGTZs2aV2KZnLJZRvb6EtfrUsxu0ACiSeeq1jwxGGSycgANZK/vz+hoaF89tlnWpeimd3sJpVUHuMxrUsxuyCCADmks7qSAaqCsLAwtm7dypEj1bMtbAMbaEnLatH3825eeFGXurIdtJqSAaqCXr160aJFC6PmjK/KNrChWp6+GwQSKAO0mpIBqgKdTsf48eP5/vvvTTo3vSWKJZZTnKr2ASovJFVPMkBVMmLECJycnFi4cKHWpZjVr/xKTWrSla5al6KZQAI5znHykPdqrG5kgKrE2dmZUaNG8b///Y/canQH6Q1soA99qvVY8CCCyCFHztJZDckAVdH48eO5cuUKv/zyi9almEUGGexmd7U+fQdoSUs5S2c1JQNURffddx8DBw6sNl2aIoggl1yrv/v8vTjggD/+8kJSNSQDVGVhYWHs27ePP/74Q+tSTG4DG+hMZ+pSV+tSNCeHdFZPMkBV1q1bNzp06MDnn3+udSkmJRBsZnO1P303kFfiqycZoCYwYcIEVq1axaVLl7QuxWSiiCKeeBmgtwQSSBxxXOOa1qVIZiQD1ASGDBmCh4cH8+fP17oUk9nABnzwIZBArUuxCHJIZ/UkA9QEHBwceOmll1iwYAFZd95c1IpsYAOP8zg6LGxiJo3Up74c0lkNyQA1kXHjxpGRkcGKFSu0LkV1V7hCFFHy9P0urWktA7SakQFqIp6enjzzzDN8+umnWNlN/1nPevToCSZY61IsiryQVP3IADWhV199lWPHjrFjxw6tS1HVBjbwCI/gjLPWpViUQAI5xjE5pLMakQFqQq1bt6Z79+5W1bE+l1wiiZSn7yUwDOk8zWmtS5HMRAaoiYWFhbFu3Tr++cc6xknvZCdppFXLmyffS0taYo+9PI2vRmSAmlj//v1p3LgxX31lHVP9bmADAQTQiEZal2Jx9OjlkM5qRgaoidna2jJu3DgWL15MWlqa1uUYzdB9SSqZHNJZvcgANYMXX3wRnU7Ht99+q3UpRvmHfzjNadn+WQZ5d/rqRQaoGbi5ufH888/z2WefkZ+fr9p2U1JSmD9/PsHBwbi7u+Pk5ISfnx9Dhw7l8GH12+HWsx533OlMZ9W3bS0CCeQiF0lCnZkJNm7ciL+/P3Z2dqpsT1KXDFAzmThxIhcuXGDDhg2qbfP1119nwoQJDBgwgBMnTpCUlMTixYs5dOgQ7dq1Y82aNartC5TT9970xg75x1watYZ0xsTE0L9/f6ZNm0ZiYqIapUkmIAPUTPz8/OjTp4/qXZpeeOEFwsLC8PLywtnZmYceeogVK1aQn5/PlClTVNtPOunsYY88fb+HBjTAE0+jT+PfeustunbtSlRUFK6uripVJ6lNJ6xtmIwF27p1K6GhoRw6dIigoCCT7svZ2ZmcnBzy8vLQ6Ywfrx5OOM/wDIkk4oGHChVar570pDGNWcSiSm8jKysLJycnAHx8fEhISCAvT3bQtzAR8gjUjB599FECAwP54osvTLqfzMxMsrKyCAgIUCU8Adawhm50k+FZDmoM6TSEp2TZZICa2csvv8yyZctKbdc6efIkAwcOpGbNmjg7O9OxY0fWr19PSEgIOp0OnU7H6NGjy9zHqlWrAJgxY4YqNeeRx2Y2M4ABqmzP2hlm6czn9gVDNX6ukgUSklnduHFDeHh4iPfff7/Yc6dPnxa1atUS3t7eIiIiQly/fl0cO3ZMhISECE9PT6HX6++5/YSEBFGvXj0xevRo1WqOFJECgfhH/KPaNq1ZlIgSCES0iBZCGP9z9fb2Fra2tuYoXaqYLTJANTB16lRRv359kZOTU+TxQYMGCUCEh4cXefzKlSvC2dn5nn9o165dE23atBFDhgwReXl5qtU7UUwUASJAte1Zu2yRLeyEnfhR/CiEMP7nKgPUYm2Rp/AaGD9+PNeuXSM8PLzI45s3bwagV69eRR739PSkefPmZW4zMzOTXr160bJlS5YvX46tra1q9a5jnTx9r4C7h3Qa83OVLJsMUA14e3vz5JNPMnfu3MLHcnJyuH79Oo6Ojri4uBR7Te3atUvdXl5eHoMGDcLb25ulS5eqGp6HOcxZzsoArSDDkE5jfq6S5ZMBqpGwsDCioqLYt28fAHq9HldXV7Kzs8nIyCi2/pUrV0rd1tixY8nJyeGnn34qMmLF19eX/fv3G1XnWtbSgAa0p71R26luDEM6jfm5SpZPBqhGunTpQqdOnYp0rO/Tpw9w+5TPICEhodTb4b3zzjscP36ctWvXotfrVa9zLWvpT38591EFBRLIBS6QRFKlfq5SFaF1K2x1tnz5cmFnZycuXLgghBDizJkzwt3dvcjV2qNHj4revXuL+++/v9jFhm+//VYAZS779u2rdH2XxCWhEzqxSWwy6uusji6JSwKB+E38VuGf693kRSSLJS8iaWnQoEF4eXkV3iu0adOm7Nu3jw4dOvD0009Tr149xo4dy7Rp0/D19S32+rsvQqltDWuoQQ160MOk+7FG3nhThzoc4UiFf64A69evL+wfGhcXR35+fuH/Fy2q/AgnSV1yKKfGZs6cydy5c7l48SI1atQodb2QkBD27NlDdna22WoLJZRa1OInfjLbPq1JMME0pSlf83Wp62jxc5VUI4dyau2ll14iOzubZcuWaV1KEWmksZOd8uq7EeQsndZPBqjG6tSpw7/+9S8+//xzi5r+eBObKKBAzn1kBMMsnXcO6ZSsiwxQCzBp0iSio6PZtm1bsed+/PFHdDodkZGR5OTkmG3M9FrW8jAPUxvZT7GygggiiyzOcKbYc1r9XCV1yTZQC9GzZ0+cnJxYv3691qWQSy51qcu7vMtEJmpdTpWVQw4uuLCc5QxmsNblSOqTbaCWIiwsjI0bN3Ly5EmtS+E3fiOVVPrRT+tSqjQ9evzwk3MkWTEZoBbi8ccfp0mTJnz55Zdal8Ja1hJEEI1prHUpVZ6cpdO6yQC1EDY2NkyYMIHFixeTnJysWR0Cwa/8Kq++q0TO0mndZIBakBdeeAF7e3tNpz8+yEEuclEGqEoMQzpTSNG6FMkEZIBaEFdXV0aMGMEXX3yh6vTHFbGWtXjjTVvaarJ/axNIIAJh9CydkmWSAWphwsLCuHTpEmvXrtVk/2tZy0AGypuHqKQhDfHAQ57GWykZoBamcePG9O3bV/Xpj8vjPOc5whF5+q6y1rSWAWqlZIBaoLCwMHbt2sXff/9t1v2uZS1uuNGd7mbdr7WTQzqtlwxQCxQcHExQUJDZuzStZS196IMDDmbdr7ULJJCjHJVDOq2QDFALNWHCBH744QcSEhKKPB4VFWX0XeYvc5nZzCaa6MLHUkllN7vl6bsJGIZ0xhCjdSmSymSAWqhhw4ZRq1YtFixYQH5+Pj///DNdunShffv2JY6Zr4ib3GQ602lJS5rSlOlM5wu+AKA3vdUoX7pDK1phi608jbdCdvdeRdKCXq9n2LBhfPrppyxcuJDLly9jY2ODnZ0dSUlJRm3bEcfCf8cSyxzmkEceNanJW7zFEzzBwzyMnfz1UIUTToVDOgcxSOtyJBXJI1ALdObMGcLCwvjyyy/JyMggPj4eIQT5+fkUFBSoGqAAeeQByj1AF7CAnvTEHXeGM5xjHDNqX5JCDum0TjJALciOHTvo3bs3/v7+zJ8/n+zsbPLy8oqsU1BQYPRMjncH6J1yyQUggwwiicQbb6P2JSnkkE7rJAPUgqSlpbFt2zaEENy8ebPU9YwNUAcc7tlR3gYbVrFK3g9UJYEEcp7zpJKqdSmSimSAWpCBAweyZMkSdLqyw+3atWtG7UeHrsz2TRts+JiP6UIXo/Yj3SaHdFonGaAWZtiwYXz++edlrpOSYvyNKUrr62mPPb3oRRhhRu9Duu0+7pNDOq2QDFALNH78eGbMmFHqkWhmZmaxttGKKilAbbHFAw++53s5Ft4EAgiQAWplZIBaqJkzZzJhwgRsbIr/iIQQRh+F6tGX+PjP/IwHHkZtWyqZHNJpfWSAWrBPPvmEp59+Gju74u2VandlssGGOcyhK12N2q5UOsMsnQUUaF2KpBIZoBbMxsaGZcuW0bNnT+zt7Ys8Z2yA3nkEamj3nMQko7YplS2IIDLJlEM6rYgMUAtnb2/P6tWrad++fZEQVesIVLZ7mk8AAXJIp5WRAVoFODk5sWHDBnx9fbG3t0en0xkdoE44Ff57DWtku6cZOOGEL77yQpIVkYOdqwg3t9qsWfMbjz7ahQsXYjl8OImoKEhLg4K7mtRKur7k4gJ3tgJkP+AM7jDx0v/hmt6JWEeoXRscHcHJqfjrJXXIIZ3WRSeEEFoXUZ3cuAEXL0JCAly7pixJSZCcXPxzZiZcvw4ZGZCba9hCLNAVGAnMrnwhv/YHmwLotw5E8VN3Q5jWqAHu7uDhUfrnBg2gfn2oU6fy5VQXs5jFN3xDLLFalyIZL0IegaooPx8uXIDYWIiJgUuXlP9fvgxxccqSetdIvtq1lRC6M5AaNVI+16gBrq7K0aOjI7i5QY0aTbh0KZLIyO+ZMkVZx+GuLp2urnD3hfu7j1TfdPJjVOJ0ap3RceMGZGcrtWVlKf9OSYGcHCW8DaGelATnzxcN+ju7ozo6gre3Eqg+PkqoNmwITZpA06bK5+p+dBtIIOc4Ryqp1KKW1uVIRpJHoJUQHw/HjilLTIyyxMbCuXO3jxRr1lTCo2FDJUh8fJRg8fa+HS6enlBCN89yycjIwMXFpdJfQzbZZd5UpLzS0pTvR3z87TeJ+PjbR9mGNxCDBg2UMDUszZtD69bg6wu2tkaXY/HOc55GNGI3u+lGN63LkYwTIQO0DFlZcPAgHD2qLMeOKZ+Tk5Xn69UDP7+igWBY5OnsbTdu3D4qv3M5c0Z508nPV45eW7aEgABlad0aHngA6tbVunp1CQQeeDCTmYxjnNblSMaRAXqn2FjYsweiopTl77+V01hXV/D3V/7AW7VSPnfoAF5eWldc9d28CadPw4kTcPy48n0/cQLOngUhlCP1du2UpVs36NoVnJ21rto43elOC1own/lalyIZp/oGaEEBHDoE27cry969kJ6utNG1bQsdO95emjbVutrqJykJ/voL/vzz9nL1qtK227YtBAcrS7duVS9QJzCBv/mbfezTuhTJONUrQM+ehU2blMD87Tflj9TTU/lDfPhh6NxZOXW8a9CPZCFiY5Ug3bNH+RlGRysX0Dp3Vn6GoaHQqVPl25XN5Wu+5hVeIZ10bGRX7KrM+gP0+HFYvx7WrYPff1eOVrp0gZAQZWnb1vL/4KSSJSbCrl2wbRts3aq8QdapA336wKBBSqDqS75niqb+5E860YnTnMYXX63LkSrPOgP06FFYsgR++UW5SOHjA/37wxNPQPfu8gjTWh0/DmvWKEtUlNJ23acPDBumfLaUq/xZZOGKKytZyVM8pXU5UuVZT4CmpsKKFfDtt8rFn6ZNYcgQGDgQ2reHe9zkXbIyFy/Cr79CeDjs3Klc8Hv+eRg5Epo107o6aEYznuEZ3uVdrUuRKq/qB+ixYzBnDvz0k3Iq/vTT8MILSpumDE0JlLbTJUuU5eJFeOghePVV5axEq+abwQwml1xWs1qbAiQ1RFTZ1r+9e5U/gMBA5XTt88+VDttLlyqn6TI8JYMmTeC995TmnC1blFFeTz2lXDBcuvTOYbLmI2fptA5VLkAPHoQePZTuK0lJsHat0ub54ovKUEdJKo2NjXJhafVq5XemQwfl98bXF77/Xul3ai6BBHKWs6STbr6dSqqrMgGanAzjxim/9Hl5ytXXvXuhXz95tClVXMuWyin9mTPw2GNK2+hDDylv0OYgZ+m0DlUiQH/8UWn4X7NGuUi0e7fyyy5JxrrvPpg3T+m0D8obdFiYMgLNlO7nfmpRS57GV3EWHaA3b8LEifCvf8Ezz8DJk/Dcc+Y54ty4cSP+/v4lzkdUmvz8fKZNm4afnx+Ojo706dOn1HX/+usvRowYQePGjXFycsLd3Z2AgACeeuop5s2bR0yMMu1DQEAAOp2uyPLMM88UbickJKTIc+3bty+2r/Pnz9O/f3/S05XTxZSUFObPn09wcDDu7u44OTnh5+fH0KFDOXy4/HdLF0Kwd+9eXn75Zfz9/dHr9dStW5du3bqxbNky7r4+OXXqVFauXFnq9kaOHIler6dx48aEhYWRnZ1d7lqM1bat8sa8eLFyZPrQQ8qNUExFh47WtJYBWtUJC3X5shBdugjh6irETz+Zb79nzpwR/fr1E4GBgcLNzU3Y2tqW+7ULFiwQgHjvvfdESkpKievk5+eL1157TdjZ2YnXX39dREdHi+zsbJGQkCAiIiJESEiIAAQgcnNzhRBCJCQkCA8PDwGIZcuWFdvmhg0bhJ+fn8jMzCz23MGDB0WdOnXEF198UfjYqFGjhJ2dnfj000/F5cuXRWZmpti1a5do2bKlsLW1FatXry7X1xsdHS0AERISIg4fPiyysrJETEyMePbZZwUgJk+eXGT9M2fOiMaNG4s333yz1G2mp6eL+fPnC0DMmjWrXHWo7dQpIQIChKhTR4jt2023n5fFy6KL6GK6HUimtsUiA/TyZSGaNxfCz0+I6Gjz7vvZZ58Vs2fPFrm5ucLb27tCAWoIjvT09FLXmT59ugDEwoULS3w+Ly9P9OnTp0iACiHE8uXLBSA8PDxEQkJC4ePJycmiYcOGYu/evcW2lZaWJnx8fMTYsWOLPD5q1CgxZsyYYusfOnRIAMLPz++eX6sQSoDa2dmJ5OTkIo/n5OQIDw8PodfrRXZ2drF96HQ6sXLlyjK37ezsLEJDQ8tVhylkZAgxZIgQjo5CbNlimn0sEAtEDVFD5It80+xAMjXLC9DsbCE6dRLC31+I+Hjz7//GjRuF/65ogIaGhpa5fnR0tLCxsRHt2rUrczu///57sQAVQoj+/fsLQDz11FOFjw0dOlRMmTKlxO3MmDFD2NnZibi4uHJ/DU5OTsLGxkYUFBSU+zUladOmjQBEampqsecGDRokfHx8in19d2rQoME9v0+mlp8vxHPPCeHiIsTRo+pvf7/YLxCIM+KM+huXzMHyAvS114SoWVM5jdJaRQO0Z8+eZa7/yiuvCEB8+OGHlaonPj5e1K5dWwBi1apVYvXq1aJVq1bFjvKEEKKgoEDUq1dPPPjgg+XefkZGhgBEYGBgpeozSElJETVq1BBt27Yt8fkVK1YIQKxZs6bUbXh7e4ugoCCj6lDDzZtCPPSQEC1bCpGTo+62M0SGsBE24mfxs7oblsxli0VdRDp1Cj79VBlZ5O+vdTXq27VrFwCBgYGVen39+vX55JNPAHj55ZcZP348S5cuRV/CHTMOHz5MYmIiQUFB5d7+qlWrAJgxY0al6ktPT2fv3r30798fLy8vvvvuuxLXa9OmDQBbtmyp1H7Myd4evvtO6YT/v/+pu+0a1KApTeWFpCrMogL0iy+gcWMYNUrrSirn5s2bJYaZQXx8PAAeHpWfQnj48OE89thjXLlyBV9fX9q1a1fieseOHQPAx8enXNtNTExk6tSpjB49msGDB1e4rpkzZ1KzZk26deuGra0tq1evJiAgoMR1vb29i9RYEr1eT64WQ4RK0KgRvPSS8uZ+9wyoxpKzdFZtFhWg69Ypd86pqreXu3DhQrkCS2dkPyw/Pz8Adu7cydq1a0tc5/KtiYhq1qx5z+0lJSXRu3dvevTowfz5lbtL+ptvvklOTg7R0dE0b96ctm3b8v7775e4rpubGzqdrrDGkjRo0IC4uDjy7py1TkMjRijj6NXuaC+HdFZtFhNV6elKv7uOHbWupOKSk5OZM2cO58+fZ9y40ue5adCgAQDXrl2r9L52797NL7/8wty5cwF46aWXSClhInhDH0r7e9y7LzMzk169etGyZUuWL1+OrRH3fHNwcKB58+bMmzeP/v378/bbb7Nt27YS17WzsyMrK6vUbY0dO5b09HTefvtto75fagkIUO4lW8ZBc6UEEkgssXJIZxVlMQGakaF8NmKiSU2MGDECDw8Ppk6dypQpU5g4cWKp63bv3h2AI0cqd8SRkZHBiBEjWLhwIa+88gp9+vQhISGBsLCwYus6OiozbpZ1GpyXl8egQYPw9vZm6dKlRoXn3fr16wfA+vXrqf7vDgAAIABJREFUS923UxlzHA8bNoxZs2YxZ84cPD096d27t2q1VYZOp/xuXr+u7nYNQzqPoXIyS2ZhMQFap45yw9tbzYRVxpIlS0hLS+PHH39k7ty5jB07ttR1x44di52dHeHh4WVuc8qUKdjY2HDy5Mkij0+ePJmQkJDCMFmwYAFubm58//33xYKqfv36AKSlpZVZT05ODj/99FOREVe+vr7s37+/zBrvxdAWnGyYwvQO6enpCCEKayzJjBkzmD59OvPmzSM1NZXNmzcbVY+xsrKU+zHUq6fudhvRSA7prMq07gdwp44dhXjxRa2ruK2i3Zg6dOggateuXeY677//vgDEN998U+LzJ0+eFG5ubmLIkCFFHt+8ebNo3LhxsU76CxcuFIBo0KBBkdFPBw8eFIAYN25cifv5z3/+Izp16iSuX79e7LmmTZuKffv2lfl1CCHE5MmTxdChQ0t8btiwYQIQn3/+ebHnTpw4IQDx73//u9RtN2/eXDRu3PieNZjLxo1CgBCXLqm/7W6im/i3KP17IVksy+oH+sknSqfla9e0rkShdj9Qg6lTpwp7e3vxxhtviFOnTomcnBxx6dIlsWjRIlG/fn3RrVs3kZGRUbh+SkqKaNiwodixY0eJ2zMM/xwxYkThYwUFBaJu3bol9gP99ttvC4eLlrbcHaBDhw4VgIiNjS18bPLkyUKn04l3331XnD17VmRnZ4uzZ8+KKVOmCEC0a9euyMAEA0M/0LKGjFpKP1CD3r2F6N7dNNseJ8aJrqKraTYumZJlBWh6uhANGghxRw6Y3bp160oNla+//rrM14aEhJQ7cP/880/x3HPPiYYNGwp7e3vh6uoqOnfuLD777DORc0ePbW9v7yI1DBgwoPC5lJSUEuv85JNPhBDKsNGSRiL17du3wgEaHBwsXFxcRF5eXuFjaWlpYtGiRaJXr16iUaNGwsHBQbi4uIh27dqJ2bNnlxieQigjkby9vcXNmzdL/f54e3uLNm3alOt7aWpr1ypHn5GRptn+fDFfuApXUSCMG/0lmZ1lBagQQqxeLYROJ8SSJVpXUnF9+/YVOp1O6zIKpaamCm9v72Jj4SsqJSVFODk5idGjRxtdk2Es/A8//FDmevXq1ROdO3c2en/GOnNGCHd3IYYPN90+9ol9AoGIETGm24lkCpY1EgmUSeDeeEO5U/jqKjZdjI+PD0IIEhMTtS4FUPqArlu3jvDwcL788stKbUMIwcSJE3Fzcyu1X2d5xcbG8uSTTzJt2rQit+S7W25uLsnJyeUeBGAqFy7Ao48qgzu++sp0+2lNa2yw4TDlv5WgZBksLkABPvgAxoyBwYOVYZ1VZdo7w9XxDz/8kKSkJI2rUbRt25a///6bTZs2Fd4PtCISExOJjY0lMjISLy8vo2pZsGABs2bNYtasWaWuk5aWxty5c8nNzdW069KePdC5szJNzObNSh9QU6lBDZrQRF6Jr4q0PgYuy4IFQtjbC9G/vxCl3F7T4nz00UeiRYsWQq/Xi969e2tdTpUyfPhwYW9vL3x9fcVbb71VpL3VnBYsEMLBQYjHHzff791T4inxpHjSPDuT1LLF4qc13rVLmd/d2VkZi3yrf7Ykqe70aZg0SZm58/33YepU88239R7v8T3fc5rT5tmhpAbLn9b44YfhwAFliOeAAdC3r/KLLklqycyE6dOVaY4vXoQdO2DaNPNOVhhIIDHEyCGdVYzFByhA/frwww/KL/alS8ov+rhxEBurdWVSVZaRAZ98okxYOG+e0t5+4IA2ExYahnQe57j5dy5VWpUIUIPu3SEqCj77TDnNatYMhg6FSg4tl6qppCR45x3lNnVvv61crPz/9s48LKqy/ePfYQcBkUVkSxFwAQGXNDXcySU3LLVcSlN+kaWZlVbaW1avqZmpr5W4ZWbu5pJbmkuuaFrhjgooKgoiOwgDwzy/P+6GRYZ9Zs7McH+u61wHzpw5zz0H5nue5V5u3ACmTAFqUENQo3jDG/aw54UkA8OgBBSgf/CICEq+vHYtZcdp2xbo0wdYv55ilhnmSYSglfUJE4CmTSk58pQplCj5m28AFxdp7eMqnYaJwQmoCjMzKnccHQ3s3QvY2QGvvUbD/UmTgD//lNpCRh9ITATmzqXRSrduwIULwPz5QEIC8OmnQB1yW2ucIASxL6iBofer8DUhPR3YupXms6KjqacxdCit3PfsKd3wjNEtt28Du3YBe/YAf/xBaehGjqSRS/v2UltXMZGIxAzMQCYyIYMOV7CY2nLQqAS0NOfPA7/8AuzcCcTEAI0bA0OGkJj26AFUI1E7YyAoFMC5c8D+/fT3vnSJepaDBgHDhgH9+wOVVFrRG6IQha7oinjEwxveUpvDVI3xCmhpYmLoi7VjBwmrTAY8/TTQuzdtzz4LVJLbl9EzlEpaODx6FDhyBDh2jBIdP/UUjTjCwsj9zdBGHLnIhT3s8Qt+QRjCpDaHqZr6IaClefSo5It35Aitvlpakp/pM8/Q1qkTfRkZ/SAzk3qYZ8/S3Pbp0/R3dHamqZnevYFevYBWraS2tO74whev4lV8gk+kNoWpmvonoE9y7x4J6YkT9OW8cgUoKgKaNCkR1eBgICCA3F4Y7ZKeTkPwS5dINP/8kzwulErAy4v+Hl27kmAGBRluAcKKeBEvQgYZtqHyqgWMXsAC+iQ5OeRMffYsbefOUVYegBJLBARQgTHV5ucHeHrqNmrFGEhLA2Jj6YF15QoJ5pUrtGoOAA4OtOBTelRQSQUQo+EzfIb1WI8buCG1KUzVsIBWh4wM8jct/UW/dIkcsgGaAmjeHPD1BXx8SvZPPUXiam8vrf1SIJdTfat790go4+JoU/2sKiRqZQX4+9PDKCCAoszatKHeZn1kB3ZgOIYjE5mwhYFVWKx/sIDWheRkistXiUPprXQl3gYNSEjd3Er2Hh40h+fkVLI5O+u32Obl0UMjNZV6kKmpQEoKkJREPccHDyiWPCmJjquwtqYHimpTPWB8fGhaRIPFQA2eOMTBF76IQhQ6o7PU5jCVwwKqLTIzSUzu3SsRlgcPSGhUYvPoEfBk1WEzMxJTR0fKQNWoEfXSrK1pWGtpSYJsb0/CI5PR8dKozlehUJQvx5ubCxQUlNgql9P0RXY2kJ9P+9xc4PHjEtEsH+WVCXPzl+HlNQ8+PsFwdy95QHh5lTwo3N01cUfrBwICDnDAAizA63hdanOYyjloYI4ehkPDhrS1aVP5eVlZ1Jt79Khsz04lWOnpJGh5eeQgnp9PopaRQeGJpcXRVmTj7fyvML/odcQXloyBqxJZOzv63c6OnM6trSm0UfWzStBL752cABMTgWHDHuPixZ5Ys2YXunfvrrkbWE+RQYY2aMMhnQYC90CNiWvXaELx4kWaTNQBcrkc48aNw86dO7F27Vq89NJLOmnXmJmESbiMyziBE1KbwlSO/ucDZWqAqhaTq6vOmrS0tMTGjRsxefJkjBo1CgsXLtRZ28ZKEIJwERchwH0bfYeH8MZEcjJNjOo4Q4ZMJsPXX38NLy8vTJs2DXfu3MHixYshY9+uWhGMYGQhCwlIQDM0k9ocphJYQI2J5GRaypdoWXvq1KlwdHTExIkTkZ6ejtWrV8Pc3FwSWwyZQARCBhku4AILqJ7DQ3hj4uFDnQ7f1fHKK69g//792LVrFwYMGFCrSqD1HTvYwRvevJBkALCAGhPJyZILKAD06dMHhw8fxuXLl9GnTx8kq+ZmmWoTjGAWUAOABdSY0BMBBYCnn34aUVFRyMrKQpcuXXDjBocm1gTVQhKj37CAGhN6JKAA4O3tjdOnT6NJkybo2rUroqKipDbJYAhCEGIRixzkSG0KUwksoMZEcjJljtYjnJyc8Pvvv6Nz58547rnnsHfvXqlNMgiCEAQllFylU89hATUm9GARSR0NGjTArl27MHr0aAwdOhQrV66U2iS9xwc+XKXTAGA3JmMhO5viPfWsB6rC1NQUy5cvh7u7OyIiIpCYmIjZs2dLbZbeIoMMAQhgAdVzWECNBVVuPWdnae2oBJlMhtmzZ8PLywtvvPEG7t27h8jISJgZWu0NHcFVOvUf/s81FjIzaW8A1fImTpwIJycnjB49GqmpqdiwYQOsuShVOYIQhE3YBAHBVTr1FJ4DNRYMSEABICwsDEeOHMHJkyfRu3dvPCqdQJUBQL6gmcjEHdyR2hSmAlhAjYWMDNo/mbdOj+ncuTOOHTuG+/fvo0ePHrhzh4WiNEEIKg7pZPQTFlBjITOTsi0bQgH0Uvj7++PMmTOwsLBA586dER0dLbVJeoMd7NAMzXghSY9hATUWMjMNZvj+JG5ubjh69ChatGiBXr164dixY1KbpDdwSKd+wwJqLBiwgAKAg4MDDhw4gH79+qFfv37YvHmz1CbpBRzSqd+wgBoLBi6gQEly5ilTpmDUqFH4+uuvpTZJcoIQhJu4iVzkSm0KowZ2YzIWMjIMXkAB8hVdsGABPD098e677+Lu3btYtGgRTEzq57O+dEhnJ3SS2hzmCVhAjYXMTINaga+KqVOnwsnJCRMmTEBaWhp++OGHepmc2Qc+sIUtLuIiC6geUj8f68aIEQzhn2Ts2LHYv38/fv3113qbnNkEJlylU49hATUWjFBAAUrOfOLECVy7dg3dunXD/fv3pTZJ53BIp/7CAmosZGUB9vZSW6EVgoKCcPLkScjlcoSEhOD69etSm6RTuEqn/sICaizk5gINGkhthdZQJWd2c3ND165dcfr0aZ3bkJ6ejsjISPTu3RuOjo6wtraGn58fxowZgwsXtNdDDEYwMpCBu7irtTaY2sECaizI5YCFhdRWaBVHR0ccPHgQXbp0Qd++fXWenHn69OmYMmUKhg4diqtXryI1NRU//PADoqOj0aFDB+zcuVMr7XJIp/7CAmosFBQYXBhnbZA6OfOECRMwdepUNGnSBDY2NujWrRs2bNiAoqIizJgxQytt2sMeTdGUF5L0EHZjMhbqQQ9UhVTJmVetWqX2eHBwMKytrREXFwchBGQyzaee45BO/YQF1FioJz1QFarkzE899RQiIiJw9+5dLF++XJLkzLm5ucjLy0NQUJBWxBOgYfxWbNXKtZnaw0N4Y0AIoLCw3vRASzNhwgRs27YNGzduxPDhw5GXl1ej98fExCAsLAwNGzaEjY0NOnXqhD179iA0NBQymQwymQzh4eGVXmPrVhK2WbNm1fpzVIUqpPMxHmutDaYWCMbwycsTAhBi1y6pLZGMqKgo4ezsLDp37ixSUlKq9Z6bN28KBwcH4eHhIQ4ePCiys7PF5cuXRWhoqHBxcRGWlpZVXiMpKUm4urqK8PDwun6ESrkurgsIiD/Fn1pth6kRB7gHagwUFNC+HvZAVXTu3BnHjx/H/fv30b1792olZ545cyYyMjKwZMkSPPfcc7C1tUVAQAA2bNiA3Nyqk3ekpqaif//+6NmzJyIjIzXxMSrEF77FIZ2M/sACagyoBLQezYGqo3Xr1jhz5gwsLS2rlZz5t99+AwD069evzHEXFxe0atWq0vfm5uaiX79+8Pf3x/r162Fqalo346vABCZcpVMPYQE1BuRy2tfjHqgKNzc3HD9+HIGBgejevTsOHjyo9jy5XI7s7GxYWVnB1ta23OuNGjWqsA2FQoERI0bAw8MDa9eu1bp4quCQTv2DBdQY4B5oGezs7LB7924MHDgQgwcPxqZNm8qdY2lpCTs7O+Tn5yMnJ6fc6w8fPqzw+hEREZDL5diyZUuZVX9fX1+cOXNGMx9CDSoB5ZBO/YEF1BjgHmg5LCwssGHDBkydOhWjR4/GggULyp0zYMAAACVDeRVJSUm4ceOG2uvOnj0bV65cwa5du2Cp4weWKqTzHu7ptF2mEqRexmI0wIULtAofEyO1JXrJ4sWLhYmJiXj77bdFUVFR8fHY2Fjh6OhYZhX+0qVLon///qJp06blVuHXrFkjAFS6RUVFae1zZIgMIRMysVvs1lobTI3gVXijgHuglTJ16lSsXbsWkZGRGDduHAoLCwEAPj4+iIqKQseOHTF8+HC4uroiIiICH330EXx9fctdZ9u2bbo2vQwN0RBP4SleSNIjOBLJGCgqor0EUTiGwtixY+Hu7o5hw4ZhwIAB2L59O+zt7dGiRQvs2LGjWtfYs2ePlq2sGg7p1C+4B2pMCF5cqIzevXvj5MmTiImJQUhICBITE6U2qcZwlU79ggXUGFAVXGMBrZLAwECcOHECBQUF6Natm8ElZw5CEG7gBod06gksoMaAKoEFC2i1qCw586ZNmyCTyXD48GHI5fJqxcLrkiAEoQhFuIqrUpvCgAXUOGABrTGq5Mxdu3ZF3759i+c3X375ZQghymwVpbGTAj/4oQEa8DBeT2ABNQZYQGtFgwYNsHPnTowZMwZhYWFYsWKF1CZVCYd06he8bGsMqARUqZTWDgNElZy5efPmiIiIQHx8PObNmye1WZXCIZ36AwuoMaBaRGIBrTUffPABXFxcEBERgZSUFMmSM1eHIARhO7ZLbQYDFlDjwNyc9v86iDO1Y8KECXBycsKoUaOQmpqKjRs3wtraWmqzyhGMYKQhDfdwD57wlNqceg3PgRoDqphsVUQSU2uGDh2Ko0eP4tSpU+jVqxcePXoktUnl4Cqd+gMLqDHAAqpRnnnmGRw/fhxJSUno3r07EhISpDapDA5wgBe8eCFJD2ABNQZYQDVO69atERUVBUtLS3Tp0qXK5My6hkM69QMWUGNAJaCqvKCMRnBzc8OJEycQGBiIbt26VZicWQo4pFM/YAE1BrgHqjVsbW2xe/duDBo0qMLkzFIQhCBcx3XkoWZVSBnNwgJqDLCAahVVcuZ33nkHo0ePxldffSW1SeVCOh/jMc7hHFZiJZKRLLF19Qd2YzIGZDIS0RrWRGeqj0wmw/z58+Hu7o53330XiYmJWLRoEUxMdN8HuY3buI7raIImeBfvIgEJuIu7UIL8gEdipM5tqq+wgBoLtraAmto+jGaZOnUqPDw88Morr+D+/ftYt24drKys1J6bnp5eaXG6mhCJSKzDOlzEReSA/s5WsMIpnEIRiorPc4YzGqKhRtpkqoaH8MaCnR2QnS21FfWC4cOHY+/evTh48CAGDhyIrKyscucsWbIEI0dqricYgACcxuli8QSAfOSXEU8A8Ie/xtpkqoYF1FhgAdUpquTM169fL5ececuWLZg2bRoOHTqEAwcOaKS9buiGF/ACzGFe4TkWsEAgAjXSHlM9WECNBTs7HsLrmMDAQJw8eRIFBQUICQnB9evX8ccff2Ds2LEAKFHJO++8g6KioiquVD2+xteVvq6EEq3RWiNtMdWDBdRY4B6oJDRr1gwnT56Eq6srunTpgoEDB6KoqAhCCBQVFeHGjRv46aefNNKWN7zxLt6FWQVLFwoo0AqtNNIWUz1kQnASSaNgxAjKyrR5s9SW1Etu3LiBDh06ID8/HwqFovi4TCaDs7Mzbt26hQYNGtS5nWxkwxveSEMaBMp/dRORCHe417kdploc5B6oscA9UMlITU3FwIEDIZfLy4gnAAghkJ6ejsWLF2ukLTvY4Ut8CRlk5V6zgQ3c4KaRdpjqwQJqLDRsCGRkSG1FvSMvLw8DBw7E7du3i+vNP4lCocCcOXOQlJSkkTbDEY4ABMAUpmWOt0ALtcLKaA8WUGPB2RlITZXainpFUVERXn75ZZw9e7Zcz/NJFAoFPv/8c420awITLMGSMi5MpjBFMII1cn2m+rCAGgtOToAe5q40ZoQQGDNmDEJCQgBQyGdFFBYWYsWKFRoro9wLvTAQA4vdmkxhygtIEsACaiw4OwPp6UAVPSFGc5iZmWHkyJE4ceIErl+/jmnTpsHOzg4mJiaQycoPpU1MTDB9+nSNtb8ES4oXkgpQwC5MEsACaiw4O1NVzrQ0qS2pl7Ro0QLz5s1DYmIili1bhlatqDdYuldaWFiI3bt348SJExpp0wc+mIzJxfOeLdFSI9dlqg+7MRkLly4BQUHA1atAa+6J6APHjh3Dt99+ix07dsDExASFhYUwMTFB27Ztcf78ebW9VHXk5QH5+TTAyM+n3xUKcrrIMU/H2Ge9kW+aix0HHiM/u3yk0pPh+CYmtOYI0N7KCmjQALC3B0xNy72dqZiDLKDGwoMHgLs7cPw40K2b1NYwpXjw4AFWrlyJb7/9HikplGpuypTN8PMbibQ0Wvt7cp+bS2JZLceKyd8Cb30HtL5WZ1vNzSkvjZ0diaqTE+DoWHav2lxcgCZNAE9PwMamzk0bIiygRkNBAXUlfvkFGDZMamvqHY8fA/HxQFwccOsWcOcOPdPu3QPu36ctP18BYBeApZDJ7sHF5SqcnS3KCZSjI4mYlRXg4EB7a+uSn1VipepZKqDA19ZfYKb8s+KepQpVT7U0BQUk0AAJdH4+2Z+VRT/n5NB7cnNJzJ8U+EePygu7gwPg4UFi6uYGeHnR1rw54ONDPxth75YF1KhwcgL++19g0iSpLTFKFAogNpZmS2JiSCxV24MHJee5u5NgqITEzY3ExcODXnN3B+7fvwZLS0s0b95cI7YVorDSRCOapqgISEmhz52YSNv9+/TAePAAuHuXHiKqRFUWFkDTpiSmPj6Ary8QEAC0aUP3x0BhATUqgoKAIUNIRJk6kZwM/P03ieXly7RdvUpJ/01NAW9vEgEfn5JelmrTw1LykpGSUvKQUfXQ4+KAGzeAhw/pHCcnIDCQxDQwkLa2bQ3iPrKAGhUDBtCk1Jo1UltiUBQWAhcvAidPAn/9Rdu1a+TU0KgR4O8PdOhAPSZ/f6BdO5ofZOpGejpw5Qo9mK5coft+8SJNH5iZAS1a0H3v0AEICaH7LkEBgMpgATUqwsNp3KRH1SP1kdxc4MQJ4MgR4OhRIDqahueNGwOdOpVsHTvSfCSjO4SgHuqff5Zs//xDc7MNGwLPPgv07g306UMDLokFlQXUqPj0U2DbNnqcM8UolcDZs/RcOXyYfi4ooN5knz70pXzmGaBZM6ktZdRRWAhcuEB/t2PH6KH36BG5PvfsSYI6YIAkfz8WUKNixQpgxgxOKgKaqzxxAti9m54p9+/TYkVICBAaSl84Ly+prWRqS3w8cOgQbb//Tv/y/v7A4MHAoEH0UKymm21dYAE1Kvbupf+e7Gzyg6lnKBTA/v3Azz/TPicHePppICyMNn8uF2SUFBYCf/wB7NgB/PoreQR4ewMvvACMH0+LU1qCBdSoiI6mmfaYGKBl/Qnri4mhdbOffqKV3R49gOHDySHB01Nq6xhdIgRw7hywcyflFo+Pp/ns114DRo1COT/ZOsICalRkZNCy8f79QP/+UlujVZRK+pJ88w1w6hT5GI4fD4wbR70PhhGC5kx/+IHiS4QAXnoJmD5dY6MRzkhvVDg4kFNdXJzUlmiNggL6QgQEUBWTxo1pcSg+Hpg9m8WTKUEmo0Wmn34i5/7Fi2lVPzCQpnTOnKl7Gyygxoavr1EKqBDAjz+So/qkSUCXLuRssH078NxzkruzMHqOvT3w+usUGLF9OwVKdOlCXhgXLtT+uvxvZ2z4+FC8oRHx11+0qhoeTvOacXHUC23F+YOZGmJiAgwdCkRFkTtUXh456k+eTI79Nb6e5k1kJMXX12gEND8fmDKFFgHMzEhIv/uOF4YYzdCzJ82fr1pFrm4tWgBbttTsGiygxoaPD00IFhVVfW4NEELg1KlTeOutt9CiRQtYWlqicePGCAkJwc8//wxNr0Xevk1Z+X7+GVi7lhYDgrVU8ic9PR2RkZHo3bs3HB0dYW1tDT8/P4wZMwYXqjG+KyoqwkcffQQ/Pz9YWVlhwIABFZ577tw5jB8/Ht7e3rC2toajoyPatGmDF198EcuWLUPcv9Mvbdq0gUwmK7O9/PLLxdcJDQ0t89rTTz9drq2EhAQMGTIEWaqMHqXYt28fWrRoATMz9TXmK6Om9+vDDz/E5krKbb/22muwtLSEt7c3pk6divz8/BrbVFtkMlp8vH6d5tRffhmYNo1co6qFYIyLU6eEAIS4fVujl7127ZoAIEJDQ8WFCxdEXl6eiIuLE6NGjRIAxHvvvaextg4eFMLJSYjgYCFu3tTYZStk4sSJwszMTCxevFg8ePBA5ObmiuPHjwt/f39hamoqduzYUen7ly9fLgCIzz//XKSnp6s9p6ioSLz//vvCzMxMTJ8+XVy7dk3k5+eLpKQkcfDgQREaGioACACisLBQCCFEUlKScHJyEgDEzz//XO6ae/fuFX5+fiI3N7fca//8849wdnYWS5cuLXM8NjZWDB48WAQFBQl7e3thampa3dtUTE3vV2xsrPD29hYff/xxhdfMysoSkZGRAoCYM2dOjW3SFBs3CmFrK0RIiBDJyVWefoAF1NhITiYBPXRIo5e9du2aMDMzE2lpaWWOy+Vy4eTkJCwtLUV+fn6d29m7VwhLSyFGjxZCjS5ohYkTJ4rXX3+93PHo6GgBQPj5+VX6ftVDJCsrq8JzZs6cKQCIFStWqH1doVCIAQMGlBFQIYRYv369ACCcnJxEUlJS8fG0tDTh5eUlTp06Ve5amZmZwtPTU0RERKi1de7cuaKwsFB4eHjUWkBrer+io6OFTCYTmzdvrvTaNjY2om/fvjW2SZNcviyEj48QbdoI8fBhpaeygBolTk5CLFmis+batm0rAIiMjIw6XSc6WogGDYSYMEGIoiINGVdHrK2thYmJiVAqlRWe07dv30qF6Nq1a8LExER06NCh0rZOnz5dTkCFEGLIkCECgHjxxReLj40ZM0bMmDFD7XVmzZolzMzMRGJiYrnXHj9+XPxzbQW0Miq7XyNGjBCenp7lPl9p3N3dq7xPuuDuXRLRrl2FkMsrPO0Az4EaI23aUAJLHZCRkYGbN2+iXbt2aFiHMA+5nOafOnYEli/XD7ek3Nxc5OXlFc9HVkRRFfPNK1asgFKXTJrNAAAgAElEQVSpxIgRIyo9r0uXLhBClJuXjIyMRKNGjfDLL79g27Zt2LlzJ6Kjo9XWmRdCYNWqVXjmmWfg7u5e7nVrLSbZrOp+DRs2DPfu3cPevXsrvIZMJoNCDyrLenpSHoVLlyhHT0Xowb8po3ECA+kvXwUxMTEICwtDw4YNYWNjg06dOmHPnj1lFijCw8PVvjcrKwunTp3CkCFD0KRJE/z00091MnnxYspmvnYtrbjrA1u3bgUAzJo1q07XOX78OAAgKCioVu93c3PDokWLAABvvfUWJk+ejLVr18LS0rLcuRcuXEBycjKCtbXiVglV3a+2bdsCAA4cOKAzm+pC69bA/PnAwoWVuFbrrE/M6I7ISJoJr2TYefPmTeHg4CA8PDzEwYMHRXZ2trh8+bIIDQ0VLi4uwtLSssL3fvHFF8ULHj179hQXL16sk7kKhRDu7kJUMCKVhKSkJOHq6irCw8OrPLdbt27Cxsamwtfd3NwEAHH27Nk62fT8888LAKJHjx4VnrNu3ToBQHz55ZdVXk+TQ/jq3K/MzEwBQHTr1q3Cc5o3by78/f01YpMmUCiEaN5ciLffVvsyD+GNksBASkWUkFDhKTNnzkRGRgaWLFmC5557Dra2tggICMCGDRuQq6o4VgEff/wx5HI5rl27hlatWqFdu3b44osvam3uX39Rurlx42p9CY2SmpqK/v37o2fPnoiMjKzy/Dt37sCzGs6p1S1jXBF+fn4AqFzyrl271J7z4N/iTHWZTqkp1b1f9vb2kMlkxTaqw93dHYmJiXoxjAeofMvYsTScVwcLqDESGEgObpUM43/77TcAQL9+/cocd3FxQatqhPhYWFigVatWWLZsGYYMGYJPPvkEhw4dqpW5V65Q9j19SDeXm5uLfv36wd/fH+vXr4dpJaUk09LSsGDBAiQkJODNN9+s8DzVXOSjR49qbdeJEyewfft2fPPNNwCAN954A+lqQmdUPpTm5ropMFeT+wUAZmZmyMvLq/D1iIgIZGVl4ZNPPqnT/dIknTpRpVV1/QoWUGPEzo6yBVcgoHK5HNnZ2bCysoKtmryhjVT1cqvJ4MGDAQB79uypua2gzrI+pC9VKBQYMWIEPDw8sHbt2krFYPz48XBycsKHH36IGTNm4O23367w3B49egAALl68WCu7cnJyMH78eKxYsQLTpk3DgAEDkJSUhKlTp5Y718rKCgBQWG1P8NpTk/tV+j2VLWSNHTsWc+bMwYIFC+Di4oL+epBVzN6e9k+WhwZYQI2XoCCq0KUGS0tL2NnZIT8/Hzk5OeVef6gql1hNVIsZaWlpNbcTlFEpNZVW4qUkIiICcrkcW7ZsKbMS7uvrizNPpO758ccfkZmZiU2bNuGbb75BREREpdc1MzPDtm3bKm1/xowZMDExQUxMTJnj7733HkJDQ4vFZPny5bC3t8e6devKPbTc/q0RnJmZWfUHriM1uV8ALTwKIYptVMesWbMwc+ZMLFu2DBkZGcUjJSm5d48WNp2c1Lyo2ylZRmfMni1Es2YVvjxy5EgBQGzdurXM8QcPHghLS8tyi0jvvfeeGDNmjNprjR07VgAQ//vf/2plakIC+f4fOFCrt2uETz/9VDzzzDMiOzu73Gs+Pj4iKiqqwvd27NhRNGrUqNLrqxbeVq9erfb1mJgYYW9vL1566aUyx3/77Tfh7e1dzkl/xYoVAoBwd3cvE/30zz//CADizTffrNQeIeq2iFSb+3X16lUBQEyaNKnC67Zq1Up4e3vXyiZtMWGCEF26qH2JHemNlt9+I1UqFb1SmtjYWOHo6FhmFf7SpUuif//+omnTpmoFVCaTic8++0zcunVL5Ofni1u3bokZM2YIAKJDhw5lnLRrSkiIEIMG1frtdWLNmjXFXgUVbZUJaJ8+faolRB9++KEwNzcXH3zwgbh+/bqQy+Xi3r17YtWqVcLNzU2EhISInJyc4vPT09OFl5eXOHr0qNrrqcI/x48fX3xMqVSKxo0bi2effbZKe6ojoGPGjBEARHx8fPGx2t6vDRs2CACVhsZ6eHiI4ODgKm3XFcnJQtjYCPFERKwKFlCjJT1dCBMTIXbtqvCU69evi7CwMGFvby9sbGxE165dxbFjx0SfPn3KCWhmZqZYtWqV6Nevn2jWrJmwsLAQtra2okOHDmLu3Ll1Ek8hSvR+z546XaZWDBw4sE4CGhoaWu2e3J9//ileeeUV4eXlJczNzYWdnZ3o3LmzWLJkiZCXCnnx8PAo0/7QoUOLX0tPT1dr46JFi4QQFDZaUSTS7t27K/yMK1euLHd+7969ha2trVAoFHW+XyNGjBAeHh6ioKCgwvvj4eEh2rZtW617qQteeUUIT08hSj3XSsMCatS0bCnEzJk1fps6AdUFY8cK4ewsxK1bOm+6TgwcOFDIZDKpzSgmIyNDeHh4qI2Frwnp6enC2tq6Wr6wVaGKhd+4cWOl57m6uorOnTvXuT1NsHKlEDKZEL/+WuEp7Adq1HTuTMW0DYTISAqhe+45mrg3FDw9PSGEQHJystSmACAf0N27d2Pbtm347rvvanUNIQTefvtt2Nvb18nHFwDi4+Pxwgsv4KOPPiqTku9JCgsLkZaWVi2fWm2zdStVPvj4YyqVXBEsoMbMM89QERgN5wbVFg0aAAcOAFZWpP1RUVJbVD1Uq+Pz5s1DamqqxNYQ7dq1w/nz57F//361+UCrIjk5GfHx8Th8+DCaNGlSJ1uWL1+OOXPmYM6cORWek5mZiW+++QaFhYWSui4JAcybRxU833oL+OyzKt/AGC1//UUTi5cvV+v0jRs3lpvLmjhxopaNLE9mphAvvCCEmZkQ8+bpvPlaMX/+fNG6dWthaWkp+vfvL7U5BsW4ceOEubm58PX1Ff/5z3/KzLfqkqwsIYYPr9H/3QEua2zMKBRU5vjrr4FK/BT1ESGAOXOo0uaAAZRsxMdHaqsYY2XXLspEn59PZT1CQqr1Ni5rbNSYmdF/wpEjUltSY2Qymn86fJjC6Nq0od8fP5baMsaYuH4d6N8fGDaMqnT+/Xe1xRMAz4EaP336kAoplVJbUit69ACio4G5c4FvvwVatgSWLFEfl8ww1SUuDnjjDQrYS06mmlvr1wM1ne5lATV2+vShOMlq5AfVV8zMgHfeod7CCy8As2YBzZoBn38O1DJ6lKmnREfTAlHLlsChQ1Tl9fx5KmBYG1hAjZ3gYMDFhXqhBo6rK/U+b98G3nyTfm7aFJg4kcrTMow6Hj8G1q0DevcG2rcHYmKo2uv160B4OKWsqy28iFQfGDmSxryVlFIwRHJygDVrgB9+oJ5Fy5ZUovbVVwE11SyYesaZM/T/sXkzkJcHDBxIa6l9+9IcuwY4yAJaH1i+HHjvPRrvWlhIbY1WuHKFehk//EAzFu3aAYMGUZ2laqQ3ZYwApRI4fRrYswfYuZN6mK1bU6Lu116jrF8ahgW0XhAbC/j5AceP136yx0CQy4F9++gLtGcPPTOCgoCwMHKHevpp/am5xNSdzEzgjz8oY/yvvwIpKSSaYWHA8OE0ZNciLKD1Bj8/8tX46iupLdEZCgWtru7cSX5+d+9Sctzu3WltrXfvkuT9jGHw+DHNdx85Qttff5HPcMeO9O8dFkZTOTqCBbTeMGMGsGMHcPOm1JZIRkwMraUdOULCmppK62tdu1LU6zPPUA9VlYGckZ6EBErn8OeftD93jkYZrVoBvXrRQ7BnT8DZWRLzWEDrDadPA88+S/XiAwKktkZylEpaeDp6lG7Nn39SAhMTE/pydupEvZrAQHLir2GVE6aGCEHeFVeuABculIhmcjJNuQQE0AMuJIRGD3qySMgCWm9QKinV0ZtvUkgPU47790t6OmfPUlSKqjKGpyd9iQMDaR8QAPj6srDWFKWSHlQ3b9Kz/MoVclG+cqWk5lDTpvTwUo0K2renRDN6CAtoveKNN8hr+Px5qS0xGBIS6Mt9+XLJdu0axUwDwNMNb8La1wMefjbw9aV4fR8fqunn5gb8Wy6qXpGZCSQm0r2Li6MtNpb28fElta+cnGiBT/VgatOGftZhRea6wgJarzhwgAJ/4+MBb2+prTFYioooPj973U4EfDUOR9q/j0iX/xQLhUpcAZpjdXMjQW3ShHqyrq503MmJNkdH2ldSrFJyMjOBR49o3jgtjfaPHpFQPnhAC3RJSbQvna/A2RllHiyqzc9PK25FuoYFtF5RWEjf3tmzgUrK8DJVIAR5M8ycCYwZQ362pdTv/n0apqqE5cGDkt8TE0lo1IWg2tiUiKmNDQ1b7e2pF2tnR6WfraxKFrksLMoPbe3syrpp5eWVFXQAUJWTLyoCsrIoxiI/n0RSdX56OgmhSjAVirLXMDcncXR3p83Ts/yDwsvLoHqTtYEFtN4xdiyNrU6ckNoSwyQ7m7zzDx8Gli4F/u//anUZpbJsb061V/38+DEJW1YWCVpODjXd8eFeHEFv5Mus8fhx+VLQGRmk7yoqE1kTExI4GxsSZgcHeg5YWdHcbmlBd3QkwVT1mu3savWxjQ0W0HrHvn0UonPzJifYrCmJiRQPmJREzqWdO+u2/StXaLLwt98oHpGRGs4HWu/o25eG8evXS22JYXHpEjmMFhZSkLWuxRMA/vc/mjx87jndt82ohQW0vmFmRkPQdevKjvWYijl6lHxofX0pDKZZM93bkJ5OD72pUzl0So9gAa2PvPIKLRdzDriq2bMHeP55Grrv308ThVKwciXlXRs7Vpr2GbWwgNZH2rcHOnQAVqyQ2hL9ZtMmyuA8ciT12KXKZFVURDWfw8M5zlTPYAGtr0REUPWslBSpLdFP1q2j3t6UKcCPP0qbwmnXLvKcePNN6Wxg1MICWl8ZM4Z8Vn76SWpL9I9ffgEmTACmTwcWLpR+znHpUvKcYK8JvYMFtL5iY0M9rMhIgy04pxV+/50eLhERVMlOai5fptRRU6ZIbQmjBhbQ+szkyRTWuWOH1JboBydOAEOHkoAuXSq1NcSSJZQhuE8fqS1h1MCO9PWdF1+keMM//5TaEmm5eZMKg/foQXPDdak0pilSUykecuFCYNIkqa1hysOO9PWeDz+kLLVHj0ptiXSkpdEcY7NmNCesD+IJUIy9lRVVyWP0Eu6BMpTa29KSQgTrG3I5RWclJFCEUZMmUltEFBYCzZvTPLU+zMUy6uAeKAPggw8o1d3ff0ttie6ZPh345x9ymNcX8QSAjRspHTu7Luk13ANliA4dqBrXhg1SW6I7du+mRaN162jhSJ9o3x7w9wd+/llqS5iK4R4o8y/vv0+LJ7GxUluiG+7cAcaPJ3clfRPPo0epV8w5W/Ue7oEyhEIBtGhBxdO/+05qa7SLQkHJQeRymve0spLaorIMGULZjY8dk9oSpnK4B8r8i5kZlT5evZoWVIyZRYuo9OPGjfonnjdvAnv3AtOmSW0JUw24B8qUUFhIVb26dAHWrpXaGu1w6xYlJf7oI2DWLKmtKc9bb1HWp5s39cediqkIzkjPPMHmzcDo0VS5s107qa3RLEKQy9LDh/T5zM2ltqgs6enAU08BX37JoZuGAQ/hmScYORLo1Mk4a8dv2EALNKtX6594AuQ4b2ICjBsntSVMNeEeKFOeY8eAnj2pcFrv3lJboxkKCiimvFcvYNUqqa0pj8px/uWXgQULpLaGqR7cA2XU0KMHDXU//NB4yn589x3VG/70U6ktUc+mTeQ4z65LBgULKKOer74C/voL2L5dakvqTnY2MG8e8M47lJxD31DVmR81Sj/tYyqEBZRRT3AwDSdnzqThpSHz/fc0hJ8xQ2pL1LNvH5UsfvddqS1haggLKFMxX3xBPqHffy+1JbVHoaDhe3g40KhRrS+zb98+tGjRAmbaKO3x1VdUuC44uEZvS09PR2RkJHr37g1HR0dYW1vDz88PY8aMwYULFzRvJ1MewTCVMXOmEPb2QiQmSm1J7di0SQhTUyHi42v19tjYWDF48GARFBQk7O3thampqWbtO3tWCECIY8dq/NaJEycKMzMzsXjxYvHgwQORm5srjh8/Lvz9/YWpqanYsWOHZm1lnuQAr8IzlZOXR871zz5LSTcMjW7dABeXWs/ljh49GkFBQXj//ffRrFkzJCUlQaFQaM6+F14A7t2rVULr8PBwmJqaYvny5WWOX7hwAW3btoWfnx9u3LihKUuZ8rAjPVMNdu4Ehg0DjhwhNyBDISEB8Pam0MgBA2p1iby8PFhbWwMAPD09NSugN26Qa9XWrSSkGsTGxgZyuRwKhQIyqYviGS/sxsRUg7Awytg+ebJhLSht3Qo0bFinekIq8dQKCxYAvr50fzVIbm4u8vLy0KZNGxZPLcMCylSPxYupAN2SJVJbUn22baOes4VF8aGYmBiEhYWhYcOGsLGxQadOnbBnzx6EhoZCJpNBJpMhPDxc+7YlJ1Ouz/ffp+gjDdq3detWAMAsfYz1NzaknYNlDIpPPxXCzk6Ie/ektqRq7t8XQiYTYvfu4kM3b94UDg4OwsPDQxw8eFBkZ2eLy5cvi9DQUOHi4iIsLS0rvaSHh4fmFpE++EAIV1ch8vI0Zp8QQiQlJQlXV1cRHh6uGTuZyjjAAspUn7w8IXx8hBg5UmpLqmbjRiHMzITIyio+NGLECAFAbNu2rcypDx8+FDY2NroT0KwsIRwchJg7t8zhutr36NEj0bZtW/HSSy8JhUJRdzuZqjjAQ3im+lhZUb30LVuoHIY+c/w48PTTgJ1d8aHf/i2a169fvzKnuri4oFWrVrqz7fvvAaUSeOONMofrYl9ubi769esHf39/rF+/HqacCk8nsIAyNWPAAOCVV6gURlqa1NZUzLFjFNP/L3K5HNnZ2bCysoKtrW250xvVwcm+Rjx+DHzzDeX9dHDQiH0KhQIjRoyAh4cH1q5dy+KpQ1hAmZqzdCkl+9XX0MPMTODaNfJd/RdLS0vY2dkhPz8fOTk55d7y8OFD3di2fDmQk0Nx+aWoi30RERGQy+XYsmVLmUgpX19fnDlzRnO2M+VgAWVqTsOGwLJllLV+506prSnP1auUoCMwsMzhAf/6gqqGyiqSkpJ043AulwMLF9LQvXHjci/Xxr7Zs2fjypUr2LVrFywtLTVvM1M5Us/CMgbM2LFCuLkJkZYmtSVlWblSCFtbIZTKModjY2OFo6NjmVXuS5cuif79+4umTZtqfxHpu++EsLKqMCy2pvatWbNGAKh0i4qKqr29TFXwIhJTB5YuJR/G996T2pKyXL1KET5POJH7+PggKioKHTt2xPDhw+Hq6oqIiAh89NFH8PX1VXupPXv2FPtfJiYmoqioqPj3VTVJzFxYSI7z4eGAu7vaU2pq37Zt26rfPqMVOJSTqRu7dwNDh9YpXFLjDB5MCzQ1iN0PDQ3FyZMnkZ+frx2bVq8GJk2iYnFNm9b47Vq3j6kNHMrJ1JHBgylv6OuvU1E0fSAxEfD0lNqKEoqKgPnzgfHjayWejP7CAsrUnaVLya8xIkJqS4j79yscJkvChg0UBjt9utSWMBqGBZSpO05OJBLbtwM//CCtLYWFQEpKtQV006ZNkMlkOHz4MORyueZj4ZVKSpg8Zgzg51fjt2vdPqZO8Bwoozk++ICyv58/D+gysqc0yclAkybkSN+9uzQ2lGbLFmD0aCrZ0bKl1NYwmoXzgTIaRKEAQkKoFxgVVSYLks6Ijwd8fEjEO3TQffulKSqiMh2BgcDGjdLawmgDXkRiNIiZGbB+Pa00f/yxNDbk5tK+QQNp2i/NunVATIz+llJm6gwLKKNZfHwoZ+jXX1O1SV2jLwJaUEBF+SZOlG46g9E6LKCM5nntNWDkSHIaT0nRbduqjPnaqJ5ZE5YtI28AqXrijE5gAWW0Q2QkYGlJq89FRbprVxV9JOXUfk4OMHcu8PbbgJeXdHYwWocFlNEODg6UaOTkSeCzz3TXrqo8hlKpuzafZOFCID8fmDFDOhsYncACymiP4GBg0SLgv/8Fdu3STZtSC+ijR5Tvc/p08o9ljBoWUEa7REQA48bRvGh8vPbbs7KivVQx43Pnkg1vvy1N+4xOYQFltM+yZUCzZlT7PC9Pu23Z29M+K0u77agjMZE+6yeflCklwhgvLKCM9rGyooic27eBadO029aTAlpURO0eOkTlNLTJp58Crq7kfcDUCyT29WDqDb6+FCc/fDjQtSvw6quau7ZCASQkAHFxwPXr1PubORN4+BC4e5det7ICsrM1096RIxQmWtpV6sYNytC/Zg15HzD1Ag7lZHTLjBmUven4caBjx7pfb/RoYOtWEkkAMDcnV6aCgrLntW8P/PVX3dsDAA8PctRfsqQkB+rw4STeFy6ULGQxxg6HcjI6Zt48oE8fSsKcmFj36736aol4AuRI/6R4mpsDnTvXvS2AKpHevw/ExgLPP0+fZfNmykT15ZcsnvUM/mszusXEhFLfNWpEIqpuUSkjA7hzp3rX69+fpgQqizxSKqlGvCa4eJH2qoHb8ePAqFFUQqRTJ820wRgMLKCM7rG3px5bXFz5JMx37lBvceHC6l9v3ryyvdAnKSrSXGamixepR6tCoSAxvXmTPA1mz5bOhYrROSygjDS0bElD3w0bSsTyn3+op3jjBi3GVNflqVs3oFevssJWGgsL6iFqgsuX1R8vLCTh/O9/acFsyxZpw0kZncACykhH377keD5jBjBnDuUSTU8n4cnNJRGqLvPnV9wLDQioWFxryvnzJQlL1FFURHOkcXHlqoIyxgevwjPS8+yzwJkz9LMqBNPEhFbOz52r/nWef578PUsLnLk58H//R5ny64pSSavvFQ3RTUxo+/FHSqLCGDu8Cs9IiBDkfH76NIlT6fh1pZJ6e//8U/3rqeuFKpWam/+Mja1YPM3MABsb4PffWTzrESygjDQoFNQz/O9/Kz7HwgJYubL61wwMpHDR0sN1TS8gqRuWm5tT4pCTJ4GePTXTFmMQsIAyuicnB+jXD1i9uvKsSQUFFN2jyjJfHb78smz+UQsLwN+/9raW5tKl8nWezMxKajAFB2umHcZgYAFldE+DBsAbbwCenoCpaeXnyuU1K8jWogX5Zap6of7+mltAio4uO79qZkYLX2fP0mdh6h0soIzukcmAESNopXrhQhLUikROqQS+/bZm1//sM3qfTKa5CCQA+Pvvsotco0cDBw+WJDBh6h28Cs9IT2oqid7335MwqXMTqmmZ4tdfp/nTFSuAgQOpXnxGBg3vs7NpDtbGhhJ/WFtTBn03N8DRUf31cnJIKFVfl88/B/7zn5p/VsaY4LrwjB4REwO8+y6wfz8N7VVzmebmwPjxJIYVkZdHLk8XL5Kz+99/k+jKZDXLTm9lRcPxli2BNm3Ih7R9e0qPpwoZXb1as9mkGEOFBZTRQw4dAqZMoYgklfhZWwNJSSXDZaWS5h737QP++IPEUy6nHqRK+K5fp7LCTz1FeTodHamHa2dHQvj4Mb0nP78kSciDB5QC7+pV4MoV4No1WsyysyORfuMNKtfx1FOS3R5Gb2ABZfQUhYJ6nLNmUe9PqaRs74GBwPr1VGPp/n1aAe/ZE+jRg7bSwiaX1z03p0JBi0effEKCGx1N9nToALz4IvVE3d3r1gZjqLCAMnpORgaJ13ffkQtRfj4QFETiNWwYCaouUCio11pQQAmVd+yghCgZGcDgwcCkScBzz+nGFkZfYAFl9JicHJpvnDePYuSbNAHefx+YPFlqy4iCAuoJr1gBHD5MYv7xx5RcmePg6wMcysnoIarherNm1PsMD6fh+u3bVN1TX7CwIHes33+nBatmzYCXXiLXqZrE8DMGCwsoo1/8/TcJ0NSpJJa3bgFffFHiXtSggbT2VUT79tQb/esvco/q3JmG9RkZUlvGaBEWUEY/EAL46isSHmtrSiKyYEHFfpn6Srt2NEe6di2wcyfQti0lS2GMEhZQRnrS06k0x8cfU17QP/4gNyRDRSYDxo6l2Pk2bcg7YMECqa1itACXNWak5e5dqmyZlQWcOqWZSp36grMzsHs3sGgRJY2+dYsqklYV/88YDCygjHTExlIpjkaNgKgoKhdsbMhkFF3VvDnFzqekUHKUyorgMQYDD+EZaXjwgFLaubtTZUtjFM/ShIUBBw5Q5FREBNdLMhJYQBnd8/gxDdstLIC9eymRR32gWzdg61Zg3TpKnsIYPCygjO557z0qX/zbbzRPWJ94/nmaB/3iC1osYwwajkRidMvu3cDQodQTe/FFqa2RjhEjqJDepUv1pwdufHAkEqNDCgqAadNoMcUAxHPz5s1o27YtrK2tIZPJIJPJcLmiuvA1ZcUKSnby5ZeauR4jCSygjO74/nsKyZw7VyuXz8nJgZ+fHwYNGlTna506dQqjRo1C3759kZKSgtjYWHhqsmxHo0aUkHnpUiAhQXPXZXQKCyijG5RK8oecNAnw8tJKE0IIKJVKKGuSQLkCtm7dCiEEpk6dCltbW/j4+ODu3bto06aNBiz9l4gIoHFjzdSsZySBBZTRDYcO0cLR//2f1pqws7NDXFwc9u3bV+dr3b17FwDg5ORU52tViIUFxfv/9JP6MiaM3sMCyuiGTZuALl2AVq2ktqRaFJUujaxNXnsNePgQOHpUN+0xGoUFlNENJ05oNeHwzp07ixd6ZDIZ8vPz1R6/ffs2XnrpJTg4OMDJyQmDBg1CXFxcuevs2rULAIoXkDprsrpnaZo2BXx9gZMntXN9RrsIhtE2KSlCyGRC7N+v9aaGDh0qAIi8vDy1x4cOHSpOnz4tcnJyxO+//y6sra1Fx44dq30drTBunBChodpvh9E0B7gHymifhAQKXWzZUmpLEB4eji5duqBBgwYIDQ3FwIEDce7cOTx69Eg6o1q0oGTRjMHBAspoH5U4aXNBppp0fCLbk9e/HgH379+XwhzCyQlITZWufabWsIAy2icvj/bW1tLaAaBhw4ZlfiCxxcoAAAQASURBVLewsAAAjbg+1RpbWyA3V7r2mVrDAspon0aNaJ+eLq0d+kpqquFl3mcAsIAyukA1dE9JkdYOfSUlRS+mN5iawwLKaB8/P8DKiuocMeX5+2/d1bdnNAoLKKN9LC2p2JoWi6up898cO3Yszpw5U+74xx9/DACQyWSYP38+AKBdu3YYNGhQhX6gZ86c0Y7hQlBWpi5dtHN9RqtwOjtGN/znP8CPP5K7DtcEKuHYMaBnz5ICdIwhwensGB3x2mtAYiLw++9SW6JfrF5NhfRYPA0SFlBGNzRvDnTvThmZGOLePWDbNiA8XGpLmFrCAsrojs8/Bw4epI2haQ1XV2DcOKktYWoJz4EyumXIECA+Hjh/nlbm6ytnzgAhIZTKbvRoqa1hasdBFlBGt9y9CwQHA2PHAv/7n9TWSENODtC+PU1r7N9PteMZQ4QXkRgd4+VFpT2+/RbYvFlqa3SPUklD9uxsYO1aFk8Dx0xqA5h6yMsvA2fPkpA4OwN9+khtke6YPBnYt4/mgV1dpbaGqSPcA2WkYeFCYPhwYNiw+pGNXQjg/fepGufGjUC3blJbxGgAFlBGGkxMgDVrgIEDgQEDqOSHsVJQQHO+S5fSolFYmNQWMRqCBZSRDnNzYP164K23aCX6ww+Nr7haQgLQqxewZw+wdy+vuBsZLKCMtJiY0HB+1SpaWOreHShVo8ig2baNcgBkZlIegNBQqS1iNAwLKKMfTJgAnDtHyZcDA4EvvgDkcqmtqh23bgGDBwMjRtB27hwQECC1VYwWYAFl9IfWrUlsPvsM+Oorig//+WdAVyWG60pKCk1DBARQsMDRo8Dy5XqRiZ/RDiygjH5hbg5Mnw5cuwY8+ywlIQkIoExO/5Yq1jvu3gVmzCDH+DVrgC+/BKKjKcsSY9RwJBKj38TGAnPmABs2UO2gV1+l5BtSD4kLC4EDB8gtad8+wMWF3JQmTQJsbKS1jdEVHMrJGAjJycAPPwArV9IcY6tWwIsvkktQu3a6yTGanU3D8u3bgd27qcZT795ARAQwdCjwb4E6pt7AAsoYGEolcOoUidiOHeQm1LAhJeYICaEY8zZtAHf3urWjUAA3bwKXL1PijxMnqCSJUknZ4194gbZmzTTysRiDhAWUMXAuX6as7sePAydPAqr67o6OQIsWQJMmFH/fuDEJraUlDbEtLalHqVDQPiuL5jKTk4E7d4AbN8gB3syMFrd69CAXq+7dOQSTUcECyhgZqalUHuPKFZo/TUqiTPjJySSScjnVYC8ooDlVc3PAzg6wtwc8PEhwPT1piiAgAPD3J7FlmPKwgDIMw9QSTmfHMAxTW1hAGYZhagkLKMMwTC0xA7BVaiMYhmEMkIv/DzyI1D2fNFUzAAAAAElFTkSuQmCC", + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# other dag\n", + "other_dag = circuit_to_dag(simple2,measure_flag=False) # dag graph\n", + "\n", + "# draw the other dag\n", + "draw_dag(other_dag, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[-1, 0{H(2)}, 1{CX(2,3)}, 2{CX(1,2)}, inf]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "other_dag_copy = copy.deepcopy(other_dag)\n", + "nodes_2 = copy.deepcopy(list(other_dag_copy.nodes()))\n", + "# nogate_nodes = [nodes[0],nodes[-2],nodes[-1]] # -1,inf,measure node\n", + "# dep_graph_copy.remove_nodes_from(nogate_nodes) # remove -1,inf,measure node\n", + "# dep_graph_copy.remove_nodes_from([nodes[6]]) # remove -1,inf,measure node\n", + "nodes_2" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### -1 node 的边 " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# draw the other dag\n", + "draw_dag(other_dag_copy, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 拼接" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dep_graph_copy.merge_dag(other_dag_copy)\n", + "draw_dag(dep_graph_copy, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0, 1, 2, 3}" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dep_graph_copy.qubits_used" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(set(), 15)" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dep_graph_copy.update_cbits_used()\n", + "dep_graph_copy.update_num_instruction_nodes()\n", + "\n", + "dep_graph_copy.cbits_used,dep_graph_copy.num_instruction_nodes" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## add nodes with giving predecessors and successors lists according to the qubits pos\n", + "这个 predecesors 和 successors 是按照qubits的位置来的，所以要先求出qubits的位置 \n", + "predecessors 和 successors 可以按照dag的nodes的label来求，并且按照the added node的pos也就是qubits来排序后以一个list的形式作为参数传入" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "({0: 4{CP(1,0)}(1.571), 1: 4{CP(1,0)}(1.571), 2: 3{CX(2,1)}},\n", + " {0: 6{RXX(0,1)}(1.571), 1: 6{RXX(0,1)}(1.571), 2: 8{CSWAP(0,1,2)}})" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# predessors of the added node ,make a list\n", + "# for example ,the added node is the barrier node \n", + "\n", + "# 1. get the added node\n", + "# use node_dict to get the added node\n", + "the_added_node = node_dict[5]\n", + "the_added_node\n", + "\n", + "# 2. get the predessors of the added node\n", + "addnode_predessors = copy.deepcopy(list(dep_graph.predecessors(the_added_node)))\n", + "\n", + "# 3. get the successors of the added node\n", + "addnode_successors = copy.deepcopy(list(dep_graph.successors(the_added_node)))\n", + "\n", + "\n", + "addnode_predessors, addnode_successors\n", + "#([4{CP(1,0)}(1.571), 3{CX(2,1)}], [6{RXX(0,1)}(1.571), 8{CSWAP(0,1,2)}])\n", + "\n", + "# 4. remove the edges between the predessors,successors about the qubits used by the added node \n", + "# 4.1 get the qubits used by the added node\n", + "qubits_used_by_added_node = [qubit for qubit in the_added_node.pos]\n", + "\n", + "\n", + "# 4.2 make a predessors dict about the qubits \n", + "addnode_predessors_dict = {}\n", + "addnode_predessors_dict[0] = addnode_predessors[0]\n", + "addnode_predessors_dict[1] = addnode_predessors[0]\n", + "addnode_predessors_dict[2] = addnode_predessors[1]\n", + "\n", + "\n", + "# 4.3 make a successors dict about the qubits\n", + "addnode_successors_dict = {}\n", + "addnode_successors_dict[0] = addnode_successors[0]\n", + "addnode_successors_dict[1] = addnode_successors[0]\n", + "addnode_successors_dict[2] = addnode_successors[1]\n", + "\n", + "addnode_predessors_dict, addnode_successors_dict\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "dep_graph_copy.add_instruction_node(the_added_node,addnode_predessors_dict,addnode_successors_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# draw the dep_graph_copy, which is the first dag\n", + "draw_dag(dep_graph_copy, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## relabeling nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "draw_dag(dep_graph_copy, output_format=\"png\") " + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "# relabel the nodes\n", + "\n", + "dep_graph_copy_copy2 = nx.MultiDiGraph()\n", + "dep_graph_copy_copy2.add_nodes_from([(-1, {\"color\": \"green\"})])\n", + "\n", + "i = 0\n", + "for node in nx.topological_sort(dep_graph_copy):\n", + " if node not in [-1, float('inf')]:\n", + " node_copy = copy.deepcopy(node)\n", + " node_copy.label = i\n", + " dep_graph_copy_copy2.add_node(node_copy)\n", + " i += 1\n", + "\n", + "dep_graph_copy_copy2.add_nodes_from([(float('inf'), {\"color\": \"red\"})])\n", + "\n", + "for edge in dep_graph_copy.edges(data=True):\n", + " dep_graph_copy_copy2.add_edges_from([(edge[0], edge[1], edge[2])])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# draw the dep_graph_copy, which is the first dag\n", + "draw_dag(dep_graph_copy_copy2, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png\n" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'qubit_used_2' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/home/parallels/Documents/pyquafu/src/quafu/dagcircuits/labquafu_dag.ipynb Cell 57\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39m# relabel by reconstructed_circuit , circuit to dag again\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m qubit_num \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39m(qubit_used \u001b[39m|\u001b[39m qubit_used_2) \u001b[39m# 并集求总的qubit数\u001b[39;00m\n\u001b[1;32m 3\u001b[0m re_circuit \u001b[39m=\u001b[39m dag_to_circuit(dep_graph_copy, qubit_num)\n\u001b[1;32m 5\u001b[0m \u001b[39m# 构建dag\u001b[39;00m\n", + "\u001b[0;31mNameError\u001b[0m: name 'qubit_used_2' is not defined" + ] + } + ], + "source": [ + "# # relabel by reconstructed_circuit , circuit to dag again\n", + "# qubit_num = len(qubit_used | qubit_used_2) # 并集求总的qubit数\n", + "# re_circuit = dag_to_circuit(dep_graph_copy, qubit_num)\n", + "\n", + "# # 构建dag\n", + "# re_dep_graph = circuit_to_dag(re_circuit,measure_flag= False) # 更新为新的函数名\n", + "\n", + "# # 可视化dag\n", + "# draw_dag(re_dep_graph, output_format=\"svg\") # 或者使用 \"png\" 作为输出格式" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 're_circuit' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/home/parallels/Documents/pyquafu/src/quafu/dagcircuits/labquafu_dag.ipynb Cell 58\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m re_circuit\u001b[39m.\u001b[39mdraw_circuit()\n", + "\u001b[0;31mNameError\u001b[0m: name 're_circuit' is not defined" + ] + } + ], + "source": [ + "# re_circuit.draw_circuit()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## nodelist_to_dag" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "def nodelist_to_dag(op_nodes: List[Any]) -> DAGCircuit:\n", + " # Starting Label Index\n", + " i = 0\n", + " \n", + " # A dictionary to store the last use of any qubit\n", + " qubit_last_use = {}\n", + " \n", + " # g = nx.MultiDiGraph() # two nodes can have multiple edges\n", + " # g = nx.DiGraph() # two nodes can only have one edge\n", + " g = DAGCircuit() \n", + " \n", + " # Add the start node \n", + " # g.add_node(-1,{\"color\": \"green\"})\n", + " g.add_nodes_from([(-1, {\"color\": \"green\"})])\n", + " \n", + " # deepcopy the circuit to avoid modifying the original circuit\n", + " # gates = copy.deepcopy(circuit.gates) # need to import copy\n", + " # change to: gate = copy.deepcopy(input_gate) in gate_to_node()\n", + "\n", + " for op_node in op_nodes:\n", + " # transform gate to node\n", + " hashable_gate = copy.deepcopy(op_node)\n", + " g.add_node(hashable_gate,color=\"blue\")\n", + " \n", + " # Add edges based on qubit_last_use; update last use\n", + " for qubit in hashable_gate.pos:\n", + " if qubit in qubit_last_use:\n", + " g.add_edge(qubit_last_use[qubit], hashable_gate,label=f'q{qubit}')\n", + " else:\n", + " g.add_edge(-1, hashable_gate,label=f'q{qubit}',color=\"green\")\n", + " \n", + " qubit_last_use[qubit] = hashable_gate\n", + "\n", + " \n", + " # Add the end node\n", + " # g.add_node(float('inf'),{\"color\": \"red\"})\n", + " g.add_nodes_from([(float('inf'), {\"color\": \"red\"})])\n", + " \n", + " for qubit in qubit_last_use:\n", + " g.add_edge(qubit_last_use[qubit], float('inf'),label=f'q{qubit}',color=\"red\")\n", + "\n", + " # update the qubits_used, cbits_used, num_instruction_nodes\n", + " g.qubits_used = g.update_qubits_used()\n", + " g.cbits_used = g.update_cbits_used()\n", + " g.num_instruction_nodes = g.update_num_instruction_nodes()\n", + " \n", + " return g" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q[0] --H-------\n", + " \n", + "q[1] --H----+-- M->c[2]\n", + " | \n", + "q[2] --X----*-- M->c[1]\n" + ] + } + ], + "source": [ + "# example simple3 circuit\n", + "simple3 = QuantumCircuit(3)\n", + "simple3.h(0)\n", + "simple3.h(1)\n", + "simple3.x(2)\n", + "simple3.cnot(2,1)\n", + "simple3.measure([2,1], [1,2])\n", + "\n", + "simple3.draw_circuit()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0{H(0)}, 1{H(1)}, 2{X(2)}, 3{CX(2,1)}]" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "i = 0 \n", + "op_nodes = [] \n", + "for gate in simple3.gates:\n", + " op_nodes.append(gate_to_node(gate,specific_label=i))\n", + " i += 1\n", + "\n", + "op_nodes\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "nodesdag = nodelist_to_dag(op_nodes[1:])" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1{H(1)}, 2{X(2)}, 3{CX(2,1)}]" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nodes_list = nodesdag.nodes_list()\n", + "nodes_list" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "# # Add measure_gate node\n", + "qm = Any\n", + "qm.name = \"measure\" \n", + "qm.paras, qm.duration, qm.unit = [None,None,None]\n", + "qm.pos = copy.deepcopy(simple3.measures) # circuit.measures is a dict\n", + "measure_gate = InstructionNode(qm.name, qm.pos, qm.paras, qm.duration, qm.unit, label=\"m\")\n", + "# nodes_list.append(measure_gate)\n", + "# nodes_list" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "1\n" + ] + }, + { + "data": { + "text/plain": [ + "({1, 2}, dict_keys)" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "for qubit in measure_gate.pos:\n", + " print(qubit)\n", + "\n", + "set(measure_gate.pos),type(measure_gate.pos.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2}" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nodesdag.qubits_used" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## nodes_list qubit mapping" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "# nodes_qubit_mapping_dict \n", + "def nodelist_qubit_mapping_dict(nodes_list):\n", + " '''\n", + " Args:\n", + " nodes_list: a list of nodes\n", + " Returns:\n", + " nodes_qubit_mapping_dict: a dict about keys are the qubits used by the nodes and values are the new qubits\n", + " '''\n", + " nodes_list_qubits_used = set()\n", + " for node in nodes_list:\n", + " if hasattr(node, 'pos') and node.pos is not None:\n", + " nodes_list_qubits_used = nodes_list_qubits_used | set(node.pos)\n", + " \n", + " mapping_pos = list(range(len(nodes_list_qubits_used))) \n", + " # mapping, get a dict\n", + " nodes_qubit_mapping_dict = dict(zip(sorted(list(nodes_list_qubits_used)), mapping_pos))\n", + " nodes_qubit_mapping_dict\n", + "\n", + " return nodes_qubit_mapping_dict\n", + "\n", + "def nodelist_qubit_mapping_dict_reverse(nodes_list):\n", + " '''\n", + " Args:\n", + " nodes_list: a list of nodes\n", + " Returns:\n", + " nodes_qubit_mapping_dict_reverse: a dict about keys are the new qubits and values are the qubits used by the nodes\n", + " ''' \n", + " nodes_qubit_mapping_dict = nodelist_qubit_mapping_dict(nodes_list)\n", + " # reverse mapping, get a dict\n", + " nodes_qubit_mapping_dict_reverse = {value: key for key, value in nodes_qubit_mapping_dict.items()}\n", + " \n", + " return nodes_qubit_mapping_dict_reverse\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "# a function to map nodes_list\n", + "def nodes_list_mapping(nodes_list, nodes_qubit_mapping_dict):\n", + " '''\n", + " Args:\n", + " nodes_list: the nodes list of instruction nodes\n", + " nodes_qubit_mapping_dict: the dict of the mapping qubits\n", + "\n", + " return: \n", + " nodes_list_mapping: the nodes_list after mapping qubits\n", + " '''\n", + " nodes_qubit_mapping_dict \n", + " nodes_list_mapping = []\n", + " for node in nodes_list:\n", + " node_new = copy.deepcopy(node)\n", + " if hasattr(node, 'pos') and node.pos is not None:\n", + " if isinstance(node.pos, list):\n", + " node_new.pos = [nodes_qubit_mapping_dict[qubit] for qubit in node.pos]\n", + " elif isinstance(node.pos, dict):\n", + " node_new.pos = {}\n", + " # the values of the dict are void, so we need to copy the values from the original dict\n", + " for qubit in node.pos:\n", + " node_new.pos[nodes_qubit_mapping_dict[qubit]] = copy.deepcopy(node.pos[qubit])\n", + " nodes_list_mapping.append(node_new)\n", + " return nodes_list_mapping\n" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "original nodes_list:\n", + " [1{H(1)}, 2{X(2)}, 3{CX(2,1)}]\n", + "mapped nodes_list:\n", + " [1{H(0)}, 2{X(1)}, 3{CX(1,0)}]\n", + "mapped nodes_list_reverse:\n", + " [1{H(1)}, 2{X(2)}, 3{CX(2,1)}]\n" + ] + } + ], + "source": [ + "nodes_qubit_mapping_dict = nodelist_qubit_mapping_dict(nodes_list)\n", + "nodes_qubit_mapping_dict_reverse = nodelist_qubit_mapping_dict_reverse(nodes_list)\n", + "\n", + "mapped_nodes_list = nodes_list_mapping(nodes_list, nodes_qubit_mapping_dict)\n", + "\n", + "\n", + "mapped_nodes_list_reverse = nodes_list_mapping(mapped_nodes_list, nodes_qubit_mapping_dict_reverse)\n", + "# nodes_list,mapped_nodes_list,mapped_nodes_list_reverse\n", + "print(\"original nodes_list:\\n\", nodes_list)\n", + "print(\"mapped nodes_list:\\n\", mapped_nodes_list)\n", + "print(\"mapped nodes_list_reverse:\\n\", mapped_nodes_list_reverse)\n", + "\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### nodes_list to dag for qubit mapping\n", + "- original nodes_list to dag\n", + "- new nodes_list after qubit mapping to dag\n", + "- new nodes_list after qubit inverse mapping to dag" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# draw the nodesdag, which is the original dag\n", + "nodesdag = nodelist_to_dag(nodes_list)\n", + "draw_dag(nodesdag, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# draw the nodesdag\n", + "nodesdag = nodelist_to_dag(mapped_nodes_list)\n", + "draw_dag(nodesdag, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# draw the nodesdag\n", + "nodesdag = nodelist_to_dag(mapped_nodes_list_reverse)\n", + "draw_dag(nodesdag, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2. Transforming DAG to QuantumCircuit" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NodeView((-1, 0{CX(0,1)}, 1{CX(1,0)}, 2{X(2)}, 3{CX(2,1)}, 4{CP(1,0)}(1.571), 5{barrier(0,1,2)}, 6{RXX(0,1)}(1.571), 7{delay(0)}, 8{CSWAP(0,1,2)}, 9{MCX(0,1,2)}, 10{MCY(0,1,2)}, 11{MCZ(0,1,2)}, 12{CT(2,1)}, inf))" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dep_graph.nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "%3\n", + "\n", + "\n", + "\n", + "-1\n", + "\n", + "-1\n", + "\n", + "\n", + "\n", + "0{CX(0,1)}\n", + "\n", + "0{CX(0,1)}\n", + "\n", + "\n", + "\n", + "-1->0{CX(0,1)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "-1->0{CX(0,1)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "1{X(2)}\n", + "\n", + "1{X(2)}\n", + "\n", + "\n", + "\n", + "-1->1{X(2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "2{CX(1,0)}\n", + "\n", + "2{CX(1,0)}\n", + "\n", + "\n", + "\n", + "0{CX(0,1)}->2{CX(1,0)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "0{CX(0,1)}->2{CX(1,0)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "3{CX(2,1)}\n", + "\n", + "3{CX(2,1)}\n", + "\n", + "\n", + "\n", + "1{X(2)}->3{CX(2,1)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "2{CX(1,0)}->3{CX(2,1)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "4{CP(1,0)}(1.571)\n", + "\n", + "4{CP(1,0)}(1.571)\n", + "\n", + "\n", + "\n", + "2{CX(1,0)}->4{CP(1,0)}(1.571)\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "3{CX(2,1)}->4{CP(1,0)}(1.571)\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "5{barrier(0,1,2)}\n", + "\n", + "5{barrier(0,1,2)}\n", + "\n", + "\n", + "\n", + "3{CX(2,1)}->5{barrier(0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "4{CP(1,0)}(1.571)->5{barrier(0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "4{CP(1,0)}(1.571)->5{barrier(0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "6{RXX(0,1)}(1.571)\n", + "\n", + "6{RXX(0,1)}(1.571)\n", + "\n", + "\n", + "\n", + "5{barrier(0,1,2)}->6{RXX(0,1)}(1.571)\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "5{barrier(0,1,2)}->6{RXX(0,1)}(1.571)\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "8{CSWAP(0,1,2)}\n", + "\n", + "8{CSWAP(0,1,2)}\n", + "\n", + "\n", + "\n", + "5{barrier(0,1,2)}->8{CSWAP(0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "6{RXX(0,1)}(1.571)->8{CSWAP(0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "7{delay(0)}\n", + "\n", + "7{delay(0)}\n", + "\n", + "\n", + "\n", + "6{RXX(0,1)}(1.571)->7{delay(0)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "9{MCX(0,1,2)}\n", + "\n", + "9{MCX(0,1,2)}\n", + "\n", + "\n", + "\n", + "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "7{delay(0)}->8{CSWAP(0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "10{MCY(0,1,2)}\n", + "\n", + "10{MCY(0,1,2)}\n", + "\n", + "\n", + "\n", + "9{MCX(0,1,2)}->10{MCY(0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "9{MCX(0,1,2)}->10{MCY(0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "9{MCX(0,1,2)}->10{MCY(0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "11{MCZ(0,1,2)}\n", + "\n", + "11{MCZ(0,1,2)}\n", + "\n", + "\n", + "\n", + "10{MCY(0,1,2)}->11{MCZ(0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "10{MCY(0,1,2)}->11{MCZ(0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "10{MCY(0,1,2)}->11{MCZ(0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "12{CT(2,1)}\n", + "\n", + "12{CT(2,1)}\n", + "\n", + "\n", + "\n", + "11{MCZ(0,1,2)}->12{CT(2,1)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "11{MCZ(0,1,2)}->12{CT(2,1)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "m{measure(0,1,2=>0,1,2)}\n", + "\n", + "m{measure(0,1,2=>0,1,2)}\n", + "\n", + "\n", + "\n", + "11{MCZ(0,1,2)}->m{measure(0,1,2=>0,1,2)}\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "12{CT(2,1)}->m{measure(0,1,2=>0,1,2)}\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "12{CT(2,1)}->m{measure(0,1,2=>0,1,2)}\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "\n", + "inf\n", + "\n", + "inf\n", + "\n", + "\n", + "\n", + "m{measure(0,1,2=>0,1,2)}->inf\n", + "\n", + "\n", + "q0\n", + "\n", + "\n", + "\n", + "m{measure(0,1,2=>0,1,2)}->inf\n", + "\n", + "\n", + "q1\n", + "\n", + "\n", + "\n", + "m{measure(0,1,2=>0,1,2)}->inf\n", + "\n", + "\n", + "q2\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 从dag中重建量子电路\n", + "reconstructed_circuit = dag_to_circuit(dep_graph, simple.num) # 更新为新的函数名\n", + "\n", + "# 构建dag\n", + "dep_graph = circuit_to_dag(reconstructed_circuit) # 更新为新的函数名\n", + "\n", + "# 可视化dag\n", + "draw_dag(dep_graph, output_format=\"svg\") # 或者使用 \"png\" 作为输出格式" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q[0] --*----+---------P(1.571)----||-------#---------Delay(100ns)----*----*----*----*------- M->c[0]\n", + " | | | || RXX(1.571) | | | | \n", + "q[1] --+----*----+-------*--------||-------#-------------------------x----*----*----*----T-- M->c[1]\n", + " | || | | | | | \n", + "q[2] --X---------*----------------||---------------------------------x----X----Y----Z----*-- M->c[2]\n" + ] + } + ], + "source": [ + "reconstructed_circuit.draw_circuit()" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "edge = {'label': 'q23'}\n", + "int(edge['label'][1:]) == 23" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "from quafu import QuantumCircuit" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ycquafu", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From adbce8954bb2d0a098bc3463035d7ee1876fedb4 Mon Sep 17 00:00:00 2001 From: chen_wei <109205133+chensgit169@users.noreply.github.com> Date: Sun, 2 Jul 2023 22:44:42 +0800 Subject: [PATCH 23/70] Add files via upload MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CircuitPlotManager has been implemented to support plotting the most commonly-used gates/instructions, with two simple examples uploaded. Please help to test whether it has no error integrating into dev-branch, for it was written firstly to work well with the odd version of pyquafu. Supports for other instructions, as well as more documentation and examples, will be added a little bit later. （线路绘图功能基本完成，稍加完善即可发布使用。请先测试与dev分支能够整合无误。使用说明文档和其余功能稍后添加。） --- visualisation/__init__.py | 0 visualisation/circuitPlot.py | 488 ++++++++++++++++++++++++ visualisation/examples/__init__.py | 0 visualisation/examples/deutsch_jozsa.py | 106 +++++ visualisation/figures/deutsch_jozsa.png | Bin 0 -> 124193 bytes visualisation/figures/test.png | Bin 0 -> 284254 bytes 6 files changed, 594 insertions(+) create mode 100644 visualisation/__init__.py create mode 100644 visualisation/circuitPlot.py create mode 100644 visualisation/examples/__init__.py create mode 100644 visualisation/examples/deutsch_jozsa.py create mode 100644 visualisation/figures/deutsch_jozsa.png create mode 100644 visualisation/figures/test.png diff --git a/visualisation/__init__.py b/visualisation/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/visualisation/circuitPlot.py b/visualisation/circuitPlot.py new file mode 100644 index 0000000..68fd201 --- /dev/null +++ b/visualisation/circuitPlot.py @@ -0,0 +1,488 @@ +import numpy as np +import quafu +import matplotlib.patheffects as pe +import matplotlib.pyplot as plt +from matplotlib.collections import PolyCollection, PatchCollection, LineCollection +from matplotlib.patches import Circle, Arc +from matplotlib.text import Text + +line_args = {} +box_args = {} + +DEEPCOLOR = '#0C161F' +BLUE = '#1f77b4' +ORANGE = '#ff7f0e' +GREEN = '#2ca02c' +GOLDEN = '#FFB240' +GARNET = '#C0392B' + +""" +layers(zorder): + +0: figure +1: bkg box +2: wires +3: closed patches +4: white bkg for label/text +5: labels +""" + +su2_gate_names = ['x', 'y', 'z', 'id', 'w', + 'h', 't', 'tdg', 's', 'sdg', 'sx', 'sy', 'sw', + 'phase', + 'rx', 'ry', 'rz', + ] + +swap_gate_names = ['swap', 'iswap'] +r2_gate_names = ['rxx', 'ryy', 'rzz'] +c2_gate_names = ['cp', 'cs', 'ct', 'cx', 'cy', 'cz'] +c3_gate_names = ['fredkin', 'toffoli'] +cm_gate_names = ['mcx', 'mcy', 'mcz'] +operation_names = ['barrier', 'delay'] + + +class CircuitPlotManager: + """ + A class to manage the plotting of quantum circuits. + Stores style parameters and provides functions to plot. + + To be initialized when circuit.plot() is called. + """ + _wire_color = '#FF0000' + _wire_lw = 1.5 + + _light_blue = '#3B82F6' + _ec = DEEPCOLOR + + _a_inch = 2 / 2.54 # physical lattice constant in inch + _a = 0.5 # box width and height, unit: ax + + _barrier_width = _a / 3 # barrier width + + _stroke = pe.withStroke(linewidth=2, foreground='white') + + def __init__(self, qc: quafu.QuantumCircuit): + """ + Processing graphical info from a quantum circuit, + whose gates are stored as a list at present. + + In the future the circuit will be stored as a graph + or graph-like object, procedure will be much simplified. + (TODO) + """ + self.qbit_num = qc.num + + # step0: containers of graphical elements + + self._h_wire_points = [] + self._ctrl_wire_points = [] + + self._closed_patches = [] + + self._mea_arc_patches = [] + self._mea_point_patches = [] + + self._ctrl_points = [] + self._not_points = [] + self._swap_points = [] + + self._barrier_points = [] + + self._text_list = [] + + # step1: process gates/instructions + dorders = np.zeros(qc.num, dtype=int) + for gate in qc.gates: + id_name = gate.name.lower() + _which = slice(np.min(gate.pos), np.max(gate.pos) + 1) + depth = np.max(dorders[_which]) + paras = getattr(gate, 'paras', None) + + # TODO: call processing functions + if id_name == 'barrier': + self._proc_barrier(depth, gate.pos) + elif id_name == 'measure': + self._proc_measure(depth, gate.pos) + elif id_name in su2_gate_names: + self._proc_su2(id_name, depth, gate.pos, paras) + elif id_name == 'swap': + self._proc_swap(depth, gate.pos) + elif id_name == 'cx': + self._proc_ctrl(depth, gate.ctrls[0], gate.targs[0], 'x') + else: + # control + raise NotImplemented + dorders[_which] = depth + 1 + self.depth = np.max(dorders) + 1 + + for q, c in qc.measures.items(): + self._proc_measure(self.depth - 1, q) + + # step2: initialize bit-label + self.q_label = [f'q_{i}' for i in range(qc.num)] + self.c_label = [f'c_{i}' for i in qc.measures.values()] + + # step3: figure coordination + self.xs = np.arange(-3 / 2, self.depth + 3 / 2) + self.ys = np.arange(-2, self.qbit_num + 1 / 2) + + def __call__(self, + title=None, *args, **kwargs): + """ + + """ + # Not supported by patch collections? + # if 'xkcd' in kwargs: + # import random + # plt.gca().xkcd(randomness=random.randint(0, 1000)) + if title is not None: + title = Text((self.xs[0] + self.xs[-1]) / 2, -0.8, + title, + size=30, + ha='center', va='baseline') + self._text_list.append(title) + + # initialize a figure + _size_x = self._a_inch * abs(self.xs[-1] - self.xs[0]) + _size_y = self._a_inch * abs(self.ys[-1] - self.ys[0]) + fig = plt.figure(figsize=(_size_x, _size_y)) # inch + ax = fig.add_axes([0, 0, 1, 1], + aspect=1, + xlim=[self.xs[0], self.xs[-1]], + ylim=[self.ys[0], self.ys[-1]], + ) + ax.axis('off') + ax.invert_yaxis() + + self._circuit_wires() + self._inits_label() + self._measured_label() + self._render_circuit() + + ######################################################################### + # Helper functions for processing gates/instructions into graphical + # elements. Add only points data of for the following collection-wise + # plotting if possible, create a patch otherwise. + ######################################################################### + def _circuit_wires(self): + """ + plot horizontal circuit wires + """ + for y in range(self.qbit_num): + x0 = self.xs[0] + 1 + x1 = self.xs[-1] - 1 + self._h_wire_points.append([[x0, y], [x1, y]]) + + def _gate_bbox(self, x, y, fc: str): + a = self._a + from matplotlib.patches import FancyBboxPatch + bbox = FancyBboxPatch((-a / 2 + x, -a / 2 + y), a, a, + boxstyle=f'round, pad={0.2 * a}', + edgecolor=DEEPCOLOR, + facecolor=fc, + ) + self._closed_patches.append(bbox) + + def _inits_label(self, labels: list[int] = None): + """ qubit-labeling """ + if labels is None: + labels = self.q_label + + for i, label in enumerate(labels): + label = r'$|%s\rangle$' % label + txt = Text(-2 / 3, i, + label, + size=18, + color=DEEPCOLOR, + ha='right', + va='center', + ) + self._text_list.append(txt) + + def _measured_label(self, labels: list[int] = None): + """ measured qubit-labeling """ + if labels is None: + labels = self.c_label + + for i, label in enumerate(labels): + label = r'$%s$' % label + txt = Text(self.xs[-1] - 3 / 4, i, + label, + size=18, + color=DEEPCOLOR, + ha='left', + va='center', + ) + self._text_list.append(txt) + + def _gate_label(self, s, x, y): + if not s: + return None + _dy = 0.05 + text = Text(x, y + _dy, + s, + size=24, + color=DEEPCOLOR, + ha='center', + va='center', + ) + text.set_path_effects([self._stroke]) + self._text_list.append(text) + + def _para_label(self, para_txt, x, y): + """ label parameters """ + if not para_txt: + return None + _dx = 0 + text = Text(x + _dx, y+0.7*self._a, + para_txt, + size=12, + color=DEEPCOLOR, + ha='center', + va='top', + ) + self._text_list.append(text) + + def _measure_label(self, x, y): + from matplotlib.patches import FancyArrow + a = self._a + r = 1.1 * a + d = 1.2 * a / 3.5 + + arrow = FancyArrow(x=x, + y=y + d, + dx=0.15, + dy=-0.35, + width=0.04, + facecolor=DEEPCOLOR, + head_width=0.07, + head_length=0.15, + edgecolor='white') + arc = Arc((x, y + d), + width=r, + height=r, + lw=1, + theta1=180, + theta2=0, + fill=False, + zorder=4, + color=DEEPCOLOR, + capstyle='round', + ) + center_bkg = Circle((x, y + d), + radius=0.035, + color='white', + ) + center = Circle((x, y + d), + radius=0.025, + facecolor=DEEPCOLOR, + ) + self._mea_arc_patches.append(arc) + self._mea_point_patches += [center_bkg, arrow, center] + + ######################################################################### + # # # # processing-functions: decompose ins into graphical elements # # # + ######################################################################### + def _proc_su2(self, id_name, depth, pos, paras): + if id_name in ['x', 'y', 'z', 'h', 'id', 's', 't', 'p', 'u']: + fc = '#EE7057' + label = id_name.capitalize() + elif id_name in ['rx', 'ry', 'rz']: + fc = '#6366F1' + label = id_name.upper() + else: + fc = '#8C9197' + label = '?' + + if id_name in ['rx', 'ry', 'rz', 'p']: + para_txt = r'$\theta=$' + f'{paras:.3f}' + else: + para_txt = None + + self._gate_label(label, depth, pos) + self._para_label(para_txt, depth, pos) + self._gate_bbox(depth, pos, fc) + + def _proc_ctrl(self, depth, ctrl_pos, tar_pos, tar_name, ctrl_type: bool = True): + if tar_name == 'x': + self._ctrl_points.append((depth, ctrl_pos, ctrl_type)) + self._ctrl_wire_points.append([[depth, ctrl_pos], [depth, tar_pos]]) + self._not_points.append((depth, tar_pos)) + else: + raise NotImplemented + + def _proc_swap(self, depth, pos): + p1, p2 = pos + self._swap_points += [[depth, p] for p in pos] + self._ctrl_wire_points.append([[depth, p1], [depth, p2]]) + + def _proc_barrier(self, depth, pos: list): + x0 = depth - self._barrier_width + x1 = depth + self._barrier_width + + for p in pos: + y0 = (p - 1 / 2) + y1 = (p + 1 / 2) + nodes = [[x0, y0], [x0, y1], [x1, y1], [x1, y0], [x0, y0]] + self._barrier_points.append(nodes) + + def _proc_measure(self, depth, pos): + fc = GOLDEN + self._gate_bbox(depth, pos, fc) + self._measure_label(depth, pos) + + # TODO: decide whether to draw double wire for measurement + # y = pos + 0.02 + # x0 = depth + # x1 = self.depth - 1 / 2 + # self._h_wire_points.append([[x0, y], [x1, y]]) + + ######################################################################### + # # # # # # # # # # # # # # rendering functions # # # # # # # # # # # # # + ######################################################################### + def _render_h_wires(self): + h_lines = LineCollection(self._h_wire_points, + zorder=0, + colors=self._wire_color, + alpha=0.8, + linewidths=2, + ) + plt.gca().add_collection(h_lines) + + def _render_ctrl_wires(self): + v_lines = LineCollection(self._ctrl_wire_points, + zorder=0, + colors=self._light_blue, + alpha=0.8, + linewidths=4, + ) + plt.gca().add_collection(v_lines) + + def _render_closed_patch(self): + collection = PatchCollection(self._closed_patches, + match_original=True, + zorder=3, + ec=self._ec, + linewidths=0.5, + ) + plt.gca().add_collection(collection) + + def _render_ctrl_nodes(self): + circle_collection = [] + r = self._a / 4 + for x, y, ctrl in self._ctrl_points: + fc = '#3B82F6' if ctrl else 'white' + circle = Circle((x, y), radius=r, fc=fc) + circle_collection.append(circle) + circles = PatchCollection(circle_collection, + match_original=True, + zorder=5, + ec=self._ec, + linewidths=2, + ) + plt.gca().add_collection(circles) + + def _render_not_nodes(self): + points = [] + rp = self._a * 0.3 + r = self._a * 0.5 + + for x, y in self._not_points: + points.append([[x, y - rp], [x, y + rp]]) + points.append([[x - rp, y], [x + rp, y]]) + circle = Circle((x, y), radius=r, lw=1, + fc='#3B82F6') + self._closed_patches.append(circle) + + collection = LineCollection(points, + zorder=5, + colors='white', + linewidths=2, + capstyle='round', + ) + plt.gca().add_collection(collection) + + def _render_swap_nodes(self): + points = [] + r = self._a / (4 ** (1 / 2)) + for x, y in self._swap_points: + points.append([[x - r, y - r], [x + r, y + r]]) + points.append([[x + r, y - r], [x - r, y + r]]) + collection = LineCollection(points, + zorder=5, + colors='#3B82F6', + linewidths=4, + capstyle='round', + ) + plt.gca().add_collection(collection) + + def _render_measure(self): + stroke = pe.withStroke(linewidth=4, foreground='white') + arcs = PatchCollection(self._mea_arc_patches, + match_original=True, + capstyle='round', + zorder=4) + arcs.set_path_effects([stroke]) + + plt.gca().add_collection(arcs) + pointers = PatchCollection(self._mea_point_patches, # note the order + match_original=True, + zorder=5, + facecolors=DEEPCOLOR, + linewidths=2, + ) + plt.gca().add_collection(pointers) + + def _render_barrier(self): + barrier = PolyCollection(self._barrier_points, + closed=True, + fc='lightgray', + hatch='///', + zorder=4) + plt.gca().add_collection(barrier) + + def _render_txt(self): + for txt in self._text_list: + plt.gca().add_artist(txt) + + def _render_circuit(self): + self._render_h_wires() + self._render_ctrl_wires() + self._render_ctrl_nodes() + self._render_not_nodes() + + self._render_swap_nodes() + self._render_measure() + self._render_barrier() + self._render_closed_patch() + self._render_txt() + + +if __name__ == '__main__': + n = 8 + qc_ = quafu.QuantumCircuit(n) + qc_.h(0) + + qc_.barrier([0, 3]) + qc_.x(0) + qc_.swap(0, 4) + qc_.cnot(3, 6) + qc_.rz(4, 3.2) + + for k in range(10): + qc_.x(7) + for k in range(n-1): + qc_.cnot(k, k + 1) + qc_.measure([0, 1, 2, 3], [0, 1, 2, 3]) + + # for i in range(30): + # qc.x(4) + + cmp = CircuitPlotManager(qc_) + cmp(title='This Is a Quantum Circuit') + import os + if not os.path.exists('./figures/'): + os.mkdir('./figures/') + plt.savefig('./figures/test.png', dpi=300, transparent=True) + plt.close() + # plt.show() diff --git a/visualisation/examples/__init__.py b/visualisation/examples/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/visualisation/examples/deutsch_jozsa.py b/visualisation/examples/deutsch_jozsa.py new file mode 100644 index 0000000..25af135 --- /dev/null +++ b/visualisation/examples/deutsch_jozsa.py @@ -0,0 +1,106 @@ +import random + +import matplotlib.pyplot as plt +import numpy as np + +from quafu import QuantumCircuit +from visualisation.circuitPlot import CircuitPlotManager + + +def get_const_oracle(n: int): + const_oracle = QuantumCircuit(n + 1) + output = np.random.randint(2) + if output == 1: + const_oracle.x(n) + const_oracle.name = 'Constant Oracle' + return const_oracle + + +def get_balanced_oracle(n: int): + oracle = QuantumCircuit(n + 1) + b_str = ''.join([random.choice('01') for _ in range(n)]) + + # Place X-qu_gate + for qubit in range(len(b_str)): + if b_str[qubit] == '1': + oracle.x(qubit) + + # Use barrier as divider + oracle.barrier(list(range(n+1))) + + # Controlled-NOT qu_gate + for qubit in range(n): + oracle.cnot(qubit, n) + + oracle.barrier(list(range(n+1))) + + # Place X-qu_gate + for qubit in range(len(b_str)): + if b_str[qubit] == '1': + oracle.x(qubit) + + oracle.name = 'Balanced Oracle' + return oracle + + +def deutsch_jozsa(n: int, case: str): + circuit = QuantumCircuit(n + 1) # number of q-bit and c-bit + + # Initialization + for qubit in range(n): + circuit.h(qubit) + circuit.x(n) + circuit.h(n) + + # Add oracle + ################################################# + if case == 'balanced': + b_str = ''.join([random.choice('01') for _ in range(n)]) + + # Place X-qu_gate + for qubit in range(len(b_str)): + if b_str[qubit] == '1': + circuit.x(qubit) + + circuit.barrier(list(range(n+1))) + # Controlled-NOT qu_gate + for qubit in range(n): + circuit.cnot(qubit, n) + circuit.barrier(list(range(n+1))) + + # Place X-qu_gate + for qubit in range(len(b_str)): + if b_str[qubit] == '1': + circuit.x(qubit) + elif case == 'constant': + const_oracle = QuantumCircuit(n + 1) + output = np.random.randint(2) + if output == 1: + const_oracle.x(n) + else: + raise ValueError('undefined case: ' + case) + ################################################# + + # Repeat H-qu_gate + circuit.barrier(list(range(n+1))) + for qubit in range(n): + circuit.h(qubit) + circuit.barrier(list(range(n+1))) + + # Measure + circuit.measure(list(range(n)), list(range(n))) + return circuit + + +if __name__ == '__main__': + # plt.figure(dpi=240) + # balanced_oracle = get_balanced_oracle(n=4) + circuits_ = deutsch_jozsa(n=4, case='constant') + cmp = CircuitPlotManager(circuits_) + cmp(title='Deutsch-Josza Circuit') + import os + + if not os.path.exists('./figures/'): + os.mkdir('../figures/') + plt.savefig('../figures/deutsch_jozsa.png', dpi=240) + # plt.show() diff --git a/visualisation/figures/deutsch_jozsa.png b/visualisation/figures/deutsch_jozsa.png new file mode 100644 index 0000000000000000000000000000000000000000..5f40dd32b9f1fb007ffec626b59baee2db84cf2a GIT binary patch literal 124193 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 literal 0 HcmV?d00001 diff --git a/visualisation/figures/test.png b/visualisation/figures/test.png new file mode 100644 index 0000000000000000000000000000000000000000..a53e5b036f3860cbfd91ad5d9f5df7ff3a6da26d GIT binary patch literal 284254 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�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

LvZK87xR4HVS0 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 literal 0 HcmV?d00001 From a5b5c0b85e468c388f5095a701f2dac81e8bcaeb Mon Sep 17 00:00:00 2001 From: chen_wei <109205133+chensgit169@users.noreply.github.com> Date: Sun, 2 Jul 2023 23:20:16 +0800 Subject: [PATCH 24/70] Add files via upload reload for dir-path mistake... --- src/quafu/visualisation/__init__.py | 0 src/quafu/visualisation/circuitPlot.py | 488 ++++++++++++++++++ src/quafu/visualisation/examples/__init__.py | 0 .../visualisation/examples/deutsch_jozsa.py | 106 ++++ .../visualisation/figures/deutsch_jozsa.png | Bin 0 -> 124193 bytes src/quafu/visualisation/figures/test.png | Bin 0 -> 284254 bytes 6 files changed, 594 insertions(+) create mode 100644 src/quafu/visualisation/__init__.py create mode 100644 src/quafu/visualisation/circuitPlot.py create mode 100644 src/quafu/visualisation/examples/__init__.py create mode 100644 src/quafu/visualisation/examples/deutsch_jozsa.py create mode 100644 src/quafu/visualisation/figures/deutsch_jozsa.png create mode 100644 src/quafu/visualisation/figures/test.png diff --git a/src/quafu/visualisation/__init__.py b/src/quafu/visualisation/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/quafu/visualisation/circuitPlot.py b/src/quafu/visualisation/circuitPlot.py new file mode 100644 index 0000000..68fd201 --- /dev/null +++ b/src/quafu/visualisation/circuitPlot.py @@ -0,0 +1,488 @@ +import numpy as np +import quafu +import matplotlib.patheffects as pe +import matplotlib.pyplot as plt +from matplotlib.collections import PolyCollection, PatchCollection, LineCollection +from matplotlib.patches import Circle, Arc +from matplotlib.text import Text + +line_args = {} +box_args = {} + +DEEPCOLOR = '#0C161F' +BLUE = '#1f77b4' +ORANGE = '#ff7f0e' +GREEN = '#2ca02c' +GOLDEN = '#FFB240' +GARNET = '#C0392B' + +""" +layers(zorder): + +0: figure +1: bkg box +2: wires +3: closed patches +4: white bkg for label/text +5: labels +""" + +su2_gate_names = ['x', 'y', 'z', 'id', 'w', + 'h', 't', 'tdg', 's', 'sdg', 'sx', 'sy', 'sw', + 'phase', + 'rx', 'ry', 'rz', + ] + +swap_gate_names = ['swap', 'iswap'] +r2_gate_names = ['rxx', 'ryy', 'rzz'] +c2_gate_names = ['cp', 'cs', 'ct', 'cx', 'cy', 'cz'] +c3_gate_names = ['fredkin', 'toffoli'] +cm_gate_names = ['mcx', 'mcy', 'mcz'] +operation_names = ['barrier', 'delay'] + + +class CircuitPlotManager: + """ + A class to manage the plotting of quantum circuits. + Stores style parameters and provides functions to plot. + + To be initialized when circuit.plot() is called. + """ + _wire_color = '#FF0000' + _wire_lw = 1.5 + + _light_blue = '#3B82F6' + _ec = DEEPCOLOR + + _a_inch = 2 / 2.54 # physical lattice constant in inch + _a = 0.5 # box width and height, unit: ax + + _barrier_width = _a / 3 # barrier width + + _stroke = pe.withStroke(linewidth=2, foreground='white') + + def __init__(self, qc: quafu.QuantumCircuit): + """ + Processing graphical info from a quantum circuit, + whose gates are stored as a list at present. + + In the future the circuit will be stored as a graph + or graph-like object, procedure will be much simplified. + (TODO) + """ + self.qbit_num = qc.num + + # step0: containers of graphical elements + + self._h_wire_points = [] + self._ctrl_wire_points = [] + + self._closed_patches = [] + + self._mea_arc_patches = [] + self._mea_point_patches = [] + + self._ctrl_points = [] + self._not_points = [] + self._swap_points = [] + + self._barrier_points = [] + + self._text_list = [] + + # step1: process gates/instructions + dorders = np.zeros(qc.num, dtype=int) + for gate in qc.gates: + id_name = gate.name.lower() + _which = slice(np.min(gate.pos), np.max(gate.pos) + 1) + depth = np.max(dorders[_which]) + paras = getattr(gate, 'paras', None) + + # TODO: call processing functions + if id_name == 'barrier': + self._proc_barrier(depth, gate.pos) + elif id_name == 'measure': + self._proc_measure(depth, gate.pos) + elif id_name in su2_gate_names: + self._proc_su2(id_name, depth, gate.pos, paras) + elif id_name == 'swap': + self._proc_swap(depth, gate.pos) + elif id_name == 'cx': + self._proc_ctrl(depth, gate.ctrls[0], gate.targs[0], 'x') + else: + # control + raise NotImplemented + dorders[_which] = depth + 1 + self.depth = np.max(dorders) + 1 + + for q, c in qc.measures.items(): + self._proc_measure(self.depth - 1, q) + + # step2: initialize bit-label + self.q_label = [f'q_{i}' for i in range(qc.num)] + self.c_label = [f'c_{i}' for i in qc.measures.values()] + + # step3: figure coordination + self.xs = np.arange(-3 / 2, self.depth + 3 / 2) + self.ys = np.arange(-2, self.qbit_num + 1 / 2) + + def __call__(self, + title=None, *args, **kwargs): + """ + + """ + # Not supported by patch collections? + # if 'xkcd' in kwargs: + # import random + # plt.gca().xkcd(randomness=random.randint(0, 1000)) + if title is not None: + title = Text((self.xs[0] + self.xs[-1]) / 2, -0.8, + title, + size=30, + ha='center', va='baseline') + self._text_list.append(title) + + # initialize a figure + _size_x = self._a_inch * abs(self.xs[-1] - self.xs[0]) + _size_y = self._a_inch * abs(self.ys[-1] - self.ys[0]) + fig = plt.figure(figsize=(_size_x, _size_y)) # inch + ax = fig.add_axes([0, 0, 1, 1], + aspect=1, + xlim=[self.xs[0], self.xs[-1]], + ylim=[self.ys[0], self.ys[-1]], + ) + ax.axis('off') + ax.invert_yaxis() + + self._circuit_wires() + self._inits_label() + self._measured_label() + self._render_circuit() + + ######################################################################### + # Helper functions for processing gates/instructions into graphical + # elements. Add only points data of for the following collection-wise + # plotting if possible, create a patch otherwise. + ######################################################################### + def _circuit_wires(self): + """ + plot horizontal circuit wires + """ + for y in range(self.qbit_num): + x0 = self.xs[0] + 1 + x1 = self.xs[-1] - 1 + self._h_wire_points.append([[x0, y], [x1, y]]) + + def _gate_bbox(self, x, y, fc: str): + a = self._a + from matplotlib.patches import FancyBboxPatch + bbox = FancyBboxPatch((-a / 2 + x, -a / 2 + y), a, a, + boxstyle=f'round, pad={0.2 * a}', + edgecolor=DEEPCOLOR, + facecolor=fc, + ) + self._closed_patches.append(bbox) + + def _inits_label(self, labels: list[int] = None): + """ qubit-labeling """ + if labels is None: + labels = self.q_label + + for i, label in enumerate(labels): + label = r'$|%s\rangle$' % label + txt = Text(-2 / 3, i, + label, + size=18, + color=DEEPCOLOR, + ha='right', + va='center', + ) + self._text_list.append(txt) + + def _measured_label(self, labels: list[int] = None): + """ measured qubit-labeling """ + if labels is None: + labels = self.c_label + + for i, label in enumerate(labels): + label = r'$%s$' % label + txt = Text(self.xs[-1] - 3 / 4, i, + label, + size=18, + color=DEEPCOLOR, + ha='left', + va='center', + ) + self._text_list.append(txt) + + def _gate_label(self, s, x, y): + if not s: + return None + _dy = 0.05 + text = Text(x, y + _dy, + s, + size=24, + color=DEEPCOLOR, + ha='center', + va='center', + ) + text.set_path_effects([self._stroke]) + self._text_list.append(text) + + def _para_label(self, para_txt, x, y): + """ label parameters """ + if not para_txt: + return None + _dx = 0 + text = Text(x + _dx, y+0.7*self._a, + para_txt, + size=12, + color=DEEPCOLOR, + ha='center', + va='top', + ) + self._text_list.append(text) + + def _measure_label(self, x, y): + from matplotlib.patches import FancyArrow + a = self._a + r = 1.1 * a + d = 1.2 * a / 3.5 + + arrow = FancyArrow(x=x, + y=y + d, + dx=0.15, + dy=-0.35, + width=0.04, + facecolor=DEEPCOLOR, + head_width=0.07, + head_length=0.15, + edgecolor='white') + arc = Arc((x, y + d), + width=r, + height=r, + lw=1, + theta1=180, + theta2=0, + fill=False, + zorder=4, + color=DEEPCOLOR, + capstyle='round', + ) + center_bkg = Circle((x, y + d), + radius=0.035, + color='white', + ) + center = Circle((x, y + d), + radius=0.025, + facecolor=DEEPCOLOR, + ) + self._mea_arc_patches.append(arc) + self._mea_point_patches += [center_bkg, arrow, center] + + ######################################################################### + # # # # processing-functions: decompose ins into graphical elements # # # + ######################################################################### + def _proc_su2(self, id_name, depth, pos, paras): + if id_name in ['x', 'y', 'z', 'h', 'id', 's', 't', 'p', 'u']: + fc = '#EE7057' + label = id_name.capitalize() + elif id_name in ['rx', 'ry', 'rz']: + fc = '#6366F1' + label = id_name.upper() + else: + fc = '#8C9197' + label = '?' + + if id_name in ['rx', 'ry', 'rz', 'p']: + para_txt = r'$\theta=$' + f'{paras:.3f}' + else: + para_txt = None + + self._gate_label(label, depth, pos) + self._para_label(para_txt, depth, pos) + self._gate_bbox(depth, pos, fc) + + def _proc_ctrl(self, depth, ctrl_pos, tar_pos, tar_name, ctrl_type: bool = True): + if tar_name == 'x': + self._ctrl_points.append((depth, ctrl_pos, ctrl_type)) + self._ctrl_wire_points.append([[depth, ctrl_pos], [depth, tar_pos]]) + self._not_points.append((depth, tar_pos)) + else: + raise NotImplemented + + def _proc_swap(self, depth, pos): + p1, p2 = pos + self._swap_points += [[depth, p] for p in pos] + self._ctrl_wire_points.append([[depth, p1], [depth, p2]]) + + def _proc_barrier(self, depth, pos: list): + x0 = depth - self._barrier_width + x1 = depth + self._barrier_width + + for p in pos: + y0 = (p - 1 / 2) + y1 = (p + 1 / 2) + nodes = [[x0, y0], [x0, y1], [x1, y1], [x1, y0], [x0, y0]] + self._barrier_points.append(nodes) + + def _proc_measure(self, depth, pos): + fc = GOLDEN + self._gate_bbox(depth, pos, fc) + self._measure_label(depth, pos) + + # TODO: decide whether to draw double wire for measurement + # y = pos + 0.02 + # x0 = depth + # x1 = self.depth - 1 / 2 + # self._h_wire_points.append([[x0, y], [x1, y]]) + + ######################################################################### + # # # # # # # # # # # # # # rendering functions # # # # # # # # # # # # # + ######################################################################### + def _render_h_wires(self): + h_lines = LineCollection(self._h_wire_points, + zorder=0, + colors=self._wire_color, + alpha=0.8, + linewidths=2, + ) + plt.gca().add_collection(h_lines) + + def _render_ctrl_wires(self): + v_lines = LineCollection(self._ctrl_wire_points, + zorder=0, + colors=self._light_blue, + alpha=0.8, + linewidths=4, + ) + plt.gca().add_collection(v_lines) + + def _render_closed_patch(self): + collection = PatchCollection(self._closed_patches, + match_original=True, + zorder=3, + ec=self._ec, + linewidths=0.5, + ) + plt.gca().add_collection(collection) + + def _render_ctrl_nodes(self): + circle_collection = [] + r = self._a / 4 + for x, y, ctrl in self._ctrl_points: + fc = '#3B82F6' if ctrl else 'white' + circle = Circle((x, y), radius=r, fc=fc) + circle_collection.append(circle) + circles = PatchCollection(circle_collection, + match_original=True, + zorder=5, + ec=self._ec, + linewidths=2, + ) + plt.gca().add_collection(circles) + + def _render_not_nodes(self): + points = [] + rp = self._a * 0.3 + r = self._a * 0.5 + + for x, y in self._not_points: + points.append([[x, y - rp], [x, y + rp]]) + points.append([[x - rp, y], [x + rp, y]]) + circle = Circle((x, y), radius=r, lw=1, + fc='#3B82F6') + self._closed_patches.append(circle) + + collection = LineCollection(points, + zorder=5, + colors='white', + linewidths=2, + capstyle='round', + ) + plt.gca().add_collection(collection) + + def _render_swap_nodes(self): + points = [] + r = self._a / (4 ** (1 / 2)) + for x, y in self._swap_points: + points.append([[x - r, y - r], [x + r, y + r]]) + points.append([[x + r, y - r], [x - r, y + r]]) + collection = LineCollection(points, + zorder=5, + colors='#3B82F6', + linewidths=4, + capstyle='round', + ) + plt.gca().add_collection(collection) + + def _render_measure(self): + stroke = pe.withStroke(linewidth=4, foreground='white') + arcs = PatchCollection(self._mea_arc_patches, + match_original=True, + capstyle='round', + zorder=4) + arcs.set_path_effects([stroke]) + + plt.gca().add_collection(arcs) + pointers = PatchCollection(self._mea_point_patches, # note the order + match_original=True, + zorder=5, + facecolors=DEEPCOLOR, + linewidths=2, + ) + plt.gca().add_collection(pointers) + + def _render_barrier(self): + barrier = PolyCollection(self._barrier_points, + closed=True, + fc='lightgray', + hatch='///', + zorder=4) + plt.gca().add_collection(barrier) + + def _render_txt(self): + for txt in self._text_list: + plt.gca().add_artist(txt) + + def _render_circuit(self): + self._render_h_wires() + self._render_ctrl_wires() + self._render_ctrl_nodes() + self._render_not_nodes() + + self._render_swap_nodes() + self._render_measure() + self._render_barrier() + self._render_closed_patch() + self._render_txt() + + +if __name__ == '__main__': + n = 8 + qc_ = quafu.QuantumCircuit(n) + qc_.h(0) + + qc_.barrier([0, 3]) + qc_.x(0) + qc_.swap(0, 4) + qc_.cnot(3, 6) + qc_.rz(4, 3.2) + + for k in range(10): + qc_.x(7) + for k in range(n-1): + qc_.cnot(k, k + 1) + qc_.measure([0, 1, 2, 3], [0, 1, 2, 3]) + + # for i in range(30): + # qc.x(4) + + cmp = CircuitPlotManager(qc_) + cmp(title='This Is a Quantum Circuit') + import os + if not os.path.exists('./figures/'): + os.mkdir('./figures/') + plt.savefig('./figures/test.png', dpi=300, transparent=True) + plt.close() + # plt.show() diff --git a/src/quafu/visualisation/examples/__init__.py b/src/quafu/visualisation/examples/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/quafu/visualisation/examples/deutsch_jozsa.py b/src/quafu/visualisation/examples/deutsch_jozsa.py new file mode 100644 index 0000000..25af135 --- /dev/null +++ b/src/quafu/visualisation/examples/deutsch_jozsa.py @@ -0,0 +1,106 @@ +import random + +import matplotlib.pyplot as plt +import numpy as np + +from quafu import QuantumCircuit +from visualisation.circuitPlot import CircuitPlotManager + + +def get_const_oracle(n: int): + const_oracle = QuantumCircuit(n + 1) + output = np.random.randint(2) + if output == 1: + const_oracle.x(n) + const_oracle.name = 'Constant Oracle' + return const_oracle + + +def get_balanced_oracle(n: int): + oracle = QuantumCircuit(n + 1) + b_str = ''.join([random.choice('01') for _ in range(n)]) + + # Place X-qu_gate + for qubit in range(len(b_str)): + if b_str[qubit] == '1': + oracle.x(qubit) + + # Use barrier as divider + oracle.barrier(list(range(n+1))) + + # Controlled-NOT qu_gate + for qubit in range(n): + oracle.cnot(qubit, n) + + oracle.barrier(list(range(n+1))) + + # Place X-qu_gate + for qubit in range(len(b_str)): + if b_str[qubit] == '1': + oracle.x(qubit) + + oracle.name = 'Balanced Oracle' + return oracle + + +def deutsch_jozsa(n: int, case: str): + circuit = QuantumCircuit(n + 1) # number of q-bit and c-bit + + # Initialization + for qubit in range(n): + circuit.h(qubit) + circuit.x(n) + circuit.h(n) + + # Add oracle + ################################################# + if case == 'balanced': + b_str = ''.join([random.choice('01') for _ in range(n)]) + + # Place X-qu_gate + for qubit in range(len(b_str)): + if b_str[qubit] == '1': + circuit.x(qubit) + + circuit.barrier(list(range(n+1))) + # Controlled-NOT qu_gate + for qubit in range(n): + circuit.cnot(qubit, n) + circuit.barrier(list(range(n+1))) + + # Place X-qu_gate + for qubit in range(len(b_str)): + if b_str[qubit] == '1': + circuit.x(qubit) + elif case == 'constant': + const_oracle = QuantumCircuit(n + 1) + output = np.random.randint(2) + if output == 1: + const_oracle.x(n) + else: + raise ValueError('undefined case: ' + case) + ################################################# + + # Repeat H-qu_gate + circuit.barrier(list(range(n+1))) + for qubit in range(n): + circuit.h(qubit) + circuit.barrier(list(range(n+1))) + + # Measure + circuit.measure(list(range(n)), list(range(n))) + return circuit + + +if __name__ == '__main__': + # plt.figure(dpi=240) + # balanced_oracle = get_balanced_oracle(n=4) + circuits_ = deutsch_jozsa(n=4, case='constant') + cmp = CircuitPlotManager(circuits_) + cmp(title='Deutsch-Josza Circuit') + import os + + if not os.path.exists('./figures/'): + os.mkdir('../figures/') + plt.savefig('../figures/deutsch_jozsa.png', dpi=240) + # plt.show() diff --git a/src/quafu/visualisation/figures/deutsch_jozsa.png b/src/quafu/visualisation/figures/deutsch_jozsa.png new file mode 100644 index 0000000000000000000000000000000000000000..5f40dd32b9f1fb007ffec626b59baee2db84cf2a GIT binary patch literal 124193 zcmeFZ3kv}eK^hSiB!!0(2@wTpq#L&iY!$_%Lq)o!q!AQUK%~2* zTUz>z$$sDS`v=a4^WpWn_BMFdde)lrj&YBB-1FfTIf*SB={Hg+lr5JfFDOzdG`;xm z#QL@P7o*|w1pLNtby3ZVYNlspt7CDCBCBI%Zfs^{Y;a@0%`FQ{12a=@jjB zvNE?6;N&#g_(+a2iES6#owWbhvFX;tyE#kwPY+5azgsUUap7Ea<&OSmKOHyp zTephZZF%sQ4R1qGi*atq;CC8s$LT=*mn{tqj`~0B=-hSI<9k zTTF@LE;a}Mjc@tqj~_p-o?#JI8+$dB$Edb1A#bVDk6VAdSzA)_pMl!Am~h#EXy^H9 z!@BsO@2}Z<^B=9E+~r0VHXWJluX5<|(`RgqNJvOny?XVB#Rm@_MBe=N;)HUvQmy>W zo9~^R8)PVyW)HtZ;%v&%pLbuNG|O37eAs(Z?G4_*XrwtK)4bze;hdbLnw{vKYBWkPX#RLdN=nMYfPI-sd3h+geBj~H;GdmdqVWeWKKht)ghJVG zpOpz%R$dV*F;yim+W*#rS#fr}yXLL26F|mUVr5si}E{ zvJTt&jMLB0Z*HPobPAV7-}v$_YY9pT??iy%Jjd9<~G*G)PK2X$E z>(C|7D~oeespcK$Rejb_&b__Jw=G}i#mkpGE(>-wF{<)sTdZDA4>fcSyuckO(kHcZ zH53#S=J1*tnvV<|r-v#wab~vC&a(`D3c_f$FJ-VZ_L!UZ03o40}YZwY~ki+k*#Ri;E?&-H#qW zuFA0NO|c!-8g9u_ZAv$*3vpeF>g&6`PUIkka-9Y+Q0}F_e>7PZ(WO73;qoEzM`Zm! zW*){D=D!u0AL16CuGc-ixo~8j*SP*ldW%iK+Rgjk4AjIl8EdE9R@lR?uC(Wb(v?E@ zEy*o5eLoK@PB)p&EzOUn8aJH2rKi`Z32>RXw?nA?fPhus8{(GMA+KKTW<7e8jg|G{ zh7B78Y=(TFvWUj(7C$xU{SgF{30PX3X>%&~p@W<9nl$#klozSMzl0>@k`=V&(ktC3 zyf|59)0W^kGvWZFC-&e`qxkkb%@!sBC2^0fH82>SJHIYCFN_rnIM1aN7JaOIc0l~h z&9B=drnY@lFMi52G5Ljo;)~7NePh+CRU6l@|EeAjFOMI#8EuWjQi$g*FJ%#L`~3Mr zR!!1BdQmj>|H zTB^Ko*oIw4`i9fnYGIXu0x;@C7TO0i*QsUxJX85=w%wka>=$rZ_?WviXGGRa-uVd~ z_oZ^-nZWyO#9LyMbqd#Rp+ECA{*Yma%bbBp!-p^ZpBB3B-M>Fouj^${7q96slvLa` zSTY7k|8W;~)Mmq`O;tHFtuZ7hrMI~d=N=yEyuVH4XG}uwz@J}a8IL}G@&xf=Q6@x| ze&4=Gv%E!><@vVd4?!>~xL+UavlgL5DM3rvry8HPAnu{xl4)HPtsHYkr{J$W#}z-v z&*QNN{Y71KU!EW<64)6P5nTCJ+(RaH%lh>{1NkkjdV_2QGEP|1^BPB557rX%wX}vc zpF^%RPIboZC#ye-op6fOq=0> zuIQm%yLZ1&$eoj-hRZw;2?>cQSw(qs1<|K{d-wO(RUdAZRHvJ1SIzKS_IQqD^fLGE zA)d=8sjlwN?D9vaYPik5mkANCp zzuGNlo3GD_NPC~Gh`pK|sJa{XX{U4+d(|y1&da9ej1@6Vm2#K!WxQJ$Y|coA>x}&C z#UGUfDIVifQ#JCUi|@BG3EYNrgpW+%vwiLirqA;7@?OSpkLLfqrZHLH>s@H5^`GB5 ztcMRDJ8(b@0d(WmttyDBQa&7UNCuG(Qv=b|h^N^(v$?zMef<2Q5Or^3(*?}i@5%)W zMJ4N(pMWDF6^$dRo0})XF!o@He*V1jnp0cr^$BHI^=qXMH!rJ-{#A8DS2vlt_wP09 zta?i6SdSbz!NsK@A|kSJ(cv@Jn1%clS5TX6yV z@%KMML=)ihxZ- z+a?mduseq}0|yQtJ0^+O`0n5urJa|1{``3jjSNRgDXGc;vs{B{6E!v8q9+W!U5^-# z9z0l3!`i-_PdDe9iYd%mN73$4?O>YtI((-prkLLOF_ekuZ*|hieaARs?lCH<*!o-+uW@cu} zQHmGg`qY_`mYN(#+t+NWKQ8YPEc$eR9Z4bZ?u*L{6JD^IS9{#;9Ua*YAHD!A60MQ( zfqY4A+_e~l7#PN@7-bFRU9RE>>ee|2`g_Vtatdza$o<`!kuUm1Pn?LA<( zp`V=G8wW*pQrb_irKIm=Vlt8ZFk6MMQuXmKJR0J3BiiQjr5uMT4aLrE`w36emP|U> zZMaeDRA*w1>^}npsZG`i&bczIVo4OOGELh)JOL*ve!f znFCMyz^`XzHOVtCDJgkMWO0&u=){Q=jt#+f92- z2`^@zV8rZDyRlzeorBMsG*C%w89t! zbL1oz`Od?c#+uCX=wQH!3hAbr5jE=XC3kdINU-qW%I;^Gn_eI}_|7pAJCeM7`Hppl zx8E6q7iDdiU1owfdjFXjDD>FI0Q>%+kgO-0rM)I?jyGoi@FBm3bu2uFN=vTCk+k35 zFZ1{2&>VP{6gZYqBom^t@bQN0hI4WcChi8XeeH0e*dlT?!pES;dlY-0kurclgCOIMq(Ed>1b*7g{G>hm(HELOAYBo zd^z1y7NFnInc4jQ@=MRJUnPBvvw+NR9X@=xUei)%eJ}R#$sRV9ecOa5pD9Eu9hWwm zo|@uu-^OCfDC#0qK1F*tMm2$VF>AK{{x%KG_^^$Ne6C$zcXY;QjhuFJcAi*hE+2Jq z7HgI`7Il`f^N0xF6t{k7?ebO^~o7zG$&`s3DpB6Ul!}!Vc9hxDrx;To8aWZyMXy<+-{7 z$jBj%)WFx-nFNJ}H9L!*Pyu6k^nWl)7u&cY2>Kh+($h!JkLI;~tJ%*fGTXI_)Cz4b z^KsIx)J?=y^LYt;7R-Uao>LpNS*MMRm-q+r+`D0Rd0;g(#h;ycTx@nwj0589ZXSv9{jIiT$ zXJWn;yiB?@pKnZBI1(4(!#79(>i;fkil1c-%%pf zM98yvZC%=2_!B#Xblo2wu$!5Ar0dajudc3}E%v=Z4nT){XlZ+2(62Y3IeMI*0LZN7EV@%5@fPRa#2^1n_{^6Na&UWo<1)p>ybS+jU}NemFy3H6jnJmhWwlj>?E z&5!0{Nl8hMo;;~Z(k)K09#mOGN!XZa9fLhG>i4EwV!S(n%p4aPtx<^AV;`A{p z?bi2K3IszTZqck;$0j18MPLcOefO?ix-<18OghYr#3AN4IBR#cWsT;>aOVCgh@ZE! zw~vCq5N`(x2uDE}rIvJKFduRo8_v554l>xI+?8eMba2IOIt5BH%ts zk=2n!F8+vIVC0v_v`y9_$cn_89zA-b2#gH3=5h1z&^O6?@#4h?lPrQtOq#%+h}(4^ z{`>F04J+S2eE06%3Xc$}AWmMQzcOsk&YkaoK@e>Q7G@^|T$i%tf&{{_vxcZ1)N>qC zTbiQa!5U=2CVI+(ChlrnM^PW%m}*dU$;HJ*E`F`vlYLwTlT+Id9z3|R-N&hy4jecj zB`>dvx7x}q6bX0iHE1j=$OOzwWC6^Rwi>K0Q{v0B?3E+1mXD9GO_xI}TTNbM_I>{} zUasztm(aWUku3S{5}!Q7EWl$oclT&`TPEy<$FTYstVen@d*W&CY!3sqiqQ#Xj|WaQ z%^K#dn%ZN7l4C%b^OOddCni4gcK;c#r%zQ-aWHAuD|_N;t(t&I`rT-?uAsQ=9(JC3 z*@&z{pzi5g-*3icA^dz;a$Q=mXID!+2hd&%2ed}a5~?vRs?&CjLxd}jpTB^*@!Qdm zYE9dg*TY;I$NBiwK7IN`;2!;1(^wJbxtlH1qj}4Qpq%`9P5hB_LWJrfTzKa8&;2=nemzEorxI`SXfJ#8yNi#bv3r@_-q$AaT(^5l{T%wkd}LTMTu?x? zSd_360t^I}Or1{vT&IfGVrF`}w(M+MY;Uk5@rf+GrsdYNhYlTLy$ojN<1BgN5F)gRfS0x3LrnE9!mf1TCf9|lWr+j7AtxM3>KHF*+3hxX<=5N~UdH>$M z-6(8O;gLr&LTOQC+ajN>fA5>t41&3cx95VMDO0! zRmA7uhT6%pSvJE~b(*$O2-kJlA}T;O1UPHE%zl}ix=+$T>0o_Qr*hsa=F>O-377G+ zD4Un}Kl5#}I*GE8vgYo!$4{T~9&T7bX>&hDIw$<%4 zr>CcnecmO%ueUs;eC8v*j0bC~XV?rtOb{0(4d78nSWEiG6IU@ud@Xz!^o! z`XkBF0H&uR#eiB>UJNh&eB4^iWVAIWoMi&=T~jk&S_bRhGphHy{nJ*4@>0jCRFO4S z;B)^Vj!vAJ26A}<&eSMv?6dQGh0se4PK=?Ko>-_2>sj^v{PdyjeNBiFFo&^aHdr%$ zV@c~uJ$vZ99b$+HpGMR`?a+#k7hn)7H*uR+o!6l*R*HHj<lPDB|Kck-BoKgR$o2X z-``Jv>iXTN(745gg-Im)E~9KPi~Wx|b5Y5AOnzF&5-E0n?d-s)A@WTGlHR}lOp=iDy9ggq=tR*)~KPm+WtGP$BsTy_?U=ktY_YPhl zVCD3&6-Hu`W=_KqtZaW z{Un$c7kGFI19mx2l${Odhz|Dl)~i!8RsCLCdWI)`T2@My%_dd z(5~;Ths^MO$x4K&YAl(M*Ay6CBb5JyfM7h$^oAXUtixbj`sCbTLX)v0$e_iAiE_Dw zZw;j*FTG)zAU-TCc)rG)D%{9+VWZ~6Cl3DRYL51l?58+RHTM1tFcY+Eb-jCIPUGVxoyM~M>b z^rQ}P8n)XT6?w6kO%%MT{IZD$Q0hc^r>{bo)E-&iQ=jy*5S>9}uefqKx z(Y6lVLs?+peEkP5z90pBgr=24b)-Uggoh)T&haxvxz6*(X&K-KgB+?2#HIn2eV2B2 zk7SM38YSfPbUg|*8mdp?^{UnWaPuLo^_IfLA38Q6u$T{W@qgJ9O7~V4B{eybY%bf% z=FWd&P3Xwh*+H# z_@KGmUkGUcJl~a0i2%R{@!csH;S#cLy5$D&WQ6pBet=#Rh@pVFU#%^#fzCkUF7q_q z)YBu(SYqVCUOtPif1+&kB1|8oe)r)F>E%2*{0SxFeo-h))Q+4!U8$6n&3r5M=C_^0 zZF$T7CIo#rO!f&)g{Y$ElwHQlt^XtC%}%ugtgK)30`A!vj^W0)2R3`buLrQ2X>ShJ zp}|psWH4IIHIh9c7hs}DrKZ|X=ta~j)UUW`<5e!P$T}JO!1j>=TSu0Jt(&@y z;pR$&{?=Sb(aLe~=hAgwSXek2SvpISMsgVv^~uQ3_CJD!jiNOHYJ)U3jQ^Ud(@yVl z*gSM-6=nQBnBrR?jP#;40V2u_#4NZCDh~&kfX>%-Fr-Li%=QE*=Q_H$? zLl$vykhbK3RJ*Yo)M1b>BVAG)peWst{dWh@55y#mkfdS^A#d=;_CW@_-5Nn=VGi|*|UCz zGbk$>YRpihD5E9~7$$5GDMD?gh7Cx`k6co$)I`V)@TwLT7vpzf9g=0mmUdRi^qtTY zlHNHID*61NVPi@ZtL{p&;ha85Q9A-WYIV&~UYy5r(%&!iO3;_m9S`+-crSgr-t%?f z&mX&~z6x9ogqK6Ld0WhS`rFs9r}m6z9DHv@!!2QcqF$>%cmPoLN8zyiOzqVm&lwXiun}B*n6bc z=YYO7QXg?`FGl)#>)25DR#DRsIGxP2fi{Qzv}gOTYZc$hvQEG0Dm(XWdp zFE3~_lxS3X?*<43`ZKqmp%DV)-<0MrU>zOBX%NJUwijNhuKm;fJ#=(YfKYwl&}#qL zacC0p)@bb4m&R=S(mt`Py1X?93@aSQYn8SIc!4(|?oO!V~2Bmo=PEVvGa;76t6qhnKfVChC zIPv%!>Ft=L!CHQz#+8wcvB@ASid8wY=e)K^Eoq1#=UrCxJAJDfpmgOs)Ke9elwRGc zGc;_80W=O3&^aCC}f~{}Fh{f;G`2 zrzt1<#)=Iv@^8yOt@qT_=RIoo#+rnqvg@eNyg0;d2#l>y(w(R&223M7Z_e+6O{k)C z9_>E<4i)wwY2B9kam$uH4AR!q*4E=V+`nOnKV}_`kKarTnur-g2cPNPKbkz6<&%XX zb*fUDv%xv9ggC0`@lo?NHNeRecsnh6_8*VPygsH zby;;KT!zlWYxpTVOGERXcs5**^d75<4Vu#8P{8#}-eF`1X|Kl+QxMYpibJzeNs!y? z&{-&aGNI)N1)S{eUs9ElldA;;NI_iAnfM_{=ty+TNdFlvf;N-;G4J0Wp6ahEuBK^1 z06K#;M^ve~_x(cv;08&KX_i?{mV4c^qR<43vI$P%9M}*mu<7;6%R(oVSo-{sgiLDk z*+5Q7iS~wHTP-~clUf}|g^9cXz&Y9I5d-(>)2Ba#f3hbsh!3}<2@90j`Bae6=0SP` zr)O!Y*VdUNG#1&lbDLizZM?x}rboY3RZdLLW+>aGV-RFF5{DMLN3{e={Wj;};ZY`} z3d*Y~5Ezl5E;50Rt$@9=%4n}c9+Np3pOvClMjv33lan)r@5|^~{fR8hr6=^aWQ zH8@uSA@gPItS^i<2&+f6$G5twk&;-7d@h^H?f9zFb>p~3_%X&6-Wk0}IGN1=AHJ!E z7y>XmdK*OtwAcF1w)b~-9@5s%9rfrvHIaLxJXL|Q%=q`KkQoWMHwl>PnO0HMUTNOV z;^2{LQO7Ew%Ox8u)WDt_=>lcO3Nd6->`52uvN*?|@h(uyW%kxR`=dzDFQRNnPf|+i z(aV^>ud2xM7m=364m%&p^@rHE;imL*r6zD9^)+W%+^=ju1N94O52Lj*g)J~ZG?QZ( zMDB4wZN+0Vq=rI64B))fQk#yBj<@NfVXI00)zSxr@lLG)!kNuG4%niPNXTSo*ebEt zR0Kh%8G9bmR~MdX4h37S1mL3x@D{{do9cx7&iyXjCYwrBEK`8;f_Q$kN@LSo9oX7d z1Y-ahgd03BF1}~)-f+~1vvYI)8+U_sk0qVNtgW^+kqU>X!?2MQFr!t&9d!Th2VqQ& zLAhB;Zb$j7+J*pTe|&@aL%0fwKP2LY%LPTFjWUQmk)tyL+cp4^0|}csDdas{ZgMUW3Zd@wsI~ z`=l#D)(}=XYi?~|*qzQI(tZM)9||)ZK(MYN9*w53hgLOu8c!Jc6~W`%3w*B}8e~H+ z3p}*V%(jn*xZkF+MJRC#riB*FmS8JYu$wis+D>l~d<>95{woXwvA|~>2x^o_lVBOd zn;2_HQx`y*5J#0^lKJ`W;wEAg92=Sm^7v9*9AL+heLT6l6@Ku)dtP_ zPeK8JzS{?md;SojAbk#!`#{=A>TTo!p|(z;$)DmxiiYIxKbjlQiv1%jF7%ZqX%G)Y zqYYsq;A{CFP)UM_dZNr8Tw$$>s0hOW%06 z3e>(K2-fh%p6+{odZJbW;H*UX_pB>WnB--E>Rhd6?zn&yujw>o&}kZdY|iJF$w>SmIRjnnv{RH1p@MI?UVjehowPk*5nLadXM7aDs& zba80f7=WOp7j?;AyOlBW*O$k=QElkTlD3zWq@=m|7oR|3M-`Imr_O@1``A++l7PI) z9~W#yhl>dCF$F!1l;lmlZ+|&FxAa&aDdD19Agf7%$`JiLyzPs@-&fb%J$e95Xe$7t zv(7h_@wLMvdC((9 z7gG_&290B+|JISxIx9Yn*5+duPy(4{K{1>2V4>{Yhl){HO@oQDeH9 zS@baY*7h#LcDaouA};_s%6L`eS-$IUp#(obnMx(y!*I^EO;`}2plK}#o`_mQFAE{M zzQtB-$M)^llV#D^qIs>Mv`-{9YYhtv%a(no&Rt70uGl3nq%$A_W|maU{ap9%-BW^~ zCtw&bM?X_Ozr}B{zz6_UF8;7BV0%hKI7-63N-xfWRVI;!SXGNnlS%l9C0b8#!0&IZ zNw;e9`47_Tf*tq$92-ux8CDN4Ard__(yv}A`@(q^oUXQXkwvQDXm*uS7Hpab2`w#n z%xT?jv3zS0(ckC(iLQbov=Nykf{1IQG89-FoZo&g;W2A%)(ZfeE?B;pCCDuyp`KBd zjZS?@(Y-FvN?58ZM4}Njjf|ZZvkVT+|gdCT9aU=@Gg~dgaG)pTr<09ZxStkCr zL>=)>(ceOzJ=^Y#ea{57CYzcLp%XjEjw;8|9R28F6me7FOa+aHvKw<8)600#9|Sgk z4B%|ipX8!lMP*Xa=|K3m5QGQ?uD&K&#UdjUbtCX4mPWvEa zEuTwIxWE5M?0~>K_TXy;f#ke51*)tagy#|T}o|O|8b(oB_8LHR$rnbz*O&eab%AXC5 zl)k5eBZ&<^N&~<6aL>=p;pK-1XwCJJa6UBjASQxP%sUy`vol%S!FHs%;oECIxeSZ$ z>KIkdfZ?GQn{GYqM&@u@(+Z7ff_lbfuKy@?luPB5efq>qgnF<=;} zr)+9%I~RB;z38BZ$H9UHkn){zoHh;^Mt3e8c}y^G|GLx3!;m5=+HH)Fbj~Lp5UyUok{K`^A)>q2j_Yz zK`Rg-VaeeB7Pvq##~T{|!M=)6IhNwre>B$Y79o1y0W4KD`tUb0ozc^ngu+Ac<`Buq z)dqL*=D$CNZh`T{F%2(m$^?dk4#u zYSyL&eX6bXaT@=K(L*$U{S^t`gtzG`mvbLv8H1Bt8c)i3&UJ{BF#uAlwcIIY3h%9- z93QXr(RT4m$mrozMZcHSg?d>;B@1Pl%~#)%f>N40RaI4F&VfJ99k@amLQuKEW%bh1 zBnIdq#aQEQLA3;!U~6QUb~t5#De?8+CBV)u3+zh;2+~|!Gjbd4((p#-$qEU%wxVnV zGy&+K%fKtv)mhhR_ExJ0ekx6ifda;Uz!AbfQa?qd?K&c3-ZVSMrWAQSxeT;HpjPpk zZ9;FL*^Th(j3=0%s((_7c19T7lxaf)&$Jqv{*cd@Hu${`jy*MW$Zs~53mxHzA8t!% z8{Q_h(O{eA?~Jv_oRHVMn!trrBYYCZ!6xXJ(2dXQK@t|eP0a=g9^P{e8nqN6pZ=Mo z83jeg3GLkMG8@Db%SO2gBp}^y{jnKbmN|bHjCV{R4J9{(Llt13nco4EJOOo3z%Z!l zI0z1Yj4Z9Pt;%(FgkGpxFAMB4PhW+JexJ}lmYDXbM+k_N>ijl~{{%lQ% z0zA*e!yBiSl$H|ZNB4M@ojfEnH{6{9}wF(q2Xp(E%)Ay2z0Z7uut=bkIJ$%Sz{kN!Nx+XOF)u7mQ zqKC;u1=cWYF5SN&x$BbWzK&O8u8UKuK0yb1P1Vzkqw2IA%dF-B1+D?9S1P%&l0`#DFN%|e$Yg=;1+0c(bwprEmhpDp$oJA-e~fAkHzXI|Go+~f4LsEX z4Ka^tGase~r~vq9t^F6fA%-FKWOx5pP3~5gc@t{Hn(+7U`@#cED@h`KB@o|@L`t|< z!Y?@g{D!cyrr!*VWxvySq&n9qPV z!4rC6{#2F1Q=Z5y4a%wsS~;HB&xl%r6HY?u^AW`R78aHe5#dHg6?ql@lnkUA?m#k zvuYT~U{Xw{(@R?>e~)Fh)#>5y?Q4TJ_u5cnt?+EuOLW-{bBklOaxyg&k{1v~#nYAm zo^N|H3D)ufPUOzzc%yx}4x5*Eo-=3iMMrn{>xdbL%SDk2q2tT>ElTJ~R6u5!<$4s`#Y+k+aM^sR zxftZ?gdl|%WkLK^dFWrpg^D08F&0^okPmTXG&xSa7P4mfcB*tSZh4-L>&AuL;-);; zJR*bXwr@&C58SEl`abt0tA51*UH&=CGEf1gmNMGf+PY{~Y-OUoYeWVXf9&aS!c0RF zlqR}pUlv)G3+ty4$;qmrZc)Hhs{xM%Hj=PxYG_f;2x0WDC|)y*QAHezgd{NDofz%= zsAo6yk9q5<&7Bx7;$5^Wd39XZ3A~3rJppNT3#Zgk+LYMdKs6>t^%4ZZWQPGbPjE#7 z-Qr`fI~H6;!75z>7JmZ7RLKYL6fYv`3%wtK20)_alWp)RZQHN)Yu0W~9Gt=!%uOOV z+B*B<7X}lGe7STzfzbFS`MXV7{%q*A)bE+?@oXz$OUS-aXSoDolN&-YgBd;yM?k`x zt-~#owQy8OsJT8_Up|+)ZRH7;mXOw6P z-M_>Ddx$QFkg5}LXRE!8N&^~On&pKa%nn~af{zU@^5@ons(|KAK)K~L9y<#@vwiM& zh#rt;vhvGf7?*AlpK)IPsm+Jb&G>^D@C2-tf2-@!K--h@%@U_QA8TJiW0+>uA!+G`f_1WG5Y+zjpA%<@|!=w5(6r+}? zaryy!k_TP1w6u`BU&Crbp%aDWUfQ^E<7uAO|8N^|+Id=pKSj(TNH|~ym69SRj5Mu# zjzBUGyROA2W!mtpyqOR~LQ%(wl4UM>7;!fOov?l+v>IF;-x!bVPs9-TD$BAvg8z;c z`o&jy<0k&W4!=Ypcp)=W&@P2R=Ltb=Q?@*U1&?ukVoa+DNG@5w(_i#NVRTgdGZFCO zM^}hzO)+A&gXFw32*xM{sib*jAF>Q#?q&S()Ra>iD@Z`ZJTi1Ul!*bf5Yn*2L>M6p zq7f6y<^%ceoJXc31luHXvk`Rl8Cs(I^U9-8Vl+7oUyzW9LHt5d#{6%TQ3UX0o%*(MtTemvy zsisi)_?xo)%b4yrdh{_y)(D^>lBfcZ-z!j5zX4>|PAx}A6zyyS-nL|nyF^22;U7O` zh}{O)EufkFBviES@R1|Y=iN36I8Mj*&yyk^wid0H^o~&MJ9i#58#OAw$pj_c^5UrL zEIaKv5j62le;D(P#>4o-aQ|o|JPtZhpmGGEpI`>Yn>|1Yok0Bvz#a+Y4Ywd9k)opF zE0pU<6ny|+0w~HcG(2&}J+#2S|Au50;BwX|;h{jTL?TQRo*#M#GCW0y$ns#}@SfA# zHg2p$>AIVN!Dv=4_AqLb)_zOH#<{x&yn%TyKz5OdU<4sJlDe3f7?Fh|9s@sN>>&cl zgGt1RPo6eyYGR^lyt`z0X?3T%Tp-_Dh&Y-yo5zQt`@h1oA3C&$p8kZZ>vAmTW-n;U zi2!Qp`guNWzK4qD61)cCj}wow^<7&04-*;;U;Kd~@mT7##w(kZaKBd;_sx&+K`Zi;s3!zzIl+i7`=z zA6c6m)BB+ri3Xeq=E&T)efyiasX?}b2hZc1U*fg#hSnI=A*gY3A`yB@^*ooHOJ2;f ze9OyNWnwS_Cm(Fxut9++_R$O^qI<9mNH0+At2#MlV+kUN)UfLfeSv-PM2hqKWu)9l zU`(RnZ<%3NiS>n{zXQJ;g*}y$mZoC54Rkj&;=0t2F#rBQ)~- zb0h7w_7p8j=0hL;NP%))97-%L`|dpiQ-nW_wA_p12V_G;Gzkd=-Gons2>Ld=nV90p zytZmDBk@I|w2=+utB9WmlMjGFgoO6=b&#nLHXUMo##~FoTGZLGczI? zY!ftR7DtCpNVpe)@6Q&$H@hGyFK_#&b50%s9EF>y>M8Ag7<{;j;qr{Kb7#&%Fbom4 zcy19VrvCS`tG`c7Omv#+G$5)(sH6~S<;YA>i$sF z_yvHXBeX{t&qoGVS62vjFO$h+>YUd<|NMlbSOeM%hPk#|fY=LfoShRG{qquDh90X1 zDRdh5rP(<;4w9K~!U%kz4`de-(g4S)h*2#~%}3Yhp)Dt!o|0m)gYSvbay;}!O9L6% zMr@5?&AHV-w@IvqVU{U z)~ovF6lS5HnUQRaE=umgxHLKDA|Yqmzu*3J+$1=++o0e{&nrgy+mSP8s(YO7P9r2$ zLbAf-^4`i6S&PWp`_r0CE$7tqgrMJ@Yg=CG{oQ6Dri4}kAvEu=+lG!U@a!DOi!+$V z_bAohrXh>=dz6i80JTX0{gqU7#Uq^it=Zv|RfvOUQ1zD-r%6F5LfXfgs1)&*ad>G* z(z9S^NC1{VkrG6pbb~LAGWj6xfn0qNlO=bo`T5bVl0rXiMS2YZi>gm&1;8ySn24B! zb=?i3#KOF`0vxNV*y1cecQtBd;4&^%pVj#fB{?Wv522|hr4Y&lwj)PYWo)>d-T1L=Yy)e5po68@NE4Gf3zWsfdnu2lu&6zOI5`{Jg-WEr7) z!r06Qry*D}nJe-3a^we$7XH(IpUA?)^sflP&l_`{v&tT?5)`+y;}g?5@XX)eFgj?D zL@n@|;rCa^2`GeKa&&U+utEOaRb+6O8vdpa(@I!Trq%>uApObjYzenfU`9jPBW-m2 z7|{`tWF18Lv^uns-lw&6R$7}|ORk^?*q7mub9y9aNcy&0t&hky8phk+11M z<9Q1eV?jI#VZ(_NG z>s#q`9-_B*P3Km4+RXv`3g~g92N7mYk=ZU3yaL_!t)UXzbkWlC7V<_JLQiB4K+u~a z@?4hZkHa9w(3WQaShN1Bdul@6CW1xc9}I}h&5VxzZp5w|;c2F$JD<|?eAiosEIa}26{oDm=mA3Y2t4~vKp zG;Utj5+oCSNbXa3CKCVDll7hu$z`Z$HAC&9|3 zrF_P9$qBVlZ$>%1>vnto-$V;@QuvY3i4#&d)5QVObqG26<218)jhe_al2Z(}(jCQ^ zJz_2uWh2qiu<`NLA6VS0LPR$pYlvi-2pi`>AMIga2#ClfTY=f?LHJ&p{aSS}4@CXZ zWPJZ|-8n+i5j}Gs?(8q@m_~Zcz`4h84w6pig$oxVL2V4wCxxPMF+6@~`uWR<;X@z= zWk|U|By|`dF+irru?#nZ=lbC%!43n*v5DmyUhj26K~#lV`*&zAsiE2-MZwDWenYYZ z>6QZJ18K&9psS*;T5T@Oc_?obM`Gy6g^0uv)dRMWfQ7A$d~aZp{dhtt8JW_J*DxMN z2Di{KClHOWOayg7fq?;3ZNgvSxQoXuvLhH)iN>UmAvTs^Nq{NR1OO}e{nTc1S^$Bg zfZ`~25|E&$h8n2Ez^(h4i5rl44{ZxuN74{6uP^GHd(K-o!NiJ3VbRXf}1 z(~8(aRp>-&5bsdS{;YhwVJ|NZJWx-%;YPk2kivj`H&7tl=QU3JfwPb?RR9y12at6t znc^hP4a7NbB#juB^KUJFecnJAm8gKnrBCc50Rlf;;IM(7+!vsy7=(%V=4$OV8K0je$aDduAE$lw^tNzYqkyw!wUCF&rVdv{ zc)g5SIZ3nl`VVr_=EpdQSFQVgilIrI)Q~3QcbaTPb`Jj%IpgQuV1nPST*qM~L`!qPmmCFpr5&sw)+B!pk*OxtNLAHm<#laVP6|Eu zH%@z4(X$bh4^WOP?h19>OT_QTt^nU8Ae4Zikt2uh;Mch4A#(2MmHiLg-1;FFsYdm+ zp@&?x+YWkG{GQ$oF%BGz1YLrj3knN0HFuJ0`TknjZH@0Jfk=sqsE&$~09E3gNTmvB zIFPw&RiBk}QMY0^9+yeexpxe#+#tUjr*4rukzfBi#`OO`r@QtH4iF1%--q(Bq;7Fb z;ZKsA5D#v~Z9=^Q(xe6y^n$mKEGloPY2yLM&l+i>Y&e7N5ILS|WC^)q^y@e!pS>X~ zNE;jgvqK*yidb*OfuHpyqm?*CkUy4#tyQ!h_AInRV#TV@t(&0S4HP;KQ_rWa9BjMW z;;#ux`_=U@%47S`(nNUSx@S-MeKL4oX>n1JK#C~5mxfs4xdRswE`q;M@6SR&FPI|# ze?Pde@`IQ6XG_}f@!yA6!iJk?%>6yMmHA2hkFxOyWE?n$>T}Jfjh}=le0%Xf3JvYQ zH|`j?{^jbY1yCJKjVzSiyWLoQ6I2s|#fx!No92o??p{5zJ(iEn*A+vDjEzSryZ>@K z?#pu4G*G;F)qg)@$7j1iC2&uvHnYsCb2?Y*@7af+Uqi7wLB5!>ttX0n@!f()B=nSv z5npM4E5xG)x4)vcqjU{f1oHYq&mz{cscs6Vyg9X>EK~Bz_uK80-=Y$4{rMPW_gX9% z#cuDvcl{Oh>5(#(pK?y@9M<5j{z@eMy*-#dc6;fXeAbnZZvFS89S>LDT;u%82gfjJ zW^TO$Pxdvhq>x^Iy~@yr9?aT|{!Chx&qRb(ZoIzwg4-y+FRTQLcAaJ(wWM_trEAW~ zx$*qp{@HEErP#gv46=ph+g6sIxnS45m8Ivnhj(vYM^^c+$FaVDm!6g^{fHYmwK89P zch_|{tVrNvvMe*`?cVJMtV+d(AOFY=l9#)zBRG1V9C(Lsy>MXzF2gq}DWpcfR_6E+ zi-e>?YfgJu>Mp~_?X(dzkG*gA1lp^A7?Ni_8i7LreRuC4g>3!RiXtI?+HY?dviDUe28IZ*68^N!L& zKe-V882$-P)81u`RQK(p`28G5 z0mRMl7>ziA8_vvR?4p`qd1jh3d*q2zhXDX(WlcBb*aH;b-o5jCC$HzC#C>{V+iW7I zz@^YuC;185MY;W>s|pGWtcve0(T@%7I-wOC8B_9isadZu7i?&h*=D3Q=DAsROq=&f za!N`}iI~V9_MP!)t48*QI4E`K=)`lZJN62DO^ZdXh|re%xsJsp{By~@hiq=Mvym2R zZ=}}F9sgN;&81cAm)iM3x)+tFx3KEp9Jr|%{jT%H>u16CHPaUh3Ma=WjB>&o%<_)onyzp{OqvoZ*)Da`OQGp zYgx+YL{$2vocF61&30(x+*`x`7$M)D8zg}9V7}3{Ain^Y?yo2>o)*C5`n}Sw>z5Mzf z*7FRijaj1VXSXrN_N`fG*{qVMmS`HOcHTtFBSuQ?*`u|;!%_uLZx%oLqB2F4o-{-d6o;P=uqRzptiHZ1a0@8TZ%XB-fdDDM`UcbCt z7H&jy@&eyBwZ5+vx&zh|!;Q2|FHIKXl%);rf<8oFJzUS@c0e0)(dmhYa|>;U{2hNA zr!@`K#l`VgxI9~n-1#>YUoX|l9*moCXiwh7m_>cf0sFN zeTUHX=eouJ4_RLx4rTwoJtZn@JtfJOR6>@LeXE2JvS+L%WZ!o~DJd0^ea*fb`_7PL zr!Zt4>x_LHW{ffB{fy`P{r%qKegEt@8uxvFmTNh$^ExlBJR8(RIW=}KjC!>%M}Ii$ zI+v4dd)R#0l{$GSQOIPxHQ&6Z8hy0$R_&rN`bRe~%1>>EKMW0%3+)kHXto@Lu&Roos-L85z6pQ@w{BmLyx3=&TnQ!Zl z4;USdS251K{I@;`kDaiw{BghKNW%h=#!VRVTkk0<0VBcrLJUohc`k;H@y$fHsl7_25@qVrJb!xZ^|j0A1(aQgbL+E$>Q3aa9+W z+SGqv0Jg%;E_ZzF^TPZLC1uQX6Tkf0{Hn~_)TknMu-a|F7*WOC#}c7>3C3`P$AZ(T;Xx# z)p)$i^T6gSqa`^%4uwq5EibdE@QaCI+L4eJ{t`w?J)i*19(aNUl7hWu8lO=NeN4t`5ibf`Us*^Cm1fS60Mqos;N&dX#oU`u<% zt;sF$AV8$Gv4>hkjUlbOS!g+{tzKAn*bt?lr$$y{2E1oKbh|eDsS}c{{=Z*;(>Oqf zI^+f**!5MxI|>z@G2mlffakKs4nU`yY|;V~w+rb6PCkvVQ!Je;vN+nYpzW6cmQUJS zUfiBgl@lYm^!;ld`=z|otIF1ba8#`k9SeE(M;I;q$E98cpmWQ}ae5TDjhVj)*v3_d z2pRRx(NK%&?8boXn>;rV0y*IgrKt3_VLl8zwEn$~pfK2P0fS=KrOS|VOW`Xn<>uD? zT?awmK0MtkHu({PY_anmy_LB#8&~3{Fh5!+R77+C`JxaAF9KQte>yP1(-xKE{!-gB zY#|sE(xvFxlkc#VO~@ImDKmRckFHbx=n2>_VwSkZqQ#`7_j!(e-|Z)d9DRSP^p42C9dC1-YQJr^6@x&4GD4xowhpHgf$ z+P-&xZ}3m_1NrHdi$=qq?JZV*=GD#@Sh(QrLASl1i-pj&$|gIattJRBxTja1CgGpO z(SH7#Vb)2iru(DGhTCyD>P@JCme~~#{W?i2Ls<%gk|TjtvY>iMq0e^|cxhdIMmjyx zi&mo^0mBMQsulv}(Ie+GOMi8X#o-*K;{*z>ny1-UzR$ILCi`enQAoqFVx=5IO^N*a zy$D{--g>2n0R)-a@S2NzQ42vaqf;R;O}09XzWXus4HsEUUdk{@G61>bNB(&8gPSt^ z!9yqLDwJ;skx0TpW(+Xa9-;e-XdUddUUUCtFkjrtCR0 zll`eekCB10iB;XtNZuFP*mNx+9tsZFeVG~1$R!k2NM#-==F?`Go z@)8>ro z+||F^7lev(wm<|e%2Deev$+YnWqx@onPmLI>OAc#YB!wrF-)p)(w&m75~_0D(Z=fF zgl&X=wl7cmGKx?o1N-d~_3r0ShaROv7<}-bkk*(W^1Gi|g_WmXH)69uIxtN#X?DJ_ zG+%t5OJ41w^=#mnq72Tl=mA(wwZ=71cFqMsXXhiK*up_`{vm05*H&kQ{hHy08>)Nd zA=v&js^-ToI6UE}z+Fa2cq^ya%yj@ujm472%J_y)29%RY-@Zke>YaW4DE{Z#$`rjXpUex;O*u3trjsWzQPOO1Q6{1S?T^wFT0AYfk?I5i$O zekDQ2-376v>7{a9e_20x;KG?T~L4S!mW;3y>_5~8!M4rtZOB^nAHH~ah$e4J3e#)3rE=~iWi9=WWj9n=QwmJ}l}@egy%)_a6#>{|n{kfQ%5g>&kh zFt2yYT40N=vfH=Rq8uKn#F2&oC>tF*>9hsMac=rjk&?i_wcvEo-Q$c3)9ZmAuJxRS z?h*&t`@$}rH6*x2#u@xnGS=pRd^&!itH53zCxk5;F^w;mVI8o2>N@P;|JnX$ zbVJcGtO6GQ*8Rb`Y*FK^l^UDk#GR>12Mtis+B-_h)JqSjTf=L}3uOO-YTtm+{R`Y& zJ4R@B9x&gZ)q5690K$Z!KmmTz3fs>m<@dxLE!^#eoo7P9)8B6P`XXv!{U!9T=|qYd zC`itK02fdn=J+2l1xP}*{eqbAX9epO_>RoI<3j;oCuctf;72^l-FpMybZ&iZ1yT#4 zpb7W6XBb<^uXo90d_FmDDvaWGq%+<{XQ`Q5WuLwVSC&9yBN#~7 zTX2w&_-L1f)_^xuUIPK$r;gOI7us(iCh1Q@urA5JL1&jNPJlxu@S1%JDAv?_FK2!D zr`_}!>&~_BQ+qiIw~jhw8skrndl?QE<%i_lgxq@dpNPSvp99Y`S$6ZHEI2|B7H{Zp zBvn?%4tE~}JzMS`bzt+ph8`ppjCkoNZ5UmET)Ymvn#t-1?HRX?TCUk}vGf^$ zh$VNa@6df~gk6V|$#?E%_0sc+DyeDp`j2KOs;4hjTtdW)ND=!$jg_p?BwQ?6dB6Md zKac?x$q3n1WTtVoi&+#}(Bz4vImFbyU)N@GAOR**0Y2^)__#7R{?iu&{`;(J@uzn> zg-!UOy0ma1>bS_0JXx>j$Ykd`UBoMQjQpaa-3-*^1#hIq=xC~Mhi3hi8w`QzSdSw& zjTg~HWX|J*Zll0|l=`5i2ZbWf1xNb2sFibf-XSy;Nw!~_nN8h4x zuAj%;&lFIxC526s$KO+sy;Wc6v0oYkmaA?%N=-bH9~Y}u(|GxJ!`o{}p(7LPgWfTa zZ#z_bGSPFm*>WF!_pocC22P3vyn7sg!n#IBB_{Zc=mL#1KzRlfNg7H)A&Hhti<1hg- z6L1Q9t2DSr4Y?WJ?OjE@MF2qI`gDaBTa5z}%dkC7ThRZJS0t%uVl6VQg zTz9S13ZDQjfN@SGzriiIGQ$dAfi_jlr`z^e&x+$KHGmi!Vc?S9AAAT6_IMQuxhMqI zpvFwD-ii*B{YiI%;`1z;jzb74iVx1bzaxAT$$nkGetV96^CnO#ro1||d{@hHvRt2h z*kG!v+U0xYC}52`C8FtjN&{}8w)o|vcNtfZh7~up>znOu#GIZfbl5L{I{U3cFpl3y zhvd8hvu#fg(NT^9kMETU4(M?VB>2*?G<*le9NL=y>)|ci46$}oJe~y2g24f6k)V}f zTMg0?@09#Ppnl1PY~#&(L-Rm6qaZjc9%C^btDCE}T63dkcZA4Q0K>EC%M`?Tt&OL6 z5+gG^?%4$5GUql~JsN!KAFUv?@YLqtfeR4dyljDPTNH z4yaG*)xDrr60`e$Q~L{hJ=Fp&vp}?A+kt15=LD|ElZaEX$80nem{!!&f#ThF7rxGa zQD?4JS=!`IO&yX7xZ$G?v7pTefT_d#s;HNyr#GQMZ&<%j*^>ekTlGX6Bn)Qj>2+1WNPZ^;R2*bH=-B_E*o&vGcZ0#-2BXt=4r$L`;46C%@DMuQZnSVb)F z6N30e)d66>-E-(P9oxKUqHK3pr@-%1C4q`h9zBj=gK)lanLZ0@iMxGF3bu2@n|lKY znUXQ_atBs9*?_$FDF2$1Cx!ZAaQ$TY!L-7Wm-Z9ioj97vBZd99q)>i)OR<80`RGd* zL@5fkJfuFZB0w-8l6*5~{={zoonAFbED7YJW+;uM5;$*AA?(i`Lq|gZM32`vX6L{dV7ylQX(dhhNtN zVa{v$ceB+Or)|sXb%?Hm8+?P!TsP*&&F{5fuk-TSkA)$jM7*El6b}A^k#i6fB4fVB zUw3vE4han@eEH}sve;C2ZxyMXi*sZ~<~?|$uwPSpE!n$t49l`Yh%+ArkfKJFg5O%L znctouNp{|lBtj5~5oY02O_cHvtk(U09q0{RVT6xrg9XU(KEk_Jd%Ck6=HznucPcT1 z0Z@&=m_r60ibR~eQT}as#%;3?sXNs)wXAvth zAK+`X0zHGCuu)BLD|l5|6p=`Kvcal>VEOprUHfo~r(X}GSg7@IfcHq_RjtO=l2Dji z2M=G6e)S#L&FS@})@&6F*sDs%xIuF@(?)P94fkLp>`ezFM1I!u>Ba}Rkty%VoP)iU zXV1iTKDkUk0EyY&?g#C}!*!-=Hp~m`h~tXrj1cKgP|iuJla)58BX-9tBk(xX-IN^d zw+97Jo0AziY1Ok_bEOiQ13KmSjKPF=sDV-(;$Z+}A| z$?``gl$6xf9~|U+3ng#riQy9W^dhb#jRA7_jilCrL^D|5;7lVjLb9Bc%IG; zL{S<+_SCNO-0f+CNa1)6DOTp3evvMajS zV5lZ5l${(IHK4|qn_cO{CrX+#*))@9q1t|(p=0s0oomzmS`YULj zmQwU2^I6RPjOsQwST}r~vCuDs8fB};=#^zC0l2{cs9z1?OdFy>IV=;Vmr2vl&#L)Q zGEGak30HlIbfgl#2WmEcmJ4)O0x8oM-(@gpk zCDbgbKzI=leq@KtD*-1DBYWnw?L>V@*t<|Z+(VO*`b7Z)K6&m3>D=5DZwoOw&g?D) z`(C^pbMSbNE2hysBG>v*+EDAu<$O`Y-m&T0=ddQ+4t8ZSJ%v#A0{@tIRJE)j3)_&D zb%Bt7_`-$Dz=&UGbxz4dy{7i^3>m?r5@Fkas5G|WHt>C7aWm-7ZwY!ug}!~U)#~VI zJ;{Y3Ii}6|hn?_(l-{|W6Dzx^Eu`jOrNDE5xs7^ZeSkdkO2_%cG z0Q}xZAQ;OX%)rLXl2#=gDF^D+@F{P4_E1in!E*#7OznSzPhk2T;X_?Rk2wB?kx4G{nh$k>{8~x&-G&{l()T~6~c?p z%&VW+_K_C-kp+=G63K?z;GazgbMB)KL!DoQY5eOz6twtE!g=-uiyj~?I8azJ1EA`C z_;2nwd4KA3cH&#NrezQ+tc)}uat0DXJxQa<-;R{_$#X&w1{CAJND2@>SK5bFzWiQ^ ztNX;FqanTAG6&D-)`(Mktodibx!gRibn}axevU`J!zw6b?&1oCZMTz`3(Sh`Mh?I! zk;Bg2k~`S_V8S#L?fi9kPA>nYXoozF62EgVFCeL9c$RnPH$iA1qUlL3d{ zWR~NEw{@|AS!4Xo2%;Y9$>qYRI+IM{9>Ub%fuS(x4TOJrbijC-r}-!64|?e;BXhzP z=%rm|-ECRPwba7tCZ&p-(59Eooc>Ek4)9Sv6e-UP*wTF6I@wEUko>VE9o3w#{I_r$ z5hIye5uIhzAlI8$V9Pwc*>K?g^YayCLBV4mpXP(tduK3MiynoE-T47g_ad$UjHBJu zHD?r*hMKxyNMExHj1$y(d$6HU{KaG280A%L{L z+WvWZ>mw%4iIRK%Q$DMvV>xBEex{biru9!r#A%;BjN9RJTax`?*y$|G9$`%h%PLyA z>!_Kcc8XtHM}zQixJY$atN{!i8aB=}8(vFm)-TJ5!$po9HJPo$H#38drc$w*@<%!q z67h36uYKmm;-W!}U`Y}Xmd!K<-NSMIfP|4e@Kypv6zOO*r`S9~UG5HY6B!;3Hz|Ag z<^Wx27_lKWa;FNw8XK+u%Ppb(%umX`;=SlM6q*Lh??{8)nJ~iFFoC*=^-*5Al^SN+ z+^(q7^K+%c2M>pYEEBX%&AT|gI_HtWM8t?KhzQ1@^v4N-U&cjI!@GCg*NZKQ;?U|> z)pnx=kyRU@XkVX>x?em|%7@_yIGK&!eEeMBeVV3b8~fS3DqwMieO0E~KGTLXsFRwx z)pQ|H%E1H)FlT_NaY>CR;C{nK<(sM#Z z=)(<^1e3({L3hYH4tmrP^v1RG|5YfP^IZ&4!Aq=43K+MZr2vI2p1lhlfm+}(gBWLigu z!DDj3t?XoX(uB6@p2|L`!Py|{UaIaP^6}Zsr!nf}Kp_sJ>tcTL6EL!FmD>%$ z1PMhTiwcCsg(I(1(j72IaZp&{i9sRSuyG^cZ5GpdrRzJJ2@$AYsvyVxe6*fng{3Zh`4p^NgE05c()hMAfhe&jZ- zs=#@)i8B*D{ck}SaS7-M=mBWb3m+u7c&&#YBz2Ae9vP{p3T0eP3#uu6&=h<}j;VKh zXYZR9D-m7>CKRU1oD%4#MRNhR6a(wspXsCwmlr4+YSrho=ngPv?YFB%*;ltgPo5jX zY3veT2)mygS{uQ{ft-N71V4PQuX1zNCzT#D_M^u=%!6-2y8jD8P|!BHw@wHTM|mFI zup_c<)PU2sBX%#>f;4{84fxtO<9DGU%N=~?%VTk7NRahBjsgq@BpJt@NW#`g2_LeW z7})J3R^nJkfv9@nf#=3akaa0^9DqB{t2J8OD{N@}z7tRu*FaOVb$@D{B@Dyp2oFq* z;TRNkL-~xmF9ZNCFQ?BTE5qe`y9L5`m*-;I5TtDzF=v!1h|{f|^Tqd8{s?wR=TrmA zl-T5rXRZb!LB1l?kdOz@>Cg$Z#Skn*WMb0|0!H@ocHu`|v6Vi2c`Owb)jh|R{le2& zjMw9y&^kjAE}hxANG#d;N3?T=M&CRJllxpzD5)E>fYO=!qu#^HH;Ayzt{PCyca^Hg z110MvZ?n-%rs=pUAt8A)63uk+x{TLi5pPDB9{Epz+;z$6=*__1GNG$2<`Ils*0vlQ zQLNWw!jo&-P^%IvOJ(y?BTS8pXcOqf<{{y)$*8%b(18Hx5%cE?FhTU2esydD+<*S) zPkNw#!DDOdJm~0fMW(W+DXk5mYOJiDkRJ}eqfoHhci`;i7IrfTt5}^xoc^n8r50BYphV>jQu6fG z;()C=7FNTRd^#P^3+zDofVDs@g~ElXrMSw|h&S z5REs_FYlt)RF*Md_&`*e(w#X1cI30=n|Ad$o1R}s?&=8n*pXSy1nzQ6D4R@?X`DL` zwCtgjQmkihdrEkkWP)YNSSETPB?9RW#`??wGc}CiYK~i1x~V!P?L9mvg~)qOQpX}X z%svbmZwAGO7P!~E97~fDmp7HJ@`iz03_$2(Tf?YK1mjPFGTCn$>@A;QHH_bhzklgi z?zwEiq`CZ;GqN|E?&!!hcz2DdSii5_*1*%Fvp=;qZf1Y7{$FU?S|dZK_(LimA5o0n z{jt{9qd+6+%3B>8ppEWerq~c!rAsXG6fl4zDO8EE2oPK?8L7S$DXDhbGnX0xF=L@F zG1=Ti>QjT&`_6EeX~v18sYpvx?9EZBBJ!7{8uYW#-wW*)3P%CSFN94J(~7LHIetg^ z9VO$<&;DFHSQ)xA)@(|e#juW74BS!S={1ga4mE3h^2h8$Y|2M1hmdF*kZ-TY4 zLh^_W|NZHNlu(LUO{+)IGudb$rpHfncKTt_*xJfRl}NFsCMKULe`jb~?sRCqCwP2Yjnkon;Jmv^aXvedcMu)5@eU zwJ7t)LLgxPsAq0PaKqeKE3sN*>kr9iFdEWsYw`3vm}Qk4C5>CkoFIwU_^2u+G0Y$& z^JT&AXu4DtKq&pt620_B=|ovM>#dX;E93t458nR8rZo?2O5$ybHG0te2GJ?E0fW9v z_qdQr0nwcVzsKw0->?@lamZ(|s5B*1nSe|JhTmfWjK_ho4us{@{s#it@YrJlnoI>o zu=ih&x%>BXFF9@Sm)ZNuMY-jLdiI*(A~Oy1AXnQ&P^Nw)cevnggx$BCN^I-i7++N82wLm&wGmz^*c(+xPSU3AEZ5 z6@n1#s-DbOlo^t-D~8_Fefsn}nC){zwE@32)Vy?AciyaTl3EHewhqb{sYLhM45jP> zeMj-0nr}8)qOR2w=`Q@b2K@b@Od!nq*c!HMF&&1-{n+R{yBx4V{Q0^&=G%{lrluhs zY?qkzect+3WBa|g;x8r*eEKoMewz^T(ioU-PS^o;dwYjXG0~y7f#2xvH4KTVHzvbo z0ZwB>m+!LONgzuE?nr=PU;|Jv$b6`j+uPJGXlJw0JRaE@E#53t#UT)4(CMWc;gsUJ zIpzHd0GBsZgG!*8@Z5l0;s$GUQ$&=8@R7;ti%M&~ysOlw7vW45VVA0`*?DDxMx02|Tbe2;T$f;2k7+#F1=m>@?Q+ak&gk%Nf32 zpj}O;=Rm@s0-AoKg?kAaiN+yVDjJhR*Xo3d?9;N&jFYt&?!-p08q}9BT1rp#2&-~T zOgNo}c*VPn1-><=5%4Ns{Xj^Q>>F9W3FB$n3M(vhk;FN&FQj;9|6-u5n*Ul_5Uq`f za9K*t4;yne=f)&F@wAE>v;X2Vxy1%sK+_$(DCW)3s6W-PaCd!uEC^)P{dLn*ddo?B zsQ;ElB=AjTx!uu1p0-MX2#3d?;zpW0?tI7h9Nk!A<579F&DG<%v~^x}Pymj|bV`va zaLZnM(7ZCqn=*bii6yHk7RYMb=?xG`bm{MYP9oN5D_xp>DQ4lq(0IH@6^o{cNkGZ! z`gYrZXoYG1p~9CZX7pb8RM=Ro{b7CC6t^UHQjF^v^mRDJ;M;X(QE+DifOxe0sFBej_n0EJ4Z-5qqF zMr#HrX3@%(UkXYPQ^|$LkKkLM<0&=Icrwq(4ZfqVmD|Pag>4{VCd7kK?ZQ77_T~zm z(XVo^iDh?&6W~-{U5l{-`~3Ygd8;#W6R`T!SvR+jrXIm7@ePaAVSU(9N<#fhuFiaaFU@fRi`-n@Jk-h^NbcIJR%USEk_tkvjX9ux0{CW8-g!dIgz!+tQyTBr z8;|(ihe--mWL>uHmW567!TeRCBjey{x(756t;MsH+Jp%uO#-Zbm$1aQ?nMCM&5|dt ztQIZybByP!)Fhv1W)!TyEZZO_obQGz$`%VM9zqvSlviDr-z`TeLVvV(pdU{lzN(3R z3s$o+CUs-AmNBddYmLmiAb!5*{EKM}pYpIO-N-$sNJSt=JK)2HP+nn}M1g^4$Ai0^-~ z2hIKT>o6i)&F|6h;FN>(e(IZrmZuq(Mr*V&ic9Xy8^5PRokSKV`hYKr!))WR!9Xy9&N=TpT`27cQtTWrWeY9$((&SY^3W&7l= z!Eo7zUy_CfJ#a>uO&m!!>YC(L7ICPjQC|&xc);KN$z|L6gMzaM_{?uNR8d0DvIY8VXg59JA>o z4co{UNAhUe4%Y$dLtBXZacLC|?t!gz+U!sa!nGo&aXUO0jJM4cD@CNe@h?m(FxtAu zzVI0BAha+5?PaKxq6k0|_$Zi<15})3N z?!4{aA5scrc|%epE1J-cXlp-zK>DL=8t+zAlI$x4=s!mnB}QTqg(Unp zyBxX%mu01ClDAN7_h(VzQ^Uf-swMo2hS*`fsjUcv?|6?v(cq8vz)P8Z@;#09GxG}< zBJdMIn+UG$gp|zmurPH!6CIsR+|zD)ZG|5M8cCa8Ry7UP?PZiPv_Q1K?kU@j1m~7d zXj?k@5U={>ig&XYxp`j^2nnHJOjgals%k~pd_ya%MQ#p5W2Nlv(5gFWS?d!BbMv5@ zmfxf0O70x~yXP6?L62W4rOD{;X>bIQf$wMVRz9?Q}jk!tt*x`twjsLgdDJr>L)<2Z51~d?9UPo5eiOK(Gnk@d@6z;qO4a zkhLFs^HS(|KR9lKq+V>ZKc4f8)aHv~)6p$zgV7RW_^NZAZW9ehc0s|4AD%9z_uOe^ zNfe~3tIwm|DrmdG5oXpLF8TbOQ!@xX%qyRTG~n~<>!JQ(VPZj`hyhN*@aERMCs?*S zha!ih?z4ddqvUgK1dy~SHe~eYz6i~jd@g%as?G>ZM&7ItZZ=Q~*$xf(+0}NDt*0E+ zr`}xv1f)`?VBh%ufoO4Eh1B$nj2BwOux%D1XN~>GN+RzCI=b(FU-GT$X<^%z)AF|P zC*p!??S5EI|7zA46jIeV7 zze(Q9_mUz}Lp1e-gP^6%1oz57#nb`u(9DNga^&(gSn{9Ni3UlX#}^H~MdS6zg2e zWhvBsRn?Dvr1solprodp26WNPBIJGGPEE5=LG!Y18~?b;WW}S7=^Rh{HYV^EF<$HZ z4o~HbYaAsinRfG&6p%<{B5{o6eKVL*#GpXwBKzj zUrfa@$C)k=8(^D$wgYMvg>+wU@%ewwt=b~qfEw_2B=`_+Oe-S;ZLyPAkvDBKH;2Vd z-O4??MK)zI@aFC6w2stEVs5QpKZ83QH zsW{VsH<;~Tea4k`eFM!M*89zYB3hq-wENiS{QCW1cPg*`w;CTgXcM>@!(Eyq!Ewyb zMg`_1l{6@W)^gdIW=j9~cCF=yGh(ks?^{5vCr4SD2EAG0|)KZWY&oQboS^0H^fIhxGTza&jq5c?m6Mr7A>3`AvuPxbu?Gi4DD*CeynED*GWJ% zi7a~R8yfnL1Eqla!zj8Y;^twq^>zQ!b(7mtxW^xhQ7WQviV&}y9arjPnD0a%PuV; zU#M^ns-v@puTn2rM!~02_yl0V&))*IK^>;t?#FF=dIUAc5w-= zofuGlZw0(z2<|!Fq8Ycz^zK6?x4dZu##hBgMM-J7Qde_FuEe4_L7&|q4hwh0`E9ZG1ZLGelBa1H`x z>w1p8ZY(7xY04;$v=}gy+Sc8BF7&;vgE?Z;mkMp4n2GEJ>R2;YryGV&p z9Ni{T0wq?dk|v(zNb%o){x&9dWTf`( z5I6JDD=(`z=aX(*rL5QnimYE?zO*5}=7xON)A$9Jlx2EJ6QNi7J9l+=mX~#-ief1? zT?5Tj{(g!9cZ^}SG34+|vhz}&uWDF$_=plF#d67iCX!4j`DNO%B8GT1&RZe74m2!G zpJ8NA&x6s>f#a+># z>Df**OU zYm7Hq6{eFbgb^bjLD$Y~`at)>1jDHKk`$>JCl|#Bv=Yv!rk^W{XYL(k%z<3} z=MhvSs84K^edgAwl(hRb8!b%_s16P|4RBTNvHiO>hhgx~3C_KyG9+8)OE0k3~*v_)`k8;LL35kM~aQPQUa*U2`b5{uU<9^A3 zHc-V~non@2PwFracmw1_?5{Y*f!3T6?edXady61vNpmBkd@)23vgOEAUeflD>3Ch| z+KNS)1u&r=pOb4oAmA6O?8Y9Z$XJOTBm>gs#zC+7_ZDcMUVBhy;nRS4wO6`5mx=rwSXA3k*RPb(Q8!i_M# zlT(v;ykRF=Nc;J-rJZs=c_V}mURXbF>o@+13c!*M?m4L?jRQHW-NSDY$NpgEO(5C_yT$^i>z6bB zgho5%;8(4g1iR3VWm3epnw$l+JcjtJN=8+ zXl(Ix{+)X7)j9tsWzH__I#7H}xbH*hLwPMjC8ZEblJvahU+V=$(VmF`QTI_lv3icXe35pn-2r9ND6YWa zk#!k8Bkla*;ftQDiG@5&3Qxegp756kRtmayxrqH0=+=L9GT8UsyGJOOK$TXZfq5_1 zW%&vH>Z#ta#2k|9;P<5LB}qm6=^=UT=d(_VDE$jUSaF2LsIlB`Uz1W zT|ZIJ5S7J2Edz^CbzuA4eePi=y&~OgBefcCLx1|0hCGStpjU&&p!u>D=EQ|Wr?_2HMK zy}uU*E+4$7zw$j@k;YeMCr8!obb2R^%NlOEKyEO||G}HhJ0CwMN9etLpZ*3I?@~A9 zmAa{BmaU@`fLRZLJQDx+(98hllR6>cWVQuHNKvK@)kz4GYlg*siaId2IfF(VST}2O zifNJ<6*TQfizU|Nws+JU84P18eVs~agG z96BM`#r*CXTjwm1`|abMon;pPk^ALXt|2k5g*pQ`l0ICyiQ$Mn-k%Q?g=6 zd~NqX75sLM{h4x1rb2N}jq6T`)(o%=noY^2jT`>zRfwWqnSbQO$BMeI4CpTp#YD}Sw$$M47iSq; zmwjKK`2mD}^iuHl^WhU)>aPXzJ%KF7S;&tEwUkb(Gw+@@Mx1F+JO{KO{=6dA?0Yb9 z+0tldaR}&4~p=3t&?I^|*`70z7hk`1q)*2e(U4s0DsYv{H)# zLDgf=?v?L=1Uu3|Bm`Z-qzo!Y;Yvgse!Lgxi%X7qUv(leH^*+4r9xk)+;I8GEUn46 zwUFsG(+^*W8}r7~%)p@8qn+WuGJ1W=j3iPT_(Z zK@&Te4wEtU?$e(RFMthJ!-Mr+QPrmC9C_sTq%lkZBX;!Gw?-XGHgmC~nxUwhsERpX z?#V@1d$Q6TFHyM*19*Yw@Bgz?Qs8Aoe7PQ{XvRg!um_+7)6^Q`lFW52*Gz7&qi)`) ziMyV1XGagVh3+{RMQ|atdJNSH&aSJZ$v9w{+VnI-D`(#(DwK8UcoZ!Z6tLEDXjb=-;K?cdy}&|& zSBXofm29!ppKi$#TUfa5X2QR;pIa!&1dxvpKNU{s-|ZwX*>!s)dD0NngT z`Lfq%DD+j_bIfsK0D-K5fm-?`T=_r^s>pV|%Bg5wmJSZc)1!#9cr@!}&NqABtPd=?lL68+}$y5B0Y zhADJ%qrNTdKomn2LJ-JIkaO_iZVg)whXm%v^#1|@E|p}^1-3O+o1RTdYL6~ zU(R2Iq{iNR1@hs=Ba3iN8lkxL_;TUL;I`*XN{x&Fjt?f>9UO|DEK11jYtndG zNSb{z#pGlGdg9{q-3?R#4&yV<=Jij%O8Gck0c@Tu*u0N!6*B&uWD^tX=Qm2ng{#cS z^*lO|7J3ktFy4D{5&bDFOvi~4FP^t;{}I2p8I|N{%6vo?6Vwff0!{yj(QbrfWuQ^U)ey?0}mQ?V$iWhHH7GbIw4us#G&%Jvol@g+QVGyy{^%{uuC7<^Z7qMl!1NGg3qP0RZu7?5(>OyfOcB)@1LTWM z2k48IuVfGE)dsT&V{+wSJYbi9t$VG`L*c}a09+8SI?`w{0eJevhi{tqiiCGIGGLSy zlr(jM)&6AbkC60@*NOTjSajy!M^XS0fAlRa{}Hs@!JG5e=NGZXO3DT6t<8a~L? z-)on^!3|BVt(8oX+PSAiY}#w6tbSLA;pwV8eApH(ZaKj2_*^U!z8&n%`i4Gc*=54$vx{Mrs~)#Tl0|I%?)Gc1$z`E_!^~pMEE^Yp(3GiuEawN0y znI*^WMX%NHY=WOZNmC0o^M>Tv74kXpv_WW> z>u#&#A*=T?M;?~)rnn^cUx6K*2!D8sC%&U~(zl1AeU6DWRhT2rcB!9sN#w?)`Irc+U4g$ll3b zd+oW#9OGTPE`^_#Q1ZI_dfoXWXQKZ{8~$t$t{>7T4J7F2-nqGU9AR!|PPnZlUV=im*3(G4;`J2U24KhVs5;muCH#ru_-?p{U!;;7ogN_Wf?+%i0F1!;MeKp+J@;a9s~NMLF2c3#C1g%t?GNW_r%M8Qjmda3 zz)WlFG57ivdu?vQoYpaeJ(mE~#__e*q(BvKDrvs?z3~7k_wWr5V*|&qg|5pgX%f5{ z^wcl4VkQ}*?7yVR#Z`GntoEGX>&w#D@ZTC{29@DnT4su-(_@yoYNr6q3ip=yCt{+{V2dxt6J^G8@cX0}ny&ebBn@___*acY z@8fv0i$8(B3}Jf}4zz+EvQqXV6T^6RsY>pow7L>ZeDt&|Lo*udG zfr29SSuX=eLXyL}1{KtmqT4_BJM=Kwcb}hH+41}-d>s!5=X-K0lBc6($f?y~@i~Hf zs5;*I8p^qn<)nYFS?37uQrx-kk|cZh$LdS=hxdVgC?C68=!_*^a2l+wpK)d2fFaz? zMgQY1*8{r3$|D&rz1}iA;hfj6j<{AV_xQ5U8fq?GFV+sskF z^4)|(DVnDv!b;UPdqIR@A3tNfQ{k z?rfKrp*t%}D#vZJHJnRb-QIVn8`7`L4?TI!b4hGm8k25m{!^Mgi=Usrcsw+Dd2mCv zRV+Yh`0~qzGcW6}ee@W<_-OB5^@kCL0MhIdlTd-WshgWu#ouS;>Y}+E)SD;oQ7DHz zOw28zzQRHW2T%_Wg!&|wnFtHHK$EQRu#y}gA30-Lp;sCd!y3E}rm&zS06AWzpePtp z5E7#K98;5ag5_$>7FX$;ig4d8d44+Zrh8Ti{d*Z zl=(sa&+8lW5CtSi6ea#Y0MuYynn7 zICl8_dy%W67*a?{=LCH~zFKG=B1qRu3_w{Gx%YQfsVGVLRrQ}=(ZH`@c>G;hG6?>= zzwoaCPId9*^>b%p^I5M@DV};*Y`Goh2rPzP{)E0ia(~W-*ipB#j0jiIhGVH?sYuE(;xpyfGIO-q@ zwRH6&LVU42?71IlLVZBKC6q6PGgGiv27x7^MkpZDzdw6LsoSVN0672};!yN~JK%Di z9A#)CD4l-|B1+BajS_~CIy5N%9=J~GKVE43=Oc2OQXH>;UkEEA7}N5Ut4kRGnv|!KInKFnVEk=)@3&?-a}dhKN4E7qHspo3Y_AcnCJnQaG4!|=6fFxkGBu>p{L%gj>SB@hnN zNSoh_<%P7Fm&BR!2y`mDdcF5Ud-=?{lNZ3Q!7q_s^khcfYq5Ui7S@_7vQC`D07s zhW!^7&CQ!>$Icpa#(cN&P?Nj_azB&z3?Gx*7ggwP?*zA(vDqPp_BTJaqN&fmfN#@l zi2MxBPlW?R4Xb%3uO9m$|Jg94Gdkmny7U^U8`q9k?Igg~0!~X(ZSL3{vvipS|EtLX zzmMLnrWJ)=xpyE__8_Lx9KMF@W_0eqW~={5HM92_&1w3i+V7k(%x_O5Zrd&`P!o0^YL~3PWmmOM=&C_C*-AY-TEHDI zK<=^$tWX5+!iAh89;{Q+7`){+@X1fnlwNmHd&G8U4ePTo(Mu<(UTgOK_(WO*pMaS0 z-ok6JWp|FGVQ|!{EPA ziY6RGoKd7w=it`T+T1ww&2({T!J_-FI)}SulU}7?)OS%X5s!+Vot@{7D@2zCoZ%z( z+bLq@<5pL*p)Pd1a395aO{vaXW*6bmX!Xkgl2hWBB(F!}nEsg}r>pTtkfK_}uK22_ z!yBESG@eS&2j>m0DVOxbNH0&6ayIvstE_Lb$ZxWGe7agg+<4+}V&pYrXkP7X^-%D- z!T|8`x*bIqwlqrKTBf&_a#iuz&slww&Qp2g+Bp`Lpjg2C7{11R#ERwFRrO}GYk6o5 zqN8=nV(4^zxPk#j(_0IM;W53vm*4@y@lf1p_|3Jk7Q^kd=A_!wYIrZr-j_84XJlSh z4A*rJM4p!`@rh5HU}V~Wedp7R*lRTv={Zi*i6tNv$-x$riC$a}x~rU^U*Hy#F2ti= znd6)Gg?KAH{M*?$ws1I)o+B~Szh9b&+G#wu8ng=DZ9ha}Zy=|X~+D}65QCwW|V^RRCYdVhP|vuedUAeC(`LzQ4~Vow~aTi58uNV6f$ z)LjmkM(^GH-s2?g-&FCyvNmw`=8%G@3iUw2!wfS&(0H6pBGXGsE_V>;+BJ*PYU@pN zQCGZ9k5*HvrbDc5P3NfOcU0j zc0m^V1sAB7+cz;8&^*8YQaP=%cO6Qg7m<;A1_s9p@E=l)z?+dMzaXn5tdL{)hOMR` zx6i13zTGPSkl(`$39^JhDfqi1`n7Rn0vRi7Vi zQXnmNQu)%c#6drsH1SyNf#r7On2soE;L1Jk?3F45=}DLA5XN@~nwyiBAUs~CSMM<_ z^SIi&I^65AUH7??_>nAHqJs(zLWBwWH2)lAHC3$bfYWJZ?KRtbZi{B%nycwkbGgFw zlds8lCRzMfCwgHe&e3uIA|l9I$i!Z}UA;ULZ(Q54N%p^j7x$UV$a@@S+pi$w@QNY3 zOl!u8X3D~M)=Yrp^2$S5xg5$xYSJe49^$y0(1{+ks_}B53u%}ryCs$xG#u1feI*w0 zcI;h`{|?uIc>n&iSmCFF2Sxj#dQ@`;aS`KFt3R|P5Z8?*~O*ec`~-FB6@Ej zmR>N^J8{UlEDt-OC6(9`%<@Q)D>k&h^wv;XC|lwjn)v;3FIkW?w#?L31wuF{HXHZt z@Z5m&@)^r=C;dLwGwnXJVX}C$X3vM4?}CHAnFq`Z)Mu@F9azYTGQKM?m+f>T!TI>J z33NX0S-O|P*4Mhns7subK4y>4Qbmm3`?9XiT4KSi&mvPCoHtWX%`Dc)+!;_1G)d_v z$d?to`KlxwVY!BT(VCglGrK*t%jpQSk}xK7N)r7wQRh~o)QE<}8V>v1r}#-P?tyPU zH-S;GrxzzkGv$U7{wc^L+}{;pdxwoZIyy^4y7099sfrB82bE>Nh7~nQQ-}9wQ!${S z%;{pha#9j*^3mbRD7svCzpCh-qam;3`>JZBMV}Ch9m&2y>!2o!!`MV8H!T;F-S4~) zpNY1&Qhs)7rBcVCy}1vc6Sa!jyQVuNTAA9RQ{yrkYKo^qNdG*I-*NAfqx0df65@}w z#T$jx#!j71Onfnk4g~wb{IKp#D`gbteb(TY)M3Y!Z=W?OY%KUdN_Oj{E0CBweU8W2 z&bDl&7`)I|prY7+=J8oX>a1IgK`dh0z}wWJFOay$Id+`SD*;2U_4_uzZ>=-+)MZDQ zOp{g{iY7C%viL_@sbBAghvAz6F1j0U-s#GezAs?9ZljmplhgnPiR7j@M=LQD=Uq4n zORb5Z4NX#?jE|s{xH0c}2YF6tHuPH2poUgR~v;yxm&YQ_N=%U*9g(- z>M^^Arve9uWjm8fJteVr+RtlWVcUxFJ2+X9qpt7A5@qG3-`+Ro{={mD>C;b-y0qdr zUsI7uTHJx!(TogGzo|9nyF{-(wRsc1bJ1mopJ!NP-?ZW8y)&@CylgK&BD$}7Y(Krw z9P2o&eyzP@WH5DYa=UEN3^Sn1-Ysx#y1B-2qS>Onk8)J6&Y(vP@MUwu9Ik*p4!f{Dv)H^I?0#f9W9wRB+BjI=-pQ7b zcsr=Zs&XMlHFwiH&LYsz&ZRl%0X7mdAC zTt@S~flAw7sOR>Agk46Fu;;+>hCCY*p_ya8}TGrNM9J8Q`XqWP)#(p&l-9wq6CiE%fr#0re( zQP!s(P=Bd^#WTt`n?@^>C=~TEB+}Z~Z9lzm3~ZfH2$@4+Z=0n!E{R zm;5x)znsK62UJ}p`Q5)+zJw%(>w~_n*T&Z#?omFuG=Dx!~)8b7F!5 z+{0<$Cu!2_;;pEGvZqoXhJ{t4M5k=|3d7Rzu%%%qlmcB@ltR)i@jZuC~V4hj>OzApw(g zb4$*`fOibVaQw$LYM#uD4B_I#<%N&z_n!OGi~GoY9mPXKq+CU~7arkjd46`2Zhsja z8Rju%XnHFjZrr;bay^f5q4#}E*X%xRH$rso#$btrIz-KXcI9g1dEsg%h1%kd+igi) zZSi0e23)1(p_uOz-Yl%CLBms=Tc5hTNoLN5a=tqh$0#WW_6<|PMbo0f5W+#Bv=;2$ z0b(tU*-nDwvjK&M!gHqhV198UCfCp-W`wZWnHh&L>=IL}-ua;_k87r;xnd~DNEs}V z%v#}Ce}#dNKVrcoSL~jPeL;ch%>&+XM1`%`V*=|RI~NACd!odhV~T|o9)6}02CN}0 zl@1`wD|4F3y9_<(;;!vW+Jx_z+D>b2S;xLq?fKgQWP@+$gv*SIYk%6eVD|?V*%qW$5^vjk^5KJ>u(fHwo1@*+@Y-II36L(GH83zSe@J3@vO>Wd$a1y zwrAo#&xNJ_5-?878kb%T zT^(MZDv1H`Y2qJ=ND^7wGv4#&_*BBqQ#PhYDDck zfqY8Eo$!UAd<(6GEp&7awGpVI9eT880&CKZOy3*En0c3EWoMHXoMSuEDoqElLv#D6 zb{?esT?nG@_!c_;(~>Q?qL(8&uEi(V-|4ZkBH=ieCa}WR(OYo*R_!T6|Ee7{N|X?MsgmyZ=$ye}oEA{m> zAFSS1QOYdXSu68HXV2do zV?IT`4zBN8pa8=;r_E7_z7O>P?-`pd<}f^(@#|HG?c52jmr2o+jRhm#wWS78mj}J<4_!?e}%)>rGE`B0dV6ALwUw0{tbNipABi_L+MVuI~lzD4&rZ9 z&UV~J734nLhd(F@%P60%X?zJ7%VFumbD2wvEv?ka*yQ>NCa%$PUHbK~pX_hq%XI1r zx%A{oB@Z*f_jDJ;OH0iOlrPQa&4*WW_Kw11lSZOlXZ5)DY}GED&k5+s!)Pj5BWz-K}3X-v80Lzfx1gmRaR9#04&XCb`sjRlVDq)?CxrK?91l zeKCY7j5A@&xS_JvP9m&5Gpm23K!N}PH*%cs7of;rT)^I?dh;gL!2exo@VjGj@1loN zKb3|lShy!dMO`DL3zlWuw)aGq=(M+X#}n=>`frrBadlb$%oWVI z?0}C`D5;k4sPtUqJHKq^@!4khGP+i8&6?pcHKM$?pW@Owkp|n|A!&pSq;Dx0qtV{J zCpH@(L^~5$DO)cIgI;-yt2Py)b(w@$Iz>%9$t@GEXkrp4 zp>Ov2({V@0?(jYE1Yh2lM5)HXLd5DOnk7#0I#Euc^7pFm0e=y^U)JVgW%rxM@Fdaw z>yhHh`JAe1CiKkpi`u!pdxrcW6cI<5#>Yt!Mf^$ge)@W%f=@9I-~2q}zcTNK{3GE5 zwfS?MOq#cT39QWYn?)Ae%!)V1I?JJhvm&Pqnx>hr;uZB zrX4Zwm;o4Sk-C(k4qN4p(PXxs;@kc}4uDAsiAIr)x|A|BZjw7vaWR-R{8R;97B^5=nT1-df(_7#JsRq7}oV@Ik6tJS&E6t#A;TX9&WJ63E8>G`+;75Nx@$vFvSWemA=!Xn~UOa$9b5+tPMAu z8d&j>wh2em-^L2pE$-sy8y37aZ2ljH5INWpQFZP}PwYf0ySo}KRm zsx%tp&X86smj~k`2d4uS`l9Pc+YE7nZErqnl-%fcn7|Cc{>A&iY-S;U;#4p-(22zquZXpZXK1GlhXx# z{Zu|o^-#uGOz!nm5whR&+E_77Xu57Vk#;BhZxH7@yUuHhytc5g0V_qbNp-Rw`B$gw z{OP_-$R{Ds5me~Ce?~W7=_}D+X>k?3v)2p^^6bq0l*ztJMn_}jR{Dnvm3+g<-*;_% z-xXMT>d8ZRG88tjpr?G1ieVny@aV6vsghP3yA`rAi%Hvyca7b%PbiZKgpLP9&CC-$ zn{YZqKD{L5{tlCGfDZ`7z$3`NiQM&TPJ_jCmiL8qi@SIAUGT0@0((boJGjULOv)~l z4UvKZwpS!zF5kSx-X`Q;@2$op_4A0*;Jl|}&yUu#S#XE4KvhS{(uSnk&Zk-@XGz3* zRSo$NgQuD9bUmuv+z#~zkx^S#3#09AeugpdEpr~p_v?W}3D{r0xu#ADJMR3P80Nz~ z)>w5|n<^6f*`$Eh_wVFXY3OOHQuuX@PZ~JGG$zPB87}30^96Ktr9JJnh1qQ(9C`^J zE`hIv)hq%CiMV-)4|#m7uygGD-H>I{D+s}9WHBFLv>6W(bHn`V-_ceRzYz2KG}_6( z(-YkT^DrF3WZa_CNnZvRk(BH)0rRXe zZ8=>DGp~}ostx|npV#+}7F|~5GwO(xad1$+?p9%1xiBe%lxS?XvE#PQh|>Tl4i4S# zQy*)n7yEiW@7dbOZv4(Fze&&3)|wM(b*OHgr*b}Nk0`N7$ZsP)J#EIqYdA+kP*xin z9S@w)XeY?188ooEMdfYG+Aw)-r-IEvTc?>GKW=CKOUfd`*$nmowr{cERD{3-O^JO{ zR%A_TQf)pqG2efac!pc5A9fBy1t}oSJ9bYxq&fdiL#PH?y2=l~p5R?cI;GsOcFPqR z8uinaze}t1^-OQ{iMxO0Ks+wet5aP5;n{|iLP_U$zF1%!%Wak3kO`QtayL|`RaBeL zL#h`v&l5%X6XC}Lf8S3U83K!8eT4k)TiIa$@TZqUemDJ!OllxkkLLQQH7J-IZet{O zeA=)|&CbUv=hv*{;hbQ5=*p2+yV;!f^y%`q5zAF~Tx@Jo1Fn}|)J<<~GgA7vzZ3Dzz@V-KBdOzRu~!$EoU|?AO-st5HkR z10$!$i0{Lt9n&$4sjV$9kKy>8;`sFE_KsV8z$O$Xg~D^e+@Aos&qBMWdOpT+DMC^e zuNG?OFZ-W!jPqIfrDbEPua9uwwGZc4nA3$Wc5y#ei=qouRL6Xf*u!vWICP$ zI}n_)Y_*GmHEYY{F1~E*;FedB2{|U)>w(5=6D+LacPxYWl?#v$?L?G+T{rYa+Zd86 zq7&=9-4(h9!L44~$zL*+30*#Ap&K^}0*?nQJ%ZGP#BwufZa;Saj~%F>ks?Y8lPHsQ z0L6*=C|jq4!)jEFZ8>i&%`S@06&Eef4tONh7MD7$Ac5%#JKk)~S%a12GW)RNHP30n z{&%?HDE`Mg%)CiAUZjR|$u<+yw0alhzTmMlkH62z`ThE^y|LPg9YnnFC(7W&+SdC7fcrEF~(NzvZtWtSPjK38f70nAvGi1nnt$T;f9 z1zXywFIFowr;{W1w|2Ly9B}HAdJ%a@Y%T=O7V$@8Yg2%eswdLB4G<2isWTAlyr=v` z0C|#cef%f5`Hf13;@<(I&Xrh(Hhj>1AI+RscEb^Pb02-{R_rI?u;%BX>}kptEj_Qe zw6nie&nGT{b{5Vov*X3!Yw3ri%t6GGw@E|{-As6)TyaF6HMDv zdYn$Yc&;2tBhWPMu$G*z0z~C~uev9=_sNMpnc*BK;b_Z{300fSDnZr_Wb%sMb@b#B zxQ2E9^rT+95Ca6v5isVVDUI=eI|g_6{cc_hcpQv&Hgv(J;n&X``EL(Ve#K;5kUag_ zj)@;W>F>SQ3VD}XO%~5LwFms(g?E??#qi0=H7}maIvol54S)ZNV(Z!yN7>)lBNzd( zz)>QCRk4aV!)rR@q&NR!DNWrueM@RJgKK#uA)>3yOIsVa%DRh5Y{3s`=3T^~*gNPc ze;tBSviXUR#ORwFSWb?T~FE>d#W(xNQqBWA}%*wef z#w-k`7vjxx=!gCKz0UpUJ2m}l^BpEHl0R57k)H0+_lb_+2>FH1nE$@1}Eq=O0iM6GLy3*i`$i7%5jLK>E3B}IXp@c7%UHKzS=gHoaj^hLKZ!B6;h*A>v45%S zgQ3E%PxjA($guM^q9}+(JPC}hUC-_!>157U=;%EiEsq+%S+o7KvvMVGa~U?R)QDV- zc{!c1zrk_CH-GkPiqcb$Q#Ptfi_edl@>UoTg`)g`90B#%$8<6PH5|JtUus%;*dlg0 z+7ZtxvH7uA@+5Fq=fJEhy1vz|MYcdoM?EJ1bGG|MYi$O5fN>r~tR*U<)0kl4k-Xk! z+p-=7LR%2We`Zvzcm*W z`Fmb;7^xGsw-AZ`L8do^fj!o_8SfB)iCkm#|+)j+1gMx5y}{MuH9xo zrmy$icTtVq&vKhE_rq!1?K+1T*Wk>dxzXCq)b!-y%6%wLH+*7J=%3h!Uf{Odhon6# zea4m^yV9U(py*s-q`pFnW4JCKORk+TN*>Iz5Yp_ zH*VY;4jkiV4ZJ1yaVyP8jBCC;7#Fb$lhS}^H4EexhKZ8ibn1nZ5GW3_jbK&@+Wg?>0d(@c~&|A3g$&UFi z<94AHKS|;HChY?7EoK`tCb){phNo;sWS@Oh#~fard`g379*JLnvbD+%tRE_=K$k}t z$>gLS1MpA7JO{y?)p;E5otvnhvsNiYI1eNrhsLi^*`O0?D)i?Kbns&DqaArUbz6AF zwShu2{!;uNNmLHw`;Y2}S={+UdDlO5x~ER;!R>kOI16`{9ud3hd11{ z**Cl(P`Nt4qo}+S*j@7eq30cHOX0=@Q-lhHTY5*RNTPSzP@lhi%2;e0qYJo=^55>3 zkY`MO5z2}|Fr-1v_uUIRR6izIpFmwSyR@4?qoDRmXYrBzkn(44>BUH_0|uR$z6h#* zH$(=P-x5n+GW()H>i1>p>FmLN9UA9}o1raVYh!gc^aY9hrSM@Z8Q0kfVsx8elMkgz8=& z0RZUKJp>q*LGE^c`r@yX!PK7H>@m5&rU|bUa@f+7eI9E`k4mmg4ePhJe^E9NcOGDQ zw!w5`@`twn#^q%3y4ECU>su>;U2I{yTg2PLc6olqPbWmWi2+dY0EA zAtA538IXbQ7t{E_0vhg4xKWu_TZ0BVDk&_u$KOlu&rlDQca@i@D)L#GTOcUe?gCeU zRC0jT)RVBV?uQ!&CcprqvO;>kY^bM@GCd}p%vZuX-bq?=#5fG&ExZRBSpDCzZS*F} zZ+@GI3Rp9w*+YmtAO0+|#=DJOw|VQN2$z|4>+$J%NW!{GGyU4>jGh?l`0`5L1ai1D zL%rsD+0nzvttJbV+Ovcuf9+1kdnsBwW59eh{3T4D1SV`62UcLO)iLHbo*bz3udvPYR`kb#3O$ z4>3zP^#HzW3hg!5W}aWOR{ZnlR*rt*j0?J<%+{daU2060{?Ga;?CnorIHV94Cq32H zJDGo6%nS2I@cX!iNfd#sHUEC=~J+A!ptq6_OKHCR^U~@?OR?8% z`PG6$excp^J6VY0R7)e+)VrkIyt-|J+b9PJBQu6sJVMU;9mF(&?WG&P z>es!Q%3Y?>ATRJaok@JiZBsLj*dNnK_8{4yB9e+pY%hk2A$O47@K>sotxUbO0%g+Xqr#eY}hqak^bIJdn3U)}E;k7W@X3y*(AK^He z+BvP0|dS6WMtqH-*kO+zM-K zxUutmkN1k+%hb<~4%pm3o74I5>lf{blMbB& z^dvAOW7w!B^710HZ-?^X!=2+ZGp;KZzd0l>NeWfG&8YtRqkyh2yShnt|8 zLdydNNYf<$kCYnvA!c-%7k=bN^#T%A!LK7wcZkPC*oiZeDeGg3zVgvy3Hd9%G? z;E%SmppU!uvGD<6YT+1S2w1UVcynzm|MDwdA7qkH|n zk7TIO4uQ};6{lu6wH-=6qh?%SUx;)WwB&4Jf3MAf%i}^I_m3LoU2(3VIKuVYVbcJr?!2TbfNaq9fiS&P3L>JOmIB(4(M-wS_1nVSK(L2mmC z$}FITqWZYYk}#G;4j6ZFa{lmx@FaTcwaB*nbDXjzd4w2a@GySb4#7u7{3_yw2aY~P z)dN?X*_C@y9&y@4f)JJ`y^~MvF+5P6B+T%>b4lGD;h5$;VPT}hIlTFTF}-?peN#=W zh}|^c+pb~Kex$$IoQ>}_JY|7l3yAkvntPZH;G`T1BA%PGhH zHx-C#`Gg;GHnbFYzy;xm*Y<&tM=+)%B{?~!nA)*KE6V#r)v#EIt+w>^xcdUE4Q-=FnE_{qPSm#JO|o z+K#iG*nhDv%W6O3O{<)15F6(TlY10Iz^JeBoW1n_2fn;!lS=Gt##%^yTwLD>HIgKQ zM3VicZY^^jbVok%Xd7s^((L(r)o9{c?AF|omPY**s>6acUy0?3I1ONF7#WRx;?ZEO zDcV74>Gr--`cc4e3mwqhC1SfdPn+2&$$j<4jW@8?ZcSQM5y59z;Zre=sfYYX3d^9Zg3R1%7Y~5Z^rS!|09-DeOq@k1d;UJerRfMnYm%=er8ME9 z#6g&GzQ7GP4JCOd59o%?rueY7XHk45=WQ9C%aA5PT>20egJBKmv&32V);hyQ>_opi z5;N;&aCcZqTGjJY zU{A{R6_NC~2rZ;nwQCzD{u`frS|g`Pj9nQOAq4N5S)=!d`7yHheo5T6YsgH5$(0kbjTY zvAqh1cU-WuIKBa^YO$^H!?}E*sj-}=^jNBP6JGFY)Ag-0D85qJbVpL4-yJ4c4hxc= zfQb(J4sW{m(YHU48o>Wkd0QP9v-o4~=+Rqe?>#GTqM_xHiMicg4M(1UiwLNdv%3;{5gF_i`&j0 zT245_cMlld%QKx->F_{(-yPAeRP<19!lt#NU-4Dw+(K^!8gS7<-xUqp4h}TOK`&=V4@2{99PtuKl_Y z2}_|A@Dn;PImbjP$UXc_YH1B+!9iRldWPeo=`8yi* z+R`c4dYf$3)DY%D4Pjn|HhK`Rf(^o&Xm;rRFPBsDVo{q1&d+`vR`)2|#xU?~f zz$A4 z)Oa*}{{q;=JUSjVc*|dj6(foaEwz$G*m^x*9~r!oCAi-__t~k$+dtZ+N6X)qoD6(h zyX|@Rn1E4Mw_`wi(wiGc8DlbXs!f|CBcmcCb5>uynu(0hO&Y42o_b5y+xC$f?hVX} z1r=;x&W?hKTpFq*_aEnIH`UwDE5PpHqb0BFv$_==$0h|H)PAJi$Ts6~iveKF<3Au5 z7C&B8K?)L=a0o+PerP{i^>ud6d-&k*_V#urc;ey4JewqnvOYBaR}~Dsx4%_zu)Yy% zUL5^y=?L-VaM_h3+LG8?pZT4JO3hdY$_NV#th^-)Li46anr>XvaQ3u=tXYo@*xg2C z>PusLzFgd%jK@G!8S03&ei_l`gzr(HB8Tk%&-4W3Lm_GyxG|khy~;xKELzSVD3RMQ z@xKo$g|68$cTebyM({8m1|pBA>@gZq{mgj`b9(X+p%rRSqw98gFuv0$fH z$ma?g;Y6^D&k3WV4(3Y=6pZy+|6!1?`Tj?~ezi~F)1?Nr%znz+33R~)bh3M0VQs^_ zF@FWWrl6prbXe4l8eHF<|23oS%05rt7r6XN@U%c~uGPReA|%M=*?1M5p}x%k5XGgk zRgd*F1XMsmKxvVmzxdeUz8qad`v5CcVDl(Dcu+Blt~Q$&|dD(J2oy6)E(uS&C86oL{A4v5sHH>*&U^|N4qoKx;d&5bHm0DsKIY)W`>t-(Ndo$WDd3 z&O>*7gExpPa(QcZMg046{vT@gzA$CyCxOq;hl{$?&f%alYPy~sxUGNm=uvf5)n5zG z`Yx;6bLr0=n-k~*RwwKw@R!sWC!E_HqDF2@Yc`=r;}DwwZreIS{$f#jjjt*`R;q#c z!U~ME5QqFjwAm4)swf=stnE#_w&6V5cd+cc9^B+Ed+cnQtLH{J>=N*!(Yb@NPqMbH zfat+5D43Tvimc;iuM`ieq)QbB)jGUM}RDJTa>^zrYAF3zojUlSq1c20|Q}pGxJ;Ov=2| z=jVIGdWpvs-c~B9$5ZJno=J_ClQV;sAHWhzt;$^N!gYL%b1}QdHE9j*?=dViaXrFh zo(vol8?TlQ%&fR-mJ#y@m5Z~M`ZOPah4$nuQN*=2@GxVrS&e(Zi*S%qMq80!1MFUi zjLyAIewC$+bIY>MG0#VRuVg$GB&Ltipg)A^xIazV{A(3WX+=sTu)MupUlF_1PnS%u zJz#V5PTl&v%s#(}-vq1ubD>SbkZm=2eRI)#!s*9&r^4$;h>iE*tv>_r0~j%*pQuIs zjHESt`SRsJjc-JH;;ZKiz6o5H@S@tx{Iu2A9-rS$003dH^^4?l%ZTR%FxgwN{w=3~#&C;?Lz*Z>jzwkfq)l zNLpMS5lXNdm$l@+++s4)_clTg+@IYxU@nd?L~;!Ds9LyY6(I)lW->E7YXekT3_~m> zljXY#%I6V_&*<8j3D*ig&oJl%07sY3)+6lCC#VOoQGmHF>SH~y^Wfd~BKCc7$wBMo z@}qF#H2B~oiovM>+*G3*2!s$Fg--#2ui5LzEWoo*#e7fYP4@pbc<``Li9-AM4(5-o zWIT`#y({X8u~U*FXLj6XI4A}e95-A!kxUj|Ua{r}_oOA)-vm75h1%^sCT(NhWzFy_ z$q2S+ca3L>XTSO4*xpR|HMsty*o6>Hy|9f?D{$mWrE}-7WCi=-?xq>0hCfF_n2NaG zBZ|K+U6;hEkT%~>@n4OpYTVpkc~V!fTVAm3Vj&NtxGBfux_a@qJm(R|i#K8a$QR{_ z@@8NaN@^%9EPPNJdS++7O`#evtoLtSA?h@Me`{Xo3?ckdgp;j-O&C6Fd0Jgl^S7+l zLn3K17>gWHIF}Zsk0%Y3kBM&`8c}yhl-cRHBj_q)3o@K{@Euv?f@5C-5SD0vZL_=? zQuqS1hglkNWlZ^8rfM-}QY1=?3g<+1!c8nss0P$T8rssKGtWic52UtBvT$ z`in_&r_?|TXd=e?@7ex>Lb)mb59v_Jg62y}nd(v8t1@Z-(>*)EUQWq@?=(I=tP*lV z^C5(xXlNSp;=G&3YOu+N0pzpZlsRBhshw+5vMiT2UN+L*%fRiJYAcqq<|XnriJ{$<1xGBpZkBj#hvD=?5Ig zXkH6~x&D7>hZ*G?j3F+D`k6lULRo9hNv8K@IJ04^V)tsMsPQ2yW0ILv%wOmic(EaQX`zRzF7VR@DL|s&RCl%2+2rlGZkyxqeV{D80Oa}Pj|JQ^ z5Kg4Lnm$#FD>W)7c(KYmyx8vLx|rCPyi~9Y>$vVw>zL-!>RI+O@5HkC=sk(qKAp+a z#U`@hPMU2oiGo=}&XbT3cW@@fem+|#)JjL^%SU4Krs_Zp#zze`qw?=Sy#%b@?`NyW z1%|n=QR`%zuPm0iJSblJJ<{E6>5Tqt-Eoj!qg|}CJK@e2K-<@>qhRBX$B&q(SM-g} z3RD|3O4m$ke_s$Isz7A zBu$-(VUA<{G!wfzwz5;_&LM=uV?z!bX5Bg;cc443pz${}Gta^VPf<0|m6lQ52^tSnc3@ z;#fl#80K>6pOIfqd5!zgQ}yXd=z*7!?r-)_#d{#Uw}ob1~B6N zAmzZx9lO|>t_^_f{{>hii=uTDTlbf|zl0_%}nJsgr@yrZ2O#G)B%{B;roqbf2M+oO1#$K+hB=7zg{xIt1)@OZ# z`QnU2A@?ft18*eKV-PeSk{`*vwy9ZBKdmE1P0u;7%|BM7Idqp#7$QwgdcLUk?R^rs z?eN>1tY3PQi3LGY5Mp{!+}b2sEHR&5fV^9?hdG&UUSt+3;~n*R6c|TSZ(btNE5@Xw z=lp^bXa6K=xK{x>jq~R_1#);`TByG=KWKA@Ek?gm|9WHDJ5HkjtCx5eX!b&<2Jmu0 z{z!K8+qZ?AF(N@zk03#Bx5esChcAwe9bZ#HPqq$kUm_T&J9R3DL zIM2DZB)-ji0K>F})sMA(KF&zLHR<6_W={iOHoW^n&Xhgpr4I+TZc_26UAdwM^0(Z) zY~A`pgG~fS*nC48b;Y{ZlKZ-@)a!t0G+JFvYqhwd?9r_UzVQjSX7@e13b(ovkP4C6 zthkqv0l^=#w}984N)GraaM`2chx!R?_@C$ZpSjx|kh!vfU)p^vNR1M^34H)A+lfi= zKrq3Dqj9>2q%9wXh3Wq<`Y>;W0+^&n(xdge>6c}<9UvErFb(HD^`_tmsS?Dm!Xoc;Kvv-FLR`7Qq%Kk2sIdr~{z*JQs~qiK~$pL|ft z)_Gvwn*|)6*V4lZ3gW&(l~R-_2AfBWh28JoKy&>Ic8Iu|evVrKjIfUx`5+)UA5SZN zm1JQLsm(@}5_4kxZrZDOEhBgZ#~})1hh7t0lJ8&$%%dTh>TL=Ptl=qId?;(+Q{yrR zwAlp;ERs2(WAB3%wkfSK%-wnho8QP zg5#yzdR6X3`t>AF@KCM95XiU8E}(9;(m?^?H?=wV={uPEdDUDiQwL+l&+)p1{2$uh zI;zU9`}^HAN~?q*-GYEfH&P-cARr(u-QC?HAl)HIw{(|CcS?hFPI5zC-y4JeZTJt;S_cQ5$y&FN${HUUw$6@HFVG2MT8ln3*Kj~wSDt=>U zC-eTT>a)4C6N_Rfj_#yp&R&Z0im~H%qUl*Fvd|*zO)&+bF{g%SXwJ2*bppxzs^BD| zB-`4#I(Oq#j{TB@qdD6d8Mj>`ue>`74Hnj1y~FSVt>&IF^Sn|%t%_xNDFvcPOm7wu zUeV;<{e7dJz#IDDw|D26;!LiAcw0qn_K7GY=$9@Y^xyEKeREbipr4; zOsC`)&6_TNMET7WewP#I12hJo1aL`pi<|K7bv>@69BZECtQ8cCyLZJ6FNx`-Pj*N+Tg&QQ&DrP z4hkOTK6ucOxk;kgr0U4nJv!gBh43WUs@ynDB+mV~z`%U|*CuQTZe7njJOtWNTlom{ zm3r}9)(&s!I5;Lo9ouJI?Y3R(D+iZ&S|U(6n|E_Z;&1nc8e--zOTnS+V({8gUF8wB zaK96;mIo;xY<>$G4`5vP|I)QH0ffUIlcLNQ>U0t50xK~pyvO|~5Bg^-)YB}U zvHJa1=!Y*&Yq&)Q=&%;lnoMB0Ct6z%AEFcw%B$r`s-%s2|jt;d@^HcD@aC|iL~gzZ;*H82;Ffg>4X zDS*t(xve)Jbr;rx?7D;`aUylDtw{!8%*3P;P?RNCm>G(^$gUZ+xSjbSm3Uh z$g7JKLmlqJ@O;YZP-scr%>?i9oX`bNPD<|;Z8n+La?9y3Z%n9=FsKIPF>Xr@4&k{WDqdo;b^_PHN6l2kFty!er z+`6TJP3G=;I_61IBhg7>?*|ZsK|(V3*4w$`<510CdIJ_Bu!d~FyzklljF_hQffyvY zFx?*12UXWS+86>TL9{!RU<)Wjzs@7w4)f&Ch56|*FK z9n`K$^72bBI!S$KLBaREd-q`00)R$@u?S)R7@k@*7$ae`5G(ewBM81y{Pu3H%c+L#&5No1ozCrFkfG~%Y@af*eL@FA!sOzzi0k(tQCwp z##$VcM*bhifT;FcC8fA3S{UC=I&=mUf}0Rj&mA zFF-eJbUl7^TC7pXgw?Wt=U+F=__EZX;o}S(#X=vrhV1A6^i+Z|bcUet5bXOIMNHrn z4rw*a0h$9v%Ac})(81v$h#~=DT<@<%8<-@WXdQE28htU5mcC(2?%L09y35B z`i;Zj+*d2zQ3wtK5LEn#M}2bfEad5fAmaf$W&`O5@_*AE2Jr}d(_g3^2maGL9g0nZ z3K?1`4-YA2fL#ZK=njN|_2>JvnL#uOfpF+|YG*ZR--l3uwI2fc%Y761%dh^Q|N8>` z?|+(Y0K%O2oxxiCzhzzE=l^m6|0_=Ymm7C?vVv%f!s^``|1c5#U=U3~Zq{2$i*pJ+|)_3QgnASw3G7yjj5E`JXOtSAU5#J<0l z=5ev<#SiAsm%oI2zkh&6KqbaDZsk+_0teaocsHhNf5sGMng`6lyGYb4^v)@bf}IDu zuu}ZH8I|I$VmN=Ac<`Wa0Jx1v*zj814X^p#@csk50Il}G z(H5X4{~=m{p#6^5_`g9b0GL#_h>3|JW0SxndS4mSp2ZJ3(gKB@pfRuEwu}y5|q!xlw!UCx_@^63h#qA*R!FC;` znt0O9_)PO6b9^-&F7i(R2Sfa(xb#Q@=(&Ntq>yNcjcpG4yEPbat+Nr!WFSYYYx9Gs za1G3vrJ5-_+UPi22q+f-a4dw#GbZo5$WG061=3v>&FgTmyB^OXgMjO?2Tq{Pu%z2O7@Boc4(x67Ce*H{Ti$`U1?!p~Me}ed z@{!Y=Au53OH%(<@sYhL{o^MmTVpUg>+3@;23lo=TtGOE1vTDYnLD`eovrJd-{C8!{ zmBuSmeZY(#dfe+tt&czp2a|jwQAeOv=fQY7ab=7ht-u5;Fk6!v>6s2l9ene+sV3e)VK* zzQ<%WhUcgQ9JZ$_)SF|XFL!KVk=;QNy~$j@{sEdF)xx&hSHQWvIMNw#MuVj<2bvaH zcb_t{9f8Ag=gF(FDe`WfD!@D(S&qh*cto22u{T+*zVWrKO04Nt_1yBo$+c(d{O-f@BOP1ZlK5=@$k|6Kg+zJ@d#B+%(=&_`_SvFUbWCCj!pL+_fL+%aozakpaYD5 z$ePrl{*E|td2*RmMzc~W&1~9ygLJC7M8IVq1KuTMtZ6_(f#r7Ac5pLZFYMli?a~lz zz7AZC`opR+H>H9?M=Eowhj3{*R9w)Iqx~sCO|6pp)8m%Tj>N;LLlV%?QiSbzmmcv* z=rh>vmyt&|lMu=BpQ>m1=LTG&1~ z0x4FNG`E9nwQuRRL)X?R;T76VVj+0aS_a;rf2i@%PkaKObDZnQqb?-#=qNlx9sM^m ztqS_V6^`yva_pA+2{-2x7OT7YCr8B3?ScecPVMnRkbJ!MW8j5>XU4u`q2vW3G{?a# z%TaC*hA$KuQDC=sA|*~4o*g{}9nI?20@Q&}AVh_hrA__$3P}+)6(F26I1cv#y)Zes z%0=%T;5R36bCmmMhi??X6*Zm~g531TGsk&D9i@n84}6^wwLn)lrt|Ib0Bw)9;Jk~) zM4*-wfUZ6~Tk@MV>t83X6W!`?t`j#y)MpChQ1-Vkt|Lk9POq^z&u1Z^p(=nKItnHi zBZc6(PQ$J=Cu}p@X-%Ut>+2Ljqs>b!5g|d_fgE7`ii5EZAN+)EY}NBz8o)~TpaL{OuuqHw z)BnD4wIyCjXZYT0Ksl5wd+u@(Z(;J7bbGTNIDJ>GxL}k+#4tdl0XS_$IbhbR+yBzZ zw_DsFb+q4ZdvDFWSj??3mA|+?(qyh()3Y}Pz)|p&ah*Z^4LYD7413<3`sMJKDmIYR zdTGzw(5HO$m?XIDaX4G3#+lCkv2k3$`snnM6&@JE0T`cF5e1%xk{D6?1URHk)|vMI z;0_JS7!x1fQ=|Q{`2$Wh^#q{*UDka!CvXwTbpN7x5C@|`MHkppQ%{;Pdkuz!{Wd-) zrx#p098|=Wye~?y6|DRZ?@)0NAYpiOH-^z>4&VyMGk#@}J4!we{&6#c0q34*kzjq% znKz%-EEW>C1)yAL{|oIfA~iokwFvZOX?5_3vpY81)DX=%X-0vt`2NB6cp=!<&jl># z!$w|@_1-W=H!lB7o}NuZ4!=FmDTgxHL{$L?Bioa8W>jFm>jUvT^&v!pjP61@5}1lE zK_{!5qMK7oAI~t8yrZ>wIDb-`6clM#vmPUm=LMxs^Hw+Xw4o64w(p`6n>)#%w<#wS z-$Z3;4*|H}Lk%ZEE>^(q3fSp5%ukTvJbPry0gjNI9Iy`UPv&R(Qcr7pdfwfV$HQ9q zz{)m?U+!}@GxO1mx0#Shnm9H943?$mruZG}keXK1bXI4cU0fi6Uj@XcaGoR(cCafx z1VF9Wb!#&K{j~cq=0=r&ZGI0}HRKHXD@zF>4hDZ3%Sad4TSh$~%KSA`Spn;J^EQVg zwG-e`5>L59=1~C7tWWupXMuxVt<%A9tRX9sH46>^C#xJAjpcZ=LH_#f+rpBj6w7H_ zxCro8u?&Ou0zNN`*A#{xNRq*3q?j8YghmRr@B5f&6-JzUk_nxtk{B5*T+8E4=@ByPM^l&3`Pf z@i2P0jkmJjM@&lEm5FS`niC`52;lh#f87*qpZk9ddc&Knl@@2IK@OqtfnjmZhbjcp zT!~(R-Zxu-PfQKIf(B%`8vwUX_~#+Y6jAo}b4`=+nbE7O0?SV`r^pV#Se=oX$(9~< zdc4pAC~`2AawH&00)oemv0=_{`<7R+QHd+geSnQ;@a;}UP6Q3+3UYI&U^nsY@t!%y zinr~hRf z5^-8ajBXxP*xq$!LLq>mRTLS3pHv7?>|vVqge8lId#Ya05o{{ zv^vs?)dvIWlwV>1SVgWJpp~R(ZZtG(cwA5O=pvtnNI%Ow*>3g_X##fjyg?LEn07;z z#A(T1!8@K9_b?*IHvjN=p+P@HECy0qen&DFnOS@G!!?N!WOCGU9_Sm4=>-WK(1aN136|R=NSH#cHIcHrm0iLPL>DK04{|e~386CBz z@xpT9<{F&^K^la2@m~v-OUWerf2pE#M6!p!Xu8o~#RUDcv<;VFk!xVn^eIR1^WoRp z&!>VW_y!23tt}s3fUjh!^hC*_5d+;S7Mg`8kKO3agL1fmThnFrxSC4R-82xIwH65N zkNVWS-n;$b2?XAk*QA9C6chzGz;kloJR|>ccERg}fJXKmNc_d%OYA*M$bXOhr5Z-# z^!<9n1-q$VzyhLCAiy5da>L{~YM|ln-hadaDsr|!@l3rXw)nv0_5X%6q;B&^#aCQE zcC6Jn1^~ot3WT+(=PPhoD@;&Wxt zhbHESmUAdr`(vo=_ov0m$|{>eiT$huVnIUi(OrOaa98OG{%ZRUBN?*t_q&q1iAs5# zbpw)N{U4H{r5;NGf;PonSo#VUR`UXcV4LWA`B#Td*F+%IRg!pKIJYwayVL>4iDg9c z4`VwxKjyp7!;m?l;4hsFXMDf~lCza)mAyXR+6EM7jQZovx!#$nB>ciH2qN6l9YGI< z5QJgp+eD=^U<^PSO@;pCJ(a6#HPC|jmy>tLvL#5XM75Ber1K{ZP)psA&FA6gUv@bkm!v{nUSU=$f z4RBmH-q8ltGz@=af`2zN5So(OBRg)M7-a;0dVLj5N>GUD=m^?bfvUit4&@Ap*rI=a z=$~F10HAz{L>(iVSptv z9awBgN{R1=I0@~}mJUf|0;j17I&X6~&yb^D24D=zSaxyTS9EQ1mYnVd^-mTcum(Xo zWbMDDh6p+Xs(UXk+tDS-~9Z7Mxq`^NhMcbd1^11J`N;5dLUjL zBPl|#?|}%P=+0|lJ&M<#c$%OCwO7%~f(|_1c6|b7N7Z-GVid?&A3C*Hg($`0$R5CE zAQQX#YoZZdGEq zU+4ib;OX&J{iC^taq?Z#q?m#;Z;AY)U{`6^c7l(06hJ+&>WBaM2R8_toO-I1S@D2M z3Tt(3Ca_%E3cyuqzy_87_FL5&7G&mQt`&)Q6yR)hrg>=2I6iW^0FGofkdQT*0o?^- zzB~u_fBboY?uNY1nSuHV@5|Lut&sRT1|W>UC!zNb(-FwDeg#JKhM#hd`>*`fK<*%b zzqnzU)iU$j+i8>kC$^z93|EP#9PlHke{;z>IWfY$#a#;RcVp-330q#q5a=NLGUZP4 zWE1;S(1Z#QH(tTI55Ato0yqC7VoG{(8(z~JE{3l?6y3Wfv$Ze6A`>g2Afcu6QOCBv z4?Xm;dtJ5OsC4(H(X1^TDtPgYD&%u8IQ^iJY~Td%2i4gSvQ162PEJ_oCYU znR)-zi&4f)h`#RmtY#OdW)}nc!QL~^`aYqcJCn%0g!O$l5(Wc)*;Jv#vHnFE8OxdH>Ip!|w=B?m-}Z z5B{sx;*dX8HW}42;eBN?EMhV&^V;aAA5`p?WTiUx>NIX+*pm%|z7zl(RUR@9WD_vJb4XJIh)zL)D zy*B;52^>Ea1y4ovV2d<2kQI#6kYCr@QmLPpT2170hDZ=(bcTldPtne*s&octltch_l zPCR9HGy;sz3*+Ph@IIjKAi&n6G2K3bR3r1WqkplH<`#M z`vu831 zaB4VRs-vP(lL3l(`$J&`a9;2FXkOl255klRBbj6q!IV3EGpUp z&t?Ha0ChkRNdP*6hEBf%F8hrksKyIjtnb+%IpS6q4%8g z9^qeLSRwmcjp{oqsS&Jfsuat|dFrK`EnsvjfU`vWneSec^{4@CoD2Y>eSzuShxmX= z#>LNkEv`ADcl{b10k#s6lf-XD4r* z(Rb;GyhK=P=mviILZk)eVNhjkBqtw{EE|`|DW?SbWP+iS1I4I{KjRbr; zKSrxTjP0RXFAMsCRf5KZkRfcuKkb!D{Xy;Dyo#hXJ<4oRU7Z>X*NCs_Jhz^7eM3b< zlWV!JxfK~z)Ypfue+b72K!ipfwK0?siSN)-Q5k`%@iF@RP_{*6dc)+39i6-nyTZ35kT%k# zhI@clb#yVazX{~O5df4UwOTmYWj(GAjx$|83yJysd2!S8AmVm2=^PE?@??8X3Twf$ z`Y|=<-?<=}$ZbdhJ8tRxhik`7ud#J2M}OTiy1EB05%BVg0MJkhEcIjcTBjBozfKS$j zY3ypiX>lQF3}qTAlatzBh@EJnsm)J(Pumvq|AA@9&MA#EfHDQkxM$DokAs60rtvMv z=5AEg?@wMT3XaSurmBEiENaP7fz+%tPj-*j)8($!UXw(0FoGNksq^d*r``#lhG#$3 zozXB5VE91_DXjI%8*kGO!=8{HK+rmbu;4MHq0jrnQun_dV*L-me6fE>n+lB~s~IQOAYb(vj(^ac({F z?Pat9r3HaTpLgtuTSLl2Ey7C5%3E98mc#yltKHS=W)9P|5+VbV@++PZq+s?mNyi%~p8UJ8q#+Z%~p|Dr3nbiF~LKv4Y zu=;(IV@aE%mx5Im6sgyW0!Ksv=sT*d#i4?=x{;MczrX5fDAqUsq`)v_{TCbWqCku z;xzsZb>B;1DFROL6x$^y8RuWSG%4%V_C$6wb66YeTAt8)?QSoRFGPSj+=Y`vFb(X4 z!0@F!I1ld0wes;Wx2n*!my8eKD(}j~;n>D*O8~GjZi4o0s!+ZSC5Hgv54$_$QVSSl%2Y}X`%%P)BN}CJTZnI z@9c{(nYKC#rY|fmO;sE_1}2vnNBuy(XR-0wHp13QEy;y7LE6b`gzc)#wt8;&xqQF% z0>7j75XSXzzCPO7<@xe-C1bLHE2inBeOLRDq1 zmZUg3k*9zLvMh@iMEeH4_hqP~bJmy;MY6 zu+h)hkq9e_9llIEqv73~4y9;&?y^!8dvYoj`z1Xc8zuZnM`*i6XStkgd&uAw>5)t0 z*#{X5c()|@OYmEZ$8NT%#h!y3Udx&+wK|M^dI~*06b^}}^9%H+pku*S{rR)2uOT4H za3H<3^i@UkZVqb~J4^0nep0nL{xQng<*(gItu~R<1+)}d+9^CjLZ6`_Z1jyu zlyH6?9KB8%q4#d^UcX5Peri3#PAQQoh&}lIJ8~_=3c#9OGljhbzuDS6bLVx~71s0+ zxN>7iV+ach3Q7)X<->_^VTq@W!?Wca^0=RlBe(NLK+OZmpy7tY#>N(D=0bA;&9do& zqImyjroo^d2fT_LMCAlQ)v#yXin+V^rskd!4tIya_kGtcM|)DaNY;7~MCic_#H zY2yw(2M1bC1+UEXXNI6$$ zhqo)$^TXJDOQ-)r=FBGb%z!*!m8#0}y?tQ@+>frEq7EfU)5=HTFdTSG%(BeVCQ&(+nHcjxLW88Hb8 z51#>N{9w<(k2x&awqJ71WTb&jiD&MNIzO<~3FyIT|on<=&|AK`@AH{Sq`irU24doYO) zfAliHt(C(^Vn#MK{a#9*(R7?t)$`^acn(Tbj-?bzEQ0zyj{;Mpg1T^P6j=lv_udEc zqtJUJZyd2<+vdy_84h;p3>E2#+FC6*4icZacH(_%us0fCa6HHNj)HobJHnwDz~gi9 z(tRosKYG{O?&I^4QS+O0>3P_U1O=NYS7=#vHNK|Djq%P@19A!vfD;mhiZ>h%1Uflw zMbXjG`31>h9VH`)9@*|p3Pq}y*6bKfr|n)R+nf+pXW(dQAw5DooSZ``}@xtOgk z@yqRfLsp5rD3|ip*|W958$@AmB{xq)5~LdsoT(cK_UVf^k-s*27}hsY*eWrVug)ix zYGSF~M6|cQ-islbuhm1jsx`&{cTV3*ccGOVKmat$Jw zjt3@#bVS75lcxiMf?koBpeqyfJ&dT=1uJ~f>a|cGafU_t&rjf|KR$k8*!qE0^@3K; z4cj#K*6Z_Pz{#LW^t~r8C{x^zU)`$b=bH+liH28IIP9IH(aNRZ>^vWL5VbQV!LEM7 z@>pl^nBP^qbFI<`NoTa=!(tWherGYi=TB!Bxy8C_FXW=_W2Mg(%7yQJiR({4URXXE z!WxuGqY)AN`iNwF|7F!cC#^QLYB%GCHb+L>$S5d<(xh1Om$<_v@1)M_Bq`%K>)%I@ zsi<=n)s#6Z)Skf;u?c+`{ZUiws)ERK_M?B|K;7cU3+6_e4fSSY27!2X#c%6W&PE~> z*ayoJkts<*L0b}`t*`Z4A4O0e%m+k=wer;#9yAHnOWr+zNyEnQ!RBPkP3XZv3+;Ym zFj)Sy&d(L9Ahb=0uWcC?I#t^)Ap#S8hVwpRKK-FYV%kSt>P5to+g^%L?=f?sNqlcF zybMJS^AUoi$-5?)bQPB}ay;6noAbARj#YPNza0alE^pF=i zRoSsfJZ{bL(Vm}~LF>h1Zjp(Rz6{BbUYw$B(dVV?TGcJbHnZtLGMoA)Q+gf|xK}+u zX~_W}T+mBun1msUO&k5m?)eHvR(frb{#I0`Yy+w!Bk2zfjrn+ElG_fssCN2Lu2l3 zw)gcg9Yw?ZI`fO^+gFPAl?HglP@3!8Fs#3 z8?`|I)%OT!<-wr0NR1P{%$VnXir(&yhN~*B^6witecR#N^{%pa^=PjlLQe1KUW)iE zZEgmSg~WaKpcW~;PD2P}aXNcvrUrd6U16eH-L^|$-HY9Kv8X7#0FDiZBjuwE+-Uq($w#YJ7h! zz!Y@Kfyw%dx@AFb@9C`13^KG~K#KW1(pN4Q&ZXi083&H}&r)Y1P0vershQ3hqUNh3 z;tLI}?zZe;Q?DuJ9*Ie{(Wi9@LS0?DTB>E(JY9@>sep_@q}auH$@ z8zF3EH;$J!a68yEg9w2W*Pgo(tAmAV$U!N~Qf=a#n!r=RvdH!Pf}AvDw+3R@fu33C z921YV(b1B{L5=0wHHq*iVWp*Sy3@3R6Ugs9PcHFKaXtCDyT4FfJ$EzR(}NcX)%ijm zgo;&OUhS@_iTsIB03FPUR+K|K+zcb$K?dtnZ{EKEWEk%9lS2~)x zwA~{+o|Hx6Uo~f<@%;ulgIUy(F-YG-1Z7vOkUB;LQEH1Tq=aI57Fx(D&glf+<@pkZ z$2?dO$v%|jXASQxvAj!K}w(lpY;S=3d%R03jvAZG;h@KuuE_BnIf_) zI9>f*Mmq6zj=~8_!JsO#H!}}ggzbj|gr#n)ChrSaHf+FlI3X?z|Jk|bHxxG;!8MgJ zEwJe@G^4+y;ehS_eYC?46*LG0pE+x(DOj;gXH|g!9eHVBHwXSPidRGQw1-lRlq4Kq z$|FhxeeQMVWbJKIUc{eMo_kMT^lVnrQNN%fmo-&HyF4MqK4uRw^Z60_q`XFPdeu%| z%RY1M_TiIRY|CZ=1jFzfUw^G@EImt7V@L042Xpmb+suL;Dz}%ftfFGTl9M)=pmMs* zaCSYIk`XevD9qVK+V>C#Cog{4H%4vwEr+P+OADgDsO>{z^ok_Lt$_v?jMGnPehpV{ zQVZ*(O_Z98k076@Tf7r`(AVI|Y`D^)-`Lily=R=7y{y~Yn8=E%q|~9#*Jp&sY*M2utXJAPT0=1zJhagt(t9mYp-sr|Xq!*ZqYI0bk*8Va_94HH_E2=#oK# zS(VtX%h9>Y3_Z8ysH!rVPZepE?f)`>V7}>wQ=R^&A`v2-(1;k5}VO9aE?;h22dyvZu9OLd+dla&SDSg(+V5fje7r z!@$METT)1LO6~8;UalS8Y6C$;P)Y}%39HRbwl~7!zRKk}ahmh*=dBnjTOCqd_7`SF zgNhNuMqqoHL2?JNB7qAu-6aidpF#QSTYqkD^LadNw`e$=Pkm4wzS}86)&7*eF;?9d z!FlIjxQB8N$t4@oO#&UvcXpm(Wa$S` z{jh2ZP+-=0;3F*ROZzF3w1+{o*xo+y zWUW&Wfhh!k=q%Qi z!4i;UcQU(xF4y+kyQD+Q?OiSMt3%>O-n^yK3}@lVuSFjp3wsOO&V;83dwP4TXGqPU zvij~<6;~?qY0YV*YN8U{D_1f13J)YK92{gD2Wu^U;mN1%CL4W2Lr2ur{py)|Bu(~0 z}s&SHdq2V9JkvER~>jq!9Gf^81l zZyDJa?jh+D!#P27X7HqgzZmqjd~x)?vGs!Jyy3AD(&FPVhF@bk!-O21-uTAXFY;b3 zjNP{kLv*Ak-Sj*!;h8un>3Y?oispli%(L!H6|1DkL@3ZNIftLN0h6jA+l{^Ko;wj5oYEi8#z2404v_THWl`_ufjHkE>~KMU4oC zN3Ckg+FjUQ1WIsUb5oygF|>qoc4;8tVxsCXU8Y)f$H zPli<7u3~&!y1DH=Jq*hpvunM16VxFUdyiwm`tp@uz!YOuLTSFopdlmTN%MX5c(e`w zQ_&Y%9&kxj77}i{=VSDiji)#kwa(aT)n?>;5;NT`tIcrnTbiAQX>cH_ymsP@*3!Q1 zXJV%9=hV_t_y8ulvAId^H`3(U*#?(1*UgVgUEiR4igARD$m*o`g1cWeI!O*qQt;G8 zHkz)DZI;Js-M`(OE#prV<0zVR2Fp>d%SSBbr>%KrK|x>FN5FwMpb86tFeRMBw3Z zEIfbvU-VZ;$D}+v6VorSrQHNT6|jb0s9Jq78m*(wNSw6%^4b11DZ3nqt;RucBKnmH zyqY%NyI$hUa>$;nu1q#IMWc-#huxP4&|_Ru&m+q8F{JFipeL9c4UGNHX!vLxr%lDY zb@rPdc3-^%<$D8MZv}SckgkjO{pqm;KNwriR}q7AfU0zLzo^jmW{pd(n(#@s1^j1u zofL8ENQxI!ms~|M7)YEI%?I0uQ&Gn}`=Hmvr%!#-^)q#Lkrpdg9a6^er~MSd3)iQ! zs{2rjsjmm;Yu#V^^s`v>ze?Izn7=|~BWbWEqp;xs%m09rrHILQ?bPIqenk06|FICj zCNp*7H|x@d#Q|<+%hSIXRSzqKj*O&C*HfFVmRF2hNfc@2DmY%-c)wi&99{<(IP7_% z19OTEkImZ6Gvo7;Sk9LQ0~Zi=&r7kh7kdxkMCb3r&IU4X^8$oVa=f|iR^p==@`&?T zMZSUf76S>1LuiyH)SCP_BmK6-^MsOtSH0rZOBu7d8(KUjO%wEfo9zR%zV zsO3OfSyjhBG8w6fSWKCydsUwt=8Mb35+Re6E|n8@%)?9{M^A~tP0GjIU5lW3g<6N& z#2_WQB8|S*J$E=CFc#3t$L+60g*_oPcD*N&mRVDSD0DvNYT016exddmIXRiu-aiZn zC|$-Mj0e<9UzOHcXQF;0aW1H&bmrG)v@yf@k?~vZ@zM4BA>vsURG55f*{CJ(qJ7~K zOZQjo!t<-x`-(qB!*#g!MO!g^he~y@i#0*Wce}lRP51PvPh6Y|wM36Ze&6S(o#5U1 zQlEkp_Ax~2pnU|lQeg7%A?@M87_AQL&osFrjU?rRqiBN<{efxj-sYY=kB;1LmUs{H z*7IkGI4p7dbJ*SJ*4Zd2C~T0>*Mft_K(x;-1C`Gx2Fk*_-%#e*lSaod;lLB~j?Nz* z@=c3*45h$S%DoEDVTKd-(eqBdJKQIDSB~@Q{WBTj1PSjIjEp_waDh(;rEjDzi%tdb z2A%gvkq{jtvY8$X8?g}#ow~^1Ru-CFRm^%Tl5l?pn}kx>lG`(MV!kem+e^}0Ec(iL zSC54o-Z9&has8pSYef5V6rVG)6%y&EiG4&mJ`2v&RKBzVN^a}Q*JIQsrw1F z_$T7PK2Lnlp-nr7(-_^R^Eua3osnO1_vX2Yr<$3;@gl}0jh9)Fl-B{xGY^>qRp_>< zaogPjCR}5}j$QWhdMs(XEeF9*3cF>za#(1)2br-yB{tjknH$ab4OD36G{x5ObpG#) zx8FP72g;J_a>KawA^ieedlrZ&>XXv%OE)AA%W$sYL`tK_BSKyG2trGTu;o1s)|5Uq zIr0sph8G-j52l8eI9@z9_1KBQQDYV>|3LqcKLt&>EdC zbEnPY>H_plDJd!Ivkhyvt7h&EPbliq1}A}*=OsTO8>*1etLp`$2%Z;T^Ph7UWyPhY zgt2dPk~0YiR}|&u64*A~;DJ9?;_HbZP_{E#kR2--HX6$Ft!XZnP2&z6J`JlboW_8d zt5tvR$qL!^c#zJtBV+tRcM6-=6{a~p027-+0iPWOTGcH0O4yAM&f6SO!=U^zTGQqH z$li1sw*G(zJz9M z+cjoUqgSZY)#jlsEyyez$6Y-G;ukUKAQ2;roqXGgqo~VE2_Av>!k&?+@QK$25y@P_GnVsMFA5{kh2c(r)y7yEB$w{~6){~Y>XCgr4`zgvC&cjj5 z&T|#rqhn%pfL7)s(5M*>G+4VXSn$zRwt@*0_i(uJe4Qi3oV4U8!TjOEa~&B;Wm^(H zJk_31CEJc38|Mzf3nI}o-kpWw%O>+Zo6_rnMUs-3pP#;`Q&x~{hBJstFK{k@HEUCD zA9m0o<$=eHPBa96faxgi@AsR&s5$8tiO11QYt=)Am9WtynZtm8T1cw!zuijJYD}~_>qa2j2(L$S5sitOYIOlh{E=uROhoup>l7)Sjt}A+UV0`^J6T@U@wte!yFPpofor zaaVsbRf)kY0HyNrfiIX<$r)Yx0e4-xQty1GH)>+HJ<|PccfMRZ|Ud6@Cy&GwhD}Vzqq`wpt8;-Kk+9PxilqP|BR5UcP%PRAs97j1s zq>s0#jnNK|<3>w@F6zf#BoBhPJ#)|H4GXh}wlAbm^@blNL6z9fC_Yb~1iPCDT02;v zDX8UN-sMKjr`e?ASz5oWQ&TALINo1dA57aHS|>+A-9<98_bL9m^62}t^f~LSrj^qn zR*RA6N6e1HaQK(?>WSd3h7->m9^v?}@YXBwjdvynL1+oLg?DUZb#>Lh)z_kB`Zx*L zb2%*A8JPJf`Iu@L7MIYXS9#0c!FzclT<9)(HNoDmFb&r-%Uif)E@wiO5`A(81|lSX z|AWJmfV4DbLJ84yG3iIsRTln$7XJmbyd2s-w)e0wG`yP=nCYXNEa_ULAd{G*-1+nR z9nMyDx`=};=8suk5?Z;mvZM3!3*FU`4op?LjEt#=IiI6#goh>@r3~3VF3#$MW&8D) zXl=24?Rk!PaLz#4!|Sts%7%1*lWA+Zrh|t);9Y3IkPuta7c{4P`X zA|~zExKq6pd09w&uOL}T70H0iopk7mLwFyk;8lLmPF*>Q)tC8JE(S#?*t0+PD!5jj zfIKnI!}0fLG~s^9DUTKUt<;Df|4g!M0xz3i0OI7P+xa+r$;sLuTT@Av9xFv6)UE$bU2c%4-Vv|TtQB}qf_H2R{U#frU7A!Km;CUDcifG%jD^f zcX0}@8rb%E3Ro{$F=Lv~btu`W-m#efZf)=U-pOwC%wGR1#0I?nFVNTZKUhAWs_Wwf z8`lkIc zsEZh^S7N9}U)=uXE9kIOJYGvE=9g)nq|82Dy=)8LVs$r+RJ`D+DTNYHgJ}oiESw$0 zI)J!qp5vLhw_YwAav4pRfwlNh$9Uk@AVS;rmpBdq|8HeeiQmXA?^eDp=YO^*M8z-m zpBi7Y=W@Pa{P^+X;;R0&D5QZ9Wc`KY1IqKMXrmZjd`;BjVt(if>T-qRc%)6sO~aiI z!^8xcIxnyRGIM2uZ&|%^A0N2uVBjCqD?qtrvQWhi${MoFEnW1_g0$o)Y)HbAKo-Q?8I-vNScJ7?q} zRQy^Em^h%Xk9I+l#5X+MB?)20;>~PJWRQLc>ff<(@C@#)k22+igqJ~GB3)QsycGz5 zvUUx03%^wOmfI{ve76-)sGFePomYavoBMOK0V1a*tYU5b97J>m#u9#k!Ql)|Pwn;X zA38MB#d9Y0b2)FJ3nW~}Xisjto?y%Vj4B;bRhoD&pPk!#a{Q{^%&bDg zAbtm@w~U(sCbl9B5CYLh5&GaFLqVns45YmQZC7Kmhu9EiHU7ZNz0lPhBpw-jL@3xR zL>7`PI*xq<$jjQ&d+4KR-VyzHK&DjlrjX)M@B(6R={c3}Tm%$-J@`XM1eA4S;nZbC zQ#QID9XvgS$Lxr(g(&E2hj!{#2R7AKKEc^EDR&yVl9)X{h~tAx*(O0^3x!suoHt&f zV0^jGLL*sKV{YpFmhlOIVG?0+|eH?tf zAcxk}+zLu>9s9-Kkr0N8_r-JfS^#T2NF-|YmEX(?<)9EQP}%!eszg59x_@w5%~yP; z1_!A~RZs@fid8`bG=;aS6O>G#UGP{xeGI$udn$hpj<7(HThw1n5iY&&9gUHzQ_!h* zp7bnjwHID&Ag|-Ce>7U2(q5C@`D-^WQyRNE&*mmC0{VgiqA2+>{Y#g(ZbgtOcbVWW z=UK+&eXjxH+Ks33VrwG`y}zcVYd^RqXVRC^P*6Am<@J5SgMG^AcMof^fKtNZ@X~>q znYmX_PEOA0F}g#T;$mfA`^;~aXLAE~%(yFStK`k;Ej$nA+9mRPwg%o(z}{@j+e-OG zB3e-kztL%IoSp{*W4kqHqnO3t*Jke*1_yO%fE8CI=ldlp^@Ql2H@L629v^cHRKhJb z>@^%AEn|`owQ~s|>p9aHq53My+RjrI)|n=bU_pRrktPW>F=~Cx-=gJ|A7eMt_O#o3 zCt&*hp(1T?cy}|IwY=zC+-gE@Infi`{b_Xf$?Y!~x#urgvXf2e<{LYTOkjICSX42h zok+iYPkePv&==K?s~E^KBUFewN3X*!G99-8n`e<7Sz%L6(4vV9n=TMl`p0RY3GBH z9>|MkOuuau#GbN8Cz-$GpZibGcnaG<461R@QUJz>f>MscL3M+?C-VB zfouCP@C=Se`k~#X9nU2w5&m9c^-|vca|4Ny8zn>tOw(Vd^WQ<$&P&w zxIa{eckUjU6cvrp<$~#nD{HW*C=UfhMag-Org(`rxY3NJ@_t`GP==>n<0&atdx6j? z09SmAIuz@fnCF=`KUK43_*JvPudvXJ&3u{w10LQla5XF1(?tjn@cu8hz5*<(ZR;AO zM5IJOT0#+NP&)M`6a@(dX+^rbTLeWwR6rU*L0TH5yQD!7kS;;G`=1*;_dECdzw?}P z?{oHf-L=+UbIvix7^^Do7{jFkAG0vitX`1`LvX`)MMF(-pRMUnl!v$99M|JqT){XCKtE(AfoK%57dm}SSMS;5UZEG zO3f1Q{0eTY}pUGA~CqM#^TOH(5%5o zjIMk7l!Yfx=^y30YuuCkq~w$7ETCHW-R%Fg7wUOfBT z#FI{s+v*9Gm5b!APjOb2${D5u^&rp zy1sC6rN75Z$M&*~+OEik5XOTj98F>LPiBvfjCRv51x{yq1zi98=i8v#IjPvFVGSmD zAAuPY#py_jnv%}9AqV;a3f0aClqo4LOTK6t2Mz`XRirr+&{V)3!wl<_4T%j7s}k0F zo?(Z>z-~YQc*J6@zq@+hX3mxfmUgVuXu_ZH{J(Q)@!hF+1n#tOg3qUK=#$M|+>?OQ z7cY#xu9@^aAfWfvxCn%Y&{wJ4YEJ-lUV^9#|N4y!0!hH){ZGx`>*t4KQ<37F2R2FW zy_BIsb}w|pOsC;hWq;G*hwE-6D}CT`H~Rmb8fHQ*Rhk zKXKMnd)g32?Qypy_KLxKby`6Qg9#S+J4V1U}1nF=ep7x4*wj zf8z!U{<~}@yhyGOs=?u1iarhu%jU!CPvbT>L(B$0FkX*+UM+GbRq9@T0!@UrdUMCZNVkzE7z!cz*U*^x^^?$*&ksC!$cMUNYpo;Xv=) z+1*nggnPFvv~1502+n${U<1ZYOrH(zM_1L>)^-~RERRfZXy_b&n495wbnBA^ETBxi zH3rXrrkd`qk>1J`4%2r()KIzPEQ^}DW^xWD4r_>X62d%{8`^TDDv5u`w_R8`N`CU1 zufW=O!;;L{xH0*ClNx?=vl-uH9oE8v&Z;s@bAgj{=gIK5PKtBt2a;i3*?yy_^6F64 zhTVK<8IOU1r5Nc)YL}RK`kR+n1qIf8OMM=5E2g;+h@F64RXqLD4pU6D+$?L|lyKTs zQH|f8?K9>}iXX=2E^9&xOcXEHQ5PuPhcd$(rKCv;b-usNzVx=O;eGnoHVz9qXVYn6 z65_sh={U%^nr}3Xhc~JQwtnRlm1!`MCccWj75qGE_{Z?B^OSiLuXktuv>e`Ym8pX)R+^IM5{; z?LKm*OX0HR*O%sfv{Y2FRQqBW6Ly=RU}aF^N1m`7a0FqK=by`OZc=V(&79?R%-yZI zS^b_*&#ZzDJ_ZOIkmO}m*VbYbg-{z9A4geXF&AeAYdog)#4cq{EJ-&8G`m?>m_H$wM{xf+2W_*$oXfHQ9t7a#BF%WKVANfwH^Ka-5#3~XYSs= z3io2ja*cPQ&G%)v0{}a;)Q%BuSj3_8B_=R}BLyO2)5LR|E@)oO=gYo{qhD>m^M@?= zRqM(~=rcKCVAeJSKQ)@Xe(AgNebL>4XLEK!XcDQ!PDd&C+C`VIcIURNv`3kSI}Gt< zavg+6>t_U<-USFuE7N_2siW7b9UjUFBsxsj2fN(vp)RJuwRM z;exK5+rsypoytC!A3h^CupDQu>dX3C_gsctTT=ex&GenAU;Mx`V$pkuns2ml6pDVqPk4npL6s$``St8kFv<5?SNH4%E})6>Jd#4G*q)zB73#R}srmIq z%WO{S&TI5?ldwzoKNQYV7k*ZkQ6`|``H;k-g$Xwu7@^}t`Q+n|o6_1^)}(p-hOKJE zcT(XttZlnj8&etNMxl35i+{M^qDC6(3M={)W?WpH8rQ6Hb&b$y+@0FvMbQveznDse z`%3G9+{UvM2PSztmM}&$9!K=~>e@ChWp|Mmzq8|nP*g}?M;-my!7AHv6v;J{e)MiZ zu8E~?M_fU#70Z;1?q@!(*#4OL-#296clk2fdgTs^%VaN%RCV=0A+m{M>_(=E&GiDz zBKNm1MitaN9W+ofNR%uf(<{cIj)7Q%fo%GgtS5xs}pHi(^RWn zdu(o-t^_Twe;ko@DXLZ4uteRkVA8RMTpQN)cQo)!dP_7R8D`@#?iIA^=Z!BsCvNlU z5>G^T6Se1gD0?$ZS?L8$L~f3lAjuG?0q!ku%f`d6{-)!BGCNr8u4Vm-c&8#jZ~OJA2}0{mN6GR zo^WxdL}}0Vk$uM~Yi~7%*5K;cr^W}GYzMuLx5e2l7G`|8`*#y{OgWvL*Mzd|C`zQw zgdTZ4#93QyY`*oL(r-wkFaYi-9DCZ^Fi?^~=K<&EH502tJ z(RR6Hr|x8ObBy^`Y=;^4-TMX?DelX%vPnL*AiiK5X!ZF^ezzVh1NFXB zUwDTLOE(AU`_Un$DY9{sE6Nv)3)Dq~tVOh)SB*I=IP;=3XZtRFk8U%to9}IYGMh9g z>?%gkQF(xk@NXPTr7>>ccYl;BW`0^DLOh@CTdj< zlh(P9dkbaizPms34E3sgun2^i`+^`$MA=iVwnQ&q7QFIs$)-ut0*JtLw>VT-{Xwyod#{k#Xz1JL;psO)X<6$g1T&Sp zGgMsP9uOpT1yml5gdo?MALYAzc=yHd6-9RYr2*O`ODb>fq!&s0_wt9QiArw5969$C zaK-tJ$1#GAw6l{W#PM$efHU+=UmyD1m#%ycQ%Jhi4S>rE&n2RZy=Y(=97oV~`<9=~7boHe*bGtpo9FAexB&{Xw=67Z0Zn_LZs18t z`gX)~n-ALDY}+>hyzQ#cqJl)`ZK+5aO26N^0B8NU;EwZaX~y9CxVqh9r@AXl3}W=S z*0?X5+S+adj*`93!*l68bfV7U<4Qx?0yZ)qrR**W<(me6nF+OtkU<@v)<>T%+{8cm zlpsxM5*;XQFTKrmtV0KR@SqioIpog_{D}>^V#2~h|7lg6Dmx%?zgu%!A>2RhXZ-Cx zLeqTd;`feNpl)|aLdnSlXNKx%*z1B1X{wL&&;$ICmX`_n%)s{^xM|2_XK@Nt{m) zhobo+4RWN&L45+N7-T$}Ak{;P9Vl5DlsI69!(W(Q$g#oGV|=H_fW;CZtAFyAS?K;& zTgV;CYMmS_!9M+&#p{#Pec}Gl(cbPb2bEgDd!O->cN~qZ{GT{X@Mlu)MNV|uLf`g3 zb=%3=wR)+)4;>v{h8rRIdp7B%6NyEr9#VXQpy=-$3K%|RAvPkXL`{7=eY_If5?`2F zyBIhG0vm29R920a&n^LtkidrEzixx-!GF3>|D(+DJaY3FBZS$m1eF$ynv&pWOr+c_ ztiDJbDr{Ax8>jpc{_8(O$NjH<1N@lq^lq;MZ2gZQ1m5EO>1QG92lz2mjKstxAbI@P zaed_Y&8P2AI|FbU^1r7^{5SfI{DG>I?@RW|zkp~MK-$xnp#sI^3EvcCD9Dc!xgk81 z1j1WnNZiZAH|-_L=)HQ9KHLThr|ipMI`O5#YLRUC@h53&K(OHddG6vrGVx`Ec~m!i z^JFHl{&O!cP6r_WbmTEkM?UPq?NgLk{p7=V?|VAJcTY+fm=k{w`~7p+=D&XJe{z`k zB{IL10Q`eHXsJ7S!~jg>G6+focRzi)GNH(jYxMe7BSm@c>9@mxc5)1=L^!tg_ZV`b z>!+Xri2smLw1L#~KYw)LFGSLCatVKkN&n1~f7YI+`=<~Gun2mR@7vA^!uRpd0dn$?o#&`(dtlLg z=y#@|*l+=&HzXpASB1{8>$PNWvg1iPxdoE=&AAlT%pqabSP1#Ga8 zKFo0{t#jQnV^jND^WS9;Ot%jWrBhln)D4k>B<$f z8=JgU%220&zRt$WKwoqgDu^fUHdo~}S&0^VK+A-vhUlyD^}oFFT3aXsAP! zxpg2|h&x?!6kFjsAq8%CqVpGSHq0%!aVG?kM`5{E-EO?5ow^oyUm)VqtG32-U)LnW z$%YC`jmQi`WI5bE}mDDjD}KR{ZYHao0cyFX!jOPW5z;a*VRs$hL)z#V1t?QutQt{hdvkI9tNRv(LdN^ zP);9She4?O0*N%cn)UM*>DOcz17vpJ=F7(k`D!$du%4ZuNJAY(kAc^rmi(d9)Cv0ZnIiu(ubJh zd#b`z5_*jbdVRmwpS(@6Av$Kf)$ecb#Z;Qn-0{>Z;!xXfy#NySzWoD~3X*fn>+(c$ z+4XAqNZCr?Fb(+WuCX@x>$-}HLCvRF!>_#TL*0(8ZT#aAS4IIAfG9g;rTr4N4tjVq ztoAuB3H6qUN_ls;(gu~tnUr?5+up7k&&Ln7yE=tdZZhjPv9s6ih|5pvO2>V+9M;lX z-HeEDQ44d;El>WYjFdNyg^7s_8{eK>yYTicyL*oXLDl~D4ZFEzhcsUcPK^8hXah8Y6!d~KvHoATxiyXJS@k)Rz{m$7|G^Df3ZAs?IH zufhiQw>>D*Z7kt)f4A-~W+>+Ce8t2=!x_4Nlr%&GKj>4;=Td414H-H=N7|?Tf}PyQ znz;8DD2PKRxhR<44gepsZ0pBzsM)Vf0K3#e4}nZejNGwVF@$D zqk_6m7u|SVvp)Y~yc@E;WWdEKd~B3ZJ6TiVBS#?Yep{TTBAyc4S7vv?j4yiiyIeL1 zP6hu62FSkteL1v_jN^!yA~G_3>-&=8%GOw-;L_#JF>ea3=*NS1SjfNH)o1fS3)3V8 zk=~ZAxe0pGudQX8rhos&5#>uTjAEq2h?^hi?G6@ord;5&2+d*G23BOuI7s;(sHmJr z>ooFGSR(X()Y>ooNQg6`alxzo@}G`7R&zad&z&cJYh;SA?-SBCEPF25L1Q75XgTpE zQ=v_pQ0rvHIQpf*8-Q##{agyhmGZy5;8V%kpAnHm$)F@$fQ6u{jb?m$ed-I#xf+aA z6MHLY2u|o)d>@m+J#)OXr2v5FtH}Gw&E?6^F6!#0?QbL$O~ijlEh*nMZe1mQcfgPh zdrg_P!fZ}&)nBOU0| z-{e60$b0kTE`C>iWRxw@#Xqz3njrJ3r4nPgd|;O%efSoLMH$5_B^q80<3Sf}aH-sr zk#{}qv%9BG<@K$rDMlh^jl`6Ogn&+F0$r@eUQ@xd;;bn%L{$} z=-7b9dMvfis<$kfawOy9bPkl=gZR;a8iU&Vq(})f?X#o;GM=b?@yAfT%EqRfufLWQ zv9Ph#067qV;xx!qpLL{-W+Z*OeONHpKPcB=a#k$JyS-y@G@OL`QGo8hzIgYWCSv=!TG;N6g2LvB3m%c0OZ~e*Bo|UoR_6xRcYn7Qq-*CcT*(j(K zRsCjF;fRMpiKU)WIBp*&D^wPJ_3Z<q=2)>c`E=gjL*^&>KLd&73sn zrvnx4<%`Ue2kiqg?b9#LQJsT#;Vq=g%KA{3Ln_A({<(tvWf_C_&zu=jkJ9isRxZ}6 z30+su#Ey;r&Azx(_X%Eq;vS@@Orfw&F@4tjnxAyAYc1hOX1>1Hh-9}fi;)akdzU9$ zyB0oRx#(@arTbQvB=OgD=v83qrCtYv4%`_sONw>{kJhVyToURsuqlGeCG z>5ZPC{~=}CT2o~7`IWclAfUg5>zueKB<g{(eRz0_8h#%F)CMmySE65TxEgbXdF>qfw+bU;vWpidKFY*P0LZW) zRND5GtgI&P9g^3VzV0lL;q@#K2&a-{m9ryNfd?_sq4EN`4UAD=(iI- z&z3~!G)Cslc72Sse?^rl12iMM51a2uoOgGrb)}hzA$(k5`C3AOh33hDz3}5e)Q`W= zPf7~u!l{VDGz?iR4~md)t=Ih(von&cmVEb%5WLQ0GaY_UOZp_La!=nZ5Ir~_d>t?A7%{M6|5osrkgX1SG&#G$WYraioObwM*vXr#Zm z{1u~#`Lg>R3OH*1^N4yup!j=<2!_{E_L-ekcd6dN)dO z)xFSlQqTT%Xd>am`+~nt%5fw5&36XQRZ7%wb;0MmWl2!h2yHLBfIuhhE7eZ--4@IZjO zlz>JOO4g4*bUn8I{3H;j3r)OXgr6V()L6Uh{fowAan8X^*vShdu4TN}85x+LoOZdB zPfNHcU*{pfj?zA^V}Gl}HWEcggDDeo&-ENo;-pH?Nw@RHFe{OsK9L3RnNFQrY$Rjj zu@9ouqv+iBupE|uF%PmAKOq8woQALsMLS6L6?V}(< z@%@^mti_=MQU|LkkrlUg`5`i(H+nGw&Ue|J;(0&(hV=x*E2w%ZTb z5;fmlz_p9Vby6F(iV`{$)GSkR9vjIiZ)@5e#zZr~#baVHgyj(iZ3_GSNpUfRt&Bn~ zRsHgDmiLoR>snGwki?U-ZSNmN)HCTKDA<%XC7)i2=Jdr}KMAF$E*7Y)yLdOK=;tUr zTHEG&($|))gQR`8%r!KGVYpHWPG1Zu_yizT_AsfhGlQzZnOu21m&9oP+EUAM_20x@ zZP5txcrdgTzIOA|QBHkN=^NJK!*YtoHPs)k^H`a9C$REPntU#G{2JShJqB1A>Drr8 zG$`5`Y(${>{2yN8OU;;^vrTfucJAAgN|HnUjX1XA$3&r__Z5{i&3-*_!n)RGFCB)O zLP5m_D36Nt-)1;aieYYXu(@PRKY42N%1Cm+Fh!wuU`Xaw$mDxIR9c;}Is8081@$lV zgyXw7HgF=0J<6@P?_GWOd2w35s+MrX@OU5w^JO3-gWz9q2=}Br{xTo~nH|M*+~NMa zSXetxe%n;f2+M@rva-6p-aTL2 z^IjV%pa8y3Q94j!noru+DSHnl+@D`CW$1@j+~ntseKPUD-|N;RhhW`^RD_KtXpQJD zSHvW=dEPkJ3EE!>RW5lba11LwqB-@c0MZb~x}hh7vQ!o;eCVT`yN^4`FJ27TU#hsB z{OXHXK0Wcuab;vDHfEoZXGqhfxl-+rVa}2Fe+Z?4Ck4ppNuyiY{VzXf0pP-^8er$x zVI#a*Furhi-9|;o(*W<7wRJXfR&yO<;iGX8!Ql98&LjS9Q$XI$e)s&gyCmd9bnE*5 zSu&RJCsph>k8ZDu4|-j`v_~j4KEM1c8E9atrv$e&&MPA_*K)4fSOQ)XBb$VkXi;?I zc%XzTr6Y#q55uLKI&bkmog;sBg~1-y8~emABcwB$W3_rgE*@mc4eUcJW5uQV8L#JS z7{3Kg=Xg4)gze90%jeUQ_dH5`_5LvlaVV?RCW2%M`uruGal-6yaN0TZLPBB^-N2L)0iurk1-7xbpL7t*r{lilz zdtO2DEyhLtGxd?v$8B=xxgFuhtj$>m#dA5~{x6$Z28yKwu6uMp#~B-6wL}^6ow;MW zu!eOZ6c2d|d|y3vph}|W=j`a-ZVdi)jg8Hx$PwQo6~VJ_m;8m?K-}D%X(a0X#zMl1 z|MFM-&IHo2->Q|i^B671^y+1qD?D%P$(n?)J}u+ev`1|3H=@yNv6s64>jS96X?Wc6 zt}x|56E#J4sa-kt_omCRTaQGBdg(~F>I1caMPY|0fYUsrz5|Ppk`V5~em;fiG z)H{Ku0kkS8tMxKq^qyfvyIniKoh=QP9ULh-l8TDNEiEm&Hz>wGu6woDV&I=SAf~)v z7E4|c40Rfl(e~mm5-lP7uMSqdBB4VNrZz8J96&>Kr(krWzQ@DE3jza4uoqHpXn|Gd z%PCI_@^GckUStvrs}d-2iKO(tkAfv70uBe51ayH?f0~txow)HMICL7OTYo1KFOnMH zpnUH4;xh06h{wl`Mlx8w+06%7XbB~nFFabwFhE}xcUWow3=PxWM{)hiPl+_Ek7^7` z;_w}0o>?_`)04sEl`AKk_=P^NEANbvo7fK0Gfek&fd%Q-nS^ zua^Pp$^ozu;WHa~Re2+m^vooou-*plAxw%VB1Bw_e2+aNiOE)d!0nBGOQyIhl9=(*jfd zh#nPkX7E0?hzA`QOd^(`u7-iR2yBy`P~+Evj7|oS2n>O ziXXSE3>;>v1jZ$`y(MN-yym*9xd9yCKm^`OY=%9Jy-TkIxg z*Gv4^(`QlP;(G4fIbzqfi^0@^_1?8IEBkc9p&nN-lo$D0 zAdvr?!9!v7io=UlwWZzV94RT2z6zC9j^b=m0DKsg0^W?hQBGTHSwc}nK=axl^!}C9 zAB~Mv9cow~9eLzrfDNs&@7VZ4iNxGbd3Oxxj(gn}?fK z3QGPM{=s7lmX(blU3vrd0>3>}U-4R9VZ;D2Q8j0}XD!vTTR`U5lL9*z)N}u4H3|qEh;1E`+%@IE@_pS28|{}4R*lP}Z*rh$I^v%-MO2Ph ze51?9#y=Ub-!Y4LS%be|g2e2op;3Xl-SXh$PJYXA2FX&(<+!=-=BQ=p5nKX067NUp zr172E6rIO-W8b%{O6br&T=^0;<-ox~%h}t;6VULAeua*UCqJyg^WVA~0GiC9EyE zGXH8EK3oYogYEXv7@?M~E^f-hd}N=Jgk-2iJv@Mfbk4RhNl+ z{uvJHF>J@(Gm~l4DR;rIZ49pUqG!xG9(%IS+%@M_NaDRPf@Y`PO)8hGwgT3q{7z2g zKF%8Vqi+~+Ek6~osfdHz2x)zEne7J3juwc7`IbZA)5nB(5*=8QCX&_a&}oAN`jOwusvw3;Db9)!?)kfY_}S27%r$ zyJF`&@DLRDXWL5Arebi;b$dxp#tCu_!Gz5_Bj*RHqvkZ{!G47@9Lo}zKG8GKf@cF?o3mP=B@{|$Y` z{LI1nxd%=qTRNO9uK*wdQ??fXMXHpGa&6auiu$kDeoHTc#$#((} zyJ!PF*cRGDM+dt=7FK%mXdAtP| z0tnkJ9+wx+zi}tK)|!1(Jn!Tm=D#6HU(~n;V`b%9$izJZ zUI=L>>|M`lW_8*d8`vu+(>ug(bmctuQ~X5CO4new|2D_Maa^o77-Rfg;sb3j zr0ock@dfndU@a$FR8~^*@s$aFGCgmP*g-Tkvv*8@E}U&J;(buhU~g^IX7tK*nI-BF zQ470IUKbHLIxYWz_RCVxi*079ngD?g67@F;*#Rro z<{OQ`4&PV(8()_nU$&rl<2=9(l7frL7{;aE%ImH1jSc;H4t$KGk=OX>^Zx?f&s3$I+_Dr2Un(b%ko(&LmgW;26i7AU~di@FB8!z?yg@ zO+2o)y`W&!lcpck(RYo3+Oq86R@lCs;>y#ng%AlCV25Pm^jJ|SCV}gHs{BH@D4OwP zb88|*_NBivQ{?086P^@JZi_qO?lFsS5qK^Suu)#T_BP^tod>R235mc4pOv-ngQ(dr z6RhN-4QpJL2}mD~W5BKdgW}mNF7jf~h^;G#25V_}kgzeC@Ia7Pzgu5o7j@7aYwiVjh~%Acy> zWZ~$o0R#RvT>U=;n|BL6Xj*X?QNK(a7hbdtS@o=N%gWv@+_(w8hUuP1v^s8Uv}X=j zJMLReUxwaC6&)cuZl#cgo!fl~822-MNh31V{4)MfS92)SMn3pG4rodB@`CEqnbsP` z4J1!`6Y6-GMNrD^%@2&ZBlTU)jj0RZ{5S^Fo_-#5!fGqiDNbfb68{7HTD+;J#OR1m zh3Vs;1EtG!C)uWr0*F?x;~}1;=-_SW9Gg6ZKhtKwD|R@+I=tWctXg(88k?YMWRZ${ zr{VgUxeVUvj|UaAUaxN}sc4lO)S}1Q?}dWJ3@#t!`gwzr5l~AwS?o;?;L)C* zLR>=?%!+JJf&jwq`4)`56|v3h@iCLBvpSL%z|*~+0Qr~c~Mocn<#%$Hqn&u2StXrNuc2>AlYMak$AHql(l&@l_sJ5(hvAg-|v ze@0m6E3GBOMflyLz-?5?sY%N#T@YHrZ9|2Dd+{-R6dym*Zwfg=rTk~hF>Crg-<2y@ z1n45XKE1~)cKUt6W_=CtnlqlB;+R-iiS9!`Abktc_p_3r0;mbGb;fjuG_)Qk&*1Kw z8xtMCC1m}UP$8Ha0W+N}U@MixNb{qa*C{)|%LCyX9=I;#Z$MG% zb~Mf=BCxd7(h-qQE3g}8o064!56bvPm!SCnUB-L$jK1f5G_)yo`D?-4dk{6`SZ{VX zt(8RN*wurtB4X6&vhw6$WjT5BCD!RHXqT;mTEdM&}UaXMvL zcvJh)()TxYJD%UdD;{qo8TFRQr_}E3FQsmmutp1KUJb0y0t&X?5zxgN`%ud11js)lu7Qf~0mUvAv%O@)1^nZx+H<6wk z$JIhD_NxK2$N0-lM5@wW<4T2C(=<p&SxU7^|zR>Mk~FY;ZI2C>nc<{5#GgRekBCUq?}|V?0+2idKOCFkYA1(|7a+ zeVWyu^YIoQ_6X0pjh}+%3>N`nJL7-DY?T(Q!3qGA1`M)QR z+v*{r7Ug3c9Ok&}5{BWds}i6IUu9waupNSa>zjI%4yWe%cg@d?L7u|3>TUhwuxAU+ zFCx=Ck62(^&pE-uu&z`(soIoNG_c=L#PT=m_3PkKE#?EMc)$X#nMTDJ2TKb`?osa8 zzO={u^@0mmS=hlFF&KO$Jqf6RyHJEh59<#ocgib0j_a7|KK+dW8ZUHz;KZMUEN}1?c%v-6S?_OM zo37%llsy*t9oa4JfBv90X^KOV#-JSI`=Qd(b)e!^JkF_EQ^T*mo9VM#n!Yn9EGRuc zJ-=-&34O*l6rAWs9yY2UT@)&|qW1sg(~0F$#_?foTHN%9WsS!2;}l|WQm+O}mCjN_ z!u^z2$DiFOsq&hS97<3jIU?UVuT>GsMd0y`-ZZ%A<4c7oR10*m@i<*xjRmAvVGPn8|uJHf=Xj zL7~z|-0|gX6rHGz0Lb_BzkG>_`QI*`x7*{x*a>E9Z`~#$rhSw&$yig%Ww&y9W1$BR zDXKt%2*wMT`%}}idWQ{}PRBhz1?UV9W!q-VhgMgQXU3*yo|f{b#K+xxKsC1jNk>In{UBdtK_vcs+_rONVRb zx9PXTqR!2UrjLfq*P8=hz2DieiN)&A?$af-Ti*h|=_$n2yl0Nf0V{G*Adh4o>W-+K zqu!^M{W&%;NL|gFAaeG&|1Tsppx?qsk`eSr;PSfB^ek%&+LqWuv9rv9cq@?L%+>=J-cXOLjL zyBCsELbWa>{tRsl(g@cj>Y&O(%PNrIoGoxq{vj_enG>Co-e10RQ&N50)Ww=Ya67_-;K30#?9=(~NuVWmYQWOJ{#zXUt5 z`iul@{b91%m=+O1PWFA58jO3xPu%GTzm+%4erefjo7kO}A)uOn1CfO|)cvpc9ML@A zQNXivmn71}m{xvv&uIgfDdm&;UR=!9wT55%hH1KbxGNp!FKbboUH6g3L;bQaJ}NOK z1ZyJZ0sRvX);oNNb57x1<{7lv`t|pw1?u1TM;qsQtA#e(a&;czlJymwHN(q?UTVjk zw*pRT2gWa#v`VXVxdwh}P@Y(jf>+zWj5_aA+jsymolzzvaBo3q)a^cy`6g$gvCr*Y zKjKNnOX|9|=e-Hu6P?jG;PnNIql(}^bYgfIL8@QEgdH?W-f|Gc)=H7Y*VvqB;vNM(GcBxWpO|?{L!{(*+mW zv$zC>8|Ab8A&3E>@_}v1yl;`=bZm~fg@*e$-e|$-_;0O6Dt=OH?KpZk zoW!)ESwU``;^N!AzX03wP!s642~pA1^nt!2bKH<-3XYJtM$v4tODV`cq@*VJ^%Ik# zTHzrO*TPHW&oe)kmARE30{NcW<|sZqa1?)Yd;NCc+%^B0N}l@qnn08qsiQ7j{ZlPMHZK_X~mEKl~@I%+93^$C= z?CdvdVLiM>im-9J;KO}}00~rXbhtwtl~BIyUp!sq*S481 zX>!CZA*(94zTg-5geQ{C9OTef#kdfQHrj*-A|$ulK6o=OV^rMt#%9OV*xUXc#GEW& zL$1S)hK6X7@+#H6QsO^c7m=zBmOxdm3C%O|Tv%Dn8Wl9T&ebW{!I+c5wr`uyfA)*# z*39`64@xjw{S#z@GxjD_Q%Xuo?P$S7(bIhPd0OD1fAHDCUqXT6E{`;*_+HLNtEvci zZvUD-{#0nf&b4{xcYI^B4JR}7Ee~sxVvb_ox^9w=HBe1u`2_S{kY&*Dycp2x=2t4lusf@H75Y&6&`jDXRjlsWwyo70AWNqq+b2N+~4V-w0kR+FYDQ}3CM_Y^7Rs8nNbyi_2Fec6U zWgaVhhkx_{iasun?i-S$rIux9;$1vY#k~*=foG)QLNHSi&75bI$+#DJWpOB*JI@E10n{gU-L#q`+zMv*Bu0xntk% z?or;8cQv!o%>FzPVKwhVuQrzy&=Yq$tu%NCG(Cm~L)Eeo&68jd zBzdfJ{72@IL*b#{y|f(r{dl!vr>D*rcl8iQuKKh-)AuAhpB2m_n)B33Qd>g}!0mAqw+XXYkpumF4 zg4g~YM2l;h5AsG{*H?uSdV3s`+@rq;oiBysQN0g>3m9nAfwf14*1XdAbXP^hT+Y`z zGoQ1#^c?(ktTyLw!XtVv%Rq0ftgP(1ppv@Hvll9Yh~fCJMK&vBrKStd`m$MqP-y*A z#8}k2h8}@a>DX_U#ipo_zLs@?3gW-N(&d8w?A1&UW&7?IXsulgIw5*|x%oldYD{8N zIMgjs`sKIw7~zo5t(nT-UYEME4HgveqH%8pu3;%?N&crEVxay{_&A>d7DAa}$-$;M z5^LCs+r2VZ6BJR!pAVt?5x~n_X&@o%XgtqA4D1MW2Qu-B@UWoxaAB(!MqB}KIBY@e z=E0Wn=c4EF%0oPFL4-@Pq9BP;h~~@Oqq##X#94|L#Idu5(>f*!xS(pBr@EWjjN)bY z_+C<>7oO*dy8F5hT*jYDt{}Vxq-_fpM9LKb=_>6UWI-+4VA?3xAzzfQ0EUV*rCYB; z3L>NYKk@H0Q2p7e1mnrXpMoX}u(3vNZr*}@aLa!lMObDO8~SaEp7ItP7NzSRb<9^E zI=jKBiS7N7dwofmAo7^w2(s}%OB(UJGw5TR6dm;2Hi^?Z(rXkk!drxo*fn0KhTMbo z#@>4fx@+7{b!uk&dNQ%`oToOPoO|B*XF4k_mxZ9Y4mQQ7%$r`?6ETpVu@L6U2C3cj z^z3BH^bbF|Wm;EZhG;%wx`pdKKhdUpst;KI3tl5Ae4NfDIic7kMd3j1?>;sn44vAi z#++&!zB>ae9$u;e#qmtmuniC~+4ZC2*hpv6q-B~AsLD;;+u?s#{=Dw*%F>_%vRmJt z6XNm)6y$=jg$3Vc61x0Sb`E;tavXwsx$JU3(fuPy>6wRM#5fMbxj#R*2}j(v8SUon zF-BaD^;%<0(N<1vJWJxn-K4-in|S<5G3+_ywy{JdP(156teZz9r>Mx?px{Cc%gwyq z5o}}!Wj3mlA4;7CnQ!niWV!z_bOdwLw-47t6SJl(v!pGw<35}7gP$k9rZ9`Xe()sh zb8)q!}?Vjkg~dU+-skl-tb zbN4M3BB1LF`l9jA{i9htpE%js>w)iu)KUq@ZH%2sqq=T~i`zz>myzb%W|rdo_cv(` zQ~BZAE)GIJGDe>l?_hQTRr=}o-8~KXXNWS^6buBrKDrAlRwBq8!Gwp*tFwf)ujnf4 z-wZ8PCJ3-U(t8TktfmnPwi#Y(WPYo3iJo4Re^{b23ZuK|8;bIsIo;^%K zFTvZ276@jqu|^-um~PJv)-Ub33+yL>o25JwZFIp;xETC|q4`wvlkh_9jR+@W+Be1L zj6}6NMOUk>cb;u&LiG)Qv+Y^4XgiNnfS)J!8N*7)fBSisI&C;Zk8*``$+He6UTgJn?*z)nB{)r5$6E#ZrUoOreF9P=Km|9%)qpOHSTP63`L0_bU{Fn4N}mZ+>HfA>Z)gtQ3_hT~Da;e^T-DyNpYYv&OsjLZ^fg>JFr;ApU*4XcqoM@DDM=}HSxv;?v5erc_C}** zI1c8p1D(jrgoLW=+kL<7iUIRv+qIxQ8px-FjnZ<>gk3btCUSbkH49lCXE0qHTjO!odrSfK?7;*XvE}lUcd*=+EeFYCsu<(ri|13QD{@cPc zJmD^@3`Yl=YD~%{gg%Yb3L(YW0gDv=zgkb%Mautp!)%y zrgfmUhHbim<?;N7;|0{NZ(zF* z;ih#RgjX*+JfQ(l@rK%rCnj*R-T2hd*cd0^_vu{vO~>VK3IKv>ltA=M+!yi(Vj`*6q?`BV5Njw{oZ;{%?pZCZ8xHfTFlem5W~t?R@35 zft&!H>)H+Apmdf!{$!7nNpN=QoTkIaew6;x#3;tAX@cOdowXOM|6mlczw8-oY8r7{ z2i@A`8%zVnHxF#bh#=WzH%Gd{=D*S!8nZ{gvmoTf_p+xpLN8BR8cMIL_!6@+hmP|_ zmWE21DIdk0Db7G^5@9fYOfX4-cB8<6>OVX}mXLd2`En<{z9-3FZx3#raGv!ipvBDm zLAh_fujjv0T=hfgkrYQ(MI?P6q-+#FsRWn5E3N~(mUnblqO*T_Pun47EcJEy?u^Wc zQ2s~(yfMXJV4q|?qe1{WXwU^e``m}&q3FW_tF^C82A&kbw~v)O#T$oSsVWl_)SrIB z-e>Uf0(EL&xX4jq{C(X^o1my;)rKbt84o&1!S`KD*fBq!khU=IjUmR1^=I*nJh#&* zz(Fv#=#rV%Otj}_=C;*XXQ(>OyLcV1<`D59QO`rhx%i`c1iAu5x>0Q zb#}rz*0~?`dqUKL4x0I~jI(_TSukM1<7M}Fc(NxTWmoi^m0vV<&w}N*E|dUc_&1>H+}{$Fa7vjs(i+kb62ss4vu z`i@~BvU|qLFB1KmLm^4KVQhFBL*uz+oE?-})c*n7`~h1|-Pz;p#RaSR?}8vh#dYMm zfmwD-a{h{{f$YsjtS9_AD2(8DIGx+^>f5&=H=mCg8Rv7D6(+weY557?G{U;56HJbs41+r2K`pE0dQ7%))9li7 zvGN^%9;mK0doP~&ja>k4->b16wO)IW8@B2VIk&Utc3>F1d;d^SdMXpaQIHj@_F3+a zf2GYB7n6l^s;)nKS-b0Cu3ihRjJ&m{g2 zY6m6&eUYlSkzFF>!W#jcMSKBCwps3|StcB+REf8Ahv_^x*)HSjkd~e_{lJzoIxY_< zrfK>VC9t4Z3gwk2VIMGXGPT~)q(&QGcs5S@C*#~5Y^10X2KQQ<-u9;5c6+t+WN6^Z z{1P^?gcq1n1$*m2N^8CPviMEZtC(St_u=nrz_cE^7SO!Fj1{(*s7pFXdQi;`gl`s9Q_DW?HmEP0bU@LbPRVQ5>XXTTT{f0~?Ekg*)=^QeZ{PPQ3ZjyVL8>4~qe!QMQqm<|0@4B!Lra5%ASJ1E zhjfFKv~&zzBOo9QHRN+%gFpBF-S7MFyWT&Zo3-{{d(ED?@{A+C$LE-({>i|?(mIqg z!emiB>$0hw#h4TK+bvml3Lv*YZ#1aq+oajZcuE+vFDC0f;uC0BWs)RRF z4R5Bj0Fac{VyF5;3Pq>@F31b4Y-oaZ5nxsIhgH1A>~~OOpscB1L0{|QSu|ffo}j&2 z_MqcKc5>Cg>vuAzbeEP!fZ4l>JrP9a3wjA&$?}}ckO9ozTT&iS=Z-*Ky7+Qe0hTna z8&nX^^DE#%+}_@B769R}4lQi3VrB*X3(`RTjqt%rHn*~*XiUPJx|ignoh-QoGZqw! zr=8iQG2A;6)zzjzVO6B{Qzhlyy|(Ic^r<}q(Rb9>pz|dl(o5k7>r}NU-5&%RR@#=lm z`J=o7zqQ^ppJBz0K>tiqOAebl+qPY(husq$I+^<-7i>+k7OgD=hxGpPJR5;RBH@p; z8V7_E`L1(I0w0%%V|rIjLsv1_TflJiVcyqRK^^0zq6e0jRX_ zFqSwBRiVZ`eJ+7-*u78rUMam4H&*EPm=%XyN6jM>+-&sT8R8RyDs%kN%te~vN~(XHp-JP+L67|+NADq5V?YE?qz)-43hD7G*#W3fqG0g>^Lr6D&*hY z-6Ez+Y37pgpSYA!diUOS!1Pq?DOIO1=&1Cao7AAm7XQQn-WceLsBq;>tFFKWYWV_= zt|aFtPF5#_01V87E}j3pNXr{Rp&`pm*6Mzj&Zh6_(%F*&4;~PLM8t5&SAP2J?4%k| z`4PZpPZ1kofq5*4$`Vn1OuF|kp6I7X{T~in;@GySE{DdH{cuzfM8;Q^TsPdzkgsvR z^5V9Mr81DS$AZ`m#~*q54yZB;r|*CT7U13>8d}|f$dwTh5&j_e@?8+weBSKtA=3=v z7VHPuX-mwByinGgk?SWwG5=*~JjlA6ml1$sqoc1zkX(Mg1I7CfTa|%I+Dn^Nn;kZ0 zEyMJ|p8+cKfpwhfGHD*yP8ePST75t`0jD)hJ)^6xq_jelkMEb}0t^`iqevor3)ISo zjWuHz;&ql%znRi6bA8?nhQUC$UfF5qD-IJvL}~WJ2f%s@2C-<fpYxK&uw(g}vM6tK9i!py6DUAh4BRIO>v@OoYkEh^6XFm7 zm>1>`JF8r=;rkB|qrFw>vgWA534w>54faP(k|F8w#I3NUHQIAu1lBebRbHOhC2C)a zSmG_Ot9ld(cI}Q+lM;`ys~)Rdg!FiSN~HdgL!UJ-I3ohl+`oBc(ZVq4;%+T$pYz;3 zzjJkAi`2_fC?Ht&xS|m$q+Z8hbkohkUnykv3=H$P_~|m>J5c9r;ydFfGc0CA zg@%Au55z2&AUgK{Yn>CQ2|lB*{(lG%l4#y-9eTx5kEYo(%>KP)#!+)b9QGCzNpssW z;C$`f)oA;ENLp^3{l+$BXlttV6OhneH`g&RXc5x=zNU1f)w{|c_IUr}Ga4eV#yhX0 ze=oJ>k=&N{ENkqPYfl73AuxwP)#annDMZ9AIH(s4WSl@a-3Dc=OrS7DWtrJ{6M@A4bYxetOXc;Cm+U!jBMI_Jp>ileY9O3*U3nHl86KaucTn~(*TL5!4p270#FJmjvI~&ys(xYOxCW1 zOO*9#9KvUJ^rr^wOtoIU!%;6&$2pdrFA^(=ZIZ7JYqPD#12<~{NB zkS|vWEs4t3HKRIXgV+2r^C|@5ddC1St z&$L$2nFiGv8y_ycc=6WuHsjqh0_9f<_?tQPx}eAp6Efp9ClBRoitgS6y~Kdgpj`<% zPXc+X8iqPbSA3Z%^!9iKB~)kX=ZBLV%T-(wn(^k~k%J*;9FZ9)?p4~~CMV*7D(i4} zs`9HBH$$Y)cIC~y765y!9F=q${O|}-Ti~545S+zd` zUT0@IfP>biQMe-BjG5lOXJ@+zjX$%(+VV;jP2YMJBt$VabhSxeECPfS&{ZM|)NbQ} zO5KD$>OA)x%?i`zlM6C>OCc&0g>Jk(KyoBvRV81ikD1tE-n=DN?*Z$EX-ygT_9GP$ z0J!UZ8Ts0E(iyZ}pao;3uVN4(`vFTOkyG)Op`^%0g#MT>MKQgdO=7_I1nSou{ zLJr<%i^+(sFwu2?eCc<2iThMEodE}pU;iU^m2qzr(A!^yFqZ$#2Te^oK5Sw7CDR#I zbkC-2hhEj1t;tD*&o>1$iMR+3*8xN!jdTqvw6A7Hm9e?jUzup~_8?z2O%|1hLKW)t z;4T$G#FpBU!qmjQoc(47s|~~l9opa#?a74psJ2bYrkNUqCXct?bg!s#f}$7HNPGB`!DCEyqNlgz6?6rdzb^Dk)g4iYkH$AbdySJAhaK^l+!nznZQif}vlwpNK5f)wi9 zVY0!kZ>MQwo3PukOj{q6Gq()vuv>!v`1ih~OL)H-L<3fqDZ8rs|Nq|1!6GQY_6PiQZhu zz{`)X@RpjIo<2kt6Hpw85fX(_Ka9y3-vT}0Ju8!%+7O8Ty_Nta{%ThIPtVdGsXPy{ zXQ?LKvl8-IyIIWS3NC(g45xU3F)$lK{&!CI5?rY}>UtD>8&*@fMVfy4;hh<}l_7*i z)s{c)7PX*EQ_sM#Zk=-Ht(v`IGr&h(5PWQeZ*|uu7V7oBl7DE;+<6cttV6(@?qD9c znb$Ns{{^r+vqLBPA2D&;;p!yR`0Ib%`ASN8BXEZ?I$1g=>XC|===wcQ&a&aQOi%+b zT4dnbnZi4IJThHjFmd7f=mn2+iM%yG?h`wdU-F6$F?gq`tYUq8DgH&vw*iv}#psU@ z0h1QcTLMAZieYY#>(Byk0S5I)c6_h{C|FrWphL^Gd0PI!IsMhoUv-6;r)pB}w(e|t zO?hE`&>V`?q!v74zM^v)h7~8I*OzU0l`~h9c7Ndlkpv)p0ahr`e;_vCgsKJF*S4LP zODeLg?*PtEtH*OZ!c1h1rKCe?=5=@Nj&BDGIS@SPKJDyciM%Mc+o2&Yu)}O($9++z zxFBhdvKfbN>hPTyAT!bZ+(Z4CU7}sw<8-AyKeN&9Om?3=uDe1(DNu+7LkqIcSiA&a zq5eSlKJBIk7U$)WdOBI96NeoU~^n!!vMfp zBG(51t>l3aD+CVhLR`a6xZ#v{BmQ;^y36Qu^Q)&|FYdf}U%ZR)=~K%v-6xMV0Jn%B zw4R`#*O3y>>wJO+6H#U9_=TIMmoc|1RrvuljB_V58?nlMn?%U^A0BBVHi6@E$?t{Q zU?%eo3&4cB0~kpGmCwF2m%3Y}fQCeCeSVg_ zs4Dw)|GsiOKtH1<1YMEf7j>((cS;TgbE6tGww;mu;H!|15)T28}4RGNvhI1@nn>CfnRj=IZy@TA7B{* zAiIz+1R~jYd9y!FED{l&%M^@{#!vx3A{$2gB4*}?ZMXrr@^~I+O5>ikyMj>IW^s=T zB+(u)F+5c>`809AD(`gN!jlXeKt3NsWi|l+24$}R2Nl-@8Af zFb<4&QHG5F(e8@xU=Ig`>;3~?{9m-9$XWF14@2?)LbT$42ppgv1V-*{4Y|ogm4D!* zmZG5eE$~mY0YE;_AdqH%7#Or5U7mV*$+$Ohtq=u%bQ$!OqmzzZ_<@A5qL+b50RAk6 zF=MvI0z-}k#ZB&8?Q|3e{NR86#n46&W1`2|LJn7#DxZVES{BKf*ZW`m3y7wQfp4TL zm|p#-yabH*|9t)weEzq31Kh@6bS>!dG}o0y4$?Rw7 z;h>gKV765K`7$nsJQd*Yjd?_Wk1eNoHijS=>px%q{{c9A32fl^cAz@%zra~>3|!U; zxQgI~{CTIZK==@1{X*}Vp6u+7&tn8I(r2IjA@11(AvpUNE3CT6-GAdSEzvn+O1iCFhoZnF! zEpjdZTRj#y8)#&FX`^$6w5(KEzJAv{zkH#k36my=i z3t=T6)ex@a`2muqY#w$<^~LnqM_6a5&RLr$xWuTy58<1M&&*lmJ)PXwTOH(hT0FCUcTWfk%kZMGH-bhbdl?-cfTe09zo|bCkd0=lNB)qxo+VEY z?cq?RcS+~6r&|K{PqHZ(bu5Qy{Ux_vMy;%N?}ZxuBltrMl9P>E_J1Nd@8BaNZ{%`6 zHKcydg9H>HFYsuq3?c9#n4S=AWkJ-qC!x*1X#Ne)abQ}nVooDKV6tUdPc9gz3)wHd}XT~YY0rI6jnH=N8msthb={7${3X%ZF6ab6O3#I``91F5I z#1p{O=4nUopIU9y&8K8uI}NSpilaRLMdD}owN!N(9+E2z{<^FWoSYmIPlWj!&+i6a zy7#~{aEBkEHgkb2Q2$xc9dT9#k&O>>{l$le)H<|dkH5CBcdZ+1_qH{)Q77pc?S2$% zynJQ7Ba|nh70jEJH$Gx``;sElw1fCww^qUQUc`j*1R!X2AH5D-)nDvT zHhX(=U-hCln!SJ3WKhClh?b+T@zdRis9yr9hfDbb$+dpD7Qhti>k3VOP>W0Oz7#Rb zO_imW#u-x5`lt`vgN)pbz(FG>+8+gjvA1vwoNK^y5lpfqwb2lcsZX^NsU2E<`K?Be zcSyGH5NY2(*4>|Lahr^5S;t{wEqmv~`@q1r^B?ri>79T&@9kDK3S5-$^7x%+ioI*O z?EO-6pcCqCQr;s$9OFgHFme^sjvha%^TMgN1~E9W2Bl_r1GZHi`!m!Hrmw9x%PliA zWO>w!atka{FIWX>^B%`|2%ip>7w@zqb-20c<7#)8_|!{MX_B?3%EDTAUiZds`AP-_ z_vIMB{jr>O{urs_miDQ*&iakY`YZjHce}8Jali4yU`BdsWOurD*E%TVO8Y{zsQUF_^hLgwQdPfW|>x5T(6{mubx>idST&J$~Q?iy~IU) zSVdzzkF6%z5Kn>`_d2kXnt`Jll{tZfLwc zHlOBRujd1oAcgCbeXEfgl=UB&Y%48kUF9+#j4+|%knt? z*64Q-BA4o46EK2)})`*^x5mL@Z|IdqhiQe}ls`y0n9q)Plqz+t?p^eAB--=9ENnW2MJr`mf_ zkWsZ+1YM;`Z2aeIq{Bt6LZ=6DUd6ZtNpAF&OTDJC=@HxoUd8Ve)rTamz68b0l}p;F zFxuFr%ivhwLIKTG_|@GWEWHxTW9-%Wd_0Bh(QE0e3M;ER2UTp{Raf)j*BM>A3$&tV zCqy-A)&KRg1?XqtNl68Gahw|SoLK?TWiTG^=v2Ga9=X+nYY6@Ii`-(Ys+-idyIKRG zpmS=s${rtg$lyHpsXo;F&QZH$FmPqE?;{GqZ>}K^~@V>Qtq!(VK zXV4JCyO_8!$N@u<;9X531E;d2k z@G~M7j4O+%TtdH#$SKYLNXW)=2w)qce}88V{qC!jD;ASP7XPh*p$@lWTN_)7Sc(0G zH{B@_yet(<(jtGq?E-y!YisL#>*m8RhuF9J==#X^?c?GMv@^Sy?Yi4q9Is#d=DvOR zfCij002LPe_Xa7T8;sDl5^PQR;C3zOr{b&$Oz-EYL{374@py8+`=v0Kv6U0k=4(sIo zBQV$<1w!OG7)_c(2HO?P{S&79KvU%1BC(nxB<%R^L!;bC%LYi-IrkZ;&7phhAo1JjX9nNe>=Toom1f)Z_)$Vt}yp6 ztx0hy6IO!q>$xU+399CPmXeiDh5G%ZN@l0YYjJOX<{2xO*crS;USw~6EUEf!8A)Ge zfdikLW0>sKk^B5@$Nj;EAL|05cGAxF>Gs3Bx!}U@)Ic{Rimlp$E}xFej`It?G-}_i z9KD(*AA4cr#v(XE&GNC+g>yxH2?hN~pD3-gG?uJ^7 z$!xYAKf_6MeQf@apBU-=)8Hv)TXBS*fIoSDAnH;AFFk!MH`>qwQP(uSwBs~{jMp|D zEOc_7JGI)idD>`cQ@DT~qq1Lmw5kGqc+yF^RZthGr_m?jwAGg>E%3r+Vc6lvc zH^O_MH^=^h5L3FP>;3ItDe(l;Z@c3OU6Td=^%!o<@tZc!Z)Q%zkt@?yM}%T6+qkocO* zwBOWbv}y`3-Jo*%h3k4Wb~AE)I$xSm8ooLm7|iS@g`%PLF=t^@G)LeMw`EC>D^+g1 zqqu#)t#tKP`t4^+(3SE0>&gK6AP_+h@OSyJ6;nlIHq3 z)99sMZRzTB>bloN9_+ltW9Du(5GBda`nL0S3+2Ew+>A&~jbisBiED|@Mg8bpt#WOL zs}%Y^@cP~iPm(JloK!Jc**gC7Gv4r;8|` zJ_Uunntn#!u^s4bt<`z#oq@;J6F(XDsD!M)-eA!-4F=7s#iydyOohU{Y3}QAd?%&k zc9avbtj_5Wv8>zNSb<9tn8kA;rO@nqgKjLa8GSI%*l;kr&9iv1;Fh+w)rsQXtD{i~ zA5*OAP8+}6{*rzHQ{#dv|qCj5%JCq?BT zsjZ(g{rjigDwjj{yv5k(dKY=mv@CU^?B ze!uYg%1;?eD@&dc5%J1QW4D@B91Z74#DY~&fSc)p_KiDRL`Zo?*Pb=QydBq3U_mh_ z^&-I(Qat(P)sc7*$YCibB>k~9G;1p+gI0Rj^O;nx^&Ag}##HOanB0gQsi@*H_Zbh% z%K3GM(AzcxLT|@)WXf7Ai-lBYt0JG&bHYB~`g&}DRoMz2`Wl*&uTh9kFv@^w4LAHLbWGo&(ld7hB5rkp5OMJo|NH(Jwp?+j|(r{ zwd#%!bD`(QSlccixnA$GNcFB0ky@@a2ai@g+|lQwDDbAN&D~U;b}Ik{2`-b4p=~KQ zX+sokY{F^UH&FD4wKvszuwkbD;N2{-adh>@aj~W%u`oM@yje56c)yr{-dVDp3k7bJ z!Wtfzk>vWMo>kNQY|yEQQEis;OVCT+e)Ex|r>mo%xm>k2zMI+WBui0-1?~52ih%uJ z$LHxHxc!JG6?p+1znKz#bFkGnIBt8Opx$IB)^5DoDk(6~C0m0_*+RW^aC5SHrFp(u z>{v)#qtyHh0Q8w`_Ad^Xm97q(EoO79ICh0$G2fGI{5rR2L44v;MYDV)h8r$2YswtomT zNohMEIirftd60t5#DnJr0V?hE1Z=T1&1kmoot*<38!~-nR&^=&J5`h_t%}o^s|3o7=L+ueyM+lD$VK8hSVDt8)k#r)C}S7)4NxJ2wjl+>Kd_0CTxRdXTB z$uU(s_azLdoL^3NC#HZ}6{U*PKp_>AuKfU~g_CL;i7DFd$iY3yMVA8^pTjn=q~g*g z=mi`196YzG=PK<-H#ax`YzdeL+N1|rjy!Q98?|>x7Dj%euwY!ayqGoYEoPHpjVi@0 z3KfdWnwMEl10M2ke?9H+GD}4MAr)K`sr{ys(`wArBI#t)_+T?b2kV6K0U+NDnx!SD zSqL5aMCM;Ue^6w=tvA%p2e9cMgj@9ax(C1B>5&10-vb@c@E~ZH* zq=0hbp^lf8Qs_sSl2-V%dwTLtPRKqm5zg~asC*+@I(Bpa-g6Pw2bqV$Z>f9y#NFKL zENfBPT8E*H=fY~Mz*3g|9{Wi7lbTvbclXdr>1qemr2;AUf`h5bVJ$g|ITpt}u3k3` zG-+G@5kz?TVyBzxlvQz__4JhSYHSXJ`)E!ta$rWUDKajOQKF?2akWM*F!;(S>+;un z4TlA({z(FU^~F+~uB7qRch&2Kt|E#&L+%Uc}t4B(qUJ!{L zbnI3ycsR%CXXGW<{^`WmMa>y3acz_e1KYGP3-j2zcQ@CYu`3#15jKNuc?AWM4|vO~ zFc=}dKd6~Oq2Ephi)^p`qGCKk0i`Xty^S9u?CB=+RPRfyI!W_1cx98MomIU~(GK@% znsI)e?m8>(YzBQ=?72opmLo$Eira}KWFTR-V4r`lhTnDJ%R(M#2H)7u$CIT^-D zPRShxiSU#A-G{DUIApkU9N}cLlG)(}OqHvKy;H8FoO5*yy&P}9OY<%_&*xcBIj}30 z=-GWpx(KV#NcDzHw82EOCjQ=py!ny80SL{K#X8o~G%dH#!d2oXuRODr?`a4XFbA!LSoSLr@{{Fzfzw z^R(S5^?0S3LmG1VO;=x)d-K|G1=!seyW$n%WG})r+nWDn zD$G0G$N{^ioso{!9Tj*8^vF@m8(D70kIgjP+}tXUtL)a4R?)s1nws$k@dJ#y8rs@* zbq7m_k|Dy6!JtTY`EB)0@1CWSEQ-g2UFdBFecEEq!?^B1_U?^27reFcQjPN9iu#G&^kwPoWt@%7rlgSk z-OAW>u0HC$N##YsN$P#Q!ZhWIlI|B#We?v8AwS?tGo$lDz_Qt@1n)|1FL=FPGu>%1 zUFt0Bb9x$Kk6`xNMqUdk29ww=J2}|QGww00A|^mDEt~H-2&Z5SavyFTk-bpzyh-QX z3+5=NTBqYh*SmE++ zYbol8Ry4`hX}LgEM{W5;FiDncn)93b)KcN>o}kkDX;Od4+MA$tGV3@Fmhn0@9`=l3 zmpRzXBU)b)zGxfZqlkg6zTs*!n)GGKtE{Ow-r9-XdM)QjnKf&L;GRzr5t-V?iQ2PC zaDGa=HDYwT@ z8I6l2nU1%yGfYme?yR&(%!38~&hlwgF?{c0)`vxN*k|4sS0S(K0c3DAkb|qZ#bNJx zK3V4kDOG2X|EhL|-q(e(@1 zr4slYmUo>gb8V*iENj*1$Va+Kk#4A>K+gQU$<%WV_y2t|rXm^HJL9=(<=SVnN5pR; zwKbS*Xl0^1jwA1lbNK_c{-r`UWI_&K$AwYAwlevZ=?C3w-kX-Ei^m5E#7^<|v%pDL zvGIR^9WCpPds1&kW0UWy>>9#kW6Cu$v0SkYzv?hVBhR|8Ou8chUH_qnA~QJV`Es`N zUPWO7Stj$qHz>Mr{*T)vC|*zpKsVJ(wb}*w^-J06N!6C7EoMD_TY7~A0=wQ|x zl^Cv;UEb5FHA+w^P*Yt-cQ6|(Dk;^(OB3}n3NQR_Zf%dFJhFWTtB$!2dB$>-;Id%F zg}Ks%AVQI@TBriR1G`FK*)0`x*OQm`L5SEPkHEPfFZ-xIwaKSmo-TK&v|zF@xZ!SD zhF_~=BQTVsq1r2OEE?R)`mfQ{_4aP;Yu8i{3rIrD+;_3PJvF6mJ#DYX;8p5~pxYdK7R4V*(5b;YLvP>fOM zs;WuH^<{TXrpT|hvimwsdOnOd88$|&B7dYr(=1PD8?PLg<@d*J)KCq=0iigv+VV6S z%!VrYN*$Ri%bL_ZnQdw9y*vW%e~i~5mT!AMGyTXZBind2RFEOz5H*ZJx>CLgWz3&Bg;!u(3tlQl9x2T3CT8qjYDcpdceJ5XNVyc8 zKBkzuu5VsT0@NMG`x5l+?Yt2QTC27yX<7)*EvMRZLRVi_vxvCWPow#$AF-#|aZZFK zB-}h1@rUtH)umP7Pv$OKJQs4RuRF1{PwPZPkbqt0CS9;9aNKBaG8-4W#zmNn61>4* z(uqYD>xdCB9cKKan9ZF&u+>yddCMZAIXh;E;;Hq>(H4pO>!arO;r&ME_1qnv(1q0vqv&d>(|B!TZmK0B zn^LVQqh^cpOy?1nVeY*g0_768t2pu!%#vtRFYPjuAr@@*W+^m&M2L`Hg>T0KZ4feo zo8BK1PWOD?cLKz1r(fd@5|ZU5#PbJ2LOS7Zy<~u8+T$a_B?XoA%k5?d5!n40HPnajx-NX z<#?H^SmoLf?uQ|H;0XJ?kBUHOBlwVXGHzpmCp#aMZ-3n;YuYOB43v)FTp&rp}-P36lS@1 z&AKkO%p5^mKdocw+~kY*)aC@BMH#9Gxmf+|*7~zrk(#yk39Uiyt)!tYzo$Or>bTR? zA93n{1PtD&J#dRuj!S;H4fuVZu^3hlsAVl`m5O2>8O=z_8!pADwyS{iUehWt%FVLSS$_9DufZ!yKG@*B6Z#4?B zp<-#dDIy`uxA^LKzUp1+C;d{_19bFa+0F(65jBz@Rq{AXtNM3+Pme%Bg+|%ZuxvGU`n>#sVqp$Zi`<}E$Qc$mig%}zx68Dw0NmB=0RKQmDL0E$TW=vF79URW49m+2L>0;;v**%5eX9K z>Vp&3iF9`+JWA4&5oG=O2GVcsqh*+QpROZ zvj|k9+1&)-iOskz=d#BqK6@>V7OvtrB8V?TfB;5Wy%CuA;NPPHM}=?4>1BGqxkyD1 zul&x$Lxn#!l=L^kfe|tJ@4-{P)ifXS!y3ey%oL>qaB)d2h2DJLbqJ{Av#WYkyc>;} zs`VxCnk=;bNJ$~kLpp7T$m3o5xyzBL!={p}nPzvJ?0lKsYQIFDdRgJ(jvkfOdrnFI zJq5EG$K^)?JhPRg39F@C(|vnFN5DmJ-j)B=$Dz}Y3nQ$_#7DtAV68r2%w2sJUyxp9 zr^q-_S42usn=5Ig67@Xfw$5yl-Ku&qH+(f=Z$-|&j3x`(f{uq9!O05+gSV@fh)A^y z!f~dULPr=SI(mCYK5J~`+VI3t3)s$pVbb3ya=%jy1U|$A3-i>Xn!1&yo=I5Qj-uWNbL+nxwn)#g|kpFWTX3<&76l?5E( ziVF4ahqsctgMRNU5fKNtvZ$IDhcBA93ZUYnSRj*SSvsU27}#08&s0r2hb>6fi}ePK z1RkwO1XH0hY1$E)0pSNadGX6u-u7F<%==fafH0r{6Eegkf<-phbz`JK4~oI~W$8i9 z6rC0$RiE0+fJu1~Ov;svA;tGg-6inOVUIPT-eYOt5J~1Va`6_|p=D0p=IcpL)WA9l zETk85NJN!IH6=OEI4MEZtW(0iNIqASb%0geciDPaymRt#3Cw&Atq1)6Ai%7?w zmSM-f@HA2(Yn#Zn7o&sG^ndFq%FA^T{1I53{di3ns z>glESiFe~$Yg75h24dce6LuSvbXHECh4EyWSHY6mrDqf4zB8m603w@!dL&IK!=0~D zX#t0$omMBao+O#Ie_gE7`z?odsk?l7G>Y$j`56Gm-sp~7{&M*3+6M;I z*v;aO<0?JiM2+*}cz@zjp*M^wzRmyEF|u>)D*2mFJsY+mG+BFN#u&SCQEI{lq1DmD zazZOZY|- zt(ggyw+@SG5ME-bnN!c}9F<$#tgNgg<(lQ$sW<-&I`=S2Y@JL~d^fyUJayEQQ2ln# ziyCWbtbA{5NKo)PJ|%DJhWin{u7-MT)e78{Km+;i_hy;-&BFL@fKKFan?os6vV*{& z4S}b0j;idnw&45)Aad1lldeDEoCZtrnC#TB*of{h%;W2et0*-!wYvgTFwraJ-ssfS z)DH<%z^;A@o|dHKSIdJoJCc(zknCKsHlmtD&4_oS4fE|c#&Q5?aBVU=i>JP8C?%yW zYqj0@^}@CJ$fP7IioJqHE)~Z*%O}lfz76M>&U@=0X`moBotS`&H}%tv9IHB2ZEd%P zGC}0Ff;m$t2iwz6i{>Ej^4Rg`8xj%{WvA~AjI4_FD9I>}E#xZ=s-$ToIVOA-x^s9; zYICRs!UB;>rf@RKC|p?S+}oG9sxefLU(1R2;==kGr1jjk7P6D9FT#XN?)Bg-C-V7a zxmK5f$zo}lnCOn?0EuXiaeLk;J8@Kb!xW*4)9-PB#eggYCWOcF28CemH=Hsj$YF3X zFI_?b|LfrQ$KKq{pJMB(z!UY{4|tZ0j`S%TlMj=b_H6q|O5x4~lvhIgYM^I4_~f zHLvbLbP^g1!elEyW&w}A9FtVR z2Tmrys!Ale{?1n~dri4rL`ONIrQ>?=?qnKoL@N9SGd&fu+F@B~4P_YVl=;g+s7oH~ zNMc6?oe~+*e6nM%Q*KtKrO4mF=_+Mqf0H)?>>`EPgCqY(Mb?s)OGa@0z-b24ukq4T zHB?H4xsJ#Co@uB^A@`6SxE13do=}X`#wtn5<7;G`C5wr!17+-5y!w`(P5>7VM@J zOv;(N9nX03GL4Ro-#FMHu2cnV<6iqru!dUTr$zceFB1yl8_k*|lzxbhPsIW4g7)yK z(v#di<$yKW44FUK(J@{Su|Pv%r(|HaGWsNAo10!YAhfB>V)_dOpF<>KN}yxDrfpun z9_5ef>p^7K68F}9Cq1ouQv~@^k!?yP@xeleat(qfA~+Gp^&?71DhKg!QV#RaxCT@M zc3k*b+cmP%vAKXKoB`;F;^D--wW1f_yDRn$<2`ZLhRxid^^MG4zjg7SIKm~zTI~e4 zaeCh45=Bp5OTCM$-BJqWEJLBFjoQt?%a<>EIZY;1+po52SY8?3-Ha&5YHhRUPgh5( zSDE{8nvatgu6eId4nD4xkh6X29T2S8(eMK}YbuR%l^r_!#dD#IC++@4s`IQ%^_)u5!i>$4!5=i@U+3PF$F$ z6*oMjO^ieIfK!HkB!bEKV_aMgaMU}IC}k&cw$8B#<-!@`Mb<>KVAlGDZw&4gigI$F z@q$EF=#CD!+q zlikQo&5~@jTa49eH6`-L>Upyx#L>lbL^bz7YDV7cz+||B7u?~Z(1$c&LcN@)6{AQ4 zG4<3A1F(udXH?BAYL##;Q0kKJ_H@#Mu>nu_uYdxEBtlXs^f^KKiY&XFDEuy3$3p`0 z9|S_jq=k7;ybgF5U)5CxN?Kb>-hMr8!)dtKdn%8XLaNQ@u+)pXIwvWjPta&m8^k5B zC4t4pdJ{_eUjODU3ig%2T_`5#@f*4&!rT5R{H)it==_8fV~IEr`57-ZiNyc)z3>E4 zsQ<1;yI??31dnEif)H%b^YgT?K}0)pohoqAyaObntk7QxB%v(YTt%C5fu(8M;VGy4 zJ7}9SBS-Asx*u=tmbU~_`u~nN2rt~};d>>2(V@qocv-J7Powmz{|X4KjBZu=znB_! zzx=Y;6@>CQOtu)6DX&2%+S-`T0EySHt=+NdW?kQLz*sDzYc<;$w;SfpnpO@p8BA3H z*7@rj-I$?13x(D0d?iFud?Y(Z!Vqfl?x6 zU}~Z3T?;%HujFp(6x1oy_6ipFAKTiZ-gd4zXrOkQ=^mi7pDo+%0&FOT$y20``+(Fb3;eVBL|;P08}+0QJ-Dz5Uyxb&D?Gvf308;>W=30GF<)K^ zMB{Q+><`?nhaApU7Y_L4U7yOg|yfBLOs@NOkrj zxH38%nf7W%VX9R+FLWfY_eZI!miFQam!^B(jx~2wF+JnqakTPYzV#N+Im~bVMB^Il zoZwKYz`H;;YbY7M`ADFM8NtAs%P#sDb@Td5DjbyDul_b4b($XBbuf7UC~I6;-lGzR z@~#kQU8Ko+jZ|qV6I2f$tW*@UTOTYMZ}T+(Gu`FTp7HSGDZ^q1*?kFSjmIM(hM{!0 z|4n-J8wba&&u@;Y0xiZ^_UDK5t~QyUY)lYw(^WuO(DgjU`j`xqDDI6_C$WPkyuP-9#u~J={;uySwbCPIqAr??eA_VPKE0DnmiBVp{u}x z4yLak)7#N;c^M6Z`CrekvZWNpozA!5{XJMK$$xkc9#pH*W%*rK!50d zYVSm_uGLG6>>aua7Wec*}vtM-CPahb#L>OS}Sqa99?v0O4F3a^oKvaXGtIr<~b1|AxTd2GG=LkTvr%jtv{reVVT94xJg`A+Ty)9u)c51dUc?izu%>5{kfF> z&2zv;@o0R3i9uOH*8$?#(6>cCkwT%=i9m4Ye?&XjkAP_B2J~xa;Qvwg+yd$zWrv{i z9%TPg@A@%h)n&=Iem9We%TL^((T<-vmyOr02wAz4p+Z>}#gq839pWA=76 zc4PgjNh0CBsOA`lZn1m+wL6|FV1J{zd-twxylmdv(usRI4cvDhehC*yQPs~ft7||; zhf;}Gs=IwM6MP8jZUu=y-N5Lipp-Ur3&JrpbaWSk2yR^Gd3;UOQ^e<;&S`41C?q12 zkkCXuu+C&->xpyh7JGELRt`1$Gc_4AG7-71tBgc`K68RY!%COxV&UL;2(&Ip~G-6`n!LNgpeYd?ORS|M4Ty*25 z76z|$fu2(Z#I=VVvFe%UOmC;voq+Bj)|U5JuC1M|U4e=#S$$&gOsr-8 zi1VsyFeKikd)lsnbdP&k6vz0Qw!n$zR;6n-ha!)UCd#s8Q7-XDWFSi5#N{c8Gqu9M zV~v!TQlwaZ8oS0LQLC%Whd|~RzlCnC-HImFacM+{bl;y~sVrQG?WNyZM&y0!k;V=| zo6l>n&d0>u(i$uP62~XfV4(d8UEZ_?hcn=#Ou=s>w+PP2n_inSpSe&!U9f!nzRsSa zQ+%qC^Z+E}wA&cx(H%=Pxecyv9(BkeU=YnAcsy92X+8fOzvogTCQby6YEjNPe!}OJ zp<>ZmgVUt$)y#^;<%YamcSqOf@tjL^d!LwT9yqauwaxdXr3tpNa%~Ls@_i+bC;GM9 zcrbac_hrQ|{o(@nz(1Er1un5T?!+yje`Tn&m7u#*PCKl(@pdB%&XvIJQBS<#3KOSm zS^(pW-}9Z)%j&3FVRf*mm7uFr?p>(a6yDdZD;!3%&&?*1;p|#==rrhJp}mI(bFnz! zVvT~yxca^Ju9mm1;xDW;!dDkjhdJDr`|=x*0}1uHLp|~5%@DwMCGa0km$b5pz$DYO z6CzXmkcQuTIjl;K?j^17!}IKsQJN@O{@o7>3gHy-B-!u5tXYE6i-ZFHC=a|7bh+73 zt(mde(bTwBl`+e^DW!`*Pn}TwJjsdy{$S~LMnZBYYvqqdwK20FLZ|666nrn|%SV0< zVqI`DSiFgT{Hn*an_=h2s;zUvm-hz=$eCO@Ehsbsg}$b0;7|wx7Us!KFxmk8v`8dv zCNR;4%l3xX2ZM`MO*+5u;~4wOX_O0zjks1TBt>3E0aIobjVoKlz~9o+vOLs&O-U$k zfy&4#Z|chvq1^s5^L+Tn+@6j;oqDY=tX$FFXb^)p>)(HvU$vA%0&OTDT1EBfl{geN z5KjHQUl~kP*bVYfc8w$>rW;e?{*ga}`|=XvRyQbOA8@b?H;#Sbe1y8Z(;t}U1YhJN z*_WJBiQ|wS2{PGO`Dt%K5uad-Q7+`ys2o0$qP!eOPL}dTD|YojC@n`OegyjY?jp%g zpGA$Gm5wzArky-dAj;;L_i`92lV-#*MrwndC2zMb-3QI0Rpq_F4 zWV;(>Cg@2~w^To=?$X^m7M7O$X!=Qs<=E4tqYa90HD1|dNa-smVrxndKBaBJ4PQ3a z03ga_10TF;$e(oH{ys0e((N!+@HT0XyFh(JLJ2V_N)dTI11R6;^!e{;jrX!}l1im;-oqq0jU1^06 z@s{q#TE&0o*r2ITbxG2x^bxe^Z6EQ)s_fv7$@wLj4=)(WiL*NJTc;3w0b=}X2~6je z=z8LA0ntf)mHis&SJXM-RE9&rjVLx&XuCB6LRS1(z72=TV-VT`nuY{$u z2SrxKD?bh>28avwCS*8Ml4nidWU+T*xD-|_BP0z}JK_l-^16^fWG@zoI#b$8e575D zRMo~E<2iRnA<`|$K{2L&vy}`I$=?DGNz@}UXZUB6tkLUnG4_(VP-PieoF}~b8aK6U z^n|pWoutS=s75&9-mFuBT7jlsYpI&ICrRO z=XT48>vLa_A+YV{%iZR1e_PE7?I>Uy$}`|2PXP;ULLw!Dyjpx{L?LlLo4eyxSh_~l z+bqT=5W<)pyLUExLF`{%K0Y+HkeGqQhrTZD;taM_6qB`KOtj-~E?C2hhcdFj_<+q4 zndsfW&QNV|9f*$ez+{CfVyvU9p#CAt6i9^s1XqAI9q5o-n+x@kq@6IrWsG40MEF2< zO!#lp0q0C4d=}4&_#>KtET6kCu3)lnP)e$S>5rZA?GWkEdDMoGp$9&C8)ET3h z-G?Gh{(nrI|N88YAth@2ukZaig{axTKI6w6F9On`pJl~fU_Q9;&pHo$4De8xy#J~- zpF`4U4;rvL$6#bs3)IkqfCSdq7{NV-KgMo^F4r~&8vPi_l`swFc~xMPi+ZLpNsmnw zzW3n3{`2|uKdU0^@g6ul?b(;1V8NN9lK0F&g}ke?jp2`V`j24_)Kd4m=-g z(lfQX6i};!@For(>Ggiw^TLncD8?l5!)?B6V`0L~;6!iUosHzQrt7eZcZhHNQeVzN z@p?#o9*>E={Lzy)&F>u^%gCOGMhNuBHQNK3s+d1>%p<}4XM+*u`Tg(5|NBhN#>W2+ jh_mMa`@efY?4F(@$-A?n9sg?zdL9zbWJL3y>U#bkg~u7? literal 0 HcmV?d00001 diff --git a/src/quafu/visualisation/figures/test.png b/src/quafu/visualisation/figures/test.png new file mode 100644 index 0000000000000000000000000000000000000000..a53e5b036f3860cbfd91ad5d9f5df7ff3a6da26d GIT binary patch literal 284254 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�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

LvZK87xR4HVS0 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 literal 0 HcmV?d00001 From 1e14e8e1e912259e8f5cf25ea7ca53890e61fbf9 Mon Sep 17 00:00:00 2001 From: chen_wei <109205133+chensgit169@users.noreply.github.com> Date: Sun, 2 Jul 2023 23:20:54 +0800 Subject: [PATCH 25/70] Delete visualisation directory --- visualisation/__init__.py | 0 visualisation/circuitPlot.py | 488 ------------------------ visualisation/examples/__init__.py | 0 visualisation/examples/deutsch_jozsa.py | 106 ----- visualisation/figures/deutsch_jozsa.png | Bin 124193 -> 0 bytes visualisation/figures/test.png | Bin 284254 -> 0 bytes 6 files changed, 594 deletions(-) delete mode 100644 visualisation/__init__.py delete mode 100644 visualisation/circuitPlot.py delete mode 100644 visualisation/examples/__init__.py delete mode 100644 visualisation/examples/deutsch_jozsa.py delete mode 100644 visualisation/figures/deutsch_jozsa.png delete mode 100644 visualisation/figures/test.png diff --git a/visualisation/__init__.py b/visualisation/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/visualisation/circuitPlot.py b/visualisation/circuitPlot.py deleted file mode 100644 index 68fd201..0000000 --- a/visualisation/circuitPlot.py +++ /dev/null @@ -1,488 +0,0 @@ -import numpy as np -import quafu -import matplotlib.patheffects as pe -import matplotlib.pyplot as plt -from matplotlib.collections import PolyCollection, PatchCollection, LineCollection -from matplotlib.patches import Circle, Arc -from matplotlib.text import Text - -line_args = {} -box_args = {} - -DEEPCOLOR = '#0C161F' -BLUE = '#1f77b4' -ORANGE = '#ff7f0e' -GREEN = '#2ca02c' -GOLDEN = '#FFB240' -GARNET = '#C0392B' - -""" -layers(zorder): - -0: figure -1: bkg box -2: wires -3: closed patches -4: white bkg for label/text -5: labels -""" - -su2_gate_names = ['x', 'y', 'z', 'id', 'w', - 'h', 't', 'tdg', 's', 'sdg', 'sx', 'sy', 'sw', - 'phase', - 'rx', 'ry', 'rz', - ] - -swap_gate_names = ['swap', 'iswap'] -r2_gate_names = ['rxx', 'ryy', 'rzz'] -c2_gate_names = ['cp', 'cs', 'ct', 'cx', 'cy', 'cz'] -c3_gate_names = ['fredkin', 'toffoli'] -cm_gate_names = ['mcx', 'mcy', 'mcz'] -operation_names = ['barrier', 'delay'] - - -class CircuitPlotManager: - """ - A class to manage the plotting of quantum circuits. - Stores style parameters and provides functions to plot. - - To be initialized when circuit.plot() is called. - """ - _wire_color = '#FF0000' - _wire_lw = 1.5 - - _light_blue = '#3B82F6' - _ec = DEEPCOLOR - - _a_inch = 2 / 2.54 # physical lattice constant in inch - _a = 0.5 # box width and height, unit: ax - - _barrier_width = _a / 3 # barrier width - - _stroke = pe.withStroke(linewidth=2, foreground='white') - - def __init__(self, qc: quafu.QuantumCircuit): - """ - Processing graphical info from a quantum circuit, - whose gates are stored as a list at present. - - In the future the circuit will be stored as a graph - or graph-like object, procedure will be much simplified. - (TODO) - """ - self.qbit_num = qc.num - - # step0: containers of graphical elements - - self._h_wire_points = [] - self._ctrl_wire_points = [] - - self._closed_patches = [] - - self._mea_arc_patches = [] - self._mea_point_patches = [] - - self._ctrl_points = [] - self._not_points = [] - self._swap_points = [] - - self._barrier_points = [] - - self._text_list = [] - - # step1: process gates/instructions - dorders = np.zeros(qc.num, dtype=int) - for gate in qc.gates: - id_name = gate.name.lower() - _which = slice(np.min(gate.pos), np.max(gate.pos) + 1) - depth = np.max(dorders[_which]) - paras = getattr(gate, 'paras', None) - - # TODO: call processing functions - if id_name == 'barrier': - self._proc_barrier(depth, gate.pos) - elif id_name == 'measure': - self._proc_measure(depth, gate.pos) - elif id_name in su2_gate_names: - self._proc_su2(id_name, depth, gate.pos, paras) - elif id_name == 'swap': - self._proc_swap(depth, gate.pos) - elif id_name == 'cx': - self._proc_ctrl(depth, gate.ctrls[0], gate.targs[0], 'x') - else: - # control - raise NotImplemented - dorders[_which] = depth + 1 - self.depth = np.max(dorders) + 1 - - for q, c in qc.measures.items(): - self._proc_measure(self.depth - 1, q) - - # step2: initialize bit-label - self.q_label = [f'q_{i}' for i in range(qc.num)] - self.c_label = [f'c_{i}' for i in qc.measures.values()] - - # step3: figure coordination - self.xs = np.arange(-3 / 2, self.depth + 3 / 2) - self.ys = np.arange(-2, self.qbit_num + 1 / 2) - - def __call__(self, - title=None, *args, **kwargs): - """ - - """ - # Not supported by patch collections? - # if 'xkcd' in kwargs: - # import random - # plt.gca().xkcd(randomness=random.randint(0, 1000)) - if title is not None: - title = Text((self.xs[0] + self.xs[-1]) / 2, -0.8, - title, - size=30, - ha='center', va='baseline') - self._text_list.append(title) - - # initialize a figure - _size_x = self._a_inch * abs(self.xs[-1] - self.xs[0]) - _size_y = self._a_inch * abs(self.ys[-1] - self.ys[0]) - fig = plt.figure(figsize=(_size_x, _size_y)) # inch - ax = fig.add_axes([0, 0, 1, 1], - aspect=1, - xlim=[self.xs[0], self.xs[-1]], - ylim=[self.ys[0], self.ys[-1]], - ) - ax.axis('off') - ax.invert_yaxis() - - self._circuit_wires() - self._inits_label() - self._measured_label() - self._render_circuit() - - ######################################################################### - # Helper functions for processing gates/instructions into graphical - # elements. Add only points data of for the following collection-wise - # plotting if possible, create a patch otherwise. - ######################################################################### - def _circuit_wires(self): - """ - plot horizontal circuit wires - """ - for y in range(self.qbit_num): - x0 = self.xs[0] + 1 - x1 = self.xs[-1] - 1 - self._h_wire_points.append([[x0, y], [x1, y]]) - - def _gate_bbox(self, x, y, fc: str): - a = self._a - from matplotlib.patches import FancyBboxPatch - bbox = FancyBboxPatch((-a / 2 + x, -a / 2 + y), a, a, - boxstyle=f'round, pad={0.2 * a}', - edgecolor=DEEPCOLOR, - facecolor=fc, - ) - self._closed_patches.append(bbox) - - def _inits_label(self, labels: list[int] = None): - """ qubit-labeling """ - if labels is None: - labels = self.q_label - - for i, label in enumerate(labels): - label = r'$|%s\rangle$' % label - txt = Text(-2 / 3, i, - label, - size=18, - color=DEEPCOLOR, - ha='right', - va='center', - ) - self._text_list.append(txt) - - def _measured_label(self, labels: list[int] = None): - """ measured qubit-labeling """ - if labels is None: - labels = self.c_label - - for i, label in enumerate(labels): - label = r'$%s$' % label - txt = Text(self.xs[-1] - 3 / 4, i, - label, - size=18, - color=DEEPCOLOR, - ha='left', - va='center', - ) - self._text_list.append(txt) - - def _gate_label(self, s, x, y): - if not s: - return None - _dy = 0.05 - text = Text(x, y + _dy, - s, - size=24, - color=DEEPCOLOR, - ha='center', - va='center', - ) - text.set_path_effects([self._stroke]) - self._text_list.append(text) - - def _para_label(self, para_txt, x, y): - """ label parameters """ - if not para_txt: - return None - _dx = 0 - text = Text(x + _dx, y+0.7*self._a, - para_txt, - size=12, - color=DEEPCOLOR, - ha='center', - va='top', - ) - self._text_list.append(text) - - def _measure_label(self, x, y): - from matplotlib.patches import FancyArrow - a = self._a - r = 1.1 * a - d = 1.2 * a / 3.5 - - arrow = FancyArrow(x=x, - y=y + d, - dx=0.15, - dy=-0.35, - width=0.04, - facecolor=DEEPCOLOR, - head_width=0.07, - head_length=0.15, - edgecolor='white') - arc = Arc((x, y + d), - width=r, - height=r, - lw=1, - theta1=180, - theta2=0, - fill=False, - zorder=4, - color=DEEPCOLOR, - capstyle='round', - ) - center_bkg = Circle((x, y + d), - radius=0.035, - color='white', - ) - center = Circle((x, y + d), - radius=0.025, - facecolor=DEEPCOLOR, - ) - self._mea_arc_patches.append(arc) - self._mea_point_patches += [center_bkg, arrow, center] - - ######################################################################### - # # # # processing-functions: decompose ins into graphical elements # # # - ######################################################################### - def _proc_su2(self, id_name, depth, pos, paras): - if id_name in ['x', 'y', 'z', 'h', 'id', 's', 't', 'p', 'u']: - fc = '#EE7057' - label = id_name.capitalize() - elif id_name in ['rx', 'ry', 'rz']: - fc = '#6366F1' - label = id_name.upper() - else: - fc = '#8C9197' - label = '?' - - if id_name in ['rx', 'ry', 'rz', 'p']: - para_txt = r'$\theta=$' + f'{paras:.3f}' - else: - para_txt = None - - self._gate_label(label, depth, pos) - self._para_label(para_txt, depth, pos) - self._gate_bbox(depth, pos, fc) - - def _proc_ctrl(self, depth, ctrl_pos, tar_pos, tar_name, ctrl_type: bool = True): - if tar_name == 'x': - self._ctrl_points.append((depth, ctrl_pos, ctrl_type)) - self._ctrl_wire_points.append([[depth, ctrl_pos], [depth, tar_pos]]) - self._not_points.append((depth, tar_pos)) - else: - raise NotImplemented - - def _proc_swap(self, depth, pos): - p1, p2 = pos - self._swap_points += [[depth, p] for p in pos] - self._ctrl_wire_points.append([[depth, p1], [depth, p2]]) - - def _proc_barrier(self, depth, pos: list): - x0 = depth - self._barrier_width - x1 = depth + self._barrier_width - - for p in pos: - y0 = (p - 1 / 2) - y1 = (p + 1 / 2) - nodes = [[x0, y0], [x0, y1], [x1, y1], [x1, y0], [x0, y0]] - self._barrier_points.append(nodes) - - def _proc_measure(self, depth, pos): - fc = GOLDEN - self._gate_bbox(depth, pos, fc) - self._measure_label(depth, pos) - - # TODO: decide whether to draw double wire for measurement - # y = pos + 0.02 - # x0 = depth - # x1 = self.depth - 1 / 2 - # self._h_wire_points.append([[x0, y], [x1, y]]) - - ######################################################################### - # # # # # # # # # # # # # # rendering functions # # # # # # # # # # # # # - ######################################################################### - def _render_h_wires(self): - h_lines = LineCollection(self._h_wire_points, - zorder=0, - colors=self._wire_color, - alpha=0.8, - linewidths=2, - ) - plt.gca().add_collection(h_lines) - - def _render_ctrl_wires(self): - v_lines = LineCollection(self._ctrl_wire_points, - zorder=0, - colors=self._light_blue, - alpha=0.8, - linewidths=4, - ) - plt.gca().add_collection(v_lines) - - def _render_closed_patch(self): - collection = PatchCollection(self._closed_patches, - match_original=True, - zorder=3, - ec=self._ec, - linewidths=0.5, - ) - plt.gca().add_collection(collection) - - def _render_ctrl_nodes(self): - circle_collection = [] - r = self._a / 4 - for x, y, ctrl in self._ctrl_points: - fc = '#3B82F6' if ctrl else 'white' - circle = Circle((x, y), radius=r, fc=fc) - circle_collection.append(circle) - circles = PatchCollection(circle_collection, - match_original=True, - zorder=5, - ec=self._ec, - linewidths=2, - ) - plt.gca().add_collection(circles) - - def _render_not_nodes(self): - points = [] - rp = self._a * 0.3 - r = self._a * 0.5 - - for x, y in self._not_points: - points.append([[x, y - rp], [x, y + rp]]) - points.append([[x - rp, y], [x + rp, y]]) - circle = Circle((x, y), radius=r, lw=1, - fc='#3B82F6') - self._closed_patches.append(circle) - - collection = LineCollection(points, - zorder=5, - colors='white', - linewidths=2, - capstyle='round', - ) - plt.gca().add_collection(collection) - - def _render_swap_nodes(self): - points = [] - r = self._a / (4 ** (1 / 2)) - for x, y in self._swap_points: - points.append([[x - r, y - r], [x + r, y + r]]) - points.append([[x + r, y - r], [x - r, y + r]]) - collection = LineCollection(points, - zorder=5, - colors='#3B82F6', - linewidths=4, - capstyle='round', - ) - plt.gca().add_collection(collection) - - def _render_measure(self): - stroke = pe.withStroke(linewidth=4, foreground='white') - arcs = PatchCollection(self._mea_arc_patches, - match_original=True, - capstyle='round', - zorder=4) - arcs.set_path_effects([stroke]) - - plt.gca().add_collection(arcs) - pointers = PatchCollection(self._mea_point_patches, # note the order - match_original=True, - zorder=5, - facecolors=DEEPCOLOR, - linewidths=2, - ) - plt.gca().add_collection(pointers) - - def _render_barrier(self): - barrier = PolyCollection(self._barrier_points, - closed=True, - fc='lightgray', - hatch='///', - zorder=4) - plt.gca().add_collection(barrier) - - def _render_txt(self): - for txt in self._text_list: - plt.gca().add_artist(txt) - - def _render_circuit(self): - self._render_h_wires() - self._render_ctrl_wires() - self._render_ctrl_nodes() - self._render_not_nodes() - - self._render_swap_nodes() - self._render_measure() - self._render_barrier() - self._render_closed_patch() - self._render_txt() - - -if __name__ == '__main__': - n = 8 - qc_ = quafu.QuantumCircuit(n) - qc_.h(0) - - qc_.barrier([0, 3]) - qc_.x(0) - qc_.swap(0, 4) - qc_.cnot(3, 6) - qc_.rz(4, 3.2) - - for k in range(10): - qc_.x(7) - for k in range(n-1): - qc_.cnot(k, k + 1) - qc_.measure([0, 1, 2, 3], [0, 1, 2, 3]) - - # for i in range(30): - # qc.x(4) - - cmp = CircuitPlotManager(qc_) - cmp(title='This Is a Quantum Circuit') - import os - if not os.path.exists('./figures/'): - os.mkdir('./figures/') - plt.savefig('./figures/test.png', dpi=300, transparent=True) - plt.close() - # plt.show() diff --git a/visualisation/examples/__init__.py b/visualisation/examples/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/visualisation/examples/deutsch_jozsa.py b/visualisation/examples/deutsch_jozsa.py deleted file mode 100644 index 25af135..0000000 --- a/visualisation/examples/deutsch_jozsa.py +++ /dev/null @@ -1,106 +0,0 @@ -import random - -import matplotlib.pyplot as plt -import numpy as np - -from quafu import QuantumCircuit -from visualisation.circuitPlot import CircuitPlotManager - - -def get_const_oracle(n: int): - const_oracle = QuantumCircuit(n + 1) - output = np.random.randint(2) - if output == 1: - const_oracle.x(n) - const_oracle.name = 'Constant Oracle' - return const_oracle - - -def get_balanced_oracle(n: int): - oracle = QuantumCircuit(n + 1) - b_str = ''.join([random.choice('01') for _ in range(n)]) - - # Place X-qu_gate - for qubit in range(len(b_str)): - if b_str[qubit] == '1': - oracle.x(qubit) - - # Use barrier as divider - oracle.barrier(list(range(n+1))) - - # Controlled-NOT qu_gate - for qubit in range(n): - oracle.cnot(qubit, n) - - oracle.barrier(list(range(n+1))) - - # Place X-qu_gate - for qubit in range(len(b_str)): - if b_str[qubit] == '1': - oracle.x(qubit) - - oracle.name = 'Balanced Oracle' - return oracle - - -def deutsch_jozsa(n: int, case: str): - circuit = QuantumCircuit(n + 1) # number of q-bit and c-bit - - # Initialization - for qubit in range(n): - circuit.h(qubit) - circuit.x(n) - circuit.h(n) - - # Add oracle - ################################################# - if case == 'balanced': - b_str = ''.join([random.choice('01') for _ in range(n)]) - - # Place X-qu_gate - for qubit in range(len(b_str)): - if b_str[qubit] == '1': - circuit.x(qubit) - - circuit.barrier(list(range(n+1))) - # Controlled-NOT qu_gate - for qubit in range(n): - circuit.cnot(qubit, n) - circuit.barrier(list(range(n+1))) - - # Place X-qu_gate - for qubit in range(len(b_str)): - if b_str[qubit] == '1': - circuit.x(qubit) - elif case == 'constant': - const_oracle = QuantumCircuit(n + 1) - output = np.random.randint(2) - if output == 1: - const_oracle.x(n) - else: - raise ValueError('undefined case: ' + case) - ################################################# - - # Repeat H-qu_gate - circuit.barrier(list(range(n+1))) - for qubit in range(n): - circuit.h(qubit) - circuit.barrier(list(range(n+1))) - - # Measure - circuit.measure(list(range(n)), list(range(n))) - return circuit - - -if __name__ == '__main__': - # plt.figure(dpi=240) - # balanced_oracle = get_balanced_oracle(n=4) - circuits_ = deutsch_jozsa(n=4, case='constant') - cmp = CircuitPlotManager(circuits_) - cmp(title='Deutsch-Josza Circuit') - import os - - if not os.path.exists('./figures/'): - os.mkdir('../figures/') - plt.savefig('../figures/deutsch_jozsa.png', dpi=240) - # plt.show() diff --git a/visualisation/figures/deutsch_jozsa.png b/visualisation/figures/deutsch_jozsa.png deleted file mode 100644 index 5f40dd32b9f1fb007ffec626b59baee2db84cf2a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 124193 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 diff --git a/visualisation/figures/test.png b/visualisation/figures/test.png deleted file mode 100644 index a53e5b036f3860cbfd91ad5d9f5df7ff3a6da26d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 284254 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�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

LvZK87xR4HVS0 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 From 878b7297679c1f28a38857e151a285a384e04244 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 5 Jul 2023 12:45:54 +0800 Subject: [PATCH 26/70] "adjusted format according to PEP8" --- src/quafu/results/results.py | 50 +++++++++++++++++++----------------- 1 file changed, 26 insertions(+), 24 deletions(-) diff --git a/src/quafu/results/results.py b/src/quafu/results/results.py index 647f97b..28439ed 100644 --- a/src/quafu/results/results.py +++ b/src/quafu/results/results.py @@ -1,4 +1,3 @@ - import numpy as np from functools import reduce import copy @@ -6,9 +5,11 @@ from collections import OrderedDict from ..utils.basis import * + class Result(object): """Basis class for quantum results""" - pass + pass + class ExecResult(Result): """ @@ -20,8 +21,9 @@ class ExecResult(Result): taskid (int): Unique task id for the execute result. transpiled_circuit (QuantumCircuit): Quantum circuit transpiled on backend. """ + def __init__(self, input_dict, measures): - status_map = {0:"In Queue", 1:"Running", 2:"Completed", "Canceled":3, 4:"Failed"} + status_map = {0: "In Queue", 1: "Running", 2: "Completed", "Canceled": 3, 4: "Failed"} self.measures = measures self.task_status = status_map[input_dict["status"]] self.res = eval(input_dict['res']) @@ -29,8 +31,8 @@ def __init__(self, input_dict, measures): self.logicalq_res = {} cbits = list(self.measures.values()) for key, values in self.counts.items(): - newkey = "".join([key[i] for i in cbits]) - self.logicalq_res[newkey] = values + newkey = "".join([key[i] for i in cbits]) + self.logicalq_res[newkey] = values self.taskid = input_dict['task_id'] self.taskname = input_dict['task_name'] @@ -40,10 +42,9 @@ def __init__(self, input_dict, measures): self.transpiled_circuit.from_openqasm(self.transpiled_openqasm) self.measure_base = [] total_counts = sum(self.counts.values()) - self.probabilities = {} + self.probabilities = {} for key in self.counts: - self.probabilities[key] = self.counts[key]/total_counts - + self.probabilities[key] = self.counts[key] / total_counts def calculate_obs(self, pos): """ @@ -52,7 +53,7 @@ def calculate_obs(self, pos): Args: pos (list[int]): Positions of observalbes. """ - return measure_obs(pos, self.logicalq_res) + return measure_obs(pos, self.logicalq_res) def plot_probabilities(self): """ @@ -61,7 +62,7 @@ def plot_probabilities(self): bitstrs = list(self.probabilities.keys()) probs = list(self.probabilities.values()) plt.figure() - plt.bar(range(len(probs)), probs, tick_label = bitstrs) + plt.bar(range(len(probs)), probs, tick_label=bitstrs) plt.xticks(rotation=70) plt.ylabel("probabilities") @@ -75,6 +76,7 @@ class SimuResult(Result): probabilities (ndarray): Calculated probabilities on each bitstring. rho (ndarray): Simulated density matrix of measured qubits """ + def __init__(self, input, input_form): self.num = int(np.log2(input.shape[0])) if input_form == "density_matrix": @@ -83,9 +85,9 @@ def __init__(self, input, input_form): elif input_form == "probabilities": self.probabilities = input elif input_form == "state_vector": - self.state_vector = input - - def plot_probabilities(self, full: bool=False, reverse_basis: bool=False, sort: bool=None): + self.state_vector = input + + def plot_probabilities(self, full: bool = False, reverse_basis: bool = False, sort: bool = None): """ Plot the probabilities from simulated results, ordered in big endian convention. @@ -102,9 +104,9 @@ def plot_probabilities(self, full: bool=False, reverse_basis: bool=False, sort: inds = np.where(self.probabilities > 1e-14)[0] probs = self.probabilities[inds] - basis=np.array([bin(i)[2:].zfill(self.num) for i in inds]) + basis = np.array([bin(i)[2:].zfill(self.num) for i in inds]) if reverse_basis: - basis=np.array([bin(i)[2:].zfill(self.num)[::-1] for i in inds]) + basis = np.array([bin(i)[2:].zfill(self.num)[::-1] for i in inds]) if sort == "ascend": orders = np.argsort(probs) @@ -115,7 +117,6 @@ def plot_probabilities(self, full: bool=False, reverse_basis: bool=False, sort: probs = probs[orders][::-1] basis = basis[orders][::-1] - plt.figure() plt.bar(inds, probs, tick_label=basis) plt.xticks(rotation=70) @@ -128,7 +129,7 @@ def calculate_obs(self, pos): "Calculate observables Z on input position using probabilities" inds = np.where(self.probabilities > 1e-14)[0] probs = self.probabilities[inds] - basis=np.array([bin(i)[2:].zfill(self.num) for i in inds]) + basis = np.array([bin(i)[2:].zfill(self.num) for i in inds]) res_reduced = dict(zip(basis, probs)) return measure_obs(pos, res_reduced) @@ -143,9 +144,10 @@ def intersec(a, b): inter.append(a[i]) aind.append(i) bind.append(j) - + return inter, aind, bind + def diff(a, b): diff = [] aind = [] @@ -153,7 +155,7 @@ def diff(a, b): if a[i] not in b: diff.append(a[i]) aind.append(i) - + return diff, aind @@ -164,12 +166,12 @@ def merge_measure(obslist): for obs in obslist: if len(measure_basis) == 0: measure_basis.append(obs) - targ_basis.append(len(measure_basis)-1) + targ_basis.append(len(measure_basis) - 1) else: added = 0 for mi in range(len(measure_basis)): measure_base = measure_basis[mi] - interset, intobsi, intbasei = intersec(obs[1], measure_base[1]) + interset, intobsi, intbasei = intersec(obs[1], measure_base[1]) diffset, diffobsi = diff(obs[1], measure_base[1]) if not len(interset) == 0: if all(np.array(list(obs[0]))[intobsi] == np.array(list(measure_base[0]))[intbasei]): @@ -185,8 +187,8 @@ def merge_measure(obslist): added = 1 break - if not added: + if not added: measure_basis.append(obs) - targ_basis.append(len(measure_basis)-1) + targ_basis.append(len(measure_basis) - 1) - return measure_basis, targ_basis \ No newline at end of file + return measure_basis, targ_basis From 0c3b06ff6f144d6aa1af04588a8ac4e291fb3b20 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 5 Jul 2023 12:51:03 +0800 Subject: [PATCH 27/70] "adjusted format according to PEP8" --- src/quafu/__init__.py | 5 +- src/quafu/backends/backends.py | 25 ++--- src/quafu/circuits/para_circuit.py | 10 +- src/quafu/circuits/quantum_circuit.py | 24 ++-- src/quafu/elements/quantum_element.py | 104 +++++++++--------- src/quafu/pulses/quantum_pulse.py | 40 +++---- src/quafu/qfasm/qfasm_convertor.py | 1 - src/quafu/qfasm/qfasm_parser.py | 26 +++-- src/quafu/qfasm/qfasmlex.py | 70 ++++++------ src/quafu/simulators/default_simulator.py | 55 ++++----- src/quafu/simulators/simulator.py | 22 ++-- .../visualisation/examples/deutsch_jozsa.py | 4 +- .../visualisation/figures/deutsch_jozsa.png | Bin 124193 -> 0 bytes 13 files changed, 193 insertions(+), 193 deletions(-) delete mode 100644 src/quafu/visualisation/figures/deutsch_jozsa.png diff --git a/src/quafu/__init__.py b/src/quafu/__init__.py index b13f90a..36699e6 100644 --- a/src/quafu/__init__.py +++ b/src/quafu/__init__.py @@ -1,10 +1,11 @@ from .circuits.quantum_circuit import QuantumCircuit -from .results.results import ExecResult, SimuResult +from .results.results import ExecResult, SimuResult from .tasks.tasks import Task from .users.userapi import User from .simulators.simulator import simulate __all__ = ["QuantumCircuit", "ExecResult", "Task", "User", "SimuResult", "simulate"] + def get_version(): - return "0.2.11" \ No newline at end of file + return "0.2.11" diff --git a/src/quafu/backends/backends.py b/src/quafu/backends/backends.py index 6c6eabd..6587eaa 100644 --- a/src/quafu/backends/backends.py +++ b/src/quafu/backends/backends.py @@ -6,8 +6,9 @@ import matplotlib.pyplot as plt from quafu.users.userapi import User + class Backend(object): - def __init__(self, backend_info : dict): + def __init__(self, backend_info: dict): self.name = backend_info['system_name'] self._valid_gates = backend_info['valid_gates'] self.qubit_num = backend_info['qubits'] @@ -15,14 +16,14 @@ def __init__(self, backend_info : dict): self.status = backend_info['status'] self.qv = backend_info["QV"] # self.task_in_queue = backend_info["task_in_queue"] - + def get_chip_info(self, user=User()): api_token = user.apitoken url = user._url data = {"system_name": self.name.lower()} - headers={"api_token": api_token} - chip_info = requests.post(url = url + user.chip_api, data=data, - headers=headers) + headers = {"api_token": api_token} + chip_info = requests.post(url=url + user.chip_api, data=data, + headers=headers) chip_info = json.loads(chip_info.text) json_topo_struct = chip_info["topological_structure"] qubits_list = [] @@ -70,17 +71,17 @@ def get_chip_info(self, user=User()): elarge = [(u, v) for (u, v, d) in G.edges(data=True) if d["weight"] >= 0.9] esmall = [(u, v) for (u, v, d) in G.edges(data=True) if d["weight"] < 0.9] - elarge_labels = {(u, v) : "%.3f" %d["weight"] for (u, v, d) in G.edges(data=True) if d["weight"] >= 0.9} - esmall_labels = {(u, v) : "%.3f" %d["weight"] for (u, v, d) in G.edges(data=True) if d["weight"] < 0.9} + elarge_labels = {(u, v): "%.3f" % d["weight"] for (u, v, d) in G.edges(data=True) if d["weight"] >= 0.9} + esmall_labels = {(u, v): "%.3f" % d["weight"] for (u, v, d) in G.edges(data=True) if d["weight"] < 0.9} - pos = nx.spring_layout(G, seed=1) + pos = nx.spring_layout(G, seed=1) fig, ax = plt.subplots() nx.draw_networkx_nodes(G, pos, node_size=400, ax=ax) nx.draw_networkx_edges(G, pos, edgelist=elarge, width=2, ax=ax) nx.draw_networkx_edges( G, pos, edgelist=esmall, width=2, alpha=0.5, style="dashed" - , ax=ax) + , ax=ax) nx.draw_networkx_labels(G, pos, font_size=14, font_family="sans-serif", ax=ax) edge_labels = nx.get_edge_attributes(G, "weight") @@ -89,11 +90,7 @@ def get_chip_info(self, user=User()): fig.set_figwidth(14) fig.set_figheight(14) fig.tight_layout() - return {"mapping" : int_to_qubit, "topology_diagram": fig, "full_info": chip_info} - + return {"mapping": int_to_qubit, "topology_diagram": fig, "full_info": chip_info} def get_valid_gates(self): return self._valid_gates - - - \ No newline at end of file diff --git a/src/quafu/circuits/para_circuit.py b/src/quafu/circuits/para_circuit.py index 8a31b96..04a85f1 100644 --- a/src/quafu/circuits/para_circuit.py +++ b/src/quafu/circuits/para_circuit.py @@ -1,8 +1,7 @@ - - from .quantum_circuit import QuantumCircuit from ..transpiler.Qcovercompiler import QcoverCompiler + class QAOACircuit(QuantumCircuit): def __init__(self, logical_qubits, physical_qubits, nodes, edges, params, p, gate="CNOT"): num = logical_qubits @@ -20,12 +19,9 @@ def compile_to_IOP(self): QASM from qcover directly """ qaoa_compiler = QcoverCompiler() - self.qasm = qaoa_compiler.graph_to_qasm(self.logical_qubits, self.physical_qubits, self.nodes, self.edges, self.paras, self.p, gate=self.gate) + self.qasm = qaoa_compiler.graph_to_qasm(self.logical_qubits, self.physical_qubits, self.nodes, self.edges, + self.paras, self.p, gate=self.gate) def upate_paras(self, paras): self.paras = paras pass - - - - diff --git a/src/quafu/circuits/quantum_circuit.py b/src/quafu/circuits/quantum_circuit.py index 58ab7aa..c5cad9b 100644 --- a/src/quafu/circuits/quantum_circuit.py +++ b/src/quafu/circuits/quantum_circuit.py @@ -1,10 +1,12 @@ from typing import Iterable import numpy as np -from ..elements.quantum_element import Barrier, Delay, ControlledGate, MultiQubitGate, ParaMultiQubitGate, QuantumGate, SingleQubitGate, XYResonance +from ..elements.quantum_element import Barrier, Delay, ControlledGate, MultiQubitGate, ParaMultiQubitGate, QuantumGate, \ + SingleQubitGate, XYResonance from quafu.pulses.quantum_pulse import QuantumPulse from ..elements.element_gates import * from ..exceptions import CircuitError + class QuantumCircuit(object): def __init__(self, num: int): """ @@ -25,7 +27,7 @@ def used_qubits(self) -> List: self.layered_circuit() return self._used_qubits - def add_gate(self, gate : QuantumGate): + def add_gate(self, gate: QuantumGate): self.gates.append(gate) def layered_circuit(self) -> np.ndarray: @@ -87,7 +89,7 @@ def layered_circuit(self) -> np.ndarray: self._used_qubits = list(used_qubits) return self.circuit - def draw_circuit(self, width : int=4, return_str : bool=False): + def draw_circuit(self, width: int = 4, return_str: bool = False): """ Draw layered circuit using ASCII, print in terminal. @@ -118,7 +120,7 @@ def draw_circuit(self, width : int=4, return_str : bool=False): printlist[2 * q1 + 1:2 * q2, l] = "|" printlist[q1 * 2, l] = "#" printlist[q2 * 2, l] = "#" - if isinstance(gate, ControlledGate): #Controlled-Multiqubit gate + if isinstance(gate, ControlledGate): # Controlled-Multiqubit gate for ctrl in gate.ctrls: printlist[reduce_map[ctrl] * 2, l] = "*" @@ -136,7 +138,7 @@ def draw_circuit(self, width : int=4, return_str : bool=False): printlist[tq1 + tq2, l] = gate.symbol maxlen = max(maxlen, len(gate.symbol) + width) - else: #Multiqubit gate + else: # Multiqubit gate if gate.name == "SWAP": printlist[q1 * 2, l] = "x" printlist[q2 * 2, l] = "x" @@ -152,7 +154,6 @@ def draw_circuit(self, width : int=4, return_str : bool=False): printlist[2 * q1:2 * q2 + 1, l] = "||" maxlen = max(maxlen, len("||")) - printlist[-1, l] = maxlen circuitstr = [] @@ -173,8 +174,7 @@ def draw_circuit(self, width : int=4, return_str : bool=False): else: print(circuitstr) - - def from_openqasm(self, openqasm : str): + def from_openqasm(self, openqasm: str): """ Initialize the circuit from openqasm text. Args: @@ -308,7 +308,6 @@ def from_openqasm(self, openqasm : str): if not global_valid: print("Warning: All operations after measurement will be removed for executing on experiment") - def to_openqasm(self) -> str: """ Convert the circuit to openqasm text. @@ -328,7 +327,6 @@ def to_openqasm(self) -> str: self.openqasm = qasm return qasm - def id(self, pos: int) -> "QuantumCircuit": """ Identity gate. @@ -566,7 +564,6 @@ def cp(self, ctrl: int, tar: int, para) -> "QuantumCircuit": self.gates.append(CPGate(ctrl, tar, para)) return self - def swap(self, q1: int, q2: int) -> "QuantumCircuit": """ SWAP gate @@ -590,7 +587,7 @@ def toffoli(self, ctrl1: int, ctrl2: int, targ: int) -> "QuantumCircuit": self.gates.append(ToffoliGate(ctrl1, ctrl2, targ)) return self - def fredkin(self, ctrl: int, targ1:int , targ2: int) -> "QuantumCircuit": + def fredkin(self, ctrl: int, targ1: int, targ2: int) -> "QuantumCircuit": """ Fredkin gate @@ -624,7 +621,7 @@ def delay(self, pos, duration, unit="ns") -> "QuantumCircuit": self.gates.append(Delay(pos, duration, unit=unit)) return self - def xy(self, qs: int, qe: int, duration: int, unit: str="ns") -> "QuantumCircuit": + def xy(self, qs: int, qe: int, duration: int, unit: str = "ns") -> "QuantumCircuit": """ XY resonance time evolution for quantum simulator Args: @@ -697,7 +694,6 @@ def mcz(self, ctrls: List[int], targ: int): """ self.gates.append(MCZGate(ctrls, targ)) - def measure(self, pos: List[int], cbits: List[int] = []) -> None: """ Measurement setting for experiment device. diff --git a/src/quafu/elements/quantum_element.py b/src/quafu/elements/quantum_element.py index a04e639..4bee26f 100644 --- a/src/quafu/elements/quantum_element.py +++ b/src/quafu/elements/quantum_element.py @@ -4,13 +4,14 @@ from functools import reduce import copy -def reorder_matrix(matrix : np.ndarray, pos : List): + +def reorder_matrix(matrix: np.ndarray, pos: List): """Reorder the input sorted matrix to the pos order """ qnum = len(pos) - dim = 2**qnum + dim = 2 ** qnum inds = np.argsort(pos) - inds = np.concatenate([inds, inds+qnum]) - tensorm = matrix.reshape([2]*2*qnum) + inds = np.concatenate([inds, inds + qnum]) + tensorm = matrix.reshape([2] * 2 * qnum) return np.transpose(tensorm, inds).reshape([dim, dim]) @@ -32,18 +33,19 @@ def __repr__(self): return f"{self.__class__.__name__}" def to_qasm(self): - return "barrier " + ",".join(["q[%d]" % p for p in range(min(self.pos), max(self.pos)+1)]) + return "barrier " + ",".join(["q[%d]" % p for p in range(min(self.pos), max(self.pos) + 1)]) + class Delay(object): - def __init__(self, pos : int, duration : int, unit="ns"): + def __init__(self, pos: int, duration: int, unit="ns"): self.name = "delay" if isinstance(duration, int): self.duration = duration else: raise TypeError("duration must be int") - self.unit=unit - self.pos=pos - self.symbol = "Delay(%d%s)" %(duration, unit) + self.unit = unit + self.pos = pos + self.symbol = "Delay(%d%s)" % (duration, unit) def __repr__(self): return f"{self.__class__.__name__}" @@ -51,39 +53,43 @@ def __repr__(self): def to_qasm(self): return "delay(%d%s) q[%d]" % (self.duration, self.unit, self.pos) + class XYResonance(object): - def __init__(self, qs : int, qe : int, duration : int, unit="ns"): + def __init__(self, qs: int, qe: int, duration: int, unit="ns"): self.name = "XY" if isinstance(duration, int): self.duration = duration else: raise TypeError("duration must be int") - self.unit=unit - self.pos=list(range(qs, qe+1)) - self.symbol = "XY(%d%s)" %(duration, unit) + self.unit = unit + self.pos = list(range(qs, qe + 1)) + self.symbol = "XY(%d%s)" % (duration, unit) def to_qasm(self): - return "xy(%d%s) " %(self.duration, self.unit) + ",".join(["q[%d]" % p for p in range(min(self.pos), max(self.pos)+1)]) + return "xy(%d%s) " % (self.duration, self.unit) + ",".join( + ["q[%d]" % p for p in range(min(self.pos), max(self.pos) + 1)]) + class Measure(object): - def __init__(self, bitmap : dict): + def __init__(self, bitmap: dict): self.qbits = bitmap.keys() self.cbits = bitmap.values() + class QuantumGate(object): - def __init__(self, name: str, pos: Union[int, List[int]], paras: Union[None,float, List[float]], matrix): + def __init__(self, name: str, pos: Union[int, List[int]], paras: Union[None, float, List[float]], matrix): self.name = name self.pos = pos self.paras = paras self.matrix = matrix - + if paras: if isinstance(paras, Iterable): - self.symbol = "%s(" %self.name + ",".join(["%.3f" %para for para in self.paras]) + ")" + self.symbol = "%s(" % self.name + ",".join(["%.3f" % para for para in self.paras]) + ")" else: self.symbol = "%s(%.3f)" % (self.name, paras) else: - self.symbol = "%s" %self.name + self.symbol = "%s" % self.name @property def name(self): @@ -127,21 +133,22 @@ def __repr__(self): return f"{self.__class__.__name__}" def to_qasm(self): - qstr = "%s" %self.name.lower() - + qstr = "%s" % self.name.lower() + if self.paras: if isinstance(self.paras, Iterable): - qstr += "(" + ",".join(["%s" %para for para in self.paras]) + ")" + qstr += "(" + ",".join(["%s" % para for para in self.paras]) + ")" else: - qstr += "(%s)" %self.paras + qstr += "(%s)" % self.paras qstr += " " if isinstance(self.pos, Iterable): qstr += ",".join(["q[%d]" % p for p in self.pos]) else: - qstr += "q[%d]" %self.pos - + qstr += "q[%d]" % self.pos + return qstr + class SingleQubitGate(QuantumGate): def __init__(self, name: str, pos: int, paras, matrix): super().__init__(name, pos, paras=paras, matrix=matrix) @@ -164,7 +171,7 @@ def matrix(self, matrix): def get_targ_matrix(self, reverse_order=False): return self.matrix - + class FixedSingleQubitGate(SingleQubitGate): def __init__(self, name, pos, matrix): @@ -214,19 +221,18 @@ def matrix(self, matrix): self._matrix = reorder_matrix(self._matrix, self.pos) - def get_targ_matrix(self, reverse_order=False): targ_matrix = self._targ_matrix if reverse_order and (len(self.pos) > 1): qnum = len(self.pos) order = np.array(range(len(self.pos))[::-1]) - order = np.concatenate([order, order+qnum]) - dim = 2**qnum - tensorm = targ_matrix.reshape([2]*2*qnum) + order = np.concatenate([order, order + qnum]) + dim = 2 ** qnum + tensorm = targ_matrix.reshape([2] * 2 * qnum) targ_matrix = np.transpose(tensorm, order).reshape([dim, dim]) return targ_matrix - + class FixedMultiQubitGate(MultiQubitGate): def __init__(self, name: str, pos: List[int], matrix): @@ -251,46 +257,46 @@ def matrix(self, matrix): self._matrix = reorder_matrix(self._matrix, self.pos) else: raise TypeError("Unsupported `matrix` type") - + class ControlledGate(MultiQubitGate): """ Controlled gate class, where the matrix act non-trivaly on target qubits""" + def __init__(self, name, targe_name, ctrls: List[int], targs: List[int], paras, matrix): self.ctrls = ctrls self.targs = targs self.targ_name = targe_name - super().__init__(name, ctrls+targs, paras, matrix) + super().__init__(name, ctrls + targs, paras, matrix) self._targ_matrix = matrix if paras: if isinstance(paras, Iterable): - self.symbol = "%s(" %self.targ_name + ",".join(["%.3f" %para for para in self.paras]) + ")" + self.symbol = "%s(" % self.targ_name + ",".join(["%.3f" % para for para in self.paras]) + ")" else: self.symbol = "%s(%.3f)" % (self.targ_name, paras) else: - self.symbol = "%s" %self.targ_name + self.symbol = "%s" % self.targ_name - @property def matrix(self): return self._matrix @matrix.setter - def matrix(self, matrix : Union[np.ndarray, Callable]): - targ_dim = 2**(len(self.targs)) + def matrix(self, matrix: Union[np.ndarray, Callable]): + targ_dim = 2 ** (len(self.targs)) qnum = len(self.pos) - dim = 2**(qnum) + dim = 2 ** (qnum) if isinstance(matrix, Callable): matrix = matrix(self.paras) if matrix.shape[0] != targ_dim: raise ValueError("Dimension dismatch") else: - self._matrix = np.zeros((dim , dim), dtype=complex) - control_dim = 2**len(self.pos) - targ_dim + self._matrix = np.zeros((dim, dim), dtype=complex) + control_dim = 2 ** len(self.pos) - targ_dim for i in range(control_dim): self._matrix[i, i] = 1. - + self._matrix[control_dim:, control_dim:] = matrix self._matrix = reorder_matrix(self._matrix, self.pos) # self._targ_matrix = reorder_matrix(matrix, self.targs) @@ -300,24 +306,22 @@ def get_targ_matrix(self, reverse_order=False): if reverse_order and (len(self.targs) > 1): qnum = len(self.targs) order = np.array(range(len(self.targs))[::-1]) - order = np.concatenate([order, order+qnum]) - dim = 2**qnum - tensorm = targ_matrix.reshape([2]*2*qnum) + order = np.concatenate([order, order + qnum]) + dim = 2 ** qnum + tensorm = targ_matrix.reshape([2] * 2 * qnum) targ_matrix = np.transpose(tensorm, order).reshape([dim, dim]) return targ_matrix + class ControlledU(ControlledGate): def __init__(self, name, ctrls: List[int], U: Union[SingleQubitGate, MultiQubitGate]): self.targ_gate = U targs = U.pos if isinstance(targs, int): targs = [targs] - + super().__init__(name, U.name, ctrls, targs, U.paras, matrix=self.targ_gate.get_targ_matrix()) - + def get_targ_matrix(self, reverse_order=False): return self.targ_gate.get_targ_matrix(reverse_order) - - - diff --git a/src/quafu/pulses/quantum_pulse.py b/src/quafu/pulses/quantum_pulse.py index 4d8cda0..c4587eb 100644 --- a/src/quafu/pulses/quantum_pulse.py +++ b/src/quafu/pulses/quantum_pulse.py @@ -4,15 +4,16 @@ from copy import deepcopy import scipy.special + class QuantumPulse(object): def __init__(self, - name:str, + name: str, pos: Union[int, list], paras: list, - duration: Union[float,int], + duration: Union[float, int], unit: str, channel: str, - time_func: Optional[Callable] = None, + time_func: Optional[Callable] = None, ): """ Quantum Pulse for generating a quantum gate. @@ -28,7 +29,7 @@ def __init__(self, Where t=0 is the start, t=duration is the end of the pulse. """ - + self.name = name self.pos = pos self.paras = paras @@ -39,7 +40,7 @@ def __init__(self, self.channel = channel else: raise ValueError("channel must be 'XY' or 'Z'") - + @property def symbol(self): return "%s(%d%s, %s)" % (self.name, self.duration, self.unit, self.channel) @@ -50,8 +51,8 @@ def __repr__(self): def __str__(self): symbol = "%s(%d%s" % (self.name, self.duration, self.unit) for para in self.paras: - symbol += ", %s" %para - symbol += ", %s" %self.channel + symbol += ", %s" % para + symbol += ", %s" % self.channel symbol += ")" return symbol @@ -59,7 +60,7 @@ def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0., offset: Union[float, int] = 0., - args : dict = None + args: dict = None ): """ Return pulse data. @@ -80,8 +81,8 @@ def __copy__(self): return deepcopy(self) def to_qasm(self): - return self.__str__() + " q[%d]" %self.pos - + return self.__str__() + " q[%d]" % self.pos + def plot(self, t: Optional[np.ndarray] = None, shift: Union[float, int] = 0., @@ -130,7 +131,7 @@ def set_unit(self, unit="ns"): class RectPulse(QuantumPulse): - def __init__(self, pos, amp, duration, unit ,channel): + def __init__(self, pos, amp, duration, unit, channel): self.amp = amp def rect_time_func(t, **kws): @@ -139,13 +140,13 @@ def rect_time_func(t, **kws): super().__init__("rect", pos, [amp], duration, unit, channel, rect_time_func) - def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): args = {"amp": self.amp} return super().__call__(t, shift, offset, args) + class FlattopPulse(QuantumPulse): - def __init__(self, pos, amp, fwhm, duration, unit ,channel): + def __init__(self, pos, amp, fwhm, duration, unit, channel): self.amp = amp self.fwhm = fwhm @@ -153,17 +154,17 @@ def flattop_time_func(t, **kws): amp_, fwhm_ = kws["amp"], kws["fwhm"] sigma_ = fwhm_ / (2 * np.sqrt(np.log(2))) return amp_ * (scipy.special.erf((duration - t) / sigma_) - + scipy.special.erf(t / sigma_) - 1.) + + scipy.special.erf(t / sigma_) - 1.) super().__init__("flattop", pos, [amp, fwhm], duration, unit, channel, flattop_time_func) - def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): args = {"amp": self.amp, "fwhm": self.fwhm} return super().__call__(t, shift, offset, args) + class GaussianPulse(QuantumPulse): - def __init__(self, pos, amp, fwhm, phase, duration, unit ,channel): + def __init__(self, pos, amp, fwhm, phase, duration, unit, channel): self.amp = amp if fwhm == None: self.fwhm = 0.5 * duration @@ -178,10 +179,9 @@ def gaussian_time_func(t, **kws): sigma_ = fwhm_ / np.sqrt(8 * np.log(2)) # fwhm to std. deviation return amp_ * np.exp( -(t - 0.5 * duration) ** 2 / (2 * sigma_ ** 2) + 1j * phase_) - + super().__init__("gaussian", pos, [amp, fwhm, phase], duration, unit, channel, gaussian_time_func) - + def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): - args = {"amp": self.amp, "fwhm": self.fwhm, "phase":self.phase} + args = {"amp": self.amp, "fwhm": self.fwhm, "phase": self.phase} return super().__call__(t, shift, offset, args) - diff --git a/src/quafu/qfasm/qfasm_convertor.py b/src/quafu/qfasm/qfasm_convertor.py index 9b2f419..669a6c7 100644 --- a/src/quafu/qfasm/qfasm_convertor.py +++ b/src/quafu/qfasm/qfasm_convertor.py @@ -1,4 +1,3 @@ - from .qfasm_parser import QfasmParser, QregNode from quafu.dagcircuits.circuit_dag import node_to_gate from quafu.dagcircuits.instruction_node import InstructionNode diff --git a/src/quafu/qfasm/qfasm_parser.py b/src/quafu/qfasm/qfasm_parser.py index 40ac2ad..0c611c2 100644 --- a/src/quafu/qfasm/qfasm_parser.py +++ b/src/quafu/qfasm/qfasm_parser.py @@ -1,4 +1,3 @@ - import ply.yacc as yacc from quafu.elements.element_gates import * @@ -6,11 +5,13 @@ from quafu.dagcircuits.instruction_node import InstructionNode from .qfasmlex import QfasmLexer + # import numpy as np class DeclarationNode(object): pass + class QregNode(DeclarationNode): def __init__(self, n): self.n = n @@ -19,7 +20,8 @@ def __repr__(self): return self.__str__() def __str__(self): - return "qreg[%d]" %self.n + return "qreg[%d]" % self.n + class CregNode(DeclarationNode): def __init__(self, n): @@ -29,7 +31,8 @@ def __repr__(self): return self.__str__() def __str__(self): - return "creg[%d]" %self.n + return "creg[%d]" % self.n + class IncludeNode(DeclarationNode): def __init__(self, filename): @@ -39,7 +42,8 @@ def __repr__(self): return self.__str__() def __str__(self): - return "include %s" %self.file + return "include %s" % self.file + class OPENQASMNode(DeclarationNode): def __init__(self, version): @@ -49,17 +53,18 @@ def __repr__(self): return self.__str__() def __str__(self): - return "OPENQASM %.1f" %self.version + return "OPENQASM %.1f" % self.version class QfasmParser(object): tokens = QfasmLexer.tokens + def __init__(self, debug=False): self.parser = yacc.yacc(module=self, debug=debug) self.parsed_nodes = [] - self.lexer = QfasmLexer() + self.lexer = QfasmLexer() - def parse(self, input : str): + def parse(self, input: str): self.parsed_nodes = self.parser.parse(input, lexer=QfasmLexer()) return self.parsed_nodes @@ -69,7 +74,7 @@ def p_main_0(self, p): """ p[0] = [p[1]] - def p_main_1(self, p): + def p_main_1(self, p): """ main : main program """ @@ -104,7 +109,7 @@ def p_include(self, p): """ p[0] = IncludeNode(p[2]) - def p_qreg(self, p): #TODO:verify register name + def p_qreg(self, p): # TODO:verify register name """ qreg : QREG bitreg ';' """ @@ -124,7 +129,6 @@ def p_instruction(self, p): """ p[0] = p[1] - def p_arg_list_0(self, p): """ arg_list : expression @@ -160,7 +164,7 @@ def p_measure_0(self, p): ''' measure : MEASURE bitreg ASSIGN bitreg ''' - p[0] = InstructionNode("measure", {p[2] : p[4]}, None, None, None, "", None, "") + p[0] = InstructionNode("measure", {p[2]: p[4]}, None, None, None, "", None, "") def p_pulse_like_1(self, p): ''' diff --git a/src/quafu/qfasm/qfasmlex.py b/src/quafu/qfasm/qfasmlex.py index e456d8c..797987c 100644 --- a/src/quafu/qfasm/qfasmlex.py +++ b/src/quafu/qfasm/qfasmlex.py @@ -4,49 +4,50 @@ # interaction with quantum hardware import ply.lex as lex -import numpy as np +import numpy as np + class QfasmLexer(object): def __init__(self): self.build() - + def input(self, data): self.data = data self.lexer.input(data) - + def token(self): ret = self.lexer.token() return ret - + literals = r'=()[]{};<>,.+-/*^"' reserved = { - "creg" : "CREG", - "qreg" : "QREG", - "pi" : "PI", - "measure" : "MEASURE", - "include" : "INCLUDE" + "creg": "CREG", + "qreg": "QREG", + "pi": "PI", + "measure": "MEASURE", + "include": "INCLUDE" } tokens = [ - "FLOAT", - "INT", - "STRING", - "ASSIGN", - "MATCHES", - "ID", - "UNIT", - "CHANNEL", - "OPENQASM", - "NONE" - ] + list(reserved.values()) + "FLOAT", + "INT", + "STRING", + "ASSIGN", + "MATCHES", + "ID", + "UNIT", + "CHANNEL", + "OPENQASM", + "NONE" + ] + list(reserved.values()) def t_FLOAT(self, t): r"(([1-9]\d*\.\d*)|(0\.\d*[1-9]\d*))" t.value = float(t.value) return t - + def t_INT(self, t): r"\d+" t.value = int(t.value) @@ -55,11 +56,11 @@ def t_INT(self, t): def t_STRING(self, t): r"\"([^\\\"]|\\.)*\"" return t - + def t_ASSIGN(self, t): r"->" return t - + def t_MATCHES(self, t): r"==" return t @@ -71,32 +72,32 @@ def t_UNIT(self, t): def t_CHANNEL(self, t): r"XY|Z" return t - + def t_OPENQASM(self, t): r"OPENQASM" return t - + def t_NONE(self, t): r"None" return t - + def t_ID(self, t): r"[a-z][a-zA-Z0-9_]*" t.type = self.reserved.get(t.value, "ID") return t - - t_ignore=" \t\r" + + t_ignore = " \t\r" def t_error(self, t): - print("Illegal character '%s'" %t.value[0]) - + print("Illegal character '%s'" % t.value[0]) + def t_newline(self, t): r"\n+" t.lexer.lineno += len(t.value) - + def build(self, **kwargs): self.lexer = lex.lex(module=self, **kwargs) - + def test(self, data): self.lexer.input(data) while True: @@ -104,8 +105,9 @@ def test(self, data): if not tok: break print(tok) - + + if __name__ == "__main__": m = QfasmLexer() m.build() - m.test("rx(21ns, pi) q[0], q[1]") \ No newline at end of file + m.test("rx(21ns, pi) q[0], q[1]") diff --git a/src/quafu/simulators/default_simulator.py b/src/quafu/simulators/default_simulator.py index aee53a5..4db06c1 100644 --- a/src/quafu/simulators/default_simulator.py +++ b/src/quafu/simulators/default_simulator.py @@ -1,9 +1,9 @@ -#default circuit simulator for state vector +# default circuit simulator for state vector from typing import Iterable, List, Union from quafu.circuits.quantum_circuit import QuantumCircuit from ..results.results import SimuResult -from ..elements.quantum_element import Barrier, Delay, QuantumGate, SingleQubitGate, MultiQubitGate, XYResonance +from ..elements.quantum_element import Barrier, Delay, QuantumGate, SingleQubitGate, MultiQubitGate, XYResonance import numpy as np from functools import reduce from sparse import COO, SparseArray @@ -11,44 +11,46 @@ import copy + def global_op(gate: QuantumGate, global_qubits: List) -> coo_matrix: """Local operators to global operators""" - num = len(global_qubits) + num = len(global_qubits) if isinstance(gate, SingleQubitGate): - local_mat = coo_matrix(gate.matrix) + local_mat = coo_matrix(gate.matrix) pos = global_qubits.index(gate.pos) - local_mat = kron(kron(eye(2**pos), local_mat), eye(2**(num - pos-1))) + local_mat = kron(kron(eye(2 ** pos), local_mat), eye(2 ** (num - pos - 1))) return local_mat elif isinstance(gate, MultiQubitGate): - local_mat =coo_matrix(gate.matrix) + local_mat = coo_matrix(gate.matrix) pos = [global_qubits.index(p) for p in gate.pos] num_left = min(pos) num_right = num - max(pos) - 1 num_center = max(pos) - min(pos) + 1 - center_mat = kron(local_mat, eye(2**(num_center - len(pos)))) + center_mat = kron(local_mat, eye(2 ** (num_center - len(pos)))) origin_order = sorted(pos) - origin_order.extend([p for p in range(min(pos), max(pos)+1) if p not in pos]) + origin_order.extend([p for p in range(min(pos), max(pos) + 1) if p not in pos]) new_order = np.argsort(origin_order) center_mat = COO.from_scipy_sparse(center_mat) center_mat = permutebits(center_mat, new_order).to_scipy_sparse() - center_mat = kron(kron(eye(2**num_left), center_mat), eye(2**num_right)) + center_mat = kron(kron(eye(2 ** num_left), center_mat), eye(2 ** num_right)) return center_mat -def permutebits(mat: Union[SparseArray, np.ndarray], order : Iterable)\ - ->Union[SparseArray, np.ndarray]: +def permutebits(mat: Union[SparseArray, np.ndarray], order: Iterable) \ + -> Union[SparseArray, np.ndarray]: """permute qubits for operators or states""" num = len(order) order = np.array(order) r = len(mat.shape) - mat = np.reshape(mat, [2]*r*num) - order = np.concatenate([order+len(order)*i for i in range(r)]) + mat = np.reshape(mat, [2] * r * num) + order = np.concatenate([order + len(order) * i for i in range(r)]) mat = np.transpose(mat, order) - mat = np.reshape(mat, [2**num]*r) + mat = np.reshape(mat, [2 ** num] * r) return mat -def ptrace(psi, ind_A: List, diag: bool=True) -> np.ndarray: + +def ptrace(psi, ind_A: List, diag: bool = True) -> np.ndarray: """partial trace on a state vector""" num = int(np.log2(psi.shape[0])) order = copy.deepcopy(ind_A) @@ -56,18 +58,19 @@ def ptrace(psi, ind_A: List, diag: bool=True) -> np.ndarray: psi = permutebits(psi, order) if diag: - psi = np.abs(psi)**2 - psi = np.reshape(psi, [2**len(ind_A), 2**(num-len(ind_A))]) + psi = np.abs(psi) ** 2 + psi = np.reshape(psi, [2 ** len(ind_A), 2 ** (num - len(ind_A))]) psi = np.sum(psi, axis=1) - return psi + return psi else: - psi = np.reshape(psi, [2**len(ind_A), 2**(num-len(ind_A))]) + psi = np.reshape(psi, [2 ** len(ind_A), 2 ** (num - len(ind_A))]) rho = psi @ np.conj(np.transpose(psi)) return rho -def py_simulate(qc: QuantumCircuit, - state_ini: np.ndarray = np.array([]), - output: str="amplitudes") -> SimuResult: + +def py_simulate(qc: QuantumCircuit, + state_ini: np.ndarray = np.array([]), + output: str = "amplitudes") -> SimuResult: """Simulate quantum circuit Args: qc: quantum circuit need to be simulated. @@ -82,17 +85,15 @@ def py_simulate(qc: QuantumCircuit, used_qubits = qc.used_qubits num = len(used_qubits) if not state_ini: - psi = np.zeros(2**num) + psi = np.zeros(2 ** num) psi[0] = 1 else: psi = state_ini - for gate in qc.gates: - if not ((isinstance(gate, Delay)) or (isinstance(gate, Barrier)) or isinstance(gate, XYResonance)): + for gate in qc.gates: + if not ((isinstance(gate, Delay)) or (isinstance(gate, Barrier)) or isinstance(gate, XYResonance)): op = global_op(gate, used_qubits) psi = op @ psi return psi - - \ No newline at end of file diff --git a/src/quafu/simulators/simulator.py b/src/quafu/simulators/simulator.py index 004afd0..3f13f95 100644 --- a/src/quafu/simulators/simulator.py +++ b/src/quafu/simulators/simulator.py @@ -1,4 +1,3 @@ - from typing import Union from .default_simulator import py_simulate, ptrace, permutebits from .qfvm import simulate_circuit, execute @@ -7,7 +6,9 @@ import numpy as np from ..exceptions import QuafuError -def simulate(qc : Union[QuantumCircuit, str], psi : np.ndarray= np.array([]), simulator:str ="qfvm_circ", output: str="probabilities", use_gpu: bool=False, use_custatevec: bool=False)-> SimuResult: + +def simulate(qc: Union[QuantumCircuit, str], psi: np.ndarray = np.array([]), simulator: str = "qfvm_circ", + output: str = "probabilities", use_gpu: bool = False, use_custatevec: bool = False) -> SimuResult: """Simulate quantum circuit Args: qc: quantum circuit or qasm string that need to be simulated. @@ -33,11 +34,11 @@ def simulate(qc : Union[QuantumCircuit, str], psi : np.ndarray= np.array([]), si qasm = qc qc = QuantumCircuit(0) qc.from_openqasm(qasm) - + measures = [qc.used_qubits.index(i) for i in qc.measures.keys()] num = 0 if simulator == "qfvm_circ": - num = max(qc.used_qubits)+1 + num = max(qc.used_qubits) + 1 measures = list(qc.measures.keys()) if use_gpu: if use_custatevec: @@ -54,17 +55,16 @@ def simulate(qc : Union[QuantumCircuit, str], psi : np.ndarray= np.array([]), si psi = simulate_circuit_gpu(qc, psi) else: psi = simulate_circuit(qc, psi) - - elif simulator == "py_simu": + + elif simulator == "py_simu": psi = py_simulate(qc, psi) elif simulator == "qfvm_qasm": num = qc.num measures = list(qc.measures.keys()) - psi = execute(qasm) + psi = execute(qasm) else: raise ValueError("invalid circuit") - if output == "density_matrix": if simulator in ["qfvm_circ", "qfvm_qasm"]: psi = permutebits(psi, range(num)[::-1]) @@ -77,10 +77,10 @@ def simulate(qc : Union[QuantumCircuit, str], psi : np.ndarray= np.array([]), si psi = permutebits(psi, range(num)[::-1]) probabilities = ptrace(psi, measures) probabilities = permutebits(probabilities, list(qc.measures.values())) - return SimuResult(probabilities, output) - + return SimuResult(probabilities, output) + elif output == "state_vector": return SimuResult(psi, output) else: - raise ValueError("output should in be 'density_matrix', 'probabilities', or 'state_vector'") \ No newline at end of file + raise ValueError("output should in be 'density_matrix', 'probabilities', or 'state_vector'") diff --git a/src/quafu/visualisation/examples/deutsch_jozsa.py b/src/quafu/visualisation/examples/deutsch_jozsa.py index 25af135..357408c 100644 --- a/src/quafu/visualisation/examples/deutsch_jozsa.py +++ b/src/quafu/visualisation/examples/deutsch_jozsa.py @@ -3,8 +3,8 @@ import matplotlib.pyplot as plt import numpy as np -from quafu import QuantumCircuit -from visualisation.circuitPlot import CircuitPlotManager +from quafu.circuits.quantum_circuit import QuantumCircuit +from ..circuitPlot import CircuitPlotManager def get_const_oracle(n: int): diff --git a/src/quafu/visualisation/figures/deutsch_jozsa.png b/src/quafu/visualisation/figures/deutsch_jozsa.png deleted file mode 100644 index 5f40dd32b9f1fb007ffec626b59baee2db84cf2a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 124193 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 From 244e08ddaa41c988a52a0e6ad49711fac9f80db0 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 5 Jul 2023 16:33:12 +0800 Subject: [PATCH 28/70] "optimized import in quantum_circuit.py" Some unused 'imports' were removed. And it's not suggested to use 'from xxx import *' to avoid namespace conflicts. --- src/quafu/circuits/quantum_circuit.py | 17 ++- src/quafu/elements/element_gates.py | 147 +++++++++++++++----------- src/quafu/elements/quantum_element.py | 5 +- 3 files changed, 100 insertions(+), 69 deletions(-) diff --git a/src/quafu/circuits/quantum_circuit.py b/src/quafu/circuits/quantum_circuit.py index c5cad9b..a77884e 100644 --- a/src/quafu/circuits/quantum_circuit.py +++ b/src/quafu/circuits/quantum_circuit.py @@ -1,9 +1,14 @@ -from typing import Iterable +from typing import List import numpy as np -from ..elements.quantum_element import Barrier, Delay, ControlledGate, MultiQubitGate, ParaMultiQubitGate, QuantumGate, \ - SingleQubitGate, XYResonance + from quafu.pulses.quantum_pulse import QuantumPulse -from ..elements.element_gates import * +from ..elements.quantum_element import Barrier, Delay, MultiQubitGate, QuantumGate, ControlledGate, \ + SingleQubitGate, XYResonance +from ..elements.element_gates import IdGate, HGate, XGate, YGate, ZGate, \ + SGate, TGate, RXGate, RYGate, RZGate, CZGate, TdgGate, SdgGate, SXGate, SYGate, WGate, \ + SWGate, PhaseGate, CXGate, CYGate, CSGate, CTGate, CPGate, SwapGate, ToffoliGate, FredkinGate, \ + RXXGate, RYYGate, RZZGate, MCXGate, MCYGate, MCZGate + from ..exceptions import CircuitError @@ -395,6 +400,7 @@ def tdg(self, pos: int) -> "QuantumCircuit": pos (int): qubit the gate act. """ self.gates.append(TdgGate(pos)) + return self def s(self, pos: int) -> "QuantumCircuit": """ @@ -498,6 +504,7 @@ def p(self, pos: int, para: float) -> "QuantumCircuit": para (float): rotation angle """ self.gates.append(PhaseGate(pos, para)) + return self def cnot(self, ctrl: int, tar: int) -> "QuantumCircuit": """ @@ -694,7 +701,7 @@ def mcz(self, ctrls: List[int], targ: int): """ self.gates.append(MCZGate(ctrls, targ)) - def measure(self, pos: List[int], cbits: List[int] = []) -> None: + def measure(self, pos: List[int], cbits: List[int] = None) -> None: """ Measurement setting for experiment device. diff --git a/src/quafu/elements/element_gates.py b/src/quafu/elements/element_gates.py index 452d790..cb982bb 100644 --- a/src/quafu/elements/element_gates.py +++ b/src/quafu/elements/element_gates.py @@ -1,19 +1,19 @@ # This is the file for concrete element quantum gates -from .quantum_element import ControlledGate, FixedSingleQubitGate, ParaMultiQubitGate, ParaSingleQubitGate,\ - ControlledGate, FixedMultiQubitGate import numpy as np -from typing import List from scipy.linalg import sqrtm +from .quantum_element import FixedSingleQubitGate, ParaMultiQubitGate, ParaSingleQubitGate, \ + ControlledGate, FixedMultiQubitGate + def _u2matrix(_phi=0., _lambda=0.): - "OpenQASM 3.0 specification" + """OpenQASM 3.0 specification""" return np.array([[1., np.exp(-1.j * _lambda)], [np.exp(1.j * _phi), np.exp((_phi + _lambda) * 1.j)]], dtype=complex) def _u3matrix(_theta=0., _phi=0., _lambda=0.): - "OpenQASM 3.0 specification" + """OpenQASM 3.0 specification""" return np.array([[np.cos(0.5 * _theta), -np.exp(_lambda * 1.j) * np.sin(0.5 * _theta)], [np.exp(_phi * 1.j) * np.sin(0.5 * _theta), np.exp((_phi + _lambda) * 1.j) * np.cos(0.5 * _theta)]], dtype=complex) @@ -33,37 +33,43 @@ def _rzmatrix(theta): return np.array([[np.exp(-0.5j * theta), 0.], [0., np.exp(0.5j * theta)]], dtype=complex) + def _pmatrix(labda): - return np.array([[1, 0], - [0, np.exp(1j*labda)]] ,dtype=complex) + return np.array([[1, 0], + [0, np.exp(1j * labda)]], dtype=complex) + def _rxxmatrix(theta): """Unitary evolution of XX interaction""" - return np.array([[np.cos(theta/2), 0, 0, -1j*np.sin(theta/2)], - [0, np.cos(theta/2), -1j*np.sin(theta/2), 0], - [0, -1j*np.sin(theta/2), np.cos(theta/2), 0], - [-1j*np.sin(theta/2), 0, 0, np.cos(theta/2)] - ]) + return np.array([[np.cos(theta / 2), 0, 0, -1j * np.sin(theta / 2)], + [0, np.cos(theta / 2), -1j * np.sin(theta / 2), 0], + [0, -1j * np.sin(theta / 2), np.cos(theta / 2), 0], + [-1j * np.sin(theta / 2), 0, 0, np.cos(theta / 2)] + ]) + def _ryymatrix(theta): """ Unitary evolution of YY interaction""" - return np.array([[np.cos(theta/2), 0, 0, 1j*np.sin(theta/2)], - [0, np.cos(theta/2), -1j*np.sin(theta/2), 0], - [0, -1j*np.sin(theta/2), np.cos(theta/2), 0], - [1j*np.sin(theta/2), 0, 0, np.cos(theta/2)] - ]) + return np.array([[np.cos(theta / 2), 0, 0, 1j * np.sin(theta / 2)], + [0, np.cos(theta / 2), -1j * np.sin(theta / 2), 0], + [0, -1j * np.sin(theta / 2), np.cos(theta / 2), 0], + [1j * np.sin(theta / 2), 0, 0, np.cos(theta / 2)] + ]) + def _rzzmatrix(theta): - return np.array([[np.exp(-1j*theta/2), 0, 0, 0], - [0, np.exp(1j*theta/2), 0, 0], - [0, 0, np.exp(1j*theta/2), 0], - [0, 0, 0, np.exp(-1j*theta/2)] - ]) + return np.array([[np.exp(-1j * theta / 2), 0, 0, 0], + [0, np.exp(1j * theta / 2), 0, 0], + [0, 0, np.exp(1j * theta / 2), 0], + [0, 0, 0, np.exp(-1j * theta / 2)] + ]) + class IdGate(FixedSingleQubitGate): def __init__(self, pos: int): - super().__init__("Id", pos, matrix = np.array([[1., 0.], - [0., 1.]], dtype=complex)) + super().__init__("Id", pos, matrix=np.array([[1., 0.], + [0., 1.]], dtype=complex)) + class HGate(FixedSingleQubitGate): def __init__(self, pos: int): @@ -88,40 +94,47 @@ def __init__(self, pos: int): super().__init__("Z", pos, matrix=np.array([[1., 0.], [0., -1.]], dtype=complex)) + class SGate(FixedSingleQubitGate): def __init__(self, pos: int): super().__init__("S", pos, matrix=np.array([[1., 0.], [0., 1.j]], dtype=complex)) + class SdgGate(FixedSingleQubitGate): def __init__(sell, pos: int): - super().__init__("Sdg", pos, matrix = np.array([[1., 0.], - [0., -1.j]], dtype=complex)) + super().__init__("Sdg", pos, matrix=np.array([[1., 0.], + [0., -1.j]], dtype=complex)) + class TGate(FixedSingleQubitGate): def __init__(self, pos: int): super().__init__("T", pos, matrix=np.array([[1., 0.], - [0., np.exp(1.j*np.pi/4)]], dtype=complex)) + [0., np.exp(1.j * np.pi / 4)]], dtype=complex)) + class TdgGate(FixedSingleQubitGate): def __init__(self, pos: int): super().__init__("Tdg", pos, matrix=np.array([[1., 0.], - [0, np.exp(-1.j*np.pi/4)]] ,dtype=complex)) + [0, np.exp(-1.j * np.pi / 4)]], dtype=complex)) + class WGate(FixedSingleQubitGate): def __init__(self, pos: int): super().__init__("W", pos, matrix=np.zeros((2, 2), dtype=complex)) - self.matrix = (XGate(0).matrix + YGate(0).matrix)/np.sqrt(2) + self.matrix = (XGate(0).matrix + YGate(0).matrix) / np.sqrt(2) def to_qasm(self): - return "rz(-pi/4) q[%d];\nrx(pi) q[%d];\nrz(pi/4) q[%d]" %(self.pos, self.pos, self.pos) - + return "rz(-pi/4) q[%d];\nrx(pi) q[%d];\nrz(pi/4) q[%d]" % (self.pos, self.pos, self.pos) + + class SXGate(FixedSingleQubitGate): def __init__(self, pos: int): super().__init__("SX", pos, matrix=np.zeros((2, 2), dtype=complex)) self.matrix = sqrtm(XGate(0).matrix) self.symbol = "√X" + class SYGate(FixedSingleQubitGate): def __init__(self, pos: int): super().__init__("SY", pos, matrix=np.zeros((2, 2), dtype=complex)) @@ -129,18 +142,20 @@ def __init__(self, pos: int): self.symbol = "√Y" def to_qasm(self): - return "ry(pi/2) q[%d]" %(self.pos) - + return "ry(pi/2) q[%d]" % (self.pos) + + class SWGate(FixedSingleQubitGate): def __init__(self, pos: int): super().__init__("SW", pos, matrix=np.zeros((2, 2), dtype=complex)) # sqrtm(WGate(0).matrix) - self.matrix = np.array([[0.5+0.5j, -np.sqrt(0.5)*1j], - [np.sqrt(0.5), 0.5+ 0.5j]], dtype=complex) + self.matrix = np.array([[0.5 + 0.5j, -np.sqrt(0.5) * 1j], + [np.sqrt(0.5), 0.5 + 0.5j]], dtype=complex) self.symbol = "√W" def to_qasm(self): - return "rz(-pi/4) q[%d];\nrx(pi/2) q[%d];\nrz(pi/4) q[%d]" %(self.pos, self.pos, self.pos) + return "rz(-pi/4) q[%d];\nrx(pi/2) q[%d];\nrz(pi/4) q[%d]" % (self.pos, self.pos, self.pos) + class RXGate(ParaSingleQubitGate): def __init__(self, pos: int, paras): @@ -160,102 +175,112 @@ def __init__(self, pos: int, paras): class PhaseGate(ParaSingleQubitGate): def __init__(self, pos: int, paras): super().__init__("P", pos, paras, matrix=_pmatrix) - + class iSwapGate(FixedMultiQubitGate): - def __init__(self, q1:int, q2:int): + def __init__(self, q1: int, q2: int): super().__init__("iSWAP", [q1, q2], matrix=np.array([[1., 0., 0., 0.], - [0., 0., 1.j, 0.], - [0., 1.j, 0., 0.], - [0., 0., 0., 1.]], dtype=complex)) + [0., 0., 1.j, 0.], + [0., 1.j, 0., 0.], + [0., 0., 0., 1.]], dtype=complex)) def get_targ_matrix(self, reverse_order=False): return self.matrix class SwapGate(FixedMultiQubitGate): - def __init__(self, q1:int, q2:int): + def __init__(self, q1: int, q2: int): super().__init__("SWAP", [q1, q2], matrix=np.array([[1., 0., 0., 0.], - [0., 0., 1., 0.], - [0., 1., 0., 0.], - [0., 0., 0., 1.]], dtype=complex)) + [0., 0., 1., 0.], + [0., 1., 0., 0.], + [0., 0., 0., 1.]], dtype=complex)) self.symbol = "x" def get_targ_matrix(self, reverse_order=False): return self.matrix + class CXGate(ControlledGate): - def __init__(self, ctrl:int, targ:int): + def __init__(self, ctrl: int, targ: int): super().__init__("CX", "X", [ctrl], [targ], None, matrix=XGate(0).matrix) self.symbol = "+" class CYGate(ControlledGate): - def __init__(self, ctrl:int, targ:int): + def __init__(self, ctrl: int, targ: int): super().__init__("CY", "Y", [ctrl], [targ], None, matrix=YGate(0).matrix) class CZGate(ControlledGate): - def __init__(self, ctrl:int, targ:int): + def __init__(self, ctrl: int, targ: int): super().__init__("CZ", "Z", [ctrl], [targ], None, matrix=ZGate(0).matrix) + class CSGate(ControlledGate): - def __init__(self, ctrl:int, targ:int): + def __init__(self, ctrl: int, targ: int): super().__init__("CS", "S", [ctrl], [targ], None, matrix=SGate(0).matrix) def to_qasm(self): return "cp(pi/2) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) + class CTGate(ControlledGate): - def __init__(self, ctrl:int, targ:int): + def __init__(self, ctrl: int, targ: int): super().__init__("CT", "T", [ctrl], [targ], None, matrix=TGate(0).matrix) def to_qasm(self): return "cp(pi/4) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) + class CPGate(ControlledGate): - def __init__(self, ctrl:int, targ:int, paras): + def __init__(self, ctrl: int, targ: int, paras): super().__init__("CP", "P", [ctrl], [targ], paras, matrix=PhaseGate(0, paras).matrix) + class ToffoliGate(ControlledGate): - def __init__(self, ctrl1:int, ctrl2:int, targ:int): + def __init__(self, ctrl1: int, ctrl2: int, targ: int): super().__init__("CCX", "X", [ctrl1, ctrl2], [targ], None, matrix=XGate(0).matrix) + class FredkinGate(ControlledGate): - def __init__(self, ctrl:int, targ1:int, targ2:int): + def __init__(self, ctrl: int, targ1: int, targ2: int): super().__init__("CSWAP", "SWAP", [ctrl], [targ1, targ2], None, matrix=SwapGate(0, 1).matrix) class RXXGate(ParaMultiQubitGate): - def __init__(self, q1:int, q2:int, theta): + def __init__(self, q1: int, q2: int, theta): super().__init__("RXX", [q1, q2], theta, matrix=_rxxmatrix(theta)) - + def get_targ_matrix(self, reverse_order=False): return self.matrix + class RYYGate(ParaMultiQubitGate): - def __init__(self, q1:int, q2:int, theta): + def __init__(self, q1: int, q2: int, theta): super().__init__("RYY", [q1, q2], theta, matrix=_ryymatrix(theta)) def get_targ_matrix(self, reverse_order=False): return self.matrix + class RZZGate(ParaMultiQubitGate): - def __init__(self, q1:int, q2:int, theta): + def __init__(self, q1: int, q2: int, theta): super().__init__("RZZ", [q1, q2], theta, matrix=_rzzmatrix(theta)) def get_targ_matrix(self, reverse_order=False): return self.matrix + class MCXGate(ControlledGate): - def __init__(self, ctrls, targ:int): + def __init__(self, ctrls, targ: int): super().__init__("MCX", "X", ctrls, [targ], None, matrix=XGate(0).matrix) + class MCYGate(ControlledGate): - def __init__(self, ctrls, targ:int): + def __init__(self, ctrls, targ: int): super().__init__("MCY", "Y", ctrls, [targ], None, matrix=YGate(0).matrix) + class MCZGate(ControlledGate): - def __init__(self, ctrls, targ:int): + def __init__(self, ctrls, targ: int): super().__init__("MCZ", "Z", ctrls, [targ], None, matrix=ZGate(0).matrix) - diff --git a/src/quafu/elements/quantum_element.py b/src/quafu/elements/quantum_element.py index 4bee26f..fb33a2a 100644 --- a/src/quafu/elements/quantum_element.py +++ b/src/quafu/elements/quantum_element.py @@ -1,8 +1,7 @@ # This is the file for abstract quantum gates class -from typing import Union, Callable, List, Tuple, Iterable, Any, Optional +from typing import Union, Callable, List, Iterable + import numpy as np -from functools import reduce -import copy def reorder_matrix(matrix: np.ndarray, pos: List): From 94515cafcfb77682c927d580f289a9cc0ee7d716 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 5 Jul 2023 17:05:01 +0800 Subject: [PATCH 29/70] "add sxdg and related" Add SXdgGate to quantum_element.py, sxdg() to quantum_circuit.py and also counterparts for Y. Matrices were written explicitly as array of numpy, symbols were also given. --- src/quafu/circuits/quantum_circuit.py | 94 ++++++++++++++++----------- src/quafu/elements/element_gates.py | 26 +++++++- src/quafu/elements/quantum_element.py | 2 + 3 files changed, 82 insertions(+), 40 deletions(-) diff --git a/src/quafu/circuits/quantum_circuit.py b/src/quafu/circuits/quantum_circuit.py index a77884e..add4c63 100644 --- a/src/quafu/circuits/quantum_circuit.py +++ b/src/quafu/circuits/quantum_circuit.py @@ -2,13 +2,10 @@ import numpy as np from quafu.pulses.quantum_pulse import QuantumPulse + from ..elements.quantum_element import Barrier, Delay, MultiQubitGate, QuantumGate, ControlledGate, \ SingleQubitGate, XYResonance -from ..elements.element_gates import IdGate, HGate, XGate, YGate, ZGate, \ - SGate, TGate, RXGate, RYGate, RZGate, CZGate, TdgGate, SdgGate, SXGate, SYGate, WGate, \ - SWGate, PhaseGate, CXGate, CYGate, CSGate, CTGate, CPGate, SwapGate, ToffoliGate, FredkinGate, \ - RXXGate, RYYGate, RZZGate, MCXGate, MCYGate, MCZGate - +import quafu.elements.element_gates as qeg from ..exceptions import CircuitError @@ -33,6 +30,7 @@ def used_qubits(self) -> List: return self._used_qubits def add_gate(self, gate: QuantumGate): + # TODO: check gate position self.gates.append(gate) def layered_circuit(self) -> np.ndarray: @@ -339,7 +337,7 @@ def id(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(IdGate(pos)) + self.gates.append(qeg.IdGate(pos)) return self def h(self, pos: int) -> "QuantumCircuit": @@ -349,7 +347,7 @@ def h(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(HGate(pos)) + self.gates.append(qeg.HGate(pos)) return self def x(self, pos: int) -> "QuantumCircuit": @@ -359,7 +357,7 @@ def x(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(XGate(pos)) + self.gates.append(qeg.XGate(pos)) return self def y(self, pos: int) -> "QuantumCircuit": @@ -369,7 +367,7 @@ def y(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(YGate(pos)) + self.gates.append(qeg.YGate(pos)) return self def z(self, pos: int) -> "QuantumCircuit": @@ -379,7 +377,7 @@ def z(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(ZGate(pos)) + self.gates.append(qeg.ZGate(pos)) return self def t(self, pos: int) -> "QuantumCircuit": @@ -389,7 +387,7 @@ def t(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(TGate(pos)) + self.gates.append(qeg.TGate(pos)) return self def tdg(self, pos: int) -> "QuantumCircuit": @@ -399,7 +397,7 @@ def tdg(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(TdgGate(pos)) + self.gates.append(qeg.TdgGate(pos)) return self def s(self, pos: int) -> "QuantumCircuit": @@ -409,7 +407,7 @@ def s(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(SGate(pos)) + self.gates.append(qeg.SGate(pos)) return self def sdg(self, pos: int) -> "QuantumCircuit": @@ -419,7 +417,7 @@ def sdg(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(SdgGate(pos)) + self.gates.append(qeg.SdgGate(pos)) return self def sx(self, pos: int) -> "QuantumCircuit": @@ -429,7 +427,18 @@ def sx(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(SXGate(pos)) + self.gates.append(qeg.SXGate(pos)) + return self + + def sxdg(self, pos: int) -> "QuantumCircuit": + """ + Inverse of √X gate. + + Args: + pos (int): qubit the gate act. + """ + gate = qeg.SXdgGate(pos) + self.add_gate(gate) return self def sy(self, pos: int) -> "QuantumCircuit": @@ -439,7 +448,18 @@ def sy(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(SYGate(pos)) + self.gates.append(qeg.SYGate(pos)) + return self + + def sydg(self, pos: int) -> "QuantumCircuit": + """ + Inverse of √Y gate. + + Args: + pos (int): qubit the gate act. + """ + gate = qeg.SYdgGate(pos) + self.add_gate(gate) return self def w(self, pos: int) -> "QuantumCircuit": @@ -449,7 +469,7 @@ def w(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(WGate(pos)) + self.gates.append(qeg.WGate(pos)) return self def sw(self, pos: int) -> "QuantumCircuit": @@ -459,7 +479,7 @@ def sw(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(SWGate(pos)) + self.gates.append(qeg.SWGate(pos)) return self def rx(self, pos: int, para: float) -> "QuantumCircuit": @@ -470,7 +490,7 @@ def rx(self, pos: int, para: float) -> "QuantumCircuit": pos (int): qubit the gate act. para (float): rotation angle """ - self.gates.append(RXGate(pos, para)) + self.gates.append(qeg.RXGate(pos, para)) return self def ry(self, pos: int, para: float) -> "QuantumCircuit": @@ -481,7 +501,7 @@ def ry(self, pos: int, para: float) -> "QuantumCircuit": pos (int): qubit the gate act. para (float): rotation angle """ - self.gates.append(RYGate(pos, para)) + self.gates.append(qeg.RYGate(pos, para)) return self def rz(self, pos: int, para: float) -> "QuantumCircuit": @@ -492,7 +512,7 @@ def rz(self, pos: int, para: float) -> "QuantumCircuit": pos (int): qubit the gate act. para (float): rotation angle """ - self.gates.append(RZGate(pos, para)) + self.gates.append(qeg.RZGate(pos, para)) return self def p(self, pos: int, para: float) -> "QuantumCircuit": @@ -503,7 +523,7 @@ def p(self, pos: int, para: float) -> "QuantumCircuit": pos (int): qubit the gate act. para (float): rotation angle """ - self.gates.append(PhaseGate(pos, para)) + self.gates.append(qeg.PhaseGate(pos, para)) return self def cnot(self, ctrl: int, tar: int) -> "QuantumCircuit": @@ -514,7 +534,7 @@ def cnot(self, ctrl: int, tar: int) -> "QuantumCircuit": ctrl (int): control qubit. tar (int): target qubit. """ - self.gates.append(CXGate(ctrl, tar)) + self.gates.append(qeg.CXGate(ctrl, tar)) return self def cy(self, ctrl: int, tar: int) -> "QuantumCircuit": @@ -525,7 +545,7 @@ def cy(self, ctrl: int, tar: int) -> "QuantumCircuit": ctrl (int): control qubit. tar (int): target qubit. """ - self.gates.append(CYGate(ctrl, tar)) + self.gates.append(qeg.CYGate(ctrl, tar)) return self def cz(self, ctrl: int, tar: int) -> "QuantumCircuit": @@ -536,7 +556,7 @@ def cz(self, ctrl: int, tar: int) -> "QuantumCircuit": ctrl (int): control qubit. tar (int): target qubit. """ - self.gates.append(CZGate(ctrl, tar)) + self.gates.append(qeg.CZGate(ctrl, tar)) return self def cs(self, ctrl: int, tar: int) -> "QuantumCircuit": @@ -546,7 +566,7 @@ def cs(self, ctrl: int, tar: int) -> "QuantumCircuit": ctrl (int): control qubit. tar (int): target qubit. """ - self.gates.append(CSGate(ctrl, tar)) + self.gates.append(qeg.CSGate(ctrl, tar)) return self def ct(self, ctrl: int, tar: int) -> "QuantumCircuit": @@ -557,7 +577,7 @@ def ct(self, ctrl: int, tar: int) -> "QuantumCircuit": tar (int): target qubit. """ - self.gates.append(CTGate(ctrl, tar)) + self.gates.append(qeg.CTGate(ctrl, tar)) return self def cp(self, ctrl: int, tar: int, para) -> "QuantumCircuit": @@ -568,7 +588,7 @@ def cp(self, ctrl: int, tar: int, para) -> "QuantumCircuit": ctrl (int): control qubit. tar (int): target qubit. """ - self.gates.append(CPGate(ctrl, tar, para)) + self.gates.append(qeg.CPGate(ctrl, tar, para)) return self def swap(self, q1: int, q2: int) -> "QuantumCircuit": @@ -579,7 +599,7 @@ def swap(self, q1: int, q2: int) -> "QuantumCircuit": q1 (int): qubit the gate act. q2 (int): qubit the gate act. """ - self.gates.append(SwapGate(q1, q2)) + self.gates.append(qeg.SwapGate(q1, q2)) return self def toffoli(self, ctrl1: int, ctrl2: int, targ: int) -> "QuantumCircuit": @@ -591,7 +611,7 @@ def toffoli(self, ctrl1: int, ctrl2: int, targ: int) -> "QuantumCircuit": ctrl2 (int): control qubit targ (int): target qubit """ - self.gates.append(ToffoliGate(ctrl1, ctrl2, targ)) + self.gates.append(qeg.ToffoliGate(ctrl1, ctrl2, targ)) return self def fredkin(self, ctrl: int, targ1: int, targ2: int) -> "QuantumCircuit": @@ -603,7 +623,7 @@ def fredkin(self, ctrl: int, targ1: int, targ2: int) -> "QuantumCircuit": targ1 (int): target qubit targ2 (int): target qubit """ - self.gates.append(FredkinGate(ctrl, targ1, targ2)) + self.gates.append(qeg.FredkinGate(ctrl, targ1, targ2)) return self def barrier(self, qlist: List[int]) -> "QuantumCircuit": @@ -650,7 +670,7 @@ def rxx(self, q1: int, q2: int, theta): theta: rotation angle. """ - self.gates.append(RXXGate(q1, q2, theta)) + self.gates.append(qeg.RXXGate(q1, q2, theta)) def ryy(self, q1: int, q2: int, theta): """ @@ -661,7 +681,7 @@ def ryy(self, q1: int, q2: int, theta): theta: rotation angle. """ - self.gates.append(RYYGate(q1, q2, theta)) + self.gates.append(qeg.RYYGate(q1, q2, theta)) def rzz(self, q1: int, q2: int, theta): """ @@ -672,7 +692,7 @@ def rzz(self, q1: int, q2: int, theta): theta: rotation angle. """ - self.gates.append(RZZGate(q1, q2, theta)) + self.gates.append(qeg.RZZGate(q1, q2, theta)) def mcx(self, ctrls: List[int], targ: int): """ @@ -681,7 +701,7 @@ def mcx(self, ctrls: List[int], targ: int): ctrls: A list of control qubits. targ: Target qubits. """ - self.gates.append(MCXGate(ctrls, targ)) + self.gates.append(qeg.MCXGate(ctrls, targ)) def mcy(self, ctrls: List[int], targ: int): """ @@ -690,7 +710,7 @@ def mcy(self, ctrls: List[int], targ: int): ctrls: A list of control qubits. targ: Target qubits. """ - self.gates.append(MCYGate(ctrls, targ)) + self.gates.append(qeg.MCYGate(ctrls, targ)) def mcz(self, ctrls: List[int], targ: int): """ @@ -699,7 +719,7 @@ def mcz(self, ctrls: List[int], targ: int): ctrls: A list of control qubits. targ: Target qubits. """ - self.gates.append(MCZGate(ctrls, targ)) + self.gates.append(qeg.MCZGate(ctrls, targ)) def measure(self, pos: List[int], cbits: List[int] = None) -> None: """ diff --git a/src/quafu/elements/element_gates.py b/src/quafu/elements/element_gates.py index cb982bb..82258d0 100644 --- a/src/quafu/elements/element_gates.py +++ b/src/quafu/elements/element_gates.py @@ -131,18 +131,38 @@ def to_qasm(self): class SXGate(FixedSingleQubitGate): def __init__(self, pos: int): super().__init__("SX", pos, matrix=np.zeros((2, 2), dtype=complex)) - self.matrix = sqrtm(XGate(0).matrix) + self.matrix = np.array([[0.5 + 0.5j, 0.5 - 0.5j], + [0.5 - 0.5j, 0.5 + 0.5j]]) self.symbol = "√X" +class SXdgGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("SXdg", pos, matrix=np.zeros((2, 2), dtype=complex)) + matrix = np.array([[0.5 - 0.5j, 0.5 + 0.5j], + [0.5 + 0.5j, 0.5 - 0.5j]]) + self.matrix = matrix + self.symbol = "√X†" + + class SYGate(FixedSingleQubitGate): def __init__(self, pos: int): super().__init__("SY", pos, matrix=np.zeros((2, 2), dtype=complex)) - self.matrix = sqrtm(YGate(0).matrix) + self.matrix = np.array([[0.5 + 0.5j, -0.5 - 0.5j], + [0.5 + 0.5j, 0.5 + 0.5j]]) self.symbol = "√Y" def to_qasm(self): - return "ry(pi/2) q[%d]" % (self.pos) + # TODO: this is not correct + return "ry(pi/2) q[%d]" % self.pos + + +class SYdgGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("SY", pos, matrix=np.zeros((2, 2), dtype=complex)) + self.matrix = np.array([[0.5 - 0.5j, -0.5 + 0.5j], + [0.5 - 0.5j, 0.5 - 0.5j]]) + self.symbol = "√Y†" class SWGate(FixedSingleQubitGate): diff --git a/src/quafu/elements/quantum_element.py b/src/quafu/elements/quantum_element.py index fb33a2a..20b5bed 100644 --- a/src/quafu/elements/quantum_element.py +++ b/src/quafu/elements/quantum_element.py @@ -149,6 +149,8 @@ def to_qasm(self): class SingleQubitGate(QuantumGate): + _matrix = None + def __init__(self, name: str, pos: int, paras, matrix): super().__init__(name, pos, paras=paras, matrix=matrix) From a59a82b71f4a8bd5295f2dae1e5610f4ae1ebe31 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Thu, 6 Jul 2023 11:21:02 +0800 Subject: [PATCH 30/70] "add some user-friendly features" 1. Use self.add_gates() to check out position range. 2. Set default pos of barrier() to be None which means to act on all qubits. 3. Integrate plot_circuit() from visualisation module. (Have tested by plotting.) --- src/quafu/circuits/quantum_circuit.py | 92 +++++++++++++++------------ src/quafu/elements/quantum_element.py | 2 - 2 files changed, 52 insertions(+), 42 deletions(-) diff --git a/src/quafu/circuits/quantum_circuit.py b/src/quafu/circuits/quantum_circuit.py index add4c63..9c4dc13 100644 --- a/src/quafu/circuits/quantum_circuit.py +++ b/src/quafu/circuits/quantum_circuit.py @@ -2,7 +2,6 @@ import numpy as np from quafu.pulses.quantum_pulse import QuantumPulse - from ..elements.quantum_element import Barrier, Delay, MultiQubitGate, QuantumGate, ControlledGate, \ SingleQubitGate, XYResonance import quafu.elements.element_gates as qeg @@ -21,7 +20,7 @@ def __init__(self, num: int): self.gates = [] self.openqasm = "" self.circuit = [] - self.measures = dict(zip(range(num), range(num))) + self.measures = {dict(zip(range(num), range(num)))} self._used_qubits = [] @property @@ -30,7 +29,9 @@ def used_qubits(self) -> List: return self._used_qubits def add_gate(self, gate: QuantumGate): - # TODO: check gate position + pos = np.array(gate.pos) + if np.any(pos >= self.num): + raise CircuitError(f"Gate position out of range: {gate.pos}") self.gates.append(gate) def layered_circuit(self) -> np.ndarray: @@ -177,6 +178,11 @@ def draw_circuit(self, width: int = 4, return_str: bool = False): else: print(circuitstr) + def plot_circuit(self, *args, **kwargs): + from quafu.visualisation.circuitPlot import CircuitPlotManager + cmp = CircuitPlotManager(self) + return cmp(*args, **kwargs) + def from_openqasm(self, openqasm: str): """ Initialize the circuit from openqasm text. @@ -337,7 +343,8 @@ def id(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(qeg.IdGate(pos)) + gate = qeg.IdGate(pos) + self.add_gate(gate) return self def h(self, pos: int) -> "QuantumCircuit": @@ -347,7 +354,8 @@ def h(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(qeg.HGate(pos)) + gate = qeg.HGate(pos) + self.add_gate(gate) return self def x(self, pos: int) -> "QuantumCircuit": @@ -357,7 +365,8 @@ def x(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(qeg.XGate(pos)) + gate = qeg.XGate(pos) + self.add_gate(gate) return self def y(self, pos: int) -> "QuantumCircuit": @@ -367,7 +376,8 @@ def y(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(qeg.YGate(pos)) + gate = qeg.YGate(pos) + self.add_gate(gate) return self def z(self, pos: int) -> "QuantumCircuit": @@ -377,7 +387,7 @@ def z(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(qeg.ZGate(pos)) + self.add_gate(qeg.ZGate(pos)) return self def t(self, pos: int) -> "QuantumCircuit": @@ -387,7 +397,7 @@ def t(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(qeg.TGate(pos)) + self.add_gate(qeg.TGate(pos)) return self def tdg(self, pos: int) -> "QuantumCircuit": @@ -397,7 +407,7 @@ def tdg(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(qeg.TdgGate(pos)) + self.add_gate(qeg.TdgGate(pos)) return self def s(self, pos: int) -> "QuantumCircuit": @@ -407,7 +417,7 @@ def s(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(qeg.SGate(pos)) + self.add_gate(qeg.SGate(pos)) return self def sdg(self, pos: int) -> "QuantumCircuit": @@ -417,7 +427,7 @@ def sdg(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(qeg.SdgGate(pos)) + self.add_gate(qeg.SdgGate(pos)) return self def sx(self, pos: int) -> "QuantumCircuit": @@ -427,7 +437,7 @@ def sx(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(qeg.SXGate(pos)) + self.add_gate(qeg.SXGate(pos)) return self def sxdg(self, pos: int) -> "QuantumCircuit": @@ -448,7 +458,7 @@ def sy(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(qeg.SYGate(pos)) + self.add_gate(qeg.SYGate(pos)) return self def sydg(self, pos: int) -> "QuantumCircuit": @@ -469,7 +479,7 @@ def w(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(qeg.WGate(pos)) + self.add_gate(qeg.WGate(pos)) return self def sw(self, pos: int) -> "QuantumCircuit": @@ -479,7 +489,7 @@ def sw(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.gates.append(qeg.SWGate(pos)) + self.add_gate(qeg.SWGate(pos)) return self def rx(self, pos: int, para: float) -> "QuantumCircuit": @@ -490,7 +500,7 @@ def rx(self, pos: int, para: float) -> "QuantumCircuit": pos (int): qubit the gate act. para (float): rotation angle """ - self.gates.append(qeg.RXGate(pos, para)) + self.add_gate(qeg.RXGate(pos, para)) return self def ry(self, pos: int, para: float) -> "QuantumCircuit": @@ -501,7 +511,7 @@ def ry(self, pos: int, para: float) -> "QuantumCircuit": pos (int): qubit the gate act. para (float): rotation angle """ - self.gates.append(qeg.RYGate(pos, para)) + self.add_gate(qeg.RYGate(pos, para)) return self def rz(self, pos: int, para: float) -> "QuantumCircuit": @@ -512,7 +522,7 @@ def rz(self, pos: int, para: float) -> "QuantumCircuit": pos (int): qubit the gate act. para (float): rotation angle """ - self.gates.append(qeg.RZGate(pos, para)) + self.add_gate(qeg.RZGate(pos, para)) return self def p(self, pos: int, para: float) -> "QuantumCircuit": @@ -523,7 +533,7 @@ def p(self, pos: int, para: float) -> "QuantumCircuit": pos (int): qubit the gate act. para (float): rotation angle """ - self.gates.append(qeg.PhaseGate(pos, para)) + self.add_gate(qeg.PhaseGate(pos, para)) return self def cnot(self, ctrl: int, tar: int) -> "QuantumCircuit": @@ -534,7 +544,7 @@ def cnot(self, ctrl: int, tar: int) -> "QuantumCircuit": ctrl (int): control qubit. tar (int): target qubit. """ - self.gates.append(qeg.CXGate(ctrl, tar)) + self.add_gate(qeg.CXGate(ctrl, tar)) return self def cy(self, ctrl: int, tar: int) -> "QuantumCircuit": @@ -545,7 +555,7 @@ def cy(self, ctrl: int, tar: int) -> "QuantumCircuit": ctrl (int): control qubit. tar (int): target qubit. """ - self.gates.append(qeg.CYGate(ctrl, tar)) + self.add_gate(qeg.CYGate(ctrl, tar)) return self def cz(self, ctrl: int, tar: int) -> "QuantumCircuit": @@ -556,7 +566,7 @@ def cz(self, ctrl: int, tar: int) -> "QuantumCircuit": ctrl (int): control qubit. tar (int): target qubit. """ - self.gates.append(qeg.CZGate(ctrl, tar)) + self.add_gate(qeg.CZGate(ctrl, tar)) return self def cs(self, ctrl: int, tar: int) -> "QuantumCircuit": @@ -566,7 +576,7 @@ def cs(self, ctrl: int, tar: int) -> "QuantumCircuit": ctrl (int): control qubit. tar (int): target qubit. """ - self.gates.append(qeg.CSGate(ctrl, tar)) + self.add_gate(qeg.CSGate(ctrl, tar)) return self def ct(self, ctrl: int, tar: int) -> "QuantumCircuit": @@ -577,7 +587,7 @@ def ct(self, ctrl: int, tar: int) -> "QuantumCircuit": tar (int): target qubit. """ - self.gates.append(qeg.CTGate(ctrl, tar)) + self.add_gate(qeg.CTGate(ctrl, tar)) return self def cp(self, ctrl: int, tar: int, para) -> "QuantumCircuit": @@ -588,7 +598,7 @@ def cp(self, ctrl: int, tar: int, para) -> "QuantumCircuit": ctrl (int): control qubit. tar (int): target qubit. """ - self.gates.append(qeg.CPGate(ctrl, tar, para)) + self.add_gate(qeg.CPGate(ctrl, tar, para)) return self def swap(self, q1: int, q2: int) -> "QuantumCircuit": @@ -599,7 +609,7 @@ def swap(self, q1: int, q2: int) -> "QuantumCircuit": q1 (int): qubit the gate act. q2 (int): qubit the gate act. """ - self.gates.append(qeg.SwapGate(q1, q2)) + self.add_gate(qeg.SwapGate(q1, q2)) return self def toffoli(self, ctrl1: int, ctrl2: int, targ: int) -> "QuantumCircuit": @@ -611,7 +621,7 @@ def toffoli(self, ctrl1: int, ctrl2: int, targ: int) -> "QuantumCircuit": ctrl2 (int): control qubit targ (int): target qubit """ - self.gates.append(qeg.ToffoliGate(ctrl1, ctrl2, targ)) + self.add_gate(qeg.ToffoliGate(ctrl1, ctrl2, targ)) return self def fredkin(self, ctrl: int, targ1: int, targ2: int) -> "QuantumCircuit": @@ -623,17 +633,19 @@ def fredkin(self, ctrl: int, targ1: int, targ2: int) -> "QuantumCircuit": targ1 (int): target qubit targ2 (int): target qubit """ - self.gates.append(qeg.FredkinGate(ctrl, targ1, targ2)) + self.add_gate(qeg.FredkinGate(ctrl, targ1, targ2)) return self - def barrier(self, qlist: List[int]) -> "QuantumCircuit": + def barrier(self, qlist: List[int] = None) -> "QuantumCircuit": """ Add barrier for qubits in qlist. Args: qlist (list[int]): A list contain the qubit need add barrier. When qlist contain at least two qubit, the barrier will be added from minimum qubit to maximum qubit. For example: barrier([0, 2]) create barrier for qubits 0, 1, 2. To create discrete barrier, using barrier([0]), barrier([2]). """ - self.gates.append(Barrier(qlist)) + if qlist is None: + qlist = list(range(self.num)) + self.add_gate(Barrier(qlist)) return self def delay(self, pos, duration, unit="ns") -> "QuantumCircuit": @@ -645,7 +657,7 @@ def delay(self, pos, duration, unit="ns") -> "QuantumCircuit": duration (int): duration of qubit delay, which represents integer times of unit. unit (str): time unit for the duration. Can be "ns" and "us". """ - self.gates.append(Delay(pos, duration, unit=unit)) + self.add_gate(Delay(pos, duration, unit=unit)) return self def xy(self, qs: int, qe: int, duration: int, unit: str = "ns") -> "QuantumCircuit": @@ -658,7 +670,7 @@ def xy(self, qs: int, qe: int, duration: int, unit: str = "ns") -> "QuantumCircu unit: time unit of duration. """ - self.gates.append(XYResonance(qs, qe, duration, unit=unit)) + self.add_gate(XYResonance(qs, qe, duration, unit=unit)) return self def rxx(self, q1: int, q2: int, theta): @@ -670,7 +682,7 @@ def rxx(self, q1: int, q2: int, theta): theta: rotation angle. """ - self.gates.append(qeg.RXXGate(q1, q2, theta)) + self.add_gate(qeg.RXXGate(q1, q2, theta)) def ryy(self, q1: int, q2: int, theta): """ @@ -681,7 +693,7 @@ def ryy(self, q1: int, q2: int, theta): theta: rotation angle. """ - self.gates.append(qeg.RYYGate(q1, q2, theta)) + self.add_gate(qeg.RYYGate(q1, q2, theta)) def rzz(self, q1: int, q2: int, theta): """ @@ -692,7 +704,7 @@ def rzz(self, q1: int, q2: int, theta): theta: rotation angle. """ - self.gates.append(qeg.RZZGate(q1, q2, theta)) + self.add_gate(qeg.RZZGate(q1, q2, theta)) def mcx(self, ctrls: List[int], targ: int): """ @@ -701,7 +713,7 @@ def mcx(self, ctrls: List[int], targ: int): ctrls: A list of control qubits. targ: Target qubits. """ - self.gates.append(qeg.MCXGate(ctrls, targ)) + self.add_gate(qeg.MCXGate(ctrls, targ)) def mcy(self, ctrls: List[int], targ: int): """ @@ -710,7 +722,7 @@ def mcy(self, ctrls: List[int], targ: int): ctrls: A list of control qubits. targ: Target qubits. """ - self.gates.append(qeg.MCYGate(ctrls, targ)) + self.add_gate(qeg.MCYGate(ctrls, targ)) def mcz(self, ctrls: List[int], targ: int): """ @@ -719,7 +731,7 @@ def mcz(self, ctrls: List[int], targ: int): ctrls: A list of control qubits. targ: Target qubits. """ - self.gates.append(qeg.MCZGate(ctrls, targ)) + self.add_gate(qeg.MCZGate(ctrls, targ)) def measure(self, pos: List[int], cbits: List[int] = None) -> None: """ @@ -746,5 +758,5 @@ def add_pulse(self, """ if pos is not None: pulse.set_pos(pos) - self.gates.append(pulse) + self.add_gate(pulse) return self diff --git a/src/quafu/elements/quantum_element.py b/src/quafu/elements/quantum_element.py index 20b5bed..fb33a2a 100644 --- a/src/quafu/elements/quantum_element.py +++ b/src/quafu/elements/quantum_element.py @@ -149,8 +149,6 @@ def to_qasm(self): class SingleQubitGate(QuantumGate): - _matrix = None - def __init__(self, name: str, pos: int, paras, matrix): super().__init__(name, pos, paras=paras, matrix=matrix) From 5c1f6170cd84d3ca7d40cc4d65b811e79c3843ee Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Thu, 6 Jul 2023 12:03:18 +0800 Subject: [PATCH 31/70] "Separate element_gates.py" Outer access to element_gates remains the same for all gates have been imported in __init__.py --- src/quafu/elements/element_gates/__init__.py | 19 ++++++ src/quafu/elements/element_gates/c11.py | 39 ++++++++++++ src/quafu/elements/element_gates/c12.py | 7 +++ src/quafu/elements/element_gates/c21.py | 7 +++ src/quafu/elements/element_gates/cm1.py | 17 ++++++ src/quafu/elements/element_gates/pauli.py | 52 ++++++++++++++++ src/quafu/elements/element_gates/phase.py | 7 +++ src/quafu/elements/element_gates/rotation.py | 41 +++++++++++++ src/quafu/elements/element_gates/sqrt.py | 63 ++++++++++++++++++++ src/quafu/elements/element_gates/swap.py | 19 ++++++ 10 files changed, 271 insertions(+) create mode 100644 src/quafu/elements/element_gates/__init__.py create mode 100644 src/quafu/elements/element_gates/c11.py create mode 100644 src/quafu/elements/element_gates/c12.py create mode 100644 src/quafu/elements/element_gates/c21.py create mode 100644 src/quafu/elements/element_gates/cm1.py create mode 100644 src/quafu/elements/element_gates/pauli.py create mode 100644 src/quafu/elements/element_gates/phase.py create mode 100644 src/quafu/elements/element_gates/rotation.py create mode 100644 src/quafu/elements/element_gates/sqrt.py create mode 100644 src/quafu/elements/element_gates/swap.py diff --git a/src/quafu/elements/element_gates/__init__.py b/src/quafu/elements/element_gates/__init__.py new file mode 100644 index 0000000..67052df --- /dev/null +++ b/src/quafu/elements/element_gates/__init__.py @@ -0,0 +1,19 @@ +from .pauli import XGate, YGate, ZGate, HGate, IdGate, WGate, SWGate +from .phase import PhaseGate +from .rotation import RXGate, RYGate, RZGate, RXXGate, RYYGate, RZZGate +from .swap import SwapGate, iSwapGate +from .sqrt import SXGate, SXdgGate, SYGate, SYdgGate, SGate, SdgGate, TGate, TdgGate +from .c11 import CXGate, CYGate, CZGate, CSGate, CTGate, CPGate +from .c21 import ToffoliGate +from .c12 import FredkinGate +from .cm1 import MCXGate, MCYGate, MCZGate + +__all__ = ['XGate', 'YGate', 'ZGate', 'HGate', 'IdGate', 'WGate', 'SWGate', + 'SXGate', 'SXdgGate', 'SYGate', 'SYdgGate', 'SGate', 'SdgGate', 'TGate', 'TdgGate', + 'PhaseGate', + 'RXGate', 'RYGate', 'RZGate', 'RXXGate', 'RYYGate', 'RZZGate', + 'SwapGate', 'iSwapGate', + 'CXGate', 'CYGate', 'CZGate', 'CSGate', 'CTGate', 'CPGate', + 'ToffoliGate', + 'FredkinGate', + 'MCXGate', 'MCYGate', 'MCZGate'] diff --git a/src/quafu/elements/element_gates/c11.py b/src/quafu/elements/element_gates/c11.py new file mode 100644 index 0000000..3f49e28 --- /dev/null +++ b/src/quafu/elements/element_gates/c11.py @@ -0,0 +1,39 @@ +from ..quantum_element import ControlledGate +from ._matrices import XMatrix, YMatrix, ZMatrix, SMatrix, TMatrix + + +class CXGate(ControlledGate): + def __init__(self, ctrl: int, targ: int): + super().__init__("CX", "X", [ctrl], [targ], None, matrix=XMatrix) + self.symbol = "+" + + +class CYGate(ControlledGate): + def __init__(self, ctrl: int, targ: int): + super().__init__("CY", "Y", [ctrl], [targ], None, matrix=YMatrix) + + +class CZGate(ControlledGate): + def __init__(self, ctrl: int, targ: int): + super().__init__("CZ", "Z", [ctrl], [targ], None, matrix=ZMatrix) + + +class CSGate(ControlledGate): + def __init__(self, ctrl: int, targ: int): + super().__init__("CS", "S", [ctrl], [targ], None, matrix=SMatrix) + + def to_qasm(self): + return "cp(pi/2) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) + + +class CTGate(ControlledGate): + def __init__(self, ctrl: int, targ: int): + super().__init__("CT", "T", [ctrl], [targ], None, matrix=TMatrix) + + def to_qasm(self): + return "cp(pi/4) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) + + +class CPGate(ControlledGate): + def __init__(self, ctrl: int, targ: int, paras): + super().__init__("CP", "P", [ctrl], [targ], paras, matrix=PhaseGate(0, paras).matrix) diff --git a/src/quafu/elements/element_gates/c12.py b/src/quafu/elements/element_gates/c12.py new file mode 100644 index 0000000..f9347f8 --- /dev/null +++ b/src/quafu/elements/element_gates/c12.py @@ -0,0 +1,7 @@ +from ..quantum_element import ControlledGate +from ._matrices import SwapMatrix + + +class FredkinGate(ControlledGate): + def __init__(self, ctrl: int, targ1: int, targ2: int): + super().__init__("CSWAP", "SWAP", [ctrl], [targ1, targ2], None, matrix=SwapMatrix) diff --git a/src/quafu/elements/element_gates/c21.py b/src/quafu/elements/element_gates/c21.py new file mode 100644 index 0000000..fbbcd70 --- /dev/null +++ b/src/quafu/elements/element_gates/c21.py @@ -0,0 +1,7 @@ +from ..quantum_element import ControlledGate +from ._matrices import XMatrix + + +class ToffoliGate(ControlledGate): + def __init__(self, ctrl1: int, ctrl2: int, targ: int): + super().__init__("CCX", "X", [ctrl1, ctrl2], [targ], None, matrix=XMatrix) diff --git a/src/quafu/elements/element_gates/cm1.py b/src/quafu/elements/element_gates/cm1.py new file mode 100644 index 0000000..040797c --- /dev/null +++ b/src/quafu/elements/element_gates/cm1.py @@ -0,0 +1,17 @@ +from ._matrices import XMatrix, YMatrix, ZMatrix +from ..quantum_element import ControlledGate + + +class MCXGate(ControlledGate): + def __init__(self, ctrls, targ: int): + super().__init__("MCX", "X", ctrls, [targ], None, matrix=XMatrix) + + +class MCYGate(ControlledGate): + def __init__(self, ctrls, targ: int): + super().__init__("MCY", "Y", ctrls, [targ], None, matrix=YMatrix) + + +class MCZGate(ControlledGate): + def __init__(self, ctrls, targ: int): + super().__init__("MCZ", "Z", ctrls, [targ], None, matrix=ZMatrix) diff --git a/src/quafu/elements/element_gates/pauli.py b/src/quafu/elements/element_gates/pauli.py new file mode 100644 index 0000000..74bd051 --- /dev/null +++ b/src/quafu/elements/element_gates/pauli.py @@ -0,0 +1,52 @@ +from ..quantum_element import FixedSingleQubitGate +import numpy as np + + +class IdGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("Id", pos, matrix=np.array([[1., 0.], + [0., 1.]], dtype=complex)) + + +class HGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("H", pos, matrix=1 / np.sqrt(2) * np.array([[1., 1.], + [1., -1.]], dtype=complex)) + + +class XGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("X", pos, matrix=np.array([[0., 1.], + [1., 0.]], dtype=complex)) + + +class YGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("Y", pos, matrix=np.array([[0., -1.j], + [1.j, 0.]], dtype=complex)) + + +class ZGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("Z", pos, matrix=np.array([[1., 0.], + [0., -1.]], dtype=complex)) + + +class WGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("W", pos, matrix=np.zeros((2, 2), dtype=complex)) + self.matrix = (XGate(0).matrix + YGate(0).matrix) / np.sqrt(2) + + def to_qasm(self): + return "rz(-pi/4) q[%d];\nrx(pi) q[%d];\nrz(pi/4) q[%d]" % (self.pos, self.pos, self.pos) + + +class SWGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("SW", pos, matrix=np.zeros((2, 2), dtype=complex)) + self.matrix = np.array([[0.5 + 0.5j, -np.sqrt(0.5) * 1j], + [np.sqrt(0.5), 0.5 + 0.5j]], dtype=complex) + self.symbol = "√W" + + def to_qasm(self): + return "rz(-pi/4) q[%d];\nrx(pi/2) q[%d];\nrz(pi/4) q[%d]" % (self.pos, self.pos, self.pos) \ No newline at end of file diff --git a/src/quafu/elements/element_gates/phase.py b/src/quafu/elements/element_gates/phase.py new file mode 100644 index 0000000..c40f2a6 --- /dev/null +++ b/src/quafu/elements/element_gates/phase.py @@ -0,0 +1,7 @@ +from ..quantum_element import ParaSingleQubitGate +from ._matrices import pmatrix + + +class PhaseGate(ParaSingleQubitGate): + def __init__(self, pos: int, paras): + super().__init__("P", pos, paras, matrix=pmatrix) diff --git a/src/quafu/elements/element_gates/rotation.py b/src/quafu/elements/element_gates/rotation.py new file mode 100644 index 0000000..05ac4f9 --- /dev/null +++ b/src/quafu/elements/element_gates/rotation.py @@ -0,0 +1,41 @@ +from ..quantum_element import ParaMultiQubitGate, ParaSingleQubitGate +from ._matrices import rxmatrix, rymatrix, rzmatrix, rxxmatrix, ryymatrix, rzzmatrix + + +class RXGate(ParaSingleQubitGate): + def __init__(self, pos: int, paras): + super().__init__("RX", pos, paras, matrix=rxmatrix) + + +class RYGate(ParaSingleQubitGate): + def __init__(self, pos: int, paras): + super().__init__("RY", pos, paras, matrix=rymatrix) + + +class RZGate(ParaSingleQubitGate): + def __init__(self, pos: int, paras): + super().__init__("RZ", pos, paras, matrix=rzmatrix) + + +class RXXGate(ParaMultiQubitGate): + def __init__(self, q1: int, q2: int, theta): + super().__init__("RXX", [q1, q2], theta, matrix=rxxmatrix(theta)) + + def get_targ_matrix(self, reverse_order=False): + return self.matrix + + +class RYYGate(ParaMultiQubitGate): + def __init__(self, q1: int, q2: int, theta): + super().__init__("RYY", [q1, q2], theta, matrix=ryymatrix(theta)) + + def get_targ_matrix(self, reverse_order=False): + return self.matrix + + +class RZZGate(ParaMultiQubitGate): + def __init__(self, q1: int, q2: int, theta): + super().__init__("RZZ", [q1, q2], theta, matrix=rzzmatrix(theta)) + + def get_targ_matrix(self, reverse_order=False): + return self.matrix diff --git a/src/quafu/elements/element_gates/sqrt.py b/src/quafu/elements/element_gates/sqrt.py new file mode 100644 index 0000000..fc81563 --- /dev/null +++ b/src/quafu/elements/element_gates/sqrt.py @@ -0,0 +1,63 @@ +from ..quantum_element import FixedSingleQubitGate +import numpy as np + + +class SGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("S", pos, matrix=np.array([[1., 0.], + [0., 1.j]], dtype=complex)) + + +class SdgGate(FixedSingleQubitGate): + def __init__(sell, pos: int): + super().__init__("Sdg", pos, matrix=np.array([[1., 0.], + [0., -1.j]], dtype=complex)) + + +class TGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("T", pos, matrix=np.array([[1., 0.], + [0., np.exp(1.j * np.pi / 4)]], dtype=complex)) + + +class TdgGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("Tdg", pos, matrix=np.array([[1., 0.], + [0, np.exp(-1.j * np.pi / 4)]], dtype=complex)) + + +class SXGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("SX", pos, matrix=np.zeros((2, 2), dtype=complex)) + self.matrix = np.array([[0.5 + 0.5j, 0.5 - 0.5j], + [0.5 - 0.5j, 0.5 + 0.5j]]) + self.symbol = "√X" + + +class SXdgGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("SXdg", pos, matrix=np.zeros((2, 2), dtype=complex)) + matrix = np.array([[0.5 - 0.5j, 0.5 + 0.5j], + [0.5 + 0.5j, 0.5 - 0.5j]]) + self.matrix = matrix + self.symbol = "√X†" + + +class SYGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("SY", pos, matrix=np.zeros((2, 2), dtype=complex)) + self.matrix = np.array([[0.5 + 0.5j, -0.5 - 0.5j], + [0.5 + 0.5j, 0.5 + 0.5j]]) + self.symbol = "√Y" + + def to_qasm(self): + # TODO: this is not correct + return "ry(pi/2) q[%d]" % self.pos + + +class SYdgGate(FixedSingleQubitGate): + def __init__(self, pos: int): + super().__init__("SY", pos, matrix=np.zeros((2, 2), dtype=complex)) + self.matrix = np.array([[0.5 - 0.5j, -0.5 + 0.5j], + [0.5 - 0.5j, 0.5 - 0.5j]]) + self.symbol = "√Y†" diff --git a/src/quafu/elements/element_gates/swap.py b/src/quafu/elements/element_gates/swap.py new file mode 100644 index 0000000..5086621 --- /dev/null +++ b/src/quafu/elements/element_gates/swap.py @@ -0,0 +1,19 @@ +from ..quantum_element import FixedMultiQubitGate +from ._matrices import ISwapMatrix, SwapMatrix + + +class iSwapGate(FixedMultiQubitGate): + def __init__(self, q1: int, q2: int): + super().__init__("iSWAP", [q1, q2], matrix=ISwapMatrix) + + def get_targ_matrix(self, reverse_order=False): + return self.matrix + + +class SwapGate(FixedMultiQubitGate): + def __init__(self, q1: int, q2: int): + super().__init__("SWAP", [q1, q2], matrix=SwapMatrix) + self.symbol = "x" + + def get_targ_matrix(self, reverse_order=False): + return self.matrix From 8e01805dcf09c62e1d48b5fe2bb783be0af8e96f Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Thu, 6 Jul 2023 12:17:13 +0800 Subject: [PATCH 32/70] "Modify measure()" 1. Now allows updating by several commands of .measure(pos, cbits) on different positions. 2. Also allows to measure all qubits directly by measure() 3. Add uniqueness check. --- src/quafu/circuits/quantum_circuit.py | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/src/quafu/circuits/quantum_circuit.py b/src/quafu/circuits/quantum_circuit.py index 9c4dc13..890a14c 100644 --- a/src/quafu/circuits/quantum_circuit.py +++ b/src/quafu/circuits/quantum_circuit.py @@ -20,7 +20,7 @@ def __init__(self, num: int): self.gates = [] self.openqasm = "" self.circuit = [] - self.measures = {dict(zip(range(num), range(num)))} + self.measures = {} self._used_qubits = [] @property @@ -733,7 +733,7 @@ def mcz(self, ctrls: List[int], targ: int): """ self.add_gate(qeg.MCZGate(ctrls, targ)) - def measure(self, pos: List[int], cbits: List[int] = None) -> None: + def measure(self, pos: List[int] = None, cbits: List[int] = None) -> None: """ Measurement setting for experiment device. @@ -741,14 +741,19 @@ def measure(self, pos: List[int], cbits: List[int] = None) -> None: pos: Qubits need measure. cbits: Classical bits keeping the measure results. """ - - self.measures = dict(zip(pos, range(len(pos)))) + if pos is None: + pos = list(range(self.num)) if cbits: - if len(cbits) == len(self.measures): - self.measures = dict(zip(pos, cbits)) - else: + if not len(cbits) == len(pos): raise CircuitError("Number of measured bits should equal to the number of classical bits") + else: + cbits = pos + + newly_measures = dict(zip(pos, cbits)) + self.measures = {**self.measures, **newly_measures} + if not len(self.measures.values()) == len(set(self.measures.values())): + raise ValueError("Measured bits not uniquely assigned.") def add_pulse(self, pulse: QuantumPulse, From dde160977e60a68ea9cf1e24656cb2bd42d24e98 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Thu, 6 Jul 2023 12:20:31 +0800 Subject: [PATCH 33/70] "Isolate matrices of gates in thus file. " --- src/quafu/elements/element_gates/_matrices.py | 142 ++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100644 src/quafu/elements/element_gates/_matrices.py diff --git a/src/quafu/elements/element_gates/_matrices.py b/src/quafu/elements/element_gates/_matrices.py new file mode 100644 index 0000000..b5b16b7 --- /dev/null +++ b/src/quafu/elements/element_gates/_matrices.py @@ -0,0 +1,142 @@ +import numpy as np + +IdMatrix = np.eye(2, dtype=complex) +XMatrix = np.array([[0., 1.], [1., 0.]], dtype=complex) +YMatrix = np.array([[0., -1.j], [1.j, 0.]], dtype=complex) +ZMatrix = np.array([[1., 0.], [0., -1.]], dtype=complex) +SMatrix = np.array([[1., 0.], [0., 1.j]], dtype=complex) +SXMatrix = np.array([[1., 1.j], [1.j, 1.]], dtype=complex) / np.sqrt(2) +SYMatrix = np.array([[1., -1.], [1., 1.]], dtype=complex) / np.sqrt(2) +TMatrix = np.array([[1., 0.], [0., np.exp(1.j * np.pi / 4)]], dtype=complex) +WMatrix = (XMatrix + YMatrix) / np.sqrt(2) +HMatrix = (XMatrix + ZMatrix) / np.sqrt(2) +SwapMatrix = np.array([[1., 0., 0., 0.], + [0., 0., 1., 0.], + [0., 1., 0., 0.], + [0., 0., 0., 1.]], dtype=complex) +ISwapMatrix = np.array([[1., 0., 0., 0.], + [0., 0., 1.j, 0.], + [0., 1.j, 0., 0.], + [0., 0., 0., 1.]], dtype=complex) +CXMatrix = np.array([[1., 0., 0., 0.], + [0., 1., 0., 0.], + [0., 0., 0., 1.], + [0., 0., 1., 0.]], dtype=complex) +CYMatrix = np.array([[1., 0., 0., 0.], + [0., 1., 0., 0.], + [0., 0., 0., -1.j], + [0., 0., 1.j, 0.]], dtype=complex) +CZMatrix = np.array([[1., 0., 0., 0.], + [0., 1., 0., 0.], + [0., 0., 1., 0.], + [0., 0., 0., -1.]], dtype=complex) +ToffoliMatrix = np.array([[1., 0., 0., 0., 0., 0., 0., 0.], + [0., 1., 0., 0., 0., 0., 0., 0.], + [0., 0., 1., 0., 0., 0., 0., 0.], + [0., 0., 0., 1., 0., 0., 0., 0.], + [0., 0., 0., 0., 1., 0., 0., 0.], + [0., 0., 0., 0., 0., 1., 0., 0.], + [0., 0., 0., 0., 0., 0., 0., 1.], + [0., 0., 0., 0., 0., 0., 1., 0.]], dtype=complex) +FredkinMatrix = np.array([[1., 0., 0., 0., 0., 0., 0., 0.], + [0., 1., 0., 0., 0., 0., 0., 0.], + [0., 0., 1., 0., 0., 0., 0., 0.], + [0., 0., 0., 1., 0., 0., 0., 0.], + [0., 0., 0., 0., 1., 0., 0., 0.], + [0., 0., 0., 0., 0., 0., 1., 0.], + [0., 0., 0., 0., 0., 1., 0., 0.], + [0., 0., 0., 0., 0., 0., 0., 1.]], dtype=complex) + + +def u2matrix(_phi=0., _lambda=0.): + """OpenQASM 3.0 specification""" + return np.array([[1., np.exp(-1.j * _lambda)], + [np.exp(1.j * _phi), np.exp((_phi + _lambda) * 1.j)]], dtype=complex) + + +def u3matrix(_theta=0., _phi=0., _lambda=0.): + """OpenQASM 3.0 specification""" + return np.array([[np.cos(0.5 * _theta), -np.exp(_lambda * 1.j) * np.sin(0.5 * _theta)], + [np.exp(_phi * 1.j) * np.sin(0.5 * _theta), + np.exp((_phi + _lambda) * 1.j) * np.cos(0.5 * _theta)]], dtype=complex) + + +def rxmatrix(theta): + return np.array([[np.cos(0.5 * theta), -1.j * np.sin(0.5 * theta)], + [-1.j * np.sin(0.5 * theta), np.cos(0.5 * theta)]], dtype=complex) + + +def rymatrix(theta): + return np.array([[np.cos(0.5 * theta), - np.sin(0.5 * theta)], + [np.sin(0.5 * theta), np.cos(0.5 * theta)]], dtype=complex) + + +def rzmatrix(theta): + return np.array([[np.exp(-0.5j * theta), 0.], + [0., np.exp(0.5j * theta)]], dtype=complex) + + +def pmatrix(labda): + return np.array([[1, 0], + [0, np.exp(1j * labda)]], dtype=complex) + + +def rxxmatrix(theta): + """Unitary evolution of XX interaction""" + return np.array([[np.cos(theta / 2), 0, 0, -1j * np.sin(theta / 2)], + [0, np.cos(theta / 2), -1j * np.sin(theta / 2), 0], + [0, -1j * np.sin(theta / 2), np.cos(theta / 2), 0], + [-1j * np.sin(theta / 2), 0, 0, np.cos(theta / 2)] + ]) + + +def ryymatrix(theta): + """ Unitary evolution of YY interaction""" + c = np.cos(theta / 2) + s = 1j * np.sin(theta / 2) + return np.array([[c, 0, 0, +s], + [0, c, -s, 0], + [0, -s, c, 0], + [+s, 0, 0, c] + ]) + + +def rzzmatrix(theta): + return np.array([[np.exp(-1j * theta / 2), 0, 0, 0], + [0, np.exp(1j * theta / 2), 0, 0], + [0, 0, np.exp(1j * theta / 2), 0], + [0, 0, 0, np.exp(-1j * theta / 2)] + ]) + +# def rx_matrix(phi: float): +# return np.array([[np.cos(phi / 2), -1.j * np.sin(phi / 2)], +# [-1.j * np.sin(phi / 2), np.cos(phi / 2)]]) +# +# +# def ry_matrix(phi: float): +# return np.array([[np.cos(phi / 2), -np.sin(phi / 2)], +# [np.sin(phi / 2), np.cos(phi / 2)]], dtype=complex) +# +# +# def rz_matrix(phi: float): +# rz = np.array([[np.exp(-1.j * phi / 2), 0.], +# [0., np.exp(1.j * phi / 2)]]) +# return rz +# +# +# def su2_matrix(gamma: float, beta: float, delta: float): +# """ +# SU = Rz(beta)Ry(gamma)Rz(delta). +# +# Symbol convention is the same as in the textbook +# of Chuang and Nielsen. +# """ +# s, c = np.sin(gamma / 2), np.cos(gamma / 2) +# alpha1, alpha2 = (delta + beta) / 2, (delta - beta) / 2 +# su2_mat = np.array([[np.exp(-1.j * alpha1) * c, -np.exp(-1.j * alpha2) * s], +# [np.exp(1.j * alpha2) * s, np.exp(1.j * alpha1) * c]]) +# return su2_mat +# +# +# def u2_matrix(alpha: float, gamma: float, beta: float, delta: float): +# return np.exp(1.j * alpha) * su2_matrix(gamma, beta, delta) From 4f63c223dc2fc4d4a0ec402c3c554f1adfd78a4c Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Thu, 6 Jul 2023 12:22:46 +0800 Subject: [PATCH 34/70] "delete old element_gates.py" --- src/quafu/elements/element_gates.py | 306 ---------------------------- 1 file changed, 306 deletions(-) delete mode 100644 src/quafu/elements/element_gates.py diff --git a/src/quafu/elements/element_gates.py b/src/quafu/elements/element_gates.py deleted file mode 100644 index 82258d0..0000000 --- a/src/quafu/elements/element_gates.py +++ /dev/null @@ -1,306 +0,0 @@ -# This is the file for concrete element quantum gates -import numpy as np -from scipy.linalg import sqrtm - -from .quantum_element import FixedSingleQubitGate, ParaMultiQubitGate, ParaSingleQubitGate, \ - ControlledGate, FixedMultiQubitGate - - -def _u2matrix(_phi=0., _lambda=0.): - """OpenQASM 3.0 specification""" - return np.array([[1., np.exp(-1.j * _lambda)], - [np.exp(1.j * _phi), np.exp((_phi + _lambda) * 1.j)]], dtype=complex) - - -def _u3matrix(_theta=0., _phi=0., _lambda=0.): - """OpenQASM 3.0 specification""" - return np.array([[np.cos(0.5 * _theta), -np.exp(_lambda * 1.j) * np.sin(0.5 * _theta)], - [np.exp(_phi * 1.j) * np.sin(0.5 * _theta), - np.exp((_phi + _lambda) * 1.j) * np.cos(0.5 * _theta)]], dtype=complex) - - -def _rxmatrix(theta): - return np.array([[np.cos(0.5 * theta), -1.j * np.sin(0.5 * theta)], - [-1.j * np.sin(0.5 * theta), np.cos(0.5 * theta)]], dtype=complex) - - -def _rymatrix(theta): - return np.array([[np.cos(0.5 * theta), - np.sin(0.5 * theta)], - [np.sin(0.5 * theta), np.cos(0.5 * theta)]], dtype=complex) - - -def _rzmatrix(theta): - return np.array([[np.exp(-0.5j * theta), 0.], - [0., np.exp(0.5j * theta)]], dtype=complex) - - -def _pmatrix(labda): - return np.array([[1, 0], - [0, np.exp(1j * labda)]], dtype=complex) - - -def _rxxmatrix(theta): - """Unitary evolution of XX interaction""" - return np.array([[np.cos(theta / 2), 0, 0, -1j * np.sin(theta / 2)], - [0, np.cos(theta / 2), -1j * np.sin(theta / 2), 0], - [0, -1j * np.sin(theta / 2), np.cos(theta / 2), 0], - [-1j * np.sin(theta / 2), 0, 0, np.cos(theta / 2)] - ]) - - -def _ryymatrix(theta): - """ Unitary evolution of YY interaction""" - return np.array([[np.cos(theta / 2), 0, 0, 1j * np.sin(theta / 2)], - [0, np.cos(theta / 2), -1j * np.sin(theta / 2), 0], - [0, -1j * np.sin(theta / 2), np.cos(theta / 2), 0], - [1j * np.sin(theta / 2), 0, 0, np.cos(theta / 2)] - ]) - - -def _rzzmatrix(theta): - return np.array([[np.exp(-1j * theta / 2), 0, 0, 0], - [0, np.exp(1j * theta / 2), 0, 0], - [0, 0, np.exp(1j * theta / 2), 0], - [0, 0, 0, np.exp(-1j * theta / 2)] - ]) - - -class IdGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("Id", pos, matrix=np.array([[1., 0.], - [0., 1.]], dtype=complex)) - - -class HGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("H", pos, matrix=1 / np.sqrt(2) * np.array([[1., 1.], - [1., -1.]], dtype=complex)) - - -class XGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("X", pos, matrix=np.array([[0., 1.], - [1., 0.]], dtype=complex)) - - -class YGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("Y", pos, matrix=np.array([[0., -1.j], - [1.j, 0.]], dtype=complex)) - - -class ZGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("Z", pos, matrix=np.array([[1., 0.], - [0., -1.]], dtype=complex)) - - -class SGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("S", pos, matrix=np.array([[1., 0.], - [0., 1.j]], dtype=complex)) - - -class SdgGate(FixedSingleQubitGate): - def __init__(sell, pos: int): - super().__init__("Sdg", pos, matrix=np.array([[1., 0.], - [0., -1.j]], dtype=complex)) - - -class TGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("T", pos, matrix=np.array([[1., 0.], - [0., np.exp(1.j * np.pi / 4)]], dtype=complex)) - - -class TdgGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("Tdg", pos, matrix=np.array([[1., 0.], - [0, np.exp(-1.j * np.pi / 4)]], dtype=complex)) - - -class WGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("W", pos, matrix=np.zeros((2, 2), dtype=complex)) - self.matrix = (XGate(0).matrix + YGate(0).matrix) / np.sqrt(2) - - def to_qasm(self): - return "rz(-pi/4) q[%d];\nrx(pi) q[%d];\nrz(pi/4) q[%d]" % (self.pos, self.pos, self.pos) - - -class SXGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("SX", pos, matrix=np.zeros((2, 2), dtype=complex)) - self.matrix = np.array([[0.5 + 0.5j, 0.5 - 0.5j], - [0.5 - 0.5j, 0.5 + 0.5j]]) - self.symbol = "√X" - - -class SXdgGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("SXdg", pos, matrix=np.zeros((2, 2), dtype=complex)) - matrix = np.array([[0.5 - 0.5j, 0.5 + 0.5j], - [0.5 + 0.5j, 0.5 - 0.5j]]) - self.matrix = matrix - self.symbol = "√X†" - - -class SYGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("SY", pos, matrix=np.zeros((2, 2), dtype=complex)) - self.matrix = np.array([[0.5 + 0.5j, -0.5 - 0.5j], - [0.5 + 0.5j, 0.5 + 0.5j]]) - self.symbol = "√Y" - - def to_qasm(self): - # TODO: this is not correct - return "ry(pi/2) q[%d]" % self.pos - - -class SYdgGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("SY", pos, matrix=np.zeros((2, 2), dtype=complex)) - self.matrix = np.array([[0.5 - 0.5j, -0.5 + 0.5j], - [0.5 - 0.5j, 0.5 - 0.5j]]) - self.symbol = "√Y†" - - -class SWGate(FixedSingleQubitGate): - def __init__(self, pos: int): - super().__init__("SW", pos, matrix=np.zeros((2, 2), dtype=complex)) - # sqrtm(WGate(0).matrix) - self.matrix = np.array([[0.5 + 0.5j, -np.sqrt(0.5) * 1j], - [np.sqrt(0.5), 0.5 + 0.5j]], dtype=complex) - self.symbol = "√W" - - def to_qasm(self): - return "rz(-pi/4) q[%d];\nrx(pi/2) q[%d];\nrz(pi/4) q[%d]" % (self.pos, self.pos, self.pos) - - -class RXGate(ParaSingleQubitGate): - def __init__(self, pos: int, paras): - super().__init__("RX", pos, paras, matrix=_rxmatrix) - - -class RYGate(ParaSingleQubitGate): - def __init__(self, pos: int, paras): - super().__init__("RY", pos, paras, matrix=_rymatrix) - - -class RZGate(ParaSingleQubitGate): - def __init__(self, pos: int, paras): - super().__init__("RZ", pos, paras, matrix=_rzmatrix) - - -class PhaseGate(ParaSingleQubitGate): - def __init__(self, pos: int, paras): - super().__init__("P", pos, paras, matrix=_pmatrix) - - -class iSwapGate(FixedMultiQubitGate): - def __init__(self, q1: int, q2: int): - super().__init__("iSWAP", [q1, q2], matrix=np.array([[1., 0., 0., 0.], - [0., 0., 1.j, 0.], - [0., 1.j, 0., 0.], - [0., 0., 0., 1.]], dtype=complex)) - - def get_targ_matrix(self, reverse_order=False): - return self.matrix - - -class SwapGate(FixedMultiQubitGate): - def __init__(self, q1: int, q2: int): - super().__init__("SWAP", [q1, q2], matrix=np.array([[1., 0., 0., 0.], - [0., 0., 1., 0.], - [0., 1., 0., 0.], - [0., 0., 0., 1.]], dtype=complex)) - self.symbol = "x" - - def get_targ_matrix(self, reverse_order=False): - return self.matrix - - -class CXGate(ControlledGate): - def __init__(self, ctrl: int, targ: int): - super().__init__("CX", "X", [ctrl], [targ], None, matrix=XGate(0).matrix) - self.symbol = "+" - - -class CYGate(ControlledGate): - def __init__(self, ctrl: int, targ: int): - super().__init__("CY", "Y", [ctrl], [targ], None, matrix=YGate(0).matrix) - - -class CZGate(ControlledGate): - def __init__(self, ctrl: int, targ: int): - super().__init__("CZ", "Z", [ctrl], [targ], None, matrix=ZGate(0).matrix) - - -class CSGate(ControlledGate): - def __init__(self, ctrl: int, targ: int): - super().__init__("CS", "S", [ctrl], [targ], None, matrix=SGate(0).matrix) - - def to_qasm(self): - return "cp(pi/2) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) - - -class CTGate(ControlledGate): - def __init__(self, ctrl: int, targ: int): - super().__init__("CT", "T", [ctrl], [targ], None, matrix=TGate(0).matrix) - - def to_qasm(self): - return "cp(pi/4) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) - - -class CPGate(ControlledGate): - def __init__(self, ctrl: int, targ: int, paras): - super().__init__("CP", "P", [ctrl], [targ], paras, matrix=PhaseGate(0, paras).matrix) - - -class ToffoliGate(ControlledGate): - def __init__(self, ctrl1: int, ctrl2: int, targ: int): - super().__init__("CCX", "X", [ctrl1, ctrl2], [targ], None, matrix=XGate(0).matrix) - - -class FredkinGate(ControlledGate): - def __init__(self, ctrl: int, targ1: int, targ2: int): - super().__init__("CSWAP", "SWAP", [ctrl], [targ1, targ2], None, matrix=SwapGate(0, 1).matrix) - - -class RXXGate(ParaMultiQubitGate): - def __init__(self, q1: int, q2: int, theta): - super().__init__("RXX", [q1, q2], theta, matrix=_rxxmatrix(theta)) - - def get_targ_matrix(self, reverse_order=False): - return self.matrix - - -class RYYGate(ParaMultiQubitGate): - def __init__(self, q1: int, q2: int, theta): - super().__init__("RYY", [q1, q2], theta, matrix=_ryymatrix(theta)) - - def get_targ_matrix(self, reverse_order=False): - return self.matrix - - -class RZZGate(ParaMultiQubitGate): - def __init__(self, q1: int, q2: int, theta): - super().__init__("RZZ", [q1, q2], theta, matrix=_rzzmatrix(theta)) - - def get_targ_matrix(self, reverse_order=False): - return self.matrix - - -class MCXGate(ControlledGate): - def __init__(self, ctrls, targ: int): - super().__init__("MCX", "X", ctrls, [targ], None, matrix=XGate(0).matrix) - - -class MCYGate(ControlledGate): - def __init__(self, ctrls, targ: int): - super().__init__("MCY", "Y", ctrls, [targ], None, matrix=YGate(0).matrix) - - -class MCZGate(ControlledGate): - def __init__(self, ctrls, targ: int): - super().__init__("MCZ", "Z", ctrls, [targ], None, matrix=ZGate(0).matrix) From 16572deac8b9536980899f7c5ce3244d0e685a03 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Tue, 11 Jul 2023 10:59:50 +0800 Subject: [PATCH 35/70] "ignore .pyd in git" --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 252f33e..511b07d 100644 --- a/.gitignore +++ b/.gitignore @@ -13,4 +13,5 @@ cmake *.egg-info test .vscode -thirdparty \ No newline at end of file +thirdparty +.pyd \ No newline at end of file From ec56ecbb80ea64886285b6cc46731de779b40f3c Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Tue, 11 Jul 2023 13:19:01 +0800 Subject: [PATCH 36/70] "Add Superclass Instruction" And set a class attribute 'name' for the subclasses. --- src/quafu/elements/quantum_element.py | 171 ++++++++++++++++++++------ 1 file changed, 136 insertions(+), 35 deletions(-) diff --git a/src/quafu/elements/quantum_element.py b/src/quafu/elements/quantum_element.py index fb33a2a..1b1f4e1 100644 --- a/src/quafu/elements/quantum_element.py +++ b/src/quafu/elements/quantum_element.py @@ -1,8 +1,30 @@ -# This is the file for abstract quantum gates class +# (C) Copyright 2023 Beijing Academy of Quantum Information Sciences +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from abc import ABC from typing import Union, Callable, List, Iterable import numpy as np +""" +Base classes for ALL kinds of possible instructions on superconducting +quantum circuits. +""" + +ParaType = dict[str: float | int] +PosType = Union[int, List[int]] + def reorder_matrix(matrix: np.ndarray, pos: List): """Reorder the input sorted matrix to the pos order """ @@ -14,9 +36,80 @@ def reorder_matrix(matrix: np.ndarray, pos: List): return np.transpose(tensorm, inds).reshape([dim, dim]) -class Barrier(object): +class Instruction(ABC): + name = None # type: str + # """ + # Metaclass for primitive instructions in DIRECTED ACYCLIC quantum circuits + # or quantum-classical circuits. + # + # Member variables: + # + # - sd_name: standard name without args or extra annotations. Used for communications + # and identifications within pyquafu program, for example, to translate a qu_gate into qasm. + # Ideally every known primitive during computation should have such a name, and should be + # chosen as the most commonly accepted convention. NOT allowed to be changed by users once + # the class is instantiated. + # + # - pos: positions of relevant quantum or classical bits, legs of DAG. + # + # - dorder: depth order, or topological order of DAG + # + # - symbol: label that can be freely customized by users. If sd_name is not None, name is the + # same as sd_name by default. Otherwise, a symbol has to be specified while sd_name remains + # as None to indicate that this is a use-defined class. + # """ + # + # _ins_id = None # type: str + # + # def __init__(self, pos: PosType, label: str = None, paras: ParaType = None): + # # if pos is not iterable, make it be + # self.pos = [pos] if isinstance(pos, int) else pos + # if label: + # self.label = label + # else: + # if self._ins_id is None: + # raise ValueError('For user-defined instruction, label has to be specified.') + # self.label = self._ins_id + # if paras: + # self.label += '(' + ', '.join(['%.3f' % _ for _ in paras.values()]) + ')' + # self.paras = paras + # + # @classmethod + # def get_ins_id(cls): + # return cls._ins_id + # + # @abstractmethod + # def openqasm2(self) -> str: + # pass + + # @_ins_id.setter + # def sd_name(self, name: str): + # if self.sd_name is None: + # self.sd_name = name + # else: + # import warnings + # warnings.warn(message='Invalid assignment, names of standard ' + # 'instructions are not alterable.') + + # def to_dag_node(self): + # name = self.get_ins_id() + # label = self.__repr__() + # + # pos = self.pos + # paras = self.paras + # paras = {} if paras is None else paras + # duration = paras.get('duration', None) + # unit = paras.get('unit', None) + # channel = paras.get('channel', None) + # time_func = paras.get('time_func', None) + # + # return InstructionNode(name, pos, paras, duration, unit, channel, time_func, label) + + +class Barrier(Instruction): + name = "barrier" + def __init__(self, pos): - self.name = "barrier" self.__pos = pos self.symbol = "||" @@ -35,9 +128,10 @@ def to_qasm(self): return "barrier " + ",".join(["q[%d]" % p for p in range(min(self.pos), max(self.pos) + 1)]) -class Delay(object): +class Delay(Instruction): + name = "delay" + def __init__(self, pos: int, duration: int, unit="ns"): - self.name = "delay" if isinstance(duration, int): self.duration = duration else: @@ -53,9 +147,10 @@ def to_qasm(self): return "delay(%d%s) q[%d]" % (self.duration, self.unit, self.pos) -class XYResonance(object): +class XYResonance(Instruction): + name = "XY" + def __init__(self, qs: int, qe: int, duration: int, unit="ns"): - self.name = "XY" if isinstance(duration, int): self.duration = duration else: @@ -69,15 +164,21 @@ def to_qasm(self): ["q[%d]" % p for p in range(min(self.pos), max(self.pos) + 1)]) -class Measure(object): +class Measure(Instruction): + name = "measure" + def __init__(self, bitmap: dict): self.qbits = bitmap.keys() self.cbits = bitmap.values() -class QuantumGate(object): - def __init__(self, name: str, pos: Union[int, List[int]], paras: Union[None, float, List[float]], matrix): - self.name = name +class QuantumGate(Instruction, ABC): + name = 'gate' + + def __init__(self, + pos: PosType, + paras: Union[float, List[float]] = None, + matrix=None): self.pos = pos self.paras = paras self.matrix = matrix @@ -90,14 +191,6 @@ def __init__(self, name: str, pos: Union[int, List[int]], paras: Union[None, flo else: self.symbol = "%s" % self.name - @property - def name(self): - return self.__name - - @name.setter - def name(self, _name): - self.__name = _name - @property def pos(self): return self.__pos @@ -149,8 +242,10 @@ def to_qasm(self): class SingleQubitGate(QuantumGate): - def __init__(self, name: str, pos: int, paras, matrix): - super().__init__(name, pos, paras=paras, matrix=matrix) + name = 'su(2)' + + def __init__(self, pos: int, paras, matrix): + super().__init__(pos, paras=paras, matrix=matrix) @property def matrix(self): @@ -173,13 +268,13 @@ def get_targ_matrix(self, reverse_order=False): class FixedSingleQubitGate(SingleQubitGate): - def __init__(self, name, pos, matrix): - super().__init__(name, pos, paras=None, matrix=matrix) + def __init__(self, pos, matrix): + super().__init__(pos, paras=None, matrix=matrix) class ParaSingleQubitGate(SingleQubitGate): - def __init__(self, name, pos, paras, matrix): - super().__init__(name, pos, paras=paras, matrix=matrix) + def __init__(self, pos, paras, matrix): + super().__init__(pos, paras=paras, matrix=matrix) @property def matrix(self): @@ -201,8 +296,10 @@ def matrix(self, matrix): class MultiQubitGate(QuantumGate): - def __init__(self, name: str, pos: List[int], paras, matrix): - super().__init__(name, pos, paras=paras, matrix=matrix) + name = 'su(n)' + + def __init__(self, pos: List[int], paras, matrix): + super().__init__(pos, paras=paras, matrix=matrix) self._targ_matrix = matrix @property @@ -234,13 +331,13 @@ def get_targ_matrix(self, reverse_order=False): class FixedMultiQubitGate(MultiQubitGate): - def __init__(self, name: str, pos: List[int], matrix): - super().__init__(name, pos, paras=None, matrix=matrix) + def __init__(self, pos: List[int], matrix): + super().__init__(pos, paras=None, matrix=matrix) class ParaMultiQubitGate(MultiQubitGate): - def __init__(self, name, pos, paras, matrix): - super().__init__(name, pos, paras, matrix=matrix) + def __init__(self, pos, paras, matrix): + super().__init__(pos, paras, matrix=matrix) @property def matrix(self): @@ -261,11 +358,11 @@ def matrix(self, matrix): class ControlledGate(MultiQubitGate): """ Controlled gate class, where the matrix act non-trivaly on target qubits""" - def __init__(self, name, targe_name, ctrls: List[int], targs: List[int], paras, matrix): + def __init__(self, targe_name, ctrls: List[int], targs: List[int], paras, matrix): self.ctrls = ctrls self.targs = targs self.targ_name = targe_name - super().__init__(name, ctrls + targs, paras, matrix) + super().__init__(ctrls + targs, paras, matrix) self._targ_matrix = matrix if paras: @@ -314,13 +411,17 @@ def get_targ_matrix(self, reverse_order=False): class ControlledU(ControlledGate): - def __init__(self, name, ctrls: List[int], U: Union[SingleQubitGate, MultiQubitGate]): + """ Controlled gate class, where the matrix act non-trivaly on target qubits""" + + name = 'cu' + + def __init__(self, ctrls: List[int], U: Union[SingleQubitGate, MultiQubitGate]): self.targ_gate = U targs = U.pos if isinstance(targs, int): targs = [targs] - super().__init__(name, U.name, ctrls, targs, U.paras, matrix=self.targ_gate.get_targ_matrix()) + super().__init__(U.name, ctrls, targs, U.paras, matrix=self.targ_gate.get_targ_matrix()) def get_targ_matrix(self, reverse_order=False): return self.targ_gate.get_targ_matrix(reverse_order) From edade0c67891bb93413290b6142dc4ed47c443c9 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Tue, 11 Jul 2023 13:22:18 +0800 Subject: [PATCH 37/70] "Fix some small problems." --- src/quafu/elements/element_gates/_matrices.py | 2 + src/quafu/elements/element_gates/c11.py | 4 +- src/quafu/elements/element_gates/pauli.py | 27 +++---- src/quafu/qfasm/qfasm_convertor.py | 2 +- src/quafu/visualisation/circuitPlot.py | 40 ++-------- .../visualisation/examples/deutsch_jozsa.py | 76 +++++++------------ 6 files changed, 48 insertions(+), 103 deletions(-) diff --git a/src/quafu/elements/element_gates/_matrices.py b/src/quafu/elements/element_gates/_matrices.py index b5b16b7..568137a 100644 --- a/src/quafu/elements/element_gates/_matrices.py +++ b/src/quafu/elements/element_gates/_matrices.py @@ -9,6 +9,8 @@ SYMatrix = np.array([[1., -1.], [1., 1.]], dtype=complex) / np.sqrt(2) TMatrix = np.array([[1., 0.], [0., np.exp(1.j * np.pi / 4)]], dtype=complex) WMatrix = (XMatrix + YMatrix) / np.sqrt(2) +SWMatrix = np.array([[0.5 + 0.5j, -np.sqrt(0.5) * 1j], + [np.sqrt(0.5), 0.5 + 0.5j]], dtype=complex) HMatrix = (XMatrix + ZMatrix) / np.sqrt(2) SwapMatrix = np.array([[1., 0., 0., 0.], [0., 0., 1., 0.], diff --git a/src/quafu/elements/element_gates/c11.py b/src/quafu/elements/element_gates/c11.py index 3f49e28..b43963b 100644 --- a/src/quafu/elements/element_gates/c11.py +++ b/src/quafu/elements/element_gates/c11.py @@ -1,5 +1,5 @@ from ..quantum_element import ControlledGate -from ._matrices import XMatrix, YMatrix, ZMatrix, SMatrix, TMatrix +from ._matrices import XMatrix, YMatrix, ZMatrix, SMatrix, TMatrix, pmatrix class CXGate(ControlledGate): @@ -36,4 +36,4 @@ def to_qasm(self): class CPGate(ControlledGate): def __init__(self, ctrl: int, targ: int, paras): - super().__init__("CP", "P", [ctrl], [targ], paras, matrix=PhaseGate(0, paras).matrix) + super().__init__("CP", "P", [ctrl], [targ], paras, matrix=pmatrix(paras)) diff --git a/src/quafu/elements/element_gates/pauli.py b/src/quafu/elements/element_gates/pauli.py index 74bd051..59180ab 100644 --- a/src/quafu/elements/element_gates/pauli.py +++ b/src/quafu/elements/element_gates/pauli.py @@ -1,41 +1,36 @@ +from ._matrices import XMatrix, YMatrix, ZMatrix, HMatrix, WMatrix, SWMatrix from ..quantum_element import FixedSingleQubitGate -import numpy as np class IdGate(FixedSingleQubitGate): def __init__(self, pos: int): - super().__init__("Id", pos, matrix=np.array([[1., 0.], - [0., 1.]], dtype=complex)) + super().__init__("Id", pos, matrix=XMatrix) class HGate(FixedSingleQubitGate): def __init__(self, pos: int): - super().__init__("H", pos, matrix=1 / np.sqrt(2) * np.array([[1., 1.], - [1., -1.]], dtype=complex)) + super().__init__("H", pos, matrix=HMatrix) class XGate(FixedSingleQubitGate): def __init__(self, pos: int): - super().__init__("X", pos, matrix=np.array([[0., 1.], - [1., 0.]], dtype=complex)) + super().__init__("X", pos, matrix=XMatrix) class YGate(FixedSingleQubitGate): def __init__(self, pos: int): - super().__init__("Y", pos, matrix=np.array([[0., -1.j], - [1.j, 0.]], dtype=complex)) + super().__init__("Y", pos, matrix=YMatrix) class ZGate(FixedSingleQubitGate): def __init__(self, pos: int): - super().__init__("Z", pos, matrix=np.array([[1., 0.], - [0., -1.]], dtype=complex)) + super().__init__("Z", pos, matrix=ZMatrix) class WGate(FixedSingleQubitGate): def __init__(self, pos: int): - super().__init__("W", pos, matrix=np.zeros((2, 2), dtype=complex)) - self.matrix = (XGate(0).matrix + YGate(0).matrix) / np.sqrt(2) + super().__init__("W", pos, matrix=WMatrix) + self.symbol = "W" def to_qasm(self): return "rz(-pi/4) q[%d];\nrx(pi) q[%d];\nrz(pi/4) q[%d]" % (self.pos, self.pos, self.pos) @@ -43,10 +38,8 @@ def to_qasm(self): class SWGate(FixedSingleQubitGate): def __init__(self, pos: int): - super().__init__("SW", pos, matrix=np.zeros((2, 2), dtype=complex)) - self.matrix = np.array([[0.5 + 0.5j, -np.sqrt(0.5) * 1j], - [np.sqrt(0.5), 0.5 + 0.5j]], dtype=complex) + super().__init__("SW", pos, matrix=SWMatrix) self.symbol = "√W" def to_qasm(self): - return "rz(-pi/4) q[%d];\nrx(pi/2) q[%d];\nrz(pi/4) q[%d]" % (self.pos, self.pos, self.pos) \ No newline at end of file + return "rz(-pi/4) q[%d];\nrx(pi/2) q[%d];\nrz(pi/4) q[%d]" % (self.pos, self.pos, self.pos) diff --git a/src/quafu/qfasm/qfasm_convertor.py b/src/quafu/qfasm/qfasm_convertor.py index 669a6c7..9ccebce 100644 --- a/src/quafu/qfasm/qfasm_convertor.py +++ b/src/quafu/qfasm/qfasm_convertor.py @@ -1,7 +1,7 @@ from .qfasm_parser import QfasmParser, QregNode from quafu.dagcircuits.circuit_dag import node_to_gate from quafu.dagcircuits.instruction_node import InstructionNode -from quafu import QuantumCircuit +from quafu.circuits.quantum_circuit import QuantumCircuit def qasm_to_circuit(qasm): diff --git a/src/quafu/visualisation/circuitPlot.py b/src/quafu/visualisation/circuitPlot.py index 68fd201..995009d 100644 --- a/src/quafu/visualisation/circuitPlot.py +++ b/src/quafu/visualisation/circuitPlot.py @@ -1,11 +1,12 @@ +# from quafu.circuits.quantum_circuit import QuantumCircuit import numpy as np -import quafu import matplotlib.patheffects as pe import matplotlib.pyplot as plt from matplotlib.collections import PolyCollection, PatchCollection, LineCollection from matplotlib.patches import Circle, Arc from matplotlib.text import Text + line_args = {} box_args = {} @@ -61,7 +62,7 @@ class CircuitPlotManager: _stroke = pe.withStroke(linewidth=2, foreground='white') - def __init__(self, qc: quafu.QuantumCircuit): + def __init__(self, qc): """ Processing graphical info from a quantum circuit, whose gates are stored as a list at present. @@ -71,7 +72,6 @@ def __init__(self, qc: quafu.QuantumCircuit): (TODO) """ self.qbit_num = qc.num - # step0: containers of graphical elements self._h_wire_points = [] @@ -111,7 +111,7 @@ def __init__(self, qc: quafu.QuantumCircuit): self._proc_ctrl(depth, gate.ctrls[0], gate.targs[0], 'x') else: # control - raise NotImplemented + raise NotImplementedError(f'Gate {id_name} is not supported yet.') dorders[_which] = depth + 1 self.depth = np.max(dorders) + 1 @@ -176,7 +176,7 @@ def _circuit_wires(self): def _gate_bbox(self, x, y, fc: str): a = self._a from matplotlib.patches import FancyBboxPatch - bbox = FancyBboxPatch((-a / 2 + x, -a / 2 + y), a, a, + bbox = FancyBboxPatch((-a / 2 + x, -a / 2 + y), a, a, # this warning belongs to matplotlib boxstyle=f'round, pad={0.2 * a}', edgecolor=DEEPCOLOR, facecolor=fc, @@ -456,33 +456,3 @@ def _render_circuit(self): self._render_barrier() self._render_closed_patch() self._render_txt() - - -if __name__ == '__main__': - n = 8 - qc_ = quafu.QuantumCircuit(n) - qc_.h(0) - - qc_.barrier([0, 3]) - qc_.x(0) - qc_.swap(0, 4) - qc_.cnot(3, 6) - qc_.rz(4, 3.2) - - for k in range(10): - qc_.x(7) - for k in range(n-1): - qc_.cnot(k, k + 1) - qc_.measure([0, 1, 2, 3], [0, 1, 2, 3]) - - # for i in range(30): - # qc.x(4) - - cmp = CircuitPlotManager(qc_) - cmp(title='This Is a Quantum Circuit') - import os - if not os.path.exists('./figures/'): - os.mkdir('./figures/') - plt.savefig('./figures/test.png', dpi=300, transparent=True) - plt.close() - # plt.show() diff --git a/src/quafu/visualisation/examples/deutsch_jozsa.py b/src/quafu/visualisation/examples/deutsch_jozsa.py index 357408c..49d9133 100644 --- a/src/quafu/visualisation/examples/deutsch_jozsa.py +++ b/src/quafu/visualisation/examples/deutsch_jozsa.py @@ -1,51 +1,49 @@ import random - import matplotlib.pyplot as plt import numpy as np from quafu.circuits.quantum_circuit import QuantumCircuit -from ..circuitPlot import CircuitPlotManager +from quafu.visualisation.circuitPlot import CircuitPlotManager -def get_const_oracle(n: int): - const_oracle = QuantumCircuit(n + 1) +def get_const_oracle(qc: QuantumCircuit): + n = qc.num - 1 output = np.random.randint(2) if output == 1: - const_oracle.x(n) - const_oracle.name = 'Constant Oracle' - return const_oracle + qc.x(n) + qc.name = 'Constant Oracle' + return qc -def get_balanced_oracle(n: int): - oracle = QuantumCircuit(n + 1) +def get_balanced_oracle(qc: QuantumCircuit): + n = qc.num - 1 b_str = ''.join([random.choice('01') for _ in range(n)]) # Place X-qu_gate for qubit in range(len(b_str)): if b_str[qubit] == '1': - oracle.x(qubit) + qc.x(qubit) # Use barrier as divider - oracle.barrier(list(range(n+1))) + qc.barrier() # Controlled-NOT qu_gate for qubit in range(n): - oracle.cnot(qubit, n) + qc.cnot(qubit, n) - oracle.barrier(list(range(n+1))) + qc.barrier() # Place X-qu_gate for qubit in range(len(b_str)): if b_str[qubit] == '1': - oracle.x(qubit) + qc.x(qubit) - oracle.name = 'Balanced Oracle' - return oracle + qc.name = 'Balanced Oracle' + return qc def deutsch_jozsa(n: int, case: str): circuit = QuantumCircuit(n + 1) # number of q-bit and c-bit - # Initialization for qubit in range(n): circuit.h(qubit) @@ -55,37 +53,18 @@ def deutsch_jozsa(n: int, case: str): # Add oracle ################################################# if case == 'balanced': - b_str = ''.join([random.choice('01') for _ in range(n)]) - - # Place X-qu_gate - for qubit in range(len(b_str)): - if b_str[qubit] == '1': - circuit.x(qubit) - - circuit.barrier(list(range(n+1))) - # Controlled-NOT qu_gate - for qubit in range(n): - circuit.cnot(qubit, n) - circuit.barrier(list(range(n+1))) - - # Place X-qu_gate - for qubit in range(len(b_str)): - if b_str[qubit] == '1': - circuit.x(qubit) + get_balanced_oracle(circuit) elif case == 'constant': - const_oracle = QuantumCircuit(n + 1) - output = np.random.randint(2) - if output == 1: - const_oracle.x(n) + get_const_oracle(circuit) else: raise ValueError('undefined case: ' + case) ################################################# # Repeat H-qu_gate - circuit.barrier(list(range(n+1))) + circuit.barrier() for qubit in range(n): circuit.h(qubit) - circuit.barrier(list(range(n+1))) + circuit.barrier() # Measure circuit.measure(list(range(n)), list(range(n))) @@ -93,14 +72,15 @@ def deutsch_jozsa(n: int, case: str): if __name__ == '__main__': - # plt.figure(dpi=240) - # balanced_oracle = get_balanced_oracle(n=4) - circuits_ = deutsch_jozsa(n=4, case='constant') - cmp = CircuitPlotManager(circuits_) + dj_qc = deutsch_jozsa(n=4, case='constant') + cmp = CircuitPlotManager(dj_qc) cmp(title='Deutsch-Josza Circuit') - import os - if not os.path.exists('./figures/'): - os.mkdir('../figures/') - plt.savefig('../figures/deutsch_jozsa.png', dpi=240) + dj_qc.plot_circuit(title='Deutsch-Josza Circuit') + plt.show() + + # import os + # if not os.path.exists('./figures/'): + # os.mkdir('./figures/') + # plt.savefig('./figures/deutsch_jozsa.png', dpi=240) # plt.show() From 313decef7805117cd48c4a54b1f2c3636d299cb6 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Tue, 11 Jul 2023 13:23:10 +0800 Subject: [PATCH 38/70] "Add an example for plotting." --- .../visualisation/examples/basic_elements.py | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 src/quafu/visualisation/examples/basic_elements.py diff --git a/src/quafu/visualisation/examples/basic_elements.py b/src/quafu/visualisation/examples/basic_elements.py new file mode 100644 index 0000000..b552572 --- /dev/null +++ b/src/quafu/visualisation/examples/basic_elements.py @@ -0,0 +1,31 @@ +import matplotlib.pyplot as plt +from quafu.visualisation.circuitPlot import CircuitPlotManager +from quafu.circuits.quantum_circuit import QuantumCircuit +import os + +if not os.path.exists('./figures/'): + os.mkdir('./figures/') + +n = 8 +qc_ = QuantumCircuit(n) +qc_.h(0) +qc_.barrier([0, 3]) +qc_.x(0) +qc_.swap(0, 4) +qc_.cnot(3, 6) +qc_.rz(4, 3.2) + +for k in range(10): + qc_.x(7) +for k in range(n): + qc_.cnot(k, k + 1) +qc_.measure([0, 1, 2, 3], [0, 1, 2, 3]) + +# for i in range(30): +# qc.x(4) + +cmp = CircuitPlotManager(qc_) +cmp(title='Basic Elements in Circuit') + +plt.savefig('./figures/basics.png', dpi=300, transparent=True) +plt.close() From 996fecd4d3c3d1cb92e3636d627cc7681ee9fb44 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Tue, 11 Jul 2023 18:59:36 +0800 Subject: [PATCH 39/70] "Move pulse into element package, inherent Instruction" --- .../quantum_element}/pulses/__init__.py | 2 ++ .../quantum_element}/pulses/quantum_pulse.py | 28 ++++++++++++------- 2 files changed, 20 insertions(+), 10 deletions(-) rename src/quafu/{ => elements/quantum_element}/pulses/__init__.py (85%) rename src/quafu/{ => elements/quantum_element}/pulses/quantum_pulse.py (91%) diff --git a/src/quafu/pulses/__init__.py b/src/quafu/elements/quantum_element/pulses/__init__.py similarity index 85% rename from src/quafu/pulses/__init__.py rename to src/quafu/elements/quantum_element/pulses/__init__.py index 44e297c..34be485 100644 --- a/src/quafu/pulses/__init__.py +++ b/src/quafu/elements/quantum_element/pulses/__init__.py @@ -7,3 +7,5 @@ # @Email: yhshi@iphy.ac.cn # @Reminders: |0> has been in the past, |1> is still in the future # @License: Copyright (c) 2023, IOP, CAS + +from .quantum_pulse import QuantumPulse diff --git a/src/quafu/pulses/quantum_pulse.py b/src/quafu/elements/quantum_element/pulses/quantum_pulse.py similarity index 91% rename from src/quafu/pulses/quantum_pulse.py rename to src/quafu/elements/quantum_element/pulses/quantum_pulse.py index c4587eb..88b9d28 100644 --- a/src/quafu/pulses/quantum_pulse.py +++ b/src/quafu/elements/quantum_element/pulses/quantum_pulse.py @@ -1,13 +1,17 @@ -from typing import Union, Optional, Callable, Dict +from copy import deepcopy +from typing import Union, Optional, Callable + import matplotlib.pyplot as plt import numpy as np -from copy import deepcopy import scipy.special +from quafu.elements.quantum_element.instruction import Instruction + + +class QuantumPulse(Instruction): + name = 'Pulse' -class QuantumPulse(object): def __init__(self, - name: str, pos: Union[int, list], paras: list, duration: Union[float, int], @@ -19,7 +23,6 @@ def __init__(self, Quantum Pulse for generating a quantum gate. Args: - name (str): Pulse name pos (int): Qubit position. paras (list): Parameters of the pulse. duration (float, int): Pulse duration. @@ -29,8 +32,7 @@ def __init__(self, Where t=0 is the start, t=duration is the end of the pulse. """ - - self.name = name + super().__init__() self.pos = pos self.paras = paras self.duration = duration @@ -131,6 +133,8 @@ def set_unit(self, unit="ns"): class RectPulse(QuantumPulse): + name = "rect" + def __init__(self, pos, amp, duration, unit, channel): self.amp = amp @@ -138,7 +142,7 @@ def rect_time_func(t, **kws): amp_ = kws["amp"] return amp_ * np.ones(np.array(t).shape) - super().__init__("rect", pos, [amp], duration, unit, channel, rect_time_func) + super().__init__(pos, [amp], duration, unit, channel, rect_time_func) def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): args = {"amp": self.amp} @@ -146,6 +150,8 @@ def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = class FlattopPulse(QuantumPulse): + name = "flattop" + def __init__(self, pos, amp, fwhm, duration, unit, channel): self.amp = amp self.fwhm = fwhm @@ -156,7 +162,7 @@ def flattop_time_func(t, **kws): return amp_ * (scipy.special.erf((duration - t) / sigma_) + scipy.special.erf(t / sigma_) - 1.) - super().__init__("flattop", pos, [amp, fwhm], duration, unit, channel, flattop_time_func) + super().__init__(pos, [amp, fwhm], duration, unit, channel, flattop_time_func) def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): args = {"amp": self.amp, "fwhm": self.fwhm} @@ -164,6 +170,8 @@ def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = class GaussianPulse(QuantumPulse): + name = "gaussian" + def __init__(self, pos, amp, fwhm, phase, duration, unit, channel): self.amp = amp if fwhm == None: @@ -180,7 +188,7 @@ def gaussian_time_func(t, **kws): return amp_ * np.exp( -(t - 0.5 * duration) ** 2 / (2 * sigma_ ** 2) + 1j * phase_) - super().__init__("gaussian", pos, [amp, fwhm, phase], duration, unit, channel, gaussian_time_func) + super().__init__(pos, [amp, fwhm, phase], duration, unit, channel, gaussian_time_func) def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): args = {"amp": self.amp, "fwhm": self.fwhm, "phase": self.phase} From 099082d955fa565db33e1e34d6847d698374f593 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Tue, 11 Jul 2023 20:38:40 +0800 Subject: [PATCH 40/70] "Set `name` and `matrix` properties for Ins and Gates" Set 'name' as an abstract property for any abstract base class like Instruction and as a class attribute for concrete class like XGate. Some logic for adding `matrix` to QuantumCircuit and its subclasses. Matrices of gate-cls with paras are properties decorated by @property, which update matrices automatically when parameters updated. --- src/quafu/elements/element_gates/__init__.py | 4 +- src/quafu/elements/element_gates/c11.py | 26 +- src/quafu/elements/element_gates/c12.py | 6 +- src/quafu/elements/element_gates/c21.py | 6 +- src/quafu/elements/element_gates/cm1.py | 14 +- src/quafu/elements/element_gates/pauli.py | 37 +- src/quafu/elements/element_gates/phase.py | 12 +- src/quafu/elements/element_gates/rotation.py | 62 ++- src/quafu/elements/element_gates/sqrt.py | 70 +-- src/quafu/elements/element_gates/swap.py | 14 +- src/quafu/elements/quantum_element.py | 427 ------------------ .../elements/quantum_element/instruction.py | 80 ++++ .../quantum_element/quantum_element.py | 86 ++++ .../elements/quantum_element/quantum_gate.py | 270 +++++++++++ 14 files changed, 614 insertions(+), 500 deletions(-) delete mode 100644 src/quafu/elements/quantum_element.py create mode 100644 src/quafu/elements/quantum_element/instruction.py create mode 100644 src/quafu/elements/quantum_element/quantum_element.py create mode 100644 src/quafu/elements/quantum_element/quantum_gate.py diff --git a/src/quafu/elements/element_gates/__init__.py b/src/quafu/elements/element_gates/__init__.py index 67052df..51cbf28 100644 --- a/src/quafu/elements/element_gates/__init__.py +++ b/src/quafu/elements/element_gates/__init__.py @@ -1,7 +1,7 @@ from .pauli import XGate, YGate, ZGate, HGate, IdGate, WGate, SWGate from .phase import PhaseGate from .rotation import RXGate, RYGate, RZGate, RXXGate, RYYGate, RZZGate -from .swap import SwapGate, iSwapGate +from .swap import SwapGate, ISwapGate from .sqrt import SXGate, SXdgGate, SYGate, SYdgGate, SGate, SdgGate, TGate, TdgGate from .c11 import CXGate, CYGate, CZGate, CSGate, CTGate, CPGate from .c21 import ToffoliGate @@ -12,7 +12,7 @@ 'SXGate', 'SXdgGate', 'SYGate', 'SYdgGate', 'SGate', 'SdgGate', 'TGate', 'TdgGate', 'PhaseGate', 'RXGate', 'RYGate', 'RZGate', 'RXXGate', 'RYYGate', 'RZZGate', - 'SwapGate', 'iSwapGate', + 'SwapGate', 'ISwapGate', 'CXGate', 'CYGate', 'CZGate', 'CSGate', 'CTGate', 'CPGate', 'ToffoliGate', 'FredkinGate', diff --git a/src/quafu/elements/element_gates/c11.py b/src/quafu/elements/element_gates/c11.py index b43963b..f07ab4b 100644 --- a/src/quafu/elements/element_gates/c11.py +++ b/src/quafu/elements/element_gates/c11.py @@ -1,39 +1,51 @@ from ..quantum_element import ControlledGate -from ._matrices import XMatrix, YMatrix, ZMatrix, SMatrix, TMatrix, pmatrix +from .matrices import XMatrix, YMatrix, ZMatrix, SMatrix, TMatrix, pmatrix class CXGate(ControlledGate): + name = "CX" + def __init__(self, ctrl: int, targ: int): - super().__init__("CX", "X", [ctrl], [targ], None, matrix=XMatrix) + super().__init__("X", [ctrl], [targ], None, matrix=XMatrix) self.symbol = "+" class CYGate(ControlledGate): + name = "CY" + def __init__(self, ctrl: int, targ: int): - super().__init__("CY", "Y", [ctrl], [targ], None, matrix=YMatrix) + super().__init__("Y", [ctrl], [targ], None, matrix=YMatrix) class CZGate(ControlledGate): + name = "CZ" + def __init__(self, ctrl: int, targ: int): - super().__init__("CZ", "Z", [ctrl], [targ], None, matrix=ZMatrix) + super().__init__("Z", [ctrl], [targ], None, matrix=ZMatrix) class CSGate(ControlledGate): + name = "CS" + def __init__(self, ctrl: int, targ: int): - super().__init__("CS", "S", [ctrl], [targ], None, matrix=SMatrix) + super().__init__("S", [ctrl], [targ], None, matrix=SMatrix) def to_qasm(self): return "cp(pi/2) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) class CTGate(ControlledGate): + name = "CT" + def __init__(self, ctrl: int, targ: int): - super().__init__("CT", "T", [ctrl], [targ], None, matrix=TMatrix) + super().__init__("T", [ctrl], [targ], None, matrix=TMatrix) def to_qasm(self): return "cp(pi/4) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) class CPGate(ControlledGate): + name = "CP" + def __init__(self, ctrl: int, targ: int, paras): - super().__init__("CP", "P", [ctrl], [targ], paras, matrix=pmatrix(paras)) + super().__init__("P", [ctrl], [targ], paras, matrix=pmatrix(paras)) diff --git a/src/quafu/elements/element_gates/c12.py b/src/quafu/elements/element_gates/c12.py index f9347f8..ffd56f5 100644 --- a/src/quafu/elements/element_gates/c12.py +++ b/src/quafu/elements/element_gates/c12.py @@ -1,7 +1,9 @@ from ..quantum_element import ControlledGate -from ._matrices import SwapMatrix +from .matrices import SwapMatrix class FredkinGate(ControlledGate): + name = "CSWAP" + def __init__(self, ctrl: int, targ1: int, targ2: int): - super().__init__("CSWAP", "SWAP", [ctrl], [targ1, targ2], None, matrix=SwapMatrix) + super().__init__("SWAP", [ctrl], [targ1, targ2], None, matrix=SwapMatrix) diff --git a/src/quafu/elements/element_gates/c21.py b/src/quafu/elements/element_gates/c21.py index fbbcd70..b56eada 100644 --- a/src/quafu/elements/element_gates/c21.py +++ b/src/quafu/elements/element_gates/c21.py @@ -1,7 +1,9 @@ from ..quantum_element import ControlledGate -from ._matrices import XMatrix +from .matrices import XMatrix class ToffoliGate(ControlledGate): + name = "CCX" + def __init__(self, ctrl1: int, ctrl2: int, targ: int): - super().__init__("CCX", "X", [ctrl1, ctrl2], [targ], None, matrix=XMatrix) + super().__init__("X", [ctrl1, ctrl2], [targ], None, matrix=XMatrix) diff --git a/src/quafu/elements/element_gates/cm1.py b/src/quafu/elements/element_gates/cm1.py index 040797c..fa7d733 100644 --- a/src/quafu/elements/element_gates/cm1.py +++ b/src/quafu/elements/element_gates/cm1.py @@ -1,17 +1,23 @@ -from ._matrices import XMatrix, YMatrix, ZMatrix +from .matrices import XMatrix, YMatrix, ZMatrix from ..quantum_element import ControlledGate class MCXGate(ControlledGate): + name = "MCX" + def __init__(self, ctrls, targ: int): - super().__init__("MCX", "X", ctrls, [targ], None, matrix=XMatrix) + super().__init__("X", ctrls, [targ], None, matrix=XMatrix) class MCYGate(ControlledGate): + name = "MCY" + def __init__(self, ctrls, targ: int): - super().__init__("MCY", "Y", ctrls, [targ], None, matrix=YMatrix) + super().__init__("Y", ctrls, [targ], None, matrix=YMatrix) class MCZGate(ControlledGate): + name = "MCZ" + def __init__(self, ctrls, targ: int): - super().__init__("MCZ", "Z", ctrls, [targ], None, matrix=ZMatrix) + super().__init__("Z", ctrls, [targ], None, matrix=ZMatrix) diff --git a/src/quafu/elements/element_gates/pauli.py b/src/quafu/elements/element_gates/pauli.py index 59180ab..0ec83d4 100644 --- a/src/quafu/elements/element_gates/pauli.py +++ b/src/quafu/elements/element_gates/pauli.py @@ -1,35 +1,53 @@ -from ._matrices import XMatrix, YMatrix, ZMatrix, HMatrix, WMatrix, SWMatrix +from .matrices import XMatrix, YMatrix, ZMatrix, HMatrix, WMatrix, SWMatrix from ..quantum_element import FixedSingleQubitGate class IdGate(FixedSingleQubitGate): + name = "Id" + matrix = XMatrix + def __init__(self, pos: int): - super().__init__("Id", pos, matrix=XMatrix) + super().__init__(pos) class HGate(FixedSingleQubitGate): + name = "H" + matrix = HMatrix + def __init__(self, pos: int): - super().__init__("H", pos, matrix=HMatrix) + super().__init__(pos) class XGate(FixedSingleQubitGate): + name = "X" + matrix = XMatrix + def __init__(self, pos: int): - super().__init__("X", pos, matrix=XMatrix) + super().__init__(pos) class YGate(FixedSingleQubitGate): + name = "Y" + matrix = YMatrix + def __init__(self, pos: int): - super().__init__("Y", pos, matrix=YMatrix) + super().__init__(pos) class ZGate(FixedSingleQubitGate): + name = "Z" + matrix = ZMatrix + def __init__(self, pos: int): - super().__init__("Z", pos, matrix=ZMatrix) + super().__init__(pos) class WGate(FixedSingleQubitGate): + name = "W" + matrix = WMatrix + def __init__(self, pos: int): - super().__init__("W", pos, matrix=WMatrix) + super().__init__(pos) self.symbol = "W" def to_qasm(self): @@ -37,8 +55,11 @@ def to_qasm(self): class SWGate(FixedSingleQubitGate): + name = "SW" + matrix = SWMatrix + def __init__(self, pos: int): - super().__init__("SW", pos, matrix=SWMatrix) + super().__init__(pos) self.symbol = "√W" def to_qasm(self): diff --git a/src/quafu/elements/element_gates/phase.py b/src/quafu/elements/element_gates/phase.py index c40f2a6..6150f8a 100644 --- a/src/quafu/elements/element_gates/phase.py +++ b/src/quafu/elements/element_gates/phase.py @@ -1,7 +1,13 @@ from ..quantum_element import ParaSingleQubitGate -from ._matrices import pmatrix +from .matrices import pmatrix class PhaseGate(ParaSingleQubitGate): - def __init__(self, pos: int, paras): - super().__init__("P", pos, paras, matrix=pmatrix) + name = "P" + + def __init__(self, pos: int, paras: float = 0.): + super().__init__(pos, paras=paras) + + @property + def matrix(self): + return pmatrix(self.paras) diff --git a/src/quafu/elements/element_gates/rotation.py b/src/quafu/elements/element_gates/rotation.py index 05ac4f9..d3812a6 100644 --- a/src/quafu/elements/element_gates/rotation.py +++ b/src/quafu/elements/element_gates/rotation.py @@ -1,41 +1,77 @@ from ..quantum_element import ParaMultiQubitGate, ParaSingleQubitGate -from ._matrices import rxmatrix, rymatrix, rzmatrix, rxxmatrix, ryymatrix, rzzmatrix +from .matrices import rx_mat, ry_mat, rz_mat, rxxmatrix, ryymatrix, rzzmatrix class RXGate(ParaSingleQubitGate): - def __init__(self, pos: int, paras): - super().__init__("RX", pos, paras, matrix=rxmatrix) + name = "RX" + + def __init__(self, pos: int, paras: float = 0.): + super().__init__(pos, paras) + + @property + def matrix(self): + return rx_mat(self.paras) class RYGate(ParaSingleQubitGate): - def __init__(self, pos: int, paras): - super().__init__("RY", pos, paras, matrix=rymatrix) + name = "RY" + + def __init__(self, pos: int, paras: float = 0.): + super().__init__(pos, paras) + + @property + def matrix(self): + return ry_mat(self.paras) class RZGate(ParaSingleQubitGate): - def __init__(self, pos: int, paras): - super().__init__("RZ", pos, paras, matrix=rzmatrix) + name = "RZ" + + def __init__(self, pos: int, paras: float = 0.): + super().__init__(pos, paras) + + @property + def matrix(self): + return rz_mat(self.paras) class RXXGate(ParaMultiQubitGate): - def __init__(self, q1: int, q2: int, theta): - super().__init__("RXX", [q1, q2], theta, matrix=rxxmatrix(theta)) + name = "RXX" + + def __init__(self, q1: int, q2: int, theta: float = 0.): + super().__init__([q1, q2], paras=theta) + + @property + def matrix(self): + return rxxmatrix(self.paras) def get_targ_matrix(self, reverse_order=False): return self.matrix class RYYGate(ParaMultiQubitGate): - def __init__(self, q1: int, q2: int, theta): - super().__init__("RYY", [q1, q2], theta, matrix=ryymatrix(theta)) + name = "RYY" + + def __init__(self, q1: int, q2: int, theta: float = 0.): + super().__init__([q1, q2], paras=theta) + + @property + def matrix(self): + return ryymatrix(self.paras) def get_targ_matrix(self, reverse_order=False): return self.matrix class RZZGate(ParaMultiQubitGate): - def __init__(self, q1: int, q2: int, theta): - super().__init__("RZZ", [q1, q2], theta, matrix=rzzmatrix(theta)) + name = "RZZ" + + def __init__(self, q1: int, q2: int, theta: float = 0.): + super().__init__([q1, q2], paras=theta) + + @property + def matrix(self): + return rzzmatrix(self.paras) def get_targ_matrix(self, reverse_order=False): return self.matrix diff --git a/src/quafu/elements/element_gates/sqrt.py b/src/quafu/elements/element_gates/sqrt.py index fc81563..5d18adb 100644 --- a/src/quafu/elements/element_gates/sqrt.py +++ b/src/quafu/elements/element_gates/sqrt.py @@ -3,61 +3,75 @@ class SGate(FixedSingleQubitGate): + name = "S" + matrix = np.array([[1., 0.], + [0., 1.j]], dtype=complex) + def __init__(self, pos: int): - super().__init__("S", pos, matrix=np.array([[1., 0.], - [0., 1.j]], dtype=complex)) + super().__init__(pos) class SdgGate(FixedSingleQubitGate): - def __init__(sell, pos: int): - super().__init__("Sdg", pos, matrix=np.array([[1., 0.], - [0., -1.j]], dtype=complex)) + name = "Sdg" + matrix = SGate.matrix.conj().T + + def __init__(self, pos: int): + super().__init__(pos) class TGate(FixedSingleQubitGate): + name = "T" + matrix = np.array([[1., 0.], + [0., np.exp(1.j * np.pi / 4)]], dtype=complex) + def __init__(self, pos: int): - super().__init__("T", pos, matrix=np.array([[1., 0.], - [0., np.exp(1.j * np.pi / 4)]], dtype=complex)) + super().__init__(pos) class TdgGate(FixedSingleQubitGate): + name = "Tdg" + matrix = TGate.matrix.conj().T + def __init__(self, pos: int): - super().__init__("Tdg", pos, matrix=np.array([[1., 0.], - [0, np.exp(-1.j * np.pi / 4)]], dtype=complex)) + super().__init__(pos) class SXGate(FixedSingleQubitGate): + name = "SX" + matrix = np.array([[0.5 + 0.5j, 0.5 - 0.5j], + [0.5 - 0.5j, 0.5 + 0.5j]], dtype=complex) + def __init__(self, pos: int): - super().__init__("SX", pos, matrix=np.zeros((2, 2), dtype=complex)) - self.matrix = np.array([[0.5 + 0.5j, 0.5 - 0.5j], - [0.5 - 0.5j, 0.5 + 0.5j]]) - self.symbol = "√X" + super().__init__(pos) class SXdgGate(FixedSingleQubitGate): + name = "SXdg" + matrix = SXGate.matrix.conj().T + def __init__(self, pos: int): - super().__init__("SXdg", pos, matrix=np.zeros((2, 2), dtype=complex)) - matrix = np.array([[0.5 - 0.5j, 0.5 + 0.5j], - [0.5 + 0.5j, 0.5 - 0.5j]]) - self.matrix = matrix - self.symbol = "√X†" + super().__init__(pos) + self.symbol = "√X" class SYGate(FixedSingleQubitGate): + name = "SY" + matrix = np.array([[0.5 + 0.5j, -0.5 - 0.5j], + [0.5 + 0.5j, 0.5 + 0.5j]], dtype=complex) + def __init__(self, pos: int): - super().__init__("SY", pos, matrix=np.zeros((2, 2), dtype=complex)) - self.matrix = np.array([[0.5 + 0.5j, -0.5 - 0.5j], - [0.5 + 0.5j, 0.5 + 0.5j]]) + super().__init__(pos) self.symbol = "√Y" - def to_qasm(self): - # TODO: this is not correct - return "ry(pi/2) q[%d]" % self.pos - class SYdgGate(FixedSingleQubitGate): + name = "SYdg" + matrix = SYGate.matrix.conj().T + def __init__(self, pos: int): - super().__init__("SY", pos, matrix=np.zeros((2, 2), dtype=complex)) - self.matrix = np.array([[0.5 - 0.5j, -0.5 + 0.5j], - [0.5 - 0.5j, 0.5 - 0.5j]]) + super().__init__(pos) self.symbol = "√Y†" + + def to_qasm(self): + # TODO: this seems incorrect + return "ry(pi/2) q[%d]" % self.pos diff --git a/src/quafu/elements/element_gates/swap.py b/src/quafu/elements/element_gates/swap.py index 5086621..87dffd2 100644 --- a/src/quafu/elements/element_gates/swap.py +++ b/src/quafu/elements/element_gates/swap.py @@ -1,18 +1,24 @@ from ..quantum_element import FixedMultiQubitGate -from ._matrices import ISwapMatrix, SwapMatrix +from .matrices import ISwapMatrix, SwapMatrix -class iSwapGate(FixedMultiQubitGate): +class ISwapGate(FixedMultiQubitGate): + name = "iSWAP" + matrix = ISwapMatrix + def __init__(self, q1: int, q2: int): - super().__init__("iSWAP", [q1, q2], matrix=ISwapMatrix) + super().__init__([q1, q2]) def get_targ_matrix(self, reverse_order=False): return self.matrix class SwapGate(FixedMultiQubitGate): + name = "SWAP" + matrix = SwapMatrix + def __init__(self, q1: int, q2: int): - super().__init__("SWAP", [q1, q2], matrix=SwapMatrix) + super().__init__([q1, q2]) self.symbol = "x" def get_targ_matrix(self, reverse_order=False): diff --git a/src/quafu/elements/quantum_element.py b/src/quafu/elements/quantum_element.py deleted file mode 100644 index 1b1f4e1..0000000 --- a/src/quafu/elements/quantum_element.py +++ /dev/null @@ -1,427 +0,0 @@ -# (C) Copyright 2023 Beijing Academy of Quantum Information Sciences -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -from abc import ABC -from typing import Union, Callable, List, Iterable - -import numpy as np - -""" -Base classes for ALL kinds of possible instructions on superconducting -quantum circuits. -""" - -ParaType = dict[str: float | int] -PosType = Union[int, List[int]] - - -def reorder_matrix(matrix: np.ndarray, pos: List): - """Reorder the input sorted matrix to the pos order """ - qnum = len(pos) - dim = 2 ** qnum - inds = np.argsort(pos) - inds = np.concatenate([inds, inds + qnum]) - tensorm = matrix.reshape([2] * 2 * qnum) - return np.transpose(tensorm, inds).reshape([dim, dim]) - - -class Instruction(ABC): - name = None # type: str - # """ - # Metaclass for primitive instructions in DIRECTED ACYCLIC quantum circuits - # or quantum-classical circuits. - # - # Member variables: - # - # - sd_name: standard name without args or extra annotations. Used for communications - # and identifications within pyquafu program, for example, to translate a qu_gate into qasm. - # Ideally every known primitive during computation should have such a name, and should be - # chosen as the most commonly accepted convention. NOT allowed to be changed by users once - # the class is instantiated. - # - # - pos: positions of relevant quantum or classical bits, legs of DAG. - # - # - dorder: depth order, or topological order of DAG - # - # - symbol: label that can be freely customized by users. If sd_name is not None, name is the - # same as sd_name by default. Otherwise, a symbol has to be specified while sd_name remains - # as None to indicate that this is a use-defined class. - # """ - # - # _ins_id = None # type: str - # - # def __init__(self, pos: PosType, label: str = None, paras: ParaType = None): - # # if pos is not iterable, make it be - # self.pos = [pos] if isinstance(pos, int) else pos - # if label: - # self.label = label - # else: - # if self._ins_id is None: - # raise ValueError('For user-defined instruction, label has to be specified.') - # self.label = self._ins_id - # if paras: - # self.label += '(' + ', '.join(['%.3f' % _ for _ in paras.values()]) + ')' - # self.paras = paras - # - # @classmethod - # def get_ins_id(cls): - # return cls._ins_id - # - # @abstractmethod - # def openqasm2(self) -> str: - # pass - - # @_ins_id.setter - # def sd_name(self, name: str): - # if self.sd_name is None: - # self.sd_name = name - # else: - # import warnings - # warnings.warn(message='Invalid assignment, names of standard ' - # 'instructions are not alterable.') - - # def to_dag_node(self): - # name = self.get_ins_id() - # label = self.__repr__() - # - # pos = self.pos - # paras = self.paras - # paras = {} if paras is None else paras - # duration = paras.get('duration', None) - # unit = paras.get('unit', None) - # channel = paras.get('channel', None) - # time_func = paras.get('time_func', None) - # - # return InstructionNode(name, pos, paras, duration, unit, channel, time_func, label) - - -class Barrier(Instruction): - name = "barrier" - - def __init__(self, pos): - self.__pos = pos - self.symbol = "||" - - @property - def pos(self): - return self.__pos - - @pos.setter - def pos(self, pos): - self.__pos = pos - - def __repr__(self): - return f"{self.__class__.__name__}" - - def to_qasm(self): - return "barrier " + ",".join(["q[%d]" % p for p in range(min(self.pos), max(self.pos) + 1)]) - - -class Delay(Instruction): - name = "delay" - - def __init__(self, pos: int, duration: int, unit="ns"): - if isinstance(duration, int): - self.duration = duration - else: - raise TypeError("duration must be int") - self.unit = unit - self.pos = pos - self.symbol = "Delay(%d%s)" % (duration, unit) - - def __repr__(self): - return f"{self.__class__.__name__}" - - def to_qasm(self): - return "delay(%d%s) q[%d]" % (self.duration, self.unit, self.pos) - - -class XYResonance(Instruction): - name = "XY" - - def __init__(self, qs: int, qe: int, duration: int, unit="ns"): - if isinstance(duration, int): - self.duration = duration - else: - raise TypeError("duration must be int") - self.unit = unit - self.pos = list(range(qs, qe + 1)) - self.symbol = "XY(%d%s)" % (duration, unit) - - def to_qasm(self): - return "xy(%d%s) " % (self.duration, self.unit) + ",".join( - ["q[%d]" % p for p in range(min(self.pos), max(self.pos) + 1)]) - - -class Measure(Instruction): - name = "measure" - - def __init__(self, bitmap: dict): - self.qbits = bitmap.keys() - self.cbits = bitmap.values() - - -class QuantumGate(Instruction, ABC): - name = 'gate' - - def __init__(self, - pos: PosType, - paras: Union[float, List[float]] = None, - matrix=None): - self.pos = pos - self.paras = paras - self.matrix = matrix - - if paras: - if isinstance(paras, Iterable): - self.symbol = "%s(" % self.name + ",".join(["%.3f" % para for para in self.paras]) + ")" - else: - self.symbol = "%s(%.3f)" % (self.name, paras) - else: - self.symbol = "%s" % self.name - - @property - def pos(self): - return self.__pos - - @pos.setter - def pos(self, _pos): - self.__pos = _pos - - @property - def paras(self): - return self.__paras - - @paras.setter - def paras(self, _paras): - self.__paras = _paras - - @property - def matrix(self): - return self._matrix - - @matrix.setter - def matrix(self, matrix): - self._matrix = matrix - - def __str__(self): - properties_names = ['pos', 'paras', 'matrix'] - properties_values = [getattr(self, x) for x in properties_names] - return "%s:\n%s" % (self.__class__.__name__, '\n'.join( - [f"{x} = {repr(properties_values[i])}" for i, x in enumerate(properties_names)])) - - def __repr__(self): - return f"{self.__class__.__name__}" - - def to_qasm(self): - qstr = "%s" % self.name.lower() - - if self.paras: - if isinstance(self.paras, Iterable): - qstr += "(" + ",".join(["%s" % para for para in self.paras]) + ")" - else: - qstr += "(%s)" % self.paras - qstr += " " - if isinstance(self.pos, Iterable): - qstr += ",".join(["q[%d]" % p for p in self.pos]) - else: - qstr += "q[%d]" % self.pos - - return qstr - - -class SingleQubitGate(QuantumGate): - name = 'su(2)' - - def __init__(self, pos: int, paras, matrix): - super().__init__(pos, paras=paras, matrix=matrix) - - @property - def matrix(self): - return self._matrix - - @matrix.setter - def matrix(self, matrix): - if isinstance(matrix, (np.ndarray, List)): - if np.shape(matrix) == (2, 2): - self._matrix = np.asarray(matrix, dtype=complex) - else: - raise ValueError(f'`{self.__class__.__name__}.matrix.shape` must be (2, 2)') - elif isinstance(matrix, type(None)): - self._matrix = matrix - else: - raise TypeError("Unsupported `matrix` type") - - def get_targ_matrix(self, reverse_order=False): - return self.matrix - - -class FixedSingleQubitGate(SingleQubitGate): - def __init__(self, pos, matrix): - super().__init__(pos, paras=None, matrix=matrix) - - -class ParaSingleQubitGate(SingleQubitGate): - def __init__(self, pos, paras, matrix): - super().__init__(pos, paras=paras, matrix=matrix) - - @property - def matrix(self): - return self._matrix - - @matrix.setter - def matrix(self, matrix): - if isinstance(matrix, Callable): - self._matrix = matrix(self.paras) - elif isinstance(matrix, (np.ndarray, List)): - if np.shape(matrix) == (2, 2): - self._matrix = np.asarray(matrix, dtype=complex) - else: - raise ValueError(f'`{self.__class__.__name__}.matrix.shape` must be (2, 2)') - elif isinstance(matrix, type(None)): - self._matrix = matrix - else: - raise TypeError("Unsupported `matrix` type") - - -class MultiQubitGate(QuantumGate): - name = 'su(n)' - - def __init__(self, pos: List[int], paras, matrix): - super().__init__(pos, paras=paras, matrix=matrix) - self._targ_matrix = matrix - - @property - def matrix(self): - return self._matrix - - @matrix.setter - def matrix(self, matrix): - if isinstance(matrix, np.ndarray): - self._matrix = matrix - elif isinstance(matrix, List): - self._matrix = np.array(matrix, dtype=complex) - else: - raise TypeError("Unsupported `matrix` type") - - self._matrix = reorder_matrix(self._matrix, self.pos) - - def get_targ_matrix(self, reverse_order=False): - targ_matrix = self._targ_matrix - if reverse_order and (len(self.pos) > 1): - qnum = len(self.pos) - order = np.array(range(len(self.pos))[::-1]) - order = np.concatenate([order, order + qnum]) - dim = 2 ** qnum - tensorm = targ_matrix.reshape([2] * 2 * qnum) - targ_matrix = np.transpose(tensorm, order).reshape([dim, dim]) - - return targ_matrix - - -class FixedMultiQubitGate(MultiQubitGate): - def __init__(self, pos: List[int], matrix): - super().__init__(pos, paras=None, matrix=matrix) - - -class ParaMultiQubitGate(MultiQubitGate): - def __init__(self, pos, paras, matrix): - super().__init__(pos, paras, matrix=matrix) - - @property - def matrix(self): - return self._matrix - - @matrix.setter - def matrix(self, matrix): - if isinstance(matrix, Callable): - self._matrix = matrix(self.paras) - self._matrix = reorder_matrix(self._matrix, self.pos) - elif isinstance(matrix, (np.ndarray, List)): - self._matrix = matrix - self._matrix = reorder_matrix(self._matrix, self.pos) - else: - raise TypeError("Unsupported `matrix` type") - - -class ControlledGate(MultiQubitGate): - """ Controlled gate class, where the matrix act non-trivaly on target qubits""" - - def __init__(self, targe_name, ctrls: List[int], targs: List[int], paras, matrix): - self.ctrls = ctrls - self.targs = targs - self.targ_name = targe_name - super().__init__(ctrls + targs, paras, matrix) - self._targ_matrix = matrix - - if paras: - if isinstance(paras, Iterable): - self.symbol = "%s(" % self.targ_name + ",".join(["%.3f" % para for para in self.paras]) + ")" - else: - self.symbol = "%s(%.3f)" % (self.targ_name, paras) - else: - self.symbol = "%s" % self.targ_name - - @property - def matrix(self): - return self._matrix - - @matrix.setter - def matrix(self, matrix: Union[np.ndarray, Callable]): - targ_dim = 2 ** (len(self.targs)) - qnum = len(self.pos) - dim = 2 ** (qnum) - if isinstance(matrix, Callable): - matrix = matrix(self.paras) - - if matrix.shape[0] != targ_dim: - raise ValueError("Dimension dismatch") - else: - self._matrix = np.zeros((dim, dim), dtype=complex) - control_dim = 2 ** len(self.pos) - targ_dim - for i in range(control_dim): - self._matrix[i, i] = 1. - - self._matrix[control_dim:, control_dim:] = matrix - self._matrix = reorder_matrix(self._matrix, self.pos) - # self._targ_matrix = reorder_matrix(matrix, self.targs) - - def get_targ_matrix(self, reverse_order=False): - targ_matrix = self._targ_matrix - if reverse_order and (len(self.targs) > 1): - qnum = len(self.targs) - order = np.array(range(len(self.targs))[::-1]) - order = np.concatenate([order, order + qnum]) - dim = 2 ** qnum - tensorm = targ_matrix.reshape([2] * 2 * qnum) - targ_matrix = np.transpose(tensorm, order).reshape([dim, dim]) - - return targ_matrix - - -class ControlledU(ControlledGate): - """ Controlled gate class, where the matrix act non-trivaly on target qubits""" - - name = 'cu' - - def __init__(self, ctrls: List[int], U: Union[SingleQubitGate, MultiQubitGate]): - self.targ_gate = U - targs = U.pos - if isinstance(targs, int): - targs = [targs] - - super().__init__(U.name, ctrls, targs, U.paras, matrix=self.targ_gate.get_targ_matrix()) - - def get_targ_matrix(self, reverse_order=False): - return self.targ_gate.get_targ_matrix(reverse_order) diff --git a/src/quafu/elements/quantum_element/instruction.py b/src/quafu/elements/quantum_element/instruction.py new file mode 100644 index 0000000..0d30b6a --- /dev/null +++ b/src/quafu/elements/quantum_element/instruction.py @@ -0,0 +1,80 @@ +from abc import ABC, abstractmethod +from typing import Union, List + + +class Instruction(ABC): + @property + @abstractmethod + def name(self) -> str: + raise NotImplementedError('name is not implemented for %s' % self.__class__.__name__ + + ', this should never happen.') + # """ + # Metaclass for primitive instructions in DIRECTED ACYCLIC quantum circuits + # or quantum-classical circuits. + # + # Member variables: + # + # - sd_name: standard name without args or extra annotations. Used for communications + # and identifications within pyquafu program, for example, to translate a qu_gate into qasm. + # Ideally every known primitive during computation should have such a name, and should be + # chosen as the most commonly accepted convention. NOT allowed to be changed by users once + # the class is instantiated. + # + # - pos: positions of relevant quantum or classical bits, legs of DAG. + # + # - dorder: depth order, or topological order of DAG + # + # - symbol: label that can be freely customized by users. If sd_name is not None, name is the + # same as sd_name by default. Otherwise, a symbol has to be specified while sd_name remains + # as None to indicate that this is a use-defined class. + # """ + # + # _ins_id = None # type: str + # + # def __init__(self, pos: PosType, label: str = None, paras: ParaType = None): + # # if pos is not iterable, make it be + # self.pos = [pos] if isinstance(pos, int) else pos + # if label: + # self.label = label + # else: + # if self._ins_id is None: + # raise ValueError('For user-defined instruction, label has to be specified.') + # self.label = self._ins_id + # if paras: + # self.label += '(' + ', '.join(['%.3f' % _ for _ in paras.values()]) + ')' + # self.paras = paras + # + # @classmethod + # def get_ins_id(cls): + # return cls._ins_id + # + # @abstractmethod + # def openqasm2(self) -> str: + # pass + + # @_ins_id.setter + # def sd_name(self, name: str): + # if self.sd_name is None: + # self.sd_name = name + # else: + # import warnings + # warnings.warn(message='Invalid assignment, names of standard ' + # 'instructions are not alterable.') + + # def to_dag_node(self): + # name = self.get_ins_id() + # label = self.__repr__() + # + # pos = self.pos + # paras = self.paras + # paras = {} if paras is None else paras + # duration = paras.get('duration', None) + # unit = paras.get('unit', None) + # channel = paras.get('channel', None) + # time_func = paras.get('time_func', None) + # + # return InstructionNode(name, pos, paras, duration, unit, channel, time_func, label) + + +PosType = Union[int, List[int]] +ParaType = dict[str, Union[float, int]] diff --git a/src/quafu/elements/quantum_element/quantum_element.py b/src/quafu/elements/quantum_element/quantum_element.py new file mode 100644 index 0000000..165c8cb --- /dev/null +++ b/src/quafu/elements/quantum_element/quantum_element.py @@ -0,0 +1,86 @@ +# (C) Copyright 2023 Beijing Academy of Quantum Information Sciences +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from quafu.elements.quantum_element.instruction import Instruction + +""" +Base classes for ALL kinds of possible instructions on superconducting +quantum circuits. +""" + + +class Barrier(Instruction): + name = "barrier" + + def __init__(self, pos): + self.__pos = pos + self.symbol = "||" + + @property + def pos(self): + return self.__pos + + @pos.setter + def pos(self, pos): + self.__pos = pos + + def __repr__(self): + return f"{self.__class__.__name__}" + + def to_qasm(self): + return "barrier " + ",".join(["q[%d]" % p for p in range(min(self.pos), max(self.pos) + 1)]) + + +class Delay(Instruction): + name = "delay" + + def __init__(self, pos: int, duration: int, unit="ns"): + if isinstance(duration, int): + self.duration = duration + else: + raise TypeError("duration must be int") + self.unit = unit + self.pos = pos + self.symbol = "Delay(%d%s)" % (duration, unit) + + def __repr__(self): + return f"{self.__class__.__name__}" + + def to_qasm(self): + return "delay(%d%s) q[%d]" % (self.duration, self.unit, self.pos) + + +class XYResonance(Instruction): + name = "XY" + + def __init__(self, qs: int, qe: int, duration: int, unit="ns"): + if isinstance(duration, int): + self.duration = duration + else: + raise TypeError("duration must be int") + self.unit = unit + self.pos = list(range(qs, qe + 1)) + self.symbol = "XY(%d%s)" % (duration, unit) + + def to_qasm(self): + return "xy(%d%s) " % (self.duration, self.unit) + ",".join( + ["q[%d]" % p for p in range(min(self.pos), max(self.pos) + 1)]) + + +class Measure(Instruction): + name = "measure" + + def __init__(self, bitmap: dict): + self.qbits = bitmap.keys() + self.cbits = bitmap.values() diff --git a/src/quafu/elements/quantum_element/quantum_gate.py b/src/quafu/elements/quantum_element/quantum_gate.py new file mode 100644 index 0000000..480a2aa --- /dev/null +++ b/src/quafu/elements/quantum_element/quantum_gate.py @@ -0,0 +1,270 @@ +from abc import ABC, abstractmethod +from typing import Callable, List, Union, Iterable + +import numpy as np + +from quafu.elements.quantum_element.instruction import Instruction, PosType + + +def reorder_matrix(matrix: np.ndarray, pos: List): + """Reorder the input sorted matrix to the pos order """ + qnum = len(pos) + dim = 2 ** qnum + inds = np.argsort(pos) + inds = np.concatenate([inds, inds + qnum]) + tensorm = matrix.reshape([2] * 2 * qnum) + return np.transpose(tensorm, inds).reshape([dim, dim]) + + +class QuantumGate(Instruction): + def __init__(self, + pos: PosType, + paras: Union[float, List[float]] = None, + ): + self.pos = pos + self.paras = paras + + if paras: + if isinstance(paras, Iterable): + self.symbol = "%s(" % self.name + ",".join(["%.3f" % para for para in self.paras]) + ")" + else: + self.symbol = "%s(%.3f)" % (self.name, paras) + else: + self.symbol = "%s" % self.name + + @property + @abstractmethod + def matrix(self): + raise NotImplementedError("Matrix is not implemented for %s" % self.__class__.__name__ + + ", this should never happen.") + + # @property + # def pos(self): + # return self.__pos + # + # @pos.setter + # def pos(self, _pos): + # self.__pos = _pos + # + # @property + # def paras(self): + # return self.__paras + # + # @paras.setter + # def paras(self, _paras): + # self.__paras = _paras + + def __str__(self): + properties_names = ['pos', 'paras', 'matrix'] + properties_values = [getattr(self, x) for x in properties_names] + return "%s:\n%s" % (self.__class__.__name__, '\n'.join( + [f"{x} = {repr(properties_values[i])}" for i, x in enumerate(properties_names)])) + + def __repr__(self): + return f"{self.__class__.__name__}" + + def to_qasm(self): + qstr = "%s" % self.name.lower() + + if self.paras: + if isinstance(self.paras, Iterable): + qstr += "(" + ",".join(["%s" % para for para in self.paras]) + ")" + else: + qstr += "(%s)" % self.paras + qstr += " " + if isinstance(self.pos, Iterable): + qstr += ",".join(["q[%d]" % p for p in self.pos]) + else: + qstr += "q[%d]" % self.pos + + return qstr + + +class SingleQubitGate(QuantumGate, ABC): + def __init__(self, pos: int, paras: float = None): + super().__init__(pos, paras=paras) + + # @property + # def matrix(self): + # return self._matrix + # + # @matrix.setter + # def matrix(self, matrix): + # if isinstance(matrix, (np.ndarray, List)): + # if np.shape(matrix) == (2, 2): + # self._matrix = np.asarray(matrix, dtype=complex) + # else: + # raise ValueError(f'`{self.__class__.__name__}.matrix.shape` must be (2, 2)') + # elif isinstance(matrix, type(None)): + # self._matrix = matrix + # else: + # raise TypeError("Unsupported `matrix` type") + + def get_targ_matrix(self, reverse_order=False): + return self.matrix + + +class MultiQubitGate(QuantumGate, ABC): + def __init__(self, pos: List[int], paras: float = None): + super().__init__(pos, paras) + self._targ_matrix = self.matrix + + # @property + # def matrix(self): + # return self._matrix + # + # @matrix.setter + # def matrix(self, matrix): + # if isinstance(matrix, np.ndarray): + # self._matrix = matrix + # elif isinstance(matrix, List): + # self._matrix = np.array(matrix, dtype=complex) + # else: + # raise TypeError("Unsupported `matrix` type") + # + # self._matrix = reorder_matrix(self._matrix, self.pos) + + def get_targ_matrix(self, reverse_order=False): + targ_matrix = self._targ_matrix + if reverse_order and (len(self.pos) > 1): + qnum = len(self.pos) + order = np.array(range(len(self.pos))[::-1]) + order = np.concatenate([order, order + qnum]) + dim = 2 ** qnum + tensorm = targ_matrix.reshape([2] * 2 * qnum) + targ_matrix = np.transpose(tensorm, order).reshape([dim, dim]) + + return targ_matrix + + +class ParaSingleQubitGate(SingleQubitGate, ABC): + def __init__(self, pos, paras: float): + if paras is None: + raise ValueError("`paras` can not be None for ParaSingleQubitGate") + elif not isinstance(paras, float): + raise TypeError("`paras` must be float for ParaSingleQubitGate") + super().__init__(pos, paras=paras) + + # @property + # def matrix(self): + # return self._matrix + # + # @matrix.setter + # def matrix(self, matrix): + # if isinstance(matrix, Callable): + # self._matrix = matrix(self.paras) + # elif isinstance(matrix, (np.ndarray, List)): + # if np.shape(matrix) == (2, 2): + # self._matrix = np.asarray(matrix, dtype=complex) + # else: + # raise ValueError(f'`{self.__class__.__name__}.matrix.shape` must be (2, 2)') + # elif isinstance(matrix, type(None)): + # self._matrix = matrix + # else: + # raise TypeError("Unsupported `matrix` type") + + +class FixedSingleQubitGate(SingleQubitGate, ABC): + def __init__(self, pos): + super().__init__(pos=pos, paras=None) + + +class FixedMultiQubitGate(MultiQubitGate, ABC): + def __init__(self, pos: List[int]): + super().__init__(pos=pos, paras=None) + + +class ControlledGate(MultiQubitGate, ABC): + """ Controlled gate class, where the matrix act non-trivaly on target qubits""" + + def __init__(self, targe_name, ctrls: List[int], targs: List[int], paras, matrix): + self.ctrls = ctrls + self.targs = targs + self.targ_name = targe_name + super().__init__(ctrls + targs, paras) + self._targ_matrix = matrix + + if paras: + if isinstance(paras, Iterable): + self.symbol = "%s(" % self.targ_name + ",".join(["%.3f" % para for para in self.paras]) + ")" + else: + self.symbol = "%s(%.3f)" % (self.targ_name, paras) + else: + self.symbol = "%s" % self.targ_name + + # TODO + + @property + def matrix(self): + return self._matrix + + @matrix.setter + def matrix(self, matrix: Union[np.ndarray, Callable]): + targ_dim = 2 ** (len(self.targs)) + qnum = len(self.pos) + dim = 2 ** (qnum) + if isinstance(matrix, Callable): + matrix = matrix(self.paras) + + if matrix.shape[0] != targ_dim: + raise ValueError("Dimension dismatch") + else: + self._matrix = np.zeros((dim, dim), dtype=complex) + control_dim = 2 ** len(self.pos) - targ_dim + for i in range(control_dim): + self._matrix[i, i] = 1. + + self._matrix[control_dim:, control_dim:] = matrix + self._matrix = reorder_matrix(self._matrix, self.pos) + # self._targ_matrix = reorder_matrix(matrix, self.targs) + + def get_targ_matrix(self, reverse_order=False): + targ_matrix = self._targ_matrix + if reverse_order and (len(self.targs) > 1): + qnum = len(self.targs) + order = np.array(range(len(self.targs))[::-1]) + order = np.concatenate([order, order + qnum]) + dim = 2 ** qnum + tensorm = targ_matrix.reshape([2] * 2 * qnum) + targ_matrix = np.transpose(tensorm, order).reshape([dim, dim]) + + return targ_matrix + + +class ParaMultiQubitGate(MultiQubitGate, ABC): + def __init__(self, pos, paras): + if paras is None: + raise ValueError("`paras` can not be None for ParaMultiQubitGate") + super().__init__(pos, paras) + + @property + def matrix(self): + return self._matrix + + @matrix.setter + def matrix(self, matrix): + if isinstance(matrix, Callable): + self._matrix = matrix(self.paras) + self._matrix = reorder_matrix(self._matrix, self.pos) + elif isinstance(matrix, (np.ndarray, List)): + self._matrix = matrix + self._matrix = reorder_matrix(self._matrix, self.pos) + else: + raise TypeError("Unsupported `matrix` type") + + +class ControlledU(ControlledGate): + """ Controlled gate class, where the matrix act non-trivially on target qubits""" + + name = 'cu' + + def __init__(self, ctrls: List[int], U: Union[SingleQubitGate, MultiQubitGate]): + self.targ_gate = U + targs = U.pos + if isinstance(targs, int): + targs = [targs] + + super().__init__(U.name, ctrls, targs, U.paras, matrix=self.targ_gate.get_targ_matrix()) + + def get_targ_matrix(self, reverse_order=False): + return self.targ_gate.get_targ_matrix(reverse_order) From ed2655e68fdd1badf9fb473615bc8c6bb575e2cf Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Tue, 11 Jul 2023 20:43:00 +0800 Subject: [PATCH 41/70] "Add PLY into requirements.txt" --- requirements.txt | 4 +++- src/quafu/qfasm/qfasm_parser.py | 5 ++--- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/requirements.txt b/requirements.txt index 1b12b08..1419459 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,4 +6,6 @@ scipy>=1.8.1 setuptools>=58.0.4 sparse>=0.13.0 scikit-build>=0.16.1 -pybind11>=2.10.3 \ No newline at end of file +pybind11>=2.10.3 +ply~=3.11 +Pillow~=10.0.0 \ No newline at end of file diff --git a/src/quafu/qfasm/qfasm_parser.py b/src/quafu/qfasm/qfasm_parser.py index 0c611c2..b62657c 100644 --- a/src/quafu/qfasm/qfasm_parser.py +++ b/src/quafu/qfasm/qfasm_parser.py @@ -1,12 +1,11 @@ import ply.yacc as yacc -from quafu.elements.element_gates import * -from quafu.elements.quantum_element import * from quafu.dagcircuits.instruction_node import InstructionNode from .qfasmlex import QfasmLexer -# import numpy as np +import numpy as np + class DeclarationNode(object): pass From d1cba7e080562acadfbb6199ea5c81089b3afc8f Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Tue, 11 Jul 2023 20:48:52 +0800 Subject: [PATCH 42/70] "Fix the para-missing problem for rotation gate" Please help to test. --- .../{_matrices.py => matrices/mat_lib.py} | 28 ++++--------------- src/quafu/elements/element_gates/rotation.py | 8 +++--- 2 files changed, 10 insertions(+), 26 deletions(-) rename src/quafu/elements/element_gates/{_matrices.py => matrices/mat_lib.py} (89%) diff --git a/src/quafu/elements/element_gates/_matrices.py b/src/quafu/elements/element_gates/matrices/mat_lib.py similarity index 89% rename from src/quafu/elements/element_gates/_matrices.py rename to src/quafu/elements/element_gates/matrices/mat_lib.py index 568137a..b40ebec 100644 --- a/src/quafu/elements/element_gates/_matrices.py +++ b/src/quafu/elements/element_gates/matrices/mat_lib.py @@ -63,17 +63,17 @@ def u3matrix(_theta=0., _phi=0., _lambda=0.): np.exp((_phi + _lambda) * 1.j) * np.cos(0.5 * _theta)]], dtype=complex) -def rxmatrix(theta): +def rx_mat(theta): return np.array([[np.cos(0.5 * theta), -1.j * np.sin(0.5 * theta)], [-1.j * np.sin(0.5 * theta), np.cos(0.5 * theta)]], dtype=complex) -def rymatrix(theta): +def ry_mat(theta): return np.array([[np.cos(0.5 * theta), - np.sin(0.5 * theta)], [np.sin(0.5 * theta), np.cos(0.5 * theta)]], dtype=complex) -def rzmatrix(theta): +def rz_mat(theta): return np.array([[np.exp(-0.5j * theta), 0.], [0., np.exp(0.5j * theta)]], dtype=complex) @@ -83,7 +83,7 @@ def pmatrix(labda): [0, np.exp(1j * labda)]], dtype=complex) -def rxxmatrix(theta): +def rxx_mat(theta): """Unitary evolution of XX interaction""" return np.array([[np.cos(theta / 2), 0, 0, -1j * np.sin(theta / 2)], [0, np.cos(theta / 2), -1j * np.sin(theta / 2), 0], @@ -92,7 +92,7 @@ def rxxmatrix(theta): ]) -def ryymatrix(theta): +def ryy_mat(theta): """ Unitary evolution of YY interaction""" c = np.cos(theta / 2) s = 1j * np.sin(theta / 2) @@ -103,29 +103,13 @@ def ryymatrix(theta): ]) -def rzzmatrix(theta): +def rzz_mat(theta): return np.array([[np.exp(-1j * theta / 2), 0, 0, 0], [0, np.exp(1j * theta / 2), 0, 0], [0, 0, np.exp(1j * theta / 2), 0], [0, 0, 0, np.exp(-1j * theta / 2)] ]) -# def rx_matrix(phi: float): -# return np.array([[np.cos(phi / 2), -1.j * np.sin(phi / 2)], -# [-1.j * np.sin(phi / 2), np.cos(phi / 2)]]) -# -# -# def ry_matrix(phi: float): -# return np.array([[np.cos(phi / 2), -np.sin(phi / 2)], -# [np.sin(phi / 2), np.cos(phi / 2)]], dtype=complex) -# -# -# def rz_matrix(phi: float): -# rz = np.array([[np.exp(-1.j * phi / 2), 0.], -# [0., np.exp(1.j * phi / 2)]]) -# return rz -# -# # def su2_matrix(gamma: float, beta: float, delta: float): # """ # SU = Rz(beta)Ry(gamma)Rz(delta). diff --git a/src/quafu/elements/element_gates/rotation.py b/src/quafu/elements/element_gates/rotation.py index d3812a6..25e995c 100644 --- a/src/quafu/elements/element_gates/rotation.py +++ b/src/quafu/elements/element_gates/rotation.py @@ -1,5 +1,5 @@ from ..quantum_element import ParaMultiQubitGate, ParaSingleQubitGate -from .matrices import rx_mat, ry_mat, rz_mat, rxxmatrix, ryymatrix, rzzmatrix +from .matrices import rx_mat, ry_mat, rz_mat, rxx_mat, ryy_mat, rzz_mat class RXGate(ParaSingleQubitGate): @@ -43,7 +43,7 @@ def __init__(self, q1: int, q2: int, theta: float = 0.): @property def matrix(self): - return rxxmatrix(self.paras) + return rxx_mat(self.paras) def get_targ_matrix(self, reverse_order=False): return self.matrix @@ -57,7 +57,7 @@ def __init__(self, q1: int, q2: int, theta: float = 0.): @property def matrix(self): - return ryymatrix(self.paras) + return ryy_mat(self.paras) def get_targ_matrix(self, reverse_order=False): return self.matrix @@ -71,7 +71,7 @@ def __init__(self, q1: int, q2: int, theta: float = 0.): @property def matrix(self): - return rzzmatrix(self.paras) + return rzz_mat(self.paras) def get_targ_matrix(self, reverse_order=False): return self.matrix From c69a61dd1b74e011ea6a0de0e24a33140eeb1b75 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 11:39:18 +0800 Subject: [PATCH 43/70] add unitary decomposer --- .../element_gates/matrices/__init__.py | 2 + .../element_gates/matrices/mat_utils.py | 121 ++++++ .../element_gates/unitary/__init__.py | 2 + .../element_gates/unitary/decomposer.py | 348 ++++++++++++++++++ .../elements/quantum_element/__init__.py | 4 + 5 files changed, 477 insertions(+) create mode 100644 src/quafu/elements/element_gates/matrices/__init__.py create mode 100644 src/quafu/elements/element_gates/matrices/mat_utils.py create mode 100644 src/quafu/elements/element_gates/unitary/__init__.py create mode 100644 src/quafu/elements/element_gates/unitary/decomposer.py create mode 100644 src/quafu/elements/quantum_element/__init__.py diff --git a/src/quafu/elements/element_gates/matrices/__init__.py b/src/quafu/elements/element_gates/matrices/__init__.py new file mode 100644 index 0000000..5148bca --- /dev/null +++ b/src/quafu/elements/element_gates/matrices/__init__.py @@ -0,0 +1,2 @@ +from mat_lib import * +from mat_utils import stack_matrices, is_zero, is_hermitian diff --git a/src/quafu/elements/element_gates/matrices/mat_utils.py b/src/quafu/elements/element_gates/matrices/mat_utils.py new file mode 100644 index 0000000..479799c --- /dev/null +++ b/src/quafu/elements/element_gates/matrices/mat_utils.py @@ -0,0 +1,121 @@ +import cmath + +import numpy as np +from numpy import ndarray + +from .mat_lib import IdMatrix + + +def split_matrix(matrix: ndarray): + """ + Evenly split a matrix into 4 sub-matrices. + """ + top, bottom = np.vsplit(matrix, 2) + t_left, t_right = np.hsplit(top, 2) + b_left, b_right = np.hsplit(bottom, 2) + return t_left, t_right, b_left, b_right + + +def stack_matrices(t_left, t_right, b_left, b_right): + """ + Stack 4 sub-matrices into a matrix. + """ + top = np.hstack((t_left, t_right)) + bottom = np.hstack((b_left, b_right)) + mat = np.vstack((top, bottom)) + return mat + + +def multi_kron(op1, op2, ind1, ind2, nspin): + tmp = 1 + for i in range(nspin): + if i == ind1: + tmp = np.kron(tmp, op1) + elif i == ind2: + tmp = np.kron(tmp, op2) + else: + tmp = np.kron(tmp, IdMatrix) + return tmp + + +def general_kron(op, ind, nqubit): + tmp = 1 + for i in range(nqubit): + if i == ind: + tmp = np.kron(tmp, op) + else: + tmp = np.kron(tmp, IdMatrix) + return tmp + + +####################################################### +def is_zero(a): + return not np.any(np.absolute(a) > 1e-8) + + +def is_approx(a, b, thres=1e-6): + # TODO: seems there are some very small elements that cannot be compared correctly + # if not np.allclose(a, b, rtol=thres, atol=thres): + # print(np.sum(a-b)) + return np.allclose(a, b, rtol=thres, atol=thres) + + +def is_unitary(matrix): + mat_dg = np.conjugate(matrix).T + id_mat = np.eye(matrix.shape[0]) + return is_approx(mat_dg @ matrix, id_mat) and is_approx(matrix @ mat_dg, id_mat) + + +def is_hermitian(matrix): + tmp = np.conjuate(matrix).T + return is_approx(tmp, matrix) + + +def is_diagonal(matrix: ndarray): + diag = np.diag(matrix) + diag_mat = np.diag(diag) + return is_approx(matrix, diag_mat) + + +def is_kron_with_id2(matrix): + """ + Check if the matrix is a Kronecker product of a matrix and identity matrix. + """ + nsize = matrix.shape[0] + + a_cond = is_zero(matrix[0:nsize:2, 1:nsize:2]) + b_cond = is_zero(matrix[1:nsize:2, 0:nsize:2]) + c_cond = is_approx(matrix[0, :-1], matrix[1, 1:]) + d_cond = is_approx(matrix[-2, :-1], matrix[-1, 1:]) + + return a_cond and b_cond and c_cond and d_cond + + +####################################################### +def get_global_phase(unitary): + """ Get the global phase of arbitrary unitary, and get the special unitary. + + Args: + unitary (np.array): arbitrary unitary + Returns: + global_phase: the global phase of arbitrary unitary + special_unitary (np.array) + """ + coefficient = np.linalg.det(unitary) ** (-0.5) + global_phase = -cmath.phase(coefficient) + special_unitary = coefficient * unitary + return global_phase, special_unitary + + +def matrix_distance_squared(unitary1, unitary2): + """ Used to compare the distance of two matrices. The global phase is ignored. + + Args: + unitary1 (np.array): A unitary matrix in the form of a numpy ndarray. + unitary2 (np.array): Another unitary matrix. + + Returns: + Float : A single value between 0 and 1 indicating how closely unitary1 and unitary2 match. + A value close to 0 indicates that unitary1 and unitary2 are the same unitary. + """ + return np.abs(1 - np.abs(np.sum(np.multiply(unitary1, np.conj(unitary2)))) / unitary1.shape[0]) diff --git a/src/quafu/elements/element_gates/unitary/__init__.py b/src/quafu/elements/element_gates/unitary/__init__.py new file mode 100644 index 0000000..22d04e9 --- /dev/null +++ b/src/quafu/elements/element_gates/unitary/__init__.py @@ -0,0 +1,2 @@ +from .decomposer import UnitaryDecomposer + diff --git a/src/quafu/elements/element_gates/unitary/decomposer.py b/src/quafu/elements/element_gates/unitary/decomposer.py new file mode 100644 index 0000000..3831d16 --- /dev/null +++ b/src/quafu/elements/element_gates/unitary/decomposer.py @@ -0,0 +1,348 @@ +import cmath +import math + +import numpy as np +import scipy +from numpy import ndarray +# from quafu.circuits.quantum_circuit import QuantumCircuit + +from ..matrices import rz_mat, ry_mat, CXMatrix +from ..matrices import mat_utils as mu + + +class UnitaryDecomposer(object): + def __init__(self, array: ndarray, qubits, verbose: bool = False): + self.array = array + self.qubit_num = len(qubits) + self._check_unitary(array, self.qubit_num) + + self.qubits = qubits + self.verbose = verbose + + self.Mk_table = genMk_table(self.qubit_num) # initialize the general M^k lookup table + self.gates_list = [] + # self.quafuQC = QuantumCircuit(self.qubit_num) + + def __call__(self, *args, **kwargs): + _matrix = self.array + self._decompose_matrix(_matrix, self.qubits) + if self.verbose: + print("Decomposition done.") + + @staticmethod + def _check_unitary(array: ndarray, qubits): + assert len(array.shape) == 2 + assert mu.is_unitary(array) + assert len(array) == 2 ** qubits + + def _decompose_matrix(self, _matrix, qubits): + qubit_num = len(qubits) + self._check_unitary(_matrix, qubit_num) + if qubit_num == 1: + # self.gates_list.append((_matrix, qubits, 'U')) + # ZYZ decomposition for single-qubit gate + gamma, beta, alpha, global_phase = zyz_decomposition(_matrix) + self.gates_list.append((rz_mat(gamma), qubits, 'RZ', gamma)) + self.gates_list.append((ry_mat(beta), qubits, 'RY', beta)) + self.gates_list.append((rz_mat(alpha), qubits, 'RZ', alpha)) + # self.quafuQC.rz(qubits[0], gamma) + # self.quafuQC.ry(qubits[0], beta) + # self.quafuQC.rz(qubits[0], alpha) + return None + + # if num_qubit == 2: + # self.circuit.append((_matrix, qubits)) + # print("Two qubit gate do not need to decompose.") + # zyz_decomp(matrix) + U00, U01, U10, U11 = mu.split_matrix(_matrix) + + # if bottomLeftCorner(n)==0 and topRightCorner(n)==0: + if mu.is_zero(U01) and mu.is_zero(U10): + if mu.is_approx(U00, U11): + if self.verbose: + print('Optimization: Unitaries are equal, ' + 'skip one step in the recursion for unitaries of size') + self._decompose_matrix(U00, qubits[1:]) + else: + if self.verbose: + print("Optimization: q2 is zero, only demultiplexing will be performed.") + V, D, W = demultiplexing(U00, U11) + self._decompose_matrix(W, qubits[1:]) + self.multi_controlled_z(D, qubits[1:], qubits[0]) + self._decompose_matrix(V, qubits[1:]) + # Check if the kronecker product of a bigger matrix and the identity matrix. + # By checking if the first row is equal to the second row one over, and if the last two rows are equal + # Which means the last qubit is not affected by this gate + elif mu.is_kron_with_id2(_matrix): + # print("The last qubits not affect.") + nsize = len(_matrix) + self._decompose_matrix(_matrix[0:nsize:2, 0:nsize:2], qubits[:-1]) + else: + # print("CSD decomposition.") + L0, L1, R0, R1, c, s = fat_csd(_matrix) + V, D, W = demultiplexing(R0, R1) + + self._decompose_matrix(W, qubits[1:]) + self.multi_controlled_z(D, qubits[1:], qubits[0]) + self._decompose_matrix(V, qubits[1:]) + self.multi_controlled_y(s, qubits[1:], qubits[0]) + + V, D, W = demultiplexing(L0, L1) + self._decompose_matrix(W, qubits[1:]) + self.multi_controlled_z(D, qubits[1:], qubits[0]) + self._decompose_matrix(V, qubits[1:]) + + def multi_controlled_z(self, D, qubits, target_qubit): + print(D.shape[0]) + assert len(qubits) == int(math.log(D.shape[0], 2)) + num_qubit = len(qubits) + # print("The size of D matrix {}".format(len(qubits))) + # print(qubits) + + # alphas = -2*1j*np.log(np.diag(D)) + alphas = 2 * 1j * np.log(np.diag(D)) + Mk = self.Mk_table[num_qubit - 1] + thetas = np.linalg.solve(Mk, alphas) + # print(thetas) + assert len(thetas) == 2 ** num_qubit + + index = get_multi_control_index(num_qubit) + assert len(index) == len(thetas) + + for i in range(len(index)): + control_qubit = qubits[index[i]] + self.gates_list.append((rz_mat(thetas[i]), [target_qubit], 'RZ', thetas[i])) + self.gates_list.append((CXMatrix, [control_qubit, target_qubit], 'CX')) + + # self.quafuQC.rz(target_qubit, thetas[i]) + # self.quafuQC.cnot(control_qubit, target_qubit) + + def multi_controlled_y(self, ss, qubits, target_qubit): + assert len(qubits) == int(math.log(ss.shape[0], 2)) + num_qubit = len(qubits) + + alphas = -2 * np.arcsin(np.diag(ss)) + Mk = self.Mk_table[num_qubit - 1] + thetas = np.linalg.solve(Mk, alphas) + # print(thetas) + assert len(thetas) == 2 ** num_qubit + + index = get_multi_control_index(num_qubit) + assert len(index) == len(thetas) + + for i in range(len(index)): + control_qubit = qubits[index[i]] + self.gates_list.append((ry_mat(thetas[i]), [target_qubit], 'RY', thetas[i])) + self.gates_list.append((CXMatrix, [control_qubit, target_qubit], 'CX')) + + # self.quafuQC.ry(target_qubit, thetas[i]) + # self.quafuQC.cnot(control_qubit, target_qubit) + + +def zyz_decomposition(unitary): + """ ZYZ decomposition of arbitrary single-qubit gate (unitary). + SU = Rz(gamma) * Ry(beta) * Rz(alpha) + + Args: + unitary (np.array): arbitrary unitary + Returns: + global_phase: the global phase of arbitrary unitary + special_unitary (np.array) + """ + if unitary.shape[0] == 2: + global_phase, special_unitary = mu.get_global_phase(unitary) + beta = 2 * math.atan2(abs(special_unitary[1, 0]), abs(special_unitary[0, 0])) + t1 = cmath.phase(special_unitary[1, 1]) + t2 = cmath.phase(special_unitary[1, 0]) + alpha = t1 + t2 + gamma = t1 - t2 + else: + raise Exception("ZYZ decomposition only applies to single-qubit gate.") + return gamma, beta, alpha, global_phase + + +# # # # # # # Cosine-Sine Decomposition # # # # # # # # # # # # +def _thin_csd(q1, q2): + p = q1.shape[0] + print("the size of q1/q2: {}".format(p)) + + u1, c, v1 = np.linalg.svd(q1) + v1d = np.conjugate(v1).T + c = np.flip(c) + + cm = np.zeros((p, p), dtype=complex) + np.fill_diagonal(cm, c) + + u1 = np.fliplr(u1) + v1d = np.fliplr(v1d) + + q2 = q2 @ v1d + + # find the biggest index of c[k] <= 1/np.sqrt(2) + k = 0 + for i in range(1, p): + if c[i] <= 1 / np.sqrt(2): + k = i + + k = k + 1 + print("the k size: {}".format(k)) + + u2, _ = np.linalg.qr(q2[:, 0:k], mode='complete') + # u2, _= np.linalg.qr(q2, mode='complete') + print("the size of u2: {}".format(u2.shape)) + # print("the u2 matrix: {}".format(u2)) + s = np.conjugate(u2).T @ q2 + print("the size of s: {}".format(s.shape)) + # print("the s matrix: {}".format(np.real(s))) + + if k < p: + r2 = s[k:p, k:p] + print("the size of rs: {}".format(r2.shape)) + ut, ss, vt = np.linalg.svd(r2) + vtd = np.conjugate(vt).T + s[k:p, k:p] = np.diag(ss) + cm[:, k:p] = cm[:, k:p] @ vtd + u2[:, k:p] = u2[:, k:p] @ ut + v1d[:, k:p] = v1d[:, k:p] @ vtd + + w = cm[k:p, k:p] + z, r = np.linalg.qr(w, mode='complete') + cm[k:p, k:p] = r + u1[:, k:p] = u1[:, k:p] @ z + + for i in range(p): + if np.real(cm[i, i]) < 0: + cm[i, i] = -cm[i, i] + u1[:, i] = -u1[:, i] + if np.real(s[i, i]) < 0: + s[i, i] = -s[i, i] + u2[:, i] = -u2[:, i] + + return u1, u2, v1d, cm, s + + +def fat_csd(matrix): + """ + U = [U00, U01] = [u1 ][c s][v1 ] + [U10, U11] = [ u2][-s c][ v2] + """ + # print(matrix) + U00, U01, U10, U11 = mu.split_matrix(matrix) + + L0, L1, R0, cc, ss = _thin_csd(U00, U10) + R0 = np.conjugate(R0).T + ss = -ss + + # get the v2 + R1 = np.zeros_like(R0) + p = R1.shape[0] + for j in range(p): + if np.abs(ss[j, j]) > np.abs(cc[j, j]): + L0d = np.conjugate(L0).T + tmp = L0d @ U01 + R1[j, :] = tmp[j, :] / ss[j, j] + else: + L1d = np.conjugate(L1).T + tmp = L1d @ U11 + R1[j, :] = tmp[j, :] / cc[j, j] + + assert mu.is_approx(L0 @ cc @ R0, U00) + assert mu.is_approx(-L1 @ ss @ R0, U10) + assert mu.is_approx(L0 @ ss @ R1, U01) + assert mu.is_approx(L1 @ cc @ R1, U11) + + zeros_m = np.zeros_like(L0) + L = mu.stack_matrices(L0, zeros_m, zeros_m, L1) + D = mu.stack_matrices(cc, ss, -ss, cc) + R = mu.stack_matrices(R0, zeros_m, zeros_m, R1) + assert mu.is_approx(matrix, L @ D @ R) + + return L0, L1, R0, R1, cc, ss # L0, L1 is unitary + + +# # # # # # # # # # # # # # # # # # # # # # # # # # +def demultiplexing(u1, u2): + """ + U = [U1 0] = [V 0][D 0][W 0] + [0 U2] = [0 V][0 D*][0 W] + """ + assert mu.is_unitary(u1) + assert mu.is_unitary(u2) + + u2_dg = np.conjugate(u2).T + + [d2, v] = scipy.linalg.schur(u1 @ u2_dg) + assert mu.is_diagonal(d2) + assert mu.is_approx(v @ d2 @ np.conjugate(v).T, u1 @ u2_dg) + + d_tmp = np.sqrt(np.diag(d2)) + d = np.diag(d_tmp) + + assert mu.is_approx(d @ d, d2) + v_dg = np.conjugate(v).T + + w = d @ v_dg @ u2 + + assert mu.is_approx(u1, v @ d @ w) + assert mu.is_approx(u2, v @ np.conjugate(d).T @ w) + + zm = np.zeros_like(w) + vv = mu.stack_matrices(v, zm, zm, v) + dd = mu.stack_matrices(d, zm, zm, np.conjugate(d).T) + ww = mu.stack_matrices(w, zm, zm, w) + uu = mu.stack_matrices(u1, zm, zm, u2) + + assert mu.is_approx(vv @ dd @ ww, uu) + assert mu.is_unitary(v) + return v, d, w + + +def _graycode(n): + for i in range(1 << n): + gray = i ^ (i >> 1) + yield "{0:0{1}b}".format(gray, n) + + +def get_multi_control_index(n): + gray_codes = list(_graycode(n)) + size = 2 ** n + + index_list = [] + for i in range(size): + str1 = gray_codes[i] + str2 = gray_codes[(i + 1) % size] + + tmp = [k for k in range(len(str1)) if str1[k] != str2[k]] + assert len(tmp) == 1 + index_list.append(tmp[0]) + + return index_list + + +def genMk_table(nqubits): + """ + TODO: add docstring + """ + import re + + def bin2gray(num): + return num ^ int((num >> 1)) + + def genMk(k): + + Mk = np.zeros((2 ** k, 2 ** k)) + for i in range(2 ** k): + for j in range(2 ** k): + p = i & bin2gray(j) + strbin = "{0:b}".format(p) + tmp = [m.start() for m in re.finditer('1', strbin)] + Mk[i, j] = (-1) ** len(tmp) + + return Mk + + genMk_lookuptable = [] + for n in range(1, nqubits + 1): + tmp = genMk(n) + genMk_lookuptable.append(tmp) + + return genMk_lookuptable diff --git a/src/quafu/elements/quantum_element/__init__.py b/src/quafu/elements/quantum_element/__init__.py new file mode 100644 index 0000000..7dd3936 --- /dev/null +++ b/src/quafu/elements/quantum_element/__init__.py @@ -0,0 +1,4 @@ +from .quantum_element import Barrier, Delay, XYResonance, Measure +from .quantum_gate import QuantumGate, SingleQubitGate, MultiQubitGate, \ + ParaSingleQubitGate, ParaMultiQubitGate, ControlledGate, FixedSingleQubitGate, FixedMultiQubitGate +from .instruction import Instruction From ef4b7caa03b4943d3105c387129da3f3498d0d1f Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 12:25:41 +0800 Subject: [PATCH 44/70] integrate unitary-decomposer into QuantumCircuit as an user function self.unitary() --- src/quafu/circuits/quantum_circuit.py | 13 ++++++- src/quafu/elements/element_gates/__init__.py | 4 +- .../element_gates/unitary/decomposer.py | 39 ++++++++++++++----- 3 files changed, 45 insertions(+), 11 deletions(-) diff --git a/src/quafu/circuits/quantum_circuit.py b/src/quafu/circuits/quantum_circuit.py index 890a14c..1f31c3a 100644 --- a/src/quafu/circuits/quantum_circuit.py +++ b/src/quafu/circuits/quantum_circuit.py @@ -1,7 +1,7 @@ from typing import List import numpy as np -from quafu.pulses.quantum_pulse import QuantumPulse +from quafu.elements.quantum_element.pulses.quantum_pulse import QuantumPulse from ..elements.quantum_element import Barrier, Delay, MultiQubitGate, QuantumGate, ControlledGate, \ SingleQubitGate, XYResonance import quafu.elements.element_gates as qeg @@ -733,6 +733,17 @@ def mcz(self, ctrls: List[int], targ: int): """ self.add_gate(qeg.MCZGate(ctrls, targ)) + def unitary(self, matrix: np.ndarray, pos: List[int]): + """ + Apply unitary to circuit on specified qubits. + + Args: + matrix (np.ndarray): unitary matrix. + pos (list[int]): qubits the gate act on. + """ + compiler = qeg.UnitaryDecomposer(array=matrix, qubits=pos) + compiler.apply_to_qc(self) + def measure(self, pos: List[int] = None, cbits: List[int] = None) -> None: """ Measurement setting for experiment device. diff --git a/src/quafu/elements/element_gates/__init__.py b/src/quafu/elements/element_gates/__init__.py index 51cbf28..fd88efa 100644 --- a/src/quafu/elements/element_gates/__init__.py +++ b/src/quafu/elements/element_gates/__init__.py @@ -7,6 +7,7 @@ from .c21 import ToffoliGate from .c12 import FredkinGate from .cm1 import MCXGate, MCYGate, MCZGate +from .unitary import UnitaryDecomposer __all__ = ['XGate', 'YGate', 'ZGate', 'HGate', 'IdGate', 'WGate', 'SWGate', 'SXGate', 'SXdgGate', 'SYGate', 'SYdgGate', 'SGate', 'SdgGate', 'TGate', 'TdgGate', @@ -16,4 +17,5 @@ 'CXGate', 'CYGate', 'CZGate', 'CSGate', 'CTGate', 'CPGate', 'ToffoliGate', 'FredkinGate', - 'MCXGate', 'MCYGate', 'MCZGate'] + 'MCXGate', 'MCYGate', 'MCZGate', + 'UnitaryDecomposer'] diff --git a/src/quafu/elements/element_gates/unitary/decomposer.py b/src/quafu/elements/element_gates/unitary/decomposer.py index 3831d16..61e649f 100644 --- a/src/quafu/elements/element_gates/unitary/decomposer.py +++ b/src/quafu/elements/element_gates/unitary/decomposer.py @@ -4,7 +4,7 @@ import numpy as np import scipy from numpy import ndarray -# from quafu.circuits.quantum_circuit import QuantumCircuit +from quafu.circuits.quantum_circuit import QuantumCircuit from ..matrices import rz_mat, ry_mat, CXMatrix from ..matrices import mat_utils as mu @@ -20,7 +20,7 @@ def __init__(self, array: ndarray, qubits, verbose: bool = False): self.verbose = verbose self.Mk_table = genMk_table(self.qubit_num) # initialize the general M^k lookup table - self.gates_list = [] + self.gate_list = [] # self.quafuQC = QuantumCircuit(self.qubit_num) def __call__(self, *args, **kwargs): @@ -42,9 +42,9 @@ def _decompose_matrix(self, _matrix, qubits): # self.gates_list.append((_matrix, qubits, 'U')) # ZYZ decomposition for single-qubit gate gamma, beta, alpha, global_phase = zyz_decomposition(_matrix) - self.gates_list.append((rz_mat(gamma), qubits, 'RZ', gamma)) - self.gates_list.append((ry_mat(beta), qubits, 'RY', beta)) - self.gates_list.append((rz_mat(alpha), qubits, 'RZ', alpha)) + self.gate_list.append((rz_mat(gamma), qubits, 'RZ', gamma)) + self.gate_list.append((ry_mat(beta), qubits, 'RY', beta)) + self.gate_list.append((rz_mat(alpha), qubits, 'RZ', alpha)) # self.quafuQC.rz(qubits[0], gamma) # self.quafuQC.ry(qubits[0], beta) # self.quafuQC.rz(qubits[0], alpha) @@ -111,8 +111,8 @@ def multi_controlled_z(self, D, qubits, target_qubit): for i in range(len(index)): control_qubit = qubits[index[i]] - self.gates_list.append((rz_mat(thetas[i]), [target_qubit], 'RZ', thetas[i])) - self.gates_list.append((CXMatrix, [control_qubit, target_qubit], 'CX')) + self.gate_list.append((rz_mat(thetas[i]), [target_qubit], 'RZ', thetas[i])) + self.gate_list.append((CXMatrix, [control_qubit, target_qubit], 'CX')) # self.quafuQC.rz(target_qubit, thetas[i]) # self.quafuQC.cnot(control_qubit, target_qubit) @@ -132,12 +132,33 @@ def multi_controlled_y(self, ss, qubits, target_qubit): for i in range(len(index)): control_qubit = qubits[index[i]] - self.gates_list.append((ry_mat(thetas[i]), [target_qubit], 'RY', thetas[i])) - self.gates_list.append((CXMatrix, [control_qubit, target_qubit], 'CX')) + self.gate_list.append((ry_mat(thetas[i]), [target_qubit], 'RY', thetas[i])) + self.gate_list.append((CXMatrix, [control_qubit, target_qubit], 'CX')) # self.quafuQC.ry(target_qubit, thetas[i]) # self.quafuQC.cnot(control_qubit, target_qubit) + def apply_to_qc(self, circuit: QuantumCircuit): + if len(self.gate_list) == 0: + self() + + for g in self.gate_list: + if g[2] == 'CX': + circuit.cnot(g[1][0], g[1][1]) + elif g[2] == 'RY': + circuit.ry(g[1][0], g[3].real) + elif g[2] == 'RZ': + circuit.rz(g[1][0], g[3].real) + elif g[2] == 'U': + gamma, beta, alpha, global_phase = zyz_decomposition(g[0]) + circuit.rz(g[1][0], gamma) + circuit.ry(g[1][0], beta) + circuit.rz(g[1][0], alpha) + else: + raise Exception("Unknown gate type or incorrect str: {}".format(g[2])) + + return circuit + def zyz_decomposition(unitary): """ ZYZ decomposition of arbitrary single-qubit gate (unitary). From e3c5fdd90bcd4925f907c5ab16bbb224e50fb489 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 14:59:21 +0800 Subject: [PATCH 45/70] fix coding-time problem of matrices --- src/quafu/elements/element_gates/c11.py | 12 +- src/quafu/elements/element_gates/c12.py | 2 +- src/quafu/elements/element_gates/c21.py | 2 +- src/quafu/elements/element_gates/cm1.py | 6 +- .../element_gates/matrices/__init__.py | 4 +- .../elements/quantum_element/quantum_gate.py | 138 ++++-------------- 6 files changed, 43 insertions(+), 121 deletions(-) diff --git a/src/quafu/elements/element_gates/c11.py b/src/quafu/elements/element_gates/c11.py index f07ab4b..7a437c1 100644 --- a/src/quafu/elements/element_gates/c11.py +++ b/src/quafu/elements/element_gates/c11.py @@ -6,7 +6,7 @@ class CXGate(ControlledGate): name = "CX" def __init__(self, ctrl: int, targ: int): - super().__init__("X", [ctrl], [targ], None, matrix=XMatrix) + super().__init__("X", [ctrl], [targ], None, tar_matrix=XMatrix) self.symbol = "+" @@ -14,21 +14,21 @@ class CYGate(ControlledGate): name = "CY" def __init__(self, ctrl: int, targ: int): - super().__init__("Y", [ctrl], [targ], None, matrix=YMatrix) + super().__init__("Y", [ctrl], [targ], None, tar_matrix=YMatrix) class CZGate(ControlledGate): name = "CZ" def __init__(self, ctrl: int, targ: int): - super().__init__("Z", [ctrl], [targ], None, matrix=ZMatrix) + super().__init__("Z", [ctrl], [targ], None, tar_matrix=ZMatrix) class CSGate(ControlledGate): name = "CS" def __init__(self, ctrl: int, targ: int): - super().__init__("S", [ctrl], [targ], None, matrix=SMatrix) + super().__init__("S", [ctrl], [targ], None, tar_matrix=SMatrix) def to_qasm(self): return "cp(pi/2) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) @@ -38,7 +38,7 @@ class CTGate(ControlledGate): name = "CT" def __init__(self, ctrl: int, targ: int): - super().__init__("T", [ctrl], [targ], None, matrix=TMatrix) + super().__init__("T", [ctrl], [targ], None, tar_matrix=TMatrix) def to_qasm(self): return "cp(pi/4) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) @@ -48,4 +48,4 @@ class CPGate(ControlledGate): name = "CP" def __init__(self, ctrl: int, targ: int, paras): - super().__init__("P", [ctrl], [targ], paras, matrix=pmatrix(paras)) + super().__init__("P", [ctrl], [targ], paras, tar_matrix=pmatrix(paras)) diff --git a/src/quafu/elements/element_gates/c12.py b/src/quafu/elements/element_gates/c12.py index ffd56f5..fc8aa64 100644 --- a/src/quafu/elements/element_gates/c12.py +++ b/src/quafu/elements/element_gates/c12.py @@ -6,4 +6,4 @@ class FredkinGate(ControlledGate): name = "CSWAP" def __init__(self, ctrl: int, targ1: int, targ2: int): - super().__init__("SWAP", [ctrl], [targ1, targ2], None, matrix=SwapMatrix) + super().__init__("SWAP", [ctrl], [targ1, targ2], None, tar_matrix=SwapMatrix) diff --git a/src/quafu/elements/element_gates/c21.py b/src/quafu/elements/element_gates/c21.py index b56eada..23d903b 100644 --- a/src/quafu/elements/element_gates/c21.py +++ b/src/quafu/elements/element_gates/c21.py @@ -6,4 +6,4 @@ class ToffoliGate(ControlledGate): name = "CCX" def __init__(self, ctrl1: int, ctrl2: int, targ: int): - super().__init__("X", [ctrl1, ctrl2], [targ], None, matrix=XMatrix) + super().__init__("X", [ctrl1, ctrl2], [targ], None, tar_matrix=XMatrix) diff --git a/src/quafu/elements/element_gates/cm1.py b/src/quafu/elements/element_gates/cm1.py index fa7d733..d6a7ed0 100644 --- a/src/quafu/elements/element_gates/cm1.py +++ b/src/quafu/elements/element_gates/cm1.py @@ -6,18 +6,18 @@ class MCXGate(ControlledGate): name = "MCX" def __init__(self, ctrls, targ: int): - super().__init__("X", ctrls, [targ], None, matrix=XMatrix) + super().__init__("X", ctrls, [targ], None, tar_matrix=XMatrix) class MCYGate(ControlledGate): name = "MCY" def __init__(self, ctrls, targ: int): - super().__init__("Y", ctrls, [targ], None, matrix=YMatrix) + super().__init__("Y", ctrls, [targ], None, tar_matrix=YMatrix) class MCZGate(ControlledGate): name = "MCZ" def __init__(self, ctrls, targ: int): - super().__init__("Z", ctrls, [targ], None, matrix=ZMatrix) + super().__init__("Z", ctrls, [targ], None, tar_matrix=ZMatrix) diff --git a/src/quafu/elements/element_gates/matrices/__init__.py b/src/quafu/elements/element_gates/matrices/__init__.py index 5148bca..f69bd9f 100644 --- a/src/quafu/elements/element_gates/matrices/__init__.py +++ b/src/quafu/elements/element_gates/matrices/__init__.py @@ -1,2 +1,2 @@ -from mat_lib import * -from mat_utils import stack_matrices, is_zero, is_hermitian +from .mat_lib import * +from .mat_utils import stack_matrices, is_zero, is_hermitian diff --git a/src/quafu/elements/quantum_element/quantum_gate.py b/src/quafu/elements/quantum_element/quantum_gate.py index 480a2aa..1588eca 100644 --- a/src/quafu/elements/quantum_element/quantum_gate.py +++ b/src/quafu/elements/quantum_element/quantum_gate.py @@ -1,5 +1,5 @@ from abc import ABC, abstractmethod -from typing import Callable, List, Union, Iterable +from typing import List, Union, Iterable import numpy as np @@ -84,56 +84,24 @@ class SingleQubitGate(QuantumGate, ABC): def __init__(self, pos: int, paras: float = None): super().__init__(pos, paras=paras) - # @property - # def matrix(self): - # return self._matrix - # - # @matrix.setter - # def matrix(self, matrix): - # if isinstance(matrix, (np.ndarray, List)): - # if np.shape(matrix) == (2, 2): - # self._matrix = np.asarray(matrix, dtype=complex) - # else: - # raise ValueError(f'`{self.__class__.__name__}.matrix.shape` must be (2, 2)') - # elif isinstance(matrix, type(None)): - # self._matrix = matrix - # else: - # raise TypeError("Unsupported `matrix` type") - - def get_targ_matrix(self, reverse_order=False): + def get_targ_matrix(self): return self.matrix class MultiQubitGate(QuantumGate, ABC): def __init__(self, pos: List[int], paras: float = None): super().__init__(pos, paras) - self._targ_matrix = self.matrix - - # @property - # def matrix(self): - # return self._matrix - # - # @matrix.setter - # def matrix(self, matrix): - # if isinstance(matrix, np.ndarray): - # self._matrix = matrix - # elif isinstance(matrix, List): - # self._matrix = np.array(matrix, dtype=complex) - # else: - # raise TypeError("Unsupported `matrix` type") - # - # self._matrix = reorder_matrix(self._matrix, self.pos) def get_targ_matrix(self, reverse_order=False): - targ_matrix = self._targ_matrix + targ_matrix = self.matrix + if reverse_order and (len(self.pos) > 1): qnum = len(self.pos) + dim = 2 ** qnum order = np.array(range(len(self.pos))[::-1]) order = np.concatenate([order, order + qnum]) - dim = 2 ** qnum tensorm = targ_matrix.reshape([2] * 2 * qnum) targ_matrix = np.transpose(tensorm, order).reshape([dim, dim]) - return targ_matrix @@ -145,24 +113,6 @@ def __init__(self, pos, paras: float): raise TypeError("`paras` must be float for ParaSingleQubitGate") super().__init__(pos, paras=paras) - # @property - # def matrix(self): - # return self._matrix - # - # @matrix.setter - # def matrix(self, matrix): - # if isinstance(matrix, Callable): - # self._matrix = matrix(self.paras) - # elif isinstance(matrix, (np.ndarray, List)): - # if np.shape(matrix) == (2, 2): - # self._matrix = np.asarray(matrix, dtype=complex) - # else: - # raise ValueError(f'`{self.__class__.__name__}.matrix.shape` must be (2, 2)') - # elif isinstance(matrix, type(None)): - # self._matrix = matrix - # else: - # raise TypeError("Unsupported `matrix` type") - class FixedSingleQubitGate(SingleQubitGate, ABC): def __init__(self, pos): @@ -174,15 +124,32 @@ def __init__(self, pos: List[int]): super().__init__(pos=pos, paras=None) +class ParaMultiQubitGate(MultiQubitGate, ABC): + def __init__(self, pos, paras): + if paras is None: + raise ValueError("`paras` can not be None for ParaMultiQubitGate") + super().__init__(pos, paras) + + class ControlledGate(MultiQubitGate, ABC): """ Controlled gate class, where the matrix act non-trivaly on target qubits""" - def __init__(self, targe_name, ctrls: List[int], targs: List[int], paras, matrix): + def __init__(self, targe_name, ctrls: List[int], targs: List[int], paras, tar_matrix): self.ctrls = ctrls self.targs = targs self.targ_name = targe_name super().__init__(ctrls + targs, paras) - self._targ_matrix = matrix + self._targ_matrix = tar_matrix + + # set matrix + # TODO: change matrix according to control-type 0/1 + targ_dim = 2 ** (len(self.targs)) + ctrl_dim = 2 ** (len(self.ctrls)) + dim = targ_dim + ctrl_dim + self._matrix = np.eye(dim, dtype=complex) + control_dim = 2 ** len(self.pos) - targ_dim + self._matrix[control_dim:, control_dim:] = tar_matrix + self._matrix = reorder_matrix(self._matrix, self.pos) if paras: if isinstance(paras, Iterable): @@ -192,32 +159,11 @@ def __init__(self, targe_name, ctrls: List[int], targs: List[int], paras, matrix else: self.symbol = "%s" % self.targ_name - # TODO - @property def matrix(self): + # TODO: update matrix when paras of controlled-gate changed return self._matrix - @matrix.setter - def matrix(self, matrix: Union[np.ndarray, Callable]): - targ_dim = 2 ** (len(self.targs)) - qnum = len(self.pos) - dim = 2 ** (qnum) - if isinstance(matrix, Callable): - matrix = matrix(self.paras) - - if matrix.shape[0] != targ_dim: - raise ValueError("Dimension dismatch") - else: - self._matrix = np.zeros((dim, dim), dtype=complex) - control_dim = 2 ** len(self.pos) - targ_dim - for i in range(control_dim): - self._matrix[i, i] = 1. - - self._matrix[control_dim:, control_dim:] = matrix - self._matrix = reorder_matrix(self._matrix, self.pos) - # self._targ_matrix = reorder_matrix(matrix, self.targs) - def get_targ_matrix(self, reverse_order=False): targ_matrix = self._targ_matrix if reverse_order and (len(self.targs) > 1): @@ -227,44 +173,20 @@ def get_targ_matrix(self, reverse_order=False): dim = 2 ** qnum tensorm = targ_matrix.reshape([2] * 2 * qnum) targ_matrix = np.transpose(tensorm, order).reshape([dim, dim]) - return targ_matrix -class ParaMultiQubitGate(MultiQubitGate, ABC): - def __init__(self, pos, paras): - if paras is None: - raise ValueError("`paras` can not be None for ParaMultiQubitGate") - super().__init__(pos, paras) - - @property - def matrix(self): - return self._matrix - - @matrix.setter - def matrix(self, matrix): - if isinstance(matrix, Callable): - self._matrix = matrix(self.paras) - self._matrix = reorder_matrix(self._matrix, self.pos) - elif isinstance(matrix, (np.ndarray, List)): - self._matrix = matrix - self._matrix = reorder_matrix(self._matrix, self.pos) - else: - raise TypeError("Unsupported `matrix` type") - - class ControlledU(ControlledGate): """ Controlled gate class, where the matrix act non-trivially on target qubits""" + name = 'CU' - name = 'cu' - - def __init__(self, ctrls: List[int], U: Union[SingleQubitGate, MultiQubitGate]): - self.targ_gate = U - targs = U.pos + def __init__(self, ctrls: List[int], u: Union[SingleQubitGate, MultiQubitGate]): + self.targ_gate = u + targs = u.pos if isinstance(targs, int): targs = [targs] - super().__init__(U.name, ctrls, targs, U.paras, matrix=self.targ_gate.get_targ_matrix()) + super().__init__(u.name, ctrls, targs, u.paras, tar_matrix=self.targ_gate.get_targ_matrix()) def get_targ_matrix(self, reverse_order=False): return self.targ_gate.get_targ_matrix(reverse_order) From 85faea10ecde125ecac955984aa1ba48f1dac15f Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 15:01:08 +0800 Subject: [PATCH 46/70] open benchmark module With unitary decomposer test. --- .../examples => benchmark}/deutsch_jozsa.py | 172 +++++++++--------- src/quafu/benchmark/unitary_test.py | 11 ++ 2 files changed, 97 insertions(+), 86 deletions(-) rename src/quafu/{visualisation/examples => benchmark}/deutsch_jozsa.py (88%) create mode 100644 src/quafu/benchmark/unitary_test.py diff --git a/src/quafu/visualisation/examples/deutsch_jozsa.py b/src/quafu/benchmark/deutsch_jozsa.py similarity index 88% rename from src/quafu/visualisation/examples/deutsch_jozsa.py rename to src/quafu/benchmark/deutsch_jozsa.py index 49d9133..0d08b71 100644 --- a/src/quafu/visualisation/examples/deutsch_jozsa.py +++ b/src/quafu/benchmark/deutsch_jozsa.py @@ -1,86 +1,86 @@ -import random -import matplotlib.pyplot as plt -import numpy as np - -from quafu.circuits.quantum_circuit import QuantumCircuit -from quafu.visualisation.circuitPlot import CircuitPlotManager - - -def get_const_oracle(qc: QuantumCircuit): - n = qc.num - 1 - output = np.random.randint(2) - if output == 1: - qc.x(n) - qc.name = 'Constant Oracle' - return qc - - -def get_balanced_oracle(qc: QuantumCircuit): - n = qc.num - 1 - b_str = ''.join([random.choice('01') for _ in range(n)]) - - # Place X-qu_gate - for qubit in range(len(b_str)): - if b_str[qubit] == '1': - qc.x(qubit) - - # Use barrier as divider - qc.barrier() - - # Controlled-NOT qu_gate - for qubit in range(n): - qc.cnot(qubit, n) - - qc.barrier() - - # Place X-qu_gate - for qubit in range(len(b_str)): - if b_str[qubit] == '1': - qc.x(qubit) - - qc.name = 'Balanced Oracle' - return qc - - -def deutsch_jozsa(n: int, case: str): - circuit = QuantumCircuit(n + 1) # number of q-bit and c-bit - # Initialization - for qubit in range(n): - circuit.h(qubit) - circuit.x(n) - circuit.h(n) - - # Add oracle - ################################################# - if case == 'balanced': - get_balanced_oracle(circuit) - elif case == 'constant': - get_const_oracle(circuit) - else: - raise ValueError('undefined case: ' + case) - ################################################# - - # Repeat H-qu_gate - circuit.barrier() - for qubit in range(n): - circuit.h(qubit) - circuit.barrier() - - # Measure - circuit.measure(list(range(n)), list(range(n))) - return circuit - - -if __name__ == '__main__': - dj_qc = deutsch_jozsa(n=4, case='constant') - cmp = CircuitPlotManager(dj_qc) - cmp(title='Deutsch-Josza Circuit') - - dj_qc.plot_circuit(title='Deutsch-Josza Circuit') - plt.show() - - # import os - # if not os.path.exists('./figures/'): - # os.mkdir('./figures/') - # plt.savefig('./figures/deutsch_jozsa.png', dpi=240) - # plt.show() +import random +import matplotlib.pyplot as plt +import numpy as np + +from quafu.circuits.quantum_circuit import QuantumCircuit +from quafu.visualisation.circuitPlot import CircuitPlotManager + + +def get_const_oracle(qc: QuantumCircuit): + n = qc.num - 1 + output = np.random.randint(2) + if output == 1: + qc.x(n) + qc.name = 'Constant Oracle' + return qc + + +def get_balanced_oracle(qc: QuantumCircuit): + n = qc.num - 1 + b_str = ''.join([random.choice('01') for _ in range(n)]) + + # Place X-qu_gate + for qubit in range(len(b_str)): + if b_str[qubit] == '1': + qc.x(qubit) + + # Use barrier as divider + qc.barrier() + + # Controlled-NOT qu_gate + for qubit in range(n): + qc.cnot(qubit, n) + + qc.barrier() + + # Place X-qu_gate + for qubit in range(len(b_str)): + if b_str[qubit] == '1': + qc.x(qubit) + + qc.name = 'Balanced Oracle' + return qc + + +def deutsch_jozsa(n: int, case: str): + circuit = QuantumCircuit(n + 1) # number of q-bit and c-bit + # Initialization + for qubit in range(n): + circuit.h(qubit) + circuit.x(n) + circuit.h(n) + + # Add oracle + ################################################# + if case == 'balanced': + get_balanced_oracle(circuit) + elif case == 'constant': + get_const_oracle(circuit) + else: + raise ValueError('undefined case: ' + case) + ################################################# + + # Repeat H-qu_gate + circuit.barrier() + for qubit in range(n): + circuit.h(qubit) + circuit.barrier() + + # Measure + circuit.measure(list(range(n)), list(range(n))) + return circuit + + +if __name__ == '__main__': + dj_qc = deutsch_jozsa(n=4, case='constant') + cmp = CircuitPlotManager(dj_qc) + cmp(title='Deutsch-Josza Circuit') + + dj_qc.plot_circuit(title='Deutsch-Josza Circuit') + # plt.show() + + import os + if not os.path.exists('./figures/'): + os.mkdir('./figures/') + plt.savefig('./figures/deutsch_jozsa.png', dpi=240) + # plt.show() diff --git a/src/quafu/benchmark/unitary_test.py b/src/quafu/benchmark/unitary_test.py new file mode 100644 index 0000000..f008c5d --- /dev/null +++ b/src/quafu/benchmark/unitary_test.py @@ -0,0 +1,11 @@ +from scipy.stats import unitary_group +from quafu import QuantumCircuit + +nqubit = 5 +qubits = list(range(nqubit)) +U0 = unitary_group.rvs(2 ** nqubit) + +# Using QSD to decompose the unitary +qc = QuantumCircuit(nqubit) +qc.unitary(U0, qubits) +qc.draw_circuit() From c8e481026ea1e6528b5765375cbee252228c26eb Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 15:11:24 +0800 Subject: [PATCH 47/70] detailing QuafuError (unfinished) --- src/quafu/benchmark/__init__.py | 0 src/quafu/exceptions/__init__.py | 2 + src/quafu/exceptions/circuit_error.py | 15 +++++ .../quafu_error.py} | 58 ++++++++++--------- 4 files changed, 48 insertions(+), 27 deletions(-) create mode 100644 src/quafu/benchmark/__init__.py create mode 100644 src/quafu/exceptions/__init__.py create mode 100644 src/quafu/exceptions/circuit_error.py rename src/quafu/{exceptions.py => exceptions/quafu_error.py} (80%) diff --git a/src/quafu/benchmark/__init__.py b/src/quafu/benchmark/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/quafu/exceptions/__init__.py b/src/quafu/exceptions/__init__.py new file mode 100644 index 0000000..0490b03 --- /dev/null +++ b/src/quafu/exceptions/__init__.py @@ -0,0 +1,2 @@ +from .quafu_error import * + diff --git a/src/quafu/exceptions/circuit_error.py b/src/quafu/exceptions/circuit_error.py new file mode 100644 index 0000000..3a0f95e --- /dev/null +++ b/src/quafu/exceptions/circuit_error.py @@ -0,0 +1,15 @@ +from .quafu_error import CircuitError + + +class IndexOutOfRangeError(CircuitError): + """ """ + + +class InvalidParaError(CircuitError): + """ """ + + +class UnsupportedYet(CircuitError): + """ For un-supported instructions """ + + diff --git a/src/quafu/exceptions.py b/src/quafu/exceptions/quafu_error.py similarity index 80% rename from src/quafu/exceptions.py rename to src/quafu/exceptions/quafu_error.py index 939989c..221a7f8 100644 --- a/src/quafu/exceptions.py +++ b/src/quafu/exceptions/quafu_error.py @@ -1,27 +1,31 @@ - -""" -Exceptions for errors raised while building circuit. -""" - -class QuafuError(Exception): - """Base class for errors raised by Quafu.""" - - def __init__(self, *message): - """Set the error message.""" - super().__init__(" ".join(message)) - self.message = " ".join(message) - - def __str__(self): - """Return the message.""" - return repr(self.message) - -class CircuitError(QuafuError): - """Exceptions for errors raised while building circuit.""" - pass - -class ServerError(QuafuError): - pass - -class CompileError(QuafuError): - pass - +""" +Exceptions for errors raised while building circuit. +""" + + +class QuafuError(Exception): + """Base class for errors raised by Quafu.""" + + def __init__(self, *message): + """Set the error message.""" + super().__init__(" ".join(message)) + self.message = " ".join(message) + + def __str__(self): + """Return the message.""" + return repr(self.message) + + +class CircuitError(QuafuError): + """Exceptions for errors raised while building circuit.""" + pass + + +class ServerError(QuafuError): + """ Exceptions for errors raised while connecting to server.""" + pass + + +class CompileError(QuafuError): + """ Exceptions for errors raised while compiling circuit. """ + pass From 3f7e737f73dd9f6bfbdbffe2416591ee6b60f307 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 15:13:59 +0800 Subject: [PATCH 48/70] small adjustment --- .../element_gates/unitary/decomposer.py | 27 ++++++------------- 1 file changed, 8 insertions(+), 19 deletions(-) diff --git a/src/quafu/elements/element_gates/unitary/decomposer.py b/src/quafu/elements/element_gates/unitary/decomposer.py index 61e649f..ddbb42b 100644 --- a/src/quafu/elements/element_gates/unitary/decomposer.py +++ b/src/quafu/elements/element_gates/unitary/decomposer.py @@ -4,7 +4,6 @@ import numpy as np import scipy from numpy import ndarray -from quafu.circuits.quantum_circuit import QuantumCircuit from ..matrices import rz_mat, ry_mat, CXMatrix from ..matrices import mat_utils as mu @@ -21,7 +20,6 @@ def __init__(self, array: ndarray, qubits, verbose: bool = False): self.Mk_table = genMk_table(self.qubit_num) # initialize the general M^k lookup table self.gate_list = [] - # self.quafuQC = QuantumCircuit(self.qubit_num) def __call__(self, *args, **kwargs): _matrix = self.array @@ -45,9 +43,6 @@ def _decompose_matrix(self, _matrix, qubits): self.gate_list.append((rz_mat(gamma), qubits, 'RZ', gamma)) self.gate_list.append((ry_mat(beta), qubits, 'RY', beta)) self.gate_list.append((rz_mat(alpha), qubits, 'RZ', alpha)) - # self.quafuQC.rz(qubits[0], gamma) - # self.quafuQC.ry(qubits[0], beta) - # self.quafuQC.rz(qubits[0], alpha) return None # if num_qubit == 2: @@ -114,9 +109,6 @@ def multi_controlled_z(self, D, qubits, target_qubit): self.gate_list.append((rz_mat(thetas[i]), [target_qubit], 'RZ', thetas[i])) self.gate_list.append((CXMatrix, [control_qubit, target_qubit], 'CX')) - # self.quafuQC.rz(target_qubit, thetas[i]) - # self.quafuQC.cnot(control_qubit, target_qubit) - def multi_controlled_y(self, ss, qubits, target_qubit): assert len(qubits) == int(math.log(ss.shape[0], 2)) num_qubit = len(qubits) @@ -135,29 +127,26 @@ def multi_controlled_y(self, ss, qubits, target_qubit): self.gate_list.append((ry_mat(thetas[i]), [target_qubit], 'RY', thetas[i])) self.gate_list.append((CXMatrix, [control_qubit, target_qubit], 'CX')) - # self.quafuQC.ry(target_qubit, thetas[i]) - # self.quafuQC.cnot(control_qubit, target_qubit) - - def apply_to_qc(self, circuit: QuantumCircuit): + def apply_to_qc(self, qc): if len(self.gate_list) == 0: self() for g in self.gate_list: if g[2] == 'CX': - circuit.cnot(g[1][0], g[1][1]) + qc.cnot(g[1][0], g[1][1]) elif g[2] == 'RY': - circuit.ry(g[1][0], g[3].real) + qc.ry(g[1][0], g[3].real) elif g[2] == 'RZ': - circuit.rz(g[1][0], g[3].real) + qc.rz(g[1][0], g[3].real) elif g[2] == 'U': gamma, beta, alpha, global_phase = zyz_decomposition(g[0]) - circuit.rz(g[1][0], gamma) - circuit.ry(g[1][0], beta) - circuit.rz(g[1][0], alpha) + qc.rz(g[1][0], gamma) + qc.ry(g[1][0], beta) + qc.rz(g[1][0], alpha) else: raise Exception("Unknown gate type or incorrect str: {}".format(g[2])) - return circuit + return qc def zyz_decomposition(unitary): From 1488317bc7d6777cce2a3a870c81288859f05f6f Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 15:14:28 +0800 Subject: [PATCH 49/70] small adjustment in formatting --- src/quafu/results/results.py | 6 ++---- src/quafu/simulators/simulator.py | 8 ++++++-- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/quafu/results/results.py b/src/quafu/results/results.py index 28439ed..3f3ce69 100644 --- a/src/quafu/results/results.py +++ b/src/quafu/results/results.py @@ -1,8 +1,7 @@ -import numpy as np -from functools import reduce import copy -import matplotlib.pyplot as plt from collections import OrderedDict + +import matplotlib.pyplot as plt from ..utils.basis import * @@ -97,7 +96,6 @@ def plot_probabilities(self, full: bool = False, reverse_basis: bool = False, so sort: Sort the results by probabilities values. Can be `"ascend"` order or `"descend"` order. """ - from ..utils.basis import get_basis probs = self.probabilities inds = range(len(probs)) if not full: diff --git a/src/quafu/simulators/simulator.py b/src/quafu/simulators/simulator.py index 3f13f95..7edd68d 100644 --- a/src/quafu/simulators/simulator.py +++ b/src/quafu/simulators/simulator.py @@ -7,8 +7,12 @@ from ..exceptions import QuafuError -def simulate(qc: Union[QuantumCircuit, str], psi: np.ndarray = np.array([]), simulator: str = "qfvm_circ", - output: str = "probabilities", use_gpu: bool = False, use_custatevec: bool = False) -> SimuResult: +def simulate(qc: Union[QuantumCircuit, str], + psi: np.ndarray = np.array([]), + simulator: str = "qfvm_circ", + output: str = "probabilities", + use_gpu: bool = False, + use_custatevec: bool = False) -> SimuResult: """Simulate quantum circuit Args: qc: quantum circuit or qasm string that need to be simulated. From 9b0adc33e36b2b515a6e6274e88a3708324b5ef3 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 15:35:16 +0800 Subject: [PATCH 50/70] add register mechanism for QuantumGate From now on you may look up all the available concrete gate class by: for name, cls in QuantumGate.gate_classes.items(): print(name, cls.__name__) Similar mechanism is to be implemented for Instruction. --- src/quafu/elements/element_gates/c11.py | 8 +++++ src/quafu/elements/element_gates/c12.py | 3 ++ src/quafu/elements/element_gates/c21.py | 4 +++ src/quafu/elements/element_gates/cm1.py | 5 ++++ src/quafu/elements/element_gates/pauli.py | 9 ++++++ src/quafu/elements/element_gates/phase.py | 3 ++ src/quafu/elements/element_gates/rotation.py | 8 +++++ src/quafu/elements/element_gates/sqrt.py | 10 +++++++ src/quafu/elements/element_gates/swap.py | 4 +++ .../elements/quantum_element/quantum_gate.py | 29 +++++++++---------- 10 files changed, 68 insertions(+), 15 deletions(-) diff --git a/src/quafu/elements/element_gates/c11.py b/src/quafu/elements/element_gates/c11.py index 7a437c1..035bf05 100644 --- a/src/quafu/elements/element_gates/c11.py +++ b/src/quafu/elements/element_gates/c11.py @@ -49,3 +49,11 @@ class CPGate(ControlledGate): def __init__(self, ctrl: int, targ: int, paras): super().__init__("P", [ctrl], [targ], paras, tar_matrix=pmatrix(paras)) + + +ControlledGate.register_subclass(CXGate) +ControlledGate.register_subclass(CYGate) +ControlledGate.register_subclass(CZGate) +ControlledGate.register_subclass(CSGate) +ControlledGate.register_subclass(CTGate) +ControlledGate.register_subclass(CPGate) diff --git a/src/quafu/elements/element_gates/c12.py b/src/quafu/elements/element_gates/c12.py index fc8aa64..7acda31 100644 --- a/src/quafu/elements/element_gates/c12.py +++ b/src/quafu/elements/element_gates/c12.py @@ -7,3 +7,6 @@ class FredkinGate(ControlledGate): def __init__(self, ctrl: int, targ1: int, targ2: int): super().__init__("SWAP", [ctrl], [targ1, targ2], None, tar_matrix=SwapMatrix) + + +ControlledGate.register_subclass(FredkinGate) diff --git a/src/quafu/elements/element_gates/c21.py b/src/quafu/elements/element_gates/c21.py index 23d903b..c5e3184 100644 --- a/src/quafu/elements/element_gates/c21.py +++ b/src/quafu/elements/element_gates/c21.py @@ -7,3 +7,7 @@ class ToffoliGate(ControlledGate): def __init__(self, ctrl1: int, ctrl2: int, targ: int): super().__init__("X", [ctrl1, ctrl2], [targ], None, tar_matrix=XMatrix) + + +ControlledGate.register_subclass(ToffoliGate) + diff --git a/src/quafu/elements/element_gates/cm1.py b/src/quafu/elements/element_gates/cm1.py index d6a7ed0..8733f06 100644 --- a/src/quafu/elements/element_gates/cm1.py +++ b/src/quafu/elements/element_gates/cm1.py @@ -21,3 +21,8 @@ class MCZGate(ControlledGate): def __init__(self, ctrls, targ: int): super().__init__("Z", ctrls, [targ], None, tar_matrix=ZMatrix) + + +ControlledGate.register_subclass(MCXGate) +ControlledGate.register_subclass(MCYGate) +ControlledGate.register_subclass(MCZGate) diff --git a/src/quafu/elements/element_gates/pauli.py b/src/quafu/elements/element_gates/pauli.py index 0ec83d4..a1cd170 100644 --- a/src/quafu/elements/element_gates/pauli.py +++ b/src/quafu/elements/element_gates/pauli.py @@ -64,3 +64,12 @@ def __init__(self, pos: int): def to_qasm(self): return "rz(-pi/4) q[%d];\nrx(pi/2) q[%d];\nrz(pi/4) q[%d]" % (self.pos, self.pos, self.pos) + + +FixedSingleQubitGate.register_subclass(IdGate) +FixedSingleQubitGate.register_subclass(HGate) +FixedSingleQubitGate.register_subclass(XGate) +FixedSingleQubitGate.register_subclass(YGate) +FixedSingleQubitGate.register_subclass(ZGate) +FixedSingleQubitGate.register_subclass(WGate) +FixedSingleQubitGate.register_subclass(SWGate) diff --git a/src/quafu/elements/element_gates/phase.py b/src/quafu/elements/element_gates/phase.py index 6150f8a..ef4f2c9 100644 --- a/src/quafu/elements/element_gates/phase.py +++ b/src/quafu/elements/element_gates/phase.py @@ -11,3 +11,6 @@ def __init__(self, pos: int, paras: float = 0.): @property def matrix(self): return pmatrix(self.paras) + + +ParaSingleQubitGate.register_subclass(PhaseGate) diff --git a/src/quafu/elements/element_gates/rotation.py b/src/quafu/elements/element_gates/rotation.py index 25e995c..fc28fff 100644 --- a/src/quafu/elements/element_gates/rotation.py +++ b/src/quafu/elements/element_gates/rotation.py @@ -75,3 +75,11 @@ def matrix(self): def get_targ_matrix(self, reverse_order=False): return self.matrix + + +ParaSingleQubitGate.register_subclass(RXGate) +ParaSingleQubitGate.register_subclass(RYGate) +ParaSingleQubitGate.register_subclass(RZGate) +ParaMultiQubitGate.register_subclass(RXXGate) +ParaMultiQubitGate.register_subclass(RYYGate) +ParaMultiQubitGate.register_subclass(RZZGate) diff --git a/src/quafu/elements/element_gates/sqrt.py b/src/quafu/elements/element_gates/sqrt.py index 5d18adb..a72ce9c 100644 --- a/src/quafu/elements/element_gates/sqrt.py +++ b/src/quafu/elements/element_gates/sqrt.py @@ -75,3 +75,13 @@ def __init__(self, pos: int): def to_qasm(self): # TODO: this seems incorrect return "ry(pi/2) q[%d]" % self.pos + + +FixedSingleQubitGate.register_subclass(SGate) +FixedSingleQubitGate.register_subclass(SdgGate) +FixedSingleQubitGate.register_subclass(TGate) +FixedSingleQubitGate.register_subclass(TdgGate) +FixedSingleQubitGate.register_subclass(SXGate) +FixedSingleQubitGate.register_subclass(SXdgGate) +FixedSingleQubitGate.register_subclass(SYGate) +FixedSingleQubitGate.register_subclass(SYdgGate) diff --git a/src/quafu/elements/element_gates/swap.py b/src/quafu/elements/element_gates/swap.py index 87dffd2..44798bc 100644 --- a/src/quafu/elements/element_gates/swap.py +++ b/src/quafu/elements/element_gates/swap.py @@ -23,3 +23,7 @@ def __init__(self, q1: int, q2: int): def get_targ_matrix(self, reverse_order=False): return self.matrix + + +FixedMultiQubitGate.register_subclass(ISwapGate) +FixedMultiQubitGate.register_subclass(SwapGate) diff --git a/src/quafu/elements/quantum_element/quantum_gate.py b/src/quafu/elements/quantum_element/quantum_gate.py index 1588eca..941a7ab 100644 --- a/src/quafu/elements/quantum_element/quantum_gate.py +++ b/src/quafu/elements/quantum_element/quantum_gate.py @@ -17,6 +17,8 @@ def reorder_matrix(matrix: np.ndarray, pos: List): class QuantumGate(Instruction): + gate_classes = {} + def __init__(self, pos: PosType, paras: Union[float, List[float]] = None, @@ -38,21 +40,15 @@ def matrix(self): raise NotImplementedError("Matrix is not implemented for %s" % self.__class__.__name__ + ", this should never happen.") - # @property - # def pos(self): - # return self.__pos - # - # @pos.setter - # def pos(self, _pos): - # self.__pos = _pos - # - # @property - # def paras(self): - # return self.__paras - # - # @paras.setter - # def paras(self, _paras): - # self.__paras = _paras + @classmethod + def register_subclass(cls, subclass, name: str = None): + assert issubclass(subclass, cls) + + if name is None: + name = subclass.name + if name in cls.gate_classes: + raise ValueError(f"Name {name} already exists.") + cls.gate_classes[name] = subclass def __str__(self): properties_names = ['pos', 'paras', 'matrix'] @@ -190,3 +186,6 @@ def __init__(self, ctrls: List[int], u: Union[SingleQubitGate, MultiQubitGate]): def get_targ_matrix(self, reverse_order=False): return self.targ_gate.get_targ_matrix(reverse_order) + + +QuantumGate.register_subclass(ControlledU) From 47a085ab5e6a3ce5baa9fe343f3f265d05e2c667 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 16:01:59 +0800 Subject: [PATCH 51/70] add register mechanism for Instruction. --- src/quafu/elements/element_gates/c11.py | 12 ++-- src/quafu/elements/element_gates/c12.py | 2 +- src/quafu/elements/element_gates/c21.py | 2 +- src/quafu/elements/element_gates/cm1.py | 6 +- src/quafu/elements/element_gates/pauli.py | 14 ++--- src/quafu/elements/element_gates/phase.py | 2 +- src/quafu/elements/element_gates/rotation.py | 12 ++-- src/quafu/elements/element_gates/sqrt.py | 16 +++--- src/quafu/elements/element_gates/swap.py | 4 +- .../elements/quantum_element/instruction.py | 57 ++++++------------- .../elements/quantum_element/quantum_gate.py | 5 +- 11 files changed, 55 insertions(+), 77 deletions(-) diff --git a/src/quafu/elements/element_gates/c11.py b/src/quafu/elements/element_gates/c11.py index 035bf05..9074290 100644 --- a/src/quafu/elements/element_gates/c11.py +++ b/src/quafu/elements/element_gates/c11.py @@ -51,9 +51,9 @@ def __init__(self, ctrl: int, targ: int, paras): super().__init__("P", [ctrl], [targ], paras, tar_matrix=pmatrix(paras)) -ControlledGate.register_subclass(CXGate) -ControlledGate.register_subclass(CYGate) -ControlledGate.register_subclass(CZGate) -ControlledGate.register_subclass(CSGate) -ControlledGate.register_subclass(CTGate) -ControlledGate.register_subclass(CPGate) +ControlledGate.register_gate(CXGate) +ControlledGate.register_gate(CYGate) +ControlledGate.register_gate(CZGate) +ControlledGate.register_gate(CSGate) +ControlledGate.register_gate(CTGate) +ControlledGate.register_gate(CPGate) diff --git a/src/quafu/elements/element_gates/c12.py b/src/quafu/elements/element_gates/c12.py index 7acda31..c51e9e6 100644 --- a/src/quafu/elements/element_gates/c12.py +++ b/src/quafu/elements/element_gates/c12.py @@ -9,4 +9,4 @@ def __init__(self, ctrl: int, targ1: int, targ2: int): super().__init__("SWAP", [ctrl], [targ1, targ2], None, tar_matrix=SwapMatrix) -ControlledGate.register_subclass(FredkinGate) +ControlledGate.register_gate(FredkinGate) diff --git a/src/quafu/elements/element_gates/c21.py b/src/quafu/elements/element_gates/c21.py index c5e3184..5419cbd 100644 --- a/src/quafu/elements/element_gates/c21.py +++ b/src/quafu/elements/element_gates/c21.py @@ -9,5 +9,5 @@ def __init__(self, ctrl1: int, ctrl2: int, targ: int): super().__init__("X", [ctrl1, ctrl2], [targ], None, tar_matrix=XMatrix) -ControlledGate.register_subclass(ToffoliGate) +ControlledGate.register_gate(ToffoliGate) diff --git a/src/quafu/elements/element_gates/cm1.py b/src/quafu/elements/element_gates/cm1.py index 8733f06..c00f244 100644 --- a/src/quafu/elements/element_gates/cm1.py +++ b/src/quafu/elements/element_gates/cm1.py @@ -23,6 +23,6 @@ def __init__(self, ctrls, targ: int): super().__init__("Z", ctrls, [targ], None, tar_matrix=ZMatrix) -ControlledGate.register_subclass(MCXGate) -ControlledGate.register_subclass(MCYGate) -ControlledGate.register_subclass(MCZGate) +ControlledGate.register_gate(MCXGate) +ControlledGate.register_gate(MCYGate) +ControlledGate.register_gate(MCZGate) diff --git a/src/quafu/elements/element_gates/pauli.py b/src/quafu/elements/element_gates/pauli.py index a1cd170..677deb0 100644 --- a/src/quafu/elements/element_gates/pauli.py +++ b/src/quafu/elements/element_gates/pauli.py @@ -66,10 +66,10 @@ def to_qasm(self): return "rz(-pi/4) q[%d];\nrx(pi/2) q[%d];\nrz(pi/4) q[%d]" % (self.pos, self.pos, self.pos) -FixedSingleQubitGate.register_subclass(IdGate) -FixedSingleQubitGate.register_subclass(HGate) -FixedSingleQubitGate.register_subclass(XGate) -FixedSingleQubitGate.register_subclass(YGate) -FixedSingleQubitGate.register_subclass(ZGate) -FixedSingleQubitGate.register_subclass(WGate) -FixedSingleQubitGate.register_subclass(SWGate) +FixedSingleQubitGate.register_gate(IdGate) +FixedSingleQubitGate.register_gate(HGate) +FixedSingleQubitGate.register_gate(XGate) +FixedSingleQubitGate.register_gate(YGate) +FixedSingleQubitGate.register_gate(ZGate) +FixedSingleQubitGate.register_gate(WGate) +FixedSingleQubitGate.register_gate(SWGate) diff --git a/src/quafu/elements/element_gates/phase.py b/src/quafu/elements/element_gates/phase.py index ef4f2c9..f40d119 100644 --- a/src/quafu/elements/element_gates/phase.py +++ b/src/quafu/elements/element_gates/phase.py @@ -13,4 +13,4 @@ def matrix(self): return pmatrix(self.paras) -ParaSingleQubitGate.register_subclass(PhaseGate) +ParaSingleQubitGate.register_gate(PhaseGate) diff --git a/src/quafu/elements/element_gates/rotation.py b/src/quafu/elements/element_gates/rotation.py index fc28fff..69ee7f7 100644 --- a/src/quafu/elements/element_gates/rotation.py +++ b/src/quafu/elements/element_gates/rotation.py @@ -77,9 +77,9 @@ def get_targ_matrix(self, reverse_order=False): return self.matrix -ParaSingleQubitGate.register_subclass(RXGate) -ParaSingleQubitGate.register_subclass(RYGate) -ParaSingleQubitGate.register_subclass(RZGate) -ParaMultiQubitGate.register_subclass(RXXGate) -ParaMultiQubitGate.register_subclass(RYYGate) -ParaMultiQubitGate.register_subclass(RZZGate) +ParaSingleQubitGate.register_gate(RXGate) +ParaSingleQubitGate.register_gate(RYGate) +ParaSingleQubitGate.register_gate(RZGate) +ParaMultiQubitGate.register_gate(RXXGate) +ParaMultiQubitGate.register_gate(RYYGate) +ParaMultiQubitGate.register_gate(RZZGate) diff --git a/src/quafu/elements/element_gates/sqrt.py b/src/quafu/elements/element_gates/sqrt.py index a72ce9c..2cca359 100644 --- a/src/quafu/elements/element_gates/sqrt.py +++ b/src/quafu/elements/element_gates/sqrt.py @@ -77,11 +77,11 @@ def to_qasm(self): return "ry(pi/2) q[%d]" % self.pos -FixedSingleQubitGate.register_subclass(SGate) -FixedSingleQubitGate.register_subclass(SdgGate) -FixedSingleQubitGate.register_subclass(TGate) -FixedSingleQubitGate.register_subclass(TdgGate) -FixedSingleQubitGate.register_subclass(SXGate) -FixedSingleQubitGate.register_subclass(SXdgGate) -FixedSingleQubitGate.register_subclass(SYGate) -FixedSingleQubitGate.register_subclass(SYdgGate) +FixedSingleQubitGate.register_gate(SGate) +FixedSingleQubitGate.register_gate(SdgGate) +FixedSingleQubitGate.register_gate(TGate) +FixedSingleQubitGate.register_gate(TdgGate) +FixedSingleQubitGate.register_gate(SXGate) +FixedSingleQubitGate.register_gate(SXdgGate) +FixedSingleQubitGate.register_gate(SYGate) +FixedSingleQubitGate.register_gate(SYdgGate) diff --git a/src/quafu/elements/element_gates/swap.py b/src/quafu/elements/element_gates/swap.py index 44798bc..1e7ebcd 100644 --- a/src/quafu/elements/element_gates/swap.py +++ b/src/quafu/elements/element_gates/swap.py @@ -25,5 +25,5 @@ def get_targ_matrix(self, reverse_order=False): return self.matrix -FixedMultiQubitGate.register_subclass(ISwapGate) -FixedMultiQubitGate.register_subclass(SwapGate) +FixedMultiQubitGate.register_gate(ISwapGate) +FixedMultiQubitGate.register_gate(SwapGate) diff --git a/src/quafu/elements/quantum_element/instruction.py b/src/quafu/elements/quantum_element/instruction.py index 0d30b6a..80897dc 100644 --- a/src/quafu/elements/quantum_element/instruction.py +++ b/src/quafu/elements/quantum_element/instruction.py @@ -3,51 +3,28 @@ class Instruction(ABC): + ins_classes = {} + @property @abstractmethod def name(self) -> str: raise NotImplementedError('name is not implemented for %s' % self.__class__.__name__ + ', this should never happen.') - # """ - # Metaclass for primitive instructions in DIRECTED ACYCLIC quantum circuits - # or quantum-classical circuits. - # - # Member variables: - # - # - sd_name: standard name without args or extra annotations. Used for communications - # and identifications within pyquafu program, for example, to translate a qu_gate into qasm. - # Ideally every known primitive during computation should have such a name, and should be - # chosen as the most commonly accepted convention. NOT allowed to be changed by users once - # the class is instantiated. - # - # - pos: positions of relevant quantum or classical bits, legs of DAG. - # - # - dorder: depth order, or topological order of DAG - # - # - symbol: label that can be freely customized by users. If sd_name is not None, name is the - # same as sd_name by default. Otherwise, a symbol has to be specified while sd_name remains - # as None to indicate that this is a use-defined class. - # """ - # - # _ins_id = None # type: str - # - # def __init__(self, pos: PosType, label: str = None, paras: ParaType = None): - # # if pos is not iterable, make it be - # self.pos = [pos] if isinstance(pos, int) else pos - # if label: - # self.label = label - # else: - # if self._ins_id is None: - # raise ValueError('For user-defined instruction, label has to be specified.') - # self.label = self._ins_id - # if paras: - # self.label += '(' + ', '.join(['%.3f' % _ for _ in paras.values()]) + ')' - # self.paras = paras - # - # @classmethod - # def get_ins_id(cls): - # return cls._ins_id - # + + @name.setter + def name(self, _): + import warnings + warnings.warn("Invalid assignment, names of standard instructions are not alterable.") + + @classmethod + def register_ins(cls, subclass, name: str = None): + assert issubclass(subclass, cls) + + if name is None: + name = subclass.name + if name in cls.ins_classes: + raise ValueError(f"Name {name} already exists.") + cls.ins_classes[name] = subclass # @abstractmethod # def openqasm2(self) -> str: # pass diff --git a/src/quafu/elements/quantum_element/quantum_gate.py b/src/quafu/elements/quantum_element/quantum_gate.py index 941a7ab..e349eef 100644 --- a/src/quafu/elements/quantum_element/quantum_gate.py +++ b/src/quafu/elements/quantum_element/quantum_gate.py @@ -41,7 +41,7 @@ def matrix(self): ", this should never happen.") @classmethod - def register_subclass(cls, subclass, name: str = None): + def register_gate(cls, subclass, name: str = None): assert issubclass(subclass, cls) if name is None: @@ -49,6 +49,7 @@ def register_subclass(cls, subclass, name: str = None): if name in cls.gate_classes: raise ValueError(f"Name {name} already exists.") cls.gate_classes[name] = subclass + Instruction.register_ins(subclass, name) def __str__(self): properties_names = ['pos', 'paras', 'matrix'] @@ -188,4 +189,4 @@ def get_targ_matrix(self, reverse_order=False): return self.targ_gate.get_targ_matrix(reverse_order) -QuantumGate.register_subclass(ControlledU) +QuantumGate.register_gate(ControlledU) From 5963397be1b6ece8eea127be0e1c2c95440c00a1 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 16:03:43 +0800 Subject: [PATCH 52/70] modify time_func as an attribute of QuantumPulse. --- .../quantum_element/pulses/quantum_pulse.py | 76 +++++++++++++------ .../quantum_element/quantum_element.py | 6 ++ 2 files changed, 59 insertions(+), 23 deletions(-) diff --git a/src/quafu/elements/quantum_element/pulses/quantum_pulse.py b/src/quafu/elements/quantum_element/pulses/quantum_pulse.py index 88b9d28..71663c9 100644 --- a/src/quafu/elements/quantum_element/pulses/quantum_pulse.py +++ b/src/quafu/elements/quantum_element/pulses/quantum_pulse.py @@ -5,11 +5,13 @@ import numpy as np import scipy.special +from abc import ABC, abstractmethod + from quafu.elements.quantum_element.instruction import Instruction -class QuantumPulse(Instruction): - name = 'Pulse' +class QuantumPulse(Instruction, ABC): + pulse_classes = {} def __init__(self, pos: Union[int, list], @@ -17,7 +19,6 @@ def __init__(self, duration: Union[float, int], unit: str, channel: str, - time_func: Optional[Callable] = None, ): """ Quantum Pulse for generating a quantum gate. @@ -37,7 +38,6 @@ def __init__(self, self.paras = paras self.duration = duration self.unit = unit - self.time_func = time_func if channel in ["XY", "Z"]: self.channel = channel else: @@ -47,6 +47,28 @@ def __init__(self, def symbol(self): return "%s(%d%s, %s)" % (self.name, self.duration, self.unit, self.channel) + @abstractmethod + def time_func(self, t: Union[np.ndarray, float, int], **kwargs): + """ + Return the pulse data. + + Args: + t (np.ndarray, float, int): Time list. + kwargs (dict): Keyword arguments for the pulse. + """ + pass + + @classmethod + def register_pulse(cls, subclass, name: str = None): + assert issubclass(subclass, cls) + + if name is None: + name = subclass.name + if name in cls.pulse_classes: + raise ValueError(f"Name {name} already exists.") + cls.pulse_classes[name] = subclass + Instruction.register_ins(subclass, name) + def __repr__(self): return self.__str__() @@ -138,11 +160,12 @@ class RectPulse(QuantumPulse): def __init__(self, pos, amp, duration, unit, channel): self.amp = amp - def rect_time_func(t, **kws): - amp_ = kws["amp"] - return amp_ * np.ones(np.array(t).shape) + super().__init__(pos, [amp], duration, unit, channel) - super().__init__(pos, [amp], duration, unit, channel, rect_time_func) + def time_func(self, t: Union[np.ndarray, float, int], **kwargs): + """ rect_time_func """ + amp_ = kwargs["amp"] + return amp_ * np.ones(np.array(t).shape) def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): args = {"amp": self.amp} @@ -156,13 +179,15 @@ def __init__(self, pos, amp, fwhm, duration, unit, channel): self.amp = amp self.fwhm = fwhm - def flattop_time_func(t, **kws): - amp_, fwhm_ = kws["amp"], kws["fwhm"] - sigma_ = fwhm_ / (2 * np.sqrt(np.log(2))) - return amp_ * (scipy.special.erf((duration - t) / sigma_) - + scipy.special.erf(t / sigma_) - 1.) + super().__init__(pos, [amp, fwhm], duration, unit, channel) + + def time_func(self, t, **kws): + """ flattop_time_func """ - super().__init__(pos, [amp, fwhm], duration, unit, channel, flattop_time_func) + amp_, fwhm_ = kws["amp"], kws["fwhm"] + sigma_ = fwhm_ / (2 * np.sqrt(np.log(2))) + return amp_ * (scipy.special.erf((self.duration - t) / sigma_) + + scipy.special.erf(t / sigma_) - 1.) def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): args = {"amp": self.amp, "fwhm": self.fwhm} @@ -174,22 +199,27 @@ class GaussianPulse(QuantumPulse): def __init__(self, pos, amp, fwhm, phase, duration, unit, channel): self.amp = amp - if fwhm == None: + if fwhm is None: self.fwhm = 0.5 * duration else: self.fwhm = fwhm - self.phase = phase - def gaussian_time_func(t, **kws): - amp_, fwhm_, phase_ = kws["amp"], kws["fwhm"], kws["phase"] - # start: t = 0, center: t = 0.5 * duration, end: t = duration - sigma_ = fwhm_ / np.sqrt(8 * np.log(2)) # fwhm to std. deviation - return amp_ * np.exp( - -(t - 0.5 * duration) ** 2 / (2 * sigma_ ** 2) + 1j * phase_) + super().__init__(pos, [amp, fwhm, phase], duration, unit, channel) - super().__init__(pos, [amp, fwhm, phase], duration, unit, channel, gaussian_time_func) + def time_func(self, t, **kws): + """ gaussian_time_func """ + amp_, fwhm_, phase_ = kws["amp"], kws["fwhm"], kws["phase"] + # start: t = 0, center: t = 0.5 * duration, end: t = duration + sigma_ = fwhm_ / np.sqrt(8 * np.log(2)) # fwhm to std. deviation + return amp_ * np.exp( + -(t - 0.5 * self.duration) ** 2 / (2 * sigma_ ** 2) + 1j * phase_) def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): args = {"amp": self.amp, "fwhm": self.fwhm, "phase": self.phase} return super().__call__(t, shift, offset, args) + + +QuantumPulse.register_pulse(RectPulse) +QuantumPulse.register_pulse(FlattopPulse) +QuantumPulse.register_pulse(GaussianPulse) diff --git a/src/quafu/elements/quantum_element/quantum_element.py b/src/quafu/elements/quantum_element/quantum_element.py index 165c8cb..83d93ae 100644 --- a/src/quafu/elements/quantum_element/quantum_element.py +++ b/src/quafu/elements/quantum_element/quantum_element.py @@ -84,3 +84,9 @@ class Measure(Instruction): def __init__(self, bitmap: dict): self.qbits = bitmap.keys() self.cbits = bitmap.values() + + +Instruction.register_ins(Barrier) +Instruction.register_ins(Delay) +Instruction.register_ins(XYResonance) +Instruction.register_ins(Measure) From 43944539f04d42452c430eac07983d2cfc168db2 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 16:08:11 +0800 Subject: [PATCH 53/70] small fix --- .../quantum_element/pulses/quantum_pulse.py | 41 ++++++++++++------- 1 file changed, 27 insertions(+), 14 deletions(-) diff --git a/src/quafu/elements/quantum_element/pulses/quantum_pulse.py b/src/quafu/elements/quantum_element/pulses/quantum_pulse.py index 71663c9..2b9c936 100644 --- a/src/quafu/elements/quantum_element/pulses/quantum_pulse.py +++ b/src/quafu/elements/quantum_element/pulses/quantum_pulse.py @@ -1,20 +1,22 @@ +from abc import ABC, abstractmethod from copy import deepcopy -from typing import Union, Optional, Callable +from typing import Union, Optional import matplotlib.pyplot as plt import numpy as np import scipy.special -from abc import ABC, abstractmethod +from quafu.elements.quantum_element.instruction import Instruction, PosType + -from quafu.elements.quantum_element.instruction import Instruction +TimeType = Union[np.ndarray, float, int] class QuantumPulse(Instruction, ABC): pulse_classes = {} def __init__(self, - pos: Union[int, list], + pos: PosType, paras: list, duration: Union[float, int], unit: str, @@ -28,10 +30,6 @@ def __init__(self, paras (list): Parameters of the pulse. duration (float, int): Pulse duration. unit (str): Duration unit. - name (str): Pulse name. - time_func (callable): Time function of the pulse. - Where t=0 is the start, t=duration is the end of the pulse. - """ super().__init__() self.pos = pos @@ -81,7 +79,7 @@ def __str__(self): return symbol def __call__(self, - t: Union[np.ndarray, float, int], + t: TimeType, shift: Union[float, int] = 0., offset: Union[float, int] = 0., args: dict = None @@ -167,7 +165,12 @@ def time_func(self, t: Union[np.ndarray, float, int], **kwargs): amp_ = kwargs["amp"] return amp_ * np.ones(np.array(t).shape) - def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): + def __call__(self, + t: TimeType, + shift: Union[float, int] = 0, + offset: Union[float, int] = 0, + *args, + **kwargs): args = {"amp": self.amp} return super().__call__(t, shift, offset, args) @@ -183,13 +186,18 @@ def __init__(self, pos, amp, fwhm, duration, unit, channel): def time_func(self, t, **kws): """ flattop_time_func """ + from scipy.special import erf amp_, fwhm_ = kws["amp"], kws["fwhm"] sigma_ = fwhm_ / (2 * np.sqrt(np.log(2))) - return amp_ * (scipy.special.erf((self.duration - t) / sigma_) - + scipy.special.erf(t / sigma_) - 1.) + return amp_ * (erf((self.duration - t) / sigma_) + erf(t / sigma_) - 1.) - def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): + def __call__(self, + t: TimeType, + shift: Union[float, int] = 0, + offset: Union[float, int] = 0, + *args, + **kwargs): args = {"amp": self.amp, "fwhm": self.fwhm} return super().__call__(t, shift, offset, args) @@ -215,7 +223,12 @@ def time_func(self, t, **kws): return amp_ * np.exp( -(t - 0.5 * self.duration) ** 2 / (2 * sigma_ ** 2) + 1j * phase_) - def __call__(self, t: Union[np.ndarray, float, int], shift: Union[float, int] = 0, offset: Union[float, int] = 0): + def __call__(self, + t: TimeType, + shift: Union[float, int] = 0, + offset: Union[float, int] = 0, + *args, + **kwargs): args = {"amp": self.amp, "fwhm": self.fwhm, "phase": self.phase} return super().__call__(t, shift, offset, args) From d621f10b585c6519f33e8b6dc56c35e33a670bd1 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 16:12:42 +0800 Subject: [PATCH 54/70] small fix --- src/quafu/elements/quantum_element/pulses/quantum_pulse.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/quafu/elements/quantum_element/pulses/quantum_pulse.py b/src/quafu/elements/quantum_element/pulses/quantum_pulse.py index 2b9c936..1ed07c0 100644 --- a/src/quafu/elements/quantum_element/pulses/quantum_pulse.py +++ b/src/quafu/elements/quantum_element/pulses/quantum_pulse.py @@ -4,11 +4,9 @@ import matplotlib.pyplot as plt import numpy as np -import scipy.special from quafu.elements.quantum_element.instruction import Instruction, PosType - TimeType = Union[np.ndarray, float, int] From 35ec52c59d74b3ce99b507b514c38133422f5ded Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 16:58:29 +0800 Subject: [PATCH 55/70] standardize __init__() of instruction.py --- src/quafu/elements/element_gates/sqrt.py | 87 ------------------- .../elements/quantum_element/instruction.py | 28 ++++-- .../quantum_element/quantum_element.py | 7 +- .../elements/quantum_element/quantum_gate.py | 19 ++-- 4 files changed, 38 insertions(+), 103 deletions(-) delete mode 100644 src/quafu/elements/element_gates/sqrt.py diff --git a/src/quafu/elements/element_gates/sqrt.py b/src/quafu/elements/element_gates/sqrt.py deleted file mode 100644 index 2cca359..0000000 --- a/src/quafu/elements/element_gates/sqrt.py +++ /dev/null @@ -1,87 +0,0 @@ -from ..quantum_element import FixedSingleQubitGate -import numpy as np - - -class SGate(FixedSingleQubitGate): - name = "S" - matrix = np.array([[1., 0.], - [0., 1.j]], dtype=complex) - - def __init__(self, pos: int): - super().__init__(pos) - - -class SdgGate(FixedSingleQubitGate): - name = "Sdg" - matrix = SGate.matrix.conj().T - - def __init__(self, pos: int): - super().__init__(pos) - - -class TGate(FixedSingleQubitGate): - name = "T" - matrix = np.array([[1., 0.], - [0., np.exp(1.j * np.pi / 4)]], dtype=complex) - - def __init__(self, pos: int): - super().__init__(pos) - - -class TdgGate(FixedSingleQubitGate): - name = "Tdg" - matrix = TGate.matrix.conj().T - - def __init__(self, pos: int): - super().__init__(pos) - - -class SXGate(FixedSingleQubitGate): - name = "SX" - matrix = np.array([[0.5 + 0.5j, 0.5 - 0.5j], - [0.5 - 0.5j, 0.5 + 0.5j]], dtype=complex) - - def __init__(self, pos: int): - super().__init__(pos) - - -class SXdgGate(FixedSingleQubitGate): - name = "SXdg" - matrix = SXGate.matrix.conj().T - - def __init__(self, pos: int): - super().__init__(pos) - self.symbol = "√X" - - -class SYGate(FixedSingleQubitGate): - name = "SY" - matrix = np.array([[0.5 + 0.5j, -0.5 - 0.5j], - [0.5 + 0.5j, 0.5 + 0.5j]], dtype=complex) - - def __init__(self, pos: int): - super().__init__(pos) - self.symbol = "√Y" - - -class SYdgGate(FixedSingleQubitGate): - name = "SYdg" - matrix = SYGate.matrix.conj().T - - def __init__(self, pos: int): - super().__init__(pos) - self.symbol = "√Y†" - - def to_qasm(self): - # TODO: this seems incorrect - return "ry(pi/2) q[%d]" % self.pos - - -FixedSingleQubitGate.register_gate(SGate) -FixedSingleQubitGate.register_gate(SdgGate) -FixedSingleQubitGate.register_gate(TGate) -FixedSingleQubitGate.register_gate(TdgGate) -FixedSingleQubitGate.register_gate(SXGate) -FixedSingleQubitGate.register_gate(SXdgGate) -FixedSingleQubitGate.register_gate(SYGate) -FixedSingleQubitGate.register_gate(SYdgGate) diff --git a/src/quafu/elements/quantum_element/instruction.py b/src/quafu/elements/quantum_element/instruction.py index 80897dc..1ccb6db 100644 --- a/src/quafu/elements/quantum_element/instruction.py +++ b/src/quafu/elements/quantum_element/instruction.py @@ -1,7 +1,25 @@ +# (C) Copyright 2023 Beijing Academy of Quantum Information Sciences +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + from abc import ABC, abstractmethod from typing import Union, List +PosType = Union[int, List[int]] +ParaType = dict[str, Union[float, int]] + + class Instruction(ABC): ins_classes = {} @@ -25,9 +43,10 @@ def register_ins(cls, subclass, name: str = None): if name in cls.ins_classes: raise ValueError(f"Name {name} already exists.") cls.ins_classes[name] = subclass - # @abstractmethod - # def openqasm2(self) -> str: - # pass + + def __init__(self, pos: PosType, paras: ParaType = None, *args, **kwargs): + self.pos = pos + self.paras = paras # @_ins_id.setter # def sd_name(self, name: str): @@ -53,5 +72,4 @@ def register_ins(cls, subclass, name: str = None): # return InstructionNode(name, pos, paras, duration, unit, channel, time_func, label) -PosType = Union[int, List[int]] -ParaType = dict[str, Union[float, int]] + diff --git a/src/quafu/elements/quantum_element/quantum_element.py b/src/quafu/elements/quantum_element/quantum_element.py index 83d93ae..f182fbe 100644 --- a/src/quafu/elements/quantum_element/quantum_element.py +++ b/src/quafu/elements/quantum_element/quantum_element.py @@ -24,7 +24,7 @@ class Barrier(Instruction): name = "barrier" def __init__(self, pos): - self.__pos = pos + super().__init__(pos) self.symbol = "||" @property @@ -50,8 +50,8 @@ def __init__(self, pos: int, duration: int, unit="ns"): self.duration = duration else: raise TypeError("duration must be int") + super().__init__(pos) self.unit = unit - self.pos = pos self.symbol = "Delay(%d%s)" % (duration, unit) def __repr__(self): @@ -69,8 +69,8 @@ def __init__(self, qs: int, qe: int, duration: int, unit="ns"): self.duration = duration else: raise TypeError("duration must be int") + super().__init__(list(range(qs, qe + 1))) self.unit = unit - self.pos = list(range(qs, qe + 1)) self.symbol = "XY(%d%s)" % (duration, unit) def to_qasm(self): @@ -82,6 +82,7 @@ class Measure(Instruction): name = "measure" def __init__(self, bitmap: dict): + super().__init__(list(bitmap.keys())) self.qbits = bitmap.keys() self.cbits = bitmap.values() diff --git a/src/quafu/elements/quantum_element/quantum_gate.py b/src/quafu/elements/quantum_element/quantum_gate.py index e349eef..174a33b 100644 --- a/src/quafu/elements/quantum_element/quantum_gate.py +++ b/src/quafu/elements/quantum_element/quantum_gate.py @@ -23,8 +23,7 @@ def __init__(self, pos: PosType, paras: Union[float, List[float]] = None, ): - self.pos = pos - self.paras = paras + super().__init__(pos, paras) if paras: if isinstance(paras, Iterable): @@ -132,20 +131,17 @@ class ControlledGate(MultiQubitGate, ABC): """ Controlled gate class, where the matrix act non-trivaly on target qubits""" def __init__(self, targe_name, ctrls: List[int], targs: List[int], paras, tar_matrix): + super().__init__(ctrls + targs, paras) self.ctrls = ctrls self.targs = targs self.targ_name = targe_name - super().__init__(ctrls + targs, paras) self._targ_matrix = tar_matrix # set matrix # TODO: change matrix according to control-type 0/1 - targ_dim = 2 ** (len(self.targs)) - ctrl_dim = 2 ** (len(self.ctrls)) - dim = targ_dim + ctrl_dim + targ_dim, ctrl_dim, dim = self.ct_dims self._matrix = np.eye(dim, dtype=complex) - control_dim = 2 ** len(self.pos) - targ_dim - self._matrix[control_dim:, control_dim:] = tar_matrix + self._matrix[ctrl_dim:, ctrl_dim:] = tar_matrix self._matrix = reorder_matrix(self._matrix, self.pos) if paras: @@ -161,6 +157,13 @@ def matrix(self): # TODO: update matrix when paras of controlled-gate changed return self._matrix + @property + def ct_dims(self): + targ_dim = 2 ** (len(self.targs)) + ctrl_dim = 2 ** (len(self.ctrls)) + dim = targ_dim + ctrl_dim + return ctrl_dim, targ_dim, dim + def get_targ_matrix(self, reverse_order=False): targ_matrix = self._targ_matrix if reverse_order and (len(self.targs) > 1): From a55094d467cedb03e7bce08d4abcfbe3795762c1 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 16:59:27 +0800 Subject: [PATCH 56/70] small adjustment --- src/quafu/elements/element_gates/c11.py | 17 ++++-- src/quafu/elements/element_gates/clifford.py | 53 ++++++++++++++++++ src/quafu/elements/element_gates/pauli.py | 58 ++++++++++++++++---- 3 files changed, 112 insertions(+), 16 deletions(-) create mode 100644 src/quafu/elements/element_gates/clifford.py diff --git a/src/quafu/elements/element_gates/c11.py b/src/quafu/elements/element_gates/c11.py index 9074290..78c9b62 100644 --- a/src/quafu/elements/element_gates/c11.py +++ b/src/quafu/elements/element_gates/c11.py @@ -1,8 +1,13 @@ from ..quantum_element import ControlledGate +from abc import ABC from .matrices import XMatrix, YMatrix, ZMatrix, SMatrix, TMatrix, pmatrix -class CXGate(ControlledGate): +class _C11Gate(ControlledGate, ABC): + ct_dims = (1, 1, 2) + + +class CXGate(_C11Gate): name = "CX" def __init__(self, ctrl: int, targ: int): @@ -10,21 +15,21 @@ def __init__(self, ctrl: int, targ: int): self.symbol = "+" -class CYGate(ControlledGate): +class CYGate(_C11Gate): name = "CY" def __init__(self, ctrl: int, targ: int): super().__init__("Y", [ctrl], [targ], None, tar_matrix=YMatrix) -class CZGate(ControlledGate): +class CZGate(_C11Gate): name = "CZ" def __init__(self, ctrl: int, targ: int): super().__init__("Z", [ctrl], [targ], None, tar_matrix=ZMatrix) -class CSGate(ControlledGate): +class CSGate(_C11Gate): name = "CS" def __init__(self, ctrl: int, targ: int): @@ -34,7 +39,7 @@ def to_qasm(self): return "cp(pi/2) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) -class CTGate(ControlledGate): +class CTGate(_C11Gate): name = "CT" def __init__(self, ctrl: int, targ: int): @@ -44,7 +49,7 @@ def to_qasm(self): return "cp(pi/4) " + "q[%d],q[%d]" % (self.pos[0], self.pos[1]) -class CPGate(ControlledGate): +class CPGate(_C11Gate): name = "CP" def __init__(self, ctrl: int, targ: int, paras): diff --git a/src/quafu/elements/element_gates/clifford.py b/src/quafu/elements/element_gates/clifford.py new file mode 100644 index 0000000..ea10936 --- /dev/null +++ b/src/quafu/elements/element_gates/clifford.py @@ -0,0 +1,53 @@ +import numpy as np + +from quafu.elements.element_gates.matrices import HMatrix +from quafu.elements.quantum_element import FixedSingleQubitGate + + +class HGate(FixedSingleQubitGate): + name = "H" + matrix = HMatrix + + def __init__(self, pos: int): + super().__init__(pos) + + +class SGate(FixedSingleQubitGate): + name = "S" + matrix = np.array([[1., 0.], + [0., 1.j]], dtype=complex) + + def __init__(self, pos: int): + super().__init__(pos) + + +class SdgGate(FixedSingleQubitGate): + name = "Sdg" + matrix = SGate.matrix.conj().T + + def __init__(self, pos: int): + super().__init__(pos) + + +class TGate(FixedSingleQubitGate): + name = "T" + matrix = np.array([[1., 0.], + [0., np.exp(1.j * np.pi / 4)]], dtype=complex) + + def __init__(self, pos: int): + super().__init__(pos) + + +class TdgGate(FixedSingleQubitGate): + name = "Tdg" + matrix = TGate.matrix.conj().T + + def __init__(self, pos: int): + super().__init__(pos) + + +FixedSingleQubitGate.register_gate(HGate) +FixedSingleQubitGate.register_gate(SGate) +FixedSingleQubitGate.register_gate(SdgGate) +FixedSingleQubitGate.register_gate(TGate) +FixedSingleQubitGate.register_gate(TdgGate) diff --git a/src/quafu/elements/element_gates/pauli.py b/src/quafu/elements/element_gates/pauli.py index 677deb0..9f513e6 100644 --- a/src/quafu/elements/element_gates/pauli.py +++ b/src/quafu/elements/element_gates/pauli.py @@ -1,4 +1,6 @@ -from .matrices import XMatrix, YMatrix, ZMatrix, HMatrix, WMatrix, SWMatrix +import numpy as np + +from .matrices import XMatrix, YMatrix, ZMatrix, WMatrix, SWMatrix from ..quantum_element import FixedSingleQubitGate @@ -10,14 +12,6 @@ def __init__(self, pos: int): super().__init__(pos) -class HGate(FixedSingleQubitGate): - name = "H" - matrix = HMatrix - - def __init__(self, pos: int): - super().__init__(pos) - - class XGate(FixedSingleQubitGate): name = "X" matrix = XMatrix @@ -66,10 +60,54 @@ def to_qasm(self): return "rz(-pi/4) q[%d];\nrx(pi/2) q[%d];\nrz(pi/4) q[%d]" % (self.pos, self.pos, self.pos) +class SXGate(FixedSingleQubitGate): + name = "SX" + matrix = np.array([[0.5 + 0.5j, 0.5 - 0.5j], + [0.5 - 0.5j, 0.5 + 0.5j]], dtype=complex) + + def __init__(self, pos: int): + super().__init__(pos) + + +class SXdgGate(FixedSingleQubitGate): + name = "SXdg" + matrix = SXGate.matrix.conj().T + + def __init__(self, pos: int): + super().__init__(pos) + self.symbol = "√X" + + +class SYGate(FixedSingleQubitGate): + name = "SY" + matrix = np.array([[0.5 + 0.5j, -0.5 - 0.5j], + [0.5 + 0.5j, 0.5 + 0.5j]], dtype=complex) + + def __init__(self, pos: int): + super().__init__(pos) + self.symbol = "√Y" + + +class SYdgGate(FixedSingleQubitGate): + name = "SYdg" + matrix = SYGate.matrix.conj().T + + def __init__(self, pos: int): + super().__init__(pos) + self.symbol = "√Y†" + + def to_qasm(self): + # TODO: this seems incorrect + return "ry(pi/2) q[%d]" % self.pos + + FixedSingleQubitGate.register_gate(IdGate) -FixedSingleQubitGate.register_gate(HGate) FixedSingleQubitGate.register_gate(XGate) FixedSingleQubitGate.register_gate(YGate) FixedSingleQubitGate.register_gate(ZGate) FixedSingleQubitGate.register_gate(WGate) FixedSingleQubitGate.register_gate(SWGate) +FixedSingleQubitGate.register_gate(SXGate) +FixedSingleQubitGate.register_gate(SXdgGate) +FixedSingleQubitGate.register_gate(SYGate) +FixedSingleQubitGate.register_gate(SYdgGate) From cb6be26954b3b5b5435af2c349a5bfc218db92fb Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Wed, 12 Jul 2023 17:46:41 +0800 Subject: [PATCH 57/70] circuitPlot.py almost finished (untested yet) --- src/quafu/circuits/quantum_circuit.py | 20 ++-- src/quafu/elements/element_gates/__init__.py | 11 +- src/quafu/elements/element_gates/cm1.py | 21 +++- .../elements/quantum_element/quantum_gate.py | 19 --- src/quafu/visualisation/circuitPlot.py | 111 ++++++++++++------ 5 files changed, 113 insertions(+), 69 deletions(-) diff --git a/src/quafu/circuits/quantum_circuit.py b/src/quafu/circuits/quantum_circuit.py index 1f31c3a..9dc1a7d 100644 --- a/src/quafu/circuits/quantum_circuit.py +++ b/src/quafu/circuits/quantum_circuit.py @@ -1,6 +1,8 @@ from typing import List import numpy as np +import quafu.elements.element_gates.clifford +import quafu.elements.element_gates.pauli from quafu.elements.quantum_element.pulses.quantum_pulse import QuantumPulse from ..elements.quantum_element import Barrier, Delay, MultiQubitGate, QuantumGate, ControlledGate, \ SingleQubitGate, XYResonance @@ -354,7 +356,7 @@ def h(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - gate = qeg.HGate(pos) + gate = quafu.elements.element_gates.clifford.HGate(pos) self.add_gate(gate) return self @@ -397,7 +399,7 @@ def t(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.add_gate(qeg.TGate(pos)) + self.add_gate(quafu.elements.element_gates.clifford.TGate(pos)) return self def tdg(self, pos: int) -> "QuantumCircuit": @@ -407,7 +409,7 @@ def tdg(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.add_gate(qeg.TdgGate(pos)) + self.add_gate(quafu.elements.element_gates.clifford.TdgGate(pos)) return self def s(self, pos: int) -> "QuantumCircuit": @@ -417,7 +419,7 @@ def s(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.add_gate(qeg.SGate(pos)) + self.add_gate(quafu.elements.element_gates.clifford.SGate(pos)) return self def sdg(self, pos: int) -> "QuantumCircuit": @@ -427,7 +429,7 @@ def sdg(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.add_gate(qeg.SdgGate(pos)) + self.add_gate(quafu.elements.element_gates.clifford.SdgGate(pos)) return self def sx(self, pos: int) -> "QuantumCircuit": @@ -437,7 +439,7 @@ def sx(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.add_gate(qeg.SXGate(pos)) + self.add_gate(quafu.elements.element_gates.pauli.SXGate(pos)) return self def sxdg(self, pos: int) -> "QuantumCircuit": @@ -447,7 +449,7 @@ def sxdg(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - gate = qeg.SXdgGate(pos) + gate = quafu.elements.element_gates.pauli.SXdgGate(pos) self.add_gate(gate) return self @@ -458,7 +460,7 @@ def sy(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - self.add_gate(qeg.SYGate(pos)) + self.add_gate(quafu.elements.element_gates.pauli.SYGate(pos)) return self def sydg(self, pos: int) -> "QuantumCircuit": @@ -468,7 +470,7 @@ def sydg(self, pos: int) -> "QuantumCircuit": Args: pos (int): qubit the gate act. """ - gate = qeg.SYdgGate(pos) + gate = quafu.elements.element_gates.pauli.SYdgGate(pos) self.add_gate(gate) return self diff --git a/src/quafu/elements/element_gates/__init__.py b/src/quafu/elements/element_gates/__init__.py index fd88efa..434d0e6 100644 --- a/src/quafu/elements/element_gates/__init__.py +++ b/src/quafu/elements/element_gates/__init__.py @@ -1,21 +1,20 @@ -from .pauli import XGate, YGate, ZGate, HGate, IdGate, WGate, SWGate +from .pauli import XGate, YGate, ZGate, IdGate, WGate, SWGate, SXGate, SXdgGate, SYGate, SYdgGate +from .clifford import HGate, SGate, SdgGate, TGate, TdgGate from .phase import PhaseGate from .rotation import RXGate, RYGate, RZGate, RXXGate, RYYGate, RZZGate from .swap import SwapGate, ISwapGate -from .sqrt import SXGate, SXdgGate, SYGate, SYdgGate, SGate, SdgGate, TGate, TdgGate from .c11 import CXGate, CYGate, CZGate, CSGate, CTGate, CPGate from .c21 import ToffoliGate from .c12 import FredkinGate -from .cm1 import MCXGate, MCYGate, MCZGate +from .cm1 import MCXGate, MCYGate, MCZGate, ControlledU from .unitary import UnitaryDecomposer -__all__ = ['XGate', 'YGate', 'ZGate', 'HGate', 'IdGate', 'WGate', 'SWGate', - 'SXGate', 'SXdgGate', 'SYGate', 'SYdgGate', 'SGate', 'SdgGate', 'TGate', 'TdgGate', +__all__ = ['XGate', 'YGate', 'ZGate', 'IdGate', 'WGate', 'SWGate', 'PhaseGate', 'RXGate', 'RYGate', 'RZGate', 'RXXGate', 'RYYGate', 'RZZGate', 'SwapGate', 'ISwapGate', 'CXGate', 'CYGate', 'CZGate', 'CSGate', 'CTGate', 'CPGate', 'ToffoliGate', 'FredkinGate', - 'MCXGate', 'MCYGate', 'MCZGate', + 'MCXGate', 'MCYGate', 'MCZGate', 'ControlledU', 'UnitaryDecomposer'] diff --git a/src/quafu/elements/element_gates/cm1.py b/src/quafu/elements/element_gates/cm1.py index c00f244..231d24b 100644 --- a/src/quafu/elements/element_gates/cm1.py +++ b/src/quafu/elements/element_gates/cm1.py @@ -1,5 +1,7 @@ +from typing import List, Union + from .matrices import XMatrix, YMatrix, ZMatrix -from ..quantum_element import ControlledGate +from ..quantum_element import ControlledGate, SingleQubitGate, MultiQubitGate class MCXGate(ControlledGate): @@ -23,6 +25,23 @@ def __init__(self, ctrls, targ: int): super().__init__("Z", ctrls, [targ], None, tar_matrix=ZMatrix) +class ControlledU(ControlledGate): + """ Controlled gate class, where the matrix act non-trivially on target qubits""" + name = 'CU' + + def __init__(self, ctrls: List[int], u: Union[SingleQubitGate, MultiQubitGate]): + self.targ_gate = u + targs = u.pos + if isinstance(targs, int): + targs = [targs] + + super().__init__(u.name, ctrls, targs, u.paras, tar_matrix=self.targ_gate.get_targ_matrix()) + + def get_targ_matrix(self, reverse_order=False): + return self.targ_gate.get_targ_matrix(reverse_order) + + ControlledGate.register_gate(MCXGate) ControlledGate.register_gate(MCYGate) ControlledGate.register_gate(MCZGate) +ControlledGate.register_gate(ControlledU) diff --git a/src/quafu/elements/quantum_element/quantum_gate.py b/src/quafu/elements/quantum_element/quantum_gate.py index 174a33b..b0609ad 100644 --- a/src/quafu/elements/quantum_element/quantum_gate.py +++ b/src/quafu/elements/quantum_element/quantum_gate.py @@ -174,22 +174,3 @@ def get_targ_matrix(self, reverse_order=False): tensorm = targ_matrix.reshape([2] * 2 * qnum) targ_matrix = np.transpose(tensorm, order).reshape([dim, dim]) return targ_matrix - - -class ControlledU(ControlledGate): - """ Controlled gate class, where the matrix act non-trivially on target qubits""" - name = 'CU' - - def __init__(self, ctrls: List[int], u: Union[SingleQubitGate, MultiQubitGate]): - self.targ_gate = u - targs = u.pos - if isinstance(targs, int): - targs = [targs] - - super().__init__(u.name, ctrls, targs, u.paras, tar_matrix=self.targ_gate.get_targ_matrix()) - - def get_targ_matrix(self, reverse_order=False): - return self.targ_gate.get_targ_matrix(reverse_order) - - -QuantumGate.register_gate(ControlledU) diff --git a/src/quafu/visualisation/circuitPlot.py b/src/quafu/visualisation/circuitPlot.py index 995009d..dafd264 100644 --- a/src/quafu/visualisation/circuitPlot.py +++ b/src/quafu/visualisation/circuitPlot.py @@ -1,11 +1,17 @@ -# from quafu.circuits.quantum_circuit import QuantumCircuit -import numpy as np import matplotlib.patheffects as pe import matplotlib.pyplot as plt +import numpy as np from matplotlib.collections import PolyCollection, PatchCollection, LineCollection from matplotlib.patches import Circle, Arc from matplotlib.text import Text +from quafu.elements.quantum_element import Instruction, ControlledGate + +for name, cls in Instruction.ins_classes.items(): + print(name, cls.__name__) + +# the following line for developers only +# from quafu.circuits.quantum_circuit import QuantumCircuit line_args = {} box_args = {} @@ -38,7 +44,7 @@ r2_gate_names = ['rxx', 'ryy', 'rzz'] c2_gate_names = ['cp', 'cs', 'ct', 'cx', 'cy', 'cz'] c3_gate_names = ['fredkin', 'toffoli'] -cm_gate_names = ['mcx', 'mcy', 'mcz'] +mc_gate_names = ['mcx', 'mcy', 'mcz'] operation_names = ['barrier', 'delay'] @@ -91,29 +97,12 @@ def __init__(self, qc): self._text_list = [] # step1: process gates/instructions - dorders = np.zeros(qc.num, dtype=int) + self.dorders = np.zeros(qc.num, dtype=int) for gate in qc.gates: - id_name = gate.name.lower() - _which = slice(np.min(gate.pos), np.max(gate.pos) + 1) - depth = np.max(dorders[_which]) - paras = getattr(gate, 'paras', None) - - # TODO: call processing functions - if id_name == 'barrier': - self._proc_barrier(depth, gate.pos) - elif id_name == 'measure': - self._proc_measure(depth, gate.pos) - elif id_name in su2_gate_names: - self._proc_su2(id_name, depth, gate.pos, paras) - elif id_name == 'swap': - self._proc_swap(depth, gate.pos) - elif id_name == 'cx': - self._proc_ctrl(depth, gate.ctrls[0], gate.targs[0], 'x') - else: - # control - raise NotImplementedError(f'Gate {id_name} is not supported yet.') - dorders[_which] = depth + 1 - self.depth = np.max(dorders) + 1 + assert isinstance(gate, Instruction) + self._process_ins(gate) + + self.depth = np.max(self.dorders) + 1 for q, c in qc.measures.items(): self._proc_measure(self.depth - 1, q) @@ -127,7 +116,12 @@ def __init__(self, qc): self.ys = np.arange(-2, self.qbit_num + 1 / 2) def __call__(self, - title=None, *args, **kwargs): + title=None, + init_labels=None, + end_labels=None, + save_path: str = None, + *args, + **kwargs): """ """ @@ -159,6 +153,35 @@ def __call__(self, self._measured_label() self._render_circuit() + def _process_ins(self, ins: Instruction, append: bool = True): + name = ins.name + assert name in Instruction.ins_classes, 'If this should occur, please report a bug.' + + name = name.lower() + _which = slice(np.min(ins.pos), np.max(ins.pos) + 1) + depth = np.max(self.dorders[_which]) + paras = ins.paras + + if name == 'barrier': + self._proc_barrier(depth, ins.pos) + elif name == 'measure': + self._proc_measure(depth, ins.pos) + elif name in su2_gate_names: + self._proc_su2(name, depth, ins.pos, paras) + elif name in swap_gate_names: + self._proc_swap(depth, ins.pos, name == 'iswap') + elif name in r2_gate_names: + # TODO: combine into one box + self._proc_su2(name[-1], depth, ins.pos[0], paras) + self._proc_su2(name[-1], depth, ins.pos[1], paras) + elif isinstance(ins, ControlledGate): + self._proc_ctrl(depth, ins) + else: + raise NotImplementedError(f'Gate {name} is not supported yet.\n' + f'If this should occur, please report a bug.') + if append: + self.dorders[_which] = depth + 1 + ######################################################################### # Helper functions for processing gates/instructions into graphical # elements. Add only points data of for the following collection-wise @@ -234,7 +257,7 @@ def _para_label(self, para_txt, x, y): if not para_txt: return None _dx = 0 - text = Text(x + _dx, y+0.7*self._a, + text = Text(x + _dx, y + 0.7 * self._a, para_txt, size=12, color=DEEPCOLOR, @@ -303,18 +326,38 @@ def _proc_su2(self, id_name, depth, pos, paras): self._para_label(para_txt, depth, pos) self._gate_bbox(depth, pos, fc) - def _proc_ctrl(self, depth, ctrl_pos, tar_pos, tar_name, ctrl_type: bool = True): - if tar_name == 'x': - self._ctrl_points.append((depth, ctrl_pos, ctrl_type)) - self._ctrl_wire_points.append([[depth, ctrl_pos], [depth, tar_pos]]) - self._not_points.append((depth, tar_pos)) + def _proc_ctrl(self, depth, ins: ControlledGate, ctrl_type: bool = True): + # control part + p0, p1 = np.max(ins.pos), np.min(ins.pos) + self._ctrl_wire_points.append([[depth, p1], [depth, p0]]) + + ctrl_pos = np.array(ins.ctrls) + for c in ctrl_pos: + self._ctrl_points.append((depth, c, ctrl_type)) + + # target part + if ins.ct_dims == (1, 1, 2) or ins.name in mc_gate_names: + tar_name = ins.targ_name[-1] + if tar_name == 'x': + self._not_points.append((depth, ins.targs)) + else: + self._proc_su2(tar_name, depth, ins.targs, None) + elif ins.name == 'cswap': + self._swap_points += [[depth, p] for p in ins.targs] + elif ins.name == 'ccx': + self._not_points.append((depth, ins.targs)) else: - raise NotImplemented + from quafu.elements.element_gates import ControlledU + assert isinstance(ins, ControlledU) + self._process_ins(ins, append=False) - def _proc_swap(self, depth, pos): + def _proc_swap(self, depth, pos, iswap: bool = False): p1, p2 = pos self._swap_points += [[depth, p] for p in pos] self._ctrl_wire_points.append([[depth, p1], [depth, p2]]) + if iswap: + # TODO: add circle on swap node + raise NotImplementedError def _proc_barrier(self, depth, pos: list): x0 = depth - self._barrier_width From 11639ded37d829d87fe55bdf5a91dc2df0771b4c Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Thu, 13 Jul 2023 10:57:08 +0800 Subject: [PATCH 58/70] fix some problem during benchmarking Customized labeling of bits allowed, see new example adder.py for details. --- .../elements/quantum_element/quantum_gate.py | 15 ++++---- src/quafu/visualisation/circuitPlot.py | 35 +++++++++---------- 2 files changed, 26 insertions(+), 24 deletions(-) diff --git a/src/quafu/elements/quantum_element/quantum_gate.py b/src/quafu/elements/quantum_element/quantum_gate.py index b0609ad..1b36f8a 100644 --- a/src/quafu/elements/quantum_element/quantum_gate.py +++ b/src/quafu/elements/quantum_element/quantum_gate.py @@ -139,7 +139,10 @@ def __init__(self, targe_name, ctrls: List[int], targs: List[int], paras, tar_ma # set matrix # TODO: change matrix according to control-type 0/1 - targ_dim, ctrl_dim, dim = self.ct_dims + c_n, t_n, n = self.ct_nums + targ_dim = 2 ** t_n + dim = 2 ** n + ctrl_dim = dim - targ_dim self._matrix = np.eye(dim, dtype=complex) self._matrix[ctrl_dim:, ctrl_dim:] = tar_matrix self._matrix = reorder_matrix(self._matrix, self.pos) @@ -158,11 +161,11 @@ def matrix(self): return self._matrix @property - def ct_dims(self): - targ_dim = 2 ** (len(self.targs)) - ctrl_dim = 2 ** (len(self.ctrls)) - dim = targ_dim + ctrl_dim - return ctrl_dim, targ_dim, dim + def ct_nums(self): + targ_num = len(self.targs) + ctrl_num = len(self.ctrls) + num = targ_num + ctrl_num + return ctrl_num, targ_num, num def get_targ_matrix(self, reverse_order=False): targ_matrix = self._targ_matrix diff --git a/src/quafu/visualisation/circuitPlot.py b/src/quafu/visualisation/circuitPlot.py index dafd264..8a114aa 100644 --- a/src/quafu/visualisation/circuitPlot.py +++ b/src/quafu/visualisation/circuitPlot.py @@ -7,9 +7,6 @@ from quafu.elements.quantum_element import Instruction, ControlledGate -for name, cls in Instruction.ins_classes.items(): - print(name, cls.__name__) - # the following line for developers only # from quafu.circuits.quantum_circuit import QuantumCircuit @@ -108,8 +105,8 @@ def __init__(self, qc): self._proc_measure(self.depth - 1, q) # step2: initialize bit-label - self.q_label = [f'q_{i}' for i in range(qc.num)] - self.c_label = [f'c_{i}' for i in qc.measures.values()] + self.q_label = {i: f'q_{i}' for i in range(qc.num)} + self.c_label = {iq: f'c_{ic}' for iq, ic in qc.measures.items()} # step3: figure coordination self.xs = np.arange(-3 / 2, self.depth + 3 / 2) @@ -149,8 +146,8 @@ def __call__(self, ax.invert_yaxis() self._circuit_wires() - self._inits_label() - self._measured_label() + self._inits_label(labels=init_labels) + self._measured_label(labels=end_labels) self._render_circuit() def _process_ins(self, ins: Instruction, append: bool = True): @@ -206,12 +203,12 @@ def _gate_bbox(self, x, y, fc: str): ) self._closed_patches.append(bbox) - def _inits_label(self, labels: list[int] = None): + def _inits_label(self, labels: dict[int: str] = None): """ qubit-labeling """ if labels is None: labels = self.q_label - for i, label in enumerate(labels): + for i, label in labels.items(): label = r'$|%s\rangle$' % label txt = Text(-2 / 3, i, label, @@ -222,12 +219,12 @@ def _inits_label(self, labels: list[int] = None): ) self._text_list.append(txt) - def _measured_label(self, labels: list[int] = None): + def _measured_label(self, labels: dict[int: str] = None): """ measured qubit-labeling """ if labels is None: labels = self.c_label - for i, label in enumerate(labels): + for i, label in labels.items(): label = r'$%s$' % label txt = Text(self.xs[-1] - 3 / 4, i, label, @@ -336,19 +333,21 @@ def _proc_ctrl(self, depth, ins: ControlledGate, ctrl_type: bool = True): self._ctrl_points.append((depth, c, ctrl_type)) # target part - if ins.ct_dims == (1, 1, 2) or ins.name in mc_gate_names: - tar_name = ins.targ_name[-1] + name = ins.name.lower() + if ins.ct_nums == (1, 1, 2) or name in mc_gate_names: + tar_name = ins.targ_name.lower()[-1] + pos = ins.targs if isinstance(ins.targs, int) else ins.targs[0] if tar_name == 'x': - self._not_points.append((depth, ins.targs)) + self._not_points.append((depth, pos)) else: - self._proc_su2(tar_name, depth, ins.targs, None) - elif ins.name == 'cswap': + self._proc_su2(tar_name, depth, pos, None) + elif name == 'cswap': self._swap_points += [[depth, p] for p in ins.targs] - elif ins.name == 'ccx': + elif name == 'ccx': self._not_points.append((depth, ins.targs)) else: from quafu.elements.element_gates import ControlledU - assert isinstance(ins, ControlledU) + assert isinstance(ins, ControlledU), f'unknown gate: {name}, {ins.__class__.__name__}' self._process_ins(ins, append=False) def _proc_swap(self, depth, pos, iswap: bool = False): From c2b05326d98660077f35c40c6c6c92ff3b66a3fc Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Fri, 14 Jul 2023 09:51:03 +0800 Subject: [PATCH 59/70] add cx() as alley of cnot() --- src/quafu/circuits/quantum_circuit.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/quafu/circuits/quantum_circuit.py b/src/quafu/circuits/quantum_circuit.py index 9dc1a7d..ba946a4 100644 --- a/src/quafu/circuits/quantum_circuit.py +++ b/src/quafu/circuits/quantum_circuit.py @@ -549,6 +549,9 @@ def cnot(self, ctrl: int, tar: int) -> "QuantumCircuit": self.add_gate(qeg.CXGate(ctrl, tar)) return self + def cx(self, ctrl: int, tar: int) -> "QuantumCircuit": + return self.cnot(ctrl=ctrl, tar=tar) + def cy(self, ctrl: int, tar: int) -> "QuantumCircuit": """ Control-Y gate. From fd7a3ffb715582a22f16981b490d8b82215ccd10 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Fri, 14 Jul 2023 10:26:24 +0800 Subject: [PATCH 60/70] fix 2 known problem, add another testbench 1. Use 'if xxx is not None' instead of 'if xxx'. 2. Fix overlapping of parameter text on plot. --- src/quafu/benchmark/adder.py | 126 ++++++++++++++++++ src/quafu/benchmark/variational_n4.py | 91 +++++++++++++ .../elements/quantum_element/quantum_gate.py | 12 +- src/quafu/visualisation/circuitPlot.py | 11 +- 4 files changed, 234 insertions(+), 6 deletions(-) create mode 100644 src/quafu/benchmark/adder.py create mode 100644 src/quafu/benchmark/variational_n4.py diff --git a/src/quafu/benchmark/adder.py b/src/quafu/benchmark/adder.py new file mode 100644 index 0000000..9e4ad37 --- /dev/null +++ b/src/quafu/benchmark/adder.py @@ -0,0 +1,126 @@ +from quafu.circuits.quantum_circuit import QuantumCircuit +import matplotlib.pyplot as plt + +""" +// quantum ripple-carry adder from Cuccaro et al, quant-ph/0410184 +OPENQASM 2.0; +include "qelib1.inc"; +""" + +n = 10 +qc = QuantumCircuit(n) + + +def majority(a, b, c): + """ + gate majority a,b,c + { + cx c,b; + cx c,a; + ccx a,b,c; + } + """ + qc.cnot(c, b) + qc.cnot(a, b) + qc.mcx([a, b], c) + + +def unmaj(a, b, c): + """ + gate unmaj a,b,c + { + ccx a,b,c; + cx c,a; + cx a,b; + } + """ + qc.mcx([a, b], c) + qc.cnot(c, a) + qc.cnot(a, b) + + +def qreg(_i, name): + """ + qreg cin[1]; + qreg a[4]; + qreg b[4]; + qreg cout[1]; + """ + if name == 'cin': + return _i + elif name == 'a': + return _i + 1 + elif name == 'b': + return _i + 5 + elif name == 'cout': + return _i + 9 + else: + raise ValueError('Unknown qreg name: {}'.format(name)) + + +def creg(_i, name): + """ + creg ans[5]; + """ + if name == 'ans': + return _i + else: + raise ValueError('Unknown creg name: {}'.format(name)) + + +""" +// set input states +x a[0]; // a = 0001 +x b; // b = 1111 +""" +qc.x(qreg(0, 'a')) +for i in range(4): + qc.x(qreg(i, 'b')) + +""" +// add a to b, storing result in b +majority cin[0],b[0],a[0]; +majority a[0],b[1],a[1]; +majority a[1],b[2],a[2]; +majority a[2],b[3],a[3]; +cx a[3],cout[0]; +unmaj a[2],b[3],a[3]; +unmaj a[1],b[2],a[2]; +unmaj a[0],b[1],a[1]; +unmaj cin[0],b[0],a[0]; +""" +majority(qreg(0, 'cin'), qreg(0, 'b'), qreg(0, 'a')) +majority(qreg(0, 'a'), qreg(1, 'b'), qreg(1, 'a')) +for i in range(1, 4): + majority(qreg(i-1, 'a'), qreg(i, 'b'), qreg(i, 'a')) +qc.cnot(qreg(3, 'a'), qreg(0, 'cout')) +unmaj(qreg(2, 'a'), qreg(3, 'b'), qreg(3, 'a')) +unmaj(qreg(1, 'a'), qreg(2, 'b'), qreg(2, 'a')) +unmaj(qreg(0, 'a'), qreg(1, 'b'), qreg(1, 'a')) + +""" +measure b[0] -> ans[0]; +measure b[1] -> ans[1]; +measure b[2] -> ans[2]; +measure b[3] -> ans[3]; +measure cout[0] -> ans[4]; +""" +measure_pos = [qreg(i, 'b') for i in range(4)] + [qreg(0, 'cout')] +measure_cbits = [creg(i, 'ans') for i in range(5)] +qc.measure(measure_pos, cbits=measure_cbits) +# qc.draw_circuit() +# print(qc.to_openqasm()) + +init_labels = dict.fromkeys(range(n)) +init_labels[0] = 'cin' +for i in range(4): + init_labels[i+1] = f'a_{i}' +for i in range(5): + init_labels[i+5] = f'b_{i}' + +end_labels = {i+5: f'ans_{i}' for i in range(5)} +qc.plot_circuit(title='Quantum ripple-carry adder', + init_labels=init_labels, + end_labels=end_labels, + ) +plt.show() diff --git a/src/quafu/benchmark/variational_n4.py b/src/quafu/benchmark/variational_n4.py new file mode 100644 index 0000000..f6213a6 --- /dev/null +++ b/src/quafu/benchmark/variational_n4.py @@ -0,0 +1,91 @@ +from quafu import QuantumCircuit + +n = 4 +qc = QuantumCircuit(n) + +qasm = """ +// Generated from Cirq v0.8.0 + +OPENQASM 2.0; +include "qelib1.inc"; + +// Qubits: [0, 1, 2, 3] +qreg q[4]; +creg c[4]; + +x q[0]; +x q[1]; + +// Gate: PhasedISWAP**0.9951774602384953 +rz(pi*0.25) q[1]; +rz(pi*-0.25) q[2]; +cx q[1],q[2]; +h q[1]; +cx q[2],q[1]; +rz(pi*0.4975887301) q[1]; +cx q[2],q[1]; +rz(pi*-0.4975887301) q[1]; +h q[1]; +cx q[1],q[2]; +rz(pi*-0.25) q[1]; +rz(pi*0.25) q[2]; + +rz(0) q[2]; + +// Gate: PhasedISWAP**-0.5024296754026449 +rz(pi*0.25) q[0]; +rz(pi*-0.25) q[1]; +cx q[0],q[1]; +h q[0]; +cx q[1],q[0]; +rz(pi*-0.2512148377) q[0]; +cx q[1],q[0]; +rz(pi*0.2512148377) q[0]; +h q[0]; +cx q[0],q[1]; +rz(pi*-0.25) q[0]; +rz(pi*0.25) q[1]; + +rz(0) q[1]; + +// Gate: PhasedISWAP**-0.49760685888033646 +rz(pi*0.25) q[2]; +rz(pi*-0.25) q[3]; +cx q[2],q[3]; +h q[2]; +cx q[3],q[2]; +rz(pi*-0.2488034294) q[2]; +cx q[3],q[2]; +rz(pi*0.2488034294) q[2]; +h q[2]; +cx q[2],q[3]; +rz(pi*-0.25) q[2]; +rz(pi*0.25) q[3]; + +rz(0) q[3]; + +// Gate: PhasedISWAP**0.004822678143889672 +rz(pi*0.25) q[1]; +rz(pi*-0.25) q[2]; +cx q[1],q[2]; +h q[1]; +cx q[2],q[1]; +rz(pi*0.0024113391) q[1]; +cx q[2],q[1]; +rz(pi*-0.0024113391) q[1]; +h q[1]; +cx q[1],q[2]; +rz(pi*-0.25) q[1]; +rz(pi*0.25) q[2]; + +rz(0) q[2]; + +measure q[0] -> c[0]; +measure q[1] -> c[1]; +measure q[2] -> c[2]; +measure q[3] -> c[3]; +""" + +qc.from_openqasm(qasm) +qc.draw_circuit() +qc.plot_circuit(show=True, title='Variational n4') diff --git a/src/quafu/elements/quantum_element/quantum_gate.py b/src/quafu/elements/quantum_element/quantum_gate.py index 1b36f8a..5b60236 100644 --- a/src/quafu/elements/quantum_element/quantum_gate.py +++ b/src/quafu/elements/quantum_element/quantum_gate.py @@ -25,7 +25,7 @@ def __init__(self, ): super().__init__(pos, paras) - if paras: + if paras is not None: if isinstance(paras, Iterable): self.symbol = "%s(" % self.name + ",".join(["%.3f" % para for para in self.paras]) + ")" else: @@ -105,8 +105,12 @@ class ParaSingleQubitGate(SingleQubitGate, ABC): def __init__(self, pos, paras: float): if paras is None: raise ValueError("`paras` can not be None for ParaSingleQubitGate") - elif not isinstance(paras, float): - raise TypeError("`paras` must be float for ParaSingleQubitGate") + elif isinstance(paras, int): + paras = float(paras) + print(paras) + + if not isinstance(paras, float): + raise TypeError(f"`paras` must be float or int for ParaSingleQubitGate, instead of {type(paras)}") super().__init__(pos, paras=paras) @@ -147,7 +151,7 @@ def __init__(self, targe_name, ctrls: List[int], targs: List[int], paras, tar_ma self._matrix[ctrl_dim:, ctrl_dim:] = tar_matrix self._matrix = reorder_matrix(self._matrix, self.pos) - if paras: + if paras is not None: if isinstance(paras, Iterable): self.symbol = "%s(" % self.targ_name + ",".join(["%.3f" % para for para in self.paras]) + ")" else: diff --git a/src/quafu/visualisation/circuitPlot.py b/src/quafu/visualisation/circuitPlot.py index 8a114aa..3012bbc 100644 --- a/src/quafu/visualisation/circuitPlot.py +++ b/src/quafu/visualisation/circuitPlot.py @@ -117,6 +117,7 @@ def __call__(self, init_labels=None, end_labels=None, save_path: str = None, + show: bool = False, *args, **kwargs): """ @@ -150,6 +151,11 @@ def __call__(self, self._measured_label(labels=end_labels) self._render_circuit() + if save_path is not None: + plt.savefig(save_path, dpi=300, bbox_inches='tight') + if show: + plt.show() + def _process_ins(self, ins: Instruction, append: bool = True): name = ins.name assert name in Instruction.ins_classes, 'If this should occur, please report a bug.' @@ -254,7 +260,7 @@ def _para_label(self, para_txt, x, y): if not para_txt: return None _dx = 0 - text = Text(x + _dx, y + 0.7 * self._a, + text = Text(x + _dx, y + 0.8 * self._a, para_txt, size=12, color=DEEPCOLOR, @@ -315,7 +321,8 @@ def _proc_su2(self, id_name, depth, pos, paras): label = '?' if id_name in ['rx', 'ry', 'rz', 'p']: - para_txt = r'$\theta=$' + f'{paras:.3f}' + # too long to display: r'$\theta=$' + f'{paras:.3f}' (TODO) + para_txt = f'({paras:.3f})' else: para_txt = None From 59faa18a7a8ec8f8202a33d934fb5920c86f7087 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Fri, 14 Jul 2023 10:26:52 +0800 Subject: [PATCH 61/70] fix 2 known problem, add another testbench 1. Use 'if xxx is not None' instead of 'if xxx'. 2. Fix overlapping of parameter text on plot. --- src/quafu/visualisation/figures/test.png | Bin 284254 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 src/quafu/visualisation/figures/test.png diff --git a/src/quafu/visualisation/figures/test.png b/src/quafu/visualisation/figures/test.png deleted file mode 100644 index a53e5b036f3860cbfd91ad5d9f5df7ff3a6da26d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 284254 zcmeGEX;@R&*FKKZ!Sb;pRH*|MLCb+CqkxJShFYo^nXGsiWD*dlf}nvA!srMp2y((G zL+Xg0Frz>cASjcEv5E)?0mT5yaL^!x7)X9Q>hnDPzWTrYzxZ%ny)aY{d#}CL+V{HG zz0T!>_SP$Z{N+bEIk}aj{eK*ilT(XQb-+#Pt&`N3J_wRm+T(PNk z%YU|P{C*k7<+r%M&zxJcMrZHtU;p###-Fz?*W0w?@aCVsz0rH{+pUmL*isn%eFS~V zHR?tFL!m|2o2&*aqptRc!_*?zig~g7>|v@rSi=8)_0`mlDgN&#*&m1(%m1Gr*#6=A z|NINBn}y%~`yVL(`2wu|f4|OL-U6)le_!=~q*4CwlbqbqUt4$o`}4L{ejES&IqTAY zfBpa2Jj{nz#WZH@m1-oLEz-?Z~DW61qC>Hgaq|GjelZH@n4xc|1sf8oZz zt?^&D@o#JV|0UcwI>1C5P}GFokw@hn?y0a|6q!fiHL`VwGEw>Dg_zc|(D94B+i3E} z50dCtgEWB7`?CLkfbi6q|EU6^4#80b))7PpV!0!2`jzMDxq)RHv-oEqf~M(fg#i;J zS{ozKRq1?X($Fw(c;F@DTe+ju`)H^pD>7bOX`{*d=)*Y}FRlvB_Z}c(LL|3(fjev~ zxCk+91R@3DY4!br*SG{*yirjJhOrHOrovhPHjwb6kvcYf5o1n&b$`(o%4bpJBdjB{djie$~x|Jr{Gjei4 z_V7l8zm^nS+E<)^<3h!s@?-MC=mdy0p*C+?geH>&^H9hE!ChSP@!1Vo^>Vc7tAVm$ zn70Y5r4Jfo7o8)}7~`MM1gG&+Np&8ufsJ4hDw)9@og;$f&TPDe>eKl+DRw6|hdjUH zz;Z^~3@XJ2M$tx?4YC+TKS&tZcn~d0#Eeew&9{4Lf>|E! zF=n3NvKr*%3V(+^wqTQpnHDib{}BsWgc0H49@?0qtOl;{9KUZU+mxIwiYguugply+ za}A7Z{5K@vV$)6GzavX@aKL9tiX?$DNq^f1mU-NEnU2vvQlna4$3}_tRt}A z4!Sx`O^`Y>`8lETpB*y5@k?2K)F_dVE~O%q4q;EaG)0W2`3#6LjSn5om^B~|MwWR{ z&YAT(kpF-;zThz!uOj5+Do}JlQ`7~?+eW|bMxwW4L^|-vvc%~`QeEbaQ%gLB*|m!8 zrJp*^lJv9rg2ZWp(O_I2btFi(kI^~@g$i#|vuMDs(aVZwb*rJ`6wnI28~AdOqFHp0{SzmS46Zk&n9fyT48%shMX zni^A|PZ8c3@06`As^be&AoFC!*0IFh1)4N_q>Ump=ZNRp)>7tgb1a|pxcU6mB(==f z$MH6{PyFM~y@ciRa-~h^#1QcG9D|A6>-@bWMH})5T=Ec?%&c5X>2#tpUhrlnaqc8e z)MWjIc-afawk9jdekb#PoaF9dSd$jJ)A_k*80wwC<->&m1*FOVUd-=Q%bnOLz2=m1 z0vqfN?un&;|D9aluP|j6>N-#^)KUyR5ug53+)YkgF(>6M-mSGfVl7)7$XiOo>u5-z ze>Hc!Z$TCV=U;T{oEvl|m-nl)}Espa$c z@nW7Id$jXD$Fhf~gq1#fLmcb;Oa^_;LArNP{dB&ojiNLXaia(W2}utg;1U;P13~l_ zNmu~h{^CL^So7=qDo!_Cn=_3Ex#ssdz2s#%cq|p!peect4PQ6?Oh0k5zNVbE$P>tS znd^lePy$6rBy?76;`WsW4T7r zA4>V@{OhFT+^4MRfi6-5VE6UHMLc%C(befDXE>X$l)0WAhqO4T%F7)+4pYu6_@$TGlgKIH8f#3g zbfYy zbvgVCke59<2=PT0Ly#(p@U$BvGC*cJRxrYF3Cgr3-+<%^rrWSs(!3q{L_9aAyJ}`M zL7Jc3vF-9=AH>jSvKk)gva-j??BEZa(`3!{&=DAUGGqg@nTGjWrO%rBQ$I;5J3z(vOA)rNee+z zD8l=0V#g_$l-AP7b{Fn*-f-^jc5RCAI6U_^q~7s9a^T(pK{Z5mBW?44&3r71c^6*`T_Qx3w;_T*ZH-U5a#IU5@H z43hVcn2Gi+i?P5sNR2T@&BuZO0;p)vEjEJKno4T~y#I zi~mA|6ydD@lc+j{-e#sI>$ythEMz+FL)_F5Gk~cS6TR#N=?cOi03afeTgW0qyb~Pg z(L%wD3^s7A;j2rl7ybs$rCn}&A62vw+`Wnq^LC8%iM3c!2uF+M5r0{}?UM@<=O9?b zB@0@~6@hS%gcPfdbsftJ3S+Iwo5+G@b~VgPa0|b^<1d|Lx2>A7&yxa<_!*N_VVH=W zq1ux(Aroxd{m2sqTB4(|3zXT@^mvnEkR@Kvj5m{lv%GJ<%OW@Si-Hjiq(%#4a>S0x zYEixS(8Pf1eaTB4njLlc^s>~-KVaasGfAp1NX0!o>!MAo-RddF0}uD;(FZje#y>Xg zJbkYOqLGkwVL~GvpQ6SmQ3V=oacR#TZ^C_ak{|-Wlhqb$uzLpkaU<&HOL2%N8ffH*O7it+dZzUBE@uXGf_6KPs%J&ZHVH@d# zyBp5y@7plTsrJ(=AKKk8lN5~HIJmus#?8FJkN5-WC72$fC0unGohbs*;}Z8dJ#sFU zcOKP{zIBD=HEAx$aQm3nO5E^wBvXqPP34A+_@+3)UG{=AD{)CK9{XzI*;M}s=_wcC zOH}d;>w4_lx2e2oB6-&FoZ_>dg= z9pY(Y)AT{DhCk4vum~j1USJewvcVaSOY?5ZGOS~GmycUJ|8(32U>Rdu#k%?@Hyoz% zgrZGd6%}I)UQ{{G^2qEQd@{4D3ZU_>v52UEEpN?!ZRi#i%mbYE7SAkx)n|DdRqQ%w z=0dgM(NFf4KV|dtcenV!i9}6NEo8zwT&*r-LEy%V%MttyQ!Xno1?IajQ!TTPBvO9v z>sm?A@)XXk!#z9by0cLU+_(5JV^?RgBdlaAC|rrxJ)3FPStzXgLv|Y{X1_YSj;Xup zaL-la#m={#Do#HS{ODyPn1H$*1fOt=ldb1Nde61&9xX_S%ij;!!yd(`=QVx; z7CZO&BC2_OsoxHr?%*RU@v;S6`T`PmzE}fHB9<)C7pce_bRva0anmg#R+cz69F*bF zGZ#_zAMg?t8P{UHTANEQQK0WhK~ZMVBT?m5^d%Ej%a&nr3#&)RJ*IMQRL=&6%D+y4 zduYrFno9miWG!oU@zSi{7SpL##2H=!QLTxsLuw$bw)~;;{m#}qh?#-aS;2|W1lQ0i zd-6NYW<5u;tF=Q%>9d#X<^5dDFYI_Dvrf}Jt_`T++~z`;4kJoVJ-n*7(WR^5xl53> zCaZsKE%?BVn7WqeqmQ2ou)!JVa~xmeOQi`Cs-|n?@6WW{ zwXjr}GO5y88;(wVOB%|0O{x=jswSMgiGoYyI}%Q$uAP6YrjkDqQ^z`=dohq88b%K_ z5<|JAjaepCp;*ho=sYetfs7j%ethH@;Jv!o#_b-epL@eryrKV7T+Z$QWF6cy6Y_!P z-Ho0YMnCl`FzbRx8%5`l8aAqC6n+%ceAocu9xFH;FkMAAD?!IVF}9JX@h0&eAz=LH zB9$9xtRc1maSz6I1MZ@oFbq(8GStf;cB$oRV6<^X*$rQ)^cgOM*P`qIkc-`qHLo8B z2*1hEmRf|e!{Q5W4MmS_0V%K`mTQV_4h`@g7_gL8N_1xHjD6SNXlE*4(MBO=;<>AT zWqVgB9o-!vfTq?CNZ5yAXFCCx6uc`S35s)qxyHUftiL0xmn>a_{nEBh(fM9$hciuX zqmu2|@Ug5?iv%$wYRT@bO^%JcY*+%Yl0*K5hfc7At>8hsaLC*(QGA)IDQYV0ooE9q zmkT)ICTWm?M%z2GT5!1hp~F@SV|j=M!yexFrqFxn3Qd{^;vt%?$VJ(IBAJ?|r^dES z=_=U>zIE`IZZ^Rd2o;Ph{u-SpMgWL9Bfi#(OsFc)VkM`&vPNGI4;;S6M?wQ!BYfbc z#lg+5rVjVikvy;S{X+vtf+=+O$Ek1><&p&QZr8@A%nH%iK>Q~_#(=v1If(IXl(jG1 zU~_%!NTw@uLQUlg*EyfK0xY+F{bzrgIs(r*ssOU7`*sUB)KiA0fxRxaW=maLCbog< zQ`c(Mt23;MQVpIlHr%<<=jvcAFv>JOW1D|0*1*%JeOk-mQSgJJVjGyUAKW~we+FG+ z8y%SwIr8k*L<@fzO`rVJSm+(0F}u!bt#r~TqtfB^?L`-jg$K4M?c+x;C@Tz`!L)YJL?_K4w~EPHahkJuKO zfkd9jl2KZaejZ<&q+gCj^mcA@9eJ8#))_94Ck2~5Ewfj|q*;01PJHPb=a<()QK z4rOW*V{GQCYG@9M;yC=h&)Q;}fE#FMHh+hTG&If-d#YlQ$<2PjMYFkv&2h*zTON2H zEzaRHGS+`eSLn_06`b#y=pN>d+mY`yRStiz5@(FjcShwJ@6y8p=+W8@a{{7@fRS-S zA*@(|+s*k4X$uJLwF9Rl_a%xM=v0FP&U%F*fSWJ#UgkeIH%qOQ(ApmcAP=XfAH6D8i{DK{Y zFpiKHgml%^*Y}@>*b8pp7RUJ_Ve7Wk_a{_5O?o@Fy`xTbGexHv2grOMqBdsD5i@-i z0b;i&FF^^KEH?nx%kvMzAyc?R(8&6MBe2IN49;Bt>F)iC!pqcvtiGyL@ulvKxvwKX zoK1&(dfYRc#R)-E?9&GjDRwF(ws9XG!<={pQ4a{}0laOiJ`FDc_;d>U0P;U24@%+H z7Z+&JtdKZBP2iHLepTv>f{-b+6Z{R0yZ<^=a=3>ZCY0|wHK?OW3r1enFDOB@SVU?s zcvPYDRM)BglL%7kAUEX&YSMl~0`v^S2`*!w7Md}~(&BjsL05lYbZWQJU@vzY_Id+L z>f#<6oXanu4-#w^V?p{!J?`|g+0KU6tONorimGn;Yl9};-59eot|?ILIA|*?s``HV zaz?kfUHuMfi|z>5R`3xJqFLvu!lxuj4Jy%Y;Q!4%K$fJc2pt3$6zIQ%vn^ZS&n7=r z(YmteN9D#GK{?! zmJ6RWfQ;dVPGoQ*;Iu$J!!hNY7)B8jm&C#wv-vMH5BTep@IBn&$)LBI3meo}30AHk~eduQFQ z=mSUqLDXHQgt)qg4(0MY;JLRDcb9)OV173keES)a6KFnE?n%rSFiLdq(eiHYtk)JR z?*%nduyWHzBuwZVx_0jXx?5MHxP(_bHK_)`!47_=jP9MuhfLn#Q4W7T@29J&_VD7K@<6b;$CIC| zb2@FYj{_r&^`>K2Rfc*~j=*RC<~ZPZ14k@mi=TngiJwi%s7szYWvxkzKoY6KlWThi z?Hn!*(*c)49oDgO9VxO=9VvyVjP1|o%WYi)o?jR|`L@F*i8c0ob5`!;v+bP|oLUf29HMaJ^o=gj2rGmX-e zTdF&JcH}{#+T1y-ZFQ-92`?tGY;PVQ5a?|2a#CR~%L;^LgG6H_E= z9E-!~=T$k7F$Lxyalx%XIt5fpiJ!@w#rh8$_!}GuVm}+1{PQ>f{sh0OS+y^jW23I$_w>GAa0MG_ z_Du6VY?55>er%jz>7UH&M$C3&)1a7j+!$t50z1e^7?*Vw3ph~5^!E$QXGlgfJ^?d9hZ(n z>pXl0F;c7sX17l0tkc6|OyZW{UW9~g2k*&9sjnS@Z3`!m9KgXjoqms7Y{v5FNqQ>= z19I#ht4>yG%r7}1M2axedCl0=XA){JFQzDK(6nG6sZZ!ZQtRUld%;;1-Mrx`oZz3; zI6D(Mn$>@tomGE0An~bcux?aHK#k8V=q_PNs^q9`_ zAmcb5k2-@t%>KTQ*VVD`jAu~1sr86knvFiE@t-`;7pD3ROAVk}8JtV(A$z<$0w||0 zuhHde>7nYm{7H?3A>U=Ek7}2691J6#yf_|ltl3WAk{X}xE95(pf_c2*zMy-?6)r{N za~cUtQ`+T)WqvsC#n|k%elx$ao9}he6H+LyqVb=SV=kLNoK&{{#qZC$*r7C?zhy9f zfblsl6zGiPmsgZ2!bu~^y=(inHY#=4oeIJHQ3`Gyxf zLPwrA*t|Nu=4j)!0jHje&glVmpz%?s(Gq=!!)0IDHtF-{k1lr~&@SJvC{^vfqc=xQ z>>&b1l$*xy+NU^>DttNhA8_e2aJ7n&7k}}Vil8{tM>p(k1r=^#O7HKbibFEtCwIwD zR{MrWKD}Ns&n3nBjwx{SKL}fgv4cN-{3Ij5Um%}X&*61*#CP1HJ6lo)rT#i3Lv9;5 zoF`3?(fV1os3iT)QG)0y)Dm)PxR$;+IB~P^PNIR~ST*KYSl}0H@3(QM55Xf7gwrbU zh`0kr{%{H)OH7^D{IK)&Bc}U}F>5nGxSG(CEZ^ZmyH&CXkZPHd8?RY0C(gj5u2yY> zAyXM*lh{F$%9XPfMf=_0agsm`iktUN=Fzewe^liQa`*Ql38LI$o`I}^7}A#)JHp~3 z?XDz6wX&H6=ZtgH&6DvYy?lv;su4dJ3A?^{ZbUcd?xJ0pd(hr>zp$bIrFZWgFOV^- z1Q&QqwNTeaL%u4hn0s?qX<^(XZgR2*V~Yn!o|TuaqRlWbJGy^Eb4{0!M6QLGxe{Q? zK_oOqHJnV1i&;bKTPvyLSQ>`L%WIlSpBPGkS033bYn7e3|5=a;P_!SwBi$^iZ)2TU zll2Kb*Z#JCl~|37{uD&?G%0-Sh~!p2iV5+A#f3)g*IoVn@_2_{h@P$X%@EBVqrP0; zd&ik79Pr;Q%!-gMGcoPed)a;F@#a@>!IB=*vu>JP4GKU}h#|3O}GH!8C?JXo+E<>v>mmKU|K4?;uONG->lcl0RF?{;QQlq508<+3%J#;@$oC{yFyX z;VSV^IXdsTPC+Phu7(!6lrgW zdXKLXr7O#TanFhWxUluKMA}`y@lXJVqArkLI|L zxI&q)|fZnf-O0(xp302eR3=Vri`X* zdKZZJmtuNP9$M7Seoq_A*s8hp%UYIt2fs1GJ;kq3G+p!T)hJ(TTwL?4x-nU55a90Z zf5KOQX9!t0cWjs|XMK0L=ON-A-FVHBzBqYhTy!B8a!_R5QfS$5N=2lHt&1A#MNy@t% z(h!k)DT&iNM8uXkt@(c6uIRDZl&#GKEQiB!MvnPfnEMR#1QuRnp1xH-7m2*B+c$2) zPFmwqP*{u{KxAtwJo6=EJr$2BmTvR^b}TvP@PjS3wNZ`NX0=RjqWawHe*`Jdv{nCF zzY?h_M>`+hG@DZOZ9Tuv)%D6;#fJRfxP^XNgc)PnkKyIhksiBGjA7z}4WT7@Q}yDL zm3M?)(UOv@gK?cO1^GauHi)CMqpBzoSiCI0_XWIqq&6gVh$lDNvh#F&y+w#u_R?Mjx)+zIWr3`rouni zVpSfmt;XqY_;ji`WywQkmij`oCO{gT;k`8um3LWhZ0J*9A07KAV%b$Ke?>Koua21A zL_s?&lr6Sl{-@<-X6=y-06723cfd*Z+5?ajoc*5F-bEAex4M}2-g)|B)UzFm zt<0fB%p}DOx99bX7hASYmabyt5`RN-j_tM|L+&lY*uM_JZ-`AMmSRrT+ zpG_d)$gvsC7SImenWzU-4kIR@_b%(kncV#k_USE7XM)~Le$C|uAV!E;JAlD+^9m(7 zpyR^iWNzJ3dK+c$N96q$#MQ0sr+1#HvOVGM|9Jc?y}-p`{D@DI&#RrFFSa%CbP11F z;M9|~xos%%@!=P*YeQc?SqkVF_;@#4Ghqu3pr6YLk$@KaC>#tnITBbo|npU)Na}`em zYc11fSL~R7!p;W-SrD~rUhFX%oc(;EL$g`8VxlKJEES|;Kf%wot(4=d@rT}~17*5( z8;xhe+I~K-lyA0dGMJb_N%kbk<~q)-c^NGIM+TB}UhoRq^UkUR+kyIBOIf|j$ZVxl zo1|90FkI&ehu8>SK%l&&Qd45iZ8vr^(~|=EfC+X{%VM#P6kOehK=9ll}6s>v7#Y?%u1kz3fLkayRW`59YWHT%ROXZ~SNwN0>bGBJf?P zO;W#}FnFnob)vT7>lxP5EDO_H38|J41Q;#o=PiG zO6U8LJbQSAnkG?>9(N$TW`bbFjAPH$w?_eXCTv4jis}2PaUY5QF2+h{dM4avsVYb zK2Lx2g?|+>{RWC(6J$^qo2*)RKJFk0C4pv%4m>x4vOQo?Ew=L?-b_cSc6XUu^hBGM zC|#kX*Whpupo!5${{c_Hf?62{b3l=5m$7wH)#wWn61@ZD%GP2VxvAfLXNI*cghQa6L_iPE1f9q=<{!O)OZFpx zws~#4O3_{rNE-5jt(|(h4yX65?EL$Ot^)#Vz*;{r&@}bqXRUyHM9!=HJKT?7He_U( zEwef8@$FH0V(?`{XYgsVa9r`)2fsXJ=P!Bn;^(}2=HWA50Y#{cxa(no{z>HfP+TV8 z5uR%U5`-ks7~;i5%j)j_Ne$zDpogC6zXczRY*w8d3qj0I;Xfty^78nOHVU<^&s|>t z`4z$+)JTXiz{Z__N*Jxy|EAQDMfD|qZnMaRo6&8-hR-~F&Qo_Fx1j7;WY~c`4n=kS zH2OP9Vu}H%`VA0cD5&&-9$Y~? z;0&tUr@o#kg~^kv<%omgjP|I0nC7vpEK^zKHv6&P*?_%VX}s0*b@MS)#G7ls`s??7e38I#;R;SvPn-rWDO7uF+qMtmKnt@8V4XJ&wxX-CE&rTu~u6|EtA?-IzNL|ged^$c!tpELZ77dOPC+LKQq zfsm*JDj^AYm+dL9p*WMLWiOn7gzt@0$u3jOfhx@P`@!LaMPLc=pDz1+A9LN=(2bxZ zV3=X^6*KOHaF25y0hN<03oko^l5(D2aK>2JpDNaw3{tX)16S}Xg)gaKV+ki^5+4s2 zg0_by;NmWmEUGXoFKw*BBqwFAVoOZS-yCTjXC}+L=`O=wFbECz^Iy;W37fnOdomZ^ z1&NdTqz)YM6Zm5P--!U@QL1cR$LHZ4;mfX1zrt;jXgvPb$^z3B#l<$IoGs5Q25Psy zQQviH8fA|F_fk_eAxqmzpkDrjho|cq4POf z8z)hY!xZiuCj1U@hcE+8(OWG=QB*hN=2oRzHq(nNj-uz1PF-ewSI9CUn0oWGfIy12 z%+(+CDzsSbpoz8PbXxbmDUQ8V@f5DoHO>CM?R4$gllNp^)eJh`qG<}N{*(l)@6&jDtnz%B$jxxAlF{gg` zoV(;mY;gxk(N1tzGk%ydvMcDj#PVKa#N7lN-={cCAOW(@+1u_$nEHPex`rpIu((jS1t zmbx#Q6^$@F_pDvm%vx*JL?smUi_ap|g6jnxSb8;@xz z*_8tlpy1dJaEDn>an>>;;2uAqC z#TDJaSI+>kXiH7WyYS%0UVHNU!Obr`sEiCC2vn%;4UhYAe&iRf?Yp;4yrnyr-#}O| za47wfX;Wtx_Qy*x9+_D$v!Yrl+s7h9AMJe_6zptAPG(uvUyqnr?Hha$uF5i7zF1wh z>>aTPYKr`2R+LltDCW(G+N)ne$6c%jmOOs~#$!ecjdzFqc5ZO znl@LDCXI)C_}CXD_fZ+3!XC<+?5HE@*P)v<+G(|C0U($m35tP?;J6*G-q-I*Bug16 zx}pTaK8a2=^Q_#%;XV6yZO8V6Cb(GnO4J8zVCiITEHgVyn4+>ro~K^1}8;Qnk7&|w52US2+L2iQ?l z-H%O9Oz}lFMO#|dSLJ;eEVgNX2Yj*k&53Qk&hng*1Ba4AIjryMuhXVh`xfVq;&DeC z*y39xiyb~shDbQ)=B_}$GW1>6YF5|q+>SBNZLVG7J>b|gZhsadmIhdZ5~M!;_EF9U zw#t=nHc*D(i|b!Ixuz8S6hd%#vasBmBrt#<7Ue&1hk-!Vskye;L71T2VtUKh8jpLc z{d>@1nW}!&Kj{^_F}K;>p!dTsqIZzFkCatnvd)1#YieB2euwu$w6@h&>dr8cvg6>3 z7Un)&ngc&{YgK3g)_>78d@-tP<59b-OL$GP@H|+a?q@1V?r2xD#op*D+qJI?X}l!2 z^pVFpHf5(%@`?4~6)qm*$AR-5M&hmm;p0*;lA~vc1Cia``wh8|2uQAxk90$c_LCpX zkB!Z8^bHH%SWiVs;EOI!)Hnkx?|@rlbwg%b8d_J>D~Zo*HiN>|5dDCz){?d#Qk{jYzga)HO>wHvRa4F_bgbg?UWrd zQwS{^xZ2xM&3N}MyklVEcbLMA_#`RMzxIKijPUE=x%%U`3PE4i5@YBZetZC>?_$gSg0_jDsX6r_`v9#t5hB#cq7M3@U zA{;`2yFQfBUe=a}kb^pg{f7cL7$AHuFz&#a)ga8XBSy=iE*CK%B+|$|W^Xmu8 zuG4rP;L_5(Z@w|gKLVoHsOvd8VMOvwJ(f+Hl|JXqWbb;GUlZ6^2QW)up)Tec6_g$_YL1e($= zNCSQFBv5qpI|6qDmwx4yO@aR45<&)JG`Du{gL&I$W9Cb0aSKDNYM%mY1T6>NQ#$uQ zyLkzA!~eP))d5g5>0;3qfR2+Tn*OM0+jISCc1x zg$dUoi=U7Nbw@aEn_qs>A(%=MoP~OGh${jnXh6bCZf^jRc~GES1uf968uMJK&$9b^ z6Gxwvrzkl*CO6z4c|CbpCtv2$MvIDIcH^d-5I4cq$@K5oQ%=g*30y5XQY486N=q zd<1p1mL7UC2;8h=k=*MwoO z?8h^NfpIdvdsgC8o=BjWbMyj@twJ_VW$5Hbt4-9v4h zdTh{%BcTDN%3uTlFxy-jyl3n=4>UZ6FKr&T67zi%o!-I?&dDbV;?R|uOqNNI_1tx zRqL1iko-&8j0bb#?{rPq->E=NKc^9Y7~%F`5id5G=BM)iff*~puX(i#bQ&yv#RAcZ zXyvhNcbK;oOF$M|2VMJ00prpB#1QDLJ~hQG+Rq7q2cc+&>*lZrG6@csy=MI7H_d}9 zJW({btX#tRPROlxFDH|e$d%%o~s_{4p(bclHh~by^7XP}!(!T@(n#LhCaxcsa z!+$GaqJa?Y;}dV9h%(!pDjw#dcpU--lxF=TolsEz07wKNX7JKAU34dTdcc4Th|x;g zaRBBSG&nL19`ZL2As>3rY^{mlON2#eR3U^tzIku<8I({YFtd@lcnCNw7Jc!lEMEI2 zJ37iodTy@Wn+G;G1Lwe$4|Sx&5%YB^GLId(Er)DG7fGDhU1l_@zLkOowC6L4!-LY)kBVZ=%Io(oW`* zWEZj>$THLDrzP}AL0pTt3nC<`&W^*BUigCRU=>jApLaeT-3PoUY@Sce_#6O9&m*0Rv~`)HJ==(qT&SyEiV zLl^90kwyY=G%ttjH(@&>Y~#5F6t;saRhn~J_-C(!;2g#6v7Q3xnPbGzF(UzV&G?buGS~M?Y zgB@+~ezm?~1!(;|zOw@DK@h8 z&Ew#1UP$}F2;xcQ1eP0e3+Pc{O3!iRq%Az{0aq2H&XDLRA||*du8HbTOCX3ou6{Fb zC+Jc+Ky=RD`7FgPO`@L4&r(qO+jZ2G@t`p)!MUd!ohZb2Sl>t6fV?n%n0NB{))Smb zoNgqE8sHhbdjTZlJUsF1FTlXvr9s-@TWRn-sCk;^d1zz|U^;-fJuY~H4)^Q;^JPF* zzj*AtBVrajVXHe@4=K3>d4Xlgg2W_DSasLzsn5B_JflUPSKwtUpxrff^grSlN9Xrz zw5VR=t1~AQNs^<+OeIh}A&X8xUf%3vOLIpoUFV|}lv&J)7bFP*yJ4dSvV#)n)1r~b zkpeB#8cs{GT7@+{N0-fQ#gaO!u!a~@tcWe9=O|X1I<%j%`{fPD3xCQ)qt?8oQ9p;e ztnJdbP(ofuvDbcqq@6PXsG$ll*Mv@7RMFa$a=Hfs$)15u%#tiJ_!XqOe12n+PFTz> zj)^#J31nlJ<|Xln1u5SNuCfsjfj+yOP=Z<+7xKfynRB_oHFv4=V^mLOMzXQ*nhOH`XS~8@n4=krwk+oDO@-zr#b|o~~mqc4O{9^5Rdj zs9wi9#cb#zG(r`=)+O$Qe z#kJRz*-l8EBzTHThO)i`jd!}cNyCK&qTk|y-2orn02!;*9I{TD0Y*@ZYa08&v#j9S zt(Y-V!{Ve6IeTDAs=~#yoPdb9kdIp*Tl>2_s=vKpH-Wz)Y?*=@hIw6jl|aW$A$c&*WdK;HbOVwsKD(1IMa|+yl;!e@cfkJ$}`gI>1}HiSFKv#qp;IBaHL| zQVc_bs&_l0z2!<9) ze;;C+lxzP5duU^NMrk&|c~^N{Go6Njn)1&4T5YQjp9mSMarpoT2em~;B5zC#WeTs< zFVxR8-zaf9wm_-`&!sCktd~Y3fKLgICtPJ9H>N_5#ut=%?rN~S6ylG(QK=h@u} zP5~uQuX_-;a$(q>iFWx#bVOTV&PFx<_O{PJi=%)Wte^dw5;}BQuxLf)`rq^|0`p^c z&{%V;M?S7qE&$}dF-rRgB58w4{;yHL#rJI0Pv`%rBB^WsUWh+Z&XrmNZqtJ;?$+5gUmi)Q&UdBX_z$gLVKn!tyYvM+!R2a$}Xa&hdfImKnQ;#Quuy(dhaxg~tZN z=HZv4O9LrFCUc@v<-p2y`LC`Ol$;5zRbaMiHi#wFP|KM7jJUfhMsR-S=y>NTDOIFE z@9w|I7LUSnfhtZ}1MMrH`q399K12{f^w&|10pM@0D)3v-KV7WA+~J|ypuKaP*GMDu z@T9JA$bK?YQ|WY{&m;<_nNk84JYK%Dl$sjX3mE96Cs4{Udu~b}JX&TqYD$tsJbrWX%H(Qe@sfhhKF=_GQyUnPJKSRc(VDcB9){fI zW^gSAxC+ZE-r*+BJr9j+A+G30`?8SuZyQIQPE8pC(KM~?`Xo+p?!id;8KX{pqCcbj zw%l@$Jm=f-8q8Z*Vxpa=lUfhf4L_O4+A!A-RRIB=_I1WXJofd-H$PN?It1i5H{UB> ze}V6EQ(9oej|rs0_@*G85YUIfEok^A{19$F zu_YzKI{xNBa82(y3{*)*g@YdofHFJ$dM_B>9~nQk;Vm8ju^i&XA3TbHHWSFtoWA#5 z2Z;R1y*qb~#gdZqiL&;do7In#0_tiZI{s$zaO%~6c(PqU>eoNpo>}mPdNDMxC4>18{@|Xz zonYb`Jj}PsL2VijITrD|FjY2xkgmY=U77?tpyL+BGU{H9RM|#v=VtIT>Fy;QOCxI5 z)wj5^ahlwiXZC0peXy3}aNV>e`^!G!pw1~#D#j$fk3d8gvOW*jD zOpYZOx+mr5&mGyi9OTW*U&zBy(W%N7%l&cs7>_OX8ViiV5uY^n?*qTb5^)D3fSRI__S2p1%Sn>m*cy&_YvS^E z1I;596FW)yW)1JauECS#2VTD%2TT)?1j$CM0dnjeq-8wi4bR|F1W`lK(uLPETC@nN z<;9zQoVv zr2i;eJY$^pk;_^$E?(8OpWKa01{KDK0K6UGEhVZr8Acr+)AIt&g3>SVx~tb^i<4!q z00<;`X7U?p%1c=#{#mxMB0Topp!a^ZxQ!Rn5B1s#`kzb`{R2cpjcJUCAI@v zOqnCzLyFb1S{2NUHpF58eV$0@GrEOK?5UQ9m>-w{L@2Ihg~o;d34Mo4c(??-X(8ib z)^AcB6|MIhtM(Se>_K#>!pg{(EWoWy;_IlwIite0?+Zv4S#un&sSR&w0W#@0rT$=z zXQubJ5_%<=rJB^!N|)LpZJOY{7ScS^XZg`PFiS{;;dP>sPwb-Nf}nPvi)?0q%d%Nz z;}#Mkl#Mi6v7_3CHt?3N%eeejz1^cvNx}U*8EX~%)RbBSMr)|UdJV!i!}jDqkcS>O zz?|}#)AQM%-;UunaT-t#QtjXC->r3cy;uNA55w{h7(D2a1H<}Pp{NkbZOB@Sb^=*P z5wh1@+W(9P+L_uIKsV<|!FjJSwn^7ES`afYmk+Brl|?j!yV&^z^Ogi?qz5v*U+^A? zG@jm<7&Kg{9S;*O*V!#^bHv?OYATa#fR-8oGe=a-9B&^ecb2tHXB~<;UND>xuw`%2 zNG(uvXA(qhcx+2!%g`ZE%oTBlbNE1)3IkyvxfXK9O0PHhA?{ni2udzNHtF2)%M#Ix z%B__Rfvq$8dB}isuDiytVQ!4;d@AVZcVOh6>zAloFZ(0hCZe???%#hzN*4=rt-e^d4GZCs?lczQ6r@ z_t|IXdAM@Px6GV5bIRwGFi4sqDXt72O|ncX0RqxV=O@{7QnO&7^4|Jo<~ScchvRb4uJE}UpsuuguedY+T520Ra zZu7_Lv)x^mB9v_J$<#`6G;8aM*dV_*Y-2U@v(_35V0A6@yTn8Auch^u{mZL%y+d0o z+;mF=f}cK@Nggd@yx_$@9R#pJ^AE!fTu;jNOyX|4XF1FR%e`Rp6RNmkdY$V^&Y6Y$ z&}%0Pg0rTy7@wUG`*LU3GbU&JJ9Bd50*M4F|2&9#xs&yx1@~SywA!rCRG1@|HSVqF zTdlLaql4e-8Dc{%^hSYd;4w;Cxwjwyw%SDw6#jtbuW6nDBryovOIIlXF;+QvUgD?< zW6~vmWu&T=!Q=1Sj7h>Z0sfcvZH$up;GC=b_)L&%!xxwn_pVG*di{V}`Wxt)LP5zA z7t(~M5!8I}H6ElNc)*yX84z|Xn-^8mTNA@p?IIlo{xduYPT z^8yjnZY|r~bDI%I`ij;0Y)SyX$^6821N{J~A@9xo+A_u0B%!bBR)0+6WX+6)#MQdd z`HpgT8v{n$BdAfiAyVSguyRlO>^@ULdG58QjrX=wa*R8C#Kr~bt!@j63jlKRz1nE( z)v@&jK_zOtXtnNW3#@Swz>-MDxq;SK-&toKLGfSjU_p)3bV~@b+R~Iup29Xai{{Hh z1+f2;QE|7N7@8J_Wk$;MgXhh-E`XXZR~v)N6U(8qD_aq?2x58JLc?w5?5w7Rs?=#~ zgI8ob`NPJ0uO}2&d_%5^19N;GYNooB1_gDN$_+|UXG;y<+YA_NZ-a8O4WHcYZ`gb9 zkIh$6ECu0xd?gwgga)SrF4n08%$I1LCbMkP-u{5x|F3VX7R}%;H6It|xj+YpTDN{3 z@HrUoTzVxhA;qlK!Cx2hW>p|Q?4stgVW6$`% zfad39kuucCIWS<%2>*;(LS~qTNZn8`4Y#Hfb*`YD$*&d|= zH?~+uMM+|_9R5&A{dbdzypAEk8%x=$Gy$^6+W1Sq`o0zf{c7P_z>6RPK*FK%d#$!^ zc;c14jwpbFLONcpD4^fK01@JVm{G5|vpW%U{-2`BxwK#e&Z_O%Uywl4{H&y;(f6Pr zNu+V8YRkIg!Y>M!@&2YTHmhHvv6gG2k25$qden2sZyo*m*JGT2MtC3)B)Q^}HEA@E zGZ>V@;Xy*lpRFom{`H`r_ds5LzU5BN(f%_6QP+M>=J#LzU)k5|_vC=N^o#nx{__9# za{NOY@XP;~dO0ra7JA{$)pZ@2Lz1n$`{cO-qXRuO3qmdABzqMKE$SaW8!Kkeaq7Jp zj(vT;w;;%r?&il}*3-;5c{(ao;|kI@z^Xq9D%5ymb9-(&emb$*F~1Zqe(X!)7wUJ$`RAwXHxBQm1N{41i1{^x ze;vG^A0IyX;a?4(fBseWvbm^R~ZCvx-<$LNS?{%5kQiujmC#?6S%ox>U3?)Vl)rQN)+beS06o|9$e8 z6#Ml?2t=)+5lk?pUU@v_zvTKsL0*2_`Qx2GrQM%94|jS)%ic08F6NBXWm}d%%J}-K?6U^kyreY<^Qx|DE;1w^Zt)3UNn$o z)yVMy1k7x&L^#sQq0$c`4$-nYJ@qjA4^{2XaFJQ#?KRDilmBJG6O8{4PQ38W_iO)5 zoJ#+HCeEZzmI!wrr_gZym*1g9od#l%6l)=;wX<*u)hP~4HkuFq3W>AqV>thb1EZr= z2#rJQB4go3BW^Gri@q~PG!J2RRL2sAc;<;+(o6oy&Ybhao*VGQchQMWoH3ubq}I&t z*VYPniL-26o+amo{~Cc8v-`!`)wEm-UEic-R=HYW(PPNiibNXy8&&(;-q3aLJ1(Lt z1DWR~9Dw^YZ3W$ldnx+(-c6U@nQSP3jIajISRlhv?YYmj6X!F7tgL%yMB$du7syWi zVX^ot7X7DwJTxzMjTU>moQ?K^ws5hNfwo^m`9g5ZFnrkWX^6@c7bdP(Y#%(hWsZDp zr~^?==TjLkg#U5<$l}LJN(lT*K_CCpArJLfk2lpC8^~{%hLjNRrB7NKI8?JNiDd)^+nh^-5@5(LiY&XEGn#F>L_)A*Y1!wu4Y-p}>ePevd-A#zEzb`gD>^^tXjpBW#mxi%5( za*>Bsc^T87sFKu+8>^pNbZi_nU$H_N!y8ha(@wjcinfc%zK)kzUTv(*?Z4T5JJ7ZU zeG(8g{bK3Ui$`q@GB^(+pdVn3fH~a9sCAyxc&Mpo>4wa8D%MGqYH4t2dva*ATCW&iba;PsX7}mD3*sXDcdt@ zW8g8`=ENe&t|~Er>#VYjhm9KciM3ygiS;RQ(5}#P$!TMoR#_cxRWK?^&w0(gf&7XP zXK_`+C_wljK>nCp_Rge2v0U7#I|k*6$53s>*s!T#b&`>-Qmr`jxm&q0-sy8sh+~;u z_f!i{?#h1$E$=Y5#rwiP+DlsfBb&%;ddxL-d$q$GuF(Varo+7MExe43kpJjnv zRefbYlOTJWH*w6H81UG8bzndLfacu%iE?xYpz@cC<%iheWC=k3;34c4x1K31GgRPA zo5CyZZT9DFIouc9S!D9NZKumNm@gDWp+A6=@O1AaTyeOVS?sDLA4QyjAErN-eaB}7 zcO`>$+c|fs*-yQgqu?)-;K@~gpop;QtQ{|9@FA-?%H14 zY^Dc*j`9YSvc-&|TZiFn*|#)puTOMWx(ilSj@f)lzYKjLxYL);9AJ{RsvzBgIX}Wu0%xLwS{VbV;YidxD>`sz0H^08o7Di{B_yFJX zWANtdXp!@Yja$9|0`eA_CWnt9(4-UD6Q{va0tihAo&* zddN*k#C;SJ@BpuQ|nQ&1`2A;|y!J z0}3Y(7Ak0FbpNOiO?6|tUO$E~^Z0zDL$}J~g|48T9Ly?hddjp4%=|pz+oacD2h@@Dl$7RD*=1)dtD+%s0zyV*%B^6x za9j7L@|7l>% zcgdkxB+mPE^1d0r3Kzj^3TfxS(tWCW5kd4^T@LM3QUg7L$+vrFpr3x9F7R)pXZ6&K z^Vi0L$#p4ri(Z;H=X(UGYxoxK?KEYUB4Zued;Q#}<1~bwJVih6KTI}3&jCB`0rF5+ zE=#?l#r0QR7VVKk{oR5myY2Vw+0;?d>Umoh*W ze=1f3dFIL6)XMUXP*oH{wd#zhk1G(3l6q3-ihjP_7m&0R9f@#MLJ+Aq_tW)oh-p`q zw6xC~ADxbEP>yF#jWtUA9u?Zbsat!}u;{jy-hI9;xqHWwO%g9~7f)Fe9>NW+3upd0 zPfxhOKI`G$BODX6I`$u{)VVVApg}4I>4@m;k3>tOa3!kc9;BM?72cuC$eL#k9Kaa^ zR8qTKG8bA`Sr*x4@$@FIUE|u+?My$Lc+t3*Yxy)WKnqd$eOTnrgaThWMb7t!BS9a~?B(2K8JgbVukaZ}2Sp zkILr}-e-pvL=H|vy;hQg?#;~gt=7ThQ-==(K5FQ@1Brj5F~mU8Z`F`RTXIJ)RKd@9 zW1Fo=dM8i8;-?p8JC7xXHIe9UrU%q|kJ|8X@pHD7%3fb}on2mL!JBc|t&jegLyp6} z6>xX6sHc>*lF%KTSS~^?*Z^@iUO7PZL3LbCR(Rpwr?Kb}PArf899V;C>JZzXsUNq! zQ5!estg7pIXdp34&(qevC;LX)!w=W|q+M$^U_DtEMRgrDdsa3%*VG_~8S(XyM<0QK zjr8ux?R)VBqE8VyF)^KAUOOG}7BC6W=F7d7;R1t(k9t0w1EaC8Fzx_J!ljHeedID)HPHwZk2is_{w% z9Ap!yCi+y9y|^2i)J=w0+xjn^T3B zo3H2zuPaWTHMN{q_gwChi|O-){yTmYZ?cT@T6=CY1oXVN57rPUQ--B7svhrsD%5gp zN=HIUa_G-oAXE)25(L&+Qj*id>#^hXo`9$s05kb#fz~!Y;Pwv z+|~FlqTCWNMe_i4l`cIc3`)%;UGdgzB<>$`3*J!TdR{ClfEcKTNB=ShSKWkTgx^WXH2}uRX5Nr-vO+Jk9=71En<6?!usu6@ zMvg`BA&g%OJ6~8$c+|VJEb^JyvoJ-MjyOE?(cnxFtZT;H=pWgo3{A(wZPN=~&tq1^ z)f{T8Fe~pHk_oRSGJ2|6uci#UQ=9Upwj0X&*Bt62FMOtm5^zF=KSs}=UC}9RYnSOp zxF_3Twui6-2%}5OM1!MvOFCowng<3owVwp{OI$wj;4cWR?Z+9>Dg`Z-AtNSQaWz(F zugJ|8LNVQWTS^ROcXKhKcCw@>gavaqTw`^E$?6y9L7>8GMOxZ%aGOTBSj)OziCUMp|iFu@e zhO8|afCz>hkK5y73J9EF4Bs%n74=R%`ue5JVl^DC`K^=xaEXQGBtlD1Nt=+zz1!t= zG~h~?_xzwXfv`%Gceh>?;A<@ke?vdAZbp~5vvqJ=bO!P7)E_Ba%H)90^S_MNWqpA7 zXR7R#GYzV!HL;kQ?M-H>_0Lh#aWt$3uE_?AikND4MyUK%XIGnS~CB-o%27>dXi+C z7vWa*N+n!!@%gy#qV+p&ime_A!-i6xZNGi8(R*vJ> zT(mIvHOGHUG}#po7ET1SH4kZhIlq#`ipLst8I6r$e9H62&jWZ&dH)^|7)pjukGq10 z&LSXxHRDa2u_t0ljcJRnVzcm_<*oz8hG8w5FS`tvbz zXF12Aj`1Z8{8|pNm~GI!?qb7KDYZJw)s)%_%>uSkezJ7J@us+}kb!8Rdi? z*)LJ3^fyj=t=a$e*{8kxkh*=L=5y{p;52s9;q>FeW-O z@--K0rG}J`hpUHod7cDD_f}GcGI;Z^+sQz;>>G}PlTv@*oSr43rf4%w9Q|FgfYMA>3&#KigM?3rk9An}#@+W*#tZVr@i}3z! z=O|fj*91m^iO}s$WDkIcO6-^T{;!FA$ecLS(X284CB|~qD7o3??YJBD5TXEzu?(Sc z7)USOc<2jmM^c&t28mc8iBuT~GrKSD( z+6C%aw`orWjz%&~AA+za85Fr&H9DT`EKS;WUOIJJ@onlir~_Wsovw3{hldAe9cP-( z=D&XK2XX&3o5G8wwlZlell-clE_d8{cytIR8A~!dT)NRpWwpTud@3xLbTATqX)Dja zjYr33TFk2G^6jc-|JX)$Z zw>}-yUuqjQuAgK2`U4^SGuGPjr38foT`$$YqApJ$TX&K5M$2wnVZJTC%Ph&wif6By zkT%yu85q zs}EV3c!z3vv7UMGl_@sUkK((mWfPUwBH2ek%%_cYS9??qd3*LBOK$e=^ResvOgH|62jAfZVednKs@%u^ye6*XrdEUZ zDjz%*+Vad({z*XW%-{vo4Q(@(36~T3JDkK8s6Skz76z&$UsevK zmusZ3JuG`slCwU&hmnzSb2DLHWTdNy88z_Q&xb#8_Z9aF((lLpCbL3=q=(xDL?aFn zHSr9!2u{wlbR9jt^p4gF&4BGyuhb4ATUog}t0m3mJr>!xxSpetw zQPGC0k?ra#&5?ZE!?cdiMk7Zt5t1=l))hKsYCL`CW1M1D%DrVI=hBC2{}1Bo3PX=S zRJSO3zw8nRU>zaQ*&C+BEb8;DnUMM1QyvmH&XG9+B6GG=ofx`Wnd8rz5ZO8#^G0bN zc~Vq!a|5opLBWaXNJ_1 zt7v9QGM?8#)yDC4#4Xn@RyfTxT6XdXw)(c}7RTcyAW+B$n6jul^t4J7M&DJ?J^;R) zI!p&iF+4nVPlUdc@zQPCk3NuVx+}xHR|KkGk0Y|HC8c)Su&|xZPrGw9Qd<-(0W&w5 z{8s2hN>^TQWjVFi@a(Q`6%gZbspVG`&st`YiYC3J7CxVpYpJ!wQBPTm$y`ofj}l8; zQXH<{e?EnilDup+0PE4iNu0BWtA!!x*Gqok_4q++q(5?{HY+^YL|sYlWBi}hD=Wt8 zV21Lvs?H7HR-g9QQcO5J+{$BJw(4KP$c~V~8GGq_*GWjkstnMpCit%$^3JmMigenF zkM-W%Ak;J)^HnYkdiz{Y#H-XZe;~br$eIA5f&SqJQ#qDE5`s5u?J+teLKDycz{78{ z*0=Oyb}nf!ZavS$u)uz>qx?28@jFdl6erB?4z={V;;~(?{i@=PfT-aK*f3i<^=NV5 zj=g;oql8>6EaOLXZ0yvB<~%)X>k&#J)&hJDQ^40(=|&sR>Ul_;Q46bwA7yeL+M@!9 zR5(LlLY6@LXA_`?ivpS=!$u5bH~$aQGCYHSF|o%8O-VO!K+n6pff!i6xQc7BAme#=GC{tWFOMn3$}(KqV*x z-�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

LvZK87xR4HVS0 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 From fe65df854303faa5567ad3eaec7b82291cad5bfc Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Thu, 20 Jul 2023 20:48:30 +0800 Subject: [PATCH 62/70] Add iswap() and its plotting. Hopefully, plot_circuit now supports all the basic gates. --- src/quafu/circuits/quantum_circuit.py | 11 ++++++ src/quafu/visualisation/circuitPlot.py | 47 +++++++++++++++++++------- 2 files changed, 45 insertions(+), 13 deletions(-) diff --git a/src/quafu/circuits/quantum_circuit.py b/src/quafu/circuits/quantum_circuit.py index ba946a4..db4c1f5 100644 --- a/src/quafu/circuits/quantum_circuit.py +++ b/src/quafu/circuits/quantum_circuit.py @@ -617,6 +617,17 @@ def swap(self, q1: int, q2: int) -> "QuantumCircuit": self.add_gate(qeg.SwapGate(q1, q2)) return self + def iswap(self, q1: int, q2: int) -> "QuantumCircuit": + """ + iSWAP gate + + Args: + q1 (int): qubit the gate act. + q2 (int): qubit the gate act. + """ + self.add_gate(qeg.ISwapGate(q1, q2)) + return self + def toffoli(self, ctrl1: int, ctrl2: int, targ: int) -> "QuantumCircuit": """ Toffoli gate diff --git a/src/quafu/visualisation/circuitPlot.py b/src/quafu/visualisation/circuitPlot.py index 3012bbc..9893cae 100644 --- a/src/quafu/visualisation/circuitPlot.py +++ b/src/quafu/visualisation/circuitPlot.py @@ -52,26 +52,28 @@ class CircuitPlotManager: To be initialized when circuit.plot() is called. """ + # colors _wire_color = '#FF0000' - _wire_lw = 1.5 - _light_blue = '#3B82F6' _ec = DEEPCOLOR + _wire_lw = 1.5 + _a_inch = 2 / 2.54 # physical lattice constant in inch _a = 0.5 # box width and height, unit: ax - _barrier_width = _a / 3 # barrier width _stroke = pe.withStroke(linewidth=2, foreground='white') def __init__(self, qc): """ - Processing graphical info from a quantum circuit, - whose gates are stored as a list at present. + Processing graphical info from a quantum circuit, decompose every + gate/instruction into graphical elements and send the latter into + corresponding containers. - In the future the circuit will be stored as a graph - or graph-like object, procedure will be much simplified. + At present quantum gates and barriers are stored as a list. In the + near future the circuit will be stored as a graph or graph-like object, + procedure will be much simplified, and more functions will be developed. (TODO) """ self.qbit_num = qc.num @@ -81,14 +83,13 @@ def __init__(self, qc): self._ctrl_wire_points = [] self._closed_patches = [] - self._mea_arc_patches = [] self._mea_point_patches = [] self._ctrl_points = [] self._not_points = [] self._swap_points = [] - + self._iswap_points = [] self._barrier_points = [] self._text_list = [] @@ -121,7 +122,15 @@ def __call__(self, *args, **kwargs): """ - + :param title + :param init_labels: dict, {qbit: label} + :param end_labels: dict, {qbit: label} + :param save_path: str, path to save the figure + :param show: bool, whether to show the figure + :param args: + :param kwargs: + + More customization will be supported in the future.(TODO) """ # Not supported by patch collections? # if 'xkcd' in kwargs: @@ -359,11 +368,11 @@ def _proc_ctrl(self, depth, ins: ControlledGate, ctrl_type: bool = True): def _proc_swap(self, depth, pos, iswap: bool = False): p1, p2 = pos - self._swap_points += [[depth, p] for p in pos] + nodes = [[depth, p] for p in pos] + self._swap_points += nodes self._ctrl_wire_points.append([[depth, p1], [depth, p2]]) if iswap: - # TODO: add circle on swap node - raise NotImplementedError + self._iswap_points += nodes def _proc_barrier(self, depth, pos: list): x0 = depth - self._barrier_width @@ -465,6 +474,18 @@ def _render_swap_nodes(self): ) plt.gca().add_collection(collection) + # iswap-cirlces + i_circles = [] + for x, y in self._iswap_points: + circle = Circle((x, y), radius=2 ** (1 / 2) * r, lw=3, + ec='#3B82F6', fill=False) + i_circles.append(circle) + collection = PatchCollection(i_circles, + match_original=True, + zorder=5, + ) + plt.gca().add_collection(collection) + def _render_measure(self): stroke = pe.withStroke(linewidth=4, foreground='white') arcs = PatchCollection(self._mea_arc_patches, From 28f70222b12d32a3616220c3fc163af325c76028 Mon Sep 17 00:00:00 2001 From: chensgit169 Date: Thu, 20 Jul 2023 21:23:06 +0800 Subject: [PATCH 63/70] delete local example in visualisation Please add circuit examples into module 'benchmark'. --- src/quafu/visualisation/examples/__init__.py | 0 .../visualisation/examples/basic_elements.py | 31 ------------------- 2 files changed, 31 deletions(-) delete mode 100644 src/quafu/visualisation/examples/__init__.py delete mode 100644 src/quafu/visualisation/examples/basic_elements.py diff --git a/src/quafu/visualisation/examples/__init__.py b/src/quafu/visualisation/examples/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/src/quafu/visualisation/examples/basic_elements.py b/src/quafu/visualisation/examples/basic_elements.py deleted file mode 100644 index b552572..0000000 --- a/src/quafu/visualisation/examples/basic_elements.py +++ /dev/null @@ -1,31 +0,0 @@ -import matplotlib.pyplot as plt -from quafu.visualisation.circuitPlot import CircuitPlotManager -from quafu.circuits.quantum_circuit import QuantumCircuit -import os - -if not os.path.exists('./figures/'): - os.mkdir('./figures/') - -n = 8 -qc_ = QuantumCircuit(n) -qc_.h(0) -qc_.barrier([0, 3]) -qc_.x(0) -qc_.swap(0, 4) -qc_.cnot(3, 6) -qc_.rz(4, 3.2) - -for k in range(10): - qc_.x(7) -for k in range(n): - qc_.cnot(k, k + 1) -qc_.measure([0, 1, 2, 3], [0, 1, 2, 3]) - -# for i in range(30): -# qc.x(4) - -cmp = CircuitPlotManager(qc_) -cmp(title='Basic Elements in Circuit') - -plt.savefig('./figures/basics.png', dpi=300, transparent=True) -plt.close() From 13050731374fd145ab7d9e21f678fa8d2eb7c0ff Mon Sep 17 00:00:00 2001 From: Zhaoyilunnn Date: Fri, 21 Jul 2023 06:20:09 +0000 Subject: [PATCH 64/70] update v0.3.0 --- .gitignore | 3 ++- setup.py | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index 511b07d..ab99f8f 100644 --- a/.gitignore +++ b/.gitignore @@ -14,4 +14,5 @@ cmake test .vscode thirdparty -.pyd \ No newline at end of file +.pyd +MANIFEST.in diff --git a/setup.py b/setup.py index 9dc1c98..deecdf1 100644 --- a/setup.py +++ b/setup.py @@ -28,7 +28,7 @@ setup( name="pyquafu", - version="0.2.11", + version="0.3.0", author="ssli", author_email="ssli@iphy.ac.cn", url="https://github.com/ScQ-Cloud/pyquafu", @@ -45,4 +45,4 @@ zip_safe=False, setup_cfg=True, license="Apache-2.0 License" -) \ No newline at end of file +) From 95ec9b4a1d8d2f0cb6e116f632ee1ee766b1678b Mon Sep 17 00:00:00 2001 From: chen_wei <109205133+chensgit169@users.noreply.github.com> Date: Fri, 21 Jul 2023 15:10:05 +0800 Subject: [PATCH 65/70] Update __init__.py update version number into "0.3.0" --- src/quafu/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/quafu/__init__.py b/src/quafu/__init__.py index 36699e6..7153ea2 100644 --- a/src/quafu/__init__.py +++ b/src/quafu/__init__.py @@ -8,4 +8,4 @@ def get_version(): - return "0.2.11" + return "0.3.0" From b9a91131ae4f6a529295af5a71916e0f74d5d69c Mon Sep 17 00:00:00 2001 From: chen_wei <109205133+chensgit169@users.noreply.github.com> Date: Fri, 21 Jul 2023 15:13:44 +0800 Subject: [PATCH 66/70] Update deutsch_jozsa.py delete redundant lines --- src/quafu/benchmark/deutsch_jozsa.py | 15 ++------------- 1 file changed, 2 insertions(+), 13 deletions(-) diff --git a/src/quafu/benchmark/deutsch_jozsa.py b/src/quafu/benchmark/deutsch_jozsa.py index 0d08b71..ad327f3 100644 --- a/src/quafu/benchmark/deutsch_jozsa.py +++ b/src/quafu/benchmark/deutsch_jozsa.py @@ -71,16 +71,5 @@ def deutsch_jozsa(n: int, case: str): return circuit -if __name__ == '__main__': - dj_qc = deutsch_jozsa(n=4, case='constant') - cmp = CircuitPlotManager(dj_qc) - cmp(title='Deutsch-Josza Circuit') - - dj_qc.plot_circuit(title='Deutsch-Josza Circuit') - # plt.show() - - import os - if not os.path.exists('./figures/'): - os.mkdir('./figures/') - plt.savefig('./figures/deutsch_jozsa.png', dpi=240) - # plt.show() +dj_qc = deutsch_jozsa(n=4, case='constant') +dj_qc.plot_circuit(title='Deutsch-Josza Circuit', show=True) From a8f2056a501807fd5023b8a70e0871f9b0d23c89 Mon Sep 17 00:00:00 2001 From: chen_wei <109205133+chensgit169@users.noreply.github.com> Date: Fri, 21 Jul 2023 15:34:26 +0800 Subject: [PATCH 67/70] Update circuit_error.py add TODO --- src/quafu/exceptions/circuit_error.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/quafu/exceptions/circuit_error.py b/src/quafu/exceptions/circuit_error.py index 3a0f95e..8dda42f 100644 --- a/src/quafu/exceptions/circuit_error.py +++ b/src/quafu/exceptions/circuit_error.py @@ -1,15 +1,19 @@ from .quafu_error import CircuitError +# TODO class IndexOutOfRangeError(CircuitError): """ """ + pass class InvalidParaError(CircuitError): """ """ + pass class UnsupportedYet(CircuitError): - """ For un-supported instructions """ + """ Un-supported instructions occurs""" + pass From 18550ddbe276505b1f33f5fd0a43ba88f95db190 Mon Sep 17 00:00:00 2001 From: chen_wei <109205133+chensgit169@users.noreply.github.com> Date: Fri, 21 Jul 2023 15:40:21 +0800 Subject: [PATCH 68/70] Delete dag.dot to be sent into documentation repository --- src/quafu/dagcircuits/dag.dot | 53 ----------------------------------- 1 file changed, 53 deletions(-) delete mode 100644 src/quafu/dagcircuits/dag.dot diff --git a/src/quafu/dagcircuits/dag.dot b/src/quafu/dagcircuits/dag.dot deleted file mode 100644 index 107d185..0000000 --- a/src/quafu/dagcircuits/dag.dot +++ /dev/null @@ -1,53 +0,0 @@ -digraph { -"-1" [color=green]; -"0{CX(0,1)}" [color=blue]; -"1{X(2)}" [color=blue]; -"2{CX(1,0)}" [color=blue]; -"3{CX(2,1)}" [color=blue]; -"4{CP(1,0)}(1.571)" [color=blue]; -"5{barrier(0,1,2)}" [color=blue]; -"6{RXX(0,1)}(1.571)" [color=blue]; -"7{delay(0)}" [color=blue]; -"8{CSWAP(0,1,2)}" [color=blue]; -"9{MCX(0,1,2)}" [color=blue]; -"10{MCY(0,1,2)}" [color=blue]; -"11{MCZ(0,1,2)}" [color=blue]; -"12{CT(2,1)}" [color=blue]; -"m{measure(0,1,2=>0,1,2)}" [color=blue]; -inf [color=red]; -"-1" -> "0{CX(0,1)}" [color=green, key=0, label=q0]; -"-1" -> "0{CX(0,1)}" [color=green, key=1, label=q1]; -"-1" -> "1{X(2)}" [color=green, key=0, label=q2]; -"0{CX(0,1)}" -> "2{CX(1,0)}" [key=0, label=q1]; -"0{CX(0,1)}" -> "2{CX(1,0)}" [key=1, label=q0]; -"1{X(2)}" -> "3{CX(2,1)}" [key=0, label=q2]; -"2{CX(1,0)}" -> "3{CX(2,1)}" [key=0, label=q1]; -"2{CX(1,0)}" -> "4{CP(1,0)}(1.571)" [key=0, label=q0]; -"3{CX(2,1)}" -> "4{CP(1,0)}(1.571)" [key=0, label=q1]; -"3{CX(2,1)}" -> "5{barrier(0,1,2)}" [key=0, label=q2]; -"4{CP(1,0)}(1.571)" -> "5{barrier(0,1,2)}" [key=0, label=q0]; -"4{CP(1,0)}(1.571)" -> "5{barrier(0,1,2)}" [key=1, label=q1]; -"5{barrier(0,1,2)}" -> "6{RXX(0,1)}(1.571)" [key=0, label=q0]; -"5{barrier(0,1,2)}" -> "6{RXX(0,1)}(1.571)" [key=1, label=q1]; -"5{barrier(0,1,2)}" -> "8{CSWAP(0,1,2)}" [key=0, label=q2]; -"6{RXX(0,1)}(1.571)" -> "7{delay(0)}" [key=0, label=q0]; -"6{RXX(0,1)}(1.571)" -> "8{CSWAP(0,1,2)}" [key=0, label=q1]; -"7{delay(0)}" -> "8{CSWAP(0,1,2)}" [key=0, label=q0]; -"8{CSWAP(0,1,2)}" -> "9{MCX(0,1,2)}" [key=0, label=q0]; -"8{CSWAP(0,1,2)}" -> "9{MCX(0,1,2)}" [key=1, label=q1]; -"8{CSWAP(0,1,2)}" -> "9{MCX(0,1,2)}" [key=2, label=q2]; -"9{MCX(0,1,2)}" -> "10{MCY(0,1,2)}" [key=0, label=q0]; -"9{MCX(0,1,2)}" -> "10{MCY(0,1,2)}" [key=1, label=q1]; -"9{MCX(0,1,2)}" -> "10{MCY(0,1,2)}" [key=2, label=q2]; -"10{MCY(0,1,2)}" -> "11{MCZ(0,1,2)}" [key=0, label=q0]; -"10{MCY(0,1,2)}" -> "11{MCZ(0,1,2)}" [key=1, label=q1]; -"10{MCY(0,1,2)}" -> "11{MCZ(0,1,2)}" [key=2, label=q2]; -"11{MCZ(0,1,2)}" -> "12{CT(2,1)}" [key=0, label=q2]; -"11{MCZ(0,1,2)}" -> "12{CT(2,1)}" [key=1, label=q1]; -"11{MCZ(0,1,2)}" -> "m{measure(0,1,2=>0,1,2)}" [key=0, label=q0]; -"12{CT(2,1)}" -> "m{measure(0,1,2=>0,1,2)}" [key=0, label=q1]; -"12{CT(2,1)}" -> "m{measure(0,1,2=>0,1,2)}" [key=1, label=q2]; -"m{measure(0,1,2=>0,1,2)}" -> inf [color=red, key=0, label=q0]; -"m{measure(0,1,2=>0,1,2)}" -> inf [color=red, key=1, label=q1]; -"m{measure(0,1,2=>0,1,2)}" -> inf [color=red, key=2, label=q2]; -} From 5a2e216e1be79dc9d319af84801839e7a376e6bc Mon Sep 17 00:00:00 2001 From: chen_wei <109205133+chensgit169@users.noreply.github.com> Date: Fri, 21 Jul 2023 15:40:45 +0800 Subject: [PATCH 69/70] Delete dag_test.ipynb to be sent into documentation repository --- src/quafu/dagcircuits/dag_test.ipynb | 458 --------------------------- 1 file changed, 458 deletions(-) delete mode 100644 src/quafu/dagcircuits/dag_test.ipynb diff --git a/src/quafu/dagcircuits/dag_test.ipynb b/src/quafu/dagcircuits/dag_test.ipynb deleted file mode 100644 index 2135d85..0000000 --- a/src/quafu/dagcircuits/dag_test.ipynb +++ /dev/null @@ -1,458 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# DAG examples" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "you should install `pygraphviz` ,`pydot` package for visualization \n", - "`pip install pygraphviz ` \n", - "`pip install pydot`" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from circuit_dag import circuit_to_dag, dag_to_circuit, draw_dag # instruction_node.py in the same folder as circuit_dag.py\n", - "from quafu import QuantumCircuit" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Transform circuit into dag" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# 创建一个量子电路作为示例，您可以根据需要修改这个电路\n", - "simple = QuantumCircuit(3)\n", - "simple.cnot(0, 1)\n", - "simple.cnot(1, 0)\n", - "simple.x(2)\n", - "simple.cnot(2, 1)\n", - "simple.cp(1, 0,np.pi / 2)\n", - "simple.barrier([0, 1, 2])\n", - "simple.rxx(0, 1, np.pi / 2)\n", - "simple.delay(0, 100)\n", - "simple.fredkin(0,1, 2)\n", - "simple.mcx([0, 1], 2)\n", - "# simple.measure([0], [0])\n", - "# simple.measure([1], [2])\n", - "simple.measure([2], [1])\n", - "\n", - "\n", - "\n", - "# 构建dag\n", - "dep_graph = circuit_to_dag(simple) # 更新为新的函数名\n", - "\n", - "# 可视化dag\n", - "draw_dag(dep_graph, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "# 在此处添加您的其它代码，例如模拟电路，分析结果等" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q[0] --*----+---------P(1.571)----||-------#---------Delay(100ns)----*----*--\n", - " | | | || RXX(1.571) | | \n", - "q[1] --+----*----+-------*--------||-------#-------------------------x----*--\n", - " | || | | \n", - "q[2] --X---------*----------------||---------------------------------x----X-- M->c[1]\n" - ] - } - ], - "source": [ - "simple.draw_circuit()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Transform dag into circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "%3\n", - "\n", - "\n", - "\n", - "-1\n", - "\n", - "-1\n", - "\n", - "\n", - "\n", - "0{CX(0,1)}\n", - "\n", - "0{CX(0,1)}\n", - "\n", - "\n", - "\n", - "-1->0{CX(0,1)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "-1->0{CX(0,1)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "1{X(2)}\n", - "\n", - "1{X(2)}\n", - "\n", - "\n", - "\n", - "-1->1{X(2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "2{CX(1,0)}\n", - "\n", - "2{CX(1,0)}\n", - "\n", - "\n", - "\n", - "0{CX(0,1)}->2{CX(1,0)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "0{CX(0,1)}->2{CX(1,0)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "3{CX(2,1)}\n", - "\n", - "3{CX(2,1)}\n", - "\n", - "\n", - "\n", - "1{X(2)}->3{CX(2,1)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "2{CX(1,0)}->3{CX(2,1)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "4{CP(1,0)}(1.571)\n", - "\n", - "4{CP(1,0)}(1.571)\n", - "\n", - "\n", - "\n", - "2{CX(1,0)}->4{CP(1,0)}(1.571)\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "3{CX(2,1)}->4{CP(1,0)}(1.571)\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "5{barrier(0,1,2)}\n", - "\n", - "5{barrier(0,1,2)}\n", - "\n", - "\n", - "\n", - "3{CX(2,1)}->5{barrier(0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "4{CP(1,0)}(1.571)->5{barrier(0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "4{CP(1,0)}(1.571)->5{barrier(0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "6{RXX(0,1)}(1.571)\n", - "\n", - "6{RXX(0,1)}(1.571)\n", - "\n", - "\n", - "\n", - "5{barrier(0,1,2)}->6{RXX(0,1)}(1.571)\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "5{barrier(0,1,2)}->6{RXX(0,1)}(1.571)\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "8{CSWAP(0,1,2)}\n", - "\n", - "8{CSWAP(0,1,2)}\n", - "\n", - "\n", - "\n", - "5{barrier(0,1,2)}->8{CSWAP(0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "6{RXX(0,1)}(1.571)->8{CSWAP(0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "7{delay(0)}\n", - "\n", - "7{delay(0)}\n", - "\n", - "\n", - "\n", - "6{RXX(0,1)}(1.571)->7{delay(0)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "9{MCX(0,1,2)}\n", - "\n", - "9{MCX(0,1,2)}\n", - "\n", - "\n", - "\n", - "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "7{delay(0)}->8{CSWAP(0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "m{measure(2=>1)}\n", - "\n", - "m{measure(2=>1)}\n", - "\n", - "\n", - "\n", - "9{MCX(0,1,2)}->m{measure(2=>1)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "inf\n", - "\n", - "inf\n", - "\n", - "\n", - "\n", - "9{MCX(0,1,2)}->inf\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "9{MCX(0,1,2)}->inf\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "m{measure(2=>1)}->inf\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# 从dag中重建量子电路\n", - "reconstructed_circuit = dag_to_circuit(dep_graph, simple.num) # 更新为新的函数名\n", - "\n", - "# 构建dag\n", - "dep_graph = circuit_to_dag(reconstructed_circuit) # 更新为新的函数名\n", - "\n", - "# 可视化dag\n", - "draw_dag(dep_graph, output_format=\"svg\") # 或者使用 \"png\" 作为输出格式\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q[0] --*----+---------P(1.571)----||-------#---------Delay(100ns)----*----*--\n", - " | | | || RXX(1.571) | | \n", - "q[1] --+----*----+-------*--------||-------#-------------------------x----*--\n", - " | || | | \n", - "q[2] --X---------*----------------||---------------------------------x----X-- M->c[1]\n" - ] - } - ], - "source": [ - "reconstructed_circuit.draw_circuit()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "ycquafu", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.15" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} From c6403b5ebcc38b64c8530fa3b66e827c07850014 Mon Sep 17 00:00:00 2001 From: chen_wei <109205133+chensgit169@users.noreply.github.com> Date: Fri, 21 Jul 2023 15:41:15 +0800 Subject: [PATCH 70/70] Delete dagcircuit_test.ipynb to be sent into documentation repository --- src/quafu/dagcircuits/dagcircuit_test.ipynb | 2976 ------------------- 1 file changed, 2976 deletions(-) delete mode 100644 src/quafu/dagcircuits/dagcircuit_test.ipynb diff --git a/src/quafu/dagcircuits/dagcircuit_test.ipynb b/src/quafu/dagcircuits/dagcircuit_test.ipynb deleted file mode 100644 index 7ec063a..0000000 --- a/src/quafu/dagcircuits/dagcircuit_test.ipynb +++ /dev/null @@ -1,2976 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# `DAG`\n", - "- circuit in quafu to dag\n", - "- dag visualization briefly\n", - "- dag to circuit in quafu" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from quafu import User,QuantumCircuit,Task ,simulate\n", - "import quafu\n", - "import networkx as nx\n", - "from typing import Dict, Any, List" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - " you should install `pygraphviz` ,`pydot` package for visualization \n", - " `pip install pygraphviz ` \n", - " `pip install pydot`\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import pygraphviz as pgv\n", - "from networkx.drawing.nx_pydot import write_dot" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "from networkx import MultiDiGraph" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# user = User()\n", - "# # user.save_apitoken(\"\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# task = Task()\n", - "# task.config(backend=\"ScQ-P18\", shots=2000, compile=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import Dict, Any, List, Union\n", - "import dataclasses\n", - "\n", - "@dataclasses.dataclass\n", - "class InstructionNode: \n", - " name:Any # gate.name\n", - " pos:Union[List[Any], Dict[Any,Any]] # gate.pos | Dict[Any,Any] for measure\n", - " paras:List[Any] # gate.paras\n", - " # matrix:List[Any] # for gate in [QuantumGate]\n", - " duration:Union[int,float] # for gate in [Delay,XYResonance] in quafu \n", - " unit:str # for gate in [Delay,XYResonance] in quafu\n", - " label:str\n", - " \n", - " def __hash__(self):\n", - " return hash((type(self.name), tuple(self.pos) ,self.label))\n", - " \n", - " def __str__(self):\n", - " if self.name == 'measure':\n", - " args = ','.join(str(q) for q in self.pos.keys())\n", - " args += f'=>{\",\".join(str(c) for c in self.pos.values())}'\n", - " else: \n", - " args = ','.join(str(q) for q in self.pos)\n", - " \n", - " if self.paras == None:\n", - " return f'{self.label}{{{self.name}({args})}}'\n", - " else:\n", - " # if self.paras not a list, then make it a list of str of .3f float\n", - " if not isinstance(self.paras, list):\n", - " formatted_paras = [f'{self.paras:.3f}']\n", - " else:\n", - " formatted_paras = [f'{p:.3f}' for p in self.paras] \n", - " \n", - " formatted_paras_str = ','.join(formatted_paras)\n", - " \n", - " return f'{self.label}{{{self.name}({args})}}({formatted_paras_str})'\n", - " \n", - " def __repr__(self): \n", - " return str(self)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## dagcircuit class" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "import networkx as nx\n", - "\n", - "from networkx.classes.multidigraph import MultiDiGraph\n", - "\n", - "class DAGCircuit(MultiDiGraph):\n", - " def __init__(self,qubits_used=None, cbits_used=None, incoming_graph_data=None, **attr):\n", - " super().__init__(incoming_graph_data, **attr)\n", - " \n", - " if qubits_used is None:\n", - " self.qubits_used = set()\n", - " elif isinstance(qubits_used, set):\n", - " self.qubits_used = qubits_used\n", - " else:\n", - " raise ValueError('qubits_used should be a set or None')\n", - "\n", - " if cbits_used is None:\n", - " self.cbits_used = set()\n", - " elif isinstance(cbits_used, set):\n", - " self.cbits_used = cbits_used\n", - " else:\n", - " raise ValueError('cbits_used should be a set or None')\n", - " \n", - " # num of instruction nodes\n", - " self.num_instruction_nodes = 0\n", - "\n", - "\n", - " # add new methods or override existing methods here.\n", - "\n", - " def update_qubits_used(self):\n", - " '''\n", - " qubits_used is a set of qubits used in DAGCircuit\n", - " based on node -1's edges' labels, the qubits is the integer part of the label\n", - "\n", - " return:\n", - " qubits_used: set of qubits used in DAGCircuit\n", - " '''\n", - " if -1 not in self.nodes:\n", - " raise ValueError('-1 should be in DAGCircuit, please add it first')\n", - " self.qubits_used = set([int(edge[2]['label'][1:]) for edge in self.out_edges(-1, data=True)])\n", - " return self.qubits_used\n", - " \n", - " def update_cbits_used(self):\n", - " '''\n", - " cbits_used is a set of cbits used in DAGCircuit\n", - " calculated by measurenode's cbits \n", - " return:\n", - " cbits_used: set of cbits used in DAGCircuit\n", - " '''\n", - " for node in self.nodes:\n", - " # if node.has a attribute 'name' and node.name == 'measure'\n", - " if hasattr(node, 'name') and node.name == 'measure':\n", - " self.cbits_used = set(node.pos.values()) \n", - " return self.cbits_used\n", - " \n", - " def update_num_instruction_nodes(self):\n", - " '''\n", - " num_instruction_nodes is the number of instruction nodes in DAGCircuit\n", - " '''\n", - " if -1 not in self.nodes:\n", - " raise ValueError('-1 should be in DAGCircuit, please add it first')\n", - " if float('inf') not in self.nodes:\n", - " raise ValueError('float(\"inf\") should be in DAGCircuit, please add it first')\n", - " self.num_instruction_nodes = len(self.nodes) - 2\n", - "\n", - " for node in self.nodes:\n", - " if hasattr(node, 'name') and node.name == 'measure':\n", - " self.num_instruction_nodes -= 1\n", - " return self.num_instruction_nodes\n", - "\n", - " \n", - "\n", - " def nodes_dict(self):\n", - " '''\n", - " nodes_dict is a dictionary of nodes with the node label as key and the node as value.\n", - " without -1 and float('inf')\n", - " '''\n", - " nodes_dict = {}\n", - " for node in self.nodes:\n", - " if node != -1 and node != float('inf'):\n", - " nodes_dict[node.label] = node\n", - " return nodes_dict\n", - " \n", - "\n", - " def nodes_list(self):\n", - " ''' \n", - " nodes_list is a list of nodes without -1 and float('inf')\n", - " ''' \n", - " nodes_list = []\n", - " for node in self.nodes:\n", - " if node != -1 and node != float('inf'):\n", - " nodes_list.append(node)\n", - " return nodes_list\n", - " \n", - " def node_qubits_predecessors(self, node:InstructionNode):\n", - " '''\n", - " node_qubits_predecessors is a dict of {qubits -> predecessors }of node\n", - " Args:\n", - " node in DAGCircuit, node should not be -1\n", - " Returns:\n", - " node_qubits_predecessors: dict of {qubits -> predecessors }of node\n", - " '''\n", - " # for edge in self.in_edges(node, data=True):\n", - " # print(edge[0], edge[1], edge[2])\n", - "\n", - " if node not in self.nodes:\n", - " raise ValueError('node should be in DAGCircuit')\n", - " if node in [-1]:\n", - " raise ValueError('-1 has no predecessors')\n", - "\n", - " predecessor_nodes = [edge[0] for edge in self.in_edges(node, data=True)]\n", - " qubits_labels = [int(edge[2]['label'][1:]) for edge in self.in_edges(node, data=True)]\n", - " node_qubits_predecessors = dict(zip(qubits_labels, predecessor_nodes))\n", - " return node_qubits_predecessors\n", - " \n", - " def node_qubits_successors(self, node:InstructionNode):\n", - " '''\n", - " node_qubits_successors is a dict of {qubits -> successors }of node\n", - " Args: \n", - " node in DAGCircuit, node should not be float('inf')\n", - " Returns:\n", - " node_qubits_successors: dict of {qubits -> successors }of node\n", - "\n", - "\n", - " '''\n", - " if node not in self.nodes:\n", - " raise ValueError('node should be in DAGCircuit')\n", - " if node in [float('inf')]:\n", - " raise ValueError('float(\"inf\") has no successors')\n", - " successor_nodes = [edge[1] for edge in self.out_edges(node, data=True)]\n", - " qubits_labels = [int(edge[2]['label'][1:]) for edge in self.out_edges(node, data=True)]\n", - " node_qubits_successors = dict(zip(qubits_labels, successor_nodes))\n", - " return node_qubits_successors\n", - "\n", - " def node_qubits_inedges(self, node:InstructionNode):\n", - " '''\n", - " node_qubits_inedges is a dict of {qubits -> inedges }of node\n", - " Args:\n", - " node in DAGCircuit, node should not be -1\n", - " Returns:\n", - " node_qubits_inedges: dict of {qubits -> inedges }of node\n", - " '''\n", - " if node not in self.nodes:\n", - " raise ValueError('node should be in DAGCircuit')\n", - " if node in [-1]:\n", - " raise ValueError('-1 has no predecessors')\n", - "\n", - " inedges = [edge for edge in self.in_edges(node)]\n", - " qubits_labels = [int(edge[2]['label'][1:]) for edge in self.in_edges(node, data=True)]\n", - " node_qubits_inedges = dict(zip(qubits_labels, inedges))\n", - " return node_qubits_inedges\n", - " \n", - " def node_qubits_outedges(self, node:InstructionNode):\n", - " '''\n", - " node_qubits_outedges is a dict of {qubits -> outedges }of node\n", - " Args:\n", - " node in DAGCircuit, node should not be float('inf')\n", - " Returns:\n", - " node_qubits_outedges: dict of {qubits -> outedges }of node\n", - " '''\n", - " if node not in self.nodes:\n", - " raise ValueError('node should be in DAGCircuit')\n", - " if node in [float('inf')]:\n", - " raise ValueError('float(\"inf\") has no successors')\n", - " outedges = [edge for edge in self.out_edges(node)]\n", - " qubits_labels = [int(edge[2]['label'][1:]) for edge in self.out_edges(node, data=True)]\n", - " node_qubits_outedges = dict(zip(qubits_labels, outedges))\n", - " return node_qubits_outedges\n", - " \n", - " def remove_instruction_node(self, gate:InstructionNode):\n", - " '''\n", - " remove a gate from DAGCircuit, and all edges connected to it.\n", - " add new edges about qubits of removed gate between all predecessors and successors of removed gate.\n", - " Args:\n", - " gate: InstructionNode, gate should be in DAGCircuit, gate should not be -1 or float('inf')\n", - " '''\n", - "\n", - " if gate not in self.nodes:\n", - " raise ValueError('gate should be in DAGCircuit')\n", - " if gate in [-1, float('inf')]:\n", - " raise ValueError('gate should not be -1 or float(\"inf\")')\n", - "\n", - " qubits_predecessors = self.node_qubits_predecessors(gate)\n", - " qubits_successors = self.node_qubits_successors(gate)\n", - " for qubit in gate.pos:\n", - " if qubits_predecessors[qubit] != -1 and qubits_successors[qubit] != float('inf'):\n", - " self.add_edge(qubits_predecessors[qubit], qubits_successors[qubit], label=f'q{qubit}')\n", - " elif qubits_predecessors[qubit] == -1 and qubits_successors[qubit] != float('inf'):\n", - " self.add_edge(qubits_predecessors[qubit], qubits_successors[qubit], label=f'q{qubit}',color='green')\n", - " else:\n", - " self.add_edge(qubits_predecessors[qubit], qubits_successors[qubit], label=f'q{qubit}',color='red')\n", - "\n", - " self.remove_node(gate)\n", - "\n", - " # update qubits\n", - " self.qubits_used = self.update_qubits_used()\n", - "\n", - "\n", - " def merge_dag(self, other_dag):\n", - " '''\n", - " merge other_dag into self\n", - " Args:\n", - " other_dag: DAGCircuit\n", - " Returns:\n", - " self: DAGCircuit\n", - " '''\n", - " if not isinstance(other_dag, DAGCircuit):\n", - " raise ValueError('other_dag should be a DAGCircuit')\n", - " if other_dag == None:\n", - " return self\n", - " if self == None:\n", - " return other_dag\n", - " \n", - " # for the same qubits (intersection), \n", - " # remove the outgoing edges from the final node of the original DAG and the incoming edges from the initial node of the other DAG,\n", - " # then connect the corresponding tail and head nodes by adding edges\n", - " other_dag_qubits_used = other_dag.update_qubits_used()\n", - " self_qubits_used = self.update_qubits_used()\n", - "\n", - " insect_qubits = self_qubits_used & other_dag_qubits_used\n", - " end_edges_labels_1 = self.node_qubits_inedges(float('inf'))\n", - " start_edges_labels_2 = other_dag.node_qubits_outedges(-1)\n", - "\n", - " if len(insect_qubits) != 0:\n", - " for insect_qubit in insect_qubits:\n", - " self.remove_edges_from([end_edges_labels_1[insect_qubit]])\n", - " other_dag.remove_edges_from([start_edges_labels_2[insect_qubit]])\n", - " self.add_edge(end_edges_labels_1[insect_qubit][0], start_edges_labels_2[insect_qubit][1], label=f'q{insect_qubit}')\n", - " \n", - " # add other_dag's nodes and edges into self\n", - " # ！if we add edges, we don't need to add nodes again\n", - " self.add_edges_from(other_dag.edges(data=True))\n", - "\n", - " # remove the edges between -1 and float('inf')\n", - " self.remove_edges_from([edge for edge in self.edges(data=True) if edge[0] == -1 and edge[1] == float('inf')])\n", - " \n", - " # update qubits \n", - " self.qubits_used = self.update_qubits_used()\n", - " \n", - " def add_instruction_node(self, gate:InstructionNode,predecessors_dict:Dict[int,InstructionNode],successors_dict:Dict[int,InstructionNode]):\n", - " '''\n", - " add a gate into DAGCircuit, and all edges connected to it.\n", - " add new edges about qubits of new gate between all predecessors and successors of new gate.\n", - " Args:\n", - " gate: InstructionNode, gate should not be -1 or float('inf')\n", - " predecessors_dict: dict of {qubits -> predecessors }of gate\n", - " successors_dict: dict of {qubits -> successors }of gate\n", - " '''\n", - " if gate in [-1, float('inf')]:\n", - " raise ValueError('gate should not be -1 or float(\"inf\")')\n", - " \n", - " #remove the edges between the predessors,successors about the qubits used by the added node\n", - " qubits_pre_out_edges = []\n", - " qubits_suc_in_edges = []\n", - " for qubit in gate.pos:\n", - " pre_out_edges = self.node_qubits_outedges(predecessors_dict[qubit])\n", - " qubits_pre_out_edges.append(pre_out_edges[qubit])\n", - "\n", - " suc_in_edges = self.node_qubits_inedges(successors_dict[qubit])\n", - " qubits_suc_in_edges.append(suc_in_edges[qubit])\n", - "\n", - " self.remove_edges_from(qubits_pre_out_edges)\n", - " self.remove_edges_from(qubits_suc_in_edges)\n", - "\n", - " # add the new node and edges\n", - " for qubit in gate.pos:\n", - " if predecessors_dict[qubit] == -1:\n", - " self.add_edge(predecessors_dict[qubit], gate, label=f'q{qubit}',color='green')\n", - " else:\n", - " self.add_edge(predecessors_dict[qubit], gate, label=f'q{qubit}')\n", - " if successors_dict[qubit] == float('inf'):\n", - " self.add_edge(gate, successors_dict[qubit], label=f'q{qubit}',color='red')\n", - " else:\n", - " self.add_edge(gate, successors_dict[qubit], label=f'q{qubit}')\n", - "\n", - " # update qubits\n", - " self.qubits_used = self.update_qubits_used()\n", - "\n", - "\n", - " def is_dag(self):\n", - " '''\n", - " is_dag is a bool value to check if DAGCircuit is a DAG\n", - " '''\n", - " return nx.is_directed_acyclic_graph(self)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from quafu import QuantumCircuit\n", - "\n", - "from quafu.elements.element_gates import * \n", - "from quafu.elements.quantum_element import Barrier, Delay, ControlledGate, MultiQubitGate, ParaMultiQubitGate, QuantumGate, SingleQubitGate, XYResonance\n", - "\n", - "import networkx as nx\n", - "from typing import Dict, Any, List, Union\n", - "import copy\n", - "\n", - "# from instruction_node import InstructionNode # instruction_node.py in the same folder as circuit_dag.py now\n", - "\n", - "# import pygraphviz as pgv\n", - "from networkx.drawing.nx_pydot import write_dot\n", - "from IPython.display import Image, SVG\n", - "\n", - "\n", - "\n", - "# transform a gate in quantumcircuit of quafu(not include measure_gate),\n", - "# into a node in the graph, with specific label.\n", - "def gate_to_node(input_gate,specific_label: str):\n", - " ''' \n", - " transform a gate in quantumcircuit of quafu(not include measure_gate),\n", - " into a node in the graph, with specific label.\n", - "\n", - " Args:\n", - " inputgate: a gate in quantumcircuit of quafu(not include measure_gate)\n", - " label: the label of the node in the graph\n", - "\n", - " Returns:\n", - " node: a node in the graph, with specific label. A GateWrapper object\n", - " \n", - " '''\n", - "\n", - " import copy\n", - " gate = copy.deepcopy(input_gate) # avoid modifying the original gate\n", - " if not isinstance(gate.pos, list): # if gate.pos is not a list, make it a list\n", - " gate.pos = [gate.pos]\n", - "\n", - " # use getattr check 'paras' and other attributes if exist. if the attr doesn't exist,return None\n", - " gate.paras = getattr(gate, 'paras', None) or None\n", - " gate.duration = getattr(gate, 'duration', None) or None\n", - " gate.unit = getattr(gate, 'unit', None) or None \n", - "\n", - " if gate.paras and not isinstance(gate.paras, list): # if paras is True and not a list, make it a list\n", - " gate.paras = [gate.paras]\n", - " \n", - " # hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.matrix,gate.duration,gate.unit, label=i)\n", - " hashable_gate = InstructionNode(gate.name, gate.pos, gate.paras,gate.duration,gate.unit, label=specific_label)\n", - " return hashable_gate\n", - "\n", - "\n", - "# Building a DAG Graph using NetworkX from a QuantumCircuit\n", - "def circuit_to_dag(circuit,measure_flag = True):\n", - " '''\n", - " Building a DAG Graph using NetworkX from a QuantumCircuit\n", - " \n", - " Args:\n", - " circuit: a QuantumCircuit object\n", - " \n", - " Returns:\n", - " g: a networkx MultiDiGraph object\n", - " \n", - " example:\n", - " .. jupyter-execute::\n", - " \n", - " from circuit_dag import circuit_to_dag, dag_to_circuit, draw_dag\n", - " from quafu import QuantumCircuit\n", - "\n", - " # Create a quantum circuit as an example that you can modify as needed\n", - " circuit = QuantumCircuit(2)\n", - " circuit.h(0)\n", - " circuit.cnot(0, 1)\n", - "\n", - " # Build the dag graph\n", - " dep_graph = circuit_to_dag(circuit) # dag graph \n", - " '''\n", - " \n", - " # Starting Label Index\n", - " i = 0\n", - " \n", - " # A dictionary to store the last use of any qubit\n", - " qubit_last_use = {}\n", - " \n", - " # g = nx.MultiDiGraph() # two nodes can have multiple edges\n", - " # g = nx.DiGraph() # two nodes can only have one edge\n", - " g = DAGCircuit() # two nodes can only have one edge\n", - " \n", - " # Add the start node \n", - " # g.add_node(-1,{\"color\": \"green\"})\n", - " g.add_nodes_from([(-1, {\"color\": \"green\"})])\n", - " \n", - " # deepcopy the circuit to avoid modifying the original circuit\n", - " # gates = copy.deepcopy(circuit.gates) # need to import copy\n", - " # change to: gate = copy.deepcopy(input_gate) in gate_to_node()\n", - "\n", - " for gate in circuit.gates:\n", - " # transform gate to node\n", - " hashable_gate = gate_to_node(gate,specific_label=i)\n", - " i += 1\n", - " \n", - " g.add_node(hashable_gate,color=\"blue\")\n", - " \n", - " # Add edges based on qubit_last_use; update last use\n", - " for qubit in hashable_gate.pos:\n", - " if qubit in qubit_last_use:\n", - " g.add_edge(qubit_last_use[qubit], hashable_gate,label=f'q{qubit}')\n", - " else:\n", - " g.add_edge(-1, hashable_gate,label=f'q{qubit}',color=\"green\")\n", - " \n", - " qubit_last_use[qubit] = hashable_gate\n", - "\n", - " if measure_flag: \n", - " # Add measure_gate node\n", - " qm = Any\n", - " qm.name = \"measure\" \n", - " qm.paras, qm.duration, qm.unit = [None,None,None]\n", - " qm.pos = copy.deepcopy(circuit.measures) # circuit.measures is a dict\n", - " measure_gate = InstructionNode(qm.name, qm.pos, qm.paras, qm.duration, qm.unit, label=\"m\")\n", - " g.add_node(measure_gate,color=\"blue\")\n", - " # Add edges from qubit_last_use[qubit] to measure_gate\n", - " for qubit in measure_gate.pos:\n", - " if qubit in qubit_last_use:\n", - " g.add_edge(qubit_last_use[qubit], measure_gate,label=f'q{qubit}')\n", - " else:\n", - " g.add_edge(-1, measure_gate,label=f'q{qubit}',color=\"green\")\n", - "\n", - " qubit_last_use[qubit] = measure_gate\n", - " \n", - " # Add the end node\n", - " # g.add_node(float('inf'),{\"color\": \"red\"})\n", - " g.add_nodes_from([(float('inf'), {\"color\": \"red\"})])\n", - " \n", - " for qubit in qubit_last_use:\n", - " g.add_edge(qubit_last_use[qubit], float('inf'),label=f'q{qubit}',color=\"red\")\n", - " \n", - " # update qubits_used, cbits_used, num_instruction_nodes\n", - " g.update_qubits_used()\n", - " g.update_cbits_used()\n", - " g.update_num_instruction_nodes()\n", - "\n", - " return g\n", - "\n", - "\n", - "# transform gate in dag nodes to gate in circuit which can be added to circuit\n", - "gate_classes = {\n", - " \"x\": XGate,\n", - " \"y\": YGate,\n", - " \"z\": ZGate,\n", - " \"h\": HGate,\n", - " \"s\": SGate,\n", - " \"sdg\": SdgGate,\n", - " \"t\": TGate,\n", - " \"tdg\": TdgGate,\n", - " \"rx\": RXGate,\n", - " \"ry\": RYGate,\n", - " \"rz\": RZGate,\n", - " \"id\": IdGate,\n", - " \"sx\": SXGate,\n", - " \"sy\": SYGate,\n", - " \"w\": WGate,\n", - " \"sw\": SWGate,\n", - " \"p\": PhaseGate,\n", - " \"delay\": Delay,\n", - " \"barrier\": Barrier,\n", - " \"cx\": CXGate,\n", - " \"cp\": CPGate,\n", - " \"swap\": SwapGate,\n", - " \"rxx\": RXXGate,\n", - " \"ryy\": RYYGate,\n", - " \"rzz\": RZZGate,\n", - " \"cy\": CYGate,\n", - " \"cz\": CZGate,\n", - " \"cs\": CSGate,\n", - " \"ct\": CTGate,\n", - " \"xy\": XYResonance,\n", - " \"ccx\": ToffoliGate,\n", - " \"cswap\": FredkinGate,\n", - " \"mcx\": MCXGate,\n", - " \"mcy\": MCYGate,\n", - " \"mcz\": MCZGate,\n", - "}\n", - "\n", - "def node_to_gate(gate_in_dag):\n", - " \"\"\"\n", - " transform gate in dag graph, to gate in circuit which can be added to circuit\n", - "\n", - " Args:\n", - " gate_in_dag: a node in dag graph , gate_in_dag is a GateWrapper object. \n", - " in GateWrapper, gate_in_dag.name is uppercase, gate_in_dag.pos is a list or a dict\n", - " gate_transform support gate with one qubit or more qubits, not measures!\n", - " and you should exculde nodes [-1 ,float('inf') , measure_gate] in dag graph\n", - "\n", - " Returns:\n", - " gate: gate which can be added to circuit in quafu\n", - "\n", - " example:\n", - " import networkx as nx\n", - " from quafu import QuantumCircuit\n", - " qcircuit = QuantumCircuit(n)\n", - "\n", - " for gate in nx.topological_sort(dep_graph):\n", - " \n", - " if gate not in [-1, float('inf')]:\n", - " # measure gate to do\n", - " if gate.name == \"measure\":\n", - " qcircuit.measures = gate.pos\n", - "\n", - " else:\n", - " # use gate_transform to transform gate in dag graph to gate in circuit\n", - " qcircuit.gates.append(node_to_gate(gate))\n", - " return qcircuit\n", - " \n", - " \"\"\"\n", - "\n", - " gate_name = gate_in_dag.name.lower()\n", - " gate_class = gate_classes.get(gate_name)\n", - "\n", - " if not gate_class:\n", - " raise ValueError(\"gate is not supported\")\n", - "\n", - " if gate_name == \"barrier\":\n", - " return gate_class(gate_in_dag.pos)\n", - "\n", - " # 从gate_in_dag获取参数列表\n", - " args = gate_in_dag.pos\n", - " if gate_in_dag.paras:\n", - " args += gate_in_dag.paras\n", - "\n", - " # 处理 gate.duration 和 gate.unit\n", - " if gate_name in [\"delay\", \"xy\"]:\n", - " args.append(gate_in_dag.duration)\n", - " args.append(gate_in_dag.unit)\n", - "\n", - " # 处理多量子比特门\n", - " if gate_name in [\"mcx\", \"mcy\", \"mcz\"]:\n", - " control_qubits = gate_in_dag.pos[:-1]\n", - " target_qubit = gate_in_dag.pos[-1]\n", - " return gate_class(control_qubits, target_qubit)\n", - "\n", - " return gate_class(*args)\n", - "\n", - "\n", - "\n", - "# From DAG with Hashable Gates to quafu Gates added to circuit \n", - "def dag_to_circuit(dep_graph, n: int):\n", - " '''\n", - " From DAG with Hashable Gates to quafu Gates added to circuit\n", - " \n", - " Args:\n", - " dep_graph (DAG): DAG with Hashable Gates\n", - " n (int): number of qubits\n", - " \n", - " Returns:\n", - " qcircuit (QuantumCircuit): quafu QuantumCircuit\n", - " \n", - " example:\n", - " .. jupyter-execute::\n", - "\n", - " from circuit_dag import circuit_to_dag, dag_to_circuit, draw_dag\n", - " from quafu import QuantumCircuit\n", - "\n", - " # Create a quantum circuit as an example that you can modify as needed\n", - " circuit = QuantumCircuit(2)\n", - " circuit.h(0)\n", - " circuit.cnot(0, 1)\n", - "\n", - " # Build the dag graph\n", - " dep_graph = circuit_to_dag(circuit) # dag graph \n", - " \n", - " # use dag_to_circuit to transform dag graph to a new circuit\n", - " reconstructed_circuit = dag_to_circuit(dep_graph, circuit.num)\n", - " \n", - " \n", - " '''\n", - " \n", - " qcircuit = QuantumCircuit(n)\n", - "\n", - " for gate in nx.topological_sort(dep_graph):\n", - " \n", - " if gate not in [-1, float('inf')]:\n", - " # measure gate to do\n", - " if gate.name == \"measure\":\n", - " qcircuit.measures = gate.pos\n", - "\n", - " else:\n", - " # use gate_transform to transform gate in dag graph to gate in circuit\n", - " qcircuit.gates.append(node_to_gate(gate))\n", - " return qcircuit\n", - "\n", - "# Helper function to visualize the DAG,check the example in the docstring\n", - "def draw_dag(dep_g, output_format=\"png\"):\n", - " '''\n", - " Helper function to visualize the DAG\n", - "\n", - " Args:\n", - " dep_g (DAG): DAG with Hashable Gates\n", - " output_format (str): output format, \"png\" or \"svg\"\n", - "\n", - " Returns:\n", - " img (Image or SVG): show the image of DAG, which is Image(filename=\"dag.png\") or SVG(filename=\"dag.svg\")\n", - "\n", - " example:\n", - " .. jupyter-execute::\n", - " ex1:\n", - " # directly draw PNG picture\n", - " draw_dag(dep_g, output_format=\"png\") # save a png picture \"dag.png\" and show it in jupyter notebook\n", - "\n", - " # directly draw SVG picture\n", - " draw_dag(dep_g, output_format=\"svg\") # save a svg picture \"dag.svg\" and show it in jupyter notebook\n", - " \n", - " ex2:\n", - " # generate PNG picture\n", - " img_png = draw_dag(dep_g, output_format=\"png\") \n", - "\n", - " # generate SVG picture\n", - " img_svg = draw_dag(dep_g, output_format=\"svg\") \n", - " \n", - " # show PNG picture\n", - " img_png\n", - " \n", - " # show SVG picture\n", - " img_svg \n", - "\n", - " \n", - " '''\n", - " import pygraphviz \n", - "\n", - " write_dot(dep_g, \"dag.dot\")\n", - " G = pygraphviz.AGraph(\"dag.dot\")\n", - " G.layout(prog=\"dot\")\n", - "\n", - " if output_format == \"png\":\n", - " G.draw(\"dag.png\")\n", - " return Image(filename=\"dag.png\")\n", - " elif output_format == \"svg\":\n", - " G.draw(\"dag.svg\")\n", - " return SVG(filename=\"dag.svg\")\n", - " else:\n", - " raise ValueError(\"Unsupported output format: choose either 'png' or 'svg'\")\n", - "\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Transforming QuantumCircuit into DAG" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "from circuit_dag import circuit_to_dag, dag_to_circuit, draw_dag\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# 创建一个量子电路作为示例，您可以根据需要修改这个电路\n", - "simple = QuantumCircuit(3)\n", - "simple.measure([2], [1])\n", - "simple.cnot(0, 1)\n", - "simple.cnot(1, 0)\n", - "simple.x(2)\n", - "simple.cnot(2, 1)\n", - "simple.cp(1, 0,np.pi / 2)\n", - "simple.barrier([0, 1, 2])\n", - "simple.rxx(0, 1, np.pi / 2)\n", - "simple.delay(0, 100)\n", - "simple.fredkin(0,1, 2)\n", - "simple.mcx([0, 1], 2)\n", - "simple.mcy([0, 1], 2)\n", - "simple.mcz([0, 1], 2)\n", - "simple.ct(2,1)\n", - "# simple.measure([0], [0])\n", - "# simple.measure([1], [2])\n", - "simple.measure([1,2], [1,2])\n", - "\n", - "\n", - "\n", - "# 构建dag\n", - "dep_graph = circuit_to_dag(simple, measure_flag = False) # dag graph\n", - "\n", - "# 可视化dag\n", - "draw_dag(dep_graph, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "# 在此处添加您的其它代码，例如模拟电路，分析结果等" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dag_circuit.DAGCircuit" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(dep_graph)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## remove node" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "dep_graph_copy = copy.deepcopy(dep_graph)\n", - "nodes = copy.deepcopy(list(dep_graph_copy.nodes()))\n", - "nogate_nodes = [nodes[0],nodes[-2],nodes[-1]] # -1,inf,measure node\n", - "# dep_graph_copy.remove_nodes_from(nogate_nodes) # remove -1,inf,measure node\n", - "# dep_graph_copy.remove_nodes_from([nodes[6]]) # remove -1,inf,measure node" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "# i = 14\n", - "# nodes[i].name, nodes[i].pos, nodes[i].paras, nodes[i].duration, nodes[i].unit,nodes[i].label\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "# for predecessor in dep_graph_copy.predecessors(nodes[i]):\n", - "# print(predecessor.name, predecessor.pos, predecessor.paras, predecessor.duration, predecessor.unit, predecessor.label)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "# for successor in dep_graph_copy.successors(nodes[i]):\n", - "# print(successor.name, successor.pos, successor.paras, successor.duration, successor.unit, successor.label)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "# for edge in dep_graph_copy.in_edges(nodes[i], data=True):\n", - "# print(edge[0], edge[1], edge[2])\n", - "# predecessor_nodes = [edge[0] for edge in dep_graph_copy.in_edges(nodes[i], data=True)]\n", - "# labels = [int(edge[2]['label'][1:]) for edge in dep_graph_copy.in_edges(nodes[i], data=True)]\n", - "# labels\n", - "# # get a dict about keys are the predecessors of the node and values are the labels of the edges\n", - "# predecessor_labels = dict(zip(labels,predecessor_nodes))\n", - "# predecessor_labels,predecessor_labels.keys(),predecessor_labels.values()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "# successor_nodes = [edge[1] for edge in dep_graph_copy.out_edges(nodes[i], data=True)]\n", - "# labels = [int(edge[2]['label'][1:]) for edge in dep_graph_copy.out_edges(nodes[i], data=True)]\n", - "# labels\n", - "# # get a dict about keys are the successors of the node and values are the labels of the edges\n", - "# successor_labels = dict(zip(labels,successor_nodes))\n", - "# successor_labels,successor_labels.keys(),successor_labels.values()" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "# successors = list(dep_graph_copy.successors(nodes[i]))\n", - "# predecessors = list(dep_graph_copy.predecessors(nodes[i]))\n", - "\n", - "# # for successor in successors:\n", - "# # self.remove_edge(node, successor)\n", - "# # for predecessor in predecessors:\n", - "# # self.add_edge(predecessor, successor, label=None, color='black')\n", - "# # self.remove_node(node)\n", - "# for successor in successors:\n", - "# dep_graph_copy.remove_edge(nodes[i], successor)\n", - "# # for predecessor in predecessors:\n", - "# for qubit in nodes[i].pos:\n", - "# if predecessor_labels[qubit] != -1 and successor_labels[qubit] != float('inf'):\n", - "# dep_graph_copy.add_edge(predecessor_labels[qubit], successor_labels[qubit], label=f\"q{qubit}\")\n", - "# elif predecessor_labels[qubit] == -1 and successor_labels[qubit] != float('inf'):\n", - "# dep_graph_copy.add_edge(predecessor_labels[qubit], successor_labels[qubit], label=f\"q{qubit}\", color='green')\n", - "# else:\n", - "# dep_graph_copy.add_edge(predecessor_labels[qubit], successor_labels[qubit], label=f\"q{qubit}\", color='red')\n", - "# dep_graph_copy.remove_node(nodes[i])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[(-1, {'color': 'green'}),\n", - " (0{CX(0,1)}, {'color': 'blue'}),\n", - " (1{CX(1,0)}, {'color': 'blue'}),\n", - " (2{X(2)}, {'color': 'blue'}),\n", - " (3{CX(2,1)}, {'color': 'blue'}),\n", - " (4{CP(1,0)}(1.571), {'color': 'blue'}),\n", - " (5{barrier(0,1,2)}, {'color': 'blue'}),\n", - " (6{RXX(0,1)}(1.571), {'color': 'blue'}),\n", - " (7{delay(0)}, {'color': 'blue'}),\n", - " (8{CSWAP(0,1,2)}, {'color': 'blue'}),\n", - " (9{MCX(0,1,2)}, {'color': 'blue'}),\n", - " (10{MCY(0,1,2)}, {'color': 'blue'}),\n", - " (11{MCZ(0,1,2)}, {'color': 'blue'}),\n", - " (12{CT(2,1)}, {'color': 'blue'}),\n", - " (inf, {'color': 'red'})]" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "list(dep_graph_copy.nodes(data=True))" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "%3\n", - "\n", - "\n", - "\n", - "-1\n", - "\n", - "-1\n", - "\n", - "\n", - "\n", - "0{CX(0,1)}\n", - "\n", - "0{CX(0,1)}\n", - "\n", - "\n", - "\n", - "-1->0{CX(0,1)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "-1->0{CX(0,1)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "2{X(2)}\n", - "\n", - "2{X(2)}\n", - "\n", - "\n", - "\n", - "-1->2{X(2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "1{CX(1,0)}\n", - "\n", - "1{CX(1,0)}\n", - "\n", - "\n", - "\n", - "0{CX(0,1)}->1{CX(1,0)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "0{CX(0,1)}->1{CX(1,0)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "3{CX(2,1)}\n", - "\n", - "3{CX(2,1)}\n", - "\n", - "\n", - "\n", - "2{X(2)}->3{CX(2,1)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "1{CX(1,0)}->3{CX(2,1)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "4{CP(1,0)}(1.571)\n", - "\n", - "4{CP(1,0)}(1.571)\n", - "\n", - "\n", - "\n", - "1{CX(1,0)}->4{CP(1,0)}(1.571)\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "3{CX(2,1)}->4{CP(1,0)}(1.571)\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "5{barrier(0,1,2)}\n", - "\n", - "5{barrier(0,1,2)}\n", - "\n", - "\n", - "\n", - "3{CX(2,1)}->5{barrier(0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "4{CP(1,0)}(1.571)->5{barrier(0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "4{CP(1,0)}(1.571)->5{barrier(0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "6{RXX(0,1)}(1.571)\n", - "\n", - "6{RXX(0,1)}(1.571)\n", - "\n", - "\n", - "\n", - "5{barrier(0,1,2)}->6{RXX(0,1)}(1.571)\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "5{barrier(0,1,2)}->6{RXX(0,1)}(1.571)\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "8{CSWAP(0,1,2)}\n", - "\n", - "8{CSWAP(0,1,2)}\n", - "\n", - "\n", - "\n", - "5{barrier(0,1,2)}->8{CSWAP(0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "6{RXX(0,1)}(1.571)->8{CSWAP(0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "7{delay(0)}\n", - "\n", - "7{delay(0)}\n", - "\n", - "\n", - "\n", - "6{RXX(0,1)}(1.571)->7{delay(0)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "9{MCX(0,1,2)}\n", - "\n", - "9{MCX(0,1,2)}\n", - "\n", - "\n", - "\n", - "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "7{delay(0)}->8{CSWAP(0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "10{MCY(0,1,2)}\n", - "\n", - "10{MCY(0,1,2)}\n", - "\n", - "\n", - "\n", - "9{MCX(0,1,2)}->10{MCY(0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "9{MCX(0,1,2)}->10{MCY(0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "9{MCX(0,1,2)}->10{MCY(0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "11{MCZ(0,1,2)}\n", - "\n", - "11{MCZ(0,1,2)}\n", - "\n", - "\n", - "\n", - "10{MCY(0,1,2)}->11{MCZ(0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "10{MCY(0,1,2)}->11{MCZ(0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "10{MCY(0,1,2)}->11{MCZ(0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "12{CT(2,1)}\n", - "\n", - "12{CT(2,1)}\n", - "\n", - "\n", - "\n", - "11{MCZ(0,1,2)}->12{CT(2,1)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "11{MCZ(0,1,2)}->12{CT(2,1)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "inf\n", - "\n", - "inf\n", - "\n", - "\n", - "\n", - "11{MCZ(0,1,2)}->inf\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "12{CT(2,1)}->inf\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "12{CT(2,1)}->inf\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# # get the dag nodes\n", - "# nodes = list(dep_graph.nodes(data=True))\n", - "# print(\"dag nodes:\", nodes)\n", - "\n", - "# # get the dag edges\n", - "# edges = list(dep_graph.edges(data=True))\n", - "# print(\"dag edges:\", edges)\n", - "\n", - "draw_dag(dep_graph, output_format=\"svg\") # 或者使用 \"svg\" 作为输出格式,默认为png" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{0: 0{CX(0,1)},\n", - " 2: 2{X(2)},\n", - " 1: 1{CX(1,0)},\n", - " 3: 3{CX(2,1)},\n", - " 4: 4{CP(1,0)}(1.571),\n", - " 5: 5{barrier(0,1,2)},\n", - " 6: 6{RXX(0,1)}(1.571),\n", - " 7: 7{delay(0)},\n", - " 8: 8{CSWAP(0,1,2)},\n", - " 9: 9{MCX(0,1,2)},\n", - " 10: 10{MCY(0,1,2)},\n", - " 11: 11{MCZ(0,1,2)},\n", - " 12: 12{CT(2,1)}}" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mynodes_dict = dep_graph_copy.nodes_dict()\n", - "mynodes_dict" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "dep_graph_copy.remove_instruction_node(mynodes_dict[5])" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAXHCAYAAAC3KyDIAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdd1zV9f7A8ddhiCiguFmOcuMqc1aaiiaas2tiVpp6o0wzG+ZoWP28dRt6rUwtS8tciSbXkSP0um24xb1QUAQUQVkyPr8/PkIgQ8bhfM/B99PHeWDf7/d8Pu9j+n2fz/yalFIKIYQQ4u5i7IyOQAghhO2QpCGEEKLQJGkIIYQoNAejAxBCaIkkEk44scRygxukk0488QC44w5AZSpTjWp44IETTkaGK+5RkjSEsLAIItjDHkJv/zrKUS5wIStBFFY1qlGb2vje/tWc5rSjHVWpWkqRCwEmmT0lROmKI461rOU3fmMb2zjDGeyw4z7uoxnNaEpT6lIXDzzwwotqVMMFF+yxxw03AGKJzSoriigiieQiFwkjjMMcJpRQLnIRO+zwxZfHeIzut3+Vp7yRH1+ULTGSNIQoBTe5yTKWEUQQm9mMQtGBDjzGY3SiE+1pT0UqmrXOa1xjJzvZevvXPvZRgQr0oheDGUwf+uCIo1nrFPccSRpCmFMoocxmNgtZyC1u4Y8/AxjAEzyRNS5hKZe4RDDBrGQlW9hCDWowkpEEEog33haNRZQZkjSEMIcjHOETPmExi7mP+xjJSEYwgupUNzo0QCeQhSxkFrOIJJIAAniP97if+40OTdgWWdwnRElEEEEAAbSgBUc4wgpWcIITvMVbVpMwADzx5C3e4jSn+Yqv2M52mtKU13ityAPw4t4mSUOIYkgnnRnMoAlN+JM/WclK9rKXfvTDhMno8PJVjnK8wAuc5CQzmcmP/EgTmrCMZUaHJmyEJA0hiiiCCPzwYxKTeJVXOcIR+tPfqpPFnRxx5EVe5AQn6EUvhjCEZ3iGG9wwOjRh5WRMQ4gi2MAGhjKU6lRnCUtoRSujQzKL9axnGMNww42VrKQ5zY0OSVgnGdMQorAWsIA+9MEff/7irzKTMAB60pODHMQTTzrRif/xP6NDElZKkoYQhTCd6YxgBBOYwI/8aPY1FtagFrXYyEZ60IOe9GQ1q40OSVgh6Z4S4i7mM5+RjGQ603mVV40Op9RlkMFLvMRCFrKBDTzKo0aHJKyHrNMQoiAb2MATPMEkJvEBHxgdjsWkk04AAfzGb+xhD41oZHRIwjpI0hAiP1e4Qkta4ocfP/GT0eFYXAopdKITqaSym92yq64AGQgXIn8jGIELLsxmttGhGMIJJxazmDOc4W3eNjocYSUkaQiRhzWs4Vd+ZQELcMXV6HBYt24dDRs2xMHBsk8zuJ/7+YzPmMlMTnLSonUL6yTdU0LcIZ10WtCCpjRlOcsNjeXMmTOMHz+esLAwzp8/T0JCAmlpaRaNIZ10WtGKhjRkBSssWrewOtI9JcSd1rGOYxxjGtOMDoV33nmHjh07snfvXlxdjWnx2GPPh3zIL/zCGc4YEoOwHtLSEOIOAxjADW7wG78ZHQpJSUk4OzsD4O3tTWRkpMVbGqBbG/WoxzCG8SEfWrx+YTWkpSFEdje5yVrWMoxhRocCkJUwjGaPPUMZyhKWGB2KMJgkDSGy2cMeUknFDz+jQ7E63ejGGc4QQYTRoQgDSdIQIpvd7M56XrfIqR3tsMeePewxOhRhIEkaQmQTRpisfs6HK6544EEYYUaHIgwkSUOIbK5ylapUtVh9R44cwWQy5XiNGTPGYvUXVTWqcZWrRochDGTZlUJCWLlEEi2aNJo1a4YtTWCsSEVuctPoMISBpKUhRDbuuBNLrNFhWK1rXKMKVYwOQxhIkoYQ2VSjGtFEGx2G1YommmpUMzoMYSBJGkJk44svBzlIOulGh2J1LnCBGGJoRjOjQxEGkqQhRDYd6Ug88RzlqNGhALBmzZqsAfKIiAjS09Oz/nvevHkWjWUXu3DEkTa0sWi9wrrINiJCZJNOOp54MoYxvMM7RodjVQII4BKX2MY2o0MRxpFtRITIzh57nuEZ5jOfDDKMDsdqXOUqwQTzPM8bHYowmCQNIe4wkpGc5zz/5b9Gh2I1ZjObcpRjEIOMDkUYTLqnhMhDAAEc4ACHOYwjjkaHY6hooqlPfd7kTXmCn5DuKSHy8i/+xTnO8QVfGB2K4SYykYpUZDzjjQ5FWAFJGkLk4T7u4z3eYwpT2M9+o8MxzApWMJ/5fM3XVKSi0eEIKyDdU0LkI4MM/PAjggh2scui24tYg2McoyMdeZqnmcUso8MR1iFGkoYQBbjMZR7mYWpQgxBC7plv2xe5yMM8TB3qsIlNlKe80SEJ6yBjGkIUxAMPNrCBc5yjL32JJ97okEpdGGF0pzuVqMR/+a8kDJGDJA0h7qIBDdjIRo5xjM505jKXjQ6p1BziEB3piBNObGAD7rgbHZKwMpI0hCiElrRkF7tIJpm2tC2Tq6IXs5hHeIRGNGIb2/DE0+iQhBWSpCFEIdWlLrvYRSta0YUuTGUqqaQaHVaJ3eAGIxjBMzzDCEawnvVUopLRYQkrJUlDiCIII4wTnKAKVfiET3iAB9jKVqPDKralLKUxjVnNaoIJ5j/8h3KUMzosYcUkaQhRSD/yIw/zMJ54cpCDHOEIdalLF7oQQIDV7IxbGNvZzmM8xlCG0oteHOc4fehjdFjCBkjSEOIuEkgggACe53ne5E1CCMETT+7jPtawhlWs4ihHaU5zhjCEvew1OuQ8KRSb2ERXutKJTpgwsYtdfMu399waFFF8kjSEKMB5ztORjmxmMxvZyFSmYo99jmv60pcDHGAZyzjGMR7iIdrQhnnMI444gyL/WySRfMqnNKQhPeiBCRP/439sYQvtaGd0eMLGyOI+IfKxgx38g39Qk5qsYhX1qFfo981lLkEEoVB0oxtP8iS96EUtapVy1NoZzrCa1axkJTvZiRtuPMuzBBKIL74WiUGUSbIiXIi8zGY24xhHP/qxgAXFWgkeS2zWjXsjG0kiiYY0pBOd6EhHmtOcpjSlAhVKFOt1rnOEIxziEDvZyVa2EkEElalMH/owkIE8zuM441yieoRAkoYQOSkUb/Im05nOVKbyDu9gwlTichNIYCc72cY2trKVvewliSTssKMe9ahDHbzwwgMPqlAla1GdO+6kk0488Vk/r3CFSCIJJ5zznOciFwFwxJH61OcZnqETnWhLW5kJJcxNkoYQmW5xi+d5niCCmM98nubpUqvrJCfpSlcmM5lrXCOccC7d/hV7+5dCcZ3r2GFHJSphjz1uuFGDGtSiFt5444MPzWiGL758zuf8wi+c4YwkC1FaJGkIAXCTmwxiEDvYwXKW05OepVrfeMZn3eDvHFgvrotc5H7uZx7zeI7nzFKmEHeQpCFENNE8zuNEEsk61tGKVqVa301u4o03b/M2b/CGWct+juf4i784whHsZHKkMD/Z5Vbc26KIoitdiSc+a4uQ0raABaSSyghGmL3sSUziBCdYwxqzly0EyJRbcQ+LIopudOMmN9nCFupSt9TrVCia0pTOdGYOc0qljj70IZpo9rCnVMoX9zRpaYh7U2bCSCGF7Wy3SMIA2MAGjnOc0YwutTqmMIXf+Z3tbC+1OsS9S1oa4p5zlat0ohOppLKFLXjhZbG6e9ObFFL4jd9KtZ5HeZRKVJJuKmFu0tIQ95ZEEulDHxJIsHjCOM1p1rOesYwt9bre4i3Wspb97C/1usS9RVoa4p6RTjqDGMQ2trGDHTSmsUXrH8c4ggk26zTb/CgUD/IgvvjyEz+Val3iniItDXHvGMc41rOeYIItnjBucIMf+IGxjC31hAFgwsTrvM5SlnKGM6Ven7h3SNIQ94RpTGMuc1nGMh7mYYvXv4AFpJFWKtNs8xNAAD748B/+Y7E6RdknSUOUeRvYwLu8y3/4jyEPGsogg5nMZDjDs/aUsgQHHHiN15jHPCKJtFi9omyTpCHKtAtc4BmeIYAAXuZlQ2IIJpiznGUMYyxe90hG4oors5hl8bpF2SQD4aLMSiGFR3iEFFLYw54Sb0FeXJ3ohDvuBBNsSP0f8iEzmEEYYbjiakgMosyQgXBRdr3CK5ziFCtZaVjC2MtetrOd8Yw3pH6Al3mZVFL5ju8Mi0GUHdLSEGXSWtbyBE+wkpUMYIBhcQxlKIc5zEEOmuW5HMX1Cq/wX/7LaU7jgINhcQibJ7vcirInjjia05zOdGYhCw2LI4II7uM+vuVbw7cqP8c5GtCAJSxhEIMMjUXYNEkaouwZwQjWsIZQQqlOdcPimMhEFrCAMMJwwsmwODI9yZNc5CJ/8IfRoQjbJWMaomwJIYQFLGA2sw1NGIkkMo95jGWsVSQM0A9++pM/2c1uo0MRNkxaGqLMSCGFxjSmHe1YylJDY5nFLN7kTS5wgWpUMzSW7NrTHh98WM5yo0MRtklaGqLs+IqvuMIVPuMzQ+NQKL7iK57jOatKGACv8mrWY2aFKA5JGqJMiCOOj/iIV3kVb7wNjWU1qznBCV7hFUPjyMs/+AdeePEVXxkdirBRkjREmfAJn5BBhtmfuV0cn/IpvehFU5oaHUouDjgwlrF8x3dc57rR4QgbJElD2LzLXGYmM5nCFKpQxdBYfud3drCDt3jL0DgK8gIvYIcd85hndCjCBslAuLB5E5jAYhZzmtOUp7yhsfSjH5FE8ju/GxrH3YxnPEEEcZazOOJodDjCdshAuLBtiSTyHd/xMi8XO2EcOHCA3r17U7lyZVxdXfHz82Pnzp1FLucEJ1jDGiYxqVhxZLdu3ToaNmyIg0PprN5+lVeJJJIggsxedmxsLHPmzKFr165UqVIFZ2dnGjRowNChQzl48KDZ6xOWJUlD2LSFLCSBBEYysljv//333+nYsSOurq4cO3aMc+fOcd999/HYY4+xcePGIpX1CZ/QgAb0pW+xYgE4c+YMffv2ZdKkSVy5cqXY5dxNHeowgAF8zudmL/vNN99k7Nix9OvXj6NHj3L16lW+//57Dhw4QOvWrVm1apXZ6xSWI91Twqa1oAVtaFOszfgyMjJo0aIF165d48yZMzg7OwOQnp6Or68viYmJnDp1Cienuy/Oy9wy5Gu+LnYCA3j66adp0aIFb7zxBnXr1iUyMpK0tLRil1eQP/mTtrRlG9t4lEfNVu6oUaOwt7dn7ty5OY4fPHiQVq1a0aBBA06ePGm2+oRFxaCEsFH71X6FQu1Wu4v1/i1btihAjR07Nte5qVOnKkAFBQUVqqw31ZuqpqqpklRSsWLJlJiYmPV7Ly8vZW9vX6Ly7qaD6qAGqAGlWkd2zs7Oys7OTmVkZFisTmFW0dI9JWzWUpZSj3q0o12x3r9582YAHnrooVznMo+FhITctZx44vmGb3iN10o8EJ/Z2rGU8YwnmGBOc7rU60pISCApKYlmzZphMhm3468oGUkawiYpFMtYRgABObYcP378OP3796dSpUpUqFCBtm3bsmbNGvz8/DCZTJhMJkaNGpV1LYC3d+7FgF5eXgCF6kb5mq9RKF7ghVznihKPEQYykLrUZSYzC7zOHJ9j+XK9dcmUKVPMFr8wgNFtHSGK40/1p0Kh9ql9WcdOnTqlKleurLy8vNTGjRvVjRs31JEjR5Sfn5+qXr26cnJyylFG9+7dFaD27NmTq/xTp04pQD344IMFxpGskpWn8lQT1IQ8yyhKPHeyRPeUUkrNUDNURVVRxarYPM+X9HMopVRkZKSqWbOmGjVqlLnDF5YVLUlD2KQP1YfKU3mqDPV33/igQYPyHIeIiopSFSpUKFLSOHnypAJU69atC4xjnpqnyqlyKkJF5DpX1HjuZKmkEa/ilatyVf9R/8nzfEk/R0xMjGrVqpUaPHiwSktLM1vcwhAypiFs0yY20YMeObqm1q9fD8Djjz+e49rq1avTuHHjXGVUrlwZ0H3td8o8lnlNXtJJ59/8m2d5Fk88c50vajxGccWVp3maWcxCkXsyZUk+R0JCAo8//jhNmzZl0aJF2Nvbmy9wYQhJGsLmJJDA7/xOd7pnHUtJSeHGjRuUL18eFxeXXO9xd3fPdSzzhhceHp7rXEREBAANGzbMN46lLOUsZ5nAhFznihOPkcYyllOcIoScA/8l+RxpaWkMGjQILy8vfvjhB0kYZYQkDWFzdrCDFFLoStesY05OTri6upKcnMzNmzdzvScqKirXsS5dugCwd+/eXOcyj3Xr1i3PGDLI4GM+ZghDaEjuxFKceIzkiy+P8Ahf83WO4yX5HIGBgaSkpPDzzz/nWNlev3599uzZY77ghUVJ0hA25w/+oB71qEWtHMf9/f2Bv7tTMkVGRuY5C6pz5840bdqUoKAgkpOTs46np6ezdOlSfHx86N27d54xrGAFRzla4MaERY3HaC/zMv/lv4QRluN4cT7H1KlTCQ0NJTg4uFCLI4UNMXpURYii6qP6qKfUU7mOnz59WlWpUiXHLJ/Dhw+rnj17qjp16uQ5YLt7925Vvnx5FRAQoC5fvqxiYmJUYGCgcnBwUOvXr8+z/gyVoR5UD+YZQ0njyc5SA+GZbqlbylN5qilqSo7jRf0c8+fPV0CBr927i7cgUxhOZk8J2+OhPNSn6tM8z504cUL1799fubm5qQoVKqiOHTuqrVu3qm7duuV7k963b5/y9/dXbm5uysXFRXXt2lXt2LEj3/pXqVXKpEzqoDp411iLGs/q1avzvdF+++23d62vpN5Wb6vqqrpKVsnF/hy9e/eWpFF2RcveU8KmXOEKtahFCCE5xjTuxs/Pjx07duTohiqutrTFCy9+4Zdil2HOeMzpEpeoS10WsICnefqu11vr5xClRrZGF7blGMcAaEITQ+r/lV/5kz+ZzGRD6i9tnnjShz65BsSFyCRJQ9iU4xzHDTc88DCk/n/xL3rRiza0MaR+SxjNaHayk33sMzoUYYUkaQibcoITRWplLF26FJPJREhICCkpKSXa6ymEEHawo0StDHPGU1q60Q1ffJnL3HyvsYXPIUqHjGkIm9KPfrjiyk/8ZPG6H+MxHHFkE5ssXrelfcEXTGIS4YTjjnUtRBSGkjENYVvCCceb3LvSlrYtbGErW3mHdyxetxGe53nssedHfjQ6FGFlJGkImxJBBF54WbzeKUzhcR6nE50sXrcRMvej+oqv8tyPSty7JGkIm5FKKtFEWzxpBBPMHvbwAR9YtF6jjWUsZziTaz8qcW+TpCFsRgwxZJBBdapbrM4MMniP93iSJ2lLW4vVaw0y96OaxSyjQxFWRJKGsBmxxAJYdGB2MYs5wpF7rpWRaTSjWc1qznPe6FCElZCkIWyGpZNGKqlMZSrP8ZxhiwmNNpCBVKc685hndCjCSkjSEDYjjjgAKlHJIvXNYx4XuXjPzJjKSznKMYIRzGc+aaQZHY6wApI0hM24iX6eQ0UqlnpdySTzL/7FS7xEPeqVen3WbBSjiCSS9ay/+8WizJOkIWzGLW5RjnI5HvFaWr7gC2KJZRKTSr0ua1ePenSmM9/xndGhCCsgSUPYjMykYU572cstbuU4Fkccn/AJ4xlPTWqatT5bNZKRrGENl7hkdCjCYLKNiLBKF7jAalZzk5vEEUciiRzmMPvYR1vacpObxN/+5Ydfsb8Fd6EL5znPDGbQn/4AvMM7fMVXnOWsbKFxWzLJeOLJW7d/iXtWjCQNYZXiiccDD1JIwQEHFIoMMvIcjP2ar3mJl4pVjzvuxBGHQvEIj/A+79Of/rzN20xgQkk/RpkylrFsZCPHOW6RLkJhlWTvKWGd3HBjCEOww44UUrjFrXxn7/SiV7HquMQlrnM9a5uMPeyhG91wwYV+9Ct27GXVP/knJznJdrYbHYowkCQNYbXGMIZUUgu8pilNqUOdYpV/iEM5/jszKcUQQ0taMpGJWTO2BLSgBa1pLQPi9zhJGsJqtaIVLWiBXT5/TctRjoEMLHb5hzmc58B6KqmkkMJnfEYDGrCIRbJp322jGMVylnOd60aHIgwiSUNYtTGMyffcLW7Rm97FLvsQh0gnPd/z6aRnrU+4W4vnXjGEIQD8zM8GRyKMIgPhwqrd5CY1qUkiibnOueNODDH5tkTupjGNOcGJAq95hVeYwYxi11EWBRBABBEytnFvkoFwYd1ccGEYw3J1IzniSD/6FftmnkoqZziT5zkTJuyw42u+ZiYzJWHc4VmeZSc78/3zE2Wb/GsQVu9FXsy1AC+NNJ7giWKXeYxjec7GssceJ5wIJrjY03jLusd5nJrUNOSRu8J4kjSE1WtBCx7ioRzf+O2xpwc9il3mIQ7lakE44khlKrODHSVKSGWdAw4MYQgLWSgTBO5BkjSETXiZl7N+b4cdj/IorrgWu7zDHMYBh6z/dsSRutRlL3tpTesSxXoveJZnOcMZdrPb6FCEhUnSEDZhMIOzdre1wy5ry4/i2s/+rBlRDjjwAA+wi13FXvNxr3mAB2hOcxay0OhQhIVJ0hA2wRlnRjACEybSSCvRVFuAAxxAobDDjoEMZBvbqEY1M0V7b3iGZ1jGMlJIMToUYUEy5VZYlevXITkZEhMhLg4yMiAhAW7dgosVjzOiQ1O8Eu/nq42nSL1j6YSTE1SokPOYszOULw+OjuDiAq6ukOh8lbouOkFMYAIf87HspVQMl7hEbWqzjGU8yZNGhyMsQzYsFOZ36xZERkJ4OERHw7VrcPWq/hkT8/fvr17VCSE2VieKpKRCFL79UdjTHt78tPgBdtkCm7rj9MaXuP70Em5u4OYGVatCtWpQpYr+ffafNWqAtzfUrAn29sWvuqzpQQ9ccWUFK4wORViGJA1RdJGRcPYsnDkD587B5csQEaFfly7BlSuQ/W+Vi8vfN+DsrypV9Dl3d90acHaGSpX07ytW1Ddye/ucLYigcovxzPCmm2MnypfPGVdmiyS7GzcgLU0fT0iA+HgIrvEt5a/XotHJPiQn62Px8X8ntOxJ7dq1nMnMwUEnDm9v8PAAHx/w9IR69eD+++G++/TnulfMYx5jGUsUUSWamCBshiQNkbe4ODhyRL9Onfo7SZw5o2++oG/mdevmvHl6eua8oVavrq8zlxRSsMc+x8ynoirqw5wSE3WivHRJt54uX4aLF/XP8HCdLC9e1MkJdBLMTCD33w8NG0Lz5tC0qU6MZclVrlKLWvzETwxmsNHhiNInSeNel54OR4/CwYM6QRw+DKGhEBamz7u66pve/ffnfnl5gZ1MpQB0wggL+zuxZn+dOqW73+ztdSJp0QJ8fXUiadUK6tc3OvqS6UEP3HAjiCCjQxGlT5LGvebSJdi79+/Xzp16TMHBAWrX1t+GW7fWN7WmTaFJE0kMJZWerhNKaKhO0KGh+s/+xAl9zs1NJ5BHHoGHH4b27XULzVZ8wzeMZzxXuIILLkaHI0qXJI2y7vx5CAmBzZth61bdlWJvr5NB27b61a6dThKOjkZHe29JSoL9++GPP/5+nbm9nVPDhtC5M3TrBl266IF4axVDDB54sIhFPMVTRocjSpckjbImNhY2bNBJIiREj0VUqKC/wXbpAh066JaEq4xZWqWYGJ08du/W/w//+EO3Rpo1g65dwc9PJxJrGxvxww933FnOcqNDEaVLkkZZEBUF69fD8uWwcaO+ybRqpW8wfn662+POmUbCNiQk6ATy22/6tX+/nljQrRv06QP9+unZXEaby1xe4zWiiMpauS/KJEkatioyEhYuhJ9/1v3jLi7g7w/9+0OvXnrqqih7IiMhOBhWrYItW/QXhE6dICAABg/W4yNGyOyiWsxiBjHImCCEJUjSsCWpqbB2LXz/Pfz6q+5i+sc/YMAA3XVhzqmtwvrFx+u/B7/8ohOJnZ3++zBihE4kJgsvcu9GN6pSVZ7qV7ZJ0rAF0dEwcyZ8+63u8+7WTd8Y+veXbiehXb8OS5bA/Pnw5596SvTYsTBqlF4oaQlzmMPrvC5dVGWbJA1rdv48fP65bllUrAijR+tkUbu20ZEJa3bkCHzzjf574+ysk8eYMaW/Uj2aaDzxZClLZS+qskuShjW6cgUmT4Yff9Srq19/XSeLOzfjE6IgMTHw5Zfw1Vd6G5Vx42DSpNJteXShCzWpyVKWll4lwkjyjHBrkpamu6EaNdIzZb7/Xq8mHjNGEoYoumrV4P339cLC996DWbP0+pzlpTgrdhCDWM1qEkgovUqEoSRpWImDB+HBB+Gtt3SSOHYMnn1Wr9QWoiRcXOCNN+D4cT0Fe/Bg/TMiwvx1DWQgKaSwgQ3mL1xYBUkaVuCHH/Siu6pVdX/0//1f6bcsDhw4QO/evalcuTKurq74+fmxc+fOu74vPT2dSZMm0aBBA8qXL4+/v3++1/75558MHz6cevXq4ezsTJUqVWjWrBlPPvkks2fP5szt5c/NmjXDZDLleAUEBGSV4+fnl+PcQw89lKuusLAw+vbtS3x8vFk+Z17WrVtHw4YNcSggk0+cOJFly5ble/7555/HycmJevXqMW7cOJKTk4sVS3HUrKlbr7t26e1kHnxQT9s1p1rUoiMdCSbYvAUL66GEYVJTlQoMVMpkUuqtt5RKS7NMvXv27FHOzs5q8ODB6tKlSyo6Olr985//VA4ODmrDhg0Fvnfu3LkKUB988IGKjY3N85r09HT1xhtvKAcHB/Xmm2+qY8eOqeTkZBUZGak2btyo/Pz8FKAAlZqaqpRSKjIyUlWtWlUB6qeffspV5tq1a1WDBg1UQkJCrnP79+9X1apVU19++aXZPmd2p0+fVn369FEtWrRQbm5uyt7evsBr69Wrp95+++18r4mPj1dz5sxRgJo2bVqh4zCn+HilBg1SysFBqc8+M2/Z/1b/VlVVVZWmLPQXWlhStCQNg6SmKvXUU0pVrKjUL79Yrt709HTl6+urPDw8VGJiYtbxtLQ01ahRI+Xj46OSk5Pzff+QIUMUoOLj4/O9ZvLkyQpQ33zzTZ7n09LSlL+/f46koZRSixYtUoCqWrWqioyMzDp+7do15ePjo3bu3JmrrLi4OOXt7a0CAwPN+jnv/MwfffSRSk1NVV5eXgUmDaWUOnDggDKZTGrZsmUFXlehQtStbrYAACAASURBVAXVo0ePQsVQGjIydMKws1Nq6lTzlXtUHVUo1A61w3yFCmshScMor72mVIUKSv3vf5atd8uWLQpQY8eOzXVu6tSpClBBQUH5vr9Hjx4F3jSPHTum7OzsVOvWrQuMY9euXbmShlJK9e3bVwHqySefzDo2dOhQNWHChDzLmTJlinJwcFARERE5jpf0c2aXPekUJmkopdSgQYOUt7d3rs+Xnaen513/nCzh2291a/f7781XZgPVQE1UE81XoLAW0TKmYYB162D6dL1Yr3Nny9a9efNmgDzHBTKPhYSE5Pv+9PT0Asv/5ptvyMjIYNCggreS6NChA0qpXOMDc+bMwd3dnRUrVhAUFMSqVas4cOAAH3zwQa4ylFLMmzePdu3a4enpmeNcST9nds7F2B1wwIABhIeHs3bt2nyvMZlMpGU+uclAo0bpqbijR8PJk+Ypsze9Wc1q8xQmrIokDQtLS9OLrQIC4OmnLV//8ePHAfD29s51zsvLC4CTJbhzbNu2DYAWLVoU6/0eHh7MmDEDgJdffpkxY8bwww8/4JTHHikHDx7kypUrtGzZMte50v6cd9OqVSsANmywjVlE778PjRvDa6+Zp7wneIJQQjnNafMUKKyGJA0L++9/9bz5adOMqf/69esAVMxjhZeLi36ATmxsbL7vv3XrVp438EyXLl0CoGrVqsWOcdiwYfTq1YuoqCjq169P69at87zuyJEjQN6JoaSfs6QyE1NmjHlxcnIiNTW11GIoCgcHPWtv3To9NbekOtGJylRmHetKXpiwKpI0LGz1ar1V+X33GR1Jbur25gCmAna6u3DhQp436TsVVEZhNGjQAICtW7cSHJz39M3Lly8DUKmIW/oW5nOWlJubGyaTKSvGvHh6ehIREWEVXVSgd0muXh3WrCl5WY440oMe0kVVBknSsLAjR/TT8oxSuXJlABIScq/YzTyWeU12165d49NPPyUsLIzRo0fnW37m2EJMTEyxY9y+fTsrV65k+vTpALz44ot5tgoy1zg45vHIweJ+TnNycHAgKSkp3/OBgYHEx8fz7rvvlujPy1zs7KBNG/2ceHPoQx+2spU44sxToLAKkjQs7OZNvULXKI0bNwYgPDw817mI20uEGzZsmOP48OHDqVq1KhMnTmTChAm88sor+Zbf+fbI/qFDh4oV382bNxk+fDjffPMN48ePx9/fn8jISMaNG5fr2vK3t/jNq4unOJ/T3NLS0gocRH/mmWeYNm0an376KdWrV6dnz56lGk9huLrCjRvmKasXvVAoNrHJPAUKqyBJw8Jq1NCrcY3SpUsXAPbu3ZvrXOaxbt265Ti+YMEC4uLiWLp0KdOnTycwMDDf8gMDA3FwcCAoKKjAOCZMmICdnV3WgHWm119/HT8/v6wb6Ny5c3Fzc2PhwoWsuaPfxMPDA4C4uNzfZIvzOc0pPj4epVRWjHmZMmUKkydPZvbs2Vy/fp3169eXWjyFFREBtWqZp6wqVKEDHaSLqqwxdMbvPeitt5SqX18vrDJCenq6atq0qfL09FRJSUlZx9PS0lSTJk2Uj49PjuN3atOmjXJ3dy+wjg8//FAB6rvvvsvz/PHjx5Wbm5saPHhwjuPr169X9erVy7Vw8JtvvlGA8vT0zLEKff/+/QpQo0ePNvvnzE9h12kcPXpUAeqll17K95rGjRurevXqFTmG0nL9ulJOTkr9+KP5ypTV4WWOLO6ztIMHlQKl1q0zLobdu3er8uXLq4CAAHX58mUVExOjAgMDlYODg1q/fn2B7+3WrVuhbpoTJ05Ujo6O6q233lInTpxQKSkpKjw8XM2bN095eHioRx55RN28eTPr+tjYWOXj46O2bNmSZ3mZW48MHz4861hGRoaqUaOGevjhh83yOYcOHaoAdfbs2Xw/V2GTxuLFixWgfilgub+Xl5dq2bLlXcuylH//WylXV508zEVWh5c5kjSM0K+fUo0aKVWML7pms2/fPuXv76/c3NyUi4uL6tq1q9qx4+7/sP38/Ap101RKqT/++EM9++yzysfHRzk6OipXV1fVvn17NXPmTJWSkpJ1nZeXV9ZeVIDq169f1rnY2Ngc5zJfM2bMUErpLUvyWhFenM/ZtWtX5eLiotLu2ARs9erVecYAqG+//TbPsgYNGqS8vLzUrVu38v3z8fLyUq1atcr3vCWFhyvl5qbUlCnmL1tWh5cpkjSMEBamVOXKSj33nNGRFF3v3r2VyWQyOows169fV15eXrn2niqq2NhY5ezsrEaNGlXimDL3nlqyZEmB19WsWVO1b9++xPWVVHKyUh066C8y2XZMMZtX1avKV/mav2BhBNlGxAi1a8Pixfr1+utGR1M03t7eKKW4cuWK0aEAeo3G6tWrCQoKYtasWcUqQynFK6+8gpubGx9++GGJ4jl79iwDBw5k0qRJObZ3v1NqairXrl0r1JqX0pSSAk8+qZ/fsmqVfjysufWmN6GEcpGL5i9cWJwkDYP4+8NPP8EXX+gtRW7eNDqiwsmc1fTxxx9z9epVg6PRHnjgAf766y9+/fXXXM/TKIwrV65w9uxZQkJCqFXCqUNz585l2rRpTCtgyX9cXBzTp08nNTXV0Gm2ERHQtSvs2AEbNuhtRErDIzxCBSqwkY2lU4GwKHlGuMG2bdNPUqtUCVasAF9foyO6u08++YQFCxZw9uxZunTpwq+//mp0SDZj+PDhLF68mDp16jBkyBDee+897O3tLR7H9u36752rK6xcWfp/7/zxxw03lpH/A6qETYiRpGEFwsPhH/+Ao0fh3Xdh3DjIY5GzECUWHw9Tp8KXX0K/fjB/vk4cpW0GM/iQD4kmGnssnySF2cRI95QV8PbWLY7XXtNJo0UL2CSLaIUZKaUfK9yoESxcCF9/DcuXWyZhAPSgB7HE8hd/WaZCUWokaViJcuX0N8CjR6FJE+jRA3r31t0IQhRXRobufmrbFkaO1IPeJ07AP/8JpbhfYy6++OKDj4xrlAGSNKxM3br6H/mmTXoPoE6d9K64q1frb4tCFMatW7rrydcXBg3SM/b27YOvvoIqVYyJqTvdJWmUAZI0rJSfn+6y2rED3N11/7OvL3z2GVjJbFdhhU6fhrff1lvvv/gidOgAoaF6kkUxn4tlNt3pzh72yK63Nk4Gwm3E4cMwezYsWaKn5/bqBSNG6J8yaH5vS0jQ4xPz5+vuTE9PGDZMJw0fH6Oj+9tVrlKDGgQRxAAGGB2OKB6ZPWVrUlL00/9+/BF+/RXc3HSr5IknYMAAyw1sCmNduwYhIbrbctUq/feiRw947jn99+COR69bjba0pTWtmc1so0MRxSNJw5ZduABBQfqmsWuXHkzv0QP69tU/DV5sLMzs+HHYuBGCg3XXpb09dOsG/fvDwIFQgifsWszbvM0iFnGOc0aHIopHkkZZERWlWyCrVulvoMnJ0LChXvHbtSs89ph+lKewHWFhsGULbN6s/59euqQXgfr769aEv7/ttSy3sY3OdOYUp6hPfaPDEUUnSaMsSkrSLY/Nm/Xrr78gPR2aNdMDo+3a6SmYTZrob6vCeLduwYED8Mcf+rVrF5w5o/eC6thRJ/4uXfTjWK2166kw0kijGtWYxjRe5mWjwxFFJ0njXhAfD1u36tfvv+upl4mJ+ltq69Y6iTz4oJ6d1bChDKyXtqQkvUHg4cP6/8Xvv+uEkZIClSvr/x/t2unWYYcOcPuptmVGf/qjUAQTbHQoougkadyL0tLgyBF9s/r9d/3N9sQJfbxcOb1xna8vNG+uWyeNGun1I+XKGR25bUlK0lNgjx/Xf96hoXDoEJw9q1t+Tk56GmzbtvrVrp1O2pZcdGeEr/maiUzkKldxRL6h2BhJGkJLSdGr0UND9Q0u8xUWps/b2+vpm/Xrw/33//267z7w8ICaNY2N3wjp6XrNTHg4nDunu5NOn9Y/z5zRu8iC/rO7/36dhH19dSJu3lz/WdpyV1NxneQkjWjETnbSkY5GhyOKRpKGKFh8vL4RZr8ZZr7Cw/9epV6uHNSqpWdseXqCl5d+1aihVyBXrapfmb+3s9JlpampcPWqntKa/eflyxAZCRcv6t+Hh+uEkZ6u3+fgAHXq5Eyoma8GDcpeF1NJ+eBDIIG8zdtGhyKKRpKGKL6UFDh/PufNNCJCvy5d0jfW6GhISvoRuADZbhCZycPNTY+tlC+vf1asqH9fqRJUqKC7cECfy/6t3N5evze769dzbrWSkqLHbkD/TE7W1yQl/f375GR9LjM55PU4DhcXnRA9PHRrq1Yt/dPD4+/k6ONzb7Yaius5niOCCEIIMToUUTSSNETpOnToEB06dGD48LEEBn6c9e09Olr/jI/XK9yTkvReWzdv6ht5fLxe6Xzrli4nNjZnuQkJn3DrVg1geNaxghKLs7NORu7u+qezsx50Ll9eJ6fMJJZXq0jGcsxvPvMZzWiucQ1nSuFxgaK0SNIQpSc2NpY2bdpQu3ZtNm7ciIMZv4p36NCBDh06MH36dLOVKSznAheoQx1CCKErXY0ORxSePE9DlI6MjAyeeeYZEhMTWbRokVkTBkB0dDTVZbWizapNbe7nfrawxehQRBFJL6woFR9++CGbNm1i8+bNeHh4mL38qKgoatSoYfZyheV0oYskDRskLQ1hduvXr+eDDz5gxowZPPLII2YvPykpiRs3bkjSsHFd6MLv/M4NbhgdiigCSRrCrK5evcrzzz9PQEAAL79cOttEREdHA0j3lI3rRjfSSWcHO4wORRSBJA1hVmPGjMHOzo6vvvqq1OqIiooCkJaGjatJTZrQRLqobIyMaQizCQ4OZtmyZaxduxZ3d/dSq0eSRtnRla5sZrPRYYgikJaGMIuYmBgCAwMZOXIk/v7+pVpXVFQUzs7OuLi4lGo9ovR1oQv72U8ssXe/WFgFSRrCLEaPHo2DgwOffvppqdcVHR0trYwy4jEeA2ArWwG4xCWWspSXeZld7DIwMpEf6Z4SJbZs2TKCgoLYuHEjlStXLvX6JGmUHde4hi++fMZnvMIrXORi1rnneM7AyER+JGmIEomLi2PcuHG88MIL+Pn5WaTOqKgomTlloy5wgdWsZhvb2MxmYojBHnvssCOV1BzXeuJpUJSiIJI0RIm8//77pKamMm3aNIvVGRUVRc17cS/2MiCRRF7jNVJJRaF3MEq//Ss7EyZqUcuIEMVdyJiGKLZjx47x1Vdf8dFHH1G1alWL1SvdU7arMY15l3exu8utpzKV5QFNVkqShii2N954g+bNmzNq1CiL1ivdU7btLd6iKU1xKKCjwwPzbz0jzEO6p0Sx7Ny5k3Xr1rFx40bsLPxEJdms0LY54MCP/MhDPJTvNbWpbcGIRFFIS0MUyzvvvMOjjz5K9+7dLVrvjRs3SEpKku4pG9eKVoxnfJ6tDQcc8MbbgKhEYUhLQxRZSEgIW7ZsYefOnRavW1aDlx0f8AHLWU444TkGwu2xl5lTVkxaGqLIPvnkE7p160bHjh0tXrckjbLDGWd+4AcyyMhxPJ10GdOwYpI0RJEcPnyYTZs28eabbxpSf+YOt9WqVTOkfmFenenMCEbk6KZKI01aGlZMkoYoks8++4xmzZrRo0cPQ+qPiorCzc0NZ2d5rnRZ8TmfU4UqOabhSkvDeknSEIUWGxvLzz//zCuvvILJZDIkBpluW/ZUohLf8V2ObippaVgvSRqi0BYtWoS9vT2DBw82LAZZ2Fc2PcETDGQgoFeD10D+H1srmT0lCu3777/nqaeewtXV1bAY5NngZUtyMsTH61dg4izW+27CPsORrVv1avAbNyAt7e/rXV3B4fZdy2SCypWhXDmoVAnc3PR/i9IlSUMUSmhoKPv372fmzJmGxhEdHU3dunUNjUEULDUVwsLg3Dm4fBkuXYLISP37y5fhyhW4fh3i4iAlJfs7a8HzM2Hsl5Rk+U/lyjqBVKkCXl5QowZ4e+ufXl76Vb++Pi+KTpKGKJQVK1ZQq1YtHn74YUPjiIqKok2bNobGILToaDh4EA4fhtOn9evMGZ0wMlsHzs7g4aFfNWtCq1b65u3urm/smS2EzFaCg8PzLKl2kxeu6fdXqABOTn/Xef06KL3PIWlpuiWSvbUSF6eviY+Hq1d1wrp8Gf76C6KidMLK5O6uk8f99+tXkybQsiU0agSOsu1VviRpiEJZuXIlAwcOtPiWIXeSgXBjXLoEO3bA3r06URw6pG/GANWrQ+PG+sbbqZO+EdevD/fdp2/MRTWBMZgq5H3uzu6nov5VSE2Fixd1csue6H75BT75RJ8vVw58faFFC51EOnSA1q0lkWSSpCHu6ty5cxw8eJDPP//c0DiUUsTExMiYhgWEhsK2bbBrl04W58/rsYTMm+lrr+kbaosWugVhTiZKb2aeo6NOZvfdR64usFu34NgxnRAPHdLJcd063aJydoY2beCRR6BjR+jcGe7Vpw1L0hB3FRQURNWqVencubOhccTGxpKamipJoxQkJMDu3bB6NaxaBRcu6Jtiy5YweDA8/DA8+mjZHmguV05/3pYtcx6/dAl27tTJc8MG+PhjPQjfqhU88QT06QMPPqiP3QtMSmX2EAqRt44dO9K4cWO+//57Q+M4fvw4TZo04cCBA7S881+2KLJr12DFCli6VLcqlNLfpv39oWdP3SVjb290lNYnOho2bYJff4WNG/VYiZcXPPkkBARA+/ZlOoHESNIQBYqIiKB27doEBwfzxBNPGBrL9u3b6dSpE5cuXcLDQ1YMF0dSEqxcCUuW6BufvT307q1veN27gwWfpVUmZGTAvn2wZg0sWwbHj0Pdurp19uyzujuvjImRxX2iQOvXr6d8+fIWe/53QaKiojCZTLLvVDGcOQMTJ0Lt2jBsmJ5h9OWXeirs8uX6G7IkjKKzs4OHHoKpU/V4yJEj+s93xQpo1kyf+/FHPcBeVkjSEAXatm0bHTp0oHz58kaHQlRUFO7u7jjKNJZC27YNevWChg1h8WJ49VUID9f98y+8oKe6CvPx9dUJ5ORJPf7h7Q0jRkCdOvB//6enAts6SRqiQNu2bePRRx81OgxAthApil27wM9Pz/JJStLffM+dgylToFYto6Mr+0wm6NFDTyo4exaGD4fPP4d69eBf/9LrS2yVJA2Rr/DwcM6fP0+nTp2MDgWQpFEYp0/rMYqHH9ZTSLds0a/+/WVQ2yi1a+tEce4cjBkD//63nvL79dd6TMTWSNIQ+dq6dSvlypWjXbt2RocCyL5TBbl1S3d/NG+uu582bdJdU489ZnRkIlPlyvD++zp5PP+87irs2FGvB7ElkjREvrZv306bNm2oUCGf5bkWJqvB8xYaCg88AB99pG9Kf/2lu6aEdapSRa8+37dPL5h86CF47z3baXVI0hD52r17t+F7TWUnLY3cfv5ZrwuoWlUnjwkTZLsLW9GsGWzfDl98oZNI79567Yy1k6Qh8pSWlsaJEydo0aKF0aFkiY6OlpZGNpMn66myI0ZASIheHyBsi8kEL72kk8fRo7rVceKE0VEVTJKGyNOpU6dISUnB14yrkw4cOEDv3r2pXLkyrq6u+Pn5sXPnzkK9Nz09nWvXrpmlpbFu3ToaNmyIg4Pt7qIzebL+djp/Psycad7WRWxsLHPmzKFr165UqVIFZ2dnGjRowNChQzlYiA749PR0Jk2aRIMGDShfvjz+/v5Z55o1a4bJZMrxCggIyDrv5+eX49xDDz2Uq/ywsDD69u1L/O35q0WNd+LEiSxbtizf+J9//nmcnJyoV68e48aNIzk5+a6fuaQeekh3K9asqbsWz54t9SqLTwmRh+DgYGUymVRCQoJZytuzZ49ydnZWgwcPVpcuXVLR0dHqn//8p3JwcFAbNmy46/uvXLmiALVly5Zix3D69GnVp08f1aJFC+Xm5qbs7e2LXZaRPvhAKTs7pX78sXTKHzlypHJwcFD/+c9/1OXLl1VCQoLatm2batq0qbK3t1e//PJLge+fO3euAtQHH3ygYmNjc52PjIxUVatWVYD66aefcp1fu3atatCgQZ5/9/bv36+qVaumvvzyy2LHe/r0aVWvXj319ttv5/sZ4uPj1Zw5cxSgpk2bVuDnNafr15V66CGl6tZV6uJFi1VbFNGSNESevvzyS1W9enWzlJWenq58fX2Vh4eHSkxMzDqelpamGjVqpHx8fFRycnKBZRw+fFgBKjQ0tNhxDBkyRH300UcqNTVVeXl52WTS2LxZKZNJqdmzS6+OkSNHqhdeeCHX8QMHDihANWjQoMD3DxkyRAEqPj4+32sWLVqkAFW1alUVGRmZdfzatWvKx8dH7dy5M9d74uLilLe3twoMDCxxvAcOHFAmk0ktW7aswM9SoUIF1aNHjwKvMberV5Vq0kSprl2VysiwaNWFIUlD5G3ixInqgQceMEtZW7ZsUYAaO3ZsrnNTp05VgAoKCiqwjJCQEAWo6OjoYseRPWHZYtK4eVOp++9Xql8/42JwdnZWdnZ2KqOAu1mPHj0K9Wfbt29fBagnn3wy69jQoUPVhAkT8rx+ypQpysHBQUVERJgl3kGDBilvb2+Vmpqa7/s9PT1V69atC12fuezfr1S5ckp98YXFq76baBnTEHmKiYkx26Dz5s2bAfLsn848FhISUmAZUVFR2NvbU6UEz+h0dnYu9nutwYcf6m0ovv3WmPoTEhJISkrKGpfIT3p6eqHKmzNnDu7u7qxYsYKgoCBWrVrFgQMH+OCDD3Jdq5Ri3rx5tGvXDk9PT7PEO2DAAMLDw1m7dm2+ZZhMJtKyP6TcQlq1gkmT9NhVTIzFqy+QJA2Rpxs3buDq6prv+ePHj9O/f38qVapEhQoVaNu2LWvWrMkxkDlq1KisawG8vb1zlePl5QXAyZMnC4wnOjqaatWq5XhyYFFisHUJCTB7NrzxRtGfVmcuy5cvB2DKlClmKc/Dw4MZM2YA8PLLLzNmzBh++OEHnLI/3/W2gwcPcuXKlSJtiX+3eFu1agXAhg0bihq6Rbz5JpQvD3PmGB1JTrY7fUSUqps3b+a7m+zp06fp0KEDFStWJCgoiA4dOhAWFsarr77KoUOHcHJyyjHj5Pr16wBUrFgxV1kutx9/FhsbW2A8d24hUtQYbN369ZCYqFcSG+HKlStMnDiRUaNG8dRTTxV47a1bt/K88edl2LBh/Pzzz6xbt47OnTvTunXrPK87cuQIkPcXj+LGm/mFJbPsvDg5OZFq0Ba1FSvCkCF6y/W33zYkhDxJS0PkSSmVbxfE5MmTuX79OjNnzqR79+64uLjg6+vL4sWLSUhIKHI9QIHdHZB7Nbg5Y7AFO3boLgsjWhlXr16lZ8+ePPbYY8wpxNfeCxcuFPrmDtCgQQNAb1sTHByc5zWXbz+QvFKlSmaL183NDZPJlFV2Xjw9PYmIiDCkiwr0poehoXore2shSUPkyWQykZHPvgbr168H4PHHH89xvHr16jRu3DjX9ZVvPyM0r5t55rHKd3mO6J2rwYsag607exYaNbJ8vQkJCTz++OM0bdqURYsWYV/ArofXrl3j008/JSwsjNGjRxeq/O3bt7Ny5UqmT58OwIsvvphnqzOz1Xi3bfGLEi+Ag4MDSUlJ+Z4PDAwkPj6ed999lxgDBhcaN9ZPVLSmdRuSNESeKlSoQGJiYq7jKSkp3Lhxg/Lly2d1LWXn7u6e61jmTTw8PDzXuYiICAAaNmxYYDzZk0ZxYrB1yclg6XH8tLQ0Bg0ahJeXFz/88EOBN+Dhw4dTtWpVJk6cyIQJE3jllVfuWv7NmzcZPnw433zzDePHj8ff35/IyEjGjRuX69rM57kU1FVUlHizv6egCRLPPPMM06ZN49NPP6V69er07NnzrmWaU+a2b3n8UzSMJA2Rpxo1ahAdHZ3ruJOTE66uriQnJ3Pz5s1c56OionId69KlCwB79+7NdS7zWLdu3QqMJ/sWIsWJwdZVrgxXr1q2zsDAQFJSUvj5559zrJ6vX78+e/bsyXHtggULiIuLY+nSpUyfPp3AwMC7lv/666/j5+eXdSOeO3cubm5uLFy4kDVr1uS4NvPxvnFxcWaJFyA+Ph6lVIGPDp4yZQqTJ09m9uzZXL9+PauFaymZjZsSTBo0O0kaIk/Vq1fP9+abuS3Enf+AIiMj85wF1blzZ5o2bUpQUFCOwen09HSWLl2Kj48PvXv3LjCeO7unihqDrWvWTO+KailTp04lNDSU4ODgQg9qu7m5MWjQIB544AGCgoIKvHbDhg1s2rSJzz77LOuYj49P1n8HBgZmTaAAvf0I5N1aLW68ma3czLLzsnLlSurVq8eoUaMKNZ5ibnv36hlUt4d9rIOx60SEtZo1a5aqWrVqnudOnz6tqlSpory8vNTGjRvVjRs31OHDh1XPnj1VnTp1lJOTU6737N69W5UvX14FBASoy5cvq5iYGBUYGKgcHBzU+vXrC4zl1q1bymQyqZUrV5YohuxsbXHfnj1KgVL79pV+XfPnz1dAga/du3fn+/5u3boV+GcbGxurfHx88t0Sxs/PTwFq+PDhWccyMjJUjRo11MMPP2y2eBcvXqyAArdF8fLyUi1btsz3fGnr21cpf3/Dqs+LrAgXeVu+fLkymUz5rpY9ceKE6t+/v3Jzc1MVKlRQHTt2VFu3blXdunXL94a9b98+5e/vr9zc3JSLi4vq2rWr2rFjx11jCQ8PV0Cua4saw+rVq/O9qXz77beF+FMxTkaG3lpi2LDSr6t3794lShp+fn75Jg0vL68c5fTLtrw9NjY2z7pmzJihlFJq8uTJea4IL268gwYNUl5eXurWrVv5fhYvLy/VqlWrAv+8SsupU0rZ2yu1dKkh1edHkobI286dOxWgwsLCivS+gpJGce3bt08B6uTJk4bFYA2WLNEbFW7bZnQkBevdu7cymUxmL/f69evKy8sr195TxZG599SSJUsKvK5mzZqqffv2Ja6vScjJVgAAIABJREFUqDIylOreXammTZVKS7N49QWRbURE3po0aQJAaGiowZH8PbB9rz9LIyAABgyAYcPgxg2jo8mft7c3SimuXLli1nIrVarE6tWrCQoKYtasWcUu5+zZswwcOJBJkybl2Jb9TqmpqVy7dq1Ia07M5euv9bPd58+3vme7S9IQeXJ3d8fLy6vA1bKWEh0dTbly5QwZiLQ2s2bphPH00/q54NYoczbUxx9/zFUzT/l64IEH+Ouvv/j111+znqdRVHPnzmXatGlMmzYt32vi4uKYPn06qampFp9mu3mz3kJk0iRo29aiVReO0W0dYb0ef/xxNayQnehLlizJ1Y88cuRIs8Tx+eefK29vb0NjsCb79ilVubJSAwYoVcAGrYb697//rZo0aaKcnJxUz549jQ6nSIYNG6YcHR1V/fr11TvvvKPSLNg/tGuXUi4uSv3jH1bXLZUp2qTU7X0chLjDG2+8wf/+9z/++usvQ+OYNGkSGzZsYJ8l55xauR07oGdP6NoVFi4EaYTZvuBgePZZ6N5d7zdlpQ+WjJHuKZGvZs2acfTo0UJvdV1a7lyjIeCRR2DjRj2Pv00bsIJeRFFM6ekwZYoerxoyBJYssdqEAciYhijAgw8+SFJSkuHjGnfucCu0jh110qhVC9q3hy++0DcgYTtOntTPBJ8+HebNg7lzoVw5o6MqmCQNka9mzZpRqVIldu7caWgcd+5wK/5WqxaEhMD48XrwtH17y64cF8WTkgLvvw8tWkBcHOzaBSNGGB1V4UjSEPmys7OjXbt27N6929A4JGkUzNFRP9Vv/369qWHbtjBqFJw/b3Rk4k7p6fDTT9C8OXz2GfzrX/DHH/DAA0ZHVniSNESBOnTowK5duwyNQcY0CqdpU9i6Fb7/Xs/xb9QIXnwRLl40OjKRkQFLl+o9xJ5/XncthobCa69Z9/hFXiRpiAJ17NiRs2fPFvigmtKUmJhIQkKCJI1CMpnguefg+HH9LPGQEKhXD/r0gd9+089mEJYTFwfffKOTxdChuoVx5AgsWAC1axsdXfFI0hAFat++Pfb29oZ1UWWuBpekUTSOjjp5hIbqVcXR0XoqZ8uW+lnj164ZHWHZpRTs3g0jR4KHhx5r8vODY8fg55+NeZiWOUnSEAVyc3OjWbNmbN++3ZD6M5/pIWMaxVOunJ77v+f/2bvvuKbO9n/gn5BA2AiIyNKiiIjUUVyoVUEUkYpURaU466Bqq/bROjusfWyf/tpqffq1xdFW66pKHRWto+rjxDoqbm1BRZmCLEEISbh/f9wNQwIykpwErvfrdV4J55yccyXGc+Xc8zxw6RLQrRswbx6/mL32Gi9f1+chSQxJfDywaBHQpg0vfrpwAfjqKyAlhbdse8E8YwaDkgZ5oQEDBuDkyZOCnJvuNDTH15fXd2RkAN9/z9e9+Sbg6AgMHw5ER1PleV3IZMDRozwJt2/PK7N37ADGjOGNEq5fB2bMANRMLmnQqEc4eaE9e/Zg1KhRePz4Mezt7XV67h9//BFvv/222vnFScNlZwO7dwP79/MxjwoK+LzUwcGAvz//xazjf3K9pVTy+ojTp4HDh3ljg8JCoGNH/nmNHAn07MnrlRqxLEoa5IWys7Ph4OCA3bt3Y/jw4To99+eff47o6Gjcv39fp+dtikpK+AXx0CF+UVT16fTy4smjTx/enLd9e8Nr8VMfT57wzpNxcbwfRVwcL8qzseHDtwwZwhdDrdCuJ0oapHa6du0Kf39/rFy5UqfnnT9/Pk6fPo0//vhDp+cl/C7k3Dm+nD0LXLwIFBXx6Uc7duSV6p068cXTE3BxETri+ikqAhISgFu3eL3EtWvA1au8LgIor6Po3ZsP39KxI2DUdAv2s5rA7wWiCQMGDMCJEyd0fl4aQkQ4dna8svy11/jfcjlvjXX1avmFdd8+/osc4B0LPTyAtm350qYNTySOjoCrK9CihTBDZOTkAGlpfElN5f1WEhN5okhMLE8OEgm/i+rcGZg9mz926cLjJ+XoToPUyr59+zBixAid12sEBwfDyckJP/zwg87OSeomNbX8Aqx6TEzklepZWZX3dXDgF+FmzQBra77Y2PC/bWz4L3grq/LiLxMTwMKCP1cqgYpTaBQU8ERWWMjXq5a8PJ4onjwB0tOB4uLy10ilPIGpElvFxdOTbyc1ojsNUjv9+vWDkZERjh8/jvDwcJ2d9/Hjx+jcubPOzkfqztmZL/36Vd0mk/HWWikp/DE5GXj8mF/Y8/L4Rf7vv/nz3Fzex0H1CPALflHRSQC/AvgKtrblxzYz40VlZmY84agSUJs2PAnZ2/OxuZyceHwtW1KlviZQ0iC1Ymtriz59+mD//v06TRqZmZnUR8OASaW8orghlcXffnsTH330EzIzv9JcYKTemm51DqmzYcOG4cCBA1AoFDo7J9VpEKJfKGmQWgsLC0N2drbOBjDMy8tDcXExJQ1C9AglDVJrbdu2hZeXF/bv36+T89EQIoToH0oapE5CQ0Oxd+9enZyLhhAhRP9Q0iB1Mnz4cCQkJODq1ataP5cqadCdBiH6g5IGqZPevXvDy8tLJ/0mHj9+DBsbG0ip8TwheoOSBqmziRMn4qeffkJRUZFWz0MtpwjRP5Q0SJ1NnjwZhYWF2LNnT5Vt9R1Y8MyZM/jqq6/w008/4eDBg7h8+TLu37+P5s2bNzRcQogGUec+UmeOjo4ICQnB999/jzfeeAMAcPToUXzwwQcwMjKqV5NcpVKJ+fPnQyQS4fmRbczNzeHg4IAWLVrAyckJEydOxMiRIzXyXgghdUNJg9TLlClTEBoaio0bN+K7777DhQsXYGRkVO87g169esHExAQlJSVVthUVFeHhw4d4+PAhRCIRPv3004aGTwipJyqeIvVibW0NZ2dnTJ48GZcvXwYAlJaWIjMzEzKZrM7Hk0ql6N27N0Q1zGAjkUgQGBgIHx+fesdNCGkYShqkTs6cOYNXX30V/fv3R0ZGBgBetKTCGMOjR4/qdexBgwZBUsPsPgqFAgsWLKjXsQkhmkFJg9RKamoqevXqhVdffRVxcXEAUO0YVPWtDA8ICIBcLle7zcjICF5eXhg4cGC9jk0I0QxKGqRWnJ2dMXjwYIhEokp3Fs+TSCT1ThrdunWDubl5tdsXL15cY/EVIUT7KGmQWlu+fDk+++yzGvcRi8VISkqq1/ElEknZvB3Ps7e3x9ixY+t1XEKI5lDSIHWycOFCfPnll9X+4pfL5bh37169jx8YGAixWFxpnUQiwb/+9S+YCDFXKCGkEkoapM7mzZuHb7/9Vm3iKC0txd9//13vY6ur1xCLxZg2bVq9j0kI0RxKGqRe3nrrLaxbt05t4qhvnQYAdO7cGTY2NmV/GxsbY9q0aTqdl5wQUj1KGqTepk6dii1btsDIyKhS8sjJycGzZ8/qdUwjIyP4+/uXFVEpFArMmTNHI/ESQhqOkgZpkDfeeAPbt2+vlDgYY3j48GG9jxkYGAiRSASJRIJhw4bBw8NDU+ESQhqIkgZpsNGjR2PHjh2VEkdDiqj8/f2hUCigUCiwcOFCTYVJCNEAGnuKaMTIkSPx66+/IiwsDHK5HA8ePAAA5OYCxcXAs2dAXh5QWgoUFgLPDzFVUACo6r8Z6wBr6+ZwcGiFZ8964/ffy/czMwNMTQFjY8DSErCy4n9bWenmfRLS1FHSIC9UUgKkpwPJyUBmJpCdDTx5wh+zssqfP3kyFPb2vyI9PQyzZ9/HzJn1PaMIwGDk57+OQYNq/ypLS55ArK35Ym8PNG8O2Nnx5xUfW7QAXF0BR0fguRa+hJAaUNIgSE8H7t0DEhOB+/eBtDQgJYUvqalARgZQcbRyS8vyC7Bq8fbm6ywthyAr6wguXNiEt98GbGz4hdzCgl/IxWJAKgWe7/ituoNQ+f33yejRwx/Pdz5/+hRQKHgiKywE8vMBmYyvLyjgdzX5+XxRJbTbtysnuopzR0kkPHG4ugJOToCbG+DsDLi7A23bAm3a8PdFCOEoaTQReXnAjRt8+fvv8iSRmMgvvgC/mL/0UvnF09ubX0ArXlAdHPh+NeuH1FQPODvXP97AwEC1621t639MlWfPeKJMTeV3T2lpwKNH/PHKFSA2lv+tGlrL1rY8gbRtC3h6Ai+/zD8fM7OGx0OIIaGk0cgolcCtW8DVqzxBXL8O3LwJqEb2sLLiF722bYGQEP6oWlxcADUjeNSLc0MyhpaZm/ME0KZN9fsoFPwzUyVW1RIby5NucTG/a2rTBujUCejYkSeSLl0AauxFGjNKGgYuNRW4fLl8OXsWyMnhxS6tWvFfw5Mm8YuatzfQoYPmEkNjJpGUJ9PnKZU8ody8yRP0zZtATAywYgXfZm3NE0jfvkCfPkCvXvwOjZDGgJKGgXnwADh2DDh+HDh5ktc7iMU8GfToAXz2GdCzJ08SxsZCR9s4qe4w2rQBhg0rX19UxIu3LlzgS0wM8PnnfJunJ9C/PzBwIODvzyviCTFElDT0XE4OcPgwTxLHjvG6CHNz/gt21izAzw/w9aUmp/rAzAzo3ZsvKllZPIHExfF/wx9/5HcjPj5AQAAQGMgTCdWNEENBSUMPPX4MHDoE7NoFHDnCLzJdugDh4fwi07dv5ZZGRH81bw4MHcqXTz7hjQ7i4oDff+fLN9/whgUDB/K7luHDeWsuQvQVJQ09kZ4ObN4M7NzJ6yYsLYHgYGDjRn7BqTCGHzFgFhY88asah6WnA/v2AXv3ArNn87vHfv2AsWOBMWN4/Qgh+oSqRAUkl/OLRWgob8762WdA167AgQO8E92OHUBEBCWMxqxlSyAqCvjtN36HuWULrzSfPZs3c544kdddVewnQ4iQKGkIIDMTeP993v9h5EjefHPzZt4Sat06fofx4r4QpLGxtuZ3Fz//zPuMfPkl75g4YADQrh2wenV5nxpChEJJQ4cePADeeYd3oFu3Dpgxg/fAPnKEF0dQPQVRadaMfz8uXOB9bYYOBZYu5d+d5ct5z3ZChEBJQwcyMoApU/ivxdhY3gzzwQNg2TLel4KQmvj4AP/9L//OzJzJ7zhat+Z3q3TnQXSNkoYWKRT8P3j79rylzA8/8N7Eb79ddewlQl6keXPg4495x8KPPgLWrOH9c3btEjoy0pRQ0tCSq1eBV14BFi7kSeL2bWD8eN7TmJCGsLQE5s8H7tzhrbDGjOGPKSlCR0aaAkoaWrBpE+90Z2/Px3/69791c2dx8OBBeHp6QlKHzKRUKrF48WK0a9cOpqamCA4OrnbfixcvYtKkSXB3d4eZmRns7Ozg4+ODkSNH4rvvvkNiYiIAwMfHByKRqNIyduzYsuOoZuZTLd26datyrqSkJISGhiI/P18j7/N58fHxCAkJQbNmzWBlZYXAwECcPXu2yn6LFi3Cjh07qj3O5MmTIZVK4e7ujjlz5qC4uLjeMdWVoyO/ez13jjeieOUV4MQJnZ1e7+Xk5CA6OhoBAQGws7ODmZkZ2rVrh8jISFy9elXo8AwXIxojlzMWFcWYSMTYwoWMKRS6OW9CQgIbNmwY69SpE7O2tmZisbjWr127di0DwJYvX85ycnLU7qNUKtn8+fOZRCJh7733Hrt9+zYrLi5m6enp7MiRIywwMJABYACYXC5njDGWnp7O7O3tGQC2ZcuWKsc8cOAAa9euHSssLKyy7cqVK6x58+bsm2++0dj7rOj8+fPMzMyMjRkzhqWmprLMzEw2bdo0JpFI2OHDh6uc093dnb3//vvVHi8/P59FR0czAGzFihX1iqmh8vMZCw9nTCJh7MsvBQlBa9asWcOaN29e59dNmTKFSSQS9vXXX7O0tDRWWFjITp06xby9vZlYLGZ79uzRQrSNXiYlDQ2RyxkbPZoxCwvGdP1djIiIYJ999hmTy+XMxcWlThfTiIgIBoDl5+dXu8+SJUsYALZu3Tq12xUKBQsODq6UNBhjbOvWrQwAs7e3Z+np6WXrs7OzmZubGzt79myVY+Xl5TFXV1cWFRWl0fepolQqWceOHZmTkxN79uxZpffQvn175ubmxoqLiyu9Jj4+nolEIrZjx44aj21ubs4GDx5c55g0pbSUJwwjI8aWLRMsDI1rSNKYPn16lfXx8fEMAGvXrp0mwmtqKGloyr/+xZi5OWP/+5/uz13x4lfXi+ngwYNr3P/27dvMyMiI+fr61nicc+fOVUkajDEWGhrKALCRI0eWrYuMjGQLFixQe5ylS5cyiUTCUlJSqmxryPtUOXHiBAPA3nnnnSrbli1bxgCwmJiYKtvCw8OZq6trlfdXkbOz8ws/J11Yv57f7f7wg9CRaEZ9k0ZNzMzMmJGRESstLdXocZuATKrT0ICDB4GVK4H16/lIprpm1oDR7pTPT433nHXr1qG0tBTh4eE17ufn5wfGWJV6hujoaNja2uKXX35BTEwM9u7di/j4eCxfvrzKMRhj2LBhA3r27Kl2Po6GvE+V48ePA4DaehTVumPHjlXZ9vrrryM5ORkHDhyo9tgikQgK1cxNApo6FVi8mDfP/esvoaPRP4WFhSgqKiqreyN1Q0mjgRQK3mFv7FjgjTeEjkbzTp06BQDo1KlTvV7v5OSEVatWAQBmzZqFt99+G5s2bYJUTZf3q1evIiMjA507d65/wC9w584dAICrq2uVbS4uLgCAv9Rcabt06QIAOHz4sNZi06SPPwa8vIB//UvoSDTrzp07CAsLg42NDczNzdGjRw/ExsZWalwxderUGo+x6582ykuXLtVFyI0ONQBtoF9/5e3mjx4VOpL6KSkpUXsBV0lNTQUA2Nvb1/scEydOxM6dO3Hw4EH0798fvr6+ave7ceMGAPUXdE3Jzc0FAFhYWFTZZmlpCYC3unmeKqGoYlRHKpVCLpdrIswGk0h4q71hw3jTXC8voSNquISEBPj5+cHCwgIxMTHw8/NDUlIS5s6di2vXrkEqlb6w9VpGRgYWLVqEqVOnYvTo0TqKvHGhO40G2r+fD1Ve09Sh+uzhw4e1ukg39Da+Xbt2AICTJ09i3759avdJS0sDANgINEIj+2dUQHXv1draGiKRqCxGdZydnZGSkqIXRVQAH8PMwYGPQtAYLFmyBLm5uVi9ejUGDRoES0tLdOzYEdu2bUNhLbrGP3nyBEOGDMGAAQMQHR2tg4gbJ0oaDXTjBp8xz9BkZ2fjiy++QFJSEmbOnFntfqq6haysrHqf6/Tp09i9ezdWrlwJAHjrrbfU/ppX/Uo01uKUg82aNQMAtRcZ1TrVPs+TSCQoKiqq9thRUVHIz8/Hhx9+2KDPS1OMjIDu3fnYVY3BoUOHAABBQUGV1js4OMDrBbdShYWFCAoKgre3N7Zu3QqxWKy1OBs7ShoNVFDAe+gakkmTJsHe3h6LFi3CggULMHv27Gr37f9Pzf61a9fqda6CggJMmjQJ69atw7vvvovg4GCkp6djzpw5VfY1/WfERm0W8aguLsnJyVW2pfzTpdrT01PtaxUKRY2V8ePGjcOKFSvwxRdfwMHBAUOGDNFAxA1jZQU8fSp0FA3HGMPTp09hampaVoxYka2tbbWvVSgUCA8Ph4uLCzZt2kQJo4EoaTRQixa8N64h2bhxI/Ly8vDzzz9j5cqViIqKqnbfqKgoSCQSxMTE1HjMBQsWwMjIqKyiWWXevHkIDAwsu4CuXbsW1tbW2Lx5M2KfKzdxcnICAOTl5dXnbdWKv78/AODy5ctVtqnWDRw4sMq2/Px8MMbKYlRn6dKlWLJkCb777jvk5uaW/TIWUkoKn7PD0IlEIlhZWaG4uBgFBQVVtj9+/Lja10ZFRUEmk2Hnzp2VWvd5eHjg/PnzWom3URO0xW8jsHAhYx4evGOVPqhr/4Xu3bszW1vbGvf55JNPGAD2/fffq91+584dZm1tzcaMGVNp/aFDh5i7u3uVjoPr1q1jAJizs3OlXuhXrlxhANjMmTNfGHdDOvd5e3szZ2dnVlRUVLZeoVCwDh06MDc3t0rrVW7dusUAsBkzZlR7bC8vL+bu7l7nmLQlN5cxqZSxn34SOpKGUfXTGD16NAPAdu3aVWl7Wloak0qlTCqVVnntRx99xHr27MmePn1aZVvbtm1ZXFyc1uJupKhzX0NdvcoYwNjBg0JHwtX1Yjpw4MBa7b9o0SJmbGzMFi5cyO7evctkMhlLTk5mGzZsYE5OTqxv376soKCgbP+cnBzm5ubGTpw4ofZ4qqFHJk2aVLautLSUtWjRgvXp0+eF8dTmfUZGRjIA7N69e5XWx8XFMVNTUzZ27FiWlpbGsrKyWFRUFJNIJOzQoUNqj7Vt2zYGoMahJ1xcXFjnzp1fGLuufP45Y1ZWPHkYMlXSSEhIYHZ2dszFxYUdOXKEPX36lF2/fp0NGTKEtW7dukrS+PHHH8uGt6luoaRRZ5Q0NGH4cMbat2dMzQ9Undi/f3+1/ynWr19f42sDAwNrnWQuXLjAxo8fz9zc3JixsTGzsrJivXr1YqtXr2YymaxsPxcXl0oxDB8+vGxbTk6O2jhXrVrFGONDllTXI7yu7zMgIIBZWloyhZpBwP78808WHBzMrK2tmaWlJQsICGBnzpyp9r2Hh4czFxcXVlJSUu0+Li4urEuXLtVu16XkZMasrRlbulToSBquYo/wu3fvsrCwMGZtbc3Mzc1Z79692cmTJ9nAgQOrJI2QkBBKGppHSUMTkpIYa9aMsQkThI6k7kJCQphIJBI6jDK5ubnMxcVF7dhTdZGTk8PMzMzY1KlTGxyTauyp7du317ifo6Mj69WrV4PP11DFxYz5+fEfMhVGXjFYtRlGRF3SIFpBw4hoQqtWwLZtfJk3T+ho6sbV1RWMMWRkZAgdCgDeR2P//v2IiYnBmjVr6nUMxhhmz54Na2trfPLJJw2K5969exgxYgQWL15caXj358nlcmRnZ2u1Y2JtyGR83vnbt4G9ewENjLxCSCWUNDQkOBjYsoVPyzl2LG+KawhUrZr+85//4MmTJwJHw3Xt2hWXLl3Cb7/9pnY+jRfJyMjAvXv3cOzYMbRsYNOhtWvXYsWKFVixYkW1++Tl5WHlypWQy+WCNrNNSQECAoAzZ4DDhxtHL3Cih4S+12lsTp5krGVLXjRw44bQ0dTO559/zjp06MCkUikbMmSI0OEYlIkTJzJjY2Pm4eHBPvjgA7X1J7pw6hRjTk6MeXoazveutmoqntq+fXuVeoopU6boOMImJVPE2D9jJxCNSU4GRo0Cbt0CPvwQmDMH0GInZ9KE5ecDy5YB33wDDB8O/Pgj79DXmHz77bf46KOPkJmZKXQoBMii4iktcHUFTp3iI4x++CHQqZPhDmhI9BNjfFrh9u2BzZuBb78Fdu1qfAmD6B9KGlpiYsJ/Ad66BXToAAweDISEAKdPCx0ZMWSlpcDu3Xy8sylTeKX33bvAtGkATQ1BdIGShpa99BL/T370KB8DqF8/Piru/v381yIhtVFSwoueOnYEwsN5i70//wT+7/8AOzuhoyNNCSUNHQkM5EVWZ84Atra8/LljR+DLLwE9ae1K9FBCAvD++3zo/bfeAvz8gJs3gV9+4cWehOgaJQ0d69OH32VcvQoMGACsWMHrQIYPB/btA/RkDh8ioMJCYONGPnWwpyd/PnEiTyA//EBNaYmwKGkI5OWXeeVlejrvFFhaysunHR2B0aOBn35qHENak9rJzuYV2RMmAE5OQFQUYG0N7NgBPHjAf1y4uQkdJSGUNAQnlfIy6v37gXv3eFFEejrw5ps8gYSF8V+XaqZ/IAbuzh3eGXTgQP5vPX488OQJ8NVXfLj9/fv5d0NCkzITPUJfRz3SqhVvpvuvfwGPH/P5x/fuBWbNAoqLeVFFQABfBgzgU3kSw5GUBJw4ARw/Dhw7xhODjQ0fTWDrVv5ITWaJvqOkoadatACmTuVLURFw7hy/2Bw/DmzYACiVgI8Prxjt2ZM3wezQAaBJyfRDSQkQHw9cuMCXc+eAxEQ+FlTv3vyHgL8/n46V7iSIIaGvqwEwM+NFGKoJ5fLzgZMn+fLHH3zMq2fP+K9UX1+eRF55hbfO8vSk3ujaVlTEBwi8fp03g/3jD54wZDKgWTP+7xEZye8O/fyAf2a1JcQgUdIwQNbWwLBhfAEAhQK4cYNfrP74A4iN5eXiCgXvZOjlxRPIyy/zu5P27Xn/ERMTQd+GwSkq4i2Y7tzhn/fNm8C1a7wuSqnk9VOdOvG7vpkzebLw9KROd6RxoaTRCEgkQJcufFFN9y2T8d7oN2/yC9yNG8DatbxcHeDFWG5ugIcH0LZt+dKmDW+94+go3PsRilLJ+8wkJwP37/PipIQE/piYyEeRBfhn17YtT8IRETwRv/wy/yypqIk0dvQVb6SkUqBrV75UlJ/PL4QVL4Z37wIHD/KLpaqXuokJ0LIl70Pi7Ay4uPClRQveA9neni+q50Z62g5PLuctkrKzKz+mpfFWao8e8efJyTxhKJX8dRIJ0Lo1Tw4dOwKhoeWJtV07KmIiTRcljSbG2prXd7zyStVtMhnvE1DxYpqSwpeLF4E9e4DMTF5M8zxV8rC25nUrpqb80cKCP7exAczNeTID+LaKv8rFYv7ainJzKw+1IpPxuhuAPxYX832KisqfFxfzbarkoG46DktLwNJyBxg7An//79C3rwnc3Pgdlio5urnRXQMh6tB/C1JGKuX1He3b17xfUVHVX++ZmfwxP59PQFVUxDsnZmTwC3l+Pu/pXFLCj5GTU/mYJSV8O7AegAOAsBoTi5kZT0a2tvzRzIzX05ia8uSkSmLq7opMTIDDh5th9OgYPHp0F998sxfNmzfXyGdISGNHSYPUmZkZL7bSxsymAQHb4eXlhW+/DdP8wSsICgrCmTNnMGzYMPj5+SE2NhbtX5QtCSHUI5w0XS+//DLi4uJga2uL3r1743//+5/QIRGi9yhpkCbNyckJp06dwuDBgxEUFIRNmzYJHRK7T1FeAAAgAElEQVQheo2SBmnyTE1NsW3bNixevBiTJk3CnDlzUFpaKnRYhOglqtMgBIBIJMKyZcvQqlUrzJgxA6mpqdi0aRPMzc2FDo0QvUJ3GoRU8Oabb+LYsWP43//+h4CAAKSnpwsdEiF6hZIGIc/p27cv4uLikJubi27duuHKlStCh0SI3qCkQYgaHh4eOHfuHNq1a4d+/fohNjZW6JAI0QuUNAiphp2dHQ4fPowRI0YgLCwM33zzjdAhESI4qggnpAYmJibYtGkTXnnlFcydOxc3btzAmjVrIKExRkgTRd98Qmphzpw5cHFxwcSJE5GUlISdO3fC+vnBsghpAqh4ipBaGjVqFI4fP474+Hj07dsXSapx5glpQihpEFIHPXv2xKVLlyAWi+Hn54eLFy8KHRIhOkVJg5A6cnV1xenTp+Hr64t+/fph+/btQodEiM5Q0iCkHiwtLbF3715MmzYNkZGRWLZsmdAhEaITVBFOSD2JxWL897//hY+PD2bNmoWHDx8iOjoaJjT5OmnE6E6DkAaaPn06YmNj8csvvyAgIACZmZlCh0SI1lDSIEQDVJM6JScno3fv3rh7967QIRGiFZQ0CNEQmtSJNAWUNAjRIJrUiTR2lDQI0TCa1Ik0ZtR6ihAtoEmdSGNFdxqEaNGbb76J48eP06ROpNGgpEGIlvXp04cmdSKNBiUNQnRAXyd1OnjwIDw9PWmod1JrlDQI0RF9mtQpMTERoaGhWLx4MTIyMgSLgxgeShqE6JBqUqevvvoKc+fORVRUFBQKhc7j+OCDD9C7d29cvnwZVlZWOj8/MVx0T0qIAJ6f1GnHjh2wsbHR2fm///57mJmZ6ex8pPGgOw1CBFJxUqdXX31Vp5M6UcIg9UVJgxABaWpSpzt37iAsLAw2NjYwNzdHjx49EBsbi8DAQIhEIohEIkydOlXD0ZOmiIqnCBGYalKniIgI9OvXDz/88AMiIiJq/fqEhAT4+fnBwsICMTEx8PPzQ1JSEubOnYtr165BKpWiuLhYi++ANCV0p0GIHmjIpE5LlixBbm4uVq9ejUGDBsHS0hIdO3bEtm3bUFhYqL2gSZNESYMQPaGa1Ck6OhorVqzAm2++iZKSkhe+7tChQwD48OwVOTg4wMvLSyuxkqaLkgYheqYukzrJZDI8ffoUpqamsLS0rLLd1tZWm6GSJoiSBiF6qLaTOkmlUlhZWaG4uBgFBQVVtj9+/FjboZImhpIGIXqqtpM6BQcHAygvplJJT0/HX3/9pe0wSRNDSYMQPaaa1CkoKKjaSZ0+/fRT2NnZYe7cuTh69CgKCgpw48YNTJ48GS1bthQgatKYUdIgRM+Zmppi69at1U7q1LZtW8TFxaF79+4YNWoUHB0dERUVhcWLF8PDw0PtMWNjY8v6b6SkpECpVJb9vWHDBl29NWKAqJ8GIQZANalT69at8dZbbyElJQU//fRT2aROnp6e2LNnT62P99prr4Expq1wSSNGdxqEGJDJkyfj+PHjOHnyJE3qRARBSYMQA0OTOhEhUdIgxAC9aFKnn3/+GSKRCMeOHYNMJqOxp4jGUNIgxECpJnUaOXIkwsLC8N///rds29ixY8EYq7RQBTfRBKoIJ8SAmZiYYOPGjejatSveffdd3Lx5E2vWrKHpW4nW0DeLkEZA6EmdSNNBxVOENBJCTupEmg5KGoQ0Ipqa1ImQ6lDSIKSRUU3q5Ovri379+mH79u1Ch0QaEUoahDRCDZnUiZCaUEU4IY2UalInHx8fzJo1Cw8fPkR0dDRMTEyEDo0YMLrTIKSRq8ukToS8CCUNQpqA2k7qRMiLUNIgpImo7aROhNSEkgYhTUhtJnUS0rVr19CsWTNYWVmVLQsWLEBhYWGlddbW1hg7dqzQ4TZJVBFOSBOjmtTJ09MTkyZNwp9//olVq1bByEj9b0ilUgmxWKyT2Dp16gRbW1s8ePDghfsOHTpU+wGRKuhOg5AmSDWp0w8//IDo6GiMHj0az549q7LfkydPMGDAAOTl5ekstgkTJsDY2LjGfUxMTBAWFqajiEhFlDQIacJqmtRJJpNh2LBhOHPmDD799FOdxRQREQG5XF7tdolEgtDQUFhbW+ssJlKOkgYhTZy6SZ0YY5gyZUrZMCQrV67EX3/9pZN4vLy84OPjA5FIpHa7UqlEZGSkTmIhVVHSIITAw8MDZ8+eRdu2bTFgwAC89dZb2LZtGxQKBQBenDVjxgydxTNhwoRq61HMzMwwZMgQncVCKqOkQQgBANjb2+PIkSMYMmQI1q9fD8ZY2Ta5XI7jx49XmSFQW8aOHQulUlllvbGxMcaOHQtTU1OdxEGqoqRBCClz/fp17Nu3T+02IyMjzJo1CzKZTOtxuLm5wc/Pr0qLLrlcjjfeeEPr5yfVo6RBCAEAJCUlISgoCAqFotJdhkppaSlSUlKwatUqncQzfvz4KvUa9vb2GDBggE7OT9SjpEEIQX5+PoKCgpCfn6+2WEhFqVRi+fLlSE1N1XpMo0ePrpQ0TExMMH78eJ31GSHqUdIghOD06dMoKiqCQqF4YR8JhUKB9957T+sx2dnZITAwsGy+85KSEkRERGj9vKRmlDQIIQgJCUFSUhIuXbqESZMmwdTUFGKxWG0vcblcju3bt+P06dNaj2vcuHEoLS0FwOs5unfvrvVzkppR0iCElPH19cW6deuQnp6Ob7/9Fr6+vgAAqVRaaT+xWIyZM2fWWJSlCcOHDy+785kwYUK1fTeI7tDYU4SQKmxsbDB9+nRMnz4d165dw/fff49NmzYhPz8fYrEYCoUCN27cwA8//IBp06bV6djPngHFxUBuLlBUxJ/L5UBBQeX9ZDLg2TNLvPJKKOLidsHOLgK//ALY2FTeTywGVJ3DmzUDTE0Bc3O+XzXDaZEGEDF1zSQIEUhAQAC8vLzw7bffCh0KeY5MJsO+ffuwbt06HD9+HIwxWFk1ww8/3EdxcTNkZwNPngDZ2aj0/MkToLCQJ4f6DWG1D8BHAOLr/EqptDyBWFgAdnaAvX35o2qxswMcHABnZ8DFhSceolYW3WkQQqooKAASE/ny4AHw6BGQmipFSspoJCePhkTyEHL5Rjx9+gPCw5fBxOTrShdjOzvA1RXo1In/bWHBL8Q2NvwiLpUCtrZ8nZkZIBLxu4SKVHcQJSXB+OmnTEydWtMdCX+ek8OTU1ERv5MpLubb8vP561RJLDUVuH4dyMrif+fnVz6mvT3g5AS0asUfXV0BNzegbVu+uLg03bsYutMgeoXuNHRHLgfu3gVu3ADu3ClPEomJwOPHfB+RiP/6bt2aXzxdXPji7MwvpI6OpXjw4DQGDepT1spJGxhjWq3PUCiAzEwgJYUnlORkIC2NJ8u0NL4+Kak8YUmlgLt7eRLx8AA6dgRefpnfsTRidKdBSFOQkgL8+SdPENevlycKuRyQSMovft26AWPGlP/dpg2/QFbPCB069Nd6/NquAJdIeFJ0cqp5v4yMysk1MRG4eBHYupXfsQCAoyNPHj4+PJF07swXExOtvgWdoaRBSCNTUADExwOXL5cvt27xbU5O/ELm7w+8/Tbg7Q34+vIiIvJijo586d276racHODmTf5Z37zJk8mGDfzfQyIBPD2Bvn2BPn34Z+7tze/kDA0lDUIMXH4+cPIkcPw4X27eBJRKXoTUowcwbhzQsye/UD3f8ohojq0tTwp9+5avKy0F/voLuHChfPnxR36HZ2/P9w0IAAYO5MncEFCdBtErVKfxYgoFcOYM8PvvwLFjwKVLPEl06sQvQH378mTh6ip0pEQdmQy4cgX44w/gxAme8HNzgZYt+b9fQAAQHMyTvh7KoqRB9AolDfWKiniSiI0F9u3jZett2gCBgby4Y+BAXkFNDI9SyYsTz5wBzp4FDh/md4/e3kB4ODBsGL9L1BOUNIh+oaRRTiYDfv0V2LYNOHKENx/18wPCwvji4SF0hEQbiov5D4S9e4H9+3lLtvbtgVGjgIkTgXbtBA0vq4m2NCZEf129CsyZw+8cIiJ48li9mjf9PHMGmD+fEkZjZmoKvPYar0RPTQVOneJ/b9rEk0e/fvx5YaEw8VHSIEQPKBS82aavL9ClC/Dbb8C8ebxvwMGDwNSpQIsWQkdJdE0sBl59FfjyS97J8sABXvcRFcVbws2cCdy7p9uYKGkQIqCiImDNGl7kMGkS4OXFf1nevQssXkz1FKScWMwryHfu5P1uPvmE1394egJvvMHvUHWBkgYhAlAqgf/7P+Cll4D33gNCQnjTzK1b+S9LQ2y/T3TH3p4XYf71F7B5M+8b0rUrEBrK12kTJQ1CdOz0aV4MNW8er9h88IAnEHd3oSMjhkYs5vVeV67wlnUPH/Le6IsXVx2jS1MoaRCiIwUFvAiqf39eHn39OvD//h/VVZCGE4mAoUN5n52vvgLWruVFnYcOaf5clDRIoxIfH4+QkBA0a9YMVlZWCAwMxNmzZ4UOC7dv8w53v/0G7N7NHz09tXMuxhjOnj2LWbNmwdPTE1KpFC1atEDfvn2xZcsWvKiVvVKpxOLFi9GuXTuYmpoiODi42n0vXryISZMmwd3dHWZmZrCzs4OPjw9GjhyJ7777DomJiQAAHx8fiESiSsvYsWPLjhMYGFhpW7du3aqcKykpCaGhocj/Z0janJwcREdHIyAgAHZ2djAzM0O7du0QGRmJq/Us4D948CA8PT1rHHxx0aJF2LFjR7XbJ0+eDKlUCnd3d8yZMwfFxcX1iqU+JBI+PMzdu8CAAbzY8+OPec90jWGE6BF/f382Y8aMer32/PnzzMzMjI0ZM4alpqayzMxMNm3aNCaRSNjhw4c1HGntxcQwZmnJWO/ejCUna/98t2/fZgBYYGAgu3r1KisqKmKJiYksIiKCAWDz5s2r8fVr165lANjy5ctZTk6O2n2USiWbP38+k0gk7L333mO3b99mxcXFLD09nR05coQFBgYyAAwAk8vljDHG0tPTmb29PQPAtmzZUuWYBw4cYO3atWOFhYVVtl25coU1b96cffPNN2XrpkyZwiQSCfv6669ZWloaKywsZKdOnWLe3t5MLBazPXv21PozS0hIYMOGDWOdOnVi1tbWTCwW17ivu7s7e//996vdJz8/n0VHRzMAbMWKFbWOQ9O++44xqZSxoUMZy8vTyCEzKWkQvVLfpKFUKlnHjh2Zk5MTe/bsWdl6hULB2rdvz9zc3FhxcbEmQ62VrVsZE4sZmzmTsZIS3Zzz9u3bTCKRsOzs7ErrZTIZs7e3Z1KptMbPQpVc8vPzq91nyZIlDABbt26d2u0KhYIFBwdXShqMMbZ161YGgNnb27P09PSy9dnZ2czNzY2dPXu2yrHy8vKYq6sri4qKqrR+ypQpbPr06VX2j4+PZwBYu3btqo3/eREREeyzzz5jcrmcubi41Jg0VOcQiURsx44dNe5nbm7OBg8eXOs4tOGPPxhzcmLMz08jiYOSBtEv9U0aJ06cYADYO++8U2XbsmXLGAAWExOjiRBr7dQpxoyNGZs/X6enrVGXLl0YAJabm1vtPoMHD67xonn79m1mZGTEfH19azzXuXPnqiQNxhgLDQ1lANjIkSPL1kVGRrIFCxaoPc7SpUuZRCJhKSkpNZ6vIjMzM2ZkZMRKS0trtX/FHxq1SRqMMRYeHs5cXV2rvL+KnJ2dX/g56cKdO4y1bMlYSAhjSmWDDpVJdRqkUTh+/DgAqC0LV607duyYzuLJz+etWl57jVd264Pc3Fz8/fff6Nq1K2xqGO5WqVTWeJx169ahtLQU4eHhNe7n5+cHxliV+oHo6GjY2tril19+QUxMDPbu3Yv4+HgsX768yjEYY9iwYQN69uwJ51qO4FdYWIiioqKyepTaMKvH2PCvv/46kpOTceDAgWr3EYlEUCgUdT62prVvD+zZw4cn+frrhh2LkgbRW3fu3EFYWBhsbGxgbm6OHj16IDY2tlKl6dSpU8v2BQBXNUO7uvzTQ+4vbTdgr+CTT4CSEmD9euH7XOTn5+Ps2bMIDQ1Fy5Yt8dNPPzXoeKdOnQIAdOrUqV6vd3JywqpVqwAAs2bNwttvv41NmzZBqma2p6tXryIjIwOdO3eu9fF37doFAFi6dGm94qutLl26AAAOHz6s1fNoSq9ewJIlwEcf8VkK64uSBtFLCQkJ8PPzw6VLlxATE4PHjx/jxx9/xOrVq3Ht2jVIpdKyX6EA/xUNABYWFlWOZWlpCYC3ttGFwkJg3Treac/eXienrNa///1v2NjYoG/fvhCLxdizZw98fHxqfE1JSYnaC7hKamoqAMC+AW9u4sSJGDp0KB4/fgwPDw/4VjOM640bNwCo/zGgTkZGBhYtWoSpU6di9OjR9Y6vNlQ/RlQxqiOVSiGXy7UaR13Mn89nYly7tv7HoKRB9NKSJUuQm5uL1atXY9CgQbC0tETHjh2xbds2FNZxpDb2TxNTbU8ZqnLqFPD0KTB+vE5OV6P3338fMpkMt2/fhpeXF7p27YpPPvmkxtc8fPiwVhfphn6e7f4ZrvXkyZPYt2+f2n3S0tIAoMbiNJUnT55gyJAhGDBgAKKjoxsUW21YW1tDJBKVxaiOs7MzUlJS9KKICgDMzYHRo/noufVFSYPopUP/9EoKCgqqtN7BwQFeXl5V9m/WrBkAqE0oqnWqfbTtxg2gVSs+sJw+MDExgZeXF7777juEhobiww8/xO+//15lv+zsbHzxxRdISkrCzJkzqz2eqm4hKyur3jGdPn0au3fvxsqVKwEAb731lto7QVUfB2Nj4xqPV1hYiKCgIHh7e2Pr1q0Qi8X1jq0uJBIJioqKqt0eFRWF/Px8fPjhhw36vDSpRw/+Ha0vShpE7yiVSjx9+hSmpqZlRUsV2draVlmnSiTJyclVtqWkpAAAPLXVm+45BQWAlZVOTlVnw4YNAwDExsZWWj9p0iTY29tj0aJFWLBgAWbPnl3tMfr37w8AuHbtWr1iKCgowKRJk7Bu3Tq8++67CA4ORnp6OubMmVNlX1NTUwCosYhHoVAgPDwcLi4u2LRpk84ShurcNVWijxs3DitWrMAXX3wBBwcHDBkyRGexVcfamg+UWd+bH0oaRO+IxWJYWVmhuLgYBWoG0Hn8+HGVdf7+/gCAy5cvV9mmWjdw4EANR6peixZ87gt9nN5MVVeRnZ1daf3GjRuRl5eHn3/+GStXrkRUVFS1x4iKioJEIkFMTEyN51qwYAGMjIzKGimozJs3D4GBgWUX0LVr18La2hqbN2+uksycnJwAAHl5eTXGI5PJsHPnzkottTw8PHD+/PkaY2yI/Px8MMbKYlRn6dKlWLJkCb777jvk5uaW3UELKTmZ17XV0Om9Zg1vAUyI5qj6aYwePZoBYLt27aq0PS0tjUmlUiaVSiutVyqVzNvbmzk7O7OioqKy9QqFgnXo0IG5ublVWq9Nly8zBvBHIcybN49FRkaq3TZu3DgGgP33v/+t9vXdu3dntra2NZ7jk08+YQDY999/r3b7nTt3mLW1NRszZkyl9YcOHWLu7u5VOg6uW7eOAWDOzs6VeqFfuXKFAWAzZ85Ue56PPvqI9ezZkz19+rTKtrZt27K4uLga34c6te2ncevWLQagxn5FXl5ezN3dvc4xaNOwYXypJ+rcR/SLKmkkJCQwOzs75uLiwo4cOcKePn3Krl+/zoYMGcJat25dJWkwxlhcXBwzNTVlY8eOZWlpaSwrK4tFRUUxiUTCDh06pLP3UFrKWIcOjE2apLNTVjJv3jwmEonYxx9/zO7fv8+Ki4vZ/fv32YIFCxgA5uvrW6kz2/MGDhxYq4vmokWLmLGxMVu4cCG7e/cuk8lkLDk5mW3YsIE5OTmxvn37soKCgrL9c3JymJubGztx4oTa46mGHplU4YMrLS1lLVq0YH369Kmy/48//lg2VEl1y/NJIzIykgFg9+7dq/Z91TZpbNu2jQGocbgSFxcX1rlz5xceS1f+/puPUPDzz/U+BCUNol8q9gi/e/cuCwsLY9bW1szc3Jz17t2bnTx5kg0cOFBt0mCMsT///JMFBwcza2trZmlpyQICAtiZM2d0+RYYY4xt2cKYkRFj587p/NQsLy+PbdiwgQUFBbGXXnqJmZiYMEtLS+br68s+++yzGhMGY/ziXZuLJmOMXbhwgY0fP565ubkxY2NjZmVlxXr16sVWr17NZDJZ2X4uLi6VLubDhw8v25aTk6P2gr9q1SrGGB+yRF2P8JCQkDonjYCAAGZpackUCkWl9fv376/2GOvXr1f73sPDw5mLiwsrqWF8GBcXF9alS5dafZbaVlrKWHAwY97ejNXQif1FKGkQ/VKbYURqShr6ZMgQxlq1YiwjQ+hI6iYkJISJRCKhwyiTm5vLXFxcqow9VVc5OTnMzMyMTZ06tcExqcae2r59e437OTo6sl69ejX4fJrw6aeMSSSMnT7doMPQMCKEaMuWLYCxMTB4MPDkidDR1J6rqysYY8jIyBA6FAC8j8b+/fsRExODNWvW1OsYjDHMnj0b1tbWL+yn8iL37t3DiBEjsHjx4krDuz9PLpcjOzu71h0TtWntWmDpUmDlSqBv34Ydi5IGIVpibw8cO8bHoerVC6hnC1WdU7Vq+s9//oMnepLtunbtikuXLuG3334rm0+jLjIyMnDv3j0cO3YMLRvYgWbt2rVYsWIFVqxYUe0+eXl5WLlyJeRyuaDNbJVKYOFCYMYMPrTNO+9o4KAaue8hRENqKp7avn17lfLmKVOm6DjCusvMZCwwkDFTU8aqaWykdz7//HPWoUMHJpVK2ZAhQ4QOx6BMnDiRGRsbMw8PD/bBBx9UqT/RlcxMxgYN0vj3LlPEmD62JidNVUBAALy8vPDtt98KHYpGKRR83uavvgLGjAG+/BL4Z+giQjSKMWDrVmDBAsDMDPjlF+CfsRU1IYuKpwjRAYkE+OILPubPxYt8/ub//IePhEuIpsTHA/36ARMnAqGhfM5wDSYMAFSnQYhOhYTwcX8WLuRlzN7efPh0mUzoyIghu3kTmDAB6NaNzwd+8SIQHQ2oGXGnwShpEKJjpqbA++8Dt28DAQG8ctLdnd+JPH0qdHTEkMTFAcOHAy+/DPz5J/DTT8CZM8Arr2jvnJQ0CBFIq1Z83o1794DISH7n0aoVMGsWL1YgRJ38fGDDBqB3b75kZgJ79wLXrwNvvKH9Sb8oaRAiMGdnfpeRlMRnVjtxAujeHejUiU/N2ZBZ1kjjwBhw8iSvq3ByKr87PXkSOHeO11/oaoZIShqE6AlbWz7b361b/E7D35/ffTg58Q5Zn38OJCQIHSXRFaWSFzXNmcPvQAcM4N+LDz8EHj3iLaT69dN9XNTkluiVxtrktr6ePeMtrvbsAX77jdd5+PoCYWFAcDBvGWNEP/0ajSdPgOPHgV9/BQ4cAHJy+L9xWBgwahTQsaPQESKLkgbRK5Q0qieT8QvK3r38opKeDtjZ8V+gAQF86dBB6ChJXTx9yqcHPn6cL9eu8WKmPn14oggL48VQeoSSBtEvlDRqhzHedPf4cT5UyalTQF4eL8rq0wfo2ZNP6+nrC1hYCB0tUUlIAC5cAP74gz9eusSLoXx8yhN///5ALaZEF0pWfeduIoQISCTizSxffpmXeSuV/AJ04gRvhvnVV/xORCzmRRo9evDK9Zdf5n9bWwv9Dhq30lLg/n3eoik+nieICxd48ZOxMdC5M0/sc+fyuqsWLYSOuPYoaRDSCIjF/CLUs2f5uocP+S9a1a/an3/m85cDwEsv8eTh48MXb2+gbVu9/oWrl5RK/jn//TdPEDdv8sdbt3h9lEgEtGnDk/b77/N/n65deV8dQ0VJg5BGqlUrvoSH878ZAx48qHxx++03YNWq8uFMHBx48lAtHh78oufmBrRsCZiYCPZ2BJOTA6Sm8s8uIQFITCx/fPCg/LNzdOR3cn37AlFRvMm0tzdgaSlk9JpHSYOQJkIk4pWq7u68Xb+KXM47GCYmli8JCcDOnbyIpeIQJy1b8sXVlfcvcXbmfzs48Ep5e3u+2Nnp96/pnBxeVKRasrOBrCzelDU9nT+mpQEpKUBRUfnrHB3LE2qvXuXP27Xj77spoKRBSBNnbAy0b8+X55WW8ovnw4f8YpqczH91p6QAJ06sRk7OYygUK5CbW/W1FhblCcTcnC82NjyZWFgAVlb8uZUV318q5ftUZGNTuUlxYWHlQR4ZQ9m55XJe/FZQABQX857ThYU86eXm8ueqJFFaWvk8UimP1dWVNybo3BkICipPji4u/K6tsd011AclDUJItYyM+AWz4jDuCoUCs2fPxr1767BixQosXMjL9iv+an/+8dkzvuTl8Yt6Rga/qBcXl9ez1JQQVExN+XDfFakSi1gMlJb+ClNTwMUlFDY2vILZ1JTvUzGJ2dsDzZuX/03JoPYoaRBCai0nJwejRo3ChQsXsHv3boT+U84lFvMLtNCtgKZM2YeLFy/i8OHQF+9M6oX6khJCaiUxMRG9e/fGnTt3cPLkybKEoU+mTZuG69ev4/z580KH0mhR0iCEvNC5c+fg5+cHqVSK8+fP4xVtjr3dAL169UKXLl2wfv16oUNptChpEEJqtGPHDgwcOBB9+/bFuXPn4ObmJnRINZo6dSq2b9+OXHW186TBKGkQQtRijGHZsmWIiIjA9OnTERMTA/PnmzfpoXHjxsHIyAjbtm0TOpRGiZIGIaQKmUyG8ePHY8WKFVizZg1Wr14NIwMZTtfGxgajR4/G2rVrhQ6lUTKMbwEhRGeysrIwaNAgHDx4EIcPH8aMGTOEDqnOpk2bhmvXruHChQtCh9LoUNIghJS5ceMGunfvjpSUFJw9exYBAQFCh1Qvfn5+VCGuJZQ0CCEAgKNHj6Jv375wdnZGXFwcOhj45BxTpkzBzz//jAJV70GiEZQ0CCFYv349QkJCMGTIEBw7dgwthO6lpwFvvPEG5BdSL5cAACAASURBVHI5fvnlF6FDaVQoaRDShCmVSixatAhRUVFYsmQJtm/fDlN9HmmwDuzs7BASEoLNmzcLHUqjQsOIENJEFRQUIDIyEocPH8bmzZsRGRkpdEgaN378eIwcORKPHj3S+/4lhoLuNAhpglJSUtC/f3+cO3cOR48ebZQJAwBCQkJgZ2eHLVu2CB1Ko0FJg5AmJj4+Hr169YJMJsPFixfx6quvCh2S1hgbG2Ps2LHYuHGj0KE0GpQ0CGlCdu/ejT59+qBDhw44e/YsXnrpJaFD0rrx48fjr7/+wsWLF4UOpVGgpEFIE7F69WqEh4cjMjISBw4cgE0TmRC8R48e8PLyogpxDaGkQUgjp1AoMHPmTMybNw+ffvop1q1bB2NjY6HD0qnx48dj27ZtKKk4yxOpF0oahDRiOTk5CAoKwubNm7F7924sXLhQ6JAEMXHiROTm5uK3334TOhSDR0mDkEbKECZN0hUXFxf079+fiqg0gJIGIY2QoUyapEtjx47FwYMHaViRBqKkQUgjY2iTJunK66+/DrlcjgMHDggdikGjpEFII2GokybpSvPmzTFgwADExMQIHYpBo6RBSCNgyJMm6VJ4eDgOHjyIwsJCoUMxWPStIsTANYZJk3RlxIgRKCkpwcGDB4UOxWBR0iDEgDV00qSDBw/C09MTEknTGLu0efPm6NevH3bt2iV0KAaLkgYhBqohkyYlJiYiNDQUixcvRkZGhhaj1D/h4eE4cOAAFVHVEyUNQgxQQydN+uCDD9C7d29cvnwZVlZWWopSP40cORIlJSU4dOiQ0KEYJEoahBgQTU2a9P3332PRokVNpliqIgcHB7z66qtURFVPTe8bQ4iB0uSkSWZmZhqMzPCMGjUK7733HgoLC2FhYSF0OAaF7jQIMQAvmjTpzp07CAsLg42NDczNzdGjRw/ExsYiMDAQIpEIIpEIU6dOFSh6/TNixAgUFxfj6NGjQodicOhOgxA9Fx8fj2HDhsHGxgYXL16sMgdGQkIC/Pz8YGFhgZiYGPj5+SEpKQlz587FtWvXIJVKUVxcLEzweqply5bo3r07Dh48iLCwMKHDMSh0p0GIHqvNpElLlixBbm4uVq9ejUGDBsHS0hIdO3bEtm3bqIVQDYKDgxEbGwvGmNChGBRKGoToqdpOmqRqBRQUFFRpvYODA7y8vLQep6EKCQlBWloarl27JnQoBoWSBiF6pi6TJslkMjx9+hSmpqawtLSsst3W1lbb4RosX19fODk5Ue/wOqKkQYgeqeukSVKpFFZWViguLlY75Pfjx4+1FarBE4lECAoKoqRRR5Q0CNET9Z00KTg4GACqdFZLT0/HX3/9pfE4G5OhQ4ciLi4OT548EToUg0FJgxA90JBJkz799FPY2dlh7ty5OHr0KAoKCnDjxg1MnjwZLVu21GLUhi8oKAhGRkbU9LYOKGkQIrCGTprUtm1bxMXFoXv37hg1ahQcHR0RFRWFxYsXw8PDQ+1rYmNjy/pvpKSkQKlUlv29YcMGTbwtg2BtbY3evXtTEVUdUD8NQgTCGMPHH3+M5cuX45133sGqVavqPQeGp6cn9uzZU+v9X3vtNWpq+o+hQ4fiiy++QGlpKc1BUgv0CREiAJo0SX8MHToUWVlZuHjxotChGAS60yBEx7KysvD666/j5s2bOHz4cJ3nwCCa5ePjg9atW+PAgQPo2bOn0OHoPfppQ4gOqSZNSk1NrdekSbX1888/QyQS4dixY5DJZDT21AsEBQVRZXgtUdIgREcaMmlSXY0dOxaMsUpLU6rgrit/f39cunQJ+fn5Qoei9yhpEKIDDZ00iWhXQEAAlEolzp49K3Qoeo+SBiFapKlJk4h2tWjRAh06dMCJEyeEDkXvUUU4IVqiyUmTiPb5+/tT0qgFutMgRAteNGkS0T/+/v64cuUKcnNzhQ5Fr1HSIETD4uPj0atXL8hkMly8eBGvvvqq0CGRWujXrx9KS0upXuMFKGkQokG1mTSJ6CcHBwd4enri3LlzQoei1yhpEKIhtZ00ieivPn360J3GC1DSIKSB6jJpEtFvffr0wYULF1BSUiJ0KHqLWk8R0gA5OTkYNWoULly4gN27d9d6Dgyin/r06YOioiLEx8ejR48eQoejl+hOg5B6qu+kSUR/eXp6wsHBgYqoakB3GkQw0dHR2LlzJ0pLS8vWJSUlITU1FQMGDChbZ2RkhHnz5iEkJESAKNU7d+4cwsLC4OzsjPPnz9d5Dgyin0QiEXr27Ik//vhD6FD0FiUNIhgvL69qO1PdvXu37LlIJMKWLVt0FRby8/Px5MkTuLu7q92+Y8cOTJo0CcHBwdiyZQvMzc11FhvRPl9fX51+3wwNFU8RwfTr1w+Ojo417mNkZFQ2yJ+uLF++HEOGDEFeXl6l9YwxLFu2DBEREZg+fTpiYmIoYTRC3bp1w71795CdnS10KHqJkgYRjJGREcaNGwcTE5Nq9xGJRJgwYYLOYrpz5w6+/vpr/P3333j99dehUCgA0KRJTUm3bt3AGMOff/4pdCh6ib71RFARERE1Nm8UiUQYMWKEzuJ55513YGRkBMYYTp06henTpyMrKwuBgYE4ePAgDh8+jBkzZugsHqJ7LVu2hIuLCy5duiR0KHqJ6jSIoHx9feHu7o779+9X2SYWizFkyBDY2dnpJJa9e/fi999/L/tbqVRi48aNuHr1KvLz8xEXF4f27dvrJBYiLF9fX1y+fFnoMPQS3WkQwU2YMEFtZ7jS0lKMGzdOJzHIZDK8++67VYqcGGO4cuUKPvroI0oYTcgrr7yC+Ph4ocPQS5Q0iODGjRsHuVxeZb1UKsVrr72mkxi++OILPHr0qFLz34qmTp2Kixcv6iQWIjwfHx/cu3cPhYWFQoeidyhpEMF5eHigU6dOEIlEZeuMjY0xYsQIWFhYaP38ycnJWLFiBZRKpdrtjDEolUqEhIQgOTlZ6/EQ4fn4+KC0tBS3b98WOhS9Q0mD6IUJEyZALBaX/S2Xy3U2B8X8+fOrTRgqCoUCmZmZGD58OP36bAI8PDxgZmaGGzduCB2K3qGkQfRCREREpaIha2trBAYGav28p0+fxs6dO9UWj6kYGxtDJBLB398fCxYsgERC7UcaO7FYjA4dOlDSUIO+/UQvODs7w8/PD3FxcRCLxYiIiKix/4YmlJaW4p133oFYLC7rj6FibGwMuVyOFi1aYPLkyZg+fTratGmj1XiIfvHx8aGkoQYlDaI3xo8fj7i4OMjlckRERGj9fGvXrsX169fL7nBEIhGMjIxgZGSE0NBQTJw4EUOHDq1UbEaajo4dO+L48eNCh6F3KGmQBnv6FFAoAJkMePYMYAyoOM3ys2d8mzqlpYBqtA6pdDREorfRrFkLZGS8il27AJEIaNas+nObmwNSKX9uZASo5j2ysgIkEr5N3Ugf2dnZWLJkCUpLSyGRSKBQKODt7Y233noLkZGRsLW1rfsHQRoVDw8PpKSkoKioCGZmZkKHozdEjDEmdBBENwoLgexsICeHPz59ytfl55c/f/aMb1c9f/qUX9SfPQOKioDiYv5Y8WKvWSEAvAF8odGjVkw+lpZAXt47yM//P4jFVnB2noj27d+Es3NXWFgA1tY86VhY8IRja8ufW1kBdnb8bzs7wNRUoyESPXPt2jV07twZN2/ehLe3t9Dh6IssutMwUHl5QFoakJkJPH7Mn2dnV04Kzz+qG61DLC6/SJqb84tjs2blF0wHh8rbjI35RRfg+4lEfL2JifptQOX16lhb8zgAYNu2SHTo0AFdu/K/S0p4Aqvpc1DVnysUPMlVXK9KdEolT44AcPfuDcTG/g1//21wc3sdJSWmyMkBnjwBHj3i++Xn80SpSqLqmJlVTiLPPzZvDrRsyT9DR0f+XActiImGeHh4QCQSISEhgZJGBXSnoWfS0/mFKzkZePiwPCFkZgIZGXz748eVi3tEIn5hsrev/gKmbp21dXnRjr6QyWSQajkouVxe5+lYnz3jiaSmpPz8uszMqgnH3JwnD0dH/m+met6yJeDmBrRqBbi68n9LIjxnZ2e89957ePfdd4UORV/QnYYuFRcDiYnA/fs8KTx6xJeHD/nfycmVk0HLlkCLFoCzM7/AtG8PODnxdQ4O5esdHHj5fWOg7YQBoF7zd5ubl1/w60Im48kjPZ0n/cxM/iPg8WO+JCQAZ8/y7U+eVD5f69Y8gbi68mSiSiju7sBLL/E7OKJdHh4eSExMFDoMvdJILjX6o7gYSE0Fbt4Ebt0C7t0rXx48KC9KMTXlF/02bfjFoFcv/rxNG54YWreuuUiHGAaptPzC/yIyGZCSwr8/aWnl35vU/8/emcdFVb1//DMsDvsuiICJICgY7rnvuCCupZmpqWVZmtvPNMTMvpplWVSaW5pmmqlhWuKSW+aeiuKWiltuMCyyg2wz5/fH6QLDLAwwcGeG5/16ndcd7jn33ude7j2fc85zlgTgyhVe4CjbwcDTEwgOLn1vhBAYSO+OvvDz8yPRKAeJRhV5+hS4epULg7C9cYOXJAHeRu/jA/j7A35+QP/+fOvvzz9satsmyiOVlmb8mkhP50Jy5w4XkTt3gJs3gZgYLi4Ab6708gKaNwdatACCgoDnn+dbe/vauRdTwcfHh6ZILweJRgUUFACXL/Nw/Tpw7RrfymQ83smJf5jBwcCLLwJNm3Jx8PXlzmGC0CfOzkDbtjyUJy9PWUz++Qc4cQJYu5bHAbxZKyio9J1t3Zr/TUNR1OPl5YUnT56IbYZBQY7wMhQXA7duAbGxyiE/nwuAvz//WIOD+YcWHMzFocw8ewRhkCQkcBERmk2vXwcuXeJiYmkJhIQAXbqUClLz5nzcS10nJiYGgwcPRk5OTq1MnmkEpNZp0Xj6FDh+HPjrL+DcOSAujnfRtLUFWrUC2rcH2rXjISCAxIEwLYqLuXhcuACcP8+3V64ARUV8kGTbtkCnTkCPHkDnznWzSfXixYto27Ytbt++DX9/f7HNMQTqlmikpXGROHYM+PNP3tQE8FJW586lAkHVdaKuIjTHXrjAw+nTvPZtackLUT178lBXRCQpKQkNGjTAsWPH0KNHD7HNMQRMWzQUCl6C+u03YP9+XooCgJYteempVy+gWzfeTkwQhHoSEnhB69gxXiuPj+ci8sILQHg4MHQoL2iZIgqFAlZWVvjhhx/w6quvim2OIWB6opGfDxw+DPz+O7BnD3dYN2kCDBoE9OlDIkEQ1SUhgdfUjx7lvbaSk7m/b+hQYMgQ7hsxpZp6gwYNMH/+fEybNk1sUwwB0xjcp1AAhw4BGzYAe/dy51779sC0afwlbtFCbAsJwnRo2BAYM4YHhQI4e5YX0n77DfjySz59yksvAa+/zmsjxo6zszMyyg6QqeMYdf+IBw+Ajz7iPZjCwviAqKgoPkDq77+ByEgSDIKoSczMuH9j6VI+Tik+Hpg7l49y79CB+wu/+UZ5tLux4eTkhHRNE5DVQYxSNA4eBAYM4M1Oa9cCr7zCBzgdPw689RYfKUsQRO3TtCkwZw4f8Hr2LO999eGHfLDh6NHAxYtiW1h5qKahjFGJRkwM7wbYvz+vFu/cyedt+uwz3iVWbIYMGQKJRIKPP/64wrRyuRzz5s1D06ZNYWVlhbCwMI1pz58/jwkTJsDX1xfW1tZwcXFBixYt8NJLL2H16tVK0xzY2dlBIpGoBDMzM9SvXx/Dhg3D+fPnNV7rwYMHGDJkCLKEKWHLsG/fPgQEBFRrudO4uDiEh4fDyckJ9vb2CA0NxalTp1TSRUREYPv27RrPM3HiREilUvj6+mLGjBnIz8/X6fo1eX9du3ZV++wlEglmzpyplHbNmjUa0wpB0zuhi50VPb/aoEMHXqhLSADWrOG1kLZteYHv3DlRTasUzs7OVNMoCzMCLl9mrFcvxiQSxl58kbHYWLEtUmXTpk0MAAPAFi9eXGH6tWvXMgBs0aJFLD09XW0auVzO3nvvPWZhYcHmzJnDbty4wfLz85lMJmMHDx5koaGhJdcsKioqOe7SpUsMABs6dGjJvoyMDPbrr78yd3d3ZmlpyQ4dOqRyvUuXLjE3Nze2YsUKpf137txhgwcPZiEhIczBwYGZm5vr+liUOHv2LLO2tmajRo1iCQkJLCUlhb355pvMwsKC/fHHHyrX9PX1ZR988IHG82VlZbE1a9YwAGzJkiUVXr+m769Lly4l/4/yYcaMGUppV69erTGtEBYtWlRlO3V5fmJw4ABjXbrwb/mVVxh7/FhsiypmypQprGfPnmKbYSikGLRoFBUx9uGHjFlaMtaxI2OnT4ttkXqePHnCnJ2d2bhx43QWjdGjRzMALCsrS2OayMhIBoB99913auOLi4tZWFiYTqIhsGXLFgaABQcHK+3PzMxk3t7ebPLkyWpt/fTTT1lRURHz8vKqUqYql8tZcHAw8/T0ZHl5eUr3EBgYyHx8fFh+fr7SMXFxcUwikbDt27drPbeNjQ3r16+f1jQ1fX+McdE4f/68TmlXr16t9v/DGGPx8fFMKpWyxMTEatmp6/MTg127GGvalDFHR8bWrRPbGu3MmTOHdejQQWwzDAXDFY3UVMZ692bMxoaxb75hTC4X2yLNDBw4kL311lts8+bNOotGv379tH70N27cYGZmZqxt27Zaz3P69OlKicaTJ09KSrJlazjz589nFhYW7MmTJyrHlM3kq5qp/vnnnwwAmzZtmkrcRx99xACw6OholbiRI0cyb29vpfsrT8OGDSt8TjV9f4xVTjQOHTrEvvjiC7Vx06ZNY6NGjdKLnbo8P7HIy2PsvfcYMzNjbMIExsqVGQyG+fPns1atWolthqGQYpA+jdRUPuo0Pp47t6dPN9x5cDZs2IDr16/jiy++qNRxcrlca/x3330HhUKBkSNHak3XqVMnMMZ0bodnZYblSP6bF4UxhvXr16NDhw5o2LChyjH6WB/56NGjAIB27dqpxAn7jhw5ohI3fPhwPH78GHv37tV4bolEguLiYo3xtXF/lSU0NBSzZ89W2Z+dnY1NmzZhypQpKnFVsVOX5ycW1tbAsmW8m/zu3cDgwZrXkhcTS0tLFKpb9rKOYnBZcXExH1vx7BnvfaFuNk9D4fHjx5g9ezY2bNgAez3POX38+HEAQEhIiF7Pe+zYMQBAcHAwHB0dAQCXL19GUlISWrZsqddrleXmzZsAAG81C0t4eXkBAOLj41XiWrVqBQD4448/qnzt2rg/gc2bN6NVq1awtbWFo6MjunXrhq1bt+p8/MaNG9GoUSN0795dL/bo4/nVNAMG8AG5584Bb78ttjWq1KtXj0SjDAYnGl9/zScO3LOHd9MzZCZNmoRXX30VvXv3rvSxhYWFWlepS/hvcQRXPa37mZWVhV27duH//u//YGlpia+//rok7tp/k3Cpy9D1hdBlUd1MoXb/rRikroeKICiCjeqQSqUoKirSGF8b9yeQnp6ODRs2IDk5GefOnYOvry/GjBmD6dOnV3gsYwwrV65UW8uoKro8P0OgbVtgyxZg0yZg3z6xrVGGREMZgxoRLpcDy5fzkdzNm4ttjXbWrVuH27dvY+fOnVU6/uHDhzplYpJqTK3722+/lRwvkUjg4uKCLl264IMPPkD79u1L0iUmJgJASc2jthGazNTdq4ODAyQSSYmN6mjYsCGuXr2K4uJitc10tXV/J0+eVPo7MDAQP/74I27duoUVK1ZgzJgx6NChg8bj9+/fj8TERIwbN05vNuny/AyFQYP4XFZRUcDAgWJbU0q9evVQYIjtZiJhUDWNu3f5mtmjRoltiXYePnyIOXPmYMOGDZWeYz8tLQ3Lli3DgwcPtJYohbb31NTUKts5dOhQMMbAGINCoUBqaip+++03JcEAUDLGoSprZ+uKk5MTACA3N1clTtgnpCmPhYUFnj17pvHckydPRlZWFj788EO1z6s27k8bI0aMAADs2bNHa7rly5fjtddeK6l56YuKnp8hMWoUXziqApdfrWJubl6hD7IuYVCikZbGt/Xri2tHRezZsweZmZno2bOn0mAsoYS4YMGCkn137twpOW7ChAlwdXVFREQE5s6dq7XJQpiG+YowNW8NYmVlBQBam3iqS7NmzQBwP1B5hJXRAjSM0CwuLtbqBB47diyWLFmCZcuWoX79+hgwYIBSfG3cnzY8/5uiIDk5WWOa+Ph4HDx4UK9NUwIVPT9Dwt0dKCwEsrPFtoTQhEGJRuPGfHv9uqhmVMjUqVNLSvBlw+bNmwEAixcvLtlXduGWH374AZmZmdi2bRuioqIwefJkjdeYPHkyLCwsEB0drdWWuXPnwszMrMTRXBWETC0zM7PK56iIXr16AQBiY2NV4oR9ffr0UYnLysoCY6zERnXMnz8fkZGRWL16NTIyMnDgwAGl+Nq4P20I/il3d3eNaZYvX47u3bsjSM9zjOvy/AyJa9cAFxe+jDJhmBiUaDRowKcuX7FCbEtqDgcHB4wcORKtW7fWKggBAQFYuHAhLly4gA0bNqhNc+vWLaxduxYvv/xySUm+KrT4b1ZHdbUAfdGjRw8EBQUhOjpaacoPuVyObdu2wcfHB+Hh4SrHCbWQFlpmnvz111/h6+uLSZMmqfVb1Mb9rV+/Hm3VdPVjjGHHjh0AgMGDB6s9NisrCz/++COmTp2qd7t0eX6GQkEBn3bk5ZfFtoTQhkGJBgAsWgQcOAB8/73YltQsDg4Oauc/KssHH3yAiIgIvP3224iIiEB8fDwKCwvx5MkTfP/99+jVqxdCQkLwfTUfVsuWLeHu7o7Lly9X6zwCY8eOhUQiwf3790v2mZmZ4fvvv0daWhomTpwImUyGp0+fYurUqbh9+zbWrVtX0oxUlri4OABAv379NF4vOzsbDg4OGuP1eX///vsvzM3NIZFIcLHc7HsXL17E1KlTcefOHeTn5+PWrVsYN24cYmNjMW3aNI1O8A0bNsDOzg7Dhw+vtn3l0eX5GQoREXym6vffF9sSQiu1PZxQFz74gDELC8Z27BDbEt2YPHmy2rmD+vfvr/GY0NBQnUcenzt3jo0bN475+PgwS0tLZm9vzzp27Mi++eYbVlBQoJTW1tZWxY7AwMAKrxEZGalxxPSePXs0zo+0Ts0cEL1792Z2dnasuLhYJe7ixYssLCyMOTg4MDs7O9a7d2928uRJjXaNHDmSeXl5scLCQo1pvLy8Khyxq6/7u3//PjMzM2MSiYRduXKlZH9+fj775Zdf2PDhw5mfnx+TSqXM0dGR9ezZk23dulWjXQqFgvn7+7MPP/xQq/2VtVNAl+dnCCxezEeGa3lUorFy5Urm5uYmthmGguFOIzJzJn+J/vc/w55CpKqEh4cziUQithklZGRkMC8vL7VzM1WG9PR0Zm1tzSZNmlRtm4S5k37++Wet6Tw8PFjHjh21ptHX/RkTuj4/McnNZWz8eMbMzRlbvVpsa9RDoqGE4YoGY4ytWsVYvXqMde7M2D//iG2NfhFqJzKZTGxTSrh48SJzdXVl3377bZWOVygUbNy4cczDw0Nlsr3KcvfuXdakSRMWGRmpNV1hYSGztLRkI0aMqPCc1b0/Y0LX5ycmf/3FmL8/Y87OjO3fL7Y1miHRUMIw554SeOcdIDaWTy3SsiUweTKQlCS2VfpB6Ba6dOlSPDWQZc1at26NCxcuYP/+/RX6W9SRlJSEe/fu4ciRI2jQoEG1bFm7di2WLFmCJUuWaEyTmZmJqKgoFBUVqXSzVUd178+Y0OX5icXDh8Brr/H55QICgCtX+FQihJEgtmzpglzO2KZNjHl6MmZnx9j06cYxD39FfPbZZ6x58+ZMKpWyAQMGiG2OUTF+/HhmaWnJ/P392YIFC9T6TwjD4s4d/u1KpYwFBhqPz5JqGkqkSBgrM+2pgZOTw1cAi4riAwGHDwfeeAPo3dtwZ8EliLpMYSHw22/Ahg18meaAAN47auxYoBoLQNYqq1atwsKFC5GSkiK2KYZAqlFltXZ2wHvvAffuAatX8ylH+vYF/Px4V91Hj8S2kCAIgA/SmzWrdG1wc3O+PPP168CECcYjGIQqRiUaAlZWwMSJwMmTwD//ACNGAKtW8RHlvXrxmXLv3RPbSoKoW8TF8cJbmzbA888DMTFcOB484L+HDaMWAVPA6P+FzZvzhVwePeIlGS8v/uL6+QEhIcAHHwDnzwPG0whHEMZBURFfB2P6dF5ga90a+O47oGNH4NgxvohaZKThL3FAVA6TqSRaWvKSzLBhvLfV8ePA778DW7cCS5bwKUp69eI9Nnr0AAIDxbaYIIwLuRy4fJkLwrFj/BvLzOSFs3HjgKFD+boY1ZjNnzACTEY0ymJhwZ3jvXvzpqorV/jCLn/9BcyezR3qnp6lAtKjB1CNqZsIwiQpLxInTgAZGYCbG9C9O/Dxx3z9C19fsS0lahOTFI3yhITwEBHBP4S4OO4POXWK78vIABwceDts27alIThYbMsJovZISODjooRw6hSQns6XKujQgX8roaG8GYp8E3WXOiEaZTE3LxWFGTN4U1ZsLF+f+Px54NAh4NtvAYWC10bateOhTRsuIo0bU/WbMG6Ki4E7d3gPp4sX+Xt/4QIvPFla8sJT+/bA559z/0RwML3zRCl1TjTKY2HBS1FlJyDNyuIf04UL/IP64Qdg4UIeZ2fHne8tWgBBQfwDCwoCfHxEMZ8gNKJQ8F6E167xXobC9sYNPn7C3Jz79tq1AxYv5kLRsiXvnUgQmqjzoqEOBwfu7+jZs3RfZmbph3f9Og8HDvCpnAHA0ZH7Rfz9VYObmxh3QdQVnjzhNYe7d/lWCDdvAs+e8VpC48a8cDNgAPfrBQfzwo+RLOhHGBAkGjri6Ah06sRDWdLSlEtwd+4A27YB9+/z0pxwrCAgfn5AkyaAtzevnTRqxGsvBKGJtDTg8WM+Z9OjR7z2UFYghOW/bWz4++Xvz30P775bRUf2yAAAIABJREFUWiOmd4zQFyQa1cTFhfck6d5deb9czj/wsiXAu3eBPXu4oOTklKZ1cuIi8txzvE+78Nvbm3cVdnen2oopolAAyclASgqvLTx+zMODB6V/P3gA5OWVHuPiwnsr+fsDgweXFkT8/YGGDcW7F6LuQKJRQ5ib8yaBxo15qa88GRmlmYKQWTx8CNy+Dfz5JxecMquiwtKSi4eHR6mQNGjA/3Z35057V1fA2ZlnLLa2tXWnRFmysnjNID2dC4IQEhK4OCQl8SbNlBS+X6EoPdbOjtc8hRpoly586+1dWpCwsRHv3ggCINEQDScnHrQt3SxkODIZDykpfJuUxENcXGma4mLlY+vV4+Lh7FwqJOV/29vzjMrRkWdGtrb8t50d/7uuNWlkZQG5ubxkn5HBa4N5eXybmQlkZ3MxSE8vFQZhK/yWy5XPKZWWirq7O8/8X3iBd2Mtu9/Tk78PBGHokGgYMO7uPGgTFoGUFJ5plc/Eymds9+6V/s7J4RmhNpycgHr17sLWth5cXHxK9kkkXFikUt4Dzd4eauMELC01i5C2uKws1YxYIDNTuaSelwcUFHABFe5LSKMuLj29VCR0eQ52dsrC26ABdyZrEuf69UkICNODRMNEqF+fh6qQmVmaeQol6rw8vu/Ro1QsXRoGa+vnERq6E4zxUjjARaeoiKdLSYHaOAEh0y6LXH4Zcvk1FBePUYkTKC8+2uKsrHhvIDMzXmMCuJhZWPBM3MZGOc7JqbSG5eDA09ra8uDkVPq7rtW4CEIbJBoEHB1LM9Ky5OfnIzR0GGxti3D06Cp4eOj3upGR2/H777/j2rUx+j0xQRA1BokGoRbGGCZNmoRr167hxIkT8NC3YgCIjY1F27Zt9X5egiBqDppBhlDL3LlzsWPHDuzcuRPPP/98jVzj4sWLJBoEYWRQTYNQYd26dfjyyy+xadMm9OnTp0au8e+//yI1NZVEgyCMDKppEEocPXoUU6ZMweLFizFu3Lgau05sbCzMzc3RqlWrGrsGQRD6h0SDKCExMRFjx47FoEGDEBkZWaPXio2NRbNmzWBLoxAJwqgg0SAAAEVFRRg5ciQcHBywadMmSGp4LmxyghOEcUKiQQAAIiIicOXKFezevRsODg41fj1yghOEcUKOcAKHDh3C119/jQ0bNqBZLax7S05wgjBeqKZRx0lNTcX48eMxfPhwjB8/vlauSU5wgjBeSDTqOFOnToWFhQXWrVtXa9ckJzhBGC/UPFWHiYmJwY4dO7B//344OzvX2nXJCU4QxgvVNOoomZmZePvttzF+/HgMGDCgVq9NTnCCMF5INOoo8+bNQ3FxMaKiomr1uuQEJwjjhpqn6iDXr1/HunXrsH79eri4uNTqtckJThDGDdU06iCzZs1CSEhIjU4ToglyghOEcUM1jTrGnj17cPjwYZw8eRJmZrVfZiAnOEEYN1TTqEMwxrBo0SIMHz4cnTt3FsUGcoIThHFDNY06xK5duxAbG4v169eLcn1yghOE8UM1jTqCUMt46aWX0LJlS1FsICc4QRg/VNOoIxw5cgSXL1/GDz/8IJoN5AQnCOOHahp1hBUrVqB79+6ilvLJCU4Qxg+JRh3gwYMH2Lt3L6ZNmyaqHeQEJwjjh0SjDrBx40Z4eHhg2LBhotlATnCCMA1INOoA0dHRGDFiBCwsqu7C2rdvHwICAqp8Dn04wePi4hAeHg4nJyfY29sjNDQUp06dqvL5CIKoPCQaJk58fDyuX7+Ol156qUrH3717F0OGDMG8efOQlJRUZTuq6wT/+++/0blzZ9jb2+PGjRu4f/8+mjRpgp49e+LgwYNVtosgiMpBomHi7Ny5E+7u7ujSpUuVjl+wYAE6d+6M2NhY2NvbV9mO6jjBFQoF3njjDTg5OWHjxo3w9PSEm5sbVq9eDT8/P0yaNAkFBQVVto0gCN0h0TBxjh07hv79+8Pc3LxKx3///feIiIioVtMWUD0n+PHjx3H9+nWMGDEC1tbWJfvNzc0xevRoPHr0CDExMdWyjyAI3SDRMGEYY4iNjUX79u2rfI6ymXRVqa4T/OjRowCAdu3aqcQJ+44cOVJ1AwmC0BkSDRPm3r17ePr0qVJme/PmTQwbNgyOjo6wsbHBCy+8gJiYGISGhkIikUAikWDSpEl6tUOdE7wydty8eRMA4O3trXJuLy8vANx3QxBEzUMjwk2YixcvwsLComTakDt37qBTp06wtbVFdHQ0OnXqhAcPHmDmzJm4cuUKpFIp8vPz9W5HeSd4Ze3IyMgAALVOdDs7OwBAenq63u0mCEIVEg0T5u7du2jUqBFsbGwAAJGRkcjIyMD69evRt29fAEBwcDC2bt2Kxo0b15gd5Z3g+rSDMQYAkEgkerOXIAjNUPOUCZOYmAhPT8+Svw8cOAAA6N+/v1K6+vXro1mzZjVmR3kneGXtcHJyAgDk5uaqxAn7hDQEQdQsJBomTGJiIho2bAgAKCgoQHZ2NqysrEqadMri7OxcIzaUd4JXxQ5BSB4/fqwS9+TJEwBAQECAPs0mCEIDJBomTFJSEjw8PAAAUqkU9vb2yM/PR05Ojkra5OTkGrGhvBO8Knb06tWr5Fzqzg8Affr00afZBEFogETDhHn27FmJPwMAwsLCAJQ2DwnIZLIa632kbiR4Ze3o0aMHgoKCEB0dreQgl8vl2LZtG3x8fBAeHl4j9hMEoQyJhgkjOIkFPvnkE7i4uGDmzJk4dOgQcnJycO3aNUycOBENGjSoERvUjQSvrB1mZmb4/vvvkZaWhokTJ0Imk+Hp06eYOnUqbt++jXXr1sHKyqpG7CcIQhkSDROGMabUq8jPzw9nzpxB+/btMWLECHh4eGDy5MmYN28e/P391Z4jJiamZNzEkydPIJfLS/7WZdlYdSPBq2JHx44dcfr0aWRmZiIwMBCNGzfG7du3S0a8EwRRO1CXWxOnfG0jICAAu3bt0vn4QYMGqZxDV7SNBK+sHQDQunVr7Nu3r0q2EAShH6imYcI4ODggMzNTtOvTmuAEYXqQaJgwbm5uePr0qWjXpzXBCcL0INEwYdzc3JCamqo1zbZt2yCRSHDkyBEUFBTode6pykyHXpN2EAShP0g0TBg3N7cKx1+88sorYIwpBV0c3LpQmenQa9IOgiD0B4mGCdOkSRPcu3cPcrm81q8tOMHVTWdOEITxQqJhwgQGBiI/Px8PHz6s9WsLTnBhhl2CIEwDEg0TRpiz6datW7V+bXKCE4RpQqJhwjg7O8PDwwPXr1+v9WtXZ01wgiAMFxINE6d9+/Y4d+5crV+3OmuCEwRhuJBomDgdO3bEmTNnavWa5AQnCNOFRMPE6dSpEx49elSy7kRtQE5wgjBdSDRMnPbt28PS0hInT56stWuSE5wgTBcSDRPH3t4eHTt2VFm7AgCysrJq5JrkBCcI04VEow4wYMAAHDhwAIwxyOVy7NmzBwMHDkTv3r2rfe45c+YgKioKx44dKxEhcoIThOlCU6PXAcLCwjB//ny888472L17N5KTkyGRSNCoUaNqn/vChQs4duwYAEAikcDHxwfW1ta4d+8ejh07hjZt2sDBwaHa1yEIwjCgmoYJo1AocPjwYXz88ccwMzPDxo0bkZSUBMYYFAoF8vLyqn2NwMBAWFpaAuBrdzx8+BAJCQlYtWoVevXqBScnJzRu3BhvvfVWldflIAjCcKCahgny6NEjrF+/HmvXrkVycjIsLCygUChQWFiolO7Zs2fVvpafn5/S6oAAX7tbmO+KMYYHDx6gSZMmKukIgjA+SDRMkKSkJCxbtqxEFIqKitSm05dolBejspiZmcHHxwezZs2q9rUIghAfap4yQdq1a4fo6GiYmWn/9xYXF2sUFF3RtKa3gEKhwKpVqyCVSqt1HYIgDAMSDRNl4MCBWL16dYXpquvX8Pf319jsZGlpifDwcAwcOLBa1yAIwnAg0TBh3nrrLcyePVtrjSMnJ6da17CxsYGrq6vG+K+++qpa5ycIwrAg0TBxli1bhpdffhkWFurdV7m5udW+RtOmTVX2WVhYICIiQm0cQRDGC4mGiSORSLBx40a0bdu2pGtsWfQhGs2bN1cSJYlEAjc3N7z//vvVPjdBEIYFiUYdwMrKCnv37oW3t7eKcOhDNPz8/GBubl7yN2MMK1asoLmnCMIEIdGoI7i6uuLw4cOwt7dXyuD1IRr+/v4l3W4tLS3RvXt3jBgxotrnJQjC8CDRqEM0adIEMTExMDc3L+nxVF1HOMBrGsJob4VCgW+//bba5yQIwjAh0ahjdOrUCdHR0SWioY+pRMo6u6dPn47nn3++2uckCMIwoRHhdYDsbKC4mIfsbCA4eDBmzVqGL7+cjX/+ycGFC0BGhubjGdMeDzjAzs4ZEokEPXosxOHDqimsrABr69K/7e0BCwse7O2V9xEEYbjQJ2oAKBRAejrPmDMy+O+cHODZM57JZ2fz3zk5QFYW/52bC2Rm8t95efy3QqEqEJr5PwAPsHRpHpYu1cddNAPwFoYNc6z2mdQJiY0NFx1HR8DWlv92cADs7Phve3vl38Lfzs6AkxPf2thU2zSCqPOQaOgRuRxITQVSUvhWJuO/BUEovxV+a1oLydKSZ3z29jwzLP/bx4eX4O3seAZqbs4zRqkUMDPjGSygeZ+FRRSuXr2AVq34OdT0yC2hovhly17B66+/Bk3jCAUxExBErqCAi15F+3JygPx8/qwEQb13T1lcy/5WR716pQLi5KT829mZBzc3oH59vvXwANzduUgRBMEh0agAxoCkJODJEx4ePwaSk7kYJCXxrSASqak8vYCZGc+AXFyUM6iGDZUzK3UZWe001ZijadMOejnTnDnTtcY7O+vlMjojiEh5gVa3jY/nv9PS+P+wfIcya2v+f/TwKBWU+vWBBg148PEBPD35tmwTHEGYInVaNBgDEhKA+/e5GCQkAI8e8e2TJ/x3YiJQdk4/V9fSzMPdHXj+edWSqZtbacZCs4GLg9BE5elZ+WPz8rh4lC8UCDXH1FTg5k3+biQlAWUn+XVx4YUCHx++9fYGvLz47+eeA5o0oWYywrgxedHIz+cicO+earh5U7lU6ezMP2pPTyA4GAgN5R+7sM/HhzcDEaaNjQ3QqBEPupCezt+xxMTS7b17/HdcXOk+AeE9UxcaNaLOAIRhYxKvZ3Ex/0j/+YcLwY0bPNy5wz9ogDcVeXkBvr48DBkCzJjBfzdpwpsZKphJnCDUIvhDgoM1p8nNBf79l7+n9+/zcO8esG8f/y0Ml7Gw4MIRGAgEBQHNmgHNm/Pg4lIrt0MQWjEq0Sgu5qJw5YqyQNy5w5sIJBLeBBAYCHTtCkycyAXB15fvpyUdCLGwteWioklYkpNLhUSoBR87BqxdWyoo9evz4wMDuYgEBQGtW/OmUIKoLQxWNIqKuIMyNrY0XLrE25stLXlTUVAQMHgwF4agIJT0AiIIY8PdnYcOavolpKcD16/zgpKwPXSIiwvAm07btuWCEhTEfwcFkT+NqBkMQjQUCuDaNeDECeDsWS4ON2/yLqwODlwM2rUD3nyT/w4K0t79kyBMCWdnXnPu2lV5f3Iy/1aE8OuvwOef8w4eLi5Amzb8u+nShYfa7sFGmCaiiMazZ8D588DJk8CpUzxkZnKB6NSJ+xsWLuRVbz8/KjERhDrc3YH+/XkQyM7mzndBSH7/HfjsM/4NBQVx4enSBejWjTfZEkRlqRXRUCh489L+/cAffwAXLnAfhJcXf3k//phvW7TgA9QIgqga9vb8W+rWrXTf06e8YCYU0jZs4N+ftzfQqxcQFgb068e7kxNERdSYaKSlAQcPcqE4cIBXpb29+Qv6zju8xNO4cU1dnSAIAVdXXnsfMoT/Xbamf/gwMH48L9i98AIQHs6/0datqYZPqEfCWNkxzNUjLQ3Yvh34+Wfg9Gn+0nXtCgwYwF/EkBB9XYkgCH2RlcUd60IB78kT3gV9+HBg7FjeZFyXBWTVqlVYuHAhUlJSxDbFEEitdk2joID3Nf/xR761tOQv24wZfHCcY/XnryMIogZxcABeeokHxoDLl/m3/PPPwOrVgL8/MGYMFxB/f7GtJcSmysPZ4uOBadP4iOkRI3hf8nXr+FQLmzfzF5AEgyCMC4mE91CMjASuXuXO9CFDgO++AwICuBN9yxblqVOIukWlRePvv/lL1Lw5r86+/z7w8CGv3r72mrjjJIqKivDVV1+hbdu2sLe3h7u7O8LCwrBnzx5oa4WTy+WYN28emjZtCisrK4SFhSnF29nZQSKRqA1WVlYICQnBypUrla7RokULlbSvvPJKSXxoaKhSXLt27ap0THkePHiAIUOGIKvc1LlxcXEIDw+Hk5MT7O3tERoailOnTlX6GQPAvn37EBAQAAst811ERERg+/btGuMnTpwIqVQKX19fzJgxA/n5+TpdW9P96WqXNrp27arx/zxz5kyltGvWrNGYVgjl36PK2FnR86stWrUCvvySz8O2bx8fH/X663zA7Oefq07uSJSSnp6ONWvWoHfv3nBxcYG1tTWaNm2KMWPG4PLly2KbV3WYjly/ztjgwYwBjHXuzNiuXYzJ5boeXfPk5OSwrl27spCQEPbXX3+xvLw89uDBAzZixAgGgF29elXjsWvXrmUA2KJFi1h6erraNJcuXWIA2NChQ0v2FRQUsEuXLrEuXbowAGzOnDlKx8hkMubq6soAsC1btqicc+/evaxp06YsNze3WseUtdHNzY2tWLFCaf/Zs2eZtbU1GzVqFEtISGApKSnszTffZBYWFuyPP/7Q+FzKc+fOHTZ48GAWEhLCHBwcmLm5uda0vr6+7IMPPtCYJisri61Zs4YBYEuWLKnw+prurzJ2aUP4P6oLM2bMUEq7evVqjWmFsGjRoirbqcvzE4uHDxmbO5cxe3vGPDwYW76csaIisa2qOVauXMnc3Nwqfdwbb7zBLCws2Ndff80SExNZbm4uO378OAsKCmLm5uZs165dNWBtjZNSoWg8e8bYvHmMWVoy1ro1Y/v21YZdleedd95hDg4OTCaTKe3PyclhUqlUq2iMHj2aAWBZWVka06gTDYGHDx8yMzMzZmFhwZ4+faoU99NPPzEAzNXVVcm2tLQ05uPjw06dOqVyvqock5mZyby9vdnkyZOV9svlchYcHMw8PT1ZXl5eyf7i4mIWGBjIfHx8WH5+vsb7Lsvo0aPZp59+yoqKipiXl1eFmXNcXByTSCRs+/btWtPZ2Niwfv36aU2j6f6qYpcmunTpws6fP69T2tWrV6t9FxhjLD4+nkmlUpaYmFgtO3V9fmKRnMzY7NmMSaWMtWzJ2NmzYltUM1RHNN566y2V/XFxcQwAa9q0qT7Mq220i8bdu4y1acOYoyNjK1YwVlxcW3ZVDplMxszNzdk777xTpeP79etX4QesTTQYY8zLy4sBYEePHlWJGzJkCAPAXnrppZJ9Y8aMYXPnztV4vcoeM3/+fGZhYcGePHmitP/PP/9kANi0adNUjvnoo48YABYdHa3RjrKUFR1dM+eRI0cyb29vVqSlKNqwYUPWtm1brefRdH9VtUsdlRGNQ4cOsS+++EJt3LRp09ioUaP0Yqcuz09sbt1iLDSUFyy/+IIxhUJsi/RLVUVDG9bW1szMzIwpjO9haRaNS5cYq1+fsVatGLt9uzZtqjzfffcdA8B++umnKh3fp0+faotGw4YNGQB2+vRplbiEhATm7OzMALBffvmF7dq1iwUHB2st4VfmGIVCwTw8PFiXLl1U4hYsWMAAsE2bNqnExcTEMABVEltdM72tW7cyAGz37t1az9WyZUuN8drur6p2qaMyoqGJrKws5uDgwP766y+t6fT5/AwBhYKxr7/mwvHmm4bVdF1d9C0aOTk5DAALCQnR2zlrkRS1jvBHj4C+ffm4ipMnDb+b3cWLFwEAzs7OmD17Nnx8fFCvXj0899xzmD59OtLS0mr0+g8fPkRiYiIcHBwQrGYaU09PT3z11VcAgKlTp+Ldd9/Fpk2bINUy7W5ljrl8+TKSkpLQsmVLlbibN28CALy9vVXivLy8AADx8fE63GXVaNWqFQDgjz/+qPI5tN2fvtm8eTNatWoFW1tbODo6olu3bti6davOx2/cuBGNGjVC9+7d9WKPPp5fbSCR8G720dG8+31kpNgW1Qw3b97EsGHD4OjoCBsbG7zwwguIiYlR6qQyadIkref45ZdfAADz58+vDZP1jlrRmDiRr0L3++/GsT5y4n8r3Lz++utISkrCX3/9heTkZCxevBgbNmxAp06dkJmZqfH4wsJCrRm4JoqKihAXF4dXX30VlpaW+Pbbb+GgYZWm8ePHY+DAgUhOToa/vz/atm1b4fl1PebatWsA1AtDRkYGAMBWzT/S7r+ubunCoiM1gCBMgo3qkEqlKCq7PGI5tN2fvklPT8eGDRuQnJyMc+fOwdfXF2PGjMH06dqXswUAxhhWrlyJKVOm6M0eXZ6fITFkCJ/Ofdky4Phxsa3RL3fu3EGnTp1w4cIFREdHIzk5GRs3bsQ333yDK1euQCqVgjGG9evXazxHUlISIiIiMGnSJLz88su1aL0eKV/3OHeO95A6caL26z1VpX///gwA8/X1VWn7/fjjjxkAtmDBAo3HP/fccywgIEDrNYTmKXVh+PDh7M6dOxXaOWPGjJJjdG1u0OWYzz//nAFgK1euVInr27cvA8DOqvFSxsfHMwAV+hPUUZlmIIlEwvz9/TXGd+3alTk6Ompst9d2f9WxS1deeOEFjc+wLHv37mX29vYsOzu7wnPq8/kZIn36MDZwoNhW6AeheWrkyJFqfYDJycnMxsaGSaVSredJTU1lrVq1YqNGjWLFhuogrhjV5qkjR/icUOWnYTZkhFJ0aGioSt/3wYMHA1BfvU9LS8OyZcvw4MEDnUuHQ4cOBWMMjDE8fvwYo0aNwq5du/Ddd99pPe7EiRP49ddfERUVBQB4++23Kyzh63qMMMbBUs188U5OTgCAXDUd6oV9QpqawsLCAs+ePdMYP3nyZGRlZeHDDz9EamqqSry2+6sNRowYAQDYs2eP1nTLly/Ha6+9VlKD0xcVPT9DZNw44OhRPqeVqXDgwAEAQP+y0woDqF+/Ppo1a6b12NzcXPTv3x9BQUH46aefYG7EM7OqiEZqKm+aMiYa/zfzoauaaTrd3d0BQGXemAkTJsDV1RURERGYO3euTs0P5fHy8sIPP/wAPz8/LFu2DBcuXFCbLicnBxMmTMB3332HWbNmISwsDDKZDDNmzNB47socY2VlBQBqm3iEl/nx48cqcU+ePAEABAQEVHyz1aC4uBjW1tYa48eOHYslS5Zg2bJlqF+/PgYMGKAUr+3+agNPT08AQHJyssY08fHxOHjwoF6bpgQqen6GSIMGQH5+6aqDxg5jDNnZ2bCyslJbKHDWslhJcXExRo4cCS8vL2zatMmoBQNQIxp+fsCtW/wfbix0/a9aJPg2yiJ86B7llPCHH35AZmYmtm3bhqioKEyePLlK17ayssInn3wCxhgiIiLUppk9ezZCQ0NLMsO1a9fCwcEBmzdvRkxMTLWPETI1dX6bXr16AQBiY2NV4oR9ffr00eVWq0RWVhYYYyU2qmP+/PmIjIzE6tWrkZGRUVKiE9B2f7VBQkICgNICiDqWL1+O7t27IygoSK/X1uX5GSJxcXy9Dw0uPqNDIpHA3t4e+fn5yFGjhNoKFJMnT0ZBQQF27Nih1BLi7++Ps2fP1oi9NUr5BiuZjA/WKTfo1qDJz89nXl5ezMPDgz179kwpTvBpLF26VOPx7du3Z87Ozlqvoa3LrUKhYK1bt2YA2MGDB5XiDhw4wHx9fVUGDgrdhBs2bKgyCr2yxwi2TZkyRcU2uVzOgoKCWMOGDZWeTXFxMWvevDnz8fFReWa6oGub/D///FNht95mzZoxX19fjfHa7q+qdpVn3bp1rE2bNir7FQoFa9u2rVafRmZmJrO3t2c7duzQ+Xr6fH6GRnY2Y889x9jMmWJboh8En8bLL79c0gW+LImJiUwqlar1aSxcuJB16NBBrZ/Lz8+PnTlzpsbsriHUj9P44APGbGwYi42tbXuqzv79+5mFhQUbOnQoi4+PZ+np6ezHH39ktra2rEOHDkoDq8qjj3Eae/fuZQBYmzZtSgbspKenMx8fH/bnn3+qPSY0NJQBYBMmTCjZV5VjFAoFc3d31ziO4cyZM8zKyoq98sorLDExkaWmprLJkyczCwsLduDAAZX0Y8aMYQDYvXv31J6PscqPM9A2ZYIu4zS03V9l7Lp//z4zMzNjAFhsmRd83bp1JcJ0+/Zt9uzZM3bz5s2SZ6FucKTAV199xTw9PSs1AE+fz8+QkMsZe/VVxtzdGUtIENsa/SCIxp07d5iLiwvz8vJiBw8eZNnZ2ezq1atswIAB7LnnnlMRjY0bN1Y41YzJiEZREWP9+jHm4sKYMd3T6dOnWf/+/ZmjoyOrV68ea9asGfvoo4+0CgZjPCPW9gHb2tqq/LPVjfjt2rWrxpejrNikp6dX+DLpesxXX33FGGMsMjJS44hpxhi7ePEiCwsLYw4ODszOzo717t2bnTx5Um3a3r17Mzs7O5UeHnv27NFo67p169Sea+TIkczLy4sVFhZqfL5eXl6sVatWGuMrur/K2CWIhkQiYVeuXCnZn5+fz3755Rc2fPhw5ufnx6RSKXN0dGQ9e/ZkW7du1WiXQqFg/v7+7MMPP9Rqf2XtFNDl+RkKBQWMjR/PmJUVY4cOiW2N/ig7uO/WrVts2LBhzMHBgdnY2LDOnTuzv/76i/Xp00dFNMLDw+uOaDDG55waNIixevUY++Yb05saoCzh4eFMIpGIbUa1yMjIYF5eXmrnZqoM6enpzNramk2aNKnaNglzJ/38889a03l4eLCOHTtqTaOv+zMmdH1+hsC9e4x16MCYnR1jaipS1PWJAAAgAElEQVSvRo0uI8LViYaJon5EOABYWQG//QYsWADMns3XHL5yRat7xGjx9vYGYwxJSUlim1JlHB0dsWfPHkRHR2PlypVVOgdjDNOnT4eDgwMWL15cLXvu3buHF198EfPmzVOa3r08RUVFSEtLq3Dgnj7uz5jQ9fmJTWEhsHQp0KIFX0b2wgWgXI9UwsTQup6GmRnwwQf8RVAo+LrBL78M3L5dW+bVDkIPpaVLl+Lp06ciW1N1WrdujQsXLmD//v1q15uoiKSkJNy7dw9HjhxBgwYNqmXL2rVrsWTJEixZskRjmszMTERFRaGoqEilm606qnt/xoQuz09MFArgl1+AoCBg0SJgzhzg3DkgMFBsy4gaR9c6iVzO2NatjAUGMmZhwdjLL5vWVMifffYZa968OZNKpWzAgAFim2PyjB8/nllaWjJ/f3+2YMECYx4hW6fIymIsKoqxxo1LJyd8+FBsq2oWbc1TP//8s4qf4o033qhlC2uVFAljWpa0U0NxMS9hREXxGkibNnz05+jRxjcokCCIilEogGPH+DLOO3cCjPH56WbOBJo0Edu6mmfVqlVYuHChygDhOkpqpZd7tbDgAnH+PHDiBF8O8qOPAG9vIDwc2LoVyMurAVMJgqhVrl0DIiKA554D+vThfy9ezJd3Xr68bggGoUrVFlP+j65defj2Wz4j7pYtwIQJ3Inerx8QFsZDw4Z6spYgiBqjuBg4dQrYvx/Yu5eLROPGwPjxwNixQAXTKxF1hGqJhoC1NTBqFA8pKXxO/ZgYYNo0Ph1Jq1alAtKpE2DkU68QhMkgk3GR2L8fOHQIyMgAAgKAgQOBVat4oVAiEdtKwpDQi2iUpX594J13eHj2jLeF7tsHbN8OfPIJ4OTEX8QuXfi2XTteMyEIouZ5+JA3K58+zbfXrvHvr0cP3gtq4EA+/xxBaELvolEWa+vSGgYAxMcDf/zBVwNcsQKYNw+QSrlwCELSuTOgZrJagiAqiVzOReHkSd7sdOIE8PgxYGnJv7l+/fgYi549ARsbsa0ljIUaFY3yBATwMG0a/zshgb/MJ08Chw/z1b4UCsDTE2jbtjQEB5PTjSC0UVzMZ6eOjS0NcXFAbi5gZwd07Ai88UZp4czIZlonDIhaFY3yNGwIjBzJAwA8fQr8/Tdw8SJw6RJfa/h//+NxHh58cGGbNtxH0qwZF6AqrNJKEEaNTAbcuAFcv176rVy/DhQV8eWZW7bk38rEiUD79ny0tlml+0kShHpEFY3yuLryNtWBA0v3ZWTwj+LSJf6B7N4NfPYZr3qbmwO+vkDz5lxEmjXjI1SbNeO+E4IwVuRy4P59Lg43bvBaxD//ADdv8m8CAFxcuDiEhvIR2a1b84IUdTQhahKDEg11ODkBvXrxIFBYyD+imzd5uHGDN2+tXFk6RqRBA/4B+fry0KRJ6Za6ABOGQF4eF4Z795S3d+/yqXoKC3k6Hx9eEGrfnnd/DQzkBaVqzvRCEFXC4EVDHfXqAc8/z0NZGAP+/be0VHb3Lv8Qz57l+wsKeDorK1Ux8fYGvLx4aNiQX4MgqsPTp9xv9+gRkJjI38Gy4iCTlaZ1dy99F4cNKxWGwEDA3l60WyAIFYxSNDQhkZSKQfn57xgDnjzhH2vZDzcuDti1i3/Acnlpeg8P7pAXxKRhQ17i8/Tkv93cePdiS8vavUdCfLKy+PuSksJFoawwCNvHj5WXTLa35yOrfX2BF17gY5rKFlpsbcW7H4KoDCYlGtqQSLgAeHvzad7LI5cDSUnKH39CAhea+Hg+3uTRI9UpUlxceClREJEGDfhWCA0aAM7OvJnNycl01kw2FYqKuI8gPZ2HlBQgNRVITubvg/C3IBIpKaU1VoA7mD08SgsWISG8wFK+sGFnJ949EoQ+qTOiURHm5vwDr8jfkZnJRSU1lWcgQmYiZDQ3bgDHj5fGKxSq1xEExMmJC0pZURH22drybpFOTnxrbc33W1vz5jVn55p7FsZAfj4fPJqezrf5+aW/nz3jQpCTw7eCKAi/y/6dm6t6bltbLvgeHqXCHxLCCwdCYUCI8/Cg2iZRtyDRqCSOjjzogkLBxUPIoMpnXGVLuP/+q7wvL6/iiR8FMXFy4oOzpFI+oaTQBm5nxzO0ivYJ2Npq9uWYm2uuJRUV8QxaE1lZyk1/ZdNnZ/MxBhXty8gAsrKuoLg4CBkZFtA2N7NEwp+JnZ2yELu48OYg4e/yQu3kxIWABroRhGZINGoQMzNeOnV3r/o5MjJKS8/lS9J5efx3ZiYvMRcW8iCUnjMzuXDl5fFaD1CagZdNJ5CertkOXrI/CqAYQD+VeG01H6F2JFBWgAShKruvQQO+z8ysVKBtbPLx5ZcD4OPTElFRO+DiYg8bG801MYIgagYSDQNHKAkbAqNGrYVcLkd0tKpo1DxWGDbsAMLDwxEV1QUxMTFo1KiRCHYQRN2GxokSOiOTyaq9DGx1CAkJwdmzZ2FmZoZOnTrh4sWLotlCEHUVEg1CZ2QyGTxEXp7Ry8sLJ06cQEhICHr06IG9e/eKag9B1DVINAidEbumIWBvb489e/bg1VdfxdChQ7F69WqxTSKIOgP5NAidePbsGbKysgxCNADAwsICa9asgaenJ6ZOnYqbN2/iq6++ghnNzEcQNQqJBqETiYmJAABPT0+RLSlFIpHgo48+gq+vL9566y08ffoUGzduhCUNnCCIGoOKZYROCKJhKDWNsowfPx579+7Fb7/9hqFDhyJX3Yg9giD0AokGoRMymQwSiQTu1Rl0UoOEhobizz//xIULF9C7d2+kpqaKbRJBmCQkGoROyGQyuLq6op4BT//brl07nDlzBk+fPkX37t3x6NEjsU0iCJODRIPQiaSkJINsmiqPn58fTpw4AUtLS3Tr1g23bt0S2ySCMClINAidMJTutrrg6emJY8eOwdvbG507d8bZs2fFNokgTAYSDUInjEk0AMDZ2RkHDx5Ehw4dEBoaioMHD4ptEkGYBCQahE4Ym2gAgI2NTUmPqiFDhuDXX38V2ySCMHpINAidMIQpRKqCpaUlNm/ejEmTJmHUqFHYtm2b2CYRhFFDg/uICmGMGY0jXB1mZmb49ttv4eTkhLFjxyI/Px8TJkwQ2yyCMEpINIgKSUtLQ2FhodGKhsDHH38Mc3NzvP7668jNzcXUqVPFNokgjA4SDaJCZDIZAMMcDV5Z/ve//8HGxgbTpk2DXC7H9OnTxTaJIIwKEg2iQkxJNADg/fffh5mZGWbOnAm5XI5Zs2aJbRJBGA0kGkSFyGQyWFpawsXFRWxT9MacOXNga2uLd999Fzk5OViwYIHYJhGEUUCiQVRIYmIiGjRoYHLTjk+ZMgXm5uaYMmUKcnNzsXTpUrFNIgiDh0SDqBBj7jlVEZMnT4aZmRnefvtt1KtXD4sWLRLbJIIwaEg0iAoxxoF9leHNN9+EhYUFJk2aBGtra8ybN09skwjCYCHRICpEJpPB19dXbDNqlIkTJ4IxhkmTJsHS0hLvvfee2CYRhEFCokFUiEwmQ6dOncQ2o8Z5/fXXkZ2djVmzZsHOzg5vv/222CYRhMFhWp5Nokao7hQicXFxCA8Ph5OTE+zt7REaGopTp07p0UL9MWPGDCxcuBBTp07Fli1bxDaHIAwOEg1CK0VFRUhLS6uyT+Pvv/9G586dYW9vjxs3buD+/fto0qQJevbsabAzzy5cuBBz587FhAkTsH37drHNIQiDgpqnCK0kJSVBoVBUSTQUCgXeeOMNODk5YePGjbC2tgYArF69GsePH8ekSZNw+/ZtSKVSfZtdbT799FMUFRVh3LhxsLW1xaBBg8Q2iSAMAqppEFqpzmjw48eP4/r16xgxYkSJYACAubk5Ro8ejUePHiEmJkZvtuqbZcuWYeLEiRgxYgQOHDggtjkEYRCQaBBaqY5oHD16FABfu7s8wr4jR45Uw7qaRSKRYNWqVXjxxRcxcuRInD59WmyTCEJ0SDQIrchkMtjb28PW1hYAcPPmTQwbNgyOjo6wsbHBCy+8gJiYGISGhkIikUAikWDSpEklaQHA29tb5bxeXl4AgPj4+Fq6k6phbm6OH3/8EaGhoRg0aBD++ecfsU0iCFEhnwahlbID++7cuYNOnTrB1tYW0dHR6NSpEx48eICZM2fiypUrkEqlyM/PLzk2IyMDAEoEpyx2dnYAgPT09Fq4i+phYWGB7du3IywsDP369cOZM2fg4+MjtlkEIQpU0yC0UlY0IiMjkZGRgW+++QZ9+/aFnZ0dgoODsXXrVuTm5lbqvIwxALwJyBioV68efv31V7i4uGDgwIElgkgQdQ0SDUIrMpkMnp6eAFDiDO7fv79Smvr166NZs2Yqxzo5OQGAWkER9glpjAFHR0fs27cPGRkZePHFF1FYWCi2SQRR65BoEFoRahoFBQXIzs6GlZVVSdNSWZydnVX2CULy+PFjlbgnT54AAAICAvRscc3i7e2Nffv24eLFiyVTjxBEXYJEg9CKMBpcKpXC3t4e+fn5yMnJUUmXnJyssq9Xr14AgNjYWJU4YV+fPn30bHHN8/zzz+PXX39FdHQ0PvzwQ7HNIYhahUSD0EpZn0ZYWBgAqIxZkMlkantB9ejRA0FBQYiOjlZykMvlcmzbtg0+Pj4IDw+vQetrjt69e2PDhg1YsmQJVq5cKbY5BFFrkGgQGsnOzkZubm6JaHzyySdwcXHBzJkzcejQIeTk5ODatWuYOHGi2nEcZmZm+P7775GWloaJEydCJpPh6dOnmDp1Km7fvo1169bBysqqtm9Lb4wZMwYLFy7EjBkzsHv3brHNIYhagUSD0Ej5gX1+fn44c+YM2rdvjxEjRsDDwwOTJ0/GvHnz4O/vr/YcHTt2xOnTp5GZmYnAwEA0btwYt2/fxrFjx1Qc6sbIwoULMWHCBIwdOxbnz58X2xyCqHFonAahEXWjwQMCArBr165Knad169bYt2+fXm0zJNasWYOEhAQMHToU58+fLxm4SBCmCNU0CI3IZDKYmZnB3d1dbFMMGmHwn6urKwYPHoy8vDyxTSKIGoNEg9CITCaDm5sbLCyoQloR9vb2+P333/Ho0SOMHz+euuISJguJBqGRpKSkCicq3LZtGyQSCY4cOYKCggKluafqGr6+vti2bRt2796NTz/9VGxzCKJGINEgNFK2u60mXnnlFTDGlML69etryULDo0+fPoiKisKCBQvw+++/i20OQegdEg1CI7qIBqHKtGnTMHHiRLz22mu4ffu22OYQhF4h0SA0kpiYSKJRRVauXImAgAC8+OKLlZ7MkSAMGRINQiNU06g6UqkUO3fuRFJSUp318RCmCYkGoRaFQoGUlBQSjWrg4+ODn3/+Gb/88guWL18utjkEoRdINAi1pKamoqioiESjmvTp0wf/+9//8N577+Hs2bNim0MQ1YZEg1BLddYGJ5SJjIxEaGgoRo8eTYs3EUYPiQahFhIN/SGRSLBp0yYUFhaSf4Mwekg0CLXIZDJIpVKjWlnPkKlfvz62bt2K3bt3Y82aNWKbQxBVhkSDUIvQc8pY1vA2Bnr06IHIyEjMmjULcXFxYptDEFWCRIPAjRs38Mcff+Dq1atISkoCY0ynKUSIyrNw4UK0b98eY8eOVVqYiiCMBZqJjkB8fDyGDRtW8re5uTmsra1hY2ODsLAweHp6wsvLC+7u7ujSpQvatGkjorXGjbm5ObZu3YqQkBBERkYiKipKbJMIolKQaBDo1q0bJBJJycyscrkcOTk5yMnJwYEDB2BhYQGJRIKioiIcPnxYZGuNH29vb3z11Vd4/fXXMWjQIPTu3VtskwhCZ6h5ioCLiwsCAwM1xhcXF0Mul6Nly5bo06dPLVpmuowfPx4vvfQSXnvtNaSnp4ttDkHoDIkGAQDo168f6tWrpzGeMYbIyMhatMj0WbVqFeRyOWbMmCG2KQShMyQaBADes6eoqEhjvJeXF1588cVatMj0cXNzw7p167B582bs2bNHbHMIQidINAgAXDQ0YW5ujoiICFrBrwYYNGgQxowZg7fffptGixNGAYkGAQBwdXVF06ZN1cbZ2tpiwoQJtWtQHeKbb75BcXEx5s+fL7YpBFEhJBpECX379lXxa1haWmLWrFmwtbUVySrTx9XVFVFRUVizZg1OnjwptjkEoRUSDaIEdX4NMzMzTJ06VSSL6g5jxoxB//798eabb6KgoEBscwhCIyQaRAnl/RqWlpZ44403UL9+fZEsqlusWbMGjx8/xueffy62KQShERINogR3d3c0adKk5G+5XI5Zs2aJaFHdolGjRpg/fz4+/fRT/Pvvv2KbQxBqIdEglBDGa1haWmL48OHw9/cX26Q6xf/93/+hUaNGeO+998Q2hSDUQqJBKNGjRw8UFhaiqKgI77//vtjm1Dnq1auHFStWYOfOnThw4IDY5hCECtTx3kTJygIKCoDsbCA3FygsBIqKgJwc5XRyOU9behz3awQHd0NmZnuUnWrK2hqwsgLMzQEHB8DGBpBKAWfnWrihOkTfvn0xfPhwTJ8+HVevXoVUKhXbJIIogUTDgElPBxISgORkICUFSEvjIT299LcQ8vL4/oIC/rvqNAAQiOvX56FvX92Pkkq5iAhi4uKiHJydlf/29AQ8PHggVImKikJQUBDWrl2L6dOni20OQZRAoiEST58C9+8D9+4BDx4AT54AiYlcJBIS+O9nz0rTSySqGa+LC+Dtzbc2NjxeyLzt7flvB4fSGoJEAqhbiM/JiccJfPvtuxg7dgD+m/S2hOxsoLi4tMaSm8tFKiOjVKyysvh+QdhSU4H4eGWBk8tLz1mvHhcOb+/SbYMGQOPGgK8vD56een30RkHjxo0xbdo0LF68GBMmTICDg4PYJhEEAEDCWPmsgdAXqanA9evAP/8Ad+9ygRCEQmgSMjfnmaKPD88shUzTy4vv9/IC3N2B2uz1yhir0RX7MjO5MMpkXCyFbWIi3yYkAI8f8yY1gIuery/QpAnf+vkBQUE8eHnVmJmik5GRAT8/P0yZMgWLFy8W25w6y6pVq7Bw4UKkpKSIbYohkEo1DT2QnQ1cusTF4do14MYNvk1O5vFOToC/P8/w+vcvLUE3aQI0asRL24ZETS/x6ujIQ/PmmtPI5Vw47t8vFdr794HYWGDbNt5cB/BnGxQEBAeXblu3BtzcavQWagUnJydERERg4cKFmDx5Mry9vcU2iSCoplFZiop4c0tsLHDqFHDyJHDzJqBQ8Kagpk1VMzFfX+XmH6L6pKdzIRFqcsL23j0e7+kJtG1bGjp1Mk4hyc/PR2BgIMLCwrBmzRqxzamTUE1DiVQSjQpISwNOnACOHQP++gu4epW367u4AO3alYa2bXmtgRCX5GQu6BculIaEBC7agYFA9+5Ajx5Az55Aw4ZiW6sbGzduxJtvvomrV6+iubbqGVEjkGgoQaJRnpwc4MgR4M8/uUhcucL3h4TwzKZzZy4SZQZOEwZOQgIXj7//5v/Tc+d4jbFp01IB6devdv1GlUFYNbFFixbYtm2b2ObUOUg0lCDRAICHD4EDB4A9e4BDh3hPoCZNgNBQHnr3BlxdxbaS0Bd5ecDFi7x58fBhXpMsKuK+kEGDgMGDgTZtDKtJcceOHRg9ejQuX76MFi1aiG1OnYJEQ4m6Kxp37gBbtgC7dwOXL/Muqv368UwjPNxwS52E/snJAf74A4iJAfbt401cvr7A0KHA2LG86VFsFAoFWrZsiZYtW2LLli1im1OnINFQIrVOTSOSng6sXQt07QoEBADffQd06wYcPMi7x0ZHAxMmkGDUNezsgJdeAjZu5N1+T58GXnmFC0i7drwzw2ef8d5cYmFmZoZ58+Zh27ZtuHXrlniGEHWeOiEa587xTMDTE/i//wOee45nCI8eAStWAH37Gl63V0IczMx4T6tPPgFu3QLOnOE+j88/5+9N//783RGjfj5q1Cg0bdoUn376ae1fnCD+w2RFQ6HgTU/dugEdOvDBdatX84FkP/0EDBjAB9YRhDY6dgRWruQ1kJ07uZ9j0CCgRQtg/Xru/6otzM3NERkZiS1btuD27du1d2GCKIPJiQZjwI4dQLNmvMnBxYV3lz1/Hpg4kfsuCKKy1KsHDBvGO0xcucILIu++y2sfy5dzR3pt8Oqrr6JJkya0UBMhGiYlGhcu8H74o0fzrrE3bgC//ca7VRKEvmjRAtiwAfj3X+C114D33/9/9u48Lqrq/QP4Z2BYZVNWBVTcFVxAXEANBRIMNTUtTUstlTJNf2blllnf6OuW5lKiueaGxdcyN8Ak1ywRcyMVUUNlB9n3GZ7fH6cBxplBlhnuDJz363VfwL3n3vtcGO5z7z3nnsOaZB8/rvl96+vrY+HChdi7dy9SU1M1v0OOe0aTSBr5+cDbb7OrP5GI1WHs3s0quzlOUxwcWF3H338DPXuyprojRrD+szRp6tSpsLKywrfffqvZHXGcEjqfNK5dYy1cjh1jfRKdO6fZJpKhoaEQiUQ1TiNGjFC5vlQqxeLFi9G5c2cYGxvXWFYmLCysctvGxsb1invt2rWV2xCiD6PExESMHj0aedUH7wBw7do1BAUFwcrKCubm5vD398fFixcV1l+0aBEOHTqkcvvTp0+HkZERXFxcMG/ePJSUlKj9GFRxcWGPRM+dYz0Wu7sDJ09qbn9GRkZ455138M0336CwsFBzO1LixIkT6NKlC8Ri3m1ds0U6bNs2ImNjomHDiJKTG2efW7ZsIQA1Tp9//rnK9bdu3VpZJjs7u0779vPzIyMjowbF37t3b3J0dGzQNurqr7/+IhsbG9q0aZPc/D/++INMTEzotddeo+TkZMrIyKCZM2eSWCymyMhIubIJCQnk4uJCy5YtU7mfvLw8Cg0NJQAUEhKikWN5noICojffJBKJiBYtIpJKNbOf9PR0MjExoW+//VYzO3hGQkICjRo1inr16kUWFhakr6/fKPvVBt988w3Z2NgIHYa2yNDZpPHll+wfc/lyIomk8fa7ZcsWevnll5Uui4+PJyMjI0pJSVG5/qRJkwgA5eXl1Xnfupg0cnNzycnJiYKDg+XmS6VScnV1pdatW1NRUVHlfIlEQl27diVnZ2cqKSmRW+fatWskEono0KFDNe7T1NSUhg8frr6DqIddu4iMjIimTtXc53PmzJnUuXNnkmoqM1UzadIk+u9//0vl5eXk6OjIk0bzlaGTj6d27ACWLmVNIT/7rHGbznbq1AlDhgxRumzTpk0YM2YMHBwcVK6flZUFfX19mDeTZlyrV69Gamoqli9fLjf/3LlziIuLw/jx42FiYlI5X19fH5MmTcLjx49x7NgxuXV69+6N8ePH44MPPoBEIlG5TysrK2RlZan3QOpo2jTWCOPQIeCjjzSzjwULFiAhIQG//PKLZnZQzY4dO7Bo0SL+WIrTvTqNW7eA2bNZ0nj33cbfv7+/Pz744AOF+fn5+dizZw9mz55d4/rS6sPWNXFEhO3bt2PAgAFo80yXstHR0QAAT09PhfVk806fPq2wbOzYsXjy5AmO19BUSSQS1ZhUGktAAGtltX498NNP6t9+t27dMGLECGzevFn9G39G9cTONW86lzTefZdVdK9YIXQk8nbt2oW2bdvihRdeaPC27ty5gzFjxsDS0hItWrTAkCFDcOHCBZXlMzIy8P7776N9+/YwNDSEra0txo0bh2vXrtVqfxKJBIcOHcKLL74IBwcHmJiYoGfPntiwYQMqKioAsFHknq3w/+KLLyrXrz5//PjxAIDr168jLS0NvXv3VnqMAJRWyjv+OxxffHy8wrI+ffoAACIjI2t1bEKbNIm9HzRnjvzwveoye/ZsnD59GnFxcXVar/pnzNTUFP3798exY8fg7+9f+XecMWOG+gPmdJ/QD8jq4uJFIoB91SYVFRXUpUuXWlVKDhkyhExNTVUuv3fvHllZWZGjoyNFRUVRfn4+3bhxg4YPH07t27dXqNNITk6mdu3akb29PR0/fpzy8/Pp1q1b5OPjQ8bGxvT777/LlVdWp3H06FECQF9++SU9ffqUMjIyaOPGjaSnp0cLFy6UKxsQEEB6enqUkJCgELuXlxft37+/8ue9e/dWbvdZL774IgGgP/74Q+nvAAB5eHgoLMvNzSUANGTIECW/PaZDhw7Uo0cPlcsbW2oqkYkJ0dat6t+2VColFxcXmjdvXq3XUfYZu3XrFvn7+5Otre1z6814nUazplsV4QsXEmnRuaDS8ePHydzcnPLz859btl27dtSlSxeVyydMmEAAKDw8XG5+UlISGRkZKfxDT506lQDInayJiFJSUsjIyIj69u0rN19V0hg6dKhCLFOmTCEDAwPKzc2tnBcZGUkAaPbs2XJlL1y4QI6OjlRWVlY5b/Xq1QSAvvnmG4Vt15Q04uPjCYBC7DIikYg6deqkdBkR0eDBg8nS0pLKy8tVlmlsr75KFBiomW3/97//JSsrKyooKKhVeVWfsfT0dDI1NeVJ4xk8acjRrYrwGzdYX0DaZuPGjXjzzTdhZmamsszTp0+xZs0aJCYm1ljvERERAQAICAiQm9+mTRt0UfK24s8//ww9PT2MHDlSbr6DgwNcXV0RGxuLJ8/pnnXkyJH47bffFOb37t0b5eXlco8+hg8fjp49e2L37t1ylc1r1qzB3LlzYWBgUDlP9q5E9XkyVlZWAKD0PQPZPFmZZ4nFYhTX8KwnODgYeXl5WL58OTIzM1WWa0wDB1YN6KVuM2bMQElJSa0HaFL1GbO1tUW3bt3UHh/XtOhU0igo0L6+o+Lj4xEVFVVjIpg2bRqsra2xaNEifPTRR3j//feVlistLUV+fj6MjY2VJiA7OzuF8rm5uaioqIClpaVCncPVq1cB4Lmd2+Xm5mL58uXo2bMnWrZsWbn+hx9+CAAoKiqSKz9//nwUFRVVvpEcHx+P6OhozJo1S66c7EXEcp2mX1wAACAASURBVCUdM8lOTsoSWtK/r1QrS5IAq0OpqWJ2ypQpCAkJwZo1a2Bra4vAwECVZRuLpSXruUATbGxs8Morr9SqQvx5n7GWLVtqIkSuCdGppGFvr/kuGupq48aNeOGFF9CjRw+VZXbv3o3c3FyEhYVh3bp1CA4OVlrOyMgI5ubmKCkpQUFBgcLyp0+fKpS3srKCWCxGeXk5iEjpNGzYsBqPYdSoUfjPf/6DmTNnIj4+HhUVFSAirF+/HgBrBVXd5MmTYW9vj82bN6O0tBRfffUVpk6dqnDCad26NQCWlJ4liyk2NlZhmWyen5+fwrK8vDwQUeW2lVm6dCmWLFmCLVu2ICcnp/LKWkiPH7NuRzTl3XffxbVr13D58uUayz3vM5aenq6pELkmQqeSxuDBbOzuxuyOuiZ5eXn4/vvv8d577z23rIWFBSZMmAB3d3eEh4erLCfrVuTZE11mZqbSwXfGjRsHiUSitOuNVatWoW3btjU2P5VKpbh48SIcHBzw/vvvw9bWFqJ/xzlV9QjIyMgIs2fPRnp6Or766ivs378f8+bNUygnG5ZU2d2Ej48PevTogfDwcLkuP6RSKcLCwuDs7IygoCCF9WR3ITUNeXr48GG4uLhgxowZsLS0VFmuMUVEsM+vpgwaNAg9evTA7t27n1tW1WcsNTVVaYu15q60tLTe3fc0SYJVp9RDUhJ7y1YTrVDqY/369dS6des6Vbj6+fnVWImYkJBArVq1kmvZEhcXRwEBAWRnZ6dQSZmWlkYdO3akDh060IkTJygnJ4eysrIoNDSUTE1NFd6eVlYR7uvrSwBo9erVlJGRQUVFRRQdHU1t27YlAHTq1CmFODMyMsjExIREIpHKN+QrKirIzs6OBg0apHT5pUuXyNjYmCZOnEgpKSmUmZlJwcHBJBaLKSIiQuk6Bw4cIAD0008/qfwdOjo6Uu/evVUub2wXLrBWf7/9ptn9rF69miwtLeXesFdG2Wfs5s2bFBgYSO3ateMV4c8ICQmhzp07Cx2GttCt1lNERO+/T2RtTVRDTx2NoqKigjp16kTLly+v03r+/v7P/Ye7e/cujRkzhiwsLMjExIT69etHx44dIz8/v8r+rd5+++3K8llZWbRgwQLq0KEDGRgYkK2tLQ0fPlzuZL9mzRqFPrKWLl1KRCwBBAcHk7OzMxkYGJC9vT1NmzaNFi1aVFlWWUummTNnEgA6e/asymNZsmQJicViSkpKUrr86tWrNGLECLKwsCAzMzPy9fWlCxcuqNzehAkTFFppPcvR0ZH69OmjcnljKikh6tWLyM9P8/tKTU0lAwMDOnjw4HPLVv+MmZqakre3N509e1ZlVzWyZtnKpu+++04Th6M1li1bRr169RI6DG2he0kjP5+oUycib2+i4mKho6m7oKAgEolEQoehFjt37lTZLFYmJyeHHB0dFfqeqg9Z31PPOyna29vTwIEDG7y/hqqoIHrjDSJLS6L79xtnnyNHjmxQv1vq6N+sqfnggw9owIABQoehLXSryS0AmJkBR4+yAZZGjwaeadij9ZycnEBESEtLEzqUBgsNDcWCBQtqLGNpaYmjR48iPDwc33zzTb339eDBA4wbNw6LFy/GxIkTVZYrLy/H06dPBen+vbqKCuCdd1h3/T/8AHTo0Dj7nT59On799Vc8evSocXbYDBQXF/NuVKrRuaQBsKFcT58G/voL8PIClNQPay1Z88+VK1cK3qleXW3fvh1jx45FQUEBQkNDkZ2djVdfffW567m7u+PKlSs4efKkwngatbV161aEhIQgJCREZZnc3FysW7cO5eXlgjazzcgAXnoJ2LOHjSs+fHjj7XvkyJGwtrbG3r17G2+nTVxeXh4sLCyEDkN7CH2v0xCJiewxlZkZ0b59QkdTe6tWraLu3buTkZERBWrqNWEN+O677wgAicVi6tWrF8XGxgodUqWpU6eSgYEBderUiT755BOSNGZ/+dWcO0fk6EjUti3RMz24NJp58+bV2OuAMgcPHlSoq6heb9ac+fr60jvvvCN0GNoiQ0T0TCN8HVNWBixaBHz9NTBuHBt+s7EeBXCcTFYW60QzNJQN+7pzJ6DihXaNi4mJQf/+/XHlyhX01eQwls1E9+7dMWnSJIXu/ZupTJ18PFWdoSGwbh0bXvPvv4EePYCPPwbq+RSE4+qkrIx1fd65M3sUtW0b+ypUwgCAfv36oXPnzjh48KBwQTQhycnJNb5M2tzofNKQCQhgffusXcsGaerUCfjPfwAt6XqIa2KKioBvv2UXKUuXsjFe4uNZN+j/vhspqNdeew0HDx6s7Nqeq5+ioiLk5eUpjAfTnDWZpAEAYjEbt+DePWDWLGDDBqBdOzYGB3/RlVOHtDTgk0+Atm2BhQuBF18E7twBvviCtezTFpMnT0ZycjLOnz8vdCg6LTk5GQD4nUY1TSppyLRsyf6JExNZHcevvwLdu7O7kX37ACUdq3KcShIJcOwYMHEiuwjZtg14/33g0SNgyxaWQLRNt27d0Lt3b/6IqoFkXfd07NhR4Ei0R5NMGjItWgDvvcea5P7vf4CxMfDWW0Dr1mwM59OnWXt6jlMmNhaYPx9wdGTvBKWksEdSiYnA8uWAjY3QEdZs0qRJCA8PV9rLMFc7f//9N5ycnLSmDzNtoPOtp+oqOxv48Ufg+++B338HWrUCfH2BkSOBMWMA3hy7+ZJKgUuX2F3Fzz+zi4127dgdxsyZgK5dbP7zzz9wcXFBZGQkhjfmyyJNyFtvvYUnT54gKipK6FC0RWazSxrV3bnDTg5HjwJ//AEYGADDhrEmk76+7CVCrml78gSIjgaOH2c90eblAT17Vl1E9O8vdIQN07dvX/Tr1w+hoaFCh6KTBg4ciIEDB+Lrr78WOhRt0byTRnUZGezEcfQoEBXFBnxycACGDgV8fNjUvbvQUXIN9fgxcOYMm86eBe7fZ822fXzYxcLIkYCLi9BRqk9ISAg2bdqEpKQk6OvrCx2OTiEitGzZEqtWrVI5Bk4zxJOGMhIJEBPDTipnzwIXL7JR1xwc2LCdnp5Vk7W10NFyqhQUAFevAleusOmPP4CHDwEjI3YHIbsg8PICTE2FjlYz4uPj0bVrV5w7dw5DhgwROhydcv/+fXTq1AkXLlzAoEGDhA5HW/CkURsSCasUPX+enXiuXGGVoQB7+9zTE+jbF+jVi92NtGsnbLzNUVoaEBfHpthY9je6c4fVU9jbs79Rv37ACy+wxN+c+p/r0aMHAgICKkdi5Gpn3759eOutt5Cbm8s7LKzCk0Z9ZWSwuxHZVWxsLPBvk26Ym7P6EDc3lkRcXdnLhu3bs0chXP1IpezxUkICe/tfNsXFAbKRcFu1Ajw8WIKQ3Q1qY5PYxrRs2TLs2bMHjx49qhyVkXu+OXPmICYmBn/++afQoWgTnjTUKTu76iRW/aQmG9dcTw9wcmJ3Jy4u7GuHDiyZODmxx1/NOalIpeyOISmJ3ck9eFA1PXzI5slaj1pbs2Tcowf7KkvOmhyHW1fFxsbC09MTMTEx8PT0FDocneHp6YlBgwZhw4YNQoeiTXjSaAw5OazCtfoJUPb9o0dVJ0IAsLVlJz4nJ/ZYRfbV2ppdRcsma2th+zeqrfx8dhcgm7Ky2JSWxu7MUlKqvqalVb03o6fH3o+QJVbZ5OLC7tpsbYU9Ll1CRGjXrh2mT5+Ozz77TOhwdEJxcTEsLS2xZ88eTJo0SehwtAlPGkKTSNhJ88kTdtKUfU1KAlJT2de0NHailUrl19XTq0oi5uZsMjQELC3ZM3tjY5ZYDA2rurgwMlKs9DU1ZfOrx5SfL1+mpAQoLmbfFxezn3NzgdJSVuFcUMA678vJYf0yyZKEsvfKLC2vQiJZBHf3fXBxsYODA0sQDg5Amzbs5cu2bZv3XZe6zZ49G3/++SdiY2OFDkUnnDt3Dj4+Prh//z468G6zq8sUCx1BcycWsxNkbZ675+bKX7VXn/Lz2Ym7pIS9a5CVxU7o2dnsq2yEw6Ii9nN1eXmKCallS8U4zc3Z97LEY2HBEpOZGTvhGxmxhGVqKn9XJJtatmRf4+IMMXp0ApKTvRAa+gtcXV3r98vjam3kyJEIDQ3FkydPBB/VUBdERUWhffv2PGEowe80OEFkZWVh/PjxiI2Nxb59+zB69GihQ2rSSkpKYGNjg3Xr1mHWrFlCh6P1+vXrB09PT2zZskXoULSN7o+nwekma2trREZGYvz48Rg3bhxWrVoldEhNmrGxMfz8/HD8+HGhQ9F6mZmZuHr1KgICAoQORSvxpMEJxtDQEDt37sRXX32FpUuXYsaMGSgrKxM6rCYrKCgIp06dQpHsWSWn1KlTp6Cnp4dhw4YJHYpW4kmDE9y8efNw7NgxhIeHw9fXF+np6UKH1CSNHDkSJSUlOHv2rNChaLXIyEh4e3vznm1V4EmD0wqBgYG4cOECkpOT4eXlhbi4OKFDanLatGkDV1dXnD59WuhQtJZEIsHx48cRFBQkdChaiycNTmu4ubkhJiYGbdu2hZeXF3755RehQ2py/P398euvvwodhtb67bffkJmZiVdeeUXoULQWTxqcVuEV5Jrl5+eHGzduIDU1VehQtFJ4eDg8PDz4SH014EmD0zq8glxzfHx8IBaLcebMGaFD0TpSqRQ///wzxo8fL3QoWo0nDU5r8Qpy9TM3N0f//v15vYYSZ8+eRXp6OsaNGyd0KFqNJw1Oq/EKcvXz9/fHqVOnhA5D64SFhaF3797o2rWr0KFoNZ40OK33bAX50aNHhQ5Jp/n5+SExMREJCQlCh6I1iouL8eOPP2Lq1KlCh6L1eNLgdEL1CvKxY8fyCvIGGDBgAMzMzPgjqmp+/PFHFBYWYsqUKUKHovV40uB0Bq8gVw9DQ0O88MILPGlUs2vXLowaNQq2vM/95+JJg9M5vIK84fz8/BAdHY0K2QAmzdjDhw9x7tw5TJ8+XehQdAJPGpxO4hXkDePn54esrCz89ddfQociuB07dsDe3h6BgYFCh6ITeNLgdBavIK+/Xr16wcHBodk/oiotLcX27dsxa9YsiMV8eKHa4EmD02m8grx+RCIRhg0b1uy7FAkLC8PTp08xc+ZMoUPRGTxpcDqPV5DXz9ChQ3Hp0iVIJBKhQxHMN998g/Hjx8PR0VHoUHQGTxpck8EryOvG29sbBQUFuHHjhtChCOLSpUuIiYnB3LlzhQ5Fp/CkwTUpvIK89lxdXdGyZUv8/vvvQociiI0bN8LDwwNeXl5Ch6JTeNLgmhxeQV47IpEIAwYMaJZJ48GDBwgPD8eCBQuEDkXn8KTBNUm8grx2vLy8mmXSWL16NZydnfHaa68JHYrO4UmDa7J4BfnzDRo0CImJiXjy5InQoTSatLQ0fP/99/joo494M9t64EmDa/J4BblqAwcOhFgsxqVLl4QOpdF89dVXsLCw4J0T1hNPGlyzoK0V5NeuXUNQUBCsrKxgbm4Of39/XLx4sdH236JFC/Ts2bPZJI2nT58iNDQUCxYsgImJidDh6CSeNLhmQ9sqyP/88094e3vD3Nwct2/fxsOHD9GhQwcMHToUUVFRjRaHt7d3s6nXWLNmDYyMjPDuu+8KHYruIo5rZkpLS2n69Omkr69PK1euFCQGqVRKrq6u1Lp1ayoqKqqcL5FIqGvXruTs7EwlJSWNEsv+/fvJwMCACgsLG2V/QklPTydzc3Nas2aN0KHosgx+p8E1O9pQQX7u3DnExcVh/Pjxco9J9PX1MWnSJDx+/BjHjh1rlFi8vb1RXl6OK1euNMr+hBISEgIzMzPMnj1b6FB0Gk8aXLMlZAV5dHQ0AMDT01NhmWxeY3Um2L59ezg6OjbpR1TJycnYtm0bli5dClNTU6HD0Wk8aXDNmjoryO/cuYMxY8bA0tISpqam6N+/P44dOwZ/f3+IRCKIRCLMmDGjsiwAODk5KWxH1g9SfHx8vWOpKy8vryZdGf7ZZ5/Bzs6Od0yoBjxpcM2eOirIExIS4OXlhStXriA8PBzp6enYtWsXNmzYgBs3bsDIyAhEhO3btwMAcnJyALDWS88yMzMDAGRnZzfgqOqmf//+iImJabT9Naa4uDjs3LkTn3/+OQwNDYUOR+fxpMFxaPgb5EuWLEFOTg42bNiAF198EWZmZnB1dcWBAwdQWFhYp20REQDWzUdj8fDwQEpKClJTUxttn41l4cKFcHNz4+N/qwlPGhz3r4ZUkEdERAAAAgIC5Obb2tqiW7duCuWtrKwAQGlCkc2TlWkMHh4eEIlEuHr1aqPtszFER0cjIiICa9euhZ4eP92pA/8tctwz6lpBXlpaivz8fBgbG1c+WqquZcuWCvNkiURZ9x1JSUkAgC5dutQn/Hpp2bIl2rdv36SShlQqxfz58zF69Gj4+fkJHU6TwZMGxylRlwpyIyMjmJubo6SkBAUFBQrLlSWdYcOGAQBiY2MVlsnmNfaJzsPDo0mNGb5jxw7cuXOHd1apZjxpcJwKsgpyZ2fn51aQjxgxAkDVYyqZ1NRUpa2gfHx80KNHD4SHh6OkpKRyvlQqRVhYGJydnREUFKSmI6kdd3f3JnOnkZ2djWXLlmHOnDlKHw9yDSD064Ucp+1q8wZ5QkICtWrVihwdHSkqKory8/Pp5s2bFBgYSO3atSMjIyOFdS5dukTGxsY0ceJESklJoczMTAoODiaxWEwRERGaPiwFJ06cIACUkZHR6PtWt3feeYfs7e0pJydH6FCamgyeNDiulr7++mvS19ent99+m0pLSxWW3717l8aMGUMWFhZkampK3t7edPbsWfLz81OaNIiIrl69SiNGjCALCwsyMzMjX19funDhgqYPRanU1FQCQKdOnRJk/+py9epV0tfXp++//17oUJqiDBHRv+37OI57roiICEycOBFubm44fPgw7OzsnruOv78/Lly4IPcYSls5Ojpi3rx5+Oijj4QOpV6ICIMGDYKenh7Onz/fqM2Wm4lMXqfBcXWgrV2sq4uuV4Zv3boVMTEx2Lx5M08YGsKTBsfVUV0qyHWNh4eHzlaGJyUlYfHixVi4cCH69OkjdDhNFk8aHFcP1tbWiIqKqvEN8rCwMIhEIpw+fRqlpaVyfU9pK3d3d9y7dw+5ublCh1Jns2fPhr29PZYvXy50KE0ar9PguAbasGEDPvjgA0ybNg3ffvutTvdvlJiYiPbt2+PChQsYNGiQ0OHU2p49e/DWW2/h7NmzGDx4sNDhNGW8ToPjGqopjUHetm1bWFhY6FRdTWpqKhYsWIA5c+bwhNEIeNLgODVoKhXkIpEI3bt316n458yZA3Nzc4SEhAgdSrPAkwbHqUlTqSB3dXXVmaTx448/4vDhw9i2bZvSfr849eNJg+PUSFZB/sorr9Sri3VtoCtJIysrC3PnzsXbb7+N4cOHCx1OsyEWOgCOa2oMDQ2xa9cu9OnTBx988AHu3bunUxXkrq6uSE1NRWZmJmxsbIQOR6X58+dDX18fa9asETqUZoXfaXCchuhqBbmrqysA4Pbt2wJHolp4eDj27duHLVu2NOq4IxxPGhynUbpYQe7k5AQrKyutjfXJkycIDg5GcHAwRo8eLXQ4zQ5PGhynYbpYQa6tLagqKirw5ptvwt7eHuvWrRM6nGaJJw2OawS6VkGurZXhX3zxBX7//XccOHAApqamQofTLPGKcI5rJNUryBcsWKDVFeSurq74+eefIZFIkJiYiPv37yMhIQF5eXlYtGiRIDFdvnwZX3zxBdauXcv7lhIQ70aE4wRw8uRJTJo0qU5drGuKVCqtTAoJCQm4d+8e/vzzT9y4cQMSiQRSqbSy7KhRo/DLL79oNJZNmzZh3rx5cr3U5ubmwt3dHV27dsWJEyd4D7bCyeSDMHGcQG7evEkuLi7UoUMHunXrlspy9+/fp4qKCo3FUVpaSu3atSMAZGBgQIaGhgRAYTI0NKQVK1ZoLA4iosjISAJAo0aNory8vMr5r7/+OtnZ2VFKSopG9889Vwav0+A4gdSmgjw9PR1Dhw7Fnj17NBaHoaEhPv30U+jp6aG8vBxlZWVKy5WVlaFv374aiwMADhw4AH19fZw8eRIeHh6Ij4/H7t27cfDgQezatQsODg4a3T/3fPzxFMcJrKysDMHBwdi7dy9CQkLw8ccfAwBKS0vh4+ODy5cvw8rKCg8ePNDYOwlSqRRdu3bFw4cPUVFRobJcSkqKxk7cJSUlsLGxQWFhIQBALBbD0NAQPj4+cHV15S/xaQfeyy3HCU1WQf7VV19hyZIlmDFjBsrKyjB79mxcuXIFRISCggJ88sknGotBX18fn3/+OWq6hrS1tdXolf7Ro0dRVFRU+bNEIkFJSQkiIiKgp6dXYzLjGg+/0+A4LXL06FFMnjwZvr6++OWXX+RO4np6eoiNjdVYy6GKigr07NkTd+/elav8Bljvty+99BKOHTumkX0DwMsvv4wTJ05AIpEoLNPT08Pw4cMRFhYGS0tLjcXAPRe/0+A4bTJq1CisX78eR48eVbjq19PTw6xZs2q8G2gIPT09fPHFFwoJAwAMDAzQv39/jewXAHJycnDy5EmlCQNgCe3XX3+Fp6cn4uPjNRYH93w8aXCcFvn7778xb948pcskEgliY2Px/fffa2z/Y8eOhYeHB8Ri+Ve4NF0Jfvjw4Vo9fvrnn39w5MgRjcXBPR9/PMVxWiIrKwseHh5ITk5WecUtEok0Xil+8uRJvPTSSwrzk5OT0bp1a43sc+jQobhw4YLSuxyAHXe/fv2wc+fOyg4VOUHwx1Mcpw1KS0sxcuRIPHr0SGXCANAoleIjRoyAt7e33N2GjY2NxhJGSkoKzp8/rzRhiMVimJmZYf369bh06RJPGFqAJw2O0wIFBQUICAiAk5MTANTYtUh5eTm+/fZbXL9+XWPxrFy5sjJ5iUQijdZnhIWFQU9P/lSkr68PgFWOJyQkYN68eQplOGHwvwLHaQFra2usWLECjx8/xpUrVzB16lSYmppCJBJVnkCr03Sl+JAhQzB06NDKdyX69eunkf0AwPfffy93l6Gvr482bdogIiIC4eHhsLe319i+ubrjSYPjtEzfvn2xbds2ZGVl4dChQ3jxxRehp6cHAwODyjISiQQxMTHYu3evxuJYvXo1pFIpSktL4enpqZF93L9/H9evXwcRQSwWQ09PD++99x5u376NgIAAjeyTaxheEc5xOiAxMRHff/89tm/fjkePHsHQ0BBlZWVo1aoVHjx4oPLdhdJSoKgIqKgAcnPZvNxc9jMAFBcDJSXK91leDixd+hL++uskQkOfoFUrR7nlJiaAsbHydQ0MADOzqp+trACRiM0zMACMjABTU+Dzzz/Hp59+CgCVFd1ubm61/r1wjS6TJw2O0xLFxcDTp1VTbi5QWAjk51d9X1BAuHfvIm7e3IVHj8IglRbBzu59WFhsQEUFkJMDELGyKrqQqqObAAIAJKtjY0p0hUiUDBOTtbC3nwmRSA9WViy5tGjBvlpZVX3/7M8WFkCrVlVT9UTFaQRPGhynCRIJkJ4OpKUBKSns+/R0IDNTPjFUn4qLFbcjFgPm5oClJTtRtmjBTpQWFoCRURHS0g7jn3/2IyhoDRwd3WBuztaR3QVUv+Jv2ZJ9lZWpvn1VWrYEdu/ejWnTpiksy8sDVLSQRVERu8sBWBLLyZFfp6gIuH07FocOrcBrr22BlZVTZcLLyQEKCljiKywEsrOrvi8oYMsLC6u2X52hoXwSadUKsLau+t7ODrC3Z1Pr1uxnIyPVx88p4EmD4+qCiCWBxETg0SMgKYlNzyaIjAxWVsbUlJ2gbGxUn9CenSwta39Ck0gkCi/kabvCwkK0aNGi3utLJOwO7Nnkm5WlOjGnprI7t+patWJJxM4OcHQEbG1ZQnF0BNq3B9q2Bdq0qUq0zRxPGhxXnUTCEsL9+ywpPH4M/PMP+/7RI+DJk6rHPvr6gIMDO6HIrl7btKk66Tg4sBNRmzb8sYk2KS5mySMlhSX35GSW8Ksn/eRk9n31v3WbNkC7diyJyCZnZ6BjR6BDh2Zzx8KTBtc8JScDf/8NPHggP/39d9VjImNjdqLo0IElAdn3ssnZmT3+4Zqu7Gz2uZAlkeqfleRklnxkZ9CWLYEePQBXV/nPSY8e7HFhE8GTBtd0EQEPHwI3bwK3bgE3brCvCQlVV5CtWgGdOgGdOwNdurCvnTqxSVYHwHGqFBSwu9J799jn6t49NsXHszsXgD3WatcOcHMDevasmjp31slHXjxpcE1DUREQGwtcv86SxI0bQFwce34tErFn0z17sn/cbt3YP2znzqxOgeM0IS+vKpHcvVt14ZKQwBoDGBmxuxJZMundG+jXj7UO02I8aXC6RyoF7txhSUI2xcSwuwdLS3aX0KMH0Lcv+6fs04dVQHOcNigvZ3cif//NLmxiY6selQLsUejgwcCgQewz7Omp+n0YAfCkwWm/4mLg4kUgOhr4/Xf2T1ZQwFokeXgA/fuzacAAdkfBcbooNZVd/Fy+XDXl5LA7kj59gIEDgWHDAB8fQe9GeNLgtI9EAvz5J0sS0dHApUusTX7XruwKTJYgXF118pkwx9UKEbsjkSWQixfZ41eRiN2B+PqyadAgdgHVSHjS4LRDRgbwyy/Azz8DZ86wOwln56p/DD8/1m6e45qzrCz2/yG7oLpzh92JeHkBL78MjB3LKt01iCcNTjiJiSxJ/PQTcOECe5t3+HAgMJAlic6dhY6Q47RbUhJLHpGRwPHj7HGWhwcwbhxLID16qH2XPGlwjSsvD9i/H9i5E7hyhVVcBwWxD/iIEaybDI7j6q6sjN2FHD4MHDnC6ki6dgWmTgWmT2cvm6oBTxpc44iNBbZuBQ4eZD2svvoq8Npr7NFTDeMNcRxXDxUVrC7wxx+BvXtZ0/MxY4BZs9hdvEhU703zpMFpjlQK/PAD8NVXLGm4ugLBwcAbAzIQaQAAIABJREFUb2h9W3SOazJKSljy2LaNPQbu1Al4/31gxox6vanOxwjn1I8ICAtjz1PfeIO9aX3+PHu5ae7cxk8YEokEO3bsQP/+/WFtbY2WLVuib9++2Lx5M8qe03+4VCrF4sWL0blzZxgbG2PEiBEqy8bExGDatGlwcXGBiYkJWrVqBTc3N7zyyivYsmUL7t+/r7Dt0NBQeHt7w9LSEgYGBmjTpg1eeuklbN68Gf/8809lWQcHB4hEIrnpzp07ctsbP348RCIRkpKS5OYvW7ZMbr2VK1fKLb937x5EIhEGDhyo8tjMzMwU9i8SiaCnpwdbW1uMGTMGMTExKtdPTEzE6NGjkZeXJzf/2rVrCAoKgpWVFczNzeHv74+LFy+q3E5NTpw4gS5dutSr48bs7GyEhobC19cXrVq1gomJCTp37ozJkycrHVZ30aJFOHTokMrtTZ8+HUZGRnBxccG8efNQomrQkkZgbMz+D2X/gwEBwMcfsy5ONm5k743UCXGcGl29SuTtTaSnRzR1KlF8vNAREU2ZMoUA0OLFiyktLY0yMzNp1apVBIBGjhxZ47pbt24lAPT5559Tdna20jJSqZQWLlxIYrGYPvzwQ7p9+zaVlJRQamoqRUVFkb+/PwEgAFReXl653qRJk0hPT49WrVpFjx8/puLiYkpISKAlS5aQSCQia2truf1s27aNAND8+fMVYpBIJGRlZUUAaMeOHQrLs7KyyMrKisrKyhSWLV68uDK+uLg4lb+Lv/76iwDQyy+/XDkvJyeHDh8+THZ2dmRgYECnTp1Sup6NjQ1t2rRJbv4ff/xBJiYm9Nprr1FycjJlZGTQzJkzSSwWU2RkpMo4npWQkECjRo2iXr16kYWFBenr69d6XZm3336bxGIxff3115SSkkKFhYV07tw56tGjB+nr69NPP/2ksE8XFxdatmyZym3m5eVRaGgoAaCQkJA6x6RJqalEH3xAZGxM1LUrUURErVfN4EmDUwuJhOizz4gMDIgGDyaKjRU6Iub+/fsEgNzd3RWWvfjiiwSALl++rHL9SZMmEQDKy8tTWWbJkiUEgLZt26Z0uUQioREjRsgljcuXLxMAmjlzptJ1Zs+erZA0Hj16RACoW7duCuUvXrxIpqamBIAmTJigsDwsLEzuZC8jlUrJ0dGR3N3dCQAtXLhQ5XEqSxoy+/btIwDk6uoqNz83N5ecnJwoODhYYb+urq7UunVrKioqqpwvkUioa9eu5OzsTCUlJSpjqW7SpEn03//+l8rLy8nR0bHeSWPWrFkK869du0YAqHPnzkqXiUQiOnToUI3bNjU1peHDh9c5psbw4AHRK68QiUREs2YRFRQ8dxWeNLiGy8sjCgpiVy3r1xNJpUJHVOXMmTMEgF5//XWFZXPnziUAFB4ernL94cOH13gSun37Nunp6VHfvn1rjOP333+XSxq7du0iALR27VqVcT+bNIiIunfvTgAoMTFRbv7y5ctpwYIFZGZmRi1btiSJRCK3fPr06fTtt98qbO/kyZPUrl07iomJIQBkb28vdzdUXU1JIykpqfJupfod2dKlS0ksFlNSUpJc+d9++40A0Ny5cxW2tWLFiuf+XaqrnnTqmzRqYmJiQnp6elRRUaGwbMKECeTk5KTyd0ZE1KZNm+d+PoT2ww9ENjZE7u5Ejx/XWDSD12lwDVJUBLz0EnuD+9QpYP58QE+LPlXdunWDgYGBwvN/ALhz5w5EIhF69uypcn2pqqHp/rVt2zZUVFRgwoQJNZbz8vICEVU+b7e3twcAnDp1Sml5Hx8fZGZmKswPDAwEAERERMjNj4iIwKhRo+Dr64vs7GxcvnxZbnlUVFTlutXt3LkT06ZNg6enJ3r16oW0tDScOHGixmNRhqq1pxH92zSHiLB9+3YMGDAAbdq0kSsfHR0NAPD09FTYlmze6dOna7VvEw32O15YWIji4mK4ublVHld1Y8eOxZMnT3D8+HGV2xCJRJBIJBqLUR0mTGBvnZeVAd7ebBwZVbTo35vTRdOmsR48z59nXXxoG3t7e6xduxbXr1/HkiVLkJGRgadPn2L16tX49ddfsXz5cnTp0qXe2z937hwAoFevXnVab8iQIXBwcEBkZCRGjBiBM2fOoKKi4rnrBQQEAAAiIyMr5z19+hR37tyBt7e30uW3bt2CqakpXFxc5Lb19OlTHD16FFOnTgXAKm8Blkjq6syZMwAAV1dXWFpaAgCuX7+OtLQ09O7dW6G8LIk7OTkpLHP899X/+Pj4Osehbj/++CMAYOnSpUqX9+nTB4D871tXubgAZ8+y4X/HjKmhgrwxbn24pumXX9iz0F9/FTqS5/vhhx/Iycmp8hGKjY2N0grjZw0ZMoRMTU1VLm/dujUBoD///LPOMZ0/f56cnZ0rY7Kzs6PJkyfTgQMHqLCwUOk6xcXFZGJiQpaWlpWPRMLCwmjUqFFExCpoAdCAAQMq11m7di3NmTNHYVubNm2iYcOGVf6ckZFBBgYGJBaLKS0tTaG8ssdTubm5KivC9+7dSwDoyy+/VNiWrD7pjz/+UFh27949AkAeHh5Kfwc1UefjqdTUVLK3t6cZM2aoLJObm0sAaMiQISrLdOjQgXr06KGWmBpDQgKRqSnRqlVKF/PHU1z9bdgAjB7NXhbSVkSEWbNmYfLkyViwYAFSU1ORkZGBkJAQzJkzBxMnTqzx0cGjR4+UXg0/S9mji+cZPHgw7t27hz179uDll19GcXEx9u/fj9dffx1t27ZFWFiYwjrGxsZ44YUXkJubiz/++AMAu8qV3WF07NgRHTt2RExMDJ4+fVq5XNmjqV27dlXeXQCAjY0NRo4cCYlEgr1796qM+8iRI5VNbq2srDBz5kwMHDgQFy9ehL+/f2W5lJQUAKi886gt+vdRV31+p+qSlZWFwMBADB06FKGhoSrLWVhYQCQSVR6rMm3atEFSUpLWP6KS6dgRmDcP2LSJvWuloFFTGNdkSKWs4nvPHqEjqdmePXtUVrh+9tlnBIDWr1+vsCwrK4tWr15NAOjrr79Wuf2+ffsSADpx4kSDYy0vL6fTp0/TxIkTCQDp6+vT1atXFcqtW7eOANDSpUuJiF1dJyQkVC5/7733CACFhYVRUVERWVpaUsEzzWKuX79O5ubmCnc0v/zyi9JWUEQ1V4Qr8/nnn6tsVTZhwgQCQKdPn1a5Hz8/v1rtpzp13GkUFBRQ37596fXXX1doUKCMgYEBOTo6qly+d+9eEolEtHjxYsrIyGhQbI3lyhUiQGmTeX6nwdVPURF701TbBzeSVRhXvwKW8fv3FunkyZNy86dNmwZra2ssWrQIH330Ed5//32V2/fx8QEA3Lhxo8GxisVi+Pr64uDBg/j4448hlUoRHh6uUE521xAZGYmbN2/C2NgYHTt2rFxevV7j7Nmz8PT0RItnOvXauXMn8vPz0aJFC7mX9UaPHg0AiIuLU6hMryvjf0cOKlfycLxbt24AgCdPnigsk72c2JC6pvqSSCSYMGECHB0dsWfPHujr69dqnZoq46dMmYKQkBCsWbMGtra2Su/6tI2tLfv6782qHJ40uHoxM2MJ4/ZtoSOpWWFh4XPLFBQUyP28e/du5ObmIiwsDOvWrUNwcLDKdYODgyEWi5We3Kv76KOPoKenV1kBfPHixcoWVMoMGzYMAHtT+Vndu3eHs7MzYmNjsW/fvsokUX1dQ0NDREZGIiIiQmF5eXk59u/fj4sXL4KIFKb58+cDYI+vGqJ169YAgNzcXJXHFxsbq7BMNs9PgOeewcHBKC0txQ8//CD3ZnmnTp0qHwdWl5eXByKqPFZlli5diiVLlmDLli3IyclRaPmmjeLi2Fdlg5rxpMHV27hxwI4d9eiGoBENGDAAgPLmm7Jmn8q6z7CwsMCECRPg7u5eY0Lo0qULPv30U1y5ckVlq6O7d+9i69atePXVVyuvsIkI6enpSk9EAHDlyhUAgLu7u9LlAQEBICJs3LhR4crVzMwMgwYNQnJyMnbv3q2QNI4ePQobGxt4e3sr3fbbb78NADh48CCKi4tVHPnzubm5AVB+N+Hj44MePXogPDxcrosNqVSKsLAwODs7IygoqN77ro8VK1YgLi4OR44cgZGRUa3Wkd0VyY5VmcOHD8PFxQUzZsyoc/2OULZsYa0hlV7XNOJjMq6JkbWy+OQToSNRLTs7mzp37kwGBga0YcOGym5Etm/fTqampuTo6EjJyckq1/fz86vVM/JFixaRgYEBffzxx3T37l0qLS2lJ0+e0Pbt26l169Y0ePBguXqF8+fPEwBydnam/fv3U1JSEpWUlNDDhw9pzZo1ZGhoSH379lX5VnR4eDgBIAMDA8rPz1dYvnLlSgJArVu3Vlg2cuRIWr16dY3H079/fwJA+/btq5xX1zqNiooKsrOzo0GDBildfunSJTI2NqaJEydSSkoKZWZmUnBwMInFYopQ0q/F5MmTCQA9ePBA5T5rU6ehbDuyly1rmi5duqSwrQMHDhAAhW5Gno2pd+/eNcakTfbvr7FVJH8jnGuYbdvYB2zLFqEjUe3p06f04YcfUrdu3cjIyIgMDQ2pY8eONGfOHEpNTa1xXX9//1pXrF6+fJneeOMNcnZ2JgMDAzI3N6eBAwfShg0bqLS0VK6sVCqlCxcu0MKFC2nAgAHUpk0bEovFZG5uTp6envTll1+qbHZLxPp8EovFNHToUKXLZSf4adOmVc57/Pix3EmwerNcmYcPHyqcLO3t7alFixYK87t27frc38mSJUuUvhEuc/XqVRoxYgRZWFiQmZkZ+fr60oULF5SW9fX1JTMzM4XK6aNHj6o80X/33Xe12k5QUFC9ksaECRPI0dFRaZ9eMo6OjtSnTx+Vy7VJVBSRkRHRggUqi/CkwTVcSAhLHIsWsT6ompKgoCASiURCh6GzcnJyyNHRUaHvqbrKzs4mExOTGt+ZaMztEFX1PXXw4MEay9nb29PAgQMbvD9NCw1lfce9+WaNXQHxpMGpx5497ArFy4vo7l2ho1Gf4OBgAvDcOxJOtatXr5K1tTVt3ry5XutXVFTQG2+8Qfb29pSSklLvONS1HSLWEWaHDh1oyZIlNZYrKysjAwMDGj9+fIP2p0lpaURjx7KeqVesIFLSxVZ1vMktpx5vvglcvcoqxd3c2MtBShrN6BxZJfPKlSuRlZUlcDS6yd3dHVeuXMHJkycVxtOojbS0NDx48ACnT5+GQwPGLFXXdgBg69atCAkJQUhIiMoyubm5WLduHcrLy7WymW15OXtBt2tX9r976hTw6ae1GNWvkZIZ10yUlxNt3Upka0tkbU306adEKoah0BmrVq2i7t27k5GREQUGBgodDqcDpk6dSgYGBtSpUyf65JNPavWSYGMpK2NPBjp1IjIxIfr4Y6Lc3FqvnsGHe+U04ulTYP161hWBSARMmcKGeq2hZSLHcRr06BGwfTtrJp+VBUyfDixeDLRtW6fN8DHCOc3KyQG++45N9+6xbpdnzQJefbVe4xNzHFcHEglw/DgbHzwiArCzA956C3j3XaAWXaopw5MG1ziIgOho9uH9+WfA1BR4+WVg7Fhg+HCeQDhOXSQS1sX5Tz8Bhw8DaWmAvz+7WBs9GjAwaNDmedLgGl96OrBvH/tAX7rEEsaIESyBBAUBOvLSLMdpjZISVpF9+DBw9Ch7/NSrF+u14Y03gA4d1LYrnjQ4YaWkAEeOsKui335j9R/e3oCvL5v692/wlRHHNTkVFcD16+x/Jjqa3VkUFQEDBrCLr3HjWBfnGsCTBqc9srOBEyfYFVN0NBty0swMGDKkKon07g3UouNRjmty7txh/xfR0cCZM+xuwsYGGDaMjWkzahTwzKi6msCTBqe9HjwALlwALl5klXlJSSyJ9O4N9O1bNbm6Ch0px6lXXh5w4wb77F+4wMbvTk8HWrQAvLxYHYW/P+DuDug17tt2PGlwuoEIuHUL+P134M8/2T/R7dvsNt3RkT3GGjAA8PBgzXpr6Kma47RKdjZw8yZw7Rr7XF++zFoaAqwuYsAA9vkeOBDw9ASq9dguBJ40ON2Vnw9cucKSiCyRJCezZdbW7I7EzY1NvXqxOxIzM2Fj5pqv0lLg77/Zxc+tW+xO4tYtQNZzfKtWLDlUn2SDIWkRnjS4piUjo+qfUfaPGRcHFBaySnYXF9ZtQufOQJcu7GunTkC7dryuhFOPJ0/YncK9e0BCAvt65w77XiIBDA2B7t3ZxUzPnuyCxs0NcHYWOvJa4UmDa/oqKoCHD6sSyN27Vf/UsuEsDQ3ZowBZIunYkf0Tt2/PvvJmwJxMcTHwzz+socajR8D9+1XJ4d491ooJAMzNqy5KOndmCcLNjV20CPyIqSF40uCat6dPq/7Zq08PHsiPj2xhwbpbaNeOfXV2rkoqdnas1Qp/9KX7iouB1FTWFPzJE5YUHj+uShKPHwOZmVXlzczYBYYsMciSRJcuQAP7RNRWPGlwnCqFhUBiIptkJ4zqPz95Ij/Urakpq4B3cGDDZLZpwxJK69bsZzs7VtfSqhWbuMaRl8cuALKy2NvR6eksKaSlVSWI9HRWH1a9E159ffa3bN9e/kKhXTs2OTsDLVsKdlhC4UmD4+qrooKddJ498aSnK87Lz5dfVySqSh6qJnNzdiVrZcWaWpqZyf9cy2GsdZpEwn53ublAQQFL5LKfZd8/fVrzJJHIb9PUlCUDBweWyB0d2VcHB5bgZXeODg78xVIleNLguMZQXMwSSFZW1VVvdnbNJ7ucnEsoLj4LYJHSbYrFLLFYWrJkYmTEJlNTdpVsYcHKWVmxJNWiBau7kZWRMTBQ/WjNxAQwNlacX17OTuKqjrWkpOrn0lL2nF8qrbqSz8lhzagLC4Gysqoysu3m5LBlpaWqf6cmJuz4n5d8W7VidwStWrFEwB8jNghPGhynjY4cOYLXX38d/v7+2LnzMIqL9VFYyE6o2dmo/L6wsOrnsjJ24i0trTr5ErETMMCuyiUSxZO6bB1l8vLYyR4oAfA9gJEA2kAkYslImWeTkOzntLSVMDKSwMVlGczNWdKTJSVZGVmys7BgP7dowb63tKy625IlykZ+qY1jeNLgOG0TGhqKOXPmYObMmdi8eTP0taAtcEZGBuzs7BAdHY1hw4bVaxtr167F8uXLcefOHbSt4yAOnNbI5Lma47TI6tWrMXv2bKxYsQJbtmzRioShLu+//z7atGmDTz75ROhQuAbgSYPjtMSqVauwaNEirF+/HsuWLRM6HLUzNDRESEgI9u3bh9jYWKHD4eqJJw2O0wJLlizBkiVLsG3bNsybN0/ocDTm1VdfhZeXFxYuXCh0KFw98aTBcQL7/PPPsWrVKuzatQszZswQOhyNEolEWL16Nc6ePYujR48KHQ5XDzxpcJyANm7ciBUrVuDbb7/Fm2++KXQ4jcLb2xtjxozBihUrwNvh6B6eNDhOINu3b8f8+fOxbt06BAcHCx1Oo1q+fDn++usvHD9+XOhQuDriSYPjBBAREYF3330Xy5cvx/z584UOp9H16dMHI0eO5HcbOognDY5rZHFxcZg4cSImTJiATz/9VOhwBLNixQpcvXoVp06dEjoUrg540uC4RpSSkoLAwED07dsXu3fvhkgkEjokwXh4eCAwMBArVqwQOhSuDnjS4LhGUl5ejldffRUtWrTA//73PxgaGgodkuA++eQTXLp0Cb/99pvQoXC1xJMGxzWShQsX4tq1a/jf//4HK1UdNzUzXl5e8PHxwcaNG4UOhaslnjQ4rhGEhYVh06ZN2L59O1xdXYUOR6u8++67OHr0KBITE4UOhasFnjQ4TsMePXqEd955B3PnzsVrr70mdDhaZ9y4cbC3t8fOnTuFDoWrBZ40OE6DKioqMG3aNLRp0wYrV64UOhytZGBggOnTp2Pbtm0orz4UIqeVeNLgOA3asGEDzp8/jz179sDExETocLRWcHAwMjIycOTIEaFD4Z6DJw2O05B//vkHS5cuxfLly9GvXz+hw9Fqzs7OeOmll7BlyxahQ+GegycNjtOQ+fPnw8nJCR999JHQoeiEmTNn4rfffsOjR4+EDoWrAU8aHKcBUVFROHLkCDZu3AgjIyOhw9EJgYGBaNmyJQ4dOiR0KFwNeNLgODUrLy/HnDlzMGHCBAQGBgodjs4wMDDA2LFjedLQcjxpcJya7dmzB4mJiVizZo3QoeicCRMmIDY2lr+zocV40uA4NSovL8eXX36Jt956C+3atRM6HJ0zbNgwmJub48SJE0KHwqnAkwbHqdHOnTuRlJSEjz/+WOhQdJKhoSH8/Px40tBiPGlwnJoQEdauXYu33noL7du3FzocnRUYGIgzZ85AKpUKHQqnBE8aHKcmp06dQkJCAt577716b+PatWsICgqClZUVzM3N4e/vj4sXL6oxSmGdOHECXbp0gVgsVllm4MCBKCgowO3bt+u07ezsbISGhsLX1xetWrWCiYkJOnfujMmTJ+P69esNDZ37F08aHKcm3333HXx8fODm5lav9f/88094e3vD3Nwct2/fxsOHD9GhQwcMHToUUVFRao62cd2/fx+jR4/G4sWLkZaWVmNZNzc3mJqaIiYmpk77+PDDDzF37ly8/PLL+Pvvv5GVlYWdO3fi2rVr6Nu3L37++eeGHAL3L540OE4NSktLERkZiUmTJtVr/YqKCrz99tuwsrLCrl270Lp1a9jY2GDLli3o2LEjZsyYgdLSUjVH3Xg++eQTeHt7IzY2Fubm5jWW1dfXR+/evXHlypU67+ett97CvHnz4ODgAFNTUwwZMgQHDhyAVCrlL1mqiep7RI7jau3MmTPIz8+v93sZ586dQ1xcHObOnSvXR5W+vj4mTZqEFStW4NixY3jllVfUFXKj2rFjR5363urduzfi4uLqtI/t27er3JaJiQnu378PImrWoyWqA7/T4Dg1OH/+PLp27VrvZrbR0dEAAE9PT4VlsnmnT5+uf4ACq2tnjY6OjkhOTlbLvgsLC1FcXAw3NzeeMNSAJw2OU4O//voLffv2lZt3584djBkzBpaWljA1NUX//v1x7Ngx+Pv7QyQSQSQSYcaMGZVlAcDJyUlh246OjgCA+Ph4DR9F7dXl2OqjdevWSElJUct+fvzxRwDA0qVL6x0PV4U/nuI4Nbh165Zcq6mEhAR4eXmhRYsWCA8Ph5eXFxITEzF//nzcuHEDRkZGKCkpqSyfk5MDAGjRooXCts3MzACw1kHaoK7HVh8ODg4oKCjAwIEDYWZmVu/9pKWlYdGiRZgxYwZeffXVBsXEMTxpcFwDERFSUlIq7wgAYMmSJcjJycH27dvx4osvAgBcXV1x4MCBOr/DQUQAoDWPVtR5bKpYW1sDAHJzc7Fjx4567ScrKwuBgYEYOnQoQkND1RIXxx9PcVyD5eTkoLy8HHZ2dpXzIiIiAAABAQFyZW1tbdGtWzeFbVhZWQFgz9+fJZsnKyO0uh5bQ9VnP4WFhQgICECPHj2wf/9+6Ovrqz2u5oonDY5rINkjElllb2lpKfLz82FsbFz5aKm6li1bKsyTnQSfPHmisCwpKQkA0KVLF7XFXF/l5eV1Prb67gcAjIyM6rwfiUSCCRMmwNHREXv27OEJQ8140uC4BpKdlCoqKgCwE525uTlKSkpQUFCgUD49PV1h3rBhwwAAsbGxCstk8/z8/NQWc30ZGBjU+djqQ/bGeGlpaZ33ExwcjNLSUvzwww9yb5536tQJf/zxh1ria8540uC4BpLdYRQVFVXOGzFiBICqRzkyqampSltB+fj4oEePHggPD5er3JVKpQgLC4OzszOCgoI0EX6d1fXY6qOsrKzy+7rsZ8WKFYiLi8ORI0f44FeaQhzHNZiZmRlt37698ueEhARq1aoVOTo6UlRUFOXn59PNmzcpMDCQ2rVrR0ZGRgrbuHTpEhkbG9PEiRMpJSWFMjMzKTg4mMRiMUVERDTm4ShIT08nABQdHV2vY6vO0dGR9PX1aywTFhZG+vr6ddrPrl27CECN06VLlxr8u2jmMvidBsepgZOTk9zY1h07dsSlS5fQr18/jB8/Hvb29ggODsbixYvRqVMnpdsYOHAgfv/9d+Tm5qJr165o37497t27hzNnzihUBgupPsd27NixyvcqkpKSIJVKK39W9iZ3WloabG1t67Sf8PBwtR8rp4g3ueU4NXBzc1PoSbVLly746aef6rQdd3d3nRhLoq7HNnLkyMqmw7WRlpYGe3v7Ou3n2LFjtd4+V3/8ToPj1MDDwwNXr14VOowm4/Hjx3LvvXDagycNjlODwYMH4/Hjx1rV1Ycuu3nzJlxdXYUOg1OCJw2OUwMvLy9YWVkhMjJSZZmwsDCIRCKcPn0apaWlDe6fSZuo89ikUinu3r2rdFySpvw71BUiqsuDRo7jVJo0aRKSk5Nx9uxZoUNRu4yMDNjZ2SE6OrrynRJNuXPnDrp3746rV6/C3d1do/vi6iyT32lwnJpMmTIF58+fx/3794UORafFxsbC0NAQ3bt3FzoUTgmeNDhOTQICAmBvb48dO3YIHYpOO3v2LPr16wdjY2OhQ+GU4EmD49RELBZj9uzZCA0NVdr1BVc7Z86cwdChQ4UOg1OBJw2OU6N3330XpaWlKoce5WqWkpKCe/fuwcfHR+hQOBV40uA4NbKxscHs2bPx5ZdfIi8vT+hwdE5kZCSMjY3h7e0tdCicCjxpcJyaLVq0CGVlZVi3bp3Qoeicw4cPw9/fX+kIhpx24EmD49TM2toaS5cuxerVq/HgwQOhw9EZBQUF+PXXXzF27FihQ+FqwJMGx2nA/Pnz0aFDB8yZM0foUHRGZGQkysrKMGrUKKFD4WrAkwbHaYCBgQFCQ0MRFRXFx6eupQMHDsDHxwe2trZCh8LVgCcNjtOQwYMHY/Hixfi///s/3LhxQ+hwtMY///yDwYMH47fffqucl5WVhePHj2MnL7/BAAAgAElEQVTatGnCBcbVCu9GhOM0SCKRwMfHB7m5uYiJiakc5U/beXh44N69e3LzSkpKYGhoCD29qmtNU1NTxMfHw9LSstbbPnPmTGVXJL6+vvjPf/6DmJgYLFu2DCkpKUrHBOe0RiYfT4PjNEgsFmPfvn1wd3fHxx9/jI0bNyotR0QQiUSNHJ1qI0aMwLVr1xTGwJBIJJXfi0QivPDCC3VKGADw8OFD6OvrQyqV4vz58xg0aBCsrKwwZMgQnjB0AH88xXEa5uLigtDQUGzevBk7d+5UWB4dHY358+cLEJlqU6ZMee6gSSKRCG+88Uadt52YmAixmF2vlpeXA2Atp06ePImBAwciOjq67gFzjUe4oWY5rnlZunQpGRgYUFRUVOW8y5cvk4mJCenr61N8fLyA0Snq1q1bjeNtGxsbU35+fp23O3XqVNLX11e6Tdn8oUOH0vnz5zVwVFwD8THCOa6x/Oc//8Frr72G8ePH4+bNm7h9+zaGDx+OsrIy6Onp/T97dx4WVdn+Afw7DPuuqAgjlTsgJW65Fi6UuKRZYZLmlsWbifpWGu6k2Vvpz0oz0HB73zIt0sxdcwsNTVHckhQVF0QEYpdlGO7fH08DjDODzjDMGfT+XNe5hjnLc+4zzJz7bM/zYNasWVKHqGH06NGwsbHROc3a2hrDhg0z6nLSxYsXoVKpdE5Tjz948CASEhIMLpvVPb4RzpgZlZaWIjg4GKmpqSgvL0dWVlblfQKZTIbjx4+jU6dOEkcpXLt2Dc2bN9d7mWrbtm0YNGiQweU2bdoUGRkZeqfLZDIsWbLE4i7ZMQBAFicNxszs4sWL6Nq1K4qKiiqv6QPi6D0oKAi//vqrhNFp6tKlCxITE7USh6urKzIzM2Fra2tQeUqlEvb29qioqNA5XSaTYenSpVwp0nJxJ0yMmVN+fj6GDx+ulTAA8WTSvn37LOpG8OjRoyGXyzXG2djYYMSIEQYnDAC4fv16jQkjNjaWE4aF46TBmJmUlZXhxRdfxPnz57UShppcLsd777133yeXzGXEiBFasSiVSrz22mtGlXf16lWd462srLBmzRqMHz/eqHKZ+XDSYMwMysvLERoaigMHDmjUdbiXSqVCUlISfv75ZzNGp1/jxo0RFBSkcbbRuHFjPPPMM0aVl5qaWvm4LSDOLqysrLBu3TqMGTOm1vGyusdJgzEzKCwsREBAANzd3SGXyzVqVd/LysoK06dP1/uEkbm9/vrrlWcbtra2GDNmTI3x1yQ1NbUyAclkMsjlcsTFxWHUqFEmi5fVLU4ajJmBu7s7Fi5ciNu3b2P16tXw9fUFAI2jbrWKigpcuXIF//3vf80dpk4vvfRSZZxlZWUICwszuqzU1FQolUpYWVnB2toaP/30EzeFXs9w0mDMjOzs7DB69GicP38e8fHxGDp0KORyuVZ9CCJCZGQkiouLJYq0iqurKwYOHAhA1G7v2LGj0WVdvHgRFRUVsLGxwfbt2zFkyBBThcnMhNueYkwivXr1Qq9evXD16lWsWLEC0dHRKCwsBBGBiJCdnY2YmBj8+9//Nsn6cnIAIiA3t+oVAFQqQF/PtPn5YnrLlqMA/IzOnUfjxx/FtAYNdC/j5ASoH6xycQGsrQFXV0AuF2caDg4O2LFjB3r37m2S7WLmxfU0GLMQhYWFWLt2LZYsWVL5lJGbmxt+//067t51xd9/A3l5Ymefn685FBSIpKB+X1ammRxq/ysvAdAUwB8A2tSiDC8A2+Dm1hNWVoC7e1VSadBAvN47uLmJ+VxdxWuTJkDjxiIhMbPjyn2MmVtBAXDjBnDrVtVw5w6QlSWGzMwKXLu2C3//vQQq1X4AcwB8WLm8egd67+DuLnawrq6AjU3VmcD9XgGxnK57246OgJ2d+Purr76qrENRXi62Q5fqSUp9ppKfD2RmpuPq1Rto0eJpjfFKpXYyzMvT/FtX4rOzAxo1EoOnp0gk6vfe3oCXF+DjI149PB7sf8Pui5MGY6ZUVgZcuwZcuSKGmzfFkJYmksONG0BhYdX89vZip+bpWbXDU+8EGzUCiosv4MiRNYiMnAsfH2cY2Aq5SZHEzberz6bu3AEyM6snWe1xaWlAUVHVsg4OgEIhkok6kTRrBrRsCbRoIQZ7e8k2rT7hpMGYoe7eBZKTgZQUkRguX65KEjduiCNoAGjYUOygmjWr2mE1a1Z1BOztzUfAdSk/XzNh37wJpKdXneXdvAncvl01v7e3ZhJp2RJo1Qrw9YWkydrCcNJgTJ+yMuDSJeDPP4Hz56te//qrKjE0aFC1k2nRAvD3B9q1Ezscd3dp42f3V1oqkoo66VcfLlwQBwiA+D+r/7fq1yefFGeEjxhOGowBQHY2cOIEkJgoXk+dEpeZiMS1cz8/ccQZEFD12qKFuHfAHk4qlfgOXLggDhaqv6ovMXp5AYGBQOfOQKdOYmjWTNq46xgnDfboKSoCjh0D/vijKlGkpoppjz1W9eNv104MLVqIx0UZU1Mnk3PnxAHGiRPirJQIaNq06jvUuTPQs6e4VPmQ4KTBHn6FhcDRo8Dhw8CRI0B8vLgs4eVV9ePu1Al4+ulH8nIDM5GCAuD0aXEQoh6Sk4GKCnHgERwsEkjv3uLgpJ7ipMEePmVlwKFDwI4dwMGDwJkz4gjQzw949lngmWeAoCBxc5qxupSdLQ5WDh0SBytJSeJx5bZtxXdxwADguecAIzpAlAonDfZwyMgAtm8Xw9694qjvySeBfv3Ej7NXL/EcP2NSKiioOtvdv19cIrWxEQcxgwcDgwaJsxILxkmD1V+3bwMbNgDffy+uKdvaAn36VP34Hn9c6ggZq1lmJrBzJ7BtG7Bnj6jI6O8PDB8OjBolnsKzMJw0WP1y9y7w88/At9+KMwonJ+Dll4GhQ8U1Y0dHqSNkzDhKpTgD+eUXYONGcfbco4dIHsOHW8zNdE4arH64dAn4v/8D1q8HSkqA/v3Fj2noUK7Jyx4+KpU4KPr2W2DzZvF+6FDg/feBLl0kDY2TBrNsx44BixaJH06LFkBEBBAWxvcn2KOjoADYtAn46itxGbZ3b2DaNHETXYJWXbK4Pw1mkY4fFz+Obt1Esw8bN4qa2JMnc8JgjxYXF2DMGPGb2L9ftKM1eDDw1FPA1q3mj4eTBrMo2dlAeLhIFjKZeGT22DHglVd0t8JaF1QqFb744gsEBgbC0dERbm5u6Nu3L3799dcHWnbGjBlo3bo17O3tMWDAgMpphYWFkMlkGkNCQsJ9y5w2bZrGMh999JHWPMePH8fYsWPRvHlzODg4oGHDhggICMDLL7+M6OhoXL58GQAQEBCgFcOIESMqywkODtaY1rlzZ611Xbt2DUOGDEH+PZ1wJCUlYdCgQXB3d4eLiwuCg4Nx5MiR+26fLjt27ECbNm109mx4Pzk5OYiJiUHfvn3RsGFDODg4oHXr1hg5ciROnz6tNX9kZCQ2btyot7xx48bBzs4OzZs3x5QpU1BSUmJwTKbSp494lPz0aVHxdMgQMfzTkr55EGMWYvVqIg8PIm9vovXrpYmhvLycBg8eTDY2NrRs2TLKysqiK1eu0Lhx40gmk9H3339f4/IrVqwgADR//nzKycnROc+pU6cIAAGgAQMG1FheVlYWOTs7EwAaOXKk1nSVSkXvv/8+WVtb07Rp0+jChQtUUlJCt2/fpj179lBwcHDlupRKJRER3b59mzw8PAgAffvtt1plbt++nVq3bk1FRUU6Y2/UqBEtW7ZMY/zRo0fJwcGBXn31Vbp16xZlZmbSm2++SdbW1rR79+4at7G6lJQUeuGFF+ipp54iV1dXksvlD7ys2htvvEHW1tb0xRdfUHp6OhUVFdFvv/1G/v7+JJfLafPmzVrrbN68Oc2ePVtvmfn5+RQTE0MAaOHChQbHVFcOHCDy9ydycCBasICovLzOV5nJSYNJ7u5dotdfJ7KyIvr3v4ny86WLZe3atQSAIiIiNMZXVFSQr68vNWjQQG8yICIKCwsjAJRfw0acOnWKHBwc6PHHHycAdPz4cb3zzpo1i/z8/PQmjZkzZxIAWrlypc7ly8vLacCAARpJg4jou+++IwDk4eFBt2/frhz/999/k4+PDx05ckSrrLy8PGrWrBmFh4drjFepVNSuXTvy8vKiu3fvaqy7bdu25OPjQyUlJXq3sbqwsDD6z3/+Q0qlkhQKhdFJ46233tIan5SURACodevWOqfJZDLauHFjjWU7OjrS888/b3BMdamsjGjRIpE4+vYlunOnTlfHSYNJq6CAqE8fooYNiXbulDoaoqFDhxIA2rNnj9a0Dz74gADQN998o3f5559//r47ulOnTpGTkxNFR0cTABo6dKjO+XJycqhhw4aViezepHHhwgWysrKiTp061bi+33//XStpEBENGTKEANDLL79cOW7kyJE0ffp0neXMmjWLrK2tKS0tTWP8gQMHdCZaIqKoqCgCQHFxcTXGqFY96RibNGri4OBAVlZWVFFRoTUtNDSUmjVrpvU5Veft7X3fz1sqp04RtWhB5OtLdPNmna0mk+9pMMmoVOL58/PngQMHgJAQqSMCMjIyAABNmjTRmubl5QUAOHz4sN7lVeo20x/AuHHjoFAo8Msvv+DMmTNa05cuXYqBAweipZ4aXitXrkRFRQVCQ0NrXE/37t1BRFr3B2JiYtCgQQP89NNPiIuLw88//4ykpCTMnz9fqwwiQmxsLLp27Qpvb2+Nafv37wcAnfc/1OP27dtXY4xqDg4ODzSfMYqKilBcXFx5X+dew4YNw82bN7F9+3a9ZchkMpSXl9dZjLURGCiaLLGyAp5/Xn/PirXFSYNJ5rPPRLLYulU8CWIJGjVqBKAqeVSXmZkJAEhVN4lbS3Z2dpg2bRqICAsXLtSYVlhYiGXLlmHmzJl6l//tt98AAE8Z+eF5eXnh888/BwC88847mDRpEtatWwc7df+u1Zw+fRoZGRlo37691rTk5GQAQDMdbYIr/mng6+LFi0bFaEo//vgjAGDWrFk6pwcGBgIAdu/ebbaYTM3LC9i9WzxQ8s47dbMOThpMEpmZwMcfA/PmidZlLUX//v0BANu2bdOatmvXLgDiiFWfsrIynTtdfd566y14enoiLi4OFy5cqBy/fPly9O3bF35+fnqXvXXrFgDAoxbd/40ZMwYDBw7EnTt30KpVK3Tq1EnnfOfOnQOgOzHk5uYCAJycnLSmOf/TEl9OTo7RMZpCRkYGIiMjMWHCBAwfPlznPOoEp95WXezs7KBUKuskRlNp1gyIiREVA0+cMH35nDSYJDZuFKfRU6ZIHYmmCRMmoFOnToiJicHy5cuRnZ2N69evY9KkSUhLSwNQ8yWU69ev69yx6uPg4IB3330XFRUV+PjjjwEAd+/exeeff673iPhete23u3Xr1gCAQ4cOYcuWLTrnSU9PBwC4GdjvKf1Td1jKvsWzs7MREhKC3r17IyYmRu98rq6ukMlklduqi7e3N9LS0iz2EpXaiy+KBjvXrDF92Zw0mCT++EO0PluHl7CNYm9vjwMHDmDKlClYvHgxvLy80LVrVxBR5eWNpk2bai33999/Y9GiRbh27RomTpxo0DonTpwIDw8PfP/990hJScGKFSvQrVu3+152Ut9byMrKMmh91cXHx2PTpk1YsmQJAOBf//qXzrMCdd0EGx1dFbr/06+trjMw9Th3ifq+LSoqQv/+/eHv74/vvvsO8vv0pmVtbY3i4mK908PDw5Gfn4+5c+fW6nM3hwEDRD8ypsZJg0kiN1f0u2yJXFxcsGjRIly9ehVlZWVIT0/H8uXLK3eAHTt21Jh/7Nix8PDwQGRkJKZPn47JkycbtD5nZ2dMnToVKpUK8+bNw+LFizF79uz7LhcUFAQAOm+iP4jCwkKMHTsWK1euxL///W8MGDAAt2/fxhQdp3/2/zTwpevSjK+vLwDg5s2bWtPUZ2dt2rQxKsbaKC8vR2hoKBQKBdatW3ffhKFepqYzyVGjRmHhwoVYtGgRGjdujBBLeHpDjwYNgLq4KshJg0lCoQBSUqSOwjDqp6ZeeukljfFr165FXl4eNmzYgCVLliA8PNzgsiMiIuDm5ob169ejffv2Op9Euld4eDisra0RFxdX43zTp0+HlZVV5Q1rtffeew/BwcGVO74VK1bA1dUV//vf/7Tu6aifHMvLy9Mqv0+fPgCAxMRErWnqcf369bvv9phaeHg4SktL8cMPP2g8OdaqVSsc1XEInp+fDyKq3FZdZs2ahZkzZyI6Ohq5ubmV97ksUUpKHfUQWGdP8zJWg19+EZX5UlKkjkRTZmYmyWQyrboIeXl51LRpUxoxYkSNy3fp0oUaNGhQ4zzqehr3+vDDD8nNzU2rYl18fLzeyn0LFiwgALRq1Sqd60pOTiZXV1d69dVXNcbv2rWLmjdvrlUJceXKlQSAvL29NSoxqmuxT5w4UWsdKpWK/P39ydvbm4qLiyvHl5eXk5+fH/n4+GiMf1C1qacxb9486tq1KxUUFGhNa9myJSUkJGiN//PPPwkAvf3223rL9fX1pebNmxsVkzkVFhI1akT0yScmL5or9zFplJUR+fkRDRkidSSaMjMzCQA9//zzdOnSJSopKaFjx45R9+7dqX379pSdnV3j8v369Xvgyn0PqqakQUQUGRlJNjY29MEHH9Bff/1FpaWldPPmTYqNjSUvLy/q1asXFRYWVs6fk5NDPj4+dODAAZ3lqZseGTt2bOW4iooKatKkCfXs2VPnMgkJCWRvb08jRoyg9PR0ysrKovDwcLK2tqZdu3ZpzT9y5EgCQFeuXNG73Q+SNHSVs2bNmsqmU/QNupLG+vXrCYBWMyP3xtS+ffsaY7IE06cTubvXSe1wThpMOgcOEFlb18nRUK3s3buXhgwZQk2bNiUHBwcKCAigBQsWaNRW1ic4OLjGHZ2Tk5PGzqt///41lqdrh3dvu09ERH/88Qe9/vrr5OPjQzY2NuTi4kLdunWjL7/8kkpLSyvnUygUGmVVr42ek5Ojc32ff/45EYkmS3TVCFc7efIkDRgwgFxdXcnZ2Zn69u1Lhw8f1jlv3759ydnZmcrvaSxp69atenf0umri6ypn0KBBRiWN0NBQUigUVFZWpjNm9ecXGBiod7ol2LxZnMXraVmmtjhpMGktXUokk4m2cx4GgwYNIplMJnUYdSI3N5cUCoVW21OGysnJIQcHB5owYYJFlENU1fbU/Rqk9PT0pG7dutV6fXXlp5+IbG2JarjCVlucNJj0vvxSHBmNHSsaL6zPwsPDCYBGI4APk5MnT5KHhwd99dVXRi1fUVFBr7/+Onl6elJ6errRcZiqHCKiy5cvU4sWLWjmzJk1zldWVkY2Njb0yiuv1Gp9dUGlIpo3T/yOIiKIdDStZSrc9hST3uTJoimRX34BAgIAHZWx6w31k0iffPIJsrOzJY7G9Dp06IATJ05g586dWv1pPIiMjAxcuXIF+/bt01nfxdzlAOKpsYULF2o15VJdXl4elixZAqVSaXGP2Z48CfTsCXzyCbBkCbB0aR336Fdn+YgxA6WniybSZTKiwYOJarhHatE+/fRT8vPzIzs7OwoJCZE6HFZLY8aMIRsbG2rVqhXNmTNH6z6MVHJyiCZPJpLLiZ59lujsWbOsNpP7CGcW58AB0dhaaiowdizw7rtAq1ZSR8WYZcjIEP2Ff/01YGcHLF4MhIWZrb9w7iOcWZ4+fUR3losXA3v2AG3bAqGhottXxh5VFy+KrpCfeAJYuRKYOhVITgZee81sCQMAwGcazKKpVMCmTcCiRcDx46Lv8NGjgVdfBRo2lDo6xurW3bvA5s3A//4H7N0LtGwJvPee+A1I1G5bFicNVm8cOgTExoofkVIJDBwofjwDB4rTdMYeBhUV4hLt//4nDphKSkQHZePHA0OGiNahJcRJg9U/hYXix/S//wH79wNubuJHNXiweOUzEFbfFBUB+/YB27eLpwdv3RL9zIwaBYwYATRuLHWElThpsPotLQ344QfxQ4uPF0dpPXoAgwaJISBA6ggZ0y01tSpJHDwIlJUBnTuLg5/hw8W9PAvESYM9PIqKxJnHtm1VR2uenkCXLkCvXkBwMNChg+Sn9+wRdesWcOQI8Ouvoi/vP/8EHB2Bvn2BF14QyeKe7tctEScN9nCqqBA3zg8eFGcghw8DeXni0lWvXkBQENC1KxAYCOjopZSxWikrA86dE0/8xceL+3G3bomb1127iu9fUJColGdrK3W0BuGkwR4NKpV4jPe338QQHw9kZQFyOeDrC3TqJC4NdOokEomjo9QRs/pCqQTOngUSE6uGM2dE4nBxEZdLn31WDF261PuHNjhpsEfX1aviB37iRNWPPSenKpEEBADt2gF+fuK1VStAR2+n7BFRUSG+M3/+WTWcPy8SRlkZ4OwsDjg6daoa2rYV36eHCCcNxqq7ckUkj5Mnq3YKV6+KHYaNDdCmDeDvL4Y2bYAWLcTQpInUkTNTyc0FLl8W34WUFPEduHBBDOruwx97rOpgQp0oHsIEoQsnDcbup6Skaqdx7pyohXvunHj6Rd1ltotLVQJRDy1bAj4+QLNmgKurpJvAqikuBm7cAG7eFInhypWqJHHlCvD332I+uVz8/9TJwc9PnH36+j7S/09OGowZS6USOx/1zkbfzgcQly58fMTTMQqFSCTe3mKcpyfQtCnQqBHflK+NkhJxnyozU9x0TksTrzduiNebN8W4nJyqZXQle/XwxBP17ia1OXDSYKyu5OWJHdaNG0B6unhV78iuXxfjsrI0l3FwEMmjcWNxycvR8SYee0yBRo1kaNQIcHcXR7n3Dg0aSLONdSE/v2rIy6v6OydHDHfuiM8tO1u8ZmSI18JCzXJcXUVyVifoxx4DvLyqxikUFlVprr7gpMGYlEpKRPJQ7wjVQ2YmcO7cEezdOxQ+Pgshl4cjK0vsRFUq3WW5uora8a6ugL29OGuxtRVnOTY2+l8B0eCdu7t2mVZWosx7FRZWXZqrrqAAKC8Xf6tUYmd/v9eyMs3EoE+DBiLGJk1EYlUP6gTr4VE1TqHgs7Y6wkmDMUu0efNmjBw5Es8//zzWr18Px2rPABcWah6Nq3e21d8XF4vG7kpLRaXHsrKqHb36tfoOXj3+XqWlohygBMB/AQwG4A17e90N5jk4iIQFVCUideK5du0T2NmVIyBgNlxdAWtrcXnI1lbzjKn6GZQ6CT7C9xAsDScNxizN8uXLMXnyZEycOBFffPEF5BbwSE5mZiaaNGmC/fv3o0+fPkaVsXjxYsydOxfJycl47LHHTBwhMxPuT4MxS/Lpp58iIiICCxcuxLJlyywiYZjK5MmT4e3tjTlz5kgdCqsFThqMWYhPP/0UM2bMwJIlSxAZGSl1OCZna2uLhQsX4ttvv0ViYqLU4TAjcdJgzAJERkZi1qxZWL16NaZOnSp1OHVm+PDh6N69O95//32pQ2FG4qTBmMSioqKwaNEirF27FmPHjpU6nDolk8nw2Wef4dChQ9i6davU4TAjcNJgTEKff/455s+fj6+//hqjRo2SOhyz6NGjB1588UVERUWBn8OpfzhpMCaRlStX4r333sPSpUsRHh4udThmNXfuXJw6dQrbt2+XOhRmIE4ajElg586deOeddzBv3jxMmjRJ6nDMLjAwEIMHD+azjXqIkwZjZnb27FmEhYVh+PDhmDt3rtThSCYqKgonT57E3r17pQ6FGYCTBmNmlJ6ejpCQEDz99NNYu3YtZDKZ1CFJpmPHjggJCUFUVJTUoTADcNJgzEyUSiWGDx8OZ2dn/Pjjj7DhHp0wZ84cJCQk4MCBA1KHwh4QJw3GzOTdd99FUlISNm3aBDddrQA+grp3746goCAsXbpU6lDYA+KkwZgZfP/991i+fDlWr16Ndu3aSR2ORXn77bexdetWXLt2TepQ2APgpMFYHbt+/TomTpyIiIgIhIaGSh2OxXnppZfg6emJ1atXSx0KewCcNBirQxUVFRg3bhy8vLzwySefSB2ORbKxscG4ceOwcuVKKHV10sEsCicNxurQF198gfj4eHz77bdw0NUBBQMAhIeHIzMzE1u2bJE6FHYfnDQYqyOpqamYM2cO5s6di44dO0odjkXz8fHBwIEDER0dLXUo7D44aTBWR6ZOnQqFQoFp06ZJHUq98Oabb+LAgQO4fv261KGwGnDSYKwO7N69G1u2bMHSpUthZ2cndTj1QkhICBo0aICNGzdKHQqrAScNxkxMqVRi0qRJGD58OEJCQqQOp96wsbHBsGHDOGlYOE4ajJnYunXrcP36dXz66adSh1LvhIaGIjExketsWDBOGoyZkFKpxMcff4zx48fjiSeekDqceqdPnz5wcXHBjh07pA6F6cFJgzETWr16NdLS0vDBBx9IHUq9ZGtri379+nHSsGCcNBgzkYqKCixevJjPMmopJCQEBw8ehEqlkjoUpgMnDcZMZO/evUhJScE777xjdBlJSUkYNGgQ3N3d4eLiguDgYBw5csSEUUprx44daNOmDaytrfXO061bNxQWFuLChQsGlZ2Tk4OYmBj07dsXDRs2hIODA1q3bo2RI0fi9OnTtQ2d/YOTBmMmEhsbi2effRYBAQFGLX/s2DH06NEDLi4uuHDhAq5evYoWLVqgd+/e2LNnj4mjNa/Lly9jyJAhmDFjBjIyMmqcNyAgAI6Ojjh+/LhB65g2bRoiIiIwdOhQ/Pnnn8jOzsbq1auRlJSETp064eeff67NJrB/cNJgzARKS0uxe/duhIWFGbV8RUUF3njjDbi7u2PNmjXw8vJCo0aNEB0djZYtW2LChAkoLS01cdTmM2fOHPTo0QOJiYlwcXGpcV65XI727dvjxIkTBq9n/PjxmDJlCpo2bQpHR0c888wzWL9+PVQqFaZPn25s+Kwa/eeIjLEHdvDgQRQUFGDQoEFGLf/bb7/h/OrnUJAAACAASURBVPnziIiI0GijSi6XIywsDFFRUdi2bRtefvllU4VsVqtWrTKo7a327dvj/PnzBq0jNjZWb1kODg64fPkyiOiR7i3RFPhMgzETiI+Ph6+vL3x8fIxafv/+/QCAzp07a01Tj9u3b5/xAUrM0MYaFQoFbt26ZZJ1FxUVobi4GAEBAZwwTICTBmMmcPLkSa0dfnJyMl588UW4ubnB0dERTz/9NLZt24bg4GDIZDLIZDJMmDChcl4AaNasmVbZCoUCAHDx4sU63ooHZ8i2GcPLywvp6ekmWc+PP/4IAJg1a5bR8bAqfHmKMRM4d+4cIiIiKt+npKSge/fucHJyQlxcHLp3745r165h6tSpOHPmDOzs7FBSUlI5f25uLgDAyclJq2xnZ2cA4ukgS2DothmjadOmKCwsRLdu3eDs7Gz0ejIyMhAZGYkJEyZg+PDhtYqJCZw0GKslIsLt27c1zhJmzpyJ3NxcxMbG4rnnngMAtGvXDuvXrze4DgcRAYDFXFox5bbp4+HhAQDIy8vDqlWrjFpPdnY2QkJC0Lt3b8TExJgkLsaXpxirtZycHCiVSjRp0qRy3K5duwAA/fv315i3cePG8PX11SrD3d0dgLj+fi/1OPU8UjN022rLmPUUFRWhf//+8Pf3x3fffQe5XG7yuB5VnDQYq6WysjIAgL29PQDx+G1BQQHs7e0rLy1V16BBA61x6p3gzZs3taalpaUBANq0aWOymI2lVCoN3jZj1wMAdnZ2Bq+nvLwcoaGhUCgUWLduHScME+OkwVgtqS8bqS8j2dnZwcXFBSUlJSgsLNSa/86dO1rj+vTpAwBITEzUmqYe169fP5PFbCwbGxuDt80Y6hrjpaWlBq8nPDwcpaWl+OGHHzRqnrdq1QpHjx41SXyPMk4ajNWS+nHS6ju3AQMGAKi6lKN2+/ZtnU9BBQUFwd/fH3FxcRo3d1UqFTZs2AAfHx+j64CYmqHbZgz12Zuh64mKisL58+exZcsW7vyqrhBjrNacnZ1p1apVle9TUlKoYcOGpFAoaM+ePVRQUEBnz56lkJAQevzxx8nOzk6rjISEBLK3t6cRI0ZQeno6ZWVlUXh4OFlbW9OuXbvMuTla7ty5QwBo//79Rm1bdQqFguRyeY3zbNiwgeRyuUHrWbNmDQGocUhISKj1Z/GIy+QzDcZMQKFQaPRt3bJlSyQkJKBLly545ZVX4OnpifDwcMyYMQOtWrXSWUa3bt3w+++/Iy8vD23btsUTTzyBS5cu4eDBg1o3g6VkzLZt27atsl5FWloaVCpV5XtdNbkzMjLQuHFjg9YTFxdn8m1l2viRW8ZM4Mknn9RqSbVNmzbYvHmzQeV06NChXvQlYei2DR48uPKez4PIyMiAp6enQevZtm3bA5fPjMdnGoyZQIcOHXDy5Empw3ho3Lhxo7ImPLMsnDQYM4FnnnkG169fR0pKitShPBTOnj2Ldu3aSR0G04GTBmMm0L17d7i5uWk96VPdhg0bIJPJsG/fPpSWlta6fSZLYsptU6lU+Ouvv3T2S/Iwf4b1hYwMudDIGNMrLCwMt27dwqFDh6QOxeQyMzPRpEkT7N+/v7JOSV1JTk6Gn58fTp48iQ4dOtTpupjBsvhMgzETGTlyJOLj43H16lWpQ6nXEhMTYWtrCz8/P6lDYTpw0mDMRPr37w9PT0+9nQGxB3Po0CF06dKlslkWZlk4aTBmIjY2Npg4cSKio6N1NjzIHszBgwfRu3dvqcNgenDSYMyE3n77bZSWlnJT3EZKT0/HpUuXEBQUJHUoTA9OGoyZUKNGjfDee+/ho48+QlZWltTh1Du7d++Gvb09evToIXUoTA9OGoyZ2PTp0+Hg4IAPP/xQ6lDqnU2bNiE4OFhnD4bMMnDSYMzEnJ2dsWDBAsTExOD8+fNSh1NvFBYW4tdff8WwYcOkDoXVgJMGY3Vg3LhxCAgIwLvvvmtQm0uPst27d6OsrAwvvPCC1KGwGnDSYKwOWFlZYfny5di/fz+WL18udTj1wvr16xEUFITGjRtLHQqrAScNxupIjx49MGvWLEybNg1nzpyROhyLkZqail69euHAgQOV47Kzs7F9+3aMHTtWusDYA+FmRBirQ+Xl5QgKCkJeXh6OHz9e2cufpevYsSMuXbqkMa6kpAS2trawsqo61nR0dMTFixfh5ub2wGUfPHiwsimSvn37YsGCBTh+/Dhmz56N9PR0nX2CM4uRxf1pMFaHrK2t8e233yIwMBAffPABli5dqjVPdnY2HBwc4OjoKEGEug0YMABJSUla92PKy8sr/5bJZHj22WcNShgAcPXqVcjlcqhUKsTHx6Nnz55wd3fHM888wwmjHuDLU4zVsebNm2PFihX46quv8M0332hMKywsREhICJYtWyZRdLqNGjXqvjfwZTIZXn/9dYPLvnbtGqytxfGqUqkEID6HnTt3olu3bti/f7/hATPzka6rWcYeLfPmzSNra2vas2cPERGVlJRQUFAQASAXFxfKzc2VOEJNvr6+Nfa3bW9vTwUFBQaXO2bMGJLL5TrLVI/v3bs3xcfH18FWsVriPsIZM5d58+YhLCwMr7zyCk6fPo2wsDAcOXIEAFBcXIzFixdLHKGm0aNHw8bGRuc0a2trDBs2zKjLSRcvXoRKpdI5TT3+4MGDSEhIMLhsVvf4RjhjZlRaWorg4GCcO3cOBQUFGjtPe3t7pKamwtPTU8IIq1y7dg3NmzfXe5lq27ZtGDRokMHlNm3aFBkZGXqny2QyLFmyBFOnTjW4bFbnuD8NxszJzs4OTz31FPLy8rSOtlUqFT7++GOJItP2+OOPo1OnTpDJZFrTXF1d8dxzzxlcplKpRGZmpt7pMpkMS5cu5YRhwThpMGZGUVFRiI6O1nn0rlQq8fXXX1tUJ06jR4+GXC7XGGdjY4MRI0bA1tbW4PKuX7+OiooKndNkMhliY2MxadIko2Jl5sFJgzEzWbZsGT788MMan0qSyWSYP3++GaOq2YgRI7TiVSqVeO2114wqT19CtLKywpo1azB+/HijymXmw0mDMTPYsmULpkyZovNST3VKpRL//e9/kZycbKbIata4cWMEBQVpnG00btwYzzzzjFHlpaamVj5uC4gkaWVlhXXr1mHMmDG1jpfVPU4ajJnBCy+8gD179qB///6QyWR6n0oCALlcjlmzZpkxupq9/vrrlWcbtra2GDNmjEatcEOkpqZWJiCZTAa5XI64uDiMGjXKZPGyusVJgzEzsLKyQnBwMHbu3ImTJ09i7NixsLW11XlfQKlUYvPmzfjjjz8kiFTbSy+9VHl2UFZWhrCwMKPLSk1NhVKphJWVFaytrfHTTz9xU+j1DCcNxswsMDAQK1euxI0bNzB//nw0btwYVlZWGkfvlnS24erqioEDBwIQtds7duxodFkXL15ERUUFbGxssH37dgwZMsRUYTIz4XoajEmspKQE69evx+LFi3HhwgXY2NhUNq9x8ODBWveXTQTk5oq/c3LEa14eoH6IqaAAqNaklM7ljh37Cf/3f68gNHQeQkOjAACursA9D1YBAGQywN296r27uxjn5gb4+jb5p8mQHejdu3ettotJIouTBmMWZN++fViyZAl27twJIoK/fxd88cUfyM0F8vPFDr6wULxWH6ce8vIApVLMo1KJ6aZRAqApgD8AtKlFGV4AtgHoCScnwNYWcHAA7O0BZ2fAxaVqaNBA872Li0hArq4iAXl4AI0bayYoVuc4aTBmDsXFQFoacPs2cOsWkJ4OZGUB2dlAZmbV3+qhtPQigC8BrAOwAcBguLpW7VidnTV3qurxDRqIo39XV80j/upH+1ZWYl71Q0z29mLHrUv1+b766qvKOhTVz0LuVVYGFBVBa77Ll9Nx584NeHk9jYqKqjOcwkKR6KonwMLCqqSoTpLqRHkva2uRQNRDo0ZVCaVRI8DTE2jWTLwqFGKbmNE4aTBWW3l5wNWrQGqqGNTJoXqSyMurmt/KSuzA7t25Vd/hqQd7+1xcunQUL78cItXmVSKi+z4ybA7q5JGVJRJudrZ20lVPy8oCMjJEUlJzdNRMIk2bivePPQY88YQYuPNAvThpMHY/SiVw5Qpw6ZJmclD/rb5PAABeXoC3t+brveM8PXXfC2B1gwi4c6cqkWdkADdvar7euCHO/tT3eZydRfJo3lwM6mTSogXQtq04O3tEcdJgTC03F7h8WSSI8+eBP/+s+rukRMzToIHYcagTQIsWVUObNnzpoz5TKkXyUF8+vHJFc0hNrUoqXl5Au3bi/+7vX/V38+biMuBDjJMGe/SUlwN//QUkJYnh1CngzBlxOQMQ1/fbthWDr68Y2rYFWrcWR6Ds0VRSIg4qkpPF9yc5WQwXL1ZdfnR3FwmkQwcgMFAMAQGAnZ20sZsQJw32cCsvF4nhxAmRHJKSgLNnxY1pW1vxAw8MBJ56CvDzE8nh8ccf+qNFZmLp6VXJ5MwZ8V07e1Y8EGBjI75bgYEimXTqBHTurP/hAwvHSYM9XAoKgGPHgMOHgcREID5eHAW6uIjE0K6duJyg/uE+wtemmRncuiW+h+rhxAlxb8XaWlzO7NUL6NkTePZZcc+kHuCkweq3nBzg11+BvXuBI0eACxfEjc+2bYHu3cUPskcPcaTHZw/MEqSmiu9qQoJ4PXtW1Klp3lx8X/v1A/r3F/dNLBAnDVa/qFTiaG33bmDXLkDdPNPTT4ujtR49RLLgRyZZfaE+O/79d3FmfPgwUFoqzoz79xdDz54Wc1+EkwazfGVlwJ49wMaNwM6d4jn8Zs2qflDBweKpJsYeBnfvAr/9Jg6Kdu8W90qcnMT3PDQUGDpU0gcyOGkwy6RSAfv2iUSxebN4HLZnT2DYMJEo2rWTOkLGzOPaNZE8tmwRl2GtrYFBg4ARI4CBA81+Q52TBrMsV68Cy5cD//2veAT26aeBV18VR1g+PlJHx5i0/v4b2LQJ2LABOHhQ1G4PDQUiIsTTWWbASYNZhoMHgaVLgV9+EU07vPUWEBYmKkwxxrRlZAA//gisWAGcOwcEBQGTJ4vLV3XY4kAW96fBJLV5M9C+PdCnjziz+P57UYFq1ixOGIzVxNMTmDRJPH3166+iMcrQUKBlSyAmRndz96bASYNJ4tQpkSheflk8DnvihHhyJDS0qlVVc9qxYwfatGmj0X+1PklJSRg0aBDc3d3h4uKC4OBgHDly5L7LqVQqzJgxA61bt4a9vT0GDBhQOa2wsBAymUxjSEhIuG+Z06ZN01jmo48+0prn+PHjGDt2LJo3bw4HBwc0bNgQAQEBePnllxEdHY3Lly/j6NGjWut3v6fN8Z9//llj+uDBgzWmX7t2DUOGDEH+Pe2xG/t56WLI/+leOTk5iImJQd++fdGwYUM4ODigdevWGDlyJE6fPq01f2RkJDZu3Ki3vHHjxsHOzg7NmzfHlClTUKJua0YC/fqJex4XLwJDhgBTpoiKhHv21MHKiDEzys4mGj+eyMqKqHt3oqNHpY0nJSWFXnjhBXrqqafI1dWV5HJ5jfMfPXqUHBwc6NVXX6Vbt25RZmYmvfnmm2RtbU27d++ucdkVK1YQAJo/fz7l5OTonOfUqVMEgADQgAEDaiwvKyuLnJ2dCQCNHDlSa7pKpaL333+frK2tadq0aXThwgUqKSmh27dv0549eyg4OLhyXUqlkoiIxo0bRwBo9OjROtd58+ZN8vT0pNTUVK24GzVqRMuWLdMYX5vPqzpD/0+6vPHGG2RtbU1ffPEFpaenU1FREf3222/k7+9PcrmcNm/erLXO5s2b0+zZs/WWmZ+fTzExMQSAFi5caHBMdeXSJaIXXyQCiAYOJLp82WRFZ3LSYGYTH0/k40OkUBB9/z1RRYXUERGFhYXRf/7zH1IqlaRQKGrcGalUKmrXrh15eXnR3bt3K8eXl5dT27ZtycfHh0pKSmpcFwDKz8/XO8+pU6fIwcGBHn/8cQJAx48f1zvvrFmzyM/PT2/SmDlzJgGglStX6ly+vLycBgwYoJE0srKyyMPDgwDQoUOHtJZ55ZVX6D//+Y/GuLy8PGrWrBmFh4drjK/t51WdIf8nfd544w166623tMYnJSURAGrdurXOaTKZjDZu3Fhj2Y6OjvT8888bHFNd27+f6MknidzciO6zCQ+KkwYzjx9+ILKzIxoyhCgrS+poqlTfmd1vZ3TgwAECQBEREVrToqKiCADFxcXpXf7555+/787u1KlT5OTkRNHR0QSAhg4dqnO+nJwcatiwIa1du1Zn0rhw4QJZWVlRp06dalzf77//rpE0iIhiY2MJALVr147Kysoqx+/cuZP8/f01xhGJ5GVtbU1paWka42v7eVVnyP/JGA4ODmRlZUUVOo5kQkNDqVmzZhqf0b28vb3v+1lLpbiY6J13iGQyonvyvTEy+Z4Gq3O//CKehPrXv8SNbw8PqSOq4mDAQ+779+8HAHTu3Flrmnrcvn379C6vUqkeeF3jxo2DQqHAL7/8gjNnzmhNX7p0KQYOHIiWLVvqXH7lypWoqKhAaGhojevp3r07iEjjHsH48ePRs2dPnD9/Hp9//jkA0Y95REQEvv76a9jY2FTOS0SIjY1F165d4e3trVF2bT+v6gz5PxmqqKgIxcXFCAgI0NnJ1LBhw3Dz5k1s375dbxkymQzldXXnuZbs7YGvvgKWLRMPmCxaVLvyOGmwOnXlCvDaa8AbbwBffCF6rauvkpOTAQDNmjXTmqZQKAAAFy9eNMm67OzsMG3aNBARFi5cqDGtsLAQy5Ytw8yZM/Uu/9tvvwEAnnrqKYPXLZPJEB0dDWtra8yfPx/Xr1/Hxx9/jB49eiAoKEhj3tOnTyMjIwPt27fXKsecn1dt/PjjjwCAWbNm6Zwe+E8FiN27d5stprrwzjvAkiVAZCTwTz43Sj3+CbP64N13RUNsX30ldSS1l/tPB9VOTk5a05z/adchp3o3fvcoKyuDnQENCL311lvw9PREXFwcLly4UDl++fLl6Nu3L/z8/PQue+vWLQCAh5GndU8++SSmTp2KoqIijBw5Et988w0W6ThEPXfuHADdiaG2n5c5ZGRkIDIyEhMmTMDw4cN1zqNOcOpt1cXOzg7K6n3KWqgpU0Q9jokTqzqUMhQnDVZnbt0Ctm0DoqJEnwIPM/qnjmxNfWhfv35d585VHwcHB7z77ruoqKjAxx9/DAC4e/cuPv/8c71HxfeqTZ/eUVFR8PHxweHDhzF79mw0adJEa5709HQAgJubm0FlP8jnVdeys7MREhKC3r17IyYmRu98rq6ukMlklduqi7e3N9LS0iz2ElV1H38s+v04cMC45TlpsDpz7JhopnzgQKkjMQ11vYWioiKtaepx99ZtAIC///4bixYtwrVr1zBx4kSD1jlx4kR4eHjg+++/R0pKClasWIFu3brd97KT+v5CVlaWQeurzsnJCc8++ywA6Lz8BKCyboKNjqMCYz8vcygqKkL//v3h7++P7777DvL7VKG2trZGcXGx3unh4eHIz8/H3Llza/WZm4Ovr+iF8gGqAenESYPVmdxc0TZOPe2hTIuvry8A4ObNm1rT0tLSAABt2rTRGD927Fh4eHggMjIS06dPx+TJkw1ap7OzM6ZOnQqVSoV58+Zh8eLFmD179n2XU9970HUT3ZTs/+nFStelGWM+L3MoLy9HaGgoFAoF1q1bd9+EoV6mppvxo0aNwsKFC7Fo0SI0btwYISEhpgzZ5Dw8RDtWxuCkweqMjw9QWCguUz0M+vTpAwBITEzUmqYe169fP43xa9euRV5eHjZs2IAlS5YgPDzc4PVGRETAzc0N69evR/v27XU+jXSv8PBwWFtbIy4ursb5pk+fDisrq8qb1oby+qenoDx1J9nVGPN5mUN4eDhKS0vxww8/aDw11qpVKxw9elRr/vz8fBBR5bbqMmvWLMycORPR0dHIzc3Frl276iR2U1CpgJQU0a2xUWr91C5jehQXE7m7E330kdSRPJgHqdzn7+9P3t7eVFxcXDm+vLyc/Pz8yMfHR2P8vbp06UINGjSoMQZ1PY17ffjhh+Tm5kZHjhzRGB8fH6+3ct+CBQsIAK1atUrnupKTk8nV1ZVeffVVvfGMHDmSAFB8fLzeeAHQxIkTtabV9vPSpzb1NObNm0ddu3algoICrWktW7akhIQErfF//vknAaC3335bb7m+vr7UvHlzo2Iyt82bRZ2NlBSjFufKfaxuRUURubgQXbkidST39yA7o4SEBLK3t6cRI0ZQeno6ZWVlUXh4OFlbW9OuXbtqXLZfv34PXLnvQdWUNIiIIiMjycbGhj744AP666+/qLS0lG7evEmxsbHk5eVFvXr1osLCQr3l3y9pVFRUUJMmTahnz546pxv6eanXd6WGL8yD/J90lbNmzZrKZlP0DbqSxvr16wmAVjMj98bUvn37GmOyBHl5RC1bEg0fbnQRnDRY3SouJurQgcjf37Jqgqtt3bpV7w7km2++0bnMyZMnacCAAeTq6krOzs7Ut29fOnz48H3XFRwcXOPOzsnJSWP9/fv3r7E8XTHf2/YTEdEff/xBr7/+Ovn4+JCNjQ25uLhQt27d6Msvv6TS0lKdZatrpN876KoVPXPmTJ01wtUM+bz69u1Lzs7OVF5erjHe0P+TrnIGDRpkVNIIDQ0lhUKhVRO+OoVCQYGBgXqnW4LSUqKQECIvL6Jbt4wuhpMGq3tpaURPPEHk50d0Tzt3j5RBgwaRTCaTOgyTy83NJYVCodX2lKFycnLIwcGBJkyYYBHlEFW1PfX999/XOJ+npyd169at1uurKzk5RH37ijaoTpyoVVHcjAire97ewJEjoq5Gx46iKZFHUbNmzUBEyMjIkDoUk3Jzc8PWrVsRFxeH5cuXG1UGEWHy5MlwdXXFggULjI7FVOUAwJUrV/DSSy9hxowZGDFihN75lEol/v77b4Pq4JjTsWPid5ecDBw6BHTqVLvyOGkws/D2Fl/eUaOAl14CnnsOOH9e6qjMS/0Y5ieffILs7GyJozGtDh064MSJE9i5c6dWfxoPIiMjA1euXMG+ffvQtGlTo+MwVTkAsGLFCixcuFCrGZfq8vLysGTJEiiVSot7zDY7W9QA79lTdMx04oTo8KzWTHHqw5gh9u0jat+eyMaG6K23iDIzpY7IfD799FPy8/MjOzs7CgkJkTocVgtjxowhGxsbatWqFc2ZM0frPoxUysqIvvhCXIpSKIhWrCBSqUxWfCb3Ec4koVIBsbHA3LmAUglMmCAaVDP62XHGHnHZ2eI3tXy5+Hv6dGDaNFHB1oSyOGkwSeXlAV9/LYb0dODFF4GICOCexlQZY3qcPSuaPf/2W8DOTrQoPXUqUEe3WDhpMMugVAKbNgFLlwK//w4EBIg+OF59VVyPZYxVuX0biIsDNmwQD5n4+QGTJwOvvw7oaFTYlDhpMMtz4gSwZo34Udy5A3TpIpLH8OGiaRLGHkXZ2eLAasMG8RSUo6No5nz0aCA4GDBTg8GcNJjlUqlEZzEbN4ofS24u0Lkz0L+/GLp1A6o1HcTYQ4UIOH0a2L1bDIcPi+/74MHiIGrgQEkaA+WkweqHsjJg717RP8fu3cDVq4CbmzjC6t8feP55vonO6r/MTPE9370b2LNHXIby9BSPqA8aJBLGP/1XSYWTBqufrlwBfv1VDLt3A/n5gJeXqLjUq5d4Nv3ppwFbW6kjZUy/K1fEGURiorg3ceqUuMwUGCgSxAsvAB06WFQ3yZw0WP1XWio6lDl8WNxE//138VSWiwvQtWtVAunQQSQWxqSQkyOSwvHjVd/TrCxxb6JzZ3Gw06OHeHJQ4rOJmnDSYA+figrgzz/FkduRI+LHefmymObpKY7iAgNFEgkMFL2YWdCRHHsIpKYCSUmaw7VrYpqXlziQ6dkT6N5dNPFRj7pD5qTBHg3qo7zqP+ILF4DycvGIYrt2gL8/0LatGPz8xKO+9ejHzMxMpRKJ4K+/xEHKxYuifaezZ8X3zcpKfIeqH6AEBtb7s11OGuzRVVoKnDsnksm5c+IH/9dfYkdAJJ5UadFCJJC2bYE2bYAnnhCDjw/fL3kUqFRAWpo4c0hNBS5dEt8R9VBaKubz8hJ9b7dtK+oYBQYCTz0lLpE+ZDhpMHavu3erdgrJyVXJ5NIloKhIzGNlBSgUVUmkefOqv728RFKp40pWzASKi0V3xOnp4ok8dXJQDzduiIqnAGBvLw4i1MnB17fqbzc36bbBzDhpMGaIzEztHYt6uHpV7ITUnJxE8vD0FE06NG0qXtXvGzUCPDzEIJdLsTUPr6wsURkuK0s8tpqWJhLDrVtVSeLWLXEZSc3WVjy2rU7+1Yfmzev9ZSVT4aTBmCllZIgdUlqa5s6q+vs7d8S9lOoaNNBMIh4emu9dXcWlDvXg7i7GOTuLI+CHjVIJFBSICp35+UBhoXivHpebKxJ4drbuoaKiqiyZTCTq6slboah69fISTfd7efEDEQ+AkwZj5lZRIZKL+khY/ar+Wz2kpiYgI+MQKioikZ+vnWjUbGw0E4lcXvXq7CymOzmJI2kHB5Fk7Ow0Wz91dBTjdJWt6/HP4mKgpER7fHm52LGrlZaKy31Kpdjxq6dXVIjHogFxtE8kEoE6MegqGxAJwN1dDDUl2caNq/729OQHGkyIkwZjlmjLli147bXXEBwcjE2bNkEul6O4WPNoOz+/6n1BgdgJ5+WJHXJurtgR5+eLm7kFBWKHXVQkatffu9NXL3evu3fVN3tLAPwXwGAA3nqTCSDOmtTU88nlwN9/fwKgHB06zNaYz81NHOG7u2ueTbm4iHmqv7fg+guPCk4ajFmamJgYTJo0CW+++Sa++uoryC3ghkdmZiaaNGmC/fv3o0+fPkaVsXjxYsydOxfJycl47LHHTBwhM5MsvoLHmAX57LPPMHHiRERFRSE6OtoiEoapTJ48Td7ZvwAAIABJREFUGd7e3pgzZ47UobBa4KTBmIX49NNPERkZic8//xyzZ8+WOhyTs7W1xcKFC/Htt98iMTFR6nCYkThpMGYBZs6ciZkzZ2LlypWYMmWK1OHUmeHDh6N79+54//33pQ6FGYmTBmMSmz9/Pj799FOsWbMGEyZMkDqcOiWTyfDZZ5/h0KFD2Lp1q9ThMCNw0mBMQkuXLkVUVBS+/vprjB49WupwzKJHjx548cUXERUVBX4Op/7hpMGYRGJjYzF16lQsWbIE4eHhUodjVnPnzsWpU6ewfft2qUNhBuKkwZgEdu3ahbfffhtz587F1KlTpQ7H7AIDAzF48GA+26iHOGkwZmbnz5/HiBEjEBoainnz5kkdjmSioqJw8uRJ7N27V+pQmAE4aTBmRunp6QgJCUGnTp2wdu1ayGQyqUOSTMeOHRESEoKoqCipQ2EG4KTBmJkolUoMHz4cTk5O+Omnn2DLHXJgzpw5SEhIwIEDB6QOhT0gThqMmcn777+PpKQk/PTTT3B3d5c6HIvQvXt3BAUFYenSpVKHwh4QJw3GzGDDhg1YtmwZYmNj0a5dO6nDsShvv/02tm7dimvqTrSZReOkwVgdu379Ov71r38hIiICr776qtThWJyXXnoJnp6eWL16tdShsAfASYOxOlRRUYGxY8fC29sbn3zyidThWCQbGxuMGzcOK1euhFLdtyqzWJw0GKtDX375JeLj47Fu3To4ODhIHY7FCg8PR2ZmJrZs2SJ1KOw+OGkwVkdSU1Mxa9YszJ07F126dJE6HIvm4+ODgQMHIjo6WupQ2H1w0mCsjkydOhXNmjXD9OnTpQ6lXnjzzTdx4MABXL9+XepQWA04aTBWB/bs2YMtW7Zg6dKlsNPV+TbTEhISggYNGmDjxo1Sh8JqwEmDMRNTKpWYNGkSQkNDERISInU49YaNjQ2GDRvGScPCcdJgzMTWrVuHa9euYdGiRVKHUu+EhoYiMTGR62xYME4ajJmQUqnExx9/jPHjx+Pxxx+XOpx6p0+fPnBxccGOHTukDoXpwUmDMRNavXo10tLS8MEHH0gdSr1ka2uLfv36cdKwYJw0GDORiooKLF68GOPHj8cTTzwhdTj1VkhICA4ePAiVSiV1KEwHThqMmcjevXuRkpKCd955x+gykpKSMGjQILi7u8PFxQXBwcE4cuSICaOU1o4dO9CmTRtYW1vrnadbt24oLCzEhQsXDCo7JycHMTEx6Nu3Lxo2bAgHBwe0bt0aI0eOxOnTp2sbOvsHJw3GTCQ2NhbPPvssAgICjFr+2LFj6NGjB1xcXHDhwgVcvXoVLVq0QO/evbFnzx4TR2tely9fxpAhQzBjxgxkZGTUOG9AQAAcHR1x/Phxg9Yxbdo0REREYOjQofjzzz+RnZ2N1atXIykpCZ06dcLPP/9cm01g/+CkwZgJlJaWYvfu3QgLCzNq+YqKCrzxxhtwd3fHmjVr4OXlhUaNGiE6OhotW7bEhAkTUFpaauKozWfOnDno0aMHEhMT4eLiUuO8crkc7du3x4kTJwxez/jx4zFlyhQ0bdoUjo6OeOaZZ7B+/XqoVCquZGki+s8RGWMP7ODBgygoKMCgQYOMWv63337D+fPnERERodFGlVwuR1hYGKKiorBt2za8/PLLpgrZrFatWmVQ21vt27fH+fPnDVpHbGys3rIcHBxw+fJlENEj3VuiKfCZBmMmEB8fD19fX/j4+Bi1/P79+wEAnTt31pqmHrdv3z7jA5SYoY01KhQK3Lp1yyTrLioqQnFxMQICAjhhmAAnDcZM4OTJk1o7/OTkZLz44otwc3ODo6Mjnn76aWzbtg3BwcGQyWSQyWSYMGFC5bwA0KxZM62yFQoFAODixYt1vBUPzpBtM4aXlxfS09NNsp4ff/wRADBr1iyj42FV+PIUYyZw7tw5REREVL5PSUlB9+7d4eTkhLi4OHTv3h3Xrl3D1KlTcebMGdjZ2aGkpKRy/tzcXACAk5OTVtnOzs4AxNNBlsDQbTNG06ZNUVhYiG7dusHZ2dno9WRkZCAyMhITJkzA8OHDaxUTEzhpMFZLRITbt29rnCXMnDkTubm5iI2NxXPPPQcAaNeuHdavX29wHQ4iAgCLubRiym3Tx8PDAwCQl5eHVatWGbWe7OxshISEoHfv3oiJiTFJXIwvTzFWazk5OVAqlWjSpEnluF27dgEA+vfvrzFv48aN4evrq1WGu7s7AHH9/V7qcep5pGbottWWMespKipC//794e/vj++++w5yudzkcT2qOGkwVktlZWUAAHt7ewDi8duCggLY29tXXlqqrkGDBlrj1DvBmzdvak1LS0sDALRp08ZkMRtLqVQavG3GrgcA7OzsDF5PeXk5QkNDoVAosG7dOk4YJsZJg7FaUl82Ul9GsrOzg4uLC0pKSlBYWKg1/507d7TG9enTBwCQmJioNU09rl+/fiaL2Vg2NjYGb5sx1DXGS0tLDV5PeHg4SktL8cMPP2jUPG/VqhWOHj1qkvgeZZw0GKsl9eOk1XduAwYMAFB1KUft9u3bOp+CCgoKgr+/P+Li4jRu7qpUKmzYsAE+Pj5G1wExNUO3zRjqszdD1xMVFYXz589jy5Yt3PlVXSHGWK05OzvTqlWrKt+npKRQw4YNSaFQ0J49e6igoIDOnj1LISEh9Pjjj5OdnZ1WGQkJCWRvb08jRoyg9PR0ysrKovDwcLK2tqZdu3aZc3O03LlzhwDQ/v37jdq26hQKBcnl8hrn2bBhA8nlcoPWs2bNGgJQ45CQkFDrz+IRl8lnGoyZgEKh0OjbumXLlkhISECXLl3wyiuvwNPTE+Hh4ZgxYwZatWqls4xu3brh999/R15eHtq2bYsnnngCly5dwsGDB7VuBkvJmG3btm1bZb2KtLQ0qFSqyve6anJnZGSgcePGBq0nLi7O5NvKtPEjt4yZwJNPPqnVkmqbNm2wefNmg8rp0KFDvehLwtBtGzx4cOU9nweRkZEBT09Pg9azbdu2By6fGY/PNBgzgQ4dOuDkyZNSh/HQuHHjRmVNeGZZOGkwZgLPPPMMrl+/jpSUFKlDeSicPXsW7dq1kzoMpgMnDcZMoHv37nBzc9N60qe6DRs2QCaTYd++fSgtLa11+0yWxJTbplKp8Ndff+nsl+Rh/gzrCxkZcqGRMaZXWFgYbt26hUOHDkkdisllZmaiSZMm2L9/f2WdkrqSnJwMPz8/nDx5Eh06dKjTdTGDZfGZBmMmMnLkSMTHx+Pq1atSh1KvJSYmwtbWFn5+flKHwnTgpMGYifTv3x+enp56OwNiD+bQoUPo0qVLZbMszLJw0mDMRGxsbDBx4kRER0frbHiQPZiDBw+id+/eUofB9OCkwZgJvf322ygtLeWmuI2Unp6OS5cuISgoSOpQmB6cNBgzoUaNGuG9997DRx99hKysLKnDqXd2794Ne3t79OjRQ+pQmB6cNBgzsenTp8PBwQEffvih1KHUO5s2bUJwcLDOHgyZZeCkwZiJOTs7Y8GCBYiJicH58+elDqfeKCwsxK+//vr/7N15WFRl+wfw78Agi2yiiIqEuCCgKe57brggai7hkpmaJmWpvfZqrmlu1a+y1MwlzdRyQcrX3C2XXNI0FFwRN1wQUJB9HeD5/XE3LM4Aw2xngPtzXecaPOfMOfcgc+7znGfD0KFDpQ6FlYKTBmMGMGHCBDRv3hwzZswo15hLVdmRI0eQk5ODQYMGSR0KKwUnDcYMwMzMDGvWrMHx48exZs0aqcOpELZv347u3bvD2dlZ6lBYKThpMGYgnTt3xrx58zBz5kxcuXJF6nBMRlRUFLp27YoTJ04UrEtISMCBAwcwfvx46QJjGuFhRBgzoNzcXHTv3h3Jycm4ePFiwSx/pq5169a4fft2sXVZWVmoVq0azMwK7zVtbGwQGRkJBwcHjY998uTJgqFIevXqhSVLluDixYuYP38+YmJi1M4JzkxGPM+nwZgByeVy/PTTT/D19cVHH32EVatWqeyTkJAAa2tr2NjYSBChev7+/ggLC1Opj8nNzS34WSaT4ZVXXilXwgCA+/fvw9zcHHl5eTh9+jS6dOkCR0dHdOvWjRNGBcCPpxgzMA8PD6xfvx7ffvstvv/++2Lb0tLS0L9/f6xevVqi6NR74403yqzAl8lkGDt2bLmP/eDBA8jldL+qUCgA0O/h0KFD6NixI44fP17+gJnxSDfVLGNVy8KFC4VcLhdHjx4VQgiRlZUlunfvLgAIOzs7kZSUJHGExXl5eZU637aVlZVITU0t93HHjRsnzM3N1R5Tub5Hjx7i9OnTBvhUTEc8RzhjxrJw4UKMHj0ar732GsLDwzF69GicPXsWAJCZmYkvv/xS4giLe/PNN2FhYaF2m1wux9ChQ7V6nBQZGYm8vDy125TrT548iXPnzpX72MzwuCKcMSPKzs6Gn58frl27htTU1GIXTysrK0RFRcHFxUXCCAs9ePAAHh4eJT6m2r9/PwICAsp93Dp16iAuLq7E7TKZDCtWrMAHH3xQ7mMzg+P5NBgzJktLS7Ro0QLJyckqd9t5eXlYvny5RJGpcnd3R5s2bSCTyVS22dvbo0+fPuU+pkKhwLNnz0rcLpPJsGrVKk4YJoyTBmNGtGjRIqxdu1bt3btCocB3331nUpM4vfnmmzA3Ny+2zsLCAqNGjUK1atXKfbyHDx8iPz9f7TaZTIaNGzfi/fff1ypWZhycNBgzktWrV+OTTz4ptVWSTCbD4sWLjRhV6UaNGqUSr0KhwOuvv67V8UpKiGZmZti8eTPeeustrY7LjIeTBmNGsHfvXkyfPl3to56iFAoFtm7dioiICCNFVjpnZ2d07969WGnD2dkZ3bp10+p4UVFRBc1tAUqSZmZm2LJlC8aNG6dzvMzwOGkwZgSDBg3C0aNH0a9fP8hkshJbJQGAubk55s2bZ8ToSjd27NiC0ka1atUwbty4Yr3CyyMqKqogAclkMpibmyMkJARvvPGG3uJlhsVJgzEjMDMzg5+fHw4dOoRLly5h/PjxqFatmtp6AYVCgT179uDChQsSRKpq2LBhBaWDnJwcjB49WutjRUVFQaFQwMzMDHK5HL/88gsPhV7BcNJgzMh8fX2xYcMGPHr0CIsXL4azszPMzMyK3b2bUmnD3t4eAwYMAEC921u3bq31sSIjI5Gfnw8LCwscOHAAgwcP1leYzEi4nwZjEsvKysL27dvx5Zdf4ubNm7CwsCgYXuPkyZM6z5edmwukpgL5+UByMq1LTCzcnpICqOtrJwSQlEQ///33L/jqq9cQGLgQgYGLAAB2doC8hNHratQo/NnBATAzo/19fGr/O2TIQfTo0UOnz8UkEc9JgzETcuzYMXz11QocPnwIQgh4e7fDV19dQGoqXcBTUoC0NEoC6talpQFZWUBmJpCTA6Sn6yuyLAB1AFwA4KnDMeoC2A+gC6ysAGtroFo1oHp1+tnOjhZHx8Kf1a1zcABq1gRq1aLXF1oFM8PhpMGYMTx7BsTFAdHRQGws/fzsGZCQoLrExwNCRAJYCWALgJ2QyQYWu2ja2tJrjRqFP9vaAvb2hRdhuZzWm5nRRRYoLAEo7/4BulhbWamPu2hp4ttvvy3oQ1G0FPIihYKSl5KyVHPvXgzi4h7B1bU9cnMpoeXkUILLyqJ/K5NfcjIlQ2UiVCbI1FQqOb3I0RFwdqYE8uJSty7g4gK4ugJ16gC1axd+dlZunDQY00VeHiWCqChaHjwAnj4FHj2i18ePKUHk5BS+x8qKLmK1axe/Wy66ODvTeguLJEREnMfQof2l+ogFhBBlNhk2hsxMSiBFE60yAcfHqybhJ0+Kl7jkcvrd16tHCUW5uLkBDRrQ4uZGyZep4KTBWFni44Fbt4B79wqTg3J59IjurAHA0hJ46SW6m1VekOrVK/7vunWLP+9nxpGeXpjAla/R0cVLfw8fFiYXMzMqmSiTiIdH4c9NmgD160v3WSTGSYMxgB55PHxIieH6deDGjcKfY2JoHwsLugNVJoOGDYsv7u78bL2iS0yk//cnT+j//d69wuX2bXpkBtANQqNGQLNm9H/v40M/e3nRo8FKjJMGq3piY4GwsMIlPBy4e5dKDDIZJYamTWnx8qJXT0+6u+Rn4VVbXByVOpVLRAS93r9PjyrNzOjmoUULwNe3cGnQQOrI9YaTBqvcHjwA/v4buHy5MEnExtK2l14CWrakL7WPT2FyqOR3iswAcnKoJKJMJMq/tbt3qamzo2PxJNK+Pd2QmEAVUXlx0mCVR24ufWnPngXOnAFOn6Z6B7mcEoSPD9CmDS3t21NlNGOGlJZGf5PXrwOhobRcvgxkZFDLtA4dgC5d6G+yWzdKLiaOkwaruHJygL/+Ao4epQTxzz/UdLNWLaBTJ6BzZ1ratgVsbKSOljGSm0ulkL/+KlwePaKbmxYtKIn07Qv07GmSpV5OGqxiuX2bksSRI8CJE3Qn16QJ0KMHJYhOnegxE2MVyePHVEI+dw7480+qZ7OwoATSrx8lEV9fk3icxUmDmTYhqE5i1y7gt9+oFYu9PdCrV+GXqWFDqaNkTL/i4gpvjn7/nfr8uLgAAQHAiBFA794lD+FiYJw0mGn65x9KFLt3U2V206bA8OFA//5UmpDoC8OY0QlBj7OOHAF+/RW4eJEewQ4bBowcCXTvbtSm3pw0mOlISAC+/x7YuJFanTRsSF+KESOoaM4Yo9J2cDDdVIWFUQnkzTeB996j5r4GxkmDSe/KFWD1auDnn6nT1PjxwOuvA+3aSR0ZY6YtMhLYsYNutmJjgVdfBaZOpTo+A+GkwaRz9iywYAFVaHt70x/72LE08B5jTHMKBT26Wr2avlctWgAff0yPdPUsnvu3MqO7f58eOXXrRj1ojx6lduzvvitNwjh48CA8PT2LzV2tz/0BIC8vD3PmzEGTJk1gZWUFf3//gm1paWmQyWTFlnPnzpV5zJkzZxZ7z9KlS1X2uXjxIsaPHw8PDw9YW1vDyckJzZs3x/Dhw7F27VrcvXu3YN/mzZurxKFuMTMzQ6yyh2QRDx48wODBg5GiHGvjX2FhYQgICICjoyPs7Ozg5+eHs2fPavy7K0qb371SYmIi1q1bh169esHJyQnW1tZo0qQJxowZg/DwcJX9Z8+ejV27dpV4vAkTJsDS0hIeHh6YPn06srKyyh2TvlhY0KPcM2eoPrBZMyAwkOo7/vlHzycTjBlJRoYQs2YJYWkphJeXEPv2SRvPnTt3xKBBg0SLFi2Evb29MDc31+v+Ra1fv14AEIsXLxaJiYlq97l8+bIAIAAIf3//Uo8XHx8vbG1tBQAxZswYle15eXniv//9r5DL5WLmzJni5s2bIisrS8TGxoqjR48KPz+/gnMpFAohhBDNmjUTe/bsUXu+zMxM4ePjIwCIGTNmqI29Vq1aYvXq1cXWnz9/XlhbW4uRI0eKJ0+eiGfPnom3335byOVyceTIkVI/Y1G6/O6VJk6cKORyufjmm29ETEyMSE9PF6dOnRI+Pj7C3Nxc5bPfuXNHeHh4iPnz55d4zJSUFLFu3ToBQCxbtqzcMRnShQtCdOsmhJmZEGPHCvH0qV4O+4yTBjOKa9eEaNZMiBo1hPj2WyH+vU5JavTo0eLTTz8VCoVCuLq6lnkhKu/+L74XgEhJSSlxn8uXLwtra2vh7u4uAIiLFy+WuO+8efOEt7d3iUlj7ty5AoDYsGGD2vfn5uYKf39/jZPGtGnTBADRvHlzkZWVVWxbcnKyqF+/vggKCiq2Pi8vTzRr1kzUrVtXZGRkFDt306ZNhZubm8qxSqLL715p4sSJYvLkySrrw8LCBADRpEkTtdtkMpnYtWtXqce2sbERffv2LXdMxhASIoS7uxB16wpx7JjOh+OkwQzvxAkhHByE6NJFiAcPpI6mUNELmSYXovLuX1Tfvn3L3P/y5cuievXqYu3atQKAePXVV9Xul5iYKJycnMSPP/6oNmncvHlTmJmZiTZt2pR6vr/++qtY0ijJ0aNHhUwmE5aWliI8PFxl+7x584RcLhfR0dHF1p84cUIAEFOnTlV5z6JFiwQAERISUuq5lXT53WvC2tpamJmZifz8fJVtgYGBon79+qX+nurVq1fm71tKSUlCBAYKIZcLsXmzTod6xnUazKDOnQMGDKD+FceP0xhQpsLa2tqg+xeVp24S7hJMmDABrq6u+O2333DlyhWV7atWrcKAAQPQqFEjte/fsGED8vPzERgYWOp5OnXqBCFEqfUDz58/x/jx4yGEwLJly9CiRYti24UQ2LhxIzp06IB69eoV23b8+HEAQNu2bVWOq1x37NixUmNU0uV3X5b09HRkZmYW1Om8aOjQoXj8+DEOHDhQ4jFkMhly1U0paCIcHKiJ7kcfAW+9RS0VtcVJgxlMfDwwZAjQpw/9kfJMaJqxtLTEzJkzCy7URaWlpWH16tWYO3duie8/deoUAKhc4LURFBSEJ0+eoEePHpgxY4bK9vDwcMTFxaFly5Yq2yIiIgAA9dXMWOTq6goAiIyM1DlGXe3evRsAMG/ePLXbff/tJHTkyBGjxWQIMhmwdCkwcyYwcSI1ddcGJw1mMAsWUKuOn37iyYlycnJgaWmp8f6TJ0+Gi4sLQkJCcPPmzYL1a9asQa9eveDt7V3ie588eQIAqFmzpvYBA9i6dStCQkLg6OiIrVu3qr0Lv3btGgD1iSHp30nEq6sZdc/232ZyicoJxCUSFxeH2bNnY9KkSRgxYoTafZQJTvlZ1bG0tIRCOYWjifv0UxpV99/p3suNkwYziLQ0YNs2YO5cGgK6qnv48KHaC2tJrK2tMWPGDOTn52P58uUAgIyMDHz99dcl3hG/SJf5vKOiojB16lQAwHfffQc3Nze1+8X8O62hg4NDuY4v/u0eJuWc4wkJCejfvz969OiBdevWlbifvb09ZDJZwWdVp169eoiOjjbpR1RKZmbA8uU0MvT161q8X/8hMUZF3/R0YNAgqSOR1vPnz/HFF1/gwYMHmDJlSrneO2XKFNSsWRM7duzAnTt3sH79enTs2LHMx07KuoX4+HitYs7Pz8ebb76JlJQUjB49GqNHjy5xX2XfBAsLC5Vtjv9ODpGunHi7COU6R4kmkEhPT0e/fv3g4+ODn3/+GeZlFIXlcjkyMzNL3B4UFISUlBR8/PHHWv/ejemVV6ieQ5vuMpw0mEEonzro+ISkQhs/fjxq1qyJ2bNnY9asWZg2bVq53m9ra4sPPvgAeXl5WLhwIb788kvMnz+/zPd1794dANRWomvi//7v/3D69Gm4ubnhu+++K3VfKysrAFD7aMbLywsA8PjxY5Vt0dHRAABPT0+tYtRFbm4uAgMD4erqii1btpSZMJTvKa0y/o033sCyZcvwxRdfwNnZGf3799dnyHonk9F38/nz8r+XkwYzCGUrqVu3pI1DSj/++COSk5Oxc+dOrFixAkFBQeU+xtSpU+Hg4IDt27ejZcuWalsivSgoKAhyuRwhISGl7jdr1iyYmZkVVFgDwOXLl/Hxxx9DJpNhy5YtZZYE6tatCwBITk5W2dazZ08AQGhoqMo25brevXuX/mEMICgoCNnZ2QgODi7Wcqxx48Y4f/68yv4pKSkQQhR8VnXmzZuHuXPnYu3atUhKSsLhw4cNEru+pKXRHB5aDXCoa/tfxtTJzxeiYUMh1DTRN0nlbftf3v3btWsnatSoUeo+yn4aL/rkk0+Eg4ODOHv2bLH1p0+fLrFz35IlSwQAsWnTJrXnioiIEPb29mLkyJEF6zIzMws6DH744Yclxjl8+HDxxRdfFMQMQEyZMkVlv7y8POHj4yPq1asnMjMzC9bn5uYKb29v4ebmVmy9pnTpp7Fw4ULRoUMHkZqaqrKtUaNG4ty5cyrrb9y4IQCId999t8Tjenl5CQ8PD61iksLatTQyQ0JCud/KnfuY4axfL4SFhRChoVJHUjZDJ43evXtr3LlPU6UlDSGEmD17trCwsBAfffSRuHXrlsjOzhaPHz8WGzduFHXr1hVdu3YVaWlpBftPnTpVABAvv/xyqT21iyaN/Px8Ubt2bdGlSxe1+547d05YWVmJUaNGiZiYGBEfHy+CgoKEXC4Xhw8fVtl/zJgxAoC4d+9eiefX5Hev7jibN28uGDqlpEVd0ti+fbsAUGJveWVMLVu2LDUmUxETI0StWkJMn67V2zlpMMPJyxOib18hXF2FiIqSOhpV+/btK/Hi8f333+u8f1F+fn6lXuiqV69e7Hj9+vUr9XjqYnhx3CchhLhw4YIYO3ascHNzExYWFsLOzk507NhRrFy5UmRnZxfs9+jRIyGTycq8qCoXZdIQgoYsUdcjXOnSpUvC399f2NvbC1tbW9GrVy9x5swZtfv26tVL2Nraitzc3GLry/u7V3ecgIAArZJGYGCgcHV1FTk5OWpjFoKShq+vb4nbTUVyshBt2wrRtKkQpYxoUxpOGsywkpKE8PWlxKFmBIoqIyAgQMhkMqnDMIikpCTh6uqqMvZUeSUmJgpra2sxadIkkziOEIVjT+3YsaPU/VxcXETHjh11Pp8hRUfTd7FuXSHu3NH6MDyMCDMsBwfg5EnA0xPo2BFYv56mr6xq6tevDyEE4uLipA5F7xwcHLBv3z6EhIRgzZo1Wh1DCIFp06bB3t4eS5Ys0ToWfR0HAO7du4dhw4Zhzpw5GDVqVIn7KRQKPH/+vFz9cIzt4EGa/TIrC/jrL6CEEWg0wkmDGZyDA82ZMWsWTUnZsSP94VYlyiaYn332GRISEiSORv9atWqFf/75B4cOHVKZT0MTcXFxuHfvHo4dO4Y6depoHYe+jgMA69evx7Jly1SGcikqOTkZK1asgEKhMMlmtg8f0lSwAwfSbH7nzgENGuh4UH0VfRjTRGioEN27CyGT0aib9+9LHZHxfP7558Lb21tYWlqK/v37Sx0O09G4ceOEhYXAKQOAAAAgAElEQVSFaNy4sViwYIFKPYyUUlOFWLhQCCsrqr8IDtbboZ/xdK9MEr/+SiNuRkfTfOBTpwJqxrxjjJVDVBTw3XfAxo003tuiRUBQEKDFRIcl4TnCmXRycoDNm4FVq4AbN2hog6lTaWRcPf6RM1apCQGcOEHzg+/bB9SpQ1Mnv/ceYIBRWjhpMOkJARw7Rn/0+/cDdevSfMcjRwLt20sdHWOmKSKC5sjYuZN+7tqVbrqGDqXRpQ2EkwYzLffuAT/8QF+GO3cADw9gxAhKIK1aSR0dY9K6e5e+G8HBQHg43WC99howYYLRvh+cNJjpunSp8AsSFUXNBPv1A/r2BXr14iHXWeWXnQ2cOUOtD48eBcLCAGdnYPhwupF65RUa6tyIOGkw0ycEcOECsHcvfXEuX6ZKvk6dCpNI69ZG//IwZhA3bxYmiZMngYwMoGlT+lsfOJBumCSc1IyTBqt44uOp4u+PP4BDh4BHjwBbW2p91bUr0KULvdaoIXWkjJUuN5ceM505A4SGAn/+SX0rbG2pP9PAgcCrr+qhb4X+cNJgFZsQwNWrwKlT1HHpr7/oUZa5OfDyy5RAOnak571Nm3KrLCYdIYD796mkfP48/a2GhtIjKBcXKjl36UJL+/YmO0UyJw1W+Tx5Qgnk7Fl6vXSJmvdaWQHNm1MC8fWlkkmLFlw3wvQvOxu4do3qIMLCqDQRHg6kpFAy8PGh5NCpE9C5M9C4sdQRa4yTBqv8FAqaCzk8vPBLHBYGJCVRPUjDhkCzZlQSadoU8PKi16o86yDTTGoqTTR26xbVRURG0mtEBD16ql6dSrwtW9LNSsuW9O/q1aWOXGucNFjVFRVFyePKFfqiK7/8GRm0vVatwgTStCklF3d3er5cq5aUkTNjSkmhv5WoKHq8pPw7uXWLRjQAgGrVqLSg/Htp2ZJKs40bm+xjJm1x0mCsKCGoIjIyku4WIyLo4hAZSReI/Hzaz9aWkseLi5sb4OpKz6i5/sT05ecDT58CsbH0/65MDkUX5Xz3AP2/enoWL5V6edH/fRX5/+akwZimcnJKvrBERVFdivLbJJPRBaZOHUoiL766uFBpxdkZsLeX6hNVXmlpQEICtbSLjaUlOlr1NS6OHiMp1a6teiOgLF16eADW1pJ8HFPCSYMxfcnOpgvRkydATEzha9GfnzwpfucK0JAPNWuqLrVq0auDA40hZG9PJRw7O3qtUYN+rox3uEJQnVNKCiWA1FRakpLoNTmZkkJCAvDsWeHPyiU7u/jxbG2B+vUpWdevT8nBza34q7s7JwUNcNJgzNiysugOV93FrugSHf0Q0dHbAcxGUlLJx7O2Lkwmyr4pylcHB6rsVyaX6tXp+bu1NbUmU1Kuf1G1auorbbOygMxM1fV5eXShV1Io6KKvXK9MBgC9CkHrlduVySE9veTPa2dHn8vJiZKqs7P6pKtc6tat0BXPpoaTBmOm6MqVKxgwYABq1qyJM2fOwM7OruCiqrzzVt6JKy+0yjvw/Hx6BQpLNcr1qan0OCY9nR63AUBW1mlkZHhCJnNRiSMjQ/WuHaAEVFJTZWWiAqgS2N4eaJx1DUsejsOcVochq+0MmYzWm5tTwrOwKCxB2dkVJkDlz8rFAKO2svLhpMGYqTl27BiGDRuGtm3b4tdff4WDg4PBzqVQKNCwYUOMHTsWy5cvN9h5kJFB7Zp79KDx8FlFFc+j9TBmQn777TcEBAQgICAAhw4dMmjCAICQkBDExMRg8uTJBj0PbGyAr74CtmyhMWBYhcUlDcZMRHBwMN544w1MmDABa9euhZkRRmDs3LkzXF1dsXv3boOfCwAwaFDhWBoGnPSBGQyXNBgzBdu2bcPrr7+O9957D+vWrTNKwrh06RLOnTuHqVOnGvxcBb79ltonr1hhvHMyveKSBmMS27VrF8aMGYOZM2fi008/Ndp533zzTVy9ehWXL1822jkBAMuWAcuX0+BMHh7GPTfTFVeEMyal3377Da+99hreffddrFy50mjnffr0Kdzd3bFmzRq89dZbRjsvAGq21bIlda3eu9e452a64sdTjEnljz/+wIgRI/DWW2/hm2++Meq5165dC1tbW4wePdqo5wVAnT+++w747Tfg4EHjn5/phEsajEngypUr6NatGwYNGoStW7capQ5DSaFQwMPDA+PGjcOyZcuMdl4VI0ZQhfi1a4ClpXRxsPLgkgZjxvbkyRMMGjQIvr6+2LRpk1ETBkCttOLi4vDOO+8Y9bwqvvqKxlVZvVraOFi5cEmDMSNKS0tD165doVAocPbsWThK0MW5U6dOcHNzQ3BwsNHPrWLhQuDrr2ko4bp1pY6GlY1LGowZixACEydOxJMnT3Dw4EFJEsb58+dx/vx5TJs2zejnVmv2bBpEat48qSNhGuKkwZiRfPnll/jll1/w008/wd3dXZIYVqxYgbZt26Jr166SnF+FtTXw+efUU/zCBamjYRrgx1OMGcGJEyfQt29ffPrpp/jvf/8rSQwPHjxA48aNsW3bNowaNUqSGErUoweNovj334WjHTJTxP00GDO058+fo0WLFujYsSN2794NmUwmSRwffvghdu3ahfv378PC1IbwCAsD2ralwQzHjpU6GlYyrtNgzNCmTJkCANiwYYNkCSM1NRWbNm3C9OnTTS9hADSh9oQJwPz5NFkHM1mcNBgzoG3btiE4OBjff/89nJycJItj48aNUCgUmDhxomQxlOmTT2j2KW6Ca9L48RRjBvL06VN4eXnhjTfewKpVqySLIy8vD56enggICJA0Do0sWECDGt65Q9PuMVPDj6cYM5SZM2fC1tbWsJMbaWDPnj2IiooynWa2pfnoI+od/tlnUkfCSsAlDcYM4MyZM3jllVcQEhKCYcOGSRpLly5dULt2bezZs0fSODS2ejXw3/8CN28CDRtKHQ0rjltPMaZveXl58PX1hZubGw5KPCDfP//8g3bt2uHPP//EK6+8ImksGlMoaGrYjh2BrVuljoYVx0mDMX3bunUrJk6ciOvXr8PT01PSWEaPHo3IyEiEhoZKGke5BQcDo0cDFy8CrVtLHQ0rxEmDMX1SKBTw9vZG9+7dsWnTJkljuX//Pjw9PfHjjz9izJgxksZSbkJQScPREThyROpoWCGuCGdMnzZv3oyHDx9ingmMpbRixQrUrVsXI0aMkDqU8pPJqDL86FHg9Gmpo2FFcEmDMT3Jz8+Hp6cn+vTpg7Vr10oaS0JCAtzd3bF8+fKK0WqqJD17UgI5flzqSBjhkgZj+rJ//37cu3cPH3zwQbnfm5iYiHXr1qFXr15wcnKCtbU1mjRpgjFjxiA8PLzcx1u9ejUsLS31MpXrwYMH4enpCblcrvOxym3pUuDECeDkSeOfm6knGGN64efnJwYMGKDVeydOnCjkcrn45ptvRExMjEhPTxenTp0SPj4+wtzcXOzZs0fjY6Wnp4tatWqJhQsXahWL0p07d8SgQYNEixYthL29vTA3N9fpeFrr1UuILl2kOTd70TMuaTCmBzdv3sSxY8fw/vvva32Mt956C9OnT0edOnVgY2ODbt26Yfv27cjLy8OsWbM0Ps6mTZuQkZGB9957T+tYAGDBggXo3LkzQkNDYWdnp9OxdLJkCXD2LJU4mOS4ToMxPZg/fz62bduG+/fv6336VhsbG2RnZyM3N7fMAQ/z8vLQtGlT9O/fH99++61O583MzIS1tTUAoH79+oiNjUVubq5Ox9Ranz5AZiZw5ow052dKXKfBmD4EBwdj5MiRek8Y6enpyMzMRPPmzTUaIXfXrl2IiorCf/7zH53PrUwYJmHxYipt/PGH1JFUeZw0GNPRxYsXcfv2bYwcObLY+oiICAwZMgQODg6wsbFB+/btsX//fvj5+UEmk0Emk2HSpEmlHnv37t0AoHET3q+++gqBgYFo1KiRyjZ9xCOZTp2Avn2Bjz+WOhImda0KYxXdrFmzROPGjYutu337tnB0dBSurq7i6NGjIjU1VVy7dk34+fkJZ2dnYWlpWeZxY2NjhYuLi5g0aZJGcRw5ckQAEKGhoSrbdI3H1dVVuopwpXPnhACE+P13aeOo2p5x0mBMRy1bthTTp08vti4wMFAAECEhIcXWP336VNjY2JR5kY6Pjxe+vr5i5MiRIjc3V6M4evfuLfr06aN2m67xmETSEIJaUpXwGZlRcOspxnTx9OlTXLlyBX369Cm2/vDhwwCAfv36FVvv7OwMLy+vUo+Znp6Ofv36wcfHBz///DPMzc3LjOPixYs4duwYZs6cqXa7LvGYlJkzgd9/By5dkjqSKouTBmM6+P3332FhYYHu3bsXrMvOzkZqaiqsrKxga2ur8p4aNWqUeLzc3FwEBgbC1dUVW7Zs0ShhAMCSJUvQoUMHleSlazwmp39/mhr2q6+kjqTK4qTBmA5OnjyJDh06FLsYW1paws7ODllZWUhLS1N5z9OnT0s8XlBQELKzsxEcHFysB3bjxo1x/vx5te8JDw/H/v37MX/+fLXbdYnHJM2YQaPgPnggdSRVEicNxnRw4cIFdOzYUWW9v78/gMLHQkqxsbGIjIxUe6xFixbh+vXr2Lt3LywtLTWOYenSpWjZsiUCAgJK3EebeEzWqFFAvXrAN99IHUnVJHWtCmMVVXp6upDL5SI4OFhl2507d4STk1Ox1kpXr14V/fv3F+7u7ioVz5s3bxYASl3OnTuncp4bN24IMzMz8csvv5Qaa3njeZHJVIQrffmlENWrCxEfL3UkVQ1XhDOmrUuXLiE3Nxft2rVT2daoUSOcO3cO7dq1w2uvvQYXFxcEBQVhzpw5aNy4scr+ISEhWsWwdOlSeHl5YciQIaXuV954ABqAUdl/Izo6Gnl5eQX/3rhxo1bx6s3kyYCFBbB+vbRxVEESDFvJWOUQHh4OJycnNGjQQO12T09Pjefl3r9/f7nPf/fuXQQHB2Pr1q0a9UQvTzwAMHDgQAhTHWXIzg4ICgJWrqQ6DisrqSOqMrikwZiWIiIi4O3tLdn5ly1bhgYNGiAwMFCyGCQ1bRqQlATs2CF1JFUKJw3GtBQRESFZH4eHDx/i559/xvz586WZ58IU1KsHDBsGrFsndSRVCicNxrQUERGBpk2barz/zp07IZPJcOzYMWRnZ+s01tPy5ctRt25dvP7661q9X9/xSOadd4ALF4DQUKkjqTJ4aHTGtJCdnQ1ra2v88ssvGDp0qFHPHRMTg4YNG2LVqlV4++23jXpuk9S8OdClC1eKGwcPjc6YNqKjoyGEgJubm9HPvXTpUjg7O2PcuHFGP7dJevttYPt2ICVF6kiqBE4ajGkhOjoaAODq6mrU896/fx8bN27EokWLUK1aNaOe22SNGwfk5wM//SR1JFUCJw3GtBAdHQ1zc3PUrl3bqOedP38+GjRogDfffNOo5zVpjo7AyJHAmjVSR1IlcNJgTAvPnj1DrVq1NB5QUB+uXr2KnTt3YtmyZVW3xVRJ3nkHuHED+OsvqSOp9DhpMKaF58+fw8nJyajnnDt3Llq1aoXhw4cb9bwVQvv2QJs23PzWCDhpMKaF5ORkODo6Gu18Z8+exf79+7F8+XKN5gqvkoKCgN27gcREqSOp1DhpMKaFxMREoyaN+fPno1u3bujbt6/RzlnhjBoFyGTAL79IHUmlxkmDMS1kZGTAxsbGKOc6dOgQTp48ic8++8wo56uw7OyAAQN4WBED46TBmBays7PLNeeFtoQQmD9/PgYPHozOnTsb/HwV3ujRwMmTwL9Nopn+cdJgTAs5OTl6TxrqZuYLDg5GWFgYFi9erNdzVVoBAVTi0HKoeVY2HkaEsTKcPHkSly9fRkZGBlJTU5GSkoIDBw7A0tIS9erVQ3p6OtLS0pCRkYGvv/4aw4YNK/c5YmJiUK9ePQwdOhRffvklGjZsiLy8PDRv3hxt27bFtm3bDPDJKqlx44Bbt4ASpsdlOonnxt6MlSE2NhYzZsyAhYUFzMzMkJ+fj/z8fOTl5eH27dsF+5mZmaFbt25anePKlSsAgH379mHfvn344IMP4Orqirt372o110aVNno04O8P3LkDlDDBFNMeJw3GyjBs2DDUqFEDiaU05ZTJZGjbti2cnZ21OseVK1dQrVo15OTkAABWrlwJuVyO7t27SzK+VYXm5wfUrk3Nb+fMkTqaSofrNBgrQ7Vq1fD222/DwsKixH3kcnmZU66W5urVq8jPzy/4t0KhQGZmJo4fPw5vb2/s3r1b62NXOXI5MHw4t6IyEE4ajGkgKCgIubm5JW5XKBQYOHCg1scPDQ1Ve/z8/HxERUVhxIgR6NWrV8FjLFaG0aOBq1eB69eljqTS4aTBmAYaNmyIHj16lDjmU506dfDyyy9rdezc3NxidSMvys/Ph5mZGc6cOYOIiAitzlHldOkC1K0LlGNOdKYZThqMaei9995DXl6eynoLCwudxoO6desWFApFidvlcjmqV6+O33//HSNGjND6PFWKmRk1vz1wQOpIKh1OGoxp6NVXX0WtWrVU1isUCgQEBGh93KtXr5Y4npSFhQVcXFzw999/o3v37lqfo0oaOJCmgo2LkzqSSoWTBmMaksvlmDx5skqFuKWlJXr06KH1ca9evap2QiW5XI7GjRvj/Pnz8Pb21vr4VZafH1CtGnDokNSRVCqcNBgrh8mTJxd7RGVubo4+ffrA2tpa62Nevny5oKmtklwuR7du3XD+/HnUr19f62NXadWrAz178iMqPeOkwVg5vPTSS+jTp0+xCvHBgwfrdMywsDAUHZjBzMwMr7/+Oo4cOQJ7e3udjl3l9ekDHD9O08EyveCkwVg5TZkypaB5bH5+PgYMGKD1sZKTkxEbG1ts3YIFC7Bly5ZS+4UwDfn5Ac+fA2FhUkdSaXDSYKycAgICUKdOHQBA8+bN4erqqvWxrl27BiEEZDIZzM3N8eOPP2LRokV6ipSheXOgTh3g2DGpI6k0eBgRxl6QkwOkpwNpafRzUhKtz8gAsrMBwBz9+r2LLVsWokWLYVDXWdvaGrCyKr5OLqcBWAF6rVYNOH+eOutZWVnhl19+gb+/v8E+V5UkkwE9elDSmDlT6mgqBR7lllVKT5/SEhtLTycSE2kp+rNySU6mJJGTU56ZQqMBNABwFkB7HSJ9D8AvAI7A3r4lqlUD7O0BW1ugRo3Cxcmp+L9r1ABcXOgmunZtwNxchxAqu++/B/7zH/rP5Ud+uuJRblnFkpMDPHwIREUBDx4Ajx5RYnjyhJrjK1+L9pWTydRfgD096dXBgS7SFhb072rVqOFN9er0c40adBzleuKK//znLaxY0RZOTqpxpqYCL44KkpUFZGbSz8nJFOPixbkYPvwCbG1fQkoKrUtOplKOMqnFxAA3bhRPdEWPbW5OiaNOHaBePfq5fn3qEN2gQeGiQwOviq1rV7orCA8H2raVOpoKj0sazOSkpgIREcDNmzS6dVQUcP8+vT55UtgQpnp14KWX6I7b1bXwYlm7Nv3bxYWWmjUNE2d6ejqqF2YRrWg7A2BKCiVLZaKMjaXkEhNTmESjo4uXnOrUKZ5EGjYEfHwAb2+oTXyVhhBArVrAxx8D06dLHU1FF89Jg0kmOZlu/m7epOXGDZo75+FD2m5pCTRqBHh40EXO3b34RU/LUcirlORkSrbKRZl8o6KAu3epRANQovXxAby8KIl4ewO+vpXodzxwIN1l7NoldSQVHScNZhzJyTToaGho4RIRQaUGe3ugSZPCO99mzQovYPys3rASE2kg2Bs3Cl/v3aMFoEdcbdrQovx/adZM2pi18umnwLff8tzhuuOkwfRPCCo5nD5Ny9mzdGcL0GOj1q0Ll1atAJ5jyPQ8ewZcvgxculS43L1L2+rUATp1Al55BejWjUokJp/c//yTWlFFRVGRlWmLkwbTnRD0mOnkSfpunj1LFx1bW7q4dO0KtGtHScLFRepombaSkiiRhIYW3gwkJFDz4c6d6f+5Z0+gY0cTTCKZmYCjI7B5M/D661JHU5Fx0mDaSU+n0Rn276fx4B49osdM7dtTJ9wuXehnNePwsUrk3j3gzBlKIL//TnUmtrZ0Uz9oEI1OrkPfR/1q354y2qpVUkdSkXHSYJqLjaV6xL176UKRn0/fwwEDAH9/KkmUMMI3qyIiI2l8wEOHgFOnqAlxmzbA4ME0mV6jRhIG9+67VLF25oyEQVR4nDRY6VJSgF9/pemWjx0DbGwK7yD79TNcc1ZW8aWnA3/8QQlkzx7qbNmhAz0dGjGC6kaMasMG4MMPqVWGGY+gpCVOGky9v/4CVq8G/vc/qrPw96cv+8CBVbiTGNNabi7ddGzfTn9T6ek0AO1771FJ1SjX8H/+ocq1W7eoZyfTRjynW1YgJwfYto2+V126UGuZ1aupw9iePUBgICcMph25nEqmW7bQY84dO+hmZPBgoGlTYOVKKtUa1MsvU7f/y5cNfKLKjZMGQ3Y28PXX1BJx4kSgcWMqaVy4AEyaVDiMBmP6YG1NNyCHD1O/kL59gfnzqTf/7NmFA0TqnaUldf7hpKETfjxVhQkB7NwJzJtHd3/vv0+jLJhMaxdWZSQl0biCn39O/54/H5gyxQCt78aNo8oVngJWW/x4qqoKD6eWT2+8Qc0jIyOB//s/ThhMGo6ONHL5nTvA228Dc+dSoeDIET2fqEmTwl6KTCucNKoYIehRVIcO1BIqLAz44Qd6NGAMBw8ehKenZ7HpUl+UmJiIdevWoVevXnBycoK1tTWaNGmCMWPGIDw8vMxz5OXlYc6cOWjSpAmsrKxKnaPi4sWLGD9+PDw8PGBtbQ0nJyc0b94cw4cPx9q1a3H33wuMr68vZDKZxsvSpUuLnefBgwcYPHgwUv59cK/rZ1RHk9/t7NmzsauU8ZcmTJgAS0tLeHh4YPr06cjKytIqFm05OtKIH5GR9Dfq7w/MmKGcx0QPGjSg4ZG1nP41LCwMAQEBcHR0hJ2dHfz8/HD27Fk9BVdBCFZlPHsmRL9+QlhYCLFsmRC5ucY79507d8SgQYNEixYthL29vTA3Ny9x34kTJwq5XC6++eYbERMTI9LT08WpU6eEj4+PMDc3F3v27Cn1XOvXrxcAxOLFi0ViYqLaffLy8sR///tfIZfLxcyZM8XNmzdFVlaWiI2NFUePHhV+fn4CgAAgFAqFaNmypdi9e3exYwQFBQkA4tChQ8XWjxw5UixZsqTg35cvXxa1atUSq1ev1ttnLKo8v9s7d+4IDw8PMX/+/BL3SUlJEevWrRMAxLJlyzSOwxC2bRPC3l6Ili2FiIzUwwHPnBECEOLRo3K/9fz588La2lqMHDlSPHnyRDx79ky8/fbbQi6XiyNHjughuArhGSeNKuLRIyG8vYVo0ECI8+eNf/7Ro0eLTz/9VCgUCuHq6lpm0pg8ebLK+rCwMAFANGnSpMxzARApKSkl7jN37lwBQGzYsEHt9tzcXOHv769z0khOThb169cXQUFBev2MRZXnd6s8h0wmE7t27Sp1PxsbG9G3b1+N4zCUu3eFaNtWCGdnIUJDdTxYdDQljVOnyvW2vLw80axZM1G3bl2RkZFRsD43N1c0bdpUuLm5iaysLB2DqxA4aVQFiYlC+PgI0awZfWekUPSLpsmFrSTW1tbCzMxM5Ofnl7hP3759Sz3+zZs3hZmZmWjTpk2p5/rrr78KkoY6JSWNoubNmyfkcrmILscvXpPPWJQ2v9vAwEBRv379Ej+bEELUq1evzN+RsaSlCdGnjxC1aulY4sjPF8LKSoitW8v1thMnTggAYurUqSrbFi1aJACIkJAQHQKrMJ5xnUYVMH48tYE/coRmdpOCtR46eKSnpyMzMxPNmzeHrJTxSvLy8ko9zoYNG5Cfn4/AwMBS9+vUqROEEKXWEZRGCIGNGzeiQ4cOqKfhL17Tz1iUNr/boUOH4vHjxzhw4ECJ+8hkMuS+OP2gRKpXp75CHh7AsGE61HHIZDTee0xMud52/PhxAEBbNTP/KdcdO3ZMy6AqFk4aldzu3cC+fcDPP1f8llG7d+8GAMybN0+n45w6dQoA0KJFC51jKk14eDji4uLQsmVLjd+jr89YFl9fXwDAEb03TzKc6tWB4GCqx1Y2zdWKrS2Qno6IiAgMGTIEDg4OsLGxQfv27bF//374+fkVNGiYNGkSACAiIgIAUF9NixHXf79YkZGROgRVcfAc4ZXc8uXAyJE090FFFhcXh9mzZ2PSpEkYMWJEqfvm5OSUOoXqkydPAAA1DTxw1rVr1wCov9CoU57PqCvlhU4ZozqWlpZQFJ1s3QQ0aADMmgWsWEHDSGk1266tLe48foxOnTqhevXqCAkJQadOnfDgwQN88MEHuHLlCiwtLYu1HEv6t8ehuul9bW1tAVCLuKqASxqV2N271KQ2KEjqSHSTkJCA/v37o0ePHli3bl2Z+z98+FCjC7Wmj3+0FfPvIxAHB4cy9y3vZ9SVvb09ZDJZQYzq1KtXD9HR0SbziEpp8mQac1Drp0G2tph78iSSkpKwcuVK9OnTB7a2tmjWrBm2b9+O9PT0ch1O/Ns/2tB/T6aCk0YlFh5Oj3A7dZI6Eu2lp6ejX79+8PHxwc8//wzzUmb3ef78Ob744gs8ePAAU6ZMKXE/Zf1CfHy83uMtSnmnamFhUep+5fmM+iSXy5GZmVni9qCgIKSkpODjjz82+O+qPGrXpj56YWFaHsDWFocfPQIA9OvXr9gmZ2dneHl5qbzF0dERANQmFOU65T6VHSeNSiw1FbCyqrgTIeXm5iIwMBCurq7YsmVLqRfT8ePHo2bNmpg9ezZmzZqFadOmlbhv9+7dAQBXrlzRe8xFWVlZAUCpj3jK8xn1LTc3t9RK9DfeeAPLli3DF198AWdnZ/Tv399osZXFwYH+vrWRLZcjVaGAlZVVwaOlomqoGWxNmUgeP36ssi3633nHPavIyLmcNCoxFxea5TIhQS6xLUMAACAASURBVOpItBMUFITs7GwEBwcXa8HUuHFjnD9/vti+P/74I5KTk7Fz506sWLECQaU8kwsKCoJcLkdISEip5581axbMzMwKKkHLq27dugCA5OTkUmPR9DPqU0pKCoQQBTGqM2/ePMydOxdr165FUlISDh8+bLB4yuvhQ+3n47DMyoKdhQWysrKQlpamsv3p06cq63r27AkACA0NVdmmXNe7d2/tAqpgOGlUYp060UjQBw9KHUn5LVq0CNevX8fevXtLrdQuyt7eHoGBgWjVqlWpCcHT0xMLFy7EP//8gx9++EHtPrdu3cL69esxYsQItY8rNNG8eXMA6u9OAe0+o74o746VMarz66+/wsPDA5MmTdKoXsZYLl2iATa1btyRlgZ/d3cAUEmEsbGxaltBde/eHT4+PggJCSlWQZ6Xl4edO3fCzc0NAQEBWgZUwUjbT4QZ2siRQrRoYdwhQ8pSVge0zZs3FwzhUdJy7ty5Et/fu3dvjTq4zZ49W1hYWIiPPvpI3Lp1S2RnZ4vHjx+LjRs3irp164quXbuKtLS0Et9fVue+/Px8Ubt2bdGlSxe9fMYxY8YIAOLevXslxqRp577t27cLAKUOV+Lq6ipatmxZ5rGM7bXXaFgRDfs+qmrXTtyZPFk4OTkJV1dXcfToUZGamiquXr0q+vfvL9zd3YWlpaXK286dOyesrKzEqFGjRExMjIiPjxdBQUFCLpeLw4cP6/ahKg7uEV7Z3bxJHWCXLpU2jn379pV4cfz++++L7RsQEKBT0vDz89O4x/mFCxfE2LFjhZubm7CwsBB2dnaiY8eOYuXKlSI7O1vte0q64KempqrsO3fuXLU9wrX5jL169RK2trYi94U7gPL8bpUCAwOFq6uryMnJKfF34+rqKnx9fUvcLoU9e2gUkAMHdDiIt7cQn3wibt26JYYMGSLs7e2FjY2N6Ny5s/jzzz9F79691SYNIYS4dOmS8Pf3F/b29sLW1lb06tVLnDlzRodgKhxOGlXB118LYW5OX7iqICAgQMhkMqnDEEIIkZSUJFxdXVXGniqvxMREYW1tLSZNmqRzTMqxp3bs2FHqfi4uLqJjx446n09fLl0Sws5OiLff1vFA9erRl6IEpSUNxsOIVAkffEBzFIwcST1qK7v69etDCIG4uDipQ4GDgwP27duHkJAQrFmzRqtjCCEwbdo02NvbY8mSJTrFc+/ePQwbNgxz5szBqFGjStxPoVDg+fPnGndMNLTz5wE/P6BjR+Dbb3U4UHY2VYi89JLeYqtqOGlUEd99B0ydCowaRbPz6W1+AhOkbBr62WefIcEEmo61atUK//zzDw4dOlQwn0Z5xMXF4d69ezh27BjqaNtk6F/r16/HsmXLsGzZshL3SU5OxooVK6BQKEyime3WrUDv3kDnzsDevTo2IVfOpeHhobf4qhypyzrMuLZsEcLWVojWrYW4dUvqaAzn888/F97e3sLS0lL0799f6nAqjHHjxgkLCwvRuHFjsWDBApX6E2N6+lSIQYOEkMuFWLhQT405jhyhSpHnz1U27dixQ6VOaOLEiXo4aaXyjOcIr4Ju3wbGjAGuX6fxe2bOBOzspI6KMaJQABs2AIsX0+ySP/9MpQy9WL8e+OgjmpScaYPnCK+KmjQBzp4FFi6k58ONGwNr1tCXlTGpCAGEhADNmtHNzBtv0FAheksYABAVxY+mdMRJo4qysKDRQu/coS/nhx8CXl7AypU09wZjxpKTA2zbBrRtS4012rcHIiKAr76i4UL06sYNoGlTPR+0auGkUcU5OdGXMyIC6NcPmD8fqF+fKsvv3JE6OlaZxcUBn3wCuLsDEydSCfiff4CffqIh0A0iNBRo3dpAB68auE6DFZOUBGzaRI+rHjwAevYEXn+dZkurIoN4MgPKygIOHAC2b6dXOzsa6nzKFCNMEhYfDzg7A0ePAn36GPhklVY8Jw2mVl4esH8/NXc8eJCeNw8YQAkkIADQw+ytrIrIy6O5L7Zvpylb09OBHj3oseioUTQSs1EcPUrF6adPKXkwbXDSYGVLTqb28bt3A4cPU31Ily7AwIHAkCH0eIGxohISgOPHgT/+AH77jfrT+fgAb75JSymD6xrOZ59REfrfuTSYVjhpsPKJiaE5xw8epLvHtDRq7TJgAJX4O3WiKZhZ1ZKTQ/URx47RY6eLFwG5HOjWjf42Bg+mVnqSGjmS5gr47TeJA6nQOGkw7WVnA6dPUwI5eBC4dYsuFK1bA1270tDVXboAtWpJHSnTt9RU4Nw54MwZ4NQp4MIFuh7Xrw/4+9PSp4+J3UA0agSMHQssWiR1JBUZJw2mP0+eUBJRXkiuXaO6EC8vak7Zpg0lFF9f7kxYkWRlAVevUsOjS5eoRHHlCtVVNGlSeIPQtasJlCZKEhtLz8S4ElxXnDSY4SQlUQL566/CC058PGBmRheb1q2BVq2A5s0psbi70zYmnehoan594wZw+TL9n924QR0/7e0p4bduTR3uunaVqG5CGyEhVOuekGCAzh9VCicNZlwPH9KFSJlEwsKohAJQiywvL+p75eNDP3t6Upt9/p7rT2YmcP8+DScTEVGYJG7dokYPAPXf8fUtLB22bk2liAqb1GfMAE6coEzIdMFJg0kvKYkuWNev0+vNm7Tcv0+PQAC6iDVoULh4eNCruztQuzYtMpl0n8GUPH9OT2MeP6bfYVQULcqfi44Y7+5OSdrbmxYvL0rYla5FaocOQLt2Oo6rzsBJg5my7Gzg3r3iF7yiP8fHF+5rYUGJo25doE4dWurVo3U1awI1alDiqVGj8OeKkmSSkoDERFqeP6fXhATqbhAXR4+Unj6l17i44sPe29sXJlhlslUuDRsC1atL9amMKDOTeqZu3kwdjZguOGmwiis1le6m1V04Y2LobvvpU7rQKkssRTk6FiYQS0saUdXOjhKQo2PhOltbWgfQRfbF+RyKbgdougblYx6lvLzCMb2U27OzgYwMIDM5B5l51ZCUVLguObkwUeTnq8bu5FRYwnJ1BVxcVBNmvXq0X5V36hTQvTvdbRhsfJIqI14udQSMacvOrvCxSlmKXoSL3rErf1ZerFNTqc/BvXvUaigzky72yqSz6Mlk7LB4E+flXYsd+8ULu6OjaklGuU4mK0xK7XPOYPm1UZjT7xKcGtYuSFQODoWlohdLSTVqVJxSkkk4fZoyKycMveCSBmOaSkmhq/1vv1F3eH3IzKSKBH9/YN06/RyTFde9Oz2L27xZ6kgqA55PgzGNXblCHU9atNDfMa2tabahjRupMwTTL2UvxL59pY6k0uCkwZimwsOppOHmpt/jjh1LHVY++EC/x2XUzDYvjyYZZ3rBSYMxTV25QqUMfVcomJnR7FcnTgCHDun32FXd0aOUkGvXljqSSoOTBmOaun6duq8bQufONGTwhx8CubmGOUdVdPQoP5rSM04ajGnqzh0a/8RQvvySmm19/73hzlGVREVRt3cea0qvOGkwpomMDOr04eFhuHM0bAi89x6wcKFqRw9WfkePUseaLl2kjqRS4aTBmCbu36eWUw0bGvY8CxbQeZYvN+x5qoL//Q/w81Ptjcl0wkmDMU3cu0evhixpANQ6a8EC4Jtv6HEY005SEs0IFRgodSSVDicNxjRx/z61wDHGrEJTptCQsvPmGf5cldWePdTKTV+dMFkBThqMaeLJExqKwhjkcuDTT2lS9rNnjXPOyiYkBOjXj8fUNwBOGoxpIj7euPPWDh4M9OgBzJ5tvHNWFklJwB9/AK+9JnUklRInDcY0kZBg/MnOP/+cShoHDhj3vBXd3r30yo+mDIKTBmOaiI+niTmMqV07KnHMmaN+fHSm3u7d1KGvRg2pI6mUOGkwpomEBOMnDQBYtozmYt21y/jnrogSE+nR1PDhUkdSaXHSYEwTiYnSzGjUrBkwZgy1pMrJMf75K5rt22ksryFDpI6k0uKkwZgmcnKk6yS2eDG13uL5IMq2eTMwYgT1d2EGwUmDMU3k59MdrBTc3YG33wY++YSGM2HqXb0KhIYCEyZIHUmlxkmDMU1ImTQA4OOPgbQ0YM0a6WIwdZs2UY/9V16ROpJKjZMGY5rIzwfMzaU7v7MzMHUqdfpLTJQuDlOVk0P1GRMn8gTqBsZJgzFN5OVJW9IAgFmz6IK4YoW0cZii336jFm5vvil1JJUeJw3GNGFuTolDSg4OlDi+/hqIi5M2FlOzeTMNG6LvqXiZCk4ajGnCwYGGp5DatGnUaY2HTi8UFQUcOQK89ZbUkVQJnDQY00SNGqZRl2BtDcydC6xfT81wGfDdd4CLC/Dqq1JHUiVw0mBME3pMGomJiVi3bh169eoFJycnWFtbo0mTJhgzZgzCw8PLPsBbb9E4WF99pZd4ynLw4EF4enpCLpcb5XzlkpkJ/PADzXhoYSF1NFUCJw3GNOHkpLekMXPmTEydOhWvvvoqbty4gYSEBPzwww8ICwtDmzZt8L///a/0A1haAh9+SKWNZ8/0EpM6d+/exeDBgzFnzhzEmWodyk8/UVPkiROljqTK4KTBmCb0/HjqrbfewvTp01GnTh3Y2NigW7du2L59O/Ly8jBr1qyyDxAURPNfr1ypt5hetGDBAnTu3BmhoaGws7Mz2Hl08u23wKhR9HiKGYVMCCGkDoIxkzdvHg25fe2aQU9jY2OD7Oxs5ObmQlZWf4Ply2n49AcPDDJsRmZmJqytrQEA9evXR2xsLHJzc/V+Hq2dPAn07AlcuEAjAjNjiOeSBmOa8PYGbt8GDHjRTE9PR2ZmJpo3b152wgCA99+nviMG6iWuTBgma/VqoFMnThhGxkmDMU14eVGv4/v31W6OiIjAkCFD4ODgABsbG7Rv3x779++Hn58fZDIZZDIZJk2aVOopdu/eDQCYp+nc4Pb2VAH89df0XL8M+ojRZDx4QB363n9f6kiqHsEYK1tqqhAymRB796psun37tnB0dBSurq7i6NGjIjU1VVy7dk34+fkJZ2dnYWlpWebhY2NjhYuLi5g0aVL54oqPF8LWVoivvip1N11jdHV1Febm5uWLzZCmTRPCzU2InBypI6lqnnHSYExTbm5CfPaZyurAwEABQISEhBRb//TpU2FjY1PmBTk+Pl74+vqKkSNHitzc3PLHNWOGEHXqCJGRUeIuusZoUklDmSi/+UbqSKqiZ/x4ijFN+fgA16+rrD58+DAAoF+/fsXWOzs7w8vLq9RDpqeno1+/fvDx8cHPP/8Mc20GRZw5E0hOBrZsKXEXXWI0OatW0dwm3MxWEpw0GNNU+/bAX38VW5WdnY3U1FRYWVnB1tZW5S01SpmnOjc3F4GBgXB1dcWWLVu0SxgAUKcOMH48jYCrZnY/XWI0Oenp1AN8+nRAzWdhhsdJgzFNdesG3L1bbPgOS0tL2NnZISsrC2lqKqOfPn1a4uGCgoKQnZ2N4ODgYr2tGzdujPPnz5cvttmzgdhYYMcOlU26xGhy1q2jXuBTpkgdSZXFSYMxTXXqRI9Fjh8vttrf3x9A4SMgpdjYWERGRqo91KJFi3D9+nXs3bsXlpaWusf20kvA6NHA0qVqR+PVJkaTo1DQo6mgIBpGhUlD6loVxioUPz8hRowoturOnTvCycmpWMukq1eviv79+wt3d3eVSubNmzcLAKUu586dK39st28LYW4uxK5dKpvKG+OLTKIifNMmIapVE+LRI2njqNq4Ipyxchk0iIbhLlJ30KhRI5w7dw7t2rXDa6+9BhcXFwQFBWHOnDlo3LixyiFCQkIME1vjxsDw4dRT/IWBHsobIwDs37+/oP9GdHQ08vLyCv69ceNGw3yGkuTm0ucaOxaoX9+452bF8DAijJXHw4c0D/WePcDgwWXu7ufnhzNnziArK8sIwQEIDwdataIhTwYN0ugtRo9RGz/8ALzzDhARATRsKHU0VRkPI8JYubz0EtC9O7B1q9SRqNeyJRAQAPzf/0kdif4oFMCyZcCECZwwTAAnDcbKa9w4YP9+gw5LrpMPPwTOnAHK2wLLVP34I/DoEbUQY5LjpMFYeQUGAnZ2wNq1Je6yc+dOyGQyHDt2DNnZ2cYd16lHD+pT8vXXpe4maYyaUiio/8nEifRYkEmO6zQY08aCBcCGDTQ/tSmOBrtjB1UaR0ZW7Ec669fTvOi3bgENGkgdDeM6Dca09N57QEoK8P33UkeiXmAg4OpKw4dXVNnZ1GJq0iROGCaEkwZj2qhTB5g6FViyhJKHqZHL6Q590yYgKUnqaLSzbh3VG82dK3UkrAhOGoxpa+5cID8fWLFC6kjUmzyZJmnasEHqSMovNZVKGdOmUYmJmQxOGoxpy9GRRphdsaLYeFQmw86OHu2sWqV2IEOT9vnnVAmuyXzpzKg4aTCmi+nTgdq16dUUffAB8PQpEBwsdSSai4kBvvmGSnJOTlJHw17AracY09WJE0Dv3tRL/NVXpY5G1ZgxwLVrQFgYoMnc41J75x3qB3P7tmm2TKva4jlpMKYPY8cCf/5JkzTZ2UkdTXGXLgFt2gB//EHJzZRFRgLNm1M9zPjxUkfDVHHSYEwvnj2ji13//qXOoCeZnj3prv3gQakjKd1rr9H4UuHhgLaTUjFD4n4ajOmFszMli23bgJ9+kjoaVR9+CBw+rHa6WpNx+jTwyy9UCc4Jw2RxSYMxffrPf4CNG4HQUMDTU+poCglBJaFOnSg+pZwcICQEGDlS2gt1fj7QoQPg4ECP0Zip4sdTjOlVdjZdmPPzgbNngerVpY6o0PffU4fEqCiqEF+/nnqMx8fT4zUpZ8PbvBl4+23g8mXg5Zeli4OVhZMGY3r34AENGNilCz1uMZUWS1lZ1FGuQQPg6lVap1DQ661bxikZ7d5NlfJFx8NKSwOaNgWGDAHWrDF8DEwXXKfBmN65uwO//gocOAAsXix1NDRn+L59gL8/8Pw5JQyFojBhALTeGFasALy9aS7z7Gxa9/nnQEYG8MknxomB6YSTBmOG0KUL9cT+5BOqHJdCaipNXlSvHvUfOX2a1hdNFkqJiYaPJzeXHj/l5ACLFgE+PsDOnZRIFiyQ9vEY05hc6gAYq7SCgqj+YMIE6rsxZIhxz29tDfz9N/UIB6jEoY6ZmXFKGleuFJYu8vLoMd7o0fRYbOhQw5+f6QWXNBgzpOXLqZPa66/TbHrGJJdTy6iePQELi9L3M0bS+PtvOpeSMondv0+V3ytXlpzYmMngpMGYIclkNMR3nz7AoEHAxYvGPX+1asD//kf1CCUlDpnMOEnjwgX16xUKID2dmiu3amX83xErF04ajBmaXE6thl55hZLH338b9/z29tT3wc2t+J2+khDGqdM4fZrqNUoiBFXSb9pEPzOTxEmDMWOoVo1Gmu3SBejXz/iJw9kZOHmSKptfTBy5uYYvaSQlAffulbzd3JzqVj77jEpmptJMmangpMGYsVhaUlPcrl0BPz/g99+Ne343NzqnjU3x3t/5+dS5z5AuXCi59CCXUyfIo0eBjz4ybBxMZ5w0GDMmS0uqYxgxAhg4kJqcqhMdTa2v9K35/7d39zFR13EcwN9Hh+MGBkpTK5mr1Gxq6pJSN4ExYytZGtaUfGg2FTWXF9PWFpt/5AzTpZg6W6al5kaWSFGbW2JBIqbGVmri02zyEGlTfLoTz7v+eEuID0R6v/v+jnu/Nkfh7ff7Hpv34ff9fh4GANu383zjxt/mrQ4alZV82rqZ0wn07s1UXLt34BUAChoioed0sv/T669z1kVBQeu/9/uBCRPYHnzz5uDff9gwZlVF3fDP3+rtqYqKW+tDoqL4xLVnT+sKcbE1BQ0RExwOFrXl5wO5ucDs2S2HxPn5/JB1OPi0cepU8O8/ejT7PTU/bZw7F/x7NAsE+KRx8/bU/Pmsmr//fuvuLUGn3lMipn33HYvcnn6aI04zMloCSHQ0MHQoM4+s6EK7ahUwZw6vffVqSxA5fRpoaGBW1ZUrgMfD3lXR0UBcHJ+WunThqNvu3Vs/tdzs+HFuQQG8T3Q0q+Rfein470espoaFIrbw66/AlCncJqqvb52aGhXF/kzz5gX3nn4/75uXx9/409OZ4VRf31K53R5OJwNH375sDTJwIPDkk2xM2KkTt9gmTmx53bffAoMGBfe9SKgoaIjYxuTJPBi/XS1DdDSL3u71w/bYMeDrr5l+W17ObSmXi9lLqal8qnn4Yf558EGga1d+8MfE8HVNTSzE8/n4FNLQANTUMNBUV3MW+cGDQGMjs7SGD+frKyuZblxUxPRfCVcKGiK28OWXwMsv3/nvnU7gkUc4BtXl+n/XPnGCUwWLilg8l5jI1iIpKQwUAwbwvMHrDd78j6NHGZR+/JGBsKmJ3X/HjWNwHDw4OPeRUFPQEDHu1Cmgf3/OlWjrn6PTyfOHZcv++5p+P9uhr1nD+ocePYCsLDYGTE0N3ZS+a9eADRu4XbV1K+eLVFdzSt/MmcwSi4kJzVokGBQ0RIzy+fghXlHRvtc7HCzQu1NNg9/PM4MFC/hUkp4OzJjBDrttNS0Mpf37mU68cSO7/+bmAm+88f+foMQEBQ0Ro7xeoLgYKCnhh/3ZszxDaGq6/eujongmcOgQzxtuVFrKca7V1fwNPi8P6NfP+vdwt+rqgPffZwDp2pX//corplclbVPQELENv5+V0d9/z62cvXtbUllvbBkeHQ08/zwrywEeRufmMkvphRf44fv446Ff/92qr+dQprVr+dS1erW9g11kU9AQsa3aWj59lJRwS8rrZRuS5nTYDRv41PHqq8xUKihg0AhXP/8MzJoFHD4MLF8OTJ9uekVyKwUNkbDg9TITqaSEWVC1tdzGunqVWzqrV3eMymqfj+cx+fnMJlu3jgFR7EJBQyTsXLnCmd87drAdSFFRx2slvmMHMH48Cwa/+YZpwmIHChoiYcXjYaCoquKZRmqq6RVZp7oaeO45bsnt3Mm0YTFNQUMkbPh8rLWoqOCH6MCBpldkvfp6FiK6XKxij483vaJId0ZdbkXCxZw5TKstKYmMgAGwlcn27WygmJXVOotMjFDQEAkHX3zBeobPP+c8jEjSqxezyCoqgIULTa8m4ml7SsTuamr4ZDFxIrBypenVmLNqFeB2A2VlbIQoJmh7SsT23nmH2UNLlpheyX8qLCzE4MGD4XK54HA44HA4cODAgeBcfPZsnm+43W336BJLKWiI2FlVFbBpE/Dee5b0Zrp48SL69OmDzMzMe77Wrl27kJ2djYyMDJw+fRrHjh1Dz549g7DK6xwOBs59+7hdJ0Y4TS9ARNqwbBnbiFs05S4QCMDv98Pv99/ztbZs2YJAIIC5c+ciLi4OcXFxOBXsUbWDBrF+Y+lSfpWQU9AQsavz59lK/IMPLCve69y5M44fPx6UazUHiESrC/FycoC0NHbx1QTAkNP2lIhdFRezieGECaZX0i7XQpUOm5ICPPYYhztJyCloiNhVeTmQnGxZQdu2bdv+Pax2OBzwer23/f7Jkycxfvx4JCQkIDExEZmZma2eTppfX1xcDAD/HoIPsyo12OHgPJGffrLm+tImBQ0Ru6qstDS1dOzYsQgEAhgzZkyb33e73XC73aitrUVhYSFKS0uRnZ19x9d7PB4EAgFUVlZatnaMGMED8atXrbuH3JaChohdnTxpi7kY06ZNw/DhwxEbG4tRo0Zh9OjR2Lt3L86cOWNuUX37svNvQ4O5NUQoBQ0RO2pq4sxwG3R3TU5ObvX/SUlJAIC6ujoTy6Hmn4vJwBWhFDRE7OjyZRaw2WBudvxNZyqdOnUCgKCk6d61uDh+vXTJ3BoilIKGiB3FxwNOJ2eGy63+/ptfb56TLpZT0BCxI4cD6NKF3V3lVs0/lwceMLuOCKSgIWJX/fuzjYjc6pdfgG7dOCNdQkpBQ8SuRoxgO3CL3K6+YtKkSaisrLzl+3l5eQAAh8OBxYsXAwCGDBmCzMzMO9ZpWJpyu3s3fz4ScmqNLmJXpaUsYvv9d6BfP9OrsY9LlzicadEiDqaSUFJrdBHbSkvjAKL1602vxF4KC4ErV8KmvUpHo6AhYldRUcDUqcC6dUBjo+nV2IPfD6xYwdGvOgQ3QkFDxM7mzmW9xvVzhIi3aRNw4ABw/YxFQk9BQ8TOEhI4uW/5cqC62vRqzDp7lj+LqVOZWSZG6CBcxO58PmDkSLYW2b0buF6RHXGys4GdOzlHo3t306uJVDoIF7E9pxPYuBE4epTbVZGooIAjXjdvVsAwTEFDJBz07g189hnw8cfAu++aXk1oFRYCubmck56ebno1EU/jXkXCxYsvAqtXAzNnAjExwPz5pldkva++AqZM4RPWW2+ZXo1AQUMkvMyYwTkSb74J1NZyfnhUB90wWLmSwWLWLGDpUtOrket0EC4SjrZsASZP5nbNp5+yD1NH4fEAbje34hYtAt5+2/SKpMUZBQ2RcLVnDzOKvF6edzz7rOkV3bvffuN7qqsDPvmEW3JiJ8qeEglbzzzDLrgjRwIZGcDEiUB9velV3Z2LF4F584CnnmJtSlWVAoZNKWiIhLP4eGYXFRezI+4TTwALFwLnz5teWfs0NQFr1rAh4/r1wIcfAmVl7LkltqTtKZGOwuMBliwBli3j4bjbDeTk2PO848IFYMMGtkf56y9g+nRgwQL1k7I/nWmIdDjnzrEYbsUKbvuMHcusq7Q04L77zK5t3z5g7VoW6fl8wGuv8aC7Z0+z65L2UtAQ6bA8HlZRf/QR249068YAkpUFpKQALpf1a/D5eGC/bRuwdStw4gS30HJyWH/RpYv1a5BgUtAQiQiHD/NDe+tWYP9+9q9KTmbwGDoUGDgQePTRe38S+eMP4OBB3qO8nOcsly4BffsyWI0bx/tJuFLQEIk4tbXADz/wwLmsDDhyhHMqXC5+uCclcTLeQw/xoD02lkEmNpbpvR4PvzY2An/+CdTUMGururrlAL5XL2Z1paQA058K1QAAAGpJREFUqam8rnQEChoiEe/yZeDQIdZIHDnCGonmPxcu8FykqYlPDDExDC4uF9C5M5sHJiUBPXoAffoAAwawbXlCgul3JdZQ0BARkXZTcZ+IiLSfgoaIiLSbgoaIiLSbE8AW04sQEZGwcOEfBU/DpVryLLAAAAAASUVORK5CYII=", - "text/plain": [ - "" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "draw_dag(dep_graph_copy, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{0, 1, 2}" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dep_graph_copy.qubits_used = dep_graph_copy.update_qubits_used()\n", - "dep_graph_copy.qubits_used" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[-1,\n", - " 0{CX(0,1)},\n", - " 1{CX(1,0)},\n", - " 2{X(2)},\n", - " 3{CX(2,1)},\n", - " 4{CP(1,0)}(1.571),\n", - " 5{barrier(0,1,2)},\n", - " 6{RXX(0,1)}(1.571),\n", - " 7{delay(0)},\n", - " 8{CSWAP(0,1,2)},\n", - " 9{MCX(0,1,2)},\n", - " 10{MCY(0,1,2)},\n", - " 11{MCZ(0,1,2)},\n", - " 12{CT(2,1)},\n", - " inf]" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "nodes" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## node_dict" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "12{CT(2,1)}" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dep_graph.nodes_dict() \n", - "dep_graph.nodes_dict()[12]" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "6{RXX(0,1)}(1.571)" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dep_graph.nodes_list()[6]" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{0: 0{CX(0,1)},\n", - " 1: 1{CX(1,0)},\n", - " 2: 2{X(2)},\n", - " 3: 3{CX(2,1)},\n", - " 4: 4{CP(1,0)}(1.571),\n", - " 5: 5{barrier(0,1,2)},\n", - " 6: 6{RXX(0,1)}(1.571),\n", - " 7: 7{delay(0)},\n", - " 8: 8{CSWAP(0,1,2)},\n", - " 9: 9{MCX(0,1,2)},\n", - " 10: 10{MCY(0,1,2)},\n", - " 11: 11{MCZ(0,1,2)},\n", - " 12: 12{CT(2,1)}}" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# make a node_dict\n", - "node_dict = {}\n", - "for node in nodes:\n", - " if node != -1 and node != float('inf'):\n", - " node_dict[node.label] = node\n", - "\n", - "node_dict \n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "5{barrier(0,1,2)}" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# test the node_dict\n", - "node_dict[5]" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q[0] --*----+---------P(1.571)----||-------#---------Delay(100ns)----*----*----*----*-------\n", - " | | | || RXX(1.571) | | | | \n", - "q[1] --+----*----+-------*--------||-------#-------------------------x----*----*----*----T-- M->c[1]\n", - " | || | | | | | \n", - "q[2] --X---------*----------------||---------------------------------x----X----Y----Z----*-- M->c[2]\n" - ] - } - ], - "source": [ - "simple.draw_circuit()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 计算qubit used 依据 -1或者inf对应的边的label" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-1 0{CX(0,1)} {'label': 'q0', 'color': 'green'}\n", - "-1 0{CX(0,1)} {'label': 'q1', 'color': 'green'}\n", - "-1 2{X(2)} {'label': 'q2', 'color': 'green'}\n" - ] - }, - { - "data": { - "text/plain": [ - "{0, 1, 2}" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# make a qubit_used dict\n", - "qubit_used = {}\n", - "# 依据 -1或者inf对应的边的label\n", - "nodes[0]\n", - "for edge in dep_graph_copy.out_edges(nodes[0], data=True):\n", - " print(edge[0], edge[1], edge[2])\n", - "\n", - "qubit_used = set([int(edge[2]['label'][1:]) for edge in dep_graph_copy.out_edges(nodes[0], data=True)])\n", - "qubit_used\n" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "set" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dep_graph_copy.update_qubits_used()\n", - "type(dep_graph_copy.qubits_used)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## dag 拼接" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q[0] --------------- M->c[0]\n", - " \n", - "q[1] ------------*-- M->c[1]\n", - " | \n", - "q[2] --H----*----+-- M->c[2]\n", - " | \n", - "q[3] -------+------- M->c[3]\n" - ] - } - ], - "source": [ - "# other circuit to compose\n", - "simple2 = QuantumCircuit(4)\n", - "simple2.h(2)\n", - "simple2.cnot(2, 3)\n", - "simple2.cnot(1, 2)\n", - "\n", - "simple2.draw_circuit()" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# other dag\n", - "other_dag = circuit_to_dag(simple2,measure_flag=False) # dag graph\n", - "\n", - "# draw the other dag\n", - "draw_dag(other_dag, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[-1, 0{H(2)}, 1{CX(2,3)}, 2{CX(1,2)}, inf]" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "other_dag_copy = copy.deepcopy(other_dag)\n", - "nodes_2 = copy.deepcopy(list(other_dag_copy.nodes()))\n", - "# nogate_nodes = [nodes[0],nodes[-2],nodes[-1]] # -1,inf,measure node\n", - "# dep_graph_copy.remove_nodes_from(nogate_nodes) # remove -1,inf,measure node\n", - "# dep_graph_copy.remove_nodes_from([nodes[6]]) # remove -1,inf,measure node\n", - "nodes_2" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### -1 node 的边 " - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# draw the other dag\n", - "draw_dag(other_dag_copy, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 拼接" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dep_graph_copy.merge_dag(other_dag_copy)\n", - "draw_dag(dep_graph_copy, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{0, 1, 2, 3}" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dep_graph_copy.qubits_used" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(set(), 15)" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dep_graph_copy.update_cbits_used()\n", - "dep_graph_copy.update_num_instruction_nodes()\n", - "\n", - "dep_graph_copy.cbits_used,dep_graph_copy.num_instruction_nodes" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## add nodes with giving predecessors and successors lists according to the qubits pos\n", - "这个 predecesors 和 successors 是按照qubits的位置来的，所以要先求出qubits的位置 \n", - "predecessors 和 successors 可以按照dag的nodes的label来求，并且按照the added node的pos也就是qubits来排序后以一个list的形式作为参数传入" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "({0: 4{CP(1,0)}(1.571), 1: 4{CP(1,0)}(1.571), 2: 3{CX(2,1)}},\n", - " {0: 6{RXX(0,1)}(1.571), 1: 6{RXX(0,1)}(1.571), 2: 8{CSWAP(0,1,2)}})" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# predessors of the added node ,make a list\n", - "# for example ,the added node is the barrier node \n", - "\n", - "# 1. get the added node\n", - "# use node_dict to get the added node\n", - "the_added_node = node_dict[5]\n", - "the_added_node\n", - "\n", - "# 2. get the predessors of the added node\n", - "addnode_predessors = copy.deepcopy(list(dep_graph.predecessors(the_added_node)))\n", - "\n", - "# 3. get the successors of the added node\n", - "addnode_successors = copy.deepcopy(list(dep_graph.successors(the_added_node)))\n", - "\n", - "\n", - "addnode_predessors, addnode_successors\n", - "#([4{CP(1,0)}(1.571), 3{CX(2,1)}], [6{RXX(0,1)}(1.571), 8{CSWAP(0,1,2)}])\n", - "\n", - "# 4. remove the edges between the predessors,successors about the qubits used by the added node \n", - "# 4.1 get the qubits used by the added node\n", - "qubits_used_by_added_node = [qubit for qubit in the_added_node.pos]\n", - "\n", - "\n", - "# 4.2 make a predessors dict about the qubits \n", - "addnode_predessors_dict = {}\n", - "addnode_predessors_dict[0] = addnode_predessors[0]\n", - "addnode_predessors_dict[1] = addnode_predessors[0]\n", - "addnode_predessors_dict[2] = addnode_predessors[1]\n", - "\n", - "\n", - "# 4.3 make a successors dict about the qubits\n", - "addnode_successors_dict = {}\n", - "addnode_successors_dict[0] = addnode_successors[0]\n", - "addnode_successors_dict[1] = addnode_successors[0]\n", - "addnode_successors_dict[2] = addnode_successors[1]\n", - "\n", - "addnode_predessors_dict, addnode_successors_dict\n" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [], - "source": [ - "dep_graph_copy.add_instruction_node(the_added_node,addnode_predessors_dict,addnode_successors_dict)" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbYAAAeXCAYAAAC8KUDZAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdd1yV5f/H8ddhiAjiQFSmE00ktTR3TrTMHGWoaX21tKjUbFhpWjmyYcOWObL8OdMcWY60UnNrLtwjt6DgAlFAhcP1++MSFBkyzjn3AT5PHvcDOPd97vt9yM7nXPd9XddtUkophBBCiMLhewejEwghhBCWJIVNCCFEoSKFTQghRKHiZHQAIUThlkACEUQQQwxXuYoZM3HEAVCGMgCUpjTlKIc33rjgYmRcUQhIYRNCWEQkkWxhC/tvfR3gAKc5nVbEcqoc5QgggNq3vu7nfhrRCE88rZRcFDYm6RUphMiLK1xhGcv4m79ZxzqOcQwHHKhKVYIJJoggKlMZb7zxxZdylMMddxxxxAMPAGKISdvXec4TRRRnOMMpTrGXvexnP2c4gwMO1KY2rWhFu1tfxSlu5MsX9ut7KWxCiBy7xjXmMY8FLGA1q1EomtCEVrSiBS1oTGPccLPoMS9zmY1sZO2tr53spAQleIzH6EEPOtEJZ5wtekxRoElhE0Lc2372M5GJzGQmN7lJBzrwBE/wOI+nXSezlbOc5Td+YxGLWMMaylOefvQjjDD88LNpFmGXpLAJIbK2j32MYxxzmENVqtKPfjzP83jhZXQ0QBe5mcxkAhOIIoqe9OQDPqAa1YyOJowjA7SFEBlFEklPelKHOuxjHwtZyGEO8w7v2E1RA/DBh3d4h6Mc5Tu+Yz3rCSKIN3gj151WROEhhU0IkcaMmfGMpxa12MY2FrGIHeygC10wYTI6XpaKUYwXeZEjHOFrvmYGM6hFLeYxz+howgBS2IQQgG6lhRDCMIbxGq+xj310patdF7S7OePMS7zEYQ7zGI/xNE/zDM9wlatGRxM2JNfYhBCsZCW96Y0XXvzMz9SjntGRLGIFK+hDHzzwYBGLuJ/7jY4krE+usQlR1P0f/0cnOtGBDmxne6EpagCP8ii72Y0PPrSgBf/wj9GRhA1IYROiCPuSL3me53mbt5nBDIuPQbMHFanIn/xJe9rzKI+yhCVGRxJWJoVNiCJqGtMYwhC+5Es+5MMCdS0tt1xw4Wd+pg996EEP1rPe6EjCiuQamxBF0EpW8jiPM4xhjGa00XFsxoyZnvTkb/5mC1uoSU2jIwnLkwHaQhQ10URTl7qEEMIsZhkdx+ZucIMWtCCJJDazWe4mUPhI5xEhiprneR533JnIRKOjGMIFF+Ywh2McYwQjjI4jrEAKmxBFyFKW8gd/8H/8HyUpaXQcli9fTo0aNXBysu0dtKpRjc/5nK/5miMcsemxhfXJqUghiggzZupQhyCCmM98Q7McO3aM119/nVOnTnHy5Eni4+NJTk62aQYzZupRjxrUYCELbXpsYVVyKlKIomI5yznIQcYy1ugovPfeezRt2pQdO3ZQsqQxLUdHHBnDGH7lV45xzJAMwjqkxSZEEfEET3CVq/zN30ZHITExEVdXVwD8/PyIioqyeYsNdKutClXoQx/GMMbmxxdWIS02IYqCa1xjGcvoQx+jowCkFTWjOeJIb3rzMz8bHUVYkBQ2IYqALWwhiSRCCDE6it1pS1uOcYxIIo2OIixECpsQRcBmNlOZynjjbXQUu9OIRjjiyBa2GB1FWIgUNiGKgFOcklk2slCSknjjzSlOGR1FWIgUNiGKgEtcwhNPmx1v3759mEymdMvAgQNtdvzcKkc5LnHJ6BjCQmw7KlIIYYgEEmxa2IKDgylIHa7dcOMa14yOISxEWmxCFAFlKEMMMUbHsFuXuUxZyhodQ1iIFDYhioBylOMCF4yOYbcucIFylDM6hrAQKWxCFAG1qc1udmPGbHQUu3Oa01zkIsEEGx1FWIgUNiGKgKY0JY44DnDA6CgALF26NK1TSWRkJGazOe33qVOn2jTLJjbhjDMP8ZBNjyusRzqPCFEEBBNMecqzmMXcz/1Gx+Hxxx+3m84li1lMYxpTghJGRxEWIi02IYoARxx5hmeYxjRSSDE6jt24xCV+4zee4zmjowgLksImRBHRj36c5CS/87vRUezGRCZSjGKEEmp0FGFBUtiEKCKCCKI73RnKUJJIMjqO4S5wgc/4jLd4C3fcjY4jLEgKmxBFyEd8xAlO8A3fGB3FcEMZihtuvM7rRkcRFiaFTYgipCpV+YAPGM5wdrHL6DiGWchCpjGN7/keN9yMjiMsTAqbEEVIFFHc4AZlKENPehbJ+REPcpD+9OdlXqYrXY2OI6xACpsQRcB2tvMsz1KJSkxkIj3pSRJJdKQj8cQbHc9mznCGR3iEYIL5gi+MjiOsRAqbEIVUCiksYQntaMdDPMQ+9vEt33KSk4xnPCtZyQlO0JnOxBFndFyrO8UpWtEKZ5z5nd8pTnGjIwkrkcImRCFzk5vMYAY1qUlXulKc4vzFX+xkJy/yYtpA5EAC+ZM/OchBWtKSc5wzOLn17GEPTWlKAgkc5zg96MEGNhgdS1iJFDYhCokEEviKr6hCFcIIoz3tOcYxlrCEEEIwYcrwnLrUZRObuM51GtKQdawzILl1zWEOzWlOTWpyiEOsZz0ppPAwD9Oc5qxildERhYVJYROigLvGNb7ma6pTnRGM4Cme4ihHmcAEKlP5ns+vTGU2sYkGNKANbRjJyEIxzu0qV3me53mGZ3ie51nBCkpRiuY052/+Zg1rcMaZEEJoTWv+4R+jIwsLkcImRAGVQAIf8RGVqMR7vEcf+nCCE3zN1/jim6t9laEMv/IrX/M14xjHAzzAWtZaKbn1zWUu93EfS1jCb/zGV3xFMYql26YVrVjDGjawAXfcaU1rmtOc9aw3KLWwFClsQhQwZsz8xE/UoAaf8AkDGchJTvIxH+OFV772PYAB7GMflalMa1rTk552c0eAnFjPelrRit705jEe4xCH6ESnbJ/TjGYsYUlaIW9JS57gCfaz3xaRhRVIYROiAPmbv6lPfcIIoyMdOcIRRjHKond/rkpVlrKUxSzmAAe4n/t5mqfZwQ6LHcOSFIq/+Is2tKEFLTBhYhOb+IEf8MQzx/tpQQs2sIE/+ZPTnKYOdehOd45y1IrphTVIYROiANjPfjrSkXa0wwsvdrGLyUymIhWtdszOdCaccOYxj4McpAENeIiHmMpUrnDFasfNqSii+IzPqEEN2tMeEyb+4R/WsIZGNMrzfkMIYRvbmMUswgmnNrUZyECiibZgemFNJmUvN0USQmRwiUu8xVtMZzqNaMRnfEYzmhmSZQMbmMxkFrCAFFIIIYRudOMxHrNqgb1Tai/PRSxiIxvxwINneZYwwqhNbYsfL4kkpjGN0YzmKlcZxjBe4zUZA2ffvpfCJoSdmslM3uRNilGM8YznKZ7KtMu+rT3Hc8xnPq1oxWpWk0giNahBC1rQlKbcz/0EEZTvG3fGEss+9rGHPWxkI2tZSySRlKY0nejEkzzJIzyCK64WemVZSyCBb/mWsYylFKUYy1ie5Vm7+O8hMpDCJoS9Oc5xXuEV/uRPXuAFPuMzPPAwOhYA05meVti60Y144tnIRtaxjrWsZQc7SCQRBxyoQhUqUQlffPHGm7KUpQxlAN0L04yZOOLSvkcTTRRRRBDBSU5yhjMAlKIUjWlMi1tfDWmYoYejrZzlLKMYxY/8yIM8yJd8SXOaG5JFZEkKmxD2IplkJjCB4QynKlWZwhQa09joWGm2sIVWtGIoQxnJyEy3MWPmOMfZy14OcIAIIjh76yvm1pdCEUssDjjggQeJJOKFF374UZGK+OGHP/4EE0xtalOJSrZ9oTmwi128wRusZS096MEnfGKXOYsoKWxC2IPtbOd5nucYx3if93mDN3DG2ehYaaKIogENeJAHWcxiHCzU7yyZZFxxZRaz6EEPi+zTlv7mb17jNY5znLd5m2EMwwUXo2MVdd9Lr0ghDGTGzId8SFOaUp7y7GUv7/COXRW1JJLoTnfccGMmMy1W1ACccKIiFTnNaYvt05ZCCGEXu/iYj/mSLwkmmJWsNDpWkSeFTQiDHOMYLWjBWMbyGZ/xF39RlapGx8pgEIMIJ5xFLKIUpSy+/wAC0q6nFUTOODOYwRzkIE1owqM8Sic6FejXVNBJYRPCAAtYwIM8SAIJbGc7gxlslz3spjOdKUzhJ36ySnd6AH/8C0UR8MWXGczgb/7mP/6jFrUYyUhuctPoaEWOFDYhbCiZZIYylO50pwtd2MQmqxWM/NrCFsII433e5ymestpxAggosKciM9OWtuxiF2/yJp/wCQ/xEFvZanSsIkUKmxA2cpazPMzDTGACs5nNDGbYZAxWXkQRxVM8RXva8z7vW/VYhaXFdidXXBnFKPaylwpUoBnNGMIQEkk0OlqRIIVNCBvYznYa0pAYYtjGNp7maaMjZenOziIzmGHRziKZ8cefC1wggQSrHscIqTdz/ZmfmcY0gglmDWuMjlXoSWETwsrmMpcWtCCYYLawhfu4z+hI2RrEIHaxi0UsojSlrX68AAIAiCDC6scySiih7Gc/dalLW9oSRhhXuWp0rEJLCpsQVjSOcfSiF2GEsYxlNikU+ZHaWWQa02x27c8ff4BCdzrybhWpyCIWMY95LGIRdajDX/xldKxCSQqbEFagULzDOwxlKOMYx3jG44ij0bGyldpZ5D3es2pnkbt54UUJShSqDiTZCSWUfeyjAQ14hEd4gRe4xjWjYxUqUtiEsLBkknmWZ/mKr5jDHIYwxOhI9xRNNKGE0opWVu8skhk//Ap9i+1OFajAfObzC7+wmMU8yINsY5vRsQoNKWxCWFASSfSiF4tZzDKW0ZOeRke6p9TOIiUowVzmGtKyLIw9I3PiKZ5iP/sJJJCmNGUkIzFjNjpWgSeFTQgLMWOmD31YxjKWsIQQQoyOlCOv8io72WmzziKZKWxj2XKjPOVZylI+53M+4RPa0a5Qd6SxBSlsQliAGTM96MESlvAHf9Ca1kZHypEZzGAyk23aWSQzRbXFlsqEicEMZjvbuchFggnmZ342OlaBJYVNCAt4hVdYznKWsYwWtDA6To5sYQsv8qLNO4tkxh//Ittiu1MwwWxmM93pTi968SIvEk+80bEKHClsQuTTB3zAj/zILGYVmKJmdGeRuwUQQDzxXOay0VEM54YbU5jCwltfTWjCUY4aHatAkcImRD78wA+MYQwTmciTPGl0nByxh84idysqY9ly40meZDe7ccWV+tRnMYuNjlRgSGETIo82sIGBDGQEI3iBF4yOk2P20Fnkbqmzj8jpyPT88GMd6+hOd57kSYYylBRSjI5l95yMDiBEQXSOc/SgBx3owEhGGh0nx1I7i8xjnl3dVcANN8pSVlpsmXDBhR/4gYd4iEEMYi97mcUsylDG6Gh2S1psQuTSDW7QhS6UprTF7yhtTVvZyou8yAhGEEqo0XEyKOo9I+/lRV5kIxvZxz4a0pC97DU6kt0qGP9HCmFH3uVdDnGIxSymJCWNjpMj0UTzFE/RkpZ8wAdGx8lUUR7LllMNaMBWtuKNN01pygIWGB3JLklhEyIX/uIvvuIrvuM7Agk0Ok6OpHYWccWVecyzi84imZEWW85UpCKrWEVf+tKd7nzO50ZHsjtyjU2IHLrEJfrSl6d4iv/xP6Pj5NhgBrOTnWxhi910FsmMP/4sY5nRMQoEZ5z5lm8JJJDXeZ3DHGYiE3GSt3RACpsQOTaEITjgwCQmGR0lx2Ywg0lMsrvOIpkJIICznMWM2W5blfbmVV4lgAB60YsLXGAOcyhBCaNjGU5ORQqRAxvZyHSm8zVf57k3Wnh4OB07dqR06dKULFmSkJAQNm7caOGkt+1kJy/xEsMZnufOIsuXL6dGjRo4OVn/M7A//iSRRBRRed5HTEwMkyZNok2bNpQtWxZXV1cCAwPp3bs3u3fvtmBa+9GVrqxhDZvYRGtac57zRkcynBQ2Ie4hmWQGMIB2tMvzIOytW7fStGlTSpYsycGDBzlx4gRVq1alVatW/PnnnxZOrDuLdKELD/NwnoYjHDt2jM6dOzNs2DCio6Mtni8zlhjL9tZbbzFo0CC6dOnCgQMHuHTpEj/99BPh4eHUr1+fxYsL5yDnRjRiM5uJJZYmNOEwh42OZCiTUkoZHUIIe/Yt3/IWb7GXvXnqMJKSkkKdOnW4fPkyx44dw9XVFQCz2Uzt2rVJSEjgv//+w8XFxSJ5k0iiHe04y1n+5d88XVfr1asXderUYciQIVSuXJmoqCiSk5Mtki8rSSThiitzmEN3uudpH/3798fR0ZHJkyene3z37t3Uq1ePwMBAjhw5Yom4duk85+lEJ05wgt/5ncY0NjqSEb5HCSGylKASlLfyVq+r1/O8jzVr1ihADRo0KMO6kSNHKkAtWLAgPzHTeVm9rNyVu9qr9uZ5HwkJCWk/+/r6KkdHR0tEuydf5as+U59ZZd+urq7KwcFBpaSkWGX/9uKauqY6qU7KTbmpVWqV0XGMMEFORQqRjR/4gRhi8nUX7NWrVwPQoEGDDOtSH1u1alWe93+nmcxkEpP4iZ8IJjjP+0ltVdqatbr8x8fHk5iYSHBwMCaTyeL7tyduuPErv/IUT/EYj/EbvxkdyeaksAmRhRvcYBzjeImX8MEn3bpDhw7RtWtXSpUqRYkSJWjYsCFLly4lJCQEk8mEyWSif//+adsC+Pn5ZTiGr68vgEVOj+1kJ2GEZdpZJDd5jRRAQIbCZons8+fPB2D48OFWy25PHHHkJ37iGZ6hO91ZyEKjI9mW0W1GIezVVDVVuSgXFaki0z3+33//qdKlSytfX1/1559/qqtXr6p9+/apkJAQ5eXlpVxcXNJt365dOwWoLVu2ZDjGf//9pwD14IMP5itrlIpSfspPtVftVbJKzlfeu9nyVOSb6k1VX9VP+z2/2ZVSKioqSlWoUEH179/fmtHtUopKUQPUAOWknNQCZbnT3XZughQ2IbLQQDVQvVXvDI+HhoZmel3s/PnzqkSJErkqbEeOHFGAql+/foZ1OXVT3VQtVUsVqAJVjIrJd9672bKwfaW+UuVV+bTf85v94sWLql69eqpHjx4qOTk5220LsyFqiHJWzuo39ZvRUWxBrrEJkZltbGM723mZlzOsW7FiBQCPPPJIuse9vLy47777MmxfurTulRgfn/FOyKmPpW6TF6/xGjvYkeVtaHKb10gBBHCBCySSCOQve3x8PI888ghBQUHMnj0bR8eiO+h7HON4gRcIJZSlLDU6jtVJYRMiE5OZzP3cTzOapXv8xo0bXL16leLFi+Pu7p7heWXKZBy8nfoGHBERkWFdZGQkADVq1MhTzpnMZCITs+wskpe8RvLHH4Uiksh8ZU9OTiY0NBRfX1+mT59epIsagAkT3/ItvelNKKGsYY3RkaxKCpsQd7nOdeYzn370y7DOxcWFkiVLcv36da5du5Zh/fnzGWd9aN26NQA7duzIsC71sbZt2+Y65y52EUYY7/JuljOL5CWvke4cpJ2f7GFhYdy4cYNffvkl3awp1atXZ8uWLZYPXgA44MBUptL11tcudhkdyWqksAlxl5Ws5BrXsiwWHTp0AG6fJksVFRWVae/Gli1bEhQUxIIFC7h+/Xra42azmblz5+Lv70/Hjh1zlTGaaDrTmYd5mFGMynbb3OY1khdeuOKa1jMyL9lHjhzJ/v37+e233yw26L2wcMCBGcygKU15hEcK7wwlRl/lE8LePKOeUc1V8yzXHz16VJUtWzZdT729e/eqRx99VFWqVCnTDg2bN29WxYsXVz179lTnzp1TFy9eVGFhYcrJyUmtWLEiV/lSO4tUUVXURXXxntvnJe+dbNl5RCmlqqvqarQarZTKffZp06YpINtl8+bNNnst9ipOxakGqoGqpqqpc+qc0XEsTXpFCnGnG+qGKqVKqfFqfLbbHT58WHXt2lV5eHioEiVKqKZNm6q1a9eqtm3bZlkodu7cqTp06KA8PDyUu7u7atOmjdqwYUOuMw5QA3I9s0hu8y5ZsiTLwvDDDz/kOnNutFFt1AvqhTxl79ixoxS2HDqvzqtAFagaqoYqQSXc+wkFxwSZK1KIO/zDP7SmNcc4RlWq5vr5ISEhbNiwId0pR0uayUz60Ie5zM3zfIp3snbevOhLX6KJ5g/+yHY7e8xe0BznOI1oRCtaMY95OBSOq1PfF4pXIYSl/MVfVKNanoqatd3ZWcQSRc1eBRCQrxn+Rc5VpSoLWcjv/J6nu0DYKylsQtzhb/6mHe2MjpFBameR5jS/Z2eRgs4ffylsNtSCFkxgAh/yIXOZa3Qci5DCJsQtscSygx2EEJLr586dOxeTycSqVau4ceOGRedeTCKJHvTAGWd+5meL3F3amnnzyx9/rnGNWGIzXW/P2Quq/vRnIAPpT3/2s9/oOPkm19iEuGUlK3mURznPebzwMjpOmoEMZDrT2czmfM3YX1Ac4AC1qc1udlOHOkbHKTKSSKItbYkiim1soxSljI6UV3KNTYhUW9lKFarYVVGbyUy+53t+5MciUdTg9iBta9y+RmTNGWfmMperXOV5nkdRcNs8UtiEuGUb22hIQ6NjpEntLDKMYYW6s8jd3HGnNKXlOpsBfPBhLnP5nd+ZwASj4+SZFDYhbtnGNhqQ8WagRogmmi50oTnNGc1oo+PYXGb3ZRO20ZKWDGc4b/EWe9hjdJw8kcImBHCe80QTzQM8YHSUtM4ijjharLNIQWOtO2mLnBnBCB7gAXrRi+sUvHGCUtiEQHdYAKhFLYOTwBu8wQ52sIQleOJpdBxDyFg2YznhxCxmcYYzDKfg3XVcCpsQwEEOUopS+OBjaI6ZzGQCE4pUZ5HMSIvNeFWpyle3vrZQsO6IIIVNCHRhCyLI0AxFtbNIZvzxJ4IIUkgxOkqR9hzPEUIIz/EcN7hhdJwck8ImBHCCE1SnumHHP8/5It1Z5G4BBJBEElFEGR2lyJvCFCKI4BM+MTpKjklhEwJ9Y8vU8VO2lkxyke8scjd//AEZy2YPKlGJUYziIz7iIAeNjpMjUtiEQBe21DdTW3ud19nO9iLdWeRufvjhgIN0ILETgxlMEEG8zutGR8kRp3tvIkThUpOanOUsTjjhhhsuuJBAAt/yLfOYRznK4Ywz7rgzjnEWmVpoEpNoS1sCCUz3+CxmMYEJzGVuke4scjdnnKlIRWmx2QlHHPmO73iYh1nKUh7ncaMjZUvmihRFztu8zRd8kW3HBBMmHuRBtrM938dLIQVvvEkggXnM4zEeA3RnkeY0ZzCD+YiP8n2cwqYxjWlCE8Yz3ugo4pYe9GAHO9jPflxwMTpOVmSuSFH0dKbzPXvbOeDAK7xikeOtZS3nOU888TzO44xlLBe5SDe60YxmjGGMRY5T2MhYNvszjnGc5Szf873RUbIlhU0UOU1pSlnKZrtNMYoRSqhFjjeb2TjjjLr19T7v04Y2mDAxj3nSWSQLMpbN/lSiEgMZyEd8xFWuGh0nS1LYRJHjgAOd6YwzzpmuL0YxnuVZSlIy38e6yU1+4ReSSEp7LIUUDnEIhZLu7NmQG47ap3d4hxvcsOtWmxQ2USR1oQvJJGe67iY3eZEXLXKc5SznGtcyPJ5EEmc4QwMa8Bu/WeRYhU0AAZznfIGcq7Aw88STV3mVz/iMOOKMjpMpKWyiSGpPe4pRLMPjJkzUohb1qW+R48xmNk5ZdD5OJplEEnmCJ/iYjwv0/a+swR9/FIpIIo2OIu7yJm9ixsx3fGd0lExJYRNFUglK0Ja2Ga5vOeDAIAZZ5BhXucrv/J7uNOTdTJhQKDazmVhiLXLcwiJ1wLycjrQ/ZSjDS7zEN3xjly1qKWyiyHqCJzI85ogjT/O0Rfa/iEVZnu4EPYN6Wcoynen8zu+UoYxFjltYlKc8LrhIBxI7NYhBxBDDL/xidJQMpLCJIuvubv/OONOTnpSmtEX2P5OZmDBleNwJJ0yYeI7nOMYx/sf/LHK8wsaECT/8pMVmp3zwIZRQPudzuzuNLoVNFFnlKU996qcVnySSCCPMIvs+z3n+4R/MmNM97oADNajBFrYwhSl44GGR4xVW0uXfvr3Ga+xlL+tYZ3SUdKSwiSKtG93SOndUoxpNaGKR/c5lbrrWmjPOuODCR3zEHvbQkIYWOU5hF0CAFDY71uDW1zSmGR0lHSlsokjrTGeSSMKEiQEMyPTUYV7MZCZmzGn7a097/uM/3uEdGZCdCzKWzf71oQ8LWGBXA7ZlEmRRaCUkwPXrEBsLiYn656QkuJZuWFkQXs0CuOxyjlJL/sf8m/pRBwcoddfcx46O4HHrzGHp0lC8OJQoobdzuOMj4nGOs4MdKBTlKMcXfCHX0fJICpv960UvhjCEhSykL32NjgNIYRMFQHQ0nDunl0uX4PLl29/v/PnSJYiP1wXsypVcHODzUPCLoF/PvN8yxsXldpFLeGMODDBR9Y+BNFs+ln1uJfnUEzw9oWxZ8PICHx/w9dXFUWQtgACucpUrXLHIXRaE5ZWlLJ3pzHSmS2ETAnTr6dgxvZw8CWfOwNmzEBkJERG6mN28eXv7YsVuF4jU735+UKeO/t3NTReLUqV0oXFxgTJl9GOurmAy6dbWnbYU60xxNzOte9x+LGPLDm7c0K1AgJgYXUATE3WL8Pp1vS4uDma0PESr8Ztx2tmQC5fh0CW4eFEX3ri7Jmrw9ARvbwgI0N/9/MDfH6pV04uvb/rWYFFz5w1HpbDZr570pDvducAFvPAyOo7ctkZYX1ISHD4M+/bBoUO3C9mxY3D+vN7GZNKtmEqV9Bu8r69efHz0m723t/65ZP6nb8zAjBkHHCxyfU2hSCEly+toyclw4YIu3GfP3i7eZ87o75GRcOrU7aLq4gJVqtwudNWrQ+3acP/9uuVX2F3lKh54sIxlabf7EfYnnnjKUY7v+Z7neM7oON9LYRMWFRkJO3fqIrZ37+1ilpQETk6336DvXqpW1W/iQouOTv8BIHU5ckS3/AAqVNAFLjhYF7u6dfVSLONMYQVaaUrzKZ9abGdxG6EAACAASURBVCiGsI7HeRwnnFjMYqOjfC+nIkWeXbsG4eGwY8ft5cABvc7bW7/Ztm4NAwdCUBDUr69PB4p7q1BBL02bZlwXEwP79+u/9f79sG0bTJ2q/3s4OUGNGtC8OTRrpv/mQUG6RVxQyVi2gqELXXiN10gggRKUMDSLtNhEjsXFwdq1sHq1XvbvB7NZnyJs2FAvjRrpN9O7exQK60pJ0a25f/+9vYSH65ayp6cudG3aQNu2+gNHQdKRjnjiyQxmGB1FZCOSSPzw40/+pB3tjIwipyJF1pKTYcMG+PtvWLUKtm/XhaxOHf0m2by5LmZ+fkYnFZm5cQN27YKtW2HNGv2hJDYWKlbU//3atIEOHfQHE3v2Ei9xmMOsYY3RUcQ9VKc6venNKEYZGUMKm0gvMVEXsqVL4bff9LWeqlUhJESf2mrbVnfqEAWP2axbcRs2wMaNsHKlboUHBUFoKHTqpFvb9mYsY/mJnzjGMaOjiHt4juc4yUmjP4RIYRP6k/3vv8OcOfDnn7rrepMm0LWrXqpXNzqhsIbr1/WHmMWLYckS3UO1Zk146ino0wcCA41OqM1kJv3pTyKJOMhkSXbtJ35iIAOJJTbT+x3aiBS2omz3bvjpJ5g9W5+iat8ennwSOneG8uWNTidsyWyGTZt0K33ePN27tXlz6NdPFzo3N+Oy/cM/tKY15zhHRSoaF0Tc03/8Rw1qsJWtRs6H+r18/ClikpN1IatfH+rVgz/+gDff1GOnli+H/v2lqBVFjo7w8MPw+ed6oPyyZfpaXFiY7uH6yitw/Lgx2eSGowVHNarhhht72WtoDilsRURiIkyYoE8v9e0L990H69bpgdPDhsl1M3Gbo6PuVPLLL7rlNmaMvh5Xowb06qVb+rbkhx8OOEiX/wLAAQeCCGI/+w3OIQo1sxm++w4qV4a33oKOHXW38Nmz9Sf0gjy+SVifpycMHqz/zcycqcfOPfCAPl195IhtMhSjGOUpLy22AiKYYPaxz9AMUtgKsfXr9SnHN9/UnQFOntRFrkoVo5OJgsbREZ5+Wg8fWLoUTp/Ws54MG5ZxTk1rkPuyFRxS2IRVXLumTze2bKmvj+zdC+PGybUzkX8mEzz2mB7T+MUXMHmyPq29YoV1jyuzjxQcValKFFFc57phGaSwFTIHD+pB03/8AYsW6e81alj3mOHh4XTs2JHSpUtTsmRJQkJC2Lhx4z2fZzabGTZsGIGBgRQvXpwOHTpkue22bdvo27cvVapUwdXVlbJlyxIcHEy3bt2YOHEix47pMU7BwcGYTKZ0S8+ePdP2ExISkm5dgwYNMhzr1KlTdO7cmbi7puLP6+vMzPLly6lRowZOTlnPajd06FDmzZuX5frnnnsOFxcXqlSpwuDBg7l+3XZvJE5Oeqq0w4ehVSt9invUKD0DijUEECCnIgsIX3xRKM5xzrgQShQaCxYo5e6uVNOmSkVE2OaYW7ZsUa6urqpHjx7q7Nmz6sKFC+qFF15QTk5OauXKldk+d/LkyQpQo0ePVjExMZluYzab1ZAhQ5STk5N666231MGDB9X169dVVFSU+vPPP1VISIgCFKCSkpKUUkpFRUUpT09PBahZs2Zl2OeyZctUYGCgio+Pz7Bu165dqly5curbb7+12Ou809GjR1WnTp1UnTp1lIeHh3J0dMx22ypVqqgRI0ZkuU1cXJyaNGmSAtTYsWNznMPSJk5UysVFqcceU+rKFcvv/0v1pfJW3pbfsbC4SBWpUKj1ar1RESZIYSskZs9WytFRqVdeUermTdsc02w2q9q1aytvb2+VkJCQ9nhycrKqWbOm8vf3V9evX8/y+U8//bQCVFxcXJbbvPvuuwpQU6ZMyXR9cnKy6tChQ7rCppRSs2fPVoDy9PRUUVFRaY9fvnxZ+fv7q40bN2bY15UrV5Sfn58KCwuz6Ou8+zV//PHHKikpSfn6+mZb2JRSKjw8XJlMJjVv3rxstytRooRq3759jjJYy9atSnl7K9WkieWL23w1X5mUSV1XOfs7C+Mkq2TlqBzVPJX9v1krksJWGKxbp5Szs1JDhtj2uGvWrFGAGjRoUIZ1I0eOVIBasGBBls9v3759tm/sBw8eVA4ODqp+/frZ5ti0aVOGwqaUUp07d1aA6tatW9pjvXv3Vm+//Xam+xk+fLhycnJSkZGR6R7P7+u8052FMSeFTSmlQkNDlZ+fX4bXdycfH597/p1s4dAhpSpWVKpjR6XMZsvtd6vaqlCoY+qY5XYqrKaiqqi+Ud8YdfgJco2tgIuL073VHn9cdxCxpdWrVwNkep0q9bFVq1Zl+Xyz2Zzt/qdMmUJKSgqhoaHZbtekSROUUhmuV02aNIkyZcqwcOFCFixYwOLFiwkPD2f06NEZ9qGUYurUqTRq1Aifu2YFzu/rvJNrHu7b88QTTxAREcGyZcuy3MZkMpGcnJzrfVtazZrw6696qq6vvrLcfu+8k7awf664kkiiYceXwlbAjRkDN2/CDz/YfkzaoUOHAPDLZHp/31sjvo/kY7DTunXrAKhTp06enu/t7c348eMBGDBgAAMHDmT69Om4ZHJH0927dxMdHU3dunUzrLP267yXevXqAbBy5UqrHcOSGjeGd9+FDz7Qdwu3hApUoBjFpANJASGFTeRZfDxMmaIHXnt62v74sbGxALhlMpGgu7s7ADExMVk+/+bNm5kWmVRnz54FwDMfL65Pnz489thjnD9/nurVq1M/i+nr9+3T424yK175fZ35lVo8UzNmxsXFhaSkJKtlyK0hQ/Qd0SdPtsz+HHDADz9psRUQUthEnq1bB1evwrPPGp0kI3Vrbm1TNs3I06dPZ1pI7pbdPnIi8NY09WvXruW3337LdJtz53TX5FK5vENqTl5nfnl4eGAymdIyZsbHx4fIyEi7OB0JUKIEdO+u7xpgKTKWreCQwibybN8+CAjQk9UaoXTp0gDEx8dnWJf6WOo2d7p8+TKfffYZp06d4pVXXsly/6nXui5evJjnjOvXr2fRokV8+eWXALz00kuZtq5Sx4A5OztnWJfX12lJTk5OJCZm/UYRFhZGXFwc77//fr7+XpbUsKH+N2opMpat4HDGmSSMO4Mgha0Au3YNSpY07vj33XcfABERERnWRUZGAlDjrtHhffv2xdPTk6FDh/L222/z6quvZrn/li1bArBnz5485bt27Rp9+/ZlypQpvP7663To0IGoqCgGDx6cYdvixYsDZHo6Ly+v09KSk5Oz7XjyzDPPMHbsWD777DO8vLx49NFHrZonJzw89OTblmpESotN5JQUtgKsfHk4dw6MuqNe69atAdixY0eGdamPtW3bNt3j//d//8eVK1eYO3cuX375JWFhYVnuPywsDCcnJxYsWJBtjrfffhsHB4e0Th6p3nzzTUJCQtLe5CdPnoyHhwczZ85k6dKl6bb19vYG4MqVKxZ5nZYUFxeHUiotY2aGDx/Ou+++y8SJE4mNjWWFtee4yoGICH3tN5vJVXLFH39psYmcMWqggci/HTuUAv3dCGazWQUFBSkfHx+VmJiY9nhycrKqVauW8vf3T/f43R566CFVpkyZbI8xZswYBagff/wx0/WHDh1SHh4eqkePHukeX7FihapSpUqGwd9TpkxRgPLx8Uk328muXbsUoF555RWLv86s5HQc24EDBxSgXn755Sy3ue+++1SVKlVyncGaOnXSi6UsU8sUCnVFWWFqE2FRrVVr9bLK+t+rlckA7YIsJUWpWrWU6tvXuAybN29WxYsXVz179lTnzp1TFy9eVGFhYcrJyUmtWLEi2+e2bds2R2/sQ4cOVc7Ozuqdd95Rhw8fVjdu3FARERFq6tSpytvbWzVv3lxdu3YtbfuYmBjl7++v1qxZk+n+Uqfh6nvHHy4lJUWVL19eNWvWzCKvs3fv3gpQx48fz/J15bSwzZkzRwHq119/zXZfdevWvee+bOW///RMOHPnWm6fe9QehULtU/sst1NhFVLYRL7MmqWUg4NSmzYZl2Hnzp2qQ4cOysPDQ7m7u6s2bdqoDRs23PN5ISEhOXpjV0qpf//9Vz377LPK399fOTs7q5IlS6rGjRurr7/+Wt24cSNtO19f37S5IwHVpUuXtHUxMTHp1qUu48ePV0rp6bsym3kkL6+zTZs2yt3dXSUnJ6d7fMmSJZlmANQPP/yQ6b5CQ0OVr6+vupnNXGm+vr6qXr16Wa63pZQUpTp0UCooSKlsJkvJtRgVo1Co5Wq55XYqrEIKm8i3Rx9VKiBAqehoo5PkTseOHZXJZDI6RprY2Fjl6+ubYa7I3IqJiVGurq6qf//++c6UOlfkzz//nO12FSpUUI0bN8738Szho4+UcnJSar0V5sD1UB5qspps+R0LizK6sEnnkUJg1ixwdob27eHSJaPT5Jyfnx9KKaKjo42OAugxbEuWLGHBggVMmDAhT/tQSvHqq6/i4eHBmDFj8pXn+PHjPPnkkwwbNizdrXfulpSUxOXLl3M0JtDaJk+G4cPhyy+heXPL7196RoqckMJWCHh6wqpVet7Ixo0hj73jbS61t+Inn3zCJTupyA888ADbt2/njz/+yHA/tpyIjo7m+PHjrFq1ior5HGA4efJkxo4dy9ixY7Pc5sqVK3z55ZckJSUZ2sXfbIZ33oGXX9bTvA0aZJ3jSM9IkSNGtRWF5V24oFRIiFLFiyuVRSdCu/Ppp5+qWrVqKRcXF/Xoo48aHadA6dOnj3J2dlbVq1dX7733XobrebZy4YJS7drZ5t/di+pF1Vq1tu5BRL4ZfSrSpJRRo6CENSQnw7Bh8MUX0KMHfP453JpqUAiLUgpmz4a33wZXV1i4EG7N12w1H/Ih/8f/cZSj1j2QyJc2tOE+7uN7vjfi8N/LqchCxskJPvtMz9G3bRvcdx988om+A4AQlhIeDi1aQJ8+0LkzbN9u/aIG+lRkBBEo5PO4yJoUtkKqY0c9T9877+hrHkFB+tY2N24YnUwUZPv3w//+Bw0aQEqK/vA0aRKUKWOb4wcQwA1ucJ7ztjmgKJCksBVixYvDiBFw8CC0aaMv6Fepolt0V68anU4UJJs3Q5cucP/9sHMnzJgBGzbAgw/aNofccFTkhBS2IiAgQN+37fhx6N1bt+ACAmDAAH0KSYjMxMXB1KnQtKleLlyAxYth717o1cv2N7YFXdhMmKRnpMiWFLYixMdHt9ZOndJ3OF6zBh56COrUga++stzdjkXBpRSsXauvnXl7327lr10Lmzbp62lGFLRULrhQnvLSYhPZksJWBJUpo++6feCAbrG1bq1bcd7eelDtp5/CUel0VmSYzfq04uDBuiXfqpX+d/H++3DmjO752KKF0Slvk0Ha4l6ksBVx9evD11/ffgPz84OPPoIaNXRrbuxYfU0lJcXopMKSLl2C+fP13de9vODhh/Ud2fv3152O9u/XHY/KlTM6aUZyw1FxLxa6U5Io6EqU0OPeevTQPSdXr9bXU777TndAKVtWf5Jv00YvtWoZnVjkxtWrunCtXq2XPXv0KcVmzeC996BrV33KsSDwx5+tbDU6hrBjUthEBi4u0KGDXiZN0p/gV6/W03YNHw5XrujTls2aQaNG0LChbvm5uRmdXKQ6ehT+/Re2btXft2/XpxyDg/UHk1GjoGVLKFXK6KS5548/85lvdAxhx6SwiWyZTLqL9/3362swZrN+k1yzRncB/+ILiIoCR0eoXVsXuYce0tvXrg0eHka/gsItJQVOnNA9FcPDdRH79199qtHZGerW1R8+XntNX0stX97oxPkXQABRRHGTmxSjmNFxhB2SwiZyxdFRv1E2anT7sdOndcsgtXUwdy5cu6bXVa6sC1xwsF6CgqBatYLZUjCS2az/zv/9p4vY/v36+4EDkJCgP4BUrao/WIwYof/7PPCAHstY2PjjTwopnOUslalsdBxhh6SwiXwLCNBLaKj+XSk4eTL9G/Aff8D48ben9vLy0gUudaleXb8x+/tDxYpQrAh+EI+JgbNn9d/u6FE4duz295Mnb//tKlTQLeLmzSEsTA/XCAoCd3cj09tOAAEAnOa0FDaRKSlswuJMJt0RoUoVPe4pVVKSHiR+7Njt5ehR+OUXfTrtzum+KlbUi7d3Av7+JfDx0b97eemOLJ6eeilb1r5bJTEx+rRg6nL5Mly8qHuhRkXp7+fOQWQkJCbefl6FCreLfuPGt38ODNSvuyirSEWKUUy6/IssSWETNuPsDDVr6uVuKSn6Df70af2GHxEBP/88nO3b/+H69fWsX+/AuXMQG5vxuW5ut4tciRJ6KVVKFzw3NyhZUv9csqTe3sVFb3OnUqXA4Y7BL/Hx6SeOVur2sZOS9KnWa9fg+nU9Q0d8vC7MsbH659RCdvcwCRcXndXPT3fAqVsXHnlE/+7jo+/EEBBQdFpfeeGAAz74SJd/kSUpbMIuODjoN/XUW+x8/fXXbNnyMT/88AP9+t2uOGZz+tbP3d8TEvRy5YouPNHRuvBcv377ul9q0TKbd3Hz5gKKFx9NbKxjujzFi+tbsdwptfg5OupOMW5uertSpXSnjNSf7yy0np56LFjq71KwLCOAAGmxiSxJYRN2Z9q0abz++ut8/vnn9OvXL906R0ddRCzRu2/cuL/45pvpRERkfYdqYZ9k9hGRHZl5RNiVOXPm0L9/fz788EPeeOMNqx4rPDycBx54wKrHENYhs4+I7EhhE3ZjyZIl9O3bl0GDBvHuu+9a/Xjh4eHUs8XdMYXFSYtNZEcKm7AL69evp3v37vTr14/x48db/XiJiYkcOXKEunXrWv1YwvL88SeGGK4iNxYUGUlhE4Y7fvw4Tz75JB07dmTChAmYbHBflD179mA2m+VUZAGVOpZNWm0iM1LYhKGuXr1Kly5d8Pf3Z/r06Tg42Oaf5K5du/Dw8KBq1ao2OZ6wLLmTtsiO9IoUhklJSaFHjx5cvnyZf//9FzcbzqK8e/du6tata5PWobC8MpShJCWlA4nIlBQ2YZixY8eyatUq1q1bh2/qADYb2bVrFw0bNrTpMYVlSQcSkRU5FSkMsWbNGkaNGsUXX3xBoztnVLYBs9nM3r17pUdkAZda2G5yk5OcZD3rmcUs1rPe6GjCYNJiEzYXFRVFz5496datGwMHDrT58Y8cOUJCQoIUtgLkFKfYxjYiiOAUpzjDGfawh/WsZzrTUai0bacxjYd52MC0wmhS2ITNvfDCC7i7uzN16lRDjh8eHo6zszNBQUGGHF/k3kUuEkooTjjhgANJJKUrZndqSlMbpxP2Rk5FCpuaMmUKy5cv56effqJk6qzENhYeHk5QUBDF7fm2ACKd+tSnHe0AuMnNLItaKUoRSKAtowk7JIVN2MyJEyd48803eeutt2jZsqVhOWTGkYJpFKNIJjnL9Q448DAPY0J6uhZ1UtiEzQwYMIBKlSoxatQoQ3Ps3r1bClsB1IQmNKMZTllcQXHCSa6tCUAKm7CRhQsXsmLFCr777jtcXFwMy3H27Fmio6OlsBVQH/BBlq22m9yU62sCkMImbCAhIYEhQ4bwv//9j1atWhmaJTw8HJPJJHNEFlDtaEdDGmbaanPEkfrUNyCVsDdS2ITVffrpp8TGxjJu3Dijo/Dvv/9SrVo1ypQpY3QUkUcjGJFpq60udXHFNZNniKJGCpuwqgsXLjB+/HiGDh1KeUvcHTSftm3bxkMPPWR0DJEPj/M493M/jty+63kxitGKVsaFEnZFCpuwqjFjxuDu7s6gQYOMjgLA9u3bpbAVcCZMjGAEKaSkPZZEEk1oYmAqYU+ksAmrOX36NFOmTOH999+nRIkSRsfh1KlTnD9/XgpbIfAUTxFIIA633sIUSgqbSCOFTVjNN998g5eXF/369TM6CqBPQzo6Oso92AoBBxx4l3fTBmr74IMvtp1IW9gvKWzCKq5evcrUqVMZNGgQzs7ORscBdGELCgqy6e1xhPX0pjd++AHQghYGpxH2ROaKFFYxdepUkpOT6d+/v9FR0kjHkYLr+nWIi9PLlSv698REJ7r5juCrWmG4727G/CO3ty9ZEpxuvbuZTFC6NBQrBqVKgYeH/l0UXlLYhFVMmjSJvn37UrZsWaOjAKCUYteuXXTv3t3oKOKWpCQ4dQpOnIBz5+DsWYiK0j+fOwfR0RAbqwvZjRtZ7MSlDxwdw9TnmzJ1Z+6OX7q0LnJly4KvL5QvD35++ruvr16qV9frRcEihU1Y3KZNmzhy5Ag///yz0VHSHD58mNjYWGmxGeDCBdi9G/buhaNH9XLsmC5qybeGo7m6gre3XipUgHr1dIEpU0YXn9SWVmpry8lJt8rAhZkuH9BvUx3c7pjQJjYW1K15kpOT4erVjK2+2Fj986VLuqieOwfbt8P587qopipTRhe4atX0UqsW1K0LNWuCnZxlF3eRwiYsbvr06dSuXZsHH3zQ6Chptm3bhouLC8HBwUZHKdTOnoUNG2DHDl3M9uzRBQPAywvuu08XhxYtdLGoXh2qVtXFI69eJePp7rtPNXp55W6fSUlw5owuwHcW419/hXHj9PpixaB2bahTRxe6Jk2gfn0pdvZACpuwqOvXrzNv3jzee+89o6Oks23bNurWrWvoPJWF0f79sG4dbNqkC9rJk7o1lfqG/8Yb+k2/Th3dEisonJ11wa1aFdq1S7/u5k04eFAX7T17dAFfvly3TF1d4aGHoHlzaNoUWrYEd3djXkNRJoVNWNTq1auJi4ujR48eRkdJRzqOWEZ8PGzeDEuWwOLFcPq0fuOuWxd69IBmzeDhhwt354xixfTrvXu60bNnYeNGXeBXroRPPtEdV+rVg8cfh06d4MEH9WPCuqSwCYtavHgxDRo0wM/Pz+goaZKSkti9ezcvvfSS0VEKpMuXYeFCmDtXt86U0q2Sfv3g0Uf16TdHx3vvp7Dz8YHQUL2AbsH99Rf88QdMnAijRukOKd26Qc+e0LixFDlrkcImLCYlJYWlS5cyYMAAo6Oks2/fPhITE6XFlguJibBoEfz8s35zdnSEjh1h5kx9as7T0+iE9s/LC3r10ktKCuzcCUuXwrx58M03ULmybuU++6w+dSssRwZoC4sJDw/n3LlzPP7440ZHSWfbtm24u7tTs2ZNo6PYvWPHYOhQCAiAPn10z8Fvv9Xd8OfP1y0NKWq55+AADRrAyJH6+ty+ffrvu3AhBAfrdTNm6E4pIv+ksAmLWb16NV5eXtSpU8foKOls27aN+vXr4yjny7K0bh089hjUqAFz5sBrr0FEhL5e9OKLupu9sJzatXWRO3JEX4/z84Pnn4dKleDDD/UwBJF3UtiExfzzzz+0atUKk51dOJCOI1nbtAlCQnTvvcRE3YI4cQKGD4eKFY1OV/iZTNC+ve6Ic/w49O0LX3wBVarARx/p8Xci96SwCYtITk5m/fr1tGzZ0ugo6SQkJLB//34aNGhgdBS7cvSovmbWrJnuvr5mjV66dpWOIEYJCNDF7MQJGDgQPv1UDzf4/nt9jU7knBQ2YREHDx4kLi6O5s2bGx0lnS1btpCcnEzTpk2NjmIXbt7Up7ruv1+favzrL30aslUro5OJVKVL6x6UJ07Ac8/p08JNm+rxciJnpLAJi9i+fTvFixcnKCjI6CjpbNy4kYCAAPz9/Y2OYrj9++GBB+Djj/Ub5/bt+jSksE9ly+pZTnbu1IPeGzSADz6Q1ltOSGETFrFz507q1q1rN7eoSbVx40aaNWtmdAzD/fKLHjfl6akL3Ntvy9RPBUVwMKxfr4cIjBunTyFfvmx0KvsmhU1YxK5du+xqbkjQ4+q2bNlS5Avbu+/qbvrPPw+rVunxU6JgMZng5Zd1gTtwQLfeDh82OpX9ksImLOLgwYMWn2B4+fLl1KhRAyenvM0jsHfvXq5cuWKx637h4eF07NiR0qVLU7JkSUJCQti4caNF9m0t776rP+VPmwZff23ZVlpMTAyTJk2iTZs2lC1bFldXVwIDA+nduze7c3BByGw2M2zYMAIDAylevDgdOnRIWxccHIzJZEq39OzZM219SEhIunWZdQ46deoUnTt3Ju5W3/nc5h06dCjz5s3LMv9zzz2Hi4sLVapUYfDgwVy/fv2erzm/GjTQp5ArVNCnkY8ft/ohCyYlRD5FR0crQK1atcoi+zt69Kjq1KmTqlOnjvLw8FCOjo552s+ECROUh4eHSk5OznemLVu2KFdXV9WjRw919uxZdeHCBfXCCy8oJycntXLlynzv3xpGj1bKwUGpGTOss/9+/fopJycn9dVXX6lz586p+Ph4tW7dOhUUFKQcHR3Vr7/+mu3zJ0+erAA1evRoFRMTk2F9VFSU8vT0VICaNWtWhvXLli1TgYGBKj4+PsO6Xbt2qXLlyqlvv/02z3mPHj2qqlSpokaMGJHla4iLi1OTJk1SgBo7dmy2r9eSYmOVatBAqcqVlTpzxmaHzbHWqrV6Wb1s1OEnSGET+bZu3ToFqIiICIvs7+mnn1Yff/yxSkpKUr6+vnkubL169VKPPPJIvvOYzWZVu3Zt5e3trRISEtIeT05OVjVr1lT+/v7q+vXr+T6OJa1erZTJpNTEidY7Rr9+/dSLL76Y4fHw8HAFqMDAwGyf//TTTytAxcXFZbnN7NmzFaA8PT1VVFRU2uOXL19W/v7+auPGjRmec+XKFeXn56fCwsLynTc8PFyZTCY1b968bF9LiRIlVPv27bPdxtIuXVKqVi2l2rRRKiXFpoe+JylsosD78ccflZubm0qx0P9ddxaP/BS2SpUqqdGjR+c7z5o1axSgBg0alGHdyJEjFaAWLFiQ7+NYyrVrSlWrplSXLsZlcHV1VQ4ODtn+m2jfvn2O/tt27txZAapbt25pj/Xu3Vu9/fbbmW4/fPhw5eTkpCIjIy2SNzQ0VPn5+amkpKQsn+/j46Pq16+f4+NZyq5dShUrptQ339j80NkyurDJNTaRb6dPnyYgrPrNWAAAIABJREFUIMBiM464urrmex+RkZGcOnXKIh1HVq9eDZDpdZzUx1atWpXv41jKmDF6SqYffjDm+PHx8SQmJqZdJ8uK2WzO0f4mTZpEmTJlWLhwIQsWLGDx4sWEh4czevToDNsqpZg6dSqNGjXCx8fHInmfeOIJIiIiWLZsWZb7MJlMJKfeDtyG6tWDYcP0tdSLF21+eLslhU3kW2RkZLa3qTl06BBdu3alVKlSlChRgoYNG7J06dJ0HQD69894F+T82LBhA05OTjRs2DDfmQ4dOgSQ6Wv09fUF4MiRIxbNn1fx8foWKUOG5P6u0ZYyf/58AIYPH26R/Xl7ezN+/HgABgwYwMCBA5k+fXqmN43dvXs30dHR1L37Zmn5yFuvXj0AVq5cmdvoNvHWW1C8OEyaZHQS+yG3rRH5FhERkWVhO3r0KE2aNMHNzY0FCxbQpEkTTp06xWuvvcaePXtwcXGxSm+yjRs3Uq9ePdwzuX1xbjPFxsYC4ObmlmFfqfuPiYmx+GvIixUrICFBz1hhhOjoaIYOHUr//v3p3r17ttvevHkzx3c079OnD7/88gvLly+nZcuW1K9fP9Pt9u3bB2T+ISSveVM/vKTuOzMuLi4kGTQ1v5sbPP20vh3OiBGGRLA70mIT+Rb9/+zdeVxUZfs/8M8wgwMIo4DIMqCiggjkkisuqYAKkksLqWlJaVFa+pTl2mL1teynufRkiprlk1s+pJnmmhoo4mNqrrmEjMiwiewQyzDcvz/uBsEZEJjlzMD1fr3OCzznzDnXIJxr7j0rC66urjqPLVq0CPn5+VizZg1GjhwJe3t7BAQEYPv27SgpKTFaTKdOnaqzGtKQMTHGAMBsJn4+dYpXTwlRWsvJyUFYWBiGDx+O9Q0oPty9e7dRC9L6+PgAAOLi4rB3716d52RkZAAA2rRpY7B4ZTIZRCJR9bV18fDwQFpamiDVkQCfSPnaNb7MEKHERgygsLAQsjrWNTl06BAAYPTo0bX2u7i4wM/PzyjxFBcX48qVK3UmtsbG1LZtWwDQmfQ0+zTnCC05GRBi2bmSkhKMHj0a/v7+2LZtW71LBOXm5mL58uVISUnBzJkzG3T9kydPYvfu3Vi5ciUA4LXXXtNZStaUtB81A05j4gUAiUSC0tLSOo9HR0ejsLAQH3zwAe4L0Njl58dXNqdxbRwlNqK3oqIiODg4aO0vLy9HUVERbGxsdFYJOjo6GiWexMREVFZWIigoyCAxaZKdUqnUOpaWlgYA8PX11TdsgygrAwzQ96ZRKisrERkZCblcji1bttSbJKKiouDs7IwFCxZg3rx5mD179iOvX1xcjKioKGzYsAFvvfUWwsPDkZmZiTlz5mida2NjAwD1Vgs2Jt6ar6mvU9PUqVOxdOlSLF++HC4uLggLC3vkNQ3Jzo5//ftvk97WbFFiI3qrK7FJpVI4ODigrKwMxcXFWsfv3btnlHgSEhLg7e2ts5qrKTGNGDECAHD+/HmtY5p9ISEh+oZtEG3bAjk5pr1ndHQ0ysvLsWvXrlqzxHTt2hVnzpypde53332HgoIC7Ny5EytXrkR0dPQjrz937lyEhoZWJ4uYmBjIZDJ8//332L9/f61z3d3dAQAFBQUGiRfgNRKMsepr67J48WIsWrQI69atQ35+fnWtgKloColOTia9rdmixEb0olarUVpaqrP0A6B6mqSH/9AzMzON1pPwURMfNzamYcOGwd/fH7GxsbU6lajVauzcuRNeXl6IiIgwUPT6CQzks8GbypIlS3Dt2jXs3bu3wR1BZDIZIiMj0bt3b8TGxtZ77uHDh3H06FGsWLGiep+Xl1f1v6Ojo6s79wContZNV+m6qfFqSuX1TRm3e/dueHt7Y8aMGQ1q3zO08+d5z8h/miGJUCPoSPOQn5/PANQ5rVRSUhJzcnJicrmcHTlyhBUVFbErV66wsLAw1rFjRyaVSuu9fmMHaFdWVjIHBwe2rp4pN5oSU2JiIrOxsWGTJk1iGRkZ7P79+yw6OppJJBJ26NChBsdnbGfOMAYwduGC8e/17bffMgD1bomJiXW+PiQkpN7/27y8PObl5cVOnDih83hoaCgDwKKioqr3VVVVsfbt27PBgwcbLN7t27czAPVOESaXy1nPnj3rPG5s48YxFh4u2O21CD1AmxIb0UtqaioDwE6fPl3nOTdv3mQTJkxgMpmM2dnZsUGDBrG4uDgWEhKiM4ns27evzgfPxo0b643n/PnzDAC7cuVKvec1NibGGLtw4QILDw9nMpmM2dvbs+DgYHbq1Kl672NqVVV8mqVp04x/r4iICL0SW2hoaJ2JTS6X17rO+BrTqOTl5em816pVqxhjjC1atEjnzCNNjTcyMpLJ5XJWUVFR53uRy+WsV69e9f68jOWvvxgTixnbuVOQ2+tEiY1YtD///JMBYJcvX270a+tLIk315ZdfsrZt2zK1Wt2k1xsjJlPbsYNPfhwfL3Qk9YuIiGAikcjg183Pz2dyuVxrrsim0MwVuWPHjnrPc3V1ZQMHDtT7fo1VVcXYyJGM+fszZoC5vg1G6MRGbWxEL5ppkRrSs8wUTpw4gSeeeAJWVi33V3vSJOCpp4Bp04CiIqGjqZunpycYY8jKyjLoddu0aYN9+/YhNjYWa9eubfJ1kpOT8fTTT2PhwoW1lsx5mEqlQm5ubqPG5BnK118DJ07wZYnM5E/QLLTcv35iEJrxQkINTK2pqqoK8fHx1b0YW7K1a3lSe/55oKJC6Gh00/RyXLZsGXIM3JWzd+/eOHfuHA4ePFi9HltjxcTEYOnSpVi6dGmd5xQUFGDlypVQqVQm7+J//DifTmvhQqCOmeNaLqHKiqR5SEpKYgDY+fPnG/yaHTt2aLVtTJ8+Xe9YNO1rly5davRrjRWTkC5cYKxtW8aeeoqxeiamF9Tnn3/OunfvzqRSKQsLCxM6nEaZNm0as7a2Zl27dmXvv/++Qdb9a6jTpxmzt2fs2WfNqwpSQ+iqSBFj/8wJREgT3L17Fx07dsSZM2cwYMAAQWNZsWIFli1bhnv37rXoqsiaTp0CwsKA4GDg++8BAXqiEwPbuxd44QVg5Eg+P2QTF5g3qmAEww9++BpfC3H7r+mvn+hFM8DVHKoiT5w4gREjRlBSq2HIEODIET7OqV8/oJ55fImZU6uBxYt5++nkycCOHeaZ1MwBPQGIXsylja2yshKnTp2i9jUdBg3iic3NDRg4EPjyS/6QJJbj1i0gNBRYuRLYtAmIiQFatRI6KvNFiY3oxVxKbOfOnUNhYSGCg4MFjcNcubkBx44Bb73FOxwMHGjaGUpI05SXAx99BPToARQUAKdPAy+/LHRU5o8SG9GLZlqi8vJyQeM4fvw43N3djbZiQHNgbc1X1/7jDz5Rcv/+wIwZwJ07QkdGHqZWA1u3Ao89BqxYAXz6KXD2LNC7t9CRWQZKbEQvdnZ2sLGxMXh37cb67bffqBqygfz9gbg4YPNmPgaqWzfgtdeA1FShIyNVVcDOnXzOz5de4tXI164Bb79N7WmNQYmN6M3Z2VmQNag0SktLcerUKbOZYd8SiETAiy8CN24AGzfyakpvb2DsWODXX/naXsR0CgqADRt4QpsyhZfUrl4FvvsO6NBB6OgsDyU2ord27doJWmKLj49HaWkpRo4cKVgMlsramie4a9f47BXZ2bwbec+ewLp1QG6u0BE2X4wBiYnA9OmAuztv+wwNBa5fB3btEmbB2OaCEhvRm9AltiNHjiAgIABeXl6CxWDpWrXiY6POnAHOnQP69gXmzuUP3Cef5O095jw9lyW5eBFYsADo3JlXNZ49C3zxBZCWxnusmsmatRaNEhvRW7t27QRNbIcPH8bo0aMFu39z06cPb3/LygK++Ybve/llwNUVGD8eWL+eOpw0Rnk5cPQo/6DQrRvvAPLDD8DEibwjz5UrwOuvA3UsaUiagBIb0ZuQVZFpaWn4888/MWrUKEHu35w5OABTpwL79wOZmbw0AfAqM29voHt33qlh3z7Tr9ptztRq4NIl4KuveJulszMwahRw+DAwbhyvfkxOBpYtA3r1Ejra5on62RC9OTs7Izs7W5B7HzlyBFKpFEOHDhXk/i2FkxMfGjBjBp9U+eRJ4NAh/rBevZqf4+fHq9YGD+ZDCbp1axk9+XJy+AD4xEQ+ziwxkVfbtmnDpzJbuZJPa0adQEynBfzaEWPz8PCAUqkU5N6HDx/GE088ATs7O0Hu3xK1agWEhPBt+XLeweT0ab4lJADbtwOlpYCNDRAQwDui9OjBN19fQC4X+h00TWkpkJQE/Pknbye7fJmXzNLS+HFNm9nnn/OpzAICAJrdTRiU2IjeOnXqhIKCAuTn56Nt27Ymu29VVRWOHz+O+fPnm+yeRJuTE+9g8uST/N8qFe9leenSg4f/3r0PqittbYGuXYEuXfjWuTNPdq6ugKcn0L69MNNF5eUBGRl8S0/n4/pu3+bJ7PbtBwlMIuGl0Z49gdmz+ddevXj8xDxQYiN68/b2BgAoFAr0NuHUCOfPn0d2djZ1HDEz1tb8Qf9w+1F6+oMkofkaFwds2QI83PfIxYUnirZtAZmMb23a8H+3acNLQg4OD6o6W7UCWrfm36vVQM0l2IqLebItKeH7NVtBAU9mOTm8DbGs7MFrpFKeZLt04SWvceMeJGJfX36cmC9KbERvHTt2hJWVlckT24EDB+Dp6YmAgACT3ZM0nYcH3554QvtYeTnvhZmWxr8qlcC9ezz5FBTwRPTXX/z7/Hw+Biw/H6io+AUq1c+wsopBaemD6zk6Pvje1pZXi9ra8qSoSZKdO/NE6ezM59J0d+fxubnxfcRyUWIjerOxsYGbmxvumLgP+O7duzF+/HiIRCKT3pcYnlTKO1c0toPF+++fwU8/ncaVK8aJi1gmatokBuHt7Q2FQmGy+925cweXL1/GU089ZbJ7EvOTnJxcXRVOiAYlNmIQnTp1Mmli+/HHH9G2bVs8oatei7QYCoWCEhvRQomNGETXrl3x119/mex+e/bswbhx46oXOiUtEyU2ogslNmIQAQEBuH37NkprtuAbSVZWFs6cOUPVkC1caWkpsrKyKLERLZTYiEEEBgZCrVbj+vXrRr/X3r170apVK5rNv4W7c+cOGGOU2IgWSmzEIHx8fGBjY4MrJuietmfPHowePRqtNQOXSIukadOlxEYeRomNGIREIoGfnx+uXbtm1PsUFRXhxIkTVA1JkJycjHbt2sHBwUHoUIiZoXFsxGACAwNrldhycnJw+vRpVFZWNikRxcXFQa1WY/jw4bD6Z9K9/fv3Q61WY8yYMQaLm1gm6jhC6kIlNmIw7u7uOHv2LF599VX4+PjAxcUF48aNw8mTJ5t0vYSEBISEhMDDwwPz5s3DlStXsGfPHgwbNgzt2rUzcPTE0lBiI3WhEhtpksrKSly4cAEJCQk4efIk4uPjkZOTAysrK3z33XdQqVQAAGtra8ibOJ17VVUVrK2tkZWVhdWrV2P58uWwt7fHyJEjkZaW1uTrkuZBoVDQPKFEJ0pspElUKhUmT54MhUIBkUiEqqoqADwZab4HeAL09PRs0j3UanV1FaQmUZaUlGD//v346aef0K9fP0yfPh2TJk2CTCbT8x0RS3Pnzh0qsRGdqCqSNImtrS3Wr18PxlitRPYwxliTE5uu6zLGoFKpwBjDuXPnEB0djSeffBKMsSbdg1imvLw85OfnU2IjOlFiI002cuRITJ069ZGzf3h5eTXp+vUlTA0nJyds27aNJkJuYTRd/Tt37ixwJMQcUWIjelm9ejVat25dZ2IRiURwd3dv0rUfldhEIhF2797d5MRJLJdCoYCVlRX93xOdKLERvTg7O2P16tX1Hm/qfI5qtbre419//TWGDRvWpGsTy5acnAy5XA4prfhJdKDERvQ2bdo0DB8+XGcCa2r7GlB3iU0ikWDmzJl49dVXm3xtYtmoqz+pDyU2YhCbN2+u7sGoIRKJ0KlTpyZfs6qqSqtTiLW1Nfr27YtVq1Y1+brE8lFiI/WhxEYMolOnTvjwww8hFour91lbW6NDY5dEruHhEptYLIaLi0v1JMik5aLERupDiY0YzLvvvovu3btDInkwPFKfQdQ1E5tIJIJYLMbPP/+M9u3b6xUnsWyMMaSkpFBiI3WixEYMRiKRYPPmzdUJSZ/B2YB255EtW7agT58+esVILF9GRgbKysoosZE6UWIjBtWvXz/MnDkTYrEYVVVVepfYKisrYWVlhYULF2LSpEkGjJRYKhrDRh6FptQiBpGfD5SVAX//DUyc+Cl27IhFTk4m7t71wq+/PjivuBj4Z3asalIpYGdXe5+tLZCVxafnGjw4FG+++TGKigBaoYQkJydDKpU2eXwkaf4osZFqFRVAZiagVALZ2UBuLpCTw7/ev//g+5wcoKQEyMvjyay09OErOQCIATABL77ooUdEVQB8kJDwI9zdH3RKsbcHbGwAmYxvzs5Au3aAkxP/vubX9u0BT0/A1RWo0a+FWDCFQoGOHTtq9cIlRIMSWwuSmQkkJwO3bwMKBZCRAaSl8S09HcjKAmr2rre3f5AkNJu/P99nbw84OvIEY2sLtGnDv2/dmicbsXgcPvroNaxebVMrBltbfl5NJSU8qdZUVAR89FFrPP30T3Bzk6GwECgv5/uLi3lCLSzkmybpXr9eOxnXTLgSCU9unp6Auzvg5QV4eADe3kCXLkDnzvx9EfNHPSLJo1Bia2YKCoCrV/n2118PEtnt2zyBALzqr1OnBw94f3/+kK/50Hdx4efpIyZmpVYS06V1a77V5OgIrF79kV6rI//9N0/m6em8FJqRAaSm8q9//AHs38//XVn54J6aJNelC+DrCzz2GP/52No2OQxiYAqFAt27dxc6DGLGKLFZKLUa+PNP4NIlnsSuXAGuXQNSUvhxBwf+YO7SBYiI4F81m1wOmKIWx6YhWa0e+iQ1gLfbde7Mt7pUVvKfmSb5a7b9+/kHg7IyXoXZuTPQowcQEMCTXa9eQNeueoVHmkihUNAK6qRelNgsRHo6cP78gy0hgbdxSSRAhw68VBEVxR+8/v5A9+6mSV6WTiJ5kPAfplbzpHftGv8Qce0aEBsLLF3Kj8lkPMkNGQIMHgwMHMhLusR4VCoV0tLSqCqS1IsSm5m6cwc4dgw4fhyIi+PtYGIxT1j9+wOffQYMGMATWRPnGCaPoCmpde4MjB37YH9pKa/KPHuWb7GxwOef82O+vsCwYUBICDBiBO+8Qgzn7t27UKvVlNhIvSixmYm8PODwYZ7Ijh3jbWN2drwkMGsWEBQE9OlD3d3Nga0tMGgQ3zTu3+dJLjGR/x9++y0v1QUGAsHBQGgoT3bUVqcfGsNGGoISm4Du3QMOHQL++1/gyBH+IOzVC4iM5A/CIUO0exAS89SuHTBmDN8++YR31ElMBH79lW///jfvjBMSwkt/48fzXpqkcZKTk+Hg4AAn6sJK6kGJzcQyM4Hvvwd27eJtZfb2QHg48N13/KHYpo3QERJDaN2afzgJDeX/zswE9u4FfvoJmD2bl8KfeAKYNAmYOJG315FHUygUVFojj0TdC0xApeIPtHHjeFf6zz4DevcGfvmFD4T+4Qdg8mRKas2ZmxsQHQ0cPMhL6lu38o4ms2fzIRbTpvG21IdW6SEPoTFspCEosRlRdjbw3nt8fNgzz/Cu499/z3s4btjAS2q0AHDLI5PxUtrOnXxM3YoVfHD58OGAjw+wZs2DMYekNkpspCEosRnBnTvAm2/yQdAbNgCvv85n+jhyhFc9UbsZ0Wjblv9+nD3LxyKOGQMsXsx/dz7+mM+gQh6gxEYaghKbAWVlAdOn80/d+/fzLuB37gBLlvCxZoTUJzAQ+PJL/jszcyYvuXXsyEv9VIIDSkpKkJ2dTYmNPBIlNgOorOQPoW7deA+4zZv5rBVvvKE9az0hj9KuHfDRR3xw+IcfAmvX8vGL//2v0JEJi7r6k4aixKanS5eAxx8H5s/niez6deCFF/iMFoTow94eeOcd4MYN3rty4kT+NS1N6MiEkZycDADo2LGjwJEQc0eJTQ9btvCB087OfL7G//s/05TQDhw4AF9fX0gakT3VajUWLlwIHx8f2NjYIDw8vM5zf//9d0RFRcHb2xu2trZwcnJCYGAgnnnmGaxbtw63b98GAAQGBkIkEtXaai4GGhoaWutY3759te6VkpKCcePGobCw0CDv82EXL15EREQE2rZtCwcHB4SGhiIhIUHrvAULFuCHH36o8zovvfQSpFIpvL29MWfOHJSVlTU5psZydeW1AKdP845Hjz8OnDhhstubDYVCAVdXV7R+eMbsRsjLy8P69esRHBwMJycn2NrawsfHB1OmTMGlS5cMGC0RFCONplIxFh3NmEjE2Pz5jFVWmua+SUlJbOzYsaxHjx5MJpMxsVjc4NfGxMQwAOzjjz9meXl5Os9Rq9XsnXfeYRKJhL377rvs+vXrrKysjGVmZrIjR46w0NBQBoABYCqVijHGWGZmJnN2dmYA2NatW7Wu+csvvzAfHx9WUlKideyPP/5g7dq1Y//+978N9j5rOnPmDLO1tWUTJ05k6enpLDs7m73yyitMIpGww4cPa93T29ubvffee3Ver7CwkK1fv54BYEuXLm1STPoqLGQsMpIxiYSxFSsECUEwc+bMYQMHDtTrGtOnT2cSiYStXr2aZWRksJKSEhYfH8/8/f2ZWCxme/bsMVC0LdsINoK9zl4X6vZrKbE1kkrF2HPPMda6NWOm/huYPHky++yzz5hKpWJyubxRD/zJkyczAKywsLDOcxYtWsQAsA0bNug8XllZycLDw2slNsYY27ZtGwPAnJ2dWWZmZvX+3Nxc5uXlxRISErSuVVBQwDw9PVl0dLRB36eGWq1mAQEBzN3dnf3999+13kO3bt2Yl5cXKysrq/WaixcvMpFIxH744Yd6r21nZ8dGjRrV6JgMpaqKJzUrK8aWLBEsDJMbN24cmzx5sl7XmD59Onv11Ve19l+8eJEBYD4+Pnpdn3CU2CzM228zZmfH2G+/mf7eNR/QjX3gjxo1qt7zr1+/zqysrFifPn3qvc7p06e1Ehtj/KEDgD3zzDPV+6ZMmcLmzZun8zqLFy9mEomEpaWlaR3T531qnDhxggFgb775ptaxJUuWMAAsNjZW61hkZCTz9PTUen81eXh4PPLnZAobN/Jag82bhY7ENB577DG2aNEio13f1taWWVlZsaqqKqPdo6UQOrFRG1sjHDgArFwJbNzIZ3A3NVs9ZtBVq9X1Ht+wYQOqqqoQGRlZ73lBQUFgjGm1e61fvx6Ojo748ccfERsbi59++gkXL17Exx9/rHUNxhg2bdqEAQMGwMPDQ+u4Pu9T4/jx4wCgs11Ps+/YsWNax5566ikolUr88ssvdV5bJBKhUrM6qYBmzAAWLuRDA27dEjoa47tz547RuvqXlJSgtLS0ut2YWDZKbA1UWckHXU+aBDz/vNDRGF58fDwAoEePHk16vbu7O1atWgUAmDVrFt544w1s2bIFUh1Tq1y6dAlZWVno2bNn0wN+hBs3bgAAPD09tY7J5XIAwC0d2aBXr14AgMOHDxstNkP66CPAzw94+22hIzGu+/fvo6ioSGdiu3HjBiZMmIA2bdrAzs4O/fv3x/79+2t1XpoxY0a91//vP2MpFi9ebJT4iWlRp/QG+vlnPq7o6FGhI2maiooKnUlGIz09HQDg7Ozc5HtMmzYNu3btwoEDBzBs2DD06dNH53lXr14FoDvpGEp+fj4A6OxBZ29vD4D3kHuYJulpYtRFKpVCpVIZIky9SSS8N+7YsXxYgJ+f0BEZR11j2JKSkhAUFITWrVsjNjYWQUFBSElJwb/+9S9cvnwZUqn0kT1Ys7KysGDBAsyYMQPPPfec0d4DMR0qsTXQvn18GRlLHRt69+7dBiUSfathfHx8AABxcXHYu3evznMyMjIAAG0EmvWZ/TPTsK73KpPJIBKJqmPUxcPDA2lpaWZRHQnwOUddXPhsN81VcnIyxGKx1u/wokWLkJ+fjzVr1mDkyJGwt7dHQEAAtm/fjpIGTNeSk5ODsLAwDB8+HOvXrzdW+MTEKLE10NWrfOVqS5Obm4vly5cjJSUFM2fOrPM8TVvX/fv3m3yvkydPYvfu3Vi5ciUA4LXXXtNZKtJ8grY24tLfbdu2BQCdDzfNPs05D5NIJCgtLa3z2tHR0SgsLMQHH3yg18/LUKysgH79+FyTzZVCoYCXl5fW78yhQ4cAAKNHj66138XFBX6PKL6WlJRg9OjR8Pf3x7Zt2yAWiw0bNBEMJbYGKi7mM0FYkqioKDg7O2PBggWYN28eZs+eXee5w/7pDXP58uUm3au4uBhRUVHYsGED3nrrLYSHhyMzMxNz5szROtfmn1mgjVmdp3moKZVKrWNp/0zd4evrq/O1lZWV9XZgmTp1KpYuXYrly5fDxcUFYWFhBohYPw4OQFGR0FEYj67Jj8vLy1FUVAQbG5vq6uWaHB0d67xeZWUlIiMjIZfLsWXLFkpqzQwltgZq357P+mBJvvvuOxQUFGDnzp1YuXIloqOj6zw3OjoaEokEsbGx9V5z3rx5sLKyqu6coTF37lyEhoZWP+RjYmIgk8nw/fffY/9DdWTu7u4AgIKCgqa8rQYZMWIEAOD8+fNaxzT7QkJCtI4VFhaCMVYdoy6LFy/GokWLsG7dOuTn51eXGoSUlsbXfGuudCU2qVQKBwcHlJWVobi4WOs19+7dq/N60dHRKC8vx65du2r18O3atSvOnDljuMCJICixNVBQEHDsmOUtBCmTyRAZGYnevXvXm7R8fX3x4Ycf4ty5c9i8ebPOc27evImYmBg899xztap5Dh8+jKNHj2LFihXV+7y8vKr/HR0dXd2ZA+BTcQG6S1OGMmzYMPj7+yM2NrZW5wG1Wo2dO3fCy8seqa/SAAAgAElEQVQLERERWq/TlOY0Meqye/dueHt7Y8aMGYK1E9ZUUMCXvQkKEjoS46lruRrN1HAPf7jIzMzU2esVAJYsWYJr165h79699XaoIhZMqBF0lubSJcYAxg4cEDoSrrEDl0NCQhp0/oIFC5i1tTWbP38+u3nzJisvL2dKpZJt2rSJubu7syFDhrDi4uLq8/Py8piXlxc7ceKEzutppuGKioqq3ldVVcXat2/PBg8e/Mh4GvI+p0yZwgCw5OTkWvsTExOZjY0NmzRpEsvIyGD3799n0dHRTCKRsEOHDum81vbt2xmAeqdWksvlrGfPno+M3VQ+/5wxBwfG8vOFjsQ41Go1k0qlOqdsS0pKYk5OTkwul7MjR46woqIiduXKFRYWFsY6duzIpFJprfO//fbb6mnh6toSExNN9daaLaEHaFNia4Tx4xnr1o2x0lJh7r9v3746/xg3btxY72tDQ0MbnAjPnj3LXnjhBebl5cWsra2Zg4MDGzhwIFuzZg0rLy+vPk8ul9eKYfz48dXH8vLydMa5atUqxhifvquumUca+z6Dg4OZvb09q9QxaeeFCxdYeHg4k8lkzN7engUHB7NTp07V+d4jIyOZXC5nFRUVdZ4jl8tZr1696jxuSkolYzIZY4sXCx2J8dy9e5cBYKdPn9Z5/ObNm2zChAlMJpMxOzs7NmjQIBYXF8dCQkK0EltERAQlNhOgxGZBUlIYa9uWsRdfFDqSxouIiGAikUjoMKrl5+czuVyuc67IxsjLy2O2trZsxowZesekmStyx44d9Z7n6uqq92S8hlBWxlhQEP+wVWMWsmYnLi6OAWAZGRmNep2uxEZMQ+jERm1sjdChA7B9O9/mzhU6msbx9PQEYwxZWVlChwKAj2Hbt28fYmNjsXbt2iZdgzGG2bNnQyaT4ZNPPtErnuTkZDz99NNYuHBhraV3HqZSqZCbm2vUweUNUV4OPPMMX//vp58AA8xCZraSk5Nha2sLV1dXoUMhFoISWyOFhwNbtwJffsmn19LRGcssaXorLlu2DDk5OQJHw/Xu3Rvnzp3DwYMHda7H9ihZWVlITk7GsWPH4KZnl8CYmBgsXboUS5curfOcgoICrFy5EiqVStAu/mlpQHAwcOoUcPhw851tREOhUKBTp040hyNpOKHKipYuLo4xNzdeDXT1qtDRNMznn3/OunfvzqRSKQsLCxM6HIsybdo0Zm1tzbp27cref/99ne15phAfz5i7O2O+vpbze6evF154gY0ZM6bB5+/YsUOr3Wz69OlGjJA8TOiqSBFjltaB3XwolcCzzwJ//gl88AEwZw5gxMk0SAtWWAgsWQL8+9/A+PHAt9/yQdktwdChQ9GzZ0989dVXQodCGigYwfCDH77G10Lc/muqitSDpycQH89nVv/gA6BHD8udJJmYJ8aALVuAbt2A778Hvv4a+O9/W05SA+oew0ZIXSix6alVK/5J+s8/ge7dgVGjgIgI4ORJoSMjlqyqCti9m89POn067yhy8ybwyitAS2pqKi8vR0ZGBiU20iiU2AykUyf+IDp6lM/Z98QTfDWAffssb7YSIpyKCl7NGBAAREbynrgXLgBffQU4OQkdnemlpKSgqqpKa7kaQupDic3AQkN59eSpU4CjI28PCQgAVqwAzKSnPTFDSUnAe+/xZZFee41Pj3XtGvDjj7yKu6VKTk4GAHTq1EnYQIhFocRmJIMH89LapUvA8OHA0qW8TW78eGDvXsBM1qkkAiopAb77Dhg2DPD15d9Pm8aT3ObNzb8bf0MoFAo4OjrWucQQIbpQYjOyxx7jDf6ZmXxgd1UVby9xdQWeew74z3+a93IjpLbcXN7548UXAXd3IDoakMmAH34A7tzhH4C8vISO0nxQxxHSFJTYTEQq5W0m+/YBycm82ikzE3j5ZZ7kJkzgn9KNOOE9EciNG3xAf0gI/79+4QUgJwf44gu+FNK+ffx3o8bqKeQflNhIU9CfkgA6dOBDBN5+G7h3D/j5Zz4t0qxZQFkZr5YKDubb8OGAi4vQEZPGSEkBTpwAjh/nSx2lpwNt2vBZa7Zt419bUnd9fSgUiuq19QhpKEpsAmvfHpgxg2+lpcDp0/yBePw4sGkToFYDgYG8M8GAAbz7d/fuAC34ax4qKoCLF/l6aGfP8v+/27f53I2DBvEPKyNGAP36UYmsKRQKBV5++WWhwyAWhv7UzIitLa+u0izsXFgIxMXx7X//43NU/v03/7Tfpw9PdI8/zntd+vrSrCfGVlrKJx2+coV3wf/f/3hSKy8H2rbl/x9TpvBSdlAQYGMjdMSWraioCLm5udTVnzQaJTYzJpMBY8fyDQAqK4GrV/kD9X//A/bv5+00lZV8oLifH09yjz3GS3nduvHxda1aCfo2LE5pKe+ZeOMG/3lfuwZcvszbRtVq3l7aowcvPc+cyROar2/LGjhtCpqu/tTGRhqLEpsFkUiAXr34Fh3N95WX81lPrl3jD+GrV4GYGN7OA/AqSy8voGtXoEuXB1vnzrxXXktcCUSt5mMKlUpAoeBVh0lJ/Ovt23z2fID/7Lp04R8UJk/mHxYee4z/LKla0fiSk5MhEonQsWNHoUMhFob+PC2cVAr07s23mgoL+cO65gP75k3gwAH+QNfMhtKqFeDmxsfYeXgAcjnf2rfnM104O/NN872VmfajVal4T8Pc3NpfMzJ479PUVP69UsmTmlrNXyeRAB078gQWEACMG/cg+fv4UHWikBQKBdzd3WFD/wmkkSixNVMyGW9/e/xx7WPl5XzMVM0Hfloa337/HdizB8jO5lVyD9MkOJmMt/XZ2PCvrVvz79u0AezseMIF+LGapRuxmL+2pvz82tOOlZfztkSAfy0r4+eUlj74vqyMH9MkMO3l3AogkUyFh8fn6NjRH15efIozLy9eUtUkcC8vKn2ZK+rqT5qK/qRbIKmUt79161b/eaWl2qWg7Gz+tbCQL7JaWsoHmGdl8WRTWMhn1Kio4NfIy3twPbX6CkpLd0KlWgLgQU+X+pKfrS1PmI6O/KutLW83tLHhCVSTaB8uXYrFDM8+W4CrV4fg009/xpAhQwzxoyMmRImNNBUlNlInW1teRenpaZjrffPNWcyZswYVFXWvUm04bXH06FFMnToVoaGh2LZtG5555hkT3JcYikKhwOO6qhwIeQQzbTEhzVFqaio8DZUlG0AqlWLnzp2IiorCxIkTsWHDBpPdm+iHMYY7d+5QiY00CZXYiMmkpaXBy8QTIYrFYqxfvx7e3t547bXXkJ6ejiVLlpg0BtJ49+7dw99//01j2EiTUGIjJqNUKk1aYqtp/vz5cHFxQXR0NO7fv48vv/wSVubaxZPQGDaiF0psxGRSU1PRt29fwe7/8ssvw8nJCc8//zzS09Oxfft26kpuphQKBaytrSGXy4UOhVgg+shKTEbIEpvGhAkTcPDgQRw/fhzh4eEoKCgQNB6im0KhQIcOHSCmSVFJE1BiIyZRVFSEgoICwRMbAAwbNgynTp1CUlIShgwZgjTNVCPEbFBXf6IPSmzEJJT/LDRnDokNAAIDA3Hy5EmoVCoMGTIEt27dEjokUgMlNqIPSmzEJFJTUwHA5L0i69OpUyecPn0aHh4eGDRoEBITE4UOifyDEhvRByU2YhJKpRJ2dnZwcnISOpRanJyccOTIEQwYMAAjR47EwYMHhQ6pxausrIRSqaSu/qTJKLERkzCHjiN1ad26Nfbu3YtJkyZhwoQJ2L59u9AhtWhKpRIqlYpKbKTJqLs/MQlzTmwAIJFIsHHjRnh6emLq1KlQKpWYN2+e0GG1SDSGjeiLEhsxCXNPbAAgEomwZMkSODo64u2330ZaWhpWrVpFA7lNTKFQoHXr1nBxcRE6FGKhKLERk1AqlRYzoe2cOXPQrl07vPTSS8jNzcXmzZthbW396BcSg6COI0Rf9FGUmIRSqbSoWSSmTJmCgwcP4ueff8aYMWNQVFQkdEgtBiU2oi9KbMToSkpKkJeXZ1Zd/RsiJCQEx44dw+XLlxESEoLs7GyhQ2oRKLERfVFiI0anGcNm7m1suvTt2xeJiYnIy8tDUFAQkpKShA6p2aPERvRFiY0YnbnNOtJYnTt3xsmTJyGTyTB06FBcvHhR6JCardLSUmRlZdEYNqIXSmzE6JRKJWxsbODs7Cx0KE3m5uaG+Ph49OjRA0OHDsXRo0eFDqlZUigUYIxRiY3ohRIbMTrNytkikUjoUPRib2+Pffv2ISIiAmPHjsWuXbuEDqnZUSgUAPh0Z4Q0FSU2YnRCrJxtLK1atcKOHTvwxhtv4Pnnn8e6deuEDqlZUSgUaNeuHRwcHIQOhVgwGsdGjM4SBmc3hkgkwooVK+Di4oJZs2YhJSUFy5YtEzqsZoE6jhBDoMRGjC41NRU9evQQOgyDmz9/Ptzc3DBjxgxkZWVh48aNkEjoT0oflNiIIdBfITG65lZiq2natGlwcnLCpEmTkJubi507d8LW1lbosCyWQqHA6NGjhQ6DWDhqYyNG9ffffyM3N7fZJjYAGDt2LI4fP47Tp08jODgYOTk5QoeEAwcOwNfX1+JKkHfu3KESG9EbJTZiVJY+hq2hBgwYgPj4eKSnp+OJJ56oHpRuardv38a4ceOwcOFCZGVlCRJDU+Xl5SE/P5/GsBG9UWIjRmWOK2cbS/fu3ZGYmAiJRIKBAwfiypUrJo/h/fffx6BBg3D+/HmL61lIy9UQQ6HERoxKqVRCKpWiXbt2QodiEh4eHvjtt9/QuXNnDBs2DAkJCSa9/zfffIMFCxZYXBUkwNvXrKysWsSHIGJclNiIUWk6jlj64OzGcHR0xK+//oqQkBCMGjUK+/fvN9m9LbnjikKhgFwuh1QqFToUYuEosRGjas49IusjlUqxc+dOTJ06FRMmTMDGjRubdJ0bN25gwoQJaNOmDezs7NC/f3/s378foaGhEIlEEIlEmDFjhoGjFwZ19SeGYnn1FcSiKJXKFlu1JBaLERMTg86dOyM6OhppaWlYsmRJg1+flJSEoKAgtG7dGrGxsQgKCkJKSgr+9a9/4fLly5BKpSgrKzPeGzAxSmzEUCixEaNSKpUIDAwUOgxBzZ8/H/b29pg9ezZycnKwZs0aWFk9urJk0aJFyM/Px6ZNmzBy5EgAQEBAALZv394s51JUKBQYOHCg0GGQZoCqIolRpaamWtTK2cYya9Ys/Pjjj9i0aROeffbZBpW0Dh06BABaA5ZdXFzg5+dnlDiFwhhDSkoKdfUnBkGJjRhNWVkZcnNzW2xV5MMmTJiAgwcP4vjx4xgzZgwKCgrqPLe8vBxFRUWwsbGBvb291nFHR0djhmpy6enpKCsro6pIYhCU2IjRpKamgjHWIjuP1GX48OE4deoUbt26haFDhyItLU3neVKpFA4ODigrK0NxcbHW8Xv37hk7VJPSLFdDiY0YAiU2YjQtZdaRxgoMDMSpU6dQUVGBoUOH4tatWzrPCw8PB/CgSlIjMzOzztdYKoVCAalUCnd3d6FDIc0AJTZiNJrB2e3btxc6FLPTqVMnnD59Gm5ubhg0aBDOnDmjdc6nn34KJycn/Otf/8LRo0dRXFyMq1ev4qWXXoKbm5sAURuPQqFAx44dG9SphpBHod8iYjSajiMtaXB2Yzg5OeHo0aPo378/QkNDtUpmXbp0QWJiIvr164dnn30Wrq6uiI6OxsKFC9G1a1ed19y/f3/1+La0tDSo1erqf2/atMkUb6tJqKs/MSTq7k+MJi0tjaohH6F169b4+eefER0djfHjx+O7777D5MmTq4/7+vpiz549Db7ek08+CcaYMUI1KoVCge7duwsdBmkmKLERo0lNTaXE1gASiQSbNm2Ci4sLpkyZAqVSiXfffVfosExKoVBgzJgxQodBmglKbMRolEpl9cBiUj+RSIRly5bB3d0db7/9NpRKJVatWtUi2pxUKhXS0tJoDBsxmOb/V0ME01LnidTHnDlzsGXLFqxbtw5RUVFQqVS1ju/cuRMikQjHjh1DeXl5s5grMiUlBWq1mtrYiMFQiY0YRVlZGe7fv0+JrQmmTp0Kd3d3PPXUU8jIyMDu3bur11abNGkSJk2aJHCEhkVj2IihUYmNGEVaWhoNztZDSEgIjh8/jsuXLyMkJATZ2dlCh2Q0CoUCDg4OcHJyEjoU0kxQYiNG0ZJWzjaWvn37IjExEXl5eQgKCsLt27eFDskoFAoFta8Rg6LERoxCqVTC2tqaBmfrqXPnzjh58iRkMhmGDh2KixcvCh2SwdEYNmJolNiIUSiVSsjl8hbRq8/Y3NzcEB8fj8DAQIwYMQLx8fFCh2RQVGIjhkZPHWIU1CPSsOzt7bFv3z6MGjUKo0aNwq5du4QOyWCoxEYMjRIbMYqWvHK2sUilUmzfvh3Tp0/H888/j/Xr1wsdkt5KSkqQnZ1NiY0YFHX3J0ahVCoRHBwsdBjNjlgsxtq1a9GhQwfMnDkTd+7cwbJly4QOq8mSk5MBUFd/YliU2IhR0MrZxjV//ny4urrilVdewb1797BhwwZIJJb356wZw9axY0eBIyHNieX9JRCzV15ejuzsbKqKNLKoqCg4Oztj4sSJyM3NxY4dO2Brayt0WI2iUCjg6uqK1q1bCx0KaUaojY0YHA3ONp2xY8fixIkTSEhIQHBwMHJycoQOqU4nT57Ehg0bcPToUSQlJaGiooI6jhCjoBIbMThaOdu0BgwYgLi4OISFhWHYsGE4ePCgWZaW7927h+jo6Op/i0Qi2NvbQyaTISoqCt7e3vD29kbnzp3h5+eHdu3aCRgtsWSU2IjBpaamwtraGq6urkKH0mL4+/vjzJkzCA8Px9ChQ3Ho0CH4+fnpPDc3N1eQ6av69+9f69+MMRQVFaGoqAhbt26FRCKBSqVCVVUVDh48iLCwMJPHSJoHqookBqdUKuHh4QGxWCx0KC2Kh4cHfvvtN3h5eWHw4MFISEjQOuePP/5AYGAgMjMzTR6fl5dXnaUwtVpdvVpBnz59KKkRvVBiIwZHK2cLx9HREUePHsWIESMwatQo/PLLL9XHkpKSMHLkSGRkZODjjz8WJL6goKB6Z6NRq9X49NNPTRgRaY4osRGDo5WzhWVjY4MffvgBU6ZMwfjx47Fp0ybcu3cPo0aNQmFhIQBgw4YN+Ouvv0we28CBA+scliAWi9G3b1+MGjXKxFGR5oYSGzE4mk5LeGKxGDExMZg/fz5effVVPP7441AqldULl1pZWWHx4sUmj6t///6oqKjQeYxKa8RQKLERg6PEZh5EIhHee+89dOnSBVlZWbVW41apVIiNjcWZM2dMGlO/fv0gEom09mtKayNHjjRpPKR5osRGDKqiogL37t2jxGYG1Go1Jk+ejDt37qCyslLruFgsxjvvvGPSmNq0aaNz3JparcZnn31m0lhI80WJjRhUWloaqqqqzHIcVUvCGMOrr76K/fv360xqAFBZWYmEhAQcOXLEpLENGTKkVjubWCxGv379EBoaatI4SPNFiY0YFA3ONg8LFy7E5s2boVar6z1PLBZj7ty5qKqqMlFkvDqyJmpbI4ZGiY0YlFKphFgshpubm9ChtGgvvfQSZs2aBTs7O0gkEp3tWgBPKteuXcPOnTtNFlv//v2rS5ESiQT9+/en0hoxKEpsxKBocLZ56NatG7766itkZmZi7dq16NKlCwDU2dV+3rx5KC8vN0lsvXr1grW1NQBeHUqlNWJolNiIQVGPSPPi4OCAV199Fbdu3cLRo0cxduxYWFlZoVWrVtXnMMaQmZmJmJgYk8TUqlUrBAYGAuADtkNCQkxyX9Jy0FyRxKBo5WzzJBKJEBoaitDQUNy6dQtr167FN998g/LycqjVaqjVaixZsgQvvfQSHBwcGnTNv/8GysqA/HygtJR/r1IBxcW1zysv5+fW5OY2GMAfePrp/8Ovv/J9YjEgk/Hv27YFbGwAOzugTRugnslKCNEiYowxoYMgzceAAQMwZMgQfPHFF0KHQh6hqKgIW7ZswYoVq5CSwleyfuqpDzB8+EfIyQFyc/mm+T4nBygp4QmsoEDfu38PYBOAuAadLZU+SHKtWwNOToCz84Ovms3JCXBxATw8ALmcJ0diesEIhh/88DW+FuL2X1OJjRgUTadlXoqLgdu3+XbnDpCaCqSnA2lpgFLpgIyMN1BRMQvAEQCrsGfPapw+PRPt2rlWJwpPT6BHD544WrfmyaJNG55opFLA0ZHvs7UFRCJe2qqpZklM49q1/rh92xNDhz7YV7Nkl5fHE2hpKS8RlpXxY4WF/D1pEm16OnDlCnD/Pv/3PzOGVXN2BtzdgQ4d+FdPT8DLC+jShW9yOZUGmyNKbMRgVCoVDc4WgEoF3LwJXL0K3LjxIJHdvg3cu8fPEYl4KaZjR/6A79MHGDeO7/P0FMHdfTQ8PEYjKysJubkp6N/fuEsOBQR0Q0BAN4Nft7ISyM7miTs9HVAqgYwMntBTU4EzZ4CUlAfVpVIp4O39INF17QoEBACPPcZLfsQyUWIjBpOeng61Wk2JzYjS0oALF3gSu3LlQTJTqQCJ5MEDum9fYOLEB//u3Jk/xB/FwaGr8d+EEUkkPHG7u9d/XlZW7Q8At28Dv/8ObNvGS34A4OrKE1xgIE92PXvyrUa/G2KmKLERg6HB2YZVXAxcvAicP/9g+/NPfszdnT9sR4wA3ngD8PfnpTBbW2FjthSurnwbNEj7WF4ecO0a/1lfu8YT3qZN/P9DIgF8fYEhQ4DBg/nP3N+fl4iJ+aDERgwmNTUVYrEY7o/6uEx0KiwE4uKA48f5du0aoFbz6sL+/YGpU4EBA/jDtE0boaNtvhwdeeIaMuTBvqoq4NYt4OzZB9u33/KSsrMzPzc4GAgJ4R84iLAosRGDUSqVcHd3r3MQMKmtshI4dQr49Vfg2DHg3DmeyHr04A/IDz/kCY0KwMKzsgL8/Pj24ot8X3k58McfwP/+B5w4wf+/5swB3Nx4kgsOBsLD+QcTYlr0BCIGQytnP1ppKU9k+/cDe/fytp7OnYHQUOD113lCk8uFjpI0hFQKDBzItzlz+IeSixf5h5WEBODtt4EZM3hVZWQkMHYsL20T46PERgyGuvrrVl4O/PwzsH07cOQI77oeFAS88w4wYQLviUcsn1jME1efPjzRlZXxDzE//QSsWwd89BHQrRvw7LPAtGmAj4/QETdfNIKDGAzNOlLbpUv8ASeXA5Mn8wS3Zg3vfn7qFE9slNSaLxsb4MkneceT9HQgPp7/e8sWnuCeeIJ/X1IidKTNDyU2YjBKpRLyFl6PVlnJu4z36QP06gUcPAjMncvHTh04wKum2rcXOkpiamIxMHQosGIFHyj/yy+8LS46mvdwnTkTSE4WOsrmgxIbMYjKykpkZma22KrI0lJg7VpevRQVxTsZxMfzgdMLF1K7GXlALOadSnbt4uMSP/kEOHyYDyN4/nle0if6ocRGDEIzOLulVUWq1cBXXwGdOgHvvgtERPBu4du28U/oNL6J1MfZmVdX37oFfP89HzvXuzefFebWLaGjs1yU2IhBtMTB2SdP8irHuXN5Z4A7d3iS8/YWOjJiacRi3g77xx+8x+zdu3zWk4ULtVdLII9GiY0YhFKphJWVVYsYnF1czKsbhw3j7SNXrgD/7/9R2xnRn0gEjBnDxzR+8QUQE8OrtQ8dEjoyy0KJjRiEUqmEm5tb9crI+rh48SIiIiLQtm1bODg4IDQ0FAkJCQaIUn/Xr/NB0wcPArt386++vsa5F2MMCQkJmDVrFnx9fSGVStG+fXsMGTIEW7duxaNWnFKr1Vi4cCF8fHxgY2OD8PDwOs/9/fffERUVBW9vb9ja2sLJyQmBgYF45plnsG7dOty+fRsAEBgYCJFIVGubNGlS9XVCQ0NrHevbt6/WvVJSUjBu3DgU/jMVf15eHtavX4/g4GA4OTnB1tYWPj4+mDJlCi41scHpwIED8PX1rXeygAULFuCHH36o8/hLL70EqVQKb29vzJkzB2VlZU2KpSkkEj5V2s2bwPDhvIr7o4/4DCikARghBvDWW2+xAQMG6H2dM2fOMFtbWzZx4kSWnp7OsrOz2SuvvMIkEgk7fPiwASJtuthYxuztGRs0iDGl0vj3u379OgPAQkND2aVLl1hpaSm7ffs2mzx5MgPA5s6dW+/rY2JiGAD28ccfs7y8PJ3nqNVq9s477zCJRMLeffdddv36dVZWVsYyMzPZkSNHWGhoKAPAADCVSsUYYywzM5M5OzszAGzr1q1a1/zll1+Yj48PKykp0Tr2xx9/sHbt2rF///vf1fumT5/OJBIJW716NcvIyGAlJSUsPj6e+fv7M7FYzPbs2dPgn1lSUhIbO3Ys69GjB5PJZEwsFtd7rre3N3vvvffqPKewsJCtX7+eAWBLly5tcByGtm4dY1IpY2PGMFZQIFgYDTaCjWCvs9eFuv1aSmzEICIjI9kzzzyj1zXUajULCAhg7u7u7O+//67eX1lZybp168a8vLxYWVmZvqE2ybZtjInFjM2cyVhFhWnuef36dSaRSFhubm6t/eXl5czZ2ZlJpdJ6fx6aBFhYWFjnOYsWLWIA2IYNG3Qer6ysZOHh4bUSG2OMbdu2jQFgzs7OLDMzs3p/bm4u8/LyYgkJCVrXKigoYJ6eniw6OrrW/unTp7NXX31V6/yLFy8yAMzHx6fO+B82efJk9tlnnzGVSsXkcnm9iU1zD5FIxH744Yd6z7Ozs2OjRo1qcBzG8L//MebuzlhQkPknN0pspFkYOHAgmzNnjl7XOHHiBAPA3nzzTa1jS5YsYQBYbGysXvdoivh4xqytGXvnHZPfuk69evViAFh+fn6d54waNareB/v169eZlZUV69OnT733On36tFZiY4yxcePGMQC1PtBMmTKFzZs3T+d1Fi9ezCQSCUtLS6v3fjXZ2toyKysrVlVV1aDza9jnqIgAACAASURBVH4gakhiY4x/KPP09NR6fzV5eHg88udkCjduMObmxlhEBGNqtdDR1E3oxEZtbMQglEql3j0ijx8/DgA622U0+44dO6bXPRqrsJD3VnvySd5BxBzk5+fjr7/+Qu/evdGmnmn+1Wp1vdfZsGEDqqqqEBkZWe95QUFBYIxptVetX78ejo6O+PHHHxEbG4uffvoJFy9exMcff6x1DcYYNm3ahAEDBsCjgbMCl5SUoLS0tLpdryFsm7Buz1NPPQWlUolffvmlznNEIhEqKysbfW1D69YN2LOHT9W1erXQ0ZgvSmxEb2q1us7B2Tdu3MCECRPQpk0b2NnZoX///ti/f3+tTgYzZsyoPhfQPWRAM6PJLRMP7vnkE6CiAti4UfgxaYWFhUhISMC4cePg5uaG//znP3pdLz4+HgDQo0ePJr3e3d0dq1atAgDMmjULb7zxBrZs2QKpjhVNL126hKysLPTs2bPB1//vf/8LAFi8eHGT4muoXr16AQAOHz5s1PsYysCBwKJFfDWB7GyhozFPlNiI3jIyMlBZWamVkJKSkhAUFIRz584hNjYW9+7dw7fffos1a9bg8uXLkEql1Z/kAV4SAYDWrVtr3cPe3h4A70FnKiUlwIYNfOC1s7PJbqvT//3f/6FNmzYYMmQIxGIx9uzZg8DAwHpfU1FRoTPJaKSnpwMAnPV4c9OmTcOYMWNw7949dO3aFX3qmL7+6tWrABo+zjErKwsLFizAjBkz8NxzzzU5vobQfGjSxKiLVCqFSqUyahyN8c47fHWBmBihIzFPlNiI3jSDsx+edWTRokXIz8/HmjVrMHLkSNjb2yMgIADbt29HSSNnfmX/dG1vaJWUIcTHA0VFwAsvmOyWdXrvvfdQXl6O69evw8/PD71798Ynn3xS72vu3r3boESi78/U559p6uPi4rB3716d52RkZABAvVWnGjk5OQgLC8Pw4cOxfv16vWJrCJlMBpFIVB2jLh4eHkhLSzOL6kgAsLMDnnsO2LdP6EjMEyU2orfU1FSdg7MP/TOqdPTo0bX2u7i4wM/PT+s6bdu2BQCdSU+zT3OOKVy9CnTowCerNQetWrWCn58f1q1bh3HjxuGDDz7Ar7/+qnVebm4uli9fjpSUFMycObPO62nauu7fv9/kmE6ePIndu3dj5cqVAIDXXntNZ6laMwbsUeMcS0pKMHr0aPj7+2Pbtm0Qi8VNjq0xJBIJSktL6zweHR2NwsJCfPDBB3r9vAypf3/+O0q0UWIjelMqlXB1dUWrVq2q95WXl6OoqAg2NjbV1Yg1OTo6au3TJDtNCbCmtLQ0AICvsUZD61BcDDg4mOx2jTJ27FgAwP79+2vtj4qKgrOzMxYsWIB58+Zh9uzZdV5j2LBhAIDLly83KYbi4mJERUVhw4YNeOuttxAeHo7MzEzMmTNH61wbGxsAqLc6r7KyEpGRkZDL5diyZYvJkprm3vV1PJk6dSqWLl2K5cuXw8XFBWFhYSaLrS4yGZ9820wKkWaFEhvRm64ekVKpFA4ODigrK0Oxjsnu7t27p7VvxIgRAIDz589rHdPsCwkJMUTIDdK+PV877RETfAhC03aWm5tba/93332HgoIC7Ny5EytXrkR0dHSd14iOjoZEIkFsbGy995o3bx6srKyqO/dozJ07F6GhodUP+ZiYGMhkMnz//fdaCVdTmi8oKKg3nvLycuzatatWD8yuXbvizJkz9caoj8LCQjDG6p0ObvHixVi0aBHWrVuH/Pz86toIISmVvO23nslVWixKbERvdXX110zh9PBDIDMzU2fvxmHDhsHf3x+xsbG1pi9Sq9XYuXMnvLy8EBERYeDo6xYUBOTk8IlphfDOO+9g6tSpOo8dPHgQANCvXz+tYzKZDJGRkejdu3e9ScvX1xcffvghzp07h82bN+s85+bNm4iJicFzzz1Xq/r48OHDOHr0KFasWFG9z8vLq/rf0dHR1Z2BAFR3dNFVGgeAJUuW4Nq1a9i7d2+9HV6MQVMbUF9nnN27d8Pb2xszZsxoUDuhKfz6K/8dJToINYKONB+DBg1is2fP1tqflJTEnJycmFwuZ0eOHGFFRUXsypUrLCwsjHXs2JFJpVKt1yQmJjIbGxs2adIklpGRwe7fv8+io6OZRCJhhw4dMsXbqVZVxVj37oxFRZn0ttXmzp3LRCIR++ijj5hCoWBlZWVMoVCwefPmMQCsT58+tQYkPywkJKRBA5QXLFjArK2t2fz589nNmzdZeXk5UyqVbNOmTczd3Z0NGTKEFRcXV5+fl5fHvLy82IkTJ3ReTzMNV1SNH1xVVRVr3749Gzx4sNb53377bfW0XXVtiYmJtV4zZcoUBoAlJyfX+b4aOkB7+/btDEC9U3fJ5XLWs2fPR17LVP76i8+Es3On0JHoJvQAbUpsRG8dOnRgn3/+uc5jN2/eZBMmTGAymYzZ2dmxQYMGsbi4OBYSEqIzsTHG2IULF1h4eDiTyWTM3t6eBQcHs1OnThnzLdRp61bGrKwYO33a9PcuKChgmzZtYqNHj2adOnVirVq1Yvb29qxPnz7ss88+qzepMcYTTEMe7IwxdvbsWfbCCy8wLy8vZm1tzRwcHNjAgQPZmjVrWHl5efV5crm8VsIZP3589bG8vDydSWnVqlWMMT59l66ZRyIiIhqd2IKDg5m9vT2rrKystX/fvn11XmPjxo0633tkZCSTy+Wsop650uRyOevVq1eDfpbGVlXFWHg4Y/7+jNUzWYqgKLERi1ZZWcmsra3Z9u3bG/W6+hKbuQkLY6xDB8aysoSOpHEiIiKYSCQSOoxq+fn5TC6Xa80V2Vh5eXnM1taWzZgxQ++YNHNF7tixo97zXF1d2cCBA/W+nyF8+iljEgljJ08KHUndhE5s1MZG9JKZmQmVStWsFxjduhWwtgZGjeJtbpbC09MTjDFkZWUJHQoAPoZt3759iI2Nxdq1a5t0DcYYZs+eDZlM9shxfI+SnJyMp59+GgsXLqy19M7DVCoVcnNzzeJ3PCYGWLwYWLkSGDJE6GjMFyU2opeWsHK2szNw7BifN3LgQKCJveNNTtNbcdmyZcgxk4zcu3dvnDt3DgcPHqxej60xsrKykJycjGPHjsFNzwGGMTExWLp0KZYuXVrnOQUFBVi5ciVUKpWgXfzVamD+fOD11/k0b2++KVgolkGosiJpHmJjY5lIJGrwcjI7duzQavuYPn26kaM0jOxsxkJDGbOxYeybb4SOpmE+//xz1r17dyaVSllYWJjQ4ViUadOmMWtra9a1a1f2/vvva7XnmUp2NmMjR1rW753QVZEixsxxlA6xFKtXr8ayZcuQmZkpdCgmUVkJLFwIfPEFMHEisGIF8M9Ug4QYFGPAtm3AvHmArS3w44/AP/M1m71gBMMPfvgaXwtx+6+pKpLoJS0tTWuOyOZMIgGWL+dz9P3+O+DnByxbxlcAIMRQLl4EnngCmDYNGDcOOHfOcpKaOaDERvRiiHXYLFFEBJ+nb/583ubh78+XtikvFzoyYsmuXQNefBHo2xeoquIfntavB3TMQEfqQYmN6CU1NbVFJjYAsLEB3nsPuH4dCA7mDfre3rxEV1QkdHTEkiQmAuPHA489Bly4APznP8CpU8DjjwsdmWWixEb00lJLbDV16MDXbUtOBqZM4SW4Dh2AWbN4FRIhuhQWAps2AYMG8S07G/jpJ+DKFeD554Vf2NaSUWIjTVZVVYWMjIwWn9g0PDx4aS0lha9wfOIE0K8f0KMHsHo1rXZMeIeQuDjedubu/qCUHxcHnD7N29MooemPEhtpsqysLFRUVFBie4ijI191+88/eYltxAheinN354NqP/8cSPr/7N13WBTX+gfw77L0DoJIE7GggrEEO6Ko2GJP7CXRiBJioibXa6yJxmiS5ya5UX+J3VgSo1Fj7F2QGBugoIgNC9J7l7p7fn+cuwsrS9/dAfb9PM88LDOzM++uOO+cM6dECx0l0RSJhFcrLlzIS/I+Pvzv4vPPgdhY3vKxf3+ho2xaKLGROouNjQVQceZsUsbTE9iwoewC5uQErF8PuLnx0ty6dfyZilQqdKREldLTgUOH+OzrtraAtzefkd3Pjzc6un+fNzyysRE60qaJZvIhdRYXFweRSCSfiZlUztiY93ubPJm3nLx8mT9P+b//4w1QrK35nfygQXzp2FHoiElt5ObyxHX5Ml/u3uVVil5ewKpVwLhxvMqRaAYlNlJncXFxsLW1lc+OTGrGwAAYMYIvW7bwO/jLl/mwXStWANnZvNrSywvo1Qvo2ZOX/ExMhI6cyERHA7duATdv8p+hobzKsVMnfmOyZg0wYADQQKZu0zqU2EidUYvI+hOJeBPvN97gz2AkEn6RDAzkTcC//x5ISgLEYsDDgye5Hj34/h4egLm50J+gaZNKgefPeUvF8HCexG7d4lWNenpAly785mPRIv4stXlzoSMmACU2Ug+U2FRPLOYXyl69yta9fMlLBrLSwYEDQF4e39aqFU9wnTrxxd0daNOGSgq1JZHw7/nJE57E7t/nP6OigFev+A1I69b8xmLlSv7v060b78tIGh5KbKTO4uLi0LlzZ6HDaPJatuTLxIn8d8aAFy8UL8BnzgD//W/Z0F62tjzByZa2bfmF2dkZaNEC0NcX7OMIJjMTSEjg3110NPD0adnPFy/Kvjs7O14i7tcP8Pfn3TXc3QFTUyGjJ7VBiY3UWWxsLEaMGCF0GFpHJOINEVxdeb8nmZIS3kn86dOyJToa+OMPXp1WfrivFi0kMDa+AHf34XBw4H3wWrTgCdHamk/V06wZf92QSyWZmbxaULZkZABpabwValIS/5mYCMTHAwUFZe+zsytL+r17l71u145/btK4UWIjdcIYQ2JiIjX1b0D09ID27fnyOqmUX+BfvgSiohLwzTfT8OLFLXTr9hjR0U74+2++PSur4ntNTMqSnLExXywseMIzMQHMzPhrMzO+v4EB36c8CwtAp1znovx8xYGjGSs7d0kJr2rNywMKC/kIHfn5PDFnZfHXskT2ejcJAwMeq5MTb4DTpQswbBj/3cGBz8TQsiWVvpo6SmykTpKTk1FUVETP2BoJHR1+UX/8OBCrVk2HmZkZQkKuoWtXxX8/iUSx9PP6z1ev+JKdzRNPcjJPPIWFZc/9qkpaMvr6d6CjcwhGRuvl62TJTyzmjWJMTHjCtLDgjTJkr8sn2mbNeF8w2e+UsAhAiY3UkTbMnN2USCQSrF27Fl999RXGjh2LnTt3wtLSssJ+YjFPIupu3XfoUDSmTPkWeXlrIRaL1XsyonUosZE6kXXOdqRZNhu8lJQUzJw5E1euXMH333+PhQsXCh0SbGxsIJVKkZGRAVtbW6HDIU0MJTZSJ7GxsWjWrBmMjIyEDoVUITAwENOnT4epqSlu3LiBrg1ktkqb/40llZaWRomNqByNFUnqRNtmzm5sGGP49ttvMWTIEPTu3Ru3bt1qMEkNUExshKgaldhInVDn7IYrNTUVM2bMaFBVj6+zsbGBSCSixEbUghIbqZPY2Fh4eHgIHQZ5TVBQEKZNmwZ9fX1cuXIFvcoPYdKA6OnpwdzcnBIbUQuqiiR1QiW2hkVW9ejr64tevXohPDy8wSY1GVtbW6TS7KtEDajERmqNMYb4+HhKbA1EamoqZs6ciaCgoAZb9aiMjY0N0tPThQ6DNEGU2EitpaamUufsBuLKlSuYNm0a9PT0GnTVozI2NjZUFUnUgqoiSa3RzNnCk1U9Dh48GD179sSdO3caVVIDKLER9aESG6k12agj1DlbGKmpqXj33XcRGBiI77//HgsWLIBIJBI6rFqzsbFBVFSU0GGQJogSG6m1uLg4NGvWDMavj3RL1K581WNQUBB69+4tdEh1ZmlpiSxloy4TUk9UFUlqjVpEah5jDBs2bMCQIUPQo0cP3Llzp1EnNQAwMTFBfn6+0GGQJohKbKTW4uLi6PmaBqWlpWHmzJm4ePEivvrqKyxZsqRRVj2+jhIbURdKbKTW4uLi0KFDB6HD0ArBwcGYOnUqdHV18ffffzf6Ulp5lNiIulBVJKm12NhYajiiZrKqR19fX3Tv3h3h4eFNKqkBPLGVlJSguPzkbYSoAJXYSK3IOmdTVaT6pKWl4d1338WFCxeaVNXj60xMTAAA+fn50NfXFzga0pRQYiO1kpaWhsLCQmo8oibBwcGYNm0axGIxgoOD0adPH6FDUpvyic3KykrgaEhTQlWRpFZo5mz1KF/16OnpiTt37jTppAYoJjZCVIlKbKRWqHO26qWlpeG9997D+fPnm3TV4+tMTU0BUGIjqkeJjdRKbGwsrK2t5RclUj+3bt3C5MmTIZFIcOXKFfTt21fokDRGVmLLy8sTOBLS1FBVJKkVGtVfNWRVj/369cMbb7yB8PBwrUpqAFVFEvWhxEZqJTY2lhJbPaWnp2PUqFFYvHgxli9fjr/++gvW1tZCh6VxxsbGEIlElNiIylFVJKmVuLg4tGvXTugwGi1trnp8nY6ODgwNDSmxEZWjEhupFRonsm7KVz126tSpTlWPp0+fhpubG3R1m879qLGxMV69eiV0GKSJaTr/Q4hG0DO22ktPT8d7772Hc+fOYcWKFfj888+ho1Pze8qnT5/ik08+QUxMDJKTk9UYqeaJxWJIJBKhwyBNDCU2UmPp6el49eoVjTpSCyEhIZg8eTJKSkoQFBQELy+vWh9j1apV6Nu3L/7880+0atWqSVXdUWIj6kCJjdSYbOZsKrFVjzGGjRs3YsmSJRg6dCh2796NZs2a1elYO3fuhJGRkYojbBgosRF1oGdspMaoc3bNZGdnY+LEiVi8eDGWLVuGY8eO1TmpAWiySQ0AdHV1UVpaKnQYpImhxEZqLC4uDpaWljAzMxM6lAYrJCQE3bp1w82bNxEUFITVq1dXeJ728OFDjBs3DhYWFjA2NkbPnj1x8uRJ+Pr6QiQSQSQSwc/PT6BPoFlUYiPqQFWRpMaoRWTlylc99u/fH7/++ivs7Owq7BcdHY0+ffrAxMQEhw8fRp8+fRATE4NFixbh7t27MDAwQGFhoQCfQBiU2Ig6UImN1BjNnK1cdnY2Jk2aJK96PHfunNKkBgDLly9HVlYWNmzYgCFDhsDU1BQeHh7Yv39/k2oUUlOU2Ig6UImN1FhcXBxat24tdBgNSmhoKCZPnozi4mIEBgaiX79+Ve5/9uxZAMCwYcMU1tva2qJDhw64f/++2mJtiKRSaa26PhBSE/QXRWqMhtMqI+tw7eXlBVdXV4SGhlab1IqKipCbmwtDQ0Olg0hr45xkEokEYrFY6DBIE0OJjdQYdc7mcnJyMHnyZHnV4/nz5yuteizPwMAAZmZmKCwsVDqifUpKijrCbdCoxEbUgf6iSI1kZGQgPz9f6xNbaGgounXrhmvXruHy5ctKWz1WZcSIEQDKqiRlkpKS8PjxY5XG2hhQYiPqQH9RpEZo5mxg27Zt8PLyQqtWrRAaGgpvb+9aH2P9+vWwtrbGokWLcOHCBeTl5SEyMhKzZ89GixYt1BB1w0aJjagD/UWRGtHmUUdycnIwadIkfPjhh1i2bBkuXLhQ5yTUpk0bXL9+HT169MCECRNgZ2cHf39/LFu2DG3btlX6npMnT8r7t8XHx0Mikch/37FjR30+muDoGRtRB2oVSWokLi4OFhYWMDc3FzoUjQoLC8PkyZORm5uLs2fPwtfXt97HdHNzw9GjR2u8/6hRo8AYq/d5GyIqsRF1oL8oUiPa2HBk27Zt6Nu3L1xcXBAREaGSpEYUFRUVwdDQUOgwSBNDiY3UiDY19Ze1elRF1SOpWkFBASU2onKU2EiNaMtwWrdv38abb76JoKAgnDlzptatHuviwIEDEIlEuHTpEoqKirRmrEjGGIqKipr0IM9EGJTYSI1oQ2KTVT22bNkS4eHhGDJkiEbOO2XKFDDGFJbG3iikJoqKiiCVSimxEZWjxEZqpCkntpycHEyZMgUffvghli5digsXLsDe3l7osJo82WDPlNiIqlGrSFKtzMxM5OXlNckBkG/fvo3JkycjJycHp0+fxtChQ4UOSWsUFBQAoMRGVI9KbKRaTbVz9t69e9GvXz84OzsjPDyckpqGUWIj6kKJjVSrqSW23NxcTJ06FbNmzcKCBQuo6lEgr169AkCJjageVUWSasXFxcHMzAwWFhZCh1Jvd+7cwaRJk5CdnY2zZ89SKU1AWVlZAABLS0uBIyFNDZXYSLWaSsORvXv3wsvLC05OToiIiKCkJrDs7GwAlNiI6lFiI9Vq7DNnv171ePHiRap6bACys7Ohp6dHVZFE5agqklQrNja20Sa28lWPZ86cqTBzNRFOVlZWk6jeJg0PldhItRprVaSs1aOjoyPCw8MpqTUw2dnZVA1J1IISG1EQFBSEyMhI+YN9oPElttzcXEybNg2zZs3Cxx9/jEuXLsHBwUHosMhrsrOzqcRG1IKqIomCtWvX4vLlywAAQ0NDODg4wMzMDMePH0dcXBwcHR3h6OiIli1bws3NDQYGBgJHrCgqKgoTJ05EamoqTp8+jeHDhwsdEqlETk4OJTaiFpTYiIJ+/fohODgYpaWlKCwsxLNnzwAAycnJuHDhAiQSCUpLS2Fvb4/nz59rLC7GGLKysmBlZVXpPnv37kVAQAC6d++OCxcuUCmtgUtLS4O1tbXQYZAmiKoiiYK+ffuitLS0wnqJRIKioiKUlpZCLBZj8eLFGi2t7dy5E2+//TYkEkmFbbm5uZg+fTpmzZoFPz8/XLx4kZJaI5CYmEjTARG1oMRGFPTp06faaVpMTU0xb948DUXEW2UuWrQIQUFBWLNmjcK2qKgo9OnTB+fPn8fp06exYcMG6OnpaSw2UnfJycmws7MTOgzSBFFiIwrMzc3h5uZW6XZdXV0sXrwYpqamGotpzpw5KC4uBgB89dVXOHfuHABe9dijRw80a9YMERER9DytkUlOTqYSG1ELSmykgoEDB1Za6tHX18f8+fM1FsuOHTtw8eJFlJSUAABEIhGmTJmCt99+G7Nnz8Ynn3xCrR4boYKCAuTk5FCJjagFJTZSgZeXl9JnWXp6eliwYEGVDThUKT4+Hp988gkYY/J1UqkU+fn5CA0NxYkTJ/DVV19BV5faQDU2SUlJAECJjagFJTZSgZeXF6RSaYX1IpEICxYs0Fgc77//PoqKiiqsLykpQUJCAq5evaqxWIhqJScnA6DERtSDEhupoFWrVmjevLnCOj09Pfj7+2tsjMUdO3bgwoUL8irI10kkEnzzzTc4fvy4RuIhqpWSkgIAFf7OCFEFSmxEKW9vb4jFYvnvUqkU//rXvzRyblkryPJVkMqIRCK8++678vniSOPx8uVL2NjY0ADIRC0osRGlvL29IRKJAPDS2rvvvgsXFxe1n5cxptAKsjI6OjoQiUTIycnBf//7X7XHRVQrJiYGrVq1EjoM0kTRU3eilJeXl7yjtkQiwdKlSzVy3p07d+LixYtKS2tisVi+vmfPnpgyZQomTJgAR0dHjcRGVOfFixcauVEi2okSG1Gqa9euMDQ0RGFhISZMmFBl3zZViY+Px6effqqQ1PT09CCRSCAWi9GvXz+MHTsWU6ZMoUYHjVxMTAz69+8vdBikiaLE1gQwBsgG48/NBUpLgaIi4NWrsn2ysvh+yhQWAgUFr6/VhatrDzx4cBV9+67AxYuVn9/CApANVmJgABgb899l49uamQHVtchnjGH27NnIzc2Frq4uSktLYWRkhNGjR2PChAkYMWKERjuFE/V68eIFZs6cKXQYpImixKZhmZlARgb/mZUFZGfzBJSfz1/n5fHX+fl8e34+356TwxeJpPLkpXoDAFhi0aLOKjmaLOmJRIBsGi4rK8DEBMjI+AWRkRegr2+Btm3fhofHO+jSxReWlgbIzwfOnOHvMTfn77G25j/LtW8hjcSrV6+QlpZGVZFEbSix1ZFEAqSm8iUpCUhO5q/T0xWT1+s/lZWaDA35xd3CAjA15Rd/U1P+u7U14Oxctk1Pj++rr89fywoxlpY8YRgb8wRSfhtQtl6Z8qWr8s6e9YK5+Qh07gxU0uoepaU80coUFPASYPn12dmAVFq2TSLhSVoq5duysl7h+vVnGDDgMvT0+qOgQIzoaCAsTDHRK2NhoZjorK3LXjdrBtja8sXeHmjenC80lKSwYmJiwBijxiNEbSixvaa4GIiPB+LigJgY/jopiSet5OSy16mp/MIso6/PL5rlL6xOTkDnzpVfeC0tFavxGhpfX98ajepha1vfMxkD+KravbKyeEJ8/Ybh9dfR0fxnejr/d3q9mrVZM8DOTjHh2dryGwgnJ760bAlQS3T1ePHiBQBQiY2ojdYltvR04OlT4OVLIDaWJ6+4OL68fMkTl6xUpa/PL3yyi1+rVkCfPvwiaGcHtGjBX7dowRNVU9PQhqqytORLy5a1e19eHpCQwJNcSgqQmMh/pqby9WFh/KYlPl4xCdra8iTn7MzPKUt8LVsCbdrwvwtSew8fPoSdnR1NMkrUpmFduVQkMxN49qzicv8+v6jJWFkBrVvzC1SXLsD48fy1gwNf7+JCz3CaAlNTwM2NL9XJzOTJLjGR/83IXj98CFy+DLx4UfZc08AAcHTkfyutWwPu7oCHB/3tVOfBgwfo2LGj0GGQJqzRJjbGgOfPgchInrAiI4GoKODx47ILj5ERv7Nu25YnrnfeKfvdyYmetZCKrKz44uGhfLtUyhNddDRfnj7lP0NDgQMHeFUpwEv7bdrw48iWTp2Adu2qbyHa1D148ABvvPGG0GGQJqxR/BdLT+fVRXfv8uR17x7w4EFZgwIXF37hGDoU+OgjnrjatOHJixBV0tHhpTRHR2DAgIrbU1PLkt6jR/zvdP9+XvqTSHjC69CBl+7eeIMnO09Pfjxt8fDhQ0yaNEnoMEgT1uASW24uEBHBjfIcfwAAIABJREFUE5lsefCAl9CsrPgF4c03gRkzeDLr2hWwsRE6akI4WSvMPn0U15eU8NqEqChewxAVBfz2G6/ilEr537anJ+DlxX/27Mmf4zY1qampSEtLo6pIolaCJ7ZHj4ArV4C//wZCQoAnT/h/dHt7oHt3YPJk/rN7d96Ag5DGSE+vrEpy4sSy9Tk5/OYtNJQve/cCa9bwbS4uQI8ePNn5+PAWtg21BW1NPXjwAAAosRG10nhie/yYJ7KgIL4kJPB+WX37AhMmlCUxqkYk2sDcHBg4kC8y6elliS4kBPjqK+CTT3g3EW9vnuQaa6J78OABzM3NacZzolZqT2z5+cC5c8CJE8D582WJzMuLPw8bMIDflVJDDkK4Zs2AYcP4AvAajHv3ym4G167lic7KChg0CBg9Ghg1ir+voYuKikLHjh3lM0cQog5qSWyJiTyRHT8OXLrEny/06UOJjJC60NHhrXq7dAEWLlRMdGfPAv7+fKQXLy9gzBhg7FjegKohCg0NxZtvvil0GKSJU1lFRnY2sGULT2BOTvyOUl8f+Plnnuj+/htYtoxXOVJSI6TuZIlu4UI+hmZqKu9q4OICrF/PuxR06gR8841iv02hSSQSREREwNPTU+hQSBNXr8TGGE9Y773HOzX/61+8E+yxY0BaGvDnn8Ds2aoYcokQUhkzM/58eu9ePoJKYCCvovzuOz5KytixvPbkf9PrCebBgwfIz8+nxEbUrk6J7dUrYONG3h+nf3/edPn77/nzsz17eH0/jbNHiObp6vKGJRs38iHCfv2VDxM2fjxPcl98wW86hRAWFgZDQ0N4VNb7nRAVqVVie/UK+PprPmbismWAry8QHs5bbn3wgfIR4jVtzJgxEIlE+Oqr6gfVlUgkWLZsGdq1awdDQ0OMGDGi0n1DQkIwa9YsuLq6wsjICNbW1ujUqRPeeecdbN68GU+fPpXva2pqCpFIVGHR0dGBra0txo0bh5CQkErPFRMTgzFjxiBHNoxFOadPn4abm1u9xnEMDw/HyJEjYWlpCTMzM/j6+uKff/6psN/SpUtx8ODBSo8ze/ZsGBgYwNXVFQsXLkRhYWGNzq/Oz9evXz+l371IJMKiRYsU9t2yZUul+8qWyv4mahJndd+fuhkY8O4y58/zEVL8/PijARcX/qggNVWz8YSFhaFz587Qq8eziMzMTGzZsgWDBg2CtbU1jIyM0K5dO0yfPh0REREqjJY0aqyG9u5lzMmJMTMzxlauZCwlpabv1Jw9e/YwAAwAW7t2bbX7b926lQFgX375JcvMzFS6j0QiYYsXL2a6urrs3//+N3vw4AErLCxkSUlJ7Pz588zX11d+zpKSEvn77ty5wwCwsWPHytdlZWWxP//8kzVv3pzp6emxCxcuVDjfnTt3mI2NDdu0aZPC+ujoaDZ69GjWuXNnZm5uzsRicU2/FgU3btxgRkZGbPLkySwhIYGlpqayuXPnMl1dXXbu3LkK53R1dWUrV66s9Hg5OTlsy5YtDABbt25dtedX9+fz8vKS/3u8vixcuFBh382bN1e6r2z58ssv6xxnTb4/TcvLY+zHHxmzt2fMwoKxb75hrLhYM+fu27cvCwgIqNcx5syZw3R1ddmPP/7IEhMTWX5+PgsODmbu7u5MLBazo0ePqihaUh8D2UAWwOr3b10PP1Wb2GJjGRs2jDGxmLEPPmAsKUkTcdVefHw8s7KyYjNnzqxxYps6dSoDwHJycirdZ/ny5QwA27Ztm9LtpaWlbMSIETVKbDK//vorA8A8PDwU1mdnZzMnJyfm7++vNNavv/6alZSUMEdHxzpd+CUSCfPw8GD29vbs1atXCp+hffv2zNnZmRUWFiq8Jzw8nIlEInbw4MEqj21sbMyGDh1a5T7q/nyM8cQWEhJSo303b96s9N+HMcYeP37MDAwMWGJiYr3irOn3p2l5eYytXs2YsTFjXbowdueOes9XWlrKTExM2I4dO+p1nDlz5rB58+ZVWB8eHs4AsHbt2tXr+EQ1GnRi+/tvxpo3Z6xDB8auXdNUTHXz1ltvsXnz5rF9+/bVOLENHTq0ygvTgwcPmI6ODvP09KzyONeuXatVYouPj5eXCMqXFFesWMF0dXVZfHx8hfeUT0R1vfAHBgYyAOzjjz+usG316tUMADt8+HCFbRMnTmROTk4Kn+91Dg4O1X5P6v58jNUusV24cIF99913Srd9/PHHbPLkySqJsybfn1CePGHM25sxIyPGfv1VfeeRJZ7w8HC1ncPIyIjp6OgwqVSqtnOQmhE6sVX6jO3iRWDIEN7n7ObNimPfNSS7du3C/fv38d1339XqfRKJpMrt27Ztg1QqxcTyYyAp0adPHzDGavxciJWbRlvWUZUxhh07dqBXr15KR2UwUkFrnMuXLwMAunfvXmGbbN2lS5cqbBs/fjzi4uJw6tSpSo8tEolQWkWzO018vtry9fXFv/71rwrrc3NzsWfPHnz44YcVttUlzpp8f0Jp25a3olywAJg5kz+DU4egoCBYWFigU6dOajl+fn4+CgoK0KlTJ+r8TZQ3HomK4k2EJ03izYTNzTUdVs3FxcXhX//6F3bt2gUzMzOVHjs4OBgA0LlzZ5UeNygoCADg4eEhn2wxIiICycnJ6NKli0rPVd7Dhw8BAE5Kxitz/N/w8o8fP66wrWvXrgCAc+fO1fncmvh8Mvv27UPXrl1hYmICCwsLeHt7Y//+/TV+/y+//IKWLVuif//+KolHFd+fOonFvM/b+vXAxx8DJ0+q/hxXrlzBgAEDIFYySd3Dhw8xbtw4WFhYwNjYGD179sTJkyfh6+srb8Tj5+dX5fEPHToEAFixYoXqgyeNjtLE9v77fBy6nTsb/lh0fn5+mDZtGgYNGlTr9xYXF8PAwKDS7QkJCQCAZioaqygnJwdHjx7Fp59+Cj09Pfz444/ybZGRkQCUJx1VycrKAgCYmJhU2GZqagqAtzp7nSzpyWJUxsDAACUlJZVu18Tnk8nMzMSuXbuQkpKCW7duwdXVFdOnT8eCBQuqfS9jDD/99JPS0lpd1eT7awiWLuWltrlz+SwbqsIYw99//40BSub5iY6ORp8+fRAaGorDhw8jJSUFv/zyCzZs2IC7d+/CwMBAXtqvTHJyMpYuXQo/Pz+aDocAUDKk1j//8KrHkJCGPyHi9u3b8eTJExw5cqRO73/58mWNLrT1qdo4duyY/P0ikQjW1tbw8vLCypUr0aNHD/l+if8bIsJCoD4TsupRZZ/V3NwcIpFIHqMyDg4OuHfvHkpLS5VWyWrq8129elXh9/bt22Pv3r149OgRNm3ahOnTp6NXr16Vvv/MmTNITEzEzJkzVRZTTb6/huKHHwBnZz6HnL+/ao4ZGRmJtLQ0pYlt+fLlyMrKwo4dOzBkyBAAvCZj//79aNWqVbXHTk9Px/Dhw+Hj44MtW7aoJmDS6FUoj125wqe2V/IYpkF5+fIl/v3vf2PXrl1KSyBVycjIwH/+8x/ExMRUeWcuexaUVo8erWPHjgVjDIwxSKVSpKWl4dixYwpJDYC8D1h9+vhUx9LSEgB/HvE62TrZPq/T1dVFQUFBpcf29/dHTk4OPv/8c6XflyY+X1UmTJgAADhx4kSV+23cuBHvvvuuvASrKtV9fw2FtTV/tv6/2nKVkD1fk1XJlnf27FkAwDDZiM//Y2triw4dOlR53Pz8fAwbNgzu7u747bfflFZzEu1UIbGlpzeOIbBOnDiB7Oxs+Pj4KHSold1pr1q1Sr4uOjpa/r5Zs2ahWbNmWLp0KZYsWVJl9ZTsDvPu3bvq/TAADA0NAaDK6rz6kl0o4uLiKmyLj48HALi5uSl9b2lpaZUNJ2bMmIF169bhP//5D2xtbTF8+HCF7Zr4fFWxt7cHAKSkpFS6z+PHj3H+/HmVVkPKVPf9NSTNm/PrgKpcuXIF3t7eFRJPUVERcnNzYWhoqPRGwsrKqtJjlpaWYuLEiXB0dMSePXsoqREFFRKbqyuf7LO4WIhwam7+/PnyklD5Zd++fQCAtWvXyte1LTfU+e7du5GdnY0DBw7ghx9+gH8V9S3+/v7Q1dXF4cOHq4xlyZIl0NHRkTfOqAvZhTc7O7vOx6jOwP9N+hUWFlZhm2zd4MGDK2zLyckBY0weozIrVqzA8uXLsXnzZmRlZcnvxGU08fmqInte2ryK2Wo3btyI/v37w93dXaXnrsn315Dcu8drbVRB9nxNWUMcAwMDmJmZobCwEHl5eRW2V3UT4u/vj6KiIvzxxx8KVd9t27bFjRs3VBM8abQqJLbx4/msvr/9JkQ4mmFubo6JEyeiW7duVSYtNzc3fPHFFwgNDcWuXbuU7vPo0SNs3boVkyZNqrbqpCqyZtDKSlOqMmDAALi7u+Pw4cMKw19JJBIcOHAAzs7OGDlyZIX3yUpzVTXV/vPPP+Hq6go/Pz+lz9E08fl27NihdIBdxhj++OMPAMDo0aOVvjcnJwd79+7F/PnzVR5XTb6/hiIkBLhxQ3GW7/q4c+cOUlJSlN4wAZAPWfb6jVBSUpLSFroAsHr1aty/fx/Hjh2rsvEX0V4VEpujIx/3cfFi4PlzIULSHHNzc6XjFZa3cuVKLF26FB988AGWLl2Kx48fo7i4GPHx8di5cycGDhyIzp07Y+fOnfWKpUuXLmjevLnKxrubMWMGRCIRnpf7R9TR0cHOnTuRkZGB2bNnIykpCenp6Zg/fz6ePHmC7du3y6sMywsPDwcADB06tNLz5ebmwryKfiGq/HwvXryAWCyGSCTC7du3Fbbdvn0b8+fPR3R0NAoLC/Ho0SPMnDkTYWFh+PjjjyttOLJr1y6Ymppi/Pjx9Y7vdTX5/hqCnBxg1ixg8GA+O4AqnDhxAg4ODujWrZvS7evXr4e1tTUWLVqECxcuIC8vD5GRkZg9ezZatGhRYf/du3djzZo1uHnzJszMzCqM7Vl+zFaixZR1287PZ+zNNxlr3ZqxFy/U2D9chfz9/ZWO9Tds2LBK3+Pr61vjES5u3brFZs6cyZydnZmenh4zMzNjvXv3Zhs2bGBFRUUK+5qYmFSIo3379tWeY/ny5ZWOzHHixIlKxzPcvn17hf0HDRrETE1NWWlpaYVtt2/fZiNGjGDm5ubM1NSUDRo0iF29erXSuCZOnMgcHR1ZcRWDCjo6OrKuXbtq5PM9f/6c6ejoMJFIxO7evStfX1hYyA4dOsTGjx/P2rRpwwwMDJiFhQXz8fFh+/fvrzQuqVTK2rZtyz7//PMq469tnDI1+f6Elp3NRyBxcGDs5UvVHbd79+5Kh1Ar79GjR2zcuHHM3NycGRsbs759+7IrV66wwYMHMwMDA4V9R44cWe34ntevX1fdByB1IvTII5UOqZWayseQa96csaAgTcakOSNHjmQikUjoMOSysrKYo6NjtReC6mRmZjIjIyPm5+dX75hkYx3+/vvvVe5nZ2fHevfuXeU+qvp8jUlNvz8hPXjAWMeOfGDk+/dVd9yEhAQmEonYyZMn6/R+ZYmNNA5CJ7ZKu1/b2ABXrwLe3rxaYtEiQEkr8UbNyckJjDEkJycLHQoA3sfrxIkTOHz4MH766ac6HYMxhgULFsDc3Bxr166tVzzPnj3D22+/jWXLlmHKlCmV7ldSUoKMjIxq+wSq4vM1JjX9/oRSWsonI33zTT7lVGgooMp2MydPnoShoaG80RIhmlLluCKmpsDhw3za+V9/5bNjb9sm/Ey8qiJrkv7NN98gXZXtm+uhW7duCA0NxZkzZ6p9/qdMcnIynj17hkuXLil9RlEbW7duxbp167Bu3bpK98nOzsYPP/yAkpKSCk38lanv52tMavL9CeXiRcDTE1i+nI8TeeUKoGQIz3qRDYtlbGys2gMTUp2alu3S0hj77DPGDAz4s7cff2SsoEB9ZUlN+fbbb1nHjh2ZgYEBGz58uNDhNCrvvfce09PTY23btmWrVq1S+jyPNBxSKWPHjzPWuzdjAGOjRvHR/dXh1atXzMTEpNLpnqry+++/V3huNmfOHDVESdRF6KpIEWPlhpqvgSdP+ICpv/4KNGvGW1HNng20a6eGrEsIqbekJGDvXmDXLuDxY2D0aGDFCqBnT/Wd89SpUxg9ejRiY2PlY2US7TEIg9ABHfAz1DRdRNV+rvUQx+3a8cGRo6P5VPP79gHt2wM+Pvx1Ixg1iJAmr7QUOHECGDcOaNmS34wOGQLcvQscO6bepAYA+/fvh5eXFyU1Iog6j93v7Ax8+SXw4gVw6hRvbOLnB9jbA9OnA3/8wfvFEEI0o7AQOH2a90N1duZJLS8P2L0bSEgANm0CNNFHPD8/H8ePH8f06dPVfzJClKj3+P1iMTBiBF9SU4Hff+d3hNOn8ylvfHz43G5jxgAamLGEEK2Sns5vLI8fB86d4y2XPT2Bjz4Cpk3jQ+Rp2pEjR1BcXFztBL2EqEutn7HVVEYGv3s8fhw4e5bfOb7xBk90Pj5A//78GR0hpOby8ng3nCtX+Aj8sumlfHx4CW30aD56kJCGDRsGY2NjHD16VNhAiGCEfsamthnXrK2BGTP4UlTEp5+/cIH/Z/zpJ4AxXi0iS3Te3rw6kxBS5vVEFhrKn5916AAMGAB8+ikwfDig4snj6ywxMRGXLl3CgQMHhA6FaDGNTCVqYMD/88m6OeXl8YFWL17k/2k3bwZKSvjzOU/PssXLiydIQrRBSQlvtRgWVraEhPCZNlq35v8fZs/m/49athQ6WuV+//13mJiYKB1MmxBNEWSObFNTwNeXLwCQnc1n7g4J4XekW7fyJso6OvzOtHt3oEcPoHNnXsqjZEcau9xc4MED3kpRlsDu3uXJzdKS39h5e/MSWd++QD372mvMb7/9hokTJzaauedI06S2Z2z1FRvLk1xISFnCy8ri21q04AnOw4MvnTrxoYCUzJZCiKAKCoCoKOD+fcUlJoZXx5uYAF278hs32Q1cu3aASCR05LUXGhqKHj16IDg4GN7e3kKHQwQk9DO2BpvYlImN5ReJe/f43a7sp2yOQmdn3qeubVugTRvFn3QDSdSluJh3e4mOVlweP+ZTP0mlgL4+0LEjvwF74w3+s1Mn3mpRp86dbhqWmTNnIjIyEnfu3BE6FCIwoRObIFWRdeXszJdhw8rWMcYvKrI74cePebI7cQL43/yOAHhLsbZty5Jdy5aAiwvvguDoCOjpafzjkEZCIuFV4y9fAnFx/Gd0NPD0Kf/58iXfBwBsbcv+xt57ryyBtWnDWy82VSkpKTh06BB+/lmQCxkhChr9fzWRiN/1uroCo0YpbisoKLv4lP95+TK/QJWU8P10dAA7O57snJz4Uj7ptWjBFxrLtekpLOT9LxMSgMREnqRiY/nfR2ws/z0xsWzgb7GYN3KS1QQMHKhYM1DFXKtN2s8//wwzMzNMnTpV6FAIafyJrSpGRvxuWdloC1Ipvwt//SIWFwfcugUcOsS3S6Vl7zEx4Rc1Ozt+Z25vDzRvzhcHB76uWTPAyoov+vqa+6yEk0iAzEzejzIjgyet5GSenFJT+b9pUhJ/nZjIGy6VZ2dXdnPj6ckHF3By4jc9zs7837kpl7zqoqSkBDt27MC8efOo0QhpELT2v6iODr9IOTgAvXop36ekpOyimJxcdmefksJfR0Xx/kXJyXwEiNeZmvIEZ21dluxef21qyhOmmRm/2zc25r9bWvKf2pQcJRI+DFtuLh9B49UrnqRkr3NzeQOijIyy5FX+Z2ZmxUQF8O9WduNhZwd06cJfy0ristcODrxrCqmdP/74A8nJyfjggw+EDoUQAFqc2GpCT6/s7r06xcU82Sm72JZ/HRfHG73I1uXl8Q7sldHV5RdmCwue9IyMeFympny7pSWvjjU25hdl2f7lt8lUlSgr2yZLNsoo25aVxZ97vnrFP1dpKU9IAE86UmnZtuJinrSysvjPmnwPlpZlNwfW1rz6r7KbB2trnrSoEKFemzZtwttvvw1nZ2ehQyEEACU2ldHX58/j6jKckezin5NTVjrJyuJJLz+/4sW/qIjvw1hZF4iUFF7ClCWL8ttkeNKRQCJ5CLHYHYDotW3K47OwqNhyTyJ5hNLSC2je/COFbebm/DmUoSFPKDo6Zd0wnJx4gjIw4In49aRtYsJfm5mV/W5lpX0l18YkODgYN2/exHfffSd0KITIUWJrAHR1y0ob6hYREYmuXbsiIiICnTt3rvNxjhyJxKRJC3H58ki4CjHSLmkQ1qxZAx8fH/Tr10/oUAiRayI9aEhNXb9+HWZmZvDw8KjXccaOHQt7e3ts27ZNRZGRxubatWu4fPkyvvjiC6FDIUQBJTYtc+PGDfTo0QNisbhex9HV1YWfnx927NiBwsJCFUVHGpPPP/8cXl5e8PHxEToUQhRQYtMyN27cQO/evVVyLH9/f2RnZ+PPP/9UyfFI4/H333/j0qVLWLt2rdChEFIBJTYtkpmZicePH6NXZf0basne3h6jR4/G5s2bVXI80jgwxrB06VIMHDgQAwcOFDocQiqgxiNa5O7du2CMwdPTU2XHDAgIwJAhQ3D37t16NUYhjcehQ4dw48YN3Lp1S+hQCFGKSmxaJDIyEhYWFnBU4RTLgwcPhpubG7Zs2aKyY5KGq6SkBCtXrsT06dNVeoNEiCpRYtMiUVFR6KRsfLF6EIlE8Pf3x759+5BTWU9u0mRs3rwZsbGx9GyNNGiU2LTI/fv3693MX5n3338fUqkU+/fvV/mxScORkpKC1atXY+HChXBxcRE6HEIqRYlNi0RFRaklsVlaWmLSpEn4v//7P5UfmzQcn332GUxMTLBy5UqhQyGkSpTYtERGRgZSU1PRoUMHtRw/ICAA9+/fxz///KOW4xNhXbt2DXv27MEPP/wAU9lApYQ0UJTYtERsbCwAqK0KqWfPnujevTs1/W+CJBIJ5s+fD19fX0ycOFHocAipFiU2LSFLbKpsEfm6Dz74AIcOHUJKSorazkE077///S8ePHiATZs2CR0KITVCiU1LxMXFwcrKSq3VSNOmTYOpqSl++eUXtZ2DaNbz58+xevVqrFq1Cu3btxc6HEJqhBKbloiLi4NTTSaWqwcjIyPMnDkTmzdvhkQiUeu5iPoxxjB37ly0adMGS5YsETocQmqMEpuWiI+PV3tiA3h15MuXL3Hu3Dm1n4uo19atW3HlyhXs3LkTenp6QodDSI1RYtMSmZmZsLa2Vvt5OnToAB8fH2pE0sg9f/4cn332GT799FN0795d6HAIqRVKbFoiPz8fJiYmGjlXQEAATp8+jRcvXmjkfES1pFIpZs+eDWdnZ6xZs0bocAipNUpsWiI/Px/GxsYaOdf48eNhb2+P7du3a+R8RLW+/vpr3LhxA/v374ehoaHQ4RBSa5TYtIQmS2y6urp4//33sX37dhQVFWnknEQ1bt++jS+//BLr16+n2RpIo0WJTUtoMrEBvBFJVlYWjh49qrFzkvrJy8vDtGnT0K9fPyxatEjocAipM0psWqKoqAgGBgYaO5+DgwNGjhxJjUgakQ8//BAZGRnYu3cvdHTo0kAaL/rr1RL6+vooLi7W6DkDAgIQHByMe/fuafS8pPZ27NiB3377Dfv27VPr6DSEaAIlNi1hZGSEwsJCjZ5zyJAhcHNzw9atWzV6XlI7kZGRWLhwIZYuXYphw4YJHQ4h9UaJTUsYGRmhoKBAZccLDw/HyJEjYWlpCTMzM/j6+lYY2V8kEmHevHnYu3cvcnNzVXbu8k6fPg03Nzfo6uqq5fhNXVZWFiZMmABPT09q2k+aDEpsWkKVie3mzZvo27cvzMzM8ODBAzx//hytW7eGj48Pzp8/r7Dv+++/D4lEovJJSJ8+fYoxY8Zg2bJlSE5OVumxtYVUKsWMGTOQk5OD33//nW4OSJNBiU1LqKoqUiqVYs6cObC0tMQvv/wCe3t72NjYYPPmzWjTpg38/PwUmvhbWVlh4sSJ+Pnnn+t97vJWrVqFvn37IiwsDGZmZio9trZYsmQJLl26hL/++oueq5EmhRKblrC2tkZqamq9jxMcHIz79+9jwoQJMDIykq8Xi8WYOnUqYmNjcfLkSYX3BAQE4O7du7h+/Xq9zy+zc+dOLF26lEoZdbRv3z58//33+Pnnn9GzZ0+hwyFEpSixaYlWrVqpZIiry5cvA4DS8QNl6y5duqSwvlevXvD09FRp0//ySZXUzu3bt+Hv748lS5Zg9uzZQodDiMpRYtMSrVq1wvPnz5Vue/jwIcaNGwcLCwsYGxujZ8+eOHnyJHx9fSESiSASieDn5yffF4DSmQJk1VmPHz+usM3f3x9//PFHpZOQ1iYGUndJSUkYO3Ys+vfvj/Xr1wsdDiFqQfU4WsLV1RXZ2dnIzMyElZWVfH10dDT69OkDExMTHD58GH369EFMTAwWLVqEu3fvwsDAQOHZXFZWFgAoHcVENolpZmZmhW3Tp0/HZ599hj179uDf//63wrbaxkDqprCwEOPGjYOJiQkOHDgAsVgsdEiEqAWV2LREq1atAKBCdeTy5cuRlZWFDRs2YMiQITA1NYWHhwf279+P/Pz8Wp2DMQaAN/N/nbGxMWbMmIEtW7ZAKpWqLQZSOX9/fzx69AjHjh2DpaWl0OEQojaU2LSEi4sLxGIxoqOjFdafPXsWACp0zLW1tUWHDh0qHEd2QVSWcGTrKrtoBgQE4Pnz5xW6BNQ2BlJ7X3zxBX777Tf8/vvvaN++vdDhEKJWlNi0hIGBAdq3b487d+7I1xUVFSE3NxeGhobyasTyyldZysgSTVxcXIVt8fHxAAA3NzelMXTs2BEDBgxQaERSlxhI7WzZsgVr167F1q1bMXz4cKHDIUTtKLFpkR49eiAkJET+u4GBAczMzFBYWIi8vLwK+ytr6DFw4EAAQFhYWIVtsnWDBw+uNIaAgACcOnVKXiValxhIzf3111/46KOPsG7dOsyZM0focAjRCEqpSHkrAAAgAElEQVRsWqRXr164desWSktL5etGjBgBoKw6UCYpKUlp68YBAwbA3d0dhw8fVmjQIZFIcODAATg7O2PkyJGVxjB+/HjY2dlhx44ddY6B1ExgYCCmTJkCf39/LFu2TOhwCNEcRrTGw4cPGQB27do1+bro6GhmbW3NHB0d2fnz51lubi67d+8eGz58OHNxcWEGBgYVjnP9+nVmaGjIpkyZwhITE1laWhrz9/dnurq67OzZs9XGsXLlStaiRQtWVFRU5xjKc3R0ZGKxuJbfRtMWERHBLC0t2ZQpU5hEIhE6HKJlBrKBLIAFCHX6n6jEpkXat2+Pli1b4sKFC/J1bdq0wfXr19GjRw9MmDABdnZ28jv8tm3bKj1O7969ce3aNWRnZ6N9+/Zo1aoVnjx5gqCgoBqNDj9v3jykpqbir7/+qnMMJ0+elPdvi4+Ph0Qikf9evjSojZ4+fYphw4bhzTffxO7du2luNaJ1RIz9r4020QoffPABQkJClD4je52vry+uXr2qlj5kY8eORU5ODgIDAwWLoSlKSUlBv379YGFhgcDAQKUNcghRt0EYhA7ogJ+h2jFia+hnupXTMhMmTMDt27fx5MkTQeMICAhAUFAQIiMjBY2jKUlPT8eQIUMgEolw+vRpSmpEa1Fi0zI+Pj5o3rw5Dh48KGgcw4YNQ7t27bBt2zZB42gq0tPT4evri5ycHJw/fx62trZCh0SIYCixaRldXV3MmDED27dvh0QiUbrPgQMHIBKJcOnSJRQVFallnEaRSIS5c+di9+7dSich1UQMTUVWVhaGDx+OjIwMXLp0CS4uLkKHRIig6BmbFnr69Cnc3Nxw7NgxjBo1SrA40tPT4eTkhI0bN2Lu3LmCxdGYZWVlYejQoUhKSkJQUBBat24tdEiE0DM2onlt2rTBkCFD8N133wkaR7NmzTBx4kT89NNPgsbRWGVnZ8uTWmBgICU1Qv6HEpuWWrVqFa5cuYKgoCBB4wgICEBERARu3LghaByNzetJrU2bNkKHREiDQYlNS3l5eWHw4MFYuXKloHH06dMHb775pkonIW3qZEktISGBkhohSlBi02KrV6/GP//8U21fMnWbN28eDh48iNTUVEHjaAzS0tLg6+tLSY2QKlBi02L9+vXD0KFDsXjx4kpbSGrC9OnTYWhoiD179ggWQ2MQFxeH/v37Iz09HUFBQZWOykKItqPEpuU2bdqE+/fvY+vWrYLFYGpqWukkpIR79uwZfHx8AADBwcFUUiOkCpTYtJybmxsWLVqEZcuWITExUbA45s+fj2fPnuHixYuCxdBQRUZGwtvbG9bW1ggODoaTk5PQIRHSoFFiI1i1ahUsLS3x2WefCRZDx44d4e3tTY1IXhMcHIx+/fqhffv2uHTpEmxsbIQOiZAGjxIbgYmJCTZt2oRff/0VR48eFSyOgIAAnDhxAjExMYLF0JCcOnUKw4cPh4+PD06fPg0zMzOhQyKkUaDERgAAY8aMwZw5czBv3jwkJCQIEsPbb78NGxsb7Ny5U74uMTER3377LT755BNBYhLKr7/+ivHjx2P69Ok4cuQIDA0NhQ6JkEaDEhuR+/HHH2FtbY1Zs2ZBiJHW9PX1MWfOHGzfvh1nzpzBuHHj4OzsjKVLlyI8PFzj8Qhl/fr1ePfdd/HJJ59g27ZtEIvFQodESKNCiY3ImZiYYO/evQgMDMR//vOfCtvPnz+PFStWqO38OTk5MDU1RXp6Ot566y2cOnVK3g0hOztbbefVpJKSkkq3lZaWIiAgAJ9//jk2btyIb7/9FiKRSIPREdI0UGIjCnr16oVvv/0Wy5cvx7lz5+Trz5w5g1GjRuGHH35Aenq6Ss95+/ZtzJs3D3Z2dvj8889RWloKAPKfAB/st7HLyclBnz59lFb15ubmYsyYMdi3bx+OHj2Kjz76SIAICWkaKLGRCj799FO89957mDp1Kp48eYJTp05h7NixkEgkKC0txcaNG1V2rl27dsHT0xO//PILCgsLUVpaqrQaVNnUNo3NkiVLEBYWhvHjx6O4uFi+Pj4+Hv3790d4eDiuXLmC0aNHCxglIY0fTVtDlCooKED//v1RWFiIR48eQSKRyDtPm5ubIy4uTiWt9BhjmDFjBv744w+FEtrrDA0NUVBQUO/zCeX69evw8vICYwxisRhz587F5s2bcffuXYwcORKWlpY4deoUWrZsKXSohNQbTVtDGiQjIyN89NFHePjwoUJSA4BXr16pbKQSkUiE3bt3Y8CAAdDV1a10v6KioioTX0NWWlqKuXPnyhuBSCQSbNmyBZ9++in69u0Ld3d3/PPPP5TUCFERSmxEqZMnT2Lu3LmQSqUVhrkqLS3FN998o7ISlJ6eHo4ePQp3d3fo6ekp3Ycx1mirI7/77js8ePCgQmLeuHEjRo0ahVOnTsHc3Fyg6AhpeiixkQoOHz6McePGobS0tNKxG7OysrB3716VndPMzAwXL16Eo6NjpcktJydHZefTlJiYGKxZs6bS7/HixYtITk7WcFSENG2U2IiCEydOYMqUKZBIJFX2ZZNKpVi3bp1KqwdtbW1x8eJFmJmZKe271RgTW0BAQKUzJ0gkEuTk5GD8+PEoKirScGSENF2U2IiCIUOGYOPGjbC3t4eOjg50dJT/iTDGEB8fj4MHD6r0/G3atMHZs2ehr69foQ9XY+vLduDAAZw5c6bKvmslJSW4ffs2Fi5cqMHICGnaKLERBYaGhvjwww8RExODX375BS4uLhCJRJUmuKqq2eqqR48eOHz4cIVzNqYSW1ZWFj766KNqO1jr6elBIpHgzz//xP379zUUHSFNGyU2opSenh7effddREdH4+DBg3B1da2Q4KRSKaKjo3Hy5EmVn/+tt97C7t275YlBJBI1qsT22WefITs7W2l1rlgsho6ODvT19TFmzBgcP34c8fHx8PDwECBSQpoeSmykSjo6Opg4cSIeP36MY8eOwd3dHQDkz8B0dHSwZs0atZx7xowZWL16tTy5NZaqyJs3b2L79u0Kzx/FYjHEYjF0dXUxdOhQ/PLLL8jIyMDhw4cxevToShvMEEJqr/KOQ4SUo6Ojg9GjR2PUqFH466+/sHr1aty9exeMMdy+fRuBgYEYOHBgnY5dXFyM/Px8SKVSefLKzs6GVCrFyJEjERoaihMnTiAsLKzCRKQFBQUoLCys9NiWlpaVVgdaWFjIS6DGxsYwMDCAgYEBjI2NIRaL69QEv6SkBLNmzQIAeQlXKpWib9++eO+99/DOO+/A0tKy1sclhNQcjTxCai09PR3p6ek4ceIEtm7diidPnqBjx47w9/dHfn4+cnJykJ2djby8PPmSmZmJ/Px8FBcXIzc3F6WlpdUmpYZClhzNzMygq6sLc3NzmJqawtTUFGZmZrC0tISJiQlMTU0REhIiH2OzVatWeOutt/DOO++gffv2sLa2hpGRkcCfhhD1E3rkEUpsWq6oqAjJyclISEhASkoKEhISkJqaioyMDKSnpyMjI0PhdXp6eqXPjaysrGBlZQVzc/MKF38LCwuYmprKS0SVlY6srKwAQJ5EAD6djVgsxunTp/H2228rnFdPTw+mpqZKP1tpaWmlnbplTe1l8vLyUFJSIk+2JSUlyMvLU1qKzMrKQl5eHvLz8xWSdkZGBp4/fw4dHR2UlpYq7QphbGwMa2trNGvWTP6z/NK8eXPY29ujRYsWsLOzoxmzSaNEiY2oBWMMiYmJiImJQUxMDOLi4uTJKz4+HikpKUhMTERmZqbC+6ysrNC8eXOFC6+1tbXCaxsbG/lrCwsLWFhYAOAtAbW5mi0nJ0eh+rK4uBjZ2dkKNwWv/5QtGRkZSEtLQ0pKisIAyfr6+mjevDkcHR0Vkp6DgwNcXFzQsmVLtGrVCsbGxkJ8ZEKUosRG6oQxhri4OERHR8uTl2x5+fIlXr58Kb9A6urqokWLFnBycqpQInBwcFC4cNJMzcJLS0tDcnIyEhMTkZSUhOTkZIWbkaSkJMTHxys0prG1tUXLli0Vkp2LiwtatWoFNzc3SnxEo4RObNR4pIHLzMzEs2fP5Mv9+/cRFRWFR48eIS8vDwBgYGAAR0dHtG7dGo6OjujRowdat24tX1q2bFnlAMOkYbGxsYGNjU21zf8LCgqQmJio8PeRkJCAyMhIHD9+HC9evJD3MbSyskLr1q3h7u4ODw8P+d+Gu7s7PfcjTQ6V2BqI3Nxc3Lt3D/fu3UNERATu3r2LBw8eICMjAwDvOO3m5oZ27drJF9nvdnZ2AkdPGqLCwkI8f/4cjx8/xpMnTxR+yiY71dXVhaurKzp37ow33ngDnTt3RpcuXeT9FgmpC6FLbJTYBBAbG4uQkBBERETIE9nz58/BGIOFhYX8AtOpUyd5EmvZsiVdaIjK5OXlyRPdw4cP5X+Hz549g1QqhZmZGTp16iRPdF27dkW3bt2oqprUCCW2Ji4/Px937txBWFgYwsLCcPXqVTx//hwAYG9vD09PT3h6esLDwwPu7u7o2LFjpcNXEaJuxcXFePLkCcLCwhAVFYX79+/j1q1bSElJga6uLtzc3NCvXz94eXnB09MT7u7udMNFKqDE1sSkpaUhMDAQly9fxvXr1xEZGQmJRAIHBwf06tULvXv3Rq9evdC9e3eYmJgIHS4hNRIdHY2bN2/Klzt37qCkpAQ2Njbo1asXvL294evri27dutGNGaHE1ti9evUKV69exaVLl3Dx4kWEh4dDJBKhR48e6Nu3L3r37o3evXvD2dlZ6FAJUZnCwkLcvn0bN2/exI0bN3DlyhUkJyejWbNmGDhwIHx9fTF48GC0bdtW6FCJACixNUIJCQk4evQojh49iqtXr6KoqAgdO3bE4MGD4evrCx8fH3nfLkK0AWMM9+7dk9/gBQcHIy8vT2H0lQEDBiidZ480PZTYGomYmBj8+eefOHLkCK5fvw4TExO89dZbGDFiBHx9feHo6Ch0iIQ0GCUlJbhx4wYuXLiAY8eO4e7du7C1tcW4cePwzjvvYNCgQTTwcxNGia0By8/Px/79+7Fjxw6EhITA0tISo0ePxjvvvIOhQ4dSCzFCaujJkyc4cuQIjhw5grCwMFhaWmLSpEn44IMP0LVrV6HDIypGia0BioqKwubNm7Fv3z4UFRVh0qRJmDZtGt1lEqICMTExOHLkCHbu3ImoqCj06dMHH3zwASZNmkQ3i02E0ImNmi+VI5t6xcPDA2fPnsXKlSsRFxeHPXv2YNiwYZTUCFEBFxcXfPrpp7h//z4CAwPh7OwMPz8/ODk5Yfny5UhLSxM6RNLIUWIDEBERgbfeeguDBg2Cvr4+zp49i0ePHmHx4sVo1qyZRmPp168fRCKR0mXRokVVvlcikWDZsmVo164dDA0NMWLECPm27777Tn4cJycndX+MRiUmJgZjxoypMEN3eHg4Ro4cCUtLS5iZmcHX1xf//PNPnc5x+vRpuLm51Wlos8zMTGzZsgWDBg2ST33Trl07TJ8+HRERERX2X7p0KQ4ePFjp8WbPng0DAwO4urpi4cKFgk4d5OPjg4MHD+Lly5dYtGgRduzYAVdXV6xcuVI+ZBwhtca0WGJiIps5cybT0dFhPXr0YJcuXRI6JObl5cUAKF0WLlxY5Xu3bt3KALAvv/ySZWZmKt2nS5cuzNHRUR2hq0Rubi5r27YtGzlypEbOd+fOHWZjY8M2bdqksP7GjRvMyMiITZ48mSUkJLDU1FQ2d+5cpqury86dO1fj40dHR7PRo0ezzp07M3NzcyYWi2sd45w5c5iuri778ccfWWJiIsvPz2fBwcHM3d2dicVidvTo0QrndHV1ZStXrqz0mDk5OWzLli0MAFu3bl2tY1KXvLw89u233zIrKyvm4ODA9u/fL3RIpA4GsoEsgAUIdfqftDaxHTlyhNnY2LDWrVuzP/74g0mlUqFDYozxxBYSElKn906dOpUBYDk5OZXu09ATW05ODmvdujUbMWKE2s+VnZ3NnJycmL+/v8J6iUTCPDw8mL29PXv16pV8fWlpKWvfvj1zdnZmhYWFNTrH1KlT2ddff81KSkqYo6NjnRPbvHnzKqwPDw9nAFi7du2UbhOJROzgwYNVHtvY2JgNHTq01jGpW2pqKps3bx4TiURs4sSJLCMjQ+iQSC1QYhPAl19+yUQiEfPz82O5ublCh6OgPolt6NCh1V44G3pi06QVK1YwXV1dFh8fr7A+MDCQAWAff/xxhfesXr2aAWCHDx+u0TnKJ8a6JraqGBkZMR0dHaU3ZhMnTmROTk6spKSk0vc7ODgwT09PlcakShcuXGCOjo6sffv2LDo6WuhwSA0Jndi07hnb8uXLsWbNGmzatAnbt2+vdPblxkgikQgdQqPBGMOOHTvQq1cvODg4KGy7fPkyAKB79+4V3idbd+nSpRqdR51TwuTn56OgoACdOnVSOl7j+PHjERcXh1OnTlV6DJFIpHSm74bC19cXoaGhMDc3R//+/fHixQuhQyKNgFYltt9++w3ffPMNdu3ahfnz5wsdTqX27duHrl27wsTEBBYWFvD29sb+/ftVeo6HDx9i5MiRsLCwgLGxMQYOHFihYURpaSkOHjyIIUOGoEWLFjAyMsIbb7yBDRs2yOf5AoC//vpLoZHLo0ePMGnSJDRr1ky+bseOHbXe5/VGDampqViwYAFatWoFfX192Nra4u2330Z4eHitYklLS0NERASSk5PRpUsXpd8NAKWNbGQd8R8/flz3L19FDh06BABYsWKF0u2y/mHnzp3TWEzq0KJFC1y8eBHNmzfHqFGjUFRUJHRIpKETqqyoaVlZWczGxoYtWLBA6FCq5OXlxWbOnMnCwsJYXl4ee/jwIZs5c2alVWPleXt7M2Nj4yr36dKlC7OwsGADBw5kV69eZbm5uSwkJIR17tyZ6evrs6CgIPm+J06cYADY+vXrWUZGBktNTWUbN25kOjo6bPHixRWOPXbsWAaADRgwgAUGBrL8/Hx248YNJhaLWWpqaq33KSgokB87ISGBubi4MDs7O3bq1CmWm5vLIiMj2YABA5ihoSG7du1arWLZt2+f/LO9bsiQIQwAu3HjRoVtT548YQDYm2++WeX3rIwqqyKTkpKYnZ0d8/Pzq3Sf7OxsBoB5e3tXuk/r1q2Zu7u7SmJStxcvXjAzMzP21VdfCR0KqYbQVZFak9g2b97MTExMWFZWltCh1EnPnj0rvdjKuLi4MDc3tyqP06VLFwaAXb9+/f/Zu++wps42DsC/sGcYygygKIKistyrKuBAPledVSsOLFp3ra2ztba2WqwWFRW11lUnllq3xdGKFVRQ3CKiokxZYcgKeb8/ThOJCRAg4QTy3td1roQznxOS85zxDonxd+/eJQCIu7u7eNzJkydJv379pNYxadIkoq2tTfh8vsR4UTI5c+ZMlduvzTyVE1tAQAABQH777TeJedPS0oiurq7Uc6KatvPjjz8SACQ0NFRqWnWJLSEhgQCo03MpRSW2rKws4uHhQcaNG0cEAkG183I4HOLk5FTl9N69exMTE5Nqn8OpkhUrVhAej1fjflPsYjuxqc2tyKioKHh7ezfaxolHjx4NADh58qTUtJycHAQHB+Ply5f49NNPa1yXnp4eunXrJjGuY8eOsLW1RXx8PNLS0gAA//vf/3D58mWp5d3d3VFeXo4HDx7IXH/Xrl1rjEGeeSr7448/oKGhgf/9738S462trdG+fXvExsbi9evXcm9HdJtTVqV7U1NTAMwzrPeJxonmaWhFRUUYNGgQXF1d8dtvv9XYqLCWlhaKi4urnB4UFIT8/Hx89dVXjaJi9MiRI5GSkoKkpCS2Q6FUmNokttzc3AavbK1INjY2AIDMzEyJ8VOmTEGzZs2wZMkSfPHFF5g3b16N6xI9b3qfpaWlxDb4fD6++uordOzYEWZmZuJnVIsXLwbAdNkjizz9zNWmL7rS0lLw+XwIhUKYmJhIVVyPi4sDwLRHKO92RE03lZeXS01r27YtAMhMlCkpKQAAZ2dnueNXFIFAgDFjxoDH42Hv3r1ytZQvEAiqLcAyadIkrFmzBsHBwbCwsMDgwYMVGbLCNW/eHABzMkdRVVGbxObg4CAuFNAYpaamAniXfET27NkDPp+Pw4cPY8OGDQgKCqpxXXw+X+Z4UUITbWPo0KH49ttvMWPGDCQkJEAoFIIQgo0bNwJgShY2BF1dXZiamkJLSwvl5eUghMgc+vfvL/c6RScKsj4L0XpiY2OlponG+fj41GVX6iUoKAilpaU4evSoRAsmTk5OiI6Olpo/Pz8fhBDxvsqyfPlyLFu2DNu2bUNeXh7OnTunlNgV5dGjRwCYZrkoqipqk9hGjhyJmJgYmU0QqYpdu3ahU6dOUuMJITh69CgAJtm8j8vlYsyYMfD09ER4eHiN2yksLJT6HO7du4fU1FS4u7vDxsYGFRUVuHbtGqytrTFv3jxYWFiIr/Kqu7WlLB9++CEEAoHMJq3WrVsHBweHWhVb79ChAwDZV2V9+/aFq6srwsPDJUpmVlRU4PDhw7C3t4e/v38d9qLuVq1ahQcPHuDEiRPQ1dWVaxnR1aVoX2X5/fff4ejoiMDAwEZxmz4sLAw9evSAtbU126FQKkxtEpuvry+6d++OGTNmqHRx4bi4OMyePRuJiYkoKSnBkydP8PHHHyM2NhZz586VejZWGZfLlWrvUBZDQ0PMmTMHMTExKCoqwq1btzBp0iTo6OggJCQEAKCpqYl+/fohPT0dwcHByMrKQnFxMS5fvozt27crbH/l9cMPP6B169aYNm0azp49Cz6fj5ycHISFhWH16tVYv359rdphdHd3h6WlpcwTHQ0NDfzyyy/IycnB1KlTkZ6ejuzsbMyePRtPnz7Fzp07pVqhnzRpEjgcDp4/f16v/ZS1nj179uCbb75BTEwMjI2NpW7FPnv2TOa6RNUgBg4cWOX2CgoKwOVy6xVzQ/n9998RERGBlStXsh0KperYKrbChkePHhFTU1MyevRoUlZWxnY4UkpKSsixY8fIyJEjSevWrYmuri4xMTEh/fr1k6vNPF9f3ypL3QUHB4vbnOTxeOTGjRukf//+xMjIiOjr65O+ffuSqKgoiWXevHlDgoKCiL29PdHW1iZWVlZkypQpZMmSJeJ1derUiVy/fl1m25aVyTNPRESE1PSJEyeKp2dnZ5PPPvuMtGrVimhraxMLCwsycOBA8tdff9VqOyLLli2T2fKISFxcHPHz8yNcLpcYGRkRb29vqc9IxNvbmxgZGUmV1hNVmZA17Ny5U671+Pv7V7kO0fB+KVdCmJZHeDxetd91Ho9HPDw8qpyuKqKiooiBgQGZOXMm26FQcmC7VKRaJTZCCPnnn3+IkZER8fX1bXLtz/n7+xMOh8N2GI1GXl4e4fF4Um1F1lZubi7R19evtk5ZQ66HkHdtRR46dKja+aysrEj37t3rvT1lOnz4MNHX1ycffvhho6mWoO7YTmxqcytSpE+fPrh69SoeP34MNzc3REZGsh2SwtjZ2YEQgoyMDLZDaRRMTExw8uRJhIeHIzQ0tE7rIIRg3rx54HK5+Pbbb+sci6LWAwBJSUn48MMPsXTpUowfP77K+crLy5GTk6Oy3RgVFBQgMDAQ48ePR1BQkFShGYqqitolNoBpaujevXvo27cvBgwYgAEDBuDu3btsh1VvoqLaa9euRXZ2NsvRNA6enp64desWzp49K9fzyfdlZGQgKSkJFy9erFeBBkWtB2AKWKxZswZr1qypch4+n48NGzagvLxc5Yr4E0Jw7NgxdOjQAX/++Sd+//13bNy4Ua7qDRQFQL2escny119/EQ8PD6KhoUE+/vjjKp+3NBbr1q0j7dq1I7q6umTw4MFsh0OpoICAAKKtrU2cnJzIypUrVaoVj7/++ot07txZ/HvMyMhgOySqDti+FckhpIEqI6kwoVCI/fv346uvvsKbN28wfvx4zJo1C126dGE7NIpq8vLz83HgwAFs374d9+/fx/Dhw/HNN9/Azc2N7dCoOvKGN9qiLbZiKxub36qWtyLfp6GhgYCAADx58gQbNmxAbGwsunbtii5duuCXX36psoUNiqLqLj4+HjNnzgSPx8PixYvRpUsXxMXFISIigiY1ql7oFVsVrl27hu3bt+PYsWPQ19fH8OHDMWrUKAwYMECqDhNFUfJJTEzE8ePHER4ejlu3bqFdu3YICgpCQEAAa+1vUorH9hUbTWw1yMrKwoEDB3Ds2DFER0fDyMgI/v7+GDVqFPz8/GBgYMB2iBSl0h4+fIjjx4/j+PHjiI+PR/PmzTFy5EhMmDABffv2ldluKdW40cTWiKSkpCAiIgLHjx/H1atXoauri759+8LHxwc+Pj5wd3enP1JK7eXm5uLy5cu4ePEiIiMjkZCQABsbG4wcORKjRo1C3759aQnHJo4mtkYqMzMTJ06cQGRkJC5duoSsrCxYWFjA29sbvr6+8PHxgaOjI9thUpTSlZSU4Nq1a+JEFhcXB0IIvLy84OvriyFDhqBXr17Q0KCP9NUFTWxNRFJSEiIjIxEZGYnz588jPz8fNjY26NSpk3jo06cPfY5ANXqpqamIjY3FtWvXEBUVhdjYWJSUlKBVq1bw9fWFr68vvL29G3U3UVT90MTWBJWWliImJgbXr19HdHQ0YmJikJaWBi0tLXTs2BHdu3dHt27d4O7uDldXV+jo6LAdMkXJlJaWhnv37uHmzZuIiYlBTEwMMjMzoa2tDQ8PD3Tr1g3du3dHnz594ODgwHa4lIqgiU1NJCcnIzo6Wpzo4uLiUFJSAm1tbbi4uKBjx45wd3dHx44d4ebmprLNHFFNU0lJCR48eIC7d+/i3r17uHv3LuLj48W9ajs4OIhPyLp164ZOnTrR0sFUlWhiU1MCgQAJCQm4d+8e4uPjce/ePdy7dw8vX74EAJibm6N9+/ZwdnZGmzZt4OzsDE/7vJYAACAASURBVGdnZzg5OcndHxdFvS89PR1PnjzB06dPkZCQgKdPn+LRo0dITExERUUFDAwM0L59e7i5ucHNzU18wmVubs526FQjQhMbJSEvL0981vzw4UPxwSc5ORmEEGhoaMDBwUGc8Nq0aQNHR0c4ODjAwcGBHoDUXHl5OV6/fo2XL18iOTkZz549E3+Hnj59Km4P09jYWPz9Ed0xcHNzQ+vWrWmJRareaGKj5FJSUiJxlp2QkICEhAQkJiZKtOZvZGSEFi1aoEWLFnBwcJB4tba2ho2NDa1710iR/3puyMzMRHJystTw4sULpKWlQSgUAgD09PTQsmVLuLi4iK/6Ra+2trYs7w3VlNHERtVbSUkJXr58KT5LT05OFv/98uVLpKSkoLy8XDy/sbExeDweLC0tYWtrCysrK9jY2MDGxgZWVlawtraGubk5zM3NYWhoyOKeNX1CoRDZ2dnIyclBdnY2MjIykJKSgszMTKSkpCAjIwNpaWlIT09HZmYmBAKBeFlzc3PxlXrLli0lTmQcHBzq3UsARdUV24mNdm7UBOjp6cHFxQUuLi4yp1dUVCA9PR2pqalIT09Heno60tLSxAfPGzduIDU1FRkZGSgpKZFYVldXF82aNRMnusrvmzdvDi6XCzMzMxgaGsLIyAjGxsYwNTUV/21kZNQQHwFrBAIBCgoKwOfzUVhYKB7y8vJQWFiI/Px85OTkiBNX5ffZ2dnIy8uTWqeFhYX4ZMPa2hqurq6wtbWFpaWl+ITE3t6+yX+2FFVXNLGpAU1NTfB4PPB4vBrnzcvLQ2ZmpswDsej969evER8fj5cvXyInJweEEPHtL1kqJz5DQ0Noa2vDyMgIHA5HXK/PxMQEGhoaMDQ0hI6ODnR1dSVumb7/d2XGxsYyO6AsLCyUuFIVEQqF4PP54r8JIeIEw+fzIRQKUVRUhLKyMpSUlKC4uFicwCoqKpCfn4/8/HwUFhZKnQhUZmhoCGNjY4mTAVtbW3To0EF8kvD+SYOlpSWt/kFR9UQTGyXB1NS0xkrkxcXFWLBgAWJjYzF37lwEBwejoqIChYWFKCgoEF+tVL56KSgoQGFhIYqLi1FaWoq3b9+KkwQAvHjxAgDTa7JAIEBxcbFE0sjNzUVhYSEMDQ0lmi2rnJTeV10y5HK5yMnJgaGhIQwMDGBqagoOhyNOkvr6+tDT04OxsTFsbGygoaEBExMTcTI2NjYWX5FyuVxwuVzx36KrVtq8GkWxgyY2qlYePnyIcePGIT09HSdPnoS/v794mr6+PiwsLJSy3TVr1mDr1q1ISUlR2Dr/97//ITs7G9evX1fYOimKYh9tvI2S2759+9ClSxeYm5vjzp07EklN2S5fvgwfHx+FrnPlypWIjo7GpUuXFLpeiqLYRRMbVaP8/HxMmDABU6ZMQWBgICIjI+V6XqcoZWVluH79Ovr376/Q9Xbr1g0+Pj5Ys2aNQtdLURS76K1IqlqxsbEYP3488vPzcfbsWQwaNKjBY7h+/Trevn2r8MQGAMuXL4e3tzeioqLQu3dvha+foqiGR6/YqCpt27YNPXv2hKOjI+7evctKUgOAq1evokWLFmjZsqXC192/f3/07t0bP/zwg8LXTVEUO2hio6SUlpZixowZmDNnDpYvX45z587BysqKtXhu3ryJbt26KW39S5cuxZkzZ3Dr1i2lbYOiqIZDExslITU1Ff3798eRI0cQHh6Or776ivUOImNjY9GpUyelrX/IkCHo3Lkz1q5dq7RtUBTVcGhio8Ti4uLQo0cPZGVlITo6GiNHjmQ7JHETU15eXkrdztKlS/H777/j/v37St0ORVHKRxMbBQA4cOAAevfujfbt2+PGjRtwdXVlOyQAzNUah8OBp6enUrczcuRItG/fnl61UVQTQBObmhMIBFiyZAkmT56MefPm4dSpUzW2PNKQ4uLi0LJlSzRr1kyp2+FwOFiyZAkOHz6MhIQEpW6LoijloolNjWVlZWHQoEEIDQ3F0aNHsXbtWtafp73v8ePHaN++fYNsa/z48XB0dMSPP/7YINujKEo5VOsoRjWY+Ph4eHl54cWLF/j3338xevRotkOSKTExEU5OTg2yLU1NTSxZsgT79+/Hq1evGmSbFEUpHk1saujs2bPo06cPnJyccPPmTXTs2JHtkKr07NkztG7dusG2N3nyZFhbW2Pjxo0Ntk2KohSLJjY1s2vXLgwfPhyjRo3CuXPnYG5uznZIVcrPz0dWVlaDJjZtbW3Mnz8fO3bsQFZWVoNtl6IoxaGJTU0QQrBq1Sp88sknWLZsGXbv3q3y/X4lJiYCQIMmNgAICgqCvr4+tmzZ0qDbpShKMWhiUwOlpaUYO3Ys1q5diwMHDmDVqlWNoq+wFy9egMPhoEWLFg26XUNDQ8yePRubN29GYWFhg26boqj6o4mtiePz+fDz80NkZCQuXLiACRMmsB2S3LKzs8HlcqGrq9vg2543bx7Kysqwc+fOBt82RVH1QxNbE5aeno7+/fvj0aNHuHz5Mj744AO2Q6qV3Nxc1urUmZubIzAwEBs2bEBZWRkrMVAUVTc0sTVRz58/xwcffAA+n4+rV6/Cw8OD7ZBqjc/ns1pZfNGiRcjMzMSBAwdYi4GiqNqjia0Junv3Lnr06AFTU1NER0c3WD0wRcvLy4OZmRlr27ezs8PEiRPx448/QigUshYHRVG1QxNbE3Pz5k30798frq6uuHTpEiwsLNgOqc7y8vJYb97ryy+/xNOnTxEREcFqHBRFyY8mtibk6tWr8PX1Rbdu3XD69GkYGRmxHVK9FBcXQ19fn9UYXFxcMGLECKxZswaEEFZjoShKPjSxNRGXL1/GkCFD0K9fP0RERLCeEBRBS0sLAoGA7TCwZMkS3L59GxcvXmQ7FIqi5EATWxNw+vRp+Pn5YeTIkTh+/DgrxeOVQUdHRyVKJHbp0gU+Pj5Yt24d26FQFCUHmtgauXPnzmHUqFGYOHEi9uzZAy0tLbZDUhhtbW2Ul5crdJ1nzpyBs7NzrT+nzz//HJGRkbh9+7ZC46nszp078Pf3h6mpKYyNjeHr64tr164pbXsU1VTRxNaIRUZG4sMPP8T48eOxc+dOletypr50dHQUltiePXuGYcOGYenSpcjIyKj18oMHD4aHhwc2bNigkHjeFxMTg549e8LY2BiPHj3C8+fP0apVK/Tr1w8XLlxQyjYpqqlqWkdCNXL16lWMGDECQ4cOxa5du5pcUgMUeyty5cqV6NmzJ2JjY2FsbFyndSxYsABHjhxBcnKyQmISEQqFmD59OkxNTfHrr7/CxsYGzZs3x7Zt29C6dWsEBgaitLRUodukqKas6R0N1cDVq1fh5+eHoUOH4uDBg03q9mNlJiYmyM3NVci6fvnlFyxZsqRen9WECRNgbW2NTZs2KSQmkX/++QcPHjzA6NGjJQr9aGpq4qOPPsKrV69w6tQphW6Topoymtgamdu3b2Po0KEYPHgw9u/fD01NTbZDUhpra2ukp6crZF2KKCWqra2NOXPmYMeOHcjLy1NAVIxLly4BADp37iw1TTSOlsikKPnRxNaIJCYmYsiQIejcuTN+++23JnulJmJjY4OsrCyZz9keP36MESNGwMTEBAYGBujatStOnToFX19fcDgccDgcBAYGKjymmTNnQkNDAzt27Kh2vtrE9/jxYwBMSyfv4/F4AICEhAQF7wlFNV1N+8jYhKSkpGDAgAFo0aIF/vjjjyZTpL86jo6OEAqFeP78OZydncXjExMT0aNHDxgaGiI8PBw9evTAy5cvsWDBAty9exe6urooKSlRSkxcLheBgYHYtGkTFixYILNPu9rGJ7r6MzQ0lFqXqJK9om7JUpQ6oFdsjcCbN2/g6+sLIyMjnDlzptG3KCIvFxcXcDgc8RWNyLJly5CXl4eQkBAMGDAARkZGaN++PQ4ePIiioiKlx7VgwQJkZmbi0KFDMqcrMj5RayeNof88ilIVNLGpuOLiYgwbNgxlZWU4f/48zM3N2Q6pwRgaGsLOzg6PHj2SGH/u3DkAwKBBgyTGW1hYoG3btkqPy87ODmPHjsX69etlNrNV2/hE7WHKSnqicWy3mUlRjQlNbCpMKBRi0qRJSEhIwJkzZ2Bra8t2SA2uU6dOuHnzpvjv0tJSFBQUQE9PT+aVa0P1BvDFF1/gwYMHUnXM6hKfKNm9fv1aalpKSgoASNyKpSiqejSxqbDFixfj1KlTOHbsGFxcXNgOhxVdunTBjRs3xH/r6urC2NgYJSUlKCwslJo/MzOzQeJyc3ODj48P1q9fLzG+LvH1798fABAbGys1TTTOx8dHEWFTlFqgiU1F7dixAxs3bsSuXbvg7e3Ndjis6d69O169eoWXL1+Kx/n5+QF4d8tPJD09vUFLD4qa2YqLi5MYX9v4+vbtC1dXV4SHh0sUKqmoqMDhw4dhb28Pf39/JewBRTVRhFI5p0+fJpqammTNmjVsh8K6kpISYmRkRMLCwsTjEhMTibm5OeHxeOTChQukoKCA3Lt3jwwePJi0aNGC6OrqVrtOHo9HNDU1FRKfh4cHmThxosS4usR3/fp1oqenR8aPH0/S0tJIVlYWCQoKIlpaWuTcuXMKiZWiGkp/0p/MIrPY2nwoTWwq5vHjx8TExIRMnTqV7VBUhr+/Pxk5cqTEuCdPnpARI0YQLpdLDAwMSM+ePcnff/9NfHx8ZCaOkydPEgAyh507d9Y5tr179xItLS3y4sWLesVHCCFxcXHEz8+PcLlcYmRkRLy9vUlUVFSdY6MotrCd2DiE0N4TVUVBQQG6d+8OLpeLK1euqEVdNXmEhYXhs88+Q3p6eo3tPPr6+iIqKkpp9djeV1ZWhtatW2Ps2LH46aefapy/oeOjKDZ4wxtt0RZbsZWNzW+lz9hUBCEEU6dORU5ODo4dO0aTWiVjx45FRUUF/vjjD7ZDkaKjo4O5c+di165dyM/PZzsciqJAC4+ojK+//hp//vknjh49KrNpJXVmZmaGwYMHY9++fWyHItPMmTMBALt27WI5EoqiAJrYVMLJkyfx3XffITQ0FH369GE7HJUUFBSEyMhI3L17V+b0w4cPg8Ph4OLFiygtLVVaW5GycLlcBAQEYNOmTRAIBCoXH0WpG/qMjWWvXr2Cp6cnhg0bht27d7MdjsoihKBDhw7o0aOHSl4ZPX/+HG3atMGhQ4cwZswYtsOhKFbRZ2xqTCAQYMKECWjWrBlCQkLYDkelcTgcLFy4EAcOHMDz58/ZDkeKo6Mjhg0bhuDgYLZDoSi1RxMbi77++mvcunULR48erXOvzupkypQpaNWqFVasWMF2KDItXLgQN2/eRHR0NNuhUJRao4mNJVeuXMG6deuwadMmuLu7sx1Oo6ClpYXvvvsOhw4dwq1bt9gOR0qfPn3QtWtXbNy4ke1QKEqt0WdsLMjOzkbHjh3xwQcf4PDhw2yH0+j07t0bWlpauHLlCtuhSDl48CAmT56MhIQEtGrViu1wKIoV9BmbGpo9ezY4HA62bdvGdiiN0o8//oh//vkHx48fZzsUKWPHjgWPx0NoaCjboVCU2qKJrYH98ccfOHr0KHbt2tVgXaw0NT179sS0adMwc+bMBmvNX15aWlqYPXs2du7cCT6fz3Y4FKWWaGJrQG/evEFQUBA++eQTcQvwVN1s2LAB+vr6WLBgAduhSPnkk09ACKHVNyiKJTSxNaBZs2bBwMCAFglXAC6Xi927d+Pw4cP4/fff2Q5HgqmpKaZOnYqQkJAqK2xTFKU8NLE1kCNHjiAiIgK7d++mRfsVxNfXFwEBAfj000+RmprKdjgSFi5ciNevX6tk+5YU1dTRxNYACgoKsGjRIkybNk3cWzKlGJs3b4a5uTlGjRqFsrIytsMRE1XYrlz0v6ysDMeOHUPv3r0hFApZjI6imjaa2BrA119/jeLiYnz//fdsh9LkGBkZISIiAg8ePMCXX37JdjgSFi5ciH///Rdnz57F6tWrYWtri7Fjx+LatWvIy8tjOzyKarK02A6gqXvw4AG2bNmC0NBQWFhYsB1Ok+Ti4oIdO3bgo48+gpeXFz7++GOpeZ48eQJnZ2dwOJwGi4vL5cLa2hrDhg0DAInnbdnZ2TA3N2+wWChKndArNiUihGDOnDnw8PDA9OnT2Q6nSRs/fjzmzp2LWbNm4caNGxLTnjx5gl69eiEiIkLpcQiFQkRGRsLPzw+enp7Izs6GQCCQKkSSnZ2t9FgoSl3RKzYl+u2333D16lXcuHEDGhr0HELZNm7ciFevXsHf3x9RUVFwcXFBSkoKvL29kZOTgy+++ALDhg2DlpZyvvbZ2dno2bMnEhISoKWlBUIIysvLZc6blZWllBgoiqJXbEpTVlaGr7/+GtOmTYOXlxfb4agFTU1NHDx4EG3atIGfnx8SEhIwcOBAvHnzBoQQPH/+XKl1y5o1a4Zly5aBw+FUW8xfU1OTXrFRlBLRxKYkmzdvRlpaGlauXMl2KGpFX18fJ06cgIaGBrp27YqnT5+Kr5qEQiGWL1+OoqIipW1f1OFodWhioyjloolNCfh8Pn744QcsWLAA9vb2bIejdszNzdGyZUsUFRVJ3QrMy8vDzz//rNTtz5kzBytXrqyyoAqHw6GJjaKUiCY2JVi3bh2EQiEWL17MdihqhxCCwMBAXLlyRebtQIFAgO+//17pbUyuXr0a8+fPl/lstaKigj5joygloolNwdLS0hASEoIVK1bQRo5Z8OWXX2Lfvn2oqKiocp6ysjKsWbNG6bFs2LABH3/8MTQ1NSXGCwQCmtgoSoloYlOwjRs3wtTUFJ9++inboaidsLAwBAcHo6YuBgUCAbZt24bnz58rNR4Oh4OdO3di4MCBUiUxMzIylLptilJnNLEpEJ/Px44dO7Bw4ULo6emxHY7amTp1Ko4ePYo+ffoAALS1taudf9myZUqPSVtbG8ePH0fXrl0l4lG17nYoqimhiU2BNm/eDACYMWMGy5GoJx0dHYwZMwZ///03YmNjMWXKFOjo6Mist1ZeXo4jR44gLi5O6XHp6+vj7NmzcHV1FSe3nJwcpW+XotQVTWwKUlJSgtDQUMydOxcmJiZsh6P2vLy8sGPHDrx69QrfffcdbGxswOFwJJ53aWlpNVgBHy6XiwsXLsDe3h4cDod2QkpRSsQhNT2QoOSyZcsWfPnll3j+/DksLS3ZDod6j0AgQEREBH7++Wf8+++/0NbWFlcFiIyMhI+PT723UVAACATMUFAgOQ4ACAGePHmJuXO7ITc3AydO5MPA4F0XRoQANbWNrKcH6OvLP93YGNDSYgZRb0micRSlLN7wRlu0xVZsZWPzW2liUwChUAhnZ2cMHjwYW7ZsYTscqgpCIZCbC1y/Ho9duzbjzJkDKC8vhYODG5Ytu4PCQg6Ki4HCQiA/HyguBoqKAD6fef/2LZN4CJGdxOT3CMAHAG4AcFT4fspLVrIzMGASo4kJYGjIvOdyASMj5r2xseR70d9mZoCpKfNqYMDaLlEqgu3ERs/bFODs2bNISkrCnDlz2A5FLVRUAFlZwJs3zGt6OvM+N5dJPO+/it7n54vW4A5gF4AfAfyCV6+2YdGiI2jWbDz09ZkDtbExxO/t7ZkrISMj5iCvqckcvHV1AQ0NJgkAsscZGgI6Ou9iNzICtLXb4fbtszA2LoOTk+S+MdOr3vfKV4DyTOfzmYReWsok5prGFRYCJSXMZ1VYyCT0pKR37wsKJN/LoqPzLsmZmkq+NzNjhubNAQsL5tXKCrC0ZD4rilIEesWmAEOGDEFFRQXOnz/PdiiNFiFARgaQksIMr18DmZlMwsrIYF5FiSwri5lfREODOUiam1d/QJX1amwMcDgVuH//Ptzd3dn7ABopUaJ7/ySiuhOMnBzmf/h+y2b6+sz/0crqXdKzsACsrZnB3h6wsWFeq7sdS7GPXrE1cs+ePcP58+cbpEuUxooQIDUVeP6cSVipqcCrV8xrSgrzPi0NqNz6VbNm7w5wlpZAx47SZ/jNm787+NWvmzVNmtTqSHQ70sam9su+fcskuPdPXERX4FlZwOPHzHcjIwOo3EG6uTlga8skOVtbwM4O4PGY9y1aAK1a0Vui6owmtnoKDQ2FnZ0d/P392Q6FVSUlTKJKSpIeHj+WPDs3M2MOPDY2QPv2gK8vc0ASjbO3Z275UU2bgQHg4MAM8sjNZb5jaWnvXpOSmPd37rwbJyL6nskaHBxoAZqmjP5r6+Ht27fYu3cvvvjiC6lmk5oigYA5kDx8yCSrR4+YITGROegAzG1BHg9wdGSGYcOA+fOZ961aMbeUaNd0VF2Ins+1b1/1PEVFwIsXzPf0+XNmSEoCzpxh3hcWMvNpaTHJzcUFcHUF2rYF2rVjBtqxeeNHE1s9HDhwAEVFRZg6dSrboSiUQMAkrrt3JZNYYiJzO4jDYW73uLgAvXsDU6cyScvRkRmvq8v2HlDqytCQSXxVJb/MzHfJTnQ34coVICzsXdKzsGCWd3FhEp2rK+Dpydz2phoHmtjqITQ0FB999FGjrrdWXg4kJACxse+G27eZ5x/a2sxtQVdXYOhQJnm5ugIeHkzpPYpqbCwtmaFbN+lpubnAgwfMyZzo9a+/mAQIMLfJO3Vikp6rK/Pe1bW+z3cpZaClIuvon3/+Qd++fXHjxg106dKF7XDkIhQC9+8DV68C0dFMAnv8mCk+z+UyCcvTkxk8PJgfbQ3NLVJUk5eZyfxWKg+JiUyhKHNzwMsL6NwZ6NWLGWinHuyXiqSJrY7GjRuH5ORkXL9+ne1QqlRcDNy8CURFAdeuMQOfzySxHj2YH6QokbVuTc88KUpeBQVMgRVRortxg7ldz+EwJ4S9ezNJrk8f5va8umE7sdFbkXWQlpaGiIgI7N69m+1QJAiFzK3Es2eB8+eBW7eYZ2I8HvMD++475rVDB6aSMUVRdWNszPyW/utIAgCQnc2cPIpOJHfvZn5/dnZA//6Anx8wcCBTlYVSLprY6iAsLAympqYYPXo026EgJwe4cIFJZufOMbdN7OyYH9GsWcyZY8uWbEdJUU1fs2ZMKeBhw5i/K98xiYwEAgKYk8+uXQF/f+Y36ulJ75QoA70VWUsVFRVo0aIFJk+ejO+//56VGHJygCNHgEOHgH//ZX4YvXsDgwczPxY3N1bCoiiqGvn5TGEU0UloSgpT/WXkSGDSJObxQFNJcvRWZCNz7tw5pKamYtq0aQ263dJSpi7Ovn3Mq7Y284OYP5+p4Ex7yqEo1cblAqNGMQMhQHw881s+dAjYtg1wcgImTmSS3PttiFK1Q6vK1tLu3bvRr18/ODXQNy8hAZg7l2mZY/Ropq7Nzp1Ms0P79zM/EprUKKpx4XCYksfLlgH37jEFUIYNA3bsAJydmYInBw5INiNGyY8mtlrIysrC6dOnG+RqLSaG+aK3a8fcuvjySyA5mbmVMXkyu/XIysvLsXHjRnTq1AnGxsawtLSEn58fTp48ierubFdUVGDp0qVo06YN9PT04OfnJzHdyMgIHA5H5qCnpwc3NzeEhoZKbKNDhw5S844fP1483dfXV2Ja586d67TM+16+fIlhw4Yh/12XAQCAO3fuwN/fH6ampjA2Noavry+uXbtW688YAM6cOQNnZ2eZPYCLLFmyBEeOHKly+tSpU6GrqwtHR0fMnz8fJSUlcm27qv2TN67q9O7du8r/84IFCyTm3b59e5Xziob3v0e1ibOmz6+heHgAP/3EtJt65gxTf3TaNKbRgx9/lG4wmqoBoeS2fv16YmJiQoqKipS2jQcPCBk6lBCAkJ49CYmIIKSiQmmbq7XCwkLSu3dv4ubmRv7++2/y9u1b8vLlSzJ69GgCgNy7d6/KZcPCwggAsnr1apKbmytzntu3bxMAZPjw4eJxpaWl5Pbt26RXr14EAFm8eLHEMunp6aRZs2YEADlw4IDUOk+fPk3atGkj8X+ryzKVY2zevDnZvHmzxPjo6Giir69Pxo0bR1JTU8mbN2/IjBkziJaWFjl//nyVn8v7EhMTydChQ4mbmxvhcrlEU1Oz2nkdHR3JihUrqpwnPz+fbN++nQAga9asqXH7Ve1fbeKqjuj/KGuYP3++xLzbtm2rcl7RsHr16jrHKc/nx5bkZEK++IIQY2NCrKwI2bSJkPJytqOST3/Sn8wis9jafChNbLXg5uZGZs6cqZR1FxcTsnQpIdrahHh6EnLmjFI2U2+zZs0iXC6XpKenS4wvLCwkurq61Sa2jz76iAAg+fn5Vc4jK7GJJCcnEw0NDaKlpUWys7Mlpv32228EAGnWrJlEbDk5OcTe3p5cu3ZNan11WYbP5xM7OzsSFBQkMb6iooK0b9+e2NjYkLdv34rHCwQC4uLiQuzt7UlJSUmV+13ZRx99RH744QdSXl5OeDxejQnkzp07hMPhkCNHjlQ7n4GBARk4cGC181S1f3WJqyq9evUiN2/elGvebdu2yfwuEEJIQkIC0dXVJWlpafWKU97Pjy2ZmYQsWkSIri4h7u6EREezHVHNaGJrJKKjowkAcuPGDYWv+9kzQry8CDExIWTzZkIEAoVvQiHS09OJpqYmmTWrbl/YgQMH1niQqS6xEUIIj8cjAMilS5ekpg0bNowAIKNGjRKPmzhxIvniiy+q3F5tl1m+fDnR0tIiKSkpEuMvX75MAJC5c+dKLbNq1SoCgISHh1cZR2WVE6O8CWTMmDHEzs6OlFdzSm9ra0s6depU7Xqq2r+6xiVLbRLbX3/9RdavXy9z2ty5c8m4ceMUEqc8nx/bnjwhxNeXOfldv54QoZDtiKrGdmKjz9jktHv3bnTo0EHhzWfduQN0787Ub7l1C5gzR3UrT//555+oqKhA796967R8RUVFvWMg/z1f09PTk5q2fft2mJmZ4fjx4wgPD8cff/yBO3fuYPXq1VWurzbLEEKwa9cudOvWDba2thLTLl26BAAy8FEbrAAAIABJREFUn8eJxl28eFGufdSvQy+aI0eOxOvXr3H69Okq5+FwOBBU0/12dftX17jqy9fXF4sWLZIaX1BQgL179+LTTz+Vmqasz49tzs5MndXgYGDpUiAoiDluUNJoYpNDcXExjh49iunTpyt0va9eAQMGMPXOoqJUv4hvXFwcAMDMzAyLFi2Cvb09dHR00KJFC8ybNw85OTlK3X5ycjLS0tLA5XLRXkbz7TY2Nti4cSMAYPbs2ZgzZw727t0L3Wq6G6jNMvHx8cjIyJDZKenjx48BAHZ2dlLTeDweACAhIUGOvawbDw8PAKhXL+7V7Z+i7d+/Hx4eHjA0NISJiQn69OmDgwcPyr38r7/+CgcHB3zwwQcKiUcRn19D4HCYKj7h4UzVn2XL2I5INdHEJoejR4/i7du3mDhxokLXO3Uq0xv0n38y3W2ourT/enGcNm0aMjIy8PfffyMzMxPffvstdu/ejR49eoDP51e5fFlZWbVJpirl5eW4c+cOJkyYAG1tbWzZsgXcKnoiDQgIwJAhQ5CZmQknJyd06tSpxvXLu8z9+/cByE5eeXl5AABDGf9Io/+KsOaKOq1TAlHyFMUoi66uLsord1P+nur2T9Fyc3Oxe/duZGZm4saNG3B0dMTEiRMxb968GpclhCA0NFTm1VpdyfP5qZJhw5iudoKDgX/+YTsa1UMTmxx2796NYcOGwcLCQmHrvHkTuHgR2L698XRhLyoqrq+vjz179qBVq1YwNTXF5MmTsXTpUiQkJOCnn36qcvnk5GS5D5onTpwQF+fW0dGBp6cnLC0t8fDhQ3z88cfVLtumTRsAwN9//40TJ07ItT15lhEldpNaVhwU3T7lKLFZCS6XCw6HI45RFltbW6SkpFR5O7Ku+1dbUVFR2LdvH7y8vGBoaAgXFxfs27cPXbt2xebNmxETE1Pt8mfPnkVaWlqN34PakOfzUzUBAUwblOvWsR2J6qGJrQbPnj3D1atXFV537eJFpg3HOj6uYoXoasTX11eqbtDQoUMByL6Vk5OTg+DgYLx8+VLus+zhw4eDEAJCCF6/fo1x48YhIiICO3bsqHa5q1ev4vfff8eGDRsAADNnzqzxSkneZUSJXVtGXz6mpqYAgCIZFY5E40TzKIuWlhaKi4urnB4UFIT8/Hx89dVXyMrKkppe3f41BFHbqydPnqx2vk2bNmHy5MniK2FFqenzU0UffwxcukSftb2PJrYaHDp0CBYWFhgwYIBC15uVxdyGbExa/teacjMZzZOLOlt98+aNxPgpU6agWbNmWLJkCb744gu5bjW9j8fjYc+ePWjdujWCg4Nx69YtmfMVFhZiypQp2LFjBxYuXAg/Pz+kp6dj/vz5Va67NsuICqzIup3Xtm1bAMDr16+lpqWkpAAAnJ2da97ZehAIBNUWnJg0aRLWrFmD4OBgWFhYYPDgwRLTq9u/hmBjYwMAyMzMrHKehIQEXLhwQaG3IUVq+vxUkbU1UFLyrvdvikETWw2OHDmCsWPH1rmVhaq0bg08ecJ8KRsLUWlIWbdrRAcjq/ey9Z49e8Dn83H48GFs2LABQUFBddq2np4evv/+exBCsGTJEpnzLFq0CL6+vuIDdlhYGLhcLvbv349Tp07VexnRgVfWc8T+/fsDAGJjY6Wmicb5+PjIs6t1kp+fD0KIOEZZli9fjmXLlmHbtm3Iy8vDuXPnJKZXt38NITU1FQCq7ZF+06ZN+OCDD+Dq6qrQbcvz+amiO3eYHsGreOSsvtiqaNAYPHz4kAAgV69eVfi609OZCpfvNe6g0kpKSgiPxyNWVlakuLhYYtp3331HAJC1a9dWuXyXLl2ImZlZtduorh6bUCgknp6eBAC5cOGCxLRz584RR0dHqcrfO3bsIACIra2tVGsntV1GFNunn34qFVtFRQVxdXUltra2Ep+NQCAg7dq1I/b29lKfmTzkrYcl+q5WV8ewbdu2xNHRscrp1e1fXeN6386dO4mXl5fUeKFQSDp16kQAkOgqaiDz+XxibGxMjh49Kvf2FPn5qZqCAkJatCBkwQK2I5HGdj02mtiqsWLFCmJnZ0cqlNSm1YoVhBgYEBIbq5TVK8XZs2eJlpYWGT58OElISCC5ublk3759xNDQkHTr1k2icuz7fHx86l1B+/Tp0wQA8fLyIsL/aqjm5uYSe3t7cvnyZZnL+Pr6EgBkypQp4nF1WUYoFBJLS0vSq1cvmctcv36d6OnpkfHjx5O0tDSSlZVFgoKCiJaWFjl37pzU/BMnTiQASFJSksz1ESL/gfngwYMEAImIiKh2Xe7u7lVOr2n/ahPX8+fPiYaGBgFAYit9wXfu3ClOnk+fPiXFxcXk8ePH4s9CVgV3kY0bNxIbG5taVaJW5OenSioqCJkwgRBLS0JSU9mORhpNbCrM2dmZLFq0SGnrLy8nZOBAQszNCbl+XWmbUbh///2XDBo0iJiYmBAdHR3Stm1bsmrVqmqTGiFMsqjuIGNoaCjVDqCsliV69+5dZbuBlRNibm5uje0MyrvMxo0bCSGELFu2rMqWOQghJC4ujvj5+REul0uMjIyIt7c3iYqKkjmvt7c3MTIyIoL3mpo5efJklbHu3LlT5rrGjBlDeDweKSsrq/Lz5fF4xMPDo8rpNe1fbeISJTYOh0Pu3r0rHl9SUkKOHTtGRo4cSVq3bk10dXWJiYkJ6devHzl48GCVcQmFQuLk5ES++uqrauOvbZwi8nx+qqK0lJCAAEL09Aj56y+2o5GNJjYVdevWLaU1oVVZcTEh//sfITo6hISEqHYzOfXl7+9POBwO22HUS15eHuHxeDLbUqyN3Nxcoq+vTwIDA+sdk6itw0OHDlU7n5WVFenevXu18yhq/xoTeT8/VZCUREi3boQYGREi4yaAymA7sdHCI1U4cuQIWrVqJbOJJEXS0wNOnABWrgQWLQL69AHu3lXqJlljZ2cHQggyMjLYDqXOTExMcPLkSYSHhyM0NLRO6yCEYN68eeByufj222/rFU9SUhI+/PBDLF26VKLrnfeVl5cjJyenxnqEiti/xkTez49tZWXA2rVAhw5AcTHT/N6gQWxHpbpoYpOBEIJjx45h3LhxSq1UK6KhAaxYwXxZhULA0xMYOxZ4+lTpm25QopKHa9euRXZ2NsvR1J2npydu3bqFs2fPyuyvrCYZGRlISkrCxYsXYW1tXa9YwsLCsGbNGqxZs6bKefh8PjZs2IDy8nKpIv6y1Hf/GhN5Pj82CYXAsWOAqyuwejWweDFw4wbg4sJ2ZCqOrWtFVXbt2jUCgNy5c6fBt11RQcjBg4S4uBCipUXI2LGNo5sKea1bt460a9eO6OrqksGDB7MdTpMXEBBAtLW1iZOTE1m5cqXU8zxKNeXnE7JhAyEtWzKt+c+YwfTP1liwfSuSQ0g1XR6rqfnz5+PChQt49OgRazEIBMyZ2oYNzJWclxfTysBHHzW+it0URdVMKASuXAH27weOHwcIYdqTXbAAaNWK7ehqxxveaIu22IqtbGx+K70V+R5CCH7//XeMHTuW1Ti0tJgkdvMmcPUq03X8qlWAnR3g7w8cPAi8fctqiBRFKcD9+8CSJUCLFoCPD/P3t98CycnApk2NL6mpAsU2p9EExMfH4/Xr1+K2D1VB797MsGUL0xPAgQPAlClMwZOBAwE/P2aQ0YUWRVEqRiAArl0Dzp4FTp9mElnLlkyjxpMmAf+1zkbVA01s7zlz5gwsLS3h5eXFdihS9PWBceOY4c0bpk+mU6eAuXOZprk8PN4luR49VLfDUopSN+npTCI7exb46y8gL4/pOHTIEGDrVubEtQHKqakN+oztPX369EGbNm2we/dutkORW3Exc2/+zBnmh/PsGWBqyvxYevViXjt3Zq7wKIpSvuRk5hHCv/8yr/fvM7+/vn2ZZDZkCNNebFPF9jM2mtgqyc3NhaWlJQ4ePIgxY8awHU6dJSQA588zvXJHRQGpqYCuLpPcRMmuZ09ARiP9FEXVUkUFk7iiophbjFevAq9fA9razG+uZ0/A2xvo16/x9L1YX2wnNnorshJRX2KK7qKmoTk7M8PcuczfqanMDy4qCoiMZHrdFQoBGxugU6d3Q/v29EE1RVVHIGB65YiNfTfcuQMUFQFGRkD37sD06e9OIBtZLzhNBr1iqyQgIAAvX77ElStX2A5FqbKzgZgYIC4OuH2bGZ4/Z6ZZWTEVxL28mGd2bdsySVJXl92YKaqhpacDjx4BDx68+608eACUlwOGhoC7O/Nb8fQEunRhWgXRoOXMAdArNpUhFApx/vx5fPbZZ2yHonTNmr27zy+Sl/cuycXFAX/8wXQ5X1HBFEJxdATatWMSXdu2TEsIbdsyz/IoqrGqqGBO6h49YoYnT4CHD4HHj5nfBACYmzPJy9eXafnD05M52aOFs1QXTWz/uXnzJjIyMjCk8tFejZiaAv37M4NIWRnzQ3/8mBkePWJuZYaGvqtDZ23N/MgdHZmhVat3r7T6AaUK3r5lkldSkuTrs2dMs3VlZcx89vbMyVqXLkzRexcX5mSunq2eUSygie0/Z8+ehb29PTp06MB2KCpDRwfo2JEZKiMEePHi3dnts2fMwSI6mhlfWsrMp6cnnfDs7AAejxlsbZltUFR9ZGczz5FfvQLS0pjvYOUElp7+bl5Ly3ffxREj3iUvFxfA2Ji1XaAUjCa2/5w7d05tr9Zqi8N5l7Deb1OXECAlhTmgVD643LkDREQwB5mKinfzW1kxhVhECc/WljlztrFh3jdvDlhYMCXMKPWSn898X968YRJX5eQlen39mqnDKWJszLTg4egIdO3K1PmsfGJlaMje/lANhyY2AG/fvkVcXBwWLlzIdiiNHofDJCk7O6YLnvdVVAAZGZIHqNRUJhkmJDD18V69km4uzNycOdu2sGCSnbU18140WFsDZmbMLVVTU4DLbZDdpeRUXs48s8rNZYY3b4CsLCAzk/k+iP4WJbI3b95d+QNMoQwrq3cnP25uzEnV+ydERkbs7SOlOmhiAxATE4Py8nL07NmT7VCaPE1N5iBU0/M3Pp9JfFlZzEFOdMATHQwfPQL++efddKFQejuiJGdqyiS9yolP9N7QkCmSbWbG3DoVvdfXZwZ1LxxTUsI0AJCby7yWlLx7X1zMJKvCQuZVlLhE7yv/XVQkvW5DQ+akxMrq3cmJm9u7E5jK06ys6FU7JT+a2ABERUWhRYsWsLe3ZzsU6j8mJswgD6GQSXCig+j7B9fKVwovXkiOe/u25sakKyc5AwOm6oOW1rtnMkZGzEG3pnEihoZVP1vU1Kz6arO8nEkiVcnPl7zNW3n+ggKmDlZ5OUFhIee9ce/my8uTTFrVVQbicJjPxMhI8oTB3Jy59Vf5BOL9EwoLC/WprEw1PJrYAFy7dg29evViOwyqjjQ0mLN8S8u6r6PyAf39KxJR8svPZxJAeTlTkk50FcLnM8n17Vvm6rHyuMrziWRmngSgA21t6S6QRVdIVTEzq3qavr5ks2mVk6ShIfDy5ZcgpBjdum0CwFwh6egwn5/oJILLZdZjaMiM09dnEpCp6bsEL7qipU20UapK7RObUChEdHQ0vv/+e7ZDoVgkuqJQNkIIXF2/wAcffICwMOnEpkxHj3bC+PHjsXFjP3z44YcNum2Kakhqn9ju3bsHPp+P3r17sx0KpQbOnDmDx48f48iRIw2+7bFjxyIyMhLTp0+Hp6cnHB0dGzwGimoIat8ATFRUFLhcLtq3b892KJQaCAkJwYABA+Dm5sbK9jdt2oSWLVti3LhxKBPVTKaoJkbtE9u1a9fQs2dPaNL2cSgle/jwISIjIzF//nzWYtDT08PRo0fx+PFjLF26lLU4KEqZaGKjBUeoBhISEgInJyf4+fmxGkebNm2wdetWbNy4EadOnWI1FopSBrVObOnp6UhOTkaPHj3YDoVq4nJzc/Hbb79h3rx50FCBJuAnTZqEyZMnY/r06cjIyGA7HIpSKPZ/YSy6c+cOAMDd3Z3lSKimLiwsDJqampg8eTLboYht2bIFJiYmCAgIAO29impK1DqxxcfHw97eHs2bN2c7FKoJEwgE2Lp1KwIDA8FVoba+jIyMsGfPHkRGRmLrVlb6zaIopVD7xEav1ihlO378OFJTUzF79my2Q5HSs2dPLFu2DJ9//jnu3bvHdjgUpRBqndju3r3LWrFrSn2EhIRg2LBhaNWqFduhyPTVV1/Bw8MDEyZMQEnlpvIpqpFS28QmEAiQkJBA+1+jlCo2NhbXr19ntYh/TbS0tLB//368ePECq1atYjsciqo3tU1sSUlJKC8vh7OzM9uhUE3Yhg0b0LFjR/Tt25ftUKrl5OSE9evXY/369YiJiWE7HIqqF7VNbAkJCQCYOj0UpQxpaWkIDw/HZ599xnYocvnkk0/g6+uLKVOm0FuSVKOm1onNxsZGpUqpUU3L1q1bYWJigvHjx7Mdilw4HA7CwsKQkpJCb0lSjZraJrbExER6tUYpTWlpKXbu3IlPP/0Ueo2of5cWLVogODgYwcHBuHbtGtvhUFSdqG1ie/HiBW3dnFKaAwcOIDc3FzNnzmQ7lFr75JNPMGDAAAQGBtJbklSjpLaJLTk5GQ4ODmyHQTVRmzdvxvjx42Ftbc12KLXG4XCwfft2pKSk4JtvvmE7HIqqNbVNbK9evYK9vT3bYVBN0KVLlxAfH485c+awHUqdtWzZEmvXrsVPP/1EK25TjY5aJjY+n4/8/Hya2CilCAkJQZ8+fdClSxe2Q6mXmTNnonPnzpgxYwaEQiHb4VCU3NQysaWmpgIAeDwey5FQTc2LFy9w+vRpla6QLS8NDQ2EhYUhLi4Ov/zyC9vhUJTc1DKxZWZmAgAsLS1ZjoRqakJCQsDj8TB8+HC2Q1GIjh07Yu7cufjyyy/FvxuKUnVqmdiysrLA4XBgbm7OdihUE1JQUIBff/0Vc+bMgZaWFtvhKMy3334LExMTfP7552yHQlFyUdvEZmpqCm1tbbZDoZqQ3bt3o7y8HNOnT2c7FIUyMDDAxo0bsX//fly8eJHtcCiqRmqZ2HJyctCsWTO2w6CaEEIItm7diilTpjTJOwEjRozA8OHDMXv2bJSVlbEdDkVVSy0TG5/Ph4mJSZ2Wzc3Nxfbt2+Ht7Q1zc3Po6+ujTZs2mDhxIuLj4xUcKdVYnDx5Ek+fPq1zEf87d+7A398fpqamMDY2hq+vr8q1/LF582a8evUKoaGhbIdCUdVSy8RWWFgIQ0PDOi27ePFizJ07F8OHD8fDhw+RnZ2N3bt3486dO+jUqRP++OMPBUdLNQYhISEYPHgw2rVrV+tlY2Ji0LNnTxgbG+PRo0d4/vw5WrVqhX79+uHChQtKiLZu7O3tsWDBAqxevRpZWVlsh0NRVeIQQgjbQTS0qVOnIiMjA2fOnKn1soGBgdDU1ERYWJjE+Pj4eHh4eKBNmzbingMo9fDgwQN07NgRZ8+exaBBg2q1rFAohJubG3JycvDs2TPo6+sDACoqKtC+fXu8ffsWT58+ha6urjJCr7XCwkI4Oztj5MiR9MqNqpI3vNEWbbEVW9nY/Fa1vGIrKiqq8xXbrl27pJIaALi7u0NfXx/Pnj2DGp4rqLWff/4Zbdq0wYABA2q97D///IMHDx5g9OjR4qQGAJqamvjoo4/w6tUrnDp1SpHh1ouRkRG+++47hIWF0RZJKJWllomtuLgYBgYGCl1nUVERiouL0aFDB3A4HIWum1JdOTk5OHjwIBYuXAgNjdr/nC5dugQA6Ny5s9Q00ThVK4k4ZcoUeHl5YcGCBWyHQlEyqWViq6iogKampvjvx48fY8SIETAxMYGBgQG6du2KU6dOwdfXFxwOBxwOB4GBgdWu89ixYwCA5cuXKzV2SrVs27YNurq6+Pjjj8XjavN9evz4MQDAzs5Oat2ilnFU7da2hoYGfv75Z1y+fFmlriYpSqTp1CKtBaFQKL6qSkxMRI8ePWBoaIjw8HD06NEDL1++xIIFC3D37l3o6urW2HVHRkYGlixZgsDAQIwdO7YhdoFSAeXl5di+fTtmzJghvrVd2+9TXl4eAMi8NW5kZASAKYmranr27InRo0dj8eLF8PPzkzhRpCi2qeUVGyFEnNiWLVuGvLw8hISEYMCAATAyMkL79u1x8OBBFBUV1biu7OxsDB48GP369cP27duVHTqlQsLDw5GWlibR51p9v0+ViZ7Vquqt7e+//x7Pnj3D/v372Q6FoiSobWITPQ85d+4cAEiVZrOwsEDbtm2rXU9RUREGDRoEV1dX/Pbbb/SsVc2EhITgww8/lOiwtrbfJ1NTUwCQmfRE40TzqBonJycEBARg1apVKC0tZTscihJTy8SmqakJgUCA0tJSFBQUQE9PT3zbpzIzM7Mq1yEQCDBmzBjweDzs3buXJjU1Ex0djZiYGIlW/OvyfRIlu9evX0tNS0lJAQA4OzsrKmyFW7VqFTIzM2nr/5RKUcvEpquri9LSUujq6sLY2BglJSUoLCyUmq+61syDgoJQWlqKo0ePSjR46+TkhOjoaKXETamOkJAQeHl5oVevXuJxdfk+9e/fHwAQGxsrNU00zsfHR1FhKxyPx8OMGTPw3Xff4e3bt2yHQ1EA1DSx6enpiW+d+Pn5AXh3C0kkPT29ytJoq1atwoMHD3DixAmVqThLNZzU1FQcP34cCxculJpW2+9T37594erqivDwcIlCJRUVFTh8+DDs7e3h7++v4D1QrBUrVqCwsBDbtm1jOxSKAqCmiU10xQYwD8DNzc2xYMEC/PXXXygsLMT9+/cxdepUWFtbSy27Z88efPPNN4iJiYGxsbG4+LZoePbsWUPvDtXAtmzZAjMzM4wZM0ZqWm2/TxoaGvjll1+Qk5ODqVOnIj09HdnZ2Zg9ezaePn2KnTt3Qk9PryF2q84sLCwwe/ZsrF27Fvn5+WyHQ1Hqmdj09fVRXFwMAGjdujWuX7+OLl26YPTo0bCyskJQUBCWLl0KJycnqWXDw8MbOlxKhRQXF2PHjh2YM2eOzKv12n6fAKB79+74999/wefz4eLigpYtW+Lp06e4cuVKrZvoYsvixYtRXl6OTZs2sR0KRalnPTYTExPw+Xzx387OzoiIiJBrWVohVb0dOHAAhYWF+OSTT6qcpzbfJxFPT886tV2qKszNzTFv3jxs2rQJn332mcJb9qGo2lDLKzZTU1OVrPRKqb4tW7ZgwoQJsLKyYjsUlTN//ny8ffsWv/76K9uhUGpOLRObmZmZuMUHipJXZGQk7t69i3nz5rEdikpq1qwZAgIC8NNPP0EgELAdDqXG1DKxmZqaIi8vr8pW+A8fPgwOh4OLFy+itLRUrrYiqaYvJCQE/fr1g4eHR62WU6fv0+eff45Xr17RZ9EUq9SyP7bIyEgMGDAA2dnZMDc3ZzscqhFITEyEi4sLjh8/jhEjRrAdjkobN24cnjx5gtu3b6tsc2CUctH+2FhgY2MDgKmPRFHy2LRpExwcHDB06FC2Q1F5ixcvRnx8vMp1t0OpD7VMbLa2tgBoYqPkU1BQgL1792LevHm06TQ5dO7cGd7e3ggODmY7FEpNqWViMzMzg76+PtLS0tgOhWoEdu3aBUIIpk2bxnYojcbnn3+OCxcu4OHDh2yHQqkhtUxsAGBtbU2v2KgaCYVChIaGYsqUKTAxMWE7nEZj8ODBcHJyws6dO9kOhVJDapvYWrZsiRcvXrAdBqXi/vzzTyQlJWH27Nlsh9KocDgcTJs2DXv27KGNI1MNTm0TW6tWrWi7jlSNQkJC4O/vDxcXF7ZDaXSmTZuGoqIiHD9+nO1QKDWj1oktKSmJ7TAoFXb//n38/fffEn2uUfKzsrLCsGHD6O1IqsGpdWJLTk5GeXk526FQKmrDhg1wdXVV6f7QVN0nn3yCq1ev4sGDB2yHQqkRtU1szs7OqKiooLcjKZnevHmDQ4cOYf78+bSScT0MGDAATk5O2LVrF9uhUGpEbRNb+/btoaWlhbt377IdCsWywMBArFq1CllZWeJx27dvh4GBASZOnMhiZI0fh8PB9OnTsW/fPomOVClKmdQ2senq6qJNmzY0sVGIj4/HN998Ax6Ph+nTp+P27dsICwvDzJkzafcrChAQEIC8vDypXsUpSlnUNrEBgLu7O01sFN68eQMAKCsrw4EDB+Dl5YXc3FzY29ujoqKC5egaPxsbG/Tq1Ys2jEw1GLVObB07dqSJjZLom6+srEz8OmvWLLRs2RLr1q2j/ffV05gxY/Dnn3/S25FUg1DrxObu7o7k5GR60FJjQqEQhYWFUuNF/YmlpKRg+fLlcHBwwPnz5xs6vCbj/+ydd1hUx9fHv7ssVRAU6UVBBAUb9oYFUcCuEaOxx0Kixphij8Y3BmNL0UTFqNHEbozlp1HsvfeCqChYAEGkg4DL7nn/mCyw7C5SFi5lPs8zz8LM3Llnd+/e752ZM2cCAgKQkZGBo0ePCm0KpxpQrYWtadOmICLcu3dPaFM4ApGSkgK5XK6xnIggEonQo0cP+Pj4lKNlVQtra2u0b9+eD0dyyoVqLWwODg4wNzfnw5HVmPyekOrQ1dVFx44dsX37dh7Zv5QMHjwY+/fv58ORnDKnWgsbwOfZqjsJCQkay3R1ddG4cWMcPHgQ+vr65WhV1WTw4MFIS0vD8ePHhTaFU8Wp9sLWtGlT3LlzR2gzOAKRmJioNl9XVxdOTk44duwYjI2Ny9mqqom9vT3atWvHY0dyypxqL2xt27bFrVu3eATyakpCQgLEYuWfga6uLszNzXHs2DGYm5sLZFnVpFevXtyBhFPmVHth69y5M6RSKa5cuSK0KRwBSEhIgEQiyf1fIpHA2NgYp0+fhqOjo4CWVU26deuGmJgYPH78WGhTOFWYai9s9vb2qFevHs6ePSu0KRwBSEhIyI0FKRaLoaenh+PHj/NtasqItm3bwsTEBCdPnhScz3U4AAAgAElEQVTaFE4VptoLGwB4eXnh3LlzQpvBEYCEhATI5XKIRCJIJBIcPnwYLVq0ENqsKotEIkGnTp1w6tQpoU3hVGG4sIEJ26VLl3KjTnCqD0lJSZBKpRCLxdizZw86d+4stElVnm7duuH06dMgIqFN4VRRJO+vUvXx8vLC27dvcevWLbRt21ZoczgFyMoCMjOBlBQgOxtQBApJTgYK3htTU4GC4R319IAaNZTzJBLAxAR48iQOIpEIP/30Jzp06A2pFNDVLbv3wgG8vb0xY8YM3L9/H02aNBHaHE4VhAsbADc3N1haWuLcuXNc2MqIrCwgJoalN2+ApCQgMVF9Sk4GMjKYiCUnl7VlKQBW4vPPh0OxUbZYDJiaAoaGgJERULs2UKsWe82fFHl16gAODoClJRNRTuE0b94ctWrVwsmTJ7mwccoEEfHxAADABx98gJycHOzfv19oUyodWVlAZCQQEcFeo6OZgL16lSdmBcNxGhurCkTt2oC5OWBmxnpY+vrsbwMDJjI1a7I8E5O8Ngr2rmrUUBWXzExmY0GbMzOBf/7ZhO7dxyA7m4lpejoT1JQUVicjQ1l0CwpyZqZyu1ZWLNnb573a2wNOTizVrct7hAAwcOBAAMDevXsFtoRTFnjDGw3REKuxWojTr+Y9tv/w8vLCwoULIZfLVdY1cdhNPiwMePAAePxYWchiYvLqmZuzG7mdHevFtG8PWFuz/21s2GudOuXbszE0ZEkd06ePKVXbmZlAfDwQFQXExjJRf/WKvUZHA1evAi9fsiFSANDRYZ+PszMTOmdnwM0N8PAAXFyqj+i1bdsWq1cLctPjVAO4sP1H586dkZiYiHv37qFZs2ZCmyMYOTlMvO7fZyksjL1GRrK5Kz09djN2dgY8PYFBg/Ju0E5OrFdVnTA0BBwdWSqMN2/YZ5j/gSAyEjhzBnj2LO+zdXUF3N2Z0Lm7A82aMcH7b0VClaFFixZ4+fIl4uLiYGVlJbQ5nCoGF7b/aN68OaysrHD48OFqJWwxMcCNG8CFC8D588Dt22z4TSJhN2t3d+CDD/Juth4ebGiQUzzq1GGpdWvVsnfvgPBw9kARGsped+4EHj1igmdiAjRtCrRsmZfc3Su32LVs2RIAcPv2bfj6+gpsDaeqwefY8jF69Gg8e/YMZ86cEdqUMkEqBa5dA06fZj2Fy5fZEJmeHusZtGqVlxo1qj7DYhWVzEzg7l3g+vW8FBbGxM7CAujYEejalaUmTZjTS2XC0dERkyZNwqxZs4Q2haNl+BxbBcLf3x8jR45EcnIyzMzMhDan1MjlTMiOH2dCdvEi643Z2gLdugFLljARa9qUe/NVRAwNgbZtWVKQkQHcusW+1zNngO++A6ZNY443Xl5M5Hx8gMaNBTO7yLi7u+PRo0dCm8GpgvAeWz6SkpJgaWmJbdu2ISAgQGhzSsTbt8CJE8DBgyzFxDDvvM6d2RN+p05AixaVexiLo0xEBHt4OX4cOHkSSEgA6tUDevYE+vRhrxVx153PP/8c165dw8WLF4U2haNlhO6xVbLBi7KlVq1aaNeuHQ4fPiy0KcUiNRXYuBHw92dP7gMGMIePKVPYUFZsLLBrF/D552x+hota1cLZGZg4kX3Hr1+znvmwYcClS0C/fmx93ZAhwJ49bClDRcHNzQ0PHz4U2gxOFYQLWwH8/f1x+PDhCh/uRyYDQkKA4cOZO/2kSWwx8dq1TMguXABmz2ZzL5zqg1jMllgsWsQeaiIjgaAgtuYuIIANQ0+axERPaNzc3JCUlPTeXcw5nOLCha0AvXr1QmxsLG7evCm0KWqJjQXmzWNrxHr1Ap4/B375ha2d+ucfYPRo5ljA4QBsSHLKFDZM+eIFMHMmcPYs0KEDW1rwyy9AWpowtim2BXr58qUwBnCqLFzYCtCsWTPY2dnh0KFDQpuiRGgoMG4cu1H9/jswfjxzET9/ng1DVQFfF04ZY2cHzJjBhqlv3AB8ffMekmbOZIvMy9ceOwBAdHR0+Z6YU+XhwlYAkUgEPz+/CjPP9uAB0LcvG1K8dAn49VfWS/vuO6B+faGt41RWWrRg19KLF8CsWcCWLWyubvx41vsvD4yMjFCrVi1Elbeicqo8XNjU0KtXL1y9ehXx8fGC2ZCQwIaQmjVjno0HDrBe24QJfIE0R3vUqsWELTISWLeODVm6urJ5uYJxMMsCW1tbxOSPycbhaAEubGrw8/ODvr4+9u3bJ8j5168HGjRgXmxr17I1S717c29GTtmhp8fmZx8+ZE5HS5awRfpHjpTteWvXro3kst/CgVPN4MKmBiMjI/j6+uKff/4p1/OmpTE37cBANiT0+DHw8cdlF1EiODgYIpGo0OTv76/xeJlMhtmzZ6NBgwYwMDAotK6CHTt25LZtUMKu5/Lly3PbsLe3L1EbpeH58+fo168fUhWRjf/j9u3b6N27N8zMzGBiYgIfHx9cuHBB5fhZs2Zh586dGtsfO3Ys9PX14eTkhM8//xxZBbcmKEMMDIA5c9i117Ejc1CaM4fFEC0LzMzMtCJshw4dgqurKyQSHnOiMkNEuHDhAiZPngxXV1fo6+vD0tISnTp1wpYtW4rurU4ctWzdupV0dXUpISGhXM539y5RgwZEVlZEx46VyylpzZo1BKDQ9N1332k8fu3atbl1kpKSinXu7t27k76+fqnsb9asGdnZ2ZWqjeJy69YtqlOnDv36669K+ZcvXyZDQ0P68MMPKSYmhuLj42nChAkkkUjoyJEjSnWfPHlCTk5O9M0332g8T2pqKgUHBxMACgoKKpP3UhT++IPIyIioUyeimBjttz9ixAjq27dviY9/8uQJ9e3bl5o2bUo1a9YkHR0dLVrHKSndqBt9Sp8W+7iwsDACQD4+PnTnzh3KzMykp0+f0rBhwwgAffXVV0VpZhUXNg2kpqaSgYEB/fHHH2V+ritXiGrVIurShejVqzI/XS5r1qyh/v37qy17/Pgx6evr06tCDFJcbKmpqcU+d2UUtpSUFLK3t6fAwEClfJlMRh4eHmRjY0Nv377Nzc/JySE3NzdycHCgrKwspWNu375NIpGIdu7cWeg5jYyMqGfPntp7EyXg/n0iV1f24PXihXbbnjRpEnXp0qXExw8bNox++OEHkkqlZGdnx4WtglAaYZNIJJSYmKiUn52dTebm5qSvr6/yW1LDKj4UqQETExP07NkTu3fvLtPzRESw+bP27dmCa2vrMj2dEi4uLvDy8lJb9uuvv2LAgAGwLsSghIQE6OjowESx82cVZ+nSpYiNjcX8+fOV8s+ePYvQ0FAMHjwYhvk2ftPR0cGwYcPw8uVLHDx4UOmYZs2aYfDgwfjqq6+QU8g4n5mZGRISErT7RoqJhwdb+6avz6LbFBiBLRUSiQQymazEx2/YsAGzZs3iQ5BVhIYNG0IqlaJWrVpK+Xp6enBwcEB2dnaRhua5sBXC4MGDcezYMSQV3P5ZS+TksFBHjo7A33+Xv7ejj48PvvrqK5X8tLQ0/Pnnn5g0aVKhx5fmhlTZICKsX78ebdu2ha2trVLZyZMnAQCtWrVSOU6Rd+LECZWygQMHIioqCv/++6/G84pEokKFr7ywsgIOH2YRTD75RHvtisViyOXyEh9vqGkHWU6VIjk5GeHh4fD09ISpqel763NhK4T+/ftDR0cHBw4cKJP2V61iLvzbtrFwWBWFjRs3wtHREZ07dy51Ww8fPsSAAQNgamqKGjVqwMvLC+fPn9dYPz4+HlOnTkW9evWgp6cHCwsLDBo0CLdv3y7S+XJycrBz50706NED1tbWMDQ0RJMmTbBixYrcG2hycrKKk8z333+fe3z+/MGDBwMA7ty5g7i4OLV79SniHapzZFEsQn78+LFKWfPmzQEAR8ra9VBL2NsDGzYA27ezZQHaoKCw5b9ejIyM0KZNGxw8eBA+Pj6538n48eO1c3JOuVCa7zQ1NRUXLlxAv379YG1tjb/++qtoJy32IGg1o0+fPqWa3NaETEbk4ED0xRdab7pUyOVycnV1pdWrV7+3rpeXFxkZGWksDw8PJzMzM7Kzs6OjR49SWloa3b17l3r27En16tVTmWOLiYmhunXrkpWVFf3777+UlpZG9+/fpy5dupCBgQFdvHhRqb66ObYDBw4QAFq0aBElJiZSfHw8rVy5ksRiMX399ddKdX19fUksFtOTJ09UbG/fvj1t3bo19//NmzfntluQHj16EAC6fPmy2s8AALVo0UKlLCUlhQCQl5eXmk+P4ezsTO7u7hrLhcDXl6hHD+209cUXX1C7du2ISP31cv/+ffLx8SELC4v3zsnyObaKg2KOrTTf6cKFC3Od2Lp27Up3794t6um588j72LhxI+nr61NycrJW271yhQhgE/MViX///ZdMTEwoLS3tvXXr1q1Lrq6uGssDAgIIAO3evVspPzo6mvT19VUu6tGjRxMAJUEhInr16hXp6+tTy5YtlfI1CVvXrl1VbBkxYgTp6upSSkpKbt6RI0cIAE2aNEmp7vnz58nOzo7evXuXm7d06VICQKtWrVJpuzBhe/z4MQFQsV2BSCQiFxcXtWVERJ06dSJTU1OSSqUa65Q3u3YRSSRExXSEVUtgYCB5e3sTkebr5fXr12RkZMSFrRKhELbSfqfZ2dkUFhZGn3zyCeno6BTqpZ0P7jzyPgYMGAAiUpn8Ly137wImJmxiviKxcuVKjBo1CsbGxhrrJCYmYtmyZXj+/Hmh83AhISEAAF9fX6V8W1tbuLq6qtTft28fxGIx+vTpo5RvbW0NDw8P3Lhx473hl/r06YNTp06p5Ddr1gxSqRShoaG5eT179kSTJk2wadMmJQeNZcuW4bPPPoNuvi3EFRPWumq2FVdsSpuRkaFSpsjTtHGtRCJBZiEhPgIDA5Gamor58+dXmCj47duz+eF8H2WJycjIyL3WNF0vFhYWaNiwYelPxil3Svud6unpoWHDhlizZg369euH+fPn43gRxsG5sL0HMzMzdO/eHbt27dJqu+npQM2aWm2y1Dx+/BhHjx4tVKzGjBkDc3NzzJo1CzNmzMDUqVPV1svOzkZaWhoMDAzUiqSlpaVK/ZSUFMjlcpiamqrMgSl2WwgPDy/0PaSkpGD+/Plo0qQJatWqlXv89OnTAQBv375Vqj9t2jS8ffsWq1evzv0MTp48iYkTJyrVUywml0qlKudU/EDVia4iwK86IQfYnF5hDhAjRoxAUFAQli1bBgsLC/j5+WmsW14orltt7AqQkZGBGjVqvPd6Keglx6n4yLJlWv1O+/btCwBF6mRwYSsCw4YNw+HDh7X6xGxlBcTHV6yNH1euXInOnTvD3d1dY51NmzYhJSUFO3bswE8//YTAwEC19fT19WFiYoKsrCykp6erlCcmJqrUNzMzg0QigVQqBRGpTd26dSv0PfTt2xcLFy7EhAkT8PjxY8jlchARfv75ZwBQiVwwfPhwWFlZ4bfffkN2djZ+/PFHjB49WuVHZ2NjA4AJZ0EUNt24cUOlTJHXvXt3lbLU1FQQUW7b6pg7dy7mzJmDNWvWIDk5OfcJWEgUu8xoY2lKamoqTExM3nu9vH79uvQn45QrOvo6Wv1O9f/bBr7gvUMdXNiKwKBBg6Cvr6/VXlvHjsC7d4CaUTNBSE1NxV9//YXJkye/t27NmjUREBAAT0/PQtf5KUJsFbwZv3nzBo8ePVKpP2jQIOTk5KgNQ7VkyRI4OjoW6vouk8lw4cIFWFtbY+rUqbCwsIDovwCbmob79PX1MWnSJLx+/Ro//vgjtm7dis8//1ylXuPGjQGo75V16dIF7u7u2L17t9IaG5lMhh07dsDBwQG9e/dWOU7Rm1O0rY49e/bAyckJ48ePL5Kbc3lw5AjbJqkQs4tMTExMrrBrul5iY2PVepVyKj7F/U6//vprjBgxQm1bih1XWrdu/f4TF3dSsLoyYsQIat++vVbb7NZNe95lpeXnn38mGxubYjkpdO/evdDJ+idPnlDt2rWVPKJCQ0PJ19eXLC0tVSaO4+LiqH79+uTs7EyHDh2i5ORkSkhIoODgYDIyMlKJ0qHOecTb25sA0NKlSyk+Pp7evn1LJ0+eJEdHRwJAx9TEK4uPjydDQ0MSiUQaI7HI5XKytLSkjh07qi2/dOkSGRgY0NChQ+nVq1f05s0bCgwMJIlEQiEhIWqP2bZtGwGgvXv3avwM7ezsqFmzZhrLy5usLKJ69YgmT9ZOe2ZmZrR27VoiUn+93Lt3j/z8/Khu3brceaQSoXAeKe53+tVXX5FIJKL/+7//o8jISMrKyqLIyEiaMWNGrhNW/ug+GuBekUUlJCSEANCjR4+01ubZs0QiEdG2bVprskTI5XJycXGh+fPnF+s4Hx+f995IHj16RAMGDKCaNWuSoaEhtW7dmg4ePEjdu3fPdeUdN25cbv2EhAT68ssvydnZmXR1dcnCwoJ69uypJEjLli1TiWk5d+5cImIiFRgYSA4ODqSrq0tWVlY0ZswYmjVrVm5ddR6KEyZMIAB05swZje9lzpw5JJFIKDo6Wm35zZs3yd/fn2rWrEnGxsbk7e1N58+f19heQECAivdlQezs7Kh58+Yay8ubuXOJjI2Jnj8vfVsZGRkEgA4cOJCbl/96MTIyog4dOtCZM2c0hmBTLO9Ql9atW1d6IzklIn9IreJ8pykpKbR+/Xry9fWlevXqkZ6eHhkbG1PLli3phx9+KIqoEXFhKzoymYzs7Ozo22+/1Wq7n33GbhS3b2u12XKhd+/eJBKJhDZDK/zxxx8aXfIVJCcnk52dnUqsyJKgiBW5ffv2QutZWVnlrvMSmr17icRiojVrtNOeIuDtrVu33ltXG7FFOeVHUWJFluF3yt39i4pYLMaHH35YvK0TisCPPwJt2wI9ewJ37mit2XLB3t4eRIS4uDihTSk1wcHB+PLLLwutY2pqigMHDmD37t1YtWpVic8VERGBQYMGYfbs2Rg6dKjGelKpFImJiYJszVOQAweAoUNZOC1thdQKCwuDWCzW6DHK4ZQULmzFYMSIEXj69CkuXbqktTZ1dYH9+4EmTQAvLxZeq7KgcD1fvHix4IF6i8v69esxcOBApKenIzg4GElJSRgyZMh7j/P09MT169dx+PBhlf3YisratWsRFBSEoKAgjXVSUlLw008/QSqVCuriL5cDixYBgwaxjUh//VV7bYeFhcHR0RFGFSmeHKdqUBb9wKpMkyZN6NNPi78dw/uQSolmzmRzbiNHEmVkaP0UZcKSJUuoUaNGpK+vT35+fkKbU2TWrVtHAEgikVDTpk3pxo0bQpuUy+jRo0lXV5dcXFxo3rx5lJOTI4gd8fFE/v4sysjixURyuXbbHzFiBPn7+xdaZ/v27SpzZ/nnZDkVk8KGIsvhO10lItLiuFo1YMmSJVi6dCliYmJy11Vok3372K7ZlpZsmFKNlziHU6bI5cDGjcA33wCGhsDOnUBRPKyLS5MmTdCrVy8sWbJE+41zBMUb3miIhliN1UKcfjUfiiwmI0aMQEpKSu6aCm0zYABw+zbQtCnQpw/g6wvcv18mp+JwVDh1CmjZEvj0UyAgALh5s2xELTk5GQ8ePED79u213zin2sOFrZjY2dmhS5cu2Lx5c5mdw9ER2LWLbe6YmAg0bw6MHAnculVmp+RUc44fB/z8AG9vwM6OxTJduZItxC4LLl++DLlcjnbt2pXNCTjVGi5sJWDUqFE4ePAg4uPjy/Q8Xl7AlSvAn38C9+4BLVoA3bsDhw4BfACZU1qkUmDzZsDTE+jRg/1/7Bhw8CBQ1jGHL126BBcXl0J3aOdwSgoXthIwZMgQGBkZYcuWLWV+LrEYGD6cDU8eO8a8KPv0ARo1AoKCgBcvytwEThXj/n1gxgygXj1g3Di2w8TNm8CJE4CPT/nYcPz4cXTp0qV8TsapdnBhKwGGhoYICAjAhg0byvW8Pj5ASAgbJurZE1ixAnByArp1Y5P9JfQ+51QDYmOBn39mvbMmTYC//2ai9vQpsGULyy8vEhMTceXKFfTq1av8TsqpVnBhKyHjxo1DaGgorly5Uu7nbtyYzX+8esUC0jo4AFOmAObmQKdOwJIlAI8Zy4mIYA8/PXqwa+T//o+J2rFjrOy771h+eXPo0CGIxWK1Ox5wONqAu/uXgubNm6NNmzb4/fffhTYFSUnA//7H5keOHGF7ZTVrxoYt/fyANm0APT2hreSUJenpwIULwOHDLFJIRARgYcGWjPTtC/j7M/d9oRk2bBji4+OLtGEkp3IitLs/F7ZS8Msvv2DevHl49epVoTtOlzfZ2cCZM3lC9/w5YGQEtGsHdO3KUps2QBksw+OUI2lpTMjOnGHp2jW2s7WHBxOyvn3Zdy6uQOMy6enpsLa2xrJly/Dpp58KbQ6njODCVolJSEiAnZ0dgoODMWbMGKHN0ciTJ2zpwOnT7Ab44gV7cm/dmqVWrVhycRHaUo4mZDIgLIyJ1/Xr7PXWLSZkjRoBnTsDXbqwh5ZC9i0VnE2bNiEwMBAxMTEwNzcX2hxOGcGFrZIzZMgQvHr1CufOnRPalCITGckE7uJFdoMMDWWu3rVq5Ylcs2aAuzvg5saHMMubjAwmYg8eMPG6fp29ZmSwB5LmzdkDSceOTMysrIS2uOh0794dtWrVKnSDWk7lhwtbJefIkSPw8/PDgwcP0KhRI6HNKRFZWWw5gaIncP06cz7JyQEkEqB+feaw0qgRG+ZycwOcnYEKsqFzpSU+ns2DKURMkZ49Y+sU9fXZ596qVV7P2sODfSeVkcjISLi4uOCff/7BgAEDhDaHU4ZwYavkyOVyODs7Y8iQIVi6dKnQ5miNd++Ahw/ZTTc0lN1wQ0PZsGZODqtjbs4EzsmJvSr+trdn0StMTIR9D0KTmMg8V1+8YAIWEcF6y4q/09JYPQMD9tCgeHBo1IgJmrMzoKMj7HvQJl988QX27NmDp0+fQlJZ1ZlTJIQWNn51lRKxWIzRo0fnbkWiq6srtElaQU+Pxats2lQ5/9079TfpQ4fYa3p6Xt0aNZjIWVkpv9apw4Y9a9dWThX9o8vOZmJVMMXFMQGLiVF+zcrKO7Z27Tzx9/dXfhioW7dqCZg60tLSsHHjRnzzzTdc1DhlDu+xaYFnz56hfv36fIgFbHgtJgaIimI3fMVrdDRbJBwdDSQkAJmZqseamOSJnKEh8+SsWZOJbM2a7H99fSaKACASqcYy1NUFCjqopqSwiPUK5HKWBzCnjNRU4O1bJlzJyew1I4P1qLKy8gQsI0PVZmNj5lJvawtYW7Oeav5XW1sm5mUVc7Gy8PPPP2PevHl48eIFateuLbQ5nDJG6B4bFzYt4evrC7FYXGZR/6samZnqez+JiWxNXmYmE5vUVCY0aWlMWBTiAzCHl/w9RKl0D6RSO2Rnt1U6l7Gxam/Q1JS5wYvF7G9DQzYkaGbGxLNGDSa0BgaqPcv8iTvWvJ+srCy4urpiwIABWLlypdDmcMoBoYWNjwloiUmTJmHgwIF49OgR3NzchDanwmNoyHo1dnbaa7Nx4/kYOHAgFi5s+/7KnHIjODgY8fHxmDFjhtCmcKoJFWjpZuWmb9++qFevHoKDg4U2pdry/PlzODk5CW0GJx8ZGRlYvHgxpkyZAnt7e6HN4VQTuLBpCbFYjMDAQGzcuBHp+cfHOOXC69evkZ6ezoWtgrFy5UpkZGRg+vTpQpvCqUZwYdMi48aNQ3Z2Nv766y+hTal2REZGAgAXtgpEcnIyli9fjmnTpsHS0lJoczjVCC5sWqROnToYM2YMli9fjhzFYi9OuRAZGQmJRMKHuyoQCxcuhFgsxldffSW0KZxqBhc2LTNjxgy8fPkSO3bsENqUakVkZCQcHR35GqkKQlhYGH799Vd8//33MKvuax045Q4XNi3j5OSEoUOHYtGiRZDnXzzFKVMiIyP5MGQF4ssvv4SHhwfGjx8vtCmcaggXtjJg1qxZePjwIfbv3y+0KdWGiIgILmwVhH379iEkJAS//PILdKp6SBVOhYQLWxng4eGBDz74APPnz+e9tnKC99gqBpmZmfj6668xbNgwdOnSRWhzONUULmxlRFBQEB4+fIht27YJbUqVRyaT4eXLl1zYKgDz58/HmzdvsGzZMqFN4VRjuLCVEa6urhg5ciTmzZuHd+/eCW1OlSYqKgpSqZQLm8BcvXoVP//8M5YvXw47bYaU4XCKCRe2MmTBggV49eoV1q9fL7QpVRq+hk143r17h3HjxqFz584YN26c0OZwqjlc2MoQR0dHTJo0CQsWLECyInIvR+tERkbCyMiILwIWkKCgIERERGDdunUQiURCm8Op5nBhK2MWLFgAHR0dLFy4UGhTqiwKxxF+QxWG69ev44cffsCiRYtQv359oc3hcLiwlTU1a9bEggULsHLlSoSGhgptTpWEe0QKR0ZGBkaMGIEOHTrgs88+E9ocDgcAF7ZyYfz48fDw8ODbdpQRfA2bcEydOhWvX7/G5s2bIRbz2wmnYsCvxHJAR0cHK1aswOHDh7F3716hzaly8B6bMOzZswcbN27Exo0b4eDgILQ5HE4uXNjKiS5dumDUqFGYPHkyUlJShDanypCVlYXY2FgubOXM8+fPMX78eAQGBqJ///5Cm8PhKMGFrRz58ccfkZOTg2+//VZoU6oMz549AxFxYStHsrKy8MEHH8DBwQE//vij0OZwOCpwYStHzM3NsWTJEvz222+4fv260OZUCRRr2OrVqyesIdWIyZMn4+nTp/jnn39gZGQktDkcjgpc2MqZMWPGwMvLCx9//DGPSKIFIiMjYW5uDlNTU6FNqRYEBwdj06ZN2LJlC1xcXIQ2h8NRCxe2ckYkEmHjxo149uwZvvvuO6HNqfRwx5Hy4/Lly5g2bRrmzZuH3r17C20Oh6MRLmwCUK9ePSxevBhLlizBtWvXhDanUsNd/cuHFy9eYODAgeIDjHwAACAASURBVPDx8cH8+fOFNofDKRQubALx6aefokuXLhg7diyysrKENqfSwntsZU9aWhr69euH2rVrY+vWrXy9GqfCw69QgRCJRFi/fj2ioqIwffp0oc2ptGhD2G7fvo3evXvDzMwMJiYm8PHxwYULF7RkYeVGLpdjxIgRiI6OxoEDB/hcJqdSwIVNQOrVq4f169dj1apVfOF2CUhJSUFycnKphO3KlSvo0KEDTExMEBYWhsjISDg7O6Nr1644evSoFq2tnHzxxRc4evQoDhw4AGdnZ6HN4XCKhIiISGgjqjuBgYHYtWsXbt26xd3Wi8GtW7fQokULPHr0CK6ursU+Xi6Xo2nTpkhMTMTTp09haGgIgG1c6uHhgbdv3yI8PBz6+vraNr1S8OOPP2L69OnYsWMHhgwZIrQ5nEqEN7zREA2xGquFOP1q3mOrAKxYsQJ169bFhx9+CKlUKrQ5lYbIyEiIxWLUrVu3RMefPXsWoaGhGDx4cK6oASwE2rBhw/Dy5UscPHhQW+ZWKrZs2YLp06dj+fLlXNQ4lQ4ubBUAAwMD7Nq1C2FhYdzjrBhERETA1ta2xD2qkydPAgBatWqlUqbIO3HiRMkNrKQcPHgQY8eOxezZs/Hll18KbQ6HU2y4sFUQXF1d8csvv2Dp0qV8bqeIqHMcefjwIQYMGABTU1MYGRmhTZs2OHjwIHx8fCASiSASiTB+/PjcugBgb2+v0radnR0A4PHjx2X8LioWly9fxtChQ/HRRx/h+++/F9ocDqdESIQ2gJPHxx9/jFOnTmHkyJG4desWbG1thTapQlNQ2J48eYL27dujRo0a2L17N9q3b4/nz59j2rRpuHv3LvT19ZWWVih2Na9Ro4ZK28bGxgCApKSkMn4XFYcbN27A398fPXv2xB9//ME3buVUWniPrYKxevVqmJqaYuTIkcjJyRHanApNQWGbM2cOkpOTsWLFCvTo0QPGxsbw8PDAtm3bkJGRUay2FT5V1eXmfufOHfj6+qJ169bYtm0bdHR0hDaJwykxXNgqGCYmJti1axeuXLmCL774QmhzKixEhBcvXigJW0hICADA19dXqa6FhQUaNmyo0oaZmRkAqBU9RZ6iTlXm4cOH8PX1RfPmzbF//34YGBgIbRKHUyq4sFVAmjdvjr/++gurVq1CcHCw0OZUSGJjY/H27dtcYcvOzkZaWhoMDAxyhxHzU6tWLZU8hdhFRUWplEVHRwNAiZYRVCYeP34Mb29vuLi4YN++fUreoRxOZYULWwVl0KBBmD9/PqZOnYpTp04JbU6FQ7FdjWLRsL6+PkxMTJCVlYX09HSV+q9fv1bJ69atGwA2t1QQRV737t21ZnNF4969e+jcuTOcnZ0REhKi9oGAw6mMcGGrwHz77bcYNGgQAgIC8OTJE6HNqVBERkZCT09PycHG398fQN6QpILY2Fi13o1dunSBu7s7du/ereRUIpPJsGPHDjg4OFTZKPY3btyAt7c33NzccOjQIS5qnCoFF7YKjGKLG2dnZ/Tr1w8pKSlCm1RhiIiIQN26dZUC8i5atAi1a9fGtGnTcOzYMaSnp+P+/fsYO3YsrK2tVdoQi8XYsGEDEhMTMXbsWMTGxiIhIQGTJ09GeHg41q1bVyXnm86fPw9vb2+0bt0aISEhqFmzptAmcThahQtbBcfQ0BD79u1DSkoKhg0bBplMJrRJFQJ1a9jq16+PS5cuoXXr1hg8eDCsrKwQGBiI2bNna9wUs127drh48SJSUlLg5uaGevXqITw8HKdPn1ZxQqkKHDt2DH5+fvDx8eFzapwqC1/HVgmwtbXF33//DW9vb8ydOxeLFy8W2iTBiYyMhJubm0q+q6trsQNKe3p64tChQ9oyrcKyc+dOjBo1CkOGDMHGjRshkfCfP6dqwntslYQOHTpg7dq1WLp0KVavFiSwaIWC78NWPH777Td89NFH+OSTT/Dnn39yUeNUafjVXYkYPXo0oqKi8Nlnn8HCwgIBAQFCmyQIUqkUUVFRXNiKABHh//7v//Ddd99h/vz5WLBggdAmcThlDhe2SsbcuXPx5s0bjBgxAmZmZujRo4fQJpU7L1++hEwmK5Kw7dixA8OGDcv9XyQSYdy4cVi/fn1ZmlghePfuHSZOnIht27Zh06ZNGDVqlNAmcTjlAhe2SshPP/2EhIQEDB48GKdPn4anp6fQJpUrBdewFcbQoUMxdOjQsjapwhEfH49Bgwbh7t27+N///gc/Pz+hTeJwyg0ubJUQkUiEDRs24PXr1/D19cWFCxfQoEEDoc0qNyIiImBiYgJzc3OhTamQ3L9/H/369YNIJMLFixfh4eEhtEkcTrnCnUcqKbq6uvj777/h6OgIf39/xMXFCW1SucEdRzQTEhKCTp06wdbWFpcuXeKixqmWcGGrxJiYmODff/+FSCRCnz59kJqaKrRJ5QIXNvWsWLECffr0weDBg3Hy5ElYWloKbRKHIwhc2Co5VlZWCAkJQXR0NHr16qU2TmJVgwubMu/evcPYsWPx1VdfISgoCOvXr4eenp7QZnE4gsGFrQpQv359nD59GhEREfDz86vy4saFLY+EhAT07NkT//zzD/bs2YOZM2cKbRKHIzhc2KoIrq6uOHXqFJ4+fQp/f/8qK24ZGRmIj4/nwgYWyLhly5aIiorC5cuX0a9fP6FN4nAqBFzYqhBubm44deoUwsPD0atXr2LvGl0ZePbsGYioSK7+VZnffvsNHTt2RIMGDXD58mW4u7sLbRKHU2HgwlbFaNiwIY4ePYoHDx5g4MCBStuxVAUiIiIAAHXr1hXYEmFIS0vDsGHDMHXqVEybNg0hISGoU6eO0GZxOBUKLmxVkKZNm+L48eO4efMm+vfvX6XELTIyEpaWltVy/7Bbt26hRYsWOHHiBEJCQrB48WLo6OgIbRaHU+HgwlZFad68OUJCQnD16lUMGjQImZmZQptUbC5evIhNmzbhzJkzePHiBeRyebV1HPnrr7/QsWNH2NnZ4fbt2+jZs6fQJnE4FRYeeaQK06pVKxw9ehT+/v7w9/fHgQMHYGJiIrRZRSY2NhZjx47N/V8ikcDExAS1atXCJ598Aicnp9zk6uoKU1NTAa0tG9LS0hAYGIgdO3ZgxowZCAoK4r00Duc9iIiIhDaCU7aEhYWhR48esLa21jgnk5WVheTkZLU7TQvFy5cv4ejoqLZMV1cXYrEY7969AxHh4MGD6N27dzlbWLbcunULH374IVJSUrB161b4+PgIbRKHUyS84Y2GaIjVEGSLrdV8KLIa0KhRI5w7dw7Jycno3LkzoqOjlcqJCKNGjcLnn38ukIXqcXBw0BgPUiqVIjs7G2KxGJ6enlVK1GQyGZYsWYL27dvnDj1yUeNwig4XtmqCk5MTzp07B7FYDC8vLzx9+jS3bNasWdi9ezf+/vtvXLx4UUArVenQoQPEYs2XqUwmQ1BQUDlaVDrCwsIKLX/27Bm6d++OefPmYdasWTh+/DhsbGzKyToOp2rAha0aYWNjg5MnT8LU1BReXl4IDQ3F+vXrsXTpUhARdHR08Mknn0Aulwttai5t27bVuNuzjo4OmjdvXmm2ZFm9ejW6du2KpKQkteV//fUXmjRpgjdv3uDKlStYsGABn0/jcEoAF7ZqhqWlJU6ePIl69eph/PjxCAwMzC3LyclBaGgotmzZIqCFyrRu3Rrv3r1TWyaTybB48WKIRKJytqr4nD9/HlOnTkV8fDxmzZqlVBYXF4f+/ftj7Nix+Pjjj3Hjxo1qt8ceh6NNuPNINeXKlSvw9vZGVlaWUg9NJBLBwsICERERqFGjhoAWMpKTk1G7dm0UvEx1dHTg6emJa9euCWRZ0Xn16hWaNWuGxMREyGQyiEQinDt3Dh07dsTu3bvx6aefwtjYGH/++Sc6d+4stLkcTqnhziOccic6Ohr9+/fHu3fvVIYdiQiJiYlYunSpQNYpY2ZmptYzsrLMrWVnZ6NPnz5ITk6GTCYDwET5448/xkcffYQhQ4bggw8+wL1797iocThaggtbNSM1NRU9evRAYmIicnJy1NbJycnB4sWL8fz583K2Tj2dOnVSmmfT0dFBq1atKsUi5UmTJuHOnTuQSqW5eTk5OXj69CmioqLw77//Ijg4uFpGUuFwygoubNUIqVSKQYMGISwsTOlGqw4iUpkLEoo2bdoozaPJZDL88MMPAlpUNFatWoWNGzfm9tTyI5PJcOXKFbi6ugpgGYdTteHCVs0IDAxEt27dIBKJoKurq7GeVCrFzp07cfny5XK0Tj2tW7fOFWIdHR20bt26wq/runjxIqZNm6YyN5gfIsLEiRPL0SoOp3rAha0aoauri4CAAJw8eRIvXrzAwoULYWVlBZFIpNatXEdHB5MnTy705lweeHp65g5FVobeWlRUFPr16/fez00qleLUqVPYtm1bOVnG4VQPuLBVU+zt7TFz5kxER0fj6NGj6NevH8RisVIvLicnB7du3RL8xmtgYIBGjRoBANq3b4/u3bsLak9hZGVloX///khNTVU7BJkfHR0diEQifPHFF0hMTCwnCzmcqg8PglzN0dHRgY+PD3x8fBAZGYn169dj3bp1ePPmDSQSCaRSKb7++msMHDgQRkZGRWozPR2QSoGsLCAzE8jJAdLS8spTUgBNa8AzMgB1y9asrTvi3r17GDDgexw/rv7YGjUAPT32t64uYGwMiESAmRnLMzEBNKz11hoKZxF1oqanp4ecnBzI5XKYm5ujbdu26Ny5Mzp27Fjkz5bD4bwfvo6tmpOSAiQmAgkJQHIy+z8lRYorVw7i1Kk1ePLkOIgInp4L4OLyLVJSmPikpzOxyi9aGgJqaImNAP4EcLrULRkaAgYGTORMTPJE0MyMvdaokfe/4u/8/5uaArVr5yWFmK5atQpTpkwBwNYDKh4MdHR04Obmhu7du6N9+/bo2LGjxuDOHE5VQOh1bLzHVoV4+xaIjWXp9WsgJoYJVmKicsqfp260zMhIFzVqDISJyUC4uz9DauoGPHq0BXZ24+DgYI8aNfJu8GIxewXy/jcyAvT12Q2/Rg3lOkCesKhDcUxB7t9vjdevnVBYQI7kZEDxmJadzT4PmQxITWV5ip6ioleoqJOdzfKSk5lgZ2Swzy8pif2tEPL87eeHieE5vH49DQCgq1sTNjYd4eTUCe7uHdCiRWs4OtaAjQ1gackSh8MpO3iPrRKQnQ28fAm8eMHSy5dAfDzw6pWyiKWnKx9nbg5YWCj3Lgomc/O8VzMzltRFqMrJyUFCQgKsrKzK500XgIgqROist2/zermK9Pp1Nnbu/A6Ghi4wNm4PmcwNCQmi3IeI16/Zd6hAImHfi5UVYGvL/raxAaytAUfHvGRhIdz75HBKg9A9Ni5sFYCMDCA8HHj+PC/lF7JXr/LqGhgADg7spmhtzZKlJbtBWlnl/W1pmTdExhGepKS8h5DoaPZgEhvLvlvFg0lcHMtTYGgI1K3LRM7Bgb3Wq8denZ1ZXgXQeg5HBaGFjQ9FlhPv3gFRUUBEBBAaCjx4wP6OiACePctzpqhVi920bGyAZs2AgQPz/re1ZTe2QnZx4VRQatVi6T/nTo0orpOYGCZ6imskJga4fRt4/DhvTlNPD7C3Z9eHuzvg4cH+dnbm1wmnesOFTctkZzPRuncPuH8fuHuX/R8VxeZnRCL2pN2gAUt+fuzV1ZXdjDTNPXGqB3p6eeKkibg44MkT1stXpHPngD/+yBuONjIC3NyAJk2Axo3ZQ1LjxuzhiMOp6nBhKwWvXgHXrzPxunuXCdnjx8xTUE+PPUU3bgxMnsyEq0EDwMWFixendFhZsdSxo2pZTEye2D18yK7LY8fyhrPNzYGmTdl12aQJ4OnJRK+QIDQcTqWDC1sRycgAbt0CbtzISw8esDIbGzYM5OMDzJzJ/vbw4ALGKX9sbVnq0kU5PzmZPXg9eMCGwm/cADZuZD08XV320NWpExPLli3ZQxmfv+NUVriwaSA2Fjh5Ejh9Grh8md0QZDLmrNGmDfDRR+y1TRtlV3YOpyJiZsaEq1OnvDy5HHj0CLh6laUrV5jYSaWsZ9emDRM6b2+gdeuyX9zO4WgL7hX5H0lJwJkzwIkTTNAePGBPsm3bAu3b54kYX1fLqcpkZbGRCYXYnTnDvDhNTFgv0NubpaZNeY+OoxmhvSKrtbDduwfs3QscOMB+zERszkHx4/XyUr9YmMOpTjx6xB72Tp4ETp1ia/Pq1AF69GBeu/7+bJE6h6NAaGGrVoMLcjkbbtm7l6UnT9h8RL9+wJw57Im0dm2hreRwKhZubix9+in7Dd25w0Tu33+BYcPYyIZC5Pr1Y8OYHI6QVIseW3g48PvvwLZtzGvMxQUYNIj9ENu04et9OJyS8uYN8L//sQfF48eZR3C3bsC4cez3xYMEVE+E7rFV2Vv6u3fArl3MU9HNjf09YQJzfw4PB5YsAdq146LG4ZSGOnWAjz9mw/mvXwNbt7KIKcOHs/Was2YBT58KbSWnulHlbuuJicC33zInj48+YgtVDxxg0RsWLGBrdzgcjvYxMQGGDAH272fRdCZNYkLXoAHQsyc0bjfE4WibKiNsqalsnqxePWD1aiAwkP24/vc/oHdvQM0G0WVKTk4ONmzYgDZt2sDc3By1atVCy5Yt8dtvv+Gdug3H8iGTyTB79mw0aNAABgYG8Pf311j32rVrGDNmDJycnGBoaIjatWujcePG+OCDD7BmzRo8LfC4LJPJEBwcjA4dOsDU1BS6urqwtbVFr1698Ntvv+HZs2e5da2trSESiZTSw4cPldobPHgwRCIRoqOjlfK/+eYbpeMWL16sVB4eHg6RSIR27dppfG/GxsYq5xeJRBCLxbCwsMCAAQNw7do1jcc/f/4c/fr1Q6oivP9/3L59G71794aZmRlMTEzg4+ODCxcuaGynMA4dOgRXV9fcHb6LQ1JSEoKDg+Ht7Y3atWvD0NAQDRo0wPDhw3Hnzh2V+rNmzcLOnTs1tjd27Fjo6+vDyckJn3/+ObKysoptk7awt2cPmM+eMaED2Dxchw5sCQ2HU6ZQJUcuJ9qwgcjKisjcnGjpUqK0NKGtIhoxYgQBoNmzZ1NcXBy9efOGlixZQgCoT58+hR67du1aAkDfffcdJSUlqa0jk8no66+/JolEQtOnT6ewsDDKysqi2NhYOnr0KPn4+BAAAkBSqTT3uGHDhpFYLKYlS5bQy5cvKTMzk548eUJz5swhkUhE5ubmSuf5/fffCQBNmzZNxYacnBwyMzMjALRhwwaV8oSEBDIzM6N3796plM2ePTvXvtDQUI2fxa1btwgA9e/fPzcvOTmZ9uzZQ5aWlqSrq0vHjh1Te1ydOnXo119/Vcq/fPkyGRoa0ocffkgxMTEUHx9PEyZMIIlEQkeOHNFoR0GePHlCffv2paZNm1LNmjVJR0enyMcqGDduHEkkEvrll1/o1atXlJGRQWfPniV3d3fS0dGhvXv3qpzTycmJvvnmG41tpqamUnBwMAGgoKCgYttUlly6RNSzJxFANGgQ0YsXQlvEKSu6UTf6lD4V6vSrKrWwRUcT+fkR6egQTZ1KlJAgtEWMp0+fEgDy9PRUKevRowcBoKtXr2o8ftiwYQSAUlNTNdaZM2cOAaDff/9dbXlOTg75+/srCdvVq1cJAE2YMEHtMZMmTVIRthcvXhAAatiwoUr9CxcukJGREQGggIAAlfIdO3YoCZICmUxGdnZ25OnpSQDo66+/1vg+1Qmbgi1bthAA8vDwUMpPSUkhe3t7CgwMVDmvh4cH2djY0Nu3b3Pzc3JyyM3NjRwcHCgrK0ujLfkZNmwY/fDDDySVSsnOzq7EwjZx4kSV/Nu3bxMAatCggdoykUhEO3fuLLRtIyMj6tmzZ7FtKg8OHSJycyMyNSX680+hreGUBVzYSsiNG0R2dkQNGhBdvCi0NcqcPn2aANBHH32kUvbZZ58RANq9e7fG43v27FnojTIsLIzEYjG1bNmyUDsuXryoJGwbN24kALR8+XKNdhcUNiKiRo0aEQB6/vy5Uv78+fPpyy+/JGNjY6pVqxbl5OQolY8dO5ZWr16t0t7hw4epbt26dO3aNQJAVlZWSr3K/BQmbNHR0bm9vvw927lz55JEIqHo6Gil+qdOnSIA9Nlnn6m0tWDBgvd+L/nJL4wlFbbCMDQ0JLFYTHK5XKUsICCA7O3tNX5mRES2trbvvT6E5O1boi++IBKJiD77jKjApcOp5AgtbJVyju3OHaB7d7YFyNWrLDJIRaJhw4bQ1dVVmY8CgIcPH0IkEqFJIV4sMnXbWufj999/h1wuR0BAQKH12rdvDyLKnf9RbBJ67NgxtfW7dOmCN2/eqOT7+fkBAEJCQpTyQ0JC0LdvX3h7eyMpKQlXr15VKj969Gjusfn5448/MGbMGLRq1QpNmzZFXFwcDh06VOh7UQflW6mi2ISUiLB+/Xq0bdsWtgVC2Z88eRIA0KpVK5W2FHknTpwo0rkNDQ2LbW9RycjIQGZmJho3bqx2c9WBAwciKioK//77r8Y2RCIRcnJyyszG0mJoCPz0E/NW3rABGDUqb+smDqe0VDphe/2aeVi1a8cWiJqZCW2RKlZWVli+fDnu3LmDOXPmID4+HomJiVi6dCmOHz+O+fPnw9XVtcTtnz17FgDQtGnTYh3n5eUFa2trHDlyBP7+/jh9+jTkRbib+Pr6AgCOHDmSm5eYmIiHDx+iQ4cOasvv378PIyMjODk5KbWVmJiIAwcOYPTo0QCYwwPAxK64nP7PC8HDwwOm/wXsvHPnDuLi4tCsWTOV+ooHDXt7e5UyOzs7AMDjx4+LbYe2+fvvvwEAc+fOVVvevHlzAMqfd2Vl8GBg3z7gn3+AoCChreFUGYTqK5aUkSOJ6tYlKmT6qcKwa9cusre3zx0uq1Onjloni4J4eXmRkZGRxnIbGxsCQFeuXCm2TefOnSMHB4dcmywtLWn48OG0bds2ysjIUHtMZmYmGRoakqmpae7w144dO6hv375ExJwaAFDbtm1zj1m+fDlNmTJFpa1ff/2VunXrlvt/fHw86erqkkQiobi4OJX66oYiU1JSNDqPbN68mQDQokWLVNpSzG9evnxZpSw8PJwAUIsWLdR+BoWhzaHI2NhYsrKyovHjx2usk5KSQgDIy8tLYx1nZ2dyd3fXik3lwYoVRHp6RGFhQlvC0QZ8KLIYxMUBO3awJzsTE6Gt0QwRYeLEiRg+fDi+/PJLxMbGIj4+HkFBQZgyZQqGDh1a6DDRixcv1PYqCqJumOp9dOrUCeHh4fjzzz/Rv39/ZGZmYuvWrfjoo4/g6OiIHTt2qBxjYGCAzp07IyUlBZcvXwbAeguKnlr9+vVRv359XLt2DYmJibnl6oYhN27cmNtLA4A6deqgT58+yMnJwebNmzXavX///lx3fzMzM0yYMAHt2rXDhQsX4OPjk1vv1X8bj5kWc8sF+m9YsySfqbZISEiAn58funbtiuDgYI31atasCZFIlPte1WFra4vo6OgKPRyZnylT2FKdNWuEtoRTFahUwnb5MgvZM3Cg0JYUzubNm7Fu3Tp88skn+OKLL2BlZYU6depg4sSJuWuRfvvtN5XjEhMTsWzZMjx//hyTJk3S2L5i7kjdfFhR0NfXx6hRo7Bv3z4kJibixIkTGDp0KBISEjBixAjcunVL5RiFiCnm2QrOn/n5+UEul+PYsWPIzMzE1atX0bVrV6U27t69i/DwcHzwwQdK+Qqh27hxo0ab+/fvDyICEUEul+PNmzfYv38/WrdurVRPsXZLV83OmWb/jVtnZGSolCnyzAQa287IyICvry/c3d2xdetW6Lxn4aVEIkFmZqbG8sDAQKSmpmL+/Pklvk7KE7GY/a7/G2XncEpFpRK2pCQWScTISGhLCkdx88/fk1DQvXt3AMDhw4eV8seMGQNzc3PMmjULM2bMwNSpUzW23+W/XSTv3r1balslEgm8vb2xfft2zJw5EzKZDLt371appxCxI0eO4N69ezAwMED9+vVzy/PPs505cwatWrVCjQJbI/zxxx9IS0tDjRo1lBZc9+vXDwAQGhqq4oBSXAz+291VKpWqlDVs2BAAEBUVpVKmWGBemrnPkpKTk4OAgADY2dnhzz//fK+oKY4pzIFlxIgRCAoKwrJly2BhYaG291zRsLBgOwdwOKWlUglb3bpsJ+sXL4S2pHDU9QgKkp6ervT/pk2bkJKSgh07duCnn35CYGCgxmMDAwMhkUjUClB+ZsyYAbFYnOs0ceHChVzPSHV069YNAIuIUZBGjRrBwcEBN27cwJYtW3KFLP+xenp6OHLkCEJCQlTKpVIptm7digsXLuT2vPKnadOmASi811YUbGxsAAApKSka39+NGzdUyhR5igeP8iQwMBDZ2dnYtWuXUgQTFxeX3KHf/KSmpoKIct+rOubOnYs5c+ZgzZo1SE5OVvForYiEhgIFfI04nBJRqYStUyfAyqrij8O3bdsWgHrXcYXLubpQUjVr1kRAQAA8PT0LFS1XV1d8++23uH79ukZvwkePHmHt2rUYMmRIbk+FiPD69Wu1N0sAuH79OgDA09NTbbmvry+ICCtXrlTpARgbG6Njx46IiYnBpk2bVITtwIEDqFOnDjp06KC27XHjxgEAtm/fXugQ2/to3LgxAPW9si5dusDd3R27d+9WCjclk8mwY8cOODg4oHfv3iU+d0lYsGABQkNDsX//fujr6xfpGEXvUvFe1bFnzx44OTlh/PjxxZ5vFIL4eGD3bqDAKDWHUzKEcVopOQrvqevXhbZEM0lJSdSgQQPS1dWlFStW5IbUWr9+PRkZGZGdnR3FxMRoPL579+5F8rKbNWsW6erq0syZM+nRo0eUnZ1NUVFRtH79erKxsaFOnTpRenp6bv1z584RAHJwcKCtW7dSdHQ0ZWVlUWRkJC1btoz0/vkS8QAAIABJREFU9PSoZcuWGqNv7N69mwCQrq4upamJW7Z48WICQDY2Niplffr0oaVLlxb6ftq0aUMAaMuWLbl5hS3QVodcLidLS0vq2LGj2vJLly6RgYEBDR06lF69ekVv3ryhwMBAkkgkFBISolJ/+PDhBIAiIiI0nrMoXpHq2lEsmC8sXbp0SaWtbdu2EQCVkFsFbWrWrFmhNlUU5HIWYquyeDtz3o/QXpGVTthkMhZGy9KS6MEDoa3RTGJiIk2fPp0aNmxI+vr6pKenR/Xr16cpU6ZQbGxsocf6+PgU2X386tWrNHLkSHJwcCBdXV0yMTGhdu3a0YoVKyg7O1uprkwmo/Pnz9PXX39Nbdu2JVtbW5JIJGRiYkKtWrWiRYsWaXT5J2IxGiUSCXXt2lVtuUKExowZk5v38uVLpRt1/iUBCiIjI1Vu6FZWVlSjRg2VfDc3t/d+JnPmzFEbeUTBzZs3yd/fn2rWrEnGxsbk7e1N58+fV1vX29ubjI2NVaKqHDhwQKMYrVu3rkjt9O7du0TCFhAQQHZ2dmpjcCqws7Oj5s2bayyvKMjlLPKIvj7R6dNCW8PRFlzYSkB6OlGnTkRmZkTFiFtbaejduzeJRCKhzai0JCcnk52dnUqsyOKSlJREhoaGha4pK892iPJiRW7fvr3QelZWVtSuXbtSn68sSUsjGjyYjcD8/bfQ1nC0idDCVqnm2BTUqAEcO8a2o/H3B6ZNA96+Fdoq7WFvbw8iQlxcnNCmVEpMTU1x4MAB7N69G6tWrSpRG0SEqVOnombNmli4cGGJbdFWOwAQERGBQYMGYfbs2Rg6dKjGelKpFImJiUVaCykU584BzZuzLWyOHWMRSDgcbVEphQ0ADAyALVvYgu3NmwFXV+Cvv4B84QMrLQrHjMWLFyOB+z+XCE9PT1y/fh2HDx9W2Y+tKMTFxSEiIgInTpyAtbV1ie3QVjsAsHbtWgQFBSGokNhTKSkp+OmnnyCVSiuki390NNsrsWtXtgHp7dtA585CW8WpcgjVV9Qm8fFs2xodHaImTdhWGDKZ0FaVjiVLllCjRo1IX1+f/Pz8hDaHUwkYPXo06erqkouLC82bN09lXlBI4uKIZs4kMjQkcnBgv1E1GxdwqghCD0WKiKpCH4dx5w7w3XfA3r2AmxswcSIwejRQu7bQlnE41ZOzZ4Hff2eu/HXqADNnst9lEVc2cCop3vBGQzTEaqwW4vSrK+1QpDqaNWNRwu/eZUMdCxYAdnbAyJFsTJ/D4ZQ9iYnAzz8D7u5Aly7A48fAqlXA06fAZ59xUeOUPVVK2BQ0bswWcUdHAytXAg8fsnH8hg2BOXOA69erxlwch1NRSEpic9wDB7KHyQULmKjdvMn2TBw3jgsap/yoksKmwNgYmDABuHaNiVmvXsD27UDr1iyS+OefA2fOAO/Z15PD4ajh1SsgOJjtj2hlxX5r2dmsdxYdzR4uNQSx4XDKlCo1x1ZUbt5k83B797L4dHXqAN7eealBA6Et5HAqHhkZwPnzwMmTLN28yXbC9vcHBg1iD46VIHoXpxwQeo6tWgpbfh4/Bg4cYD/Us2eB9HTAwUFZ6CrwciAOp8x49w64cgU4cYL9Pq5cYXmNGrHfRc+eQI8eTNw4nPxwYatAyGRsXc3x4yydPw9kZQE2NkDLlnmpUyegVi2hreVwtEtMDHDjBnDhArv2b94EMjPZ9d+pE+DjA/j5AY6OQlvKqehwYavAZGayzU0vXWIT4FevsnkFHR3m8dWmDUvNmwMeHiwiCodTGYiMBO7fZ0KmuLYTEgBdXXY9K67tjh2BfNvucThFQmhhk7y/TvXF0BDo1o0lBS9fspvA5cvsdedONnwpFrO9pJo0YV6ZTZuy1wYNAAn/lDkCkZjIlr/cvw/cu8dSaCigCMZSvz7Qti0wbx4TMk9PFtWHw6nM8B5bKZHLgYgI1ZvHkydsaFNfn81JuLoCLi5M6Fxd2auFhdDWc6oC796xHtjjx0B4eF4KC2PDiwAbOi/40NW4MXf24JQNvMdWyRGLmWC5uDDPMAVZWezJ+P599hoeDuzfzxapKva4NDNjAufiwsTO2ZnNXzg4MIcVvu6HoyA+no0WvHwJPHvGHpwUAvb8ed6SFRsbdk01aMCcOxQixh2gONUJLmxlhIFBnrNJfuRydnPKf2MKD2dDms+e5YmeSARYW+cJnaMjS3XrAra2LFlaAnp65f7WOFomKQmIjWXztwrhUojYixdMuPJvKm5tzR6CXF1Z4AHFSECDBmztJodT3eHCVs6IxUyc6tYFundXLY+Ly7uh5b/JnTvHXmNjlevXqcMWx1pZMbGzsGCRHywt2Q3Q0pLFyqxdmzu3lBcyGZvbUqTXr9mC5dev8wQsf152dt6xBgbs2lA8zHTooPy/gwOfA+Nw3gcXtgqGQqRatVJfnpXF5k1iY5Vvjq9esbzwcFZe8IYJsKFNhchpSiYmTACNjdlQqeJvxf8iUdl/BkLz9i1bjJyWBqSksL/T0/P+T0tTFi5FSkhgrykpqm2amys/gNSvz4YN8+dZWbEHEQ6HUzq4sFUyDAzYMJSz8/vrJiYCb96ovwn/P3t3Hh/T1f8B/DOZyTLZV9lbQUgipGqnikgRsXSRluapSqWNUqULYqmiD21/7YMu1orytDxBVLUoKooi9q2WWGJrgsi+yTYz5/fH6SQZM9lmJnNnxvf9et3XJPfeOed7R9zvnHPPPVe53L8PXLpU83th4aeQyfoD6KGxTFtbnuwcHPjAAwsL/rNEwkeR2tjwnx0c+P7K+/2U+yjZ2dXdjaos91GlpXyghCaFhbybV6m4GJDJeBdeeTlQVSVHSYkYAO/6q73Pw4c8cZWUAAUF9c8j6uTEj6X2l4EnnuBD5DV9UXBz461oul5KiOFQYjNjypNrY8jlckycOBGrV6/G6tWr8eKLPVBQwE/2yhZLfn7Nz6WlNQlCmVSUiefhQz7YQaGoab08mnge/V2Jv+dXAFcBfKCyzcqq7u5UW1vV5KFMnNbWwN27M1FZmYnevdcB4POEWljUvMfGhrdIHR35Ym/P3+/oyBOZstWqTNaEEONGiY3g4cOHGD16NPbu3YuffvoJw4cPByDc7CqTJ+/FqVOncOjQBw3v3AjJyU/j5Zc/w4cfTkS3bt30UiYhxHiZ9ez+pGElJSWIiorC4cOHsXfv3uqkJqTs7Gx46PEmv5EjR6JPnz6YMmUK6LZNQswfJbbHWGFhIQYNGoRLly5h37596Nmzp9AhAdB/YgOAJUuW4NixY9i4caNeyyWEGB9KbI+p/Px8RERE4Pbt2zh48CA6duwodEjVmiOxderUCWPGjEFCQgLKat8URggxO5TYHkPFxcUYMmQIsrKycODAAbRr107okFTk5OTA3d1d7+UuWLAA2dnZWLVqld7LJoQYD0psj5mysjKMGDEC6enp2L17N1ob4dTtOTk5em+xAYCPjw/eeustfP7559RqI8SMUWJ7jMhkMowcORLnzp3D3r17ERwcLHRIaoqKilBRUdEsLTYAmD59OgoKCrBmzZpmKZ8QIjxKbI+RCRMm4MCBA/jtt9+M6ppabdnZ2QDQLC02APDy8sK4cePw+eefo+LRqVkIIWaBEttj4rPPPkNiYiJ++OEHo76XKycnB0DzJTaAt9oePHiAtWvXNlsdhBDhUGJ7DCQnJ2PmzJlYtGgRXnjhBaHDqZeyxdZcXZEA4Ofnh7Fjx+LLL7+EQtP0J4QQk0aJzcxdunQJsbGxePvttzF58mShw2lQdnY27OzsYGtr26z1TJ48Genp6UhJSWnWegghhkeJzYyVlJQgOjoaoaGhWLx4sdDhNEp2dnazttaUgoOD0bt3b6xcubLZ6yKEGBYlNjMWGxuL3NxcbNmyBVYm8kTS5hrqr0l8fDy2bduGzMxMg9RHCDEMSmxmKjExEVu3bkVSUhJ8fHyEDqfRmmPWkbpER0fDxcWFhv4TYmYosZmhmzdv4r333sOHH36Ifv36CR1OkxiyxWZtbY3XX38dq1evpkEkhJgRSmxmRqFQIDY2Fv7+/pg7d67Q4TSZoa6xKY0ZMwZ37tzB8ePHDVYnIaR5UWIzMytWrEBqaio2bNgAGxsbocNpMkN2RQJAhw4dEBgYiG3bthmsTkJI86LEZkZyc3MxZ84cvPfeewgLCxM6HK0YusUGAMOGDcPPP/9s0DoJIc2HEpsZmTp1KqRSKWbPni10KFqpqKhAcXGxQVtsADBixAikpaXhypUrBq2XENI8KLGZiePHj2Pt2rVYtGgR7O3thQ5HK4aYTkuT3r17w8PDg7ojCTETlNjMxEcffYRevXohOjpa6FC01twTINdFLBYjKioKO3fuNGi9hJDmIRE6AKK7I0eOYM+ePSY/PZQh5omsy7PPPouNGzeisrLSZG5mJ4RoRi02MzBnzhz07t0b4eHhQoeik5ycHEgkEjg7Oxu87t69e6OsrAxnzpwxeN2EEP2iFpuJO3XqFFJSUky+tQbwUZ1ubm4QiUQGrzswMBCurq44ceIEunfvbvD6CSH6Qy02E7ds2TKEhISgf//+OpWzc+dOtG3bFhKJcN918vLy4OLi0uT35efnY8WKFQgPD4erqyukUikCAwMRExODc+fONaoMkUiEDh064MKFC02u/1Fnz55FVFQUnJ2d4eDggIiICBw+fFjncgkhjUOJzYSVlpYiKSkJEydO1LqVk56ejuHDh2PGjBnIysrSc4RNU1BQoFVimzp1KiZNmoQRI0bg0qVLyM3NxZo1a3D27Fl07ty50feohYaG6pzYjh07hl69esHBwQGXL1/GzZs30apVK/Tr1w979uzRqWxCSONQYjNhe/bsQXl5OV566SWty1COpjx16hQcHBz0GF3T5efna5XYAOCNN97A5MmT4eXlBVtbW/Tp0wcbNmyAXC7HtGnTGlVGUFAQrl69qlX9AJ/ObNy4cXB2dsb3338Pb29vuLu7Y/ny5WjdujXi4uJQUVGhdfmEkMaha2wmbMeOHejRowc8PT21LiMxMRFSqVSPUWlP28S2evVqjevDwsIglUqRnp4OxliDrVo/Pz/k5OSgvLxcq+nIDh48iIsXL2LSpEkqn6lYLMbo0aMxd+5cbN++XacvIoSQhlGLzYQdPnwYAwYM0KkMY0lqAE9s+hwRWVpairKyMoSGhjaqq9bX1xeMMdy7d0+r+vbt2wcA6NKli9o25TpzGORDiLGjxGaiCgsLcfXqVbWTaFpaGp5//nk4OTnB1tYW3bp1w/bt2xEREQGRSASRSIS4uDiBoq5f7Wts+jiOzZs3AwBmzZrVqPqVN4YrZ0BpahxpaWkAeMvvUb6+vgCgU1cnIaRxqCvSRF29ehUKhQKhoaHV665fv46ePXvCzs4OycnJ6NmzJ27fvo0pU6bg/PnzsLa2Rnl5uYBR10/ZYtPHcWRlZSEhIQFxcXF4+eWXG1W/nZ0dAN7SA5r+eRYUFKiUU5tymrP8/PxGxUII0R4lNhN1584dWFhYqLQOZs6ciYKCAqxevRrPPfccAKB9+/bYsGEDWrZsKVCkjae8xqbrceTm5mLw4MHo168fVqxY0ej6lQmppKQEgH4/T8YYAAhyjx4hjxvqijRRDx48gKurq8r0T7t27QIADBo0SGVfDw8PBAUFGTS+ppLJZCgtLYWLi4tOx1FaWopBgwYhJCQE69evh1gs1jqmpsahvD6obPE9GlftfQghzYcSm4kqKytTGbmnfOSLjY2Nxtn9tR1GbygFBQVgjMHe3l7r45DJZIiOjoavry/WrVvX5KSmHIpvY2Oj1eepTHYZGRlq2zIzMwEAbdu2bVJMhJCmo8RmomQymcosIdbW1nBwcEB5eXl1V1ptDx48MGR4Taa89uTh4aH1ccTHx6OiogKbNm1S+WzatGmDo0ePNhiD8nqZjY2NVp+ncvaXU6dOqW1TrtN1FCshpGGU2EyUg4MDiouLVdZFRkYCqOlCU7p//77Rj8ZTJjYXFxetjmPu3Lm4ePEitm3bBmtra61iUM680qJFCwBN/zz79u2LkJAQJCcnqwwqkcvlSEpKgr+/P6KiorSKjRDSeJTYTJSzszMKCwuhUCiq1y1cuBCurq6YMmUKfv/9d5SUlODChQuIjY2Fl5eXgNE2rHZia+pxrF27FvPmzcOxY8fg4OBQPQxfuaSnpzcqBmV3oY+PD4Cmf54WFhZITExEXl4eYmNjcf/+feTm5mLixIm4du0avvvuO61u/CaENA0lNhPl5+cHmUyGu3fvVq9r3bo1UlNT0bVrV4wcORKenp6Ij4/HjBkz0KZNG43lbN++vToBZGZmQi6XV/9e14wezaGgoABisRgODg5NPo7k5GS9xJCRkQEnJ6fqa2rafJ49evTAkSNHUFhYiHbt2qFly5a4du0a9u/frzYIhRDSPGi4v4kKDAwEwO+1qj3kv23btti6dWujyxk6dGj1UHQhKe9hUw6Hb8pxbN++XS8xnD9/Hu3bt1dZ19TPEwA6depET+MmREDUYjNRXl5eaNGiBU6fPi10KHqh7+m0tHHmzBl06tRJ0BgIIbqjxGbCevTo0ajRfqZA20fW6EtlZSXOnz9PiY0QM0CJzYT16dMH+/fvVxlA8qikpCSIRCKkpKSgoqLCaOeKbGhm/+Y+jkOHDqG0tLTBB7aayudJyONMxIzhAgvRysWLFxEaGoqjR4+ie/fuQoejk+joaIhEImzatEmQ+qdPn45ffvkFly9fFqR+QsxJOMIRhCAswzIhql9GLTYT1r59e7Rq1QpbtmwROhSdCd0VuW3btur71gghpo0Sm4mLiYnB+vXrIZfLhQ5FJ7o8PVtXR48exZUrVxATEyNI/YQQ/aLEZuLGjBmDe/fu6W3Iu1CEHBX5ww8/IDg4GJ07dxakfkKIflFiM3Ft2rTB8OHDsXDhQqFD0YlQXZFlZWXYuHEjxowZY/C6CSHNgxKbGZg5cyaOHz+OAwcOCB2KVhhjKCwsFCSxrV+/HsXFxRg7dqzB6yaENA9KbGagW7du6Nu3Lz7//HOhQ9FKUVER5HK5IF2R3377LUaNGmX0c2kSQhqPEpuZSEhIwK5du3D8+HGhQ2my2hMgG9L+/ftx7tw5TJo0yaD1EkKaFyU2MzF48GD069cPEyZMqPeGbWMkVGJbsGAB+vbtiy5duhi0XkJI86LEZka+/fZbnD9/3qCz8utDQUEBAMMmttTUVOzduxdz5swxWJ2EEMOgxGZGQkJC8M4772DGjBnIyckROhyNysrKcO/ePTx8+LB6XX5+PkQiEZycnPReX25ursb18+bNwzPPPIPw8HC910kIERZNqWVmioqKEBQUhMjISCQmJqptz8nJgbu7uwCRcRkZGfD39wcAiMVi2Nvbw9raGowxBAUFwc3NDc7OznB0dERQUBDefvttneqbPHkyrly5gsTERPj6+gLg19b69++PvXv3YsCAATofEyFEldBTaoERs7NlyxYGgP30008q63///Xfm4eHBcnNzBYqMa9euHQNQ5yIWixkA9sknn+hcV2BgIAPA7O3t2bp165hCoWBdunRhkZGRejgSQogm/Vl/9jZ7W6jql1JXpBl68cUXERcXh3HjxuHOnTsAgE2bNmHIkCHIzs7W2JIzpOHDh8PKyqrO7XK5HBKJBG+++aZO9WRlZeH69esAgJKSEowdOxZhYWE4ffo0FixYoFPZhBDjRYnNTC1ZsgSenp547bXXqu/Vkslk1duEnFsyMjISlZWVdW63tLTESy+9BE9PT53qSUlJqX4iN8BvBE9LS4OlpSVOnDihU9mEEONFic1M2dnZ4ccff8SxY8cwadIkMMbA/rmcKvTcks888wzs7Ozq3F5VVaWXe8tSUlIgFovVyq6oqMD48eMxePBg3L17V+d6CCHGhRKbmWKM4ccff9TYMrKwsMDixYsFiIqztLTEgAEDIJFI1LaJRCKEhISgd+/eOteza9cuVFVVadzGGENKSgpCQkIEewYcIaR5UGIzQ5WVlXjllVfw9ddfV7fSapPL5Thw4AD++usvAaLjoqKiNMZmYWGBKVOm6Fz+jRs3GmyNKbsp62s9EkJMDyU2M1NcXIxBgwZh69at9c5AYmlpiWXLBBmKCwAYMmSIxvikUileffVVncvX1A1Zm1gsRocOHXDmzBlERUXpXB8hxHhQYjMzaWlpyMrKgkKhUBk48aiqqiqsW7euetYPQ/Pz80NgYKDKOktLS8TFxemlBbV3716Nx29hwf/kJ0yYgKNHjyIgIEDnugghxoUSm5np2rUrLly4gKSkJPj5+dXbaqmqqsL3339vwOhUjRgxQmXYv0wmw/jx43UulzGGvXv3Vo8CVbK0tISDgwN27NiBr7/+GpaWljrXRQgxPpTYzJCFhQWio6Nx/fp1LFu2DC4uLhoHashkMixZskSwSZNrD/sXi8Xo168f2rVrp3O5Fy5cQF5enso6Zdfj2bNnMWTIEJ3rIIQYL0psZszKygpvvfUW7ty5g3//+9+wtbVVa6XcuXMHv/32myDx1R72r1AoMHnyZL2Um5KSUp3IH+16bNmypV7qIIQYL0psjwF7e3tMnz4dt27dwvjx4yEWi6sTnEQiEWzov6WlZfUkxF5eXhg6dKheyv39998hl8thaWkJR0dH/Pbbb9T1SMhjRL1/ipgtDw8PfP3115gwYQISEhKwbds2yOVy7Nu3D1euXGlyN2BlJVBaWvNaUQEoJ+0vLwfKytTfI5cDRUU1v3t7DwXwK/r1ewfbt4tR17gR5RNtLCwAJ6eaV7EYcHSs2U8mk2H//v1gjKFLly7YvHlz9eTHhJDHA83u/xjKzwcePAD270/FkiUfIC0tFf37T8KgQV+jsJAnnkeX/HxAJgOKi4GqKqCkRF/R/A0gEMAdAC20LkUiARwcAMaOoqCgNzw8EtC69Tw4Okrg5AQ4O/ME+Oji4gK4u9cs1tb6Oi5CHl9Cz+5PLTYzwBiQlQXcvQtkZvIlKwvIyQGys3kSy8mp+b1msGBPAEcgFm/Hn38uxM2bxXBxcag+6Ts5Ab6+/GdnZ8DSErC3B6ysADu7ul+BmkSjibLFxfnjs8/mIiGhBR4+5K2+R9VOpMoWX12v+/efg43Ndjz5ZGR1Ui4sBG7dUk/WxcXqdTk4AC1aAB4eNcnOwwPw9AS8vAB/f8DbG/DzA6RSbf/FCCHNiVpsJqCoCLhxgy83bwIZGTx53b0L/P03cP8+7w5UcnHhJ2HlidnTU/1E3aIF/9nFBbC15bORlJWVwd7e3uDHJ5fL670toSkUCkX1gJGGMMZbosqEr0z+yi8FyuXBA74uK4snWSVXV8DHpybZ+fvzpVUrvvj7107ghDw+qMVGAPAT66VLPHmlp9cksvR0fnIF+EnSxwd44gl+Iu3SBRgxouakqnzVpiWhfOinEPSV1AA0OqkBgEjEk5OrK9C2bcP7P9oyzsgA7t3jXy4yM4Fjx4Dbt2tal1ZWQMuWPMm1bl2T8Nq2BQIDeQuYEKJ/lNgMLD8fuHiRJ7Har/fu8e3W1rz7r1UrICwMeOGFmhNiUBDqHFxBmp9IxFvCXl7A00/XvV9+fs0XE+Vy5Qrw22+8S1Sh4F21TzwBhIQA7dvXvAYH8xY0IUR71BXZTBgDrl8HTp3iy8mTwLlz/KQH8FaC8oSmXIKDeVIj5qusjCe5y5f5Fxrla3o6v/YpkQBt2gCdO9csnTrVfb2SEGNEXZFm4u5d4PBhnsBOngROnwYKCviJqn17foIaOZInr/bt+XUv8viRSoGnnuJLbZWVNQnv/Hn+ZejTT3kXtYUF0K5dTaLr1g3o2pW6MgmpC7XYtKRMZHv3AocO8RPSoyegzp15lxV1LRFt3b1b0+o/dQo4fpwPZrG15S25Z54BIiKA3r1plCYxHtRiMxHZ2fwaye7dwIEDfLCAjQ3/9vzSS0CfPkDPnnw4PCH64uPDl2HDatZduQL8+Sdw8CCQlAR8/jkfqNK1K9C/PzB0KP+ZRmSSxxW12Opx7hywYwewfTsf8WZpCTz7LNC3L3/t1o1u6CXCu3OHJ7mDB4E9e/jIzBYtgCFDgKgoYOBA1dlZCGluQrfYKLE94vRp4IcfgC1b+DBuLy9+coiKAp57jlpkxPhduFDzhSw1lU871rcv8OqrvHeBBqKQ5kaJzQj8/Tewfj1PaJcu8fuMRo3i3T+dO/Nh3oSYotxc3n2+ZQtPdmIx8PzzQEwMb8lpeJoRIToTOrE9tn/WjPFrZosXA/v28Rk4Ro0CEhOBHj2Ejo4Q/XBz4y21V1/lt5ps2sS/wA0dyrsr33wTeOcdGqVLzMtjd3m5qgr473/5zc9Dh/JvrFu38tFn335LSY2YLxcXID6ej+K9fh0YPx5YtYrPjjJ+PHDtmtAREqIfj01iUyj4f+LWrYG4OH4f0dmzvNU2fDgfVUbI46JVK2DuXD4TyuLFQEoKn9kmOprPlEKIKXssEtuJE7wl9s47fIqq9HTeauvY0XAxyOVyLFmyBE899RRsbW3h5OSE8PBw7N27t1HvnTFjBgIDA2FjY4PIyMjqbSUlJRCJRCpLampqg2VOnTpV5T3//ve/1fY5ceIExo4di4CAAEilUri6uiI0NBQvvfQSli9fjvT0dABAaGioWgyjRo2qLiciIkJlW5cuXdTqun37NoYPH46i2g9rA3D27FlERUXB2dkZDg4OiIiIwOHDhxs8Pk127tyJtm3bVj9duyny8/OxYsUKhIeHw9XVFVKpFIGBgYiJicG5c+fU9k9ISMDGjRvrLC82NhbW1tYICAjA5MmTUV5e3uSY9EEq5a21K1d4N+Xly3wCgXnz+DP1CDFJzIwVFTEWH8+YhQVj/foxduGCMHHIZDI2dOhQZmlpyb755huWk5PDbty4wWJjY5lIJGL/+9//6n3/ypUrGQA2f/58lp+fr3GfM2fOMAAMAIuMjKy3vJycHGY9mkvLAAAgAElEQVRvb88AsJiYGLXtcrmcffjhh0wikbCpU6eyy5cvs/Lycnb//n22Z88eFhERUV1XVVUVY4yx+/fvMzc3NwaA/fjjj2pl7tixgwUGBrLS0lKNsbu7u7NvvvlGZf3Ro0eZVCplr7zyCrt79y7Lzs5mb775JpNIJGz37t31HmNt169fZ8OGDWMdO3Zkjo6OTCwWN/q9SuPGjWMSiYQtWbKE3bt3j5WWlrKDBw+ykJAQJhaL2datW9XqDAgIYLNnz66zzKKiIrZixQoGgC1YsKDJMTWHykrGvvySMQcHxlq3ZmzPHqEjIqaoP+vP3mZvC1X9UrNNbJcuMRYUxFiLFoytX8+YQiFcLGvXrmUA2KRJk1TWKxQKFhQUxFxcXOpMWIwxNnr0aAaAFRUV1bnPmTNnmFQqZU8++SQDwE6cOFHnvrNmzWLBwcF1JraZM2cyAGzVqlUa3y+TyVhkZKRKYmOMsfXr1zMAzM3Njd2/f796fV5eHvP392eHDx9WK6uwsJD5+fmx+Ph4lfVyuZy1b9+eeXt7s4cPH6rU3a5dO+bv78/Ky8vrPMbaRo8ezT799FNWVVXFfH19tU5sb731ltr6s2fPMgAsMDBQ4zaRSMQ2btxYb9m2trZs4MCBTY6pOWVmMhYdzb8Uzpsn7P8fYnoosTWDkycZc3NjrGdPxjIyhI6GsREjRjAAbI+Gr7/Tp09nANh3331X5/sHDhzY4Mn4zJkzzM7Oji1fvpwBYCNGjNC4X35+PnN1da1Oto8mtsuXLzMLCwvWuXPneus7cuSIWmJjjLHhw4czAOyll16qXhcTE8OmTZumsZxZs2YxiUTCMjMzVdb/8ccfGr8MMMbY3LlzGQCWnJxcb4xKtROjtomtPlKplFlYWDCFhrN/dHQ08/PzU/ucavPx8Wnw8xbK8uWMWVkxFhfHmEwmdDTEVAid2MzuGtvNm8CgQfz+s5QU45gtPysrCwDQokULtW3e3t4AgEOHDtX5frlc3ui6YmNj4evri19++QXnz59X2/71119jyJAhaN26tcb3r1q1CgqFAtHR0fXW07NnTzDG1K5XrVixAi4uLtiyZQuSk5Px888/4+zZs5g/f75aGYwxrF69Gt27d4ePj4/Ktn379gGAxutxynUpKSn1xqgkbcZJFEtLS1FWVlZ9nfFRL7zwAjIyMrBjx446yxCJRJDVPNbcqIwfD/z0E/Djj8DUqUJHQ0jjmFViUyiAl1/mz7nautV4JoV1d3cHUJPgasvOzgYA3Lp1Sy91WVtbY+rUqWCMYcGCBSrbSkpK8M0332DmzJl1vv/gwYMAgI5ajqzx9vbG4sWLAQATJ07EO++8g3Xr1sFaw9xj586dQ1ZWFsLCwtS2paWlAQD8/PzUtvn+823l6tWrWsWoT5s3bwYAzJo1S+P2p/6Zxn/37t0Gi0nfoqL4/Z1LlgC//ip0NIQ0zKwS248/8vkdN2wwrhn1Bw0aBADYvn272rZdu3YB4N/861JZWakxMdTlrbfegqenJ5KTk3H58uXq9UuXLkV4eDiCg4PrfO/du3cBAG5ubo2u71Gvv/46hgwZggcPHqBNmzbo3Lmzxv0uXLgAQHPyKigoAADYaXiyqvJJ3/nKh9sJJCsrCwkJCYiLi8PLL7+scR9lElYeqybW1taoqqpqlhj15dVXgdGjgfff518gCTFmZpXY1qzhzzwLChI6ElVxcXHo3LkzVqxYgaVLlyI3Nxd37tzBO++8g8zMTAD1d5fduXNH48m/LlKpFO+//z4UCgUWLlwIAHj48CEWL15cZ8viUZq61ZoiMDAQAHDgwAFs27ZN4z73/nlsuJOTU5PKZv/MAqdrjLrIzc3F4MGD0a9fP6xYsaLO/RwdHSESiaqPVRMfHx9kZmYabXek0pw5/MbuAweEjoSQ+plNYmOMP6tq8GChI1FnY2ODP/74A5MnT8aXX34Jb29vdO/eHYyx6q4sLy8vtffl5eXhiy++wO3btzFhwoQm1TlhwgS4ubnhf//7H65fv46VK1eiR48eDXYxKq915eTkNKm+2v7880/89NNPWLRoEQBg/PjxGltXynu3LDU8MdPZ2RmA5pascp1yH0MrLS3FoEGDEBISgvXr10MsFte7v0QiQVlZWZ3b4+PjUVRUhDlz5uj0uTe3du34jd1HjwodCSH1M5vEVlEBlJUBAp3rGuTg4IAvvvgCN2/eRGVlJe7du4elS5dWn6Sffvpplf3Hjh0LNzc3JCQkYNq0aXj33XebVJ+9vT2mTJkCuVyOjz/+GF9++SVmz57d4Pv69u0LABoHnjRGSUkJxo4di1WrVuG9995DZGQk7t+/j8mTJ6vta2NjAwAau+GC/ml2Z2RkqG1TtnLbtm2rVYy6kMlkiI6Ohq+vL9atW9dgUlO+p74W+b/+9S8sWLAAX3zxBTw8PDDYGL+d/cPFhT8ZnhBjZjaJzcYGcHfns4qYEuVoyBdffFFl/dq1a1FYWIikpCQsWrQI8fHxTS570qRJcHJywoYNGxAWFqZxhOGj4uPjIZFIkJycXO9+06ZNg4WFRfUgD6UPPvgAERER1SfnlStXwtHRET/88IPaNUbliNDCwkK18vv37w8AOHXqlNo25boBAwY0eDz6Fh8fj4qKCmzatEllRGibNm1wVENTpqioCIyx6mPVZNasWZg5cyaWL1+OgoKC6uuuxkYu56OO/f2FjoSQBgh1o0FzeO01xrp0Mb6bSbOzs5lIJFK7V6uwsJB5eXmxUaNG1fv+rl27MhcXl3r3Ud7H9qh58+YxJycntZuj//zzzzpv0P7kk08YAJaYmKixrrS0NObo6MheeeUVlfW7du1iAQEBajeSr1q1igFgPj4+KjeiK2dLmTBhglodcrmchYSEMB8fH1ZWVla9XiaTseDgYObv76+yvrF0uY/t448/Zt27d2fFxcVq21q3bs1SU1PV1l+6dIkBYG+/Xfc9PUFBQSwgIECrmAzp118ZE4kYu35d6EiIsRP6PjazSmwnT/KZEn74QehIVGVnZzMAbODAgezatWusvLycHTt2jPXs2ZOFhYWx3Nzcet8/YMCARt+g3Vj1JTbGGEtISGCWlpZs+vTp7MqVK6yiooJlZGSw1atXM29vb/bMM8+wkpKS6v3z8/OZv78/++OPPzSWp5yGa+zYsdXrFAoFa9GiBevdu7fG96SmpjIbGxs2atQodu/ePZaTk8Pi4+OZRCJhu3btUts/JiaGAWA3btyo87gbk9g0lfP9999XTyNW16IpsW3YsIEBUJty69GYwsLC6o1JaGVljIWEMPb880JHQkwBJTY9e/ddxuztGTt7VuhIVP3+++9s+PDhzMvLi0mlUhYaGso++eQTlVkx6hIREVHvydjOzk7lBDto0KB6y9N0Un50nkbGGDt+/Dh77bXXmL+/P7O0tGQODg6sR48e7KuvvmIVFRXV+/n6+qqUVXvWk/z8fI31LV68mDHGp+/SNPOI0unTp1lkZCRzdHRk9vb2LDw8nB06dEjjvuHh4cze3p7JHpki49dff60zGWma8UVTOVFRUVoltujoaObr68sqKys1xqz8/J566qk6twtNoeC9IS4ujNXznYGQapTY9KyykrEBAxhzd+ctOHMQFRXFRCKR0GE0i4KCAubr66s2V2RT5efnM6lUyuLi4oyiHMZq5opsaJJrT09P1qNHD53raw5VVYy98QafVktDI5kQjYRObGYzeETJ0hL45RegSxfg2Wf542lMnZ+fHxhjGmcuMXVOTk749ddfkZycjKVLl2pVBmMM7777LhwdHfHJJ59oHYu+ygGAGzdu4MUXX8SMGTNUHuHzqKqqKuTl5TXpPkVDycoCBg4EkpKAn3/mU9URYgrMLrEBfNaR7dv53HaxscCwYXw0l6lSjjD87LPPkJubK3A0+tepUyecPHkSv/32m9rz2BojKysLN27cQEpKisb7AQ1dDsBHgy5YsEBtWrPaCgsLsWjRIlRVVRnVEH/G+BfCDh2Av/8GUlOBWo8AJMT4CdVWNJQDBxgLDWVMKmXs44/5RXBT9Pnnn7Pg4GBmbW3NBg8eLHQ4REevv/46s7S0ZG3atGEfffSR2nVBoZw+zZ+KIZHw69WFhUJHREyR0F2RIsb+mZ/IjFVVAV99xZ8K7OYGvPceMG4c8M+Ug4Q89k6cAL74AtiyBXjmGWDpUiA0VOioiKkKRziCEIRlWCZE9cvMsivyUZaWwIcfAmlpwIgRwKxZ/AkAs2YB9+8LHR0hwmAM2LED6NcP6NaNd9dv3Ajs309JjZi2xyKxKfn68pbbnTvABx/wR3G0bMlnLd+xAzDyOWgJ0Ys7d4CFC4HgYH792c4O2LePt9pGjgQEnFuaEL14rBKbkqsrb63dusW7XDIz+X9wPz9gyhRAwyxOhJi0oiL+9Iv+/YGAAGDxYuC554Dz5/mXun9mMCPELEga3sV82djwa23jxvFumB9/5MtXXwFt2/JkFxXFrzlomICeEKP299/Azp18hHBKCu96HDaMD90fPJj+pon5eiwGjzTV0aPATz/xE8Lly4CTE7+HJyqKD3v28BA6QkLUyeX80U3bt/OEdvYs72Z87jme0F580XiffkHMi9CDRyixNeDWLWDPHuDXX4Hff+ePx2nVCoiIAHr3Bvr2BZ58UugoyeNILufJ69Ah4PBh3irLy+PXjQcOBIYO5Untn6cDEWIwlNhMSEkJ8Mcf/AnCf/4JnD7NB5wEBvJZTvr0Abp25Q9kbMRjughpkvx8fv33yBH+95eaCpSWAl5e/G/v2WeBAQP4oBBChCR0Ynusr7E1lb0979IZNoz/XlLCvyn/+SdPdj/+yFt09vbAU08BnTvzqb06d+bJzuKxHKpDtFFQwJNY7UX5rEF/f95TsHgxT2j/PJOVEPIPSmw6sLfn196Uc+hVVQF//cVPQidP8i6i5cuBykq+b1gYEBLCl/bt+TdrI5wikBhQWRm/v/LSJeDiRX5N96+/apKYjw//YvTaa/y1c2egnmeWEkJAg0eaXWVlTbI7e5afxC5cALKz+XYnp5pEFxQEtGnDr+G1bs3nvCSmjzF+S8mNG3y5cqUmkd28CSgUgJUV79IOCeE3Rz/9NCUxYrqoK9LMWVnVfNOuLSen5hv6xYv8RLdjB3DvXs0+Xl48ySkTnfJnPz9+wrO2NuyxkLrl5PB/u1u3eGtLmcRu3ODJq7yc72djw28lCQ4GXn+9pgXfpg0NvydEXyixCcTdnV8n6dtXdf3Dh6onReWyaZPqCRIAPD15V5Wvb02ye+IJvs7bm9fh7k4nTF0UFfHHt2Rn88SVkcGXe/f4DB7KdbX/Xby8ar6IdOlS84WkVSv+b0MIaV6U2IyMrS3vitI0Vx9jNSfSu3f5Dbh37/JurrQ0Pi1SRgZPjrU5OfEk6O7OJ4GWSv9GQIA/PDz4fU2OjoCLC391cuKvjo78HihzIJfzBJWfz19rLwUFvLWlXB484ElM+XtlZU05IhFPWsovEx078hud/fz47z4+fKi9VCrYoRJCQInNpIhE/OTZ0Lf+/Hw+ubPy5JydXXOy/uOPf+PChU8RHJyGwkJ/FBbyE7wmYrFq0hOL+c9Aw68A7yrVdJ3QxkbzyT8/X32dQgEUFtb8Xl7OB1zUfi0uLoVMZouyMlH1+tJSflyFhfxnTSwteWJXtmzd3XlLq0cP1XUtWvCb8r28qPVLiCmgxGaGXFxUEwwAyOVyvPPOO7hw4Tt89dVXmDjRX2V77daMMtkpF+U2uZy3cBirSUI3bvDfCwrUk1BpqWqLR6mo6DPI5R0ARKmsd3AAJBr+IpVJFahJlspXS8uHOHCgPZ5+egFCQmIglfLEaW9f0/JULsoErVyoZUWIeaLE9hgoKytDdHQ09u/fj61bt2KY8ka8WjQlw+bStu0ajBkzBrNnRzW8c4Ns8eabz+G336Zj9+4XYEtDSQl57NEtw2aupKQEUVFRSE1Nxb59+zQmNUPLycmBhx4n3FywYAGKi4uxaNEivZVJCDFdlNjMWEFBAQYNGoRLly5h37596Natm9AhQSaToaCgAO7u7nors0WLFpg2bRo+//xz3Kt9vwQh5LFEic1MFRQUICIiAn///TcOHDiAsLAwoUMCwFtrjDG9ttgA4P3334erqys++ugjvZZLCDE9lNjMUHFxMSIjI5GVlYX9+/ejXbt2QodULScnBwD02mIDAKlUik8++QTr1q1DunI+KkLIY4kSm5l5+PAhhg8fjhs3bmDPnj1o1aqV0CGpyP5nLjF9t9gAICYmBgEBAfjss8/0XjYhxHRQYjMjMpkMI0eOxIULF7Bv3z4EG+HzS3JycmBhYQFXV1e9ly0WizF9+nSsW7cOt27d0nv5hBDTQInNjEyYMAEHDx7Ezp070b59e6HD0Sg7Oxuurq4QN9MD68aMGQNfX1/83//9X7OUTwgxfpTYzMTChQuxZs0a/Pjjj+jatavQ4dQpJydH79fXarO0tMS0adOwZs0aZGZmNls9hBDjRYnNDCQnJ2P27Nn4+uuv8fzzzwsdTr30fQ+bJm+88Qbc3Nzw7bffNms9hBDjRInNxF26dAmxsbGYOHEiJkyYIHQ4DcrOzm7WFhsAWFtbIy4uDomJiaioqGjWugghxocSmwkrLi7GyJEj0aFDB/znP/8ROpxGycvLa5aBI4968803kZeXh59//rnZ6yKEGBdKbCZs7NixKCgowJYtW2BlZSV0OI1SUFAAZ2fnZq/Hz88PUVFRWLlyZbPXRQgxLpTYTFRiYiJ+/vlnJCUlwdvbW+hwGq2oqAhOTk4GqSs+Ph5//PEHLl26ZJD6CCHGgRKbCbp58ybee+89TJ06Fc8++6zQ4TRJYWGhwRLb4MGDERAQgMTERIPURwgxDpTYTIxcLsdrr72GVq1aYd68eUKH02SFhYVwdHQ0SF0WFhYYPXo0tmzZAsaYQeokhAiPEpuJWblyJU6cOIEffvgB1tbWQofTJDKZDA8fPjRYiw0Ann/+edy+fRtnz541WJ2EEGFRYjMhDx48wOzZs/Hee++hQ4cOQofTZIX/PF7bkImtS5cu8Pf3x7Zt2wxWJyFEWJTYTMj06dNhZ2eH2bNnCx2KVoRIbCKRCCNGjKBh/4Q8RiixmYhjx45h3bp1WLx4Mezt7YUORytCJDYAGDFiBM6dO4cbN24YtF5CiDAosZmIjz/+GL169cLIkSOFDkVrQiW2vn37wsnJCb/99ptB6yWECIMSmwk4cuQIdu/ebZKjIGtTJjZDjYpUsrS0RK9evXD48GGD1ksIEQYlNhMwZ84c9O7dGwMGDBA6FJ0UFhbC2tpakNGcvXv3xsGDBw1eLyHE8CixGblTp04hJSUF8+fPFzoUnRUXFxu8tabUq1cvZGZm4u7du4LUTwgxHEpsRm758uUIDg5G//79dSpn586daNu2LSQSiZ4ia7ry8nLY2Ng0+X35+flYsWIFwsPD4erqCqlUisDAQMTExODcuXONKiMsLAwAcP78+SbX/6izZ88iKioKzs7OcHBwQEREBHVzEmJEKLEZsdLSUiQlJWHChAkQiURalZGeno7hw4djxowZyMrK0nOETVNRUaFVN+TUqVMxadIkjBgxApcuXUJubi7WrFmDs2fPonPnzo0ayu/q6go/P79GJ8K6HDt2DL169YKDgwMuX76MmzdvolWrVujXrx/27NmjU9mEEP2gxGbE9uzZg7KyMp1GQn700Ufo1asXTp06BQcHBz1G13QVFRVatdgA/vDQyZMnw8vLC7a2tujTpw82bNgAuVyOadOmNaqM4OBgXL16Vav6AUChUGDcuHFwdnbG999/D29vb7i7u2P58uVo3bo14uLi6PlvhBgB4fqlSIO2b9+Obt26wcvLS+syEhMTIZVK9RiV9srLy7Vqsa1evVrj+rCwMEilUqSnp4Mx1mCr9oknnsDt27ebXL/SwYMHcfHiRUyaNEnlMxWLxRg9ejTmzp2L7du346WXXtK6DkKI7qjFZsQOHz6s80hIY0lqgPZdkXUpLS1FWVkZQkNDG9VV++STT+LOnTta17dv3z4AfJquRynXpaSkaF0+IUQ/KLEZqaKiIly7dg1du3ZVWZ+Wlobnn38eTk5OsLW1Rbdu3bB9+3ZERERAJBJBJBIhLi5OoKjrV3vwiD6OY/PmzQCAWbNmNar+Fi1aIDs7W2VdU+JIS0sDwB9i+ihfX18A0KmrkxCiH9QVaaTS0tKgUChUJju+fv06evbsCTs7OyQnJ6Nnz564ffs2pkyZgvPnz8Pa2hrl5eUCRl0/ZYtNH8eRlZWFhIQExMXF4eWXX25U/U5OTigqKqrutmxqHAUFBQAAOzs7tbKV05zl5+c39uMghDQTarEZqczMTIhEouqWAADMnDkTBQUF+Oqrr/Dcc8/B3t4e7du3x4YNG1BaWipgtI2jbLHpehy5ubkYPHgw+vXrhxUrVjS6ficnJ8jlcpSUlADQ7+epfN6btqNXCSH6Q4nNSD148AAuLi4q16R27doFABg0aJDKvh4eHggKCjJofNpQtth0OY7S0lIMGjQIISEhWL9+PcRicaPrV+6rUCgANP3zdHZ2ro5BU1y19yGECIcSm5F6dKBFRUUFiouLYWNjo3F2fxcXF0OGp5WKigpYWlpqfRwymQzR0dHw9fXFunXrmpTUAP70cQCQSCRafZ7KZJeRkaG2LTMzEwDQtm3bJsVECNE/SmxGSi6Xw8Ki5p/H2toaDg4OKC8vr+5Kq+3BgweGDE8r5eXlsLW11fo44uPjUVFRgU2bNqnMoNKmTRscPXq0wfplMhkA3nLT5vNUzv5y6tQptW3KdaY+nych5oASm5FycHBAcXGxyrrIyEgANV1oSvfv3zeJ0XjKVqg2xzF37lxcvHgR27Zt0/qWgby8PEil0uqRmU2No2/fvggJCUFycrLKoBK5XI6kpCT4+/sjKipKq9gIIfpDic1Iubu7o6ioCJWVldXrFi5cCFdXV0yZMgW///47SkpKcOHCBcTGxup0E7ehKAePNPU41q5di3nz5uHYsWNwcHCoHoavXNLT0xtVf1ZWFjw9Pat/b2ocFhYWSExMRF5eHmJjY3H//n3k5uZi4sSJuHbtGr777jutZ1YhhOgPJTYj5e/vDwC4detW9brWrVsjNTUVXbt2xciRI+Hp6Yn4+HjMmDEDbdq00VjO9u3bqxNAZmYm5HJ59e91zejRXJQttqYeR3Jysl7qz8rKQosWLap/1+bz7NGjB44cOYLCwkK0a9cOLVu2xLVr17B//361QSiEEGHQfWxGKjg4GBYWFrh8+bLKgIS2bdti69atjS5n6NCh1UPRhVZZWQkrKysATTuO7du366X+tLQ0tcEdTf08AaBTp07YuXOnXmIihOgftdiMlK2tLVq1aoXTp08LHYreyOXyJo9k1KdLly4hJCREsPoJIYZBic2I9enTBwcOHBA6DL1RKBQqIz0NqaCgALdv30ZoaKgg9RNCDIcSmxHr378/jh07pnE4ulJSUhJEIhFSUlJQUVFh1HNF1pfYmvs4Dh48CADo2bNnvfuZ0udJCNGMEpsRGzJkCGQyWb3Xc0aNGgXGmMpi6EEhjVVfYmvu49i/fz86duwId3f3evczpc+TEKIZJTYj5ubmhr59+2LTpk1Ch6IXQnZF7t69G+Hh4YLUTQgxLEpsRu7111/HL7/8gnv37gkdis6ESmwXL17EpUuX6AGghDwmKLEZuejoaDg4OCAxMVHoUHQmVGLbvHkzvL29G7y+RggxD5TYjJyNjQ0mTJiAJUuWoKioSOhwdCJUYktKSsLIkSMF6wYlhBgW/U83AR988AEUCgW++uoroUPRiRCJ7fDhw7hy5Qpef/11g9ZLCBEOJTYT4OzsjClTpuA///kP8vLyhA5Ha0IktsTERHTs2BGdO3c2aL2EEOFQYjMRU6ZMgUQiwaJFi4QORWuGTmwFBQXYvHkz3YdGyGOGEpuJcHR0xKxZs/Cf//wHaWlpQoejFUMntmXLlsHCwgJjxowxWJ2EEOFRYjMhkydPRqdOnRAbG1v9NGhTYsjEVlFRgW+//RYTJ06Ek5OTQeokhBgHSmwmxMLCAitXrsTp06exdOlSocNpsuZKbDk5OWrrvv/+e+Tl5WHSpEl6r48QYtwosZmYDh06ICEhATNnzsTNmzeFDqdOb7zxBjp27IgOHTqgQ4cOaNu2LSQSCaZNmwY/P7/qJSAgQOWZc01VWlqKVq1a4bPPPqt+KKtcLseiRYswduxYeHt76+mICCGmghKbCZo1axZatWqFUaNGoaKiQm37+vXrUVZWJkBkNdq3b4+//voLFy5cwIULF3Dt2jUUFxfjwYMHyMzMrF6srKzQsmVLres5c+YMiouLMWvWLAQHB+P333/Hli1bcOPGDXzwwQf6OyBCiMmgxGaCrKyssGXLFly5cgWTJ09W2bZy5Uq89tprgs9UMnr06Aa7HS0tLXW+v+z48eOwtLSEQqHA7du3MXDgQLz//vsYNGgQAgMDdSqbEGKaKLGZqMDAQPz3v//FqlWrsGbNGgDA8uXL8fbbb4MxhoULF6Kqqkqw+Hx8fPDMM8/U+2DRqqoqREdH61TP8ePHoVAoAKB6QE12djZSUlIwd+5cjS1aQoh5o8RmwoYPH46pU6finXfewbx58zBx4kQwxgAAWVlZWL9+vaDxvf7669XxPEokEiEsLEznVtWRI0fURohWVlaioqICCxYsQFBQEHbt2qVTHYQQ00KJzcQtWLAAQ4cOxbx581SSCGMM8+fPr27NCGHkyJGQSCQat0kkErz22ms6lZ+fn4+MjIw6t8tkMty+fRuRkZGCd80SQgyHEpuJ+/bbb5GcnKzWMmKM4datW/jpp58EiozfVD506FBYWlqqbZPJZBg5cqRO5Z88ebLOFqESYwwfffQR3njjDZ3qIoSYDkpsJmzx4sV477336lf6uu0AACAASURBVO3umzt3boMn/+b02muvQSaTqawTiUTo3r07nnzySZ3KPn78OKysrDRuE4vFsLS0xH//+1/Mnz8fIpFIp7oIIaaDEpuJ+vLLL/H+++/Xu49CocDFixexe/duA0WlbsiQIXBwcFBZJxaL8a9//Uvnso8dO6aWNAHezeni4oJDhw7p3N1JCDE9lNhMkFwuh1wuh6ura53XsJTEYjHmz59voMjUWVlZYdSoUSotK4VCoXM3JACkpqaqXUO0tLREu3btcOrUKXTr1k3nOgghpocSmwkSi8WYPn067t69i6VLl8LT0xMWFhYau9vkcjlSU1Nx6NAhASLlYmJiqmcFsbCwQN++feHp6alTmffu3VObSsvCwgJDhw7F8ePH8cQTT+hUPiHEdFFiM2HW1tZ46623cOfOHXz//ffw9/fXmOAkEgn+/e9/CxQl0KdPH/j6+gLg19diYmJ0LvP48eNq66ZOnYrk5GTY2trqXD4hxHRRYjMDVlZWGDNmDK5fv47vv/8eAQEBEIlE1TN/yGQy7N69G6dPnxYkPpFIVP3oGJFIhBdeeEHnMk+ePAmJRAKxWAxra2ts3LgRn332mcEfZEoIMT71X6AhJsXS0hJjxozBq6++iqSkJMybNw/p6emwsLCono0kOTlZq7IrKoCHD4GqKqCkBJDLgaIivo0xoKBA8/sqK4HSUsDdPQbApwgNjUBKiisAwMICqOuJMtbWgLLhZWkJ2NsDYjHg6Mjfl5qaCplMBg8PD+zYsQNdu3bV6rgIIeZHxIQcC06aDWPAgwcK/O9/W/DVV3Nx69YliEQWmDfvMmxs2qK4GNVLURFPTMXFPGk9fMiXigqgrAwoL9dXVJ0AfABA1xGRDIAbgCfh5LQDFhY+cHLiic/ZmSc/B4eaxcmJL/b2NeucnQE3t5qFei8J0Z9whCMIQViGZUJUv4xabCYkNxe4fx+4exe4dw/IygIePODrlUtOTs3PjFkAiAYwEsAvYOzfWLDgc3h7J6qc5J2cgCeeqPndzg6wsQGk0pqWk6ZWU+3WlqMj3/ao2vt9880beP314XB05L8rW4GalJTw1mHt/ZStxYyMm1i1KgLjx69FeTnPSPn5Na3IwsKapH3vHv9dua6khLcgHyWVAu7uPMm5uwMeHjVJz90d8PMDPD0BX1/Aywuo4/Y5QogRoBabEWCMn4Bv3gRu3QJu3+YJLDOzJpHdv6/acrKx4SfaFi1qTr61WyC1T87u7ryFYmsL7Nu3D88++2yDtwk0B7lcXu+kyI1VXFwMe3t7rW+6Vih4C/XRLwLKpfaXhZwcIDubL7V5ePDPv3bC8/EBWrYEAgL4IpXqfKiEmCRqsT0mioqAK1eAGzd48rp1qyaR3brFWyUAbxn5+fGTpI8P0KUL4O3Nf6796uqqXRzh4eH6OSAt6COpAVC74bupLCz45+fqCjR2DubKypovG1lZQEaG6uvp03xbXl7Nezw9axJdy5Y1PwcGAk8+yeMghOgfJTY9y88HLl4ELl3iSUz5882bvGUGAC4uQKtWfHn++ZqfW7XiXYICNKZIA6ys+L9NQ7fHlZfzFvaNG6rL778D6ek1g2ysrPgXmJAQoH17/m8fEgKEhfHuYEKI9ugUqqWSEuDcOeDsWb6cOQNcvlxzzcjDAwgK4kvfvkBwMNCuHf+mrmFOYGImbGxqvqRokpcHXLvG/1auXOHLtm086SmvKT7xBNChA9CpE/DUU/w1IACg6S4JaRy6xtYIhYXAsWO8u+nMGZ7Irl/n12pcXGpOPu3b1yQzbbsKyeNJJuMtu7Q0nvTOneN/a9eu8UExTk68Naf8W+vWjX9ZomRHjBFdYzNCd+8Chw8Dhw7x1zNneBLz9ubJa/BgoHNnvoSE0MmF6E4iAdq25cvw4TXrKyt5cjt1qmZZvZr3DDg4AN27A71787/FZ5+t+75AQh4n1GIDP3Hs3g2kpACpqXwwgLU1P1n07Ak88wx/1XF6Q0L0QibjLbrDh/nf66FDfBCLRMJbc888AwwcyLvAaWQmEYLQLbbHMrEVFwP79vFktns37wJydAT69eMnhV69+GhEa2uhIyWkcf7+uybR7d8PnD/Pk1qfPsCgQbyXISRE6CjJ44ISm4E8eABs2QJs3sy/4crlwNNP8//0AwfyZEajEYm5uHu35ovb3r38njx/f97N+corvPuSbjcgzYUSWzPKzwe2bgWSkngLzcYGGDaML889x0cuEmLu5HLg5Elg1y7+5e6vv/itBtHRPMl17y50hMTcUGJrBikpwLffAjt38m+lQ4bw/8BDh9KcgIRcvAhs3MiXq1f5rQlxccCbb/JZagjRldCJzWw6I8rKgO++4/f/RETw1lpiYk0X5MsvU1IjBOAje+fP5/fQnT4NvPAC8MUX/P65N9/k1+cIMWUmn9hKS4F58/j1g0mTgK5d+fD8/fuBf/2LZnEgpD6dOgFffskHnyxaBBw5wu+XGzCAD0QhxBSZbGJTKIB16/hsHosXA+++C9y5A6xZw29iNbSdO3eibdu2jZpc+OzZs4iKioKzszMcHBwQERGBw4cPN/g+uVyOGTNmIDAwEDY2NoiMjKzeVlJSApFIpLKkNuLMNHXqVJX3aHrS9okTJzB27FgEBARAKpXC1dUVoaGheOmll7B8+XKkp6fj6NGjavU7OzurlPPzzz+rbB86dKjK9tu3b2P48OEoUj7oTcfPS5Om/Ds9Kj8/HytWrEB4eDhcXV0hlUoRGBiImJgYnDt3Tm3/hIQEbNy4sc7yYmNjYW1tjYCAAEyePBnl+ns+UJPZ2QHjxwMXLgB79vDp33r3BkaP5v+vCDEpzAQdPcpY586MicWMjR/P2IMHwsVy/fp1NmzYMNaxY0fm6OjIxGJxvfsfPXqUSaVS9sorr7C7d++y7Oxs9uabbzKJRMJ2795d73tXrlzJALD58+ez/Px8jfucOXOGgT+wjEVGRtZbXk5ODrO3t2cAWExMjNp2uVzOPvzwQyaRSNjUqVPZ5cuXWXl5Obt//z7bs2cPi4iIqK6rqqqKMcZYbGwsA8DGjBmjsc6MjAzm6enJbt26pRa3u7s7++abb1TW6/J51dbUfydNxo0bxyQSCVuyZAm7d+8eKy0tZQcPHmQhISFMLBazrVu3qtUZEBDAZs+eXWeZRUVFbMWKFQwAW7BgQZNjak4//8xYYCBjUiljs2czVl4udETEVPRn/dnb7G2hql9qUolNoWDss88Ys7RkbMAAxv76S+iIGBs9ejT79NNPWVVVFfP19a33hCmXy1n79u2Zt7c3e/jwYfV6mUzG2rVrx/z9/Vl5PWeP0aNHMwCsqKiozn3OnDnDpFIpe/LJJxkAduLEiTr3nTVrFgsODq4zsc2cOZMBYKtWrdL4fplMxiIjI1USW05ODnNzc2MA2IEDB9TeM3LkSPbpp5+qrCssLGR+fn4sPj5eZb2un1dtTfl3qsu4cePYW2+9pbb+7NmzDAALDAzUuE0kErGNGzfWW7atrS0bOHBgk2NqbhUVjC1axJiDA2NPP83YtWtCR0RMASW2RqqqYmzsWJ7UvvySJzljUPuE29AJ848//mAA2KRJk9S2zZ07lwFgycnJdb5/4MCBDZ6Qz5w5w+zs7Njy5csZADZixAiN++Xn5zNXV1e2du1ajYnt8uXLzMLCgnXu3Lne+o4cOaKS2BhjbPXq1QwAa9++PausrKxe/9tvv7GQkBCVdYzxBCuRSFhmZqbKel0/r9qa8u+kDalUyiwsLJhCwx9mdHQ08/PzU/mMHuXj49PgZy2kq1d5YnN3Z+zYMaGjIcZO6MRmEtfYGOOjtTZvBn75BfjgA+OZn1HahDmL9u3bBwDo0qWL2jblupSUlDrfL5fLG11XbGwsfH198csvv+C8hmFuX3/9NYYMGYLWrVtrfP+qVaugUCgQHR1dbz09e/YEY0zlmtUbb7yB3r174+LFi1i8eDEAoLy8HJMmTcKyZctgWevxBowxrF69Gt27d4ePj49K2bp+XrU15d+pqUpLS1FWVobQ0FCNDz994YUXkJGRgR07dtRZhkgkgkwma7YYdRUYCPz5J7/n7bnn+L1whBgrk0hsS5cCP/4IJCfzqYFMVVpaGgDAz89PbZuvry8A4OrVq3qpy9raGlOnTgVjDAsWLFDZVlJSgm+++QYzZ86s8/0HDx4EAHTs2LHJdYtEIixfvhwSiQTz58/HnTt3sHDhQvTq1Qt9+/ZV2ffcuXPIyspCWFiYWjmG/Lx0sXnzZgDArFmzNG5/6p/RTLt37zZYTM3B1hb46Sc+Y8+IEXxEMiHGyOgTW04OMGsWkJBg2kkNAAr+ecqknZ2d2jZ7e3sAfORdXSorK2HdhAks33rrLXh6eiI5ORmXL1+uXr906VKEh4cjODi4zvfevXsXAODm5tbo+mrr0KEDpkyZgtLSUsTExOC7777DF198obbfhQsXAGhOXrp+XoaQlZWFhIQExMXF4eWXX9a4jzIJK49VE2tra1QpH8hmxKys+I3dBQXAp58KHQ0hmhl9YktK4l2RCQlCR9K82D8TwGjqylK6c+eOxgRQF6lUivfffx8KhQILFy4EADx8+BCLFy+us3XxqPriacjcuXPh7++PQ4cOYfbs2WjRooXaPvfu3QMAODXxeSuN+byaW25uLgYPHox+/fphxYoVde7n6OgIkUhUfaya+Pj4IDMz06i7I5VatACmTOGPzzGBcMljyOgTW2oq0L8/v8/G1Cnv6yrV0IejXPfovV8AkJeXhy+++AK3b9/GhAkTmlTnhAkT4Obmhv/973+4fv06Vq5ciR49ejTYxai83pWTk9Ok+mqzs7PDs88+CwAauxoBVN+7ZanhseLafl6GUFpaikGDBiEkJATr16+HWCyud3+JRIKysrI6t8fHx6OoqAhz5szR6TM3lGHD+OOd0tOFjoQQdUaf2PLzzedp1EFBQQCAjIwMtW2ZmZkAgLZt26qsHzt2LNzc3JCQkIBp06bh3XffbVKd9vb2mDJlCuRyOT7++GN8+eWXmD17doPvU14L0zTwRJ9sbGwAQGM3nDaflyHIZDJER0fD19cX69atazCpKd9T3wCWf/3rX1iwYAG++OILeHh4YLCR97sre6gF7gkmRCOjT2z+/vxBoOagf//+AIBTp06pbVOuGzBggMr6tWvXorCwEElJSVi0aBHi4+ObXO+kSZPg5OSEDRs2ICwsTOMow0fFx8dDIpEgOTm53v2mTZsGCwuL6oEeTeXt7Q0AKCwsVNumzedlCPHx8aioqMCmTZtURoO2adMGR48eVdu/qKgIjLHqY9Vk1qxZmDlzJpYvX46CggLs2rWrWWLXlytX+OsTTwgbByGaGH1iGzaMd0dqed40Kn379kVISAiSk5NVpk+Sy+VISkqCv78/oqKi1N7n6OiI6OhodOrUqcFEo4mTkxPef/99ODk5Naq1BvCW0Mcff4yTJ09izZo1Gve5cuUKVq5ciZdffrm6ddVUoaGhADS3yrT9vJrT3LlzcfHiRWzbtq3RA3mUrUvlsWry008/ISAgAHFxcU2+3iiEtWv5w3gfuUODEKNg9Ilt8GA+Y/877/DnSpkyCwsLJCYmIi8vD7Gxsbh//z5yc3MxceJEXLt2Dd99911115wmjo6OavMoNtacOXNQUFCAXr16Nfo9s2fPRkJCAsaPH4+EhARcvXoVlZWVyMzMRGJiIvr374+OHTsiMTFRq5gAfu2tRYsWGuda/H/27jssiqvtA/BvaUvbpYmogIqCKPZYYomvSFBUrImY+FleC5HE2GKir9hNYmKqJVHBFk3sEo29RGNijS2CDbuiIiB9qcvucr4/TpYiCwJbZhef+7rmWpidnfPMKvPMOXPmnOp8XyNGjIBIJMLDhw+rHVN5+9mwYQMWLlyI8+fPQyKRlBkb8345N5yio6MBAL169Sq3vKysLEilUq1iNpQ//gC2bq35HbqICRPq0fCquHiRj1c3caLxjDiitm/fvqLxEl9c1qxZo/Ez//zzD+vTpw+TSqXM3t6eBQQEsNOnT7+0rMDAwApHzLCzsytVflBQUIX70xTzi2M1MsbYhQsX2MiRI5mnpyeztLRkEomEderUiS1btozJ5XKN+1aPfPLiomn0jVmzZmkceUStKt9XQEAAs7e3Z0qlstT6qv47adpPcHBwuftQL+fOnSuzr5CQEObu7l5mxJWS3N3dWZs2bcp931jcusWYiwtjQ4cKHQkxZkKPPGISiY0xxqKiGLOwYGzcOMYqOD/UaMHBwUwkEgkdhs5lZGQwd3f3MmNFVlV6ejqzsbFhoaGhRrEfxorHity6dWuF27m5ubFOnTppXZ4+nTvHmKsrY127MlZihDJCyhA6sRl9U6Ta228Dv/3Gn2vr1g3QsqXJJHl4eIAxhqSkJKFD0SkHBwfs27cPUVFRWLFiRbX2wRjD5MmTIZVK8dlnn1U7Fl3tBwAePHiAt956C+Hh4Xj33XfL3U6hUCAtLa1KzygaEmN8aqju3fmQWkePAnocoYwQrZlMYgOA4GDg8mVALuezAM+cCWRlCR2V4ai7gC9evBipqakCR6Nbbdu2xaVLl3Do0KFq3UdMSkrCgwcPcPz4cdSpU6facehqPwAQGRmJRYsWlRnSrKTMzEx8//33UCgURtnF/+JF4I03gBkzgPBwYM8emomemACh6oraKChgbOlSxhwdGatXj7HISMZUKqGjMoyvvvqKNWvWjInFYta7d2+hwyFa+O9//8ssLS2Zt7c3mzt3bpn7gkJ68oSxkSMZE4kYCwhgLDpa6IiIKRG6KVLE2L9jE5mg5GRg3jxgzRqgWTM+i/aIEdRMQkh1xcQAP/wAbN7MnyH99ltgwAChoyKmJgABaIqmWImVQhS/0qSaIl/k6gqsWsX/GDt04InN05M3UdJ09oRUjkrFR+3v0QNo0wb4+29g2TLg+nVKasQ0mXRiU2veHFi/niezjz4CfvkFaNyY35P75Regmo9+EVKj/fMPv3fm5QWEhAASCfD773yutfHj+Uj+hJiiGpHY1Fxd+RQ3jx7xphRzcyA0FHBzA956i0+3kZsrdJSECOfGDd5836QJ0K4d8OuvwMiRwJ07fBLfwEDjmcSXkOqyePkmpsfSEhg6lC/p6cWPCYwYAYjFQEAAEBTEF29voaMlRH/y8oC//gKOHAEOH+ZD03l48L+Nd94BOnYUOkJCdM+kO49UVXIysHs3/wM/fpw3UTZuXJzkAgKAf+evJMRk3bjBE9mRI8DJk0B+PtCqFf8/3r8/0LUrYFaj2mqIsRG688grldhKUqmA6Gjg2DFg3z4+0LJIBPj68ud2unblTTXNmwsdKSHlUyp556nTp4EzZ3jt7PlzPq1MQABvWuzTh3eqIsRQKLEZieRk4M8/+cnh7FngyhV+0vD05EmuSxee6Fq1olodEc6DB/yC7Nw5/v9UPWBBnTr8/+gbb/ClXTuqlRHhUGIzUrm5fNSF06f5CeTcOX6/zswM8PHh3aLbtAHatuWvbm5CR0xqEoWCNylGR5deMjP5/0E/P37Bpb7oatxY6IgJKSZ0YquRnUd0wdaWj43370TSAPj4lFeuFJ9kVq4Enjzh79WtC7RowZsymzXjr76+/EY9IeXJy+OTdt6+zTt2qJebN4GCAj7YQIsW/ALqnXf4RVTLltRqQEhFqMampdTU4mQXG8uX27eBtDT+vkRSnOSaNQMaNQIaNuRLBRMqkxokL48/gqJe1Ens9m0gLo4PMmxhwf9vNG3Kl1ateBLz9eXvEWJKqMZm4lxc+A36wMDS65OTi5Pc7dv8559+4g+RKxR8G2vr4iRXcqlfn9f03NzoIVlTkJYGJCQAT5+WTmDqJTGxeFsnJ96U3awZbw1QX/A0bkz/1oToCiU2PXF15ct//lN6vUpV+gT48CF/jY0FDh4E4uNLzxTu5sYXdaLz8OAdBTw8gNq1i8sxkcmXTUZBAa+Np6byXobx8Tx5PXtW/Kpe8vOLP+fgUHyB8vrrwLvvlr5ocXAQ5HAIeaVQYjMwc3OgQQO+lLx/p6ZQ8JNlfDy/0i95Qo2PBy5c4OtfnLXG0pLXHl9cXF35q4ND8SKR8Hs0EknxuprYgy4nB8jO5lMbZWbyJSuLLzJZceJKTQVSUvhrcjJ/fXE6JLG49IVF27a8G727O//d3Z0vTk7CHCshpBglNiNjaVmc+CqSnw8kJfETsvqk/OKJOi4OOHDgSxQW9kB+fidkZpa/Pzu74oTn4MATsFTKn+1zdOTbODry39WJUCIpff9H/b6mfWtqZpPJStdO1XJzeRd2taws/uhFTg6vSeXl8ePPz+c/FxQUv1cyiRUWaj5WsZgfW8kLAHXnn1q1+PLixYGra/nfHSHEuFBiM1HW1hUnQJVKhQ8//BB//LEWa9euxejRnQCUrrWoay4ZGaXXZWXxmmN2Nk88Mhnv4KCetTw9HUX7UicP9XaaZGQsBmMtAQSXWm9ry5PMiywtS/f6UydGGxt+3Onpu+Hi4oNatVqgbl2eXNVJViLhtSaJhC9SaemaqURC97IIqekosdVAubm5GDZsGI4dO4Zdu3ZhQIm5R9QneENq0mQ9Ro0ahTlzgl++8UswxtC16zcQiaTYvPmwDqIjhNQ0NfDOyqstOzsbwcHBOHPmDI4dO1YqqQklJSUFrjpqyxOJRFi8eDGOHDmCo0eP6mSfhJCahRJbDZKZmYmgoCDcvHkTf/zxBzp37ix0SFAqlcjIyECtWrV0ts///Oc/6N+/P6ZPnw6Vppt0hJBXGiW2GiI9PR2BgYGIi4vDyZMn0apVK6FDAsBra4wxndXY1L755hvcvHkTv/zyi073SwgxfZTYaoCsrCz07dsXSUlJ+Ouvv+Dr6yt0SEVSUlIAQKc1NgDw9fXFuHHjMG/ePBQUFOh034QQ00aJzcTl5eVh4MCBuH//Po4cOYLGRjYabnJyMgDovMYGAHPmzEFSUhJ+/vlnne+bEGK6KLGZMKVSiSFDhiAmJgbHjh1Ds2bNhA6pjJSUFJiZmcHZ2Vnn+/bw8MCoUaOwePFiKJVKne+fEGKaKLGZsAkTJuCvv/7CoUOHjOae2ouSk5Ph7OwMc3Nzvex/5syZiIuLw86dO/Wyf0KI6aHEZqIWL16MdevW4ZdffkHHjh2FDqdcKSkpOr+/VlLjxo0REhKCzz//HIXlDTVCCHmlUGIzQVFRUZg1axa+//57DB48WOhwKqTLZ9jKM2vWLMTGxuLgwYN6LYcQYhoosZmYmzdvYsyYMfjggw8wZcoUocN5qeTkZL3W2ACgRYsWCAwMRGRkpF7LIYSYBkpsJiQ7OxshISFo0aIFlixZInQ4lZKWlqaXjiMveu+993Dw4EHExcXpvSxCiHGjxGZCxowZg9TUVPz666+wMpGRfDMyMuConh5AjwYNGgQ3Nzf89NNPei+LEGLcKLGZiHXr1mH37t3Ytm0b6tWrJ3Q4lSaTyeBggFGXLS0tMWrUKKxbt46G2SLkFUeJzQQ8fPgQH330ET755BP4+/sLHU6VZGZmGiSxAUBoaCji4+Nx6NAhg5RHCDFOlNiMXGFhIcaMGQNPT08sWLBA6HCqLDMzE1Kp1CBleXt7o1u3bti2bZtByiOEGCdKbEYuIiIC586dw5YtW2BtbS10OFWiVCqRm5trsBobwO+1HThwAAqFwmBlEkKMCyU2I5aamop58+bho48+QuvWrYUOp8oyMzMBwKCJbfDgwcjIyMCpU6cMViYhxLhQYjNi06dPh42NDebMmSN0KNUiRGJr2LAhWrZsiT179hisTEKIcaHEZqQuXLiADRs24Pvvv4e9vb3Q4VSLEIkNAAYOHIjffvsNjDGDlksIMQ6U2IzU3Llz0aVLF4SEhAgdSrUJmdgeP36Ma9euGbRcQohxsBA6AFLW2bNncfToURw/flzoULSiTmyG6hWp9tprr8HZ2dmoZhInhBgO1diM0Lx589C1a1cEBAQIHYpWMjMzIRaLIRaLDVqumZkZOnXqhDNnzhi0XEKIcaAam5G5fPkyjh8/bvK1NQDIysqCRCIRpOwuXbpgzZo1gpRNCBEW1diMzMqVK+Hn54cePXpotZ+DBw+iSZMmsLAQ7tolPz8fNjY2Vf5ceno6IiIiEBAQAGdnZ9jY2MDHxwfDhw9HTExMpfbRpk0bxMXFIT09vcrlq0VHRyM4OBiOjo6QSCQIDAykWiAhJoASmxHJycnB9u3bMWHCBIhEomrt4/79+xgwYADCw8ORlJSk4wirRi6XV6sZcvr06Zg0aRIGDhyImzdvIjU1FevXr0d0dDTatWuH33777aX7UN9bq24HkvPnz6NLly6QSCSIjY3Fw4cP0ahRI/j7++Po0aPV2ichxDAosRmRo0ePIi8vD0OGDKn2PtS9KS9fvixYM6BadRMbAIwdOxZTpkxBnTp1YGtri27dumHLli1QqVSYMWPGSz/v6ekJBwcH3Lx5s8plFxYWYty4cXB0dMRPP/2EunXrolatWli1ahUaN26M0NBQyOXy6hwWIcQA6B6bETlw4AA6duwINze3au9j3bp11Wr+04f8/PxqDQO2du1ajetbt24NGxsb3L9/H4yxl9ZqGzZsiMePH1e5/JMnT+LGjRuYNGlSqe/S3Nwcw4YNw4IFC7B//368/fbbVd43IUT/qMZmRE6fPo0333xTq30YS1IDtKuxaZKTk4O8vDy0aNGiUk21DRo0wKNHj6pczh9//AEAaN++fZn31OtqQuceQmoqSmxGQiaT4e7du+jQoUOp9bdu3cKgQYPg4OAAW1tbdOzYEfv370dgYCBEIhFEIhFCQ0MFirpicrm8qMami+PYuXMnAGD27NmVKt/d3R0JCQlVLv/WrVsAAA8PD437BIA7d+5UKgZCiOFRU6SRuHXrFgoLC9GyZcuidffu3UPnzp1hZ2eHqKgodO7cGXFxcZg6dSquhjeGdgAAIABJREFUXr0KsViM/Px8AaOumFwuh5WVlU6OIykpCTNnzkRoaCiGDh1aqfIdHR2RkZFR5fIzMjIAAHZ2dmX2qR7eTJveloQQ/aLEZiTi4+MhEolKzY49a9YsZGRkYO3atejZsycAoHnz5tiyZQsaNmwoUKSVp1QqYWFhofVxpKamonfv3vD390dERESly3dwcEBmZqZOv0f1+JPV7bVKCNE/aoo0EsnJyXB0dCzV2eLw4cMAgKCgoFLburq6omnTpgaNrzrUHTy0OY6cnBwEBQXBz88Pmzdvhrm5eaXLF4vFkMvlVS7f0dGxqGxN8ZTchhBifCixGYkXO1rI5XJkZWXB2tpa4+j+Tk5Ohgyv2hhj1T4OpVKJkJAQuLu7Y+PGjVVKauqyAVS5fHWye/r0aZn34uPjAQBNmjSpUiyEEMOhxGYkXuy+LhaLIZFIkJ+fj+zs7DLbP3/+3JDhVQtjDGZmZtU+jrCwMMjlcuzYsaPUCCre3t74+++/9Va+etSXy5cvl3lPvU7b3quEEP2hxGYk7O3ti0bDV+vTpw+A4iZJtcTERJPoladO1tU5jgULFuDGjRvYs2dPtR8ZkMlkkEqlVS6/e/fu8PPzQ1RUVKlOJSqVCtu2bYOnpyeCg4OrFRMhRP8osRkJNzc35Obmlrqv88UXX8DZ2RlTp07F77//juzsbFy/fh1jxoxBnTp1BIy2ctSJrarHsWHDBixcuBDnz5+HRCIp6o6vXu7fv1+p8lNSUuDi4lLl8s3MzLBu3TqkpaVhzJgxSExMRGpqKj788EPcvXsXa9asqdaD54QQw6DEZiTq168PAHj48GHRusaNG+PcuXPo0KEDhgwZAjc3N4SFhSE8PBze3t4a97N///6iBBAfHw+VSlX0e3kjeuiLOrFV9TiioqJ0Un5qaipcXFyq9T126tQJZ8+eRWZmJnx9fdGwYUPcvXsXf/75Z5lOKIQQ40Ld/Y1EkyZNYGlpiRs3bqBFixal1u/evbvS++nXr19RpwmhlbxnWJXj2L9/v07Kv3fvHrp161bl8tXatm2LgwcP6iQWQojhUI3NSIjFYjRt2hSXLl0SOhSdsbS0hEKhEKz8O3fuwNfXV7DyCSHCoMRmRLp3744TJ04IHYbOWFlZoaCgQJCynzx5AplMZhLP+xFCdIsSmxEJCAjAlStXKuwCv23bNohEIhw/fhxyudyox4q0srIqd3oXfR/H2bNnYWFhgXbt2glSPiFEOJTYjEhQUBBsbGywa9eucrd59913wRgrtRi6U0hlVVRj0/dxnDlzBm3atNH4ULYhyieECIcSmxGxtbVF3759sW3bNqFD0QmxWCxYU+SJEyeKOo4QQl4tlNiMzJgxY/DXX3/h+vXrQoeiNaHusT148ADXr19H//79DV42IUR4lNiMTFBQELy9vbFq1SqhQ9GapaWlIIltz549cHR0xBtvvGHwsgkhwqPEZmTMzMwwbdo0rFu3DnFxcUKHoxWhamy7du1CcHAwLC0tDV42IUR4lNiMUGhoKDw9PTF//nyhQ9GKEInt8ePHOHPmDIYNG2bQcgkhxoMSmxGytLTEZ599hl9++QUxMTFCh1NtFXX315dNmzbBycmpaEJRQsirhxKbkRo6dChat26NuXPnCh1KtRm6VyRjDBs3bsS7774LKysrg5VLCDEulNiMlJmZGb7++mvs378fv/76q9DhVIuhmyKPHDmCO3fuICwszGBlEkKMDyU2IxYYGIjQ0FC8//77SEpKEjqcKjN0Yvvxxx/Ro0cPtGrVymBlEkKMDyU2I7dkyRI4ODiYZC3EysoKhYWFUCqVRevy8vKQmpqq1X4vXLiAx48fl1p3//59HDp0CBMnTtRq34QQ00eJzcjZ2dlh9erV2Lt3LzZv3ix0OOVKS0vDlClTMHbsWAwdOhT+/v6YM2cOnJycUL9+fUgkEpibm8PW1hYDBgzQqqxNmzbBx8cHM2bMQHp6OgBg5cqV8PDw0HrfhBDTR/OxmYCAgABMmjQJH3zwAdq2bQs/P79S7+fm5uL8+fPo0aOHQBECzs7OOHbsGGJjYyucD87MzAx9+/bVqqyrV6+ioKAAS5YsQWRkJMLDw7FhwwZ88sknsLCg/9KEvOqoxmYivv32W7z22mvo168fUlJSitbn5+ejX79+GDlypGDjMqpNnDgRZmYV/5cqLCxEcHCwVuWohxtTKpWQyWSYM2cOFAoFrKysoFKptNo3IcT0UWIzEZaWlti+fTuUSiWGDRsGpVKJgoICDB48GKdOnUJCQgLWr18vaIwjR46EWCyucJtatWqhdevW1S4jIyOjzD06lUqF7OxsTJ8+Hc2bN8eBAweqvX9CiOmjxGZC3NzcsGvXLpw5cwazZ8/GiBEj8Pvvv0OpVIIxhoULFxr8geiS7O3tMXLkyHKfIbO0tMTgwYMhEomqXcaNGzc0rldPPXPv3j3069cPvXr1MvkhyQgh1UOJzcS0b98eGzZsQHR0NHbt2lXU9MYYQ3JysuC1tgkTJpTbJKpUKrVuhrx582aF99FUKhVEIhFcXFxQt25drcoihJgmSmwmhjGGY8eO4dixY2XuJ6lUKsyfPx95eXkCRQe0atUKHTp0gLm5eZn3LCwsEBAQoNX+b968WeF9PJFIhIkTJ2Lz5s00+gghryhKbCaEMYYPP/wQ69atQ2FhocZt0tLSBK+1TZo0qUx8ZmZm6NatGyQSiVb7VveILM+8efOwfPnyl3ZiIYTUXPTXb0I+/vhjREZGlpvUAF5r+/TTT5Gfn2/AyEobOnQoHBwcSq0zMzPDwIEDtd63pglYzczMYGZmhrVr12LBggVal0EIMW2U2EzE7du38dtvv4ExprGZr6TU1FSsWbPGQJGVJRaLMW7cuFLzoSmVSq2fX5PJZEhOTi61ztzcHFZWVti/fz/GjRun1f4JITUDJTYT4evri3v37mHPnj1o27YtAJTbiUJdaxPyXtsHH3xQaigtLy8veHt7a7XPmzdvlnr428LCAnZ2djh+/Dj69Omj1b4JITUHJTYTYmZmhv79++PixYs4deoUevbsCZFIpHGm6PT0dEFrbY0bN4a/vz8sLCyKuvlr68aNG0W1VUtLS7i5ueHChQvo0qWL1vsmhNQclNhM1BtvvIGDBw/i9u3beP/992FlZVUqwalrbbm5uYLFOGnSJKhUKigUCp3UqGJjYwHwmpqPjw8uXrwIX19frfdLCKlZaGA9E+fj44Ply5djxowZWLp0KSIiIiCXy6FUKpGamorVq1dj6tSpWpWRmQkUFgJZWYBSCeTkAOqOiXl5QHn9VAoL+0MqdUVeXhaSk/+DnTuL3xOLAVtbzZ+zswPUPfVtbABra779P/9cg0qlQrdu3bBv374yHVQIIQQARKyiEWuJycnMzMTy5RFYuvRbpKWlQCp1wYoVj6FQ2CIrC0VLRgZK/a5ep1LxRAYA/w6cr6UFAK4C2KWDfTUA0AHAZpibiyGVAiIR4OgIWFgAEgn/WSLhi709IJWWXefoCLi4FC82NjoIjRBSJAABaIqmWImVQhS/kmpsJiA3F4iPBxITgWfP+GtKCpCaCiQnF//MFwfI5f8DMBXAJshk32LkyAjY208rc7K3twccHAB3d/7q4ACYmQFOTrxc9e8SCU8c6pqUuhYFFCcUTaytgYyMMBw7dgwjR5Z+LzsbUCg0fy4jA1Bfbqlrh2lp2VixYgBCQ5chL88MCgXfh0oFyGR8XyUTdno68ORJ8c/Z2fxnTf1pbG2Lk5yrK3+tVat4nYcH4ObGv6c6dXjtkRBivKjGJrDUVODhQ+DRI+DxY+DpU+D5c/6alMQTWlZW8fbm5kDt2vzEW3IpWQNR/16rFuDgUIi7dy+gU6dOgh2jSqV66SMKhtgH3w9PfsUXAqUvDJKTS7+XnMz/PUpyceEJrl49oG5dvtSrBzRsWLxIpVqHSojJohpbDZeXB9y5Azx4wJPXo0fFiezRo+KkZWbGT5YeHvy1WTOgR4/ik6f6tXZtntwqzwwuLsIlNQA6SUi62AffT/EFQGUVFJS92EhKKv796lVeky6ZAJ2dSyc6Ly/+6u0NNG4MaOjISgjREUpsOpKeDty4Ady8yZPYgwf899u3eS0B4E18jRrxpW9f/qpOWk2b8qY+YnysrPgFh4dHxdvJ5Tzpqf/9HzzgCe/qVeC33/gFDWO8+bZ+ff7v7+cHNG9e/P+iUSPDHBMhNRkltirKyQGuXQOio4uXmzeLa15OTkCTJrzGNXIk/7lpU36VTvdmajaxuOLklJ0N3L3LL3Zu3wZu3QJOnQLWreP/rwBek2zZEmjdGmjThi/Nm1MNj5CqoMRWAZkMOH8e+Oef4iR29y6vgUml/KTTsSMwblxxMqtdW+ioibGytwfatuVLSYzxji7qhHf1KnD2LLB6NW/KtrLiyU2d7Nq14wv15iREM+o8UsKzZ8CZM8Dp0/z1yhX+/FbduvzE4udXfFJp1ozfFyNEX1QqIC6ON2lfvsyXixf5fT0LC34x9cYbQNeuQLdu/D4eIcZA6M4jr3Rii40FjhwBTpwA/v6b3/wXi3ni6tyZnzA6d+adOQgxFg8f8hrduXP8AuzaNZ4E69fn/2cDAoCgIMDTU+hIyatK6MT2SjVFpqcDx4/zZHb0KO9e7+QE+PsDM2bwJNauHd0LI8bNy4svw4fz37OygAsXeLI7fRqYPJk3Yfr58QTXqxfQvTs1XZJXR41PbE+eADt3Ar/+yu+XAfy+2Jgx/I++Y8eqdp8nxLhIJMCbb/IF4EOcnTpVfAG3ZAl/WL57dyAkBBg8mD+OQEhNVSObIp89A6KigB07+FWsoyMwcCAQHMz/+NUjaxDyKnj2jCe4ffuAgwd5s2XPnsDQocCgQXyEGUJ0SeimyBrT/UGp5LWygAB+b2HuXN5cs3cvH4Lqp5+AIUMoqZFXT716wOjR/O/j+XP+t2BuDoSF8aHC3n6b32cmpKYw+cSWlgZ89RV/TmzoUN6lOiqK9xz75RegX7/ikeIJedVJJPzenPqCLyKCvwYEAK1aAWvXah5PkxBTYrKJLSkJmDCBjwbx5Ze8NnbnDv+DHTy4eJBeQohmjo68JnfmDHDpEvDaa8DEibzFY8EC/kA5IabI5BJbXh7wxReAjw+wfz/w3Xd8zL7vvuO1NkM7ePAgmjRpAguLyvXDqer2AB8AODw8HD4+PrC2ti41aWd2djZEIlGp5dy5cy/d5/Tp00t95vPPPy+zzcWLFzF69Gh4eXnBxsYGzs7OaNGiBd5++22sWrUK9+/fL9q2RYsWZeLQtJiZmSExMbFMWXFxcRgwYABkMlmp9dHR0QgODoajoyMkEgkCAwNx5syZSn93JVXnu1dLT09HREQEAgIC4OzsDBsbG/j4+GD48OGIiYkps/3MmTOxffv2cvc3ZswYiMVieHl5YcqUKcgvb1I7A2nXDtiwgfcUnjIFWLaMPye3fj1/lpMQk8JMyM6djNWvz5i9PWOff85Ybq5wsdy7d4/179+ftWrVikmlUmZubq7T7UuKjIxkANinn37K0tPTNW5z5coVBoABYH369KlwfykpKcze3p4BYMOHDy/zvkqlYp988gmzsLBg06dPZ7GxsSw/P58lJiayo0ePssDAwKKyFAoFY4yx5s2bs927d2ssLy8vj/n5+TEAbNq0aRpjr1WrFvvhhx9Krf/777+ZjY0Ne+edd9izZ89YcnIye++995iFhQU7cuRIhcdYkjbfvdq4ceOYhYUFW7p0KUtISGA5OTns5MmTzM/Pj5mbm5c59nv37jEvLy82Z86ccvcpk8lYREQEA8AWLVpU5Zj0KTmZsYkTGbO0ZKxNG8ZOnxY6ImJKerAe7AP2gVDFrzCJxJadzdjo0YyJRIyNHctYQoLQETE2bNgw9uWXXzKFQsHc3d1ferKs6vYvfhYAk8lk5W5z5coVZmNjwxo0aMAAsIsXL5a77ezZs1mzZs3KTWyzZs1iANjq1as1fl6pVLI+ffpUOrFNnjyZAWAtWrRg+fn5pd7LzMxkHh4eLCwsrNR6lUrFmjdvzurWrctyS1zBKJVK5uvryzw9PcvsqzzafPdq48aNY+PHjy+zPjo6mgFgPj4+Gt8TiURs+/btFe7b1taW9erVq8oxGUJsLGO9ezNmbs7YggWMqVRCR0RMASW2l0hJYez11xmrVYuxffuEjqZYyZNtZU6WVd2+pF69er10+ytXrjA7Ozu2atUqBoANHDhQ43bp6enM2dmZbdiwQWNii42NZWZmZqxdu3YVlnf27NlSia08R48eZSKRiInFYhYTE1Pm/dmzZzMLCwsWHx9fav2JEycYADZp0qQyn1mwYAEDwKKioiosW02b774ybGxsmJmZGSssLCzzXkhICPPw8Kjwe6pXr95Lv28hFRYy9uOPjInFjA0dylglryfIK0zoxGbU99iys/moCc+f8xvc/foJHVExmyoO41DV7UtSqee9qYQxY8bA3d0de/fuxdWrV8u8v3z5cvTt2xeNy7khuXr1ahQWFiIkJKTCcjp37gzGWIX3q9LS0jB69GgwxrBo0SK0atWq1PuMMaxduxavv/466tWrV+q9P/74AwDQvn37MvtVrzt+/HiFMapp892/TE5ODvLy8oruMb5o8ODBePr0KQ4cOFDuPkQiEZRKpd5i1JZIBHz4YfED3//3f3TfjRg3o05s773H57c6fpzfyCYvJxaLMX369KJkUlJ2djZ++OEHzJo1q9zPnzx5EgDKJKHqCAsLw7Nnz+Dv749p06aVeT8mJgZJSUlo3bp1mfdu3boFAPDQMAmau7s7AODOnTtax6itnTt3AgBmz56t8f02bdoAAI4cOWKwmPSle/fih7y/+ELoaAgpn9EmthMngG3beE+tV33U8oKCAoirMIDl+PHj4ebmhqioKMTGxhatX7FiBQICAtCsWbNyP/vs2TMAgEtVppjW4Oeff0ZUVBQcHR3x888/a6zNXL9+HYDm5JWRkQEAsNMw+6q9vT0A3lNRSElJSZg5cyZCQ0MxdOhQjduok7D6WDURi8VQKBR6iVHX3ngDWLSIL3FxQkdDiGZGm9hWreJXiL17Cx2J8B4/fqzx5F8eGxsbTJs2DYWFhfji30vr3NxcLFmypNyaxYs0JaLKevToESZNmgQAWLlyJTzLGWY+ISEBAOBQxTGd2L+jwGkTo7ZSU1PRu3dv+Pv7IyIiotztpFIpRCJR0bFqUq9ePcTHxxt1c2RJkyfzEXx++knoSAjRzGgT29mzQP/+QkchrLS0NHzzzTeIi4vDhAkTqvTZCRMmwMXFBVu3bsW9e/cQGRmJTp06vbSJUX2vKyUlpVoxFxYWYtSoUZDJZBg2bBiGDRtW7rbqZ7csNUwP7ejoCIDfw3qRep16G0PLyclBUFAQ/Pz8sHnzZpi/ZBRtCwsL5FUwnEdYWBhkMhnmzZtX7e/dkCwsgL59+X1vQoyR0Sa29HRAy9YwkzZ69Gi4uLhg5syZmDFjBiZPnlylz9vb22Pq1KlQqVSYP38+vv32W8yZM+eln+vevTsAaOx4Uhlff/01Tp06BU9PT6xcWfEAqNb/Dg+jqRmuadOmAICnT5+WeS8+Ph4A0ESAG69KpRIhISFwd3fHxo0bX5rU1J+pqAPLiBEjsGjRInzzzTdwdXVFbxNopnBx4X+jhBgjo01sDRoAt28LHYVwNmzYgMzMTGzbtg3ff/89wsLCqryPSZMmwcHBAVu2bEHr1q019jB8UVhYGCwsLBAVFVXhdjNmzICZmVlRJw8AuHLlCubNmweRSISNGze+tEZVt25dAEBmZmaZ93r06AEAuHz5cpn31OveVM/TYkBhYWGQy+XYsWNHqR6h3t7e+Pvvv8tsL5PJwBgrOlZNZs+ejVmzZmHVqlXIyMjA4cOH9RK7Lt2+zf9GCTFGRpvY+vcHtmwB5HKhIxGOVCpFSEgI2rZt+9JEo4mDgwOmTZsGBweHStXWAF4Lmj9/Pi5duoT169dr3Ob27duIjIzE0KFDi2pW+fn5GD58OBQKBaZNm1aUmF40ZMgQfPvttwD4MFyA5lpZ9+7d4efnh6ioqFLDTalUKmzbtg2enp4IDg6u1DHpyoIFC3Djxg3s2bOn0p151LVL9bFqsmvXLnh5eSE0NLTK9xuF8OwZcPgwMGCA0JEQopnRJrZJk/jI/Z99JnQkwpNKpWXGUKysefPmISMjA126dKn0Z+bMmYOZM2fi/fffx8yZM3Hnzh0UFBQgPj4e69atQ48ePdCqVSusW7eu6DMzZsxAbGwsWrZsWeYxg/K0bt0atWvX1jjWopmZGdatW4e0tDSMGTMGiYmJSE1NxYcffoi7d+9izZo1RU2ZaiNGjIBIJMLDhw8rfayaaNrPhg0bsHDhQpw/fx4SiaTMGJglx80sKTo6GgDQq1evcsvLysqCVCrVKmZDYYz/bXp48Nk0CDFKQj0aXhmrV/NhtDZvFjqSsvbt21c0XuKLy5o1a7TevqTAwMAKR8uws7Mrtb+goKAK96cphhfHaWSMsQsXLrCRI0cyT09PZmlpySQSCevUqRNbtmwZk8vlRds9efKEiUSico/vxeWbb74p+uysWbM0jjyi9s8//7A+ffowqVTK7O3tWUBAADtdzsCFAQEBzN7enimVylLrq/rda9pPcHDwS4/r3LlzZfYVEhLC3N3dWUFBgcaYGeOjobRp06bc943JnDl8/MgTJ4SOhBgzoUceMerExhhjM2bwceo0nHdfGcHBwUwkEgkdhl5kZGQwd3f3MmNFVlV6ejqzsbFhoaGhRrEfxorHity6dWuF27m5ubFOnTppXZ4+KZWMTZ7MmJkZY+vXCx0NMXZCJzajbYpU++or3hw5eTKfILGaLXImzcPDA4wxJCUlCR2Kzjk4OGDfvn2IiorCihUrqrUPxhgmT54MqVSKz7Rou9bVfgDgwYMHeOuttxAeHo5333233O0UCgXS0tKq9JyioT1+DPToAaxezQdNGDNG6IgIqZjRJzYACA8Hfv8d+PNPPufasmVAFYZPNHnq7t+LFy9GamqqwNHoXtu2bXHp0iUcOnSoWvcSk5KS8ODBAxw/fhx16tSpdhy62g8AREZGYtGiRRXeb8zMzMT3338PhUJhlF388/L4hWXLlkByMnDuHPCSIUQJMQ5C1RWrIy2Nsf/9j48y3qwZYwcOCB2R4Xz11VesWbNmTCwWs969ewsdDtHSf//7X2Zpacm8vb3Z3Llzy9wXFFJhIWM7djDWsCFjdnaMzZ8v7NyHxPQI3RQpYuzf8YlMyO3bwPTpfEDW7t15L62BA/mICISQ6snNBTZtAn74AYiN5U2On30GaFl5Ja+gAASgKZpiJSoepEFPVppEU+SLfH2BvXt506SDA+923KgRsHgxYAIjEhFiVB4+5BeKHh78Xnb79sCVK8CaNZTUiGkyycSm1r07sGcPcPcuT25ffQV4evKff/2V3yMghJSVng6sXw8EBQHe3rxTyCefAE+e8MGNW7YUOkJCqs+kE5tao0bAt98CT58Cy5fzWts77wBubsCIEbzJ8lUewYQQgPco/uUXPqpPnTp88lBbW2D7dl5rmzULcHUVOkpCtFej7krZ2fHJSd97D0hMBKKi+B/toEGARAIEBvIZuYOCaJw78mq4fp3Pen30KPDXX3zm6549gbVr+X1pExnwhJAqMcnOI1X19Cmwezcf3+6vv4CcHH6fTp3kuncH/p27khCTlpLCZ5w/coQns/h4PhJ/YCCf23DgQD6XGiH6JHTnkVcisZWkVAIxMbx5cv9+4J9/ADMznujeeAPo2hVo1w5o3lzoSAl5uQcPgNOngcuX+fxoV64AIhHQpg1PZoGB/MJNw5R3hOgNJTaBJSby3pVnz/IlJoYnPw8PnuS6dOGJrlUr3pxJiFDS0njiuniR/189d47X0GxseE/GLl340r077y1MiFAosRmZnBx+4jhzhp84zp3jJxQzMz7qSZs2fGndmr+6uwsdMalpGOM1sehovsTE8NcnT/j77u5A5878wqtzZ+C116hGRoyL0ImtRnUe0QU7O8Dfny9qjx6VPsGsWcPXAbwXWcuWQJMmQNOmfGnShHdOMasRfU6JvigUvDdibCwfdOD2beDWLd7hQyYDzM0BHx9+AfXhh8UXVPRsGSEVo8RWCQ0b8mXQoOJ1GRnFye7GDeDmTWDXLuD5c/6+tTW/b+fryxOdj0/xftzd+UmL1HwFBXwQ4bg4fjF09y5PYLGxvFamUPDt6tfn/1fatgVGjeJJrGVL3h2fEFI1lNiqydGxbM0O4A++qk9cd+7wn3/9lZ/E1M/SWVrye3jqRNegAeDlxX+uW5cnPjqhmQaZjPc8jI8vTl4ll2fPeBd7gPe89fbmCeydd3jtXn3xY2cn3DEQUtNQYtMxJyegUye+lMQYkJBQ+qSnPhGeOcN/LvkQuVTKE1ydOppfa9Xi3bhdXKj2p2sFBUBqKl+Sk3nSSkzU/JqbW/w5Ozt+ceLlxZsMBw4svnhp2JD/mxFC9I8Sm4GIREC9enzp0qXs++rEl5DAr/JLviYk8BpgQgKQlFR2yh4np9KJ7sVFKuU9Ou3t+c+OjsW/19SaYVYWkJ3NX7OyeNOx+meZrDhxlVySk/lrVlbpfVlZ8VFsPDz4a+vW/CFnT0+gdm3+WqcOjdpBiLGgxGYkSia+du3K306l4vfxUlKKT8glf1Yvd+8W/yyTFd/LeVED86fIkdaFxNEc9vb8JG5nx19tbPi9QrGYJ0BLS54Mzc1Lj1ih/owmmh4GVqnKnzBWJiuduNPTGQARMjN5k15WFn8cIyeH16zy8oD8fP6qTmTp6eV/f9bWPPaSib9ePX4/S9PFQa1aPHkRQkwHJTYTY27O78PVrVu1z+XnF9dY0tP5a+GDR+g04z+42fU9HO8ytyhpvJg8MjJ405tczpveFAqeRNRyc4Hc3Bj05VW6AAAgAElEQVTk538LW9tVEIn4MC7qfWni4KC516itLU+kAJCa+hGsrBjq118KiYRPS6R+38WFJ151UhWLeS30xRrpi+uoWzwhNR8ltleEtTVfiprL4uOBcW8C7k5o/9OHaO+s3f5//PEU5s07gNRUO4hEWocLAFi1qgmmTp2K7dsnoXHjxrrZKSGkxqMnrV5Fycl8oEwLCz6goLOWWQ3ApUuX0L59e4h0ldUAvPfee2jUqBEWLFigs30SQmo+SmyvmowMPhquXA6cOMF7Q+jAxYsX0b59e53sS83CwgILFy7Eli1bcOXKFZ3umxBSc1Fie5XIZHw6g+Rk4Pffea8JHcjOzsbt27d1ntgAICQkBB06dMDs2bN1vm9CSM1Eie1VkZsLDBjAH5w7epQ/bKUjMTExUKlUaFdRd85qEolEWLx4MQ4dOoQ//vhD5/snhNQ8lNheBQUFwJAhfOyvP/7gQ17oUGxsLOzs7FC/fn2d7lfN398fPXv2RHh4OGjMbkLIy1Biq+kUCp7Uzp7lM63qYaK527dvw9fXV6cdR170zTff4NKlS/jtt9/0VgYhpGagxFaTMQaMHs0nnDt8uOInv7WgTmz61Lp1a4SEhCA8PBxKpVKvZRFCTBsltppsxgwgKgrYvbvs4JU6ZIjEBgBffvklHj58iA0bNui9LEKI6aLEVlOtWgV89x2fPO7NN/VWjEKhwMOHDw2S2Ly8vBAaGor58+cjt+Tow4QQUgIltppozx5g0iTg66/55F56lJCQAIVCAS8d9rKsyNy5c5GZmYkff/zRIOURQkwPJbaa5uRJ4N13+ZTLn3yi9+KePXsGAKhb1cErq6lOnTqYOnUqvv76a8jKG0mZEPJKo8RWk9y7B7z1FtCvH7BkiUGKTEhIgEgkgpuORjCpjE8++QSFhYVYtmyZwcokhJgOSmw1hUwGDBrEp+PeuFHz0Pl6kJiYCGdnZ4jVQ/IbgKOjI6ZMmYLvvvsO6RXNUUMIeSVRYqsJlErg7bf5fDR79hh09tDExESDNUOW9NFHH8Hc3JxqbYSQMiix1QRTpgBnzgC//caneTag58+fo7YAM3FKpVJMmzYNS5YsQVpamsHLJ4QYL0pspu6HH4CICGDzZqBDB4MXn5OTA7vyps/WsylTpsDa2hrfffedIOUTQowTJTZT9uefwLRpwOefA4MHCxKCXC436P21kuzt7fHxxx9j2bJleP78uSAxEEKMDyU2U/XkCfDOO7wH5MyZgoVRUFAAKysrwcr/8MMPYW9vT7U2QkgRSmymSC7nAxs7OfEekHocfPjloQhXYwMAOzs7zJgxAytWrEBSUpJgcRBCjAclNlM0cSIQG8vHgJRKBQ1F6MQGABMmTICjoyO++uorQeMghBgHSmymJjISWLcO2LQJaNZM6GhQWFio1+lqKsPa2hr/+9//sGrVKsTHxwsaCyFEeJTYTMmVK7xr/5w5fDZsI2Bvb4/s7Gyhw8D48ePh6upKtTZCCCU2k5GTA/zf/wGvvw7Mny90NEUkEgmysrKEDgNisRjh4eFYs2YNEhIShA6HECIgSmym4oMPgNRUYMsWwNxc6GiK6CuxHTx4EE2aNIGFhUWlPzN27Fg4OztjiR7HyUxPT0dERAQCAgLg7OwMGxsb+Pj4YPjw4YiJidFbuYSQyqPEZgo2bOD31NauBdzdhY6mFKlUqtPEdv/+fQwYMADh4eFV7uUoFosxdepUrFy5EqmpqTqLqaTp06dj0qRJGDhwIG7evInU1FSsX78e0dHRaNeuHX777Te9lEsIqTxKbMbu7l1g8mTg44+N5r5aSRKJRKfTx8ydOxddunTB5cuXIZFIqvz5CRMmwNraGqtWrdJZTC8aO3YspkyZgjp16sDW1hbdunXDli1boFKpMGPGDL2VSwipHBFjjAkdBClHQQG/p2ZlBZw+DVhaCh1RGatXr8b06dORmZmpk/3l5eXBxsYGAODh4YHExEQolcoq7WPu3LlYtWoVHj16BHt7e53EVRm2traQy+VQKpWC9xQlREgBCEBTNMVKrBSi+JVUYzNmCxfyGtumTUaZ1ADAx8cHMpkMiYmJOtmfOqlpY+rUqZDL5Vi3bp0OIqqcnJwc5OXloUWLFpTUCBEYJTZjdfky8M03wLffAj4+QkdTriZNmgAA7t69q/H9W7duYdCgQXBwcICtrS06duyI/fv3IzAwECKRCCKRCKGhoTqNycXFBePGjcO3336LgoKCl26vixh37twJAJg9e7ZOjoEQogVGjE9eHmN+fowFBjJWWCh0NBUqLCxkEomErV27tsx7d+/eZY6Ojszd3Z0dPXqUZWVlsevXr7PAwEDm6urKxGJxhft2d3dn5ubm1YrryZMnzMrKiq1fv77C7bSNkTHGEhMTmZubGwsNDa1WrITUND1YD/YB+0Co4ldQjc0YzZgBxMcD69cLOg5kZYhEInh7e2ussc2aNQsZGRlYtmwZevbsCXt7ezRv3hxbtmxBTk6OXuPy8PDA8OHD8dVXX6GwsLDc7bSNMTU1Fb1794a/vz8iIiJ0eQiEkGqixGZsTpwAVqzg86x5egodTaX4+voiNja2zPrDhw8DAIKCgkqtd3V1RdOmTfUe1//+9z/cvXsXu3fvLncbbWLMyclBUFAQ/Pz8sHnzZpgb0fOFhLzKKLEZk7w8YPx43q1/5Eiho6m09u3b4+zZs2AlOtjK5XJkZWXB2tpaY89EJycnvcfl6+uLwYMH4/PPPy8Vmy5iVCqVCAkJgbu7OzZu3EhJjRAjQonNmCxaBCQl8dqaCenatStSUlJw7969onVisRgSiQT5+fkax5I01MSgc+bMQUxMDH7//fcy72kTY1hYGORyOXbs2FFqdBRvb2/8/fffugmeEFItlNiMxe3bvAfkokWAh4fQ0VTJa6+9BltbW/z555+l1vfp0wdAcXOfWmJiIu7cuWOQ2Nq0aYOePXviyy+/1Ph+dWJcsGABbty4gT179gg+ZQ8hRAOhuq2QEgoLGevRg7H27RlTKoWOplr69evHBg0aVGrdvXv3mLOzc6keh9euXWO9e/dmDRo00GuvyJJOnDjBALAzZ86Uea+qMf70008MQIXLuXPntI6ZEFNGvSIJn1/t5Ek+15qJ3qsJDg7GsWPHkJ+fX7SucePGOHfuHDp06IAhQ4bAzc0NYWFhCA8Ph7e3t8b97N+/v+jZsfj4eKhUqqLf165dW63Y/P390aVLF41T2lQ1xqioqGrFQAgxHBpSS2gpKYCvLzBqFKDHUen17dmzZ6hfvz527NiBt95666XbBwYG4vTp06USoT7t3bsXgwYNwtWrV9GiRYtKfcbQMRJSU9CQWq+6+fMBsRj49FOhI9FKvXr10KNHD2zatEnoUDTq378/mjVrhu+//17oUAghekaJTUixscDq1cAXXwDVGMne2IwaNQoHDhwwWI/HqhCJRJg2bRq2bNlCE5ESUsNRYhPStGlAixa8GbIGGDJkCKRSaYVTxmzbtg0ikQjHjx+HXC7Xy1iR5RkxYgScnJywYsWKCrcTMkZCiPboHptQDh0C+vYFjh0D3nxT6Gh0Zt68eYiIiEBcXJxORurXtU8//RTLli3D48ePYWdnJ3Q4hNRIdI/tVaRS8fEg33qrRiU1gE/0mZ2djcjISKFD0WjixImQy+XYuHGj0KEQQvSEEpsQVq8G7twBNHQ/N3V16tTBlClT8OmnnyItLU3ocMpwdnbGiBEj8N1330GlUgkdDiFEDyixGZpczjuLhIUB5TzLZepmzZoFKysrjc+NGYNp06bh0aNH2Ldvn9ChEEL0gBKboa1Zw59d+9//hI5EbyQSCWbPno3ly5cjLi5O6HDKaNKkCYKDg6nrPyE1FCU2Q5LLefNjWBjg7i50NHr1/vvvw9PTE+Hh4UKHotG0adNw6tQpnD9/XuhQCCE6RonNkFav5rW16dOFjkTvLC0tsXTpUmzduhV79uwROpwy/P390bFjRywx4dFeCCGaUWIzFLkc+Ppr4P33a3xtTa1v374YO3Ys3nvvPaN8aHvKlCmIiorCgwcPhA6FEKJDlNgMZc0aIDWVd/N/hSxZsgQ2NjYICwsTOpQyhg4dCnd3d/z4449Ch0II0SFKbIZQWAgsXQqMHQvUrSt0NAYllUqxbt067NmzB9u3bxc6nFIsLCwwadIkrF27FhkZGWXeVygUAkRFCNEWJTZD2LcPePAAmDhR6EgEERgYiAkTJmD8+PG4deuW0OGUMn78eJiZmZWaEufcuXMYOnSoUdYyCSEvZ/HyTYjWli0DgoOBpk2FjkQwS5YswdWrVzFw4EBcuHABDg4OQocEgNcox44di6VLl8LV1RVLly5FdHQ0RCIRevXqJXR4hJBqoBqbvl2/Dvz5JzBlitCRCMrS0hI7duxATk4ORo0ahcLCQqFDAgA8f/4cVlZWSE5OxpgxY3Dt2jUAAGMMycnJAkdHCKkOSmz6tmQJ4OdX48aErI46depg+/btOHz4MD7//HON2ygUCiQlJek9ln/++Qfjx4+Hp6cnvvvuOxQUFIAxVmqYrdTUVL3HQQjRPWqK1KfkZGDLFt4UKRIJHY1R6Nq1K5YvX44PPvgADRo0wH//+9+i9xhjGDduHORyuV47mmzcuBGjR4+Gubl5heNFpqen6y0GQoj+UI1NnzZtAqytgREjhI7EqISFhWH27NkYN24coqKiitbPnz8fmzZtws6dO/H333/rrfxRo0Zh3LhxL90uOzvbaJpMCSGVRzU2ffr5ZyAkBLC1FToSo/PZZ59BJpNh+PDhcHBwwOPHj/HZZ58BKO6Gf+HCBYj0UNMViUSIjIxERkYG9uzZA6VSqXG7wsJCZGZmwsnJSecxEEL0h2ps+nLjBhAdDYwcKXQkRuv777/HoEGDMGjQIIwfP75ovVKpxOXLl7Fjxw69lW1ubo4tW7age/fusLAo//rOGKfeIYRUjBKbvmzcCDRoALzxhtCRGC1zc3N89NFHUCgU0DSR+8cff4z8/Hy9lW9lZYW9e/eiTZs2sLS01LgNJTZCTA8lNn0oLAS2buW1Neo0Uq6HDx+iX79+KCwsLJPYGGNITEzE8uXL9RqDra0tDh06hAYNGmhMbtQzkhDTQ4lNH44fB54+BYYPFzoSo5WamoqePXsiMzOz3J6JKpUKCxYs0Hv3/1q1auHEiRNwdXUt1SxpZmZGNTZCTBAlNn3Ytg3o2PGVHmmkIvn5+RgwYADu379fbscNNaVSiYULF+o9Jg8PD/z555+QSqUwNzcHwJtKKbERYnoosekaY8ChQ8CgQUJHYrTU99b8/f0hEolgZWVV7rYKhQKRkZGIjY3Ve1w+Pj44fPgwxGIxzMzMqMZGiImixKZrly8DCQl8bEiikaWlJYYMGYITJ07gzp07+Oijj+Dk5ASRSFRUWyrJ3Nwc06ZNM0hsHTp0wN69e2Fubg65XE6JjRATJGKauqOR6lu4EFi7Fnj8mDqOVIFcLsfevXuxcuVK/PXXX7C0tERBQUGpbY4cOaLXgYkLCoCcHCA7G9i791dMmjQUffoMx8yZP0MuL72tQsG3e5GNDX8mvyQLC0Ai4T9LJICVFeDgwLezsdHPsRAipAAEoCmaYiVWClH8Skpsuvb660DbtkBEhNCRmKxr164hMjISGzZsQH5+PhhjYIyhadOmuHbtmsZandrz53xJTATS0oD0dL6U/Fm9ZGbyRFZQwH8vayOAKAD79HSknFTKk51UCtjbA05OxYuzc+nfnZwANzegTh2gdm2ggq+CEMFQYqtJkpP5GWf3bmDAAKGjMXnZ2dnYunUrfvzxR1y9ehUAMG3aGvj5heLJE568nj0DkpKKX0vODSoSVZwkHBx4IrG05L9bWQF2dnyxsuLrTp/+HQEBPWFnVzo2kQhwdCwbc1YW8GJ/mPx8IC+P/5yZyWOUyfi6/Hz+s0LB38vOLj8Zp6UBJTuQmpvz5FanDlCvHv/Zw4PPZduwYfFCtUJiaJTYapKffwbGjwdSU1HmTEheKisLuHULiI0F7t0DHj0CHj7kr8+eXURhYQSAv2BrG40GDezh5ga4uxef0GvX5r+7ufHFxUXgA9IDmYwndHUyT0zkt3QTEooT/dOnQMkJwevUKZ3oGjcGmjXji7OzQAdCajShExuNFalLJ08CnTtTUnuJzEwgJoYnsNhY4OZN4PZtflsSAMRifvL18gJat+aV34YNO6Bhww5wcsqAra0M9erZC3sQApFK+dKkScXbZWbyCwL1or5AOHQIuH+/+P5g7dp8VqWmTYuTXZs2gKurfo+DEH2ixKZL588D/foJHYVRycwErl3jnUXVy61bfHAWqRTw8QEaNQLGjAGaNy8+yZZ/78jx34VUxMGBXxS0bq35/fR0PpzpzZvFr0ePAg8e8Pfr1gXateOL+t+leXPDxU+INiix6UpWFq9+fPqp0JEIhjH+FZw6xZczZ3gtAeBNhK+9xic7eO013r/G01PQcF9pTk58GNMXhzJNTgauXAH++YcvmzbxGh7AmzQ7dwb+8x+gWzdes6POK8QYUWLTlUuX+J39jh2FjsRgGONNin/+Cfz1F09kycm8Q0bnzrwW1qEDT2RubkJHSyrD1RXo1YsvahkZPNldvswvWD7/nN9GlkiALl14cuzRA+jUiRIdMQ7UeURXFi8GfvgBiI8XOhK9yskB/vgD2L+f36958oQ3KXbsCAQGAl278p8rGEyE1AAPHgCnT/OLmd9/5/fw7O0Bf3+gf38+PoG7u9BREqEI3XmEEpuuvPUW7wP+669CR6JziYnA9u3Anj38ZFZYyJNX375Anz68RkbPor/a7twBDhzgFzsnT/LHF9q14x1/hg3jnYHIq0PoxEZNkbryzz9AWJjQUeiMTAbs2sVn3zl+nE8C3r8/sGEDEBRUM7vSk+pr0oQvH33Ea/XHjvEk98MPwNy5fNyC//s/YOhQfq+OEH2isSJ1QS7nbXK+vkJHorWzZ/kVtpsb8P77PKFt3cqfm9q8mZ+cKKmRitjZAQMH8sF34uOBw4f5n8bcufx5wz59eFN2YaHQkZKaihKbLjx8yP9KGzUSOpJqKSgAfvmFd/To2pX3gvvhB/7Q7+7dvCcjjV5BqsPCgtfwN27kTdpbt/JORwMG8GS3bBlvHSBElyix6cLDh/zVy0vYOKpILgeWLAEaNADGjQO8vXmN7cIFIDSUdwknRFdsbPhF0uHD/Lm5Xr2AOXN4LW7mzNKjpRCiDUpsuvDgAW+fc3AQOpJKYYxfOTdrBsyeDYwcyXPz1q28mz4h+ta0KbBiBW/BnzuXT4jh7Q0sXcpbEAjRBiU2XXj40GSaIWNieI/GESN41+w7d4Cvv6au2UQYjo7A9Ol8bND33gNmzeJJ78gRoSMjpowSmy48eGD0iY0x3uz4+uu8Q0h0NLB+PW8GMoSDBw+iSZMmsLAovyNueno6IiIiEBAQAGdnZ9jY2MDHxwfDhw9HTEzMS8tQqVQIDw+Hj48PrK2t0adPn3K3vXjxIkaPHg0vLy/Y2NjA2dkZLVq0wNtvv41Vq1bh/r/DbbRp0wYikajSy+eff16qnLi4OAwYMACyf28kaXuMmlTmu505cya2b99e7vtjxoyBWCyGl5cXpkyZgvz8/GrFUl2OjsCXX/ILrddf5x1Mpk1DmXnwCKkURrTXoQNjn3widBTlSk5mLCiIMUtLxhYtYkypNFzZ9+7dY/3792etWrViUqmUmZubl7vtuHHjmIWFBVu6dClLSEhgOTk57OTJk8zPz4+Zm5uz3bt3V1hWZGQkA8A+/fRTlp6ernEblUrFPvnkE2ZhYcGmT5/OYmNjWX5+PktMTGRHjx5lgYGBDAADwBQKBWvdujXbuXNnqX2EhYUxAOzQoUOl1r/zzjvss88+K/r9ypUrrFatWuyHH37Q2TGWVJXv9t69e8zLy4vNmTOn3G1kMhmLiIhgANiiRYsqHYc+/PILY1IpY61bM3bnjqChkGrowXqwD9gHQhW/ghKbLjRqxNiXXwodhUZPnjDWrBljDRsy9vffhi9/2LBh7Msvv2QKhYK5u7u/NLGNHz++zPro6GgGgPn4+Ly0LABMJpOVu82sWbMYALZ69WqN7yuVStanTx+tE1tmZibz8PBgYWFhOj3Gkqry3arLEIlEbPv27RVuZ2try3r16lXpOPTl/n3G2rdnzNWVscuXhY6GVAUltprAyYmxiAihoygjPZ0xPz/GmjdnLD5emBhyc3OLfq7Mybc8NjY2zMzMjBUWFpa7Ta9evSrcf2xsLDMzM2Pt2rWrsKyzZ88WJTZNyktsJc2ePZtZWFiw+Cp88ZU5xpKq892GhIQwDw+Pco+NMcbq1av30u/IULKzGevZk7FatajmZkqETmx0j00XZDLN0ykLbPRoHtqRI3yGZSHY6OABuJycHOTl5aFFixYQVTB2l6rk9NIarF69GoWFhQgJCalwu86dO4MxVuE9q4owxrB27Vq8/vrrqFfJL76yx1hSdb7bwYMH4+nTpzhw4EC524hEIihfnAZcIHZ2/FlKLy8+ah3dcyOVQYlNWwUFfFR/a2uhIyll505g3z4+Woip93jcuXMnAGD27Nla7efkyZMAgFatWmkdU0ViYmKQlJSE1uVNhqaBro7xZdq0aQMAOGJC3Q7t7IAdO4C4OOCrr4SOhpgCSmzaUj90Y2TD2X/xBfDOO3zuLFOWlJSEmTNnIjQ0FEOHDq1w24KCAojF4nLff/bsGQDARc9jgl2/fh0A4FHJLqdVOUZtuf97laOOUROxWAyFQqHXOKqqYUNgxgz+nFtOjtDREGNHiU1b6hOApaWwcZRw/z7vzm/qYzKnpqaid+/e8Pf3R0RExEu3f/z4caWSSWWb+qorISEBAOBQiQf2q3qM2pJKpRCJREUxalKvXj3Ex8cbTXOk2vjxfEb248eFjoQYO0ps2lLf1zEznq8yJoZPI2PKo4jk5OQgKCgIfn5+2Lx5M8wrmMEyLS0N33zzDeLi4jBhwoRyt1Pf70pJSdF5vCWpnwGzfMnFTlWOUZcsLCyQl5dX7vthYWGQyWSYN2+e3r+rqqhdG/Dx4RdthFTEeM7GRGeysvgtPyNrHa00pVKJkJAQuLu7Y+PGjRWe8EePHg0XFxfMnDkTM2bMwOTJk8vdtnv37gDw/+zdeXxMZ///8dckIRLZJLUmWtmIIMRSRvWuahCK2mIpd2mptPVrudtSStGWu7sud7WoWkstqa32Cq3WLiX2isRSQZBdSGS5fn/MNyHNwkyWM5N8nn3Mg5xz5pzPZGrec51znevi6NGjpV7zvar93/XW4k7nGfMaS1tWVlaxHU+GDh3KjBkz+OSTT6hZsybBwcHlVtv9ODsb/v8WojgSbBVQ7dpw+zbEx2tdiWlCQ0PJyMhg5cqV+Xom+vj4sG/fvnzbLly4kOTkZJYvX87MmTMJLeb8a2hoKDY2NoSFhRV7/PHjx2NlZcXp06dNqr9u3boAJCcnF1vLg77G0pSSkoJSKq/GwkyaNIm3336bb7/9lqSkJLZs2VJm9Rjr4kWZz03cnwRbBaTXGy75bdqkdSXGmzZtGidOnGDdunXFdgS5l5OTEyEhIQQGBhYbWg0bNmTq1KkcOnSI+fPnF7rNX3/9xZw5cxgwYAB+fn4mvYamTZsCcOnSpULXm/IaS0tsbCxwt8bCrF69Gk9PT0aOHPlA1wnLy59/Gqa+sfQOUaLsyQzaFZCzs+Gen08/NUwMWo5nuUpk4cKFvPvuuwA4Ojoa/XwnJ6e8MRmLMnnyZNLS0njppZc4c+YML7zwAg0aNOD69ets2bKFd955h4CAAL7//nuTXgNA8+bNqVWrVqFjP5ryGocOHcrSpUuJiYnBs4RTIx35vwtUXbp0KXKb1NRUHnrooRIdpyx88AE0bw6tW2tdiTB30mKroKZNMwwo++GH2taxYcOGvAGCY2Njyc7Ozvt53rx5+ba93ynC+3nQ3o4ffPABu3fv5vLlywQFBeHg4EDjxo2ZN28eEyZMIDw8nOrVqxd43sKFC9HpdMyZMweAbt26odPpuHnzZoE6Ro4cyf79+/NuMchlymu8cuUKDg4OPPzww/mWG/O7zbVmzRrc3d15+umniz1mWfccNdbatRAWZriNxcxKE+ZIqzFPKozr15UCpcLDta6kgM8/V8raWikjxtW1aE8//bTS6XRal6GUUiopKUm5u7sXGCvSWImJicrOzk6NHDmyxDXljhX5448/Frtd7dq1Vbt27Up8vNLy559KOToq9eKLWlciHpQMqSXKzNixhjmuBg40jNxQ0Xl4eKCUIi4uTutScHZ25ueffyYsLIxZs2aZtA+lFK+99hpOTk68//77JaonJiaGvn37MnHiRAYNGlTkdpmZmSQkJDzwzeVlbd8+CAqCdu3g66+1rkZYCgm2Cu6bb+DVV2HQIBgzpmKPtZfbLf3DDz8k3gy6hAYGBnLo0CE2b95832t/hYmLiyMmJobw8HDqlLAr4Jw5c5gxYwYzZswocpvk5GRmzpxJZmamWXTxX7wYnnoK2reHdess9/YVoQGt2ooVhhmfirzXokVKOTgo1bKlUn/9pXU1Zeejjz5SjRs3Vra2tio4OFjrcizGsGHDVJUqVZSPj4965513VFZ5Ttr3D9euKdWzp1I2NkpNnVq+8weK0qH1qUidUkppHa4W7cYNqFnTMM5Pp05aV1OsqCgYMgROnIA33oBx48CEzodClInMTJg7F957zzDL+9KlhtaasDyd6IQffnzDN1oc/hs5FVmJ+PrC7t0wdarheoWPD8yadXe4SyG0oJShx2OTJoYvXEOHGobNklATppJgq2SqVDGMkn72rOED5I03wM8PvvzSMHebEOXlzh1YssRwX9rAgfDoo3D6NHz2meFeTCFMJcFWSbm6Gj5ATp+Grl1h8mTw8DB0MDl7VuvqREUWFwfvvguPPAIjRhjOJBOFazAAACAASURBVBw6BD/8YJieRoiSkmCr5Bo0MPSc/PtvwynKn3+GRo0MXaznz4ekJK0rFBVBejr89BP062cItK+/hhdegHPnYPlyCAzUukJRkUiwCQBcXAynJaOiYPVqw6mg0aMNA8727Wu4BlLMTCdCFJCdDdu2wfDhhoG5Bw40zKc2e7bhi9SMGZY/u7swTzJWpMjH2hqeecbwSE423D+0ahUMHmy4PvfYY9CjB/TubfjmLcS94uNhxw7Yvh3WrzcMWuzvD2+/Dc89B8VMKiBEqZFgE0VydjZ8GD33HFy5YjhNuWmT4Xrc2LGGXmzdu0PnzoYZBRwctK5YlLc7dwzXx8LDYeNGOHgQbGzg8ccNt5P06mXofStEeZJgEw+kbl0YNcrwyMiA3383hNz69fDJJ4YPs5YtoUMHw7Qijz0GZjhAvCih1FTYuxf++AN27YIDBwynqD08oFs3eOstwxcd+ZIjtCTBJoxma2voXBIUBDNnwuXLhqD74w/DKagvvjDcm+TnZ+jK3aqVIfRatJAbwi1JejocOwYREYa50A4dgqNHDdfOfH0NX2KGDzf8Ka0yYU4k2ESJ1atn6BgwcKDh56QkQ8jt2WP4UJw+3TBAi5WV4QOxZUtDL7imTQ3h98gjhnVCO7Gxhls/Tp6Ew4cNQXbypOHmfScnw5eSJ56AiRMNQSbXyoQ5k2ATpc7FxdDBpEePu8suXjR8WOZ++//iC0NLD8DOzhBwjRoZOhr4+UHDhoZbEeRG3dJz6xacP2/o+Xr6NJw6ZXicPn335nxXV0OIdekCEyYYvoT4+MgXD2FZJNhEuXj4YcOjd++7y5KS4K+/DGNX/vWX4UN28WLDvU3Z2YZtXF0NAZf78PQ0/PnII1CrluEhE08aJCQYeiFeumT4HZ4/b3jk/j13Nh+dzvBeNGpk6PTzwguGLxP+/oZhT4WwdBJsQjMuLtC2reFxr4wMiInJ/6F8/ryhs8LixYbTmrmqVDGEW926hnvu6tQxnBqtVQvc3KBGDUM41qhx9++WEoRJSZCYaHgkJBj+jI+Ha9cMIRUba/h7bKzh53unJHJyuvslQK833K7h6Wl4eHlBIROEC1FhSLAJs2NrC40bGx6FSU01tEoK+3A/d87Qa+/aNUMY5Lb87uXicjfkbG0NI8k7OhpC0sXl7jIHB8MyMATBP+cDu3c9QE6O4d6/e2Vn3z3Nl7s+Pd3QkzA11XANKynJEEq3bsGNG+e4efMREhOtyMkpWLur692Wqru74UvBP0O9Xj3DdkJUVhJswuI4OhYffPdKTr7b6rm35ZP799xASU013JMVE3M3eFJS7gZjcjIFgsawLAG4BRhmnHZxKdgizF2m0xUMzqpVDS0oW1uwsbnJ3LlteeyxF3jhhQ8LbW0KIe5Pgk1UaM7OhkdZDa47YcLH/PLLL0RERJTC3hwIDPyM5557jpAQHwYOHFkK+xSi8pFgE6IEMjMzqXLv+cgS+ve//82JEycYPXo0vr6+PPHEE6W2byEqC+nEK0QJlHawAfz3v/+lW7du9O/fn+jo6FLdtxCVgQSbECVQFsFmZWXFDz/8gLu7O7169SL5nz1ShBDFkmATogTKItgAHBwc2LRpE8nJyQwePJjswrp3CiEKJcEmRAmUVbAB1KtXj7Vr1/Lrr78yceLEMjmGEBWRBJsQJVCWwQbQunVrFi5cyKeffsp3331XZscRoiKRXpFClEBZBxvAgAEDiIyMzOsp2bFjxzI9nhCWTlpsQpRAeQQbwPTp0+nbty/9+/fn7NmzZX48ISyZBJsQJVBewabT6ViwYAFeXl7SU1KI+5BgE6IEyivYAOzs7Fi7di0pKSkMHDhQekoKUQQJNiFKoDyDDQw9JdetW8fvv//OW2+9VW7HFcKSSLAJUQKZmZnY2JRvH6xWrVqxcOFCZs6cyZw5c8r12EJYAukVKUQJZGVllWuLLVdISAjHjh3j1VdfpWHDhjz55JPlXoMQ5kpabEKUQHmfirzXu+++S79+/aSnpBD/IMEmRAloGWw6nY758+fj4+NDz549SUpK0qQOIcyNBJsQJaBlsMHdnpI3b95k0KBBZGVlaVaLEOZCgk2IEtA62ADq1q2b11Ny3LhxmtYihDmQYBOiBMwh2ABatmzJ4sWL+fLLL5k9e7bW5QihKQk2IUrAXIINoF+/fkyZMoXXXnuN8PBwrcsRQjMSbEKUgDkFG8DUqVPp378/AwYMICoqSutyhNCEBJsQJWBuwabT6fj+++/x9fWVnpKi0pJgE6IEzC3YwNBTcs2aNdy6dYsBAwZIT0lR6UiwCVEC5hhscLen5J49e3j99de1LkeIciXBJkQJaDWk1oMIDAxk8eLFzJo1i2+//bZcjpmYmMjs2bPp1KkTrq6u2NnZ4evry5AhQ4iMjCyXGoSQYBPCRFlZWSilzDbYAPr27cvUqVPLrafkuHHjePXVV3nmmWc4efIk8fHxzJ8/nyNHjtCqVSvWrl1b5jUIIcEmhIkyMzMBzDrYAN555x0GDhxISEgIZ86cKfPjvfDCC4wZM4Y6depgb2/P448/zrJly8jOzmb8+PFlfnwhZHR/IUxkKcGm0+mYN28eTz75JL169WLv3r3UqFGjTI41b968Qpc3b94cOzs7oqOjUUqh0+nK5PhCgLTYhDCZpQQbQLVq1fJ6Svbu3Zs7d+6U6/HT0tK4ffs2TZs2lVATZU6CTQgTWVKwAdSpU4f169cTERHBK6+88sDPO336NL1798bZ2Rl7e3seffRRNmzYQFBQEDqdDp1Ox8iRI4vdx6pVqwCYNGlSiV6DEA9CTkUKYaLcYCvvGbRLokWLFixZsoT+/fsTGBjI6NGji93+7Nmz6PV6qlevTlhYGHq9ngsXLjB27FiOHj2Kra0t6enpxe4jLi6OCRMmMHLkSAYMGFCaL0eIQkmLTQgTWVqLLVefPn147733GDNmDJs2bSp227fffpukpCS+/PJLOnfujIODA02aNGHZsmWkpaXd91jx8fEEBwfTsWNHGZxZlBsJNiFMZKnBBobAGjx4MIMHD+bEiRNFbrdlyxYAunbtmm95zZo18fPzK/YYaWlpdO3aFX9/f5YuXYq1tXXJCxfiAUiwCWGi3KGqLDHYdDod3333HU2aNKFnz57cuHGjwDYZGRmkpqZSrVo1HBwcCqwvrmdlVlYWISEhuLu7s2jRIgk1Ua4k2IQwkSW32OBuT8ns7Gz69u1boKekra0tjo6OpKenc/PmzQLPv3btWpH7Dg0NJSMjg5UrV+a7Bunj48O+fftK70UIUQgJNiFMZOnBBlC7dm02bdpEZGQkL7/8coH13bp1A+6eksx19erVIm/2njZtGidOnGDdunXY2tqWftFC3IcEmxAmqgjBBtCkSRN+/PFHFi1axFdffZVv3X//+19cXV0ZO3Ysv/zyCzdv3uT48eM8//zz1KlTp8C+Fi5cyLvvvsv+/ftxdHTMux0g9xEdHV1eL0tUYhJsQpioogQbQPfu3Zk+fTqvv/46GzZsyFvu7e3N3r17adOmDf3796d27dqEhoYyceJEfHx8CuwnLCysPMsWolCWcwOOEGamIgUbwIQJE4iOjubZZ59lz549NG3aFICGDRuyZs2aB9rHvaEohFakxSaEiSpasAF88803tGzZkl69enH9+nWtyxHCJBJsQpioIgZblSpVCAsLw8rKin79+pX7mJJClAYJNiFMVBGDDeChhx5i/fr1HD16lJdeeqnA+uXLl6PT6QgPDycjI+OBxooUojxJsAlhoszMTKysrLCyqnj/jPz9/fnxxx9ZvHgxn3/+eb51gwYNQimV71HUdDVCaKHi/YsUopxkZmZWuNbavbp168YHH3zAm2++yc8//6x1OUI8MOkVKYSJKnqwAYwbN46oqCiGDBnC7t27adasmdYlCXFf0mITwkSVIdgAZs2aRatWrejVq1exw2gJYS4k2IQwUWUJttyekjY2NvTr14+MjAytSxKiWBJsQpiosgQbgJubG+vXr+fYsWOEhoZqXY4QxZJgE8JElSnYABo3bsyKFSv44Ycf+PTTT7UuR4giSbAJYaLKFmxgmHD0448/5q233mL9+vValyNEoaRXpBAmyszMzDfXWGXx+uuvc+bMGYYOHcoff/xBQECA1iUJkY+02IQwUWVsseX63//+R+vWraWnpDBLEmxCmCgrK6vSBltuT8kqVarQp08f6SkpzIoEmxAmqswtNgBXV1d+/vlnTp48yahRowrdRilFUlJSOVcmKjsJNiFMVNmDDcDPz4/ly5ezbNkyPv7443zr0tLS6NevHx988IFG1YnKSoJNCBNJsBl07dqVTz75hIkTJ7Ju3ToALl26RPv27VmzZg0LFiwgOztb4ypFZSLBJoSJJNjuGjt2LKNGjWLo0KGsWLGCNm3acOrUKQCuX7/Otm3bNK5QVCYSbEKYSIItv6+++gpfX1/+/e9/c+PGjbz56mxsbJg/f77G1YnKRIJNCBNJsN2llGLmzJkcOXKErKwssrKy8tZlZWWxdu1a4uPjNaxQVCYSbEKYSILNID09nWeffZaJEyfmTTz6T0opVqxYoUF1ojKSYBPCRBJsEBcXR/v27Vm+fHmhgZYrJydHZtkW5UaCTQgTSbBBzZo1GTVqFE5OTlStWrXI7ZRSHD58mJMnT5ZjdaKykmATwkQSbGBlZcVLL73E+fPnCQ0NxcrKqsjfSdWqVVm0aFE5VygqIwk2IUwkwXZXjRo1+Oqrrzh48CAtWrTAysoKnU6Xb5s7d+4wb968fB1LhCgLEmxCmEiCraCWLVuyf/9+FixYQI0aNQrMfpCQkCD3tIkyJ8EmhIkk2Aqn0+l47rnniI6O5uWXX8bKyiov4GxsbFiwYIHGFYqKrvJNJiVEKZFgK56LiwtfffUVw4cP56WXXuLQoUNkZWWxbt06EhIScHV1LfK5qamppKamkpKSQlpaGrdu3co3g0BKSkq+YbocHBzyvRfOzs7Y2Njg7OyMi4sLTk5OlXLuvMpK3mkhTCTB9mByT09+9dVXTJkyhZSUFF566SUaNWpEbGws165d48qVKyQkJJCcnExSUlKxtw6Yyt7eHicnJ1xcXKhVqxZ169aldu3a1KlTJ+/vDRo0wMvLC1tb21I/vig/EmxCmEiCraDk5GSOHz/O8ePHiYqKIjo6mpiYGKKjo0lLS8vbbu3atfj5+VGvXj1q165NkyZNcHNzw8XFBWdnZ5ycnHB0dMTJyQkHBwdsbW2xt7fPe3716tXz3V6QnJxMTk4OcHeqnOzsbFJSUkhMTCQlJSWvBZiYmMi1a9e4fPkyhw4d4urVq1y5coXbt28DhlOp7u7ueHt74+Xlhbe3N40bNyYgIAAvLy+srOQKjrmTYBPCRJmZmZX69Nbly5fZu3cvERERHDt2jOPHj3P+/HkAnJycaNiwIV5eXjz99NN5AeHl5YW7uzsnTpzAx8eH6tWrl0otzs7O+X4u7jRnUZKTkzl37ly+MI6JieG3337j/Pnz5OTkUL16dfz9/QkICCAgIIC2bdvSsmVL+YJjZirvv0ohSqgytdhycnI4fPgwu3fvZu/evezZs4eLFy9ibW1N48aNadasGaNGjaJZs2Y0bdqUBg0aFLu/5s2bl0/hRnB2dqZFixa0aNGiwLq0tDROnDjB0aNH81qkueNfVqtWjdatW9OuXTvat2/Pv/71L9zc3DR4BSKXBJsQJsrKyqrQwRYXF8euXbvYvn07P//8M1euXMHR0ZG2bdvy/PPP06pVKzp06ECNGjW0LrXMVa9enUcffZRHH3003/LLly+ze/du/vjjD3bu3MnMmTMBCAwMJCgoiKCgIP71r38VOyqLKH0SbEKYqCK22E6dOsXKlSv56aefOHbsGHZ2djz++OO88cYbdO7cmWbNmhW48boyq1evHiEhIYSEhACQlJTEzp072bZtG6tWreKjjz7C0dGRbt26MWDAALp3746dnZ3GVVd8EmxCmKiiBFt0dDTLli1j5cqVHD9+nHr16tG/f38+++wzOnToIB/ERnBxcaFPnz706dMHgLNnz7Jt2zZ++uknBg4cSLVq1ejRowcDBw7k6aeflpZcGZFgE8JElhxs2dnZ7Ny5k7lz57J69WpcXFzo3r07//3vf+nWrVul7hRTmnx8fPDx8eGVV14hPj6ejRs3smrVKgYMGICbmxvDhw9n1KhReHl5aV1qhSL9VoUwkSUGW3x8PFOmTMHDw4Pg4GBu3brFmjVriIuLY/HixfTs2VNCrYy4ubnx3HPP8fPPPxMTE0NoaCg//PADvr6+BAcHs337dq1LrDAk2IQwgVLKojqPXL9+nQkTJtCgQQO+/fZbXnzxRWJiYtiwYQM9e/bE2tpa6xIrlfr16/Puu+9y/vx5fvrpJ7Kzs+ncuTOPPfYYW7Zs0bo8iyfBJoQJckeoN/dgu3XrFpMnT8bT05MFCxYwZcoUzp07x3vvvcfDDz+sdXmVno2NDb179+aXX35h7969uLi40K1bN9q1a8f+/fu1Ls9iSbAJYYLMzEzAvINt3bp1NGnShK+//ppp06Zx7tw5xo0bh4ODg9aliUK0a9eOjRs3cvDgQRwcHGjfvj0vvvgi8fHxWpdmcSTYhDCBOQdbfHw8vXv3pk+fPnTo0IHTp0/z5ptv5huSSpiv1q1bs337dpYtW8bmzZtp1KgRYWFhWpdlUSTYhDCBuQbbgQMHaNWqFYcPH2bHjh0sWbKEOnXqaF2WMMHAgQM5deoUAwcOZMCAAYwdO5Y7d+5oXZZFkGATwgTmGGzz58/n8ccfp3Hjxvz555907NhR65JECTk6OjJr1iyWLVvG/PnzeeKJJ7hx44bWZZk9CTYhTGBuwTZ37lxGjhzJuHHj2LhxY5mNVXjkyBGefvppXFxccHR0JCgoiN27d9/3ednZ2UycOBFfX1+qVatGt27d8q13cHBAp9Ple3z66af5tvHw8CiwzeTJkwsc68KFC/Tq1YuUlBQAEhMTmT17Np06dcLV1RU7Ozt8fX0ZMmQIkZGRBZ4/YcIEVqxYUeRref7557G1tcXT05MxY8aQnp5+39dfUoMGDeLAgQPExcURFBQk193uR4mSuX5dKVAqPFzrSkQ5Onv2rAJURESE1qWoefPmKZ1Op95///0yPc6+ffuUnZ2dGjhwoLp8+bK6fv26evHFF5WNjY3aunVrsc+dM2eOAtR7772nEhMTC93m8OHDClDPPPNMkfs5d+6cAtRjjz1W5D4eeugh9b///S9v2YgRI5SNjY364osv1JUrV1RaWpratWuX8vf3V9bW1mrNmjX59nH27Fnl6empJk+eXGQdKSkpavbs2QpQM2bMKO6ll6oLFy4oT09P1aJFC5WQkFBuxzXWk+pJ9bJ6WavDz5JgKykJtkrp1KlTClBHjx7VtI4///xTVa1aVU2ZMqVMj5Odna2aNGmi6tatq27dupW3PCsrSzVq1EjVr19fpaenF/n8wYMHK0ClpKQUuU1Jgy05OVl5eHio0NDQfMtHjBihRo0aVWD7I0eOKED5+voWuk6n06kVK1YUWYtSStnb26suXboUu01pu3DhgvLw8FADBgwo1+MaQ+tgk1ORQpjAHE5FZmRkMGzYMNq2bcvUqVPL9Fi7du3ixIkT9O/fP9/YkdbW1gwePJi///6bDRs2FPn8+Ph4rK2tcXR0LLMaP/74Y65evcqUKVPyLZ83bx5z5swpsH3z5s2xs7MjOjq6wIzdzZs3p3///rzxxht59ywWxsXFpdxPCz788MMsW7aMsLAwlixZUq7HthQSbEKYwByC7aOPPuLixYssXbq0zGd13rFjB2Doiv5PucvCw8OLfH52dnbZFPZ/lFLMmzePtm3bUq9evQd6TlpaGrdv36Zp06aFzljQp08fLl26xMaNG4vch06nKzb4ysrjjz/OmDFjGDNmDMnJyeV+fHMnwSaECbQOtvT0dL788kv+85//UL9+/TI/3unTpwFDB45/cnd3B+DMmTNlXkdRIiMjiYuLM2oC01WrVgEwadKkQtfnTji6devWkhdYBqZMmUJOTg7fffed1qWYHQk2IUyQG2xaDRi8detWkpKSePHFF8vleElJSYBhws1/yh3JJDExscjn37lzB1tb2wc61rp16wr0fsx9eHp6Fvqc48ePA4UHb2Hi4uKYMGECI0eOZMCAAYVukxvYufsujK2tbd7/C+XNxcWFQYMGsWzZMk2Ob84k2IQwgdYttj/++IOAgIAHPu1WlnKvTxU3AenFixcfOHSeeeYZlFKFPs6dO1foc65cuQKAs7PzffcfHx9PcHAwHTt2ZPbs2UVu5+TkhE6ny9t3YerVq0dsbKwmpyMBgoODiYyMzLu1QRhIsAlhAq2DLTo6Gj8/v3I7nouLC2C4LvVPuctyt7lXQkICn3zyCRcuXOCVV14ps/py7yW73/uRlpZG165d8ff3Z+nSpfed1cDGxobbt28XuT40NJSUlBSmTJmiyY3TjRs3Jicnp8jAr6wk2IQwgdaj+9++fbtcx37MDdFLly4VWBcbGwtAw4YN8y0fPnw4bm5uTJgwgfHjx/Paa6+VWX3VqlUDKPa0YFZWFiEhIbi7u7No0aIHmqonKyur2BnEhw4dyowZM/jkk0+oWbMmwcHBxhdfArmnhgv7wlGZSbAJYQKtW2w1atQo1xbCk08+CUBERESBdbnLnnrqqXzLFy5cSHJyMsuXL2fmzJmEhoaWWX1169YFKLaHYGhoKBkZGaxcuTLftVEfHx/27dtXYPuUlBSUUnn7LsykSZN4++23+fbbb0lKSir3udSuX78OUGYjzZhKoe6/URmSYBPCBFp3HmnWrBkREREF7r8qK0888QT+/v6EhYXlG0IqOzub5cuXU79+fZ5++ukCz3NyciIkJITAwMAyHaG+adOmQOEtSoBp06Zx4sQJ1q1b98CdWHJborn7Lszq1avx9PRk5MiRD3R9r7RFRERgb2+Pt7d3uR+7OOmkY0fRLd2yJsEmhAkyMzOxtrYu8/vHitK1a1diY2M5cOBAuRzPysqK77//noSEBJ5//nmuXr1KfHw8o0ePJioqiu+++y7vdGBhnJycyrSDQ/PmzalVq1ahYz8uXLiQd999l/379+Po6Figp2V0dHSh+zxy5AgAXbp0KfK4qampODk5lc6LMEFYWBhBQUGafcEqShppVKdgD9ryIsEmhAkyMzM1vTm7ZcuWtGjRosBAwWWpXbt27Nmzh+TkZBo1akSDBg2Iiori119/pWvXrsU+t7gek2C4ZSAwMBC4292/sEGQc7v77969O98gyDqdjpEjR7J//34uX76c73mmthTXrFmDu7t7oS3Re93vtZWVY8eOsW3bNkaMGKHJ8Ytzi1vYo938f+YV80JYCK2DDeD999+nV69ebNiwgR49epTLMQMDA9m0aZPRz7O1tSUnJ6fI9Tdv3rzvPoo6zZhr/PjxLFq0iPfeey9fN/7ihvoqSmRkJGFhYSxbtqzY9zkrK6vYlmpZycrKYtSoUbRu3ZqePXuW+/HvJ400TYNNWmxCmMAcgq1Hjx4MGzaMF154gbi4OE1ruR8PDw+UUmVap7OzMz///DNhYWHMmjXL5P3ExMTQt29fJk6cyKBBg4rcLjMzk4SEhAe+P680TZ8+nSNHjjB//nzNWozFucUtORUphKUxh2AD+PLLL3F0dKR3795mfZNubjf4Dz/8sEwHDQ4MDOTQoUNs3rzZ5N/HnDlzmDFjBjNmzChym+TkZGbOnElmZma5d/H/8ccfmT59Op999lmxHVu0kkOO5sEm09aUlExbUyl99tlnysPDQ+sylFJKnTlzRrm7uyu9Xq+Sk5O1LqdIH330kWrcuLGytbVVwcHBWpdjsmHDhqkqVaooHx8f9c4776isrKxyO/bKlSuVjY2Nev3118vtmMaKVbEKhdqldmlVgkxbI4QpzKXFBuDr68uOHTu4cOECTz75pNmOQjF+/HhOnjxJeno6mzdv1rocky1cuJA7d+4QFRXFe++990A3epeUUoqZM2fy7LPPMmbMGD777LMyP6apLnABgEd4RLMaJNiEMIE5BRsYRv3YtWsXOTk5tGrVivXr12tdkiglSUlJ9O3bl7feeosZM2aUa09YU1zkItZYUw/txjGVYBPCBOYWbADe3t7s2bOHfv360bt3b1566SUSEhK0LkuUwMaNGwkMDOTAgQPs2LGD8ePHa13SfV3gAu64Y6Nhp3sJNiFMYI7BBmBnZ8d3333HsmXLWLduHX5+fsyfP7/cRigRpePChQv07t2bHj160K5dOw4fPszjjz+udVkP5CIXeZiHNa1Bgk0IE5hrsOUaNGgQp0+fZvDgwYwaNYq2bduyYcMGCTgzFxcXx5tvvom/vz9//fUX27dv58cff6RWrVpal/bAoonGk8LnzSsvEmxCmMDcgw0M93V9+eWXREREUKdOHXr16kXr1q1Zu3atBJyZiY2NZezYsXh6erJs2TKmT59OZGRkgYGlLcERjtCcB5/JvCxIsAlhAksItlzNmzdn/fr1REZG0qRJE/r370+jRo346KOP8kaHF9qIiIggNDQUX19fli9fztSpU4mOjuY///kPVatW1bo8o8USy1Wu0pKWmtYhwSaECSwp2HI1a9aMxYsXExkZSZcuXfjggw+oX78+Q4cOZefOnWRnZ2tdYqVw5coVPv/8cxo3bkzr1q05evQo33zzDRcuXOCtt94qdv43c/cnf6JDRwtaaFqHBJsQJsjMzDS7EdUfVJMmTfj666+JjY1l1qxZnDlzhk6dOuHu7s7o0aP59ddfJeRK2ZUrV5g1axYdO3bEw8ODadOm0bFjR44cOcLevXsZPnz4A0+nY87+5E+88KIGNTStwzL/ZQqhsaysLItrsf1T9erVGTFiBCNGjODMmTOsXLmSVatW8c0331C7dm26d+9Oly5dm6oMUgAAIABJREFUCAoK4qGHHtK6XIuSnZ1NREQE27ZtY+vWrezZs4fq1avTs2dPwsLC6NatmyaDJ5e1wxzW/DQkSLAJYRJLPBVZnIYNGzJ58mQmT57MX3/9xU8//cSWLVtYsmQJOTk5tGzZki5duvD444/Trl07XFxctC7ZrOTk5HDq1Cn27NnD9u3bCQ8PJz4+Hnd3d7p06cIbb7xBcHBwhQyzXArFfvbzOq9rXQo6Jd2jSubGDahZE8LDoVMnrasR5aRfv35UqVKF5cuXa11KmUpJSWHnzp1s3bqV7du3ExUVhZWVFX5+fuj1etq3b0+bNm3w8/OrUEF/P3FxcRw+fJh9+/blPZKTk6levTodOnSgS5cudOnSxSwHKS4rRzlKc5oTQYTWrbZvpMUmhAkyMzOxt9duvqny4uTkxDPPPMMzzzwDGD7Qcz/I9+7dy/Lly0lLS6NKlSo0btyYpk2bEhAQQLNmzWjUqBEPP/ywRQdeQkIC0dHRHD9+nGPHjnHs2DGOHj3KtWvXAMNoL3q9nhkzZqDX6wkICLDYa68ltZ3tuOGmeccRkFORQpikop2KfFC1a9fOF3RZWVmcOnUq7wP/2LFjzJo1i7///hsAGxsb6tevj7e3N15eXnh5eeHu7k69evWoU6cOtWvXxs3NTZPXkpGRwbVr14iNjc3788KFC0RHRxMTE0NMTAxJSUmAYUQXf39/AgIC6N69OwEBATRv3lyuPd4jnHCe4imszKBPogSbECaorMH2TzY2NjRr1oxmzZrx7LPP5i1PTEzk7Nmz+UIiKiqKLVu2cOXKFTIzM/O2tbW1pVatWtSqVQtnZ2ecnJxwcnLC0dERJycnnJ2dAXBxccmbVNPW1javxZyTk0NycnLe/m7dukVGRgYZGRmkpqaSkpJCYmIiKSkppKamkpSURFxcXIF54VxcXGjQoAFeXl506tSJkSNH4uXlhbe3N56enuUyir+lyiST3/mdTzGPAZol2IQwgQRb8WrUqEGbNm1o06ZNoeuvXbvGtWvXuHLlClevXiUuLo4bN26QlJRESkoKCQkJnD9/npSUFFJSUgqE1+3bt0lPT8/7OTf0lFLk5OTg6uqKra1tXjC6uLjg7u6e93OtWrVwd3enVq1a1KtXj9q1a1fojh1lbR/7SCWVpzCPkVIk2IQwgQRbyeS20Eq7c0VcXBx16tQhLCyMzp07l+q+RdFWsxo//PDGW+tSALlBWwiTSLCZp9q1a9OgQQP27t2rdSmVhkKxmtUMZKDWpeSRYBPCBBJs5kuv10uwlaM/+IOLXCSEEK1LySPBJoQJJNjMl16vZ9++feTk5GhdSqWwkpU0pSlNaKJ1KXkk2IQwgQSb+dLr9SQlJXH69GmtS6nwcshhNavNqrUGEmxCmESCzXw1b94ce3t7OR1ZDnayk8tcZgADtC4lHwk2IUwgwWa+qlSpQuvWrSXYysFc5tKe9vjhp3Up+UiwCWECCTbzJh1Iyt4NbrCOdYQSqnUpBUiwCWECCTbzptfrOXXqFAkJCVqXUmF9z/fYYUd/+mtdSgESbEKYQILNvOn1epRSHDhwQOtSKiSF4nu+5zmewx7zGwxcgk0IE1jyDNqVQa1atfD29pbTkWXkF34hiihGMUrrUgolwSaECaTFZv7kOlvZ+ZzPeYInzOretXtJsAlhpJycHHJyciTYzJxer2f//v1kZ2drXUqFEkkkW9nKW7yldSlFkmATwkhZWVkAEmxmTq/Xk5KSwsmTJ7UupUL5kA9pRjOCCda6lCJJsAlhpNy5xCTYzFtAQAAODg5yOrIUneMcYYTxFm+hQ6d1OUWSYBPCSBJslsHa2po2bdpIsJWiT/kUDzzMbqSRf5JgE8JIEmyWQzqQlJ7LXGYBC3iDN7Ax86k8JdiEMJIEm+XQ6/WcOXOGGzduaF2KxXuf93HFlRGM0LqU+5JgE8JIEmyWQ6/XA7B//36NK7Fs5znPfObzLu9ih53W5dyXBJsQRpJgsxxubm74+PjI6cgSeod3eIRHGMYwrUt5IOZ9olQIMyTBZlnat28vwVYCJzjBsv/7z9yvreWSFpsQRpJgsyy5N2rn3n8ojDORiQQQYHaTiRZHgk0II0mwWRa9Xk9aWhrHjx/XuhSLs5Wt/MzPfMInWFlQXFhOpUKYCQk2y9K0aVOcnJzkdKSRMslkLGPpRz+CCNK6HKNIsJmBI0eO8PTTT+Pi4oKjoyNBQUHs3r1b67JEEUor2DZt2kTDhg1lloAyZmVlVSo3aicmJjJ79mw6deqEq6srdnZ2+Pr6MmTIECIjI0upWvPxJV9ygQt8widal2I0CTaN7d+/n/bt2+Po6MipU6c4d+4cXl5edOzYkW3btmldnihESYMtOjqaXr16MXHiROLi4kqzNFGE0uhAMm7cOF599VWeeeYZTp48SXx8PPPnz+fIkSO0atWKtWvXllK12osjjulMZzzj8cRT63KMplNKKa2LsGg3bkDNmhAeDp06GfXUnJwcAgICSEhIIDo6Gjs7w/0h2dnZNGnShFu3bhEVFYWtrW1ZVC5MtHXrVoKDg0lOTsbJycno5z/77LMEBATw5ptv0qBBA65evSodG8rY5s2b6d69O1evXqV27dom7WPkyJFYW1szZ86cfMsjIyNp0aIFvr6+nDlzpjTK1dxwhvMrv3KSk2Y5keh9fCMtNg3t2rWLEydO0L9//7xQA8MYd4MHD+bvv/9mw4YNGlYoClPSFtv333/PhAkT5BRkOdLr9VhZWZXoRu158+YVCDWA5s2bY2dnR3R0NBWhnRBOOItZzOd8bomhBsipSE3t2LEDgNatWxdYl7ssPDy8XGsS91fSYLv3S4woHy4uLjRs2LBMOpCkpaVx+/ZtmjZtik5nviPeP4hb3OIlXqIvfelDH63LMZkEWyk7ffo0vXv3xtnZGXt7ex599FE2bNhAUFAQOp0OnU7HyJEj87YF8PDwKLAfd3d3gApzaqMiyQ02a2trwLj3XGinsAGRS+O9W7VqFQCTJk0qs9rLy1Smcp3rfMmXWpdSInIupBSdPXsWvV5P9erVCQsLQ6/Xc+HCBcaOHcvRo0extbUlPT09b/ukpCQAqlevXmBfDg4OgKEnljAvmZmZ2NjYoNPpjH7PhXb0ej0rVqwgKysLGxubUnnv4uLimDBhAiNHjmTAAPOeyuV+IonkS75kFrNwx13rckpGiZK5fl0pUCo8XIWEhChAhYWF5dvk2rVryt7eXtna2uZb3rlzZwWoffv2FdjtmTNnFKBatWpVpuUL4y1YsEDZ2dkppZTR7/k/ubu7K2tr6zKrVdx1/PhxBaiIiAilVMnfuxs3bqgWLVqogQMHqqysrDKruzxkqAzVQrVQT6gnVI7K0bqckpolpyJL0ZYtWwDo2rVrvuU1a9bEz8+vwPYuLi6A4Rz9P+Uuy91GmI/MzMy862vGvudCO/7+/tSoUSPvdGRJ3ru0tDS6du2Kv78/S5cuzTstbane5V2iiOI7vjPrmbEflARbKcnIzCQ1NZVq1arlnUa8V40aNQosy/3Hc+nSpQLrYmNjAWjYsGEpVypKKisriypVqpCRkWH0ey60o9Pp8m7ULsl7l5WVRUhICO7u7ixatMjiQ20Pe/iIj/iMz/DFV+tySoUEWymxrVIFR0dH0tPTuXnzZoH1165dK7DsySefBCAiIqLAutxlTz31VClXKkoqt8Vma2tr9HsutKXX69mzZ0+J3rvQ0FAyMjJYuXJlvls2fHx82LdvX5nUXVbSSGM4wwkiiFGM0rqcUiPBVoq6desG3D3Fkevq1auF9m584okn8Pf3JywsLN9F6uzsbJYvX079+vV5+umny7ZoYbR7T0Ua+54Lben1es6dO8fVq1dNeu+mTZvGiRMnWLduXYUYOOE1XiORRBaysEKcgsyj9VU+i3dP55GzZ88qV1dX5e7urrZt26ZSU1PVsWPHVHBwsHrkkUcKvRi9d+9eVa1aNTVo0CB15coVdePGDRUaGqpsbGzUli1bNHhB4n4++OAD5eXlpZRSJr3n95LOI+UrKSlJWVlZqTVr1hj93i1YsEABxT727t2r0Ssz3mq1WqFQP6mftC6ltEnnkdLk7e3N3r17adOmDf3796d27dqEhoYyceJEfHx8Cn1Ou3bt2LNnD8nJyTRq1IgGDRoQFRXFr7/+WuCitjAP97bYTHnPN2zYkHePVGxsLNnZ2Xk/z5s3rzxfSqXj7OxM48aN2bt3r9HvXVhYmAYVl43znGcEIxjJSPrSV+tySp3cx1bKGjZsyJo1a4x6TmBgIJs2bSqjikRpuzfYwPj3vEePHhVi6CVLde+N2sa8dxVleLtMMhnCEOpRz+JvxC6KtNiEMNI/g01YFr1ez8GDB7lz547WpWhiAhOIJJKVrLTYsSDvR4JNCCNJsFk2vV5Penp6hZxD7X42sYnP+ZxZzMIff63LKTMSbGVs+fLl6HQ6wsPDycjIkHEDK4D7BZu85+bNz88PV1fXQgdErsjvXQwx/Jt/M+z//qvIZD62kirBfGzCMr3yyiucOnWKnTt3al2KMFH37t1xdnbmxx9/1LqUcnGb23SgA9lks4c9FfYU5P+R+diEMJacirR8hY30X1EpFM/zPOc5z2pWV/RQA+RUpBBGk2CzfLkj+ecOXVeRfczHhBHGMpbhhZfW5ZQLCTYhjCTBZvnatm2LtbW1xQ2BZaxtbGMSk/iYj+lK5bkvVoJNCCNJsFk+R0dHmjRpUqFPR57iFAMZyGAG8zqva11OuZJgE8JIEmwVQ0W+zhZPPL3ohT/+fMd3WpdT7iTYhDCSBFvFoNfriYiIICMjQ+tSSlUmmfSnP1lksYY1VKOa1iWVOwk2IYwkwVYx6PV6MjIyOHz4sNallBqFYgQjiCCC9aynFrW0LkkTEmxCGCkzMzPfPFzCMvn6+vLQQw9VqNORU5jCj/zIKlbRjGZal6MZCTYhjJQ7g7awbDqdjnbt2lWYYPuGb5jBDGYzu1L1gCyMfO0UwkhyKrLi0Ov1zJo1C4DU1FQOHDjAnj17iIuL4+uvv9a4ugf3Iz/yKq/yIR8yghFal6M5CTYhjCTBVjFERUWRkZFBtWrVaNy4MWfOnCEnJwedTkfHjh21Lu+BhRPO8zzPaEYznvFal2MWJNiEMJIEm2VSSjFz5kx+/fVX9uzZQ0JCAlZWVlSpUiVfz0hra2u8vMxrhI5d7OJf/KvA8gMcoDe9CSGkws6tZgq5xiaEkSTYLJNOp+P69ets2LCBhIQEAHJycgp097e2tqZ+/fpalFiozWzmKZ5iNavzLY8iip70pCMdWcACdOg0qtD8SLAJYSQJNss1depU6tevj7W1dZHbZGVl8cgjj5RjVcWbylSyyWYAA1jHOgAucYnOdMYLL5azHBs5+ZaPBJsQRpJgs1x2dnbMnTuX7OzsIrfJzs7m4YcfLseqivYLv3CQgygUOeTQn/4sZSld6IIjjmxiE9WprnWZZkeCTQgjSbBZtuDgYPr161fse2guwTaNaXmtMYUim2yGMYwUUtjKVmpQQ+MKzZMEmxBGkmCzfF9//TW2traFrtPpdHh4eJRzRQXtZCd72EMWWXnLcltuccRxmIozYkppk2ATwkgSbJavTp06fPDBB+h0BTtc1KhRg2rVtB9fcSpTC712lhtufejDJjZpUJn5k2ATwkgSbBXDK6+8QuvWrQsMj2YOPSL/4A9+5/d8rbV75ZBDNtn0pS872FHO1Zk/CTYhjCTBVjFYWVkxb948lFJ5y3Q6Hd7e3hpWZVBUa+1e1lhzhzt8x3fkkFNOlVkGCTYhjCRjRVYcAQEBvPbaa3nvZ5UqVTTv6r+f/exgR5GttSpUQYeOznTmIAf5kR+xko/yfOS3IYQRsrOzycnJkWCrQKZPn06tWrWwsjJ8HGp9KnIqU6lCwf+/qlAFG2wYyED+4i82spFWtNKgQvMnwSaEETIzMwEk2CoQe3t7Zs2aRU5ODnfu3NE02A5zmG1sI5PMvGU22GCHHS/zMhe4wBKW4IuvZjVaArldXQgjSLBZtszMTG7evElqairp6emkpqYC4ODgQLt27di3bx9Xr17ll19+ISkpqcDzHR0dC3Q2cXZ2xsrKCnt7e+zs7HB2dsbe3r7I2wmKM5WpWGFFDjlYYYUzzoxjHC/zMs44m/aiKyEJNiGMIMFmHm7evMnff/9NXFwc165dIyEhgfj4+EL/TEtLywuzrKzCr1vd69VXXy2VGnU6HS4uLtjZ2VG9enVcXV1xc3Mr9M+HHnqIVK9UNnhvQKHwwIOJTOR5nscOu1KppzKRYBPCCLnBJjNol53MzEwuXrxIdHQ00dHRXLp0iUuXLnH58mViY2O5dOlSXksr171Bkft3b29vXF1dcXBwoHr16jg6OlKtWjUcHR1xcHCgWrVqODk5AXdbYt9//z0vvPACOp0uryV2r8TExHw/5+TkkJycDBjCNiMjg+TkZG7dukV6ejpJSUncvn2btLS0fIF77ty5fD9nZ2fDKiADqn5WlWp7qrGi1gr2PryXunXr4uHhgbe3N15eXnh5eZnUGqxM5F+nEEaQFlvpuXjxIidOnOD48ePExMTkBdnFixfzWlY1atSgfv361K9fH09PTzp06IC7uzt169alfv361KlTh5o1axZ6o7Up3nzzzWLX16hRcAgrNze3Eh/3UuIl1qeux/u0N1f/dZW/Pf/mypUrXLp0idOnT+e1TuHuyCheXl54e3vj7e1N48aNadasGV5eXgXCuDKSYBPCCBJsxrt58yZ//vknx48f59ixYxw/fpzjx4/nXcOqV68evr6+eHt707Fjx7wPay8vL1xdXTWuvnx41PDglRqvQDFDVN68eTMv/O997Ny5k/Pnz6OUwt7eHn9/f5o1a0bTpk1p1qwZrVq1qjS/x1wSbEIYIbclIcFWuOzsbE6fPk1ERETe4+DBg9y5cwdnZ2d8fHzw9/enf//+NGnShGbNmlG7dm2ty7YIDg4ONG/enObNmxdYd+fOHaKiooiIiODkyZOcOHGCWbNmERMTA0DdunVp1aoVHTp04LHHHqNVq1bY2VXca3cSbEIYQVps+WVnZ3Po0CF27NjBjh072LdvHzdv3qR69eq0atUKvV7P2LFjadOmjeY3PldkVatWpUmTJjRp0iTf8ri4OA4ePMiBAwc4cOAAH330EYmJiVStWpXWrVvTqVMnOnXqhF6vN4vxMUuLTt07noww3o0bULMmhIdDp05aVyPKWGRkJC1atOCvv/6iYcOGWpejiTNnzrBlyxbCw8P57bffSE5Opm7dujz11FP861//om3btjRp0qTYyTyFNpRSREVFceDAAX7//Xd27NjB2bNnsbOzo3379nTq1ImuXbvSsmXLUrtuqYFvJNhKSoKtUjl06BBt2rQhJiYGT09PrcspNydOnGDVqlVs2LCBiIiIvPu+goKCCAoKsvQPwkrtypUr/PHHH2zfvp0tW7Zw8eJF6tevT7du3ejRowddu3alatWqWpdpjG/kVKQQRqhMpyIPHjzI4sWLWbNmDbGxsXh6etK7d28+++wzOnToIC2yCqJu3bqEhIQQEhICwJ9//sm6detYu3Ytc+fOpUaNGvTo0YN///vfPPXUUxbR61KCTQgjVPRgu379OkuXLmX+/PkcO3YMf39/XnzxRXr37l1opwVR8bRs2ZKWLVvy7rvvEhMTw9q1awkLC6NLly488sgjDB8+nOHDh9OgQQOtSy2S+UevEGakogbboUOHGDBgAB4eHkydOhW9Xs/evXs5ceIEU6dOlVCrpLy8vHj99dfZs2cPp06dYuDAgcyZMwdvb286d+7M1q1btS6xUBJsQhihogVbeHg4nTt3zrtu+N1333HlyhXmzJlDu3bttC5PmBE/Pz8++ugj/v77b9auXYu1tTXBwcG0bNmSFStWGEZPMRMSbEIYoaIE2+7du2nbti1BQUEopdi2bRuHDh3iueeew97eXuvyhBmzsbGhZ8+ebNmyhT///JOGDRsyZMgQ/Pz8WL16tdblARJsQhjF0oPt6tWrDBs2jMcffxxnZ2cOHjzI9u3b6dy5s9alCQsUGBjI8uXLOX36NHq9nv79+9OlSxdOnz6taV0SbEIYITMzE51OZ5E9AufOnUujRo347bffCAsLY9u2bbRu3VrrskQF4OPjw+LFi/njjz+4ceMGAQEBTJ48+YFmUygLEmxCGCEzM9PiWmu3bt1i2LBhvPzyy4wePZqTJ0/St2/fcjn2pk2baNiwoVGzIWRnZzNx4kR8fX2pVq0a3bp1K3LbgwcPMnz4cDw9PbGzs8PV1ZWmTZvSr18/vv32W6KjowFo2rQpOp0u32PQoEF5+wkKCsq3rrDAv3DhAr169SIlJQUwjPQ/e/ZsOnXqhKurK3Z2dvj6+jJkyBAiIyMf+PUqpdi9ezejR4+mYcOG2NraUqtWLTp06MAPP/zAP281njBhAitWrChyf88//zy2trZ4enoyZswY0tPTH7iWkmrfvj0HDx7k888/Z+bMmXTp0oVr166V2/HzKFEy168rBUqFh2tdiSgH8+fPV9WrV9e6jAd27tw51bx5c+Xm5qY2b95cbsc9e/as6tmzpwoICFBOTk7K2tr6gZ87Z84cBaj33ntPJSYmFrpNdna2evPNN5WNjY0aN26cOnXqlEpPT1dXr15V27ZtU0FBQQpQgMrMzFRKKXX16lXl5uamAPXDDz8U2OfGjRuVr6+vSktLK7Du8OHD6qGHHlL/+9//8paNGDFC2djYqC+++EJduXJFpaWlqV27dil/f39lbW2t1qxZ80Cv99SpUwpQQUFBKjIyUt2+fVtFR0erwYMHK0C98cYb+bY/e/as8vT0VJMnTy5ynykpKWr27NkKUDNmzHigOkrbkSNHlLe3t3J3d1f79+8vz0PPkmArKQm2SmXOnDnKxcVF6zIeSExMjHr44YdVixYt1Llz58r12IMHD1YffPCByszMVO7u7kYFW+4HekpKSpHbvP322wpQc+fOLXR9VlaW6tatW75gU0qppUuXKkC5ubmpq1ev5i1PSEhQ9evXV7t37y6wr+TkZOXh4aFCQ0PzLR8xYoQaNWpUge2PHDmiAOXr63vf16qUIdhsbGxUQkJCvuUZGRnKzc1N2draqvT09ALH0Ol0asWKFcXu297eXnXp0uWB6igLiYmJqlu3bsrJyUnt3bu3vA4rwVZiEmyVytdff61q1qypdRn3lZKSovz9/VVgYGCBD8zycOvWrby/GxtsXbp0KXb7U6dOKSsrK9WqVati97Nnz54CwaaUUr169VKA6tevX96yIUOGqPHjxxe6n0mTJikbGxsVGxv7wK/Bzs5OWVlZqZycnAd+TmFatGihAJWUlFRgXUhIiPLw8Cjw+u5Vr169+/6eylpGRobq2bOneuihh8rrC9YsucYmhBEs5RrbmDFjiI+PZ/369YVOjlnWSjIlyv3uh5o7dy45OTl5Q0AVRa/Xo5QqcH1v9uzZ1KhRg59++omwsDDWrl3LkSNHeO+99wrsQynFvHnzaNu2LfXq1Xug+tPS0rh9+3bedT1TJSUlERUVRWBgIM7OzgXW9+nTh0uXLrFx48Yi96HT6TTrwJGratWqLF++HHd3d5599llycnLK/JgSbEIYwRKCbf/+/SxcuJBvvvkGDw8Prcspdbt27QIgICDApOfXrVuXzz//HIDRo0fz//7f/2PRokXY2toW2DYyMpK4uDijRl5ZtWoVAJMmTTKpvpSUFHbv3k2vXr2oU6cOixcvLnS7Fi1aAJjt6B/3sre3Z8mSJRw6dIglS5aU+fEk2IQwQmZmplE9/LTwxRdf0KZNm3Lr+Vja7ty5U2jI5Lp8+TIAbm5uJh9j2LBhdO/enWvXruHj40OrVq0K3e748eMAD/wFIS4ujgkTJjBy5EgGDBhgdF3Tp0/H2dk5b5DpNWvW0LRp00K3dXd3z1djYWxtbfPuvdRas2bNePbZZ/nss8/K/FgSbEIYwdxbbFlZWWzevJnnnntO61JMdvHixQcKkpJOk+Pr6wvAb7/9xrp16wrd5sqVKwCFngr8p/j4eIKDg+nYsSOzZ882qabJkyeTkZHBqVOn8PPzIzAwkPfff7/QbZ2cnNDpdHk1FqZevXrExsZqfjoy1/Dhwzl27Bjnz58v0+NIsAlhhKysLLMOtkuXLpGcnEybNm20LsVoCQkJfPLJJ1y4cIFXXnmlyO1yr3XduHHD5GP9/vvvrF69mpkzZwLw0ksvkZiYWGC73HvA7veep6Wl0bVrV/z9/Vm6dGmJbuCvWrUqfn5+fPvtt/Tq1YspU6awffv2Qre1sbHh9u3bRe4rNDSUlJQUpkyZUqLfV2l59NFHgeJbmaVBgk0II5h7iy01NRUAR0dHjSsxzvDhw3Fzc2PChAmMHz+e1157rchtn3jiCQCOHj1q0rFu3rzJ8OHDmTt3Lv/5z3/o1q0bV69eZcyYMQW2rVatGkCxp/OysrIICQnB3d2dRYsWleqoND179gRgw4YNRR67uI46Q4cOZcaMGXzyySfUrFmT4ODgUqvNFHZ2dtjY2OT9f1pWJNiEMIK5B1vt2rWBu9ehLMXChQtJTk5m+fLlzJw5k9DQ0CK3DQ0NxcbGhrCwsGL3OX78eKysrAqMW/jGG28QFBSU9yE/Z84cnJycWLJkSYEAqVu3LgDJycnF1pORkcHKlSvzXX/18fFh3759xdZ4P7nXGhMSEgqsS0lJQSmVV2NhJk2axNtvv823335LUlISW7ZsKVE9JRUXF0dWVlbe/6dlRYJNCCOYe7DVqlULb2/vIk9dmTMnJydCQkIIDAwsNrQaNmzI1KlTOXToEPPnzy90m7/++os5c+YwYMAA/Pz88pZv3bqVX375hU8//TRvWf369fN+Dg0NJSkpKW9dbseNS5cuFXqcadOmceLECdatW1dsh5fivPnmmwxXBWxMAAAgAElEQVQdOrTQdZs3bwYo9NRybGxsvhoLs3r1ajw9PRk5cuQDXScsa9u3b6fK/2fvvuOauvo/gH/C3giIbLUyVMBVK4qjKuLAhXWPVqvYn3b4qLWuaq22j1Zra0tb52MdtXUUrVBxC9aNaOtCERUQGYLKkB0TOL8/TkmlrASS3CR8369XXmi4ufdLFD6cc88wNFR9V7k6ZsvpNJqg3ajMnDmT9e3bV+gyarV06VLWrFkzVlhYKHQpjDHFJ2j369dPruMXLVrEDA0N2cKFC1lCQgITi8UsLS2Nbd26lTk5ObGePXtWeg9yc3OZm5sbO336dLXnq1iG6+2335Y9V15ezpo1a8Z69OhR5fjt27fLlu2q6fHv1TYmTZrEALCkpCTZc/PmzWMikYitWLGCJScns9LSUpacnMwWLFjAALDOnTtXmvBeYffu3QxArUt3ubi4sA4dOtT4eXUqLy9nfn5+bOTIkaq+FK080mAUbI1KSEiIoEsUySMrK4s1adKkyhqD6nTo0KEaf9j/73//q/W1gYGBcgdhbGwse+utt5ibmxszNDRklpaWrFu3biw0NJSJxWLZcS4uLpVqCA4Oln0uNze32jq/+eYbxhhfvqu6lUeGDBmicLAFBAQwCwsLJpVKZc89f/6cbd26lQ0cOJC1bNmSGRkZMQsLC9a5c2f2xRdfVBtqjPGVR1xcXNiLFy9qfH9cXFxYx44d5XovVW3btm1MX1+f/fnnn6q+FAVbg1GwNSqTJ09mQ4YMEbqMOm3dupXp6emxiIgIoUtR2JAhQ5hIJBK6DJm8vDzm4uJSZa1IReXm5jJTU1M2ffr0BtdUsVbknj17aj3OwcGBdevWrcHXa6jr168zc3Nz9uGHH6rjcrSkFiGK0PR7bBVCQkIQEhKCCRMmIDo6WuhyFOLq6grGGLKysoQuBQCfw3bo0CHs378f69evr9c5GGP4z3/+AysrqxrnpckrKSkJI0eOxOLFiyttvfNvEokEOTk5gq8+c/fuXQwaNAh+fn5YvXq1Wq5JwUaIArQl2ABg48aNGDFiBAYPHowtW7YIXY7cKkYrrl69GtnZ2QJXw3Xq1AlXr17F0aNHZfuxKSIrKwtJSUmIioqCo6Njg2rZvHkzVq5ciZUrV9Z4zPPnz7Fu3TpIJBJBh/gfO3YMPXr0gLu7OyIiItT3vaOOdqFOo67IRiU4OJhNnDhR6DLkVl5ezlavXs309PTYm2++We1eY5pozZo1rG3btszY2JgNGjRI6HK0ypQpU5ihoSHz8PBgn3zySaX7eepS8f9OX1+fTZo0Sd3/79aLGPvX9qxEMc+eAfb2QFQUEBAgdDVExYYMGQJ7e3vs2LFD6FIUcvjwYbz11ltwcnLC999/jwD6v0pU5NatW5g1axYuXbqEb775ptZVZFRkA3VFEqIAbeqKfNmQIUPw119/wd3dHf369cPYsWORmpoqdFlEh+Tl5WH27Nl49dVXUVJSgosXLwoRagDoHhshCtHWYAOAli1b4vfff8fhw4dx/fp1tG3bFvPmzZNN9CWkPvLy8rBq1Sp4eXlh79692Lx5My5dulTjjgnqQMFGiAK0OdgqDB48GLdu3cLnn3+Offv2oVWrVggJCUFCQoLQpREtkpmZiYULF6JFixZYu3Yt3nnnHSQkJGDatGnQ0xM2WijYCFGALgQbwNcgnDt3LpKSkrBhwwacP38e3t7eGDJkCPbv348XL14IXSLRQOXl5Th16hQmTZqEli1b4qeffsKSJUuQkpKClStXokmTJkKXCICCjRCF6EqwVTAyMkJISAji4+MRFhYGxhjGjx8PFxcXzJkzBzdu3BC6RKIBHj58iOXLl6NVq1bo378/kpOTsX79ejx8+BALFiyAlZWV0CVWotlbAROiYXQt2Cro6elh5MiRGDlyJDIyMrBr1y78+OOPCA0NRatWrTB06FCMGTMG3bt3F7ybiahHUlISDh06hLCwMFy8eBEODg4YO3Yspk2bhg4dOghdXq3ofyghCpBIJJW2JtFFzs7OWLhwIRISEnD+/HmMGDECkZGR6NWrF5o3b4733nsPR48eRWFhodClEiV68eIFzp07h0WLFqF169Zwd3fHF198AW9vbxw+fBipqakIDQ3V+FADqMVGiEI0fQdtZRKJROjRowd69OiBr7/+Gjdv3kR4eDjCw8OxceNGGBoaomvXrggICEBAQAC6detW761biPqVlZXhr7/+wunTpxEdHY3z58+jqKgI7u7ueOONNzBixAj4+/trZQudgo0QBehqV6Q82rdvj/bt22PZsmXIzMxEdHQ0oqOjsWvXLnz22WcwMzND165d0a1bN/j5+cHPzw/Ozs5Cl03+lpOTg9jYWNnjwoULyMvLg4ODAwICAvDtt9+ib9++cHd3F7rUBqNgI0QBjTnYXubo6IiJEydi4sSJAIDk5GTZb/0RERFYs2YNysvL4erqKgu5jh07wsfHR/BFeRuDZ8+e4ebNm4iLi8OVK1dw+fJl3L9/HwDQqlUrdO3aFZ999hkCAgLg4+MjcLXKR8FGiAIo2Kr3yiuvyHYUAID8/HxcvXoVMTExiI2NxXfffYeMjAwAQJMmTeDr6wtfX1+0a9cO3t7e8PT0hIuLi5BfglZ6+vQpEhMTERcXV+lRsTOCra0tunTpgvHjx8PPzw9du3aFvb29wFWrHgUbIQqgYJOPlZWV7N5bhZycHNy6dQu3b9/GrVu3EBcXh7179yIvLw8AYGpqCnd3d3h4eMDd3V32cHNzg5ubGywsLIT6cgRTUlKCjIwMpKamIjExEYmJiXjw4IHsz8+fPwcAmJubw9vbG+3atcPgwYPRrl07+Pj4NNquYAo2QhRAwVZ/tra26N27N3r37l3p+YyMDNkP64qPZ86cwbZt25Cbmys7ztLSEq6urnBycoKLiwtcXFzg7OyMpk2bwtbWFnZ2dmjatCns7OxgaWmp7i9PbkVFRcjJyUF2djays7Px7NkzPHv2DFlZWUhNTUVmZibS0tKQkZGBnJwc2essLCxkYd+vXz/83//9n+zvLVq00MpBHqpCwUaIAijYlM/Z2RnOzs54/fXXq3wuJycHaWlpVX7gZ2Rk4Pr167h37x6kUinKysoqvc7Q0BB2dnaws7ODmZkZrK2tYWpqChMTE9jY2MDExASmpqawtraGnp4e9PT0YG1tXekcFcdXkEgkVaY4FBYWQiKRAOBrJpaWlqK4uBj5+fkoLS1FYWEhCgoKUFxcLAuz0tLSSucQiURo2rQpHBwc4OrqCkdHR3Tp0gVOTk5wdXWFs7MzXF1d4eDg0KD3uTGhYCNEAY1puL8msLW1ha2tLdq3b1/p+YyMDAwZMgS2trY4evQoWrZsKWv9VARIxceSkhLk5eWhpKQEJSUlSEpKQklJCUpLS2UtwupC60VhIbpKJLgCoACoM/ysrKxgamoKc3NzWFlZwczMDM2aNYOlpSVMTU1lQVvRunz5o0gkUtl72BhRsBEiJ6lUCsYYBZvA7ty5g6CgIFhYWCAmJgbNmzcHAFhbW6NVq1bKu1BiIuDhAVy9Cgi4Uj1RHHXKEiKnii4nCjbhxMTEoHfv3nB2dsaZM2dkoaYST57wj82aqe4aRCUo2AiREwWbsMLDwxEQEICePXsiOjoaTZs2Ve0F/x4yj0YwPF7XULARIicKNuH8+OOPGDNmDCZOnIiwsDCYmpqq/qJPngBNmgAvDSAh2oGCjRA5UbCpH2MMy5cvxzvvvIMlS5Zg69at6luEOiuLuiG1FA0eIUROFGzqVVZWhnfffRfbt2/H5s2b8c4776i3gCdPABpir5Uo2AiREwWb+hQVFWHcuHH4448/EBERgcGDB6u/iCdPqMWmpSjYCJETBZt6ZGdnY9iwYbh37x5OnjwJf39/YQrJygJ0cIHgxoDusREiJwo21UtOTkb37t2RmZmJixcvChdqAG+x0YhIrUTBRoicKoJN13fQFsrVq1fh7+8PKysrXLp0CV5eXsIWlJVF99i0FAUbIXKiFpvqREVFoV+/fvD19UVUVJTw6yJKpUBuLt1j01IUbITIiYJNNXbt2oWgoCAEBwfj6NGjsLKyErok3g3JGAWblqJgI0ROFGzKFxoairfffhvvvvsuduzYoTnvbUoK/6jKJbuIylCwESInqVQKgIJNGRhjmD9/PubOnYs1a9YgNDRUs/YTe/QI0NcHGulGndqO7oITIidqsSmHWCzGlClTEB4ejj179mDcuHFCl1TVo0c81OjfWitRsBEiJwq2hsvLy0NwcDBu3ryJEydOVLu5qEZITaVuSC1GwUaInCjYGiYjIwODBw/GkydP8Mcff6BDhw5Cl1SzR48o2LSYBnVqE6LZJBIJ9PT0NOtekJa4c+cO/P39IZFIEBMTo9mhBlCwaTn6DiVEThKJhFpr9aDWzUGV5dEjwM1N6CpIPVGwESInCjbFqX1zUGUoLgays6nFpsUo2AiREwWbYtavX4/Ro0dj2rRp2L9/v3o2B1WGijlsLVoIWwepNwo2QuREwSafis1BZ82ahaVLl+KHH36Avr6+0GXJ79Ej/pFabFqLRkUSIicKtrpJpVK89957wm0OqgyPHgGWlkCTJkJXQuqJgo0QOVGw1a6oqAhjx47FmTNnhNscVBlSU6kbUstRVyQhcqJgq1l2djb69++Py5cv4+TJk3KHWm5uLjZt2oSAgADY2trC1NQUnp6emDRpEm7cuKHiqmuQkkIjIrUcBRshcqJgq15DNgedP38+Zs2aheDgYNy5cwfZ2dnYtm0brl+/js6dOyM8PFyFldfg/n3A01P91yVKQ8FGiJwo2KpSxuag06ZNw+zZs+Ho6AgzMzP06tULu3fvRllZGRYsWKCCquuQkAC0bq3+6xKloXtshMiJgq2yqKgojBw5En5+fjhw4EC99lHbunVrtc936NABpqamSExMBGMMIpGooeXK5+lTICeHgk3LUYuNEDlRsP3j5c1Bjxw5ovTNQYuKilBSUgJfX1/1hRrAW2sABZuWo2AjRE4UbFxoaCimTJmCd999Fzt37qzynty9excjRoyAtbU1zMzM4Ofnh8jISAQGBkIkEkEkEmH69Om1XiMsLAwAsGTJEpV9HdW6excwNwdcXNR7XaJU1BVJiJwkEgkMDBrvt0zF5qDr1q3D2rVrMW/evCrHPHjwAP7+/jA3N8f+/fvh7++PlJQUzJkzBzdv3oSxsTFKS0trvU5WVhYWLVqE6dOnY+zYsar6cqpXcX9Nna1EonSN97uUEAVJpdJG22KTd3PQjz/+GHl5edi6dSv69+8PAPDx8cHu3bvRsmXLOq+TnZ2NQYMGoU+fPti0aZMyvwT50MARnUBdkYTIqbF2Rebl5WHAgAE4fvw4Tpw4UeuO18eOHQMADBw4sNLz9vb2aNOmTa3XKSoqwsCBA+Ht7Y1ffvlFmGW4KNh0ArXYCJFTYww2RTYHFYvFKCgogImJCSwsLKp83sbGpsbXSqVSjBkzBi4uLti5c6cwoSaRAMnJFGw6gFpshMipsQWbopuDGhsbw9LSEqWlpSgsLKzy+SdPntT42hkzZkAsFuPXX3+tdB/Tw8MDMTEx9f8iFJGYyMONgk3rUbARIqfGFGwvbw569uxZuTcHDQoKAvBPl2SFzMxM3Lt3r9rXLF++HLdv30ZERASMjY0bVnhDJCTwQSO06ojWo2AjRE6NJdj+vTmonZ2d3K9dtWoVbG1tMWfOHJw8eRKFhYWIi4vD1KlT4ejoWOX4HTt2YMWKFbh8+TIsLS1l0wEqHomJicr80mqXkAC4ugLVdKMS7ULBRoicGkOwrV+/HqNGjcK0adNw4MABhTcHdXd3x6VLl9ClSxeMHj0aDg4OmDFjBhYvXgwPD48qx+/fv19ZpTccDRzRGTR4hBA56XKwMcawYsUKfPbZZ1i2bBmWL19e73N5eXnh4MGDch0bGRlZ7+soXUIC0KmT0FUQJaBgI0ROuhpsOrE5qDLExwMTJghdBVECCjZC5KSLwaYzm4M21KNHfPHjOkZ+Eu1A99gIkZOuBVt9NwdV1N69eyESiRAVFQWxWCzXWpFqd/06HxHZrp3QlRAloBYbIXLSpWBLTk7GoEGDIJFIcPHixXrtoyav8ePHY/z48So7v1LcuAG0bAlYWwtdCVECarERIiddCbarV6+iW7dusLKyQkxMjEpDTWvcuEHdkDqEgo0QOelCsJ06dQr9+vVD+/btERUVhWbNmgldkmagYNMpFGyEyEnbg23Xrl0YPHiwyjYH1VpFRUBSEgWbDqFgI0RO2hxsdW0O2qjdvAmUlwPt2wtdCVESCjZC5KSNwcYYw0cffYS5c+di7dq1CA0NhYg20azsyhWgSROgVSuhKyFKQqMiCZGTtu2gLe/moI3e1atAly60a7YO0Z7vUkIEpk0ttry8PAQHB+PmzZs4ceIEXn/9daFL0lxXrgAjRwpdBVEiCjZC5CSVSrUi2Co2B3369Gmdm4M2egUFwL17wGuvCV0JUSK6x0aIHBhjWhFsL28OeunSJQq1uly9ygeOdOkidCVEiajFRkg1rl+/Dj09PVj8vTeXVCoFwO9b5ebmwtDQUPY5TRETE4OhQ4fC09MTkZGRCu2j1mhduQI4OvJ92IjOoGAjpBrz58/HqVOnqjz/1ltvVfq7oaEh0tPTYW9vr67SqhUeHo6JEydi4MCB2L17t8L7qDVaFQNHiE6hrkhCqjFq1Kg6h8Xr6elh4MCBKg+1kpISlJaW1vj5hm4O2qjFxtL9NR1EwUZINeQJNsYYpk2bpvJa1q1bhzfffBPl5eVVrr98+XLMmjULn3zyCX744Qfo6dG3tNzS04GUFKBHD6ErIUpG3wWEVMPe3h7du3evNSgsLS1Vvn/ZkydPsGrVKhw4cACzZ8+WPS+VSjFjxgysXLkSmzdvbtCO143WuXOAgQHQtavQlRAlo2AjpAbjx4+vsdVmaGiIyZMnw9jYWKU1fPrpp5BIJAB4l+OaNWtQVFSE4OBg7N69GxEREY13x+uGunAB6NQJ0LBBQKThRIwxJnQRWu3ZM8DeHoiKAgIChK6GKFFmZiZcXFyqdAFWuHLlCl5T4f2ZhIQE+Pj4oKysTPacSCRCy5YtUVRUhMOHD6v0+jqvUyegTx/gm2+EroQo1wZqsRFSA0dHR/j5+VXbavPw8FB5qHz00UdVukIZY0hJScHq1asp1BoiPx+4dYvur+koCjZCajF+/Pgq4WJoaKjy7r+zZ88iMjJS1g35b++++y5iYmJUWoNOu3QJKCujYNNRFGyE1GL06NFVuiKlUikmTpyosmsyxjBv3rwaF1wuLy+HVCpFUFAQ7t27p7I6dNqFC4CHB+DkJHQlRAUo2AiphYuLC1577TVZq01fXx/9+vWDqwpXqvj111/x559/ylY7qU5ZWRmeP3+OQYMG4enTpyqrRWedPQv07Cl0FURFKNgIqcPL3ZGMMYSEhKjsWmKxGPPnz691Dl1FS87NzQ3vv/++xq9fqXGKi4GYGBrspcMo2Aipw6hRo2QjE01NTREcHKyya61fvx4ZGRnVjsQ0MjKCSCRCr1698OuvvyIpKQnz5s1DkyZNVFaPTjp/HhCLgb59ha6EqAitFUlIHVq0aIGOHTvi2rVrmDBhgsqWrMrNzcVnn31WaXh/RUvRysoKM2bMwMyZM9GyZUuVXL/RiIoC2rShhY91GAUbaZTy8vJQWlqK4uJiPH/+HOXl5SgqKsKLFy8qHVdYWAiJRAIfHx9cu3YNzZs3x++//w4zM7NKx5mamsLExES26r+lpSVMTExgaWkpd00rV65EQUEBAD7yUiKRoEuXLpg9ezZGjRoFIyOjhn/hhAdbv35CV0FUiIKNaK0XL14gMzMTaWlpePr0KXJycpCdnY2cnBw8e/ZM9ufs7GwUFRUhNzcXpaWlKCkpqfc1ly1bpvBrLCwsYGJiAisrK1hZWcHOzg5NmzaFra0t7OzsYGtrC8YYvv32W5SXl8PY2BiTJ0/GBx98gPbt29e7VlKNvDzg+nVgyRKhKyEqRMFGNFZmZiaSkpKQmJiI5ORkPH78GOnp6UhPT0dGRgaysrLw8sI5FhYWsrCoeHh7e8PW1hYWFhawsbGBiYkJTE1NYW1tDRMTE5ibm8PKygr6+vowNjausSUGAJGRkRg6dGi1LbuCggJIpVK8ePECRUVFyM/Ph1gsRkFBAQoLC1FaWor8/Hzk5+fLQjc+Pl4WvJmZmbIuSLFYjO3bt+PIkSNwdXWFk5MT3Nzc4OzsjFdeeQXu7u5o1aoVbG1tVfwvoIOio/nH3r2FrYOoFAUbEdTz588RFxeHuLg43L9/XxZkiYmJKCoqAgAYGxujZcuWsh/w3t7ecHZ2rvRD397eXuXrNg4dOhQAYG5uDnNz80qfs7Gxqfd5i4uLERsbiy5duiArKwsZGRlIS0vD48ePkZqaisePH+PatWuIjIxEamqqbBqAjY2NLOTc3d3h5eWFdu3awdvbm7auqUl0NF9Ki34p0Gm0VmRD0VqRcikrK8OdO3dw48YNxMXF4datW7h9+zZSUlIA8JXyvby84O7uXuXh4uJC27H8TSqVIiUlRRb+Lz/u37+P0tJS6Ovro1WrVmjfvj18fHzQrl07dOzYER4eHkKXLzxPT2DMGGDVKqErIaqzgYKtoSjYqpWRkYE///xT9rhw4QJyc3NhYGCA5s2bw9vbG507d4aPjw+8vb3Rtm1bCq8GKisrQ0pKCm7fvo07d+7g9u3b+PPPP5GQkICysjJYWVmhXbt26NmzJ3r06IFu3boJvvO3Wt29C7Rty4f701JauoyCrcEo2AAADx8+RFRUFKKjo3HmzBmkp6dDX18fbdu2hZ+fH/z8/NC1a1f4+PjQhGI1KykpwbVr1xAbGyt7JCYmAgC8vLzQu3dv9OvXD3379kWzZs0ErlaFvv6at9SePAH09YWuhqgOBVuDNdJgy83NxfHjxxEdHY2oqCgkJSXBzMwMPXr0QN++feHv74/OnTsrNNydqM+zZ88QGxuLS5cuITo6GrGxsSgrK4Ovry8CAgIQGBiIfv366da9uoAAwNkZ+PlnoSshqkXB1mCNKNiePHmCY8eOISwsDCdOnEBZWRk6duyIwMBABAYGomfPnrIRhES7FBUV4dKlSzh16hROnTqFa9euwdjYGP369cOwYcMQHBwMBwcHocusv/x8/n26YwcwYYLQ1RDVomBrMB0PtszMTOzatUu2MK+FhQWCgoIwYsQIDB48GNbW1kKXSFQgMzMTERERCA8Px+nTp1FWVobXX38d48ePx7hx42BlZSV0iYoJC+OBlpUF2NkJXQ1RLQq2BtPBYJNIJDh8+DC2bduGo0ePwtLSEqNHj8Ybb7yBgIAAlQ+rJ5olPz8fR48excGDBxEREQE9PT2MHj0a06ZNw+uvv17rgs0a4+23gcRE4Nw5oSshqkc7aJN/PH36FEuXLoWrqytGjRqF0tJS7Nq1CxkZGdiyZQuCgoIo1BohKysrjBs3Dnv37sXjx4/x1VdfIT4+Hn369IGnpydCQ0Nlcw41Unk5cOwYMHiw0JUQNaEWW0PpQIvt4cOH+Prrr7Ft2zaYm5vjvffew7Rp09C8eXOhSyMaLC4uDlu2bMG2bdtgamqKWbNm4YMPPtC8FVHOnwd69QLi4gAfH6GrIapHLbbGLCsrCyEhIfD09ERkZCTWrFmDhw8fYvny5RRqpE6+vr747rvv8PDhQ7z33nsIDQ1FixYtsHTpUs1qwYWFAa1bU6g1IhRsjZBUKkVoaChat26NU6dOYdu2bbh//z4++OCDKmslElKXpk2bYsWKFUhJScGnn36K9evXo23btggLCxO6NIAx4OBBYNw4oSshakTB1sjcuHEDr776KhYuXIgPPvgA8fHxeOutt2S7MhNSXxYWFvjoo49w9+5dBAYGYty4cQgMDER6erpwRV26BKSmAqNHC1cDUTsKtkZk586d8Pf3h52dHeLi4vDf//5XZS203NxcbNq0CQEBAbC1tYWpqSk8PT0xadIk3Lhxo87Xl5WVYfHixfD09ISJiQmCgoJqPPbKlSt4++238corr8DU1BS2trbw9fXFqFGjsHHjRtkqG76+vhCJRJUe48ePl50nMDCw0udee+21KtdKSUnB8OHDkZ+fX+VzR44cgZeXV71+SVD0/Vq0aBH27dtX4/mmTp0KY2NjvPLKK5g9ezZKS0sVrqm+HBwcsG3bNly8eBEZGRl49dVXcfr0abVdv5IDBwAvL6BduwafijGGCxcu4P3334eXlxeMjY3RrFkz9OzZEz///DNouIIGYaRhnj5lDGAsKkroSmokkUjYjBkzmEgkYgsXLmRSqVTl1wwJCWEGBgbs22+/ZY8fP2ZFRUXs7NmzzNvbm+nr67ODBw/W+vrNmzczAOyzzz5jubm51R5TVlbGPvroI2ZgYMDmz5/P4uPjWWlpKcvMzGQnTpxggYGBDAADwCQSCWOMsczMTGZnZ8cAsJ9//rnKOQ8fPsw8PT1ZUVFRlc9du3aNNW3alH3//feVnn/w4AEbNmwYa9++PbOysmL6+vryvk0yir5fDx48YK+88gpbunRpjefMz89nmzZtYgDYypUrFa5JGfLz89mYMWOYgYEB++qrr9R78fJyxlq0YGzJEqWcLj4+ngFggYGB7MaNG6ykpIQlJiayCRMmMABs3rx5SrkOabD1FGwNpeHBJpFI2NixY5m5uXmdYaJMISEh7P/+7/+qPH/9+nUGgHl6etb6+oofFvn5+TUe8/HHHzMAbMuWLdV+XiqVsqCgoErBxhhjv/zyCwPA7OzsWGZmpuz5nJwc5ubmxi5cuFDlXM+fP2eurq5sxowZ1db6xRdfMIlEwlxcXOodbIq+X9evX2cikYjt27ev1nObmZmxAQMGKFyTspSXl7OvvvqK6enpseXLl6vvwpcv8+/Nv/5Syo1i5okAACAASURBVOni4+OZgYEBy8nJqfS8WCxmdnZ2zNjYmJWWlirlWqRBKNgaTMOD7cMPP2RmZmbsjz/+ELoUGVNTU6anp8fKy8trPGbAgAG1BkR8fDzT09NjnTt3rvVaFy9erBJsjDE2fPhwBoCNGjVK9tykSZPYggULqj3PkiVLmIGBAUtPT6/yueLiYtmf6xtstant/RozZgxzdXWt8vW9zNnZuc73SR3+97//MZFIxLZt26aeC86fz1irVmq5VMeOHRkAlpeXp5brkVpRsDWYBgfb4cOHGQD2yy+/CF2KTGFhIQPA2rdvX+tx/fr1qzUg5s6dywCw1atX16uOjIwMZmNjwwCwsLAwdvDgQebj41Ptb9zl5eXMwcGB9ejRo87zKjvY6nq/du/ezQCw8PDwWmvq0KGD0mpqiI8//piZmJiwhIQE1V6orIwxV1fGaumqVZbc3Fxmbm7OOnXqpPJrEbmsp8EjOkoqlWLWrFkYP348Jk6cKHQ5MhVDwJcsWdKg85w9exYA0L59+3q93snJCd988w0A4P3338cHH3yAnTt3Vruyyo0bN5CVlYUOHTrUv+B6quv96tixIwDg+PHjaqupIVasWIE2bdrgww8/VO2FTp4E0tKAN9+s9bC7d+9ixIgRsLa2hpmZGfz8/BAZGVlpINH06dOrfW1+fj4uXLiA4cOHw9HRET/99JMqvhJSH0JHq9bT0BbbgQMHmL6+PktMTBS6FJnMzEzm4ODApk+fXuexvXr1YmZmZjV+3snJiQFgly9fblBNgwcPZgBY7969azxm165dDABbtWpVnedTZotNnvfr+fPnDADr1atXjce0atWKeXt7K6UmZYiMjGQikYjFx8er7iITJzLWvXuth9y/f581adKEubi4sBMnTrCCggIWFxfHAgMDmb29PTM2Nq7xtZ9//rlsYFKfPn3YzZs3lf0VkPqjFpuuOnToEHr27IlWrVoJXQoAIDs7G4MGDUKfPn2wadOmOo9/9OgRXF1d6zyuoQvwenp6AgDOnDmDiIiIao95/PgxAKh1JwN53y8rKyuIRCJZjdVxdnZGeno6pFKpKkpVWFBQEOzt7REZGamaC+TnA+HhwJQptR728ccfIy8vD6Ghoejfvz8sLCzg4+OD3bt317lyytKlSyEWixEfH482bdqgU6dO+Pzzz5X5VZAGoGDTUXFxcfDz8xO6DAB8r6+BAwfC29sbv/zyC/Rr2b04JycHa9euRUpKCt57770aj3N2dgbAN8ysr3PnzuG3337DunXrAAAzZ85Ebm5uleMq5oCpa+dvRd4vADAwMEBJSUmNn58xYwby8/OxbNmyBr1fyqKnp4cuXbrg1q1bqrlAWBhf+Hjs2FoPO3bsGABg4MCBlZ63t7dHmzZt6ryMkZER2rRpg40bN2L48OFYtmwZTp06Vf+6idJQsOmowsJCWFhYCF0GpFIpxowZAxcXF+zcubPWH9Jvv/027OzssGjRIixYsAD/+c9/ajy2d+/eAICbN2/Wq67CwkK8/fbb2LJlC+bOnYugoCBkZmZi9uzZVY6t2DxVIpHU61qKUOT9evk1te10/eabb2LlypVYu3Yt7O3tMWjQIGWWXC+WlpYoKChQzcl37gSGDweaNKnxELFYjIKCApiYmFT7fWJjY6PQJYcNGwYAqmuFEoVQsOmoZs2aISMjQ+gyMGPGDIjFYvz666+VVuTw8PBATExMpWN37NiB58+fY+/evVi3bh1mzJhR63kNDAywf//+Wq+/YMEC6Onp4e7du5WenzdvHgIDA2U/5Ddv3gwrKyvs2rWryg8nJycnAMDz58/r/oIbSJH3C+ADGBhjshqrs2TJEnz88cfYuHEj8vLyZC0VIaWnp8PR0VH5J374kK/mX0c3pLGxMSwtLVFaWorCwsIqn3/y5IlCl60YdJSTk6PQ64hqULA1lJER/6iG3+YV4e/vj6ioKEGX+Vm+fDlu376NiIgIufdxs7KywpgxY9CpU6daQ8vLywuffvoprl69im3btlV7TEJCAjZv3oyxY8dW6lo6fvw4Tp48ia+++kr2nJubm+zvM2bMQF5enuxzvr6+AIC0tDS5vob6qs/7VbEOY0WN1fntt9/wyiuvYPr06Rqx4/nz588RGxsLf39/5Z/8xx8BR0dgwIA6D61Ypu3fQZ+ZmYl79+5VOf6jjz7CmzWMsjx69CgAoEuXLopWTFRB6OErWk8s5qMia5lHJIQbN24wAOzIkSOCXH/79u2yUWM1PS5dulTj6+uax1Zh0aJFzNDQkC1cuJAlJCQwsVjM0tLS2NatW5mTkxPr2bMnKywslB2fm5vL3Nzc2OnTp6s9X8UyXG+//bbsufLyctasWTOlzWObNGkSA8CSkpJkz9X3/aqYx1bbqjKaNI+NMcbWrFnDLC0tlT+ZWSxmzMGBsU8+kevwBw8eMFtb20qjIm/dusUGDRrEWrRoUWVU5Lx585hIJGIrVqxgycnJrLS0lCUnJ7MFCxYwAKxz586VJusTwdAEbaXQ02OsjmWNhBAcHMxat27NSkpK1H7tIUOGNCjYAgMD5R42Hxsby9566y3m5ubGDA0NmaWlJevWrRsLDQ1lYrFYdpyLi0ul6wcHB8s+l5ubW22N33zzDWOMTyyuaeWRQ4cO1fg1/u9//6tyfEBAALOwsKi0Zmd9368xY8YwFxcX9uLFixrfHxcXF9axY0e53ktVS0tLY1ZWVmyJktZvrGT3bsYMDBhLTZX7JQkJCWzEiBHMysqKmZmZse7du7MzZ86wfv36VQm258+fs61bt7KBAweyli1bMiMjI2ZhYcE6d+7MvvjiCwo1zUHBphSmpozt3Cl0FVWkpKSwJk2asMmTJwtdisKGDBnCRCKR0GXI5OXlMRcXl2rXilREbm4uMzU1lWsuX10q1orcs2dPrcc5ODiwbt26Nfh6DVVaWsr8/f1Z69atVRMCPXsyNnKkUk5VXbARrUHz2JTCzg7QgGHU/9a8eXPs3r0bu3fvxrx584QuRyGurq5gjCErK0voUgDwOWyHDh3C/v37sX79+nqdgzGG//znP7CysmrwnKekpCSMHDkSixcvrrT1zr9JJBLk5OTINSdQlcRiMUaNGoX4+HiEh4fXOoqzXm7f5oNGapkiQhoPCjZlcHAANOQH8L8FBQXh559/xnfffYfx48dXOwJME1WMVly9ejWys7MFrobr1KkTrl69iqNHj1a7H1tdsrKykJSUhKioqAaPCNy8eTNWrlyJlStX1njM8+fPsW7dOkgkEkGH+KenpyMgIADnz5/H8ePH5ZojprDvvwc8PYGAAOWfm2gfoduMOmHIEMamTBG6ilqdOXOGOTo6statW7O4uDihy5HLmjVrWNu2bZmxsTEbNGiQ0OVolSlTpjBDQ0Pm4eHBPvnkE7XswVeds2fPMicnJ+bl5aW6/3f5+YxZWjIWGtrgU+3Zs6fKvc2QkBAlFEnUaL2IMdr2tcGmT+cLrmrA/KDapKWlYfTo0bhz5w6WLVuG2bNnq201DdK45OfnY/ny5fj+++8RHByM7du3w9LSUjUX+/57YPFi/j1Yy6Rs0mhsoK5IZWjRAkhMFLqKOrm6uuLs2bP48MMPsWzZMrRv3x4nT54UuiyiQxhj2LlzJ1q3bo1du3Zhw4YNCAsLU12oSaXAN9/wCdkUauRvFGzK0Lo1kJwMiMVCV1InIyMjLF++HHfu3EHbtm0xYMAADBkyBOfOnRO6NKLFysvL8dtvv8HPzw8hISEYNWoUEhIS8M477zR4oepa7dsHPHoEzJ2rumsQrUPBpgxt2gBlZVrRaqvQsmVL/Pbbbzh58iQKCgrw+uuvo2fPnjh06JCgq5UQ7fLixQts374dPj4+GDNmDJo3b46//voLP/zwA2xtbVV7ccaAr74Cxo8HPDxUey2iVSjYlMHTE9DTA+Ljha5EYYGBgTh79izOnz8PGxsbBAcHw8fHB1999ZXGDLUnmufBgwdYunQpWrVqhZkzZ8Lf3x+3b9/GgQMH6r35q8IOHwauXwe0bCoLUT0aPKIs3t7AiBHAqlVCV9Igt27dwsaNG7Fnzx4UFhZi8ODBmDZtGgYPHkwDTRq5oqIihIWFYfv27Th37hycnZ0xZcoUzJw5E25ubuovqFcvwNoaoBX1SWUbKNiUZepU3tcfFSV0JUohFovx+++/46effsLRo0dhZWWFwMBADB06FG+88YbqBgMQjZKTk4OoqCgcOnQI4eHhEIvFGDBgACZPnow33nij0g4EanXuHPD66/xjz57C1EA0FQWb0mzaBCxYAOTmAnLsoaVNHj16hP379yM8PBwXL16EkZERBgwYgOHDh2PAgAGCr2pBlOvu3bs4ceIEIiIicPbsWejr66Nfv34YMWIERo4cCTs7O6FLBIYOBbKzgUuXhK6EaB4KNqW5dg149VXgxg1AXfcYBPDkyRP8/vvvCA8PR1RUFEpLS+Hl5YWAgAAEBASgT58+sLe3F7pMooCUlBScPn0a0dHRiIqKQkZGBqytrREUFIQ33ngDQUFBmtVCj40FunUDDh0ChgwRuhqieSjYlKasjC+ttWRJoxl6XFJSgosXLyI6OhrR0dG4evUqysrK4OvrC39/f3Tt2hV+fn5o27atXDtBE9V78eIFrl+/jtjYWMTGxuLixYtITEyEqakpunfvjoCAAPTt2xddunQRrpuxLoGBQGkpXxuSkKoo2JRq3DggPx/4e9PBxiY/Px9nzpzBmTNncPnyZfz1118oLi6GpaUlOnfujK5du+LVV1+Fj48PvLy8aDCKipWUlCA+Ph63bt3CX3/9hcuXL+P69esQi8Vo0qQJunbtiq5du6JPnz7w9/eHiYmJ0CXX7eRJvono6dNAnz5CV0M0EwWbUv34IzBrFu/7V/bq5VpIKpUiLi4Oly9fxuXLlxEbG4uEhARIpVIYGRmhTZs28PHxQbt27eDr64vWrVujZcuWMKrYlZzIpaSkBA8ePMDdu3cRFxeH27dv4+bNm0hKSkJZWRmMjY3Rvn17+Pn5wc/PD127doWXl5dqJ06rAmOAvz/QtCmNhCS1oWBTqrQ0oHlz4MgRQMDV1DWZWCzGnTt3cPv2bcTFxckeKSkpAAB9fX24ubnBw8MD7u7uskerVq3g5OQEBwcHgb8C9SsrK0NWVhbS0tKQnJyMxMREPHjwAImJiUhMTER6ejoA/t65u7ujXbt28PHxga+vL9q1awcPDw/N7VZURFgYn4x99SrQqZPQ1RDNRcGmdF27Aj4+wLZtQleiVfLz8/HgwYNKP7ArHmlpabLVUIyMjODo6AhXV1c4OzvDxcUFLi4uaNasGWxtbWFnZwc7OzvZn/X0NHMNAolEguzsbOTk5FT6+PjxY2RmZiI1NRWPHz9GWloasrKyUFZWBgAwMDBAixYtKoV+xcPT01M7uhPro6wMaNeOD9D6+WehqyGajYJN6b7+Gvjvf/n+bNSlphRisRgPHz6s9AM/PT0d6enpyMjIQFpaGp4+fYqSkpIqr7W1tUUba2u8sLWFhaUlTExMYGlpCXNzc5iYmMDa2hpmZmYwNjYGAFhaWlZq3ejr68PKyqrSOfPy8iotOyYWi1FcXAwAKC4uRmlpKfLy8lBSUiL7c2lpKYqLi2UBVt1+bhYWFnB0dISTkxPc3Nzg6OgINzc3ODk5yQLczc1NN1pfitq6lW8iGh8PuLsLXQ3RbBRsSpeaylf7p6HIaldSUlK1FZSZiVErVuC6lxcOduyIkpISFBQUoLCwEKWlpcjPz0dRURFevHgBAMjNza10zhcvXqCoqAhDAeQBOI/aw8/U1BQmJiawsbGBiYkJTE1N0aRJE5iYmMDMzEzWkqyudUn3FmtQUMAXGh85EvjhB6GrIZqPgk0levYEXF2BvXuFroT88ANfS/D27YYtlBsQwBe73rBBebUR+cybB+zYASQk8IEjhNSO9mNTiZAQ4OBB4MkToStp3PLygBUrgNmzafV3bXXnDt9I9IsvKNSI3CjYVGH8eMDMDPjpJ6EradxWrQLKy4FFi4SuhNTXrFl8JZ+QEKErIVqEgk0VTE2BiRP5DW/q6RVGSgr/TX/5ckDV+4IR1di7F/jjD2D9ep1bf5WoFgWbqrz7LnDvHp/TRtTviy8AZ2dg5kyhKyH1kZvLl6abNo1PoSFEARRsquLrCwQFAWvXCl1J45OWxgcbLFwI0LJd2unDD/nHL78Utg6ilSjYVGn+fODMGdpaQ93WrgXs7YEpU4SuhNRHdDSwcyfvgrSxEboaooUo2FSpTx+gSxf6rVOdsrL4vc0FC4C/J10TLVJcDLzzDjB6NJ+3Rkg9ULCp2iefAOHhwOXLQlfSOKxbB1haAtOnC10JqY+PP+bTNL77TuhKiBajYFO1YcP4iuSffip0JbqvuBjYsgWYM4d2V9BGUVF8JOu33wKOjkJXQ7QYBZs6fP45cPw4cPas0JXotj17eLhNmyZ0JURReXn8323ECOCtt4Suhmg5CjZ16NePP+bN4xOGiWps3gyMGQM0ayZ0JURR774LSKW8xU1IA1Gwqct33wHXr/PRXkT5rl8HrlyheWvaaNcuYN8+PujHzk7oaogOoGBTF29vYMYMvrzT8+dCV6N71q8H2rYFevQQuhKiiKQkvmzW7Nl83ichSkDBpk4rVvDulhUrhK5EtxQV8ftr770HiERCV0PkJRYD48YBr7zCV4ohREko2NTJzg5YvRoIDaVJ28p07BhQWsp/SBLtMX8+cPcu/6VEV3f+JoKgYFO36dOBvn35vSCJROhqdMPBg3wPPHt7oSsh8vr9d75X3qZNfJ87QpSIgk3dRCJg40bg/n1aR1IZJBK+0PSIEUJXQuSVmAhMnsx/uZs0SehqiA6iYBOCpye/z7ZiBR/NR+rv9Gm+EnxwsNCVEHkUFwOjRvH7auvWCV0N0VEUbEKZN4+P4Js4ESgpEboa7XXwINCpE/9BSTRfSAiQmgrs30/31YjKULAJRU8P2L4dyMigHZ4b4tgxvmwZ0XxffgmEhQG//AK4uwtdDdFhFGxCatGC30D//nt+M50oJjUVePiQD8Yhmu3UKb7A8ZdfAoMGCV0N0XEUbEJ7801g6lS+d1hystDVaJfTpwEjI8DPT+hKSG0SE/lUjHHj/tlAlBAVomDTBOvX83tE48bxSatEPrGxwKuvAmZmQldCapKbCwwdyv9/b90qdDWkkaBg0wQmJsDevXyy6qxZQlejPa5d48GmoNzcXGzatAkBAQGwtbWFqakpPD09MWnSJNy4cUMFhXJHjhyBl5cXDAwMVHYNjSKRAGPHAvn5fE9C2kqIqAkFm6bw8uKLwf74I7/vRmpXXg7cugV07KjwS+fPn49Zs2YhODgYd+7cQXZ2NrZt24br16+jc+fOCA8PV2qpiYmJGD58OBYvXoysrCylnlujzZ4NXLzIQ83VVehqSCNCwaZJgoP53La5c/mmi6Rm6elAQQHg41Ovl0+bNg2zZ8+Go6MjzMzM0KtXL+zevRtlZWVYsGCBUkv95JNP0L17d/z555+wtLRU6rk11tdf822E9uwBunQRuhrSyIgYY0zoIshLGAMmTABOngTOn+cr1pOqzpwB+vQBHj9W6m7LZmZmEIvFkEqlEL28oHJAAF/6acMGhc9ZUlIC07+74VxdXZGZmQmpVKqskjXP3r18RZEvv+TzNQlRrw3UYtM0IhGf39amDR8WnZYmdEWaKTmZDxpxcFDaKYuKilBSUgJfX9/KodZApo3p3lJ0NPD223zjUAo1IhAKNk1kasrXP7SxAQYOBHJyhK5I8zx+DDg5ybapuXv3LkaMGAFra2uYmZnBz88PkZGRCAwMhEgkgkgkwvTp02s9ZVhYGABgyZIltR6njGvppCtXeHf66NF8Y11CBNJIhmdpIWtr4PBhvuzW4MH8npu5udBVaY7cXB78AB48eAB/f3+Ym5tj//798Pf3R0pKCubMmYObN2/C2NgYpaWltZ4uKysLixYtwvTp0zF27Ngaj1PGtXTS/ft8WH/v3rzHQY9+ZybCof99mszFhd9rS07mc9x0+b6Mol4Kto8//hh5eXkIDQ1F//79YWFhAR8fH+zevRtFRUV1nio7OxuDBg1Cnz59sGnTplqPbei1dFJ6OtC/P5+rtm8fYGgodEWkkaNg03SensChQ3ywxNSpfHAJ4RPZ/15E99ixYwCAgQMHVjrE3t4eberY66uoqAgDBw6Et7c3fvnlF+jr69d6fEOupZOys4EBAwALC959Tr0KRANQsGkDPz/+m/C+ffyGPIUbn8cmEkEsFqOgoAAmJiawsLCocpjN36266kilUowZMwYuLi7YuXNnnaEmLiur97V0UnExv6dWUAAcPQrY2gpdESEAKNi0x+DBwM6dfMHk2bMp3P5mbGwMS0tLlJaWorCwsMrnnzx5UuNrZ8yYAbFYjF9//bXSaiAeHh6IiYmpei19/XpfS+dIJHyQSEICcOIE4OYmdEWEyFCwaZMJE4DffgO2bAFmzOCtlsbKwgL4O1yCgoIA/NNNWCEzMxP37t2r9uXLly/H7du3ERERAWNjY7kvW59r6ZyyMr4D9vnzfNugxtgFSzQaBZu2GTYMOHCAL7/11luNd0CJjQ0fQAJg1apVsLW1xZw5c3Dy5EkUFhYiLi4OU6dOhWM1k7d37NiBFStW4PLly7C0tJQN0a94JCYm1nhZRa+lcypC7fffgYgIoHNnoSsipAoKNm00ZAjfOfrgQb7tTWMMN1tbPnABgLu7Oy5duoQuXbpg9OjRcHBwwIwZM7B48WJ4eHhUeen+/fvrfVlFrwUAkZGRstBMT09HWVmZ7O9btWnF+7IyPvk6PJyHGu2DRzQUzWPTVoMG8Rv2Q4fyLsrduxvXMOsWLfgw8xcvACMjeHl54eDBg3K9NDIyskGXVuRaADB06FBo/cp1FaH222+8tdavn9AVEVIjarFps969gchIfp9jxAjZPadGwcOD/7B9+FDoSnQfhRrRMhRs2q53b74qydWr/M+PHwtdkXp4ePDltOLjha5Et70caocOUagRrUDBpgv8/ICYGD6vqEsXQIWbZWoMKys+Gu/y5Wo/vXfvXohEIkRFRUEsFqt0/UZ1XkutysqAKVP+CbWAAKErIkQutG2NLsnNBd54gwfbb7/p/s39kBAgMRH44w/VX6sB29ZopYpQO3iQQo1oG9q2RqfY2ADHj/PJ3IMGAT//LHRFqtWjBxAbC5SUCF2JbpFI+ICk8HC+EDeFGtEyFGy6xtiYB9rs2Xy+0X//q7urlAQFAaWlfA8wohwVy2QdO8ZDrU8foSsiRGEUbLpIJOK7F69fD3z2GV/6qKBA6KqUz8kJePVV/gOYNFxeHt//7/JlvkxW795CV0RIvVCw6bJ33+WtmYsXgddeA27fFroi5RsyhAebrrZK1SUzk9+Trbhn2a2b0BURUm8UbLquZ08+FcDODvD358tx6ZKRI4FHj4BLl4SuRHs9fAi8/jrv1o2JAdq1E7oiQhqEgq0xcHEBTp/m+7mNGQMsWsRHvemCDh0AX1++8gpR3O3b/JcfKyvg7FmgeXOhKyKkwSjYGgtjYyA0lO8M8O23fDHlnByhq1KO8eOBX3/lo/mI/GJj+X00T0/eZW1vL3RFhCgFBVtjM306/808Lg7o2JH/WdtNnMgXRD5yROhKtEdUFF9FpEcP/r5ZWQldESFKQ8HWGPn5AbduAd278wEDs2drd2vnlVf4D+ktW4SuRDvs2MGnSowdyyfym5oKXREhSkXB1lhZWwN79wLbtwNbt/L7LElJQldVfzNm8LlXtChyzRgDli0Dpk0DFizg/+76+kJXRYjSUbA1dpMn81GTYjHQqROwZ4/QFdXP8OGAgwPwv/81/FyffcaD39Lyn8eFC/yXgJefa9KE/3KgDcRi/m/9xRd8WbD//pfPdyREB1GwEaBtWz5cftIkfr/qnXe0bwscQ0Ng5kxg0yagqOif5yUSYONGHt7yGjYMyM/n70HF48ULPhz+5eeKi/nSZZouJ4dPvI6I4NvOzJwpdEWEqBQFG+FMTflv8gcP8jUC27fnUwS0yQcf8JbJzp28223/fsDLC3jvPT4CUF6dOvFtcWpjYMDX5GzSpGE1q1pSEh8g8uABHygUFCR0RYSoHAUbqWzECD636dVX+YCMGTO0p/Vmawu8+SZfTqxLFz444tEjHkKK7tv21lu170heXs6vpcliYvikfEtL3mLt2FHoighRCwo2UlWzZry1s28fHzXXrp12LDQcH8+DLCWFb93DGA8gqZSPAlXEpEn8dTUxNubLeWmq/fv5qvzdu/Mlshwdha6IELWhYCM1GzPmn9ZbYKDmtt7S0vh9QV9f4ORJ/ty/Q0nRdTLd3fmqJtUNsDA05AtLa+Iwecb44JexY/m9tAMHADMzoasiRK0o2EjtmjXjPxx37eKtgI4d+Z5vmiIykt8P2779n9ZZdZ4946vXK2Ly5OqHw0skfJCNpiks5L+M/Pe//H7punWAHn2Lk8aH/tcT+UyaxFcrefVVPhJwwgTg8WOhq+KDIaZO5aFWF0Xvs40fX/15mzThLVh1kkiArKyaP5+ayvdO++MPPp+PRj6SRoyCjcjPyYmvyRgdDVy7xqcJhIYKu6Cyvj4fzv/FF3Ufp2iwOTnxEYUvt3oMDXnIGxgoXmtDrF4NjBpVfYv03Dm+LZFUygeJ0I7XpJGjYCOK69uXB9ucOcDChXyJritXhK1p4UJg2zYeQtV1v9Un2AA+OvJlEglvrarTrVv8vtmFC8DSpZU/t2ULH73apw//fMuW6q2NEA1EwUbqx9QUWL6ctxBMTfnou7lzFb+PpUxTp/JRnAYGVe+NSSS8K1VRo0dXPpeTE/9a1UUqBaZM+WcQy5df8nmGYjFf0HrmTODDD/kKKObm6quLEA1GwUYaxteXd4Vt3Aj88gufEL1li3Ddk8HB2nc9ZgAAC2BJREFUwIkTgIlJ5e5CxhQf8g8ANjZ81Q4DA94NOXmyepei+vJLPnWhYpFqkYjX0KcPEBbGVxJZvZqWxyLkJRRspOFEIt56uHePL7A7axa/5yPUlji9e/PJyba2lSdZZ2TwZbAUVTGnTSLhA0rU5e5d3ip+eQBLeTlf2iszk7+/Q4eqrx5CtAQFG1GeJk146+HWLb5rd+/efN3F5OS6X/vwoXJHWfr68nBzdf0n3Bjj4VuX4mJ+3OXLwKlTfB6YkRGf5PzsGX/u6lVes1isvJpfVl7OuyCrI5HwuXvKWPCZEB0kYowxoYsgOurQIWDePP5D+MMP+VYpNW1oOWUKcPEiHwDRrJnyasjKAvr35wNHpFLeXVoxBy09nYff7dv8cecOX7kkP1+xazRtCjRvDvj48Ee7dkDXroCdXf3rXrsWWLSo7mkMP//MW5SEkAobKNiIar14AXz3HbBqFb9P9cknfAUTI6N/jklM5PfmAP7x/PmGhcK/FRTwbW3++IOvhWljw7vxEhP5CMpWrXgLz9ubjyp0cuItzqZNAQsLPnjk/HnA05M/BwDPnwNPnvAuwdRUvozXrVs8IFNT+Xl9fPi9sP79+cPERL56793j4fjiRe3HiUT8nNev//P+EUIo2Iia5OYCa9bweW/NmgGff86H0otEfDTjL7/wLjZDQx4g587xe2QNVVjI17z89VfehQjwTVX79AFefx3o1k2+0YSMyT9AIyeHtzzPnOGPv/7i3ZmDBwPjxvHu2ZoWWC4v56Mu//qr9l3NDQ15C9TUFFi8uOo0AEIaLwo2omYpKfyH8O7dfIDJRx/xrsGXJx4bGgKtW/NWlY1N/a5z+zYfqblrF2/5BAXx1lpWFjB/vnK+FnllZPC90H77jW8F1KwZEBLCW66urpWP/fZb3m1b3beloSEPOwsLPvozOJiHJQ3zJ+RlFGxEILdvAytW8HtfCQlVWyeGhnxdyqgovu2KvOLi+BD53bt5F2NICB+paW+v3PrrKyODh+369bwbc/x44NNP+aLLycm8O7S09J/jjY35ABVra97SGzuWTz94uSuXEPIyCjYioJQUvoBxTQsXGxrytSlPneKtlNqkp/OBKr/+ygPx00/5fTVNnd/14gWwYwdfCiwjA3j/fb6LeUwMvxcplfIwHjeOL6XVq1f1CzITQv6Ngo0IKCSEt17qupfUowdw9Gj1gy/KyvjglE8/5UHw9de8i05TA+3fJBLgxx95l2xREb+vOHUqD7Nu3bTn6yBEc2xQ80quhPwtJQX46afaN/ME+A/+8+f5ROTDh3nXXIX0dL6L9aVLfCrB4sWauUdabSpWM0lP592oERG8i9LXl0KNkHqiFhsRxvTpvKUiLwMDvl3Ob7/xMDh+nM/fsrcH9uzh3Y+64NgxPqfPyuqf3csJIYrYQCuPEPUrL+ddbsOH88ES/75/ZmzMux1fbrFIpbzFNn48X8V/2DA+0vHqVd0JNYCH940bgLMzn47wxx9CV0SI1qEWG9EMubl8iaqXH4mJwP37fMJzSUnl4z/+mO8UravddWIx76KMiOCLHQ8bJnRFhGgLGjxCtER2Nh8k8vnnvKX30Ud8orUuKy8H3n2XD7A5fpyPjCSE1IWCjWiJ48f5AJLFi/mmm41FWRnvfj11ik8FaN1a6IoI0XQUbEQLZGUBHToAgYF80d/GRizm99skEj4C9OWRoYSQf6PBI0QLTJvGB5hs3Ch0JcIwNuYrqSQm0pqQhMiBgo1otshIPjl7xw7FltYSwL59+9CxY0eYmppCJBJBJBIhLi5OOSd3dwe++oovIi3PnnKENGIUbERzlZUBCxfyVThUMFCksLAQnp6eGKqEXagvXLiACRMmYMCAAXj69CkePHgA138vcNxQ06bxe2yLFyv3vIToGFp5hGiuI0f4IskHD6rk9IwxlJeXo7yuzTzlEBYWBsYYZs+eDQsLC1hYWCA1NVUJVb5EX5+PCh05kndLursr9/yE6AhqsRHNtW0bEBCgsk00LS0tkZiYiCNHjjT4XBUhZqfMDVKrM2wY3+pmxw7VXocQLUbBRjRTYSFfaWTKFKErkUtZWZl6LqSvz5cS27NHPdcjRAtRsBHNFBPDh7cHBqrk9OHh4bIBHiKRCKV/74H27+cfPnyIcePGoUmTJrCzs8PQoUORmJhY5TwREREAIBs40q1bN5XUDQDo1493Raanq+4ahGgxCjaimS5dAlq2BJycVHL6ESNGgDGG4ODgWp+fM2cO5syZg/T0dOzbtw/R0dGYMGFCjceXlJSAMYaYmBiV1A0A6NqVt9xUeQ1CtBgFG9FMKSkascrG9OnT4e/vD3NzcwQGBmLIkCG4cuUKnj17JlxRlpY88FNShKuBEA1GwUY0U3Y2oOqBGHLo0qVLpb+7ubkBADIyMoQo5x9Nm/L3iBBSBQUb0UzFxRqxaai1tXWlvxsZGQGAUqYINIi5OR9gQwipgoKNaCYbG76VDaleTg7f044QUgUFG9FMTZsCT58KXYXmevqUv0eEkCoo2Ihm8vHhO0mra36YNnn0CHj2DPD1FboSQjQSBRvRTN27A/n5wJ07Kjl9dfPP3nzzTcTExFR5funfK+qLRCKsWbMGANCpUycMHTq0xnlsKh3uf/EiYGgI/GtgCyGEo7UiiWby9QWaNQPCw4F27ZR++or5Z9VR1vMqEx4OdOsGmJmp97qEaAlqsRHNpK8PvPkmsH07IPQIRE2SnQ1ERABTpwpdCSEai4KNaK6QEODhQ+D334WuRHNs3AgYGQFjxghdCSEai4KNaC5vb2DsWGDRIr5uZGP39Cmwdi0wfz7fUZwQUi0KNqLZVq0CkpOB774TuhLhLVrEJ2bPnSt0JYRoNAo2otlatQI+/RRYsgS4dk3oaoRz4AC/37hhAw83QkiNREztQ7oIUVB5Od++Jj2dD3XXgDUk1So+nk9/mDgRWL9e6GoI0XQbKNiIdnj8GOjRg08BiIpqPK2W1FT+dbdoAZw8CZiYCF0RIZpuA3VFEu3g5AQcP87vtw0fzidv67qUFKB/f8Damo8MpVAjRC4UbER7eHoCJ07wrrnevXkrTlfdvMm7H42NeaDb2AhdESFag4KNaJcOHfh9ttJSwM8POHtW6IqUb/duoGdPvtHq2bOAs7PQFRGiVSjYiPZp2ZKH22uvAQEBwPLlujHPraAAmDaNr7gybRpw7BjvhiSEKISCjWgnGxvg4EEgNBT48kugUyfgzBmhq6q/vXuBNm2AQ4f4klnffstXGCGEKIyCjWi3998H4uJ4K65vX2D8eJXtCKAS584BffoAkyYBgwcDd+8C/9/e3fsWFIZRAD/o0sVHB5HQCIOJTdjuQMLEoJOhs79J+AekYjJZfIRRKiQ2FiI1YRCT6HDSWGxVN733/JI3FsN7p5P363kKBbNnJfKvKdjk/4tGgXabVe/nc3YDKJeB8djsmd12ufDqfiYDGAbgcHBrtVaz3xs9kT+gYBPrKBaByQRoNHhzMplkz7J6HTgczJ4d8PXFWo+xGJDLMdB6PaDbBdJps2cnYhl6oC3WNRwC1SrQbHKVlM0Cb2/c8gsEHjOHxYLnZq0WMBoBbjfw/g5UKuwSLiL3psojYgO73TVcOh3gdOKqyTD4ViyRYCeB3zbu3O953jedMsT6fZYB83p5blYqAfk88Px8n+8SkVsUbGIzxyNDZzBg8IzHDDqnE4hEWLoqGGSlk5eX68Nonw84n1nx5Od3u+X24nrNvnGrFf/r8bDDtWFwpFK64SjyOAo2sbnzGVgugdmMF0/Wa2Cz4djtOC4XrsacToaWy8UtRb+fW5qhEPD6CsTj3F4Mh83+KhE7U7CJiIilqAiyiIhYi4JNREQsRcEmIiKW8gTgw+xJiIiI3MnnN1d9CBuvDCESAAAAAElFTkSuQmCC", - "text/plain": [ - "" - ] - }, - "execution_count": 42, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# draw the dep_graph_copy, which is the first dag\n", - "draw_dag(dep_graph_copy, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## relabeling nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "draw_dag(dep_graph_copy, output_format=\"png\") " - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [], - "source": [ - "# relabel the nodes\n", - "\n", - "dep_graph_copy_copy2 = nx.MultiDiGraph()\n", - "dep_graph_copy_copy2.add_nodes_from([(-1, {\"color\": \"green\"})])\n", - "\n", - "i = 0\n", - "for node in nx.topological_sort(dep_graph_copy):\n", - " if node not in [-1, float('inf')]:\n", - " node_copy = copy.deepcopy(node)\n", - " node_copy.label = i\n", - " dep_graph_copy_copy2.add_node(node_copy)\n", - " i += 1\n", - "\n", - "dep_graph_copy_copy2.add_nodes_from([(float('inf'), {\"color\": \"red\"})])\n", - "\n", - "for edge in dep_graph_copy.edges(data=True):\n", - " dep_graph_copy_copy2.add_edges_from([(edge[0], edge[1], edge[2])])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABOUAAAeXCAYAAACfXdHQAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeVxTV9oH8F8g7GHf91VBcAUUK1oRN1zQLlq1SnVmWpfasdNp1bZq7TLtaJ1p7bRjq3Y6Vau16lStuNWlguAOqIiAyr7vkLCT5Hn/sLmvQES25CZwvnzyAZKbe54k5zk3ee65NwIiIjAMwzAMwzAMwzAMwzAMozY6fAfAMAzDMAzDMAzDMAzDMP0NK8oxDMMwDMMwDMMwDMMwjJqxohzDMAzDMAzDMAzDMAzDqJmQ7wAYhumbZJCh5PefalRDBhkkkEAKKYxhDAMYwAhGsIAFHOEIK1jxHTLTSbW1tRCLxaipqUF9fT1qa2vR0tLC3V5VVdVqeUtLS+5vPT09iEQiGBsbw9zcHGZmZhCJRGqLnenbZDIZxGIx6urq0NDQALFYDACoqamBXC5vtWzbfgoAIpEIenp6ra4zNTWFUCiEkZERDA0NYWlpCUNDQxgZGanugTBMG4q+LRaLUVtbi8bGRjQ0NKCxsZFbpqWlBbW1ta3u17ZPK/quoaEhRCIRzMzMYG5uDh0dtp+e4RcRobq6Gk1NTa3eW0ilUkgkknbLKxvXdXR0YG5u3m5ZxTiueA9iYmICfX19WFhYQCAQqOwxMYy6sPzRbqwoxzBMjzSgAddxHbdxG3dwBylIQQYyUIpSyCDr9HoMYQgXuMAXvhiMwQhAAAIRCH/4QwA24KtafX09MjIykJOTg6KiIhQVFaG4uBiFhYUoKSlBaWkpqqqqIBaLIZN1/nXtDF1dXZiZmcHS0hL29vaws7ODs7Mz7O3t4eTkBAcHB7i7u8PHx4cVQvqJ+vp65OXlobi4GOXl5SgvL0dFRQUqKyvb/a6rq4NEImlXHFYHRYHOxMQEVlZWsLa2VvrbysoKzs7OcHR0hI2NjVpjZDRTbW0tcnJykJubi7KyMpSXl3NjbXl5OXedogjX0NCg0niMjIy4Ip2NjQ1sbW1hY2PDjcm2trawtbWFq6sr3N3d2c4URqmamhoUFhaitLQUFRUVqKqqUnqprKxEVVUVGhsbUVdXx8v4rfBoocHIyAiWlpYdXqytrWFnZwcnJyelBQyG6S6WP/2XgH37KsMwXSGHHFdxFSdwAhdwAddxHU1oghWsuGKaL3zhCEc4wQn2sIcVrKADHZjCFEIIUY96NKEJjWhEJSpRiEIUoQh5yMNd3EUKUpCKVDSjGbawxTiMwwRMwCzMghvc+H4KtBYRITs7G7du3cLdu3fx4MEDPHjwABkZGSgsLOSWMzc3h5OTE+zt7eHs7Aw7OzvY2dnB0tKSm92mmF2h2AgbGhpy9zczM4Ouri6A/5/doaCY2aGYbaeYcScWi1FVVYXS0lKUlJSgoKAApaWlKCgoaHV/Z2dneHt7w9vbGz4+PggICMDQoUPh6emphmeQ6Q0ymQy5ubnIzMxERkYG8vPzkZubi6KiIhQUFKCgoADV1dWt7qN4I6es6GViYgJTU1OIRCIYGhrCzMwMxsbGMDQ0hIWFBQBwe3Ufpdjz+6iOZtTV19ejsbER1dXVXD+uqqpCU1MTamtr2xUMH/1bKpVy6zM0NISzszOcnJzg4uICR0dHuLq6wsvLC15eXvD29mbF5z5ALpcjJycH6enpSEtLQ3Z2NrKzs5Gbm4ucnBxUVlZyyxoaGsLGxgZ2dnawt7fnCmK2trbcOGtiYgJzc3OYmprCxMQExsbG0NfXh4mJCbceZbMc2vbpuro6NDc3o76+nito19TUoLa2FnV1dRCLxSgrK2tXKCwrK0NTUxO3Hmtra7i7u8PNzQ3u7u7w9PSEn58ffH194e7uzmZP9DFSqRQFBQWt+rFiG11SUsLtyGtbPFbscGt7sbKygqWlJYyMjGBsbAyRSMTNvFH060fH7Udn3CsoG9ebm5tRV1fXblnFOK64XZEHVVVV3AzT+vp61NfXP7YQotgx+SgjIyM4ODjA0dGx1Xsmd3d3eHh4wN3dHS4uLtx7IqZ/YvnD8udJWFGOYZhOiUc89mIvjuIoClEIb3gjDGEY//tPbxfLpJDiJm4iFrGI+f1HDDGCEITn8TxewktwglOvttmXEBFSU1Nx6dIlJCYm4vbt20hOToZYLIZAIICHhwcGDBjAFbcUF09PT40rCDQ0NCAzM7NVEVHxd3Z2NogI5ubmGDJkCIYOHYrAwECMGTMGfn5+7IMhjwoLC3Hnzh2kpKRwr1tmZiays7O5Pbrm5uZwdXWFq6srHB0d4eLiAicnJzg7O3MFKxsbG61/Q6bY+11YWMgVHouKipCbm4vi4mKuKKng5OTEFZ+9vLwwaNAgDBkyBD4+Plr/XPRFeXl5SEhIwK1bt5Camor09HSkp6dzH7Ds7e3h5eXVqojl5uYGT09PuLi4aM1sgZqaGuTl5SE7O5ub5af4nZGRgdLSUgCAsbExfH194evri0GDBmHYsGEICgqCi4sLz4+A6UhdXR1XRL5//z5XQMjOzkZ+fj63c8HQ0BCurq7ch2lHR0elH6z7wtjdlkwmQ3l5eauCSmFhIYqLi1FcXMwVV3Jzc7kitlAo5GaYenh4wMPDAwMHDuSK2MbGxjw/KqY3sPx5MpY/j8eKcgzDPFYtarEbu/ENvkEykjEUQ/E8nsezeBZDMEStsTSjGedxHodxGD/jZ1SjGpGIxAqswGRMVmssmkgqleLKlSuIi4tDfHw8Ll26hMrKSpiYmGD48OEYMmQI93vIkCEwNTXlO+ReIRaLkZycjOTkZNy8eZP7XV9fD2tra4wZMwZjx45FaGgoQkJC2s2MYnquoaEBSUlJ3OuQkpKC27dvczOB7OzsMHDgQK7I9OiFHcr5/xoaGpCRkaH0kpWVBZlMBkNDQ/j7+2Pw4MHcLNHAwEDY2dnxHX6/UVpaisuXLyMhIQE3btxAQkICSktLoaOjA29vb/j7+8PX1xd+fn4YNGgQ/Pz8uBmbfV1VVRXS0tK4wmRqaipSU1ORkZEBIoK9vT2CgoIQFBSE4OBgPPXUU7C1teU77H5HLBbj9u3buHv3LtLS0nD37l2kp6cjJycHRAQ9PT14eXlxH4AVM1YUfzs6OvL9EDQeEaG4uBhZWVnIycnhijOKvzMzM9HS0gKBQAB3d3f4+fnB39+fGzeGDRvWZ96n9TUsf1SvP+YPK8oxDNNOLWrxH/wHm7CJK34txVJMwiS+QwPwsEB3FEexAztwDucwBEOwHusxB3P61fnnSkpKcPr0aURHR+PMmTOorq6Gg4MDgoODuULUqFGj2k1P7+tkMhnS0tIQHx+PuLg4XLx4EdnZ2TAxMcGECRMQGRmJiIgIuLmxQ6G7IzMzE3FxcUhISOAKE01NTTA1NcXAgQPh7++PgIAA+Pv7Izg4mL0B7QXNzc24f/8+7t69i5SUFCQkJODu3bvIysoCEcHR0ZErdowdOxZjxozpM3uP+VZcXIyLFy9yOzwSExPbPedBQUEIDQ2FlRX7wiJlJBIJbt26xY0ZCQkJSEtLg1wuh5eXF0JDQzF27FhMnToV7u7ufIfbp9TU1CA5OVnpc29gYABvb29uvA4ICICXlxcCAgJanZKC6X1SqZQ7jUNKSgo3tiuOaADQbowJCQlhO2DUjOWPZuqL+cOKcgzDcOSQYzu2YwM2oAUtWIVVeANvaPQ3oyYiER/gAxzDMYzESHyFrzASI/kOS2UePHiA/fv348CBA0hOToaxsTEmTJiAiIgIREREwMfHh+8QNdL9+/dx6tQpnDx5EjExMaivr8ewYcPwwgsvYP78+fDy8uI7RI0kl8tx69YtnDt3DufPn0d8fDzEYjGMjIwwYsQIjBo1irt4eXmxw4XVrKKiAtevX8e1a9e4S1lZGYRCIUaMGIHw8HCEh4dj7NixrEjXSS0tLbh48SKOHTuGEydO4N69exAKhQgODsbTTz+Np59+GmPHjtWaQ041VXV1NeLj4xETE4PY2FgkJCRAKpXC19cXM2bMwMyZMzFu3Dg2u7kL5HI57t6926qInJOTA+Dh+VgDAwMxYsQI7jfbMaWZcnJykJSUhKSkJCQmJiIxMZE776+HhwdXxB43bhz8/f3ZdreXsPzpG7Q1f1hRjmEYAA+LW8uxHDdxE6/jdbyDdzS6GNdWEpLwV/wVsYjFUizF3/F3WKBvHDJUXFyMffv2Yf/+/bh+/Trs7Owwd+5czJ49G+PGjWN75LqooaEBsbGxOHr0KA4dOoSysjKMGjUK8+fPx4svvgh7e3u+Q+RVdnY2Tp48iXPnzuHChQuoqKiAra0tJkyYgPHjx2P06NEYMmQI9PT0+A6VUSIzMxPXrl1DXFwczp8/j9TUVOjr62P06NEIDw/HlClTEBISAh0dHb5D1RgSiQTHjh3DL7/8gtOnT6O6uhr+/v6IjIxEeHg4xowZw75tVMVqa2sRHx+Pc+fOITo6GqmpqbCwsEBERARmzZqFmTNnat3hSKoml8uRmJiI3377DRcvXkR8fDwqKythamqK0NBQhIaGIjg4GCNGjOj32zVtV1xcjKSkJNy4cQNxcXG4fPkyJBIJrK2tERoainHjxiEsLAyBgYFsbO8klj/9hzbkDyvKMUw/RyBswRasx3o8haewDdsQgAC+w+oWAmEv9mI1VsMABtiHfRiDMXyH1W0JCQnYsWMHdu/eDQMDA8yaNQtz585FREQEK4j0EplMhsuXL+PgwYPYt28fxGIxZs+ejaVLl2LSJM04XFsdUlJSEB0djWPHjuHSpUswNjbGU089hUmTJmHSpEkYMWIEe6OvpUpKShAbG4uzZ8/izJkzyMrKgo2NDaZNm4a5c+diypQpMDAw4DtMtZPJZPjtt9+we/duHD58GA0NDRg9ejQiIyMxe/Zs+Pn58R1iv5aVlYUzZ87g2LFj+PXXX6Gjo4PIyEhERUX1621gRUUFzp8/j7NnzyI6OhqFhYWws7PDqFGj+vVpK/qbtqfpuHDhAvLy8mBjY4MJEyZg0qRJmDVrFhwcHPgOVaOw/GEAzcwfVpRjmH6sClWYj/n4Db/hY3yMt/BWnzgnWznKsQRLcBqn8Qk+wWqs5jukTpNKpdi7dy8+++wz3L59GyNHjsSrr76KefPmady3ovY1DQ0N+PHHH7Ft2zYkJCRg+PDhePPNN7FgwYI+9w1YAJCcnIzvv/8ehw8fRlZWFlxcXDBr1iw888wzCAsL67cfevu6lJQUHDlyBEeOHEFCQgJMTU0xbdo0LFq0CNOmTeuTff1RDx48wL///W/s27cPZWVlCA0NxaJFi/DCCy/A0tKS7/AYJSorK3HgwAH88MMPuHTpEuzs7LBw4UKsXLmyX5x6IDs7G/v378fRo0dx/fp16OjoIDQ0FBEREZg2bRqGDh3Kd4iMBrh9+zZOnjyJkydPIj4+HkSEUaNGYfbs2Zg/f36/PV8jyx+mM3jPH2IYpl/KpVwKoAByJVe6Rtf4DqfXyUlO/6R/ki7p0gpaQVKS8h1Sh6RSKe3Zs4cGDhxIenp6tHjxYrp2re+9LtriypUrtGjRIhIKheTn50f79u0jmUzGd1g9VlVVRdu2baORI0cSAPL29qZ3332Xrl27RnK5nO/wGDXLzc2lr776isLCwkggEJCjoyOtXbuW0tLS+A6t1124cIFmz55NOjo65OHhQR9++CFlZmbyHRbTRRkZGfThhx+Sh4cH6erq0nPPPUexsbF8h9XriouL6csvv6QxY8aQQCAgGxsbevnll+nQoUNUU1PDd3iMhquurqaDBw/SH//4R7K2tiaBQEChoaH01VdfUWlpKd/hqRzLH6Yn+MgfVpRjmH7oPt0nF3KhITSE8imf73BU6jAdJiMyojk0h1qohe9wlPr1119p0KBBpKurS4sXL6YHDx7wHRLzu3v37lFUVBTp6upSQEAAnTt3ju+QuiU5OZkWL15MhoaGZGxsTC+99BJduHCBFeIYTkZGBm3YsIFcXV0JAI0bN44OHz6s9cXo48ePU2BgIAGg0NBQOnToEEmlmr2ThnkyqVRKBw8epDFjxhAACg4OppMnT/IdVo/IZDI6duwYTZs2jXR1dcnU1JQWLVpEx48fp+bmZr7DY7RUc3MzRUdH08KFC0kkEpFQKKTp06fT8ePHtX58fxTLH0YV1JU/rCjHMP1MIRWSF3nRKBpFVVTFdzhqEUuxZEzG9Ef6I8lJc4oQxcXFtHDhQgJAzz77LKWnp/MdEvMYqampNHv2bBIIBPTSSy9pzZ7m+Ph4ioyMJIFAQAEBAbRjxw62l5jpkEwmo9OnT9MzzzxDOjo65O/vT99//73Wfai5evUqhYWFceMrm3ncd129epVmz55NACg8PJyuX7/Od0hdUl1dTZ999hl5e3uTQCCgqVOn0k8//UT19fV8h8b0MXV1dfTjjz/S5MmTSSAQ0IABA2jr1q1a/b6A5Q+jLqrMH1aUY5h+pI7qaBgNIz/yozIq4zsctTpOx0mP9GgjbeQ7FCIiOnjwIFlaWpK7uzv98ssvfIfDdNKRI0fI1dWVrK2t6eeff+Y7nMdKTEzkChJjxoyho0ePsllxTJelpKTQ4sWLSU9Pj9zc3Gj37t0a34/Ky8tpwYIFJBAIaNy4cXTp0iW+Q2LUJC4ujjtcbdGiRVRRUcF3SB2qqKigN998k0QiEZmamtLKlSv75KHjjGa6e/curVixgut/a9asocrKSr7D6jSWPwyfejt/WFGOYfqR5bScLMmSsimb71B48Q19QzqkQ7/Rb7zFIJVKafXq1SQQCOjVV1+l2tpa3mJhukcikdCyZctIIBDQO++8o1GHwlVUVNCrr75Kurq6FBoaSjExMXyHxPQBOTk5tHz5cq5fJSYm8h2SUseOHSMHBwdydXWlo0eP8h0Ow5Off/6ZnJ2dycnJiY4fP853OO3U19fT5s2bydLSkuzs7Oif//wnVVdX8x0W009VVVXRli1byMbGhqysrGjLli3U0NDAd1iPxfKH0SS9lT+sKMcw/cQv9AsJSECH6BDfofBqDs0hF3Lh5dBdiURCkyZNIiMjI9q9e7fa22d613//+18yNDSkKVOmaERxdf/+/WRjY0MODg60a9cujZ/RxGifxMRECg0NJV1dXVq1ahU1NjbyHRIRPTzny7JlywgARUVFUVVV/zg1A/N4lZWVtHDhQm4HWEuLZpxT9vDhw+Tq6komJia0YcMGEovFfIfEMEREVFNTQ+vWrSMTExNyc3PTyKM4WP4wmqqn+cOKcgzTDzRRE3mTNy2khXyHQkQPT7w9YMAA0tXVVXvblVRJtmRLq2m1Wtutq6ujsLAwsre3V/ksk+48v1KplN5++23y8fEhAwMDioiI4G4LCAggAK0u8+bN426fOHFiq9uCgoLarT87O5siIyO58y5UVlbS119/TRMmTCBLS0syNDQkHx8fevHFF+nmzZvt7r927Vrav3//Y+NfsmQJ6evrk4eHB61atUpte3lv3LhBdnZ2NHHiRN7OX9Lc3EyrVq0igUBAK1euVPm5Ybr62rXVUV9r69q1a7R48WLy8PAgQ0NDsrS0pICAAHruuedo27Zt3JeiqKKPPqo3xqykpCSaPn06mZubk0gkookTJ1JcXFy75TS1ryvI5XLatWsXmZmZ0ciRIyknJ0et7bclkUgoIiKCRCIRHTqknp1OnekPcrmc4uLi6NVXX6UBAwaQvr4+2draUmhoKO3Zs+eJRfMn5YmJiUm7Pr9ly5ZWyzg7O7dbZt26de3a6qvjMxHRgQMHyMTEhGbMmMHrzpPa2lp65ZVXCAAtWbKECgsL1dp+d8ewyMhIAkAfffTRE5fVlrG9p9swha7muCbnyaMKCgpo8eLFBICWL19OdXV1vMTxKG3Jn9DQ0Hb9VXF5/fXXO7yvtuRPd54XZfrSduZR3c0fVpRjmH7gc/qcjMiIcimX1zgePHhAkZGRNHToUDIzM+OlKEdE9C/6FxmSodoO421ubqYpU6aQjY0NJScnq6ydnjy/27dvJwD04YcfKp1lUlxcTNbW1gSAfvjhh3a3KzbMyjY+SUlJZGNjQ19++SV33Z/+9CcSCoW0detWKioqorq6OoqNjSV/f3/S1dWlw4cPt3tsnp6etH79+sc+BrFYTN988w0BoI8//rjTj72nbt26RVZWVjRt2jS1z8YoLi6mMWPGkEgkop9++kktbXb1tWvrSX2N6OGXDbz11lskFApp9erVlJqaSo2NjVRcXEy//vorTZo0iXsTqXjOe7uPEvXemHXlyhUyMjKiefPmUWFhIZWVldErr7xCQqGQTp8+3a5NTe3rj0pPT6fBgweTjY0NnT9/npcYKioqaOTIkWRvb6+Wk/t3pT+kpqYSAJo0aRLdunWLGhoaKCMjgxYsWEAA6M033+ywrc7kSVJSEgGg2bNnP3Y9WVlZ3DfPPm4dfXl8Jnr4RRC2trYUEhLCyzmzkpKSaODAgbyci7QnY9iuXbu4cbYzRTltGdt7ug1T6GqOa3qetHXo0CGysrIiPz8/un37Nm9xaFP+9KQopy35053nRZm+tp1pq6v5w4pyDNPHyUhGbuRGf6W/8h0KLViwgP7+979TS0sLOTs781aUa6ImciM3tc2W27BhA5mYmKh8hlxPnl/Fm8iODgXYu3cvASBra2sqLi7mrq+srCRXV1eKj49vd5+amhpycXGhZcuWtbr+T3/6Ey1durTd8jdv3iQANGDAAKW3CQSCJxafjI2NacqUKR0u09uuX79OxsbG9MEHH6itzeLiYho0aBANGDCA7t69q7Z2u/PaPaozfe3dd98lALRjxw6lt0ulUpo2bVqrN55EvdtHFbH2dMySyWQUEBBAjo6OrWZTSqVS8vX1JVdX13aHgWpyX39UbW0tzZs3jwwNDdsVF1VNJpPR1KlTyc3NjZsVoGpd6Q+pqakkFArbFYGamprI2tqaDAwMOjz8tzN50tOiXH8Zn4mI7t27Ry4uLjR9+nSSyWRqa/f8+fNkZmZGEyZMoIKCArW1q9DdMaygoIAsLS0pKiqq00U5bRnbe7oNU+hOjmt6nrSVl5dHTz/9NFlYWFBsbKza29e2/AkNDe32DiJtyR9FrD19b9QXtzNtdSV/WFGOYfq403SaQKBUSuU7lFYfSPksyhERbaSNZE/21EzNKm0nMTGR9PT0aNu2bSpth6hnz++UKVM6tfysWbMIAD3//PPcdQsXLqQ1a9YoXX7dunUkFAq79GbKyMiIdHR0lB7eNXfuXHJxcelwRpqTk5PSKfiq9sUXX5BQKFTLjJ3GxkYaPXo0DRgwgJc3qo/T0Wun8KS+lpqaSjo6Ok98DS9dutTujSdR7/bR3hizfvvtNwJAf/7zn9vd9v777xMApYddanJff5RMJqOoqCgSiUQqnQnc1vr168nQ0FAt+abQW9uw4cOHE4AOT07emTG5p0W5/jQ+Ez3cHhsZGdHGjRvV0t6NGzdIJBLRvHnzqKmpSS1tttXdPjt9+nRaunQp7dmzp9NFOW0a2x+nM9uwzugoxzU9T9pqbGyk559/nkxNTSkpKUlt7Wpj/vSkKKdN+aPqz3PavJ1pq7P5w4pyDNPH/YH+QE/RU3yH0Q7fRblsyiYBCeg0qXZ2x8iRIyk8PFztJ93v6vM7ceLETi1fWFhIlpaWBIAOHjxIhw8fpoCAAKUzPuRyOdnb2z/2sCllamtrCQANHTpU6e379u0jAHTkyJHHrsPZ2ZmGDRvW6TZ7i0wmo7CwMHrqKdXn2+rVq8nMzIzS0tJU3lZnPem1U3hSX3vjjTcIAG3atKlbcaiqj3Z3zNqwYQMBoF27drW7LTo6mgDQihUr2t2myX29rebmZho3bhz5+/ur5cPT1atXSUdHh3bu3Knyth6nu/2hqqqKTExMaMSIER0u15kxuSdFuf42Pit88803pKOjQzdu3FBpO5WVleTi4kJTp07VmC+Z6Gyf/c9//kPu7u4kFou7VJTT1rFdobPbsCd5Uo5rQ5601dTURBMnTiR3d3e1fNOptuZPT4py2po/vf15ri9sZ9rqTP7ogGGYPu0iLmIyJvMdhsZxhzt84IM4xKmsjZiYGFy/fh2bN2+GQCBQWTvq5OjoiM8//xwAsHLlSrz22mvYtWsXDAwM2i1769YtlJSUYNiwYZ1e/8GDBwEA69atU3r78OHDAQCnT5/uaugqp6Ojg02bNuHy5cuIj49XWTv37t3D559/ji1btsDX11dl7XTVk167zoqNjQUADB06tFv3V3Uf7aq0tDQAgIuLS7vbnJ2dATx8TdvS5L7elp6eHnbv3o3s7Gx89dVXKm9vw4YNCA0Nxcsvv6zytnqLWCxGfHw8Zs2aBQcHB+zevZvXePrb+KywdOlShISEYOPGjSpt5+2334ZcLsfevXshFApV2lZvys/Px5tvvonvvvsOpqamvbpuTR/be7oN62yOa0OetKWvr48ff/wRjY2NWL9+vcrb09b8AYA9e/Zg+PDhMDExgbm5OcaNG4d9+/b1eL2anj+9pS9sZ9rqTP6wohzD9GHlKEcGMvAUnuI7FI00BmNwGZdVtv4DBw5g+PDhCA4OVlkbvaW5uVnphlmZxYsXY/r06SgtLYWPjw+CgoKULnfnzh0AyosRypSUlODtt9/Gyy+/jBdeeEHpMooihmLdyhgYGKClpaVTbfa2kJAQDB48GD/99JPK2vjyyy/h4eGhUQWJzrx2Ck/qa4WFhQAAa2vrbsejqj7aHdXV1QAAExOTdreJRCIAQFVVVbvbNL2vt+Xh4YHly5dj69atkMvlKmsnJycHZ8+exerVq1XWRm/729/+BnNzc4wdOxa6uro4fPgwBg8e3OF9ujImHz16FAKBQOnF09NT6X364/gMAAKBAKtXr8bJkyeRn5+vkjYKCwvx/fff46OPPurROMaHl19+GS+++CLCw8O7fF9tHtu7sg1Tpis5rg15ooytrS0++OADfPvttygpKVFZO9qcP8DD7fl3332H0tJSXLt2DZ6enli4cCFWrVrV4f20Ocu2OK4AACAASURBVH96S1/ZzijzpPxhRTmG6cNykAMCwReaM5tGkwzEQGQjW2Xrj4+Px+TJ2jFLMTc3t0sb3wEDBgB4OBvw6NGjSpcpKioCAJibmz9xfRUVFYiIiEBYWBi++eabxy5nZmYGgUDArVsZJycnFBQUQCqVPrFdVZgyZYpKZ8odO3YMixYtgo6OZmzCO/vaKXS2r/V0dmlv91FVICIAyh+rNvT1tpYsWYK8vDwkJSWprI3z58/DwMAAU6dOVVkbvW39+vVoampCamoq/Pz8MGLECHz00Ucd3qcrY/Ls2bNBD09J0+6SlZWl9D79dXwGgOnTp0NPTw/nz59Xyfp/+eUXGBgYYOHChSpZv6rs3LkT9+/fx6efftqt+2vr2N7VbZgyXclxbckTZV566SXo6OggOjpaZW1oa/4AQFxcHHbv3o3AwECYmJjA19cXu3fvxqhRo/Dll1/i6tWrj72vtuZPb+lr2xllOsofzXhHzzCMSpSjHABgDfXsabpz5067vfSvvfaaWtruDmtYowIVKlt/ZmYm/Pz8VLb+3lBZWYktW7YgJycHr776aqfuc/HiRfz888/47LPPAADLly9XOtOnsbERwMND2zpSV1eHqVOnwt/fH3v37oWurm6HywuFQjQ0NDz29mXLlkEsFuO9995DeXn5kx5Or/Pz80NGRoZK1i2RSJCTk4NRo0apZP1d1ZXXrrN9zcnJCQB69Nr1dh/tCQsLCwAPn6u2FNcplmlL0/t6W4MHD4axsXGHe7B76t69e/Dz84O+vr7K2lAFfX19+Pn54euvv8asWbPw3nvv4ezZs+2W686Y3B39dXwGHs6i8PX1RXp6ukrWf+vWLQQFBXV6pqMmyM3NxerVq/Hdd98pndXbEW0e27vavzvS2RwHtCNPlDEyMkJwcLBKd7xoY/48yZw5cwA83KnaljbnT2/pi9sZZTrKH1aUY5g+rAEPBywjGKmlvcGDB7fbS6+O8wt1lwgi1KH9B+Xe0tDQACMj9Tz33bFkyRJYW1vj7bffxpo1a544tR4AamtrsWTJEuzYsQNvvPEGpk2bhuLiYrz++uvtljU0NASADqeQS6VSzJ07F87Ozti1a1en3hBLpdIOn9dFixbh448/xpYtW2Bra4uIiIgnrrM3GRsbo76+XiXrrq2tBfD/hz3yqSuvXVf62vjx4wEAt2/f7lZcvd1He0pRmFd2qFxBQQEAYODAgUrvq+l9vS2BQACRSASJRKKyNurr67tcNNA0kZGRANBub3l3xuTu6q/js4JIJFJaKO8NYrGYt9m33XXs2DHU1NQgLCys1Y7VqKgoAA/P46i47sGDB9z9tHls707/7qzH5fijbWtDnihjZmYGsVissvVrY/48iaOjIwCgtLS01fXanD+9pS9vZ5R5XP6wohzD9GGWsAQAVKH9XhAGqEAFrGClsvVbWlqiokJ1M/F66vvvv0dNTQ3279+Pzz77DMuWLXvifd58801MmjSJ28Bt374dZmZm2LNnT7s3n4o3ITU1NY9d37Jly9DU1IQDBw60Opmvj48Prly50m55sVgMIuLWrcy6devw7rvv4uuvv0Z1dTVOnTr1xMfVm8rLy2FlpZp+ZW1tDV1dXe7cInzqymvXlb62bNkyCIVCHDp0qMP216xZAx0dHe6LFBR6u4/21IQJEwAACQkJ7W5TXDdx4sR2t2lDX2+roaEBlZWVsLe3V1kb1tbWKj2fkTooZoBUVla2ur47Y3J39dfxWaGkpAQ2NjYqWbeDgwNyc3NVsm5VWblypdLDn/fs2QMA+Oijj7jrfHx8uPtp89je1f7dFY/LcUC78kSZ3NzcDmPvKW3MnydRvGezs7Nrdb02509v6cvbGWUemz+q+upXhmH4l0zJBALdoTt8h9JOb3+Fdnesp/UUQAEqW39YWBj94Q9/UNn6O9LV53fkyJFkaWnZ4TKnTp0iT09PEovFra7fsWMHASAnJyeqqqrirk9KSiIA9Oqrrypd38aNGykkJIQkEkm727y9veny5cvtrr979y4BoBUrVjw2Tj8/P/L09OzwsahSVFQUTZw4UWXrDwkJoZdfflll6++M7rx2Cp3pax999BEBoP/85z9Kb09LSyMzMzOaN29eq+t7u48+qrtjlkwmI39/f3JycqKGhgbueqlUSoMGDSJXV9dW1ytoQ19v68SJEwSA8vPzVdbGsWPHSCAQUElJicra6Iwn9Yc333yTFi5cqPS2RYsWEQD617/+9dj7dyZPFP139uzZj10mKyuLAFBoaKjS+/a38ZmIqKioiAQCAZ04cUIl6z969Cjp6OioNA+6oztj2J49ewgAffTRR09cVpvG9p5swxS6m+PakifK5OTkkEAgoOPHj6usDW3Nn507d1JgYGC76+VyOQUFBREAunLlymPvr03586iefJ7ry9sZZTrKH1aUY5g+rJEayZAMaQ/t4TuUdjShKDedptN8mq+y9X/yySdkZ2dHzc3NKmvjcbr6/E6cOLHD5auqqsjV1ZV+++03pbdPmjSJANCSJUu46+RyOdnZ2bX7MEhE9N///pcAdHhRtjHet28fAaDDhw8/NlZnZ2caNmxYB49WdZqamsja2po2b96ssja2bt1KJiYmVFZWprI2OtLd107hSX1N4e233yY9PT1au3YtpaenU1NTE+Xn59O3335Ljo6ONHbsWKqtreWW7+0+2lZncmrhwoUEgDIzM1tdf/nyZTI0NKT58+dTUVERlZeX07Jly0goFNKpU6eUrkvT+7oyERERNH78eJW2UVtbS2ZmZvTZZ5+ptJ0n6UxRTiAQ0AcffEBZWVnU2NhIWVlZtGbNGgJAQUFBVF9f/9j7dyZPelKU64/js8LmzZvJwsKiw+e/JxobG8nZ2Zlef/11lay/u1RdlNOWsb07/VvZ2N7dHNeWPFFmxYoV5ObmRk1NTSprQ1vzZ+fOnVwh6/79+9TQ0EBpaWlc3/nzn//c4fq1JX/a6u57o76+nVGmo/xhRTmG6eOeoqdoBT1+b4I6HTt27LED786dO9Uai5zkZEVW9AV9obI2cnJySE9Pj3bt2qWyNh7Vk+d30qRJj92oOjs7t1rXox8Aq6qqlLb3+eefExHRu+++S0KhkAoKClqtc8aMGd3aGM+dO5ecnZ07LHQ6OzvT8OHDO3y8qvLdd9+Rvr4+5eXlqawNiURCTk5OtHjxYpW10ZHuvnYKHfW1tq5du0ZRUVHk6upKenp6ZGpqSqNHj6Yvvvii1ZsaVfRRoq7nVHh4OIlEIpJKpe1uS0xMpGnTppGZmRmJRCIKDw+nuLi4xz52Te/rbR09epQA0Llz51Te1htvvEEODg7t9vqrWlf6Q01NDX377bc0depU8vDwIH19fRKJRBQUFER///vfn1gQelKemJiYtIthy5YtrZZpmxcAaN26ddzt/W18Jnr4utjZ2dHq1atV2s7OnTtJV1e3wxxXh+6+L1i2bJnS+0ydOvWx99GWsb07/VvZ2N7dHNeGPFEmJiaGdHR06Pvvv1d5W9qYP42NjXTw4EF69tlnydvbmwwMDMjc3JzCwsJo3759T2xLW/Knq88LkfL86cvbGWWelD+sKMcwfdx6Wk8u5EJSav8hsT+7QBcIBEqmZJW288orr5CjoyOVl5ertJ2emjFjBgkEgl5fb3V1NTk7O9OyZct6vK6bN2+SQCCgH3/8scPl7O3tafTo0T1ur6vKysrI3t6eli9frvK2jhw5QgKBgP773/+qvK3epqq+1l291UerqqrIyMioVw4t1vS+3taDBw/IyspKbYXisrIysrOza3eITl+ijjzpT+Mz0cPZH3PmzCF7e3uqqKhQeVuRkZFkb29PGRkZKm1LU7Cx/cm0IU+UuXfvHtna2tKzzz6rlvZY/vCP5U/v6Uz+sKIcw/RxGZRBAhLQSTrJdygaJYqiaCSNVHk71dXV5ObmRgsWLFB5Wz2h2CteXFzc6+tOTEwka2tr+uqrr7q9joyMDPLy8qJ33323w+Wam5tJT0+P5syZ0+22umvu3Lnk4uLS6rwcqvTOO++Qnp4e/e9//1NLe71FlX2tu3raR+VyOUVFRZG9vT0VFRX1KBZt6OuPysnJIU9PTwoKCqK6ujq1tXv+/HkSCoW8H8aqKurKk/4yPhMRffrppyQUCunChQtqaU8ikVBwcDC5uLjQnTuad27f3sbG9o5pS560devWLXJ0dKTRo0e3OixS1Vj+8I/lT891Nn9YUY5h+oHxNJ6m0BS+w9AYeZRHRmRE22m7Wto7ffo0CQQClZ5nrKcOHz5MAOgvf/mLSmb1ZWVl0YwZM6impqZb91+zZs0T94xVV1fTpk2bCAB9++233Wqnuz7++GPS0dGhs2fPqq1NuVxOK1euJKFQSJs3bya5XK62tntC1X2tu3rSR4uKiig0NLRXPjhoel9/1MWLF8nR0ZGGDRvGyzkOP/30U9LV1aXt29UzlquTOvOkr4/PRETbtm0jXV1dtRdxJRIJTZo0iUxNTftkP30UG9s7pg150tauXbtIJBLR+PHjuz0+9ATLH/6x/Om+ruQPK8oxTD8QQzEEAp2m03yHohGW0BLyIA9qpEa1tblz504SCATtzvmjSTZv3kyDBg0iAwMDioiI4DucLlm8eDHp6emRj48PbdiwQek5vVTliy++IIFAQNu2bVNbm4/avn076enpUWRkpNpm6fWUNvc1vvHZ1x+1fft20tfXp5kzZ/La7zZt2kQCgYDWrl3LWwyq0lfyhO8+q+gjGzduVGu7Ci0tLbRx40bS0dGh559/XuWHzvKpr/RZPvCdJ4+qrq6mBQsWkEAgoFWrVqn0ix2ehOUP0xnanj+sKMcw/UQkRVIABVADNfAdCq8u02XSJV3aS3vV3vY//vEPEggE9P7775NMJlN7+0zvkslk9N5775FAIOBOjMuXmJgYcnBwIC8vLzp69CivsTB9271792j69Omkq6tLn3zyiUbM0FScFPyFF17QqBkGDL/Kyspozpw5JBQK6bvvvuM7HDpz5gw5OTmRk5MT7dixg1paWvgOiWFaaWlpoe3bt5OjoyO5uLjQ+fPn+Q6Jw/KH0XQ9yR9WlGOYfiKXcsmSLOnP1PFXcvdlEpLQABpAU2kqyYmfD5Jff/21RswuYXqmoqKCpk2bRgYGBrRjxw6+wyEiosLCQm7P3LRp0+jevXt8h8T0IbW1tfTOO++QgYEBDRkyhGJjY/kOqZUzZ86Qi4sLOTo6UnR0NN/hMDw7evQo2dvbk5ubm1q+EbizysvLaeXKlaSnp0eDBg2iw4cP8x0Sw5BcLqf//e9/5OfnR/r6+rRq1SqNnJHG8ofRRL2RP6woxzD9gJSkdIgO0SAaRAIS0H7az3dIaicjGT1Hz5EDOVAx8XsS1UuXLpGzszN5enrS6dPskGJtc/LkSfLw8CBXV1e6evUq3+G0ExMTQ0OHDiUDAwNasWJFv/nmMkY1JBIJffbZZ+Ts7EwWFhb0r3/9S2NnKFRVVVFUVBQBoPnz57O+3w/dv3+fXnjhBQJAS5Ysoerqar5DUkoRp0AgoJEjR9IPP/zA6yGCTP/U1NREu3fvpqCgIBIIBLRgwQKtGDdZ/jCaoDfzhxXlGKYPq6RK+pQ+JXdyJx3SoUiKpJfoJTIgAzpL6jshvSZYQSvIkAwpljRjdkdxcTE999xzBIBefPFFjfq2JUa5oqIimjdvHgGgF154gUpLS/kO6bEUU+i9vLxIV1eXFixYQDdv3uQ7LEaLlJeX08aNG8na2ppEIhG98cYbGt3nH/XLL7+Qr68vt8eajy+hYNSrpKSEXnvtNW4GzfHjx/kOqVOuX79Oc+fOJaFQSI6OjvTBBx+w9wOMyhUVFdHGjRvJwcGB9PT0aN68eZSQkMB3WF3G8ofhgyryhxXlGKYPukf3aBWtIhMyIVMypaW0lFIplYgezhhbSAvJlEzpPGnOuSJURU5yepPeJF3SpcOkedPcf/nlF3J3dycLCwv629/+RmKxmO+QmDZqamroww8/JHNzc/L09KQTJ07wHVKntbS00N69e2no0KEkEAgoPDyc9uzZQ/X19XyHxmgguVxOFy9epD/84Q9kYmJC1tbW9P7772vledpaWlrom2++IUdHRzIzM6O//vWvlJWVxXdYTC/LzMykv/zlL2RqaqrV55rKy8ujd955h2xsbMjAwICeffZZOnDgABurmV5TX19PP/30Ez3zzDOkr69Ptra2tG7dOsrPz+c7tB5j+cOomqrzhxXlGKYPSaIkmktzSUAC8iEf2kSbqIran7esmZppPs0nAzKgH6njr5fWZk3URC/SiyQkIQ2mwZRESXyHpFRtbS299957ZGZmRjY2NrRp0yaqra3lO6x+TyKR0Mcff0xWVlZkYWFBH3zwAdXV1fEdVrfI5XI6ceIEPfPMM6Snp0fm5ua0bNkyunLlCt+hMRogPz+fPvnkExowYAABoMDAQPrqq6/6xDhUW1tLn376Kbm6upKuri7NmTOH4uLi+A6L6aGLFy/Sc889R7q6uuTm5kZbtmzR2vH5UQ0NDfT999/T5MmTSVdXl0xNTSkqKoqOHz9Ozc3NfIfHaJnm5maKjo6mRYsWkUgkIl1dXZo6dSrt3r2bGhsb+Q6v17H8YXqTOvOHFeUYpg+IpViaQlMIBAqhEDpGx0hGHX+7p4xk9Ff6KwlIQGtpLTVT39pYZVM2jaExZEZm9A/6Bw2n4aRDOhRFUZRBmnm+DLFYTJs2bSJzc3MyNzenpUuXUkpKCt9h9Tv379+ntWvXcoftrV27liorK/kOq9dUVlbS9u3bafjw4QSA3N3dadWqVXTmzBmtnGHCdE9WVhZt3bqVJk2aREKhkCwsLGjp0qVaeQhTZ8hkMvrll18oNDSUANCgQYNo48aNWnH+JOah/Px82rp1Kzd2BQUF0a5du/rsuFVeXk7bt2+n0NBQEggEZGJiQjNnzqTt27dTXl4e3+ExGqqkpIQOHDhAUVFRZGFhweXK1q1bqaioiO/w1IblD9MdfOWPgIgIDMNopTjEYTM2IxrRCEUo1mItIhHZpXV8h++wCqswBEPwA36AN7xVFK36HMIhLMVSOMEJP+EnBCAABMIhHMJ6rEcWsvAH/AHv4T04w5nvcNupqKjAjh07sH37duTl5WHKlClYtmwZpk2bBgMDA77D65Oamppw4sQJfPPNNzhz5gzc3d2xfPlyvPLKK7CysuI7PJW5ceMG/ve//+HIkSNIS0uDra0tZs2ahcjISISFhcHc3JzvEJleIpVKcf36dZw8eRJHjhxBcnIyrK2tMXPmTDz77LOIiIjoN+PLtWvXsHv3buzfvx9VVVUYP348Fi5ciFmzZsHW1pbv8JhHlJaW4tixY/jhhx8QGxsLKysrzJ8/H4sXL0ZwcDDf4alNVlYWjh07hhMnTiAmJgZNTU0YPnw4pk2bhsmTJ2PUqFEwNjbmO0yGB/X19bh27RrOnDmDkydP4ubNmzA0NMT48eMxffp0REZGwsPDg+8wecXyh3kcTckfVpRjGC10HuexDutwBVcwGZOxHuvxNJ7u9vpSkYoFWIB7uId38A7WYA0MoH0fzrKQhVVYhWhEYymWYiu2wghGrZaRQopd2IUP8SHKUIbX8BrexbuwgAVPUT+eTCZDdHQ0tm3bhrNnz8LMzAzPPfcc5s2bh4kTJ0JXV5fvELWaVCrFuXPnsH//fhw5cgRisRiTJ0/GypUrMWPGDOjo6PAdolqlpaXhyJEjOHz4MG7cuAGBQIDg4GCEh4cjPDwcoaGhMDIyevKKGI0gl8tx+/Zt/Pbbbzh//jxiYmIgkUjg5uaG2bNn45lnnsHTTz8NoVDId6i8aW5uxqlTp7Bnzx5ER0ejubkZISEhmDlzJmbOnImhQ4fyHWK/dOvWLURHRyM6OhrXrl2Dvr4+IiMjERUVhYiICOjp6fEdIq/q6+tx4cIFnDhxAidPnkRmZib09PQQHByMsWPHYty4cRgzZgysra35DpVRgYqKCsTHx+PixYuIj4/HjRs30NLSAm9vb0RERGD69OmYMGEC214/Bsuf/k1T84cV5RhGi6QgBWuwBidwAhGIwPt4HyEI6ZV1t6AFW7EVH+JDOMABG7ERC7AAutD8wk8ZyvBP/BP/wr/gCU/8G/9GGMI6vE8TmvANvsHf8DcQCBuwASuwAvrQV0/QXZSXl4cDBw7gp59+wvXr12FnZ4cZM2YgIiICkydPhqWlJd8haoXKykqcOXMGp06dQnR0NMrLyzFq1CjMnz8fc+fOhYuLC98haoTy8nJcuHAB58+fx/nz55Geng4DAwOMGjUKISEhCAkJwahRo+Dm5sZ3qMzvampqcP36dVy9ehXXrl3DpUuXUF5eDhsbG4SFhSE8PBwTJkyAn58f36FqpLq6Ovz66684fvw4oqOjUVJSAjc3N4SHhyMsLAzjx4/v97NNVCUzMxOxsbHcmJOXlwcHBwfMmDEDM2fOxOTJk2FiYsJ3mBorLy8PsbGxiIuLw8WLF3H37l0AwKBBgxAcHIzAwEAEBgZi+PDhMDU15TlapivEYjFu3ryJxMREJCYmIiEhAampqRAIBPD398e4ceO4QpKrqyvf4Wollj99lzblDyvKMYwWKEQhPsAH+A7fwRe+2IzNmIEZKmkrH/lYj/XYi73whjfextuYj/kwhKFK2uuJPOThS3yJr/E1jGGMd/AOVmIl9ND5vei1qMU/8A98ik9hBzt8iA8RhSgIIFBh5D3z4MEDHDx4EMePH8fVq1dBRBg9ejQiIiIwfvx4BAcHsz2kv6uvr8eNGzcQExODU6dO4erVqxAIBBgzZgymTZuGF154AV5eXnyHqfEKCgpw7tw5xMXF4erVq0hJSYFMJoODgwNGjRqFUaNGYfjw4QgICGCFCzWoqqpCcnIykpOTcf36dVy7dg3p6emQy+VwdXVFSEgIxowZgwkTJmDo0KH9btZnT8nlcty4cQPHjx/HhQsXcO3aNTQ2NsLNzQ3jx4/H2LFjERwcjCFDhvT7WVtd1dzcjOTkZNy4cQNxcXGIiYlBXl4eDA0NERISggkTJmD69OkIDg6GQKC522FNVllZifj4eFy6dAkJCQlITExERUUFdHR04OPjg8DAQIwYMQIBAQHw8/ODh4cHm3nPM5lMhuzsbKSlpSElJQWJiYlISkrC/fv3QUSwsbFBYGAggoKCMGbMGISGhrKdsSrC8kf79IX8YUU5htFgdajDV/gKH+NjWMAC67Eef8Kf1DJ77QEe4GN8jH3YBxFEeAkv4WW8jAAEqLztjrSgBadxGjuwAydwArawxVt4CyuwAsbo/vkg8pGPj/ARvsW3GImR+Af+gbEY24uRq0ZVVRXOnj2LU6dO4fTp0ygoKICenl6rDU9QUBDc3d35DlUtsrOzcePGDcTHx+Py5ctITExES0sLXF1dMXXqVERERGDSpEnsXGk9VFdXh4SEBFy9ehVXr17F9evXkZubCwAwMzODv78/hgwZgsGDB2Pw4MEYMGAAXFxc2IfsLqqsrERGRgbu3LmDlJQUJCcnIyUlBQUFBQAACwsLBAYGtpq96OjoyHPUfU9jYyOuXr2KmJgYxMTE4OrVq6irq4O+vj6GDh2KoKAgBAUFYcSIEfDz84NIJOI7ZI0gkUiQnp7OzVBISEhAcnIympubIRKJEBISgqeffhphYWEICQnpN+c05ENubi43WyQxMRG3bt1Cfn4+AMDAwAB+fn7w9fWFn58fBg0ahIEDB8LDw6NPn1OVDxUVFcjOzsb9+/dx9+5dpKWlIT09Henp6WhqagIAuLi4YPjw4dwMrcDAQN5n8fR3LH80Q1/OH1aUYxgNtQd78BbeQgta8C7exWt4jZfZaiUowXf4DjuxE1nIgi98MQdz8AyewQiMUEuBUAIJfsNv+Bk/4xiOoQpVCEc4lmEZZmN2rx5yeh3X8RbewkVcxHzMx6f4FC7QnkMas7OzuYJUXFwc7ty5A5lMBgsLCwwbNgxDhw7lfvv4+GjcnqLOqqysxIMHD3D79m3cunULt2/fxu3bt1FdXQ1dXV0MGTIEY8eOxVNPPYWxY8eywyzVoLq6GikpKbhz5w5XPEpOTkZFRQWAh29cvby84OPjA29vb+63m5sbXFxcYGZmxvMjUL+mpiYUFhYiPz8fDx48QEZGBnd58OABqqqqAACGhobw9/fH4MGDERAQgCFDhiAgIID1a57IZDKkp6dzhaaEhATcvHkTtbW1AAA3Nzfuw9mgQYPg6+sLLy8vODk59blz+EmlUhQWFiIzMxNpaWlITU1Famoq0tPTuUK9qakphg8fzhUvAwMD4evry2aX8EwsFnOvWVpaGvd3ZmYmWlpaADzcyeLh4QEPDw94enpyf7u5ucHBwQH29vbsdfydVCpFaWkpiouLkZubi+zsbGRlZbX6LZFIAAB6enrw9vbmxodHx4r+uC3URix/eld/zx9WlGMYDfMAD7ACK3Ae5/EqXsUH+ABW4H9Py2Vcxvjff+7jPnKQA3OYY+zvP4EIxGAMhhOcetSOFFLcx33cwR1cwRVcxEUkIQlyyPEUnsJzv/94wKN3HthjHMERvIW3UIISrMd6vIE3NPZ8cx2RSCS4desWV7i6efMm7ty5g/r6egCAlZVVqwKJp6cnHBwc4OzsDHt7e9jZ2an90De5XM5tmAsKClBSUoKsrCyuaPFoscLExASDBw/GsGHDuMvQoUPZeT80SElJCe7fv9+q4KS4lJeXc8sZGxvD1dUVjo6OcHFxgaOjI5ydnWFjYwNra2tYWVlxf2vyTMeGhgZUVFSgsrISFRUVqKioQFlZGUpKSpCfn4+ioiLk5eWhuLgYZWVl3P2MjIzg7e3NXRQ56e3tzQ6P0QIymQyZmZnc3vu0tDTcvXsX6enpqKmpAQAIhUI4OzvDzc2N+2Dm4uICBwcH2NrawsbGBg4ODhrTv6urq1FSS0pEMgAAIABJREFUUoKysjKUl5ejqKgI+fn53Aem3NxcFBYWQiqVAgDMzc3h5+cHf3//VkVJLy8vdgi1FmlpaeE+BLe9ZGVlobi4mFtWR0cHdnZ2sLOzg7OzM+zs7ODk5AQHBwdYWVnBysoKlpaWrS76+trxXqq5uRlVVVWoqqpCZWUl93dFRQVKSkpQWFiI0tJSFBQUoLS0FCUlJXj0Y7WjoyNXhFFWmGGHvvdNLH8eYvnTNawoxzAaQgop/o1/Yx3WwQte2IEdGI3RfIcF4OFsuWAEwx/+OIET0IUu7uAOYhCDWMQiDnEoRCEAwApWGIiBcIADXOEKO9jBHOYwgAGMYQwDGEACCaSQQgIJxBAjD3koQQlykYt7uIdmNEMIIQZhEMZjPJ7+/cce9mp93M1oxtf4GuuxHg5wwBf4AtMxXa0xqIJMJkNWVla7WTkZGRnIzs5GXV0dt6xQKISdnR3s7e1hbm4Oc3NzmJmZcRdzc3MIBAJYWPz/t9caGxtzhyE1NTVxBUAAXDGtpqYGYrEYYrGY+7u6uprbMMtkMu4+IpEIHh4erQoWiqKFp6cn+7CnxWpqapCXl9eqWFVUVISCggIUFhaisLAQ5eXl3F5nBaFQyBXqjI2NYWlpCUNDQxgZGcHCwgIGBgYwMTGBmZkZV8xqOytUsbyCVCrl9sIq1NXVobm5mYu1qakJtbW1kEgkaGxshEQiQV1dHerr67kCXENDQ7vHaW1tDXt7ezg7O8PJyYkrOrq6usLBwQEuLi5wcurZDg1GcxUVFSErKwu5ubnIzc1FTk4OV9gqKCjgxkUFfX192NrawtbWFqampjAxMYGpqSnMzc0hEom4/wG06uNt/5fJZBCLxdxtj/ZxiUSC2tpa1NXVoaamhuvLEokEZWVlKCsr4/q+gqWlJVxcXODu7g53d3e4ublxvxU7dJi+r7GxEbm5uSgpKUFRURGKi4tRXFyMoqIi7kN2SUkJKisr2/Uh4OE2XVFgMDQ0hJmZGTcem5qaQk9PjxvHjY0fnpZET0+v3WHhyq6rra1tt7149DrFmF5dXY2WlhZIJBI0NDSgsbGRG+MVRYRH3wsp6Ovrw9raul0Rxd7eHg4ODnB0dIS9vT3c3NxgaKh552Jm+Mfyh+WPMqwoxzAaIBGJeAWvIBWpWIM1eBfvasysrBa0YBImoQhFuIZrsICF0uUqUIFkJCMFKXiAByhGMQpQgBKUQAwxmtCEOtShGc0QQQQBBJBBBi94wRnOcIADXOACP/ghAAHwhz8MoBnnlylAAd7BO9iDPZiJmdy3vPZVdXV1yM/PR0lJCffmoLS0FNXV1a2KaIoPcm2LGYrrgPYbfcUHRsUHTEVhT3Gxs7NrNVPP2dmZfeseA4lEgoqKCpSXl7ebhdbQ0ICqqio0NjaioaEB1dXVaGxsRH19PWpqaiCXy59YcAPQrrgMtC7cmZqawtDQEKamphCJRNwbYMXfiiLho78Vf7PCMdOR5uZmbjaaYgal4n9F8ay2thbV1dVcIU1xqGzbgl7b/9sWoxX/i0QirsBnYWHRqvinmLVna2vbahaftszQYDRHXV0dN0NG2ayZpqYm1NTUcOO3RPJ/7N15XJV1/v7x12GRTRDEDYXkAK4opeC+omSaRVqpWU6T5Ta22J7Wt2XqazXVz5qmxqU0NUepMfdcMtdw30AlcwEXZDNBRBHZf38YfEXAFA7cLNfTBw/z3Pe5P9ehmsbLz32/L5GVlVXkNaDwN/7XK+m1G/+w5cbXHBwcsLe3p169etSpUwdnZ+cir9nZ2eHm5lbiDiU3Nzf9/xGpVPr3p/ZQKSdioHTSeY3XmM50QghhOtPxoWpNgpzIRL7lW3ay06JDHraylT70IZ54PKgeDyb/mZ95lmc5zWkmM5nXeK3KFIciIiIiIiJSveiPbkUMsotddKADYYQxn/msY12VK+TmM58ZzGAOcyw+dbVgp9lJTlr0uhUphBAOcpB3eZeP+ZgOdCCccKNjiYiIiIiISDWkUk6kkuWQwzu8Q0964oMPhzjEYzxmdKxi9rOfCUzgDd5gGMMsfv1mNMMOu2pVygHYYsvLvMxRjtKa1vSmN4/zOCmkGB1NREREREREqhGVciKVKJ54+tGPj/iIT/mUNaypkrduJpHEAzxAL3rxDu9UyBpWWOGFV7Ur5Qo0pSlLWMJ3fMc61uGPP4tZbHQsERERERERqSZUyolUks1sJpBAkkhiJzt5hmcwYTI6VjHZZDOCETjgwHd8hzXWf/6mMvLBp9qWcgWGMYyjHCWUUIYznPu5n7OcNTqWiIiIiIiIVHEq5UQqWD75vM/7hBBCH/qwl70EEGB0rFJNYhL72McSlpQ6adVSzJirfSkH4IorM5nJT/zEEY7QnvbMZa7RsURERERERKQKUyknUoEyyOBRHuVt3mYa0wgjDGecjY5Vqm/5tnCwQzvaVfh6NaWUK1AwCOJJnuQpnmIoQznHOaNjiYiIiIiISBWkUk6kgsQRR2968xM/sYY1PMdzRke6qf3sZzzjK2ywQ0nMmIkllmyyK2W9yuCII/+P/8cv/MJhDtOOdixlqdGxREREREREpIpRKSdSAX7lV7rRjXTS2clOQggxOtJNVcZgh5KYMZNLLrHEVtqalaU73dnHPoYylAd5kOEM5wIXjI4lIiIiIiIiVYRKOREL281u+tCHpjRlK1tpQQujI91UZQ52uJEZM0CNuoX1ei64MJOZrGY14YRzF3exiU1GxxIREREREZEqQKWciAWtYQ3BBNOd7mxiEw1oYHSkP/U8z1faYIcbNaABLrjU2FKuwCAGEUEEHehACCG8yqs16pZdERERERERuX0q5UQsZCUrGcpQRjCCH/gBBxyMjvSnvuVbpjOd2cyulMEOJfHGu8aXcgCNaMQylvEVX/ElX9KHPpzhjNGxRERERERExCAq5UQsYDWrGcYwRjGKr/kaG2yMjvSnDnCA8YzndV5nOMMNy1HTJrD+mSd5kn3s4zKXCSCAH/jB6EgiIiIiIiJiAJVyIuW0ilUMZSh/5a98xVdYVYN/rZJIIpRQetGLv/N3Q7OYMRNDjKEZKltrWrOLXYxgBMMYxiQmkUWW0bFERERERESkElX99kCkCtvGNoYznL/wF2YwAxMmoyP9qYLBDrbYspCFlTrYoSS1badcAQccmMlM5jKX2cymJz1r5fdBRERERESktlIpJ1JGv/IroYTSn/7VppADeIEX2Mc+VrACd9yNjoMZM+c4x2UuGx3FEI/zOLvZTTrpdKITq1ltdCQRERERERGpBCrlRMoggQQGMpA2tOF7vq8Wz5CDa4Md/s2/DR3scCMzZgBOc9rgJMZpS1t2s5v7uI/7uZ9/8A+jI4mIiIiIiEgFUykncpsyyeQhHsIBB1ayslpMWYWqM9jhRmbMmDDV+ls3nXBiLnOZznTe5E1GMpIMMoyOJSIiIiIiIhVEpZzIbXqWZznMYZawBDfcjI5zSwoGO/Skp+GDHW7khBMNaVjrhj2UZhzj+JEfWcc6etCDWGKNjiQiIiIiIiIVQKWcyG2YznRmM5v/8B/88Tc6zi25frDDIhYZPtihJLV12ENp7uZudrObq1ylK13ZzW6jI4mIiIiIiIiFqZQTuUWHOcyLvMibvMn93G90nFtW1QY7lESlXHF++LGLXQQSSB/6MJ/5RkcSERERERERC1IpJ3ILMslkFKMIJJA3edPoOLesKg52KIlKuZI548xSlvI3/sYTPMGbvEk++UbHEhEREREREQuoHiMjRQz2Gq9xkpNEEFElb/8sScFghylMqVKDHUqiUq501lgzjWn4488EJpBIIjOYUW3+ORQREREREZGSqZQT+RM72cm/+Bff8A1mzEbHuSVJJPEAD9CTnrzLu0bH+VM++HCJSySTXGVvsTXaUzxFYxozghGc4xxhhFWbyb8iIiIiIiJSnG5fFbmJXHKZyET60Y/HebzM14mIiGDw4MG4urri7OxMSEgI27Zts2DS/1Mw2MEa63INdli9ejUtW7bExqbiu/uCsrO8E1gvXLjAjBkz6NevH/Xr18fBwYEWLVrw2GOPERkZaYmohrqP+9jIRraxjUEM4iIXjY4kIiIiIiIiZaRSTuQmvuRLoojiX/yrzNfYtWsX3bt3x9nZmSNHjnDy5El8fHzo27cvP/30kwXTXvMiL7KPfaxkZZl2nUVHRxMaGsqUKVNISkqyeL6S3MEd2GBT7ltYX3nlFZ599lkeeOABfv31V5KTk5kzZw4REREEBgaybNkyCyU2The6sIUtnOAEPelJPPFGRxIREREREZEyMOXn5+up4SIlOM95/PBjIhN5n/fLdI28vDwCAgJISUkhOjoaB4drtxvm5ubi7+/PlStXOH78OHZ2dhbJ/C3f8lf+ShhhZX6O3KOPPkpAQAAvv/wy3t7eJCYmkpOTY5F8N+ONN3/jb7zGa2W+xpgxY7C2tmbmzJlFXo+MjOSuu+6iRYsWHDt2rLxRq4RTnOIe7iGbbH7iJ/zwMzqSiIiIiIiI3AbtlBMpxTSmUYc6vM7rZb7G1q1biYqK4uGHHy4s5ACsra0ZOXIksbGxrFq1yhJxCwc7TGZyuQY7zJ49m8mTJ1fKbavXs8Swh6+//rpYIQdw55134uDgQHR0NDXlzyG88WYrW3HFld705jCHjY4kIiIiIiIit0GlnEgJUkjhC77gJV6iLnXLfJ2NGzcCEBQUVOxYwWsbNmwo8/ULnONc4WCH93ivXNe6vjysTD74VNgE1vT0dDIyMmjXrh0mk6lC1jBCYxqziU20oAX96c8RjhgdSURERERERG6RSjmREhTskpvIxGLHfvvtN4YMGUK9evVwdHSkc+fOrFq1ipCQEEwmEyaTiTFjxhSeC+Dp6VnsOs2aNQMo9+2UOeTcdLDD7eQ1Umk75SyR/7///S8Ab7zxRoVkN1I96rGGNbSmNcEE8xu/GR1JREREREREbkHl3p8mUg1c4Qpf8iUv8zLOOBc5duLECbp164aTkxOLFy+mW7dunD59mueff56DBw9iZ2fH1atXC89PTU0FwMnJqdg6dete24F34cKFcuV9gRfYy162s73YYIfbzWskM2ZOc5pccguLRUvkT0pKYvLkyYwZM4bhw8t+W29V5ogjK1nJ3X/82MrWwom2IiIiIiIiUjVpp5zIDRaxiCtcYSxjix17/fXXSU1N5Z///Cd33303devWxd/fn4ULF5Kenn5b6xQ826w8t1MuYAFf8iWzmU172ldo3opmxkwWWUWmiZY3f3JyMgMHDqRv377MmDGjIuMbzgUX1rGOxjSmL305zWmjI4mIiIiIiMhNqJQTucFMZjKMYTSiUbFja9euBeCee+4p8nrDhg1p3bp1sfNdXV0BSiyQCl4rOOd23cpgh9vNa6SCnV3X38Janvzp6encc889tG3blv/85z9YW1vf9PyawBVX1rIWF1y4m7uLFJwiIiIiIiJStaiUE7nOPvaxhz2MZ3yxY5mZmVy6dAl7e/vCW0+v5+bmVuy1guLo7NmzxY7FxcUB0LJly9vOmUwyD/EQPehR6mCHsuQ1UhOa4IhjYSlXnvw5OTkMGzaMZs2aMW/evFpRyBVoQAM2sAFbbOlHPxJJNDqSiIiIiIiIlEClnMh1FrCAVrSiF72KHbOzs8PZ2ZmrV69y+fLlYsfPnTtX7LXg4GAA9u3bV+xYwWv9+/e/rYw55PAwD5NPPgtZWGywQ3nyGsmEieY0LyzlypN//PjxZGZm8v3332Nj83+PzvTz82Pnzp2WD1/FNKIRP/ETOeRwL/dyiUtGRxIREREREZEbqJQT+UM++SxhCSMYUeo5gwYNAv7vtsoCiYmJJU5R7dOnD23btmXx4sVFBhLk5uYSFhaGl5cXgwcPvq2cL/Iie9nLClbQgAY3Pfd28xrtxgmsZcn/zjvvEBUVxfLly7Gzs6u4sFVcM5qxnvUkkMBwhpNDjtGRRERERERE5Doq5UT+sJOdnOEMD/FQqee8//771K9fn+eff57169dz+fJlDh8+zOjRo2nSpEmx862srJg9ezYpKSmMHj2axMREkpOTefrppzl+/DhfffUV9vb2t5xxAQv4gi9KHexQ3rxGu7GUu938c+fO5e9//zu7du3C2dkZk8lU5Cs6OroyP47hzJhZxSrCCWcCE4yOIyIiIiIiItdRKSfyhx/4gRa0IICAUs/x9fVlx44ddOrUiYcffpjGjRszfvx4pkyZgp+fX4nv6dq1K9u3b+fixYu0atUKb29vjh8/zubNm4sNMLiZCCIYz3he47VSBztYIu+qVasKS6y4uDhyc3MLf/3111/fct6yMGMmhpgy51+8eHGF5quOAgkkjDDmMY+pTDU6joiIiIiIiPzBlJ+fn290CJGqoC1tGcxgPubjMr0/JCSE8PDwIrepWkoyyXSiE374sYY1pT5H7nZUZN6yWsISHuZhrnAFe26+g7Aq5q/KpjOdp3maH/iBoQw1Oo6IiIiIiEitp51yIkAccRzhCHdzt9FRirnVwQ41gRkz+eRzhjNGR6lx/sbfmMAEHudxDnHI6DgiIiIiIiK1nko5EWA967HHnp70NDpKMS/yInvYc0uDHao7H3wAijxXTiznn/yTIIIIJZTznDc6joiIiIiISK2mUk4E2MAGutMdRxxv+71hYWGYTCY2bNhAZmYmJpOJMWPGWCTX7Q52uBUVmbe86lEPN9xuWspV5fxVnS22fM/35JPPKEaRR57RkURERERERGotPVNOBPDDj7/wF97mbaOjFIoggh704Dme4wM+MDpOpQkkkBBC+Af/MDpKjbWXvfSkJ2/xFq/zutFxREREREREaiXtlJNaL5lkYoihC12MjlIomWQe5EG6053/5X+NjlOpbpzAKpYXRBD/4B+8xVtsZKPRcURERERERGollXJS6+1iF3CtqKgKrh/ssIhFNXqwQ0nMmPVMuUrwHM8RSih/4S/8zu9GxxEREREREal1VMpJrbeXvZgxV5khCi/xErvYxQ/8UGUyVSaVcpXDhIk5zMEWW8Yz3ug4IiIiIiIitY5KOan1DnKQu7jL6BjAtcEO/+JffMM3dKSj0XEMYcZMCilc5KLRUWo8V1xZwAKWs5x5zDM6joiIiIiISK2iUk5qvSMcoQ1tjI5BBBGMZzyv8iojGGF0HMP44APAKU4ZG6SW6ElPJv3x4zSnjY4jIiIiIiJSa6iUk1othxyiiTa8lLt+sMNUphqaxWjNaY4VVhr2UImmMpWmNOUpniIfDeQWERERERGpDCrlpFaLJppMMg0t5XLIYRjDau1ghxvZY08Tmui5cpXIAQe+4Rs2sYlv+dboOCIiIiIiIrWCSjmp1aKJBsAPP8MyvMzL7GRnrR3sUBINe6h8XejCBCbwIi9ynvNGxxEREREREanxVMpJrRZLLK644oKLIev/h//wOZ/X6sEOJVEpZ4wP+AB77JnMZKOjiIiIiIiI1Hgq5aRWiyUWL7wMWTuCCMYxrtYPdiiJSjljuODCNKYxhznsZKfRcURERERERGo0U35+vp7qLbXCv/k3z/M8dtjhhBM22JBFFrnk0p72uOKKHXa44sogBjGEIeVe8wQnWM96/sbfiryeTDKd6IQvvqxlba1/jtyNvuEbnuZp0knHhMnoOLVOCCGkk852tuv7LyIiIiIiUkFUykmtEUsszWl+S9Mld7ObTnQq95rv8i5v8zajGc10pmOHHTnkMIABnOQke9ij58iVYAtb6EtfEkigCU2MjlPrRBBBIIEsYhHDGW50HBERERERkRpJt69KreGFF+1od9NzTJhoQxuLFHIA85lf+HMPehBHnAY73AIzZgDdwmqQu7iLUYxiMpO5ylWj44iIiIiIiNRIKuWkVnmQB7HFttTjVljxDM9YZK197Cuc7ppLLgc5iD/+LGABc5ijwQ430Yxm1KGOSjkDTWUqiSQyi1lGRxEREREREamRVMpJrRJKKNlkl3rcGmse5VGLrLWIRdShTuGvs8nmMpe5wAVOc9oia9RU1ljjhZdKOQN54sk4xvEhH5JBhtFxREREREREahyVclKrdKQjTWla4jFbbBnJSFxxLfc6eeSxgAVkkVXk9VxyySOPKUxhFKNUdtyEJrAa7zVeI5VU5jDH6CgiIiIiIiI1jko5qXWGMrTIDrYC2WQzjnEWWWMLW0giqdTj+eQTRhi96U088RZZs6bxwUelnME88OApnuIf/INMMo2OIyIiIiIiUqOolJNa537uL7aDzYQJX3zpRjeLrLGQhTd9dl3BmrHEcpjDFlmzptFOuarhNV4jiSQWscjoKCIiIiIiIjWKSjmpdYIJxhHHIq9ZY80zPIMJU7mvn0UW3/Fdqc+us8EGEyZGM5pjHGMAA8q9Zk1kxkwssTd9BqBUPE88eZiH+ZzPjY4iIiIiIiJSo6iUk1qnDnUYxCBssCl8zYSJUYyyyPVXs5rLXC7xmBVWtKQlO9jBLGbhgotF1qyJzJjJIYeznDU6Sq33Ii9ygAP8wi9GRxEREREREakxVMpJrTSEIeSRB1wb8PAQD9GABha59gIWFCn8Ctaww473eZ9IIulCF4usVZOZMQPoFtYqIJBAutBFu+VEREREREQsSKWc1Er3cm/hrarZZDOe8Ra57iUusZKVhbdcWv3xr1h/+nOUo7zGa8UKOylZQxrijLNKuSriGZ5hOcs5xzmjo4iIiIiIiNQIKuWkVqpPfbrSFQBvvOlDH4tcdylLySEHuPbsOHfc+YEfWMMamtPcImvUJt54q5SrIh7kQeyxJ4wwo6OIiIiIiIjUCNqyIzVObm4uaWlppKenk5GRQVpaGgAXL14kLy+v8Lz2d7RnW8tt9DjYg8VHFxe+XrduXWxti05OdXZ2xsbGBgcHB+zt7XFzc8Pe3h4HB4ci581nPnnkFQ5y+IRP9Ny4ctAE1qrDEUce4iG+5Vue4zmj44iIiIiIiFR7pvz8/HyjQ4iU5MqVK8TGxpKYmMj58+c5f/48ycnJpKSkFPs5PT2dS5cucfnyZbKzb3Fapy/wK+AF5bkjr6Cgs29uz6nwU9SNrUuPOT1oebEl9evXx93dnfr161O/fn2aNWuGh4cHDRpY5vl1Nd3zPM9udrOd7UZHEWAjG+lPfw5xiHa0MzqOiIiIiIhItaadcmKI3Nxczpw5Q0xMDNHR0Zw9e5YzZ86QkJBAXFwccXFxpKamFnmPm5sb7u7uhSWXu7s73t7euLu74+TkhLOzM3Xr1sXe3h4XFxccHR2xt7fH1dUVACcnJ+rUqVPkmp/afMq7Se8Wee3GHXUAFy5cAK4VhVevXiU1NZWMjAyuXr3KhQsXyMzMZLPvZjw2etDi+xak/p7K/uT9RcrDnJycwuvZ29vTrFkzmjZtiqenJx4eHnh5eeHj44OPjw++vr7FduHVRmbMul2yCulLXzzx5L/8V6WciIiIiIhIOWmnnFSo+Ph4Dh8+TFRUFCdOnCA6OpqYmBhOnTpVuKOtXr16eHl54eXlhYeHB56enjRt2pRmzZoVFlYNGjTA2tra4vlyyLHY4IVssrHFttTjFy9eJD4+nvj4+MLiMSEhgTNnzpCYmFhYShZo2rQpvr6++Pr64uPjQ5s2bWjfvj1+fn4V8r2oilawgiEM4TKXccTR6DgCTGQiO9nJfvYbHUVERERERKRaUyknFpGRkcGBAwc4dOgQhw4dIioqioMHD5KSkgJAo0aNaNmyZWHJdP2XbuX8PxkZGURHR5f4dfLkSXJzc7G3t6dt27a0a9cOf39/AgIC6NixI40aNTI6vsUd4hABBBBFFG1pa3QcAdawhsEM5gxn8MTT6DgiIiIiIiLVlko5KZOYmBjCw8PZt28f+/btY+/evWRmZuLs7EzLli1p27Yt/v7+tG3blqCgIDw8PIyOXO1lZWVx/Phxfv31V6Kioti3bx+//vorJ0+eJD8/Hw8PDwIDAwkMDKRnz550794dR8fqvbvsMpdxxplVrGIwg42OI0AmmTSkIR/xEROYYHQcERERERGRakulnPypvLw8IiMj2bBhAxs3bmTbtm2kpaXh4OBAhw4d6Ny5c+GXj48PJpPJ6Mi1SnJyMnv27GH37t2FX7///js2NjZ06NCBfv360a9fP3r27FktS7pGNOIt3uIZnjE6ivxhKEPJI4/lLDc6ioiIiIiISLWlUk5KdOrUKdasWcOGDRvYvHkzycnJNGzYkODgYPr06UPXrl1p3749tralP0NNjBMTE8Pu3bsJDw9n48aNHDlyhDp16tC1a1f69evHgAED6NKlC1ZWVkZH/VNd6EJPevL/+H9GR5E/fMZnvMd7/M7vWFH1/xkSERERERGpilTKSaGoqChWrVrFypUr2b59O46OjnTr1o2QkBBCQkLo0KFDtShxpLikpCS2bt3Kzz//zPr16zl58iQNGjRg0KBBDBs2jAEDBmBnZ2d0zBI9wiNkkslSlhodRf6wl710opOe9SciIiIiIlIOKuVquUOHDjF37lyWLl3KyZMn8fT0JDQ0lCFDhtC3b1/thKuhoqKiWLZsGcuWLWPfvn04OzszaNAgRo0axaBBg6rUdNcpTGENa4ggwugo8occcnDDjWlMYyxjjY4jIiIiIiJSLamUq4VSU1NZtGgR33zzDXv27MHX15cRI0YwZMgQgoKC9Ey4WiY2NpYVK1awePFitmzZQpMmTXj88ccZPXo0rVq1Mjoes5jFy7xMGmlGR5HrhBCCF158wzdGRxEREREREamWVMrVIocPH+aTTz7hu+++w8rKiocffpgnn3yS3r17q4gT4Nqz6ObOncvcuXOJjY2lV69evPjii4SGhhp26/J61jOAASSTTH3qG5JBinuFV9jIRvaxz+goIiIiIiIi1ZIeEFYLbN++ndDQUAICAti7dy+ff/45CQkJzJs3jz59+qiQk0I+Pj68++67nDp1inXr1uHu7s5DDz0Rd7G5AAAgAElEQVRE+/btmTdvHtnZ2ZWfCR8ATnKy0teW0rWlLUc4Qi65RkcRERERERGpllTK1WAHDhwgODiYHj16kJyczLJlyzh06BBjx47FxcXF6HhShVlZWTFgwACWLl3KoUOH6NSpE2PHjsXPz49vv/2Wytxgewd3YI01McRU2pry5/zxJ4MMTnHK6CgiIiIiIiLVkkq5GiglJYWnn36aTp06kZ2dzZYtW9i2bRuhoaHaFSe3rW3btsydO5cTJ05w7733Mnr0aHr16sWBAwcqZX1bbGlGM+2Uq2La0hYTJqKIMjqKiIiIiIhItaRSrob57rvvaNWqFUuWLGHOnDn88ssv9O7d2+hYUgPccccdTJ8+nT179gDQqVMnJk2aRGZmZoWvbcasUq6KqUtdPPAgmmijo4iIiIiIiFRLKuVqiOzsbCZNmsTIkSMZMWIER48e5fHHH6/wnXEREREMHjwYV1dXnJ2dCQkJYdu2bX/6vtzcXKZMmUKLFi2wt7dn0KBBpZ67Z88ennjiCcxmMw4ODtSvX5927drx0EMPMX36dKKjr5UC7dq1w2QyFfl65JFHCq8TEhJS5FhQUFCxtU6fPk1oaChpaUUnfZb1c5Zk9erVtGzZEhsbm1LPmTx5Mt99912px0ePHo2dnR1ms5lJkyZx9erVMmUpiw4dOvDLL78wZ84c5s6dS69evThz5kyFrqlSrmpqSlMSSDA6hoiIiIiISLWkUq4GSEpKom/fvsyZM4ewsDC++OKLSnlm3K5du+jevTvOzs4cOXKEkydP4uPjQ9++ffnpp59u+t7Zs2fz4Ycf8vjjj5OYmMiaNWuKnZOXl8crr7xC9+7dadSoEWvWrCE1NZUjR47w6aefkpaWxsSJE/Hz8yMnJ4fDhw+TmJiIu7s7AAsWLCAsLKzwej///DM//vgjLVq0ID09nb179xZZLyIigqCgIAYMGFDk+1eez3m96OhoQkNDmTJlCklJSTc9d+zYsUyZMoU333yzxOPffPMN58+fZ/LkyXz++edMmzbtlnNYgslk4vHHH2fPnj1kZGQQGBjIpk2bKmw9lXJVU1OaEk+80TFERERERESqJVN+ZT6xXSwuKSmJ4OBgcnJyWL58OW3atKmUdfPy8ggICCAlJYXo6GgcHByAazvg/P39uXLlCsePH8fOzq7E9z/66KMsWrSItLQ0nJ2dSzznjTfe4P3332fWrFmMHTu22PHc3Fzuv/9+1qxZQ3Z2duHOs4ULF/LYY4/h7u5OVFQUjRs3BuDChQvceeedhIWF0b179yLXSktLw9/fn8GDBzNjxgyLfc4bP3NAQAAvv/wy3t7eJCYmkpOTU+r5kZGRdOjQgbCwMIYPH17qeU5OTvTs2ZN169b9aYaKkJ6ezlNPPcXy5ctZvnw5AwYMsPgaC1jAGMZwhStY6c8Sqoy/8TeOcpSNbDQ6ioiIiIiISLWj391WY5mZmQwZMoScnBw2b95caYUcwNatW4mKiuLhhx8uLKoArK2tGTlyJLGxsaxatarU9ycnJ2NtbV1qIffbb7/x4YcfEhgYWGIhV7BWSTvJHn30UUJDQ0lOTubpp58ufP3ZZ59l5MiRxQo5gI8++ojExETeeusti37O682ePZvJkyff9LbV69155508/PDDvPTSSzct71xdXUlOTr6la1YEJycnFi5cyLBhw3jooYc4fPiwxdcwYyaTTO3KqmKa0IQkbr7rU0REREREREqmUq4ae/PNN/n1119ZuXIlTZs2rdS1N268tjOmpOeyFby2YcOGUt+fm5t70+vPmjWLvLw8hg0bdtPzunXrRn5+frGia8aMGbi5ufHDDz+wePFili1bRkREBO+++26xa+Tn5/P111/TpUuXYt/H8n7O611f6t2qoUOHcvbsWX788cdSzzGZTDct7SqDlZUVs2fPpkOHDowYMYKsrCyLXt+MGUC3sFYxjjhyhStGxxAREREREamWVMpVU8eOHePTTz/l448/plWrVpW+/m+//QaAp6dnsWPNmjUDrmUsq61btwIQEBBQpvd7eHjw6aefAvD000/zzDPPMG/evBJvM42MjCQpKYk777yz2LGK/px/5q677gIw7NbU22Fra8v8+fM5deoUX3zxhUWv7YEH9tirlKtiHHAggwyjY4iIiIiIiFRLKuWqqX/96194e3szZswYQ9ZPTU0Frt26eKO6desC157hVpqsrKybPoctPv7abYoFQxvK4q9//Sv33nsv586dw8/Pj8DAwBLPK7jdsqTirbyfs7wKir+b3RJqZ2dHdnZ2hWW4Hd7e3kyYMIHPPvuMvLw8i13XhInmNFcpV8WolBMRERERESk7lXLV1MqVKxk1ahRWVlXvb2HB7BCTyVTqOWfOnCmxBLvRza5xK1q0aAHAli1bWL58eYnnJCQkAFCvXr3buvatfM7ycnFxwWQyFWYsSdOmTYmLizP8FtYCTzzxBLGxsRw4cMCi1/XBR6VcFaNSTkREREREpOyqXqMjf+rSpUucPn2azp07G5bB1dUVuDZ580YFrxWcc72UlBQ+/vhjTp8+zcSJE0u9fsGz3c6fP1/mjL/88gtLlixh2rRpAEyYMKHEXW1Xr14Frt1+eaOyfk5LsrGxISOj9OJj/PjxpKWl8dZbb5Xr+2Up7dq1w9HR0eIDH8yYVcpVMTbYkE3V2KUpIiIiIiJS3aiUq4YuX74M/N/tk0Zo3bo1AGfPni12LC4uDoCWLVsWef2JJ57A3d2dyZMn8+qrr/Lcc8+Vev0+ffoAcPDgwTLlu3z5Mk888QSzZs3ihRdeYNCgQSQmJjJp0qRi59rb2wOUeAtoWT6npeXk5Nx0SMSoUaOYOnUqH3/8MQ0bNmTgwIEVmufPmEwm6taty6VLlyx6XZVyIiIiIiIiUpOolKuG3N3dsba2LnzumhGCg4MB2LdvX7FjBa/179+/yOtz587l4sWLhIWFMW3aNMaPH1/q9cePH4+NjQ2LFy++aY5XX30VKyurwoEMBV566SVCQkIKC6qZM2fi4uLCt99+y6pVq4qc6+HhAcDFixct8jktKS0tjfz8/MKMJXnjjTd4/fXXmT59Oqmpqaxdu7bC8tyKjIwMUlJSaNy4sUWva8ZMHHFkkmnR64qIiIiIiIgYQaVcNVSnTh2CgoL4+eefDcvQp08f2rZty+LFiwtv/wTIzc0lLCwMLy8vBg8eXOx9Li4uDBs2jA4dOty0cGvZsiVvv/02e/fuZc6cOSWec/ToUWbOnMnw4cMLd7TBtUml69ev55NPPil8zcvLq/DX48ePLxzgANdut4SSd8OV9XNaSsFuvIKMJVmyZAlms5kxY8bc9nPxKsLmzZvJycmhe/fuFr2uGTN55HGGMxa9roiIiIiIiIgRVMpVUyNHjmTRokWGPUPMysqK2bNnk5KSwujRo0lMTCQ5OZmnn36a48eP89VXXxXeFloSFxcX0tLSbrrG//zP/zB58mQmTJjA5MmTOXbsGFlZWcTFxTF79myCg4MJCAhg9uzZhe9JTU1l7NixzJkzB2dn5yLXGzt2LCEhIcTHx/PCCy8Uvn7nnXfSqFEjIiMjLfI5R40ahclk4uTJ8t9qGRERAcCAAQNKPefSpUu4uLiUey1L+fzzz+nTp0/h5FhLMWMG0C2sIiIiIiIiUiOolKumnnrqKerVq8fLL79sWIauXbuyfft2Ll68SKtWrfD29ub48eNs3ryZe+6556bvvdWJpR988AHbtm0jPj6ekJAQ6tatS5s2bfj666+ZPHkyGzZswMnJCQBPT0/c3NyIjY0lODiYIUOGFF4nNTUVk8lUuLtw7ty5mEwmPvvsM0wmE2PGjGHXrl0l3hJ8u58zISGBunXrcscddxR5fdWqVZhMJkwmE3FxceTm5hb++uuvvy7x8y9dupRmzZr96W68ipwAeztWrFjB2rVreeuttyx+bTfccMVVpZyIiIiIiIjUCKb8/Px8o0NI2SxfvpyhQ4cyZ84cnnjiCaPj3Jb77ruP1atXk5eXZ3QU4Nrz5Pz9/bnvvvuYMWNGma+TmppK06ZNeeyxx/jqq6/KlSkyMpIOHTqwcOFCHnnkkVLPa9KkCWazmR07dpRrvfKKjo6mc+fO3H///cydO7dC1uhIRwYwgA/5sEKuL7fne75nBCPIR/8ZERERERERuV3aKVeNPfDAA0yePJlx48axZMkSo+PcFk9PT/Lz80lKSjI6CgD16tVj5cqVLF68mC+//LJM18jPz+e5557DxcWF9957r1x5YmJiePDBB5kyZcpNC7ns7GxSUlLw9PQs13rldebMGe6++27MZjP//ve/K2wdTWAVERERERGRmkKlXDU3depUxo0bx4gRI/joo4+oLhsfC6aifvjhhyQnJxuc5poOHTqwd+9e1qxZ86fPuytJUlISMTExbNiwgSZNmpQry8yZM5k6dSpTp04t9ZyLFy8ybdo0srOzC7+fRggPD6dr1664uLiwdu1aHB0dK2wtM2ZiiKmw64uIiIiIiIhUFt2+WkPMmjWLZ555hoEDBzJ//nxcXV2NjvSnPvroI+bOnUtMTAzBwcGsWbPG6EjVxhNPPMHChQtp3rw5I0eO5O2338ba2rrSc8yaNYtnn32WAQMG8O2331b4P3df8iVv8zbnMWbAiRSl21dFRERERETKTqVcDbJ161ZGjBiBo6Mjn376KaGhoUZHkhrq+PHjPP/886xbt4733nuPyZMnV8qwidWsZjCDuchFXKg6E2drK5VyIiIiIiIiZafbV2uQ3r17s3//frp06cKQIUO49957OX78uNGxpAZJT0/n9ddfp3379sTGxrJp0yamTJlSadNfzZgBOMWpSllPREREREREpKKolKthPDw8WLhwIZs3byYuLo727dszceJEYmL0HC4pu8uXL/Ppp5/SqlUrpk+fzscff8z+/fvp1atXpeYwY8aEScMeREREREREpNpTKVdD9e7dm3379vH555+zbt06WrZsyaOPPkpkZKTR0aQaSU5O5p133sHb25u33nqL4cOHc+zYMZ599llsbGwqPY899jShiYY9iIiIiIiISLWnUq4Gs7GxYdy4cRw9epT58+cTFRVFhw4d6N+/PwsWLCAjI8PoiFIF5efnEx4ezpNPPknz5s354osvePbZZzl16hTTpk2jYcOGhuYzY9ZOOREREREREan2VMrVAjY2Njz66KNERETw448/4uLiwpNPPomHhwcTJkxg165dRkeUKiAuLo4PPviAVq1a0atXLyIjI/nHP/7B6dOnefvtt3F3dzc6IqBSTkRERERERGqGyr//TAxjMpkYNGgQgwYN4sKFC/z3v/9l+vTpzJw5k+bNm/PAAw9w//3307dvX0NuTZTKd+rUKZYvX86qVavYvHkzdevWZfjw4YSFhdGxY0ej45XIjJmlLDU6hoiIiIiIiEi5mPLz8/ONDiHG2rt3Lz/88APLli3jt99+o2HDhoSGhhYWdPXq1TM6olhITk4Oe/bsYc2aNSxbtoxDhw7h7u7Offfdx9ChQxk4cCB2dnZGx7ypOczhWZ7lMpcxUTlTX6Vk3/M9IxhBPvrPiIiIiIiIyO1SKSdF/PbbbyxbtoylS5eyd+9eTCYTQUFB9OvXj379+tGjRw8cHByMjim3KC8vj4MHD7Jp0yY2btzIli1buHTpEnfccQcPPPAAQ4YMoXfv3tVqZ+RmNhNMMEkk0YhGRsep1VTKiYiIiIiIlJ1KOSnV+fPn2bx5Mxs3bmTjxo0cPXoUOzs7OnfuTJcuXejSpQudO3fmjjvuMDqq/OHixYvs2bOHXbt2sXv3brZv38758+dp0KABffv2pV+/fgQHB9O6dWujo5bZaU7jjTc72EFXuhodp1ZTKSciIiIiIlJ2KuXklsXFxbFhwwbCw8PZtWsXUVFR5Obm0qRJEzp37kznzp2566678Pf3x9vb2+i4Nd6FCxc4dOgQhw4dYs+ePezevZujR4+Sl5eHl5cXXbp0oXv37gQHBxMQEICVVc2Y65JLLg44MI95jGSk0XFqNZVyIiIiIiIiZadSTsosPT2dffv2sWvXLnbt2sWePXs4c+YMAC4uLrRt25b27dvTrl072rVrR4sWLfD09MRk0nPAbkdKSgrR0dEcPnyYqKgoDh06RFRUFHFxcQC4urrSsWPHIrsXPTw8DE5dsXzx5Sme4nVeNzpKraZSTkREREREpOyqz4OkpMpxcnKid+/e9O7du/C11NRUoqKiOHz4cGF5tGTJEpKTkwGws7PDx8cHPz8/fH19C3++44478PT0xMXFxaiPY5jMzEzi4+M5e/YsJ06cIDo6uvDrxIkTXLhwAQB7e3vatm1Lu3bt6N+/P+3bt8ff379W3j5sxsxJThodQ0RERERERKTMtFNOKkVSUhLHjx8vUjgVfJ0/f77wPHt7ezw8PGjevDmenp54eHjQrFkzGjRogLu7O/Xr1y/866o8FTYjI4Pk5GRSUlJITk4mOTmZ33//naSkJM6ePUtCQgKxsbEkJiby+++/F77PwcEBX1/fwq+C0tLX1xdvb2+sra0N/FRVx1jGcpKT/MzPRkep1bRTTkREREREpOy0U04qRePGjWncuDE9e/YsduzixYvExsayZcsWXnvtNVxdXWndujVxcXEcOXKE+Ph4zp8/T3Z2dpH32djYFBZ1jo6OuLm5YW9vj4ODA66urtjZ2eHk5ISLi0thmeXm5lbkGgXnF8jJyeHSpUtFzklPTycrK6swa2ZmJpcvX+bSpUtcvXqVS5cukZ6ezpUrVwoLuIyMjGKf093dncaNG9OsWTOaNm1Khw4d8PDwwMvLiyZNmuDp6UnTpk3L9g2uZcyY2chGo2OIiIiIiIiIlJlKOTFcvXr1OH36NO+88w7du3dnxYoV2NvbFzvv0qVLJCcnc/78+WK70DIyMrhw4QJXr14lIyODU6dOcfXqVa5cucLFixfJy8srLNwyMzOxsrLC1ta2SOEGYDKZcHV1LbLu9cWds7Mz9vb2ODs7U7duXRwcHGjYsGHhXxeUhNf/XPDXNWXQQlXggw9nOEMOOdjof8ZERERERESkGtLvZsVwR48e5Z577qFNmzYsXbq0xEIOrhVizs7O5Z7s6uXlxcSJE5kyZUq5riPGMWMmhxzOchZvvI2OIyIiIiIiInLbtHVHDHXs2DGCg4Px9fVl9erVODk5Veh6sbGxnD17lq5du1boOlKxzJgBNOxBREREREREqi2VcmKY48ePExwcjLe3N2vWrKFu3boVvubOnTuxtramU6dOFb6WVJxGNKIudVXKiYiIiIiISLWlUk4MER8fT0hICF5eXqxduxZnZ+dKWXfnzp20b9++UgpAqVjNaa5STkRERERERKotlXJS6S5fvsx9991HnTp1WLlyJS4uLpW29o4dO+jWrVulrScVxwcflXIiIiIiIiJSbamUk0qVm5vLY489RmxsLGvWrKFhw4aVtnZWVhYHDhzQ8+RqCDNmlXIiIiIiIiJSbamUk0r1wgsvsGHDBlavXo2fn1+lrn3gwAGuXr2qUq6GMGMmhhijY4iIiIiIiIiUiY3RAaT2WLBgAV988QVhYWGGDFrYsWMH7u7utGjRotLXFsszYyaJJK5wBUccjY4jIiIiIiIicltUykmliIiIYPz48bz66qsMHz7ckAw7d+6ka9eumEwmQ9YXyzJjJp98TnMaDzw4ed2PCUzACSejI4qIiIiIiIiUSqWcVLjU1FSGDh1K9+7dmTp1qmE5du7cyZgxYwxbX8rnN34jhpjC4u0oR3HCiSCCuMKVwvPccOMlXjIwqYiIiIiIiMifUyknFW7cuHFkZWWxcOFCrK2tDcmQkJDA6dOnNXm1GpvCFJaxDFtsMWEim2zyyS9yjgkTnelsUEIRERERERGRW6dBD1KhZs+ezQ8//MC8efMqddLqjXbs2IGVlZUhz7ITy3ibtwvLuCyyihVyALbY0g0VryIiIiIiIlL1qZSTCnP8+HEmTZrEK6+8QkhIiKFZdu7cib+/Py4uLobmkLK7i7u4n/uxxbbUc7LIogtdKjGViIiIiIiISNmolJMKkZ+fz7hx42jRogXvvfee0XHYuXOnbl2tAaYylRxySj1uwkQntBtSREREREREqj6VclIhZs+ezS+//MJXX32FrW3pO5sqQ3Z2Nvv27aNr166G5pDya0c7QgktdbecF164417JqURERERERERun0o5sbjExEReffVVJk2aRFBQkNFxiIyM5MqVKyrlaojSdstZY00PehiQSEREREREROT2qZQTi5syZQouLi68++67RkcB4JdffqFBgwa0bt3a6ChiAf74M4QhxXbLWWGlyasiIiIiIiJSbaiUE4uKjIxk/vz5fPjhhzg5ORkdB4Bt27bRo0cPTCaT0VHEQt7jvWK75bLJViknIiIiIiIi1YZKObGoV155haCgIEaMGGF0lELbt2+nZ8+eRscQC/LHn6EMLbJbzhprOtDBwFQiIiIiIiIit87G6ABSc6xbt47169ezdevWKrMr7dixYyQkJKiUq4He5V2WsrTw121ogwMOBiYSERERERERuXXaKScW88EHHzBw4EB69epldJRC4eHhODg40LFjR6OjiIX548+DPIjtHz96ouJVREREREREqg/tlBOL2L17N1u2bGHTpk1GRykiPDycLl26UKdOHaOjSAV4h3dYwhLyyacTnYyOIyIiIiIiInLLVMqJRXzwwQd06tSJvn37Gh2liPDwcB555BGjY4gFZGVlcfHiRdLS0khNTSUrK4v09HR6BfRia6OtpG9K57/n/1t4vpOTU5Ey1s3NDVtbW1xcXKhXrx5ubm5GfAwRERERERERQKWcWMCpU6dYsWIF33//vdFRikhKSuL48eP06NHD6ChSitzcXM6cOUNMTAzx8fEkJiYSHx9PUlIScXFxnDt3jgsXLnDx4kWuXr1a8kX8gW3w3N3PQe7trV9Q0Lm6uuLp6UmjRo1o1qwZTZo0wcPDA09PT3x9fWnYsGG5P6uIiIiIiIjI9VTKSbl98803NGzYkNDQUKOjFPHLL79gbW1N165djY5S6124cIHIyEgOHTrEsWPHiI6O5sSJE5w6dYrs7GwA7O3tady4MU2bNqVx48a0b9+exo0b4+bmhouLS2GB5uLigpubG9bW1ri4uADwje03TLw8EXt7+8I109LSyM291tLl5uaSlpZGVlYWaWlpXLx4kdTU1MKddykpKYUlYEREBElJSZw7d468vDwA6tWrh6+vL76+vvj5+dG6dWsCAgJo27atbo0WERERERGRMlEpJ+WSl5fH3LlzGT16NLa2tkbHKWLbtm0EBARQr149o6PUKufOnWP79u3s3r2bgwcPcvDgQWJjYwGoX78+rVq1ws/Pj65du+Ln54efnx8+Pj40aNCgzGu+yIvFXiso7Arc7vVzcnKIi4vjxIkThSXiiRMn+PHHH5k2bRqZmZnY2toWFnR33nkn3bp1IygoqEg5KCIiIiIiIlISU35+fr7RIaT6Wrt2Lffeey9Hjx6lRYsWRscpIigoiB49evDPf/7T6Cg12rFjx9i6dSvh4eFs376d48ePY2VlRZs2bQrLqoCAAAICAmjWrJnRcS0iJyeHo0ePcvDgQSIjIzl48CAREREkJCRQp04dgoKC6N69Oz179qRPnz64uroaHblCfM/3jGAE+eg/IyIiIiIiIrdLpZyUy1NPPUVUVBQ7d+40OkoRly9fxs3Njf/85z8MHz7c6Dg1ypUrV9i+fTs///wzK1as4MiRIzg6OtKhQwd69uxJjx496NGjB/Xr1zc6aqWLj49n27ZthIeHs23bNg4cOIDJZOKuu+4iJCSE++67j+7du2NlZWV0VItQKSciIiIiIlJ2KuWkzHJzc/Hw8ODll1/m1VdfNTpOEevXr2fAgAHExcXRtGlTo+NUe2lpaSxbtoywsDA2btxIVlYWHTt2ZODAgQwcOJCuXbtiY6O74W904cIFfv75Z9auXcvatWuJj4+nUaNGPPjggzzyyCP06tWrWhd0KuVERERERETKTr+LljLbvHkzv//+O0OGDDE6SjHh4eH4+vqqkCuHrKwsVqxYwaJFi1i9ejV5eXkMHDiQWbNmcc8999C4cWOjI1Z5bm5uDBs2jGHDhpGfn8/Bgwf58ccf+e6775gxYwbNmjVj2LBhjBo1isDAQKPjioiIiIiISCXSTjkpsxdffJGffvqJw4cPGx2lmP79++Pl5cXcuXONjlLtJCQkMH/+fL744gvi4+Pp1q0bw4YN49FHH6Vhw4ZGx6sxjhw5wnfffUdYWBhHjx4lMDCQcePGMWrUKBwdHY2Od0u0U05ERERERKTsqu99U2K4n3/+mXvuucfoGMVkZ2eza9cuevbsaXSUamXPnj08+OCDeHl58dlnn/HXv/6VU6dOER4ezqRJk1TIWVibNm145513+O2339iyZQt+fn4888wzNG/enDfeeIPz588bHVFEREREREQqkEo5KZNz585x+PBh+vfvb3SUYvbv3096erpKuVu0f/9+QkND6dy5MwkJCSxYsIDTp0/zv//7v3h5eRkdr1bo3bs3YWFhnDlzhueee46vv/4aHx8f/ud//oeUlBSj44mIiIiIiEgFUCknZbJhwwZsbGzo3bu30VGKCQ8Pp2HDhrRq1croKFVabGwsw4YNIygoiISEBH788Ud27NjBI488Qp06dYyOVys1adKEN998k5iYGN544w1mzpyJj48PH330EdnZ2UbHExEREREREQtSKSdlsn37djp27EjdunWNjlLMxo0b6dOnDyaTyegoVVJubi6fffYZ/v7+REZGsmzZMnbv3s29995rdDT5g5OTE6+99hoxMTG88MILvPPOOwQGBrJjxw6jo4mIiIiIiIiFqJSTMtm9ezedO3c2OkYxOTk5hIeHExwcbHSUKikmJoauXbsyefJkXtDyFikAACAASURBVHjhBQ4ePEhoaKgKzCrK2dmZt99+m0OHDuHh4UHPnj15/vnntWtORERERESkBlApJ7ctKyuLyMhIOnXqZHSUYvbs2UNaWhr9+vUzOkqVs2bNGoKCgsjLyyMiIoK///3v2NvbGx1LboGvry/r1q1j3rx5zJkzh+DgYBISEoyOJSIiIiIiIuWgUk5u2+HDh8nMzCQwMNDoKMVs3LgRDw8PWrdubXSUKuWTTz7hvvvuIzQ0lPDwcH1/qqlRo0axc+dOzp8/T2BgIPv37zc6koiIiIiIiJSRSjm5bVFRUdjZ2dGyZUuLXnf16tW0bNkSGxubMl9j06ZNFt0lFxERweDBg3F1dcXZ2ZmQkBC2bdtmsetXhk8++YRXX32VadOmMXfuXBwcHCx27QsXLjBjxgz69etH/fr1cXBwoEWLFjz22GNERkb+6ftzc3OZMmUKLVq0wN7enkGDBhUea9euHSaTqcjXI488Ung8JCSkyLGgoKBi1z99+jShoaGkpaWVKe/kyf+fvfuOiupM2AD+DKD0LtKjVBUQJPaCgiJKNEiKLTGurhhcjVE3ZdFsoskeTXEPRreoRI1uskoMKip2BazEFkGcAUVQURCUoQwgIGW+PzzMJ0vRgZm5lOd3Dsc49859n2FNOD77lgj88ssvzeafO3cudHV14eTkhCVLlqCysvKFn7mtPDw8cOnSJfTv3x9BQUG4fv262sckIiIiIiIi1WMpR0pLS0trc3n2vMzMTISEhGD58uXIz89v9XOePn2KpKQkle0nd/HiRYwYMQLGxsZIS0vDnTt34OzsDH9/fxw/flwlY6jbv//9b3z66af4/vvvsWTJEpU//5NPPsHixYsxZcoUSCQSSKVSbNu2DcnJyRg4cCBiY2NbfP/WrVvxzTffYPbs2cjLy8ORI0cU127cuIG8vDxYWloCAH7++WdER0crrp88eRKHDh2Cm5sbysvLceXKlQbPTk5OxqBBgxAUFAQTE5NW5Z0/fz6WL1+Ozz//vMn8P/74IwoKChAREYENGzYgMjLy5b95bWBiYoLY2Fj4+Phg/PjxuHnzpkbGJSIiIiIiItURyeVyudAhqGN544030L179xZnECnjnXfegbe3Nz7++GP07t0beXl5qKmpUfo5iYmJCAgIQFZWFpycnNqUqa6uDt7e3igsLERmZqZidlltbS08PT3x5MkTZGRkQFdXt03jqNPvv/+OYcOGYdWqVVixYoVaxggLC4O2tjY2b97c4PWUlBQMGDAAbm5uuHXrVrPvf+edd7Br1y7IZDIYGxs3ec/OnTvx7rvvwtLSEmKxGNbW1gCezXrz8fFBdHQ0RowY0eA9MpkMnp6emDRpEjZt2tSmvCkpKfD19UV0dDSmTZvW7GcxNDTEqFGjcOzYsWbvUbXy8nKMHTsWNTU1+O2339CtWzeNjQ0Au7Eb0zEdcvDHCBERERERkbI4U46UduvWLfTp00dlz9u6dSsiIiLaPPMuISEBvXr1anMhBwBnzpyBWCzG22+/3WC5p7a2NmbOnIn79+8jLi6uzeOoS1VVFebMmQM/Pz8sX75cbeNs2bKlUcEFAD4+PtDX10dmZiZa6v2lUim0tbWbLeSAZ8VdSEgIpFIpFi1apHh98eLFmDlzZqNCDgC+++475OXl4YsvvmhzXh8fH7z99tv46KOPWiyLzczMIJVKm72uDoaGhoiOjsatW7ewevVqjY5NREREREREbcNSjpSWnZ2N3r17q+x5qtrjLCEhAePGjVPJs+Lj4wGgyX3K6l87deqUSsZShw0bNuDOnTvYunUrRCKRxscvLy9HRUWFYl+45tTW1r7U8zZt2gRzc3Ps2bMHMTExiI2NRXJyMr766qtG98rlcmzZsgVDhw6FnZ2dSvK+8cYbePDgAQ4dOtTsM0QiUatmeLaVk5MTvv76a6xZswZ37tzR+PhERERERETUOizlSCmFhYUoKyuDo6Njs/ekp6cjNDQUpqamMDAwwJAhQxAXF9dgY/6wsDCV5nry5AkuXbrU4n5yyuRKT08HADg4ODR6jr29PQC0uCxTSLW1tVi3bh0WLVqk0vJUGb/++isA4LPPPlPJ82xtbbFu3ToAwKJFi/DBBx9gx44dTS4fTklJQX5+Pnx8fFSWd8CAAQCg0aWpyliwYAEcHBywfv16oaMQERERERHRS1LNTv3UZWRnZwMAXnnllSav3759G8OHD4ehoSFiYmIwfPhw3Lt3D0uXLsX169ehq6urlhMqz549i6qqqmZLOWVzFRcXA3i2PPB/GRkZAXi2p1l7dPbsWTx8+BDz5s0TZPz8/HxEREQgLCysxT3YgGeHc7zsvnx/+MMfsHv3bhw+fBhjxozBwIEDm7zvxo0bAJouVFubt76IrX92U3R1dVFdXf1SY6qajo4O5syZg02bNmHdunWCzI4kIiIiIiIi5XCmHCml/nRUGxubJq+vWLECxcXFWL9+PcaPHw8jIyN4enpi586dKC8vV1uuhIQE9O3bV1GeqDNX/Z5j7bX4OHfuHJycnODm5qbxsaVSKSZOnAh/f/8GByw0Jzs7+6XLMwCKz3T69Gns37+/yXsePnwIADA1NVVZXhMTE4hEIsWzm2JnZ4ecnBxBlrACQFBQEB4+fIisrCxBxiciIiIiIiLlsJQjpchkMohEomY35j969CgAYMKECQ1et7KyQt++fdWWKyEhocWlq8rmMjMzA4AmC7v61+rvaW+ysrJUehDHyyovL8eECRPg4eGB//73v9DW1m723sLCQqxduxb37t3DwoULX+r5Z8+exd69exEZGQng2ZLNpmYr1s94fNFJpMrkBZ7NRquoqGj2enh4OGQyGb744gsUFBS86OOoXP2f48zMTI2PTURERERERMpjKUdKkclkMDIygpZW4z86VVVVKC0thZ6enmKJ5/PMzc3VkqmkpARXr15ttpRrTa76guPBgweNruXk5AAA3N3d2xJbbSoqKlR2eMbLqqmpwdSpU2Fvb48dO3a0WHDNmTMHlpaWiIiIwKeffooPP/zwhc8vKyvDnDlzEBUVhWXLliE4OBh5eXlYsmRJo3v19PQAoMWlpMrkff49LX1fZ82ahdWrV2Pt2rWwsrLCxIkTX/hMVTIwMADwbH9FIiIiIiIiav9YypFSZDIZTExMmrymq6sLY2NjVFZWoqysrNH1R48eqSXTmTNnUFdXB39/f5Xlqi/4rl692uha/WuqOulV1czNzSGVSjU6Znh4OKqqqrB7927o6Pz/VpWurq747bffGty7fft2lJSUIDo6GpGRkQgPD3/h8z/66CMEBgYqiq7NmzfDxMQEP/30E+Li4hrca2trC+BZWauKvMCzP/dyuVzx7KZ89tlnWLFiBTZu3Iji4mLF7ExNqZ+dZ2FhodFxiYiIiIiIqHVYypFSWirlACA4OBgAGhUSeXl5ajutNCEhAf3794eVlZXKco0ZMwYeHh6IiYlpcABEbW0toqOj4ejoiEmTJqnoE6iWl5cXrl+/rrG9zVatWgWxWIz9+/e/9KENJiYmmDp1Knx9fRETE9PivceOHcOJEyfw97//XfGao6Oj4vfh4eGKgzmAZ58faHqWY2vz1s+OrH92U/bu3QsnJyeEhYW91H52qnb16lWIRKIWMxIREREREVH7wVKOlFJaWtpiKbdmzRpYWFhg6dKlOHHiBMrKynDjxg3MnTu32cMh2io+Ph5jx45t8R5lc2lpaWHr1q0oLCzE3LlzkZeXB6lUikWLFiEjIwM//PCDYplkezN+/HgUFxcjMTFR7WNt374dX375JS5evAhjY2OIRKIGXy/a38zExAQymazZ68XFxZg/fz62bdvWaB/D+fPnIzAwELm5uVi2bJnidR8fH/Ts2RMpKSkqy5ucnAzg2WEKzXnRvxvqFhsbi0GDBnGmHBERERERUQfBUo6U8qKZci4uLkhKSsLgwYPx9ttvw9raGuHh4Vi+fDlcXV2bfE9cXJyiFMnJyUFtba3i91u2bGkxj1QqRWpqaouHPLQ217Bhw3DhwgWUlJSgT58+6N27NzIyMpCYmNjowIj2xM3NDSNHjsT69evVPtaLZrm9SEsn2Do4OMDc3Bz3799HQEAAQkNDFdeKi4shEolw8uRJAM/KNpFIhO+//x4ikQhhYWG4ePEicnNzVZJ33759sLe3f+HsSKFO5H306BGio6Pxhz/8QZDxiYiIiIiISHkiuVwuFzoEdRwzZ85EVVUV9u7dq/R7AwMDce7cuQbLQdsqJiYGM2bMQEFBQatPQ1VHLqEdP34cEydORGxsLEJCQoSO06zJkyfj8OHDqKurU+lzS0pK4OnpicmTJ2PTpk1telZKSgp8fX2xc+dOzJgxo9n7bGxs4OTkhKSkpDaN1xozZ87E+fPnkZ6erjjwQRN2YzemYzrk4I8RIiIiIiIiZXGmHCmlrq7upU6q1JRjx45hyJAhrS7kOqugoCDMnTsXYWFhajtgQxUcHBwgl8uRn5+v0ueampri4MGDiImJwb/+9a9WPycrKwtvvvkmli9f3mIhV11djcLCQjg4OLR6rNbat28ffvnlF0RFRWm0kCMiIiIiIqK2YSlHStHR0dHYAQIv4/jx4+16KamQIiMjYWBggKlTp+LJkydCx2lS/Wmq33zzjcpPjPX19cWVK1dw5MiRFveta8nmzZuxevVqrF69utl7SkpKEBkZierqasXn0ZQrV65g7ty5WLBggcbHJiIiIiIiorZhKUdKaU0pFx0dDZFIhFOnTqGqqkqx51dbpaWlITs7u9WlnLpytRempqY4duwYbt68iSlTprTL5bmhoaH49ttvcezYMdjb2ytOyVWV3r17Iy4urtUHMHz77bctzpCbM2cOrKyssGXLFnz++eeYM2dOK5MqLzU1FRMnTsTQoUOxbt06jY1LREREREREqsE95Ugp8+bNw8OHD3H48GGho+D777/Hl19+iYKCgna1pLa9SU5OxtixY+Hj44Pdu3fDyspK6EjURvHx8Zg+fTp8fHxw8OBB6OvrC5KDe8oRERERERG1HmfKkVLa0/LV48ePIzAwkIXcCwwYMAAJCQnIzs7GwIEDcenSJaEjUSvJ5XKsXbsWEyZMwLhx47B//37BCjkiIiIiIiJqG5ZypJT2UspVVVXhzJkz3E/uJfn4+ODy5cvw8vLC6NGjsWbNGlRXVwsdi5SQnZ2NkJAQrFixAt999x2io6NhaGgodCwiIiIiIiJqJZZypJT2UsqdPXsW5eXlCAoKEjpKh2FhYYG4uDh89dVXWL16NXx9fXHu3DmhY9EL1NTUIDIyEp6enrh9+zYSEhKwbNkyoWMRERERERFRG7GUI6Xo6uq2iwMDjh07hn79+uGVV14ROkqHoqWlhU8//RSpqalwdHTE6NGj8c477+DmzZtCR6P/IZfLsW/fPrz66qv47LPP8PHHHyM5ORmjRo0SOhoRERERERGpAEs5UoqFhQWkUqnQMXD8+HHOkmsDZ2dnHDlyBL/++itSUlLg6emJ2bNn4/bt20JH6/LkcjkOHDiAgQMH4u2330bfvn2RkpKClStXQldXV+h4REREREREpCIs5UgpPXr0ELyUe/DgAVJTUzFx4kRBc3QGb731FlJTU7Fr1y5cvnwZffr0wfjx43Hw4EHwYGbNKi0tRVRUFHx8fBAaGgp7e3tcvnwZu3fvhru7u9DxiIiIiIiISMVYypFSLC0tUVJSgqdPnwqW4dChQzAwMIC/v79gGToTLS0tTJ06FTdu3EB0dDSqq6sREhKCvn37Yt26dcjPzxc6Yqf2+++/Y9GiRbC3t8eyZcswdOhQJCcn4+DBg3j11VeFjkdERERERERqwlKOlNKjRw8AEHS23KFDhxAYGAg9PT3BMnRG2tramDp1KhITE5Gamopx48Zh5cqVsLe3R1BQELZt24aioiKhY3YKEokEK1euRJ8+fTBw4ECcOHECX375JXJycvDDDz/A29tb6IhERERERESkZizlSCmWlpYAhCvlqqqqkJCQgEmTJgkyflfh5eWFf//738jLy8POnTthZGSERYsWwcbGBsHBwdiwYQMyMjKEjtlhVFdX4/Tp01i+fDm8vb3h6emJrVu34rXXXsNvv/2GmzdvYtmyZTAzMxM6KhEREREREWmISM6No0gJjx49grW1NRISEgRZPnr06FG89tpryM7OhoODg8bH78pkMhliY2Nx8OBBnDx5EsXFxXBxccHEiRMxbtw4jBgxAtbW1kLHbBfq6uqQlpaGc+fO4fjx4zh58iRkMhnc3NwQHByMN998E35+ftDS6tj/v8hu7MZ0TIcc/DFCRERERESkLB2hA1DHYmFhAZFIhIKCAkHGP3ToEHx8fFjICcDExASzZ8/G7NmzUVNTg6SkJBw9ehRHjx7Fpk2bUFtbCzc3NwwfPhwjR47E0KFD4eHhgW7dugkdXe2Ki4tx7do1XLhwARcuXEBSUhKKiopgZGSEMWPGYM2aNZg4cSJcXFyEjkpERERERETtBEs5UoqOjg6sra1x//59QcY/cuQIZsyYIcjY9P90dHTg5+cHPz8/rF69GjKZDElJSbhw4QLOnz+Pjz76CGVlZejevTs8PDzg7e0Nb29v+Pj4wN3dHY6OjhCJREJ/DKVVVVUhMzMTEokEKSkpuH79OlJSUnDv3j0AgKOjI0aOHIkvv/wSI0eOhLe3N3R0+J9ZIiIiIiIiaox/WySlOTk54c6dOxofVyKRIDMzk/vJtUMmJiaYMGECJkyYAACoqalBenq6orhKTk7GsWPHFCe56urqwtnZGa6urnB1dYWTkxMcHR3Rs2dP2Nvbw8bGBrq6uhr/HCUlJcjNzUV+fj5ycnLw4MED3L59G5mZmcjMzMSDBw9QV1cHbW1tuLq6wsfHB+Hh4fD29saAAQNgb2+v8cxERERERETUMbGUI6UJVcodOnQIFhYWGDJkiMbHJuXo6OjAy8sLXl5eePfddxWvP3r0CLdu3VKUXJmZmbhw4QJ27typKOzqWVpawsbGBmZmZjAxMYGJiQlMTU1hZmYGU1NTaGtrw8jISLE8VkdHB8bGxgAAuVyO4uJixbPKy8vx9OlTVFRUoKSkBDKZDDKZDMXFxSgpKYFUKsXDhw9RUVGheE/37t1hZ2cHFxcXuLm5KZafuri4wN3dHQYGBur8FhIREREREVEnx1KOlObk5ITY2FiNjxsXF4fXXnsN2traGh+bVKNnz57o2bMnRo0a1eja06dP8ejRI+Tk5ChmquXl5aGkpERRpGVmZiqKtLq6OhQVFaGsrAwGBgaorq7GkydPFM8zMzNTLJHV09ODvr4+9PT0FOWeiYkJnJ2dYWpqCnNzc9jZ2cHGxgZ2dnawtrZGz549NfZ9ISIiIiIioq6HpRwpzcnJCXfv3oVcLtfYvmD5+fk4f/48li1bppHxSPO6d+8OBwcHpQ7xiIuLQ0hICO7duwdTU1M1piMiIiIiIiJSLS2hA1DH4+TkhPLycjx+/FhjY+7duxe6uroICgrS2JjU/onFYjg6OrKQIyIiIiIiog6HpRwpzcnJCQA0uq/cnj17MGnSJO7jRQ1IJBJ4eHgIHYOIiIiIiIhIaSzlSGmOjo7Q09NDenq6RsaTSqU4ffo03nrrLY2MRx0HSzkiIiIiIiLqqFjKkdJ0dHTQr18/pKamamS8/fv3Q1tbG8HBwRoZjzoGuVyO9PR0lnJERERERETUIbGUo1bp37+/xkq5PXv2YMKECTAxMdHIeNQx3Lt3D2VlZSzliIiIiIiIqENiKUetoqlSrrS0FPHx8Vy6So2IxWIAQL9+/QROQkRERERERKQ8lnLUKv3798fDhw/VfgLrgQMHUFtbi8mTJ6t1HOp4JBIJHBwcYGZmJnQUIiIiIiIiIqWxlKNW8fb2BvD/s5UeP36M/fv346OPPkJubm6rnrl9+3ZkZWU1eG3Pnj0YO3YsLCws2haYOh0e8kBEREREREQdGUs5apUnT57A2NgYK1asgIuLC3r27InQ0FBERkbC0NCwVc/89ttv4erqiqFDh2Lz5s3Izc3F8ePHuXSVmsRSjoiIiIiIiDoylnL0UtLT0/GPf/wD06ZNg7W1NVxdXVFeXo4rV640mN2mr68PU1PTVo1RXV0NuVyOy5cvY9GiRejVqxfkcjm6d++OqqoqVX0U6gTkcjnS0tJYyhEREREREVGHxVKOXkp6ejo+/PBD7NmzB48ePQIA1NXVobq6usF9PXv2bPUYtbW1AJ4VLrW1taipqcHTp08xd+5cWFpa4r333sPJkychl8tb/0GoU7h//z5KS0vh6ekpdBQiIiIiIiKiVmEpRy8lNDQUoaGh0NbWbvG+Xr16tXqMurq6Rq/V1NRALpejvLwc0dHRGD9+PDZt2tTqMahz4MmrRERERERE1NGxlKOXtnHjRujp6TV7XVtbu02lXP1MuZaEhoZiwYIFrR6DOgeJRAI7OzuYm5sLHYWIiIiIiIioVVjK0UuzsbHB3//+d4hEoiav6+jowN7evtXPb6mU69atG9zc3PDzzz83Oz51HTzkgYiIiIiIiDo6lnKklPnz58PPzw/dunVrdK2urk4tpZy2tjYMDAxw8ODBVp/sSp2LRCLhfnJERERERETUobGUI6WIRCL88MMPTV6rrq5uUynX1J5y9fbt2wcXF5dWP5s6j/qTV7mfHBEREREREXVkLOVIae7u7vjiiy+aPPRB1aWcSCTCP/7xDwQEBLT6udS5PHjwACUlJZwpR0RERERERB0aSzlqlYiICPTt2xc6OjoNXlfl8lUdHR3Mnj0bf/rTn1r9TOp8JBIJAJ68SkRERERERB0bSzlqFR0dHWzbtq3B7DYtLS1YW1u3+pnPP6tbt27w9fVFVFRUm3JS5yORSGBjYwNLS0uhoxARERERERG1Gks5arUhQ4Zg4cKFitlyFhYWjWbOKaO+lNPR0UGPHj0QFxeH7t27qyQrdR48eZWIiIiIiIg6A5Zy1CZr1qyBlZUVAMDOzq5Nz5LL5QCenbZ66NAh9OzZs835qPPhyatERERERETUGbR+WhN1WbW1tZDJZCgvL0dFRQX+8pe/YOnSpTA0NMTJkycb3FtUVNTo/UZGRujWrVuD14yNjVFdXQ0A+O6779C7d29UVFRAX19ffR+EOqS0tDS89957QscgIiIiIiIiahORvH56EnU5T548wf3795GXl4eCggIUFBRAKpWisLCw0a/l5eUoLS1FWVmZojzTFHNzc+jp6cHQ0BAWFhawtLRs8lcLCwvY29vD1tYWPXr00GhG0oycnBw4ODjg9OnTGD16tNBxurzd2I3pmA45+GOEiIiIiIhIWZwp10nV1tYiOzsbWVlZyMzMxIMHD5CdnY2HDx8iJycHOTk5KC4ubvAec3NzWFpaNii7evfuDUtLSxgaGsLY2BhGRkbQ09ODiYkJDAwMoKenBzMzMxQVFSExMRF//OMfGzzT2Ni40T5zJSUlDQ51AJ7NqAsLC8P333+Pp0+fori4GBUVFaisrERRURGqqqpQVlbWoCi8d+9eg/KwpqZG8Tw9PT3Y29vDzs4ODg4OsLW1haOjI5ydneHs7AwXFxfOwuuA6k9e5Z5yRERERERE1NGxlOvgcnNzcePGDYjFYty+fRuZmZnIysrC3bt3FTPaTE1N4ejoCEdHRzg4OGDYsGGws7ODvb29orDq0aMHtLW125RlwIABL/UMU1PTRq+Zm5tj//79MDY2bvX4JSUlyM3NRW5urqJ4fPjwIbKzs3H+/HlFKVnPzs4OLi4ucHFxgbOzM/r164f+/fvD1dW1zd8LUg+xWIyePXtyJiQRERERERF1eCzlOoiKigpcu3YNqampSE1NhVgsxvXr11FYWAgA6NmzJ9zd3eHi4oKRI0cqyiYXFxeNFRhtLbLaUsgBz8o+U1NT9OvXr9l7KioqkJmZ2ejr3LlzuHPnDmpra6GnpwcPDw94eXnB09MT3t7eePXVV3nwRDuQlpbGQx6IiIiIiIioU2Ap105lZWXh3LlzuHr1Kq5evYorV66gqqoKxsbGcHd3h4eHByZOnAgPDw8MGjQItra2QkfuEPT19eHl5QUvL69G154+fYqMjAxIJBKIxWJcvXoVmzdvxp07dyCXy2Fra4uBAwdi4MCBGDVqFEaMGAEDAwMBPkXXJRaLMWDAAKFjEBEREREREbUZD3poB+rq6pCSkoJTp04hPj4e58+fh0wmg76+Pnx9fTFkyBDFl7OzM0QikdCRuxSpVIrLly/j0qVLiq/Hjx9DR0cHvr6+GDt2LMaOHYtRo0axpFMzS0tL/O1vf8PChQuFjkLgQQ9ERERERERtwVJOIHfv3sWRI0dw6tQpJCYmQiqVwsrKCgEBARgzZgyGDRuG/v37o1u3bkJHpSZkZWXh0qVLOHfuHOLj45GWlobu3btj2LBhGDt2LIKCgjB06FBoaWkJHbXTePjwIezs7JCQkAB/f3+h4xBYyhEREREREbUFSzkNEovFiIuLw8GDB3HhwgUYGBhg+PDhCAwMRGBgIHx9fVnidFD5+fk4c+YMTp48iRMnTuDOnTvo0aMHgoODMXXqVAQFBUFXV1fomB3aqVOnEBgYiPz8fO7v106wlCMiIiIiImo97imnZqmpqdi+fTv27duHO3fuwMHBASEhIVi5ciX8/f05E66TsLa2xtSpUzF16lQAzwrY2NhYxMbGYsqUKTA2NkZwcDBmzZqF4OBgnu7aCmKxGD169GAhR0RERERERJ0CSzk1KC4uxq5du/Djjz/i8uXLcHFxwcyZMxEaGopBgwZxT7guwNPTE56envjss89w//59HDhwADExMQgJCYGNjQ1mz56NuXPnok+fPkJH7TB48ioRERERERF1JlwrqUI3btzAnDlzYGtri48//hj9+vVDYmIiMjIysHr1agwePJiFXBfk6OiIRYsWISEhAbdv30ZYERERawAAIABJREFUWBh27tyJvn37YvTo0YiNjUVdXZ3QMds9sVgMDw8PoWMQERERERERqQRLORW4cOECQkJC4O3tjStXrmDDhg14+PAhduzYgTFjxrCIIwVnZ2d89dVXuHv3Lo4dOwZLS0u89dZb6N+/P3bs2IHq6mqhI7ZbaWlpLOWIiIiIiIio02Ap1wbXrl1DQEAARo4cCalUitjYWKSmpmL+/PkwMTEROh61Y1paWggKCsK+ffuQmpqKwYMHY/78+XB1dcVPP/0Enr/SUH5+PgoKCljKERERERERUafBUq4VCgsLsWjRIgwePBjV1dU4ffo0zp8/j5CQEM6KI6V5eHhg+/btuH37Nl577TXMnTsXfn5+uHbtmtDR2g2xWAwA3FOOiIiIiIiIOg2Wckr65Zdf0KdPH+zduxfbtm3D2bNnMXr0aKFjUSfwyiuvYOPGjbh8+TIAYPDgwViyZAmqqqoETiY8iUQCc3NzWFtbCx2FiIiIiIiISCVYyr2k6upqLFmyBDNnzsT06dNx8+ZNzJ49WyMz4w4fPgx3d3fo6Lz8Ybm1tbVYvnw53NzcoKenh+Dg4GbvvXz5MubMmQMnJyfo6+vDwsICXl5eeOutt7Bx40ZkZmYCALy8vCASiRp8zZgxQ/GcwMDABtcGDRrUaKx79+4hJCQEMplMJZ/zfyUnJ2PSpEkwMzODsbExAgMDcf78+Ub3RURE4Jdffmn2OXPnzoWuri6cnJywZMkSVFZWtjqTsnx9fXH27Fls27YN27dvh5+fH7KzszU2fnskkUjg5eXV5ucUFRVh06ZNGDt2LCwsLKCvrw83Nze8++67SElJUUFSIiIiIiIiopfDUu4l5Ofnw9/fH9u2bUN0dDT++c9/amTPuMzMTISEhGD58uXIz89X6r1bt27FN998g9mzZyMvLw9HjhxpdE9dXR0++eQTjBgxAj179sSRI0dQXFyMtLQ0rFu3DjKZDAsXLoSrqytqampw48YN5OXlwdLSEgDw888/Izo6WvG8kydP4tChQ3Bzc0N5eTmuXLnSYLzk5GQMGjQIQUFBDb5/bfmcz7t48SJGjBgBY2NjpKWl4c6dO3B2doa/vz+OHz/e4N758+dj+fLl+Pzzz5t81o8//oiCggJERERgw4YNiIyMbHWu1hCJRJg9ezYuX76MiooKDBw4EAkJCRrN0J5IJBKV7Cf3ySefYPHixZgyZQokEgmkUim2bduG5ORkDBw4ELGxsSpIS0RERERERPQS5NSivLw8eb9+/eRubm5yiUSi0bFnzpwp//rrr+XV1dVye3t7uba2tlLvBSCXyWTN3rNixQo5AHlUVFST12tqauTBwcFyAPLq6mrF6//973/lAOSWlpbyvLw8xeuFhYVyR0dH+fnz5xs9q6SkRO7g4CAPDw9X6eesV1tbK/f09JTb2trKnzx50uAz9OnTR+7o6CivrKxs8J7k5GS5SCSS//LLLy0+28DAQB4UFKR0JlUpKyuTT58+Xa6npyc/duyYYDmEZGVlJV+/fn2bnzNv3jz5+++/3+j15ORkOQC5m5tbm8foSn6R/yKHnD9GiIiIiIiIWkMkl/OYx+ZUVVXB398fUqkUiYmJsLOz0+j4FRUV0NfXBwA4ODggLy8PNTU1L/XeCRMm4NSpU83en56eDk9PT/j6+jaa0fa8pKQkjBgxAtXV1Q2WlU6ZMgUHDhzAW2+9hZiYGADArFmzYG9vj2+//bbRc/7617/i22+/xb179xp9H9vyOeslJiYiICAAixcvxoYNGxpc+/LLL7Fq1SrExMTgrbfeanBt2rRpSEpKwp07d5pdNmtvbw9bW9sWv0/qVldXhzlz5mDfvn1ISkpSyVLOjqKgoABWVlY4ceIEAgMD1TaOgYEBqqqqUFNTwwNbXtJu7MZ0TIcc/DFCRERERESkLC5fbcHnn38OiUSCgwcParyQA6Aoqlqjtra2xetRUVGoq6vD1KlTW7xv+PDhkMvljQqrTZs2wdzcHHv27EFMTAxiY2ORnJyMr776qtEz5HI5tmzZgqFDhzb5fWzL56wXHx8PAE3uY1f/2qlTpxpde+ONN/DgwQMcOnSo2WeLRCKlS0JV09LSwtatW+Hr64vp06fj6dOngubRpBs3bgBQ78mr5eXlqKioUOybSERERERERKRuLOWacevWLaxbtw5r165Fnz59hI6jcmfOnAEAeHt7t+r9tra2WLduHQBg0aJF+OCDD7Bjxw7o6uo2ujclJQX5+fnw8fFpfeAXSE9PB/Bspt3/sre3B/Dsf9P/NWDAAADAsWPH1JZNVbp164b//Oc/uHv3Lv75z38KHUdjJBIJzMzMYGtr2+T19PR0hIaGwtTUFAYGBhgyZAji4uIaHDwSFhbW4hi//vorAOCzzz5TeX4iIiIiIiKiprCUa8Y//vEP9O7d+4V/mW+vnj592mRBVi83NxcAFIc2tMYf/vAHvPbaa3j06BFcXV0xcODAJu+rn+nUVGGmKsXFxQAAQ0PDRteMjIwAPDt583/VF3b1GZuiq6uL6upqVcRss969e2PBggX4/vvvUVdXJ3QcjZBIJM3Okrt9+zaGDx+OK1euICYmBo8ePcKPP/6I9evX4/r169DV1VXM1GxOfn4+IiIiEBYWhmnTpqnrYxARERERERE1wFKuGQcPHsSsWbOgpdUxv0XZ2dkvVYK1damem5sbAOD06dPYv39/k/c8fPgQAGBqatqmsVqrftvEpj6riYkJRCKRImNT7OzskJOTI/gS1npz5szB/fv3ce3aNaGjaERLpdyKFStQXFyM9evXY/z48TAyMoKnpyd27tyJ8vLyFz5bKpVi4sSJ8Pf3x6ZNm1QdnYiIiIiIiKhZHbNxUrPS0lLcu3cPQ4YMETqK0goLC7F27Vrcu3cPCxcubPa++r3dCgoKWj3W2bNnsXfvXkRGRgIAFixY0ORstMrKSgDPll+qi5mZGQA0WcTUv1Z/z//S0dFBRUVFs88ODw+HTCbDF1980abvl6p4eXnBwMCgxdl9nYlYLEa/fv2avHb06FEAzw42eZ6VlRX69u3b4nPLy8sxYcIEeHh44L///S+0tbVVE5iIiIiIiIjoJbCUa0JZWRmA/1/22FHMmTMHlpaWiIiIwKeffooPP/yw2XvHjBkDALh+/XqrxiorK8OcOXMQFRWFZcuWITg4GHl5eViyZEmje/X09ABArUtA6wuYBw8eNLqWk5MDAHB3d2/yvTU1NS0eNjFr1iysXr0aa9euhZWVFSZOnKiCxK0nEolgZGSE0tJSQXNoglQqxaNHj5qcKVdVVYXS0lLo6ek1+e+qubl5s8+tqanB1KlTYW9vjx07drCQIyIiIiIiIo1jKdcES0tLaGtrK/Zd6yi2b9+OkpISREdHIzIyEuHh4c3eGx4eDh0dHcTExLT4zE8//RRaWlqKgxTqffTRRwgMDFQUVJs3b4aJiQl++uknxMXFNbi3foP+kpKS1nyslxIQEAAAuHr1aqNr9a+NGzeu0TWZTAa5XN7sIQLAs83/V6xYgY0bN6K4uFgxO0soFRUVKCwshLW1taA5NEEsFgMAPDw8Gl3T1dWFsbExKisrFUX68x49etTsc8PDw1FVVYXdu3c3OFnY1dUVv/32mwqSExEREREREbWMpVwTunfvjkGDBuHkyZNCR1GaiYkJpk6dCl9f3xYLN3d3d6xcuRJXrlzBtm3bmrzn5s2b2Lx5M6ZNm9ZgKeCxY8dw4sQJ/P3vf1e85ujoqPh9eHi44uAF4NlyS6DpWWyqMmbMGHh4eCAmJkaxXBYAamtrER0dDUdHR0yaNKnR++pn0dVnbMrevXvh5OSEsLAwwfbFe15iYiJqamowYsQIoaOonUQigYmJiWK59f8KDg4GgEZFaV5eXpOn7QLAqlWrIBaLsX///hYPQyEiIiIiIiJSJ5ZyzZg5cyZ27drVLvYQaw0TExPIZLIW7/nrX/+KiIgILFiwABEREbh16xaePn2KnJwcbN26FQEBAfD29sbWrVsV7ykuLsb8+fOxbds2GBsbN3je/PnzERgYiNzcXCxbtkzxuo+PD3r27ImUlBSVfLZZs2ZBJBLhzp07ite0tLSwdetWFBYWYu7cucjLy4NUKsWiRYuQkZGBH374QbGM9nnJyckAgKCgoGbHKy0thYmJiUqyq8KGDRswZswYxcmxnVn9IQ/NHUiyZs0aWFhYYOnSpThx4gTKyspw48YNzJ07FzY2No3u3759O7788ktcvHgRxsbGEIlEDb4yMzPV/ZGIiIiIiIiIALCUa9a8efNgamqKjz/+WLAMcXFxirIgJycHtbW1it9v2bKlxfe+7KmqX3/9Nc6fP4/c3FwEBgbCyMgI/fr1w5YtWxAREYFTp07B0NAQAODg4ABzc3Pcv38fAQEBCA0NVTynuLgYIpFIMbtw+/btEIlE+P777yESiRAWFoaLFy82uSRY2c/58OFDGBkZ4ZVXXmnw+rBhw3DhwgWUlJSgT58+6N27NzIyMpCYmNjoIIB6+/btg729fZOz6J7X1lNqVeXAgQM4evQovvjiC6GjaERLJ68CgIuLC5KSkjB48GC8/fbbsLa2Rnh4OJYvXw5XV9dG979ouTYRERERERGRpojkcrlc6BDt1f79+/HGG29g27ZtmDNnjtBxlDJ58mQcPnwYdXV1QkcB8Gw/OU9PT0yePBmbNm1q9XOKi4thZ2eHd999Fz/88EObMqWkpMDX1xc7d+7EjBkzmr3PxsYGTk5OSEpKatN4bZWZmYkhQ4bg9ddfx/bt2wXNoim2trb45JNP8Oc//1np9wYGBuLcuXMNljOTau3GbkzHdMjBHyNERERERETK4ky5FkyZMgURERF4//33sXfvXqHjKMXBwQFyuRz5+flCRwEAmJqa4uDBg4iJicG//vWvVj1DLpfjww8/hImJCf72t7+1KU9WVhbefPNNLF++vMVCrrq6GoWFhXBwcGjTeG2VnZ2N8ePHw8nJCf/+978FzaIpRUVFyMvLa3GmHBEREREREVFHxVLuBVavXo33338f06dPx3fffYeOMrGw/lTUb775BlKpVOA0z/j6+uLKlSs4cuTIC/e7a0p+fj6ysrJw6tSpJvcLU8bmzZuxevVqrF69utl7SkpKEBkZierqasX3Uwjnzp3DsGHDYGJigqNHj8LAwECwLJrU0smrRERERERERB0dl6++pKioKHzwwQeYOHEi/vOf/8DMzEzoSC/03XffYfv27cjKykJAQACOHDkidKQOY86cOdi5cyd69eqFmTNnYuXKldDW1tZ4jqioKCxevBhBQUH46aefOsSfO1WJiorCJ598otiv8GVFR0dj5syZDV6bN2/eC/dhJOVx+SoREREREVHrsZRTwpkzZzB9+nQYGBhg3bp1CAkJEToSdVIZGRlYunQpjh07hr/97W+IiIhoN4dNaMrSpUtx8eJFwffyo+axlCMiIiIiImo9Ll9VwujRo/H7779j6NChCA0NxWuvvYaMjAyhY1EnUl5ejhUrVqB///64f/8+EhISsHz58i5XyAHPlq9y6SoRERERERF1VizllGRra4udO3ciMTEROTk56N+/PxYuXIisrCyho1EHVlZWhnXr1qFPnz7YuHEj1q5di99//x1+fn5CRxOMRCJhKUdERERERESdFku5Vho9ejSuXr2KDRs24NixY3B3d8c777yDlJQUoaNRByKVSrFq1Sr07t0bX3zxBaZNm4Zbt25h8eLF0NHRETqeYIqLi5Gbm8tSjoiIiIiIiDotlnJtoKOjg/fffx83b97Ef/7zH4jFYvj6+mLcuHH4+eefUVFRIXREaofkcjnOnTuHP/7xj+jVqxf++c9/YvHixbh79y4iIyNhZWUldETBSSQSADx5lYiIiIiIiDovlnIqoKOjg3feeQfJyck4dOgQTExM8Mc//hG2trZYsGABLl68KHREagdycnLw9ddfo0+fPvDz80NKSgq+/fZb3Lt3DytXroSlpaXQEdsNsVgMIyMjvPLKK0JHISIiIiIiIlKLrrs+Tg1EIhGCg4MRHByMoqIi/Prrr9i4cSM2b96MXr16YcqUKXj99dfh7+/fpZcmdiV3797F/v37ERcXh8TERBgZGWHatGmIjo7Gq6++KnS8distLQ0eHh5d8oALIiIiIiIi6hpEcrlcLnSIzu7KlSvYs2cPYmNjkZ6eDisrK4SEhCgKOlNTU6EjkorU1NTg8uXLOHLkCGJjY5GamgpLS0tMnjwZb7zxBiZOnAhdXV2hY7Z7EyZMgJ2dHX788Ueho1ALdmM3pmM65OCPESIiIiIiImWxlNOw9PR0xMbGYt++fbhy5QpEIhEGDRqEsWPHYuzYsRg5ciT09fWFjkkvqa6uDtevX0dCQgLi4+Nx+vRplJaW4pVXXsGUKVMQGhqK0aNHc2akkhwdHfHhhx/ik08+EToKtYClHBERERERUeuxlBNQQUEBEhMTER8fj/j4eNy8eRO6uroYMmQIhg4diqFDh2LIkCHcV6sdKSkpweXLl3Hx4kVcunQJFy5cQEFBAXr06AF/f3+MHTsWAQEB6Nu3r9BROyyZTAYzMzMcPHgQkyZNEjoOtYClHBERERERUeuxlGtHcnJycOrUKZw7dw4XL16EWCxGbW0tbGxsMGTIEAwZMgQDBgyAp6cnevfuLXTcTq+oqAipqalITU3F5cuXcenSJdy8eRN1dXVwdHTE0KFDMWLECAQEBMDb2xtaWjw3RRWSkpIwYsQI3Llzh3/O2zmWckRERERERK3HUq4dKy8vx9WrV3Hx4kVcvHgRly9fRnZ2NgDAxMQEHh4e6N+/P7y8vODl5QU3Nzc4ODhwc3wlFRYWIjMzEzdu3IBYLEZqairEYjFycnIAAGZmZnj11VcbzF60tbUVOHXntXXrVnz44YcoLS1l0dnOsZQjIiIiIiJqPW501Y4ZGhpi9OjRGD16tOK14uJiiMVi3LhxQ1Ee7d27F1KpFACgq6sLZ2dnuLq6wsXFRfHrK6+8AgcHB5iYmAj1cQRTVVWF3NxcPHjwALdv30ZmZqbi6/bt2ygqKgIA6OnpwcPDA15eXhg3bhz69+8PT09PLh/WMIlEAg8PDxZyRERERERE1KlxplwnkZ+fj4yMjAaFU/1XQUGB4j4DAwM4OjrC1tYWDg4OsLW1hb29PXr06AFLS0tYWFgo/rk9nwpbUVEBqVSKwsJCSKVSSKVSPH78GPn5+Xjw4AEePnyI+/fvIy8vD48fP1a8T19fHy4uLoqv+tLSxcUFvXv3hra2toCfigAgODgYPXv2xI4dO4SOQi/AmXJEREREREStx5lynYS1tTWsra0xatSoRtdKSkpw//79BmXVw4cPkZOTg7S0NOTm5qKgoADV1dUN3qejo6Mo6gwMDGBubg49PT3o6+vDzMwMurq6MDQ0hImJiaLMMjc3b/CM+vvr1dTUoLS0tME95eXlePr0qSJrVVUVysrKUFpaisrKSpSWlqK8vBxPnjxRFHAVFRWNPqe+vj6cnJxgb28POzs7+Pr6wtbWFo6OjrCxsYGDgwPs7Oxa9w0mjZFIJPD39xc6BhEREREREZFasZTrAkxNTWFqagovL68W7ystLYVUKkVBQUGjWWgVFRUoKipCZWUlKioqcPfuXVRWVuLJkycoKSlBXV1dk4VbWVlZg7JPJBLBzMyswT3PF3fGxsbQ09ODsbExjIyMoK+vDysrK8U/15eEz/9qaWmJw4cPIywsDIMHD8aWLVugo8M/2h1RWVkZ7t+/Dw8PD6GjEBEREREREakVmwtSMDY2hrGxsUpPvDx9+jT8/f2Rn5+Pnj17quy5/2v27NmwsLDA9OnTUVxcjF27djWYoUcdg1gshlwuh6enp9BRiIiIiIiIiNSKO6mTWtXPnNPEAROTJ09GfHw8zp07h+DgYJSUlKh9TFItiUQCAwMDlRbDRERERERERO0RSzlSq9LSUujo6EBPT08j4w0dOhSnT59GZmYmRo0ahZycHI2MS6ohkUjQt29fnrxKREREREREnR7/5ktqJZPJNDJL7nmenp44e/Ysqqur4efnh4yMDI2OT60nkUi4dJWIiIiIiIi6BJZypFalpaUwNjbW+Li9e/fGhQsXYG1tDT8/P1y7dk3jGUh5YrEY/fr1EzoGERERERERkdqxlCO1Ki0t1fhMuXoWFhY4ceIEBgwYgNGjR+PEiROC5KCXU1ZWhuzsbM6UIyIiIiIioi6BpRyplUwmE2SmXD0jIyMcOHAAkyZNwuuvv46YmBjBslDL0tLSIJfL4eHhIXQUIiIiIiIiIrVjKUdqJdTy1ed1794du3btwsKFCzFjxgxERUUJmoeaJpFIoKenBycnJ6GjEBEREREREamdjtABqHMTcvnq80QiESIjI2FtbY0FCxYgNzcXq1atEjoWPaf+5FVtbW2hoxARERERERGpHUs5UiuZTAY7OzuhYyj85S9/gbGxMRYvXgypVIr169dDS4sTRtsDnrxKREREREREXQnbCFKr9jJT7nkLFy5ETEwMtmzZgvfeew/V1dVCRyLw5FUiIiIiIiLqWljKkVoJfdBDc9544w0cPnwYcXFxCA4ORmlpqdCRurQnT57g3r17nClHREREREREXQZLOVKr9nDQQ3MCAgIQHx+P1NRUjBs3Do8fPxY6UpeVlpaGuro6nrxKREREREREXQZLOVKr9lzKAcDAgQORlJSEwsJCjBkzBtnZ2UJH6pIkEgl0dXXh7OwsdBQiIiIiIiIijWApR2rVHveU+1/Ozs44e/YsunfvjuHDhyM1NVXoSF1O/cmrOjo8e4aIiIiIiIi6BpZypDaVlZV4+vRpu54pV8/W1haJiYlwdnbGmDFjcOHCBaEjdSlisZhLV4mIiIiIiKhLYSlHalN/eEJ7nylXz8zMDCdPnkRAQACCgoJw5MgRoSN1GRKJhKUcERERERERdSks5Uht6ku5jjBTrp6uri52796NmTNnIiQkBD/++KPQkTq9yspK3L17l6UcERERERERdSncwInURiaTAehYpRwAaGtrIyoqCpaWlpg3bx6kUik+/vhjoWN1WmlpaaitrWUpR0RERERERF0KSzlSm462fPV5IpEI33zzDWxtbfHnP/8ZBQUF+PrrryESiYSO1umIxWJ0794drq6uQkchIiIiIiIi0hiWcqQ2HXWm3POWLFkCCwsLzJs3D3l5ediyZQtPCFWxtLQ09OnTh99XIiIiIiIi6lL4t2BSm9LSUmhra8PAwEDoKG3y3nvvwdzcHNOnT0dRURGio6Ohr68vdKxOgyevEhERERERUVfEgx5IbUpLSzv0LLnnTZ48GfHx8Th//jyCg4NRUlIidKROgyevEhERERERUVfEUo7URiaTdcj95JozdOhQnDlzBpmZmRg1ahRycnKEjtThVVZWIisri6UcERERERERdTks5UhtOtNMuXoeHh44d+4cqqur4efnh4yMDKEj4fDhw3B3d++Qe7LdvHkTtbW18PT0FDoKERERERERkUaxlCO1KS0t7VQz5er16tULFy5cgLW1Nfz8/HDt2jVBcmRmZiIkJATLly9Hfn6+IBnaSiwWo1u3bjx5lYiIiIiIiLoclnKkNjKZrNPNlKtnYWGBkydPYsCAARg9ejROnDih8Qyff/45RowYgatXr3bY77NEIoG7uzu6desmdBQiIiIiIiIijep4692ow+iMy1efZ2hoiAMHDmD27Nl4/fXX8dNPP2Hq1KkaG3/r1q0d/hRYHvJAREREREREXRVnypHadNblq8/r3r07du3ahYULF2LmzJmIiorS2NgdvZADWMoRERERERFR18VSjtSmMy9ffZ5IJEJkZCRWr16N8PBwREREtOo56enpCA0NhampKQwMDDBkyBDExcUhMDAQIpEIIpEIYWFhKk4vnKqqKmRmZrKUIyIiIiIioi6Jy1dJbbrCTLnn/eUvf4GJiQk++OADlJeXY/369dDSerne+/bt2xg+fDgMDQ0RExOD4cOH4969e1i6dCmuX78OXV1dVFZWqvkTaNbNmzdRU1PDk1eJiIiIiIioS2IpR2rTVWbKPe9Pf/oTbG1tMXPmTBQWFmL79u0vdYjBihUrUFxcjC1btmD8+PEAAE9PT+zcuRO9e/dWc2phSCQS6Ojo8ORVIiIiIiIi6pK4fJXUprMf9NCc0NBQHD58GHFxcQgODkZpaekL33P06FEAwIQJExq8bmVlhb59+6olp9AkEgnc3Nygq6srdBQiIiIiIiIijWMpR2rTVUs5AAgICEB8fDxSU1Mxbtw4PH78uNl7q6qqUFpaCj09PRgZGTW6bm5urs6oguEhD0RERERERNSVsZQjtXj69Cmqqqq61J5y/2vgwIFISkpCUVERxowZg+zs7Cbv09XVhbGxMSorK1FWVtbo+qNHj9QdVRASiYT7yREREREREVGXxVKO1EImkwFAl50pV8/Z2Rlnz55F9+7dMWzYMKSmpjZ5X3BwMID/X8ZaLy8vD7du3VJ7Tk2rrq7G7du3OVOOiIiIiIiIuiyWcqQW9fuodeWZcvVsbGyQmJgIV1dXjBkzBufPn290z5o1a2BhYYGlS5fixIkTKCsrw40bNzB37lzY2NgIkFq9bt68ierqapZyRERERERE1GWxlCO1qC/luvpMuXpmZmY4ceIEAgICEBQUhCNHjjS47uLigqSkJAwePBhvv/02rK2tER4ejuXLlzd7OmlcXBxEIhFEIhFycnJQW1ur+P2WLVs08bFarf7kVXd3d6GjEBEREREREQlCR+gA1Dlx+Wpjurq62L17NxYsWICQkBBERUVh7ty5iuvu7u7Yt2/fSz9v8uTJkMvl6oiqdhKJBC4uLjx5lYiIiIiIiLoslnKkFly+2jRtbW1ERUXB3t4e8+bNg1Qqxccffyx0LI3jIQ9ERERERETU1bGUI7WQyWTQ1taGgYHSR4dDAAAgAElEQVSB0FHaHZFIhFWrVsHc3Bx//vOfUVBQgK+//hoikUjoaBojFovx5ptvCh2DiIiIiIiISDDcU47UorS0FEZGRl2qaFLWkiVLsGPHDkRGRmLu3LmoqalpcD06OhoikQinTp1CVVUVRCIRwsLCBEqrOjx5lYiIiIiIiIgz5UhNSktLuZ/cS5g1axbMzMwwffp0FBUVITo6Gvr6+gCAGTNmYMaMGQInVL2MjAw8ffqUpRwRERERERF1aZwpR2ohk8m4n9xLmjx5MuLj43H+/HkEBwejpKRE6EhqJZFIoK2tzZNXiYiIiIiIqEtjKUdqwZlyyhk6dCjOnDmDzMxMjBo1Cjk5OUJHUhuxWAxnZ2fFjEAiIiIiIiKiroilHKlFaWkpZ8opycPDA+fOnUN1dTX8/PyQkZEhdCS1SEtL48mrRERERERE1OWxlCO1kMlknCnXCr169cKFCxdgY2MDPz8/XLt2TehIKicWi7mfHBEREREREXV5LOVILbh8tfUsLCxw4sQJDBgwAKNHj8aJEyeEjqQyNTU1yMjIYClHREREREREXR5LOVILLl9tG0NDQxw4cACTJk3C66+/jl9//VXoSCpx+/ZtVFVVsZQjIiIiIiKiLo+lHKkFl6+2Xffu3bFr1y4sXLgQM2fOxObNm4WO1GZisRhaWlro27ev0FGIiIiIiIiIBKUjdADqnLh8VTVEIhEiIyNhbW2NBQsW4M6dO/jmm2+EjtVqEsn/sXfnUVWV+//A34fpMI8iMyrgxKQIgrOgRFIKVJqZ5tVyKvNWtwmtvPdqlmlL0+o6o5nXi8NNvWKKppGihmjigBMg86QyncM87d8ffjk/iUGGw9kM79daZyF7P3vvzzmdlsv3ep7nc4udV4mIiIiIiIjAUI46iEwm4/JVJfr4449haGiIt99+GyUlJdiwYQPU1LreRNdbt25x6SoRERERERERGMpRB+FMOeV78803YWVlhRkzZiA/Px+7du2Cpqam2GU1acOGDaitrYWLiwsGDRoEe3t73Lp1C88995zYpRERERERERGJjqEcKV1VVRXKy8sZynWAkJAQ/PzzzwgJCUFgYCAOHTrUaT/nW7duYevWrYrfdXV1oampidjYWKxduxYuLi4YPHgw+vbtC4lEImKlRERERERERKrHUI6UTi6XAwCXr3YQPz8/nDlzBs899xwmTpyIY8eOwdzcvNGxubm5sLCwUHGFj7m6ukJTUxNVVVUAgNLSUgDAb7/9hnPnzqGyshIAYGpqioSEBJiamopSJxEREREREZEYut6mVNTpyWQyAOi0M7i6A09PT1y8eBEFBQUYN24c0tLSGozZuHEjJk2aBEEQRKgQcHNzUwRyT6qurlYEcmpqapg/fz4DOSIiIiIiIupxGMqR0nGmnGo4ODjg3Llz0NbWxogRI3D9+nXFuT179uDdd99FXFwc9u/fL0p97u7uTx2jp6eHjz/+WAXVEBEREREREXUuDOVI6epCOc6U63iWlpb49ddf4eTkBF9fX5w/fx4RERGYM2cOgMcz0UJDQxudsdbRTE1N0atXrybPq6urY8WKFTAxMVFhVURERERERESdA0M5UjouX1UtY2NjREZGYsyYMfj2228xbdo01NbWQhAE1NbWIi0tDWFhYaLUNnTo0EabOEgkElhaWuLNN98UoSoiIiIiIiIi8TGUI6WTy+VQU1ODnp6e2KX0GDo6OlixYgV+/vlnVFZW1ttHThAEfPrpp4pGC6o0dOhQaGpqNnpu7dq1kEqlKq6IiIiIiIiIqHNgKEdKJ5PJoK+vDzU1fr1UJSkpCc888wzKyspQW1tb75wgCCgsLMS3336r8rrc3NxQXV1d75i6ujqcnZ0xffp0lddDRERERERE1FkwNSGlk8vlXLqqQllZWfD19UVRUVGDAKxOdXU1Pv/8c+Tn56u0Njc3twYhYU1NDb755huGtkRERERERNSj8V/FpHQM5VRHLpfj2WefRUZGxlObOZSXl2Pt2rUqquwxZ2dnqKurK37X0NBAQEAA/P39VVoHERERERERUWfDUI6UTi6Xw9DQUOwyegQDAwNs374d06dPh7q6epP7twGPZ8utX78e2dnZKqtPKpWiT58+it9ramrw1Vdfqez5RERERERERJ0VQzlSOplMxplyKuTj44Pw8HBkZGRg5cqVMDc3h5qaWqPLQ2tra7FixQqV1ufp6Qk1NTVoampi9uzZGDp0qEqfT0RERERERNQZMZQjpeNMOXFYWlri448/Rnp6OsLDwxXhl4aGhmJMVVUVtm3bhsTERJXV5e7ujtraWkgkEqxcuVJlzyUiIiIiIiLqzDSePoSodWQyGUxNTcUuo8eSSqWYNm0apk2bhqioKHzzzTc4evQo1NXVFfvOffLJJ9i3b1+L7ldTUwOZTIaSkhKUlZVBJpMBAIqKiho0cSgoKGhwfd0zQ0JCcPfuXdy9excGBgbQ0NCAjo4OtLW1YWJiAm1tbejo6LTnrRMRERERERF1GRJBEASxi6DuxdfXF66urvjuu+/ELoX+T0pKCtavX4/t27ejtLQUEokEy5Ytg66uLvLz85GXl1fvZ0lJCeRyOYqLi5/aQELZ6gI6PT09mJqawszMrNGfpqamsLGxgZWVFXr16qXSGumx/diP6ZgOAfxrhIiIiIiIqLU4U46UjstXVa+mpgZpaWm4f/8+kpKSkJGRgbS0NGRnZyMzMxOZmZkoLCxUjBcEAWvWrEGfPn3qhV19+/aFmZkZ9PT0YGBgAH19fWhra8PQ0BC6urrQ1taGsbExAEBPTw9aWlr16qibAfekwsJC/Pjjj5g1a5biWN2MutLSUpSXl6OwsBBlZWUoLy9HQUEBKioqUFxcXC8oTE1NrRceVldXK+6nra0NGxsbWFtbw9bWFlZWVrCzs4ODgwMcHBzg6OjIWXhERERERETUqTCUI6Vjo4eOk5WVhZs3byI+Ph6JiYlISkrC/fv3kZKSopjRZmRkBDs7O9jZ2cHW1hYjRoyAtbU1bGxsFIGVmZkZTp8+DS8vL5iZmXVozcbGxliyZEm9YyYmJu2+b1FREbKyspCVlaUIHrOzs5GWlobz588rQsk61tbWcHR0hKOjIxwcHDB48GC4ubnByckJ6urq7a6HiIiIiIiIqDUYypHSyeVyhnLtVFZWhqtXr+LGjRu4ceMG4uPjcf36deTn5wMAevfujQEDBsDR0RGjR49WhE2Ojo4tXsr57LPPduRb6HBGRkYwMjLC4MGDmxxTVlaGpKSkBq/o6GgkJyejpqYG2tracHZ2hqurK1xcXODu7o5hw4ahd+/eKnw3RERERERE1NMwlCOlk8lkXL7aSvfv30d0dDSuXLmCK1eu4PLly6ioqICBgQEGDBgAZ2dnTJo0Cc7OzvDy8oKVlZXYJXcJOjo6cHV1haura4NzlZWVSEhIwK1btxAfH48rV65gy5YtSE5OhiAIsLKygqenJzw9PTFmzBiMGjUKurq6IrwLIiIiIiIi6o7Y6IGUqrq6Gpqamvjpp5/wwgsviF1Op1RbW4tr167h9OnTOHPmDM6fPw+ZTAYdHR14eHjA29tb8XJwcIBEIhG75B4lLy8PsbGxuHTpkuL18OFDaGhowMPDAxMmTMCECRMwZsyYHh/SsdEDERERERFR2zGUI6UqKCiAqakpTp06BX9/f7HL6TRSUlJw/PhxnD59GlFRUcjLy4O5uTn8/Pwwfvx4jBgxAm5ubtDU1BS7VGrE/fv3cenSJURHR+PMmTO4ffs2tLS0MGLECEyYMAEBAQHw8fGBmpqa2KWqFEM5IiIiIiKitmMoR0qVlpaGPn36ICYmBt7e3mKXI6r4+HhERETg6NGjuHDhAnR1dTFy5Ej4+/vD398fHh4ePS7E6S5yc3Nx9uxZ/PLLLzh16hSSk5PRq1cvBAYGYtq0aQgICIBUKhW7zA7HUI6IiIiIiKjtGMqRUt28eRNubm64detWsxvwd1c3btzArl27cOjQISQnJ8PW1hZBQUEICQmBr68vZ8J1U/Hx8Th8+DAOHz6MK1euwMDAAIGBgZg1axYCAwO7bXdXhnJERERERERtx0YPpFRyuRwAelSjh8LCQvznP//Bzp07ERsbC0dHR8yYMQMhISHw8vLinnA9gIuLC1xcXPDJJ58gPT0d//vf/3Dw4EEEBQXB0tISs2fPxty5czFw4ECxSyUiIiIiIqJOgmvnSKnqQjkDAwORK+l4N2/exJw5c2BlZYUPPvgAgwcPRlRUFBISErBq1SoMHz6cgVwPZGdnh8WLF+PXX39FYmIi5s2bh71792LQoEEYN24cDh8+jNraWrHLJCIiIiIiIpExlCOlkslkkEgk0NfXF7uUDnPhwgUEBQXB3d0dly9fxsaNG5GdnY0ffvgB48ePZxBHCg4ODlixYgVSUlIQGRkJMzMzvPTSS3Bzc8MPP/yAqqoqsUskIiIiIiIikTCUI6WSy+XQ09Prlg0Mrl69Cj8/P4wePRp5eXk4fPgwbty4gfnz5/eo5brUempqaggICMChQ4dw48YNDB8+HPPnz4eTkxN+/PFHcGtPIiIiIiKinqf7JSckKplM1u0Cqvz8fCxevBjDhw9HVVUVfvvtN5w/fx5BQUGcFUet5uzsjF27diExMRHPPfcc5s6di7Fjx+Lq1atil0ZEREREREQqxFCOlEoul3er/eT27duHgQMH4qeffkJYWBjOnTuHcePGiV0WdQP29vbYtGkTYmNjAQDDhw/HO++8g4qKCpErIyIiIiIiIlVgKEdKpaxQLi4uDs8//zyMjY1hYGAAf39/nD9/XgkVtkxVVRXeeecdzJgxA9OnT8fdu3cxe/bsDpsZJwgCzp8/j8WLF2PAgAGQSqXo3bs3xowZgz179jx1eWNNTQ2WLl2K/v37Q1tbG4GBgU2OjY2NxZw5c9CvXz/o6OjA1NQUrq6ueOmll7Bp0yYkJSUBAFxdXSGRSOq9XnnlFcV9/P39653z8vJq8KzU1FQEBQVBJpMBAAoKCrB582ZMmDABpqam0NHRQf/+/TFz5kxcu3atLR8dfv75ZwwYMAAaGk03kw4NDcW+ffuaPD937lxIpVL069cP77zzDsrLy9tUS1t4eHjg3LlzCAsLw65duzB27FikpaWp7PlEREREREQkDoZypFRyubzdy1djYmIwatQoGBgY4Pbt20hOToaDgwN8fX1x8uRJJVXatNzcXPj6+iIsLAzh4eH47rvvOnxJ7t27dzFmzBjcu3cPBw8eRFFREX7//XfY29vjtddew4cfftjs9Tt27MDq1asxe/Zs5OTk4Pjx4w3G1NbW4sMPP8SoUaPQu3dvHD9+HIWFhbh9+zbWr18PmUyGt956C05OTqiursbNmzeRk5MDMzMzAMCePXsQHh6uuN8vv/yCY8eOoX///igpKcHly5frPS8uLg5eXl4ICAhQfH4ffvghlixZguDgYNy6dQt5eXkICwtDXFwcPD09cfjw4RZ/ZklJSQgKCsLSpUuRm5vb7Nj58+dj6dKl+Oyzzxo9v3PnTjx69AihoaHYuHEj1q1b1+I6lEEikWD27NmIjY1FWVkZPD098euvv6q0BiIiIiIiIlIticAdxkmJZs2aheLi4laFK0+qra2Fu7s78vPzkZSUBB0dHQCPZ4K5uLigtLQUCQkJkEqlyixbITc3F35+fqiursaRI0cwePDgDnnOn925cwdubm548OABTExMFMcrKythbW2N4uJiFBUVNfm+X331VfznP/+BTCZrcqbiJ598gi+++AJbt27F/PnzG5yvqanBlClTcPz4cVRVVSlmnu3duxczZ86EmZkZ4uPjYWFhAeDxrLchQ4YgPDwco0aNqncvmUwGFxcXPP/889i8ebPi+Lx586Curo4tW7bUG3/t2jUMHToU/fv3x71791rwiT1+z+7u7vjggw/Qt29f5OTkoLq6usnx165dg4eHB8LDw/Hyyy83OU5PTw9jxoxBZGRki+pQtpKSErzxxhs4cuQIjhw5goCAAFHqaIn92I/pmA4B/GuEiIiIiIiotThTjpSqvTPlzp49i/j4eEydOlURyAGAuro6ZsyYgfT0dERERCij1AYqKioQEhKC6upqREVFqSyQA4BBgwahqqqqXiAHAFpaWrCzs0NFRUWzSyrz8vKgrq7eZCB3584drF69Gp6eno0GcsDjz7ixmWSvvvoqgoKCkJeXh8WLFyuOL1myBDNmzGgQyAHAmjVrkJOTg+XLl9c7vn379gaBHAAMGTIEOjo6SEpKanEn0h07diA0NLTZZat/fsbUqVPx/vvvNxveGRsbIy8vr0X37Ah6enrYu3cvpk2bhpdeegk3b94UrRYiIiIiIiLqOAzlSKmam6nVEmfOnAGARvcnqzt2+vTpNt+/OZ999hlu3bqFo0ePwtraukOe0VqFhYVISEiAh4cHjIyMmhxXU1PT7H22bt2K2tpaTJs2rdlxI0eOhCAIDYKuzZs3w8TEBP/9739x8OBBHD58GHFxcVixYkWDewiCgO3bt8PHx6fFn2NJSQnKysoU+9i1xJOhbUu98MILyMjIwLFjx5ocI5FImg3tVEFNTQ07duyAh4cHpk+fjsrKSlHrISIiIiIiIuVjKEdK1Vijhzt37iAkJARGRkbQ1dWFt7c3IiIi6jUKmDdvnmIsANja2ja4t42NDQC0eHlja9y7dw/r16/H2rVrMXDgQKXfv7VkMhnOnz+PoKAgWFpaYvfu3e2639mzZwEA7u7ubbreysoK69evBwAsXrwYb7/9Nn744YdGl9Neu3YNubm5GDJkSIvvf+DAAQCPl9h2pKFDhwKAaEtTW0NTUxO7d+9GSkoKvvvuO7HLISIiIiIiIiVjKEdK9edQLjExESNHjsTly5dx8OBBPHjwADt37sSGDRtw/fp1SKVSxcwq4PHMMODxEr4/09fXB/B4LzNl+/bbb9G3b19FOCimzz//HEZGRhgzZgzU1dVx6NAhuLq6NntNZWVls/vsZWVlAYCiaUNb/OUvf8Fzzz2HBw8ewMnJCZ6eno2Oq1tu2Viw2pjc3FyEhoZi3rx5ze71pgx1wW5zS0KlUimqqqo6tI6W6tu3LxYtWoRvvvkGtbW1YpdDRERERERESsRQjpRKJpPV21Nu2bJlKCwsxIYNG/DMM89AX18fLi4u2Lt3L0pKSlp177q9xlq6vLE1jh49ilmzZkFNTfz/JT799FNUVFTg9u3bGDRoEDw8PLBy5cpmr0lLS2tRCNbez65///4AgN9++w1HjhxpdEx2djYANLvctk5eXh4mTZoEX1/feg0hOoqhoSEkEomixsZYW1sjMzNT9CWsdebMmYP09HRcvXpV7FKIiIiIiIhIicRPIKhb+fNMuRMnTgAAnn322XrjzM3NMWjQoAbXGxsbA0CjgV3dsboxyiKXy5Gamgpvb2+l3rc9tLS0MGjQIGzatAlBQUFYvnw5fvnllwbj8vPzsXbtWqSmpuKtt95q8n51e7s9evSozTWdO3cOP/30E9atWwcAWLRoUaOzFusaUmhqajZ7v5KSEjz77LNwdnbGv//9b6irq7e5ttbQ0NBAWVlZk+cXLlwImUyG5cuXt+vzUhZXV1fo6uqy4QMREREREVE3w1COlKampgalpaWKmXIVFRWQy+XQ1tZWLD190p87jQJQBHUZGRkNzmVmZgIABgwYoMyyUVxcDACN1tgZTJkyBQAadJ2dM2cOzMzMEBoaio8++gh//etfm7zH+PHjAQDXr19vUw3FxcWYM2cOtm7divfeew+BgYHIycnBO++802CstrY2ADS7BLS6uhrTpk2DjY0NfvjhB5UFcnXPbq5JxKxZs7Bq1SqsXbsW5ubmmDRpkspqa4xEIoG+vj7kcrmodRAREREREZFyMZQjpSkuLoYgCIqZclKpFAYGBigvL1cEX0968OBBg2N+fn4AgCtXrjQ4V3ds4sSJyiwbZmZmUFdXV+y71tnU7RWXn59f7/iuXbtQVFSE8PBwrFu3DgsXLmzyHgsXLoSGhgYOHjzY7LM++ugjqKmpKRpu1Hn//ffh7++vCKi2bNkCQ0ND/Pjjjw3CQisrKwBAUVFRs/VUVFRg//799Tq9Ojk54ffff2+2xvaQyWQQBEFRY2M++eQTLFu2DJs2bUJhYaFitqdYysrKkJ+fDwsLC1HrICIiIiIiIuViKEdKI5PJAKDe8tXAwEAAaBBs5OTkNNpFdfz48XB2dsbBgwcVyyCBx7PwwsPDYWdnh+eff16pdWtpacHLy6vR5aGq8sEHH2DWrFmNnjt+/DgAYPjw4Q3OGRoaYtq0afDw8Gg2cBswYAD+/ve/4/LlywgLC2t0zN27d7Flyxa8/PLL9ZYWR0ZG4tSpU/j6668Vx+zs7BS/L1y4UNGgA4CiKUVjsx0B4B//+Afi4+Nx5MiRZptTdIS62ZbNNc746aef0K9fP8ybN69F++J1tKioKFRXV2PUqFFil0JERERERERKxFCOlKZued2TjR6++OILmJqa4t1338WpU6dQXFyMmzdvYu7cubC0tGxwDzU1NezYsQP5+fmYO3cucnJykJeXh8WLFyMhIQHbtm1TLI9UphkzZuA///mPqHuI7d27FytWrEBKSgoqKiqQkpKCjz/+GHv27IGnp2eznWENDQ0VoWhTPv30U4SGhmLRokUIDQ3FvXv3UFlZiczMTOzYsQN+fn5wd3fHjh07FNcUFhZi/vz5CAsLqxe2AsD8+fPh7++PrKwsvPfee4rjQ4YMQe/evXHt2rUGNezatQv//Oc/ERMTAwMDA0gkknqvpKSkBtfMmjULEokEycnJzb6/loiLiwMABAQENDlGLpfX+w6LbePGjRg/fryicywRERERERF1DwzlSGkamynn6OiIixcvYvjw4Zg6dSosLCywcOFCLF26FE5OTo3eZ8SIEbhw4QKKioowcOBA9O3bFwkJCYiKimrQMEJZ3njjDRgZGeGDDz7okPs/zfLly7Ft2zZcuHABfn5+MDQ0hJubG06fPo0vv/wS586da3YftJZ2Vf3yyy9x/vx5ZGVlwd/fH/r6+hg8eDC2b9+O0NBQnD59Gnp6egAAW1tbmJiYID09HX5+fggJCVHcp7CwEBKJRDG7cNeuXZBIJPjmm28gkUgwb948xMTENFgS/LTls43Jzs6Gvr4+7O3t6x2PiIhQhHmZmZmoqalR/L59+/ZG73Xo0CHY2Ng8dbZlR3T4bYv//e9/OHHiBJYvXy52KURERERERKRkEkEQBLGLoO7h1KlTCAgIQGFhYYuW/fn7+yM6OrreMlUxHTlyBC+88ALCwsIwZ84csctplcmTJ+Pnn39GbW2t2KUAeLyfnIuLCyZPnozNmze3+T6FhYWwtrbGzJkzsW3btnbVdO3aNXh4eGDv3r145ZVXmhxnaWmJfv364eLFi+16XnslJSXB29sbU6ZMwa5du0StpSn7sR/TMR0C+NcIERERERFRa3GmHCmNXC5XdIrsioKDgxEaGooFCxbgp59+ErucVrG1tYUgCMjNzRW7FACAkZERjh49ioMHD+L7779v0z0EQcBf//pXGBoaYuXKle2q5/79+3jxxRexdOnSZgO5qqoq5Ofnw9bWtl3Pa6+0tDQ888wz6NevH/71r3+JWgsRERERERF1DIZypDQymQy6urpQV1cXu5Q2W7VqFRYsWIDp06djzZo16CoTSeu6oq5evRp5eXkiV/OYh4cHLl++jOPHjz91v7vG5Obm4v79+zh9+nSj+w+2xpYtW7Bq1SqsWrWqyTFFRUVYt24dqqqqFJ+nGKKjozFixAgYGhrixIkT0NXVFa0WIiIiIiIi6jgM5Uhp5HJ5g2YAjQkPD4dEIsHp06dRUVGh2IOsM5BIJPjuu+/w/fff49NPP0VwcHC9zqKdVUhICL766itERkbCxsZG0fVWbH379kVERESbGidYWloiOjoaLi4u7a7jq6++anaG3Jw5c2Bubo7t27fjs88+E2358tatWzFx4kR4enoiKioKvXr1EqUOIiIiIiIi6njcU46UZtWqVdi9ezfu3r0rdilKcfbsWUyfPh26urpYv349goKCxC6JuqmEhAS8++67iIyMxMqVKxEaGtppmk00h3vKERERERERtR1nypHStHSmXFcxbtw4/PHHH/Dx8UFISAiee+45JCQkiF0WdSMlJSVYtmwZ3NzckJ6ejl9//RVLly7tEoEcERERERERtQ9DOVIauVzepmWKnZmVlRX27t2LqKgoZGZmws3NDW+99Rbu378vdmnUhRUXF2P9+vUYOHAgNm3ahLVr1+KPP/7A2LFjxS6NiIiIiIiIVIShHClNd5sp96Rx48bhypUr2LhxIyIjIzFgwAC8+uqruHbtmtilUReSl5eHf/zjH+jbty+WL1+Ol19+Gffu3cOSJUugoaEhdnlERERERESkQgzlSGlkMlm3DeUAQENDAwsWLMDdu3exe/duxMfHw8PDAxMnTsSePXtQVlYmdonUCQmCgOjoaLz++uvo06cPvvvuOyxZsgQpKSlYt24dzM3NxS6RiIiIiIiIRMBQjpSmOy5fbYyGhgZeffVVxMXF4dixYzA0NMTrr78OKysrLFq0CDExMWKXSJ1AZmYmvvzySwwcOBBjx47FtWvX8NVXXyE1NRV///vfYWZmJnaJREREREREJCKulyKl6e4z5f5MIpEgMDAQgYGBKCgowIEDB7Bp0yZs2bIFffr0QXBwMKZMmQJfX18uTewhUlJScOTIEURERCAqKgr6+vp4+eWXER4ejmHDholdHhEREREREXUiTApIabrznnJPY2JiggULFmDBggW4fPky/vvf/+Lw4cPYuHEjzM3NERQUpAjojIyMxC6XlKS6uhqxsbE4fvw4Dh8+jBs3bsDMzAyTJ0/GwYMHMWnSJEilUrHLJCIiIiIiok6IoRwpTU9Zvod6IeMAACAASURBVPo0Xl5e8PLywpdffok7d+7g8OHDOHToEHbu3AmJRAIvLy9MmDABEyZMwOjRo6GjoyN2ydRCtbW1uH79On799VecOXMGv/32G+RyOezt7REcHIxvvvkG48aN48xIIiIiIiIieiqJIAiC2EVQ92BgYICNGzdi7ty5YpfSKT169AhRUVE4c+YMzpw5g7t370IqlcLb2xs+Pj7w8fGBt7c37O3txS6V/k9RURFiY2MRExODS5cu4cKFC3j06BF69eoFX19fTJgwAX5+fhg0aJDYpYpiP/ZjOqZDAP8aISIiIiIiai2GcqQUtbW10NDQwP79+zF16lSxy+kSMjMzcfr0aURHRyMmJgbx8fGoqamBpaUlvL294e3tjaFDh8LFxQV9+/YVu9xur6CgADdu3MCNGzcQGxuLS5cu4e7du6itrYWdnR18fHwwatQo+Pn5wd3dHWpq7JPDUI6IiIiIiKjtGMqRUshkMhgZGSEyMhIBAQFil9MllZSU4MqVK4iJiUFMTAxiY2ORlpYGADA0NISzszPc3Nzg6uoKV1dX9O/fH7a2tpBIJCJX3rXk5+cjKSkJN2/eRHx8PG7cuIH4+HhkZmYCAIyNjTFs2LB6sxetrKxErrpzYihHRERERETUdtz4iJRCLpcDQI9t9KAMenp6GDduHMaNG6c4VlhYiPj4eNy8eVMRHv3000/Iy8sDAEilUjg4OMDJyQmOjo6Kn/b29rC1te2Re/xVVFQgKysLGRkZSExMRFJSkuKVmJiIgoICAIC2tjacnZ3h6uqKiRMnws3NDS4uLlw+TERERERERCrBmXKkFLdv34azszNu3rwJFxcXscvp9nJzc5GQkFAvcKp7PXr0SDFOV1cXdnZ2sLKygq2tLaysrGBjY4NevXrBzMwMpqamij935q6wZWVlyMvLQ35+PvLy8pCXl4eHDx8iNzcXGRkZyM7ORnp6OnJycvDw4UPFdTo6OnB0dFS86kJLR0dH9O3bF+rq6iK+q66PM+WIiIiIiIjajjPlSCk4U061LCwsYGFhgTFjxjQ4V1RUhPT09HphVXZ2Ns6cOYPy8nJUVVXh0aNHqKqqqnedhoaGIqjT1dWFiYkJtLW1oaOjA2NjY0ilUujp6cHQ0FARZpmYmNS7R934OtXV1YrvRp2SkhJUVlYqaq2oqEBxcTHkcjnKy8shl8tRUlKC0tJSRQBXVlbW4H2amZnBwsICNjY2sLa2hoeHB6ysrGBnZwdLS0vY2trC2tq6bR8wERERERERUQdjKEdKIZPJADCU6wyMjIxgZGQEV1dXAI8D05kzZyItLQ3btm3DrFmzFMfz8vLw6NGjBrPQysrKUFBQgPLycpSVlSElJQXl5eUoLS1FUVERamtrnxq4AYBEIoGxsbHi95qaGtTU1MDCwgLA4++LtrY2DAwMoK+vDx0dHZibmyv+XBcSPvmz7s9stEBERERERERdGUM5UgrOlOucMjIyEBwcjLS0NERGRtbbr87AwAAGBgYq7ex69uxZjB8/HmfOnEGfPn1U9lwiIiIiIiKizoZTTUgp5HI5dHV1oaHBnLezuHjxIry8vFBVVYXY2Nh6gZxYhg8fDk1NTVy8eFHsUoiIiIiIiIhExVCOlEImk3GWXCcSHh6OiRMnwtPTE9HR0SqdDdccHR0duLu74/fffxe7FCIiIiIiIiJRMZQjpZDL5QzlOgFBEPCPf/wDM2bMwPz583H06FEYGhqKXVY9I0eO5Ew5IiIiIiIi6vEYypFSyOXyThf+9DTFxcV48cUXsXr1auzatQsbNmzolM0QRowYgatXrzbaUZWIiIiIiIiop+h8/2KnLonLV8WVkZGB8ePHIzo6GidPnsRf/vIXsUtq0siRI1FVVYU//vhD7FKIiIiIiIiIRMNQjpSCM+XE0xkbOjTHwcEBlpaW3FeOiIiIiIiIejSGcqQU3FNOHHUNHYYNG9apGjo8jY+PD/eVIyIiIiIioh6NoRwpBZevqtafGzpERER0qZmKI0aMYChHREREREREPRpDOVIKLl9VnScbOuzcubPTNnRozsiRI5GVlYX09HSxSyEiIiIiIiIShYbYBVD3wJlyqpGRkYHg4GCkpaUhMjIS48ePF7ukNvHy8oKGhgYuXrwIOzs7scshIiIiIiIiUrmuNb2GOi3uKdfx/tzQoasGcgCgp6cHFxcXXL58WexSiIiIiIiIiETBUI6UgstXO1ZXbejQHA8PD8TFxYldBhEREREREZEoGMpRuwmCgOLiYs6U6wBdvaFDc4YOHYo//vhD7DKIiIiIiIiIRME95ajdiouLUVtby1BOyYqLi/Haa6/h+PHj2LlzJ+bMmSN2SUo1dOhQ5OXlISMjA7a2tmKXQ0RERERERKRSDOWo3eRyOQB0mxlcnUFmZiaCg4ORmprapRs6NMfDwwMSiQRXr15lKEdEREREREQ9DpevUrvVhXKcKaccv//+O7y8vFBZWdnlGzo0x9DQEP369eO+ckRERERERNQjMZSjdpPJZAA4U04ZwsPDMWHCBHh4eHSbhg7NGTp0KK5duyZ2GUREREREREQqx1CO2o0z5dqvrqHDq6++2u0aOjTHxcUF8fHxYpdBREREREREpHIM5ajd6mbK6evri1xJ11RSUoKXXnoJq1evRlhYGDZs2AA1tZ7xv6aLiwsSExNRUVEhdilEREREREREKsVGD9Rucrkc2tra0NLSEruULqeuoUNKSkq3bejQHGdnZ1RXV+PevXtwc3MTuxwiIiIiIiIilekZ03GoQ8nl8h6x1FLZnmzocPny5R4XyAHAwIEDoaGhwSWsRERERERE1OMwlKN2k8lk3E+ulfbt26do6HDu3Llu39ChKVpaWnBycsKtW7fELoWIiIiIiIhIpRjKUbvJ5XKGci1U19BhxowZioYORkZGYpclKjZ7ICIiIiIiop6IoRy1G5evtkxdQ4cvv/yyzQ0dfv75ZwwYMAAaGt1nO0hnZ2fcvn1b7DKIiIiIiIiIVKr7/MueRMPlq0/3ZEOHkydPtnr/uKSkJLz33ntITU1Fbm5uB1UpDkdHR9y/fx+1tbU9pussEREREREREf8FTO3GmXLNq2voUFFRgdjY2DY1dPjss88watQoXLlypdsFoE5OTqioqEBGRobYpRARERERERGpDGfKUbvJ5XL06tVL7DI6pX379mHu3LkYP348wsPD27x/3I4dO6Cjo6Pk6joHJycnAEBiYiLs7e1FroaIiIiIiIhINThTjtqNy1cbUnZDh+4ayAGAhYUFDA0NkZiYKHYpRERERERERCrDUI7ajd1X63uyocOOHTuwYcMGqKur1xtz584dhISEwMjICLq6uvD29kZERAT8/f0hkUggkUgwb948kd6B6jk6OiIpKUnsMoiIiIiIiIhUhstXqd1kMhn3lPs/TzZ0iIyMhK+vb4MxiYmJGDlyJPT09HDw4EGMHDkSqampePfdd3H9+nVIpVKUl5ervngROTk5MZQjIiIiIiKiHoUz5ajdOFPusT83dGgskAOAZcuWobCwEBs2bMAzzzwDfX19uLi4YO/evSgpKVFt0Z0EZ8oRERERERFRT8NQjtpFEAQUFxf3+Jly+/btw4QJEzB06FBER0ejX79+TY49ceIEAODZZ5+td9zc3ByDBg3q0Do7Kzs7O6SlpYldBhEREREREZHKMJSjdiktLUVNTU2PnSnX2oYOFRUVkMvl0NbWhr6+foPzJiYmHVlup2VnZ4f8/PweO1OQiIiIiIiIeh6GctQuMpkMAHpkKFdSUoKpU6c229Dhz6RSKQwMDFBeXo7i4uIG5x88eNBR5XZqdnZ2AICMjAyRKyEiIiIiIiJSDYZy1C5yuRwAetzy1czMTPj6+uK3335DZGQk5s6d2+JrAwMDAfz/Zax1cnJycO/ePaXW2VUwlCMiIiIiIqKehqEctUtdKNeTZsrFxMTAy8sL5eXlzTZ0aMoXX3wBU1NTvPvuuzh16hSKi4tx8+ZNzJ07F5aWlh1TdCdnZmYGXV1dpKeni10KERERERERkUowlKN2qVu+2lNmyu3fvx9+fn4taujQFEdHR1y8eBHDhw/H1KlTYWFhgYULF2Lp0qVwcnJq9JqIiAhIJBJIJBJkZmaipqZG8fv27dvb+7Y6BVtbW4ZyRERERERE1GNoiF0AdW09ZaacIAj45z//iRUrVmDJkiVYt27dU/ePa86AAQNw6NChFo+fPHkyBEFo8/O6Ajs7O4ZyRERERERE1GMwlKN2kclkkEql0NLSEruUDlNSUoLZs2cjIiIC27dvx+uvvy52Sd2ShYVFj210QURERERERD0PQzlqF7lc3q1nyWVlZSE4OBjJycmIjIxs9f5x1HLm5uZITk4WuwwiIiIiIiIileCectQucrm82+4nd/XqVYwYMaLNDR1aIzw8HBKJBKdPn0ZFRQUkEgnmzZvXYc/rjMzNzfHw4UOxyyAiIiIiIiJSCYZy1C7ddabc/v37MXr0aDg7O7e5oUNrvPLKKxAEod6ruzRwaCmGckRERERERNSTMJSjdpHJZN0qlBMEAV999RVeeeUVvPbaa4iIiICRkZHYZfUI5ubmKCoqQmVlpdilEBEREREREXU47ilH7dKdlq+Wl5fjjTfewP79+/Hdd9/hrbfeErukHsXc3BwA8OjRI1hbW4tcDREREREREVHHYihH7dJdZso92dDh5MmT8PPzE7ukHqd3794AgIcPHzKUIyIiIiIiom6Py1epXbrDTLm6hg4ymQwXLlxgICcSU1NTAEB+fr7IlRARERERERF1PIZy1C5dfabc/v37MWbMGDg7O+PSpUsYMGCA2CX1WHXfI7lcLnIlRERERERERB2PoRy1S1ftvvpkQ4dZs2axoUMnIJVKoaWlxVCOiIiIiIiIegTuKUft0hVDuScbOnz77bdYvHix2CXR/9HX10dxcbHYZRARERERERF1OIZy1C4ymaxL7SnHhg6dm76+PmfKERERERERUY/AUI7apbi4uMvMlLt69SqCg4Oho6ODCxcucP+4TsjAwIChHBEREREREfUI3FOOWkwmk9X7vbS0FNXV1V1iptyBAwfY0KELYChHREREREREPQVnylGL+fj44M6dO9DX14euri50dXVhZmaGf/7znwgLC4OBgYHi9cknn0BXV1fskiEIAtasWYOlS5di/vz5+P7776Ghwa99Z8VQjoiIiIiIiHoKphPUYpMnT0ZCQgKKi4vrbcafl5eHS5cuQV1dHYIgYNiwYVi1apVKakpPT4ednV2j59jQoeuRSqWoqKgQuwwiIiIiIiKiDsflq9RigYGBqKmpafJ83bklS5aopJ6UlBS4u7vjwoULDc5lZWVh3LhxOHHiBE6ePMlArotQV1dv9jtGRERERERE1F0wlKMWGzt2LPT09Jodo6enh6lTp6qkniVLlqCwsBBTpkxBWlqa4nhcXBxGjBiBoqIiXLhwgR1WuxCGckRERERERNRTMJSjFtPU1ERAQECTe7JpampiwYIFKtlL7uTJk4iIiAAAyOVy+Pv7QyaT4cCBAxg9ejScnZ0RExODgQMHdngtpDxqamqora0VuwwiIiIiIiKiDsdQjlplypQpTYYm1dXVWLBgQYfXUFlZiUWLFkFdXR0AUFVVheTkZAQFBeGVV17BggULcOzYMRgbG3d4LaRcnClHREREREREPQVDOWqVwMBACILQ4Li6ujp8fX0xYMCADq/hq6++QlpaWr3wprq6GufOncPs2bOxfv16RWBHXQtDOSIiIiIiIuopGMpRq1haWsLNza3B8draWpU0eEhLS8MXX3zRaHBTW1uLH374AXv27OnwOqhjMJQjIiIiIiKinoKhHLVaSEgINDU16x0zMzPD5MmTO/zZb7/9drOhjSAIeP3113Hx4sUOr4WUj6EcERERERER9RQM5ajVnnvuOVRVVSl+19TUxNtvv90gqFO2EydO4OjRo/We3Zjq6uoGHVmpa6iuru7w7xERERERERFRZ8BQjlpt+PDhMDU1VfxeW1uLefPmdegzKyoq8Oabbza7V5yamhrU1NSgpaWFgIAA5OXldWhNpHwVFRWQSqVil0FERERERETU4RjKUaupqanh+eefh6amJjQ0NDB58mTY2Nh06DO//vprpKenN7q0sW5mlZubG9atW4esrCzs3bsXHh4eHVoTKV95eTlDOSIiIiIiIuoRNMQugLqmyZMnY8+ePRAEAYsXL+7QZ6Wnp+Pzzz+vF8hpaWmhsrISFhYWmDNnDt544w3079+/Q+ugjldRUQFtbW2xyyAiIiIiIiLqcAzlepCCggIAQElJCSorK1FZWYmSkhLF+aKiItTW1jZ67Z/HlpaWQiKRoFevXigoKMDhw4ehr6/f5LMNDQ0VS0+1tLSgp6cHADAxMQEA6OnpQUtLq9FrlyxZgoqKCqipPZ7YqampiWnTpuH111/H+PHjFcep6+PyVSIiIiIiIuopGMp1QoWFhSgoKEB+fj4KCgogk8lQWlqKkpISFBYWoqSkBCUlJSguLkZRUZHiXFFREYqLi1FVVaX4+ecwTdkePnyI6dOnK+1+fw7sysrKkJ2dDQAwMjJC//79MXjwYBgZGeHkyZO4dOkS9PT0oKenB319fRgZGcHAwACmpqYwMTGBqakpNDT4Ne8qGMoRERERERFRT8G0ogMJgoAHDx7g4cOHyM3NRU5ODh4+fIj8/HzF68nwre5nY7PVpFIpdHV1YWJiAj09Pejq6sLAwACGhoYwMjKClZWV4pyWlhZ0dXUhlUqhoaEBAwMDAI9DLTU1Nejo6EBbWxvq6uowNDRUPKPueGMkEgmMjY3rHdu4cSNmzpwJMzMzlJaWoqKiotFra2trUVRUpPi9vLwcZWVl9Y7LZDLU1NTUO5eXl4fdu3fD0dERDg4O0NDQgFwuR05ODu7fv4/S0lJFSFlaWgq5XN7o8+tCuieDurqfpqam6N27N8zNzWFhYQFLS0uYm5szGBIJl68SERERERFRT8FQrg2qqqqQlZWF9PR0pKWlISsrC9nZ2fXCt7ow7sl90DQ1NWFubg4zMzNFMGRtbQ0XF5cmAyMTE5N6Sz87k7feeksxC01XVxe6urpNjjUzM2v1/SsrK7Fs2TJIJJIWX1NUVAS5XN5s6Jmfn4+UlBT88ccfyMvLw4MHD1BaWlrvPiYmJrCwsEDv3r1hYWGh+LONjQ1sbW1hZ2eHPn36NPueqfXY6IGIiIiIiIh6CoZyjSgsLERiYiLS0tIUwVt6ejoyMjKQmpqKnJwcxWw2TU1NWFpawtraGubm5rC1tcXw4cMVs6/qjvfu3Ru9evUS+Z0pV0cvC21qj7nmGBkZwcjICLa2tq26rqSkBDk5OcjNzcXDhw+RnZ2NBw8e4MGDB8jJyUFcXBwePnyI9PT0egGeqakpbG1tYW9vD3t7e0VgZ29vDwcHB9jY2LQqVOzp8vPzYWpqKnYZRERERERERB2ux4ZyBQUFuH//fpOvOiYmJnBwcICVlRXc3NwQHBwMKysrWFtbw8HBAfb29tyzrBvQ09ODo6MjHB0dnzq2bp+7uu9K3UzJe/fuISoqCqmpqYp9/LS0tGBrawsHB4d6L2dnZwwcOJDfnT8pKCho06xKIiIiIiIioq6m2ycCqampiI+Px82bNxU/ExISFPuPSaVSODg4wMnJCW5ubggJCYGTkxMcHR1hb2/fptla1L3p6OgowrXGCIKAnJwcJCUlITExUfHzjz/+wIEDBxRdcDU1NdG3b1+4urrC2dkZbm5uirCuJ37vioqKUFlZyVCOiIiIiIiIegSJIAiC2EUoQ2FhIa5cuYIbN24owrdbt25BJpMBAGxtbRXBx8CBA+Ho6AgnJyfY2tpCTU1N5OqpJ8nLy1MEdffu3cOtW7cUYXF1dTU0NTXRv39/uLq6wsXFBa6urvD09ESfPn3ELr1D3b9/H46Ojrh8+TI8PT3FLodaYD/2YzqmQ0C3+GuEiIiIiIhIpbpkKFdSUoKrV6/iypUritedO3dQW1sLExMTODs7w8XFRfHT3d0dvXv3FrtsomZVVVUhPT0d8fHxuHLlCm7duoX4+HjcvXsXNTU1MDIyUgR0Y8aMwZgxY2BlZSV22UoTGxsLb29vJCcno2/fvmKXQy3AUI6IiIiIiKjtukQol5ycjKioKJw9exaxsbG4c+cOampqYG5uDi8vL8Vr+PDh3SqkIAKA4uJiXL16FZcvX1a8EhISIAgCbG1t4eXlhdGjR2P8+PEYNmxYp+zU2xInTpxAYGAgZDIZDAwMxC6HWoChHBERERERUdt1ylAuOTkZv/32G3799VdERUUhLS0NOjo68PHxgY+PjyKA6+7L+YiaUlRUpAjoYmNjER0djdzcXBgaGmLs2LEYP348fH19u1RI9+9//xtz585FRUUFO9Z2EQzliIiIiIiI2q5TNHooKyvD6dOn8b///Q8nT55EamoqdHR0MGLECLzxxhvw9fWFj48PpFKp2KUSdQpGRkaYOHEiJk6cqDh269YtREVFISoqCl9//TU++ugjGBoawtfXF5MnT8aUKVNgaWkpYtXNe/ToEczMzBjIERERERERUY8g2ky5R48eISIiQhHElZaWYvjw4Xj++ecZwhG1kyAIipDu5MmTOHXqFCoqKuDt7Y3g4GAEBQXB2dlZ7DLr+dvf/oYLFy7g999/F7sUaiHOlCMiIiIiImo7lYZyJSUlOHDgAHbt2oXo6GhoampiwoQJCA4OxpQpU7gfHFEHKS0txalTp3D06FEcPXoUDx48QP/+/TFz5kzMnTsX9vb2YpeIF198EZqamti3b5/YpVALMZQjIiIiIiJqOzVVPOTSpUtYuHAhrK2tsWjRIlhaWmL//v149OgRjh07hgULFjCQI+pAurq6CA4Oxvbt25GdnY3z588jODgYmzdvRr9+/TBp0iQcOHAAFRUVotWYkpLCrqtERERERETUY3RYKFdRUYFt27bB3d0dPj4+uHDhAlasWIHMzEyEh4fjxRdfhJ6eXkc9noiaoKamhlGjRmHt2rVIS0vDf//7X2hqamLGjBmwtbXFRx99hKysLJXXlZqayuYtRERERERE1GMoPZSrrKzEhg0b4ODggCVLlmD48OH4/fffcePGDbzzzjswMzNT9iNbLSgoCBKJBJ9//vlTx9bU1GDp0qXo378/tLW1ERgY2OTY2NhYzJkzB/369YOOjg5MTU3h6uqKl156CZs2bUJSUpJirL6+PiQSSYOXmpoazM3NERISgtjY2CaflZqaiqCgIMhksgbnfv75ZwwYMAAaGm3v4xEXF4fnn38exsbGMDAwgL+/P86fP99gXGhoaLPLDefOnQupVIp+/frhnXfeQXl5eYue35Hvb8yYMY1+9hKJBO+++269sZs3b25ybN2rqe9ES+p82ufX0TQ1NRESEoKjR48iLS0N7733Hv7973/DwcEBixYtQmZmpkrqkMvlyM/Pb/NMuYKCAmzevBkTJkyAqakpdHR0FMtzr127ptxiiYiIiIiIiJRAqaHcoUOHMHjwYCxduhQzZszA/fv3sWPHDvj4+CjzMe2ye/duHD16tMXjd+zYgdWrV2P27NnIycnB8ePHG4ypra3Fhx9+iFGjRqF37944fvw4CgsLcfv2baxfvx4ymQxvvfUWnJycUF1dDQAoLi7G1atXAQDBwcEQBAGCIKCgoABbt27FxYsXMXr0aPzyyy8NnhcXFwcvLy8EBATA0NBQcTwpKQlBQUFYunQpcnNzW/vRKMTExGDUqFEwMDDA7du3kZycDAcHB/j6+uLkyZP1xs6fPx9Lly7FZ5991ui9du7ciUePHiE0NBQbN27EunXrnvr8jn5/yjZq1Kh6v7emzqd9fqpkbW2NZcuW4f79+9i4cSNOnDiBAQMGYPny5S0OU9sqOTkZANocyn344YdYsmQJgoODcevWLeTl5SEsLAxxcXHw9PTE4cOHlVgtERERERERkRIISvDgwQPhpZdeEiQSifDaa68JaWlpyrit0mVmZgomJibCa6+9JgAQVq5c+dRrZsyYIQAQZDJZk2OWLVsmABC2bt3a6Pnq6mohMDBQACBUVVUpjl+9elUAIAQHBze4Zs+ePQIAwcXFpd7xoqIiwdbWVli4cGGjtX755ZdCVVWVYGNjI6irqz/1/f1ZTU2N4OLiIlhZWQmlpaX13sPAgQMFOzs7oby8vN41cXFxgkQiEfbt29fsvXV1dYWAgIBmx3T0+xMEQRg9erQQGxvborGbNm1q9L+PIAjCvXv3BKlUKmRnZ7erzpZ+fqpWVlYmrFmzRjA0NBQGDhwonD9/vsOedeTIEQGAIJfL23T9G2+8ISxYsKDB8bi4OAGA0L9///aWSI3YJ+wTICjlrxEiIiIiIqIep90z5a5evQovLy9cuXIFJ0+exO7du2FnZ9fe23aI+fPnY9q0aQgICGjxNXl5eVBXV4eBgUGj5+/cuYPVq1fD09MT8+fPb3SMurp6q2dC+fn5AQDi4+NRWFioOL5mzRrk5ORg+fLlDa7ZsWMHQkND27Vs9ezZs4iPj8fUqVOho6OjOK6uro4ZM2YgPT0dERER9a4ZMmQIpk6divfff18xE7AxxsbGyMvLa/b5Hf3+WsvJyQljx45t9Ny3336LkJAQWFpa1jve2jpb+vmpmra2Nj788EPcvHlTMVPyX//6V4c8KykpCRYWFtDX12/T9du3b8eWLVsaHB8yZAh0dHSQlJQEQXWNpomIiIiIiIieql2hXExMDMaPH4++ffvi0qVL8Pf3V1ZdShcWFob4+Hh8/fXXrbqupqam2fNbt25FbW0tpk2b1uy4kSNHQhCEFgc1TwYIEolEcWz79u3w8fGBtbV1g2ueDNHa6syZMwAALy+vBufqjp0+fbrBuRdeeAEZGRk4duxYk/eWSCTNhk6qeH+t5e/vj/fff7/BcblcRFSk5AAAIABJREFUjh9++AFvvfVWg3NtqbMln59Y7OzscOzYMaxcuRJLlixp0V6MrXXt2jW4u7sr/b4lJSUoKyuDq6ur4v8jIiIiIiIios6gzaFcWloaAgMD4efnh19++QXm5ubKrEupMjIy8P777yMsLKzJGW9tdfbsWQBQeqAQFRUFAHBxcYGRkRGAx8FFbm4uhgwZotRnPenOnTsAAFtb2wbnbGxsAAD37t1rcG7o0KEAgMjIyDY/WxXvr86PP/6IoUOHQk9PD0ZGRhg7diz27t3b4ut37twJe3t7jBs3Tin1KOPz60gSiQQff/wxNm3ahOXLl+PHH39U6v2vXbvW4L/7nTt3EBISAiMjI+jq6sLb2xsRERHw9/dXNNmYN29es/c9cOAAAOCTTz5Rar1ERERERERE7dXmUO7NN9+ElZUV9u3bB01NTWXWpHTz5s3Dq6++igkTJrT62srKSkil0ibPZ2VlAYDSusrKZDIcOnQIf/vb36CpqYlvvvlGce7mzZsAGg/MlKVuqayenl6Dc3VLCwsKChqcqwvs6mpsjFQqRVVVVZPnVfH+6hQUFCAsLAwPHjzApUuX0K9fP8ycORN//etfn3qtIAj4/vvvG50l11Yt+fw6gwULFuC9997DkiVLlNZso7q6Grdv364XbCcmJmLkyJG4fPkyDh48iAcPHmDnzp3YsGEDrl+/DqlUqphZ2ZTc3FyEhoZi3rx5ePnll5VSKxEREREREZGytCmUu337No4fP45169ZBW1tb2TUp1bZt25CQkIA1a9a06fq0tLQWhUTtWRp35MgRxcwfY2NjzJ8/HyNGjMD58+frLQnOzs4GAMXMOVWrW1Lb2Hs1NDSERCJR1NgYa2trZGZmNrmEVVXvLzo6Grt378awYcOgp6eHgQMHYvfu3fD29sa3336LmJiYZq8/fvw4srOz8dprrymtppZ8fp3F559/Dk1NTezYsUMp97t9+zYqKirqzZRbtmwZCgsLsWHDBjzzzDPQ19eHi4sL9u7di5KSkqfeMy8vD5MmTYKvry/+H3t3HhZVufgB/Dsssu+LbIKKgImAhnuaqKgohI6i5tbVsktes7wtXpdsfaxMr6XdrppoVuZVw5TcFzS9bph4JVwSBERkFUZmGHZm5veHD/MTGRCHgQPM9/M8POo5Z97zPXPt9vR93ve8Gzdu1ElOIiIiIiIiIl3SqpQ7c+YMbG1tn2rDBCHcvXsX7777LrZu3apx5ldjJBIJVq9ejczMzEZnRNW++6ywsFDrnBMmTIBKpYJKpYJSqURhYSHi4uLQv3//OtdVVFQAQIvOTLS1tQUAjcVH7bHaax5nZGSE8vLyBseOjo6GTCbD+++/r/H7ao3na0xUVBQAYP/+/Y1et379erz00ktab0rQkCd9f22FmZkZIiMj1Uusm+uPP/5Ap06d0LNnT/WxI0eOAADGjh1b51onJ6c612lSWlqKsWPHolevXvjpp59gaGiok5xEREREREREuqRVKVdUVAQHB4c2/+L0/fv3QyqVIiQkRD0TTSQSqWc4rVixQn3s9u3b6s/NmTMHDg4OWLJkCRYvXtzoksbhw4cDeFgstLTaWYmNLQFtrtrC4969e/XOZWdnAwB8fX01frampqbRTQ5mzZqFlStXYvXq1XByckJYWFid863xfI1xdXUFABQUFDR4TUpKCo4dO6bTpau1nvT9tSXOzs5P3Em3qZKSkvDMM8+gU6dOAIDKykqUlJTA1NRUY/FpZ2fX4Fg1NTWYMmUK3N3d8f3337OQIyIiIiIiojZLq1KuW7duyMrKgkwm03UenVqwYIF6BtqjP7Uvqf/kk0/Ux3r06KH+3LZt2yCVSrFz506sXbsW0dHRDd4jOjoaRkZGiI2NbTTL4sWLYWBgoN5IQRu1pZFUKtV6jCcZMWIEACAxMbHeudpjo0aNqndOJpNBpVKpM2qyfPlyLFu2DBs2bEBxcbF6NlSt1ni+xtS+H9DZ2bnBa9avX4/nn38evXr10um9m/L9tSXJycno3r27zsZ69H1yJiYmsLKyQkVFBeRyeb3rGytNo6OjUVlZid27d9fZ6bhHjx64ePGiTvISERERERER6YJWpdz48eNhZGSEb7/9Vtd52gxra2tMmTIFffv2bbRw8/X1xQcffIDLly9j69atGq+5desWNm3ahKlTpz5x6V1jevfuDUDzLDZdGT58OHr16oXY2Fj1clIAUCgU2LlzJ7p06YLw8PB6n6udRVebUZNffvkF3bp1w7x58zS+N641ni8mJgbBwcH1jqtUKuzevRsA8MILL2j8rEwmww8//IAFCxboPFdTvr+2IiUlBUePHsWUKVOaPZZSqcSlS5fq/W8ybtw4AKhX3Obl5Wnc/RcAPvzwQ1y/fh1xcXGNbs5CRERERERE1BZoVcrZ2NjgnXfewQcffNDmd4tsLmtr6yfOCHzvvfewZMkSvPbaa1iyZAlSUlJQVVWF7OxsbNmyBSNGjEBgYGCzX4wfFBQEZ2dnJCUlNWucWrNmzYJIJEJGRob6mIGBAbZs2QKJRIK5c+ciLy8PRUVFWLBgAVJTU7F582aNm3tcvXoVABp9z2BJSQmsra0bPK/L57tz5w4MDQ0hEolw5cqVOueuXLmCBQsW4Pbt26ioqMCtW7cwe/ZsJCYmYuHChRg4cKDGMbdu3QpLS0uIxeJm53tcU76/tqC8vBwvvfQSgoKCdPI9JCcnQyKRICQkpM7xTz/9FPb29li0aBGOHz8OuVyOa9euYe7cuXBxcak3zrZt2/DRRx8hISEBVlZWdZari0QipKWlNTsrERERERERkS5pVcoBD5ci9u/fH2PGjMHNmzd1manFvPbaaxrfKff4u80e1dT35n322Wc4d+4ccnJyEBoaCktLSzzzzDOIiYnBkiVLEB8fX2ezCUtLS/Tt2xfA/++++qRZdCKRCPPmzUNCQoJ6qeWjDhw4oC4hsrOzoVAo1H+OiYmpd31ubi4sLS3h6elZ5/igQYNw/vx5SKVS+Pn5oWvXrkhNTcVvv/1W78X7tfbu3Qt3d3eNs+gef4bWer7aMR/dOGL27Nn4+eefkZubi7CwMNja2mLgwIHIzs7Gjh07sH79eo3jqFQqfPPNN3j11VfrLIvURJucTf3+hFReXo4pU6YgNTUV27dv18mGHKdPn4adnR0CAgLqHPf29saFCxfQv39/REVFoXPnzoiOjsbSpUvrLDWv9aTl40RERERERERtjUilUqm0/XBJSQnGjRuHa9euYfv27YiIiNBltjYhIiIChw4dglKpFDoKgIfvW/P390dERAQ2btyo9TjFxcVwc3PDzJkzsXnz5mZlSkpKQt++fbFjxw68+OKLDV7n4uKCbt264cKFCw1eo6vna0+a+v0JKTMzE5MnT0ZGRgYOHz6MAQMG6GTcyZMno6amBnFxcU3+TGhoKM6ePVtneTUJYzd2YxqmQQWt/zVCRERERESkt7SeKQcAVlZWiI+Px+TJkxEZGYl58+ahuLhYV9naBA8PD6hUKuTn5wsdBcDDpcP79+9HbGwsvvnmG63GUKlUeOONN2BtbY1PPvmkWXnS09MxadIkLF26tNFCqbq6GhKJBB4eHo2Op4vna0+a+v0JRalUYuPGjQgMDERVVRUuXbqks0JOpVLh7Nmz6h2MiYiIiIiIiPRJs0o54OFOiVu2bMGvv/6KI0eOwNvbG6tWrUJlZaUu8gmudmnr559/jqKiIoHTPNS3b19cvnwZhw8f1moH3Pz8fKSnpyM+Pl7j+7mexqZNm7By5UqsXLmywWukUinWrl2L6urqRpcK12ru87UnTfn+hHLy5En0798fCxcuxPz583Hp0iV4e3vrbPwbN26goKCApRwRERERERHppWYtX32cXC7HmjVrsGrVKjg7O+Ott97Cq6++CnNzc13dQhBffPEFtm3bhvT0dIwYMQKHDx8WOlK7MWfOHOzYsQNeXl6YPn06PvjgAxgaGgodixpx9uxZrFq1CgcOHEBoaCjWrFmDoKAgnd/n3//+N5YuXQqJRNKkvxM7d+7E9OnT6xx75ZVXGnxPH7U8Ll8lIiIiIiLSnk5LuVp3797F6tWrsWXLFlhYWGD27Nl45ZVX4O/vr+tbEZEOFBUV4aeffsKWLVvwxx9/YPTo0Vi+fHmLzmKbOnUqSktLcfDgwRa7B7UslnJERERERETaa/byVU08PT3x9ddfIyMjA4sWLUJcXBx69+6NwYMHIyYmBiUlJS1xWyJ6CkqlEseOHcOLL74Id3d3vPfeexgwYAB+//13HDt2rEULucrKShw5cqRN7zZLRERERERE1JJaZKbc41QqFU6dOoWtW7diz549MDQ0xPjx4xEZGYnx48fD3t6+pSMQER5uuHH69GnExcUhLi4OWVlZGDp0KF5++WVMnToVFhYWrZLj119/hVgsRlZWFtzc3FrlnqR7nClHRERERESkvVYp5R714MED7N69G3v37sWpU6egVCoxbNgwREZGYsKECejWrVtrxiHq8KRSKQ4fPoy4uDgcOXIExcXFCAoKQmRkJGbOnAk/P79WzzRnzhykpqbi3LlzrX5v0h2WckRERERERNpr9VLuUTKZDEeOHEFcXBwOHz6MBw8e4JlnnsGIESMwfPhwDB8+HJ07dxYqHlG7VFZWhgsXLuD06dM4deoUEhISoFKp8Pzzz6vL765duwqWr7q6Gi4uLli2bBnefvttwXJQ87GUIyIiIiIi0p6gpdyjampqcPr0aRw/fhy//fYbEhMTUVNTg169emH48OEICQnB888/DxcXF6GjErUpj5dwly5dQlVVFby9vTF8+HCMGjUK48aNg52dndBRAQDHjx/HmDFjkJaWhu7duwsdh5qBpRwREREREZH22kwp97jS0lJcuHABZ8+exblz53DmzBlUVVXB1dUVwcHB6p/BgwfD0dFR6LhEraKmpga3bt1CYmKi+ufy5cuorKyEq6srhg4ditDQUIwZM0bQ2XCNmT9/PhISEnDlyhWho1AzsZQjIiIiIiLSXpst5R4nl8tx/vx5/P7777h8+TJ+//13ZGdnQyQSwcfHB/3790e/fv0QGBiIgIAAODk5CR2ZqFnKyspw8+ZNJCcn4/Lly7h8+TKSkpJQUVEBKysrPPvss+q/98899xw8PDyEjvxESqUSHh4emD9/PlasWCF0HGomlnJERERERETaazelnCa5ubl1SrrLly+jsLAQAODk5ITevXujV69e6N27N/z9/dG7d+82s4SPqFZlZSVu3ryJGzdu4Nq1a+pfMzIyoFQqYWpqij59+qBfv37qEq5nz54wMDAQOvpTq126evPmTfTs2VPoONRMLOWIiIiIiIi0165LOU1yc3Nx/fp1dbmRnJyMGzduQCaTAQDc3Nzg5+eHHj16oEePHvD29lb/3sLCQuD01FHV1NTgzp07SEtLw+3bt9U/KSkpSE9PR01NDYyNjeHr66sukHv16oWAgAB4e3vD0NBQ6EfQienTp+Pu3bvcdbWDYClHRERERESkvQ5XyjXk7t276pIuNTUVt2/fRlpaGu7duwelUgkAcHFxURd0PXr0gKenJ7y8vODh4QF3d3eYmJgI/BTUVqlUKuTl5eHu3bvIzs7G3bt31cVbWloa7ty5g5qaGgCAg4NDnTLY398f/v7+8PX1hbGxscBP0nKKi4vh5uaG9evXY968eULHIR1gKUdERERERKQ9I6EDtBZPT094enoiLCyszvHKykqkp6fXKVBu376Ns2fPIisrC5WVleprXVxc4OHhAQ8PD3h6eqJLly7w8PBAly5d4OzsDFdXV1haWrb2o1ELq6qqQkFBAfLy8pCTk4O7d+/i3r17uHfvHjIzM3Hv3j3k5OSgqqoKACASieDi4qIu3oYOHVpnZqa+LqHevn07DAwMMG3aNKGjEBEREREREQlOb2bKaSsvLw9ZWVm4d+8esrKy6hUyeXl56hlQAGBubo7OnTvDxcUFzs7OcHFxQefOndWlnbOzM+zt7WFvbw87OzvOvhOASqWCRCLBgwcPUFRUhPv37+P+/fvIyclBQUEBCgoKkJubi4KCAuTn50MikdT5vJOTk7qcrZ1J+WhR6+bmhk6dOgn0dG2TSqVCr169MHz4cGzcuFHoOKQjnClHRERERESkPZZyzaRQKJCXl6f+uX//PvLy8pCfn1+n3Ll//z4KCgrqfd7c3Fxd0NX++ujv7e3tYWlpCXNzc9jY2MDKygrm5uawsLCAra0tLCws9KrYUyqVkEqlkMvlKC0tRWlpKYqLi1FWVobS0lLIZDJIpVI8ePBAXbw9/mtxcXG9cS0tLdWlqZOTE9zc3ODs7FynTO3cuTPc3NxgZmYmwJO3b0ePHkVYWBiSkpIQGBgodBzSEZZyRERERERE2mMp14pqampQUFCgLoc0FUaafi+Xy1FRUdHguIaGhrC2toa1tTXMzc1hbm6uPgYANjY2MDAwgJmZGUxNTeucs7a2rrOJgLm5eYMlX0PnaosyTTSdk8lkUCgUKC8vR0VFBRQKhXojjtpzFRUVKC8vR3V1NeRyOaRSKcrKylBeXv7E78HGxqbRkvPRY/b29nBycoK5uXmD41LzRUREoLy8HPHx8UJHIR1iKUdERERERKQ9vXmnXFtgZGQENzc3uLm5PfVna8utkpISlJaWoqysDA8ePFD/vqSkBFKpFKWlpaioqEBVVRVKS0sBAA8ePAAAFBYWoqqqSl10AQ9fvq9SqVBcXAwrKyvI5XL1xhePqy3MNHm03FMoFFAoFOolnI8Xf5aWljA2NoaJiQnMzc0hEolga2sL4OHuuMbGxujUqRMsLCzqFY6PzhC0sLCApaUlbG1tYW5uDlNT06f+Xqnl3bhxA4cPH8aePXuEjkJERERERETUZrCUaycMDAzUM7x07dixYxg7dizOnz8PPz+/Zo+3evVqfP7558jPz4eREf+K6buVK1fCz88PkZGRQkchIiIiIiIiajMMhA5Awvvxxx8xaNAgnRRyACAWiyGRSHDmzBmdjEftV1paGnbv3o0VK1bAwID/d0NERERERERUi/+VrOdKS0uxb98+zJ49W2dj9ujRAwEBAdi7d6/OxqT2aeXKlfDy8sKUKVOEjkJERERERETUprCU03OxsbGoqqrC1KlTdTquWCzG3r17wX1E9NedO3ewfft2LF++nMuYiYiIiIiIiB7DUk7P/fTTTwgPD4ejo6NOxxWLxcjOzsbvv/+u03Gp/VixYgW8vLwwa9YsoaMQERERERERtTks5fSYVCrF6dOnERUVpfOx+/Tpg+7du3MJq55KSkrCjh078Nlnn8HY2FjoOERERERERERtDks5PXb48GEolUqMGzeuRcafOHEi9uzZ0yJjU9v2zjvvoF+/fpg8ebLQUYiIiIiIiIjaJJZyemz//v0YNmwY7OzsWmR8sViM1NRU3Lhxo0XGp7bp0KFDOHHiBD7//HOIRCKh4xARERERERG1SSzl9JRCocDRo0fxwgsvtNg9hgwZAhcXFy5h1SPV1dVYvHgxIiMjMWLECKHjEBEREREREbVZLOX01NmzZ1FUVISIiIgWu4eBgQEiIyNZyumRL7/8Erdv38bq1auFjkJERERERETUprGU01MnT56Et7c3fHx8WvQ+YrEYiYmJyMjIaNH7kPCysrLwySefYNmyZfD19RU6DhEREREREVGbxlJOT/33v//FsGHDWvw+o0aNgq2tLX799dcWvxcJ680334SLiwsWL14sdBQiIiIiIiKiNo+lnB6qqanB77//jueee67F72VsbIxx48ZxCWsHd/DgQezduxfffPMNTE1NhY5DRERERERE1OaxlNNDV65cgVwub5VSDni4hPXs2bO4f/9+q9yPWldxcTFee+01TJ8+HWPGjBE6DhEREREREVG7wFJOD507dw4ODg7o2bNnq9xv3Lhx6NSpE/bv398q96PW9fe//x2VlZVYt26d0FGIiIiIiIiI2g2WcnooISEBgwcPhkgkapX7WVpaIjQ0lEtYO6BDhw5h27Zt2LhxI5ycnISOQ0RERERERNRusJTTQzdv3kTv3r1b9Z5isRjHjx+HTCZr1ftSyykuLsZf//pXzJgxA5MmTRI6DhEREREREVG7wlJOzyiVSty+fRu+vr6tet/IyEgoFAocOXKkVe9LLSc6OhpKpRLr168XOgoRERERERFRu8NSTs9kZWWhrKwMfn5+rXpfBwcHDBs2jEtYO4iYmBjExsbi+++/h4ODg9BxiIiIiIiIiNodlnJ6JiUlBQBafaYc8HAJ68GDB1FRUdHq9ybduXHjBt58800sXrwYo0ePFjoOERERERERUbvEUk7PpKSkwN7eHo6Ojq1+70mTJkEul+PkyZOtfm/SjcrKSsycORP+/v746KOPhI5DRERERERE1G6xlNMzWVlZ6Nq1qyD3dnd3R3BwMJewtmMLFy7EnTt3sGvXLnTq1EnoOERERERERETtFks5PVNcXAxbW1vB7i8Wi7Fv3z4oFArBMpB2fvjhB8TExCAmJgbdunUTOg4RERERERFRu8ZSTs9IpVLY2NgIdv+oqCgUFhbi/PnzgmWgp/e///0Pr732GpYvX47JkycLHYeIiIiIiIio3WMpp2d0WcpdvXoV4eHhsLW1hZWVFUJDQ3Hu3LlGP+Pr64uePXu22BLWQ4cOwdfXF0ZGRi0yvj4qKirC5MmT8dxzz+HDDz8UOg4RERERERFRh8BSTs/oqpRLSEjAkCFDYGVlhZs3byIjIwPdu3dHSEgIjh071uhnxWIxfvnlF6hUqmbnqJWWlobIyEgsXboU+fn5OhtX31VXVyMqKgoAsGvXLhgaGgqciIiIiIiIiKhjYCmnZ0pKSmBlZdWsMZRKJV555RXY2triu+++g6urKxwdHbFhwwZ4e3tj3rx5qKysbPDzYrEYmZmZuHr1arNyPGrFihUYMmQIEhMTm/189P/mz5+PxMRE7Nu3D/b29kLHISIiIiIiIuowWMrpGYVC0ezZTmfOnMH169cRFRUFMzMz9XFDQ0NMnz4dWVlZOHDgQIOf79evHzw9PXW6hHXLli1YsmQJl63q0BdffIHvvvsO27dvR2BgoNBxiIiIiIiIiDoUlnJ6xsTEBNXV1c0a4+TJkwAelmuPqz0WHx/f4OdFIhEmTJig01Lu0XKQmu/gwYNYtmwZ/vnPfyIyMlLoOEREREREREQdDks5PWNiYqJxaemff/6JiRMnwsbGBubm5hgwYAAOHDiA0NBQiEQiiEQizJs3T30tAHh4eNQbx93dHQCQkpLSaA6xWIxr167h1q1bGs8/TR7SrUuXLmHatGmYN28eFi1aJHQcIiIiIiIiog6Ja/30jL29PYqKiuocu337NgYPHgwLCwvExsZi8ODByMzMxKJFi/DHH3/AxMQEFRUV6uuLi4sBABYWFvXGt7S0BAA8ePCg0RzPP/88HB0dERcXh8WLFzcrD+lOSkoKIiIiMHz4cHz99ddCxyEiIiIiIiLqsDhTTs84OTmhoKCgzrFly5ahuLgY69atw+jRo2FpaQl/f3/s2LEDpaWlTzV+7Y6qIpGo0esMDQ3xwgsvaFzCqss81HS5ubkICwtD165dsWvXLhgbGwsdiYiIiIiIiKjDYimnZzp37ozc3Nw6x44cOQIAGDt2bJ3jTk5O6NmzZ70xbG1tAUBjQVZ7rPaaxojFYiQkJODevXvNykPNJ5PJEB4eDkNDQxw4cEA945GIiIiIiIiIWgZLOT3j7e2N27dvq2e0VVZWoqSkBKamphqLGDs7u3rHaouxx8s0AMjOzgYA+Pr6PjHLmDFjYGlpiV9//VV9TJs81DxlZWV44YUXkJ+fj+PHj8PZ2VnoSEREREREREQdHks5PePr64uSkhLk5eUBeLjxg5WVFSoqKiCXy+td//hSVwAYMWIEACAxMbHeudpjo0aNemIWExMTjB07ts4SVm3ykPaqqqowZcoU3LhxA0ePHkXXrl2FjkRERERERESkF1jK6ZlnnnkGAJCcnKw+Nm7cOAD/v2y0Vl5ensZdVIcPH45evXohNja2zoYLCoUCO3fuRJcuXRAeHt6kPGKxGKdPn4ZEItE6D2mnuroaU6ZMwblz53D48GH07t1b6EhEREREREREeoOlnJ7p3LkzunXrhgsXLqiPffrpp7C3t8eiRYtw/PhxyOVyXLt2DXPnzoWLi0u9MQwMDLBlyxZIJBLMnTsXeXl5KCoqwoIFC5CamorNmzfD1NS0SXnCw8MhEolw4MABrfPQ01MoFJg5cyZOnTqFI0eOoF+/fkJHIiIiIiIiItIrLOX00ODBg+uUct7e3rhw4QL69++PqKgodO7cGdHR0Vi6dCl69OihcYxBgwbh/PnzkEql8PPzQ9euXZGamorffvut3gYNjbGxscHIkSPrLGHVJs+BAwcgEokgEomQnZ0NhUKh/nNMTEyT8+iDmpoazJw5EwcPHsT+/fsxaNAgoSMRERERERER6R0joQNQ6wsJCcGiRYtQXl4OMzMzAA/fNfdoMdYUffv2xaFDh5qdRywWY9GiRSgtLYWFhYVWeSIiItSbV1DDFAoF/vKXv2D//v3Yv38/hg8fLnQkIiIiIiIiIr3EmXJ6KDIyEhUVFYiPjxc6CgBgwoQJqKqqwrFjx4SO0qHVbuoQFxeHAwcOYOTIkUJHIiIiIiIiItJbLOX0UOfOndGvXz/s27dP6CgAHuYZPHjwU8/Uo6YrLy/H5MmTER8fj2PHjql30CUiIiIiIiIiYbCU01MzZszArl27UFJSovH8zp07IRKJEB8fj8rKSohEIsybN6/F8ojFYuzfvx9VVVVtIk9HUlxcjLCwMJw/fx7Hjh3DkCFDhI5EREREREREpPdEKr6ISy9JJBK4u7vjX//6F1555RWh4+DOnTvo1q0bjh07htGjRwsdp8PIy8vDuHHjkJ+fjyPq7z93AAAgAElEQVRHjiAwMFDoSNSB7MZuTMM0qMB/jRARERERET0tzpTTU/b29oiKisLXX3/dJjZI6Nq1K/r06cMlrDqUnp6OYcOGoaKiAhcvXmQhR0RERERERNSGsJTTY0uXLkVycjL2798vdBQAD5ew7t27F0qlUugo7V5iYiIGDx4MOzs7nDlzBp6enkJHIiIiIiIiIqJHsJTTY7169UJkZCQ++uijNjFbTiwWIy8vDwkJCUJHaddOnTqFkSNHIiAgAPHx8XBychI6EhERERERERE9hqWcnnvvvfdw5coVHDt2TOgoCAgIgK+vL5ewNsPevXsxfvx4RERE4PDhw7CyshI6EhERERERERFpwFJOzwUHByM8PBxLliyBQqEQOg4mTJjAUk5L69evR1RUFKKjo/Hjjz/C2NhY6EhERERERERE1ACWcoQvv/wSN2/exObNm4WOArFYjNu3byM5OVnoKO1GdXU1XnvtNfz973/Hp59+iq+++goGBvxHm4iIiIiIiKgt43+5E3x8fPD6669j+fLlKCwsFDTLwIED4erqytlyTSSRSBAWFobt27cjNjYW//jHP4SORERERERERERNwFKOAADvv/8+OnXqhPfff1/QHAYGBlzC2kQpKSkYMmQIUlJScPr0aYjFYqEjEREREREREVETsZQjAIC1tTXWrFmDTZs24eTJk4JmEYvFuHr1KtLT0wXN0ZYdPXoUAwcOhL29PS5fvozg4GChIxERERERERHRU2ApR2ozZ87EpEmT8Je//AUPHjwQLMeIESNgZ2eHffv2AQDKysqwd+9evPTSS9i4caNgudqKdevWITw8HOPGjUN8fDw6d+4sdCQiIiIiIiIiekos5aiODRs2oLq6Gm+//bZgGYyNjTF69Ghs2rQJYrEY9vb2mDx5MrZv347y8nLBcgmtqqoKL7/8Mt5++22sXLkSO3bsgJmZmdCxiIiIiIiIiEgLRkIHoLbF0dERGzduhFgsxvjx4xEVFVXnfGxsLBQKBaZNm6bzexcWFuLQoUPYuXMnjh07BqVSibS0NCgUCgAPyzoTExOd37c9yMrKwrRp03Dt2jX88ssviIyMFDoSERERERERETUDSzmqZ+LEiZg/fz5efvll9O7dGz179gQA/PDDD5g7dy6eeeYZnZZyFRUVCA8Px6lTp2Bg8HDyZm0RV/srAKhUqg5ZytXU1MDIqOF/FA8ePIiXXnoJzs7OuHDhAvz9/VsxHRERERERERG1BC5fJY3WrVuHwMBATJw4ETKZDBs2bMCcOXOgVCpx/fp1nDhxQmf3MjU1RVRUFFQqFRQKRZ0i7lFKpbLDlXJHjx7Fyy+/rPGcQqHAhx9+iMjISIwfPx6XL19mIUdERERERETUQbCUI42MjY3xn//8BxKJBGFhYViwYAFUKhUAwMjICKtWrdLp/ebPn48XX3yx0RljHa2Uy8/Px4wZM/Djjz9i9+7ddc7dv38f48aNw6pVq7B27Vr8+OOPsLCwECgpEREREREREekaSzlqUJcuXRAVFYULFy6oCzng4XLLEydOICkpSaf327x5M7y8vBot5kxNTXV6T6GoVCrMnj0bJSUlEIlEePXVV5GdnQ0AOHPmDIKCgpCSkoLTp0/jzTffFDgtEREREREREekaSznSSKVS4Z133sGGDRs0njc2NsbatWt1ek9LS0vs3btX/V45TTrKTLkvv/wSJ06cQHV1NVQqFcrLyzFr1ix89dVXCA0NRf/+/fG///0PAwYMEDoqEREREREREbUAlnJUj0qlwhtvvNFo6VZdXY2ffvoJ9+7d0+m9AwICsH79eohEIo3nO0Ipl5ycjCVLltSZfVhdXY0zZ87g+++/xyeffIJ9+/bBzs5OwJRERERERERE1JJYylE9r7/+Ov71r3/VKY00MTAwwDfffKPz+0dHR2PGjBkwNjaud669l3KlpaUQi8Uav9vaTTTCw8MbLCWJiIiIiIiIqGNgKUf1fPTRR1i8eDFMTU01FmO1qqur8c0330Aul+s8w8aNG+Hl5VXv/u29lHv99deRmZmJmpoajedVKhWmT5+OqqqqVk5GRERERERERK2JpRzV4+joiFWrViErKwtvvfUWTExMGiznysvLERMTo/MMDb1frj2Xcnv27MG2bdsaLOSAh5to3Lx5E5988kkrJiMiIiIiIiKi1sZSjhrk6OiIzz//HHfv3sVbb72FTp06oVOnTnWuqampwerVqxstmrTVu3dv/Otf/6pzrL2WcpmZmZgzZ06TlqWqVCp8+umnuHDhQiskIyIiIiIiIiIhsJSjJ3J2dsbnn3+O27dvIzo6GsbGxnVmzuXl5SE2NrZF7j1v3jzMnDlTXWY9Xgq2BzU1NZg2bRoqKys1vktOJBKpv09bW1u8+OKL+P7779GjR4/WjkpERERERERErUSketLb/Ikek56ejo8//hjbt2+HoaEhqqurERgYiKtXrz71WMXFxVCpVJDL5aiurkZFRQXKy8sBPCyzSkpKUFFRgddeew3Z2dn4+eefYWtrC6VSCalU2uC4ZmZmMDU11XjO1NQUZmZmAABDQ0NYW1sDgHq3UysrKxgZGT31szTkgw8+wMqVK6FQKNTHjI2NUVNTA5FIhICAAISFhSEiIgJDhgypt2SXqK3ajd2YhmlQgf8aISIiIiIielos5ajJysrKUFRUBIlEgqKiIvz555/Yvn07Ll68CJVKhdmzZ8Pe3h5yuRwymQxSqRRyuRylpaUoKSlBVVUVSktLn1iotRW1xV6nTp1gYWEBExMTWFpawsbGBtbW1rC0tISFhQWsra1hY2MDS0tL9Y+dnR2sra2Rnp6OmTNnQqlUwtDQEAqFAu7u7oiMjMTYsWMxcuRIWFlZCf2oRFphKUdERERERKQ9lnJ6rKCgAAUFBcjJyUFeXh7u37+PwsJCFBYWqos3iUSi/n1FRUW9MUxMTGBqaoqamhoYGhoiICAAFhYW6uLKwsIClpaWsLa2bnRWmrm5OUxMTNQFWC1bW1v10tUdO3Zg8uTJ6vfK2djYNDirTCaT1ZmZ9qiSkhL1O/Cqq6shl8vrFIVSqRRKpbLe7L3y8nLI5XKUlJTUKxyLi4tRWloKuVyucTdakUgECwsLODs7w8XFBQ4ODrC3t4e9vT0cHBzUxzt37gw3Nzc4Ozu3y6W6pF9YyhEREREREWmPpVwHVFJSgrt37yIjIwN3795FXl4esrOzUVBQgNzcXOTl5aGgoADV1dXqz5iamsLZ2RkODg5wdHRUl0aPl0eP/mpjY1Pn3XLJycnw8/NjmYSHy3KPHz8OiUSCLl26QCaT1Zll+HjpmZeXB5lMVmcMJycnODs7w9XVVV3Yubu7w8PDA15eXvD09ISLi4tAT0jEUo6IiIiIiKg5WMq1QzKZDKmpqbhz5w4yMzORmZmJO3fu4O7du8jMzMSDBw/U19rb28PNza1OsVM7E8vd3V1d+tTOXCPhlJeXIy8vD7m5ucjPz0dOTk6dmYy153Jzc6FUKgE8LFO9vLzUJV3t7728vODj4wNXV1eBn4o6MpZyRERERERE2mMp10ZVV1cjKysL6enpuH79Om7cuIH09HSkp6cjIyNDvYunnZ0dunfvju7du8PV1RVubm7qP3t7e8PW1lbgJyFdq66uxv3795Gbm6v+O5Geno6cnBzk5ubi1q1b6iW0JiYm8Pb2hr+/v/rvRffu3dG7d2/OsqNmYylHRERERESkPZZyAlMoFEhLS0NSUhL++OMP/PHHH7h27RoyMzOhUCggEonQpUsX+Pj4wNfXFz4+PvDz84OPjw+8vLy4VJTqUalUyM3NRUpKClJTU9U/t27dQlpaGqqqqgA8XB7r7++PgIAABAYGIigoCP7+/jA3Nxf4Cai9YClHRERERESkPZZyraisrAyJiYn43//+h+TkZCQlJeH69esoKyuDkZERfHx81OVIbQHn4+MDMzMzoaNTB6FQKJCZmaku6a5fv67+eyiXy2FoaAhvb28EBQUhMDAQgYGBGDBgAGfVkUYs5YiIiIiIiLTHUq4Fpaen4+zZs0hMTERiYiIuX76MyspK2Nrawt/fH/7+/ujVqxeCg4Px7LPPcoYSCSonJweJiYm4ceMGrl+/jsTERPz5559QKpVwdXVFcHAwgoODMXToUDz33HMsi4mlHBERERERUTOwlNORmpoaXLp0CfHx8Th37hwSEhJQXFwMU1NTBAcHY+DAgRg4cCAGDRoET09PoeMSNYlMJsOlS5dw8eJFJCQkICEhAffv34exsTH69OmDwYMHY+TIkQgJCYGNjY3QcamVsZQjIiIiIiLSHku5Zrhx4wZOnDiB+Ph4/Pbbb5DJZPDw8EBISIi6hOvTpw+MjY2FjkqkM2lpaeqC7uzZs7h69SoMDAzQr18/hIaGIjQ0FIMHD+b7DvUASzkiIiIiIiLtsZR7ClVVVYiPj8eePXtw6NAh5ObmwtbWFiEhIeoyws/PT+iYRK2qsLAQJ0+eRHx8PE6cOIH09HSYm5sjJCQEYrEYEydOhKOjo9AxqQWwlCMiIiIiItIeS7knKC8vx7Fjx7Bnzx7s378fUqkU/fv3R2RkJEJDQ9GvXz8YGhoKHZOozcjIyMCJEydw6NAhHD16FFVVVQgJCcHkyZMhFou5aUQHwlKOiIiIiIhIeyzlGnD+/Hls3LgRe/fuRVlZGYYMGYLJkydj0qRJfCccURPJ5XIcOnRIPbu0rKwMw4YNw6uvvoqoqCiYmJgIHZGagaUcERERERGR9ljKPUIul+Onn37Chg0bkJSUhODgYLz88ssQi8VwdXUVOh5Ru1Y763T79u2Ii4uDra0t5s6di+joaHTv3l3oeKQFlnJERERERETaYykHoKCgAJ999hm2bt2K6upqTJs2DfPnz8eAAQOEjkbUIeXm5iImJgbffvstcnJyMHbsWCxbtgxDhw4VOho9BZZyRERERERE2jMQOoCQ5HI5Pv74Y/To0QO7d+/G+++/j3v37uG7775r9UJu6NChEIlEGn8WLVrU6GcVCgWWLl0KHx8fmJqaYty4cepza9asUY/j4eHR0o/RrmRmZiIyMhIymazO8atXryI8PBy2trawsrJCaGgozp07p9U9Dh06BF9fXxgZGT31Zx88eICNGzdi5MiRsLe3h5mZGXx8fDBz5kwkJSXVu37JkiXYtWtXg+PNnTsXJiYm6NatG958801UVFQ8dSZdcXV1xYoVK5CRkYHY2FiUlpZi2LBhGD16NK5cuSJYLiIiIiIiIqLWopelnEqlwrfffosePXpg7dq1WLJkCVJTU/H222/D3t5e6HhPbcuWLfj888/x0ksvIS8vD4cPH1afe+edd6BSqRAUFCRgwieTy+Xw8fFBREREq9zv6tWr6NevH8aMGQNra2v18YSEBAwZMgRWVla4efMmMjIy0L17d4SEhODYsWNNHj8tLQ2RkZFYunQp8vPztcr47rvvYuHChZgwYQJu3LiBoqIibN26FVevXkVwcDD27dtX5/pXX30VS5cuxYoVKzSO991336GwsBBLlizB+vXrsXbtWq1y6ZKRkRHEYjFOnz6NkydPoqysDP3798df//pXFBcXCx2PiIiIiIiIqMXo3fLVnJwczJkzB6dOncLChQuxfPlyODg4CB0LQ4cOxVdffYV+/fo99WdnzJiB//znP5DJZLCystJ4TZ8+fVBYWIh79+41N2qLKCkpQZ8+feDn54dDhw616L1kMhn8/f0RHh6OjRs3qo8rlUoEBgZCIpEgLS0NZmZmAB7ORPT390dZWRlSU1ObtDnBjBkzEBgYiHfeeQddu3ZFXl4eampqnirnvHnzYGhoiE2bNtU5npSUhD59+sDHxwcpKSn1zvXt2xc7d+7E1KlTGxzbwsICQ4cOxdGjR58qU0tTqVTYsWMH3n33XRgZGeH777/HiBEjhI5FDeDyVSIiIiIiIu3p1Uy5pKQkDBgwAJmZmTh37hzWrl3bJgq55ioqKoKhoWGDhVx7YGVlhbS0tBYv5ADgiy++QF5eHt5///06x8+cOYPr168jKipKXcgBgKGhIaZPn46srCwcOHCgSffYsmULlixZotWy1VoxMTH1CjkACAoKgpmZGdLS0vB4px4UFISoqCi8/fbbjZaAtra2KCoq0jpbSxGJRJg5cyaSk5MxYMAAjBkzpk5xSkRERERERNRR6E0pd+3aNYwYMQJ+fn5ISEjoUJs4KBQKoSO0GyqVCjExMRg4cCDc3NzqnDt58iQAaJytWHssPj6+Sfd5tNTTtdLSUpSXl6N3794QiUT1zovFYty7dw8HDx5scAyRSPTUM/dak4ODA2JjY7FmzRosWLAAX375pdCRiIiIiIiIiHRKL0o5qVSK8ePHo0+fPjh06BBsbW2FjqTRjz/+iD59+sDCwgI2NjYYNmwYduzYodN7/PnnnwgPD4eNjQ3Mzc0xYsSIepsY1NTUYNeuXRg9ejRcXFxgZmaGgIAArFu3DkqlUn3dvn376mxIcevWLUydOhUODg7qYzExMU99zeMbENy/fx9vvPEGunbtik6dOsHJyQmTJk3C1atXnypLYWEhkpKSkJ+fr/Ede3/++ScAaNwQw93dHQDqLRcVws8//wwAWL58ucbzffr0AYA2tzRVG2+++SZWrVqFd95556ne6UdERERERETU1ulFKbdixQpUVVUhNja2Se8DE8qDBw+wdetWFBQU4NKlS+jWrRtmzpyJN954o9HPVVVVNem55HI5/va3v2HZsmXIzs7GmTNnIJFIMHLkSJw+fVp93ZEjR/Diiy9i5MiRuHnzJrKysvDXv/4Vb731Fv7xj3+or5s4cSJUKhUmTJgAAIiOjsbf/vY3ZGVl4eLFizA0NNTqmkfl5uaif//+2L17N/79739DIpHgt99+g0QiweDBg3HhwoUmZwEezpgENBdvtRsLWFhY1DtnaWkJ4OH/RkLKz8/HkiVLMG/evAbfGVdbINY+qyYmJiaorq5ukYy69s477yAqKgrR0dHtJjMRERERERHRk3T4Uk4ul+O7777De++916Z3Vj179ix++OEHPPvss7CwsICfnx9++OEHDBgwAF9//TUSEhIa/Ozdu3c1lkyPk0ql+PTTT/Hcc8/B0tIS/fr1w/bt21FVVYU333yzzrUhISFYunQp7Ozs4OjoiIULF2LGjBlYt24dZDKZxvH/8Y9/ICQkBObm5hg4cCBqamrg6Oj41Nc8aunSpcjMzMTatWsxfvx4WFpawt/fHzt37oRKpcLChQufKktubi4AwMbG5onf16Nq392mabloaykqKkJYWBhCQkIafc+atbU1RCKR+lk1cXNzQ3Z2dptewvqo1atXP9U7/YiIiIiIiIjaug5fyiUlJUEul2PixIlCR9FKVFQUAGD//v31zkkkEqxevRqZmZn429/+9sSxTE1NMXDgwDrHAgIC4ObmhqSkJHWJExERgVOnTtX7fFBQEKqrq3H9+nWN4zflPX1P+y6/ffv2wcDAABEREXWOu7i4wN/fH4mJiRp3lG3oPrVLY42Njeudq13WXFpaWu9c7TGhlj6XlpZi7Nix6NWrF3766Sf1zL+GGBkZoby8vMHz0dHRkMlkeP/991FYWKjruDrn6emJfv364b///a/QUYiIiIiIiIh0osOXchKJBADa7S6rrq6uAICCgoI6x+fMmQMHBwcsWbIEixcvfuISVwDq96s9ztnZuc49pFIp3n//fQQEBMDOzk79TrZ3330XAFBWVqZxfE3LPrW5plZlZSWkUimUSiVsbGzqvDNOJBLhypUrAIDU1NQm38fU1BQANC6D7NmzJwBoLPmys7MBAL6+vk3Orys1NTWYMmUK3N3d8f333z+xkKv9TGObTcyaNQsrV67E6tWr4eTkhLCwMF1GbhGOjo7qf56JiIiIiIiI2rsOX8p5eXkB+P+X+Lc3OTk5AP6/OKu1bds2SKVS7Ny5E2vXrkV0dPQTx5JKpRqP15Zxtfd44YUX8Mknn+DVV19FSkoKlEolVCqVegfM2qWcLc3ExAS2trYwMjJCdXU1VCqVxp8RI0Y0eczaklPTd1E7TmJiYr1ztcdGjRqlzaM0S3R0NCorK7F7924YGRmpj/fo0QMXL16sd71MJoNKpVI/qybLly/HsmXLsGHDBhQXF+PIkSMtkl1XVCoVbt68ia5duwodhYiIiIiIiEgnOnwpFxAQAG9vb3z77bdCR2lQTEwMgoOD6x1XqVTYvXs3gIdF2eOsra0xZcoU9O3bF7GxsU+8j1wuR1JSUp1jycnJyMnJQVBQEFxdXaFQKHDu3Dm4uLjgjTfegJOTk3p2XWPLIVvKpEmTUFNTU2+HWABYtWoVPD09n+q9aL179wageTbc8OHD0atXL8TGxtbZAVahUGDnzp3o0qULwsPDtXgK7X344Ye4fv064uLimrxJSe2svtpn1eSXX35Bt27dMG/evKd+v54QTpw4gfT0dIjFYqGjEBEREREREelEhy/lRCIR3nvvPWzevLlNv4/qypUrWLBgAW7fvo2KigrcunULs2fPRmJiIhYuXFjvXXCPsra2bnDzhUdZWFjg9ddfR0JCAkpLS3H58mXMmjULnTp1wrp16wAAhoaGCAkJQV5eHlavXo3CwkKUl5fj1KlTjW4u0FI+++wzeHt74+WXX8bhw4chlUohkUiwadMmfPzxx1izZk2d2WNPEhQUBGdn53rlJAAYGBhgy5YtkEgkmDt3LvLy8lBUVIQFCxYgNTUVmzdvVi9/rTVr1iyIRCJkZGQ06zk1jbNt2zZ89NFHSEhIgJWVVb3lu2lpaRrHunr1KgBgzJgxDd6vpKQE1tbWzcrcWmQyGRYsWIDIyEgEBQUJHYeIiIiIiIhIJzp8KQcAf/nLXxAZGQmxWIxr164JHaee2bNn4+eff0Zubi7CwsJga2uLgQMHIjs7Gzt27MD69esb/XxjO4KuWbMGIpEISUlJsLW1xdq1a7F06VK4uLjg+eefh52dHU6ePInhw4erP7Nr1y5ER0fj66+/hpubG7p164YffvgBM2bMAACMHj0a/fr1w8WLFyESiRAXFwcAMDMzq5elKdfs27ev3jWzZs0C8HBJ7aVLlzBx4kS8/vrrcHJyQs+ePfHLL78gLi4OU6dObfJ9ar+refPmISEhQb00+FGDBg3C+fPnIZVK4efnh65duyI1NRW//fYbxo4dW+/63NxcWFpawtPTs87xAwcOqMuz7OxsKBQK9Z9jYmKaNE5TZj9qsnfvXri7uz9xVp+QO8k2VVlZGcRiMUpLS/Hvf/9b6DhEREREREREOiNStdYLwgRWXl6O8ePH4+rVq9i9ezdGjx4tdCSdiYiIwKFDh6BUKoWO0i5IpVL4+/sjIiKiWbP/iouL4ebmhpkzZ2Lz5s2CjwM83G24b9++2LFjB1588cUGr3NxcUG3bt1w4cKFZt2vJeXk5GDixInIyMhAfHw8AgMDhY5Ej9mN3ZiGaVBBL/41QkREREREpFN6MVMOeDhz6siRI4iIiEBYWBjefffdOu8Na888PDygUqmQn58vdJR2wcbGBvv370dsbCy++eYbrcZQqVR44403YG1tjU8++UTrLLoaBwDS09MxadIkLF26tNFCrrq6GhKJBB4eHs26X0uKjY1FUFAQSkpKcPHiRRZyRERERERE1OHoTSkHPNzN88cff8TOnTsRExMDX19ffPvtt1AoFEJHa5awsDAAwOeff46ioiKB07QPffv2xeXLl3H48OEmvY/vcfn5+UhPT0d8fDxcXFy0zqGrcQBg06ZNWLlyJVauXNngNVKpFGvXrkV1dbX6701bkpqaihdeeAFTpkzBuHHj8Pvvv8Pb21voWEREREREREQ6pzfLVx+Xk5ODjz76CFu3boWvry8+/PBDTJkyRehYWvviiy+wbds2pKenY8SIETh8+LDQkaiNmTNnDnbs2AEvLy9Mnz4dH3zwAQwNDYWOBQC4e/cu/vnPf2LTpk3o1q0bvvrqK43v8KO2hctXiYiIiIiItKe3pVytmzdvYunSpYiLi8OAAQMwf/58TJs2DWZmZkJHI+rwTp8+jY0bN+KXX36Bu7s73nvvPbz00ktPtaMuCYelHBERERERkfb0avmqJs888wz27duH8+fPo3v37oiOjoaHhwfeeustpKSkCB2PqMORSqX4+uuv4e/vj5CQEGRkZODbb7/FrVu38PLLL7OQIyIiIiIiIr2g9zPlHldQUICtW7di06ZNyMzMxNChQzF58mRMmjQJXbp0EToeUbtUWlqKQ4cOYc+ePThw4ABEIhFmzJiB1157DX379hU6HmmJM+WIiIiIiIi0x1KuAUqlEkeOHMF//vMf7N+/HzKZDAMGDMDkyZMxefJkdO/eXeiIRG2aVCrFgQMHsGfPHhw5cgRVVVUYPnw4pk6diunTp8Pa2lroiNRMLOWIiIiIiIi0x1KuCaqqqnDixAns2bMHcXFxKCoqQu/evREaGorQ0FAMHz4clpaWQsckEpRCoUBiYiLi4+Nx4sQJnDt3DkqlEiNHjkRUVBQmTpwIR0dHoWOSDrGUIyIiIiIi0h5LuadUU1ODU6dO4fDhw4iPj0dycjKMjIwwcOBAjBo1CqGhoRg4cCCMjY2FjkrU4m7duoUTJ04gPj4ep06dQnFxMVxdXTFq1CiMGTMGERERsLOzEzomtRCWckRERERERNpjKddM9+/fx2+//YYTJ07g+PHjyMjIgLGxMQIDA/Hcc88hODgYwcHB8Pf3FzoqUbPI5XJcvXoViYmJOHfuHE6fPo2CggJYWFhg8ODB6pmjzz77LEQikdBxqRWwlCMiIiIiItIeSzkdS01Nxblz53Dx4kVcvHgR165dg0KhgJubGwYNGoRBgwbh2WefRVBQEJfyUZtVXl6O69ev4+rVq0hISMDFixdx48YNKJVKeHp6YuDAgRg0aBAGDx6M/v37c/x7ydsAACAASURBVMdUPcVSjoiIiIiISHss5VpYaWkpLl++rC7pEhISkJubCwBwdXVFQEAAgoKCEBAQgMDAQDzzzDPo1KmTwKlJn2RkZCA5ORnJyclISkrCH3/8gdu3b0OhUMDCwgLBwcHqQnngwIFwc3MTOjK1ESzliIiIiIiItMdSTgD5+fnqAiQ5ORl//PEHbty4gcrKShgbG8PPzw9+fn7w9fWFj48P/Pz84OPjAycnJ6GjUztVVlaG1NRUpKSkIDU1Fampqfjzzz9x48YNyGQyiEQidOvWDYGBgQgMDFSXxd7e3jAwMBA6PrVRLOWIiIiIiIi0x1KujaipqcGtW7fUM5Zqy5OUlBSUl5cDAOzs7ODj4wNfX1/4+fmha9eu6Nq1Kzw9PeHm5sYlhHru/v37yMzMxN27d3Hnzp06Jdy9e/egUqlgaGgILy8v+Pr6wtfXF7169UJgYCB69+4NKysroR+B2hmWckRERERERNpjKdfGqVQqZGVl1SlYbt26hdTUVGRmZqKqqgoAYGRkBDc3N3h6eqJr167w8vKCp6cnPD094eHhAWdnZzg7Owv8NKSt0tJS3Lt3D/n5+cjMzFSXb7U/d+7cUZe3IpEIrq6u6gLXx8dHPePS29uby6NJZ1jKERERERERaY+lXDumUqmQm5uLO3fu1CloMjMz1cdkMpn6emNjY3Tu3Blubm7o3LkzXF1d4erqqj7m7OwMR0dH2Nvbw97enjtotjC5XI6ioiJIJBLk5eUhPz8fOTk5yM/PR25uLnJzc9XHSktL1Z8zMTFBly5d1KWrl5eX+sfT0xNdunSBiYmJgE9G+oKlHBERERERkfZYynVwxcXFyMnJQV5eHnJyclBQUIDs7GwUFBSoj+fl5UEikdT7rIODg7qgq/29nZ0dHBwc4ODgAGtra1hYWMDGxgbW1tawtLSEhYUFrK2tYWNj0+HfRSaTyVBaWgq5XA6ZTAapVFrnzxKJBBKJRF28Pf772lmOtczNzeHq6goXFxe4uLioi1J3d3c4OzvDzc1NfY6FKbUFLOWIiIiIiIi0x5eQdXC2trawtbVFr169Gr2usrISBQUF6tKosLCwXomUm5uLgwcPwsTEBCqVCjKZTL1kUhNzc3NYWFjAysoKtra2EIlE6rLOwsICnTp1gqmpKczMzGBkZKR+p5mdnV2dcR7/cy0TExOYm5vXO15dXQ25XK7xM3K5HNXV1eo/l5aW/h97dx4WVb24Afwd9mUGBgHZREVQERUlBDSXXEhzSa3MJbUyNSssvdliditbTP15M7dyX1IzMTXLHddULDEVzX0jEGSHYZ0BZub8/vDOXJFFlhkOMO/neXiCs3zPeybMp/f5fs9BcXExVCoVlEol1Go18vLyIAgCFAoFgAflm0ajQV5enr50y8nJqfC+dffyaKnZvHnzMiWn7svd3Z3PdCMiIiIiIiIyISzlCMD/lkR6e3uXu3/nzp14/fXX4ebmhs2bNyM4OBgAoNVqkZOTg9zcXOTn5yM/Px95eXlQKBT6n/Pz8/UFV3Z2NgAgLy8ParUaWVlZKCoqQnFxMQoKCvTj6SiVSiiVynJnhukKtfKUV+QJggCNRoMmTZrA3NwcAGBrawsbGxtYWVnB3t4eZmZmcHR0hEQiQcuWLWFmZgapVApLS0vY29tDKpVCKpVCLpdDJpPpZwc+PFvQxsamGp88EREREREREZkilnJUqby8PLz33ntYtWoVxo8fj+XLl8Pe3l6/38zMDE5OThXOZqut559/Hmq1Gr/99lutx1IqlfD29sbEiRPxySefGCAdEREREREREVHNNO6HflGtxMTEIDg4GL/88gt27dqFjRs3lirkjE2j0eD48eMIDw83yHi2traYOHEiVqxYUWoJKxERERERERFRXWMpR2VoNBrMnz8fPXr0QIsWLRAbG4thw4bVeY4zZ84gOzsb/fv3N9iYERERSE1Nxa5duww2JhERERERERFRdbGUo1Li4+PRp08fzJ49G19++SUOHjwIT09PUbJERUWhWbNm8Pf3N9iYzZs3x5AhQ7Bs2TKDjUlEREREREREVF0s5Uhv+/btCAwMhEKhwNmzZ/Hhhx/CzEy8X5HDhw8bdJacztSpU3HixAlcvHjR4GMTEREREREREVUFSzmCWq3GjBkzMHLkSIwdOxYxMTHo0KGDqJmKiorw119/oXfv3gYfOzw8HB06dMB3331n8LGJiIiIiIiIiKqCpZyJS0tLwzPPPIPvv/8ea9aswffffw8bGxuxY+HChQsoKipCt27djDL+G2+8gc2bNyMrK8so4xMRERERERERVYalnAk7efIkOnfujISEBJw5cwavvfaa2JH0zpw5gyZNmsDX19co47/yyiuwsrLC+vXrjTI+EREREREREVFlWMqZIEEQsHjxYvTr1w8hISGIiYlBYGCg2LFKOXPmDMLCwiCRSIwyvlQqxcsvv4ylS5dCo9EY5RpERERERERERBVhKWdi8vLyMGrUKMyYMQOzZs3Crl27IJfLxY5Vhq6UM6a3334b9+7dw/79+416HSIiIiIiIiKiR1mIHYDqzvXr1/HCCy8gPT0dBw4cQHh4uNiRypWTk4O4uDgEBwcb9TqtW7dGeHg4li1bhiFDhhj1WkRERERERERED+NMOROxbds2BAcHw9nZGRcvXqy3hRwA3LhxA4IgoF27dka/1tSpUxEVFYUbN24Y/VpERERERERERDos5Ro5QRDw2WefYfTo0Zg4cSKOHj0KDw8PsWNV6saNG7CyskKLFi2Mfq3BgwfDx8cH33//vdGvRURERERERESkw1KuEVOpVBg/fjy+/vprLFmyBEuWLIGFRf1fsXzjxg34+fnVSVYzMzO8+eabWL9+PXJzc41+PSIiIiIiIiIigKVco5WUlISePXti//79OHjwIKZOnSp2pCq7ceMG2rZtW2fXmzRpErRaLTZv3lxn1yQiIiIiIiIi08ZSrhG6dOkSunbtitzcXJw+fRp9+/YVO1K13Lx5E23atKmz68nlcowZMwbLli2DIAh1dl0iIiIiIiIiMl0s5RqZqKgo9OzZE23btkVMTEydzjgzlKSkJDRv3rxOrzlt2jRcu3YNR48erdPrEhEREREREZFpYinXiKxbtw5DhgzBc889h/3798PR0VHsSNWm1WqhUCjg7Oxcp9ft0KEDevbsiWXLltXpdYmIiIiIiIjINLGUawQEQcCsWbMwadIkfPzxx1i/fj0sLS3FjlUj2dnZ0Gg0cHFxqfNrT506Fbt370ZcXFydX5uIiIiIiIiITAtLuQZOrVZjwoQJ+M9//oP169fjs88+g0QiETtWjWVkZABAnc+UA4Dnn38eHh4eWLlyZZ1fm4iIiIiIiIhMC0u5BqyoqAijR4/Gzz//jF9//RWvvPKK2JFqLTMzEwBEmSlnYWGByZMnY9WqVSgsLKzz6xMRERERERGR6WAp10Dl5+djyJAhOHr0KKKiojBw4ECxIxmEQqEA8OCNqGJ44403UFhYiMjISFGuT0RERERERESmgaVcA5SamopevXrh8uXLOHbsGLp37y52JIMRBAEAYGYmzq9m06ZNMWLECCxZskSU6xMRERERERGRaWAp18AkJSWhV69eyMvLw+nTp9GpUyexIxmUrozTarWiZZg6dSpiY2Nx+vRp0TIQERERERERUePGUq4BSUhIQO/evWFhYYGTJ0/Cx8dH7EgGZ25uDsCwpdy+ffvQpk0bWFhYVOn4rl27IiQkBMuWLTNYhkfFxsZi8ODBkMvlkMlkCA8PR3R0tNGuR0RERERERET1C0u5BiIhIQF9+/aFpaUlDh8+DHd3d7EjGYUhZ8rduXMHQ4cOxUcffYTU1NRqnRsREYHt27cjKSmp1jkedebMGTz55JOQyWS4du0a4uLi0KpVK/Tu3RtRUVEGvx4RERERERER1T8s5RqA+Ph49O7dGzKZDCdOnICHh4fYkYzGkKXcJ598gieffBLnzp2DTCar1rmjR4+Gk5MT1qxZU+scD9NqtZg4cSLkcjnWr18PDw8PuLi4YPny5fD19cWkSZNQVFRk0GsSERERERERUf3DUq6eu3v3Lnr06IEmTZrgyJEjcHFxETuSUdna2gIACgoKaj3W2rVrMXPmzCovW32YtbU1Jk6ciJUrV6K4uLjWWXROnDiBK1euYMSIEfp7BR4s2x0zZgzu3buHPXv2GOx6RERERERERFQ/sZSrx+7du4d+/frBzc0Nhw8fRpMmTcSOZHSurq4AgPT09FqP9XDpVRNvvPEG0tPTsXPnzlpn0Tl69CgAoEuXLmX26bYdOXLEYNcjIiIiIiIiovqJpVw9lZaWhgEDBkAmk+HgwYOQy+ViR6oTulIuLS2tzL7r169j+PDhcHR0hJ2dHUJDQ7Fnzx6Eh4dDIpFAIpFg0qRJBsvSvHlzDB069LEvfKhOruvXrwMAmjVrVmYcLy8vAMDNmzcNdg9EREREREREVD9Vf10fGV1GRgb69esHtVqNI0eOwNnZWexIdcbR0REODg5ISEgotf327dvo1q0b7O3tsX37dnTr1g3x8fGYPn06Ll26BGtra6hUKoPnmTp1Kvr27Ytz584hODi4zP7q5lIoFAAAe3v7MmNJpVIAQHZ2tsHvg4iIiIiIiIjqF86Uq2cUCgX69++PwsJCHD16tFG/1KEivr6+uHPnTqlts2bNgkKhwOLFi/H0009DKpWiffv22LJli0GeP1eRPn36oGPHjvj+++/L3W/IXIIgAAAkEkmtcxMRERERERFR/cZSrh5RqVQYPnw40tPTcfjw4XKXOJqC1q1bl1nCeeDAAQDAgAEDSm13dXWFv7+/UfO8+eab+Omnn5CZmVlmX3Vz6ZYhl1fY6baZylJlIiIiIiIiIlPGUq6e0Gq1ePnllxEbG4s9e/bAx8dH7EiiCQwMxIULF/Q/FxUVIS8vDzY2Nvolng9zcnIyap5XXnkFNjY2WLt2bantNcmlK+oSExPL7EtKSgIAtGnTxhCxiYiIiIiIiKgeYylXT7z77rv49ddfsWPHDnTq1EnsOKIKDg5GfHy8/g2s1tbWkMlkUKlUyM/PL3N8eS+FMCQ7Ozu88sor+O6776DRaPTba5KrT58+AIBz586V2afb1q9fP0NFJyIiIiIiIqJ6iqVcPTBv3jwsXboUP/74IwsZAF26dIFEIkFMTIx+28CBAwH8b7moTkpKSp28rTQiIgKJiYnYs2dPqe3VzfXUU08hICAA27dvL/UCCI1Gg61bt8Lb2xuDBw82wh0QERERERERUX3CUk5kW7ZswaxZs7BkyRKMGDFC7Dj1gouLCzp27IjDhw/rt3399ddo0qQJpk+fjkOHDiE/Px+XL1/GhAkT4O7ubvRMfn5+GDBgAJYtW1Zqe3VzmZmZYe3atcjKysKECROQkpKCzMxMRERE4NatW1i9ejVsbGyMfj9EREREREREJC6WciL6888/MXHiRMyYMQMRERFix6lX+vfvj0OHDul/9vX1xR9//IGQkBCMGDECbm5umDJlCj766CP4+fmVO8aePXsgkUggkUiQlJQEjUaj/3nNmjXVzhQREYHDhw/j8uXLtcrVtWtXnD59Gjk5OWjbti1atmyJW7du4fjx42VeGEFEREREREREjZNEEARB7BCm6P79+wgNDUXHjh2xZ88emJubix2pXjl69Cj69euHGzduPPbFB+Hh4Th16lSp5aDGIAgC/P398fTTT5eZMSdmLiKxbMM2jMIoCOBfI0RERERERNXFmXIiUCqVGD58OBwcHLB161YWcuXo3bs3PD09sXXrVrGj6EkkEkyZMgU//PADcnJyxI5DRERERERERA0YS7k6JggCJkyYgLt37+K3336Do6Oj2JHqJTMzM7zwwgvYsmUL6tNkztdeew2CIGDjxo1iRyEiIiIiIiKiBoylXB37+uuvsXPnTuzYsaPCZ47RA6+//jpu3ryJI0eOlLt/69atkEgkOHLkCIqKiiCRSDBp0iSjZpLL5Rg3bhyWLl0KrVZbb3IRERERERERUcPCZ8rVoePHjyM8PBwLFy7EO++8I3acBqF3795wcHDAb7/9JnYUvStXrqBjx444cOAA+vfvL3YcItHwmXJEREREREQ1x1KujqSmpiIoKAihoaH45ZdfIJFIxI7UIOzatQsvvPACLly4gMDAQLHj6NXHspCorrGUIyIiIiIiqjkuX60DGo0G48aNg729PX744QcWctUwbNgwhISE4OOPPxY7SilTp07F3r17cffuXbGjEBEREREREVEDxFKuDvz73//GqVOnsG3bNr7YoZokEgm++OIL7NmzB7///rvYcfSGDx8OLy8vrFixQuwoRERERERERNQAsZQzssOHD2P+/PlYtmwZgoKCxI7TIPXv3x/9+vXDv//9b7Gj6FlYWGDKlClYs2YNCgoKxI5DRERERERERA0MSzkjUigUmDhxIoYPH46JEyeKHadBmzNnDqKjoxEZGSl2FL3XX38dSqUSP/30k9hRiIiIiIiIiKiBYSlnRG+99RZKSkqwevVqsaM0eGFhYZg8eTKmTZuG7OxsseMAAFxdXTFy5EgsW7ZM7ChERERERERE1MCwlDOSHTt2YOvWrVizZg2cnZ3FjtMoLFiwABYWFnj//ffFjqI3bdo0XLx4ESdPnhQ7ChERERERERE1ICzljCApKQmvv/46IiIiMGjQILHjNBoODg5YvHgx1q1bh2PHjokdBwDwxBNPIDQ0lLPliIiIiIiIiKhaWMoZwRtvvAFXV1fMnz9f7CiNzgsvvIDhw4fj1VdfRVZWlthxAABTp07Fzp07kZiYKHYUIiIiIiIiImogWMoZ2M8//4y9e/fi+++/h52dndhxGqW1a9dCIpFg/PjxEARB7DgYNWoUnJ2dSz07MC0tDfPnz8fUqVNFTEZERERERERE9RVLOQPKzc3Fv/71L7z22mvo27ev2HEaLScnJ0RGRuLQoUNYtGiR2HFgZWWFyZMnY8WKFTh16hTGjh0LLy8vzJw5E2fPnhU7HhERERERERHVQyzlDGjWrFlQqVSYN2+e2FEavbCwMHzxxReYOXMm/vjjjzL7o6OjsXbt2jrJUlxcDC8vL+Tn56Nnz57Yvn071Go1ANSbN8USERERERERUf0iEerD+r9G4OzZs+jWrRvWr1+P8ePHix3HJGi1WgwfPhxnzpzBmTNn0LJlSwDAuXPn8NRTT8HW1hYJCQmwtbU1yvWTk5OxceNGLFy4EOnp6TAzM4NGoyl1TNOmTZGammqU6xOJbRu2YRRGQQD/GiEiIiIiIqoulnIGoNVqERISAicnJxw6dAgSiUTsSCZDNzutqKgIp0+fRmJiInr06IH8/HwAwPz58zFjxgyDX3fnzp0YOXIkJBKJflZceWxsbKBUKg1+faL6gKUcERERERFRzXH5qgFs3LgRFy9exKJFi1jI1TGpVIq9e/ciLy8Pzz77LPr06YOCggJoNBpoNBp89dVXyMvLM/h1hw8fjhdffPGxx6lUKpSUlBj8+kRERERERETUsLGUqyWlUonPPvsMkyZNQocOHcSOY5I8PT2xcuVKnD9/HgqFotTMtfz8fHz33XcGv6aZmRk2btyIvn37wsLCotJjFQqFwa9PRERERERERA0bS7la+uabb5CVlYXZs2eLHcVkpaWl4Z133kFJSUmZpaRqtRpz585Fbm6uwa9raWmJX375BUFBQbC0tKzwOL7sgYiIiIiIiIgexVKuFtLS0rBgwQJ8+OGHcHd3FzuOScrIyEDPnj2RkJBQ4TLRwsJCLFq0yCjXt7Ozw/79+9GiRYsKiznOlCMiIiIiIiKiR7GUq4XZs2dDJpPh3XffFTuKScrJyUF4eDhu375d6XPb1Go1FixYYLQZa87Ozjh27BhcXFzKXcrKUo6IiIiIiIiIHsVSroaSkpKwbt06fPrpp7CzsxM7jklKS0tDmzZtIJFIKl0+Cjx44cI333xjtCzNmjXDoUOHYGdnB3Nzc/12iUTC5atEREREREREVAZLuRpasGABXF1d8corr4gdxWS1bt0a27Ztw+3bt/Huu+9CKpVW+NIFtVqNhQsXIi0tzWh52rdvj6ioKFhaWsLM7MEfLQsLC86UIyIiIiIiIqIyWMrVQEZGBtauXYv33nsP1tbWYscxeS1btsS8efOQlJSE//znP3B3d4eZmZm+GNMpKSkx6mw5AAgLC8PPP/8MiUQC4MFbWjlTjoiIiIiIiIgexVKuBr755hvY2Nhg4sSJYkehhzg4OGDatGmIj4/H1q1bERgYCAD62XNqtRpLlixBamqqUXMMGTIEq1atgkQiQXFxMWfKEREREREREVEZ5a/1owrl5ORgxYoV+PDDDyGVSsWOQ+WwsrLCiy++iBEjRiAqKgrz58/HsWPHYGFhAZVKhXnz5uHbb7+t8fjFxcUoKCgAAOTm5kKj0ZTaBgB+fn547bXXsHbtWly5cgWHDx8uNUZBQQGKi4srvIZEIoFcLq/yfisrK9jb2wN4UE6am5uX2kZERERERERE9YtEEARB7BANyYIFCzBnzhwkJCTAwcFB7DhUgfz8fGRnZ0OhUEChUODSpUuIjIxEdHQ0zMzM8MEHH0AQBCiVShQWFkKhUECpVEKpVCI7OxtKpRIqlarcAq4herSoMzc3h4ODA6RSKWxtbSGTySCTyWBrawupVAoHBwfY2Njov9dtd3Jyglwuh5OTE5ycnMS+LRLZNmzDKIyCAP41QkREREREVF0s5apBq9XCz88PQ4cOxaJFi8SOYxLy8vKQmpqK9PR0pKenIyMjA+np6frC7dF/6r5Xq9XljieTyaDVamFpaQkfHx/Y2trCzs4Ojo6O5X6vK68AQCqVwtLSstxtFhYWkMlk+utYWlpCKpVCq9UiMjISY8aMKZXjcbPYHp1596iioiIUFhbqf1apVFAqlQCgf4ZdZdtKSkqQn5+PvLw8KJVK5OfnIzc3FyqVqtzvKyoj5XK5vqR79Htdcde0aVM0bdoUrq6ucHFxgaurq/6Ze9SwsZQjIiIiIiKqOZZy1bB3714MGTIEly9fRvv27cWO02AVFBQgISEB9+/fR1JSEu7fv4+0tDR94aYr4TIyMqBSqUqdK5VK4erqiiZNmlRaBj36T6lUWqoEU6lUsLGxqetbb7CKi4tLzT583D9132dlZSEjIwMP/2fGzMysVEGnK+1cXFzg7u4OLy8vNGvWDJ6enmjatKmId02Pw1KOiIiIiIio5ljKVcOQIUOgUqnKPB+M/ic3NxdxcXFISEjQF24JCQlITk5GYmIiEhMTkZubqz/exsYG7u7ucHd3L1PS6IobNzc3fWnDIq3h0Wg0yMjIKFO66orXlJQU/ff3799HTk6O/lxra2t4enrCy8sL3t7e8PDwgLe3N7y8vODl5YVWrVrB3d1dxLszbSzliIiIiIiIao4veqii+Ph4HDhwANu2bRM7iqhKSkpw79493L17F3fv3sX9+/eRnJys/zkuLk4/K8rGxgaenp5o1aoVPDw8EBQUBA8Pj1Lb3N3dYWbGlwA3Zubm5nBzc4Obm1uVjlepVLh//77+d+vh37EzZ85g165dSEhI0C9Rtra21hd0j375+fnB0dHRmLdHREREREREVCOcKVdFM2fOxKZNm/DPP//A0tJS7DhGl5aWhqtXr+LGjRu4evUqrl+/jhs3biAxMVH/fDFHR0f4+PigVatW8PHxKfV9ixYtYGtrK/JdUGOlVqv1RV1cXBzi4uL039+9exfJycn6Y11cXODn54eAgAD4+/ujXbt2aNeuHVq2bAlzc3MR76Lh40w5IiIiIiKimmMpVwXFxcXw9vZGREQEPv30U7HjGFRKSgpiY2Nx5coVXL9+HdeuXcO1a9eQlZUF4EHxpisy/P399aVbq1at0KRJE5HTE5VPpVKVKuxu3LiB69ev4/r160hMTATwYIadv7+//qtdu3bo1KkT2rRpw9mbVcRSjoiIiIiIqOZYylXBzz//jDFjxiAhIQGenp5ix6mx+/fv49y5c/qvq1ev4u7duwAAJycnBAQEoH379mjVqpX+ex8fH74pkxqVoqIi3L59G1evXsWVK1f0fw6uXLkClUoFKysr+Pn5ITg4uNQXZ36WxVKOiIiIiIio5ljKVcFzzz2HwsJCHDx4UOwoVZaWlobo6GicOnUK586dQ2xsLHJycmBubo62bdsiKCgInTt3RlBQEJ544gk4OTmJHZlIVMXFxfj7779x4cIF/delS5dQUFAAS0tLtG/fHkFBQXjyySfRvXt3+Pv7m3xhzVKOiIiIiIio5ljKPUZubi7c3NywfPlyvPrqq2LHqdDNmzcRHR2NkydP4vTp07hx4wbMzc3RoUMHhIaGIigoCEFBQQgMDISdnZ3YcYkaBI1Gg5s3b+LChQuIjY3FX3/9hZiYGBQUFMDFxQXdu3dHjx490L17d3Tp0sUknjf5MJZyRERERERENcdS7jHWrVuHiIgIJCcnQy6Xix1HLyUlBfv378eBAwfw+++/IzU1Fba2tggNDdWXBN27d4eDg4PYUYkaFbVajfPnz+tnokZHR+v//IWFheGZZ57BwIEDERgYKHZUo2MpR0REREREVHMs5R7j6aefhoODA3bs2CFqDo1Gg5iYGOzbtw/79+/H+fPnYW1tjaeeegrh4eEmO1OHqD7QzVQ9fvw4Dhw4gLS0NDRr1gwDBw7EwIEDER4eDplMJnZMg2MpR0REREREVHMs5SqRkpKCZs2aYevWrRgxYkSdX1+r1eLYsWPYvHkzdu/ejczMTPj4+GDgwIEYNGgQ+vTpw6WoRPWMVqvF+fPnsX//fuzbtw9nz56Fubk5nnrqKYwdOxbPP/98oynoWMoRERERERHVHEu5SixevBiffPKJfmlaXbly5Qo2bdqEH3/8EYmJiQgNDcWoUaMwaNAg+Pv711kOIqq9FIKaWAAAIABJREFUjIwMREVFYceOHdi7dy/Mzc0xfPhwjBs3Dk8//TQsLCzEjlhjLOWIiIiIiIhqjqVcJXr27ImWLVti06ZNRr+WUqnExo0bsXLlSly4cAEtWrTAuHHjMH78eLRt29bo1yci48vOzsa2bduwadMmnD59Gm5ubhg/fjymTp2K5s2bix2v2ljKERERERER1ZyZ2AHqq+zsbPz5558YOnSo0a/z6aefonnz5pg+fTo6deqE48eP4+7du/jqq69ELeRKSkrw7bffIjg4GDKZDE2bNsXAgQOxe/duVNblajQafPTRR2jdujVsbGwwcODAUvulUikkEkm5XzY2NggMDMR3331X6hodOnQoc+zo0aP1+8PDw0vt69KlS43OeVR8fDyGDh2K3NzcUttjY2MxePBgyOVyyGQyhIeHIzo6utqfMQDs27cPbdq0qXTG1MyZMxEZGVnh/gkTJsDa2ho+Pj6YNm0aVCpVla5d0f1VNVdlevToUeG/5+nTp5c6dsWKFRUeq/t69PeoOjkf9/nVFScnJ0yZMgWnTp3C7du38cYbb2DLli3w9fXFmDFjcPnyZbEjEhERERERUV0RqFxbtmwRLCwshOzsbKOMr1Qqha+++kqQy+WCs7Oz8PnnnwupqalGuVZN5OfnCz169BACAwOF33//XSgsLBTi4+OFESNGCACEv//+u8JzV65cKQAQvvjiiwo/vwsXLggAhGHDhum3FRUVCRcuXBC6d+8uABDef//9UuekpKQIzs7OAgBh8+bNZcbcu3ev0Lp1a6GgoKBW5zyc0cXFRVi6dGmp7X/++adga2srjBo1Srh//76Qnp4uTJ48WbCwsBAOHjxY4efyqNu3bwvPPvusEBgYKDg4OAjm5uaVHuvj4yP8+9//rvCY3NxcYcWKFQIAYc6cOY+9fkX3V51cldH9eyzva9q0aaWOXb58eYXH6r6++OKLGuesyucnluLiYmHz5s1Cp06dBDMzM+Gll14S4uLixI5VJZFCpACBf40QERERERHVBP9vqgLjxo0TevfubZSxDx06JPj5+QlSqVSYPXu2kJOTY5Tr1Mabb74pODg4CCkpKaW25+fnC9bW1pWWcmPGjBEACLm5uRUeU14pp5OQkCCYmZkJFhYWQmZmZql9P/74owBAcHZ2LpUtKytL8Pb2FqKjo8uMV5NzcnJyhGbNmglTpkwptV2j0Qjt27cXPDw8hMLCQv12tVottG3bVvD29hZUKlWF9/2wMWPGCHPnzhVKSkoELy+vx5ZfsbGxgkQiESIjIys9zs7OTujfv3+lx1R0fzXJVZHu3bsLZ8+erdKxy5cvL/d3QRAE4ebNm4K1tbWQnJxcq5xV/fzEotVqhcjISKFt27aCnZ2dMG/ePEGtVosdq1Is5YiIiIiIiGqOy1fLodVqERUVhUGDBhl0XI1Gg48//hj9+/dHYGAgrl27hs8++wwODg4GvU5tpaamYtWqVRg7dizc3NxK7bO3t4dKpUKHDh0qPD8zMxPm5uY1fsOkt7c3PDw8oFarcfHixVL7XnrpJQwdOhSZmZmIiIjQb3/77bcxZswYPPnkk2XGq8k5//d//4eUlBR8+umnpbafOHECV65cwYgRI0q9/MPc3BxjxozBvXv3sGfPnird59q1azFz5swqLw/t1KkTRowYgRkzZkCtVld4nFwuR2ZmZqVjVXR/NcllCH5+fujZs2e5+5YuXYrhw4fD3d291HZjfX5ikUgkGDlyJC5duoRZs2bh888/R3h4OJKTk8WORkREREREREbAUq4cMTExSEtLw+DBgw02ZklJCUaNGoWFCxfi22+/xY4dO9CsWTODjW9Iv/32GzQaDXr06FGj8zUaTa0zCP99npyNjU2ZfStWrICTkxN27NiB7du3Y9euXYiNjcUXX3xR4XjVOUcQBKxZswZhYWHw9PQste/o0aMAUO7z53Tbjhw5UqV7rMkbfZ977jkkJiZi7969FR4jkUgqLZ0qu7+a5qqt8PBwzJgxo8z2vLw8/PDDD3jrrbfK7DPW5yc2KysrfPzxxzh37hzS0tLQtWtX3L59W+xYREREREREZGAs5cqxb98+NG/eHAEBAQYbc/LkyYiKikJUVBSmTZtmsHGN4fz58wAePJR+xowZ8Pb2hpWVFVq0aIF33nkHWVlZRr1+QkICkpOT4eDggPbt25fZ7+HhgW+//RYAEBERgalTp+KHH36AtbV1hWNW55yLFy8iNTUVnTp1KrPv+vXrAFBuoerl5QUAuHnzZhXusmY6d+4MADh48GCNx6js/gxt06ZN6Ny5M+zt7eHo6IiePXtiy5YtVT5//fr1aN68OXr16mWQPIb4/OpKu3btcPLkSbi6uiI8PBzZ2dliRyIiIiIiIiIDYilXjgMHDhh0ltyOHTuwceNGREZGVrhErz7RLZd77bXXkJqait9//x1paWn48ssvsW7dOnTr1g05OTkVnl9cXFxpQVaRkpISxMbG4qWXXoKlpSWWLVtW4dLeV155BYMGDUJaWhr8/PwQHBz82PGreo7uDZjlFW8KhQLAg2W8j5JKpQBg1PJEV/xV9pZOa2trlJSUVLi/svsztOzsbKxbtw5paWmIiYmBj48Pxo4di3feeeex5wqCgO+++67cWXI1VZXPrz5p0qQJDh48CI1Gg6lTp4odh4iIiIiIiAyIpdwj8vPzceHCBfTp08dgY86dOxdjxozBwIEDDTamMalUKgAPlgdu2LABrVq1glwux8svv4yPPvoIN2/exDfffFPh+QkJCVUufH799VdIJBJIJBJYWVkhKCgITZs2xdWrVzF+/PhKz23dujUA4Pfff8evv/5apetV5RxdKeno6FilMXV0S24lEkm1zqsOBwcHSCSSSp8z5unpiaSkpAqXsNb0/qrr1KlT2LhxI5544gnY29ujbdu22LhxI0JDQ7F06VKcOXOm0vP379+P5OTkx/4eVEdVPr/6xtnZGYsWLUJkZCTi4uLEjkNEREREREQGwlLuEadPn4ZarUb37t0NMp5CocC5c+cMWiwYm24WWHh4eJmH6D/77LMAyl/+l5WVhQULFiA+Pr7Ks5uGDRsG4cFbgJGYmIhRo0bhl19+wapVqyo97+TJk9i5cycWLlwIAHjjjTceO0OtqufoSklLS8sy++RyOQCgoKCgzD7dNt0xxmJhYQGlUlnh/ilTpiA3NxeffvopMjIyyuyv7P7qwogRIwAAu3fvrvS4JUuW4OWXX9bPQDSUx31+9dHw4cNhZ2eHY8eOiR2FiIiIiIiIDISl3COio6Ph6+tb7gPwa0JXijRt2tQg49WFli1bAngwQ+dRuvtIT08vtf3VV1+Fs7MzZs6ciQ8++KBKyxMf5eXlhQ0bNsDX1xcLFizAX3/9Ve5x+fn5ePXVV7Fq1Sr861//wsCBA5GSklLps/qqc47u5RLlLQH19/cHACQmJpbZl5SUBABo06bN42+2FtRqdaUvORg3bhzmzJmDBQsWwNXVFc8880yp/ZXdX13w8PAAAKSlpVV4zM2bNxEVFWXQpas6j/v86iNzc3O4uLiU+XNHREREREREDRdLuUecOnWqxm8dLU/z5s1hZWWFS5cuGWxMY9Pdf3lL/HRFipubW6ntGzZsQE5ODrZu3YqFCxdiypQpNbq2jY0Nvv76awiCgJkzZ5Z7zIwZMxAeHq4vm1auXAkHBwds2rQJe/bsqfU5utKovOfm6ZY1nzt3rsw+3bZ+/fpV5VZrJDc3F4Ig6DOW5+OPP8asWbOwfPlyKBQKHDhwoNT+yu6vLty/fx9A5UX1kiVL0KtXL4O+bAWo2udXH2VmZuLevXvw8/MTOwoREREREREZCEu5h6jVasTExBi0lLOyssILL7yARYsWiTYzqboGDRoELy8vHDhwQL/UUUe35HD48OFlznNwcMCLL76IoKAgbN++vcbX141x5MgRHDp0qNS+gwcP4tChQ/jPf/6j3+bt7a3/ecqUKfqXMdT0nA4dOgAofzbcU089hYCAAGzfvr3UZ6PRaLB161Z4e3sb9CUhj9LNxtNlLM/OnTvh4+ODSZMmlfvcuMruz1DWrFlT7os0BEHAtm3bAPxvKfSjcnNzsXHjRkRERBg8V1U+v/po0aJFcHBwaDDPpSQiIiIiIqLHYyn3kPPnzyM/P9+gpRwAzJ49G7dv38b7779v0HGNxdraGmvWrEFmZiZGjx6NW7duQaFQYNOmTZg7dy7CwsIqXZ7q4OCA3NzcGl9fIpHgq6++AgDMnDlT/wIFhUKByZMnY926dZDJZKXOmTx5MsLDw3H//n3861//0m+vyTmdOnVC06ZNcfHixTLZzMzMsHbtWmRlZWHChAlISUlBZmYmIiIicOvWLaxevVq/PFRn3LhxkEgkBnlIf2xsLACgf//+FR6Tl5dX4Vtrgcrvr7r++ecfmJubQyKR4Pz586X2nT9/HhEREbh9+zZUKhVu3LiB8ePH49y5c3j77bcRFhZW7pjr1q2DVCrFc889V+t8j6rK51ffHD16FPPmzcPnn38OOzs7seMQERERERGRoQikt3DhQsHFxUXQarUGH/unn34SzM3NhXfffVfQaDQGH98YTp8+LQwYMEBwdHQUrKysBH9/f2H27NlCYWFhpeeFh4cL5ubmFe63t7cXAJT6GjVqVJnjevToUeY43dewYcP0x2VnZ1d4XHXP+fbbbwVBEIRZs2YJFhYWQlJSUrn3cP78eWHgwIGCg4ODIJVKhb59+wqnTp0q99i+ffsKUqlUUKvVpbbv3r27wqyrV68ud6wXX3xR8PLyEoqLiyv8fL28vITOnTtXuP9x91edXHFxcYKZmZkgkUiES5cu6berVCrh559/Fp577jnB19dXsLa2FhwdHYXevXsLW7ZsqTCXVqsV/Pz8hE8//bTS/NXNqVOVz68+2b9/v2BnZyeMHTvWKP9dqq1IIVKAwL9GiIiIiIiIakIiCP+dhkQYO3YsFAoF9u7da5Txf/rpJ0yYMAG9evXCpk2byjyXrbEYMmQI9u3bB61WK3aUGsvJyUH79u0xZMgQrFixosbjKBQKeHp6YuzYsVi9enWtMl28eBFBQUHYsmULRo8eXeFx7u7u8PHxwR9//FHhMYa6v4akqp9ffaBWqzFnzhx8+eWXGDduHNauXQtzc3OxY5WxDdswCqMggH+NEBERERERVReXrz4kNjYWnTt3Ntr4Y8aMwalTp3Dnzh34+/tj+fLl0Gg0RrueWJo1awZBEJCamip2lBpzdHTE7t27sX37dnz33Xc1GkMQBLzzzjtwcHDAl19+Was8d+/exfPPP4+PPvqo0kKppKQEWVlZaNasWaXjGeL+GpKqfn71wenTp9GlSxfMmzcPS5YswYYNG+plIUdERERERES1w1Luv5RKJW7evIlOnToZ9TpdunTB33//jWnTpmH69Ono0KEDNm7c2KBnlT1K94bTefPmITMzU+Q0NRcUFIS//voL+/fvr9Ez8lJTU3H37l0cOXIE7u7utcqycuVKzJkzB3PmzKnwmJycHCxcuBAlJSX6fweVqe39NSRV+fzEduXKFYwcORI9evSAk5MTzp8/j7feekvsWERERERERGQkXL76X2fPnkVoaChu3LiBNm3a1Mk1b968idmzZyMyMhJt27bF9OnTMX78eNja2tbJ9Y3p//7v/7BhwwbcvXsXffr0wf79+8WO1Ki9+uqr2LJlC1q0aIExY8bgs88+4+yqBuLo0aNYuHAh9u3bh86dO+OLL77AkCFDxI5VJVy+SkREREREVHMs5f5rzZo1mD59OnJzc2FmVrcTCK9evYqFCxdi8+bNsLe3x6hRozBu3Dg8+eSTdZqDiOpGQkICfvzxR2zevBlXr15Fr169MGPGDDz77LOQSCRix6sylnJEREREREQ1x+Wr/3Xx4kV07Nixzgs5AAgICMCaNWsQHx+PDz74ACdPnkT37t3RunVrfP7557hz506dZyIiw8rJycG6devQp08f+Pj4YOHChejTpw/++usv/P777xg6dGiDKuSIiIiIiIiodjhT7r969eqFgICAevMmytjYWGzatAk//fQTUlJS0KVLFwwcOBCDBg1CSEiIKOUhEVXPP//8g/3792Pfvn04cuQIBEHAs88+i3HjxmHgwIGwtLQUO2KtcKYcERERERFRzbGU+y9nZ2d8/vnnmDp1qthRStFoNDh8+DB27dqF/fv3Iz4+Hi4uLhgwYAAGDRqEAQMGwNnZWeyYRASguLgYJ0+e1Bdx165dg0wmw9NPP40hQ4bg+eefh6Ojo9gxDYalHBERERERUc1ZiB2gPlAoFMjKykLr1q3FjlKGubk5BgwYgAEDBgB48IZG3f/wv/rqq9BqtejcuTN69OiB7t27o0ePHvDw8BA5NZFpKCgoQExMDE6ePIno6GicPn0a+fn5CAgIwODBg7Fs2TL06NEDVlZWYkclIiIiIiKieoYz5QD89ddfCAkJwa1bt+Dn5yd2nCrLzc3FkSNHcPz4cZw6dQoXL16ERqOBr6+vvqDr3r072rVrx2dVERlASkoKTp8+jVOnTiE6Ohrnz5+HWq1GixYt0LNnT/To0QMDBgxAy5YtxY5aJzhTjoiIiIiIqOZYygGIjIzE2LFjUVhY2KBntBQUFODChQuIjo7GqVOncOrUKSgUCshkMgQGBqJ9+/YICAhAcHAwQkJCYG1tLXZkonrr/v37OHfuHM6dO4erV6/iypUruHbtGszMzNC2bVt96d2zZ0/4+PiIHVcULOWIiIiIiIhqjqUcgK+//hqrV69GXFyc2FEMSq1WIzY2FufOncP58+dx4cIF/P3331CpVLCxsUGHDh3wxBNPICgoCAEBAQgICICLi4vYsYnqlFKpxPXr13H9+nXExsbq/6xkZmbCzMwMvr6++j8nTzzxBMLCwuDg4CB27HqBpRwREREREVHN8ZlyAO7evQtfX1+xYxichYUFunTpgi5duui3qdVqXLt2DRcuXNB/RUZGIicnB8CDF160a9cO7dq1Q9u2bREQEAB/f3+0aNGCb3ylBi0jIwPXrl3TF3BXr17FjRs3EB8fD61WC0tLSwQEBCAoKAjPPvssgoKC0LlzZ8hkMrGjExERERERUSPEUg7AnTt30KZNG7Fj1AkLCwt07NgRHTt2xMsvv6zfnpiYWKas2LNnD5KTkwEAtra2aNOmDVq1aoVWrVrBx8dH/08fHx8uhSXRabVaJCUl4e7du4iLiyv1z5s3byIjIwMAIJPJ0LZtW7Rr1w69evXSl8++vr6wtLQU+S6IiIiIiIjIVHD5KoCWLVvizTffxIcffih2lHpHoVDgxo0buHLlCm7evFmq7MjMzAQASCQSeHp6lirqWrZsCQ8PDzRr1gxeXl6Qy+Ui3wk1dCqVCklJSbh//z7u3btXqoCLi4vDP//8g+LiYgAPSuSHfx9bt24Nf39/+Pv7w9vbW+Q7aTy4fJWIiIiIiKjmTH6mnCAIuH//Pv9HvQJyuRxhYWEICwsrsy83N7dUKaL7/uzZs4iPj0dhYaH+WDs7O3h7e5cq6jw9PeHt7Q13d3c0bdoUbm5ukEqldXl7VA8UFRUhIyMD6enpSEpKQnJyMhITE0sVcMnJyfqZbgBgaWkJDw8PffHWvXv3UiWch4eHiHdERERERERE9HgmX8plZmaipKQEbm5uYkdpcBwcHNC5c2d07ty53P0KhQJJSUlITExEcnIyEhIS9IXLlStXkJycjJSUlFLn2NrawsXFBe7u7nB1ddV/ubu7w8XFRf+zk5MT5HI55HI5LCxM/te4XsnJyYFCoUB2djaysrKQmpqK9PR0ZGRkIDU1FWlpaUhPT0d6ejpSU1P1zzPUkclk8Pb2hqenJ7y8vBAUFAQPD49S29zd3SGRSES6QyIiIiIiIqLaM/k2IzU1FQDg7u4ucpLGR1eatW/fvsJjiouLkZqaWqqsycjIQEpKir64uXr1KlJSUpCRkQGlUllmDJlMpr+WXC4vVdjpvre3t4dcLoetrS1sbGzg5OQEOzs72NrawtHREfb29rCysjLmx1GvCYIAhUKBwsJCKJVK5OTklPq+oKAABQUFUCgU+sJN973uZ922R1fEW1hYlCpU3d3dERwcDFdXV/0MSd1+T09PzpYkIiIiIiIik2DypZxuphZnyonDysoK3t7eVV4+nJ+fj4yMDH0B9Gg59PAMrbt37+p/LiwsRHZ2dqVjm5mZ6Qs6W1tbODg4AHgwI9Dc3ByWlpb6wqiybToWFhaVvrlTJpNVOMsvJycHWq223H1FRUWllgY/fHxxcTEKCgoeu02pVEKpVEKhUECpVEKlUlX62djb2+uLzYdLTz8/P/22h7c/fJyrq2ulYxMRERERERGZIpMv5VJTU2FhYYEmTZqIHYWqQCqVQiqVomXLltU6b+fOnXj99dfh4uKC5cuXo0WLFmVmghUWFiIvLw95eXlQKpXIz88HAP3sL5VKpZ+pl5CQUGbbo7PECgsLUVRUVG4e3cy0itjZ2QF48Ow0MzOzUvt05eHDdAXfw0WgbpudnZ2+dJZKpbC0tIS1tTXs7Oz0swdtbW3h5OSk/14ul5eaSUhEREREREREhsVSLjUVbm5uZYoPahzy8vLw3nvvYdWqVRg/fjyWL18Oe3t7sWM9lkajgaOjI7755htMnDhR7DhEREREREREZGAm30TpSjlqfGJiYhAcHIxffvkFu3btwsaNGxtEIQcA5ubmCAoKwtmzZ8WOQkRERERERERGYPKlXEZGBp951choNBrMnz8fPXr0QIsWLRAbG4thw4aJHavawsLCcObMGbFjEBEREREREZERmHwpl5eXV+nD+KlhiY+PR58+fTB79mx8+eWXOHjwIDw9PcWOVSMhISH4+++/9S9pICIiIiIiIqLGg6UcS7lGY/v27QgMDIRCocDZs2fx4YcfNuhnBYaGhkKj0eDChQtiRyEiIiIiIiIiA2u4jYWB5OfnQyqVih2DakGtVmPGjBkYOXIkxo4di5iYGHTo0EHsWLXm4+ODpk2bIiYmRuwoRERERERERGRgJv/21by8PJZyDVhaWhpeeuklREdHY82aNXjttdfEjmRQISEhLOWIiIiIiIiIGiHOlONMuQbr5MmT6Ny5MxISEnDmzJlGV8gBD5awspQjIiIiIiIianxMvpTjM+UaHkEQsHjxYvTr108/kywwMFDsWEYRGhqKuLg4pKWliR2FiIiIiIiIiAzI5Es5zpRrWPLy8jBq1Ci89957mDVrFnbt2gW5XC52LKMJDQ2FRCLB2bNnxY5CRERERERERAZk8s+UKyoqgpWVldgxqAquX7+OF154Aenp6Thw4AD69esndiSja9KkCXx9fXH27FkMHjxY7DhEREREREREZCAmP1NOq9XC3Nxc7Bj0GNu2bUNwcDBcXFxw8eJFkyjkdMLCwnDmzBmxYxARERERERGRAbGUYylXrwmCgE8//RSjR4/GpEmTcOTIEXh4eIgdq07pnpsnCILYUYiIiIiIiIjIQEy6lNNoNAAAMzOT/hjqLZVKhXHjxmHu3LlYsmQJFi9eDAsL01txHRoaiqysLNy5c0fsKERERERERERkIKbXcDxEq9UCAGfK1UNJSUkYPnw44uLiEBUVhT59+ogdSTRBQUGwsrJCTEwM/Pz8xI5DRERERERERAZg0lPEdDPlWMrVL5cuXULXrl2Rm5uL06dPm3QhBwA2Njbo2LEjYmJixI5CRERERERERAbCUg5cvlqfREVFoWfPnmjbti1iYmLQpk0bsSPVC2FhYSzliIiIiIiIiBoRk26jdA/Ol0gkIichAFi3bh0GDx6M559/Hvv374ejo6PYkeqNkJAQXLhwAcXFxWJHISIiIiIiIiIDMOlSztraGgBQUlIichLTJggCPvroI0yaNAmffPIJ1q9fD0tLS7Fj1SuhoaFQqVT4+++/xY5CRERERERERAZg0i96sLS0hJmZGVQqldhRTJZarcbEiROxdetWbNiwAS+//LLYkeqldu3aQS6XIyYmBsHBwWLHISIiIiIiIqJaMumZcgBgZWWFoqIisWOYpKKiIowaNQrbt2/Hr7/+ykKuEhKJBMHBwXyuHBEREREREVEjYfKlnLW1NUs5EeTn52PIkCE4duwYoqKi8Mwzz4gdqd4LDQ1lKUdERERERETUSJh8KWdjY8NSro6lpqaiV69euHz5Mo4fP47u3buLHalBCAkJwfXr15Gbmyt2FCIiIiIiIiKqJZMv5ThTrm4lJiaiV69eyM/Pxx9//IHAwECxIzUYXbt2hVarxV9//SV2FCIiIiIiIiKqJZZytSzlsrOzsWLFCvTt2xdNmjSBra0tWrdujbFjx+LixYsGTNrwJSQkoHfv3rCwsMCJEyfQsmVLsSM1KB4eHvDy8jLoEtbY2FgMHjwYcrkcMpkM4eHhiI6ONtj4RERERERERFQ+ky/lpFIp8vPza3z++++/j7fffhvDhg3D1atXkZmZiXXr1iE2NhbBwcHYtWuXAdM2XAkJCejbty+srKxw+PBhuLu7ix2pQQoLCzNYKXfmzBk8+eSTkMlkuHbtGuLi4tCqVSv07t0bUVFRBrkGEREREREREZXP5Es5uVyOnJycWo3x2muvYdq0aXB3d4ednR169uyJLVu2QKPR4IMPPjBQ0obrn3/+Qe/evSGTyXDixAl4eHiIHanBCgkJwZ9//lnrcbRaLSZOnAi5XI7169fDw8MDLi4uWL58OXx9fTFp0iQu6yYiIiIiIiIyIpZycjkUCkWNz1+zZg1WrlxZZnunTp1ga2uLO3fuQBCE2kRs0O7cuYOePXvC2dkZR48ehYuLi9iRGrTQ0FAkJycjKSmpVuOcOHECV65cwYgRI2Bra6vfbm5ujjFjxuDevXvYs2dPbeMSERERERERUQVYytWylKtIQUEBlEolOnToAIlEYvDxG4J79+4hPDwTnwXXAAAgAElEQVQc7u7uOHToEJycnMSO1OCFhITA3Ny81ktYjx49CgDo0qVLmX26bUeOHKnVNYiIiIiIiIioYiZfyjk6OpYp5a5fv47hw4fD0dERdnZ2CA0NxZ49exAeHg6JRAKJRIJJkyZVOu7PP/8MAPj444+Nlr0+S0tLQ//+/SGTyXDgwAHI5XKxIzUKMpkM/v7+5ZZy1fm9vX79OgCgWbNmZcbx8vICANy8edOId0JERERERERk2izEDiC2R0u527dvo1u3brC3t8f27dvRrVs3xMfHY/r06bh06RKsra2hUqkqHTM1NRUzZ87EpEmTMHLkSGPfQr2TkZGBvn37QqPR4OjRo3B2dhY7UqMSGhpappSr7u+t7nfe3t6+zPhSqRTAgzcLExEREREREZFxmPxMuUeXr86aNQsKhQKLFy/G008/DalUivbt22PLli0oKCh47HiZmZl45pln0Lt3b6xYscKY0eslhUKB/v37Q6lU4tixY3ypgxGEhITg7Nmz0Gq1+m21/b19mO4ZiKa67JqIiIiIiIioLph8Kefk5FRqRtCBAwcAAAMGDCh1nKurK/z9/Ssdq6CgAAMGDEBAQAB+/PFHmJubGz5wPaZSqTBs2DCkp6fjyJEj+mWQZFihoaHIy8vTL0EFqv97q1tOXF5hp9vGJcdERERERERExmPypZybmxuUSiVyc3NRVFSEvLw82NjY6JfwPayyFxWo1Wq8+OKL8PLywg8//GByhZxWq8X48eNx8eJF7N27Fy1bthQ7UqMVGBgIW1tb/RLWmvze6oq6xMTEMvt0b3Zt06aNIWMTERERERER0UNMvpRzd3cHAKSkpMDa2hoymQwqlQr5+flljk1LS6twnClTpqCoqAjbtm2DhcX/HtXn5+eHP//80/DB65l3330Xe/bswe7duxEYGCh2nEbN0tISQUFB+lKuJr+3ffr0AQCcO3euzD7dtn79+hkyNhERERERERE9xORLOd0zz5KTkwEAAwcOBPC/5YA6KSkpFb6Ncvbs2bhy5Qp+/fVXWFtbGzFt/TR37lwsXboUmzZtQs+ePcWOYxIefdlDdX9vn3rqKQQEBGD79u2lXgCh0WiwdetWeHt7Y/DgwUZKT0REREREREQmX8q5urrCwsJCX8p9/fXXaNKkCaZPn45Dhw4hPz8fly9fxoQJE/Sz6h62YcMGfP755zhz5gxkMhkkEkmprzt37tT1LdWpH3/8ER9//DGWLl2KESNGiB3HZISEhODSpUtQKpUAqv97a2ZmhrVr1yIrKwsTJkxASkoKMjMzERERgVu3bmH16tWwsbGp69siIiIiIiIiMhkmX8qZmZnB1dUVKSkpAABfX1/88ccfCAkJwYgRI+Dm5oYpU6bgo48+gp+fX5nzt2/fXteR640///wTkyZNwnvvvYe33npL7DgmJTQ0FCUlJYiNjQVQ/d9bAOjatStOnz6NnJwctG3bFi1btsStW7dw/PjxMi+MICIiIiIiIiLDsnj8IY2fh4eHfqYc8OAB97/88kuVzt2zZ4+xYtVr9+/fx4gRI9C7d2/MnTtX7Dgmx9fXFy4uLoiJiUG3bt0AVO/3VicoKAj79u0zRkQiIqL/Z+++o6I6F66B74Ghd5AiTUBABbFEbIiigi0KUa8tiRo1GGOMidH4GTUxptiiMdFrFEtiosZFiPWKYhfE8lowFhBUVBCQIiJNYChzvj+8zA1SQp0z4P6tNYtwynP2TBCXez3nPERERERUg1d+phzwYrGHv5dyVLPCwkKMHDkShoaGCA4OfuVWmlUFEokE3bt3r/BcOSIiIiIiIiJqPljKAbCxsUFKSorYMZoFQRAwdepUPHjwAP/5z39gZGQkdqRX1suLPRARERERERFR88FSDkCbNm2QkJBQ7f7g4GBIJBKcOnUKMpkMEokEgYGByguoQpYtW4b9+/dj37591T6rjJSje/fuuH//Pp4+fVrlfv7cEhEREREREakuiSAIgtghxLZ7925MmTIFhYWFvBWzBuHh4fDz88MPP/yA2bNnix3nlffkyRNYWFggLCwMQ4cOFTsOvYJCEILxGA8Br/xfI0RERERERHXGmXIAHBwcUFJSwltYa5Ceno633noLo0ePZiGnIszNzeHk5MRbWImIiIiIiIiaIZZyABwdHQEADx8+FDmJaiorK8Pbb78NPT09bN26Vew49Dd8rhwRERERERFR88RSDi9WX9XV1a3xuXKvss8//xznz59HSEgIF3ZQMVyBlYiIiIiIiKh5YikHQCKRwN7enjPlqnDy5EmsWrUKGzZsQNeuXcWOQy/p0aMHnjx5wp9dIiIiIiIiomaGpdx/OTo6sth4SXZ2Nt59912MHDkS7777rthxqArdunWDhoYGZ8sRERERERERNTMs5f7LxcUFd+/eFTuGSvnggw9QUlLC58ipMB0dHXTs2JGlHBEREREREVEzw1Luv9q1a4e4uDixY6iMvXv3Ijg4GNu2bYOZmZnYcagGXOyBiIiIiIiIqPlhKfdfHTp0QHZ2NtLS0sSOIrqUlBS89957mDVrFl5//XWx49A/6N69O65du4bS0lKxoxARERERERFRLbGU+6/27dsDAGfLAXj//fdhbm6OVatWiR2FaqFnz54oKChAdHS02FGIiIiIiIiIqJZYyv1X69atYWJigtjYWLGjiOrPP//E4cOHsXHjRujq6oodh2rBzc0NhoaGuHz5MgRBwJ07d7Bz507Mnj0bERERYscjIiIiIiIioipIxQ6gStq1a4c7d+6IHUM0ubm5+OSTTzBt2jQMHDhQ7DhUC2lpabh8+TJcXV2xfv16zJs3D/n5+ZBIJBAEARMmTBA7IhERERERERFVgaXc37Rv3/6Vvn110aJFKCoqwsqVK8WOQjW4cOEC1q5diwsXLiA1NRUAoK2tDZlMBkEQAEDx1dHRUbScRERERERERFQ9lnJ/4+bmhhMnTogdQxRXrlxBUFAQtm/fjlatWokdh2rg6uqKkydPIicnR7GtqKio0nGampqwsrJSZjQiIiIiIiIiqiU+U+5vOnXqhJSUFGRmZoodRankcjnef/999O/fHxMnThQ7Dv2DVq1a4bvvvoOaWs1/fK2trf/xGCIiIiIiIiISB//F/jddu3YFANy4cUPkJMq1Y8cO3LhxAz/++CMkEonYcagWAgMD0a1bN2hoaFR7jIuLixITEREREREREVFdsJT7GwsLC1hZWb1SpVxhYSG+/PJLBAYGomPHjmLHoVpSU1NDUFAQysrKqtyvoaEBZ2dnJaciIiIiIiIiotpiKfeSzp07v1Kl3Pfff4+srCwsXbpU7ChUR6+99hpmzpwJqbTyoyElEgkXeSAiIiIiIiJSYSzlXvIqlXIZGRlYvXo1FixYwAUBmqnly5fD2Ni40m3HJSUlLOWIiIiIiIiIVBhLuZd07twZt2/fRnFxsdhRmtzSpUthYGCAuXPnih2F6snQ0BBr166ttF0QBJZyRERERERERCqMpdxLunTpgpKSEty+fVvsKE0qJSUFv/zyC5YsWQJdXV2x41ADTJw4Ed7e3pUWfWApR0RERERERKS6WMq9pH379jAwMMCVK1fEjtKkVq9eDXNzc7zzzjtiR6EGkkgkCAoKglwuV2zT0dGBqampiKmIiIiIiIiIqCYs5V6ipqaG1157DZcvXxY7SpPJzMzEzz//jE8//RRaWlpix6FG4Obmhk8++USx6EObNm1ETkRERERERERENWEpV4WePXvi0qVLYsdoMt9//z20tbXx7rvvih2FGtGXX34JMzMzAICLi4vIaYiIiIiIiIioJlKxA6ii7t27Y82aNcjLy4OBgYHYcRpVTk4OgoKCsGDBAujr64sdh+ohLy8PMpkMubm5KCgogEwmQ2lpKfLy8vDee+/hm2++gYaGBo4fP46cnJxK5+vq6laaIamtrQ0dHR2oqanByMgIOjo60NbWrnJlVyIiIiIiIiJqOJZyVejZsyfkcjmuXbsGHx8fseM0qi1btkAQBHzwwQdiR3ml5ebmIiUlBenp6cjMzERWVlaVr2fPniE/Px85OTmQyWTIz8+v1fj79u3Dvn37GiWrpqYm9PT0YGBgAF1dXZiamipeJiYmFb43NTWFlZUVrKysYGlpyUKPiIiIiIiIqBos5apgZ2cHa2trXLp0qUWVcoIgYOvWrZg8eTIMDQ3FjtNiZWdn48GDB3j48CESEhKQnJyMtLQ0pKSkKL4WFBRUOMfY2BhmZmYVyi13d3eYmppCX18fxsbG0NLSgp6eHvT19aGlpQUjIyPFDDcAMDExAQA8ePAAjx49Qv/+/WFkZAQ1tYp3qefl5aG0tLTCtvz8fJSUlKCsrKzCDLzs7GzIZDI8f/4ceXl5KCgoqFAaxsfHVygQS0pKFGNKpVJYWlrC1tZW8dXKygpt2rSBk5MTHB0dYW1tzeKOiIiIiIiIXkkSQRAEsUOoopEjR0IqlWLPnj1iR2k0x48fx5AhQ3Dr1i107NhR7DjN2rNnzxATE4Pbt28jPj4eDx8+VBRxz549A/BiVVRra2tFGVVeTtnZ2VUoq1q1alWpOGuu8vLy8PjxY6SnpyMpKQnp6ekVSsnU1FQ8evQIMpkMwIvbZh0cHODo6AgnJyc4OTnBzc0NHTp04GIVzUAIQjAe4yGAf40QERERERHVFUu5aqxYsQIbNmxASkqK2FEazejRo/H06VNERESIHaXZKCgowPXr1xEdHY3bt28rirjHjx8DAAwMDODs7KyY+VVeLjk6OsLBwYGr21ZBLpfj8ePHFYrM8q/x8fFIS0sD8OKz7dChAzp27Kj42qVLF1hZWYn8DqgcSzkiIiIiIqL6YylXjcjISPTr1w/379+Hk5OT2HEaLDU1FW3atMFvv/2GN998U+w4Kqm0tBR37txBVFSU4nXlyhUUFxdDS0sLbdu2hbu7O9zc3BRfO3To0GJmuamKnJwcxMfHKwrQ8q8PHz6EIAho3bo1unXrpnj16tUL5ubmYsd+JbGUIyIiIiIiqj+WctWQyWQwNjbG5s2bMXnyZLHjNNhXX32FDRs2IDk5mbO3/is3NxeRkZGIiIhAREQE/vrrL5SUlMDIyAjdunWDp6en4uXo6Ch23FdeVlYWoqKicPXqVcXr0aNHAABnZ2d4e3tjwIAB8PHx4a2vSsJSjoiIiIiIqP5YytXA29sbHTp0wNatW8WO0iCCIMDBwQETJkzAqlWrxI4jmsLCQpw5cwZnzpxBREQErl27BrlcDjc3N/Tv3x9eXl7w9PSEi4sLFx9oJjIyMnD16lVcvnwZ4eHhuHTpEoqKiuDg4AAfHx8MGDAAgwcPRuvWrcWO2iKxlCMiIiIiIqo/lnI1WLhwIfbv34+4uDixozTIxYsX4eXlhRs3bqBTp05ix1GqJ0+eICwsDKGhoTh69Cjy8vLg5OQEPz8/9OnTBwMHDoStra3YMamRlJaW4saNGzh58iROnjyJc+fOoaioCG5ubvD398eIESPQp08flq6NhKUcERERERFR/bGUq8GRI0cwYsQIpKWlwcLCQuw49TZ37lwcPnwYd+7cETuKUjx69Ai///479u3bh6ioKOjo6MDX1xf+/v4YPnw4rK2txY5ISlJYWIiTJ08iNDQUoaGhePz4MWxtbREQEIC3334bvXv3ZkHXACzliIiIiIiI6o+lXA1ycnJgZmaGkJAQjB49Wuw49SIIAhwdHTFx4kR8++23YsdpMnl5edi7dy927NiBiIgImJqa4l//+hf8/f0xcOBA6OjoiB2RRCYIAq5du4ZDhw5h7969iI6OhrOzMyZNmoSJEye2iAVdlI2lHBERERERUf1x2cgaGBkZoWPHjjh79qzYUert0qVLSExMxNixY8WO0iRu3LiBqVOnwsrKCu+//z5MTU2xf/9+PH78GEFBQRg+fDgLOQIASCQSdOvWDUuXLsWtW7dw7do1+Pv7Y+PGjXB2doaPjw/27t0LuVwudlQiIiIiIiJ6BbCU+wcDBgzA6dOnxY5Rb3/++SdcXFzQuXNnsaM0GkEQcOzYMQwePBhdunTB1atX8f333yM1NRV79uxBQEAANDQ0xI5JKq5r165Yu3YtkpOTERoaClNTU4wbNw6urq7YsGEDnj9/LnZEIiIiIiIiasFYyv0DX19fREdHIy0tTewo9bJ3716MGTNG7BiN5vDhw+jUqROGDRsGADh69Chu3ryJ999/HyYmJiKno+ZIKpXi9ddfVyzqMnjwYCxYsAD29vZYsWIFioqKxI5IRERERERELRBLuX/g4+MDqVSK8PBwsaPUWWxsLBITExEQECB2lAaLiYnBkCFDMGLECHTo0AHXr1/H8ePHMWTIED6onxqNi4sLNm7ciEePHmH27NlYvnw5OnTogJCQEPDxm0RERERERNSYWMr9AwMDA3Tv3h2nTp0SO0qdnThxAsbGxvD09BQ7Sr0VFRXh448/RpcuXfD06VOcPXsWISEh6NSpk9jRqAUzMzPD0qVLcefOHfTv3x9vvvkmfHx8cP/+fbGjERERERERUQvBUq4WfH19ceLECbFj1NnJkycxYMAASKXSRh33yJEjcHV1bfRxX3b37l307t0bO3bswJYtW3D58mX07du3ya4XFBQEiURS46v8ttmqlJWVYeHChXBxcYG2tnaNx5YLDg5WjK2trV2v3GvWrFGMYWtrW68xGqJ8NmZubm6F7devX8fw4cNhbGwMAwMD+Pn54fz585XO/+yzz/DHH39UO/7UqVOhpaUFR0dHfPzxx0q9ndTa2hrbt2/H5cuXUVBQgNdeew0hISFKu35LJQgCzp8/j1mzZsHV1RVaWlqwsLCAt7c3du3axVmJRERERET0SmApVwu+vr5ITEzEgwcPxI5Sa6WlpYiIiICfn1+jjXn//n0EBARg4cKFSE9Pb7Rxq/LHH3/A09MTmpqauHbtGqZOnQo1NfF/XL28vKrd9/PPP2PlypWYPHky0tLSEBYW9o/jTZgwAYIgwNfXt96ZPv30UwiCIMpiHtevX4enpycGDx4MQ0NDxfZLly7By8sLBgYGiI2NxcOHD+Hk5IT+/fvj+PHjFcaYPn06Fi5ciC+++KLKa2zfvh2ZmZn47LPPsH79eqxdu7ZJ31NVunXrhvPnz+Odd97BhAkT8MEHH6CkpETpOVqKO3fuwNvbG3fv3sWePXuQk5OD//u//4O9vT0mTZqE+fPnix2RiIiIiIioyYnfcjQDvXv3hq6uLk6ePCl2lFq7dOkScnNzG7WU++KLL+Dl5YWoqCgYGBg02rgvCwoKwltvvYWpU6ciMjISjo6OTXatl73xxhsQBKHS6+7du9DS0sL06dOrPbf8uYNz5syBsbGxkhKLJzc3F/7+/vjXv/6FDz/8ULFdLpfj3XffhbGxMbZv347WrVujVatW2LRpE9q2bYvAwEDIZDLF8W3btsX+/fuxbNmyamehGRgYYMaMGdDV1UVERESTv7eqaGlpYf369fjzzz+xc+dOjBs3DsXFxaJkaQmkUqniVnRtbW04OTnh119/hZmZGTZs2FDhZ4SIiIiIiKglYilXC5qamvDx8cGxY8fEjlJrJ0+ehL29PVxdXRttzJ9//hmfffZZk962un//fsyaNQtff/011q1bB01NzSa71sucnZ2rvT323//+N0aOHAkrK6tqz3/69CnU1dWbtLBUJd999x3S0tKwZMmSCtvPnj2LmJgYjBkzBjo6Oort6urqePPNN5GUlITQ0NAK53Tu3BljxozBvHnzUFpaWu01jY2N8fTp08Z9I3X0r3/9C8eOHcPp06fx3nvviZqluWrfvj1KSkoqrZisqakJOzs7yGQyrnpLREREREQtHku5Who2bBhOnjzZbG5Zi4iIaNAtkVX5e8HSFBISEvDOO+9gxowZWLx4cZNeqyp+fn6YN29epe15eXn47bff8MEHH9R4fllZWVNFUzmCIGDbtm3o2bMnrK2tK+w7ffo0AFS5wEj5tqoWThk1ahSSk5Nx+PDhaq8rkUhqLO2UxcvLC3/88Qd27dqFbdu2iR2nxcjOzsa9e/fQtWtXGBkZiR2HiIiIiIioSbGUq6Xhw4cjNzcXFy9eFDvKP5LL5YiKikKvXr1qPC4uLg4jR46EkZERdHV10aNHD4SGhsLPz0+xcEBgYKCSUr+47dPOzg4//PCD0q5ZG9u3b4e9vT369evX4LH+/pnr6emhb9++OHfuXLXHP3nyBB999BEcHBygqakJc3NzjB49GtevX6/V9UpLS/HHH39g0KBBsLKygo6ODjw8PLBu3TrI5XIAL4qQlxe0+PbbbxXn/337mDFjAAA3btxAenp6lc+xi4uLA4AqF52wsbEB8GIRj5d16dIFAJrNjNShQ4di7ty5+PTTT/Hs2TOx44iuIb9PcnNzcf78eQQEBMDKygo7duxQcnoiIiIiIiLlYylXS05OTnB2dq7Vw/vFFhsbi9zcXHTv3r3aY+Lj49G7d29cvXoVe/bsQUZGBrZv345169bh5s2b0NLSUsyGUoa4uDj85z//wcqVK6GlpaWUa9aGIAj46aef/nGWHAAUFxfXmP3lzzw9PR0bN27EN998g/v371c6PjU1Fd27d0dISAg2btyIrKwshIeHIysrC717965VQXz06FFMmDABAwcORGxsLJKSkvDee+9h7ty5WLBgAYAXt4QKgoAhQ4ZATU0N8fHx+PzzzwG8eO6XIAjo3bs3fv/9d+zZswcAEB0dDaDq4i07OxsAoKenV2mfvr4+AFRZYpUXduVjV0VLS0ulZqt+8cUXUFdXx+bNm8WOIqqG/D759ttvYWRkBG9vb6irq2P//v3o2LGjCO+CiIiIiIhIuVjK1cHQoUObRSl3+fJlaGtr1/gP20WLFiE7Oxvr1q3DoEGDoK+vD3d3d+zevRvPnz9XYtoXDhw4AEtLS4wYMULp165JWFgYUlNTMWnSpH889tGjR1WWVOWq+sw9PDywfft2pKamVjp+4cKFSExMxNq1a/H6668r/h8FBwdDEATMnj27Vu+hf//+WLhwIUxMTNCqVSvMnj0bb731FtatW4fc3FzFcXPnzoVcLq+0uun58+fx6NEjjB07VrGtPG9dbzEUBAHAi9tQX2ZoaAiJRFLlZ1HO2toaKSkpKnELK/BiAYrx48dj3759YkcRVUN+n3z++eeQyWSIjY1F+/bt0bVrV3zzzTdKSk5ERERERCQelnJ1MGzYMNy8eRMpKSliR6nRlStX0LVrV2hoaFR7zNGjRwEAQ4YMqbDd3Nwc7du3b9J8Vbl58yZ69uxZZVkjpvXr12Py5MmKGV5VycrKwurVq5GYmFjjjLrqPnNra+sqF+Q4cOAA1NTUKhWVVlZWcHd3R1RUFJKTk2vMP2LECJw5c6bS9s6dO6OkpAQxMTGKbYMHD4aHhwd+/fXXCosprF69GrNnz67w81T+EP6qfsbKV56tqowp31bd6rRSqRSFhYXVvp8ZM2YgNzcXS5YsQWZmZrXHKVOvXr1w69YtReH4Kmro7xNNTU20b98emzZtQkBAAJYsWdKsVrsmIiIiIiKqD5ZydTBgwABoa2sr/gGqqq5cuYIePXpUu18mkyEvLw/a2tpVlk0vr4ioDPn5+Sq3aundu3dx/PjxGou2KVOmwMzMDJ999hn+3//7f/joo4+qPO6fPnMLC4tKx+fk5EAul8PIyKjSM9+uXbsGALh3716N7yEnJwdLliyBh4cHTExMFOfPnz8fAFBQUFDh+Dlz5qCgoAAbN25UfAZVrTKqra0NAFXeSlpewlRVGJYX2tWtClxaWlrjgiITJ07EsmXLsHr1apibm2Po0KHVHqssRkZGKCoqUqnbapVKhkb9feLv7w8AlVboJSIiIiIiamlYytWBjo4OBgwYoNL/WJTJZLh582aVK1+W09LSgoGBAYqKipCfn19pf0ZGRlNGrJKlpaXKzUBcv349+vXrBzc3t2qP+fXXX5GTk4Pg4GCsXbsWM2bMqPK4f/rMs7KyKh1vbGwMqVSKkpISCIJQ5WvAgAE1vgd/f3988803mD59Ou7evQu5XA5BEBSLabw8u+vtt9+GpaUlNmzYAJlMhu+//x7vvPNOpWKldevWAF6Ufi8rzxQVFVVpX/m2qlYGzs3NhSAIirGrsnjxYixatAibNm1Cdna2ShTkSUlJMDU1haampthRxKGFRv19Uv5cxpf/TBAREREREbU0LOXqKCAgAMePH680w0hV3LlzB8XFxYqVLKszbNgwAKhUaqSlpVW5MmZT8/b2xsWLFys840xMubm52LFjB2bNmvWPxxoaGmLs2LHo2rWrYiGEqlT3mWdmZuLOnTuVjh89ejRKS0tx/vz5SvtWrVoFe3v7Gp+tVlZWhvPnz8PKygofffQRzM3NFbcHV3eLqJaWFj744ANkZGTg+++/x++//46PP/640nHlzyusajacj48P3NzcsGfPHsVtruV5goODYWdnh+HDh1c6r7yUrelZiPv27YOjoyMCAwPr/Dy7pnL06FF4e3uLHUNUdf198umnn2LixIlVjlX+3M6aFqohIiIiIiJqCVjK1ZG/vz8KCwtx6tQpsaNUKTY2FlKpFC4uLjUet3z5cpiammLOnDk4ceIE8vPzER0djalTp8LKykpJaf9n5MiR0NTUxE8//aT0a1fll19+gb6+PkaNGlXrcwwNDWssFav6zG/fvo2JEydWedvfihUr0LZtW0ybNg1hYWHIyclBVlYWNm/ejK+//hpr1qyBVCqt9nrq6uro378/0tLSsHr1amRmZqKwsBBnzpxBUFBQted98MEH0NHRweeffw4/Pz84OztXOqZz586wsLDAjRs3Ku1TU1PDzz//jKysLEydOhVpaWl4+vQpZs2ahXv37mHr1q2K21//7vr16wBePNuuOnl5eTA0NKx2v7LFxMQgLCwMkydPFjuKqOrz+2T37t34+uuvkbojmr8AACAASURBVJCQAJlMhoSEBCxYsAC7du1Ct27dEBgYqOR3QUREREREpGQC1VmPHj2Ed999V+wYVVq6dKng6upaq2Pv3LkjjBw5UjA0NBR0dXUFLy8vISIiQvD19RW0tLQqHX/o0CEBQJWvrVu3Njj7V199Jejp6Qnx8fENHqsh5HK54OzsLCxZsqRO5/n5+Qnq6uo1HvP3z1xHR0fo3r27EBoaKvj6+io+y7//bD19+lSYO3eu4OTkJGhoaAjm5ubC4MGDhRMnTiiOWb16daX/H4sXLxYEQRCePHkizJgxQ7CzsxM0NDQES0tLYcqUKcJnn32mOLZbt26Vck6fPl0AIERERFT7XhYtWiRIpVIhJSWlyv3Xrl0Thg0bJhgaGgr6+vrCwIEDhXPnzlU73tixYwUbGxuhuLi42mNsbGyELl26VLtfmUpLSwVvb2/htddeE8rKysSOI4o/hD8ECC/+GqnL75OcnBxh27ZtwpAhQwQHBwdBU1NT0NfXF7p16yasWLFCKCgoEOPtEBERERERKZVEEF7hJQPrafny5Vi3bh0eP34MdXV1seNU8Oabb6KgoAAHDx6s9xh+fn44d+5chVsPlaG4uBi9evVCaWkpzp07p1IzompjxIgROHLkCORyudhRGmz79u346aefcPXq1WqPycnJgbu7O0aMGFHjzLvauHHjBrp27Yrdu3djwoQJ1R5nZWUFR0dHXLx4sUHXawxz5szBli1bcPHiRXTu3FnsOKIIQQjGYzwEVP/XiFi/T4iIiIiIiFQdb1+thzfeeAMZGRm4dOmS2FEqiYuLQ4cOHcSOUS+ampo4ePAgMjMzMWTIEGRnZ4sdqU5sbW0hCALS09PFjtJgQUFBmDt3bo3HGBkZ4dChQ9izZ0+Dbjt+8OABRo8ejYULF9ZYyJWUlCArKwu2trb1vlZj+eyzz/Dvf/8bv/766ytbyBEREREREVHDsJSrB3d3d7Rt27ZBs9Gaglwux927d9G+fXuxo9SbnZ0dwsPDkZKSgh49eiieM9YcDB06FACwcuVKPH36VOQ0dbNt2zaMGjUK+fn5CAoKwrNnzzBu3Lh/PK9r1664evUqwsLC6r1Ix+bNm7Fs2TIsW7as2mNycnKwdu1alJSUKD5nMeTk5GDs2LFYs2YNfvvtt1p9RkRERERERERVYSlXTyNHjsS+ffvEjlFBUlISCgoK0K5du3qdHxwcDIlEglOnTkEmk0EikYjysHVXV1dcvXoVjo6O6NWrF9atW6f0DPUxcuRIrFq1CseOHYONjY1iRcrm4sCBAzAxMcGmTZsQHBxc4yISf+fg4IDQ0NB63268atWqGmfITZkyBebm5ti2bRu++OILTJkypV7Xaai//voLnp6eOHv2LMLCwqpdPZReUJXfJ0RERERERKqKz5Srp8uXL6Nnz564evUqunXrJnYcAEBERAT69++P1NRUUVZQbWxlZWX45ptv8O2332LQoEH4/vvv4ebmJnYsesXk5uZi+fLl+PHHH9GvXz/s2rULFhYWYsdSCbV5phwRERERERFVjTPl6qlHjx5o27Yt/vjjD7GjKCQnJ0NDQ6PFFAbq6upYunQpwsPDkZGRgc6dO+PDDz9sdreGUvNUVlaGLVu2wMXFBdu2bcOaNWtw9OjRFvPni4iIiIiIiMTFUq4BxowZg+DgYKjKZMPk5GTY2NhATa1l/W/19vbGlStXsHnzZuzbtw/Ozs5YtGgRUlNTxY5GLZBMJsMvv/yCTp064cMPP8Rbb72Fe/fu4cMPP2xxf7aIiIiIiIhIPPwXZgOMHz8eSUlJuHz5sthRALwo5VRhZcqmoKamhmnTpuHu3bv49NNPsX37djg4OGDq1Km4deuW2PGoBcjKysLy5cvh4OCAmTNnokePHoiOjsYPP/wAExMTseMRERERERFRC8NSrgG6du2K9u3bq8wtrC25lCunr6+PxYsXIyEhAZs2bcKVK1fQuXNn9O/fH7/88ku9VwClV5NcLseJEycwefJk2NnZYc2aNZgyZQoePnyI7du3w9XVVeyIRERERERE1EKxlGugMWPG4M8//4RcLhc7CpKTk2FnZyd2DKXQ0tLCtGnTcOvWLRw5cgQWFhaYNWsWrKys8Oabb+LIkSMoLS0VOyapqOjoaCxYsAD29vYYPHgw7t27hzVr1uDRo0dYsWIFrK2txY5IRERERERELRxLuQYaN24ckpOTceHCBbGjIDU1Fa1btxY7hlJJJBIMHToUISEhSEtLQ1BQEDIzMzFixAhYWlpi3Lhx2LFjB7Kzs8WOSiIqKytDVFQUli5dCk9PT3h4eGD37t2YOHEi4uLicPHiRcycORP6+vpiRyUiIiIiIqJXhERQlVUKmjF3d3f4+vpi/fr1oubQ0dHBli1bMGnSJFFzqIKHDx9i3759CA0Nxblz5yCRSNCvXz+MGDECfn5+cHd3h0QiETsmNaG0tDSEh4cjNDQUYWFhyMrKQrt27eDv74833ngDffr04c9AA4UgBOMxHgL41wgREREREVFdsZRrBF999RWCgoKQnJwMdXV1UTIUFhZCV1cXhw4dwogRI0TJoKqePXuGsLAwHDp0CEePHkV2djbMzc3Rr18/+Pj4oH///ujYsSMLmmYuNTUV4eHhiIiIQEREBOLi4iCVStGnTx/4+/vD39+fz4hrZCzliIiIiIiI6o+lXCO4c+cO2rdvjzNnzqB///6iZEhJSYGtrS3Onz8PLy8vUTI0B2VlZfjrr78UxU1kZCSys7PRqlUr9OrVC56enujevTs8PT1hYWEhdlyqRkFBAa5fv46rV6/i6tWruHTpEu7evQupVIru3bvDx8cHPj4+6NOnDwwMDMSO22KxlCMiIiIiIqo/lnKNpHPnzvDy8sKmTZtEuX50dDQ8PDxw+/ZtdOjQQZQMzVFZWRlu3LiBs2fP4tKlS7hy5Qru378PALC3t4enp6fiGWRubm5wcHCAmhofxahMmZmZiImJQUxMDKKionD16lXcvn0bpaWlMDMzUxSpffv2RZ8+faCnpyd25FcGSzkiIiIiIqL6YynXSJYtW4Yff/wRqampkEqlSr9+ZGQk+vXrh7S0NFhaWir9+i3Js2fPcOXKFcUsrKioKDx69AgAoKuriw4dOsDNzU3xcnV1haOjI7S0tERO3nzJ5XKkpKQgPj4esbGxiI6ORlxcHKKjo/HkyRMAgLGxMbp06VJhNqOTk5PIyV9tLOWIiIiIiIjqj6VcI4mPj4eLiwuOHz+OQYMGKf36Bw8exMiRI1FUVMRyqAnk5uYqyqK/l0aJiYkAXqwCa21tDScnJ8XL0dERTk5OsLGxgZWVFbS1tUV+F+KRy+VIT09HamoqEhIS8PDhQzx48EDxSkhIQHFxMQDAxMSkQunp7u4ONzc32NjYiPwu6GUs5YiIiIiIiOpP+VO6WihnZ2f06NEDO3bsEKWUy8vLg5aWFgu5JmJoaIiePXuiZ8+eFbbn5eXh/v37FQqmBw8e4OLFixWKJgAwMzODlZUVbGxs0Lp1a1hbW6N169YwMzODqalppZeqy8/PR1ZWVoVXZmYm0tPTkZaWhpSUFMXXjIwMlJaWAqhYYDo6OqJXr16KIrNt27awsrIS+Z0RERERERERNT2Wco1oypQpmDdvHv7973/D2NhYqdcuLCyEjo6OUq9JgIGBAbp06YIuXbpU2ieXy/H48WMkJycjPT290te//voL6enpePr0qaKwKieRSBTlnKGhIfT19aGpqQljY2Noa2tDR0cHhoaG0NLSUixkoKGhAX19/Qrj6OjoVJihJ5fLkZOTU+GY4uJiPH/+HABQVFSEwsJC5ObmQiaTIS8vDwUFBZDJZHj27BkKCwsVBdzfC8dyJiYmsLKygqWlJWxsbODq6qqYKVj+1d7e/pWeNUhEREREREQEsJRrVG+99RbmzZuHPXv2IDAwUKnXlslknCWnYtTU1GBrawtbW9tqj5HJZJgwYQKOHz+OzZs3w93dHVlZWXj69Kmi/MrNzcXz588hk8mQnZ2N7OxspKamIicnBzKZDPn5+QBeFLNFRUUVxs/Pz0dJSUmFbcbGxpBIJIrv1dXVYWhoCADQ1NSEnp4eDAwMoKWlBUNDQ7Rq1QpaWlowMTGBjo4OTE1NYWJiUuXsPi6CQURERERERFQ7LOUakZGREQICArB9+3all3JFRUWcfdTM5OfnY+TIkbh27RpOnjyJ3r17ix2JiIiIiIiIiJSE01oa2dSpU3HhwgXExcUp9bpc4KF5ycrKgp+fH2JiYhAREcFCjoiIiIiIiOgVw1KukQ0aNAh2dnb47bfflHpdmUzGmXLNRGpqKnx8fJCRkYHIyEh4eHiIHYmIiIiIiIiIlIylXCNTU1PDpEmTsGPHDpSVlSnturx9tXl48OABvL29IZfLERkZCWdnZ7EjEREREREREZEIWMo1gSlTpiA1NRXHjx9X2jXLysr4kH0VFxMTg759+8LMzAwRERGwsbEROxIRERERERERiYQtThNwcXFBnz598OuvvyrtmhKJBIIgKO16VDeXL1+Gj48PXF1dcerUKbRq1UrsSEREREREREQkIpZyTWTKlCk4cOAAMjMzlXI9lnKq6/Tp0/D19YWXlxfCwsJgYGAgdiQiIiIiIiIiEhlLuSYyfvx4aGpq4o8//lDK9VjKqaYDBw7g9ddfx8iRI7Fv3z4+94+IiIiIiIiIALCUazL6+voYPXo0tm/frpTrsZRTPTt27MDYsWMRGBiI3377DVKpVOxIRERERERERKQiWMo1oalTpyIqKgq3bt1q8mupqamxlFMh69evx5QpUzBv3jxs2LCBi3AQERERERERUQVsCpqQj48P2rZtiy1btjT5tdTU1CCXy5v8OvTPVq1ahTlz5mDNmjVYuXKl2HGIiIiIiIiISAWxlGtCEokEM2bMwG+//Ya8vLwmvZampiZkMlmTXoNqJggCPvnkEyxevBjbtm3D3LlzxY5ERERERERERCqKpVwTCwwMRFlZGXbv3t2k19HV1UVBQUGTXoOqV1ZWhmnTpmHjxo0IDg7GtGnTxI5ERERERERERCqMpVwTMzExwdixY7Fx48YmvY6Ojg4KCwub9BpUNZlMhrFjx+LPP//EoUOHMGbMGLEjEREREREREZGKYymnBDNnzsTNmzdx/vz5JrsGSzlx5OfnY8SIEQgPD8eJEycwePBgsSMRERERERERUTPAUk4JevbsCU9PT2zatKnJrqGrq8tSTsmysrIwaNAgREdHIzw8HL179xY7EhERERERERE1EyzllOT999/Hn3/+ifT09CYZX0dHByUlJSgtLW2S8ami1NRU9O/fH2lpaYiMjESnTp3EjkREREREREREzQhLOSV56623oK+vj19++aVJxtfX1wcAPH/+vEnGp/95+PAh+vbti9LSUkRGRsLZ2VnsSERERERERETUzLCUUxIdHR1MnjwZQUFBKCsra/TxjY2NAQDZ2dmNPjb9T0xMDLy9vWFiYoKzZ8/C1tZW7EhERERERERE1AyxlFOiWbNmISkpCWFhYY0+tomJCQDg2bNnjT42vXDlyhX4+PjAxcUFp06dQqtWrcSORERERERERETNFEs5JXJ2doavr2+TLPhQPlOOpVzTOHPmDHx9fdG7d2+EhYXB0NBQ7EhERERERERE1IyxlFOymTNnIiwsDPfu3WvUcY2NjSGRSFjKNYGDBw/i9ddfh7+/P/bt2wcdHR2xIxERERERERFRM8dSTskCAgJgY2ODLVu2NOq4UqkU+vr6LOUa2c6dOzFmzBhMmzYNO3fuhIaGhtiRiIiIiIiIiKgFYCmnZFKpFDNnzsSWLVuQm5vbqGObmJiwlGtEGzZswJQpUzBv3jz89NNPUFPjHxciIiIiIiIiahxsGUQwc+ZMyOVybN++vVHHNTc3x5MnTxp1zFfVqlWr8NFHH2HVqlVYuXJlrc+7fv06hg8fDmNjYxgYGMDPzw/nz59vwqRERERERERE1ByxlBOBiYkJ3nnnHfz4448oLS1ttHGtrKyQlpbWaOO9igRBwNy5c7F48WJs2bIFn376aa3PvXTpEry8vGBgYIDY2Fg8fPgQTk5O6N+/P44fP96EqYmIiIiIiIiouZEIgiCIHeJV9ODBA7i6uiI4OBhjxoxplDEDAwORlJSEY8eONcp4r5qysjJMnz4dv//+O3bt2oWxY8fW+ly5XI5OnTohKysL9+/fVywGUVZWBnd3dxQUFODevXvQ0tJqqvhESheCEIzHeAjgXyNERERERER1xZlyInFycoK/vz++++67RhuTM+XqTyaTYdy4cQgJCcF//vOfOhVyAHD27FnExMRgzJgxFVZnVVdXx5tvvomkpCSEhoY2dmwiIiIiIiIiaqZYyonok08+wZUrV3Dx4sVGGc/S0hKpqamNMtar5Pnz5/D398fp06dx/PhxDBkypM5jnD59GgDg6elZaV/5tlOnTjUsKBERERERERG1GCzlRNSvXz/07NkTP/zwQ6OMZ2VlhczMTJSUlDTKeK+CZ8+eYdCgQbh58ybCw8Ph5eWl2BcXF4eRI0fCyMgIurq66NGjB0JDQ+Hn5weJRAKJRILAwEDFsQBga2tb6Ro2NjYAgLt37yrhHRERERERERFRcyAVO8Cr7uOPP8akSZNw//59tG3btkFjWVtbQxAEpKWlwc7OrpEStlxpaWkYMmQIcnJyEBkZCRcXF8W++Ph49O7dG3p6etizZw969+6NxMREzJkzBzdv3oSWlhaKiooUx2dnZwMA9PT0Kl1HX18fwIsCkIiIiIiIiIgI4Ew50Y0dOxY2NjbYsGFDg8cqL+KSkpIaPFZL9/DhQ/Tt2xfFxcU4d+5chUIOABYtWoTs7GysW7cOgwYNgr6+Ptzd3bF79248f/68TtcqX0tFIpE0Wn4iIiIiIiIiat5YyolMKpVi9uzZ+PnnnxWzrerLxsYGGhoaePToUSOla5lu376Nvn37wsjICGfPnq3yltOjR48CQKXny5mbm6N9+/aVjjc2NgaAKgu78m3lxxARERERERERsZRTAe+99x7U1NSwdevWBo2jrq4Oa2trJCYmNlKylufKlSvw8fFB27Ztcfr0aZibm1c6RiaTIS8vD9ra2opbT//OxMSk0rbyoi45ObnSvpSUFACAq6trQ+MTERERERERUQvBUk4FGBoaYtq0aVi/fj2Ki4sbNJa9vT1vX61GeHg4fH190bNnTxw9ehSGhoZVHqelpQUDAwMUFRUhPz+/0v6MjIxK2wYMGAAAiIqKqrSvfJuvr29D4hMRERERERFRC8JSTkXMnTsXGRkZ2LlzZ4PGadOmDWfKVeHQoUMYNmwYRowYgf3790NHR6fG44cNGwbgf7exlktLS6tyFVUfHx+4ublhz549FRaAKCsrQ3BwMOzs7DB8+PBGeCdERERERERE1BKwlFMRtra2mDRpElasWIHS0tJ6j8NSrrJdu3Zh9OjRmDJlCnbt2gUNDY1/PGf58uUwNTXFnDlzcOLECeTn5yM6OhpTp06FlZVVpePV1NTw888/IysrC1OnTkVaWhqePn2KWbNm4d69e9i6dSu0tbWb4u0RERERERERUTPEUk6FLFy4EAkJCdizZ0+9x3BycsL9+/cVK36+6n766Se88847mDdvHjZt2gQ1tdr9yLdt2xYXL15E9+7dMWbMGFhaWmLGjBlYuHAhnJ2dqzynV69euHDhAnJyctCuXTs4ODjg3r17CA8Pr7RgBBERERERERG92iQC2xuVMmHCBMTGxuL69euQSCR1Pj8yMhL9+vVDcnIybGxsmiBh87Fq1SosXLgQq1atwvz58xttXD8/P5w7d67CbapEr6IQhGA8xkMA/xohIiIiIiKqK86UUzGLFi3CrVu3cPjw4XqdXz6LKz4+vjFjNSuCIGDevHlYvHgxNm/e3KiFHBERERERERFRY2App2I6deqE4cOH49tvv63X+a1bt4aBgQHu3bvXyMmah7KyMgQGBmLDhg3YvXs3pk+fLnYkIiIiIiIiIqJKWMqpoM8//xyXLl3CmTNn6nW+k5PTKzlTrri4GBMmTEBwcDAOHjyIcePGNer4wcHBkEgkOHXqFGQyGSQSCQIDAxv1GkRERERERET0auAz5VTUwIEDIZVKcfz48TqfO3bsWJSVlWHfvn1NkEw1PX/+HKNHj8bly5cRGhqKPn36iB2JqMXjM+WIiIiIiIjqjzPlVNSiRYtw4sQJXLx4sc7nurm5ISYmpglSqaZnz55h8ODBuHHjBs6cOcNCjoiIiIiIiIhUHks5FeXn54fevXvju+++q/O5HTt2xP3791FYWNgEyVRLWloaBgwYgOTkZJw9exZdunQROxIRERERERER0T9iKafCFixYgIMHD+LmzZt1Os/DwwNlZWWIjY1tomSqISEhAX379oVMJsO5c+fg6uoqdiQiIiIiIiIiolphKafCAgIC4Onpia+++qpO5zk7O0NbWxu3bt1qomTii42NRd++fWFoaIizZ8/Czs5O7EhERERERERERLXGUk6FSSQSfP7559i/fz+uXr1a6/OkUinat2+P6OjoJkwnnqtXr6Jfv35wdHTE6dOnYW5uLnYkIiIiIiIiIqI6YSmn4gICAtC9e3d8++23dTrPw8OjRZZyERER8PX1RY8ePXDs2DEYGRmJHYmIiIiIiIiIqM5YyjUDS5YswcGDB3HlypVan9OxY8cWd/tqaGgohg0bhtdffx0HDhyAjo6O2JGIiIiIiIiIiOqFpVwzMHz4cPTs2RNff/11rc/p2LEjUlJSkJWV1YTJlGf37t0YPXo0Jk+ejN9//x0aGhpiRyIiIiIiIiIiqjeWcs3E0qVLERoaikuXLtXqeA8PDwBATExMU8ZSio0bN2LSpEmYO3cuNm3aBDU1/tgSERERERERUfPGdqOZGDp0KPr27VtpJdaCggKsXLkSiYmJFbbb2dnB2NhYcQtrQUEBIiMjsWbNGkRFRSktd0OtWrUKH374IZYvX46VK1dCIpGIHYmIiIiIiIiIqMFYyjUjX3zxBcLCwnDu3DmUlpZi69atcHBwwMKFCyss6iAIAuLi4mBhYYGgoCB4eHjA0NAQ/fr1w/z581FUVCTiu/gfmUwGQRCq3CcIAubPn4/FixcjKCgICxYsUHI6IiIiIiIiIqKmIxGqa0VIJfn4+CAnJwd5eXlISEiAIAiQSqX4+OOPoaenhwsXLuD//u//kJeXBzU1NWhoaEAmk1UYIykpCba2tiK9g/9Zvnw5njx5gh9++KHC9rKyMrz//vvYsWMHduzYgfHjx4uUkIhqEoIQjMd4COBfI0RERERERHUlFTsA1d6FCxeQlZWF6OhoqKurQy6XK/YlJSVh//79KC4uVmyTy+WVCjmpVApra2ulZa7Os2fPsGLFCuTn58PExARLliwBABQXF2PixIk4fPgwDhw4gGHDhomclIiIiIiIiIio8fH21WYgJiYGo0ePRp8+fRAXFwfgxWyyciUlJUhMTMSiRYugrq5e41itW7dWiYUSvvvuO0Vh+OWXX2L9+vUoKChAQEAAwsLCcOjQIRZyRERERERERNRi8fZVFbdhwwZ89NFHUFNTq1DEvczIyAjp6elwc3NDYmJitcf6+PggPDy8idLWTkZGBtq0aVPh2XYSiQT9+vVDbGwsjh49iq5du4qYkIhqg7evEhERERER1Z/4U6aoRoGBgQgICPjH48qfMxcUFFRtISeVSuHs7NzYEevsm2++qZRREARERkZi8eLFLOSIiIiIiIiIqMVjKafitLW1sXfvXkybNg0SiaTGY+Pi4jBo0CCMHTsWGhoalfarq6ujTZs2TRW1VhITE7F582aUlJRU2icIAubNm4djx46JkIyIiIiIiIiISHlYyjUD6urq2Lx5M7744osajyl/3tz69euhpaVV6ZiSkhI4ODg0Vcxa+fLLL6vdJwgC5HI53njjDZw/f16JqYiIiIiIiIiIlIulXDMhkUjw1VdfYf369ZBIJJVmzamrq+POnTsAACsrKyxbtqzSgg5yuVzUUi42NhY7d+6scpZcOblcjuLiYowYMQLR0dFKTEdEREREREREpDws5ZqZ2bNnY+fOnVBTU6tQupWUlCAmJkbx/axZs+Du7g6pVFrhfDFvX128eHGNq8OqqalBIpHA2toaS5Ysgb29vRLTEREREREREREpD0u5Zujtt9/GwYMHoaGhoSi5BEGoMLNMXV0dv/zyC+RyeYVtNjY2Ss8LAFFRUThw4ECVs+TKn3/n4eGBX3/9FQkJCfjkk09gaGio7JhERERERERERErBUq6ZGj58OM6ePQt9fX1FqZWSkoKioiLFMZ6enpg+fbpiv6WlZY0z1ZrSZ599VmnWXnmp6O/vjwsXLuD69euYPHlypeOIiIiIiIiIiFoalnLNWI8ePRAZGQkTExOoqalBLpcjPj6+wjErVqyAgYEBAMDJyUmMmDh37hxOnjyJkpISSCQSqKurQ09PDzNnzsTDhw+xd+9e9O7dW5RsRERERERERERi4JSkZur58+coLi6Gubk5QkJCMHHiRCQnJ+PIkSOQyWTIy8tDaWkpAGD69OlYtWoVdHV1cfLkSRQUFEAmk1U7toGBQbWz1XR1dRUru0qlUkXhZ2xsDIlEUmHmXrn58+cr/tvJyQnz58/HpEmToKur26DPgIiIiIiIiIiouZIIgiCIHaKly8vLw9OnT5GVlYWsrCzk5ubi+fPnyM/PR25uruL758+fIycnp9L3ZWVlyM3NBQBkZ2ejOfwv09LSgq6uriK7rq4ubGxsYGdnBz09Pejr68PAwABGRkbQ09ODnp4eDA0NFd8bGhrC1NRU8dLW1hb7LRHRS0IQgvEYDwGq/zuJiIiIiIhI1XCmXB0VFRUhPT0djx8/xpMnT5CamoonT54oCreqXlUtbqCtrQ09PT0YGRnBMkYQCwAAIABJREFUwMBAUUwZGxvD2toa+vr6iu8lEgmMjY0B/G8Wm46ODrS1taGhoQF9fX0AL57RdvjwYYwfPx7a2trQ0dFRXO/+/fu4ceMGRo8eXeGclwmCgOzs7Grff05OjmLxiOLiYjx//rzCObm5uSgrK1PMxjt16hRsbGxgamqK/Px8ZGdnKwrHJ0+eVPg+Ly+vwvh/p6urCzMzswpFnampKczMzGBmZgYLCwtYWFjA2toaFhYWMDc3F+35eURERERERERE/4Qz5f6ruLgYycnJSEpKQmJiIpKSkpCRkYG0tDSkpaUhIyMDqampyMnJqXCesbExLCwsKpRELxdHL5dIhoaGohRGpaWlzWIRhcLCQuTm5iIrK6vCDMOXX0+fPlW8MjIyKixyoaamVqmos7S0hLW1Nezs7GBnZwd7e3tYWVmJ+E6JmjfOlCMiIiIiIqo/1W9oGklhYSHi4+ORkJCAxMREPHr0CI8ePUJSUhISEhKQlpammKGlpaUFW1tbWFlZwcLCAh4eHrCwsICVlZViW3nR05xuq2wOhRwA6OjoQEdHB5aWlnU6LycnB6mpqYoCNT09vcKsxujoaKSlpSE1NVVxC7C2traioCt/tWnTBvb29mjbti3s7e2hpsb1UIiIiIiIiIiocbWomXLls90ePHiABw8eICYmBrdv38aDBw+QkJCgKN1MTEzQunVrWFtbw8nJCU5OThW+d3BwYBHTgpWUlChuPS7/WXn8+LHi+3v37ime4aehoQE7OzvFz4mbmxvc3d3h5OSENm3a8BZZeqVxphwREREREVH9NctSrqSkBHFxcbh165biFRMTg0ePHimKN1tbWzg7O8PFxQUuLi6K/27btm2FZ60RVSUzMxPx8fG4d+9epVd5YaetrY127drB3d0dnTp1goeHBzp27Ah7e3uR0xMpB0s5IiIiIiKi+lP5Uu7Jkye4evUqbty4gVu3biE6OhqxsbEoKSmBhoYG2rVrh44dO6JTp06KAs7FxQW6urpiR6cWKiMjA3fv3sW9e/dw584d3Lx5E9HR0UhKSgLw4jmD5QVdp06d0KVLF3Tt2hVaWloiJydqXCzliIiIiIiI6k+lSrmSkhLcvHkT586dQ1RUFKKiohAbGwtBENC6dWu4u7srbh90c3NDt27dOOuNVEZOTg7i4+MRExODqKgo3L59G9evX0dmZiakUilcXV3RrVs3eHt7o0+fPujQoQNvk6ZmjaUcERERERFR/YlaymVmZuLMmTMIDw/HxYsXcevWLZSWlqJVq1bo0aNHhZeZmZlYMYnqTRAExMfH4/Lly4rXX3/9BZlMBiMjI/To0QNeXl4YOHAgevXqBU1NTbEjE9UaSzkiIiIiIqL6U2opl5eXh4iICJw+fRqnT5/GzZs3oa6ujm7dusHLy0tRwDk5OSkrEpHSlZSU4Pr164qS7uzZs0hISICuri68vb0xcOBADBw4EK+99hoXkiCVxlKOiIiIiIio/pq8lLtz5w7279+PQ4cO4fLlyygrK0PHjh3h6+uLgQMHwsfHB4aGhk0ZgUjlPXjwQFFWnz59Gunp6TA2Noavry9GjRqF4cOHw9jYWOyYRBWwlCMiIiIiIqq/JinloqKisH//fuzfvx+3b9+Gubk5AgICMGjQIAwYMAAWFhaNfUmiFkMQBNy+fRunTp3CkSNHcObMGQDAgAEDMGrUKLzxxhuwsrISOSURSzkiIiIiIqKGaLRSLjExEdu2bcPOnTuRmJgIe3t7jBo1CqNGjYK3tzdvwyOqp+zsbBw+fBj79+9HWFgYioqK0KdPH7z77rv4/+zdeVzU1f4/8NfAINvAsMkigqKCiqQZ5pYbhlsulYpKeU1zwYdaWm5oltrNa2WZ1+UrKhhm7l6XG5prqWnupSVpAoqibLIOINsM5/eHv5krzoAwwHywXs/HYx7G+XzOOe/PZA8evR7nfM6IESN42AlJhqEcERERERGR8WoUymk0Ghw4cADr16/H999/Dzc3N4wZMwYhISEIDAyszTqJCEBhYSEOHz6Mbdu2Yd++fbC1tcWYMWMwadIk+Pv7S10e/c0wlCMiIiIiIjKemTGd8vLy8Omnn6Jp06Z4/fXXUVJSgp07d+LOnTv49NNPGcgR1RFra2u89tpr2LFjB5KSkjB37lzExMSgTZs26NGjB7777jtIeKAyEREREREREVVRtUK5hw8f4pNPPkHTpk2xdOlSvPHGG7h58yaOHDmCYcOGwcLCoq7qNEitViMqKgodO3aEs7MzHB0dERgYiNWrV6OkpKTSvhqNBvPmzYOvry+srKwwYMCACu+9ePEixo4dCx8fH1hbW8PJyQkBAQEYNmwY1q5di4SEBL2xIyIi0LVrVyiVSlhYWKBRo0Z45ZVXsHr1aiQmJurudXd3h0wmK/e5ceNGufGGDx8OmUyG+/fvl2tfsGBBuX6ffvppuetxcXGQyWTo3Llzhc+mUCj05pfJZDAzM0PDhg3x2muv4eLFixX2v3PnDoYMGQKVSlWu/cqVK7rDCezs7BAcHIwzZ85UOE5lDh48CD8/P8jl8mr3zc7ORkREBHr37g0nJydYW1vD19cXb775Jq5evap3f3h4OHbs2FHheOPGjYOlpSV8fHwwffp0FBUVVbum2uLq6oq5c+fq/ht0dHTEq6++ihdeeAEHDx6UrC4iIiIiIiIiqgJRRTt37hReXl7Czs5OLFq0SGRlZVW1a50ZPXq0ACDmzZsn0tLSREZGhvjss88EADFo0KBK+65bt04AEB9//LHIzs42eI9GoxGzZs0ScrlczJ49W1y/fl0UFRWJ1NRUceTIEREcHCwACACitLRU1y80NFSYmZmJzz77TCQlJYnCwkIRHx8v5s+fL2QymXB2di43z/r16wUAMWPGDL0a1Gq1cHBwEABEVFSU3vXMzEzh4OAgSkpK9K7NmzdPV19sbGyF38Wvv/4qAIhXX31V15aTkyP27NkjXF1dhYWFhTh69KjBfi4uLmLVqlXl2s+dOyesra3FyJEjRXJysnjw4IGYOHGikMvl4vDhwxXW8aT4+HgxePBg0bZtW2Fvby/Mzc2r3Fdr/PjxQi6XixUrVoiUlBRRUFAgTp06Jfz9/YW5ubnYu3ev3pw+Pj5iwYIFFY6pUqlERESEACCWLFlS7Zrq0pUrV8Trr78uAIh+/fqJmzdvSl0S/YXtEDsERJV/jRAREREREdFjnvp/UxkZGSIkJETIZDLx9ttvi5SUFFPU9VQJCQkCgGjfvr3etT59+ggA4sKFCxX2Dw0NFQCESqWq8J758+cLAGL9+vUGr6vVajFgwIByodyFCxcEADFx4kSDfaZMmaIXyt29e1cAEK1atdK7/8yZM8LGxkYAECEhIXrXt2/fXi5M09JoNMLT01O0b99eABCzZs2q8DkNhXJa3377rQAg2rRpU649NzdXNG7cWISFhenN26ZNG+Hh4SEePnyoa1er1aJly5bCy8tLFBUVVVjL40JDQ8XSpUtFaWmp8PT0NDqUmzRpkl77lStXBADh6+tr8JpMJhM7duyodGwbGxvRt2/fatdkCidPnhTPP/+8sLGx0QtNiWoLQzkiIiIiIiLjVbp99c8//0Tnzp1x7tw5HD58GFFRUXB3d6/txXpGSUpKAgC0bt1a71qrVq0AAHfv3q2wf2ZmJszNzWFnZ2fw+o0bN3Tvx5s4caLBe8zNzfHhhx+Wa4uNjQUAtGzZ0mCfESNG6LV5eXmhdevWuHHjhl7Nhw8fxuTJk6FQKHDs2DFoNBq96/369dMb88iRI5DL5Vi/fj0AYPPmzVCr1QZrqkxQUJDuuXJycnTtn3/+OVJTU/HRRx+Vu//UqVOIjY3F8OHDy50Kam5ujtDQUCQlJSEmJqZKc0dFRSE8PNyobatakZGRWLdunV57u3btYG1tjYSEBL13sLVr1w7Dhw/HzJkzK/3OHBwckJmZaXRtdalHjx64cOECZs2ahffeew9jxoxBcXGx1GURERERERER0f9XYSgXFxeHnj17wtnZGRcvXkSfPn1MWddTtWrVChYWFnrvXwMeBWoymQzPPfdchf2fDLeetH79epSVlSEkJKTS+7p06QIhhC44cnNzAwAcPXrU4P09e/ZERkaGXnv//v0BAIcOHSrXfujQIQwePBi9e/dGdnY2Lly4UO76kSNHdH0ft3HjRowdOxYdOnRA27ZtkZaWZtR7xh4PrGQyma4tMjISnTp1QqNGjcrd/8MPPwAAOnTooDeWtu348eNVmvvxUK+2FRQUoLCwEAEBAbrnetzrr7+Oe/fu4cCBAxWOIZPJjAo6TcXCwgKLFy/GwYMH8d1332HYsGEoLS2VuiwiIiIiIiIiQgWhXF5eHvr164dmzZrh+PHjuqCpPnFzc8MXX3yBq1evYv78+Xjw4AGysrLw+eef49ixY/joo4/g5+dn9PinTp0CALRt27Za/bp37w53d3ccPnwYAwYMwIkTJ1BWVvbUftrVbocPH9a1ZWVl4caNG+jatavB69euXYONjQ18fHzKjZWVlYXvvvsOb731FoBHhxMAj4K66jpx4gQAoE2bNlAqlQCAq1evIi0tDe3atdO7XxuSNm7cWO+ap6cnAODmzZvVrqO27dq1CwDwwQcfGLz+/PPPAyj/fT+r+vTpg0OHDuHkyZOYNWuW1OUQERERERERESoI5RYuXIi8vDzs378ftra2pq6pyt59911s27YNmzdvhqurK5ydnbFs2TJERkZi0aJFlfYtKSmBpaVlhdeTk5MBAM7OztWqSaFQYNeuXfDy8sKhQ4cQFBQEDw8PjB49Gtu2bcPDhw8N9uvZsyesra1x/Phx3eqro0ePomfPnmjQoIEulHt8JV1FW1e3bt2KLl266MK60aNHw8LCAgcOHEB6enqVnkOlUmHv3r14//33YWFhgRUrVuiuXbt2DYDh4E27xdXQ3xuFQgHg0YmoUkpLS0N4eDgmTJhgcDsx8L8AUfushlhaWj4zK886deqEdevWYfXq1Th//rzU5RARERERERH97emFcgUFBYiKisKCBQvQsGFDKWqqEiEEJk2ahDfffBPvv/8+UlNT8eDBAyxZsgTTpk3DqFGjKt1aePfuXYOh0pMMbW18mm7duiEuLg6bNm3Cq6++isLCQmzZsgVvvPEGvL29sX37dr0+VlZW6NGjB3Jzc3Hu3DkA5UO35s2bo3nz5rh48SKysrJ01w1tXf366691q+MAwMXFBYMGDYJarcbmzZsrrHv//v2QyWSQyWRwcHDAxIkT0blzZ5w5cwbBwcG6+1JSUgBAt3KuqrRbYY35TmtLZmYm+vfvj169eiEiIqLC++zt7SGTyXTPakijRo1w//79er2F9XFvvPEGOnbsiJUrV0pdChEREREREdHfnl4od+XKFahUKgwdOlSKeqps8+bN2LBhAyZPnoz33nsPbm5ucHFxwaRJkxAeHo4dO3Zg9erVev2ysrKwbNky3LlzB1OmTKlwfO270gy9/60qLC0tMWbMGOzbtw9ZWVk4fvw4Ro0ahczMTIwePRq//vqrXp8nV8M9+b64/v37o6ysDEePHkVhYSEuXLiAXr16lRvjt99+Q1xcHIYNG1auXRvSff311xXW/Oqrr0I8OpEXZWVlyMjIwP79+/Hiiy+Wu6+oqAjAo3eWPcnBwQHAo3D3Sdo27T2mVlBQgH79+sHf3x9btmyBubl5pffL5XIUFhZWeD0sLAwqlQofffSR0X9PTG3YsGG6rdlEREREREREJB29UE67CsvFxcXkxVSHNrh6fAWX1ssvvwwA+P7778u1jx07Fs7OzggPD8ecOXPw7rvvVjh+z549ATwKuWpKLpejd+/e2LZtG+bOnQuNRoPdu3fr3acN4A4fPozff/8dVlZWaN68ue764++VO3nyJDp06KC3TXTjxo3Iy8uDra2tbtWbTCbDkCFDADw6RfXJwyKqy8rKCgAMbt3Unnx77949vWv3798HgBq9689YarUaISEh8PT0xKZNm54ayGn7VHbYxOjRo7FkyRIsW7YMDRs2NLhqsb5p2LBhvT0xloiIiIiIiOjvRC+Ua9q0KQDg+vXrpq6lWgytxHpSfn5+uZ+jo6ORm5uL7du3Y/ny5QgLC6uwb1hYGORyucHw7HFz5syBmZmZ7oCDM2fOVHowRlBQEADD71Vr3bo1vLy8cPnyZXz77bd674sLCgpCgwYNcPjwYRw6dEjvemlpKbZs2YIzZ87oVrw9/pkxYwaAylfLVYWHhwcAIDc3t8Lnu3z5st41bZs2NDWlsLAwFBcXY+fOnbqTcgGgRYsWuu3Cj1OpVBBC6J7VkA8++ADz58/H2rVrkZOTo3dybn0UGxurdzAIEREREREREZmeXigXEBAAPz+/St+3VR906tQJAHD8+HG9az/88AMAoHPnznrX7O3tERISgvbt21cauPn5+WHhwoW4dOlShaeW/vnnn1i3bh1GjBihWyEmhEB6errBoAcALl26BABo3769wev9+vWDEAIrV67UW3mlUCjw0ksvITk5GdHR0Xqh3HfffQcXFxd07drV4Njjx48HAGzbtq3SbZlPExAQAMDwariePXvC398fu3fv1m1zBQCNRoPt27fDy8sLAwcONHpuYyxatAixsbHYv39/pYd7PE67qk/7rIbs2bMHPj4+mDBhQrXfryeF/Px8fPvtt3pbm4mIiIiIiIjI9PRCOZlMhoULFyIqKspg4FVfTJkyBb6+vli7di1WrlyJ9PR0ZGZmIioqCp9++ik8PT0xa9asCvvb29tDpVJVOseCBQsQHh6OyZMnIzw8HDdv3kRJSQnu37+PqKgoBAUFoW3btoiKitLrO2LECGzduhXJyckoLi5GYmIivvjiC3z88ccIDAzEmDFjDM6pDeI0Go1u1dnjtEGcjY0N2rZtW+7a119/jbfffrvC5wkICEDHjh2Rm5uLPXv2VPrslWnXrh1cXV1x9epVvWtmZmaIiopCVlYWxo0bh9TUVGRmZmLq1KmIi4vDhg0bdNtftUaPHg2ZTIbbt28bXVNF40RHR2Px4sU4f/487Ozsym3plclkSEhIMDjWlStXAAB9+/atcL68vDzY29vXqGZTeu+991BaWopp06ZJXQoRERERERHR355eKAc8OqVx1KhRGDp0KC5evGjqmqrEwcEB58+fx4wZM7B27Vp4e3ujUaNGWLp0Kd5++21cvny50q2HVT0BdOnSpThz5gySk5MRHBwMhUKB1q1bIzIyEuHh4Th+/Hi597p17doVp0+fxsiRI7Fy5Uq8+OKLUCgUaNu2LXbs2IFFixbh1KlTFa7YCg4Ohlwux0svvQSFQqF3XRvKPb5K7t69e5DJZIiJicGcOXMMrhBMTEyETCbTvU9u9OjRcHd3h0Kh0K3a056+ql31VxGZTIYJEybg/PnzSE5O1rveuXNn/Pzzz8jNzUXLli3RtGlTxMXF4cSJE3qr+4BHp7kqFAp4e3uXa4+JidGFZ/fv34dGo9H9HBkZWaVxnrb9uCJ79+6Fp6fnU1f1SXmSbHUsXrwYX3/9NSIjI+Hq6ip1OURERERERER/ezIhhDB0oaSkBEOHDsWJEycQHR2N4cOHm7q2OjVo0CAcPHgQZWVlUpfyTMrNzUWbNm0waNCgGm11zsnJQaNGjfDmm29iw4YNko8DAFevXkX79u2xdetWjBo1qsL73N3d4ePjg7Nnz9ZovrpUXFyMqVOnIjo6GmvXrsXEiROlLon+QnZiJ0ZiJAQM/hohIiIiIiKiShhcKQcADRo0wL59+zB27FiEhIRg/PjxBl/s/6xq3LgxhBBIS0uTupRnklKpxHfffYfdu3djzZo1Ro0hhMC7774Le3t7/POf/zS6ltoaBwBu3bqFoUOHYt68eZUGcqWlpcjKykLjxo1rNF9d+uWXX9ChQwfs2rUL+/btYyBHREREREREVI9UGMoBgFwux+rVq3HgwAEcOnQIzZs3x7///W9oNBpT1VdntO9u+/TTT5GZmSlxNc+m9u3b49KlS/j++++f+n4+Q9LS0nDr1i0cP34c7u7uRtdRW+MAwLp167BkyRIsWbKkwntyc3OxfPlylJaW6h3GUR9kZmZi+vTp6NSpE5RKJS5fvoxBgwZJXRYRERERERERPabC7atPys7OxmeffYavvvoKjRs3xty5c/H2229DLpfXdY115vPPP0d0dDRu3bqFoKAgfP/991KXRPXc2LFjsXXrVjRp0gShoaFYuHAhzM3NpS4LwKMwbtWqVVixYgVsbW2xcOFCTJgwAWZmlWbvREbj9lUiIiIiIiLjVTmU0/rzzz/xySefYNu2bWjSpAkmTJiAcePG1XiFEhEZ58KFC1i/fj22b98OGxsbzJw5E9OmTSt3AAlRXWAoR0REREREZLxqL6Fp2bIlNm/ejBs3bmDIkCH44osv4O3tjZCQEBw9ehTVzPiIyAgqlQpr165F+/bt0alTJ1y4cAGfffYZbt++jblz5zKQIyIiIiIiIqrnqr1S7klFRUXYtWsX1q9fj9OnT6Np06YYNmwYhg4dis6dO3PrHFEtycvLw8GDB7Fnzx4cOHAAQgiMGDECkyZNQpcuXaQuj/6GuFKOiIiIiIjIeDUO5R4XGxuLzZs3Y+/evbh58yY8PDzw6quvYujQoejVqxcsLCxqayqiv4WMjAz897//xd69e3H06FFoNBr07NkTw4YNQ2hoKBwcHKQukf7GGMoREREREREZr1ZDucfFxsZi79692Lt3L3755Rc4ODigV69e6N27N3r37o02bdrUxbREz7SioiKcPXsWP/zwA3744QecP38eFhYW6Nu3L15//XUMHjwYzs7OUpdJBIChHBERERERUU3UWSj3uMTERHz33Xc4duwYTp06hZycHLi7u+sCuqCgIDRr1qyuyyCqd9RqNS5duqQL4X7++WcUFhaiRYsWCAoKQt++fdG/f38oFAqpSyXSw1COiIiIiIjIeCYJ5R6n0Whw5coVnD59GmfOnMHhw4ehUqng7u6ODh06IDAwEIGBgejatStXBNFfTnJyMi5fvozLly/jzJkz+Pnnn/Hw4UO4ubmhR48eCA4ORp8+feDj4yN1qURPxVCOiIiIiIjIeCYP5Z5UXFyMCxcu4Pz58zh37hwuXLiApKQkmJmZoWXLlujYsSM6duyI559/HgEBAbC3t5eyXKIqS0pKwrVr13D58mVcuHABFy5cQFpaGuRyOQICAtCpUyd07NgRXbt2RatWraQul6jaGMoREREREREZT/JQzpCUlBRdiHHu3DlcunQJKpUKANC0aVMEBATgueeeQ9u2bREQEICWLVvyEAmSTG5uLn7//Xdcu3YNv/32G65du4bff/8dOTk5AIAmTZqgY8eOuhAuMDAQNjY2EldNVHMM5YiIiIiIiIxXL0O5JwkhkJiYqBd83Lx5E6WlpWjQoAFatmwJPz8/+Pr6wtfXFy1atICfnx/c3d2lLp/+AkpLS5GYmIi4uLhynxs3buDu3bsAAHt7e11g/NxzzyEgIABt27aFo6OjxNUT1Q2GckRERERERMZ7JkK5ipSUlOD69eu4du0arl27pgtK4uPj8fDhQwCAnZ2dLqjz9fVFs2bN4O3tDS8vL3h7e8PKykrip6D6IisrC0lJSbh79y7u3LmD+Ph43d+pxMRElJaWAgBcXV11f59atmyJgIAABAQEoGnTptI+AJGJMZQjIiIiIiIy3jMdylXm3r17uoDu8ZVNt27dQmFhoe4+Nzc3XUDn5eWFpk2bwsvLC56envD09ISrqyssLS0lfBKqDSqVCsnJyUhLS8OdO3dw9+5dXQCnDeEKCgp09zds2BDNmjWDr6+vbgVmixYt4OvrC6VSKeGTENUfDOWIiIiIiIiM95cN5SqTkZGhC2W0Ac3jP6empuLxr8XR0RHu7u5wc3NDo0aN4OrqCg8PD7i7u8PV1RXu7u5wdHSEk5MT7OzsJHyyvw8hBLKyspCVlYXMzEykp6cjJSUFqampSE9Px/3793VtaWlp5YJYS0tLg0Gstq1JkyawtraW8OmIng0M5YiIiIiIiIz3twzlnqakpATJyclISUlBenq6boVVWlqaXltRUVG5vhYWFnBycqr0Y2dnB4VCATs7OyiVStja2sLW1hb29vawt7eHubm5RE9uOoWFhSgoKIBKpYJKpUJBQQEKCgqQm5uLvLw8qFQqXeim/WRnZ+tCuOzsbL0xHRwc4OHhAVdXV1146u7uXq7Nzc2N7xkkqiUM5YiIiIiIiIzHUK6GcnNzkZ6erhcgVRQoZWVlIS8vTy/Me5y1tbVeSKdQKGBhYQFLS0vY2NjA3Nwc9vb2AB6FUTKZDLa2tmjQoEG5cSp6Z56dnR3kcrlee2FhYYW1qVQqaDQa3c/5+fkoLS1FcXExHj58CI1GozslNzs7G2VlZSgsLERJSYleCPf4OE+yt7eHnZ2dbvWhoY+zs3O5n11dXfl+QCITYyhHRERERERkPP1UhqpFqVQa9Y4xtVqNvLw85ObmYtmyZYiIiMBnn30GHx8f5Ofno6CgAHl5ecjJyYEQQhdkPXz4EMXFxSgqKkJGRgaEEMjJyQEA5OXlQa1W6+aoKPx6vM+TLCwsoFAoDF57MuSzsbGBpaWlro9MJoODgwMAID4+HjY2NujTpw+srKxgaWkJhUIBpVKpWyloa2tr8GciIiIiIiIior86hnISkcvlcHR0RGRkJNauXYv/+7//w+TJkyWpJT8/H3Z2dvj+++/Rv3//WhnzP//5D0JCQrB06VIMGTKkVsYkIiIiIiIiIvqrMJO6gL+zL7/8EnPnzsXq1aslC+QAwNbWFnK5HLm5ubU25rBhwzBmzBiMHz8eKSkptTYuEREREREREdFfAUM5iXz11VeYPXs2Vq1ahSlTpkhai0wmg52dXa2GcgCwZs0aODk54a233kJZWVmtjk1ERERERER04MkAAAAgAElEQVRE9CxjKCeBdevWYebMmVixYgWmTp0qdTkAHr0br6L3zBnL1tYWW7duxcmTJ7FixYpaHZuIiIiIiIiI6FnGUM7Ejh49imnTpmHRokV49913pS5Hx8HBodZXygFAYGAgFi1ahPnz5+P333+v9fGJiIiIiIiIiJ5FDOVM6MaNGxg5ciSGDh2KDz/8UOpyylEqlXUSygHA3Llz8fzzz2Py5MncxkpEREREREREBIZyJpOZmYnBgwejdevW2LRpE2QymdQllVOXoZyZmRk2bNiAixcvIjIysk7mICIiIiIiIiJ6ljCUM4GSkhIMHz4carUae/fuhZWVldQl6anLUA4AnnvuOUyfPh1z5sxBcnJync1DRERERERERPQsYChnApMnT8avv/6KmJgYuLq6Sl2OQXUdygHA4sWL4eTkhNmzZ9fpPERERERERERE9R1DuTr2zTffIDo6Gt9++y3atGkjdTkVMkUoZ2NjgzVr1mDr1q04ePBgnc5FRERERERERFSfMZSrQ/Hx8Zg2bRree+89DBo0SOpyKmWKUA4ABgwYgGHDhmHGjBkoKSmp8/mIiIiIiIiIiOojhnJ1RK1WIzQ0FK1atcLSpUulLueplEolcnJyTDLX8uXLkZSUhIiICJPMR0RERERERERU3zCUqyPLli3D77//jujoaDRo0EDqcp5KqVRCpVJBCFHnc3l7e+Odd97BP//5T5OsziMiIiIiIiIiqm8YytWBGzdu4OOPP8bixYvh7+8vdTlV4uDggLKyMuTn55tkvnnz5qGsrAxffvmlSeYjIiIiIiIiIqpPGMrVgXfeeQf+/v6YOXOm1KVUmVKpBACTrVxzdHTErFmzsHLlSmRnZ5tkTiIiIiIiIiKi+oKhXC3bu3cvjh8/jhUrVkAul0tdTpWZOpQDgKlTp8Lc3BwrV6402ZxERERERERERPUBQ7laVFJSgtmzZ2PUqFHo3r271OVUixShnL29PaZPn45///vfyMvLM9m8RERERERERERSYyhXi7755hskJSXh008/lbqUatOGcqY6gVXrnXfeQUlJCaKjo006LxERERERERGRlBjK1RKNRoPPP/8cY8eOhbe3t9TlVJutrS3kcrnJT0N1dHTE6NGjsWrVKpSVlZl0biIiIiIiIiIiqTCUqyVbt27F7du3ER4eLnUpRlMqlSYP5QBg2rRpiI+Px5EjR0w+NxERERERERGRFBjK1ZK1a9di6NCh8PHxkboUo0kVygUEBKB79+6Iiooy+dxERERERERERFJgKFcLfvvtN5w9exaTJ0+WupQacXBwQHZ2tiRzjxkzBjExMZLNT0RERERERERkSgzlasHGjRvh5+eHXr16SV1KjTg6OkoWioWEhMDMzAy7du2SZH4iIiIiIiIiIlNiKFcL9u/fj5EjR0Imk0ldSo04OTlJFsrZ29tj0KBB+M9//iPJ/EREREREREREpsRQroauXLmCxMREDBkypMZjHTx4EH5+fpDL5bVQWfXVZKVcdnY2IiIi0Lt3bzg5OcHa2hq+vr548803cfXq1SqN0bdvX5w+fRrFxcVG1fC4K1euYODAgXBwcICdnR2Cg4Nx5syZGo9LRERERERERFQbGMrV0KFDh+Dh4YHAwECjx0hISMCQIUMwb948pKWl1WJ11VOTUG727Nl455138Oqrr+KPP/5AZmYmNm7ciCtXriAwMBD79u176hh9+vTBw4cPcfbsWaNq0Dp//jy6du0KOzs7XL9+Hbdv30azZs3Qq1cvnvBKRERERERERPUCQ7kaOnfuHF566aUabV398MMP0bVrV1y+fBl2dna1WF31ODo6Iisry+j+b7/9NqZPnw53d3fY2Nige/fu2Lp1KzQaDebMmfPU/t7e3mjevDmOHz9udA1lZWUYP348HBwc8PXXX8PDwwMuLi5Yu3YtmjdvjgkTJtTKSjwiIiIiIiIioppgKFdDFy9eRIcOHWo0RlRUFMLDwyXbtqpVk5VykZGRWLdunV57u3btYG1tjYSEBAghnjpOz549a7RS7tSpU4iNjcXw4cNhbW2tazc3N0doaCiSkpIQExNj9PhERERERERERLWBoVwNZGRkIDk5Ge3bt6/ROI+HR1JydHSESqWCRqOptTELCgpQWFiIgICAKq0m9PPzQ3x8vNHz/fDDDwBgMCjVttVkJR4RERERERERUW1gKFcD9+/fBwA0adKkXPuNGzfw2muvQalUwsbGBh07dkRMTAyCg4Mhk8kgk8kwYcIEKUqulJOTE8rKyqBSqQDUznPs2rULAPDBBx9UqYbmzZsjKSmp3BbT6tRx48YNAEDjxo31xvb09AQA3Lx5s0q1EBERERERERHVFWn3Sz7jUlJSAAAeHh66tvj4eHTp0gW2trbYvXs3unTpgjt37mDGjBn47bffYGlpiaKiIqlKrpSjoyMAICsrC5mZmTV+jrS0NISHh2PChAkYMWJElWpo0aIFysrKkJiYiJYtW1b7+8zJyQEA2Nra6o2tUCgAwOgtukREREREREREtYUr5WogKysLDRo0gL29va5t/vz5yMnJwb///W/06dMHCoUCbdq0wdatW1FQUCBhtU+nDeWys7Nr/ByZmZno378/evXqhYiIiCrXoF11mJSUBKB2v0/tO+1qcigHEREREREREVFtYChXyw4dOgQA6NevX7n2hg0bolWrVlKUVGWPh3I1eY6CggL069cP/v7+2LJlC8zNzatcg/b9etrVb9Wtw8HBQVeDoboev4eIiIiIiIiISCoM5WrA3Ny83KEIxcXFyMvLg5WVlW6r5OO0oVd9ZW9vD3Nzc6Snpxv9HGq1GiEhIfD09MSmTZuqFcgBQIMGDQA8+i6N+T61Qd29e/f0rmnfAejn51etmoiIiIiIiIiIahtDuRqwsrKCRqPRHUpgaWkJOzs7FBUVIT8/X+/+9PR0U5dYLWZmZlAqlcjPzzf6OcLCwlBcXIydO3dCLv/fKwtbtGiBc+fOVakGuVyOkpISo77PoKAgAMDly5f1rmnbXn755afWQURERERERERUlxjK1YD2/WeJiYm6tgEDBgD437ZLrdTU1Gfi1E9HR0dkZWUZ9RyLFi1CbGws9u/fD0tLS6NrkMvlUKvVAKr/ffbs2RP+/v7YvXt3uQMgNBoNtm/fDi8vLwwcONDo2oiIiIiIiIiIagNDuRrw8fEBANy+fVvX9q9//QtOTk6YMWMGjh49ivz8fFy7dg3jxo2Du7u7VKVWmaOjI7Kzs6v9HNHR0Vi8eDHOnz8POzs7yGSycp+EhIQqzV9YWIiioiLd1tTq1mFmZoaoqChkZWVh3LhxSE1NRWZmJqZOnYq4uDhs2LABVlZWNfuSiIiIiIiIiIhqiKFcDSiVSri5ueHatWu6tubNm+Ps2bN48cUXMXz4cLi5uSEsLAzz5s1DixYtDI4TExOjC6/u378PjUaj+zkyMtJUjwPgf6FcdZ9j9+7dtTJ/ZmYmAMDZ2RmAcd9n586d8fPPPyM3NxctW7ZE06ZNERcXhxMnTugdGEFEREREREREJAX502+hynTv3h0nT57ErFmzdG1+fn7Yu3dvlccYNGgQhBB1UV61OTk5ITs7G0D1niMmJqZW5s/KygLwv1CuunVotW/fHgcPHqyVmoiIiIiIiIiIahtXytVQUFAQTp48idLSUqlLqRXalXJSefDgAYDyoRwRERERERER0V8NQ7ka6tu3L/Ly8nDixAmpS6kVUody169fh6OjI0M5IiIiIiIiIvpLYyhXQy1atMBLL72EqKioCu/Zvn07ZDIZjh8/juLiYshkMkyYMMGEVVad9vRVQ0zxHH/88QcCAgIqvedZ+j6JiIiIiIiIiAyRifryMrNnWHR0NMLCwnDv3j00bNhQ6nJqJDIyEjNnzkRubq4k8/fq1QutWrVCRESEJPMTUdXtxE6MxEgI8NcIERERERFRdXGlXC0YMWIEFAoF1qxZI3UpNebk5IS8vDyo1WqTzy2EwLVr1+Dv72/yuYmIiIiIiIiITImhXC2wsbHB+++/jy+//FJ3UMGzytnZGUIIZGZmmnzuP/74A5mZmejatavJ5yYiIiIiIiIiMiWGcrVkxowZsLGxwfLly6UupUZcXFwAABkZGSaf++TJk7Czs8Pzzz9v8rmJiIiIiIiIiEyJoVwtsbW1xZw5c7Bq1SqkpaVJXY7RtKGcFCvlTp48ie7du0Mul5t8biIiIiIiIiIiU2IoV4umTJkCpVKJDz/8UOpSjObk5ASZTGbylXJlZWU4efIkevToYdJ5iYiIiIiIiIikwFCuFllbW+PLL79EZGQkTp8+LXU5RrGwsIBSqTR5KPfzzz8jLS0NgwcPNum8RERERERERERSYChXy0aNGoWBAwdi8uTJKCkpkbocozg7O5s8lNuzZw/8/Px48ioRERERERER/S0wlKsDq1evRmJiIr788kupSzGKi4uLyd8pt2/fPoSEhJh0TiIiIiIiIiIiqTCUqwNNmjTBhx9+iI8//hi///671OVUm6lDuQsXLuD27dt4/fXXTTYnEREREREREZGUGMrVkdmzZ6NLly4YNWoUHj58KHU51eLi4lJu+6parUZqairu379f47H37NmDwsLCcm0bN25Eq1atEBgYWOPxiYiIiIiIiIieBQzl6oiZmRm++eYbpKWlYcaMGVKXU6G7d+9i+/btWLVqFRYuXIgpU6bg4sWLuHDhApo3bw4HBwdYWFjAw8MDGzZsqPF8kyZNQpMmTbBmzRqUlJSgsLAQO3bswKRJk2rhaYiIiIiIiIiIng0yIYSQuoi/sn379mHo0KHYvn07RowYoXc9NzcXSqVSgsoeuX79Otq0aQMzMzPI5XKUlZWhtLTU4L0nT55Ejx49jJ5LpVLpntXMzAxubm7o378/tmzZgnv37qFhw4ZGj01EprcTOzESIyHAXyNERERERETVxZVydey1117D1KlTMX78ePz222/lrj148ABdu3bF6dOnJaoOaN26Nfr16wczMzMUFxdXGMhZWlqiU6dONZorLi5O989lZWVITU3Fpk2bYGVlhb1790Kj0dRofCIiIiIiIiKiZwVDORNYvnw5OnXqhCFDhiAtLQ0AkJWVhaCgIPzxxx9YsGCBpPXNnj27wjAOAGQyGbp16wZLS8sazRMfHw+ZTKb7WQiBsrIy5OfnY/LkyWjVqhW++eYblJWV1WgeIiIiIiIiIqL6jqGcCVhYWGDnzp1o0KABBg0ahLS0NAQHB+PmzZsAHm0LPXXqlGT19e7dGwEBATAzM/zXQS6Xo0+fPjWeJyEhAQ0aNNBrLysrgxACt27dwltvvYUePXqgqKioxvMREREREREREdVXDOVMxMnJCf/9738RFxeHbt264dq1a7rVaXK5HAsXLpS0vtmzZ6Oi1wuWlpbi5ZdfrvEc8fHxlW5RlclksLa2xieffAIrK6saz0dEREREREREVF8xlDMhb29v+Pn5ITExsdx2UbVajRMnTuCnn36SrLbQ0FC4uroavKZQKNC+ffsaz/HHH39ArVYbvGZubg5ra2scP34cvXr1qvFcRERERERERET1GUM5EyksLMSAAQPw66+/GgympF4tZ2FhgenTp0Mul5drNzc3R1BQEMzNzWs8R3x8vMF2uVwOpVKJ06dPo0uXLjWeh4iIiIiIiIiovmMoZwLFxcUYMmQIzp49W+FKMbVajR9//FHSk1gnT56sF8rJZDIEBwfXeOyCggJkZWXptVtYWKBhw4Y4e/Ys2rVrV+N5iIiIiIiIiIieBQzlTGDSpEk4duxYpSecAo9WjH344Ycmqkqfo6Mjxo8fDwsLC12bWq1G7969azx2fHy83jvrLCws4ObmhtOnT8PPz6/GcxARERERERERPSsYypnAmjVrsGLFCnh4eEAmk1V4yml9eLfczJkzyx3G4OjoiDZt2tR43Pj4eMhkMt3PFhYWaNq0Kc6fP49mzZrVeHwiIiIiIiIiomcJQzkTUCgUmD59Ou7cuYPo6GjdqjBD72mT+t1yPj4+GDhwICwsLCCXy9G3b99yYZqx4uPjdSvwLCws4O/vj59//hmNGjWq8dhERERERERERM8ahnImZGFhgTFjxuD69ev46aef0KdPH127lvbdclKulps9ezZKS0uh0Wjw8ssv18qYCQkJUKvVkMvl6NixI3766Se4uLjUythERERERERERM8a+dNvobrQrVs3fP/99/jll1/w5ZdfYvv27TA3N0dpaSnkcjkWLVqE48eP13getVqNvLw8lJaWIj8/HyUlJSgoKADw6ACKhw8f6vURQqBp06ZITExEcXExdu3apbsml8thZ2dncC4HBwfdqjpHR0fIZDI4ODjAzMwM169fR1lZGYKDg7Fv3z5YW1vX+NmIiIiIiIiIiJ5VMvHk2/dJEjdu3MDnn3+OzZs3605o3b59O7y9vZGdnQ2VSgWVSlXunx//5ObmIicnB2q1GiqVShfG1SfakM7c3Bz29vawtLSEvb097O3t4eDgAKVSqfv58Y+joyOcnZ3RsGFDuLi4wMrKSupHISIAO7ETIzESAvw1QkREREREVF1cKWdC6enpSElJwb1793D//n2kpqYiIyMDGRkZSE9Px4MHD+Ds7IyMjAxoNBqMGjVK11cbZDk6OuqFVu7u7lAqlXBwcICFhQXs7Ox0K9oq+hMAzMzMoFQqDdZqY2ODpUuXYtGiReXaCwsLUVRUpHe/RqOBSqUCAJSVlSE3N1f3Z2FhIb744guEhYUhPz9f115cXKwLFXNycnD37l2DgeOTFAoFGjZsCFdXV7i4uOg+bm5ucHd3R+PGjeHh4QFvb2/Y2NgY+6+LiIiIiIiIiKjOcKVcLSkoKMCtW7eQkJCAxMRE3L17t1wAl5ycjOLiYt399vb2aNSokS5QejxkatiwIaytrXHy5EmEhISgffv2sLW1NfkzlZaWlnvfnbHUajXMzc2NPjAiOztbF14+HmKmp6eXa0tNTUVaWlq571mpVKJx48bw9PREo0aN4OXlhcaNG6NZs2Zo3rw5vLy8IJczmyYyBlfKERERERERGY+hXDVkZWXh+vXriI+Px61bt3Qh3K1bt5CWlgbg0RZN7SotDw8PNG7cGI0aNYKnp6duBZeXl5ckIdvfRVpami4QTU5ORnJyMpKSkpCSkoKkpCQkJSUhNzcXwKNDNry9vXUhXbNmzdCsWTO0aNECrVq1gqWlpcRPQ1R/MZQjIiIiIiIyHkM5A7Kzs3Hr1i3Exsbijz/+0P1569YtAECDBg10q62e/LRs2RIKhULiJ6Cn0f47NvS5c+cONBoNzM3N0aRJEzRr1gz+/v5o06YN/P39JVu5SFTfMJQjIiIiIiIy3t8+lEtMTMSlS5dw+fJlXLp0CVeuXEFGRgaAR6eJtm7dGm3atCn3p5eXl9FbMan+Ky4uRlxcHP74449yn5s3b6K0tBRmZmZo1qwZXnjhBXTo0AGBgYEIDAys8P18RH9VDOWIiIiIiIiM97cK5dLT03HmzBlcunRJF8RlZmbC3NwcrVq1QmBgIF544QVd+Obp6Sl1yVSPlJaWIj4+HrGxsbh27RouX76My5cvIyUlBTKZDC1atNAFdB07dkTHjh15Uiz9pTGUIyIiIiIiMt5fOpRLSUnB6dOncfr0aZw5cwa//PILhBDw8PDQhSeBgYHo1q0bHB0dpS6XnlHJycm6gE674jI1NRVyuRzt2rVDcHAwXnrpJXTv3h0ODg5Sl0tUaxjKERERERERGe8vFcplZ2fj8OHDOHToEE6ePInExEQ0aNAAHTp0QI8ePdC9e3d069YN9vb2UpdKf3G3b9/GqVOncOrUKfz000+Ii4uDXC7HCy+8gKCgILzyyit46aWXYG5uLnWpREZjKEdERERERGS8Zz6Uu379OmJiYnDgwAGcOXMGAPDSSy8hKCgIPXr0QKdOnWBjYyNxlfR3l5KSogvojhw5gri4ODg5OaFfv34YPHgw+vXrBycnJ6nLJKoWhnJERERERETGeyZDudjYWGzevBm7d+9GQkICXFxcMGDAAAwcOBD9+vXjFkGq927evKkLk3/66SeUlZWhW7duCA0NxYgRI7idmp4JDOWIiIiIiIiM98yEcqmpqdi2bRs2b96MX3/9FU2aNEFoaCgGDx6MTp06cRsgPbNyc3Nx5MgR7Nu3D/v27YNGo8HAgQPxj3/8A6+88goaNGggdYlEBjGUIyIiIiIiMl69D+V+/PFHLF++HN9//z0UCgWGDx+OMWPGoHv37pDJZFKXR1Sr8vLysGfPHmzevBk//vgjHBwcMG7cOEyfPh1eXl5Sl0dUDkM5IiIiIiIi45lJXYAhGo0Gu3btQseOHdG7d2/k5eVh69atSE1NRWRkJHr06MFAjv6S7Ozs8NZbb+HYsWO4c+cOZs+ejR07dqB58+Z466238Pvvv0tdIhERERERERHVgnoVygkhsHXrVrRs2RKjRo1CkyZNcP78eZw4cQIjRoyAlZWV1CUSmUzjxo0RHh6OhIQEbNiwAb/88gvatWuHgQMHIjY2VuryiIiIiIiIiKgG6k0oFxsbi6CgIPzjH/9Ar1698Oeff+pWy5mKRqPBihUr8Pzzz8PGxgZKpRK9e/fGsWPHqtR33rx58PX1hZWVFQYMGKC7lp+fD5lMVu5z9uzZp445e/bscn0++eQTvXsuXryIsWPHwsfHB9bW1nByckJAQACGDRuGtWvXIiEhAQAQEBCgV8OoUaN04wQHB5e71qFDB7257ty5gyFDhkClUpVrv3LlCgYOHAgHBwfY2dkhODhYdxJudR08eBB+fn6Qy+XV7pudnY2IiAj07t0bTk5OsLa2hq+vL958801cvXpV7/7w8HDs2LGjwvHGjRsHS0tL+Pj4YPr06SgqKqp2TbWhQYMGeOutt/Dbb78hJiYG6enpaN++PWbPno28vDxJaiIiIiIiIiKiGhISKywsFDNnzhQWFhbixRdfFBcvXpSkDrVaLQYNGiQsLCzEqlWrREZGhrh165YYN26ckMlkYtu2bZX2X7dunQAgPv74Y5GdnW3wnl9//VUAEADEgAEDKh0vIyNDKBQKAUC8+eabetc1Go2YNWuWkMvlYvbs2eL69euiqKhIpKamiiNHjojg4GDdXKWlpUIIIVJTU4Wzs7MAIL799lu9MQ8cOCB8fX1FQUGBwdpdXFzEqlWryrWfO3dOWFtbi5EjR4rk5GTx4MEDMXHiRCGXy8Xhw4crfcbHxcfHi8GDB4u2bdsKe3t7YW5uXuW+WuPHjxdyuVysWLFCpKSkiIKCAnHq1Cnh7+8vzM3Nxd69e/Xm9PHxEQsWLKhwTJVKJSIiIgQAsWTJkmrXVBc0Go2IiIgQTk5OwtPTU+zZs0fqkuhvaofYISAk/zVCRERERET0TJL0/6Zu374tXnjhBaFUKsW6deuERqORrJbo6GgBQLzzzjvl2svKykSrVq2Eo6NjhWGbEEKEhoYKAEKlUlV4z6+//iqsra1FkyZNBIBKA8gPPvhAtG7dusJQbv78+QKAWL9+vcH+arVaDBgwoFwoJ4QQW7ZsEQCEs7OzSE1N1bVnZWUJLy8vcebMGb2xcnNzRePGjUVYWFi5do1GI9q0aSM8PDzEw4cPy83dsmVL4eXlJYqKiip8xseFhoaKpUuXitLSUuHp6Wl0KDdp0iS99itXrggAwtfX1+A1mUwmduzYUenYNjY2om/fvtWuqS49ePBAvP3220Imk4n33ntPqNVqqUuivxmGckRERERERMaTbPvqn3/+iW7dukGtVuPSpUuYNGkSzMyk2027d+9eAMDgwYPLtctkMrz66qvIzs7G7t27K+yfmZkJc3Nz2NnZVTqPmZkZwsPDAcDgdlQAyMnJwdq1azF37lyD12/cuIFPP/0UgYGBmDhxosF7zM3N8eGHH+q1v/HGGxgyZAgyMzMxdepUXfs777yD0NBQdO3aVa/P559/jtTUVHz00Ufl2k+dOoXY2FgMHz4c1tbW5eYODQ1FUlISYmJiDNb3pKioKISHhxu1bVUrMjIS69at02tv164drK2tkZCQAPHEYcPt2rXD8OHDMXPmTKjV6grHdnBwQGZmptG11QUXFxdERUVhy5YtWLduHUaOHImSkhKpyyIiIiIiIiKiKpAkBUtLS0OfPn3g7e2NU6dOoUWLFlKUoVcTALi6uupd8/DwAACcPn26wv4ajabKc40bNw6enp7473//i99++03v+sqVK/HKK6+gefPmBvuvX78eZWVlCAkJqXSeLl26QAihF3RFRETA0dER//nPf7B7927s27cPV65cwccff6w3hhACkZGR6NSpExo1alTu2g8//AAABt8/p207fvx4pTVqPR7q1baCggIUFhbq3qv3pNdffx337t3DgQMHKhxDJpNVGtpJKTQ0FIcOHcLRo0crDGmJiIiIiIiIqH6RJJT7xz/+AUtLS8TExECpVEpRgh4XFxcA/wvnHvfgwQMAQGJiYq3MZWlpidmzZ0MIgSVLlpS7lp+fj1WrVmH+/PkV9j916hQAoG3btkbN7+Hhga+++goAMHXqVEybNg2bNm2CpaWl3r1Xr15FWloa2rVrp3ftxo0bAB6dEvokT09PAMDNmzeNqrE27dq1CwDwwQcfGLz+/PPPAwAOHz5ssppqW/fu3bFjxw5s2bIFX3/9tdTlEBEREREREdFTmDyUO3jwII4dO4ZvvvkGTk5Opp6+Qv369QMAg9stDx06BODRiquKlJSUGAy1KjJp0iS4ublh9+7duH79uq59zZo16N27N1q3bl1h3+TkZACAs7Nzled70ltvvYVXXnkF6enpaNGiBQIDAw3ed+3aNQCGg7ecnBwAgK2trd41hUIB4NGJqFJKS0tDeHg4JkyYgBEjRhi8Rxsgap/VEEtLS5SWltZJjbWlf//+mDp1KubNm4fCwkKpyyEiIiwoZ50AACAASURBVCIiIiKiSpg8lNu4cSOCg4PRpUsXU09dqQkTJiAwMBARERFYs2YNMjMzcffuXUybNg33798HUPkWy7t37xoMripibW2N999/H2VlZfjXv/4FAHj48CG++uqrCld0PcnQVszq8PX1BQCcPHkS+/fvN3hPSkoKAFR7RaP23W01rbEmMjMz0b9/f/Tq1QsREREV3mdvbw+ZTKZ7VkMaNWqE+/fv19strFrz589HZmZmld/lR0RERERERETSMHkod/78efTv39/U0z6VlZUVfvzxR0yfPh1ffPEFPDw80KlTJwghdNsf3d3d9fplZWVh2bJluHPnDqZMmVKtOadMmQJnZ2ds27YN8fHxWLduHTp37vzUbanad7tlZGRUa77H/fTTT9izZw+WL18OAJg8ebLBVW1FRUUAAAsLC71rDg4OAAyvINS2ae8xtYKCAvTr1w/+/v7YsmULzM3NK71fLpdXurosLCwMKpUKH330UY2+97rm5uaGF154AefPn5e6FCIiIiIiIiKqhMlDuZycHMmCmqexs7PDsmXLcPv2bZSUlCAlJQVr1qzRBUwvvPBCufvHjh0LZ2dnhIeHY86cOXj33XerNZ9CocCMGTOg0WiwcOFCfPHFF1iwYMFT+/Xs2RMADB4SURX5+fkYO3Ys1q9fj/feew8DBgxAamoqpk+frnevlZUVABjcutmqVSsAwL179/SuaVcX+vn5GVVjTajVaoSEhMDT0xObNm16aiCn7VPZSsjRo0djyZIlWLZsGRo2bFgvg2UtR0dHybcNExEREREREVHlTB7KNW7cGAkJCaaetka0p64OHTq0XHt0dDRyc3Oxfft2LF++HGFhYdUe+5133oFSqcTWrVvRrl07gyeZPiksLAxyuRy7d++u9L45c+bAzMxMdyCD1syZMxEcHKwLltatWwd7e3ts3rxZb9uj9uTZ3NxcvfGDgoIAAJcvX9a7pm17+eWXn/o8tS0sLAzFxcXYuXNnuZNnW7RogXPnzundr1KpIITQPashH3zwAebPn4+1a9ciJydH957B+ig+Ph7e3t5Sl0FERERERERElTB5KDdgwADs3Lmz3r2bKyMjA2ZmZrpDFLRUKhUiIyMxatQog6u+7O3tERISgvbt2z81JDNEqVTi/fffh1KprNIqOeDR6rOFCxfi0qVL2Lhxo8F7/vzzT6xbtw4jRozQrWgDHp0wevToUXzxxRe6Ni8vL93PYWFhugMcACAgIACA4dVwPXv2hL+/P3bv3q3b5goAGo0G27dvh5eXFwYOHFilZ6otixYtQmxsLPbv31/lgze0q/q0z2rInj174OPjgwkTJtSbE4MNOXfuHBISEjBgwACpSyEiIiIiIiKiSpg8lJs6dSqSkpKwevVqU0/9VEIIjBs3DvHx8SguLsaFCxfQv39/uLm5Yc2aNZX2tbe3h0qlMmrejz76CDk5OejatWuV+yxYsADh4eGYPHkywsPDcfPmTZSUlOD+/fuIiopCUFAQ2rZti6ioKF2fnJwcTJw4ERs3boSdnV258SZOnIjg4GAkJyfjvffe07W3a9cOrq6uuHr1ql4NZmZmiIqKQlZWFsaNG4fU1FRkZmZi6tSpiIuLw4YNG3TbX7VGjx4NmUyG27dvV/lZDTE0TnR0NBYvXozz58/Dzs4OMpms3KeiFZpXrlwBAPTt27fC+fLy8mBvb1+jmuuaWq3G+++/j27duuHFF1+UuhwiIiIiIiIiqoTJQ7nmzZvjgw8+wNy5c/HTTz+ZevoKubi44OjRo7CyskL37t3h6OiI8ePH45VXXsHZs2fh5ORUaf+nnTKqUCjQvn17FBQUQCaTPfWdZDKZDN27dwcAbNmyBTKZTC/IXLp0Kc6cOYPk5GQEBwdDoVCgdevWiIyMRHh4OI4fPw5bW1sAj7YNOzo6IikpCUFBQXjttdd04+Tk5EAmk+HYsWMAHoVbMpkMK1asgEwmw4QJE3D+/Hm9VYQA0LlzZ/z888/Izc1Fy5Yt0bRpU8TFxeHEiRPo16+f3v0pKSlQKBR62ytjYmJ04dn/Y+++o6I49/+Bv3dZOssiRZCigAUFlBgTG/ao2FOuWK4pFhKNXss10VhSjNHEJH41ideoEY3GiKL+LIk9mkSuaIwS0UhTQVSKCAhLX2B3fn94dq8IKCy7O6Dv1zlzgJnZ5/OZgRxP3ud5ZtLT06FWq3U/h4eH12kcfWYqAsC+ffvg4eHx2Fl9Yr5Jti7mzZuH2NhYrF27ttH3SkRERERERPS0kwiCIJi6qEajwZgxY3D8+HH8/PPPuhcXNGUjRozA4cOHodFoxG7F4JRKJQICAjBixAisX79e73Hy8/Ph7u6OCRMmYOPGjaKPAwCXLl1C586dERERgXHjxtV6npubG3x8fHD27NkG1TMGQRAwf/58rF69Gj/++OMjr4PIkHZhF8ZiLASY/J8RIiIiIiKiJs/kM+WA+8sed+zYgWHDhmHw4MFYs2aNGG0YlKenJwRBQFZWltitGJxCocDPP/+MPXv2PHYZb20EQcCsWbNgb2+PTz75RO9eDDUOAKSkpOCVV17BwoULHxlkVVRU4N69e/D09GxQPWPIz8/HSy+9hG+++Qbbtm1jIEdERERERETURIgSygGAubk5duzYgS+++AJz585Fv379cOXKFbHaaTDtctQVK1YgNzdX5G4Mr3Pnzrhw4QKOHDmi17PzsrKykJKSgpMnT8LNzU3vPgw1DnD/rbPLly/H8uXLaz1HqVRi1apVqKioeOySY1P7+eef0alTJ8TExOC3337D+PHjxW6JiIiIiIiIiOpIlOWrD7t48SKmT5+OmJgYvP3221i2bFm1FxE0BV988QW2bNmClJQU9O/fH0eOHBG7JWqAiRMnIiIiAq1atcL48ePx0UcfwczMTOy2cPXqVcycORO//PILXn31VaxatQrOzs5it0VPIS5fJSIiIiIi0l+jCOWA+8+Z++6777B48WJYWFhg9uzZmDZtGhwcHMRujahR+Pvvv7Fy5Urs2LEDQUFB+Pbbb/mWVRIVQzkiIiIiIiL9ibZ89WFSqRTTpk1DYmIi3njjDXz++edo2bIl5s6di1u3bondHpFofv31VwwdOhRBQUH466+/EB4ejnPnzjGQIyIiIiIiImrCGk0op+Xi4oIVK1bg1q1bWLJkCfbs2YM2bdrg5Zdfxr59+6BSqcRukcjoMjMzsWrVKgQFBeGFF16ASqXCwYMHcfnyZbz++uuQShvdf7pEREREREREVA+N9v/s5XI55s6di+TkZGzZsgVFRUUYPXo03N3d8fbbb+PMmTNoJCtviQyipKQE27dvx9ChQ+Hl5YVPPvkE3bp1w/nz5/Hrr79i2LBhkEgkYrdJRERERERERAbQaJ4pVxfp6emIiIjADz/8gCtXrsDHxwcjRozA8OHD0a9fP1haWordIlG9ZGVl4dChQzh8+DCOHTsGlUqFIUOG4LXXXsPIkSNhZWUldotEteIz5YiIiIiIiPTXpEK5B8XGxmL37t04dOgQLl26BFtbWwwaNAjDhw/HsGHD4O7uLnaLRNUIgoC//voLhw4dwsGDBxETEwMLCwv0798fI0eORGhoKN+kSk0GQzkiIiIiIiL9NdlQ7kF3797F0aNHcfDgQRw9ehSFhYXw9fVFcHAwevXqhUGDBsHHx0fsNukppFarkZiYiOjoaJw4cQK//fYbcnJy0Lx5c4SEhGDkyJEYMmQI5HK52K0S1RtDOSIiIiIiIv09EaHcg0pLS3Hq1ClERUUhKioK58+fR3l5Oby9vdGnTx/06dMHzz//PPz9/SGTycRul54wBQUFuHjxIs6ePYuoqChER0ejoKAATk5O6N27N/r27Yt+/frhmWeeEbtVogZjKEdERERERKS/Jy6Ue1hJSQnOnTunC+rOnTuHkpISWFtbIygoCM899xy6dOmCLl26oEOHDgzqqM60AVxMTIxuu3btGjQaDVq0aIE+ffrogriAgAC+pIGeOAzliIiIiIiI9PfEh3IPq6ysRHx8PGJiYnDhwgXExMTg0qVLKCsrg42NDTp27IjAwEC0b98egYGB6NChA1q1aiV22ySi8vJyJCYmIiEhAXFxcYiPj8eVK1d0AVzz5s11wa528/LyErttIqNjKEdERERERKS/py6Uq0llZSXi4uIQExOD2NhYxMfHIz4+HpmZmQAAuVyO9u3bIyAgAP7+/mjTpg18fX3h6+vLZ4E9QTIzM5GSkoKUlBQkJiYiMTERV65cQUpKCiorKyGTydC6dWsEBgbC398fzz77LAM4eqoxlCMiIiIiItIfQ7lHyMvLQ3x8POLi4nSzpBITE5GWlgbtbXNxcYGvry9at26tC+p8fX3h6ekJDw8PWFlZiXwVpJWXl4f09HTcvHlTF76lpKQgOTkZKSkpKC0tBQBYWlqidevW8Pf3h7+/PwICAtChQwf4+fnBwsJC5KsgajwYyhEREREREemPoZweysrKcOPGjSrBzoNbSUmJ7lxnZ2e4u7vDy8sL7u7u8PDwgKenJ9zd3eHu7g5nZ2c4OzvD0tJSxCtq2goLC5GdnY27d+8iMzMTaWlpSE9PR0ZGBm7fvo2MjAykpaVV+b00b968Soj64Obh4QGpVCriFRE1DQzliIiIiIiI9MdQzgju3LmD9PR0pKenVwmFtEHRrVu3UFxcXOUzcrkczZs3h4uLiy6oc3Z2hqurKxwcHKBQKODg4AB7e3vdplAoYGdnJ9JVGpYgCMjPz0d+fj4KCgqqbPn5+cjJydFt2gBO+7NKpaoylqura7UAtGXLlrp9LVu2fGLuG5GYGMoRERERERHpj6GcSAoKCpCZmVklbMrKyqry882bN3Hjxg1YWFhAqVTWOI5UKq0S2MlkMjg4OEAikTz2KwCYm5vXGFBZWlrCxsam2v78/HzU9CeTl5en+16lUqGkpKTGr9rzSkpKUFJSogveCgsLa7w+mUwGhUJRJajUhpU17XN1deWsQyITYShHRERERESkP5nYDTyttLPd/Pz8ajx+8uRJvPTSSxg0aBAiIyNhZWVV4ywy7UwypVIJpVKJyspKKJVKaDQa3dfU1FQIgqALxB4M0LRh2cOKi4tRXl5ebb+dnR3Mzc2r7ZfL5ZDJ7v85aYM+CwsL2Nra6gK+1NRU3Lx5E6+++irs7OxgY2Ojm/Gn/frwbMCagkEiIiIiIiIioqaOoVwjtH//fowbNw6hoaH4/vvvdWGXg4MDHBwcTNpLUFAQRo0ahU8++aTBY2VkZMDf3x8ODg5YtmyZAbojIiIiIiIiImqa+DT7RuaHH35AaGgowsLCsHXrVl0gJxZDrm52d3fHsmXL8Pnnn+PixYsGG5eIiIiIiIiIqKlhKNeIfPnll5g4cSI++OAD/Oc//2kUbwAVBEH3/DlDmD59Orp3746pU6dCrVYbbFwiIiIiIiIioqZE/NSHAABr1qzBe++9h6+//hoffvih2O1UYchQTiqVIjw8HJcvX8aaNWsMNi4RERERERERUVPCUK4R2LFjB+bMmYPPP/8cM2fOFLudKozxcl4/Pz8sWLAA77//PtLS0gw+PhERERERERFRY8dQTmQnTpzApEmT8K9//Qvz5s0Tu51qDL18VWvhwoVwdXXF4sWLDT42EREREREREVFjx1BOROfOncPLL7+MMWPG4KuvvhK7HZOytLTEihUr8OOPP+LChQtit0NEREREREREZFIM5UQSFxeHYcOGoX///ti8ebNRZqMZgrFmygFAaGgoevbsiXfffdco4xMRERERERERNVYM5USQnZ2N4cOHIzAwELt27YJMJhO7pVoZM5QDgJUrVyIqKgr79+83Wg0iIiIiIiIiosaGoZyJVVZWYuzYsQCA//f//h+srKxE7khc3bp1w9ixY/Huu++ivLxc7HaIiIiIiIiIiEyCoZyJzZs3D3/++ScOHDgAZ2dnsdt5LGPPlAOAzz77DOnp6di4caNR6xARERERERERNRYM5Uzo4MGD+Prrr7Fx40YEBQWJ3U6dmCKU8/b2RlhYGD7//HNUVFQYtRYRERERERERUWPAUM5E7t69i7CwMLz++usYP3682O00Ou+88w4yMzMRGRkpditEREREREREREbHUM5EJk+eDDs7O6xZs0bsVurFFDPlgPuz5caMGYNPP/0UGo3G6PWIiIiIiIiIiMTEUM4Edu7cicOHD+P777+HXC4Xu516MVUoBwDvvfceEhMTceTIEZPUIyIiIiIiIiISC0M5I1MqlXjnnXfw5ptvonfv3mK306h16tQJQ4YMweeffy52K0RERERERERERsVQzsjef/99qNVqrFixQuxW9GLKmXLA/dly//3vf3H27FmT1SQiIiIiIiIiMjWGckaUmpqK7777DkuXLkWzZs3Ebkcvpg7l+vbti2effRbr1683WU0iIiIiIiIiIlNjKGdEixcvhre3NyZNmiR2K03KlClTsHv3buTn54vdChERERERERGRUTCUM5Jr165h586dWLp0KczNzcVuR2+mnikHAP/85z8B3H9BBhERERERERHRk4ihnJF89dVXaNWqFUaPHi12K02Og4MDXn75ZWzfvl3sVoiIiIiIiIiIjIKhnBHk5eVh69atmDNnDszMzMRup0GkUik0Go3J644ZMwZnzpxBRkaGyWsTERERERERERkbQzkj2LFjByQSyRPxLDmZTIbKykqT1x0yZAjs7Oywd+9ek9cmIiIiIiIiIjI2hnJGEBkZiVGjRkEul4vdSoPJZDKo1WqT17W0tMTQoUNx6NAhk9cmIiIiIiIiIjI2hnIGdufOHURHRyM0NLTBYx0+fBjt2rWDTCYzQGf60XemXF5eHtavX48BAwbA0dER1tbWaNu2LSZMmIBLly7VaYy+ffvizJkzBgkFY2NjMXz4cDg4OEAul2PgwIGIjo5u8LhERERERERERPpgKGdgR48ehbm5OYYMGaL3GMnJyRg1ahQWLlyIrKwsA3ZXf/qGcvPmzcPMmTPx4osvIj4+Hrm5udi8eTNiY2PRpUsX7N+//7Fj9OrVCwUFBfj777/1aV3n3Llz6NmzJ+RyORISEnDjxg34+vqiX79+OH78eIPGJiIiIiIiIiLSB0M5Azt9+jS6desGKysrvcf44IMP0LNnT8TExIi+BLYhz5SbPHkyZs+eDTc3N9jY2KB3796IiIiAWq3G/PnzH/v5wMBAODo64vTp03rVBwCNRoMpU6bAwcEB33//PVq0aAFnZ2esW7cOrVu3RlhYGFQqld7jExERERERERHpg6GcgUVHRyM4OLhBY2zatAkLFiwQddmqlpmZmV6hXHh4ODZs2FBtf1BQEKytrZGcnAxBEB45hkQiwfPPP48LFy7Uu75WVFQU4uLiMHr0aFhbW+v2m5mZYfz48bh9+zYOHjyo9/hERERERERERPpgKGdAKpUKV69exbPPPtugcR4Mj8Rm6Bc9FBcXo7S0FIGBgZBIJI8938fHB7dv39a73q+//goAeO6556od0+47efKk3uMTEREREREREemDoZwB3b59GxqNBt7e3lX2JyYm4qWXXoJCoYCNjQ26du2KgwcPYuDAgZBIJJBIJAgLCxOn6cd4cPmqIa5j9+7dAIDFixfXqb6Xlxdu3rxZZV99+khMTAQAeHp6Vhvbw8MDAHD16tU69UJEREREREREZCjir498gty6dQsA0KpVK92+69evo0ePHrC1tcWePXvQo0cP3Lx5E3PmzMHly5dhaWmJsrIysVp+LG0oZ4jryMrKwoIFCxAWFoYxY8bUqX7Lli11YadUKq13H/n5+QAAW1vbamPb2dkBuP+mWCIiIiIiIiIiU+JMOQO6d+8eAMDJyUm3b9GiRcjPz8fXX3+NQYMGwc7ODgEBAYiIiEBxcbFYrdaZNpRr6HXk5uZiyJAh6NevH9avX1/n+u7u7igvL9cFZ4a8n9pn2tVlGS0RERERERERkSExlDMgQRB0yye1jh49CgAICQmpcq6Liwvat29v0v70YWFhgfLy8gZdR3FxMUJCQuDv74/t27fDzMyszvXNzc0BQLeEtr59ODg46Hqoqa8HzyEiIiIiIiIiMhWGcgakDeW0VCoVCgsLYWVlpVsq+aBmzZqZsj29WFpaoqSkRO/rqKysRGhoKDw8PLB169Z6BXIAdOer1Wq97qc2qEtLS6t2LD09HQDQrl27evVERERERERERNRQDOUMyMbGBhqNBiUlJQDuB1pyuRxlZWUoKiqqdv7du3dN3WK9WVtbo7y8XO/rmDp1KlQqFXbt2gWZ7H+PMGzTpg3++OOPx9aXSu//iarVar3uZ//+/QEAMTEx1Y5p973wwguP7YOIiIiIiIiIyJAYyhlQy5YtAaDK20KHDh0K4H/LLrXu3LnTJN76aWVlhdLSUr2uY8mSJYiLi8OBAwdgaWmpV33tc9+06ttH37594e/vjz179lR5AYRarcbOnTvh5eWF4cOH69UbEREREREREZG+GMoZkLe3N4Cqodynn34KR0dHzJkzB7/88guKiopw5coVTJo0CW5ubiJ1WndWVlYoKyur93Vs2bIFH3/8Mc6dOwe5XK571p52S05OrlP93NxcAP97eUZ9+5BKpdi0aRPu3buHSZMm4c6dO8jNzcWMGTNw7do1bNy4EVZWVg24Q0RERERERERE9cdQzoDs7e3h5uaGy5cv6/a1bt0aZ8+exfPPP4/Ro0fD1dUVU6dOxcKFC9GmTZsaxzl48KAuvEpPT4dardb9HB4ebqrLAXB/+WpZWVm9r2PPnj0GqZ+dnQ1bW1vY2NgA0O9+du/eHWfOnIFSqYSfnx+8vb1x7do1/P7779VeGEFEREREREREZAqyx59C9dGnTx+cOnUK8+fP1+1r164d9u3bV+cxRowYUW3ZplgsLS1RWloKoH7XcfDgQYPUz87OhouLS5V99b2fANC5c2ccPnzYID0RERERERERETUUZ8oZWL9+/fDf//4XFRUVYrdiENqZcmK5c+cOmjdvLlp9IiIiIiIiIiJjYChnYIMGDUJRURF+/fVXsVsxCO0z5cQSHx+PDh06iFafiIiIiIiIiMgYGMoZWJs2bRAcHIzNmzfXes7OnTshkUhw8uRJqFQqSCQShIWFmbDLutO+fbUmpriOK1euICAg4JHnNKX7SUREREREREQEABKhsTy87AmyZcsWTJ06FWlpadWeh9bUbNu2DW+++aYos+Xy8vLg6OiIw4cPY+jQoSavT0SPtgu7MBZjIYD/jBAREREREdUXZ8oZwZgxY2Bra4u1a9eK3UqD2djYQKVSobKy0uS1tW+xDQwMNHltIiIiIiIiIiJjYihnBDY2NnjnnXewevVq3Lt3T+x2GkQulwMACgsLTV771KlT8PLygpeXl8lrExEREREREREZE0M5I5k9ezasrKywcuVKsVtpEIVCAQAoKCgwee1Tp06hf//+Jq9LRERERERERGRsDOWMxM7ODvPmzcM333yDu3fvit2O3uzt7QGYPpQrLy/HH3/8gb59+5q0LhERERERERGRKTCUM6Lp06dDoVDggw8+ELsVvWlnyimVSpPWPXPmDEpKStCvXz+T1iUiIiIiIiIiMgWGckZkY2OD//u//0N4eDiio6PFbkcvYs2U27t3LwIDA+Hr62vSukREREREREREpsBQzsjGjRuHoUOHYtq0aaioqBC7nXqztbWFTCYzaSgnCAL279+PV155xWQ1iYiIiIiIiIhMiaGcCXz99ddITk7GqlWrxG6l3iQSCeRyuUmXr/7555+4ffs2QzkiIiIiIiIiemIxlDOB1q1b44MPPsCSJUtw+fJlsdupN4VCYdKZcrt370br1q0RFBRksppERERERERERKbEUM5E3nvvPfTo0QPjx49HSUmJ2O3Ui729fZVQThAEZGdnN3j2XFZWFhITE6vsq6ysxPbt2/H66683aGwiIiIiIiIiosaMoZyJSKVS/PDDD8jKysLcuXPFbqdWf/31F3744QesWrUKixcvRlhYGHJycrB161b4+vqiWbNmMDMzQ/PmzXH69OkG1frzzz8REBCAV199FdevXwcA/Pzzz7h79y7eeOMNQ1wOEREREREREVGjJBO7gaeJp6cnNmzYgNGjR2PAgAEYM2ZMleMZGRk4cuQIpkyZIlKHQFxcHN544w2Ym5tDKpVCrVajsrKy2nlmZmbo06dPg2olJydDIpFg165d2LFjB15//XXcunULgwYNQqtWrRo0NhERERERERFRY8aZcib2j3/8AzNmzMDkyZMRGxur23/nzh306dMH//73v5Gfny9af+PGjYOrqysqKiqgUqlqDOQAoEuXLpDL5Q2qlZycDDMzM1RUVECj0WD79u34/fffAQApKSkNGpuIiIiIiIiIqDFjKCeCr776Ct26dcOLL76IrKws3L17F3369MGtW7dQWlqKb775RrTezM3NMXPmTMhktU+itLCwwNChQxtc69q1aygvL9f9rA3nfvvtN/j5+eGtt95Cenp6g+sQERERERERETU2EkEQBLGbeBrdu3cP3bp1Q7NmzVBQUIDk5GTdrDQ7OzukpaVBoVCI1puHhwfKyspqPScqKgq9e/duUB1fX1/cuHGj1uPaJbSrVq3C9OnTG1SLiAxvF3ZhLMZCAP8ZISIiIiIiqi/OlBOJo6MjfvzxRyQkJFQJ5ACgrKwM3377rai9vfbaazA3N6/xuJWVFbp27dqgGhqNBmlpaY89r23btggNDW1QLSIiIiIiIiKixoahnEjy8/Mxbdq0Gp/bVllZic8//xyFhYUidQe88847NT5PTiqVok+fPrC0tGzQ+GlpaaioqKj1uLm5OQICAvD777/DxcWlQbWIiIiIiIiIiBobhnIiUCqVGDBgAOLi4moNpoqLi7F+/XoTd/Y/fn5+eOGFF6o9W87MzAyDBw9u8PjJycm1HpPJHtoamgAAIABJREFUZHj++ecRFRUFJyenBtciIiIiIiIiImpsGMqZmDaQu3Tp0iNnilVWVuKzzz5DSUmJCburat68edVmy1VUVGDgwIENHlv75tWHmZmZoX///jhx4kSD3+5KRERERERERNRYMZQzsZycHLRt2xYAan1mm1ZBQQE2bNhgirZqNHjwYLRv3x5S6f/+TBQKBTp27NjgsVNSUmqchRcSEoKffvoJ1tbWDa5BRERERERERNRYMZQzsdatW2Pnzp24fv06pk2bBgsLi1rDObVajeXLl6O0tNTEXf7PO++8o/teJpNh8ODBVUI6fV2/fr3KTEGpVIrRo0fjwIEDsLKyavD4RERERERERESNGUM5kfj4+OCbb77B7du3sWjRItjZ2VWbOQbcfyFEeHi4CB3e99prr8HBwQEAIAgCBg0aZJBxExMTodFoANwP5CZPnoyIiIga7wERERERERER0ZOGoZzImjdvjiVLliAjIwMrV66Es7MzzMzMIJFIANyfLbd06VKUlZWJ0p+lpSVmzJgBiUQCtVqNF154wSDjpqamAgAkEglmzZqF7777ziAz8IiIiIiIiIiImgKJIAiC2E3Q/5SUlGDz5s1YsWIFMjMzAQAajQbffvst3n777QaNXV5ejuLiYlRWVqKwsBAajQZKpVJ3PC8vr8bPZWdn4/XXX4e9vX21N8JKJBLdTLqHWVhYwNbWFsD9pa9yuRxSqRQajQatW7cGALz33ntYsWJFg66LiMSxC7swFmMhgP+MEBERERER1RdDuUaqoqICO3fuxMcff4zk5GS4uLhg06ZNKC0tRX5+PgoKClBYWIjCwkIUFRVV21dcXIzS0lKUlZVBpVKJ+hbXx1EoFJBKpbC3t4eZmRmaNWsGuVwOuVwOOzs7yOXyKvu0m4ODAxwdHeHs7AwnJyddAEhEpsFQjoiIiIiISH8M5UwsPz8fGRkZyMzMREZGBu7evYu7d+8iJycHubm5uk37s/a5a1ramWkPhlN2dnY1BlmWlpawsbGBubm57pl12tlqCoUCANCsWTPd2HZ2drW+dCItLQ0JCQkYM2ZMlf0VFRUoKiqq8TPFxcUoLy8HUHWW3sGDB5GTk4MBAwZAEATk5+fr7o1arYZSqaw1dCwqKtLte5iVlRWcnJx0IZ2Li4vuZ2dnZ7i7u8PNzQ0eHh5wc3PjCyWIGoihHBERERERkf4YyhnQnTt3kJqaihs3buDWrVu68E0bwGVmZlZ5k6qlpSWaN28OFxeXKgGSk5OTbnNxcdHtu3fvHjp16iTa9ZWXl8PCwqLB4xQWFkIulzdoDG2YV1OQqf0+Oztb93N2djbu3r2LB//cHR0d0aJFC7i7u6NFixa67318fODj4wNvb2/Y2dk19HKJnlgM5YiIiIiIiPTHUK4eiouLkZSUhJSUFNy4cQOpqam6EC41NVUXuMlkMnh4eOhmZNX01dXVFS4uLiJf0dOloqICWVlZSE9PR1ZWFtLS0qp9zcjIQHZ2tu4zzs7OuoDO29tb933btm3h4+MDMzMzEa+ISFwM5YiIiIiIiPTHUK4GeXl5iIuLQ3x8PFJSUnTfp6am6paTNmvWDL6+vjVuLVu2hEwmE/kqSF8qlQrp6elISUmptmlnPAKAubk5vLy84O/vj4CAAPj6+sLf3x+dOnWCvb29yFdBZHwM5YiIiIiIiPT3VIdyJSUl+PvvvxEbG4uLFy/i4sWLSEhIQGFhIYD7yxv9/PzQoUMH+Pn56b739vY2yDJOapqUSiWuXr2KpKQkJCQk4OrVq0hMTMS1a9egUqkAAO7u7ujYsSM6d+6Mzp0745lnnkGbNm0glUpF7p7IcBjKERERERER6e+pCeWKiorw559/IiYmBrGxsYiNjUVSUhLUajXs7e0RFBSEzp07IzAwEO3bt0f79u25vJTqRa1WIzU1FYmJiUhISMDly5dx8eJFJCYmorKyEnZ2dujUqZMupOvatSsCAgK4BJaaLIZyRERERERE+ntiQ7mMjAzExMQgOjoap0+fxvnz51FeXo5mzZrB398fXbp00W0dOnTgDCYymoqKCly9ehUxMTG67dKlSygqKoKdnR2CgoLQq1cvBAcHo1evXlXeiEvUmDGUIyIiIiIi0t8TE8qlpqbi2LFjOHnyJM6cOYP09HSYm5ujc+fO6NGjB4KDg9GzZ094eHiI3SoR1Go14uLicPr0aZw9exbR0dG4ceMGzMzM0LFjR/Tq1QuDBw9G//79+QZYarQYyhEREREREemvyYZyJSUlOHXqFI4ePYpjx44hKSkJtra26Nu3L4KDgxEcHIznn38eNjY2YrdKVCeZmZk4c+YMoqOjERUVhYsXL0ImkyE4OBghISEICQlBUFAQJBKJ2K0SAWAoR0RERERE1BBNKpTLy8vD3r17sXv3bpw6dQoqlQqdOnVCSEgIBg8ejF69esHS0lLsNokM4u7du/jll19w7NgxHD9+HFlZWXBzc8OIESMwduxY9O/fn8+jI1ExlCMiIiIiItJfow/lCgsLceDAAURGRuL48eOQSqUYNmwYRo4ciZCQELRo0ULsFomMThAEXLx4EceOHcPevXtx4cIFuLq6YvTo0Rg7diyCg4P5XEQyOYZyRERERERE+mu0odyZM2ewZs0a7N+/HxqNBoMHD8bYsWMxatQo2Nvbi90ekaiuX7+OyMhIREZG4u+//4anpycmTZqEt99+m0E1mQxDOSIiIiIiIv01qlCuvLwckZGR+Oabb3DhwgV07doVb731Fl555RW+kZKoFvHx8YiIiMDGjRuRn5+P0NBQzJo1C127dhW7NXrCMZQjIiIiIiLSX6NY76ZSqfDll1+iVatWmDJlCtq0aYOzZ8/i3LlzmDJlCgM5okfw9/fHsmXLcOvWLXz33XdISEhAt27d0LNnT5w8eVLs9oiIiIiIiIioBqKHcnv27IG/vz+WLFmCiRMn4saNG9ixYwe6d+9u8l4OHz6Mdu3aQSaTPfbc2NhYDB8+HA4ODpDL5Rg4cCCio6Mf+zm1Wo2FCxeibdu2sLKywtChQ3XHioqKIJFIqmxnz5597Jjz5s2r8plly5ZVO+f8+fOYOHEifHx8YG1tDUdHRwQGBuIf//gH1q1bh+TkZPzxxx/V6js4OFQZZ//+/VWOjxgxosrxmzdvYtSoUSgoKDDI/apJfX5PD8vLy8P69esxYMAAODo6wtraGm3btsWECRNw6dKlaucvWLAAkZGRtY43adIkWFpawsfHB7Nnz0ZZWVm9ezIUS0tLvPHGG4iJiUFUVBScnJwwcOBAjBo1ClevXhWtLyIiIiIiIiKqgSCSy5cvC7179xYkEonw2muvCbdv3xarFeH69evCyJEjhU6dOgn29vaCmZnZI8//448/BGtra2Hs2LFCRkaGkJ2dLbz55puCTCYTjh079sjPbtiwQQAgLF26VMjLy6vxnIsXLwoABADC0KFDHzleTk6OYGdnJwAQJkyYUO24Wq0W3n33XUEmkwnz5s0TEhIShLKyMuHOnTvC8ePHhYEDB+pqVVRUCIIgCJMmTRIACK+//nqNNdPS0gRXV1chNTW1Wt/Ozs7CmjVrquxvyP16UH1/TzWZMmWKIJPJhK+++krIzMwUiouLhaioKMHf318wMzMT9u3bV62mj4+P8P7779c6ZkFBgbB+/XoBgLB8+fJ692RMJ06cEDp16iSYm5sLc+bMEYqKisRuiZ4gkUKkAEG0f0aIiIiIiIiaNFH+b+rbb78VrKyshB49egh//vmnGC1UMX78eOGzzz4TKioqBA8Pj0eGPWq1WggICBBatGghlJSU6PZXVlYKfn5+gpeXl1BWVvbIWgCEgoKCWs+5ePGiYG1tLbRq1UoAIJw/f77WcxcvXix06NCh1lBu0aJFAgDhu+++q/HzlZWVwtChQ6uEcjk5OYKTk5MAQDh16lS1z4wePVr47LPPquxTKpWCp6enMHXq1Cr7G3q/HlSf31NtpkyZIrz11lvV9sfGxgoAhLZt29Z4TCKRCJGRkY8c28bGRhg8eHC9ezK2yspKYcOGDYKTk5PQvn174dKlS2K3RE8IhnJERERERET6M+n/TWk0GuHf//63IJVKhQ8//FCorKw0ZflaPRgWPS7s+e233wQAwsyZM6sdW7JkiQBA2LNnT62fHzx48GPDpIsXLwq2trbCunXrBADCiy++WON5eXl5gqOjo7Bly5YaQ7mEhARBKpUKXbp0eWS9M2fOVAnlBEEQwsPDBQBCQECAUF5ertt/5MgRwd/fv8o+QbgfDspkMiE9Pb3K/oberwfV5/ekD2tra0EqlQoajabasdDQUMHT07PKPXqYu7v7Y++1mG7fvi307t1bkMvlwokTJ8Ruh54ADOWIiIiIiIj0Z9Jnys2bNw9r165FREQEPv74Y5iZmZmyfK2sra3rfO6vv/4KAHjuueeqHdPue9TD9dVqdZ1rTZo0CR4eHvjpp59w+fLlase/+eYbDBs2DK1bt67x89999x00Gg1CQ0MfWadHjx4QBKHKM9omT56M4OBgxMXFYfXq1QCAsrIyzJw5E99++y3Mzc115wqCgPDwcHTr1g3u7u5Vxm7o/XpQfX5P9VVcXIzS0lIEBgZCIpFUO/7yyy8jLS0Nhw4dqnUMiUSCyspKo/XYUJ6enjhx4gRGjhyJESNG6P1MPyIiIiIiIiJqOJOFcjt27MCqVauwdetWjB071lRlDS4xMRHA/YDjYR4eHgBgsIfqW1paYt68eRAEAcuXL69yrKioCGvWrMGiRYtq/XxUVBQAoFOnTvWuLZFIsG7dOshkMixduhS3bt3Cp59+ip49e6Jv375Vzr106RKysrIQFBRUbRxT3q+G2L17NwBg8eLFNR5/5plnAADHjh0zWU/GYGFhgW3btmHo0KF45ZVXkJOTI3ZLRERERERERE8lk4RyJSUlmDt3LqZNm4Zx48aZoqTR5OfnAwBsbW2rHbOzswNw/w2ftSkvL4elpWWd67311ltwdXXFnj17kJCQoNu/du1aDBgwAB06dKj1sxkZGQAAJyenOtd7UMeOHTFnzhwUFxdjwoQJ2LhxI7788stq5125cgVAzcFbQ++XKWRlZWHBggUICwvDmDFjajxHGyBqr7UmlpaWqKioMEqPhiSVSrF161ZYWFjg/fffF7sdIiIiIiIioqeSSUK5AwcOIDc3F0uWLDFFOdEIggAANS5/1Lp161aN4VVtrK2tMXfuXGg0Gnz66acA7oecq1evrnVW18Me1c/jLFmyBF5eXjh9+jTef/99NG/evNo5mZmZAACFQlGvsetyv4wtNzcXQ4YMQb9+/bB+/fpaz7O3t4dEItFda03c3d2Rnp7eqJewasnlcixcuBA//vgjioqKxG6HiIiIiIiI6KljklDu7Nmz6Nq1a42BTlPj4OAA4P4zyB6m3ac950H37t3Dl19+iZs3b2L69On1qjl9+nQ4OTlhx44duH79OjZs2IDu3bs/dlmq9vluDVmiaGtriz59+gBAjctTgfvPmgNQ5TlzWvreL1MoLi5GSEgI/P39sX379sc+41Amk6G0tLTW41OnTkVBQQE+/PDDJrEsdOTIkSguLsalS5fEboWIiIiIiIjoqWOSUC4vLw+Ojo6mKGV07du3BwCkpaVVO5aeng4AaNeuXZX9EydOhJOTExYsWID58+dj1qxZ9appZ2eHOXPmQK1W46OPPsLKlSvrtOxQ++y3ml4SYUhWVlYAUOPSTX3ulylUVlYiNDQUHh4e2Lp1a51eOlJZWfnIl028+uqrWL58Ob788ku4uLhgyJAhhmzZ4LTLmsVePkxERERERET0NDJJKOfl5YVr166ZopTR9e/fHwAQExNT7Zh23wsvvFBl/5YtW6BUKrFz506sWrUKU6dOrXfdmTNnQqFQICIiAkFBQTW+zfRhU6dOhUwmw549ex553vz58yGVSnUvZaivFi1aAACUSmW1Y/rcL1OYOnUqVCoVdu3aVeWts23atMEff/xR7fyCggIIgqC71posXrwYixYtwrp165Cfn4+jR48apXdDSUpKAgC0atVK5E6IiIiIiIiInj4mCeVGjhyJxMREnD171hTljKpv377w9/fHnj17dMs2AUCtVmPnzp3w8vLC8OHDq33O3t4eoaGh6Ny582NDspooFArMnTsXCoWizg/nb9euHT766CNcuHABmzdvrvGcpKQkbNiwAWPGjNHNaquvwMBAADXPhtP3fhnTkiVLEBcXhwMHDtT5pRvaWX3aa63J3r174ePjg7CwsHo/X08MW7ZsgY+PzyOviYiIiIiIiIiMwyShXPfu3dG3b1/MmjUL5eXlpihpNFKpFJs2bcK9e/cwadIk3LlzB7m5uZgxYwauXbuGjRs36pZz1sTe3h4FBQV61f7www+Rn5+Pnj171vkz77//PhYsWIBp06ZhwYIFuHr1KsrLy5Geno5Nmzahf//+6NSpEzZt2qRXT8D9Z801b968xmeT6XO/Xn31VUgkEty4cUPvnmobZ8uWLfj4449x7tw5yOVySCSSKltycnKNY8XGxgIABg8eXGu9wsJC2NvbN6hnU/nrr7+wbt06vPfee6K+aIOIiIiIiIjoaWWSUE4ikWDDhg24du0aJk+eDI1GY4qydXbw4EFdKJOeng61Wq37OTw8vNr53bt3x5kzZ6BUKuHn5wdvb29cu3YNv//+O0JCQh5Z63EBiJ2dHTp37ozi4mJIJJLHPpdMIpGgd+/eAIDt27dDIpHgP//5T5VzPvvsM0RHRyMjIwMDBw6EnZ0dOnTogPDwcCxYsAAnT56Era1ttbHXr18PiUSC7du3AwB69+4NiURS7e2iEokEYWFhOHfuHDIyMqqNU9/7lZmZCTs7O7Rs2bLK/vr+nmoaR59ZigCwb98+eHh4PHZWX1MIuG7fvo2XXnoJffv2xZtvvil2O0RERERERERPJYkgCIKpip04cQIjR47EiBEjsG3btkfOKHtSjRgxAocPH250wWRDKZVKBAQEYMSIEVi/fr3e4+Tn58Pd3R0TJkzAxo0bRR8HAC5duoTOnTsjIiIC48aNq/U8Nzc3+Pj4NOpl2leuXMGwYcPg4OCAqKgo0d58S0+GXdiFsRgLASb7Z4SIiIiIiOiJYZKZcloDBw7EsWPHcPLkSXTt2hXx8fGmLN8oeHp6QhAEZGVlid2KQSkUCvz888/Ys2cP1q5dq9cYgiBg1qxZsLe3xyeffKJ3L4YaBwBSUlLwyiuvYOHChY8M5CoqKnDv3j14eno2qJ4xbdq0Cd27d4ePjw9OnTrFQI6IiIiIiIhIRCYN5QCgT58+iI2NhUKhwDPPPIPZs2cjPz/f1G2IRrscdcWKFcjNzRW5G8Pq3LkzLly4gCNHjuj13LysrCykpKTg5MmTcHNz07sPQ40DABs2bMDy5cuxfPnyWs9RKpVYtWoVKioqHrvcWAzx8fEYMmQI3nzzTUyZMgW//PILmjVrJnZbRERERERERE81ky5ffZBGo8GPP/6I+fPno6KiAh9++CFmzJgBmUwmRjsm9cUXX2DLli1ISUlB//79ceTIEbFbIj1NnDgRERERaNWqFcaPH4+PPvoIZmZmYrcFAMjNzcXSpUuxdu1aPPvss1i9ejWCg4PFboueIFy+SkREREREpD/RQjmt/Px8LFu2DGvWrEGrVq0wc+ZMTJw4EXK5XMy2iJqspKQkrFmzBlu3bkWzZs2wYsUKjB8/vkm8hIKaFoZyRERERERE+jP58tWHOTg4YOXKlYiPj8fAgQOxcOFCeHp6Ys6cObh+/brY7RE1CYIg4MiRIxg6dCg6dOiAY8eOYdmyZUhMTMQ///lPBnJEREREREREjYzooZxW69at8e233yItLQ0ffvghfvrpJ/j5+WHgwIEIDw/HvXv3xG6RqNGJi4vDBx98gLZt22L48OFQq9X46aefkJSUhNmzZ8PGxkbsFomIiIiIiIioBqIvX62NWq3GwYMHsW3bNhw+fBhqtRqDBg3C2LFj8eKLL8Le3l7sFolEcf36dezcuRORkZG4cuUKvLy8MGbMGEyePBn+/v5it0dPES5fJSIiIiIi0l+jDeUeVFhYiJ9++gk7d+7E8ePHIZVK0a9fPwwePBhDhgxBhw4dxG6RyGhUKhWio6Nx7NgxHDt2DJcuXYKrqytGjx6NcePGoWfPnpBKG82kV3qKMJQjIiIiIiLSX5MI5R6Ul5eHAwcO4MiRIzhx4gTu3buHli1bIiQkBCEhIXjhhRfg4OAgdptEDXLt2jVdCPfbb7+huLgY7du3R0hICEaOHIl+/fo1mre80tOLoRwREREREZH+mlwo9yCNRoOLFy/ixIkTOHHiBE6dOoWKigr4+voiODgYvXr1QnBwMPz9/fmge2q0KisrkZSUhOjoaJw+fRr//e9/kZqaCltbW/To0QMjRozAiy++CG9vb7FbJaqCoRwREREREZH+mnQo97C8vDycOnUKp0+fxtmzZxETEwOVSoUWLVqgZ8+eCA4OxnPPPYegoCA+k45Ec+vWLcTGxuLcuXM4ffo0Lly4gJKSEjg7O+v+ToODg9GtWzfIZDKx2yWqFUM5IiIiIiIi/T1RodzDysrKcOHCBZw5cwbR0dE4e/YssrOzIZFI4Ovri86dO+OZZ57RbR4eHmK3TE+QyspKJCYmIjY2VrddvHgR9+7dg0QigZ+fH3r27IlevXqhR48eaN++vdgtE9ULQzkiIiIiIiL9PdGhXE20s5Qe3G7cuAEAcHFxQceOHeHn54f27dujffv28PPzQ8uWLbn8lWqlUqlw9epVJCUlISkpCQkJCUhMTERcXBzKyspgYWGBwMDAKgEwZ2vSk4ChHBERERERkf6eulCuJvn5+bqALj4+HomJiUhISEBOTg4AwMbGBn5+fvDz80OHDh3g6+sLHx8feHt7w93dnYHdU0ClUiE1NVW3Xbt2DQkJCUhKSkJqairUajXMzMzg7e2t+zvp2LEjnnnmGfj7+8Pc3FzsSyAyOIZyRERERERE+mMo9wi5ubm6mU9JSUlITExEYmIibt68ifLycgCApaUlWrZsCW9v72qbh4cH3NzcYGlpKfKV0OMolUqkp6cjPT29Svim3TIzM6H9T0WhUKBt27a68E0b2LZr146/a3qqMJQjIiIiIiLSH0M5PWg0GmRkZCA1NRU3btzAjRs3qgQ4t2/fRmVlpe58Z2dnuLm5wdPTE25ubrqwztPTE66urnB2doazszOaNWsm4lU9eSoqKpCbm4vc3Fzk5OQgLS0Nd+7c0X1NT0/XfS0pKdF9zs7ODt7e3rrZkNqv2o2/J6L7GMoRERERERHpj6GcEVRWVuLOnTu4ffs2srKykJaWVu3rnTt3kJ2dXeVzZmZmcHJygrOzM5ycnKpsLi4uUCgUcHBwgL29Pezs7CCXyyGXy3X7zMzMRLpi4yktLUVhYSEKCwuRn5+PgoICFBUVobCwEEqlUhe6Pbjl5OQgOzsbBQUFVcYyNzeHq6urLgzVfvXy8tL93KJFCzg7O4t0tURNC0M5IiIiIiIi/TGUE5FKpcLdu3d1IVJNAVNaWhrOnz8Pe3t7qFQq5Ofn1zqetbV1laBOIpHAwcEBAHSzuxQKBaRSKeRyOWQyGezs7Ko876y2cM/GxqbGpZmFhYVVZgVqlZWVobS0VPdzcXExysvLUVJSApVKpTteXl6O4uJiVFRUoKioCBUVFboArraxgfsBm0KhqBZePhhiPvizs7Mzmjdvzuf/ERkQQzkiIiIiIiL9ycRu4GlmaWkJLy8veHl51Xj88uXLGD58ONq0aYNDhw7pzisoKNDNHtPOGFMqlVX2FRQUoLKyEoWFhdBoNFAqlQCA1NRUAPefoabRaFBQUAC1Wg0AVc57mPb8h1lbW8PKyqrafplMBrlcXu08CwsLJCcnw8fHBy1btoSNjQ1cXV0hlUqhUChgZmYGe3t7ODg46AJG7dasWTPd9zXVJCIiIiIiIiJqKhjKNVLHjh1DaGgounXrhj179kChUOiO2dvbw97e3qT99OzZE926dcPq1asbPNbw4cORnp6OnTt3QiqVGqA7IiIiIiIiIqKmhYlIIxQeHo4RI0Zg9OjROHz4cJVATiw5OTkGe9baypUrERcXh23bthlkPCIiIiIiIiKipoahXCMiCALmz5+Pt956Cx9//DE2b95c5XlvYsrOzoaLi4tBxurQoQOmTJmCxYsXo7i42CBjEhERERERERE1JQzlGgmNRoPp06fjq6++wrZt27Bo0SKxW9KpqKiAUqk06FtJly5disLCQqxatcpgYxIRERERERERNRUM5RoBtVqNN998E5s3b0ZkZCQmTJggdktV5ObmQhAEg82UA4DmzZtj/vz5+OKLL5CVlWWwcYmIiIiIiIiImgKGciITBAFhYWGIiIjAvn378PLLL4vdUjXZ2dkAYNBQDgDmzp0LuVyOL7/80qDjEhERERERERE1dgzlRDZnzhxERERg7969GDZsmNjt1Egbyhly+SoAWFtb491338X69etx9+5dg45NRERERERERNSYMZQT0UcffYS1a9fixx9/xNChQ8Vup1Y5OTkwMzNDs2bNDD72tGnTYGtri9WrVxt8bCIiIiIiIiKixoqhnEg2bdqETz75BBs2bEBoaKjY7TxSdnY2HB0dYWZmZvCxbWxsMHfuXPznP/9BTk6OwccnIiIiIiIiImqMGMqJ4NSpU5g+fTref/99TJkyRex2HisnJ8fgS1cf9K9//QvW1tZYs2aN0WoQERERERERETUmDOVM7OrVq3jppZfwj3/8Ax9//LHY7dRJdna2wV/y8CBbW1vMmTMHX3/9NZRKpdHqEBERERERERE1FgzlTKikpASjR49G27ZtsXnzZkgkErFbqpN79+7B0dHRqDVmzJgBtVqNH374wah1iIiIiIiIiIgaA4ZyJjRjxgykpaUhMjJzpgDmAAAgAElEQVQSVlZWYrdTZ0qlEg4ODkatoVAoMGHCBKxbtw6CIBi1FhERERERERGR2BjKmcj27duxdetW/PDDD/Dx8RG7nXpRKpVQKBRGrzN9+nQkJCTg1KlTRq9FRERERERERCQmhnImkJmZiVmzZmHGjBkYMWKE2O3Um6lCuU6dOqFHjx5Yt26d0WsREREREREREYmJoZwJzJgxAwqFAp999pnYrehFqVTC3t7eJLXefvtt7Nu3DxkZGSapR0REREREREQkBoZyRrZv3z7s378fW7ZsgZ2dndjt6MVUM+UAIDQ0FPb29vj+++9NUo+IiIiIiIiISAwM5YyovLwc7733Hv75z3+iT58+YrejF41Gg6KiIpOFclZWVnjttdf4FlYiIiIiIiIieqIxlDOiNWvWIC0tDZ9++qnYreitsLAQGo3GZMtXAWD8+PG4evUqYmJiTFaTiIiIiIiIiMiUGMoZSUlJCVasWIE5c+agZcuWYrejN6VSCQAmmykHAF27dkWbNm0QGRlpsppERERERERERKbEUM5INm7ciJKSEvz73/8Wu5UGKSgoAGDaUA4AXnnlFezdu9ekNYmIiIiIiIiITIWhnBFUVFRg1apVCAsLg4uLi9jtNIh2ppwpl68CwMiRI5GcnIykpCST1iUiIiIiIiIiMgWGckZw7Ngx3L59G3PmzBG7lQYTY/kqAPTo0QNOTk44dOiQSesSEREREREREZkCQzkj2LZtG3r37g0fHx+xW2mwwsJCSCQS2NramrSumZkZBg4ciJMnT5q0LhERERERERGRKTCUM7CCggL8/PPPePXVVxs81uHDh9GuXTvIZDIDdKYflUoFS0tLSCSSen0uLy8P69evx4ABA+Do6Ahra2u0bdsWEyZMwKVLl+o0Rrdu3XD+/Hl92taJjY3F8OHD4eDgALlcjoEDByI6OrpBYxIRERERERERNRRDOQM7deoUVCoVXn75Zb3HSE5OxqhRo7Bw4UJkZWUZsLv6U6lUsLCwqPfn5s2bh5kzZ+LFF19EfHw8cnNzsXnzZsTGxqJLly7Yv3//Y8d47rnnkJ2djZs3b+rTOs6dO4eePXtCLpcjISEBN27cgK+vL/r164fjx4/rNSYRERERERERkSEwlDOw3377DR07doSzs7PeY3zwwQfo2bMnYmJiIJfLDdhd/ZWXl8PS0lKvz06ePBmzZ8+Gm5sbbGxs0Lt3b0RERECtVmP+/PmP/XyXLl0gk8lw4cKFetfWaDSYMmUKHBwc8P3336NFixZwdnbGunXr0Lp1a4SFhUGlUulzWUREREREREREDcZQzsB+//139OvXr0FjbNq0CQsWLBB12aqWvjPlwsPDsWHDhmr7g4KCYG1tjeTkZAiC8MgxbGxs4OvriytXrtS7flRUFOLi4jB69GhYW1vr9puZmWH8+PG4ffs2Dh48WO9xiYiIiIiIiIgMgaGcAWk0GsTHx6NLly4NGufBEElsDZkpV5Pi4mKUlpYiMDCwTs+p8/DwQGZmZr3r/PrrrwDuL4F9mHYfXyJBRERERERERGJhKGdA6enpUKlUaN26dZX9iYmJeOmll6BQKGBjY4OuXbvi4MGDGDhwICQSCSQSCcLCwkTq+tG0L3oADHMdu3fvBgAsXry4TvVbtGihC+XqUz8xMREA4OnpWW1MDw8PAMDVq1fr1AMRERERERERkaGJvz7yCZKSkgIA8PHx0e27fv06evToAVtbW+zZswc9evTAzZs3MWfOHFy+fBmWlpYoKysTq+XHqqiogIWFhUGuIysrCwsWLEBYWBjGjBlTp/otWrRAVFRUvevn5+cDAGxtbauNaWdnB+D+G2KJiIiIiIiIiMTAUM6AtEHQgy95WLRoEfLz8xEeHo5BgwYBAAICAhAREQFvb28x2qwXjUYDiUTS4OvIzc3FkCFD0K9fP6xfv77O9R0dHZGXl2fQ+6h9ll1dls8SERERERERERkDl68aUGVlJQBUeUHD0aNHAQAhISFVznVxcUH79u1N15yepFIpBEFo0HUUFxcjJCQE/v7+2P7/2bvv6CrqxP3j75uE9EIglIQaWkJCFZAmqCyCqIi6NJd1BWGNq18EAVFhFWQFOyquCIqIfgUVosjKoiBYkCJfRcoSCBAIJQ1Ceki/d35/8MtdYxIg5d4J8LzOmZMwM3c+z1w5h+NzPjOflStxdXWtco6qjl+/fn372BXl+e05IiIiIiIiIiLOplKuFlmtVlxdXe0zsAoLC8nJycHT09P+yORvBQYGOjtilVksFqxWa7Xvo6SkhFGjRtGsWTM++OCDahVyQJXHLy3qEhISyh1LTEwEoEOHDtXKIiIiIiIiIiJSUyrlapGPjw9Wq9U+E8vDwwM/Pz8KCgrIzc0td/7Zs2edHbHKXFwu/BWp7n1ERUVRWFjI6tWry8wgbNeuHT/99NMlxzcMAxcXlyqPf/PNNwOwe/fucsdK9/3hD3+45PgiIiIiIiIiIo6gUq4WtWzZEoBTp07Z9w0bNgz47+OXpVJSUq6I1T8tFgs2m61a9zF37lxiYmJYt26dfQXXqioqKsLd3b3K4994441EREQQHR1dZgEIq9XKJ598QosWLbj99turlUlEREREREREpKZUytWiFi1aAGVLuQULFtCgQQOmTp3KN998Q25uLgcOHGDChAk0bdrUrKiXzWKxYBhGle9jxYoVPPvss+zatQs/Pz8sFkuZ7dixY5c1/pkzZ2jSpEmVx3dxceG9994jPT2dCRMmkJKSQlpaGo888ghHjx7l3XffxdPTs8bfj4iIiIiIiIhIdaiUq0X169enadOm7Nu3z76vbdu27Ny5k169ejFy5EiaNGlCVFQUTz31FO3atavwOuvXr7eXV4mJiVitVvufly1b5qzbAf5bylX1PqKjo2tl/JSUFJo0aVKt77FPnz7s2LGDrKwswsLCaN26NUePHuX7778vt2CEiIiIiIiIiIgzuV36FKmKAQMGsHXrVmbOnGnf16FDB9auXXvZ17jjjjswDMMR8arM1dUVq9UKVO0+1q9fXyvjnzlzhr59+1Z5/FLdu3dnw4YNtZJFRERERERERKS2aKZcLbvxxhv58ccf7UXWlc7Dw4PCwkLTxj99+jQhISGmjS8iIiIiIiIi4ggq5WrZkCFDyM7OZvPmzWZHqRVmlnIZGRkkJiYSGRlpyvgiIiIiIiIiIo6iUq6WtW/fnhtuuIHly5dXes4nn3yCxWJhy5YtFBYWYrFYmDRpkhNTXj5PT88yq5f+lqPv4z//+Q8AnTt3NmV8ERERERERERFHsRh15eVlV5EVK1YQFRVFQkICjRo1MjtOjXz44Yc8+OCDlRZzjrR48WJmz55Neno6FovF6eOLyMWtZjVjGIOB/hkRERERERGpKs2Uc4DRo0fj4+PDW2+9ZXaUGvP09KSoqMiUhSd2795N165dVciJiIiIiIiIyFVHpZwDeHt7M336dF577TXS09PNjlMjnp6eGIZhynvlfvjhBwYOHOj0cUVEREREREREHE2lnINMmTIFT09PXnnlFbOj1IiHhweA00u5hIQEjh07xo033ujUcUVEREREREREnEGlnIP4+vry+OOPs2jRIs6ePWt2nGrz8fEB4Pz5804d9/vvv8fd3Z2+ffs6dVwREREREREREWdQKedADz/8MAEBATz99NNmR6k2X19fAHJzc5067qZNm+jTpw/e3t5OHVdERERERERExBlUyjmQt7c3r776KsuWLWP79u1mx6kWf39/AHJycpw2ZnFxMevXr+euu+5y2pgiIiIiIiIiIs6kUs7Bxo4dy7Bhw3jooYcoLi42O06V+fn5Ac4t5b7//nsyMjIYMWKE08YUEREREREREXEmlXJO8MYbb3Ds2DEWLlxodpQqM6OU++KLL+jWrRtt2rRx2pgiIiIiIiIiIs6kUs4J2rZty9NPP83cuXPZv3+/2XGqxNPTk3r16jmtlCsuLmbNmjWMHDnSKeOJiIiIiIiIiJhBpZyTPPHEE/Tt25d7772XvLw8s+NUiZ+fX5lSLiMjg7i4ODIyMmp03Y8++oi//OUvHDt2zL5v/fr1pKWlcd9999Xo2iIiIiIiIiIidZnFMAzD7BDXioSEBLp168bIkSNZsmSJ2XEq9OWXX3LgwAHS0tJIS0vj3Llz/PrrrxiGQX5+PtnZ2dhsNgBiYmKIiIio9lhz5sxh3rx5uLm5MWHCBGbPns2jjz5Kfn4+mzZtqq1bEhEHWc1qxjAGA/0zIiIiIiIiUlVuZge4ljRv3pylS5cycuRIBg0axOjRo8scT0pK4quvvmLixIkmJYS4uDhmzZpFvXr1sNlsWK3WCs9r1KhRjQo5gPj4eFxdXSkpKWHFihUsX74cNzc3FixYUKPrioiIiIiIiIjUdXp81cn++Mc/8sgjj/DAAw+wd+9e+/6UlBQGDhzIY489RmZmpmn5Jk2ahLe3N8XFxZUWcm5ubgwbNqzGYx05csQ+Rul4NpuNmTNnct999xEXF1fjMURERERERERE6iKVciZ4/fXX6d27NyNGjODMmTOcPXuWgQMHcurUKfLz81m0aJFp2fz8/Jg4cSL16tWr9BybzcaQIUNqPNaJEyfK7Sst5z755BPCw8OZOHFiheeJiIiIiIiIiFzJ9E45k6Snp9O7d28CAwPJzs7m2LFjlJSUAODr60tCQgIBAQGmZIuLi6NDhw5U9lfDYrGQmJhIcHBwtccoKirC09Oz0jFKx/H09OSrr77ixhtvrPZYIuIYeqeciIiIiIhI9WmmnEkaNGjARx99xKFDh8oUcgAFBQUsXrzYtGzt2rXj1ltvrXS2XFhYWI0KOYBTp05dtJBzdXXF29ubzZs3q5ATERERERERkauOSjmTZGZm8tBDD1FYWFimkAMoKSnhxRdfJCcnx6R0MG3aNIqLi8vtd3d35/bbb6/x9ePj4ys95urqipeXF1u2bKFfv341HktEREREREREpK5RKWeCrKwsBg0aRExMTIXFF8D58+dZsmSJk5P91+DBg+nYsSMuLmX/ihQVFXHLLbfU+PonTpzAza384r9ubm54e3vz7bff0rt37xqPIyIiIiIiIiJSF6mUc7LSQm7fvn2VFnJwYbbc888/T15enhPTlTV16tRy+9zc3LjhhhtqfO0TJ07g6upa7tp+fn5s27aNXr161XgMEREREREREZG6SqWck507d4727dsDXHSFU4Ds7GyWLl3qjFgVuu+++/Dz87P/2WKx0LdvX3x8fGp87RMnTpQpJd3c3AgICGDr1q106dKlxtcXEREREREREanLVMo5Wdu2bfnkk0+Ii4vjoYcewt3dvdJyzmq1Mn/+fPLz852c8gIvLy8efvhhez43NzeGDRtWK9c+fPgwNpsNuFBOBgUFsXPnTjp16lQr1xcRERERERERqctUypkkNDSURYsWcfr0aWbNmoWvr2+F71jLzMxk2bJlJiS84H/+53/s5VlxcXGtvE8OLsyUgwtFX6NGjdi2bZt9BqGIiIiIiIiIyNVOpZzJGjduzNy5c0lKSuKVV14hKCgIV1dXLBYLcGG23Lx58ygoKDAlX0hICPfccw8A/v7+XHfddTW+ZkFBAenp6VgsFpo1a8ZPP/1E27Zta3xdEREREREREZErRfmpWWIKPz8/pkyZwl//+leWL1/OCy+8QHJyMnDhPXTvv/8+f/vb32o0RkFBAfn5+RQVFXH+/HlKSkrIyckBwGazkZWVVeHn+vTpw5o1a+jYsSOfffZZueOBgYEVfq504QYAFxcXAgICAEhLS8MwDNq2bcvWrVsJCQmp0X2JiIiIiIiIiFxpLIZhGGaHkPKKi4tZuXIl//jHPzh+/DhBQUEsXbqUgoICcnJyyMzMJDs7m9zcXHJycsrtKygoIDc3l+LiYvLy8igsLDT7lirl5+eHm5sbPj4+uLu74+/vj6+vL35+fvj5+VG/fn3777/fV79+fRo2bEhQUFCl5aCIOMZqVjOGMRjonxEREREREZGqUinnRFarlTNnzpCcnGzfzpw5Q1paGmlpaZw7d87+89y5c2RnZ5e7Rr169coVVaUFVmBgoP13Ly8vvL298fDwwNPTEy8vL9zd3fHx8bHPYPvt7DW48Hiqq6truTEtFgsbNmygb9++hIaGljlWXFxMbm5uhfebn59vf+y2dFaezWZjx44dNG/e3P6uuqysLGw2Gzk5OZSUlJCVlUVOTo69cMzKyiI7O7vMvszMzHLjubq60rBhw3JbUFAQjRs3pnHjxoSEhBAcHExwcLBKPJEaUiknIiIiIiJSfSrlaklhYSEnTpywb0lJSSQmJpKSkkJSUhIpKSmcOXPGXkTBhRIsODi4wiKpUaNGBAUFldmXlpZGRESEKfdntVorLOzMVFrOpaWlkZqaai81f7+lpqaSmprK2bNny8wY9PT0JDg4mJCQEJo2bWr/2bJlS0JDQ2ndujUhISH29/uJSFkq5URERERERKpPpdxlMgyDU6dOcfTo0TLl24kTJ4iPjyc5OZnSr9Lf358WLVrYZ2SVFj+/L4C8vb1Nvqtrz7lz58oUpb8tTpOTk+1lalFREQAeHh5lSrrSLTQ0lLCwMM22k2uaSjkREREREZHqUyn3O4WFhcTFxXHw4EGOHz9OTEwMBw8e5PDhw/bHND09PQkJCaFNmzblttLiTa5sGRkZHD9+vNyWlJREfHw8+fn5wIVFLtq0aUNERASRkZH238PCwnBz0zoqcnVTKSciIiIiIlJ912wpZxgGx44dY8+ePezdu5d9+/bxn//8h1OnTgEX3t3Wpk0bOnbsSIcOHQgLCyM8PJwOHToQFBRkcnoxk9Vq5dSpUxw5coTY2FhiY2PtvyclJQHg7u5OWFgYXbt2pWvXrnTr1o3u3bvTsGFDk9OL1B6VciIiIiIiItV3TZRyVquVmJgYfv75Z/bu3Wsv4XJycnB1dSUsLIxu3brRtWtXwsPDCQ8PJzQ0lHr16pkdXa4w2dnZHDlyhMOHD3PgwAH27dvH3r17SU5OBqBFixZlSro+ffpoZqVcsVTKiYiIiIiIVN9VWcrl5uayd+9etm/fzrZt29ixYwfp6em4u7vTrl07evToYd+6d++Oj4+P2ZHlKpeRkUFMTAy7d++2b4cPH8ZqtRIcHEyPHj244YYb6N+/P9dffz3u7u5mRxa5JJVyIiIiIiIi1XdVlHKZmZls2bKFzZs3s23bNg4ePIjNZqNt27b07duXvn370r9/fzp16lTnVhCVa1dubi67du1ix44d7Ny5k507d5KZmYmPjw+9evXixhtvZMiQIfTu3Vt/b6VOUiknIiIiIiJSfVdkKWe1Wvnll1/YtGkTGzduZNeuXRiGQc+ePRkwYAD9+/enT58+NG3a1OyoIpfNZrNx6NAhduzYwfbt2/nuu+84deoU9evXZ/DgwQwZMoShQ4fSsmVLs6OKACrlREREREREauKKKeUKCwv5+uuvWbNmDV999RXp6ek0b96coUOHMmTIEAYPHkyDBg3MjilSq2JjY9m4cSMbN27khx9+IC8vj/DwcO666y7GjBlDt27dzI4o1zCVciIiIiIiItVXp0u5oqIiNm/ezKeffsq6devIycmhf//+3H333QwZMoTIyEizI4o4TWFhIdu2bePrr78mOjqaEydO0KFDB8aMGcPo0aPp1KmT2RHlGqNSTkREREREpPrqZCl3+PBh3nzzTT7++GMyMjLo3bs3Y8aMYdSoUTRr1szseCKmMwyDXbt2sXr1atasWUNCQgKRkZFERUVx//334+/vb3ZEuQaolBMREREREam+OlPK2Ww2Nm7cyBtvvMGmTZto06YNDz74IGPGjKFVq1ZmxxOps2w2G9u3b+ejjz5i5cqVuLq6Mn78eP7nf/6H9u3bmx1PrmIq5URERERERKrPxewANpuNDz74gI4dO3L77bdjtVpZt24dR44cYebMmSrkRC7BxcWFAQMGsHTpUk6fPs0zzzzDl19+SXh4OHfccQd79+41O6KIiIiIiIiI/I6ppdwPP/zA9ddfz6RJkxg4cCAHDhzgm2++Yfjw4bi4OD/ahg0b6NChA25ubg45Hy6sHPvUU0/Rvn17PD09GTZsmP1Ybm4uFoulzLZz585LXvPxxx8v85nnnnuu3Dk///wz48ePJzQ0FC8vLxo0aECnTp344x//yNtvv82xY8fs53bq1Klcjoo2FxcXUlJSyo118uRJ7rzzTrKzs8vs37t3L7fffjv169fHz8+PwYMHs3379sv+7n6rOt99qYyMDJYsWcKgQYNo0KABXl5etG/fnnHjxrFv375y5z/55JN8+umnlV5vwoQJeHh4EBoaypQpUygoKKhyptoSGBjI9OnTiYuL4/PPPyctLY0ePXowceJEkpOTTcslIiIiIiIiIr9jmODkyZPG3XffbQDGsGHDjJiYGDNi2MXFxRnDhw83unTpYvj7+xuurq61ev5vLV261ACMefPmGRkZGRWes2fPHgOwfz8Xc+7cOcPX19cAjHHjxpU7brVajRkzZhhubm7G448/bhw6dMgoKCgwUlJSjE2bNhmDBw+2j1VcXGwYhmFERkYaa9eurXC8/Px8IyIiwgCMadOmVZg9KCjIePPNN8vs/+mnnwwvLy9jzJgxRlJSkpGammr89a9/Ndzc3IyNGzde9B5/qybffamJEycabm5uxuuvv24kJycb58+fN7Zu3WpEREQYrq6u5e49Li7OCA0NNf7+979Xes3s7GxjyZIlBmDMnz+/ypkcxWazGR9//LHRqlUrw9fX13juuefs/51FaupT41MDw5R/RkRERERERK54Tv+/qc8++8wIDAw0OnbsWKUyxpHuvfde4/nnnzeKi4uNZs2aXbLoqer5v/8sYGRnZ1d6zp49ewwvLy+jVatWBmD8/PPPlZ47e/Zso2PHjpWWcrNmzTIA45133qnw8yUlJcawYcMuu5R79NFHDcDo1KmTUVBQUOZYVlaW0bx5cyMqKqrMfqvVakRGRhrBwcFGXl5embHDwsKMFi1alLtWZWry3ZeaOHGi8eCDD5bbv3fvXgMw2rdvX+Exi8VifPrppxe9tre3tzFkyJAqZ3K0/Px84/nnnze8vb2NPn36GPHx8WZHkquASjkREREREZHqc+r/Tb3yyiuGxWIxoqKiypQzZvttlsspeqp6/m8NGTLkkufv2bPH8PHxMd5++20DMEaMGFHheRkZGUaDBg2MFStWVFjKHTp0yHBxcTF69Ohx0fF27NhRppSrzKZNmwyLxWJ4eHgY+/btK3d89uzZhpubm5GYmFhm/3fffWcAxuTJk8t9Zu7cuQZgREdHX3TsUjX57i+Hl5eX4eLiYthstnLHRo0aZTRv3vyi31NISMglv28zHTx40OjcubPRtGlTY/fu3WbHkSucSjkREREREZHqc9qL21577TVmzpzJa6+9xpIlS/Dy8nLW0JdU1Sw1yW61Wi/73AkTJtCsWTP+9a9/sX///nLHFy1axG233Ubbtm0r/Pw777yDzWZj1KhRFx2nb9++GIZx0fezpaenM378eAzDYP78+XTp0qXMccMwWLZsGb179yYkJKTMsW+//RaAnj17lrtu6b4tW7ZcNGMpR/69OX/+PPn5+fZ36v3e3XffTUJCAv/+978rvYbFYqGkpMRhGWuqY8eObN++nS5dujB48GAOHTpkdiQRERERERGRa5JTSrnvvvuOGTNm8NJLLzFlyhRnDHlV8PDw4PHHH7cXYb+Vm5vLm2++yaxZsyr9/NatWwHKFWjVERUVRVJSEjfddBPTpk0rd3zfvn2cOXOGrl27ljsWGxsLQPPmzcsda9asGQBHjhypccaaWrNmDQCzZ8+u8Hi3bt0A2Lhxo9MyOYKfnx/r1q0jMjKSO++8k7y8PLMjiYiIiIiIiFxzHF7K2Ww2HnnkEYYPH8706dMdPVydV1RUhIeHx2Wf/+CDD9KkSROio6PLzGp66623GDRoEB07dqz0s0lJSQA0bNiw+oGBDz/8kOjoaOrXr8+HH35Y4SyyAwcOABUXb5mZmQD4+PiUO+br6wtcWBHVTGfOnOHJJ59k0qRJjB49usJzSgvE0nutiIeHB8XFxQ7JWJs8PT1ZvXo1qampvPTSS2bHEREREREREbnmOLyU++GHHzh06BALFixw9FBXhFOnTlVYXFXGy8uLadOmYbPZ7N9hXl4er732WqUzun6vohLtcp04cYLJkycDsHjxYlq0aFHhecnJyQAEBARU6fqGYdQ4Y02lpaVx6623ctNNN7FkyZJKz/P398disdjvtSIhISEkJibW6UdYSwUHBzNlyhTefffdKj1WLSIiIiIiIiI15/BSbseOHbRr146IiAhHD1Wnpaen8/LLL3Py5EkefvjhKn324YcfpmHDhnz88cfExcWxdOlS+vTpc8nHUkvf7Xbu3LlqZbbZbPzlL38hOzube++9l3vvvbfScwsKCgCoV69euWP169cHLryz7fdK95We42znz59n6NChREREsHLlSlxdXS96vpubG/n5+ZUej4qKIjs7m2eeeaba37szDR8+nKSkJOLj482OIiIiIiIiInJNcXgpl5GRQYMGDRw9TJ02fvx4GjZsyJNPPsnMmTN59NFHq/R5X19fpk6ditVqZc6cObzyyiv8/e9/v+TnbrzxRoAKF4m4HC+99BI//vgjLVq0YPHixRc919PTE6DCRzfDw8MBSEhIKHcsMTERgA4dOlQrY02UlJQwatQomjVrxgcffHDJQq70MxdbbOLPf/4z8+fP5+WXX6ZRo0bceuuttRm51gUFBQEXSmMRERERERERcR6Hl3ItW7bk2LFjV8TjfI6yYsUKsrKy+OSTT1i4cCFRUVFVvsbkyZMJCAhg1apVdO3atcKVTH8vKioKNzc3oqOjL3rezJkzcXFxsS/IALBnzx6eeeYZLBYLH3zwwf7eVM0AACAASURBVCVnsgUHBwOQlZVV7tjNN98MwO7du8sdK933hz/84eI34wBRUVEUFhayevXqMivPtmvXjp9++qnc+dnZ2RiGYb/XisyePZtZs2bx9ttvk5mZyddff+2Q7LWl9L95q1atTE4iIiIiIiIicm1xeCk3fPhw0tPT+fLLLx09VJ3m7+/PqFGj6N69+yVLsooEBAQwbdo0AgICLmuWHFyYfTZnzhx++eUXli9fXuE5hw8fZunSpYwePdo+o62goIBx48ZRXFzMtGnT7KXa740cOZJXXnkFgE6dOgEVz4a78cYbiYiIIDo62v6YK4DVauWTTz6hRYsW3H777Zd1T7Vl7ty5xMTEsG7dusteeKN0Vl/pvVbk888/JzQ0lEmTJlX5/XpmeP/99+nduzdNmjQxO4qIiIiIiIjINcXhpVxoaChjx45l+vTpFc6iutb4+/uTnZ1drc8+88wzZGZm0q9fv8v+zN///neefPJJHnroIZ588kmOHDlCUVERiYmJvPfee9x888106dKF9957z/6ZmTNncujQITp37sz8+fMva5yuXbvSuHFj9u3bV+6Yi4sL7733Hunp6UyYMIGUlBTS0tJ45JFHOHr0KO+++6798ddSf/7zn7FYLDV+11lF11mxYgXPPvssu3btws/PD4vFUmY7duxYhdfau3cvAEOGDKl0vJycHPz9/WuU2Vk2bdrEmjVrmDVrltlRRERERERERK45Di/lABYuXEhRURGjRo2isLDQGUNWyfr16+2FTGJiIlar1f7nZcuW1fj837rUKqO+vr50796d8+fPY7FYLvlOMovFwoABAwBYuXIlFouFf/7zn2XOef7559m+fTtJSUkMHjwYX19fOnbsyLJly3jyySfZsmULPj4+wIWZbqWf/89//oOnp2e50qp0++yzz8rkmDRpErt27SIpKalczj59+rBjxw6ysrIICwujdevWHD16lO+//56hQ4eWOz85ORlfX19atmxZZn9Vv/uKrlOdmYoAa9eupVmzZpec1WfmSrKX68CBA4wdO5Zx48Zx5513mh1HRERERERE5JpjMQzDcMZAe/bs4Q9/+ANdunRh7dq1BAYGOmPYOueOO+5gw4YN2Gw2s6PUuqysLCIjI7njjjtYsmRJta+TmZlJSEgI48aN49133zX9OgD79u2je/furFq1irFjx1Z6XtOmTQkNDWXnzp01Gs+RfvzxR+666y66dOnCV199VW6WosjlWs1qxjAGA6f8MyIiIiIiInJVccpMOYDu3buzdetWjh8/Tvfu3dm2bZuzhq5TmjdvjmEYnDlzxuwotS4gIIAvv/yS6Oho3nrrrWpdwzAMHn30Ufz9/fnHP/5R7Sy1dR2A48ePc8899/DUU09dtJArLi4mPT2d5s2b12g8R7HZbDz//PMMGjSIm266SYWciIiIiIiIiImcVsrBhRfk//rrr3Tt2pWBAwcyevRoTp486cwIpit9HPWFF14gLS3N5DS1r3v37vzyyy989dVX1Xp33pkzZzh+/DhbtmyhadOm1c5RW9cBWLp0KfPnz7/o+/WysrJYuHAhxcXFl3zk2AzfffcdPXr0YM6cOcyePZs1a9aokBMRERERERExkdMeX/29L7/8kqlTp5KSksLkyZOZPXs2fn5+ZkRxupdeeokVK1Zw/Phxbr75Zr766iuzI0kNjB8/nlWrVtGqVSvuvfde5syZg6urq9mxADh69Ki9hBs8eDCvvfbaRVePFakKPb4qIiIiIiJSfaaVcgCFhYW8/vrrLFiwAG9vb6KiooiKiiI4ONisSCJXhZ07d7Jo0SI+++wzwsLCePXVVy+6aqxIdaiUExERERERqT6nPr76ex4eHjzxxBMcPXqUiRMnsnjxYlq3bs24ceP46aefzIwmcsUpLCzkww8/pGfPnvTr14+jR4+ybNky9u7dq0JOREREREREpI4xtZQr1bhxY5577jlOnz7N0qVLiY2NpW/fvnTv3p0XX3yREydOmB1RpE6y2Wxs3bqVRx55hBYtWjBp0iTat2/P9u3b+eWXX/jLX/5SZx6lFREREREREZH/MvXx1YvZvn07K1asYO3ataSnp3P99dczZswYRo0aVWdXtxRxBsMw+Omnn/j000+Jjo4mMTGRTp06MWbMGB544AFCQkLMjijXCD2+KiIiIiIiUn11tpQrVVxczObNm1m9ejVffPEF2dnZ9OzZkyFDhjB06FD69OmDm5ub2TFFHCo9PZ0tW7awadMmNm7cyOnTpwkPD2f06NGMGTOGiIgIsyPKNUilnIiIiIiISPXV+VLutwoLC9m0aRP//ve/2bRpE/Hx8fj7+zNo0CCGDh3KkCFDaNOmjdkxRWqspKSEXbt2sWnTJjZt2sTPP/8MwPXXX8/QoUO566676Nq1q8kp5VqnUk5ERERERKT6rqhS7veOHz/O5s2b2bx5M5s2bSIrK4vg4GB69OjBDTfcQP/+/enVqxceHh5mRxW5qJycHHbt2sW2bdvYvXs327ZtIzMzk6ZNm3LLLbcwfPhwBg8eTGBgoNlRRexUyomIiIiIiFTfFV3K/VZRURE7d+5k27Zt7Ny5k507d5Keno63tze9evWif//+XH/99XTr1o1WrVqZHVeuYcXFxRw8eJA9e/awY8cOduzYwaFDh7DZbHTo0IG+ffvSr18/Bg4cSHh4uNlxRSqlUk5ERERERKT6rppS7vcMwyA2NpadO3eyfft2du7cSWxsLIZhEBgYSLdu3exb165diYiIoF69embHlqtMZmYm+/btY+/evezdu5d9+/YRExNDUVERXl5e9OjRg379+tG/f3/69u1Lo0aNzI4sctlUyomIiIiIiFTfVVvKVSQ7O5v9+/fby5E9e/YQExNDQUEB7u7uREZGEhYWRnh4OOHh4XTo0IGwsDC8vb3Nji513NmzZzl06BCHDx/myJEjHDp0iEOHDhEfHw9AUFBQmSK4W7duhIWFaZESuaKplBMREREREam+a6qUq0hJSQmxsbHs3buX//znP8TGxhIbG8vx48cpKSnBYrHQsmVLOnToYC/qWrduTWhoKK1bt8bHx8fsWxAnOXPmDCdOnODkyZMcP36cw4cPc+jQIY4cOUJGRgYA/v7+9jI3IiKCrl270q1bN5o1a2ZyepHap1JORERERESk+q75Uq4yxcXFHDt2jNjYWA4fPmwvYOLi4jh37pz9vEaNGtGqVStat25N69at7b+3atWKxo0b06RJExPvQi5XUVERZ86cISEhgVOnTnHy5ElOnDhhL+Hi4+PJz88HwNXVlRYtWtiL2vDwcMLCwggLC1P5JtcUlXIiIiIiIiLVp1KuGnJzc+2FTXx8vL24Kd2XlpZmP9fd3Z3GjRvTokULmjRpQvPmzcv8DA4OpmHDhjRs2FCPyTpARkYG586d49y5c/bSraKfZ8+etX/G1dWVZs2a2YvW32/NmzfX+wdFUCknIiIiIiJSEyrlHCAnJ4eEhASSk5NJSkoiJSWFxMTEcj/z8vLKfM7Ly8te0DVs2JBGjRqV+bO/vz9+fn7Ur18fPz8/++br60tgYKBJd+tYRUVF5ObmkpmZSXZ2Nrm5ueTk5JCTk0NmZiZZWVmkpqaSlpZW4Wa1Wstcr1GjRjRp0oRmzZrRtGnTCn+GhISodBO5DCrlREREREREqk+lnImys7NJSUkpUyKlp6eTlpZmn93122OlpVRl/Pz8GFOvHtuCgvDx88PNzQ0/Pz9cXFwICAgAsJd3AQEBuLi44Pf/zytVv359LBZLuWt7e3vj4eFRbn9OTg4lJSXl9hcWFpYpHfPy8igsLKSgoID8/HyKioo4f/48JSUl5OTkYLPZyMrKsv/Mzs4mJyeHwsLCCu/VYrFQv359AgICypWXDRs2pEGDBjRs2JCgoCD71rhx4wrvQUSqR6WciIiIiIhI9WnpRxP5+/vj7+9fpc8YhmGfNVY6Y6x0JlnrTz+l5+ef8+Hdd3MoKMhejP22+Dp+/DiAfWGC0iIMwGq1kp2dDVyYoWaz2fD09AQuFIi/n3UG4OnpiZeXV7n9rq6uZe6t9Dp5eXm0a9fOXhjWq1ePNm3aAP8tBAMDAyucCfj7fSIiIiIiIiIiVyqVcleY0tKq3OOqH3wAn38OCxdy/9SpNR5n/PjxpKSk8PXXX9f4WqU+/PBDJkyYwJo1a+jZs2etXVdERERERERE5ErjYnYAqQVffAGTJsGcOVALhRxAbGwsHTt2rJVrlbrvvvvo378/U6ZMQU9Ni4iIiIiIiMi1TKXcle7bb2HsWHjwwQulXC05fPgwYWFhtXY9uDDL74033mDXrl2sWrWqVq8tIiIiIiIiInIlUSl3Jfv5Z7jrLvjjH+HNN2vtssnJyWRmZhIeHl5r1yzVvXt3Jk6cyIwZM+zvrxMRERERERERudaolLtSHT0Kd9wBffrA+++DS+39pzxy5AhArc+UK/X8889TXFzMggULHHJ9EREREREREZG6TqXclSghAW65Bdq0gbVrwd29Vi9/6tQpPDw8aNq0aa1et1SDBg2YO3cur732GocPH3bIGCIiIiIiIiIidZlKuStNaioMHgwBAfDVV+DjU+tDJCQk0KxZMywWS61fu9Tf/vY3OnbsyOTJkx02hoiIiIiIiIhIXaVS7kqSnw/Dh0NxMXz9NdSv75BhEhMTad68uUOuXcrV1ZV//vOfbN68mfXr1zt0LBERERERERGRukal3JXCMGDixAvvktuwAYKDHTZU6Uw5R7vhhhsYPXo0U6dOpaCgwOHjiYiIiIiIiIjUFSrlrhRPPQXR0bBmDThoAYZSSUlJTinlAF555RVSUlJYuHChU8YTEREREREREakLVMpdCZYvh5degmXLYNAghw+XmppKo0aNHD4OQPPmzXnqqaeYP38+J0+edMqYIiIiIiIiIiJmUylX123ZAg89BE8/DX/5i1OGzM7Oxt/f3yljAcyYMYPg4GCefvppp40pIiIiIiIiImImlXJ12bFjMHo0jBwJc+c6bdicnBynlnIeHh7Mnz+flStX8uuvvzptXBERERERERERs6iUq6tyc+Guu6BlywuPrVosThk2Ly+P4uJip5ZyAKNHj6Z3797MmDHDqeOKiIiIiIiIiJhBpVxdZBjwwAOQmgr/+hd4eztt6OzsbACnl3IWi4UXXniB7777jm+++capY4uIiIiIiIiIOJtKubro2Wfhiy/g00+hRQunDp2bmwuAr6+vU8cFGDhwIHfccQePP/44NpvN6eOLiIiIiIiIiDiLSrm65osvYN48WLQIbrzR6cMbhgGAi4s5fzVefvllYmJiWLlypSnji4iIiIiIiIg4g0q5uuTYMRg/HiZNurDiqglKyzir1WrK+OHh4YwfP55Zs2aRn59vSgYREREREREREUdTKVdXFBRcWGm1dWt44w3TYri6ugKY+vjos88+S0ZGBm+99ZZpGUREREREREREHEmlXF0xeTIcPw6ffw5eXqbFMHumHEBISAhTp05l/vz5pKWlmZZDRERERERERMRRVMrVBatWwXvvwfLl0KaNqVHqwkw5gCeeeAIPDw9eeOEFU3OIiIiIiIiIiDiCSjmzHTgAf/0rzJgBd99tdhrc3d0BKCgoMDWHn58fs2fPZtGiRRw/ftzULCIiIiIiIiIitU2lnJkKCuDee+G662DBArPTANCgQQNcXV05d+6c2VF46KGHaNWqFXPnzjU7ioiIiIiIiIhIrVIpZ6bHH4fTp+F//xfc3MxOA1x4fDUwMJDU1FSzo1CvXj2ee+45Vq5cSUxMjNlxRERERERERERqjUo5s3z9Nbz1FixefGHF1TqkUaNGDinlNmzYQIcOHXCrQgE5atQoOnfuzLx582o9T6mMjAyWLFnCoEGDaNCgAV5eXrRv355x48axb98+h40rIiIiIiIiItculXJmSE2FCRPgz3+GP/3J7DTlNG7cuFYfXz127Bh33nknTz31FGfOnKnSZy0WC08//TRr1qxh//79tZbptx5//HEmT57MiBEjOHjwIGlpaSxfvpy9e/fSo0cPvvjiC4eMKyIiIiIiIiLXLpVyzmYY8MAD4OUF//yn2WkqVNsz5Z5++mn69evH7t278fPzq/Ln77nnHrp06cJzzz1Xa5l+74EHHmDKlCk0bdoUb29vBgwYwKpVq7BarcycOdNh44qIiIiIiIjItaluvMjsWrJkyYVHV3/4Afz9zU5ToZYtW7J169Zau957772Hl5dXtT9vsVh45plnGDlyJPv27aNr1661lg1g2bJlFe7v2rUrXl5eHDt2DMMwsFgstTquiIiIiIiIiFy7NFPOmU6ehCeeuLDAQ79+ZqepVGRkJAcPHsRms9XK9WpSyJW6++676dq1q0Nny/3e+fPnyc/Pp1OnTirkRERERERERKRWqZRzFsOAqCho1gyeecbsNBcVGRlJXl4e8fHxFR6PjY3lrrvuIiAgAG9vb66//nrWr1/P4MGDsVgsWCwWJk2aVKuZLBYLc+bM4bPPPrusxRdqI+OaNWsAmD17dq3cg4iIiIiIiIhIKT2+6izLlsE338DWreDpaXaai4qMjMRisXDgwAHatm1b5lhcXBx9+/bFx8eH6Oho+vbty8mTJ5k6dSr79+/Hw8ODgoICh+QaMWIE3bp1Y968eXz22WeVnlcbGc+cOcOTTz7JpEmTGD16dG3fioiIiIiIiIhc4zRTzhmSkmDmTJg+Hfr3NzvNJfn6+tKqVSsOHDhQ7tisWbPIzMzkjTfe4JZbbsHX15fIyEhWrVrF+fPnHZqr9N1ya9euJSYmptLzapoxLS2NW2+9lZtuuoklS5bU5i2IiIiIiIiIiAAq5Zzjr3+Fxo3h2WfNTnLZOnfuzP79+8vt//rrrwEYOnRomf2NGjUiPDzc4blGjBhBp06deP755ys9pyYZz58/z9ChQ4mIiGDlypW4urrWPLSIiIiIiIiIyO+olHO0NWvgq6/gvfegFhY8cJY+ffrw448/ltlXWFhITk4Onp6e+Pr6lvtMYGCgw3NZLBaeeOIJPvnkE44ePVrueE0ylpSUMGrUKJo1a8YHH3ygQk5EREREREREHEalnCPl5V1YaXXCBLjhBrPTVMlNN91EcnIycXFx9n0eHh74+flRUFBAbm5uuc+cPXvWKdnGjh1LmzZteOWVV8odq0nGqKgoCgsLWb16NW5u/33dYrt27fjpp59qJ7yIiIiIiIiICCrlHGvOHMjOhos8allX9erVC19fX7755psy+4cNGwb89xHRUikpKRw5csQp2VxdXZkxYwbvv/8+p06dKne8Ohnnzp1LTEwM69atw8PDo/ZDi4iIiIiIiIj8hko5Rzl4EN54AxYsuPA+uStMvXr1GDJkCP/617/K7F+wYAENGjRg6tSpfPPNN+Tm5nLgwAEmTJhA06ZNnZZvwoQJBAcH8/rrr5c7VtWMK1as4Nlnn2XXrl34+flhsVjKbMeOHXPGLYmIiIiIiIjINUSlnKNMngxdulxY5OEKNWLECL777juys7Pt+9q2bcvOnTvp1asXI0eOpEmTJkRFRfHUU0/Rrl27Cq+zfv16e8GVmJiI1Wq1/3nZsmXVylavXj2mTp3K0qVLSU1NLXOsqhmjo6OrlUFEREREREREpLoshmEYZoe46qxaBffdBz/9BL16mZ2m2tLT0wkODmbp0qWMHz/+kucPHjyYbdu2UVBQ4PhwXFgpNTQ0lAcffJDnnnvusj7j7IwiV7PVrGYMYzDQPyMiIiIiIiJVpZlyta2gAGbNurC4wxVcyAE0aNCA4cOH88EHH5gdpUI+Pj5MnjyZxYsXV7iog4iIiIiIiIhIXaVSrrYtWgRnz8LcuWYnqRX3338/P/zwQ5lVWOuSRx55hKKiIpYvX252FBERERERERGRy6ZSrjZlZMCLL8KMGdC8udlpasVtt91GaGgob7zxRqXnfPLJJ1gsFrZs2UJhYSEWi4VJkyY5JV+DBg24//77ee211ygpKamTGUVEREREREREfk/vlKtNjz0GK1dCXBz4+5udpta8/vrrzJ49m1OnTtGwYUOz45Rz/PhxOnTowMcff8yoUaPMjiNyzdA75URERERERKpPM+VqS3w8vP02PPvsVVXIAUycOBFPT09ee+01s6NUqE2bNowYMYKXX37Z7CgiIiIiIiIiIpdFpVxtmT0bWrWCq/CRSD8/P2bPns3ChQs5ffq02XEqNH36dH7++We2bdtmdhQRERERERERkUvS46u1ITYWIiNh1SoYM8bsNA5RVFREREQEAwcOrLOLKvTr148mTZqwdu1as6OIXBP0+KqIiIiIiEj1aaZcbViwADp0gKv4fWbu7u784x//4IMPPmDPnj1mx6nQ9OnT+de//kVsbKzZUURERERERERELkqlXE0dPw4ff3zh8VWXq/vrHDt2LD169OCJJ54wO0qF7r77btq0acOiRYvMjiIiIiIiIiIiclFXd4vkDAsWXHiX3NixZidxOIvFwhtvvMG3337Le++9Z3acclxcXJgyZQorVqzg3LlzZscREREREREREamUSrmaOH0a/vd/YdYscHMzO41T9O3bl+nTpzNt2jROnjxpdpxyHnjgAXx8fFi8eLHZUUREREREREREKqVSriZefBGCg+G++8xO4lTz5s2jZcuWPPDAA9S1dUK8vb2JiorirbfeIj8/3+w4IiIiIiIiIiIVUilXXZmZsGIFTJsG9eqZncapPDw8eP/999m6dStvv/222XHKefTRR8nOzuajjz4yO4qIiIiIiIiISIVUylXX8uUXFna4/36zk5iiZ8+ezJo1i+nTp/Pzzz+bHaeMxo0bM27cOF599VVsNpt9v9VqZe3atcTFxZmYTkREREREREREpVz1GAYsXXqhkAsIMDuNaebMmcOgQYMYMWIEycnJZscp4/HHH+fo0aNs2LCBjIwMXn75ZVq1asU999xDbGys2fFERERERERE5Bp3baxOUNu++gqOHIHPPjM7ialcXFz46KOPuP766xk1ahTffvst7u7uZscCICwsjP79+zNlyhQSExOxWq2UlJTg4uJCenq62fFERERERERE5BqnmXLV8c9/wuDB0KmT2UlMFxgYyOeff86+ffuYMWNGhefYbDaSkpKcksdms7F582aGDRvGtm3bSEhIoLCwkJKSEgDc3NzIyMhwShYRERERERERkcpoplxVxcXBxo3X/Cy53+rcuTPLly9nzJgxtG7dmmnTppU5PnPmTPbs2cOWLVsclsEwDBYuXMjrr79OYmIiLi4uGIZBUVFRmfMsFotmyomIiIiIiIiI6VTKVdWKFRASAsOHm52kThk1ahRnz55l8uTJBAQEMHHiRAAWLVrEq6++CsC///1vbr/9doeMb7FYcHFxISEhAbiwqENFDMPQTDkRERERERERMZ1KuaowDFi1Cv70J3B1NTtNnfPII4+QnJxMVFQUAQEBeHh48NhjjwHg6urKlClTGDJkCPXq1XPI+I899hipqam88MILGIZR4TklJSUq5URERERERETEdCrlqmLHDoiPh3HjzE5SZz333HOcO3eOcf//Oyotx6xWK/Hx8bz77rs8/PDDDht//vz5pKam8v7771c4W85ms5Gamuqw8UVERERERERELocWeqiKVasgIgK6dDE7SZ322GOP4ebmhtVqLTNjzWazMXv2bLKyshw2tsViYcmSJYwYMQI3t4o753PnzjlsfBERERERERGRy6FS7nKVlEB0NNx3n9lJ6rTU1FSGDh1KcXFxhTPVcnNzWbBggUMzuLq68vHHHzNw4MAKi7m0tDSHji8iIiIiIiIicikq5S7Xxo2Qmgpjx5qdpM7Ky8vjtttuIykpieLi4grPKSkpYeHChRw7dsyhWdzd3fniiy+IjIws9w47R87UExERERERERG5HCrlLtfq1dC/P7RubXaSOqmkpIRRo0bxyy+/VFrIlbJYLDz11FMOz+Tn58fmzZtp0aJFmRlz2dnZlS4EISIiIiIiIiLiDCrlLofNBl9/DXfeaXaSOstisfC3v/2NYcOGYbFYcHd3r/Tc4uJioqOj2blzp8NzBQUF8f333xMUFGQv5qxWK7m5uQ4fW0RERERERESkMirlLsfu3XD2LAwbZnaSOsvV1ZU77riDDRs2kJCQwLx582jSpAkWiwVXV9cKz588ebJTZqy1aNGCTZs24eXlhYvLhb/yGRkZDh9XRERERERERKQyFkPP8V3avHnw7rtw6hRYLGanuWJYrVa+++47Xn31VTZu3Iibm1uZR1stFgsff/wxY8aMcViG4uJicnNzOX/+PP/3f//HvffeS1FREcuXL6dFixbl8mZnZ5e7hqenJ15eXmX2ubq64u/vD4Cvry/u7u7Ur18fDw8PvL29HXY/InXJalYzhjEY6J8RERERERGRqlIpdzn69oXOneGdd8xOcsU6cuQI77zzDsuWLSMnJweLxYLNZiMkJIS4uDg8PT0r/WxaWhopKSmcPXuWc+fOkZGRUWZLT0+3/56ZmUleXh6FhYVkZmaa9u44Pz8/3N3dCQgIwMfHh8DAwHJbgwYN7L83btyY4OBgGjduXOGKsSJ1kUo5ERERERGR6lMpdynp6dC48YWFHu65x+w0V7yCggLWrFnDW2+9xa5duwB48MEH6dOnD6dPnyYlJYWkpCTOnj1LQkICZ8+epbCwsMw16tevX6bQ+u3v9evXx8fHxz5zzd3dHV9fX7y9vfHw8CAgIID169fj4+PDyJEjy+ULDAwsty83N7fc4hWFhYXk5eUBkJOTQ1FREVlZWfb9OTk5FBcXk5mZyfnz5ystETMyMsrNHmzSpAmNGzemWbNmNGnShJCQEIKDg2ndujWhoaG0bt0aHx+fGv+3EKkplXIiIiIiIiLVp1LuUj7+GO6/H1JTISDA7DRXnLy8PGJjY4mNjeXIkSOcOHHCvp0+VXOmhQAAIABJREFUfRqbzQZceES0devW5cqopk2bEhwcbJ9FFhQUhKUWHiHOy8urM4+Z5ubmkpKSQkpKCsnJySQnJ9vLyTNnzpCYmEhSUhJpaWn2zzRq1IjWrVvbt7Zt2xIeHk5ERASNGjUy8W7kWqJSTkREREREpPpUyl3Kww/D3r2wY4fZSeq03Nxc9u/fT0xMDLGxsRw8eJDY2FhOnjyJYRi4u7vTpk2bMkVS6RYUFIS7u3u5d7xJWTk5OfZCMz4+nhMnTnDy5ElOnDhBXFyc/X14DRs2pGPHjnTs2JHw8HAiIyPp0qULwcHBJt+BXG1UyomIiIiIiFSfXl51Kf/3f3DDDWanqFOys7PZv38/u3fvtm+HDx/GarXi4eFB27ZtiYyM5P777ycyMpI2bdoQGRl50ffGyaX5+fnRuXNnOnfuXOHxjIwMYmJiOHjwIMePHycmJoYtW7YQHx+PYRgEBgYSERFBjx497FtEREStzDwUERERERERkarRTLmLKSy88Mjqe+/BuHFmpzHN0aNH+fHHH9m6dSs7duwgLi4OwzBo0qQJ1113XZmtdevWZseV38nIyGDPnj38+uuv9u3o0aPYbDaCgoLo27cvAwYM4IYbbqBnz57Uq1fP7MhyhdBMORERERERkepTKXcxu3ZBnz5w5Ai0b292Gqc5ePAgW7Zs4ccff+THH38kJSUFLy8vevfuzcCBA+nZsyfXXXcdzZo1MzuqVFNOTo69qNu2bRvbtm3jzJkzeHt706dPHwYMGMBNN91E//79VdJJpVTKiYiIiIiIVJ9KuYv55z/h6acvrMB6FT/il5+fz/bt2/nyyy9Zt24dJ0+exNfXlz59+tC/f39uuOEGBgwYgIeHh9lRxYGOHz/Otm3b2L59O9u2bePgwYN4e3vTr18/7rjjDu655x6990/KUCknIiIiIiJSfSrlLub++yE5GTZtMjtJrUtLS2PNmjWsXbuWH374gaKiIq677jpuu+02brvtNnr16oWrq6vZMcVE8fHxbNiwgQ0bNvDdd9+Rn59Pt27dGD58OGPHjiUiIsLsiGIylXIiIiIiIiLVp1LuYjp3huHDYcECs5PUiry8PNatW8eqVavYuHEj9erV4/bbb+e2225j2LBhNGnSxOyIUkfl5+fz/fffs2HDBtauXUtiYiLdunXjT3/6E2PHjtUMumuUSjkREREREZHqUylXGcMAX19YvPjCjLkr2K+//sqbb75JdHQ0BQUF3HLLLfzpT3/irrvuwtfX1+x4coWx2Wxs3bqVVatWER0dTVZWFgMHDuThhx/m7rvvxs1NizpfK1TKiYiIiIiIVJ+L2QHqrJQUyMuD0FCzk1RLSUkJa9asYcCAAfTo0YPdu3fzwgsvkJSUxIYNG/jzn/+sQk6qxcXFhZtuuol33nmHlJQU1q5dS0BAAGPHjqVNmza8+OKLpKWlmR1TREREREREpE5TKVeZ+PgLP6+wUq6kpISlS5fSpk0bxo4dS1BQEN9++y379+/nkUceoVGjRmZHlKuIu7s7d955J1988QVxcXGMGjWK559/nhYtWvDoo4+SmppqdkQRERERERGROkmlXGXi46FePQgJMTvJZVu3bh1dunTh0UcfZcSIEcTFxbF27Vpuvvlms6PJNSA0NJRXX32VhIQEXnrpJaKjo2nXrh3z588nLy/P7HgiIiIiIiIidYpKucrEx0OrVnAFrEB65Mj/Y+/Ow6qqF/2PfzbIIDI5M3kSATVznlLLHHI2M8shj1ZqFJWa9jvlcexkJ8shvXnO7agFDnUlp+uQBA5ZajndqyY5luGICiTKICLj/v3RhbMZVQQWG96vHh5hrbXX97P21sfHT9+1vr+qW7duGjJkiFq0aKFTp07pn//8p3ytbJYfKgdnZ2dNmDBBZ8+e1dtvv6158+apcePG2rBhg9HRAAAAAACoMCjlinL+vFXcuhoSEqK2bdvq9u3bOnjwoNauXSs/P79yGTs8PFyNGzcu9sH+N2/e1NKlS9WzZ0/VqlVL1atXV0BAgEaNGqXIyMi7jpGVlaVp06YpICBAjo6O6t+/f5HH/u///q/GjBkjX19fVa9eXbVq1VLz5s313HPPacmSJYqKipIktW7dWiaT6Z6/PvjggzzjXLx4UU8//bSSkpJK5RoLcy/v7dSpU7V27doi948dO1YODg7y9fXVpEmTdOfOnRJlKakaNWpo1qxZ+u2339S/f38NGzZMgYGBSklJKdccAAAAAABURJRyRbl6VfLxMTpFkZKTkzV06FC9+uqrmjBhgvbv36+OHTuWy9hRUVF6+umnNW3aNMXGxhZ77DvvvKOJEydq8ODBOnXqlOLj47V8+XIdO3ZM7dq10+bNm4t9fUhIiObOnasXX3xRMTExioiIKHBMdna23nnnHXXp0kX16tVTRESEEhISdPr0af3Hf/yHkpKS9MYbb8jf31+ZmZmSpPXr18tsNud+BQUFSZIiIiLybB8xYkSesY4dO6b27durT58+cnV1LZVrLOl7+8orr2jatGmaNWtWoftXrFih69eva+rUqfrHP/6hRYsW3XOO0lSvXj19/vnn2rx5s7Zs2aK2bduWuKwEAAAAAKCyoJQryq1bkouL0SkKdf36dfXs2VP79u3Tzp07NXfuXNnZ2ZXb+LNmzVKXLl105MgRudzDezRu3DhNmjRJHh4ecnJyUteuXRUaGqqsrCxNmTKl2Nfu3r1bkjR58mS5u7sXmefjjz/Wv/71L82fP19NmzaVg4OD6tevr969e2vbtm3FzrC7V0lJSRo0aJCee+45TZgwodSuMf+13Ot76+fnp02bNmnOnDlat25doce4uLgoKChITk5O2rNnzz3nKAuDBw9WZGSkvLy81K1bN+3du9fQPAAAAAAAGMlkNpvNRoeokNq2lfr1kz780Ogkedy+fVs9e/ZUXFycdu7cWW63qlpKTU1V9erVJUk+Pj6KiYnJnYF2P5ycnJSWlqbMzEyZTKZCj+nbt6927dpV5PnPnDmjRx55RG3atNHhw4eLHOvAgQPq0qWLMjIyCr0l9LXXXtOyZcsUERGhfv36FXqOmTNnat68ebp48aK87nEBkHu5RksleW+HDx+uAwcO6Pz580Xe7urt7S1PT89i36PykpaWplGjRmnHjh3au3evWrdubXQklNA6rdMIjZBZ/DUCAAAAAPeLmXJFSUmRatQwOkUBEyZM0G+//abt27cbUshJyi2NHkRKSopSU1PVvHnzYsuqrKysYs/z2WefKTs7W8OGDSv2uM6dO8tsNhf7jLbimM1mBQcH69FHH73nQu5er9FSSd7bIUOGKDo6Wt98802Rx5hMphIVp2XBwcFBoaGh6tixo5555pncZ/MBAAAAAFCVUMoVpQKWct99951WrFihkJAQBQQEGB3ngaxfv16SNGPGjAc6T84tkC1btnzgTMWJjIxUbGysWrVqdc+vKa1rvJucmWbbt28v03FKk729vb766iulpqYW+Uw8AAAAAAAqM0q5olTAUu7DDz9Unz59NHjwYKOjPJDY2FhNnTpVgYGBGj58eLHHpqeny8HBocj9V69elSTVrl27VDPmd+LECUl/3FJ6L+7nGh+Ut7e3pH9nLIyDg4MyMjLKNMf9qlu3rt577z199tlniouLMzoOAAAAAADlilKuKCkpkpOT0SlyxcfHa/fu3bmrhFqr+Ph49evXT927d9fSpUvvevylS5fuqQi719tDS+ratWuSJDc3t7see7/X+KBcXV1lMplyMxbGy8tLV65cqTC3sOZ46aWXZDKZir31FgAAAACAyohSrigZGVI5rmh6NydOnFBWVpYee+wxo6OUWEpKivr27atmzZpp9erVsrW1LfLYGzduaMGCBbp48aLeeOONIo/Leb7b9evXSz2vpTt37kjSXVe5vZ9rLE3VqlVTampqkfuDgoKUlJSkd999t8zfq/vh5OSkNm3a6NixY0ZHAQAAAACgXFHKWYnk5GRJf8yKskaZmZkaNmyYvL29tWrVqmLLqjFjxqh27dqaOnWqpkyZojfffLPIY7t16yZJ+vnnn0s9syVHR0dJKvYW0Pu5xtKWmZlZ7CIRo0eP1pw5c7RgwQLVrVu3yBVmjeDm5pb7+xsAAAAAgKqCUs5K1K9fX5J0+fJlg5OUTFBQkNLS0rRu3bo8K6D6+/vr4MGDeY5duXKlEhMTtWbNGi1atKjYW3aDgoJUrVo1bdiwodjxp0yZIhsbG505c6ZE+T09PSVJiYmJxWa512ssTUlJSTKbzbkZCzNjxgxNnz5dS5YsUUJCgrZt21Zmee7XpUuX5OHhYXQMAAAAAADKFaWclWjdurVcXV0VHh5udJT79t577+nkyZPasmVLsYs2WHJ1ddWwYcPUpk2bYgu3xo0b629/+5sOHz6s5cuXF3rML7/8omXLlmn48OFq2rRpia6hefPmkqTo6OhC95fkGkvLlStXJP07Y2E2btwoX19fBQYG3tNz8crLhQsXdOrUKT3xxBNGRwEAAAAAoFxVu/shqAjs7Ow0evRoLV68WK+99lru7ZQV3cqVKzV79mxJkouLy32/3tXVVUlJScUeM3PmTKWkpOi1117Tr7/+qnHjxqlhw4b6/ffftW3bNs2aNUstW7ZUSEhIia5Bklq1aqV69eopMjKywL6SXOPo0aO1evVqnTt3Tr6+viXOJSn3eWx9+vQp8pjk5GTVqVPngcYpC3PnztVDDz2kJ5980ugoAAAAAACUK2bKWZFp06bpxo0bmjFjhqE5wsLCZDKZZDKZdOXKFWVlZeX+HBwcnOfYu91Wejf3uqrqRx99pH379unq1avq1auXnJ2d9fDDDys4OFhTp07Vrl27VKNGjQKvW7lypUwmk5YtWyZJ6t+/v0wmk27dulUgR2BgoA4dOqSrV6/m2VeSa7x27ZqcnZ31pz/9Kc/2+3lvc2zatEne3t4aOHBgsWOW9Qq192vPnj36/PPP9f777991AQ0AAAAAACobk9lsNhsdokIymaS1a6Xhw41OkseXX36pl156SSEhIRo7dqzRccrcU089pfDwcGVnZxsdRYmJiXrkkUf01FNPaenSpSU+T0JCgry8vDRq1Ch9/vnnD5QpMjJSbdq0UWhoqJ5//vkij/Pw8JCvr68OHDjwQOOVlrNnz+qxxx5T165d9d///d9Gx0EJrdM6jdAImcVfIwAAAABwv5gpZ2VeeOEFTZ8+Xa+88soDFzrWwMfHR2azWbGxsUZHkZubm7Zu3aoNGzbo008/LdE5zGaz3nzzTbm6uurvf//7A+U5d+6cnn32WU2bNq3YQi4jI0M3btyQj4/PA41XWk6cOKHu3burUaNG+uKLL4yOAwAAAACAISjlrNAHH3ygOXPm6NVXX9WLL76olJQUoyOVmX79+kn649lj8fHxBqeR2rRpo8OHDysiIuKuz7orTGxsrM6dO6ddu3Y98Iqjy5Yt05w5czRnzpwij0lMTNSiRYuUkZGR+14aaf369eratasCAgK0ffv2Qm8pBgAAAACgKuD21aJU0NtXLW3atEmvvPKK6tatq9DQULVp08boSGVi/vz5Wrlypc6dO6cePXooIiLC6EhWYcyYMQoNDdVDDz2kkSNH6m9/+5tsbW0NyZKUlKTx48dr9erVmjhxohYsWCB7e3tDsqD0cPsqAAAAAJQcpVxRrKCUk6TLly/rxRdf1IEDBzRhwgRNnz5dtWrVMjoWIEnKzs7WqlWr9O677yorK0urVq1S7969jY6FUkIpBwAAAAAlx+2rVq5Bgwb69ttvtXDhQn355Zfy9/fX/PnzdefOHaOjoYoLDw9X69at9eqrr+qpp55SZGQkhRwAAAAAAP+HUq4SsLW11fjx4/Xbb79pwoQJev/99xUQEKB58+bpxo0bRsdDFZKZman169frscce08CBA+Xv768TJ05oyZIlqlu3rtHxAAAAAACoMCjlKhEXFxe9//77Onv2rIYPH66PPvpIDRo0UFBQkE6ePGl0PFRiN27c0Lx58+Tn56fnn39e9erV0759+7Rx40Y1adLE6HgAAAAAAFQ4lHKVkKenpxYuXKjo6GjNnz9fe/bsUYsWLfTEE09oyZIlun79utERUQmkp6dr69at+vOf/6wGDRroo48+0tChQ3X27Flt2rRJXbp0MToiAAAAAAAVFqVcJebs7Kzx48fr9OnTCg8Pl4+Pj95++215eXnpqaee0urVq3Xr1i2jY8KKZGdna8+ePQoKCpKnp6cGDx6s6OhoLVq0SNHR0Vq4cKEaNWpkdEwAAAAAACq8akYHQNkzmUzq16+f+vXrp9TUVH377bf68ssvNW7cONnY2Ojxxx9Xr169NGjQIDVr1szouKhgbt26pe+//15hYWEKCwvT1atX1axZM02cOFEvvPCC/Pz8jI4IAAAAAIDVMZnNZrPRISokk0lau1YaPtzoJGXm+vXr2rp1qyIiIrRjxw4lJiYqICBAAwcOVO/evfX444/L1dXV6JgoZ5mZmTp69Ki+++47hYeH68CBA5KkLl26aMCAAZS3yLVO6zRCI2QWf40AAAAAwP2ilCtKFSjlLGVmZmrfvn2KiIhQeHi4jh8/LltbW7Vs2VJdu3ZV165d9fjjj8vDw8PoqChlt2/f1qFDh7R37179+OOPOnjwoG7duqX69eurX79+GjBggPr06SN3d3ejo6KCoZQDAAAAgJKjlCtKFSvl8ouLi9OPP/6YW9QcO3ZMWVlZCggIUIcOHdS2bVu1bdtWbdq0oayxIhkZGTp+/LiOHj2qo0eP6siRI/rpp5+UkZGhhg0b5ilgmzZtKpPJZHRkVGCUcgAAAABQcpRyRanipVx+ycnJ2r9/v/bt26cjR47o6NGjiomJkclkUqNGjdS2bVu1a9dOzZo108MPPyxfX1/Z2toaHbtKi42N1alTp3TmzBn99NNPOnr0qI4fP6709HTVqFFDrVq1Urt27dSpUyc98cQT8vHxMToyrAylHAAAAACUHKVcUSjl7urKlSu5M66OHj2qY8eO6dKlS5IkBwcHNWnSRE2bNlXTpk3VrFkzBQQEyNfXVzVr1jQ4eeVx584dXbhwQVFRUTp16pR++eWX3CLu5s2bkiR3d3e1atUqd3Zj27Zt1aRJE0pTPDBKOQAAAAAoOUq5olDKlUhycrLOnDmj06dP6/Tp07klUVRUlDIzMyVJbm5uatiwoXx9ffP8+qc//UkeHh6qV6+ebGxsDL6SiiExMVFXr17VlStXdOHCBZ0/f14XLlzI/f7atWu5x3p7e+vhhx9W06ZN8/zq6elp4BWgMqOUAwAAAICSo5QrCqVcqUpPTy+0VMr5NS4uLvdYW1tb1atXT56envL09FT9+vXl7e2tevXqqXbt2qpZs6Zq1qypWrVq5X5vLbO+kpKSdOPGDd28eVM3b97UjRs3dOPGDcXGxiouLk5XrlxRbGysrl27ppiYGKWmpua+1tnZObfEzF9oNmrUiJVyUe4o5QAAAACg5KoZHQBVg729vRo3bqzGjRsXuv/27du6dOlSocVUdHS0/ud//kdxcXG6ceNG7ow7S25ubrkFnaOjo2rUqCFnZ2fZ2dmpZs2asrOzk7Ozs2rUqCF7e3tJkpOTkxwcHPKcx3K/JJnNZiUkJOQ5xnJbzvfp6elKSUnRrVu3lJGRoZs3b+ZuS05O1vXr15WYmKisrKxCs+fMEPTy8lKHDh3k4eEhT09P1atXT97e3vL09FTdunXv700HAAAAAAAVFqUcKgQnJ6fc58/dTXJycp7ZZjkzznK+v3PnjlJSUpSSkqL09HSdO3euQGkm/TFrLX9JVtg2V1fXAjPx3Nzccm+xdXd3l729fZ7Sr1GjRrK3t88tB5cuXSpfX1/9/e9/V+3atfPM8uNWXQAAAAAAqh5KOVgdFxcXubi46KGHHiqT82/fvl39+vVTYmJiqd0S2rdvX/Xo0UObNm3SZ599VirnBAAAAAAA1ospOkA+OTPlSvM5dR06dNCaNWu0fPlyffTRR6V2XgAAAAAAYJ0o5YB8yqKUk6SnnnpKn376qWbMmKFVq1aV6rkBAAAAAIB14fZVIJ+yKuUkKSgoSFFRUXrllVfk5eWl3r17l/oYAAAAAACg4qOUA/Ipy1JOkubNm6eYmBgNHTpUe/fuVatWrcpkHAAAAAAAUHFx+yqQT04pV1aroppMJgUHB6tjx44aMGCALl26VCbjAAAAAACAiotSDsgnKyurzGbJ5bC3t9d///d/q06dOhowYIBu3rxZpuMBAAAAAICKhVIOyKc8SjlJcnV1VXh4uJKSkjRkyBClpaWV+ZgAAAAAAKBioJQD8imvUk6SvL29FR4ersjISI0ZM0bZ2dnlMi4AAAAAADAWpRyQT3mWcpLUvHlzbdy4UZs2bdKMGTPKbVwAAAAAAGAcVl8F8invUk6SevTooRUrVmjUqFHy8vLSxIkTy3V8AAAAAABQvijlgHyysrLKbOXV4owcOVJRUVGaPHmyfHx8NGTIkHLPAAAAAAAAygelHJCPETPlcsycOVMxMTEaNWqUvv32W3Xp0sWQHAAAAAAAoGzxTDkgn+zsbMNKOUlavHix+vbtq8GDB+vXX381LAcAAAAAACg7lHJAPkbOlJMkW1tbhYaGKiAgQP3791dsbKxhWQAAAAAAQNmglAPyMbqUk6Tq1avr66+/lq2trZ566imlpKQYmgcAAAAAAJQuSjkgn4pQyklSnTp1FBERoUuXLmnEiBHKzMw0OhIAAAAAACgllHJAPhWllJMkPz8/bd26Vbt379Ybb7xhdBwAAAAAAFBKKOWAfCpSKSdJHTt21FdffaXly5dr7ty5RscBAAAAAAClgFIOyKeilXKSNGjQIH366aeaPn26vvjiC6PjAAAAAACAB1TN6ABARVMRSzlJCgoKUlRUlAIDA+Xp6anevXsbHQkAAAAAAJQQpRyQT0Ut5SRp3rx5iomJ0dChQ7V37161atXK6EgAAAAAAKAEuH0VyKcil3Imk0nBwcHq0KGDBgwYoEuXLhkdCQAAAAAAlAClHJBPRS7lJMne3l4bN25UnTp1NGDAAN28edPoSAAAAAAA4D5RygH5VPRSTpJcXV0VHh6upKQkDRkyRGlpaeUy7s2bN7V06VL17NlTtWrVUvXq1RUQEKBRo0YpMjKyXDIAAAAAAFAZUMoB+VhDKSdJ3t7eCg8PV2RkpMaMGSOz2VzmY77zzjuaOHGiBg8erFOnTik+Pl7Lly/XsWPH1K5dO23evLnMMwAAAAAAUBlQygH5WEspJ0nNmzfXxo0btWnTJs2YMaNcxhw3bpwmTZokDw8POTk5qWvXrgoNDVVWVpamTJlSLhkAAAAAALB2rL4K5GNNpZwk9ejRQytWrNCoUaPk6empiRMnltlYwcHBhW5v1aqVqlevrqioKJnNZplMpjLLAAAAAABAZUApB+RjbaWcJI0cOVJRUVF666235OPjoyFDhpTr+CkpKUpNTVXLli0p5AAAAAAAuAfcvgrkY42lnCTNnDlTr732mkaNGqX9+/ff8+vOnDmjZ555Rm5ubnJyclLHjh0VFhamXr16yWQyyWQyKTAwsNhzrF+/XpLK7RZaAAAAAACsHTPlgHystZSTpMWLFys6OlqDBw/Wvn371Lhx42KP/+2339S5c2fVqFFDGzZsUOfOnXXx4kVNnjxZP//8sxwcHHTnzp1izxEbG6upU6cqMDBQw4cPL83LAQAAAACg0mKmHJCPNZdytra2Cg0Nlb+/v/r376/Y2Nhij58+fboSEhK0ePFi9e7dW87OznrkkUcUGhqqlJSUu44XHx+vfv36qXv37lq6dGlpXQYAAAAAAJUepRyQjzWXcpLk5OSkrVu3ytbWVoMGDSq2XNu2bZskqW/fvnm2161bV02bNi12nJSUFPXt21fNmjXT6tWrrfo9AwAAAACgvFHKAflYeyknSXXq1FFERIQuXryoESNGKDMzs8AxaWlpSk5OlqOjo5ydnQvsr1mzZpHnz8zM1LBhw+Tt7a1Vq1ZZ/fsFAAAAAEB5o5QD8qkMpZwk+fn5aevWrdq9e7fGjx9fYL+Dg4NcXFx0584d3bp1q8D+uLi4Is8dFBSktLQ0rVu3TtWq/fvRlP7+/jp48GDpXAAAAAAAAJUYpRyQT2Up5SSpY8eO+uqrrxQSEqK5c+cW2N+/f39J/76NNUdMTIx+/fXXQs/53nvv6eTJk9qyZYscHBxKPzQAAAAAAFUAq68C+VSmUk6SBg0apE8//VSvv/66vLy89OKLL+bu+/DDD/Xtt99q8uTJcnNzU+fOnXXhwgW988478vDwUExMTJ5zrVy5UrNnz5Ykubi4lOt1AAAAAABQmTBTDsinspVy0h+3m/7lL39RYGCgdu7cmbvdz89PBw4cUIcOHTR06FDVr19fQUFBmjZtmvz9/QucZ8OGDeUZGwAAAACASouZckA+lbGUk6T58+crNjZWQ4cO1d69e9WqVStJUuPGjbVp06Z7OkdYWFhZRgQAAAAAoMpgphyQT2Ut5Uwmk4KDg9WhQwcNGDBAly5dMjoSAAAAAABVFqUckE9lLeUkyd7eXhs3blSdOnU0YMAAJSQkGB0JAAAAAIAqiVIOyCc7O1s2NpX3j4arq6vCw8OVlJSkIUOGKC0tLc/+NWvWyGQyadeuXUpLS5PJZFJgYKBBaQEAAAAAqJwqb/MAlFBlnimXw9vbW+Hh4Tp27JjGjBkjs9mcu+/555+X2WzO8xUcHGxgWgAAAAAAKh9KOSCfqlDKSVLz5s21ceNGbdy4UTNmzDA6DgAAAAAAVQqrrwL5VJVSTpJ69OihFStWaPTo0fL09NTEiRONjgQAAAAAQJVAKQfkU5VKOUn685//rKioKL311lvy8fHRkCFDjI4EAAAAAEClRykH5FPVSjlJmjVrlmJjYzVq1Cjt2rVLnTt3NjoSAAAAAAAPgYVhAAAgAElEQVSVGs+UA/KpiqWcJC1evFh9+vTR008/rV9//dXoOAAAAAAAVGqUckA+VbWUs7W1VWhoqPz9/dW/f3/FxsYaHQkAAAAAgEqLUg7Ip6qWcpLk5OSkrVu3ytbWVoMGDVJKSorRkQAAAAAAqJQo5YB8qnIpJ0l16tRRRESELl68qBEjRigzM9PoSAAAAAAAVDqUckA+Vb2UkyQ/Pz9t3bpV33//vcaPH290HAAAAAAAKh1KOSAfSrk/dOzYUWvWrFFISIjmzZtndBwAAAAAACoVSjkgH0q5fxs0aJD+8z//U9OmTdMXX3xR5HEZGRnlmAoAAAAAAOtXzegAQEVDKZfXa6+9pqioKAUGBsrT01O9e/fO3Wc2mzVz5kzZ2dnpvffeMy4kAAAAAABWhplyQD6UcgXNnz9fzz//vIYOHarIyEhJUnp6ul544QV9+OGHWrJkCQtCAAAAAABwHyjlgHwo5QoymUwKDg5Whw4dNGDAAJ06dUp9+/bV2rVrJUm///67wsLCDE4JAAAAAID1oJQD8qGUK5y9vb3Wr18vLy8vDRo0SPv27cudHWdjY6NPP/3U4IQAAAAAAFgPSjkgH0q5ol29elVXrlzR5cuX8yzukJWVpV27dum3334zMB0AAAAAANaDUg7Ih1KucN9//706deqk33//vdDVVu3s7BQSEmJAMgAAAAAArA+lHJAPpVxBoaGh6tu3r1JTU4tc0CE9PV3Lli1TWlpaOacDAAAAAMD6UMoB+VDK5ZWenq6dO3cqMzNTJpOp2GMTEhK0cePGckoGAAAAAID1opQD8snOzqaUs2Bvb68VK1bo8OHD6tSpk6Q/FnYoDAs+AAAAAABwbyjlAAvZ2dkym82UcoVo27atfvjhB+3cuVP+/v6FFnNZWVnat2+fTp48aUBCAAAAAACsB6UcYCErK0uSKOWK0atXL504cUJLlixRzZo1Va1atTz77e3t9fnnnxuUDgAAAAAA60ApB1iglLs3dnZ2evXVVxUVFaW//OUvsrOzk52dnaQ/nkEXEhKi27dvG5wSAAAAAICKq9rdDwGqDkq5+1OzZk3NnTtXgYGBeuedd7R582bZ2trq1q1bWrt2rcaOHVvs69PT05WUlKSkpCQlJCQoIyNDycnJufvT0tLylHt2dnZydnbO/dnR0VHVq1eXs7OzXF1d5erqqho1apT+hQIAAAAAUMoo5QALlHIl4+/vr02bNumHH37QhAkT9PPPP2vOnDkym826evWq4uLidO3aNcXExCguLk4JCQlKSkrSnTt3Sj2Lra2tXF1dVbNmTdWpU0f169dX/fr15eXlpbp168rb21teXl7y8/NTnTp1Sn18AAAAAADuBaUcYIFS7t5kZmbqt99+0/Hjx3X69GlFRUXp3LlzioqK0rVr1yRJUVFRmjBhgnx8fFS/fn15eHioTZs2qlevntzd3XNntrm4uMjd3V1ubm6ysbFRzZo1c8epVq2aXFxccn++c+eOUlNTc39OSUlRenq6kpOTc2fc5Xx/8+ZN/f7774qNjdWFCxd04MABxcbG6vr167mvd3V1lZ+fnxo1aiQ/Pz8FBASoZcuWeuSRR5hxBwAAAAAoU5RygIWcUq6wlUWrqtTUVB05ckSHDh3S8ePHdfz4cZ06dUp37tyRra1tbqHVqlUrDRkyJLfk8vDwUGxsrJo3b15qWRwdHeXo6Jj7s2WBd6/S09MVHR2dWyLm/Lpz5059+umnSklJkY2NjXx9fdWyZUs1b95c7du3V+fOnVW3bt1SuxYAAAAAQNVGKQdYYKacFBMToz179ujAgQM6ePCgjh49qoyMDHl4eKhly5bq2bOn3nzzTbVo0ULNmjXLU5LlVxFLLHt7ezVq1EiNGjVSr1698uzLzs7WuXPndPz4cZ04cULHjx/XunXr9MEHH8hsNisgIECdOnVS586d9fjjj6tFixYGXQUAAAAAwNpRygEWsrOzJVWtUi4zM1MHDx5UWFiYvv32Wx09elQ2NjZq0qSJHn/8cb3xxhtq166dmjVrJpPJZHTcMmVjYyN/f3/5+/tryJAhuduTk5MVGRmpffv26ccff9TMmTN148YN1atXT926dVOvXr00cOBAeXt7G5geAAAAAGBNTGaz2Wx0iArJZJLWrpWGDzc6CcpRdHS0GjRooP3796tz585GxykzSUlJ+vrrr7V+/Xrt3LlTqampevjhh9WnTx/16dNH3bp145lqxcjKytJPP/2kHTt2aMeOHdq/f78yMzPVrl07DRs2TMOGDZOvr6/RMcvcOq3TCI2QWfw1AgAAAAD3i5lygIXKfPtqamqqNm3apHXr1mn79u3Kzs5W79699c9//lN9+vRRgwYNjI5oNWxtbdW+fXu1b99e06dP161bt/T9999r69atWrBggf7617+qffv2Gj58uEaOHCkfHx+jIwMAAAAAKhieZg9YqIyl3C+//KKpU6fqT3/6k1588UVdv35dc+fOVXR0tMLCwvTyyy9TyD0gZ2dnDRo0SJ999pliYmL0ww8/qEuXLlq4cKEeeugh9e7dW+vXr1dmZqbRUQEAAAAAFQSlHGChspRyZrNZmzdv1hNPPKGmTZtqw4YNevvtt3X16lX9+OOPmjRpUoVchKEysLW11eOPP67Fixfr0qVL+uqrr5Sdna0RI0bI399f8+fPV3JystExAQAAAAAGo5QDLFh7KZedna0NGzaodevWeu6551S7dm3t2LFDv/76q/7617+qXr16RkesUuzt7TV8+HDt2rVLZ86c0XPPPacPPvhAvr6+mjNnjpKSkoyOCAAAAAAwCKUcYMGaS7mdO3eqZcuWGjFihJo2bapjx45p06ZN6t27t2xs+KNutMaNG2vhwoW6cOGCxo8fr48//lgNGzbUggULlJGRYXQ8AAAAAEA541/qgAVrLOWio6M1fPhw9enTR40bN9bx48e1du1atWjRwuhoKEStWrU0e/ZsnT9/XhMnTtTf/vY3tW7dWrt37zY6GgAAAACgHFHKARasrZT77LPP9PDDD+unn35SeHi4Nm7cqGbNmhkdC/fA3d1ds2fP1smTJ+Xn56eePXtq7NixSklJMToaAAAAAKAcUMoBFqyllEtJSdELL7yg119/XW+++aaOHz+u/v37Gx0LJeDr66uvv/5amzdv1jfffKOOHTvq9OnTRscCAAAAAJQxSjnAgjWUcpcuXdKjjz6qbdu2KTw8XHPmzJGjo6PRsfCAnn76aR09elTu7u7q2LGjNm/ebHQkAAAAAEAZopQDLFT0Uu7SpUvq0aOHbG1tdfToUfXt27dMxjl27JgGDhwod3d3ubi4qFevXtq3b99dX5eVlaVp06YpICBAjo6OBWbvOTs7y2Qy5fn6+OOP8xzj4+NT4JiZM2cWGOvixYt6+umnc1cwvXnzppYuXaqePXuqVq1aql69ugICAjRq1ChFRkYWeP3UqVO1du3aIq9l7NixcnBwkK+vryZNmqQ7d+7c9foflI+Pj3bv3q1Ro0Zp+PDh2rhxY5mPCQAAAAAwBqUcYKEil3JXrlxRjx495OzsrF27dqlBgwZlMs6hQ4fUpUsXubi46PTp0zp//rwaNWqk7t27a8eOHcW+NiQkRHPnztWLL76omJgYRURE5Nl/69Yt/fTTT5KkwYMHy2w26+23385zTHR0tM6fPy9Jeuyxx2Q2m/XBBx/kOebYsWNq3769+vTpI1dXV0nSO++8o4kTJ2rw4ME6deqU4uPjtXz5ch07dkzt2rUrMPPslVde0bRp0zRr1qxCr2XFihW6fv26pk6dqn/84x9atGjRXd650mFnZ6clS5YoKChIzz//vLZs2VIu4wIAAAAAyhelHGChopZy2dnZGj16tBwcHLRr1y7VqVOnzMZ5+eWX5e7urhUrVsjT01N16tTRkiVL5Ofnp8DAQKWlpRX5+pwVRCdPnix3d/cyyZiUlKRBgwbpueee04QJE/LsGzdunCZNmiQPDw85OTmpa9euCg0NVVZWlqZMmZLnWD8/P23atElz5szRunXrCh3LxcVFQUFBcnJy0p49e8rkegpjMpn0j3/8Q+PGjdOLL76YW1ICAAAAACoPSjnAQkUt5RYuXKgDBw7oq6++KrNCTpL27t2rkydPaujQoapevXrudltbW40cOVKXL19WWFhYka+Pj4+Xra2tXFxcyizj/PnzFRMTo3fffTfP9uDgYC1btqzA8a1atVL16tUVFRUls9lcYN/QoUP1l7/8RZmZmUWO6e7urvj4+NK5gHtkMpm0ePFi+fr66oUXXsj9vQkAAAAAqBwo5QALFbGUi46O1qxZszR79my1atWqTMf67rvvJEnt27cvsC9n265du4p8fVkXR2azWcHBwXr00Ufl5eV1T69JSUlRamqqmjdvLpPJVGD/kCFDFB0drW+++abIc5hMpmJLu7Li4OCg//qv/9Lhw4cVEhJS7uMDAAAAAMoOpRxgoSKWcp988onq16+vt956q8zHOnPmjKQ/FhzIz9vbW5L066+/lnmOokRGRio2Nva+ysn169dLkmbMmFHo/tatW0uStm/f/uABy0Dz5s01duxYzZ8/v8BMPwAAAACA9aKUAyxUtFLObDbrq6++0tixY2Vvb1/m4yUkJEiSatSoUWCfs7OzpD9WOS1Kenq6HBwc7mmsLVu2FFhlNefL19e30NecOHFCUuGlYWFiY2M1depUBQYGavjw4YUek1M25py7MA4ODsrIyLinMcvCa6+9pqioKB06dMiwDAAAAACA0kUpB1ioaKXcuXPndPXqVfXt29foKLmztAq7BTTHpUuX7rkwy1l9tbCvohY2uHbtmiTJzc3truePj49Xv3791L17dy1durTI41xdXWUymXLPXRgvLy9duXLFkFtYpT+efefp6akffvjBkPEBAAAAAKWPUg6wUBFLOUl6+OGHy2W8nBVTU1JSCuzL2VbYqqo3btzQggULdPHiRb3xxhtllu/OnTuSJDs7u2KPS0lJUd++fdWsWTOtXr36rp9ntWrVlJqaWuT+oKAgJSUl6d1339X169fvP3gpePjhhxUVFWXI2AAAAACA0kcpB1jIKeVsbCrGH43bt29LUp6VUMtS06ZNJf2xuER+V65ckSQ1btw4z/YxY8aodu3amjp1qqZMmaI333yzzPI5OjpKUrG3kmZmZmrYsGHy9vbWqlWr7qlgzczMLPY9Hj16tObMmaMFCxaobt266tev3/2Hf0A1atTI/f0AAAAAALB+FaN5ACqIrKws2djYFHuLZnmqVauWpD9uxSwPPXr0kCQdOXKkwL6cbU8++WSe7StXrlRiYqLWrFmjRYsWKSgoqMzyeXp6SpISExOLPCYoKEhpaWlat26dqlWrlrvd399fBw8eLHB8UlKSzGZz7rkLM2PGDE2fPl1LlixRQkKCtm3b9gBXUTK///67ateuXe7j3o1JFePPCgAAAABYG0o5wEJWVlaFuXVVkh555BGZTCYdPny4XMbr1q2bmjVrpg0bNuTeKir98b6sWbNGDRo00MCBAwu8ztXVVcOGDVObNm20YcOGMsvXvHlzSYXP5JOk9957TydPntSWLVvuecGJnBmAOecuzMaNG+Xr66vAwMB7ep5daUtPT9fx48fVokWLch+7OKlKlaMcjY4BAAAAAFaJUg6wUNFKuVq1aqlDhw7auHFjuYxnY2OjkJAQ3bhxQ2PHjlVMTIzi4+M1fvx4nT17Vp9//nnuLaSFcXV1VVJSUpnla9WqlerVq6fIyMgC+1auXKnZs2fr0KFDcnFxKbCia1HPYzt27JgkqU+fPkWOm5ycLFdX19K5iBIIDw9XampqsRmNkKIU1VDBlXoBAAAAAHdHKQdYqGilnCS9/PLLWrNmTZGzw0pbp06dtH//fiUmJqpJkyZq2LChzp49q927d991Fdi73fbr7OysNm3aSJK2bNkik8mkjz/+OM8xPj4+8vX1lSTt27dPJpNJM2fOzD1/YGCgDh06pKtXr+Z5XUln6G3atEne3t6FzgC0ZOQtzYsWLVLfvn3veWXb8kIpBwAAAAAlV+3uhwBVR0Us5V566SXNnz9fr7/+ur7++utyKYfatGmj8PDw+36dg4ODsrOzi9x/69atu57jbuXjlClTtGrVKr3//vtaunRp7vawsLB7D/p/IiMjtWHDBoWGhha7omtmZmaxMwTLUkhIiPbt26f9+/cbMn5xKOUAAAAAoOSYKQdYqIilnIODg7788ktFRETos88+MzpOsXx8fGQ2mxUbG1tmY7i5uWnr1q3asGGDPv300xKf59y5c3r22Wc1bdo0Pf/880Uel5GRoRs3bhgyS+3cuXN666239Ne//lWPPvpouY9/N7d1m1IOAAAAAEqIUg6wUBFLOUnq3Lmzpk+frsmTJ2v79u1GxylSv379JElz584t0xVj27Rpo8OHDysiIqLEz7BbtmyZ5syZozlz5hR5TGJiohYtWqSMjIzcaysvsbGxGjRokAICAvTee++V69j36pZuUcoBAAAAQAlRygEWKmopJ0mzZ8/WSy+9pMGDB+ubb74xOk6hnnnmGc2bN0/bt2+Xt7e3+vfvX2ZjNWzYUGFhYSVegGHevHnFzpAbM2aM6tatq+DgYM2aNUtjxowpYdL7FxcXp169eikjI0Nbt26Vvb19uY19P6IVLW95Gx0DAAAAAKwSz5QDLGRlZcnGpmJ21SaTSf/617+UmpqqoUOH6l//+pfGjh1rdKwCpkyZoilTphgd44GtXLlSK1euLPdxjx8/rqFDh8psNmv37t3y8vIq9wz36oIu6Gk9bXQMAAAAALBKFbN9AAySnZ1dYWfKSZKNjY2WL1+uSZMm6eWXX9bLL7+s1NRUo2OhlKxcuVKdOnVS/fr1tWfPngpdyEnSJV3SQ3rI6BgAAAAAYJUo5QALFfn21Ry2traaO3eutmzZos2bN6tDhw764YcfjI6FB3Dt2jWNHDlS48aN04QJE/Tdd9/J09PT6FjFSlCCEpVIKQcAAAAAJUQpB1iwhlIux6BBg3TkyBE1aNBA3bp100svvVSmq56i9GVmZuqTTz5R06ZNdejQIYWHh2vevHmqVq3iP1ngoi5KEqUcAAAAAJQQpRxgwZpKOemPxQ4iIiK0YcMG7d69W02bNtXs2bN18+ZNo6OhGNnZ2VqzZo1atWqlqVOnatKkSTp58mS5r/D6IM7pnGxkoz/pT0ZHAQAAAACrRCkHWLC2Ui7Hs88+q1OnTumtt97S4sWL5evrq1mzZik+Pt7oaLCQmZmpL7/8Uo888ohGjx6t1q1b68SJE3r//fdVvXp1o+Pdl6M6qiZqouqyrtwAAAAAUFFQygEWrLWUk6QaNWro3Xff1aVLlzR79mwFBwfLx8dHw4cP17fffmt0vCotJiZG8+bNU0BAgMaMGaMWLVroxIkTWr16tfz9/Y2OVyKHdVjt1M7oGAAAAABgtSjlAAvWXMrlcHZ21qRJk3T27FktXLhQv/zyi3r37q22bdtq6dKlzJ4rJxkZGQoPD9ezzz6rBg0aaOHChRo2bJjOnj2rdevWqWnTpkZHfCBHdZRSDgAAAAAeAKUcYKEylHI5nJ2d9cYbbygyMlL79+9Xy5Yt9f/+3/+Th4eH+vXrp5CQEAq6UpaRkaFt27bp5ZdfloeHh5566inFx8dr1apVunz5subPn69GjRoZHfOBXdIlxSmOUg4AAAAAHgClHGChMpVyljp37qyVK1cqLi5OX3zxhZycnDRx4kR5enqqd+/eWrBggSIjI2U2m42OanWuXbumVatWadSoUfLw8NCAAQN08uRJTZ8+XefPn9eePXv05z//WQ4ODkZHLTVHdEQ2slFrtTY6CgAAAABYrWpGBwAqkspayuVwdnbWyJEjNXLkSCUnJyssLExhYWFasGCBpkyZIg8PD/Xu3VtPPvmkOnfurMaNGxsducL5/fffdfDgQe3Zs0c7duzQ8ePH5ejoqMcff1wzZszQc889p4ceesjomGXqoA6qqZrKRS5GRwEAAAAAq0UpB1io7KWcJRcXl9yCLjs7W8eOHdP27du1Y8cOBQUFKS0tTXXq1FGnTp3UqVMnde7cWa1bt1atWrWMjl5u0tLSdPLkSR06dEgHDx7UgQMHdPbsWZlMJjVr1kx9+vTR/Pnz9cQTT8jJycnouOVmp3aql3oZHQMAAAAArJrJzP1qhTOZpLVrpeHDjU6CcjRx4kRFRkZq7969RkcxVHp6uo4ePZpbRB04cECXL1+WJHl7e6tFixZq2bKlWrRooWbNmsnPz09ubm4Gpy659PR0XbhwQWfOnNHx48f1888/6/jx4zp79qwyMzPl6uqqjh07qnPnzrklZVUqJy1d13XVV31t0RY9paeMjgMAAAAAVouZcoCFqjRTrjj29va55dPkyZMl/fHstJ9//jm3sNqxY4c++eQTpaenS5Jq166tRo0ayc/PT40aNVLDhg3l4eEhDw8PeXl5qV69erKzszPkeuLi4hQXF6dr164pJiZGly9fVlRUlM6dO6dz584pOjpa2dnZMplMatiwoVq0aKFnn31WLVu2VMuWLdW4cWPZ2PAITknaru2yla2e0BNGRwEAAAAAq0YpB1iglCuap6enPD091bdv39xtGRkZOnfuXJ6C69y5c/r666918eJFJScn5zlHvXr1VK9ePbm5ucnV1VWurq5yc3PL/dnOzk7Vq1eXo6Nj7mtq1qyZ+/2tW7eUkZEh6Y/PKikpSZJ08+ZNJScnKykpSUlJSUpOTlZCQkJuGZfzGklycHCQt7e3GjVqpMaNG6tfv365ZaK/v79cXV3L5P2rLHZqp7qoi1zF+wQAAAAAD4JSDrBAKXd/7Ozs1KRJEzVp0qTQ/bdv386dnRYbG6urV68qLi5OiYmJueXZuXPnlJCQoKSkJGVmZuYp3rKzs5WYmJh7vpzCLjs7WxkZGfLw8JCkPCWfq6urvL295ebmllsCenl5qX79+vLw8Kiyt52WBrPM2qmdekNvGB0FAAAAAKwepRxggVKudDk5OcnPz09+fn6let49e/aoe/fu2rt3r7y9vUv13Cja/+h/dFVXNUADjI4CAAAAAFaPhyQBFijlrEPbtm1lY2OjI0eOGB2lSvlKX6mJmqiN2hgdBQAAAACsHqUcYIFSzjq4uLjI39+fUq4cZStbG7RBz+t5o6MAAAAAQKVAKQdYoJSzHu3bt9fhw4eNjlFl7NZuXdEVDddwo6MAAAAAQKVAKQdYoJSzHu3atWOmXDn6Sl+pjdqomZoZHQUAAAAAKgVKOcACpZz1aNeunWJjY3XlyhWjo1R6aUrTRm3UCI0wOgoAAAAAVBqUcoAFSjnr0aZNGxZ7KCfrtE5JStJojTY6CgAAAABUGpRygAVKOevh6urKYg/lZImWaIiGyFveRkcBAAAAgEqjmtEBgIqEUs668Fy5shepSB3QAX2n74yOAgAAAACVCjPlAAuUctalXbt2rMBaxj7Vp2qqpuqu7kZHAQAAAIBKhVIOsEApZ13at2/PYg9lKFGJClWoXtfrMslkdBwAAAAAqFQo5QALlHLWhcUeytZn+kwmmfSiXjQ6CgAAAABUOpRygAVKOevCYg9l547u6BN9otf1utzlbnQcAAAAAKh0KOUAC9nZ2bKx4Y+FNWGxh7IRohDd0A1N1mSjowAAAABApUT7AFhgppz1YbGH0pehDH2sj/WyXpaXvIyOAwAAAACVEqUcYIFSzvqw2EPpW63VuqIreltvGx0FAAAAACotSjnAAqWc9WGxh9KVqUx9pI80SqPUUA2NjgMAAAAAlRalHGCBUs76sNhD6QpWsM7rvGZohtFRAAAAAKBSo5QDLFDKWScWeygdKUrR+3pfr+t1+cvf6DgAAAAAUKlRygEWKOWsE4s9lI5FWqRbuqXpmm50FAAAAACo9CjlAAuUctaJxR4e3O/6XR/rY03RFNVXfaPjAAAAAEClRykHWKCUs04s9vDg/q6/q4Zq6C29ZXQUAAAAAKgSKOUAC5Ry1onFHh7Mz/pZS7RE7+t91VANo+MAAAAAQJVAKQdYoJSzXiz2UDJmmfWm3lQbtdE4jTM6DgAAAABUGZRyZeTYsWMaOHCg3N3d5eLiol69emnfvn1Gx8JdlEYpFx4ersaNG6tatWqllAr3ojQWe7h586aWLl2qnj17qlatWqpevboCAgI0atQoRUZGllLSimWVVukH/aD/1H/Khr8SAAAAAKDc8C+wMnDo0CF16dJFLi4uOn36tM6fP69GjRqpe/fu2rFjh9HxUIwHKeWioqL09NNPa9q0aYqNjS3lZLibdu3aPfBiD++8844mTpyowYMH69SpU4qPj9fy5ct17NgxtWvXTps3by7FxMZLVKKma7re0BvqqI5GxwEAAACAKoVSrpRlZ2fr5Zdflru7u1asWCFPT0/VqVNHS5YskZ+fnwIDA5WWlmZ0TBThQUq5WbNmqUuXLjpy5IhcXFxKORnupm3btqWy2MO4ceM0adIkeXh4yMnJSV27dlVoaKiysrI0ZcqUUkpbMUzXdGUrW3/X342OAgAAAABVDqVcKdu7d69OnjypoUOHqnr16rnbbW1tNXLkSF2+fFlhYWEGJkRxHqSUCwkJ0dSpU7lt1SClsdhDcHCwli1bVmB7q1atVL16dUVFRclsNj9IzArjR/2opVqqj/Wx3OVudBwAAAAAqHIo5UrZd999J0lq3759gX0523bt2lWumXDvHqSUsyxhYYyyWuwhJSVFqampat68uUwmU6mfv7zd1m2N0zj1V3+N1mij4wAAAABAlUQpdw/OnDmjZ555Rm5ubnJyclLHjh0VFhamXr16yWQyyWQyKTAwMPdYSfLx8SlwHm9vb0nSr7/+Wn7hcV8sS7n7+dxRMRS22ENpfI7r16+XJM2YMaPMspenmZqpOMVpqZYaHQUAAAAAqizus7uL3377TTiSagwAACAASURBVJ07d1aNGjW0YcMGde7cWRcvXtTkyZP1888/y8HBQXfu3Mk9PiEhQZJUo0aNAudydnaW9McKj6iYckq5+/3cUTFYLvbg7e1dKp9jbGyspk6dqsDAQA0fPrycrqTsHNRB/UP/ULCC5aOC//MAAAAAAFA+mCl3F9OnT1dCQoIWL16s3r17y9nZWY888ohCQ0OVkpJyX+fKeRZVZbj9rbLKKeVK83NH+cm/2MODfo7x8fHq16+funfvrqVLrX9WWapSNUZj1Ed9NEZjjI4DAAAAAFUapdxdbNu2TZLUt2/fPNvr1q2rpk2bFjje3f2PB6YX9g/+nG05x6DiySnl7vdzR8WQf7GHB/kcU1JS1LdvXzVr1kyrV68u8bMGK5J39I5iFatlKriYBQAAAACgfHH7ajHSMjKUnJwsR0fH3FtPLdWsWbPAtpx/6EdHRxfYd+XKFUlS48aNSzkpSoPZbJbZbFZ2dvZ9f+6oOHIWe0hLSyvx55iZmalhw4bJ29tbq1atqhSFXIQi9C/9S6u1Wg3UwOg4AAAAAFDlMVOuGA52dnJxcdGdO3d069atAvvj4uIKbOvRo4ckFboCZM62J598spSTojRkZWVJkhwdHe/7c0fFkbPYg4ODQ4k/x6CgIKWlpWndunWqVu3f/+/C399fBw8eLJPcZSlWsRr7f/+N1Eij4wAAAAAARCl3V/3795f079vgcsTExBS6imq3bt3UrFkzbdiwIc8D5LOysrRmzRo1aNBAAwcOLNvQKJGcUs7W1va+P3dUHJaLPZTkc3zvvfd08uRJbdmyRQ4ODmWet6xlK1ujNVrOctYn+sToOAAAAACA/0MpdxcffvihatWqpcmTJ2vnzp26deuWTpw4obFjx8rDw6PA8TY2NgoJCdGNGzc0duxYxcTEKD4+XuPHj9fZs2f1+eefy9HR0YArwd1YlnL3+7mj4rBc7OF+P8eVK1dq9uzZOnTokFxcXGQymfJ8RUVFGXBFD2aBFmiv9mqN1shFLkbHAQAAAAD8H0q5u/Dz89OBAwfUoUMHDR06VPXr11dQUJCmTZsmf3//Ql/TqVMn7d+/X4mJiWrSpIkaNmyos2fPavfu3QUeOI+Kw7KUK8nnHhYWllveXLlyRVlZWbk/BwcHl+elVGmWiz3c7+e4YcMGAxKXnb3aq5maqTmao/Zqb3QcAAAAAIAFFnq4B43/P3t3HldVmfhx/HMBZVEgNhOEzAA1QAz3BUdTxrXUMtTSSk2zzbE9rWzMaXOWLJt+qZVLZWmaWxqVYe67BQpuCe6IJoIost/z+0NkIhZXOCzf97zuCz333PN87wV8vfrO85yncWMWL158Va8JCwvju+++K6dEUh7+WMrB1X/f77rrLgzDKJdscnUubfYAV/d9XL58eXnGqlAnOcn93E9vevMcz5kdR0RERERERP5EM+VECvy5lJOq69JmDzVVHnkMZCBOOPEZn2HBYnYkERERERER+ROVciIFVMpVH3/c7KEmGsc4trKVr/kaV1zNjiMiIiIiIiIlUCl3DebNm4fFYiE6Oprs7GwsFgsjR440O5Zcp0ulnI1Nyb8W+r5XHX/c7OHPqvv3cQELeJd3mcEMwggzO46IiIiIiIiUwmLoJlgls1hg/nwYONDsJFJBjh07hp+fHxs2bKBDhw5mx5Hr1KRJEwYPHszrr79udpQK8wu/0IlOjGAEH/CB2XFERERERESkDJopJ1JAy1erlz9u9lATJJNMf/rTgQ5MYYrZcUREREREROQyVMqJFLBarYBKueqiJm32kEUW93APtajFV3yFnTbWFhERERERqfRUyokU0Ey56qWmbPZgYDCKUexlL9/xHZ54mh1JREREREREroBKOZECKuWql7I2e6hOJjGJeQX/a0ITs+OIiIiIiIjIFVIpJ1JApVz14uLiQkBAQLUu5b7kS17ndd7jPXrQw+w4IiIiIiIichVUyokUUClX/VTnzR5+5meGM5zxjOdJnjQ7joiIiIiIiFwllXIiBVTKVT/VdbOHOOK4t+B/b/CG2XFERERERETkGqiUEymgUq76ubTZQ1JSktlRbpiDHKQnPQkjjDnMwYLF7EgiIiIiIiJyDVTKiRRQKVf9XNrsobrMljvOcSKIoB71WMxialPb7EgiIiIiIiJyjVTKiRRQKVf9/Hmzh4SEBL7++mteeuklli1bZnK6q3Oa03SnO3bYEUUUrriaHUlERERERESug53ZAUQqC5Vy1cvBgwfZsWMHnp6ezJs3jylTpnDu3DksFguGYbBw4UKzI16xs5ylJz05z3nWsY6budnsSCIiIiIiInKdVMqJFFApV/Xt2LGDl156iW3btpGeno7FYqF27dpkZ2cXnmMYBgABAQFmxSxROum44FLs+AUucDd3k0wy61jHLdxiQjoRERERERG50bR8VaSASrmqLyQkhISEBM6dOwdcLOD+WMhdYrFY8Pf3r+h4pdrIRjrQgRRSihzPIYcBDGAve/mRH2lEI5MSioiIiIiIyI2mUk6kgEq5qs/e3p7p06cXzoYrjZubG3Xr1q2gVJc3nvHEE08EEaSTDkAuudzHfWxiE9/zPUEEmZxSREREREREbiSVciIFVMpVD927d6dXr17UqlWr1HMCAwMrMFHZ1rGOtawFIJ54/spfOcc5HuZhoolmOctpQQuTU4qIiIiIiMiNplJOpIBKuerjgw8+KPU5W1tbbr/99gpMU7aXeAm7gtt75pLLr/xKe9qzmMUsZznhhJucUERERERERMqDSjmRAirlqg9/f39eeukl7OyK72VjZ2dXae4n9x3fsYlN5JFXeCyXXPaxj/a0pxOdTEwnIiIiIiIi5UmlnEgBlXLVy8svv8zNN9+MjU3Rf+Zyc3MrRSlnYDCBCYWz5P4ojzzWspaHeRgrVhPSiYiIiIiISHlTKSdSQKVc9eLo6MiUKVOwWouWWlarlYCAAJNS/c9iFvMLvxSZJfdH+eQzn/k8xVMVnExEREREREQqgko5kQL5+flYLBYsFovZUeQGiYyMpFu3bsU2fTB7ppwVKy/zMraUXQDnk89HfMREJlZMMBEREREREakwKuVECuTn52uWXDU0derUIrPlnJ2dcXd3NzERzGc++9lPPvklPm/Bgg02uOHG67zOkzxZwQlFRERERESkvKmUEymgUq56CgoKYuzYsYWbPtx2222m5sknnwlMwELxGZmX7i/XkIa8y7sc5ziv8RpeeFV0TBERERERESlnKuVECqiUq77+/ve/4+rqCkDTpk1NzTKHOSSSWGQDh0tlXEtasoxlJJLIWMbiiKNZMUVERERERKScFd/2T6SGUilX9WVmZpKVlUVqaipZWVlkZmaSl5fHuXPneOSRR/jnP/+JnZ0dUVFRnD9/vtjr3dzcivzdxsamsMxzdXXFwcGBOnXq4OLick0/K7nkFrk/XC1qYWDQj368yIu0oc1VX1NERERERESqJpVyIgVUylUep0+f5sSJExw/fpwzZ86QkpJS6teMjAyysrJIS0u7omvPnTuXuXPnXnfGWrVqUbduXZydnalTpw4eHh64u7sX+Xrp4eXlRf369Ym6NYqjtY8CUJe6PMVTjGEMPvhcdx4RERERERGpWlTKiRRQKVcxLly4QGJiIgkJCRw8eJAjR45w4sQJjh07RlJSEklJSWRlZRWeX6tWrWJll7e3NyEhIbi7u1O3bl0cHBy46aabcHBwwNHRsfDPTk5OwP9mwO3cuZPs7Gzatm1bOAPukksz6v4oJyeHjIwMANLS0sjKyuLChQukp6eTlZXF+fPnOXfuHBkZGaSkpJCSkkJycjLx8fGcOXOG06dP/68sdAAOgI1hw82f3Uzw1mCS3ZKZ5jcNPz8/brvtNvz9/fHz89PPoYiIiIiISA2gUk6kgEq5GycvL48DBw6wa9cu9u7dS0JCQuHjxIkThef5+Pjg5+eHt7c3YWFh9O7dmwYNGtCgQQN8fHzw8fEpVp5dj86dO5f6nJ2dXbHlqzdCfn4+v//+O9+d+44DJw5wyy+3cCL7BMc8jnHixAm2b9/OkSNHSE9PB6B27do0bNgQf39//P39CQgIIDg4mJCQELy9vW94PhERERERETGHSjmRAirlrs3Jkyf55Zdf2LVrF3FxccTFxbF7926ys7OxtbWlUaNGBAQE0Lx5c+65557Cssnf3x9Hx+q/kYGtrS3169dnRP0RFw+0Kvm833//vbC4vDSTMDY2lgULFnDq1CkAPDw8CA0NJTg4mGbNmtGsWTPuuOOOGvE5ioiIiIiIVDcq5UQKqJS7vNzcXHbu3Mn69evZsWMHO3bsYM+ePRiGgZubG0FBQXTq1InHHnuMoKAgwsLCqFOnjtmxqwQvLy+8vLxo165dsedSU1OJj49n9+7dxMfHs2PHDubMmcO5c+ews7OjcePGtGzZkpYtWxIeHk5YWBg2NtpcW0REREREpDJTKSdSID8/X0XGn2RkZLBu3TpWrVrFzz//TExMDHl5edSrV482bdowePBg2rRpQ+vWrXF3dzc7brXl5uZGeHg44eHhhccMwyAhIYGtW7cWPhYsWEBWVhaurq507NiRbt260bVrV0JDQ/WzLSIiIiIiUslYDMMwzA5RKVksMH8+DBxodhKpIJMnT2b69OkkJiaaHcU0VquVLVu28OOPPxIdHc2WLVvIyckhKCiIbt260bFjR9q2bcutt95qdlQpQW5uLrGxsWzZsoU1a9bw888/c/r0aTw9PenSpQvdunWjZ8+e+v6JiIiIiIhUAirlSqNSrsZ56623mDVrFr/99pvZUSpUdnY269at49tvv2XhwoUkJSXh7e1NeHg4ERER9OrVCz8/P7NjyjVKTEzkp59+4qeffmLlypWkpaURFBTE3XffzV133UXHjh2xWCxmxxQREREREalxVMqVRqVcjfOPf/yDuXPnsnfvXrOjlLu8vDyioqL44osviIqK4vz587Rq1Yr+/fvTv39/goKCzI4o5SAnJ4fVq1ezZMkSli1bxvHjx2nUqBEDBgxg2LBhBAcHmx1RRERERESkxtBNhkQK1ISNHvbs2cOLL76In58f/fv35/fff+edd97hyJEjbN26lZdfflmFXDVWu3Ztunfvzv/93/9x9OhRtmzZwuDBg1m0aBEhISG0bduW6dOnc/bsWbOjioiIiIiIVHsq5UQKVNdSzmq18s0339CxY0eCgoL4+uuvGT16NAkJCaxatYonnngCX19fs2NKBbNYLLRp04a33nqLAwcOsGrVKpo0acKzzz6Lt7c3I0aMYPfu3WbHFBERERERqbZUyokUqG6lXE5ODjNnziQoKIiBAwdSv359Vq5cSWJiIhMnTtTN/qWQxWLhzjvv5LPPPiMpKYkpU6awZcsWmjVrxj333MPmzZvNjigiIiIiIlLtqJQTKVBdSjnDMJg1axb+/v48/vjjdOzYkfj4eL755hsiIiKwsdGvvZTO1dWV0aNHs2vXLr755huSk5Np3749ERERxMbGmh1PRERERESk2tB/nYsUqA6l3I4dO+jQoQOPPvoo/fr1IyEhgU8//ZSmTZuaHU2qGBsbG/r378+mTZv4+eefycjIoFWrVowZM4bU1FSz44mIiIiIiFR5KuVEClTlUi4rK4unnnqKNm3aUKtWLXbs2MF///tf3StOboguXbqwceNGPv74YxYsWECTJk34+uuvzY4lIiIiIiJSpamUEylQVUu5Q4cOER4ezty5c5kzZw5r1qwhNDS03Mf97rvvaNy4MXZ2dlf8mvz8fMaPH09gYCAODg706tWr1HO3bdvGsGHDaNSoEY6Ojri7uxMSEsKAAQP46KOPSEhIACAkJASLxVLkMXjw4MLrREREFHmuVatWxcY6fPgwffv2JT09HYDU1FSmTZtG165dcXd3x9HRkcDAQIYMGXJVSzgNw2DDhg08+eSTNG7cGHt7e+rVq0d4eDhffPEFhmEUOX/cuHHMnz+/1OsNHz4ce3t7GjVqxNixY8nKyrriLNfLYrEwbNgw9u3bx3333cfgwYN55plnyM3NrbAMIiIiIiIi1YlKOZECVbGUW7lyJS1btiQvL4/t27czdOhQLBZLuY6ZkJBA3759GT9+PCdPnryq13766ae88847PPTQQyQnJxMVFVXsHKvVygsvvECHDh2oV68eUVFRpKWlsWfPHqZMmUJ6ejpPPPEEAQEB5OXlERcXR3JyMh4eHgB88cUXzJs3r/B6P/30EytWrCAwMJCMjAy2b99eZLyYmBhatWpF9+7dcXFxAeCFF15gzJgx9OvXj927d5OSksLMmTOJiYmhZcuWLFmy5Ire7759+wgPD2f//v0sXLiQs2fPsnnzZm655RYefPBBXnjhhSLnjxo1ivHjxzNhwoQSrzdr1ixOnz7NuHHjmDp1Ku++++4V5biRXF1d+b//+z/mzp3Lxx9/TLdu3fj9998rPIeIiIiIiEhVZzH+PFVDLrJYYP58GDjQ7CRSQR577DF+++03oqOjzY5yRVasWMGAAQO47777+Pjjj3F0dKyQcR944AFCQ0N5/vnnufXWW0lOTiYvL++KX/vVV1+Rnp6Os7Nziee88sorvPXWW8yYMYNRo0YVez4/P5+7776bqKgocnNzC2fqffnllwwZMgQPDw/i4+O5+eabgYuz3po3b868efPo0KFDkWulp6cTHBxMnz59mDZtWuHxkSNHYmtry/Tp04ucHxsbyx133EFgYCD79++/7Pvdu3cvzZo149SpU7i5uRUez8nJwcfHh/Pnz3P27Fns7e2LjBEWFsa8efMYWMa/P3Xq1CE8PJwffvjhsjnKS1xcHP3798fR0ZFVq1bh5eVlWhYREREREZGqRqVcaVTK1TijRo3i8OHD/Pjjj2ZHuazY2Fg6dOjA/fffz4wZMyp0R9XMzMzCAtDX1/eqSrkePXoQHR1d6vl79+4lODiYsLCwYjPa/mjTpk106NChSCkH0K9fP5YtW8aAAQNYuHAhAEOHDqVBgwZMnjy52HVeffVVJk+ezOHDh/Hx8bmi9+Dk5ER2djZ5eXnXNSsxLCyMmJgY0tLScHV1LfLcwIED2bRpEwcPHix1eXCDBg3w9vYu83OqCMeOHaNz5854e3uzatUqateubWoeERERERGRqkLLV0UKVJXlq1lZWQwaNIi2bdsybdq0Ci3kgOuakZefn1/m8zNmzMBqtRIZGVnmee3bt8cwjGKF1bRp03Bzc+Obb75h4cKFLFmyhJiYGCZNmlTsGoZh8Mknn9C2bdsrLuQyMjLIzMwsvI/dtUpLS+O3334jLCysWCEHcM8993Ds2DFWrFhR6jUsFssVl6HlydfXl2+//ZadO3cyceJEs+OIiIiIiIhUGSrlRApUlVLuvffeIykpiTlz5lzVJgtVwdq1awGueaMKb29vpkyZAsCTTz7JU089xZw5c4osD70kNjaWkydP0rx58yu+/oIFC4CLS2yvRXp6Ohs2bKBv377Ur1+fzz77rMTz7rjjDgBTl6ZejaCgIN555x3+/e9/F27AISIiIiIiImVTKSdSoCqUcvn5+UydOpUnnngCPz8/s+NctZycnBILskuSkpIACjdtuBYPP/wwvXv35tSpUwQEBNCyZcsSz4uLiwMuzvS6EidPnmTcuHGMHDmyzHu9leaNN97A1dWV8PBwbG1tWbx4MSEhISWe26BBgyIZS2Jvb1+pdj4dPXo0vr6+fPDBB2ZHERERERERqRJUyokUqAql3Pbt2zlx4gQPP/yw2VGuyZEjR66oBLveHWQDAwMBWLNmDUuXLi3xnBMnTgCUuHz0z1JSUujZsyddunQpsiHE1Xj11VfJzs5mz549NG3alLCwMP7xj3+UeK6LiwsWi6UwY0l8fHw4fvx4pVjCCmBra8vQoUP59ttvzY4iIiIiIiJSJaiUEylQFUq5+Ph4nJ2duf32282OclXOnDnDv/71Lw4fPswTTzxR6nmX7u12+vTpax5r3bp1LFq0iHfffRe4uKtuampqsfOysrIAqFWrVpnXy8jIoEePHgQFBTF37tzr+hmpXbs2TZs25aOPPqJv37689tpr/PTTTyWea2dnR2ZmZqnXGj16NOnp6bz22mvX9XndSG3atCExMZELFy6YHUVERERERKTSUyknUqAqlHLnz5+nbt26Zse4KsOGDcPDw4Nx48bx4osv8re//a3Uczt37gzAzp07r2ms8+fPM2zYMGbMmMEzzzxDr169SE5OZuzYscXOdXBwAChzCWheXh6RkZE0aNCAOXPm3NCfj7vvvhuA5cuXlzp2WZtqDB06lDfffJN//etfeHl50bNnzxuW7Vq5uLgAcO7cOZOTiIiIiIiIVH4q5UQKVIVSrl69eqSkpJCdnW12lCs2e/Zszp49y7x583j33XcZPXp0qeeOHj0aOzs7Fi5cWOY1X3zxRWxsbNi7d2+R48899xwRERGFBdX06dNxcXHh888/L1Z+eXt7A3D27Nky82RnZ/P1118X2VQjICCAzZs3l5nxci7dW+/MmTPFnktPT8cwjMKMJXnllVd4+eWX+eijj0hLS+P777+/rjw3wrFjx7Czs7uuewKKiIiIiIjUFCrlRApUhVKuffv25OTkFO5SWlW4uLgQGRlJWFhYmYVb48aN+fvf/8727duZOXNmiefs27eP6dOnM3DgQJo2bVp4/IcffmDlypX8+9//Ljzm5+dX+PfRo0eTlpZW+NylTRaOHTtW4jgTJ04kPj6epUuXlrk5RVmef/55hg4dWuJzUVFRALRu3brYc8ePHy+SsSSLFi2iUaNGjBw58orui1cRfvrpJ9q0aVPtdgUWEREREREpDyrlRApUhVKuYcOGdOzYscrucOni4kJ6enqZ57z66quMGzeOxx57jHHjxrF//35ycnI4fvw4n376KXfeeSehoaF8+umnha9JS0tj1KhRzJw5E2dn5yLXGzVqFBERESQlJfHMM88UHm/evDn16tUjNja2WIbZs2fz+uuvs2XLFpydnbFYLEUeCQkJxV4zdOhQLBYLBw8eLHL8yy+/ZNKkSRw6dIjs7GwOHTrESy+9xBdffEHLli0ZOXJksWvFxMQA0L1791I/p3PnzhUuF60MTp48ybx583jggQfMjiIiIiIiIlIlqJQTKVAVSjm4WFp9++23fPfdd6aMv3z58sJy6vjx4+Tn5xf+/ZNPPinztVe6q+rbb7/Nhg0bSEpKIiIigrp163L77bfzySefMG7cOKKjo6lTpw4Avr6+uLm5cfToUe6880769+9feJ20tDQsFkvhZgqzZ8/GYrHw3nvvYbFYGDlyJFu2bCEpKanI+JdbPluSEydOULduXW655ZbCY6+99hoff/wxGzdu5M4778TFxYVmzZoRHR3N22+/zbp160q8b9zixYtp0KABffr0KXPM692l9kZ6/vnn8fT0ZPjw4WZHERERERERqRIshmEYZoeolCwWmD8fBg40O4lUkIiICPz9/Zk+fbrZUS5r6NCh/Pjjj2zbto2GDRuaHeeK3XXXXXz33XdYrVazowAX7ycXHBzMXXfdxbRp0675Omlpafj4+DBkyBA+/vjj68oUGxtLWFgYX375JYMHDy71vPr169OoUSM2bdp0XePdCB9//DGjR49m2bJl3HXXXWbHERERERERqRI0U06kQFWZKQcXNzDw8fEhIiKi8P5jVYGvry+GYXDy5EmzowDg6urKt99+y8KFC/nwww+v6RqGYfC3v/0NFxcX/vGPf1xXnsTERO69917Gjx9fZiGXm5vLmTNn8PX1va7xboSvv/6aJ554ggkTJqiQExERERERuQoq5UQKVKVSrk6dOvz444/Y29vTtm3bSjFb6kpc2hX1nXfeISUlxeQ0F4WFhbF9+3aioqIue7+7kpw8eZLExESio6OpX7/+dWWZPn06b775Jm+++Wap55w9e5Z3332X3Nzcws/TDIZh8Pbbb/PAAw/w1FNP8frrr5uWRUREREREpCrS8tXSaPlqjdOxY0dat27Ne++9Z3aUK5aens7w4cNZtmwZb7zxBi+99JLZkS7rn//8J7NnzyYxMZE777yzcBdSubxhw4bx5Zdf0rBhQ+6//37+/ve/m1Iknzt3juHDh7N06dIq83MnIiIiIiJS2aiUK41KuRqnXbt2dOzYkf/85z9mR7kqhmHwxhtvMHHiRHr37s17772Hv7+/2bGkmlqyZAnPPPMM2dnZfP3114SHh5sdSUREREREpErS8lWRAlarFRubqvcrYbFYmDBhAqtWreLgwYOEhIQwYcIELly4YHY0qUb27dtHz549uffee+nYsSO//PKLCjkREREREZHrUPUaCJFyUpXuKVeSzp078+uvv/L222/zwQcf0LRpU6ZOnUpGRobZ0aQKS0hIYPTo0YSGhnLy5EnWrl3LF198cd33zxMREREREanpVMqJFKjqpRxArVq1ePrpp9m3bx/33HMP48eP59Zbb2XSpEmcOXPG7HhShcTExDB48GCaNGnCqlWr+PDDD9m+fbtmx4mIiIiIiNwgKuVEClSHUu6Sm2++mffff5/Dhw/z+OOP8/7779OwYUNGjhzJhg0bzI4nldSFCxf4/PPP6dq1Ky1atGDfvn3MnTuXvXv3MnLkyGrz+yEiIiIiIlIZqJQTKVCdSrlLPD09mTRpEocPH+att94qnOnUtGlTJk+eTFJSktkRpRLYvHkzo0ePxtvbm5EjR+Lm5kZUVBS//PILgwYNqna/FyIiIiIiIpWBSjmRAtWxlLukbt26jBkzhpiYGOLi4ujfvz//+c9/8PPzo1WrVkycOJF9+/aZHVMqiNVqZf369YwbN44mTZrQvn171q1bx8svv8zRo0f55ptv6NGjBxaLxeyoIiIiIiIi1ZZKOZEC1bmU+6Pg4GDeeecdjh49ysKFCwkODi7cGKJ58+b8/e9/Z/PmzeTl5ZkdVjrrhQAAIABJREFUVW6gs2fPsmTJEh555BHq169Pp06dWLZsGQMGDGDHjh3s3r2bl156iXr16pkdVUREREREpEawMzuASGVRU0q5S+zt7bnnnnu45557yMvLY82aNSxZsoRZs2YxadIkXFxc+Mtf/kK3bt3o2rUrzZo108ypKuTChQusX7+en3/+mVWrVrFjxw4Mw6B169Y899xz9O/fnyZNmpgdU0REREREpMayGIZhmB2iUrJYYP58GDjQ7CRSQW655RbGjh3Lc889Z3YU0+3du5fo6GhWrVrFmjVrSElJwcvLiw4dOtC2bVvatm1Lq1atcHFxMTuqFDh8+DBbtmxhy5YtbN26la1bt5KTk0PTpk3p2rUrXbt2pUuXLnh4eJgdVURERERERFApVzqVcjVOgwYNeOGFF3j66afNjlKpWK1WYmJi+Pnnn9m4cSNbt27l2LFj2NjY0LRpU9q0aUPr1q1p1qwZISEhuLm5mR25WjMMg0OHDhEfH09MTExhAXfy5Ens7OwIDg6mbdu2dOrUia5du+Lj42N2ZBERERERESmBlq+KFKhpy1evlI2NDS1atKBFixaFswiTkpLYunVr4cysxYsXc/bsWQB8fX0JDg6mWbNmBAcHExwcTEBAgMq6q2S1Wjl27Bi//fYbcXFxxMfHs3PnTnbv3s25c+cAaNiwIa1bt+b555+nbdu2tGjRgjp16picXERERERERK6ESjmRAirlrpyPjw/9+/enf//+hccOHz5MfHw8cXFxxMXFER0dzX//+1+ysrIAcHd3x9/fH39/fwICAgr/7Ofnh7e3N/b29ma9HdOcPXuW48ePc/jwYRISEkhISODAgQMkJCSQmJhIdnY2AB4eHoSGhtK6dWtGjBhBSEgIwcHBuLq6mvwORERERERE5FqplBMpoFLu+jRs2JCGDRvSu3fvwmP5+fkcPHiwsHC69FiyZAkHDhwoLOwAvLy88Pb2xs/Pj/r16+Pr68vNN9+Ml5cXHh4eeHh44O7ujoeHB46Ojma8xSty9uxZTp8+TUpKCmfOnCElJYXTp09z/PhxTpw4wdGjR0lOTubo0aNcuHCh8HWenp6FZWVkZGRhaRkYGKgdUUVERERERKohlXIiBVTK3Xi2trYEBAQQEBBQ4vNJSUkcO3assKw6ceIEx44d48iRI6xevZojR46Qm5tb7HVOTk6FBZ2TkxN16tTBxcUFe3t7nJ2dqVu3Lg4ODoUbUdSuXbvYsk5nZ2fs7P73T2BmZmaRkhAgNTUVuPizkZ6eTkZGBllZWZw9e7bw/NTUVC5cuFBYwuXl5RW5Rq1atfD09MTHxwcfHx+CgoLo1q1bkfLRz89Ps95ERERERERqGJVyIgVUylW8S0XVn61evZr+/fvTsWNHFi1aRF5eXuGss0tfL/35woULZGRkkJ6eTmZmJr///jvnzp0jKyur8N5rFy5cKFwKeol9WhqNDYN1gEHZxZ2NjQ2urq44OTnh4ODATTfdhLu7Ow4ODri5uRUpCd3d3fH09Cyc3efs7FxeH5+IiIiIiIhUYSrlRAqolKscFi1axJAhQ+jduzdz587FwcEBuLi89YaaORPGjoWC4k5ERERERESkItmYHUCkslApZ76pU6cSGRnJo48+yoIFCwoLuXJx6hToXm0iIiIiIiJiEpVyIgVUypnHMAwmTpzI008/zYQJE3j//fexsSnnf55UyomIiIiIiIiJtHxVpIDValUpZ4KcnBxGjBjBggUL+PzzzxkyZEjFDHzyJNx8c8WMJSIiIiIiIvInKuVEuDhLDlApV8HOnz9PZGQk69evZ+nSpfTs2bPiBj91Cho1qrjxRERERERERP5ApZwIKuXMkJycTJ8+fUhKSmLNmjW0aNGiYgOcPAnt2lXsmCIiIiIiIiIFVMqJoFKuoiUmJtKzZ0+sVitr164lMDCw4kOcOgU3ekdXERERERERkSukjR5EUClXkbZt20b79u256aab2LRpkzmFnNUKKSm6p5yIiIiIiIiYRqWcCCrlKsrKlSvp1q0bzZs3Jzo6Gi+zZqqdPg15edp9VUREREREREyjUk4ElXIVYc6cOfTp04d7772XFStW4OzsbF6YU6cuftVMORERERERETGJSjkRVMqVt8mTJzN8+HCeffZZZs2aRa1atcwNdPLkxa+aKSciIiIiIiIm0UYPIqiUKy/5+fmMGTOGGTNm8OGHH/L444+bHemiU6fAzg7c3c1OIiIiIiIiIjWUSjkRVMqVh+zsbB588EGWLVvGV199RWRkpNmR/ufwYfD1BRtNFhYRERERERFzqJQT4X+lnI1KmhsiNTWVfv36ERcXx8qVK+nUqZPZkYo6ehRuucXsFCIiIiIiIlKDqZQTQTPlbqSkpCR69erF6dOnWb16NaGhoWZHKu7IEZVyIiIiIiIiYipNCxJBpdyNEh8fT7t27bBarWzevLlyFnKgUk5ERERERERMp1JOBLBarYBKueuxevVqOnbsiL+/P+vXr8fPz8/sSKVTKSciIiIiIiImUykngmbKXa9FixbRq1cvunXrRlRUFK6urmZHKt25c5CWplJORERERERETKVSTgSVctdj6tSpREZG8uijj7JgwQIcHBzMjlS2w4cvflUpJyIiIiIiIiZSKSeCSrlrYRgGEydO5Omnn2bChAm8//77VWP32kulXGVeXisiIiIiIiLVnnZfFUGl3NXKyclhxIgRLFiwgM8//5whQ4aYHenKHTkCbm7g4mJ2EhEREREREanBVMqJoFLuapw/f57IyEjWr1/P0qVL6dmzp9mRrs7Ro1q6KiIiIiIiIqZTKSeCSrkrlZycTJ8+fUhKSmLNmjW0aNHC7EhXTzuvioiIiIiISCWgUk4ElXJXIjExkZ49e2K1Wlm7di2BgYFmR7o2R45A8+ZmpxAREREREZEargrclV2k/KmUK9u2bdto3749N910E5s2bbriQi41NZVp06bRtWtX3N3dcXR0JDAwkCFDhhAbG1vOqUtx+LA2eRARERERERHTqZQTQaVcWVauXEm3bt1o3rw50dHReHl5XfFrX3jhBcaMGUO/fv3YvXs3KSkpzJw5k5iYGFq2bMmSJUvKMXkJsrLg+HEICKjYcUVERERERET+RKWcCCrlSjNnzhz69OnDvffey4oVK3B2dr7qa4wYMYKxY8dSv359nJyc6NSpE19++SX5+fm8+OKL5ZC6DPv3Q34+NG1aseOKiIiIiIiI/InuKSeCSrmSTJ48mfHjx/Piiy/y9ttvY7FYrvoan3zySYnHmzdvjqOjIwkJCRiGcU3Xvib79oGtLfj7V8x4IiIiIiIiIqVQKSeCSrk/ys/PZ8yYMcyYMYMPP/yQxx9//IaPkZGRQWZmJqGhoRVXyAHs3QuNGoG9fcWNKSIiIiIiIlICLV8VQaXcJdnZ2dx///3MnDmTr776qsRCbu/evfTv3x9XV1ecnJxo06YNy5cvJyIiAovFgsViYeTIkWWOs2DBAgBeeeWVcnkfpdq3D5o0qdgxRUREREREREqgmXIiqJSDizul9uvXj7i4OFauXEmnTp2KnXPgwAHat29PnTp1WLhwIe3bt+fw4cM8/fTT7Ny5E3t7e7Kyssoc5+TJk4wbN46RI0cycODA8no7Jdu3D/7yl4odU0RERERERKQEmikngkq5pKQkunTpQmJiIqtXry6xkAN4+eWXSUtL4/333+evf/0rdevWJTg4mC+//JKMjIzLjpOSkkLPnj3p0qUL06ZNu9Fv4/L279dMOREREREREakUVMqJ8L9Szsam5v1KxMXF0a5dO6xWK5s3byY0NLTUc7///nsAevToUeS4l5cXTS+zo2lGRgY9evQgKCiIuXPnVnwBmpQE6enaeVVEREREREQqhZrXQIiUID8/v0bOklu9ejXh4eH4+/uzfv16fH19Sz03Ozubc+fO4eDgQN26dYs97+bmVupr8/LyiIyMpEGDBsyZM8ecz3rfvotfNVNOREREREREKgGVciLUzFJu0aJF9OrVi27duhEVFYWrq2uZ59vb2+Ps7ExWVhbnz58v9vypU6dKfe3o0aPJzs7m66+/xs7uf7eyDAgIYPPmzdf+Jq7Gvn3g6go331wx44mIiIiIiIiUQaWcCDWvlJs6dSqRkZE8+uijLFiwAAcHhyt6Xa9evYD/LWO9JDk5mf3795f4mokTJxIfH8/SpUuxt7e/vuDXY98+LV0VERERERGRSkOlnAg1p5QzDIOJEyfy9NNPM2HCBN5///2ruo/eW2+9hbu7O08//TQrV67k/PnzxMXFMXz4cOrXr1/s/NmzZ/P666+zZcsWnJ2dsVgsRR4JCQk38u2Vbe9eLV0VERERERGRSkOlnAg1o5TLycnhwQcf5O233+bzzz9n4sSJV30Nf39/Nm3aROvWrbnvvvu4+eabGT16NOPHjycgIKDY+QsXLrwByW+QfftUyomIiIiIiEilYXf5U0Sqv+peyp0/f57IyEjWr1/P0qVL6dmz5zVfq3HjxixevPiKzl2+fPk1j3NDZWXBkSMq5URERERERKTSUCknQvUu5ZKTk+nTpw9JSUmsWbOGFi1amB2p4u3dC/n5cPvtZicRERERERERAVTKiQDVt5RLSEigV69eWK1W1q1bV+IS0xohNhbs7aFxY7OTiIiIiIiIiAC6p5wIUD1LuW3bttG+fXtuuukmNm3aVG6F3Lx587BYLERHR5OdnY3FYmHkyJHlMtY1i42FkBCw0/8PISIiIiIiIpWDSjkRql8pt3LlSrp168Ydd9xBdHQ0Xl5e5TbW4MGDMQyjyOOTTz4pt/GuSUwMNG9udgoRERERERGRQirlRKhepdycOXPo06cP9957LytWrMDZ2dnsSObbtUulnIiIiIiIiFQqKuVEuFjK2dhU/V+HyZMnM3z4cJ599llmzZpFrVq1zI5kvmPH4PRplXIiIiIiIiJSqegGSyKA1Wqt0jPl8vPzGTNmDDNmzODDDz/k8ccfNztS5REbe/FraKi5OURERERERET+QKWcCFV7+Wp2djYPPvggy5Yt46uvviIyMtLsSJVLbCzccgu4uZmdRERERERERKSQSjkRqm4pl5qaSr9+/YiLi2PlypV06tTJ7EiVz/bt0LKl2SlEREREREREiqj6N9ESuQGqYil3/PhxunTpQmJiImvWrFEhV5pt26B1a7NTiIiIiIiIiBShUk6EqlfKxcXF0a5dO6xWK5s3b6ZZs2ZmR6qckpMvbvTQqpXZSURERERERESKUCknQtUq5VavXk14eDgBAQGsX78eX19fsyNVXtu2gcUCLVqYnURERERERESkCJVyIlSdUm7RokX06tWLbt26ERUVhaurq9mRKrdt28DfHzw8zE4iIiIiIiIiUoQ2epAaJy0tjTNnzhQ5dvbsWQzDIDU1tchxFxeXSlPWTZ06lWeeeYannnqKKVOmYGOjTv2ytm/X/eRERERERESkUlIpJzXOxo0b6dOnT4nPubu7F/n7a6+9xuuvv14RsUplGAavv/46kyZN4rXXXmPixImm5qlSduyAcePMTiEiIiIiIiJSjEo5qXEiIiJwcXEhPT39sucOHTq03POkpaVx0003lfhcTk4OI0aMYMGCBXz++ecMGTKk3PNUGwcPwqlT2uRBREREREREKiWtf5Map3bt2gwYMIBatWqVeo7FYqFly5YEBgaWe5777ruP//73v8WOnz9/nn79+rF06VKWLl2qQu5qrV8PtWtDy5ZmJxEREREREREpRqWc1EiDBg0iNze31OdtbGwYMWJEueeIiooiOjqav/3tb3zzzTeFx5OTk+ncuTMxMTGsWbOGnj17lnuWamfDhouz5JyczE4iIiIiIiIiUozFMAzD7BCVksUC8+fDwIFmJ5FykJeXh5eXF2lpaSU+b2trS3JyMp6enuWWIT8/n+DgYA4cOIDVasXW1pbvv/+eW2+9lZ49e2IYBt9//z0BAQHllqFaCwmBPn1g8mSzk4iIiIiIiIgUo5lyUiPZ2dlx3333lbiE1c7Ojl69epVrIQcwa9YsfvvtN/Lz8zEMA6vVyt13302rVq3w8PBg8+bNKuSuVWoq7NkDHTuanURERERERESkRCrlpMYqbQlrfn4+w4YNK9exMzMzefXVV/njRFWr1Upubi65ubnMmjWr3EvBam3DBjAMaN/e7CQiIiIiIiIiJVIpJzXWnXfeiZubW7HjTk5O9O7du1zH/uc//0lKSgp/Xj2el5dHTk4O/fr148yZM+WaoVrbsAGaNgUvL7OTiIiIiIiIiJRIpZzUWLa2tgwaNIjatWsXHqtVqxYPPPAAjo6O5TbuqVOnmDx5Mnl5eSU+n5uby6FDh+jRowcXLlwotxzV2vr1EB5udgoRERERERGRUqmUkxotMjKSnJycwr/n5uby0EMPleuYEyZMKLWQ+2OO7du389BDD2G1Wss1T7WTmQnbt+t+ciIiIiIiIlKpqZSTGq1Lly5F7t3m4+NDx3Isc/bs2cMnn3xS4r3sLrm0+UT79u2JjIxUKXe1NmyArCzo2tXsJCIiIiIiIiKlUiknNZqNjQ0DBw6kdu3a1KpVixEjRmCxWMptvOeeew5bW9tixy0WC7a2tjg6OjJs2DBiY2PZuHEjgwYNws7OrtzyVEvR0dC4Mfj5mZ1EREREREREpFQq5aTGGzhwIDk5OeTm5jJ06NByG2fNmjVERUUVmSV36X52jRo14s033+T48ePMmDGD0NDQcstR7UVHQ7duZqcQERERERERKZOm4Ei1k5+fT3p6OhkZGWRmZpKeng7A2bNniy0FTU1NxTAMnJ2d8fT0ZOfOnSQmJhYuIb3E2dkZOzs7HB0dcXBwwM3NDQcHhyveEMIwDJ5++mlsbGywWq3Y2dlhGAZ9+/blqaeeonPnzjfmzdd0aWnwyy/w0ktmJxEREREREREpk0o5qbQuXLjA0aNHSU5O5vTp05w+fZqUlBTOnDlT7GtGRgbnzp3j/PnzZd6vrSznzp1j4MCBV/26SwVdnTp1cHd3x8PDo9jXvXv3EhMTA4CXlxdjxoxh1KhR1K9f/5qySilWrwbDAJWcIiIiIiIiUslZDMMwzA5RKVksMH8+XENJI5eXn5/PkSNHSExMJCEhgWPHjnHkyBFOnDjB8ePHOX78OGlpaUVe4+bmhoeHR4mlV506dXB2dqZu3bo4ODjg4uKCk5MTDg4O3HTTTQDUqVOncLnoJZdmwG3ZsgV/f388PT1LnVEHF4vCrKws0tLSyMzMJCsri9TUVLKzszl//nyxwvDS4/fff+ePv2oODg40aNAAHx8ffH198fb2xs/Pj9tuu43bbrsNf3//K56FJ38wZgxs3Ag7dpidRERERERERKRMmikn5SopKYm4uDji4+M5cOAACQkJJCYmcujQocIZba6urvj5+eHn54evry/t2rXDx8eHBg0aFBZWnp6eJW6QcKO0bdu28M+urq7Fnndzc7vmayckJJCXl0f9+vVJSkoiKSmpsHg8ceIER44cYcOGDYWl5CU+Pj74+/vj7+/Pbbfdxu23306zZs0ICAgo18+iSlu1Cvr0MTuFiIiIiIiIyGVpplxpNFPuqmRmZvLrr7+ya9cudu3aRXx8PDt37uTMmTMA1KtXj8aNGxeWTH98eHp6mpy+8sjMzCQhIaHEx8GDB8nPz8fBwYGgoCBCQkIIDg4mNDSUFi1aUK9ePbPjm+voUbjlFvjxR/jrX81OIyIiIiIiIlImlXKlUSlXpsTERNavX8+OHTvYsWMH27dvJzs7G2dnZxo3bkxQUBDBwcEEBQXRqlUrvL29zY5c5eXk5PDbb7+xe/du4uPj2bFjB7t37+bgwYMYhoG3tzctW7akZcuWhIeH06FDB5ycnMyOXXE++ghefBFOnwZ7e7PTiIiIiIiIiJRJpVxpVMoVslqtxMbGEh0dzapVq9iwYQPp6ek4OjoSFhZGmzZtCh+33XYbFovF7Mg1SkpKCtu2bWPr1q2Fj99//x07OzvCwsLo2rUrXbt2JTw8vHqXdHfdBbVrw6JFZicRERERERERuSyVcqWp4aXcoUOHiIqKIjo6mtWrV5OSkoKXlxd33nknnTt3pl27djRr1oxatWqZHVVKkJiYyNatW1m/fj2rVq1iz5491K5dm3bt2tG1a1e6d+9O27ZtsbGxMTvqjZGZCZ6eMHUqPPKI2WlERERERERELkulXGlqYCkXHx/P8uXL+fbbb9m4cSNOTk60b9+eiIgIIiIiCAsLqz4lTg1z8uRJ1q5dy08//cTKlSs5ePAgnp6e9OrVi8jISLp37459VV7yuWIF3H33xfvKNWhgdhoRERERERGRy1IpV5oaUsrt2rWL2bNns3jxYg4ePIivry99+/alf//+dOnSRTPhqqn4+HiWLFnCkiVL2LFjB87OzvTq1YuhQ4fSq1evqre76xNPwJYtsGOH2UlERERERERErohKudJU41IuLS2Nr776ilmzZrFt2zb8/f0ZNGgQ/fv3p1WrVronXA1z9OhRli1bxsKFC1mzZg3169fnoYceYvjw4TRp0sTseFemUSN48EGYNMnsJCIiIiIiIiJXRKVcaaphKRcXF8e///1v5s+fj42NDffddx8jRozgL3/5i4o4AS7ei2727NnMnj2bo0eP0qlTJ5599ln69u1beZcux8VBs2awaRO0a2d2GhEREREREZErUkn/K1tupI0bN9K3b19CQ0PZvn07U6dO5cSJE8yZM4fOnTurkJNCt912G5MmTeLQoUP88MMPeHh4MGDAAJo1a8acOXPIzc01O2JxixdD/frQpo3ZSURERERERESumEq5auzXX3/lzjvvpGPHjqSkpLBkyRJ27drFqFGjcHFxMTueVGI2NjZ0796dxYsXs2vXLlq3bs2oUaMICAjg888/p1JNsF2wAAYMgMo6k09ERERERESkBPqv2GrozJkzPPnkk7Ru3Zrc3FzWrFnDhg0b6Nu3r2bFyVULCgpi9uzZHDhwgN69ezN8+HA6derEr7/+anY02L8fdu26WMqJiIiIiIiIVCEq5aqZ+fPn06RJExYtWsTMmTNZt24df/nLX8yOJdXALbfcwkcffcS2bdsAaN26NWPHjiU7O9u8UAsWgJcXdOpkXgYRERERERGRa6BSrprIzc1l7Nix3H///QwaNIh9+/bx0EMPldvMuNTUVKZNm0bXrl1xd3fH0dGRwMBAhgwZQmxs7GVfn5+fz/jx4wkMDMTBwYFevXqVeu62bdsYNmwYjRo1wtHREXd3d0JCQhgwYAAfffQRCQkJAISEhGCxWIo8Bg8eXHidiIiIIs+1atWq2FiHDx+mb9++pKenF3vuu+++o3HjxtjZ2V3JR1TE1X5e48aNY/78+aVeb/jw4djb29OoUSPGjh1LVlbWVWe6VmFhYaxbt46ZM2cye/ZsOnXqxJEjRyps/CK++ebiLLlr+J78kWEYbNiwgSeffJLGjRtjb29PvXr1CA8P54svvqhcy3VFRERERESkejCkZGAY8+ebneKKJCcnGx06dDDq1q1rzK+gzI888ohhZ2dnvPfee8aJEyeMjIwMY+3atUZQUJBha2trLF68uMzXT58+3QCMSZMmGampqSWek5+fbzz//POGnZ2d8cILLxh79uwxsrKyjOTkZOPHH380IiIiDMAAjNzcXMMwLn4WHh4eBmB88cUXxa65YsUKIzAw0MjIyCj23K+//mp4enoaH3zwQZHjBw4cMO6++24jNDTUcHFxMWxtba/0Yyp0tZ/XgQMHjEaNGhmvvvpqqddMT083pk2bZgDGm2++edWZboR9+/YZISEhhqenp7Fq1aqKHTwx8eLv6cqV132pPXv2GIARERFhxMbGGpmZmUZCQoJx//33G4Dx3HPP3YDAIiIiIiIiIv+jUq40VaSUS05ONm6//XYjMDDQ2L17d4WN+8gjjxiPPvposeMxMTEGYAQGBpb5+ktlR3p6eqnnvPzyywZgzJgxo8Tn8/LyjF69ehUp5QzDMObOnWsAhoeHh5GcnFx4/MyZM4afn5+xYcOGYtc6e/as4evra4wePbrErG+//baRm5trNGjQ4JpLuav9vGJiYgyLxXLZotXJycno3r37VWe6Uc6fP28MGjTIcHBwMH744YeKG/iddwzDw8Mw/vC9v1Z79uwx7OzsjDNnzhQ5np2dbXh4eBj29vZGVlbWdY8jIiIiIiIiconFMLQuq0QWC8yfDwMHmp2kVNnZ2XTp0oWUlBRWr16Nj4+P2ZEAcHJyIjs7m7y8vFKXz/bo0YPo6Gjy8vJKfH7v3r0EBwcTFhbG9u3bSx1r06ZNdOjQgdzc3CLLSvv168eyZcsYMGAACxcuBGDo0KE0aNCAyZMnF7vOq6++yuTJkzl8+HCxzzEzMxNHR0cAfH19SU5OLjX3tSjr8xo4cCCbNm3i4MGDpS6bbdCgAd7e3mV+TuXNarUybNgwFi9ezKZNmwgJCSn/Qdu0gdBQ+OSTch0mLCyMmJgY0tLScHV1LdexREREREREpObQPeWqsAkTJrB7926+/fbbSlPIZWRkkJmZWXh/t9Lk5+eXeZ0ZM2ZgtVqJjIws87z27dtjGEaxwmratGm4ubnxzTffsHDhQpYsWUJMTAyTJk0qdg3DMPjkk09o27ZtiZ/jpUKuPFzu87rnnns4duwYK1asKPUaFovlhpaE18LGxoZPP/2UsLAwBg0aRE5OTvkOuH8/bNsGDzxQrsOkpaXx22+/ERYWpkJOREREREREbiiVclXU/v37mTJlCv/6179o0qSJ2XEKLViwAIBXXnnluq6zdu1aAEJDQ6/p9d7e3kyZMgWAJ598kqeeeoo5c+Zgb29f7NzY2FhOnjxJ8+bNrz3wNbrc53XHHXcA8MMPP1RYpmtVq1YtPvvsMw4dOsR///vf8h1s1izw9YXOnUs9Ze/evfTv3x9XV1eSSn9KAAAgAElEQVScnJxo06YNy5cvL7Lhx8iRI0t8bXp6Ohs2bKBv377Ur1+fzz77rLzeiYiIiIiIiNRQKuWqqA8++IBbb7211FLBDCdPnmTcuHGMHDmSgZdZ9puTk1NiQXZJUlISAB4eHtec5+GHH6Z3796cOnWKgIAAWrZsWeJ5cXFxwMWlqRXpSj6vBg0aAP/LWBJ7e3tyc3PLJePVuvXWW3nsscd47733sFqt5TOI1Qpz58LDD4OtbYmnHDhwgPbt27N9+3YWLlzIqVOnmDVrFu+//z47d+7E3t6+cIbkn73xxhu4uroSHh6Ora0tixcvrpjluCIiIiIiIlKjqJSror799luGDh2KjU3l+BampKTQs2dPunTpwrRp0y57/pEjR66oBCtrCeyVCAwMBGDNmjUsXbq0xHNOnDgBUKHLE6/083JxccFisRRmLImPjw/Hjx83fQnrJcOGDePo0aP8+uuv5TNAdDQcPQpDh5Z6yssvv0xaWhrvv/8+f/3rX6lbty7BwcF8+eWXZGRklHn5V199lezsbPbs2UPTpk0JCwvjH//4x41+FyIiIiIiIlLDVY5GR67KuXPnOHz4MG3atDE7CnDxvmg9evQgKCiIuXPnYlvK7CWAM2fO8K9//YvDhw/zxBNPlHrepXu7nT59+ppzrVu3jkWLFvHuu+8C8Nhjj5GamlrsvKysLODi8suKcDWfF4CdnR2ZmZmlPj969GjS09N57bXXruvzulFCQkJwcnL6//buPcznOu/j+PPHxIzDOEwtQinC5lAqx+3Eqiihg0qHTaW0lcV2WKqV3YpqW227WyS5pdZ2sGFXpVukUohsQusQKc2gjEMzYhzmd//xWVNuDDNm5jszno/rmmsOvr/v9zVjdF29rs/n8851dd9hef55aNsWGjc+4CVTp04FwkCRHzvmmGNonMvr9ihXrhyNGzdmxIgRdO3alcGDB/P2228fXm5JkiRJkn7EUq4EyszMBKBSpUoRJ4Fdu3bRo0cPateuzfPPP59rwdSrVy9SUlIYOHAg99xzD7/61a8OeO05/z0r7NNPP81XrszMTHr16sWoUaMYMGAAnTt3Zt26dfTr12+faxMTEwGKZAtoXn5eP35NbsMmrr32Wh5++GH+8Ic/cMwxx9CpU6eCjJxnsViMSpUqkZGRUfA3/+47mDgRfvGLA16SlZVFRkYGiYmJ+/03Uq1atTw98uKLLwZgypQpecsqSZIkSVIuLOVKoJSUFMqWLZtz7lqU+vTpQ1ZWFq+88speE1AbNGjAnDlz9rp27NixbNmyhZdeeonhw4fTp0+fXO+bkJDAhAkTcn3+PffcQ5kyZVi6dOleX7/zzjvp2LFjTkH1zDPPkJyczAsvvLBPuVKrVi0AtmzZcvBv+DDl5ecFYeBAPB7Pybg/9913H/feey8jRoxg8+bNOavEorJt2zY2btxIjRo1Cv7mEybArl2Qy1Te8uXLU7lyZbZv355TYP/YN998k6dH7jn7cOPGjXnLKkmSJElSLizlDqRcOdixI+oU+1WuXDnOOOOMyLfTDRkyhCVLljB58uRchzb8WHJyMj169KBFixa5Fm4NGzbkgQceYP78+YwZM2a/1yxbtoxnnnmGK664Yq8tiW+99RbTpk3j8ccfz/la3bp1cz7v06cPmzdvzvmzPYf4f/3114f0PeRXfn5eqampALkOGnjttdc44YQT6N27d5Gei3cgM2fOZNeuXbRr167gbz5mDHTrBgcZANK5c2eAfQrKdevWsXz58n2uv+uuu7j2AGfUvfnmmwC0bNkyP4klSZIkSdovS7kDSUyE/541Vhz17NmTv//975GdITZ27Fh+97vfMXfuXCpXrkwsFtvrbeXKlbm+Pjk5me+++y7Xa+6//34GDhzIrbfeysCBA1m+fDk7duwgNTWV5557jvbt29O8eXOee+65nNds3ryZm2++mTFjxlC5cuW97nfzzTfTsWNH0tLSGDBgQM7XTznlFH7yk5+wcOHCfPwk9nXttdcSi8X44osvcr6W35/XJ598AsD5559/wOdlZGSQnJxcINkLwp///GfOOeecnMmxBWbhQvjgA/jlLw966dChQ6levTr9+/dn2rRpZGZmsnjxYm644QZq1qy539eMHz+e3//+96xevZqsrCxWr17Nb37zG1588UVOP/30YjXpWJIkSZJU8lnKHUhiImRlRZ3igG666SaqVKnCXXfdFcnzD7at9GAOdarqsGHD+OCDD0hLS6Njx45UqlSJn/70p4wePZqBAwcyffp0KlasCECdOnWoVq0aa9asoX379nTv3j3nPps3byYWi+WsLhw7diyxWIw//elPxGIxevfuzdy5c/e7JXjKlCk55Vlqaiq7d+/O+Xz06NH7XL927VoqVarEcccdl/O1/P68Jk6cSO3atbnoootyve5wp9QWlH/+859MnTqVwYMHF/zNn3oKfvpTOPfcg15av359Zs+eTcuWLbn88supUaMGffr0YdCgQTRo0GCf6wcPHsyzzz7Lhx9+SPv27UlOTqZZs2ZMnz6dYcOG8f777+d6rp8kSZIkSXkVi8fj8ahDFEv16sEdd0BEpdehmDx5MpdccgljxoyhV69eUcfJky5duvDGG2+QnZ0ddRQgnCfXpEkTunTpwsiRI/N9n82bN3PsscdyzTXX8Oyzzx5WpoULF9KiRQvGjx/PVVdddcDratasyQknnMDs2bMP63mHa+XKlbRq1YqLL76YsWPHFuzNt2yB2rXhkUfCv8vD0LFjR2bNmpUzdVeSJEmSpCi4Uu5AqlWDYn6we7du3Rg4cCC33HILr732WtRx8qROnTrE43HWr18fdRQAqlSpwr/+9S8mTJjAU089la97xONxfvWrX5GcnMyDDz54WHlWrVrFpZdeyqBBg3It5Hbu3MnGjRupU6fOYT3vcH311Vecd955nHDCCTz99NMF/4CxYyEWg+uuK/h7S5IkSZIUAUu5A6lVC9atizrFQT388MPccsstXHnllTz22GOUlIWPe6aiPvLII6Snp0ecJmjRogXz58/nzTffPOh5d/uzfv16Vq1axfTp0w94btmheuaZZ3j44Yd5+OGHD3jNli1bGD58ODt37sz5eUZh1qxZtGnThuTkZKZOnUqFChUK9gHxOIwYAddeC8VgkIUkSZIkSQXB7asHcuONoZR7442okxySUaNGcccdd9CpUyfGjRtH1apVo450UI899hhjx45l1apVtG/fPmfKpQ6uV69ejB8/nuOPP56ePXvywAMPULZs2SLPMWrUKPr27cv555/PCy+8UDi/d2+/DeedFwY9NG+e79u89NJL9OzZc6+v3XTTTfs9F1CSJEmSpMJmKXcggwbBW2/BggVRJzlk7733HldeeSUVKlTgiSeeoGvXrlFHUim1YsUK+vfvz1tvvcWDDz7IwIEDC2/YxKWXwrffwvvvF879JUmSJEmKgNtXD+T44+GLL6JOkSdnn302CxYsoHXr1nTv3p0LL7yQFStWRB1LpcjWrVu59957adasGWvWrOGdd95h0KBBhVfILV8OkydDv36Fc39JkiRJkiJiKXcgjRrB5s0l4ly5H6tVqxbjx49n5syZpKam0qxZM2677TZWrVoVdTSVYJmZmTzxxBM0atSIESNG8Ic//IEFCxZw1llnFe6DH3sMTjgBLrmkcJ8jSZIkSVIRs5Q7kMaNw/ulS6PNkU9nn302H3/8MX/+85956623aNiwIVdffTULFy6MOppKkPT0dIYMGUK9evUYPHgwV1xxBcuXL6dv374kJCQU7sNTU+GFF2DgQIjgvDxJkiRJkgqTpdyB1KoVJj2W0FIOICEhgVtuuYVly5Yxbtw4lixZQosWLfj5z3/Oiy++yLZt26KOqGIoHo8za9YsbrzxRo4//nj++te/0rdvX1avXs3w4cM55phjiibIE09A9eph6qokSZIkSaWMpVxumjcvUYMeDiQhIYGrr76aTz75hNdff53k5GRuvPFGatWqxa233srcuXOjjqhiIDU1lWHDhtGoUSPOOussFi5cyKOPPsqXX37JAw88QEpKStGF2bgRRo2CO++ExMSie64kSZIkSUXE6au5uecemDoVPv006iQFbtOmTbz66quMGDGCTz75hOOPP55u3bpx8cUXc+655xb+1kQVC6tXr2by5MlMmTKFmTNnUqlSJa644gr69OnDaaedFl2w3/8e/vQn+PJLqFw5uhySJEmSJBUSS7ncvPYa9OgBmzZBcnLUaQrN/Pnz+cc//sGkSZNYunQpxxxzDF27ds0p6KpUqRJ1RBWQXbt2MW/ePN58800mTZrEokWLSElJoUuXLlxyySV06tSJ8uXLRxvy+++hXj249dZQzkmSJEmSVApZyuUmLQ1q14Zp06Bjx6jTFImlS5cyadIkJk6cyPz584nFYpxxxhl06NCBDh068LOf/YykpKSoY+oQZWdn8+mnn/LOO+8wY8YM3n33XTIyMjjuuOPo1q0b3bt35+yzzy5eKyMfeyyUcV98AUV1fp0kSZIkSUXMUu5gTjoprJYbOjTqJEVuw4YNzJw5kxkzZjBjxgyWLVtG+fLladWqFa1bt6Z169a0atWK4447Luqo+q8tW7Ywb9485s6dy0cffcSHH37Ihg0bOProozn33HPp0KED7du3p/Ge6cLFzebNUL8+3H67q+QkSZIkSaWapdzB3HEHzJ4NH38cdZLIpaamMn36dGbNmsXcuXNZsmQJu3fvpmbNmrRq1YpWrVpx6qmn0qRJE+rVqxd13FJv06ZNLFq0iEWLFjFv3jw++ugjli1bRnZ2NnXr1qV169a0a9eO9u3b07x5c8qUKQFzXe69F0aOhJUroVq1qNNIkiRJklRoLOUO5l//gm7dIDUVatWKOk2xsnXrVj7++GPmzp3L3LlzmTdvHl999RUAycnJnHzyyTRr1oymTZvStGlTTjrpJOrUqUMsFos4ecmyceNGVq5cyeLFi1myZAmLFi1iyZIlpKamAlC1alVOO+20vVYv1iqJv6tr14aVqb/7XZi6KkmSJElSKWYpdzCZmZCSAs8+C7/4RdRpir3NmzezZMkSFi9enFMeLVq0iPT0dADKly/PiSeeSIMGDahfv37O++OOO446deqQXIoHahxIVlYWaWlpfP3113z++eesXLky5+3zzz9n06ZNACQmJnLyySfTtGlTmjRpQrNmzWjSpEnp2T58223wz3/CihXguYWSJEmSpFLOUu5QXHQRlC0bCgPly/r161mxYsVehdOetw0bNuRcV6FCBerWrUutWrWoU6cOtWrVonbt2hx99NGkpKRQvXr1nI+L81TYbdu2kZ6ezsaNG0lPTyc9PZ1vv/2W9evX8/XXX7N27VrWrFnDunXr+Pbbb3Nel5SURP369XPe9pSW9evXp169epQtWzbC76oQffEFNG4MTz8NN90UdRpJkiRJkgqdpdyhGDcOevcO2+tSUqJOU+ps2bKFNWvW7FVWrV27ltTUVNLS0khLS2PDhg3s3Llzr9clJCSQkpJC4+RkMpOTqVatGomJiSQlJVG1alXKly9PxYoVSU5Ozimzqv2/c8r2XL/Hrl27yMjI2OuarVu3smPHjpysWVlZZGZmkpGRwfbt28nIyGDr1q18//33OQXctm3b9vk+U1JSqFGjBrVr1+bYY4/NKR3r1q1LzZo1qVOnDscee2yB/ExLnKuvDuc2LlkCxWkSrCRJkiRJhcRS7lBkZECNGvDnP4dyTpHIyMggPT2dDRs25KxC27V0KT2HDuV/evRgfuXKbN++nW3btrF582a2b9/O999/z5YtW8jOzs61cLsFeBv4IhajatWqe13z4+KucuXKJCYmUrlyZSpVqkRSUtJeH+9Zzffj93s+LhGDFqIwdy60awevvAKXXRZ1GkmSJEmSioSl3KG67DLYtAlmzIg6iX7s0kth6VL49NP8r7CKx6FMmVAK9ehRsPmUu+xsaNsWKlWC6dOjTiNJkiRJUpFxn9ihuuEG6NoVli+Hhg2jTiOA2bNh0iR4/XW3PJZUo0bBggXhTZIkSZKkI4j76Q7VhRfC8ceHKayKXjwO/fpB+/bQuXPUaZQfGzfCb38L/ftDs2ZRp5EkSZIkqUhZyh2qMmXCVMj/+R/Yvj3qNPr738PqqieeiDqJ8mvgQChXDgYPjjqJJEmSJElFzlIuL3r3DkMfxo+POsmRLTsbHnwQrr0WmjePOo3y4/334bnn4PHHoXLlqNNIkiRJklTkLOXyombNUAQ99lgohhSNV1+FFStg0KCokyg/srKgTx+44ALo2TPqNJIkSZIkRcJSLq/uuScUQpMnR53kyBSPw9ChYUpqo0ZRp1F+DBkCqanwzDNRJ5EkSZIkKTKWcnnVqBF06waPPBJ1kiPT5MmwaBHce2/USZQfCxfCH/8Y/v3UrRt1GkmSJEmSIhOLx+PxqEOUOPPmQevWMGkSdO0adZojS8uWUKcOTJxYcPeMx8Mgj1deCSvwVDh27oQ2baBiRZg5M/zMJUmSJEk6Qvl/xfnRsiVccgncd59nyxWlWbNg/nzPkiupfv97WLoURo+2kJMkSZIkHfH8P+P8Gjo0FAxOYi06I0dCixbQqlXUSZRXH34Iw4aFrasNG0adRpIkSZKkyFnK5VejRnDddfDb38K2bVGnKf3S0+Ef/4Dbb486ifIqMxN69YKOHcPUVUmSJEmSZCl3WIYOhY0b4bHHok5S+o0ZA+XLw1VXRZ1EedW3L2zeDGPHQiwWdRpJkiRJkooFS7nDUbNmmAL66KPwxRdRpym94nF49lm4/vowJEAlx6uvwvPPh3PkataMOo0kSZIkScWGpdzhGjAAjj8efv3rqJOUXjNnwooVbn0saVauhJtvhl/+0inFkiRJkiT9P5Zyh6tcOfjLX2DyZHjttajTlE4TJsCpp8LJJ0edRIcqKwuuvDIU1o8/HnUaSZIkSZKKHUu5gtCxI9xwQxhCsHFj1GlKl3gc/vlP6N496iTKi1//GpYtg1degaSkqNNIkiRJklTsWMoVlOHDISEhbGdVwfnoI/j6a7jkkqiT6FC9+io8/TQ880yYUixJkiRJkvZhKVdQqlSBp56CcePCVlYVjIkToV49aN486iQ6FJ99BjfdBLfdBldfHXUaSZIkSZKKLUu5gtS1a9jG2rs3pKVFnaZ0mDQJLrss6hQ6FBkZcPnl0LRpWDkqSZIkSZIOyFKuoP3lL5CSElYJZWdHnaZkW7UqnEvWpUvUSXQw2dnhd37TprB9tXz5qBNJkiRJklSsWcoVtIoV4cUX4cMP4Q9/iDpNyfbuu5CYCG3aRJ1EB/Pb38Jbb4VCrnbtqNNIkiRJklTsWcoVhjPOgGHD4P77YebMqNOUXO+9Fwq5xMSokyg3EyaE3/cRI+DMM6NOI0mSJElSiWApV1h+/eswMfTKKyE1Neo0JdPcudCuXdQplJv58+H66+H228OAB0mSJEmSdEgs5QpLLAbPPQfVq8MVV8COHVEnKlm+/x6WL4fTTsvzSzdt2sTIkSPp0KED1atXJykpiZNOOolrrrmGhQsXFkLY4I033qBhw4YkJCQU2jOKlbS0UDyfdRY88UTUaSRJkiRJKlEs5QpT5crwj3/AokVw661RpylZFi2C3bvh1FPz/NK7776bvn370q1bNz777DPS09MZM2YMn3zyCaeffjqTJk0q0KgrV66ka9euDBo0iPXr1xfovYutzEy46KLwO/7SS3CkFJGSJEmSJBUQS7nCdvLJ8MorMG6cgx/yYtkySEqCE0/M18tvvPFG+vXrR82aNalQoQJnnXUW48ePZ/fu3dxzzz0FGvW3v/0t7dq14+OPP6Zy5coFeu9iaffuMGk1LQ3eeAOqVo06kSRJkiRJJY7LW4pCp06hkLvrLmjYELp1izpR8bdqFdSrF7YB59Ho0aP3+/VTTjmFpKQkVq5cSTweJ5aPe+/Pc889R1JSUoHcq0S44w6YNg1mzAh/R5IkSZIkKc9cKVdUBgyA3r3DCqNZs6JOU/ytWgUnnFCgt9y6dSvbtm2jadOmBVbIAUdWITd4MDz7LLz4IrRtG3UaSZIkSZJKLEu5ovT00+EcrosuggULok5TvK1bB7Vr53y6dOlSunfvTpUqVahQoQKtWrViypQpdOzYkVgsRiwWo3fv3rne8tVXXwXgvvvuy/W6gnhWqfT00/DQQzByJFx2WdRpJEmSJEkq0dy+WpTKlg0rjLp1C1ta33sPGjeOOlXxtHEjtGgBwOeff07btm2pWLEiEyZMoG3btnz55Zf079+fTz/9lPLly7N9+/Zcb7d+/XoGDhxI7969ueKKKw54XUE8q1R66SXo2xeGDQsrPiVJkiRJ0mFxpVxRK1cuTGRt1AjOOw++/DLqRMXTpk05AwTuvfdeNm/ezJNPPsl5551HpUqVaNKkCePHj2fr1q0HvVV6ejqdOnXi3HPPZeTIkblee7jPKpWmT4deveC22+A3v4k6jSRJkiRJpYKlXBQqVIApU+Doo0Mxt3591ImKn6wsSEwEYOrUqQBccMEFe11yzDHH0PggKw23bt3KBRdcwMknn8zf/vY3ypYtm+v1h/OsUmnePOjeHS6/HJ58Muo0kiRJkiSVGpZyUalSBV5/HXbvhi5d4Lvvok5UvGRnQ5kyZGVlkZGRQWJiIpUqVdrnsmrVqh3wFrt27aJHjx7Url2b559//qCFXNbOnfl+Vqm0YkX43TznHBg7Fsr4nwtJkiRJkgqK/5cdpWOPhWnTIDUVzj8/bNnUXsqXL0/lypXZvn07mZmZ+/z5N998c8DX9unTh6ysLF555RUSEn44PrFBgwbMmTNn32cddVS+n1XqpKaGVZwnnggvvwwJHj8pSZIkSVJBspSL2oknwgcfwLffwplnQlpa1ImKh0qVICMDgM6dOwM/bC3dY926dSxfvny/Lx8yZAhLlixh8uTJlC9f/pAfm59nlTrffBMKueRkeOMNqFgx6kSSJEmSJJU6lnLFwQknwDvvwM6d0KEDrFkTdaLoVasGmzcDMHToUKpXr07//v2ZNm0amZmZLF68mBtuuIGaNWvu89KxY8fyu9/9jrlz51K5cmVisdhebytXrjzgY/P6rFLnm2/C7+DOnTB1avh7kCRJkiRJBc5Srrg47jh4/30oXx7OOiuc53Ukq14d0tMBqF+/PrNnz6Zly5Zcfvnl1KhRgz59+jBo0CAaNGiwz0snTJiQ78fm9VkAU6ZMySn8UlNT2b17d87no0ePzneWIvfNN/Dzn8OOHaEkPvbYqBNJkiRJklRqeVBUcVKjBsycCRdeCGefDf/7v9CsWdSpolGvHvznPzmfNmzYkIkTJx7SS6dMmXJYj87LswC6dOlCPB4/rGdGbk8hl5UVCrnataNOJEmSJElSqeZKueKmWjV46y046aSwjXD+/KgTRaN+fchlm6kKkIWcJEmSJElFzlKuOEpODud5nXEGnHsuTJoUdaKi17BhmAD63XdRJyndLOQkSZIkSYqEpVxxVaECTJkCvXrBpZfCkCFRJyparVtDPA5z5+73j1966SVisRjTp08nKyuLWCxG7969CyVKUT6rSO0Z6mAhJ0mSJElSkYvFS/xhWEeAJ5+EO+8MBd2IEXDUUVEnKhonnAA33ACDBxfuc+JxKFMGXnkFevQo3GcVF+vXhxVyO3fCjBkWcpIkSZIkFTFXypUE/fqFVXOvvgqdO8PmzVEnKhpnngnvvht1itInLS1si961yxVykiRJkiRFxFKupOjUCd5/H1asgJYtYfnyqBMVvj3f85FSQhaFzz8PZWcsFgq5Y4+NOpEkSZIkSUckS7mSpHlzmD07DIL42c9g2rSoExWuzp3D1tK33446SemwZAmccw6kpIQViLVqRZ1IkiRJkqQjlqVcSXPssfDee3DeeaG0evBByM6OOlXhqF4d2rQJW3d1eObODYVcw4YwfTocc0zUiSRJkiRJOqJZypVEFSvC+PHw9NPw0EOhoPvmm6hTFY5LL4WJE2HbtqiTlFyvvx6mrJ55Jrz5ZlhpKUmSJEmSImUpV5Ldcgt8+CF88QWccQbMmRN1ooJ31VWwdWsok5R348fDJZfA5ZfDhAmQmBh1IkmSJEmShKVcyXf66TBvHjRpEiZqPvlk1IkKVq1a4fsaPz7qJCXPU0/BddfBL38JY8dCQkLUiSRJkiRJ0n9ZypUGKSlhi+KgQfDrX8M118CWLVGnKjjXXBPOlduwIeokJcejj0LfvjBsWChqY7GoE0mSJEmSpB+xlCstypSBBx4I2zxnzIBTT4X33486VcG48kqoUCGs9lLudu2CW2+F++6D0aPhnnuiTiRJkiRJkvbDUq60Of98+PRTOOWUMG2zXz/YsSPqVIenQgW4+moYORLi8ajTFF8ZGXDxxfDii/Daa3DjjVEnkiRJkiRJBxCLx205Sq1x4+D226Fx41DUNGoUdaL8W7QImjeHadOgY8fDu1fHjvDRR3sXfNu3Q7lyYcXhHkcdBQsXQt26h/e8opCWBl26wLp18M9/hsEfkiRJkiSp2HKlXGn2i1+EVXPly0OLFuFssZLawTZrFgY+DB++99fT0+Huu2HnzkO/V+fOYVVZZuYPb7t2wfff//D51q1Qv37JKOQ+/RTatAkrImfPtpCTJEmSJKkEsJQr7U44AWbOhLvugjvvhIsugjVrok6VP3feCVOnwpIlsG0bPPII1KsHjz8OK1ce+n169tx7Rdz+lC0bSs3i7q234KyzwirIDz6A44+POpEkSZIkSToEbl89ksyeHc4ZS00Nhdattx68nCpOsrOhSROoWRP+85+wSm7XrjBZdMIEuPTSQ7/XWWfBhx+Ge+5PmTJhS2iNGgWTvTA8+yzcdlsoD0eODNttJUmSJElSiVCCGhkdtrZtw1bH++6DAQPg7LNh6dKoUx26GTMgKwveew+++TbJrAgAAA8iSURBVCYUchDKqLx+H9ddF8q8/SlbNmyVLa6FXDwOQ4ZAnz7h7/K55yzkJEmSJEkqYSzljjRHHQW/+Q3MmxfOIGvRIhQ8xXlC60cfwZlnwnnnwZdfhtVtP17guXs3fPZZ3u7Zo8eBSzkIpV1x9N130K0bPPoo/P3v4e9OkiRJkiSVOJZyR6rmzcP2zSFDQsHTpg0sWBB1qn3de2/INmdO+Hx/20137w5TUvOiWrVQ8pUtu++flSkDl1yS96yFbcWKsNpx3rywavDKK6NOJEmSJEmS8slS7kiWkBBWzS1cCJUqQatWcMcdsHlz1Ml+cOedcPrpBz/7bsWKA58PdyDXXrvvaxISwjCMKlXydq/DtXZtKBcP5H//F1q3DpN058wJ5ZwkSZIkSSqxLOUEDRvCu+/CmDFhYEL9+vDkk3kvuQpDSkrI1qHD/le17ZGVBV99lbd7d+8eSq4f2707lHVFKR6Hq66CBx7Y/5+PGhWKwgsugFmznLAqSZIkSVIpYCmnIBYLUzyXLg2l1J13hpVZH30UdTKoUAGmTAn5clsx95//5P2+3brtPSQhKQkuvDB/OfPrmWfC8IqhQ+HNN3/4elYW3HBDmLD60EPhDLkKFYo2myRJkiRJKhSWctpb1aphldy8eaGsatcO+vaNfktrQkKYMnr33fv/83Ll8l7KAVxzDezcGT4+6ii4/PJQzBWVL78MBSiEYvSqq2D1akhLC9NxX3sNJk4M24wlSZIkSVKpYSmn/WvRAj74IGxpfeWVsKX10UejndIai8Ejj8Cf/hQ+/vH01Ozs/JVynTpBcnL4eOfOUNIVlXgcbrrph1IwOxu2bYOLL4bTToOMDJg/P3wuSZIkSZJKFUs5HdiPt7T26gWDB8Opp8Lrr0ebq18/GDcubGXds5111668T2CFsDruqqvCx9WqhbPrisro0WGK6p5SDsLHS5dCo0ZhoMNJJxVdHkmSJEmSVGQs5XRw1arBH/8YJpyecUZYufXzn8Mnnxza67dtC6vCCtK118LUqWFQw54BEIe6Um7jRliyJKwEfPttqFcvfL1NG5g5E955B/7977CFNLeJqIcjLQ1+/ev9/1x27YL334dp0wrn2ZIkSZIkKXKxeLyg2xKVerNmhXPQ5s8PgwgefBBq1Trw9fffD999F86q+/GW04Iwe3bYgpqZGbZ/rl0LNWuGsmvJEliwILxfvBiWLYPUVNi+/dDvX7Ys1KgRtu82aQJNm0Lz5tCyJSQm5j/3BReE8u/Hq+R+LBYL9//3v8OqOUmSJEmSVKpYyil/4nGYMCEMIFi/Hnr3hvvug5/8ZO/rtmyB2rVh69YwMKIwirnPPgsr99atC8/4+uuw0mzDhrCS7qc/DYXaT38KdeuGArF27bACMDExXDN6NNx6a8iZnR1W061fH0q8tWtDoffZZ7BoEWzaFF7TqhWce26Y1tq69aF/X88/H8rMg/3TS0iAxo3D0I3DKQAlSZIkSVKxYymnw7NjB4wdG86b27oVbr8d7r33h+EJDz8MQ4aELZllysAdd/wwqKEgfP11OF/upZdCYZaUBOedF8qys8+GU04J5dbBxOOHnmn1anjvPXj33bDdddWqUPJ17x621bZpc+DXpqWFoi0zM/dSrly58LOtWTMM2+jc+dCySZIkSZKkEsFSTgVj61b4619h2LAwPOGuu8LquQYNYPPmH64rUyZ8feTI/Bdz8Xg4b23ECJgyJax4u+SSUMZt3QrXX18w39OhWrQIJk4MKwcXLQpF4K23hoKuUqW9r+3WDd58c//bVvcUcbVqQY8e4a1dux+GWUiSJEmSpFLDUk4Fa8MGeOQReOopqFw5bAP9/8MSDqeYe/vtsBJv3jw4/XS45Ra47rqwQq44+PhjGDUK/va3kOn222HAAKhSJXztuuv2XiGXkBBWEdatG4rFHj3gZz8r+C2+kiRJkiSpWLGUU+FYtQpatAgDHvYnr8Xc3Llh6+vHH4dtooMHw6mnFmzmgrRhAwwfHlYPli8fzt576KFwxt6eIq5xY7j6arj00nDmnSRJkiRJOmJYyqlwPP10GLqQnX3gaw6lmNu0CQYODIMYzj03FF2nnFIokQtFejoMHQpPPBFWyDVqBDfeGIq4Bg2iTidJkiRJkiJyCCfgS3m0c2coog7W92Znh7IN9l/MzZoF11wTzll74YWwqqykSUkJW2wTEsJQiE8+CWVk/fpRJ5MkSZIkSRHyBHkVvBdfhNTUg5dy8EMxN2DA3tc/8gi0bx9WxS1aVDILuT0aNYJHH4XZs+H3vw9n4l100d4DMCRJkiRJ0hHF7asqeO3ahQJqj7Jlw0qx3bvDWWr7U6ZM2O76+ONhOMJzz8Ef/wi/+lXpG3owdy5cdhlUrx4msdauHXUiSZIkSZJUxCzlVDi+/x6++gq+/jq8ffUVrFkDX34JX3wBaWnhmv+vQYPwZy+9BBdfXPS5i8qaNdC5M2RkwDvvwIknRp1IkiRJkiQVIUs5Ree770I5taewe+op+OwzePhhuOeeqNMVvk2b4LzzwkTWWbOgRo2oE0mSJEmSpCJiKafi4b77wtbVf/0Lzj8/6jRF55tv4MwzITk5FHOJiVEnkiRJkiRJRcBBD4re22+HwQ5PP31kFXIAP/kJTJ0KK1fC3XdHnUaSJEmSJBURV8opWps2QdOmcNZZ4Ry5I9XLL0PPnjBlClx4YdRpJEmSJElSIXOlnKL10ENhIuvIkVEnOaiXX36ZU089laSkJGKxGLFYjMWLFxfMza+8MrwNGAA7dxbMPSVJkiRJUrFlKaforFoVhjsMGQJVqxb47TMzMznppJPo0qXLYd/rgw8+oGfPnpx//vl8++23fP7559SpU6cAUv7IsGFhOu2oUQV7X0mSJEmSVOxYyik6f/kL1K4NN99cKLePx+NkZ2eTnZ192Pd69dVXicfj9OvXj0qVKlG/fn3WrFlD06ZNCyDpf9WrB7fcAsOHg7vKJUmSJEkq1SzlFI0dO+Bvf4Mbb4SEhEJ5ROXKlVm5ciVvvPHGYd9rzZo1AKSkpBz2vXJ1221hBeHMmYX7HEmSJEmSFClLOUVj+nTYsAGuvz7qJIdk9+7dRfOgxo2hVSsYP75onidJkiRJkiJhKadovP9+KKAK+ly2/5o0aVLOMIZYLMb27dv3+/XVq1dz5ZVXUrVqVVJSUujSpQsrV67c5z6TJ08GyBny0KZNm0LJDUDHjjBrVuHdX5IkSZIkRc5STtGYMwfati2023fv3p14PE63bt1y/Xr//v3p378/qampvPzyy8yYMYOePXse8Ppt27YRj8eZM2dOoWWnXTtYtgw2biy8Z0iSJEmSpEhZyikaq1dDo0ZRp6B37960bduWihUr0rFjRy666CLmzZvHhg0bogvVsGEY9PDVV9FlkCRJkiRJhcpSTtFIT4fCHppwCFq2bLnX53Xr1gUgLS0tijjBnp9LlMWgJEmSJEkqVJZyisb330NSUtQpqFKlyl6flytXDoDs7Owo4gQVK4b3W7dGl0GSJEmSJBUqSzlFo1o12LQp6hTF056z5KpXjzaHJEmSJEkqNJZyisbRR8O330adonja83M5+uhoc0iSJEmSpEJjKadoNGkC//531CmKpwULIDER6tePOokkSZIkSSoklnKKRrt2MHt2mDJaCCZNmkQsFmPy5MkAJCUlce211zJnzpx9vn7//fcDEIvFePTRRwFo0aIFXbp02e99YrEYc+bMKZTcQPi5nHEG/Pd8O0mSJEmSVPrE4vFCakWk3Hz6KZxyCsyaBT/7WdRpio9du+D44+Hmm2HIkKjTSJIkSZKkQuJKOUWjeXNo0QLGjIk6SfHyxhuwdi1cd13USSRJkiRJUiFypZyi89RTcM898PnnUKtW1GmKhw4doGxZmDYt6iSSJEmSJKkQWcopOtu3Q+PGcP75MGpU1Gmi98YbcNFF8P77cOaZUaeRJEmSJEmFyFJO0XrhBbjhhjDcoGXLqNNEZ9s2OP10aNQIJk6MOo0kSZIkSSpklnKKVnY2dOoEq1bBggWQnBx1omj88pfw0kvw739DvXpRp5EkSZIkSYXMQQ+KVpky8Pzz8N13YeJodnbUiYre3/4GzzwDzz5rISdJkiRJ0hHCUk7Rq1ULXn4ZJk+GAQOiTlO03noLbrwR7roLLr886jSSJEmSJKmIJEQdQAKgfXt48UW46ipISoJhwyAWizpV4Xr7bbjssvA9P/po1GkkSZIkSVIRcqWcio/LL4f/+R8YPhx69YKdO6NOVHhefDFMWu3eHUaPLv0FpCRJkiRJ2oulnIqX666DKVPCBNIOHWDNmqgTFaydO+Huu+EXv4B+/cL02aOOijqVJEmSJEkqYpZyKn7OPx8+/BA2boRTT4XXXos6UcH4/HM480wYMSKsCHzsMVfISZIkSZJ0hLKUU/HUtCnMmweXXhrOXevWDVavjjpV/mzfDkOGQLNmsGMHzJ8P118fdSpJkiRJkhQhSzkVXxUqwLPPwvTpsGIFNGkC994L6elRJzs0u3bBuHEh9/Dh8NBD8NFH0Lhx1MkkSZIkSVLEYvF4PB51COmgduyAv/wlTCndvh1uvz281akTdbJ9bdsGf/97mCC7enU4P+7BB+HYY6NOJkmSJEmSiglLOZUsW7fC00/DH/8IGzaECaa33BLOoYt6YMLixWGS6rhxIec118D998OJJ0abS5IkSZIkFTuWciqZduwIE1qfeQZmzoRq1aBr13AGXfv2UKlS4WfYvRsWLIBJk8IwiqVLoX59uPlmuOEG+MlPCj+DJEmSJEkqkSzlVPJ98QX84x+hpJszB8qUgdNOg7PPhlatwtCIk06ChITDe05qKixZAh9/DLNmhbfvvoN69UIZeOml0LZteL4kSZIkSVIuLOVUuqxfD+++C++9F97/5z9hRVu5ctCwIRx3HNSsGc6iq1IlrKhLSIDKlSErC77/PrzfsiXc6+uvYe1aWL4cNm0Kz6hdG848M5R+55wTBjlIkiRJkiTlgaWcSrft20Mxt3gxLFsWSrZ168L7jIzwtnMnZGaG4q5iRUhMDCVdjRqhgKtZM6y0a9IEmjWD6tWj/q4kSZIkSVIJZyknSZIkSZIkFTEPv5IkSZIkSZKKmKWcJEmSJEmSVMQs5SRJkiRJkqQilgC8GnUISZIkSZIk6Ujyf8oaNi7hjbucAAAAAElFTkSuQmCC", - "text/plain": [ - "" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# draw the dep_graph_copy, which is the first dag\n", - "draw_dag(dep_graph_copy_copy2, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png\n" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'qubit_used_2' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/home/parallels/Documents/pyquafu/src/quafu/dagcircuits/labquafu_dag.ipynb Cell 57\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39m# relabel by reconstructed_circuit , circuit to dag again\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m qubit_num \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39m(qubit_used \u001b[39m|\u001b[39m qubit_used_2) \u001b[39m# 并集求总的qubit数\u001b[39;00m\n\u001b[1;32m 3\u001b[0m re_circuit \u001b[39m=\u001b[39m dag_to_circuit(dep_graph_copy, qubit_num)\n\u001b[1;32m 5\u001b[0m \u001b[39m# 构建dag\u001b[39;00m\n", - "\u001b[0;31mNameError\u001b[0m: name 'qubit_used_2' is not defined" - ] - } - ], - "source": [ - "# # relabel by reconstructed_circuit , circuit to dag again\n", - "# qubit_num = len(qubit_used | qubit_used_2) # 并集求总的qubit数\n", - "# re_circuit = dag_to_circuit(dep_graph_copy, qubit_num)\n", - "\n", - "# # 构建dag\n", - "# re_dep_graph = circuit_to_dag(re_circuit,measure_flag= False) # 更新为新的函数名\n", - "\n", - "# # 可视化dag\n", - "# draw_dag(re_dep_graph, output_format=\"svg\") # 或者使用 \"png\" 作为输出格式" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 're_circuit' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/home/parallels/Documents/pyquafu/src/quafu/dagcircuits/labquafu_dag.ipynb Cell 58\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m re_circuit\u001b[39m.\u001b[39mdraw_circuit()\n", - "\u001b[0;31mNameError\u001b[0m: name 're_circuit' is not defined" - ] - } - ], - "source": [ - "# re_circuit.draw_circuit()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## nodelist_to_dag" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [], - "source": [ - "def nodelist_to_dag(op_nodes: List[Any]) -> DAGCircuit:\n", - " # Starting Label Index\n", - " i = 0\n", - " \n", - " # A dictionary to store the last use of any qubit\n", - " qubit_last_use = {}\n", - " \n", - " # g = nx.MultiDiGraph() # two nodes can have multiple edges\n", - " # g = nx.DiGraph() # two nodes can only have one edge\n", - " g = DAGCircuit() \n", - " \n", - " # Add the start node \n", - " # g.add_node(-1,{\"color\": \"green\"})\n", - " g.add_nodes_from([(-1, {\"color\": \"green\"})])\n", - " \n", - " # deepcopy the circuit to avoid modifying the original circuit\n", - " # gates = copy.deepcopy(circuit.gates) # need to import copy\n", - " # change to: gate = copy.deepcopy(input_gate) in gate_to_node()\n", - "\n", - " for op_node in op_nodes:\n", - " # transform gate to node\n", - " hashable_gate = copy.deepcopy(op_node)\n", - " g.add_node(hashable_gate,color=\"blue\")\n", - " \n", - " # Add edges based on qubit_last_use; update last use\n", - " for qubit in hashable_gate.pos:\n", - " if qubit in qubit_last_use:\n", - " g.add_edge(qubit_last_use[qubit], hashable_gate,label=f'q{qubit}')\n", - " else:\n", - " g.add_edge(-1, hashable_gate,label=f'q{qubit}',color=\"green\")\n", - " \n", - " qubit_last_use[qubit] = hashable_gate\n", - "\n", - " \n", - " # Add the end node\n", - " # g.add_node(float('inf'),{\"color\": \"red\"})\n", - " g.add_nodes_from([(float('inf'), {\"color\": \"red\"})])\n", - " \n", - " for qubit in qubit_last_use:\n", - " g.add_edge(qubit_last_use[qubit], float('inf'),label=f'q{qubit}',color=\"red\")\n", - "\n", - " # update the qubits_used, cbits_used, num_instruction_nodes\n", - " g.qubits_used = g.update_qubits_used()\n", - " g.cbits_used = g.update_cbits_used()\n", - " g.num_instruction_nodes = g.update_num_instruction_nodes()\n", - " \n", - " return g" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q[0] --H-------\n", - " \n", - "q[1] --H----+-- M->c[2]\n", - " | \n", - "q[2] --X----*-- M->c[1]\n" - ] - } - ], - "source": [ - "# example simple3 circuit\n", - "simple3 = QuantumCircuit(3)\n", - "simple3.h(0)\n", - "simple3.h(1)\n", - "simple3.x(2)\n", - "simple3.cnot(2,1)\n", - "simple3.measure([2,1], [1,2])\n", - "\n", - "simple3.draw_circuit()" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[0{H(0)}, 1{H(1)}, 2{X(2)}, 3{CX(2,1)}]" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "i = 0 \n", - "op_nodes = [] \n", - "for gate in simple3.gates:\n", - " op_nodes.append(gate_to_node(gate,specific_label=i))\n", - " i += 1\n", - "\n", - "op_nodes\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "nodesdag = nodelist_to_dag(op_nodes[1:])" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[1{H(1)}, 2{X(2)}, 3{CX(2,1)}]" - ] - }, - "execution_count": 52, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "nodes_list = nodesdag.nodes_list()\n", - "nodes_list" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [], - "source": [ - "# # Add measure_gate node\n", - "qm = Any\n", - "qm.name = \"measure\" \n", - "qm.paras, qm.duration, qm.unit = [None,None,None]\n", - "qm.pos = copy.deepcopy(simple3.measures) # circuit.measures is a dict\n", - "measure_gate = InstructionNode(qm.name, qm.pos, qm.paras, qm.duration, qm.unit, label=\"m\")\n", - "# nodes_list.append(measure_gate)\n", - "# nodes_list" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2\n", - "1\n" - ] - }, - { - "data": { - "text/plain": [ - "({1, 2}, dict_keys)" - ] - }, - "execution_count": 54, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "for qubit in measure_gate.pos:\n", - " print(qubit)\n", - "\n", - "set(measure_gate.pos),type(measure_gate.pos.keys())" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{1, 2}" - ] - }, - "execution_count": 55, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "nodesdag.qubits_used" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## nodes_list qubit mapping" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [], - "source": [ - "# nodes_qubit_mapping_dict \n", - "def nodelist_qubit_mapping_dict(nodes_list):\n", - " '''\n", - " Args:\n", - " nodes_list: a list of nodes\n", - " Returns:\n", - " nodes_qubit_mapping_dict: a dict about keys are the qubits used by the nodes and values are the new qubits\n", - " '''\n", - " nodes_list_qubits_used = set()\n", - " for node in nodes_list:\n", - " if hasattr(node, 'pos') and node.pos is not None:\n", - " nodes_list_qubits_used = nodes_list_qubits_used | set(node.pos)\n", - " \n", - " mapping_pos = list(range(len(nodes_list_qubits_used))) \n", - " # mapping, get a dict\n", - " nodes_qubit_mapping_dict = dict(zip(sorted(list(nodes_list_qubits_used)), mapping_pos))\n", - " nodes_qubit_mapping_dict\n", - "\n", - " return nodes_qubit_mapping_dict\n", - "\n", - "def nodelist_qubit_mapping_dict_reverse(nodes_list):\n", - " '''\n", - " Args:\n", - " nodes_list: a list of nodes\n", - " Returns:\n", - " nodes_qubit_mapping_dict_reverse: a dict about keys are the new qubits and values are the qubits used by the nodes\n", - " ''' \n", - " nodes_qubit_mapping_dict = nodelist_qubit_mapping_dict(nodes_list)\n", - " # reverse mapping, get a dict\n", - " nodes_qubit_mapping_dict_reverse = {value: key for key, value in nodes_qubit_mapping_dict.items()}\n", - " \n", - " return nodes_qubit_mapping_dict_reverse\n" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": {}, - "outputs": [], - "source": [ - "# a function to map nodes_list\n", - "def nodes_list_mapping(nodes_list, nodes_qubit_mapping_dict):\n", - " '''\n", - " Args:\n", - " nodes_list: the nodes list of instruction nodes\n", - " nodes_qubit_mapping_dict: the dict of the mapping qubits\n", - "\n", - " return: \n", - " nodes_list_mapping: the nodes_list after mapping qubits\n", - " '''\n", - " nodes_qubit_mapping_dict \n", - " nodes_list_mapping = []\n", - " for node in nodes_list:\n", - " node_new = copy.deepcopy(node)\n", - " if hasattr(node, 'pos') and node.pos is not None:\n", - " if isinstance(node.pos, list):\n", - " node_new.pos = [nodes_qubit_mapping_dict[qubit] for qubit in node.pos]\n", - " elif isinstance(node.pos, dict):\n", - " node_new.pos = {}\n", - " # the values of the dict are void, so we need to copy the values from the original dict\n", - " for qubit in node.pos:\n", - " node_new.pos[nodes_qubit_mapping_dict[qubit]] = copy.deepcopy(node.pos[qubit])\n", - " nodes_list_mapping.append(node_new)\n", - " return nodes_list_mapping\n" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original nodes_list:\n", - " [1{H(1)}, 2{X(2)}, 3{CX(2,1)}]\n", - "mapped nodes_list:\n", - " [1{H(0)}, 2{X(1)}, 3{CX(1,0)}]\n", - "mapped nodes_list_reverse:\n", - " [1{H(1)}, 2{X(2)}, 3{CX(2,1)}]\n" - ] - } - ], - "source": [ - "nodes_qubit_mapping_dict = nodelist_qubit_mapping_dict(nodes_list)\n", - "nodes_qubit_mapping_dict_reverse = nodelist_qubit_mapping_dict_reverse(nodes_list)\n", - "\n", - "mapped_nodes_list = nodes_list_mapping(nodes_list, nodes_qubit_mapping_dict)\n", - "\n", - "\n", - "mapped_nodes_list_reverse = nodes_list_mapping(mapped_nodes_list, nodes_qubit_mapping_dict_reverse)\n", - "# nodes_list,mapped_nodes_list,mapped_nodes_list_reverse\n", - "print(\"original nodes_list:\\n\", nodes_list)\n", - "print(\"mapped nodes_list:\\n\", mapped_nodes_list)\n", - "print(\"mapped nodes_list_reverse:\\n\", mapped_nodes_list_reverse)\n", - "\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### nodes_list to dag for qubit mapping\n", - "- original nodes_list to dag\n", - "- new nodes_list after qubit mapping to dag\n", - "- new nodes_list after qubit inverse mapping to dag" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 59, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# draw the nodesdag, which is the original dag\n", - "nodesdag = nodelist_to_dag(nodes_list)\n", - "draw_dag(nodesdag, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# draw the nodesdag\n", - "nodesdag = nodelist_to_dag(mapped_nodes_list)\n", - "draw_dag(nodesdag, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 61, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# draw the nodesdag\n", - "nodesdag = nodelist_to_dag(mapped_nodes_list_reverse)\n", - "draw_dag(nodesdag, output_format=\"png\") # 或者使用 \"svg\" 作为输出格式,默认为png" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 2. Transforming DAG to QuantumCircuit" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "NodeView((-1, 0{CX(0,1)}, 1{CX(1,0)}, 2{X(2)}, 3{CX(2,1)}, 4{CP(1,0)}(1.571), 5{barrier(0,1,2)}, 6{RXX(0,1)}(1.571), 7{delay(0)}, 8{CSWAP(0,1,2)}, 9{MCX(0,1,2)}, 10{MCY(0,1,2)}, 11{MCZ(0,1,2)}, 12{CT(2,1)}, inf))" - ] - }, - "execution_count": 62, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dep_graph.nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "%3\n", - "\n", - "\n", - "\n", - "-1\n", - "\n", - "-1\n", - "\n", - "\n", - "\n", - "0{CX(0,1)}\n", - "\n", - "0{CX(0,1)}\n", - "\n", - "\n", - "\n", - "-1->0{CX(0,1)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "-1->0{CX(0,1)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "1{X(2)}\n", - "\n", - "1{X(2)}\n", - "\n", - "\n", - "\n", - "-1->1{X(2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "2{CX(1,0)}\n", - "\n", - "2{CX(1,0)}\n", - "\n", - "\n", - "\n", - "0{CX(0,1)}->2{CX(1,0)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "0{CX(0,1)}->2{CX(1,0)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "3{CX(2,1)}\n", - "\n", - "3{CX(2,1)}\n", - "\n", - "\n", - "\n", - "1{X(2)}->3{CX(2,1)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "2{CX(1,0)}->3{CX(2,1)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "4{CP(1,0)}(1.571)\n", - "\n", - "4{CP(1,0)}(1.571)\n", - "\n", - "\n", - "\n", - "2{CX(1,0)}->4{CP(1,0)}(1.571)\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "3{CX(2,1)}->4{CP(1,0)}(1.571)\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "5{barrier(0,1,2)}\n", - "\n", - "5{barrier(0,1,2)}\n", - "\n", - "\n", - "\n", - "3{CX(2,1)}->5{barrier(0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "4{CP(1,0)}(1.571)->5{barrier(0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "4{CP(1,0)}(1.571)->5{barrier(0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "6{RXX(0,1)}(1.571)\n", - "\n", - "6{RXX(0,1)}(1.571)\n", - "\n", - "\n", - "\n", - "5{barrier(0,1,2)}->6{RXX(0,1)}(1.571)\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "5{barrier(0,1,2)}->6{RXX(0,1)}(1.571)\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "8{CSWAP(0,1,2)}\n", - "\n", - "8{CSWAP(0,1,2)}\n", - "\n", - "\n", - "\n", - "5{barrier(0,1,2)}->8{CSWAP(0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "6{RXX(0,1)}(1.571)->8{CSWAP(0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "7{delay(0)}\n", - "\n", - "7{delay(0)}\n", - "\n", - "\n", - "\n", - "6{RXX(0,1)}(1.571)->7{delay(0)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "9{MCX(0,1,2)}\n", - "\n", - "9{MCX(0,1,2)}\n", - "\n", - "\n", - "\n", - "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "8{CSWAP(0,1,2)}->9{MCX(0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "7{delay(0)}->8{CSWAP(0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "10{MCY(0,1,2)}\n", - "\n", - "10{MCY(0,1,2)}\n", - "\n", - "\n", - "\n", - "9{MCX(0,1,2)}->10{MCY(0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "9{MCX(0,1,2)}->10{MCY(0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "9{MCX(0,1,2)}->10{MCY(0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "11{MCZ(0,1,2)}\n", - "\n", - "11{MCZ(0,1,2)}\n", - "\n", - "\n", - "\n", - "10{MCY(0,1,2)}->11{MCZ(0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "10{MCY(0,1,2)}->11{MCZ(0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "10{MCY(0,1,2)}->11{MCZ(0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "12{CT(2,1)}\n", - "\n", - "12{CT(2,1)}\n", - "\n", - "\n", - "\n", - "11{MCZ(0,1,2)}->12{CT(2,1)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "11{MCZ(0,1,2)}->12{CT(2,1)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "m{measure(0,1,2=>0,1,2)}\n", - "\n", - "m{measure(0,1,2=>0,1,2)}\n", - "\n", - "\n", - "\n", - "11{MCZ(0,1,2)}->m{measure(0,1,2=>0,1,2)}\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "12{CT(2,1)}->m{measure(0,1,2=>0,1,2)}\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "12{CT(2,1)}->m{measure(0,1,2=>0,1,2)}\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "\n", - "inf\n", - "\n", - "inf\n", - "\n", - "\n", - "\n", - "m{measure(0,1,2=>0,1,2)}->inf\n", - "\n", - "\n", - "q0\n", - "\n", - "\n", - "\n", - "m{measure(0,1,2=>0,1,2)}->inf\n", - "\n", - "\n", - "q1\n", - "\n", - "\n", - "\n", - "m{measure(0,1,2=>0,1,2)}->inf\n", - "\n", - "\n", - "q2\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# 从dag中重建量子电路\n", - "reconstructed_circuit = dag_to_circuit(dep_graph, simple.num) # 更新为新的函数名\n", - "\n", - "# 构建dag\n", - "dep_graph = circuit_to_dag(reconstructed_circuit) # 更新为新的函数名\n", - "\n", - "# 可视化dag\n", - "draw_dag(dep_graph, output_format=\"svg\") # 或者使用 \"png\" 作为输出格式" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q[0] --*----+---------P(1.571)----||-------#---------Delay(100ns)----*----*----*----*------- M->c[0]\n", - " | | | || RXX(1.571) | | | | \n", - "q[1] --+----*----+-------*--------||-------#-------------------------x----*----*----*----T-- M->c[1]\n", - " | || | | | | | \n", - "q[2] --X---------*----------------||---------------------------------x----X----Y----Z----*-- M->c[2]\n" - ] - } - ], - "source": [ - "reconstructed_circuit.draw_circuit()" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "edge = {'label': 'q23'}\n", - "int(edge['label'][1:]) == 23" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [], - "source": [ - "from quafu import QuantumCircuit" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "ycquafu", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.15" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -}