From fc3c293e22ad474e70e9b8d7ab3934b8b3591123 Mon Sep 17 00:00:00 2001 From: Bjoern Enders Date: Wed, 4 May 2022 09:44:55 -0700 Subject: [PATCH] Release 0.5 : merging in GPU efforts (#261) * fixes doc * some changes to import fft * further step to debug * import fft now doesn't use cppimport, compiles to a temporary directory rather than the build directory, and can be imported multiple times with different shapes. Needs a decent tidy up though. * initial refactor. Now subclasses the UnixCCompiler like a real person * Removes the find module- not needed anymore * clean up imports * Moving more to gpu - broken * All elements in place, needs testing * smaller fixes * get rid of unnecessary printing * Executes now with segfault when saving, can't confirm reco * save final result, even if autosave is false (like current master) * Fixing travis build, ignoring all acceleration tests for now * refactor so that the temporary directories are cleaned up * moved tag for cuda tests in correct place * Bugfix: reduce epsilon in fourier update to avoid overflow issues * remove trace of debugging * Added memory to ML_pycuda but it's not used yet. Smaller fixes like LL and photon error now follow original more closely. Found wrong calculation of A1, A2 in polyline coefficient * Added regularizer to ML_pycuda with unity tests * pycuda floating intensities first pass * Nans are gone, executs but differs from ML and ML_serial * Float intens test part one, renaming * Fixed a weird issue probably resulting from races when writing out the floating intensity coefficients.Floating intensity switch now functional * renamed engine * Fixed accelerate tests * using older version of pyopencl to fix travis build * Restore normal Storage.data at the end, since its context has been changed in iterate * removed print statements * made support constraint work by copying data to CPU and back * Added pycuda tests for gaussian filter, expected to fail * new template DM/ML pycuda template * Added complex convolution kernel, tests passing * tiding up * object smoothing in DM_serial, DM_pycuda and DM_pycuda_streams * fixed smoothing preconditioner in ML_pycuda * cast to int to avoid np.isscalar warning * cast to int to avoid np.isscalar warnings * include archflag in linker command to avoid warnings * Create new context in engine_initiatlize \nthis allows to run multiple pycuda engines back-to-back * Cleaning up and preparing for log-likelihood * fix name of engine in diamond benchmarks * Added array-based kernel for log likelihood and tested against regular ptypy LL * log-likelihood error in DM_serial * prepare for log-likelihood kernel, test is failing * new kernel for log_likelihood, improved tests, seems to work * clean up * more cleanup * Implemented exit error in DM_serial, including unit test * Implemented exit_error dor DM_pycuda doing the reduction on the CPU, works but is slow * Move tests for exit_error to Fourier kernel * Full implementation of exit error on the GPU, works in tests and example * simplified log-likelihood reduction * added todo * added new line * Removed debugging traces * fixed tests * Fixed bug in DM_pycuda * Added error metrics to DM_pycuda_streams * Bugfix in pycuda_streams * device memory pool is causing problems in tests * ML pycuda is broken -> fixed (#269) * queue synchronisation needed * Added option to disable DMPs * Benchmark test scripts for ML * bugfix: forgot to create placeholder for GPU memory * fix in position refinement kernel * [WIP] Enable nearfield propagation for pycuda engines (#275) * Enable nearfield propagation, first pass * Farfield works, but still problems with self.fw and self.bw in nearfield propagation * New template for testing nearfield with DM pycuda * Removed lambdas for nf prop still not tested * Using correct FFTs for nf prop * Need a third fft for nf prop * removed unnecessary code * removed unnecessary filter * Added acceleration tests for propagation kernel, nf prop still broken * modified nearfield templates * Make sure nf prop kernels have correct dtype * cosmetic changes and small bug-fix in prop kernel * Changed template size back to 1024 Co-authored-by: Julio Cesar DA SILVA Co-authored-by: Benedikt Daurer * create rank_local for non-mpi start tackles one issue in #255 * [bugfix] Gaussian kernel now works with non-square images (#276) * Allow for post-iterate modifications in ML_serial * Bugfix in gaussian filter, now works with non-square images * bugfix: update fft3 queue only in nearfield case * apply probe support for non-MPI case, this closes #277 * Introduce fourier_power_bound parameter (#279) * Introduce fourier_relax_normalization parameter * Introduce explicit parameter for power bound * Include theoretical power bound value for Poisson data in doc * Fix Gaussian filtering kernel (#281) * make Gaussian filter work for low sigma values * Remove scipy dependency * Make copy instead changing kernel syntax * Take abs of data (same as DM engine) * Revived old streaming engine * Bug fix to save new pos for new DM engines (#284) * initial fix to save new pos for new DM engines * Finished fix to save positions * clean up * Use consistent variable names * Bugfix: only convert to new coords when posref used * update test workflow * Improve data loading scaling with decreasing frames_per_block (#286) * move reformat/initialize out of scan model * cleaning up * move tests to root level * fix imports * Added new DM_local engine, currently does nothing * started working on iterator * DM_local works with alpha=0 * DM_local work in progress * same power bound for all scans * Use shuffled vieworder * WIP: Reorganizing GPU efforts (#291) * Reorganizing GPU efforts * Fixed some imports * Tests passing. Accelerated engines all broken. * More import statement fixes * Further import Fixes. Reikna is unhappy Reikna test complain about an "invalid resource handle". Needs further investigation * Pycuda engines fail silently, again. * Separated useful stuff from array_based into base * Accelerate base tests are working. Adding explict imports in templates * Amended test workflw * Update test.yml * fixed imports * fixed imports in accelerate tests * more import fixes * More import fixes * Save out arrays for debugging * Added DLS tests based on real data * most of dls_tests are working now * improve dls_tests * DM_pycuda_stream fully functional plus extras (#292) * Reviving pycuda stream engine part 1 * Testing new mem manager * First pass on DM_pycuda_stream with GPUData * Ready for testing * Still testing * Three stream flow with per data event. * Added position refinement * Made DM_pycuda and DM_pycuda_stream compatible with staggered data * Removed block limit, Datamanager now grows dynamically * Need to copy back pagelocked memory, some cleanup * Exposed FFT choice to users. Disentangled the 2 cuda-based FFTs Co-authored-by: Benedikt Daurer * DLS real data tests now working, not all are passing * Test with atomics for now * improved dls_tests * small change to dls_tests * only read regul data for regularization tests * Testing make_a012: still failing * Fixed import * Testing probe/object update without atomics * Gpu flexible datatypes (#294) * generalised and flexible data types for fill_b kernels * configurable data types for batched_multiply * build_aux kernels and variants with flexible dtypes * flexible data type for build_exit * flexible data types for error_reduce * finite difference kernel update for consistent and flexible data types * consistent naming of data types in dot.cu * flexible types in exit_error.cu * fmag_all_update kernel with flexible datatypes * adjustable data types in fourier_error.cu * configurable data types for full_reduce * gd_main with flexible data types * flexible data types in log_likelihood * flexible data types in intens_renorm * flexible dtypes in update_addr_error_state * flexible data types for make_a012 * better error output from kernel compilation by inserting a line directive * flexible data types for make_model * flexible data types in ob_update_ML * flexible data types in ob_update * flexible data types on ob_update2_ML * type-generic ob_update2 * flexible data types for pr_update_ML * flexible data types for the pr_update kernel * flexible data type for pr_update2_ML * flexible data types for pr_update2 * flexible data type on transpose * flexible data type for kernel in convolution * removing old type substitutions * fixing explicit type casts * adding an ACC_TYPE to the tiled update kernels * adding note to explain the register-spilling effect on the tiled update kernels * Making ob/pr denominator real, tests passing (#295) * removed unused code throwing a confusing error * Gpu precision and bugfixes (#296) * fixing bug in DLS test, transferring the wrong data to GPU * investigations / improvements re make_a012 precision errors * fixing explicit type casts * adding an ACC_TYPE to the tiled update kernels * fixing non-atomic ob_update versions for ob dimensions * fixing gradient descent data type specification in test * simplifying ob/pr updates by removing denominator type (#297) * Save Imodel * Added crop_pad and testing (#300) * Added crop_pad and testing * Added GPU tests for crop_pad_simple Co-authored-by: Benedikt Daurer * Gpu hackathon: intensity kernel fix (#301) * fixing intensity kernel race condition without extra memory * Save Imodel Co-authored-by: Benedikt Daurer * Gpu hackathon: accuracy scripts (#302) * accuracy testing script for gradient descent kernels * forgotten return statements * fix in results building Co-authored-by: Benedikt Daurer * Gpu hackathon: crop pad (#303) * adding a 4D test case for crop-pad * crop/pad GPU tests are passing * Integrated crop_pad into propagator, simple tests passing * Added tests for crop/pad, refactored ArrayUtilsKernel. * adding BDIM_X/BDIM_Y to other uses of the error_reduce kernel * conditionally enable -std=c++14 flag depending on CUDA version Co-authored-by: Benedikt Daurer Co-authored-by: Bjoern Enders * consolidate yml files (#307) * WIP: Local douglas rachford algorithm (#304) * Renamed engine to Douglas-Rachford (DR) and added citation * working on tests * Use build_aux kernel to compute pr*ob product * Add unit tests for new kernels * formatting * Added tests for build_exit_alpha_tau * adding prototypes to make tests runnable * fixing reference implementation for alpha_tau test * implementation of build_exit_alpha_tau on GPU * Separate the maximum norm from the main update * Updated tests * First draft of DR_pycuda engine * Properly reading back the errors * kernel + tests for max_abs2 * ob_update_local is working on GPU * Added debugging output * simplified base kernel, we should be able to also simplify the CUDA kernel for max_abs2 * pr_update_local working on GPU * DR pycuda engine is running, but having illegal memory access issues * Define grid by using addr instead of ex * simplified / refactored max_abs2 as independent function * Changed addr in the DR engine * norm is now of type IN_TYPE * DRpycuda engine working now * clean up * more clean up, made exit_error optional * added dls_test for update_local * don't need pbound in DR and can make fourier_error optional * optimised GPU kernels for DR engine, using a thread block per Y dimension * max norm for DR engine needs to sum over modes * ob/pr norm is a single value now * No need for lists, pycuda can do slicing :) * no need anymore for lists when copying errors back * typo * allow changing block dimensions easily from python * adjusting in case of BDIM_Y > 1, we need to return early then * adding fourier_deviation kernel to GPU - tested against fourier_error * fourier_deviation integrated in DR engine * fmag_all_update without pbound * cleaned up and renamed fmag_update_nopbound * Trying a different strategy for shuffling the vieworder * adding a build_aux2 with different parallelisation strategy * build_aux_no_ex with different parallelisation scheme * integrate new build_aux kernels into DR engine * load_kernel supports multiple kernels / file + refactor to keep code DRY * fixing max_abs2 and local updates to aggregate over modes * better parallelisation on the log_likelihood error * avoid extra copy on the CPU for D2H transfers * make vieworder shuffling simpler again * first attempt to DR streaming engine * use random shuffle for vieworder in streaming engine * allow for modes in engine, add templates * Bring DR engines back in sync * Test ob/pr update local with modes * updates to DR engine to fix sizing and transfers * updating benchmark script to new API * made DR work with modes * fixing crash on shutdown due to pagelocked memory * increased MAX_BLOCKS and clean up * Fixed typo Co-authored-by: Jorg Lotze * Use blockmodel in DR templates * added benchmark script that fails with DM_pycuda_stream * update scan name * Fixed bug in GpuDataManager2 that would overallocate blocks. * fixing transpose kernel call, as that moved to its own class * includes scratchmem sizi in dict key (#308) * updates to imported FFT to compile all supported sizes into the same module * integrating filtered_cufft in setup.py * cleanup and re-organising file locations * Revert accidental commit: "cleanup and re-organising file locations" This reverts commit 6c4904b0a81194fc077befd28c472cf92297882a. * Revert accidental commit: "integrating filtered_cufft in setup.py" This reverts commit ce89ee71d63846779025d77d9adb7059ea09c697. * Revert acidental commit: "updates to imported FFT to compile all supported sizes into the same module" This reverts commit c8b3f7b56f22c1f066db1b8ce7a04fb0229acad5. * Fix in context initialisation to raise an exception (#312) * fix in context initialisation to raise an exception in case more processes than GPUs are created * More verbose error and allow to create new stream with existing context * improved error message Co-authored-by: Benedikt Daurer * WIP: position correction (#309) * Introduce grid search option for position refinement * fixed bug in address mangler * re-designed position correction base kernel, added grid search * Make sure we stay within valid bounds * base address manglers tests * address mangler's get_address on GPU (tests) * integrating GPU-based address manglers in DM engines * Fix typo in DM_serial, clean up debugging traces * avoid expensive re-allocations for deltas in address manglers * position grid search seems to work again with all DM engines * simplified address mangler * Template scripts for position correction * use a raw memcopy for the deltas to GPU, which will also work for differing sizes * Fixing data type and memcopy for the deltas in address manglers * Remove warning message * fixing typo for transpose kernel + setting position correction stream * Implement "photon" metric in all DM engines * need to synchronize * starting to add position correction in ML * Add templates for position refinement * It does not make sense to implement position correction for ML in this way Co-authored-by: Jorg Lotze * no need to test for ML with position refinement * archived extensions.py * Gpu smoothing fix (#314) * work in progress refactoring of convolution kernel * tests for gaussian smoothing are passing now * integrating new smoothing kernels into engines * create the tmp array if not given * avoid repeatedly creating tmp array Co-authored-by: Jorg Lotze * Precompile cufft during setup to avoid MPI failures and speed up execution (#313) * updates to imported FFT to compile all supported sizes into the same module * integrating filtered_cufft in setup.py * cleanup and re-organising file locations * fixing typos * made cufft extension module optional in setup.py (enabled by default for now) * replaced cmdline flag with try/except * moved setupext into accelerate folder * move extension back to root level, improved build message Co-authored-by: Benedikt Daurer * needed to make changes in position correction tests * Gpu NCCL wrapper (#310) * multi-GPU wrapper using NCCL for allReduce * Implementation and generalisation of the multi-gpu tests, incl. cuda-aware MPI * adding C++ MPI test for cuda-aware MPI * multi-gpu support integration in DM_pycuda_stream - work in progress * clean up and findings for multi-gpu implementation * probe allreduce and change calc on GPU for all DM engines * Change smoothing message to level 4 * use multigpu.allReduceSum in all DM engines * Moved support constraint to GPU for DM engines * Attempt to write clip_magnitudes kernel, unity test fails * Integrate clip magnitues kernel into DM engines, still off for now * working on clip magnitudes kernel * adjusting test to pass complex * use clip_object * need to pass gpu array * adding reproducer script used for reproducing nccl crash in the engines * adding dummy call to build_aux_no_ex to test * Fixing Nccl issue - Streams allocated before NCCL can't be used afterwards * move smoothing message to log level 4 * use more simple syntax for DtoD copies * this avoids clean up error when using NCCL * Use multigpu allreduce for change, clean up * remove benchmarks from pycuda engines and move most logging to level 4 * cosmetic changes Co-authored-by: Benedikt Daurer * checking at runtime if nccl/cuda-mpi are available * Fixed bugs in address manglers * Fixed bug in DM stream engines related to smoothing/object update * reversing the order of the support constraints (#315) * reversing the order of the support constraints * now making the intended change * Make basic fourier update a true blend between DM and AP (#288) * Make basic update a true blend between DM and AP * made all DM updates a true blend of DM and AP. * Cleaned up debugging traces * pycuda engines need to be explicitely imported * remove print statement * We need a third object copy for smoothing in the stream engines (#321) * We need a third object copy for smoothing * switch the temporary buffers obb.gpu and obb.tmp * small bugfix * bugfix: rescale size of aux when using MPI (#322) * bugfix: rescale size of aux when using MPI * same MPI rescaling of aux for the serial engines * Update multi_gpu.py (#324) This is a quick fix for when the nccl library in cupy comes back as `_UnavailableModule`. Alternatively this could be put catched the __init__ bits of `MultiGpuCommunicatorNccl` where it raises a `RuntimeError` then. * Add option to choose fft lib in ML_pycuda (#326) * add padding to the HDF5loader (#330) * Allow different masks for spectro scans (#333) * Record new positions only if requested (#328) * make saving of new positions optional * saving grids should not be optional * Make recording of local error map optional (#329) * Make recording of local error map optional * set userlevel to 2 * Check if position refinement amplitude is large enough (#331) * bugfix: correctly resize the aux shape (#332) * Use correct aux shape in propagation kernel tests * Update release_notes.md * gather_dict/bcast_dict can create issues with multinode MPI (#327) * simplify gather_dict, works with multiple nodes * Keep previous code for gather_dict * Simplify bcast_dict, works with multiple nodes * merge back into single bcast_dict, remove in-place * Position refinement for ML (#334) * working on posref for ML * position refinement works with ML_pycuda * use asynchronous copies, getting illegal memory access * moved sqrt calculation after synchronizing event * Wrong type for `ma`, must be float not bool * needed to specify out array in cumath.sqrt Co-authored-by: Bjoern Enders * avoid elementwise comparison * avoid elementwise comparison (after fixing typo) * only update views for the original container (#337) * remove automatic import of all experiment classes (#338) * WIP: Python 3.9 (#339) * include Python 3.8 and 3.9 in GitHub Actions workflow * first round of syntax changes after running flake8 * more flake fixes and ignoring some cases * enable syntax checking in GitHub Actions workflow * fixed syntax in test.yaml * us float() instead of np.float() which is deprecated in numpy 1.20 * specify numpy dtype to avoid deprecation warnings * more fixes and ignore statements, the code now passes E9,F63,F7,F82 checks * convert to raw strings to avoid invalid escape sequence warnings * one more rawstring conversion * removed deprecated code, updated release notes * typo * Allow for non-boolean frame filter in HDF5Loader * removed dependency * fixed more invalid escape sequences * Fixed parsing of framefilter and solved dtype deprecation warnings * More dtype fixes to remove deprecation warnings * select outer index for framefilter * log power bound * save floating intensities in ML_serial and ML_pycuda (#353) * Clean exit when data does not fit into device memory (#354) * DM_pycuda engines don't fully clear memory (#352) * improving cleanup, still not all memory freed * Use MPI instead of NCCL by default * add empty line * Remove traces of OpenCL engine (#311) * padding to longer necessary (legacy of opencl version) * remove unnecessary padding from DR_serial * correct order fixes problem with setstream tests * fixed dtype * convert to int to avoid deprecation warnings * WIP: include a general form of projection update (#361) * Refactored Fourier update into general form, RAAR included * Refactor stupidity * Refactor stupidity part 2 plus updated docs * Renamed DR to DM * Docststrings updated * Added first unity test for projection_update_generalized and removed severe bug * Removed output files for engine tests * Added general projection engine * Added general kernels. Modified kernel classes * Fitted engines to projection form. * Minor bug fixes, typos. Auxiliary Wave Kernel test run. * Fixed inheritance * Updated pyucda_streams * Fixed RAAR update * Renamed and moved DM engines * Minor fixes for tests * test fix again * test fix Co-authored-by: Benedikt Daurer * Stochastic Douglas-Rachford algorithm (#359) * Renamed to SDR and implemented core engine * Working on local probe/object update * Generalise stochastic engines * working on basic stochastic engines * Refactor of stochastic engines, including serial engines * Added CUDA kernels for local ob/pr norm, tests passing * refactor of stochastic PYCUDA engines (EPIE/SDR) - tests passing * removed debugging traces * Merged CUDA stream features into stochastic pycuda base engine * Integrating posref into stochastic engines, still in progress * introduce decay parameter for posref * Position refinement works for all stochastic engines * Use class mixing and combine all stochastic engines in single file * Move params and citation to Mixin classes * fixed tests * remove duplication in docstrings * prepare for merge with generic fourier_update * integration of general fourier update (in progress) * use generalised fourier update in stochastic engines, introduce rescale parameter * fixed imports * include more probe parameters in stochastic engines * New definition of the generic update * fixed typo * Optional global object norm in ePIE (#367) * adding option to use global object norm for ePIE * added global object norm option for pycuda engine * Moved new object_norm_is_global parameter into EPIE engine * remove files that have been uploaded by accident * Introducing the idea of customized engines with an object regulariser (#358) * Introducing the idea of plugins with an object regulariser * Include shape check for DM plugin * Provide option to only regularise the phase * clean up and improve docs * improve doc * added test script * Created new folder mods for customized engines, added start/stop to object regulariser * Moved back to plugin structure inside the package * small change to test script * renamed plugins to custom prepare for merge * clean exit that also works with interactive python (e.g. notebooks) (#368) * move non-standard engines into custom folder (#369) * moved some of the engines to custom * remove engines from ptypy/engines * comment dynamic load * fixed imports in engine tests * Make fft chooser more intelligent, update compute_levels (#370) * Make fft chooser more intelligent, update compute_levels * fixed fft chooser and completed compute levels * no need to make variable private * cleaned up previous commit * Improve warning message * roll back to require CUDA >=11.0 for cufft * cufft compile flags (#372) * cuda version dependent arch flags * improve messaging * raise error if CUDA version is not supported * use probe_update_start in stochastic serial/pycuda engines * bugfix: forgot new argument in FFT chooser * Improve logging (#371) * elevate citation info to critical * move timing log from warning to info * working on new interactive verbose level * added interactivelog messages * small formatting change * removed timing from interactive logging * small fix to interactive logging and example notebooks * include ipynb checkpoints in gitignore * improved interactive logging * use string for logging citation * clean up * Updating release notes * Fix how frames_per_block is defined (#375) * access the frames per block in the engines via the scan model * remove debugging * making sure fpc is per MPI rank * added convenience loaders for GPU engines and ptyscan modules (#376) * added convenience loaders for GPU engines and ptyscan modules * Added tests for auto loaders * Rebranding projectional pycuda engines (#377) * register different names, but keep classes the same * EPIE improvements (#378) * Added ePIE model with lower memory footprint * Renamed model to GradFull and BlockGradFull and made sure it works with ePIE and ML * make variable private * added more documentation * moved definition of supported models * moved supported models into mixin classes * moved scan model check to initialize * added todo * make MPI optional (#379) * Added wrapper for timing main ptycho functions (#381) * Wrap main ptycho functions in LogTime * move benchmarks out of runtime * add user level to benchmark parameter * Derive engine name from params not class * Shift object and exit waves during centring probe (#373) * Shift object and exit waves during centring probe * [WIP] mass center cuda * Finished mass_center for 2D * Completed the mass_center 3D case * Loop through different exit wave storages when centering probe * Fix a bug in the size of threads and block in final_sums in mass_center * Simplify the looping syntax * Implement center_probe in stochastic algorithm * Put center_probe in projectional_serial * Finish the abs2sum kernel * [WIP] interpolated shift kernel The starting value of a block for positive shift is wrong, and the last value of a block for negative shift is wrong?? * Fix a bug in linear_interpolate_kernel in interpolated shift The four corners of the Halo were missing, leading to the usage of random values in shared memory when performing linear interpolation. The four corners of the Halo are now defined correctly. * Fix another bug in linear_interpolate_kernel (swapped rows and columns) rows and columns variables are swapped, may result in pre-mature return. * Finish the interpolated shift kernel * Implement center_probe in projectional_pycuda * Reduce number of loopings when shifting exit waves * Revert "Reduce number of loopings when shifting exit waves" This reverts commit 4e5e22cd39ba887a7aad44ae1e47d53fa09ed6c6. * Adjust the way to access object and gpu data in projectional * Move the center_probe method out of inner loop in projectional * Adjust the way to access object in stochastic * Move the center_probe method out of inner loop in stochastic * Implement the center_probe in stochastic pycuda * fixed imports for opencl engines * Pre-determine if data is distributed (#335) * introduce new scaling flag for Container and pre-determine if data is distributed * need to check if MPI is enabled * name change * made variable "distributed" private and renamed to "_is_scattered" * Reorganise templates (#384) * remove unnecessary init files * move template scripts into subfolders * updated and tested basic ptypy templates * need an init for test folder * updated position refinment templates * more changes to templates * cleaned up moonflower engine templates * more changes to engine templates * added templates for RAAR engines * more changes to templates * fixed farfield example * moved delayed scripts to live processing folder * organised model and misc templates, added new notebooks * benchmarks scripts up-to-date * small fix in diamond benchmarks * add minimal prep and run script in accelerate templates * updated dependencies for pycuda engines * [WIP] Memory management for ML_pycuda engine revised after projectional_pycuda_stream (#382) * First round of transferring mem management from DM to ML * Data management replaced except for pos corr update * fixed import * Add gpu supp constraint, harmonized engine.finalize * Added alternative LL calculation for Position correction + tests * Allowed for index reversal after pos corr run * Wrong log_likelihood in second call in pos corr * Moved pycuda_streams to archive. Cleaned ML_pyuda and mem_utils * cleaned up gpudata test * temporarily disable flake8 linter (causing trouble with python 3.8) * fix import * fixed goudata tests and small bug in mem utils * new hdf5 loader using mutliprocessing (#380) * WIP: Unit tests for engines (#389) * ML engine tests * debug * debugging ML precision * working on engine tests for ML_serial * debugging * Cleaning up, some engine tests still failing * more cleanup and small changes * more cleanup * engine tests passing with tol=1e-2 * revert Brenorm changes * moved cufft extension into separate module (#390) * moved cufft extension into separate module * cleaning up * fixed small bug in log_likelihood.cu * WIP: Release 0.5 (#393) * Path to default sphinx layout has changed * Initial doc push for release * more updates * forget a file * Removed OrderedDict from h5rw * Fixed parts of h5info. Fixed guide. Release nodes * Responded to Benedikts comments * Sequestered cufft requirement * more on dependencies * Cleaning up references * Fixed stylesheet * minimal fix * Added format parameter to save in alternate format * bugfix * bugfix bugfix * kept the record_positions switch * Root level resources dir gutted, moved to pip install Co-authored-by: Benedikt Daurer Co-authored-by: Benedikt J. Daurer * archived unused tests, specified valid tests in setup.cfg * simplified workflow, put back linter * formatting changes for 0.5 release * formatting changes to release notes * adjust length of underlines * typeDict is a depcreated alias of sctypeDict * _MODE_CONV removed with PIL 9.1.0 (#399) Co-authored-by: Aaron Parsons Co-authored-by: Benedikt Daurer Co-authored-by: Benedikt J. Daurer Co-authored-by: Julio Cesar DA SILVA Co-authored-by: Jorg Lotze Co-authored-by: Timothy Poon <62692924+ptim0626@users.noreply.github.com> --- .clang-format | 65 + .github/workflows/test.yml | 26 +- .gitignore | 1 + .travis.yml | 19 +- README.rst | 11 +- archive/array_based/__init__.py | 7 + archive/array_based/array_utils.py | 87 ++ archive/array_based/base.py | 22 + archive/array_based/constraints.py | 143 ++ archive/array_based/data_utils.py | 90 ++ archive/array_based/error_metrics.py | 37 + .../array_based/object_probe_interaction.py | 132 ++ archive/array_based/propagation.py | 52 + archive/cuda_extension/cuda/CMakeLists.txt | 135 ++ archive/cuda_extension/cuda/CMakeLists.txt.in | 15 + archive/cuda_extension/cuda/README.md | 19 + archive/cuda_extension/cuda/func/abs2.cu | 133 ++ archive/cuda_extension/cuda/func/abs2.h | 23 + .../cuda/func/addr_info_helpers.cpp | 47 + .../cuda/func/addr_info_helpers.h | 29 + .../cuda_extension/cuda/func/center_probe.cu | 150 ++ .../cuda_extension/cuda/func/center_probe.h | 27 + .../func/clip_complex_magnitudes_to_range.cu | 90 ++ .../func/clip_complex_magnitudes_to_range.h | 25 + .../cuda/func/complex_gaussian_filter.cu | 314 ++++ .../cuda/func/complex_gaussian_filter.h | 38 + .../func/difference_map_fourier_constraint.cu | 532 +++++++ .../func/difference_map_fourier_constraint.h | 97 ++ .../cuda/func/difference_map_iterator.cu | 381 +++++ .../cuda/func/difference_map_iterator.h | 104 ++ .../func/difference_map_overlap_constraint.cu | 303 ++++ .../func/difference_map_overlap_constraint.h | 82 ++ .../difference_map_realspace_constraint.cu | 112 ++ .../difference_map_realspace_constraint.h | 27 + .../cuda/func/difference_map_update_object.cu | 226 +++ .../cuda/func/difference_map_update_object.h | 57 + .../cuda/func/difference_map_update_probe.cu | 242 +++ .../cuda/func/difference_map_update_probe.h | 60 + .../cuda/func/extract_array_from_exit_wave.cu | 255 ++++ .../cuda/func/extract_array_from_exit_wave.h | 46 + .../cuda/func/far_field_error.cu | 154 ++ .../cuda/func/far_field_error.h | 29 + .../cuda/func/farfield_propagator.cu | 231 +++ .../cuda/func/farfield_propagator.h | 83 ++ .../cuda/func/get_difference.cu | 190 +++ .../cuda_extension/cuda/func/get_difference.h | 36 + .../cuda/func/interpolated_shift.cu | 428 ++++++ .../cuda/func/interpolated_shift.h | 30 + .../cuda/func/log_likelihood.cu | 269 ++++ .../cuda_extension/cuda/func/log_likelihood.h | 67 + .../cuda_extension/cuda/func/mass_center.cu | 257 ++++ .../cuda_extension/cuda/func/mass_center.h | 21 + archive/cuda_extension/cuda/func/norm2.cu | 160 ++ archive/cuda_extension/cuda/func/norm2.h | 26 + .../cuda/func/realspace_error.cu | 160 ++ .../cuda/func/realspace_error.h | 31 + .../func/renormalise_fourier_magnitudes.cu | 229 +++ .../func/renormalise_fourier_magnitudes.h | 40 + .../cuda/func/scan_and_multiply.cu | 194 +++ .../cuda/func/scan_and_multiply.h | 46 + archive/cuda_extension/cuda/func/sqrt_abs.cu | 14 + .../cuda_extension/cuda/func/sum_to_buffer.cu | 347 +++++ .../cuda_extension/cuda/func/sum_to_buffer.h | 47 + archive/cuda_extension/cuda/splines/README.md | 6 + .../cuda/splines/bspline_kernel.cuh | 114 ++ .../cuda/splines/cubicPrefilter2D.cu | 107 ++ .../cuda/splines/cubicPrefilter2D.cuh | 107 ++ .../cuda/splines/cubicPrefilter_kernel.cu | 114 ++ .../cuda/splines/cubicPrefilter_kernel.cuh | 114 ++ .../cuda_extension/cuda/splines/math_func.cu | 77 + .../cuda_extension/cuda/splines/math_func.cuh | 75 + .../cuda/tests/gaussian_weights_test.cpp | 27 + .../cuda/tests/indexing_test.cpp | 94 ++ archive/cuda_extension/cuda/utils/Complex.h | 5 + .../cuda/utils/CudaFunction.cpp | 19 + .../cuda_extension/cuda/utils/CudaFunction.h | 26 + archive/cuda_extension/cuda/utils/Errors.h | 122 ++ .../cuda/utils/FinalSumKernel.h | 36 + .../cuda/utils/GaussianWeights.h | 25 + .../cuda_extension/cuda/utils/GpuManager.cu | 104 ++ .../cuda_extension/cuda/utils/GpuManager.h | 163 +++ archive/cuda_extension/cuda/utils/Indexing.h | 40 + archive/cuda_extension/cuda/utils/Memory.cpp | 31 + archive/cuda_extension/cuda/utils/Memory.h | 195 +++ archive/cuda_extension/cuda/utils/Patches.h | 21 + .../cuda_extension/cuda/utils/ScopedTimer.h | 51 + archive/cuda_extension/cuda/utils/Timer.h | 30 + archive/cuda_extension/engines/DM_gpu.py | 189 +++ archive/cuda_extension/engines/DM_npy.py | 286 ++++ archive/cuda_extension/engines/gpu_testing.py | 177 +++ archive/cuda_extension/extensions.py | 102 ++ .../minimal_DMGpu_iterate_benchmark.py | 53 + .../minimal_DMNpy_iterate_benchmark.py | 53 + archive/cuda_extension/python/__init__.py | 7 + archive/cuda_extension/python/array_utils.py | 8 + archive/cuda_extension/python/config.py | 17 + archive/cuda_extension/python/constraints.py | 13 + .../cuda_extension/python/cuda_functions.pxd | 281 ++++ .../cuda_extension/python/error_metrics.py | 5 + .../cuda_extension/python/gpu_extension.pyx | 1020 +++++++++++++ .../python/object_probe_interaction.py | 11 + archive/cuda_extension/python/propagation.py | 6 + .../cuda_extension/setup.py.cuda_extension | 144 ++ archive/cuda_extension/tests/__init__.py | 10 + .../cuda_extension/tests/array_utils_test.py | 416 ++++++ .../tests/constraints_regression_test.py | 551 +++++++ .../cuda_extension/tests/constraints_test.py | 1079 ++++++++++++++ .../cuda_extension/tests/data_utils_test.py | 54 + .../tests/engine_iterate_unity_test.py | 209 +++ .../cuda_extension/tests/error_metric_test.py | 112 ++ .../tests/farfield_propagator_test.py | 229 +++ .../tests/minimal_numpy_DM_test.py | 56 + .../tests/minimal_numpy_DM_test_4096x4096.py | 60 + .../tests/minimal_numpy_DM_test_64x64.py | 56 + .../tests/minimal_numpy_ML_test.py | 56 + .../tests/object_probe_interaction_test.py | 1272 ++++++++++++++++ archive/cuda_extension/tests/utils.py | 69 + {ptypy => archive}/engines/DM.py | 12 +- {ptypy => archive}/engines/DM_simple.py | 4 +- {ptypy => archive}/engines/dummy.py | 1 - .../engines/projectional_pycuda_streams.py | 866 +++++++++++ archive/misc/mpitest.cpp | 47 + benchmark/cufft_vs_reikna.py | 82 ++ .../diamond_benchmarks/ML_accurracy_test.py | 404 +++++ .../moonflower_scripts/i08.py | 74 + .../moonflower_scripts/i13.py | 75 + .../moonflower_scripts/i14_1.py | 73 + .../moonflower_scripts/i14_2.py | 75 + .../moonflower_scripts/profile_all.sh | 33 + benchmark/model_speed.py | 15 +- benchmark/mpi_allreduce_bench.sh | 11 + benchmark/mpi_allreduce_bench_launcher.sh | 8 + benchmark/mpi_allreduce_bench_multinode.sh | 18 + benchmark/mpi_allreduce_speed.py | 42 + benchmark/tiled_vs_atomic.py | 113 ++ cufft/dependencies.yml | 10 + cufft/extensions.py | 151 ++ cufft/filtered_fft/.gitignore | 6 + cufft/filtered_fft/Makefile | 29 + cufft/filtered_fft/compiler_flags_info.txt | 6 + cufft/filtered_fft/errors.h | 86 ++ cufft/filtered_fft/filtered_fft.cu | 322 ++++ cufft/filtered_fft/filtered_fft.h | 34 + cufft/filtered_fft/module.cpp | 102 ++ cufft/filtered_fft/smoke_test.cpp | 65 + cufft/filtered_fft/test_Makefile | 43 + cufft/setup.py | 45 + ..._dependencies.yml => dependencies_core.yml | 5 +- ...l_dependencies.yml => dependencies_dev.yml | 5 +- dependencies_full.yml | 15 + doc/conf.py | 14 +- doc/html_templates/ptypysphinx/download.html | 9 +- doc/html_templates/ptypysphinx/layout.html | 2 +- .../ptypysphinx/static/header.css_t | 8 +- doc/index.rst | 18 +- doc/parameters2rst.py | 186 ++- doc/rst/ptypy.engines.rst | 14 +- doc/rst/ptypy.experiment.rst | 8 + doc/rst_templates/getting_started.tmp | 291 ++-- doc/script2rst.py | 8 +- ptypy/__init__.py | 51 +- {templates => ptypy/accelerate}/__init__.py | 0 ptypy/accelerate/base/__init__.py | 3 + ptypy/accelerate/base/address_manglers.py | 87 ++ ptypy/accelerate/base/array_utils.py | 150 ++ ptypy/accelerate/base/engines/ML_serial.py | 541 +++++++ ptypy/accelerate/base/engines/__init__.py | 0 .../base/engines/projectional_serial.py | 614 ++++++++ .../engines/projectional_serial_stream.py | 267 ++++ ptypy/accelerate/base/engines/stochastic.py | 450 ++++++ ptypy/accelerate/base/kernels.py | 815 +++++++++++ ptypy/accelerate/cuda_pycuda/__init__.py | 68 + .../cuda_pycuda/address_manglers.py | 74 + ptypy/accelerate/cuda_pycuda/array_utils.py | 698 +++++++++ ptypy/accelerate/cuda_pycuda/cuda/__init__.py | 0 ptypy/accelerate/cuda_pycuda/cuda/abs2sum.cu | 29 + .../cuda_pycuda/cuda/batched_multiply.cu | 37 + .../accelerate/cuda_pycuda/cuda/build_aux.cu | 99 ++ .../cuda_pycuda/cuda/build_aux_no_ex.cu | 103 ++ .../cuda/build_aux_position_correction.cu | 46 + .../accelerate/cuda_pycuda/cuda/build_exit.cu | 65 + .../cuda_pycuda/cuda/build_exit_alpha_tau.cu | 60 + .../cuda_pycuda/cuda/clip_magnitudes.cu | 30 + .../cuda_pycuda/cuda/convolution.cu | 190 +++ ptypy/accelerate/cuda_pycuda/cuda/delx.cu | 210 +++ ptypy/accelerate/cuda_pycuda/cuda/dot.cu | 56 + .../cuda_pycuda/cuda/error_reduce.cu | 56 + .../accelerate/cuda_pycuda/cuda/exit_error.cu | 47 + ptypy/accelerate/cuda_pycuda/cuda/fill3D.cu | 60 + ptypy/accelerate/cuda_pycuda/cuda/fill_b.cu | 105 ++ .../cuda_pycuda/cuda/fmag_all_update.cu | 62 + .../cuda_pycuda/cuda/fmag_update_nopbound.cu | 53 + .../cuda_pycuda/cuda/fourier_deviation.cu | 58 + .../cuda_pycuda/cuda/fourier_error.cu | 65 + .../cuda_pycuda/cuda/fourier_error2.cu | 84 ++ .../cuda_pycuda/cuda/fourier_update.cu | 138 ++ .../cuda_pycuda/cuda/full_reduce.cu | 44 + ptypy/accelerate/cuda_pycuda/cuda/gd_main.cu | 36 + .../cuda_pycuda/cuda/get_address.cu | 35 + .../cuda_pycuda/cuda/intens_renorm.cu | 66 + .../cuda_pycuda/cuda/interpolated_shift.cu | 279 ++++ .../cuda_pycuda/cuda/log_likelihood.cu | 153 ++ .../accelerate/cuda_pycuda/cuda/make_a012.cu | 67 + ptypy/accelerate/cuda_pycuda/cuda/make_aux.cu | 104 ++ .../accelerate/cuda_pycuda/cuda/make_exit.cu | 70 + .../accelerate/cuda_pycuda/cuda/make_model.cu | 30 + .../cuda_pycuda/cuda/mass_center.cu | 138 ++ ptypy/accelerate/cuda_pycuda/cuda/max_abs2.cu | 115 ++ .../cuda_pycuda/cuda/ob_norm_local.cu | 59 + .../accelerate/cuda_pycuda/cuda/ob_update.cu | 68 + .../accelerate/cuda_pycuda/cuda/ob_update2.cu | 128 ++ .../cuda_pycuda/cuda/ob_update2_ML.cu | 124 ++ .../cuda_pycuda/cuda/ob_update_ML.cu | 67 + .../cuda_pycuda/cuda/ob_update_local.cu | 73 + .../cuda_pycuda/cuda/pr_norm_local.cu | 59 + .../accelerate/cuda_pycuda/cuda/pr_update.cu | 69 + .../accelerate/cuda_pycuda/cuda/pr_update2.cu | 124 ++ .../cuda_pycuda/cuda/pr_update2_ML.cu | 121 ++ .../cuda_pycuda/cuda/pr_update_ML.cu | 66 + .../cuda_pycuda/cuda/pr_update_local.cu | 77 + .../accelerate/cuda_pycuda/cuda/transpose.cu | 45 + .../cuda/update_addr_error_state.cu | 43 + ptypy/accelerate/cuda_pycuda/cufft.py | 176 +++ ptypy/accelerate/cuda_pycuda/dependencies.yml | 20 + .../cuda_pycuda/engines/ML_pycuda.py | 789 ++++++++++ .../cuda_pycuda/engines/__init__.py | 0 .../engines/projectional_pycuda.py | 603 ++++++++ .../engines/projectional_pycuda_stream.py | 512 +++++++ .../cuda_pycuda/engines/stochastic.py | 529 +++++++ ptypy/accelerate/cuda_pycuda/fft.py | 180 +++ ptypy/accelerate/cuda_pycuda/kernels.py | 1270 ++++++++++++++++ ptypy/accelerate/cuda_pycuda/mem_utils.py | 426 ++++++ ptypy/accelerate/cuda_pycuda/multi_gpu.py | 179 +++ .../cuda_pycuda/optimisation_log.md | 417 ++++++ ptypy/accelerate/ocl_pyopencl/__init__.py | 27 + .../accelerate/ocl_pyopencl/engines/DM_ocl.py | 411 ++++++ .../ocl_pyopencl/engines/DM_ocl_npy.py | 572 ++++++++ .../ocl_pyopencl/full_dependencies.yml | 3 +- ptypy/accelerate/ocl_pyopencl/kernel_heap.txt | 550 +++++++ ptypy/accelerate/ocl_pyopencl/npy_kernels.py | 236 +++ .../ocl_pyopencl/npy_kernels_for_block.py | 235 +++ ptypy/accelerate/ocl_pyopencl/ocl_fft.py | 233 +++ ptypy/accelerate/ocl_pyopencl/ocl_kernels.py | 421 ++++++ ...els_self_contained_for_future_reference.py | 946 ++++++++++++ ptypy/core/classes.py | 54 +- ptypy/core/data.py | 12 +- ptypy/core/geometry_bragg.py | 2 +- ptypy/core/illumination.py | 80 +- ptypy/core/manager.py | 47 +- ptypy/core/ptycho.py | 133 +- ptypy/core/sample.py | 103 +- ptypy/core/xy.py | 4 +- ptypy/{engines => custom}/DMOPR.py | 13 +- ptypy/custom/DM_object_regul.py | 66 + ptypy/custom/DM_pycuda_object_regul.py | 83 ++ ptypy/{engines => custom}/MLOPR.py | 14 +- ptypy/custom/__init__.py | 0 .../ePIE.py => custom/ePIE_parallel.py} | 53 +- ptypy/engines/Bragg3d_engines.py | 2 +- ptypy/engines/ML.py | 39 +- ptypy/engines/__init__.py | 18 +- ptypy/engines/base.py | 87 +- ptypy/engines/posref.py | 207 ++- ptypy/engines/projectional.py | 553 +++++++ ptypy/engines/stochastic.py | 476 ++++++ ptypy/engines/utils.py | 272 +++- ptypy/experiment/__init__.py | 29 - ptypy/experiment/diamond_nexus.py | 10 +- ptypy/experiment/hdf5_loader.py | 268 +++- ptypy/experiment/nanomax.py | 2 +- ptypy/experiment/optiklabor.py | 28 +- ptypy/experiment/spec.py | 4 +- ptypy/io/edfIO.py | 2 +- ptypy/io/h5rw.py | 69 +- ptypy/io/interaction.py | 2 +- ptypy/io/rawIO.py | 2 +- ptypy/resources/__init__.py | 1 + .../default_parameters_configparser.txt | 15 + .../parameter_descriptions.configparser | 15 + ptypy/simulations/detector.py | 2 +- ptypy/simulations/ptysim_utils.py | 4 +- ptypy/simulations/simscan.py | 56 +- ptypy/utils/array_utils.py | 269 ++-- ptypy/utils/misc.py | 5 +- ptypy/utils/parallel.py | 90 +- ptypy/utils/parameters.py | 2 +- ptypy/utils/plot_client.py | 4 +- ptypy/utils/plot_utils.py | 19 +- ptypy/utils/scripts.py | 14 +- ptypy/utils/verbose.py | 99 +- ptypy_core_dependencies.yml | 8 - release_notes.md | 125 +- resources/__init__.py | 11 - resources/ptypy_logo_1M.png | Bin 255113 -> 0 bytes resources/tree.bmp | Bin 7308054 -> 0 bytes setup.cfg | 3 + setup.py | 60 +- .../ptypy_i13_AuStar_farfield_pycuda.py | 115 ++ .../ptypy_i13_AuStar_nearfield_pycuda.py | 117 ++ .../ptypy_id22ni_AuStar_focused_pycuda.py | 119 ++ .../ptypy_laser_logo_focused_pycuda.py | 99 ++ .../ptypy_minimal_prep_and_run_pycuda.py | 53 + templates/engines/moonflower_DM.py | 54 + templates/engines/moonflower_DM_ML.py | 69 + templates/engines/moonflower_DM_ML_pycuda.py | 67 + templates/engines/moonflower_DM_ocl.py | 56 + templates/engines/moonflower_DM_pycuda.py | 56 + .../engines/moonflower_DM_pycuda_nostream.py | 57 + templates/engines/moonflower_DM_serial.py | 56 + templates/engines/moonflower_EPIE.py | 60 + .../engines/moonflower_EPIE_ML_pycuda.py | 74 + templates/engines/moonflower_EPIE_pycuda.py | 58 + templates/engines/moonflower_EPIE_serial.py | 58 + .../moonflower_ML_Gaussian.py} | 36 +- .../moonflower_ML_Poisson.py} | 23 +- templates/engines/moonflower_ML_pycuda.py | 62 + templates/engines/moonflower_ML_serial.py | 62 + .../moonflower_RAAR.py} | 29 +- templates/engines/moonflower_RAAR_ML.py | 70 + .../engines/moonflower_RAAR_ML_pycuda.py | 68 + templates/engines/moonflower_RAAR_pycuda.py | 57 + templates/engines/moonflower_RAAR_serial.py | 57 + templates/engines/moonflower_SDR.py | 62 + templates/engines/moonflower_SDR_pycuda.py | 60 + templates/engines/moonflower_SDR_serial.py | 59 + templates/{ => experiment}/nanomax_zmq_run.py | 13 +- .../live_processing/moonflower_DM_delayed.py | 57 + .../moonflower_DM_delayed_pycuda.py | 59 + .../{ => live_processing}/on_the_fly_ptyd.py | 0 .../{ => live_processing}/on_the_fly_rec.py | 0 templates/{ => misc}/bragg_field_of_view.py | 5 +- templates/{ => misc}/bragg_prep_and_run.py | 5 +- templates/misc/moonflower_DM_object_regul.py | 62 + .../misc/moonflower_DM_object_regul_pycuda.py | 62 + .../moonflower_probe_sharing.py} | 11 +- templates/{ => misc}/pars_few_alldoc.py | 0 .../moonflower_blockfull.py} | 19 +- templates/model/moonflower_blockgradfull.py | 64 + .../moonflower_blockvanilla.py} | 25 +- .../moonflower_full.py} | 14 +- .../moonflower_gradfull.py} | 24 +- .../moonflower_independent_probes.py} | 14 +- .../moonflower_probe_from_array.py} | 14 +- templates/model/moonflower_probe_modes.py | 54 + templates/model/moonflower_resample.py | 62 + .../moonflower_vanilla.py} | 11 +- templates/notebooks/moonflower_dm.ipynb | 195 +++ .../notebooks/moonflower_dm_pycuda.ipynb | 218 +++ templates/notebooks/moonflower_epie.ipynb | 200 +++ .../notebooks/moonflower_epie_pycuda.ipynb | 211 +++ templates/notebooks/moonflower_ml.ipynb | 202 +++ .../notebooks/moonflower_ml_pycuda.ipynb | 223 +++ templates/notebooks/moonflower_raar.ipynb | 194 +++ .../notebooks/moonflower_raar_pycuda.ipynb | 217 +++ templates/position_evaluation.py | 195 --- .../moonflower_posref_DM.py} | 55 +- .../moonflower_posref_DM_pycuda.py | 109 ++ .../moonflower_posref_DM_serial.py | 109 ++ .../moonflower_posref_EPIE.py | 103 ++ .../moonflower_posref_EPIE_pycuda.py | 105 ++ .../moonflower_posref_ML.py | 110 ++ .../moonflower_posref_ML_pycuda.py | 115 ++ .../moonflower_posref_ML_serial.py | 112 ++ .../moonflower_posref_SDR.py | 103 ++ .../moonflower_posref_SDR_pycuda.py | 105 ++ ...9p0keV.py => ptypy_i13_AuStar_farfield.py} | 23 +- ...p7keV.py => ptypy_i13_AuStar_nearfield.py} | 23 +- ...7keV.py => ptypy_id22ni_AuStar_focused.py} | 24 +- ...d_632nm.py => ptypy_laser_logo_focused.py} | 27 +- ...mple_ptyd.py => ptypy_make_sample_ptyd.py} | 4 +- ...d_run.py => ptypy_minimal_load_and_run.py} | 15 +- templates/ptypy_minimal_prep_and_run.py | 54 + test/accelerate_tests/__init__.py | 0 test/accelerate_tests/base_tests/__init__.py | 0 .../base_tests/address_manglers_test.py | 96 ++ .../base_tests/array_utils_test.py | 296 ++++ .../base_tests/auxiliary_wave_kernel_test.py | 429 ++++++ .../base_tests/engine_tests.py | 171 +++ .../base_tests/fourier_update_kernel_test.py | 570 +++++++ .../gradient_descent_kernel_test.py | 279 ++++ .../base_tests/import_test.py | 10 + .../base_tests/po_update_kernel_test.py | 512 +++++++ .../position_correction_kernel_test.py | 326 +++++ .../cuda_pycuda_tests/__init__.py | 43 + .../address_manglers_test.py | 77 + .../cuda_pycuda_tests/array_utils_test.py | 540 +++++++ .../auxiliary_wave_kernel_test.py | 666 +++++++++ .../derivatives_kernel_test.py | 334 +++++ .../cuda_pycuda_tests/engine_tests.py | 172 +++ .../cuda_pycuda_tests/engine_utils_test.py | 54 + .../cuda_pycuda_tests/fft_scaling_test.py | 265 ++++ .../cuda_pycuda_tests/fft_setstream_test.py | 98 ++ .../cuda_pycuda_tests/fft_tests/__init__.py | 0 .../fft_tests/cufft_init_test.py | 28 + .../fft_tests/fft_accuracy_test.py | 48 + .../fourier_update_kernel_test.py | 685 +++++++++ .../cuda_pycuda_tests/gpudata_test.py | 258 ++++ .../gradient_descent_kernel_test.py | 327 +++++ .../cuda_pycuda_tests/import_test.py | 10 + .../cuda_pycuda_tests/multi_gpu_test.py | 84 ++ .../po_update_kernel_test.py | 943 ++++++++++++ .../position_correction_kernel_test.py | 149 ++ .../propagation_kernel_test.py | 158 ++ .../ocl_pyopencl_tests/__init__.py | 0 .../ocl_pyopencl_tests/ocl_kernels_test.py | 780 ++++++++++ test/archive_tests/__init__.py | 0 .../array_based_tests/__init__.py | 0 .../constraints_regression_test.py | 977 ++++++++++++ .../constraints_unity_test.py | 221 +++ .../array_based_tests/data_utils_test.py | 54 + .../error_metric_test_regression_test.py | 103 ++ .../error_metric_unity_test.py | 106 ++ .../farfield_propagator_regression_test.py | 92 ++ .../farfield_propagator_unity_test.py | 166 +++ ...bject_probe_interaction_regression_test.py | 1303 +++++++++++++++++ .../object_probe_interaction_unity_test.py | 44 + test/archive_tests/array_based_tests/utils.py | 66 + test/archive_tests/dls_tests/__init__.py | 0 .../dls_auxiliary_wave_kernel_test.py | 57 + .../dls_tests/dls_drpycuda_test.py | 83 ++ .../dls_gradient_descent_kernel_test.py | 261 ++++ .../dls_tests/dls_po_update_kernel_test.py | 106 ++ .../dls_tests/dls_propagation_kernel_test.py | 102 ++ .../dls_tests/dls_regularizer_kernel_test.py | 77 + test/core_tests/classes_test.py | 4 +- test/core_tests/import_ptypy_test.py | 12 +- test/engine_tests/DMOPR_test.py | 15 +- test/engine_tests/DM_simple_test.py | 23 - test/engine_tests/DM_test.py | 12 +- test/engine_tests/MLOPR_test.py | 15 +- test/engine_tests/ML_test.py | 27 +- test/engine_tests/engine_utils_test.py | 89 ++ test/ptyscan_tests/diamond_nexus_test.py | 16 +- test/ptyscan_tests/hdf5_loader_test.py | 18 +- test/util_tests/derivatives_test.py | 89 ++ test/utils.py | 129 +- tutorial/minimal_script.py | 4 +- tutorial/simupod.py | 5 +- 438 files changed, 55657 insertions(+), 1557 deletions(-) create mode 100644 .clang-format create mode 100644 archive/array_based/__init__.py create mode 100644 archive/array_based/array_utils.py create mode 100644 archive/array_based/base.py create mode 100644 archive/array_based/constraints.py create mode 100644 archive/array_based/data_utils.py create mode 100644 archive/array_based/error_metrics.py create mode 100644 archive/array_based/object_probe_interaction.py create mode 100644 archive/array_based/propagation.py create mode 100644 archive/cuda_extension/cuda/CMakeLists.txt create mode 100644 archive/cuda_extension/cuda/CMakeLists.txt.in create mode 100644 archive/cuda_extension/cuda/README.md create mode 100644 archive/cuda_extension/cuda/func/abs2.cu create mode 100644 archive/cuda_extension/cuda/func/abs2.h create mode 100644 archive/cuda_extension/cuda/func/addr_info_helpers.cpp create mode 100644 archive/cuda_extension/cuda/func/addr_info_helpers.h create mode 100644 archive/cuda_extension/cuda/func/center_probe.cu create mode 100644 archive/cuda_extension/cuda/func/center_probe.h create mode 100644 archive/cuda_extension/cuda/func/clip_complex_magnitudes_to_range.cu create mode 100644 archive/cuda_extension/cuda/func/clip_complex_magnitudes_to_range.h create mode 100644 archive/cuda_extension/cuda/func/complex_gaussian_filter.cu create mode 100644 archive/cuda_extension/cuda/func/complex_gaussian_filter.h create mode 100644 archive/cuda_extension/cuda/func/difference_map_fourier_constraint.cu create mode 100644 archive/cuda_extension/cuda/func/difference_map_fourier_constraint.h create mode 100644 archive/cuda_extension/cuda/func/difference_map_iterator.cu create mode 100644 archive/cuda_extension/cuda/func/difference_map_iterator.h create mode 100644 archive/cuda_extension/cuda/func/difference_map_overlap_constraint.cu create mode 100644 archive/cuda_extension/cuda/func/difference_map_overlap_constraint.h create mode 100644 archive/cuda_extension/cuda/func/difference_map_realspace_constraint.cu create mode 100644 archive/cuda_extension/cuda/func/difference_map_realspace_constraint.h create mode 100644 archive/cuda_extension/cuda/func/difference_map_update_object.cu create mode 100644 archive/cuda_extension/cuda/func/difference_map_update_object.h create mode 100644 archive/cuda_extension/cuda/func/difference_map_update_probe.cu create mode 100644 archive/cuda_extension/cuda/func/difference_map_update_probe.h create mode 100644 archive/cuda_extension/cuda/func/extract_array_from_exit_wave.cu create mode 100644 archive/cuda_extension/cuda/func/extract_array_from_exit_wave.h create mode 100644 archive/cuda_extension/cuda/func/far_field_error.cu create mode 100644 archive/cuda_extension/cuda/func/far_field_error.h create mode 100644 archive/cuda_extension/cuda/func/farfield_propagator.cu create mode 100644 archive/cuda_extension/cuda/func/farfield_propagator.h create mode 100644 archive/cuda_extension/cuda/func/get_difference.cu create mode 100644 archive/cuda_extension/cuda/func/get_difference.h create mode 100644 archive/cuda_extension/cuda/func/interpolated_shift.cu create mode 100644 archive/cuda_extension/cuda/func/interpolated_shift.h create mode 100644 archive/cuda_extension/cuda/func/log_likelihood.cu create mode 100644 archive/cuda_extension/cuda/func/log_likelihood.h create mode 100644 archive/cuda_extension/cuda/func/mass_center.cu create mode 100644 archive/cuda_extension/cuda/func/mass_center.h create mode 100644 archive/cuda_extension/cuda/func/norm2.cu create mode 100644 archive/cuda_extension/cuda/func/norm2.h create mode 100644 archive/cuda_extension/cuda/func/realspace_error.cu create mode 100644 archive/cuda_extension/cuda/func/realspace_error.h create mode 100644 archive/cuda_extension/cuda/func/renormalise_fourier_magnitudes.cu create mode 100644 archive/cuda_extension/cuda/func/renormalise_fourier_magnitudes.h create mode 100644 archive/cuda_extension/cuda/func/scan_and_multiply.cu create mode 100644 archive/cuda_extension/cuda/func/scan_and_multiply.h create mode 100644 archive/cuda_extension/cuda/func/sqrt_abs.cu create mode 100644 archive/cuda_extension/cuda/func/sum_to_buffer.cu create mode 100644 archive/cuda_extension/cuda/func/sum_to_buffer.h create mode 100644 archive/cuda_extension/cuda/splines/README.md create mode 100644 archive/cuda_extension/cuda/splines/bspline_kernel.cuh create mode 100644 archive/cuda_extension/cuda/splines/cubicPrefilter2D.cu create mode 100644 archive/cuda_extension/cuda/splines/cubicPrefilter2D.cuh create mode 100644 archive/cuda_extension/cuda/splines/cubicPrefilter_kernel.cu create mode 100644 archive/cuda_extension/cuda/splines/cubicPrefilter_kernel.cuh create mode 100644 archive/cuda_extension/cuda/splines/math_func.cu create mode 100644 archive/cuda_extension/cuda/splines/math_func.cuh create mode 100644 archive/cuda_extension/cuda/tests/gaussian_weights_test.cpp create mode 100644 archive/cuda_extension/cuda/tests/indexing_test.cpp create mode 100644 archive/cuda_extension/cuda/utils/Complex.h create mode 100644 archive/cuda_extension/cuda/utils/CudaFunction.cpp create mode 100644 archive/cuda_extension/cuda/utils/CudaFunction.h create mode 100644 archive/cuda_extension/cuda/utils/Errors.h create mode 100644 archive/cuda_extension/cuda/utils/FinalSumKernel.h create mode 100644 archive/cuda_extension/cuda/utils/GaussianWeights.h create mode 100644 archive/cuda_extension/cuda/utils/GpuManager.cu create mode 100644 archive/cuda_extension/cuda/utils/GpuManager.h create mode 100644 archive/cuda_extension/cuda/utils/Indexing.h create mode 100644 archive/cuda_extension/cuda/utils/Memory.cpp create mode 100644 archive/cuda_extension/cuda/utils/Memory.h create mode 100644 archive/cuda_extension/cuda/utils/Patches.h create mode 100644 archive/cuda_extension/cuda/utils/ScopedTimer.h create mode 100644 archive/cuda_extension/cuda/utils/Timer.h create mode 100644 archive/cuda_extension/engines/DM_gpu.py create mode 100644 archive/cuda_extension/engines/DM_npy.py create mode 100644 archive/cuda_extension/engines/gpu_testing.py create mode 100644 archive/cuda_extension/extensions.py create mode 100644 archive/cuda_extension/minimal_DMGpu_iterate_benchmark.py create mode 100644 archive/cuda_extension/minimal_DMNpy_iterate_benchmark.py create mode 100644 archive/cuda_extension/python/__init__.py create mode 100644 archive/cuda_extension/python/array_utils.py create mode 100644 archive/cuda_extension/python/config.py create mode 100644 archive/cuda_extension/python/constraints.py create mode 100644 archive/cuda_extension/python/cuda_functions.pxd create mode 100644 archive/cuda_extension/python/error_metrics.py create mode 100644 archive/cuda_extension/python/gpu_extension.pyx create mode 100644 archive/cuda_extension/python/object_probe_interaction.py create mode 100644 archive/cuda_extension/python/propagation.py create mode 100644 archive/cuda_extension/setup.py.cuda_extension create mode 100644 archive/cuda_extension/tests/__init__.py create mode 100644 archive/cuda_extension/tests/array_utils_test.py create mode 100644 archive/cuda_extension/tests/constraints_regression_test.py create mode 100644 archive/cuda_extension/tests/constraints_test.py create mode 100644 archive/cuda_extension/tests/data_utils_test.py create mode 100644 archive/cuda_extension/tests/engine_iterate_unity_test.py create mode 100644 archive/cuda_extension/tests/error_metric_test.py create mode 100644 archive/cuda_extension/tests/farfield_propagator_test.py create mode 100644 archive/cuda_extension/tests/minimal_numpy_DM_test.py create mode 100644 archive/cuda_extension/tests/minimal_numpy_DM_test_4096x4096.py create mode 100644 archive/cuda_extension/tests/minimal_numpy_DM_test_64x64.py create mode 100644 archive/cuda_extension/tests/minimal_numpy_ML_test.py create mode 100644 archive/cuda_extension/tests/object_probe_interaction_test.py create mode 100644 archive/cuda_extension/tests/utils.py rename {ptypy => archive}/engines/DM.py (98%) rename {ptypy => archive}/engines/DM_simple.py (98%) rename {ptypy => archive}/engines/dummy.py (98%) create mode 100644 archive/engines/projectional_pycuda_streams.py create mode 100644 archive/misc/mpitest.cpp create mode 100644 benchmark/cufft_vs_reikna.py create mode 100644 benchmark/diamond_benchmarks/ML_accurracy_test.py create mode 100644 benchmark/diamond_benchmarks/moonflower_scripts/i08.py create mode 100644 benchmark/diamond_benchmarks/moonflower_scripts/i13.py create mode 100644 benchmark/diamond_benchmarks/moonflower_scripts/i14_1.py create mode 100644 benchmark/diamond_benchmarks/moonflower_scripts/i14_2.py create mode 100755 benchmark/diamond_benchmarks/moonflower_scripts/profile_all.sh create mode 100755 benchmark/mpi_allreduce_bench.sh create mode 100755 benchmark/mpi_allreduce_bench_launcher.sh create mode 100755 benchmark/mpi_allreduce_bench_multinode.sh create mode 100644 benchmark/mpi_allreduce_speed.py create mode 100644 benchmark/tiled_vs_atomic.py create mode 100644 cufft/dependencies.yml create mode 100644 cufft/extensions.py create mode 100644 cufft/filtered_fft/.gitignore create mode 100644 cufft/filtered_fft/Makefile create mode 100644 cufft/filtered_fft/compiler_flags_info.txt create mode 100644 cufft/filtered_fft/errors.h create mode 100644 cufft/filtered_fft/filtered_fft.cu create mode 100644 cufft/filtered_fft/filtered_fft.h create mode 100644 cufft/filtered_fft/module.cpp create mode 100644 cufft/filtered_fft/smoke_test.cpp create mode 100644 cufft/filtered_fft/test_Makefile create mode 100644 cufft/setup.py rename core_dependencies.yml => dependencies_core.yml (63%) rename ptypy_full_dependencies.yml => dependencies_dev.yml (76%) create mode 100644 dependencies_full.yml rename {templates => ptypy/accelerate}/__init__.py (100%) create mode 100644 ptypy/accelerate/base/__init__.py create mode 100644 ptypy/accelerate/base/address_manglers.py create mode 100644 ptypy/accelerate/base/array_utils.py create mode 100644 ptypy/accelerate/base/engines/ML_serial.py create mode 100644 ptypy/accelerate/base/engines/__init__.py create mode 100644 ptypy/accelerate/base/engines/projectional_serial.py create mode 100644 ptypy/accelerate/base/engines/projectional_serial_stream.py create mode 100644 ptypy/accelerate/base/engines/stochastic.py create mode 100644 ptypy/accelerate/base/kernels.py create mode 100644 ptypy/accelerate/cuda_pycuda/__init__.py create mode 100644 ptypy/accelerate/cuda_pycuda/address_manglers.py create mode 100644 ptypy/accelerate/cuda_pycuda/array_utils.py create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/__init__.py create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/abs2sum.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/batched_multiply.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/build_aux.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/build_aux_no_ex.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/build_aux_position_correction.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/build_exit.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/build_exit_alpha_tau.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/clip_magnitudes.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/convolution.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/delx.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/dot.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/error_reduce.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/exit_error.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/fill3D.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/fill_b.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/fmag_all_update.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/fmag_update_nopbound.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/fourier_deviation.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/fourier_error.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/fourier_error2.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/fourier_update.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/full_reduce.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/gd_main.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/get_address.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/intens_renorm.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/interpolated_shift.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/log_likelihood.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/make_a012.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/make_aux.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/make_exit.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/make_model.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/mass_center.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/max_abs2.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/ob_norm_local.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/ob_update.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/ob_update2.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/ob_update2_ML.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/ob_update_ML.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/ob_update_local.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/pr_norm_local.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/pr_update.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/pr_update2.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/pr_update2_ML.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/pr_update_ML.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/pr_update_local.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/transpose.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cuda/update_addr_error_state.cu create mode 100644 ptypy/accelerate/cuda_pycuda/cufft.py create mode 100644 ptypy/accelerate/cuda_pycuda/dependencies.yml create mode 100644 ptypy/accelerate/cuda_pycuda/engines/ML_pycuda.py create mode 100644 ptypy/accelerate/cuda_pycuda/engines/__init__.py create mode 100644 ptypy/accelerate/cuda_pycuda/engines/projectional_pycuda.py create mode 100644 ptypy/accelerate/cuda_pycuda/engines/projectional_pycuda_stream.py create mode 100644 ptypy/accelerate/cuda_pycuda/engines/stochastic.py create mode 100644 ptypy/accelerate/cuda_pycuda/fft.py create mode 100644 ptypy/accelerate/cuda_pycuda/kernels.py create mode 100644 ptypy/accelerate/cuda_pycuda/mem_utils.py create mode 100644 ptypy/accelerate/cuda_pycuda/multi_gpu.py create mode 100644 ptypy/accelerate/cuda_pycuda/optimisation_log.md create mode 100644 ptypy/accelerate/ocl_pyopencl/__init__.py create mode 100644 ptypy/accelerate/ocl_pyopencl/engines/DM_ocl.py create mode 100644 ptypy/accelerate/ocl_pyopencl/engines/DM_ocl_npy.py rename full_dependencies.yml => ptypy/accelerate/ocl_pyopencl/full_dependencies.yml (83%) create mode 100644 ptypy/accelerate/ocl_pyopencl/kernel_heap.txt create mode 100644 ptypy/accelerate/ocl_pyopencl/npy_kernels.py create mode 100644 ptypy/accelerate/ocl_pyopencl/npy_kernels_for_block.py create mode 100644 ptypy/accelerate/ocl_pyopencl/ocl_fft.py create mode 100644 ptypy/accelerate/ocl_pyopencl/ocl_kernels.py create mode 100644 ptypy/accelerate/ocl_pyopencl/ocl_kernels_self_contained_for_future_reference.py rename ptypy/{engines => custom}/DMOPR.py (94%) create mode 100644 ptypy/custom/DM_object_regul.py create mode 100644 ptypy/custom/DM_pycuda_object_regul.py rename ptypy/{engines => custom}/MLOPR.py (92%) create mode 100644 ptypy/custom/__init__.py rename ptypy/{engines/ePIE.py => custom/ePIE_parallel.py} (93%) create mode 100644 ptypy/engines/projectional.py create mode 100644 ptypy/engines/stochastic.py delete mode 100644 ptypy_core_dependencies.yml delete mode 100644 resources/__init__.py delete mode 100644 resources/ptypy_logo_1M.png delete mode 100644 resources/tree.bmp create mode 100644 templates/accelerate/ptypy_i13_AuStar_farfield_pycuda.py create mode 100644 templates/accelerate/ptypy_i13_AuStar_nearfield_pycuda.py create mode 100644 templates/accelerate/ptypy_id22ni_AuStar_focused_pycuda.py create mode 100644 templates/accelerate/ptypy_laser_logo_focused_pycuda.py create mode 100644 templates/accelerate/ptypy_minimal_prep_and_run_pycuda.py create mode 100644 templates/engines/moonflower_DM.py create mode 100644 templates/engines/moonflower_DM_ML.py create mode 100644 templates/engines/moonflower_DM_ML_pycuda.py create mode 100644 templates/engines/moonflower_DM_ocl.py create mode 100644 templates/engines/moonflower_DM_pycuda.py create mode 100644 templates/engines/moonflower_DM_pycuda_nostream.py create mode 100644 templates/engines/moonflower_DM_serial.py create mode 100644 templates/engines/moonflower_EPIE.py create mode 100644 templates/engines/moonflower_EPIE_ML_pycuda.py create mode 100644 templates/engines/moonflower_EPIE_pycuda.py create mode 100644 templates/engines/moonflower_EPIE_serial.py rename templates/{minimal_prep_and_run_resample_ML.py => engines/moonflower_ML_Gaussian.py} (64%) rename templates/{minimal_prep_and_run_ML_Poisson.py => engines/moonflower_ML_Poisson.py} (83%) create mode 100644 templates/engines/moonflower_ML_pycuda.py create mode 100644 templates/engines/moonflower_ML_serial.py rename templates/{minimal_prep_and_run_ePIE.py => engines/moonflower_RAAR.py} (72%) create mode 100644 templates/engines/moonflower_RAAR_ML.py create mode 100644 templates/engines/moonflower_RAAR_ML_pycuda.py create mode 100644 templates/engines/moonflower_RAAR_pycuda.py create mode 100644 templates/engines/moonflower_RAAR_serial.py create mode 100644 templates/engines/moonflower_SDR.py create mode 100644 templates/engines/moonflower_SDR_pycuda.py create mode 100644 templates/engines/moonflower_SDR_serial.py rename templates/{ => experiment}/nanomax_zmq_run.py (83%) create mode 100644 templates/live_processing/moonflower_DM_delayed.py create mode 100644 templates/live_processing/moonflower_DM_delayed_pycuda.py rename templates/{ => live_processing}/on_the_fly_ptyd.py (100%) rename templates/{ => live_processing}/on_the_fly_rec.py (100%) rename templates/{ => misc}/bragg_field_of_view.py (98%) rename templates/{ => misc}/bragg_prep_and_run.py (95%) create mode 100644 templates/misc/moonflower_DM_object_regul.py create mode 100644 templates/misc/moonflower_DM_object_regul_pycuda.py rename templates/{probe_sharing.py => misc/moonflower_probe_sharing.py} (94%) rename templates/{ => misc}/pars_few_alldoc.py (100%) rename templates/{minimal_prep_and_run_probe_modes.py => model/moonflower_blockfull.py} (83%) create mode 100644 templates/model/moonflower_blockgradfull.py rename templates/{minimal_prep_and_run_resample_DM.py => model/moonflower_blockvanilla.py} (79%) rename templates/{minimal_prep_and_run_blockmodel.py => model/moonflower_full.py} (89%) rename templates/{minimal_prep_and_run_ML_Gaussian.py => model/moonflower_gradfull.py} (79%) rename templates/{simulation_test_OPR_scanmodel.py => model/moonflower_independent_probes.py} (91%) rename templates/{minimal_prep_and_run_probe_from_array.py => model/moonflower_probe_from_array.py} (87%) create mode 100644 templates/model/moonflower_probe_modes.py create mode 100644 templates/model/moonflower_resample.py rename templates/{minimal_prep_and_run.py => model/moonflower_vanilla.py} (89%) create mode 100644 templates/notebooks/moonflower_dm.ipynb create mode 100644 templates/notebooks/moonflower_dm_pycuda.ipynb create mode 100644 templates/notebooks/moonflower_epie.ipynb create mode 100644 templates/notebooks/moonflower_epie_pycuda.ipynb create mode 100644 templates/notebooks/moonflower_ml.ipynb create mode 100644 templates/notebooks/moonflower_ml_pycuda.ipynb create mode 100644 templates/notebooks/moonflower_raar.ipynb create mode 100644 templates/notebooks/moonflower_raar_pycuda.ipynb delete mode 100644 templates/position_evaluation.py rename templates/{position_refinement.py => position_refinement/moonflower_posref_DM.py} (57%) create mode 100644 templates/position_refinement/moonflower_posref_DM_pycuda.py create mode 100644 templates/position_refinement/moonflower_posref_DM_serial.py create mode 100644 templates/position_refinement/moonflower_posref_EPIE.py create mode 100644 templates/position_refinement/moonflower_posref_EPIE_pycuda.py create mode 100644 templates/position_refinement/moonflower_posref_ML.py create mode 100644 templates/position_refinement/moonflower_posref_ML_pycuda.py create mode 100644 templates/position_refinement/moonflower_posref_ML_serial.py create mode 100644 templates/position_refinement/moonflower_posref_SDR.py create mode 100644 templates/position_refinement/moonflower_posref_SDR_pycuda.py rename templates/{ptypy_i13_AuStar_farfield_9p0keV.py => ptypy_i13_AuStar_farfield.py} (86%) rename templates/{ptypy_i13_AuStar_nearfield_9p7keV.py => ptypy_i13_AuStar_nearfield.py} (86%) rename templates/{ptypy_id22ni_AuStar_focussed_17keV.py => ptypy_id22ni_AuStar_focused.py} (86%) rename templates/{ptypy_laser_logo_focussed_632nm.py => ptypy_laser_logo_focused.py} (77%) rename templates/{make_sample_ptyd.py => ptypy_make_sample_ptyd.py} (93%) rename templates/{minimal_load_and_run.py => ptypy_minimal_load_and_run.py} (79%) create mode 100644 templates/ptypy_minimal_prep_and_run.py create mode 100644 test/accelerate_tests/__init__.py create mode 100644 test/accelerate_tests/base_tests/__init__.py create mode 100644 test/accelerate_tests/base_tests/address_manglers_test.py create mode 100644 test/accelerate_tests/base_tests/array_utils_test.py create mode 100644 test/accelerate_tests/base_tests/auxiliary_wave_kernel_test.py create mode 100644 test/accelerate_tests/base_tests/engine_tests.py create mode 100644 test/accelerate_tests/base_tests/fourier_update_kernel_test.py create mode 100644 test/accelerate_tests/base_tests/gradient_descent_kernel_test.py create mode 100644 test/accelerate_tests/base_tests/import_test.py create mode 100644 test/accelerate_tests/base_tests/po_update_kernel_test.py create mode 100644 test/accelerate_tests/base_tests/position_correction_kernel_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/__init__.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/address_manglers_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/array_utils_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/auxiliary_wave_kernel_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/derivatives_kernel_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/engine_tests.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/engine_utils_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/fft_scaling_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/fft_setstream_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/fft_tests/__init__.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/fft_tests/cufft_init_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/fft_tests/fft_accuracy_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/fourier_update_kernel_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/gpudata_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/gradient_descent_kernel_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/import_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/multi_gpu_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/po_update_kernel_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/position_correction_kernel_test.py create mode 100644 test/accelerate_tests/cuda_pycuda_tests/propagation_kernel_test.py create mode 100644 test/accelerate_tests/ocl_pyopencl_tests/__init__.py create mode 100644 test/accelerate_tests/ocl_pyopencl_tests/ocl_kernels_test.py create mode 100644 test/archive_tests/__init__.py create mode 100644 test/archive_tests/array_based_tests/__init__.py create mode 100644 test/archive_tests/array_based_tests/constraints_regression_test.py create mode 100644 test/archive_tests/array_based_tests/constraints_unity_test.py create mode 100644 test/archive_tests/array_based_tests/data_utils_test.py create mode 100644 test/archive_tests/array_based_tests/error_metric_test_regression_test.py create mode 100644 test/archive_tests/array_based_tests/error_metric_unity_test.py create mode 100644 test/archive_tests/array_based_tests/farfield_propagator_regression_test.py create mode 100644 test/archive_tests/array_based_tests/farfield_propagator_unity_test.py create mode 100644 test/archive_tests/array_based_tests/object_probe_interaction_regression_test.py create mode 100644 test/archive_tests/array_based_tests/object_probe_interaction_unity_test.py create mode 100644 test/archive_tests/array_based_tests/utils.py create mode 100644 test/archive_tests/dls_tests/__init__.py create mode 100644 test/archive_tests/dls_tests/dls_auxiliary_wave_kernel_test.py create mode 100644 test/archive_tests/dls_tests/dls_drpycuda_test.py create mode 100644 test/archive_tests/dls_tests/dls_gradient_descent_kernel_test.py create mode 100644 test/archive_tests/dls_tests/dls_po_update_kernel_test.py create mode 100644 test/archive_tests/dls_tests/dls_propagation_kernel_test.py create mode 100644 test/archive_tests/dls_tests/dls_regularizer_kernel_test.py delete mode 100644 test/engine_tests/DM_simple_test.py create mode 100644 test/engine_tests/engine_utils_test.py create mode 100644 test/util_tests/derivatives_test.py diff --git a/.clang-format b/.clang-format new file mode 100644 index 000000000..59bde10c5 --- /dev/null +++ b/.clang-format @@ -0,0 +1,65 @@ +--- +Language: Cpp +# BasedOnStyle: Google +AccessModifierOffset: -2 +AlignAfterOpenBracket: true +AlignEscapedNewlinesLeft: false +AlignOperands: true +AlignTrailingComments: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: true +AllowShortFunctionsOnASingleLine: All +AlwaysBreakAfterDefinitionReturnType: false +AlwaysBreakTemplateDeclarations: true +AlwaysBreakBeforeMultilineStrings: true +BreakBeforeBinaryOperators: None +BreakBeforeTernaryOperators: true +BreakConstructorInitializersBeforeComma: false +BinPackParameters: false +BinPackArguments: false +ColumnLimit: 80 +ConstructorInitializerAllOnOneLineOrOnePerLine: true +ConstructorInitializerIndentWidth: 4 +DerivePointerAlignment: true +ExperimentalAutoDetectBinPacking: false +IndentCaseLabels: true +IndentWrappedFunctionNames: false +IndentFunctionDeclarationAfterType: false +MaxEmptyLinesToKeep: 1 +KeepEmptyLinesAtTheStartOfBlocks: false +NamespaceIndentation: None +ObjCBlockIndentWidth: 2 +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: false +PenaltyBreakBeforeFirstCallParameter: 1 +PenaltyBreakComment: 300 +PenaltyBreakString: 1000 +PenaltyBreakFirstLessLess: 120 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 200 +PointerAlignment: Left +SpacesBeforeTrailingComments: 2 +Cpp11BracedListStyle: true +Standard: Auto +IndentWidth: 2 +TabWidth: 8 +UseTab: Never +BreakBeforeBraces: Allman +SpacesInParentheses: false +SpacesInSquareBrackets: false +SpacesInAngles: false +SpaceInEmptyParentheses: false +SpacesInCStyleCastParentheses: false +SpaceAfterCStyleCast: false +SpacesInContainerLiterals: true +SpaceBeforeAssignmentOperators: true +ContinuationIndentWidth: 4 +CommentPragmas: '^ IWYU pragma:' +ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ] +SpaceBeforeParens: ControlStatements +DisableFormat: false +... + diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index e54efc09c..411302b25 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -21,37 +21,39 @@ jobs: runs-on: ubuntu-latest strategy: max-parallel: 5 + matrix: + python-version: [3.7,3.8,3.9] steps: - uses: actions/checkout@v2 - - name: Set up Python 3.7 + - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v2 with: - python-version: 3.7 + python-version: ${{ matrix.python-version }} - name: Add conda to system path run: | # $CONDA is an environment variable pointing to the root of the miniconda directory echo $CONDA/bin >> $GITHUB_PATH - name: Install dependencies run: | - conda env update --file ptypy_core_dependencies.yml --name base + conda env update --file dependencies_core.yml --name base - name: Prepare ptypy run: | # Dry install to create ptypy/version.py python setup.py install -n -# - name: Lint with flake8 -# run: | -# conda install flake8 -# # stop the build if there are Python syntax errors or undefined names -# flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics -# # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide -# flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics + - name: Lint with flake8 + run: | + conda install flake8 + # stop the build if there are Python syntax errors or undefined names + flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics + # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide + # flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - name: Test with pytest run: | conda install pytest conda install pytest-cov - # pytest ptypy/test --doctest-modules --junitxml=junit/test-results.xml --cov=ptypy --cov-report=xml --cov-report=html --cov-config=.coveragerc - pytest + # pytest ptypy/test -v --doctest-modules --junitxml=junit/test-results.xml --cov=ptypy --cov-report=xml --cov-report=html --cov-config=.coveragerc + pytest -v # - name: cobertura-report # if: github.event_name == 'pull_request' && (github.event.action == 'opened' || github.event.action == 'reopened' || github.event.action == 'synchronize') # uses: 5monkeys/cobertura-action@v7 diff --git a/.gitignore b/.gitignore index 63373d719..5655be7fd 100644 --- a/.gitignore +++ b/.gitignore @@ -28,3 +28,4 @@ ptypy/version.py /env *.egg-info .DS_Store +.ipynb_checkpoints diff --git a/.travis.yml b/.travis.yml index fd5326f2e..de282d218 100644 --- a/.travis.yml +++ b/.travis.yml @@ -3,6 +3,8 @@ sudo: true language: python python: - 3.7 +compiler: + - gcc before_install: - wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh; # grab miniconda - bash miniconda.sh -b -p $HOME/miniconda # install miniconda @@ -12,6 +14,21 @@ before_install: - conda install pyyaml - conda info -a # and print the info + - CUDA=10.1.105-1 + - CUDA_SHORT=10.1 + - UBUNTU_VERSION=ubuntu1804 + - INSTALLER=cuda-repo-${UBUNTU_VERSION}_${CUDA}_amd64.deb + - wget http://developer.download.nvidia.com/compute/cuda/repos/${UBUNTU_VERSION}/x86_64/${INSTALLER} + - sudo dpkg -i ${INSTALLER} + - wget https://developer.download.nvidia.com/compute/cuda/repos/${UBUNTU_VERSION}/x86_64/7fa2af80.pub + - sudo apt-key add 7fa2af80.pub + - sudo apt update -qq + - sudo apt install -y cuda-core-${CUDA_SHORT/./-} cuda-cudart-dev-${CUDA_SHORT/./-} cuda-cufft-dev-${CUDA_SHORT/./-} cuda-curand-dev-${CUDA_SHORT/./-} + - sudo apt clean + - CUDA_HOME=/usr/local/cuda-${CUDA_SHORT} + - LD_LIBRARY_PATH=${CUDA_HOME}/lib64:${LD_LIBRARY_PATH} + - PATH=${CUDA_HOME}/bin:${PATH} + env: - TEST_ENV_NAME=ptypy_core_dependencies - TEST_ENV_NAME=ptypy_full_dependencies @@ -27,7 +44,7 @@ script: - echo $PYTHONPATH - conda list - python setup.py install # install ptypy - - py.test ptypy/test -v --cov ptypy --cov-report term-missing # now run the tests + - py.test test -v --ignore=ptypy/test/accelerate_tests --cov ptypy --cov-report term-missing # now run the tests after_script: - coveralls diff --git a/README.rst b/README.rst index 02a9c1ec3..1083c3160 100644 --- a/README.rst +++ b/README.rst @@ -33,8 +33,9 @@ To get started quickly, please find the official documentation at the project pa Features -------- -* **Difference Map** [#dm]_ algorithm engine with power bound constraint +* **Difference Map** [#dm]_ algorithm engine with power bound constraint [#power]_. * **Maximum Likelihood** [#ml]_ engine with preconditioners and regularizers. +* A few more engines (RAAR, sDR, ePIE, ...). * **Fully parallelized** (CPU only) using the Massage Passing Interface (`MPI `_). @@ -42,6 +43,8 @@ Features $ mpiexec -n [nodes] python .py +* **GPU acceleration** based on custom kernels, pycuda, and reikna. + * A **client-server** approach for visualization and control based on `ZeroMQ `_ . The reconstruction may run on a remote hpc cluster while your desktop @@ -60,11 +63,11 @@ Installation Installation should be as simple as :: - $ sudo python setup.py install + $ sudo pip install . or, as a user, :: - $ python setup.py install --user + $ pip install . --user Dependencies @@ -130,3 +133,5 @@ References .. [#dm] P.Thibault, M.Dierolf *et al.*, *Science* **321**, 7 (2009), `doi `_ .. [#ml] P.Thibault and M.Guizar-Sicairos, *New J. of Phys.* **14**, 6 (2012), `doi `_ + +.. [#power] K.Giewekemeyer *et al.*, **PNAS 108**, 2 (2007), `suppl. material `__, `doi `__ diff --git a/archive/array_based/__init__.py b/archive/array_based/__init__.py new file mode 100644 index 000000000..4221257bd --- /dev/null +++ b/archive/array_based/__init__.py @@ -0,0 +1,7 @@ +''' +A module for gpu acceleration + +''' +import numpy as np +COMPLEX_TYPE= np.complex64 +FLOAT_TYPE = np.float32 \ No newline at end of file diff --git a/archive/array_based/array_utils.py b/archive/array_based/array_utils.py new file mode 100644 index 000000000..c2d341711 --- /dev/null +++ b/archive/array_based/array_utils.py @@ -0,0 +1,87 @@ +''' +useful utilities from ptypy that should be ported to gpu. These don't ahve external dependencies +''' +import numpy as np +from scipy import ndimage as ndi + + +def dot(A, B, acc_dtype=np.float64): + assert A.dtype == B.dtype, "Input arrays must of same data type" + if np.iscomplexobj(B): + out = np.sum(np.multiply(A, B.conj()).real, dtype=acc_dtype) + else: + out = np.sum(np.multiply(A, B), dtype=acc_dtype) + return out + + +def norm2(A): + return dot(A, A) + + +def abs2(input): + ''' + + :param input. An array that we want to take the absolute value of and square. Can be inplace. Can be complex or real. + :return: The real valued abs**2 array + ''' + return np.multiply(input, input.conj()).real + +def sum_to_buffer(in1, outshape, in1_addr, out1_addr, dtype): + ''' + :param in1. An array . Can be inplace. Can be complex or real. + :param outshape. An array. + :param in1_addr. An array . Can be inplace. Can be complex or real. + :param out1_addr. An array . Can be inplace. Can be complex or real. + :return: The real valued abs**2 array + ''' + out1 = np.zeros(outshape, dtype=dtype) + inshape = in1.shape + for i1, o1 in zip(in1_addr, out1_addr): + out1[o1[0], o1[1]:(o1[1] + inshape[1]), o1[2]:(o1[2] + inshape[2])] += in1[i1[0]] + return out1 + +def norm2(input): + ''' + Input here could be a variety of 1D, 2D, 3D complex or real. all will be single precision at least. + return should be real + ''' + return np.sum(abs2(input)) + +def complex_gaussian_filter(input, mfs): + ''' + takes 2D and 3D arrays. Complex input, complex output. mfs has len 02: + raise NotImplementedError("Only batches of 2D arrays allowed!") + + if input.ndim == 3: + mfs = np.insert(mfs, 0, 0) + + return (ndi.gaussian_filter(np.real(input), mfs) +1j *ndi.gaussian_filter(np.imag(input), mfs)).astype(input.dtype) + +def mass_center(A): + ''' + Input will always be real, and 2d or 3d, single precision here + ''' + return np.array(ndi.measurements.center_of_mass(A), dtype=A.dtype) + +def interpolated_shift(c, shift, do_linear=False): + ''' + complex bicubic interpolated shift. + complex output. This shift should be applied to 2D arrays. shift should have len=c.ndims + + ''' + if not do_linear: + return ndi.interpolation.shift(np.real(c), shift, order=3, prefilter=True) + 1j*ndi.interpolation.shift(np.imag(c), shift, order=3, prefilter=True) + else: + return ndi.interpolation.shift(np.real(c), shift, order=1, mode='constant', cval=0, prefilter=False) + 1j * ndi.interpolation.shift(np.imag(c), shift, order=1, mode='constant', cval=0, prefilter=False) + + +def clip_complex_magnitudes_to_range(complex_input, clip_min, clip_max): + ''' + This takes a single precision 2D complex input, clips the absolute magnitudes to be within a range, but leaves the phase untouched. + ''' + ampl = np.abs(complex_input) + phase = np.exp(1j * np.angle(complex_input)) + ampl = np.clip(ampl, clip_min, clip_max) + complex_input[:] = ampl * phase \ No newline at end of file diff --git a/archive/array_based/base.py b/archive/array_based/base.py new file mode 100644 index 000000000..7429bbd2b --- /dev/null +++ b/archive/array_based/base.py @@ -0,0 +1,22 @@ +from collections import OrderedDict + +class Adict(object): + + def __init__(self): + pass + + +class BaseKernel(object): + + def __init__(self, queue_thread=None, verbose=False): + + self.queue = queue_thread + self.verbose = False + self.npy = Adict() + self.ocl = Adict() + self.benchmark = OrderedDict() + + + def log(self, x): + if self.verbose: + print(x) \ No newline at end of file diff --git a/archive/array_based/constraints.py b/archive/array_based/constraints.py new file mode 100644 index 000000000..b70abae3d --- /dev/null +++ b/archive/array_based/constraints.py @@ -0,0 +1,143 @@ +''' +a module to holds the constraints +''' + +import numpy as np + +from .error_metrics import log_likelihood, far_field_error, realspace_error +from .object_probe_interaction import difference_map_realspace_constraint, scan_and_multiply, difference_map_overlap_update +from .propagation import farfield_propagator +from ptypy.accelerate.array_based import array_utils as au +from ptypy.accelerate.array_based import COMPLEX_TYPE, FLOAT_TYPE + +def renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound): + renormed_f = np.zeros(f.shape, dtype=COMPLEX_TYPE) + for _pa, _oa, ea, da, ma in addr_info: + m = mask[ma[0]] + magnitudes = fmag[da[0]] + absolute_magnitudes = af[da[0]] + fourier_space_solution = f[ea[0]] + fourier_error = err_fmag[da[0]] + if pbound is None: + fm = (1 - m) + m * magnitudes / (absolute_magnitudes + 1e-10) + renormed_f[ea[0]] = np.multiply(fm, fourier_space_solution) + elif (fourier_error > pbound): + # Power bound is applied + fdev = absolute_magnitudes - magnitudes + renorm = np.sqrt(pbound / fourier_error) + fm = (1 - m) + m * (magnitudes + fdev * renorm) / (absolute_magnitudes + 1e-10) + renormed_f[ea[0]] = np.multiply(fm, fourier_space_solution) + else: + renormed_f[ea[0]] = np.zeros_like(fourier_space_solution) + return renormed_f + +def get_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, probe_object): + df = np.zeros(exit_wave.shape, dtype=COMPLEX_TYPE) + for _pa, _oa, ea, da, ma in addr_info: + if (pbound is None) or (err_fmag[da[0]] > pbound): + df[ea[0]] = np.subtract(backpropagated_solution[ea[0]], probe_object[ea[0]]) + else: + df[ea[0]] = alpha * np.subtract(probe_object[ea[0]], exit_wave[ea[0]]) + return df + +def difference_map_fourier_constraint(mask, Idata, obj, probe, exit_wave, addr_info, prefilter, postfilter, pbound=None, alpha=1.0, LL_error=True, do_realspace_error=True): + ''' + This kernel just performs the fourier renormalisation. + :param mask. The nd mask array + :param diffraction. The nd diffraction data + :param farfield_stack. The current iterant. + :param addr. The addresses of the stacks. + :return: The updated iterant + : fourier errors + ''' + + probe_object = scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + + # Buffer for accumulated photons + # For log likelihood error # need to double check this adp + if LL_error is True: + err_phot = log_likelihood(probe_object, mask, Idata, prefilter, postfilter, addr_info) + else: + err_phot = np.zeros(Idata.shape[0], dtype=FLOAT_TYPE) + + + constrained = difference_map_realspace_constraint(probe_object, exit_wave, alpha) + + f = farfield_propagator(constrained, prefilter, postfilter, direction='forward') + pa, oa, ea, da, ma = zip(*addr_info) + af2 = au.sum_to_buffer(au.abs2(f), Idata.shape, ea, da, dtype=FLOAT_TYPE) + + fmag = np.sqrt(np.abs(Idata)) + af = np.sqrt(af2) + # # Fourier magnitudes deviations(current_solution, pbound, measured_solution, mask, addr) + err_fmag = far_field_error(af, fmag, mask) + + vectorised_rfm = renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + + backpropagated_solution = farfield_propagator(vectorised_rfm, + postfilter.conj(), + prefilter.conj(), + direction='backward') + + + df = get_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, probe_object) + + + + exit_wave += df + if do_realspace_error: + ea_first_column = np.array(ea)[:, 0] + da_first_column = np.array(da)[:, 0] + err_exit = realspace_error(df, ea_first_column, da_first_column, Idata.shape[0]) + else: + err_exit = np.zeros((Idata.shape[0])) + + if pbound is not None: + err_fmag /= pbound + + return np.array([err_fmag, err_phot, err_exit]) + + +def difference_map_iterator(diffraction, obj, object_weights, cfact_object, mask, probe, cfact_probe, probe_support, + probe_weights, exit_wave, addr, pre_fft, post_fft, pbound, overlap_max_iterations, update_object_first, + obj_smooth_std, overlap_converge_factor, probe_center_tol, probe_update_start, alpha=1, + clip_object=None, LL_error=False, num_iterations=1): + curiter = 0 + + errors = np.zeros((num_iterations, 3, len(diffraction)), dtype=FLOAT_TYPE) + for it in range(num_iterations): + if (((it+1) % 10) == 0) and (it>0): + print("iteration:%s" % (it+1)) # it's probably a good idea to print this if possible for some idea of progress + # numpy dump here for 64x64 and 4096x4096 + + errors[it] = difference_map_fourier_constraint(mask, + diffraction, + obj, + probe, + exit_wave, + addr, + prefilter=pre_fft, + postfilter=post_fft, + pbound=pbound, + alpha=alpha, + LL_error=LL_error) + + do_update_probe = (probe_update_start <= curiter) + difference_map_overlap_update(addr, + cfact_object, + cfact_probe, + do_update_probe, + exit_wave, + obj, + object_weights, + probe, + probe_support, + probe_weights, + overlap_max_iterations, + update_object_first, + obj_smooth_std, + overlap_converge_factor, + probe_center_tol, + clip_object=clip_object) + curiter += 1 + return errors \ No newline at end of file diff --git a/archive/array_based/data_utils.py b/archive/array_based/data_utils.py new file mode 100644 index 000000000..44810410c --- /dev/null +++ b/archive/array_based/data_utils.py @@ -0,0 +1,90 @@ +''' +Created on 4 Jan 2018 + +@author: clb02321 +''' + +import numpy as np +from ptypy.accelerate.array_based import FLOAT_TYPE + + +def _vectorise_array_access(diff_storage): + # Sort views according to layer in diffraction stack + views = diff_storage.views + dlayers = [view.dlayer for view in views] + views = [views[i] for i in np.argsort(dlayers)] + view_IDs = [view.ID for view in views] + + # Master pod + mpod = views[0].pod + + # Determine linked storages for probe, object and exit waves + pr = mpod.pr_view.storage + ob = mpod.ob_view.storage + ex = mpod.ex_view.storage + + poe_ID = (pr.ID, ob.ID, ex.ID) + probe_weights = [] + object_weights = [] + addr = [] + for view in views: + address = [] + for _pname, pod in view.pods.items(): + # store them for each pod + # create addresses + probe_weights.append(pod.probe_weight) + object_weights.append(pod.object_weight) + + a = np.array([ + (pod.pr_view.dlayer, pod.pr_view.dlow[0], pod.pr_view.dlow[1]), + (pod.ob_view.dlayer, pod.ob_view.dlow[0], pod.ob_view.dlow[1]), + (pod.ex_view.dlayer, pod.ex_view.dlow[0], pod.ex_view.dlow[1]), + (pod.di_view.dlayer, pod.di_view.dlow[0], pod.di_view.dlow[1]), + (pod.ma_view.dlayer, pod.ma_view.dlow[0], pod.ma_view.dlow[1])]) + addr.append(a) + + addr_out = np.array(addr).astype(np.int32) + + + return view_IDs, poe_ID, addr_out, np.array(probe_weights, dtype=np.float32), np.array(object_weights, dtype=np.float32) + +def pod_to_arrays(P, storage_id, scan_model='Full'): + ''' + :param P. A ptycho instance + :param: storage_id The storage ID for this scan. + + :return + a dictionary containing: + diffraction: The diffraction data + probe: the probe from the FIRST POD + obj: The object buffer + exit wave: The exit wave buffer + mask: The diffraction masks + meta: The meta data, containing an 'addr' array for the addresses + ''' + if scan_model == 'Full': + diffraction_storages_to_iterate = P.di.storages[storage_id] + mask_storages = P.ma.storages[storage_id] + view_IDs, poe_IDs, addr, probe_weights, object_weights = _vectorise_array_access(diffraction_storages_to_iterate) + meta = {'view_IDs': view_IDs, + 'poe_IDs': poe_IDs, + 'addr': addr} + main_pod = P.di.V[view_IDs[0]].pod # we will use this to get all the information + probe_array = main_pod.pr_view.storage.data + obj_array = main_pod.ob_view.storage.data + obj_viewcover = main_pod.ob_view.storage.get_view_coverage() + exit_wave_array = main_pod.ex_view.storage.data + mask_array = mask_storages.data # can we have booleans? + diff_array = diffraction_storages_to_iterate.data + + + return {'diffraction': diff_array, + 'probe': probe_array, + 'probe weights': probe_weights, + 'obj': obj_array, + 'object viewcover': obj_viewcover, + 'object weights': object_weights, + 'exit wave': exit_wave_array, + 'mask': mask_array, + 'meta': meta} + diff --git a/archive/array_based/error_metrics.py b/archive/array_based/error_metrics.py new file mode 100644 index 000000000..015247917 --- /dev/null +++ b/archive/array_based/error_metrics.py @@ -0,0 +1,37 @@ +''' +A module of the relevant error metrics +''' + +from .propagation import farfield_propagator +from ptypy.accelerate.array_based.array_utils import sum_to_buffer, abs2 +from ptypy.accelerate.array_based import FLOAT_TYPE, COMPLEX_TYPE +import numpy as np + + +def log_likelihood(probe_and_obj, mask, Idata, prefilter, postfilter, addr_info): + _pa, _oa, ea, da, ma = zip(*addr_info) + LLerror = np.zeros(Idata.shape[0], dtype=FLOAT_TYPE) + ft = farfield_propagator(probe_and_obj, prefilter, postfilter, direction='forward') + abs2_ft = abs2(ft) + LL = sum_to_buffer(abs2_ft, Idata.shape, ea, da, dtype=Idata.dtype) + + unq, idx = np.unique(np.array(da)[:,0], return_index=True) + for dai, mai in zip(np.array(da)[idx], np.array(ma)[idx]): + LLerror[dai[0]] = np.divide(np.sum(np.power(np.multiply(mask[mai[0]], (np.subtract(LL[dai[0]], Idata[dai[0]]))), 2) / np.add(Idata[dai[0]], 1.)), np.prod(LL[dai[0]].shape)) + return LLerror + +def far_field_error(current_solution, measured_solution, mask): + fdev = np.subtract(current_solution, measured_solution) + summed_mask = np.sum(mask, axis=(-2, -1)) + fdev2 = np.power(fdev, 2) + masked_fdev2 = np.multiply(mask, fdev2) + summed_masked_fdev2 = np.sum(masked_fdev2, axis=(-2, -1)) + err_fmag = summed_masked_fdev2 / summed_mask + return err_fmag + +def realspace_error(difference_in_exitwave, ea_first_column, da_first_column, out_length): + errors = np.mean(abs2(difference_in_exitwave), axis=(-2, -1)) + collapsed_errors = np.zeros((out_length,), dtype=FLOAT_TYPE) + for ea_idx, da_idx in zip(ea_first_column, da_first_column): + collapsed_errors[da_idx] += errors[ea_idx] + return collapsed_errors diff --git a/archive/array_based/object_probe_interaction.py b/archive/array_based/object_probe_interaction.py new file mode 100644 index 000000000..95230baad --- /dev/null +++ b/archive/array_based/object_probe_interaction.py @@ -0,0 +1,132 @@ +''' +object_probe_interaction + +Contains things pertinent to the probe and object interaction. +Should have all the engine updates +''' + +import numpy as np +from ptypy.accelerate.array_based.array_utils import norm2, complex_gaussian_filter, abs2, mass_center, interpolated_shift, clip_complex_magnitudes_to_range +from copy import deepcopy +from ptypy.accelerate.array_based import COMPLEX_TYPE + + +def difference_map_realspace_constraint(probe_and_object, exit_wave, alpha): + ''' + in theory this can just be called in ptypy instead of get_exit_wave + ''' + return (1.0 + alpha) * probe_and_object - alpha*exit_wave + + +def scan_and_multiply(probe, obj, exit_shape, addresses): + sh = exit_shape + po = np.zeros((sh[0], sh[1], sh[2]), dtype=COMPLEX_TYPE) + for pa, oa, ea, _da, _ma in addresses: + po[ea[0]] = np.multiply(probe[pa[0], pa[1]:(pa[1] + sh[1]), pa[2]:(pa[2] + sh[2])], + obj[oa[0], oa[1]:(oa[1] + sh[1]), oa[2]:(oa[2] + sh[2])]) + return po + + +def difference_map_update_object(ob, object_weights, probe, exit_wave, addr_info, cfact_object, ob_smooth_std=None, clip_object=None): + pa, oa, ea, _da, _ma = zip(*addr_info) + + if ob_smooth_std is not None: + smooth_mfs = [ob_smooth_std, ob_smooth_std] + ob[:] = cfact_object * complex_gaussian_filter(ob, smooth_mfs) + else: + ob *= cfact_object + + extract_array_from_exit_wave(exit_wave, ea, probe, pa, ob, oa, cfact_object, object_weights) + + if clip_object is not None: + clip_min, clip_max = clip_object + clip_complex_magnitudes_to_range(ob, clip_min, clip_max) + + +def difference_map_update_probe(ob, probe_weights, probe, exit_wave, addr_info, cfact_probe, probe_support=None): + pa, oa, ea, _da, _ma = zip(*addr_info) + old_probe = deepcopy(probe) + probe *= cfact_probe + extract_array_from_exit_wave(exit_wave, ea, ob, oa, probe, pa, cfact_probe, probe_weights) + if probe_support is not None: + probe *= probe_support + + change = norm2(probe - old_probe) /norm2(probe) + + return np.sqrt(change / probe.shape[0]) + + +def extract_array_from_exit_wave(exit_wave, exit_addr, array_to_be_extracted, extract_addr, array_to_be_updated, update_addr, cfact, weights): + ''' + :param exit_wave: The exit wave buffer + :param exit_addr: The addresses for + :param array_to_be_extracted: the array to be extracted from the exit_wave buffer. This is not updated + :param extract_addr: The addresses for the array to be extracted. + :param array_to_be_updated: This is updated in place. + :param update_addr: The addresses for the array that is to be updated + :param cfact: This is the scaling for the denominator of the updated array. Not updated. + :param weights: The weights for the extracted array + + ''' + sh = exit_wave.shape + array_to_be_updated_denominator = deepcopy(cfact) + for pa, oa, ea in zip(update_addr, extract_addr, exit_addr): + extracted_array = array_to_be_extracted[oa[0], oa[1]:(oa[1] + sh[1]), oa[2]:(oa[2] + sh[2])] + extracted_array_conj = extracted_array.conj() + array_to_be_updated[pa[0], pa[1]:(pa[1] + sh[1]), pa[2]:(pa[2] + sh[2])] += extracted_array_conj * \ + exit_wave[ea[0]] * \ + weights[pa[0]] + + array_to_be_updated_denominator[pa[0], pa[1]:(pa[1] + sh[1]), pa[2]:(pa[2] + sh[2])] += extracted_array * \ + extracted_array_conj * \ + weights[pa[0]] + + array_to_be_updated /= array_to_be_updated_denominator + + +def center_probe(probe, center_tolerance): + c1 = np.array(mass_center(abs2(probe).sum(axis=0))) + c2 = np.array(probe.shape[-2:]) // 2 + if np.sqrt(norm2(c1 - c2)) < center_tolerance: + return + offset = c2-c1 + for idx in range(probe.shape[0]): + probe[idx] = interpolated_shift(probe[idx], offset) + + +def difference_map_overlap_update(addr_info, cfact_object, cfact_probe, do_update_probe, exit_wave, ob, object_weights, + probe, probe_support, probe_weights,max_iterations, update_object_first, + obj_smooth_std, overlap_converge_factor, probe_center_tol, clip_object=None): + for inner in range(max_iterations): + + # Update object first + if update_object_first or (inner > 0): + # Update object + difference_map_update_object(ob, + object_weights, + probe, + exit_wave, + addr_info, + cfact_object, + ob_smooth_std=obj_smooth_std, + clip_object=clip_object) + + # Exit if probe should not be updated yet + if not do_update_probe: + break + # Update probe + change = difference_map_update_probe(ob, + probe_weights, + probe, + exit_wave, + addr_info, + cfact_probe, + probe_support) + + # Recenter the probe + if probe_center_tol is not None: + center_probe(probe, probe_center_tol) + + # Stop iteration if probe change is small + if change < overlap_converge_factor: + break diff --git a/archive/array_based/propagation.py b/archive/array_based/propagation.py new file mode 100644 index 000000000..413654fe2 --- /dev/null +++ b/archive/array_based/propagation.py @@ -0,0 +1,52 @@ +''' +All propagation based kernels +''' +import numpy as np +from ptypy.accelerate.array_based import COMPLEX_TYPE + +def farfield_propagator(data_to_be_transformed, prefilter=None, postfilter=None, direction='forward'): + ''' + performs a fourier transform on the nd exit wave stack. FFT shift and normalisation performed by + multiplication with prefilter and postfilter + :param data_to_be_transformed. The nd stack of the current iterant. + :param prefilter. The filter to multiply before fourier transforming. Default: None. + :param postfilter. The filter to multiply after fourier transforming. Default: None. + :param direction. The direction of the transform forward or backward. Default: Forward. + :return: The transformed stack. + ''' + + dtype = data_to_be_transformed.dtype + if direction == 'forward': + def fft(x): + output = np.zeros(x.shape, dtype=dtype) + for idx in range(output.shape[0]): + output[idx] = np.fft.fft2(x[idx]) + return output + + sc = 1.0 / np.sqrt(np.prod(data_to_be_transformed.shape[-2:])) + + elif direction == 'backward': + def fft(x): + output = np.zeros(x.shape, dtype=dtype) + for idx in range(output.shape[0]): + output[idx] = np.fft.ifft2(x[idx]) + return output + + sc = np.sqrt(np.prod(data_to_be_transformed.shape[-2:])) + + if (prefilter is None) and (postfilter is None): + return fft(data_to_be_transformed) * sc + elif (prefilter is None) and (postfilter is not None): + postfilter = postfilter.astype(dtype) + return np.multiply(postfilter, fft(data_to_be_transformed)) * sc + elif (prefilter is not None) and (postfilter is None): + prefilter = prefilter.astype(dtype) + return fft(np.multiply(data_to_be_transformed, prefilter))* sc + elif (prefilter is not None) and (postfilter is not None): + prefilter = prefilter.astype(dtype) + postfilter = postfilter.astype(dtype) + return np.multiply(postfilter, fft(np.multiply(data_to_be_transformed, prefilter))) * sc + +def sqrt_abs(diffraction): + return np.sqrt(np.abs(diffraction)) + diff --git a/archive/cuda_extension/cuda/CMakeLists.txt b/archive/cuda_extension/cuda/CMakeLists.txt new file mode 100644 index 000000000..e158c762a --- /dev/null +++ b/archive/cuda_extension/cuda/CMakeLists.txt @@ -0,0 +1,135 @@ +# version 3.8+ is needed, otherwise there's no CUDA support +cmake_minimum_required(VERSION 3.8 FATAL_ERROR) + +project(ptypy_cuda LANGUAGES CXX CUDA) + +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CUDA_STANDARD 11) + +option(GPU_TIMING "Run timing for the GPU code" OFF) + +############################################################################ +## Download and unpack googletest at configure time +#configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt) +#execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" . +# RESULT_VARIABLE result +# WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/googletest-download ) +#if(result) +# message(FATAL_ERROR "CMake step for googletest failed: ${result}") +#endif() +#execute_process(COMMAND ${CMAKE_COMMAND} --build . +# RESULT_VARIABLE result +# WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/googletest-download ) +#if(result) +# message(FATAL_ERROR "Build step for googletest failed: ${result}") +#endif() + +## Prevent overriding the parent project's compiler/linker +## settings on Windows +#set(gtest_force_shared_crt ON CACHE BOOL "" FORCE) +# +## Add googletest directly to our build. This defines +## the gtest and gtest_main targets. +#add_subdirectory(${CMAKE_BINARY_DIR}/googletest-src +# ${CMAKE_BINARY_DIR}/googletest-build +# EXCLUDE_FROM_ALL) +# +## The gtest/gtest_main targets carry header search path +## dependencies automatically when using CMake 2.8.11 or +## later. Otherwise we have to add them here ourselves. +#if (CMAKE_VERSION VERSION_LESS 2.8.11) +# include_directories("${gtest_SOURCE_DIR}/include") +#endif() +############################################################################ + + +include_directories(.) + +add_library(gpu_extension STATIC + utils/Complex.h + utils/CudaFunction.h + utils/CudaFunction.cpp + utils/Errors.h + utils/Memory.h + utils/Memory.cpp + utils/ScopedTimer.h + utils/Timer.h + utils/GpuManager.h + utils/GpuManager.cu + + func/addr_info_helpers.h + func/addr_info_helpers.cpp + + func/farfield_propagator.h + func/farfield_propagator.cu + func/sqrt_abs.cu + func/scan_and_multiply.h + func/scan_and_multiply.cu + func/difference_map_realspace_constraint.h + func/difference_map_realspace_constraint.cu + func/log_likelihood.h + func/log_likelihood.cu + func/abs2.h + func/abs2.cu + func/sum_to_buffer.cu + func/sum_to_buffer.h + func/far_field_error.h + func/far_field_error.cu + func/realspace_error.h + func/realspace_error.cu + func/get_difference.h + func/get_difference.cu + func/renormalise_fourier_magnitudes.h + func/renormalise_fourier_magnitudes.cu + func/difference_map_fourier_constraint.h + func/difference_map_fourier_constraint.cu + func/norm2.h + func/norm2.cu + func/mass_center.h + func/mass_center.cu + func/clip_complex_magnitudes_to_range.h + func/clip_complex_magnitudes_to_range.cu + func/extract_array_from_exit_wave.h + func/extract_array_from_exit_wave.cu + func/interpolated_shift.cu + func/interpolated_shift.h + func/center_probe.h + func/center_probe.cu + func/difference_map_update_probe.h + func/difference_map_update_probe.cu + func/difference_map_update_object.h + func/difference_map_update_object.cu + func/difference_map_overlap_constraint.h + func/difference_map_overlap_constraint.cu + func/complex_gaussian_filter.h + func/complex_gaussian_filter.cu + func/difference_map_iterator.h + func/difference_map_iterator.cu +) + +set_target_properties(gpu_extension PROPERTIES + CUDA_RESOLVE_DEVICE_SYMBOLS OFF # no device-link symbols + CUDA_SEPARABLE_COMPILATION OFF # no device-side linking + POSITION_INDEPENDENT_CODE ON # allow linking into a dynamic lib +) + +# add "DO_GPU_TIMING" if option is true +if(GPU_TIMING) + set_target_properties(gpu_extension PROPERTIES + COMPILE_DEFINITIONS DO_GPU_TIMING + ) +endif() + +########### tests ########### + +#enable_testing() + +#macro(buildtest name) +# add_executable(${name} tests/${name}.cpp) +# target_link_libraries(${name} gtest_main) +# add_test(NAME ${name} COMMAND ${name}) +#endmacro() + +#buildtest(indexing_test) +#buildtest(gaussian_weights_test) + diff --git a/archive/cuda_extension/cuda/CMakeLists.txt.in b/archive/cuda_extension/cuda/CMakeLists.txt.in new file mode 100644 index 000000000..d60a33e9a --- /dev/null +++ b/archive/cuda_extension/cuda/CMakeLists.txt.in @@ -0,0 +1,15 @@ +cmake_minimum_required(VERSION 2.8.2) + +project(googletest-download NONE) + +include(ExternalProject) +ExternalProject_Add(googletest + GIT_REPOSITORY https://github.com/google/googletest.git + GIT_TAG master + SOURCE_DIR "${CMAKE_BINARY_DIR}/googletest-src" + BINARY_DIR "${CMAKE_BINARY_DIR}/googletest-build" + CONFIGURE_COMMAND "" + BUILD_COMMAND "" + INSTALL_COMMAND "" + TEST_COMMAND "" +) \ No newline at end of file diff --git a/archive/cuda_extension/cuda/README.md b/archive/cuda_extension/cuda/README.md new file mode 100644 index 000000000..c0dbb7a1a --- /dev/null +++ b/archive/cuda_extension/cuda/README.md @@ -0,0 +1,19 @@ +# CUDA Module for Ptypy + +Builds the functions for GPU extension module, using CMake 3.8+. + +It gets built automatically together with setup.py. + +## Tests + +Some unit tests are implemented on the C++ level, using google +test. The test framework is automatically downloaded and built +during the regular cmake build. Run "make test" in the build +directory (normally build/cuda) to run the tests. + +## Naming Conventions + +- parameter_name_ == this->parameter_name +- d_parameter_name == device pointer to parameter, everything else is host + +## setup.py Build diff --git a/archive/cuda_extension/cuda/func/abs2.cu b/archive/cuda_extension/cuda/func/abs2.cu new file mode 100644 index 000000000..b1a657255 --- /dev/null +++ b/archive/cuda_extension/cuda/func/abs2.cu @@ -0,0 +1,133 @@ +#include "abs2.h" + +#include "utils/Complex.h" +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +/************ Kernels *********************/ + +// must be real, if this template fits +template +__global__ void abs2_kernel(const T *in, T *out, size_t n) +{ + size_t ti = threadIdx.x + blockIdx.x * blockDim.x; + if (ti >= n) + return; + auto v = in[ti]; + out[ti] = v * v; +} + +// complex to real +template +__global__ void abs2_kernel(const Tc *in, T *out, size_t n) +{ + size_t ti = threadIdx.x + blockIdx.x * blockDim.x; + if (ti >= n) + return; + auto v = in[ti]; + out[ti] = v.real() * v.real() + v.imag() * v.imag(); +} + +/************ Class methods *****************/ + +template +Abs2::Abs2() : CudaFunction("abs2") +{ +} + +template +void Abs2::setParameters(size_t n) +{ + n_ = n; +} + +template +void Abs2::setDeviceBuffers(Tin *d_datain, Tout *d_dataout) +{ + d_datain_ = d_datain; + d_dataout_ = d_dataout; +} + +template +void Abs2::allocate() +{ + ScopedTimer t(this, "allocate"); + d_datain_.allocate(n_); + d_dataout_.allocate(n_); +} + +template +Tout *Abs2::getOutput() const +{ + return d_dataout_.get(); +} + +template +void Abs2::transfer_in(const Tin *datain) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_datain_.get(), datain, n_); +} + +template +void Abs2::transfer_out(Tout *dataout) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(dataout, d_dataout_.get(), n_); +} + +template +void Abs2::run() +{ + ScopedTimer t(this, "run"); + size_t block = 256; + size_t blocks = (n_ + block - 1) / block; + abs2_kernel<<>>(d_datain_.get(), d_dataout_.get(), n_); + checkLaunchErrors(); + + // sync device if timing is enabled + timing_sync(); +} + +/************** interface function *************/ + +// instantiate here to force creating all symbols +template class Abs2; +template class Abs2, float>; +template class Abs2; +template class Abs2, double>; + +template +static void entryFunc(const Tin *in, Tout *out, int n) +{ + auto abs2 = gpuManager.get_cuda_function>( + "abs2<" + getTypeName() + "," + getTypeName() + ">", n); + abs2->allocate(); + abs2->transfer_in(in); + abs2->run(); + abs2->transfer_out(out); +} + +extern "C" void abs2_c(const float *in, float *out, int n, int iisComplex) +{ + if (iisComplex != 0) + { + entryFunc(reinterpret_cast *>(in), out, n); + } + else + { + entryFunc(in, out, n); + } +} + +extern "C" void abs2d_c(const double *in, double *out, int n, int iisComplex) +{ + if (iisComplex != 0) + { + entryFunc(reinterpret_cast *>(in), out, n); + } + else + { + entryFunc(in, out, n); + } +} diff --git a/archive/cuda_extension/cuda/func/abs2.h b/archive/cuda_extension/cuda/func/abs2.h new file mode 100644 index 000000000..f5a7f3ea6 --- /dev/null +++ b/archive/cuda_extension/cuda/func/abs2.h @@ -0,0 +1,23 @@ +#pragma once + +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +template +class Abs2 : public CudaFunction +{ +public: + Abs2(); + void setParameters(size_t n); + void setDeviceBuffers(Tin *d_datain, Tout *d_dataout); + void allocate(); + Tout *getOutput() const; + void transfer_in(const Tin *datain); + void transfer_out(Tout *dataout); + void run(); + +private: + DevicePtrWrapper d_datain_; + DevicePtrWrapper d_dataout_; + size_t n_ = 0; +}; \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/addr_info_helpers.cpp b/archive/cuda_extension/cuda/func/addr_info_helpers.cpp new file mode 100644 index 000000000..9d3b217fa --- /dev/null +++ b/archive/cuda_extension/cuda/func/addr_info_helpers.cpp @@ -0,0 +1,47 @@ +#include "addr_info_helpers.h" + +#include + + +// finds which lines in the o addr array map to the same output 0 index +// --> return a map outputindex -> [addr_line_idx_0, addr_line_idx_1, ...] +static void remap_outaddr(const int *o, int N, std::map> &addr, int addr_stride) +{ + for (int i = 0; i < N; ++i) + { + int idx = i * addr_stride; + auto o_0 = o[idx]; + addr[o_0].push_back(i); + } +} + +// re-encodes the map to 3 plain vectors as follows: +// outidx contains a list of all output indices that are written to +// start holds the corresponding starting index in the indices vector for the +// mapped list indices is a flattened list with all values from the map +static void make_addrarray(const std::map> &addr, + std::vector &outidx, + std::vector &start, + std::vector &indices) +{ + for (auto &p : addr) + { + outidx.push_back(p.first); + start.push_back(int(indices.size())); + indices.insert(indices.end(), p.second.begin(), p.second.end()); + } + start.push_back(int(indices.size())); +} + + +void flatten_out_addr(const int *out_addr, + int addr_len, + int addr_stride, + std::vector &outidx, + std::vector &startidx, + std::vector &indices) +{ + std::map> addr; + remap_outaddr(out_addr, addr_len, addr, addr_stride); + make_addrarray(addr, outidx, startidx, indices); +} diff --git a/archive/cuda_extension/cuda/func/addr_info_helpers.h b/archive/cuda_extension/cuda/func/addr_info_helpers.h new file mode 100644 index 000000000..44e926370 --- /dev/null +++ b/archive/cuda_extension/cuda/func/addr_info_helpers.h @@ -0,0 +1,29 @@ +#pragma once + +#include + +/** Creates a datastructure to get the mapping of which indices in the addr_info + * array (first dim) map to each output address (handling multiple occurrences). + * + * This function is used by sum_to_buffer, to avoid data races on output + * assignment. + * + * @param out_addr_info pointer to addr_info start location containing the + * output indices. Example, for da in full addr_info: addr_info + 9 + * @param addr_len Number of lines in addr_info + * @param addr_stride Stride to go from one line to the next (it's 15 in full + * addr_info, and 3 if data has been sliced as addr_info(:,3,:) + * @param outidx output array of indices in the output the data should be + * written to (that's the unique values of out_addr_info[0] for every line) + * @param startidx output array of starting indices into the indices array, for + * the corresponding element in outidx. The length is 1 longer than outidx, to + * accomodate start + end indices at i and i+1 + * @param indices Array of indices that map to the output index. + * + */ +void flatten_out_addr(const int *out_addr_info, + int addr_len, + int addr_stride, + std::vector &outidx, + std::vector &startidx, + std::vector &indices); diff --git a/archive/cuda_extension/cuda/func/center_probe.cu b/archive/cuda_extension/cuda/func/center_probe.cu new file mode 100644 index 000000000..54a2d58dc --- /dev/null +++ b/archive/cuda_extension/cuda/func/center_probe.cu @@ -0,0 +1,150 @@ +#include "center_probe.h" + +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +// 1 block per 2nd/3rd dim +template +__global__ void sum_abs2(const complex* in, + float* out, + int dim0, + int dim12) +{ + int ty = threadIdx.y + blockIdx.y * BlockY; + int tx = threadIdx.x; + + auto val = 0.0f; + if (ty < dim12) + { + // specific block iterates over the 1st dim, + // and has fixed x/y + in += ty; + for (int i = tx; i < dim0; i += BlockX) + { + auto cval = in[i * dim12]; + auto abs2 = cval.real() * cval.real() + cval.imag() * cval.imag(); + val += abs2; + } + } + + __shared__ float blocksums[BlockX][BlockY]; + blocksums[tx][threadIdx.y] = val; + + __syncthreads(); + int nt = blockDim.x; + int c = nt; + while (c > 1) + { + int half = c / 2; + if (tx < half) + { + blocksums[tx][threadIdx.y] += blocksums[c - tx - 1][threadIdx.y]; + } + __syncthreads(); + c = c - half; + } + + if (ty >= dim12) + return; + + if (tx == 0) + out[ty] = blocksums[0][threadIdx.y]; +} + +/****************** class implementation ***********/ + +CenterProbe::CenterProbe() : CudaFunction("center_probe") {} + +void CenterProbe::setParameters(int i, int m, int n) +{ + i_ = i; + m_ = m; + n_ = n; + + mass_center_ = gpuManager.get_cuda_function( + "center_probe.mass_center", m_, n_, 1); + interp_shift_ = gpuManager.get_cuda_function( + "center_probe.interpolated_shift", i_, m_, n_); +} + +void CenterProbe::setDeviceBuffers(complex* d_probe, + complex* d_out) +{ + d_probe_ = d_probe; + d_out_ = d_out; +} + +void CenterProbe::allocate() +{ + ScopedTimer t(this, "allocate"); + d_probe_.allocate(i_ * m_ * n_); + d_out_.allocate(i_ * m_ * n_); + d_buffer_.allocate(m_ * n_); + mass_center_->setDeviceBuffers(d_buffer_.get(), nullptr); + mass_center_->allocate(); + interp_shift_->setDeviceBuffers(d_probe_.get(), d_out_.get()); + interp_shift_->allocate(); +} + +void CenterProbe::transfer_in(const complex* probe) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_probe_.get(), probe, i_ * m_ * n_); +} + +void CenterProbe::transfer_out(complex* probe) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(probe, d_probe_.get(), i_ * m_ * n_); +} + +void CenterProbe::run(float center_tolerance) +{ + ScopedTimer t(this, "run"); + + dim3 threads = {32u, 32u, 1u}; + dim3 blocks = {1u, unsigned(m_ * n_ + 32 - 1) / 32u, 1u}; + sum_abs2<32, 32> + <<>>(d_probe_.get(), d_buffer_.get(), i_, m_ * n_); + checkLaunchErrors(); + + // now mass_center across the buffer + mass_center_->run(); + + // TODO: see if this can be done on the GPU directly, + // avoiding a sync point in chain of async kernels + // Note: means putting interp_shift offset as a device buffer, + // not as parameter to the run function itself + float c1[2]; + mass_center_->transfer_out(c1); + float c2[] = {float(m_ / 2), float(n_ / 2)}; + auto err_1 = c1[0] - c2[0]; + auto err_2 = c1[1] - c2[1]; + auto err = std::sqrt(err_1 * err_1 + err_2 * err_2); + + if (err < center_tolerance) + { + return; + } + + float offset[] = {c2[0] - c1[0], c2[1] - c1[1]}; + + // now interpolated_shift on the data, and back into probe array + interp_shift_->run(offset[0], offset[1], true); + gpu_memcpy_d2d(d_probe_.get(), interp_shift_->getOutput(), i_ * m_ * n_); + + timing_sync(); +} + +/************ interface functions *************/ + +extern "C" void center_probe_c( + float* f_probe, float center_tolerance, int i, int m, int n) +{ + auto probe = reinterpret_cast*>(f_probe); + auto cp = gpuManager.get_cuda_function("center_probe", i, m, n); + cp->allocate(); + cp->transfer_in(probe); + cp->run(center_tolerance); + cp->transfer_out(probe); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/center_probe.h b/archive/cuda_extension/cuda/func/center_probe.h new file mode 100644 index 000000000..9a520b2c9 --- /dev/null +++ b/archive/cuda_extension/cuda/func/center_probe.h @@ -0,0 +1,27 @@ +#pragma once +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +#include "interpolated_shift.h" +#include "mass_center.h" + +class CenterProbe : public CudaFunction +{ +public: + CenterProbe(); + void setParameters(int i, int m, int n); + void setDeviceBuffers(complex* d_probe, complex* d_out); + void allocate(); + void transfer_in(const complex* probe); + void run(float center_tolerance); + void transfer_out(complex* probe); + +private: + DevicePtrWrapper> d_probe_; + DevicePtrWrapper d_buffer_; + DevicePtrWrapper> d_out_; + int i_ = 0, m_ = 0, n_ = 0; + InterpolatedShift* interp_shift_ = nullptr; + MassCenter* mass_center_ = nullptr; +}; diff --git a/archive/cuda_extension/cuda/func/clip_complex_magnitudes_to_range.cu b/archive/cuda_extension/cuda/func/clip_complex_magnitudes_to_range.cu new file mode 100644 index 000000000..b7ab8ddd1 --- /dev/null +++ b/archive/cuda_extension/cuda/func/clip_complex_magnitudes_to_range.cu @@ -0,0 +1,90 @@ +#include "clip_complex_magnitudes_to_range.h" +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +#include +#include + +/************ Kernels *********************/ + +__global__ void clip_complex_magnitudes_to_range_kernel(complex* data, + int n, + float clip_min, + float clip_max) +{ + int id = threadIdx.x + blockIdx.x * blockDim.x; + + auto v = data[id]; + + auto mag = abs(v); + auto theta = arg(v); + if (mag > clip_max) + mag = clip_max; + if (mag < clip_min) + mag = clip_min; + v = thrust::polar(mag, theta); + + data[id] = v; +} + +/************ Class implementation **********/ + +ClipComplexMagnitudesToRange::ClipComplexMagnitudesToRange() + : CudaFunction("clip_complex_magnitudes_to_range") +{ +} + +void ClipComplexMagnitudesToRange::setParameters(int n) { n_ = n; } + +void ClipComplexMagnitudesToRange::setDeviceBuffers(complex* d_data) +{ + d_data_ = d_data; +} + +void ClipComplexMagnitudesToRange::allocate() +{ + ScopedTimer t(this, "allocate"); + d_data_.allocate(n_); +} + +void ClipComplexMagnitudesToRange::transfer_in(const complex* data) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_data_.get(), data, n_); +} + +void ClipComplexMagnitudesToRange::run(float clip_min, float clip_max) +{ + ScopedTimer t(this, "run"); + + const int threadsPerBlock = 256; + int blocks = (n_ + threadsPerBlock - 1) / threadsPerBlock; + clip_complex_magnitudes_to_range_kernel<<>>( + d_data_.get(), n_, clip_min, clip_max); + + checkLaunchErrors(); + timing_sync(); +} + +void ClipComplexMagnitudesToRange::transfer_out(complex* data) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(data, d_data_.get(), n_); +} + +/************ interface ******************/ + +extern "C" void clip_complex_magnitudes_to_range_c(float* f_data, + int n, + float clip_min, + float clip_max) +{ + auto data = reinterpret_cast*>(f_data); + + auto ccmr = gpuManager.get_cuda_function( + "clip_complex_magnitudes_to_range", n); + ccmr->allocate(); + ccmr->transfer_in(data); + ccmr->run(clip_min, clip_max); + ccmr->transfer_out(data); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/clip_complex_magnitudes_to_range.h b/archive/cuda_extension/cuda/func/clip_complex_magnitudes_to_range.h new file mode 100644 index 000000000..802881f69 --- /dev/null +++ b/archive/cuda_extension/cuda/func/clip_complex_magnitudes_to_range.h @@ -0,0 +1,25 @@ +#pragma once + +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +/** Clips the complex magnitudes to given range + * + * BEWARE - this function works on the input in-place + */ +class ClipComplexMagnitudesToRange : public CudaFunction +{ +public: + ClipComplexMagnitudesToRange(); + void setParameters(int n); + void setDeviceBuffers(complex* d_data); + void allocate(); + void transfer_in(const complex* data); + void run(float clip_min, float clip_max); + void transfer_out(complex* data); + +private: + DevicePtrWrapper> d_data_; + int n_ = 0; +}; \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/complex_gaussian_filter.cu b/archive/cuda_extension/cuda/func/complex_gaussian_filter.cu new file mode 100644 index 000000000..b29ec68ae --- /dev/null +++ b/archive/cuda_extension/cuda/func/complex_gaussian_filter.cu @@ -0,0 +1,314 @@ +#include "complex_gaussian_filter.h" +#include "utils/GaussianWeights.h" + +#include "utils/GpuManager.h" +#include "utils/Indexing.h" +#include "utils/ScopedTimer.h" + +#include +#include + +/******* kernels *****************/ + +__constant__ float c_Kernel[ComplexGaussianFilter::MAX_KERNEL_RADIUS + 1]; + +template +__global__ void convolutionRowKernel(const complex* in, + complex* out, + int height, + int width, + int kernel_radius) +{ + int tx = threadIdx.x; + int ty = threadIdx.y; + int bx = blockIdx.x; + int by = blockIdx.y; + + // offset for batch + in += width * height * blockIdx.z; + out += width * height * blockIdx.z; + + extern __shared__ char shm_raw[]; + auto shm = reinterpret_cast*>(shm_raw); + + // Offset to block start of core area + int gbx = bx * BlockX; + int gby = by * BlockY; + int start = gbx * width + gby; + in += start; + out += start; + // width of shared memory + int shwidth = BlockY + 2 * kernel_radius; + + if (gbx + tx < height) + { + // main part - reflecting as needed + IndexReflect ind(-gby, width - gby); + shm[tx * shwidth + (kernel_radius + ty)] = in[tx * width + ind(ty)]; + + // left halo (kernel radius before) + for (int i = ty - kernel_radius; i < 0; i += BlockY) + { + shm[tx * shwidth + (i + kernel_radius)] = in[tx * width + ind(i)]; + } + + // right halo (kernel radius after) + for (int i = ty + BlockY; i < BlockY + kernel_radius; i += BlockY) + { + shm[tx * shwidth + (i + kernel_radius)] = in[tx * width + ind(i)]; + } + } + + __syncthreads(); + + // safe to return now, after syncing + if (gby + ty >= width || gbx + tx >= height) + return; + + // compute + auto sum = shm[tx * shwidth + (ty + kernel_radius)] * c_Kernel[0]; + for (int i = 1; i <= kernel_radius; ++i) + { + sum += (shm[tx * shwidth + (ty + i + kernel_radius)] + + shm[tx * shwidth + (ty - i + kernel_radius)]) * + c_Kernel[i]; + } + + out[tx * width + ty] = sum; +} + +template +__global__ void convolutionColumnsKernel(const complex* in, + complex* out, + int height, + int width, + int kernel_radius) +{ + int tx = threadIdx.x; + int ty = threadIdx.y; + int bx = blockIdx.x; + int by = blockIdx.y; + + // offset for batch + in += width * height * blockIdx.z; + out += width * height * blockIdx.z; + + extern __shared__ char shm_raw[]; + auto shm = reinterpret_cast*>(shm_raw); + // dims: BlockX + 2*kernel_radius, BlockY + + // Offset to block start of core area + int gbx = bx * BlockX; + int gby = by * BlockY; + int start = gbx * width + gby; + in += start; + out += start; + + // only do this if column index is in range + // (need to keep threads with us, so that synchthreads below doesn't deadlock) + if (gby + ty < width) + { + // main data (center point for each thread) - reflecting if needed + IndexReflect ind(-gbx, height - gbx); + shm[(kernel_radius + tx) * BlockY + ty] = in[ind(tx) * width + ty]; + + // upper halo (kernel radius before) + for (int i = tx - kernel_radius; i < 0; i += BlockX) + { + shm[(i + kernel_radius) * BlockY + ty] = in[ind(i) * width + ty]; + } + + // lower halo (kernel radius after) + for (int i = tx + BlockX; i < BlockX + kernel_radius; i += BlockX) + { + shm[(i + kernel_radius) * BlockY + ty] = in[ind(i) * width + ty]; + } + } + __syncthreads(); + + // safe to return now, after syncing + if (gby + ty >= width || gbx + tx >= height) + return; + + // compute + auto sum = shm[(tx + kernel_radius) * BlockY + ty] * c_Kernel[0]; + for (int i = 1; i <= kernel_radius; ++i) + { + sum += (shm[(tx + i + kernel_radius) * BlockY + ty] + + shm[(tx - i + kernel_radius) * BlockY + ty]) * + c_Kernel[i]; + } + + out[tx * width + ty] = sum; +} + +/******* class implementation ********/ + +ComplexGaussianFilter::ComplexGaussianFilter() + : CudaFunction("complex_gaussian_filter") +{ +} + +int ComplexGaussianFilter::totalSize() const +{ + return std::accumulate(shape_, shape_ + ndims_, 1, std::multiplies()); +} + +std::vector ComplexGaussianFilter::calcConvolutionKernel(float stddev, + int ndevs) +{ + auto lw = int(stddev * ndevs + 0.5f); + return gaussian_kernel1d(stddev, lw); +} + +void ComplexGaussianFilter::setParameters(int ndims, + const int* shape, + const float* mfs) +{ + ndims_ = ndims; + std::copy(shape, shape + ndims, shape_); + std::copy(mfs, mfs + ndims, mfs_); +} + +void ComplexGaussianFilter::setDeviceBuffers(complex* d_input, + complex* d_output) +{ + d_input_ = d_input; + d_output_ = d_output; +} + +void ComplexGaussianFilter::allocate() +{ + ScopedTimer t(this, "allocate"); + + auto total = totalSize(); + d_input_.allocate(total); + d_output_.allocate(total); +} + +void ComplexGaussianFilter::transfer_in(const complex* input) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_input_.get(), input, totalSize()); +} + +void ComplexGaussianFilter::run() +{ + ScopedTimer t(this, "run"); + + // use separable convolution in each dim + int batches = 1; + int x = 1; + int y = 1; + float stdx = 0.0f, stdy = 0.0f; + if (ndims_ == 3) + { + batches = shape_[0]; + x = shape_[1]; + y = shape_[2]; + stdx = mfs_[0]; + stdy = mfs_[1]; + } + if (ndims_ == 2) + { + x = shape_[0]; + y = shape_[1]; + stdx = mfs_[0]; + stdy = mfs_[1]; + } + if (ndims_ == 1) + { + stdy = mfs_[0]; + stdx = 0.0f; + y = shape_[0]; + } + + if (stdx > 0.0f) + { + // construct convolution kernel in current dim + auto weights = calcConvolutionKernel(stdx, NUM_STDDEVS); + if (weights.size() - 1 > MAX_KERNEL_RADIUS) + throw GPUException("Gaussian filter length too long: " + + std::to_string(weights.size())); + + checkCudaErrors(cudaMemcpyToSymbol( + c_Kernel, weights.data(), weights.size() * sizeof(float))); + + // run colums kernel with right stride + const int bx = 16; + const int by = 4; + dim3 threads(bx, by, 1); + dim3 blocks((x + bx - 1) / bx, (y + by - 1) / by, batches); + auto kernel_radius = weights.size() - 1; + auto halos = kernel_radius * 2; + auto shared = (bx + halos) * by * sizeof(complex); + if (shared > MAX_SHARED_PER_BLOCK) + { + throw GPUException("cannot run in kernel shared memory"); + } + auto inp = d_input_.get(); + convolutionColumnsKernel<<>>( + inp, d_output_.get(), x, y, kernel_radius); + checkLaunchErrors(); + } + + // last dim is continuous, so we use a different kernel + if (stdy > 0.0) + { + // construct convolution kernel in last dim + auto weights = calcConvolutionKernel(stdy, NUM_STDDEVS); + if (weights.size() - 1 > MAX_KERNEL_RADIUS) + throw GPUException("Gaussian filter length too long: " + + std::to_string(weights.size())); + checkCudaErrors(cudaMemcpyToSymbol( + c_Kernel, weights.data(), weights.size() * sizeof(float))); + + // run y kernel + const int bx = 4; + const int by = 16; + dim3 threads(bx, by, 1); + dim3 blocks((x + bx - 1) / bx, (y + by - 1) / by, batches); + auto kernel_radius = weights.size() - 1; + auto halos = kernel_radius * 2; + auto shared = (by + halos) * bx * sizeof(complex); + auto indata = d_output_.get(); + if (stdx <= 0.0f) + { + indata = d_input_.get(); + } + convolutionRowKernel<<>>( + indata, d_output_.get(), x, y, kernel_radius); + + checkLaunchErrors(); + } + if (stdx == 0.0f && stdy == 0.0f) + { + gpu_memcpy_d2d(d_output_.get(), d_input_.get(), batches * x * y); + } + timing_sync(); +} + +void ComplexGaussianFilter::transfer_out(complex* output) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(output, d_output_.get(), totalSize()); +} + +/******* interface functions *********/ + +extern "C" void complex_gaussian_filter_c(const float* f_input, + float* f_output, + const float* mfs, + int ndims, + const int* shape) +{ + auto input = reinterpret_cast*>(f_input); + auto output = reinterpret_cast*>(f_output); + + auto cgf = gpuManager.get_cuda_function( + "complex_gaussian_filter", ndims, shape, mfs); + cgf->allocate(); + cgf->transfer_in(input); + cgf->run(); + cgf->transfer_out(output); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/complex_gaussian_filter.h b/archive/cuda_extension/cuda/func/complex_gaussian_filter.h new file mode 100644 index 000000000..a79f1deb3 --- /dev/null +++ b/archive/cuda_extension/cuda/func/complex_gaussian_filter.h @@ -0,0 +1,38 @@ +#pragma once +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +class ComplexGaussianFilter : public CudaFunction +{ +public: + // number of standard deviations to use for the filter + static const int NUM_STDDEVS = 4; + + static const int ROWS_BLOCKDIM_X = 16; // width of tile - match kernel size? + static const int ROWS_BLOCKDIM_Y = 4; // height of tile + static const int MAX_SHARED_PER_BLOCK = + 48 * 1024 / 2; // at least 2 blocks per SM + static const int MAX_SHARED_PER_BLOCK_COMPLEX = + MAX_SHARED_PER_BLOCK / 2 * sizeof(float); + static const int MAX_KERNEL_RADIUS = + MAX_SHARED_PER_BLOCK_COMPLEX / ROWS_BLOCKDIM_X; + + ComplexGaussianFilter(); + void setParameters(int ndims, const int* shape, const float* mfs); + void setDeviceBuffers(complex* d_input, complex* d_output); + void allocate(); + void transfer_in(const complex* input); + void run(); + void transfer_out(complex* output); + +private: + int totalSize() const; + std::vector calcConvolutionKernel(float stddev, int ndevs); + + DevicePtrWrapper> d_input_; + DevicePtrWrapper> d_output_; + int ndims_ = 2; + int shape_[3]; + float mfs_[3]; +}; diff --git a/archive/cuda_extension/cuda/func/difference_map_fourier_constraint.cu b/archive/cuda_extension/cuda/func/difference_map_fourier_constraint.cu new file mode 100644 index 000000000..1d4a70b71 --- /dev/null +++ b/archive/cuda_extension/cuda/func/difference_map_fourier_constraint.cu @@ -0,0 +1,532 @@ +#include "difference_map_fourier_constraint.h" + +#include "addr_info_helpers.h" +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +#include +#include +#include + +/*************** kernels ********************/ + +template +__global__ void add_inplace_kernel(T *inout, const T *a, int n) +{ + int tid = threadIdx.x + blockIdx.x * blockDim.x; + if (tid >= n) + return; + inout[tid] += a[tid]; +} + +template +__global__ void div_inplace_kernel(T1 *inout, T2 divisor, int n) +{ + int tid = threadIdx.x + blockIdx.x * blockDim.x; + if (tid >= n) + return; + inout[tid] /= divisor; +} + +template +__global__ void sqrt_abs_kernel(const T *in, T *out, int n) +{ + int tid = threadIdx.x + blockIdx.x * blockDim.x; + if (tid >= n) + return; + using std::abs; + using std::sqrt; + out[tid] = sqrt(abs(in[tid])); +} + +template +__global__ void sqrt_kernel(const T *in, T *out, int n) +{ + int tid = threadIdx.x + blockIdx.x * blockDim.x; + if (tid >= n) + return; + using std::sqrt; + out[tid] = sqrt(in[tid]); +} + +template +__global__ void conjugate_kernel(const complex *in, complex *out, int n) +{ + int tid = threadIdx.x + blockIdx.x * blockDim.x; + if (tid >= n) + return; + out[tid] = complex(in[tid].real(), -in[tid].imag()); +} + +/*************** class implementation ***********/ + +DifferenceMapFourierConstraint::DifferenceMapFourierConstraint() + : CudaFunction("difference_map_fourier_constraint") +{ +} + +void DifferenceMapFourierConstraint::setParameters(int M, + int N, + int A, + int B, + int C, + int D, + int ob_modes, + int pr_modes, + bool do_LL_error, + bool do_realspace_error) +{ + M_ = M; + N_ = N; + A_ = A; + B_ = B; + C_ = C; + D_ = D; + pr_modes_ = pr_modes; + ob_modes_ = ob_modes; + do_LL_error_ = do_LL_error; + do_realspace_error_ = do_realspace_error; + + scan_and_multiply_ = gpuManager.get_cuda_function( + "dm_fourier_contraint.scan_and_multiply", + M_, + A_, + B_, + pr_modes_, + A_, + B_, + ob_modes_, + C_, + D_, + M_); + + log_likelihood_ = gpuManager.get_cuda_function( + "dm_fourier_contraint.log_likelihood", M_, A_, B_, M_, N_); + + difference_map_realspace_constraint_ = + gpuManager.get_cuda_function( + "dm_fourier_constraint.dm_realspace_constraint", M_, A_, B_); + + farfield_propagator_fwd_ = gpuManager.get_cuda_function( + "dm_fourier_constraint.farfield_propagator_fwd", M_, A_, B_); + + abs2_ = gpuManager.get_cuda_function, float>>( + "dm_fourier_contraint.abs2", M_ * A_ * B_); + + sum_to_buffer_ = gpuManager.get_cuda_function>( + "dm_fourier_constraint.sum2buffer", M_, A_, B_, N_, A_, B_, M_, M_); + + far_field_error_ = gpuManager.get_cuda_function( + "dm_fourier_constraint.farfield_error", N_, A_, B_); + + renormalise_fourier_magnitudes_ = + gpuManager.get_cuda_function( + "dm_fourier_constraint.renormalise_fourier_magnitudes", + M_, + N_, + A_, + B_); + + farfield_propagator_rev_ = gpuManager.get_cuda_function( + "dm_fourier_constraint.farfield_propagator_rev", M_, A_, B_); + + get_difference_ = gpuManager.get_cuda_function( + "dm_fourier_constraint.get_difference", M_, A_, B_); + + realspace_error_ = gpuManager.get_cuda_function( + "dm_fourier_constraint.realspace_error", M_, A_, B_, M_, N_); + + sum_to_buffer_->setAddrStride(15); + realspace_error_->setAddrStride(15); +} + +void DifferenceMapFourierConstraint::setDeviceBuffers( + unsigned char *d_mask, + float *d_Idata, + complex *d_obj, + complex *d_probe, + complex *d_exit_wave, + int *d_addr_info, + complex *d_prefilter, + complex *d_postfilter, + float *d_errors, + int *d_outidx, + int *d_startidx, + int *d_indices, + int outidx_size) +{ + d_mask_ = d_mask; + d_Idata_ = d_Idata; + d_obj_ = d_obj; + d_probe_ = d_probe; + d_exit_wave_ = d_exit_wave; + d_addr_info_ = d_addr_info; + d_prefilter_ = d_prefilter; + d_postfilter_ = d_postfilter; + d_errors_ = d_errors; + d_outidx_ = d_outidx; + d_startidx_ = d_startidx; + d_indices_ = d_indices; + outidx_size_ = outidx_size; +} + +int DifferenceMapFourierConstraint::calculateAddrIndices(const int *out1_addr) +{ + // calculate the indexing map + outidx_.clear(); + startidx_.clear(); + indices_.clear(); + flatten_out_addr(out1_addr, M_, 15, outidx_, startidx_, indices_); + outidx_size_ = outidx_.size(); + return outidx_size_; +} + +void DifferenceMapFourierConstraint::calculateUniqueDaIndices( + const int *da_addr) +{ + if (do_LL_error_) + { + log_likelihood_->calculateUniqueDaIndices(da_addr); + } +} + +void DifferenceMapFourierConstraint::updateErrorOutput(float *d_errors) +{ + d_errors_ = d_errors; + checkCudaErrors( + cudaMemset(d_errors_.get(), 0, N_ * 3 * sizeof(*d_errors_.get()))); + if (do_LL_error_) + { + log_likelihood_->updateErrorOutput(d_errors_.get() + N_); + } + if (do_realspace_error_) + { + realspace_error_->updateErrorOutput(d_errors_.get() + 2 * N_); + } + far_field_error_->updateErrorOutput(d_errors_.get()); + get_difference_->updateErrorInput(d_errors_.get()); + renormalise_fourier_magnitudes_->updateErrorInput(d_errors_.get()); +} + +void DifferenceMapFourierConstraint::allocate() +{ + ScopedTimer t(this, "allocate (joint)"); + + d_mask_.allocate(M_ * A_ * B_); + d_Idata_.allocate(N_ * A_ * B_); + d_obj_.allocate(ob_modes_ * C_ * D_); + d_probe_.allocate(pr_modes_ * A_ * B_); + d_exit_wave_.allocate(M_ * A_ * B_); + d_addr_info_.allocate(M_ * 3 * 5); + d_prefilter_.allocate(A_ * B_); + d_postfilter_.allocate(A_ * B_); + d_prefilter_conj_.allocate(A_ * B_); + d_postfilter_conj_.allocate(A_ * B_); + d_errors_.allocate(N_ * 3); + checkCudaErrors( + cudaMemset(d_errors_.get(), 0, N_ * 3 * sizeof(*d_errors_.get()))); + d_fmag_.allocate(M_ * A_ * B_); + if (!outidx_.empty()) + { + d_outidx_.allocate(outidx_.size()); + d_startidx_.allocate(startidx_.size()); + d_indices_.allocate(indices_.size()); + } + + // probe, obj, addr_info --> probe_obj + scan_and_multiply_->setDeviceBuffers( + d_probe_.get(), + d_obj_.get(), + d_addr_info_.get(), + nullptr // the output buffer is allocated + ); + scan_and_multiply_->allocate(); + auto d_probe_obj = scan_and_multiply_->getOutput(); + + if (do_LL_error_) + { + // probe_object, mask, Idata, prefilter, postfilter, addr --> err_phot + log_likelihood_->setDeviceBuffers(d_probe_obj, + d_mask_.get(), + d_Idata_.get(), + d_prefilter_.get(), + d_postfilter_.get(), + d_addr_info_.get(), + d_errors_.get() + N_, + d_outidx_.get(), + d_startidx_.get(), + d_indices_.get(), + outidx_size_); + log_likelihood_->allocate(); + } + + // probe_obj, exit_wave -> constrained + difference_map_realspace_constraint_->setDeviceBuffers( + d_probe_obj, + d_exit_wave_.get(), + nullptr // the output is allocated in there + ); + difference_map_realspace_constraint_->allocate(); + auto d_constrained = difference_map_realspace_constraint_->getOutput(); + + farfield_propagator_fwd_->setDeviceBuffers( + d_constrained, + d_constrained, // in-place, ok here + d_prefilter_.get(), + d_postfilter_.get()); + farfield_propagator_fwd_->allocate(); + // output is in d_constrained + auto d_f = d_constrained; + + abs2_->setDeviceBuffers(d_f, nullptr); + abs2_->allocate(); + + // abs2f, idata shape, ea, da => af2 + // giving strided access to addr_info to avoid another copy + // (constructor sets the stride to 15 instead of 3, we + // just offset it here to get to the ea and da parts) + sum_to_buffer_->setDeviceBuffers(abs2_->getOutput(), + nullptr, // output is allocated in here + d_addr_info_.get() + 6, + d_addr_info_.get() + 9, + d_outidx_.get(), + d_startidx_.get(), + d_indices_.get(), + outidx_size_); + sum_to_buffer_->allocate(); + auto d_af2 = sum_to_buffer_->getOutput(); + + // we'll run sqrt(af2) in-place + auto d_af = d_af2; + + // d_fmag = sqrt(abs(Idata)) will be run in a kernel + + // af, fmag, mask => err_fmag + far_field_error_->setDeviceBuffers( + d_af, d_fmag_.get(), d_mask_.get(), d_errors_.get()); + far_field_error_->allocate(); + auto d_err_fmag = d_errors_.get(); + + // f, af, fmag, mask, err_fmag, addr_info, pbound => vectorised_rfm + renormalise_fourier_magnitudes_->setDeviceBuffers( + d_f, + d_af, + d_fmag_.get(), + d_mask_.get(), + d_err_fmag, + d_addr_info_.get(), + nullptr // gets allocated inside + ); + renormalise_fourier_magnitudes_->allocate(); + auto d_vectorised_rfm = renormalise_fourier_magnitudes_->getOutput(); + + // vectorised_rfm, postfilter.conj, prefilter.conj, 'reverse' -> + // backpropagated_solution (flipped / conjugated post/pre filter) + farfield_propagator_rev_->setDeviceBuffers(d_vectorised_rfm, + d_vectorised_rfm, + d_postfilter_conj_.get(), + d_prefilter_conj_.get()); + farfield_propagator_rev_->allocate(); + auto d_backpropagated_solution = d_vectorised_rfm; + + // addr_info, alpha, backpropagated_solution, err_fmag, pbound, probe_object + // -> df + get_difference_->setDeviceBuffers(d_addr_info_.get(), + d_backpropagated_solution, + d_err_fmag, + d_exit_wave_.get(), + d_probe_obj, + nullptr); + get_difference_->allocate(); + auto d_df = get_difference_->getOutput(); + + // we'll add df to exit_wave in-place + + if (do_realspace_error_) + { + realspace_error_->setDeviceBuffers(d_df, + d_addr_info_.get() + 2 * 3, + d_addr_info_.get() + 3 * 3, + d_errors_.get() + 2 * N_); + realspace_error_->allocate(); + } + + // we'll div by pbound in-place for d_err_fmag +} + +void DifferenceMapFourierConstraint::transfer_in( + const unsigned char *mask, + const float *Idata, + const complex *obj, + const complex *probe, + const complex *exit_wave, + const int *addr_info, + const complex *prefilter, + const complex *postfilter) +{ + ScopedTimer t(this, "transfer in"); + + gpu_memcpy_h2d(d_mask_.get(), mask, N_ * A_ * B_); + gpu_memcpy_h2d(d_Idata_.get(), Idata, N_ * A_ * B_); + gpu_memcpy_h2d(d_obj_.get(), obj, ob_modes_ * C_ * D_); + gpu_memcpy_h2d(d_probe_.get(), probe, pr_modes_ * A_ * B_); + gpu_memcpy_h2d(d_exit_wave_.get(), exit_wave, M_ * A_ * B_); + gpu_memcpy_h2d(d_addr_info_.get(), addr_info, M_ * 3 * 5); + gpu_memcpy_h2d(d_prefilter_.get(), prefilter, A_ * B_); + gpu_memcpy_h2d(d_postfilter_.get(), postfilter, A_ * B_); + // conjugate will be run first-time in the run function + + if (!outidx_.empty()) + { + gpu_memcpy_h2d(d_outidx_.get(), outidx_.data(), outidx_.size()); + gpu_memcpy_h2d(d_startidx_.get(), startidx_.data(), startidx_.size()); + gpu_memcpy_h2d(d_indices_.get(), indices_.data(), indices_.size()); + } + + calculateUniqueDaIndices(addr_info + 9); +} + +void DifferenceMapFourierConstraint::run(float pbound, + float alpha, + bool doPbound) +{ + ScopedTimer t(this, "run"); + + // conjugate the pre- and post-filters + // TODO: do this only once if called multiple times + int total = A_ * B_; + int threadsPerBlock = 256; + int blocks = (total + threadsPerBlock - 1) / threadsPerBlock; + if (d_prefilter_.get() != nullptr) + { + conjugate_kernel<<>>( + d_prefilter_.get(), d_prefilter_conj_.get(), total); + checkLaunchErrors(); + } + if (d_postfilter_.get() != nullptr) + { + conjugate_kernel<<>>( + d_postfilter_.get(), d_postfilter_conj_.get(), total); + checkLaunchErrors(); + } + + scan_and_multiply_->run(); + + if (do_LL_error_) + { + log_likelihood_->run(); + } + difference_map_realspace_constraint_->run(alpha); + farfield_propagator_fwd_->run( + d_prefilter_.get() != nullptr, d_postfilter_.get() != nullptr, true); + abs2_->run(); + sum_to_buffer_->run(); + + // sqrt(abs(Idata)) + total = N_ * A_ * B_; + threadsPerBlock = 256; + blocks = (total + threadsPerBlock - 1) / threadsPerBlock; + sqrt_abs_kernel<<>>( + d_Idata_.get(), d_fmag_.get(), total); + checkLaunchErrors(); + + // sqrt(af2), in-place + sqrt_kernel<<>>( + sum_to_buffer_->getOutput(), sum_to_buffer_->getOutput(), total); + checkLaunchErrors(); + + far_field_error_->run(); + renormalise_fourier_magnitudes_->run(pbound, doPbound); + + farfield_propagator_rev_->run( + d_prefilter_.get() != nullptr, d_postfilter_.get() != nullptr, false); + + get_difference_->run(alpha, pbound, doPbound); + + auto df = get_difference_->getOutput(); + + total = M_ * A_ * B_; + threadsPerBlock = 256; + blocks = (total + threadsPerBlock - 1) / threadsPerBlock; + + add_inplace_kernel<<>>( + d_exit_wave_.get(), df, total); + checkLaunchErrors(); + + if (do_realspace_error_) + { + realspace_error_->run(); + } + + if (doPbound) + { + auto d_err_fmag = d_errors_.get(); + total = N_; + threadsPerBlock = 256; + blocks = (total + threadsPerBlock - 1) / threadsPerBlock; + div_inplace_kernel<<>>(d_err_fmag, pbound, total); + checkLaunchErrors(); + } + + timing_sync(); +} +void DifferenceMapFourierConstraint::transfer_out(float *errors, + complex *exit_wave) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(errors, d_errors_.get(), 3 * N_); + gpu_memcpy_d2h(exit_wave, d_exit_wave_.get(), M_ * A_ * B_); +} + +/**************** interface function ***********/ + +extern "C" void difference_map_fourier_constraint_c( + const unsigned char *mask, // N x A x B + const float *Idata, // N x A x B + const float *f_obj, // ob_modes x C x D + const float *f_probe, // pr_modes x A x B + float *f_exit_wave, // M x A x B + const int *addr_info, // M x 5 x 3 + const float *f_prefilter, // A x B + const float *f_postfilter, // A x B + float pbound, + float alpha, + int do_LL_error, + int do_realspace_error, + int doPbound, + int M, + int N, + int A, + int B, + int C, + int D, + int ob_modes, + int pr_modes, + float *errors) +{ + auto obj = reinterpret_cast *>(f_obj); + auto probe = reinterpret_cast *>(f_probe); + auto exit_wave = reinterpret_cast *>(f_exit_wave); + auto prefilter = reinterpret_cast *>(f_prefilter); + auto postfilter = reinterpret_cast *>(f_postfilter); + + auto dmfc = gpuManager.get_cuda_function( + "dm_fourier_constraint", + M, + N, + A, + B, + C, + D, + ob_modes, + pr_modes, + do_LL_error != 0, + do_realspace_error != 0); + + dmfc->calculateAddrIndices(addr_info + 9); + dmfc->allocate(); + dmfc->transfer_in( + mask, Idata, obj, probe, exit_wave, addr_info, prefilter, postfilter); + dmfc->run(pbound, alpha, doPbound != 0); + dmfc->transfer_out(errors, exit_wave); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/difference_map_fourier_constraint.h b/archive/cuda_extension/cuda/func/difference_map_fourier_constraint.h new file mode 100644 index 000000000..059b1fc70 --- /dev/null +++ b/archive/cuda_extension/cuda/func/difference_map_fourier_constraint.h @@ -0,0 +1,97 @@ +#pragma once + +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +#include "difference_map_realspace_constraint.h" +#include "far_field_error.h" +#include "farfield_propagator.h" +#include "get_difference.h" +#include "log_likelihood.h" +#include "realspace_error.h" +#include "renormalise_fourier_magnitudes.h" +#include "scan_and_multiply.h" +#include "sum_to_buffer.h" + +class DifferenceMapFourierConstraint : public CudaFunction +{ +public: + DifferenceMapFourierConstraint(); + void setParameters(int M, + int N, + int A, + int B, + int C, + int D, + int ob_modes, + int pr_modes, + bool do_LL_error, + bool do_realspace_error); + void setDeviceBuffers(unsigned char *d_mask, + float *d_Idata, + complex *d_obj, + complex *d_probe, + complex *d_exit_wave, + int *d_addr_info, + complex *d_prefilter, + complex *d_postfilter, + float *d_errors, + int *d_outidx, + int *d_startidx, + int *d_indices, + int outidx_size); + int calculateAddrIndices(const int *out1_addr); + void calculateUniqueDaIndices(const int *da_addr); + void allocate(); + // to be called if error point should be moved along + // in engine iterator function + void updateErrorOutput(float *d_errors); + void transfer_in(const unsigned char *mask, + const float *Idata, + const complex *obj, + const complex *probe, + const complex *exit_wave, + const int *addr_info, + const complex *prefilter, + const complex *postfilter); + void run(float pbound, float alpha, bool doPbound); + void transfer_out(float *errors, complex *exit_wave); + +private: + DevicePtrWrapper d_mask_; // N x A x B + DevicePtrWrapper d_Idata_; // N x A x B + DevicePtrWrapper> d_obj_; // ob_modes x C x D + DevicePtrWrapper> d_probe_; // pr_modes x A x B + DevicePtrWrapper> d_exit_wave_; // M x A x B + DevicePtrWrapper d_addr_info_; // M x 5 x 3 + DevicePtrWrapper> d_prefilter_; // A x B + DevicePtrWrapper> d_postfilter_; // A x B + DevicePtrWrapper d_errors_; // 3 x N + + DevicePtrWrapper d_outidx_, d_startidx_, d_indices_; + std::vector outidx_, startidx_, indices_; + int outidx_size_ = 0; + + int M_ = 0, N_ = 0, A_ = 0, B_ = 0, C_ = 0, D_ = 0, ob_modes_ = 0, + pr_modes_ = 0; + bool do_LL_error_ = 0; + bool do_realspace_error_ = 0; + // intermediate buffers + DevicePtrWrapper> d_prefilter_conj_; + DevicePtrWrapper> d_postfilter_conj_; + DevicePtrWrapper d_fmag_; + // other kernels + ScanAndMultiply *scan_and_multiply_ = nullptr; + LogLikelihood *log_likelihood_ = nullptr; + DifferenceMapRealspaceConstraint *difference_map_realspace_constraint_ = + nullptr; + FarfieldPropagator *farfield_propagator_fwd_ = nullptr; + Abs2, float> *abs2_ = nullptr; + SumToBuffer *sum_to_buffer_ = nullptr; + FarFieldError *far_field_error_ = nullptr; + RenormaliseFourierMagnitudes *renormalise_fourier_magnitudes_ = nullptr; + FarfieldPropagator *farfield_propagator_rev_ = nullptr; + GetDifference *get_difference_ = nullptr; + RealspaceError *realspace_error_ = nullptr; +}; diff --git a/archive/cuda_extension/cuda/func/difference_map_iterator.cu b/archive/cuda_extension/cuda/func/difference_map_iterator.cu new file mode 100644 index 000000000..75b08c6df --- /dev/null +++ b/archive/cuda_extension/cuda/func/difference_map_iterator.cu @@ -0,0 +1,381 @@ +#include "difference_map_iterator.h" + +#include "utils/Errors.h" +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +#include "addr_info_helpers.h" + +/************** class implementation *********/ + +DifferenceMapIterator::DifferenceMapIterator() + : CudaFunction("difference_map_iterator") +{ +} + +void DifferenceMapIterator::setParameters(int A, + int B, + int C, + int D, + int E, + int F, + int G, + int H, + int I, + int N, + int num_iterations, + float obj_smooth_std, + bool doSmoothing, + bool doClipping, + bool doCentering, + bool doPbound, + bool do_LL_error, + bool doRealspaceError, + bool doUpdateObjectFirst, + bool doProbeSupport) +{ + A_ = A; + B_ = B; + C_ = C; + D_ = D; + E_ = E; + F_ = F; + G_ = G; + H_ = H; + I_ = I; + N_ = N; + num_iterations_ = num_iterations; + doPbound_ = doPbound; + doProbeSupport_ = doProbeSupport; + + // TODO: shall we make the realspace error a parameter too? + dm_fourier_constraint_ = + gpuManager.get_cuda_function( + "dm_iterator.dm_fourier_constraint", + A, + N, + E, // E == B + F, // F == C + H, + I, + G, + D, + do_LL_error, + doRealspaceError); + dm_overlap_update_ = + gpuManager.get_cuda_function( + "dm_iterator.dm_overlap_update", + A, + B, + C, + D, + E, + F, + G, + H, + I, + obj_smooth_std, + doUpdateObjectFirst, + true, // in general, allocate mem, etc for probe update + doSmoothing, + doClipping, + doProbeSupport, + doCentering); +} + +int DifferenceMapIterator::calculateAddrIndices(const int* out1_addr) +{ + // calculate the indexing map + outidx_.clear(); + startidx_.clear(); + indices_.clear(); + flatten_out_addr(out1_addr, A_, 15, outidx_, startidx_, indices_); + outidx_size_ = outidx_.size(); + return outidx_size_; +} + +void DifferenceMapIterator::calculateUniqueDaIndices(const int* da_addr) +{ + dm_fourier_constraint_->calculateUniqueDaIndices(da_addr); +} + +void DifferenceMapIterator::setDeviceBuffers(float* d_diffraction, + complex* d_obj, + float* d_object_weights, + complex* d_cfact_object, + unsigned char* d_mask, + complex* d_probe, + complex* d_cfact_probe, + complex* d_probe_support, + float* d_probe_weights, + complex* d_exit_wave, + int* d_addr_info, + complex* d_pre_fft, + complex* d_post_fft, + float* d_errors) +{ + d_diffraction_ = d_diffraction; + d_obj_ = d_obj; + d_object_weights_ = d_object_weights; + d_cfact_object_ = d_cfact_object; + d_mask_ = d_mask; + d_probe_ = d_probe; + d_cfact_probe_ = d_cfact_probe; + d_probe_support_ = d_probe_support; + d_probe_weights_ = d_probe_weights; + d_exit_wave_ = d_exit_wave; + d_addr_info_ = d_addr_info; + d_pre_fft_ = d_pre_fft; + d_post_fft_ = d_post_fft; + d_errors_ = d_errors; +} + +void DifferenceMapIterator::allocate() +{ + ScopedTimer t(this, "allocate"); + + d_diffraction_.allocate(N_ * B_ * C_); + d_obj_.allocate(G_ * H_ * I_); + d_object_weights_.allocate(G_); + d_cfact_object_.allocate(G_ * H_ * I_); + d_mask_.allocate(N_ * B_ * C_); + d_probe_.allocate(D_ * E_ * F_); + if (doProbeSupport_) + { + d_probe_support_.allocate(D_ * E_ * F_); + } + d_probe_weights_.allocate(D_); + d_exit_wave_.allocate(A_ * B_ * C_); + d_addr_info_.allocate(A_ * 15); + d_pre_fft_.allocate(C_ * B_); + d_post_fft_.allocate(C_ * B_); + d_errors_.allocate(num_iterations_ * 3 * N_); + + if (!outidx_.empty()) + { + d_outidx_.allocate(outidx_.size()); + d_startidx_.allocate(startidx_.size()); + d_indices_.allocate(indices_.size()); + } + + dm_fourier_constraint_->setDeviceBuffers(d_mask_.get(), + d_diffraction_.get(), + d_obj_.get(), + d_probe_.get(), + d_exit_wave_.get(), + d_addr_info_.get(), + d_pre_fft_.get(), + d_post_fft_.get(), + d_errors_.get(), + d_outidx_.get(), + d_startidx_.get(), + d_indices_.get(), + outidx_size_); + dm_fourier_constraint_->allocate(); + + dm_overlap_update_->setDeviceBuffers(d_addr_info_.get(), + d_cfact_object_.get(), + d_cfact_probe_.get(), + d_exit_wave_.get(), + d_obj_.get(), + d_object_weights_.get(), + d_probe_.get(), + d_probe_support_.get(), + d_probe_weights_.get()); + dm_overlap_update_->allocate(); +} + +void DifferenceMapIterator::transfer_in(const float* diffraction, + const complex* obj, + const float* object_weights, + const complex* cfact_object, + const unsigned char* mask, + const complex* probe, + const complex* cfact_probe, + const complex* probe_support, + const float* probe_weights, + const complex* exit_wave, + const int* addr_info, + const complex* pre_fft, + const complex* post_fft) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_diffraction_.get(), diffraction, N_ * B_ * C_); + gpu_memcpy_h2d(d_obj_.get(), obj, G_ * H_ * I_); + gpu_memcpy_h2d(d_object_weights_.get(), object_weights, G_); + gpu_memcpy_h2d(d_cfact_object_.get(), cfact_object, G_ * H_ * I_); + gpu_memcpy_h2d(d_mask_.get(), mask, N_ * B_ * C_); + gpu_memcpy_h2d(d_probe_.get(), probe, D_ * E_ * F_); + gpu_memcpy_h2d(d_cfact_probe_.get(), cfact_probe, D_ * E_ * F_); + if (doProbeSupport_) + { + gpu_memcpy_h2d(d_probe_support_.get(), probe_support, D_ * E_ * F_); + } + gpu_memcpy_h2d(d_probe_weights_.get(), probe_weights, D_); + gpu_memcpy_h2d(d_exit_wave_.get(), exit_wave, A_ * B_ * C_); + gpu_memcpy_h2d(d_addr_info_.get(), addr_info, A_ * 15); + gpu_memcpy_h2d(d_pre_fft_.get(), pre_fft, B_ * C_); + gpu_memcpy_h2d(d_post_fft_.get(), post_fft, B_ * C_); + + if (!outidx_.empty()) + { + gpu_memcpy_h2d(d_outidx_.get(), outidx_.data(), outidx_.size()); + gpu_memcpy_h2d(d_startidx_.get(), startidx_.data(), startidx_.size()); + gpu_memcpy_h2d(d_indices_.get(), indices_.data(), indices_.size()); + } + + calculateUniqueDaIndices(addr_info + 9); +} + +void DifferenceMapIterator::run(int overlap_max_iterations, + float overlap_converge_factor, + float probe_center_tol, + int probe_update_start, + float pbound, + float alpha, + float clip_min, + float clip_max) +{ + ScopedTimer t(this, "run"); + + for (int it = 0; it < num_iterations_; ++it) + { + if (((it + 1) % 10 == 0) && it > 0) + { + std::cout << "iteration: " << it + 1 << std::endl; + } + + dm_fourier_constraint_->updateErrorOutput(d_errors_.get() + it * 3 * N_); + dm_fourier_constraint_->run(pbound, alpha, doPbound_); + + auto do_update_probe = probe_update_start <= it; + dm_overlap_update_->run(overlap_max_iterations, + clip_min, + clip_max, + probe_center_tol, + overlap_converge_factor, + do_update_probe); + } + + timing_sync(); +} + +void DifferenceMapIterator::transfer_out(float* errors, + complex* obj, + complex* probe, + complex* exit_wave) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(errors, d_errors_.get(), num_iterations_ * 3 * N_); + gpu_memcpy_d2h(obj, d_obj_.get(), G_ * H_ * I_); + gpu_memcpy_d2h(probe, d_probe_.get(), D_ * E_ * F_); + gpu_memcpy_d2h(exit_wave, d_exit_wave_.get(), A_ * B_ * C_); +} + +/************** interface *************/ + +extern "C" void difference_map_iterator_c( + // note: E = B, F = C + const float* diffraction, // N x B x C + float* f_obj, // G x H x I + const float* object_weights, // G + const float* f_cfact_object, // G x H x I + const unsigned char* mask, // N x B x C + float* f_probe, // D x E x F + const float* f_cfact_probe, // D x E x F + const float* f_probe_support, // D x E x F + const float* probe_weights, // D + float* f_exit_wave, // A x B x C + const int* addr_info, // A x 5 x 3 + const float* f_pre_fft, // B x C + const float* f_post_fft, // B x C + float* errors, // num_iterations x 3 x N + float pbound, + int overlap_max_iterations, + int doUpdateObjectFirst, + float obj_smooth_std, + float overlap_converge_factor, + float probe_center_tol, + int probe_update_start, + float alpha, + float clip_min, + float clip_max, + int do_LL_error, + int do_realspace_error, + int num_iterations, + int A, + int B, + int C, + int D, + int E, + int F, + int G, + int H, + int I, + int N, + int doSmoothing, + int doClipping, + int doCentering, + int doPbound) +{ + auto obj = reinterpret_cast*>(f_obj); + auto cfact_object = reinterpret_cast*>(f_cfact_object); + auto probe = reinterpret_cast*>(f_probe); + auto cfact_probe = reinterpret_cast*>(f_cfact_probe); + auto probe_support = reinterpret_cast*>(f_probe_support); + auto exit_wave = reinterpret_cast*>(f_exit_wave); + auto pre_fft = reinterpret_cast*>(f_pre_fft); + auto post_fft = reinterpret_cast*>(f_post_fft); + + if (E != B || F != C) + { + throw std::runtime_error("2nd/3rd dimensions of probe and mask are not consistent"); + } + + auto dmi = gpuManager.get_cuda_function( + "dm_iterator", + A, + B, + C, + D, + E, + F, + G, + H, + I, + N, + num_iterations, + obj_smooth_std, + doSmoothing != 0, + doClipping != 0, + doCentering != 0, + doPbound != 0, + do_LL_error != 0, + do_realspace_error != 0, + doUpdateObjectFirst != 0, + probe_support != nullptr); + dmi->calculateAddrIndices(addr_info + 9); + dmi->allocate(); + dmi->transfer_in(diffraction, + obj, + object_weights, + cfact_object, + mask, + probe, + cfact_probe, + probe_support, + probe_weights, + exit_wave, + addr_info, + pre_fft, + post_fft); + dmi->run(overlap_max_iterations, + overlap_converge_factor, + probe_center_tol, + probe_update_start, + pbound, + alpha, + clip_min, + clip_max); + dmi->transfer_out(errors, obj, probe, exit_wave); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/difference_map_iterator.h b/archive/cuda_extension/cuda/func/difference_map_iterator.h new file mode 100644 index 000000000..e3f4eb6c9 --- /dev/null +++ b/archive/cuda_extension/cuda/func/difference_map_iterator.h @@ -0,0 +1,104 @@ +#pragma once +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +#include "func/difference_map_fourier_constraint.h" +#include "func/difference_map_overlap_constraint.h" + +class DifferenceMapIterator : public CudaFunction +{ +public: + DifferenceMapIterator(); + void setParameters(int A, + int B, + int C, + int D, + int E, + int F, + int G, + int H, + int I, + int N, + int num_iterations, + float obj_smooth_std, + bool doSmoothing, + bool doClipping, + bool doCentering, + bool doPbound, + bool do_LL_error, + bool doRealspaceError, + bool doUpdateObjectFirst, + bool doProbeSupport); + void setDeviceBuffers(float* d_diffraction, + complex* d_obj, + float* d_object_weights, + complex* d_cfact_object, + unsigned char* d_mask, + complex* d_probe, + complex* d_cfact_probe, + complex* d_probe_support, + float* d_probe_weight, + complex* d_exit_wave, + int* d_addr_info, + complex* d_pre_fft, + complex* d_post_fft, + float* d_errors); + int calculateAddrIndices(const int* out1_addr); + void calculateUniqueDaIndices(const int* da_addr); + void allocate(); + void transfer_in(const float* diffraction, + const complex* obj, + const float* object_weights, + const complex* cfact_object, + const unsigned char* mask, + const complex* probe, + const complex* cfact_probe, + const complex* probe_support, + const float* probe_weight, + const complex* exit_wave, + const int* addr_info, + const complex* pre_fft, + const complex* post_fft); + void run(int overlap_max_iterations, + float overlap_converge_factor, + float probe_center_tol, + int probe_update_start, + float pbound, + float alpha, + float clip_min, + float clip_max); + void transfer_out(float* errors, + complex* obj, + complex* probe, + complex* exit_wave); + +private: + DevicePtrWrapper d_diffraction_; // N x B x C + DevicePtrWrapper> d_obj_; // G x H x I + DevicePtrWrapper d_object_weights_; // G + DevicePtrWrapper> d_cfact_object_; // G x H x I + DevicePtrWrapper d_mask_; // N x B x C + DevicePtrWrapper> d_probe_; // D x E x F + DevicePtrWrapper> d_cfact_probe_; // D x E x F + DevicePtrWrapper> d_probe_support_; // D x E x F + DevicePtrWrapper d_probe_weights_; // D + DevicePtrWrapper> d_exit_wave_; // A x B x C + DevicePtrWrapper d_addr_info_; // A x 5 x 3 + DevicePtrWrapper> d_pre_fft_; // B x C + DevicePtrWrapper> d_post_fft_; // B x C + DevicePtrWrapper d_errors_; // num_iterations x 3 x N + + DevicePtrWrapper d_outidx_, d_startidx_, d_indices_; + std::vector outidx_, startidx_, indices_; + int outidx_size_ = 0; + + int A_ = 0, B_ = 0, C_ = 0, D_ = 0, E_ = 0, F_ = 0, G_ = 0, H_ = 0, I_ = 0, + N_ = 0; + int num_iterations_ = 0; + bool doPbound_ = false; + bool doProbeSupport_ = false; + + DifferenceMapFourierConstraint* dm_fourier_constraint_ = nullptr; + DifferenceMapOverlapConstraint* dm_overlap_update_ = nullptr; +}; \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/difference_map_overlap_constraint.cu b/archive/cuda_extension/cuda/func/difference_map_overlap_constraint.cu new file mode 100644 index 000000000..01a0120ec --- /dev/null +++ b/archive/cuda_extension/cuda/func/difference_map_overlap_constraint.cu @@ -0,0 +1,303 @@ +#include "difference_map_overlap_constraint.h" + +#include "utils/Complex.h" +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +/********* class implementation ************/ + +DifferenceMapOverlapConstraint::DifferenceMapOverlapConstraint() + : CudaFunction("difference_map_overlap_constraint") +{ +} + +void DifferenceMapOverlapConstraint::setParameters(int A, + int B, + int C, + int D, + int E, + int F, + int G, + int H, + int I, + float obj_smooth_std, + bool doUpdateObjectFirst, + bool doUpdateProbe, + bool doSmoothing, + bool doClipping, + bool withProbeSupport, + bool doCentering) +{ + A_ = A; + B_ = B; + C_ = C; + D_ = D; + E_ = E; + F_ = F; + G_ = G; + H_ = H; + I_ = I; + doUpdateObjectFirst_ = doUpdateObjectFirst; + doUpdateProbe_ = doUpdateProbe; + doSmoothing_ = doSmoothing; + doClipping_ = doClipping; + withProbeSupport_ = withProbeSupport; + doCentering_ = doCentering; + + dm_update_object_ = gpuManager.get_cuda_function( + "dm_overlap_constraint.dm_update_object", + A, + B, + C, + D, + E, + F, + G, + H, + I, + obj_smooth_std, + doSmoothing, + doClipping); + if (doUpdateProbe_) + { + /* size parameter translation: + D=>G,E=>H,F=>I, + G=>D,H=>E,I=>F + */ + dm_update_probe_ = gpuManager.get_cuda_function( + "dm_overlap_constraint.dm_update_probe", + A, + B, + C, + G, + H, + I, + D, + E, + F, + withProbeSupport); + } + + if (doCentering_) + { + center_probe_ = gpuManager.get_cuda_function( + "dm_overlap_constraint.center_probe", D_, E_, F_); + } +} + +void DifferenceMapOverlapConstraint::setDeviceBuffers( + int* d_addr_info, + complex* d_cfact_object, + complex* d_cfact_probe, + complex* d_exit_wave, + complex* d_obj, + float* d_obj_weigths, + complex* d_probe, + complex* d_probe_support, + float* d_probe_weights) +{ + d_addr_info_ = d_addr_info; + d_cfact_object_ = d_cfact_object; + d_cfact_probe_ = d_cfact_probe; + d_exit_wave_ = d_exit_wave; + d_obj_ = d_obj; + d_obj_weights_ = d_obj_weigths; + d_probe_ = d_probe; + d_probe_support_ = d_probe_support; + d_probe_weights_ = d_probe_weights; +} + +void DifferenceMapOverlapConstraint::allocate() +{ + ScopedTimer t(this, "allocate"); + + d_addr_info_.allocate(A_ * 15); + d_cfact_object_.allocate(G_ * H_ * I_); + d_cfact_probe_.allocate(D_ * E_ * F_); + d_exit_wave_.allocate(A_ * B_ * C_); + d_obj_.allocate(G_ * H_ * I_); + d_obj_weights_.allocate(G_); + d_probe_.allocate(D_ * E_ * F_); + if (withProbeSupport_) + { + d_probe_support_.allocate(D_ * E_ * F_); + } + d_probe_weights_.allocate(D_); + + dm_update_object_->setDeviceBuffers(d_obj_.get(), + d_obj_weights_.get(), + d_probe_.get(), + d_exit_wave_.get(), + d_addr_info_.get(), + d_cfact_object_.get()); + dm_update_object_->allocate(); + + if (doUpdateProbe_) + { + dm_update_probe_->setDeviceBuffers(d_obj_.get(), + d_probe_weights_.get(), + d_probe_.get(), + d_exit_wave_.get(), + d_addr_info_.get(), + d_cfact_probe_.get(), + d_probe_support_.get()); + dm_update_probe_->allocate(); + } + if (doCentering_) + { + center_probe_->setDeviceBuffers(d_probe_.get(), nullptr); + center_probe_->allocate(); + } +} + +void DifferenceMapOverlapConstraint::transfer_in( + const int* addr_info, + const complex* cfact_object, + const complex* cfact_probe, + const complex* exit_wave, + const complex* obj, + const float* obj_weigths, + const complex* probe, + const complex* probe_support, + const float* probe_weights) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_addr_info_.get(), addr_info, A_ * 15); + gpu_memcpy_h2d(d_cfact_object_.get(), cfact_object, G_ * H_ * I_); + gpu_memcpy_h2d(d_cfact_probe_.get(), cfact_probe, D_ * E_ * F_); + gpu_memcpy_h2d(d_exit_wave_.get(), exit_wave, A_ * B_ * C_); + gpu_memcpy_h2d(d_obj_.get(), obj, G_ * H_ * I_); + gpu_memcpy_h2d(d_obj_weights_.get(), obj_weigths, G_); + gpu_memcpy_h2d(d_probe_.get(), probe, D_ * E_ * F_); + if (withProbeSupport_) + { + gpu_memcpy_h2d(d_probe_support_.get(), probe_support, D_ * E_ * F_); + } + gpu_memcpy_h2d(d_probe_weights_.get(), probe_weights, D_); +} + +void DifferenceMapOverlapConstraint::run(int max_iterations, + float clip_min, + float clip_max, + float probe_center_tol, + float overlap_converge_factor, + bool do_update_probe) +{ + ScopedTimer t(this, "run"); + + bool doUpdateProbeCombined = doUpdateProbe_ && do_update_probe; + + for (int inner = 0; inner < max_iterations; ++inner) + { + if (doUpdateObjectFirst_ || inner > 0) + { + dm_update_object_->run(clip_min, clip_max); + } + + // exit if probe should not be updated yet + if (!doUpdateProbeCombined) + { + break; + } + + dm_update_probe_->run(); + float change = 0.0f; + dm_update_probe_->transfer_out(nullptr, &change); + + // recenter the probe + if (doCentering_) + { + center_probe_->run(probe_center_tol); + } + + // stop iteration if probe change is small + if (change < overlap_converge_factor) + break; + } + + timing_sync(); +} + +void DifferenceMapOverlapConstraint::transfer_out(complex* probe, + complex* obj) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(probe, d_probe_.get(), D_ * E_ * F_); + gpu_memcpy_d2h(obj, d_obj_.get(), G_ * H_ * I_); +} + +/********* interface functions *************/ + +extern "C" void difference_map_overlap_constraint_c( + const int* addr_info, // A x 5 x 3 + const float* f_cfact_object, // G x H x I + const float* f_cfact_probe, // D x E x F + const float* f_exit_wave, // A x B x C + float* f_obj, // G x H x I + const float* object_weights, // G + float* f_probe, // D x E x F + const float* f_probe_support, // D x E x F, can be null + const float* probe_weights, // D + float obj_smooth_std, + float clip_min, + float clip_max, + float probe_center_tol, + float overlap_converge_factor, + int max_iterations, + int doUpdateObjectFirst, + int doUpdateProbe, + int doSmoothing, + int doClipping, + int doCentering, + int A, + int B, + int C, + int D, + int E, + int F, + int G, + int H, + int I) +{ + auto obj = reinterpret_cast*>(f_obj); + auto probe = reinterpret_cast*>(f_probe); + auto probe_support = reinterpret_cast*>(f_probe_support); + auto cfact_object = reinterpret_cast*>(f_cfact_object); + auto cfact_probe = reinterpret_cast*>(f_cfact_probe); + auto exit_wave = reinterpret_cast*>(f_exit_wave); + + auto dmoc = gpuManager.get_cuda_function( + "dm_overlap_constraint", + A, + B, + C, + D, + E, + F, + G, + H, + I, + obj_smooth_std, + doUpdateObjectFirst != 0, + doUpdateProbe != 0, + doSmoothing != 0, + doClipping != 0, + probe_support != 0, + doCentering != 0); + dmoc->allocate(); + dmoc->transfer_in(addr_info, + cfact_object, + cfact_probe, + exit_wave, + obj, + object_weights, + probe, + probe_support, + probe_weights); + dmoc->run(max_iterations, + clip_min, + clip_max, + probe_center_tol, + overlap_converge_factor); + dmoc->transfer_out(probe, obj); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/difference_map_overlap_constraint.h b/archive/cuda_extension/cuda/func/difference_map_overlap_constraint.h new file mode 100644 index 000000000..75e315959 --- /dev/null +++ b/archive/cuda_extension/cuda/func/difference_map_overlap_constraint.h @@ -0,0 +1,82 @@ +#pragma once +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +#include "center_probe.h" +#include "difference_map_update_object.h" +#include "difference_map_update_probe.h" + +class DifferenceMapOverlapConstraint : public CudaFunction +{ +public: + DifferenceMapOverlapConstraint(); + void setParameters( + int A, + int B, + int C, + int D, + int E, + int F, + int G, + int H, + int I, + float obj_smooth_std, + bool doUpdateObjectFirst, + bool doUpdateProbe, // in general (alloc space / ops for it) + bool doSmoothing, + bool doClipping, + bool withProbeSupport, + bool doCentering); + void setDeviceBuffers(int* d_addr_info, + complex* d_cfact_object, + complex* d_cfact_probe, + complex* d_exit_wave, + complex* d_obj, + float* d_obj_weigths, + complex* d_probe, + complex* d_probe_support, + float* d_probe_weights); + void allocate(); + void transfer_in(const int* addr_info, + const complex* cfact_object, + const complex* cfact_probe, + const complex* exit_wave, + const complex* obj, + const float* obj_weigths, + const complex* probe, + const complex* probe_support, + const float* probe_weights); + void run( + int max_iterations, + float clip_min, + float clip_max, + float probe_center_tol, + float overlap_converge_factor, + bool do_update_probe = true // update it in this call? (logical and with + // the general setParameters one is done) + ); + void transfer_out(complex* probe, complex* obj); + +private: + DevicePtrWrapper d_addr_info_; // A x 5 x 3 + DevicePtrWrapper> d_cfact_object_; // G x H x I + DevicePtrWrapper> d_cfact_probe_; // D x E x F + DevicePtrWrapper> d_exit_wave_; // A x B x C + DevicePtrWrapper> d_obj_; // G x H x I + DevicePtrWrapper d_obj_weights_; // G + DevicePtrWrapper> d_probe_; // D x E x F + DevicePtrWrapper> d_probe_support_; // D x E x F + DevicePtrWrapper d_probe_weights_; // D + bool doUpdateObjectFirst_ = false; + bool doUpdateProbe_ = true; + bool doSmoothing_ = false; + bool doClipping_ = true; + bool withProbeSupport_ = true; + bool doCentering_ = true; + int A_ = 0, B_ = 0, C_ = 0, D_ = 0, E_ = 0, F_ = 0, G_ = 0, H_ = 0, I_ = 0; + + DifferenceMapUpdateProbe* dm_update_probe_ = nullptr; + DifferenceMapUpdateObject* dm_update_object_ = nullptr; + CenterProbe* center_probe_ = nullptr; +}; \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/difference_map_realspace_constraint.cu b/archive/cuda_extension/cuda/func/difference_map_realspace_constraint.cu new file mode 100644 index 000000000..6c881cf50 --- /dev/null +++ b/archive/cuda_extension/cuda/func/difference_map_realspace_constraint.cu @@ -0,0 +1,112 @@ +#include "difference_map_realspace_constraint.h" + +#include "utils/Complex.h" +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +/************ Kernels ******************/ + +__global__ void difference_map_realspace_constraint_kernel( + const complex *obj_and_probe, + const complex *exit_wave, + float alpha, + complex *out, + size_t total) +{ + size_t idx = blockIdx.x * blockDim.x + threadIdx.x; + if (idx >= total) + return; + auto pno = obj_and_probe[idx]; + auto ex = exit_wave[idx]; + auto val = (1.0f + alpha) * pno - alpha * ex; + out[idx] = val; +} + +/***************** Class implementation ***********/ + +DifferenceMapRealspaceConstraint::DifferenceMapRealspaceConstraint() + : CudaFunction("difference_map_realspace_constraint") +{ +} + +void DifferenceMapRealspaceConstraint::setParameters(int i, int m, int n) +{ + i_ = i; + m_ = m; + n_ = n; +} + +void DifferenceMapRealspaceConstraint::setDeviceBuffers( + complex *d_obj_and_probe, + complex *d_exit_wave, + complex *d_out) +{ + d_obj_and_probe_ = d_obj_and_probe; + d_exit_wave_ = d_exit_wave; + d_out_ = d_out; +} + +void DifferenceMapRealspaceConstraint::allocate() +{ + ScopedTimer t(this, "allocate"); + d_obj_and_probe_.allocate(i_ * m_ * n_); + d_exit_wave_.allocate(i_ * m_ * n_); + d_out_.allocate(i_ * m_ * n_); +} + +complex *DifferenceMapRealspaceConstraint::getOutput() const +{ + return d_out_.get(); +} + +void DifferenceMapRealspaceConstraint::transfer_in( + const complex *obj_and_probe, const complex *exit_wave) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_obj_and_probe_.get(), obj_and_probe, i_ * m_ * n_); + gpu_memcpy_h2d(d_exit_wave_.get(), exit_wave, i_ * m_ * n_); +} + +void DifferenceMapRealspaceConstraint::transfer_out(complex *out) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(out, d_out_.get(), i_ * m_ * n_); +} + +void DifferenceMapRealspaceConstraint::run(float alpha) +{ + ScopedTimer t(this, "run"); + size_t total = size_t(m_) * size_t(n_) * size_t(i_); + size_t block = 256; + size_t blocks = (total + block - 1) / block; + + difference_map_realspace_constraint_kernel<<>>( + d_obj_and_probe_.get(), d_exit_wave_.get(), alpha, d_out_.get(), total); + checkLaunchErrors(); + + // sync device if timing is enabled + timing_sync(); +} + +/**************** interface function ************/ + +extern "C" void difference_map_realspace_constraint_c( + const float *fobj_and_probe, + const float *f_exit_wave, + float alpha, + int i, + int m, + int n, + float *fout) +{ + auto obj_and_probe = reinterpret_cast *>(fobj_and_probe); + auto exit_wave = reinterpret_cast *>(f_exit_wave); + auto out = reinterpret_cast *>(fout); + + auto dmc = gpuManager.get_cuda_function( + "dm_realspace_constraint", i, m, n); + dmc->allocate(); + dmc->transfer_in(obj_and_probe, exit_wave); + dmc->run(alpha); + dmc->transfer_out(out); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/difference_map_realspace_constraint.h b/archive/cuda_extension/cuda/func/difference_map_realspace_constraint.h new file mode 100644 index 000000000..0d80f2a71 --- /dev/null +++ b/archive/cuda_extension/cuda/func/difference_map_realspace_constraint.h @@ -0,0 +1,27 @@ +#pragma once + +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +class DifferenceMapRealspaceConstraint : public CudaFunction +{ +public: + DifferenceMapRealspaceConstraint(); + void setParameters(int i, int m, int n); + void setDeviceBuffers(complex *d_obj_and_probe, + complex *d_exit_wave, + complex *d_out); + void allocate(); + complex *getOutput() const; + void transfer_in(const complex *obj_and_probe, + const complex *exit_wave); + void transfer_out(complex *out); + void run(float alpha); + +private: + DevicePtrWrapper> d_obj_and_probe_; + DevicePtrWrapper> d_exit_wave_; + DevicePtrWrapper> d_out_; + int i_ = 0, m_ = 0, n_ = 0; +}; diff --git a/archive/cuda_extension/cuda/func/difference_map_update_object.cu b/archive/cuda_extension/cuda/func/difference_map_update_object.cu new file mode 100644 index 000000000..ab424380f --- /dev/null +++ b/archive/cuda_extension/cuda/func/difference_map_update_object.cu @@ -0,0 +1,226 @@ +#include "difference_map_update_object.h" +#include "utils/Complex.h" +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +/********* kernels *****************/ + +static __global__ void multiply_kernel(const complex* in1, + const complex* in2, + complex* out, + int n) +{ + int gid = threadIdx.x + blockIdx.x * blockDim.x; + if (gid >= n) + return; + out[gid] = in1[gid] * in2[gid]; +} + +/********** Class implementation **********/ + +DifferenceMapUpdateObject::DifferenceMapUpdateObject() + : CudaFunction("difference_map_update_object") +{ +} + +void DifferenceMapUpdateObject::setParameters(int A, + int B, + int C, + int D, + int E, + int F, + int G, + int H, + int I, + float obj_smooth_std, + bool doSmoothing, + bool doClipping) +{ + A_ = A; + B_ = B; + C_ = C; + D_ = D; + E_ = E; + F_ = F; + G_ = G; + H_ = H; + I_ = I; + doSmoothing_ = doSmoothing; + doClipping_ = doClipping; + + extract_array_from_exit_wave_ = + gpuManager.get_cuda_function( + "dm_update_object.extract_array_from_exit_wave", + A_, + B_, + C_, + D_, + E_, + F_, + G_, + H_, + I_); + extract_array_from_exit_wave_->setAddrStride(15); + + if (doClipping_) + { + clip_complex_magnitudes_to_range_ = + gpuManager.get_cuda_function( + "dm_update_object.clip_complex_magnitudes_to_range", G_ * H_ * I_); + } + if (doSmoothing_) + { + int dims[] = {G_, H_, I_}; + float mfs[] = {obj_smooth_std, obj_smooth_std}; + gaussian_filter_ = gpuManager.get_cuda_function( + "dm_update_object.gaussian_filter", 3, dims, mfs); + } +} + +void DifferenceMapUpdateObject::setDeviceBuffers(complex* d_obj, + float* d_object_weights, + complex* d_probe, + complex* d_exit_wave, + int* d_addr_info, + complex* d_cfact) +{ + d_obj_ = d_obj; + d_object_weights_ = d_object_weights; + d_probe_ = d_probe; + d_exit_wave_ = d_exit_wave; + d_addr_info_ = d_addr_info; + d_cfact_ = d_cfact; +} + +void DifferenceMapUpdateObject::allocate() +{ + ScopedTimer t(this, "allocate"); + d_obj_.allocate(G_ * H_ * I_); + d_object_weights_.allocate(G_); + d_probe_.allocate(D_ * E_ * F_); + d_exit_wave_.allocate(A_ * B_ * C_); + d_addr_info_.allocate(A_ * 15); + d_cfact_.allocate(G_ * H_ * I_); + + extract_array_from_exit_wave_->setDeviceBuffers(d_exit_wave_.get(), + d_addr_info_.get() + 6, + d_probe_.get(), + d_addr_info_.get(), + d_obj_.get(), + d_addr_info_.get() + 3, + d_object_weights_.get(), + d_cfact_.get(), + nullptr); + + extract_array_from_exit_wave_->allocate(); + + if (doClipping_) + { + clip_complex_magnitudes_to_range_->setDeviceBuffers(d_obj_.get()); + clip_complex_magnitudes_to_range_->allocate(); + } + + if (doSmoothing_) + { + gaussian_filter_->setDeviceBuffers(d_obj_.get(), d_obj_.get()); + gaussian_filter_->allocate(); + } +} + +void DifferenceMapUpdateObject::transfer_in(const complex* obj, + const float* object_weigths, + const complex* probe, + const complex* exit_wave, + const int* addr_info, + const complex* cfact) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_obj_.get(), obj, G_ * H_ * I_); + gpu_memcpy_h2d(d_object_weights_.get(), object_weigths, G_); + gpu_memcpy_h2d(d_probe_.get(), probe, D_ * E_ * F_); + gpu_memcpy_h2d(d_exit_wave_.get(), exit_wave, A_ * B_ * C_); + gpu_memcpy_h2d(d_addr_info_.get(), addr_info, A_ * 15); + gpu_memcpy_h2d(d_cfact_.get(), cfact, G_ * H_ * I_); +} + +void DifferenceMapUpdateObject::run(float clip_min, float clip_max) +{ + ScopedTimer t(this, "run"); + + if (doSmoothing_) + { + gaussian_filter_->run(); + } + + int total = G_ * H_ * I_; + int threadsPerBlock = 256; + int blocks = (total + threadsPerBlock - 1) / threadsPerBlock; + multiply_kernel<<>>( + d_obj_.get(), d_cfact_.get(), d_obj_.get(), G_ * H_ * I_); + checkLaunchErrors(); + + extract_array_from_exit_wave_->run(); + + if (doClipping_) + { + clip_complex_magnitudes_to_range_->run(clip_min, clip_max); + } + + timing_sync(); +} + +void DifferenceMapUpdateObject::transfer_out(complex* obj) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(obj, d_obj_.get(), G_ * H_ * I_); +} + +/********** Interface functions ******/ + +extern "C" void difference_map_update_object_c( + float* f_obj, // G x H x I + const float* object_weights, // G + const float* f_probe, // D x E x F + const float* f_exit_wave, // A x B x C + const int* addr_info, // A x 5 x 3 + const float* f_cfact_object, // G x H x I + float ob_smooth_std, // scalar + float clip_min, // scalar + float clip_max, // scalar + int doSmoothing, // boolean if smoothing should be done + int doClipping, // boolean if clipping should be done + int A, + int B, + int C, + int D, + int E, + int F, + int G, + int H, + int I) +{ + auto obj = reinterpret_cast*>(f_obj); + auto probe = reinterpret_cast*>(f_probe); + auto exit_wave = reinterpret_cast*>(f_exit_wave); + auto cfact = reinterpret_cast*>(f_cfact_object); + + auto dmuo = gpuManager.get_cuda_function( + "dm_update_object", + A, + B, + C, + D, + E, + F, + G, + H, + I, + ob_smooth_std, + doSmoothing != 0, + doClipping != 0); + + dmuo->allocate(); + dmuo->transfer_in(obj, object_weights, probe, exit_wave, addr_info, cfact); + dmuo->run(clip_min, clip_max); + dmuo->transfer_out(obj); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/difference_map_update_object.h b/archive/cuda_extension/cuda/func/difference_map_update_object.h new file mode 100644 index 000000000..a23d9b7aa --- /dev/null +++ b/archive/cuda_extension/cuda/func/difference_map_update_object.h @@ -0,0 +1,57 @@ +#pragma once + +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +#include "complex_gaussian_filter.h" +#include "extract_array_from_exit_wave.h" +#include "clip_complex_magnitudes_to_range.h" + +class DifferenceMapUpdateObject : public CudaFunction +{ +public: + DifferenceMapUpdateObject(); + void setParameters(int A, + int B, + int C, + int D, + int E, + int F, + int G, + int H, + int I, + float obj_smooth_std, + bool doSmoothing, + bool doClipping); + void setDeviceBuffers(complex* d_obj, + float* d_object_weights, + complex* d_probe, + complex* d_exit_wave, + int* d_addr_info, + complex* d_cfact); + void allocate(); + void transfer_in(const complex* obj, + const float* object_weigths, + const complex* probe, + const complex* exit_wave, + const int* addr_info, + const complex* cfact); + void run(float clip_min, float clip_max); + void transfer_out(complex* obj); + +private: + DevicePtrWrapper> d_obj_; // G x H x I + DevicePtrWrapper d_object_weights_; // G + DevicePtrWrapper> d_probe_; // D x E x F + DevicePtrWrapper> d_exit_wave_; // A x B x C + DevicePtrWrapper d_addr_info_; // A x 5 x 3 + DevicePtrWrapper> d_cfact_; // G x H x I + bool doSmoothing_ = false, doClipping_ = false; + int A_ = 0, B_ = 0, C_ = 0, D_ = 0, E_ = 0, F_ = 0, G_ = 0, H_ = 0, I_ = 0; + + // child kernels + ExtractArrayFromExitWave* extract_array_from_exit_wave_ = nullptr; + ClipComplexMagnitudesToRange* clip_complex_magnitudes_to_range_ = nullptr; + ComplexGaussianFilter* gaussian_filter_ = nullptr; +}; \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/difference_map_update_probe.cu b/archive/cuda_extension/cuda/func/difference_map_update_probe.cu new file mode 100644 index 000000000..8d3d11933 --- /dev/null +++ b/archive/cuda_extension/cuda/func/difference_map_update_probe.cu @@ -0,0 +1,242 @@ +#include "difference_map_update_probe.h" +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +#include + +/********* kernels *****************/ + +static __global__ void multiply_kernel(const complex* in1, + const complex* in2, + complex* out, + int n) +{ + int gid = threadIdx.x + blockIdx.x * blockDim.x; + if (gid >= n) + return; + out[gid] = in1[gid] * in2[gid]; +} + +static __global__ void diff_kernel(const complex* a, + const complex* b, + complex* res, + int n) +{ + int gid = threadIdx.x + blockIdx.x * blockDim.x; + if (gid >= n) + return; + res[gid] = a[gid] - b[gid]; +} + +/********* class implementation *********/ + +DifferenceMapUpdateProbe::DifferenceMapUpdateProbe() + : CudaFunction("difference_map_update_probe") +{ +} + +void DifferenceMapUpdateProbe::setParameters(int A, + int B, + int C, + int D, + int E, + int F, + int G, + int H, + int I, + bool withProbeSupport) +{ + A_ = A; + B_ = B; + C_ = C; + D_ = D; + E_ = E; + F_ = F; + G_ = G; + H_ = H; + I_ = I; + withProbeSupport_ = withProbeSupport; + + extract_array_from_exit_wave_ = + gpuManager.get_cuda_function( + "dm_update_probe.extract_array_from_exit_wave", + A_, + B_, + C_, + D_, + E_, + F_, + G_, + H_, + I_); + extract_array_from_exit_wave_->setAddrStride(15); + norm2_probe_ = gpuManager.get_cuda_function>>( + "dm_update_probe.norm2_probe", G_ * H_ * I_); + norm2_diff_ = gpuManager.get_cuda_function>>( + "dm_update_probe.norm2_diff", G_ * H_ * I_); +} + +void DifferenceMapUpdateProbe::setDeviceBuffers(complex* d_obj, + float* d_probe_weights, + complex* d_probe, + complex* d_exit_wave, + int* d_addr_info, + complex* d_cfact_probe, + complex* d_probe_support) +{ + d_obj_ = d_obj; + d_probe_weights_ = d_probe_weights; + d_probe_ = d_probe; + d_exit_wave_ = d_exit_wave; + d_addr_info_ = d_addr_info; + d_cfact_probe_ = d_cfact_probe; + d_probe_support_ = d_probe_support; +} + +void DifferenceMapUpdateProbe::allocate() +{ + ScopedTimer t(this, "allocate"); + + if (withProbeSupport_) + { + d_probe_support_.allocate(G_ * H_ * I_); + } + + d_obj_.allocate(D_ * E_ * F_); + d_probe_weights_.allocate(G_); + d_probe_.allocate(G_ * H_ * I_); + d_buffer_.allocate(G_ * H_ * I_); + d_exit_wave_.allocate(A_ * B_ * C_); + d_addr_info_.allocate(A_ * 5 * 3); + d_cfact_probe_.allocate(G_ * H_ * I_); + + + + extract_array_from_exit_wave_->setDeviceBuffers(d_exit_wave_.get(), + d_addr_info_.get() + 6, + d_obj_.get(), + d_addr_info_.get() + 3, + d_buffer_.get(), + d_addr_info_.get(), + d_probe_weights_.get(), + d_cfact_probe_.get(), + nullptr); + extract_array_from_exit_wave_->allocate(); + + norm2_probe_->setDeviceBuffers(d_buffer_.get(), + nullptr // just size 1, allocated internally + ); + norm2_probe_->allocate(); + + // here, we'll run d_probe = d_buffer_ - d_probe + norm2_diff_->setDeviceBuffers(d_probe_.get(), + nullptr // just size 1, allocated internally + ); + norm2_diff_->allocate(); + + // and we'll copy d_buffer_ to d_probe_ in the end +} + +void DifferenceMapUpdateProbe::transfer_in(const complex* obj, + const float* probe_weights, + const complex* probe, + const complex* exit_wave, + const int* addr_info, + const complex* cfact_probe, + const complex* probe_support) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_obj_.get(), obj, D_ * E_ * F_); + gpu_memcpy_h2d(d_probe_weights_.get(), probe_weights, G_); + gpu_memcpy_h2d(d_probe_.get(), probe, G_ * H_ * I_); + gpu_memcpy_h2d(d_exit_wave_.get(), exit_wave, A_ * B_ * C_); + gpu_memcpy_h2d(d_addr_info_.get(), addr_info, A_ * 3 * 5); + gpu_memcpy_h2d(d_cfact_probe_.get(), cfact_probe, G_ * H_ * I_); + if (withProbeSupport_) + { + gpu_memcpy_h2d(d_probe_support_.get(), probe_support, G_ * H_ * I_); + } +} + +void DifferenceMapUpdateProbe::run() +{ + ScopedTimer t(this, "run"); + + int total = G_ * H_ * I_; + int threadsPerBlock = 256; + int blocks = (total + threadsPerBlock - 1) / threadsPerBlock; + multiply_kernel<<>>( + d_probe_.get(), d_cfact_probe_.get(), d_buffer_.get(), G_ * H_ * I_); + checkLaunchErrors(); + + extract_array_from_exit_wave_->run(); + + if (withProbeSupport_) + { + multiply_kernel<<>>( + d_buffer_.get(), d_probe_support_.get(), d_buffer_.get(), G_ * H_ * I_); + checkLaunchErrors(); + } + + // d_probe = d_buffer_ - d_probe + diff_kernel<<>>( + d_buffer_.get(), d_probe_.get(), d_probe_.get(), G_ * H_ * I_); + checkLaunchErrors(); + + norm2_probe_->run(); + norm2_diff_->run(); + + gpu_memcpy_d2d(d_probe_.get(), d_buffer_.get(), G_ * H_ * I_); + + timing_sync(); +} + +void DifferenceMapUpdateProbe::transfer_out(complex* probe, + float* change) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(probe, d_probe_.get(), G_ * H_ * I_); + + float norm2diff, norm2probe; + gpu_memcpy_d2h(&norm2diff, norm2_diff_->getOutput(), 1); + gpu_memcpy_d2h(&norm2probe, norm2_probe_->getOutput(), 1); + + *change = std::sqrt(norm2diff / norm2probe / G_); +} + +/********* interface functions *********/ + +extern "C" float difference_map_update_probe_c( + const float* f_obj, // D x E x F + const float* probe_weights, // G + float* f_probe, // G x H x I + const float* f_exit_wave, // A x B x C + const int* addr_info, // A x 5 x 3 + const float* f_cfact_probe, // G x H x I + const float* f_probe_support, // G x H x I - can be null + int A, + int B, + int C, + int D, + int E, + int F, + int G, + int H, + int I) +{ + auto obj = reinterpret_cast*>(f_obj); + auto probe = reinterpret_cast*>(f_probe); + auto exit_wave = reinterpret_cast*>(f_exit_wave); + auto cfact = reinterpret_cast*>(f_cfact_probe); + auto probe_support = reinterpret_cast*>(f_probe_support); + + auto dmup = gpuManager.get_cuda_function( + "dm_update_probe", A, B, C, D, E, F, G, H, I, f_probe_support != nullptr); + dmup->allocate(); + dmup->transfer_in( + obj, probe_weights, probe, exit_wave, addr_info, cfact, probe_support); + dmup->run(); + float change; + dmup->transfer_out(probe, &change); + return change; +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/difference_map_update_probe.h b/archive/cuda_extension/cuda/func/difference_map_update_probe.h new file mode 100644 index 000000000..a222ca616 --- /dev/null +++ b/archive/cuda_extension/cuda/func/difference_map_update_probe.h @@ -0,0 +1,60 @@ +#pragma once + +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +#include "extract_array_from_exit_wave.h" +#include "norm2.h" + +class DifferenceMapUpdateProbe : public CudaFunction +{ +public: + DifferenceMapUpdateProbe(); + void setParameters(int A, + int B, + int C, + int D, + int E, + int F, + int G, + int H, + int I, + bool withProbeSupport); + void setDeviceBuffers(complex* d_obj, + float* d_probe_weights, + complex* d_probe, + complex* d_exit_wave, + int* d_addr_info, + complex* d_cfact_probe, + complex* d_probe_support); + void allocate(); + void transfer_in(const complex* obj, + const float* probe_weights, + const complex* probe, + const complex* exit_wave, + const int* addr_info, + const complex* cfact_probe, + const complex* probe_support); + void run(); + void transfer_out(complex* probe, float* change); + +private: + DevicePtrWrapper> d_obj_; + DevicePtrWrapper d_probe_weights_; + DevicePtrWrapper> d_probe_; + DevicePtrWrapper> d_exit_wave_; + DevicePtrWrapper d_addr_info_; + DevicePtrWrapper> d_cfact_probe_; + DevicePtrWrapper> d_probe_support_; + int A_ = 0, B_ = 0, C_ = 0, D_ = 0, E_ = 0, F_ = 0, G_ = 0, H_ = 0, I_ = 0; + bool withProbeSupport_ = true; + + // temporary buffers + DevicePtrWrapper> d_buffer_; // size = probe + + // child kernels + ExtractArrayFromExitWave* extract_array_from_exit_wave_ = nullptr; + Norm2>* norm2_probe_; + Norm2>* norm2_diff_; +}; \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/extract_array_from_exit_wave.cu b/archive/cuda_extension/cuda/func/extract_array_from_exit_wave.cu new file mode 100644 index 000000000..c5a34a0a3 --- /dev/null +++ b/archive/cuda_extension/cuda/func/extract_array_from_exit_wave.cu @@ -0,0 +1,255 @@ +#include "addr_info_helpers.h" +#include "extract_array_from_exit_wave.h" +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +#include +#include +#include + +/*********** kernels ************************/ + +__device__ inline void atomicAdd(complex* x, complex y) +{ + auto xf = reinterpret_cast(x); + atomicAdd(xf, y.real()); + atomicAdd(xf + 1, y.imag()); +} + +template +__global__ void extract_array_from_exit_wave_kernel( + const complex* exit_wave, + int A, + int B, + int C, + const int* exit_addr, + const complex* array_to_be_extracted, + int D, + int E, + int F, + const int* extract_addr, + complex* array_to_be_updated, + int G, + int H, + int I, + const int* update_addr, + const float* weights, + complex* denominator, + int addr_stride) +{ + // one block per addr instance + int bid = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + + auto pa = update_addr + bid * addr_stride; + auto oa = extract_addr + bid * addr_stride; + auto ea = exit_addr + bid * addr_stride; + + array_to_be_extracted += oa[0] * E * F + oa[1] * F + oa[2]; + array_to_be_updated += pa[0] * H * I + pa[1] * I + pa[2]; + denominator += pa[0] * H * I + pa[1] * I + pa[2]; + + assert(pa[0] * H * I + pa[1] * I + pa[2] + (B - 1) * I + C - 1 < G * H * I); + + auto weight = weights[pa[0]]; + exit_wave += ea[0] * B * C; + + for (int b = tx; b < B; b += blockDim.x) + { + for (int c = ty; c < C; c += blockDim.y) + { + auto extracted_array = array_to_be_extracted[b * F + c]; + auto extracted_array_conj = conj(extracted_array); + atomicAdd(&array_to_be_updated[b * I + c], + extracted_array_conj * exit_wave[b * C + c] * weight); + atomicAdd(&denominator[b * I + c], + extracted_array * extracted_array_conj * weight); + } + } +} + +template +__global__ void div_by_denominator(complex* array_to_be_updated, + const complex* denominator, + int n) +{ + int gid = threadIdx.x + blockIdx.x * blockDim.x; + if (gid >= n) + return; + array_to_be_updated[gid] /= denominator[gid]; +} + +/*********** class implementation *********/ + +ExtractArrayFromExitWave::ExtractArrayFromExitWave() + : CudaFunction("extract_array_from_exit_wave") + +{ +} + +void ExtractArrayFromExitWave::setParameters( + int A, int B, int C, int D, int E, int F, int G, int H, int I) +{ + A_ = A; + B_ = B; + C_ = C; + D_ = D; + E_ = E; + F_ = F; + G_ = G; + H_ = H; + I_ = I; +} + +void ExtractArrayFromExitWave::setDeviceBuffers( + complex* d_exit_wave, + int* d_exit_addr, + complex* d_array_to_be_extracted, + int* d_extract_addr, + complex* d_array_to_be_updated, + int* d_update_addr, + float* d_weights, + complex* d_cfact, + complex* d_denominator) +{ + d_exit_wave_ = d_exit_wave; + d_exit_addr_ = d_exit_addr; + d_array_to_be_extracted_ = d_array_to_be_extracted; + d_extract_addr_ = d_extract_addr; + d_array_to_be_updated_ = d_array_to_be_updated; + d_update_addr_ = d_update_addr; + d_weights_ = d_weights; + d_cfact_ = d_cfact; + d_denominator_ = d_denominator; +} + +void ExtractArrayFromExitWave::allocate() +{ + ScopedTimer t(this, "allocate"); + + d_exit_wave_.allocate(A_ * B_ * C_); + d_exit_addr_.allocate(A_ * addr_stride_); + d_array_to_be_extracted_.allocate(D_ * E_ * F_); + d_extract_addr_.allocate(A_ * addr_stride_); + d_array_to_be_updated_.allocate(G_ * H_ * I_); + d_update_addr_.allocate(A_ * addr_stride_); + d_weights_.allocate(G_); + d_cfact_.allocate(G_ * H_ * I_); + d_denominator_.allocate(G_ * H_ * I_); +} + +void ExtractArrayFromExitWave::transfer_in( + const complex* exit_wave, + const int* exit_addr, + const complex* array_to_be_extracted, + const int* extract_addr, + const complex* array_to_be_updated, + const int* update_addr, + const float* weights, + const complex* cfact) +{ + ScopedTimer t(this, "transfer in"); + + gpu_memcpy_h2d(d_exit_wave_.get(), exit_wave, A_ * B_ * C_); + gpu_memcpy_h2d(d_exit_addr_.get(), exit_addr, A_ * addr_stride_); + gpu_memcpy_h2d( + d_array_to_be_extracted_.get(), array_to_be_extracted, D_ * E_ * F_); + gpu_memcpy_h2d(d_extract_addr_.get(), extract_addr, A_ * addr_stride_); + gpu_memcpy_h2d( + d_array_to_be_updated_.get(), array_to_be_updated, G_ * H_ * I_); + gpu_memcpy_h2d(d_update_addr_.get(), update_addr, A_ * addr_stride_); + gpu_memcpy_h2d(d_weights_.get(), weights, G_); + gpu_memcpy_h2d(d_cfact_.get(), cfact, G_ * H_ * I_); +} + +void ExtractArrayFromExitWave::run() +{ + ScopedTimer t(this, "run"); + + gpu_memcpy_d2d(d_denominator_.get(), d_cfact_.get(), G_ * H_ * I_); + + // we used one block per updateidx + dim3 threadsPerBlock = {32u, 32u, 1u}; + dim3 blocks = {unsigned(A_), 1u, 1u}; + extract_array_from_exit_wave_kernel<32, 32> + <<>>(d_exit_wave_.get(), + A_, + B_, + C_, + d_exit_addr_.get(), + d_array_to_be_extracted_.get(), + D_, + E_, + F_, + d_extract_addr_.get(), + d_array_to_be_updated_.get(), + G_, + H_, + I_, + d_update_addr_.get(), + d_weights_.get(), + d_denominator_.get(), + addr_stride_); + checkLaunchErrors(); + + int total = G_ * H_ * I_; + int blocks2 = (total + 255) / 256; + div_by_denominator<256><<>>( + d_array_to_be_updated_.get(), d_denominator_.get(), total); + + checkLaunchErrors(); + timing_sync(); +} + +void ExtractArrayFromExitWave::transfer_out(complex* array_to_be_updated) +{ + ScopedTimer t(this, "transfer out"); + + gpu_memcpy_d2h( + array_to_be_updated, d_array_to_be_updated_.get(), G_ * H_ * I_); +} + +/************ interface *******************/ + +extern "C" void extract_array_from_exit_wave_c( + const float* f_exit_wave, // complex + int A, + int B, + int C, + const int* exit_addr, // A x 3 - int + const float* f_array_to_be_extracted, // complex + int D, + int E, + int F, + const int* extract_addr, // A x 3 - int + float* f_array_to_be_updated, // complex + int G, + int H, + int I, + const int* update_addr, // A x 3 - int + const float* weights, // G - real + const float* f_cfact // G, H, I - complex +) +{ + auto exit_wave = reinterpret_cast*>(f_exit_wave); + auto array_to_be_extracted = + reinterpret_cast*>(f_array_to_be_extracted); + auto array_to_be_updated = + reinterpret_cast*>(f_array_to_be_updated); + auto cfact = reinterpret_cast*>(f_cfact); + + auto ex = gpuManager.get_cuda_function( + "extract_array_from_exit_wave", A, B, C, D, E, F, G, H, I); + ex->allocate(); + ex->transfer_in(exit_wave, + exit_addr, + array_to_be_extracted, + extract_addr, + array_to_be_updated, + update_addr, + weights, + cfact); + ex->run(); + ex->transfer_out(array_to_be_updated); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/extract_array_from_exit_wave.h b/archive/cuda_extension/cuda/func/extract_array_from_exit_wave.h new file mode 100644 index 000000000..c5c24f7cf --- /dev/null +++ b/archive/cuda_extension/cuda/func/extract_array_from_exit_wave.h @@ -0,0 +1,46 @@ +#pragma once +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +class ExtractArrayFromExitWave : public CudaFunction +{ +public: + ExtractArrayFromExitWave(); + void setParameters( + int A, int B, int C, int D, int E, int F, int G, int H, int I); + void setDeviceBuffers(complex* d_exit_wave, + int* d_exit_addr, + complex* d_array_to_be_extracted, + int* d_extract_addr, + complex* d_array_to_be_updated, + int* d_update_addr, + float* d_weights, + complex* d_cfact, + complex* d_denominator); + void setAddrStride(int stride) { addr_stride_ = stride; } + void allocate(); + void transfer_in(const complex* exit_wave, + const int* exit_addr, + const complex* array_to_be_extracted, + const int* extract_addr, + const complex* array_to_be_updated, + const int* update_addr, + const float* weights, + const complex* cfact); + void run(); + void transfer_out(complex* array_to_be_updated); + +private: + DevicePtrWrapper> d_exit_wave_; // A x B x C + DevicePtrWrapper d_exit_addr_; // A x 3 + DevicePtrWrapper> d_array_to_be_extracted_; // D x E x F + DevicePtrWrapper d_extract_addr_; // A x 3 + DevicePtrWrapper> d_array_to_be_updated_; // G x H x I + DevicePtrWrapper d_update_addr_; // A x 3 + DevicePtrWrapper d_weights_; // G + DevicePtrWrapper> d_cfact_; // G x H x I + DevicePtrWrapper> d_denominator_; // G x H x I + int A_ = 0, B_ = 0, C_ = 0, D_ = 0, E_ = 0, F_ = 0, G_ = 0, H_ = 0, I_ = 0; + int addr_stride_ = 3; // default is 3, but if full addr_info is used, it's 15 +}; \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/far_field_error.cu b/archive/cuda_extension/cuda/func/far_field_error.cu new file mode 100644 index 000000000..9fca007f6 --- /dev/null +++ b/archive/cuda_extension/cuda/func/far_field_error.cu @@ -0,0 +1,154 @@ +#include "far_field_error.h" + +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +/************* Kernels **********************/ + +template +__global__ void far_field_error_kernel(const float *current, + const float *measured, + const unsigned char *mask, + float *out, + int m, + int n) +{ + int batch = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + + extern __shared__ float sum_v[]; + auto sum_mask = (int *)(sum_v + BlockX * BlockY); + auto shidx = tx * BlockY + ty; + sum_v[shidx] = 0.0; + sum_mask[shidx] = 0.0; + + auto offset = batch * m * n; +#pragma unroll(2) + for (int i = tx; i < m; i += BlockX) + { +#pragma unroll(1) + for (int j = ty; j < n; j += BlockY) + { + auto idx = offset + i * n + j; + if (mask[idx]) + { + auto fdev = current[idx] - measured[idx]; + auto fdev2 = fdev * fdev; + sum_v[shidx] += fdev2; + sum_mask[shidx] += 1; + } + } + } + + // now sum up the data in shared memory, tree type reduction + __syncthreads(); + int nt = BlockX * BlockY; + int c = nt; + while (c > 1) + { + int half = c / 2; + if (shidx < half) + { + sum_v[shidx] += sum_v[c - shidx - 1]; + sum_mask[shidx] += sum_mask[c - shidx - 1]; + } + __syncthreads(); + c = c - half; + } + + if (shidx == 0) + { + out[batch] = sum_v[0] / float(sum_mask[0]); + } +} + +/************* class implementation ********************/ + +FarFieldError::FarFieldError() : CudaFunction("far_field_error") {} + +void FarFieldError::setParameters(int i, int m, int n) +{ + i_ = i; + m_ = m; + n_ = n; +} + +void FarFieldError::setDeviceBuffers(float *d_current, + float *d_measured, + unsigned char *d_mask, + float *d_out) +{ + d_current_ = d_current; + d_measured_ = d_measured; + d_mask_ = d_mask; + d_out_ = d_out; +} + +void FarFieldError::allocate() +{ + ScopedTimer t(this, "allocate"); + d_current_.allocate(i_ * m_ * n_); + d_measured_.allocate(i_ * m_ * n_); + d_mask_.allocate(i_ * m_ * n_); + d_out_.allocate(i_); +} + +void FarFieldError::updateErrorOutput(float *d_out) { d_out_ = d_out; } + +float *FarFieldError::getOutput() const { return d_out_.get(); } + +void FarFieldError::transfer_in(const float *current, + const float *measured, + const unsigned char *mask) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_current_.get(), current, i_ * m_ * n_); + gpu_memcpy_h2d(d_measured_.get(), measured, i_ * m_ * n_); + gpu_memcpy_h2d(d_mask_.get(), mask, i_ * m_ * n_); +} + +void FarFieldError::run() +{ + ScopedTimer t(this, "run"); + + // always use a 32x32 block of threads + dim3 threadsPerBlock = {32u, 32u, 1u}; + dim3 blocks = {unsigned(i_), 1u, 1u}; + + far_field_error_kernel<32, 32> + <<>>( + d_current_.get(), + d_measured_.get(), + d_mask_.get(), + d_out_.get(), + m_, + n_); + checkLaunchErrors(); + + timing_sync(); +} + +void FarFieldError::transfer_out(float *out) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(out, d_out_.get(), i_); +} + +/************* interface function **********************/ + +extern "C" void far_field_error_c(const float *current, + const float *measured, + const unsigned char *mask, + float *out, + int i, + int m, + int n) +{ + auto ffe = + gpuManager.get_cuda_function("farfield_error", i, m, n); + ffe->allocate(); + ffe->transfer_in(current, measured, mask); + ffe->run(); + ffe->transfer_out(out); +} diff --git a/archive/cuda_extension/cuda/func/far_field_error.h b/archive/cuda_extension/cuda/func/far_field_error.h new file mode 100644 index 000000000..c7f332a32 --- /dev/null +++ b/archive/cuda_extension/cuda/func/far_field_error.h @@ -0,0 +1,29 @@ +#pragma once +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +class FarFieldError : public CudaFunction +{ +public: + FarFieldError(); + void setParameters(int i, int m, int n); + void setDeviceBuffers(float *d_current, + float *d_measured, + unsigned char *d_mask, + float *d_out); + void allocate(); + void updateErrorOutput(float *d_out); + float *getOutput() const; + void transfer_in(const float *current, + const float *measured, + const unsigned char *mask); + void run(); + void transfer_out(float *out); + +private: + int i_ = 0, m_ = 0, n_ = 0; + DevicePtrWrapper d_mask_; + DevicePtrWrapper d_current_; + DevicePtrWrapper d_measured_; + DevicePtrWrapper d_out_; +}; diff --git a/archive/cuda_extension/cuda/func/farfield_propagator.cu b/archive/cuda_extension/cuda/func/farfield_propagator.cu new file mode 100644 index 000000000..2c9fa6cc8 --- /dev/null +++ b/archive/cuda_extension/cuda/func/farfield_propagator.cu @@ -0,0 +1,231 @@ +#include "farfield_propagator.h" + +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +#include + +/**************** Kernels ***************/ + +// can't do in-place modification of inputs +__global__ void applyPrefilter(const complex *datain, + complex *dataout, + const complex *__restrict__ filter, + size_t batchsize, + size_t size) +{ + size_t offset = threadIdx.x + blockIdx.x * blockDim.x; + if (offset >= batchsize * size) + return; + dataout[offset] = datain[offset] * filter[offset % size]; +} + +// this can always be done in-place +__global__ void applyPostfilter(complex *data, + const complex *__restrict__ filter, + float sc, + size_t batchsize, + size_t size) +{ + size_t offset = threadIdx.x + blockIdx.x * blockDim.x; + size_t total = batchsize * size; + if (offset >= total) + return; + auto val = data[offset]; + if (filter) + { + val = filter[offset % size] * val; + } + val *= sc; + data[offset] = val; +} + +/*************** Class implementation ********************/ + +cufftHandle FFTPlanManager::get_or_create_plan(int i, int m, int n) +{ + key_t key{i, m, n}; + if (plans_.find(key) == plans_.end()) + { + cufftHandle plan; + checkCudaErrors(cufftCreate(&plan)); + plans_[key] = plan; + + int dims[] = {m, n}; + size_t workSize; + checkCudaErrors(cufftMakePlanMany( + plan, 2, dims, 0, 0, 0, 0, 0, 0, CUFFT_C2C, i, &workSize)); +#ifndef NDEBUG + debug_addMemory((void *)long(plan), workSize); + std::cout << "Made FFT Plan for " << m << "x" << n << ", batch=" << i + << std::endl; + std::cout << "Allocated " << (void *)long(plan) + << ", total: " << double(debug_getMemory()) << std::endl; +#endif + } + + return plans_[key]; +} + +void FFTPlanManager::clearCache() +{ + for (auto &item : plans_) + { + cufftDestroy(item.second); +#ifndef NDEBUG + std::cout << "Freeing for FFT plan " << (void *)long(item.second) + << std::endl; + debug_freeMemory((void *)long(item.second)); + std::cout << "Total allocated: " << double(debug_getMemory()) << std::endl; +#endif + } + plans_.clear(); +} + +FFTPlanManager::~FFTPlanManager() { clearCache(); } + +/******************************/ + +FFTPlanManager FarfieldPropagator::planManager_; + +FarfieldPropagator::FarfieldPropagator() : CudaFunction("farfield_propagator") +{ +} + +void FarfieldPropagator::setParameters(size_t batch_size, size_t m, size_t n) +{ + batch_size_ = batch_size; + m_ = m; + n_ = n; + sc_ = + 1.0f / std::sqrt(float(m * n)); // with cuFFT, we need to scale both ways +} + +void FarfieldPropagator::setDeviceBuffers(complex *d_datain, + complex *d_dataout, + complex *d_prefilter, + complex *d_postfilter) +{ + d_datain_ = d_datain; + d_dataout_ = d_dataout; + d_pre_ = d_prefilter; + d_post_ = d_postfilter; +} + +void FarfieldPropagator::allocate() +{ + { + ScopedTimer t(this, "allocate"); + + d_datain_.allocate(batch_size_ * m_ * n_); + d_dataout_.allocate(batch_size_ * m_ * n_); + d_pre_.allocate(m_ * n_); + d_post_.allocate(m_ * n_); + } + + { + ScopedTimer t(this, "plan create"); + plan_ = FarfieldPropagator::planManager_.get_or_create_plan( + batch_size_, m_, n_); + } +} + +void FarfieldPropagator::transfer_in( + const complex *data_to_be_transformed, + const complex *prefilter, + const complex *postfilter) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d( + d_datain_.get(), data_to_be_transformed, batch_size_ * m_ * n_); + gpu_memcpy_h2d(d_pre_.get(), prefilter, m_ * n_); + gpu_memcpy_h2d(d_post_.get(), postfilter, m_ * n_); +} + +void FarfieldPropagator::transfer_out(complex *out) +{ + ScopedTimer t(this, "transfer out"); + if (out) + { + gpu_memcpy_d2h(out, d_dataout_.get(), batch_size_ * m_ * n_); + } +} + +void FarfieldPropagator::run(bool doPreFilter, + bool doPostFilter, + bool isForward) +{ + ScopedTimer t(this, "run"); + + size_t block = 256; + size_t total = batch_size_ * m_ * n_; + size_t blocks = (total + block - 1) / block; + auto indata = d_datain_.get(); + if (doPreFilter) + { + applyPrefilter<<>>( + d_datain_.get(), d_dataout_.get(), d_pre_.get(), batch_size_, m_ * n_); + checkLaunchErrors(); + indata = d_dataout_.get(); + } + + if (isForward) + { + checkCudaErrors( + cufftExecC2C(plan_, + reinterpret_cast(indata), + reinterpret_cast(d_dataout_.get()), + CUFFT_FORWARD)); + } + else + { + checkCudaErrors( + cufftExecC2C(plan_, + reinterpret_cast(indata), + reinterpret_cast(d_dataout_.get()), + CUFFT_INVERSE)); + } + + if (doPostFilter) + { + applyPostfilter<<>>( + d_dataout_.get(), d_post_.get(), sc_, batch_size_, m_ * n_); + checkLaunchErrors(); + } + else + { + applyPostfilter<<>>( + d_dataout_.get(), nullptr, sc_, batch_size_, m_ * n_); + checkLaunchErrors(); + } + + // sync device if timing is enabled + timing_sync(); +} + +/************* Interface function ************/ + +extern "C" void farfield_propagator_c(const float *fdata_to_be_transformed, + const float *fprefilter, + const float *fpostfilter, + float *fout, + int b, + int m, + int n, + int iisForward) +{ + auto data_to_be_transformed = + reinterpret_cast *>(fdata_to_be_transformed); + // pre- and post-filter are 2D, applied in every batch item + auto prefilter = reinterpret_cast *>(fprefilter); + auto postfilter = reinterpret_cast *>(fpostfilter); + auto out = reinterpret_cast *>(fout); + auto isForward = iisForward != 0; + + auto prop = gpuManager.get_cuda_function( + "farfield_propagator", b, m, n); + prop->allocate(); + prop->transfer_in(data_to_be_transformed, prefilter, postfilter); + prop->run(prefilter != nullptr, postfilter != nullptr, isForward); + prop->transfer_out(out); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/farfield_propagator.h b/archive/cuda_extension/cuda/func/farfield_propagator.h new file mode 100644 index 000000000..6e1e3fa47 --- /dev/null +++ b/archive/cuda_extension/cuda/func/farfield_propagator.h @@ -0,0 +1,83 @@ +#pragma once + +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +#include +#include +#include + +/** Class to manage FFT plans - re-using plans for same + * dimensions. + * + * Intended as static member of farfield_propagator + * + * Note that plans will stay allocated for the duration of the process. + * To avoid that, this class could be included into the GpuManager, and + * cleared together with the resetFunctionCache method. + */ +class FFTPlanManager +{ +public: + cufftHandle get_or_create_plan(int i, int m, int n); + void clearCache(); + ~FFTPlanManager(); + +private: + /// map key type + struct key_t + { + int i, m, n; + }; + + struct comp_t + { + bool operator()(const key_t &a, const key_t &b) const + { + if (a.i != b.i) + return a.i < b.i; + if (a.m != b.m) + return a.m < b.m; + return a.n < b.n; + } + }; + + /// map type + typedef std::map map_t; + + /// our stored plans + map_t plans_; +}; + +class FarfieldPropagator : public CudaFunction +{ +public: + FarfieldPropagator(); + void setParameters(size_t batch_size, size_t m, size_t n); + + // for setting external memory to be used + // (can be null if internal should be used) + void setDeviceBuffers(complex *d_datain, + complex *d_dataout, + complex *d_prefilter, + complex *d_postfilter); + + void allocate(); + void transfer_in(const complex *data_to_be_transformed, + const complex *prefilter, + const complex *postfilter); + void transfer_out(complex *out); + void run(bool doPreFilter, bool doPostFilter, bool isForward); + static void clearPlanCache() { planManager_.clearCache(); } + +private: + size_t batch_size_ = 0, m_ = 0, n_ = 0; + float sc_ = 1.0f; + DevicePtrWrapper> d_datain_; + DevicePtrWrapper> d_dataout_; + DevicePtrWrapper> d_pre_; + DevicePtrWrapper> d_post_; + cufftHandle plan_ = 0; + static FFTPlanManager planManager_; +}; diff --git a/archive/cuda_extension/cuda/func/get_difference.cu b/archive/cuda_extension/cuda/func/get_difference.cu new file mode 100644 index 000000000..715eb6dca --- /dev/null +++ b/archive/cuda_extension/cuda/func/get_difference.cu @@ -0,0 +1,190 @@ +#include "get_difference.h" + +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +/************* kernels ******************************/ + +template +__global__ void get_difference_kernel( + const int *addr_info, + float alpha, + const complex *backpropagated_solution, + const float *err_fmag, + const complex *exit_wave, + float pbound, + const complex *probe_obj, + complex *out, + int m, + int n) +{ + int batch = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + + // each of these are 3-d arrays with indices + auto ea = addr_info + batch * 3 * 5 + 6; + auto da = ea + 3; + + // these are the start indices for the batch item + auto offset = ea[0] * m * n; + + auto da_0 = da[0]; + +#pragma unroll(2) + for (int i = tx; i < m; i += BlockX) + { +#pragma unroll(1) // to make sure the compiler doesn't unroll + for (int j = ty; j < n; j += BlockY) + { + auto outidx = offset + i * n + j; + if (!usePbound || err_fmag[da_0] > pbound) + { + out[outidx] = backpropagated_solution[outidx] - probe_obj[outidx]; + } + else + { + out[outidx] = alpha * (probe_obj[outidx] - exit_wave[outidx]); + } + } + } +} + +/************* class implementation *****************/ + +GetDifference::GetDifference() : CudaFunction("get_difference") {} + +void GetDifference::setParameters(int i, int m, int n) +{ + i_ = i; + m_ = m; + n_ = n; +} + +void GetDifference::setDeviceBuffers(int *d_addr_info, + complex *d_backpropagated_solution, + float *d_err_fmag, + complex *d_exit_wave, + complex *d_probe_obj, + complex *d_out) +{ + d_addr_info_ = d_addr_info; + d_backpropagated_solution_ = d_backpropagated_solution; + d_err_fmag_ = d_err_fmag; + d_exit_wave_ = d_exit_wave; + d_probe_obj_ = d_probe_obj; + d_out_ = d_out; +} +void GetDifference::allocate() +{ + ScopedTimer t(this, "allocate"); + d_addr_info_.allocate(i_ * 5 * 3); + d_backpropagated_solution_.allocate(i_ * m_ * n_); + d_err_fmag_.allocate(i_); + d_exit_wave_.allocate(i_ * m_ * n_); + d_probe_obj_.allocate(i_ * m_ * n_); + d_out_.allocate(i_ * m_ * n_); +} + +void GetDifference::updateErrorInput(float *d_err_fmag) +{ + d_err_fmag_ = d_err_fmag; +} + +complex *GetDifference::getOutput() const { return d_out_.get(); } + +void GetDifference::transfer_in(const int *addr_info, + const complex *backpropagated_solution, + const float *err_fmag, + const complex *exit_wave, + const complex *probe_obj) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_addr_info_.get(), addr_info, i_ * 5 * 3); + gpu_memcpy_h2d( + d_backpropagated_solution_.get(), backpropagated_solution, i_ * m_ * n_); + gpu_memcpy_h2d(d_err_fmag_.get(), err_fmag, i_); + gpu_memcpy_h2d(d_exit_wave_.get(), exit_wave, i_ * m_ * n_); + gpu_memcpy_h2d(d_probe_obj_.get(), probe_obj, i_ * m_ * n_); +} + +void GetDifference::run(float alpha, float pbound, bool usePbound) +{ + ScopedTimer t(this, "run"); + + // TODO: is this really needed? + checkCudaErrors( + cudaMemset(d_out_.get(), 0, i_ * m_ * n_ * sizeof(*d_out_.get()))); + + // always use a 32x32 block of threads + dim3 threadsPerBlock = {32u, 32u, 1u}; + dim3 blocks = {unsigned(i_), 1u, 1u}; + if (usePbound) + { + get_difference_kernel + <<>>(d_addr_info_.get(), + alpha, + d_backpropagated_solution_.get(), + d_err_fmag_.get(), + d_exit_wave_.get(), + pbound, + d_probe_obj_.get(), + d_out_.get(), + m_, + n_); + checkLaunchErrors(); + } + else + { + get_difference_kernel + <<>>(d_addr_info_.get(), + alpha, + d_backpropagated_solution_.get(), + d_err_fmag_.get(), + d_exit_wave_.get(), + pbound, + d_probe_obj_.get(), + d_out_.get(), + m_, + n_); + checkLaunchErrors(); + } + + timing_sync(); +} + +void GetDifference::transfer_out(complex *out) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(out, d_out_.get(), i_ * m_ * n_); +} + +/************* interface function *******************/ + +extern "C" void get_difference_c(const int *addr_info, + float alpha, + const float *fbackpropagated_solution, + const float *err_fmag, + const float *fexit_wave, + float pbound, + const float *fprobe_obj, + float *fout, + int i, + int m, + int n, + int usePbound) +{ + auto backpropagated_solution = + reinterpret_cast *>(fbackpropagated_solution); + auto exit_wave = reinterpret_cast *>(fexit_wave); + auto probe_obj = reinterpret_cast *>(fprobe_obj); + auto out = reinterpret_cast *>(fout); + + auto gd = + gpuManager.get_cuda_function("get_difference", i, m, n); + gd->allocate(); + gd->transfer_in( + addr_info, backpropagated_solution, err_fmag, exit_wave, probe_obj); + gd->run(alpha, pbound, usePbound != 0); + gd->transfer_out(out); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/get_difference.h b/archive/cuda_extension/cuda/func/get_difference.h new file mode 100644 index 000000000..1dede5750 --- /dev/null +++ b/archive/cuda_extension/cuda/func/get_difference.h @@ -0,0 +1,36 @@ +#pragma once +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +class GetDifference : public CudaFunction +{ +public: + GetDifference(); + void setParameters(int i, int m, int n); + void setDeviceBuffers(int *d_addr_info, + complex *d_backpropagated_solution, + float *d_err_fmag, + complex *d_exit_wave, + complex *d_probe_obj, + complex *d_out); + void allocate(); + void updateErrorInput(float *d_err_fmag); + complex *getOutput() const; + void transfer_in(const int *addr_info, + const complex *backpropagated_solution, + const float *err_fmag, + const complex *exit_wave, + const complex *probe_obj); + void run(float alpha, float pbound = 0.0f, bool usePbound = false); + void transfer_out(complex *out); + +private: + DevicePtrWrapper d_addr_info_; + DevicePtrWrapper> d_backpropagated_solution_; + DevicePtrWrapper d_err_fmag_; + DevicePtrWrapper> d_exit_wave_; + DevicePtrWrapper> d_probe_obj_; + DevicePtrWrapper> d_out_; + int i_ = 0, m_ = 0, n_ = 0; +}; \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/interpolated_shift.cu b/archive/cuda_extension/cuda/func/interpolated_shift.cu new file mode 100644 index 000000000..212420849 --- /dev/null +++ b/archive/cuda_extension/cuda/func/interpolated_shift.cu @@ -0,0 +1,428 @@ +#include "interpolated_shift.h" + +#include "splines/bspline_kernel.cuh" +#include "splines/cubicPrefilter2D.cuh" +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +#include +#include +#include +#include +#include + +/********* kernels ******************/ + +template +__global__ void integer_shift_kernel(const complex* in, + complex* out, + int rows, + int columns, + int rowOffset, + int colOffset) +{ + int tx = threadIdx.x + blockIdx.x * BlockX; + int ty = threadIdx.y + blockIdx.y * BlockY; + if (tx >= rows || ty >= columns) + return; + + int item = blockIdx.z; + in += item * rows * columns; + out += item * rows * columns; + + int gid_old = tx * columns + ty; + assert(gid_old < columns * rows); + assert(gid_old >= 0); + + auto val = in[gid_old]; + + int gid_new_x = tx + rowOffset; + int gid_new_y = ty + colOffset; + + // write zero on the other end + while (gid_new_x >= rows) + { + val = complex(); + gid_new_x -= rows; + } + while (gid_new_x < 0) + { + val = complex(); + gid_new_x += rows; + } + while (gid_new_y >= columns) + { + val = complex(); + gid_new_y -= columns; + } + while (gid_new_y < 0) + { + val = complex(); + gid_new_y += columns; + } + // do we need to do something with the corners? + + int gid_new = gid_new_x * columns + gid_new_y; + assert(gid_new < rows * columns); + assert(gid_new >= 0); + + out[gid_new] = val; +} + +__device__ inline complex& ascomplex(float2& f2) +{ + return reinterpret_cast&>(f2); +} + +__device__ inline void calcWeights(float* weights, float fraction) +{ + if (fraction < 0.0) + { + weights[2] = -fraction; + weights[1] = 1.0f + fraction; + weights[0] = 0.0f; + } + else + { + weights[2] = 0.0f; + weights[1] = 1.0f - fraction; + weights[0] = fraction; + } +} + +template +__global__ void linear_interpolate_kernel(const complex* in, + complex* out, + int rows, + int columns, + float offsetRow, + float offsetColumn) +{ + int offsetRowInt = int(offsetRow); + int offsetColInt = int(offsetColumn); + float offsetRowFrac = offsetRow - offsetRowInt; // positive or negative + float offsetColFrac = offsetColumn - offsetColInt; + + // calculate convolutional weights + float wx[3]; + calcWeights(wx, offsetRowFrac); + float wy[3]; + calcWeights(wy, offsetColFrac); + + // indices + int tx = threadIdx.x; + int ty = threadIdx.y; + int bx = blockIdx.x; + int by = blockIdx.y; + int gx = tx + bx * BlockX; + int gy = ty + by * BlockY; + int gx_old = gx - offsetRowInt; + int gy_old = gy - offsetColInt; + + // items index is blockIdx.z + // we just advance the data + int item = blockIdx.z; + in += item * rows * columns; + out += item * rows * columns; + + __shared__ float2 shr[BlockX + 2][BlockY + 2]; + + // read top Halo + if (tx == 0) + { + if (gx_old - 1 >= 0 && gx_old - 1 < rows && gy_old >= 0 && gy_old < columns) + { + ascomplex(shr[0][ty + 1]) = in[(gx_old - 1) * columns + gy_old]; + } + else + { + ascomplex(shr[0][ty + 1]) = complex(); + } + } + // read bottom Halo + if (tx == BlockX - 1) + { + if (gx_old + 1 >= 0 && gx_old + 1 < rows && gy_old >= 0 && gy_old < columns) + { + ascomplex(shr[BlockX + 1][ty + 1]) = in[(gx_old + 1) * columns + gy_old]; + } + else + { + ascomplex(shr[BlockX + 1][ty + 1]) = complex(); + } + } + // read left Halo + if (ty == 0) + { + if (gx_old >= 0 && gx_old < rows && gy_old - 1 >= 0 && gy_old - 1 < columns) + { + ascomplex(shr[tx + 1][0]) = in[gx_old * columns + gy_old - 1]; + } + else + { + ascomplex(shr[tx + 1][0]) = complex(); + } + } + // read right Halo + if (ty == BlockY - 1) + { + if (gx_old >= 0 && gx_old < rows && gy_old + 1 >= 0 && gy_old + 1 < columns) + { + ascomplex(shr[tx + 1][BlockY + 1]) = in[gx_old * columns + gy_old + 1]; + } + else + { + ascomplex(shr[tx + 1][BlockY + 1]) = complex(); + } + } + // read the rest + if (gx_old >= 0 && gx_old < rows && gy_old >= 0 && gy_old < columns) + { + ascomplex(shr[tx + 1][ty + 1]) = in[gx_old * columns + gy_old]; + } + else + { + ascomplex(shr[tx + 1][ty + 1]) = complex(); + } + + // now we have a block + halos in shared memory - do the interpolation + __syncthreads(); + + // interpolate rows in x + __shared__ float2 shry[BlockX][BlockY + 2]; + + ascomplex(shry[tx][ty + 1]) = wx[0] * ascomplex(shr[tx][ty + 1]) + + wx[1] * ascomplex(shr[tx + 1][ty + 1]) + + wx[2] * ascomplex(shr[tx + 2][ty + 1]); + if (ty == 0) + { + ascomplex(shry[tx][0]) = wx[0] * ascomplex(shr[tx][0]) + + wx[1] * ascomplex(shr[tx + 1][0]) + + wx[2] * ascomplex(shr[tx + 2][0]); + } + if (ty == BlockY - 1) + { + ascomplex(shry[tx][BlockY + 1]) = + wx[0] * ascomplex(shr[tx][BlockY + 1]) + + wx[1] * ascomplex(shr[tx + 1][BlockY + 1]) + + wx[2] * ascomplex(shr[tx + 2][BlockY + 1]); + } + + __syncthreads(); + + if (gx >= columns || gy >= rows) + { + return; + } + + auto intv = wy[0] * ascomplex(shry[tx][ty]) + + wy[1] * ascomplex(shry[tx][ty + 1]) + + wy[2] * ascomplex(shry[tx][ty + 2]); + + // write back + + // if the point lies outside of the original frame and we're shifting in + // that direction, it gets a zero value in any case + // otherwise we take the interpolated value + bool rightzero = offsetColFrac < 0.0f; + bool leftzero = offsetColFrac > 0.0f; + bool topzero = offsetRowFrac > 0.0f; + bool bottomzero = offsetRowFrac < 0.0f; + if ((gx_old == 0 && topzero) || (gx_old == rows - 1 && bottomzero) || + (gy_old == 0 && leftzero) || (gy_old == columns - 1 && rightzero)) + { + out[gx * columns + gy] = complex(); + } + else + { + out[gx * columns + gy] = intv; + } +} + +/** this kernel is not working and shouldn't be used. It's also not optimised at + * all. */ +template +__global__ void spline_interpolate_x(const complex* in, + complex* out, + int rows, + int columns, + float offsetRowFrac, + float offsetColFrac) +{ + int tx = threadIdx.x + blockIdx.x * BlockX; + int ty = threadIdx.y + blockIdx.y * BlockY; + if (tx >= rows || ty >= columns) + return; + + float w0, w1, w2, w3; + bspline_weights(offsetRowFrac, w0, w1, w2, w3); + int gid = tx * columns + ty; + + auto x_0 = tx > 1 ? in[gid - 2 * columns] : complex(); + auto x_1 = tx > 0 ? in[gid - columns] : complex(); + auto x_2 = in[gid]; + auto x_3 = tx < rows - 1 ? in[gid + 1 * columns] : complex(); + + out[gid] = w3 * x_0 + w2 * x_1 + w1 * x_2 + w0 * x_3; +} + +/** this kernel is not working and shouldn't be used. It's also not optimised at + * all. */ +template +__global__ void spline_interpolate_y(const complex* in, + complex* out, + int rows, + int columns, + float offsetRowFrac, + float offsetColFrac) +{ + int tx = threadIdx.x + blockIdx.x * BlockX; + int ty = threadIdx.y + blockIdx.y * BlockY; + if (tx >= rows || ty >= columns) + return; + + float w0, w1, w2, w3; + bspline_weights(offsetColFrac, w0, w1, w2, w3); + + int gid = tx * columns + ty; + + auto y_0 = ty > 1 ? in[gid - 2] : complex(); + auto y_1 = ty > 0 ? in[gid - 1] : complex(); + auto y_2 = in[gid]; + auto y_3 = ty < columns - 1 ? in[gid + 1] : complex(); + + out[gid] = w3 * y_0 + w2 * y_1 + w1 * y_2 + w0 * y_3; +} + +/********* class implementation *******/ + +InterpolatedShift::InterpolatedShift() : CudaFunction("interpolated_shift") {} + +void InterpolatedShift::setParameters(int items, int rows, int columns) +{ + items_ = items; + rows_ = rows; + columns_ = columns; +} + +void InterpolatedShift::setDeviceBuffers(complex* d_in, + complex* d_out) +{ + d_in_ = d_in; + d_out_ = d_out; +} + +void InterpolatedShift::allocate() +{ + ScopedTimer t(this, "allocate"); + d_in_.allocate(items_ * rows_ * columns_); + d_out_.allocate(items_ * rows_ * columns_); +} + +void InterpolatedShift::transfer_in(const complex* in) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_in_.get(), in, items_ * rows_ * columns_); +} + +void InterpolatedShift::run(float offsetRow, float offsetColumn, bool do_linear) +{ + ScopedTimer t(this, "run"); + + dim3 threadsPerBlock = {32u, 32u, 1u}; + dim3 blocks = {unsigned((rows_ + 31) / 32), + unsigned((columns_ + 31) / 32), + unsigned(items_)}; + + // get fractional and integer parts + auto offsetRowInt = int(offsetRow); + auto offsetColInt = int(offsetColumn); + auto offsetRowFrac = offsetRow - int(offsetRow); + auto offsetColFrac = offsetColumn - int(offsetColumn); + + if (std::abs(offsetRowFrac) < 1e-6f && std::abs(offsetColFrac) < 1e-6f) + { + if (offsetRowInt == 0 && offsetColInt == 0) + { + // no transformation at all + gpu_memcpy_d2d(d_out_.get(), d_in_.get(), items_ * rows_ * columns_); + } + else + { + // no fractional part, so we can just use a shifted copy + integer_shift_kernel<32, 32> + <<>>(d_in_.get(), + d_out_.get(), + rows_, + columns_, + int(offsetRow), + int(offsetColumn)); + checkLaunchErrors(); + } + } + else + { + if (do_linear) + { + linear_interpolate_kernel<32, 32><<>>( + d_in_.get(), d_out_.get(), rows_, columns_, offsetRow, offsetColumn); + checkLaunchErrors(); + } + else + { + // bicubic + // this version has not been adapted for 3D yet + + // first, prefilter the data for cubic splines + // Note: this prefilter does not match the scipy version completely + // !!! IMPORTANT: this modifies the data in-place + CubicBSplinePrefilter2D( + d_in_.get(), columns_ * sizeof(complex), columns_, rows_); + checkLaunchErrors(); + + // then interpolate in x and y directions + // Note: these kernels are not working yet + // and the buffers should be modified to avoid the final copy and to + // avoid in-place operations as inputs might be re-used (?) + spline_interpolate_y<32, 32><<>>( + d_in_.get(), d_out_.get(), rows_, columns_, offsetRow, offsetColumn); + checkLaunchErrors(); + spline_interpolate_x<32, 32><<>>( + d_out_.get(), d_in_.get(), rows_, columns_, offsetRow, offsetColumn); + checkLaunchErrors(); + + // make sure result is in d_out_ + gpu_memcpy_d2d(d_in_.get(), d_out_.get(), rows_ * columns_); + } + } + + timing_sync(); +} + +void InterpolatedShift::transfer_out(complex* out) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(out, d_out_.get(), items_ * rows_ * columns_); +} + +/********* interface ************/ + +extern "C" void interpolated_shift_c(const float* f_in, + float* f_out, + int items, + int rows, + int columns, + float offsetRow, + float offsetCol, + int ido_linear) +{ + auto in = reinterpret_cast*>(f_in); + auto out = reinterpret_cast*>(f_out); + + auto is = gpuManager.get_cuda_function( + "interpolated_shift", items, rows, columns); + is->allocate(); + is->transfer_in(in); + is->run(offsetRow, offsetCol, ido_linear != 0); + is->transfer_out(out); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/interpolated_shift.h b/archive/cuda_extension/cuda/func/interpolated_shift.h new file mode 100644 index 000000000..b8dfdb980 --- /dev/null +++ b/archive/cuda_extension/cuda/func/interpolated_shift.h @@ -0,0 +1,30 @@ +#pragma once + +#include "utils/CudaFunction.h" +#include "utils/Memory.h" +#include "utils/Complex.h" + +/** Note: this function only does linear interpolation right so far. */ +class InterpolatedShift : public CudaFunction { +public: + InterpolatedShift(); + void setParameters(int items, int rows, int columns); + void setDeviceBuffers( + complex* d_in, + complex* d_out + ); + complex* getOutput() const { return d_out_.get(); } + void allocate(); + void transfer_in( + const complex* in + ); + void run(float offsetRow, float offsetColumn, bool do_linear=false); + void transfer_out( + complex* out + ); + +private: + DevicePtrWrapper> d_in_; + DevicePtrWrapper> d_out_; + int rows_ = 0, columns_ = 0, items_ = 0; +}; diff --git a/archive/cuda_extension/cuda/func/log_likelihood.cu b/archive/cuda_extension/cuda/func/log_likelihood.cu new file mode 100644 index 000000000..21c5876d1 --- /dev/null +++ b/archive/cuda_extension/cuda/func/log_likelihood.cu @@ -0,0 +1,269 @@ +#include "log_likelihood.h" + +#include "utils/GpuManager.h" +#include "utils/Memory.h" +#include "utils/ScopedTimer.h" + +#include +#include + +/*************** Kernels **********************/ + +__global__ void calc_LLError_kernel(const unsigned char *mask, + const float *LL, + const float *Idata, + const int *addr_info, + float *LLError, + int m, + int n, + const int *da_unique) +{ + // buffer to sum the matrices in shared memory + extern __shared__ float sumbuffer[]; + + int batch = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + int txy = tx * blockDim.y + ty; + sumbuffer[txy] = 0.0f; + + auto da = addr_info + da_unique[batch] * 3 * 5 + 9; + auto ma = da + 3; + + auto da0 = da[0]; + auto ma0 = ma[0]; + LL += da0 * m * n; + Idata += da0 * m * n; + mask += ma0 * m * n; + LLError += da0; + + for (int i = tx; i < m; i += blockDim.x) + { + for (int j = ty; j < n; j += blockDim.y) + { + auto vLL = LL[i * n + j]; + auto vIdata = Idata[i * n + j]; + auto vMask = mask[i * n + j]; + + auto m_by_LL_minus_Idata = vMask ? vLL - vIdata : 0.0f; + auto m_by_LL_minus_Idata_sqr = m_by_LL_minus_Idata * m_by_LL_minus_Idata; + + auto vIdata_p_1 = vIdata + 1.0f; + auto sumval = m_by_LL_minus_Idata_sqr / vIdata_p_1; + sumbuffer[txy] += sumval; + } + } + + // now add up sumbuffer in shared memory + __syncthreads(); + int nt = blockDim.x * blockDim.y; + int c = nt; + while (c > 1) + { + int half = c / 2; + if (txy < half) + { + sumbuffer[txy] += sumbuffer[c - txy - 1]; + } + __syncthreads(); + c = c - half; + } + + if (txy == 0) + { + auto v = sumbuffer[0] / float(n * m); + LLError[0] = v; + } +} + +/*************** Class implementation **********/ + +LogLikelihood::LogLikelihood() : CudaFunction("log_likelihood") {} + +void LogLikelihood::setParameters(int i, int m, int n, int addr_i, int Idata_i) +{ + i_ = i; + m_ = m; + n_ = n; + Idata_i_ = Idata_i; // size of mask as well + addr_i_ = addr_i; // this is same as I + + ffprop_ = gpuManager.get_cuda_function( + "loglikelihood.farfield_propagator", i, m, n); + abs2_ = gpuManager.get_cuda_function, float>>( + "loglikelihood.abs2", i * m * n); + sum2buffer_ = gpuManager.get_cuda_function>( + "loglikelihood.sum2buffer", i_, m, n, Idata_i_, m, n, addr_i, addr_i); + sum2buffer_->setAddrStride(5 * 3); +} + +void LogLikelihood::setDeviceBuffers(complex *d_probe_obj, + unsigned char *d_mask, + float *d_Idata, + complex *d_prefilter, + complex *d_postfilter, + int *d_addr_info, + float *d_out, + int *d_outidx, + int *d_startidx, + int *d_indices, + int outidx_size) +{ + d_probe_obj_ = d_probe_obj; + d_mask_ = d_mask; + d_Idata_ = d_Idata; + d_prefilter_ = d_prefilter; + d_postfilter_ = d_postfilter; + d_addr_info_ = d_addr_info; + d_out_ = d_out; + d_outidx_ = d_outidx; + d_startidx_ = d_startidx; + d_indices_ = d_indices; + outidx_size_ = outidx_size; +} + +int LogLikelihood::calculateAddrIndices(const int *out1_addr) +{ + outidx_size_ = sum2buffer_->calculateAddrIndices(out1_addr); + return outidx_size_; +} + +void LogLikelihood::calculateUniqueDaIndices(const int *da_addr) +{ + std::vector unique; + unique.reserve(addr_i_); + std::set values; + + for (auto i = 0; i < addr_i_; ++i) + { + if (values.insert(da_addr[i * 15]).second) + unique.push_back(i); + } + + // for (auto i : unique) { + // std::cout << i << std::endl; + //} + + d_da_unique_.allocate(unique.size()); + gpu_memcpy_h2d(d_da_unique_.get(), unique.data(), unique.size()); +} + +void LogLikelihood::allocate() +{ + ScopedTimer t(this, "allocate"); + d_probe_obj_.allocate(i_ * m_ * n_); + d_mask_.allocate(Idata_i_ * m_ * n_); + d_Idata_.allocate(Idata_i_ * m_ * n_); + d_prefilter_.allocate(m_ * n_); + d_postfilter_.allocate(m_ * n_); + d_addr_info_.allocate(addr_i_ * 5 * 3); + d_out_.allocate(Idata_i_); + d_LL_.allocate(Idata_i_ * m_ * n_); + d_ft_.allocate(i_ * m_ * n_); + d_abs2_ft_.allocate(i_ * m_ * n_); + + ffprop_->setDeviceBuffers( + d_probe_obj_.get(), d_ft_.get(), d_prefilter_.get(), d_postfilter_.get()); + ffprop_->allocate(); + + abs2_->setDeviceBuffers(d_ft_.get(), d_abs2_ft_.get()); + abs2_->allocate(); + + sum2buffer_->setDeviceBuffers(d_abs2_ft_.get(), + d_LL_.get(), + d_addr_info_.get() + 6, + d_addr_info_.get() + 9, + d_outidx_, + d_startidx_, + d_indices_, + outidx_size_); + sum2buffer_->allocate(); +} + +void LogLikelihood::updateErrorOutput(float *d_out) { d_out_ = d_out; } + +float *LogLikelihood::getOutput() const { return d_out_.get(); } + +void LogLikelihood::transfer_in(const complex *probe_obj, + const unsigned char *mask, + const float *Idata, + const complex *prefilter, + const complex *postfilter, + const int *addr_info) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_probe_obj_.get(), probe_obj, i_ * m_ * n_); + gpu_memcpy_h2d(d_mask_.get(), mask, Idata_i_ * m_ * n_); + gpu_memcpy_h2d(d_Idata_.get(), Idata, Idata_i_ * m_ * n_); + gpu_memcpy_h2d(d_prefilter_.get(), prefilter, m_ * n_); + gpu_memcpy_h2d(d_postfilter_.get(), postfilter, m_ * n_); + // TODO: handle this case more explicitly + if (!d_addr_info_.isExternal()) + { + gpu_memcpy_h2d(d_addr_info_.get(), addr_info, addr_i_ * 5 * 3); + } + + // transfer-in on sum_to_buffer needs to be called, for the internal + // outidx buffers + sum2buffer_->transfer_in(nullptr, nullptr, nullptr); + + calculateUniqueDaIndices(addr_info + 9); +} + +void LogLikelihood::transfer_out(float *out) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(out, d_out_.get(), Idata_i_); +} + +void LogLikelihood::run() +{ + ScopedTimer t(this, "run"); + ffprop_->run(true, true, true); + abs2_->run(); + sum2buffer_->run(); + + dim3 threadsPerBlock = {32u, 32u, 1u}; + dim3 blocks = {unsigned(d_da_unique_.size()), 1u, 1u}; + calc_LLError_kernel<<>>(d_mask_.get(), + d_LL_.get(), + d_Idata_.get(), + d_addr_info_.get(), + d_out_.get(), + m_, + n_, + d_da_unique_.get()); + checkLaunchErrors(); + + // sync device if timing is enabled + timing_sync(); +} + +extern "C" void log_likelihood_c(const float *fprobe_obj, + const unsigned char *mask, + const float *Idata, + const float *fprefilter, + const float *fpostfilter, + const int *addr_info, + float *out, + int i, + int m, + int n, + int addr_i, + int Idata_i) +{ + auto probe_obj = reinterpret_cast *>(fprobe_obj); + auto prefilter = reinterpret_cast *>(fprefilter); + auto postfilter = reinterpret_cast *>(fpostfilter); + + auto ll = gpuManager.get_cuda_function( + "loglikelihood", i, m, n, addr_i, Idata_i); + ll->calculateAddrIndices(addr_info + 9); + ll->allocate(); + ll->transfer_in(probe_obj, mask, Idata, prefilter, postfilter, addr_info); + ll->run(); + ll->transfer_out(out); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/log_likelihood.h b/archive/cuda_extension/cuda/func/log_likelihood.h new file mode 100644 index 000000000..83a30079e --- /dev/null +++ b/archive/cuda_extension/cuda/func/log_likelihood.h @@ -0,0 +1,67 @@ +#pragma once +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +#include "func/abs2.h" +#include "func/farfield_propagator.h" +#include "func/sum_to_buffer.h" + +class LogLikelihood : public CudaFunction +{ +public: + LogLikelihood(); + void setParameters(int i, int m, int n, int addr_i, int Idata_i); + + void setDeviceBuffers(complex *d_probe_obj, + unsigned char *d_mask, + float *d_Idata, + complex *d_prefilter, + complex *d_postfilter, + int *d_addr_info, + float *d_out, + int *d_outidx, + int *d_startidx, + int *d_indices, + int outidx_size); + int calculateAddrIndices(const int *out1_addr); + void calculateUniqueDaIndices(const int *da_addr); + void allocate(); + void updateErrorOutput(float *d_out); + float *getOutput() const; + void transfer_in(const complex *probe_obj, + const unsigned char *mask, + const float *Idata, + const complex *prefilter, + const complex *postfilter, + const int *addr_info); + void run(); + void transfer_out(float *out); + +private: + DevicePtrWrapper> d_probe_obj_; + DevicePtrWrapper d_mask_; + DevicePtrWrapper d_Idata_; + DevicePtrWrapper> d_prefilter_; + DevicePtrWrapper> d_postfilter_; + DevicePtrWrapper d_addr_info_; + DevicePtrWrapper d_out_; + DevicePtrWrapper d_LL_; + // internal buffer for intermediate results + DevicePtrWrapper> d_ft_; + DevicePtrWrapper d_abs2_ft_; + // these three are for bookkeeping between setDeviceBuffers and allocate + // so that they can be forwarded to sum2buffer + int *d_outidx_ = nullptr; + int *d_startidx_ = nullptr; + int *d_indices_ = nullptr; + int outidx_size_ = 0; + // unique indices for da + DevicePtrWrapper d_da_unique_; + + int i_ = 0, m_ = 0, n_ = 0, addr_i_ = 0; + int Idata_i_ = 0; + FarfieldPropagator *ffprop_ = nullptr; + Abs2, float> *abs2_ = nullptr; + SumToBuffer *sum2buffer_ = nullptr; +}; diff --git a/archive/cuda_extension/cuda/func/mass_center.cu b/archive/cuda_extension/cuda/func/mass_center.cu new file mode 100644 index 000000000..8de528d01 --- /dev/null +++ b/archive/cuda_extension/cuda/func/mass_center.cu @@ -0,0 +1,257 @@ +#include "mass_center.h" +#include "utils/FinalSumKernel.h" +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +#include +#include + +/************ kernels ***************/ + +template +__global__ void indexed_sum_middim( + const float* data, + float* sums, + int i, + int m, // dim we work on - 1 block per output + int n, + float scale) +{ + int bid = blockIdx.x; + int tid = threadIdx.x; + + data += bid * n; + + auto val = 0.0f; + for (int x = 0; x < i; ++x) + { + auto d_inner = data + x * n * m; + for (int z = tid; z < n; z += BlockX) + { + val += d_inner[z]; + } + } + + __shared__ float sumshr[BlockX]; + sumshr[tid] = val; + + __syncthreads(); + int c = BlockX; + while (c > 1) + { + int half = c / 2; + if (tid < half) + { + sumshr[tid] += sumshr[c - tid - 1]; + } + __syncthreads(); + c = c - half; + } + + if (tid == 0) + { + sums[bid] = sumshr[0] * float(bid) * scale; + } +} + +template +__global__ void indexed_sum_lastdim( + const float* data, float* sums, int n, int i, float scale) +{ + int ty = threadIdx.y + blockIdx.y * BlockY; + int tx = threadIdx.x; + + auto val = 0.0f; + if (ty < i) + { + data += ty; // column to work on + + // we collaborate along the x axis (columns) to get more threads in case i + // is small + for (int r = tx; r < n; r += BlockX) + { + val += data[r * i]; + } + } + + // reduce along X dimension in shared memory (column sum) + __shared__ float blocksums[BlockX][BlockY]; + blocksums[tx][threadIdx.y] = val; + + __syncthreads(); + int nt = blockDim.x; + int c = nt; + while (c > 1) + { + int half = c / 2; + if (tx < half) + { + blocksums[tx][threadIdx.y] += blocksums[c - tx - 1][threadIdx.y]; + } + __syncthreads(); + c = c - half; + } + + if (ty >= i) + { + return; + } + + if (tx == 0) + { + sums[ty] = blocksums[0][threadIdx.y] * float(ty) * scale; + } +} + +template +__global__ void final_sums(const float* sum_i, + int i, + const float* sum_m, + int m, + const float* sum_n, + int n, + float* output) +{ + int bid = blockIdx.x; + int tid = threadIdx.x; + // each block works on a single dimension + int nn = bid == 0 ? i : (bid == 1 ? m : n); + const float* data = bid == 0 ? sum_i : (bid == 1 ? sum_m : sum_n); + + __shared__ float shared[BlockX]; + auto val = 0.0f; + for (int i = tid; i < nn; i += blockDim.x) + { + val += data[i]; + } + shared[tid] = val; + + // now add up sumbuffer in shared memory + __syncthreads(); + int nt = blockDim.x; + int c = nt; + while (c > 1) + { + int half = c / 2; + if (tid < half) + { + shared[tid] += shared[c - tid - 1]; + } + __syncthreads(); + c = c - half; + } + + if (tid == 0) + { + output[bid] = shared[0]; + } +} + +/************ class implementation ********/ + +MassCenter::MassCenter() : CudaFunction("mass_center") {} + +void MassCenter::setParameters(int i, int m, int n) +{ + i_ = i; + m_ = m; + n_ = n; +} + +void MassCenter::setDeviceBuffers(float* d_data, float* d_out) +{ + d_data_ = d_data; + d_out_ = d_out; +} + +void MassCenter::allocate() +{ + ScopedTimer t(this, "allocate"); + d_data_.allocate(i_ * m_ * n_); + d_i_sum_.allocate(i_); + d_m_sum_.allocate(m_); + d_n_sum_.allocate(n_); + d_out_.allocate(n_ > 1 ? 3 : 2); +} + +void MassCenter::transfer_in(const float* data) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_data_.get(), data, i_ * m_ * n_); +} + +void MassCenter::run() +{ + ScopedTimer t(this, "run"); + + const int threadsPerBlock = 256; + + // first, calculate the total sum of all entries (using thrust) + thrust::device_ptr raw(d_data_.get()); + auto total_sum = thrust::reduce(raw, raw + i_ * n_ * m_); + auto sc = 1.0f / total_sum; + + // sum all dims except the first, multiplying by the index and scaling factor + indexed_sum_middim<<>>( + d_data_.get(), d_i_sum_.get(), 1, i_, n_ * m_, sc); + checkLaunchErrors(); + + if (n_ > 2) + { + // 3d case + + // sum all dims, except the middle, multiplying by the index and scaling + // factor + indexed_sum_middim<<>>( + d_data_.get(), d_m_sum_.get(), i_, n_, m_, sc); + checkLaunchErrors(); + + // sum the all dims except the last, multiplying by the index and scaling + // factor + dim3 threads = {32u, 32u, 1u}; + dim3 blk = {1u, unsigned(n_ + 32 - 1) / 32u, 1u}; + indexed_sum_lastdim<32, 32> + <<>>(d_data_.get(), d_n_sum_.get(), i_ * m_, n_, sc); + checkLaunchErrors(); + } + else + { + // 2d case + + // sum the all dims except the last, multiplying by the index and scaling + // factor + dim3 threads = {32u, 32u, 1u}; + dim3 blk = {1u, unsigned(m_ + 32 - 1) / 32u, 1u}; + indexed_sum_lastdim<32, 32> + <<>>(d_data_.get(), d_m_sum_.get(), i_, m_, sc); + checkLaunchErrors(); + } + + // summing for final results (TODO:: can we combine these?) + final_sums<256><< 1 ? 3 : 2, 256>>> (d_i_sum_.get(), + i_, + d_m_sum_.get(), + m_, + d_n_sum_.get(), + n_, + d_out_.get()); + checkLaunchErrors(); +} + +void MassCenter::transfer_out(float* out) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(out, d_out_.get(), n_ > 1 ? 3 : 2); +} + +/************ interface *******************/ + +extern "C" void mass_center_c( + const float* data, int i, int m, int n, float* output) +{ + auto mc = gpuManager.get_cuda_function("mass_center", i, m, n); + mc->allocate(); + mc->transfer_in(data); + mc->run(); + mc->transfer_out(output); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/mass_center.h b/archive/cuda_extension/cuda/func/mass_center.h new file mode 100644 index 000000000..458a4491c --- /dev/null +++ b/archive/cuda_extension/cuda/func/mass_center.h @@ -0,0 +1,21 @@ +#pragma once +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +class MassCenter : public CudaFunction +{ +public: + MassCenter(); + void setParameters(int i, int m, int n = 1); + void setDeviceBuffers(float* d_data, float* d_out); + void allocate(); + void transfer_in(const float* data); + void run(); + void transfer_out(float* out); + +private: + DevicePtrWrapper d_data_; + DevicePtrWrapper d_i_sum_, d_m_sum_, d_n_sum_; + DevicePtrWrapper d_out_; + int i_ = 0, m_ = 0, n_ = 0; +}; \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/norm2.cu b/archive/cuda_extension/cuda/func/norm2.cu new file mode 100644 index 000000000..06e6ad943 --- /dev/null +++ b/archive/cuda_extension/cuda/func/norm2.cu @@ -0,0 +1,160 @@ + +#include "norm2.h" +#include "utils/Complex.h" +#include "utils/FinalSumKernel.h" +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +#include +#include + +/************ Kernels ***************/ + +__device__ inline float dev_abs2(float x) { return x * x; } +__device__ inline float dev_abs2(complex x) +{ + return x.real() * x.real() + x.imag() * x.imag(); +} + +template +__global__ void norm2_kernel(const T* input, float* output, int size) +{ + int gid = threadIdx.x + blockIdx.x * blockDim.x; + int tid = threadIdx.x; + extern __shared__ float sum[]; + + using std::abs; + + if (gid < size) + { + sum[tid] = dev_abs2(input[gid]); + } + else + { + sum[tid] = 0.0f; + } + + // now add up sumbuffer in shared memory + __syncthreads(); + int nt = blockDim.x; + int c = nt; + while (c > 1) + { + int half = c / 2; + if (tid < half) + { + sum[tid] += sum[c - tid - 1]; + } + __syncthreads(); + c = c - half; + } + + if (tid == 0) + { + output[blockIdx.x] = sum[0]; + } +} + +/************ Class implementation **********/ + +template +Norm2::Norm2() : CudaFunction("norm2") +{ +} + +template +void Norm2::setParameters(int size) +{ + size_ = size; + numblocks_ = (size + BLOCK_SIZE - 1) / BLOCK_SIZE; +} + +template +void Norm2::setDeviceBuffers(T* d_input, float* d_output) +{ + d_input_ = d_input; + d_output_ = d_output; +} + +template +void Norm2::allocate() +{ + ScopedTimer t(this, "allocate"); + d_input_.allocate(size_); + if (numblocks_ > 1) + { + d_intermediate_.allocate(numblocks_); + } + d_output_.allocate(1); +} + +template +float* Norm2::getOutput() const +{ + return d_output_.get(); +} + +template +void Norm2::transfer_in(const T* input) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_input_.get(), input, size_); +} + +template +void Norm2::run() +{ + ScopedTimer t(this, "run"); + if (numblocks_ == 1) + { + norm2_kernel<<>>( + d_input_.get(), d_output_.get(), size_); + } + else + { + norm2_kernel<<>>( + d_input_.get(), d_intermediate_.get(), size_); + // now we have one output per block, so a final kernel is needed + int nthreads = numblocks_; + if (nthreads > 1024) + nthreads = 1024; + final_sum<<<1, nthreads, nthreads * sizeof(float)>>>( + d_intermediate_.get(), d_output_.get(), numblocks_); + } + timing_sync(); +} + +template +void Norm2::transfer_out(float* output) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(output, d_output_.get(), 1); +} + +/*********** interface function *************/ + +template +void norm2_tc(const T* data, float* out, int size) +{ + auto n2 = gpuManager.get_cuda_function>( + "norm2<" + getTypeName() + ">", size); + n2->allocate(); + n2->transfer_in(data); + n2->run(); + n2->transfer_out(out); +} + +template class Norm2; +template class Norm2>; + +extern "C" void norm2_c(const float* data, float* out, int size, int isComplex) +{ + if (isComplex != 0) + { + norm2_tc(reinterpret_cast*>(data), out, size); + } + else + { + norm2_tc(data, out, size); + } +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/norm2.h b/archive/cuda_extension/cuda/func/norm2.h new file mode 100644 index 000000000..da244b8e7 --- /dev/null +++ b/archive/cuda_extension/cuda/func/norm2.h @@ -0,0 +1,26 @@ +#pragma once + +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +template +class Norm2 : public CudaFunction +{ +public: + Norm2(); + void setParameters(int size); + void setDeviceBuffers(T* d_input, float* d_output); + void allocate(); + float* getOutput() const; + void transfer_in(const T* input); + void run(); + void transfer_out(float* output); + +private: + static const int BLOCK_SIZE = 1024; + DevicePtrWrapper d_input_; + DevicePtrWrapper d_intermediate_; + DevicePtrWrapper d_output_; + int size_ = 0; + int numblocks_ = 0; +}; \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/realspace_error.cu b/archive/cuda_extension/cuda/func/realspace_error.cu new file mode 100644 index 000000000..2435a6e32 --- /dev/null +++ b/archive/cuda_extension/cuda/func/realspace_error.cu @@ -0,0 +1,160 @@ +#include "realspace_error.h" + +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +/*************** kernels **********************/ + +__global__ void realspace_error_kernel(const complex *difference, + const int *ea_first_column, + const int *da_first_column, + int addr_stride, + float *out, + int m, + int n) +{ + int bid = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + int txy = tx * blockDim.y + ty; + + extern __shared__ float sum[]; + sum[txy] = 0.0; + + int eaidx = ea_first_column[bid * addr_stride]; + int daidx = da_first_column[bid * addr_stride]; + + for (int i = tx; i < m; i += blockDim.x) + { + for (int j = ty; j < n; j += blockDim.y) + { + auto idx = eaidx * m * n + i * n + j; + auto v = difference[idx]; + auto abs2 = v.real() * v.real() + v.imag() * v.imag(); + sum[txy] += abs2; + } + } + + __syncthreads(); + int nt = blockDim.x * blockDim.y; + int c = nt; + while (c > 1) + { + int half = c / 2; + if (txy < half) + { + sum[txy] += sum[c - txy - 1]; + } + __syncthreads(); + c = c - half; + } + + if (txy == 0) + { + auto eaerror = sum[0] / float(m * n); + atomicAdd(&out[daidx], eaerror); + } +} + +/*************** class implementation ***************/ + +RealspaceError::RealspaceError() : CudaFunction("realspace_error") {} + +void RealspaceError::setParameters( + int i, int m, int n, int addr_len, int outlen) +{ + i_ = i; + m_ = m; + n_ = n; + addr_len_ = addr_len; + outlen_ = outlen; +} + +void RealspaceError::setAddrStride(int stride) { addr_stride_ = stride; } + +void RealspaceError::setDeviceBuffers(complex *d_difference, + int *d_ea_first_column, + int *d_da_first_column, + float *d_out) +{ + d_difference_ = d_difference; + d_ea_first_column_ = d_ea_first_column; + d_da_first_column_ = d_da_first_column; + d_out_ = d_out; +} + +void RealspaceError::allocate() +{ + ScopedTimer t(this, "allocate"); + d_difference_.allocate(i_ * m_ * n_); + d_ea_first_column_.allocate(addr_len_ * addr_stride_); + d_da_first_column_.allocate(addr_len_ * addr_stride_); + d_out_.allocate(outlen_); +} + +void RealspaceError::updateErrorOutput(float *d_out) +{ + d_out_ = d_out; +} + +void RealspaceError::transfer_in(const complex *difference, + const int *ea_first_column, + const int *da_first_column) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_difference_.get(), difference, i_ * n_ * m_); + gpu_memcpy_h2d( + d_ea_first_column_.get(), ea_first_column, addr_len_ * addr_stride_); + gpu_memcpy_h2d( + d_da_first_column_.get(), da_first_column, addr_len_ * addr_stride_); +} + +void RealspaceError::run() +{ + ScopedTimer t(this, "run"); + + checkCudaErrors(cudaMemset(d_out_.get(), 0, outlen_ * sizeof(*d_out_.get()))); + + // always use a 32x32 block of threads + dim3 threadsPerBlock = {32u, 32u, 1u}; + dim3 blocks = {unsigned(addr_len_), 1u, 1u}; + realspace_error_kernel<<>>( + d_difference_.get(), + d_ea_first_column_.get(), + d_da_first_column_.get(), + addr_stride_, + d_out_.get(), + m_, + n_); + checkLaunchErrors(); + + timing_sync(); +} + +void RealspaceError::transfer_out(float *out) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(out, d_out_.get(), outlen_); +} + +/************** interface function ***************/ + +extern "C" void realspace_error_c(const float *difference, + const int *ea_first_column, + const int *da_first_column, + int addr_len, + float *out, + int i, + int m, + int n, + int outlen) +{ + auto rse = gpuManager.get_cuda_function( + "realspace_error", i, m, n, addr_len, outlen); + rse->allocate(); + rse->transfer_in(reinterpret_cast *>(difference), + ea_first_column, + da_first_column); + rse->run(); + rse->transfer_out(out); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/realspace_error.h b/archive/cuda_extension/cuda/func/realspace_error.h new file mode 100644 index 000000000..ca2b59acc --- /dev/null +++ b/archive/cuda_extension/cuda/func/realspace_error.h @@ -0,0 +1,31 @@ +#pragma once +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +class RealspaceError : public CudaFunction +{ +public: + RealspaceError(); + void setParameters(int i, int m, int n, int addr_len, int outlen); + void setAddrStride(int addr_stride); + void setDeviceBuffers(complex* d_difference, + int* d_ea_first_column, + int* d_da_first_column, + float* d_out); + void allocate(); + void updateErrorOutput(float* d_out); + void transfer_in(const complex* difference, + const int* ea_first_column, + const int* da_first_column); + void run(); + void transfer_out(float* out); + +private: + DevicePtrWrapper> d_difference_; + DevicePtrWrapper d_ea_first_column_; + DevicePtrWrapper d_da_first_column_; + DevicePtrWrapper d_out_; + int i_ = 0, m_ = 0, n_ = 0, addr_len_ = 0, outlen_ = 0; + int addr_stride_ = 1; +}; diff --git a/archive/cuda_extension/cuda/func/renormalise_fourier_magnitudes.cu b/archive/cuda_extension/cuda/func/renormalise_fourier_magnitudes.cu new file mode 100644 index 000000000..7e66f36ae --- /dev/null +++ b/archive/cuda_extension/cuda/func/renormalise_fourier_magnitudes.cu @@ -0,0 +1,229 @@ +#include "renormalise_fourier_magnitudes.h" + +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +#include +#include +#include + +/********** kernels *****************/ + +// template, to switch between pbound and not at compile-time +template +__global__ void renormalise_fourier_magnitudes_kernel(const complex *f, + const float *af, + const float *fmag, + const unsigned char *mask, + const float *err_fmag, + const int *addr_info, + complex *out, + float pbound, + int A, + int B) +{ + using std::sqrt; + + int batch = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + + auto ea = addr_info + batch * 3 * 5 + 2 * 3; + auto da = ea + 3; + auto ma = da + 3; + + auto ea_0 = ea[0]; + auto ea_1 = 0; + auto ea_2 = 0; + + auto da_0 = da[0]; + auto da_1 = 0; + auto da_2 = 0; + + auto ma_0 = ma[0]; + auto ma_1 = 0; + auto ma_2 = 0; + + for (int i = tx; i < A; i += blockDim.x) + { + for (int j = ty; j < B; j += blockDim.y) + { + auto maidx = ma_0 * A * B + (ma_1 + i) * B + (ma_2 + j); + auto eaidx = ea_0 * A * B + (ea_1 + i) * B + (ea_2 + j); + auto daidx = da_0 * A * B + (da_1 + i) * B + (da_2 + j); + + auto m = mask[maidx]; + auto magnitudes = fmag[daidx]; + auto absolute_magnitudes = af[daidx]; + auto fourier_space_solution = f[eaidx]; + auto fourier_error = err_fmag[da_0]; + + if (!usePbound) + { + auto fm = m ? magnitudes / (absolute_magnitudes + 1e-10f) : 1.0f; + auto v = fm * fourier_space_solution; + out[eaidx] = v; + } + else if (fourier_error > pbound) + { + // power bound is applied + auto fdev = absolute_magnitudes - magnitudes; + auto renorm = sqrt(pbound / fourier_error); + auto fm = + m ? (magnitudes + fdev * renorm) / (absolute_magnitudes + 1e-10f) + : 1.0f; + out[eaidx] = fm * fourier_space_solution; + } + else + { + out[eaidx] = 0.0f; + } + } + } +} + +/********** class implementation ********/ + +RenormaliseFourierMagnitudes::RenormaliseFourierMagnitudes() + : CudaFunction("renormalise_fourier_magnitudes") +{ +} + +void RenormaliseFourierMagnitudes::setParameters(int M, int N, int A, int B) +{ + M_ = M; + N_ = N; + A_ = A; + B_ = B; +} + +void RenormaliseFourierMagnitudes::setDeviceBuffers(complex *d_f, + float *d_af, + float *d_fmag, + unsigned char *d_mask, + float *d_err_fmag, + int *d_addr_info, + complex *d_out) +{ + d_f_ = d_f; + d_af_ = d_af; + d_fmag_ = d_fmag; + d_mask_ = d_mask; + d_err_fmag_ = d_err_fmag; + d_addr_info_ = d_addr_info; + d_out_ = d_out; +} + +void RenormaliseFourierMagnitudes::allocate() +{ + ScopedTimer t(this, "allocate"); + d_f_.allocate(M_ * A_ * B_); + d_af_.allocate(N_ * A_ * B_); + d_fmag_.allocate(N_ * A_ * B_); + d_mask_.allocate(N_ * A_ * B_); + d_err_fmag_.allocate(N_); + d_addr_info_.allocate(M_ * 5 * 3); + d_out_.allocate(M_ * A_ * B_); +} + +void RenormaliseFourierMagnitudes::updateErrorInput(float *d_err_fmag) +{ + d_err_fmag_ = d_err_fmag; +} + +complex *RenormaliseFourierMagnitudes::getOutput() const +{ + return d_out_.get(); +} + +void RenormaliseFourierMagnitudes::transfer_in(const complex *f, + const float *af, + const float *fmag, + const unsigned char *mask, + const float *err_fmag, + const int *addr_info) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_f_.get(), f, M_ * A_ * B_); + gpu_memcpy_h2d(d_af_.get(), af, N_ * A_ * B_); + gpu_memcpy_h2d(d_fmag_.get(), fmag, N_ * A_ * B_); + gpu_memcpy_h2d(d_mask_.get(), mask, N_ * A_ * B_); + gpu_memcpy_h2d(d_err_fmag_.get(), err_fmag, N_); + gpu_memcpy_h2d(d_addr_info_.get(), addr_info, M_ * 5 * 3); +} + +void RenormaliseFourierMagnitudes::run(float pbound, bool usePbound) +{ + ScopedTimer t(this, "run"); + + // always use a 32x32 block of threads + dim3 threadsPerBlock = {32, 32, 1u}; + dim3 blocks = {unsigned(M_), 1u, 1u}; + + if (usePbound) + { + renormalise_fourier_magnitudes_kernel + <<>>(d_f_.get(), + d_af_.get(), + d_fmag_.get(), + d_mask_.get(), + d_err_fmag_.get(), + d_addr_info_.get(), + d_out_.get(), + pbound, + A_, + B_); + checkLaunchErrors(); + } + else + { + renormalise_fourier_magnitudes_kernel + <<>>(d_f_.get(), + d_af_.get(), + d_fmag_.get(), + d_mask_.get(), + d_err_fmag_.get(), + d_addr_info_.get(), + d_out_.get(), + pbound, + A_, + B_); + checkLaunchErrors(); + } + + timing_sync(); +} + +void RenormaliseFourierMagnitudes::transfer_out(complex *out) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(out, d_out_.get(), M_ * A_ * B_); +} + +/********* interface function *********/ + +extern "C" void renormalise_fourier_magnitudes_c( + const float *f_f, // M x A x B + const float *af, // N x A x B + const float *fmag, // N x A x B + const unsigned char *mask, // N x A x B + const float *err_fmag, // N + const int *addr_info, // M x 5 x 3 + float pbound, + float *f_out, // M x A x B + int M, + int N, + int A, + int B, + int usePbound) +{ + auto f = reinterpret_cast *>(f_f); + auto out = reinterpret_cast *>(f_out); + + auto rfm = gpuManager.get_cuda_function( + "renormalise_fourier_magnitudes", M, N, A, B); + rfm->allocate(); + rfm->transfer_in(f, af, fmag, mask, err_fmag, addr_info); + rfm->run(pbound, usePbound != 0); + rfm->transfer_out(out); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/renormalise_fourier_magnitudes.h b/archive/cuda_extension/cuda/func/renormalise_fourier_magnitudes.h new file mode 100644 index 000000000..50ad5a910 --- /dev/null +++ b/archive/cuda_extension/cuda/func/renormalise_fourier_magnitudes.h @@ -0,0 +1,40 @@ +#pragma once + +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +class RenormaliseFourierMagnitudes : public CudaFunction +{ +public: + RenormaliseFourierMagnitudes(); + void setParameters(int M, int N, int A, int B); + void setDeviceBuffers(complex *d_f, + float *d_af, + float *d_fmag, + unsigned char *d_mask, + float *d_err_fmag, + int *d_addr_info, + complex *d_out); + void allocate(); + void updateErrorInput(float* d_err_fmag); + complex *getOutput() const; + void transfer_in(const complex *f, + const float *af, + const float *fmag, + const unsigned char *mask, + const float *err_fmag, + const int *addr_info); + void run(float pbound = 0.0, bool usePbound = false); + void transfer_out(complex *out); + +private: + DevicePtrWrapper> d_f_; // M x A x B + DevicePtrWrapper d_af_; // M x A x B + DevicePtrWrapper d_fmag_; // N x A x B + DevicePtrWrapper d_mask_; // N x A X B + DevicePtrWrapper d_err_fmag_; // N + DevicePtrWrapper d_addr_info_; // M x 5 x 3 + DevicePtrWrapper> d_out_; // M x A x B + int M_ = 0, N_ = 0, A_ = 0, B_= 0; +}; \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/scan_and_multiply.cu b/archive/cuda_extension/cuda/func/scan_and_multiply.cu new file mode 100644 index 000000000..40867fe93 --- /dev/null +++ b/archive/cuda_extension/cuda/func/scan_and_multiply.cu @@ -0,0 +1,194 @@ +#include "scan_and_multiply.h" + +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +#include + +/*********** Kernels ******************/ + +template +__global__ void scan_and_multiply_kernel( + complex *out, + const int *addr_info, // note: __restrict__ (texture cache) makes it slower + const complex *probe, + const complex *obj, + int probe_m, + int probe_n, + int obj_m, + int obj_n, + int m, + int n) +{ + int batch = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + + // each of these are 3-d arrays with indices + auto pa = addr_info + batch * 3 * 5; + auto oa = pa + 3; + auto ea = pa + 6; + + // these are the start indices for the batch item - m x n array from here + // probe start + auto p_i0 = pa[0]; + auto p_i1 = pa[1]; + auto p_i2 = pa[2]; + + // obj start + auto o_i0 = oa[0]; + auto o_i1 = oa[1]; + auto o_i2 = oa[2]; + + // output start + auto po_i0 = ea[0]; + + auto ooffset = o_i0 * obj_m * obj_n + o_i1 * obj_n + o_i2; + auto poffset = p_i0 * probe_m * probe_n + p_i1 * probe_n + p_i2; + auto pooffset = po_i0 * m * n; + +// let each thread jump by blockDim.x / y, so a 32x32 thread block works on +// any shape of m x n data +#pragma unroll(2) + for (int i = tx; i < m; i += BlockX) + { +#pragma unroll(1) + for (int j = ty; j < n; j += BlockY) + { + auto oidx = ooffset + i * obj_n + j; + auto pidx = poffset + i * probe_n + j; + auto poidx = pooffset + i * n + j; + + out[poidx] = probe[pidx] * obj[oidx]; + } + } +} + +/*********** Class implementation *****************/ + +ScanAndMultiply::ScanAndMultiply() : CudaFunction("scan_and_multiply") {} + +void ScanAndMultiply::setParameters(int batch_size, + int m, + int n, + int probe_i, + int probe_m, + int probe_n, + int obj_i, + int obj_m, + int obj_n, + int addr_len) +{ + batch_size_ = batch_size; + m_ = m; + n_ = n; + probe_i_ = probe_i; + probe_m_ = probe_m; + probe_n_ = probe_n; + obj_i_ = obj_i; + obj_m_ = obj_m; + obj_n_ = obj_n; + addr_len_ = addr_len; +} + +void ScanAndMultiply::setDeviceBuffers(complex *d_probe, + complex *d_obj, + int *d_addr_info, + complex *d_out) +{ + d_probe_ = d_probe; + d_obj_ = d_obj; + d_addr_info_ = d_addr_info; + d_out_ = d_out; +} + +void ScanAndMultiply::allocate() +{ + ScopedTimer t(this, "allocate"); + d_out_.allocate(batch_size_ * m_ * n_); + d_addr_info_.allocate(addr_len_ * 5 * 3); + d_probe_.allocate(probe_i_ * probe_m_ * probe_n_); + d_obj_.allocate(obj_i_ * obj_m_ * obj_n_); +} + +complex *ScanAndMultiply::getOutput() const { return d_out_.get(); } + +void ScanAndMultiply::transfer_in(const complex *probe, + const complex *obj, + const int *addr_info) +{ + ScopedTimer t(this, "transfer in"); + gpu_memcpy_h2d(d_probe_.get(), probe, probe_i_ * probe_m_ * probe_n_); + gpu_memcpy_h2d(d_obj_.get(), obj, obj_i_ * obj_m_ * obj_n_); + gpu_memcpy_h2d(d_addr_info_.get(), addr_info, addr_len_ * 5 * 3); +} + +void ScanAndMultiply::transfer_out(complex *out) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(out, d_out_.get(), batch_size_ * m_ * n_); +} + +void ScanAndMultiply::run() +{ + ScopedTimer t(this, "run"); + checkCudaErrors(cudaMemset( + d_out_.get(), 0, batch_size_ * m_ * n_ * sizeof(complex))); + // always use a 32x32 block of threads + dim3 threadsPerBlock = {32, 32, 1u}; + dim3 blocks = {unsigned(addr_len_), 1u, 1u}; + + scan_and_multiply_kernel<32, 32> + <<>>(d_out_.get(), + d_addr_info_.get(), + d_probe_.get(), + d_obj_.get(), + probe_m_, + probe_n_, + obj_m_, + obj_n_, + m_, + n_); + checkLaunchErrors(); + + // sync device if timing is enabled + timing_sync(); +} + +/******* Interface function **********/ + +extern "C" void scan_and_multiply_c(const float *fprobe, + int probe_i, + int probe_m, + int probe_n, + const float *fobj, + int obj_i, + int obj_m, + int obj_n, + const int *addr_info, + int addr_len, + int batch_size, + int m, + int n, + float *fout) +{ + auto probe = reinterpret_cast *>(fprobe); + auto obj = reinterpret_cast *>(fobj); + auto out = reinterpret_cast *>(fout); + + auto sam = gpuManager.get_cuda_function("scan_and_multiply", + batch_size, + m, + n, + probe_i, + probe_m, + probe_n, + obj_i, + obj_m, + obj_n, + addr_len); + sam->allocate(); + sam->transfer_in(probe, obj, addr_info); + sam->run(); + sam->transfer_out(out); +} diff --git a/archive/cuda_extension/cuda/func/scan_and_multiply.h b/archive/cuda_extension/cuda/func/scan_and_multiply.h new file mode 100644 index 000000000..0d6cf2f9f --- /dev/null +++ b/archive/cuda_extension/cuda/func/scan_and_multiply.h @@ -0,0 +1,46 @@ +#pragma once + +#include "utils/Complex.h" +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +class ScanAndMultiply : public CudaFunction +{ +public: + ScanAndMultiply(); + void setParameters(int batch_size, + int m, + int n, + int probe_i, + int probe_m, + int probe_n, + int obj_i, + int obj_m, + int obj_n, + int addr_len); + + void setDeviceBuffers(complex *d_probe, + complex *d_obj, + int *d_addr_info, + complex *d_out); + void allocate(); + complex *getOutput() const; + void transfer_in(const complex *probe, + const complex *obj, + const int *addr_info); + + void transfer_out(complex *out); + + void run(); + +private: + DevicePtrWrapper> d_probe_; + DevicePtrWrapper> d_obj_; + DevicePtrWrapper d_addr_info_; + DevicePtrWrapper> d_out_; + int batch_size_ = 0; + int m_ = 0; + int n_ = 0; + int probe_i_ = 0, probe_m_ = 0, probe_n_ = 0, obj_i_ = 0, obj_m_ = 0, + obj_n_ = 0, addr_len_ = 0; +}; diff --git a/archive/cuda_extension/cuda/func/sqrt_abs.cu b/archive/cuda_extension/cuda/func/sqrt_abs.cu new file mode 100644 index 000000000..4a1382e6e --- /dev/null +++ b/archive/cuda_extension/cuda/func/sqrt_abs.cu @@ -0,0 +1,14 @@ +#include +#include + +// doing this on the CPU for now - this isn't needed anywhere on its own +// - this was used as a test for the cython interfacing +extern "C" void sqrt_abs_c(const float *in, float *out, int m, int n) +{ + auto cin = reinterpret_cast *>(in); + auto cout = reinterpret_cast *>(out); + for (int i = 0; i < m * n; ++i) + { + cout[i] = std::sqrt(std::abs(cin[i])); + } +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/sum_to_buffer.cu b/archive/cuda_extension/cuda/func/sum_to_buffer.cu new file mode 100644 index 000000000..281366ba8 --- /dev/null +++ b/archive/cuda_extension/cuda/func/sum_to_buffer.cu @@ -0,0 +1,347 @@ +#include "sum_to_buffer.h" + +#include "addr_info_helpers.h" +#include "utils/Complex.h" +#include "utils/GpuManager.h" +#include "utils/ScopedTimer.h" + +#include + +/********** Kernels ***********************/ + +template +__global__ void sum_to_buffer_kernel(T *out, + int os_1, + int os_2, + const T *in1, + int in1_1, + int in1_2, + const int *__restrict__ in1_addr, + const int *outidx, + const int *startidx, + const int *__restrict__ indices, + int addr_stride) +{ + auto outi = outidx[blockIdx.x]; + auto ind_start = indices + startidx[blockIdx.x]; + auto ind_end = indices + startidx[blockIdx.x + 1]; + + int tx = threadIdx.x; + int ty = threadIdx.y; + +#pragma unroll(2) + for (int i = tx; i < in1_1; i += BlockX) + { +#pragma unroll(1) + for (int j = ty; j < in1_2; j += BlockY) + { + auto oi = outi * os_1 * os_2 + i * os_2 + j; + T val = T(); + for (auto is = ind_start; is != ind_end; ++is) + { + auto i1 = in1_addr + *is * addr_stride; + auto i1_0 = i1[0]; + auto i1_1 = i1[1] + i; + auto i1_2 = i1[2] + j; + val += in1[i1_0 * in1_1 * in1_2 + i1_1 * in1_2 + i1_2]; + } + out[oi] = val; + } + } +} + +/********** Class implementation **************/ + +template +SumToBuffer::SumToBuffer() : CudaFunction("sum_to_buffer") +{ +} + +template +void SumToBuffer::setParameters(int in1_0, + int in1_1, + int in1_2, + int os_0, + int os_1, + int os_2, + int in1_addr_0, + int out1_addr_0) +{ + in1_0_ = in1_0; + in1_1_ = in1_1; + in1_2_ = in1_2; + os_0_ = os_0; + os_1_ = os_1; + os_2_ = os_2; + in1_addr_0_ = in1_addr_0; + out1_addr_0_ = out1_addr_0; +} + +template +void SumToBuffer::setAddrStride(int stride) +{ + addr_stride_ = stride; +} + +template +void SumToBuffer::setDeviceBuffers(T *d_in1, + T *d_out, + int *d_in1_addr, + int *d_out1_addr, + int *d_outidx, + int *d_startidx, + int *d_indices, + int outidx_size) +{ + d_in1_ = d_in1; + d_out_ = d_out; + d_in1_addr_ = d_in1_addr; + d_out1_addr_ = d_out1_addr; + d_outidx_ = d_outidx; + d_startidx_ = d_startidx; + d_indices_ = d_indices; + if (d_outidx) + { + outidx_size_ = outidx_size; + } +} + +template +void SumToBuffer::allocate() +{ + ScopedTimer t(this, "allocate"); + d_in1_.allocate(in1_0_ * in1_1_ * in1_2_); + d_out_.allocate(os_0_ * os_1_ * os_2_); + d_in1_addr_.allocate(in1_addr_0_ * addr_stride_); + d_out1_addr_.allocate(out1_addr_0_ * addr_stride_); + if (!outidx_.empty()) + { + d_outidx_.allocate(outidx_.size()); + d_startidx_.allocate(startidx_.size()); + d_indices_.allocate(indices_.size()); + outidx_size_ = outidx_.size(); + } +} + +template +int SumToBuffer::calculateAddrIndices(const int *out1_addr) +{ + // calculate the indexing map + outidx_.clear(); + startidx_.clear(); + indices_.clear(); + flatten_out_addr( + out1_addr, out1_addr_0_, addr_stride_, outidx_, startidx_, indices_); + outidx_size_ = outidx_.size(); + return outidx_size_; +} + +template +T *SumToBuffer::getOutput() const +{ + return d_out_.get(); +} + +template +void SumToBuffer::transfer_in(const T *in1, + const int *in1_addr, + const int *out1_addr) +{ + ScopedTimer t(this, "transfer in"); + + gpu_memcpy_h2d(d_in1_.get(), in1, in1_0_ * in1_1_ * in1_2_); + gpu_memcpy_h2d(d_in1_addr_.get(), in1_addr, in1_addr_0_ * addr_stride_); + gpu_memcpy_h2d(d_out1_addr_.get(), out1_addr, out1_addr_0_ * addr_stride_); + if (!outidx_.empty()) + { + gpu_memcpy_h2d(d_outidx_.get(), outidx_.data(), outidx_.size()); + gpu_memcpy_h2d(d_startidx_.get(), startidx_.data(), startidx_.size()); + gpu_memcpy_h2d(d_indices_.get(), indices_.data(), indices_.size()); + } +} + +template +void SumToBuffer::run() +{ + ScopedTimer t(this, "run"); + dim3 threadsPerBlock = {32u, 32u, 1u}; + dim3 blocks = {unsigned(outidx_size_), 1u, 1u}; + sum_to_buffer_kernel + <<>>(d_out_.get(), + os_1_, + os_2_, + d_in1_.get(), + in1_1_, + in1_2_, + d_in1_addr_.get(), + d_outidx_.get(), + d_startidx_.get(), + d_indices_.get(), + addr_stride_); + checkLaunchErrors(); + + // sync device if timing is enabled + timing_sync(); +} + +template +void SumToBuffer::transfer_out(T *out) +{ + ScopedTimer t(this, "transfer out"); + gpu_memcpy_d2h(out, d_out_.get(), os_0_ * os_1_ * os_2_); +} + +/***** interface function **************/ + +// instantiate here to force creating all symbols +template class SumToBuffer; +template class SumToBuffer>; + +template +void sum_to_buffer_tc(const T *in1, + int in1_0, + int in1_1, + int in1_2, + T *out, + int out_0, + int out_1, + int out_2, + const int *in_addr, + int in_addr_0, + const int *out_addr, + int out_addr_0) +{ + auto s2b = gpuManager.get_cuda_function>( + "sum_to_buffer<" + getTypeName() + ">", + in1_0, + in1_1, + in1_2, + out_0, + out_1, + out_2, + in_addr_0, + out_addr_0); + s2b->calculateAddrIndices(out_addr); + s2b->allocate(); + s2b->transfer_in(in1, in_addr, out_addr); + s2b->run(); + s2b->transfer_out(out); +} + +extern "C" void sum_to_buffer_c(const float *in1, + int in1_0, + int in1_1, + int in1_2, + float *out, + int out_0, + int out_1, + int out_2, + const int *in_addr, + int in_addr_0, + const int *out_addr, + int out_addr_0, + int isComplex) +{ + if (isComplex != 0) + { + sum_to_buffer_tc(reinterpret_cast *>(in1), + in1_0, + in1_1, + in1_2, + reinterpret_cast *>(out), + out_0, + out_1, + out_2, + in_addr, + in_addr_0, + out_addr, + out_addr_0); + } + else + { + sum_to_buffer_tc(in1, + in1_0, + in1_1, + in1_2, + out, + out_0, + out_1, + out_2, + in_addr, + in_addr_0, + out_addr, + out_addr_0); + } +} + +template +void sum_to_buffer_stride_tc(const T *in1, + int in1_0, + int in1_1, + int in1_2, + T *out, + int out_0, + int out_1, + int out_2, + const int *addr_info, + int addr_info_0) +{ + auto s2b = gpuManager.get_cuda_function>( + "sum_to_buffer<" + getTypeName() + ">", + in1_0, + in1_1, + in1_2, + out_0, + out_1, + out_2, + addr_info_0, + addr_info_0); + s2b->setAddrStride(15); + auto in_addr = addr_info + 6; + auto out_addr = addr_info + 9; + s2b->calculateAddrIndices(out_addr); + s2b->allocate(); + s2b->transfer_in(in1, in_addr, out_addr); + s2b->run(); + s2b->transfer_out(out); +} + +extern "C" void sum_to_buffer_stride_c(const float *in1, + int in1_0, + int in1_1, + int in1_2, + float *out, + int out_0, + int out_1, + int out_2, + const int *addr_info, + int addr_info_0, + int isComplex) +{ + if (isComplex != 0) + { + sum_to_buffer_stride_tc(reinterpret_cast *>(in1), + in1_0, + in1_1, + in1_2, + reinterpret_cast *>(out), + out_0, + out_1, + out_2, + addr_info, + addr_info_0); + } + else + { + sum_to_buffer_stride_tc(in1, + in1_0, + in1_1, + in1_2, + out, + out_0, + out_1, + out_2, + addr_info, + addr_info_0); + } +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/func/sum_to_buffer.h b/archive/cuda_extension/cuda/func/sum_to_buffer.h new file mode 100644 index 000000000..8f20a5258 --- /dev/null +++ b/archive/cuda_extension/cuda/func/sum_to_buffer.h @@ -0,0 +1,47 @@ +#pragma once + +#include "utils/CudaFunction.h" +#include "utils/Memory.h" + +template +class SumToBuffer : public CudaFunction +{ +public: + SumToBuffer(); + void setParameters(int in1_0, + int in1_1, + int in1_2, + int os_0, + int os_1, + int os_2, + int in1_addr_0, + int out1_addr_0); + void setAddrStride(int stride); + int calculateAddrIndices(const int *out1_addr); + void setDeviceBuffers(T *d_in1, + T *d_out, + int *d_in1_addr, + int *d_out1_addr, + int *d_outidx, + int *d_startidx, + int *d_indices, + int outidx_size); + void allocate(); + T *getOutput() const; + void transfer_in(const T *in1, const int *in1_addr, const int *out1_addr); + void run(); + void transfer_out(T *out); + +private: + DevicePtrWrapper d_in1_; + DevicePtrWrapper d_out_; + DevicePtrWrapper d_in1_addr_; + DevicePtrWrapper d_out1_addr_; + DevicePtrWrapper d_outidx_, d_startidx_, d_indices_; + std::vector outidx_, startidx_, indices_; + int in1_0_ = 0, in1_1_ = 0, in1_2_ = 0; + int os_0_ = 0, os_1_ = 0, os_2_ = 0; + int in1_addr_0_ = 0, out1_addr_0_ = 0; + int addr_stride_ = 3; + int outidx_size_ = 0; +}; diff --git a/archive/cuda_extension/cuda/splines/README.md b/archive/cuda_extension/cuda/splines/README.md new file mode 100644 index 000000000..28179bda2 --- /dev/null +++ b/archive/cuda_extension/cuda/splines/README.md @@ -0,0 +1,6 @@ +These files have been shamelessly taken from https://github.com/DannyRuijters/CubicInterpolationCUDA +and modified to our needs. + +The copyright notice on top of the files has been left intact - please review. + +Note that spline interpolation isn't working at the moment, so this part of the sources isn't used. \ No newline at end of file diff --git a/archive/cuda_extension/cuda/splines/bspline_kernel.cuh b/archive/cuda_extension/cuda/splines/bspline_kernel.cuh new file mode 100644 index 000000000..f92233ecc --- /dev/null +++ b/archive/cuda_extension/cuda/splines/bspline_kernel.cuh @@ -0,0 +1,114 @@ +/*--------------------------------------------------------------------------*\ +Copyright (c) 2008-2010, Danny Ruijters. All rights reserved. +http://www.dannyruijters.nl/cubicinterpolation/ +This file is part of CUDA Cubic B-Spline Interpolation (CI). + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +* Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +* Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are +those of the authors and should not be interpreted as representing official +policies, either expressed or implied. + +When using this code in a scientific project, please cite one or all of the +following papers: +* Daniel Ruijters and Philippe Th�venaz, + GPU Prefilter for Accurate Cubic B-Spline Interpolation, + The Computer Journal, vol. 55, no. 1, pp. 15-20, January 2012. + http://dannyruijters.nl/docs/cudaPrefilter3.pdf +* Daniel Ruijters, Bart M. ter Haar Romeny, and Paul Suetens, + Efficient GPU-Based Texture Interpolation using Uniform B-Splines, + Journal of Graphics Tools, vol. 13, no. 4, pp. 61-69, 2008. +\*--------------------------------------------------------------------------*/ + +#ifndef _CUDA_BSPLINE_H_ +#define _CUDA_BSPLINE_H_ + +#include "math_func.cuh" + +// Cubic B-spline function +// The 3rd order Maximal Order and Minimum Support function, that it is maximally differentiable. +inline __host__ __device__ float bspline(float t) +{ + t = fabs(t); + const float a = 2.0f - t; + + if (t < 1.0f) return 2.0f/3.0f - 0.5f*t*t*a; + else if (t < 2.0f) return a*a*a / 6.0f; + else return 0.0f; +} + +// The first order derivative of the cubic B-spline +inline __host__ __device__ float bspline_1st_derivative(float t) +{ + if (-2.0f < t && t <= -1.0f) return 0.5f*t*t + 2.0f*t + 2.0f; + else if (-1.0f < t && t <= 0.0f) return -1.5f*t*t - 2.0f*t; + else if ( 0.0f < t && t <= 1.0f) return 1.5f*t*t - 2.0f*t; + else if ( 1.0f < t && t < 2.0f) return -0.5f*t*t + 2.0f*t - 2.0f; + else return 0.0f; +} + +// The second order derivative of the cubic B-spline +inline __host__ __device__ float bspline_2nd_derivative(float t) +{ + t = fabs(t); + + if (t < 1.0f) return 3.0f*t - 2.0f; + else if (t < 2.0f) return 2.0f - t; + else return 0.0f; +} + +// Inline calculation of the bspline convolution weights, without conditional statements +template inline __device__ __host__ void bspline_weights(T fraction, T& w0, T& w1, T& w2, T& w3) +{ + const T one_frac = 1.0f - fraction; + const T squared = fraction * fraction; + const T one_sqd = one_frac * one_frac; + + w0 = 1.0f/6.0f * one_sqd * one_frac; + w1 = 2.0f/3.0f - 0.5f * squared * (2.0f-fraction); + w2 = 2.0f/3.0f - 0.5f * one_sqd * (2.0f-one_frac); + w3 = 1.0f/6.0f * squared * fraction; +} + +// Inline calculation of the first order derivative bspline convolution weights, without conditional statements +template inline __device__ void bspline_weights_1st_derivative(T fraction, T& w0, T& w1, T& w2, T& w3) +{ + const T squared = fraction * fraction; + + w0 = -0.5f * squared + fraction - 0.5f; + w1 = 1.5f * squared - 2.0f * fraction; + w2 = -1.5f * squared + fraction + 0.5f; + w3 = 0.5f * squared; +} + +// Inline calculation of the second order derivative bspline convolution weights, without conditional statements +template inline __device__ void bspline_weights_2nd_derivative(T fraction, T& w0, T& w1, T& w2, T& w3) +{ + w0 = 1.0f - fraction; + w1 = 3.0f * fraction - 2.0f; + w2 = -3.0f * fraction + 1.0f; + w3 = fraction; +} + +#endif // _CUDA_BSPLINE_H_ diff --git a/archive/cuda_extension/cuda/splines/cubicPrefilter2D.cu b/archive/cuda_extension/cuda/splines/cubicPrefilter2D.cu new file mode 100644 index 000000000..9c16bdcc8 --- /dev/null +++ b/archive/cuda_extension/cuda/splines/cubicPrefilter2D.cu @@ -0,0 +1,107 @@ +/*--------------------------------------------------------------------------*\ +Copyright (c) 2008-2010, Danny Ruijters. All rights reserved. +http://www.dannyruijters.nl/cubicinterpolation/ +This file is part of CUDA Cubic B-Spline Interpolation (CI). + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +* Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +* Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are +those of the authors and should not be interpreted as representing official +policies, either expressed or implied. + +When using this code in a scientific project, please cite one or all of the +following papers: +* Daniel Ruijters and Philippe Th�venaz, + GPU Prefilter for Accurate Cubic B-Spline Interpolation, + The Computer Journal, vol. 55, no. 1, pp. 15-20, January 2012. + http://dannyruijters.nl/docs/cudaPrefilter3.pdf +* Daniel Ruijters, Bart M. ter Haar Romeny, and Paul Suetens, + Efficient GPU-Based Texture Interpolation using Uniform B-Splines, + Journal of Graphics Tools, vol. 13, no. 4, pp. 61-69, 2008. +\*--------------------------------------------------------------------------*/ + +#ifndef _2D_CUBIC_BSPLINE_PREFILTER_H_ +#define _2D_CUBIC_BSPLINE_PREFILTER_H_ + +#include +#include "cubicPrefilter_kernel.cuh" + +#include "utils/Errors.h" + +// *************************************************************************** +// * Global GPU procedures +// *************************************************************************** +template +__global__ void SamplesToCoefficients2DX( + floatN* image, // in-place processing + uint pitch, // width in bytes + uint width, // width of the image + uint height) // height of the image +{ + // process lines in x-direction + const uint y = blockIdx.x * blockDim.x + threadIdx.x; + floatN* line = (floatN*)((uchar*)image + y * pitch); //direct access + + ConvertToInterpolationCoefficients(line, width, sizeof(floatN)); +} + +template +__global__ void SamplesToCoefficients2DY( + floatN* image, // in-place processing + uint pitch, // width in bytes + uint width, // width of the image + uint height) // height of the image +{ + // process lines in x-direction + const uint x = blockIdx.x * blockDim.x + threadIdx.x; + floatN* line = image + x; //direct access + + ConvertToInterpolationCoefficients(line, height, pitch); +} + +// *************************************************************************** +// * Exported functions +// *************************************************************************** + +//! Convert the pixel values into cubic b-spline coefficients +//! @param image pointer to the image bitmap in GPU (device) memory +//! @param pitch width in bytes (including padding bytes) +//! @param width image width in number of pixels +//! @param height image height in number of pixels +template +extern void CubicBSplinePrefilter2D(floatN* image, uint pitch, uint width, uint height) +{ + dim3 dimBlockX(min(PowTwoDivider(height), 64)); + dim3 dimGridX(height / dimBlockX.x); + SamplesToCoefficients2DX<<>>(image, pitch, width, height); + checkLaunchErrors(); + + dim3 dimBlockY(min(PowTwoDivider(width), 64)); + dim3 dimGridY(width / dimBlockY.x); + SamplesToCoefficients2DY<<>>(image, pitch, width, height); + checkLaunchErrors(); +} + + +#endif //_2D_CUBIC_BSPLINE_PREFILTER_H_ diff --git a/archive/cuda_extension/cuda/splines/cubicPrefilter2D.cuh b/archive/cuda_extension/cuda/splines/cubicPrefilter2D.cuh new file mode 100644 index 000000000..e403bd76f --- /dev/null +++ b/archive/cuda_extension/cuda/splines/cubicPrefilter2D.cuh @@ -0,0 +1,107 @@ +/*--------------------------------------------------------------------------*\ +Copyright (c) 2008-2010, Danny Ruijters. All rights reserved. +http://www.dannyruijters.nl/cubicinterpolation/ +This file is part of CUDA Cubic B-Spline Interpolation (CI). + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +* Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +* Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are +those of the authors and should not be interpreted as representing official +policies, either expressed or implied. + +When using this code in a scientific project, please cite one or all of the +following papers: +* Daniel Ruijters and Philippe Th�venaz, + GPU Prefilter for Accurate Cubic B-Spline Interpolation, + The Computer Journal, vol. 55, no. 1, pp. 15-20, January 2012. + http://dannyruijters.nl/docs/cudaPrefilter3.pdf +* Daniel Ruijters, Bart M. ter Haar Romeny, and Paul Suetens, + Efficient GPU-Based Texture Interpolation using Uniform B-Splines, + Journal of Graphics Tools, vol. 13, no. 4, pp. 61-69, 2008. +\*--------------------------------------------------------------------------*/ + +#ifndef _2D_CUBIC_BSPLINE_PREFILTER_H_ +#define _2D_CUBIC_BSPLINE_PREFILTER_H_ + +#include +#include "cubicPrefilter_kernel.cuh" + +#include "utils/Errors.h" + +// *************************************************************************** +// * Global GPU procedures +// *************************************************************************** +template +__global__ void SamplesToCoefficients2DX( + floatN* image, // in-place processing + uint pitch, // width in bytes + uint width, // width of the image + uint height) // height of the image +{ + // process lines in x-direction + const uint y = blockIdx.x * blockDim.x + threadIdx.x; + floatN* line = (floatN*)((uchar*)image + y * pitch); //direct access + + ConvertToInterpolationCoefficients(line, width, sizeof(floatN)); +} + +template +__global__ void SamplesToCoefficients2DY( + floatN* image, // in-place processing + uint pitch, // width in bytes + uint width, // width of the image + uint height) // height of the image +{ + // process lines in x-direction + const uint x = blockIdx.x * blockDim.x + threadIdx.x; + floatN* line = image + x; //direct access + + ConvertToInterpolationCoefficients(line, height, pitch); +} + +// *************************************************************************** +// * Exported functions +// *************************************************************************** + +//! Convert the pixel values into cubic b-spline coefficients +//! @param image pointer to the image bitmap in GPU (device) memory +//! @param pitch width in bytes (including padding bytes) +//! @param width image width in number of pixels +//! @param height image height in number of pixels +template +void CubicBSplinePrefilter2D(floatN* image, uint pitch, uint width, uint height) +{ + dim3 dimBlockX(min(PowTwoDivider(height), 64)); + dim3 dimGridX(height / dimBlockX.x); + SamplesToCoefficients2DX<<>>(image, pitch, width, height); + checkLaunchErrors(); + + dim3 dimBlockY(min(PowTwoDivider(width), 64)); + dim3 dimGridY(width / dimBlockY.x); + SamplesToCoefficients2DY<<>>(image, pitch, width, height); + checkLaunchErrors(); +} + + +#endif //_2D_CUBIC_BSPLINE_PREFILTER_H_ diff --git a/archive/cuda_extension/cuda/splines/cubicPrefilter_kernel.cu b/archive/cuda_extension/cuda/splines/cubicPrefilter_kernel.cu new file mode 100644 index 000000000..748be3e2a --- /dev/null +++ b/archive/cuda_extension/cuda/splines/cubicPrefilter_kernel.cu @@ -0,0 +1,114 @@ +/*--------------------------------------------------------------------------*\ +Copyright (c) 2008-2012, Danny Ruijters. All rights reserved. +http://www.dannyruijters.nl/cubicinterpolation/ +This file is part of CUDA Cubic B-Spline Interpolation (CI). + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +* Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +* Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are +those of the authors and should not be interpreted as representing official +policies, either expressed or implied. + +When using this code in a scientific project, please cite one or all of the +following papers: +* Daniel Ruijters and Philippe Thévenaz, + GPU Prefilter for Accurate Cubic B-Spline Interpolation, + The Computer Journal, vol. 55, no. 1, pp. 15-20, January 2012. + http://dannyruijters.nl/docs/cudaPrefilter3.pdf +* Daniel Ruijters, Bart M. ter Haar Romeny, and Paul Suetens, + Efficient GPU-Based Texture Interpolation using Uniform B-Splines, + Journal of Graphics Tools, vol. 13, no. 4, pp. 61-69, 2008. +\*--------------------------------------------------------------------------*/ + +#ifndef _CUBIC_BSPLINE_PREFILTER_KERNEL_H_ +#define _CUBIC_BSPLINE_PREFILTER_KERNEL_H_ + +#include "math_func.cu" + +// The code below is based on the work of Philippe Thevenaz. +// See + +#define Pole (sqrt(3.0f)-2.0f) //pole for cubic b-spline + +//-------------------------------------------------------------------------- +// Local GPU device procedures +//-------------------------------------------------------------------------- +template +__host__ __device__ floatN InitialCausalCoefficient( + floatN* c, // coefficients + uint DataLength, // number of coefficients + int step) // element interleave in bytes +{ + const uint Horizon = UMIN(12, DataLength); + + // this initialization corresponds to clamping boundaries + // accelerated loop + float zn = Pole; + floatN Sum = *c; + for (uint n = 0; n < Horizon; n++) { + Sum += zn * *c; + zn *= Pole; + c = (floatN*)((uchar*)c + step); + } + return(Sum); +} + +template +__host__ __device__ floatN InitialAntiCausalCoefficient( + floatN* c, // last coefficient + uint DataLength, // number of samples or coefficients + int step) // element interleave in bytes +{ + // this initialization corresponds to clamping boundaries + return((Pole / (Pole - 1.0f)) * *c); +} + +template +__host__ __device__ void ConvertToInterpolationCoefficients( + floatN* coeffs, // input samples --> output coefficients + uint DataLength, // number of samples or coefficients + int step) // element interleave in bytes +{ + // compute the overall gain + const float Lambda = (1.0f - Pole) * (1.0f - 1.0f / Pole); + + // causal initialization + floatN* c = coeffs; + floatN previous_c; //cache the previously calculated c rather than look it up again (faster!) + *c = previous_c = Lambda * InitialCausalCoefficient(c, DataLength, step); + // causal recursion + for (uint n = 1; n < DataLength; n++) { + c = (floatN*)((uchar*)c + step); + *c = previous_c = Lambda * *c + Pole * previous_c; + } + // anticausal initialization + *c = previous_c = InitialAntiCausalCoefficient(c, DataLength, step); + // anticausal recursion + for (int n = DataLength - 2; 0 <= n; n--) { + c = (floatN*)((uchar*)c - step); + *c = previous_c = Pole * (previous_c - *c); + } +} + +#endif // _CUBIC_BSPLINE_PREFILTER_KERNEL_H_ diff --git a/archive/cuda_extension/cuda/splines/cubicPrefilter_kernel.cuh b/archive/cuda_extension/cuda/splines/cubicPrefilter_kernel.cuh new file mode 100644 index 000000000..5dc576428 --- /dev/null +++ b/archive/cuda_extension/cuda/splines/cubicPrefilter_kernel.cuh @@ -0,0 +1,114 @@ +/*--------------------------------------------------------------------------*\ +Copyright (c) 2008-2012, Danny Ruijters. All rights reserved. +http://www.dannyruijters.nl/cubicinterpolation/ +This file is part of CUDA Cubic B-Spline Interpolation (CI). + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +* Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +* Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are +those of the authors and should not be interpreted as representing official +policies, either expressed or implied. + +When using this code in a scientific project, please cite one or all of the +following papers: +* Daniel Ruijters and Philippe Th�venaz, + GPU Prefilter for Accurate Cubic B-Spline Interpolation, + The Computer Journal, vol. 55, no. 1, pp. 15-20, January 2012. + http://dannyruijters.nl/docs/cudaPrefilter3.pdf +* Daniel Ruijters, Bart M. ter Haar Romeny, and Paul Suetens, + Efficient GPU-Based Texture Interpolation using Uniform B-Splines, + Journal of Graphics Tools, vol. 13, no. 4, pp. 61-69, 2008. +\*--------------------------------------------------------------------------*/ + +#ifndef _CUBIC_BSPLINE_PREFILTER_KERNEL_H_ +#define _CUBIC_BSPLINE_PREFILTER_KERNEL_H_ + +#include "math_func.cuh" + +// The code below is based on the work of Philippe Thevenaz. +// See + +#define Pole (sqrt(3.0f)-2.0f) //pole for cubic b-spline + +//-------------------------------------------------------------------------- +// Local GPU device procedures +//-------------------------------------------------------------------------- +template +__host__ __device__ floatN InitialCausalCoefficient( + floatN* c, // coefficients + uint DataLength, // number of coefficients + int step) // element interleave in bytes +{ + const uint Horizon = UMIN(12, DataLength); + + // this initialization corresponds to clamping boundaries + // accelerated loop + float zn = Pole; + floatN Sum = *c; + for (uint n = 0; n < Horizon; n++) { + Sum += zn * *c; + zn *= Pole; + c = (floatN*)((uchar*)c + step); + } + return(Sum); +} + +template +__host__ __device__ floatN InitialAntiCausalCoefficient( + floatN* c, // last coefficient + uint DataLength, // number of samples or coefficients + int step) // element interleave in bytes +{ + // this initialization corresponds to clamping boundaries + return((Pole / (Pole - 1.0f)) * *c); +} + +template +__host__ __device__ void ConvertToInterpolationCoefficients( + floatN* coeffs, // input samples --> output coefficients + uint DataLength, // number of samples or coefficients + int step) // element interleave in bytes +{ + // compute the overall gain + const float Lambda = (1.0f - Pole) * (1.0f - 1.0f / Pole); + + // causal initialization + floatN* c = coeffs; + floatN previous_c; //cache the previously calculated c rather than look it up again (faster!) + *c = previous_c = Lambda * InitialCausalCoefficient(c, DataLength, step); + // causal recursion + for (uint n = 1; n < DataLength; n++) { + c = (floatN*)((uchar*)c + step); + *c = previous_c = Lambda * *c + Pole * previous_c; + } + // anticausal initialization + *c = previous_c = InitialAntiCausalCoefficient(c, DataLength, step); + // anticausal recursion + for (int n = DataLength - 2; 0 <= n; n--) { + c = (floatN*)((uchar*)c - step); + *c = previous_c = Pole * (previous_c - *c); + } +} + +#endif // _CUBIC_BSPLINE_PREFILTER_KERNEL_H_ diff --git a/archive/cuda_extension/cuda/splines/math_func.cu b/archive/cuda_extension/cuda/splines/math_func.cu new file mode 100644 index 000000000..1f9799f23 --- /dev/null +++ b/archive/cuda_extension/cuda/splines/math_func.cu @@ -0,0 +1,77 @@ +/*--------------------------------------------------------------------------*\ +Copyright (c) 2008-2009, Danny Ruijters. All rights reserved. +http://www.dannyruijters.nl/cubicinterpolation/ +This file is part of CUDA Cubic B-Spline Interpolation (CI). + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +* Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +* Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are +those of the authors and should not be interpreted as representing official +policies, either expressed or implied. + +When using this code in a scientific project, please cite one or all of the +following papers: +* Daniel Ruijters and Philippe Thévenaz, + GPU Prefilter for Accurate Cubic B-Spline Interpolation, + The Computer Journal, vol. 55, no. 1, pp. 15-20, January 2012. + http://dannyruijters.nl/docs/cudaPrefilter3.pdf +* Daniel Ruijters, Bart M. ter Haar Romeny, and Paul Suetens, + Efficient GPU-Based Texture Interpolation using Uniform B-Splines, + Journal of Graphics Tools, vol. 13, no. 4, pp. 61-69, 2008. +\*--------------------------------------------------------------------------*/ + +#ifndef _MATH_FUNC_CUDA_H_ +#define _MATH_FUNC_CUDA_H_ + +#include "version.cu" + +typedef unsigned int uint; +typedef unsigned short ushort; +typedef unsigned char uchar; +typedef signed char schar; + +inline __device__ __host__ uint UMIN(uint a, uint b) +{ + return a < b ? a : b; +} + +inline __device__ __host__ uint PowTwoDivider(uint n) +{ + if (n == 0) return 0; + uint divider = 1; + while ((n & divider) == 0) divider <<= 1; + return divider; +} + +inline __host__ __device__ float2 operator-(float a, float2 b) +{ + return make_float2(a - b.x, a - b.y); +} + +inline __host__ __device__ float3 operator-(float a, float3 b) +{ + return make_float3(a - b.x, a - b.y, a - b.z); +} + +#endif //_MATH_FUNC_CUDA_H_ diff --git a/archive/cuda_extension/cuda/splines/math_func.cuh b/archive/cuda_extension/cuda/splines/math_func.cuh new file mode 100644 index 000000000..16ae20866 --- /dev/null +++ b/archive/cuda_extension/cuda/splines/math_func.cuh @@ -0,0 +1,75 @@ +/*--------------------------------------------------------------------------*\ +Copyright (c) 2008-2009, Danny Ruijters. All rights reserved. +http://www.dannyruijters.nl/cubicinterpolation/ +This file is part of CUDA Cubic B-Spline Interpolation (CI). + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +* Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +* Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are +those of the authors and should not be interpreted as representing official +policies, either expressed or implied. + +When using this code in a scientific project, please cite one or all of the +following papers: +* Daniel Ruijters and Philippe Th�venaz, + GPU Prefilter for Accurate Cubic B-Spline Interpolation, + The Computer Journal, vol. 55, no. 1, pp. 15-20, January 2012. + http://dannyruijters.nl/docs/cudaPrefilter3.pdf +* Daniel Ruijters, Bart M. ter Haar Romeny, and Paul Suetens, + Efficient GPU-Based Texture Interpolation using Uniform B-Splines, + Journal of Graphics Tools, vol. 13, no. 4, pp. 61-69, 2008. +\*--------------------------------------------------------------------------*/ + +#ifndef _MATH_FUNC_CUDA_H_ +#define _MATH_FUNC_CUDA_H_ + +typedef unsigned int uint; +typedef unsigned short ushort; +typedef unsigned char uchar; +typedef signed char schar; + +inline __device__ __host__ uint UMIN(uint a, uint b) +{ + return a < b ? a : b; +} + +inline __device__ __host__ uint PowTwoDivider(uint n) +{ + if (n == 0) return 0; + uint divider = 1; + while ((n & divider) == 0) divider <<= 1; + return divider; +} + +inline __host__ __device__ float2 operator-(float a, float2 b) +{ + return make_float2(a - b.x, a - b.y); +} + +inline __host__ __device__ float3 operator-(float a, float3 b) +{ + return make_float3(a - b.x, a - b.y, a - b.z); +} + +#endif //_MATH_FUNC_CUDA_H_ diff --git a/archive/cuda_extension/cuda/tests/gaussian_weights_test.cpp b/archive/cuda_extension/cuda/tests/gaussian_weights_test.cpp new file mode 100644 index 000000000..afe80bc85 --- /dev/null +++ b/archive/cuda_extension/cuda/tests/gaussian_weights_test.cpp @@ -0,0 +1,27 @@ +#include "utils/GaussianWeights.h" +#include + +#include + +TEST(GaussianFilter, weightsCompareToPython) +{ + std::vector expected = {1.9947465e-01f, + 1.7603576e-01f, + 1.2098749e-01f, + 6.4759940e-02f, + 2.6995959e-02f, + 8.7643042e-03f, + 2.2159631e-03f, + 4.3634902e-04f, + 6.6916291e-05f}; + auto actual = gaussian_kernel1d(2, 8); + EXPECT_EQ(actual.size(), expected.size()); + + for (int i = 0; i < expected.size(); ++i) + { + EXPECT_NEAR(expected[i], actual[i], 1e-4f); + } + auto sum_right = std::accumulate(actual.begin() + 1, actual.end(), 0.0f); + auto sum = 2 * sum_right + actual[0]; + EXPECT_NEAR(sum, 1.0f, 1e-4f); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/tests/indexing_test.cpp b/archive/cuda_extension/cuda/tests/indexing_test.cpp new file mode 100644 index 000000000..101c4eee0 --- /dev/null +++ b/archive/cuda_extension/cuda/tests/indexing_test.cpp @@ -0,0 +1,94 @@ +#include + +#include "utils/Indexing.h" + +TEST(IndexingTest, inRange) +{ + IndexReflect ind(1, 10); + EXPECT_EQ(1, ind(1)); + EXPECT_EQ(5, ind(5)); + EXPECT_EQ(3, ind(3)); + EXPECT_EQ(9, ind(9)); +} + +TEST(IndexingTest, reflectTop1) +{ + IndexReflect ind(1, 10); + EXPECT_EQ(9, ind(10)); + EXPECT_EQ(8, ind(11)); + EXPECT_EQ(7, ind(12)); + EXPECT_EQ(6, ind(13)); +} + +TEST(IndexingTest, reflectTop0) +{ + IndexReflect ind(0, 10); + EXPECT_EQ(9, ind(10)); + EXPECT_EQ(8, ind(11)); + EXPECT_EQ(7, ind(12)); + EXPECT_EQ(6, ind(13)); +} + +TEST(IndexingTest, reflectTopNeg) +{ + IndexReflect ind(-5, 0); + EXPECT_EQ(-2, ind(1)); + EXPECT_EQ(-3, ind(2)); + EXPECT_EQ(-4, ind(3)); + EXPECT_EQ(-5, ind(4)); +} + +TEST(IndexingTest, reflectBottom) +{ + IndexReflect ind(1, 10); + EXPECT_EQ(1, ind(0)); + EXPECT_EQ(2, ind(-1)); + EXPECT_EQ(3, ind(-2)); +} + +TEST(IndexingTest, reflectBottom0) +{ + IndexReflect ind(0, 10); + EXPECT_EQ(0, ind(0)); + EXPECT_EQ(0, ind(-1)); + EXPECT_EQ(1, ind(-2)); + EXPECT_EQ(2, ind(-3)); +} + +TEST(IndexingTest, reflectBottomNeg) +{ + IndexReflect ind(-5, -1); + EXPECT_EQ(-5, ind(-5)); + EXPECT_EQ(-5, ind(-6)); + EXPECT_EQ(-4, ind(-7)); + EXPECT_EQ(-3, ind(-8)); +} + +TEST(IndexingTest, reflectTopWide) +{ + IndexReflect ind(1, 3); + EXPECT_EQ(2, ind(3)); + EXPECT_EQ(1, ind(4)); + EXPECT_EQ(1, ind(5)); + EXPECT_EQ(2, ind(6)); +} + +TEST(IndexingTest, reflectTopWideNeg) +{ + IndexReflect ind(-4, -1); + EXPECT_EQ(-3, ind(0)); + EXPECT_EQ(-4, ind(1)); + EXPECT_EQ(-4, ind(2)); + EXPECT_EQ(-3, ind(3)); + EXPECT_EQ(-2, ind(4)); + EXPECT_EQ(-2, ind(5)); +} + +TEST(IndexingTest, reflectBottomWide) +{ + IndexReflect ind(1, 3); + EXPECT_EQ(2, ind(-2)); + EXPECT_EQ(1, ind(-3)); + EXPECT_EQ(1, ind(-4)); + EXPECT_EQ(2, ind(-5)); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/utils/Complex.h b/archive/cuda_extension/cuda/utils/Complex.h new file mode 100644 index 000000000..4192fe060 --- /dev/null +++ b/archive/cuda_extension/cuda/utils/Complex.h @@ -0,0 +1,5 @@ +#pragma once +#include + +using thrust::complex; + diff --git a/archive/cuda_extension/cuda/utils/CudaFunction.cpp b/archive/cuda_extension/cuda/utils/CudaFunction.cpp new file mode 100644 index 000000000..0238782f3 --- /dev/null +++ b/archive/cuda_extension/cuda/utils/CudaFunction.cpp @@ -0,0 +1,19 @@ +#include "utils/CudaFunction.h" + +#include + +CudaFunction::CudaFunction(const std::string& name) : name_(name) {} + +void CudaFunction::printTimes() const +{ +#if DO_GPU_TIMING + std::cout << "\nTiming stats for " << name_ << ":\n"; + for (auto& t : times_) + { + std::cout << t.first << "=" << t.second << "ms\n"; + } + std::cout.flush(); +#endif +} + +CudaFunction::~CudaFunction() { printTimes(); } \ No newline at end of file diff --git a/archive/cuda_extension/cuda/utils/CudaFunction.h b/archive/cuda_extension/cuda/utils/CudaFunction.h new file mode 100644 index 000000000..dac018cf0 --- /dev/null +++ b/archive/cuda_extension/cuda/utils/CudaFunction.h @@ -0,0 +1,26 @@ +#pragma once + +#include +#include +#include + +/** Used as base class for all CUDA functions. + * + * Mainly used for factoring out gpu timing events, using + * ScopedTimer inside the child. + */ +class CudaFunction +{ +protected: + CudaFunction(const std::string &name); + +public: + void printTimes() const; + /** Calls printTimes() if timing is enabled */ + virtual ~CudaFunction(); + +private: + friend class ScopedTimer; + std::string name_; + std::vector> times_; +}; \ No newline at end of file diff --git a/archive/cuda_extension/cuda/utils/Errors.h b/archive/cuda_extension/cuda/utils/Errors.h new file mode 100644 index 000000000..244c1563f --- /dev/null +++ b/archive/cuda_extension/cuda/utils/Errors.h @@ -0,0 +1,122 @@ +#pragma once + +#include "utils/Patches.h" + +#include +#include +#include +#include + +/** GPU exceptions - typically thrown from CUDA API failures. + * + * Using the checkCudaErrors() macro around each call makes sure + * that this exception is thrown on error. + */ +class GPUException : public std::runtime_error +{ +public: + GPUException(int code, + const std::string &what, + const std::string &instruction = "", + const std::string &file = "", + int line = -1) + : std::runtime_error("GPU Exception at " + file + ":" + + std::to_string(line) + ": " + what + + " @ instruction '" + instruction + "'") + { + } + GPUException(const std::string &what) : std::runtime_error(what) {} +}; + +/// Wrap this around cuda or cufft API calls +#define checkCudaErrors(val) \ + detail::handleCudaErrors((val), #val, __FILE__, __LINE__) + +/// Use this macro to check if a kernel launch failed. +/// That is, call this straight after a manual kernel launch, without sync. +#define checkLaunchErrors() checkCudaErrors(cudaPeekAtLastError()) + +/// Implementation details, translating macro to exception +namespace detail +{ +inline void handleCudaErrors(cudaError_t e, + const char *func, + const char *file, + int line) +{ + if (e) + { + cudaDeviceReset(); + throw GPUException(int(e), cudaGetErrorString(e), func, file, line); + } +} + +inline void handleCudaErrors(cufftResult e, + const char *func, + const char *file, + int line) +{ + if (e) + { + const char *errstr = nullptr; + switch (e) + { + case CUFFT_INVALID_PLAN: + errstr = "cuFFT was passed an invalid plan handle"; + break; + case CUFFT_ALLOC_FAILED: + errstr = "cuFFT failed to allocate GPU or CPU memory"; + break; + case CUFFT_INVALID_TYPE: + errstr = "No longer used"; + break; + case CUFFT_INVALID_VALUE: + errstr = "User specified an invalid pointer or parameter"; + break; + case CUFFT_INTERNAL_ERROR: + errstr = "Driver or internal cuFFT library error"; + break; + case CUFFT_EXEC_FAILED: + errstr = "Failed to execute an FFT on the GPU"; + break; + case CUFFT_SETUP_FAILED: + errstr = "The cuFFT library failed to initialize"; + break; + case CUFFT_INVALID_SIZE: + errstr = "User specified an invalid transform size"; + break; + case CUFFT_UNALIGNED_DATA: + errstr = " No longer used"; + break; + case CUFFT_INCOMPLETE_PARAMETER_LIST: + errstr = " Missing parameters in call "; + break; + case CUFFT_INVALID_DEVICE: + errstr = "Execution of a plan was on different GPU than plan creation"; + break; + case CUFFT_PARSE_ERROR: + errstr = "Internal plan database error"; + break; + case CUFFT_NO_WORKSPACE: + errstr = "No workspace has been provided prior to plan execution"; + break; + case CUFFT_NOT_IMPLEMENTED: + errstr = + "Function does not implement functionality for parameters given."; + break; + case CUFFT_LICENSE_ERROR: + errstr = "Used in previous versions."; + break; + case CUFFT_NOT_SUPPORTED: + errstr = "Operation is not supported for parameters given."; + break; + default: + errstr = "Unknown"; + } + + cudaDeviceReset(); + throw GPUException(int(e), errstr, func, file, line); + } +} + +} // namespace detail diff --git a/archive/cuda_extension/cuda/utils/FinalSumKernel.h b/archive/cuda_extension/cuda/utils/FinalSumKernel.h new file mode 100644 index 000000000..47181b34d --- /dev/null +++ b/archive/cuda_extension/cuda/utils/FinalSumKernel.h @@ -0,0 +1,36 @@ + +// to be run in a single thread block +template +__global__ void final_sum(const T* data, T* output, int n) +{ + int tid = threadIdx.x; + extern __shared__ T sum[]; + + auto val = 0.0f; + // in case we have more data than threads in this block + for (int i = tid; i < n; i += blockDim.x) + { + val += data[i]; + } + sum[tid] = val; + + // now add up sumbuffer in shared memory + __syncthreads(); + int nt = blockDim.x; + int c = nt; + while (c > 1) + { + int half = c / 2; + if (tid < half) + { + sum[tid] += sum[c - tid - 1]; + } + __syncthreads(); + c = c - half; + } + + if (tid == 0) + { + output[0] = sum[0]; + } +} diff --git a/archive/cuda_extension/cuda/utils/GaussianWeights.h b/archive/cuda_extension/cuda/utils/GaussianWeights.h new file mode 100644 index 000000000..855437091 --- /dev/null +++ b/archive/cuda_extension/cuda/utils/GaussianWeights.h @@ -0,0 +1,25 @@ +#pragma once + +#include +#include + +// 1D Gaussian convolution kernel (symmetric) +inline std::vector gaussian_kernel1d(float sigma, int radius) +{ + float factor = -0.5f / (sigma * sigma); + std::vector weights(radius + 1); + float sum = 0.0f; + for (auto i = 0; i < radius + 1; ++i) + { + weights[i] = std::exp(factor * (i * i)); + if (i == 0) + sum += weights[i]; + else + sum += 2.0f * weights[i]; // for symmetry + } + for (auto i = 0; i < radius + 1; ++i) + { + weights[i] /= sum; + } + return std::move(weights); +} diff --git a/archive/cuda_extension/cuda/utils/GpuManager.cu b/archive/cuda_extension/cuda/utils/GpuManager.cu new file mode 100644 index 000000000..677f56eee --- /dev/null +++ b/archive/cuda_extension/cuda/utils/GpuManager.cu @@ -0,0 +1,104 @@ +#include "GpuManager.h" +#include +#include + +GpuManager::GpuManager() +{ + int numdev; + cudaGetDeviceCount(&numdev); + if (numdev == 0) + { + std::cout << "No GPUs found on this system\n"; + return; + } + + properties_.resize(numdev); + for (int i = 0; i < numdev; ++i) + { + cudaGetDeviceProperties(&properties_[i], i); + } + + fftDummyHandles_.resize(numdev); +} + +void GpuManager::selectDevice(int dev) +{ + if (dev >= int(properties_.size())) + { + throw GPUException("GPU " + std::to_string(dev) + " does not exist"); + } + checkCudaErrors(cudaSetDevice(dev)); + if (selectedDevice_ == dev) + { + return; + } + selectedDevice_ = dev; + + // not initialised yet + if (fftDummyHandles_[dev] == 0) + { + // init cufft and cuda context by creating a plan + checkCudaErrors(cufftPlan1d(&fftDummyHandles_[dev], 32, CUFFT_C2C, 1)); + } +} + +int GpuManager::getNumDevices() const { return int(properties_.size()); } + +std::string GpuManager::getDeviceName(int id) const +{ + return properties_[id].name; +} + +int GpuManager::getDeviceComputeCapability(int id) const +{ + return properties_[id].major * 10 + properties_[id].minor; +} + +int GpuManager::getDeviceMemoryMB(int id) const +{ + return int(properties_[id].totalGlobalMem / 1024ul / 1024ul); +} + +void GpuManager::resetFunctionCache() { functions_cache_.clear(); } + +GpuManager::~GpuManager() +{ + for (int i = 0, ni = int(fftDummyHandles_.size()); i < ni; ++i) + { + if (fftDummyHandles_[i] != 0) + { + cudaSetDevice(i); + cufftDestroy(fftDummyHandles_[i]); + cudaDeviceReset(); + } + } +} + +// for memory tracking - see Memory.cpp +// needs to be here so that it gets destructed +// after the GpuManager object +std::map alloc_map_; +size_t alloc_total = 0; + +// instatiate the object +GpuManager gpuManager; + +/**** interface functions for python ******/ + +extern "C" +{ + int get_num_gpus_c() { return gpuManager.getNumDevices(); } + + int get_gpu_compute_capability_c(int dev) + { + return gpuManager.getDeviceComputeCapability(dev); + } + + void select_gpu_device_c(int dev) { gpuManager.selectDevice(dev); } + + int get_gpu_memory_mb_c(int dev) { return gpuManager.getDeviceMemoryMB(dev); } + + std::string get_gpu_name_c(int dev) { return gpuManager.getDeviceName(dev); } + + void reset_function_cache_c() { gpuManager.resetFunctionCache(); } +} diff --git a/archive/cuda_extension/cuda/utils/GpuManager.h b/archive/cuda_extension/cuda/utils/GpuManager.h new file mode 100644 index 000000000..8f6cbfbd4 --- /dev/null +++ b/archive/cuda_extension/cuda/utils/GpuManager.h @@ -0,0 +1,163 @@ +#pragma once + +#include "utils/Complex.h" +#include "utils/Memory.h" + +#include +#include +#include +#include + +#include "utils/CudaFunction.h" +#include +#include + +/** Responsible for managing the GPUs globally. + * + * It creates the context and might eventually hold persistent + * CudaFunction objects, to keep memory allocated and re-usable. + * + * Don't create an instance directly - use the global object + * gpuManager instead. + */ +class GpuManager +{ +public: + /** Queries available devices and their properties, but doesn't initialise the + * context + */ + GpuManager(); + + /** Get number of available GPUs. + * + * Note the Cuda GPUs are numbered with integer indices, always continuous. + */ + int getNumDevices() const; + + /** Get the name of a specific GPU */ + std::string getDeviceName(int id) const; + + /** Get the compute capability of a specific GPU, in format 35 for 3.5. */ + int getDeviceComputeCapability(int id) const; + + /** Get global memory available in MB */ + int getDeviceMemoryMB(int id) const; + + /** Select a specific device to use for all calculations that follow. + * + * Note that this function creates the context on the given device, + * to avoid setup delays. Also, this device should not be changed once + * functions have been executed already. A resetFunctionCache call is needed + * before in this case. + */ + void selectDevice(int dev = 0); + + /** Resets (clears) the internal cache for CudaFunction objects + * + * Subsequent calls to CudaFunctions will re-create them, allocating new + * memory, etc. + */ + void resetFunctionCache(); + + /** Function to obtain an instance of a specific CudaFunction, given its name + * key and parameters. + * + * This functions looks up in the cache if an object with the given name + * already exists. The name is used as a key in the cache (so it should be + * unique for each distinct CudaFunction type). + * + * If the function isn't in the cache, it is created. + * + * After that, it calls setParameters on the CudaFunction, passing the + * variable parameters given to this function after the name key. + * + * Therefore all CudaFunction objects created with this functions must: + * - derive from the CudaFunction base class + * - have a default constructor + * - have a setParameters() method which accepts the arguments passed this + * this method. + * - should be written so that it respects updated setParameters in subsquent + * calls to allocate, transfer_in, setDeviceBuffers, etc... + */ + template + T* get_cuda_function(const std::string& key, Args&&... args) + { + // setup device if not already done + if (selectedDevice_ == -1) + { + selectDevice(0); + } + + // create if not already there (with default constructor) + if (functions_cache_.find(key) == functions_cache_.end()) + { + functions_cache_[key] = std::unique_ptr(new T()); + } + + // retrieve and set the parameters (they might have changed + // since we cached them) + auto ret = dynamic_cast(functions_cache_[key].get()); + if (ret == nullptr) + { + throw GPUException("cached CudaFunction with key " + key + + " doesn't match the requested type"); + } + ret->setParameters(std::forward(args)...); + + return ret; + } + + ~GpuManager(); + +private: + std::vector properties_; + std::vector fftDummyHandles_; + int selectedDevice_ = -1; + std::map> functions_cache_; +}; + +/** Global object to manage the GPUs */ +extern GpuManager gpuManager; + +/** Type helper - converting type signature into a string. + * + * This is used for generating a signature key to use in the function_cache + * above - to avoid for example Abs2 and Abs2 to have the same + * key in the cache. + **/ +template +inline std::string getTypeName() +{ + return "unknown"; +} +template <> +inline std::string getTypeName() +{ + return "float"; +} +template <> +inline std::string getTypeName() +{ + return "double"; +} +template <> +inline std::string getTypeName>() +{ + return "c_float"; +} +template <> +inline std::string getTypeName>() +{ + return "c_double"; +} + +/**** interface functions for python ******/ +extern "C" +{ + int get_num_gpus_c(); + int get_gpu_compute_capability_c(int dev); + void select_gpu_device_c(int dev); + int get_gpu_memory_mb_c(int dev); + std::string get_gpu_name_c(int dev); + void reset_function_cache_c(); +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/utils/Indexing.h b/archive/cuda_extension/cuda/utils/Indexing.h new file mode 100644 index 000000000..c2087f1ba --- /dev/null +++ b/archive/cuda_extension/cuda/utils/Indexing.h @@ -0,0 +1,40 @@ +#pragma once +#include + +// allow testing this on CPU +#ifndef __NVCC__ +#define __device__ +#endif + +/** Implements reflect-mode index wrapping + * + * maps indexes like this (reflects on both ends): + * Extension | Input | Extension + * 5 6 6 5 4 3 2 | 2 3 4 5 6 | 6 5 4 3 2 2 3 4 5 6 6 + * + */ +class IndexReflect +{ +public: + /** Create index range. maxX is not included in the valid range, + * i.e., the range is [minX, maxX) + */ + __device__ IndexReflect(int minX, int maxX) : maxX_(maxX), minX_(minX) {} + + /// Map given index to the valid range using reflect mode + __device__ int operator()(int idx) const + { + if (idx < maxX_ && idx >= minX_) + return idx; + auto ddd = (idx - minX_) / (maxX_ - minX_); + auto mmm = (idx - minX_) % (maxX_ - minX_); + if (mmm < 0) + mmm = -mmm - 1; + // if odd it goes backwards from max + // if even it goes upwards from min + return ddd % 2 == 0 ? minX_ + mmm : maxX_ - mmm - 1; + } + +private: + int maxX_, minX_; +}; diff --git a/archive/cuda_extension/cuda/utils/Memory.cpp b/archive/cuda_extension/cuda/utils/Memory.cpp new file mode 100644 index 000000000..19abd8ef4 --- /dev/null +++ b/archive/cuda_extension/cuda/utils/Memory.cpp @@ -0,0 +1,31 @@ +#include +#include + +// we have to define this in GpuManager.cu +// otherwise it gets destructed before the CudaFunctions +// are destroyed (potentially at least) +extern std::map alloc_map_; +extern size_t alloc_total; + +void debug_addMemory(void* ptr, size_t size) +{ + alloc_map_[ptr] = size; + alloc_total += size; +} + +void debug_freeMemory(void* ptr) +{ + if (alloc_map_.find(ptr) != alloc_map_.end()) + { + auto size = alloc_map_[ptr]; + alloc_total -= size; + alloc_map_.erase(ptr); + } + else + { + std::cerr << "WARNING: freeing memory of ptr " << ptr + << " that hasn't been registered before" << std::endl; + } +} + +size_t debug_getMemory() { return alloc_total; } \ No newline at end of file diff --git a/archive/cuda_extension/cuda/utils/Memory.h b/archive/cuda_extension/cuda/utils/Memory.h new file mode 100644 index 000000000..9d5b8846d --- /dev/null +++ b/archive/cuda_extension/cuda/utils/Memory.h @@ -0,0 +1,195 @@ +#pragma once + +#include "utils/Errors.h" +#include +#include + +// debugging functions, to record allocated and freed GPU memory +// allows inspection of how much memory has been allocated on the gpu +void debug_addMemory(void *ptr, size_t size); +void debug_freeMemory(void *ptr); +size_t debug_getMemory(); + +/** Allocate GPU memory, giving size in unit of sizeof(T) */ +template +inline void gpu_malloc(T *&ptr, size_t size) +{ +#ifndef NDEBUG + std::cout << "allocating " << double(size) << " on the GPU" << std::endl; +#endif + checkCudaErrors(cudaMalloc((void **)&ptr, sizeof(T) * size)); + // set it to zero + checkCudaErrors(cudaMemset(ptr, 0, sizeof(T) * size)); +#ifndef NDEBUG + debug_addMemory((void *)ptr, size); + std::cout << "Allocated " << (void *)ptr + << ", total: " << double(debug_getMemory()) << std::endl; +#endif +} + +template +inline void gpu_free(T *ptr) +{ + if (ptr) + { +#ifndef NDEBUG + std::cout << "freeing for pointer: " << (void *)ptr << std::endl; + debug_freeMemory((void *)ptr); +#endif + cudaFree(ptr); +#ifndef NDEBUG + std::cout << "Total allocated: " << double(debug_getMemory()) << std::endl; +#endif + } +} + +/** Transfers data from host to device. + * + * If any pointer is null, it silently doesn't transfer. + * + * @param device Pointer to device-allocated memory + * @param host Pointer to host-memory + * @param size Number of elmentary T items to transfer + */ +template +inline void gpu_memcpy_h2d(T *device, const T *host, size_t size) +{ + if (!host || !device) + return; + checkCudaErrors( + cudaMemcpy(device, host, sizeof(T) * size, cudaMemcpyHostToDevice)); +} + +/** Transfers data from device to host. + * + * If any pointer is null, it silently doesn't transfer. + * + * @param device Pointer to device-allocated memory + * @param host Pointer to host-memory + * @param size Number of elmentary T items to transfer + */ +template +inline void gpu_memcpy_d2h(T *host, const T *device, size_t size) +{ + if (!host || !device) + return; + checkCudaErrors( + cudaMemcpy(host, device, sizeof(T) * size, cudaMemcpyDeviceToHost)); +} + +template +inline void gpu_memcpy_d2d(T *dev_dst, const T *dev_src, size_t size) +{ + if (!dev_dst || !dev_src) + return; + checkCudaErrors( + cudaMemcpy(dev_dst, dev_src, sizeof(T) * size, cudaMemcpyDeviceToDevice)); +} + +/** Wraps a device pointer in RAII fashion, allowing to set an externally + * allocated pointer as well. + * + * If an externally-allocated pointer is set, it will return this one instead + * and avoid internal allocation. + */ +template +class DevicePtrWrapper +{ +public: + /** Default constructor */ + DevicePtrWrapper() = default; + /** Not copyable */ + DevicePtrWrapper(const DevicePtrWrapper &) = delete; + /** Not copyable */ + DevicePtrWrapper &operator=(const DevicePtrWrapper &) = delete; + /** Movable */ + DevicePtrWrapper(DevicePtrWrapper &&) = default; + /** Movable */ + DevicePtrWrapper &operator=(DevicePtrWrapper &&) = default; + + /** Assign an external pointer to use. + * + * If null, the internal pointer will be used instead + */ + DevicePtrWrapper &operator=(T *dptr) + { + set_external(dptr); + return *this; + } + + /** Allocates memory for the internal pointer. + * + * If an external pointer was set before, this function does not allocate + * anything. + * + * If the internal pointer was already allocated and size <= previous size, + * it doesn't allocate again. + * + * @param size Number of items to allocate memory for. + */ + void allocate(size_t size) + { + if (!isExternal()) + { + if (d_internal_ && size_ < size) + { + gpu_free(d_internal_); + } + if (d_internal_ && size_ >= size) + { + return; + } + + gpu_malloc(d_internal_, size); + size_ = size; + } + } + + /** Sets the external device pointer. + * + * Same as operator= + */ + void set_external(T *d) { d_external_ = d; } + + /** Unsets the external pointer - interal will be used from then on. + * + * Effectively sets the external pointer to null. + */ + void unset_external() { d_external_ = nullptr; } + + /** Check if external pointer is set */ + bool isExternal() const { return d_external_ != nullptr; } + + /** Amount of memory allocated for internal pointer. */ + size_t size() const { return size_; } + + /** Implicit conversion to bool - see if a pointer is set */ + operator bool() const { return get() != nullptr; } + + /** Get the underlying point (internal or external) */ + T *get() const + { + if (isExternal()) + { + return d_external_; + } + else + { + return d_internal_; + } + } + + /** Destructor - deallocate memory for internal pointer. */ + ~DevicePtrWrapper() + { + if (d_internal_) + { + gpu_free(d_internal_); + } + } + +private: + T *d_external_ = nullptr; + T *d_internal_ = nullptr; + size_t size_ = 0; +}; diff --git a/archive/cuda_extension/cuda/utils/Patches.h b/archive/cuda_extension/cuda/utils/Patches.h new file mode 100644 index 000000000..a0dbf111a --- /dev/null +++ b/archive/cuda_extension/cuda/utils/Patches.h @@ -0,0 +1,21 @@ +#pragma once +#include +#include + +// some GCC versions don't provide the following functions, so we patch them in + +namespace patch +{ +template +inline std::string to_string(const T& x) +{ + std::ostringstream sstr; + sstr << x; + return sstr.str(); +} +} // namespace patch + +namespace std +{ +using namespace ::patch; +} \ No newline at end of file diff --git a/archive/cuda_extension/cuda/utils/ScopedTimer.h b/archive/cuda_extension/cuda/utils/ScopedTimer.h new file mode 100644 index 000000000..8205cb981 --- /dev/null +++ b/archive/cuda_extension/cuda/utils/ScopedTimer.h @@ -0,0 +1,51 @@ +#pragma once + +#include "utils/CudaFunction.h" +#include "utils/Errors.h" +#include "utils/Timer.h" +#include + +/** If we do timing, this function syncs all device execution code first. + * + * Otherwise it doesn't do anything + */ +inline void timing_sync() +{ +#if DO_GPU_TIMING + checkCudaErrors(cudaDeviceSynchronize()); +#endif +} + +/** Scoped RAII-style timer class, that records times from construction + * to destruction and logs it in a CudaFunction object. + */ +class ScopedTimer +{ +public: + /** Constructor. Starts recording time immediately. + * + * @param func CudaFunction object to store the resulting time in. + * @param name Name of the operation that is timed. + */ + ScopedTimer(CudaFunction *func, const std::string &name) + : func_(func), name_(name) + { + } + + /** Stops timing and records the time in the CudaFunction given + * to the constructor (only if DO_GPU_TIMING is defined). + */ + ~ScopedTimer() + { +#if DO_GPU_TIMING + func_->times_.emplace_back(name_, t_.get_time()); +#endif + } + +private: +#if DO_GPU_TIMING + Timer t_; +#endif + CudaFunction *func_; + std::string name_; +}; \ No newline at end of file diff --git a/archive/cuda_extension/cuda/utils/Timer.h b/archive/cuda_extension/cuda/utils/Timer.h new file mode 100644 index 000000000..53f880bab --- /dev/null +++ b/archive/cuda_extension/cuda/utils/Timer.h @@ -0,0 +1,30 @@ +#pragma once + +#include + +/** Generic timer class, based on std::chrono . + * + * Use as: + * @code + * Timer t; + * ... // do expensive stuff + * auto time = t.get_time(); // in ms + * @encode + */ +class Timer +{ +public: + Timer() { start(); } + void start() { start_ = std::chrono::high_resolution_clock::now(); } + double get_time() + { + auto end = std::chrono::high_resolution_clock::now(); + return double(std::chrono::duration_cast(end - + start_) + .count()) / + 1e3; + } + +private: + std::chrono::high_resolution_clock::time_point start_; +}; diff --git a/archive/cuda_extension/engines/DM_gpu.py b/archive/cuda_extension/engines/DM_gpu.py new file mode 100644 index 000000000..399eb143c --- /dev/null +++ b/archive/cuda_extension/engines/DM_gpu.py @@ -0,0 +1,189 @@ +# -*- coding: utf-8 -*- +""" +Difference Map reconstruction engine that uses numpy arrays instead of iteration. + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" + +import time + +from ..utils import parallel +from .DM_npy import DMNpy +from ptypy import defaults_tree +from ..core.manager import Full, Vanilla +from archive.cuda_extension.accelerate.cuda import difference_map_iterator +from . import register +import numpy as np + +__all__ = ['DMGpu'] + + +@register() +class DMGpu(DMNpy): + """ + A full-fledged Difference Map engine that uses numpy arrays instead of iteration. + + + Defaults: + + [name] + default = DMGpu + type = str + help = + doc = + + [alpha] + default = 1 + type = float + lowlim = 0.0 + help = Difference map parameter + + [probe_update_start] + default = 2 + type = int + lowlim = 0 + help = Number of iterations before probe update starts + + [subpix_start] + default = 0 + type = int + lowlim = 0 + help = Number of iterations before starting subpixel interpolation + + [subpix] + default = 'linear' + type = str + help = Subpixel interpolation; 'fourier','linear' or None for no interpolation + + [update_object_first] + default = True + type = bool + help = If True update object before probe + + [overlap_converge_factor] + default = 0.05 + type = float + lowlim = 0.0 + help = Threshold for interruption of the inner overlap loop + doc = The inner overlap loop refines the probe and the object simultaneously. This loop is escaped as soon as the overall change in probe, relative to the first iteration, is less than this value. + + [overlap_max_iterations] + default = 10 + type = int + lowlim = 1 + help = Maximum of iterations for the overlap constraint inner loop + + [probe_inertia] + default = 1e-9 + type = float + lowlim = 0.0 + help = Weight of the current probe estimate in the update + + [object_inertia] + default = 1e-4 + type = float + lowlim = 0.0 + help = Weight of the current object in the update + + [fourier_relax_factor] + default = 0.05 + type = float + lowlim = 0.0 + help = If rms error of model vs diffraction data is smaller than this fraction, Fourier constraint is met + doc = Set this value higher for noisy data. + + [obj_smooth_std] + default = None + type = int + lowlim = 0 + help = Gaussian smoothing (pixel) of the current object prior to update + doc = If None, smoothing is deactivated. This smoothing can be used to reduce the amplitude of spurious pixels in the outer, least constrained areas of the object. + + [clip_object] + default = None + type = tuple + help = Clip object amplitude into this interval + + [probe_center_tol] + default = None + type = float + lowlim = 0.0 + help = Pixel radius around optical axes that the probe mass center must reside in + + """ + + SUPPORTED_MODELS = [Vanilla, Full] + + def __init__(self, ptycho_parent, pars=None): + """ + Difference map reconstruction engine. + """ + super(DMGpu, self).__init__(ptycho_parent, pars) + + def engine_iterate(self, num=1): + """ + Compute `num` iterations. + """ + + for dID, _diffs in self.di.S.items(): + + cfact_probe = (self.p.probe_inertia * len(self.vectorised_scan[dID]['meta']['addr']) / + self.vectorised_scan[dID]['probe'].shape[0]) * np.ones_like( + self.vectorised_scan[dID]['probe']) + + + cfact_object = self.p.object_inertia * self.mean_power * (self.vectorised_scan[dID]['object viewcover'] + 1.) + + + pre_fft = self.propagator[dID].pre_fft + post_fft = self.propagator[dID].post_fft + psupp = self.probe_support[self.vectorised_scan[dID]['meta']['poe_IDs'][0]].astype(np.complex64) + #print("{}, {}".format(psupp.shape, psupp.dtype)) + + errors =difference_map_iterator(diffraction=self.vectorised_scan[dID]['diffraction'], + obj=self.vectorised_scan[dID]['obj'], + object_weights=self.vectorised_scan[dID]['object weights'].astype(np.float32), + cfact_object=cfact_object, + mask=self.vectorised_scan[dID]['mask'], + probe=self.vectorised_scan[dID]['probe'], + cfact_probe=cfact_probe, + probe_support=psupp, #self.probe_support[self.vectorised_scan[dID]['meta']['poe_IDs'][0]], + probe_weights=self.vectorised_scan[dID]['probe weights'].astype(np.float32), + exit_wave=self.vectorised_scan[dID]['exit wave'], + addr=self.vectorised_scan[dID]['meta']['addr'], + pre_fft=pre_fft, + post_fft=post_fft, + pbound=self.pbound[dID], + overlap_max_iterations=self.p.overlap_max_iterations, + update_object_first=self.p.update_object_first, + obj_smooth_std=self.p.obj_smooth_std, + overlap_converge_factor=self.p.overlap_converge_factor, + probe_center_tol=self.p.probe_center_tol, + probe_update_start=0, + alpha=self.p.alpha, + clip_object=self.p.clip_object, + LL_error=True, + num_iterations=num) + + + #yuk yuk yuk + error_dct = {} + print(errors.shape) + jx =0 + for jx in range(num): + k = 0 + for idx, name in self.di.views.items(): + error_dct[idx] = errors[jx, :, k] + k += 1 + jx +=1 + error = parallel.gather_dict(error_dct) + + # count up + self.curiter += num + + return error + + \ No newline at end of file diff --git a/archive/cuda_extension/engines/DM_npy.py b/archive/cuda_extension/engines/DM_npy.py new file mode 100644 index 000000000..f601a46dd --- /dev/null +++ b/archive/cuda_extension/engines/DM_npy.py @@ -0,0 +1,286 @@ +# -*- coding: utf-8 -*- +""" +Difference Map reconstruction engine that uses numpy arrays instead of iteration. + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" + +from ..utils import parallel +from .DM import DM +from ..core.manager import Full, Vanilla +from ptypy.accelerate.array_based import constraints as con, data_utils as du +import numpy as np +from . import register + +#from memory_profiler import profile +__all__ = ['DMNpy'] + + +@register() +class DMNpy(DM): + """ + A full-fledged Difference Map engine that uses numpy arrays instead of iteration. + + + Defaults: + + [name] + default = DMNpy + type = str + help = + doc = + + [alpha] + default = 1 + type = float + lowlim = 0.0 + help = Difference map parameter + + [probe_update_start] + default = 2 + type = int + lowlim = 0 + help = Number of iterations before probe update starts + + [subpix_start] + default = 0 + type = int + lowlim = 0 + help = Number of iterations before starting subpixel interpolation + + [subpix] + default = 'linear' + type = str + help = Subpixel interpolation; 'fourier','linear' or None for no interpolation + + [update_object_first] + default = True + type = bool + help = If True update object before probe + + [overlap_converge_factor] + default = 0.05 + type = float + lowlim = 0.0 + help = Threshold for interruption of the inner overlap loop + doc = The inner overlap loop refines the probe and the object simultaneously. This loop is escaped as soon as the overall change in probe, relative to the first iteration, is less than this value. + + [overlap_max_iterations] + default = 10 + type = int + lowlim = 1 + help = Maximum of iterations for the overlap constraint inner loop + + [probe_inertia] + default = 1e-9 + type = float + lowlim = 0.0 + help = Weight of the current probe estimate in the update + + [object_inertia] + default = 1e-4 + type = float + lowlim = 0.0 + help = Weight of the current object in the update + + [fourier_relax_factor] + default = 0.05 + type = float + lowlim = 0.0 + help = If rms error of model vs diffraction data is smaller than this fraction, Fourier constraint is met + doc = Set this value higher for noisy data. + + [obj_smooth_std] + default = None + type = int + lowlim = 0 + help = Gaussian smoothing (pixel) of the current object prior to update + doc = If None, smoothing is deactivated. This smoothing can be used to reduce the amplitude of spurious pixels in the outer, least constrained areas of the object. + + [clip_object] + default = None + type = tuple + help = Clip object amplitude into this interval + + [probe_center_tol] + default = None + type = float + lowlim = 0.0 + help = Pixel radius around optical axes that the probe mass center must reside in + + """ + + SUPPORTED_MODELS = [Vanilla, Full] + + def __init__(self, ptycho_parent, pars=None): + """ + Difference map reconstruction engine. + """ + super(DMNpy, self).__init__(ptycho_parent, pars) + + def engine_initialize(self): + self.error = [] + self.ob_viewcover = self.ob.copy(self.ob.ID + '_vcover', fill=0.) + + def engine_prepare(self): + """ + Last minute initialization. + + Everything that needs to be recalculated when new data arrives. + """ + super(DMNpy, self).engine_prepare() + # and then something to convert the arrays to numpy + self.vectorised_scan = {} + self.propagator = {} + for dID, _diffs in self.di.S.items(): + self.vectorised_scan[dID] = du.pod_to_arrays(self, dID) + first_view_id = self.vectorised_scan[dID]['meta']['view_IDs'][0] + self.propagator[dID] = self.di.V[first_view_id].pod.geometry.propagator + + + + def engine_iterate(self, num=1): + """ + Compute `num` iterations. + """ + to = 0. + tf = 0. + # num=5 + for dID, _diffs in self.di.S.items(): + + + + + + + cfact_probe = (self.p.probe_inertia * len(self.vectorised_scan[dID]['meta']['addr']) / + self.vectorised_scan[dID]['probe'].shape[0]) * np.ones_like( + self.vectorised_scan[dID]['probe']) + + + + + cfact_object = self.p.object_inertia * self.mean_power * (self.vectorised_scan[dID]['object viewcover'] + 1.) + + # path_to_numpy_file = "/dls/mx-scratch/aaron/gpu_real_world_test_cases/i08_iterate_inputs_p100_2modes.npy" + # path_to_hdf_file = "/dls/mx-scratch/aaron/gpu_real_world_test_cases/i08_iterate_inputs_p100_2modes.h5" + + # import h5py as h5 + + # print "saving out the data" + # f = h5.File(path_to_hdf_file, 'w') + # f['diffraction'] = self.vectorised_scan[dID]['diffraction'] + # f['exit_wave'] = self.vectorised_scan[dID]['exit wave'] + # f['mask'] = self.vectorised_scan[dID]['mask'] + # f['probe'] = self.vectorised_scan[dID]['probe'] + # f['obj'] = self.vectorised_scan[dID]['obj'] + # f.close() + # print "done" + + probe_support = self.probe_support[self.vectorised_scan[dID]['meta']['poe_IDs'][0]] + mean_power = self.mean_power + object_weights = self.vectorised_scan[dID]['object weights'] + probe_weights = self.vectorised_scan[dID]['probe weights'] + pbound = self.pbound + object_viewcover = self.vectorised_scan[dID]['object viewcover'] + # overlap_max_iterations = self.vectorised_scan[dID]['overlap_max_iterations'] + # update_object_first = self.vectorised_scan[dID]['update_object_first'] + # obj_smooth_std = self.vectorised_scan[dID]['obj_smooth_std'] + # overlap_converge_factor = self.vectorised_scan[dID]['overlap_converge_factor'] + # probe_center_tol = self.vectorised_scan[dID]['probe_center_tol'] + # update_probe_after = self.vectorised_scan[dID]['update_probe_after'] + # alpha = self.vectorised_scan[dID]['alpha'] + # clip_object = self.vectorised_scan[dID]['clip_object'] + # LL_error = self.vectorised_scan[dID]['LL_error'] + # cfact_object = self.vectorised_scan[dID]['cfact_object'] + # cfact_probe = self.vectorised_scan[dID]['cfact_probe'] + pre_fft = self.propagator[dID].pre_fft + post_fft = self.propagator[dID].post_fft + # + # out_dict = {'pre_fft': pre_fft, + # 'post_fft' :post_fft, + # 'probe_support': self.probe_support[self.vectorised_scan[dID]['meta']['poe_IDs'][0]], + # 'mean_power': mean_power, + # 'object weights': object_weights, + # 'probe weights': probe_weights, + # 'pbound': pbound, + # 'object_viewcover': object_viewcover, + # 'overlap_max_iterations': self.p.overlap_max_iterations, + # 'update_object_first': self.p.update_object_first, + # 'obj_smooth_std' : self.p.obj_smooth_std, + # 'overlap_converge_factor': self.p.overlap_converge_factor, + # 'probe_center_tol': self.p.probe_center_tol, + # 'update_probe_after' : 0, + # 'alpha' : self.p.alpha, + # 'clip_object' : self.p.clip_object, + # 'LL_error' : False, + # 'cfact_object': cfact_object, + # 'cfact_probe': cfact_probe, + # 'pre_fft' : pre_fft, + # 'post_fft': post_fft, + # 'addr' : self.vectorised_scan[dID]['meta']['addr'] + # } + # print "saving out the metadata" + # np.save(path_to_numpy_file, out_dict) + # print "done" + errors = con.difference_map_iterator(diffraction=self.vectorised_scan[dID]['diffraction'], + obj=self.vectorised_scan[dID]['obj'], + object_weights=self.vectorised_scan[dID]['object weights'], + cfact_object=cfact_object, + mask=self.vectorised_scan[dID]['mask'], + probe=self.vectorised_scan[dID]['probe'], + cfact_probe=cfact_probe, + probe_support=self.probe_support[self.vectorised_scan[dID]['meta']['poe_IDs'][0]], + probe_weights=self.vectorised_scan[dID]['probe weights'], + exit_wave=self.vectorised_scan[dID]['exit wave'], + addr=self.vectorised_scan[dID]['meta']['addr'], + pre_fft=pre_fft, + post_fft=post_fft, + pbound=self.pbound[dID], + overlap_max_iterations=self.p.overlap_max_iterations, + update_object_first=self.p.update_object_first, + obj_smooth_std=self.p.obj_smooth_std, + overlap_converge_factor=self.p.overlap_converge_factor, + probe_center_tol=self.p.probe_center_tol, + probe_update_start=0, + alpha=self.p.alpha, + clip_object=self.p.clip_object, + LL_error=True, + num_iterations=num) + + + + + #yuk yuk yuk + error_dct = {} + print(errors.shape) + jx =0 + for jx in range(num): + k = 0 + for idx, name in self.di.views.items(): + error_dct[idx] = errors[jx, :, k] + k += 1 + jx +=1 + error = parallel.gather_dict(error_dct) + # t3 = time.time() + # to += t3 - t2 + + # count up + self.curiter += num + + # self.mpi_numpy_overlap_update() + # logger.info('Time spent in Fourier update: %.2f' % tf) + # logger.info('Time spent in Overlap update: %.2f' % to) + # error = parallel.gather_dict(error_dct) + return error + + def engine_finalize(self): + """ + Try deleting ever helper container. + """ + + del self.ptycho.containers[self.ob_viewcover.ID] + del self.ob_viewcover diff --git a/archive/cuda_extension/engines/gpu_testing.py b/archive/cuda_extension/engines/gpu_testing.py new file mode 100644 index 000000000..2a03de716 --- /dev/null +++ b/archive/cuda_extension/engines/gpu_testing.py @@ -0,0 +1,177 @@ +#from pytpy.array_based import COMPLEX_TYPE, FLOAT_TYPE +import numpy as np + +from archive.cuda_extension.accelerate.cuda import difference_map_fourier_constraint +#from ptypy.accelerate.array_based.constraints import difference_map_fourier_constraint + +from archive.cuda_extension.accelerate.cuda import difference_map_overlap_update +#from ptypy.accelerate.array_based.constraints import difference_map_overlap_update + + +from archive.cuda_extension.accelerate.cuda import far_field_error, realspace_error +#from ptypy.accelerate.array_based.error_metrics import far_field_error, realspace_error + +#from ptypy.accelerate.array_based.error_metrics import log_likelihood +from archive.cuda_extension.accelerate.cuda import log_likelihood + +from archive.cuda_extension.accelerate.cuda import difference_map_realspace_constraint +#from ptypy.accelerate.array_based.object_probe_interaction import difference_map_realspace_constraint + +from archive.cuda_extension.accelerate.cuda import scan_and_multiply +#from ptypy.accelerate.array_based.object_probe_interaction import scan_and_multiply + +from archive.cuda_extension.accelerate.cuda import renormalise_fourier_magnitudes +#from ptypy.accelerate.array_based.constraints import renormalise_fourier_magnitudes + +from archive.cuda_extension.accelerate.cuda import get_difference +#from ptypy.accelerate.array_based.constraints import get_difference + +from archive.cuda_extension.accelerate.cuda import abs2 +#from ptypy.accelerate.array_based.array_utils import abs2 + +from archive.cuda_extension.accelerate.cuda import sum_to_buffer +#from ptypy.accelerate.array_based.array_utils import sum_to_buffer + +from archive.cuda_extension.accelerate.cuda import farfield_propagator +#from ptypy.accelerate.array_based.propagation import farfield_propagator + + +FLOAT_TYPE = np.float32 +COMPLEX_TYPE = np.complex64 + +# def difference_map_fourier_constraint(mask, Idata, obj, probe, exit_wave, addr_info, prefilter, postfilter, pbound=None, alpha=1.0, LL_error=True, do_realspace_error=True): +# ''' +# This kernel just performs the fourier renormalisation. +# :param mask. The nd mask array +# :param diffraction. The nd diffraction data +# :param farfield_stack. The current iterant. +# :param addr. The addresses of the stacks. +# :return: The updated iterant +# : fourier errors +# ''' + +# probe_object = scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + +# # Buffer for accumulated photons +# # For log likelihood error # need to double check this adp +# if LL_error is True: +# print("probe_object={}, {}".format(probe_object.shape, probe_object.dtype)) +# print("mask={}, {}".format(mask.shape, mask.dtype)) +# print("Idata={}, {}".format(Idata.shape, Idata.dtype)) +# print("prefilter={}, {}".format(prefilter.shape, prefilter.dtype)) +# print("postfilter={}, {}".format(postfilter.shape, postfilter.dtype)) +# print("addr_info={}, {}".format(addr_info.shape, addr_info.dtype)) +# err_phot = log_likelihood(probe_object, mask, Idata, prefilter, postfilter, addr_info) +# print("err_phot={}, {}".format(err_phot.shape, err_phot.dtype)) +# else: +# err_phot = np.zeros(Idata.shape[0], dtype=FLOAT_TYPE) + + +# constrained = difference_map_realspace_constraint(probe_object, exit_wave, alpha) +# #print("constrained=\n{}".format(constrained[0])) +# #constr = constrained.flatten() +# #for i in xrange(1000): +# # if abs(constr[i]) > 0.0: +# # print("{}: {}".format(i, constr[i])) + +# f = farfield_propagator(constrained, prefilter, postfilter, direction='forward') +# pa, oa, ea, da, ma = zip(*addr_info) +# af2 = sum_to_buffer(abs2(f), Idata.shape, ea, da, dtype=FLOAT_TYPE) + +# fmag = np.sqrt(np.abs(Idata)) +# af = np.sqrt(af2) +# # # Fourier magnitudes deviations(current_solution, pbound, measured_solution, mask, addr) +# err_fmag = far_field_error(af, fmag, mask) + +# # print("f={}, {}".format(f.shape, f.dtype)) +# # print("af={}, {}".format(af.shape, af.dtype)) +# # print("fmag={}, {}".format(fmag.shape, fmag.dtype)) +# # print("mask={}, {}".format(mask.shape, mask.dtype)) +# # print("err_fmag={}, {}".format(err_fmag.shape, err_fmag.dtype)) +# # print("addr_info={}, {}".format(addr_info.shape, addr_info.dtype)) +# # print("pbound={}".format(pbound)) +# vectorised_rfm = renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + +# # print("vectorised_rfm={}, {}".format(vectorised_rfm.shape, vectorised_rfm.dtype)) + +# backpropagated_solution = farfield_propagator(vectorised_rfm, +# postfilter.conj(), +# prefilter.conj(), +# direction='backward') + + +# df = get_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, probe_object) + + + +# exit_wave += df +# if do_realspace_error: +# ea_first_column = np.array(ea)[:, 0] +# da_first_column = np.array(da)[:, 0] +# err_exit = realspace_error(df, ea_first_column, da_first_column, Idata.shape[0]) +# else: +# err_exit = np.zeros((Idata.shape[0])) + +# if pbound is not None: +# err_fmag /= pbound + +# #print("err_fmag: {}".format(err_fmag.shape)) +# #print("err_phot: {}".format(err_phot.shape)) +# #print("err_exit: {}".format(err_exit.shape)) +# return np.array([err_fmag, err_phot, err_exit]) + + + +def difference_map_iterator(diffraction, obj, object_weights, cfact_object, mask, probe, cfact_probe, probe_support, + probe_weights, exit_wave, addr, pre_fft, post_fft, pbound, overlap_max_iterations, update_object_first, + obj_smooth_std, overlap_converge_factor, probe_center_tol, probe_update_start, alpha=1, + clip_object=None, LL_error=False, num_iterations=1): + curiter = 0 + + errors = np.zeros((num_iterations, 3, len(diffraction)), dtype=FLOAT_TYPE) + for it in range(num_iterations): + if (((it+1) % 10) == 0) and (it>0): + print("iteration:%s" % (it+1)) # it's probably a good idea to print this if possible for some idea of progress + # numpy dump here for 64x64 and 4096x4096 + + #print("mask: {}".format(mask.shape)) + #print("diffraction: {}".format(diffraction.shape)) + #print("obj: {}".format(obj.shape)) + #print("probe: {}".format(probe.shape)) + #print("exit_wave: {}".format(exit_wave.shape)) + #print("addr: {}".format(addr.shape)) + #print("prefilter: {}".format(pre_fft.shape)) + #print("postfiler: {}".format(post_fft.shape)) + err = difference_map_fourier_constraint(mask, + diffraction, + obj, + probe, + exit_wave, + addr, + prefilter=pre_fft, + postfilter=post_fft, + pbound=pbound, + alpha=alpha, + LL_error=LL_error) + #print("err: {}".format(err.shape)) + errors[it] = err + + do_update_probe = (probe_update_start <= curiter) + difference_map_overlap_update(addr, + cfact_object, + cfact_probe, + do_update_probe, + exit_wave, + obj, + object_weights, + probe, + probe_support, + probe_weights, + overlap_max_iterations, + update_object_first, + obj_smooth_std, + overlap_converge_factor, + probe_center_tol, + clip_object=clip_object) + curiter += 1 + return errors \ No newline at end of file diff --git a/archive/cuda_extension/extensions.py b/archive/cuda_extension/extensions.py new file mode 100644 index 000000000..f0dfc0010 --- /dev/null +++ b/archive/cuda_extension/extensions.py @@ -0,0 +1,102 @@ +''' +These are the optional extensions for ptypy +''' + + +from distutils.version import LooseVersion +from distutils.extension import Extension +import os +import multiprocessing +import subprocess +import re +import numpy as np + + +# this is a hacky version, but is the desired behaviour +class AccelerationExtension(object): + def __init__(self, debug=False): + self.debug = debug + self._options = None + + def get_full_options(self): + return self._options + + def get_reflection_options(self): + user_options = [] + boolean_options = [] + for name, description in self._options.items(): + if isinstance(description['default'], str): + user_options.append((name+'=', None, description['doc'])) + elif isinstance(description['default'], bool): + user_options.append((name, None, description['doc'])) + boolean_options.append(name) + else: + raise NotImplementedError("Don't know what to do with parameter:%s of type: %s" % (name, type(description['default']))) + return user_options, boolean_options + + def build(self, options): + raise NotImplementedError('You need to implement the build method!') + + def getExtension(self): + raise NotImplementedError('You need to return cython extension object.') + + +class CudaExtension(AccelerationExtension): # probably going to inherit from something. + def __init__(self, *args, **kwargs): + super(CudaExtension, self).__init__(*args, **kwargs) + self._options = {'cudadir': {'default': '', + 'doc': 'CUDA directory'}, + 'cudaflags': {'default': '-gencode arch=compute_35,\\"code=sm_35\\" ' + + '-gencode arch=compute_37,\\"code=sm_37\\" ' + + '-gencode arch=compute_52,\\"code=sm_52\\" ' + + '-gencode arch=compute_60,\\"code=sm_60\\" ' + + '-gencode arch=compute_70,\\"code=sm_70\\" ', + 'doc': 'Flags to the CUDA compiler'}, + 'gputiming': {'default': False, + 'doc': 'Do GPU timing'}} + + def build(self, options): + cudadir = options['cudadir'] + cudaflags = options['cudaflags'] + gputiming = options['gputiming'] + try: + out = subprocess.check_output(['cmake', '--version']) + except OSError: + raise RuntimeError( + "CMake must be installed to build the CUDA extensions.") + + cmake_version = LooseVersion(re.search(r'version\s*([\d.]+)', + out.decode()).group(1)) + if cmake_version < '3.8.0': + raise RuntimeError("CMake >= 3.8.0 is required") + + srcdir = os.path.abspath('cuda') + buildtmp = os.path.abspath(os.path.join('build', 'cuda')) + cmake_args = [ + "-DCMAKE_BUILD_TYPE=" + ("Debug" if self.debug else "Release"), + '-DCMAKE_CUDA_FLAGS={}'.format(cudaflags), + '-DGPU_TIMING={}'.format("ON" if gputiming else "OFF") + ] + if cudadir: + cmake_args += '-DCMAKE_CUDA_COMPILER="{}/bin/nvcc"'.format(cudadir) + build_args = ["--config", "Debug" if self.debug else "Release", "--", "-j{}".format(multiprocessing.cpu_count() + 1)] + if not os.path.exists(buildtmp): + os.makedirs(buildtmp) + env = os.environ.copy() + subprocess.check_call(['cmake', srcdir] + cmake_args, + cwd=buildtmp, env=env) + subprocess.check_call(['cmake', '--build', '.'] + build_args, + cwd=buildtmp) + print("Complete.") + + def getExtension(self): + libdirs = ['build/cuda'] + if 'LD_LIBRARY_PATH' in os.environ: + libdirs += os.environ['LD_LIBRARY_PATH'].split(':') + return Extension('*', + sources=['ptypy/accelerate/cuda/gpu_extension.pyx'], + include_dirs=[np.get_include()], + libraries=['gpu_extension', 'cudart', 'cufft'], + library_dirs=libdirs, + depends=['build/cuda/libgpu_extension.a', ], + language="c++") diff --git a/archive/cuda_extension/minimal_DMGpu_iterate_benchmark.py b/archive/cuda_extension/minimal_DMGpu_iterate_benchmark.py new file mode 100644 index 000000000..861c368a3 --- /dev/null +++ b/archive/cuda_extension/minimal_DMGpu_iterate_benchmark.py @@ -0,0 +1,53 @@ +from ptypy.core import Ptycho +from ptypy import utils as u +import cProfile +p = u.Param() +p.verbose_level = 3 +p.io = u.Param() +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.ipython_kernel = False +p.scans = u.Param() +p.scans.MF = u.Param() +p.scans.MF.name = 'Full' +p.scans.MF.propagation = 'farfield' +p.scans.MF.data = u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.positions_theory = None +p.scans.MF.data.auto_center = None +p.scans.MF.data.min_frames = 1 +p.scans.MF.data.orientation = None +p.scans.MF.data.num_frames = 500 +p.scans.MF.data.energy = 6.2 +p.scans.MF.data.shape = 64 +p.scans.MF.data.chunk_format = '.chunk%02d' +p.scans.MF.data.rebin = None +p.scans.MF.data.experimentID = None +p.scans.MF.data.label = None +p.scans.MF.data.version = 0.1 +p.scans.MF.data.dfile = None +p.scans.MF.data.psize = 0.000172 +p.scans.MF.data.load_parallel = None +p.scans.MF.data.distance = 7.0 +p.scans.MF.data.save = None +p.scans.MF.data.center = 'fftshift' +p.scans.MF.data.photons = 100000000.0 +p.scans.MF.data.psf = 0.2 +p.scans.MF.data.density = 0.2 +p.scans.MF.data.add_poisson_noise = False +p.scans.MF.coherence = u.Param() +p.scans.MF.coherence.num_probe_modes = 2 # currently breaks when this is =2 + +p.engines = u.Param() + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DMGpu' +p.engines.engine00.numiter = 500 +# p.engines.engine00.overlap_max_iterations = 1 +# prepare and run + + +P = Ptycho(p, level=4) +P.run() diff --git a/archive/cuda_extension/minimal_DMNpy_iterate_benchmark.py b/archive/cuda_extension/minimal_DMNpy_iterate_benchmark.py new file mode 100644 index 000000000..499bda25e --- /dev/null +++ b/archive/cuda_extension/minimal_DMNpy_iterate_benchmark.py @@ -0,0 +1,53 @@ +from ptypy.core import Ptycho +from ptypy import utils as u +import cProfile +p = u.Param() +p.verbose_level = 3 +p.io = u.Param() +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=True) +p.ipython_kernel = False +p.scans = u.Param() +p.scans.MF = u.Param() +p.scans.MF.name = 'Full' +p.scans.MF.propagation = 'farfield' +p.scans.MF.data = u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.positions_theory = None +p.scans.MF.data.auto_center = None +p.scans.MF.data.min_frames = 1 +p.scans.MF.data.orientation = None +p.scans.MF.data.num_frames = 500 +p.scans.MF.data.energy = 6.2 +p.scans.MF.data.shape = 64 +p.scans.MF.data.chunk_format = '.chunk%02d' +p.scans.MF.data.rebin = None +p.scans.MF.data.experimentID = None +p.scans.MF.data.label = None +p.scans.MF.data.version = 0.1 +p.scans.MF.data.dfile = None +p.scans.MF.data.psize = 0.000172 +p.scans.MF.data.load_parallel = None +p.scans.MF.data.distance = 7.0 +p.scans.MF.data.save = None +p.scans.MF.data.center = 'fftshift' +p.scans.MF.data.photons = 100000000.0 +p.scans.MF.data.psf = 0.2 +p.scans.MF.data.density = 0.2 +p.scans.MF.data.add_poisson_noise = False +p.scans.MF.coherence = u.Param() +p.scans.MF.coherence.num_probe_modes = 2 # currently breaks when this is =2 + +p.engines = u.Param() + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DMNpy' +p.engines.engine00.numiter = 500 +# p.engines.engine00.overlap_max_iterations = 1 +# prepare and run + + +P = Ptycho(p, level=4) +P.run() diff --git a/archive/cuda_extension/python/__init__.py b/archive/cuda_extension/python/__init__.py new file mode 100644 index 000000000..4221257bd --- /dev/null +++ b/archive/cuda_extension/python/__init__.py @@ -0,0 +1,7 @@ +''' +A module for gpu acceleration + +''' +import numpy as np +COMPLEX_TYPE= np.complex64 +FLOAT_TYPE = np.float32 \ No newline at end of file diff --git a/archive/cuda_extension/python/array_utils.py b/archive/cuda_extension/python/array_utils.py new file mode 100644 index 000000000..c065738ce --- /dev/null +++ b/archive/cuda_extension/python/array_utils.py @@ -0,0 +1,8 @@ +''' +useful utilities from ptypy that should be ported to gpu. These don't ahve external dependencies +''' +import numpy as np +from . import COMPLEX_TYPE +from .gpu_extension import abs2, sum_to_buffer, sum_to_buffer_stride, \ + norm2, mass_center, clip_complex_magnitudes_to_range, interpolated_shift, \ + complex_gaussian_filter diff --git a/archive/cuda_extension/python/config.py b/archive/cuda_extension/python/config.py new file mode 100644 index 000000000..f874dbb41 --- /dev/null +++ b/archive/cuda_extension/python/config.py @@ -0,0 +1,17 @@ +from .gpu_extension import get_num_gpus, \ + get_gpu_compute_capability, select_gpu_device, \ + get_gpu_memory_mb, get_gpu_name, reset_function_cache + +def init_gpus(device = 0): + n = get_num_gpus() + if n > 0: + print("Detected GPUs:") + for i in range(n): + comp = get_gpu_compute_capability(i) + mem = get_gpu_memory_mb(i) + name = get_gpu_name(i) + print("{}: {} (Compute Capability: {}, Memory: {:.3f}GB)".format( + i, name, comp / 10.0, mem /1024.0 + )) + print("Initialising GPU {}...".format(device)) + select_gpu_device(device) diff --git a/archive/cuda_extension/python/constraints.py b/archive/cuda_extension/python/constraints.py new file mode 100644 index 000000000..1bde4bb86 --- /dev/null +++ b/archive/cuda_extension/python/constraints.py @@ -0,0 +1,13 @@ +''' +a module to holds the constraints +''' + +from .gpu_extension import ( + get_difference, + renormalise_fourier_magnitudes, + difference_map_fourier_constraint, + difference_map_iterator +) + + + diff --git a/archive/cuda_extension/python/cuda_functions.pxd b/archive/cuda_extension/python/cuda_functions.pxd new file mode 100644 index 000000000..2f7f4e297 --- /dev/null +++ b/archive/cuda_extension/python/cuda_functions.pxd @@ -0,0 +1,281 @@ +from libcpp.string cimport string + +cdef extern void difference_map_realspace_constraint_c( + const float* fobj_and_probe, + const float* fexit_wave, + float alpha, + int i, + int m, + int n, + float* fout +) except + + +cdef extern void scan_and_multiply_c( + const float* fprobe, + int i_probe, + int m_probe, + int n_probe, + const float* fobj, + int i_obj, + int m_obj, + int n_obj, + const int* addr_info, + int addr_len, + int batch_size, + int m, + int n, + float* fout +) except + + +cdef extern void sqrt_abs_c( + const float* indata, + float* outdata, + int m, + int n +) except + + +cdef extern void log_likelihood_c( + const float* probe_obj, + const unsigned char* mask, + const float* Idata, + const float* prefilter, + const float* postfilter, + const int* addr_info, + float* out, + int i, + int m, + int n, + int addr_i, + int Idata_i +) except + + +cdef extern void farfield_propagator_c( + const float* indata, + const float* prefilter, + const float* postfilter, + float* out, + int b, + int m, + int n, + int isForward +) except + + +cdef extern void sum_to_buffer_c(const float *in1, int in1_0, int in1_1, + int in1_2, float *out, int out_0, int out_1, + int out_2, const int *in_addr, int in_addr_0, + const int *out_addr, int out_addr_0, + int isComplex) except + +cdef extern void sum_to_buffer_stride_c(const float* in1, int in1_0, int in1_1, int in1_2, + float* out, int out_0, int out_1, int out_2, const int* addr_info, int addr_info_0, + int isComplex) except + + +cdef extern void abs2_c( + const float* indata, + float* out, + int n, + int isComplex +) except + + +cdef extern void abs2d_c( + const double* indata, + double* out, + int n, + int isComplex +) except + + +cdef extern void far_field_error_c( + const float* current, + const float* measured, + const unsigned char* mask, + float* out, + int i, int m, int n +) except + + +cdef extern void realspace_error_c( + const float* difference, + const int* ea_first_column, + const int* da_first_column, + int addr_len, + float* out, + int i, int m, int n, + int outlen +) except + + +cdef extern void get_difference_c( + const int* addr_info, + float alpha, + const float* fbackpropagated_solution, + const float* err_fmag, + const float* fexit_wave, + float pbound, + const float* fprobe_obj, + float* fout, + int i, int m, int n, + int usePbound +) except + + +cdef extern void renormalise_fourier_magnitudes_c( + const float* f_f, + const float* af, + const float* fmag, + const unsigned char* mask, + const float* err_fmag, + const int* addr_info, + float pbound, + float* f_out, + int M, int N, int A, int B, + int usePbound +) except + + +cdef extern void difference_map_fourier_constraint_c(const unsigned char *mask, + const float *Idata, + const float *f_obj, + const float *f_probe, + float *f_exit_wave, + const int *addr_info, + const float *f_prefilter, + const float *f_postfilter, + float pbound, + float alpha, + int do_LL_error, + int do_realspace_error, + int doPbound, + int M, + int N, + int A, + int B, + int C, + int D, + int ob_modes, + int pr_modes, + float *errors +) except + + +cdef extern void norm2_c(const float* data, float* out, int size, int isComplex) except + +cdef extern void mass_center_c(const float* data, int i, int m, int n, float* output) except + +cdef extern void clip_complex_magnitudes_to_range_c(float* f_data, int n, float clip_min, float clip_max) except + +cdef extern void extract_array_from_exit_wave_c( + const float* f_exit_wave, + int A, + int B, + int C, + const int* exit_addr, + const float* f_array_to_be_extracted, + int D, + int E, + int F, + const int* extract_addr, + float* f_array_to_be_updated, + int G, + int H, + int I, + const int* update_addr, + const float* weights, + const float* f_cfact +) except + +cdef extern void interpolated_shift_c(const float* f_in, float* f_out, int items, int rows, int columns, float offsetRow, float offsetCol, int doLinear) except+ +cdef extern int get_num_gpus_c() except + +cdef extern int get_gpu_compute_capability_c(int dev) except + +cdef extern void select_gpu_device_c(int dev) except + +cdef extern int get_gpu_memory_mb_c(int dev) except + +cdef extern string get_gpu_name_c(int dev) except + +cdef extern void reset_function_cache_c() except + +cdef extern void center_probe_c(float* f_probe, float center_tolerance, int i, int m, int n) except + +cdef extern float difference_map_update_probe_c( + const float* f_obj, + const float* probe_weights, + float* f_probe, + const float* f_exit_wave, + const int* addr_info, + const float* f_cfact_probe, + const float* f_probe_support, + int A, int B, int C, + int D, int E, int F, + int G, int H, int I +) except + +cdef extern void difference_map_update_object_c( + float* f_obj, + const float* object_weights, + const float* f_probe, + const float* f_exit_wave, + const int* addr_info, + const float* f_cfact_object, + float ob_smooth_std, + float clip_min, + float clip_max, + int doSmoothing, + int doClipping, + int A, int B, int C, int D, + int E, int F, int G, int H, int I) except + +cdef extern void difference_map_overlap_constraint_c( + const int* addr_info, + const float* f_cfact_object, + const float* f_cfact_probe, + const float* f_exit_wave, + float* f_obj, + const float* object_weights, + float* f_probe, + const float* f_probe_support, + const float* probe_weights, + float obj_smooth_std, + float clip_min, + float clip_max, + float probe_center_tol, + float overlap_converge_factor, + int max_iterations, + int doUpdateObjectFirst, + int doUpdateProbe, + int doSmoothing, + int doClipping, + int doCentering, + int A, int B, int C, int D, + int E, int F, int G, int H, int I) except + + + +cdef extern void complex_gaussian_filter_c(const float* f_input, + float* f_output, + const float* mfs, + int ndims, + const int* shape) except + +cdef extern void difference_map_iterator_c( + const float* diffraction, + float* f_obj, + const float* object_weights, + const float* f_cfact_object, + const unsigned char* mask, + float* f_probe, + const float* f_cfact_probe, + const float* f_probe_support, + const float* probe_weights, + float* f_exit_wave, + const int* addr_info, + const float* f_pre_fft, + const float* f_post_fft, + float* errors, + float pbound, + int overlap_max_iterations, + int doUpdateObjectFirst, + float obj_smooth_std, + float overlap_converge_factor, + float probe_center_tol, + int probe_update_start, + float alpha, + float clip_min, + float clip_max, + int do_LL_error, + int do_realspace_error, + int num_iterations, + int A, + int B, + int C, + int D, + int E, + int F, + int G, + int H, + int I, + int N, + int doSmoothing, + int doClipping, + int doCentering, + int doPbound) except+ \ No newline at end of file diff --git a/archive/cuda_extension/python/error_metrics.py b/archive/cuda_extension/python/error_metrics.py new file mode 100644 index 000000000..055e1ebb4 --- /dev/null +++ b/archive/cuda_extension/python/error_metrics.py @@ -0,0 +1,5 @@ +''' +A module of the relevant error metrics +''' + +from .gpu_extension import log_likelihood, far_field_error, realspace_error diff --git a/archive/cuda_extension/python/gpu_extension.pyx b/archive/cuda_extension/python/gpu_extension.pyx new file mode 100644 index 000000000..aa0b36402 --- /dev/null +++ b/archive/cuda_extension/python/gpu_extension.pyx @@ -0,0 +1,1020 @@ +''' +Wrapper of the CUDA extensions + +Contains all cython wrappers to the CUDA extension module, +to allow a single library build and interactions instead of many +''' + +import numpy as np +from . import COMPLEX_TYPE +from cuda_functions cimport * +cimport numpy as np +import cython +import time +from libcpp.string cimport string + +@cython.boundscheck(False) +@cython.wraparound(False) +def difference_map_realspace_constraint(obj_and_probe, exit_wave, alpha): + cdef np.complex64_t [:,:,::1] obj_and_probe_c = np.ascontiguousarray(obj_and_probe) + cdef np.complex64_t [:,:,::1] exit_wave_c = np.ascontiguousarray(exit_wave) + cdef float alpha_c = alpha + out = np.empty(exit_wave.shape, dtype=np.complex64, order='C') + cdef np.complex64_t [:,:,::1] out_c = out + difference_map_realspace_constraint_c( + &obj_and_probe_c[0,0,0], + &exit_wave_c[0,0,0], + alpha_c, + obj_and_probe.shape[0], + obj_and_probe.shape[1], + obj_and_probe.shape[2], + &out_c[0,0,0] + ) + return out + + + +@cython.boundscheck(False) +@cython.wraparound(False) +def scan_and_multiply(probe, obj, exit_shape, addresses): + cdef np.complex64_t [:,:,::1] probe_c = np.ascontiguousarray(probe) + cdef np.complex64_t [:,:,::1] obj_c = np.ascontiguousarray(obj) + cdef i_probe = probe.shape[0] + cdef m_probe = probe.shape[1] + cdef n_probe = probe.shape[2] + cdef i_obj = obj.shape[0] + cdef m_obj = obj.shape[1] + cdef n_obj = obj.shape[2] + cdef np.int32_t [:,:,::1] addr_info_c = np.ascontiguousarray(addresses) + cdef int addr_len = addresses.shape[0] + cdef batch_size = exit_shape[0] + cdef m = exit_shape[1] + cdef n = exit_shape[2] + out = np.empty(exit_shape, dtype=np.complex64, order='C') + cdef np.complex64_t [:,:,::1] out_c = out + scan_and_multiply_c( + &probe_c[0,0,0], + i_probe, m_probe, n_probe, + &obj_c[0,0,0], + i_obj, m_obj, n_obj, + &addr_info_c[0,0,0], + addr_len, + batch_size, m, n, + &out_c[0,0,0] + ) + return out + +@cython.wraparound(False) +@cython.boundscheck(False) +def farfield_propagator( + data_to_be_transformed not None, + prefilter=None, + postfilter=None, + direction='forward' + ): + cdef np.complex64_t [:,:,::1] x = np.ascontiguousarray(data_to_be_transformed) + out = np.empty_like(x) + cdef np.complex64_t [:,:,::1] out_c = out + + dtype = np.complex64 + + cdef np.complex64_t [:,::1] prefilter_c = None + if not prefilter is None: + prefilter_c = np.ascontiguousarray(prefilter.astype(dtype)) + + cdef np.complex64_t [:,::1] postfilter_c = None + if not postfilter is None: + postfilter_c = np.ascontiguousarray(postfilter.astype(dtype)) + + cdef b = data_to_be_transformed.shape[0] + cdef m = data_to_be_transformed.shape[1] + cdef n = data_to_be_transformed.shape[2] + cdef isForward = 0 + if direction == 'forward': + isForward = 1 + farfield_propagator_c( + &x[0,0,0], + &prefilter_c[0,0], + &postfilter_c[0,0], + &out_c[0,0,0], + b, m, n, isForward + ) + return out + + +@cython.boundscheck(False) +@cython.wraparound(False) +def sqrt_abs(np.complex64_t [:,::1] diffraction not None): + out = np.empty_like(diffraction) + cdef np.complex64_t[:,::1] out_c = out + cdef m = diffraction.shape[0] + cdef n = diffraction.shape[1] + sqrt_abs_c(&diffraction[0,0], &out_c[0,0], m, n) + return out + +@cython.boundscheck(False) +@cython.wraparound(False) +def log_likelihood(probe_obj, mask, Idata, prefilter, postfilter, addr_info): + cdef np.complex64_t [:,:,::1] probe_obj_c = np.ascontiguousarray(probe_obj) + cdef np.uint8_t [::1] mask_c = np.frombuffer(np.ascontiguousarray(mask.astype(np.bool)), dtype=np.uint8) + cdef np.float32_t [:,:,::1] Idata_c = np.ascontiguousarray(Idata) + cdef np.complex64_t [:,::1] prefilter_c = np.ascontiguousarray(prefilter) + cdef np.complex64_t [:,::1] postfilter_c = np.ascontiguousarray(postfilter) + cdef np.int32_t [:,:,::1] addr_info_c = np.ascontiguousarray(addr_info) + out = np.empty(Idata.shape[0], np.float32) + cdef np.float32_t [::1] out_c = out + cdef int i = probe_obj.shape[0] + cdef int m = probe_obj.shape[1] + cdef int n = probe_obj.shape[2] + log_likelihood_c( + &probe_obj_c[0,0,0], + &mask_c[0], + &Idata_c[0,0,0], + &prefilter_c[0,0], + &postfilter_c[0,0], + &addr_info_c[0,0,0], + &out_c[0], + i, m, n, addr_info.shape[0], + Idata.shape[0] + ) + return out + +@cython.boundscheck(False) +@cython.wraparound(False) +def abs2(input): + cin = np.ascontiguousarray(input) + outtype = cin.dtype + if cin.dtype == np.complex64: + outtype = np.float32 + elif cin.dtype == np.complex128: + outtype = np.float64 + cout = np.empty(cin.shape, dtype=outtype) + cdef np.float32_t [:,::1] cout_2c + cdef np.float32_t [:,:,::1] cout_3c + cdef np.float64_t [:,::1] cout_d2c + cdef np.float64_t [:,:,::1] cout_d3c + cdef int n = np.product(cin.shape) + + cdef np.float32_t [:, ::1] cin_f2c + cdef np.complex64_t [:, ::1] cin_c2c + cdef np.float32_t [:,:, ::1] cin_f3c + cdef np.complex64_t [:,:, ::1] cin_c3c + cdef np.float64_t [:, ::1] cin_d2c + cdef np.complex128_t [:, ::1] cin_z2c + cdef np.float64_t [:,:, ::1] cin_d3c + cdef np.complex128_t [:,:, ::1] cin_z3c + + if len(cin.shape) == 2: + if (cin.dtype == np.float32): + cout_2c = cout + cin_f2c = cin + abs2_c(&cin_f2c[0,0], &cout_2c[0,0], n, 0) + elif (cin.dtype == np.complex64): + cout_2c = cout + cin_c2c = cin + abs2_c(&cin_c2c[0,0], &cout_2c[0,0], n, 1) + elif (cin.dtype == np.float64): + cout_d2c = cout + cin_d2c = cin + abs2d_c(&cin_d2c[0,0], &cout_d2c[0,0], n, 0) + elif (cin.dtype == np.complex128): + cout_d2c = cout + cin_z2c = cin + abs2d_c(&cin_z2c[0,0], &cout_d2c[0,0], n, 1) + else: + raise ValueError("unsupported datatype {}".format(cin.dtype)) + elif len(cin.shape) == 3: + if (cin.dtype == np.float32): + cout_3c = cout + cin_f3c = cin + abs2_c(&cin_f3c[0,0,0], &cout_3c[0,0,0], n, 0) + elif (cin.dtype == np.complex64): + cout_3c = cout + cin_c3c = cin + abs2_c(&cin_c3c[0,0,0], &cout_3c[0,0,0], n, 1) + elif (cin.dtype == np.float64): + cout_d3c = cout + cin_d3c = cin + abs2d_c(&cin_d3c[0,0,0], &cout_d3c[0,0,0], n, 0) + elif (cin.dtype == np.complex128): + cout_d3c = cout + cin_z3c = cin + abs2d_c(&cin_z3c[0,0,0], &cout_d3c[0,0,0], n, 1) + else: + raise ValueError("unsupported datatype {}".format(cin.dtype)) + else: + raise ValueError("unsupported dimensionality: {}".format(len(cin.shape))) + return cout + +@cython.boundscheck(False) +@cython.wraparound(False) +def _sum_to_buffer_real(in1, outshape, in1_addr, out1_addr): + cdef np.float32_t [:,:,::1] in1_c = np.ascontiguousarray(in1) + cdef int os_0 = outshape[0] + cdef int os_1 = outshape[1] + cdef int os_2 = outshape[2] + cdef np.int32_t [:,:] in1_addr_c = np.ascontiguousarray(in1_addr) + cdef np.int32_t [:,:] out1_addr_c = np.ascontiguousarray(out1_addr) + out = np.empty(outshape, dtype=np.float32) + cdef np.float32_t [:,:,::1] out_c = out + # dimensions + cdef int in1_0 = in1.shape[0] + cdef int in1_1 = in1.shape[1] + cdef int in1_2 = in1.shape[2] + cdef int in_addr_0 = in1_addr.shape[0] + cdef int out_addr_0 = out1_addr.shape[0] + sum_to_buffer_c( + &in1_c[0,0,0], + in1_0, in1_1, in1_2, + &out_c[0,0,0], + os_0, os_1, os_2, + &in1_addr_c[0,0], + in_addr_0, + &out1_addr_c[0,0], + out_addr_0, + 0 + ) + return out + +@cython.boundscheck(False) +@cython.wraparound(False) +def _sum_to_buffer_stride_real(in1, outshape, addr_info): + cdef np.float32_t [:,:,::1] in1_c = np.ascontiguousarray(in1) + cdef int os_0 = outshape[0] + cdef int os_1 = outshape[1] + cdef int os_2 = outshape[2] + cdef np.int32_t [:,:,::1] addr_info_c = np.ascontiguousarray(addr_info) + out = np.empty(outshape, dtype=np.float32) + cdef np.float32_t [:,:,::1] out_c = out + # dimensions + cdef int in1_0 = in1.shape[0] + cdef int in1_1 = in1.shape[1] + cdef int in1_2 = in1.shape[2] + cdef int addr_info_0 = addr_info.shape[0] + sum_to_buffer_stride_c( + &in1_c[0,0,0], + in1_0, in1_1, in1_2, + &out_c[0,0,0], + os_0, os_1, os_2, + &addr_info_c[0,0,0], + addr_info_0, + 0 + ) + return out + +@cython.boundscheck(False) +@cython.wraparound(False) +def _sum_to_buffer_complex(in1, outshape, in1_addr, out1_addr): + cdef np.complex64_t [:,:,::1] in1_c = np.ascontiguousarray(in1) + cdef int os_0 = outshape[0] + cdef int os_1 = outshape[1] + cdef int os_2 = outshape[2] + cdef np.int32_t [:,:] in1_addr_c = np.ascontiguousarray(in1_addr) + cdef np.int32_t [:,:] out1_addr_c = np.ascontiguousarray(out1_addr) + out = np.empty(outshape, dtype=np.complex64) + cdef np.complex64_t [:,:,::1] out_c = out + # dimensions + cdef int in1_0 = in1.shape[0] + cdef int in1_1 = in1.shape[1] + cdef int in1_2 = in1.shape[2] + cdef int in_addr_0 = in1_addr.shape[0] + cdef int out_addr_0 = out1_addr.shape[0] + sum_to_buffer_c( + &in1_c[0,0,0], + in1_0, in1_1, in1_2, + &out_c[0,0,0], + os_0, os_1, os_2, + &in1_addr_c[0,0], + in_addr_0, + &out1_addr_c[0,0], + out_addr_0, + 1 + ) + return out + +@cython.boundscheck(False) +@cython.wraparound(False) +def _sum_to_buffer_stride_complex(in1, outshape, addr_info): + cdef np.complex64_t [:,:,::1] in1_c = np.ascontiguousarray(in1) + cdef int os_0 = outshape[0] + cdef int os_1 = outshape[1] + cdef int os_2 = outshape[2] + cdef np.int32_t [:,:,::1] addr_info_c = np.ascontiguousarray(addr_info) + out = np.empty(outshape, dtype=np.complex64) + cdef np.complex64_t [:,:,::1] out_c = out + # dimensions + cdef int in1_0 = in1.shape[0] + cdef int in1_1 = in1.shape[1] + cdef int in1_2 = in1.shape[2] + cdef int addr_info_0 = addr_info.shape[0] + sum_to_buffer_stride_c( + &in1_c[0,0,0], + in1_0, in1_1, in1_2, + &out_c[0,0,0], + os_0, os_1, os_2, + &addr_info_c[0,0,0], + addr_info_0, + 1 + ) + return out + +@cython.boundscheck(False) +@cython.wraparound(False) +def sum_to_buffer(in1, outshape, in1_addr, out1_addr, dtype): + if not isinstance(in1_addr, np.ndarray): + in1_addr = np.array(in1_addr, dtype=np.int32) + if not isinstance(out1_addr, np.ndarray): + out1_addr = np.array(out1_addr, dtype=np.int32) + if dtype == np.float32: + return _sum_to_buffer_real(in1, outshape, in1_addr.astype(np.int32), out1_addr.astype(np.int32)) + elif dtype == np.complex64: + return _sum_to_buffer_complex(in1, outshape, in1_addr.astype(np.int32), out1_addr.astype(np.int32)) + +@cython.boundscheck(False) +@cython.wraparound(False) +def sum_to_buffer_stride(in1, outshape, addr_info, dtype): + if not isinstance(addr_info, np.ndarray): + addr_info = np.array(addr_info, dtype=np.int32) + if dtype == np.float32: + return _sum_to_buffer_stride_real(in1, outshape, addr_info.astype(np.int32)) + elif dtype == np.complex64: + return _sum_to_buffer_stride_complex(in1, outshape, addr_info.astype(np.int32)) + + +@cython.boundscheck(False) +@cython.wraparound(False) +def far_field_error(current_solution, measured_solution, mask): + cdef np.float32_t [:,:,::1] current_c = np.ascontiguousarray(current_solution) + cdef np.float32_t [:,:,::1] measured_c = np.ascontiguousarray(measured_solution) + cdef np.uint8_t [::1] mask_c = np.frombuffer(np.ascontiguousarray(mask.astype(np.bool)), dtype=np.uint8) + out = np.empty((current_c.shape[0],), np.float32) + cdef np.float32_t [::1] out_c = out + cdef i = current_solution.shape[0] + cdef m = current_solution.shape[1] + cdef n = current_solution.shape[2] + far_field_error_c( + ¤t_c[0,0,0], + &measured_c[0,0,0], + &mask_c[0], + &out_c[0], + i, m, n + ) + return out + +@cython.boundscheck(False) +@cython.wraparound(False) +def realspace_error(difference, ea_first_column, da_first_column, out_length): + cdef np.complex64_t [:,:,::1] difference_c = np.ascontiguousarray(difference) + out = np.empty((out_length,), dtype=np.float32) + cdef np.float32_t [::1] out_c = out + cdef i = difference.shape[0] + cdef m = difference.shape[1] + cdef n = difference.shape[2] + if not isinstance(ea_first_column, np.ndarray): + ea_first_column = np.array(ea_first_column, dtype=np.int32) + if not isinstance(da_first_column, np.ndarray): + da_first_column = np.array(da_first_column, dtype=np.int32) + cdef np.int32_t [::1] ea_first_column_c = np.ascontiguousarray(ea_first_column) + cdef np.int32_t [::1] da_first_column_c = np.ascontiguousarray(da_first_column) + cdef int addr_len = min(ea_first_column.shape[0], da_first_column.shape[0]) + cdef int out_length_c = out_length + realspace_error_c( + &difference_c[0,0,0], + &ea_first_column_c[0], + &da_first_column_c[0], + addr_len, + &out_c[0], + i, m, n, + out_length_c + ) + return out + +@cython.boundscheck(False) +@cython.wraparound(False) +def get_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, probe_object): + cdef np.int32_t [:,:,::1] addr_info_c = np.ascontiguousarray(addr_info) + cdef alpha_c = alpha + bp_sol = backpropagated_solution.astype(np.complex64) + cdef np.complex64_t [:,:,::1] bp_sol_c = np.ascontiguousarray(bp_sol) + err_fmag_f32 = err_fmag.astype(np.float32) + cdef np.float32_t [::1] err_fmag_c = np.ascontiguousarray(err_fmag_f32) + cdef np.complex64_t [:,:,::1] exit_wave_c = np.ascontiguousarray(exit_wave) + cdef pbound_c = 0.0 + if not pbound is None: + pbound_c = pbound + cdef np.complex64_t [:,:,::1] probe_obj_c = np.ascontiguousarray(probe_object) + out = np.empty_like(exit_wave) + cdef np.complex64_t [:,:,::1] out_c = out + cdef int i = exit_wave.shape[0] + cdef int m = exit_wave.shape[1] + cdef int n = exit_wave.shape[2] + get_difference_c( + &addr_info_c[0,0,0], + alpha_c, + &bp_sol_c[0,0,0], + &err_fmag_c[0], + &exit_wave_c[0,0,0], + pbound_c, + &probe_obj_c[0,0,0], + &out_c[0,0,0], + i, m, n, + 0 if pbound == None else 1 + ) + return out + +@cython.boundscheck(False) +@cython.wraparound(False) +def renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound): + cdef np.complex64_t [:,:,::1] f_c = np.ascontiguousarray(f) + cdef np.float32_t [:,:,::1] af_c = np.ascontiguousarray(af) + cdef np.float32_t [:, :, ::1] fmag_c = np.ascontiguousarray(fmag) + cdef np.uint8_t [::1] mask_c = np.frombuffer(np.ascontiguousarray(mask.astype(np.bool)), dtype=np.uint8) + cdef np.float32_t [::1] err_fmag_c = np.ascontiguousarray(err_fmag.astype(np.float32)) + cdef np.int32_t [:,:,::1] addr_info_c = np.ascontiguousarray(addr_info) + cdef pbound_c = 0.0 + if not pbound is None: + pbound_c = pbound + out = np.empty_like(f) + cdef np.complex64_t [:,:,::1] out_c = out + cdef int M = f.shape[0] + cdef int N = fmag.shape[0] + cdef int A = f.shape[1] + cdef int B = f.shape[2] + assert(M == out.shape[0]) + # assert(N == af.shape[0]) + assert(N == mask.shape[0]) + assert(N == err_fmag.shape[0]) + assert(len(err_fmag.shape) == 1) + assert(M == addr_info.shape[0]) + renormalise_fourier_magnitudes_c( + &f_c[0,0,0], + &af_c[0,0,0], + &fmag_c[0,0,0], + &mask_c[0], + &err_fmag_c[0], + &addr_info_c[0,0,0], + pbound_c, + &out_c[0,0,0], + M, N, A, B, + 0 if pbound == None else 1 + ) + return out + +@cython.boundscheck(False) +@cython.wraparound(False) +def difference_map_fourier_constraint(mask, Idata, obj, probe, exit_wave, addr_info, prefilter, postfilter, pbound=None, alpha=1.0, LL_error=True, do_realspace_error=True): + cdef np.uint8_t [::1] mask_c = np.frombuffer(np.ascontiguousarray(mask.astype(np.bool)), dtype=np.uint8) + cdef np.float32_t [:,:,::1] Idata_c = np.ascontiguousarray(Idata) + cdef np.complex64_t [:,:,::1] obj_c = np.ascontiguousarray(obj) + cdef np.complex64_t [:,:,::1] probe_c = np.ascontiguousarray(probe) + # can't cast to continous array here, as it might copy and we update in-place + cdef np.complex64_t [:,:,::1] exit_wave_c = exit_wave + cdef np.int32_t [:,:,::1] addr_info_c = np.ascontiguousarray(addr_info) + cdef np.complex64_t [:,::1] prefilter_c = None + if not prefilter is None: + prefilter_c = np.ascontiguousarray(prefilter) + cdef np.complex64_t [:,::1] postfilter_c = None + if not postfilter is None: + postfilter_c = np.ascontiguousarray(postfilter) + cdef float pbound_c = 0.0 + if not pbound is None: + pbound_c = pbound + errors = np.empty((3, mask.shape[0]), dtype=np.float32) + cdef np.float32_t [:,::1] errors_c = errors + cdef float alpha_c = alpha + cdef int doLLError = 1 if LL_error else 0 + cdef int doRealspaceError = 1 if do_realspace_error else 0 + cdef int doPbound = 0 if pbound == None else 1 + cdef int M = exit_wave.shape[0] + cdef int A = exit_wave.shape[1] + cdef int B = exit_wave.shape[2] + cdef int ob_modes = obj.shape[0] + cdef int C = obj.shape[1] + cdef int D = obj.shape[2] + cdef int pr_modes = probe.shape[0] + cdef int N = mask.shape[0] + # assertions to make sure dimensions are as expected + assert(probe.shape[1] == A) + assert(probe.shape[2] == B) + assert(mask.shape[1] == A) + assert(mask.shape[2] == B) + assert(Idata.shape[0] == N) + assert(Idata.shape[1] == A) + assert(Idata.shape[2] == B) + assert(addr_info.shape[0] == M) + assert(errors.shape[1] == N) + + difference_map_fourier_constraint_c( + &mask_c[0], + &Idata_c[0,0,0], + &obj_c[0,0,0], + &probe_c[0,0,0], + &exit_wave_c[0,0,0], + &addr_info_c[0,0,0], + &prefilter_c[0,0], + &postfilter_c[0,0], + pbound_c, alpha_c, + doLLError, + doRealspaceError, + doPbound, + M, + N, + A, B, C, D, + ob_modes, pr_modes, + &errors_c[0,0] + ) + return errors + +@cython.boundscheck(False) +@cython.wraparound(False) +def norm2f(input): + cdef np.float32_t [::1] input_c = np.frombuffer(np.ascontiguousarray(input), dtype=np.float32) + cdef int size = np.prod(input.shape) + cdef float out = 0.0 + norm2_c( + &input_c[0], + &out, + size, + 0 + ) + return out + +@cython.boundscheck(False) +@cython.wraparound(False) +def norm2c(input): + cdef np.complex64_t [::1] input_c = np.frombuffer(np.ascontiguousarray(input), dtype=np.complex64) + cdef int size = np.prod(input.shape) + cdef float out = 0.0 + norm2_c( + &input_c[0], + &out, + size, + 1 + ) + return out + + +@cython.boundscheck(False) +@cython.wraparound(False) +def norm2(input): + if input.dtype == np.float32: + return norm2f(input) + elif input.dtype == np.complex64: + return norm2c(input) + else: + raise NotImplementedError("Norm2 is only implemented for single precision") + +@cython.boundscheck(False) +@cython.wraparound(False) +def mass_center(A): + if A.dtype != np.float32: + raise NotImplementedError("Only single precision is supported") + + cdef np.float32_t [::1] input_c = np.frombuffer(np.ascontiguousarray(A), dtype=np.float32) + cdef int i = A.shape[0] + cdef int m = A.shape[1] + cdef int n = 1 + if len(A.shape) == 3: + n = A.shape[2] + out = np.empty(len(A.shape), np.float32) + cdef np.float32_t [::1] out_c = out + mass_center_c( + &input_c[0], + i, m, n, + &out_c[0] + ) + return out + +@cython.boundscheck(False) +@cython.wraparound(False) +def clip_complex_magnitudes_to_range(complex_input, clip_min, clip_max): + if complex_input.dtype != np.complex64: + raise NotImplementedError("Only single precision complex data supported") + if not complex_input.flags['C_CONTIGUOUS']: + raise NotImplementedError("Can only handle contiguous arrays, due to in-place updates") + cdef int n = np.prod(complex_input.shape) + cdef float c_min = clip_min + cdef float c_max = clip_max + # discard all dimensionality information + cdef np.complex64_t [::1] input_c = np.frombuffer(np.ascontiguousarray(complex_input), dtype=np.complex64) + clip_complex_magnitudes_to_range_c( + &input_c[0], + n, c_min, c_max + ) + +@cython.boundscheck(False) +@cython.wraparound(False) +def extract_array_from_exit_wave(exit_wave, exit_addr, array_to_be_extracted, extract_addr, array_to_be_updated, update_addr, cfact, weights): + cdef np.complex64_t [:,:,::1] exit_wave_c = np.ascontiguousarray(exit_wave) + cdef np.int32_t [:,::1] exit_addr_c = np.ascontiguousarray(exit_addr).astype(np.int32) + cdef np.complex64_t [:,:,::1] array_to_be_extracted_c = np.ascontiguousarray(array_to_be_extracted) + cdef np.int32_t [:,::1] extract_addr_c = np.ascontiguousarray(extract_addr).astype(np.int32) + cdef np.complex64_t [:,:,::1] array_to_be_updated_c = np.ascontiguousarray(array_to_be_updated) + cdef np.int32_t [:,::1] update_addr_c = np.ascontiguousarray(update_addr).astype(np.int32) + cdef np.complex64_t [:,:,::1] cfact_c = np.ascontiguousarray(cfact) + cdef np.float32_t [::1] weights_c = np.ascontiguousarray(weights) + cdef int A = exit_wave.shape[0] + cdef int B = exit_wave.shape[1] + cdef int C = exit_wave.shape[2] + cdef int D = array_to_be_extracted.shape[0] + cdef int E = array_to_be_extracted.shape[1] + cdef int F = array_to_be_extracted.shape[2] + cdef int G = array_to_be_updated.shape[0] + cdef int H = array_to_be_updated.shape[1] + cdef int I = array_to_be_updated.shape[2] + extract_array_from_exit_wave_c( + &exit_wave_c[0,0,0], + A, B, C, + &exit_addr_c[0,0], + &array_to_be_extracted_c[0,0,0], + D, E, F, + &extract_addr_c[0,0], + &array_to_be_updated_c[0,0,0], + G, H, I, + &update_addr_c[0,0], + &weights_c[0], + &cfact_c[0,0,0] + ) + +@cython.boundscheck(False) +@cython.wraparound(False) +def interpolated_shift(c, shift, do_linear=False): + if not do_linear and all([int(s) != s for s in shift]): + raise NotImplementedError("Bicubic interpolated shifts are not implemented yet") + if c.dtype != np.complex64: + raise NotImplementedError("Only complex single precision type supported") + cdef int items = 0 + cdef int rows = 0 + cdef int columns = 0 + if len(c.shape) == 3: + items = c.shape[0] + rows = c.shape[1] + columns = c.shape[2] + else: + items = 1 + rows = c.shape[0] + columns = c.shape[1] + cdef np.complex64_t [::1] c_c = \ + np.frombuffer(np.ascontiguousarray(c), dtype=np.complex64) + out = np.zeros(c.shape, dtype=np.complex64) + cdef np.complex64_t [::1] out_c = np.frombuffer(out, dtype=np.complex64) + cdef float offsetRow = shift[0] + cdef float offsetCol = shift[1] + interpolated_shift_c( + &c_c[0], + &out_c[0], + items, rows, columns, + offsetRow, offsetCol, + 1 + ) + return out + +def get_num_gpus(): + return get_num_gpus_c() + +def get_gpu_compute_capability(dev): + cdef int dev_c = dev + return get_gpu_compute_capability_c(dev_c) + +def select_gpu_device(dev): + cdef int dev_c = dev + select_gpu_device_c(dev_c) + +def get_gpu_memory_mb(dev): + cdef int dev_c = dev + return get_gpu_memory_mb_c(dev_c) + +def get_gpu_name(dev): + cdef int dev_c = dev + cdef string name = get_gpu_name_c(dev_c) + return name.decode('UTF-8') + +def reset_function_cache(): + reset_function_cache_c() + +@cython.boundscheck(False) +@cython.wraparound(False) +def center_probe(probe, center_tolerance): + # can't convert to contiguous array here, as it's in-place returned + # we let Cython flag this if not contiguous + cdef np.complex64_t [:,:,::1] probe_c = probe + cdef float tol = center_tolerance + cdef int i = probe.shape[0] + cdef int m = probe.shape[1] + cdef int n = probe.shape[2] + center_probe_c( + &probe_c[0,0,0], + tol, i, m, n + ) + + +@cython.boundscheck(False) +@cython.wraparound(False) +def difference_map_update_probe(obj, probe_weights, probe, exit_wave, addr_info, cfact_probe, probe_support=None): + cdef np.complex64_t [:,:,::1] obj_c = np.ascontiguousarray(obj) + cdef np.float32_t [::1] probe_weights_c = np.ascontiguousarray(probe_weights) + # updated in-place, so can't use ascontiguousarray + cdef np.complex64_t [:,:,::1] probe_c = probe + cdef np.complex64_t [:,:,::1] exit_wave_c = np.ascontiguousarray(exit_wave) + if not isinstance(addr_info, np.ndarray): + addr_info = np.array(addr_info, dtype=np.int32) + else: + addr_info = addr_info.astype(np.int32) + cdef np.int32_t [:,:,::1] addr_info_c = np.ascontiguousarray(addr_info) + cdef np.complex64_t [:,:,::1] cfact_probe_c = np.ascontiguousarray(cfact_probe) + cdef np.complex64_t [:,:,::1] probe_support_c = None + if probe_support is not None: + probe_support_c = np.ascontiguousarray(probe_support) + cdef int A = exit_wave.shape[0] + cdef int B = exit_wave.shape[1] + cdef int C = exit_wave.shape[2] + cdef int D = obj.shape[0] + cdef int E = obj.shape[1] + cdef int F = obj.shape[2] + cdef int G = cfact_probe.shape[0] + cdef int H = cfact_probe.shape[1] + cdef int I = cfact_probe.shape[2] + return difference_map_update_probe_c( + &obj_c[0,0,0], + &probe_weights_c[0], + &probe_c[0,0,0], + &exit_wave_c[0,0,0], + &addr_info_c[0,0,0], + &cfact_probe_c[0,0,0], + &probe_support_c[0,0,0], + A,B,C,D,E,F,G,H,I + ) + +@cython.boundscheck(False) +@cython.wraparound(False) +def difference_map_update_object(obj, object_weights, probe, exit_wave, addr_info, cfact_object, ob_smooth_std=None, clip_object=None): + # updated in-place, so can't use ascontiguousarray + cdef np.complex64_t [:,:,::1] obj_c = obj + cdef np.complex64_t [:,:,::1] probe_c = np.ascontiguousarray(probe) + cdef np.float32_t [::1] object_weights_c = np.ascontiguousarray(object_weights) + cdef np.complex64_t [:,:,::1] exit_wave_c = np.ascontiguousarray(exit_wave) + if not isinstance(addr_info, np.ndarray): + addr_info = np.array(addr_info, dtype=np.int32) + else: + addr_info = addr_info.astype(np.int32) + cdef np.int32_t [:,:,::1] addr_info_c = np.ascontiguousarray(addr_info) + cdef np.complex64_t [:,:,::1] cfact_object_c = np.ascontiguousarray(cfact_object) + cdef float ob_smooth_std_c = 0 + cdef int doSmoothing = 0 + cdef int doClipping = 0 + if ob_smooth_std is not None: + ob_smooth_std_c = ob_smooth_std + doSmoothing = 1 + cdef float clip_min_c = 0 + cdef float clip_max_c = 0 + if clip_object is not None: + clip_min_c = clip_object[0] + clip_max_c = clip_object[1] + doClipping = 1 + cdef int A = exit_wave.shape[0] + cdef int B = exit_wave.shape[1] + cdef int C = exit_wave.shape[2] + cdef int D = probe.shape[0] + cdef int E = probe.shape[1] + cdef int F = probe.shape[2] + cdef int G = obj.shape[0] + cdef int H = obj.shape[1] + cdef int I = obj.shape[2] + + difference_map_update_object_c( + &obj_c[0,0,0], + &object_weights_c[0], + &probe_c[0,0,0], + &exit_wave_c[0,0,0], + &addr_info_c[0,0,0], + &cfact_object_c[0,0,0], + ob_smooth_std_c, clip_min_c, clip_max_c, + doSmoothing, doClipping, + A,B,C,D,E,F,G,H,I + ) + +@cython.boundscheck(False) +@cython.wraparound(False) +def difference_map_overlap_update(addr_info, cfact_object, cfact_probe, do_update_probe, exit_wave, ob, object_weights, + probe, probe_support, probe_weights,max_iterations, update_object_first, + obj_smooth_std, overlap_converge_factor, probe_center_tol, clip_object=None): + # updated in-place, so can't use ascontiguousarray + cdef np.complex64_t [:,:,::1] obj_c = ob + cdef np.complex64_t [:,:,::1] probe_c = probe + cdef np.float32_t [::1] object_weights_c = np.ascontiguousarray(object_weights) + cdef np.float32_t [::1] probe_weights_c = np.ascontiguousarray(probe_weights) + cdef np.complex64_t [:,:,::1] exit_wave_c = np.ascontiguousarray(exit_wave) + cdef np.complex64_t [:,:,::1] cfact_object_c = np.ascontiguousarray(cfact_object) + cdef np.complex64_t [:,:,::1] cfact_probe_c = np.ascontiguousarray(cfact_probe) + cdef np.complex64_t [:,:,::1] probe_support_c = None + if probe_support is not None: + probe_support_c = np.ascontiguousarray(probe_support) + if not isinstance(addr_info, np.ndarray): + addr_info = np.array(addr_info, dtype=np.int32) + else: + addr_info = addr_info.astype(np.int32) + cdef np.int32_t [:,:,::1] addr_info_c = np.ascontiguousarray(addr_info) + cdef float overlap_converge_factor_c = overlap_converge_factor + cdef int max_iterations_c = max_iterations + + cdef int doUpdateObjectFirst = 0 + cdef int doUpdateProbe = 0 + cdef int doSmoothing = 0 + cdef int doClipping = 0 + cdef int doCentering = 0 + + cdef float ob_smooth_std_c = 0 + cdef float clip_min_c = 0 + cdef float clip_max_c = 0 + cdef float probe_center_tol_c = 0 + + if update_object_first: + doUpdateObjectFirst = 1 + if do_update_probe: + doUpdateProbe = 1 + + if obj_smooth_std is not None: + ob_smooth_std_c = obj_smooth_std + doSmoothing = 1 + + if clip_object is not None: + clip_min_c = clip_object[0] + clip_max_c = clip_object[1] + doClipping = 1 + + if probe_center_tol is not None: + probe_center_tol_c = probe_center_tol + doCentering = 1 + + cdef int A = exit_wave.shape[0] + cdef int B = exit_wave.shape[1] + cdef int C = exit_wave.shape[2] + cdef int D = probe.shape[0] + cdef int E = probe.shape[1] + cdef int F = probe.shape[2] + cdef int G = ob.shape[0] + cdef int H = ob.shape[1] + cdef int I = ob.shape[2] + + difference_map_overlap_constraint_c( + &addr_info_c[0,0,0], + &cfact_object_c[0,0,0], + &cfact_probe_c[0,0,0], + &exit_wave_c[0,0,0], + &obj_c[0,0,0], + &object_weights_c[0], + &probe_c[0,0,0], + &probe_support_c[0,0,0], + &probe_weights_c[0], + ob_smooth_std_c, + clip_min_c, clip_max_c, + probe_center_tol_c, overlap_converge_factor_c, + max_iterations_c, + doUpdateObjectFirst, doUpdateProbe, doSmoothing, + doClipping, doCentering, + A, B, C, D, E, F, G, H, I + ) + +@cython.boundscheck(False) +@cython.wraparound(False) +def complex_gaussian_filter(input, mfs): + cdef int ndims = len(input.shape) + shape = np.ascontiguousarray(np.array(input.shape, dtype=np.int32)) + cdef np.int32_t [::1] shape_c = shape + mfs = np.ascontiguousarray(np.array(mfs, dtype=np.float32)) + cdef np.float32_t [::1] mfs_c = mfs + if input.dtype != np.complex64: + raise NotImplementedError("only complex64 type is supported") + cdef np.complex64_t [::1] input_c = np.frombuffer(np.ascontiguousarray(input), dtype=np.complex64) + out = np.empty_like(input) + cdef np.complex64_t [::1] output_c = np.frombuffer(out, dtype=np.complex64) + complex_gaussian_filter_c( + &input_c[0], + &output_c[0], + &mfs_c[0], + len(shape), + &shape_c[0] + ) + return out + +@cython.boundscheck(False) +@cython.wraparound(False) +def difference_map_iterator(diffraction, obj, object_weights, cfact_object, mask, probe, cfact_probe, probe_support, + probe_weights, exit_wave, addr, pre_fft, post_fft, pbound, overlap_max_iterations, update_object_first, + obj_smooth_std, overlap_converge_factor, probe_center_tol, probe_update_start, alpha=1, + clip_object=None, LL_error=False, num_iterations=1, do_realspace_error=True): + cdef np.float32_t [:,:,::1] diffraction_c = np.ascontiguousarray(diffraction) + # updated in-place, so can't use ascontiguousarray + cdef np.complex64_t [:,:,::1] obj_c = obj + cdef np.float32_t [::1] object_weights_c = np.ascontiguousarray(object_weights) + cdef np.complex64_t [:,:,::1] cfact_object_c = np.ascontiguousarray(cfact_object) + # converted to np.bool if needed! + cdef np.uint8_t [::1] mask_c = np.frombuffer(np.ascontiguousarray(mask.astype(np.bool)), dtype=np.uint8) + # updated in-place, so can't use ascontiguousarray + cdef np.complex64_t [:,:,::1] probe_c = probe + cdef np.complex64_t [:,:,::1] cfact_probe_c = np.ascontiguousarray(cfact_probe) + cdef np.complex64_t [:,:,::1] probe_support_c = None + if probe_support is not None: + probe_support_c = np.ascontiguousarray(probe_support) + cdef np.float32_t [::1] probe_weights_c = np.ascontiguousarray(probe_weights) + # updated in-place, so can't use ascontiguousarray + cdef np.complex64_t [:,:,::1] exit_wave_c = exit_wave + + if not isinstance(addr, np.ndarray): + addr_info = np.array(addr, dtype=np.int32) + else: + addr_info = addr.astype(np.int32) + cdef np.int32_t [:,:,::1] addr_info_c = np.ascontiguousarray(addr_info) + cdef np.complex64_t [:,::1] pre_fft_c = np.ascontiguousarray(pre_fft) + cdef np.complex64_t [:,::1] post_fft_c = np.ascontiguousarray(post_fft) + errors = np.empty((num_iterations, 3, diffraction.shape[0]), dtype=np.float32) + cdef np.float32_t [:,:,::1] errors_c = errors + + cdef float pbound_c = 0.0 + cdef int doPbound = 0 + if not pbound is None: + pbound_c = pbound + doPbound = 1 + + cdef int overlap_max_iterations_c = overlap_max_iterations + + cdef int doUpdateObjectFirst = 0 + if update_object_first: + doUpdateObjectFirst = 1 + + cdef float ob_smooth_std_c = 0 + cdef int doSmoothing = 0 + if obj_smooth_std is not None: + ob_smooth_std_c = obj_smooth_std + doSmoothing = 1 + + cdef float overlap_converge_factor_c = overlap_converge_factor + + cdef int doCentering = 0 + cdef float probe_center_tol_c = 0 + if probe_center_tol is not None: + probe_center_tol_c = probe_center_tol + doCentering = 1 + + cdef int probe_update_start_c = probe_update_start + cdef float alpha_c = alpha + + cdef int doClipping = 0 + cdef float clip_min_c = 0 + cdef float clip_max_c = 0 + if clip_object is not None: + clip_min_c = clip_object[0] + clip_max_c = clip_object[1] + doClipping = 1 + + cdef int do_LL_Error = 0 + if LL_error: + do_LL_Error = 1 + + cdef int doRealspaceError = 0 + if do_realspace_error: + doRealspaceError = 1 + + cdef int num_iterations_c = num_iterations + + cdef int A = exit_wave.shape[0] + cdef int B = exit_wave.shape[1] + cdef int C = exit_wave.shape[2] + cdef int D = probe.shape[0] + cdef int E = probe.shape[1] + cdef int F = probe.shape[2] + cdef int G = obj.shape[0] + cdef int H = obj.shape[1] + cdef int I = obj.shape[2] + cdef int N = diffraction.shape[0] + + difference_map_iterator_c( + &diffraction_c[0,0,0], + &obj_c[0,0,0], + &object_weights_c[0], + &cfact_object_c[0,0,0], + &mask_c[0], + &probe_c[0,0,0], + &cfact_probe_c[0,0,0], + &probe_support_c[0,0,0], + &probe_weights_c[0], + &exit_wave_c[0,0,0], + &addr_info_c[0,0,0], + &pre_fft_c[0,0], + &post_fft_c[0,0], + &errors_c[0,0,0], + pbound_c, + overlap_max_iterations_c, + doUpdateObjectFirst, + ob_smooth_std_c, + overlap_converge_factor_c, + probe_center_tol_c, + probe_update_start_c, + alpha_c, + clip_min_c, clip_max_c, + do_LL_Error, doRealspaceError, + num_iterations_c, + A, B, C, D, E, F, G, H, I, N, + doSmoothing, doClipping, doCentering, doPbound + ) + return errors diff --git a/archive/cuda_extension/python/object_probe_interaction.py b/archive/cuda_extension/python/object_probe_interaction.py new file mode 100644 index 000000000..6186ab9be --- /dev/null +++ b/archive/cuda_extension/python/object_probe_interaction.py @@ -0,0 +1,11 @@ +''' +object_probe_interaction + +Contains things pertinent to the probe and object interaction. +Should have all the engine updates +''' + +from .gpu_extension import difference_map_realspace_constraint, \ + scan_and_multiply, extract_array_from_exit_wave, center_probe, \ + difference_map_update_probe, difference_map_update_object, \ + difference_map_overlap_update diff --git a/archive/cuda_extension/python/propagation.py b/archive/cuda_extension/python/propagation.py new file mode 100644 index 000000000..05f562c0f --- /dev/null +++ b/archive/cuda_extension/python/propagation.py @@ -0,0 +1,6 @@ +''' +All propagation based kernels +''' + +from .gpu_extension import farfield_propagator, sqrt_abs + diff --git a/archive/cuda_extension/setup.py.cuda_extension b/archive/cuda_extension/setup.py.cuda_extension new file mode 100644 index 000000000..34acfb0cb --- /dev/null +++ b/archive/cuda_extension/setup.py.cuda_extension @@ -0,0 +1,144 @@ +#!/usr/bin/env python + +import setuptools, setuptools.command.build_ext +from distutils.core import setup +#from Cython.Build import cythonize +import sys + +from extensions import CudaExtension + +CLASSIFIERS = """\ +Development Status :: 3 - Alpha +Intended Audience :: Science/Research +License :: OSI Approved +Programming Language :: Python +Topic :: Scientific/Engineering +Topic :: Software Development +Operating System :: Unix +""" + + +MAJOR = 0 +MINOR = 4 +MICRO = 1 +ISRELEASED = False +VERSION = '%d.%d.%d' % (MAJOR, MINOR, MICRO) + + +# import os +# if os.path.exists('MANIFEST'): os.remove('MANIFEST') + +DEBUG = False + +def write_version_py(filename='ptypy/version.py'): + cnt = """ +# THIS FILE IS GENERATED FROM ptypy/setup.py +short_version='%(version)s' +version='%(version)s' +release=%(isrelease)s + +if not release: + version += '.dev' + import subprocess + try: + git_commit = subprocess.Popen(["git","log","-1","--pretty=oneline","--abbrev-commit"], + stdout=subprocess.PIPE, + stderr=subprocess.DEVNULL).communicate()[0].split()[0] + except: + pass + else: + version += git_commit.strip().decode() + +""" + a = open(filename, 'w') + try: + a.write(cnt % {'version': VERSION, 'isrelease': str(ISRELEASED)}) + finally: + a.close() + + +if __name__ == '__main__': + write_version_py() + write_version_py('doc/version.py') + try: + execfile('ptypy/version.py') + vers = version + except: + vers = VERSION + + +# optional packages that we don't always want to build +exclude_packages = ['*test*', + '*.accelerate.cuda*'] + +acceleration_build_steps = [] + +# I don't like this particularly, but I can't currently find a better way to give the desired result... +if '--tests' in sys.argv: + sys.argv.remove('--tests') + exclude_packages.remove('*test*') + +if '--with-cuda' in sys.argv: + sys.argv.remove('--with-cuda') + acceleration_build_steps.append(CudaExtension(DEBUG)) + exclude_packages.remove('*.accelerate.cuda*') + +if '--all-acceleration' in sys.argv: + sys.argv.remove('--all-acceleration') + # cuda + acceleration_build_steps.append(CudaExtension(DEBUG)) + exclude_packages.remove('*.accelerate.cuda*') + #exclude_packages.remove('*array_based*') + + +# chain this before build_ext +class BuildExtAcceleration(setuptools.command.build_ext.build_ext): + """Custom build command, extending the build with CUDA / Cmake.""" + # add the build parameters via reflection for each extension. + for ext in acceleration_build_steps: + user_options, boolean_options = ext.get_reflection_options() + setuptools.command.build_ext.build_ext.user_options.append(user_options) + setuptools.command.build_ext.build_ext.boolean_options.append(boolean_options) + + def initialize_options(self): + # initialise the options for each extension + setuptools.command.build_ext.build_ext.initialize_options(self) + for ext in acceleration_build_steps: + for key, desc in ext.get_full_options().items(): + self.__dict__[key] = desc['default'] + + def run(self): + # run the build for each extension + for ext in acceleration_build_steps: + options = {} + for key, desc in ext.get_full_options().items(): + options[key] = self.__dict__[key] + ext.build(options) + setuptools.command.build_ext.build_ext.run(self) + + +extensions = [ext.getExtension() for ext in acceleration_build_steps] + +package_list = setuptools.find_packages(exclude=exclude_packages) +#print(package_list) +setup( + name='Python Ptychography toolbox', + version=VERSION, + author='Pierre Thibault, Bjoern Enders, Martin Dierolf and others', + description='Ptychographic reconstruction toolbox', + long_description=open('README.rst', 'r').read(), + package_dir={'ptypy': 'ptypy'}, + packages=package_list, + package_data={'ptypy': ['resources/*',], + 'ptypy.accelerate.py_cuda.cuda': ['*.cu'], + 'ptypy.accelerate.py_cuda.cuda.filtered_fft': ['*.hpp', '*.cpp', 'Makefile', '*.cu', '*.h']}, + scripts=['scripts/ptypy.plot', + 'scripts/ptypy.inspect', + 'scripts/ptypy.plotclient', + 'scripts/ptypy.new', + 'scripts/ptypy.csv2cp', + 'scripts/ptypy.run'], + #ext_modules=cythonize(extensions), + #cmdclass={'build_ext': BuildExtAcceleration + #} +) diff --git a/archive/cuda_extension/tests/__init__.py b/archive/cuda_extension/tests/__init__.py new file mode 100644 index 000000000..a5f33ddcc --- /dev/null +++ b/archive/cuda_extension/tests/__init__.py @@ -0,0 +1,10 @@ +import unittest + +def have_cuda(): + try: + from archive.cuda_extension.accelerate.cuda import gpu_extension + return True + except: + return False + +only_if_cuda_available = unittest.skipIf(not have_cuda(), "no (cythonized) CUDA extension available") diff --git a/archive/cuda_extension/tests/array_utils_test.py b/archive/cuda_extension/tests/array_utils_test.py new file mode 100644 index 000000000..69e00d10b --- /dev/null +++ b/archive/cuda_extension/tests/array_utils_test.py @@ -0,0 +1,416 @@ +''' +Tests for the array_utils module +''' + + +import unittest +from ptypy.accelerate.array_based import array_utils as au +from ptypy.accelerate.array_based import FLOAT_TYPE, COMPLEX_TYPE +from copy import deepcopy +import numpy as np + +from . import have_cuda, only_if_cuda_available +if have_cuda(): + from archive.cuda_extension.accelerate.cuda import array_utils as gau + from archive.cuda_extension.accelerate.cuda.config import init_gpus, reset_function_cache + init_gpus(0) + +@only_if_cuda_available +class ArrayUtilsTest(unittest.TestCase): + + def tearDown(self): + # reset the cached GPU functions after each test + reset_function_cache() + + def test_abs2_real_input_2D_float32_UNITY(self): + x = np.ones((3,3), dtype=np.float32) + np.testing.assert_array_equal(au.abs2(x), gau.abs2(x)) + + def test_abs2_complex_input_2D_float32_UNITY(self): + x = np.ones((3,3)) + 1j*np.ones((3,3)) + x = x.astype(np.complex64) + np.testing.assert_array_equal(au.abs2(x), gau.abs2(x)) + + def test_abs2_real_input_3D_float32_UNITY(self): + x = np.ones((3,3,3), dtype=np.float32) + np.testing.assert_array_equal(au.abs2(x), gau.abs2(x)) + + def test_abs2_complex_input_3D_float32_UNITY(self): + x = np.ones((3,3,3)) + 1j*np.ones((3,3,3)) + x = x.astype(np.complex64) + np.testing.assert_array_equal(au.abs2(x), gau.abs2(x)) + + def test_abs2_real_input_2D_float64_UNITY(self): + x = np.ones((3,3)) + np.testing.assert_array_equal(au.abs2(x), gau.abs2(x)) + + def test_abs2_complex_input_2D_float64_UNITY(self): + x = np.ones((3,3)) + 1j*np.ones((3,3)) + np.testing.assert_array_equal(au.abs2(x), gau.abs2(x)) + + def test_abs2_real_input_3D_float64_UNITY(self): + x = np.ones((3,3,3)) + np.testing.assert_array_equal(au.abs2(x), gau.abs2(x)) + + def test_abs2_complex_input_3D_float64_UNITY(self): + x = np.ones((3,3,3)) + 1j*np.ones((3,3,3)) + np.testing.assert_array_equal(au.abs2(x), gau.abs2(x)) + + def test_sum_to_buffer_real_UNITY(self): + + in1 = np.array([np.ones((4, 4)), + np.ones((4, 4))*2.0, + np.ones((4, 4))*3.0, + np.ones((4, 4))*4.0], dtype=FLOAT_TYPE) + + outshape = (2, 4, 4) + + in1_addr = np.array([(0, 0, 0), + (1, 0, 0), + (2, 0, 0), + (3, 0, 0)]) + + out1_addr = np.array([(0, 0, 0), + (1, 0, 0), + (0, 0, 0), + (1, 0, 0)]) + + s1 = au.sum_to_buffer(in1, outshape, in1_addr, out1_addr, dtype=FLOAT_TYPE) + s2 = gau.sum_to_buffer(in1, outshape, in1_addr, out1_addr, dtype=FLOAT_TYPE) + + np.testing.assert_array_equal(s1, s2) + + def test_sum_to_buffer_stride_real_UNITY(self): + + in1 = np.array([np.ones((4, 4)), + np.ones((4, 4))*2.0, + np.ones((4, 4))*3.0, + np.ones((4, 4))*4.0], dtype=FLOAT_TYPE) + + outshape = (2, 4, 4) + + addr_info = np.zeros((4, 5, 3), dtype=np.int) + addr_info[:,2,:] = np.array([(0, 0, 0), + (1, 0, 0), + (2, 0, 0), + (3, 0, 0)]) + + addr_info[:,3,:] = np.array([(0, 0, 0), + (1, 0, 0), + (0, 0, 0), + (1, 0, 0)]) + + s1 = au.sum_to_buffer(in1, outshape, addr_info[:,2,:], addr_info[:,3,:], dtype=FLOAT_TYPE) + s2 = gau.sum_to_buffer_stride(in1, outshape, addr_info, dtype=FLOAT_TYPE) + + np.testing.assert_array_equal(s1, s2) + + def test_sum_to_buffer_complex_UNITY(self): + + in1 = np.array([np.ones((4,4)), + np.ones((4, 4))*2.0, + np.ones((4, 4))*3.0, + np.ones((4, 4))*4.0], dtype=FLOAT_TYPE) \ + + 1j*np.array([np.ones((4,4)), + np.ones((4, 4))*2.0, + np.ones((4, 4))*3.0, + np.ones((4, 4))*4.0], dtype=FLOAT_TYPE) + + outshape = (2, 4, 4) + + in1_addr = np.array([(0, 0, 0), + (1, 0, 0), + (2, 0, 0), + (3, 0, 0)]) + + out1_addr = np.array([(0, 0, 0), + (1, 0, 0), + (0, 0, 0), + (1, 0, 0)]) + + s1 = au.sum_to_buffer(in1, outshape, in1_addr, out1_addr, dtype=in1.dtype) + s2 = gau.sum_to_buffer(in1, outshape, in1_addr, out1_addr, dtype=in1.dtype) + + np.testing.assert_array_equal(s1, s2) + + def test_sum_to_buffer_stride_complex_UNITY(self): + + in1 = np.array([np.ones((4,4)), + np.ones((4, 4))*2.0, + np.ones((4, 4))*3.0, + np.ones((4, 4))*4.0], dtype=FLOAT_TYPE) \ + + 1j*np.array([np.ones((4,4)), + np.ones((4, 4))*2.0, + np.ones((4, 4))*3.0, + np.ones((4, 4))*4.0], dtype=FLOAT_TYPE) + + outshape = (2, 4, 4) + + addr_info = np.zeros((4, 5, 3), dtype=np.int) + addr_info[:,2,:] = np.array([(0, 0, 0), + (1, 0, 0), + (2, 0, 0), + (3, 0, 0)]) + + addr_info[:,3,:] = np.array([(0, 0, 0), + (1, 0, 0), + (0, 0, 0), + (1, 0, 0)]) + + s1 = au.sum_to_buffer(in1, outshape, addr_info[:,2,:], addr_info[:,3,:], dtype=in1.dtype) + s2 = gau.sum_to_buffer_stride(in1, outshape, addr_info, dtype=in1.dtype) + + np.testing.assert_array_equal(s1, s2) + + + def test_norm2_1d_real_UNITY(self): + a = np.array([1.0, 2.0], dtype=FLOAT_TYPE) + out = au.norm2(a) + outg =gau.norm2(a) + np.testing.assert_array_equal(out, outg) + + def test_norm2_1d_complex_UNITY(self): + a = np.array([1.0+1.0j, 2.0+2.0j], dtype=COMPLEX_TYPE) + out = au.norm2(a) + outg = gau.norm2(a) + np.testing.assert_array_equal(out, outg) + + def test_norm2_2d_real_UNITY(self): + a = np.array([[1.0, 2.0], + [3.0, 4.0]], dtype=FLOAT_TYPE) + out = au.norm2(a) + outg = gau.norm2(a) + np.testing.assert_array_equal(out, outg) + + def test_norm2_2d_complex_UNITY(self): + a = np.array([[1.0+1.0j, 2.0+2.0j], + [3.0+3.0j, 4.0+4.0j]], dtype=COMPLEX_TYPE) + out = au.norm2(a) + outg = gau.norm2(a) + np.testing.assert_array_equal(out, outg) + + def test_norm2_3d_real_UNITY(self): + a = np.array([[[1.0, 2.0], + [3.0, 4.0]], + [[5.0, 6.0], + [7.0, 8.0]]], dtype=FLOAT_TYPE) + out = au.norm2(a) + outg = gau.norm2(a) + np.testing.assert_array_equal(out, outg) + + def test_norm2_3d_complex_UNITY(self): + a = np.array([[[1.0+1.0j, 2.0+2.0j], + [3.0+3.0j, 4.0+4.0j]], + [[5.0 + 5.0j, 6.0 + 6.0j], + [7.0 + 7.0j, 8.0 + 8.0j]]], dtype=COMPLEX_TYPE) + out = au.norm2(a) + outg = gau.norm2(a) + np.testing.assert_array_equal(out, outg) + + def test_norm2_1d_real_large_UNITY(self): + a = np.ones(2000000, dtype=FLOAT_TYPE) # > 1M, to test multi-stage + out = au.norm2(a) + outg = gau.norm2(a) + np.testing.assert_array_equal(out, outg) + + def test_complex_gaussian_filter_1d_UNITY(self): + data = np.zeros((11,), dtype=COMPLEX_TYPE) + data[5] = 1.0 +1.0j + mfs = [1.0] + out = au.complex_gaussian_filter(data, mfs) + outg = gau.complex_gaussian_filter(data, mfs) + #for i in xrange(11): + # print("{} vs {}".format(out[i], outg[i])) + np.testing.assert_allclose(out, outg, rtol=1e-6) + + def test_complex_gaussian_filter_2d_simple_UNITY(self): + data = np.zeros((11, 11), dtype=COMPLEX_TYPE) + data[5, 5] = 1.0+1.0j + mfs = 1.0,0.0 + out = au.complex_gaussian_filter(data, mfs) + outg = gau.complex_gaussian_filter(data, mfs) + np.testing.assert_allclose(out, outg, rtol=1e-6) + + def test_complex_gaussian_filter_2d_simple2_UNITY(self): + data = np.zeros((11, 11), dtype=COMPLEX_TYPE) + data[5, 5] = 1.0+1.0j + mfs = 0.0,1.0 + out = au.complex_gaussian_filter(data, mfs) + outg = gau.complex_gaussian_filter(data, mfs) + np.testing.assert_allclose(out, outg, rtol=1e-6) + + def test_complex_gaussian_filter_2d_UNITY(self): + data = np.zeros((8, 8), dtype=COMPLEX_TYPE) + data[3:5, 3:5] = 2.0+2.0j + mfs = 3.0,4.0 + out = au.complex_gaussian_filter(data, mfs) + outg = gau.complex_gaussian_filter(data, mfs) + np.testing.assert_allclose(out, outg, rtol=1e-6) + + def test_complex_gaussian_filter_2d_batched(self): + batch_number = 2 + A = 5 + B = 5 + + data = np.zeros((batch_number, A, B), dtype=COMPLEX_TYPE) + data[:, 2:3, 2:3] = 2.0+2.0j + mfs = 3.0,4.0 + out = au.complex_gaussian_filter(data, mfs) + gout = gau.complex_gaussian_filter(data, mfs) + + np.testing.assert_allclose(out, gout, rtol=1e-6) + + def test_mass_center_2d_simple(self): + data = np.array([[0,0,0,0], + [0,1,1,0], + [0,1,1,0], + [0,1,1,0], + [0,1,1,0]], dtype=FLOAT_TYPE) + comg = gau.mass_center(data) + np.testing.assert_array_equal([2.5, 1.5], comg) + + def test_mass_center_2d_UNITY(self): + npts = 64 + probe = np.zeros((1, npts, npts), dtype=COMPLEX_TYPE) + rad = 10.0 + probe_vals = 2 + 3j + x = np.array(range(npts)) - npts // 2 + X, Y = np.meshgrid(x, x) + Xoff = 5.0 + Yoff = 2.0 + probe[0, (X-Xoff)**2 + (Y-Yoff)**2 < rad**2] = probe_vals + + com = au.mass_center(np.abs(probe[0])) + comg = gau.mass_center(np.abs(probe[0])) + + np.testing.assert_array_almost_equal(com, comg) + + def test_mass_center_3d_UNITY(self): + npts = 64 + probe = np.zeros((npts, npts, npts), dtype=COMPLEX_TYPE) + rad = 10.0 + probe_vals = 2 + 3j + x = np.array(range(npts)) - npts // 2 + X, Y, Z = np.meshgrid(x, x, x) + Xoff = 5.0 + Yoff = 2.0 + Zoff = 10.0 + probe[(X-Xoff)**2 + (Y-Yoff)**2 + (Z-Zoff)**2< rad**2] = probe_vals + + com = au.mass_center(np.abs(probe)) + comg = gau.mass_center(np.abs(probe)) + np.testing.assert_allclose(com, comg, rtol=1e-6) + self.assertEqual(com.dtype, comg.dtype) + + def test_interpolated_shift_integer(self): + A = np.array([[0,0,0,0,0], + [0,1,1,0,0], + [0,1,1,0,0], + [0,0,0,0,0], + [0,0,0,0,0]], dtype=COMPLEX_TYPE) + \ + 1j * np.array([[0,0,0,0,0], + [0,0,1,1,1], + [1,0,1,0,1], + [0,0,0,1,1], + [0,0,0,0,0]], dtype=COMPLEX_TYPE) + A = A.real + 1j * A.real + + shifts = [[-1, 0], + [1, 1], + [2,2], + [-5,0], + [0,4], + [-3,-3], + [0,0]] + for s in shifts: + B1 = au.interpolated_shift(A, s) + gB1 = gau.interpolated_shift(A, s) + np.testing.assert_allclose(B1, gB1, rtol=1e-7, atol=1e-7) + + def test_interpolated_shift_linear_simple(self): + A = np.array([[0,0,0,0,0], + [0,1,1,0,0], + [0,1,1,0,0], + [0,0,0,0,0], + [0,0,0,0,0]], dtype=COMPLEX_TYPE) + \ + 1j * np.array([ + [0,0,0,0,0], + [0,0,1,1,1], + [1,0,1,0,1], + [0,0,0,1,1], + [0,0,0,0,0]], dtype=COMPLEX_TYPE) + + + shifts = [ + [0,-0.25], + [-1.1,1.4], + [0.5,-0.12], + [-2.4,2.3], + [-5.6,1.2], + [0.2, 6.2], + [-0.2, -7.6], + [-102.1, 951.12], + ] + for s in shifts: + B1 = au.interpolated_shift(A, s, do_linear=True) + gB1 = gau.interpolated_shift(A, s, do_linear=True) + np.testing.assert_allclose(B1, gB1, rtol=1e-6, atol=1e-7, + err_msg="Failure for shift {}:\n CPU={}\nGPU={}".format(s, B1, gB1)) + + def test_interpolated_shift_linear(self): + npts = 32 + probe = np.zeros((1, npts, npts), dtype=COMPLEX_TYPE) + rad = 10.0 + probe_vals = 2 + 3j + x = np.array(range(npts)) - npts // 2 + X, Y = np.meshgrid(x, x) + Xoff = 5.0 + Yoff = 2.0 + probe[0, (X-Xoff)**2 + (Y-Yoff)**2 < rad**2] = probe_vals + + shifts = [[-Xoff, -Yoff], + [0.5,0], + #[-5.2, -1.9] + ] + + for s in shifts: + B = au.interpolated_shift(probe[0], s, do_linear=True) + gB = gau.interpolated_shift(probe[0], s, do_linear=True) + np.testing.assert_allclose(B, gB, rtol=1e-6, atol=1e-3, err_msg="failed for shifts {}".format(s)) + + @unittest.skip("not implemented yet") + def test_interpolated_shift_bicubic(self): + npts = 32 + probe = np.zeros((1, npts, npts), dtype=COMPLEX_TYPE) + rad = 10.0 + probe_vals = 2 + 3j + x = np.array(range(npts)) - npts // 2 + X, Y = np.meshgrid(x, x) + Xoff = 5.1 + Yoff = 2.2 + probe[0, (X-Xoff)**2 + (Y-Yoff)**2 < rad**2] = probe_vals + + shifts = [[-Xoff, -Yoff], + [2.3,1.3], + [-5.2, -1.9]] + + for s in shifts: + B = au.interpolated_shift(probe[0], s) + gB = gau.interpolated_shift(probe[0], s) + np.testing.assert_allclose(B, gB, rtol=1e-6, atol=1e-3) + + def test_clip_magnitudes_to_range(self): + data = np.ones((5,5), dtype=COMPLEX_TYPE) + data[2, 4] = 20.0*np.exp(1j*np.pi/2) + data[3, 1] = 0.2*np.exp(1j*np.pi/3) + gdata = deepcopy(data) + clip_min = 0.5 + clip_max = 2.0 + + au.clip_complex_magnitudes_to_range(data, clip_min, clip_max) + gau.clip_complex_magnitudes_to_range(gdata, clip_min, clip_max) + np.testing.assert_array_almost_equal(data, gdata) + + +if __name__=='__main__': + unittest.main() diff --git a/archive/cuda_extension/tests/constraints_regression_test.py b/archive/cuda_extension/tests/constraints_regression_test.py new file mode 100644 index 000000000..79864c1e7 --- /dev/null +++ b/archive/cuda_extension/tests/constraints_regression_test.py @@ -0,0 +1,551 @@ +''' +The tests for the constraints +''' + +import unittest +import numpy as np +from copy import deepcopy +from ptypy.accelerate.array_based import constraints as con, FLOAT_TYPE, COMPLEX_TYPE +from . import have_cuda, only_if_cuda_available + +if have_cuda(): + from archive.cuda_extension.accelerate.cuda import constraints as gcon + +@only_if_cuda_available +class ConstraintsRegressionTest(unittest.TestCase): + ''' + a module to holds the constraints + ''' + + def test_renormalise_fourier_magnitudes_pbound_none(self): + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 3 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + pbound = None # the power bound + + fmag = np.empty(shape=(N, A, B), dtype=FLOAT_TYPE)# the measured magnitudes NxAxB + mask = np.empty(shape=(N, A, B), dtype=np.int32)# the masks for the measured magnitudes either 1xAxB or NxAxB + err_fmag = np.empty(shape=(N, ), dtype=FLOAT_TYPE)# deviation from the diffraction pattern for each af + f = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # the current iterant + af = np.empty(shape=(M, A, B), dtype=FLOAT_TYPE)# the absolute magnitudes of f + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32)# the address book + + ## now lets fill them with some values, these are junk and not supposed to be indicative of real values. + + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + err_fmag[:] = np.ones((N,)) # this shouldn't be used a pbound is None + + f_fill = np.array([ix + 1j*(ix**2) for ix in range(np.prod(f.shape))]).reshape((M, A, B)) + f[:] = f_fill + + af[:] = np.sqrt((f*f.conj()).real) + pa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + oa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)]*num_probe_modes*num_object_modes) + ma = np.array([np.array([ix, 0, 0]) for ix in range(N)]*num_probe_modes*num_object_modes) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + out = con.renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + gout = gcon.renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + + out_test = out.reshape((np.prod(out.shape),)) + gout_test = gout.reshape((np.prod(gout.shape),)) + for idx in range(len(out)): + np.testing.assert_allclose(out_test[idx], + gout_test[idx], + err_msg=("failed on index:%s\n" % (idx))) + + + def test_renormalise_fourier_magnitudes_pbound_not_none(self): + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 3 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + pbound = 5.0 # the power bound + + fmag = np.empty(shape=(N, A, B), dtype=FLOAT_TYPE)# the measured magnitudes NxAxB + mask = np.empty(shape=(N, A, B), dtype=np.int32)# the masks for the measured magnitudes either 1xAxB or NxAxB + err_fmag = np.empty(shape=(N, ), dtype=FLOAT_TYPE)# deviation from the diffraction pattern for each af + f = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # the current iterant + af = np.empty(shape=(M, A, B), dtype=FLOAT_TYPE)# the absolute magnitudes of f + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32)# the address book + + ## now lets fill them with some values, these are junk and not supposed to be indicative of real values. + + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + err_fmag_fill = np.ones((N,))*(pbound+0.1) # should be greater than the pbound + err_fmag_fill[N//2] = 4.0 # this one should be less than the pbound and not update + err_fmag[:] = err_fmag_fill # this shouldn't be used a pbound is None + + f_fill = np.array([ix + 1j*(ix**2) for ix in range(np.prod(f.shape))]).reshape((M, A, B)) + f[:] = f_fill + + af[:] = np.sqrt((f*f.conj()).real) + pa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + oa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)]*num_probe_modes*num_object_modes) + ma = np.array([np.array([ix, 0, 0]) for ix in range(N)]*num_probe_modes*num_object_modes) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + gout = gcon.renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + out = con.renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + out_test = out.reshape((np.prod(out.shape),)) + gout_test = gout.reshape((np.prod(gout.shape),)) + for idx in range(len(out)): + np.testing.assert_allclose(out_test[idx], + gout_test[idx], + err_msg=("failed on index:%s\n" % (idx))) + + + def test_get_difference_pbound_is_none(self): + alpha = 1.0 # feedback constant + pbound = 5.0 # the power bound + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 3 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + + backpropagated_solution = np.empty(shape=(M, A, B), + dtype=COMPLEX_TYPE) # The current iterant backpropagated + probe_object = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # the probe multiplied by the object + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32) # the address book + + # now fill it with stuff + + backpropagated_solution_fill = np.array( + [ix + 1j * (ix ** 2) for ix in range(np.prod(backpropagated_solution.shape))]).reshape((M, A, B)) + backpropagated_solution[:] = backpropagated_solution_fill + + probe_object_fill = np.array( + [ix + 1j * ix for ix in range(10, 10 + np.prod(backpropagated_solution.shape), 1)]).reshape( + (M, A, B)) + probe_object[:] = probe_object_fill + + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(backpropagated_solution.shape), 1)]).reshape( + (M, A, B)) + exit_wave[:] = exit_wave_fill + + pa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + oa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * num_probe_modes * num_object_modes) + ma = np.zeros((M, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + gout = gcon.get_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, + probe_object) + + out = con.get_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, + probe_object) + out_test = out.reshape((np.prod(out.shape),)) + gout_test = gout.reshape((np.prod(gout.shape),)) + for idx in range(len(out)): + np.testing.assert_allclose(out_test[idx], + gout_test[idx], + err_msg=("failed on index:%s\n" % (idx))) + + def test_get_difference_pbound_is_not_none(self): + alpha = 1.0 # feedback constant + pbound = 5.0 # the power bound + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 3 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + + backpropagated_solution = np.empty(shape=(M, A, B), + dtype=COMPLEX_TYPE) # The current iterant backpropagated + probe_object = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # the probe multiplied by the object + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32) # the address book + + # now fill it with stuff + + backpropagated_solution_fill = np.array( + [ix + 1j * (ix ** 2) for ix in range(np.prod(backpropagated_solution.shape))]).reshape((M, A, B)) + backpropagated_solution[:] = backpropagated_solution_fill + + probe_object_fill = np.array( + [ix + 1j * ix for ix in range(10, 10 + np.prod(backpropagated_solution.shape), 1)]).reshape( + (M, A, B)) + probe_object[:] = probe_object_fill + + err_fmag_fill = np.ones((N,)) * (pbound + 0.1) # should be higher than pbound + err_fmag_fill[N // 2] = 4.0 # except for this one!! + err_fmag[:] = err_fmag_fill + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(backpropagated_solution.shape), 1)]).reshape( + (M, A, B)) + exit_wave[:] = exit_wave_fill + + pa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + oa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * num_probe_modes * num_object_modes) + ma = np.zeros((M, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + gout = gcon.get_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, + probe_object) + + out = con.get_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, + probe_object) + out_test = out.reshape((np.prod(out.shape),)) + gout_test = gout.reshape((np.prod(gout.shape),)) + + for idx in range(len(out)): + np.testing.assert_allclose(out_test[idx], + gout_test[idx], + err_msg=("failed on index:%s\n" % (idx))) + + def test_difference_map_fourier_constraint_pbound_is_none_with_realspace_error_and_LL_error(self): + + alpha = 1.0 # feedback constant + pbound = None # the power bound + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 4 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + npts_greater_than = int(np.sqrt(N)) # object is bigger than the probe by this amount + C = A + npts_greater_than + D = B + npts_greater_than + + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32) # the address book + Idata = np.empty(shape=(N, A, B), dtype=FLOAT_TYPE) # the measured intensities NxAxB + mask = np.empty(shape=(N, A, B), + dtype=np.int32) # the masks for the measured magnitudes either 1xAxB or NxAxB + probe = np.empty(shape=(num_probe_modes, A, B), dtype=COMPLEX_TYPE) # the probe function + obj = np.empty(shape=(num_object_modes, C, D), dtype=COMPLEX_TYPE) # the object function + prefilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + postfilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + + # now fill it with stuff. Data won't ever look like this except in type and usage! + Idata_fill = np.arange(np.prod(Idata.shape)).reshape(Idata.shape).astype(Idata.dtype) + Idata[:] = Idata_fill + + obj_fill = np.array([ix + 1j * (ix ** 2) for ix in range(np.prod(obj.shape))]).reshape( + (num_object_modes, C, D)) + obj[:] = obj_fill + + probe_fill = np.array([ix + 1j * ix for ix in range(10, 10 + np.prod(probe.shape), 1)]).reshape( + (num_probe_modes, A, B)) + probe[:] = probe_fill + + prefilter.fill(30.0 + 2.0j) # this would actually vary + postfilter.fill(20.0 + 3.0j) # this too + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(exit_wave.shape), 1)]).reshape((M, A, B)) + exit_wave[:] = exit_wave_fill + + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + pa = np.zeros((M, 3), dtype=np.int32) + for idx in range(num_probe_modes): + if idx > 0: + pa[::idx, 0] = idx # multimodal could work like this, but this is not a concrete thing. + + X, Y = np.meshgrid(range(npts_greater_than), + range(npts_greater_than)) # assume square scan grid. Again, not always true. + oa = np.zeros((M, 3), dtype=np.int32) + oa[:N, 1] = X.ravel() + oa[N:, 1] = X.ravel() + oa[:N, 2] = Y.ravel() + oa[N:, 2] = Y.ravel() + for idx in range(num_object_modes): + if idx > 0: + oa[::idx, + 0] = idx # multimodal could work like this, but this is not a concrete thing (less likely for object) + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * num_probe_modes * num_object_modes) + ma = np.zeros((M, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + gexit_wave = deepcopy(exit_wave) + + out = con.difference_map_fourier_constraint(mask, Idata, obj, probe, exit_wave, addr_info, prefilter, + postfilter, pbound=pbound, alpha=alpha, LL_error=True, + do_realspace_error=True) + + gout = gcon.difference_map_fourier_constraint(mask, Idata, obj, probe, gexit_wave, addr_info, prefilter, + postfilter, pbound=pbound, alpha=alpha, LL_error=True, + do_realspace_error=True) + np.testing.assert_allclose(out, + gout, + rtol=1e-6, + err_msg="The returned errors are not consistent.") + + np.testing.assert_allclose(exit_wave, + gexit_wave, + rtol=1e-6, + err_msg="The expected in-place update of the exit wave didn't work properly.") + + + def test_difference_map_fourier_constraint_pbound_is_none_no_error(self): + + alpha = 1.0 # feedback constant + pbound = None # the power bound + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 4 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + npts_greater_than = int(np.sqrt(N)) # object is bigger than the probe by this amount + C = A + npts_greater_than + D = B + npts_greater_than + + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32) # the address book + Idata = np.empty(shape=(N, A, B), dtype=FLOAT_TYPE) # the measured intensities NxAxB + mask = np.empty(shape=(N, A, B), + dtype=np.int32) # the masks for the measured magnitudes either 1xAxB or NxAxB + probe = np.empty(shape=(num_probe_modes, A, B), dtype=COMPLEX_TYPE) # the probe function + obj = np.empty(shape=(num_object_modes, C, D), dtype=COMPLEX_TYPE) # the object function + prefilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + postfilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + + # now fill it with stuff. Data won't ever look like this except in type and usage! + Idata_fill = np.arange(np.prod(Idata.shape)).reshape(Idata.shape).astype(Idata.dtype) + Idata[:] = Idata_fill + + obj_fill = np.array([ix + 1j * (ix ** 2) for ix in range(np.prod(obj.shape))]).reshape( + (num_object_modes, C, D)) + obj[:] = obj_fill + + probe_fill = np.array([ix + 1j * ix for ix in range(10, 10 + np.prod(probe.shape), 1)]).reshape( + (num_probe_modes, A, B)) + probe[:] = probe_fill + + prefilter.fill(30.0 + 2.0j) # this would actually vary + postfilter.fill(20.0 + 3.0j) # this too + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(exit_wave.shape), 1)]).reshape((M, A, B)) + exit_wave[:] = exit_wave_fill + + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + pa = np.zeros((M, 3), dtype=np.int32) + for idx in range(num_probe_modes): + if idx > 0: + pa[::idx, 0] = idx # multimodal could work like this, but this is not a concrete thing. + + X, Y = np.meshgrid(range(npts_greater_than), + range(npts_greater_than)) # assume square scan grid. Again, not always true. + oa = np.zeros((M, 3), dtype=np.int32) + oa[:N, 1] = X.ravel() + oa[N:, 1] = X.ravel() + oa[:N, 2] = Y.ravel() + oa[N:, 2] = Y.ravel() + for idx in range(num_object_modes): + if idx > 0: + oa[::idx, + 0] = idx # multimodal could work like this, but this is not a concrete thing (less likely for object) + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * num_probe_modes * num_object_modes) + ma = np.zeros((M, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + + gexit_wave = deepcopy(exit_wave) + + out = con.difference_map_fourier_constraint(mask, Idata, obj, probe, exit_wave, addr_info, prefilter, + postfilter, pbound=pbound, alpha=alpha, LL_error=False, + do_realspace_error=False) + + gout = con.difference_map_fourier_constraint(mask, Idata, obj, probe, gexit_wave, addr_info, prefilter, + postfilter, pbound=pbound, alpha=alpha, LL_error=False, + do_realspace_error=False) + + np.testing.assert_allclose(out, + gout, + err_msg="The returned errors are not consistent.") + + np.testing.assert_allclose(exit_wave, + gexit_wave, + err_msg="The expected in-place update of the exit wave didn't work properly.") + + def test_difference_map_fourier_constraint_pbound_is_not_none_with_realspace_and_LL_error(self): + ''' + mixture of high and low p bound values respect to the fourier error + ''' + #expected_fourier_error = np.array([6.07364329e+12, 8.87756439e+13, 9.12644403e+12, 1.39851186e+14]) + pbound = 8.86e13 # this should now mean some of the arrays update differently through the logic + alpha = 1.0 # feedback constant + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 4 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + npts_greater_than = int(np.sqrt(N)) # object is bigger than the probe by this amount + C = A + npts_greater_than + D = B + npts_greater_than + + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32) # the address book + Idata = np.empty(shape=(N, A, B), dtype=FLOAT_TYPE) # the measured intensities NxAxB + mask = np.empty(shape=(N, A, B), + dtype=np.int32) # the masks for the measured magnitudes either 1xAxB or NxAxB + probe = np.empty(shape=(num_probe_modes, A, B), dtype=COMPLEX_TYPE) # the probe function + obj = np.empty(shape=(num_object_modes, C, D), dtype=COMPLEX_TYPE) # the object function + prefilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + postfilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + + # now fill it with stuff. Data won't ever look like this except in type and usage! + Idata_fill = np.arange(np.prod(Idata.shape)).reshape(Idata.shape).astype(Idata.dtype) + Idata[:] = Idata_fill + + obj_fill = np.array([ix + 1j * (ix ** 2) for ix in range(np.prod(obj.shape))]).reshape( + (num_object_modes, C, D)) + obj[:] = obj_fill + + probe_fill = np.array([ix + 1j * ix for ix in range(10, 10 + np.prod(probe.shape), 1)]).reshape( + (num_probe_modes, A, B)) + probe[:] = probe_fill + + prefilter.fill(30.0 + 2.0j) # this would actually vary + postfilter.fill(20.0 + 3.0j) # this too + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(exit_wave.shape), 1)]).reshape((M, A, B)) + exit_wave[:] = exit_wave_fill + + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + pa = np.zeros((M, 3), dtype=np.int32) + for idx in range(num_probe_modes): + if idx > 0: + pa[::idx, 0] = idx # multimodal could work like this, but this is not a concrete thing. + + X, Y = np.meshgrid(range(npts_greater_than), + range(npts_greater_than)) # assume square scan grid. Again, not always true. + oa = np.zeros((M, 3), dtype=np.int32) + oa[:N, 1] = X.ravel() + oa[N:, 1] = X.ravel() + oa[:N, 2] = Y.ravel() + oa[N:, 2] = Y.ravel() + for idx in range(num_object_modes): + if idx > 0: + oa[::idx, + 0] = idx # multimodal could work like this, but this is not a concrete thing (less likely for object) + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * num_probe_modes * num_object_modes) + ma = np.zeros((M, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + gexit_wave = deepcopy(exit_wave) + + out = con.difference_map_fourier_constraint(mask, Idata, obj, probe, exit_wave, addr_info, prefilter, + postfilter, pbound=pbound, alpha=alpha, LL_error=True, + do_realspace_error=True) + gout = gcon.difference_map_fourier_constraint(mask, Idata, obj, probe, gexit_wave, addr_info, prefilter, + postfilter, pbound=pbound, alpha=alpha, LL_error=True, + do_realspace_error=True) + np.testing.assert_allclose(out, + gout, + rtol=1e-6, + err_msg="The returned errors are not consistent.") + + np.testing.assert_allclose(exit_wave, + gexit_wave, + rtol=1e-6, + err_msg="The expected in-place update of the exit wave didn't work properly.") + + +if __name__ == '__main__': + unittest.main() + + + diff --git a/archive/cuda_extension/tests/constraints_test.py b/archive/cuda_extension/tests/constraints_test.py new file mode 100644 index 000000000..1c27d8827 --- /dev/null +++ b/archive/cuda_extension/tests/constraints_test.py @@ -0,0 +1,1079 @@ +''' +The tests for the constraints +''' + +import unittest +from . import utils as tu +import numpy as np +from copy import deepcopy + +from ptypy.accelerate.array_based import constraints as con +from ptypy.accelerate.array_based import data_utils as du +from ptypy.accelerate.array_based.constraints import difference_map_fourier_constraint, renormalise_fourier_magnitudes, get_difference +from archive.array_based.error_metrics import far_field_error +from ptypy.accelerate.array_based.object_probe_interaction import difference_map_realspace_constraint, scan_and_multiply +from archive.array_based.propagation import farfield_propagator +import ptypy.accelerate.array_based.array_utils as au +from ptypy.accelerate.array_based import COMPLEX_TYPE, FLOAT_TYPE + +from . import have_cuda, only_if_cuda_available +if have_cuda(): + from archive.cuda_extension.accelerate.cuda import constraints as gcon + from archive.cuda_extension.accelerate.cuda import get_difference as gget_difference + from archive.cuda_extension.accelerate.cuda import renormalise_fourier_magnitudes as grenormalise_fourier_magnitudes + from archive.cuda_extension.accelerate.cuda import difference_map_fourier_constraint as gdifference_map_fourier_constraint + from archive.cuda_extension.accelerate.cuda.config import init_gpus, reset_function_cache + init_gpus(0) + +@only_if_cuda_available +class ConstraintsTest(unittest.TestCase): + + def tearDown(self): + # reset the cached GPU functions after each test + reset_function_cache() + + def test_get_difference_UNITY(self): + alpha = 1.0 + pbound = None + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + master_pod = PtychoInstance.diff.V[first_view_id].pod + propagator = master_pod.geometry.propagator + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + exit_wave = vectorised_scan['exit wave'] + Idata = vectorised_scan['diffraction'] + mask = vectorised_scan['mask'] + + # # Propagate the exit waves + probe_object = scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + constrained = difference_map_realspace_constraint(probe_object, exit_wave, alpha) + f = farfield_propagator(constrained, propagator.pre_fft, propagator.post_fft, direction='forward') + pa, oa, ea, da, ma = zip(*addr_info) + af2 = au.sum_to_buffer(au.abs2(f), Idata.shape, ea, da, dtype=FLOAT_TYPE) + + fmag = np.sqrt(np.abs(Idata)) + af = np.sqrt(af2) + # # Fourier magnitudes deviations(current_solution, pbound, measured_solution, mask, addr) + err_fmag = far_field_error(af, fmag, mask) + renormed_f = renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + + + backpropagated_solution = farfield_propagator(renormed_f, + propagator.post_fft.conj(), + propagator.pre_fft.conj(), + direction='backward') + + difference = get_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, probe_object) + gdifference = gget_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, probe_object) + + np.testing.assert_allclose(difference, gdifference, rtol=6e-5) + # Detailed errors + max_relerr = np.max(np.abs((gdifference-difference) / difference)) + max_abserr = np.max(np.abs(gdifference-difference)) + print("Max errors: rel={}, abs={}".format(max_relerr, max_abserr)) + + def test_get_difference_pbound_UNITY(self): + alpha = 1.0 + pbound = 0.597053604126 + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + master_pod = PtychoInstance.diff.V[first_view_id].pod + propagator = master_pod.geometry.propagator + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + exit_wave = vectorised_scan['exit wave'] + Idata = vectorised_scan['diffraction'] + mask = vectorised_scan['mask'] + + # # Propagate the exit waves + probe_object = scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + constrained = difference_map_realspace_constraint(probe_object, exit_wave, alpha) + f = farfield_propagator(constrained, propagator.pre_fft, propagator.post_fft, direction='forward') + pa, oa, ea, da, ma = zip(*addr_info) + af2 = au.sum_to_buffer(au.abs2(f), Idata.shape, ea, da, dtype=FLOAT_TYPE) + + fmag = np.sqrt(np.abs(Idata)) + af = np.sqrt(af2) + # # Fourier magnitudes deviations(current_solution, pbound, measured_solution, mask, addr) + err_fmag = far_field_error(af, fmag, mask) + err_fmag = np.ones_like(err_fmag) * 145.824958919 + renormed_f = renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + + backpropagated_solution = farfield_propagator(renormed_f, + propagator.post_fft.conj(), + propagator.pre_fft.conj(), + direction='backward') + + difference = get_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, probe_object) + gdifference = gget_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, probe_object) + + np.testing.assert_allclose(difference, gdifference, rtol=6e-5) + # Detailed errors + max_relerr = np.max(np.abs((gdifference-difference) / difference)) + max_abserr = np.max(np.abs(gdifference-difference)) + print("Max errors: rel={}, abs={}".format(max_relerr, max_abserr)) + + def test_get_difference_no_update_UNITY(self): + alpha = 1.0 + pbound = 0.597053604126 + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + master_pod = PtychoInstance.diff.V[first_view_id].pod + propagator = master_pod.geometry.propagator + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + exit_wave = vectorised_scan['exit wave'] + Idata = vectorised_scan['diffraction'] + mask = vectorised_scan['mask'] + + # # Propagate the exit waves + probe_object = scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + constrained = difference_map_realspace_constraint(probe_object, exit_wave, alpha) + f = farfield_propagator(constrained, propagator.pre_fft, propagator.post_fft, direction='forward') + pa, oa, ea, da, ma = zip(*addr_info) + af2 = au.sum_to_buffer(au.abs2(f), Idata.shape, ea, da, dtype=FLOAT_TYPE) + + fmag = np.sqrt(np.abs(Idata)) + af = np.sqrt(af2) + # # Fourier magnitudes deviations(current_solution, pbound, measured_solution, mask, addr) + err_fmag = far_field_error(af, fmag, mask) + err_fmag = np.ones_like(err_fmag) * 0.4 + renormed_f = renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + + backpropagated_solution = farfield_propagator(renormed_f, + propagator.post_fft.conj(), + propagator.pre_fft.conj(), + direction='backward') + + difference = get_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, probe_object) + gdifference = gget_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, probe_object) + + # result is actually all-zero, so array_equal works + np.testing.assert_array_equal(difference, gdifference) + + def test_renormalise_fourier_magnitudes_UNITY(self): + alpha = 1.0 + pbound = None + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + master_pod = PtychoInstance.diff.V[first_view_id].pod + propagator = master_pod.geometry.propagator + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + exit_wave = vectorised_scan['exit wave'] + Idata = vectorised_scan['diffraction'] + mask = vectorised_scan['mask'] + # # Propagate the exit waves + probe_object = scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + constrained = difference_map_realspace_constraint(probe_object, exit_wave, alpha) + f = farfield_propagator(constrained, propagator.pre_fft, propagator.post_fft, direction='forward') + pa, oa, ea, da, ma = zip(*addr_info) + af2 = au.sum_to_buffer(au.abs2(f), Idata.shape, ea, da, dtype=FLOAT_TYPE) + + fmag = np.sqrt(np.abs(Idata)) + af = np.sqrt(af2) + # # Fourier magnitudes deviations(current_solution, pbound, measured_solution, mask, addr) + err_fmag = far_field_error(af, fmag, mask) + + renormed_f = renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + grenormed_f = grenormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + + np.testing.assert_allclose(renormed_f, grenormed_f, rtol=1e-6) + + def test_renormalise_fourier_magnitudes_pbound_UNITY(self): + alpha = 1.0 + pbound = 0.597053604126 + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + master_pod = PtychoInstance.diff.V[first_view_id].pod + propagator = master_pod.geometry.propagator + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + exit_wave = vectorised_scan['exit wave'] + Idata = vectorised_scan['diffraction'] + mask = vectorised_scan['mask'] + + # # Propagate the exit waves + probe_object = scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + constrained = difference_map_realspace_constraint(probe_object, exit_wave, alpha) + f = farfield_propagator(constrained, propagator.pre_fft, propagator.post_fft, direction='forward') + pa, oa, ea, da, ma = zip(*addr_info) + af2 = au.sum_to_buffer(au.abs2(f), Idata.shape, ea, da, dtype=FLOAT_TYPE) + + fmag = np.sqrt(np.abs(Idata)) + af = np.sqrt(af2) + # # Fourier magnitudes deviations(current_solution, pbound, measured_solution, mask, addr) + err_fmag = far_field_error(af, fmag, mask) + err_fmag = np.ones_like(err_fmag) * 145.824958919 + renormed_f = renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + grenormed_f = grenormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + + np.testing.assert_allclose(renormed_f, grenormed_f, rtol=1e-6) + + def test_renormalise_fourier_magnitudes_no_update_UNITY(self): + alpha = 1.0 + pbound = 0.597053604126 + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + master_pod = PtychoInstance.diff.V[first_view_id].pod + propagator = master_pod.geometry.propagator + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + exit_wave = vectorised_scan['exit wave'] + Idata = vectorised_scan['diffraction'] + mask = vectorised_scan['mask'] + + # # Propagate the exit waves + probe_object = scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + constrained = difference_map_realspace_constraint(probe_object, exit_wave, alpha) + f = farfield_propagator(constrained, propagator.pre_fft, propagator.post_fft, direction='forward') + pa, oa, ea, da, ma = zip(*addr_info) + af2 = au.sum_to_buffer(au.abs2(f), Idata.shape, ea, da, dtype=FLOAT_TYPE) + + fmag = np.sqrt(np.abs(Idata)) + af = np.sqrt(af2) + # # Fourier magnitudes deviations(current_solution, pbound, measured_solution, mask, addr) + err_fmag = far_field_error(af, fmag, mask) + err_fmag = np.ones_like(err_fmag) * 0.4 + renormed_f = renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + grenormed_f = grenormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + + np.testing.assert_array_equal(renormed_f, grenormed_f) + + def test_difference_map_fourier_constraint_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + master_pod = PtychoInstance.diff.V[first_view_id].pod + propagator = master_pod.geometry.propagator + + # take a copy of the starting point, as function updates in-place + exit_wave_start = np.copy(vectorised_scan['exit wave']) + + errors = difference_map_fourier_constraint( + vectorised_scan['mask'], + vectorised_scan['diffraction'], + vectorised_scan['obj'], + vectorised_scan['probe'], + vectorised_scan['exit wave'], + vectorised_scan['meta']['addr'], + prefilter=propagator.pre_fft, + postfilter=propagator.post_fft, + pbound=None, + alpha=1.0, + LL_error=True) + + # keep result, copy original back + exit_wave = vectorised_scan['exit wave'] + vectorised_scan['exit wave'] = exit_wave_start + + gerrors = gdifference_map_fourier_constraint(vectorised_scan['mask'], + vectorised_scan['diffraction'], + vectorised_scan['obj'], + vectorised_scan['probe'], + vectorised_scan['exit wave'], + vectorised_scan['meta']['addr'], + prefilter=propagator.pre_fft, + postfilter=propagator.post_fft, + pbound=None, + alpha=1.0, + LL_error=True) + + gexit_wave = vectorised_scan['exit wave'] + + max_relerr = np.max(np.abs((exit_wave-gexit_wave) / exit_wave)) + mean_relerr = np.mean(np.abs((exit_wave-gexit_wave) / exit_wave)) + max_abserr = np.max(np.abs(exit_wave-gexit_wave)) + mean_abserr = np.mean(np.abs(exit_wave-gexit_wave)) + print("Exit wave max errors: rel={}, abs={}".format(max_relerr, max_abserr)) + print("Exit wave mean errors: rel={}, abs={}".format(mean_relerr, mean_abserr)) + + max_relerr = np.max(np.abs((errors-gerrors) / errors), axis=None) + mean_relerr = np.mean(np.abs((errors-gerrors) / errors), axis=None) + max_abserr = np.max(np.abs(errors-gerrors), axis=None) + mean_abserr = np.mean(np.abs(errors-gerrors), axis=None) + print("Errors max errors: rel={}, abs={}".format(max_relerr, max_abserr)) + print("Errors mean errors: rel={}, abs={}".format(mean_relerr, mean_abserr)) + + np.testing.assert_allclose(exit_wave, gexit_wave, rtol=3e-1, atol=18) + np.testing.assert_allclose(errors, gerrors, rtol=3e-4) + + def test_difference_map_fourier_constraint_pbound_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + master_pod = PtychoInstance.diff.V[first_view_id].pod + propagator = master_pod.geometry.propagator + pbound = 0.597053604126 + + # take a copy of the starting point, as function updates in-place + exit_wave_start = np.copy(vectorised_scan['exit wave']) + + errors = difference_map_fourier_constraint(vectorised_scan['mask'], + vectorised_scan['diffraction'], + vectorised_scan['obj'], + vectorised_scan['probe'], + vectorised_scan['exit wave'], + vectorised_scan['meta']['addr'], + prefilter=propagator.pre_fft, + postfilter=propagator.post_fft, + pbound=pbound, + alpha=1.0, + LL_error=True) + + # keep result, copy original back + exit_wave = vectorised_scan['exit wave'] + vectorised_scan['exit wave'] = exit_wave_start + + gerrors = gdifference_map_fourier_constraint(vectorised_scan['mask'], + vectorised_scan['diffraction'], + vectorised_scan['obj'], + vectorised_scan['probe'], + vectorised_scan['exit wave'], + vectorised_scan['meta']['addr'], + prefilter=propagator.pre_fft, + postfilter=propagator.post_fft, + pbound=pbound, + alpha=1.0, + LL_error=True) + + gexit_wave = vectorised_scan['exit wave'] + + max_relerr = np.max(np.abs((exit_wave-gexit_wave) / exit_wave)) + mean_relerr = np.mean(np.abs((exit_wave-gexit_wave) / exit_wave)) + max_abserr = np.max(np.abs(exit_wave-gexit_wave)) + mean_abserr = np.mean(np.abs(exit_wave-gexit_wave)) + print("Exit wave max errors: rel={}, abs={}".format(max_relerr, max_abserr)) + print("Exit wave mean errors: rel={}, abs={}".format(mean_relerr, mean_abserr)) + + max_relerr = np.max(np.abs((errors-gerrors) / errors), axis=None) + mean_relerr = np.mean(np.abs((errors-gerrors) / errors), axis=None) + max_abserr = np.max(np.abs(errors-gerrors), axis=None) + mean_abserr = np.mean(np.abs(errors-gerrors), axis=None) + print("Errors max errors: rel={}, abs={}".format(max_relerr, max_abserr)) + print("Errors mean errors: rel={}, abs={}".format(mean_relerr, mean_abserr)) + + np.testing.assert_allclose(exit_wave, gexit_wave, rtol=4e-1, atol=16) + np.testing.assert_allclose(errors, gerrors, rtol=4e-4) + + def test_difference_map_fourier_constraint_no_update_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + master_pod = PtychoInstance.diff.V[first_view_id].pod + propagator = master_pod.geometry.propagator + pbound = 200.0 + + # take a copy of the starting point, as function updates in-place + exit_wave_start = deepcopy(vectorised_scan['exit wave']) + + errors = difference_map_fourier_constraint(vectorised_scan['mask'], + vectorised_scan['diffraction'], + vectorised_scan['obj'], + vectorised_scan['probe'], + vectorised_scan['exit wave'], + vectorised_scan['meta']['addr'], + prefilter=propagator.pre_fft, + postfilter=propagator.post_fft, + pbound=pbound, + alpha=1.0, + LL_error=True) + # keep result, copy original back + exit_wave = vectorised_scan['exit wave'] + vectorised_scan['exit wave'] = exit_wave_start + + + gerrors = gdifference_map_fourier_constraint(vectorised_scan['mask'], + vectorised_scan['diffraction'], + vectorised_scan['obj'], + vectorised_scan['probe'], + vectorised_scan['exit wave'], + vectorised_scan['meta']['addr'], + prefilter=propagator.pre_fft, + postfilter=propagator.post_fft, + pbound=pbound, + alpha=1.0, + LL_error=True) + + gexit_wave = vectorised_scan['exit wave'] + + max_relerr = np.nanmax(np.abs((exit_wave-gexit_wave) / exit_wave)) + mean_relerr = np.nanmean(np.abs((exit_wave-gexit_wave) / exit_wave)) + max_abserr = np.max(np.abs(exit_wave-gexit_wave)) + mean_abserr = np.mean(np.abs(exit_wave-gexit_wave)) + print("Exit wave max errors: rel={}, abs={}".format(max_relerr, max_abserr)) + print("Exit wave mean errors: rel={}, abs={}".format(mean_relerr, mean_abserr)) + + max_relerr = np.nanmax(np.abs((errors-gerrors) / errors), axis=None) + mean_relerr = np.nanmean(np.abs((errors-gerrors) / errors), axis=None) + max_abserr = np.max(np.abs(errors-gerrors), axis=None) + mean_abserr = np.mean(np.abs(errors-gerrors), axis=None) + print("Errors max errors: rel={}, abs={}".format(max_relerr, max_abserr)) + print("Errors mean errors: rel={}, abs={}".format(mean_relerr, mean_abserr)) + + np.testing.assert_allclose(exit_wave, gexit_wave, rtol=5e-1, atol=10) + np.testing.assert_allclose(errors, gerrors, rtol=3e-4) + + def test_difference_map_fourier_constraint_pbound_is_none_with_realspace_error_and_LL_error(self): + + alpha = 1.0 # feedback constant + pbound = None # the power bound + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 4 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + npts_greater_than = int(np.sqrt(N)) # object is bigger than the probe by this amount + C = A + npts_greater_than + D = B + npts_greater_than + + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE)# deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32)# the address book + Idata = np.empty(shape=(N, A, B), dtype=FLOAT_TYPE)# the measured intensities NxAxB + mask = np.empty(shape=(N, A, B), dtype=np.int32)# the masks for the measured magnitudes either 1xAxB or NxAxB + probe = np.empty(shape=(num_probe_modes, A, B), dtype=COMPLEX_TYPE) # the probe function + obj = np.empty(shape=(num_object_modes, C, D), dtype=COMPLEX_TYPE) # the object function + prefilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + postfilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + + + # now fill it with stuff. Data won't ever look like this except in type and usage! + Idata_fill = np.arange(np.prod(Idata.shape)).reshape(Idata.shape).astype(Idata.dtype) + Idata[:] = Idata_fill + + obj_fill = np.array([ix + 1j*(ix**2) for ix in range(np.prod(obj.shape))]).reshape((num_object_modes, C, D)) + obj[:] = obj_fill + + probe_fill = np.array([ix + 1j*ix for ix in range(10, 10+np.prod(probe.shape), 1)]).reshape((num_probe_modes, A, B)) + probe[:] = probe_fill + + prefilter.fill(30.0 + 2.0j)# this would actually vary + postfilter.fill(20.0 + 3.0j)# this too + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array([ix**2 + 1j*ix for ix in range(20, 20+np.prod(exit_wave.shape), 1)]).reshape((M, A, B)) + exit_wave[:] = exit_wave_fill + + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + pa = np.zeros((M, 3), dtype=np.int32) + for idx in range(num_probe_modes): + if idx>0: + pa[::idx,0]=idx # multimodal could work like this, but this is not a concrete thing. + + + X, Y = np.meshgrid(range(npts_greater_than), range(npts_greater_than)) # assume square scan grid. Again, not always true. + oa = np.zeros((M, 3), dtype=np.int32) + oa[:N, 1] = X.ravel() + oa[N:, 1] = X.ravel() + oa[:N, 2] = Y.ravel() + oa[N:, 2] = Y.ravel() + for idx in range(num_object_modes): + if idx>0: + oa[::idx,0]=idx # multimodal could work like this, but this is not a concrete thing (less likely for object) + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)]*num_probe_modes*num_object_modes) + ma = np.zeros((M, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + gexit_wave = deepcopy(exit_wave) + + errors = con.difference_map_fourier_constraint(mask, Idata, obj, probe, exit_wave, addr_info, prefilter, postfilter, pbound=pbound, alpha=alpha, LL_error=True, do_realspace_error=True) + gerrors = gcon.difference_map_fourier_constraint(mask, Idata, obj, probe, gexit_wave, addr_info, prefilter, + postfilter, pbound=pbound, alpha=alpha, LL_error=True, + do_realspace_error=True) + + np.testing.assert_allclose(gerrors, + errors, + rtol=1e-6, + err_msg="The returned errors are not consistent.") + + np.testing.assert_allclose(gexit_wave, + exit_wave, + rtol=1e-6, + err_msg="The expected in-place update of the exit wave didn't work properly.") + + def test_difference_map_fourier_constraint_pbound_is_none_no_error(self): + + alpha = 1.0 # feedback constant + pbound = None # the power bound + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 4 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + npts_greater_than = int(np.sqrt(N)) # object is bigger than the probe by this amount + C = A + npts_greater_than + D = B + npts_greater_than + + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32) # the address book + Idata = np.empty(shape=(N, A, B), dtype=FLOAT_TYPE) # the measured intensities NxAxB + mask = np.empty(shape=(N, A, B), + dtype=np.int32) # the masks for the measured magnitudes either 1xAxB or NxAxB + probe = np.empty(shape=(num_probe_modes, A, B), dtype=COMPLEX_TYPE) # the probe function + obj = np.empty(shape=(num_object_modes, C, D), dtype=COMPLEX_TYPE) # the object function + prefilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + postfilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + + # now fill it with stuff. Data won't ever look like this except in type and usage! + Idata_fill = np.arange(np.prod(Idata.shape)).reshape(Idata.shape).astype(Idata.dtype) + Idata[:] = Idata_fill + + obj_fill = np.array([ix + 1j * (ix ** 2) for ix in range(np.prod(obj.shape))]).reshape( + (num_object_modes, C, D)) + obj[:] = obj_fill + + probe_fill = np.array([ix + 1j * ix for ix in range(10, 10 + np.prod(probe.shape), 1)]).reshape( + (num_probe_modes, A, B)) + probe[:] = probe_fill + + prefilter.fill(30.0 + 2.0j) # this would actually vary + postfilter.fill(20.0 + 3.0j) # this too + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(exit_wave.shape), 1)]).reshape((M, A, B)) + exit_wave[:] = exit_wave_fill + + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + pa = np.zeros((M, 3), dtype=np.int32) + for idx in range(num_probe_modes): + if idx > 0: + pa[::idx, 0] = idx # multimodal could work like this, but this is not a concrete thing. + + X, Y = np.meshgrid(range(npts_greater_than), + range(npts_greater_than)) # assume square scan grid. Again, not always true. + oa = np.zeros((M, 3), dtype=np.int32) + oa[:N, 1] = X.ravel() + oa[N:, 1] = X.ravel() + oa[:N, 2] = Y.ravel() + oa[N:, 2] = Y.ravel() + for idx in range(num_object_modes): + if idx > 0: + oa[::idx, + 0] = idx # multimodal could work like this, but this is not a concrete thing (less likely for object) + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * num_probe_modes * num_object_modes) + ma = np.zeros((M, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + gexit_wave = deepcopy(exit_wave) + + gerrors = gcon.difference_map_fourier_constraint(mask, Idata, obj, probe, gexit_wave, addr_info, prefilter, + postfilter, pbound=pbound, alpha=alpha, LL_error=False, + do_realspace_error=False) + errors = con.difference_map_fourier_constraint(mask, Idata, obj, probe, exit_wave, addr_info, prefilter, + postfilter, pbound=pbound, alpha=alpha, LL_error=False, + do_realspace_error=False) + + np.testing.assert_allclose(gerrors, + errors, + rtol=1e-6, + err_msg="The returned errors are not consistent.") + + np.testing.assert_allclose(gexit_wave, + exit_wave, + rtol=1e-6, + err_msg="The expected in-place update of the exit wave didn't work properly.") + + + def test_difference_map_fourier_constraint_pbound_is_not_none_with_realspace_and_LL_error(self): + ''' + mixture of high and low p bound values respect to the fourier error + ''' + #expected_fourier_error = np.array([6.07364329e+12, 8.87756439e+13, 9.12644403e+12, 1.39851186e+14]) + pbound = 8.86e13 # this should now mean some of the arrays update differently through the logic + alpha = 1.0 # feedback constant + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 4 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + npts_greater_than = int(np.sqrt(N)) # object is bigger than the probe by this amount + C = A + npts_greater_than + D = B + npts_greater_than + + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32) # the address book + Idata = np.empty(shape=(N, A, B), dtype=FLOAT_TYPE) # the measured intensities NxAxB + mask = np.empty(shape=(N, A, B), + dtype=np.int32) # the masks for the measured magnitudes either 1xAxB or NxAxB + probe = np.empty(shape=(num_probe_modes, A, B), dtype=COMPLEX_TYPE) # the probe function + obj = np.empty(shape=(num_object_modes, C, D), dtype=COMPLEX_TYPE) # the object function + prefilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + postfilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + + # now fill it with stuff. Data won't ever look like this except in type and usage! + Idata_fill = np.arange(np.prod(Idata.shape)).reshape(Idata.shape).astype(Idata.dtype) + Idata[:] = Idata_fill + + obj_fill = np.array([ix + 1j * (ix ** 2) for ix in range(np.prod(obj.shape))]).reshape( + (num_object_modes, C, D)) + obj[:] = obj_fill + + probe_fill = np.array([ix + 1j * ix for ix in range(10, 10 + np.prod(probe.shape), 1)]).reshape( + (num_probe_modes, A, B)) + probe[:] = probe_fill + + prefilter.fill(30.0 + 2.0j) # this would actually vary + postfilter.fill(20.0 + 3.0j) # this too + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(exit_wave.shape), 1)]).reshape((M, A, B)) + exit_wave[:] = exit_wave_fill + + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + pa = np.zeros((M, 3), dtype=np.int32) + for idx in range(num_probe_modes): + if idx > 0: + pa[::idx, 0] = idx # multimodal could work like this, but this is not a concrete thing. + + X, Y = np.meshgrid(range(npts_greater_than), + range(npts_greater_than)) # assume square scan grid. Again, not always true. + oa = np.zeros((M, 3), dtype=np.int32) + oa[:N, 1] = X.ravel() + oa[N:, 1] = X.ravel() + oa[:N, 2] = Y.ravel() + oa[N:, 2] = Y.ravel() + for idx in range(num_object_modes): + if idx > 0: + oa[::idx, + 0] = idx # multimodal could work like this, but this is not a concrete thing (less likely for object) + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * num_probe_modes * num_object_modes) + ma = np.zeros((M, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + gexit_wave = deepcopy(exit_wave) + + gerrors = gcon.difference_map_fourier_constraint(mask, Idata, obj, probe, gexit_wave, addr_info, prefilter, + postfilter, pbound=pbound, alpha=alpha, LL_error=True, + do_realspace_error=True) + errors = con.difference_map_fourier_constraint(mask, Idata, obj, probe, exit_wave, addr_info, prefilter, + postfilter, pbound=pbound, alpha=alpha, LL_error=True, + do_realspace_error=True) + + np.testing.assert_allclose(gerrors, + errors, + rtol=1e-6, + err_msg="The returned errors are not consistent.") + + np.testing.assert_allclose(gexit_wave, + exit_wave, + rtol=1e-6, + err_msg="The expected in-place update of the exit wave didn't work properly.") + + + @unittest.skip("The test doesn't work, but moonflower sample shows that this is actually working ok") + def test_difference_map_iterator_with_probe_update(self): + ''' + This test, assumes the logic below this function works fine, and just does some iterations of difference map on + some spoof data to check that the combination works. + ''' + num_iter = 2 + + pbound = 8.86e13 # this should now mean some of the arrays update differently through the logic + alpha = 1.0 # feedback constant + # diffraction frame size + B = 2 # for example + C = 4 # for example + + # probe dimensions + D = 2 # for example + E = B + F = C + + scan_pts = 2 # a 2x2 grid + N = scan_pts**2 # the number of measurement points in a scan + npts_greater_than = int(np.sqrt(N)) # object is bigger than the probe by this amount + + # object dimensions + G = 1 # for example + H = B + npts_greater_than + I = C + npts_greater_than + + A = scan_pts ** 2 * G * D # number of exit waves + + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(A, 5, 3), dtype=np.int32) # the address book + diffraction = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured intensities NxAxB + mask = np.empty(shape=(N, B, C), + dtype=np.int32) # the masks for the measured magnitudes either 1xAxB or NxAxB + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) # the probe function + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) # the object function + prefilter = np.empty(shape=(B, C), dtype=COMPLEX_TYPE) + postfilter = np.empty(shape=(B, C), dtype=COMPLEX_TYPE) + + # now fill it with stuff. Data won't ever look like this except in type and usage! + diffraction_fill = np.arange(np.prod(diffraction.shape)).reshape(diffraction.shape).astype(diffraction.dtype) + diffraction[:] = diffraction_fill + + obj_fill = np.array([ix + 1j * (ix ** 2) for ix in range(np.prod(obj.shape))]).reshape( + (G, H, I)) + obj[:] = obj_fill + + probe_fill = np.array([ix + 1j * ix for ix in range(10, 10 + np.prod(probe.shape), 1)]).reshape( + (D, B, C)) + probe[:] = probe_fill + + prefilter.fill(30.0 + 2.0j) # this would actually vary + postfilter.fill(20.0 + 3.0j) # this too + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(exit_wave.shape), 1)]).reshape((A, B, C)) + exit_wave[:] = exit_wave_fill + + mask_fill = np.ones_like(mask) + # mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + pa = np.zeros((A, 3), dtype=np.int32) + pa[:N,0] = 0 + pa[N:, 0] = 1 + + X, Y = np.meshgrid(range(npts_greater_than), + range(npts_greater_than)) # assume square scan grid. Again, not always true. + oa = np.zeros((A, 3), dtype=np.int32) + oa[:N, 1] = X.ravel() + oa[N:, 1] = X.ravel() + oa[:N, 2] = Y.ravel() + oa[N:, 2] = Y.ravel() + + + ea = np.array([np.array([ix, 0, 0]) for ix in range(A)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * D * G) + ma = np.zeros((A, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + + for idx in range(D): + cfact_probe[idx] = np.ones((B, C)) * 5 * (idx + 1) + + gexit_wave = deepcopy(exit_wave) + gprobe = deepcopy(probe) + gobj = deepcopy(obj) + + errors = con.difference_map_iterator(diffraction=diffraction, + obj=obj, + object_weights=obj_weights, + cfact_object=cfact_object, + mask=mask, + probe=probe, + cfact_probe=cfact_probe, + probe_support=None, + probe_weights=probe_weights, + exit_wave=exit_wave, + addr=addr_info, + pre_fft=prefilter, + post_fft=postfilter, + pbound=pbound, + overlap_max_iterations=10, + update_object_first=False, + obj_smooth_std=None, + overlap_converge_factor=1.4e-3, + probe_center_tol=None, + probe_update_start=1, + alpha=alpha, + clip_object=None, + LL_error=True, + num_iterations=num_iter) + + gerrors = gcon.difference_map_iterator(diffraction=diffraction, + obj=gobj, + object_weights=obj_weights, + cfact_object=cfact_object, + mask=mask, + probe=gprobe, + cfact_probe=cfact_probe, + probe_support=None, + probe_weights=probe_weights, + exit_wave=gexit_wave, + addr=addr_info, + pre_fft=prefilter, + post_fft=postfilter, + pbound=pbound, + overlap_max_iterations=10, + update_object_first=False, + obj_smooth_std=None, + overlap_converge_factor=1.4e-3, + probe_center_tol=None, + probe_update_start=1, + alpha=alpha, + clip_object=None, + LL_error=True, + num_iterations=num_iter) + + np.testing.assert_allclose(gerrors, + errors, + rtol=1e-6, + err_msg="The returned errors are not consistent.") + + np.testing.assert_allclose(gprobe, + probe, + rtol=1e-6, + err_msg="The returned probes are not consistent.") + + np.testing.assert_allclose(gobj, + obj, + rtol=1e-6, + err_msg="The returned objects are not consistent.") + + np.testing.assert_allclose(gexit_wave[3,:,:], + exit_wave[3,:,:], + rtol=1e-6, + atol=1e-4, + err_msg="The returned exit_waves are not consistent.") + + def test_difference_map_iterator_with_no_probe_update_and_object_update(self): + ''' + This test, assumes the logic below this function works fine, and just does some iterations of difference map on + some spoof data to check that the combination works. + ''' + num_iter = 1 + + pbound = 8.86e13 # this should now mean some of the arrays update differently through the logic + alpha = 1.0 # feedback constant + # diffraction frame size + B = 2 # for example + C = 4 # for example + + # probe dimensions + D = 2 # for example + E = B + F = C + + scan_pts = 2 # a 2x2 grid + N = scan_pts**2 # the number of measurement points in a scan + npts_greater_than = int(np.sqrt(N)) # object is bigger than the probe by this amount + + # object dimensions + G = 1 # for example + H = B + npts_greater_than + I = C + npts_greater_than + + A = scan_pts ** 2 * G * D # number of exit waves + + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(A, 5, 3), dtype=np.int32) # the address book + diffraction = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured intensities NxAxB + mask = np.empty(shape=(N, B, C), + dtype=np.int32) # the masks for the measured magnitudes either 1xAxB or NxAxB + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) # the probe function + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) # the object function + prefilter = np.empty(shape=(B, C), dtype=COMPLEX_TYPE) + postfilter = np.empty(shape=(B, C), dtype=COMPLEX_TYPE) + + # now fill it with stuff. Data won't ever look like this except in type and usage! + diffraction_fill = np.arange(np.prod(diffraction.shape)).reshape(diffraction.shape).astype(diffraction.dtype) + diffraction[:] = diffraction_fill + + obj_fill = np.array([ix + 1j * (ix ** 2) for ix in range(np.prod(obj.shape))]).reshape( + (G, H, I)) + obj[:] = obj_fill + + probe_fill = np.array([ix + 1j * ix for ix in range(10, 10 + np.prod(probe.shape), 1)]).reshape( + (D, B, C)) + probe[:] = probe_fill + + prefilter.fill(30.0 + 2.0j) # this would actually vary + postfilter.fill(20.0 + 3.0j) # this too + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(exit_wave.shape), 1)]).reshape((A, B, C)) + exit_wave[:] = exit_wave_fill + + mask_fill = np.ones_like(mask) + # mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + pa = np.zeros((A, 3), dtype=np.int32) + pa[:N,0] = 0 + pa[N:, 0] = 1 + + X, Y = np.meshgrid(range(npts_greater_than), + range(npts_greater_than)) # assume square scan grid. Again, not always true. + oa = np.zeros((A, 3), dtype=np.int32) + oa[:N, 1] = X.ravel() + oa[N:, 1] = X.ravel() + oa[:N, 2] = Y.ravel() + oa[N:, 2] = Y.ravel() + + + ea = np.array([np.array([ix, 0, 0]) for ix in range(A)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * D * G) + ma = np.zeros((A, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + + for idx in range(D): + cfact_probe[idx] = np.ones((B, C)) * 5 * (idx + 1) + + gexit_wave = deepcopy(exit_wave) + gprobe = deepcopy(probe) + gobj = deepcopy(obj) + + errors = con.difference_map_iterator(diffraction=diffraction, + obj=obj, + object_weights=obj_weights, + cfact_object=cfact_object, + mask=mask, + probe=probe, + cfact_probe=cfact_probe, + probe_support=None, + probe_weights=probe_weights, + exit_wave=exit_wave, + addr=addr_info, + pre_fft=prefilter, + post_fft=postfilter, + pbound=pbound, + overlap_max_iterations=10, + update_object_first=True, + obj_smooth_std=None, + overlap_converge_factor=1.4e-3, + probe_center_tol=None, + probe_update_start=1, + alpha=alpha, + clip_object=None, + LL_error=True, + num_iterations=num_iter) + + gerrors = gcon.difference_map_iterator(diffraction=diffraction, + obj=gobj, + object_weights=obj_weights, + cfact_object=cfact_object, + mask=mask, + probe=gprobe, + cfact_probe=cfact_probe, + probe_support=None, + probe_weights=probe_weights, + exit_wave=gexit_wave, + addr=addr_info, + pre_fft=prefilter, + post_fft=postfilter, + pbound=pbound, + overlap_max_iterations=10, + update_object_first=True, + obj_smooth_std=None, + overlap_converge_factor=1.4e-3, + probe_center_tol=None, + probe_update_start=1, + alpha=alpha, + clip_object=None, + LL_error=True, + num_iterations=num_iter) + + + np.testing.assert_allclose(gerrors, + errors, + rtol=1e-6, + err_msg="The returned errors are not consistent.") + + np.testing.assert_allclose(gprobe, + probe, + rtol=1e-6, + err_msg="The returned probes are not consistent.") + + np.testing.assert_allclose(gobj, + obj, + rtol=1e-6, + err_msg="The returned objects are not consistent.") + + np.testing.assert_allclose(gexit_wave, + exit_wave, + rtol=1e-6, + err_msg="The returned exit_waves are not consistent.") + + +if __name__ == '__main__': + unittest.main() + + + diff --git a/archive/cuda_extension/tests/data_utils_test.py b/archive/cuda_extension/tests/data_utils_test.py new file mode 100644 index 000000000..1fc37b24d --- /dev/null +++ b/archive/cuda_extension/tests/data_utils_test.py @@ -0,0 +1,54 @@ +''' +Created on 4 Jan 2018 + +@author: clb02321 +''' +import unittest +from . import utils as tu +import numpy as np + +from ptypy.accelerate.array_based import data_utils as du + + + +class DataUtilsTest(unittest.TestCase): + ''' + tests the conversion between pods and numpy arrays + ''' + + def test_pod_to_numpy(self): + ''' + tests if the vectorisation process works + ''' + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + du.pod_to_arrays(PtychoInstance, 'S0000', scan_model='Full') + + def test_numpy_pod_consistency(self): + ''' + vectorises the Ptycho instance. + ''' + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + addr = vectorised_scan['meta']['addr'] + view_IDS = vectorised_scan['meta']['view_IDs'] + + # check the probe references match up + vectorised_scan['probe'] *= np.random.rand(*vectorised_scan['probe'].shape) + + pa, oa, ea, da, ma = zip(*addr) + + for idx, vID in enumerate(view_IDS): + np.testing.assert_array_equal(vectorised_scan['probe'][pa[idx][0]], PtychoInstance.pr.V[vID].data) + + + + vectorised_scan['exit wave'] *= np.random.rand(*vectorised_scan['exit wave'].shape) + + for idx, vID in enumerate(view_IDS): + np.testing.assert_array_equal(vectorised_scan['exit wave'][ea[idx][0]], PtychoInstance.ex.V[vID].data) + + + + +if __name__ == "__main__": + unittest.main() diff --git a/archive/cuda_extension/tests/engine_iterate_unity_test.py b/archive/cuda_extension/tests/engine_iterate_unity_test.py new file mode 100644 index 000000000..b73c428ec --- /dev/null +++ b/archive/cuda_extension/tests/engine_iterate_unity_test.py @@ -0,0 +1,209 @@ +''' +This test checks the GPU vs Array based iterate methods + +''' + +import unittest +import numpy as np +from copy import deepcopy + +from . import utils as tu +from ptypy import defaults_tree +from ptypy.accelerate.array_based import data_utils as du + +from . import have_cuda, only_if_cuda_available +if have_cuda(): + from archive.cuda_extension.accelerate.cuda import constraints as gcon + from ptypy.accelerate.array_based import constraints as con + from archive.cuda_extension.accelerate.cuda.config import init_gpus, reset_function_cache + init_gpus(0) + +@only_if_cuda_available +class EngineIterateUnityTest(unittest.TestCase): + + def tearDown(self): + # reset the cached GPU functions after each test + reset_function_cache() + + @unittest.skip("Is not currently used. I suspect this comes from the race condition in the atomic adds in overlap update") + def test_DM_engine_iterate_mathod(self): + num_probe_modes = 2 # number of modes + num_iters = 10 # number of iterations + frame_size = 64 # frame size + num_points = 50 # number of points in the scan (length of the diffraction array). + fourier_relax_factor = defaults_tree['engine']['DM']['fourier_relax_factor'].default + obj_inertia = defaults_tree['engine']['DM']['object_inertia'].default + probe_inertia = defaults_tree['engine']['DM']['probe_inertia'].default + alpha = 1.0 # this is basically always 1 + + for m in range(num_probe_modes): + number_of_probe_modes = m + 1 + PtychoInstanceVec = tu.get_ptycho_instance('testing_iterate', num_modes=number_of_probe_modes, + frame_size=frame_size, + scan_length=num_points) # this one we run with GPU + vectorised_scan = du.pod_to_arrays(PtychoInstanceVec, 'S0000') + diffraction_storage = PtychoInstanceVec.di.storages['S0000'] + + pbound = (0.25 * fourier_relax_factor ** 2 * diffraction_storage.pbound_stub) + mean_power = diffraction_storage.tot_power / np.prod(diffraction_storage.shape) + + print("pbound:%s" % pbound) + print("mean_power:%s" % mean_power) + + first_view_id = vectorised_scan['meta']['view_IDs'][0] + master_pod = PtychoInstanceVec.diff.V[first_view_id].pod + propagator = master_pod.geometry.propagator + + # this is for the numpy based + diffraction = vectorised_scan['diffraction'] + obj = vectorised_scan['obj'] + probe = vectorised_scan['probe'] + mask = vectorised_scan['mask'] + exit_wave = vectorised_scan['exit wave'] + addr_info = vectorised_scan['meta']['addr'] + # NOTE: these come out as double, but should be single! + object_weights = vectorised_scan['object weights'].astype(np.float32) + probe_weights = vectorised_scan['probe weights'].astype(np.float32) + + prefilter = propagator.pre_fft + postfilter = propagator.post_fft + cfact_object = obj_inertia * mean_power * \ + (vectorised_scan['object viewcover'] + 1.) + cfact_probe = (probe_inertia * len(addr_info) / + vectorised_scan['probe'].shape[0]) * np.ones_like(vectorised_scan['probe']) + + probe_support = np.zeros_like(probe) + X, Y = np.meshgrid(range(probe.shape[1]), range(probe.shape[2])) + R = (0.7 * probe.shape[1]) / 2 + for idx in range(probe.shape[0]): + probe_support[idx, X ** 2 + Y ** 2 < R ** 2] = 1.0 + + print("For number of probe modes: %s\n" + "number of scan points: %s\n" + "and frame size: %s\n" % (number_of_probe_modes, num_points, frame_size)) + + print("The sizes and types of the arrays are:\n" + "diffraction: %s (%s)\n" + "obj: %s (%s)\n" + "probe: %s (%s)\n" + "mask: %s (%s)\n" + "exit wave: %s (%s)\n" + "addr_info: %s (%s)\n" + "object_weights: %s (%s)\n" + "probe_weights: %s (%s)\n" + "prefilter: %s (%s)\n" + "postfilter: %s (%s)\n" + "cfact_object: %s (%s)\n" + "cfact_probe: %s (%s)\n" + "probe_support: %s (%s)\n" % (diffraction.shape, diffraction.dtype, + obj.shape, obj.dtype, + probe.shape, probe.dtype, + mask.shape, mask.dtype, + exit_wave.shape, exit_wave.dtype, + addr_info.shape, addr_info.dtype, + object_weights.shape, object_weights.dtype, + probe_weights.shape, probe_weights.dtype, + prefilter.shape, prefilter.dtype, + postfilter.shape, postfilter.dtype, + cfact_object.shape, cfact_object.dtype, + cfact_probe.shape, cfact_probe.dtype, + probe_support.shape, probe_support.dtype)) + + # take exact copies for the cuda implementation + gdiffraction = deepcopy(diffraction) + gobj = deepcopy(obj) + gprobe = deepcopy(probe) + gmask = deepcopy(mask) + gexit_wave = deepcopy(exit_wave) + gaddr_info = deepcopy(addr_info) + gobject_weights = deepcopy(object_weights) + gprobe_weights = deepcopy(probe_weights) + + gprefilter = deepcopy(prefilter) + gpostfilter = deepcopy(postfilter) + gcfact_object = deepcopy(cfact_object) + gcfact_probe = deepcopy(cfact_probe) + + gpbound = deepcopy(pbound) + galpha = deepcopy(alpha) + gprobe_support = deepcopy(probe_support) + + errors = con.difference_map_iterator(diffraction=diffraction, + obj=obj, + object_weights=object_weights, + cfact_object=cfact_object, + mask=mask, + probe=probe, + cfact_probe=cfact_probe, + probe_support=probe_support, + probe_weights=probe_weights, + exit_wave=exit_wave, + addr=addr_info, + pre_fft=prefilter, + post_fft=postfilter, + pbound=pbound, + overlap_max_iterations=10, + update_object_first=False, + obj_smooth_std=None, + overlap_converge_factor=0.05, + probe_center_tol=None, + probe_update_start=1, + alpha=alpha, + clip_object=None, + LL_error=True, + num_iterations=num_iters) + + gerrors = gcon.difference_map_iterator(diffraction=gdiffraction, + obj=gobj, + object_weights=gobject_weights, + cfact_object=gcfact_object, + mask=gmask, + probe=gprobe, + cfact_probe=gcfact_probe, + probe_support=gprobe_support, + probe_weights=gprobe_weights, + exit_wave=gexit_wave, + addr=gaddr_info, + pre_fft=gprefilter, + post_fft=gpostfilter, + pbound=gpbound, + overlap_max_iterations=10, + update_object_first=False, + obj_smooth_std=None, + overlap_converge_factor=0.05, + probe_center_tol=None, + probe_update_start=1, + alpha=galpha, + clip_object=None, + LL_error=True, + num_iterations=num_iters, + do_realspace_error=True) + + # NOTE: + # Have to put large tolerances here, as after 10 iterations a discrepancy is expected + # it would be much better to have a metric of the quality of the reconstruction, + # like the mean squared error across the whole image, or something similar + # as array_close is bound by the max error, and that will be large + + for idx in range(len(errors)): + #print("errors[{}]: atol={}, rtol={}".format(idx, np.max(np.abs(gerrors[idx]-errors[idx])), np.max(np.abs(gerrors[idx]-errors[idx])/np.abs(errors[idx])) )) + np.testing.assert_allclose(gerrors[idx], errors[idx], rtol=10e-2, atol=10, err_msg="Output errors for index {} don't match".format(idx)) + + for idx in range(len(probe)): + #print("probe[{}]: atol={}, rtol={}".format(idx, np.max(np.abs(gprobe[idx]-probe[idx])), np.max(np.abs(gprobe[idx]-probe[idx])/np.abs(probe[idx])) )) + np.testing.assert_allclose(gprobe[idx], probe[idx], rtol=10e-2, atol=10, err_msg="Output probes for index {} don't match".format(idx)) + + # NOTE: these are completely different, but it still works fine with the visual sample + #for idx in range(len(exit_wave)): + #print("exit_wave[{}]: atol={}, rtol={}".format(idx, np.max(np.abs(gexit_wave[idx]-exit_wave[idx])), np.max(np.abs(gexit_wave[idx]-exit_wave[idx])/np.abs(exit_wave[idx])) )) + #np.testing.assert_allclose(gexit_wave[idx], exit_wave[idx], rtol=10e-2, atol=10, err_msg="Output exit waves for index {} don't match".format(idx)) + + for idx in range(len(obj)): + #print("obj[{}]: atol={}, rtol={}".format(idx, np.max(np.abs(gobj[idx]-obj[idx])), np.max(np.abs(gobj[idx]-obj[idx])/np.abs(obj[idx])) )) + np.testing.assert_allclose(obj, gobj, rtol=20e-2, atol=15, err_msg="The output objects don't match.") + + # clean this up to prevent a leak. + del PtychoInstanceVec + +if __name__=='__main__': + unittest.main() diff --git a/archive/cuda_extension/tests/error_metric_test.py b/archive/cuda_extension/tests/error_metric_test.py new file mode 100644 index 000000000..e359102cb --- /dev/null +++ b/archive/cuda_extension/tests/error_metric_test.py @@ -0,0 +1,112 @@ +''' +A test for the module of the relevant error metrics +''' + +import unittest +import numpy as np +from . import utils as tu +from ptypy.accelerate.array_based import data_utils as du +from ptypy.accelerate.array_based.constraints import difference_map_realspace_constraint, scan_and_multiply +from archive.array_based.propagation import farfield_propagator +import ptypy.accelerate.array_based.array_utils as au +from archive.array_based.error_metrics import log_likelihood, far_field_error, realspace_error +from ptypy.accelerate.array_based import COMPLEX_TYPE, FLOAT_TYPE + +from . import have_cuda, only_if_cuda_available +if have_cuda(): + from archive.cuda_extension.accelerate.cuda.error_metrics import log_likelihood as glog_likelihood + from archive.cuda_extension.accelerate.cuda.error_metrics import far_field_error as gfar_field_error + from archive.cuda_extension.accelerate.cuda.error_metrics import realspace_error as grealspace_error + from archive.cuda_extension.accelerate.cuda.config import init_gpus, reset_function_cache + init_gpus(0) + +@only_if_cuda_available +class ErrorMetricTest(unittest.TestCase): + + def tearDown(self): + # reset the cached GPU functions after each test + reset_function_cache() + + def test_loglikelihood_numpy_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + propagator = PtychoInstance.di.V[first_view_id].pod.geometry.propagator + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + diffraction=vectorised_scan['diffraction'] + mask = vectorised_scan['mask'] + exit_wave = vectorised_scan['exit wave'] + + probe_object = scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + + ll = log_likelihood(probe_object, mask, diffraction, propagator.pre_fft, propagator.post_fft, addr_info) + gll = glog_likelihood(probe_object, mask, diffraction, propagator.pre_fft, propagator.post_fft, addr_info) + np.testing.assert_allclose(ll, gll, rtol=1e-6, atol=5e-4) + + def test_far_field_error_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + propagator = PtychoInstance.di.V[first_view_id].pod.geometry.propagator + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + diffraction=vectorised_scan['diffraction'] + mask = vectorised_scan['mask'] + exit_wave = vectorised_scan['exit wave'] + + probe_object = scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + constrained = difference_map_realspace_constraint(probe_object, exit_wave, alpha=1.0) + f = farfield_propagator(constrained, propagator.pre_fft, propagator.post_fft, direction='forward') + pa, oa, ea, da, ma = zip(*addr_info) + af2 = au.sum_to_buffer(au.abs2(f), diffraction.shape, ea, da, dtype=FLOAT_TYPE) + + fmag = np.sqrt(np.abs(diffraction)) + af = np.sqrt(af2) + + ff_error = far_field_error(af, fmag, mask).astype(np.float32) + + gff_error = gfar_field_error(af, fmag, mask) + np.testing.assert_allclose(ff_error, gff_error, rtol=1e-6) + + def test_realspace_error_regression1_UNITY(self): + I = 5 + M = 20 + N = 30 + out_length = I + ea_first_column = range(I) + da_first_column = range(I) + + difference = np.empty(shape=(I, M, N), dtype=COMPLEX_TYPE) + for idx in range(I): + difference[idx] = np.ones((M, N)) *idx + 1j * np.ones((M, N)) *idx + + error = realspace_error(difference, ea_first_column, da_first_column, out_length) + gerror = grealspace_error(difference, ea_first_column, da_first_column, out_length) + + np.testing.assert_allclose(error, gerror, rtol=1e-6) + + def test_realspace_error_regression2_UNITY(self): + I = 5 + M = 20 + N = 30 + out_length = 5 + ea_first_column = range(I) + da_first_column = list(range(int(I/2))) + list(range(int(I/2))) + + difference = np.empty(shape=(I, M, N), dtype=COMPLEX_TYPE) + for idx in range(I): + difference[idx] = np.ones((M, N)) * idx + 1j * np.ones((M, N)) * idx + + error = realspace_error(difference, ea_first_column, da_first_column, out_length) + gerror = grealspace_error(difference, ea_first_column, da_first_column, out_length) + + np.testing.assert_allclose(error, gerror, rtol=1e-6) + + +if __name__ == '__main__': + unittest.main() + diff --git a/archive/cuda_extension/tests/farfield_propagator_test.py b/archive/cuda_extension/tests/farfield_propagator_test.py new file mode 100644 index 000000000..433a6621a --- /dev/null +++ b/archive/cuda_extension/tests/farfield_propagator_test.py @@ -0,0 +1,229 @@ +''' +Test for the propagation in numpy +''' + +import unittest +import numpy as np +from . import utils as tu +from ptypy.accelerate.array_based import data_utils as du +from ptypy.accelerate.array_based import object_probe_interaction as opi +from archive.array_based import propagation as prop +import time + +from . import have_cuda, only_if_cuda_available +if have_cuda(): + from archive.cuda_extension.accelerate.cuda import propagation as gprop + from archive.cuda_extension.accelerate.cuda.config import init_gpus, reset_function_cache + init_gpus(0) + +doTiming = False + +def calculatePrintErrors(expected, actual): + abserr = np.abs(expected-actual) + max_abserr = np.max(abserr) + mean_abserr = np.mean(abserr) + min_abserr = np.min(abserr) + std_abserr = np.std(abserr) + relerr = abserr / np.abs(expected) + max_relerr = np.nanmax(relerr) + mean_relerr = np.nanmean(relerr) + min_relerr = np.nanmin(relerr) + std_relerr = np.nanstd(relerr) + print("Abs Errors: max={}, min={}, mean={}, stddev={}".format( + max_abserr, min_abserr, mean_abserr, std_abserr)) + print("Rel Errors: max={}, min={}, mean={}, stddev={}".format( + max_relerr, min_relerr, mean_relerr, std_relerr)) + +@only_if_cuda_available +class FarfieldPropagatorTest(unittest.TestCase): + + def tearDown(self): + # reset the cached GPU functions after each test + reset_function_cache() + + #@unittest.skip("This method is not implemented yet") + def test_fourier_transform_farfield_nofilter_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + exit_wave = opi.scan_and_multiply(vectorised_scan['probe'], + vectorised_scan['obj'], + vectorised_scan['exit wave'].shape, + vectorised_scan['meta']['addr']) + + if doTiming: tstart = time.time() + array_propagated = prop.farfield_propagator(exit_wave, prefilter=None, postfilter=None) + if doTiming: + tend = time.time() + pytime = tend-tstart + tstart = time.time() + gpu_propagated = gprop.farfield_propagator(exit_wave, prefilter=None, postfilter=None) + if doTiming: + tend = time.time() + gtime = tend-tstart + + print("Times: CPU={}, GPU={}, speedup={}x".format( + pytime, gtime, pytime/gtime + )) + + + calculatePrintErrors(array_propagated, gpu_propagated) + np.testing.assert_allclose( + gpu_propagated, + array_propagated, rtol=1e-6, atol=3e-4,verbose=True + ) + + + #@unittest.skip("This method is not implemented yet") + def test_fourier_transform_farfield_with_prefilter_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + propagator = PtychoInstance.di.V[first_view_id].pod.geometry.propagator + exit_wave = opi.scan_and_multiply(vectorised_scan['probe'], + vectorised_scan['obj'], + vectorised_scan['exit wave'].shape, + vectorised_scan['meta']['addr']) + + array_propagated = prop.farfield_propagator(exit_wave, prefilter=propagator.pre_fft, postfilter=None) + gpu_propagated = gprop.farfield_propagator(exit_wave, prefilter=propagator.pre_fft, postfilter=None) + + calculatePrintErrors(array_propagated, gpu_propagated) + np.testing.assert_allclose( + gpu_propagated, + array_propagated, rtol=1e-6, atol=4e-4,verbose=True + ) + + #@unittest.skip("This method is not implemented yet") + def test_fourier_transform_farfield_with_postfilter_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + propagator = PtychoInstance.di.V[first_view_id].pod.geometry.propagator + exit_wave = opi.scan_and_multiply(vectorised_scan['probe'], + vectorised_scan['obj'], + vectorised_scan['exit wave'].shape, + vectorised_scan['meta']['addr']) + + array_propagated = prop.farfield_propagator(exit_wave, prefilter=None, postfilter=propagator.post_fft) + gpu_propagated = gprop.farfield_propagator(exit_wave, prefilter=None, postfilter=propagator.post_fft) + + calculatePrintErrors(array_propagated, gpu_propagated) + np.testing.assert_allclose( + gpu_propagated, + array_propagated, rtol=1e-6, atol=3e-4,verbose=True + ) + + #@unittest.skip("This method is not implemented yet") + def test_fourier_transform_farfield_with_pre_and_post_filter_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + propagator = PtychoInstance.di.V[first_view_id].pod.geometry.propagator + exit_wave = opi.scan_and_multiply(vectorised_scan['probe'], + vectorised_scan['obj'], + vectorised_scan['exit wave'].shape, + vectorised_scan['meta']['addr']) + if doTiming: tstart = time.time() + array_propagated = prop.farfield_propagator(exit_wave, prefilter=propagator.pre_fft, postfilter=propagator.post_fft) + if doTiming: + tend = time.time() + pytime = tend-tstart + tstart = time.time() + gpu_propagated = gprop.farfield_propagator(exit_wave, prefilter=propagator.pre_fft, postfilter=propagator.post_fft) + if doTiming: + tend = time.time() + gtime = tend-tstart + + print("Times: CPU={}, GPU={}, speedup={}x".format( + pytime, gtime, pytime/gtime + )) + + + calculatePrintErrors(array_propagated, gpu_propagated) + np.testing.assert_allclose( + gpu_propagated, + array_propagated, rtol=1e-6, atol=5e-4,verbose=True + ) + + #@unittest.skip("This method is not implemented yet") + def test_inverse_fourier_transform_farfield_nofilter_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000',) + exit_wave = opi.scan_and_multiply(vectorised_scan['probe'], + vectorised_scan['obj'], + vectorised_scan['exit wave'].shape, + vectorised_scan['meta']['addr']) + + array_propagated = prop.farfield_propagator(exit_wave, prefilter=None, postfilter=None, direction='backward') + gpu_propagated = gprop.farfield_propagator(exit_wave, prefilter=None, postfilter=None, direction='backward') + + calculatePrintErrors(array_propagated, gpu_propagated) + np.testing.assert_allclose( + gpu_propagated, + array_propagated, rtol=1e-6, atol=5e-4,verbose=True + ) + + #@unittest.skip("This method is not implemented yet") + def test_inverse_fourier_transform_farfield_with_prefilter_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + propagator = PtychoInstance.di.V[first_view_id].pod.geometry.propagator + exit_wave = opi.scan_and_multiply(vectorised_scan['probe'], + vectorised_scan['obj'], + vectorised_scan['exit wave'].shape, + vectorised_scan['meta']['addr']) + + array_propagated = prop.farfield_propagator(exit_wave, prefilter=propagator.pre_fft, postfilter=None, direction='backward') + gpu_propagated = gprop.farfield_propagator(exit_wave, prefilter=propagator.pre_fft, postfilter=None, direction='backward') + + calculatePrintErrors(array_propagated, gpu_propagated) + np.testing.assert_allclose( + gpu_propagated, + array_propagated, rtol=1e-6, atol=5e-4,verbose=True + ) + + #@unittest.skip("This method is not implemented yet") + def test_inverse_fourier_transform_farfield_with_postfilter_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + propagator = PtychoInstance.di.V[first_view_id].pod.geometry.propagator + exit_wave = opi.scan_and_multiply(vectorised_scan['probe'], + vectorised_scan['obj'], + vectorised_scan['exit wave'].shape, + vectorised_scan['meta']['addr']) + + array_propagated = prop.farfield_propagator(exit_wave, prefilter=None, postfilter=propagator.post_fft, direction='backward') + gpu_propagated = gprop.farfield_propagator(exit_wave, prefilter=None, postfilter=propagator.post_fft, direction='backward') + + calculatePrintErrors(array_propagated, gpu_propagated) + np.testing.assert_allclose( + gpu_propagated, + array_propagated, rtol=1e-6, atol=5e-4,verbose=True + ) + + #@unittest.skip("This method is not implemented yet") + def test_inverse_fourier_transform_farfield_with_pre_and_post_filter_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + propagator = PtychoInstance.di.V[first_view_id].pod.geometry.propagator + exit_wave = opi.scan_and_multiply(vectorised_scan['probe'], + vectorised_scan['obj'], + vectorised_scan['exit wave'].shape, + vectorised_scan['meta']['addr']) + + array_propagated = prop.farfield_propagator(exit_wave, prefilter=propagator.pre_fft, postfilter=propagator.post_fft, direction='backward') + gpu_propagated = gprop.farfield_propagator(exit_wave, prefilter=propagator.pre_fft, postfilter=propagator.post_fft, direction='backward') + + calculatePrintErrors(array_propagated, gpu_propagated) + np.testing.assert_allclose( + gpu_propagated, + array_propagated, rtol=1e-6, atol=5e-4,verbose=True + ) + +# + +if __name__ == "__main__": + unittest.main() diff --git a/archive/cuda_extension/tests/minimal_numpy_DM_test.py b/archive/cuda_extension/tests/minimal_numpy_DM_test.py new file mode 100644 index 000000000..b3d08501a --- /dev/null +++ b/archive/cuda_extension/tests/minimal_numpy_DM_test.py @@ -0,0 +1,56 @@ +from ptypy.core import Ptycho +from ptypy import utils as u +import cProfile +p = u.Param() +p.verbose_level = 3 +p.io = u.Param() +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=True) +p.ipython_kernel = False +p.scans = u.Param() +p.scans.MF = u.Param() +p.scans.MF.name = 'Full' +p.scans.MF.propagation = 'farfield' +p.scans.MF.data = u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.positions_theory = None +p.scans.MF.data.auto_center = None +p.scans.MF.data.min_frames = 1 +p.scans.MF.data.orientation = None +p.scans.MF.data.num_frames = 100 +p.scans.MF.data.energy = 6.2 +p.scans.MF.data.shape = 256 +p.scans.MF.data.chunk_format = '.chunk%02d' +p.scans.MF.data.rebin = None +p.scans.MF.data.experimentID = None +p.scans.MF.data.label = None +p.scans.MF.data.version = 0.1 +p.scans.MF.data.dfile = None +p.scans.MF.data.psize = 0.000172 +p.scans.MF.data.load_parallel = None +p.scans.MF.data.distance = 7.0 +p.scans.MF.data.save = None +p.scans.MF.data.center = 'fftshift' +p.scans.MF.data.photons = 100000000.0 +p.scans.MF.data.psf = 0.0 +p.scans.MF.data.density = 0.2 +p.scans.MF.data.add_poisson_noise = False +p.scans.MF.coherence = u.Param() +p.scans.MF.coherence.num_probe_modes = 1 # currently breaks when this is =2 + +p.engines = u.Param() + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DMNpy' +p.engines.engine00.numiter = 50 +# p.engines.engine00.overlap_max_iterations = 1 +# prepare and run + + +P = Ptycho(p, level=4) +P.run() +# cProfile.run('P.run()', +# '/home/clb02321/Desktop/profiling_thing_with_realspace_error.prof', +# 'tottime') \ No newline at end of file diff --git a/archive/cuda_extension/tests/minimal_numpy_DM_test_4096x4096.py b/archive/cuda_extension/tests/minimal_numpy_DM_test_4096x4096.py new file mode 100644 index 000000000..30e83067d --- /dev/null +++ b/archive/cuda_extension/tests/minimal_numpy_DM_test_4096x4096.py @@ -0,0 +1,60 @@ +from ptypy.core import Ptycho +from ptypy import utils as u +import cProfile + +beamlines = {} +beamlines['i08'] = [64, 20000]#45000] +# beamlines['i14'] = [4096, 70000] +# beamlines['i13'] = [4096, 5000] + +for beamline in beamlines.keys(): + print("####### RUNNING %s #########" % beamline) + p = u.Param() + p.verbose_level = 3 + p.io = u.Param() + p.io.autosave = u.Param(active=False) + p.io.autoplot = u.Param(active=True) + p.ipython_kernel = False + p.scans = u.Param() + p.scans.MF = u.Param() + p.scans.MF.name = 'Full' + p.scans.MF.propagation = 'farfield' + p.scans.MF.data = u.Param() + p.scans.MF.data.name = 'MoonFlowerScan' + p.scans.MF.data.positions_theory = None + p.scans.MF.data.auto_center = None + p.scans.MF.data.min_frames = 1 + p.scans.MF.data.orientation = None + p.scans.MF.data.num_frames = beamlines[beamline][1] + p.scans.MF.data.energy = 6.2 + p.scans.MF.data.shape = beamlines[beamline][0] + p.scans.MF.data.chunk_format = '.chunk%02d' + p.scans.MF.data.rebin = None + p.scans.MF.data.experimentID = None + p.scans.MF.data.label = None + p.scans.MF.data.version = 0.1 + p.scans.MF.data.dfile = None + p.scans.MF.data.psize = 0.000172 + p.scans.MF.data.load_parallel = None + p.scans.MF.data.distance = 7.0 + p.scans.MF.data.save = None + p.scans.MF.data.center = 'fftshift' + p.scans.MF.data.photons = 100000000.0 + p.scans.MF.data.psf = 0.0 + p.scans.MF.data.density = 0.2 + p.scans.MF.data.add_poisson_noise = False + p.scans.MF.coherence = u.Param() + p.scans.MF.coherence.num_probe_modes = 2 # currently breaks when this is =2 + p.engines = u.Param() + # attach a reconstrucion engine + p.engines = u.Param() + p.engines.engine00 = u.Param() + p.engines.engine00.name = 'DMGpu' + p.engines.engine00.numiter = 50 + # p.engines.engine00.overlap_max_iterations = 1 + # prepare and run + + + P = Ptycho(p, level=4) + P.run() + # cProfile.run("P.run()", filename="/home/clb02321/profiling_%s_%s_50iterations_DMCpu" % (beamline, '28826'), sort='tottime') diff --git a/archive/cuda_extension/tests/minimal_numpy_DM_test_64x64.py b/archive/cuda_extension/tests/minimal_numpy_DM_test_64x64.py new file mode 100644 index 000000000..b3d08501a --- /dev/null +++ b/archive/cuda_extension/tests/minimal_numpy_DM_test_64x64.py @@ -0,0 +1,56 @@ +from ptypy.core import Ptycho +from ptypy import utils as u +import cProfile +p = u.Param() +p.verbose_level = 3 +p.io = u.Param() +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=True) +p.ipython_kernel = False +p.scans = u.Param() +p.scans.MF = u.Param() +p.scans.MF.name = 'Full' +p.scans.MF.propagation = 'farfield' +p.scans.MF.data = u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.positions_theory = None +p.scans.MF.data.auto_center = None +p.scans.MF.data.min_frames = 1 +p.scans.MF.data.orientation = None +p.scans.MF.data.num_frames = 100 +p.scans.MF.data.energy = 6.2 +p.scans.MF.data.shape = 256 +p.scans.MF.data.chunk_format = '.chunk%02d' +p.scans.MF.data.rebin = None +p.scans.MF.data.experimentID = None +p.scans.MF.data.label = None +p.scans.MF.data.version = 0.1 +p.scans.MF.data.dfile = None +p.scans.MF.data.psize = 0.000172 +p.scans.MF.data.load_parallel = None +p.scans.MF.data.distance = 7.0 +p.scans.MF.data.save = None +p.scans.MF.data.center = 'fftshift' +p.scans.MF.data.photons = 100000000.0 +p.scans.MF.data.psf = 0.0 +p.scans.MF.data.density = 0.2 +p.scans.MF.data.add_poisson_noise = False +p.scans.MF.coherence = u.Param() +p.scans.MF.coherence.num_probe_modes = 1 # currently breaks when this is =2 + +p.engines = u.Param() + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DMNpy' +p.engines.engine00.numiter = 50 +# p.engines.engine00.overlap_max_iterations = 1 +# prepare and run + + +P = Ptycho(p, level=4) +P.run() +# cProfile.run('P.run()', +# '/home/clb02321/Desktop/profiling_thing_with_realspace_error.prof', +# 'tottime') \ No newline at end of file diff --git a/archive/cuda_extension/tests/minimal_numpy_ML_test.py b/archive/cuda_extension/tests/minimal_numpy_ML_test.py new file mode 100644 index 000000000..b3d08501a --- /dev/null +++ b/archive/cuda_extension/tests/minimal_numpy_ML_test.py @@ -0,0 +1,56 @@ +from ptypy.core import Ptycho +from ptypy import utils as u +import cProfile +p = u.Param() +p.verbose_level = 3 +p.io = u.Param() +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=True) +p.ipython_kernel = False +p.scans = u.Param() +p.scans.MF = u.Param() +p.scans.MF.name = 'Full' +p.scans.MF.propagation = 'farfield' +p.scans.MF.data = u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.positions_theory = None +p.scans.MF.data.auto_center = None +p.scans.MF.data.min_frames = 1 +p.scans.MF.data.orientation = None +p.scans.MF.data.num_frames = 100 +p.scans.MF.data.energy = 6.2 +p.scans.MF.data.shape = 256 +p.scans.MF.data.chunk_format = '.chunk%02d' +p.scans.MF.data.rebin = None +p.scans.MF.data.experimentID = None +p.scans.MF.data.label = None +p.scans.MF.data.version = 0.1 +p.scans.MF.data.dfile = None +p.scans.MF.data.psize = 0.000172 +p.scans.MF.data.load_parallel = None +p.scans.MF.data.distance = 7.0 +p.scans.MF.data.save = None +p.scans.MF.data.center = 'fftshift' +p.scans.MF.data.photons = 100000000.0 +p.scans.MF.data.psf = 0.0 +p.scans.MF.data.density = 0.2 +p.scans.MF.data.add_poisson_noise = False +p.scans.MF.coherence = u.Param() +p.scans.MF.coherence.num_probe_modes = 1 # currently breaks when this is =2 + +p.engines = u.Param() + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DMNpy' +p.engines.engine00.numiter = 50 +# p.engines.engine00.overlap_max_iterations = 1 +# prepare and run + + +P = Ptycho(p, level=4) +P.run() +# cProfile.run('P.run()', +# '/home/clb02321/Desktop/profiling_thing_with_realspace_error.prof', +# 'tottime') \ No newline at end of file diff --git a/archive/cuda_extension/tests/object_probe_interaction_test.py b/archive/cuda_extension/tests/object_probe_interaction_test.py new file mode 100644 index 000000000..e7b702aff --- /dev/null +++ b/archive/cuda_extension/tests/object_probe_interaction_test.py @@ -0,0 +1,1272 @@ +''' +tests for the object-probe interactions, including the specific DM, ePIE etc updates + +''' + +import unittest +import numpy as np +from . import utils as tu +from ptypy.accelerate.array_based import data_utils as du +from ptypy.accelerate.array_based import object_probe_interaction as opi +from ptypy.accelerate.array_based import COMPLEX_TYPE, FLOAT_TYPE +from copy import deepcopy + +from . import have_cuda, only_if_cuda_available +if have_cuda(): + from archive.cuda_extension.accelerate.cuda import object_probe_interaction as gopi + from archive.cuda_extension.accelerate.cuda.config import init_gpus, reset_function_cache + init_gpus(0) + +@only_if_cuda_available +class ObjectProbeInteractionTest(unittest.TestCase): + + def tearDown(self): + # reset the cached GPU functions after each test + reset_function_cache() + + def test_scan_and_multiply_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + # now convert to arrays + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + exit_wave = vectorised_scan['exit wave'] + + # add one, to avoid having a lot of zeros and hence disturbing the result + probe = np.add(probe, 1) + obj = np.add(obj,1) + + po = opi.scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + gpo = gopi.scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + + np.testing.assert_array_equal(po, gpo) + #np.testing.assert_allclose(po, gpo) + + def test_difference_map_realspace_constraint_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + # now convert to arrays + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + exit_wave = vectorised_scan['exit wave'] + probe_object = opi.scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + po = opi.difference_map_realspace_constraint(probe_object, exit_wave, alpha=1.0) + gpo = gopi.difference_map_realspace_constraint(probe_object, exit_wave, alpha=1.0) + np.testing.assert_array_equal(po, gpo) + + def test_extract_array_from_exit_wave_UNITY_case_a(self): + # two cases for this a) the array to be updated is bigger than the extracted array (which is the same size as the exit wave) + # b) the other way round + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + extract_addr[:, 1] = np.zeros((A,)) + extract_addr[:, 2] = np.zeros((A,)) + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + update_addr[index::scan_pts ** 2, 1] = X + update_addr[index::scan_pts ** 2, 2] = Y + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + garray_to_be_updated = deepcopy(array_to_be_updated) + gcfact = deepcopy(cfact) + + opi.extract_array_from_exit_wave(exit_wave, exit_addr, array_to_be_extracted, extract_addr, array_to_be_updated, + update_addr, cfact, weights) + + gopi.extract_array_from_exit_wave(exit_wave, exit_addr, array_to_be_extracted, extract_addr, garray_to_be_updated, + update_addr, gcfact, weights) + + + np.testing.assert_array_equal(array_to_be_updated, + garray_to_be_updated, + err_msg="The array has not been extracted properly from the exit wave.") + + def test_extract_array_from_exit_wave_UNITY_case_b(self): + # two cases for this a) the array to be updated is bigger than the extracted array (which is the same size as the exit wave) + # b) the other way round + # + npts_greater_than = 2 + B = 5 + C = 5 + + D = 2 + E = C + npts_greater_than + F = C + npts_greater_than + + G = 2 + H = B + I = C + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + extract_addr[index::scan_pts ** 2, 1] = X + extract_addr[index::scan_pts ** 2, 2] = Y + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + update_addr[:, 1] = np.zeros((A,)) + update_addr[:, 2] = np.zeros((A,)) + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + garray_to_be_updated = deepcopy(array_to_be_updated) + gcfact = deepcopy(cfact) + + opi.extract_array_from_exit_wave(exit_wave, exit_addr, array_to_be_extracted, extract_addr, + array_to_be_updated, + update_addr, cfact, weights) + gopi.extract_array_from_exit_wave(exit_wave, exit_addr, array_to_be_extracted, extract_addr, + garray_to_be_updated, + update_addr, gcfact, weights) + + + np.testing.assert_array_equal(array_to_be_updated, garray_to_be_updated) + + def test_difference_map_update_probe_UNITY_with_support(self): + ''' + This tests difference_map_update_probe, which wraps extract_array_from_exit_wave + ''' + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + extract_addr[:, 1] = np.zeros((A,)) + extract_addr[:, 2] = np.zeros((A,)) + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + update_addr[index::scan_pts ** 2, 1] = X + update_addr[index::scan_pts ** 2, 2] = Y + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + dummy_addr = np.zeros_like(extract_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(update_addr, extract_addr, exit_addr, dummy_addr, dummy_addr)) + probe_support = np.ones_like(array_to_be_updated) * 100.0 + #(ob, probe_weights, probe, exit_wave, addr_info, cfact_probe, probe_support = None) + + garray_to_be_updated = deepcopy(array_to_be_updated) + gcfact = deepcopy(cfact) + err = opi.difference_map_update_probe(array_to_be_extracted, weights, array_to_be_updated, exit_wave, addr_info, cfact, probe_support=probe_support) + + gerr = gopi.difference_map_update_probe(array_to_be_extracted, weights, garray_to_be_updated, exit_wave, addr_info, + gcfact, probe_support=probe_support) + + self.assertAlmostEqual(err, gerr, 6) + np.testing.assert_array_equal(array_to_be_updated, garray_to_be_updated) + + def test_difference_map_update_probe_UNITY_without_support(self): + ''' + This tests difference_map_update_probe, which wraps extract_array_from_exit_wave + ''' + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + extract_addr[:, 1] = np.zeros((A,)) + extract_addr[:, 2] = np.zeros((A,)) + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + update_addr[index::scan_pts ** 2, 1] = X + update_addr[index::scan_pts ** 2, 2] = Y + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + dummy_addr = np.zeros_like(extract_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(update_addr, extract_addr, exit_addr, dummy_addr, dummy_addr)) + #(ob, probe_weights, probe, exit_wave, addr_info, cfact_probe, probe_support = None) + + garray_to_be_updated = deepcopy(array_to_be_updated) + gcfact = deepcopy(cfact) + opi.difference_map_update_probe(array_to_be_extracted, weights, array_to_be_updated, exit_wave, addr_info, cfact, probe_support=None) + gopi.difference_map_update_probe(array_to_be_extracted, weights, garray_to_be_updated, exit_wave, addr_info, + gcfact, probe_support=None) + + np.testing.assert_array_equal(array_to_be_updated, garray_to_be_updated) + + def test_difference_map_update_object_with_no_smooth_or_clip_UNITY(self): + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + extract_addr[:, 1] = np.zeros((A,)) + extract_addr[:, 2] = np.zeros((A,)) + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + update_addr[index::scan_pts ** 2, 1] = X + update_addr[index::scan_pts ** 2, 2] = Y + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + dummy_addr = np.zeros_like(extract_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(extract_addr, update_addr , exit_addr, dummy_addr, dummy_addr)) + + garray_to_be_updated = deepcopy(array_to_be_updated) + gcfact = deepcopy(cfact) + opi.difference_map_update_object(array_to_be_updated, weights, array_to_be_extracted, exit_wave, addr_info, cfact, ob_smooth_std=None, clip_object=None) + gopi.difference_map_update_object(garray_to_be_updated, weights, array_to_be_extracted, exit_wave, addr_info, + gcfact, ob_smooth_std=None, clip_object=None) + + np.testing.assert_array_equal(array_to_be_updated, garray_to_be_updated) + + def test_difference_map_update_object_with_smooth_but_no_clip_UNITY(self): + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + extract_addr[:, 1] = np.zeros((A,)) + extract_addr[:, 2] = np.zeros((A,)) + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + update_addr[index::scan_pts ** 2, 1] = X + update_addr[index::scan_pts ** 2, 2] = Y + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + dummy_addr = np.zeros_like(extract_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(extract_addr, update_addr , exit_addr, dummy_addr, dummy_addr)) + obj_smooth_std = 2.0 # integer + + garray_to_be_updated = deepcopy(array_to_be_updated) + gopi.difference_map_update_object(garray_to_be_updated, weights, array_to_be_extracted, exit_wave, addr_info, + cfact, ob_smooth_std=obj_smooth_std, clip_object=None) + opi.difference_map_update_object(array_to_be_updated, weights, array_to_be_extracted, exit_wave, addr_info, cfact, ob_smooth_std=obj_smooth_std, clip_object=None) + + print("Gpu={}".format(garray_to_be_updated)) + print("Cpu={}".format(array_to_be_updated)) + + np.testing.assert_allclose( + array_to_be_updated, + garray_to_be_updated, + rtol=1e-6 + ) + + def test_difference_map_update_object_with_no_smooth_but_clipping_UNITY(self): + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + extract_addr[:, 1] = np.zeros((A,)) + extract_addr[:, 2] = np.zeros((A,)) + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + update_addr[index::scan_pts ** 2, 1] = X + update_addr[index::scan_pts ** 2, 2] = Y + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + dummy_addr = np.zeros_like(extract_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(extract_addr, update_addr , exit_addr, dummy_addr, dummy_addr)) + clip = (0.8, 1.0) + + garray_to_be_updated = deepcopy(array_to_be_updated) + gcfact = deepcopy(cfact) + opi.difference_map_update_object(array_to_be_updated, weights, array_to_be_extracted, exit_wave, addr_info, cfact, ob_smooth_std=None, clip_object=clip) + gopi.difference_map_update_object(garray_to_be_updated, weights, array_to_be_extracted, exit_wave, addr_info, + gcfact, ob_smooth_std=None, clip_object=clip) + + np.testing.assert_allclose(array_to_be_updated, garray_to_be_updated) + + + def test_center_probe_no_change_UNITY(self): + npts = 64 + probe = np.zeros((1, npts, npts), dtype=COMPLEX_TYPE) + rad = 10.0 + probe_vals = 2 + 3j + x = np.array(range(npts)) - npts // 2 + X, Y = np.meshgrid(x, x) + Xoff = 5.0 + Yoff = 2.0 + probe[0, (X-Xoff)**2 + (Y-Yoff)**2 < rad**2] = probe_vals + center_tolerance = 10.0 + + gprobe = deepcopy(probe) + opi.center_probe(probe, center_tolerance) + gopi.center_probe(gprobe, center_tolerance) + + np.testing.assert_array_equal(probe, gprobe) + + def test_center_probe_with_change_UNITY(self): + npts = 64 + probe = np.zeros((1, npts, npts), dtype=COMPLEX_TYPE) + rad = 10.0 + probe_vals = 2 + 3j + x = np.array(range(npts)) - npts // 2 + X, Y = np.meshgrid(x, x) + Xoff = 5.0 + Yoff = 2.0 + probe[0, (X-Xoff)**2 + (Y-Yoff)**2 < rad**2] = probe_vals + center_tolerance = 1.0 + gprobe = deepcopy(probe) + + gopi.center_probe(gprobe, center_tolerance) + opi.center_probe(probe, center_tolerance) + np.testing.assert_array_almost_equal(probe, gprobe, decimal=8) # interpolation obviously won't make this exact! + + def test_difference_map_overlap_update_test_order_of_updates_a(self): + ''' + This tests the order in which the object and probe are updated + ''' + smooth_std = None # anything else currently not supported + max_iterations = 1 + update_object_first = True + do_update_probe = False + # this should mean that the object gets updated but the probe does not change + ocf = 1 # spam this for this test Not needed. + + # create some inputs - I should really make this a utility... + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + probe_addr = np.empty(shape=(A, 3), dtype=int) + probe_addr[:, 0] = np.array(range(D)).repeat(A / D) + probe_addr[:, 1] = np.zeros((A,)) + probe_addr[:, 2] = np.zeros((A,)) + + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + obj[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + obj_addr = np.empty(shape=(A, 3), dtype=int) + obj_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + obj_addr[index::scan_pts ** 2, 1] = X + obj_addr[index::scan_pts ** 2, 2] = Y + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + for idx in range(G): + cfact_probe[idx] = np.ones((E, F)) * 5 * (idx + 1) + + dummy_addr = np.zeros_like(probe_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(probe_addr, obj_addr , exit_addr, dummy_addr, dummy_addr)) + + gobj = deepcopy(obj) + gprobe = deepcopy(probe) + + opi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=obj, + object_weights=obj_weights, + probe=probe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + gopi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=gobj, + object_weights=obj_weights, + probe=gprobe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + np.testing.assert_allclose(gprobe, + probe, + rtol=1e-6, + err_msg="The cuda and numpy probes are different.") + np.testing.assert_allclose(gobj, + obj, + rtol=1e-6, + err_msg="The cuda and numpy object are different.") + + def test_difference_map_overlap_update_test_order_of_updates_b(self): + ''' + This tests the order in which the object and probe are updated + ''' + + smooth_std = None # anything else currently not supported + max_iterations = 1 + update_object_first = False + do_update_probe = True + # This should mean that the probe is updated, but not the object since max_iterations=1 + ocf = 1 # spam this for this test Not needed. + + # create some inputs - I should really make this a utility... + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + probe_addr = np.empty(shape=(A, 3), dtype=int) + probe_addr[:, 0] = np.array(range(D)).repeat(A / D) + probe_addr[:, 1] = np.zeros((A,)) + probe_addr[:, 2] = np.zeros((A,)) + + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + obj[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + obj_addr = np.empty(shape=(A, 3), dtype=int) + obj_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + obj_addr[index::scan_pts ** 2, 1] = X + obj_addr[index::scan_pts ** 2, 2] = Y + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + for idx in range(G): + cfact_probe[idx] = np.ones((E, F)) * 5 * (idx + 1) + + dummy_addr = np.zeros_like(probe_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(probe_addr, obj_addr , exit_addr, dummy_addr, dummy_addr)) + + gobj = deepcopy(obj) + gprobe = deepcopy(probe) + + opi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=obj, + object_weights=obj_weights, + probe=probe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + gopi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=gobj, + object_weights=obj_weights, + probe=gprobe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + np.testing.assert_allclose(gprobe, + probe, + rtol=1e-6, + err_msg="The cuda and numpy probes are different.") + np.testing.assert_allclose(gobj, + obj, + rtol=1e-6, + err_msg="The cuda and numpy object are different.") + + def test_difference_map_overlap_update_test_order_of_updates_c(self): + ''' + This tests the order in which the object and probe are updated + ''' + + smooth_std = None # anything else currently not supported + max_iterations = 1 + update_object_first = False + do_update_probe = False + # neither the probe or the object are updated + ocf = 1 # spam this for this test Not needed. + + # create some inputs - I should really make this a utility... + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + probe_addr = np.empty(shape=(A, 3), dtype=int) + probe_addr[:, 0] = np.array(range(D)).repeat(A / D) + probe_addr[:, 1] = np.zeros((A,)) + probe_addr[:, 2] = np.zeros((A,)) + + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + obj[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + obj_addr = np.empty(shape=(A, 3), dtype=int) + obj_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + obj_addr[index::scan_pts ** 2, 1] = X + obj_addr[index::scan_pts ** 2, 2] = Y + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + for idx in range(G): + cfact_probe[idx] = np.ones((E, F)) * 5 * (idx + 1) + + dummy_addr = np.zeros_like(probe_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(probe_addr, obj_addr , exit_addr, dummy_addr, dummy_addr)) + + + gobj = deepcopy(obj) + gprobe = deepcopy(probe) + + opi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=obj, + object_weights=obj_weights, + probe=probe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + gopi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=gobj, + object_weights=obj_weights, + probe=gprobe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + np.testing.assert_allclose(gprobe, + probe, + rtol=1e-6, + err_msg="The cuda and numpy probes are different.") + np.testing.assert_allclose(gobj, + obj, + rtol=1e-6, + err_msg="The cuda and numpy object are different.") + + def test_difference_map_overlap_update_test_order_of_updates_d(self): + ''' + This tests the order in which the object and probe are updated + ''' + + smooth_std = None # anything else currently not supported + max_iterations = 1 + update_object_first = True + do_update_probe = True + # both the object and the probe are updated + ocf = 1 # spam this for this test Not needed. + + # create some inputs - I should really make this a utility... + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + probe_addr = np.empty(shape=(A, 3), dtype=int) + probe_addr[:, 0] = np.array(range(D)).repeat(A / D) + probe_addr[:, 1] = np.zeros((A,)) + probe_addr[:, 2] = np.zeros((A,)) + + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + obj[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + obj_addr = np.empty(shape=(A, 3), dtype=int) + obj_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + obj_addr[index::scan_pts ** 2, 1] = X + obj_addr[index::scan_pts ** 2, 2] = Y + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + for idx in range(G): + cfact_probe[idx] = np.ones((E, F)) * 5 * (idx + 1) + + dummy_addr = np.zeros_like( + probe_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(probe_addr, obj_addr, exit_addr, dummy_addr, dummy_addr)) + + gobj = deepcopy(obj) + gprobe = deepcopy(probe) + + opi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=obj, + object_weights=obj_weights, + probe=probe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + gopi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=gobj, + object_weights=obj_weights, + probe=gprobe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + np.testing.assert_allclose(gprobe, + probe, + rtol=1e-6, + err_msg="The cuda and numpy probes are different.") + np.testing.assert_allclose(gobj, + obj, + rtol=1e-6, + err_msg="The cuda and numpy object are different.") + + + + + def test_difference_map_overlap_update_break_when_in_tolerance(self): + ''' + This tests if the loop breaks according to the convergence criterion. + ''' + + ''' + This tests the order in which the object and probe are updated + ''' + + smooth_std = None # anything else currently not supported + max_iterations = 100 + update_object_first = False + do_update_probe = True + # both the object and the probe are updated + ocf = 4.2e-2 # chosen so that this should terminate on teh 6th iteration + + # create some inputs - I should really make this a utility... + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + probe_addr = np.empty(shape=(A, 3), dtype=int) + probe_addr[:, 0] = np.array(range(D)).repeat(A / D) + probe_addr[:, 1] = np.zeros((A,)) + probe_addr[:, 2] = np.zeros((A,)) + + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + obj[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + obj_addr = np.empty(shape=(A, 3), dtype=int) + obj_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + obj_addr[index::scan_pts ** 2, 1] = X + obj_addr[index::scan_pts ** 2, 2] = Y + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + for idx in range(G): + cfact_probe[idx] = np.ones((E, F)) * 5 * (idx + 1) + + dummy_addr = np.zeros_like(probe_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(probe_addr, obj_addr, exit_addr, dummy_addr, dummy_addr)) + + expected_probe = np.array([[[ 9.09412193-0.70329767j, 9.09412193-0.70329767j, 9.09412193-0.70329767j, + 9.09412193-0.70329767j, 9.09412193-0.70329767j], + [ 6.54680109-0.50316954j, 6.54680109-0.50316954j, 6.54680109-0.50316954j, + 6.54680109-0.50316954j, 6.54680109-0.50316954j], + [ 6.14579964-0.47170654j, 6.14579964-0.47170654j, 6.14579964-0.47170654j, + 6.14579964-0.47170654j, 6.14579964-0.47170654j], + [ 5.90408182-0.4541125j , 5.90408182-0.4541125j, 5.90408182-0.4541125j, + 5.90408182-0.4541125j , 5.90408182-0.4541125j ], + [ 4.61261368-0.35782164j, 4.61261368-0.35782164j, 4.61261368-0.35782164j, + 4.61261368-0.35782164j, 4.61261368-0.35782164j]], + + [[ 3.49120140+0.0705148j, 3.49120140+0.0705148j, 3.49120140+0.0705148j, + 3.49120140+0.0705148j, 3.49120140+0.0705148j ], + [ 3.14379764+0.06552192j, 3.14379764+0.06552192j, 3.14379764+0.06552192j, + 3.14379764+0.06552192j, 3.14379764+0.06552192j], + [ 3.08963704+0.06493596j, 3.08963704+0.06493596j, 3.08963704+0.06493596j, + 3.08963704+0.06493596j, 3.08963704+0.06493596j], + [ 3.04668784+0.06343807j, 3.04668784+0.06343807j, 3.04668784+0.06343807j, + 3.04668784+0.06343807j, 3.04668784+0.06343807j], + [ 2.78638887+0.05607619j, 2.78638887+0.05607619j, 2.78638887+0.05607619j, + 2.78638887+0.05607619j, 2.78638887+0.05607619j]]], dtype=COMPLEX_TYPE) + + expected_object=np.array([[[0.27179495+0.31753245j,0.27179495+0.31753245j,0.27179495+0.31753245j, + 0.27179495+0.31753245j,0.27179495+0.31753245j,1.00000000+1.j, + 1.00000000+1.j], + [0.58112150+0.67839354j,0.58112150+0.67839354j,0.58112150+0.67839354j, + 0.58112150+0.67839354j,0.58112150+0.67839354j,1.00000000+1.j, + 1.00000000+1.j], + [0.66542435+0.77613211j,0.66542435+0.77613211j,0.66542435+0.77613211j, + 0.66542435+0.77613211j,0.66542435+0.77613211j,1.00000000+1.j, + 1.00000000+1.j], + [0.68367511+0.7973848j,0.68367511+0.7973848j,0.68367511+0.7973848j, + 0.68367511+0.7973848j,0.68367511+0.7973848j,1.00000000+1.j, + 1.00000000+1.j], + [0.77851987+0.90848058j,0.77851987+0.90848058j,0.77851987+0.90848058j, + 0.77851987+0.90848058j,0.77851987+0.90848058j,1.00000000+1.j, + 1.00000000+1.j], + [1.20245206+1.40492487j,1.20245206+1.40492487j,1.20245206+1.40492487j, + 1.20245206+1.40492487j,1.20245206+1.40492487j,1.00000000+1.j, + 1.00000000+1.j], + [1.00000000+1.j,1.00000000+1.j,1.00000000+1.j, + 1.00000000+1.j,1.00000000+1.j,1.00000000+1.j, + 1.00000000+1.j]], + + [[4.00000000+4.j,3.17660427+3.05242205j,3.17660427+3.05242205j, + 3.17660427+3.05242205j,3.17660427+3.05242205j,3.17660427+3.05242205j, + 4.00000000+4.j], + [4.00000000+4.j,3.94026518+3.78214717j,3.94026518+3.78214717j, + 3.94026518+3.78214717j,3.94026518+3.78214717j,3.94026518+3.78214717j, + 4.00000000+4.j,], + [4.00000000+4.j,4.11254692+3.94367075j,4.11254692+3.94367075j, + 4.11254692+3.94367075j,4.11254692+3.94367075j,4.11254692+3.94367075j, + 4.00000000+4.j], + [4.00000000+4.j,4.14782619+3.9773953j,4.14782619+3.9773953j, + 4.14782619+3.9773953j,4.14782619+3.9773953j,4.14782619+3.9773953j, + 4.00000000+4.j,], + [4.00000000+4.j,4.31528330+4.14124584j,4.31528330+4.14124584j, + 4.31528330+4.14124584j,4.31528330+4.14124584j,4.31528330+4.14124584j, + 4.00000000+4.j], + [4.00000000+4.j,5.13210011+4.93122625j,5.13210011+4.93122625j, + 5.13210011+4.93122625j, 5.13210011+4.93122625j,5.13210011+4.93122625j, + 4.00000000+4.j,], + [4.00000000+4.j,4.00000000+4.j,4.00000000+4.j, + 4.00000000+4.j,4.00000000+4.j,4.00000000+4.j, + 4.00000000+4.j]]],dtype=COMPLEX_TYPE) + + gobj = deepcopy(obj) + gprobe = deepcopy(probe) + + opi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=obj, + object_weights=obj_weights, + probe=probe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + gopi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=gobj, + object_weights=obj_weights, + probe=gprobe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + np.testing.assert_allclose(gprobe, + probe, + rtol=5e-5, + err_msg="The cuda and numpy probes are different.") + np.testing.assert_allclose(gobj, + obj, + rtol=5e-5, + err_msg="The cuda and numpy object are different.") + + +if __name__ == "__main__": + unittest.main() diff --git a/archive/cuda_extension/tests/utils.py b/archive/cuda_extension/tests/utils.py new file mode 100644 index 000000000..b0ef73607 --- /dev/null +++ b/archive/cuda_extension/tests/utils.py @@ -0,0 +1,69 @@ +''' +Created on 4 Jan 2018 + +@author: clb02321 +''' +import unittest +from ptypy.core import Ptycho +from ptypy import utils as u + +def print_array_info(a, name): + print("{}: {}, {}".format(name, a.shape, a.dtype)) + +def get_ptycho_instance(label=None, num_modes=1, frame_size=64, scan_length=8): + ''' + new ptypy probably has a better way of doing this. + ''' + p = u.Param() + p.verbose_level = 0 + p.data_type = "single" + p.run = label + p.io = u.Param() + p.io.home = "/tmp/ptypy/" + p.io.interaction = u.Param(active=False) + p.io.autoplot = u.Param(active=False) + p.scans = u.Param() + p.scans.MF = u.Param() + p.scans.MF.name = 'Full' + p.scans.MF.propagation = 'farfield' + p.scans.MF.data = u.Param() + p.scans.MF.data.name = 'MoonFlowerScan' + p.scans.MF.data.positions_theory = None + p.scans.MF.data.auto_center = None + p.scans.MF.data.min_frames = 1 + p.scans.MF.data.orientation = None + p.scans.MF.data.num_frames =scan_length + p.scans.MF.data.energy = 6.2 + p.scans.MF.data.shape = frame_size + p.scans.MF.data.chunk_format = '.chunk%02d' + p.scans.MF.data.rebin = None + p.scans.MF.data.experimentID = None + p.scans.MF.data.label = None + p.scans.MF.data.version = 0.1 + p.scans.MF.data.dfile = None + p.scans.MF.data.psize = 0.000172 + p.scans.MF.data.load_parallel = None + p.scans.MF.data.distance = 7.0 + p.scans.MF.data.save = None + p.scans.MF.data.center = 'fftshift' + p.scans.MF.data.photons = 100000000.0 + p.scans.MF.data.psf = 0.0 + p.scans.MF.data.add_poisson_noise = False + p.scans.MF.data.density = 0.2 + p.scans.MF.illumination = u.Param() + p.scans.MF.illumination.model = None + p.scans.MF.illumination.aperture = u.Param() + p.scans.MF.illumination.aperture.diffuser = None + p.scans.MF.illumination.aperture.form = "circ" + p.scans.MF.illumination.aperture.size = 3e-6 + p.scans.MF.illumination.aperture.edge = 10 + p.scans.MF.coherence = u.Param() + p.scans.MF.coherence.num_probe_modes = num_modes + P = Ptycho(p, level=4) + P.di = P.diff + P.ma = P.mask + P.ex = P.exit + P.pr = P.probe + P.ob = P.obj + return P + diff --git a/ptypy/engines/DM.py b/archive/engines/DM.py similarity index 98% rename from ptypy/engines/DM.py rename to archive/engines/DM.py index 0fa4721b8..50936bd42 100644 --- a/ptypy/engines/DM.py +++ b/archive/engines/DM.py @@ -15,12 +15,11 @@ from .utils import basic_fourier_update from . import register from .base import PositionCorrectionEngine -from .. import defaults_tree from ..core.manager import Full, Vanilla, Bragg3dModel, BlockVanilla, BlockFull __all__ = ['DM'] -@register() +#@register() class DM(PositionCorrectionEngine): """ A full-fledged Difference Map engine. @@ -194,7 +193,8 @@ def engine_prepare(self): if self.p.fourier_power_bound is None: pb = .25 * self.p.fourier_relax_factor**2 * s.pbound_stub else: - pb = self.p.fourier_power_bound + pb = self.p.fourier_power_bound + log(4, "power bound for scan %s = %f" %(s.label, pb)) if not self.pbound_scan.get(s.label): self.pbound_scan[s.label] = pb else: @@ -240,8 +240,7 @@ def engine_iterate(self, num=1): logger.info('Time spent in Fourier update: %.2f' % tf) logger.info('Time spent in Overlap update: %.2f' % to) logger.info('Time spent in Position update: %.2f' % tp) - error = parallel.gather_dict(error_dct) - return error + return error_dct def engine_finalize(self): """ @@ -364,8 +363,7 @@ def object_update(self): # array and therefore underestimate the strength of the probe terms. cfact = self.p.object_inertia * self.mean_power if self.p.obj_smooth_std is not None: - logger.info( - 'Smoothing object, average cfact is %.2f' + log(4, 'Smoothing object, average cfact is %.2f' % np.mean(cfact).real) smooth_mfs = [0, self.p.obj_smooth_std, diff --git a/ptypy/engines/DM_simple.py b/archive/engines/DM_simple.py similarity index 98% rename from ptypy/engines/DM_simple.py rename to archive/engines/DM_simple.py index c99bb3ff2..aaac28139 100644 --- a/ptypy/engines/DM_simple.py +++ b/archive/engines/DM_simple.py @@ -15,7 +15,6 @@ from . import BaseEngine, register from ..utils.verbose import logger from ..utils import parallel -from .. import defaults_tree from ..core.manager import Full, Vanilla __all__ = ['DM_simple'] @@ -137,8 +136,7 @@ def engine_iterate(self, num): logger.info('Time spent in Fourier update: %.2f' % tf) logger.info('Time spent in Overlap update: %.2f' % to) - error = parallel.gather_dict(error_dct) - return error + return error_dct def engine_finalize(self): """ diff --git a/ptypy/engines/dummy.py b/archive/engines/dummy.py similarity index 98% rename from ptypy/engines/dummy.py rename to archive/engines/dummy.py index 08b8ff3f2..4a5cf943e 100644 --- a/ptypy/engines/dummy.py +++ b/archive/engines/dummy.py @@ -13,7 +13,6 @@ from ..utils import parallel from . import BaseEngine, register -from .. import defaults_tree from ..core.manager import Full, Vanilla __all__ = ['Dummy'] diff --git a/archive/engines/projectional_pycuda_streams.py b/archive/engines/projectional_pycuda_streams.py new file mode 100644 index 000000000..b766c0689 --- /dev/null +++ b/archive/engines/projectional_pycuda_streams.py @@ -0,0 +1,866 @@ +# -*- coding: utf-8 -*- +""" +Difference Map reconstruction engine. + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" + +import numpy as np +import time +from pycuda import gpuarray +import pycuda.driver as cuda + +from ptypy import utils as u +from ptypy.utils.verbose import logger, log +from ptypy.utils import parallel +from ptypy.engines import register +from ptypy.engines.projectional import DMMixin, RAARMixin +from . import projectional_pycuda + +# factor how many more exit waves we wanna keep on GPU compared to +# ma / mag data +EX_MA_BLOCKS_RATIO = 2 +MAX_STREAMS = 500 # max number of streams to use +MAX_BLOCKS = 99999 # can be used to limit the number of blocks, simulating that they don't fit + +__all__ = ['DM_pycuda_streams'] + +class GpuData: + """ + Manages one block of GPU data with corresponding CPU data. + Keeps track of which cpu array is currently on GPU by its id, + and transfers if it's not already there. + + To be used for the exit wave, ma, and mag arrays. + Note: Allocator should be pooled for best performance + """ + + def __init__(self, nbytes, syncback=False): + """ + New instance of GpuData. Allocates the GPU-side array. + + :param nbytes: Number of bytes held by this instance. + :param syncback: Should the data be synced back to CPU any time it's swapped out + """ + + self.gpu = None + self.gpuraw = cuda.mem_alloc(nbytes) + self.nbytes = nbytes + self.nbytes_buffer = nbytes + self.gpuId = None + self.cpu = None + self.syncback = syncback + self.ev_done = None + + def _allocator(self, nbytes): + if nbytes > self.nbytes: + raise Exception('requested more bytes than maximum given before: {} vs {}'.format(nbytes, self.nbytes)) + return self.gpuraw + + def record_done(self, stream): + self.ev_done = cuda.Event() + self.ev_done.record(stream) + + def to_gpu(self, cpu, id, stream): + """ + Transfer cpu array to GPU on stream (async), keeping track of its id + """ + if self.gpuId != id: + if self.syncback: + self.from_gpu(stream) + self.gpuId = id + self.cpu = cpu + if self.ev_done is not None: + self.ev_done.synchronize() + self.gpu = gpuarray.to_gpu_async(cpu, allocator=self._allocator, stream=stream) + return self.gpu + + def from_gpu(self, stream): + """ + Transfer data back to CPU, into same data handle it was copied from + before. + """ + if self.cpu is not None and self.gpuId is not None and self.gpu is not None: + if self.ev_done is not None: + stream.wait_for_event(self.ev_done) + self.gpu.get_async(stream, self.cpu) + self.ev_done = cuda.Event() + self.ev_done.record(stream) + + def resize(self, nbytes): + """ + Resize the size of the underlying buffer, to allow re-use in different contexts. + Note that memory will only be freed/reallocated if the new number of bytes are + either larger than before, or if they are less than 90% of the original size - + otherwise it reuses the existing buffer + """ + if nbytes > self.nbytes_buffer or nbytes < self.nbytes_buffer * .9: + self.nbytes_buffer = nbytes + self.gpuraw.free() + self.gpuraw = cuda.mem_alloc(nbytes) + self.nbytes = nbytes + self.reset() + + def reset(self): + """ + Resets handles of cpu references and ids, so that all data will be transfered + again even if IDs match. + """ + self.gpuId = None + self.cpu = None + self.ev_done = None + + def free(self): + """ + Free the underlying buffer on GPU - this object should not be used afterwards + """ + self.gpuraw.free() + self.gpuraw = None + +class GpuDataManager: + """ + Manages a set of GpuData instances, to keep several blocks on device. + + Note that the syncback property is used so that during fourier updates, + the exit wave array is synced bck to cpu (it is updated), + while during probe update, it's not. + """ + + def __init__(self, nbytes, num, syncback=False): + """ + Create an instance of GpuDataManager. + Parameters are the same as for GpuData, and num is the number of + GpuData instances to create (blocks on device). + """ + self.data = [GpuData(nbytes, syncback) for _ in range(num)] + + @property + def syncback(self): + """ + Get if syncback of data to CPU on swapout is enabled. + """ + return self.data[0].syncback + + @syncback.setter + def syncback(self, whether): + """ + Adjust the syncback setting + """ + for d in self.data: + d.syncback = whether + + @property + def nbytes(self): + """ + Get the number of bytes in each block + """ + return self.data[0].nbytes + + @property + def memory(self): + """ + Get all memory occupied by all blocks + """ + m = 0 + for d in self.data: + m += d.nbytes_buffer + return m + + def __len__(self): + return len(self.data) + + def reset(self, nbytes, num): + """ + Reset this object as if these parameters were given to the constructor. + The syncback property is untouched. + """ + sync = self.syncback + # remove if too many, explictly freeing memory + for i in range(num, len(self.data)): + self.data[i].free() + # cut short if too many + self.data = self.data[:num] + # reset existing + for d in self.data: + d.resize(nbytes) + # append new ones + for i in range(len(self.data), num): + self.data.append(GpuData(nbytes, sync)) + + def free(self): + """ + Explicitly clear all data blocks - same as resetting to 0 blocks + """ + self.reset(0, 0) + + + def to_gpu(self, cpu, id, stream): + """ + Transfer a block to the GPU, given its ID and CPU data array + """ + idx = 0 + for x in self.data: + if x.gpuId == id: + break + idx += 1 + if idx == len(self.data): + idx = 0 + else: + pass + m = self.data.pop(idx) + self.data.append(m) + return m.to_gpu(cpu, id, stream) + + def record_done(self, id, stream): + for x in self.data: + if x.gpuId == id: + x.record_done(stream) + return + raise Exception('recording done for id not in pool') + + + def sync_to_cpu(self, stream): + """ + Sync back all data to CPU + """ + for x in self.data: + x.from_gpu(stream) + + +class GpuStreamData: + def __init__(self, ex_data, ma_data, mag_data): + self.queue = cuda.Stream() + self.ex_data = ex_data + self.ma_data = ma_data + self.mag_data = mag_data + self.ev_compute = None + + def end_compute(self): + """ + called at end of kernels using shared data (aux or probe), + to mark when computing is done and it can be re-used + """ + self.ev_compute = cuda.Event() + self.ev_compute.record(self.queue) + return self.ev_compute + + def start_compute(self, prev_event): + """ + called at start of kernels using shared data (aux or probe), + to wait for previous use of this data is finished + """ + + if prev_event is not None: + self.queue.wait_for_event(prev_event) + + def ex_to_gpu(self, dID, ex): + """ + copy exit wave to GPU, but check first if it's already there + If not, but a previous block is on GPU, sync it back to the host + before overwriting it + """ + + return self.ex_data.to_gpu(ex, dID, self.queue) + + def ma_to_gpu(self, dID, ma, mag): + """ + Copy MA array to GPU + """ + # wait for previous work on memory to complete + ma_gpu = self.ma_data.to_gpu(ma, dID, self.queue) + mag_gpu = self.mag_data.to_gpu(mag, dID, self.queue) + return ma_gpu, mag_gpu + + def record_done_ex(self, dID): + """ + Record when we're done with this stream, so that it can be re-used + """ + self.ex_data.record_done(dID, self.queue) + + def record_done_ma(self, dID): + self.ma_data.record_done(dID, self.queue) + self.mag_data.record_done(dID, self.queue) + + def synchronize(self): + """ + Wait for stream to finish its work + """ + self.queue.synchronize() + + +class _ProjectionEngine_pycuda_streams(projectional_pycuda._ProjectionEngine_pycuda): + + """ + Defaults: + + [fft_lib] + default = cuda + type = str + help = Choose the pycuda-compatible FFT module. + doc = One of: + - ``'reikna'`` : the reikna packaga (fast load, competitive compute for streaming) + - ``'cuda'`` : ptypy's cuda wrapper (delayed load, but fastest compute if all data is on GPU) + - ``'skcuda'`` : scikit-cuda (fast load, slowest compute due to additional store/load stages) + choices = 'reikna','cuda','skcuda' + userlevel = 2 + + """ + + def __init__(self, ptycho_parent, pars = None): + + super().__init__(ptycho_parent, pars) + self.streams = None + self.ma_data = None + self.mag_data = None + self.ex_data = None + self.cur_stream = 0 + self.stream_direction = 1 + + def engine_prepare(self): + + super(projectional_pycuda._ProjectionEngine_pycuda, self).engine_prepare() + + for name, s in self.ob.S.items(): + s.gpu = gpuarray.to_gpu(s.data) + # we use default mem_flags for ob/obn/pr/prn page-locking, as we are + # operating on them on CPU as well after each iteration. + # Write-Combined memory (flags=4) is for write-only on CPU side, + # reads are really slow. + for name, s in self.ob_buf.S.items(): + # obb + d = s.data + s.data = cuda.pagelocked_empty(d.shape, d.dtype, order="C", mem_flags=0) + s.data[:] = d + s.gpu = gpuarray.to_gpu(s.data) + for name, s in self.ob_nrm.S.items(): + # obn + d = s.data + s.data = cuda.pagelocked_empty(d.shape, d.dtype, order="c", mem_flags=0) + s.data[:] = d + s.gpu = gpuarray.to_gpu(s.data) + for name, s in self.pr.S.items(): + # pr + d = s.data + s.data = cuda.pagelocked_empty(d.shape, d.dtype, order="C", mem_flags=0) + s.data[:] = d + s.gpu = gpuarray.to_gpu(s.data) + for name, s in self.pr_buf.S.items(): + # pr + d = s.data + s.data = cuda.pagelocked_empty(d.shape, d.dtype, order="C", mem_flags=0) + s.data[:] = d + s.gpu = gpuarray.to_gpu(s.data) + for name, s in self.pr_nrm.S.items(): + # prn + d = s.data + s.data = cuda.pagelocked_empty(d.shape, d.dtype, order="C", mem_flags=0) + s.data[:] = d + s.gpu = gpuarray.to_gpu(s.data) + + use_tiles = (not self.p.probe_update_cuda_atomics) or (not self.p.object_update_cuda_atomics) + + # Extra object buffer for smoothing kernel + if self.p.obj_smooth_std is not None: + for name, s in self.ob_buf.S.items(): + s.tmp = gpuarray.empty(s.gpu.shape, s.gpu.dtype) + + ex_mem = ma_mem = mag_mem = 0 + idlist = list(self.di.S.keys()) + blocks = len(idlist) + for dID in idlist: + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + + prep.addr_gpu = gpuarray.to_gpu(prep.addr) + if use_tiles: + prep.addr2 = np.ascontiguousarray(np.transpose(prep.addr, (2, 3, 0, 1))) + prep.addr2_gpu = gpuarray.to_gpu(prep.addr2) + if self.do_position_refinement: + prep.mangled_addr_gpu = prep.addr_gpu.copy() + + prep.ma_sum_gpu = gpuarray.to_gpu(prep.ma_sum) + # prepare page-locked mems: + prep.err_fourier_gpu = gpuarray.to_gpu(prep.err_fourier) + prep.err_phot_gpu = gpuarray.to_gpu(prep.err_phot) + prep.err_exit_gpu = gpuarray.to_gpu(prep.err_exit) + if self.do_position_refinement: + prep.error_state_gpu = gpuarray.empty_like(prep.err_fourier_gpu) + ma = self.ma.S[dID].data.astype(np.float32) + prep.ma = cuda.pagelocked_empty(ma.shape, ma.dtype, order="C", mem_flags=4) + prep.ma[:] = ma + ex = self.ex.S[eID].data + prep.ex = cuda.pagelocked_empty(ex.shape, ex.dtype, order="C", mem_flags=4) + prep.ex[:] = ex + mag = prep.mag + prep.mag = cuda.pagelocked_empty(mag.shape, mag.dtype, order="C", mem_flags=4) + prep.mag[:] = mag + ex_mem = max(ex_mem, prep.ex.nbytes) + ma_mem = max(ma_mem, prep.ma.nbytes) + mag_mem = max(mag_mem, prep.mag.nbytes) + + # now check remaining memory and allocate as many blocks as would fit + mem = cuda.mem_get_info()[0] + if self.ex_data is not None: + mem += self.ex_data.memory # as we realloc these, consider as free memory + if self.ma_data is not None: + mem += self.ma_data.memory + if self.mag_data is not None: + mem += self.mag_data.memory + + blk = ex_mem * EX_MA_BLOCKS_RATIO + ma_mem + mag_mem + fit = int(mem - 200*1024*1024) // blk # leave 200MB room for safety + fit = min(MAX_BLOCKS, fit) + nex = min(fit * EX_MA_BLOCKS_RATIO, blocks) + nma = min(fit, blocks) + nstreams = min(MAX_STREAMS, blocks) + + log(4, 'PyCUDA blocks fitting on GPU: exit arrays={}, ma_arrays={}, streams={}, totalblocks={}'.format(nex, nma, nstreams, blocks)) + # reset memory or create new + if self.ex_data is not None: + self.ex_data.reset(ex_mem, nex) + else: + self.ex_data = GpuDataManager(ex_mem, nex, True) + if self.ma_data is not None: + self.ma_data.reset(ma_mem, nma) + else: + self.ma_data = GpuDataManager(ma_mem, nma, False) + if self.mag_data is not None: + self.mag_data.reset(mag_mem, nma) + else: + self.mag_data = GpuDataManager(mag_mem, nma, False) + self.streams = [GpuStreamData(self.ex_data, self.ma_data, self.mag_data) for _ in range(nstreams)] + + def engine_iterate(self, num=1): + """ + Compute one iteration. + """ + self.dID_list = list(self.di.S.keys()) + + prev_event = None + + # atomics or tiled version for probe / object update kernels + atomics_probe = self.p.probe_update_cuda_atomics + atomics_object = self.p.object_update_cuda_atomics + use_tiles = (not atomics_object) or (not atomics_probe) + + for it in range(num): + + error = {} + + for inner in range(self.p.overlap_max_iterations): + + change = 0 + + do_update_probe = (self.curiter >= self.p.probe_update_start) + do_update_object = (self.p.update_object_first or (inner > 0) or not do_update_probe) + do_update_fourier = (inner == 0) + + # initialize probe and object buffer to receive an update + # we do this on the first stream we work on + streamdata = self.streams[self.cur_stream] + streamdata.start_compute(prev_event) + if do_update_object: + for oID, ob in self.ob.storages.items(): + cfact = self.ob_cfact[oID] + obn = self.ob_nrm.S[oID] + obb = self.ob_buf.S[oID] + + if self.p.obj_smooth_std is not None: + log(4,'Smoothing object, cfact is %.2f' % cfact) + smooth_mfs = [self.p.obj_smooth_std, self.p.obj_smooth_std] + # We need a third copy, because we still need ob.gpu for the fourier update + # obb.gpu[:] = ob.gpu[:] + cuda.memcpy_dtod_async(dest=obb.gpu.ptr, + src=ob.gpu.ptr, + size=ob.gpu.nbytes, + stream=streamdata.queue) + streamdata.queue.synchronize() + self.GSK.queue = streamdata.queue + self.GSK.convolution(obb.gpu, smooth_mfs, tmp=obb.tmp) + obb.gpu._axpbz(np.complex64(cfact), 0, obb.gpu, stream=streamdata.queue) + else: + ob.gpu._axpbz(np.complex64(cfact), 0, obb.gpu, stream=streamdata.queue) + obn.gpu.fill(np.float32(cfact), stream=streamdata.queue) + + self.ex_data.syncback = True + + # First cycle: Fourier + object update + for dID in self.dID_list: + t1 = time.time() + prep = self.diff_info[dID] + streamdata = self.streams[self.cur_stream] + + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # references for kernels + kern = self.kernels[prep.label] + FUK = kern.FUK + AWK = kern.AWK + POK = kern.POK + + pbound = self.pbound_scan[prep.label] + aux = kern.aux + PROP = kern.PROP + + # set streams + queue = streamdata.queue + FUK.queue = queue + AWK.queue = queue + POK.queue = queue + PROP.queue = queue + + # get addresses and auxilliary array + addr = prep.addr_gpu + addr2 = prep.addr2_gpu if use_tiles else None + err_fourier = prep.err_fourier_gpu + err_phot = prep.err_phot_gpu + err_exit = prep.err_exit_gpu + ma_sum = prep.ma_sum_gpu + + # local references + ob = self.ob.S[oID].gpu + obn = self.ob_nrm.S[oID].gpu + obb = self.ob_buf.S[oID].gpu + pr = self.pr.S[pID].gpu + + # transfer exit wave to gpu + ex = streamdata.ex_to_gpu(dID, prep.ex) + + # transfer ma/mag data to gpu if needed + if do_update_fourier: + # transfer other input data in + ma, mag = streamdata.ma_to_gpu(dID, prep.ma, prep.mag) + # waits for compute on previous stream to finish before continuing + streamdata.start_compute(prev_event) + + # Fourier update + if do_update_fourier: + log(4, '------ Fourier update -----', True) + + ## compute log-likelihood + if self.p.compute_log_likelihood: + t1 = time.time() + AWK.build_aux_no_ex(aux, addr, ob, pr) + PROP.fw(aux, aux) + FUK.log_likelihood(aux, addr, mag, ma, err_phot) + self.benchmark.F_LLerror += time.time() - t1 + + ## prep + forward FFT + t1 = time.time() + #AWK.build_aux(aux, addr, ob, pr, ex, alpha=self.p.alpha) + AWK.make_aux(aux, addr, ob, pr, ex, c_po=self._c, c_e=1-self._c) + self.benchmark.A_Build_aux += time.time() - t1 + + t1 = time.time() + PROP.fw(aux, aux) + self.benchmark.B_Prop += time.time() - t1 + + ## Deviation from measured data + t1 = time.time() + FUK.fourier_error(aux, addr, mag, ma, ma_sum) + FUK.error_reduce(addr, err_fourier) + FUK.fmag_all_update(aux, addr, mag, ma, err_fourier, pbound) + self.benchmark.C_Fourier_update += time.time() - t1 + streamdata.record_done_ma(dID) + + ## Backward FFT + t1 = time.time() + PROP.bw(aux, aux) + ## apply changes + #AWK.build_exit(aux, addr, ob, pr, ex, alpha=self.p.alpha) + AWK.make_exit(aux, addr, ob, pr, ex, c_a=self._b, c_po=self._a, c_e=-(self._a + self._b)) + FUK.exit_error(aux, addr) + FUK.error_reduce(addr, err_exit) + self.benchmark.E_Build_exit += time.time() - t1 + + self.benchmark.calls_fourier += 1 + + prestr = '%d Iteration (Overlap) #%02d: ' % (parallel.rank, inner) + + # Object update + if do_update_object: + log(4, prestr + '----- object update -----', True) + t1 = time.time() + + addrt = addr if atomics_object else addr2 + POK.ob_update(addrt, obb, obn, pr, ex, atomics=atomics_object) + self.benchmark.object_update += time.time() - t1 + self.benchmark.calls_object += 1 + + # end_compute is to allow aux + ob re-use, so we can mark it here + prev_event = streamdata.end_compute() + streamdata.record_done_ex(dID) + self.cur_stream = (self.cur_stream + self.stream_direction) % len(self.streams) + + # swap direction for next time + if do_update_fourier: + self.dID_list.reverse() + self.stream_direction = -self.stream_direction + # make sure we start with the same stream were we stopped + self.cur_stream = (self.cur_stream + self.stream_direction) % len(self.streams) + + if do_update_object: + self._object_allreduce() + + # Exit if probe should fnot yet be updated + if not do_update_probe: + break + + # Update probe + log(4, prestr + '----- probe update -----', True) + self.ex_data.syncback = False + change = self.probe_update() + + # swap direction for next time + self.dID_list.reverse() + self.stream_direction = -self.stream_direction + # make sure we start with the same stream were we stopped + self.cur_stream = (self.cur_stream + self.stream_direction) % len(self.streams) + + log(4, prestr + 'change in probe is %.3f' % change, True) + + # stop iteration if probe change is small + if change < self.p.overlap_converge_factor: break + + parallel.barrier() + + if self.do_position_refinement and (self.curiter): + do_update_pos = (self.p.position_refinement.stop > self.curiter >= self.p.position_refinement.start) + do_update_pos &= (self.curiter % self.p.position_refinement.interval) == 0 + + # Update positions + if do_update_pos: + """ + Iterates through all positions and refines them by a given algorithm. + """ + log(4, "----------- START POS REF -------------") + prev_event = None + for dID in self.di.S.keys(): + streamdata = self.streams[self.cur_stream] + + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + ob = self.ob.S[oID].gpu + pr = self.pr.S[pID].gpu + kern = self.kernels[prep.label] + aux = kern.aux + addr = prep.addr_gpu + original_addr = prep.original_addr + mangled_addr = prep.mangled_addr_gpu + ma_sum = prep.ma_sum_gpu + ma, mag = streamdata.ma_to_gpu(dID, prep.ma, prep.mag) + err_fourier = prep.err_fourier_gpu + error_state = prep.error_state_gpu + + PCK = kern.PCK + TK = kern.TK + PROP = kern.PROP + PCK.queue = streamdata.queue + TK.queue = streamdata.queue + PROP.queue = streamdata.queue + + # Keep track of object boundaries + max_oby = ob.shape[-2] - aux.shape[-2] - 1 + max_obx = ob.shape[-1] - aux.shape[-1] - 1 + + # We need to re-calculate the current error + PCK.build_aux(aux, addr, ob, pr) + PROP.fw(aux, aux) + if self.p.position_refinement.metric == "fourier": + PCK.fourier_error(aux, addr, mag, ma, ma_sum) + PCK.error_reduce(addr, err_fourier) + if self.p.position_refinement.metric == "photon": + PCK.log_likelihood(aux, addr, mag, ma, err_fourier) + cuda.memcpy_dtod_async(dest=error_state.ptr, + src=err_fourier.ptr, + size=err_fourier.nbytes, + stream=streamdata.queue) + streamdata.start_compute(prev_event) + + log(4, 'Position refinement trial: iteration %s' % (self.curiter)) + PCK.mangler.setup_shifts(self.curiter, nframes=addr.shape[0]) + for i in range(PCK.mangler.nshifts): + streamdata.queue.synchronize() + PCK.mangler.get_address(i, addr, mangled_addr, max_oby, max_obx) + PCK.build_aux(aux, mangled_addr, ob, pr) + PROP.fw(aux, aux) + if self.p.position_refinement.metric == "fourier": + PCK.fourier_error(aux, mangled_addr, mag, ma, ma_sum) + PCK.error_reduce(mangled_addr, err_fourier) + if self.p.position_refinement.metric == "photon": + PCK.log_likelihood(aux, mangled_addr, mag, ma, err_fourier) + PCK.update_addr_and_error_state(addr, error_state, mangled_addr, err_fourier) + + cuda.memcpy_dtod_async(dest=err_fourier.ptr, + src=error_state.ptr, + size=err_fourier.nbytes, + stream=streamdata.queue) + if use_tiles: + s1 = prep.addr_gpu.shape[0] * prep.addr_gpu.shape[1] + s2 = prep.addr_gpu.shape[2] * prep.addr_gpu.shape[3] + TK.transpose(prep.addr_gpu.reshape(s1, s2), prep.addr2_gpu.reshape(s2, s1)) + + prev_event = streamdata.end_compute() + + # next stream + self.cur_stream = (self.cur_stream + self.stream_direction) % len(self.streams) + + self.curiter += 1 + + #print('end loop, syncall and copy back') + for sd in self.streams: + sd.synchronize() + + for name, s in self.ob.S.items(): + s.gpu.get(s.data) + for name, s in self.pr.S.items(): + s.gpu.get(s.data) + + # FIXXME: copy to pinned memory + for dID, prep in self.diff_info.items(): + err_fourier = prep.err_fourier_gpu.get() + err_phot = prep.err_phot_gpu.get() + err_exit = prep.err_exit_gpu.get() + errs = np.ascontiguousarray(np.vstack([err_fourier, err_phot, err_exit]).T) + error.update(zip(prep.view_IDs, errs)) + + self.error = error + return error + + def _object_allreduce(self): + # make sure that all transfers etc are finished + for sd in self.streams: + sd.synchronize() + # sync all + for oID, ob in self.ob.storages.items(): + obn = self.ob_nrm.S[oID] + obb = self.ob_buf.S[oID] + self.multigpu.allReduceSum(obb.gpu) + self.multigpu.allReduceSum(obn.gpu) + obb.gpu /= obn.gpu + + self.clip_object(obb.gpu) + ob.gpu[:] = obb.gpu + + ## probe update + def probe_update(self, MPI=False): + t1 = time.time() + streamdata = self.streams[self.cur_stream] + use_atomics = self.p.probe_update_cuda_atomics + # storage for-loop + change_gpu = gpuarray.zeros((1,), dtype=np.float32) + prev_event = None + for pID, pr in self.pr.storages.items(): + prn = self.pr_nrm.S[pID] + cfact = self.pr_cfact[pID] + pr.gpu._axpbz(np.complex64(cfact), 0, pr.gpu, stream=streamdata.queue) + prn.gpu.fill(np.float32(cfact), stream=streamdata.queue) + + for dID in self.dID_list: + prep = self.diff_info[dID] + streamdata = self.streams[self.cur_stream] + + POK = self.kernels[prep.label].POK + POK.queue = streamdata.queue + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + ex = streamdata.ex_to_gpu(dID, prep.ex) + + # scan for-loop + addrt = prep.addr_gpu if use_atomics else prep.addr2_gpu + streamdata.start_compute(prev_event) + ev = POK.pr_update(addrt, + self.pr.S[pID].gpu, + self.pr_nrm.S[pID].gpu, + self.ob.S[oID].gpu, + ex, + atomics=use_atomics) + streamdata.record_done_ex(dID) + prev_event = streamdata.end_compute() + self.cur_stream = (self.cur_stream + self.stream_direction) % len(self.streams) + + # sync all streams first + for sd in self.streams: + sd.synchronize() + + for pID, pr in self.pr.storages.items(): + + buf = self.pr_buf.S[pID] + prn = self.pr_nrm.S[pID] + + self.multigpu.allReduceSum(pr.gpu) + self.multigpu.allReduceSum(prn.gpu) + pr.gpu /= prn.gpu + self.support_constraint(pr) + + ## calculate change on GPU + AUK = self.kernels[list(self.kernels)[0]].AUK + buf.gpu -= pr.gpu + change_gpu += (AUK.norm2(buf.gpu) / AUK.norm2(pr.gpu)) + buf.gpu[:] = pr.gpu + self.multigpu.allReduceSum(change_gpu) + change = change_gpu.get().item() / parallel.size + + # print 'probe update: ' + str(time.time()-t1) + self.benchmark.probe_update += time.time() - t1 + self.benchmark.calls_probe += 1 + + return np.sqrt(change) + + def engine_finalize(self, benchmark=False): + """ + Clear all GPU data, pinned memory, etc + """ + self.streams = None + self.ex_data = None + self.ma_data = None + self.mag_data = None + + super().engine_finalize(benchmark) + + +@register() +class DM_pycuda_streams(_ProjectionEngine_pycuda_streams, DMMixin): + """ + A full-fledged Difference Map engine accelerated with pycuda. + + Defaults: + + [name] + default = DM_pycuda + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + _ProjectionEngine_pycuda_streams.__init__(self, ptycho_parent, pars) + DMMixin.__init__(self, self.p.alpha) + ptycho_parent.citations.add_article(**self.article) + + +@register() +class RAAR_pycuda_streams(_ProjectionEngine_pycuda_streams, RAARMixin): + """ + A RAAR engine in accelerated with pycuda. + + Defaults: + + [name] + default = RAAR_pycuda + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + + _ProjectionEngine_pycuda_streams.__init__(self, ptycho_parent, pars) + RAARMixin.__init__(self, self.p.beta) diff --git a/archive/misc/mpitest.cpp b/archive/misc/mpitest.cpp new file mode 100644 index 000000000..e4ff84577 --- /dev/null +++ b/archive/misc/mpitest.cpp @@ -0,0 +1,47 @@ +/** This is a simple C++ test to check if cuda-aware MPI works as + * expected. + * It allocates a GPU array and puts 1s into it, then sends it + * across MPI to the receiving rank, which transfers back to + * host and outputs the values. + * The expected output is: + * + * Received 1, 1 + * + * Compile with: + * mpic++ -o test mpitest.cpp -L/path/to/cuda/libs -lcudart + * + * Run with: + * mpirun -np 2 test + */ + +#include +#include +#include +#include +#include + +int main(int argc, char** argv) +{ + MPI_Init(&argc, &argv); + + int rank; + MPI_Status status; + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + + if (rank == 0) { + int* d_send; + cudaMalloc((void**)&d_send, 2*sizeof(int)); + int h_send[] = {1, 1}; + cudaMemcpy(d_send, h_send, 2*sizeof(int), cudaMemcpyHostToDevice); + MPI_Send(d_send, 2, MPI_INT, 1, 99, MPI_COMM_WORLD); + std::cout << "Data has been sent...\n"; + } else if (rank == 1) { + int* d_recv; + cudaMalloc((void**)&d_recv, 2*sizeof(int)); + MPI_Recv(d_recv, 2, MPI_INT, 0, 99, MPI_COMM_WORLD, &status); + int h_recv[2]; + cudaMemcpy(h_recv, d_recv, 2*sizeof(int), cudaMemcpyDeviceToHost); + std::cout << "Received " << h_recv[0] << ", " << h_recv[1] << "\n"; + } + +} \ No newline at end of file diff --git a/benchmark/cufft_vs_reikna.py b/benchmark/cufft_vs_reikna.py new file mode 100644 index 000000000..d4e8b6caa --- /dev/null +++ b/benchmark/cufft_vs_reikna.py @@ -0,0 +1,82 @@ +""" +Tests cuFFT vs Reikna FFT performance (not accuracy). + +Together with a C++ implementation of cuFFT with callbacks, +we get the following numbers on a P100 GPU: + +For 100 calls of 256x256 with batch size 2000: +- Reikna with or without filters: 1,470ms +- cuFFT without filters : 792ms +- cuFFT with separate filters : 1,564ms +- cuFFT with callbacks : 916ms + +For 128x128 with batch size 2000: +- Reikna with or without filters: 389ms +- cuFFT without filters : 194ms +- cuFFT with separate filters : 388ms +- cuFFT with callbacks : 223ms +""" + + +import numpy as np +import pycuda.driver as cuda +from pycuda import gpuarray +from pycuda.tools import make_default_context +from ptypy.accelerate.cuda_pycuda.fft import FFT +from ptypy.accelerate.cuda_pycuda.cufft import FFT_cuda as cuFFT +import time + +ctx = make_default_context() +stream = cuda.Stream() + +A = 2000 +B = 256 +C = 256 + +COMPLEX_TYPE = np.complex64 + + +f = np.empty(shape=(A, B, C), dtype=np.complex64) +for idx in range(A): + f[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + +prefilter = (np.arange(B*C).reshape((B, C)) + 1j* np.arange(B*C).reshape((B, C))).astype(COMPLEX_TYPE) +postfilter = (np.arange(13, 13 + B*C).reshape((B, C)) + 1j*np.arange(13, 13 + B*C).reshape((B, C))).astype(COMPLEX_TYPE) + +f_d = gpuarray.to_gpu(f) + +prop_fwd = FFT(f, stream, pre_fft=prefilter, post_fft=postfilter, inplace=True, symmetric=True) + +start_reikna = cuda.Event() +stop_reikna = cuda.Event() +start_cufft = cuda.Event() +stop_cufft = cuda.Event() + +start_reikna.record(stream) +for p in range(100): + prop_fwd.ft(f_d, f_d) +stop_reikna.record(stream) +start_reikna.synchronize() +stop_reikna.synchronize() +time_reikna = stop_reikna.time_since(start_reikna) + +print('Reikna for {}: {}ms'.format((A,B,C), time_reikna)) + +# with pre- and post-filter +cuprop_fw = cuFFT(f, stream, pre_fft=prefilter, post_fft=postfilter, inplace=True, symmetric=True) +# without filters, and symmetric=False avoids scaling the result +#cuprop_fw = cuFFT(f, stream, pre_fft=None, post_fft=None, inplace=True, symmetric=False) + +start_cufft.record(stream) +for p in range(100): + cuprop_fw.ft(f_d, f_d) +stop_cufft.record(stream) +start_cufft.synchronize() +stop_cufft.synchronize() +time_cufft = stop_cufft.time_since(start_cufft) + +print('CUFFT for {}: {}ms'.format((A,B,C), time_cufft)) +print('CUFFT Speedup: {}x'.format(time_reikna/time_cufft)) + +ctx.pop() +ctx.detach() \ No newline at end of file diff --git a/benchmark/diamond_benchmarks/ML_accurracy_test.py b/benchmark/diamond_benchmarks/ML_accurracy_test.py new file mode 100644 index 000000000..a8da654ac --- /dev/null +++ b/benchmark/diamond_benchmarks/ML_accurracy_test.py @@ -0,0 +1,404 @@ +''' +Load real data and prepare an accuracy report of GPU vs numpy +''' + +import h5py +import numpy as np +import csv + +import pycuda.driver as cuda +from pycuda import gpuarray + +from ptypy.accelerate.cuda_pycuda.kernels import GradientDescentKernel +from ptypy.accelerate.base.kernels import GradientDescentKernel as BaseGradientDescentKernel + + +class GradientDescentAccuracyTester: + + datadir = "/dls/science/users/iat69393/gpu-hackathon/test-data-%s/" + rtol = 1e-6 + atol = 1e-6 + headings = ['Kernel', 'Version', 'Iter', 'MATH_TYPE', 'IN/OUT_TYPE', + 'ACC_TYPE', 'Array', 'num_elements', 'num_errors', 'max_relerr', 'max_abserr'] + + def __init__(self): + import sys + np.set_printoptions(threshold=sys.maxsize, linewidth=np.inf) + cuda.init() + self.device = cuda.Device(0) + self.ctx = self.device.make_context() + self.stream = cuda.Stream() + self.results = [] + + def __del__(self): + np.set_printoptions() + self.ctx.pop() + self.ctx.detach() + + def test_make_model(self, name, iter, + math_type={'float', 'double'}, + data_type={'float', 'double'}): + + res = [] + + # Load data + with h5py.File(self.datadir % name + "make_model_%04d.h5" % iter, "r") as f: + aux = f["aux"][:] + addr = f["addr"][:] + + # CPU Kernel + BGDK = BaseGradientDescentKernel(aux, addr.shape[1]) + BGDK.allocate() + BGDK.make_model(aux, addr) + ref = BGDK.npy.Imodel + + # GPU variants + addr_dev = gpuarray.to_gpu(addr) + for d in data_type: + if d == 'float': + aux_dev = gpuarray.to_gpu(aux.astype(np.complex64)) + else: + aux_dev = gpuarray.to_gpu(aux.astype(np.complex128)) + for m in math_type: + # data type will be determined based on aux_dev data type automatically + GDK = GradientDescentKernel( + aux_dev, addr.shape[1], queue=self.stream, math_type=m) + GDK.allocate() + GDK.make_model(aux_dev, addr_dev) + act = GDK.gpu.Imodel.get() + + num, num_mis, max_abs, max_rel = self._calc_diffs(act, ref) + + line = ['make_model', name, iter, d, m, 'N/A', + 'Imodel', num, num_mis, max_rel, max_abs] + print(line) + res.append(line) + + return res + + def test_floating_intensity(self, name, iter, + math_type={'float', 'double'}, + data_type={'float', 'double'}, + acc_type={'float', 'double'}): + + # note that this is actually calling 4 kernels: + # - floating_intensity_cuda_step1 + # - error_reduce_cuda (2x) + # - floating_intensity_cuda_step2 + + res = [] + + # Load data + with h5py.File(self.datadir % name + "floating_intensities_%04d.h5" % iter, "r") as f: + w = f["w"][:] + addr = f["addr"][:] + I = f["I"][:] + fic = f["fic"][:] + Imodel = f["Imodel"][:] + with h5py.File(self.datadir % name + "make_model_%04d.h5" % iter, "r") as f: + aux = f["aux"][:] + + # CPU Kernel + ficref = np.copy(fic) + Iref = np.copy(Imodel) + BGDK = BaseGradientDescentKernel(aux, addr.shape[1]) + BGDK.allocate() + BGDK.npy.Imodel = Iref + BGDK.floating_intensity(addr, w, I, ficref) # modifies fic, Imodel + Iref = BGDK.npy.Imodel + + addr_dev = gpuarray.to_gpu(addr) + for d in data_type: + for m in math_type: + for a in acc_type: + if d == 'float': + aux_dev = gpuarray.to_gpu(aux.astype(np.complex64)) + I_dev = gpuarray.to_gpu(I.astype(np.float32)) + fic_dev = gpuarray.to_gpu(fic.astype(np.float32)) + w_dev = gpuarray.to_gpu(w.astype(np.float32)) + Imodel_dev = gpuarray.to_gpu(Imodel.astype(np.float32)) + else: + aux_dev = gpuarray.to_gpu(aux.astype(np.complex128)) + I_dev = gpuarray.to_gpu(I.astype(np.float64)) + fic_dev = gpuarray.to_gpu(fic.astype(np.float64)) + w_dev = gpuarray.to_gpu(w.astype(np.float64)) + Imodel_dev = gpuarray.to_gpu(Imodel.astype(np.float64)) + + # GPU kernel + GDK = GradientDescentKernel( + aux_dev, addr.shape[1], accumulate_type=a, math_type=m, queue=self.stream) + GDK.allocate() + GDK.gpu.Imodel = Imodel_dev + GDK.floating_intensity(addr_dev, w_dev, I_dev, fic_dev) + + Iact = GDK.gpu.Imodel.get() + fact = fic_dev.get() + + num, num_mis, max_abs, max_rel = self._calc_diffs( + Iact, Iref) + line = ['floating_intensity', name, iter, d, m, + a, 'Imodel', num, num_mis, max_rel, max_abs] + print(line) + res.append(line) + + num, num_mis, max_abs, max_rel = self._calc_diffs( + fact, ficref) + line = ['floating_intensity', name, iter, d, m, + a, 'fic', num, num_mis, max_rel, max_abs] + print(line) + res.append(line) + + return res + + def test_main_and_error_reduce(self, name, iter, + math_type={'float', 'double'}, + data_type={'float', 'double'}, + acc_type={'float', 'double'}): + + res = [] + + # Load data + with h5py.File(self.datadir % name + "main_%04d.h5" % iter, "r") as f: + aux = f["aux"][:] + addr = f["addr"][:] + w = f["w"][:] + I = f["I"][:] + # Load data + with h5py.File(self.datadir % name + "error_reduce_%04d.h5" % iter, "r") as f: + err_phot = f["err_phot"][:] + + # CPU Kernel + auxref = np.copy(aux) + errref = np.copy(err_phot) + BGDK = BaseGradientDescentKernel(aux, addr.shape[1]) + BGDK.allocate() + BGDK.main(auxref, addr, w, I) + BGDK.error_reduce(addr, errref) + LLerrref = BGDK.npy.LLerr + + addr_dev = gpuarray.to_gpu(addr) + for d in data_type: + for m in math_type: + for a in acc_type: + if d == 'float': + aux_dev = gpuarray.to_gpu(aux.astype(np.complex64)) + I_dev = gpuarray.to_gpu(I.astype(np.float32)) + w_dev = gpuarray.to_gpu(w.astype(np.float32)) + err_phot_dev = gpuarray.to_gpu( + err_phot.astype(np.float32)) + else: + aux_dev = gpuarray.to_gpu(aux.astype(np.complex128)) + I_dev = gpuarray.to_gpu(I.astype(np.float64)) + w_dev = gpuarray.to_gpu(w.astype(np.float64)) + err_phot_dev = gpuarray.to_gpu( + err_phot.astype(np.float64)) + + # GPU kernel + GDK = GradientDescentKernel( + aux_dev, addr.shape[1], accumulate_type=a, math_type=m) + GDK.allocate() + GDK.main(aux_dev, addr_dev, w_dev, I_dev) + GDK.error_reduce(addr_dev, err_phot_dev) + + num, num_mis, max_abs, max_rel = self._calc_diffs( + auxref, aux_dev.get()) + line = ['main_and_error_reduce', name, iter, d, + m, a, 'aux', num, num_mis, max_rel, max_abs] + print(line) + res.append(line) + + num, num_mis, max_abs, max_rel = self._calc_diffs( + LLerrref, GDK.gpu.LLerr.get()) + line = ['main_and_error_reduce', name, iter, d, + m, a, 'LLerr', num, num_mis, max_rel, max_abs] + print(line) + res.append(line) + + num, num_mis, max_abs, max_rel = self._calc_diffs( + errref, err_phot_dev.get()) + line = ['main_and_error_reduce', name, iter, d, m, + a, 'err_phot', num, num_mis, max_rel, max_abs] + print(line) + res.append(line) + + return res + + def test_make_a012(self, name, iter, + math_type={'float', 'double'}, + data_type={'float', 'double'}, + acc_type={'float', 'double'}): + + # Reduce the array size to make the tests run faster + Nmax = 10 + Ymax = 128 + Xmax = 128 + + res = [] + + # Load data + with h5py.File(self.datadir % name + "make_a012_%04d.h5" % iter, "r") as g: + addr = g["addr"][:Nmax] + I = g["I"][:Nmax, :Ymax, :Xmax] + b_f = g["f"][:Nmax, :Ymax, :Xmax] + b_a = g["a"][:Nmax, :Ymax, :Xmax] + b_b = g["b"][:Nmax, :Ymax, :Xmax] + fic = g["fic"][:Nmax] + with h5py.File(self.datadir % name + "make_model_%04d.h5" % iter, "r") as h: + aux = h["aux"][:Nmax, :Ymax, :Xmax] + + # CPU Kernel + BGDK = BaseGradientDescentKernel(aux, addr.shape[1]) + BGDK.allocate() + BGDK.make_a012(b_f, b_a, b_b, addr, I, fic) + Imodelref = BGDK.npy.Imodel + LLerrref = BGDK.npy.LLerr + LLdenref = BGDK.npy.LLden + + addr_dev = gpuarray.to_gpu(addr) + for d in data_type: + for m in math_type: + for a in acc_type: + if d == 'float': + aux_dev = gpuarray.to_gpu(aux.astype(np.complex64)) + I_dev = gpuarray.to_gpu(I.astype(np.float32)) + b_f_dev = gpuarray.to_gpu(b_f.astype(np.complex64)) + b_a_dev = gpuarray.to_gpu(b_a.astype(np.complex64)) + b_b_dev = gpuarray.to_gpu(b_b.astype(np.complex64)) + fic_dev = gpuarray.to_gpu(fic.astype(np.float32)) + else: + aux_dev = gpuarray.to_gpu(aux.astype(np.complex128)) + I_dev = gpuarray.to_gpu(I.astype(np.float64)) + b_f_dev = gpuarray.to_gpu(b_f.astype(np.complex128)) + b_a_dev = gpuarray.to_gpu(b_a.astype(np.complex128)) + b_b_dev = gpuarray.to_gpu(b_b.astype(np.complex128)) + fic_dev = gpuarray.to_gpu(fic.astype(np.float64)) + + GDK = GradientDescentKernel(aux_dev, addr.shape[1], queue=self.stream, + math_type=m, accumulate_type=a) + GDK.allocate() + GDK.gpu.Imodel.fill(np.nan) + GDK.gpu.LLerr.fill(np.nan) + GDK.gpu.LLden.fill(np.nan) + GDK.make_a012(b_f_dev, b_a_dev, b_b_dev, + addr_dev, I_dev, fic_dev) + + num, num_mis, max_abs, max_rel = self._calc_diffs( + LLerrref, GDK.gpu.LLerr.get()) + line = ['make_a012', name, iter, d, m, a, + 'LLerr', num, num_mis, max_rel, max_abs] + print(line) + res.append(line) + + num, num_mis, max_abs, max_rel = self._calc_diffs( + LLdenref, GDK.gpu.LLden.get()) + line = ['make_a012', name, iter, d, m, a, + 'LLden', num, num_mis, max_rel, max_abs] + print(line) + res.append(line) + + num, num_mis, max_abs, max_rel = self._calc_diffs( + Imodelref, GDK.gpu.Imodel.get()) + line = ['make_a012', name, iter, d, m, a, + 'Imodel', num, num_mis, max_rel, max_abs] + print(line) + res.append(line) + + return res + + def test_fill_b(self, name, iter, + math_type={'float', 'double'}, + data_type={'float', 'double'}, + acc_type={'float', 'double'}): + + res = [] + + # Load data + + Nmax = 10 + Ymax = 128 + Xmax = 128 + + with h5py.File(self.datadir % name + "fill_b_%04d.h5" % iter, "r") as f: + w = f["w"][:Nmax, :Ymax, :Xmax] + addr = f["addr"][:] + B = f["B"][:] + Brenorm = f["Brenorm"][...] + A0 = f["A0"][:Nmax, :Ymax, :Xmax] + A1 = f["A1"][:Nmax, :Ymax, :Xmax] + A2 = f["A2"][:Nmax, :Ymax, :Xmax] + with h5py.File(self.datadir % name + "make_model_%04d.h5" % iter, "r") as f: + aux = f["aux"][:Nmax, :Ymax, :Xmax] + + # CPU Kernel + Bref = np.copy(B) + BGDK = BaseGradientDescentKernel(aux, addr.shape[1]) + BGDK.allocate() + BGDK.npy.Imodel = A0 + BGDK.npy.LLerr = A1 + BGDK.npy.LLden = A2 + BGDK.fill_b(addr, Brenorm, w, Bref) + + addr_dev = gpuarray.to_gpu(addr) + for d in data_type: + for m in math_type: + for a in acc_type: + if d == 'float': + aux_dev = gpuarray.to_gpu(aux.astype(np.complex64)) + w_dev = gpuarray.to_gpu(w.astype(np.float32)) + B_dev = gpuarray.to_gpu(B.astype(np.float32)) + A0_dev = gpuarray.to_gpu(A0.astype(np.float32)) + A1_dev = gpuarray.to_gpu(A1.astype(np.float32)) + A2_dev = gpuarray.to_gpu(A2.astype(np.float32)) + else: + aux_dev = gpuarray.to_gpu(aux.astype(np.complex128)) + w_dev = gpuarray.to_gpu(w.astype(np.float64)) + B_dev = gpuarray.to_gpu(B.astype(np.float64)) + A0_dev = gpuarray.to_gpu(A0.astype(np.float64)) + A1_dev = gpuarray.to_gpu(A1.astype(np.float64)) + A2_dev = gpuarray.to_gpu(A2.astype(np.float64)) + + GDK = GradientDescentKernel( + aux_dev, addr.shape[1], queue=self.stream, math_type=m, accumulate_type=a) + GDK.allocate() + GDK.gpu.Imodel = A0_dev + GDK.gpu.LLerr = A1_dev + GDK.gpu.LLden = A2_dev + GDK.fill_b(addr_dev, Brenorm, w_dev, B_dev) + + num, num_mis, max_abs, max_rel = self._calc_diffs( + Bref, B_dev.get()) + line = ['fill_b', name, iter, d, m, a, + 'B', num, num_mis, max_rel, max_abs] + print(line) + res.append(line) + + return res + + def _calc_diffs(self, act, ref): + diffs = np.abs(ref - act) + max_abs = np.max(diffs[:]) + aref = np.abs(ref[:]) + max_rel = np.max( + np.divide(diffs[:], aref, out=np.zeros_like(diffs[:]), where=aref > 0)) + num_mis = np.count_nonzero(diffs[:] > self.atol + self.rtol * aref) + num = np.prod(ref.shape) + + return num, num_mis, max_abs, max_rel + + +tester = GradientDescentAccuracyTester() +print(tester.headings) + +res = [tester.headings] +for ver in [("base", 10), ("regul", 50), ("floating", 0)]: + res += tester.test_make_model(*ver) + res += tester.test_floating_intensity(*ver) + res += tester.test_main_and_error_reduce(*ver) + res += tester.test_make_a012(*ver) + res += tester.test_fill_b(*ver) + +with open('ML_accuracy_test_results.csv', 'w', newline='') as f: + writer = csv.writer(f) + writer.writerows(res) + +print('Done.') diff --git a/benchmark/diamond_benchmarks/moonflower_scripts/i08.py b/benchmark/diamond_benchmarks/moonflower_scripts/i08.py new file mode 100644 index 000000000..273a8ecbf --- /dev/null +++ b/benchmark/diamond_benchmarks/moonflower_scripts/i08.py @@ -0,0 +1,74 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines("cuda") +import time + +import os +import getpass +from pathlib import Path +username = getpass.getuser() +tmpdir = os.path.join('/dls/tmp', username, 'dumps', 'ptypy') +Path(tmpdir).mkdir(parents=True, exist_ok=True) + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 500 +# set home path +p.io = u.Param() +p.io.home = tmpdir +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param() +p.io.interaction.server = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.I08 = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.I08.name = 'BlockFull' +p.scans.I08.data= u.Param() +p.scans.I08.data.name = 'MoonFlowerScan' +p.scans.I08.data.shape = 128 +p.scans.I08.data.num_frames = 10000 # real is 50000 +p.scans.I08.data.save = None + +p.scans.I08.illumination = u.Param() +p.scans.I08.coherence = u.Param(num_probe_modes=20) +p.scans.I08.illumination.diversity = u.Param() +p.scans.I08.illumination.diversity.noise = (0.5, 1.0) +p.scans.I08.illumination.diversity.power = 0.1 + +# position distance in fraction of illumination frame +p.scans.I08.data.density = 0.05 +# total number of photon in empty beam +p.scans.I08.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.I08.data.psf = 1.5 + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda' +p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 20 +p.engines.engine00.probe_update_start = 1 +p.engines.engine00.probe_update_cuda_atomics = False +p.engines.engine00.object_update_cuda_atomics = True + +# prepare and run +P = Ptycho(p,level=4) +t1 = time.perf_counter() +P.run() +t2 = time.perf_counter() +P.print_stats() +print('Elapsed Compute Time: {} seconds'.format(t2-t1)) + diff --git a/benchmark/diamond_benchmarks/moonflower_scripts/i13.py b/benchmark/diamond_benchmarks/moonflower_scripts/i13.py new file mode 100644 index 000000000..1cf42d5e4 --- /dev/null +++ b/benchmark/diamond_benchmarks/moonflower_scripts/i13.py @@ -0,0 +1,75 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines("cuda") +import time + +import os +import getpass +from pathlib import Path +username = getpass.getuser() +tmpdir = os.path.join('/dls/tmp', username, 'dumps', 'ptypy') +Path(tmpdir).mkdir(parents=True, exist_ok=True) + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 100 +# set home path +p.io = u.Param() +p.io.home = tmpdir +p.io.autosave = u.Param(active=False) #(active=True, interval=50000) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param() +p.io.interaction.server = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.i13 = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.i13.name = 'BlockFull' # or 'Full' +p.scans.i13.data= u.Param() +p.scans.i13.data.name = 'MoonFlowerScan' +p.scans.i13.data.shape = 512 +p.scans.i13.data.num_frames = 5000 +p.scans.i13.data.save = None + +p.scans.i13.illumination = u.Param() +p.scans.i13.coherence = u.Param(num_probe_modes=1) +p.scans.i13.illumination.diversity = u.Param() +p.scans.i13.illumination.diversity.noise = (0.5, 1.0) +p.scans.i13.illumination.diversity.power = 0.1 + +# position distance in fraction of illumination frame +p.scans.i13.data.density = 0.2 +# total number of photon in empty beam +p.scans.i13.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.i13.data.psf = 0.2 + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda' +p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 20 +p.engines.engine00.probe_update_start = 1 +p.engines.engine00.probe_update_cuda_atomics = False +p.engines.engine00.object_update_cuda_atomics = True + + +# prepare and run +P = Ptycho(p,level=4) +t1 = time.perf_counter() +P.run() +t2 = time.perf_counter() +P.print_stats() +print('Elapsed Compute Time: {} seconds'.format(t2-t1)) + diff --git a/benchmark/diamond_benchmarks/moonflower_scripts/i14_1.py b/benchmark/diamond_benchmarks/moonflower_scripts/i14_1.py new file mode 100644 index 000000000..9d1abcccb --- /dev/null +++ b/benchmark/diamond_benchmarks/moonflower_scripts/i14_1.py @@ -0,0 +1,73 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines("cuda") +import time + +import os +import getpass +from pathlib import Path +username = getpass.getuser() +tmpdir = os.path.join('/dls/tmp', username, 'dumps', 'ptypy') +Path(tmpdir).mkdir(parents=True, exist_ok=True) + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 500 +# set home path +p.io = u.Param() +p.io.home = tmpdir +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param() +p.io.interaction.server = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.i14_1 = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.i14_1.name = 'BlockFull' +p.scans.i14_1.data= u.Param() +p.scans.i14_1.data.name = 'MoonFlowerScan' +p.scans.i14_1.data.shape = 256 +p.scans.i14_1.data.num_frames = 15000 +p.scans.i14_1.data.save = None + +p.scans.i14_1.illumination = u.Param() +p.scans.i14_1.coherence = u.Param(num_probe_modes=2) +p.scans.i14_1.illumination.diversity = u.Param() +p.scans.i14_1.illumination.diversity.noise = (0.5, 1.0) +p.scans.i14_1.illumination.diversity.power = 0.1 + +# position distance in fraction of illumination frame +p.scans.i14_1.data.density = 0.2 +# total number of photon in empty beam +p.scans.i14_1.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.i14_1.data.psf = 0.2 + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda' +p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 20 +p.engines.engine00.probe_update_start = 1 +p.engines.engine00.probe_update_cuda_atomics = False +p.engines.engine00.object_update_cuda_atomics = True + +# prepare and run +P = Ptycho(p,level=4) +t1 = time.perf_counter() +P.run() +t2 = time.perf_counter() +P.print_stats() +print('Elapsed Compute Time: {} seconds'.format(t2-t1)) diff --git a/benchmark/diamond_benchmarks/moonflower_scripts/i14_2.py b/benchmark/diamond_benchmarks/moonflower_scripts/i14_2.py new file mode 100644 index 000000000..8e3c7241e --- /dev/null +++ b/benchmark/diamond_benchmarks/moonflower_scripts/i14_2.py @@ -0,0 +1,75 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" + +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines("cuda") +import time + +import os +import getpass +from pathlib import Path +username = getpass.getuser() +tmpdir = os.path.join('/dls/tmp', username, 'dumps', 'ptypy') +Path(tmpdir).mkdir(parents=True, exist_ok=True) + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 1000 +# set home path +p.io = u.Param() +p.io.home = tmpdir +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param() +p.io.interaction.server = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.i14_2 = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.i14_2.name = 'BlockFull' +p.scans.i14_2.data= u.Param() +p.scans.i14_2.data.name = 'MoonFlowerScan' +p.scans.i14_2.data.shape = 128 +p.scans.i14_2.data.num_frames = 10000 #50000 is the real value +p.scans.i14_2.data.save = None + +p.scans.i14_2.illumination = u.Param() +p.scans.i14_2.coherence = u.Param(num_probe_modes=5) +p.scans.i14_2.illumination.diversity = u.Param() +p.scans.i14_2.illumination.diversity.noise = (0.5, 1.0) +p.scans.i14_2.illumination.diversity.power = 0.1 + +# position distance in fraction of illumination frame +p.scans.i14_2.data.density = 0.2 +# total number of photon in empty beam +p.scans.i14_2.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.i14_2.data.psf = 0.4 + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda' +p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 20 +p.engines.engine00.probe_update_start = 1 +p.engines.engine00.probe_update_cuda_atomics = False +p.engines.engine00.object_update_cuda_atomics = True + + +# prepare and run +P = Ptycho(p,level=4) +t1 = time.perf_counter() +P.run() +t2 = time.perf_counter() +P.print_stats() +print('Elapsed Compute Time: {} seconds'.format(t2-t1)) diff --git a/benchmark/diamond_benchmarks/moonflower_scripts/profile_all.sh b/benchmark/diamond_benchmarks/moonflower_scripts/profile_all.sh new file mode 100755 index 000000000..33667bf42 --- /dev/null +++ b/benchmark/diamond_benchmarks/moonflower_scripts/profile_all.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +# exit on errors +set -e + +# Find folder of benchmarks +SCRIPTDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" +cd $SCRIPTDIR/../../.. # ptypy folder + +# scripts to run + output folder +scripts="i08 i13 i14_1 i14_2" +profdir=/dls/tmp/${USER}/nvprof + + +mkdir -p ${profdir} + + +# run all scripts +for script in $scripts +do + rm -f ${profdir}/${script}.*.nvprof + mpirun -np 4 \ + nvprof -f -o ${profdir}/${script}.%q{OMPI_COMM_WORLD_RANK}.nvprof \ + python benchmark/diamond_benchmarks/moonflower_scripts/${script}.py \ + 2>&1 | tee ${profdir}/${script}.log +done + +# Output summary +for script in $scripts +do + totaltime=$(awk '$0 ~ /Elapsed Compute Time:/ {print $4}' ${profdir}/${script}.log) + echo $script Time: $totaltime +done diff --git a/benchmark/model_speed.py b/benchmark/model_speed.py index 7abcdfd88..f05dd49dd 100644 --- a/benchmark/model_speed.py +++ b/benchmark/model_speed.py @@ -1,20 +1,23 @@ - from ptypy.core import Ptycho from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + p = u.Param() # for verbose output -p.verbose_level = 2 +p.verbose_level = "info" # set home path p.io = u.Param() -p.io.home = "/tmp/ptypy/" +p.io.home = "/".join([tmpdir, "ptypy"]) p.io.autosave = None p.io.interaction = u.Param(active=False) p.scans = u.Param() p.scans.MF = u.Param() -p.scans.MF.name = 'BlockFull' # or 'Full' +p.scans.MF.name = 'BlockFull' p.scans.MF.data = u.Param() p.scans.MF.data.name = 'QuickScan' p.scans.MF.data.shape = 32 @@ -33,11 +36,11 @@ # prepare and run P = Ptycho(p,level=1) for scan in P.model.scans.values(): - scan.frames_per_call=1000 + scan.max_frames_per_block=1000 P.model.new_data() P.model.new_data() P.model.new_data() -u.verbose.set_level(3) +u.verbose.set_level("info") if u.parallel.master: P.print_stats() diff --git a/benchmark/mpi_allreduce_bench.sh b/benchmark/mpi_allreduce_bench.sh new file mode 100755 index 000000000..b4f214f6f --- /dev/null +++ b/benchmark/mpi_allreduce_bench.sh @@ -0,0 +1,11 @@ +#!/bin/bash + +# Runs MPI all reduce benchmark with variable number of processes + +echo "Processes,i08,i13,i14_1,i14_2" +for p in {2..16} +do + echo -n $p + mpirun -np $p python mpi_allreduce_speed.py | \ + awk -F, '$0 ~ /^i[0-9]/ {printf(",%s", $2)} END {print ""}' +done \ No newline at end of file diff --git a/benchmark/mpi_allreduce_bench_launcher.sh b/benchmark/mpi_allreduce_bench_launcher.sh new file mode 100755 index 000000000..9bc2ff0db --- /dev/null +++ b/benchmark/mpi_allreduce_bench_launcher.sh @@ -0,0 +1,8 @@ +#!/bin/bash + +for p in {2..32} +do + qsub -pe openmpi ${p}0 -l exclusive,gpu=4,gpu_arch=pascal \ + -P ptychography -o mpi.${p}.out -j y mpi_allreduce_bench_multinode.sh ${p} ; +done + diff --git a/benchmark/mpi_allreduce_bench_multinode.sh b/benchmark/mpi_allreduce_bench_multinode.sh new file mode 100755 index 000000000..7f1173372 --- /dev/null +++ b/benchmark/mpi_allreduce_bench_multinode.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +workdir=~/work/ptypy +export PYTHONPATH=$workdir +cd $workdir/benchmark + +numproc=$1 + +HOSTLIST=$(cat ${PE_HOSTFILE} | awk '{print $1}' | tr "\n" ",") # comma separated list of hosts +# echo "THE HOSTLIST IS $HOSTLIST" +# NUMCORES=$(cat ${PE_HOSTFILE} | awk 'NR==1{print $2}') # to be overridden soon, but is just the number of cores per host +NUMCORES=4 +# echo "THE number of cores per node is $NUMCORES" +HOST_LIST_WITH_CORES=${HOSTLIST//,/:$NUMCORES,} # puts in the number of cores where the comma would be +HOST_LIST_WITH_CORES=${HOST_LIST_WITH_CORES%?} # gets rid of the trailing comma +# echo "THE HOST LIST WITH CORES IS $HOST_LIST_WITH_CORES" + +mpirun -np $numproc --host ${HOST_LIST_WITH_CORES} python mpi_allreduce_speed.py \ No newline at end of file diff --git a/benchmark/mpi_allreduce_speed.py b/benchmark/mpi_allreduce_speed.py new file mode 100644 index 000000000..5102e35af --- /dev/null +++ b/benchmark/mpi_allreduce_speed.py @@ -0,0 +1,42 @@ +import numpy as np +from ptypy.utils import parallel +from mpi4py import MPI +import time + +sizes ={ + 'i08': (1, 960, 960), + 'i13': (1, 13408, 13408), + 'i14_1': (1, 8160, 8160), + 'i14_2': (1, 3360, 3360), +} + +def run_benchmark(shape): + megabytes = np.product(shape) * 8 / 1024 / 1024 * 2 + + data = np.zeros(shape, dtype=np.complex64) + + # average 5 runs + duration = 0 + for n in range(5): + t1 = time.perf_counter() + parallel.allreduce(data) # 2 calls to simulate ptypy obb / obn reduce + parallel.allreduce(data) + t2 = time.perf_counter() + duration += t2-t1 + duration /= 5 + + total = parallel.allreduce(duration, MPI.MAX) + + return megabytes, duration + +res = [] + +for name,sz in sizes.items(): + mb, dur = run_benchmark(sz) + res.append([name, dur, mb, mb/dur]) + +if parallel.rank == 0: + print('Final results for {} processes'.format(parallel.size)) + print(','.join(['Name', 'Duration', 'MB', 'MB/s'])) + for r in res: + print(','.join([str(x) for x in r])) \ No newline at end of file diff --git a/benchmark/tiled_vs_atomic.py b/benchmark/tiled_vs_atomic.py new file mode 100644 index 000000000..883f4de3d --- /dev/null +++ b/benchmark/tiled_vs_atomic.py @@ -0,0 +1,113 @@ + +import numpy as np +import pycuda.driver as cuda +from pycuda import gpuarray +from pycuda.tools import make_default_context +from ptypy.accelerate.cuda_pycuda.kernels import PoUpdateKernel as POK +import gc + +cuda.init() + + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +def prepare_arrays( + overlap=0.2, + scan_pts=20, + frame_size =128, + atomics=True, + num_pr_modes=2, + num_ob_modes=1): + + fsh = (frame_size,frame_size) + shift=int(frame_size*overlap) + X, Y = np.indices((scan_pts,scan_pts)) * shift + X = X.flatten() + Y = Y.flatten() + num_pts=len(X) + X+=5 + Y+=5 + osh=(X.max()+5+fsh[0],Y.max()+5+fsh[1]) # ob shape + #print(fsh, osh, X.min(), X.max()+fsh[0], Y.min(),Y.max()+fsh[1]) + num_modes = num_ob_modes * num_pr_modes + A = num_pts * num_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(num_pr_modes,fsh[0],fsh[1]), dtype=COMPLEX_TYPE) + for idx in range(num_pr_modes): + probe[idx] = np.ones(fsh) * (idx + 1) + 1j * np.ones(fsh) * (idx + 1) + + object_array = np.empty(shape=(num_ob_modes,osh[0],osh[1]), dtype=COMPLEX_TYPE) + for idx in range(num_ob_modes): + object_array[idx] = np.ones(osh) * (3 * idx + 1) + 1j * np.ones(osh) * (3 * idx + 1) + + exit_wave = np.empty(shape=(A,fsh[0],fsh[1]), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones(fsh) * (idx + 1) + 1j * np.ones(fsh) * (idx + 1) + + addr = np.zeros((num_pts, num_modes, 5, 3), dtype=INT_TYPE) + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): # + mode_idx = 0 + for pr_mode in range(num_pr_modes): + for ob_mode in range(num_ob_modes): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + if not atomics: + addr = np.ascontiguousarray(np.transpose(addr, (2, 3, 0, 1))) + + #print(addr) + object_array_denominator = np.empty_like(object_array, dtype=FLOAT_TYPE) + for idx in range(num_ob_modes): + object_array_denominator[idx] = np.ones(osh) * (5 * idx + 2) # + 1j * np.ones(osh) * (5 * idx + 2) + + probe_denominator = np.empty_like(probe, dtype=FLOAT_TYPE) + for idx in range(num_pr_modes): + probe_denominator[idx] = np.ones(fsh) * (5 * idx + 2) # + 1j * np.ones(fsh) * (5 * idx + 2) + + return (gpuarray.to_gpu(addr), + gpuarray.to_gpu(object_array), + gpuarray.to_gpu(object_array_denominator), + gpuarray.to_gpu(probe), + gpuarray.to_gpu(exit_wave), + gpuarray.to_gpu(probe_denominator)) + +#for overlap in [0.2]: +# for +ctx = make_default_context() +stream = cuda.Stream() +pok = POK(stream) + +overlap=0.2 +scan_pts=20 +for frame_size in [64,128,256,512]: + for atomics in [True, False]: + for overlap in [0.01,0.01,0.02,0.04,0.08]: + + addr, ob, obn, pr, ex, prn = prepare_arrays(overlap, scan_pts, frame_size, atomics) + stream.synchronize() + start = cuda.Event() + stop = cuda.Event() + start.record(stream) + for p in range(1): + pok.ob_update(addr, ob, obn, pr, ex, atomics) + stop.record(stream) + stop.synchronize() + dt = stop.time_since(start) + stream.synchronize() + print('10x for {}: {}ms'.format((overlap,frame_size,scan_pts, atomics), dt)) + +del stream +ctx.pop() +ctx.detach() +del addr, ob, obn, pr, ex, prn +gc.collect() \ No newline at end of file diff --git a/cufft/dependencies.yml b/cufft/dependencies.yml new file mode 100644 index 000000000..949079d36 --- /dev/null +++ b/cufft/dependencies.yml @@ -0,0 +1,10 @@ +name: ptypy_cufft +channels: + - conda-forge +dependencies: + - python=3.9 + - cmake>=3.8.0 + - pybind11 + - compilers + - cudatoolkit-dev + - pip \ No newline at end of file diff --git a/cufft/extensions.py b/cufft/extensions.py new file mode 100644 index 000000000..4fabf2d2c --- /dev/null +++ b/cufft/extensions.py @@ -0,0 +1,151 @@ +''' +Compilation tools for Nvidia builds of extension modules. +''' +import os, re +import subprocess +import sysconfig +import pybind11 +from distutils.unixccompiler import UnixCCompiler +from distutils.command.build_ext import build_ext + + +def find_in_path(name, path): + "Find a file in a search path" + # adapted fom http://code.activestate.com/recipes/52224-find-a-file-given-a-search-path/ + for dir in path.split(os.pathsep): + binpath = os.path.join(dir, name) + if os.path.exists(binpath): + return os.path.abspath(binpath) + return None + +def locate_cuda(): + """ + Locate the CUDA environment on the system + Returns a dict with keys 'home', 'nvcc', 'include', and 'lib64' + and values giving the absolute path to each directory. + Starts by looking for the CUDAHOME env variable. If not found, everything + is based on finding 'nvcc' in the PATH. + """ + # first check if the CUDAHOME env variable is in use + if 'CUDAHOME' in os.environ: + home = os.environ['CUDAHOME'] + nvcc = os.path.join(home, 'bin', 'nvcc') + else: + # otherwise, search the PATH for NVCC + nvcc = find_in_path('nvcc', os.environ['PATH']) + if nvcc is None: + raise EnvironmentError('The nvcc binary could not be ' + 'located in your $PATH. Either add it to your path, or set $CUDAHOME') + home = os.path.dirname(os.path.dirname(nvcc)) + + cudaconfig = {'home': home, 'nvcc': nvcc, + 'include': os.path.join(home, 'include'), + 'lib64': os.path.join(home, 'lib64')} + for k, v in cudaconfig.items(): + if not os.path.exists(v): + raise EnvironmentError('The CUDA %s path could not be located in %s' % (k, v)) + return cudaconfig + +def get_cuda_version(nvcc): + """ + Get the CUDA version py running `nvcc --version`. + """ + stdout = subprocess.check_output([nvcc,"--version"]).decode("utf-8") + if bool(stdout.rstrip()): + regex = r'release (\S+),' + match = re.search(regex, stdout) + if match: + return float(match.group(1)) + raise LookupError('Unable to parse nvcc version output from {}'.format(stdout)) + else: + return None + +def get_cuda_arch_flags(version): + if version in (10.0, 10.1, 10.2): + archflag = ' -gencode=arch=compute_60,code=sm_60' + \ + ' -gencode=arch=compute_61,code=sm_61' + \ + ' -gencode=arch=compute_70,code=sm_70' + \ + ' -gencode=arch=compute_75,code=sm_75' + \ + ' -gencode=arch=compute_75,code=compute_75' + elif version == 11.0: + archflag = ' -gencode=arch=compute_60,code=sm_60' + \ + ' -gencode=arch=compute_61,code=sm_61' + \ + ' -gencode=arch=compute_70,code=sm_70' + \ + ' -gencode=arch=compute_75,code=sm_75' + \ + ' -gencode=arch=compute_80,code=sm_80' + \ + ' -gencode=arch=compute_80,code=compute_80' + elif version >= 11.1: + archflag = ' -gencode=arch=compute_60,code=sm_60' + \ + ' -gencode=arch=compute_61,code=sm_61' + \ + ' -gencode=arch=compute_70,code=sm_70' + \ + ' -gencode=arch=compute_75,code=sm_75' + \ + ' -gencode=arch=compute_80,code=sm_80' + \ + ' -gencode=arch=compute_86,code=sm_86' + \ + ' -gencode=arch=compute_86,code=compute_86' + else: + raise ValueError("CUDA version %s not supported" %str(version)) + return archflag + +class NvccCompiler(UnixCCompiler): + def __init__(self, *args, **kwargs): + super(NvccCompiler, self).__init__(*args, **kwargs) + self.CUDA = locate_cuda() + self.CUDA_VERSION = get_cuda_version(self.CUDA["nvcc"]) + module_dir = os.path.join(__file__.strip('import_fft.py'), 'cuda', 'filtered_fft') + # by default, compile for all of these + archflag = get_cuda_arch_flags(self.CUDA_VERSION) + self.src_extensions.append('.cu') + self.LD_FLAGS = [archflag, "-lcufft_static", "-lculibos", "-ldl", "-lrt", "-lpthread", "-cudart shared"] + self.NVCC_FLAGS = ["-dc", archflag] + self.CXXFLAGS = ['"-fPIC"'] + pybind_includes = [pybind11.get_include(), sysconfig.get_path('include')] + INCLUDES = pybind_includes + [self.CUDA['lib64'], module_dir] + self.INCLUDES = ["-I%s" % ix for ix in INCLUDES] + self.OPTFLAGS = ["-O3", "-std=c++14"] + + def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts): + default_compiler_so = self.compiler_so + CPPFLAGS = self.INCLUDES + extra_postargs # little hack here, since postargs usually goes at the end, which we won't do. + # makefile line is + # $(NVCC) $(NVCC_FLAGS) $(OPTFLAGS) -Xcompiler "$(CXXFLAGS)" $(CPPFLAGS) + compiler_command = [self.CUDA["nvcc"]] + self.NVCC_FLAGS + self.OPTFLAGS + ["-Xcompiler"] + self.CXXFLAGS + CPPFLAGS + compiler_exec = " ".join(compiler_command) + self.set_executable('compiler_so', compiler_exec) + postargs = [] # we don't actually have any postargs + super(NvccCompiler, self)._compile(obj, src, ext, cc_args, postargs, pp_opts) # the _compile method + # reset the default compiler_so, which we might have changed for cuda + self.compiler_so = default_compiler_so + + def link(self, target_desc, objects, + output_filename, output_dir=None, libraries=None, + library_dirs=None, runtime_library_dirs=None, + export_symbols=None, debug=0, extra_preargs=None, + extra_postargs=None, build_temp=None, target_lang=None): + default_linker_so = self.linker_so + # make file line is + # $(NVCC) $(OPTFLAGS) -shared $(LD_FLAGS) $(OBJ) $(OBJ_MOD) -o $@ + linker_command = [self.CUDA["nvcc"]] + self.OPTFLAGS + ["-shared"] + self.LD_FLAGS + linker_exec = " ".join(linker_command) + self.set_executable('linker_so', linker_exec) + super(NvccCompiler, self).link(target_desc, objects, + output_filename, output_dir=None, libraries=None, + library_dirs=None, runtime_library_dirs=None, + export_symbols=None, debug=0, extra_preargs=None, + extra_postargs=None, build_temp=None, target_lang=None) + self.linker_so = default_linker_so + +class CustomBuildExt(build_ext): + + def build_extension(self, ext): + has_cu = any([src.endswith('.cu') for src in ext.sources]) + if has_cu: + old_compiler = self.compiler + self.compiler = NvccCompiler(verbose=old_compiler.verbose, + dry_run=old_compiler.dry_run, + force=old_compiler.force) # this is our bespoke compiler + super(CustomBuildExt, self).build_extension(ext) + self.compiler=old_compiler + else: + super(CustomBuildExt, self).build_extension(ext) + + diff --git a/cufft/filtered_fft/.gitignore b/cufft/filtered_fft/.gitignore new file mode 100644 index 000000000..f54b22f60 --- /dev/null +++ b/cufft/filtered_fft/.gitignore @@ -0,0 +1,6 @@ +*.o +smoke_test +*.so +.module* +.rendered* +module_*_* \ No newline at end of file diff --git a/cufft/filtered_fft/Makefile b/cufft/filtered_fft/Makefile new file mode 100644 index 000000000..a8aa06866 --- /dev/null +++ b/cufft/filtered_fft/Makefile @@ -0,0 +1,29 @@ +NVCC = nvcc +NVCC_FLAGS += -dc -arch=sm_70 +CUDADIR = $(dir $(shell which nvcc) )/.. + +INCLUDES = $(shell python -m pybind11 --includes) -I$(CUDADIR)/include +PYMODEXT = $(shell python-config --extension-suffix) +CPPFLAGS += $(INCLUDES) -DMY_FFT_ROWS=128 -DMY_FFT_COLS=128 +OPTFLAGS = -O3 -std=c++14 +CXXFLAGS += -fPIC +LD_FLAGS += -L$(CUDADIR)/lib64 -lcufft_static -lculibos -ldl -lrt -lpthread -cudart shared +OBJ = filtered_fft.o +OBJ_MOD = module.o +MODULE = module$(PYMODEXT) + +all: $(MODULE) $(EXE) + +python: $(MODULE) + +clean: + rm -rf $(OBJ) $(EXE) $(MODULE) $(OBJ_EXE) $(OBJ_MOD) + +%.o: %.cu + $(NVCC) $(NVCC_FLAGS) $(OPTFLAGS) -Xcompiler "$(CXXFLAGS)" $(CPPFLAGS) -c $< -o $@ + +%.o: %.cpp + $(NVCC) $(NVCC_FLAGS) -x cu $(OPTFLAGS) -Xcompiler "$(CXXFLAGS)" $(CPPFLAGS) -c $< -o $@ + +$(MODULE): $(OBJ) $(OBJ_MOD) + $(NVCC) $(OPTFLAGS) -shared $(LD_FLAGS) $(OBJ) $(OBJ_MOD) -o $@ diff --git a/cufft/filtered_fft/compiler_flags_info.txt b/cufft/filtered_fft/compiler_flags_info.txt new file mode 100644 index 000000000..124e8bd62 --- /dev/null +++ b/cufft/filtered_fft/compiler_flags_info.txt @@ -0,0 +1,6 @@ +nvcc -dc -arch=sm_60 -gencode=arch=compute_30,code=sm_30 -gencode=arch=compute_50,code=sm_50 -gencode=arch=compute_52,code=sm_52 -gencode=arch=compute_60,code=sm_60 -gencode=arch=compute_61,code=sm_61 -gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_70,code=compute_70 -x cu -O3 -std=c++14 -Xcompiler "-fPIC" -DMY_FFT_ROWS=128 -DMY_FFT_COLS=128 -I/dls_sw/apps/ptypy/accelerate_cppimport_pybind/miniconda/envs/full_dependencies/include/python3.7m -I/dls_sw/apps/ptypy/accelerate_cppimport_pybind/miniconda/envs/full_dependencies/include -I/dls_sw/apps/cuda/10.1/bin//../include -c filtered_fft.cpp -o filtered_fft.o +nvcc -dc -arch=sm_60 -gencode=arch=compute_30,code=sm_30 -gencode=arch=compute_50,code=sm_50 -gencode=arch=compute_52,code=sm_52 -gencode=arch=compute_60,code=sm_60 -gencode=arch=compute_61,code=sm_61 -gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_70,code=compute_70 -x cu -O3 -std=c++14 -Xcompiler "-fPIC" -DMY_FFT_ROWS=128 -DMY_FFT_COLS=128 -I/dls_sw/apps/ptypy/accelerate_cppimport_pybind/miniconda/envs/full_dependencies/include/python3.7m -I/dls_sw/apps/ptypy/accelerate_cppimport_pybind/miniconda/envs/full_dependencies/include -I/dls_sw/apps/cuda/10.1/bin//../include -c module.cpp -o module.o +nvcc -O3 -std=c++14 -shared -L/dls_sw/apps/cuda/10.1/bin//../lib64 -lcufft_static -lculibos -cudart shared -ldl -lrt -lpthread filtered_fft.o module.o -o filtered_fft.so +nvcc -dc -arch=sm_60 -gencode=arch=compute_30,code=sm_30 -gencode=arch=compute_50,code=sm_50 -gencode=arch=compute_52,code=sm_52 -gencode=arch=compute_60,code=sm_60 -gencode=arch=compute_61,code=sm_61 -gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_70,code=compute_70 -x cu -O3 -std=c++14 -Xcompiler "-fPIC" -DMY_FFT_ROWS=128 -DMY_FFT_COLS=128 -I/dls_sw/apps/ptypy/accelerate_cppimport_pybind/miniconda/envs/full_dependencies/include/python3.7m -I/dls_sw/apps/ptypy/accelerate_cppimport_pybind/miniconda/envs/full_dependencies/include -I/dls_sw/apps/cuda/10.1/bin//../include -c smoke_test.cpp -o smoke_test.o +nvcc -O3 -std=c++14 -o smoke_test -L/dls_sw/apps/cuda/10.1/bin//../lib64 -lcufft_static -lculibos -cudart shared -ldl -lrt -lpthread filtered_fft.o smoke_test.o + diff --git a/cufft/filtered_fft/errors.h b/cufft/filtered_fft/errors.h new file mode 100644 index 000000000..f14781c1f --- /dev/null +++ b/cufft/filtered_fft/errors.h @@ -0,0 +1,86 @@ +#pragma once +#include +#include +#include +#include + + +inline std::string getloc(const char* func, const char* file, int line) +{ + return std::string(file) + ":" + std::to_string(line) + ": in function " + + func; +} + +inline void handleCudaCheck(cudaError_t res, const char* func, const char *file, int line) +{ + if (res != 0) { + throw std::runtime_error(std::string("CUDA Error: ") + + getloc(func, file, line) + ": " + cudaGetErrorString(res)); + } +} + +inline void handleCudaCheck(cufftResult res, const char* func, const char* file, int line) { + if (res) { + const char* errstr; + switch (res) { + case CUFFT_INVALID_PLAN: + errstr = "cuFFT was passed an invalid plan handle"; + break; + case CUFFT_ALLOC_FAILED: + errstr = "cuFFT failed to allocate GPU or CPU memory"; + break; + case CUFFT_INVALID_TYPE: + errstr = "No longer used"; + break; + case CUFFT_INVALID_VALUE: + errstr = "User specified an invalid pointer or parameter"; + break; + case CUFFT_INTERNAL_ERROR: + errstr = "Driver or internal cuFFT library error"; + break; + case CUFFT_EXEC_FAILED: + errstr = "Failed to execute an FFT on the GPU"; + break; + case CUFFT_SETUP_FAILED: + errstr = "The cuFFT library failed to initialize"; + break; + case CUFFT_INVALID_SIZE: + errstr = "User specified an invalid transform size"; + break; + case CUFFT_UNALIGNED_DATA: + errstr = " No longer used"; + break; + case CUFFT_INCOMPLETE_PARAMETER_LIST: + errstr = " Missing parameters in call "; + break; + case CUFFT_INVALID_DEVICE: + errstr = "Execution of a plan was on different GPU than plan creation"; + break; + case CUFFT_PARSE_ERROR: + errstr = "Internal plan database error"; + break; + case CUFFT_NO_WORKSPACE: + errstr = "No workspace has been provided prior to plan execution"; + break; + case CUFFT_NOT_IMPLEMENTED: + errstr = + "Function does not implement functionality for parameters given."; + break; + case CUFFT_LICENSE_ERROR: + errstr = "Used in previous versions."; + break; + case CUFFT_NOT_SUPPORTED: + errstr = "Operation is not supported for parameters given."; + break; + default: + errstr = "Unknown"; + } + + throw std::runtime_error(std::string("CuFFT Error: ") + + getloc(func, file, line) + + ": " + errstr); + } +} + +#define cudaCheck(e) \ + handleCudaCheck(e, __FUNCTION__, __FILE__, __LINE__) diff --git a/cufft/filtered_fft/filtered_fft.cu b/cufft/filtered_fft/filtered_fft.cu new file mode 100644 index 000000000..586d7f356 --- /dev/null +++ b/cufft/filtered_fft/filtered_fft.cu @@ -0,0 +1,322 @@ +/** Core implementation of the filtered FFT using cuFFT + callbacks. + * Note, this is a .cu file actually. The .cpp is used to make it work with cppimport + * + * The FilteredFFTImpl class is implemented as a template, + * to allow a specific implementation with compile-time constants + * as the offset modulo operations can by optimised a lot if the + * compiler knows the modulo operands. + * + * Therefore this code assumes that the following pre-processor + * definitions are defined during compilation - otherwise it will + * generate an FFT with 128x128 arrays: + * + * - MY_FFT_ROWS + * - MY_FFT_COLUMNS + * + * Also note that this implementation only works on Linux 64bit, + * as this is a limitation of cuFFT. + * On other platforms, an implementation with separately implemented + * filters should be used, e.g. with pycuda and scikit-cuda. + * + */ + +#include "errors.h" +#include "filtered_fft.h" + +#include +#include +#include +#include +#include + +template +class FilteredFFTImpl : public FilteredFFT { +public: + + /** Sets up the plan on init. + * + * @param batches Number of batches + * @param prefilt Device pointer to prefilter array (can be NULL) + * @param postfilt Device pointer to postfilter array (can be NULL) + * @param stream Stream to use for the GPU + */ + FilteredFFTImpl(int batches, + complex* prefilt, complex* postfilt, + cudaStream_t stream) : + batches_(batches), + prefilt_(prefilt), + postfilt_(postfilt), + stream_(stream) + { + setupPlan(); + } + + int getBatches() const override { return batches_; } + int getRows() const override { return ROWS; } + int getColumns() const override { return COLUMNS; } + bool isForward() const override { return IS_FORWARD; } + void setStream(cudaStream_t stream) override { + stream_ = stream; + cudaCheck(cufftSetStream(plan_, stream)); + }; + virtual cudaStream_t getStream() const { + return stream_; + } + + /// Run the FFT (forward) - can be in-place + void fft(complex* input, complex* output) override + { + if (SYMMETRIC && !IS_FORWARD) { + throw std::runtime_error("Calling FFT on a reverse-initialised instance"); + } else { + cudaCheck(cufftExecC2C(plan_, + reinterpret_cast(input), + reinterpret_cast(output), + CUFFT_FORWARD + )); + } + } + + /// Run the IFFT (reverse) - can be in-place + void ifft(complex* input, complex* output) override + { + if (SYMMETRIC && IS_FORWARD) { + throw std::runtime_error("Calling IFFT on a forward-initialised instance"); + } else { + cudaCheck(cufftExecC2C(plan_, + reinterpret_cast(input), + reinterpret_cast(output), + CUFFT_INVERSE + )); + } + } + + ~FilteredFFTImpl() + { + cufftDestroy(plan_); + } + + + ///////// Different variants of the callback device functions ///// + + /// load with prefilter + __device__ static cufftComplex CB_prefilt( + void *dataIn, + size_t offset, + void* callerInf, + void* sharedPtr + ) { + auto inData = reinterpret_cast*>(dataIn); + auto filter = reinterpret_cast*>(callerInf); + auto v = inData[offset]; + // Note: + // Modulo with powers of 2 are replaced by bit operations by the compiler, + // which are much faster. + // If non-powers of 2 are needed, it might be possible to work out the + // per-array filter offset from the threadIdx / blockidx fields. + v *= filter[offset % (ROWS*COLUMNS)]; + return {v.real(), v.imag()}; + } + + /// store with postfilter + scaling + __device__ static void CB_postfilt( + void* dataOut, + size_t offset, + cufftComplex element, + void* callerInf, + void* sharedPtr + ) { + auto outData = reinterpret_cast*>(dataOut); + auto filter = reinterpret_cast*>(callerInf); + auto v = complex(element.x, element.y); + if (!SYMMETRIC && !IS_FORWARD) { + v *= filter[offset % (ROWS*COLUMNS)] / (ROWS*COLUMNS); + } + else if (IS_FORWARD && !SYMMETRIC) { + v *= filter[offset % (ROWS*COLUMNS)]; + } + else { + float fact; + if (ROWS == COLUMNS) { + fact = ROWS; + } else { + fact = sqrt(float(ROWS*COLUMNS)); + } + v *= filter[offset % (ROWS*COLUMNS)] / fact; + } + outData[offset] = v; + } + + /// store with scaling only (no postfilter) + __device__ static void CB_postfilt_scaleonly( + void* dataOut, + size_t offset, + cufftComplex element, + void* callerInf, + void* sharedPtr + ) { + auto outData = reinterpret_cast*>(dataOut); + auto v = complex(element.x, element.y); + if (!SYMMETRIC && !IS_FORWARD) { + v /= ROWS * COLUMNS; + } else { + float fact; + if (ROWS == COLUMNS) { + fact = ROWS; + } else { + fact = sqrt(float(ROWS*COLUMNS)); + } + v /= fact; + } + outData[offset] = v; + } + + +private: + /// the core of the plan setup + void setupPlan(); + + int batches_; ///< number of batchs + cufftHandle plan_; ///< cuFFT plan handle + complex* prefilt_; ///< prefilter pointer + complex* postfilt_; ///< postfilter pointer + cudaStream_t stream_; ///< stream to operate on +}; + + +/// Device-globals to keep function pointers +/// These need to be set on the device, copied to host, +/// and then passed to the cuFFT plan. + +__device__ cufftCallbackLoadC d_loadCallbackPtr; +__device__ cufftCallbackStoreC d_storeCallbackPtr; + +/// small kernel to set the load callback device function pointer +template +__global__ void setLoadDevFunPtr() +{ + d_loadCallbackPtr = FilteredFFTImpl::CB_prefilt; +} + +/// small kernel to set the store callback device function pointer +template +__global__ void setStoreDevFunPtr() +{ + d_storeCallbackPtr = FilteredFFTImpl::CB_postfilt; +} + +/// small kernel to set the store callback device function pointer for scale only +template +__global__ void setStoreScaleDevFunPtr() +{ + d_storeCallbackPtr = FilteredFFTImpl::CB_postfilt_scaleonly; +} + + +/// setup the plan +template +void FilteredFFTImpl::setupPlan() { + // basic plan setup + cudaCheck(cufftCreate(&plan_)); + int dims[] = {ROWS, COLUMNS}; + size_t workSize; + cudaCheck(cufftMakePlanMany( + plan_, 2, dims, 0, 0, 0, 0, 0, 0, CUFFT_C2C, batches_, &workSize + )); + cudaCheck(cufftSetStream(plan_, stream_)); + + /* + std::cout << "Created plan for " << ROWS << "x" << COLUMNS + << ", for " << batches_ << " with scratch memory of " + << double(workSize) / 1024.0 / 1024.0 << "MB" + << std::endl; + */ + + // pre-filter + if (prefilt_) // no need to set load callback if we're not prefiltering + { + setLoadDevFunPtr<<<1,1>>>(); + cufftCallbackLoadC h_loadCallbackPtr; + cudaCheck(cudaMemcpyFromSymbol(&h_loadCallbackPtr, d_loadCallbackPtr, sizeof(h_loadCallbackPtr))); + cudaCheck(cufftXtSetCallback(plan_, + (void**)&h_loadCallbackPtr, + CUFFT_CB_LD_COMPLEX, + (void**)&prefilt_)); + } + + // post-filter + if (!(IS_FORWARD && !SYMMETRIC) || postfilt_) // we scale in postCall, so also needed if not postfiltering + { + cufftCallbackStoreC h_storeCallbackPtr; + if (postfilt_) { + setStoreDevFunPtr<<<1,1>>>(); + } + else { + setStoreScaleDevFunPtr<<<1,1>>>(); + } + cudaCheck(cudaMemcpyFromSymbol(&h_storeCallbackPtr, d_storeCallbackPtr, sizeof(h_storeCallbackPtr))); + cudaCheck(cufftXtSetCallback(plan_, + (void**)&h_storeCallbackPtr, + CUFFT_CB_ST_COMPLEX, + (void**)&postfilt_)); + } +} + +template +static FilteredFFT* make(int batches, int rows, int cols, complex* prefilt, complex* postfilt, + cudaStream_t stream) +{ + // we only support rows / colums are equal and powers of 2, from 16x16 to 512x512 + if (rows != cols) + throw std::runtime_error("Only equal numbers of rows and columns are supported"); + switch (rows) + { + case 16: return new FilteredFFTImpl<16, 16, SYMMETRIC, FORWARD>(batches, prefilt, postfilt, stream); + case 32: return new FilteredFFTImpl<32, 32, SYMMETRIC, FORWARD>(batches, prefilt, postfilt, stream); + case 64: return new FilteredFFTImpl<64, 64, SYMMETRIC, FORWARD>(batches, prefilt, postfilt, stream); + case 128: return new FilteredFFTImpl<128, 128, SYMMETRIC, FORWARD>(batches, prefilt, postfilt, stream); + case 256: return new FilteredFFTImpl<256, 256, SYMMETRIC, FORWARD>(batches, prefilt, postfilt, stream); + case 512: return new FilteredFFTImpl<512, 512, SYMMETRIC, FORWARD>(batches, prefilt, postfilt, stream); + case 1024: return new FilteredFFTImpl<1024, 1024, SYMMETRIC, FORWARD>(batches, prefilt, postfilt, stream); + case 2048: return new FilteredFFTImpl<2048, 2048, SYMMETRIC, FORWARD>(batches, prefilt, postfilt, stream); + default: throw std::runtime_error("Only powers of 2 from 16 to 2048 are supported"); + } +} + +//////////// Factory Functions for Python + +// Note: This will instantiate templates for 8 powers of 2, with 4 combinations of forward/reverse, symmetric/not, +// i.e. 32 different FFTs into the binary. Compile time might be quite long, but we intend to do this once +// during installation + +FilteredFFT* make_filtered( + int batches, + int rows, int cols, + bool symmetricScaling, + bool isForward, + complex* prefilt, complex* postfilt, + cudaStream_t stream) +{ + if (symmetricScaling) + { + if (isForward) { + return make(batches, rows, cols, prefilt, postfilt, stream); + } else { + return make(batches, rows, cols, prefilt, postfilt, stream); + } + } + else + { + if (isForward) { + return make(batches, rows, cols, prefilt, postfilt, stream); + } else { + return make(batches, rows, cols, prefilt, postfilt, stream); + } + } + +} + +void destroy_filtered(FilteredFFT* fft) +{ + delete fft; +} \ No newline at end of file diff --git a/cufft/filtered_fft/filtered_fft.h b/cufft/filtered_fft/filtered_fft.h new file mode 100644 index 000000000..9afa4e119 --- /dev/null +++ b/cufft/filtered_fft/filtered_fft.h @@ -0,0 +1,34 @@ +#pragma once + +#include +#include + +using thrust::complex; + +class FilteredFFT { +public: + virtual void fft(complex* input, complex* output) = 0; + virtual void ifft(complex* input, complex* output) = 0; + virtual int getBatches() const = 0; + virtual int getRows() const = 0; + virtual int getColumns() const = 0; + virtual bool isForward() const = 0; + virtual void setStream(cudaStream_t stream) = 0; + virtual cudaStream_t getStream() const = 0; + virtual ~FilteredFFT() {} +}; + +// we fix the rows/columns at compile-time, so not passing them +// to the factory here +// Note that cudaStream_t (runtime API) and CUStream (driver API) are +// the same type +FilteredFFT* make_filtered(int batches, + int rows, int columns, + bool symmetricScaling, + bool isForward, + complex* prefilt, complex* postfilt, + cudaStream_t stream); + +void destroy_filtered(FilteredFFT* fft); + + diff --git a/cufft/filtered_fft/module.cpp b/cufft/filtered_fft/module.cpp new file mode 100644 index 000000000..3eb0eb37e --- /dev/null +++ b/cufft/filtered_fft/module.cpp @@ -0,0 +1,102 @@ +#include +#include "filtered_fft.h" + + +/** Wrapper class to expose to Python, taking size_t instead of all + * the pointers, which should contain the addresses of the data. + * For gpuarrays, the gpuarray.gpudata member can be cast to int + * in Python and it will be the raw pointer address. + * cudaStreams can be cast to int as well. + * (this saves us a lot of type definition / conversion code with pybind11) + * + */ +class FilteredFFTPython +{ +public: + FilteredFFTPython(int batches, int rows, int columns, bool symmetric, + bool is_forward, + std::size_t prefilt_ptr, + std::size_t postfilt_ptr, + std::size_t stream) + { + fft_ = make_filtered( + batches, + rows, columns, + symmetric, + is_forward, + reinterpret_cast*>(prefilt_ptr), + reinterpret_cast*>(postfilt_ptr), + reinterpret_cast(stream) + ); + } + + int getBatches() const { return fft_->getBatches(); } + int getRows() const { return fft_->getRows(); } + int getColumns() const { return fft_->getColumns(); } + bool isForward() const { return fft_->isForward(); } + void setStream(std::size_t stream) { + fft_->setStream(reinterpret_cast(stream)); + } + std::size_t getStream() const { + return reinterpret_cast(fft_->getStream()); + } + + void fft(std::size_t in_ptr, std::size_t out_ptr) + { + fft_->fft( + reinterpret_cast*>(in_ptr), + reinterpret_cast*>(out_ptr) + ); + } + + void ifft(std::size_t in_ptr, std::size_t out_ptr) + { + fft_->ifft( + reinterpret_cast*>(in_ptr), + reinterpret_cast*>(out_ptr) + ); + } + + ~FilteredFFTPython() { + delete fft_; + } + +private: + FilteredFFT* fft_; +}; + + +/////////////// Pybind11 Export Definition /////////////// + +namespace py = pybind11; + + +PYBIND11_MODULE(filtered_cufft, m) { + m.doc() = "Filtered FFT for PtyPy"; + + py::class_(m, "FilteredFFT", py::module_local()) + .def(py::init(), + py::arg("batches"), + py::arg("rows"), + py::arg("columns"), + py::arg("symmetricScaling"), + py::arg("is_forward"), + py::arg("prefilt"), + py::arg("postfilt"), + py::arg("stream") + ) + .def("fft", &FilteredFFTPython::fft, + py::arg("input_ptr"), + py::arg("output_ptr") + ) + .def("ifft", &FilteredFFTPython::ifft, + py::arg("input_ptr"), + py::arg("output_ptr") + ) + .def_property_readonly("batches", &FilteredFFTPython::getBatches) + .def_property_readonly("rows", &FilteredFFTPython::getRows) + .def_property_readonly("columns", &FilteredFFTPython::getColumns) + .def_property_readonly("is_forward", &FilteredFFTPython::isForward) + .def_property("queue", &FilteredFFTPython::getStream, &FilteredFFTPython::setStream); +} + diff --git a/cufft/filtered_fft/smoke_test.cpp b/cufft/filtered_fft/smoke_test.cpp new file mode 100644 index 000000000..c1980a565 --- /dev/null +++ b/cufft/filtered_fft/smoke_test.cpp @@ -0,0 +1,65 @@ +#include "errors.h" +#include "filtered_fft.h" +#include +#include +#include + +#ifndef MY_FFT_ROWS +# define MY_FFT_ROWS 128 +# pragma GCC warning "MY_FFT_ROWS not set in preprocessor - defaulting to 128" +#endif + +#ifndef MY_FFT_COLS +# define MY_FFT_COLS 128 +# pragma GCC warning "MY_FFT_COLS not set in preprocessor - defaulting to 128" +#endif + + +///////////////// a quick smoke test +int main() { + cudaStream_t stream; + cudaCheck(cudaStreamCreate(&stream)); + + int batches = 2000; + int rows = MY_FFT_ROWS; + int cols = MY_FFT_COLS; + complex *pre, *post, *f; + cudaCheck(cudaMalloc((void**)&pre, rows*cols*sizeof(complex))); + cudaCheck(cudaMalloc((void**)&post, rows*cols*sizeof(complex))); + cudaCheck(cudaMalloc((void**)&f, batches*rows*cols*sizeof(complex))); + + auto fft = make_filtered(batches, true, true, pre, post, stream); + + if (rows != fft->getRows() || cols != fft->getColumns()) + throw std::runtime_error("Mismatch in rows/cols between smoke test and module"); + + cudaCheck(cudaDeviceSynchronize()); + auto start = std::chrono::high_resolution_clock::now(); + for (int i = 0; i < 100; ++i) + fft->fft(f, f); + cudaCheck(cudaDeviceSynchronize()); + auto end = std::chrono::high_resolution_clock::now(); + std::cout << "FFT " << batches << "x" << rows << "x" << cols << + ": " << std::chrono::duration_cast(end-start).count() << "ms\n"; + + auto ifft = make_filtered(batches, true, false, pre, post, stream); + + cudaCheck(cudaDeviceSynchronize()); + auto start2 = std::chrono::high_resolution_clock::now(); + for (int i = 0; i < 100; ++i) + ifft->ifft(f, f); + cudaCheck(cudaDeviceSynchronize()); + auto end2 = std::chrono::high_resolution_clock::now(); + std::cout << "IFFT " << batches << "x" << rows << "x" << cols << + ": " << std::chrono::duration_cast(end2-start2).count() << "ms\n"; + + std::cout << "Done\n"; + + destroy_filtered(fft); + destroy_filtered(ifft); + + cudaStreamDestroy(stream); + cudaFree(pre); + cudaFree(post); + cudaFree(f); +} diff --git a/cufft/filtered_fft/test_Makefile b/cufft/filtered_fft/test_Makefile new file mode 100644 index 000000000..f595b5c47 --- /dev/null +++ b/cufft/filtered_fft/test_Makefile @@ -0,0 +1,43 @@ +NVCC = nvcc +NVCC_FLAGS += -dc -arch=sm_60 \ + -gencode=arch=compute_30,code=sm_30 \ + -gencode=arch=compute_50,code=sm_50 \ + -gencode=arch=compute_52,code=sm_52 \ + -gencode=arch=compute_60,code=sm_60 \ + -gencode=arch=compute_61,code=sm_61 \ + -gencode=arch=compute_70,code=sm_70 \ + -gencode=arch=compute_70,code=compute_70 +CUDADIR = $(dir $(shell which nvcc) )/.. + +INCLUDES = $(shell python -m pybind11 --includes) -I$(CUDADIR)/include +PYMODEXT = $(shell python-config --extension-suffix) +CPPFLAGS += -DMY_FFT_ROWS=128 -DMY_FFT_COLS=128 $(INCLUDES) +OPTFLAGS = -O3 -std=c++14 +CXXFLAGS += -fPIC +LD_FLAGS += -L$(CUDADIR)/lib64 -lcufft_static -lculibos -cudart shared -ldl -lrt -lpthread +OBJ = filtered_fft.o +OBJ_MOD = module.o +OBJ_EXE = smoke_test.o +MODULE = filtered_fft$(PYMODEXT) +EXE = smoke_test + +all: $(MODULE) $(EXE) + +python: $(MODULE) + +clean: + rm -rf $(OBJ) $(EXE) $(MODULE) $(OBJ_EXE) $(OBJ_MOD) + +%.o: %.cu + $(NVCC) $(NVCC_FLAGS) $(OPTFLAGS) -Xcompiler "$(CXXFLAGS)" $(CPPFLAGS) -c $< -o $@ + +%.o: %.cpp + $(NVCC) $(NVCC_FLAGS) -x cu $(OPTFLAGS) -Xcompiler "$(CXXFLAGS)" $(CPPFLAGS) -c $< -o $@ + +$(MODULE): $(OBJ) $(OBJ_MOD) + $(NVCC) $(OPTFLAGS) -shared $(LD_FLAGS) $(OBJ) $(OBJ_MOD) -o $@ + +$(EXE): $(OBJ) $(OBJ_EXE) + $(NVCC) $(OPTFLAGS) -o $@ $(LD_FLAGS) $(OBJ) $(OBJ_EXE) + +$(OBJ) $(OBJ_EXE) $(OBJ_MOD): errors.h filtered_fft.h \ No newline at end of file diff --git a/cufft/setup.py b/cufft/setup.py new file mode 100644 index 000000000..8cba2f560 --- /dev/null +++ b/cufft/setup.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python + +# we should aim to remove the distutils dependency +import setuptools +from distutils.core import setup, Extension +import os + +ext_modules = [] +cmdclass = {} +# filtered Cuda FFT extension module +try: + from extensions import locate_cuda, get_cuda_version # this raises an error if pybind11 is not available + CUDA = locate_cuda() # this raises an error if CUDA is not available + CUDA_VERSION = get_cuda_version(CUDA['nvcc']) + if CUDA_VERSION < 10: + raise ValueError("filtered cufft requires CUDA >= 10") + from extensions import CustomBuildExt + cufft_dir = "filtered_fft" + ext_modules.append( + Extension("filtered_cufft", + sources=[os.path.join(cufft_dir, "module.cpp"), + os.path.join(cufft_dir, "filtered_fft.cu")] + ) + ) + cmdclass = {"build_ext": CustomBuildExt} + EXTBUILD_MESSAGE = "The filtered cufft extension has been successfully installed.\n" +except: + EXTBUILD_MESSAGE = '*' * 75 + "\n" + EXTBUILD_MESSAGE += "Could not install the filtered cufft extension.\n" + EXTBUILD_MESSAGE += "Make sure to have CUDA >= 10 and pybind11 installed.\n" + EXTBUILD_MESSAGE += '*' * 75 + "\n" + +exclude_packages = [] +package_list = setuptools.find_packages(exclude=exclude_packages) +setup( + name='filtered cufft', + version=0.1, + author='Bjoern Enders, Benedikt Daurer, Joerg Lotze', + description='Extension of CuFFT to include pre- and post-filters using callbacks', + packages=package_list, + ext_modules=ext_modules, + cmdclass=cmdclass +) + +print(EXTBUILD_MESSAGE) diff --git a/core_dependencies.yml b/dependencies_core.yml similarity index 63% rename from core_dependencies.yml rename to dependencies_core.yml index 2a449e8bf..32c492de1 100644 --- a/core_dependencies.yml +++ b/dependencies_core.yml @@ -1,8 +1,9 @@ -name: core_dependencies +name: ptypy_core channels: - conda-forge dependencies: - - python=3.7 + - python=3.9 - numpy - scipy - h5py + - pip \ No newline at end of file diff --git a/ptypy_full_dependencies.yml b/dependencies_dev.yml similarity index 76% rename from ptypy_full_dependencies.yml rename to dependencies_dev.yml index 9def5e284..230a7e190 100644 --- a/ptypy_full_dependencies.yml +++ b/dependencies_dev.yml @@ -1,8 +1,8 @@ -name: ptypy_full_dependencies +name: ptypy_full channels: - conda-forge dependencies: - - python=3.7 + - python=3.9 - numpy - scipy - matplotlib @@ -16,4 +16,3 @@ dependencies: - pip: - pytest-cov - coveralls - - fabio diff --git a/dependencies_full.yml b/dependencies_full.yml new file mode 100644 index 000000000..00ff5a4af --- /dev/null +++ b/dependencies_full.yml @@ -0,0 +1,15 @@ +name: ptypy_full +channels: + - conda-forge +dependencies: + - python=3.9 + - numpy + - scipy + - matplotlib + - h5py + - pyzmq + - mpi4py + - pillow + - pyfftw + - pip + diff --git a/doc/conf.py b/doc/conf.py index 3f345e5ee..64ad9fc0c 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -25,7 +25,7 @@ subprocess.check_call(['python', 'script2rst.py']) # We need this to have a clean sys.argv subprocess.check_call(['python', 'parameters2rst.py']) subprocess.check_call(['python', 'tmp2rst.py']) -exec(open('version.py').read()) +exec(open('../ptypy/version.py').read()) # -- General configuration ------------------------------------------------ @@ -99,7 +99,7 @@ def get_refs(dct, pd, depth=2, indent=''): def setup(app): app.connect('autodoc-process-docstring', remove_mod_docstring) app.connect('autodoc-process-docstring', truncate_docstring) - + pass napoleon_use_ivar = True napoleon_include_special_with_doc = True @@ -128,9 +128,9 @@ def setup(app): # built documents. # # The short X.Y version. -version = version #'0.0.1' +version = version #'0.0.1' # noqa: F821 # The full version, including alpha/beta/rc tags. -release = short_version #'0.0.1' +release = short_version #'0.0.1' # noqa: F821 # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. @@ -182,7 +182,7 @@ def setup(app): # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. -html_theme = 'ptypysphinx'#'sphinxdoc'#'classic'#'scrolls' #'sphinxdoc' #'alabaster' +html_theme = 'ptypysphinx'#'sphinxdoc'#'classic'#'scrolls' #'sphinxdoc' #'alabaster' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the @@ -190,7 +190,7 @@ def setup(app): html_theme_options = {'sidebarwidth':'280'} # Add any paths that contain custom themes here, relative to this directory. -html_theme_path = ['html_templates'] +html_theme_path = ['html_templates'] #, '../../../anaconda3/envs/ptypy/lib/python3.7/site-packages/sphinx/themes'] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". @@ -211,7 +211,7 @@ def setup(app): # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ['_static'] +#html_static_path = ['_static'] # Add any extra paths that contain custom files (such as robots.txt or # .htaccess) here, relative to this directory. These files are copied diff --git a/doc/html_templates/ptypysphinx/download.html b/doc/html_templates/ptypysphinx/download.html index a91d599cb..0bdeb6e70 100644 --- a/doc/html_templates/ptypysphinx/download.html +++ b/doc/html_templates/ptypysphinx/download.html @@ -6,15 +6,16 @@
  • Download TAR Ball
    • + + +unpack and follow the step-by-step installation instructions. - - +

    Support

    If you are having trouble getting ptypy up und running please let us know ( diff --git a/doc/html_templates/ptypysphinx/layout.html b/doc/html_templates/ptypysphinx/layout.html index cf2a29ef6..b490bed96 100644 --- a/doc/html_templates/ptypysphinx/layout.html +++ b/doc/html_templates/ptypysphinx/layout.html @@ -1,4 +1,4 @@ -{% extends "!layout.html" %} +{% extends "!basic/layout.html" %} {# load free fonts #} {% block extrahead %} diff --git a/doc/html_templates/ptypysphinx/static/header.css_t b/doc/html_templates/ptypysphinx/static/header.css_t index bb2670a77..19c2a442b 100644 --- a/doc/html_templates/ptypysphinx/static/header.css_t +++ b/doc/html_templates/ptypysphinx/static/header.css_t @@ -115,8 +115,14 @@ div.related ul li a { } div.sphinxsidebar { - width: {{ theme_sidebarwidth|toint - 20 }}px; } +pre { + background-color: #f8f8f8; +} + +.highlight .hll { + display: unset; +} diff --git a/doc/index.rst b/doc/index.rst index bc755bc01..c99c71264 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -5,7 +5,7 @@ Welcome Ptychonaut! framework for scientific ptychography compiled by P.Thibault and B. Enders and licensed under the GPLv2 license. -It comprises 7 years of experience in the field of ptychography condensed +It comprises 8 years of experience in the field of ptychography condensed to a versatile python package. The package covers the whole path of ptychographic analysis after the actual experiment - from data management to reconstruction to visualization. @@ -25,14 +25,17 @@ Get started quickly :ref:`here ` or with one of the examples in Highlights ---------- -* **Difference Map** [#dm]_ algorithm engine with power bound constraint +* **Difference Map** [#dm]_ algorithm engine with power bound constraint [#power]_. * **Maximum Likelihood** [#ml]_ engine with preconditioners and regularizers. +* A few more engines (RAAR, sDR, ePIE, ...). -* **Fully parallelized** (CPU only) using the Massage Passing Interface +* **Fully parallelized** using the Massage Passing Interface (`MPI `_). Simply execute your script with:: - $ mpiexec -n [nodes] python .py + $ mpiexec/mpirun -n [nodes] python .py + +* **GPU acceleration** based on custom kernels, pycuda, and reikna. * A **client-server** approach for visualization and control based on `ZeroMQ `_ . @@ -72,6 +75,9 @@ Quicklinks .. [#Thi2013] P.Thibault and A.Menzel, **Nature** 494, 68 (2013), `doi `__ -.. [#ml] P.Thibault and M.Guizar-Sicairos, **New J. of Phys.** 14, 6 (2012), `doi `__ +.. [#ml] P.Thibault and M.Guizar-Sicairos, **New J. of Phys. 14**, 6 (2012), `doi `__ + +.. [#dm] P.Thibault, M.Dierolf *et al.*, **Ultramicroscopy 109**, 4 (2009), `doi `__ + +.. [#power] K.Giewekemeyer *et al.*, **PNAS 108**, 2 (2007), `suppl. material `__, `doi `__ -.. [#dm] P.Thibault, M.Dierolf *et al.*, **New J. of Phys. 14**, 6 (2012), `doi `__ diff --git a/doc/parameters2rst.py b/doc/parameters2rst.py index be8928777..8058e6a96 100644 --- a/doc/parameters2rst.py +++ b/doc/parameters2rst.py @@ -1,61 +1,139 @@ from ptypy import defaults_tree -prst = open('rst/parameters.rst','w') -Header= '.. _parameters:\n\n' -Header+= '************************\n' -Header+= 'Parameter tree structure\n' -Header+= '************************\n\n' -prst.write(Header) +def write_desc_recursive(prst, tree): + for path, desc in tree.children.items(): + print(path) + types = desc.type + default = desc.default + lowlim, uplim = desc.limits + is_wildcard = (desc.name == '*') + + if is_wildcard: + path = path.replace('*', desc.parent.name[:-1] + '_00') + + if path == '': + continue + + if desc.children or desc.is_symlink: + if desc.parent is desc.root: + prst.write('\n' + path + '\n') + prst.write('=' * len(path) + '\n\n') + if desc.parent.parent is desc.root: + prst.write('\n' + path + '\n') + prst.write('-' * len(path) + '\n\n') + + prst.write('.. py:data:: ' + path) + + if desc.is_symlink: + tp = 'Param' + else: + tp = ', '.join([str(t) for t in types]) + prst.write(' (' + tp + ')') + prst.write('\n\n') -for path, desc in defaults_tree.descendants: - - types = desc.type - default = desc.default - lowlim, uplim = desc.limits - is_wildcard = (desc.name == '*') - - if is_wildcard: - path = path.replace('*', desc.parent.name[:-1] + '_00') - - if path == '': - continue - if desc.children and desc.parent is desc.root: - prst.write('\n'+path+'\n') - prst.write('='*len(path)+'\n\n') - if desc.children and desc.parent.parent is desc.root: - prst.write('\n'+path+'\n') - prst.write('-'*len(path)+'\n\n') - - prst.write('.. py:data:: '+path) - - if desc.is_symlink: - tp = 'Param' - else: - tp = ', '.join([str(t) for t in types]) - prst.write(' ('+tp+')') - prst.write('\n\n') - - if is_wildcard: - prst.write(' *Wildcard*: multiple entries with arbitrary names are accepted.\n\n') - - # prst.write(' '+desc.help+'\n\n') - prst.write(' ' + desc.help.replace('', '\n').replace('\n', '\n ') + '\n\n') - prst.write(' '+desc.doc.replace('','\n').replace('\n', '\n ')+'\n\n') - - if desc.is_symlink: - prst.write(' *default* = '+':py:data:`'+desc.path+'`\n') - else: - prst.write(' *default* = ``'+repr(default)) - if lowlim is not None and uplim is not None: - prst.write(' (>'+str(lowlim)+', <'+str(uplim)+')``\n') - elif lowlim is not None and uplim is None: - prst.write(' (>'+str(lowlim)+')``\n') - elif lowlim is None and uplim is not None: - prst.write(' (<'+str(uplim)+')``\n') + if is_wildcard: + prst.write(' *Wildcard*: multiple entries with arbitrary names are accepted.\n\n') + + # prst.write(' '+desc.help+'\n\n') + prst.write(' ' + desc.help.replace('', '\n').replace('\n', '\n ') + '\n\n') + prst.write(' ' + desc.doc.replace('', '\n').replace('\n', '\n ') + '\n\n') + + if desc.children: + print('recursion ' + path) + prst.write('\n') + write_desc_recursive(prst, desc) + elif desc.is_symlink: + print('following symlink ' + path) + prst.write('\n') + write_desc_recursive(prst, desc.type[0]) else: - prst.write('``\n') - - prst.write('\n') + prst.write(' *default* = ``' + repr(default)) + if lowlim is not None and uplim is not None: + prst.write(' (>' + str(lowlim) + ', <' + str(uplim) + ')``\n') + elif lowlim is not None and uplim is None: + prst.write(' (>' + str(lowlim) + ')``\n') + elif lowlim is None and uplim is not None: + prst.write(' (<' + str(uplim) + ')``\n') + else: + prst.write('``\n') + + prst.write('\n') + + +def write_desc_tree(prst, tree): + for path, desc in tree.descendants: + + types = desc.type + default = desc.default + lowlim, uplim = desc.limits + is_wildcard = (desc.name == '*') + + if is_wildcard: + path = path.replace('*', desc.parent.name[:-1] + '_00') + + if path == '': + continue + if desc.children and desc.parent is desc.root: + prst.write('\n' + path + '\n') + prst.write('=' * len(path) + '\n\n') + if desc.children and desc.parent.parent is desc.root: + prst.write('\n' + path + '\n') + prst.write('-' * len(path) + '\n\n') + + prst.write('.. py:data:: ' + path) + + if desc.is_symlink: + tp = 'Param' + else: + tp = ', '.join([str(t) for t in types]) + prst.write(' (' + tp + ')') + prst.write('\n\n') + + if is_wildcard: + prst.write(' *Wildcard*: multiple entries with arbitrary names are accepted.\n\n') + + # prst.write(' '+desc.help+'\n\n') + prst.write(' ' + desc.help.replace('', '\n').replace('\n', '\n ') + '\n\n') + prst.write(' ' + desc.doc.replace('', '\n').replace('\n', '\n ') + '\n\n') + + if desc.is_symlink: + prst.write(' *default* = ' + ':py:data:`' + desc.type[0].path + '`\n') + else: + prst.write(' *default* = ``' + repr(default)) + if lowlim is not None and uplim is not None: + prst.write(' (>' + str(lowlim) + ', <' + str(uplim) + ')``\n') + elif lowlim is not None and uplim is None: + prst.write(' (>' + str(lowlim) + ')``\n') + elif lowlim is None and uplim is not None: + prst.write(' (<' + str(uplim) + ')``\n') + else: + prst.write('``\n') + + prst.write('\n') + + +prst = open('rst/parameters.rst','w') + +Header = """\ +.. _parameters: + +************************ +Parameter tree structure +************************ + +.. note:: + This section needs to be reworked to account for the + recursive nature for |ptypy|_'s parameter tree. + Please use the examples in the templates folder to + craft your own scripts. +""" + +prst.write(Header) +write_desc_tree(prst, defaults_tree) +# write_desc_recursive(prst, defaults_tree['ptycho']) +# write_desc_tree(prst, defaults_tree['io']) +# write_desc_tree(prst, defaults_tree['scan']) +# write_desc_tree(prst, defaults_tree['scandata']) prst.close() diff --git a/doc/rst/ptypy.engines.rst b/doc/rst/ptypy.engines.rst index 0ff64b012..0e4128c3d 100644 --- a/doc/rst/ptypy.engines.rst +++ b/doc/rst/ptypy.engines.rst @@ -4,10 +4,10 @@ ptypy.engines package Submodules ---------- -ptypy.engines.DM module ------------------------ +ptypy.engines.projectional module +--------------------------------- -.. automodule:: ptypy.engines.DM +.. automodule:: ptypy.engines.projectional :members: :undoc-members: :show-inheritance: @@ -21,6 +21,14 @@ ptypy.engines.ML module :undoc-members: :show-inheritance: +ptypy.engines.stochastic module +------------------------------- + +.. automodule:: ptypy.engines.stochastic + :members: + :undoc-members: + :show-inheritance: + ptypy.engines.base module ------------------------- diff --git a/doc/rst/ptypy.experiment.rst b/doc/rst/ptypy.experiment.rst index 40e4ca02a..fef2a7ded 100644 --- a/doc/rst/ptypy.experiment.rst +++ b/doc/rst/ptypy.experiment.rst @@ -12,6 +12,14 @@ ptypy.experiment.ID16Anfp module :undoc-members: :show-inheritance: +ptypy.experiment.hdf5_loader module +----------------------------------- + +.. automodule:: ptypy.experiment.hdf5_loader + :members: + :undoc-members: + :show-inheritance: + ptypy.experiment.optiklabor module ---------------------------------- diff --git a/doc/rst_templates/getting_started.tmp b/doc/rst_templates/getting_started.tmp index 0b5d7850e..db4a6a19c 100644 --- a/doc/rst_templates/getting_started.tmp +++ b/doc/rst_templates/getting_started.tmp @@ -12,42 +12,65 @@ Installation General installation instructions --------------------------------- -Being a python package, |ptypy|_ depends on a number of other -packages which are listed below. -Once its dependecies are met, ptypy should work *out-of-the-box*. +Download and unpack |ptypy|_ from the sources. For example, on Linux +systems you can do:: -.. note:: - |ptypy| is developed for Python 2.7.x and is currently incompatible - with Python 3.x. Python 3 support is planned in future releases. - + $ wget https://github.com/ptycho/ptypy/archive/master.zip + $ unzip master.zip -d /tmp/; rm master.zip + +or make a clone of the |ptypy|_ github repository:: + + $ git clone https://github.com/ptycho/ptypy.git /tmp/ptypy-master + +which will unpack the master branch of ptypy into `/tmp/ptypy-master` but +you are of course free to place the software wherever it is convenient for you. +In principle, next you only have to navigate to that directory and install with +:: + + $ pip install . + +However, since |ptypy|_ depends on a number of other packages, we recommend +installing it in a virtual environment using the +`anaconda `_ package manager. Conveniently, this +installation route allows you to install |ptypy|_ across platforms. -Essential packages -^^^^^^^^^^^^^^^^^^ -* `NumPy `_ +Essential install +^^^^^^^^^^^^^^^^^ + +Only three Python packages are essential for |ptypy|_ to work: + +* `NumPy `_ (homepage: ``_) -* `SciPy `_ +* `SciPy `_ (homepage: ``_) -* `h5py `_ +* `h5py `_ (homepage: ``_) -Recommended packages for additional functionality -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Please note that |ptypy| is an alpha release and lacks rigorous import +Install the essential version like so +:: + + $ conda env create -f dependencies_core.yml + $ conda activate ptypy_core + (ptypy_core)$ pip install . + + +Recommended install for additional functionality +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Please note that |ptypy|_ is an alpha release and lacks rigorous import checking. There may be parts of code that implicitly ask for any of the packages listed here. Therefore, we recommend to install these packages. -* `Matplotlib `_ +* `Matplotlib `_ for any kind of plotting or image generation - (homepage: ``_) and python bindings for - `QT4 `_ + (homepage: ``_) -* `mpi4py `_ - for CPU-node parallelisation, contains python bindings for the +* `mpi4py `_ + for CPU-node parallelization, contains python bindings for the `Message Passaging Interface `_, (homepage: ``_) -* `pyzmq `_ +* `pyzmq `_ for a threaded server on the main node to perfrom asynchronous client-server communication, contains python bindings for the ZeroMQ protocol, @@ -55,139 +78,48 @@ packages listed here. Therefore, we recommend to install these packages. This package is needed for non-blocking plots of the reconstruction run (e.g. for :ref:`plotclient`). -Optional packages -^^^^^^^^^^^^^^^^^ -Other very useful packages are - -* `Ipython `_ - (homepage: ``_) - -Installation on Debian/Ubuntu ------------------------------ -|ptypy| is developed on the current LTS version of Ubuntu which is the -recommended operating system for |ptypy| - -Prerequisites -^^^^^^^^^^^^^ -Many of the required python packages are -available in the repositories. Just type (with sudo rights) +Install the recommended version like so :: - $ sudo apt-get install python-numpy python-scipy python-h5py\ - $ python-matplotlib python-mpi4py python-pyzmq + $ conda env create -f dependencies_full.yml + $ conda activate ptypy_full + (ptypy_full)$ pip install . -Get ptypy -^^^^^^^^^ -Download and unpack |ptypy|_ from the sources:: - $ wget https://github.com/ptycho/ptypy/archive/master.zip - $ unzip master.zip -d /tmp/; rm master.zip +Recommended install for GPU support +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -or make a clone of the |ptypy|_ github repository:: - - $ git clone https://github.com/ptycho/ptypy.git /tmp/ptypy-master +We support an accelerated version of |ptypy|_ for CUDA-capable +GPUs based on our own kernels and the +`PyCUDA `_ package. -CD into the download directory (e.g. /tmp/ptypy-master) and install |ptypy| with +Install the dependencies for this version like so. :: - $ python setup.py install --user + $ conda env create -f accelerate/cuda_pycuda/dependencies.yml + $ conda activate ptypy_pycuda + (ptypy_pycuda)$ pip install . -The local ``--user`` install is recommended instead of a system-wide -``sudo`` install. It makes it easier to quickly apply fixes yourself. -However, for an all-user system-wide install, type + +While we use `Reikna `_ to +provide a filtered FFT, i.e. a FFT that is fused with a pointwise +matrix multiplication, you can optionally also install a version +based on cufft and callbacks. Due to the nature of this extension it +needs to be built for fixed array sizes externally. :: - $ sudo python setup.py install + $ conda activate ptypy_pycuda + (ptypy_pycuda)$ cd cufft + (ptypy_pycuda)$ conda env update --file dependencies.yml --name ptypy_pycuda + (ptypy_pycuda)$ pip install . -Installation on Windows ------------------------ -These installation instructions were contributed by M. Stockmar and tested -with *Windows 8.1 Enterprise (64 bit)* on a core i7 Thinkpad w520 -in February 2015. -No python was installed before on that machine. +Optional packages +^^^^^^^^^^^^^^^^^ +Other very useful packages are -.. note:: - There might be also simpler ways to get a full scientific python - suite for 32 bit Windows. Please let us know if you managed to get - |ptypy|_ running on a system not listed here. - -Prerequisites -^^^^^^^^^^^^^ - -* Download and install python 2.7.x from ``_ - (Make sure you have the 64 bit version) - Click *yes* when asked to add python to the path environment variable. - -* Go to the command line and install wheel:: - - $ pip install wheel - -* Install Microsoft's implementation for MPI to use multiple CPUs from - ``_ - Other MPI implementations may work as well but were not tested. - -* Install the QT-Framework if you don't have it already. - ``_ - - -Download all other binaries -^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -The binaries will be downloaded from a `website `_ -which offers various builds for different python versions for Windows (both 32 and 64 bit) in -the form of a `python wheel `_. -Make sure you choose the correct version for your windows and system. - -Numpy and some other builds are linked against the -Intel Math Kernel Library (MKL) which is supposed to be fast. - -* First make sure you have the Microsoft Visual C++ 2010 redistributable package (maybe also the 2008 version). - - * | 2010 (64 bit, for 32 bit version check the website): - | ``_ - * | 2008 (64 bit, for 32 bit check the website): - | ``_ - -* Now, go to to ``_ - and download the latest pip binaries and update pip:: - - $ python.exe pip-6.0.8-py2.py3-none-any.whl/pip install pip-6.0.8-py2.py3-none-any.whl. - - (The file name might change slightly if a newer version of pip is available) - -* Then download all the other binaries as whl-files. - A whl-file can be installed via command line according to:: - - $ pip install filename.whl - - Download and install the binaries in the following order: - - #. ``numpy`` - #. ``pillow`` (replacement for PIL) - #. ``matplotlib`` - #. ``ipython`` - #. ``h5py`` - #. ``scipy`` (may install additional packages as well) - #. ``mpi4py`` (choose the one for MS MPI if you have installed MS MPI) - #. ``pyzmq`` - #. ``pyqt4`` (QT framework was installed before on the testing machine) - #. ``pyside`` - -.. - pip install pyqt4 (QT framework was installed before on the testing machine) - pip install pyside - - In case these instructions are not sufficient, refer to the website by C. Gohlke. - -Get ptypy -^^^^^^^^^ -Download |ptypy| from ``_ -and unzip to any directory, for example ``C:\Temp``. -Change into that directly and install from commandline:: - - $ cd C:\Temp\ptypy-master - $ python setup.py install +* `Ipython `_ + (homepage: ``_) .. _quickstart: @@ -205,8 +137,7 @@ Utilies/Binaries for convenience |ptypy| provides a few utility scripts to make life easier for you, the user. They are located in ``[ptypy_root]/scripts``. -In case of a user install on -Ubuntu Linux, they are copied to ``~/.local/bin`` +In case of an install with conda, these are copied to ``/bin`` .. note:: Due to the early stage of developmnet, @@ -248,13 +179,14 @@ that was created by |ptypy|. For such cases, we can use ``ptypy.inspect``. For example, a quick view at the top level can be realized with :: - $ ptypy.inspect /tmp/ptypy/recons/minimal/minimal_DM.ptyr -d 1 + $ ptypy.inspect /tmp/ptypy/recons/minimal/minimal_DM_0040.ptyr -d 1 which has the following the output:: - * content [Param 4]: + * content [Param 5]: * obj [dict 1]: * pars [Param 9]: + * positions [dict 1]: * probe [dict 1]: * runtime [Param 8]: * header [dict 2]: @@ -267,20 +199,27 @@ If we are interested solely in the probe we could use :: which has the following the output:: - * S00G00 [dict 13]: - * DataTooSmall [scalar = False] - * ID [string = "S00G00"] - * _center [array = [64 64]] - * _origin [array = [ -4.07172778e-06 -4.07172778e-06]] - * _pool [Param 0]: - * _psize [array = [ 6.36207466e-08 6.36207466e-08]] - * data [1x128x128 complex64 array] - * fill_value [scalar = 0.0] - * layermap [list = [0]] - * model_initialized [scalar = True] - * nlayers [scalar = 1] - * padonly [scalar = False] - * shape [tuple = (1, 128, 128)] + * SMF [dict 20]: + * DataTooSmall [scalar = False] + * ID [string = "SMF"] + * _center [array = [64. 64.]] + * _energy [scalar = 7.2] + * _origin [array = [-3.59918584e-06 -3.59918584e-06]] + * _pool [dict 0]: + * _psize [array = [5.62372787e-08 5.62372787e-08]] + * _record [scalar = (b'SMF',)] + * _recs [dict 0]: + * data [1x128x128 complex64 array] + * distributed [scalar = False] + * fill_value [scalar = 0.0] + * grids [tuple = 2x[1x128x128 float64 array]] + * layermap [list = [0]] + * model_initialized [scalar = True] + * nlayers [scalar = 1] + * numID [scalar = 1] + * padding [scalar = 0] + * padonly [scalar = False] + * shape [tuple = (1, 128, 128)] We omitted the result for the complete file to save some space but you are encouraged to try:: @@ -292,26 +231,8 @@ are encouraged to try:: Create a new template for a reconstruction script ------------------------------------------------- -In cases where we want to create a new reconstruction script from scratch, -it may be cumbersome to write each and every parameter that we want to -change. But, with the help of ``ptypy.new``, we can create a python -script which is prefilled with defaults:: - - $ ptypy.new [-h] [-u ULEVEL] [--short-doc] [--long-doc] pyfile - -In the folder ``[ptypy_root]/templates`` you find two scripts -that where auto-generated with the following calls:: - - $ ptypy.new -u 0 --long-doc pars_few_alldoc.py - $ ptypy.new -u 2 pars_all_nodoc.py - -And here is a quick view of the first one with much documentation -(only the first 50 lines). +[WIP] Due to wildcards and links in the parameter tree, this section will be reworked. -.. literalinclude:: ../../templates/pars_few_alldoc.py - :language: python - :linenos: - :lines: 1-50 .. _plotclient: @@ -341,29 +262,29 @@ you can temper with. All-in-one ---------- -We encourage you to use the script ``[ptypy_root]/templates/minimal_prep_and_run.py`` +We encourage you to use the script ``[ptypy_root]/templates/ptypy_minimal_prep_and_run.py`` and modify the *recipe* part of the data parameter branch. Observe what changes in the reconstruction when scan parameters change. -.. literalinclude:: ../../templates/minimal_prep_and_run.py +.. literalinclude:: ../../templates/ptypy_minimal_prep_and_run.py :language: python :linenos: - :emphasize-lines: 31,33,35 + :emphasize-lines: 41,43,45 Creating a .ptyd data-file -------------------------- -We encourage you to use this script ``[ptypy_root]/templates/make_sample_ptyd.py`` +We encourage you to use this script ``[ptypy_root]/templates/ptypy_make_sample_ptyd.py`` to create various different samples and see what happens if the data processing parameters are changed. If you have become curious, move -forward to :ref:`ptypy_data` and take a look at |ptypy|'s data management. +forward to :ref:`ptypy_data` and take a look at |ptypy|_'s data management. Check out the data parameter branch :py:data:`.scan.data` for detailed parameter descriptions. -.. literalinclude:: ../../templates/make_sample_ptyd.py +.. literalinclude:: ../../templates/ptypy_make_sample_ptyd.py :language: python :linenos: - :emphasize-lines: 15-26 + :emphasize-lines: 12-19 Loading a data file to run a reconstruction ------------------------------------------- @@ -375,6 +296,6 @@ and alter the reconstruction parameters and algorithms to find out if you can make the recontruction converge. Check out the engine parameter branch :py:data:`.engine` for detailed parameter descriptions. -.. literalinclude:: ../../templates/minimal_load_and_run.py +.. literalinclude:: ../../templates/ptypy_minimal_load_and_run.py :language: python :linenos: diff --git a/doc/script2rst.py b/doc/script2rst.py index 206a3f07d..b05148e46 100644 --- a/doc/script2rst.py +++ b/doc/script2rst.py @@ -137,10 +137,14 @@ def stdoutIO(stdout=None): sout.buf = '' if len(wline) > 0: - if line.startswith('# '): + if line.startswith('#'): # This was '# ' before, but pycharm eats trailing whitespaces so the marker wline = line[2:] was_comment = True - frst.write(wline) + if not wline: + # just in case there is an empty line on purpose + frst.write('\n') + else: + frst.write(wline) else: wline = ' >>> '+wline if was_comment: diff --git a/ptypy/__init__.py b/ptypy/__init__.py index 2f1633878..33da60ac8 100644 --- a/ptypy/__init__.py +++ b/ptypy/__init__.py @@ -72,8 +72,57 @@ # Import core modules from . import utils from . import io -from . import experiment from . import core from . import simulations from . import resources +# Convenience loader for GPU engines +def load_gpu_engines(arch='cuda'): + if arch=='cuda': + from .accelerate.cuda_pycuda.engines import projectional_pycuda + from .accelerate.cuda_pycuda.engines import projectional_pycuda_stream + from .accelerate.cuda_pycuda.engines import stochastic + from .accelerate.cuda_pycuda.engines import ML_pycuda + if arch=='serial': + from .accelerate.base.engines import projectional_serial + from .accelerate.base.engines import projectional_serial_stream + from .accelerate.base.engines import stochastic + from .accelerate.base.engines import ML_serial + if arch=='ocl': + from .accelerate.ocl_pyopencl.engines import DM_ocl, DM_ocl_npy + +from importlib import import_module +from .utils.verbose import log +ptyscan_modules = ['hdf5_loader', + 'cSAXS', + 'savu', + 'plugin', + 'ID16Anfp', + 'AMO_LCLS', + 'DiProI_FERMI', + 'optiklabor', + 'UCL', + 'nanomax', + 'nanomax_streaming', + 'ALS_5321', + 'Bragg3dSim'] + +# Convenience loader for ptyscan modules +def load_ptyscan_module(module): + try: + lib = import_module("."+module, 'ptypy.experiment') + except ImportError as exception: + log(2, 'Could not import ptyscan module %s, Reason: %s' % (module, exception)) + pass + +# Convenience loader for all ptyscan modules +def load_all_ptyscan_modules(): + for m in ptyscan_modules: + load_ptyscan_module(m) + +# Convenience loader for all ptyscan modules and all gpu engines +def load_all(): + load_gpu_engines("cuda") + load_gpu_engines("serial") + #load_gpu_engines("ocl") + load_all_ptyscan_modules() \ No newline at end of file diff --git a/templates/__init__.py b/ptypy/accelerate/__init__.py similarity index 100% rename from templates/__init__.py rename to ptypy/accelerate/__init__.py diff --git a/ptypy/accelerate/base/__init__.py b/ptypy/accelerate/base/__init__.py new file mode 100644 index 000000000..cfacc2aa2 --- /dev/null +++ b/ptypy/accelerate/base/__init__.py @@ -0,0 +1,3 @@ +import numpy as np +COMPLEX_TYPE= np.complex64 +FLOAT_TYPE = np.float32 \ No newline at end of file diff --git a/ptypy/accelerate/base/address_manglers.py b/ptypy/accelerate/base/address_manglers.py new file mode 100644 index 000000000..8ac8b8d1e --- /dev/null +++ b/ptypy/accelerate/base/address_manglers.py @@ -0,0 +1,87 @@ +''' +utils to help with position refinement +''' + +import numpy as np +np.random.seed(0) + +class BaseMangler(object): + ''' + Assumes integer pixel shift. + ''' + def __init__(self, max_step_per_shift, start, stop, nshifts, decay=True, max_bound=None, randomseed=None): + # can be initialised in the engine.init + + # maximum distance from the starting positions + self.max_bound = max_bound + # maximum step per iteration, decreases with progression + self.max_step = lambda it: np.ceil(max_step_per_shift * (stop - it) / (stop - start)) if decay else max_step_per_shift + self.nshifts = nshifts + self.delta = 0 + + def get_address(self, index, addr_current, mangled_addr, max_oby, max_obx): + ''' + Mangles with the address given a delta shift + ''' + old_positions = np.zeros((addr_current.shape[0], 2)) + old_positions[:] = addr_current[:, 0, 1, 1:] + new_positions = np.zeros((addr_current.shape[0],2)) + new_positions[:] = old_positions + self.delta[index] # first mode is same as all of them. + # now update the main matrix (Same for all modes) + for idx in range(addr_current.shape[1]): + mangled_addr[:, idx, 1, 1:] = new_positions + self.apply_bounding_box(mangled_addr[:,:,1,1], 0, max_oby) + self.apply_bounding_box(mangled_addr[:,:,1,2], 0, max_obx) + + def apply_bounding_box(self, addr, min, max): + ''' + Check if the mangled addresses are within valid bounds + ''' + addr[addrmax] = max + + def setup_shifts(self, current_iteration, nframes=1): + ''' + Arrange an array of shifts + ''' + raise NotImplementedError("This method needs to be overwritten in order to position correct") + + +class RandomIntMangler(BaseMangler): + + def __init__(self, *args, **kwargs): + super(RandomIntMangler, self).__init__(*args, **kwargs) + + def setup_shifts(self, current_iteration, nframes=1): + ''' + Calculates random integer shifts + ''' + max_step = self.max_step(current_iteration) + self.delta = np.random.randint(0, max_step + 1, (self.nshifts, nframes, 2)) + for index in range(self.nshifts): + self.delta[index, :, 0] *= (-1)**index + self.delta[index, :, 1] *= (-1)**(index//2) + # check if the shifts are within the maximum bound + norms = np.linalg.norm(self.delta, axis=-1) + self.delta[norms > self.max_bound] = 0 + +class GridSearchMangler(BaseMangler): + def __init__(self, *args, **kwargs): + super(GridSearchMangler, self).__init__(*args, **kwargs) + + def setup_shifts(self, current_iteration, nframes=1): + ''' + Calculates integer shifts on a grid + ''' + max_step = self.max_step(current_iteration) + delta = np.mgrid[-max_step:max_step+1:1, + -max_step:max_step+1:1] + within_bound = (delta[0]**2 + delta[1]**2) < (self.max_bound**2) + self.delta = np.tile(delta[:,within_bound].T.reshape(within_bound.sum(),1,2), (1,nframes,1)) + self.nshifts = self.delta.shape[0] + + + + + + diff --git a/ptypy/accelerate/base/array_utils.py b/ptypy/accelerate/base/array_utils.py new file mode 100644 index 000000000..839b08e70 --- /dev/null +++ b/ptypy/accelerate/base/array_utils.py @@ -0,0 +1,150 @@ +''' +useful utilities from ptypy that should be ported to gpu. These don't ahve external dependencies +''' +import numpy as np +from scipy import ndimage as ndi + + +def dot(A, B, acc_dtype=np.float64): + assert A.dtype == B.dtype, "Input arrays must of same data type" + if np.iscomplexobj(B): + out = np.sum(np.multiply(A, B.conj()).real, dtype=acc_dtype) + else: + out = np.sum(np.multiply(A, B), dtype=acc_dtype) + return out + + +def norm2(A): + return dot(A, A) + +def max_abs2(A): + ''' + A has ndim = 3. + compute abs2, sum along first dimension and take maximum along last two dims + ''' + return np.max(np.sum(np.abs(A)**2,axis=0),axis=(-2,-1)) + +def abs2(input): + ''' + + :param input. An array that we want to take the absolute value of and square. Can be inplace. Can be complex or real. + :return: The real valued abs**2 array + ''' + return np.multiply(input, input.conj()).real + + +def sum_to_buffer(in1, outshape, in1_addr, out1_addr, dtype): + ''' + :param in1. An array . Can be inplace. Can be complex or real. + :param outshape. An array. + :param in1_addr. An array . Can be inplace. Can be complex or real. + :param out1_addr. An array . Can be inplace. Can be complex or real. + :return: The real valued abs**2 array + ''' + out1 = np.zeros(outshape, dtype=dtype) + inshape = in1.shape + for i1, o1 in zip(in1_addr, out1_addr): + out1[o1[0], o1[1]:(o1[1] + inshape[1]), o1[2]:(o1[2] + inshape[2])] += in1[i1[0]] + return out1 + + +def norm2(input): + ''' + Input here could be a variety of 1D, 2D, 3D complex or real. all will be single precision at least. + return should be real + ''' + return np.sum(abs2(input)) + + +def complex_gaussian_filter(input, mfs): + ''' + takes 2D and 3D arrays. Complex input, complex output. mfs has len 0 2: + raise NotImplementedError("Only batches of 2D arrays allowed!") + + if input.ndim == 3: + mfs = np.insert(mfs, 0, 0) + + return (ndi.gaussian_filter(np.real(input), mfs) + 1j * ndi.gaussian_filter(np.imag(input), mfs)).astype( + input.dtype) + + +def mass_center(A): + ''' + Input will always be real, and 2d or 3d, single precision here + ''' + return np.array(ndi.measurements.center_of_mass(A), dtype=A.dtype) + + +def interpolated_shift(c, shift, do_linear=False): + ''' + complex bicubic interpolated shift. + complex output. This shift should be applied to 2D arrays. shift should have len=c.ndims + + ''' + if not do_linear: + return ndi.interpolation.shift(np.real(c), shift, order=3, prefilter=True) + 1j * ndi.interpolation.shift( + np.imag(c), shift, order=3, prefilter=True) + else: + return ndi.interpolation.shift(np.real(c), shift, order=1, mode='constant', cval=0, + prefilter=False) + 1j * ndi.interpolation.shift(np.imag(c), shift, order=1, + mode='constant', cval=0, + prefilter=False) + + +def clip_complex_magnitudes_to_range(complex_input, clip_min, clip_max): + ''' + This takes a single precision 2D complex input, clips the absolute magnitudes to be within a range, but leaves the phase untouched. + ''' + ampl = np.abs(complex_input) + phase = np.exp(1j * np.angle(complex_input)) + ampl = np.clip(ampl, clip_min, clip_max) + complex_input[:] = ampl * phase + + +def fill3D(A, B, offset=[0, 0, 0]): + """ + Fill 3-dimensional array A with B. + """ + if A.ndim < 3 or B.ndim < 3: + raise ValueError('Input arrays must each be at least 3D') + assert A.ndim == B.ndim, "Input and Output must have the same number of dimensions." + ash = A.shape + bsh = B.shape + misfit = np.array(bsh) - np.array(ash) + assert not misfit[:-3].any(), "Input and Output must have the same shape everywhere but the last three axes." + + Alim = np.array(A.shape[-3:]) + Blim = np.array(B.shape[-3:]) + off = np.array(offset) + Ao = off.copy() + Ao[Ao < 0] = 0 + Bo = -off.copy() + Bo[Bo < 0] = 0 + assert (Bo < Blim).all() and (Ao < Alim).all(), "At least one dimension lacks overlap" + A[..., Ao[0]:min(off[0] + Blim[0], Alim[0]), + Ao[1]:min(off[1] + Blim[1], Alim[1]), + Ao[2]:min(off[2] + Blim[2], Alim[2])] \ + = B[..., Bo[0]:min(Alim[0] - off[0], Blim[0]), + Bo[1]:min(Alim[1] - off[1], Blim[1]), + Bo[2]:min(Alim[2] - off[2], Blim[2])] + + +def crop_pad_2d_simple(A, B): + """ + Places B in A centered around the last two axis. A and B must be of the same shape + anywhere but the last two dims. + """ + assert A.ndim >= 2, "Arrays must have more than 2 dimensions." + assert A.ndim == B.ndim, "Input and Output must have the same number of dimensions." + misfit = np.array(A.shape) - np.array(B.shape) + assert not misfit[:-2].any(), "Input and Output must have the same shape everywhere but the last two axes." + if A.ndim == 2: + A = A.reshape((1,) + A.shape) + if B.ndim == 2: + B = B.reshape((1,) + B.shape) + a1, a2 = A.shape[-2:] + b1, b2 = B.shape[-2:] + offset = [0, a1 // 2 - b1 // 2, a2 // 2 - b2 // 2] + fill3D(A, B, offset) diff --git a/ptypy/accelerate/base/engines/ML_serial.py b/ptypy/accelerate/base/engines/ML_serial.py new file mode 100644 index 000000000..b779a6667 --- /dev/null +++ b/ptypy/accelerate/base/engines/ML_serial.py @@ -0,0 +1,541 @@ +# -*- coding: utf-8 -*- +""" +Maximum Likelihood reconstruction engine. + +TODO. + + * Implement other regularizers + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" +import numpy as np +import time + +from ptypy.engines.ML import ML, BaseModel +from .projectional_serial import serialize_array_access +from ptypy import utils as u +from ptypy.utils.verbose import logger, log +from ptypy.utils import parallel +from ptypy.engines.utils import Cnorm2, Cdot +from ptypy.engines import register +from ptypy.accelerate.base.kernels import GradientDescentKernel, AuxiliaryWaveKernel, PoUpdateKernel, PositionCorrectionKernel +from ptypy.accelerate.base import address_manglers + + +__all__ = ['ML_serial'] + +@register() +class ML_serial(ML): + + def __init__(self, ptycho_parent, pars=None): + """ + Maximum likelihood reconstruction engine. + """ + super(ML_serial, self).__init__(ptycho_parent, pars) + + self.kernels = {} + self.diff_info = {} + self.cn2_ob_grad = 0. + self.cn2_pr_grad = 0. + + def engine_initialize(self): + """ + Prepare for ML reconstruction. + """ + super(ML_serial, self).engine_initialize() + self._setup_kernels() + + def _initialize_model(self): + + # Create noise model + if self.p.ML_type.lower() == "gaussian": + self.ML_model = GaussianModel(self) + elif self.p.ML_type.lower() == "poisson": + raise NotImplementedError('Poisson norm model not yet implemented') + elif self.p.ML_type.lower() == "euclid": + raise NotImplementedError('Euclid norm model not yet implemented') + else: + raise RuntimeError("Unsupported ML_type: '%s'" % self.p.ML_type) + + def _setup_kernels(self): + """ + Setup kernels, one for each scan. Derive scans from ptycho class + """ + # get the scans + for label, scan in self.ptycho.model.scans.items(): + + kern = u.Param() + kern.scanmodel = type(scan).__name__ + self.kernels[label] = kern + + # TODO: needs to be adapted for broad bandwidth + geo = scan.geometries[0] + + # Get info to shape buffer arrays + fpc = scan.max_frames_per_block + + # TODO : make this more foolproof + try: + nmodes = scan.p.coherence.num_probe_modes + except: + nmodes = 1 + + # create buffer arrays + ash = (fpc * nmodes,) + tuple(geo.shape) + aux = np.zeros(ash, dtype=np.complex64) + kern.aux = aux + kern.a = np.zeros(ash, dtype=np.complex64) + kern.b = np.zeros(ash, dtype=np.complex64) + + # setup kernels, one for each SCAN. + kern.GDK = GradientDescentKernel(aux, nmodes) + kern.GDK.allocate() + + kern.POK = PoUpdateKernel() + kern.POK.allocate() + + kern.AWK = AuxiliaryWaveKernel() + kern.AWK.allocate() + + kern.FW = geo.propagator.fw + kern.BW = geo.propagator.bw + kern.resolution = geo.resolution[0] + + if self.do_position_refinement: + kern.PCK = PositionCorrectionKernel(aux, nmodes, self.p.position_refinement, geo.resolution) + kern.PCK.allocate() + + def engine_prepare(self): + + ## Serialize new data ## + + for label, d in self.ptycho.new_data: + prep = u.Param() + prep.label = label + self.diff_info[d.ID] = prep + prep.err_phot = np.zeros((d.data.shape[0],), dtype=np.float32) + # set floating intensity coefficients to 1.0 + # they get overridden if self.p.floating_intensities=True + prep.float_intens_coeff = np.ones((d.data.shape[0],), dtype=np.float32) + + # Unfortunately this needs to be done for all pods, since + # the shape of the probe / object was modified. + # TODO: possible scaling issue + for label, d in self.di.storages.items(): + prep = self.diff_info[d.ID] + prep.view_IDs, prep.poe_IDs, prep.addr = serialize_array_access(d) + # Re-create exit addresses when gradient models (single exit buffer per view) are used + # TODO: this should not be necessary, kernels should not use exit wave information + if self.kernels[prep.label].scanmodel in ("GradFull", "BlockGradFull"): + for i,addr in enumerate(prep.addr): + nmodes = len(addr[:,2,0]) + for j,ea in enumerate(addr[:,2,0]): + prep.addr[i,j,2,0] = i*nmodes+j + prep.I = d.data + if self.do_position_refinement: + prep.original_addr = np.zeros_like(prep.addr) + prep.original_addr[:] = prep.addr + prep.ma = self.ma.S[d.ID].data + + self.ML_model.prepare() + + def _get_smooth_gradient(self, data, sigma): + return self.smooth_gradient(data) + + def _replace_ob_grad(self): + new_ob_grad = self.ob_grad_new + # Smoothing preconditioner + if self.smooth_gradient: + self.smooth_gradient.sigma *= (1. - self.p.smooth_gradient_decay) + for name, s in new_ob_grad.storages.items(): + s.data[:] = self._get_smooth_gradient(s.data, self.smooth_gradient.sigma) + + norm = Cnorm2(new_ob_grad) + dot = np.real(Cdot(new_ob_grad, self.ob_grad)) + self.ob_grad << new_ob_grad + return norm, dot + + def _replace_pr_grad(self): + new_pr_grad = self.pr_grad_new + # probe support + if self.p.probe_update_start <= self.curiter: + # Apply probe support if needed + for name, s in new_pr_grad.storages.items(): + self.support_constraint(s) + else: + new_pr_grad.fill(0.) + + norm = Cnorm2(new_pr_grad) + dot = np.real(Cdot(new_pr_grad, self.pr_grad)) + self.pr_grad << new_pr_grad + return norm, dot + + def engine_iterate(self, num=1): + """ + Compute `num` iterations. + """ + ######################## + # Compute new gradient + ######################## + tg = 0. + tc = 0. + ta = time.time() + for it in range(num): + t1 = time.time() + error_dct = self.ML_model.new_grad() + tg += time.time() - t1 + + cn2_new_pr_grad, cdotr_pr_grad = self._replace_pr_grad() + cn2_new_ob_grad, cdotr_ob_grad = self._replace_ob_grad() + + # probe/object rescaling + if self.p.scale_precond: + if cn2_new_pr_grad > 1e-5: + scale_p_o = (self.p.scale_probe_object * cn2_new_ob_grad + / cn2_new_pr_grad) + else: + scale_p_o = self.p.scale_probe_object + if self.scale_p_o is None: + self.scale_p_o = scale_p_o + else: + self.scale_p_o = self.scale_p_o ** self.scale_p_o_memory + self.scale_p_o *= scale_p_o ** (1 - self.scale_p_o_memory) + logger.debug('Scale P/O: %6.3g' % scale_p_o) + else: + self.scale_p_o = self.p.scale_probe_object + + ############################ + # Compute next conjugate + ############################ + if self.curiter == 0: + bt = 0. + else: + bt_num = (self.scale_p_o * (cn2_new_pr_grad - cdotr_pr_grad) + (cn2_new_ob_grad - cdotr_ob_grad)) + + bt_denom = self.scale_p_o * self.cn2_pr_grad + self.cn2_ob_grad + + bt = max(0, bt_num / bt_denom) + + # logger.info('Polak-Ribiere coefficient: %f ' % bt) + + self.cn2_ob_grad = cn2_new_ob_grad + self.cn2_pr_grad = cn2_new_pr_grad + + dt = self.ptycho.FType + # 3. Next conjugate + self.ob_h *= dt(bt / self.tmin) + + # Smoothing preconditioner + if self.smooth_gradient: + for name, s in self.ob_h.storages.items(): + s.data[:] -= self._get_smooth_gradient(self.ob_grad.storages[name].data, self.smooth_gradient.sigma) + else: + self.ob_h -= self.ob_grad + + self.pr_h *= dt(bt / self.tmin) + self.pr_grad *= dt(self.scale_p_o) + self.pr_h -= self.pr_grad + + # In principle, the way things are now programmed this part + # could be iterated over in a real Newton-Raphson style. + t2 = time.time() + B = self.ML_model.poly_line_coeffs(self.ob_h, self.pr_h) + tc += time.time() - t2 + + if np.isinf(B).any() or np.isnan(B).any(): + logger.warning( + 'Warning! inf or nan found! Trying to continue...') + B[np.isinf(B)] = 0. + B[np.isnan(B)] = 0. + + self.tmin = dt(-.5 * B[1] / B[2]) + self.ob_h *= self.tmin + self.pr_h *= self.tmin + self.ob += self.ob_h + self.pr += self.pr_h + # Newton-Raphson loop would end here + + # Refine the scan positions + self.position_update() + + # Allow for customized modifications at the end of each iteration + self._post_iterate_update() + + # increase iteration counter + self.curiter += 1 + + logger.info('Time spent in gradient calculation: %.2f' % tg) + logger.info(' .... in coefficient calculation: %.2f' % tc) + return error_dct # np.array([[self.ML_model.LL[0]] * 3]) + + def position_update(self): + """ + Position refinement + """ + if not self.do_position_refinement: + return + do_update_pos = (self.p.position_refinement.stop > self.curiter >= self.p.position_refinement.start) + do_update_pos &= (self.curiter % self.p.position_refinement.interval) == 0 + + # Update positions + if do_update_pos: + """ + Iterates through all positions and refines them by a given algorithm. + """ + log(4, "----------- START POS REF -------------") + for dID in self.di.S.keys(): + + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + ob = self.ob.S[oID].data + pr = self.pr.S[pID].data + kern = self.kernels[prep.label] + aux = kern.aux + addr = prep.addr + original_addr = prep.original_addr + mangled_addr = addr.copy() + w = prep.weights + I = prep.I + err_phot = prep.err_phot + + PCK = kern.PCK + FW = kern.FW + + # Keep track of object boundaries + max_oby = ob.shape[-2] - aux.shape[-2] - 1 + max_obx = ob.shape[-1] - aux.shape[-1] - 1 + + # We need to re-calculate the current error + PCK.build_aux(aux, addr, ob, pr) + aux[:] = FW(aux) + PCK.log_likelihood_ml(aux, addr, I, w, err_phot) + error_state = np.zeros_like(err_phot) + error_state[:] = err_phot + PCK.mangler.setup_shifts(self.curiter, nframes=addr.shape[0]) + + log(4, 'Position refinement trial: iteration %s' % (self.curiter)) + for i in range(PCK.mangler.nshifts): + PCK.mangler.get_address(i, addr, mangled_addr, max_oby, max_obx) + PCK.build_aux(aux, mangled_addr, ob, pr) + aux[:] = FW(aux) + PCK.log_likelihood_ml(aux, mangled_addr, I, w, err_phot) + PCK.update_addr_and_error_state(addr, error_state, mangled_addr, err_phot) + + prep.err_phot = error_state + prep.addr = addr + + def engine_finalize(self): + """ + try deleting ever helper contianer + """ + if self.do_position_refinement and self.p.position_refinement.record: + for label, d in self.di.storages.items(): + prep = self.diff_info[d.ID] + res = self.kernels[prep.label].resolution + for i,view in enumerate(d.views): + for j,(pname, pod) in enumerate(view.pods.items()): + delta = (prep.addr[i][j][1][1:] - prep.original_addr[i][j][1][1:]) * res + pod.ob_view.coord += delta + pod.ob_view.storage.update_views(pod.ob_view) + self.ptycho.record_positions = True + + # Save floating intensities into runtime + float_intens_coeff = {} + for label, d in self.di.storages.items(): + prep = self.diff_info[d.ID] + float_intens_coeff[label] = prep.float_intens_coeff + self.ptycho.runtime["float_intens"] = parallel.gather_dict(float_intens_coeff) + + +class BaseModelSerial(BaseModel): + """ + Base class for log-likelihood models. + """ + + def __del__(self): + """ + Clean up routine + """ + pass + + +class GaussianModel(BaseModelSerial): + """ + Gaussian noise model. + TODO: feed actual statistical weights instead of using the Poisson statistic heuristic. + """ + + def __init__(self, MLengine): + """ + Core functions for ML computation using a Gaussian model. + """ + super(GaussianModel, self).__init__(MLengine) + + def prepare(self): + + super(GaussianModel, self).prepare() + + for label, d in self.engine.ptycho.new_data: + prep = self.engine.diff_info[d.ID] + prep.weights = (self.Irenorm * self.engine.ma.S[d.ID].data + / (1. / self.Irenorm + d.data)).astype(d.data.dtype) + + def __del__(self): + """ + Clean up routine + """ + super(GaussianModel, self).__del__() + + def new_grad(self): + """ + Compute a new gradient direction according to a Gaussian noise model. + + Note: The negative log-likelihood and local errors are also computed + here. + """ + ob_grad = self.engine.ob_grad_new + pr_grad = self.engine.pr_grad_new + ob_grad << 0. + pr_grad << 0. + + # We need an array for MPI + LL = np.array([0.]) + error_dct = {} + + for dID in self.di.S.keys(): + prep = self.engine.diff_info[dID] + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # references for kernels + kern = self.engine.kernels[prep.label] + GDK = kern.GDK + AWK = kern.AWK + POK = kern.POK + + aux = kern.aux + + FW = kern.FW + BW = kern.BW + + # get addresses and auxilliary array + addr = prep.addr + w = prep.weights + err_phot = prep.err_phot + fic = prep.float_intens_coeff + + # local references + ob = self.engine.ob.S[oID].data + obg = ob_grad.S[oID].data + pr = self.engine.pr.S[pID].data + prg = pr_grad.S[pID].data + I = prep.I + + # make propagated exit (to buffer) + AWK.build_aux_no_ex(aux, addr, ob, pr, add=False) + + # forward prop + aux[:] = FW(aux) + + GDK.make_model(aux, addr) + + if self.p.floating_intensities: + GDK.floating_intensity(addr, w, I, fic) + + GDK.main(aux, addr, w, I) + GDK.error_reduce(addr, err_phot) + aux[:] = BW(aux) + + POK.ob_update_ML(addr, obg, pr, aux) + POK.pr_update_ML(addr, prg, ob, aux) + + for dID, prep in self.engine.diff_info.items(): + err_phot = prep.err_phot + LL += err_phot.sum() + err_phot /= np.prod(prep.weights.shape[-2:]) + err_fourier = np.zeros_like(err_phot) + err_exit = np.zeros_like(err_phot) + errs = np.ascontiguousarray(np.vstack([err_fourier, err_phot, err_exit]).T) + error_dct.update(zip(prep.view_IDs, errs)) + + # MPI reduction of gradients + ob_grad.allreduce() + pr_grad.allreduce() + parallel.allreduce(LL) + + # Object regularizer + if self.regularizer: + for name, s in self.engine.ob.storages.items(): + ob_grad.storages[name].data += self.regularizer.grad(s.data) + LL += self.regularizer.LL + + self.LL = LL / self.tot_measpts + return error_dct + + def poly_line_coeffs(self, c_ob_h, c_pr_h): + """ + Compute the coefficients of the polynomial for line minimization + in direction h + """ + + B = np.zeros((3,), dtype=np.longdouble) + Brenorm = 1. / self.LL[0] ** 2 + + # Outer loop: through diffraction patterns + for dID in self.di.S.keys(): + prep = self.engine.diff_info[dID] + + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # references for kernels + kern = self.engine.kernels[prep.label] + GDK = kern.GDK + AWK = kern.AWK + + f = kern.aux + a = kern.a + b = kern.b + + FW = kern.FW + + # get addresses and auxilliary array + addr = prep.addr + w = prep.weights + fic = prep.float_intens_coeff + + # local references + ob = self.ob.S[oID].data + ob_h = c_ob_h.S[oID].data + pr = self.pr.S[pID].data + pr_h = c_pr_h.S[pID].data + I = self.di.S[dID].data + + # make propagated exit (to buffer) + AWK.build_aux_no_ex(f, addr, ob, pr, add=False) + AWK.build_aux_no_ex(a, addr, ob_h, pr, add=False) + AWK.build_aux_no_ex(a, addr, ob, pr_h, add=True) + AWK.build_aux_no_ex(b, addr, ob_h, pr_h, add=False) + + # forward prop + f[:] = FW(f) + a[:] = FW(a) + b[:] = FW(b) + + GDK.make_a012(f, a, b, addr, I, fic) + GDK.fill_b(addr, Brenorm, w, B) + + parallel.allreduce(B) + + # Object regularizer + if self.regularizer: + for name, s in self.ob.storages.items(): + B += Brenorm * self.regularizer.poly_line_coeffs( + c_ob_h.storages[name].data, s.data) + + self.B = B + + return B diff --git a/ptypy/accelerate/base/engines/__init__.py b/ptypy/accelerate/base/engines/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/ptypy/accelerate/base/engines/projectional_serial.py b/ptypy/accelerate/base/engines/projectional_serial.py new file mode 100644 index 000000000..0816c7049 --- /dev/null +++ b/ptypy/accelerate/base/engines/projectional_serial.py @@ -0,0 +1,614 @@ +# -*- coding: utf-8 -*- +""" +Difference Map reconstruction engine. + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" +import numpy as np +import time + +from ptypy import utils as u +from ptypy.utils.verbose import logger, log +from ptypy.utils import parallel +from ptypy.engines import register +from ptypy.engines.projectional import _ProjectionEngine, DMMixin, RAARMixin +from ptypy.accelerate.base.kernels import FourierUpdateKernel, AuxiliaryWaveKernel, PoUpdateKernel, PositionCorrectionKernel +from ptypy.accelerate.base import array_utils as au + + +### TODOS +# +# - The Propagator needs to be made somewhere else +# - Get it running faster with MPI (partial sync) +# - implement "batching" when processing frames to lower the pressure on memory +# - Be smarter about the engine.prepare() part +# - Propagator needs to be reconfigurable for a certain batch size, gpyfft hates that. +# - Fourier_update_kernel needs to allow batched execution + + +__all__ = ['DM_serial', 'RAAR_serial'] + +parallel = u.parallel + + +def gaussian_kernel(sigma, size=None, sigma_y=None, size_y=None): + size = int(size) + sigma = np.float(sigma) + if not size_y: + size_y = size + if not sigma_y: + sigma_y = sigma + + x, y = np.mgrid[-size:size + 1, -size_y:size_y + 1] + + g = np.exp(-(x ** 2 / (2 * sigma ** 2) + y ** 2 / (2 * sigma_y ** 2))) + return g / g.sum() + + +def serialize_array_access(diff_storage): + # Sort views according to layer in diffraction stack + views = diff_storage.views + dlayers = [view.dlayer for view in views] + views = [views[i] for i in np.argsort(dlayers)] + view_IDs = [view.ID for view in views] + + # Master pod + mpod = views[0].pod + + # Determine linked storages for probe, object and exit waves + pr = mpod.pr_view.storage + ob = mpod.ob_view.storage + ex = mpod.ex_view.storage + + poe_ID = (pr.ID, ob.ID, ex.ID) + + addr = [] + for view in views: + address = [] + + for pname, pod in view.pods.items(): + ## store them for each pod + # create addresses + a = np.array( + [(pod.pr_view.dlayer, pod.pr_view.dlow[0], pod.pr_view.dlow[1]), + (pod.ob_view.dlayer, pod.ob_view.dlow[0], pod.ob_view.dlow[1]), + (pod.ex_view.dlayer, pod.ex_view.dlow[0], pod.ex_view.dlow[1]), + (pod.di_view.dlayer, pod.di_view.dlow[0], pod.di_view.dlow[1]), + (pod.ma_view.dlayer, pod.ma_view.dlow[0], pod.ma_view.dlow[1])]) + + address.append(a) + + if pod.pr_view.storage.ID != pr.ID: + log(1, "Splitting probes for one diffraction stack is not supported in " + __name__) + if pod.ob_view.storage.ID != ob.ID: + log(1, "Splitting objects for one diffraction stack is not supported in " + __name__) + if pod.ex_view.storage.ID != ex.ID: + log(1, "Splitting exit stacks for one diffraction stack is not supported in " + __name__) + + ## store data for each view + # adresses + addr.append(address) + + # store them for each storage + return view_IDs, poe_ID, np.array(addr).astype(np.int32) + + +class _ProjectionEngine_serial(_ProjectionEngine): + """ + A full-fledged Difference Map engine that uses numpy arrays instead of iteration. + + """ + + def __init__(self, ptycho_parent, pars=None): + """ + Difference map reconstruction engine. + """ + + super().__init__(ptycho_parent, pars) + + ## gaussian filter + # dummy kernel + """ + if not self.p.obj_smooth_std: + gauss_kernel = gaussian_kernel(1,1).astype(np.float32) + else: + gauss_kernel = gaussian_kernel(self.p.obj_smooth_std,self.p.obj_smooth_std).astype(np.float32) + + kernel_pars = {'kernel_sh_x' : gauss_kernel.shape[0], 'kernel_sh_y': gauss_kernel.shape[1]} + """ + self.benchmark = u.Param() + + # Stores all information needed with respect to the diffraction storages. + self.diff_info = {} + self.ob_cfact = {} + self.pr_cfact = {} + self.kernels = {} + + def engine_initialize(self): + """ + Prepare for reconstruction. + """ + + super().engine_initialize() + self._reset_benchmarks() + self._setup_kernels() + + def _reset_benchmarks(self): + self.benchmark.A_Build_aux = 0. + self.benchmark.B_Prop = 0. + self.benchmark.C_Fourier_update = 0. + self.benchmark.D_iProp = 0. + self.benchmark.E_Build_exit = 0. + self.benchmark.F_LLerror = 0. + self.benchmark.probe_update = 0. + self.benchmark.object_update = 0. + self.benchmark.calls_fourier = 0 + self.benchmark.calls_object = 0 + self.benchmark.calls_probe = 0 + + def _setup_kernels(self): + """ + Setup kernels, one for each scan. Derive scans from ptycho class + """ + # get the scans + for label, scan in self.ptycho.model.scans.items(): + + kern = u.Param() + kern.scanmodel = type(scan).__name__ + self.kernels[label] = kern + + # TODO: needs to be adapted for broad bandwidth + geo = scan.geometries[0] + + # Get info to shape buffer arrays + fpc = scan.max_frames_per_block + + # TODO : make this more foolproof + try: + nmodes = scan.p.coherence.num_probe_modes * \ + scan.p.coherence.num_object_modes + except: + nmodes = 1 + + # create buffer arrays + ash = (fpc * nmodes,) + tuple(geo.shape) + aux = np.zeros(ash, dtype=np.complex64) + kern.aux = aux + + # setup kernels, one for each SCAN. + kern.FUK = FourierUpdateKernel(aux, nmodes) + kern.FUK.allocate() + + kern.POK = PoUpdateKernel() + kern.POK.allocate() + + kern.AWK = AuxiliaryWaveKernel() + kern.AWK.allocate() + + kern.FW = geo.propagator.fw + kern.BW = geo.propagator.bw + kern.resolution = geo.resolution[0] + + if self.do_position_refinement: + kern.PCK = PositionCorrectionKernel(aux, nmodes, self.p.position_refinement, geo.resolution) + kern.PCK.allocate() + + def engine_prepare(self): + + super().engine_prepare() + + ## Serialize new data ## + + for label, d in self.ptycho.new_data: + prep = u.Param() + + prep.label = label + self.diff_info[d.ID] = prep + prep.mag = np.sqrt(np.abs(d.data)) + prep.ma = self.ma.S[d.ID].data.astype(np.float32) + # self.ma.S[d.ID].data = prep.ma + prep.ma_sum = prep.ma.sum(-1).sum(-1) + prep.err_phot = np.zeros_like(prep.ma_sum) + prep.err_fourier = np.zeros_like(prep.ma_sum) + prep.err_exit = np.zeros_like(prep.ma_sum) + + # Unfortunately this needs to be done for all pods, since + # the shape of the probe / object was modified. + # TODO: possible scaling issue, remove the need for padding + for label, d in self.di.storages.items(): + prep = self.diff_info[d.ID] + prep.view_IDs, prep.poe_IDs, prep.addr = serialize_array_access(d) + if self.do_position_refinement: + prep.original_addr = np.zeros_like(prep.addr) + prep.original_addr[:] = prep.addr + pID, oID, eID = prep.poe_IDs + + # calculate c_facts + cfact = self.p.object_inertia * self.mean_power + self.ob_cfact[oID] = cfact / u.parallel.size + + pr = self.pr.S[pID] + cfact = self.p.probe_inertia * len(pr.views) / pr.data.shape[0] + self.pr_cfact[pID] = cfact / u.parallel.size + + def engine_iterate(self, num=1): + """ + Compute one iteration. + """ + + for it in range(num): + + error = {} + + for dID in self.di.S.keys(): + + # find probe, object and exit ID in dependence of dID + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + + # references for kernels + kern = self.kernels[prep.label] + FUK = kern.FUK + AWK = kern.AWK + FW = kern.FW + BW = kern.BW + + # get addresses and buffers + addr = prep.addr + mag = prep.mag + ma_sum = prep.ma_sum + err_phot = prep.err_phot + err_fourier = prep.err_fourier + err_exit = prep.err_exit + pbound = self.pbound_scan[prep.label] + aux = kern.aux + + # local references + ma = prep.ma + ob = self.ob.S[oID].data + pr = self.pr.S[pID].data + ex = self.ex.S[eID].data + + ## compute log-likelihood + if self.p.compute_log_likelihood: + t1 = time.time() + AWK.build_aux_no_ex(aux, addr, ob, pr) + aux[:] = FW(aux) + FUK.log_likelihood(aux, addr, mag, ma, err_phot) + self.benchmark.F_LLerror += time.time() - t1 + + ## build auxilliary wave + t1 = time.time() + AWK.make_aux(aux, addr, ob, pr, ex, c_po=self._c, c_e=1-self._c) + self.benchmark.A_Build_aux += time.time() - t1 + + ## forward FFT + t1 = time.time() + aux[:] = FW(aux) + self.benchmark.B_Prop += time.time() - t1 + + ## Deviation from measured data + t1 = time.time() + FUK.fourier_error(aux, addr, mag, ma, ma_sum) + FUK.error_reduce(addr, err_fourier) + FUK.fmag_all_update(aux, addr, mag, ma, err_fourier, pbound) + self.benchmark.C_Fourier_update += time.time() - t1 + + ## backward FFT + t1 = time.time() + aux[:] = BW(aux) + self.benchmark.D_iProp += time.time() - t1 + + ## build exit wave + t1 = time.time() + AWK.make_exit(aux, addr, ob, pr, ex, c_a=self._b, c_po=self._a, c_e=-(self._a+self._b)) + FUK.exit_error(aux,addr) + FUK.error_reduce(addr, err_exit) + self.benchmark.E_Build_exit += time.time() - t1 + + # update errors + errs = np.ascontiguousarray(np.vstack([err_fourier, err_phot, err_exit]).T) + error.update(zip(prep.view_IDs, errs)) + + self.benchmark.calls_fourier += 1 + + parallel.barrier() + + sync = (self.curiter % 1 == 0) + self.overlap_update(MPI=True) + + # Recenter the probe + self.center_probe() + + parallel.barrier() + + self.position_update() + + self.curiter += 1 + + self.error = error + return error + + def position_update(self): + """ + Position refinement + """ + if not self.do_position_refinement: + return + do_update_pos = (self.p.position_refinement.stop > self.curiter >= self.p.position_refinement.start) + do_update_pos &= (self.curiter % self.p.position_refinement.interval) == 0 + + # Update positions + if do_update_pos: + """ + Iterates through all positions and refines them by a given algorithm. + """ + log(4, "----------- START POS REF -------------") + for dID in self.di.S.keys(): + + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + ma = self.ma.S[dID].data + ob = self.ob.S[oID].data + pr = self.pr.S[pID].data + kern = self.kernels[prep.label] + aux = kern.aux + addr = prep.addr + original_addr = prep.original_addr + mangled_addr = addr.copy() + mag = prep.mag + ma_sum = prep.ma_sum + err_fourier = prep.err_fourier + + PCK = kern.PCK + FW = kern.FW + + # Keep track of object boundaries + max_oby = ob.shape[-2] - aux.shape[-2] - 1 + max_obx = ob.shape[-1] - aux.shape[-1] - 1 + + # We need to re-calculate the current error + PCK.build_aux(aux, addr, ob, pr) + aux[:] = FW(aux) + if self.p.position_refinement.metric == "fourier": + PCK.fourier_error(aux, addr, mag, ma, ma_sum) + PCK.error_reduce(addr, err_fourier) + if self.p.position_refinement.metric == "photon": + PCK.log_likelihood(aux, addr, mag, ma, err_fourier) + error_state = np.zeros_like(err_fourier) + error_state[:] = err_fourier + PCK.mangler.setup_shifts(self.curiter, nframes=addr.shape[0]) + + log(4, 'Position refinement trial: iteration %s' % (self.curiter)) + for i in range(PCK.mangler.nshifts): + PCK.mangler.get_address(i, addr, mangled_addr, max_oby, max_obx) + PCK.build_aux(aux, mangled_addr, ob, pr) + aux[:] = FW(aux) + if self.p.position_refinement.metric == "fourier": + PCK.fourier_error(aux, mangled_addr, mag, ma, ma_sum) + PCK.error_reduce(mangled_addr, err_fourier) + if self.p.position_refinement.metric == "photon": + PCK.log_likelihood(aux, mangled_addr, mag, ma, err_fourier) + PCK.update_addr_and_error_state(addr, error_state, mangled_addr, err_fourier) + + prep.err_fourier = error_state + prep.addr = addr + + + def overlap_update(self, MPI=True): + """ + DM overlap constraint update. + """ + change = 1. + # Condition to update probe + do_update_probe = (self.p.probe_update_start <= self.curiter) + + for inner in range(self.p.overlap_max_iterations): + prestr = '%d Iteration (Overlap) #%02d: ' % (parallel.rank, inner) + # Update object first + if self.p.update_object_first or (inner > 0): + # Update object + log(4, prestr + '----- object update -----', True) + self.object_update(MPI=(parallel.size > 1 and MPI)) + + # Exit if probe should not yet be updated + if not do_update_probe: break + + # Update probe + log(4, prestr + '----- probe update -----', True) + change = self.probe_update(MPI=(parallel.size > 1 and MPI)) + log(4, prestr + 'change in probe is %.3f' % change, True) + + # stop iteration if probe change is small + if change < self.p.overlap_converge_factor: break + + + ## object update + def object_update(self, MPI=False): + t1 = time.time() + + for oID, ob in self.ob.storages.items(): + obn = self.ob_nrm.S[oID] + cfact = self.p.object_inertia * self.mean_power + + if self.p.obj_smooth_std is not None: + log(4, 'Smoothing object, cfact is %.2f' % cfact) + smooth_mfs = [self.p.obj_smooth_std, self.p.obj_smooth_std] + ob.data = cfact * au.complex_gaussian_filter(ob.data, smooth_mfs) + else: + ob.data *= cfact + + obn.data[:] = cfact + + # storage for-loop + for dID in self.di.S.keys(): + prep = self.diff_info[dID] + + POK = self.kernels[prep.label].POK + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # scan for loop + ev = POK.ob_update(prep.addr, + self.ob.S[oID].data, + self.ob_nrm.S[oID].data, + self.pr.S[pID].data, + self.ex.S[eID].data) + + for oID, ob in self.ob.storages.items(): + obn = self.ob_nrm.S[oID] + # MPI test + if MPI: + parallel.allreduce(ob.data) + parallel.allreduce(obn.data) + ob.data /= obn.data + else: + ob.data /= obn.data + + # Clip object (This call takes like one ms. Not time critical) + if self.p.clip_object is not None: + clip_min, clip_max = self.p.clip_object + ampl_obj = np.abs(ob.data) + phase_obj = np.exp(1j * np.angle(ob.data)) + too_high = (ampl_obj > clip_max) + too_low = (ampl_obj < clip_min) + ob.data[too_high] = clip_max * phase_obj[too_high] + ob.data[too_low] = clip_min * phase_obj[too_low] + + self.benchmark.object_update += time.time() - t1 + self.benchmark.calls_object += 1 + + ## probe update + def probe_update(self, MPI=False): + t1 = time.time() + + # storage for-loop + change = 0 + + for pID, pr in self.pr.storages.items(): + prn = self.pr_nrm.S[pID] + cfact = self.pr_cfact[pID] + pr.data *= cfact + prn.data.fill(cfact) + + for dID in self.di.S.keys(): + prep = self.diff_info[dID] + + POK = self.kernels[prep.label].POK + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # scan for-loop + ev = POK.pr_update(prep.addr, + self.pr.S[pID].data, + self.pr_nrm.S[pID].data, + self.ob.S[oID].data, + self.ex.S[eID].data) + + self.benchmark.probe_update += time.time() - t1 + self.benchmark.calls_probe += 1 + + for pID, pr in self.pr.storages.items(): + + buf = self.pr_buf.S[pID] + prn = self.pr_nrm.S[pID] + + # MPI test + if MPI: + # if False: + parallel.allreduce(pr.data) + parallel.allreduce(prn.data) + pr.data /= prn.data + else: + pr.data /= prn.data + + self.support_constraint(pr) + + change += u.norm2(pr.data - buf.data) / u.norm2(pr.data) + buf.data[:] = pr.data + if MPI: + change = parallel.allreduce(change) / parallel.size + + return np.sqrt(change) + + def engine_finalize(self, benchmark=True): + """ + try deleting ever helper contianer + """ + if parallel.master and benchmark: + print("----- BENCHMARKS ----") + acc = 0. + for name in sorted(self.benchmark.keys()): + t = self.benchmark[name] + if name[0] in 'ABCDEFGHI': + print('%20s : %1.3f ms per iteration' % (name, t / self.benchmark.calls_fourier * 1000)) + acc += t + elif str(name) == 'probe_update': + print('%20s : %1.3f ms per call. %d calls' % ( + name, t / self.benchmark.calls_probe * 1000, self.benchmark.calls_probe)) + elif str(name) == 'object_update': + print('%20s : %1.3f ms per call. %d calls' % ( + name, t / self.benchmark.calls_object * 1000, self.benchmark.calls_object)) + + print('%20s : %1.3f ms per iteration. %d calls' % ( + 'Fourier_total', acc / self.benchmark.calls_fourier * 1000, self.benchmark.calls_fourier)) + + self._reset_benchmarks() + + if self.do_position_refinement and self.p.position_refinement.record: + for label, d in self.di.storages.items(): + prep = self.diff_info[d.ID] + res = self.kernels[prep.label].resolution + for i,view in enumerate(d.views): + for j,(pname, pod) in enumerate(view.pods.items()): + delta = (prep.addr[i][j][1][1:] - prep.original_addr[i][j][1][1:]) * res + pod.ob_view.coord += delta + pod.ob_view.storage.update_views(pod.ob_view) + self.ptycho.record_positions = True + + super().engine_finalize() + + +@register() +class DM_serial(_ProjectionEngine_serial, DMMixin): + """ + A full-fledged Difference Map engine serialized. + + Defaults: + + [name] + default = DM_serial + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + _ProjectionEngine_serial.__init__(self, ptycho_parent, pars) + DMMixin.__init__(self, self.p.alpha) + ptycho_parent.citations.add_article(**self.article) + + +@register() +class RAAR_serial(_ProjectionEngine_serial, RAARMixin): + """ + A RAAR engine. + + Defaults: + + [name] + default = RAAR_serial + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + + _ProjectionEngine_serial.__init__(self, ptycho_parent, pars) + RAARMixin.__init__(self, self.p.beta) diff --git a/ptypy/accelerate/base/engines/projectional_serial_stream.py b/ptypy/accelerate/base/engines/projectional_serial_stream.py new file mode 100644 index 000000000..1d5784700 --- /dev/null +++ b/ptypy/accelerate/base/engines/projectional_serial_stream.py @@ -0,0 +1,267 @@ +# -*- coding: utf-8 -*- +""" +Difference Map reconstruction engine. + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" + +# from .. import core +from __future__ import division + +import numpy as np +import time + +from ptypy import utils as u +from ptypy.utils.verbose import logger, log +from ptypy.utils import parallel +from ptypy.engines import register +from .projectional_serial import DM_serial + +### TODOS +# +# - The Propagator needs to be made somewhere else +# - Get it running faster with MPI (partial sync) +# - implement "batching" when processing frames to lower the pressure on memory +# - Be smarter about the engine.prepare() part +# - Propagator needs to be reconfigurable for a certain batch size, gpyfft hates that. +# - Fourier_update_kernel needs to allow batched execution + + +__all__ = ['DM_serial_stream'] + +parallel = u.parallel +MPI = (parallel.size > 1) + + +@register() +class DM_serial_stream(DM_serial): + """ + A full-fledged Difference Map engine that uses numpy arrays instead of iteration. + """ + def engine_iterate(self, num=1): + """ + Compute one iteration. + """ + + for it in range(num): + + error = {} + + for inner in range(self.p.overlap_max_iterations): + + change = 0 + + do_update_probe = (self.curiter >= self.p.probe_update_start) + do_update_object = (self.p.update_object_first or (inner > 0) or not do_update_probe) + do_update_fourier = (inner == 0) + + # initialize probe and object buffer to receive an update + if do_update_object: + for oID, ob in self.ob.storages.items(): + cfact = self.ob_cfact[oID] + obn = self.ob_nrm.S[oID] + obb = self.ob_buf.S[oID] + """ + if self.p.obj_smooth_std is not None: + logger.info('Smoothing object, cfact is %.2f' % cfact) + t2 = time.time() + self.prg.gaussian_filter(queue, (info[3],info[4]), None, obj_gpu.data, self.gauss_kernel_gpu.data) + queue.finish() + obj_gpu *= cfact + print 'gauss: ' + str(time.time()-t2) + else: + obj_gpu *= cfact + """ + obb.data[:] = ob.data + obb.data *= cfact + obn.data[:] = cfact + + # First cycle: Fourier + object update + for dID in self.di.S.keys(): + t1 = time.time() + + prep = self.diff_info[dID] + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # references for kernels + kern = self.kernels[prep.label] + FUK = kern.FUK + AWK = kern.AWK + POK = kern.POK + + pbound = self.pbound_scan[prep.label] + aux = kern.aux + FW = kern.FW + BW = kern.BW + + # get addresses and auxilliary array + addr = prep.addr + mag = prep.mag + ma_sum = prep.ma_sum + err_fourier = prep.err_fourier + + # local references + ma = self.ma.S[dID].data + ob = self.ob.S[oID].data + obn = self.ob_nrm.S[oID].data + obb = self.ob_buf.S[oID].data + pr = self.pr.S[pID].data + ex = self.ex.S[eID].data + + # Fourier update. + if do_update_fourier: + log(4, '----- Fourier update -----', True) + t1 = time.time() + AWK.make_aux(aux, addr, ob, pr, ex, c_po=self._c, c_e=1-self._c) + self.benchmark.A_Build_aux += time.time() - t1 + + ## FFT + t1 = time.time() + aux[:] = FW(aux) + self.benchmark.B_Prop += time.time() - t1 + + ## Deviation from measured data + t1 = time.time() + FUK.fourier_error(aux, addr, mag, ma, ma_sum) + FUK.error_reduce(addr, err_fourier) + FUK.fmag_all_update(aux, addr, mag, ma, err_fourier, pbound) + self.benchmark.C_Fourier_update += time.time() - t1 + + t1 = time.time() + aux[:] = BW(aux) + self.benchmark.D_iProp += time.time() - t1 + + ## apply changes #2 + t1 = time.time() + AWK.make_exit(aux, addr, ob, pr, ex, c_a=self._b, c_po=self._a, c_e=-(self._a+self._b)) + self.benchmark.E_Build_exit += time.time() - t1 + + err_phot = np.zeros_like(err_fourier) + err_exit = np.zeros_like(err_fourier) + errs = np.ascontiguousarray(np.vstack([err_fourier, err_phot, err_exit]).T) + error.update(zip(prep.view_IDs, errs)) + + self.benchmark.calls_fourier += 1 + + parallel.barrier() + + prestr = '%d Iteration (Overlap) #%02d: ' % (parallel.rank, inner) + + # Update object + if do_update_object: + # Update object + log(4, prestr + '----- object update -----', True) + t1 = time.time() + + # scan for loop + ev = POK.ob_update(addr, obb, obn, pr, ex) + + self.benchmark.object_update += time.time() - t1 + self.benchmark.calls_object += 1 + + if do_update_object: + for oID, ob in self.ob.storages.items(): + obn = self.ob_nrm.S[oID] + obb = self.ob_buf.S[oID] + # MPI test + if MPI: + parallel.allreduce(obb.data) + parallel.allreduce(obn.data) + obb.data /= obn.data + else: + obb.data /= obn.data + + self.clip_object(obb) + ob.data[:] = obb.data + + # Exit if probe should not yet be updated + if not do_update_probe: + break + + # Update probe + log(4, prestr + '----- probe update -----', True) + change = self.probe_update(MPI=MPI) + # change = self.probe_update(MPI=(parallel.size>1 and MPI)) + + log(4, prestr + 'change in probe is %.3f' % change, True) + + # stop iteration if probe change is small + if change < self.p.overlap_converge_factor: break + """ + # Exit if probe should not yet be updated + if do_update_probe: + # Update probe + log(4, prestr + '----- probe update -----', True) + + # init probe + for pID, pr in self.pr.storages.items(): + prn = self.pr_nrm.S[pID] + cfact = self.pr_cfact[pID] + pr.data[:] = pr.data + prn.data.fill(cfact) + + # second cycle + for dID in self.di.S.keys(): + prep = self.diff_info[dID] + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # references for kernels + kern = self.kernels[prep.label] + POK = kern.POK + + # get addresses and auxilliary array + addr = prep.addr + + # local references + ob = self.ob.S[oID].data + pr = self.pr.S[pID].data + ex = self.ex.S[eID].data + prn = self.pr_nrm.S[pID].data + + t1 = time.time() + + # scan for-loop + ev = POK.pr_update(addr, pr, prn, ob, ex) + + self.benchmark.probe_update += time.time() - t1 + self.benchmark.calls_probe += 1 + + # synchronize + for pID, pr in self.pr.storages.items(): + + prn = self.pr_nrm.S[pID] + buf = self.pr_buf.S[pID] + # MPI test + if MPI: + # if False: + parallel.allreduce(pr.data) + parallel.allreduce(prn.data) + pr.data /= prn.data + else: + pr.data /= prn.data + + self.support_constraint(pr) + + change += u.norm2(pr.data - buf.data) / u.norm2(buf.data) + buf.data[:] = pr.data + if MPI: + change = parallel.allreduce(change) / parallel.size + + change = np.sqrt(change) + + log(4, prestr + 'change in probe is %.3f' % change, True) + + # stop iteration if probe change is small + if change < self.p.overlap_converge_factor: break + """ + + parallel.barrier() + self.curiter += 1 + + self.error = error + return error diff --git a/ptypy/accelerate/base/engines/stochastic.py b/ptypy/accelerate/base/engines/stochastic.py new file mode 100644 index 000000000..f3b7f897e --- /dev/null +++ b/ptypy/accelerate/base/engines/stochastic.py @@ -0,0 +1,450 @@ +# -*- coding: utf-8 -*- +""" +Serialized stochastic reconstruction engine. + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" +import numpy as np +import time + +from ptypy import utils as u +from ptypy.utils.verbose import logger, log +from ptypy.utils import parallel +from ptypy import defaults_tree +from ptypy.engines import register +from ptypy.engines.stochastic import _StochasticEngine, EPIEMixin, SDRMixin +#from ptypy.core.manager import Full, Vanilla, Bragg3dModel, BlockVanilla, BlockFull +from ptypy.accelerate.base.engines import projectional_serial +from ptypy.accelerate.base.kernels import FourierUpdateKernel, AuxiliaryWaveKernel, PoUpdateKernel, PositionCorrectionKernel +from ptypy.accelerate.base import address_manglers +from ptypy.accelerate.base import array_utils as au + +__all__ = ["EPIE_serial", "SDR_serial"] + +class _StochasticEngineSerial(_StochasticEngine): + """ + A serialized base implementation of a stochastic algorithm for ptychography + + Defaults: + + [compute_exit_error] + default = False + type = bool + help = A switch for computing the exitwave error (this can impact the performance of the engine) + + [compute_fourier_error] + default = False + type = bool + help = A switch for computing the fourier error (this can impact the performance of the engine) + + """ + + #SUPPORTED_MODELS = [Full, Vanilla, Bragg3dModel, BlockVanilla, BlockFull] + + def __init__(self, ptycho_parent, pars=None): + """ + Stochastic reconstruction engine. + """ + super().__init__(ptycho_parent, pars) + + # keep track of timings + self.benchmark = u.Param() + + # Stores all information needed with respect to the diffraction storages. + self.diff_info = {} + self.ob_cfact = {} + self.pr_cfact = {} + self.kernels = {} + + def engine_initialize(self): + """ + Prepare for reconstruction. + """ + super().engine_initialize() + + self.error = [] + self._reset_benchmarks() + self._setup_kernels() + + def _reset_benchmarks(self): + self.benchmark.A_Build_aux = 0. + self.benchmark.B_Prop = 0. + self.benchmark.C_Fourier_update = 0. + self.benchmark.D_iProp = 0. + self.benchmark.E_Build_exit = 0. + self.benchmark.F_LLerror = 0. + self.benchmark.probe_update = 0. + self.benchmark.object_update = 0. + self.benchmark.calls_fourier = 0 + self.benchmark.calls_object = 0 + self.benchmark.calls_probe = 0 + + def _setup_kernels(self): + """ + Setup kernels, one for each scan. Derive scans from ptycho class + """ + # get the scans + for label, scan in self.ptycho.model.scans.items(): + + kern = u.Param() + kern.scanmodel = type(scan).__name__ + self.kernels[label] = kern + + # TODO: needs to be adapted for broad bandwidth + geo = scan.geometries[0] + + # TODO : make this more foolproof + try: + nmodes = scan.p.coherence.num_probe_modes * \ + scan.p.coherence.num_object_modes + except: + nmodes = 1 + + # create buffer arrays + ash = (nmodes,) + tuple(geo.shape) + aux = np.zeros(ash, dtype=np.complex64) + kern.aux = aux + + # setup kernels, one for each SCAN. + kern.FUK = FourierUpdateKernel(aux, nmodes) + kern.FUK.allocate() + + kern.POK = PoUpdateKernel() + kern.POK.allocate() + + kern.AWK = AuxiliaryWaveKernel() + kern.AWK.allocate() + + kern.FW = geo.propagator.fw + kern.BW = geo.propagator.bw + kern.resolution = geo.resolution[0] + + if self.do_position_refinement: + kern.PCK = PositionCorrectionKernel(aux, nmodes, self.p.position_refinement, geo.resolution) + kern.PCK.allocate() + + def engine_prepare(self): + """ + Last minute initialization. + + Everything that needs to be recalculated when new data arrives. + """ + if self.ptycho.new_data: + + # recalculate everything + mean_power = 0. + for s in self.di.storages.values(): + mean_power += s.mean_power + self.mean_power = mean_power / len(self.di.storages) + + ## Serialize new data ## + for label, d in self.ptycho.new_data: + prep = u.Param() + prep.label = label + self.diff_info[d.ID] = prep + prep.mag = np.sqrt(np.abs(d.data)) + prep.ma = self.ma.S[d.ID].data.astype(np.float32) + prep.ma_sum = prep.ma.sum(-1).sum(-1) + prep.err_phot = np.zeros_like(prep.ma_sum) + prep.err_fourier = np.zeros_like(prep.ma_sum) + prep.err_exit = np.zeros_like(prep.ma_sum) + + # Unfortunately this needs to be done for all pods, since + # the shape of the probe / object was modified. + # TODO: possible scaling issue, remove the need for padding + for label, d in self.di.storages.items(): + prep = self.diff_info[d.ID] + prep.view_IDs, prep.poe_IDs, prep.addr = projectional_serial.serialize_array_access(d) + if self.do_position_refinement: + prep.original_addr = np.zeros_like(prep.addr) + prep.original_addr[:] = prep.addr + pID, oID, eID = prep.poe_IDs + + # Keep a list of view indices + prep.rng = np.random.default_rng() + prep.vieworder = np.arange(prep.addr.shape[0]) + + # Modify addresses, copy pa into ea and remove da/ma + prep.addr_ex = np.vstack([prep.addr[:,0,2,0], prep.addr[:,-1,2,0]+1]).T + prep.addr[:,:,2] = prep.addr[:,:,0] + prep.addr[:,:,3:,0] = 0 + + # Reference to ex + prep.ex = self.ex.S[eID].data + + # Object / probe norm + prep.obn = np.zeros_like(prep.mag[0,None], dtype=np.float32) + prep.prn = np.zeros_like(prep.mag[0,None], dtype=np.float32) + + def engine_iterate(self, num=1): + """ + Compute one iteration. + """ + for it in range(num): + + error_dct = {} + + for dID in self.di.S.keys(): + + # find probe, object and exit ID in dependence of dID + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + + # references for kernels + kern = self.kernels[prep.label] + FUK = kern.FUK + AWK = kern.AWK + POK = kern.POK + FW = kern.FW + BW = kern.BW + + # global aux buffer + aux = kern.aux + + # references for ob, pr + ob = self.ob.S[oID].data + pr = self.pr.S[pID].data + + # shuffle view order + vieworder = prep.vieworder + prep.rng.shuffle(vieworder) + + # Iterate through views + for i in vieworder: + + # Get local adress and arrays + addr = prep.addr[i,None] + ex_from, ex_to = prep.addr_ex[i] + ex = prep.ex[ex_from:ex_to] + mag = prep.mag[i,None] + ma = prep.ma[i,None] + ma_sum = prep.ma_sum[i,None] + obn = prep.obn + prn = prep.prn + err_phot = prep.err_phot[i,None] + err_fourier = prep.err_fourier[i,None] + err_exit = prep.err_exit[i,None] + + # position update + self.position_update_local(prep,i) + + ## build auxilliary wave + t1 = time.time() + AWK.make_aux(aux, addr, ob, pr, ex, c_po=self._c, c_e=1-self._c) + self.benchmark.A_Build_aux += time.time() - t1 + + ## forward FFT + t1 = time.time() + aux[:] = FW(aux) + self.benchmark.B_Prop += time.time() - t1 + + ## Deviation from measured data + t1 = time.time() + if self.p.compute_fourier_error: + FUK.fourier_error(aux, addr, mag, ma, ma_sum) + FUK.error_reduce(addr, err_fourier) + else: + FUK.fourier_deviation(aux, addr, mag) + FUK.fmag_update_nopbound(aux, addr, mag, ma) + self.benchmark.C_Fourier_update += time.time() - t1 + + ## backward FFT + t1 = time.time() + aux[:] = BW(aux) + self.benchmark.D_iProp += time.time() - t1 + + ## build exit wave + t1 = time.time() + AWK.make_exit(aux, addr, ob, pr, ex, c_a=self._b, c_po=self._a, c_e=-(self._a+self._b)) + if self.p.compute_exit_error: + FUK.exit_error(aux,addr) + FUK.error_reduce(addr, err_exit) + self.benchmark.E_Build_exit += time.time() - t1 + self.benchmark.calls_fourier += 1 + + ## build auxilliary wave (ob * pr product) + t1 = time.time() + AWK.build_aux_no_ex(aux, addr, ob, pr) + self.benchmark.A_Build_aux += time.time() - t1 + + # object update + t1 = time.time() + POK.pr_norm_local(addr, pr, prn) + POK.ob_update_local(addr, ob, pr, ex, aux, prn, a=self._ob_a, b=self._ob_b) + self.benchmark.object_update += time.time() - t1 + self.benchmark.calls_object += 1 + + # probe update + t1 = time.time() + if self._object_norm_is_global and self._pr_a == 0: + obn_max = au.max_abs2(ob) + obn[:] = 0 + else: + POK.ob_norm_local(addr, ob, obn) + obn_max = obn.max() + if self.p.probe_update_start <= self.curiter: + POK.pr_update_local(addr, pr, ob, ex, aux, obn, obn_max, a=self._pr_a, b=self._pr_b) + self.benchmark.probe_update += time.time() - t1 + self.benchmark.calls_probe += 1 + + ## compute log-likelihood + if self.p.compute_log_likelihood: + t1 = time.time() + aux[:] = FW(aux) + FUK.log_likelihood(aux, addr, mag, ma, err_phot) + self.benchmark.F_LLerror += time.time() - t1 + + + # update errors + errs = np.ascontiguousarray(np.vstack([np.hstack(prep.err_fourier), + np.hstack(prep.err_phot), + np.hstack(prep.err_exit)]).T) + error_dct.update(zip(prep.view_IDs, errs)) + + # Re-center the probe + self.center_probe() + + self.curiter += 1 + + #error = parallel.gather_dict(error_dct) + return error_dct + + def position_update_local(self, prep, i): + """ + Position refinement update for current view. + """ + if not self.do_position_refinement: + return + do_update_pos = (self.p.position_refinement.stop > self.curiter >= self.p.position_refinement.start) + do_update_pos &= (self.curiter % self.p.position_refinement.interval) == 0 + + # Update positions + if do_update_pos: + """ + Iterates through all positions and refines them by a given algorithm. + """ + #log(4, "----------- START POS REF -------------") + pID, oID, eID = prep.poe_IDs + mag = prep.mag[i,None] + ma = prep.ma[i,None] + ma_sum = prep.ma_sum[i,None] + ob = self.ob.S[oID].data + pr = self.pr.S[pID].data + kern = self.kernels[prep.label] + aux = kern.aux + addr = prep.addr[i,None] + original_addr = prep.original_addr[i,None] + mangled_addr = addr.copy() + err_fourier = prep.err_fourier[i,None] + + PCK = kern.PCK + FW = kern.FW + + # Keep track of object boundaries + max_oby = ob.shape[-2] - aux.shape[-2] - 1 + max_obx = ob.shape[-1] - aux.shape[-1] - 1 + + # We first need to calculate the current error + PCK.build_aux(aux, addr, ob, pr) + aux[:] = FW(aux) + if self.p.position_refinement.metric == "fourier": + PCK.fourier_error(aux, addr, mag, ma, ma_sum) + PCK.error_reduce(addr, err_fourier) + if self.p.position_refinement.metric == "photon": + PCK.log_likelihood(aux, addr, mag, ma, err_fourier) + error_state = np.zeros_like(err_fourier) + error_state[:] = err_fourier + PCK.mangler.setup_shifts(self.curiter, nframes=addr.shape[0]) + + #log(4, 'Position refinement trial: iteration %s' % (self.curiter)) + for i in range(PCK.mangler.nshifts): + PCK.mangler.get_address(i, addr, mangled_addr, max_oby, max_obx) + PCK.build_aux(aux, mangled_addr, ob, pr) + aux[:] = FW(aux) + if self.p.position_refinement.metric == "fourier": + PCK.fourier_error(aux, mangled_addr, mag, ma, ma_sum) + PCK.error_reduce(mangled_addr, err_fourier) + if self.p.position_refinement.metric == "photon": + PCK.log_likelihood(aux, mangled_addr, mag, ma, err_fourier) + PCK.update_addr_and_error_state(addr, error_state, mangled_addr, err_fourier) + + prep.err_fourier[i,None] = error_state + prep.addr[i,None] = addr + + def engine_finalize(self): + """ + try deleting ever helper contianer + """ + if parallel.master and self.benchmark.calls_fourier: + print("----- BENCHMARKS ----") + acc = 0. + for name in sorted(self.benchmark.keys()): + t = self.benchmark[name] + if name[0] in 'ABCDEFGHI': + print('%20s : %1.3f ms per iteration' % (name, t / self.benchmark.calls_fourier * 1000)) + acc += t + elif str(name) == 'probe_update': + print('%20s : %1.3f ms per call. %d calls' % ( + name, t / self.benchmark.calls_probe * 1000, self.benchmark.calls_probe)) + elif str(name) == 'object_update': + print('%20s : %1.3f ms per call. %d calls' % ( + name, t / self.benchmark.calls_object * 1000, self.benchmark.calls_object)) + + print('%20s : %1.3f ms per iteration. %d calls' % ( + 'Fourier_total', acc / self.benchmark.calls_fourier * 1000, self.benchmark.calls_fourier)) + + self._reset_benchmarks() + + if self.do_position_refinement: + for label, d in self.di.storages.items(): + prep = self.diff_info[d.ID] + res = self.kernels[prep.label].resolution + for i,view in enumerate(d.views): + for j,(pname, pod) in enumerate(view.pods.items()): + delta = (prep.original_addr[i][j][1][1:] - prep.addr[i][j][1][1:]) * res + pod.ob_view.coord += delta + pod.ob_view.storage.update_views(pod.ob_view) + + +@register() +class EPIE_serial(_StochasticEngineSerial, EPIEMixin): + """ + A serialized implementation of the EPIE algorithm. + + Defaults: + + [name] + default = EPIE_serial + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + _StochasticEngineSerial.__init__(self, ptycho_parent, pars) + EPIEMixin.__init__(self, self.p.alpha, self.p.beta) + ptycho_parent.citations.add_article(**self.article) + +@register() +class SDR_serial(_StochasticEngineSerial, SDRMixin): + """ + A serialized implemnentation of the semi-implicit relaxed Douglas-Rachford (SDR) algorithm. + + Defaults: + + [name] + default = SDR_serial + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + _StochasticEngineSerial.__init__(self, ptycho_parent, pars) + SDRMixin.__init__(self, self.p.sigma, self.p.tau, self.p.beta_probe, self.p.beta_object) + ptycho_parent.citations.add_article(**self.article) diff --git a/ptypy/accelerate/base/kernels.py b/ptypy/accelerate/base/kernels.py new file mode 100644 index 000000000..f3a13bad5 --- /dev/null +++ b/ptypy/accelerate/base/kernels.py @@ -0,0 +1,815 @@ +import numpy as np +from ptypy.utils.verbose import logger, log +from .array_utils import max_abs2, abs2 + +class Adict(object): + + def __init__(self): + pass + + +class BaseKernel(object): + + def __init__(self): + self.verbose = False + self.npy = Adict() + self.benchmark = {} + + def log(self, x): + if self.verbose: + print(x) + + +class FourierUpdateKernel(BaseKernel): + + def __init__(self, aux, nmodes=1): + + super(FourierUpdateKernel, self).__init__() + self.denom = 1e-7 + self.nmodes = np.int32(nmodes) + ash = aux.shape + self.fshape = (ash[0] // nmodes, ash[1], ash[2]) + + # temporary buffer arrays + self.npy.fdev = None + self.npy.ferr = None + + self.kernels = [ + 'fourier_error', + 'error_reduce', + 'fmag_all_update' + ] + + def allocate(self): + """ + Allocate memory according to the number of modes and + shape of the diffraction stack. + """ + # temporary buffer arrays + self.npy.fdev = np.zeros(self.fshape, dtype=np.float32) + self.npy.ferr = np.zeros(self.fshape, dtype=np.float32) + + def fourier_error(self, b_aux, addr, mag, mask, mask_sum): + # reference shape (write-to shape) + sh = self.fshape + # stopper + maxz = mag.shape[0] + + # batch buffers + fdev = self.npy.fdev[:maxz] + ferr = self.npy.ferr[:maxz] + aux = b_aux[:maxz * self.nmodes] + + ## Actual math ## + + # build model from complex fourier magnitudes, summing up + # all modes incoherently + tf = aux.reshape(maxz, self.nmodes, sh[1], sh[2]) + af = np.sqrt((np.abs(tf) ** 2).sum(1)) + + # calculate difference to real data (g_mag) + fdev[:] = af - mag + + # Calculate error on fourier magnitudes on a per-pixel basis + ferr[:] = mask * np.abs(fdev) ** 2 / mask_sum.reshape((maxz, 1, 1)) + return + + def fourier_deviation(self, b_aux, addr, mag): + # reference shape (write-to shape) + sh = self.fshape + # stopper + maxz = mag.shape[0] + + # batch buffers + fdev = self.npy.fdev[:maxz] + aux = b_aux[:maxz * self.nmodes] + + ## Actual math ## + + # build model from complex fourier magnitudes, summing up + # all modes incoherently + tf = aux.reshape(maxz, self.nmodes, sh[1], sh[2]) + af = np.sqrt((np.abs(tf) ** 2).sum(1)) + + # calculate difference to real data (g_mag) + fdev[:] = af - mag + + return + + def error_reduce(self, addr, err_sum): + # reference shape (write-to shape) + sh = self.fshape + + # stopper + maxz = err_sum.shape[0] + + # batch buffers + ferr = self.npy.ferr[:maxz] + + ## Actual math ## + + # Reduces the Fourier error along the last 2 dimensions.fd + #err_sum[:] = ferr.astype(np.double).sum(-1).sum(-1).astype(np.float) + err_sum[:] = ferr.sum(-1).sum(-1) + return + + def fmag_all_update(self, b_aux, addr, mag, mask, err_sum, pbound=0.0): + + sh = self.fshape + nmodes = self.nmodes + + # stopper + maxz = mag.shape[0] + + # batch buffers + fdev = self.npy.fdev[:maxz] + aux = b_aux[:maxz * nmodes] + + # write-to shape + ish = aux.shape + + ## Actual math ## + + # local values + fm = np.ones((maxz, sh[1], sh[2]), np.float32) + renorm = np.ones((maxz,), np.float32) + + ## As opposed to DM we use renorm to differentiate the cases. + + # pbound >= g_err_sum + # fm = 1.0 (as renorm = 1, i.e. renorm[~ind]) + # pbound < g_err_sum : + # fm = (1 - g_mask) + g_mask * (g_mag + fdev * renorm) / (af + 1e-10) + # (as renorm in [0,1]) + # pbound == 0.0 + # fm = (1 - g_mask) + g_mask * g_mag / (af + 1e-10) (as renorm=0) + + ind = err_sum > pbound + renorm[ind] = np.sqrt(pbound / err_sum[ind]) + renorm = renorm.reshape((renorm.shape[0], 1, 1)) + + af = fdev + mag + fm[:] = (1 - mask) + mask * (mag + fdev * renorm) / (af + self.denom) + + #fm[:] = mag / (af + 1e-6) + # upcasting + aux[:] = (aux.reshape(ish[0] // nmodes, nmodes, ish[1], ish[2]) * fm[:, np.newaxis, :, :]).reshape(ish) + return + + def fmag_update_nopbound(self, b_aux, addr, mag, mask): + + sh = self.fshape + nmodes = self.nmodes + + # stopper + maxz = mag.shape[0] + + # batch buffers + fdev = self.npy.fdev[:maxz] + aux = b_aux[:maxz * nmodes] + + # write-to shape + ish = aux.shape + + ## Actual math ## + + # local values + fm = np.ones((maxz, sh[1], sh[2]), np.float32) + + af = fdev + mag + fm[:] = (1 - mask) + mask * mag / (af + self.denom) + + # upcasting + aux[:] = (aux.reshape(ish[0] // nmodes, nmodes, ish[1], ish[2]) * fm[:, np.newaxis, :, :]).reshape(ish) + return + + def log_likelihood(self, b_aux, addr, mag, mask, err_phot): + # reference shape (write-to shape) + sh = self.fshape + # stopper + maxz = mag.shape[0] + + # batch buffers + aux = b_aux[:maxz * self.nmodes] + + # build model from complex fourier magnitudes, summing up + # all modes incoherently + tf = aux.reshape(maxz, self.nmodes, sh[1], sh[2]) + LL = (np.abs(tf) ** 2).sum(1) + + # Intensity data + I = mag**2 + + # Calculate log likelihood error + err_phot[:] = ((mask * (LL - I)**2 / (I + 1.)).sum(-1).sum(-1) / np.prod(LL.shape[-2:])) + return + + def exit_error(self, aux, addr): + sh = addr.shape + maxz = sh[0] + + # batch buffers + ferr = self.npy.ferr[:maxz] + dex = aux[:maxz * self.nmodes] + fsh = dex.shape[-2:] + ferr[:] = (np.abs(dex.reshape((maxz,self.nmodes,fsh[0], fsh[1])))**2).sum(axis=1) / np.prod(fsh) + + +class GradientDescentKernel(BaseKernel): + + def __init__(self, aux, nmodes=1): + + super(GradientDescentKernel, self).__init__() + self.denom = 1e-7 + self.nmodes = np.int32(nmodes) + ash = aux.shape + self.bshape = ash + self.fshape = (ash[0] // nmodes, ash[1], ash[2]) + self.ctype = aux.dtype + self.ftype = np.float32 if self.ctype == np.complex64 else np.float64 + + self.npy.LLden = None + self.npy.LLerr = None + self.npy.Imodel = None + + self.npy.float_err1 = None + self.npy.float_err2 = None + + self.kernels = [ + 'make_model', + 'error_reduce', + 'make_a012', + 'fill_b', + 'main', + 'floating_intensity' + ] + + def allocate(self): + """ + Allocate memory according to the number of modes and + shape of the diffraction stack. + """ + # temporary buffer arrays + self.npy.LLden = np.zeros(self.fshape, dtype=self.ftype) + self.npy.LLerr = np.zeros(self.fshape, dtype=self.ftype) + self.npy.Imodel = np.zeros(self.fshape, dtype=self.ftype) + + self.npy.fic_tmp = np.ones((self.fshape[0],), dtype=self.ftype) + + def make_model(self, b_aux, addr): + + # reference shape (= GPU global dims) + sh = self.fshape + + # batch buffers + Imodel = self.npy.Imodel + aux = b_aux + + ## Actual math ## (subset of FUK.fourier_error) + tf = aux.reshape(sh[0], self.nmodes, sh[1], sh[2]) + Imodel[:] = ((tf * tf.conj()).real).sum(1) + + def make_a012(self, b_f, b_a, b_b, addr, I, fic): + + # reference shape (= GPU global dims) + sh = I.shape + + # stopper + maxz = I.shape[0] + + A0 = self.npy.Imodel + A1 = self.npy.LLerr + A2 = self.npy.LLden + + # batch buffers + f = b_f[:maxz * self.nmodes] + a = b_a[:maxz * self.nmodes] + b = b_b[:maxz * self.nmodes] + + ## Actual math ## (subset of FUK.fourier_error) + fc = fic.reshape((maxz,1,1)) + A0.fill(0.) + tf = np.real(f * f.conj()).astype(self.ftype) + A0[:maxz] = np.double(tf.reshape(maxz, self.nmodes, sh[1], sh[2]).sum(1) * fc) - I + + A1.fill(0.) + tf = 2. * np.real(f * a.conj()) + A1[:maxz] = tf.reshape(maxz, self.nmodes, sh[1], sh[2]).sum(1) * fc + + A2.fill(0.) + tf = 2. * np.real(f * b.conj()) + np.real(a * a.conj()) + A2[:maxz] = tf.reshape(maxz, self.nmodes, sh[1], sh[2]).sum(1) * fc + return + + def fill_b(self, addr, Brenorm, w, B): + + # don't know the best dims but this element wise anyway + + # stopper + maxz = w.shape[0] + + A0 = self.npy.Imodel[:maxz] + A1 = self.npy.LLerr[:maxz] + A2 = self.npy.LLden[:maxz] + + ## Actual math ## + + # maybe two kernel calls? + + B[0] += np.dot(w.flat, (A0 ** 2).flat) * Brenorm + B[1] += np.dot(w.flat, (2 * A0 * A1).flat) * Brenorm + B[2] += np.dot(w.flat, (A1 ** 2 + 2 * A0 * A2).flat) * Brenorm + return + + def error_reduce(self, addr, err_sum): + + # reference shape (= GPU global dims) + sh = err_sum.shape + + # stopper + maxz = err_sum.shape[0] + + # batch buffers + ferr = self.npy.LLerr[:maxz] + + ## Actual math ## + + # Reduces the LL error along the last 2 dimensions.fd + err_sum[:] = ferr.sum(-1).sum(-1) + return + + def floating_intensity(self, addr, w, I, fic): + + # reference shape (= GPU global dims) + sh = fic.shape + + # stopper + maxz = fic.shape[0] + + # internal buffers + num = self.npy.LLerr[:maxz] + den = self.npy.LLden[:maxz] + Imodel = self.npy.Imodel[:maxz] + fic_tmp = self.npy.fic_tmp[:maxz] + + ## math ## + num[:] = w * Imodel * I + den[:] = w * Imodel ** 2 + fic[:] = num.sum(-1).sum(-1) + fic_tmp[:]= den.sum(-1).sum(-1) + fic/=fic_tmp + Imodel *= fic.reshape(Imodel.shape[0], 1, 1) + + def main(self, b_aux, addr, w, I): + + nmodes = self.nmodes + # stopper + maxz = I.shape[0] + + # batch buffers + err = self.npy.LLerr[:maxz] + Imodel = self.npy.Imodel[:maxz] + aux = b_aux[:maxz*nmodes] + + # write-to shape (= GPU global dims) + ish = aux.shape + + ## math ## + DI = np.double(Imodel) - I + tmp = w * DI + err[:] = tmp * DI + + aux[:] = (aux.reshape(ish[0] // nmodes, nmodes, ish[1], ish[2]) * tmp[:, np.newaxis, :, :]).reshape(ish) + return + + +class AuxiliaryWaveKernel(BaseKernel): + + def __init__(self): + super(AuxiliaryWaveKernel, self).__init__() + self.kernels = [ + 'build_aux', + 'build_exit', + ] + + def allocate(self): + pass + + def build_aux(self, b_aux, addr, ob, pr, ex, alpha=1.0): + # DM only, legacy + self.make_aux(b_aux, addr, ob, pr, ex, 1.+alpha, -alpha) + + def _build_aux(self, b_aux, addr, ob, pr, ex, alpha=1.0): + + sh = addr.shape + + nmodes = sh[1] + + # stopper + maxz = sh[0] + + # batch buffers + aux = b_aux[:maxz * nmodes] + flat_addr = addr.reshape(maxz * nmodes, sh[2], sh[3]) + rows, cols = ex.shape[-2:] + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + tmp = ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] * \ + pr[prc[0], :, :] * \ + (1. + alpha) - \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] * \ + alpha + aux[ind, :, :] = tmp + return + + def make_aux(self, b_aux, addr, ob, pr, ex, c_po=1.0, c_e=0.0): + + sh = addr.shape + + nmodes = sh[1] + + # stopper + maxz = sh[0] + + # batch buffers + aux = b_aux[:maxz * nmodes] + flat_addr = addr.reshape(maxz * nmodes, sh[2], sh[3]) + rows, cols = ex.shape[-2:] + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + tmp = ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] * \ + pr[prc[0], :, :] * c_po + \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] * c_e + aux[ind, :, :] = tmp + return + + def build_exit(self, b_aux, addr, ob, pr, ex, alpha=1): + self.make_exit(b_aux, addr, ob, pr, ex, 1.0, -alpha, alpha-1) + + def build_exit_alpha_tau(self, b_aux, addr, ob, pr, ex, alpha=1, tau=1): + self.make_exit(b_aux, addr, ob, pr, ex, tau, 1 - tau * (1 + alpha), tau * alpha - 1) + + def make_exit(self, b_aux, addr, ob, pr, ex, c_a=1.0, c_po=0.0, c_e=-1.0): + + sh = addr.shape + + nmodes = sh[1] + + # stopper + maxz = sh[0] + + # batch buffers + aux = b_aux[:maxz * nmodes] + + flat_addr = addr.reshape(maxz * nmodes, sh[2], sh[3]) + rows, cols = ex.shape[-2:] + + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + dex = c_a * aux[ind, :, :] + c_po * \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] * \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] + c_e * \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] + + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] += dex + aux[ind, :, :] = dex + return + + def _build_exit(self, b_aux, addr, ob, pr, ex, alpha=1): + + sh = addr.shape + + nmodes = sh[1] + + # stopper + maxz = sh[0] + + # batch buffers + aux = b_aux[:maxz * nmodes] + + flat_addr = addr.reshape(maxz * nmodes, sh[2], sh[3]) + rows, cols = ex.shape[-2:] + + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + dex = aux[ind, :, :] - alpha * \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] * \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] + (alpha - 1) * \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] + + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] += dex + aux[ind, :, :] = dex + return + + def _build_exit_alpha_tau(self, b_aux, addr, ob, pr, ex, alpha=1, tau=1): + sh = addr.shape + + nmodes = sh[1] + + # stopper + maxz = sh[0] + + # batch buffers + aux = b_aux[:maxz * nmodes] + + flat_addr = addr.reshape(maxz * nmodes, sh[2], sh[3]) + rows, cols = ex.shape[-2:] + + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + dex = tau * aux[ind, :, :] + (tau * alpha - 1) * \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] + \ + (1 - tau * (1 + alpha)) * \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] * \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] + + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] += dex + aux[ind, :, :] = dex + return + + def build_aux_no_ex(self, b_aux, addr, ob, pr, fac=1.0, add=False): + + sh = addr.shape + + nmodes = sh[1] + + # stopper + maxz = sh[0] + + # batch buffers + aux = b_aux[:maxz * nmodes] + flat_addr = addr.reshape(maxz * nmodes, sh[2], sh[3]) + rows, cols = b_aux.shape[-2:] + + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + tmp = ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] * \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] * fac + if add: + aux[ind, :, :] += tmp + else: + aux[ind, :, :] = tmp + return + +class PoUpdateKernel(BaseKernel): + + def __init__(self): + + super(PoUpdateKernel, self).__init__() + self.kernels = [ + 'pr_update', + 'ob_update', + ] + + def allocate(self): + pass + + def ob_update(self, addr, ob, obn, pr, ex): + + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + rows, cols = ex.shape[-2:] + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] += \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols].conj() * \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] + obn[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] += \ + (pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols].conj() * \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols]).real + return + + def pr_update(self, addr, pr, prn, ob, ex): + + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + rows, cols = ex.shape[-2:] + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] += \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols].conj() * \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] + prn[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] += \ + (ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols].conj() * \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols]).real + return + + def ob_update_ML(self, addr, ob, pr, ex, fac=2.0): + + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + rows, cols = ex.shape[-2:] + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] += \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols].conj() * \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] * fac + return + + def pr_update_ML(self, addr, pr, ob, ex, fac=2.0): + + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + rows, cols = ex.shape[-2:] + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] += \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols].conj() * \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] * fac + return + + def ob_update_local(self, addr, ob, pr, ex, aux, prn, a=0., b=1.): + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + rows, cols = ex.shape[-2:] + pr_norm = (1 - a) * prn.max() + a * prn + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] += \ + (a + b) * pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols].conj() * \ + (ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] - aux[ind,:,:]) / \ + pr_norm[dic[0], dic[1]:dic[1] + rows, dic[2]:dic[2] + cols] + return + + def pr_update_local(self, addr, pr, ob, ex, aux, obn, obn_max, a=0., b=1.): + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + rows, cols = ex.shape[-2:] + ob_norm = (1 - a) * obn_max + a * obn + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] += \ + (a + b) * ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols].conj() * \ + (ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] - aux[ind,:,:]) / \ + ob_norm[dic[0], dic[1]:dic[1] + rows, dic[2]:dic[2] + cols] + return + + def ob_norm_local(self, addr, ob, obn): + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + rows, cols = obn.shape[-2:] + obn[:] = 0. + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + # each object mode should only be counted once + if prc[0] > 0: + continue + obn[dic[0],dic[1]:dic[1] + rows, dic[2]:dic[2] + cols] += \ + (ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols].conj() * \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols]).real + return + + def pr_norm_local(self, addr, pr, prn): + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + rows, cols = prn.shape[-2:] + prn[:] = 0. + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + # each probe mode should only be counted once + if obc[0] > 0: + continue + prn[dic[0],dic[1]:dic[1] + rows, dic[2]:dic[2] + cols] += \ + (pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols].conj() * \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols]).real + return + + +class PositionCorrectionKernel(BaseKernel): + from ptypy.accelerate.base import address_manglers + + MANGLERS = { + 'Annealing': address_manglers.RandomIntMangler, + 'GridSearch': address_manglers.GridSearchMangler + } + + def __init__(self, aux, nmodes, parameters, resolution): + super(PositionCorrectionKernel, self).__init__() + ash = aux.shape + self.fshape = (ash[0] // nmodes, ash[1], ash[2]) + self.npy.ferr = None + self.npy.fdev = None + self.addr = None + self.nmodes = nmodes + self.param = parameters + self.nshifts = parameters.nshifts + self.resolution = resolution + self.kernels = ['build_aux', + 'fourier_error', + 'error_reduce', + 'update_addr'] + self.setup() + + def setup(self): + Mangler = self.MANGLERS[self.param.method] + amplitude = int(np.ceil(self.param.amplitude / self.resolution[0])) + max_shift = int(np.ceil(self.param.max_shift / self.resolution[0])) + self.mangler = Mangler(amplitude, self.param.start, self.param.stop, + self.param.nshifts, decay=self.param.amplitude_decay, + max_bound=max_shift, randomseed=0) + + def allocate(self): + self.npy.fdev = np.zeros(self.fshape, dtype=np.float32) # we won't use this again but preallocate for speed + self.npy.ferr = np.zeros(self.fshape, dtype=np.float32) + + def build_aux(self, b_aux, addr, ob, pr): + """ + different to the AWK, no alpha subtraction. It would be the same, but with alpha permanentaly set to 0. + """ + sh = addr.shape + + nmodes = sh[1] + + # stopper + maxz = sh[0] + + # batch buffers + aux = b_aux[:maxz * nmodes] + flat_addr = addr.reshape(maxz * nmodes, sh[2], sh[3]) + rows, cols = aux.shape[-2:] + + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + dex = ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] * pr[prc[0], :, :] + aux[ind, :, :] = dex + + def fourier_error(self, b_aux, addr, mag, mask, mask_sum): + """ + Should be identical to that of the FUK, but we don't need fdev out. + """ + # reference shape (write-to shape) + sh = self.fshape + # stopper + maxz = mag.shape[0] + + # batch buffers + ferr = self.npy.ferr[:maxz] + fdev = self.npy.fdev[:maxz] + aux = b_aux[:maxz * self.nmodes] + + ## Actual math ## + + # build model from complex fourier magnitudes, summing up + # all modes incoherently + tf = aux.reshape(maxz, self.nmodes, sh[1], sh[2]) + af = np.sqrt((np.abs(tf) ** 2).sum(1)) + + # calculate difference to real data (g_mag) + fdev[:] = af - mag # we won't reuse this so don't need to keep a persistent buffer + + # Calculate error on fourier magnitudes on a per-pixel basis + ferr[:] = mask * np.abs(fdev) ** 2 / mask_sum.reshape((maxz, 1, 1)) + return + + def error_reduce(self, addr, err_sum): + """ + This should the exact same tree reduction as the FUK. + """ + # reference shape (write-to shape) + sh = self.fshape + + # stopper + maxz = err_sum.shape[0] + + # batch buffers + ferr = self.npy.ferr[:maxz] + + ## Actual math ## + + # Reduceses the Fourier error along the last 2 dimensions.fd + #err_sum[:] = ferr.astype(np.double).sum(-1).sum(-1).astype(np.float) + err_sum[:] = ferr.sum(-1).sum(-1) + return + + def log_likelihood(self, b_aux, addr, mag, mask, err_sum): + # reference shape (write-to shape) + sh = self.fshape + # stopper + maxz = mag.shape[0] + + # batch buffers + aux = b_aux[:maxz * self.nmodes] + + # build model from complex fourier magnitudes, summing up + # all modes incoherently + tf = aux.reshape(maxz, self.nmodes, sh[1], sh[2]) + LL = (np.abs(tf) ** 2).sum(1) + + # Intensity data + I = mag**2 + + # Calculate log likelihood error + err_sum[:] = ((mask * (LL - I)**2 / (I + 1.)).sum(-1).sum(-1) / np.prod(LL.shape[-2:])) + return + + def log_likelihood_ml(self, b_aux, addr, I, weights, err_sum): + # reference shape (write-to shape) + sh = self.fshape + # stopper + maxz = I.shape[0] + + # batch buffers + aux = b_aux[:maxz * self.nmodes] + + # build model from complex fourier magnitudes, summing up + # all modes incoherently + tf = aux.reshape(maxz, self.nmodes, sh[1], sh[2]) + LL = (np.abs(tf) ** 2).sum(1) + + # Calculate log likelihood error + err_sum[:] = ((weights * (LL - I)**2).sum(-1).sum(-1) / np.prod(LL.shape[-2:])) + return + + def update_addr_and_error_state(self, addr, error_state, mangled_addr, err_sum): + """ + updates the addresses and err state vector corresponding to the smallest error. I think this can be done on the cpu + """ + update_indices = err_sum < error_state + #log(4, "Position correction: updating %s indices" % np.sum(update_indices)) + addr[update_indices] = mangled_addr[update_indices] + error_state[update_indices] = err_sum[update_indices] diff --git a/ptypy/accelerate/cuda_pycuda/__init__.py b/ptypy/accelerate/cuda_pycuda/__init__.py new file mode 100644 index 000000000..e6c51d49f --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/__init__.py @@ -0,0 +1,68 @@ +import pycuda.driver as cuda +from pycuda.compiler import SourceModule +import numpy as np +import os +# debug_options = [] +# debug_options = ['-O0', '-G', '-g'] +debug_options = ['-O3', '-DNDEBUG', '-lineinfo'] # release mode flags + +# C++14 support was added with CUDA 9, so we only enable the flag there +if cuda.get_version()[0] >= 9: + debug_options += ['-std=c++14'] +else: + debug_options += ['-std=c++11'] + +context = None +queue = None + +def get_context(new_context=False, new_queue=False): + + from ptypy.utils import parallel + + global context + global queue + + if context is None or new_context: + cuda.init() + if parallel.rank_local >= cuda.Device.count(): + raise Exception('Local rank must be smaller than total device count, \ + rank={}, rank_local={}, device_count={}'.format( + parallel.rank, parallel.rank_local, cuda.Device.count() + )) + context = cuda.Device(parallel.rank_local).make_context() + context.push() + # print("made context %s on rank %s" % (str(context), str(parallel.rank))) + # print("The cuda device count on %s is:%s" % (str(parallel.rank), + # str(cuda.Device.count()))) + # print("parallel.rank:%s, parallel.rank_local:%s" % (str(parallel.rank), + # str(parallel.rank_local))) + if queue is None or new_queue: + queue = cuda.Stream() + + return context, queue + + +def load_kernel(name, subs={}, file=None): + + if file is None: + if isinstance(name, str): + fn = "%s/cuda/%s.cu" % (os.path.dirname(__file__), name) + else: + raise ValueError("name parameter must be a string if not filename is given") + else: + fn = "%s/cuda/%s" % (os.path.dirname(__file__), file) + + with open(fn, 'r') as f: + kernel = f.read() + for k,v in list(subs.items()): + kernel = kernel.replace(k, str(v)) + # insert a preprocessor line directive to assist compiler errors + escaped = fn.replace("\\", "\\\\") + kernel = '#line 1 "{}"\n'.format(escaped) + kernel + mod = SourceModule(kernel, include_dirs=[np.get_include()], no_extern_c=True, options=debug_options) + + if isinstance(name, str): + return mod.get_function(name) + else: # tuple + return tuple(mod.get_function(n) for n in name) + diff --git a/ptypy/accelerate/cuda_pycuda/address_manglers.py b/ptypy/accelerate/cuda_pycuda/address_manglers.py new file mode 100644 index 000000000..d19a77fa4 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/address_manglers.py @@ -0,0 +1,74 @@ +from ptypy.accelerate.cuda_pycuda import load_kernel +import numpy as np +from ptypy.accelerate.base import address_manglers as npam +from pycuda import gpuarray +import pycuda.driver as cuda + +class BaseMangler(npam.BaseMangler): + + def __init__(self, *args, queue_thread=None, **kwargs): + super().__init__(*args, **kwargs) + self.queue = queue_thread + self.get_address_cuda = load_kernel("get_address") + self.delta = None + self.delta_gpu = None + + def _setup_delta_gpu(self): + assert self.delta is not None, "Setup delta using the setup_shifts method first" + self.delta = np.ascontiguousarray(self.delta, dtype=np.int32) + + if self.delta_gpu is None or self.delta_gpu.shape[0] < self.delta.shape[0]: + self.delta_gpu = gpuarray.empty(self.delta.shape, dtype=np.int32) + # in case self.delta is smaller than delta_gpu, this will only copy the + # relevant part + cuda.memcpy_htod(dest=self.delta_gpu.ptr, + src=self.delta) + + def get_address(self, index, addr_current, mangled_addr, max_oby, max_obx): + assert addr_current.dtype == np.int32, "addresses must be int32" + assert mangled_addr.dtype == np.int32, "addresses must be int32" + assert len(addr_current.shape) == 4, "addresses must be 4 dimensions" + assert addr_current.shape == mangled_addr.shape, "output addresses must be pre-allocated" + assert self.delta_gpu is not None, "Deltas are not set yet - call setup_shifts first" + assert index < self.delta_gpu.shape[0], "Index out of range for deltas" + assert isinstance(self.delta_gpu, gpuarray.GPUArray), "Only GPU arrays are supported for delta" + + # only using a single thread block here as it's not enough work + # otherwise + self.get_address_cuda( + addr_current, + mangled_addr, + np.int32(addr_current.shape[0] * addr_current.shape[1]), + self.delta_gpu[index,None], + np.int32(max_oby), + np.int32(max_obx), + block=(64,1,1), + grid=(1, 1, 1), + stream=self.queue) + +# with multiple inheritance, we have to be explicit which super class +# we are calling in the methods +class RandomIntMangler(BaseMangler, npam.RandomIntMangler): + + def __init__(self, *args, **kwargs): + BaseMangler.__init__(self, *args, **kwargs) + + def setup_shifts(self, *args, **kwargs): + npam.RandomIntMangler.setup_shifts(self, *args, **kwargs) + self._setup_delta_gpu() + + def get_address(self, *args, **kwargs): + BaseMangler.get_address(self, *args, **kwargs) + + +class GridSearchMangler(BaseMangler, npam.GridSearchMangler): + + def __init__(self, *args, **kwargs): + BaseMangler.__init__(self, *args, **kwargs) + + def setup_shifts(self, *args, **kwargs): + npam.GridSearchMangler.setup_shifts(self, *args, **kwargs) + self._setup_delta_gpu() + + def get_address(self, *args, **kwargs): + BaseMangler.get_address(self, *args, **kwargs) \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/array_utils.py b/ptypy/accelerate/cuda_pycuda/array_utils.py new file mode 100644 index 000000000..7c2de8f3f --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/array_utils.py @@ -0,0 +1,698 @@ +from . import load_kernel +from pycuda import gpuarray +import pycuda.driver as cuda +from ptypy.utils import gaussian +import numpy as np + +# maps a numpy dtype to the corresponding C type +def map2ctype(dt): + if dt == np.float32: + return 'float' + elif dt == np.float64: + return 'double' + elif dt == np.complex64: + return 'complex' + elif dt == np.complex128: + return 'complex' + elif dt == np.int32: + return 'int' + elif dt == np.int64: + return 'long long' + else: + raise ValueError('No mapping for {}'.format(dt)) + + +class ArrayUtilsKernel: + def __init__(self, acc_dtype=np.float64, queue=None): + self.queue = queue + self.acc_dtype = acc_dtype + self.cdot_cuda = load_kernel("dot", { + 'IN_TYPE': 'complex', + 'ACC_TYPE': 'double' if acc_dtype==np.float64 else 'float' + }) + self.dot_cuda = load_kernel("dot", { + 'IN_TYPE': 'float', + 'ACC_TYPE': 'double' if acc_dtype==np.float64 else 'float' + }) + self.full_reduce_cuda = load_kernel("full_reduce", { + 'IN_TYPE': 'double' if acc_dtype==np.float64 else 'float', + 'OUT_TYPE': 'double' if acc_dtype==np.float64 else 'float', + 'ACC_TYPE': 'double' if acc_dtype==np.float64 else 'float', + 'BDIM_X': 1024 + }) + self.Ctmp = None + + def dot(self, A, B, out=None): + assert A.dtype == B.dtype, "Input arrays must be of same data type" + assert A.size == B.size, "Input arrays must be of the same size" + + if out is None: + out = gpuarray.zeros((1,), dtype=self.acc_dtype) + + block = (1024, 1, 1) + grid = (int((B.size + 1023) // 1024), 1, 1) + if self.acc_dtype == np.float32: + elsize = 4 + elif self.acc_dtype == np.float64: + elsize = 8 + if self.Ctmp is None or self.Ctmp.size < grid[0]: + self.Ctmp = gpuarray.zeros((grid[0],), dtype=self.acc_dtype) + Ctmp = self.Ctmp + if grid[0] == 1: + Ctmp = out + if np.iscomplexobj(B): + self.cdot_cuda(A, B, np.int32(A.size), Ctmp, + block=block, grid=grid, + shared=1024 * elsize, + stream=self.queue) + else: + self.dot_cuda(A, B, np.int32(A.size), Ctmp, + block=block, grid=grid, + shared=1024 * elsize, + stream=self.queue) + if grid[0] > 1: + self.full_reduce_cuda(self.Ctmp, out, np.int32(grid[0]), + block=(1024, 1, 1), grid=(1,1,1), shared=elsize*1024, + stream=self.queue) + + return out + + def norm2(self, A, out=None): + return self.dot(A, A, out) + +class TransposeKernel: + + def __init__(self, queue=None): + self.queue = queue + self.transpose_cuda = load_kernel("transpose", { + 'DTYPE': 'int', + 'BDIM': 16 + }) + + def transpose(self, input, output): + # only for int at the moment (addr array), and 2D (reshape pls) + if len(input.shape) != 2: + raise ValueError("Only 2D tranpose is supported - reshape as desired") + if input.shape[0] != output.shape[1] or input.shape[1] != output.shape[0]: + raise ValueError("Input/Output must be of flipped shape") + if input.dtype != np.int32 or output.dtype != np.int32: + raise ValueError("Only int types are supported at the moment") + + width = input.shape[1] + height = input.shape[0] + blk = (16, 16, 1) + grd = ( + int((input.shape[1] + 15)// 16), + int((input.shape[0] + 15)// 16), + 1 + ) + self.transpose_cuda(input, output, np.int32(width), np.int32(height), + block=blk, grid=grd, stream=self.queue) + +class MaxAbs2Kernel: + + def __init__(self, queue=None): + self.queue = queue + # we lazy-load this depending on the data types we get + self.max_abs2_cuda = {} + + def max_abs2(self, X, out): + """ Calculate max(abs(x)**2) across the final 2 dimensions""" + rows = np.int32(X.shape[-2]) + cols = np.int32(X.shape[-1]) + firstdims = np.int32(np.prod(X.shape[:-2])) + gy = int(rows) + # lazy-loading, keeping scratch memory and both kernels in the same dictionary + bx = int(64) + version = '{},{},{}'.format(map2ctype(X.dtype), map2ctype(out.dtype), gy) + if version not in self.max_abs2_cuda: + step1, step2 = load_kernel( + ("max_abs2_step1", "max_abs2_step2"), + { + 'IN_TYPE': map2ctype(X.dtype), + 'OUT_TYPE': map2ctype(out.dtype), + 'BDIM_X': bx, + }, "max_abs2.cu") + self.max_abs2_cuda[version] = { + 'step1': step1, + 'step2': step2, + 'scratchmem': gpuarray.empty((gy,), dtype=out.dtype) + } + + # if self.max_abs2_cuda[version]['scratchmem'] is None \ + # or self.max_abs2_cuda[version]['scratchmem'].shape[0] != gy: + # self.max_abs2_cuda[version]['scratchmem'] = + scratch = self.max_abs2_cuda[version]['scratchmem'] + + + self.max_abs2_cuda[version]['step1'](X, firstdims, rows, cols, scratch, + block=(bx, 1, 1), grid=(1, gy, 1), + stream=self.queue) + self.max_abs2_cuda[version]['step2'](scratch, np.int32(gy), out, + block=(bx, 1, 1), grid=(1, 1, 1), + stream=self.queue + ) + + +class CropPadKernel: + + def __init__(self, queue=None): + self.queue = queue + # we lazy-load this depending on the data types we get + self.fill3D_cuda = {} + + def fill3D(self, A, B, offset=[0, 0, 0]): + """ + Fill 3-dimensional array A with B. + """ + if A.ndim < 3 or B.ndim < 3: + raise ValueError('Input arrays must each be at least 3D') + assert A.ndim == B.ndim, "Input and Output must have the same number of dimensions." + ash = A.shape + bsh = B.shape + misfit = np.array(bsh) - np.array(ash) + assert not misfit[:-3].any(), "Input and Output must have the same shape everywhere but the last three axes." + + Alim = np.array(A.shape[-3:]) + Blim = np.array(B.shape[-3:]) + off = np.array(offset) + Ao = off.copy() + Ao[Ao < 0] = 0 + Bo = -off.copy() + Bo[Bo < 0] = 0 + assert (Bo < Blim).all() and (Ao < Alim).all(), "At least one dimension lacks overlap" + Ao = Ao.astype(np.int32) + Bo = Bo.astype(np.int32) + lengths = np.array([ + min(off[0] + Blim[0], Alim[0]) - Ao[0], + min(off[1] + Blim[1], Alim[1]) - Ao[1], + min(off[2] + Blim[2], Alim[2]) - Ao[2], + ], dtype=np.int32) + lengths2 = np.array([ + min(Alim[0] - off[0], Blim[0]) - Bo[0], + min(Alim[1] - off[1], Blim[1]) - Bo[1], + min(Alim[2] - off[2], Blim[2]) - Bo[2], + ], dtype=np.int32) + assert (lengths == lengths2).all(), "left and right lenghts are not matching" + batch = int(np.prod(A.shape[:-3])) + + # lazy loading depending on data type + version = '{},{}'.format(map2ctype(B.dtype), map2ctype(A.dtype)) + if version not in self.fill3D_cuda: + self.fill3D_cuda[version] = load_kernel("fill3D", { + 'IN_TYPE': map2ctype(B.dtype), + 'OUT_TYPE': map2ctype(A.dtype) + }) + bx = by = 32 + self.fill3D_cuda[version]( + A, B, + np.int32(A.shape[-3]), np.int32(A.shape[-2]), np.int32(A.shape[-1]), + np.int32(B.shape[-3]), np.int32(B.shape[-2]), np.int32(B.shape[-1]), + Ao[0], Ao[1], Ao[2], + Bo[0], Bo[1], Bo[2], + lengths[0], lengths[1], lengths[2], + block=(int(bx), int(by), int(1)), + grid=( + int((lengths[2] + bx - 1)//bx), + int((lengths[1] + by - 1)//by), + int(batch)), + stream=self.queue + ) + + + def crop_pad_2d_simple(self, A, B): + """ + Places B in A centered around the last two axis. A and B must be of the same shape + anywhere but the last two dims. + """ + assert A.ndim >= 2, "Arrays must have more than 2 dimensions." + assert A.ndim == B.ndim, "Input and Output must have the same number of dimensions." + misfit = np.array(A.shape) - np.array(B.shape) + assert not misfit[:-2].any(), "Input and Output must have the same shape everywhere but the last two axes." + if A.ndim == 2: + A = A.reshape((1,) + A.shape) + if B.ndim == 2: + B = B.reshape((1,) + B.shape) + a1, a2 = A.shape[-2:] + b1, b2 = B.shape[-2:] + offset = [0, a1 // 2 - b1 // 2, a2 // 2 - b2 // 2] + self.fill3D(A, B, offset) + + +class DerivativesKernel: + def __init__(self, dtype, queue=None): + if dtype == np.float32: + stype = "float" + elif dtype == np.complex64: + stype = "complex" + else: + raise NotImplementedError( + "delxf is only implemented for float32 and complex64") + + self.queue = queue + self.dtype = dtype + self.last_axis_block = (256, 4, 1) + self.mid_axis_block = (256, 4, 1) + + self.delxf_last, self.delxf_mid = load_kernel( + ("delx_last", "delx_mid"), + file="delx.cu", + subs={ + 'IS_FORWARD': 'true', + 'BDIM_X': str(self.last_axis_block[0]), + 'BDIM_Y': str(self.last_axis_block[1]), + 'IN_TYPE': stype, + 'OUT_TYPE': stype + }) + self.delxb_last, self.delxb_mid = load_kernel( + ("delx_last", "delx_mid"), + file="delx.cu", + subs={ + 'IS_FORWARD': 'false', + 'BDIM_X': str(self.last_axis_block[0]), + 'BDIM_Y': str(self.last_axis_block[1]), + 'IN_TYPE': stype, + 'OUT_TYPE': stype + }) + + + def delxf(self, input, out, axis=-1): + if input.dtype != self.dtype: + raise ValueError('Invalid input data type') + + if axis < 0: + axis = input.ndim + axis + axis = np.int32(axis) + + if axis == input.ndim - 1: + flat_dim = np.int32(np.product(input.shape[0:-1])) + self.delxf_last(input, out, flat_dim, np.int32(input.shape[axis]), + block=self.last_axis_block, + grid=( + int((flat_dim + + self.last_axis_block[1] - 1) // self.last_axis_block[1]), + 1, 1), + stream=self.queue + ) + else: + lower_dim = np.int32(np.product(input.shape[(axis+1):])) + higher_dim = np.int32(np.product(input.shape[:axis])) + gx = int( + (lower_dim + self.mid_axis_block[0] - 1) // self.mid_axis_block[0]) + gy = 1 + gz = int(higher_dim) + self.delxf_mid(input, out, lower_dim, higher_dim, np.int32(input.shape[axis]), + block=self.mid_axis_block, + grid=(gx, gy, gz), + stream=self.queue + ) + + def delxb(self, input, out, axis=-1): + if input.dtype != self.dtype: + raise ValueError('Invalid input data type') + + if axis < 0: + axis = input.ndim + axis + axis = np.int32(axis) + + if axis == input.ndim - 1: + flat_dim = np.int32(np.product(input.shape[0:-1])) + self.delxb_last(input, out, flat_dim, np.int32(input.shape[axis]), + block=self.last_axis_block, + grid=( + int((flat_dim + + self.last_axis_block[1] - 1) // self.last_axis_block[1]), + 1, 1), + stream=self.queue + ) + else: + lower_dim = np.int32(np.product(input.shape[(axis+1):])) + higher_dim = np.int32(np.product(input.shape[:axis])) + gx = int( + (lower_dim + self.mid_axis_block[0] - 1) // self.mid_axis_block[0]) + gy = 1 + gz = int(higher_dim) + self.delxb_mid(input, out, lower_dim, higher_dim, np.int32(input.shape[axis]), + block=self.mid_axis_block, + grid=(gx, gy, gz), + stream=self.queue + ) + + +class GaussianSmoothingKernel: + def __init__(self, queue=None, num_stdevs=4, kernel_type='float'): + if kernel_type not in ['float', 'double']: + raise ValueError('Invalid data type for kernel') + self.kernel_type = kernel_type + self.dtype = np.complex64 + self.stype = "complex" + self.queue = queue + self.num_stdevs = num_stdevs + self.blockdim_x = 4 + self.blockdim_y = 16 + + + # At least 2 blocks per SM + self.max_shared_per_block = 48 * 1024 // 2 + self.max_shared_per_block_complex = self.max_shared_per_block / 2 * np.dtype(np.float32).itemsize + self.max_kernel_radius = int(self.max_shared_per_block_complex / self.blockdim_y) + + self.convolution_row = load_kernel( + "convolution_row", file="convolution.cu", subs={ + 'BDIM_X': self.blockdim_x, + 'BDIM_Y': self.blockdim_y, + 'DTYPE': self.stype, + 'MATH_TYPE': self.kernel_type + }) + self.convolution_col = load_kernel( + "convolution_col", file="convolution.cu", subs={ + 'BDIM_X': self.blockdim_y, # NOTE: we swap x and y in this columns + 'BDIM_Y': self.blockdim_x, + 'DTYPE': self.stype, + 'MATH_TYPE': self.kernel_type + }) + # pre-allocate kernel memory on gpu, with max-radius to accomodate + dtype=np.float32 if self.kernel_type == 'float' else np.float64 + self.kernel_gpu = gpuarray.empty((self.max_kernel_radius,), dtype=dtype) + # keep track of previus radius and std to determine if we need to transfer again + self.r = 0 + self.std = 0 + + + def convolution(self, data, mfs, tmp=None): + """ + Calculates a stacked 2D convolution for smoothing, with the standard deviations + given in mfs (stdx, stdy). It works in-place in the data array, + and tmp is a gpu-allocated array of the same size and type as data, + used internally for temporary storage + """ + ndims = data.ndim + shape = data.shape + + # Create temporary array (if not given) + if tmp is None: + tmp = gpuarray.empty(shape, dtype=data.dtype) + assert shape == tmp.shape and data.dtype == tmp.dtype + + # Check input dimensions + if ndims == 3: + batches,y,x = shape + stdy, stdx = mfs + elif ndims == 2: + batches = 1 + y,x = shape + stdy, stdx = mfs + elif ndims == 1: + batches = 1 + y,x = shape[0],1 + stdy, stdx = mfs[0], 0.0 + else: + raise NotImplementedError("input needs to be of dimensions 0 < ndims <= 3") + + input = data + output = tmp + + # Row convolution kernel + # TODO: is this threshold acceptable in all cases? + if stdx > 0.1: + r = int(self.num_stdevs * stdx + 0.5) + if r > self.max_kernel_radius: + raise ValueError("Size of Gaussian kernel too large") + if r != self.r or stdx != self.std: + # recalculate + transfer + g = gaussian(np.arange(-r,r+1), stdx) + g /= g.sum() + k = np.ascontiguousarray(g[r:].astype(np.float32 if self.kernel_type == 'float' else np.float64)) + self.kernel_gpu[:r+1] = k[:] + self.r = r + self.std = stdx + + bx = self.blockdim_x + by = self.blockdim_y + + shared = (bx + 2*r) * by * np.dtype(np.complex64).itemsize + if shared > self.max_shared_per_block: + raise MemoryError("Cannot run kernel in shared memory") + + blk = (bx, by, 1) + grd = (int((y + bx -1)// bx), int((x + by-1)// by), batches) + self.convolution_row(input, output, np.int32(y), np.int32(x), self.kernel_gpu, np.int32(r), + block=blk, grid=grd, shared=shared, stream=self.queue) + + input = output + output = data + + # Column convolution kernel + # TODO: is this threshold acceptable in all cases? + if stdy > 0.1: + r = int(self.num_stdevs * stdy + 0.5) + if r > self.max_kernel_radius: + raise ValueError("Size of Gaussian kernel too large") + if r != self.r or stdy != self.std: + # recalculate + transfer + g = gaussian(np.arange(-r,r+1), stdy) + g /= g.sum() + k = np.ascontiguousarray(g[r:].astype(np.float32 if self.kernel_type == 'float' else np.float64)) + self.kernel_gpu[:r+1] = k[:] + self.r = r + self.std = stdy + + + bx = self.blockdim_y + by = self.blockdim_x + + shared = (by + 2*r) * bx * np.dtype(np.complex64).itemsize + if shared > self.max_shared_per_block: + raise MemoryError("Cannot run kernel in shared memory") + + blk = (bx, by, 1) + grd = (int((y + bx -1)// bx), int((x + by-1)// by), batches) + self.convolution_col(input, output, np.int32(y), np.int32(x), self.kernel_gpu, np.int32(r), + block=blk, grid=grd, shared=shared, stream=self.queue) + + # TODO: is this threshold acceptable in all cases? + if (stdx <= 0.1 and stdy <= 0.1): + return # nothing to do + elif (stdx > 0.1 and stdy > 0.1): + return # both parts have run, output is back in data + else: + data[:] = tmp[:] # only one of them has run, output is in tmp + +class ClipMagnitudesKernel: + + def __init__(self, queue=None): + self.queue = queue + self.clip_magnitudes_cuda = load_kernel("clip_magnitudes", { + 'IN_TYPE': 'complex', + }) + + def clip_magnitudes_to_range(self, array, clip_min, clip_max): + + cmin = np.float32(clip_min) + cmax = np.float32(clip_max) + + npixel = np.int32(np.prod(array.shape)) + bx = 256 + gx = int((npixel + bx - 1) // bx) + self.clip_magnitudes_cuda(array, cmin, cmax, + npixel, + block=(bx, 1, 1), + grid=(gx, 1, 1), + stream=self.queue) + +class MassCenterKernel: + + def __init__(self, queue=None): + self.queue = queue + self.threadsPerBlock = 256 + + self.indexed_sum_middim_cuda = load_kernel("indexed_sum_middim", + file="mass_center.cu", subs={ + 'IN_TYPE': 'float', + 'BDIM_X' : self.threadsPerBlock, + 'BDIM_Y' : 1, + } + ) + + self.indexed_sum_lastdim_cuda = load_kernel("indexed_sum_lastdim", + file="mass_center.cu", subs={ + 'IN_TYPE': 'float', + 'BDIM_X' : 32, + 'BDIM_Y' : 32, + } + ) + + self.final_sums_cuda = load_kernel("final_sums", + file="mass_center.cu", subs={ + 'IN_TYPE': 'float', + 'BDIM_X' : 256, + 'BDIM_Y' : 1, + } + ) + + def mass_center(self, array): + if array.dtype != np.float32: + raise NotImplementedError("mass_center is only implemented for float32") + + i = np.int32(array.shape[0]) + m = np.int32(array.shape[1]) + if array.ndim >= 3: + n = np.int32(array.shape[2]) + else: + n = np.int32(1) + + total_sum = gpuarray.sum(array, dtype=np.float32, stream=self.queue).get() + sc = np.float32(1. / total_sum.item()) + + i_sum = gpuarray.empty(array.shape[0], dtype=np.float32) + m_sum = gpuarray.empty(array.shape[1], dtype=np.float32) + n_sum = gpuarray.empty(int(n), dtype=np.float32) + out = gpuarray.empty(3 if n>1 else 2, dtype=np.float32) + + # sum all dims except the first, multiplying by the index and scaling factor + block_ = (self.threadsPerBlock, 1, 1) + grid_ = (int(i), 1, 1) + self.indexed_sum_middim_cuda(array, i_sum, np.int32(1), i, n*m, sc, + block=block_, + grid=grid_, + stream=self.queue, + shared=self.threadsPerBlock*4) + + if array.ndim >= 3: + # 3d case + # sum all dims, except the middle, multiplying by the index and scaling factor + block_ = (self.threadsPerBlock, 1, 1) + grid_ = (int(m), 1, 1) + self.indexed_sum_middim_cuda(array, m_sum, i, n, m, sc, + block=block_, + grid=grid_, + stream=self.queue, + shared=self.threadsPerBlock*4) + + # sum the all dims except the last, multiplying by the index and scaling factor + block_ = (32, 32, 1) + grid_ = (1, int(n + 32 - 1) // 32, 1) + self.indexed_sum_lastdim_cuda(array, n_sum, i*m, n, sc, + block=block_, + grid=grid_, + stream=self.queue, + shared=32*32*4) + else: + # 2d case + # sum the all dims except the last, multiplying by the index and scaling factor + block_ = (32, 32, 1) + grid_ = (1, int(m + 32 - 1) // 32, 1) + self.indexed_sum_lastdim_cuda(array, m_sum, i, m, sc, + block=block_, + grid=grid_, + stream=self.queue, + shared=32*32*4) + + block_ = (256, 1, 1) + grid_ = (3 if n>1 else 2, 1, 1) + self.final_sums_cuda(i_sum, i, m_sum, m, n_sum, n, out, + block=block_, + grid=grid_, + stream=self.queue, + shared=256*4) + + return out + +class Abs2SumKernel: + + def __init__(self, dtype, queue=None): + self.in_stype = map2ctype(dtype) + if self.in_stype == 'complex': + self.out_stype = 'float' + self.out_dtype = np.float32 + elif self.in_stype == 'copmlex': + self.out_stype = 'double' + self.out_dtype = np.float64 + else: + self.out_stype = self.in_stype + self.out_dtype = dtype + + self.queue = queue + self.threadsPerBlock = 32 + + self.abs2sum_cuda = load_kernel("abs2sum", subs={ + 'IN_TYPE': self.in_stype, + 'OUT_TYPE' : self.out_stype, + 'BDIM_X' : 32, + } + ) + + def abs2sum(self, array): + nmodes = np.int32(array.shape[0]) + row, col = array.shape[1:] + out = gpuarray.empty(array.shape[1:], dtype=self.out_dtype) + + block_ = (32, 1, 1) + grid_ = (1, row, 1) + self.abs2sum_cuda(array, nmodes, np.int32(row), np.int32(col), out, + block=block_, + grid=grid_, + stream=self.queue) + + return out + +class InterpolatedShiftKernel: + + def __init__(self, queue=None): + self.queue = queue + + self.integer_shift_cuda, self.linear_interpolate_cuda = load_kernel( + ("integer_shift_kernel", "linear_interpolate_kernel"), + file="interpolated_shift.cu", subs={ + 'IN_TYPE': 'complex', + 'OUT_TYPE': 'complex', + 'BDIM_X' : 32, + 'BDIM_Y' : 32, + } + ) + + def interpolate_shift(self, array, shift): + shift = np.asarray(shift, dtype=np.float32) + if len(shift) != 2: + raise NotImplementedError("Shift only applied to 2D array.") + if array.dtype != np.complex64: + raise NotImplementedError("Only complex single precision supported") + if array.ndim == 3: + items, rows, columns = array.shape + elif array.ndim == 2: + items, rows, columns = 1, *array.shape + else: + raise NotImplementedError("Only 2- or 3-dimensional arrays supported") + + offsetRow, offsetCol = shift + + offsetRowFrac, offsetRowInt = np.modf(offsetRow) + offsetColFrac, offsetColInt = np.modf(offsetCol) + + out = gpuarray.empty_like(array) + block_ = (32, 32, 1) + grid_ = ((rows + 31) // 32, (columns + 31) // 32, items) + + if np.abs(offsetRowFrac) < 1e-6 and np.abs(offsetColFrac) < 1e-6: + if offsetRowInt == 0 and offsetColInt == 0: + # no transformation at all + out = array + else: + # no fractional part, so we can just use a shifted copy + self.integer_shift_cuda(array, out, np.int32(rows), + np.int32(columns), np.int32(offsetRow), + np.int32(offsetCol), + block=block_, + grid=grid_, + stream=self.queue) + else: + self.linear_interpolate_cuda(array, out, np.int32(rows), + np.int32(columns), np.float32(offsetRow), + np.float32(offsetCol), + block=block_, + grid=grid_, + shared=(32+2)**2*8+32*(32+2)*8, + stream=self.queue) + + return out + diff --git a/ptypy/accelerate/cuda_pycuda/cuda/__init__.py b/ptypy/accelerate/cuda_pycuda/cuda/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/ptypy/accelerate/cuda_pycuda/cuda/abs2sum.cu b/ptypy/accelerate/cuda_pycuda/cuda/abs2sum.cu new file mode 100644 index 000000000..475a228bb --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/abs2sum.cu @@ -0,0 +1,29 @@ +/** abs2sum kernel, calculating the sum of abs(x)**2 value in the first dimension + * + * Data types: + * - IN_TYPE: can be float/double or complex/complex + * - OUT_TYPE: can be float/double + */ + +#include +using thrust::complex; + +extern "C" __global__ void abs2sum(const IN_TYPE* a, + const int n, + const int rows, + const int cols, + OUT_TYPE* out) +{ + int tx = threadIdx.x; + const int iy = blockIdx.y; + + for (int ix = tx; ix < cols; ix += BDIM_X) { + OUT_TYPE acc = OUT_TYPE(0); + for (int in = 0; in < n; ++in) { + OUT_TYPE tmp = abs(a[in * rows * cols + iy * cols + ix]); + acc += tmp * tmp; + } + out[iy * cols + ix] = acc; + } +} + diff --git a/ptypy/accelerate/cuda_pycuda/cuda/batched_multiply.cu b/ptypy/accelerate/cuda_pycuda/cuda/batched_multiply.cu new file mode 100644 index 000000000..1263841b6 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/batched_multiply.cu @@ -0,0 +1,37 @@ +/** This kernel was used for FFT pre- and post-scaling, + to test if cuFFT via python is worthwhile. + It turned out it wasn't. + * + * Data types: + * - IN_TYPE: the data type for the inputs + * - OUT_TYPE: the data type for the outputs + * - MATH_TYPE: the data type used for computation (filter) + */ + +#include +using thrust::complex; + +extern "C" __global__ void batched_multiply(const complex* input, + complex* output, + const complex* filter, + float scale, + int nBatches, + int rows, + int columns) +{ + int gx = threadIdx.x + blockIdx.x * blockDim.x; + int gy = threadIdx.y + blockIdx.y * blockDim.y; + int gz = threadIdx.z + blockIdx.z * blockDim.z; + + if (gx > columns || gy > rows || gz > nBatches) + return; + + auto val = input[gz * rows * columns + gy * rows + gx]; + if (MPY_DO_FILT) // set at compile-time + { + val *= filter[gy * rows + gx]; + } + if (MPY_DO_SCALE) // set at compile-time + val *= scale; + output[gz * rows * columns + gy * rows + gx] = val; +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/build_aux.cu b/ptypy/accelerate/cuda_pycuda/cuda/build_aux.cu new file mode 100644 index 000000000..e9ceeb80c --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/build_aux.cu @@ -0,0 +1,99 @@ +/** build_aux kernel. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double - for aux wave) + * - MATH_TYPE: the data type used for computation + */ + +#include +using thrust::complex; + +// core calculation function - used by both kernels and inlined +inline __device__ complex calculate( + const complex& t_obj, + const complex& t_probe, + const complex& t_ex, + MATH_TYPE alpha) +{ + return t_obj * t_probe * (MATH_TYPE(1) + alpha) - t_ex * alpha; +} + +extern "C" __global__ void build_aux( + complex* auxiliary_wave, + const complex* __restrict__ exit_wave, + int B, + int C, + const complex* __restrict__ probe, + int E, + int F, + const complex* __restrict__ obj, + int H, + int I, + const int* __restrict__ addr, + IN_TYPE alpha_) +{ + int bid = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + int addr_stride = 15; + const MATH_TYPE alpha = alpha_; // type conversion + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + exit_wave += ea[0] * B * C; + auxiliary_wave += ea[0] * B * C; + + for (int b = ty; b < B; b += blockDim.y) + { +#pragma unroll(4) // we use blockDim.x = 32, and C is typically more than 128 + // (it will work for less as well) + for (int c = tx; c < C; c += blockDim.x) + { + auxiliary_wave[b * C + c] = calculate( + obj[b * I + c], probe[b * F + c], exit_wave[b * C + c], alpha); + } + } +} + +extern "C" __global__ void build_aux2( + complex* auxiliary_wave, + const complex* __restrict__ exit_wave, + int B, + int C, + const complex* __restrict__ probe, + int E, + int F, + const complex* __restrict__ obj, + int H, + int I, + const int* __restrict__ addr, + IN_TYPE alpha_) +{ + int bid = blockIdx.z; + int tx = threadIdx.x; + int b = threadIdx.y + blockIdx.y * blockDim.y; + if (b >= B) + return; + int addr_stride = 15; + const MATH_TYPE alpha = alpha_; // type conversion + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + exit_wave += ea[0] * B * C; + auxiliary_wave += ea[0] * B * C; + + for (int c = tx; c < C; c += blockDim.x) + { + auxiliary_wave[b * C + c] = calculate( + obj[b * I + c], probe[b * F + c], exit_wave[b * C + c], alpha); + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/build_aux_no_ex.cu b/ptypy/accelerate/cuda_pycuda/cuda/build_aux_no_ex.cu new file mode 100644 index 000000000..ee091c58e --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/build_aux_no_ex.cu @@ -0,0 +1,103 @@ +/** build_aux without exit wave kernel. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double - for aux wave) + * - MATH_TYPE: the data type used for computation + */ + +#include +using thrust::complex; + +extern "C" __global__ void build_aux_no_ex(complex* auxilliary_wave, + int aRows, + int aCols, + const complex* __restrict__ probe, + int pRows, + int pCols, + const complex* __restrict__ obj, + int oRows, + int oCols, + const int* __restrict__ addr, + IN_TYPE fac_, + int doAdd) +{ + int bid = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + const int addr_stride = 15; + const MATH_TYPE fac = fac_; // type conversion + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + obj += oa[0] * oRows * oCols + oa[1] * oCols + oa[2]; + probe += pa[0] * pRows * pCols + pa[1] * pCols + pa[2]; + auxilliary_wave += ea[0] * aRows * aCols; + + for (int b = ty; b < aRows; b += blockDim.y) + { +# pragma unroll(4) + for (int c = tx; c < aCols; c += blockDim.x) + { + complex t_obj = obj[b * oCols + c]; + complex t_probe = probe[b * pCols + c]; + auto tmp = t_obj * t_probe * fac; + if (doAdd) + { + auxilliary_wave[b * aCols + c] += tmp; + } + else + { + auxilliary_wave[b * aCols + c] = tmp; + } + } + } +} + +extern "C" __global__ void build_aux2_no_ex(complex* auxilliary_wave, + int aRows, + int aCols, + const complex* __restrict__ probe, + int pRows, + int pCols, + const complex* __restrict__ obj, + int oRows, + int oCols, + const int* __restrict__ addr, + IN_TYPE fac_, + int doAdd) +{ + int bid = blockIdx.z; + int tx = threadIdx.x; + int b = threadIdx.y + blockIdx.y * blockDim.y; + if (b >= aRows) + return; + const int addr_stride = 15; + const MATH_TYPE fac = fac_; // type conversion + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + obj += oa[0] * oRows * oCols + oa[1] * oCols + oa[2]; + probe += pa[0] * pRows * pCols + pa[1] * pCols + pa[2]; + auxilliary_wave += ea[0] * aRows * aCols; + + for (int c = tx; c < aCols; c += blockDim.x) + { + complex t_obj = obj[b * oCols + c]; + complex t_probe = probe[b * pCols + c]; + auto tmp = t_obj * t_probe * fac; + if (doAdd) + { + auxilliary_wave[b * aCols + c] += tmp; + } + else + { + auxilliary_wave[b * aCols + c] = tmp; + } + } + +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/build_aux_position_correction.cu b/ptypy/accelerate/cuda_pycuda/cuda/build_aux_position_correction.cu new file mode 100644 index 000000000..327040371 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/build_aux_position_correction.cu @@ -0,0 +1,46 @@ +/** build_aux for position correction. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double - for aux wave) + * - MATH_TYPE: the data type used for computation + */ + +#include +using thrust::complex; + +extern "C" __global__ void build_aux_position_correction( + complex* auxiliary_wave, + const complex* __restrict__ probe, + int B, + int C, + const complex* __restrict__ obj, + int H, + int I, + const int* __restrict__ addr) +{ + int bid = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + int addr_stride = 15; + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * B * C + pa[1] * C + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + auxiliary_wave += ea[0] * B * C; + + for (int b = ty; b < B; b += blockDim.y) + { +#pragma unroll(4) // we use blockDim.x = 32, and C is typically more than 128 + // (it will work for less as well) + for (int c = tx; c < C; c += blockDim.x) + { + complex t_obj = obj[b * I + c]; + complex t_probe = probe[b * C + c]; + auxiliary_wave[b * C + c] = t_obj * t_probe; + } + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/build_exit.cu b/ptypy/accelerate/cuda_pycuda/cuda/build_exit.cu new file mode 100644 index 000000000..2b98634dc --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/build_exit.cu @@ -0,0 +1,65 @@ +/** build_exit kernel. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double - for aux wave) + * - MATH_TYPE: the data type used for computation + */ + + +#include +using thrust::complex; + +template +__device__ inline void atomicAdd(complex* x, complex y) +{ + auto xf = reinterpret_cast(x); + atomicAdd(xf, y.real()); + atomicAdd(xf + 1, y.imag()); +} + +extern "C" __global__ void build_exit(complex* auxiliary_wave, + complex* exit_wave, + int B, + int C, + const complex* __restrict__ probe, + int E, + int F, + const complex* __restrict__ obj, + int H, + int I, + const int* __restrict__ addr, + IN_TYPE alpha_) +{ + int bid = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + const int addr_stride = 15; + const MATH_TYPE alpha = alpha_; // type conversion + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + exit_wave += ea[0] * B * C; + auxiliary_wave += ea[0] * B * C; + + for (int b = ty; b < B; b += blockDim.y) + { +#pragma unroll(4) // we use blockDim.x = 32, and C is typically more than 128 + // (it will work for less as well) + for (int c = tx; c < C; c += blockDim.x) + { + complex auxv = auxiliary_wave[b * C + c]; + complex t_probe = probe[b * F + c]; + complex t_obj = obj[b * I + c]; + complex t_exit = exit_wave[b * C + c]; + auxv -= alpha * t_probe * t_obj; + auxv += (alpha - 1) * t_exit; + exit_wave[b * C + c] += auxv; + auxiliary_wave[b * C + c] = auxv; + } + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/build_exit_alpha_tau.cu b/ptypy/accelerate/cuda_pycuda/cuda/build_exit_alpha_tau.cu new file mode 100644 index 000000000..8528f2e9c --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/build_exit_alpha_tau.cu @@ -0,0 +1,60 @@ +/** build_exit_alpha_tau kernel. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double - for aux wave) + * - MATH_TYPE: the data type used for computation + */ + + +#include +using thrust::complex; + + +extern "C" __global__ void build_exit_alpha_tau( + complex* auxiliary_wave, + complex* exit_wave, + int B, + int C, + const complex* __restrict__ probe, + int E, + int F, + const complex* __restrict__ obj, + int H, + int I, + const int* __restrict__ addr, + IN_TYPE alpha_, + IN_TYPE tau_) +{ + int bid = blockIdx.z; + int tx = threadIdx.x; + const int b = threadIdx.y + blockIdx.y * blockDim.y; + if (b >= B) + return; + const int addr_stride = 15; + MATH_TYPE alpha = alpha_; + MATH_TYPE tau = tau_; + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + exit_wave += ea[0] * B * C; + auxiliary_wave += ea[0] * B * C; + + for (int c = tx; c < C; c += blockDim.x) + { + complex t_aux = auxiliary_wave[b * C + c]; + complex t_probe = probe[b * F + c]; + complex t_obj = obj[b * I + c]; + complex t_ex = exit_wave[b * C + c]; + + auto dex = tau * t_aux + (tau * alpha - MATH_TYPE(1)) * t_ex + + (MATH_TYPE(1) - tau * (MATH_TYPE(1) + alpha)) * t_obj * t_probe; + + exit_wave[b * C + c] += dex; + auxiliary_wave[b * C + c] = dex; + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/clip_magnitudes.cu b/ptypy/accelerate/cuda_pycuda/cuda/clip_magnitudes.cu new file mode 100644 index 000000000..8128091f9 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/clip_magnitudes.cu @@ -0,0 +1,30 @@ +/** clip_magnitudes. + * + */ + #include + #include + #include + using thrust::complex; + + extern "C" __global__ void clip_magnitudes(IN_TYPE *arr, + float clip_min, + float clip_max, + int N) +{ + int id = threadIdx.x + blockIdx.x * blockDim.x; + + if (id >= N) + return; + + auto v = arr[id]; + auto mag = abs(v); + auto theta = arg(v); + + if (mag > clip_max) + mag = clip_max; + if (mag < clip_min) + mag = clip_min; + + v = thrust::polar(mag, theta); + arr[id] = v; +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/convolution.cu b/ptypy/accelerate/cuda_pycuda/cuda/convolution.cu new file mode 100644 index 000000000..ae42ecba5 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/convolution.cu @@ -0,0 +1,190 @@ +/** + * Data types: + * - DTYPE (float/double/complex/complex) + * - MATH_TYPE (float/double) - used for the convolution kernel itself + * + * A symmetric convolution kernel is assumed here + */ + +#include +using thrust::complex; + +/** Implements reflect-mode index wrapping + * + * maps indexes like this (reflects on both ends): + * Extension | Input | Extension + * 5 6 6 5 4 3 2 | 2 3 4 5 6 | 6 5 4 3 2 2 3 4 5 6 6 + * + */ + class IndexReflect + { + public: + /** Create index range. maxX is not included in the valid range, + * i.e., the range is [minX, maxX) + */ + __device__ IndexReflect(int minX, int maxX) : maxX_(maxX), minX_(minX) {} + + /// Map given index to the valid range using reflect mode + __device__ int operator()(int idx) const + { + if (idx < maxX_ && idx >= minX_) + return idx; + auto ddd = (idx - minX_) / (maxX_ - minX_); + auto mmm = (idx - minX_) % (maxX_ - minX_); + if (mmm < 0) + mmm = -mmm - 1; + // if odd it goes backwards from max + // if even it goes upwards from min + return ddd % 2 == 0 ? minX_ + mmm : maxX_ - mmm - 1; + } + + private: + int maxX_, minX_; + }; + + +/* +Row convolution kernel +*/ +extern "C" __global__ void convolution_row(const DTYPE *__restrict__ input, + DTYPE *output, + int height, + int width, + const MATH_TYPE* kernel, + int kernel_radius) +{ + int tx = threadIdx.x; + int ty = threadIdx.y; + int bx = blockIdx.x; + int by = blockIdx.y; + + // offset for batch + input += width * height * blockIdx.z; + output += width * height * blockIdx.z; + + // reinterpret to avoid compiler warning that + // constructor of complex() cannot be called if it's + // shared memory - polluting the outputs + extern __shared__ char shr[]; + auto shm = reinterpret_cast(shr); + + // Offset to block start of core area + int gbx = bx * BDIM_X; + int gby = by * BDIM_Y; + int start = gbx * width + gby; + input += start; + output += start; + + // width of shared memory + int shwidth = BDIM_Y + 2 * kernel_radius; + + // only do this if row index is in range + // (need to keep threads with us, so that synchthreads below doesn't deadlock) + if (gbx + tx < height) + { + // main data (center point for each thread) - reflecting as needed + IndexReflect ind(-gby, width - gby); + shm[tx * shwidth + (kernel_radius + ty)] = input[tx * width + ind(ty)]; + + // left halo (kernel radius before) + for (int i = ty - kernel_radius; i < 0; i += BDIM_Y) + { + shm[tx * shwidth + (i + kernel_radius)] = input[tx * width + ind(i)]; + } + + // right halo (kernel radius after) + for (int i = ty + BDIM_Y; i < BDIM_Y + kernel_radius; i += BDIM_Y) + { + shm[tx * shwidth + (i + kernel_radius)] = input[tx * width + ind(i)]; + } + } + + __syncthreads(); + + // safe to return now, after syncing + if (gby + ty >= width || gbx + tx >= height) + return; + + // compute - will be complex if kernel is double + auto sum = shm[tx * shwidth + (ty + kernel_radius)] * kernel[0]; + for (int i = 1; i <= kernel_radius; ++i) + { + sum += (shm[tx * shwidth + (ty + i + kernel_radius)] + + shm[tx * shwidth + (ty - i + kernel_radius)]) * + kernel[i]; + } + + output[tx * width + ty] = sum; +} + + +/* +Column convolution kernel +*/ +extern "C" __global__ void convolution_col(const DTYPE *__restrict__ input, + DTYPE *output, + int height, + int width, + const MATH_TYPE* kernel, + int kernel_radius) +{ + int tx = threadIdx.x; + int ty = threadIdx.y; + int bx = blockIdx.x; + int by = blockIdx.y; + + // offset for batch + input += width * height * blockIdx.z; + output += width * height * blockIdx.z; + + // reinterpret to avoid compiler warning that + // constructor of complex() cannot be called if it's + // shared memory - polluting the outputs + extern __shared__ char shr[]; + auto shm = reinterpret_cast(shr); + + // Offset to block start of core area + int gbx = bx * BDIM_X; + int gby = by * BDIM_Y; + int start = gbx * width + gby; + input += start; + output += start; + + // only do this if column index is in range + // (need to keep threads with us, so that synchthreads below doesn't deadlock) + if (gby + ty < width) + { + // main data (center point for each thread) - reflecting if needed + IndexReflect ind(-gbx, height - gbx); + shm[(kernel_radius + tx) * BDIM_Y + ty] = input[ind(tx) * width + ty]; + + // upper halo (kernel radius before) + for (int i = tx - kernel_radius; i < 0; i += BDIM_X) + { + shm[(i + kernel_radius) * BDIM_Y + ty] = input[ind(i) * width + ty]; + } + + // lower halo (kernel radius after) + for (int i = tx + BDIM_X; i < BDIM_X + kernel_radius; i += BDIM_X) + { + shm[(i + kernel_radius) * BDIM_Y + ty] = input[ind(i) * width + ty]; + } + } + + __syncthreads(); + + // safe to return now, after syncing + if (gby + ty >= width || gbx + tx >= height) + return; + + // compute - will be complex if kernel is double + auto sum = shm[(tx + kernel_radius) * BDIM_Y + ty] * kernel[0]; + for (int i = 1; i <= kernel_radius; ++i) + { + sum += (shm[(tx + i + kernel_radius) * BDIM_Y + ty] + + shm[(tx - i + kernel_radius) * BDIM_Y + ty]) * + kernel[i]; + } + + output[tx * width + ty] = sum; +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/delx.cu b/ptypy/accelerate/cuda_pycuda/cuda/delx.cu new file mode 100644 index 000000000..f2e8a934e --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/delx.cu @@ -0,0 +1,210 @@ +/** difference along axes (last and mid axis kernels) + * + * Data types: + * - IN_TYPE: the data type for the inputs + * - OUT_TYPE: the data type for the outputs + */ + +#include +using thrust::complex; + + +/** Finite difference for forward/backward for any axis that is not the + * last one, assuring that the reads and writes are coalesced. + * + * The idea is that arrays of any number of dimensions can be reshaped + * (or just treated) as 3D, with the higher dimensions and lower dimensions + * multiplied together and the axis along which we differentiate in the middle. + * The higher dim might also be 1, capturing the case when we compute along + * the zero axis. + * + * We use the following variables: + * - higher_dim: sizes of the axes left of the diff axis multiplied together + * - axis_dim: the size along the axis we diff over + * - lower_dim: the sizes of the axes right of the diff axis multiplied together + * + * Examples: + * - 5x3x10, axis=1: higher_dim=5, axis_dim=3, lower_dim=10 + * - 10x5x4x3, axis=1: higher_dim=10, axis_dim=5, lower_dim=12 + * - 10x5x4x3, axis=0: higher_dim=1, axis_dim=10, lower_dim=60 + * - 30x40, axis=0: higher_dim=1, axis_dim=30, lower_dim=40 + * + * The thread/block dimensions are mapped as: + * z = high_dim, + * y = axis_dim, + * x = lower_dim + * + * We read tiles of the input into BDIM_Y x BDIM_X elements of shared memory, + * always using a single thread block along the y dimension (axis_dim), + * which iterates over the full axis in a loop. The other 2 dimensions are + * fully parallelised in different thread blocks. + * Data reads/writes into shared mem are coalesced since the ix index + * corresponding to the threadIdx.x is used to read the lower_dim, with no + * multiplier on the index. + * + * Once the tile is in shared memory, the difference is calculated - + * depending on forward/backward diffs, and with special cases at the + * end of the tile - either overlapping with next block or ensuring a + * zero if it's the end of the input. + * + */ +extern "C" __global__ void delx_mid(const IN_TYPE *__restrict__ input, + OUT_TYPE *output, + int lower_dim, // x for 3D + int higher_dim, // z for 3D + int axis_dim) +{ + // reinterpret to avoid compiler warning that + // constructor of complex() cannot be called if it's + // shared memory - polluting the outputs + __shared__ char shr[BDIM_X * BDIM_Y * sizeof(IN_TYPE)]; + auto shared_data = reinterpret_cast(shr); + + unsigned int tx = threadIdx.x; + unsigned int ty = threadIdx.y; + unsigned int tz = threadIdx.z; // only 0 here + + unsigned int ix = tx + blockIdx.x * BDIM_X; + unsigned int iy = ty; + unsigned int iz = tz + blockIdx.z * blockDim.z; + + // offset pointers for z dimension (higher-dim) + input += iz * axis_dim * lower_dim; + output += iz * axis_dim * lower_dim; + + // now read x/y tiles coalesced and perform difference along y, + // letting this thread block iterate along the full y axis + // to give a thread a bit more substantial work to do. + auto maxblocks = (axis_dim + BDIM_Y - 1) / BDIM_Y; + for (int bidx = 0; bidx < maxblocks; ++bidx) + { + iy = ty + bidx * BDIM_Y; + + if (iy < axis_dim && ix < lower_dim) + { + shared_data[ty * BDIM_X + tx] = input[iy * lower_dim + ix]; + } + __syncthreads(); + + if (iy < axis_dim && ix < lower_dim) + { + if (IS_FORWARD) + { + IN_TYPE plus1; + if (ty < BDIM_Y - 1 && + iy < axis_dim - 1) // we have a next element in shared data + { + plus1 = shared_data[(ty + 1) * BDIM_X + tx]; + } + else if (iy == axis_dim - 1) // end of axis + { + plus1 = shared_data[ty * BDIM_X + tx]; // make sure it's zero + } + else // end of block, but nore input is there + { + plus1 = input[(iy + 1) * lower_dim + ix]; + } + output[iy * lower_dim + ix] = plus1 - shared_data[ty * BDIM_X + tx]; + } + else + { + IN_TYPE minus1; + if (ty > 0) // we have a previous element in shared + { + minus1 = shared_data[(ty - 1) * BDIM_X + tx]; + } + else if (iy == 0) // use same as next to get zero + { + minus1 = shared_data[ty * BDIM_X + tx]; + } + else // read previous input (ty == 0 but iy > 0) + { + minus1 = input[(iy - 1) * lower_dim + ix]; + } + output[iy * lower_dim + ix] = shared_data[ty * BDIM_X + tx] - minus1; + } + } + } +} + + + +/** This is the special case for when we diff along the last axis. + * + * Here, flat_dim is all other dims multiplied together, and axis_dim + * is the dimension along which we diff. + * To ensure that we stay coalesced (compared to delx_mid), + * we use the x index to iterate within each thread block (the loop). + * Otherwise it follows the same ideas as delx_mid - please read the + * description there. + */ +extern "C" __global__ void delx_last(const IN_TYPE *__restrict__ input, + OUT_TYPE *output, + int flat_dim, + int axis_dim) +{ + // reinterpret to avoid constructor of complex() + compiler warning + __shared__ char shr[BDIM_X * BDIM_Y * sizeof(IN_TYPE)]; + auto shared_data = reinterpret_cast(shr); + + unsigned int tx = threadIdx.x; + unsigned int ty = threadIdx.y; + + unsigned int ix = tx; + unsigned int iy = ty + blockIdx.x * BDIM_Y; // we always use x in grid + + int stride_y = axis_dim; + + auto maxblocks = (axis_dim + BDIM_X - 1) / BDIM_X; + for (int bidx = 0; bidx < maxblocks; ++bidx) + { + ix = tx + bidx * BDIM_X; + + if (iy < flat_dim && ix < axis_dim) + { + shared_data[ty * BDIM_X + tx] = input[iy * stride_y + ix]; + } + + __syncthreads(); + + if (iy < flat_dim && ix < axis_dim) + { + if (IS_FORWARD) + { + IN_TYPE plus1; + if (tx < BDIM_X - 1 && + ix < axis_dim - 1) // we have a next element in shared data + { + plus1 = shared_data[ty * BDIM_X + tx + 1]; + } + else if (ix == axis_dim - 1) // end of axis - same as current to get 0 + { + plus1 = shared_data[ty * BDIM_X + tx]; + } + else // end of block, but nore input is there + { + plus1 = input[iy * stride_y + ix + 1]; + } + + output[iy * stride_y + ix] = plus1 - shared_data[ty * BDIM_X + tx]; + } + else + { + IN_TYPE minus1; + if (tx > 0) // we have a previous element in shared + { + minus1 = shared_data[ty * BDIM_X + tx - 1]; + } + else if (ix == 0) // use same as next to get zero + { + minus1 = shared_data[ty * BDIM_X + tx]; + } + else // read previous input (ty == 0 but iy > 0) + { + minus1 = input[iy * stride_y + ix - 1]; + } + output[iy * stride_y + ix] = shared_data[ty * BDIM_X + tx] - minus1; + } + } + } +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/dot.cu b/ptypy/accelerate/cuda_pycuda/cuda/dot.cu new file mode 100644 index 000000000..21087abe3 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/dot.cu @@ -0,0 +1,56 @@ +#include +#include +using thrust::complex; + +template +__device__ inline T dotmul(const T& a, const T& b) +{ + return a * b; +} + +template +__device__ inline T dotmul(const complex& a, const complex& b) +{ + //return (a * conj(b)).real(); + return a.real() * b.real() + a.imag() * b.imag(); +} + +extern "C" __global__ void dot(const IN_TYPE* a, + const IN_TYPE* b, + int size, + ACC_TYPE* out) +{ + int tx = threadIdx.x; + int ix = tx + blockIdx.x * blockDim.x; + + __shared__ ACC_TYPE sh[1024]; + + if (ix < size) + { + sh[tx] = dotmul(a[ix], b[ix]); + } + else + { + sh[tx] = ACC_TYPE(0); + } + __syncthreads(); + + int nt = blockDim.x; + int c = nt; + + while (c > 1) + { + int half = c / 2; + if (tx < half) + { + sh[tx] += sh[c - tx - 1]; + } + __syncthreads(); + c = c - half; + } + + if (tx == 0 && ix < size) + { + out[blockIdx.x] = sh[0]; + } +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/error_reduce.cu b/ptypy/accelerate/cuda_pycuda/cuda/error_reduce.cu new file mode 100644 index 000000000..91b5357b4 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/error_reduce.cu @@ -0,0 +1,56 @@ +/** error_reduce kernel. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - ACC_TYPE: the data type used for computation + */ + +extern "C" __global__ void error_reduce(const IN_TYPE* ferr, + OUT_TYPE* err_fmag, + int M, + int N) +{ + int tx = threadIdx.x; + int ty = threadIdx.y; + int batch = blockIdx.x; + __shared__ ACC_TYPE sum_v[BDIM_X*BDIM_Y]; + + int shidx = + ty * blockDim.x + tx; // shidx: index in shared memory for this block + ACC_TYPE sum = ACC_TYPE(0.0); + + for (int m = ty; m < M; m += blockDim.y) + { +#pragma unroll(4) + for (int n = tx; n < N; n += blockDim.x) + { + int idx = batch * M * N + m * N + + n; // idx is index qwith respect to the full stack + sum += ACC_TYPE(ferr[idx]); + } + } + + sum_v[shidx] = sum; + + __syncthreads(); + + int nt = BDIM_X * BDIM_Y; + int c = nt; + + while (c > 1) + { + int half = c / 2; + if (shidx < half) + { + sum_v[shidx] += sum_v[c - shidx - 1]; + } + __syncthreads(); + c = c - half; + } + + if (shidx == 0) + { + err_fmag[batch] = OUT_TYPE(sum_v[0]); + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/exit_error.cu b/ptypy/accelerate/cuda_pycuda/cuda/exit_error.cu new file mode 100644 index 000000000..fdac52e46 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/exit_error.cu @@ -0,0 +1,47 @@ +#include +#include +#include +using std::sqrt; +using thrust::abs; +using thrust::complex; + +// specify max number of threads/block and min number of blocks per SM, +// to assist the compiler in register optimisations. +// We achieve a higher occupancy in this case, as less registers are used +// (guided by profiler) +extern "C" __global__ void __launch_bounds__(1024, 2) + exit_error(int nmodes, + const complex * __restrict aux, + OUT_TYPE *ferr, + const int * __restrict addr, + int A, + int B) +{ + int tx = threadIdx.x; + int ty = threadIdx.y; + int addr_stride = 15; + MATH_TYPE denom = A * B; + + const int *ea = addr + 6 + (blockIdx.x * nmodes) * addr_stride; + const int *da = addr + 9 + (blockIdx.x * nmodes) * addr_stride; + + aux += ea[0] * A * B; + ferr += da[0] * A * B; + + for (int a = ty; a < A; a += blockDim.y) + { + for (int b = tx; b < B; b += blockDim.x) + { + MATH_TYPE acc = 0.0; + for (int idx = 0; idx < nmodes; ++idx) + { + complex t_aux = aux[a * B + b + idx * A * B]; + MATH_TYPE abs_exit_wave = abs(t_aux); + acc += abs_exit_wave * + abs_exit_wave; // if we do this manually (real*real +imag*imag) + // we get differences to numpy due to rounding + } + ferr[a * B + b] = OUT_TYPE(acc / denom); + } + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/fill3D.cu b/ptypy/accelerate/cuda_pycuda/cuda/fill3D.cu new file mode 100644 index 000000000..c3f03d8ca --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/fill3D.cu @@ -0,0 +1,60 @@ +/** fill3D kernel. + * + * Data types: + * - IN_TYPE: the data type for the inputs + * - OUT_TYPE: data type for outputs + */ + +#include +#include +using thrust::complex; + +extern "C" __global__ void fill3D( + OUT_TYPE* A, + const IN_TYPE* B, + // final dimensions of A/B in [z, y, x] + int A_Z, + int A_Y, + int A_X, + int B_Z, + int B_Y, + int B_X, + // offsets to start reading/writing + int Ao_z, + int Ao_y, + int Ao_x, + int Bo_z, + int Bo_y, + int Bo_x, + // lengths to copy + int len_z, + int len_y, + int len_x + ) +{ + // We use the following strategy: + // - BlockIdx.z for the batch (first dims combined if 4D+) + // - blockDim.z = 1 + // - multiple blocks are used across y and x dimensions + // - we loop over z dimension within the thread block + int batch = blockIdx.z; + int ix = threadIdx.x + blockIdx.x * blockDim.x; + int iy = threadIdx.y + blockIdx.y * blockDim.y; + + if (ix >= len_x || iy >= len_y) + return; + + // offset for current batch (4D+ dimension) + A += batch * A_X * A_Y * A_Z; + B += batch * B_X * B_Y * B_Z; + + // offset for start position in each dimension of the last 3 + A += Ao_z * A_Y * A_X + Ao_y * A_X + Ao_x; + B += Bo_z * B_Y * B_X + Bo_y * B_X + Bo_x; + + // copy data + for (int iz = 0; iz < len_z; ++iz) { + A[iz * A_Y * A_X + iy * A_X + ix] = + B[iz * B_Y * B_X + iy * B_X + ix]; + } +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/fill_b.cu b/ptypy/accelerate/cuda_pycuda/cuda/fill_b.cu new file mode 100644 index 000000000..46d0d09f1 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/fill_b.cu @@ -0,0 +1,105 @@ +/** fill_b kernels. + * Data types: + * - IN_TYPE: the data type for the inputs + * - OUT_TYPE: the data type for the outputs + * - MATH_TYPE: the data type used for computation + * - ACC_TYPE: the accumulator type for summing + */ + +extern "C" __global__ void fill_b(const IN_TYPE* A0, + const IN_TYPE* A1, + const IN_TYPE* A2, + const IN_TYPE* w, + IN_TYPE Brenorm, + int size, + ACC_TYPE* out) +{ + int tx = threadIdx.x; + int ix = tx + blockIdx.x * blockDim.x; + __shared__ ACC_TYPE smem[3][BDIM_X]; + + if (ix < size) + { + // MATHTYPE(2) to make sure it's float in single precision and doesn't + // accidentally promote the equation to double + MATH_TYPE t_a0 = A0[ix]; + MATH_TYPE t_a1 = A1[ix]; + MATH_TYPE t_a2 = A2[ix]; + MATH_TYPE t_w = w[ix]; + smem[0][tx] = t_w * t_a0 * t_a0; + smem[1][tx] = t_w * MATH_TYPE(2) * t_a0 * t_a1; + smem[2][tx] = t_w * (t_a1 * t_a1 + MATH_TYPE(2) * t_a0 * t_a2); + } + else + { + smem[0][tx] = ACC_TYPE(0); + smem[1][tx] = ACC_TYPE(0); + smem[2][tx] = ACC_TYPE(0); + } + __syncthreads(); + + int nt = blockDim.x; + int c = nt; + while (c > 1) + { + int half = c / 2; + if (tx < half) + { + smem[0][tx] += smem[0][c - tx - 1]; + smem[1][tx] += smem[1][c - tx - 1]; + smem[2][tx] += smem[2][c - tx - 1]; + } + __syncthreads(); + c = c - half; + } + + if (tx == 0) + { + out[blockIdx.x * 3 + 0] = MATH_TYPE(smem[0][0]) * MATH_TYPE(Brenorm); + out[blockIdx.x * 3 + 1] = MATH_TYPE(smem[1][0]) * MATH_TYPE(Brenorm); + out[blockIdx.x * 3 + 2] = MATH_TYPE(smem[2][0]) * MATH_TYPE(Brenorm); + } +} + +extern "C" __global__ void fill_b_reduce(const ACC_TYPE* in, OUT_TYPE* B, int blocks) +{ + // always a single thread block for 2nd stage + assert(gridDim.x == 1); + int tx = threadIdx.x; + + __shared__ ACC_TYPE smem[3][BDIM_X]; + + double sum0 = 0.0, sum1 = 0.0, sum2 = 0.0; + for (int ix = tx; ix < blocks; ix += blockDim.x) + { + sum0 += in[ix * 3 + 0]; + sum1 += in[ix * 3 + 1]; + sum2 += in[ix * 3 + 2]; + } + smem[0][tx] = sum0; + smem[1][tx] = sum1; + smem[2][tx] = sum2; + __syncthreads(); + + int nt = blockDim.x; + int c = nt; + while (c > 1) + { + int half = c / 2; + if (tx < half) + { + smem[0][tx] += smem[0][c - tx - 1]; + smem[1][tx] += smem[1][c - tx - 1]; + smem[2][tx] += smem[2][c - tx - 1]; + } + __syncthreads(); + c = c - half; + } + + if (tx == 0) + { + B[0] += OUT_TYPE(smem[0][0]); + B[1] += OUT_TYPE(smem[1][0]); + B[2] += OUT_TYPE(smem[2][0]); + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/fmag_all_update.cu b/ptypy/accelerate/cuda_pycuda/cuda/fmag_all_update.cu new file mode 100644 index 000000000..f8f695ca5 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/fmag_all_update.cu @@ -0,0 +1,62 @@ +/** fmag_all_update. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + */ + +#include +#include +using std::sqrt; +using thrust::complex; + +extern "C" __global__ void fmag_all_update(complex* f, + const IN_TYPE* fmask, + const IN_TYPE* fmag, + const IN_TYPE* fdev, + const IN_TYPE* err_fmag, + const int* addr_info, + IN_TYPE pbound_, + int A, + int B) +{ + int batch = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + int addr_stride = 15; + MATH_TYPE pbound = pbound_; + + const int* ea = addr_info + batch * addr_stride + 6; + const int* da = addr_info + batch * addr_stride + 9; + const int* ma = addr_info + batch * addr_stride + 12; + + fmask += ma[0] * A * B; + MATH_TYPE err = err_fmag[da[0]]; + fdev += da[0] * A * B; + fmag += da[0] * A * B; + f += ea[0] * A * B; + MATH_TYPE renorm = sqrt(pbound / err); + + for (int a = ty; a < A; a += blockDim.y) + { + for (int b = tx; b < B; b += blockDim.x) + { + MATH_TYPE m = fmask[a * A + b]; + if (renorm < 1.0f) + { + /* + // assuming this is actually a mask, i.e. 0 or 1 --> this is slower + float fm = m < 0.5f ? 1.0f : + ((fmag[a * A + b] + fdev[a * A + b] * renorm) / (fdev[a * A + b] + + fmag[a * A + b] + 1e-7f)) ; + */ + MATH_TYPE fmagv = fmag[a * A + b]; + MATH_TYPE fdevv = fdev[a * A + b]; + MATH_TYPE fm = (MATH_TYPE(1) - m) + + m * ((fmagv + fdevv * renorm) / (fmagv + fdevv + MATH_TYPE(1e-7))); + f[a * A + b] *= fm; + } + } + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/fmag_update_nopbound.cu b/ptypy/accelerate/cuda_pycuda/cuda/fmag_update_nopbound.cu new file mode 100644 index 000000000..40a65c172 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/fmag_update_nopbound.cu @@ -0,0 +1,53 @@ +/** fmag_all_update_nopbound. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + */ + +#include +#include +using std::sqrt; +using thrust::complex; + +extern "C" __global__ void fmag_update_nopbound(complex* f, + const IN_TYPE* fmask, + const IN_TYPE* fmag, + const IN_TYPE* fdev, + const int* addr_info, + int A, + int B) +{ + const int bid = blockIdx.z; + const int tx = threadIdx.x; + const int a = threadIdx.y + blockIdx.y * blockDim.y; + if (a >= A) + return; + int addr_stride = 15; + + const int* ea = addr_info + bid * addr_stride + 6; + const int* da = addr_info + bid * addr_stride + 9; + const int* ma = addr_info + bid * addr_stride + 12; + + fmask += ma[0] * A * B; + fdev += da[0] * A * B; + fmag += da[0] * A * B; + f += ea[0] * A * B; + + for (int b = tx; b < B; b += blockDim.x) + { + MATH_TYPE m = fmask[a * A + b]; + /* + // assuming this is actually a mask, i.e. 0 or 1 --> this is slower + float fm = m < 0.5f ? 1.0f : + ((fmag[a * A + b] + fdev[a * A + b] * renorm) / (fdev[a * A + b] + + fmag[a * A + b] + 1e-7f)) ; + */ + MATH_TYPE fmagv = fmag[a * A + b]; + MATH_TYPE fdevv = fdev[a * A + b]; + MATH_TYPE fm = + (MATH_TYPE(1) - m) + m * (fmagv / (fmagv + fdevv + MATH_TYPE(1e-7))); + f[a * A + b] *= fm; + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/fourier_deviation.cu b/ptypy/accelerate/cuda_pycuda/cuda/fourier_deviation.cu new file mode 100644 index 000000000..3427222c3 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/fourier_deviation.cu @@ -0,0 +1,58 @@ +/** fourier_deviation. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + */ + +#include +#include +#include +using std::sqrt; +using thrust::abs; +using thrust::complex; + +// specify max number of threads/block and min number of blocks per SM, +// to assist the compiler in register optimisations. +// We achieve a higher occupancy in this case, as less registers are used +// (guided by profiler) +extern "C" __global__ void __launch_bounds__(1024, 2) + fourier_deviation(int nmodes, + const complex *f, + const IN_TYPE *fmag, + OUT_TYPE *fdev, + const int *addr, + int A, + int B) +{ + const int bid = blockIdx.z; + const int tx = threadIdx.x; + const int a = threadIdx.y + blockIdx.y * blockDim.y; + const int addr_stride = 15; + + const int *ea = addr + 6 + (bid * nmodes) * addr_stride; + const int *da = addr + 9 + (bid * nmodes) * addr_stride; + + f += ea[0] * A * B; + fdev += da[0] * A * B; + fmag += da[0] * A * B; + + if (a >= A) + return; + + for (int b = tx; b < B; b += blockDim.x) + { + MATH_TYPE acc = MATH_TYPE(0); + for (int idx = 0; idx < nmodes; ++idx) + { + complex t_f = f[a * B + b + idx * A * B]; + MATH_TYPE abs_exit_wave = abs(t_f); + acc += abs_exit_wave * + abs_exit_wave; // if we do this manually (real*real +imag*imag) + // we get differences to numpy due to rounding + } + auto fdevv = sqrt(acc) - MATH_TYPE(fmag[a * B + b]); + fdev[a * B + b] = fdevv; + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/fourier_error.cu b/ptypy/accelerate/cuda_pycuda/cuda/fourier_error.cu new file mode 100644 index 000000000..ad483c870 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/fourier_error.cu @@ -0,0 +1,65 @@ +/** fourier_error. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + */ + + +#include +#include +#include +using std::sqrt; +using thrust::abs; +using thrust::complex; + +// specify max number of threads/block and min number of blocks per SM, +// to assist the compiler in register optimisations. +// We achieve a higher occupancy in this case, as less registers are used +// (guided by profiler) +extern "C" __global__ void __launch_bounds__(1024, 2) + fourier_error(int nmodes, + const complex *f, + const IN_TYPE *fmask, + const IN_TYPE *fmag, + OUT_TYPE *fdev, + OUT_TYPE *ferr, + const IN_TYPE *mask_sum, + const int *addr, + int A, + int B) +{ + int tx = threadIdx.x; + int ty = threadIdx.y; + int addr_stride = 15; + + const int *ea = addr + 6 + (blockIdx.x * nmodes) * addr_stride; + const int *da = addr + 9 + (blockIdx.x * nmodes) * addr_stride; + const int *ma = addr + 12 + (blockIdx.x * nmodes) * addr_stride; + + f += ea[0] * A * B; + fdev += da[0] * A * B; + fmag += da[0] * A * B; + fmask += ma[0] * A * B; + ferr += da[0] * A * B; + + for (int a = ty; a < A; a += blockDim.y) + { + for (int b = tx; b < B; b += blockDim.x) + { + MATH_TYPE acc = MATH_TYPE(0); + for (int idx = 0; idx < nmodes; ++idx) + { + complex t_f = f[a * B + b + idx * A * B]; + MATH_TYPE abs_exit_wave = abs(t_f); + acc += abs_exit_wave * + abs_exit_wave; // if we do this manually (real*real +imag*imag) + // we get differences to numpy due to rounding + } + auto fdevv = sqrt(acc) - MATH_TYPE(fmag[a * B + b]); + ferr[a * B + b] = (fmask[a * B + b] * fdevv * fdevv) / mask_sum[ma[0]]; + fdev[a * B + b] = fdevv; + } + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/fourier_error2.cu b/ptypy/accelerate/cuda_pycuda/cuda/fourier_error2.cu new file mode 100644 index 000000000..86dddf549 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/fourier_error2.cu @@ -0,0 +1,84 @@ +/** This kernel was an experiment to use shared memory reduction across + * the modes. It turned out to run about 2x slower than the one without + * shared memory, so it's not used at this stage. + */ +#include +#include +#include +using thrust::complex; + +extern "C" __global__ void fourier_error2(int nmodes, + complex *f, + const float *fmask, + const float *fmag, + float *fdev, + float *ferr, + const float *mask_sum, + const int *addr, + int A, + int B) +{ + // block in x/y are across the full tile (ix and iy go from 0 to A/B) + // might go beyond if not divisible + // blockDim.z is nmodes - we use z index to go over the modes accumulation + + int ix = threadIdx.x + blockIdx.x * blockDim.x; + int iy = threadIdx.y + blockIdx.y * blockDim.y; + int tz = threadIdx.z; // for all modes within block + int addr_stride = 15; + assert(tz < nmodes); + + const int *ea = addr + 6 + (blockIdx.z * nmodes) * addr_stride; + const int *da = addr + 9 + (blockIdx.z * nmodes) * addr_stride; + const int *ma = addr + 12 + (blockIdx.z * nmodes) * addr_stride; + + // full offset for this thread + f += ea[0] * A * B + iy * B + ix; + fdev += da[0] * A * B + iy * B + ix; + fmag += da[0] * A * B + iy * B + ix; + fmask += ma[0] * A * B + iy * B + ix; + ferr += da[0] * A * B + iy * B + ix; + + extern __shared__ float shm[]; // BX * BY * nmodes + + // offset so we have shmt[0..nmodes] to reduce in + auto shmt = + shm + threadIdx.x * blockDim.y * blockDim.z + threadIdx.y * blockDim.z; + + // modes values + if (ix < B && iy < A) + { + float abs_exit_wave = abs(f[tz * A * B]); + shmt[tz] = abs_exit_wave * + abs_exit_wave; // if we do this manually (real*real +imag*imag) + // we get differences to numpy due to rounding + } + else + { + shmt[tz] = 0.0f; + } + __syncthreads(); + + // accumulate across modes + assert(nmodes == blockDim.z); + int c = nmodes; + while (c > 1) + { + int half = c / 2; + if (tz < half) + { + shmt[tz] += shmt[c - tz - 1]; + } + __syncthreads(); + c = c - half; + } + + // now write outputs if we're the first thread in the block + if (tz == 0 && iy < A && ix < B) + { + auto acc = shmt[0]; + auto fdevv = sqrt(acc) - *fmag; + *ferr = (*fmask * fdevv * fdevv) / mask_sum[ma[0]]; + *fdev = fdevv; + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/fourier_update.cu b/ptypy/accelerate/cuda_pycuda/cuda/fourier_update.cu new file mode 100644 index 000000000..a713c4418 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/fourier_update.cu @@ -0,0 +1,138 @@ +/* +This was a test to join the fourier update kernels, +and use shared memory across the modes. +But the performance +is 2x slower than individual as we have many idle threads here. +It is not used at the moment. +*/ + +#include +#include +#include +using thrust::complex; + +extern "C" __global__ void fourier_update(int nmodes, + complex *f_d, + const float *fmask_d, + const float *fmag_d, + float *fdev_d, + float *ferr_d, + const float *mask_sum, + const int *addr, + float *err_fmag, + float pbound, + int A, + int B) +{ + // block in x/y are across the full tile (ix and iy go from 0 to A/B) + // might go beyond if not divisible + // blockDim.z is nmodes - we use z index to go over the modes accumulation + int tx = threadIdx.x; + int ty = threadIdx.y; + int tz = threadIdx.z; + + int ix = tx + blockIdx.x * blockDim.x; + int iy = ty + blockIdx.y * blockDim.y; + int addr_stride = 15; + assert(tz < nmodes); + + const int *ea = addr + 6 + (blockIdx.z * nmodes) * addr_stride; + const int *da = addr + 9 + (blockIdx.z * nmodes) * addr_stride; + const int *ma = addr + 12 + (blockIdx.z * nmodes) * addr_stride; + + // full offset for this thread + auto f = f_d + ea[0] * A * B + iy * B + ix; + auto fdev = fdev_d + da[0] * A * B + iy * B + ix; + auto fmag = fmag_d + da[0] * A * B + iy * B + ix; + auto fmask = fmask_d + ma[0] * A * B + iy * B + ix; + auto ferr = ferr_d + da[0] * A * B + iy * B + ix; + + extern __shared__ float shm[]; // BX * BY * nmodes + + // offset so we have shmt[0..nmodes] to reduce in + auto shmt = + shm + threadIdx.x * blockDim.y * blockDim.z + threadIdx.y * blockDim.z; + + // modes values + if (ix < B && iy < A) + { + float abs_exit_wave = abs(f[tz * A * B]); + shmt[tz] = abs_exit_wave * + abs_exit_wave; // if we do this manually (real*real +imag*imag) + // we get bad rounding errors + } + else + { + shmt[tz] = 0.0f; + } + __syncthreads(); + + // accumulate across modes + assert(nmodes == blockDim.z); + int c = nmodes; + while (c > 1) + { + int half = c / 2; + if (tz < half) + { + shmt[tz] += shmt[c - tz - 1]; + } + __syncthreads(); + c = c - half; + } + + // now write outputs if we're the first thread in the block + int tyrem = (A - iy) < int(blockDim.y) ? (A - iy) : blockDim.y; + int txrem = (B - ix) < int(blockDim.x) ? (B - ix) : blockDim.x; + int nt = tyrem * txrem; + int shidx = ty * txrem + tx; + if (tz == 0 && iy < A && ix < B) + { + auto acc = shmt[0]; + auto fdevv = sqrt(acc) - *fmag; + *ferr = (*fmask * fdevv * fdevv) / mask_sum[ma[0]]; + *fdev = fdevv; + + shm[shidx] = *ferr; + } + + ////////////// error reduce + __syncthreads(); + c = nt; + while (c > 1) + { + int half = c / 2; + if (shidx < half && tz == 0) + { + shm[shidx] += shm[c - shidx - 1]; + } + __syncthreads(); + c = c - half; + } + if (shidx == 0 && tz == 0) + { + err_fmag[blockIdx.z] = shm[0]; + } + + ///////////// fmag_all_update + ea += tz * addr_stride; + da += tz * addr_stride; + ma += tz * addr_stride; + + fmask = fmask_d + ma[0] * A * B + iy * B + ix; + float err = err_fmag[da[0]]; // RACE CONDITION! + fdev = fdev_d + da[0] * A * B + iy * B + ix; + fmag = fmag_d + da[0] * A * B + iy * B + ix; + f = f_d + ea[0] * A * B + iy * B + ix; + float renorm = sqrt(pbound / err); + + if (ix < B && iy < A && renorm < 1.0f) + { + auto m = *fmask; + auto fmagv = *fmag; + auto fdevv = *fdev; + float fm = + (1.0f - m) + m * ((fmagv + fdevv * renorm) / (fmagv + fdevv + 1e-10f)); + *f *= fm; + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/full_reduce.cu b/ptypy/accelerate/cuda_pycuda/cuda/full_reduce.cu new file mode 100644 index 000000000..801204aaa --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/full_reduce.cu @@ -0,0 +1,44 @@ +/** full_reduce kernel. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double - for aux wave) + * - ACC_TYPE: the data type used for internal accumulation + */ + + +#include + +extern "C" __global__ void full_reduce(const IN_TYPE* in, OUT_TYPE* out, int size) +{ + assert(gridDim.x == 1); + int tx = threadIdx.x; + + __shared__ ACC_TYPE smem[BDIM_X]; + + auto sum = ACC_TYPE(); + for (int ix = tx; ix < size; ix += blockDim.x) + { + sum = sum + ACC_TYPE(in[ix]); + } + smem[tx] = sum; + __syncthreads(); + + int nt = blockDim.x; + int c = nt; + while (c > 1) + { + int half = c / 2; + if (tx < half) + { + smem[tx] += smem[c - tx - 1]; + } + __syncthreads(); + c = c - half; + } + + if (tx == 0) + { + out[0] = OUT_TYPE(smem[0]); + } +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/gd_main.cu b/ptypy/accelerate/cuda_pycuda/cuda/gd_main.cu new file mode 100644 index 000000000..1ab643c4c --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/gd_main.cu @@ -0,0 +1,36 @@ +/** gd_main kernel. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double - for aux wave) + * - MATH_TYPE: the data type used for computation + */ + +#include +using thrust::complex; + +extern "C" __global__ void gd_main(const IN_TYPE* Imodel, + const IN_TYPE* I, + const IN_TYPE* w, + OUT_TYPE* err, + complex* aux, + int z, + int modes, + int x) +{ + int iz = blockIdx.z; + int ix = threadIdx.x + blockIdx.x * blockDim.x; + + if (iz >= z || ix >= x) + return; + + auto DI = MATH_TYPE(Imodel[iz * x + ix]) - MATH_TYPE(I[iz * x + ix]); + auto tmp = MATH_TYPE(w[iz * x + ix]) * MATH_TYPE(DI); + err[iz * x + ix] = tmp * DI; + + // now set this for all modes (promote) + for (int m = 0; m < modes; ++m) + { + aux[iz * x * modes + m * x + ix] *= tmp; + } +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/get_address.cu b/ptypy/accelerate/cuda_pycuda/cuda/get_address.cu new file mode 100644 index 000000000..dda9b45f1 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/get_address.cu @@ -0,0 +1,35 @@ +#include +#include +using thrust::complex; + +inline __device__ int minimum(int a, int b) { return a < b ? a : b; } + +inline __device__ int maximum(int a, int b) { return a < b ? b : a; } + +extern "C" __global__ void get_address(const int* addr_current, + int* mangled_addr, + int num_pods, + const int* __restrict delta, + int max_oby, + int max_obx) +{ + // we use only one thread block + const int tx = threadIdx.x; + const int idx = tx % 2; // even threads access y dim, odd threads x dim + const int maxval = (idx == 0) ? max_oby : max_obx; + + const int addr_stride = 15; + const int d = delta[idx]; + addr_current += 3 + idx + 1; + mangled_addr += 3 + idx + 1; + + for (int ix = tx; ix < num_pods * 2; ix += blockDim.x) + { + const int bid = ix / 2; + int cur = addr_current[bid * addr_stride] + d; + int bound = maximum(0, minimum(maxval, cur)); + assert(bound >= 0); + assert(bound <= maxval); + mangled_addr[bid * addr_stride] = bound; + } +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/intens_renorm.cu b/ptypy/accelerate/cuda_pycuda/cuda/intens_renorm.cu new file mode 100644 index 000000000..d0033f7f4 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/intens_renorm.cu @@ -0,0 +1,66 @@ +/** intens_renorm - with 2 steps as separate kernels. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + */ + +#include +using thrust::complex; + +extern "C" __global__ void step1(const IN_TYPE* Imodel, + const IN_TYPE* I, + const IN_TYPE* w, + OUT_TYPE* num, + OUT_TYPE* den, + int n) +{ + int i = threadIdx.x + blockIdx.x * blockDim.x; + + if (i >= n) + return; + + auto tmp = MATH_TYPE(w[i]) * MATH_TYPE(Imodel[i]); + num[i] = tmp * MATH_TYPE(I[i]); + den[i] = tmp * MATH_TYPE(Imodel[i]); +} + +extern "C" __global__ void step2(const IN_TYPE* fic_tmp, + OUT_TYPE* fic, + OUT_TYPE* Imodel, + int X, + int Y) +{ + int iz = blockIdx.z; + int tx = threadIdx.x; + int ty = threadIdx.y; + + // one thread block per fic data point - we want the first thread to read this + // into shared memory and then sync the block, so we don't get into data races + // with writing it back to global memory in the end (and we read the value only + // once) + // + __shared__ MATH_TYPE shfic[1]; + if (tx == 0 && ty == 0) { + shfic[0] = MATH_TYPE(fic[iz]) / MATH_TYPE(fic_tmp[iz]); + } + __syncthreads(); + + // now all threads can access that value + auto tmp = shfic[0]; + + // offset Imodel for current z + Imodel += iz * X * Y; + + for (int iy = ty; iy < Y; iy += blockDim.y) { + #pragma unroll(4) + for (int ix = tx; ix < X; ix += blockDim.x) { + Imodel[iy * X + ix] *= tmp; + } + } + + // race condition if write is not restricted to one thread + if (tx==0 && ty == 0) + fic[iz] = tmp; +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/interpolated_shift.cu b/ptypy/accelerate/cuda_pycuda/cuda/interpolated_shift.cu new file mode 100644 index 000000000..49db445f7 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/interpolated_shift.cu @@ -0,0 +1,279 @@ +#include +#include +#include +#include +#include +#include +using thrust::complex; + +__device__ inline complex& ascomplex(float2& f2) +{ + return reinterpret_cast&>(f2); +} + +__device__ inline void calcWeights(float* weights, float fraction) +{ + if (fraction < 0.0) + { + weights[2] = -fraction; + weights[1] = 1.0f + fraction; + weights[0] = 0.0f; + } + else + { + weights[2] = 0.0f; + weights[1] = 1.0f - fraction; + weights[0] = fraction; + } +} + +extern "C" __global__ void integer_shift_kernel(const IN_TYPE* in, + OUT_TYPE* out, + int rows, + int columns, + int rowOffset, + int colOffset) +{ + int tx = threadIdx.x + blockIdx.x * BDIM_X; + int ty = threadIdx.y + blockIdx.y * BDIM_Y; + if (tx >= rows || ty >= columns) + return; + + int item = blockIdx.z; + in += item * rows * columns; + out += item * rows * columns; + + int gid_old = tx * columns + ty; + assert(gid_old < columns * rows); + assert(gid_old >= 0); + + auto val = in[gid_old]; + + int gid_new_x = tx + rowOffset; + int gid_new_y = ty + colOffset; + + // write zero on the other end + while (gid_new_x >= rows) + { + val = complex(); + gid_new_x -= rows; + } + while (gid_new_x < 0) + { + val = complex(); + gid_new_x += rows; + } + while (gid_new_y >= columns) + { + val = complex(); + gid_new_y -= columns; + } + while (gid_new_y < 0) + { + val = complex(); + gid_new_y += columns; + } + // do we need to do something with the corners? + + int gid_new = gid_new_x * columns + gid_new_y; + assert(gid_new < rows * columns); + assert(gid_new >= 0); + + out[gid_new] = val; +} + +extern "C" __global__ void linear_interpolate_kernel(const IN_TYPE* in, + OUT_TYPE* out, + int rows, + int columns, + float offsetRow, + float offsetColumn) +{ + int offsetRowInt = int(offsetRow); + int offsetColInt = int(offsetColumn); + float offsetRowFrac = offsetRow - offsetRowInt; // positive or negative + float offsetColFrac = offsetColumn - offsetColInt; + + // calculate convolutional weights + float wx[3]; + calcWeights(wx, offsetRowFrac); + float wy[3]; + calcWeights(wy, offsetColFrac); + + // indices + int tx = threadIdx.x; + int ty = threadIdx.y; + int bx = blockIdx.x; + int by = blockIdx.y; + int gx = tx + bx * BDIM_X; + int gy = ty + by * BDIM_Y; + int gx_old = gx - offsetRowInt; + int gy_old = gy - offsetColInt; + + // items index is blockIdx.z + // we just advance the data + int item = blockIdx.z; + in += item * rows * columns; + out += item * rows * columns; + + __shared__ float2 shr[BDIM_X + 2][BDIM_Y + 2]; + + // read top Halo + if (tx == 0) + { + if (gx_old - 1 >= 0 && gx_old - 1 < rows && gy_old >= 0 && gy_old < columns) + { + ascomplex(shr[0][ty + 1]) = in[(gx_old - 1) * columns + gy_old]; + } + else + { + ascomplex(shr[0][ty + 1]) = complex(); + } + } + // read bottom Halo + if (tx == BDIM_X - 1) + { + if (gx_old + 1 >= 0 && gx_old + 1 < rows && gy_old >= 0 && gy_old < columns) + { + ascomplex(shr[BDIM_X + 1][ty + 1]) = in[(gx_old + 1) * columns + gy_old]; + } + else + { + ascomplex(shr[BDIM_X + 1][ty + 1]) = complex(); + } + } + // read left Halo + if (ty == 0) + { + if (gx_old >= 0 && gx_old < rows && gy_old - 1 >= 0 && gy_old - 1 < columns) + { + ascomplex(shr[tx + 1][0]) = in[gx_old * columns + gy_old - 1]; + } + else + { + ascomplex(shr[tx + 1][0]) = complex(); + } + } + // read right Halo + if (ty == BDIM_Y - 1) + { + if (gx_old >= 0 && gx_old < rows && gy_old + 1 >= 0 && gy_old + 1 < columns) + { + ascomplex(shr[tx + 1][BDIM_Y + 1]) = in[gx_old * columns + gy_old + 1]; + } + else + { + ascomplex(shr[tx + 1][BDIM_Y + 1]) = complex(); + } + } + // read top-left Halo + if ((tx == 0) && (ty == 0)) + { + if (gx_old - 1 >= 0 && gx_old - 1 < rows && gy_old - 1 >= 0 && gy_old - 1 < columns) + { + ascomplex(shr[0][0]) = in[(gx_old - 1) * columns + gy_old - 1]; + } + else + { + ascomplex(shr[0][0]) = complex(); + } + } + // read bottom-right Halo + if ((tx == BDIM_X - 1) && (ty == BDIM_Y - 1)) + { + if (gx_old + 1 >= 0 && gx_old + 1 < rows && gy_old + 1 >= 0 && gy_old + 1 < columns) + { + ascomplex(shr[BDIM_X + 1][BDIM_Y + 1]) = in[(gx_old + 1) * columns + gy_old + 1]; + } + else + { + ascomplex(shr[BDIM_X + 1][BDIM_Y + 1]) = complex(); + } + } + // read bottom-left Halo + if ((ty == 0) && (tx == BDIM_X - 1)) + { + if (gx_old + 1 >= 0 && gx_old + 1 < rows && gy_old - 1 >= 0 && gy_old - 1 < columns) + { + ascomplex(shr[BDIM_X + 1][0]) = in[(gx_old + 1) * columns + gy_old - 1]; + } + else + { + ascomplex(shr[BDIM_X + 1][0]) = complex(); + } + } + // read top-right Halo + if ((ty == BDIM_Y - 1) && (tx == 0)) + { + if (gx_old - 1 >= 0 && gx_old - 1 < rows && gy_old + 1 >= 0 && gy_old + 1 < columns) + { + ascomplex(shr[0][BDIM_Y + 1]) = in[(gx_old - 1) * columns + gy_old + 1]; + } + else + { + ascomplex(shr[0][BDIM_Y + 1]) = complex(); + } + } + // read the rest + if (gx_old >= 0 && gx_old < rows && gy_old >= 0 && gy_old < columns) + { + ascomplex(shr[tx + 1][ty + 1]) = in[gx_old * columns + gy_old]; + } + else + { + ascomplex(shr[tx + 1][ty + 1]) = complex(); + } + + // now we have a block + halos in shared memory - do the interpolation + __syncthreads(); + + // interpolate rows in x + __shared__ float2 shry[BDIM_X][BDIM_Y + 2]; + + ascomplex(shry[tx][ty + 1]) = wx[0] * ascomplex(shr[tx][ty + 1]) + + wx[1] * ascomplex(shr[tx + 1][ty + 1]) + + wx[2] * ascomplex(shr[tx + 2][ty + 1]); + if (ty == 0) + { + ascomplex(shry[tx][0]) = wx[0] * ascomplex(shr[tx][0]) + + wx[1] * ascomplex(shr[tx + 1][0]) + + wx[2] * ascomplex(shr[tx + 2][0]); + } + if (ty == BDIM_Y - 1) + { + ascomplex(shry[tx][BDIM_Y + 1]) = + wx[0] * ascomplex(shr[tx][BDIM_Y + 1]) + + wx[1] * ascomplex(shr[tx + 1][BDIM_Y + 1]) + + wx[2] * ascomplex(shr[tx + 2][BDIM_Y + 1]); + } + + __syncthreads(); + + if (gx >= rows || gy >= columns) + { + return; + } + + auto intv = wy[0] * ascomplex(shry[tx][ty]) + + wy[1] * ascomplex(shry[tx][ty + 1]) + + wy[2] * ascomplex(shry[tx][ty + 2]); + + // write back + + // if the point lies outside of the original frame and we're shifting in + // that direction, it gets a zero value in any case + // otherwise we take the interpolated value + bool rightzero = offsetColFrac < 0.0f; + bool leftzero = offsetColFrac > 0.0f; + bool topzero = offsetRowFrac > 0.0f; + bool bottomzero = offsetRowFrac < 0.0f; + if ((gx_old == 0 && topzero) || (gx_old == rows - 1 && bottomzero) || + (gy_old == 0 && leftzero) || (gy_old == columns - 1 && rightzero)) + { + out[gx * columns + gy] = complex(); + } + else + { + out[gx * columns + gy] = intv; + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/log_likelihood.cu b/ptypy/accelerate/cuda_pycuda/cuda/log_likelihood.cu new file mode 100644 index 000000000..075d59f0a --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/log_likelihood.cu @@ -0,0 +1,153 @@ +/** log_likelihood kernel. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + */ + +#include +#include +#include +using std::sqrt; +using thrust::abs; +using thrust::complex; + +// specify max number of threads/block and min number of blocks per SM, +// to assist the compiler in register optimisations. +// We achieve a higher occupancy in this case, as less registers are used +// (guided by profiler) +extern "C" __global__ void __launch_bounds__(1024, 2) + log_likelihood(int nmodes, + complex *aux, + const IN_TYPE *fmask, + const IN_TYPE *fmag, + const int *addr, + IN_TYPE *llerr, + int A, + int B) +{ + int tx = threadIdx.x; + int ty = threadIdx.y; + int addr_stride = 15; + + const int *ea = addr + 6 + (blockIdx.x * nmodes) * addr_stride; + const int *da = addr + 9 + (blockIdx.x * nmodes) * addr_stride; + const int *ma = addr + 12 + (blockIdx.x * nmodes) * addr_stride; + + aux += ea[0] * A * B; + fmag += da[0] * A * B; + fmask += ma[0] * A * B; + llerr += da[0] * A * B; + MATH_TYPE norm = A * B; + + for (int a = ty; a < A; a += blockDim.y) + { + for (int b = tx; b < B; b += blockDim.x) + { + MATH_TYPE acc = 0.0; + for (int idx = 0; idx < nmodes; ++idx) + { + complex t_aux = aux[a * B + b + idx * A * B]; + MATH_TYPE abs_exit_wave = abs(t_aux); + acc += abs_exit_wave * + abs_exit_wave; // if we do this manually (real*real +imag*imag) + // we get differences to numpy due to rounding + } + auto I = MATH_TYPE(fmag[a * B + b]) * MATH_TYPE(fmag[a * B + b]); + llerr[a * B + b] = + MATH_TYPE(fmask[a * B + b]) * (acc - I) * (acc - I) / (I + 1) / norm; + } + } +} + + +extern "C" __global__ void + log_likelihood2(int nmodes, + complex *aux, + const IN_TYPE *fmask, + const IN_TYPE *fmag, + const int *addr, + IN_TYPE *llerr, + int A, + int B) +{ + int bid = blockIdx.z; + int tx = threadIdx.x; + int a = threadIdx.y + blockIdx.y * blockDim.y; + if (a >= A) + return; + int addr_stride = 15; + + const int *ea = addr + 6 + (bid * nmodes) * addr_stride; + const int *da = addr + 9 + (bid * nmodes) * addr_stride; + const int *ma = addr + 12 + (bid * nmodes) * addr_stride; + + aux += ea[0] * A * B; + fmag += da[0] * A * B; + fmask += ma[0] * A * B; + llerr += da[0] * A * B; + MATH_TYPE norm = A * B; + + for (int b = tx; b < B; b += blockDim.x) + { + MATH_TYPE acc = 0.0; + for (int idx = 0; idx < nmodes; ++idx) + { + complex t_aux = aux[a * B + b + idx * A * B]; + MATH_TYPE abs_exit_wave = abs(t_aux); + acc += abs_exit_wave * + abs_exit_wave; // if we do this manually (real*real +imag*imag) + // we get differences to numpy due to rounding + } + auto I = MATH_TYPE(fmag[a * B + b]) * MATH_TYPE(fmag[a * B + b]); + llerr[a * B + b] = + MATH_TYPE(fmask[a * B + b]) * (acc - I) * (acc - I) / (I + 1) / norm; + } +} + +// ML variant which uses weights and intensity directly. +// Based of log_likelihood +extern "C" __global__ void __launch_bounds__(1024, 2) + log_likelihood_ml(int nmodes, + complex *aux, + const IN_TYPE *weights, + const IN_TYPE *I, + const int *addr, + IN_TYPE *llerr, + int A, + int B) +{ + int tx = threadIdx.x; + int ty = threadIdx.y; + int addr_stride = 15; + + const int *ea = addr + 6 + (blockIdx.x * nmodes) * addr_stride; + const int *da = addr + 9 + (blockIdx.x * nmodes) * addr_stride; + const int *ma = addr + 12 + (blockIdx.x * nmodes) * addr_stride; + + aux += ea[0] * A * B; + I += da[0] * A * B; + weights += ma[0] * A * B; + llerr += da[0] * A * B; + MATH_TYPE norm = A * B; + + for (int a = ty; a < A; a += blockDim.y) + { + for (int b = tx; b < B; b += blockDim.x) + { + MATH_TYPE acc = 0.0; + MATH_TYPE i = I[a * B + b]; + for (int idx = 0; idx < nmodes; ++idx) + { + complex t_aux = aux[a * B + b + idx * A * B]; + MATH_TYPE abs_exit_wave = abs(t_aux); + acc += abs_exit_wave * + abs_exit_wave; // if we do this manually (real*real +imag*imag) + // we get differences to numpy due to rounding + } + llerr[a * B + b] = + MATH_TYPE(weights[a * B + b]) * (acc - i) * (acc - i) / norm; + } + } +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/make_a012.cu b/ptypy/accelerate/cuda_pycuda/cuda/make_a012.cu new file mode 100644 index 000000000..11ba29f62 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/make_a012.cu @@ -0,0 +1,67 @@ +/** fmag_all_update. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + * - ACC_TYPE: data type used for accumulation + */ + +#include +using thrust::complex; + +extern "C" __global__ void make_a012(const complex* f, + const complex* a, + const complex* b, + const IN_TYPE* I, + const IN_TYPE* fic, + OUT_TYPE* A0, + OUT_TYPE* A1, + OUT_TYPE* A2, + int z, + int y, + int x, + int maxz) +{ + int ix = threadIdx.x + blockIdx.x * blockDim.x; + int iz = blockIdx.z; + + if (ix >= x) + return; + + if (iz >= maxz) + { + A0[iz * x + ix] = OUT_TYPE(0); // make sure it's the right type (double/float) + A1[iz * x + ix] = OUT_TYPE(0); + A2[iz * x + ix] = OUT_TYPE(0); + return; + } + + // we sum across y directly, as this is the number of modes, + // which is typically small + auto sumtf0 = ACC_TYPE(0); + auto sumtf1 = ACC_TYPE(0); + auto sumtf2 = ACC_TYPE(0); + for (auto iy = 0; iy < y; ++iy) + { + complex fv = f[iz * y * x + iy * x + ix]; + sumtf0 += fv.real() * fv.real() + fv.imag() * fv.imag(); + + complex av = a[iz * y * x + iy * x + ix]; + // 2 * real(f * conj(a)) + sumtf1 += MATH_TYPE(2) * (fv.real() * av.real() + fv.imag() * av.imag()); + + // use FTYPE(2) to make sure double creeps into a float calculation + // as 2.0 * would make everything double. + complex bv = b[iz * y * x + iy * x + ix]; + // 2 * real(f * conj(b)) + abs(a)^2 + sumtf2 += MATH_TYPE(2) * (fv.real() * bv.real() + fv.imag() * bv.imag()) + + (av.real() * av.real() + av.imag() * av.imag()); + } + + MATH_TYPE Iv = I[iz * x + ix]; + MATH_TYPE ficv = fic[iz]; + A0[iz * x + ix] = OUT_TYPE(MATH_TYPE(sumtf0) * ficv - Iv); + A1[iz * x + ix] = OUT_TYPE(MATH_TYPE(sumtf1) * ficv); + A2[iz * x + ix] = OUT_TYPE(MATH_TYPE(sumtf2) * ficv); +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/make_aux.cu b/ptypy/accelerate/cuda_pycuda/cuda/make_aux.cu new file mode 100644 index 000000000..b2f64ba1d --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/make_aux.cu @@ -0,0 +1,104 @@ +/** build_aux kernel. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double - for aux wave) + * - MATH_TYPE: the data type used for computation + */ + +#include +using thrust::complex; + +// core calculation function - used by both kernels and inlined +inline __device__ complex calculate( + const complex& t_obj, + const complex& t_probe, + const complex& t_ex, + MATH_TYPE a, + MATH_TYPE b) +{ + return t_obj * t_probe * a + t_ex * b; +} + +extern "C" __global__ void make_aux( + complex* auxiliary_wave, + const complex* __restrict__ exit_wave, + int B, + int C, + const complex* __restrict__ probe, + int E, + int F, + const complex* __restrict__ obj, + int H, + int I, + const int* __restrict__ addr, + IN_TYPE coeff_po_, + IN_TYPE coeff_e_) +{ + int bid = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + int addr_stride = 15; + const MATH_TYPE coeff_po = coeff_po_; // type conversion + const MATH_TYPE coeff_e = coeff_e_; // type conversion + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + exit_wave += ea[0] * B * C; + auxiliary_wave += ea[0] * B * C; + + for (int b = ty; b < B; b += blockDim.y) + { +#pragma unroll(4) // we use blockDim.x = 32, and C is typically more than 128 + // (it will work for less as well) + for (int c = tx; c < C; c += blockDim.x) + { + auxiliary_wave[b * C + c] = calculate( + obj[b * I + c], probe[b * F + c], exit_wave[b * C + c], coeff_po, coeff_e); + } + } +} + +extern "C" __global__ void make_aux2( + complex* auxiliary_wave, + const complex* __restrict__ exit_wave, + int B, + int C, + const complex* __restrict__ probe, + int E, + int F, + const complex* __restrict__ obj, + int H, + int I, + const int* __restrict__ addr, + IN_TYPE coeff_po_, + IN_TYPE coeff_e_) +{ + int bid = blockIdx.z; + int tx = threadIdx.x; + int b = threadIdx.y + blockIdx.y * blockDim.y; + if (b >= B) + return; + int addr_stride = 15; + const MATH_TYPE coeff_po = coeff_po_; // type conversion + const MATH_TYPE coeff_e = coeff_e_; // type conversion + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + exit_wave += ea[0] * B * C; + auxiliary_wave += ea[0] * B * C; + + for (int c = tx; c < C; c += blockDim.x) + { + auxiliary_wave[b * C + c] = calculate( + obj[b * I + c], probe[b * F + c], exit_wave[b * C + c], coeff_po, coeff_e); + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/make_exit.cu b/ptypy/accelerate/cuda_pycuda/cuda/make_exit.cu new file mode 100644 index 000000000..956b292dc --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/make_exit.cu @@ -0,0 +1,70 @@ +/** build_exit kernel. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double - for aux wave) + * - MATH_TYPE: the data type used for computation + */ + + +#include +using thrust::complex; + +template +__device__ inline void atomicAdd(complex* x, complex y) +{ + auto xf = reinterpret_cast(x); + atomicAdd(xf, y.real()); + atomicAdd(xf + 1, y.imag()); +} + +extern "C" __global__ void make_exit(complex* auxiliary_wave, + complex* exit_wave, + int B, + int C, + const complex* __restrict__ probe, + int E, + int F, + const complex* __restrict__ obj, + int H, + int I, + const int* __restrict__ addr, + IN_TYPE coeff_a_, + IN_TYPE coeff_po_, + IN_TYPE coeff_e_) +{ + int bid = blockIdx.x; + int tx = threadIdx.x; + int ty = threadIdx.y; + const int addr_stride = 15; + const MATH_TYPE coeff_a = coeff_a_; // type conversion + const MATH_TYPE coeff_po = coeff_po_; // type conversion + const MATH_TYPE coeff_e = coeff_e_; // type conversion + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + exit_wave += ea[0] * B * C; + auxiliary_wave += ea[0] * B * C; + + for (int b = ty; b < B; b += blockDim.y) + { +#pragma unroll(4) // we use blockDim.x = 32, and C is typically more than 128 + // (it will work for less as well) + for (int c = tx; c < C; c += blockDim.x) + { + complex auxv = auxiliary_wave[b * C + c]; + complex t_probe = probe[b * F + c]; + complex t_obj = obj[b * I + c]; + complex t_exit = exit_wave[b * C + c]; + auxv *= coeff_a; + auxv += coeff_po * t_probe * t_obj; + auxv += coeff_e * t_exit; + exit_wave[b * C + c] += auxv; + auxiliary_wave[b * C + c] = auxv; + } + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/make_model.cu b/ptypy/accelerate/cuda_pycuda/cuda/make_model.cu new file mode 100644 index 000000000..22bf7d4ab --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/make_model.cu @@ -0,0 +1,30 @@ +/** make_model - with 2 steps as separate kernels. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + */ + +#include +using thrust::complex; + +extern "C" __global__ void make_model( + const complex* in, OUT_TYPE* out, int z, int y, int x) +{ + int ix = threadIdx.x + blockIdx.x * blockDim.x; + int iz = blockIdx.z; + + if (ix >= x) + return; + + // we sum accross y directly, as this is the number of modes, + // which is typically small + auto sum = MATH_TYPE(); + for (auto iy = 0; iy < y; ++iy) + { + complex v = in[iz * y * x + iy * x + ix]; + sum += v.real() * v.real() + v.imag() * v.imag(); + } + out[iz * x + ix] = OUT_TYPE(sum); +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/mass_center.cu b/ptypy/accelerate/cuda_pycuda/cuda/mass_center.cu new file mode 100644 index 000000000..3261495d2 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/mass_center.cu @@ -0,0 +1,138 @@ +extern "C" __global__ void indexed_sum_middim( + const IN_TYPE* data, + IN_TYPE* sums, + int i, + int m, // dim we work on - 1 block per output + int n, + float scale) +{ + int bid = blockIdx.x; + int tid = threadIdx.x; + + data += bid * n; + + auto val = 0.0f; + for (int x = 0; x < i; ++x) + { + auto d_inner = data + x * n * m; + for (int z = tid; z < n; z += BDIM_X) + { + val += d_inner[z]; + } + } + + __shared__ float sumshr[BDIM_X]; + sumshr[tid] = val; + + __syncthreads(); + int c = BDIM_X; + while (c > 1) + { + int half = c / 2; + if (tid < half) + { + sumshr[tid] += sumshr[c - tid - 1]; + } + __syncthreads(); + c = c - half; + } + + if (tid == 0) + { + sums[bid] = sumshr[0] * float(bid) * scale; + } +} + + +extern "C" __global__ void indexed_sum_lastdim( + const IN_TYPE* data, IN_TYPE* sums, int n, int i, float scale) +{ + int ty = threadIdx.y + blockIdx.y * BDIM_Y; + int tx = threadIdx.x; + + auto val = 0.0f; + if (ty < i) + { + data += ty; // column to work on + + // we collaborate along the x axis (columns) to get more threads in case i + // is small + for (int r = tx; r < n; r += BDIM_X) + { + val += data[r * i]; + } + } + + // reduce along X dimension in shared memory (column sum) + __shared__ float blocksums[BDIM_X][BDIM_Y]; + blocksums[tx][threadIdx.y] = val; + + __syncthreads(); + int nt = blockDim.x; + int c = nt; + while (c > 1) + { + int half = c / 2; + if (tx < half) + { + blocksums[tx][threadIdx.y] += blocksums[c - tx - 1][threadIdx.y]; + } + __syncthreads(); + c = c - half; + } + + if (ty >= i) + { + return; + } + + if (tx == 0) + { + sums[ty] = blocksums[0][threadIdx.y] * float(ty) * scale; + } +} + + +extern "C" __global__ void final_sums(const IN_TYPE* sum_i, + int i, + const IN_TYPE* sum_m, + int m, + const IN_TYPE* sum_n, + int n, + IN_TYPE* output) +{ + int bid = blockIdx.x; + int tid = threadIdx.x; + // each block works on a single dimension + int nn = bid == 0 ? i : (bid == 1 ? m : n); + const float* data = bid == 0 ? sum_i : (bid == 1 ? sum_m : sum_n); + + __shared__ float shared[BDIM_X]; + auto val = 0.0f; + for (int i = tid; i < nn; i += blockDim.x) + { + val += data[i]; + } + shared[tid] = val; + + // now add up sumbuffer in shared memory + __syncthreads(); + int nt = blockDim.x; + int c = nt; + while (c > 1) + { + int half = c / 2; + if (tid < half) + { + shared[tid] += shared[c - tid - 1]; + } + __syncthreads(); + c = c - half; + } + + if (tid == 0) + { + output[bid] = shared[0]; + } +} + diff --git a/ptypy/accelerate/cuda_pycuda/cuda/max_abs2.cu b/ptypy/accelerate/cuda_pycuda/cuda/max_abs2.cu new file mode 100644 index 000000000..4da8efb3e --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/max_abs2.cu @@ -0,0 +1,115 @@ +/** max_abs2 kernel, calculating the sum of abs(x)**2 value in the first dimension + * and then the maximum across the last 2 dimensions + * + * Data types: + * - IN_TYPE: can be float/double or complex/complex + */ + +#include +#include +using thrust::complex; +using thrust::norm; + +inline __device__ OUT_TYPE norm(const float& in) { + return in*in; +} + +inline __device__ OUT_TYPE norm(const double& in) { + return in*in; +} + +extern "C" __global__ void max_abs2_step1(const IN_TYPE* a, + int n, + int rows, + int cols, + OUT_TYPE* out) +{ + int tx = threadIdx.x; + const int iy = blockIdx.y; + + __shared__ OUT_TYPE sh[BDIM_X]; + + OUT_TYPE maxv = OUT_TYPE(0); + + for (int ix = tx; ix < cols; ix += BDIM_X) { + OUT_TYPE v = OUT_TYPE(0); + for (int in = 0; in < n; ++in) { + v += norm(a[in * rows * cols + iy * cols + ix]); + } + if (v > maxv) + maxv = v; + } + + + sh[tx] = maxv; + + __syncthreads(); + + // reduce: + const int nt = BDIM_X; + int c = nt; + + while (c > 1) + { + int half = c / 2; + if (tx < half) + { + auto v = sh[c - tx - 1]; + if (maxv < v) { + sh[tx] = v; + maxv = v; + } + } + __syncthreads(); + c = c - half; + } + + if (tx == 0) + { + out[iy] = sh[0]; + } +} + +extern "C" __global__ void max_abs2_step2(const OUT_TYPE* in, + int n, + OUT_TYPE* out) +{ + int tx = threadIdx.x; + + in += blockIdx.x * n; + + __shared__ OUT_TYPE sh[BDIM_X]; + + OUT_TYPE maxv = OUT_TYPE(0); + for (int i = tx; i < n; ++i) { + auto v = in[i]; + if (v > maxv) + maxv = v; + } + sh[tx] = maxv; + __syncthreads(); + + // reduce: + const int nt = BDIM_X; + int c = nt; + + while (c > 1) + { + int half = c / 2; + if (tx < half) + { + auto v = sh[c - tx - 1]; + if (maxv < v) { + sh[tx] = v; + maxv = v; + } + } + __syncthreads(); + c = c - half; + } + + if (tx == 0) + { + out[0] = sh[0]; + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/ob_norm_local.cu b/ptypy/accelerate/cuda_pycuda/cuda/ob_norm_local.cu new file mode 100644 index 000000000..3969ea6e9 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/ob_norm_local.cu @@ -0,0 +1,59 @@ +/** ob_norm_local. +* +* Data types: +* - IN_TYPE: the data type for the inputs (float or double) +* - OUT_TYPE: the data type for the outputs (float or double) +* - MATH_TYPE: the data type used for computation +*/ + +#include +#include +#include +using std::sqrt; +using thrust::abs; +using thrust::complex; + +// specify max number of threads/block and min number of blocks per SM, +// to assist the compiler in register optimisations. +// We achieve a higher occupancy in this case, as less registers are used +// (guided by profiler) +extern "C" __global__ void __launch_bounds__(1024, 2) + ob_norm_local(OUT_TYPE *ob_norm, + int A, + int B, + int C, + const complex* __restrict__ obj, + int D, + int E, + int F, + const int* __restrict__ addr) +{ + const int bid = blockIdx.z; + const int tx = threadIdx.x; + const int b = threadIdx.y + blockIdx.y * blockDim.y; + const int addr_stride = 15; + + const int* oa = addr + 3 + (bid * D) * addr_stride; + const int* da = addr + 9 + (bid * D) * addr_stride; + + obj += oa[0] * E * F + oa[1] * F + oa[2]; + ob_norm += da[0] * B * C; + + if (b >= B) + return; + + for (int c = tx; c < C; c += blockDim.x) + { + MATH_TYPE acc = MATH_TYPE(0); + for (int idx = 0; idx < D; ++idx) + { + complex obj_val = obj[b * F + c + idx * E * F]; + MATH_TYPE abs_obj_val = abs(obj_val); + acc += abs_obj_val * + abs_obj_val; // if we do this manually (real*real +imag*imag) + // we get differences to numpy due to rounding + } + ob_norm[b * C + c] = acc; + } + +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/ob_update.cu b/ptypy/accelerate/cuda_pycuda/cuda/ob_update.cu new file mode 100644 index 000000000..29b993fb0 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/ob_update.cu @@ -0,0 +1,68 @@ +/** ob_update. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + */ + +#include +using thrust::complex; + +template +__device__ inline void atomicAdd(complex* x, const complex& y) +{ + auto xf = reinterpret_cast(x); + atomicAdd(xf, y.real()); + atomicAdd(xf + 1, y.imag()); +} + +extern "C" __global__ void ob_update( + const complex* __restrict__ exit_wave, + int A, + int B, + int C, + const complex* __restrict__ probe, + int D, + int E, + int F, + complex* obj, + int G, + int H, + int I, + const int* __restrict__ addr, + OUT_TYPE* denominator) +{ + const int bid = blockIdx.x; + const int tx = threadIdx.x; + const int ty = threadIdx.y; + const int addr_stride = 15; + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + denominator += oa[0] * H * I + oa[1] * I + oa[2]; + + assert(oa[0] * H * I + oa[1] * I + oa[2] + (B - 1) * I + C - 1 < G * H * I); + + exit_wave += ea[0] * B * C; + + for (int b = ty; b < B; b += blockDim.y) + { + for (int c = tx; c < C; c += blockDim.x) + { + complex probe_val = probe[b * F + c]; + complex exit_val = exit_wave[b * C + c]; + auto add_val_m = conj(probe_val) * exit_val; + complex add_val = add_val_m; + atomicAdd(&obj[b * I + c], add_val); + + auto upd_probe = probe_val.real() * probe_val.real() + + probe_val.imag() * probe_val.imag(); + atomicAdd(&denominator[b * I + c], upd_probe); + } + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/ob_update2.cu b/ptypy/accelerate/cuda_pycuda/cuda/ob_update2.cu new file mode 100644 index 000000000..821c04a6d --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/ob_update2.cu @@ -0,0 +1,128 @@ +/** ob_update. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + * - ACC_TYPE: accumulator type for the local ob accumulation + * + * NOTE: This version of ob_update goes over all tiles that need to be accumulated + * in a single thread block to avoid global atomic additions (as in ob_update.cu). + * This requires a local array of NUM_MODES size to store the local updates. + * GPU registers per thread are limited (255 32bit registers on V100), + * and at some point the registers will spill into shared or global memory + * and the kernel will get considerably slower. + */ + + +#include +#include +using thrust::complex; + +#define pr_dlayer(k) addr[(k)] +#define ex_dlayer(k) addr[6 * num_pods + (k)] +#define obj_dlayer(k) addr[3 * num_pods + (k)] +#define obj_roi_row(k) addr[4 * num_pods + (k)] +#define obj_roi_column(k) addr[5 * num_pods + (k)] + + +extern "C" __global__ void ob_update2( + int pr_sh, + int ob_modes, + int num_pods, + int ob_sh_rows, + int ob_sh_cols, + int pr_modes, + int ex_0, + int ex_1, + int ex_2, + complex* ob_g, + OUT_TYPE* obn_g, + const complex* __restrict__ pr_g, // 2, 5, 5 + const complex* __restrict__ ex_g, // 16, 5, 5 + const int* addr) +{ + int y = blockIdx.y * BDIM_Y + threadIdx.y; + int dy = ob_sh_rows; + int z = blockIdx.x * BDIM_X + threadIdx.x; + int dz = ob_sh_cols; + complex ob[NUM_MODES]; + ACC_TYPE obn[NUM_MODES]; + + int txy = threadIdx.y * BDIM_X + threadIdx.x; + assert(ob_modes <= NUM_MODES); + + if (y < dy && z < dz) + { +#pragma unroll + for (int i = 0; i < NUM_MODES; ++i) + { + auto idx = i * dy * dz + y * dz + z; + assert(idx < ob_modes * ob_sh_rows * ob_sh_cols); + ob[i] = ob_g[idx]; + obn[i] = obn_g[idx]; + } + } + + __shared__ int addresses[BDIM_X * BDIM_Y * 5]; + + for (int p = 0; p < num_pods; p += BDIM_X * BDIM_Y) + { + int mi = BDIM_X * BDIM_Y; + if (mi > num_pods - p) + mi = num_pods - p; + + if (p > 0) + __syncthreads(); + + if (txy < mi) + { + assert(p + txy < num_pods); + assert(txy < BDIM_X * BDIM_Y); + addresses[txy * 5 + 0] = pr_dlayer(p + txy); + addresses[txy * 5 + 1] = ex_dlayer(p + txy); + addresses[txy * 5 + 2] = obj_dlayer(p + txy); + assert(obj_dlayer(p + txy) < NUM_MODES); + assert(addresses[txy * 5 + 2] < NUM_MODES); + addresses[txy * 5 + 3] = obj_roi_row(p + txy); + addresses[txy * 5 + 4] = obj_roi_column(p + txy); + } + + __syncthreads(); + + if (y >= dy || z >= dz) + continue; + +#pragma unroll 4 + for (int i = 0; i < mi; ++i) + { + int* ad = addresses + i * 5; + int v1 = y - ad[3]; + int v2 = z - ad[4]; + if (v1 >= 0 && v1 < pr_sh && v2 >= 0 && v2 < pr_sh) + { + auto pridx = ad[0] * pr_sh * pr_sh + v1 * pr_sh + v2; + assert(pridx < pr_modes * pr_sh * pr_sh); + complex pr = pr_g[pridx]; + int idx = ad[2]; + assert(idx < NUM_MODES); + auto cpr = conj(pr); + auto exidx = ad[1] * pr_sh * pr_sh + v1 * pr_sh + v2; + assert(exidx < ex_0 * ex_1 * ex_2); + complex t_ex_g = ex_g[exidx]; + complex add_val = cpr * t_ex_g; + ob[idx] += add_val; + obn[idx] += pr.real() * pr.real() + pr.imag() * pr.imag(); + } + } + } + + if (y < dy && z < dz) + { + for (int i = 0; i < NUM_MODES; ++i) + { + ob_g[i * dy * dz + y * dz + z] = ob[i]; + obn_g[i * dy * dz + y * dz + z] = obn[i]; + } + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/ob_update2_ML.cu b/ptypy/accelerate/cuda_pycuda/cuda/ob_update2_ML.cu new file mode 100644 index 000000000..b62e66006 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/ob_update2_ML.cu @@ -0,0 +1,124 @@ +/** ob_update. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + * - ACC_TYPE: accumulator for the ob field + * + * NOTE: This version of ob_update goes over all tiles that need to be accumulated + * in a single thread block to avoid global atomic additions (as in ob_update_ML.cu). + * This requires a local array of NUM_MODES size to store the local updates. + * GPU registers per thread are limited (255 32bit registers on V100), + * and at some point the registers will spill into shared or global memory + * and the kernel will get considerably slower. + */ + + +#include +#include +using thrust::complex; + +#define pr_dlayer(k) addr[(k)] +#define ex_dlayer(k) addr[6 * num_pods + (k)] +#define obj_dlayer(k) addr[3 * num_pods + (k)] +#define obj_roi_row(k) addr[4 * num_pods + (k)] +#define obj_roi_column(k) addr[5 * num_pods + (k)] + +extern "C" __global__ void ob_update2_ML(int pr_sh, + int ob_modes, + int num_pods, + int ob_sh_rows, + int ob_sh_cols, + int pr_modes, + int ex_0, + int ex_1, + int ex_2, + complex* ob_g, + const complex* __restrict__ pr_g, + const complex* __restrict__ ex_g, + const int* addr, + IN_TYPE fac_) +{ + int y = blockIdx.y * BDIM_Y + threadIdx.y; + int dy = ob_sh_rows; + int z = blockIdx.x * BDIM_X + threadIdx.x; + int dz = ob_sh_cols; + MATH_TYPE fac = fac_; + complex ob[NUM_MODES]; + + + int txy = threadIdx.y * BDIM_X + threadIdx.x; + assert(ob_modes <= NUM_MODES); + + if (y < dy && z < dz) + { +#pragma unroll + for (int i = 0; i < NUM_MODES; ++i) + { + auto idx = i * dy * dz + y * dz + z; + assert(idx < ob_modes * ob_sh_rows * ob_sh_cols); + ob[i] = ob_g[idx]; + } + } + + __shared__ int addresses[BDIM_X * BDIM_Y * 5]; + + for (int p = 0; p < num_pods; p += BDIM_X * BDIM_Y) + { + int mi = BDIM_X * BDIM_Y; + if (mi > num_pods - p) + mi = num_pods - p; + + if (p > 0) + __syncthreads(); + + if (txy < mi) + { + assert(p + txy < num_pods); + assert(txy < BDIM_X * BDIM_Y); + addresses[txy * 5 + 0] = pr_dlayer(p + txy); + addresses[txy * 5 + 1] = ex_dlayer(p + txy); + addresses[txy * 5 + 2] = obj_dlayer(p + txy); + assert(obj_dlayer(p + txy) < NUM_MODES); + assert(addresses[txy * 5 + 2] < NUM_MODES); + addresses[txy * 5 + 3] = obj_roi_row(p + txy); + addresses[txy * 5 + 4] = obj_roi_column(p + txy); + } + + __syncthreads(); + + if (y >= dy || z >= dz) + continue; + +#pragma unroll 4 + for (int i = 0; i < mi; ++i) + { + int* ad = addresses + i * 5; + int v1 = y - ad[3]; + int v2 = z - ad[4]; + if (v1 >= 0 && v1 < pr_sh && v2 >= 0 && v2 < pr_sh) + { + auto pridx = ad[0] * pr_sh * pr_sh + v1 * pr_sh + v2; + assert(pridx < pr_modes * pr_sh * pr_sh); + complex pr = pr_g[pridx]; + int idx = ad[2]; + assert(idx < NUM_MODES); + auto cpr = conj(pr); + auto exidx = ad[1] * pr_sh * pr_sh + v1 * pr_sh + v2; + assert(exidx < ex_0 * ex_1 * ex_2); + complex t_ex_g = ex_g[exidx]; + complex add_val = cpr * t_ex_g * fac; + ob[idx] += add_val; + } + } + } + + if (y < dy && z < dz) + { + for (int i = 0; i < NUM_MODES; ++i) + { + ob_g[i * dy * dz + y * dz + z] = ob[i]; + } + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/ob_update_ML.cu b/ptypy/accelerate/cuda_pycuda/cuda/ob_update_ML.cu new file mode 100644 index 000000000..84e678ebb --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/ob_update_ML.cu @@ -0,0 +1,67 @@ +/** ob_update_ML. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + */ + +#include +using thrust::complex; + +template +__device__ inline void atomicAdd(complex* x, const complex& y) +{ + auto xf = reinterpret_cast(x); + atomicAdd(xf, y.real()); + atomicAdd(xf + 1, y.imag()); +} + +extern "C" +{ + __global__ void ob_update_ML(const complex* __restrict__ exit_wave, + int A, + int B, + int C, + const complex* __restrict__ probe, + int D, + int E, + int F, + complex* obj, + int G, + int H, + int I, + const int* __restrict__ addr, + IN_TYPE fac_) + { + const int bid = blockIdx.x; + const int tx = threadIdx.x; + const int ty = threadIdx.y; + const int addr_stride = 15; + MATH_TYPE fac = fac_; + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + + assert(oa[0] * H * I + oa[1] * I + oa[2] + (B - 1) * I + C - 1 < G * H * I); + + exit_wave += ea[0] * B * C; + + for (int b = ty; b < B; b += blockDim.y) + { + for (int c = tx; c < C; c += blockDim.x) + { + complex probe_val = probe[b * F + c]; + complex exit_val = exit_wave[b * C + c]; + complex add_val_m = conj(probe_val) * exit_val * fac; + complex add_val(add_val_m); + + atomicAdd(&obj[b * I + c], add_val); + } + } + } +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/ob_update_local.cu b/ptypy/accelerate/cuda_pycuda/cuda/ob_update_local.cu new file mode 100644 index 000000000..b3a955868 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/ob_update_local.cu @@ -0,0 +1,73 @@ +/** ob_update_local - in DR algorithm. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + */ + +#include +using thrust::complex; + +template +__device__ inline void atomicAdd(complex* x, const complex& y) +{ + auto xf = reinterpret_cast(x); + atomicAdd(xf, y.real()); + atomicAdd(xf + 1, y.imag()); +} + +extern "C" __global__ void ob_update_local( + const complex* __restrict__ exit_wave, + const complex* __restrict__ aux, + int A, + int B, + int C, + const complex* __restrict__ probe, + int D, + int E, + int F, + const IN_TYPE* __restrict__ pr_norm, + complex* obj, + int G, + int H, + int I, + const int* __restrict__ addr, + const IN_TYPE* pr_norm_max, + const IN_TYPE A_, + const IN_TYPE B_) +{ + const int bid = blockIdx.z; + const int tx = threadIdx.x; + const int b = threadIdx.y + blockIdx.y * blockDim.y; + if (b >= B) + return; + const int addr_stride = 15; + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + aux += bid * B * C; + const MATH_TYPE pr_norm_max_val = pr_norm_max[0]; + const MATH_TYPE A_val = A_; + const MATH_TYPE B_val = B_; + + assert(oa[0] * H * I + oa[1] * I + oa[2] + (B - 1) * I + C - 1 < G * H * I); + + exit_wave += ea[0] * B * C; + + for (int c = tx; c < C; c += blockDim.x) + { + complex probe_val = probe[b * F + c]; + complex exit_val = exit_wave[b * C + c]; + complex aux_val = aux[b * C + c]; + MATH_TYPE norm_val = (MATH_TYPE(1) - A_val) * pr_norm_max_val + A_val * pr_norm[b * F + c]; + + auto add_val_m = (A_val + B_val) * conj(probe_val) * (exit_val - aux_val) / norm_val; + complex add_val = add_val_m; + atomicAdd(&obj[b * I + c], add_val); + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/pr_norm_local.cu b/ptypy/accelerate/cuda_pycuda/cuda/pr_norm_local.cu new file mode 100644 index 000000000..6e9a8ea76 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/pr_norm_local.cu @@ -0,0 +1,59 @@ +/** pr_norm_local. +* +* Data types: +* - IN_TYPE: the data type for the inputs (float or double) +* - OUT_TYPE: the data type for the outputs (float or double) +* - MATH_TYPE: the data type used for computation +*/ + +#include +#include +#include +using std::sqrt; +using thrust::abs; +using thrust::complex; + +// specify max number of threads/block and min number of blocks per SM, +// to assist the compiler in register optimisations. +// We achieve a higher occupancy in this case, as less registers are used +// (guided by profiler) +extern "C" __global__ void __launch_bounds__(1024, 2) + pr_norm_local(OUT_TYPE *pr_norm, + int A, + int B, + int C, + const complex* __restrict__ probe, + int D, + int E, + int F, + const int* __restrict__ addr) +{ + const int bid = blockIdx.z; + const int tx = threadIdx.x; + const int b = threadIdx.y + blockIdx.y * blockDim.y; + const int addr_stride = 15; + + const int* pa = addr + 1 + (bid * D) * addr_stride; + const int* da = addr + 9 + (bid * D) * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + pr_norm += da[0] * B * C; + + if (b >= B) + return; + + for (int c = tx; c < C; c += blockDim.x) + { + MATH_TYPE acc = MATH_TYPE(0); + for (int idx = 0; idx < D; ++idx) + { + complex probe_val = probe[b * F + c + idx * E * F]; + MATH_TYPE abs_probe_val = abs(probe_val); + acc += abs_probe_val * + abs_probe_val; // if we do this manually (real*real +imag*imag) + // we get differences to numpy due to rounding + } + pr_norm[b * C + c] = acc; + } + +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/pr_update.cu b/ptypy/accelerate/cuda_pycuda/cuda/pr_update.cu new file mode 100644 index 000000000..180cf8f14 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/pr_update.cu @@ -0,0 +1,69 @@ +/** pr_update. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + */ + +#include +using thrust::complex; + +template +__device__ inline void atomicAdd(complex* x, const complex& y) +{ + auto xf = reinterpret_cast(x); + atomicAdd(xf, T(y.real())); + atomicAdd(xf + 1, T(y.imag())); +} + +extern "C" __global__ void pr_update( + const complex* __restrict__ exit_wave, + int A, + int B, + int C, + complex* probe, + int D, + int E, + int F, + const complex* __restrict__ obj, + int G, + int H, + int I, + const int* __restrict__ addr, + OUT_TYPE* denominator) +{ + assert(B == E); // prsh[1] + assert(C == F); // prsh[2] + const int bid = blockIdx.x; + const int tx = threadIdx.x; + const int ty = threadIdx.y; + const int addr_stride = 15; + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + denominator += pa[0] * E * F + pa[1] * F + pa[2]; + + assert(oa[0] * H * I + oa[1] * I + oa[2] + (B - 1) * I + C - 1 < G * H * I); + + exit_wave += ea[0] * B * C; + + for (int b = ty; b < B; b += blockDim.y) + { + for (int c = tx; c < C; c += blockDim.x) + { + complex obj_val = obj[b * I + c]; + complex exit_val = exit_wave[b * C + c]; + complex add_val_m = conj(obj_val) * exit_val; + complex add_val = add_val_m; + atomicAdd(&probe[b * F + c], add_val); + MATH_TYPE upd_obj = + obj_val.real() * obj_val.real() + obj_val.imag() * obj_val.imag(); + atomicAdd(&denominator[b * F + c], upd_obj); + } + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/pr_update2.cu b/ptypy/accelerate/cuda_pycuda/cuda/pr_update2.cu new file mode 100644 index 000000000..e5417cc01 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/pr_update2.cu @@ -0,0 +1,124 @@ +/** pr_update. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + * - ACC_TYPE: accumulator type for local pr array + * + * NOTE: This version of ob_update goes over all tiles that need to be accumulated + * in a single thread block to avoid global atomic additions (as in pr_update.cu). + * This requires a local array of NUM_MODES size to store the local updates. + * GPU registers per thread are limited (255 32bit registers on V100), + * and at some point the registers will spill into shared or global memory + * and the kernel will get considerably slower. + */ + +#include +#include +using thrust::complex; + +#define pr_dlayer(k) addr[(k)] +#define pr_roi_row(k) addr[1 * num_pods + (k)] +#define pr_roi_column(k) addr[2 * num_pods + (k)] +#define ex_dlayer(k) addr[6 * num_pods + (k)] +#define obj_dlayer(k) addr[3 * num_pods + (k)] +#define obj_roi_row(k) addr[4 * num_pods + (k)] +#define obj_roi_column(k) addr[5 * num_pods + (k)] + + +extern "C" __global__ void pr_update2(int pr_sh, + int ob_sh_row, + int ob_sh_col, + int pr_modes, + int ob_modes, + int num_pods, + complex* pr_g, + OUT_TYPE* prn_g, + const complex* __restrict__ ob_g, + const complex* __restrict__ ex_g, + const int* addr) +{ + int y = blockIdx.y * BDIM_Y + threadIdx.y; + int dy = pr_sh; + int z = blockIdx.x * BDIM_X + threadIdx.x; + int dz = pr_sh; + complex pr[NUM_MODES]; + ACC_TYPE prn[NUM_MODES]; + + int txy = threadIdx.y * BDIM_X + threadIdx.x; + assert(pr_modes <= NUM_MODES); + + if (y < pr_sh && z < pr_sh) + { +#pragma unroll + for (int i = 0; i < NUM_MODES; ++i) + { + auto idx = i * dy * dz + y * dz + z; + assert(idx < pr_modes * pr_sh * pr_sh); + pr[i] = pr_g[idx]; + prn[i] = prn_g[idx]; + } + } + + __shared__ int addresses[BDIM_X * BDIM_Y * 5]; + + for (int p = 0; p < num_pods; p += BDIM_X * BDIM_Y) + { + int mi = BDIM_X * BDIM_Y; + if (mi > num_pods - p) + mi = num_pods - p; + + if (p > 0) + __syncthreads(); + + if (txy < mi) + { + assert(p + txy < num_pods); + assert(txy < BDIM_X * BDIM_Y); + addresses[txy * 5 + 0] = pr_dlayer(p + txy); + addresses[txy * 5 + 1] = ex_dlayer(p + txy); + addresses[txy * 5 + 2] = obj_dlayer(p + txy); + assert(obj_dlayer(p + txy) < NUM_MODES); + assert(addresses[txy * 5 + 2] < NUM_MODES); + addresses[txy * 5 + 3] = obj_roi_row(p + txy); + addresses[txy * 5 + 4] = obj_roi_column(p + txy); + } + + __syncthreads(); + + if (y >= pr_sh || z >= pr_sh) + continue; + +#pragma unroll 4 + for (int i = 0; i < mi; ++i) + { + int* ad = addresses + i * 5; + int v1 = y + ad[3]; + int v2 = z + ad[4]; + if (v1 >= 0 && v1 < ob_sh_row && v2 >= 0 && v2 < ob_sh_col) + { + auto obidx = ad[2] * ob_sh_row * ob_sh_col + v1 * ob_sh_col + v2; + assert(obidx < ob_modes * ob_sh_row * ob_sh_col); + complex ob = ob_g[obidx]; + + int idx = ad[0]; + assert(idx < NUM_MODES); + auto cob = conj(ob); + complex ex_val = ex_g[ad[1] * pr_sh * pr_sh + y * pr_sh + z]; + complex add_val = cob * ex_val; + pr[idx] += add_val; + prn[idx] += ob.real() * ob.real() + ob.imag() * ob.imag(); + } + } + } + + if (y < pr_sh && z < pr_sh) + { + for (int i = 0; i < NUM_MODES; ++i) + { + pr_g[i * dy * dz + y * dz + z] = pr[i]; + prn_g[i * dy * dz + y * dz + z] = prn[i]; + } + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/pr_update2_ML.cu b/ptypy/accelerate/cuda_pycuda/cuda/pr_update2_ML.cu new file mode 100644 index 000000000..8a45891c5 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/pr_update2_ML.cu @@ -0,0 +1,121 @@ +/** pr_update. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + * - ACC_TYPE: accumulator type for local pr array + * + * NOTE: This version of ob_update goes over all tiles that need to be accumulated + * in a single thread block to avoid global atomic additions (as in pr_update_ML.cu). + * This requires a local array of NUM_MODES size to store the local updates. + * GPU registers per thread are limited (255 32bit registers on V100), + * and at some point the registers will spill into shared or global memory + * and the kernel will get considerably slower. + */ + +#include +#include +using thrust::complex; + +#define pr_dlayer(k) addr[(k)] +#define pr_roi_row(k) addr[1 * num_pods + (k)] +#define pr_roi_column(k) addr[2 * num_pods + (k)] +#define ex_dlayer(k) addr[6 * num_pods + (k)] +#define obj_dlayer(k) addr[3 * num_pods + (k)] +#define obj_roi_row(k) addr[4 * num_pods + (k)] +#define obj_roi_column(k) addr[5 * num_pods + (k)] + +extern "C" __global__ void pr_update2_ML(int pr_sh, + int ob_sh_row, + int ob_sh_col, + int pr_modes, + int ob_modes, + int num_pods, + complex* pr_g, + const complex* __restrict__ ob_g, + const complex* __restrict__ ex_g, + const int* addr, + IN_TYPE fac_) +{ + int y = blockIdx.y * BDIM_Y + threadIdx.y; + int dy = pr_sh; + int z = blockIdx.x * BDIM_X + threadIdx.x; + int dz = pr_sh; + MATH_TYPE fac = fac_; + complex pr[NUM_MODES]; + + int txy = threadIdx.y * BDIM_X + threadIdx.x; + assert(pr_modes <= NUM_MODES); + + if (y < pr_sh && z < pr_sh) + { +#pragma unroll + for (int i = 0; i < NUM_MODES; ++i) + { + auto idx = i * dy * dz + y * dz + z; + assert(idx < pr_modes * pr_sh * pr_sh); + pr[i] = pr_g[idx]; + } + } + + __shared__ int addresses[BDIM_X * BDIM_Y * 5]; + + for (int p = 0; p < num_pods; p += BDIM_X * BDIM_Y) + { + int mi = BDIM_X * BDIM_Y; + if (mi > num_pods - p) + mi = num_pods - p; + + if (p > 0) + __syncthreads(); + + if (txy < mi) + { + assert(p + txy < num_pods); + assert(txy < BDIM_X * BDIM_Y); + addresses[txy * 5 + 0] = pr_dlayer(p + txy); + addresses[txy * 5 + 1] = ex_dlayer(p + txy); + addresses[txy * 5 + 2] = obj_dlayer(p + txy); + assert(obj_dlayer(p + txy) < NUM_MODES); + assert(addresses[txy * 5 + 2] < NUM_MODES); + addresses[txy * 5 + 3] = obj_roi_row(p + txy); + addresses[txy * 5 + 4] = obj_roi_column(p + txy); + } + + __syncthreads(); + + if (y >= pr_sh || z >= pr_sh) + continue; + +#pragma unroll 4 + for (int i = 0; i < mi; ++i) + { + int* ad = addresses + i * 5; + int v1 = y + ad[3]; + int v2 = z + ad[4]; + if (v1 >= 0 && v1 < ob_sh_row && v2 >= 0 && v2 < ob_sh_col) + { + auto obidx = ad[2] * ob_sh_row * ob_sh_col + v1 * ob_sh_col + v2; + assert(obidx < ob_modes * ob_sh_row * ob_sh_col); + complex ob = ob_g[obidx]; + + int idx = ad[0]; + assert(idx < NUM_MODES); + auto cob = conj(ob); + complex ex_val = ex_g[ad[1] * pr_sh * pr_sh + y * pr_sh + z]; + complex add_val_m = cob * ex_val * fac; + complex add_val = add_val_m; + pr[idx] += add_val; + } + } + } + + if (y < pr_sh && z < pr_sh) + { + for (int i = 0; i < NUM_MODES; ++i) + { + pr_g[i * dy * dz + y * dz + z] = pr[i]; + } + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/pr_update_ML.cu b/ptypy/accelerate/cuda_pycuda/cuda/pr_update_ML.cu new file mode 100644 index 000000000..3fa24137d --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/pr_update_ML.cu @@ -0,0 +1,66 @@ +/** pr_update_ML. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + */ + + +#include +using thrust::complex; + +template +__device__ inline void atomicAdd(complex* x, const complex& y) +{ + auto xf = reinterpret_cast(x); + atomicAdd(xf, y.real()); + atomicAdd(xf + 1, y.imag()); +} + +extern "C" __global__ void pr_update_ML(const complex* __restrict__ exit_wave, + int A, + int B, + int C, + complex* probe, + int D, + int E, + int F, + const complex* __restrict__ obj, + int G, + int H, + int I, + const int* __restrict__ addr, + IN_TYPE fac_) +{ + assert(B == E); // prsh[1] + assert(C == F); // prsh[2] + const int bid = blockIdx.x; + const int tx = threadIdx.x; + const int ty = threadIdx.y; + const int addr_stride = 15; + MATH_TYPE fac = fac_; + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + + assert(oa[0] * H * I + oa[1] * I + oa[2] + (B - 1) * I + C - 1 < G * H * I); + + exit_wave += ea[0] * B * C; + + for (int b = ty; b < B; b += blockDim.y) + { + for (int c = tx; c < C; c += blockDim.x) + { + complex obj_val = obj[b * I + c]; + complex exit_val = exit_wave[b * C + c]; + complex add_val_m = conj(obj_val) * exit_val * fac; + complex add_val = add_val_m; + atomicAdd(&probe[b * F + c], add_val); + } + } +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/pr_update_local.cu b/ptypy/accelerate/cuda_pycuda/cuda/pr_update_local.cu new file mode 100644 index 000000000..d515afd55 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/pr_update_local.cu @@ -0,0 +1,77 @@ +/** pr_update_local - for DR algorithm. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + * - MATH_TYPE: the data type used for computation + * - ACC_TYPE: data type used in norm calculation (input here) + */ + +#include +using thrust::complex; + +template +__device__ inline void atomicAdd(complex* x, const complex& y) +{ + auto xf = reinterpret_cast(x); + atomicAdd(xf, T(y.real())); + atomicAdd(xf + 1, T(y.imag())); +} + +extern "C" __global__ void pr_update_local( + const complex* __restrict__ exit_wave, + const complex* __restrict__ aux, + int A, + int B, + int C, + complex* probe, + int D, + int E, + int F, + const IN_TYPE* __restrict__ ob_norm, + const complex* __restrict__ obj, + int G, + int H, + int I, + const int* __restrict__ addr, + const IN_TYPE* ob_norm_max, + const IN_TYPE A_, + const IN_TYPE B_) +{ + assert(B == E); // prsh[1] + assert(C == F); // prsh[2] + const int bid = blockIdx.z; + const int tx = threadIdx.x; + const int b = threadIdx.y + blockIdx.y * blockDim.y; + if (b >= B) + return; + const int addr_stride = 15; + + const int* oa = addr + 3 + bid * addr_stride; + const int* pa = addr + bid * addr_stride; + const int* ea = addr + 6 + bid * addr_stride; + + probe += pa[0] * E * F + pa[1] * F + pa[2]; + obj += oa[0] * H * I + oa[1] * I + oa[2]; + aux += bid * B * C; + const MATH_TYPE ob_norm_max_val = ob_norm_max[0]; + const MATH_TYPE A_val = A_; + const MATH_TYPE B_val = B_; + + assert(oa[0] * H * I + oa[1] * I + oa[2] + (B - 1) * I + C - 1 < G * H * I); + + exit_wave += ea[0] * B * C; + + for (int c = tx; c < C; c += blockDim.x) + { + complex obj_val = obj[b * I + c]; + complex exit_val = exit_wave[b * C + c]; + complex aux_val = aux[b * C + c]; + MATH_TYPE norm_val = (MATH_TYPE(1) - A_val) * ob_norm_max_val + A_val * ob_norm[b * C + c]; + + complex add_val_m = (A_val + B_val) * conj(obj_val) * (exit_val - aux_val) / norm_val; + complex add_val = add_val_m; + atomicAdd(&probe[b * F + c], add_val); + } + +} diff --git a/ptypy/accelerate/cuda_pycuda/cuda/transpose.cu b/ptypy/accelerate/cuda_pycuda/cuda/transpose.cu new file mode 100644 index 000000000..8de4e7ad7 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/transpose.cu @@ -0,0 +1,45 @@ +/** Implementation taken from + * https://github.com/JonathanWatkins/CUDA/blob/master/NvidiaCourse/Exercises/transpose/transpose.cu + * + * Kernel optimised to ensure all global memory reads and writes are coalesced, + * and shared memory access has no bank conflicts. + */ + +/** + * Data types: + * - DTYPE - any pod type + */ + +#include +using thrust::complex; + +extern "C" __global__ void transpose(const DTYPE* idata, + DTYPE* odata, + int width, + int height) +{ + __shared__ DTYPE block[BDIM][BDIM + 1]; + + // read the matrix tile into shared memory + // load one element per thread from device memory (idata) and + // store it in transposed order in block[][] + unsigned int xIndex = blockIdx.x * BDIM + threadIdx.x; + unsigned int yIndex = blockIdx.y * BDIM + threadIdx.y; + if (xIndex < width && yIndex < height) + { + unsigned int index_in = yIndex * width + xIndex; + block[threadIdx.y][threadIdx.x] = idata[index_in]; + } + + // synchronise to ensure all writes to block[][] are complete + __syncthreads(); + + // write transposed matrix back to global memory (odata) in linear order + xIndex = blockIdx.y * BDIM + threadIdx.x; + yIndex = blockIdx.x * BDIM + threadIdx.y; + if (xIndex < height && yIndex < width) + { + unsigned int index_out = yIndex * height + xIndex; + odata[index_out] = block[threadIdx.x][threadIdx.y]; + } +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cuda/update_addr_error_state.cu b/ptypy/accelerate/cuda_pycuda/cuda/update_addr_error_state.cu new file mode 100644 index 000000000..1220a0986 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cuda/update_addr_error_state.cu @@ -0,0 +1,43 @@ +/** update_addr_error_state kernel. + * + * Data types: + * - IN_TYPE: the data type for the inputs (float or double) + * - OUT_TYPE: the data type for the outputs (float or double) + */ + +#include +#include +using thrust::complex; + +extern "C" __global__ void update_addr_error_state(int* __restrict addr, + const int* __restrict mangled_addr, + OUT_TYPE* error_state, + const IN_TYPE* __restrict error_sum, + int nmodes) +{ + int tx = threadIdx.x; + int row = blockIdx.y * blockDim.y + threadIdx.y; + + // we're using one warp only in x direction, to get implicit + // intra-warp sync between reading err_st and writing it + assert(blockDim.x <= 32); + + addr += row * nmodes * 15; + mangled_addr += row * nmodes * 15; + + auto err_sum = error_sum[row]; + auto err_st = error_state[row]; + + if (err_sum < err_st) + { + for (int i = tx, e = nmodes * 15; i < e; i += blockDim.x) + { + addr[i] = mangled_addr[i]; + } + } + + if (tx == 0 && err_sum < err_st) + { + error_state[row] = error_sum[row]; + } +} \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/cufft.py b/ptypy/accelerate/cuda_pycuda/cufft.py new file mode 100644 index 000000000..d10e82b1a --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/cufft.py @@ -0,0 +1,176 @@ +import skcuda.fft as cu_fft +from skcuda.fft import cufft as cufftlib +from pycuda import gpuarray +from . import load_kernel +import numpy as np + +class FFT_cuda(object): + + def __init__(self, array, queue=None, + inplace=False, + pre_fft=None, + post_fft=None, + symmetric=True, + forward=True): + self._queue = queue + dims = array.ndim + if dims < 2: + raise AssertionError('Input array must be at least 2-dimensional') + self.arr_shape = (array.shape[-2], array.shape[-1]) + rows = self.arr_shape[0] + columns = self.arr_shape[1] + if rows != columns or rows not in [16, 32, 64, 128, 256, 512, 1024, 2048]: + raise ValueError("CUDA FFT only supports powers of 2 for rows/columns, from 16 to 2048") + self.batches = int(np.product(array.shape[0:dims-2]) if dims > 2 else 1) + self.forward = forward + + self._load(array, pre_fft, post_fft, symmetric, forward) + + def _load(self, array, pre_fft, post_fft, symmetric, forward): + if pre_fft is not None: + self.pre_fft = gpuarray.to_gpu(pre_fft) + self.pre_fft_ptr = self.pre_fft.gpudata + else: + self.pre_fft_ptr = 0 + if post_fft is not None: + self.post_fft = gpuarray.to_gpu(post_fft) + self.post_fft_ptr = self.post_fft.gpudata + else: + self.post_fft_ptr = 0 + + import filtered_cufft + self.fftobj = filtered_cufft.FilteredFFT( + self.batches, + self.arr_shape[0], + self.arr_shape[1], + symmetric, + forward, + self.pre_fft_ptr, + self.post_fft_ptr, + self._queue.handle) + + self.ft = self._ft + self.ift = self._ift + + @property + def queue(self): + return self._queue + + @queue.setter + def queue(self, queue): + self._queue = queue + self.fftobj.queue = queue.handle + + def _ft(self, input, output): + self.fftobj.fft(input.gpudata, output.gpudata) + + def _ift(self, input, output): + self.fftobj.ifft(input.gpudata, output.gpudata) + + +class FFT_skcuda(FFT_cuda): + + @property + def queue(self): + return self._queue + + @queue.setter + def queue(self, queue): + self._queue = queue + cufftlib.cufftSetStream(self.plan.handle, queue.handle) + + def _load(self, array, pre_fft, post_fft, symmetric, forward): + assert(array.dtype in [np.complex64, np.complex128]) + assert(pre_fft.dtype in [np.complex64, np.complex128] if pre_fft is not None else True) + assert(post_fft.dtype in [np.complex64, np.complex128] if post_fft is not None else True) + + math_type = 'float' if array.dtype == np.complex64 else 'double' + if pre_fft is not None: + math_type = 'float' if pre_fft.dtype == np.complex64 else 'double' + self.pre_fft_knl = load_kernel("batched_multiply", { + 'MPY_DO_SCALE': 'false', + 'MPY_DO_FILT': 'true', + 'IN_TYPE': 'float' if array.dtype == np.complex64 else 'double', + 'OUT_TYPE': 'float' if array.dtype == np.complex64 else 'double', + 'MATH_TYPE': math_type + }) if pre_fft is not None else None + + math_type = 'float' if array.dtype == np.complex64 else 'double' + if post_fft is not None: + math_type = 'float' if post_fft.dtype == np.complex64 else 'double' + self.post_fft_knl = load_kernel("batched_multiply", { + 'MPY_DO_SCALE': 'true' if (not forward and not symmetric) or symmetric else 'false', + 'MPY_DO_FILT': 'true' if post_fft is not None else 'false', + 'IN_TYPE': 'float' if array.dtype == np.complex64 else 'double', + 'OUT_TYPE': 'float' if array.dtype == np.complex64 else 'double', + 'MATH_TYPE': math_type + }) if (not (forward and not symmetric) or post_fft is not None) else None + + self.block = (32, 32, 1) + self.grid = ( + int((self.arr_shape[0] + 31) // 32), + int((self.arr_shape[1] + 31) // 32), + int(self.batches) + ) + self.plan = cu_fft.Plan( + self.arr_shape, + array.dtype, + array.dtype, + self.batches, + self._queue + ) + # with cuFFT, we need to scale ifft + if not symmetric and not forward: + self.scale = 1 / np.product(self.arr_shape) + elif forward and not symmetric: + self.scale = 1.0 + else: + self.scale = 1 / np.sqrt(np.product(self.arr_shape)) + + if pre_fft is not None: + self.pre_fft = gpuarray.to_gpu(pre_fft) + else: + self.pre_fft = np.intp(0) # NULL + if post_fft is not None: + self.post_fft = gpuarray.to_gpu(post_fft) + else: + self.post_fft = np.intp(0) + + self.ft = self._ft + self.ift = self._ift + + def _prefilt(self, x, y): + if self.pre_fft_knl: + self.pre_fft_knl(x, y, self.pre_fft, + np.float32(self.scale), + np.int32(self.batches), + np.int32(self.arr_shape[0]), + np.int32(self.arr_shape[1]), + block=self.block, + grid=self.grid, + stream=self._queue) + return y + else: + return x + + def _postfilt(self, y): + if self.post_fft_knl: + assert self.post_fft is not None + assert self.scale is not None + self.post_fft_knl(y, y, self.post_fft, np.float32(self.scale), + np.int32(self.batches), + np.int32(self.arr_shape[0]), + np.int32(self.arr_shape[1]), + block=self.block, grid=self.grid, + stream=self._queue) + + def _ft(self, x, y): + d = self._prefilt(x, y) + cu_fft.fft(d, y, self.plan) + self._postfilt(y) + + def _ift(self, x, y): + d = self._prefilt(x, y) + cu_fft.ifft(d, y, self.plan) + self._postfilt(y) + diff --git a/ptypy/accelerate/cuda_pycuda/dependencies.yml b/ptypy/accelerate/cuda_pycuda/dependencies.yml new file mode 100644 index 000000000..93ac5cd68 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/dependencies.yml @@ -0,0 +1,20 @@ +name: ptypy_pycuda +channels: + - conda-forge +dependencies: + - python=3.9 + - numpy + - scipy + - matplotlib + - h5py + - pyzmq + - mpi4py + - pillow + - pyfftw + - reikna + - pycuda + - cudatoolkit-dev + - pip + - compilers + - pip: + - scikit-cuda \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/engines/ML_pycuda.py b/ptypy/accelerate/cuda_pycuda/engines/ML_pycuda.py new file mode 100644 index 000000000..2022a2bdf --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/engines/ML_pycuda.py @@ -0,0 +1,789 @@ +# -*- coding: utf-8 -*- +""" +Maximum Likelihood reconstruction engine. + +TODO. + + * Implement other regularizers + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" +import numpy as np +from pycuda import gpuarray +import pycuda.driver as cuda +import pycuda.cumath +from pycuda.tools import DeviceMemoryPool + +from ptypy.engines import register +from ptypy.accelerate.base.engines.ML_serial import ML_serial, BaseModelSerial +from ptypy import utils as u +from ptypy.utils.verbose import logger, log +from ptypy.utils import parallel +from .. import get_context +from ..kernels import PropagationKernel, RealSupportKernel, FourierSupportKernel +from ..kernels import GradientDescentKernel, AuxiliaryWaveKernel, PoUpdateKernel, PositionCorrectionKernel +from ..array_utils import ArrayUtilsKernel, DerivativesKernel, GaussianSmoothingKernel, TransposeKernel + +from ..mem_utils import GpuDataManager +from ptypy.accelerate.base import address_manglers + +__all__ = ['ML_pycuda'] + +MAX_BLOCKS = 99999 # can be used to limit the number of blocks, simulating that they don't fit +#MAX_BLOCKS = 3 # can be used to limit the number of blocks, simulating that they don't fit + +@register() +class ML_pycuda(ML_serial): + + """ + Defaults: + + [probe_update_cuda_atomics] + default = False + type = bool + help = For GPU, use the atomics version for probe update kernel + + [object_update_cuda_atomics] + default = True + type = bool + help = For GPU, use the atomics version for object update kernel + + [use_cuda_device_memory_pool] + default = True + type = bool + help = For GPU, use a device memory pool + + [fft_lib] + default = reikna + type = str + help = Choose the pycuda-compatible FFT module. + doc = One of: + - ``'reikna'`` : the reikna packaga (fast load, competitive compute for streaming) + - ``'cuda'`` : ptypy's cuda wrapper (delayed load, but fastest compute if all data is on GPU) + - ``'skcuda'`` : scikit-cuda (fast load, slowest compute due to additional store/load stages) + choices = 'reikna','cuda','skcuda' + userlevel = 2 + + """ + + def __init__(self, ptycho_parent, pars=None): + """ + Maximum likelihood reconstruction engine. + """ + super().__init__(ptycho_parent, pars) + + def engine_initialize(self): + """ + Prepare for ML reconstruction. + """ + self.context, self.queue = get_context(new_context=True, new_queue=True) + + if self.p.use_cuda_device_memory_pool: + self._dmp = DeviceMemoryPool() + self.allocate = self._dmp.allocate + else: + self._dmp = None + self.allocate = cuda.mem_alloc + + self.qu_htod = cuda.Stream() + self.qu_dtoh = cuda.Stream() + + self.GSK = GaussianSmoothingKernel(queue=self.queue) + self.GSK.tmp = None + + # Real/Fourier Support Kernel + self.RSK = {} + self.FSK = {} + + super().engine_initialize() + #self._setup_kernels() + + def _setup_kernels(self): + """ + Setup kernels, one for each scan. Derive scans from ptycho class + """ + AUK = ArrayUtilsKernel(queue=self.queue) + self._dot_kernel = AUK.dot + # get the scans + for label, scan in self.ptycho.model.scans.items(): + + kern = u.Param() + kern.scanmodel = type(scan).__name__ + self.kernels[label] = kern + + # TODO: needs to be adapted for broad bandwidth + geo = scan.geometries[0] + + # Get info to shape buffer arrays + fpc = scan.max_frames_per_block + + # TODO : make this more foolproof + try: + nmodes = scan.p.coherence.num_probe_modes * \ + scan.p.coherence.num_object_modes + except: + nmodes = 1 + + # create buffer arrays + ash = (fpc * nmodes,) + tuple([int(s) for s in geo.shape]) + aux = gpuarray.zeros(ash, dtype=np.complex64) + kern.aux = aux + kern.a = gpuarray.zeros(ash, dtype=np.complex64) + kern.b = gpuarray.zeros(ash, dtype=np.complex64) + + # setup kernels, one for each SCAN. + kern.GDK = GradientDescentKernel(aux, nmodes, queue=self.queue, math_type="double") + kern.GDK.allocate() + + kern.POK = PoUpdateKernel(queue_thread=self.queue) + kern.POK.allocate() + + kern.AWK = AuxiliaryWaveKernel(queue_thread=self.queue) + kern.AWK.allocate() + + kern.TK = TransposeKernel(queue=self.queue) + + kern.PROP = PropagationKernel(aux, geo.propagator, queue_thread=self.queue, fft=self.p.fft_lib) + kern.PROP.allocate() + kern.resolution = geo.resolution[0] + + if self.do_position_refinement: + kern.PCK = PositionCorrectionKernel(aux, nmodes, self.p.position_refinement, geo.resolution, queue_thread=self.queue) + kern.PCK.allocate() + + mag_mem = 0 + for scan, kern in self.kernels.items(): + mag_mem = max(kern.aux.nbytes // 2, mag_mem) + ma_mem = mag_mem + mem = cuda.mem_get_info()[0] + blk = ma_mem + mag_mem + fit = int(mem - 200 * 1024 * 1024) // blk # leave 200MB room for safety + if not fit: + log(1,"Cannot fit memory into device, if possible reduce frames per block. Exiting...") + self.context.pop() + self.context.detach() + raise SystemExit("ptypy has been exited.") + + # TODO grow blocks dynamically + nma = min(fit, MAX_BLOCKS) + log(4, 'Free memory on device: %.2f GB' % (float(mem)/1e9)) + log(4, 'PyCUDA max blocks fitting on GPU: ma_arrays={}'.format(nma)) + # reset memory or create new + self.w_data = GpuDataManager(ma_mem, 0, nma, False) + self.I_data = GpuDataManager(mag_mem, 0, nma, False) + + def engine_prepare(self): + + super().engine_prepare() + ## Serialize new data ## + use_tiles = (not self.p.probe_update_cuda_atomics) or (not self.p.object_update_cuda_atomics) + + # recursive copy to gpu for probe and object + for _cname, c in self.ptycho.containers.items(): + if c.original != self.pr and c.original != self.ob: + continue + for _sname, s in c.S.items(): + # convert data here + s.gpu = gpuarray.to_gpu(s.data) + s.cpu = cuda.pagelocked_empty(s.data.shape, s.data.dtype, order="C") + s.cpu[:] = s.data + + for label, d in self.ptycho.new_data: + prep = self.diff_info[d.ID] + prep.err_phot_gpu = gpuarray.to_gpu(prep.err_phot) + prep.fic_gpu = gpuarray.ones_like(prep.err_phot_gpu) + + if use_tiles: + prep.addr2 = np.ascontiguousarray(np.transpose(prep.addr, (2, 3, 0, 1))) + + prep.addr_gpu = gpuarray.to_gpu(prep.addr) + if self.do_position_refinement: + prep.original_addr_gpu = gpuarray.to_gpu(prep.original_addr) + prep.error_state_gpu = gpuarray.empty_like(prep.err_phot_gpu) + prep.mangled_addr_gpu = prep.addr_gpu.copy() + + # Todo: Which address to pick? + if use_tiles: + prep.addr2_gpu = gpuarray.to_gpu(prep.addr2) + + prep.I = cuda.pagelocked_empty(d.data.shape, d.data.dtype, order="C", mem_flags=4) + prep.I[:] = d.data + + # Todo: avoid that extra copy of data + if self.do_position_refinement: + ma = self.ma.S[d.ID].data.astype(np.float32) + prep.ma = cuda.pagelocked_empty(ma.shape, ma.dtype, order="C", mem_flags=4) + prep.ma[:] = ma + + log(4, 'Free memory on device: %.2f GB' % (float(cuda.mem_get_info()[0])/1e9)) + self.w_data.add_data_block() + self.I_data.add_data_block() + + self.dID_list = list(self.di.S.keys()) + + def _initialize_model(self): + + # Create noise model + if self.p.ML_type.lower() == "gaussian": + self.ML_model = GaussianModel(self) + elif self.p.ML_type.lower() == "poisson": + raise NotImplementedError('Poisson norm model not yet implemented') + elif self.p.ML_type.lower() == "euclid": + raise NotImplementedError('Euclid norm model not yet implemented') + else: + raise RuntimeError("Unsupported ML_type: '%s'" % self.p.ML_type) + + def _set_pr_ob_ref_for_data(self, dev='gpu', container=None, sync_copy=False): + """ + Overloading the context of Storage.data here, to allow for in-place math on Container instances: + """ + if container is not None: + if container.original==self.pr or container.original==self.ob: + for s in container.S.values(): + # convert data here + if dev == 'gpu': + s.data = s.gpu + if sync_copy: s.gpu.set(s.cpu) + elif dev == 'cpu': + s.data = s.cpu + if sync_copy: + s.gpu.get(s.cpu) + #print('%s to cpu' % s.ID) + else: + for container in self.ptycho.containers.values(): + self._set_pr_ob_ref_for_data(dev=dev, container=container, sync_copy=sync_copy) + + def _get_smooth_gradient(self, data, sigma): + if self.GSK.tmp is None: + self.GSK.tmp = gpuarray.empty(data.shape, dtype=np.complex64) + self.GSK.convolution(data, [sigma, sigma], tmp=self.GSK.tmp) + return data + + def _replace_ob_grad(self): + new_ob_grad = self.ob_grad_new + # Smoothing preconditioner + if self.smooth_gradient: + self.smooth_gradient.sigma *= (1. - self.p.smooth_gradient_decay) + for name, s in new_ob_grad.storages.items(): + s.gpu = self._get_smooth_gradient(s.gpu, self.smooth_gradient.sigma) + + return self._replace_grad(self.ob_grad, new_ob_grad) + + def _replace_pr_grad(self): + new_pr_grad = self.pr_grad_new + # probe support + if self.p.probe_update_start <= self.curiter: + # Apply probe support if needed + for name, s in new_pr_grad.storages.items(): + self.support_constraint(s) + else: + new_pr_grad.fill(0.) + + return self._replace_grad(self.pr_grad , new_pr_grad) + + def _replace_grad(self, grad, new_grad): + norm = np.double(0.) + dot = np.double(0.) + for name, new in new_grad.storages.items(): + old = grad.storages[name] + norm += self._dot_kernel(new.gpu,new.gpu).get()[0] + dot += self._dot_kernel(new.gpu,old.gpu).get()[0] + old.gpu[:] = new.gpu + return norm, dot + + def engine_iterate(self, num=1): + err = super().engine_iterate(num) + # copy all data back to cpu + self._set_pr_ob_ref_for_data(dev='cpu', container=None, sync_copy=True) + return err + + def position_update(self): + """ + Position refinement + """ + if not self.do_position_refinement or (not self.curiter): + return + do_update_pos = (self.p.position_refinement.stop > self.curiter >= self.p.position_refinement.start) + do_update_pos &= (self.curiter % self.p.position_refinement.interval) == 0 + use_tiles = (not self.p.probe_update_cuda_atomics) or (not self.p.object_update_cuda_atomics) + + # Update positions + if do_update_pos: + """ + Iterates through all positions and refines them by a given algorithm. + """ + log(4, "----------- START POS REF -------------") + for dID in self.dID_list: + + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + ob = self.ob.S[oID].gpu + pr = self.pr.S[pID].gpu + kern = self.kernels[prep.label] + aux = kern.aux + addr = prep.addr_gpu + original_addr = prep.original_addr + mangled_addr = prep.mangled_addr_gpu + err_phot = prep.err_phot_gpu + error_state = prep.error_state_gpu + + # copy intensities and weights to GPU + ev_w, w, data_w = self.w_data.to_gpu(prep.weights, dID, self.qu_htod) + ev, I, data_I = self.I_data.to_gpu(prep.I, dID, self.qu_htod) + + PCK = kern.PCK + TK = kern.TK + PROP = kern.PROP + + # Keep track of object boundaries + max_oby = ob.shape[-2] - aux.shape[-2] - 1 + max_obx = ob.shape[-1] - aux.shape[-1] - 1 + + # We need to re-calculate the current error + PCK.build_aux(aux, addr, ob, pr) + PROP.fw(aux, aux) + PCK.queue.wait_for_event(ev) + # w & I now on device + PCK.log_likelihood_ml(aux, addr, I, w, err_phot) + cuda.memcpy_dtod(dest=error_state.ptr, + src=err_phot.ptr, + size=err_phot.nbytes) + + PCK.mangler.setup_shifts(self.curiter, nframes=addr.shape[0]) + + log(4, 'Position refinement trial: iteration %s' % (self.curiter)) + for i in range(PCK.mangler.nshifts): + PCK.mangler.get_address(i, addr, mangled_addr, max_oby, max_obx) + PCK.build_aux(aux, mangled_addr, ob, pr) + PROP.fw(aux, aux) + PCK.log_likelihood_ml(aux, mangled_addr, I, w, err_phot) + PCK.update_addr_and_error_state(addr, error_state, mangled_addr, err_phot) + + data_w.record_done(self.queue, 'compute') + data_I.record_done(self.queue, 'compute') + cuda.memcpy_dtod(dest=err_phot.ptr, + src=error_state.ptr, + size=err_phot.nbytes) + if use_tiles: + s1 = addr.shape[0] * addr.shape[1] + s2 = addr.shape[2] * addr.shape[3] + TK.transpose(addr.reshape(s1, s2), prep.addr2_gpu.reshape(s2, s1)) + + self.dID_list.reverse() + + def support_constraint(self, storage=None): + """ + Enforces 2D support constraint on probe. + """ + if storage is None: + for s in self.pr.storages.values(): + self.support_constraint(s) + + # Fourier space + support = self._probe_fourier_support.get(storage.ID) + if support is not None: + if storage.ID not in self.FSK: + supp = support.astype(np.complex64) + self.FSK[storage.ID] = FourierSupportKernel(supp, self.queue, self.p.fft_lib) + self.FSK[storage.ID].allocate() + self.FSK[storage.ID].apply_fourier_support(storage.gpu) + + # Real space + support = self._probe_support.get(storage.ID) + if support is not None: + if storage.ID not in self.RSK: + self.RSK[storage.ID] = RealSupportKernel(support.astype(np.complex64)) + self.RSK[storage.ID].allocate() + self.RSK[storage.ID].apply_real_support(storage.gpu) + + def engine_finalize(self): + """ + Clear all GPU data, pinned memory, etc + """ + self.w_data = None + self.I_data = None + + for name, s in self.pr.S.items(): + s.data = s.gpu.get() # need this, otherwise getting segfault once context is detached + # no longer need those + del s.gpu + del s.cpu + for name, s in self.ob.S.items(): + s.data = s.gpu.get() # need this, otherwise getting segfault once context is detached + # no longer need those + del s.gpu + del s.cpu + for dID, prep in self.diff_info.items(): + prep.addr = prep.addr_gpu.get() + prep.float_intens_coeff = prep.fic_gpu.get() + + + #self.queue.synchronize() + self.context.pop() + self.context.detach() + super().engine_finalize() + +class GaussianModel(BaseModelSerial): + """ + Gaussian noise model. + TODO: feed actual statistical weights instead of using the Poisson statistic heuristic. + """ + + def __init__(self, MLengine): + """ + Core functions for ML computation using a Gaussian model. + """ + super(GaussianModel, self).__init__(MLengine) + + if self.p.reg_del2: + self.regularizer = Regul_del2_pycuda( + self.p.reg_del2_amplitude, + queue=self.engine.queue, + allocator=self.engine.allocate + ) + else: + self.regularizer = None + + def prepare(self): + + super(GaussianModel, self).prepare() + + for label, d in self.engine.ptycho.new_data: + prep = self.engine.diff_info[d.ID] + w = (self.Irenorm * self.engine.ma.S[d.ID].data + / (1. / self.Irenorm + d.data)).astype(d.data.dtype) + prep.weights = cuda.pagelocked_empty(w.shape, w.dtype, order="C", mem_flags=4) + prep.weights[:] = w + + def __del__(self): + """ + Clean up routine + """ + super(GaussianModel, self).__del__() + + def new_grad(self): + """ + Compute a new gradient direction according to a Gaussian noise model. + + Note: The negative log-likelihood and local errors are also computed + here. + """ + ob_grad = self.engine.ob_grad_new + pr_grad = self.engine.pr_grad_new + qu_htod = self.engine.qu_htod + queue = self.engine.queue + + self.engine._set_pr_ob_ref_for_data('gpu') + ob_grad << 0. + pr_grad << 0. + + # We need an array for MPI + LL = np.array([0.]) + error_dct = {} + + for dID in self.engine.dID_list: + prep = self.engine.diff_info[dID] + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # references for kernels + kern = self.engine.kernels[prep.label] + GDK = kern.GDK + AWK = kern.AWK + POK = kern.POK + aux = kern.aux + + FW = kern.PROP.fw + BW = kern.PROP.bw + + # get addresses and auxilliary array + addr = prep.addr_gpu + fic = prep.fic_gpu + + err_phot = prep.err_phot_gpu + # local references + ob = self.engine.ob.S[oID].data + obg = ob_grad.S[oID].data + pr = self.engine.pr.S[pID].data + prg = pr_grad.S[pID].data + + # Schedule w & I to device + ev_w, w, data_w = self.engine.w_data.to_gpu(prep.weights, dID, qu_htod) + ev, I, data_I = self.engine.I_data.to_gpu(prep.I, dID, qu_htod) + + # make propagated exit (to buffer) + AWK.build_aux_no_ex(aux, addr, ob, pr, add=False) + + # forward prop + FW(aux, aux) + GDK.make_model(aux, addr) + + queue.wait_for_event(ev) + + if self.p.floating_intensities: + GDK.floating_intensity(addr, w, I, fic) + + GDK.main(aux, addr, w, I) + data_w.record_done(queue, 'compute') + data_I.record_done(queue, 'compute') + + GDK.error_reduce(addr, err_phot) + + BW(aux, aux) + + use_atomics = self.p.object_update_cuda_atomics + addr = prep.addr_gpu if use_atomics else prep.addr2_gpu + POK.ob_update_ML(addr, obg, pr, aux, atomics=use_atomics) + + use_atomics = self.p.probe_update_cuda_atomics + addr = prep.addr_gpu if use_atomics else prep.addr2_gpu + POK.pr_update_ML(addr, prg, ob, aux, atomics=use_atomics) + + queue.synchronize() + self.engine.dID_list.reverse() + + # TODO we err_phot.sum, but not necessarily this error_dct until the end of contiguous iteration + for dID, prep in self.engine.diff_info.items(): + err_phot = prep.err_phot_gpu.get() + LL += err_phot.sum() + err_phot /= np.prod(prep.weights.shape[-2:]) + err_fourier = np.zeros_like(err_phot) + err_exit = np.zeros_like(err_phot) + errs = np.ascontiguousarray(np.vstack([err_fourier, err_phot, err_exit]).T) + error_dct.update(zip(prep.view_IDs, errs)) + + # MPI reduction of gradients + + # DtoH copies + for s in ob_grad.S.values(): + s.gpu.get(s.cpu) + for s in pr_grad.S.values(): + s.gpu.get(s.cpu) + self.engine._set_pr_ob_ref_for_data('cpu') + + ob_grad.allreduce() + pr_grad.allreduce() + parallel.allreduce(LL) + + # HtoD cause we continue on gpu + for s in ob_grad.S.values(): + s.gpu.set(s.cpu) + for s in pr_grad.S.values(): + s.gpu.set(s.cpu) + self.engine._set_pr_ob_ref_for_data('gpu') + + # Object regularizer + if self.regularizer: + for name, s in self.engine.ob.storages.items(): + ob_grad.storages[name].data += self.regularizer.grad(s.data) + LL += self.regularizer.LL + + self.LL = LL / self.tot_measpts + + return error_dct + + def poly_line_coeffs(self, c_ob_h, c_pr_h): + """ + Compute the coefficients of the polynomial for line minimization + in direction h + """ + self.engine._set_pr_ob_ref_for_data('gpu') + qu_htod = self.engine.qu_htod + queue = self.engine.queue + + B = gpuarray.zeros((3,), dtype=np.float32) # does not accept np.longdouble + Brenorm = 1. / self.LL[0] ** 2 + + # Outer loop: through diffraction patterns + for dID in self.engine.dID_list: + prep = self.engine.diff_info[dID] + + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # references for kernels + kern = self.engine.kernels[prep.label] + GDK = kern.GDK + AWK = kern.AWK + + f = kern.aux + a = kern.a + b = kern.b + + FW = kern.PROP.fw + + # get addresses and auxiliary arrays + addr = prep.addr_gpu + fic = prep.fic_gpu + + # Schedule w & I to device + ev_w, w, data_w = self.engine.w_data.to_gpu(prep.weights, dID, qu_htod) + ev, I, data_I = self.engine.I_data.to_gpu(prep.I, dID, qu_htod) + + # local references + ob = self.ob.S[oID].data + ob_h = c_ob_h.S[oID].data + pr = self.pr.S[pID].data + pr_h = c_pr_h.S[pID].data + + # make propagated exit (to buffer) + AWK.build_aux_no_ex(f, addr, ob, pr, add=False) + AWK.build_aux_no_ex(a, addr, ob_h, pr, add=False) + AWK.build_aux_no_ex(a, addr, ob, pr_h, add=True) + AWK.build_aux_no_ex(b, addr, ob_h, pr_h, add=False) + + # forward prop + FW(f,f) + FW(a,a) + FW(b,b) + + queue.wait_for_event(ev) + + GDK.make_a012(f, a, b, addr, I, fic) + GDK.fill_b(addr, Brenorm, w, B) + + data_w.record_done(queue, 'compute') + data_I.record_done(queue, 'compute') + + queue.synchronize() + self.engine.dID_list.reverse() + + B = B.get() + parallel.allreduce(B) + + # Object regularizer + if self.regularizer: + for name, s in self.ob.storages.items(): + B += Brenorm * self.regularizer.poly_line_coeffs( + c_ob_h.storages[name].data, s.data) + + self.B = B + + return B + +class Regul_del2_pycuda(object): + """\ + Squared gradient regularizer (Gaussian prior). + + This class applies to any numpy array. + """ + def __init__(self, amplitude, axes=[-2, -1], queue=None, allocator=None): + # Regul.__init__(self, axes) + self.axes = axes + self.amplitude = amplitude + self.delxy = None + self.g = None + self.LL = None + self.queue = queue + self.AUK = ArrayUtilsKernel(queue=queue) + self.DELK_c = DerivativesKernel(np.complex64, queue=queue) + self.DELK_f = DerivativesKernel(np.float32, queue=queue) + + if allocator is None: + self._dmp = DeviceMemoryPool() + self.allocator=self._dmp.allocate + else: + self.allocator = allocator + self._dmp= None + + empty = lambda x: gpuarray.empty(x.shape, x.dtype, allocator=self.allocator) + + def delxb(x, axis=-1): + out = empty(x) + if x.dtype == np.float32: + self.DELK_f.delxb(x, out, axis) + elif x.dtype == np.complex64: + self.DELK_c.delxb(x, out, axis) + else: + raise TypeError("Type %s invalid for derivatives" % x.dtype) + return out + + self.delxb = delxb + + def delxf(x, axis=-1): + out = empty(x) + if x.dtype == np.float32: + self.DELK_f.delxf(x, out, axis) + elif x.dtype == np.complex64: + self.DELK_c.delxf(x, out, axis) + else: + raise TypeError("Type %s invalid for derivatives" % x.dtype) + return out + + self.delxf = delxf + self.norm = lambda x : self.AUK.norm2(x).get().item() + self.dot = lambda x, y : self.AUK.dot(x,y).get().item() + + from pycuda.elementwise import ElementwiseKernel + self._grad_reg_kernel = ElementwiseKernel( + "pycuda::complex *g, float fac, \ + pycuda::complex *py, pycuda::complex *px, \ + pycuda::complex *my, pycuda::complex *mx", + "g[i] = (px[i]+py[i]-my[i]-mx[i]) * fac", + "grad_reg", + ) + def grad(amp, px,py, mx, my): + out = empty(px) + self._grad_reg_kernel(out, amp, py, px, mx, my, stream=self.queue) + return out + self.reg_grad = grad + + def grad(self, x): + """ + Compute and return the regularizer gradient given the array x. + """ + ax0, ax1 = self.axes + del_xf = self.delxf(x, axis=ax0) + del_yf = self.delxf(x, axis=ax1) + del_xb = self.delxb(x, axis=ax0) + del_yb = self.delxb(x, axis=ax1) + + self.delxy = [del_xf, del_yf, del_xb, del_yb] + + # TODO this one might be slow, maybe try with elementwise kernel + #self.g = (del_xb + del_yb - del_xf - del_yf) * 2. * self.amplitude + self.g = self.reg_grad(2. * self.amplitude, del_xb, del_yb, del_xf, del_yf) + + + self.LL = self.amplitude * (self.norm(del_xf) + + self.norm(del_yf) + + self.norm(del_xb) + + self.norm(del_yb)) + + return self.g + + def poly_line_coeffs(self, h, x=None): + ax0, ax1 = self.axes + if x is None: + del_xf, del_yf, del_xb, del_yb = self.delxy + else: + del_xf = self.delxf(x, axis=ax0) + del_yf = self.delxf(x, axis=ax1) + del_xb = self.delxb(x, axis=ax0) + del_yb = self.delxb(x, axis=ax1) + + hdel_xf = self.delxf(h, axis=ax0) + hdel_yf = self.delxf(h, axis=ax1) + hdel_xb = self.delxb(h, axis=ax0) + hdel_yb = self.delxb(h, axis=ax1) + + c0 = self.amplitude * (self.norm(del_xf) + + self.norm(del_yf) + + self.norm(del_xb) + + self.norm(del_yb)) + + c1 = 2 * self.amplitude * (self.dot(del_xf, hdel_xf) + + self.dot(del_yf, hdel_yf) + + self.dot(del_xb, hdel_xb) + + self.dot(del_yb, hdel_yb)) + + c2 = self.amplitude * (self.norm(hdel_xf) + + self.norm(hdel_yf) + + self.norm(hdel_xb) + + self.norm(hdel_yb)) + + self.coeff = np.array([c0, c1, c2]) + return self.coeff diff --git a/ptypy/accelerate/cuda_pycuda/engines/__init__.py b/ptypy/accelerate/cuda_pycuda/engines/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/ptypy/accelerate/cuda_pycuda/engines/projectional_pycuda.py b/ptypy/accelerate/cuda_pycuda/engines/projectional_pycuda.py new file mode 100644 index 000000000..aa88a380f --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/engines/projectional_pycuda.py @@ -0,0 +1,603 @@ +# -*- coding: utf-8 -*- +""" +Difference Map reconstruction engine. + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" + +import numpy as np +import time +from pycuda import gpuarray +import pycuda.driver as cuda + +from ptypy import utils as u +from ptypy.utils.verbose import logger, log +from ptypy.utils import parallel +from ptypy.engines import register +from ptypy.engines.projectional import DMMixin, RAARMixin +from ptypy.accelerate.base.engines import projectional_serial +from .. import get_context +from ..kernels import FourierUpdateKernel, AuxiliaryWaveKernel, PoUpdateKernel, PositionCorrectionKernel +from ..kernels import PropagationKernel, RealSupportKernel, FourierSupportKernel +from ..array_utils import ArrayUtilsKernel, GaussianSmoothingKernel,\ +TransposeKernel, ClipMagnitudesKernel, MassCenterKernel, Abs2SumKernel,\ +InterpolatedShiftKernel +from ..mem_utils import make_pagelocked_paired_arrays as mppa +from ..multi_gpu import get_multi_gpu_communicator + +__all__ = ['DM_pycuda', 'RAAR_pycuda'] + +class _ProjectionEngine_pycuda(projectional_serial._ProjectionEngine_serial): + + """ + Defaults: + + [probe_update_cuda_atomics] + default = False + type = bool + help = For GPU, use the atomics version for probe update kernel + + [object_update_cuda_atomics] + default = True + type = bool + help = For GPU, use the atomics version for object update kernel + + [fft_lib] + default = reikna + type = str + help = Choose the pycuda-compatible FFT module. + doc = One of: + - ``'reikna'`` : the reikna packaga (fast load, competitive compute for streaming) + - ``'cuda'`` : ptypy's cuda wrapper (delayed load, but fastest compute if all data is on GPU) + - ``'skcuda'`` : scikit-cuda (fast load, slowest compute due to additional store/load stages) + choices = 'reikna','cuda','skcuda' + userlevel = 2 + + """ + def __init__(self, ptycho_parent, pars=None): + """ + Difference map reconstruction engine. + """ + super().__init__(ptycho_parent, pars) + self.multigpu = None + + def engine_initialize(self): + """ + Prepare for reconstruction. + """ + # Context, Multi GPU communicator and Stream (needs to be in this order) + self.context, self.queue = get_context(new_context=True, new_queue=False) + self.multigpu = get_multi_gpu_communicator() + self.context, self.queue = get_context(new_context=False, new_queue=True) + + # Gaussian Smoothing Kernel + self.GSK = GaussianSmoothingKernel(queue=self.queue) + + # Real/Fourier Support Kernel + self.RSK = {} + self.FSK = {} + + # Clip Magnitudes Kernel + self.CMK = ClipMagnitudesKernel(queue=self.queue) + + # initialise kernels for centring probe if required + if self.p.probe_center_tol is not None: + # mass center kernel + self.MCK = MassCenterKernel(queue=self.queue) + # absolute sum kernel + self.A2SK = Abs2SumKernel(dtype=self.pr.dtype, queue=self.queue) + # interpolated shift kernel + self.ISK = InterpolatedShiftKernel(queue=self.queue) + + super().engine_initialize() + + def _setup_kernels(self): + """ + Setup kernels, one for each scan. Derive scans from ptycho class + """ + # get the scans + for label, scan in self.ptycho.model.scans.items(): + + kern = u.Param() + kern.scanmodel = type(scan).__name__ + self.kernels[label] = kern + # TODO: needs to be adapted for broad bandwidth + geo = scan.geometries[0] + + # Get info to shape buffer arrays + fpc = scan.max_frames_per_block + + # TODO : make this more foolproof + try: + nmodes = scan.p.coherence.num_probe_modes * \ + scan.p.coherence.num_object_modes + except: + nmodes = 1 + + # create buffer arrays + ash = (fpc * nmodes,) + tuple(geo.shape) + aux = np.zeros(ash, dtype=np.complex64) + kern.aux = gpuarray.to_gpu(aux) + + # setup kernels, one for each SCAN. + log(4, "Setting up FourierUpdateKernel") + kern.FUK = FourierUpdateKernel(aux, nmodes, queue_thread=self.queue) + kern.FUK.allocate() + + log(4, "Setting up PoUpdateKernel") + kern.POK = PoUpdateKernel(queue_thread=self.queue) + kern.POK.allocate() + + log(4, "Setting up AuxiliaryWaveKernel") + kern.AWK = AuxiliaryWaveKernel(queue_thread=self.queue) + kern.AWK.allocate() + + log(4, "Setting up ArrayUtilsKernel") + kern.AUK = ArrayUtilsKernel(queue=self.queue) + + log(4, "Setting up TransposeKernel") + kern.TK = TransposeKernel(queue=self.queue) + + log(4, "Setting up PropagationKernel") + kern.PROP = PropagationKernel(aux, geo.propagator, self.queue, self.p.fft_lib) + kern.PROP.allocate() + kern.resolution = geo.resolution[0] + + if self.do_position_refinement: + log(4, "Setting up PositionCorrectionKernel") + kern.PCK = PositionCorrectionKernel(aux, nmodes, self.p.position_refinement, geo.resolution, queue_thread=self.queue) + kern.PCK.allocate() + log(4, "Kernel setup completed") + + def engine_prepare(self): + + super().engine_prepare() + + for name, s in self.ob.S.items(): + s.gpu = gpuarray.to_gpu(s.data) + for name, s in self.ob_buf.S.items(): + s.gpu, s.data = mppa(s.data) + for name, s in self.ob_nrm.S.items(): + s.gpu, s.data = mppa(s.data) + for name, s in self.pr.S.items(): + s.gpu, s.data = mppa(s.data) + for name, s in self.pr_buf.S.items(): + s.gpu, s.data = mppa(s.data) + for name, s in self.pr_nrm.S.items(): + s.gpu, s.data = mppa(s.data) + + use_tiles = (not self.p.probe_update_cuda_atomics) or (not self.p.object_update_cuda_atomics) + + # TODO : like the serialization this one is needed due to object reformatting + for label, d in self.di.storages.items(): + prep = self.diff_info[d.ID] + prep.addr_gpu = gpuarray.to_gpu(prep.addr) + if use_tiles: + prep.addr2 = np.ascontiguousarray(np.transpose(prep.addr, (2, 3, 0, 1))) + prep.addr2_gpu = gpuarray.to_gpu(prep.addr2) + if self.do_position_refinement: + prep.mangled_addr_gpu = prep.addr_gpu.copy() + + for label, d in self.ptycho.new_data: + prep = self.diff_info[d.ID] + pID, oID, eID = prep.poe_IDs + s = self.ex.S[eID] + s.gpu = gpuarray.to_gpu(s.data) + s = self.ma.S[d.ID] + s.gpu = gpuarray.to_gpu(s.data.astype(np.float32)) + + prep.mag = gpuarray.to_gpu(prep.mag) + prep.ma_sum = gpuarray.to_gpu(prep.ma_sum) + prep.err_fourier_gpu = gpuarray.to_gpu(prep.err_fourier) + prep.err_phot_gpu = gpuarray.to_gpu(prep.err_phot) + prep.err_exit_gpu = gpuarray.to_gpu(prep.err_exit) + if self.do_position_refinement: + prep.error_state_gpu = gpuarray.empty_like(prep.err_fourier_gpu) + + def engine_iterate(self, num=1): + """ + Compute one iteration. + """ + queue = self.queue + + for it in range(num): + error = {} + for dID in self.di.S.keys(): + + # find probe, object and exit ID in dependence of dID + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + + # references for kernels + kern = self.kernels[prep.label] + FUK = kern.FUK + AWK = kern.AWK + PROP = kern.PROP + + # get addresses and buffers + addr = prep.addr_gpu + mag = prep.mag + ma_sum = prep.ma_sum + err_fourier = prep.err_fourier_gpu + err_phot = prep.err_phot_gpu + err_exit = prep.err_exit_gpu + pbound = self.pbound_scan[prep.label] + aux = kern.aux + + # local references + ma = self.ma.S[dID].gpu + ob = self.ob.S[oID].gpu + pr = self.pr.S[pID].gpu + ex = self.ex.S[eID].gpu + + ## compute log-likelihood + if self.p.compute_log_likelihood: + AWK.build_aux_no_ex(aux, addr, ob, pr) + PROP.fw(aux, aux) + FUK.log_likelihood(aux, addr, mag, ma, err_phot) + + ## build auxilliary wave + #AWK.build_aux(aux, addr, ob, pr, ex, alpha=self.p.alpha) + AWK.make_aux(aux, addr, ob, pr, ex, c_po=self._c, c_e=1-self._c) + + ## forward FFT + PROP.fw(aux, aux) + + ## Deviation from measured data + FUK.fourier_error(aux, addr, mag, ma, ma_sum) + FUK.error_reduce(addr, err_fourier) + FUK.fmag_all_update(aux, addr, mag, ma, err_fourier, pbound) + + ## backward FFT + PROP.bw(aux, aux) + + ## build exit wave + #AWK.build_exit(aux, addr, ob, pr, ex, alpha=self.p.alpha) + AWK.make_exit(aux, addr, ob, pr, ex, c_a=self._b, c_po=self._a, c_e=-(self._a + self._b)) + FUK.exit_error(aux, addr) + FUK.error_reduce(addr, err_exit) + + parallel.barrier() + + sync = (self.curiter % 1 == 0) + self.overlap_update() + + self.center_probe() + + parallel.barrier() + self.position_update() + + self.curiter += 1 + queue.synchronize() + + for name, s in self.ob.S.items(): + s.data[:] = s.gpu.get() + for name, s in self.pr.S.items(): + s.data[:] = s.gpu.get() + + # costly but needed to sync back with + # for name, s in self.ex.S.items(): + # s.data[:] = s.gpu.get() + for dID, prep in self.diff_info.items(): + err_fourier = prep.err_fourier_gpu.get() + err_phot = prep.err_phot_gpu.get() + err_exit = prep.err_exit_gpu.get() + errs = np.ascontiguousarray(np.vstack([err_fourier, err_phot, err_exit]).T) + error.update(zip(prep.view_IDs, errs)) + + self.error = error + return error + + def position_update(self): + """ + Position refinement + """ + if not self.do_position_refinement or (not self.curiter): + return + do_update_pos = (self.p.position_refinement.stop > self.curiter >= self.p.position_refinement.start) + do_update_pos &= (self.curiter % self.p.position_refinement.interval) == 0 + use_tiles = (not self.p.probe_update_cuda_atomics) or (not self.p.object_update_cuda_atomics) + + # Update positions + if do_update_pos: + """ + Iterates through all positions and refines them by a given algorithm. + """ + log(4, "----------- START POS REF -------------") + for dID in self.di.S.keys(): + + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + ma = self.ma.S[dID].gpu + ob = self.ob.S[oID].gpu + pr = self.pr.S[pID].gpu + kern = self.kernels[prep.label] + aux = kern.aux + addr = prep.addr_gpu + original_addr = prep.original_addr + mangled_addr = prep.mangled_addr_gpu + mag = prep.mag + ma_sum = prep.ma_sum + err_fourier = prep.err_fourier_gpu + error_state = prep.error_state_gpu + + PCK = kern.PCK + TK = kern.TK + PROP = kern.PROP + + # Keep track of object boundaries + max_oby = ob.shape[-2] - aux.shape[-2] - 1 + max_obx = ob.shape[-1] - aux.shape[-1] - 1 + + # We need to re-calculate the current error + PCK.build_aux(aux, addr, ob, pr) + PROP.fw(aux, aux) + if self.p.position_refinement.metric == "fourier": + PCK.fourier_error(aux, addr, mag, ma, ma_sum) + PCK.error_reduce(addr, err_fourier) + if self.p.position_refinement.metric == "photon": + PCK.log_likelihood(aux, addr, mag, ma, err_fourier) + cuda.memcpy_dtod(dest=error_state.ptr, + src=err_fourier.ptr, + size=err_fourier.nbytes) + + PCK.mangler.setup_shifts(self.curiter, nframes=addr.shape[0]) + + log(4, 'Position refinement trial: iteration %s' % (self.curiter)) + for i in range(PCK.mangler.nshifts): + PCK.mangler.get_address(i, addr, mangled_addr, max_oby, max_obx) + PCK.build_aux(aux, mangled_addr, ob, pr) + PROP.fw(aux, aux) + if self.p.position_refinement.metric == "fourier": + PCK.fourier_error(aux, mangled_addr, mag, ma, ma_sum) + PCK.error_reduce(mangled_addr, err_fourier) + if self.p.position_refinement.metric == "photon": + PCK.log_likelihood(aux, mangled_addr, mag, ma, err_fourier) + PCK.update_addr_and_error_state(addr, error_state, mangled_addr, err_fourier) + + cuda.memcpy_dtod(dest=err_fourier.ptr, + src=error_state.ptr, + size=err_fourier.nbytes) + if use_tiles: + s1 = addr.shape[0] * addr.shape[1] + s2 = addr.shape[2] * addr.shape[3] + TK.transpose(addr.reshape(s1, s2), prep.addr2_gpu.reshape(s2, s1)) + + + def center_probe(self): + if self.p.probe_center_tol is not None: + for name, pr_s in self.pr.storages.items(): + psum_d = self.A2SK.abs2sum(pr_s.gpu) + c1 = self.MCK.mass_center(psum_d).get() + c2 = (np.asarray(pr_s.shape[-2:]) // 2).astype(c1.dtype) + + shift = c2 - c1 + # exit if the current center of mass is within the tolerance + if u.norm(shift) < self.p.probe_center_tol: + break + + # shift the probe + pr_s.gpu = self.ISK.interpolate_shift(pr_s.gpu, shift) + + # shift the object + ob_s = pr_s.views[0].pod.ob_view.storage + ob_s.gpu = self.ISK.interpolate_shift(ob_s.gpu, shift) + + # shift the exit waves + for dID in self.di.S.keys(): + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + if pID == name: + self.ex.S[eID].gpu = self.ISK.interpolate_shift( + self.ex.S[eID].gpu, shift) + + log(4,'Probe recentered from %s to %s' + % (str(tuple(c1)), str(tuple(c2)))) + + + ## object update + def object_update(self, MPI=False): + use_atomics = self.p.object_update_cuda_atomics + queue = self.queue + queue.synchronize() + for oID, ob in self.ob.storages.items(): + obn = self.ob_nrm.S[oID] + cfact = self.ob_cfact[oID] + + if self.p.obj_smooth_std is not None: + log(4, 'Smoothing object, cfact is %.2f' % cfact) + obb = self.ob_buf.S[oID] + smooth_mfs = [self.p.obj_smooth_std, self.p.obj_smooth_std] + self.GSK.convolution(ob.gpu, smooth_mfs, tmp=obb.gpu) + + ob.gpu *= cfact + obn.gpu.fill(cfact) + queue.synchronize() + + # storage for-loop + for dID in self.di.S.keys(): + prep = self.diff_info[dID] + + POK = self.kernels[prep.label].POK + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # scan for loop + addr = prep.addr_gpu if use_atomics else prep.addr2_gpu + ev = POK.ob_update(addr, + self.ob.S[oID].gpu, + self.ob_nrm.S[oID].gpu, + self.pr.S[pID].gpu, + self.ex.S[eID].gpu, + atomics = use_atomics) + queue.synchronize() + + for oID, ob in self.ob.storages.items(): + obn = self.ob_nrm.S[oID] + self.multigpu.allReduceSum(ob.gpu) + self.multigpu.allReduceSum(obn.gpu) + ob.gpu /= obn.gpu + + self.clip_object(ob.gpu) + queue.synchronize() + + ## probe update + def probe_update(self, MPI=False): + queue = self.queue + + # storage for-loop + change_gpu = gpuarray.zeros((1,), dtype=np.float32) + cfact = self.p.probe_inertia + use_atomics = self.p.probe_update_cuda_atomics + for pID, pr in self.pr.storages.items(): + prn = self.pr_nrm.S[pID] + cfact = self.pr_cfact[pID] + pr.gpu *= cfact + prn.gpu.fill(cfact) + + for dID in self.di.S.keys(): + prep = self.diff_info[dID] + + POK = self.kernels[prep.label].POK + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # scan for-loop + addr = prep.addr_gpu if use_atomics else prep.addr2_gpu + ev = POK.pr_update(addr, + self.pr.S[pID].gpu, + self.pr_nrm.S[pID].gpu, + self.ob.S[oID].gpu, + self.ex.S[eID].gpu, + atomics=use_atomics) + queue.synchronize() + + for pID, pr in self.pr.storages.items(): + + buf = self.pr_buf.S[pID] + prn = self.pr_nrm.S[pID] + + self.multigpu.allReduceSum(pr.gpu) + self.multigpu.allReduceSum(prn.gpu) + pr.gpu /= prn.gpu + self.support_constraint(pr) + + ## calculate change on GPU + queue.synchronize() + AUK = self.kernels[list(self.kernels)[0]].AUK + buf.gpu -= pr.gpu + change_gpu += (AUK.norm2(buf.gpu) / AUK.norm2(pr.gpu)) + buf.gpu[:] = pr.gpu + self.multigpu.allReduceSum(change_gpu) + change = change_gpu.get().item() / parallel.size + + return np.sqrt(change) + + def support_constraint(self, storage=None): + """ + Enforces 2D support constraint on probe. + """ + if storage is None: + for s in self.pr.storages.values(): + self.support_constraint(s) + + # Fourier space + support = self._probe_fourier_support.get(storage.ID) + if support is not None: + if storage.ID not in self.FSK: + supp = support.astype(np.complex64) + self.FSK[storage.ID] = FourierSupportKernel(supp, self.queue, self.p.fft_lib) + self.FSK[storage.ID].allocate() + self.FSK[storage.ID].apply_fourier_support(storage.gpu) + + # Real space + support = self._probe_support.get(storage.ID) + if support is not None: + if storage.ID not in self.RSK: + self.RSK[storage.ID] = RealSupportKernel(support.astype(np.complex64)) + self.RSK[storage.ID].allocate() + self.RSK[storage.ID].apply_real_support(storage.gpu) + + def clip_object(self, ob): + """ + Clips magnitudes of object into given range. + """ + if self.p.clip_object is not None: + cmin, cmax = self.p.clip_object + self.CMK.clip_magnitudes_to_range(ob, cmin, cmax) + + def engine_finalize(self): + """ + clear GPU data and destroy context. + """ + for name, s in self.ob.S.items(): + del s.gpu + for name, s in self.ob_buf.S.items(): + del s.gpu + for name, s in self.ob_nrm.S.items(): + del s.gpu + for name, s in self.pr.S.items(): + del s.gpu + for name, s in self.pr_buf.S.items(): + del s.gpu + for name, s in self.pr_nrm.S.items(): + del s.gpu + + # copy addr to cpu + for dID, prep in self.diff_info.items(): + prep.addr = prep.addr_gpu.get() + + # copy data to cpu + # this kills the pagelock memory (otherwise we get segfaults in h5py) + for name, s in self.pr.S.items(): + s.data = np.copy(s.data) + + self.context.pop() + self.context.detach() + + # we don't need the "benchmarking" in DM_serial + super().engine_finalize(benchmark=False) + + +@register(name="DM_pycuda_nostream") +class DM_pycuda(_ProjectionEngine_pycuda, DMMixin): + """ + A full-fledged Difference Map engine accelerated with pycuda. + + Defaults: + + [name] + default = DM_pycuda + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + _ProjectionEngine_pycuda.__init__(self, ptycho_parent, pars) + DMMixin.__init__(self, self.p.alpha) + ptycho_parent.citations.add_article(**self.article) + + +@register(name="RAAR_pycuda_nostream") +class RAAR_pycuda(_ProjectionEngine_pycuda, RAARMixin): + """ + A RAAR engine in accelerated with pycuda. + + Defaults: + + [name] + default = RAAR_pycuda + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + _ProjectionEngine_pycuda.__init__(self, ptycho_parent, pars) + RAARMixin.__init__(self, self.p.beta) diff --git a/ptypy/accelerate/cuda_pycuda/engines/projectional_pycuda_stream.py b/ptypy/accelerate/cuda_pycuda/engines/projectional_pycuda_stream.py new file mode 100644 index 000000000..c6e5adda8 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/engines/projectional_pycuda_stream.py @@ -0,0 +1,512 @@ +# -*- coding: utf-8 -*- +""" +Difference Map reconstruction engine for NVIDIA GPUs. + +This engine uses three streams, one for the compute queue and one for each I/O queue. +Events are used to synchronize download / compute/ upload. we cannot manipulate memory +for each loop over the state vector, a certain number of memory sections is preallocated +and reused. + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" + +import numpy as np +import time +from pycuda import gpuarray +import pycuda.driver as cuda +from pycuda.tools import DeviceMemoryPool + +from ptypy import utils as u +from ptypy.utils.verbose import log, logger +from ptypy.utils import parallel +from ptypy.engines import register +from ptypy.engines.projectional import DMMixin, RAARMixin +from . import projectional_pycuda + +from ..mem_utils import make_pagelocked_paired_arrays as mppa +from ..mem_utils import GpuDataManager + +EX_MA_BLOCKS_RATIO = 2 +MAX_BLOCKS = 99999 # can be used to limit the number of blocks, simulating that they don't fit +#MAX_BLOCKS = 3 # can be used to limit the number of blocks, simulating that they don't fit + +__all__ = ['DM_pycuda_stream', 'RAAR_pycuda_stream'] + + +class _ProjectionEngine_pycuda_stream(projectional_pycuda._ProjectionEngine_pycuda): + + def __init__(self, ptycho_parent, pars=None): + + super().__init__(ptycho_parent, pars) + self.ma_data = None + self.mag_data = None + self.ex_data = None + + def engine_initialize(self): + super().engine_initialize() + self.qu_htod = cuda.Stream() + self.qu_dtoh = cuda.Stream() + + def _setup_kernels(self): + + super()._setup_kernels() + ex_mem = 0 + mag_mem = 0 + for scan, kern in self.kernels.items(): + ex_mem = max(kern.aux.nbytes, ex_mem) + mag_mem = max(kern.FUK.gpu.fdev.nbytes, mag_mem) + ma_mem = mag_mem + mem = cuda.mem_get_info()[0] + blk = ex_mem * EX_MA_BLOCKS_RATIO + ma_mem + mag_mem + fit = int(mem - 200 * 1024 * 1024) // blk # leave 200MB room for safety + if not fit: + log(1,"Cannot fit memory into device, if possible reduce frames per block. Exiting...") + self.context.pop() + self.context.detach() + raise SystemExit("ptypy has been exited.") + + # TODO grow blocks dynamically + nex = min(fit * EX_MA_BLOCKS_RATIO, MAX_BLOCKS) + nma = min(fit, MAX_BLOCKS) + log(4, 'Free memory on device: %.2f GB' % (float(mem)/1e9)) + log(4, 'PyCUDA max blocks fitting on GPU: exit arrays={}, ma_arrays={}'.format(nex, nma)) + # reset memory or create new + self.ex_data = GpuDataManager(ex_mem, 0, nex, True) + self.ma_data = GpuDataManager(ma_mem, 0, nma, False) + self.mag_data = GpuDataManager(mag_mem, 0, nma, False) + + def engine_prepare(self): + + super(projectional_pycuda._ProjectionEngine_pycuda, self).engine_prepare() + + for name, s in self.ob.S.items(): + s.gpu = gpuarray.to_gpu(s.data) + for name, s in self.ob_buf.S.items(): + s.gpu, s.data = mppa(s.data) + for name, s in self.ob_nrm.S.items(): + s.gpu, s.data = mppa(s.data) + for name, s in self.pr.S.items(): + s.gpu, s.data = mppa(s.data) + for name, s in self.pr_buf.S.items(): + s.gpu, s.data = mppa(s.data) + for name, s in self.pr_nrm.S.items(): + s.gpu, s.data = mppa(s.data) + + use_tiles = (not self.p.probe_update_cuda_atomics) or (not self.p.object_update_cuda_atomics) + + # Extra object buffer for smoothing kernel + if self.p.obj_smooth_std is not None: + for name, s in self.ob_buf.S.items(): + s.tmp = gpuarray.empty(s.gpu.shape, s.gpu.dtype) + + # TODO : like the serialization this one is needed due to object reformatting + for label, d in self.di.storages.items(): + prep = self.diff_info[d.ID] + prep.addr_gpu = gpuarray.to_gpu(prep.addr) + if use_tiles: + prep.addr2 = np.ascontiguousarray(np.transpose(prep.addr, (2, 3, 0, 1))) + prep.addr2_gpu = gpuarray.to_gpu(prep.addr2) + if self.do_position_refinement: + prep.mangled_addr_gpu = prep.addr_gpu.copy() + + for label, d in self.ptycho.new_data: + dID = d.ID + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + + prep.ma_sum_gpu = gpuarray.to_gpu(prep.ma_sum) + # prepare page-locked mems: + prep.err_fourier_gpu = gpuarray.to_gpu(prep.err_fourier) + prep.err_phot_gpu = gpuarray.to_gpu(prep.err_phot) + prep.err_exit_gpu = gpuarray.to_gpu(prep.err_exit) + if self.do_position_refinement: + prep.error_state_gpu = gpuarray.empty_like(prep.err_fourier_gpu) + ma = self.ma.S[dID].data.astype(np.float32) + prep.ma = cuda.pagelocked_empty(ma.shape, ma.dtype, order="C", mem_flags=4) + prep.ma[:] = ma + ex = self.ex.S[eID].data + prep.ex = cuda.pagelocked_empty(ex.shape, ex.dtype, order="C", mem_flags=4) + prep.ex[:] = ex + mag = prep.mag + prep.mag = cuda.pagelocked_empty(mag.shape, mag.dtype, order="C", mem_flags=4) + prep.mag[:] = mag + + log(4, 'Free memory on device: %.2f GB' % (float(cuda.mem_get_info()[0])/1e9)) + self.ex_data.add_data_block() + self.ma_data.add_data_block() + self.mag_data.add_data_block() + + def engine_iterate(self, num=1): + """ + Compute one iteration. + """ + # ma_buf = ma_c = np.zeros(FUK.fshape, dtype=np.float32) + self.dID_list = list(self.di.S.keys()) + atomics_probe = self.p.probe_update_cuda_atomics + atomics_object = self.p.object_update_cuda_atomics + use_tiles = (not atomics_object) or (not atomics_probe) + + for it in range(num): + + error = {} + + for inner in range(self.p.overlap_max_iterations): + + change = 0 + + do_update_probe = (self.curiter >= self.p.probe_update_start) + do_update_object = (self.p.update_object_first or (inner > 0) or not do_update_probe) + do_update_fourier = (inner == 0) + + # initialize probe and object buffer to receive an update + if do_update_object: + for oID, ob in self.ob.storages.items(): + cfact = self.ob_cfact[oID] + obn = self.ob_nrm.S[oID] + obb = self.ob_buf.S[oID] + + if self.p.obj_smooth_std is not None: + log(4, 'Smoothing object, cfact is %.2f' % cfact) + smooth_mfs = [self.p.obj_smooth_std, self.p.obj_smooth_std] + # We need a third copy, because we still need ob.gpu for the fourier update + obb.gpu[:] = ob.gpu[:] + self.GSK.convolution(obb.gpu, smooth_mfs, tmp=obb.tmp) + obb.gpu *= np.complex64(cfact) + else: + # obb.gpu[:] = ob.gpu * np.complex64(cfact) + ob.gpu._axpbz(np.complex64(cfact), 0, obb.gpu) + obn.gpu.fill(np.float32(cfact)) + + # First cycle: Fourier + object update + for iblock, dID in enumerate(self.dID_list): + prep = self.diff_info[dID] + + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # references for kernels + kern = self.kernels[prep.label] + FUK = kern.FUK + AWK = kern.AWK + POK = kern.POK + + pbound = self.pbound_scan[prep.label] + aux = kern.aux + PROP = kern.PROP + + # get addresses and auxilliary array + addr = prep.addr_gpu + addr2 = prep.addr2_gpu if use_tiles else None + err_fourier = prep.err_fourier_gpu + err_phot = prep.err_phot_gpu + err_exit = prep.err_exit_gpu + ma_sum = prep.ma_sum_gpu + + # local references + ob = self.ob.S[oID].gpu + obn = self.ob_nrm.S[oID].gpu + obb = self.ob_buf.S[oID].gpu + pr = self.pr.S[pID].gpu + + # Schedule ex to device + ev_ex, ex, data_ex = self.ex_data.to_gpu(prep.ex, dID, self.qu_htod) + + # Fourier update. + if do_update_fourier: + self.ex_data.syncback = True + log(4, '----- Fourier update -----', True) + + # Schedule ma & mag to device + ev_ma, ma, data_ma = self.ma_data.to_gpu(prep.ma, dID, self.qu_htod) + ev_mag, mag, data_mag = self.mag_data.to_gpu(prep.mag, dID, self.qu_htod) + + ## compute log-likelihood + if self.p.compute_log_likelihood: + AWK.build_aux_no_ex(aux, addr, ob, pr) + PROP.fw(aux, aux) + # synchronize h2d stream with compute stream + self.queue.wait_for_event(ev_mag) + FUK.log_likelihood(aux, addr, mag, ma, err_phot) + + # synchronize h2d stream with compute stream + self.queue.wait_for_event(ev_ex) + #AWK.build_aux(aux, addr, ob, pr, ex, alpha=self.p.alpha) + AWK.make_aux(aux, addr, ob, pr, ex, c_po=self._c, c_e=1-self._c) + + ## FFT + PROP.fw(aux, aux) + + ## Deviation from measured data + # synchronize h2d stream with compute stream + self.queue.wait_for_event(ev_mag) + FUK.fourier_error(aux, addr, mag, ma, ma_sum) + FUK.error_reduce(addr, err_fourier) + FUK.fmag_all_update(aux, addr, mag, ma, err_fourier, pbound) + + data_mag.record_done(self.queue, 'compute') + data_ma.record_done(self.queue, 'compute') + + PROP.bw(aux, aux) + ## apply changes + #AWK.build_exit(aux, addr, ob, pr, ex, alpha=self.p.alpha) + AWK.make_exit(aux, addr, ob, pr, ex, c_a=self._b, c_po=self._a, c_e=-(self._a + self._b)) + FUK.exit_error(aux, addr) + FUK.error_reduce(addr, err_exit) + + prestr = '%d Iteration (Overlap) #%02d: ' % (parallel.rank, inner) + + # Update object + if do_update_object: + log(4, prestr + '----- object update -----', True) + addrt = addr if atomics_object else addr2 + self.queue.wait_for_event(ev_ex) + POK.ob_update(addrt, obb, obn, pr, ex, atomics=atomics_object) + + data_ex.record_done(self.queue, 'compute') + if iblock + len(self.ex_data) < len(self.dID_list): + data_ex.from_gpu(self.qu_dtoh) + + # swap direction + if do_update_fourier or do_update_object: + self.dID_list.reverse() + + # wait for compute stream to finish + self.queue.synchronize() + + if do_update_object: + + for oID, ob in self.ob.storages.items(): + obn = self.ob_nrm.S[oID] + obb = self.ob_buf.S[oID] + self.multigpu.allReduceSum(obb.gpu) + self.multigpu.allReduceSum(obn.gpu) + obb.gpu /= obn.gpu + + self.clip_object(obb.gpu) + ob.gpu[:] = obb.gpu + + # Exit if probe should not yet be updated + if not do_update_probe: + break + self.ex_data.syncback = False + + # Update probe + log(4, prestr + '----- probe update -----', True) + change = self.probe_update() + log(4, prestr + 'change in probe is %.3f' % change, True) + + # stop iteration if probe change is small + if change < self.p.overlap_converge_factor: break + + self.queue.synchronize() + parallel.barrier() + + if self.do_position_refinement and (self.curiter): + do_update_pos = (self.p.position_refinement.stop > self.curiter >= self.p.position_refinement.start) + do_update_pos &= (self.curiter % self.p.position_refinement.interval) == 0 + + # Update positions + if do_update_pos: + """ + Iterates through all positions and refines them by a given algorithm. + """ + log(4, "----------- START POS REF -------------") + for dID in self.di.S.keys(): + + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + ob = self.ob.S[oID].gpu + pr = self.pr.S[pID].gpu + kern = self.kernels[prep.label] + aux = kern.aux + addr = prep.addr_gpu + original_addr = prep.original_addr + mangled_addr = prep.mangled_addr_gpu + ma_sum = prep.ma_sum_gpu + err_fourier = prep.err_fourier_gpu + error_state = prep.error_state_gpu + + PCK = kern.PCK + TK = kern.TK + PROP = kern.PROP + + # Make sure our data arrays are on device + ev_ma, ma, data_ma = self.ma_data.to_gpu(prep.ma, dID, self.qu_htod) + ev_mag, mag, data_mag = self.mag_data.to_gpu(prep.mag, dID, self.qu_htod) + + # Keep track of object boundaries + max_oby = ob.shape[-2] - aux.shape[-2] - 1 + max_obx = ob.shape[-1] - aux.shape[-1] - 1 + + # We need to re-calculate the current error + PCK.build_aux(aux, addr, ob, pr) + PROP.fw(aux, aux) + # wait for data to arrive + self.queue.wait_for_event(ev_mag) + + # We need to re-calculate the current error + if self.p.position_refinement.metric == "fourier": + PCK.fourier_error(aux, addr, mag, ma, ma_sum) + PCK.error_reduce(addr, err_fourier) + if self.p.position_refinement.metric == "photon": + PCK.log_likelihood(aux, addr, mag, ma, err_fourier) + cuda.memcpy_dtod_async(dest=error_state.ptr, + src=err_fourier.ptr, + size=err_fourier.nbytes, stream=self.queue) + + log(4, 'Position refinement trial: iteration %s' % (self.curiter)) + PCK.mangler.setup_shifts(self.curiter, nframes=addr.shape[0]) + for i in range(PCK.mangler.nshifts): + PCK.mangler.get_address(i, addr, mangled_addr, max_oby, max_obx) + PCK.build_aux(aux, mangled_addr, ob, pr) + PROP.fw(aux, aux) + if self.p.position_refinement.metric == "fourier": + PCK.fourier_error(aux, mangled_addr, mag, ma, ma_sum) + PCK.error_reduce(mangled_addr, err_fourier) + if self.p.position_refinement.metric == "photon": + PCK.log_likelihood(aux, mangled_addr, mag, ma, err_fourier) + PCK.update_addr_and_error_state(addr, error_state, mangled_addr, err_fourier) + + data_mag.record_done(self.queue, 'compute') + data_ma.record_done(self.queue, 'compute') + cuda.memcpy_dtod_async(dest=err_fourier.ptr, + src=error_state.ptr, + size=err_fourier.nbytes, stream=self.queue) + if use_tiles: + s1 = prep.addr_gpu.shape[0] * prep.addr_gpu.shape[1] + s2 = prep.addr_gpu.shape[2] * prep.addr_gpu.shape[3] + TK.transpose(prep.addr_gpu.reshape(s1, s2), prep.addr2_gpu.reshape(s2, s1)) + + self.curiter += 1 + self.queue.synchronize() + + for name, s in self.ob.S.items(): + s.data[:] = s.gpu.get() + for name, s in self.pr.S.items(): + s.data[:] = s.gpu.get() + + # costly but needed to sync back with + # for name, s in self.ex.S.items(): + # s.data[:] = s.gpu.get() + for dID, prep in self.diff_info.items(): + err_fourier = prep.err_fourier_gpu.get() + err_phot = prep.err_phot_gpu.get() + err_exit = prep.err_exit_gpu.get() + errs = np.ascontiguousarray(np.vstack([err_fourier, err_phot, err_exit]).T) + error.update(zip(prep.view_IDs, errs)) + + self.error = error + return error + + ## probe update + def probe_update(self, MPI=False): + queue = self.queue + use_atomics = self.p.probe_update_cuda_atomics + # storage for-loop + change_gpu = gpuarray.zeros((1,), dtype=np.float32) + for pID, pr in self.pr.storages.items(): + prn = self.pr_nrm.S[pID] + cfact = self.pr_cfact[pID] + # pr.gpu *= np.float64(cfact) + pr.gpu._axpbz(np.complex64(cfact), 0, pr.gpu, stream=queue) + prn.gpu.fill(np.float32(cfact), stream=self.queue) + + for iblock, dID in enumerate(self.dID_list): + prep = self.diff_info[dID] + + POK = self.kernels[prep.label].POK + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + ev, ex, data_ex = self.ex_data.to_gpu(prep.ex, dID, self.qu_htod) + self.queue.wait_for_event(ev) + + addrt = prep.addr_gpu if use_atomics else prep.addr2_gpu + ev = POK.pr_update(addrt, + self.pr.S[pID].gpu, + self.pr_nrm.S[pID].gpu, + self.ob.S[oID].gpu, + ex, + atomics=use_atomics) + + data_ex.record_done(self.queue, 'compute') + if iblock + len(self.ex_data) < len(self.dID_list): + data_ex.from_gpu(self.qu_dtoh) + + self.dID_list.reverse() + + self.queue.synchronize() + for pID, pr in self.pr.storages.items(): + + buf = self.pr_buf.S[pID] + prn = self.pr_nrm.S[pID] + + self.multigpu.allReduceSum(pr.gpu) + self.multigpu.allReduceSum(prn.gpu) + pr.gpu /= prn.gpu + self.support_constraint(pr) + + ## calculate change on GPU + AUK = self.kernels[list(self.kernels)[0]].AUK + buf.gpu -= pr.gpu + change_gpu += (AUK.norm2(buf.gpu) / AUK.norm2(pr.gpu)) + buf.gpu[:] = pr.gpu + self.multigpu.allReduceSum(change_gpu) + change = change_gpu.get().item() / parallel.size + + return np.sqrt(change) + + def engine_finalize(self): + """ + Clear all GPU data, pinned memory, etc + """ + self.ex_data = None + self.ma_data = None + self.mag_data = None + + super().engine_finalize() + + +@register(name="DM_pycuda") +class DM_pycuda_stream(_ProjectionEngine_pycuda_stream, DMMixin): + """ + A full-fledged Difference Map engine accelerated with pycuda. + + Defaults: + + [name] + default = DM_pycuda + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + _ProjectionEngine_pycuda_stream.__init__(self, ptycho_parent, pars) + DMMixin.__init__(self, self.p.alpha) + ptycho_parent.citations.add_article(**self.article) + + +@register(name="RAAR_pycuda") +class RAAR_pycuda_stream(_ProjectionEngine_pycuda_stream, RAARMixin): + """ + A RAAR engine in accelerated with pycuda. + + Defaults: + + [name] + default = RAAR_pycuda + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + + _ProjectionEngine_pycuda_stream.__init__(self, ptycho_parent, pars) + RAARMixin.__init__(self, self.p.beta) diff --git a/ptypy/accelerate/cuda_pycuda/engines/stochastic.py b/ptypy/accelerate/cuda_pycuda/engines/stochastic.py new file mode 100644 index 000000000..3ac819725 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/engines/stochastic.py @@ -0,0 +1,529 @@ +# -*- coding: utf-8 -*- +""" +Accelerated stochastic reconstruction engine. + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" + +import numpy as np +import time +from pycuda import gpuarray +import pycuda.driver as cuda + +from ptypy import utils as u +from ptypy.utils.verbose import logger, log +from ptypy.utils import parallel +from ptypy.engines import register +from ptypy.engines.stochastic import EPIEMixin, SDRMixin +from ptypy.accelerate.base.engines.stochastic import _StochasticEngineSerial +from ptypy.accelerate.base import address_manglers +from .. import get_context +from ..kernels import FourierUpdateKernel, AuxiliaryWaveKernel, PoUpdateKernel,\ + PositionCorrectionKernel, PropagationKernel +from ..array_utils import ArrayUtilsKernel, GaussianSmoothingKernel,\ + TransposeKernel, MaxAbs2Kernel, MassCenterKernel, Abs2SumKernel,\ + InterpolatedShiftKernel +from ..mem_utils import make_pagelocked_paired_arrays as mppa +from ..mem_utils import GpuDataManager + +MPI = False + +EX_MA_BLOCKS_RATIO = 2 +MAX_BLOCKS = 99999 # can be used to limit the number of blocks, simulating that they don't fit +#MAX_BLOCKS = 10 # can be used to limit the number of blocks, simulating that they don't fit + +class _StochasticEnginePycuda(_StochasticEngineSerial): + + """ + An accelerated implementation of a stochastic algorithm for ptychography + + Defaults: + + [fft_lib] + default = reikna + type = str + help = Choose the pycuda-compatible FFT module. + doc = One of: + - ``'reikna'`` : the reikna packaga (fast load, competitive compute for streaming) + - ``'cuda'`` : ptypy's cuda wrapper (delayed load, but fastest compute if all data is on GPU) + - ``'skcuda'`` : scikit-cuda (fast load, slowest compute due to additional store/load stages) + choices = 'reikna','cuda','skcuda' + userlevel = 2 + + """ + + def __init__(self, ptycho_parent, pars=None): + """ + Accelerated base engine for stochastic algorithms. + """ + super().__init__(ptycho_parent, pars) + self.ma_data = None + self.mag_data = None + self.ex_data = None + + def engine_initialize(self): + """ + Prepare for reconstruction. + """ + self.context, self.queue = get_context(new_context=True, new_queue=True) + + # initialise kernels for centring probe if required + if self.p.probe_center_tol is not None: + # mass center kernel + self.MCK = MassCenterKernel(queue=self.queue) + # absolute sum kernel + self.A2SK = Abs2SumKernel(dtype=self.pr.dtype, queue=self.queue) + # interpolated shift kernel + self.ISK = InterpolatedShiftKernel(queue=self.queue) + + super().engine_initialize() + self.qu_htod = cuda.Stream() + self.qu_dtoh = cuda.Stream() + + def _setup_kernels(self): + """ + Setup kernels, one for each scan. Derive scans from ptycho class + """ + fpc = 0 + + # get the scans + for label, scan in self.ptycho.model.scans.items(): + + kern = u.Param() + kern.scanmodel = type(scan).__name__ + self.kernels[label] = kern + # TODO: needs to be adapted for broad bandwidth + geo = scan.geometries[0] + + # Get info to shape buffer arrays + fpc = max(scan.max_frames_per_block, fpc) + + # TODO : make this more foolproof + try: + nmodes = scan.p.coherence.num_probe_modes * \ + scan.p.coherence.num_object_modes + except: + nmodes = 1 + + # create buffer arrays + ash = (nmodes,) + tuple(geo.shape) + aux = np.zeros(ash, dtype=np.complex64) + kern.aux = gpuarray.to_gpu(aux) + + # setup kernels, one for each SCAN. + log(4, "Setting up FourierUpdateKernel") + kern.FUK = FourierUpdateKernel(aux, nmodes, queue_thread=self.queue) + kern.FUK.fshape = (1,) + kern.FUK.fshape[1:] + kern.FUK.allocate() + + log(4, "Setting up PoUpdateKernel") + kern.POK = PoUpdateKernel(queue_thread=self.queue) + kern.POK.allocate() + + log(4, "Setting up AuxiliaryWaveKernel") + kern.AWK = AuxiliaryWaveKernel(queue_thread=self.queue) + kern.AWK.allocate() + + log(4, "Setting up ArrayUtilsKernel") + kern.AUK = ArrayUtilsKernel(queue=self.queue) + + #log(4, "Setting up TransposeKernel") + #kern.TK = TransposeKernel(queue=self.queue) + + log(4, "setting up MaxAbs2Kernel") + kern.MAK = MaxAbs2Kernel(queue=self.queue) + + log(4, "Setting up PropagationKernel") + kern.PROP = PropagationKernel(aux, geo.propagator, self.queue, self.p.fft_lib) + kern.PROP.allocate() + kern.resolution = geo.resolution[0] + + if self.do_position_refinement: + log(4, "Setting up position correction") + kern.PCK = PositionCorrectionKernel(aux, nmodes, self.p.position_refinement, geo.resolution, queue_thread=self.queue) + kern.PCK.allocate() + + ex_mem = 0 + mag_mem = 0 + for scan, kern in self.kernels.items(): + if kern.scanmodel in ("GradFull", "BlockGradFull"): + ex_mem = max(kern.aux.nbytes * 1, ex_mem) + else: + ex_mem = max(kern.aux.nbytes * fpc, ex_mem) + mag_mem = max(kern.FUK.gpu.fdev.nbytes * fpc, mag_mem) + ma_mem = mag_mem + mem = cuda.mem_get_info()[0] + blk = ex_mem * EX_MA_BLOCKS_RATIO + ma_mem + mag_mem + fit = int(mem - 200 * 1024 * 1024) // blk # leave 200MB room for safety + if not fit: + log(1,"Cannot fit memory into device, if possible reduce frames per block. Exiting...") + self.context.pop() + self.context.detach() + raise SystemExit("ptypy has been exited.") + + # TODO grow blocks dynamically + nex = min(fit * EX_MA_BLOCKS_RATIO, MAX_BLOCKS) + nma = min(fit, MAX_BLOCKS) + + log(3, 'PyCUDA max blocks fitting on GPU: exit arrays={}, ma_arrays={}'.format(nex, nma)) + # reset memory or create new + self.ex_data = GpuDataManager(ex_mem, 0, nex, True) + self.ma_data = GpuDataManager(ma_mem, 0, nma, False) + self.mag_data = GpuDataManager(mag_mem, 0, nma, False) + log(4, "Kernel setup completed") + + def engine_prepare(self): + super().engine_prepare() + + for name, s in self.ob.S.items(): + s.gpu, s.data = mppa(s.data) + for name, s in self.pr.S.items(): + s.gpu, s.data = mppa(s.data) + + for label, d in self.di.storages.items(): + prep = self.diff_info[d.ID] + prep.addr_gpu = gpuarray.to_gpu(prep.addr) + if self.do_position_refinement: + prep.mangled_addr_gpu = prep.addr_gpu.copy() + + for label, d in self.ptycho.new_data: + dID = d.ID + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + + prep.ma_sum_gpu = gpuarray.to_gpu(prep.ma_sum) + prep.err_fourier_gpu = gpuarray.to_gpu(prep.err_fourier) + prep.err_phot_gpu = gpuarray.to_gpu(prep.err_phot) + prep.err_exit_gpu = gpuarray.to_gpu(prep.err_exit) + if self.do_position_refinement: + prep.error_state_gpu = gpuarray.empty_like(prep.err_fourier_gpu) + prep.obn = gpuarray.to_gpu(prep.obn) + prep.prn = gpuarray.to_gpu(prep.prn) + # prepare page-locked mems: + ma = self.ma.S[dID].data.astype(np.float32) + prep.ma = cuda.pagelocked_empty(ma.shape, ma.dtype, order="C", mem_flags=4) + prep.ma[:] = ma + ex = self.ex.S[eID].data + prep.ex = cuda.pagelocked_empty(ex.shape, ex.dtype, order="C", mem_flags=4) + prep.ex[:] = ex + mag = prep.mag + prep.mag = cuda.pagelocked_empty(mag.shape, mag.dtype, order="C", mem_flags=4) + prep.mag[:] = mag + + self.ex_data.add_data_block() + self.ma_data.add_data_block() + self.mag_data.add_data_block() + + def engine_iterate(self, num=1): + """ + Compute one iteration. + """ + self.dID_list = list(self.di.S.keys()) + error = {} + for it in range(num): + + for iblock, dID in enumerate(self.dID_list): + + # find probe, object and exit ID in dependence of dID + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + + # references for kernels + kern = self.kernels[prep.label] + FUK = kern.FUK + AWK = kern.AWK + POK = kern.POK + MAK = kern.MAK + PROP = kern.PROP + + # get aux buffer + aux = kern.aux + + # local references + ob = self.ob.S[oID].gpu + pr = self.pr.S[pID].gpu + + # shuffle view order + vieworder = prep.vieworder + prep.rng.shuffle(vieworder) + + # Schedule ex, ma, mag to device + ev_ex, ex_full, data_ex = self.ex_data.to_gpu(prep.ex, dID, self.qu_htod) + ev_mag, mag_full, data_mag = self.mag_data.to_gpu(prep.mag, dID, self.qu_htod) + ev_ma, ma_full, data_ma = self.ma_data.to_gpu(prep.ma, dID, self.qu_htod) + + # Reference to ex, ma and mag + prep.ex_full = ex_full + prep.mag_full = mag_full + prep.ma_full = ma_full + + ## synchronize h2d stream with compute stream + self.queue.wait_for_event(ev_ex) + + # Iterate through views + for i in vieworder: + + # Get local adress and arrays + addr = prep.addr_gpu[i,None] + ex_from, ex_to = prep.addr_ex[i] + ex = prep.ex_full[ex_from:ex_to] + mag = prep.mag_full[i,None] + ma = prep.ma_full[i,None] + ma_sum = prep.ma_sum_gpu[i,None] + obn = prep.obn + prn = prep.prn + err_phot = prep.err_phot_gpu[i,None] + err_fourier = prep.err_fourier_gpu[i,None] + err_exit = prep.err_exit_gpu[i,None] + + # position update + self.position_update_local(prep,i) + + ## build auxilliary wave + AWK.make_aux(aux, addr, ob, pr, ex, c_po=self._c, c_e=1-self._c) + + ## forward FFT + PROP.fw(aux, aux) + + ## Deviation from measured data + self.queue.wait_for_event(ev_mag) + if self.p.compute_fourier_error: + self.queue.wait_for_event(ev_ma) + FUK.fourier_error(aux, addr, mag, ma, ma_sum) + FUK.error_reduce(addr, err_fourier) + else: + FUK.fourier_deviation(aux, addr, mag) + self.queue.wait_for_event(ev_ma) + FUK.fmag_update_nopbound(aux, addr, mag, ma) + + ## backward FFT + PROP.bw(aux, aux) + + ## build exit wave + AWK.make_exit(aux, addr, ob, pr, ex, c_a=self._b, c_po=self._a, c_e=-(self._a + self._b)) + if self.p.compute_exit_error: + FUK.exit_error(aux,addr) + FUK.error_reduce(addr, err_exit) + + ## build auxilliary wave (ob * pr product) + AWK.build_aux2_no_ex(aux, addr, ob, pr) + + # object update + POK.pr_norm_local(addr, pr, prn) + POK.ob_update_local(addr, ob, pr, ex, aux, prn, a=self._ob_a, b=self._ob_b) + + # probe update + if self._object_norm_is_global and self._pr_a == 0: + obn_max = gpuarray.empty((1,), dtype=np.float32) + MAK.max_abs2(ob, obn_max) + obn.fill(np.float32(0.), stream=self.queue) + else: + POK.ob_norm_local(addr, ob, obn) + obn_max = gpuarray.max(obn, stream=self.queue) + if self.p.probe_update_start <= self.curiter: + POK.pr_update_local(addr, pr, ob, ex, aux, obn, obn_max, a=self._pr_a, b=self._pr_b) + + ## compute log-likelihood + if self.p.compute_log_likelihood: + PROP.fw(aux, aux) + FUK.log_likelihood2(aux, addr, mag, ma, err_phot) + + data_ex.record_done(self.queue, 'compute') + if iblock + len(self.ex_data) < len(self.dID_list): + data_ex.from_gpu(self.qu_dtoh) + + # swap direction + self.dID_list.reverse() + + # Re-center probe + self.center_probe() + + self.curiter += 1 + self.ex_data.syncback = False + + # finish all the compute + self.queue.synchronize() + + for name, s in self.ob.S.items(): + s.gpu.get_async(stream=self.qu_dtoh, ary=s.data) + for name, s in self.pr.S.items(): + s.gpu.get_async(stream=self.qu_dtoh, ary=s.data) + + for dID, prep in self.diff_info.items(): + err_fourier = prep.err_fourier_gpu.get() + err_phot = prep.err_phot_gpu.get() + err_exit = prep.err_exit_gpu.get() + errs = np.ascontiguousarray(np.vstack([err_fourier, err_phot, err_exit]).T) + error.update(zip(prep.view_IDs, errs)) + + # wait for the async transfers + self.qu_dtoh.synchronize() + + self.error = error + return error + + def position_update_local(self, prep, i): + if not self.do_position_refinement: + return + do_update_pos = (self.p.position_refinement.stop > self.curiter >= self.p.position_refinement.start) + do_update_pos &= (self.curiter % self.p.position_refinement.interval) == 0 + + # Update positions + if do_update_pos: + """ + Iterates through all positions and refines them by a given algorithm. + """ + #log(4, "----------- START POS REF -------------") + pID, oID, eID = prep.poe_IDs + mag = prep.mag_full[i,None] + ma = prep.ma_full[i,None] + ma_sum = prep.ma_sum_gpu[i,None] + ob = self.ob.S[oID].gpu + pr = self.pr.S[pID].gpu + kern = self.kernels[prep.label] + aux = kern.aux + addr = prep.addr_gpu[i,None] + mangled_addr = prep.mangled_addr_gpu[i,None] + err_fourier = prep.err_fourier_gpu[i,None] + error_state = prep.error_state_gpu[i,None] + + PCK = kern.PCK + PROP = kern.PROP + + # Keep track of object boundaries + max_oby = ob.shape[-2] - aux.shape[-2] - 1 + max_obx = ob.shape[-1] - aux.shape[-1] - 1 + + # We need to re-calculate the current error + PCK.build_aux(aux, addr, ob, pr) + PROP.fw(aux, aux) + #self.queue.wait_for_event(ev_mag) + #self.queue.wait_for_event(ev_ma) + + if self.p.position_refinement.metric == "fourier": + PCK.fourier_error(aux, addr, mag, ma, ma_sum) + PCK.error_reduce(addr, err_fourier) + if self.p.position_refinement.metric == "photon": + PCK.log_likelihood(aux, addr, mag, ma, err_fourier) + cuda.memcpy_dtod_async(dest=error_state.ptr, + src=err_fourier.ptr, + size=err_fourier.nbytes, stream=self.queue) + + PCK.mangler.setup_shifts(self.curiter, nframes=addr.shape[0]) + + #log(4, 'Position refinement trial: iteration %s' % (self.curiter)) + for i in range(PCK.mangler.nshifts): + PCK.mangler.get_address(i, addr, mangled_addr, max_oby, max_obx) + PCK.build_aux(aux, mangled_addr, ob, pr) + PROP.fw(aux, aux) + if self.p.position_refinement.metric == "fourier": + PCK.fourier_error(aux, mangled_addr, mag, ma, ma_sum) + PCK.error_reduce(mangled_addr, err_fourier) + if self.p.position_refinement.metric == "photon": + PCK.log_likelihood(aux, mangled_addr, mag, ma, err_fourier) + PCK.update_addr_and_error_state(addr, error_state, mangled_addr, err_fourier) + + cuda.memcpy_dtod_async(dest=err_fourier.ptr, + src=error_state.ptr, + size=err_fourier.nbytes, stream=self.queue) + + + def center_probe(self): + if self.p.probe_center_tol is not None: + for name, pr_s in self.pr.storages.items(): + psum_d = self.A2SK.abs2sum(pr_s.gpu) + c1 = self.MCK.mass_center(psum_d).get() + c2 = (np.asarray(pr_s.shape[-2:]) // 2).astype(c1.dtype) + + shift = c2 - c1 + # exit if the current center of mass is within the tolerance + if u.norm(shift) < self.p.probe_center_tol: + break + + # shift the probe + pr_s.gpu = self.ISK.interpolate_shift(pr_s.gpu, shift) + + # shift the object + ob_s = pr_s.views[0].pod.ob_view.storage + ob_s.gpu = self.ISK.interpolate_shift(ob_s.gpu, shift) + + # shift the exit waves + for dID in self.di.S.keys(): + prep = self.diff_info[dID] + pID, oID, eID = prep.poe_IDs + if pID == name: + prep.ex_full = self.ISK.interpolate_shift(prep.ex_full, + shift) + + log(4,'Probe recentered from %s to %s' + % (str(tuple(c1)), str(tuple(c2)))) + + + def engine_finalize(self): + """ + clear GPU data and destroy context. + """ + self.ex_data = None + self.ma_data = None + self.mag_data = None + + for name, s in self.ob.S.items(): + del s.gpu + for name, s in self.pr.S.items(): + del s.gpu + for dID, prep in self.diff_info.items(): + prep.addr = prep.addr_gpu.get() + + # copy data to cpu + # this kills the pagelock memory (otherwise we get segfaults in h5py) + for name, s in self.pr.S.items(): + s.data = np.copy(s.data) + for name, s in self.ob.S.items(): + s.data = np.copy(s.data) + + self.context.detach() + super().engine_finalize() + + +@register() +class EPIE_pycuda(_StochasticEnginePycuda, EPIEMixin): + """ + An accelerated implementation of the EPIE algorithm. + + Defaults: + + [name] + default = EPIE_pycuda + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + _StochasticEnginePycuda.__init__(self, ptycho_parent, pars) + EPIEMixin.__init__(self, self.p.alpha, self.p.beta) + ptycho_parent.citations.add_article(**self.article) + +@register() +class SDR_pycuda(_StochasticEnginePycuda, SDRMixin): + """ + An accelerated implementation of the semi-implicit relaxed Douglas-Rachford (SDR) algorithm. + + Defaults: + + [name] + default = SDR_pycuda + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + _StochasticEnginePycuda.__init__(self, ptycho_parent, pars) + SDRMixin.__init__(self, self.p.sigma, self.p.tau, self.p.beta_probe, self.p.beta_object) + ptycho_parent.citations.add_article(**self.article) diff --git a/ptypy/accelerate/cuda_pycuda/fft.py b/ptypy/accelerate/cuda_pycuda/fft.py new file mode 100644 index 000000000..916ed7e54 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/fft.py @@ -0,0 +1,180 @@ +from pycuda.compiler import SourceModule + +import numpy as np + + +class FFT(object): + + def __init__(self, array, queue=None, + inplace=False, + pre_fft=None, + post_fft=None, + symmetric=True, + forward=True): + + self._queue = queue + from pycuda import gpuarray + ## reikna + from reikna import cluda + api = cluda.cuda_api() + thr = api.Thread(queue) + + dims = array.ndim + if dims < 2: + raise AssertionError('Input array must be at least 2-dimensional') + axes = (array.ndim - 2, array.ndim - 1) + + # build the fft + from reikna.fft import fft + ftreikna = fft.FFT(array, axes) + + # attach scaling + from reikna.transformations import mul_param + sc = mul_param(array, np.float32) + ftreikna.parameter.output.connect(sc, sc.input, out=sc.output, scale=sc.param) + iscale = np.sqrt(np.prod(array.shape[-2:])) if symmetric else 1.0 + scale = 1.0 / iscale + + # attach arbitrary multiplication + from reikna import core as rc + from reikna.cluda import functions + # get the IO type + T_io = ftreikna.parameter[0] + T_2d = rc.Type(T_io.dtype, T_io.shape[-2:]) + tr = rc.Transformation( + [ + rc.Parameter('output', rc.Annotation(T_io, 'o')), + rc.Parameter('fac', rc.Annotation(T_2d, 'i')), + rc.Parameter('input', rc.Annotation(T_io, 'i')), + ], + """ + const VSIZE_T x = ${idxs[%d]}; + const VSIZE_T y = ${idxs[%d]}; + + ${output.store_same}(${mul}(${input.load_same}, ${fac.load_idx}(x,y))); + """ % axes, + render_kwds={'mul': functions.mul(T_io.dtype, T_io.dtype)}, + connectors=['input', 'output'] + ) + + if pre_fft is None and post_fft is None: + self.pre_fft = self.post_fft = None + elif pre_fft is not None and post_fft is None: + self.pre_fft = thr.to_device(pre_fft) + self.post_fft = None + ftreikna.parameter.input.connect(tr, tr.output, pre_fft=tr.fac, data=tr.input) + elif pre_fft is None and post_fft is not None: + self.post_fft = thr.to_device(post_fft) + self.pre_fft = None + ftreikna.parameter.out.connect(tr, tr.input, post_fft=tr.fac, result=tr.output) + else: + self.pre_fft = thr.to_device(pre_fft) + self.post_fft = thr.to_device(post_fft) + ftreikna.parameter.input.connect(tr, tr.output, pre_fft=tr.fac, data=tr.input) + ftreikna.parameter.out.connect(tr, tr.input, post_fft=tr.fac, result=tr.output) + + self._ftreikna_raw = ftreikna + self._scale = scale + self._iscale = iscale + self._set_stream(thr) + + @property + def queue(self): + return self._queue + + @queue.setter + def queue(self, stream): + self._queue = stream + from reikna import cluda + api = cluda.cuda_api() + thr = api.Thread(stream) + self._set_stream(thr) + + def _set_stream(self, thr): + self._ftreikna = self._ftreikna_raw.compile(thr) + + if self.pre_fft is None and self.post_fft is None: + self.ft = lambda x, y: self._ftreikna(y, self._scale, x, 0) + self.ift = lambda x, y: self._ftreikna(y, self._iscale, x, 1) + elif self.pre_fft is not None and self.post_fft is None: + self.ft = lambda x, y: self._ftreikna(y, self._scale, self.pre_fft, x, 0) + self.ift = lambda x, y: self._ftreikna(y, self._iscale, self.pre_fft, x, 1) + elif self.pre_fft is None and self.post_fft is not None: + self.ft = lambda x, y: self._ftreikna(y, self.post_fft, self._scale, x, 0) + self.ift = lambda x, y: self._ftreikna(y, self.post_fft, self._iscale, x, 1) + else: + self.ft = lambda x, y: self._ftreikna(y, self.post_fft, self._scale, self.pre_fft, x, 0) + self.ift = lambda x, y: self._ftreikna(y, self.post_fft, self._iscale, self.pre_fft, x, 1) + + + # self.queue = queue + # apply_filter_code = """ + # #include + # #include + # #include + # #include + # using thrust::complex; + # + # extern "C"{ + # __global__ void apply_filter(complex *data, + # const complex *__restrict__ filter, + # float sc, + # int batchsize, + # int size) + # { + # int offset = threadIdx.x + blockIdx.x * blockDim.x; + # int total = batchsize * size; + # if (offset >= total) + # return; + # complex val = data[offset]; + # if (filter) + # { + # val = filter[offset % size] * val; + # } + # val *= sc; + # data[offset] = val; + # } + # } + # """ + # self.apply_filter = SourceModule(apply_filter_code, include_dirs=[np.get_include()], + # no_extern_c=True).get_function("apply_filter") + # sc = isc = 1.0 / np.sqrt(array.shape[-2:]) + # + # plan = cu_fft.Plan(array.shape[-2:], np.complex64, np.complex64, array.shape[0]) + # empty_filter = np.ones((array.shape[-2:])) + 1j * np.ones((array.shape[-2:])) + # if pre_fft is None and post_fft is None: + # pre_fft = gpuarray.to_gpu(empty_filter) + # post_fft = gpuarray.to_gpu(empty_filter) + # elif pre_fft is not None and post_fft is None: + # post_fft = gpuarray.to_gpu(empty_filter) + # elif pre_fft is None and post_fft is not None: + # pre_fft = gpuarray.to_gpu(empty_filter) + # + # batch_size = np.int32(array.shape[0]) + # block = 256 + # total = np.int32(np.prod(array.shape)) + # blocks = int((total + block - 1) // block) + # + # def ft(array, out_array): + # self.apply_filter(array, pre_fft, np.float32(1.0), batch_size, np.int32(np.prod(array.shape[-2:])), + # block=(block, 1, 1), + # grid=(blocks, 1, 1),) + # cu_fft.fft(array, out_array, plan) + # self.apply_filter(out_array, post_fft, np.float32(sc), batch_size, np.int32(np.prod(array.shape[-2:])), + # block=(block, 1, 1), + # grid=(blocks, 1, 1)) + # def ift(array, out_array): + # self.apply_filter(array, pre_fft, np.float32(1.0), batch_size, np.int32(np.prod(array.shape[-2:])), + # block=(block, 1, 1), + # grid=(blocks, 1, 1)) + # print("here") + # cu_fft.fft(array, out_array, plan, True) + # print("here now") + # self.apply_filter(out_array, post_fft, np.float32(isc), batch_size, np.int32(np.prod(array.shape[-2:])), + # block=(block, 1, 1), + # grid=(blocks, 1, 1)) + # print("done") + # + # self.ft = ft + # self.ift = ift + # print("Setup the fft") diff --git a/ptypy/accelerate/cuda_pycuda/kernels.py b/ptypy/accelerate/cuda_pycuda/kernels.py new file mode 100644 index 000000000..fcb1448bb --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/kernels.py @@ -0,0 +1,1270 @@ +import numpy as np +from inspect import getfullargspec +from pycuda import gpuarray +from ptypy.utils.verbose import log, logger +from . import load_kernel +from .array_utils import CropPadKernel +from .array_utils import MaxAbs2Kernel +from ..base import kernels as ab +from ..base.kernels import Adict + +def choose_fft(fft_type, arr_shape): + dims_are_powers_of_two = True + rows = arr_shape[0] + columns = arr_shape[1] + if rows != columns or rows not in [16, 32, 64, 128, 256, 512, 1024, 2048]: + dims_are_powers_of_two = False + if fft_type=='cuda' and not dims_are_powers_of_two: + logger.warning('cufft: array dimensions are not powers of two (16 to 2048) - using Reikna instead') + from ptypy.accelerate.cuda_pycuda.fft import FFT + elif fft_type=='cuda' and dims_are_powers_of_two: + try: + from ptypy.accelerate.cuda_pycuda.cufft import FFT_cuda as FFT + except: + logger.warning('Unable to import cufft version - using Reikna instead') + from ptypy.accelerate.cuda_pycuda.fft import FFT + elif fft_type=='skcuda': + try: + from ptypy.accelerate.cuda_pycuda.cufft import FFT_skcuda as FFT + except: + logger.warning('Unable to import skcuda.fft version - using Reikna instead') + from ptypy.accelerate.cuda_pycuda.fft import FFT + else: + from ptypy.accelerate.cuda_pycuda.fft import FFT + return FFT + +class PropagationKernel: + + def __init__(self, aux, propagator, queue_thread=None, fft='reikna'): + self.aux = aux + self._queue = queue_thread + self.prop_type = propagator.p.propagation + self.fw = None + self.bw = None + self._fft1 = None + self._fft2 = None + self._p = propagator + self._fft_type = fft + + def allocate(self): + + aux = self.aux + FFT = choose_fft(self._fft_type, aux.shape[-2:]) + + if self.prop_type == 'farfield': + + self._do_crop_pad = (self._p.crop_pad != 0).any() + if self._do_crop_pad: + aux_shape = tuple(np.array(aux.shape) + np.append([0],self._p.crop_pad)) + self._tmp = np.zeros(aux_shape, dtype=aux.dtype) + self._CPK = CropPadKernel(queue=self._queue) + else: + self._tmp = aux + + self._fft1 = FFT(self._tmp, self.queue, + pre_fft=self._p.pre_fft, + post_fft=self._p.post_fft, + symmetric=True, + forward=True) + self._fft2 = FFT(self._tmp, self.queue, + pre_fft=self._p.pre_ifft, + post_fft=self._p.post_ifft, + symmetric=True, + forward=False) + if self._do_crop_pad: + self._tmp = gpuarray.to_gpu(self._tmp) + + def _fw(x,y): + if self._do_crop_pad: + self._CPK.crop_pad_2d_simple(self._tmp, x) + self._fft1.ft(self._tmp, self._tmp) + self._CPK.crop_pad_2d_simple(y, self._tmp) + else: + self._fft1.ft(x,y) + + def _bw(x,y): + if self._do_crop_pad: + self._CPK.crop_pad_2d_simple(self._tmp, x) + self._fft2.ift(self._tmp, self._tmp) + self._CPK.crop_pad_2d_simple(y, self._tmp) + else: + self._fft2.ift(x,y) + + self.fw = _fw + self.bw = _bw + + elif self.prop_type == "nearfield": + self._fft1 = FFT(aux, self.queue, + post_fft=self._p.kernel, + symmetric=True, + forward=True) + self._fft2 = FFT(aux, self.queue, + post_fft=self._p.ikernel, + inplace=True, + symmetric=True, + forward=True) + self._fft3 = FFT(aux, self.queue, + symmetric=True, + forward=False) + + def _fw(x,y): + self._fft1.ft(x,y) + self._fft3.ift(y,y) + + def _bw(x,y): + self._fft2.ft(x,y) + self._fft3.ift(y,y) + + self.fw = _fw + self.bw = _bw + else: + logger.warning("Unable to select propagator %s, only nearfield and farfield are supported" %self.prop_type) + + @property + def queue(self): + return self._queue + + @queue.setter + def queue(self, queue): + self._queue = queue + self._fft1.queue = queue + self._fft2.queue = queue + if self.prop_type == "nearfield": + self._fft3.queue = queue + +class FourierSupportKernel: + def __init__(self, support, queue_thread=None, fft='reikna'): + self.support = support + self.queue = queue_thread + self._fft_type = fft + def allocate(self): + FFT = choose_fft(self._fft_type, self.support.shape[-2:]) + + self._fft1 = FFT(self.support, self.queue, + post_fft=self.support, + symmetric=True, + forward=True) + self._fft2 = FFT(self.support, self.queue, + symmetric=True, + forward=False) + def apply_fourier_support(self,x): + self._fft1.ft(x,x) + self._fft2.ift(x,x) + +class RealSupportKernel: + def __init__(self, support): + self.support = support + def allocate(self): + self.support = gpuarray.to_gpu(self.support) + def apply_real_support(self, x): + x *= self.support + +class FourierUpdateKernel(ab.FourierUpdateKernel): + + def __init__(self, aux, nmodes=1, queue_thread=None, accumulate_type='float', math_type='float'): + super(FourierUpdateKernel, self).__init__(aux, nmodes=nmodes) + + if accumulate_type not in ['float', 'double']: + raise ValueError('Only float or double types are supported') + if math_type not in ['float', 'double']: + raise ValueError('Only float or double types are supported') + self.accumulate_type = accumulate_type + self.math_type = math_type + self.queue = queue_thread + self.fmag_all_update_cuda = load_kernel("fmag_all_update", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }) + self.fmag_update_nopbound_cuda = None + self.fourier_deviation_cuda = None + self.fourier_error_cuda = load_kernel("fourier_error", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }) + self.fourier_error2_cuda = None + self.error_reduce_cuda = load_kernel("error_reduce", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'ACC_TYPE': self.accumulate_type, + 'BDIM_X': 32, + 'BDIM_Y': 32, + }) + self.fourier_update_cuda = None + self.log_likelihood_cuda, self.log_likelihood2_cuda = load_kernel( + ("log_likelihood", "log_likelihood2"), { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }, + "log_likelihood.cu") + self.exit_error_cuda = load_kernel("exit_error", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }) + + self.gpu = Adict() + self.gpu.fdev = None + self.gpu.ferr = None + + def allocate(self): + self.gpu.fdev = gpuarray.zeros(self.fshape, dtype=np.float32) + self.gpu.ferr = gpuarray.zeros(self.fshape, dtype=np.float32) + + def fourier_error(self, f, addr, fmag, fmask, mask_sum): + fdev = self.gpu.fdev + ferr = self.gpu.ferr + if True: + # version going over all modes in a single thread (faster) + self.fourier_error_cuda(np.int32(self.nmodes), + f, + fmask, + fmag, + fdev, + ferr, + mask_sum, + addr, + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=(32, 32, 1), + grid=(int(fmag.shape[0]), 1, 1), + stream=self.queue) + else: + # version using one thread per mode + shared mem reduction (slower) + if self.fourier_error2_cuda is None: + self.fourier_error2_cuda = load_kernel("fourier_error2") + bx = 16 + by = 16 + bz = int(self.nmodes) + blk = (bx, by, bz) + grd = (int((self.fshape[2] + bx-1) // bx), + int((self.fshape[1] + by-1) // by), + int(self.fshape[0])) + #print('block={}, grid={}, fshape={}'.format(blk, grd, self.fshape)) + self.fourier_error2_cuda(np.int32(self.nmodes), + f, + fmask, + fmag, + fdev, + ferr, + mask_sum, + addr, + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=blk, + grid=grd, + shared=int(bx*by*bz*4), + stream=self.queue) + + def fourier_deviation(self, f, addr, fmag): + fdev = self.gpu.fdev + if self.fourier_deviation_cuda is None: + self.fourier_deviation_cuda = load_kernel("fourier_deviation",{ + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }) + bx = 64 + by = 1 + self.fourier_deviation_cuda(np.int32(self.nmodes), + f, + fmag, + fdev, + addr, + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=(bx, by, 1), + grid=(1, int((self.fshape[2] + by - 1)//by), int(fmag.shape[0])), + stream=self.queue) + + + def error_reduce(self, addr, err_sum): + self.error_reduce_cuda(self.gpu.ferr, + err_sum, + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=(32, 32, 1), + grid=(int(err_sum.shape[0]), 1, 1), + stream=self.queue) + + def fmag_all_update(self, f, addr, fmag, fmask, err_fmag, pbound=0.0): + fdev = self.gpu.fdev + self.fmag_all_update_cuda(f, + fmask, + fmag, + fdev, + err_fmag, + addr, + np.float32(pbound), + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=(32, 32, 1), + grid=(int(fmag.shape[0]*self.nmodes), 1, 1), + stream=self.queue) + + def fmag_update_nopbound(self, f, addr, fmag, fmask): + fdev = self.gpu.fdev + bx = 64 + by = 1 + if self.fmag_update_nopbound_cuda is None: + self.fmag_update_nopbound_cuda = load_kernel("fmag_update_nopbound", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }) + self.fmag_update_nopbound_cuda(f, + fmask, + fmag, + fdev, + addr, + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=(bx, by, 1), + grid=(1, + int((self.fshape[2] + by - 1) // by), + int(fmag.shape[0]*self.nmodes)), + stream=self.queue) + + # Note: this was a test to join the kernels, but it's > 2x slower! + def fourier_update(self, f, addr, fmag, fmask, mask_sum, err_fmag, pbound=0): + if self.fourier_update_cuda is None: + self.fourier_update_cuda = load_kernel("fourier_update") + fdev = self.gpu.fdev + ferr = self.gpu.ferr + + bx = 16 + by = 16 + bz = int(self.nmodes) + blk = (bx, by, bz) + grd = (int((self.fshape[2] + bx-1) // bx), + int((self.fshape[1] + by-1) // by), + int(self.fshape[0])) + smem = int(bx*by*bz*4) + self.fourier_update_cuda(np.int32(self.nmodes), + f, + fmask, + fmag, + fdev, + ferr, + mask_sum, + addr, + err_fmag, + np.float32(pbound), + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=blk, + grid=grd, + shared=smem, + stream=self.queue) + + def log_likelihood(self, b_aux, addr, mag, mask, err_phot): + ferr = self.gpu.ferr + self.log_likelihood_cuda(np.int32(self.nmodes), + b_aux, + mask, + mag, + addr, + ferr, + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=(32, 32, 1), + grid=(int(mag.shape[0]), 1, 1), + stream=self.queue) + # TODO: we might want to move this call outside of here + self.error_reduce(addr, err_phot) + + def log_likelihood2(self, b_aux, addr, mag, mask, err_phot): + ferr = self.gpu.ferr + bx = 64 + by = 1 + self.log_likelihood2_cuda(np.int32(self.nmodes), + b_aux, + mask, + mag, + addr, + ferr, + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=(bx, by, 1), + grid=(1, int((self.fshape[1] + by - 1) // by), int(mag.shape[0])), + stream=self.queue) + # TODO: we might want to move this call outside of here + self.error_reduce(addr, err_phot) + + def exit_error(self, aux, addr): + sh = addr.shape + maxz = sh[0] + ferr = self.gpu.ferr + self.exit_error_cuda(np.int32(self.nmodes), + aux, + ferr, + addr, + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=(32, 32, 1), + grid=(int(maxz), 1, 1), + stream=self.queue) + + # DEPRECATED? + def execute(self, kernel_name=None, compare=False, sync=False): + + if kernel_name is None: + for kernel in self.kernels: + self.execute(kernel, compare, sync) + else: + self.log("KERNEL " + kernel_name) + meth = getattr(self, kernel_name) + kernel_args = getfullargspec(meth).args[1:] + args = [getattr(self.ocl, a) for a in kernel_args] + meth(*args) + + return self.ocl.err_fmag.get() + + +class AuxiliaryWaveKernel(ab.AuxiliaryWaveKernel): + + def __init__(self, queue_thread=None, math_type = 'float'): + super(AuxiliaryWaveKernel, self).__init__() + # and now initialise the cuda + self.queue = queue_thread + self._ob_shape = None + self._ob_id = None + self.math_type = math_type + if math_type not in ['float', 'double']: + raise ValueError('Only double or float math is supported') + self.make_aux_cuda, self.make_aux2_cuda = load_kernel( + ("make_aux", "make_aux2"), { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }, "make_aux.cu") + self.make_exit_cuda = load_kernel("make_exit", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }) + self.build_aux_no_ex_cuda, self.build_aux2_no_ex_cuda = load_kernel( + ("build_aux_no_ex", "build_aux2_no_ex"), { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }, "build_aux_no_ex.cu") + # self.build_exit_alpha_tau_cuda = load_kernel("build_exit_alpha_tau", { + # 'IN_TYPE': 'float', + # 'OUT_TYPE': 'float', + # 'MATH_TYPE': self.math_type + # }) + + # DEPRECATED? + def load(self, aux, ob, pr, ex, addr): + super(AuxiliaryWaveKernel, self).load(aux, ob, pr, ex, addr) + for key, array in self.npy.__dict__.items(): + self.ocl.__dict__[key] = gpuarray.to_gpu(array) + + def make_aux(self, b_aux, addr, ob, pr, ex, c_po=1.0, c_e=0.0): + obr, obc = self._cache_object_shape(ob) + sh = addr.shape + nmodes = sh[1] + maxz = sh[0] + self.make_aux_cuda(b_aux, + ex, + np.int32(ex.shape[1]), np.int32(ex.shape[2]), + pr, + np.int32(ex.shape[1]), np.int32(ex.shape[2]), + ob, + obr, obc, + addr, + np.float32(c_po) if ex.dtype == np.complex64 else np.float64(c_po), + np.float32(c_e) if ex.dtype == np.complex64 else np.float64(c_e), + block=(32, 32, 1), grid=(int(maxz * nmodes), 1, 1), stream=self.queue) + + def make_aux2(self, b_aux, addr, ob, pr, ex, c_po=1.0, c_e=0.0): + obr, obc = self._cache_object_shape(ob) + sh = addr.shape + nmodes = sh[1] + maxz = sh[0] + bx = 64 + by = 1 + self.make_aux2_cuda(b_aux, + ex, + np.int32(ex.shape[1]), np.int32(ex.shape[2]), + pr, + np.int32(ex.shape[1]), np.int32(ex.shape[2]), + ob, + obr, obc, + addr, + np.float32(c_po) if ex.dtype == np.complex64 else np.float64(c_po), + np.float32(c_e) if ex.dtype == np.complex64 else np.float64(c_e), + block=(bx, by, 1), + grid=( + 1, + int((ex.shape[1] + by - 1)//by), + int(maxz * nmodes)), + stream=self.queue) + + + def make_exit(self, b_aux, addr, ob, pr, ex, c_a=1.0, c_po=0.0, c_e=-1.0): + obr, obc = self._cache_object_shape(ob) + sh = addr.shape + nmodes = sh[1] + maxz = sh[0] + self.make_exit_cuda(b_aux, + ex, + np.int32(ex.shape[1]), np.int32(ex.shape[2]), + pr, + np.int32(ex.shape[1]), np.int32(ex.shape[2]), + ob, + obr, obc, + addr, + np.float32(c_a) if ex.dtype == np.complex64 else np.float64(c_a), + np.float32(c_po) if ex.dtype == np.complex64 else np.float64(c_po), + np.float32(c_e) if ex.dtype == np.complex64 else np.float64(c_e), + block=(32, 32, 1), grid=(int(maxz * nmodes), 1, 1), stream=self.queue) + + def build_aux2(self, b_aux, addr, ob, pr, ex, alpha=1.0): + # DM only, legacy. also make_aux2 does no exit in the parent + self.make_aux2(b_aux, addr, ob, pr, ex, 1.+alpha, -alpha) + + """ + def build_exit_alpha_tau(self, b_aux, addr, ob, pr, ex, alpha=1, tau=1): + obr, obc = self._cache_object_shape(ob) + sh = addr.shape + nmodes = sh[1] + maxz = sh[0] + bx = 64 + by = 1 + self.build_exit_alpha_tau_cuda(b_aux, + ex, + np.int32(ex.shape[1]), np.int32(ex.shape[2]), + pr, + np.int32(ex.shape[1]), np.int32(ex.shape[2]), + ob, + obr, obc, + addr, + np.float32(alpha), np.float32(tau), + block=(bx, by, 1), + grid=(1, int((ex.shape[1] + by - 1) // by), int(maxz * nmodes)), + stream=self.queue) + """ + def build_aux_no_ex(self, b_aux, addr, ob, pr, fac=1.0, add=False): + obr, obc = self._cache_object_shape(ob) + sh = addr.shape + nmodes = sh[1] + maxz = sh[0] + self.build_aux_no_ex_cuda(b_aux, + np.int32(b_aux.shape[-2]), + np.int32(b_aux.shape[-1]), + pr, + np.int32(pr.shape[-2]), + np.int32(pr.shape[-1]), + ob, + obr, obc, + addr, + np.float32(fac) if pr.dtype == np.complex64 else np.float64(fac), + np.int32(add), + block=(32, 32, 1), + grid=(int(maxz * nmodes), 1, 1), + stream=self.queue) + + + def build_aux2_no_ex(self, b_aux, addr, ob, pr, fac=1.0, add=False): + obr, obc = self._cache_object_shape(ob) + sh = addr.shape + nmodes = sh[1] + maxz = sh[0] + bx = 64 + by = 1 + self.build_aux2_no_ex_cuda(b_aux, + np.int32(b_aux.shape[-2]), + np.int32(b_aux.shape[-1]), + pr, + np.int32(pr.shape[-2]), + np.int32(pr.shape[-1]), + ob, + obr, obc, + addr, + np.float32(fac) if pr.dtype == np.complex64 else np.float64(fac), + np.int32(add), + block=(bx, by, 1), + grid=(1, int((b_aux.shape[-2] + by - 1)//by), int(maxz * nmodes)), + stream=self.queue) + + + def _cache_object_shape(self, ob): + oid = id(ob) + + if not oid == self._ob_id: + self._ob_id = oid + self._ob_shape = (np.int32(ob.shape[-2]), np.int32(ob.shape[-1])) + + return self._ob_shape + + +class GradientDescentKernel(ab.GradientDescentKernel): + + def __init__(self, aux, nmodes=1, queue=None, accumulate_type = 'double', math_type='float'): + super().__init__(aux, nmodes) + self.queue = queue + self.accumulate_type = accumulate_type + self.math_type = math_type + if (accumulate_type not in ['double', 'float']) or (math_type not in ['double', 'float']): + raise ValueError("accumulate and math types must be double for float") + + self.gpu = Adict() + self.gpu.LLden = None + self.gpu.LLerr = None + self.gpu.Imodel = None + + subs = { + 'IN_TYPE': 'float' if self.ftype == np.float32 else 'double', + 'OUT_TYPE': 'float' if self.ftype == np.float32 else 'double', + 'ACC_TYPE': self.accumulate_type, + 'MATH_TYPE': self.math_type + } + self.make_model_cuda = load_kernel('make_model', subs) + self.make_a012_cuda = load_kernel('make_a012', subs) + self.error_reduce_cuda = load_kernel('error_reduce', { + **subs, + 'OUT_TYPE': 'float' if self.ftype == np.float32 else 'double', + 'BDIM_X': 32, + 'BDIM_Y': 32 + }) + self.fill_b_cuda, self.fill_b_reduce_cuda = load_kernel( + ('fill_b', 'fill_b_reduce'), + { + **subs, + 'BDIM_X': 1024, + 'OUT_TYPE': 'float' if self.ftype == np.float32 else 'double' + }, + file="fill_b.cu") + self.main_cuda = load_kernel('gd_main', subs) + self.floating_intensity_cuda_step1, self.floating_intensity_cuda_step2 = \ + load_kernel(('step1', 'step2'), subs,'intens_renorm.cu') + + def allocate(self): + self.gpu.LLden = gpuarray.zeros(self.fshape, dtype=self.ftype) + self.gpu.LLerr = gpuarray.zeros(self.fshape, dtype=self.ftype) + self.gpu.Imodel = gpuarray.zeros(self.fshape, dtype=self.ftype) + tmp = np.ones((self.fshape[0],), dtype=self.ftype) + self.gpu.fic_tmp = gpuarray.to_gpu(tmp) + + # temporary array for the reduction in fill_b + sh = (3, int((np.prod(self.fshape)*self.nmodes + 1023) // 1024)) + self.gpu.Btmp = gpuarray.zeros(sh, dtype=np.float64 if self.accumulate_type == 'double' else np.float32) + + def make_model(self, b_aux, addr): + # reference shape + sh = self.fshape + + # batch buffers + Imodel = self.gpu.Imodel + aux = b_aux + + # dimensions / grid + z = np.int32(sh[0]) + y = np.int32(self.nmodes) + x = np.int32(sh[1] * sh[2]) + bx = 1024 + self.make_model_cuda(aux, Imodel, z, y, x, + block=(bx, 1, 1), + grid=(int((x + bx - 1) // bx), 1, int(z)), + stream=self.queue) + + def make_a012(self, b_f, b_a, b_b, addr, I, fic): + # reference shape (= GPU global dims) + sh = I.shape + + # stopper + maxz = I.shape[0] + + A0 = self.gpu.Imodel + A1 = self.gpu.LLerr + A2 = self.gpu.LLden + + z = np.int32(sh[0]) + maxz = np.int32(maxz) + y = np.int32(self.nmodes) + x = np.int32(sh[1]*sh[2]) + bx = 1024 + self.make_a012_cuda(b_f, b_a, b_b, I, fic, + A0, A1, A2, z, y, x, maxz, + block=(bx, 1, 1), + grid=(int((x + bx - 1) // bx), 1, int(z)), + stream=self.queue) + + def fill_b(self, addr, Brenorm, w, B): + # stopper + maxz = w.shape[0] + + A0 = self.gpu.Imodel + A1 = self.gpu.LLerr + A2 = self.gpu.LLden + + sz = np.int32(np.prod(w.shape)) + blks = int((sz + 1023) // 1024) + # print('blocks={}, Btmp={}, fshape={}, wshape={}, modes={}'.format(blks, self.gpu.Btmp.shape, self.fshape, w.shape, self.nmodes)) + assert self.gpu.Btmp.shape[1] >= blks + # 2-stage reduction - even if 1 block, as we have a += in second kernel + self.fill_b_cuda(A0, A1, A2, w, + np.float32(Brenorm) if self.ftype == np.float32 else np.float64( + Brenorm), + sz, self.gpu.Btmp, + block=(1024, 1, 1), + grid=(blks, 1, 1), + stream=self.queue) + self.fill_b_reduce_cuda(self.gpu.Btmp, B, np.int32(blks), + block=(1024, 1, 1), + grid=(1, 1, 1), + stream=self.queue) + + def error_reduce(self, addr, err_sum): + # reference shape (= GPU global dims) + sh = err_sum.shape + + # stopper + maxz = err_sum.shape[0] + + # batch buffers + ferr = self.gpu.LLerr + + # print('maxz={}, ferr={}'.format(maxz, ferr.shape)) + assert(maxz <= np.prod(ferr.shape[:-2])) + + # Reduces the LL error along the last 2 dimensions.fd + self.error_reduce_cuda(ferr, err_sum, + np.int32(ferr.shape[-2]), + np.int32(ferr.shape[-1]), + block=(32, 32, 1), + grid=(int(maxz), 1, 1), + stream=self.queue) + + def floating_intensity(self, addr, w, I, fic): + + # reference shape (= GPU global dims) + sh = I.shape + + # stopper + maxz = I.shape[0] + + # internal buffers + num = self.gpu.LLerr + den = self.gpu.LLden + Imodel = self.gpu.Imodel + fic_tmp = self.gpu.fic_tmp + + ## math ## + xall = np.int32(maxz * sh[1] * sh[2]) + bx = 1024 + + self.floating_intensity_cuda_step1(Imodel, I, w, num, den, + xall, + block=(bx, 1, 1), + grid=(int((xall + bx - 1) // bx), 1, 1), + stream=self.queue) + + self.error_reduce_cuda(num, fic, + np.int32(num.shape[-2]), + np.int32(num.shape[-1]), + block=(32, 32, 1), + grid=(int(maxz), 1, 1), + stream=self.queue) + + self.error_reduce_cuda(den, fic_tmp, + np.int32(den.shape[-2]), + np.int32(den.shape[-1]), + block=(32, 32, 1), + grid=(int(maxz), 1, 1), + stream=self.queue) + + self.floating_intensity_cuda_step2(fic_tmp, fic, Imodel, + np.int32(Imodel.shape[-2]), + np.int32(Imodel.shape[-1]), + block=(32, 32, 1), + grid=(1, 1, int(maxz)), + stream=self.queue) + + + def main(self, b_aux, addr, w, I): + nmodes = self.nmodes + # stopper + maxz = I.shape[0] + + # batch buffers + err = self.gpu.LLerr + Imodel = self.gpu.Imodel + aux = b_aux + + # write-to shape (= GPU global dims) + ish = aux.shape + + x = np.int32(ish[1] * ish[2]) + y = np.int32(nmodes) + z = np.int32(maxz) + bx = 1024 + + #print(Imodel.dtype, I.dtype, w.dtype, err.dtype, aux.dtype, z, y, x) + self.main_cuda(Imodel, I, w, err, aux, + z, y, x, + block=(bx, 1, 1), + grid=(int((x + bx - 1) // bx), 1, int(z)), + stream=self.queue) + + +class PoUpdateKernel(ab.PoUpdateKernel): + + def __init__(self, queue_thread=None, + math_type='float', accumulator_type='float'): + super(PoUpdateKernel, self).__init__() + # and now initialise the cuda + if math_type not in ['double', 'float']: + raise ValueError('only float and double are supported for math_type') + if accumulator_type not in ['double', 'float']: + raise ValueError('only float and double are supported for accumulator_type') + self.math_type = math_type + self.accumulator_type = accumulator_type + self.queue = queue_thread + self.norm = None + self.MAK = MaxAbs2Kernel(self.queue) + self.ob_update_cuda = load_kernel("ob_update", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }) + self.ob_update2_cuda = None # load_kernel("ob_update2") + self.pr_update_cuda = load_kernel("pr_update", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }) + self.pr_update2_cuda = None + self.ob_update_ML_cuda = load_kernel("ob_update_ML", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }) + self.ob_update2_ML_cuda = None + self.pr_update_ML_cuda = load_kernel("pr_update_ML", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }) + self.pr_update2_ML_cuda = None + self.ob_update_local_cuda = load_kernel("ob_update_local", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type, + 'ACC_TYPE': self.accumulator_type + }) + self.pr_update_local_cuda = load_kernel("pr_update_local", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type, + 'ACC_TYPE': self.accumulator_type + }) + self.ob_norm_local_cuda = load_kernel("ob_norm_local", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type, + 'ACC_TYPE': self.accumulator_type + }) + self.pr_norm_local_cuda = load_kernel("pr_norm_local", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type, + 'ACC_TYPE': self.accumulator_type + }) + + + def ob_update(self, addr, ob, obn, pr, ex, atomics=True): + obsh = [np.int32(ax) for ax in ob.shape] + prsh = [np.int32(ax) for ax in pr.shape] + if obn.dtype != np.float32: + raise ValueError("Denominator must be float32 in current implementation") + + if atomics: + if addr.shape[3] != 3 or addr.shape[2] != 5: + raise ValueError('Address not in required shape for atomics ob_update') + num_pods = np.int32(addr.shape[0] * addr.shape[1]) + self.ob_update_cuda(ex, num_pods, prsh[1], prsh[2], + pr, prsh[0], prsh[1], prsh[2], + ob, obsh[0], obsh[1], obsh[2], + addr, + obn, + block=(32, 32, 1), grid=(int(num_pods), 1, 1), stream=self.queue) + else: + if addr.shape[0] != 5 or addr.shape[1] != 3: + raise ValueError('Address not in required shape for tiled ob_update') + num_pods = np.int32(addr.shape[2] * addr.shape[3]) + if not self.ob_update2_cuda: + self.ob_update2_cuda = load_kernel("ob_update2", { + "NUM_MODES": obsh[0], + "BDIM_X": 16, + "BDIM_Y": 16, + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type, + 'ACC_TYPE': self.accumulator_type + }) + + grid = [int((x+15)//16) for x in ob.shape[-2:]] + grid = (grid[1], grid[0], int(1)) + self.ob_update2_cuda(prsh[-1], obsh[0], num_pods, obsh[-2], obsh[-1], + prsh[0], + np.int32(ex.shape[0]), + np.int32(ex.shape[1]), + np.int32(ex.shape[2]), + ob, obn, pr, ex, addr, + block=(16, 16, 1), grid=grid, stream=self.queue) + + def pr_update(self, addr, pr, prn, ob, ex, atomics=True): + obsh = [np.int32(ax) for ax in ob.shape] + prsh = [np.int32(ax) for ax in pr.shape] + if prn.dtype != np.float32: + raise ValueError("Denominator must be float32 in current implementation") + if atomics: + if addr.shape[3] != 3 or addr.shape[2] != 5: + raise ValueError('Address not in required shape for atomics pr_update') + + num_pods = np.int32(addr.shape[0] * addr.shape[1]) + self.pr_update_cuda(ex, num_pods, prsh[1], prsh[2], + pr, prsh[0], prsh[1], prsh[2], + ob, obsh[0], obsh[1], obsh[2], + addr, + prn, + block=(32, 32, 1), grid=(int(num_pods), 1, 1), stream=self.queue) + else: + if addr.shape[0] != 5 or addr.shape[1] != 3: + raise ValueError('Address not in required shape for tiled pr_update') + + num_pods = np.int32(addr.shape[2] * addr.shape[3]) + if not self.pr_update2_cuda: + self.pr_update2_cuda = load_kernel("pr_update2", { + "NUM_MODES": prsh[0], + "BDIM_X": 16, + "BDIM_Y": 16, + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type, + 'ACC_TYPE': self.accumulator_type + }) + + grid = [int((x+15)//16) for x in pr.shape[-2:]] + grid = (grid[0], grid[1], int(1)) + self.pr_update2_cuda(prsh[-1], obsh[-2], obsh[-1], + prsh[0], obsh[0], num_pods, + pr, prn, ob, ex, addr, + block=(16, 16, 1), grid=grid, stream=self.queue) + + def ob_update_ML(self, addr, ob, pr, ex, fac=2.0, atomics=True): + obsh = [np.int32(ax) for ax in ob.shape] + prsh = [np.int32(ax) for ax in pr.shape] + exsh = [np.int32(ax) for ax in ex.shape] + + if atomics: + if addr.shape[3] != 3 or addr.shape[2] != 5: + raise ValueError('Address not in required shape for tiled ob_update') + + num_pods = np.int32(addr.shape[0] * addr.shape[1]) + self.ob_update_ML_cuda(ex, num_pods, exsh[1], exsh[2], + pr, prsh[0], prsh[1], prsh[2], + ob, obsh[0], obsh[1], obsh[2], + addr, + np.float32(fac) if ex.dtype == np.complex64 else np.float64(fac), + block=(32, 32, 1), grid=(int(num_pods), 1, 1), stream=self.queue) + else: + if addr.shape[0] != 5 or addr.shape[1] != 3: + raise ValueError('Address not in required shape for tiled ob_update') + + num_pods = np.int32(addr.shape[2] * addr.shape[3]) + if not self.ob_update2_ML_cuda: + self.ob_update2_ML_cuda = load_kernel("ob_update2_ML", { + "NUM_MODES": obsh[0], + "BDIM_X": 16, + "BDIM_Y": 16, + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type, + 'ACC_TYPE': self.accumulator_type + }) + grid = [int((x+15)//16) for x in ob.shape[-2:]] + grid = (grid[1], grid[0], int(1)) + self.ob_update2_ML_cuda(prsh[-1], obsh[0], num_pods, obsh[-2], obsh[-1], + prsh[0], + np.int32(ex.shape[0]), + np.int32(ex.shape[1]), + np.int32(ex.shape[2]), + ob, pr, ex, addr, + np.float32(fac) if ex.dtype == np.complex64 else np.float64(fac), + block=(16, 16, 1), grid=grid, stream=self.queue) + + def pr_update_ML(self, addr, pr, ob, ex, fac=2.0, atomics=False): + obsh = [np.int32(ax) for ax in ob.shape] + prsh = [np.int32(ax) for ax in pr.shape] + if atomics: + if addr.shape[3] != 3 or addr.shape[2] != 5: + raise ValueError('Address not in required shape for tiled pr_update') + num_pods = np.int32(addr.shape[0] * addr.shape[1]) + self.pr_update_ML_cuda(ex, num_pods, prsh[1], prsh[2], + pr, prsh[0], prsh[1], prsh[2], + ob, obsh[0], obsh[1], obsh[2], + addr, + np.float32(fac) if ex.dtype == np.complex64 else np.float64(fac), + block=(32, 32, 1), grid=(int(num_pods), 1, 1), stream=self.queue) + else: + if addr.shape[0] != 5 or addr.shape[1] != 3: + raise ValueError('Address not in required shape for tiled pr_update') + num_pods = np.int32(addr.shape[2] * addr.shape[3]) + if not self.pr_update2_ML_cuda: + self.pr_update2_ML_cuda = load_kernel("pr_update2_ML", { + "NUM_MODES": prsh[0], + "BDIM_X": 16, + "BDIM_Y": 16, + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type, + 'ACC_TYPE': self.accumulator_type + }) + + grid = [int((x+15)//16) for x in pr.shape[-2:]] + grid = (grid[0], grid[1], int(1)) + self.pr_update2_ML_cuda(prsh[-1], obsh[-2], obsh[-1], + prsh[0], obsh[0], num_pods, + pr, ob, ex, addr, + np.float32(fac) if ex.dtype == np.complex64 else np.float64(fac), + block=(16, 16, 1), grid=grid, stream=self.queue) + + + def ob_update_local(self, addr, ob, pr, ex, aux, prn, a=0., b=1.): + prn_max = gpuarray.max(prn, stream=self.queue) + obsh = [np.int32(ax) for ax in ob.shape] + prsh = [np.int32(ax) for ax in pr.shape] + exsh = [np.int32(ax) for ax in ex.shape] + # atomics version only + if addr.shape[3] != 3 or addr.shape[2] != 5: + raise ValueError('Address not in required shape for tiled ob_update') + num_pods = np.int32(addr.shape[0] * addr.shape[1]) + bx = 64 + by = 1 + self.ob_update_local_cuda(ex, aux, + exsh[0], exsh[1], exsh[2], + pr, + prsh[0], prsh[1], prsh[2], + prn, + ob, + obsh[0], obsh[1], obsh[2], + addr, + prn_max, + np.float32(a), + np.float32(b), + block=(bx, by, 1), + grid=(1, int((exsh[1] + by - 1)//by), int(num_pods)), + stream=self.queue) + + def pr_update_local(self, addr, pr, ob, ex, aux, obn, obn_max, a=0., b=1.): + obsh = [np.int32(ax) for ax in ob.shape] + prsh = [np.int32(ax) for ax in pr.shape] + exsh = [np.int32(ax) for ax in ex.shape] + # atomics version only + if addr.shape[3] != 3 or addr.shape[2] != 5: + raise ValueError('Address not in required shape for tiled pr_update') + num_pods = np.int32(addr.shape[0] * addr.shape[1]) + bx = 64 + by = 1 + self.pr_update_local_cuda(ex, aux, + exsh[0], exsh[1], exsh[2], + pr, + prsh[0], prsh[1], prsh[2], + obn, + ob, + obsh[0], obsh[1], obsh[2], + addr, + obn_max, + np.float32(a), + np.float32(b), + block=(bx, by, 1), + grid=(1, int((exsh[1] + by - 1) // by), int(num_pods)), + stream=self.queue) + + def ob_norm_local(self, addr, ob, obn): + obsh = [np.int32(ax) for ax in ob.shape] + obnsh = [np.int32(ax) for ax in obn.shape] + bx = 64 + by = 1 + self.ob_norm_local_cuda(obn, + obnsh[0], obnsh[1], obnsh[2], + ob, + obsh[0], obsh[1], obsh[2], + addr, + block=(bx, by, 1), + grid=(1, int((obnsh[1] + by - 1)//by), int(obnsh[0])), + stream=self.queue) + + def pr_norm_local(self, addr, pr, prn): + prsh = [np.int32(ax) for ax in pr.shape] + prnsh = [np.int32(ax) for ax in prn.shape] + bx = 64 + by = 1 + self.pr_norm_local_cuda(prn, + prnsh[0], prnsh[1], prnsh[2], + pr, + prsh[0], prsh[1], prsh[2], + addr, + block=(bx, by, 1), + grid=(1, int((prnsh[1] + by - 1)//by), int(prnsh[0])), + stream=self.queue) + + +class PositionCorrectionKernel(ab.PositionCorrectionKernel): + from ptypy.accelerate.cuda_pycuda import address_manglers + + # these are used by the self.setup method - replacing them with the GPU implementation + MANGLERS = { + 'Annealing': address_manglers.RandomIntMangler, + 'GridSearch': address_manglers.GridSearchMangler + } + + def __init__(self, *args, queue_thread=None, math_type='float', accumulate_type='float', **kwargs): + super(PositionCorrectionKernel, self).__init__(*args, **kwargs) + # make sure we set the right stream in the mangler + self.mangler.queue = queue_thread + if math_type not in ['float', 'double']: + raise ValueError('Only float or double math is supported') + if accumulate_type not in ['float', 'double']: + raise ValueError('Only float or double math is supported') + + # add kernels + self.math_type = math_type + self.accumulate_type = accumulate_type + self.queue = queue_thread + self._ob_shape = None + self._ob_id = None + self.fourier_error_cuda = load_kernel("fourier_error",{ + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }) + self.error_reduce_cuda = load_kernel("error_reduce", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'BDIM_X': 32, + 'BDIM_Y': 32, + 'ACC_TYPE': self.accumulate_type + }) + self.log_likelihood_cuda, self.log_likelihood_ml_cuda = load_kernel( + ("log_likelihood", "log_likelihood_ml"), { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }, "log_likelihood.cu") + self.build_aux_pc_cuda = load_kernel("build_aux_position_correction", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float', + 'MATH_TYPE': self.math_type + }) + self.update_addr_and_error_state_cuda = load_kernel("update_addr_error_state", { + 'IN_TYPE': 'float', + 'OUT_TYPE': 'float' + }) + + self.gpu = Adict() + self.gpu.fdev = None + self.gpu.ferr = None + + def allocate(self): + self.gpu.fdev = gpuarray.zeros(self.fshape, dtype=np.float32) + self.gpu.ferr = gpuarray.zeros(self.fshape, dtype=np.float32) + + def build_aux(self, b_aux, addr, ob, pr): + obr, obc = self._cache_object_shape(ob) + sh = addr.shape + nmodes = sh[1] + maxz = sh[0] + self.build_aux_pc_cuda(b_aux, + pr, + np.int32(pr.shape[1]), np.int32(pr.shape[2]), + ob, + obr, obc, + addr, + block=(32, 32, 1), grid=(int(maxz * nmodes), 1, 1), stream=self.queue) + + def fourier_error(self, f, addr, fmag, fmask, mask_sum): + fdev = self.gpu.fdev + ferr = self.gpu.ferr + self.fourier_error_cuda(np.int32(self.nmodes), + f, + fmask, + fmag, + fdev, + ferr, + mask_sum, + addr, + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=(32, 32, 1), + grid=(int(fmag.shape[0]), 1, 1), + stream=self.queue) + + def error_reduce(self, addr, err_fmag): + #import sys + # float_size = sys.getsizeof(np.float32(4)) + # shared_memory_size =int(2 * 32 * 32 *float_size) # this doesn't work even though its the same... + # shared_memory_size = int(49152) + self.error_reduce_cuda(self.gpu.ferr, + err_fmag, + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=(32, 32, 1), + grid=(int(err_fmag.shape[0]), 1, 1), + stream=self.queue) + + def log_likelihood(self, b_aux, addr, mag, mask, err_phot): + ferr = self.gpu.ferr + self.log_likelihood_cuda(np.int32(self.nmodes), + b_aux, + mask, + mag, + addr, + ferr, + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=(32, 32, 1), + grid=(int(mag.shape[0]), 1, 1), + stream=self.queue) + # TODO: we might want to move this call outside of here + self.error_reduce(addr, err_phot) + + def log_likelihood_ml(self, b_aux, addr, I, weights, err_phot): + ferr = self.gpu.ferr + self.log_likelihood_ml_cuda(np.int32(self.nmodes), + b_aux, + weights, + I, + addr, + ferr, + np.int32(self.fshape[1]), + np.int32(self.fshape[2]), + block=(32, 32, 1), + grid=(int(I.shape[0]), 1, 1), + stream=self.queue) + # TODO: we might want to move this call outside of here + self.error_reduce(addr, err_phot) + + def update_addr_and_error_state(self, addr, error_state, mangled_addr, err_sum): + # assume all data is on GPU! + self.update_addr_and_error_state_cuda(addr, mangled_addr, error_state, err_sum, + np.int32(addr.shape[1]), + block=(32, 2, 1), + grid=(1, int((err_sum.shape[0] + 1) // 2), 1), + stream=self.queue) + + def _cache_object_shape(self, ob): + oid = id(ob) + + if not oid == self._ob_id: + self._ob_id = oid + self._ob_shape = (np.int32(ob.shape[-2]), np.int32(ob.shape[-1])) + + return self._ob_shape + diff --git a/ptypy/accelerate/cuda_pycuda/mem_utils.py b/ptypy/accelerate/cuda_pycuda/mem_utils.py new file mode 100644 index 000000000..88c993fa6 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/mem_utils.py @@ -0,0 +1,426 @@ +import numpy as np +from pycuda import gpuarray +import pycuda.driver as cuda +from pycuda.tools import DeviceMemoryPool +from collections import deque + +def make_pagelocked_paired_arrays(ar, flags=0): + mem = cuda.pagelocked_empty(ar.shape, ar.dtype, order="C", mem_flags=flags) + mem[:] = ar + return gpuarray.to_gpu(mem), mem + + +class GpuData: + """ + Manages one block of GPU data with corresponding CPU data. + Keeps track of which cpu array is currently on GPU by its id, + and transfers if it's not already there. + + To be used for the exit wave, ma, and mag arrays. + Note: Allocator should be pooled for best performance + """ + + def __init__(self, nbytes, syncback=False): + """ + New instance of GpuData. Allocates the GPU-side array. + + :param nbytes: Number of bytes held by this instance. + :param syncback: Should the data be synced back to CPU any time it's swapped out + """ + + self.gpu = None + self.gpuraw = cuda.mem_alloc(nbytes) + self.nbytes = nbytes + self.nbytes_buffer = nbytes + self.gpuId = None + self.cpu = None + self.syncback = syncback + self.ev_done = None + + def _allocator(self, nbytes): + if nbytes > self.nbytes: + raise Exception('requested more bytes than maximum given before: {} vs {}'.format(nbytes, self.nbytes)) + return self.gpuraw + + def record_done(self, stream): + self.ev_done = cuda.Event() + self.ev_done.record(stream) + + def to_gpu(self, cpu, id, stream): + """ + Transfer cpu array to GPU on stream (async), keeping track of its id + """ + if self.gpuId != id: + if self.syncback: + self.from_gpu(stream) + self.gpuId = id + self.cpu = cpu + if self.ev_done is not None: + self.ev_done.synchronize() + self.gpu = gpuarray.to_gpu_async(cpu, allocator=self._allocator, stream=stream) + return self.gpu + + def from_gpu(self, stream): + """ + Transfer data back to CPU, into same data handle it was copied from + before. + """ + if self.cpu is not None and self.gpuId is not None and self.gpu is not None: + if self.ev_done is not None: + stream.wait_for_event(self.ev_done) + self.gpu.get_async(stream, self.cpu) + self.ev_done = cuda.Event() + self.ev_done.record(stream) + + def resize(self, nbytes): + """ + Resize the size of the underlying buffer, to allow re-use in different contexts. + Note that memory will only be freed/reallocated if the new number of bytes are + either larger than before, or if they are less than 90% of the original size - + otherwise it reuses the existing buffer + """ + if nbytes > self.nbytes_buffer or nbytes < self.nbytes_buffer * .9: + self.nbytes_buffer = nbytes + self.gpuraw.free() + self.gpuraw = cuda.mem_alloc(nbytes) + self.nbytes = nbytes + self.reset() + + def reset(self): + """ + Resets handles of cpu references and ids, so that all data will be transfered + again even if IDs match. + """ + self.gpuId = None + self.cpu = None + self.ev_done = None + + def free(self): + """ + Free the underlying buffer on GPU - this object should not be used afterwards + """ + self.gpuraw.free() + self.gpuraw = None + + +class GpuData2(GpuData): + """ + Manages one block of GPU data with corresponding CPU data. + Keeps track of which cpu array is currently on GPU by its id, + and transfers if it's not already there. + + To be used for the exit wave, ma, and mag arrays. + Note: Allocator should be pooled for best performance + """ + + def __init__(self, nbytes, syncback=False): + """ + New instance of GpuData. Allocates the GPU-side array. + + :param nbytes: Number of bytes held by this instance. + :param syncback: Should the data be synced back to CPU any time it's swapped out + """ + self.done_what = None + super().__init__(nbytes, syncback) + + def record_done(self, stream, what): + assert what in ['dtoh','htod','compute'] + self.ev_done = cuda.Event() + self.ev_done.record(stream) + self.done_what = what + + def to_gpu(self, cpu, ident, stream): + """ + Transfer cpu array to GPU on stream (async), keeping track of its id + """ + ident = id(cpu) if ident is None else ident + if self.gpuId != ident: + if self.ev_done is not None: + stream.wait_for_event(self.ev_done) + # Safety measure. This is asynchronous, but it should still work + # Essentially we want to copy the data held in gpu array back to its CPU + # handle before the buffer can be reused. + if self.done_what != 'dtoh' and self.syncback: + # uploads on the download stream, easy to spot in nsight-sys + self.from_gpu(stream) + self.gpuId = ident + self.cpu = cpu + self.gpu = gpuarray.to_gpu_async(cpu, allocator=self._allocator, stream=stream) + self.record_done(stream, 'htod') + return self.ev_done, self.gpu + + def from_gpu(self, stream): + """ + Transfer data back to CPU, into same data handle it was copied from + before. + """ + if self.cpu is not None and self.gpuId is not None and self.gpu is not None: + # Wait for any action recorded with this array + if self.ev_done is not None: + stream.wait_for_event(self.ev_done) + self.gpu.get_async(stream, self.cpu) + self.record_done(stream, 'dtoh') + # Mark for reuse + self.gpuId = None + return self.ev_done + else: + return None + +class GpuDataManager: + """ + Manages a set of GpuData instances, to keep several blocks on device. + + Currently all blocks must be the same size. + + Note that the syncback property is used so that during fourier updates, + the exit wave array is synced bck to cpu (it is updated), + while during probe update, it's not. + """ + + def __init__(self, nbytes, num, max=None, syncback=False): + """ + Create an instance of GpuDataManager. + Parameters are the same as for GpuData, and num is the number of + GpuData instances to create (blocks on device). + """ + self._syncback = syncback + self._nbytes = nbytes + self.data = [] + self.max = max + for i in range(num): + self.add_data_block() + + def add_data_block(self, nbytes=None): + """ + Add a GpuData block. + + Parameters + ---------- + nbytes - Size of block + + Returns + ------- + """ + if self.max is None or len(self) self.mem_avail + + def to_gpu(self, ar, ev=None): + """ + Issues asynchronous copy to device. Waits for optional event ev + Emits event for other streams to synchronize with + """ + stream = self.queue_in + id_cpu = id(ar) + gpu_ar = self.on_device.get(id_cpu) + + if gpu_ar is None: + if ev is not None: + stream.wait_for_event(ev) + if self.device_is_full(ar.nbytes): + self.wait_for_freeing_events(ar.nbytes) + + # TOD0: try /except with garbage collection to make sure there is space + gpu_ar = gpuarray.to_gpu_async(ar, allocator=self.dmp.allocate, stream=stream) + + # keeps gpuarray alive + self.on_device[id_cpu] = gpu_ar + + # for deleting later + self.on_device_inv[id(gpu_ar)] = ar + + self.bytes += gpu_ar.mem_size * gpu_ar.dtype.itemsize + + + ev = cuda.Event() + ev.record(stream) + return ev, gpu_ar + + + def wait_for_freeing_events(self, nbytes): + """ + Wait until at least nbytes have been copied back to the host. Or marked for deletion + """ + freed = 0 + if not self.out_events: + #print('Waiting for memory to be released on device failed as no release event was scheduled') + self.queue_out.synchronize() + while self.out_events and freed < nbytes: + ev, id_cpu, id_gpu = self.out_events.popleft() + gpu_ar = self.on_device.pop(id_cpu) + cpu_ar = self.on_device_inv.pop(id_gpu) + ev.synchronize() + freed += cpu_ar.nbytes + self.bytes -= gpu_ar.mem_size * gpu_ar.dtype.itemsize + + def mark_release_from_gpu(self, gpu_ar, to_cpu=False, ev=None): + stream = self.queue_out + if ev is not None: + stream.wait_for_event(ev) + if to_cpu: + cpu_ar = self.on_device_inv[id(gpu_ar)] + gpu_ar.get_asynch(stream, cpu_ar) + + ev_out = cuda.Event() + ev_out.record(stream) + self.out_events.append((ev_out, id(cpu_ar), id(gpu_ar))) + return ev_out \ No newline at end of file diff --git a/ptypy/accelerate/cuda_pycuda/multi_gpu.py b/ptypy/accelerate/cuda_pycuda/multi_gpu.py new file mode 100644 index 000000000..33113c273 --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/multi_gpu.py @@ -0,0 +1,179 @@ +""" +Multi-GPU AllReduce Wrapper, that uses NCCL via cupy if it's available, +and otherwise falls back to CUDA-aware MPI, +and if that doesn't work, uses host/device copies with regular MPI. + +Findings: + +1) NCCL works with unit tests, but not in the engines. It seems to +add something to the existing pycuda Context or create a new one, +as a later event recording on an exit wave transfer fails with +'ivalid resource handle' Cuda Error. This error typically happens if for example +a CUDA event is created in a different context than what it is used in, +or on a different device. PyCuda uses the driver API, NCCL uses the runtime. +Even though those are interoperable, there seems to be an issue. +Note that this is before any allreduce call - straight after initialising. + +2) NCCL requires cupy - the Python wrapper is in there + +3) OpenMPI with CUDA support needs to be available, and: + - mpi4py needs to be compiled from master (3.1.0a - latest stable release 3.0.x doesn't have it) + - pycuda needs to be compile from master (for __cuda_array_interface__ - 2020.1 version doesn't have it) + - OpenMPI in a conda install needs to have the environment variable + --> if cuda support isn't enabled, the application simply crashes with a seg fault + +4) For NCCL peer-to-peer transfers, the EXCLUSIVE compute mode cannot be used. + It should be in DEFAULT mode. + +""" + +from pkg_resources import parse_version +import numpy as np +from pycuda import gpuarray +import pycuda.driver as cuda +from ptypy.utils import parallel +from ptypy.utils.verbose import logger, log +import os + +try: + from cupy.cuda import nccl + import cupy as cp +except ImportError: + nccl = None + +try: + import mpi4py +except ImportError: + mpi4py = None + +# properties to check which versions are available + +# use NCCL is it is available, and the user didn't override the +# default selection with environment variables +have_nccl = (nccl is not None) and \ + (not 'PTYPY_USE_CUDAMPI' in os.environ) and \ + (not 'PTYPY_USE_MPI' in os.environ) and \ + ('PTYPY_USE_NCCL' in os.environ) + +# At the moment, we require: +# the OpenMPI env var OMPI_MCA_opal_cuda_support to be set to true, +# mpi4py >= 3.1.0 +# pycuda with __cuda_array_interface__ +# and not setting the PTYPY_USE_MPI environment variable +# +# -> we ideally want to allow enabling support from a parameter in ptypy +have_cuda_mpi = (mpi4py is not None) and \ + "OMPI_MCA_opal_cuda_support" in os.environ and \ + os.environ["OMPI_MCA_opal_cuda_support"] == "true" and \ + parse_version(parse_version(mpi4py.__version__).base_version) >= parse_version("3.1.0") and \ + hasattr(gpuarray.GPUArray, '__cuda_array_interface__') and \ + not ('PTYPY_USE_MPI' in os.environ) + + +class MultiGpuCommunicatorBase: + """Base class for multi-GPU communicator options, to aggregate common bits""" + + def __init__(self): + self.rank = parallel.rank + self.ndev = parallel.size + + def allReduceSum(self, arr): + """Call MPI.all_reduce in-place, with array on GPU""" + # base class only checks properties of arrays + assert isinstance(arr, gpuarray.GPUArray), "Input must be a GPUArray" + + +class MultiGpuCommunicatorMpi(MultiGpuCommunicatorBase): + """Communicator for AllReduce that uses MPI on the CPU, i.e. D2H, allreduce, H2D""" + + def allReduceSum(self, arr): + """Call MPI.all_reduce in-place, with array on GPU""" + super().allReduceSum(arr) + + if parallel.MPIenabled: + # note: this creates a temporary CPU array + data = arr.get() + parallel.allreduce(data) + arr.set(data) + +class MultiGpuCommunicatorCudaMpi(MultiGpuCommunicatorBase): + + def allReduceSum(self, arr): + """Call MPI.all_reduce in-place, with array on GPU""" + + # Check if cuda array interface is available + if not hasattr(arr, '__cuda_array_interface__'): + raise RuntimeError("input array should have a cuda array interface") + + if parallel.MPIenabled: + comm = parallel.comm + comm.Allreduce(parallel.MPI.IN_PLACE, arr) + + +class MultiGpuCommunicatorNccl(MultiGpuCommunicatorBase): + + def __init__(self): + super().__init__() + + # Check if GPUs are in default mode + if cuda.Context.get_device().get_attributes()[cuda.device_attribute.COMPUTE_MODE] != cuda.compute_mode.DEFAULT: + raise RuntimeError("Compute mode must be default in order to use NCCL") + + # get a unique identifier for the NCCL communicator and + # broadcast it to all MPI processes (assuming one device per process) + if self.rank == 0: + self.id = nccl.get_unique_id() + else: + self.id = None + + self.id = parallel.bcast(self.id) + + self.com = nccl.NcclCommunicator(self.ndev, self.id, self.rank) + + def allReduceSum(self, arr): + """Call MPI.all_reduce in-place, with array on GPU""" + + buf = int(arr.gpudata) + count, datatype = self.__get_NCCL_count_dtype(arr) + + # no stream support here for now - it fails in NCCL when + # pycuda.Stream.handle is used for some unexplained reason + stream = cp.cuda.Stream.null.ptr + + self.com.allReduce(buf, buf, count, datatype, nccl.NCCL_SUM, stream) + + def __get_NCCL_count_dtype(self, arr): + if arr.dtype == np.complex64: + return arr.size*2, nccl.NCCL_FLOAT32 + elif arr.dtype == np.complex128: + return arr.size*2, nccl.NCCL_FLOAT64 + elif arr.dtype == np.float32: + return arr.size, nccl.NCCL_FLOAT32 + elif arr.dtype == np.float64: + return arr.size, nccl.NCCL_FLOAT64 + else: + raise ValueError("This dtype is not supported by NCCL.") + + +# pick the appropriate communicator depending on installed packages +def get_multi_gpu_communicator(use_nccl=True, use_cuda_mpi=True): + if have_nccl and use_nccl: + try: + comm = MultiGpuCommunicatorNccl() + log(4, "Using NCCL communicator") + return comm + except RuntimeError: + pass + except AttributeError: + # see issue #323 + pass + if have_cuda_mpi and use_cuda_mpi: + try: + comm = MultiGpuCommunicatorCudaMpi() + log(4, "Using CUDA-aware MPI communicator") + return comm + except RuntimeError: + pass + comm = MultiGpuCommunicatorMpi() + log(4, "Using MPI communicator") + return comm diff --git a/ptypy/accelerate/cuda_pycuda/optimisation_log.md b/ptypy/accelerate/cuda_pycuda/optimisation_log.md new file mode 100644 index 000000000..99726af5b --- /dev/null +++ b/ptypy/accelerate/cuda_pycuda/optimisation_log.md @@ -0,0 +1,417 @@ +# PyCuda Optimisation Log + +This log summarises the optimisations performed on the PyCuda engine, +including the attempted ones that did not lead to improvements, +during the December-February 2019/2020 project. +It should serve as a future reference to help understand the optimisations, +and to avoid re-attempting optimisations that were not beneficial. + +**Contents** + +- [DM Engine Kernel Optimisations](#dm-engine-kernel-optimisations) + - [General Notes](#general-notes) + - [Object and Probe Update](#object-and-probe-update) + - [Tiled Version Optimisations](#tiled-version-optimisations) + - [Atomic Version Optimisations](#atomic-version-optimisations) + - [Build Exit Wave](#build-exit-wave) + - [Error Reduce](#error-reduce) + - [Fourier Error](#fourier-error) + - [FFT](#fft) + - [Analysis](#analysis) + - [Implementation](#implementation) + - [Kernel Fusion](#kernel-fusion) +- [ML Engine Kernels](#ml-engine-kernels) + - [Finite Differences (Forward / Backward)](#finite-differences-forward--backward) + - [Fill_b](#fill_b) + - [Make_a012](#make_a012) + - [Make_model](#make_model) + - [Probe/Object Update](#probeobject-update) + - [Dot Product](#dot-product) +- [MPI](#mpi) +- [Position Refinement](#position-refinement) +- [Streaming Engine](#streaming-engine) + - [Data and Streaming Management Classes](#data-and-streaming-management-classes) + - [GpuData](#gpudata) + - [GpuDataManager](#gpudatamanager) + - [Stream Management](#stream-management) + - [Synchronisation](#synchronisation) + - [Page-Locked Memory](#page-locked-memory) + +## DM Engine Kernel Optimisations + +### General Notes + +- All kernels have been written / modified to make no assumptions about the + input data sizes (for example being powers of two), or maximum number of modes, + etc. +- This has been proven by successfully running the insanity test case using the + PyCuda streaming engine +- The following optimisations were found to be most important (in order): + - Coalescing global memory access + - Reducing redundant global memory access by making use of shared memory. + In once instance this required transposing the data on the CPU. + - Tuning thread block sizes through experiments + - Maximising occupancy, for example by giving hints to the compiler using `__launch_bounds__` + so that it can optimise register usage to fit more blocks + - Using texture caches + - Math optimisations + - loop unrolling +- Kernels not explicitly mentioned in the list below either follow the same optimisations, + or were already found to be high performance + +### Object and Probe Update + +- The kernels for both are similar so the same optimisations apply for both +- 2 versions of the kernel exist: + 1. A version using a thread block per line in the address array, + with atomic adds to avoid race conditions in the output array -> [ob_update.cu](cuda/ob_update.cu). + This version was developed in the original CUDA Python module in 2018. + 2. Another version using a thread block per tile of the output array, + iterating over all lines of the address array and only updating + the part relevant to the current tile -> [ob_update2.cu](cuda/ob_update2.cu). + This version is based on the original OpenCL version with PyOpenCL. +- Performance trade-offs are: + - *Atomic Adds Version:* + - No redudant loads of the address array (one line per thread block) + - No checks if the update is relevant in the current tile + (unconditional application of the update) + - BUT the overhead of atomics in global memory (requires a global load, add, and store atomically every time) + - *Tiled Version:* + - No atomics - all updates are local + - BUT conditional if the update is affecting the current thread-block's tile. + - Becomes more efficient if the probe array is larger so that the conditional becomes true for most cases and there are less misses + - Initial tests showed that both versions are valid, depending on the size of the probe array -> the right version can be chosed based on the data sizes + - These tests need to be repeated after all optimisations have been applied + +#### Tiled Version Optimisations + +1. Starting Point: + - Every thread loads the full address array and iterates over it + - Reads all the modes for the local thread into a local array (stored in registers) + - Then updates this local array by iterating over all addresses + - Writes back to global memory at the end +2. Shared Memory: + - Avoids every thread loading the address array redudantly by + collaborating within a thread block for these loads + - Lets every thread in a threadblock load a line of the address array + into shared memory, then sync + - Then the iteration can be done in shared memory, avoiding global memory access + - Reduces redundant loads +3. Coalesced Address Array Loads: + - Transposes the address array before transfering to GPU, + so that global memory accesses to the address lines are coalesced between threads + - Reduces the global loads again as coalesced loads reduce global memory + access +4. Compile-time Constants: + - As PyCuda compiles kernels on the fly, we can set the number of modes + and array sizes as constants before compilation, allowing better compiler optimisation +5. Real-part Updates: + - Only the real part of the denominator needs updating + - The imaginary part is always zero, so it didn't need to be computed / added +6. Texture Caches: + - The constant kernel parameters were put into texture caches using the + `const X* __restrict__` modifiers + - This accelerates the repeated loads and frees the L2/L1 caches for other data +7. Loop unrolling: + - Through experimentation it was found that the update loop could be unrolled by factor 4 for best performance +8. Real denominator: + - Change obn/prn to real data type globally in ptypy, which benefits this kernel's performance (less data to load) + +#### Atomic Version Optimisations + +1. Starting Point: + - Version based on 2018 CUDA effort [extract_array_from_exit_wave.cu](../../../archive/cuda_extension/cuda/func/extract_array_from_exit_wave.cu) +2. Coalesced Access: + - Swap loop order to iterate of the `threadIdx.x` dimension in the inner loop (this is the fast-running index between threads) + - This makes sure that the global memory loads and stores are coalesced +3. Texture Caches: + - The constant kernel parameters were put into texture caches using the + `const X* __restrict__` modifiers + - This accelerates the repeated loads and frees the L2/L1 caches for other data +4. Loop Unrolling: + - Experiments where made with different loop unrolling factors, but none of them made a difference +5. Real-part Updates: + - Only the real part of the denominator needs updating + - The imaginary part is always zero, so it didn't need to be computed / added +6. Real denominator: + - Change obn/prn to real data type globally in ptypy, which benefits this kernel's performance (less data to load) + +### Build Exit Wave + +1. Starting Point + - Version with atomic adds to update the exit wave array +2. Coalesced Access: + - Swap loop order to iterate of the `threadIdx.x` dimension in the inner loop (this is the fast-running index between threads) + - This makes sure that the global memory loads and stores are coalesced +3. Remove Atomics + - The exit wave output is actually not overlapping, so atomics are not needed +4. Loop Unrolling + - Unrolling innner loop by factor for gives a slight performance advantage + +### Error Reduce + +1. Coalesced Access: + - Swap loop order to iterate of the `threadIdx.x` dimension in the inner loop (this is the fast-running index between threads) + - This makes sure that the global memory loads and stores are coalesced +2. Texture Cache + - Not beneficial on any of the constant inputs +3. Boolean Mask + - Using a boolean expression with `m < 0.5 ? X : Y` is slightly slower than the floating point version (48.8ms -> 49.2ms), so we keep using it as a number +4. Loop Unrolling + - Make no difference + +### Fourier Error + +1. Coalesced Access: + - Swap loop order to iterate of the `threadIdx.x` dimension in the inner loop (this is the fast-running index between threads) + - This makes sure that the global memory loads and stores are coalesced +2. Texture Cache + - Not beneficial on any of the constant inputs +3. Store fdev in register + - original code writes back to global memory and reading it back immediately + - seems that compiler already does this optimisation -> no difference +4. Avoid absolute value calculation + - The fdev value is squared and as it's real-valued, so there's to calc absolute value first + - --> makes no noticable difference +5. Use Mask as Boolean + - Changing expression with the boolean ? operator to avoid unnecessary loads when mask is 0 + - --> didn't affect performance +6. Occupancy + - Kernel only achieved 50% occupancy, due to too many registers per block + - Specifying `__launch_bounds__` on the kernel made compiler generate less registers --> 100% occupancy + - Speedup: 35.8ms -> 31.5ms +7. Using one thread per mode + shared memory: + - original lets every thread go in a loop over all modes to su + - tried different version which uses a thread per mode + shared memory + reduction instead + - implemented in [fourier_error2.cu](cuda/fourier_error2.cu) + - Test results on P100, minimal prep and run template for DM, 20 iterations: + - original : 35.80ms total (40 calls) + - shared mem: 80.12ms + - --> it's far worse, so not using this +8. Future Optimisations (not done) + - kernel calculates `real(abs(f)^2)`, which is mathematically the same as `real(f)*real(f) + imag(f)*imag(f)` + - The second version is faster to compute + - Code has a comment that with the second version, results differ from numpy + - However, OpenCL uses the second version + - This should be reconsidered and changed to the faster version + +### FFT + +#### Analysis + +- The Reikna version is used with pre-FFT and post-IFFT arrays built-in for scaling and shifting +- Comparisons showed large speedups with cuFFT if built-in load/store callback mechanism is used + for the scaling and shifting +- cuFFT separate kernels for pre- and post-filtering it's worse than Reikna, as shown below: + +| Version | 128x128x2000 | 256x256x2000 | +|------------------------------------|--------------|--------------| +| Reikna with or without filters | 389ms | 1,470ms | +| cuFFT without filters | 194ms | 793ms | +| cuFFT with separate filter kernels | 388ms | 1,564ms | +| cuFFT with callbacks | 223ms | 916ms | +| **=> cuFFT/callback vs Reikna** | **1.74x** | **1.60x** | + +#### Implementation + +- cuFFT with callbacks only works from C++/CUDA, as callbacks are device functions + which need to be compiled with device-side linking and then pointers to them need + to be obtained and passed to the cuFFT calls. +- This mechanism is not supported in SciKit-CUDA or PyCUDA, hence we need a native + compiled Python module for the task +- We don't want a compilation step at package-install time, prefer PyCUDA's runtime + compilation approach +- Hence we used the [cppimport](https://github.com/tbenthompson/cppimport) to build a + Python module with the [pybind11](https://pybind11.readthedocs.io/en/stable/) C++ library (header-only) for the Python bindings +- The headers can be install with pip conveniently +- CppImport compiles the code when it's imported on-the-fly (and caches it) +- We also used compile-time constant for the FFT sizes, so that the compiler is more efficient + in the callbacks (see comments in the code) +- The [import_fft.py](import_fft.py) file mangaes the cppimport itself, setting the compiler + to nvcc and setting up the compilation flags +- The [cufft.py](cufft.py) wraps the import and calls, providing the same interface as the + [Reikna FFT class](fft.py) + +### Kernel Fusion + +- Of all kernels called in a sequence, the [fourier_error](cuda/fourier_error.cu), + [error_reduce](cuda/error_reduce.cu) and [fmag_all_update](cuda/fmag_all_update.cu) kernels are joinable in principle +- In the former, all modes are calculated by 1 thread, while the latter flattens the data over + the modes +- An attempt was made in [fourier_update.cu](cuda/fourier_update.cu): + - Using shared memory reduction rather than one thread to add the modes, which unifies the thread pattern between both kernels + - Then joining the fmag_all_update kernel + - This was found to be more than twice slower than individual calls + - Also there is a potential race condition, as the err_fmag array is accessed at a different + address (using address book) than when the kernel writes to it. This should be fixable though, by working with the address book all along the fused kernel +- *Future optimisation* + - Another attempt could be done by not using shared memory, but changing fmag_all_update + to iterate over the modes in one thread as well + - the race condition would also need to be fixed, using the address book (if possible) + - This could potentially improve the performance of these kernel combined by up to 2x, + but in the overall timeline, that's only in the single-digit percentages + +## ML Engine Kernels + +Several new kernels have been implemented for the ML engine. The ones with non-trivial +optimisations are given below. +Note that all these kernels have been written to support both float and double +inputs, using compile-time replacements. +It is recommended to modify the DM kernels in a similar fashion for flexibility. + +### Finite Differences (Forward / Backward) + +- These kernels are calculating the difference of 3D arrays with a shifted version of itself: [delx_mid.cu](cuda/delx_mid.cu) and [delx_last.cu](cuda/delx_last.cu) +- They use shared memory to avoid loading the current and next pixel in every thread (reduces global loads by 2x) +- The implementation uses one thread block to iterate along the difference axis, + while the other dimensions are tiled using as many thread blocks as necessary +- Array dimenions are folded, i.e. any dimenions > 3 can be expressed as an array + with 3 dimensions where the axes dimensions before and after the difference axis are multiplied together +- For < 3D, the other dimensions can be considered of size 1 +- For coalescing the load operations, there are 2 kernels: one for the last axis + and one for all previous axes. The difference is that the loads into shared + memory are transposed. +- the code is commented in detail + +### Fill_b + +- the fill_b kernel is essentially some computations and then a reduction along the final 2 dimensions +- The math and first-stage of the reduction (within thread blocks) is in [fill_b](cuda/fill_b.cu) +- The final reduction stage across blocks is in [fill_b_reduce](cuda/fill_b_reduce.cu) +- We're reducing all 3 arrays in a single kernel, using shared memory, to avoid + the call overheads +- the block sizes have been optimised via experiments + +### Make_a012 + +- The kernel [make_a012](cuda/make_a012.cu) implements this functionality +- The summation across modes is done in a single thread, as this was found to be more effecient than shared memory (given only a small number of modes is typically used) + +### Make_model + +- The [make_model](cuda/make_model.cu) is similar, though simpler, to make_a012, + and uses the same pattern (summation across modes in one thread) + +### Probe/Object Update + +- These kernels are the same as for DM, except that there is no denominator +- The same optimisations apply + +### Dot Product + +- The real and complex vector dot product has been implemented in [dot.cu](cuda/dot.cu), including blockwise reduction. +- This is followed by a full reduction over all blocks in [full_reduce.cu](cuda/full_reduce.cu) +- Note that for complex values, this is not mathematically computing the dot product - it calculates `real(a)*real(b) + imag(a)*imag(b)` + +## MPI + +- The MPI all-reduce calls are a major bottleneck, after all the GPU optimisations +- Measurements were taken on DLS cluster, using the [mpi_allreduce_bench.sh](../../../benchmark/mpi_allreduce_bench.sh) script, for single-node and multi-node MPI +- Results are in [this sheet](https://docs.google.com/spreadsheets/d/1OyIWTkFit-0EXKzdODkcw7WfqQC2ldjLXzdz05jTQHY/edit#gid=188734367) +- Key findings: + - synchronisation time is quasi-linear with the number of nodes in DLS + - OpenMPI is far faster than MPICH2 in DLS + +## Position Refinement + +- An optional position refinement algorithm was added to the PyCUDA engines +- So far, it mangles and shifts the addresses on the CPU, and uses the GPU + to evaluate the errors +- It's working, but there is singificant data transfers between host and device +- Transposing the addresses for tiled version of ob/pr update is done on GPU though +- Suggested future optimisations: + - Implement a GPU kernel to pick the indexes from the mangled and original arrays, i.e. for the `update_addr_and_error_state` method + - this is straightforward, just reading a line for one of the two input arrays + depending on a flag + - This avoids a GPU->CPU-GPU turnaround + - Implement a kernel for the `mangle_address` method, taking the deltas as + an input for added flexibility. + - This is mostly indexing operations, adding + delta to the correct elements. + - This avoids another GPU-CPU-GPU turaround, eliminating most of them + - Perform deltas computation on GPU as well + - for example, placing the random numbers on GPU for everything at the start + - or generating them on the fly on the GPU - a simple integer XOR-shift based + random generator should suffice, as statistical properties are less + important here + +## Streaming Engine + +- implemented in [DM_pycuda_stream.py](../../engines/DM_pycuda_stream.py) +- Purpose: allow processing more blocks than fit in GPU memory, by transferring blocks as needed between GPU and CPU, in a chunked fashion +- Implemented using multiple CUDA streams, to overlap transfers with compute, + and using page-locked CPU memory to make transfers asynchronous and fast +- Using separate class for these purposes enables to use more GPU memory blocks + for the exit waves than for the ma/mag arrays, as the latter are faster to + transfer. + +### Data and Streaming Management Classes + +- Data that needs to be cycled in/out of GPU is managed by 2 classes: GpuData and GpuDataManager +- GpuStreamData manages the streams and links it to the data classes +- All these have been documented in detail with Python doc strings + +#### GpuData + +- GpuData handles one block of memory for one array (e.g. exit_wave) +- It allocates a raw GPU buffer to hold any instance of the exit_wave, + and uses a custom allocate function to return the same buffer every time for + a new array +- It keeps track of which CPU array was transferred by means of an ID +- If the same object is used to transfer a new cpu array (different ID), + it can copy the existing GPU data back to the held cpu reference before + replacing it (if syncback=True) +- Some arrays aren't modified on GPU, so the syncback parameter may be false +- It also supports resizing, in case a second engine_prepare is called with different blocks +- Explicit free methods are also given, as we can't wait for the garbage collector + to free GPU memory in case we need to reallocate immediately, to make sure + that memory is available + +#### GpuDataManager + +- manages an array of GpuData objects for multiple blocks of the same array (e.g. exit_wave) +- The GpuData objects can be seen as a list of GPU memory blocks that are fixed + size +- All interactions with GpuData objects are through this manager +- Supports looking up if a requested transfer to GPU is already present with + the same ID, in which case it just returns that without transfer +- Otherwise, takes the oldest instance and replaces the memory with the new data +- Supports resizing, relaying calls to all internal GpuData instances + +### Stream Management + +- GpuDataStream manages one CUDA stream, the related computations and transfers +- It has references to the exit wave, ma, and mag GpuDataManagers +- Decoupling this from the data managment allows to re-use the same data on + different streams, or have more streams than data blocks +- It provides events to synchronise data re-use for ptypy engines + +### Synchronisation + +- Even though we use streams to give an ordering of the computation, + some synchronisation is still needed: + - exit wave, ma, and mag memory blocks might still be in use when a new one + is about to be transferred + - the FFT plan scratch memory and aux blocks are re-used in all streams, + so there can't be compute kernels of other streams +- for the data (exit wave etc.), this is managed in the GpuData class internally. + An event is used in this class to mark when transfers are finished, + and it is synchronised before the same memory block is used again for a new + transfer to GPU. That means in the engine, we need to mark when we are done + with the data, using `record_done`. +- for the compute overlaps (aux and FFT), an `end_compute` method is called + when the compute is done, returning an event that was recorded. + Then `start_compute` is called before starting to compute the next block, + waiting for this event + +### Page-Locked Memory + +- For transfers to be truly asynchronous, the CPU-side memory needs to be + page-locked (pinned). +- That is CPU memory that cannot be paged out to disk +- PyCUDA provides methods to reserve such memory and use it with numpy arrays +- The memory flag 0 (default) means it's regular pinned memory that is fast to + read and write from CPU (used for the arrays that need to be MPI synced) +- The memory flag 4 means write-combined memory, which is fast to write on CPU + and very fast to transfer from CPU to GPU, but its extremely slow to read on CPU. + It is therefore used only for arrays that are not read/modified on CPU. diff --git a/ptypy/accelerate/ocl_pyopencl/__init__.py b/ptypy/accelerate/ocl_pyopencl/__init__.py new file mode 100644 index 000000000..648b9de7f --- /dev/null +++ b/ptypy/accelerate/ocl_pyopencl/__init__.py @@ -0,0 +1,27 @@ + + +ocl_context = None +ocl_queue = None + +def get_ocl_queue(new_queue=False): + + from ptypy.utils import parallel + import pyopencl as cl + devices = cl.get_platforms()[0].get_devices(cl.device_type.GPU) + + global ocl_context + global ocl_queue + + if ocl_context is None and parallel.rank_local < len(devices): + #ocl_context = cl.Context([devices[parallel.rank_local]]) + ocl_context = cl.Context([devices[-1]]) + print("parallel.rank:%s, parallel.rank_local:%s" % (str(parallel.rank), + str(parallel.rank_local))) + + if ocl_context is not None: + if new_queue or ocl_queue is None: + ocl_queue = cl.CommandQueue(ocl_context) + return ocl_queue + else: + return None + diff --git a/ptypy/accelerate/ocl_pyopencl/engines/DM_ocl.py b/ptypy/accelerate/ocl_pyopencl/engines/DM_ocl.py new file mode 100644 index 000000000..2a3604c2a --- /dev/null +++ b/ptypy/accelerate/ocl_pyopencl/engines/DM_ocl.py @@ -0,0 +1,411 @@ +# -*- coding: utf-8 -*- +""" +Difference Map reconstruction engine. + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" + +import numpy as np +import time +import pyopencl as cl + +from ptypy import utils as u +from ptypy.utils.verbose import logger, log +from ptypy.utils import parallel +from ptypy.engines import BaseEngine, register +from ptypy.accelerate.base.engines import projectional_serial + +from pyopencl import array as cla +from ptypy.accelerate.ocl_pyopencl.ocl_kernels import FourierUpdateKernel, AuxiliaryWaveKernel, PoUpdateKernel +from ptypy.accelerate import ocl_pyopencl as gpu + +### TODOS +# +# - Get it running faster with MPI (partial sync) +# - implement "batching" when processing frames to lower the pressure on memory +# - Be smarter about the engine.prepare() part +# - Propagator needs to be reconfigurable for a certain batch size, gpyfft hates that. +# - Fourier_update_kernel needs to allow batched execution + +## for debugging +#from matplotlib import pyplot as plt + +__all__ = ['DM_ocl'] + +parallel = u.parallel + +serialize_array_access = projectional_serial.serialize_array_access +gaussian_kernel = projectional_serial.gaussian_kernel + + +@register() +class DM_ocl(projectional_serial.DM_serial): + + def __init__(self, ptycho_parent, pars=None): + """ + Difference map reconstruction engine. + """ + + super(DM_ocl, self).__init__(ptycho_parent, pars) + + self.queue = gpu.get_ocl_queue() + + # allocator for READ only buffers + # self.const_allocator = cl.tools.ImmediateAllocator(queue, cl.mem_flags.READ_ONLY) + ## gaussian filter + # dummy kernel + if not self.p.obj_smooth_std: + gauss_kernel = gaussian_kernel(1, 1).astype(np.float32) + else: + gauss_kernel = gaussian_kernel(self.p.obj_smooth_std, self.p.obj_smooth_std).astype(np.float32) + + self.gauss_kernel_gpu = cla.to_device(self.queue, gauss_kernel) + + def engine_initialize(self): + """ + Prepare for reconstruction. + """ + super(DM_ocl, self).engine_initialize() + + self.error = [] + + def constbuffer(nbytes): + return cl.Buffer(self.queue.context, cl.mem_flags.READ_ONLY, size=nbytes) + + self.ob_cfact_gpu = {} + self.pr_cfact_gpu = {} + + def _setup_kernels(self): + """ + Setup kernels, one for each scan. Derive scans from ptycho class + """ + # get the scans + for label, scan in self.ptycho.model.scans.items(): + + kern = u.Param() + self.kernels[label] = kern + + # TODO: needs to be adapted for broad bandwidth + geo = scan.geometries[0] + + # Get info to shape buffer arrays + fpc = scan.max_frames_per_block + + # TODO : make this more foolproof + try: + nmodes = scan.p.coherence.num_probe_modes * \ + scan.p.coherence.num_object_modes + except: + nmodes = 1 + + # create buffer arrays + ash = (fpc * nmodes,) + tuple(geo.shape) + aux = np.zeros(ash, dtype=np.complex64) + kern.aux = cla.to_device(self.queue, aux) + + # setup kernels, one for each SCAN. + kern.FUK = FourierUpdateKernel(aux, nmodes) + kern.FUK.allocate() + + kern.POK = PoUpdateKernel() + kern.POK.allocate() + + kern.AWK = AuxiliaryWaveKernel() + kern.AWK.allocate() + + from ptypy.accelerate.ocl_pyopencl.ocl_fft import FFT_2D_ocl_reikna as FFT + kern.FW = FFT(self.queue, aux, + pre_fft=geo.propagator.pre_fft, + post_fft=geo.propagator.post_fft, + inplace=True, + symmetric=True).ft + kern.BW = FFT(self.queue, aux, + pre_fft=geo.propagator.pre_ifft, + post_fft=geo.propagator.post_ifft, + inplace=True, + symmetric=True).ift + self.queue.finish() + + def engine_prepare(self): + + super(DM_ocl, self).engine_prepare() + + ## The following should be restricted to new data + + # For Streaming / Queuing: Limit to data that stays on GPU like pr & ob + # recursive copy to gpu + for name, c in self.ptycho.containers.items(): + for name, s in c.S.items(): + ## convert data here + if s.data.dtype.name == 'bool': + data = s.data.astype(np.float32) + else: + data = s.data + s.gpu = cla.to_device(self.queue, data) + + # For streaming, part of this needs to be moved to engine_iterate + # this contains stuff that aligns with the data + # also only new data should be considered here. + for prep in self.diff_info.values(): + prep.addr = cla.to_device(self.queue, prep.addr) + prep.mag = cla.to_device(self.queue, prep.mag) + prep.ma_sum = cla.to_device(self.queue, prep.ma_sum) + prep.err_fourier = cla.to_device(self.queue, prep.err_fourier) + ## potentially + #prep.ex = ... + #prep.ma = ... + + # finish init queue + self.queue.finish() + + def engine_iterate(self, num=1): + """ + Compute one iteration. + """ + + for it in range(num): + + error_dct = {} + + for dID in self.di.S.keys(): + t1 = time.time() + + prep = self.diff_info[dID] + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # references for kernels + kern = self.kernels[prep.label] + FUK = kern.FUK + AWK = kern.AWK + + pbound = self.pbound_scan[prep.label] + aux = kern.aux + FW = kern.FW + BW = kern.BW + + # get addresses + addr = prep.addr + mag = prep.mag + ma_sum = prep.ma_sum + err_fourier = prep.err_fourier + + # local references + ma = self.ma.S[dID].gpu + ob = self.ob.S[oID].gpu + pr = self.pr.S[pID].gpu + ex = self.ex.S[eID].gpu + + queue = self.queue + + t1 = time.time() + AWK.build_aux(aux, addr, ob, pr, ex, alpha=self.p.alpha) + queue.finish() + + self.benchmark.A_Build_aux += time.time() - t1 + + ## FFT + t1 = time.time() + FW(aux, aux) + queue.finish() + self.benchmark.B_Prop += time.time() - t1 + + ## Deviation from measured data + t1 = time.time() + FUK.fourier_error(aux, addr, mag, ma, ma_sum) + FUK.error_reduce(addr, err_fourier) + FUK.fmag_all_update(aux, addr, mag, ma, err_fourier, pbound) + queue.finish() + self.benchmark.C_Fourier_update += time.time() - t1 + + ## iFFT + t1 = time.time() + BW(aux, aux) + queue.finish() + + self.benchmark.D_iProp += time.time() - t1 + + ## apply changes #2 + t1 = time.time() + AWK.build_exit(aux, addr, ob, pr, ex) + queue.finish() + self.benchmark.E_Build_exit += time.time() - t1 + + err_phot = np.zeros_like(err_fourier) + err_exit = np.zeros_like(err_fourier) + errs = np.array(list(zip(err_fourier.get(self.queue), err_phot, err_exit))) + error = dict(zip(prep.view_IDs, errs)) + + self.benchmark.calls_fourier += 1 + + parallel.barrier() + + sync = (self.curiter % 1 == 0) + self.overlap_update(MPI=True) + + parallel.barrier() + self.curiter += 1 + queue.finish() + + for name, s in self.ob.S.items(): + s.data[:] = s.gpu.get(queue=self.queue) + for name, s in self.pr.S.items(): + s.data[:] = s.gpu.get(queue=self.queue) + + # costly but needed to sync back with + for name, s in self.ex.S.items(): + s.data[:] = s.gpu.get(queue=self.queue) + + self.queue.finish() + + self.error = error + return error + + ## object update + def object_update(self, MPI=False): + t1 = time.time() + queue = self.queue + queue.finish() + for oID, ob in self.ob.storages.items(): + obn = self.ob_nrm.S[oID] + """ + if self.p.obj_smooth_std is not None: + logger.info('Smoothing object, cfact is %.2f' % cfact) + t2 = time.time() + self.prg.gaussian_filter(queue, (info[3],info[4]), None, obj_gpu.data, self.gauss_kernel_gpu.data) + queue.finish() + obj_gpu *= cfact + print 'gauss: ' + str(time.time()-t2) + else: + obj_gpu *= cfact + """ + cfact = self.ob_cfact[oID] + ob.gpu *= cfact + # obn.gpu[:] = cfact + obn.gpu.fill(cfact) + queue.finish() + + # storage for-loop + for dID in self.di.S.keys(): + prep = self.diff_info[dID] + + POK = self.kernels[prep.label].POK + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # scan for loop + ev = POK.ob_update(prep.addr, + self.ob.S[oID].gpu, + self.ob_nrm.S[oID].gpu, + self.pr.S[pID].gpu, + self.ex.S[eID].gpu) + queue.finish() + + for oID, ob in self.ob.storages.items(): + obn = self.ob_nrm.S[oID] + # MPI test + if MPI: + ob.data[:] = ob.gpu.get(queue=queue) + obn.data[:] = obn.gpu.get(queue=queue) + queue.finish() + parallel.allreduce(ob.data) + parallel.allreduce(obn.data) + ob.data /= obn.data + + # Clip object (This call takes like one ms. Not time critical) + if self.p.clip_object is not None: + clip_min, clip_max = self.p.clip_object + ampl_obj = np.abs(ob.data) + phase_obj = np.exp(1j * np.angle(ob.data)) + too_high = (ampl_obj > clip_max) + too_low = (ampl_obj < clip_min) + ob.data[too_high] = clip_max * phase_obj[too_high] + ob.data[too_low] = clip_min * phase_obj[too_low] + ob.gpu.set(ob.data) + else: + ob.gpu /= obn.gpu + + queue.finish() + + # print 'object update: ' + str(time.time()-t1) + self.benchmark.object_update += time.time() - t1 + self.benchmark.calls_object += 1 + + ## probe update + def probe_update(self, MPI=False): + t1 = time.time() + queue = self.queue + + # storage for-loop + change = 0 + cfact = self.p.probe_inertia + for pID, pr in self.pr.storages.items(): + prn = self.pr_nrm.S[pID] + cfact = self.pr_cfact[pID] + pr.gpu *= cfact + prn.gpu.fill(cfact) + + for dID in self.di.S.keys(): + prep = self.diff_info[dID] + + POK = self.kernels[prep.label].POK + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # scan for-loop + ev = POK.pr_update(prep.addr, + self.pr.S[pID].gpu, + self.pr_nrm.S[pID].gpu, + self.ob.S[oID].gpu, + self.ex.S[eID].gpu) + queue.finish() + + for pID, pr in self.pr.storages.items(): + + buf = self.pr_buf.S[pID] + prn = self.pr_nrm.S[pID] + + # MPI test + if MPI: + # if False: + pr.data[:] = pr.gpu.get(queue=queue) + prn.data[:] = prn.gpu.get(queue=queue) + queue.finish() + parallel.allreduce(pr.data) + parallel.allreduce(prn.data) + pr.data /= prn.data + + self.support_constraint(pr) + + pr.gpu.set(pr.data) + else: + pr.gpu /= prn.gpu + # ca. 0.3 ms + # self.pr.S[pID].gpu = probe_gpu + pr.data[:] = pr.gpu.get(queue=queue) + + ## this should be done on GPU + + queue.finish() + change += u.norm2(pr.data - buf.data) / u.norm2(pr.data) + buf.data[:] = pr.data + if MPI: + change = parallel.allreduce(change) / parallel.size + + # print 'probe update: ' + str(time.time()-t1) + self.benchmark.probe_update += time.time() - t1 + self.benchmark.calls_probe += 1 + + return np.sqrt(change) + + def engine_finalize(self): + """ + try deleting ever helper contianer + """ + super(DM_ocl, self).engine_finalize() + self.queue.finish() + + # delete local references to container buffer copies diff --git a/ptypy/accelerate/ocl_pyopencl/engines/DM_ocl_npy.py b/ptypy/accelerate/ocl_pyopencl/engines/DM_ocl_npy.py new file mode 100644 index 000000000..3539f7c15 --- /dev/null +++ b/ptypy/accelerate/ocl_pyopencl/engines/DM_ocl_npy.py @@ -0,0 +1,572 @@ +# -*- coding: utf-8 -*- +""" +Difference Map reconstruction engine. + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" + +import os.path +import numpy as np +import time +import pyopencl as cl + +from ptypy import utils as u +from ptypy.utils.verbose import logger, log +from ptypy.utils import parallel +from ptypy.engines import BaseEngine, register, projectional +from ptypy.accelerate import ocl_pyopencl as gpu + +from pyopencl import array as cla + +### TODOS +# +# - Get it running faster with MPI (partial sync) +# - implement "batching" when processing frames to lower the pressure on memory +# - Be smarter about the engine.prepare() part +# - Propagator needs to be reconfigurable for a certain batch size, gpyfft hates that. +# - Fourier_update_kernel needs to allow batched execution + +## for debugging +#from matplotlib import pyplot as plt + +__all__ = ['DM_ocl_npy'] + +parallel = u.parallel + + +def gaussian_kernel(sigma, size=None, sigma_y=None, size_y=None): + size = int(size) + sigma = np.float(sigma) + if not size_y: + size_y = size + if not sigma_y: + sigma_y = sigma + + x, y = np.mgrid[-size:size + 1, -size_y:size_y + 1] + + g = np.exp(-(x ** 2 / (2 * sigma ** 2) + y ** 2 / (2 * sigma_y ** 2))) + return g / g.sum() + + +def serialize_array_access(diff_storage): + # Sort views according to layer in diffraction stack + views = diff_storage.views + dlayers = [view.dlayer for view in views] + views = [views[i] for i in np.argsort(dlayers)] + view_IDs = [view.ID for view in views] + + # Master pod + mpod = views[0].pod + + # Determine linked storages for probe, object and exit waves + pr = mpod.pr_view.storage + ob = mpod.ob_view.storage + ex = mpod.ex_view.storage + + poe_ID = (pr.ID, ob.ID, ex.ID) + + addr = [] + for view in views: + address = [] + + for pname, pod in view.pods.items(): + ## store them for each pod + # create addresses + a = np.array( + [(pod.pr_view.dlayer, pod.pr_view.dlow[0], pod.pr_view.dlow[1]), + (pod.ob_view.dlayer, pod.ob_view.dlow[0], pod.ob_view.dlow[1]), + (pod.ex_view.dlayer, pod.ex_view.dlow[0], pod.ex_view.dlow[1]), + (pod.di_view.dlayer, pod.di_view.dlow[0], pod.di_view.dlow[1]), + (pod.ma_view.dlayer, pod.ma_view.dlow[0], pod.ma_view.dlow[1])]) + + address.append(a) + + if pod.pr_view.storage.ID != pr.ID: + log(1, "Splitting probes for one diffraction stack is not supported in " + __name__) + if pod.ob_view.storage.ID != ob.ID: + log(1, "Splitting objects for one diffraction stack is not supported in " + __name__) + if pod.ex_view.storage.ID != ex.ID: + log(1, "Splitting exit stacks for one diffraction stack is not supported in " + __name__) + + ## store data for each view + # adresses + addr.append(address) + + # store them for each storage + return view_IDs, poe_ID, np.array(addr).astype(np.int32) + + +@register() +class DM_ocl_npy(projectional.DM): + + def __init__(self, ptycho_parent, pars=None): + """ + Difference map reconstruction engine. + """ + + super(DM_ocl_npy, self).__init__(ptycho_parent, pars) + + self.queue = gpu.get_ocl_queue() + + # allocator for READ only buffers + # self.const_allocator = cl.tools.ImmediateAllocator(queue, cl.mem_flags.READ_ONLY) + ## gaussian filter + # dummy kernel + if not self.p.obj_smooth_std: + gauss_kernel = gaussian_kernel(1, 1).astype(np.float32) + else: + gauss_kernel = gaussian_kernel(self.p.obj_smooth_std, self.p.obj_smooth_std).astype(np.float32) + kernel_pars = {'kernel_sh_x': gauss_kernel.shape[0], 'kernel_sh_y': gauss_kernel.shape[1]} + + self.gauss_kernel_gpu = cla.to_device(self.queue, gauss_kernel) + + def engine_initialize(self): + """ + Prepare for reconstruction. + """ + super(DM_ocl_npy, self).engine_initialize() + + self.benchmark = u.Param() + self.benchmark.A_Build_aux = 0. + self.benchmark.B_Prop = 0. + self.benchmark.C_Fourier_update = 0. + self.benchmark.D_iProp = 0. + self.benchmark.E_Build_exit = 0. + self.benchmark.probe_update = 0. + self.benchmark.object_update = 0. + self.benchmark.calls_fourier = 0 + self.benchmark.calls_object = 0 + self.benchmark.calls_probe = 0 + self.dattype = np.complex64 + + self.error = [] + + self.diff_info = {} + self.ob_cfact = {} + self.pr_cfact = {} + + def constbuffer(nbytes): + return cl.Buffer(self.queue.context, cl.mem_flags.READ_ONLY, size=nbytes) + + self.ob_cfact_gpu = {} + self.pr_cfact_gpu = {} + + def engine_prepare(self): + + super(DM_ocl_npy, self).engine_prepare() + + # object padding on high side (due to 16x16 wg size) + for oID, ob in self.ob.storages.items(): + obn = self.ob_nrm.S[oID] + obv = self.ob_viewcover.S[oID] + misfit = np.asarray(ob.shape[-2:]) % 32 + if (misfit != 0).any(): + pad = 32 - np.asarray(ob.shape[-2:]) % 32 + ob.data = u.crop_pad(ob.data, [[0, pad[0]], [0, pad[1]]], axes=[-2, -1], filltype='project') + obv.data = u.crop_pad(obv.data, [[0, pad[0]], [0, pad[1]]], axes=[-2, -1], filltype='project') + obn.data = u.crop_pad(obn.data, [[0, pad[0]], [0, pad[1]]], axes=[-2, -1], filltype='project') + ob.shape = ob.data.shape + obv.shape = obv.data.shape + obn.shape = obn.data.shape + ## calculating cfacts. This should actually belong to the parent class + #cfact = self.p.object_inertia * self.mean_power * \ + # (obv.data + 1.) + #cfact /= u.parallel.size + #self.ob_cfact[oID] = cfact + #self.ob_cfact_gpu[oID] = cla.to_device(self.queue, cfact) + self.ob_cfact[oID] = self.p.object_inertia * self.mean_power / u.parallel.size + + for pID, pr in self.pr.storages.items(): + cfact = self.p.probe_inertia * len(pr.views) / pr.data.shape[0] + self.pr_cfact[pID] = cfact / u.parallel.size + + ## The following should be restricted to new data + + # recursive copy to gpu + for name, c in self.ptycho.containers.items(): + for name, s in c.S.items(): + ## convert data here + if s.data.dtype.name == 'bool': + data = s.data.astype(np.float32) + else: + data = s.data + s.gpu = cla.to_device(self.queue, data) + + for dID, diffs in self.di.S.items(): + prep = u.Param() + self.diff_info[dID] = prep + + prep.view_IDs, prep.poe_IDs, addr = serialize_array_access(diffs) + + all_modes = addr.shape[1] + # master pod + mpod = self.di.V[prep.view_IDs[0]].pod + pr = mpod.pr_view.storage + ob = mpod.ob_view.storage + ex = mpod.ex_view.storage + + prep.addr_gpu = cla.to_device(self.queue, addr) + prep.addr = addr + + ## auxiliary wave buffer + aux = np.zeros_like(ex.data) + prep.aux_gpu = cla.to_device(self.queue, aux) + prep.aux = aux + self.queue.finish() + + ## setup kernels + from ptypy.accelerate.ocl_pyopencl.ocl_kernels import Fourier_update_kernel as FUK + prep.fourier_kernel = FUK(self.queue, nmodes=all_modes, pbound=self.pbound[dID]) + mask = self.ma.S[dID].data.astype(np.float32) + prep.fourier_kernel.configure(diffs.data, mask, aux) + + from ptypy.accelerate.ocl_pyopencl.ocl_kernels import Auxiliary_wave_kernel as AWK + prep.aux_ex_kernel = AWK(self.queue) + prep.aux_ex_kernel.configure(ob.data, addr, self.p.alpha) + + from ptypy.accelerate.ocl_pyopencl.ocl_kernels import PO_update_kernel as PUK + prep.po_kernel = PUK(self.queue) + prep.po_kernel.configure(ob.data, pr.data, addr) + + geo = mpod.geometry + # you cannot use gpyfft multiple times due to + if not hasattr(geo, 'transform'): + from ptypy.accelerate.ocl_pyopencl.ocl_fft import FFT_2D_ocl_reikna as FFT + + geo.transform = FFT(self.queue, aux, + pre_fft=geo.propagator.pre_fft, + post_fft=geo.propagator.post_fft, + inplace=True, + symmetric=True) + geo.itransform = FFT(self.queue, aux, + pre_fft=geo.propagator.pre_ifft, + post_fft=geo.propagator.post_ifft, + inplace=True, + symmetric=True) + self.queue.finish() + prep.geo = geo + + # finish init queue + self.queue.finish() + + def engine_iterate(self, num=1): + """ + Compute one iteration. + """ + + for it in range(num): + + error_dct = {} + + for dID in self.di.S.keys(): + t1 = time.time() + + prep = self.diff_info[dID] + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # get addresses + addr = prep.addr + + # local references + ma = self.ma.S[dID].data + ob = self.ob.S[oID].data + pr = self.pr.S[pID].data + ex = self.ex.S[eID].data + + aux = prep.aux + + geo = prep.geo + queue = self.queue + + t1 = time.time() + ev = prep.aux_ex_kernel.npy_build_aux(aux, ob, pr, ex, addr) + queue.finish() + + self.benchmark.A_Build_aux += time.time() - t1 + + ## FFT + t1 = time.time() + #geo.transform.ft(aux, aux) + aux[:] = geo.propagator.fw(aux) + queue.finish() + self.benchmark.B_Prop += time.time() - t1 + + ## Deviation from measured data + t1 = time.time() + prep.fourier_kernel.npy.f = aux + err_fourier = prep.fourier_kernel.execute_npy() + queue.finish() + self.benchmark.C_Fourier_update += time.time() - t1 + + ## iFFT + t1 = time.time() + #geo.itransform.ift(aux, aux) + aux[:] = geo.propagator.bw(aux) + queue.finish() + + self.benchmark.D_iProp += time.time() - t1 + + ## apply changes #2 + t1 = time.time() + ev = prep.aux_ex_kernel.npy_build_exit(aux, ob, pr, ex, addr) + queue.finish() + + # self.prg.reduce_one_step(queue, (shape_merged[0],64), (1,64), info_gpu.data, err_temp.data, err_exit.data) + # queue.finish() + + self.benchmark.E_Build_exit += time.time() - t1 + + err_phot = np.zeros_like(err_fourier) + err_exit = np.zeros_like(err_fourier) + errs = np.array(list(zip(err_fourier, err_phot, err_exit))) + error = dict(zip(prep.view_IDs, errs)) + + self.benchmark.calls_fourier += 1 + + parallel.barrier() + + sync = (self.curiter % 1 == 0) + self.overlap_update(MPI=True) + + parallel.barrier() + self.curiter += 1 + queue.finish() + """ + for name, s in self.ob.S.items(): + s.data[:] = s.gpu.get(queue=self.queue) + for name, s in self.pr.S.items(): + s.data[:] = s.gpu.get(queue=self.queue) + + # costly but needed to sync back with + for name, s in self.ex.S.items(): + s.data[:] = s.gpu.get(queue=self.queue) + """ + self.queue.finish() + + self.error = error + return error + + def overlap_update(self, MPI=True): + """ + DM overlap constraint update. + """ + change = 1. + # Condition to update probe + do_update_probe = (self.p.probe_update_start <= self.curiter) + + for inner in range(self.p.overlap_max_iterations): + prestr = '%d Iteration (Overlap) #%02d: ' % (parallel.rank, inner) + # Update object first + if self.p.update_object_first or (inner > 0): + # Update object + log(4, prestr + '----- object update -----', True) + self.object_update(MPI=(parallel.size > 1 and MPI)) + + # Exit if probe should not yet be updated + if not do_update_probe: break + + # Update probe + log(4, prestr + '----- probe update -----', True) + change = self.probe_update(MPI=(parallel.size > 1 and MPI)) + # change = self.probe_update(MPI=(parallel.size>1 and MPI)) + + log(4, prestr + 'change in probe is %.3f' % change, True) + + # stop iteration if probe change is small + if change < self.p.overlap_converge_factor: break + + ## object update + def object_update(self, MPI=False): + t1 = time.time() + queue = self.queue + queue.finish() + for oID, ob in self.ob.storages.items(): + obn = self.ob_nrm.S[oID] + """ + if self.p.obj_smooth_std is not None: + logger.info('Smoothing object, cfact is %.2f' % cfact) + t2 = time.time() + self.prg.gaussian_filter(queue, (info[3],info[4]), None, obj_gpu.data, self.gauss_kernel_gpu.data) + queue.finish() + obj_gpu *= cfact + print 'gauss: ' + str(time.time()-t2) + else: + obj_gpu *= cfact + """ + cfact = self.ob_cfact[oID] + ob.data *= cfact + #obn.gpu[:] = cfact + obn.data.fill(cfact) + queue.finish() + + # storage for-loop + for dID in self.di.S.keys(): + prep = self.diff_info[dID] + + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # scan for loop + ev = prep.po_kernel.npy_ob_update(self.ob.S[oID].data, + self.ob_nrm.S[oID].data, + self.pr.S[pID].data, + self.ex.S[eID].data, + prep.addr) + + queue.finish() + + for oID, ob in self.ob.storages.items(): + obn = self.ob_nrm.S[oID] + # MPI test + if MPI: + #ob.data[:] = ob.gpu.get(queue=queue) + #obn.data[:] = obn.gpu.get(queue=queue) + queue.finish() + parallel.allreduce(ob.data) + parallel.allreduce(obn.data) + ob.data /= obn.data + + # Clip object (This call takes like one ms. Not time critical) + if self.p.clip_object is not None: + clip_min, clip_max = self.p.clip_object + ampl_obj = np.abs(ob.data) + phase_obj = np.exp(1j * np.angle(ob.data)) + too_high = (ampl_obj > clip_max) + too_low = (ampl_obj < clip_min) + ob.data[too_high] = clip_max * phase_obj[too_high] + ob.data[too_low] = clip_min * phase_obj[too_low] + #ob.gpu.set(ob.data) + else: + ob.data /= obn.data + + queue.finish() + + # print 'object update: ' + str(time.time()-t1) + self.benchmark.object_update += time.time() - t1 + self.benchmark.calls_object += 1 + + ## probe update + def probe_update(self, MPI=False): + t1 = time.time() + queue = self.queue + + # storage for-loop + change = 0 + cfact = self.p.probe_inertia + for pID, pr in self.pr.storages.items(): + prn = self.pr_nrm.S[pID] + cfact = self.pr_cfact[pID] + pr.data *= cfact + prn.data.fill(cfact) + + for dID in self.di.S.keys(): + prep = self.diff_info[dID] + + # find probe, object in exit ID in dependence of dID + pID, oID, eID = prep.poe_IDs + + # scan for-loop + ev = prep.po_kernel.npy_pr_update(self.pr.S[pID].data, + self.pr_nrm.S[pID].data, + self.ob.S[oID].data, + self.ex.S[eID].data, + prep.addr) + + queue.finish() + + for pID, pr in self.pr.storages.items(): + + buf = self.pr_buf.S[pID] + prn = self.pr_nrm.S[pID] + + # MPI test + if MPI: + # if False: + #pr.data[:] = pr.gpu.get(queue=queue) + #prn.data[:] = prn.gpu.get(queue=queue) + queue.finish() + parallel.allreduce(pr.data) + parallel.allreduce(prn.data) + pr.data /= prn.data + + self.support_constraint(pr) + # Apply probe support if requested + #support = self.probe_support.get(pID) + #if support is not None: + # pr.data *= support + + # Apply probe support in Fourier space (This could be better done on GPU) + #support = self.probe_fourier_support.get(pID) + #if support is not None: + # pr.data[:] = np.fft.ifft2(support * np.fft.fft2(pr.data)) + + #pr.gpu.set(pr.data) + else: + pr.data /= prn.data + # ca. 0.3 ms + # self.pr.S[pID].gpu = probe_gpu + #pr.data[:] = pr.gpu.get(queue=queue) + + ## this should be done on GPU + + queue.finish() + # change += u.norm2(pr[i]-buf_pr[i]) / u.norm2(pr[i]) + change += u.norm2(pr.data - buf.data) / u.norm2(pr.data) + buf.data[:] = pr.data + if MPI: + change = parallel.allreduce(change) / parallel.size + + # print 'probe update: ' + str(time.time()-t1) + self.benchmark.probe_update += time.time() - t1 + self.benchmark.calls_probe += 1 + + return np.sqrt(change) + + def engine_finalize(self): + """ + try deleting ever helper contianer + """ + self.queue.finish() + if parallel.master: + print("----- BENCHMARKS ----") + acc = 0. + for name in sorted(self.benchmark.keys()): + t = self.benchmark[name] + if name[0] in 'ABCDEFGHI': + print('%20s : %1.3f ms per iteration' % (name, t / self.benchmark.calls_fourier * 1000)) + acc += t + elif str(name) == 'probe_update': + # pass + print('%20s : %1.3f ms per call. %d calls' % ( + name, t / self.benchmark.calls_probe * 1000, self.benchmark.calls_probe)) + elif str(name) == 'object_update': + print('%20s : %1.3f ms per call. %d calls' % ( + name, t / self.benchmark.calls_object * 1000, self.benchmark.calls_object)) + + print('%20s : %1.3f ms per iteration. %d calls' % ( + 'Fourier_total', acc / self.benchmark.calls_fourier * 1000, self.benchmark.calls_fourier)) + + """ + for name, s in self.ob.S.items(): + plt.figure('obj') + d = s.gpu.get() + #print np.abs(d[0][300:-300,300:-300]).mean() + plt.imshow(u.imsave(d[0][400:-400,400:-400])) + for name, s in self.pr.S.items(): + d = s.gpu.get() + for l in d: + plt.figure() + plt.imshow(u.imsave(l)) + #print u.norm2(d) + + plt.show() + """ + + for original in [self.pr, self.ob, self.ex, self.di, self.ma]: + original.delete_copy() + + # delete local references to container buffer copies diff --git a/full_dependencies.yml b/ptypy/accelerate/ocl_pyopencl/full_dependencies.yml similarity index 83% rename from full_dependencies.yml rename to ptypy/accelerate/ocl_pyopencl/full_dependencies.yml index d6bd742a7..bd08f317c 100644 --- a/full_dependencies.yml +++ b/ptypy/accelerate/ocl_pyopencl/full_dependencies.yml @@ -1,4 +1,4 @@ -name: full_dependencies +name: ptypy_pyopencl channels: - conda-forge dependencies: @@ -17,3 +17,4 @@ dependencies: - pytest-cov - coveralls - fabio + - pyopencl==2020.1 \ No newline at end of file diff --git a/ptypy/accelerate/ocl_pyopencl/kernel_heap.txt b/ptypy/accelerate/ocl_pyopencl/kernel_heap.txt new file mode 100644 index 000000000..9275c2270 --- /dev/null +++ b/ptypy/accelerate/ocl_pyopencl/kernel_heap.txt @@ -0,0 +1,550 @@ +#include + +// filter shape +#define KERNEL_SHAPE_X %(kernel_sh_x)d +#define KERNEL_SHAPE_Y %(kernel_sh_y)d + +// Define usable names for buffer access + +#define obj_dlayer(k) addr[k*15 + 3] +#define pr_dlayer(k) addr[k*15] +#define ex_dlayer(k) addr[k*15 + 6] + +#define obj_roi_row(k) addr[k*15 + 4] +#define obj_roi_column(k) addr[k*15 + 5] + +#define obj_sh_row info[3] +#define obj_sh_column info[4] + +#define pr_sh info[5] + +#define N_pods info[0]*info[1] + +#define nmodes info[1] + +__kernel void calc_fm(float pbound, + __global float *fm, + __global float *fmask, + __global float *fmag, + __global float *fdev, + __global float *ferr) +{ + size_t x = get_global_id(2); + size_t dx = get_global_size(2); + size_t y = get_global_id(1); + size_t z_merged = get_global_id(0); + size_t lx = get_local_id(2); + size_t idx = z_merged*dx*dx + y*dx + x; + + __private float a[3]; + + float error = ferr[z_merged]; + float renorm = sqrt(pbound/error); + const float eps = 1e-10; + + if (renorm < 1.){ + a[0] = fmask[idx]; + a[1] = 1. - a[0]; + a[2] = fdev[idx] * renorm + fmag[idx]; + a[2] /= fdev[idx] + fmag[idx] + eps; + fm[idx] = a[0] * a[2] + a[1]; + } + else { + fm[idx] = 1.0; + } +} +__kernel void fmag_update(int nmodes, + __global cfloat_t *f, + __global float *fm + //__global cfloat_t *pre_ifft_g, + ) +{ + size_t x = get_global_id(2); + size_t dx = get_global_size(2); + size_t y = get_global_id(1); + size_t z = get_global_id(0); + size_t z_merged = z/nmodes; + + float fac = fm[z_merged*dx*dx + y*dx + x]; + //cfloat_t ft = cfloat_mul(f[z*dx*dx + y*dx + x], pre_ifft_g[y*dx + x]); + f[z*dx*dx + y*dx + x] = cfloat_mulr(f[z*dx*dx + y*dx + x] , fac); + +} + +__kernel void build_aux(__global int *info, + __global float *DM_info, + __global cfloat_t *ob_g, + __global cfloat_t *pr_g, + __global cfloat_t *ex_g, + __global cfloat_t *f_g, // calculate: (1+alpha)*pod.probe*pod.object - alpha* pod.exit + //__global float *af2, + __global cfloat_t *pre_fft_g, + __global int *addr) +{ + size_t x = get_global_id(2); + size_t dx = get_global_size(2); + size_t y = get_global_id(1); + size_t z = get_global_id(0); + //__private cfloat_t loc_sub [4]; + //__private cfloat_t loc_res [1]; + __private float alpha = DM_info[0]; + + //loc_sub[0] = cfloat_fromreal(DM_info[0]); + cfloat_t ex0 = cfloat_rmul(alpha,ex_g[ex_dlayer(z)*dx*dx + y*dx + x]); + cfloat_t ex1 = cfloat_mul(ob_g[obj_dlayer(z)*obj_sh_row*obj_sh_column + (y+obj_roi_row(z))*obj_sh_column + obj_roi_column(z)+x],pr_g[pr_dlayer(z)*dx*dx + y*dx+x]); + //loc_sub[3] = cfloat_fromreal(1. + loc_sub[0].real); + + cfloat_t ex2 = cfloat_sub(cfloat_rmul(1.+alpha,ex1),ex0); + f_g[z*dx*dx + y*dx + x] = cfloat_mul(ex2,pre_fft_g[y*dx+x]); + //af2[(z/nmodes)*dx*dx + y*dx + x] = 0; //maybe better with if z < af2_size + +} + + +__kernel void post_fft(__global int *info, + __global cfloat_t *f_g, + __global float *af2, + __global cfloat_t *post_fft_g) +{ + size_t x = get_global_id(2); + size_t dx = get_global_size(2); + size_t y = get_global_id(1); + size_t z = get_global_id(0); + size_t z_z = z*nmodes; + __private float loc_f[2]; + loc_f[1] = 0; + + + for(int i=0; i=0)&&(v1=0)&&(v2=0)&&(v1=0)&&(v2 0; + offset = offset / 2) + { + + if (ly < offset) { + scratch[ly] += scratch[ly + offset]; + } + + barrier(CLK_LOCAL_MEM_FENCE); + } + + if (ly == 0) { + result[z] = scratch[0]; + } +} + +__kernel void sum2(__global int *info, __global float *buffer, __global float *result) +{ + size_t z = get_global_id(0); + size_t dz = get_global_size(0); + size_t lz = get_local_id(0); + + for (int y=0; y0; stride/=2){ + barrier(CLK_LOCAL_MEM_FENCE); + if(lidx < stride){ + loc_sum[lidx] += loc_sum[lidx + stride]; + } + } + barrier(CLK_LOCAL_MEM_FENCE); + if (lidx==0){ + result[i*dz*dz + gid] = loc_sum[0]; + } + } + + + +} + +__kernel void gaussian_filter(__global cfloat_t *buffer, __global float *gauss_kernel){ + + size_t x = get_global_id(0); + size_t y = get_global_id(1); + size_t dx = get_global_size(0); + size_t dy = get_global_size(1); + + int ksx = KERNEL_SHAPE_X; + int ksy = KERNEL_SHAPE_Y; + __private cfloat_t sum; + sum = cfloat_fromreal(0.0); + cfloat_t img = buffer[x*dx + y]; + for(int kidx=0; kidx=0 && y-kidy+(ksy-1)/2>=0 && x-kidx+(ksx-1)/2= g_err_sum + # fm = 1.0 (as renorm = 1, i.e. renorm[~ind]) + # pbound < g_err_sum : + # fm = (1 - g_mask) + g_mask * (g_mag + fdev * renorm) / (af + 1e-10) + # (as renorm in [0,1]) + # pbound == 0.0 + # fm = (1 - g_mask) + g_mask * g_mag / (af + 1e-10) (as renorm=0) + + ind = err_sum > pbound + renorm[ind] = np.sqrt(pbound / err_sum[ind]) + renorm = renorm.reshape((renorm.shape[0], 1, 1)) + + af = fdev + mag + fm[:] = (1 - mask) + mask * (mag + fdev * renorm) / (af + 1e-7) + + #fm[:] = mag / (af + 1e-6) + # upcasting + aux[:] = (aux.reshape(ish[0] // nmodes, nmodes, ish[1], ish[2]) * fm[:, np.newaxis, :, :]).reshape(ish) + + def build_aux(self, alpha, ob, pr, ex, addr, offset=0): + + sh = addr.shape + nmodes = sh[1] + + # stopper + maxz = min(sh[0] - offset, self.fshape[0]) + + # batch buffers + addr = addr[:maxz * nmodes] + aux = self.npy.aux[:maxz * nmodes] + + flat_addr = addr.reshape(maxz * nmodes, sh[2], sh[3]) + rows, cols = ex.shape[-2:] + + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + tmp = ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] * \ + pr[prc[0], :, :] * \ + (1. + alpha) - \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] * \ + alpha + aux[ind, :, :] = tmp + + def build_exit(self, ob, pr, ex, addr, offset=0): + + sh = addr.shape + nmodes = sh[1] + + # stopper + maxz = min(sh[0] - offset, self.fshape[0]) + + # batch buffers + addr = addr[:maxz * nmodes] + aux = self.npy.aux[:maxz * nmodes] + + flat_addr = addr.reshape(maxz * nmodes, sh[2], sh[3]) + rows, cols = ex.shape[-2:] + + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + dex = aux[ind, :, :] - \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] * \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] + + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] += dex + aux[ind, :, :] = dex + + +class PO_update_kernel(BaseKernel): + + def __init__(self): + + super(PO_update_kernel, self).__init__() + + def allocate(self): + pass + + def ob_update(self, ob, obn, pr, ex, addr): + + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + rows, cols = ex.shape[-2:] + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] += \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols].conj() * \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] + obn[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] += \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols].conj() * \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] + return + + def pr_update(self, pr, prn, ob, ex, addr): + + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + rows, cols = ex.shape[-2:] + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] += \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols].conj() * \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] + prn[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] += \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols].conj() * \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] + return diff --git a/ptypy/accelerate/ocl_pyopencl/npy_kernels_for_block.py b/ptypy/accelerate/ocl_pyopencl/npy_kernels_for_block.py new file mode 100644 index 000000000..85c01d4be --- /dev/null +++ b/ptypy/accelerate/ocl_pyopencl/npy_kernels_for_block.py @@ -0,0 +1,235 @@ +import numpy as np +from collections import OrderedDict + + +class Adict(object): + + def __init__(self): + pass + + +class BaseKernel(object): + + def __init__(self): + self.verbose = False + self.npy = Adict() + self.benchmark = OrderedDict() + + def log(self, x): + if self.verbose: + print(x) + + +class FourierUpdateKernel(BaseKernel): + + def __init__(self, aux, nmodes=1): + + super(FourierUpdateKernel, self).__init__() + self.denom = 1e-7 + self.nmodes = np.int32(nmodes) + ash = aux.shape + self.fshape = (ash[0] // nmodes, ash[1], ash[2]) + + # temporary buffer arrays + self.npy.fdev = None + self.npy.ferr = None + + self.kernels = [ + 'fourier_error', + 'error_reduce', + 'fmag_all_update' + ] + + def allocate(self): + """ + Allocate memory according to the number of modes and + shape of the diffraction stack. + """ + # temporary buffer arrays + self.npy.fdev = np.zeros(self.fshape, dtype=np.float32) + self.npy.ferr = np.zeros(self.fshape, dtype=np.float32) + + def fourier_error(self, b_aux, addr, mag, mask, mask_sum): + # reference shape (write-to shape) + sh = self.fshape + # stopper + maxz = mag.shape[0] + + # batch buffers + fdev = self.npy.fdev[:maxz] + ferr = self.npy.ferr[:maxz] + aux = b_aux[:maxz * self.nmodes] + + ## Actual math ## + + # build model from complex fourier magnitudes, summing up + # all modes incoherently + tf = aux.reshape(maxz, self.nmodes, sh[1], sh[2]) + af = np.sqrt((np.abs(tf) ** 2).sum(1)) + + # calculate difference to real data (g_mag) + fdev[:] = af - mag + + # Calculate error on fourier magnitudes on a per-pixel basis + ferr[:] = mask * np.abs(fdev) ** 2 / mask_sum.reshape((maxz, 1, 1)) + return + + def error_reduce(self, addr, err_sum): + # reference shape (write-to shape) + sh = self.fshape + + # stopper + maxz = err_sum.shape[0] + + # batch buffers + ferr = self.npy.ferr[:maxz] + + ## Actual math ## + + # Reduceses the Fourier error along the last 2 dimensions.fd + #err_sum[:] = ferr.astype(np.double).sum(-1).sum(-1).astype(np.float) + err_sum[:] = ferr.sum(-1).sum(-1) + return + + def fmag_all_update(self, b_aux, addr, mag, mask, err_sum, pbound=0.0): + + sh = self.fshape + nmodes = self.nmodes + + # stopper + maxz = mag.shape[0] + + # batch buffers + fdev = self.npy.fdev[:maxz] + aux = b_aux[:maxz * nmodes] + + # write-to shape + ish = aux.shape + + ## Actual math ## + + # local values + fm = np.ones((maxz, sh[1], sh[2]), np.float32) + renorm = np.ones((maxz,), np.float32) + + ## As opposed to DM we use renorm to differentiate the cases. + + # pbound >= g_err_sum + # fm = 1.0 (as renorm = 1, i.e. renorm[~ind]) + # pbound < g_err_sum : + # fm = (1 - g_mask) + g_mask * (g_mag + fdev * renorm) / (af + 1e-10) + # (as renorm in [0,1]) + # pbound == 0.0 + # fm = (1 - g_mask) + g_mask * g_mag / (af + 1e-10) (as renorm=0) + + ind = err_sum > pbound + renorm[ind] = np.sqrt(pbound / err_sum[ind]) + renorm = renorm.reshape((renorm.shape[0], 1, 1)) + + af = fdev + mag + fm[:] = (1 - mask) + mask * (mag + fdev * renorm) / (af + self.denom) + + #fm[:] = mag / (af + 1e-6) + # upcasting + aux[:] = (aux.reshape(ish[0] // nmodes, nmodes, ish[1], ish[2]) * fm[:, np.newaxis, :, :]).reshape(ish) + return + +class AuxiliaryWaveKernel(BaseKernel): + + def __init__(self): + super(AuxiliaryWaveKernel, self).__init__() + self.kernels = [ + 'build_aux', + 'build_exit', + ] + + def allocate(self): + pass + + def build_aux(self, b_aux, addr, ob, pr, ex, alpha=1.0): + + sh = addr.shape + + nmodes = sh[1] + + # stopper + maxz = sh[0] + + # batch buffers + aux = b_aux[:maxz * nmodes] + flat_addr = addr.reshape(maxz * nmodes, sh[2], sh[3]) + rows, cols = ex.shape[-2:] + + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + tmp = ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] * \ + pr[prc[0], :, :] * \ + (1. + alpha) - \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] * \ + alpha + aux[ind, :, :] = tmp + return + + def build_exit(self, b_aux, addr, ob, pr, ex): + + sh = addr.shape + + nmodes = sh[1] + + # stopper + maxz = sh[0] + + # batch buffers + aux = b_aux[:maxz * nmodes] + + flat_addr = addr.reshape(maxz * nmodes, sh[2], sh[3]) + rows, cols = ex.shape[-2:] + + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + dex = aux[ind, :, :] - \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] * \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] + + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] += dex + aux[ind, :, :] = dex + return + +class PoUpdateKernel(BaseKernel): + + def __init__(self): + + super(PoUpdateKernel, self).__init__() + self.kernels = [ + 'pr_update', + 'ob_update', + ] + + def allocate(self): + pass + + def ob_update(self, addr, ob, obn, pr, ex): + + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + rows, cols = ex.shape[-2:] + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] += \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols].conj() * \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] + obn[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] += \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols].conj() * \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] + return + + def pr_update(self, addr, pr, prn, ob, ex): + + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + rows, cols = ex.shape[-2:] + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] += \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols].conj() * \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] + prn[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] += \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols].conj() * \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] + return diff --git a/ptypy/accelerate/ocl_pyopencl/ocl_fft.py b/ptypy/accelerate/ocl_pyopencl/ocl_fft.py new file mode 100644 index 000000000..26e08c298 --- /dev/null +++ b/ptypy/accelerate/ocl_pyopencl/ocl_fft.py @@ -0,0 +1,233 @@ +import pyopencl as cl +from pyopencl import array as cla +import numpy as np +import time + + +class FFT_2D_ocl_gpyfft(object): + + def __init__(self, queue, array, + pre_fft=None, + post_fft=None, + inplace=False, + symmetric=False): + + import gpyfft + GFFT = gpyfft.GpyFFT(debug=False) + import gpyfft.gpyfftlib as gfft + + self.queue = queue + + a = np.empty_like(array) + + dims = array.ndim + + if dims == 2: + a = a.reshape((1,) + a.shape) + elif dims == 3: + pass + else: + raise AssertionError('Input array must be 2 or 3-dimensional') + + shape = array.shape[-2:] + distance = a.strides[0] / a.itemsize + strides = (a.strides[1] / a.itemsize, a.strides[2] / a.itemsize) + + batchsize = a.shape[0] + + if a.dtype.type is np.complex64: + precision = gfft.CLFFT_SINGLE + elif a.dtype.type is np.complex128: + precision = gfft.CLFFT_DOUBLE + else: + raise AssertionError( + 'Input array data type must be either complex64 or complex128 but is %s' % str(a.dtype.name)) + + layout = gfft.CLFFT_COMPLEX_INTERLEAVED + + plan = GFFT.create_plan(self.queue.context, shape) + plan.inplace = inplace + plan.strides_in = strides + plan.strides_out = strides + plan.distances = (distance, distance) + plan.batch_size = batchsize + plan.precision = precision + plan.layouts = (layout, layout) + if symmetric: + plan.scale_forward /= np.sqrt(np.prod(shape)) + plan.scale_backward *= np.sqrt(np.prod(shape)) + self.plan = plan + # self.print_plan_info() + # allocate buffers + CA = cl.tools.ImmediateAllocator(self.queue, cl.mem_flags.READ_ONLY) + + if pre_fft is not None: + if np.isscalar(pre_fft): + pre_fft = np.ones(plan.shape, a.dtype) * pre_fft + + self.pre_fft = cla.to_device(queue, pre_fft) # allocator = CA) + queue.finish() + + precallbackstr = "#define PLANE %d\n" % np.prod(plan.shape) + precallbackstr += """float2 prefft(__global void* input, \n + uint inoffset, \n + __global void* userdata) \n + { \n + float2 fac = *((__global float2*)userdata + inoffset % PLANE); \n + float2 in = *((__global float2*)input + inoffset); \n + float2 ret; \n + ret.x = in.x * fac.x - in.y * fac.y ; \n + ret.y = in.x * fac.y + in.y * fac.x ; \n + return ret; \n + }\n""" + if precision is gfft.CLFFT_DOUBLE: + precallbackstr = precallbackstr.replace('float2', 'double2') + plan.set_callback("prefft", precallbackstr, 'pre', user_data=self.pre_fft.data) + + if post_fft is not None: + if np.isscalar(post_fft): + post_fft = np.ones(plan.shape, a.dtype) * post_fft + + # A = np.ones(self.t_shape, out_array.dtype) + self.post_fft = cla.to_device(queue, post_fft) # allocator = CA) + queue.finish() + postcallbackstr = "#define PLANE %d\n" % np.prod(plan.shape) + postcallbackstr += """void postfft(__global void* output, \n + uint outoffset, \n + __global void* userdata, \n + float2 fftoutput) \n + { \n + float2 fac = *((__global float2*)userdata + outoffset % PLANE); \n + float2 res; \n + res.x = fftoutput.x * fac.x - fftoutput.y * fac.y;\n + res.y = fftoutput.x * fac.y + fftoutput.y * fac.x;\n + *((__global float2*)output + outoffset) = res;\n + }\n""" + if precision is gfft.CLFFT_DOUBLE: + postcallbackstr = postcallbackstr.replace('float2', 'double2') + plan.set_callback("postfft", postcallbackstr, 'post', user_data=self.post_fft.data) + + plan.bake(self.queue) + temp_size = plan.temp_array_size + if temp_size: + self.temp_buffer = cl.Buffer(self.queue.context, cl.mem_flags.READ_WRITE, size=temp_size) + else: + self.temp_buffer = None + + self.plan = plan + + def _ft(self, inarray, outarray=None, forward=True): + if not self.plan.inplace and outarray is None: + raise RuntimeError('Specify an opencl array to store the results') + + elif self.plan.inplace: + events = self.plan.enqueue_transform((self.queue,), (inarray.data,), + direction_forward=forward, temp_buffer=self.temp_buffer) + else: + events = self.plan.enqueue_transform((self.queue,), (inarray.data,), (outarray.data,), + direction_forward=forward, temp_buffer=self.temp_buffer) + + return events + + def ft(self, inarray, outarray=None): + + return self._ft(inarray, outarray, True) + + def ift(self, inarray, outarray=None): + + return self._ft(inarray, outarray, False) + + # def print_plan_info(self): + # plan = self.plan + # print('in_array.shape: ', plan.shape) + # print('in_array.strides/itemsize', tuple(s // in_array.dtype.itemsize for s in in_array.strides)) + # print('shape transform ', t_shape) + # print('t_strides ', t_strides_in) + # print('distance_in ', t_distance_in) + # print('batchsize ', t_batchsize_in) + # print('t_stride_out ', t_strides_out) + # print('inplace ', t_inplace) + + +class FFT_2D_ocl_reikna(object): + + def __init__(self, queue, array, + pre_fft=None, + post_fft=None, + inplace=False, + symmetric=True): + + self.queue = queue + ## reikna + from reikna import cluda + api = cluda.ocl_api() + thr = api.Thread(queue) + + dims = array.ndim + if dims < 2: + raise AssertionError('Input array must be at least 2-dimensional') + axes = (array.ndim - 2, array.ndim - 1) + + # build the fft + from reikna.fft import fft + ftreikna = fft.FFT(array, axes) + + # attach scaling + from reikna.transformations import mul_param + sc = mul_param(array, np.float) + ftreikna.parameter.output.connect(sc, sc.input, out=sc.output, scale=sc.param) + iscale = np.sqrt(np.prod(array.shape[-2:])) if symmetric else 1.0 + scale = 1.0 / iscale + + # attach arbitrary multiplication + from reikna import core as rc + from reikna.cluda import functions + # get the IO type + T_io = ftreikna.parameter[0] + T_2d = rc.Type(T_io.dtype, T_io.shape[-2:]) + tr = rc.Transformation( + [ + rc.Parameter('output', rc.Annotation(T_io, 'o')), + rc.Parameter('fac', rc.Annotation(T_2d, 'i')), + rc.Parameter('input', rc.Annotation(T_io, 'i')), + ], + """ + const VSIZE_T x = ${idxs[%d]}; + const VSIZE_T y = ${idxs[%d]}; + + ${output.store_same}(${mul}(${input.load_same}, ${fac.load_idx}(x,y))); + """ % axes, + render_kwds={'mul': functions.mul(T_io.dtype, T_io.dtype)}, + connectors=['input', 'output'] + ) + + if pre_fft is None and post_fft is None: + self._ftreikna = ftreikna.compile(thr) + self.ft = lambda x, y: self._ftreikna(y, scale, x, 0) + self.ift = lambda x, y: self._ftreikna(y, iscale, x, 1) + + elif pre_fft is not None and post_fft is None: + self.pre_fft = cla.to_device(queue, pre_fft) + ftreikna.parameter.input.connect(tr, tr.output, pre_fft=tr.fac, data=tr.input) + self._ftreikna = ftreikna.compile(thr) + self.ft = lambda x, y: self._ftreikna(y, scale, self.pre_fft, x, 0) + self.ift = lambda x, y: self._ftreikna(y, iscale, self.pre_fft, x, 1) + + elif pre_fft is None and post_fft is not None: + self.post_fft = cla.to_device(queue, post_fft) + ftreikna.parameter.out.connect(tr, tr.input, post_fft=tr.fac, result=tr.output) + self._ftreikna = ftreikna.compile(thr) + self.ft = lambda x, y: self._ftreikna(y, self.post_fft, scale, x, 0) + self.ift = lambda x, y: self._ftreikna(y, self.post_fft, iscale, x, 1) + + else: + self.pre_fft = cla.to_device(queue, pre_fft) + self.post_fft = cla.to_device(queue, post_fft) + ftreikna.parameter.input.connect(tr, tr.output, pre_fft=tr.fac, data=tr.input) + ftreikna.parameter.out.connect(tr, tr.input, post_fft=tr.fac, result=tr.output) + # print self._ftreikna.signature.parameters.keys() + self._ftreikna = ftreikna.compile(thr) + self.ft = lambda x, y: self._ftreikna(y, self.post_fft, scale, self.pre_fft, x, 0) + self.ift = lambda x, y: self._ftreikna(y, self.post_fft, iscale, self.pre_fft, x, 1) + + queue.finish() diff --git a/ptypy/accelerate/ocl_pyopencl/ocl_kernels.py b/ptypy/accelerate/ocl_pyopencl/ocl_kernels.py new file mode 100644 index 000000000..7ecf7214e --- /dev/null +++ b/ptypy/accelerate/ocl_pyopencl/ocl_kernels.py @@ -0,0 +1,421 @@ +import pyopencl as cl +from pyopencl import array as cla +import numpy as np +import time + +from . import get_ocl_queue +from .npy_kernels_for_block import AuxiliaryWaveKernel as AWK_NPY +from .npy_kernels_for_block import PoUpdateKernel as POK_NPY +from .npy_kernels_for_block import FourierUpdateKernel as FUK_NPY + + +class Adict(object): + + def __init__(self): + pass + + +class OclBase(object): + + def __init__(self, queue_thread=None): + + self.queue = queue_thread if queue_thread is not None else get_ocl_queue() + self._check_profiling() + self.benchmark = dict() + self.ocl_wg_size = (1, 16, 16) + + def _check_profiling(self): + if self.queue.properties == cl.command_queue_properties.PROFILING_ENABLE: + self.profile = True + else: + self.profile = False + + +class FourierUpdateKernel(FUK_NPY, OclBase): + + def __init__(self, aux, nmodes=1, queue_thread=None): + FUK_NPY.__init__(self, aux, nmodes) + OclBase.__init__(self, queue_thread) + + self.framesize = np.int32(np.prod(aux.shape[-2:])) + + assert self.queue is not None + self.prg = cl.Program(self.queue.context, """ + #include + __kernel void fourier_error(int nmodes, + __global cfloat_t *exit, + __global float *fmag, + __global float *fdev, // fdev = af - fmag + __global float *ferr, // fmask*fdev**2 + __global float *fmask, + __global float *mask_sum + //__global cfloat_t *post_fft_g + ) + { + size_t x = get_global_id(2); + size_t dx = get_global_size(2); + size_t y = get_global_id(1); + size_t z_merged = get_global_id(0); + size_t z_z = z_merged*nmodes; + + __private float loc_f [3]; + __private float loc_af2a = 0.; + __private float loc_af2b = 0.; + + // saves model intensity + //loc_af2[1] = 0; + + #pragma unroll + + for(int i=0; i 0; + offset = offset / 2) + { + + if (ly < offset) { + scratch[ly] += scratch[ly + offset]; + } + + barrier(CLK_LOCAL_MEM_FENCE); + } + + if (ly == 0) { + result[z] = scratch[0]; + } + } + """).build() + + def allocate(self): + self.npy.fdev = cla.zeros(self.queue, self.fshape, dtype=np.float32) + self.npy.ferr = cla.zeros(self.queue, self.fshape, dtype=np.float32) + + def fourier_error(self, b_aux, addr, mag, mask, mask_sum): + fdev = self.npy.fdev + ferr = self.npy.ferr + + self.prg.fourier_error(self.queue, mag.shape, self.ocl_wg_size, + self.nmodes, + b_aux.data, mag.data, fdev.data, ferr.data, + mask.data, mask_sum.data) + self.queue.finish() + + def error_reduce(self, addr, err_sum): + # batch buffers + ferr = self.npy.ferr + + self.prg.reduce_one_step(self.queue, (err_sum.shape[0], 64), (1, 64), + self.framesize, + ferr.data, err_sum.data) + self.queue.finish() + + def fmag_all_update(self, b_aux, addr, mag, mask, err_sum, pbound=0.0): + # maybe cache this? + pbound = np.float32(pbound) + + sh = mag.shape + shape = (sh[0] * self.nmodes, sh[1], sh[2]) # could have also used `addr` for this + fdev = self.npy.fdev + + self.prg.fmag_all_update(self.queue, shape, self.ocl_wg_size, + self.nmodes, pbound, + b_aux.data, mask.data, mag.data, fdev.data, + err_sum.data) + self.queue.finish() + + +class AuxiliaryWaveKernel(AWK_NPY, OclBase): + + def __init__(self, queue_thread=None): + AWK_NPY.__init__(self) + OclBase.__init__(self, queue_thread) + + self._ob_shape = None + self._ob_id = None + # self.ocl_wg_size = (1, 16, 16) + + self.prg = cl.Program(self.queue.context, """ + #include + + // Define usable names for buffer access + + + #define pr_dlayer(k) addr[k*15] + #define ex_dlayer(k) addr[k*15 + 6] + + #define obj_dlayer(k) addr[k*15 + 3] + #define obj_roi_row(k) addr[k*15 + 4] + #define obj_roi_column(k) addr[k*15 + 5] + + // calculates: + // aux = (1+alpha)*pod.probe*pod.object - alpha* pod.exit + __kernel void build_aux(float alpha, + int ob_sh_row, + int ob_sh_col, + __global cfloat_t *aux, + __global cfloat_t *ob, + __global cfloat_t *pr, + __global cfloat_t *ex, + __global int *addr) + { + size_t x = get_global_id(2); + size_t dx = get_global_size(2); + size_t y = get_global_id(1); + size_t z = get_global_id(0); + size_t zb = get_global_id(0); + + //size_t obj_idx = obj_dlayer(z)*ob_sh_row*ob_sh_col + (y+obj_roi_row(z))*ob_sh_col + obj_roi_column(z)+x; + + cfloat_t ex0 = cfloat_rmul(alpha,ex[ex_dlayer(z)*dx*dx + y*dx + x]); + cfloat_t ex1 = cfloat_mul(ob[obj_dlayer(z)*ob_sh_row*ob_sh_col + (y+obj_roi_row(z))*ob_sh_col + obj_roi_column(z)+x],pr[pr_dlayer(z)*dx*dx + y*dx+x]); + //loc_sub[3] = cfloat_fromreal(1. + loc_sub[0].real); + + //cfloat_t ex2 = cfloat_sub(cfloat_rmul(1.+alpha,ex1),ex0); + aux[zb*dx*dx + y*dx + x] = cfloat_sub(cfloat_rmul(1.+alpha,ex1),ex0); + } + + __kernel void build_exit(int ob_sh_row, + int ob_sh_col, + __global cfloat_t *f, + __global cfloat_t *ob, + __global cfloat_t *pr, + __global cfloat_t *ex, + __global int *addr) + { + size_t x = get_global_id(2); + size_t dx = get_global_size(2); + size_t y = get_global_id(1); + size_t z = get_global_id(0); + size_t zb = get_global_id(0); + + size_t obj_idx = obj_dlayer(z)*ob_sh_row*ob_sh_col + (y+obj_roi_row(z))*ob_sh_col + obj_roi_column(z)+x; + + cfloat_t ex1 = cfloat_mul(ob[obj_idx],pr[pr_dlayer(z)*dx*dx + y*dx+x]); + cfloat_t df = cfloat_sub(f[zb*dx*dx + y*dx + x] , ex1); + f[zb*dx*dx + y*dx + x] = df ; // t.b. removed later + ex[ex_dlayer(z)*dx*dx + y*dx + x] = cfloat_add(ex[ex_dlayer(z)*dx*dx + y*dx + x] , df); + } + + """).build() + + def build_aux(self, b_aux, addr, ob, pr, ex, alpha=1.0): + obr, obc = self._cache_object_shape(ob) + ev = self.prg.build_aux(self.queue, ex.shape, self.ocl_wg_size, + np.float32(alpha), obr, obc, + b_aux.data, ob.data, pr.data, ex.data, addr.data) + return ev + + def build_exit(self, b_aux, addr, ob, pr, ex): + obr, obc = self._cache_object_shape(ob) + ev = self.prg.build_exit(self.queue, ex.shape, self.ocl_wg_size, + obr, obc, + b_aux.data, ob.data, pr.data, ex.data, addr.data) + return ev + + def _cache_object_shape(self, ob): + oid = id(ob) + + if not oid == self._ob_id: + self._ob_id = oid + self._ob_shape = (np.int32(ob.shape[-2]), np.int32(ob.shape[-1])) + + return self._ob_shape + + +class PoUpdateKernel(POK_NPY, OclBase): + + def __init__(self, queue_thread=None): + POK_NPY.__init__(self) + OclBase.__init__(self, queue_thread) + self.ocl_wg_size = (16, 16) + self.prg = cl.Program(self.queue.context, """ + #include + + // Define usable names for buffer access + + #define pr_dlayer(k) addr[k*15] + #define ex_dlayer(k) addr[k*15 + 6] + + #define obj_dlayer(k) addr[k*15 + 3] + #define obj_roi_row(k) addr[k*15 + 4] + #define obj_roi_column(k) addr[k*15 + 5] + + __kernel void ob_update(int pr_sh, + int ob_modes, + int num_pods, + __global cfloat_t *ob_g, + __global float *obn_g, + __global cfloat_t *pr_g, + __global cfloat_t *ex_g, + __global int *addr) + { + size_t z = get_global_id(1); + size_t dz = get_global_size(1); + size_t y = get_global_id(0); + size_t dy = get_global_size(0); + __private cfloat_t ob[8]; + __private float obn[8]; + + int v1 = 0; + int v2 = 0; + size_t x = y*dz + z; + cfloat_t pr = pr_g[0]; + + for (int i=0;i=0)&&(v1=0)&&(v2=0)&&(v1=0)&&(v2 + __kernel void fourier_error(int nmodes, + __global cfloat_t *exit, + __global float *fmag, + __global float *fdev, // fdev = af - fmag + __global float *ferr, // fmask*fdev**2 + __global float *fmask, + __global float *mask_sum + //__global cfloat_t *post_fft_g + ) + { + size_t x = get_global_id(2); + size_t dx = get_global_size(2); + size_t y = get_global_id(1); + size_t z_merged = get_global_id(0); + size_t z_z = z_merged*nmodes; + + __private float loc_f [3]; + __private float loc_af2a = 0.; + __private float loc_af2b = 0.; + + // saves model intensity + //loc_af2[1] = 0; + + #pragma unroll + + for(int i=0; i 0; + offset = offset / 2) + { + + if (ly < offset) { + scratch[ly] += scratch[ly + offset]; + } + + barrier(CLK_LOCAL_MEM_FENCE); + } + + if (ly == 0) { + result[z] = scratch[0]; + } + } + """).build() + + def execute_ocl(self, kernel_name=None, compare=False, sync=False): + + if kernel_name is None: + for kernel in self.kernels: + self.execute_ocl(kernel, compare, sync) + else: + self.log("KERNEL " + kernel_name) + m_ocl = getattr(self, 'ocl_' + kernel_name) + m_npy = getattr(self, 'npy_' + kernel_name) + ocl_kernel_args = getfullargspec(m_ocl).args[1:] + npy_kernel_args = getfullargspec(m_npy).args[1:] + assert ocl_kernel_args == npy_kernel_args + # OCL + if sync: + self.sync_ocl() + args = [getattr(self.ocl, a).data for a in ocl_kernel_args] + + self.benchmark[kernel_name] = -time.time() + m_ocl(*args) + self.benchmark[kernel_name] += time.time() + + if compare: + args = [getattr(self.npy, a) for a in npy_kernel_args] + m_npy(*args) + self.verify_ocl() + + return self.ocl.err_fmag.get() + + def execute_npy(self, kernel_name=None): + + if kernel_name is None: + for kernel in self.kernels: + self.execute_npy(kernel) + else: + self.log("KERNEL " + kernel_name) + m_npy = getattr(self, 'npy_' + kernel_name) + npy_kernel_args = getfullargspec(m_npy).args[1:] + args = [getattr(self.npy, a) for a in npy_kernel_args] + m_npy(*args) + + return self.npy.err_fmag + + def npy_fourier_error(self, f, fmag, fdev, ferr, fmask, mask_sum): + sh = f.shape + tf = f.reshape(sh[0] // self.nmodes, self.nmodes, sh[1], sh[2]) + + af = np.sqrt((np.abs(tf) ** 2).sum(1)) + + fdev[:] = af - fmag + ferr[:] = fmask * np.abs(fdev) ** 2 / mask_sum.reshape((mask_sum.shape[0], 1, 1)) + + def ocl_fourier_error(self, f, fmag, fdev, ferr, fmask, mask_sum): + self.prg.fourier_error(self.queue, self.fshape, self.ocl_wg_size, self.nmodes, + f, fmag, fdev, ferr, fmask, mask_sum) + self.queue.finish() + + def npy_error_reduce(self, ferr, err_fmag): + err_fmag[:] = ferr.astype(np.double).sum(-1).sum(-1).astype(np.float) + + def ocl_error_reduce(self, ferr, err_fmag): + shape = (self.fshape[0], 64), + self.prg.reduce_one_step(self.queue, (self.fshape[0], 64), (1, 64), self.framesize, + ferr, err_fmag) + self.queue.finish() + + def _npy_calc_fm(self, fm, fmask, fmag, fdev, err_fmag): + + renorm = np.ones_like(err_fmag) + ind = err_fmag > self.pbound + renorm[ind] = np.sqrt(self.pbound / err_fmag[ind]) + renorm = renorm.reshape((renorm.shape[0], 1, 1)) + af = fdev + fmag + fm[:] = (1 - fmask) + fmask * (fmag + fdev * renorm) / (af + 1e-7) + """ + # C Amplitude correction + if err_fmag > self.pbound: + # Power bound is applied + renorm = np.sqrt(pbound / err_fmag) + fm = (1 - fmask) + fmask * (fmag + fdev * renorm) / (af + 1e-10) + else: + fm = 1.0 + """ + + def _npy_fmag_update(self, f, fm): + sh = f.shape + tf = f.reshape(sh[0] // self.nmodes, self.nmodes, sh[1], sh[2]) + sh = fm.shape + tf *= fm.reshape(sh[0], 1, sh[1], sh[2]) + + def npy_fmag_all_update(self, f, fmask, fmag, fdev, err_fmag): + fm = np.ones_like(fmask) + self._npy_calc_fm(fm, fmask, fmag, fdev, err_fmag) + self._npy_fmag_update(f, fm) + + def ocl_fmag_all_update(self, f, fmask, fmag, fdev, err_fmag): + self.prg.fmag_all_update(self.queue, self.shape, self.ocl_wg_size, + self.nmodes, self.pbound, f, fmask, fmag, fdev, err_fmag) + self.queue.finish() + + def verify_ocl(self, precision=2 ** (-23)): + + for name, val in self.npy.__dict__.items(): + val2 = self.ocl.__dict__[name].get() + val = val + if np.allclose(val, val2, atol=precision): + continue + else: + dev = np.std(val - val2) + print("Key %s : %.2e std, %.2e mean" % (name, dev.real, np.mean(val).real)) + + @classmethod + def test(cls, shape=(739, 256, 256), nmodes=1, pbound=0.05): + + L, M, N = shape + fshape = shape + shape = (nmodes * L, M, N) + + f = np.random.rand(*shape).astype(np.complex64) * 200 + I = np.random.rand(*fshape).astype(np.float32) * 200 ** 2 * nmodes + mask = (I > 10).astype(np.float32) + + devices = cl.get_platforms()[0].get_devices(cl.device_type.GPU) + queue = cl.CommandQueue(cl.Context([devices[0]])) + + inst = cls(queue_thread=queue, nmodes=nmodes, pbound=pbound) + inst.configure(I, mask, f.copy()) + inst.verbose = True + inst.configure_ocl() + + inst.execute_ocl(compare=True, sync=True) + #inst.execute_ocl() + g = inst.ocl.f.get() + inst.execute_npy() + f = inst.npy.f + """ + g = f.copy() + inst.configure(I, mask, g) + err = inst.execute_npy(g) + inst.verify_ocl() + """ + print('Pipeline Error : %.2e' % np.std(f - g)) + for key, val in inst.benchmark.items(): + print('Kernel %s : %.2f ms' % (key, val * 1000)) + + +class Auxiliary_wave_kernel(BaseKernel): + + def __init__(self, queue_thread=None): + + super(Auxiliary_wave_kernel, self).__init__(queue_thread) + + self.prg = cl.Program(self.queue.context, """ + #include + + // Define usable names for buffer access + + + #define pr_dlayer(k) addr[k*15] + #define ex_dlayer(k) addr[k*15 + 6] + + #define obj_dlayer(k) addr[k*15 + 3] + #define obj_roi_row(k) addr[k*15 + 4] + #define obj_roi_column(k) addr[k*15 + 5] + + // calculates: + // aux = (1+alpha)*pod.probe*pod.object - alpha* pod.exit + __kernel void build_aux(float alpha, + int ob_sh_row, + int ob_sh_col, + int batch_offset, + __global cfloat_t *aux, + __global cfloat_t *ob, + __global cfloat_t *pr, + __global cfloat_t *ex, + __global int *addr) + { + size_t x = get_global_id(2); + size_t dx = get_global_size(2); + size_t y = get_global_id(1); + size_t z = get_global_id(0) + batch_offset; + size_t zb = get_global_id(0); + + size_t obj_idx = obj_dlayer(z)*ob_sh_row*ob_sh_col + (y+obj_roi_row(z))*ob_sh_col + obj_roi_column(z)+x; + + cfloat_t ex0 = cfloat_rmul(alpha,ex[ex_dlayer(z)*dx*dx + y*dx + x]); + cfloat_t ex1 = cfloat_mul(ob[obj_dlayer(z)*ob_sh_row*ob_sh_col + (y+obj_roi_row(z))*ob_sh_col + obj_roi_column(z)+x],pr[pr_dlayer(z)*dx*dx + y*dx+x]); + //loc_sub[3] = cfloat_fromreal(1. + loc_sub[0].real); + + //cfloat_t ex2 = cfloat_sub(cfloat_rmul(1.+alpha,ex1),ex0); + aux[zb*dx*dx + y*dx + x] = cfloat_sub(cfloat_rmul(1.+alpha,ex1),ex0); + } + + __kernel void build_exit(float alpha, + int ob_sh_row, + int ob_sh_col, + int batch_offset, + __global cfloat_t *f, + __global cfloat_t *ob, + __global cfloat_t *pr, + __global cfloat_t *ex, + __global int *addr) + { + size_t x = get_global_id(2); + size_t dx = get_global_size(2); + size_t y = get_global_id(1); + size_t z = get_global_id(0) + batch_offset; + size_t zb = get_global_id(0); + + size_t obj_idx = obj_dlayer(z)*ob_sh_row*ob_sh_col + (y+obj_roi_row(z))*ob_sh_col + obj_roi_column(z)+x; + + cfloat_t ex1 = cfloat_mul(ob[obj_idx],pr[pr_dlayer(z)*dx*dx + y*dx+x]); + cfloat_t df = cfloat_sub(f[zb*dx*dx + y*dx + x] , ex1); + f[zb*dx*dx + y*dx + x] = df ; // t.b. removed later + ex[ex_dlayer(z)*dx*dx + y*dx + x] = cfloat_add(ex[ex_dlayer(z)*dx*dx + y*dx + x] , df); + } + + """).build() + + self.kernels = [ + 'build_aux', + 'build_exit', + ] + + def configure(self, ob, addr, alpha=1.0): + + self.batch_offset = 0 + self.alpha = np.float32(alpha) + self.ob_shape = (np.int32(ob.shape[-2]), np.int32(ob.shape[-1])) + + self.nviews, self.nmodes, self.ncoords, self.naxes = addr.shape + self.ocl_wg_size = (1, 1, 32) + + @property + def batch_offset(self): + return self._offset + + @batch_offset.setter + def batch_offset(self, x): + self._offset = np.int32(x) + + def load(self, aux, ob, pr, ex, addr): + + assert pr.dtype == np.complex64 + assert ex.dtype == np.complex64 + assert aux.dtype == np.complex64 + assert ob.dtype == np.complex64 + assert addr.dtype == np.int32 + + self.npy.aux = aux + self.npy.pr = pr + self.npy.ob = ob + self.npy.ex = ex + self.npy.addr = addr + + for key, array in self.npy.__dict__.items(): + self.ocl.__dict__[key] = cla.to_device(self.queue, array) + + def sync_ocl(self): + for key, array in self.npy.__dict__.items(): + self.ocl.__dict__[key].set(array) + + def execute_ocl(self, kernel_name=None, compare=False, sync=False): + + if kernel_name is None: + for kernel in self.kernels: + self.execute_ocl(kernel, compare, sync) + else: + self.log("KERNEL " + kernel_name) + m_ocl = getattr(self, 'ocl_' + kernel_name) + m_npy = getattr(self, 'npy_' + kernel_name) + ocl_kernel_args = getfullargspec(m_ocl).args[1:] + npy_kernel_args = getfullargspec(m_npy).args[1:] + assert ocl_kernel_args == npy_kernel_args + # OCL + if sync: + self.sync_ocl() + args = [getattr(self.ocl, a) for a in ocl_kernel_args] + + self.benchmark[kernel_name] = -time.time() + m_ocl(*args) + self.benchmark[kernel_name] += time.time() + + if compare: + args = [getattr(self.npy, a) for a in npy_kernel_args] + m_npy(*args) + self.verify_ocl() + + return + + def execute_npy(self, kernel_name=None): + + if kernel_name is None: + for kernel in self.kernels: + self.execute_npy(kernel) + else: + self.log("KERNEL " + kernel_name) + m_npy = getattr(self, '_npy_' + kernel_name) + npy_kernel_args = getfullargspec(m_npy).args[1:] + args = [getattr(self.npy, a) for a in npy_kernel_args] + m_npy(*args) + + return + + def ocl_build_aux(self, aux, ob, pr, ex, addr): + obsh = self.ob_shape + ev = self.prg.build_aux(self.queue, aux.shape, self.ocl_wg_size, + self.alpha, obsh[0], obsh[1], self._offset, + aux.data, ob.data, pr.data, ex.data, addr.data) + return ev + + def npy_build_aux(self, aux, ob, pr, ex, addr): + + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + off = self.batch_offset + flat_addr = flat_addr[off:off + aux.shape[0]] + rows, cols = ex.shape[-2:] + + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + tmp = ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] * \ + pr[prc[0], :, :] * \ + (1. + self.alpha) - \ + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] * \ + self.alpha + aux[ind, :, :] = tmp + + def ocl_build_exit(self, aux, ob, pr, ex, addr): + obsh = self.ob_shape + ev = self.prg.build_exit(self.queue, aux.shape, self.ocl_wg_size, + self.alpha, obsh[0], obsh[1], self._offset, + aux.data, ob.data, pr.data, ex.data, addr.data) + + return ev + + def npy_build_exit(self, aux, ob, pr, ex, addr): + + sh = addr.shape + flat_addr = addr.reshape(sh[0] * sh[1], sh[2], sh[3]) + off = self.batch_offset + flat_addr = flat_addr[off:off + aux.shape[0]] + rows, cols = ex.shape[-2:] + for ind, (prc, obc, exc, mac, dic) in enumerate(flat_addr): + dex = aux[ind, :, :] - \ + ob[obc[0], obc[1]:obc[1] + rows, obc[2]:obc[2] + cols] * \ + pr[prc[0], prc[1]:prc[1] + rows, prc[2]:prc[2] + cols] + + ex[exc[0], exc[1]:exc[1] + rows, exc[2]:exc[2] + cols] += dex + aux[ind, :, :] = dex + + def verify_ocl(self, precision=2 ** (-23)): + + for name, val in self.npy.__dict__.items(): + val2 = self.ocl.__dict__[name].get() + val = val + if np.allclose(val, val2, atol=precision): + continue + else: + dev = np.std(val - val2) + mn = np.mean(np.abs(val)) + self.log("Key %s : %.2e std, %.2e mean" % (name, dev, mn)) + + @classmethod + def test(cls, ob_shape=(10, 300, 300), pr_shape=(1, 256, 256)): + + nviews, rows, cols = ob_shape + ex_shape = (nviews,) + pr_shape[-2:] + addr = np.zeros((nviews, 1, 5, 3), dtype=np.int32) + for i in range(nviews): + obc = (0, 2 * i, i) + prc = (0, 0, 0) + exc = (i, 0, 0) + mac = (i, 0, 0) # unimportant + dic = (i, 0, 0) # same here + addr[i, 0, :, :] = np.array([prc, obc, exc, mac, dic], dtype=np.int32) + + ob = np.random.rand(*ob_shape).astype(np.complex64) + pr = np.random.rand(*pr_shape).astype(np.complex64) + ex = np.random.rand(*ex_shape).astype(np.complex64) + + devices = cl.get_platforms()[0].get_devices(cl.device_type.GPU) + queue = cl.CommandQueue(cl.Context([devices[0]]), properties=cl.command_queue_properties.PROFILING_ENABLE) + + inst = cls(queue_thread=queue) + inst.verbose = True + bsize = nviews // 2 + batch = np.zeros((bsize,) + pr_shape[-2:], dtype=np.complex64) + args = (batch, ob, pr, ex, addr) + ocl_args = tuple([cla.to_device(queue, arg) for arg in args]) + inst.configure(ob, addr) + # ns = inst._ocl_build_exit(*ocl_args, batch_offset = 0) + # inst._npy_build_exit(*args, batch_offset = 0) + + # print ns + inst.load(*args) + inst.bath_offset = 3 + inst.execute_ocl(compare=True, sync=False) + + """ + inst.execute_ocl() + g = inst.ocl.f.get() + inst.execute_npy() + f = inst.npy.f + + g = f.copy() + inst.configure(I, mask, g) + err = inst.execute_npy(g) + inst.verify_ocl() + + print('Error : %.2e' % np.std(f-g)) + for key, val in inst.benchmark.items(): + print('Kernel %s : %.2f ms' % (key,val*1000)) + """ + + +class PO_update_kernel(BaseKernel): + + def __init__(self, queue_thread=None): + + super(PO_update_kernel, self).__init__(queue_thread) + + self.prg = cl.Program(self.queue.context, """ + #include + + // Define usable names for buffer access + + #define pr_dlayer(k) addr[k*15] + #define ex_dlayer(k) addr[k*15 + 6] + + #define obj_dlayer(k) addr[k*15 + 3] + #define obj_roi_row(k) addr[k*15 + 4] + #define obj_roi_column(k) addr[k*15 + 5] + + __kernel void ob_update(int pr_sh, + int ob_modes, + int num_pods, + __global cfloat_t *ob_g, + __global cfloat_t *obn_g, + __global cfloat_t *pr_g, + __global cfloat_t *ex_g, + __global int *addr) + { + size_t z = get_global_id(1); + size_t dz = get_global_size(1); + size_t y = get_global_id(0); + size_t dy = get_global_size(0); + __private cfloat_t ob[8]; + __private cfloat_t obn[8]; + + int v1 = 0; + int v2 = 0; + size_t x = y*dz + z; + cfloat_t pr = pr_g[0]; + + for (int i=0;i=0)&&(v1=0)&&(v2=0)&&(v1=0)&&(v2 10).astype(np.float32) + + + devices = cl.get_platforms()[0].get_devices(cl.device_type.GPU) + queue = cl.CommandQueue(cl.Context([devices[0]])) + + inst = Fourier_update_kernel(queue_thread=queue, nmodes = nmodes, pbound = 0.0) + inst.configure(I, mask, f.copy()) + inst.configure_ocl() + + inst2 = Fourier_update_kernel(queue_thread=queue, nmodes = nmodes, pbound = 0.0) + inst2.configure(I, mask, f.copy()) + inst2.configure_ocl() + #err = inst.execute_npy(f) + #gf = cla.to_device(queue,f) + #err_ocl = inst.execute_ocl(gf) + + inst.execute_ocl_auto(True,False) + g = inst.ocl.f.get() + f = inst.npy.f + print np.std(f-g) + """ diff --git a/ptypy/core/classes.py b/ptypy/core/classes.py index f1d912490..aee749811 100644 --- a/ptypy/core/classes.py +++ b/ptypy/core/classes.py @@ -453,7 +453,7 @@ def __init__(self, container, ID=None, data=None, shape=DEFAULT_SHAPE, self.model_initialized = False # MPI flag: is the storage distributed across nodes or are all nodes holding the same copy? - self._update_distributed(self.layermap,[0],[0]) + self._is_scattered = container._is_scattered # Instance attributes # self._psize = None @@ -551,7 +551,10 @@ def update(self): """ # Update the access information for the views # (i.e. pcoord, dlow, dhigh and sp) - self.update_views() + # do this only for the original container + # to avoid iterating through all the views when creating copies + if self.owner.original is self.owner: + self.update_views() def update_views(self, v=None): """ @@ -653,13 +656,16 @@ def reformat(self, newID=None, update=True): if v.layer not in layers: layers.append(v.layer) - # Check if storage is distributed - # A storage is "distributed" if and only if layer maps are different across nodes. + # Check if storage is scattered + # A storage is "scattered" if and only if layer maps are different across nodes. new_layermap = sorted(layers) - self._update_distributed(new_layermap, dlow_fov, dhigh_fov) + # Update boundaries + if not self._is_scattered and u.parallel.MPIenabled: + dlow_fov[:] = u.parallel.comm.allreduce(dlow_fov, u.parallel.MPI.MIN) + dhigh_fov[:] = u.parallel.comm.allreduce(dhigh_fov, u.parallel.MPI.MAX) - # Return if no views, it is important that this only happens after self.distributed is updated + # Return if no views, it is important that this only happens after self._is_scattered is updated if not views: return self @@ -749,21 +755,6 @@ def reformat(self, newID=None, update=True): self.data = new_data self.shape = new_shape self.center = new_center - - def _update_distributed(self, layermap, mn, mx): - self.distributed = False - if u.parallel.MPIenabled: - all_layers = u.parallel.comm.gather(layermap, root=0) - if u.parallel.master: - for other_layers in all_layers[1:]: - self.distributed |= (other_layers != layermap) - self.distributed = u.parallel.comm.bcast(self.distributed, root=0) - # synchronize if not distributed, this ensures the data is of the - # same shape across the nodes - # We could always consider to synchronize - if not self.distributed: - mn[:] = u.parallel.comm.allreduce(mn, u.parallel.MPI.MIN) - mx[:] = u.parallel.comm.allreduce(mx, u.parallel.MPI.MAX) def _to_pix(self, coord): """ @@ -860,7 +851,7 @@ def allreduce(self, op=None): ptypy.utils.parallel.allreduce Container.allreduce """ - if not self.distributed: + if not self._is_scattered: u.parallel.allreduce(self.data, op=op) def zoom_to_psize(self, new_psize, **kwargs): @@ -947,7 +938,7 @@ def report(self): def formatted_report(self, table_format=None, offset=8, align='right', separator=" : ", include_header=True): - """ + r""" Returns formatted string and a dict with the respective information Parameters @@ -1213,7 +1204,7 @@ def __init__(self, container, ID=None, accessrule=None, **kwargs): # Prepare a dictionary for PODs (volatile!) self._pods = None - """ Potential volatile dictionary for all :any:`POD`\ s that + r""" Potential volatile dictionary for all :any:`POD`\ s that connect to this view. Set by :any:`POD` """ # A single pod lookup (weak reference), set by POD instance. @@ -1365,7 +1356,7 @@ def pod(self): @property def pods(self): - """ + r""" Returns all :any:`POD`\ s still connected to this view as a dict. """ if self._pods is not None: @@ -1558,7 +1549,7 @@ class Container(Base): """ _PREFIX = CONTAINER_PREFIX - def __init__(self, owner=None, ID=None, data_type='complex', data_dims=2): + def __init__(self, owner=None, ID=None, data_type='complex', data_dims=2, distribution="cloned"): """ Parameters ---------- @@ -1572,6 +1563,12 @@ def __init__(self, owner=None, ID=None, data_type='complex', data_dims=2): data type - either a numpy.dtype object or 'complex' or 'real' (precision is taken from ptycho.FType or ptycho.CType) + data_dims : int + dimension of data, can be 2 or 3 + + distribution : str + Indicates if the data is "cloned" in all MPI processes or "scattered" + """ super(Container, self).__init__(owner, ID) @@ -1587,6 +1584,9 @@ def __init__(self, owner=None, ID=None, data_type='complex', data_dims=2): # self.original = original if original is not None else self self.original = self + # boolean parameter for distributed containers + self._is_scattered = (distribution == "scattered") + @property def copies(self): """ @@ -1838,7 +1838,7 @@ def report(self): def formatted_report(self, table_format=None, offset=8, align='right', separator=" : ", include_header=True): - """ + r""" Returns formatted string and a dict with the respective information Parameters diff --git a/ptypy/core/data.py b/ptypy/core/data.py index 025bad35f..89b725b80 100644 --- a/ptypy/core/data.py +++ b/ptypy/core/data.py @@ -984,7 +984,7 @@ def _mpi_pipeline_with_dictionaries(self, indices): # (re)distribute position information - every node should now be # aware of all positions - parallel.bcast_dict(pos) + pos = parallel.bcast_dict(pos) # Prepare data across nodes data, weights = self.correct(raw, weights, self.common) @@ -1419,7 +1419,7 @@ def load(self, indices): parallel.barrier() self._ch_frame_ind = parallel.bcast(self._ch_frame_ind) parallel.barrier() - parallel.bcast_dict(self._checked) + self._checked = parallel.bcast_dict(self._checked) # Get the coordinates in the chunks coords = self._ch_frame_ind[indices] @@ -1524,10 +1524,10 @@ def __init__(self, pars=None, **kwargs): geo = geometry.Geo(pars=self.meta) # Derive scan pattern - if p.model is 'raster': + if p.model == 'raster': pos = u.Param() pos.spacing = geo.resolution * geo.shape * p.density - pos.steps = np.int(np.round(np.sqrt(self.num_frames))) + 1 + pos.steps = int(np.round(np.sqrt(self.num_frames))) + 1 pos.extent = pos.steps * pos.spacing pos.model = p.model self.num_frames = pos.steps**2 @@ -1536,7 +1536,7 @@ def __init__(self, pars=None, **kwargs): else: pos = u.Param() pos.spacing = geo.resolution * geo.shape * p.density - pos.steps = np.int(np.round(np.sqrt(self.num_frames) + 1)) + pos.steps = int(np.round(np.sqrt(self.num_frames) + 1)) pos.extent = pos.steps * pos.spacing pos.model = p.model pos.count = self.num_frames @@ -1664,7 +1664,7 @@ def __init__(self, pars=None, **kwargs): # Derive scan pattern pos = u.Param() pos.spacing = geo.resolution * geo.shape * p.density - pos.steps = np.int(np.round(np.sqrt(self.num_frames))) + 1 + pos.steps = int(np.round(np.sqrt(self.num_frames))) + 1 pos.extent = pos.steps * pos.spacing pos.model = 'round' pos.count = self.num_frames diff --git a/ptypy/core/geometry_bragg.py b/ptypy/core/geometry_bragg.py index 262c04dea..5ecc27a79 100644 --- a/ptypy/core/geometry_bragg.py +++ b/ptypy/core/geometry_bragg.py @@ -10,7 +10,7 @@ import numpy as np from scipy.ndimage.interpolation import map_coordinates -__all__ = ['DEFAULT', 'Geo_Bragg'] +__all__ = ['Geo_Bragg'] local_tree = EvalDescriptor('') diff --git a/ptypy/core/illumination.py b/ptypy/core/illumination.py index ce4430400..cb0c7fb15 100644 --- a/ptypy/core/illumination.py +++ b/ptypy/core/illumination.py @@ -253,7 +253,7 @@ def aperture(A, grids=None, pars=None, **kwargs): if p.form is not None: off = u.expect2(p.offset) cgrid = grids[0].astype(complex) + 1j*grids[1] - cgrid -= np.complex(off[0], off[1]) + cgrid -= complex(off[0], off[1]) cgrid *= np.exp(1j * p.rotate) grids[0] = cgrid.real / psize[0] grids[1] = cgrid.imag / psize[1] @@ -594,42 +594,42 @@ def _propagation(prop_pars, shape=None, resolution=None, energy=None, ) -if __name__ == '__main__': - energy = 6. - shape = 512 - resolution = 8e-8 - p = u.Param() - p.aperture = u.Param() - p.aperture.form = 'circ' - p.aperture.diffuser = (10.0, 5, 0.1, 20.0) - p.aperture.size = 100e-6 - # (int) Edge width of aperture in pixel to suppress aliasing - p.aperture.edge = 2 - p.aperture.central_stop = 0.3 - p.aperture.offset = 0. - # (float) rotate aperture by this value - p.aperture.rotate = 0. - # Parameters for propagation after aperture plane - p.propagation = u.Param() - # (float) Parallel propagation distance - p.propagation.parallel = 0.015 - # (float) Propagation distance from aperture to focus - p.propagation.focussed = 0.1 - # (float) Focal spot diameter - p.propagation.spot_size = None - # (float) antialiasing factor - p.propagation.antialiasing = None - # (str) User-defined probe (if type is None) - p.probe = None - # (int, float, None) Number of photons in the incident illumination - p.photons = None - # (float) Noise added on top add the end of initialisation - p.noise = None - - probe = from_pars_no_storage(pars=p, - energy=energy, - shape=shape, - resolution=resolution) - - from matplotlib import pyplot as plt - plt.imshow(u.imsave(abs(probe[0]))) +# if __name__ == '__main__': +# energy = 6. +# shape = 512 +# resolution = 8e-8 +# p = u.Param() +# p.aperture = u.Param() +# p.aperture.form = 'circ' +# p.aperture.diffuser = (10.0, 5, 0.1, 20.0) +# p.aperture.size = 100e-6 +# # (int) Edge width of aperture in pixel to suppress aliasing +# p.aperture.edge = 2 +# p.aperture.central_stop = 0.3 +# p.aperture.offset = 0. +# # (float) rotate aperture by this value +# p.aperture.rotate = 0. +# # Parameters for propagation after aperture plane +# p.propagation = u.Param() +# # (float) Parallel propagation distance +# p.propagation.parallel = 0.015 +# # (float) Propagation distance from aperture to focus +# p.propagation.focussed = 0.1 +# # (float) Focal spot diameter +# p.propagation.spot_size = None +# # (float) antialiasing factor +# p.propagation.antialiasing = None +# # (str) User-defined probe (if type is None) +# p.probe = None +# # (int, float, None) Number of photons in the incident illumination +# p.photons = None +# # (float) Noise added on top add the end of initialisation +# p.noise = None + +# probe = from_pars_no_storage(pars=p, +# energy=energy, +# shape=shape, +# resolution=resolution) + +# from matplotlib import pyplot as plt +# plt.imshow(u.imsave(abs(probe[0]))) diff --git a/ptypy/core/manager.py b/ptypy/core/manager.py index 96189d17b..8acbc7b86 100644 --- a/ptypy/core/manager.py +++ b/ptypy/core/manager.py @@ -23,6 +23,7 @@ from .. import utils as u from ..utils.verbose import logger, headerline, log +from ..utils.verbose import ilog_message, ilog_streamer, ilog_newline from .classes import * from .classes import DEFAULT_ACCESSRULE from .classes import MODEL_PREFIX @@ -43,7 +44,7 @@ def __init__(self): self._t = time.time() def __call__(self, msg=None): - logger.warning('Duration %.2f for ' % (time.time() - self._t) + str(msg)) + logger.info('Duration %.2f for ' % (time.time() - self._t) + str(msg)) self._t = time.time() @@ -151,6 +152,14 @@ def __init__(self, ptycho=None, pars=None, label=None): self.CType = CType self.FType = FType + # Keep track of the maximum frames in a block + # For the ScanModel this will be equivalent to the total nr. of frames in the scan + # For the BlockScanModel this is defined by the user (frames_per_block) and the MPI settings + self.max_frames_per_block = 0 + + # By default we create a new exit buffer for each view + self._single_exit_buffer_for_all_views = False + @classmethod def makePtyScan(cls, pars): """ @@ -325,6 +334,9 @@ def new_data(self, max_frames): self.diff.data[self.diff.layermap.index(idx)][:] = diff_data self.mask.data[self.mask.layermap.index(idx)][:] = dct.get('mask', np.ones_like(diff_data)) + # Update maximum nr. of frames in a block + self.max_frames_per_block = self.diff.nlayers + self.diff.nlayers = parallel.MPImax(self.diff.layermap) + 1 self.mask.nlayers = parallel.MPImax(self.mask.layermap) + 1 @@ -537,6 +549,7 @@ def new_data(self, max_frames): fill=0.0, layermap=indices_node) mask = self.Cmask.new_storage(shape=sh, psize=self.psize, padonly=True, fill=1.0, layermap=indices_node) + # Prepare for View generation AR_diff = DEFAULT_ACCESSRULE.copy() AR_diff.shape = self.diff_shape # this is None due to init @@ -589,6 +602,9 @@ def new_data(self, max_frames): ## warning message for empty postions? + # Update maximum nr. of frames in a block + self.max_frames_per_block = max(diff.nlayers, self.max_frames_per_block) + # this is not absolutely necessary # diff.update_views() # mask.update_views() @@ -930,7 +946,11 @@ def _create_pods(self): for i in range(len(self.new_diff_views)): dv, mv = self.new_diff_views.pop(0), self.new_mask_views.pop(0) - index = dv.layer + # For stochastic engines (e.g. ePIE) we only need one exit buffer + if self._single_exit_buffer_for_all_views: + index = 0 + else: + index = dv.layer # Object and probe position pos_pr = u.expect2(0.0) @@ -1228,6 +1248,18 @@ class OPRModel(_OPRModel, Full): class BlockOPRModel(_OPRModel, BlockFull): pass +@defaults_tree.parse_doc('scan.GradFull') +class GradFull(Full): + def __init__(self, ptycho=None, pars=None, label=None): + super(GradFull, self).__init__(ptycho, pars, label) + self._single_exit_buffer_for_all_views = True + +@defaults_tree.parse_doc('scan.BlockGradFull') +class BlockGradFull(BlockFull): + def __init__(self, ptycho=None, pars=None, label=None): + super(BlockGradFull, self).__init__(ptycho, pars, label) + self._single_exit_buffer_for_all_views = True + # Append illumination and sample defaults defaults_tree['scan.Full'].add_child(illumination.illumination_desc) defaults_tree['scan.BlockFull'].add_child(illumination.illumination_desc) @@ -1618,14 +1650,16 @@ def new_data(self): logger.info('Processing new data.') - # Attempt to get new data - _nframes = self.ptycho.frames_per_block + # making sure frames_per_block is defined per rank + _nframes = self.ptycho.frames_per_block * parallel.size + # Attempt to get new data new_data = [] for label, scan in self.scans.items(): if not scan.data_available: continue else: + ilog_streamer('%s: loading data for scan %s' %(type(scan).__name__,label)) prb_ids, obj_ids, pod_ids = dict(), dict(), set() nd = scan.new_data(_nframes) while nd: @@ -1633,14 +1667,19 @@ def new_data(self): prb_ids.update(nd[1]) obj_ids.update(nd[2]) pod_ids = pod_ids.union(nd[3]) + ilog_streamer('%s: loading data for scan %s (%d diffraction frames, %d PODs, %d probe(s) and %d object(s))' + %(type(scan).__name__,label, sum([d.shape[0] if l==label else 0 for l,d in new_data]), len(pod_ids), len(prb_ids), len(obj_ids))) nd = scan.new_data(_nframes) + ilog_newline() # Reformatting + ilog_message('%s: loading data for scan %s (reformatting probe/obj/exit)' %(type(scan).__name__,label)) self.ptycho.probe.reformat(True) self.ptycho.obj.reformat(True) self.ptycho.exit.reformat(True) # Initialize probe/object/exit + ilog_message('%s: loading data for scan %s (initializing probe/obj/exit)' %(type(scan).__name__,label)) scan._initialize_probe(prb_ids) scan._initialize_object(obj_ids) scan._initialize_exit(list(pod_ids)) diff --git a/ptypy/core/ptycho.py b/ptypy/core/ptycho.py index a7c54594d..0cd49405c 100644 --- a/ptypy/core/ptycho.py +++ b/ptypy/core/ptycho.py @@ -9,11 +9,13 @@ """ import numpy as np import time +import json from . import paths from collections import OrderedDict from .. import utils as u -from ..utils.verbose import logger, _, report, headerline, log +from ..utils.verbose import logger, _, report, headerline, log, LogTime +from ..utils.verbose import ilog_message, ilog_streamer, ilog_newline from ..utils import parallel from .. import engines from .classes import Base, Container, Storage, PTYCHO_PREFIX @@ -70,19 +72,17 @@ class Ptycho(Base): Defaults: [verbose_level] - default = 1 + default = 'ERROR' help = Verbosity level doc = Verbosity level for information logging. - - ``0``: Only critical errors - - ``1``: All errors - - ``2``: Warning - - ``3``: Process Information - - ``4``: Object Information - - ``5``: Debug - type = int + - ``CRITICAL``: Only critical errors + - ``ERROR``: All errors + - ``WARNING``: Warning + - ``INFO``: Process Information + - ``INSPECT``: Object Information + - ``DEBUG``: Debug + type = str, int userlevel = 0 - lowlim = 0 - uplim = 5 [data_type] default = 'single' @@ -142,6 +142,15 @@ class Ptycho(Base): help = Reconstruction file name (or format string) doc = Reconstruction file name or format string (constructed against runtime dictionary) + [io.rformat] + default = "minimal" + type = str + help = Reconstruction file format + doc = Choose a reconstruction file format for after engine completion. + - ``'minimal'``: Bare minimum of information + - ``'dls'``: Custom format for Diamond Light Source + choices = 'minimal','dls' + [io.interaction] default = None type = Param @@ -248,6 +257,14 @@ class Ptycho(Base): doc = Switch to request the production of a movie from the dumped plots at the end of the reconstruction. + [io.benchmark] + default = None + type = str + help = Produce timings for benchmarking the performance of data loaders and engines + doc = Switch to get timings and save results to a json file in p.io.home + Choose ``'all'`` for timing data loading, engine_init, engine_prepare, engine_iterate and engine_finalize + userlevel = 2 + [scans] default = None type = Param @@ -332,6 +349,7 @@ def __init__(self, pars=None, level=2, **kwargs): # Communication self.interactor = None self.plotter = None + self.record_positions = False # Early boot strapping self._configure() @@ -389,9 +407,9 @@ def _configure(self): self.data_type = p.data_type assert p.data_type in ['single', 'double'] self.FType = np.dtype( - 'f' + str(np.dtype(np.typeDict[p.data_type]).itemsize)).type + 'f' + str(np.dtype(np.sctypeDict[p.data_type]).itemsize)).type self.CType = np.dtype( - 'c' + str(2 * np.dtype(np.typeDict[p.data_type]).itemsize)).type + 'c' + str(2 * np.dtype(np.sctypeDict[p.data_type]).itemsize)).type logger.info(_('Data type', self.data_type)) # Check if there is already a runtime container if not hasattr(self, 'runtime'): @@ -414,6 +432,15 @@ def _configure(self): # Find run name self.runtime.run = self.paths.run(p.run) + # Benchmark + if self.p.io.benchmark == 'all': + self.benchmark = u.Param() + self.benchmark.data_load = 0 + self.benchmark.engine_init = 0 + self.benchmark.engine_prepare = 0 + self.benchmark.engine_iterate = 0 + self.benchmark.engine_finalize = 0 + def init_communication(self): """ Called on __init__ if ``level >= 3``. @@ -479,9 +506,9 @@ def init_structures(self): """ self.probe = Container(self, ID='Cprobe', data_type='complex') self.obj = Container(self, ID='Cobj', data_type='complex') - self.exit = Container(self, ID='Cexit', data_type='complex') - self.diff = Container(self, ID='Cdiff', data_type='real') - self.mask = Container(self, ID='Cmask', data_type='bool') + self.exit = Container(self, ID='Cexit', data_type='complex', distribution="scattered") + self.diff = Container(self, ID='Cdiff', data_type='real', distribution="scattered") + self.mask = Container(self, ID='Cmask', data_type='bool', distribution="scattered") # Initialize the model manager. This also initializes the # containers. self.model = ModelManager(self, self.p.scans) @@ -495,7 +522,9 @@ def init_data(self, print_stats=True): """ # Load the data. This call creates automatically the scan managers, # which create the views and the PODs. Sets self.new_data - self.new_data = self.model.new_data() + with LogTime(self.p.io.benchmark == 'all') as t: + self.new_data = self.model.new_data() + if (self.p.io.benchmark == 'all') and parallel.master: self.benchmark.data_load += t.duration # Print stats parallel.barrier() @@ -614,13 +643,20 @@ def run(self, label=None, epars=None, engine=None): self.runtime.last_plot = 0 # Prepare the engine - engine.initialize() + ilog_message('%s: initializing engine' %engine.p.name) + with LogTime(self.p.io.benchmark == 'all') as t: + engine.initialize() + if (self.p.io.benchmark == 'all') and parallel.master: self.benchmark.engine_init += t.duration # One .prepare() is always executed, as Ptycho may hold data + ilog_message('%s: preparing engine' %engine.p.name) self.new_data = [(d.label, d) for d in self.diff.S.values()] - engine.prepare() + with LogTime(self.p.io.benchmark == 'all') as t: + engine.prepare() + if (self.p.io.benchmark == 'all') and parallel.master: self.benchmark.engine_prepare += t.duration # Start the iteration loop + ilog_streamer('%s: starting engine' %engine.p.name) while not engine.finished: # Check for client requests if parallel.master and self.interactor is not None: @@ -629,12 +665,16 @@ def run(self, label=None, epars=None, engine=None): parallel.barrier() # Check for new data - self.new_data = self.model.new_data() + with LogTime(self.p.io.benchmark == 'all') as t: + self.new_data = self.model.new_data() + if (self.p.io.benchmark == 'all') and parallel.master: self.benchmark.data_load += t.duration # Last minute preparation before a contiguous block of # iterations if self.new_data: - engine.prepare() + with LogTime(self.p.io.benchmark == 'all') as t: + engine.prepare() + if (self.p.io.benchmark == 'all') and parallel.master: self.benchmark.engine_prepare += t.duration auto_save = self.p.io.autosave if auto_save.active and auto_save.interval > 0: @@ -646,7 +686,9 @@ def run(self, label=None, epars=None, engine=None): logger.info(headerline()) # One iteration - engine.iterate() + with LogTime(self.p.io.benchmark == 'all') as t: + engine.iterate() + if (self.p.io.benchmark == 'all') and parallel.master: self.benchmark.engine_iterate += t.duration # Display runtime information and do saving if parallel.master: @@ -658,20 +700,35 @@ def run(self, label=None, epars=None, engine=None): 'Time %(duration).3f' % info) logger.info('Errors :: Fourier %.2e, Photons %.2e, ' 'Exit %.2e' % tuple(err)) + ilog_streamer('%(engine)s: Iteration # %(iteration)d/%(numiter)d :: ' %info + + 'Fourier %.2e, Photons %.2e, Exit %.2e' %tuple(err)) parallel.barrier() + ilog_newline() + # Done. Let the engine finish up - engine.finalize() + with LogTime(self.p.io.benchmark == 'all') as t: + engine.finalize() + if (self.p.io.benchmark == 'all') and parallel.master: self.benchmark.engine_finalize += t.duration # Save if self.p.io.rfile: - self.save_run() + self.save_run(kind=self.p.io.rformat) else: pass # Time the initialization self.runtime.stop = time.asctime() + # Save benchmarks to json file + if (self.p.io.benchmark == 'all') and parallel.master: + try: + with open(self.paths.home + "/benchmark.json", "w") as json_file: + json.dump(self.benchmark, json_file) + logger.info("Benchmarks have been written to %s" %self.paths.home + "/benchmark.json") + except Exception as e: + logger.warning("Failed to write benchmarks to file: %s" %e) + elif epars is not None: # A fresh set of engine parameters arrived. label = self.init_engine(epars=epars) @@ -719,7 +776,7 @@ def finalize(self): citation_info = '\n'.join([headerline('This reconstruction relied on the following work', 'l', '='), str(self.citations), headerline('', 'l', '=')]) - logger.warning(citation_info) + log("CITATION", citation_info) @classmethod def _from_dict(cls, dct): @@ -759,7 +816,7 @@ def load_run(cls, runfile, load_data=True): logger.info('Creating Ptycho instance from %s' % runfile) header = u.Param(io.h5read(runfile, 'header')['header']) - if header['kind'] == 'minimal': + if header['kind'] == 'minimal' or header['kind'] == 'dls': logger.info('Found minimal ptypy dump') content = io.h5read(runfile, 'content')['content'] @@ -904,7 +961,7 @@ def save_run(self, alt_file=None, kind='minimal', force_overwrite=True): content = dump - elif kind == 'minimal': + elif kind == 'minimal' or kind == 'dls': # if self.interactor is not None: # self.interactor.stop() logger.info('Generating shallow copies of probe, object and ' @@ -912,17 +969,9 @@ def save_run(self, alt_file=None, kind='minimal', force_overwrite=True): minimal = u.Param() minimal.probe = {ID: S._to_dict() for ID, S in self.probe.storages.items()} - for ID, S in self.probe.storages.items(): - minimal.probe[ID]['grids'] = S.grids() minimal.obj = {ID: S._to_dict() for ID, S in self.obj.storages.items()} - - minimal.positions = {} - for ID, S in self.obj.storages.items(): - minimal.obj[ID]['grids'] = S.grids() - minimal.positions[ID] = np.array([v.coord for v in S.views if v.pod.pr_view.layer==0]) - try: defaults_tree['ptycho'].validate(self.p) # check the parameters are actually able to be read back in except RuntimeError: @@ -931,6 +980,20 @@ def save_run(self, alt_file=None, kind='minimal', force_overwrite=True): minimal.runtime = self.runtime.copy() content = minimal + else: + raise RuntimeError("Save file format '" + str(kind) + "' is not supported") + + if kind == 'dls': + for ID, S in self.probe.storages.items(): + content.probe[ID]['grids'] = S.grids() + + for ID, S in self.obj.storages.items(): + content.obj[ID]['grids'] = S.grids() + + if kind in ['minimal', 'dls'] and self.record_positions: + content.positions = {} + for ID, S in self.obj.storages.items(): + content.positions[ID] = np.array([v.coord for v in S.views if v.pod.pr_view.layer==0]) h5opt = io.h5options['UNSUPPORTED'] io.h5options['UNSUPPORTED'] = 'ignore' diff --git a/ptypy/core/sample.py b/ptypy/core/sample.py index d58228c45..a2577bfd9 100644 --- a/ptypy/core/sample.py +++ b/ptypy/core/sample.py @@ -238,7 +238,7 @@ def init_storage(storage, sample_pars=None, energy=None): elif type(p.model) is np.ndarray: model = p.model elif p.model in resources.objects: - model = resources.objects[p.model](A.shape) + model = resources.objects[p.model](s.shape) elif str(p.model) == 'recon': # Loading from a reconstruction file layer = p.recon.get('layer') @@ -438,104 +438,3 @@ def simulate(A, pars, energy, fill=1.0, prefix="", **kwargs): # more modes requested than weight given mode_weights=[1., 0.1] ) - - -def from_pars_old(shape, lam, pars=None, dtype=np.complex): - """ - *DEPRECATED* - """ - p = u.Param(DEFAULT) - if pars is not None and (isinstance(pars, dict) - or isinstance(pars, u.Param)): - p.update(pars) - if p.obj is not None: - # Abort here if object is set - return p - else: - if isinstance(p.source, np.ndarray): - logger.info('Found nd-array') - obj = p.source - else: - logger.info('Fill with ones!') - obj = np.ones(shape) - - obj = obj.astype(dtype) - - off = u.expect2(p.offset) - - if p.zoom is not None: - obj = u.zoom(obj, p.zoom) - - if p.smoothing_mfs is not None: - obj = u.gf(obj, p.smoothing_mfs / 2.35) - - k = 2 * np.pi / lam - ri = p.ref_index - if p.formula is not None or ri is not None: - # use only magnitude of obj and scale to [0 1] - if ri is None: - en = u.keV2m(1e-3)/lam - if u.parallel.master: - logger.info( - 'Queuing cxro database for refractive index in object ' - 'creation with parameters:\n' - 'Formula=%s Energy=%d Density=%.2f' - % (p.formula, en, p.density)) - result = np.array(iofr(p.formula, en, density=p.density)) - else: - result = None - result = u.parallel.bcast(result) - energy, delta, beta = result - ri = - delta + 1j*beta - else: - logger.info("using given refractive index in object creation") - - ob = np.abs(obj).astype(np.float) - ob -= ob.min() - if p.thickness is not None: - ob /= ob.max() / p.thickness - - obj = np.exp(1.j * ob * k * ri) - - shape = u.expect2(shape) - crops = list(-np.array(obj.shape) + shape + 2*np.abs(off)) - obj = u.crop_pad(obj, crops, fillpar=p.fill) - - if p.noise_rms is not None: - n = u.expect2(p.noise_rms) - noise = np.random.normal(1.0, n[0] + 1e-10, obj.shape) * np.exp( - 2j * np.pi * np.random.normal(0.0, n[1] + 1e-10, obj.shape)) - if p.noise_mfs is not None: - noise = u.gf(noise, p.noise_mfs / 2.35) - obj *= noise - - off += np.abs(off) - p.obj = obj[off[0]:off[0]+shape[0], off[1]:off[1]+shape[1]] - - return p - - -def _create_modes(layers, pars): - """ - **DEPRECATED** - """ - p = u.Param(pars) - pr = p.obj - sh_old = pr.shape - if pr.ndim == 2: - ppr = np.zeros((1,) + pr.shape).astype(pr.dtype) - ppr[0] = pr - pr = ppr - elif pr.ndim == 4: - pr = pr[0] - w = p.mode_weights - # press w into 1d flattened array: - w = np.atleast_1d(w).flatten() - w = u.crop_pad(w, [[0, layers-w.shape[0]]], filltype='project') - w /= w.sum() - # make it an array now: flattens - pr = u.crop_pad(pr, [[0, layers-pr.shape[0]]], axes=[0], filltype='project') - # if p.mode_diversity =='noise' - p.mode_weights = w - p.obj = pr * w.reshape((layers, 1, 1)) - return p diff --git a/ptypy/core/xy.py b/ptypy/core/xy.py index 98b531f43..9661b2c0c 100644 --- a/ptypy/core/xy.py +++ b/ptypy/core/xy.py @@ -86,11 +86,11 @@ def from_pars(xypars=None): return None elif str(xypars) == xypars: if xypars in TEMPLATES.keys(): - return from_pars(TEMPLATES[sam]) + return from_pars(TEMPLATES[xypars]) else: raise RuntimeError( 'Template string `%s` for pattern creation is not understood' - % sam) + % xypars) elif type(xypars) in [np.ndarray, list]: return np.array(xypars) else: diff --git a/ptypy/engines/DMOPR.py b/ptypy/custom/DMOPR.py similarity index 94% rename from ptypy/engines/DMOPR.py rename to ptypy/custom/DMOPR.py index 0467cbaef..706198fb4 100644 --- a/ptypy/engines/DMOPR.py +++ b/ptypy/custom/DMOPR.py @@ -9,13 +9,12 @@ :license: GPLv2, see LICENSE for details. """ import numpy as np -from .. import utils as u -from ..utils.verbose import logger -from ..utils import parallel -from .utils import reduce_dimension -from . import register -from .DM import DM -from ..core.manager import OPRModel +from ptypy import utils as u +from ptypy.utils import parallel +from ptypy.engines.utils import reduce_dimension +from ptypy.engines import register +from ptypy.engines.projectional import DM +from ptypy.core.manager import OPRModel __all__ = ['DMOPR'] diff --git a/ptypy/custom/DM_object_regul.py b/ptypy/custom/DM_object_regul.py new file mode 100644 index 000000000..5895a5e9f --- /dev/null +++ b/ptypy/custom/DM_object_regul.py @@ -0,0 +1,66 @@ +# -*- coding: utf-8 -*- +""" +An extension plugin of the Difference Map engine +with object regularisation for air/vacuum regions. + +authors: Benedikt J. Daurer +""" +from ptypy.engines import projectional +from ptypy.engines import register +import numpy as np + +@register() +class DM_object_regul(projectional.DM): + """ + An extension of DM with the following additional parameters + + Defaults: + + [object_regul_mask] + default = None + type = ndarray + help = A mask used for regularisation of the object + doc = Numpy.ndarray with same shape as the object that will be casted to a boolean mask + + [object_regul_fill] + default = 0.0 + 0.0j + type = float, complex + help = Fill value for regularisation of the object + doc = Providing a complex number, e.g. 1.0 + 0.1j will replace both real and imaginary parts\ + Providing a floating number, e.g. 0.5 will replace only the phase + + [object_regul_start] + default = None + type = int + help = Number of iterations until object regularisation starts + doc = If None, object regularisation starts at first iteration + + [object_regul_stop] + default = None + type = int + help = Number of iterations after which object regularisation stops + doc = If None, object regularisation stops after last iteration + + """ + + def __init__(self, ptycho_parent, pars=None): + super(DM_object_regul, self).__init__(ptycho_parent, pars) + + def object_update(self): + """ + Replace values inside mask with given fill value. + """ + super().object_update() + do_regul = True + if (self.p.object_regul_start is not None): + do_regul &= (self.curiter >= self.p.object_regul_start) + if (self.p.object_regul_stop is not None): + do_regul &= (self.curiter < self.p.object_regul_stop) + + if (self.p.object_regul_mask is not None) and do_regul: + for name, s in self.ob.storages.items(): + assert s.shape == self.p.object_regul_mask.shape, "Object regulariser mask needs to have same shape as object = {}".format(s.shape) + if isinstance(self.p.object_regul_fill, complex): + s.data[self.p.object_regul_mask.astype(bool)] = self.p.object_regul_fill + elif isinstance(self.p.object_regul_fill, float): + s.data[self.p.object_regul_mask.astype(bool)] = np.abs(s.data[self.p.object_regul_mask.astype(bool)]) * np.exp(1j*self.p.object_regul_fill) diff --git a/ptypy/custom/DM_pycuda_object_regul.py b/ptypy/custom/DM_pycuda_object_regul.py new file mode 100644 index 000000000..124231629 --- /dev/null +++ b/ptypy/custom/DM_pycuda_object_regul.py @@ -0,0 +1,83 @@ +# -*- coding: utf-8 -*- +""" +An extension plugin of the accelerated (pycuda) Difference Map engine +with object regularisation for air/vacuum regions. + +authors: Benedikt J. Daurer +""" +from ptypy.accelerate.cuda_pycuda.engines import projectional_pycuda +from ptypy.engines import register +from pycuda import gpuarray +import numpy as np + +@register() +class DM_pycuda_object_regul(projectional_pycuda.DM_pycuda): + """ + An extension of DM_pycuda with the following additional parameters + + Defaults: + + [object_regul_mask] + default = None + type = ndarray + help = A mask used for regularisation of the object + doc = Numpy.ndarray with same shape as the object that will be casted to a complex-valued mask + + [object_regul_fill] + default = 0.0 + 0.0j + type = float, complex + help = Fill value for regularisation of the object + doc = Providing a complex number, e.g. 1.0 + 0.1j will replace both real and imaginary parts\ + Providing a floating number, e.g. 0.5 will replace only the phase + + [object_regul_start] + default = None + type = int + help = Number of iterations until object regularisation starts + doc = If None, object regularisation starts at first iteration + + [object_regul_stop] + default = None + type = int + help = Number of iterations after which object regularisation stops + doc = If None, object regularisation stops after last iteration + + """ + + def __init__(self, ptycho_parent, pars=None): + super(DM_pycuda_object_regul, self).__init__(ptycho_parent, pars) + + def engine_prepare(self): + super().engine_prepare() + if self.p.object_regul_mask is not None: + self.object_mask_gpu = gpuarray.to_gpu(self.p.object_regul_mask.astype(np.complex64)) + + def _setup_kernels(self): + super()._setup_kernels() + from pycuda.elementwise import ElementwiseKernel + self.obj_regul_complex = ElementwiseKernel( + "pycuda::complex *in, pycuda::complex *mask, pycuda::complex fill", + "in[i] = fill*mask[i] + in[i]*(pycuda::complex(1) - mask[i])", + "obj_regulariser_complex") + self.obj_regul_phase = ElementwiseKernel( + "pycuda::complex *in, pycuda::complex *mask, float fill", + "in[i] = pycuda::abs(in[i])*mask[i]*pycuda::exp(fill*pycuda::complex(1)) + in[i]*(pycuda::complex(1) - mask[i])", + "obj_regulariser_phase") + + def object_update(self,*args, **kwargs): + """ + Replace values inside mask with given fill value. + """ + super().object_update(*args,**kwargs) + do_regul = True + if (self.p.object_regul_start is not None): + do_regul &= (self.curiter >= self.p.object_regul_start) + if (self.p.object_regul_stop is not None): + do_regul &= (self.curiter < self.p.object_regul_stop) + if (self.p.object_regul_mask is not None) and do_regul: + for oID, ob in self.ob.storages.items(): + assert ob.shape == self.object_mask_gpu.shape, "Object regulariser mask needs to have same shape as object = {}".format(ob.shape) + if isinstance(self.p.object_regul_fill, complex): + self.obj_regul_complex(ob.gpu, self.object_mask_gpu, self.p.object_regul_fill) + elif isinstance(self.p.object_regul_fill, float): + self.obj_regul_phase(ob.gpu, self.object_mask_gpu, self.p.object_regul_fill) diff --git a/ptypy/engines/MLOPR.py b/ptypy/custom/MLOPR.py similarity index 92% rename from ptypy/engines/MLOPR.py rename to ptypy/custom/MLOPR.py index 15f479fb4..000bb73bf 100644 --- a/ptypy/engines/MLOPR.py +++ b/ptypy/custom/MLOPR.py @@ -12,13 +12,13 @@ """ import numpy as np import time -from .. import utils as u -from ..utils.verbose import logger -from ..utils import parallel -from .utils import reduce_dimension -from . import register -from .ML import ML -from ..core.manager import OPRModel +from ptypy import utils as u +from ptypy.utils.verbose import logger +from ptypy.utils import parallel +from ptypy.engines.utils import reduce_dimension +from ptypy.engines import register +from ptypy.engines.ML import ML +from ptypy.core.manager import OPRModel __all__ = ['MLOPR'] diff --git a/ptypy/custom/__init__.py b/ptypy/custom/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/ptypy/engines/ePIE.py b/ptypy/custom/ePIE_parallel.py similarity index 93% rename from ptypy/engines/ePIE.py rename to ptypy/custom/ePIE_parallel.py index 5a34e9e59..1fb3754d5 100644 --- a/ptypy/engines/ePIE.py +++ b/ptypy/custom/ePIE_parallel.py @@ -26,26 +26,25 @@ import time import random -from .. import utils as u -from ..utils.verbose import logger -from ..utils import parallel -from . import BaseEngine, register -from .. import defaults_tree -from ..core.manager import Full, Vanilla +from ptypy import utils as u +from ptypy.utils.verbose import logger +from ptypy.utils import parallel +from ptypy.engines import BaseEngine, register +from ptypy.core.manager import Full, Vanilla -__all__ = ['EPIE'] +__all__ = ['EPIEParallel'] -@register(name = 'ePIE') -class EPIE(BaseEngine): +@register(name = 'ePIEparallel') +class EPIEParallel(BaseEngine): """ - ePIE reconstruction engine. + Parallel ePIE reconstruction engine. Defaults: [name] - default = ePIE + default = ePIEparallel type = str help = doc = @@ -128,7 +127,7 @@ def __init__(self, ptycho_parent, pars=None): """ ePIE reconstruction engine. """ - super(EPIE, self).__init__(ptycho_parent, pars) + super().__init__(ptycho_parent, pars) p = self.DEFAULT.copy() if pars is not None: @@ -144,7 +143,7 @@ def __init__(self, ptycho_parent, pars=None): # Instance attributes self.ob_nodecover = None self.mean_power = None - + self.ptycho.citations.add_article( title='An improved ptychographical phase retrieval algorithm for diffractive imaging', author='Maiden A. and Rodenburg J.', @@ -191,7 +190,7 @@ def engine_prepare(self): mean_power += s.mean_power self.mean_power = mean_power / len(self.di.storages) - + # DEBUGGING: show the actual domain decomposition # if self.curiter == 0: # import matplotlib.pyplot as plt @@ -264,7 +263,7 @@ def engine_iterate(self, num=1): # scale probe such that its mean power equals the mean power of the diffraction data # This stabilizes the ePIE algorithm and prevents the probe from growing too large. pod.probe *= np.sqrt(self.mean_power / u.abs2(pod.probe).mean()) - + # Object update: logger.debug(pre_str + '----- ePIE object update -----') pod.object += (self.p.alpha @@ -342,8 +341,7 @@ def engine_iterate(self, num=1): # and that Ptycho expects. In DM, that dict is overwritten on # every iteration, so we only gather the dicts corresponding to # the last iteration of each contiguous block. - error = parallel.gather_dict(error_dct) - return error + return error_dct def engine_finalize(self): """ @@ -468,14 +466,25 @@ def center_probe(self): Stolen in its entirety from the DM engine. """ if self.p.probe_center_tol is not None: - for name, s in self.pr.S.items(): - c1 = u.mass_center(u.abs2(s.data).sum(0)) + for name, pr_s in self.pr.storages.items(): + c1 = u.mass_center(u.abs2(pr_s.data).sum(0)) + c2 = np.asarray(pr_s.shape[-2:]) // 2 # fft convention should however use geometry instead - c2 = np.asarray(s.shape[-2:]) // 2 if u.norm(c1 - c2) < self.p.probe_center_tol: break # SC: possible BUG here, wrong input parameter - s.data[:] = u.shift_zoom( - s.data, (1.,) * 3, (0, c1[0], c1[1]), (0, c2[0], c2[1])) + pr_s.data[:] = u.shift_zoom(pr_s.data, (1.,)*3, + (0, c1[0], c1[1]), (0, c2[0], c2[1])) + + # shift the object + ob_s = pr_s.views[0].pod.ob_view.storage + ob_s.data[:] = u.shift_zoom(ob_s.data, (1.,)*3, + (0, c1[0], c1[1]), (0, c2[0], c2[1])) + + # shift the exit waves, loop through different exit wave views + for pv in pr_s.views: + pv.pod.exit = u.shift_zoom(pv.pod.exit, (1.,)*2, + (c1[0], c1[1]), (c2[0], c2[1])) + logger.info('Probe recentered from %s to %s' % (str(tuple(c1)), str(tuple(c2)))) diff --git a/ptypy/engines/Bragg3d_engines.py b/ptypy/engines/Bragg3d_engines.py index 2314eccab..87ecfe519 100644 --- a/ptypy/engines/Bragg3d_engines.py +++ b/ptypy/engines/Bragg3d_engines.py @@ -7,7 +7,7 @@ :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. :license: GPLv2, see LICENSE for details. """ -from .DM import DM +from .projectional import DM from . import register from ..core.manager import Bragg3dModel from ..utils import parallel diff --git a/ptypy/engines/ML.py b/ptypy/engines/ML.py index 54f4e9e64..cf38c12a1 100644 --- a/ptypy/engines/ML.py +++ b/ptypy/engines/ML.py @@ -19,9 +19,9 @@ from ..utils import parallel from .utils import Cnorm2, Cdot from . import register -from .base import PositionCorrectionEngine -from .. import defaults_tree -from ..core.manager import Full, Vanilla, Bragg3dModel, BlockVanilla, BlockFull +from .base import BaseEngine, PositionCorrectionEngine +from ..core.manager import Full, Vanilla, Bragg3dModel, BlockVanilla, BlockFull, GradFull, BlockGradFull + __all__ = ['ML'] @@ -99,10 +99,10 @@ class ML(PositionCorrectionEngine): type = int lowlim = 0 help = Number of iterations before probe update starts - + """ - SUPPORTED_MODELS = [Full, Vanilla, Bragg3dModel, BlockVanilla, BlockFull] + SUPPORTED_MODELS = [Full, Vanilla, Bragg3dModel, BlockVanilla, BlockFull, GradFull, BlockGradFull] def __init__(self, ptycho_parent, pars=None): """ @@ -153,9 +153,9 @@ def __init__(self, ptycho_parent, pars=None): def engine_initialize(self): """ Prepare for ML reconstruction. - """ + """ super(ML, self).engine_initialize() - + # Object gradient and minimization direction self.ob_grad = self.ob.copy(self.ob.ID + '_grad', fill=0.) self.ob_grad_new = self.ob.copy(self.ob.ID + '_grad_new', fill=0.) @@ -233,9 +233,10 @@ def engine_iterate(self, num=1): # probe/object rescaling if self.p.scale_precond: cn2_new_pr_grad = Cnorm2(new_pr_grad) + cn2_new_ob_grad = Cnorm2(new_ob_grad) if cn2_new_pr_grad > 1e-5: - scale_p_o = (self.p.scale_probe_object * Cnorm2(new_ob_grad) - / Cnorm2(new_pr_grad)) + scale_p_o = (self.p.scale_probe_object * cn2_new_ob_grad + / cn2_new_pr_grad) else: scale_p_o = self.p.scale_probe_object if self.scale_p_o is None: @@ -263,11 +264,12 @@ def engine_iterate(self, num=1): bt = max(0, bt_num/bt_denom) - # verbose(3,'Polak-Ribiere coefficient: %f ' % bt) + # logger.info('Polak-Ribiere coefficient: %f ' % bt) self.ob_grad << new_ob_grad self.pr_grad << new_pr_grad + dt = self.ptycho.FType # 3. Next conjugate self.ob_h *= bt / self.tmin @@ -277,6 +279,7 @@ def engine_iterate(self, num=1): s.data[:] -= self.smooth_gradient(self.ob_grad.storages[name].data) else: self.ob_h -= self.ob_grad + self.pr_h *= bt / self.tmin self.pr_grad *= self.scale_p_o self.pr_h -= self.pr_grad @@ -286,20 +289,23 @@ def engine_iterate(self, num=1): t2 = time.time() B = self.ML_model.poly_line_coeffs(self.ob_h, self.pr_h) tc += time.time() - t2 - #print(B, Cnorm2(self.ob_h), Cnorm2(self.ob_grad), Cnorm2(self.pr_h), Cnorm2(self.pr_grad)) + if np.isinf(B).any() or np.isnan(B).any(): logger.warning( 'Warning! inf or nan found! Trying to continue...') B[np.isinf(B)] = 0. B[np.isnan(B)] = 0. - self.tmin = -.5 * B[1] / B[2] + self.tmin = dt(-.5 * B[1] / B[2]) self.ob_h *= self.tmin self.pr_h *= self.tmin self.ob += self.ob_h self.pr += self.pr_h # Newton-Raphson loop would end here + # Position correction + self.position_update() + # Allow for customized modifications at the end of each iteration self._post_iterate_update() @@ -320,7 +326,6 @@ def engine_finalize(self): """ Delete temporary containers. """ - super(ML, self).engine_finalize() del self.ptycho.containers[self.ob_grad.ID] del self.ob_grad del self.ptycho.containers[self.ob_grad_new.ID] @@ -490,7 +495,7 @@ def new_grad(self): / (w * Imodel**2).sum()) Imodel *= self.float_intens_coeff[dname] - DI = Imodel - I + DI = np.double(Imodel) - I # Second pod loop: gradients computation LLL = np.sum((w * DI**2).astype(np.float64)) @@ -516,7 +521,6 @@ def new_grad(self): self.ob_grad.storages[name].data += self.regularizer.grad( s.data) LL += self.regularizer.LL - self.LL = LL / self.tot_measpts return error_dct @@ -566,9 +570,10 @@ def poly_line_coeffs(self, ob_h, pr_h): A1 *= self.float_intens_coeff[dname] A2 *= self.float_intens_coeff[dname] - A0 -= pod.upsample(I) + A0 = np.double(A0) - pod.upsample(I) + #A0 -= pod.upsample(I) w = pod.upsample(w) - + B[0] += np.dot(w.flat, (A0**2).flat) * Brenorm B[1] += np.dot(w.flat, (2 * A0 * A1).flat) * Brenorm B[2] += np.dot(w.flat, (A1**2 + 2*A0*A2).flat) * Brenorm diff --git a/ptypy/engines/__init__.py b/ptypy/engines/__init__.py index 9704d283e..96fe8146d 100644 --- a/ptypy/engines/__init__.py +++ b/ptypy/engines/__init__.py @@ -10,10 +10,11 @@ :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. :license: GPLv2, see LICENSE for details. """ -from .. import utils as u -from .. import defaults_tree + from .utils import * + + ENGINES = dict() @@ -38,16 +39,11 @@ def by_name(name): from .base import BaseEngine, DEFAULT_iter_info # These imports should be executable separately -from . import DM -from . import DM_simple -from . import DMOPR +from . import projectional +from . import stochastic from . import ML -from . import MLOPR -from . import dummy -from . import ePIE from . import Bragg3d_engines - # dynamic load, maybe discarded in future -dynamic_load('./', ['BaseEngine', 'PositionCorrectionEngine'] + list(ENGINES.keys()), True) -dynamic_load('~/.ptypy/', ['BaseEngine', 'PositionCorrectionEngine'] + list(ENGINES.keys()), True) +#dynamic_load('./', ['BaseEngine', 'PositionCorrectionEngine'] + list(ENGINES.keys()), True) +#dynamic_load('~/.ptypy/', ['BaseEngine', 'PositionCorrectionEngine'] + list(ENGINES.keys()), True) diff --git a/ptypy/engines/base.py b/ptypy/engines/base.py index 7eed876a9..bf6d32e3f 100644 --- a/ptypy/engines/base.py +++ b/ptypy/engines/base.py @@ -13,15 +13,14 @@ from .. import utils as u from ..utils import parallel from ..utils.verbose import logger, headerline, log -from ..utils.descriptor import EvalDescriptor -from .posref import AnnealingRefine -import gc +from .posref import AnnealingRefine, GridSearchRefine __all__ = ['BaseEngine', 'Base3dBraggEngine', 'DEFAULT_iter_info', 'PositionCorrectionEngine'] DEFAULT_iter_info = u.Param( iteration=0, iterations=0, + numiter=0, engine='None', duration=0., error=np.zeros((3,)) @@ -65,6 +64,12 @@ class BaseEngine(object): help = Valid probe area in frequency domain as fraction of the probe frame doc = Defines a circular area centered on the probe frame (in frequency domain), in which the probe is allowed to be nonzero. + [record_local_error] + default = False + type = bool + help = If True, save the local map of errors into the runtime dictionary. + userlevel = 2 + """ # Define with which models this engine can work. @@ -111,7 +116,7 @@ def initialize(self): """ logger.info('\n' + headerline('Starting %s-algorithm.' - % str(type(self).__name__), 'l', '=') + '\n') + % (self.p.name), 'l', '=') + '\n') logger.info('Parameter set:') logger.info(u.verbose.report(self.p, noheader=True).strip()) logger.info(headerline('', 'l', '=')) @@ -134,6 +139,17 @@ def initialize(self): self._probe_fourier_support = {} # Call engine specific initialization # TODO: Maybe child classes should be calling this? + + # # Make sure all the pods are supported + # for label_, pod_ in self.pods.items(): + # if not pod_.model.__class__ in self.SUPPORTED_MODELS: + # raise Exception('Model %s not supported by engine' % pod_.model.__class__) + + # Make sure all scan models are supported + for model in self.ptycho.model.scans.values(): + if not model.__class__ in self.SUPPORTED_MODELS: + raise Exception('Model %s not supported by engine %s' % (model.__class__,self.p.name)) + self.engine_initialize() def prepare(self): @@ -142,11 +158,6 @@ def prepare(self): """ self.finished = False - # Make sure all the pods are supported - for label_, pod_ in self.pods.items(): - if not pod_.model.__class__ in self.SUPPORTED_MODELS: - raise Exception('Model %s not supported by engine' % pod_.model.__class__) - # Calculate probe support # an individual support for each storage is calculated in saved # in the dict self.probe_support @@ -177,16 +188,16 @@ def support_constraint(self, storage=None): for s in self.pr.storages.values(): self.support_contraint(s) - # Real space - support = self._probe_support.get(storage.ID) - if support is not None: - storage.data *= support - # Fourier space support = self._probe_fourier_support.get(storage.ID) if support is not None: storage.data[:] = np.fft.ifft2(support * np.fft.fft2(storage.data)) + # Real space + support = self._probe_support.get(storage.ID) + if support is not None: + storage.data *= support + def iterate(self, num=None): """ Compute one or several iterations. @@ -225,7 +236,7 @@ def iterate(self, num=None): logger.warning("""Engine %s did not increase iteration counter `self.curiter` internally. Accessing this attribute in that - engine is inaccurate""" % self.__class__.__name__) + engine is inaccurate""" % self.p.name) self.curiter += niter_contiguous @@ -233,7 +244,7 @@ def iterate(self, num=None): logger.error("""Engine %s increased iteration counter `self.curiter` by %d instead of %d. This may lead to - unexpected behaviour""" % (self.__class__.__name__, + unexpected behaviour""" % (self.p.name, self.curiter-it, niter_contiguous)) else: @@ -258,13 +269,15 @@ def _fill_runtime(self): info = dict( iteration=self.curiter, iterations=self.alliter, - engine=type(self).__name__, + numiter=self.numiter, + engine=self.p.name, duration=time.time() - self.t, error=error ) self.ptycho.runtime.iter_info.append(info) - self.ptycho.runtime.error_local = local_error + if self.p.record_local_error: + self.ptycho.runtime.error_local = local_error def finalize(self): """ @@ -316,6 +329,11 @@ class PositionCorrectionEngine(BaseEngine): type = Param, bool help = If True refine scan positions + [position_refinement.method] + default = Annealing + type = str + help = Annealing or GridSearch + [position_refinement.start] default = None type = int @@ -343,6 +361,11 @@ class PositionCorrectionEngine(BaseEngine): type = float help = Distance from original position per random shift [m] + [position_refinement.amplitude_decay] + default = True + type = bool + help = After each interation, multiply amplitude by factor (stop - iteration) / (stop - start) + [position_refinement.max_shift] default = 0.000002 type = float @@ -359,6 +382,11 @@ class PositionCorrectionEngine(BaseEngine): help = record movement of positions """ + POSREF_ENGINES = { + "Annealing": AnnealingRefine, + "GridSearch": GridSearchRefine + } + def __init__(self, ptycho_parent, pars): """ Position Correction engine. @@ -387,18 +415,23 @@ def engine_initialize(self): if (self.p.position_refinement.start is None) and (self.p.position_refinement.stop is None): self.do_position_refinement = False else: + for label, scan in self.ptycho.model.scans.items(): + if self.p.position_refinement.amplitude < scan.geometries[0].resolution[0]: + self.do_position_refinement = False + log(3,"Failed to initialise position refinement, search amplitude is smaller than the resolution") + return self.do_position_refinement = True - log(3, "Initialising position refinement") + log(3, "Initialising position refinement (%s)" %self.p.position_refinement.method) # Enlarge object arrays, # This can be skipped though if the boundary is less important for name, s in self.ob.storages.items(): - s.padding = int(self.p.position_refinement.max_shift // np.max(s.psize)) - s.reformat() + s.padding = int(self.p.position_refinement.max_shift // np.max(s.psize)) + s.reformat() - # this could be some kind of dictionary lookup if we want to add more - self.position_refinement = AnnealingRefine(self.p.position_refinement, self.ob, metric=self.p.position_refinement.metric) - log(3, "Position refinement initialised") + # Choose position refinement engine from dictionary + PosrefEngine = self.POSREF_ENGINES[self.p.position_refinement.method] + self.position_refinement = PosrefEngine(self.p.position_refinement, self.ob, metric=self.p.position_refinement.metric) self.ptycho.citations.add_article(**self.position_refinement.citation_dictionary) if self.p.position_refinement.stop is None: self.p.position_refinement.stop = self.p.numiter @@ -409,7 +442,7 @@ def position_update(self): """ Position refinement update. """ - if self.do_position_refinement is False: + if not self.do_position_refinement: return do_update_pos = (self.p.position_refinement.stop > self.curiter >= self.p.position_refinement.start) do_update_pos &= (self.curiter % self.p.position_refinement.interval) == 0 @@ -438,6 +471,8 @@ def engine_finalize(self): """ if self.do_position_refinement is False: return + if self.p.position_refinement.record is False: + return # Gather all new positions from each node coords = {} @@ -453,6 +488,8 @@ def engine_finalize(self): if v.pod.pr_view.layer == 0: v.coord = coords[v.ID] + self.ptycho.record_positions = True + class Base3dBraggEngine(BaseEngine): """ diff --git a/ptypy/engines/posref.py b/ptypy/engines/posref.py index c0f12a857..8528a3cc0 100644 --- a/ptypy/engines/posref.py +++ b/ptypy/engines/posref.py @@ -41,14 +41,63 @@ def update_constraints(self, iteration): iteration : int The current iteration of the engine. ''' + start, end = self.p.start, self.p.stop + # Compute the maximum shift allowed at this iteration + self.max_shift_dist = self.p.amplitude + if self.p.amplitude_decay: + self.max_shift_dist *= (end - iteration) / (end - start) - raise NotImplementedError('This method needs to be overridden in order to position correct') + def estimate_fourier_metric(self, di_view, obj): + ''' + Calculates error based on DM fourier error estimate. + + Parameters + ---------- + di_view : ptypy.core.classes.View + A diffraction view for which we wish to calculate the error. + + obj : numpy.ndarray + The current calculated object for which we wish to evaluate the error against. + Returns + ------- + np.float + The calculated fourier error + ''' + af2 = np.zeros_like(di_view.data) + for name, pod in di_view.pods.items(): + af2 += pod.downsample(u.abs2(pod.fw(pod.probe*obj))) + return np.sum(di_view.pod.mask * (np.sqrt(af2) - np.sqrt(np.abs(di_view.data)))**2) / di_view.pod.mask.sum() + + def estimate_photon_metric(self, di_view, obj): + ''' + Calculates error based on reduced likelihood estimate. + + Parameters + ---------- + di_view : ptypy.core.classes.View + A diffraction view for which we wish to calculate the error. + + obj : numpy.ndarray + The current calculated object for which we wish to evaluate the error against. + Returns + ------- + np.float + The calculated fourier error + ''' + af2 = np.zeros_like(di_view.data) + for name, pod in di_view.pods.items(): + af2 += pod.downsample(u.abs2(pod.fw(pod.probe*obj))) + return (np.sum(di_view.pod.mask * (af2 - di_view.data)**2 / (di_view.data + 1.)) / np.prod(af2.shape)) def cleanup(self): ''' Cleans up every iteration ''' + @property + def citation_dictionary(self): + return {} + class AnnealingRefine(PositionRefine): @@ -85,48 +134,6 @@ def __init__(self, position_refinement_parameters, Cobj, metric="fourier"): else: raise NotImplementedError("Metric %s is currently not implemented" %metric) - def estimate_fourier_metric(self, di_view, obj): - ''' - Calculates error based on DM fourier error estimate. - - Parameters - ---------- - di_view : ptypy.core.classes.View - A diffraction view for which we wish to calculate the error. - - obj : numpy.ndarray - The current calculated object for which we wish to evaluate the error against. - Returns - ------- - np.float - The calculated fourier error - ''' - af2 = np.zeros_like(di_view.data) - for name, pod in di_view.pods.items(): - af2 += pod.downsample(u.abs2(pod.fw(pod.probe*obj))) - return np.sum(di_view.pod.mask * (np.sqrt(af2) - np.sqrt(np.abs(di_view.data)))**2) - - def estimate_photon_metric(self, di_view, obj): - ''' - Calculates error based on reduced likelihood estimate. - - Parameters - ---------- - di_view : ptypy.core.classes.View - A diffraction view for which we wish to calculate the error. - - obj : numpy.ndarray - The current calculated object for which we wish to evaluate the error against. - Returns - ------- - np.float - The calculated fourier error - ''' - af2 = np.zeros_like(di_view.data) - for name, pod in di_view.pods.items(): - af2 += pod.downsample(u.abs2(pod.fw(pod.probe*obj))) - return (np.sum(di_view.pod.mask * (af2 - di_view.data)**2 / (di_view.data + 1.)) / np.prod(af2.shape)) - def update_view_position(self, di_view): ''' Refines the positions by the following algorithm: @@ -183,30 +190,124 @@ def update_view_position(self, di_view): continue new_error = self.fourier_error(di_view, data) - + if new_error < error: # keep error = new_error coord = new_coord log(4, "Position correction: %s, coord: %s, delta: %s" % (di_view.ID, coord, delta)) - + ob_view.coord = coord ob_view.storage.update_views(ob_view) return coord - initial_coord - def update_constraints(self, iteration): + @property + def citation_dictionary(self): + return { + "title" : 'An annealing algorithm to correct positioning errors in ptychography', + "author" : 'Maiden et al.', + "journal" : 'Ultramicroscopy', + "volume" : 120, + "year" : 2012, + "page" : 64, + "doi" : '10.1016/j.ultramic.2012.06.001', + "comment" : 'Position Refinement using annealing algorithm'} + +class GridSearchRefine(PositionRefine): + + def __init__(self, position_refinement_parameters, Cobj, metric="fourier"): ''' + Grid Search Position Refinement. - Parameters ---------- - iteration : int - The current iteration of the engine. + position_refinement_parameters : ptypy.utils.parameters.Param + The parameter tree for the refinement + + Cobj : ptypy.core.classes.Container + The current pbject container object + metric : str + "fourier" or "photon" ''' + super(GridSearchRefine, self).__init__(position_refinement_parameters) - start, end = self.p.start, self.p.stop + self.Cobj = Cobj # take a reference here. It would be cool if we could make this read-only or something - # Compute the maximum shift allowed at this iteration - self.max_shift_dist = self.p.amplitude * (end - iteration) / (end - start) + # Updated before each iteration by self.update_constraints + self.max_shift_dist = None + + # Choose metric for fourier error + if metric == "fourier": + self.fourier_error = self.estimate_fourier_metric + elif metric == "photon": + self.fourier_error = self.estimate_photon_metric + else: + raise NotImplementedError("Metric %s is currently not implemented" %metric) + + def update_view_position(self, di_view): + ''' + Refines the positions by the following algorithm: + + Calculates all shifts in a given radius around the original position and calculates the fourier error. + If the fourier error decreased the calculated postion will be used as new position. + + Parameters + ---------- + di_view : ptypy.core.classes.View + A diffraction view that we wish to refine. + + Returns + ------- + numpy.ndarray + A length 2 numpy array with the position increments for x and y co-ordinates respectively + ''' + # there might be more than one object view + ob_view = di_view.pod.ob_view + + initial_coord = ob_view.coord.copy() + coord = initial_coord + psize = ob_view.psize.copy() + + # if you cannot move far, do nothing + if np.max(psize) >= self.max_shift_dist: + return np.zeros((2,)) + + # This can be optimized by saving existing iteration fourier error... + error = self.fourier_error(di_view, ob_view.data) + + max_shift_pix = np.ceil(self.max_shift_dist / np.min(psize)) + max_bound_pix = np.ceil(self.p.max_shift / np.min(psize)) + + # Create the search grid + deltas = np.mgrid[-max_shift_pix:max_shift_pix+1:1, + -max_shift_pix:max_shift_pix+1:1] + within_bound = (deltas[0]**2 + deltas[1]**2) < (max_bound_pix**2) + deltas = (deltas[:,within_bound] * np.min(psize)).T + + for i in range(deltas.shape[0]): + # Current shift + delta = deltas[i] + + # Move view to new position + new_coord = initial_coord + delta + ob_view.coord = new_coord + ob_view.storage.update_views(ob_view) + data = ob_view.data + + # catch bad slicing + if not np.allclose(data.shape, ob_view.shape): + continue + + new_error = self.fourier_error(di_view, data) + + if new_error < error: + # keep + error = new_error + coord = new_coord + log(4, "Position correction: %s, coord: %s, delta: %s" % (di_view.ID, coord, delta)) + + ob_view.coord = coord + ob_view.storage.update_views(ob_view) + return coord - initial_coord @property def citation_dictionary(self): @@ -218,4 +319,4 @@ def citation_dictionary(self): "year" : 2012, "page" : 64, "doi" : '10.1016/j.ultramic.2012.06.001', - "comment" : 'Position Refinement using annealing algorithm'} + "comment" : 'Position Refinement using annealing algorithm'} \ No newline at end of file diff --git a/ptypy/engines/projectional.py b/ptypy/engines/projectional.py new file mode 100644 index 000000000..89dddd675 --- /dev/null +++ b/ptypy/engines/projectional.py @@ -0,0 +1,553 @@ +# -*- coding: utf-8 -*- +""" +Difference Map reconstruction engine. + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" +import numpy as np +import time +from .. import utils as u +from ..utils.verbose import logger, log +from ..utils import parallel +from .utils import projection_update_generalized, log_likelihood +from . import register +from .base import PositionCorrectionEngine +from ..core.manager import Full, Vanilla, Bragg3dModel, BlockVanilla, BlockFull + +__all__ = ['DM', 'RAAR'] + +class _ProjectionEngine(PositionCorrectionEngine): + """ + Defaults: + + [probe_update_start] + default = 2 + type = int + lowlim = 0 + help = Number of iterations before probe update starts + + [subpix_start] + default = 0 + type = int + lowlim = 0 + help = Number of iterations before starting subpixel interpolation + + [subpix] + default = 'linear' + type = str + help = Subpixel interpolation; 'fourier','linear' or None for no interpolation + + [update_object_first] + default = True + type = bool + help = If True update object before probe + + [overlap_converge_factor] + default = 0.05 + type = float + lowlim = 0.0 + help = Threshold for interruption of the inner overlap loop + doc = The inner overlap loop refines the probe and the object simultaneously. This loop is escaped as soon as the overall change in probe, relative to the first iteration, is less than this value. + + [overlap_max_iterations] + default = 10 + type = int + lowlim = 1 + help = Maximum of iterations for the overlap constraint inner loop + + [probe_inertia] + default = 1e-9 + type = float + lowlim = 0.0 + help = Weight of the current probe estimate in the update + + [object_inertia] + default = 1e-4 + type = float + lowlim = 0.0 + help = Weight of the current object in the update + + [fourier_power_bound] + default = None + type = float + help = If rms error of model vs diffraction data is smaller than this value, Fourier constraint is met + doc = For Poisson-sampled data, the theoretical value for this parameter is 1/4. Set this value higher for noisy data. By default, power bound is calculated using fourier_relax_factor + + [fourier_relax_factor] + default = 0.05 + type = float + lowlim = 0.0 + help = A factor used to calculate the Fourier power bound as 0.25 * fourier_relax_factor**2 * maximum power in diffraction data + doc = Set this value higher for noisy data. + + [obj_smooth_std] + default = None + type = float + lowlim = 0 + help = Gaussian smoothing (pixel) of the current object prior to update + doc = If None, smoothing is deactivated. This smoothing can be used to reduce the amplitude of spurious pixels in the outer, least constrained areas of the object. + + [clip_object] + default = None + type = tuple + help = Clip object amplitude into this interval + + [probe_center_tol] + default = None + type = float + lowlim = 0.0 + help = Pixel radius around optical axes that the probe mass center must reside in + + [compute_log_likelihood] + default = True + type = bool + help = A switch for computing the log-likelihood error (this can impact the performance of the engine) + + """ + + SUPPORTED_MODELS = [Full, Vanilla, Bragg3dModel, BlockVanilla, BlockFull] + + def __init__(self, ptycho_parent, pars=None): + """ + Difference map reconstruction engine. + """ + super().__init__(ptycho_parent, pars) + + self._a = 0. + self._b = 1. + self._c = 1. + + self.error = None + + self.ob_buf = None + self.ob_nrm = None + self.ob_viewcover = None + + self.pr_buf = None + self.pr_nrm = None + + self.pbound = None + + # Required to get proper normalization of object inertia + # The actual value is computed in engine_prepare + # Another possibility would be to use the maximum value of all probe storages. + self.mean_power = None + + + def engine_initialize(self): + """ + Prepare for reconstruction. + """ + super().engine_initialize() + + self.error = [] + + # Generate container copies + self.ob_buf = self.ob.copy(self.ob.ID + '_alt', fill=0.) + self.ob_nrm = self.ob.copy(self.ob.ID + '_nrm', fill=0., dtype='real') + self.ob_viewcover = self.ob.copy(self.ob.ID + '_vcover', fill=0.) + + self.pr_buf = self.pr.copy(self.pr.ID + '_alt', fill=0.) + self.pr_nrm = self.pr.copy(self.pr.ID + '_nrm', fill=0., dtype='real') + + def engine_prepare(self): + + """ + Last minute initialization. + + Everything that needs to be recalculated when new data arrives. + """ + if self.ptycho.new_data: + + # recalculate everything + mean_power = 0. + self.pbound_scan = {} + for s in self.di.storages.values(): + if self.p.fourier_power_bound is None: + pb = .25 * self.p.fourier_relax_factor**2 * s.pbound_stub + else: + pb = self.p.fourier_power_bound + log(4, "power bound for scan %s = %f" %(s.label, pb)) + if not self.pbound_scan.get(s.label): + self.pbound_scan[s.label] = pb + else: + self.pbound_scan[s.label] = max(pb, self.pbound_scan[s.label]) + mean_power += s.mean_power + self.mean_power = mean_power / len(self.di.storages) + + # Fill object with coverage of views + for name, s in self.ob_viewcover.storages.items(): + s.fill(s.get_view_coverage()) + + def engine_iterate(self, num=1): + """ + Compute `num` iterations. + """ + to = 0. + tf = 0. + tp = 0. + for it in range(num): + t1 = time.time() + + # Fourier update + error_dct = self.fourier_update() + + t2 = time.time() + tf += t2 - t1 + + # Overlap update + self.overlap_update() + + # Recenter the probe + self.center_probe() + + t3 = time.time() + to += t3 - t2 + + # Position update + self.position_update() + + t4 = time.time() + tp += t4 - t3 + + # count up + self.curiter +=1 + + logger.info('Time spent in Fourier update: %.2f' % tf) + logger.info('Time spent in Overlap update: %.2f' % to) + logger.info('Time spent in Position update: %.2f' % tp) + return error_dct + + def engine_finalize(self): + """ + Try deleting ever helper container. + """ + super().engine_finalize() + + containers = [ + self.ob_buf, + self.ob_nrm, + self.ob_viewcover, + self.pr_buf, + self.pr_nrm] + + for c in containers: + logger.debug('Attempt to remove container %s' % c.ID) + del self.ptycho.containers[c.ID] + # IDM.used.remove(c.ID) + + del self.ob_buf + del self.ob_nrm + del self.ob_viewcover + del self.pr_buf + del self.pr_nrm + + del containers + + def fourier_update(self): + """ + DM Fourier constraint update (including DM step). + """ + error_dct = {} + for name, di_view in self.di.views.items(): + if not di_view.active: + continue + #pbound = self.pbound[di_view.storage.ID] + pbound = self.pbound_scan[di_view.storage.label] + """ + error_dct[name] = basic_fourier_update(di_view, + pbound=pbound, + alpha=self.p.alpha, + LL_error=self.p.compute_log_likelihood) + """ + err_fmag, err_exit = projection_update_generalized(di_view, self._a, self._b, self._c, pbound) + if self.p.compute_log_likelihood: + err_phot = log_likelihood(di_view) + else: + err_phot = 0. + error_dct[name] = np.array([err_fmag, err_phot, err_exit]) + + return error_dct + + def clip_object(self, ob): + # Clip object (This call takes like one ms. Not time critical) + if self.p.clip_object is not None: + clip_min, clip_max = self.p.clip_object + ampl_obj = np.abs(ob.data) + phase_obj = np.exp(1j * np.angle(ob.data)) + too_high = (ampl_obj > clip_max) + too_low = (ampl_obj < clip_min) + ob.data[too_high] = clip_max * phase_obj[too_high] + ob.data[too_low] = clip_min * phase_obj[too_low] + + def overlap_update(self): + """ + DM overlap constraint update. + """ + # Condition to update probe + do_update_probe = (self.p.probe_update_start <= self.curiter) + + for inner in range(self.p.overlap_max_iterations): + pre_str = 'Iteration (Overlap) #%02d: ' % inner + + # Update object first + if self.p.update_object_first or (inner > 0) or not do_update_probe: + # Update object + log(4, pre_str + '----- object update -----') + self.object_update() + + # Exit if probe should not be updated yet + if not do_update_probe: + break + + # Update probe + log(4, pre_str + '----- probe update -----') + change = self.probe_update() + log(4, pre_str + 'change in probe is %.3f' % change) + + # Stop iteration if probe change is small + if change < self.p.overlap_converge_factor: + break + + def center_probe(self): + if self.p.probe_center_tol is not None: + for name, pr_s in self.pr.storages.items(): + c1 = u.mass_center(u.abs2(pr_s.data).sum(0)) + c2 = np.asarray(pr_s.shape[-2:]) // 2 + # fft convention should however use geometry instead + if u.norm(c1 - c2) < self.p.probe_center_tol: + break + # SC: possible BUG here, wrong input parameter + pr_s.data[:] = u.shift_zoom(pr_s.data, (1.,)*3, + (0, c1[0], c1[1]), (0, c2[0], c2[1])) + + # shift the object + ob_s = pr_s.views[0].pod.ob_view.storage + ob_s.data[:] = u.shift_zoom(ob_s.data, (1.,)*3, + (0, c1[0], c1[1]), (0, c2[0], c2[1])) + + # shift the exit waves, loop through different exit wave views + for pv in pr_s.views: + pv.pod.exit = u.shift_zoom(pv.pod.exit, (1.,)*2, + (c1[0], c1[1]), (c2[0], c2[1])) + + log(4,'Probe recentered from %s to %s' + % (str(tuple(c1)), str(tuple(c2)))) + + def object_update(self): + """ + DM object update. + """ + ob = self.ob + ob_nrm = self.ob_nrm + + # Fill container + if not parallel.master: + ob.fill(0.0) + ob_nrm.fill(0.) + else: + for name, s in self.ob.storages.items(): + # The amplitude of the regularization term has to be scaled with the + # power of the probe (which is estimated from the power in diffraction patterns). + # This estimate assumes that the probe power is uniformly distributed through the + # array and therefore underestimate the strength of the probe terms. + cfact = self.p.object_inertia * self.mean_power + if self.p.obj_smooth_std is not None: + log(4, 'Smoothing object, average cfact is %.2f' + % np.mean(cfact).real) + smooth_mfs = [0, + self.p.obj_smooth_std, + self.p.obj_smooth_std] + s.data[:] = cfact * u.c_gf(s.data, smooth_mfs) + else: + s.data[:] = s.data * cfact + + ob_nrm.storages[name].fill(cfact) + + # DM update per node + for name, pod in self.pods.items(): + if not pod.active: + continue + pod.object += pod.probe.conj() * pod.exit * pod.object_weight + ob_nrm[pod.ob_view] += u.abs2(pod.probe) * pod.object_weight + + # Distribute result with MPI + for name, s in self.ob.storages.items(): + # Get the np arrays + nrm = ob_nrm.storages[name].data + parallel.allreduce(s.data) + parallel.allreduce(nrm) + s.data /= nrm + + # A possible (but costly) sanity check would be as follows: + # if all((np.abs(nrm)-np.abs(cfact))/np.abs(cfact) < 1.): + # logger.warning('object_inertia seem too high!') + self.clip_object(s) + + def probe_update(self): + """ + DM probe update. + """ + pr = self.pr + pr_nrm = self.pr_nrm + pr_buf = self.pr_buf + + # Fill container + # "cfact" fill + # BE: was this asymmetric in original code + # only because of the number of MPI nodes ? + if parallel.master: + for name, s in pr.storages.items(): + # Instead of Npts_scan, the number of views should be considered + # Please note that a call to s.views may be + # slow for many views in the probe. + cfact = self.p.probe_inertia * len(s.views) / s.data.shape[0] + s.data[:] = cfact * s.data + pr_nrm.storages[name].fill(cfact) + else: + pr.fill(0.0) + pr_nrm.fill(0.0) + + # DM update per node + for name, pod in self.pods.items(): + if not pod.active: + continue + pod.probe += pod.object.conj() * pod.exit * pod.probe_weight + pr_nrm[pod.pr_view] += u.abs2(pod.object) * pod.probe_weight + + change = 0. + + # Distribute result with MPI + for name, s in pr.storages.items(): + # MPI reduction of results + nrm = pr_nrm.storages[name].data + parallel.allreduce(s.data) + parallel.allreduce(nrm) + s.data /= nrm + + # Apply probe support if requested + self.support_constraint(s) + + # Compute relative change in probe + buf = pr_buf.storages[name].data + change += u.norm2(s.data - buf) / u.norm2(s.data) + + # Fill buffer with new probe + buf[:] = s.data + + return np.sqrt(change / len(pr.storages)) + + +class DMMixin: + + """ + Defaults: + + [alpha] + default = 1. + type = float + lowlim = 0.0 + help = Mix parameter between Difference Map (alpha=1.) and Alternating Projections (alpha=0.) + """ + + def __init__(self, alpha): + self._alpha = 1. + self._a = -alpha + self._b = 1 + self._c = 1.+alpha + self.alpha = alpha + self.article = dict( + title='Probe retrieval in ptychographic coherent diffractive imaging', + author='Thibault et al.', + journal='Ultramicroscopy', + volume=109, + year=2009, + page=338, + doi='10.1016/j.ultramic.2008.12.011', + comment='The difference map reconstruction algorithm', + ) + + @property + def alpha(self): + return self._alpha + + @alpha.setter + def alpha(self, alpha): + self._alpha = alpha + self._a = -alpha + self._b = 1 + self._c = 1.+alpha + +class RAARMixin: + """ + Defaults: + + [beta] + default = 0.75 + type = float + lowlim = 0.0 + help = Beta parameter for RAAR algorithm + """ + + def __init__(self, beta): + self._beta = 1. + self._a = 1. - 2. * beta + self._b = beta + self._c = 2 + self.beta = beta + + @property + def beta(self): + return self._beta + + @beta.setter + def beta(self, beta): + self._beta = beta + self._a = 1. - 2. * beta + self._b = beta + self._c = 2 + + +@register() +class DM(_ProjectionEngine, DMMixin): + """ + A full-fledged Difference Map engine. + + Defaults: + + [name] + default = DM + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + _ProjectionEngine.__init__(self, ptycho_parent, pars) + DMMixin.__init__(self, self.p.alpha) + ptycho_parent.citations.add_article(**self.article) + + +@register() +class RAAR(_ProjectionEngine, RAARMixin): + """ + A RAAR engine. + + Defaults: + + [name] + default = RAAR + type = str + help = + doc = + + """ + + def __init__(self, ptycho_parent, pars=None): + + _ProjectionEngine.__init__(self, ptycho_parent, pars) + RAARMixin.__init__(self, self.p.beta) diff --git a/ptypy/engines/stochastic.py b/ptypy/engines/stochastic.py new file mode 100644 index 000000000..c1c64c378 --- /dev/null +++ b/ptypy/engines/stochastic.py @@ -0,0 +1,476 @@ +# -*- coding: utf-8 -*- +""" +Stochastic reconstruction engine. + +This file is part of the PTYPY package. + + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" +import numpy as np +import time +from .. import utils as u +from ..utils.verbose import logger, log +from ..utils import parallel +from .utils import projection_update_generalized, log_likelihood +from .base import PositionCorrectionEngine +from . import register +from ..core.manager import Full, Vanilla, Bragg3dModel, BlockVanilla, BlockFull, GradFull, BlockGradFull + +__all__ = ['EPIE', 'SDR'] + +class _StochasticEngine(PositionCorrectionEngine): + """ + The base implementation of a stochastic algorithm for ptychography + + Defaults: + + [probe_update_start] + default = 0 + type = int + lowlim = 0 + help = Number of iterations before probe update starts + + [probe_center_tol] + default = None + type = float + lowlim = 0.0 + help = Pixel radius around optical axes that the probe mass center must reside in + + [compute_log_likelihood] + default = True + type = bool + help = A switch for computing the log-likelihood error (this can impact the performance of the engine) + + """ + + def __init__(self, ptycho_parent, pars=None): + """ + Stochastic Douglas-Rachford reconstruction engine. + """ + super().__init__(ptycho_parent, pars) + if parallel.MPIenabled: + raise NotImplementedError("The stochastic engines are not compatible with MPI") + + # Adjustment parameters for fourier update + self._a = 0 + self._b = 1 + self._c = 1 + + # Adjustment parameters for probe update + self._pr_a = 0.0 + self._pr_b = 1.0 + + # Adjustment parameters for object update + self._ob_a = 0.0 + self._ob_b = 1.0 + + # By default the object norm is based on the local object + self._object_norm_is_global = False + + def engine_prepare(self): + """ + Last minute initialization. + Everything that needs to be recalculated when new data arrives. + """ + pass + + def engine_iterate(self, num=1): + """ + Compute one iteration. + """ + vieworder = list(self.di.views.keys()) + vieworder.sort() + rng = np.random.default_rng() + + for it in range(num): + + error_dct = {} + rng.shuffle(vieworder) + + for name in vieworder: + view = self.di.views[name] + if not view.active: + continue + + # Position update + self.position_update_local(view) + + # Fourier update + error_dct[name] = self.fourier_update(view) + + # A copy of the old exit wave + exit_wave = {} + for name, pod in view.pods.items(): + exit_wave[name] = pod.object * pod.probe + + # Object update + self.object_update(view, exit_wave) + + # Probe update + self.probe_update(view, exit_wave) + + # Recenter the probe + self.center_probe() + + self.curiter += 1 + + return error_dct + + def position_update_local(self, view): + """ + Position refinement update for current view. + """ + if not self.do_position_refinement: + return + do_update_pos = (self.p.position_refinement.stop > self.curiter >= self.p.position_refinement.start) + do_update_pos &= (self.curiter % self.p.position_refinement.interval) == 0 + + # Update positions + if do_update_pos: + """ + refines position of current view by a given algorithm. + """ + self.position_refinement.update_constraints(self.curiter) # this stays here + + # Check for new coordinates + if view.active: + self.position_refinement.update_view_position(view) + + def fourier_update(self, view): + """ + General implementation of Fourier update + + Parameters + ---------- + view : View + View to diffraction data + """ + #return basic_fourier_update(view, alpha=self._alpha, tau=self._tau, + # LL_error=self.p.compute_log_likelihood) + + err_fmag, err_exit = projection_update_generalized(view, self._a, self._b, self._c) + if self.p.compute_log_likelihood: + err_phot = log_likelihood(view) + else: + err_phot = 0. + return np.array([err_fmag, err_phot, err_exit]) + + def object_update(self, view, exit_wave): + """ + Engine-specific implementation of object update + + Parameters + ---------- + view : View + View to diffraction data + + exit_wave: dict + Collection of exit waves associated with the current view + """ + self._generic_object_update(view, exit_wave, a=self._ob_a, b=self._ob_b) + + def probe_update(self, view, exit_wave): + """ + Engine-specific implementation of probe update + + Parameters + ---------- + view : View + View to diffraction data + + exit_wave: dict + Collection of exit waves associated with the current view + """ + if self.p.probe_update_start > self.curiter: + return + self._generic_probe_update(view, exit_wave, a=self._pr_a, b=self._pr_b) + + def center_probe(self): + if self.p.probe_center_tol is not None: + for name, pr_s in self.pr.storages.items(): + c1 = u.mass_center(u.abs2(pr_s.data).sum(0)) + c2 = np.asarray(pr_s.shape[-2:]) // 2 + # fft convention should however use geometry instead + if u.norm(c1 - c2) < self.p.probe_center_tol: + break + # SC: possible BUG here, wrong input parameter + pr_s.data[:] = u.shift_zoom(pr_s.data, (1.,)*3, + (0, c1[0], c1[1]), (0, c2[0], c2[1])) + + # shift the object + ob_s = pr_s.views[0].pod.ob_view.storage + ob_s.data[:] = u.shift_zoom(ob_s.data, (1.,)*3, + (0, c1[0], c1[1]), (0, c2[0], c2[1])) + + # shift the exit waves, loop through different exit wave views + for pv in pr_s.views: + pv.pod.exit = u.shift_zoom(pv.pod.exit, (1.,)*2, + (c1[0], c1[1]), (c2[0], c2[1])) + + log(4,'Probe recentered from %s to %s' + % (str(tuple(c1)), str(tuple(c2)))) + + def _generic_object_update(self, view, exit_wave, a=0., b=1.): + """ + A generic object update for stochastic algorithms. + + Parameters + ---------- + view : View + View to diffraction data + + exit_wave: dict + Collection of exit waves associated with the current view + + a : float + Generic parameter for adjusting step size of object update + + b : float + Generic parameter for adjusting step size of object update + + a = 0, b = \\alpha is the ePIE update with parameter \\alpha. + a = \\beta_O, b = 0 is the SDR update with parameter \\beta_O. + + .. math:: + O^{j+1} += (a + b) * \\bar{P^{j}} * (\\Psi^{\\prime} - \\Psi^{j}) / P_{norm} + P_{norm} = (1 - a) * ||P^{j}||_{max}^2 + a * |P^{j}|^2 + + """ + probe_power = 0 + for name, pod in view.pods.items(): + probe_power += u.abs2(pod.probe) + probe_norm = (1 - a) * np.max(probe_power) + a * probe_power + for name, pod in view.pods.items(): + pod.object += (a + b) * np.conj(pod.probe) * (pod.exit - exit_wave[name]) / probe_norm + + def _generic_probe_update(self, view, exit_wave, a=0., b=1.): + """ + A generic probe update for stochastic algorithms. + + Parameters + ---------- + view : View + View to diffraction data + + exit_wave: dict + Collection of exit waves associated with the current view + + a : float + Generic parameter for adjusting step size of probe update + + b : float + Generic parameter for adjusting step size of probe update + + a = 0, b = \\beta is the ePIE update with parameter \\beta. + a = \\beta_P, b = 0 is the SDR update with parameter \\beta_P. + + .. math:: + P^{j+1} += (a + b) * \\bar{O^{j}} * (\\Psi^{\\prime} - \\Psi^{j}) / O_{norm} + O_{norm} = (1 - a) * ||O^{j}||_{max}^2 + a * |O^{j}|^2 + + """ + # Calculate the object norm based on the global object + # This only works if a = 0. + if self._object_norm_is_global and a == 0: + object_norm = np.max(u.abs2(view.pod.ob_view.storage.data).sum(axis=0)) + # Calculate the object norm based on the local object + else: + object_power = 0 + for name, pod in view.pods.items(): + object_power += u.abs2(pod.object) + object_norm = (1 - a) * np.max(object_power) + a * object_power + for name, pod in view.pods.items(): + pod.probe += (a + b) * np.conj(pod.object) * (pod.exit - exit_wave[name]) / object_norm + +class EPIEMixin: + """ + Defaults: + + [alpha] + default = 1.0 + type = float + lowlim = 0.0 + help = Parameter for adjusting the step size of the object update + + [beta] + default = 1.0 + type = float + lowlim = 0.0 + help = Parameter for adjusting the step size of the probe update + + [object_norm_is_global] + default = False + type = bool + help = Calculate the object norm based on the global object instead of the local object + + """ + SUPPORTED_MODELS = [Full, Vanilla, Bragg3dModel, BlockVanilla, BlockFull, GradFull, BlockGradFull] + + def __init__(self, alpha, beta): + # EPIE adjustment parameters + self._a = 0 + self._b = 1 + self._c = 1 + self._pr_a = 0.0 + self._ob_a = 0.0 + self._pr_b = alpha + self._ob_b = beta + self._object_norm_is_global = self.p.object_norm_is_global + self.article = dict( + title='An improved ptychographical phase retrieval algorithm for diffractive imaging', + author='Maiden A. and Rodenburg J.', + journal='Ultramicroscopy', + volume=10, + year=2009, + page=1256, + doi='10.1016/j.ultramic.2009.05.012', + comment='The ePIE reconstruction algorithm', + ) + + @property + def alpha(self): + return self._pr_a + + @alpha.setter + def alpha(self, alpha): + self._pr_b = alpha + + @property + def beta(self): + return self._ob_b + + @beta.setter + def beta(self, beta): + self._ob_b = beta + + +class SDRMixin: + """ + Defaults: + + [sigma] + default = 1 + type = float + lowlim = 0.0 + help = Relaxed Fourier reflection parameter. + + [tau] + default = 1 + type = float + lowlim = 0.0 + help = Relaxed modulus constraint parameter. + + [beta_probe] + default = 0.1 + type = float + lowlim = 0.0 + help = Parameter for adjusting the step size of the probe update + + [beta_object] + default = 0.9 + type = float + lowlim = 0.0 + help = Parameter for adjusting the step size of the object update + + """ + SUPPORTED_MODELS = [Full, Vanilla, Bragg3dModel, BlockVanilla, BlockFull] + + def __init__(self, sigma, tau, beta_probe, beta_object): + # SDR Adjustment parameters + self._sigma = sigma + self._tau = tau + self._update_abc() + self._pr_a = beta_probe + self._ob_a = beta_object + self._pr_b = 0.0 + self._ob_b = 0.0 + + self.article = dict( + title='Semi-implicit relaxed Douglas-Rachford algorithm (sDR) for ptychography', + author='Pham et al.', + journal='Opt. Express', + volume=27, + year=2019, + page=31246, + doi='10.1364/OE.27.031246', + comment='The semi-implicit relaxed Douglas-Rachford reconstruction algorithm', + ) + + def _update_abc(self): + self._a = 1 - self._tau * (1 + self._sigma) + self._b = self._tau + self._c = 1 + self._sigma + + @property + def sigma(self): + return self._sigma + + @sigma.setter + def sigma(self, sigma): + self._sigma = sigma + self._update_abc() + + @property + def tau(self): + return self._tau + + @tau.setter + def tau(self, tau): + self._tau = tau + self._update_abc() + + @property + def beta_probe(self): + return self._pr_a + + @beta_probe.setter + def beta_probe(self, beta): + self._pr_a = beta + + @property + def beta_object(self): + return self._ob_a + + @beta_object.setter + def beta_object(self, beta): + self._ob_a = beta + +@register() +class EPIE(_StochasticEngine, EPIEMixin): + """ + The ePIE algorithm. + + Defaults: + + [name] + default = EPIE + type = str + help = + doc = + + """ + def __init__(self, ptycho_parent, pars=None): + _StochasticEngine.__init__(self, ptycho_parent, pars) + EPIEMixin.__init__(self, self.p.alpha, self.p.beta) + ptycho_parent.citations.add_article(**self.article) + + +@register() +class SDR(_StochasticEngine, SDRMixin): + """ + The stochastic Douglas-Rachford algorithm. + + Defaults: + + [name] + default = SDR + type = str + help = + doc = + + """ + def __init__(self, ptycho_parent, pars=None): + _StochasticEngine.__init__(self, ptycho_parent, pars) + SDRMixin.__init__(self, self.p.sigma, self.p.tau, self.p.beta_probe, self.p.beta_object) + ptycho_parent.citations.add_article(**self.article) diff --git a/ptypy/engines/utils.py b/ptypy/engines/utils.py index fadb012c9..6c47e123e 100644 --- a/ptypy/engines/utils.py +++ b/ptypy/engines/utils.py @@ -50,7 +50,7 @@ def dynamic_load(path, baselist, fail_silently = True): # Find classes res = re.findall( - '^class (.*)\((.*)\)', file(filename, 'r').read(), re.M) + r'^class (.*)\((.*)\)', open(filename, 'r').read(), re.M) for classname, basename in res: if (basename in baselist) and classname not in baselist: @@ -76,8 +76,230 @@ def dynamic_load(path, baselist, fail_silently = True): u.logger.warning(traceback.format_exc(tb)) +def log_likelihood(diff_view): + """ + Calculates the log-likelihood for a diffraction view. + + Parameters + ---------- + diff_view : View + View to diffraction data + + Returns + ------- + ll_error : float + Log-likelihood error + """ + I = diff_view.data + LL = np.zeros_like(I) + for name, pod in diff_view.pods.items(): + LL += pod.downsample(u.abs2(pod.fw(pod.probe * pod.object))) + return np.sum(diff_view.pod.mask * (LL - I)**2 / (I + 1.)) / np.prod(LL.shape) + + +def projection_update_generalized(diff_view, a, b, c, pbound=None): + """ + Generalized projection update of a single view using its associated pods. + Updates on all pods' exit waves. We assume here that the current state + is held in pod.exit, while the product of pod.probe & pod.object hold + the state after overlap constraint has been applied. With O() denoting + the overlap constraint and F() denoting the Data/Fourier constraint, + the general projection update can be expressed with four coefficients + + .. math:: + \\psi^{j+1} = [x 1 + a O + b F (c O + y 1)](\\psi^{j}) + + However, the coefficients aren't all independent as the sum of + x+a+b and d+y must be 1, thus we choose + + .. math:: + x = 1 - a - b + + and + + .. math:: + y = 1 - c + + The choice of a,b,c should enable a wide range of projection based + algorithms. + + For memory efficiency, this projection update includes the Fourier update + which is why the power bound mechanism is included but deactivated by + default. + + Parameters + ---------- + diff_view : View + View to diffraction data + + a,b,c : float + Coefficients for Overlap, Fourier and Fourier * Overlap constraints, + respectively + + pbound : float, optional + Power bound. Fourier update is bypassed if the quadratic deviation + between diffraction data and `diff_view` is below this value. + If ``None``, fourier update always happens. + + Returns + ------- + err_fmag, err_exit : float + + - `err_fmag`, Fourier magnitude error; quadratic deviation from + root of experimental data + - `err_exit`, quadratic deviation between exit waves before and after + projection + """ + # Prepare dict for storing propagated waves + f = {} + + # Buffer for accumulated photons + af2 = np.zeros_like(diff_view.data) + # Get measured data + I = diff_view.data + + # Get the mask + fmask = diff_view.pod.mask + + # Propagate the exit waves + for name, pod in diff_view.pods.items(): + if not pod.active: + continue + f[name] = pod.fw((1-c) * pod.exit + c * pod.probe * pod.object) + af2 += pod.downsample(u.abs2(f[name])) + + fmag = np.sqrt(np.abs(I)) + af = np.sqrt(af2) + + # Fourier magnitudes deviations + fdev = af - fmag + err_fmag = np.sum(fmask * fdev**2) / fmask.sum() + err_exit = 0. + + """ + if pbound is None: + # No power bound + fm = (1 - fmask) + fmask * fmag / (af + 1e-10) + for name, pod in diff_view.pods.items(): + if not pod.active: + continue + df = pod.bw(pod.upsample(fm) * f[name]) + \ + a * pod.probe * pod.object - (a + b + c) * pod.exit + pod.exit += df + err_exit += np.mean(u.abs2(df)) + elif err_fmag > pbound: + # Power bound is applied + renorm = np.sqrt(pbound / err_fmag) + fm = (1 - fmask) + fmask * (fmag + fdev * renorm) / (af + 1e-10) + for name, pod in diff_view.pods.items(): + if not pod.active: + continue + df = pod.bw(pod.upsample(fm) * f[name]) + \ + a * pod.probe * pod.object - (a + b + c) * pod.exit + pod.exit += df + err_exit += np.mean(u.abs2(df)) + else: + # Within power bound so no constraint applied. + for name, pod in diff_view.pods.items(): + if not pod.active: + continue + df = (a + c) * (pod.probe * pod.object - pod.exit) + pod.exit += df + err_exit += np.mean(u.abs2(df)) + """ + # Essentially, the following is all the same formula + # fm = (1 - fmask) + fmask * (fmag + fdev * renorm) + # with + # renorm = 1.0 for pbound >= err_fmag + # renorm = np.sqrt(pbound / err_fmag) for pbound < err_fmag + # renorm = 0.0 for pbound == None (off-switch) + # und we use that for GPU and the serial/batched engines. + # See the basic_fourier_update_LEGACY function for the original + # implementation. We'll save a few FFTs this way but that only + # makes a difference if all ranks get similar numbers of diffraction + # frames with err_fmag inside the pbound. + if pbound is None: + fm = (1 - fmask) + fmask * fmag / (af + 1e-10) + elif err_fmag > pbound: + renorm = np.sqrt(pbound / err_fmag) + fm = (1 - fmask) + fmask * (fmag + fdev * renorm) / (af + 1e-10) + else: + fm = None + + for name, pod in diff_view.pods.items(): + if not pod.active: + continue + + if fm is not None: + df = b * pod.bw(pod.upsample(fm) * f[name]) + \ + a * pod.probe * pod.object - (a + b) * pod.exit + else: + df = (a + b*c) * (pod.probe * pod.object - pod.exit) + + pod.exit += df + err_exit += np.mean(u.abs2(df)) + + return err_fmag, err_exit + + +def projection_update_DM_AP(diff_view, alpha=1.0, pbound=None): + """ + Linear interpolation between Difference Map algorithm (a,b,c = -1,1,2) + and Alternating Projections algorithm (a,b,c = 0,1,1) with coefficients + a = -alpha, b = 1, c = 1 + alpha. Alpha = 1.0 corresponds to DM and + alpha = 0.0 to AP. + + Parameters + ---------- + diff_view : View + View to diffraction data + + alpha : float, optional + Blend between AP (alpha=0.0 and DM (alpha=1.0) . Valid interval ``[0, 1]`` + + pbound : float, optional + Power bound. Fourier update is bypassed if the quadratic deviation + between diffraction data and `diff_view` is below this value. + If ``None``, fourier update always happens. + + Returns + ------- + err_fmag, err_exit : float + + - `err_fmag`, Fourier magnitude error; quadratic deviation from + root of experimental data + - `err_exit`, quadratic deviation between exit waves before and after + projection + """ + a = -alpha + b = 1 + c = 1.+alpha + return projection_update_generalized(diff_view, a, b, c, pbound=pbound) + + def basic_fourier_update(diff_view, pbound=None, alpha=1., LL_error=True): - """\ + """ + *** DEPRECATED *** + Backwards compatible function, for reference only. Contains LL error. + Please replace with log_likelihood and projection_update_DM_AP + + See also + -------- + basic_fourier_update_LEGACY + """ + if LL_error: + err_phot = log_likelihood(diff_view) + else: + err_phot = 0.0 + + err_fmag, err_exit = projection_update_DM_AP(diff_view, alpha=alpha, pbound=pbound) + + return np.array([err_fmag, err_phot, err_exit]) + + +def basic_fourier_update_LEGACY(diff_view, pbound=None, alpha=1., LL_error=True): + """ + *** DEPRECATED *** Fourier update a single view using its associated pods. Updates on all pods' exit waves. @@ -134,8 +356,8 @@ def basic_fourier_update(diff_view, pbound=None, alpha=1., LL_error=True): for name, pod in diff_view.pods.items(): if not pod.active: continue - f[name] = pod.fw((1 + alpha) * pod.probe * pod.object - - alpha * pod.exit) + f[name] = pod.fw(-alpha * pod.exit+ + (1 + alpha) * pod.probe * pod.object) af2 += pod.downsample(u.abs2(f[name])) fmag = np.sqrt(np.abs(I)) @@ -152,7 +374,7 @@ def basic_fourier_update(diff_view, pbound=None, alpha=1., LL_error=True): for name, pod in diff_view.pods.items(): if not pod.active: continue - df = pod.bw(pod.upsample(fm) * f[name]) - pod.probe * pod.object + df = pod.bw(pod.upsample(fm) * f[name]) - alpha * pod.probe * pod.object + (alpha - 1) * pod.exit pod.exit += df err_exit += np.mean(u.abs2(df)) elif err_fmag > pbound: @@ -162,7 +384,7 @@ def basic_fourier_update(diff_view, pbound=None, alpha=1., LL_error=True): for name, pod in diff_view.pods.items(): if not pod.active: continue - df = pod.bw(pod.upsample(fm) * f[name]) - pod.probe * pod.object + df = pod.bw(pod.upsample(fm) * f[name]) - alpha * pod.probe * pod.object + (alpha - 1) * pod.exit pod.exit += df err_exit += np.mean(u.abs2(df)) else: @@ -170,7 +392,7 @@ def basic_fourier_update(diff_view, pbound=None, alpha=1., LL_error=True): for name, pod in diff_view.pods.items(): if not pod.active: continue - df = alpha * (pod.probe * pod.object - pod.exit) + df = (pod.probe * pod.object - pod.exit) pod.exit += df err_exit += np.mean(u.abs2(df)) @@ -181,24 +403,26 @@ def reduce_dimension(a, dim, local_indices=None): """ Apply a low-rank approximation on a. - :param a: - 3D numpy array. + Parameters + ---------- + a : ndarray + 3D numpy array - :param dim: - The number of dimensions to retain. The case dim=0 (which would - just reduce all layers to a mean) is not implemented. + dim : int + The number of dimensions to retain. The case dim=0 (which would + just reduce all layers to a mean) is not implemented. - :param local_indices: - Used for Containers distributed across nodes. Local indices of - the current node. + local_indices : + Used for Containers distributed across nodes. Local indices of + the current node. - :return: [reduced array, modes, coefficients] - Where: - - reduced array is the result of dimensionality reduction - (same shape as a) - - modes: 3D array of length dim containing eigenmodes - (aka singular vectors) - - coefficients: 2D matrix representing the decomposition of a. + Returns + ------- + reduced array, modes, coefficients : + where: + - reduced array is the result of dimensionality reduction (same shape as a) + - modes: 3D array of length dim containing eigenmodes (aka singular vectors) + - coefficients: 2D matrix representing the decomposition of a. """ if local_indices is None: # No MPI - generate a list of indices Nl = len(a) @@ -285,7 +509,7 @@ def reduce_dimension(a, dim, local_indices=None): def Cnorm2(c): - """\ + """ Computes a norm2 on whole container `c`. :param Container c: Input @@ -302,7 +526,7 @@ def Cnorm2(c): def Cdot(c1, c2): - """\ + """ Compute the dot product on two containers `c1` and `c2`. No check is made to ensure they are of the same kind. diff --git a/ptypy/experiment/__init__.py b/ptypy/experiment/__init__.py index f587d86f0..4838e9186 100644 --- a/ptypy/experiment/__init__.py +++ b/ptypy/experiment/__init__.py @@ -47,32 +47,3 @@ def _register_PtyScan_class(cls, name=None): globals()[name] = cls __all__.append(name) return cls - - -ptyscan_modules = [('.hdf5_loader', 'Hdf5Loader'), - ('.cSAXS', 'cSAXSScan'), - ('.savu', 'Savu'), - ('.plugin', 'makeScanPlugin'), - ('.ID16Anfp', 'ID16AScan'), - ('.AMO_LCLS', 'AMOScan'), - ('.DiProI_FERMI', 'DiProIFERMIScan'), - ('.optiklabor', 'FliSpecScanMultexp'), - ('.UCL', 'UCLLaserScan'), - ('.nanomax', 'NanomaxStepscanNov2018'), - ('.nanomax', 'NanomaxFlyscanMay2019'), - ('.nanomax', 'NanomaxStepscanSep2019'), - ('.nanomax', 'NanomaxContrast'), - ('.nanomax_streaming', 'NanomaxZmqScan'), - ('.ALS_5321', 'ALS5321Scan'), - ('.Bragg3dSim', 'Bragg3dSimScan')] - -for module, obj in ptyscan_modules: - try: - lib = import_module(module, 'ptypy.experiment') - except ImportError as exception: - log(2, 'Could not import experiment %s from %s, Reason: %s' % (obj, module, exception)) - pass - else: - globals()[obj] = lib.__dict__[obj] - - diff --git a/ptypy/experiment/diamond_nexus.py b/ptypy/experiment/diamond_nexus.py index 1cb72c000..f00cac086 100644 --- a/ptypy/experiment/diamond_nexus.py +++ b/ptypy/experiment/diamond_nexus.py @@ -214,7 +214,7 @@ def __init__(self, pars=None, **kwargs): if None not in [INPUT_FILE, ENERGY_KEY]: - self.p.energy = np.float(h5.File(INPUT_FILE, 'r')[ENERGY_KEY][()] * self.ENERGY_MULTIPLIER) + self.p.energy = float(h5.File(INPUT_FILE, 'r')[ENERGY_KEY][()] * self.ENERGY_MULTIPLIER) self.meta.energy = self.p.energy log(3, "loading energy={} from file".format(self.p.energy)) @@ -257,16 +257,16 @@ def __init__(self, pars=None, **kwargs): log(3, "The loader will not do any cropping.") # it's much better to have this logic here than in load! - if (self._ismapped and (self._scantype is 'arb')): + if (self._ismapped and (self._scantype == 'arb')): # easy peasy log(3, "This scan looks to be a mapped arbitrary trajectory scan.") self.load = self.load_mapped_and_arbitrary_scan - if (self._ismapped and (self._scantype is 'raster')): + if (self._ismapped and (self._scantype == 'raster')): log(3, "This scan looks to be a mapped raster scan.") self.load = self.loaded_mapped_and_raster_scan - if (self._scantype is 'raster') and not self._ismapped: + if (self._scantype == 'raster') and not self._ismapped: log(3, "This scan looks to be an unmapped raster scan.") self.load = self.load_unmapped_raster_scan @@ -349,7 +349,7 @@ def get_corrected_intensities(self, index): else: mask = self.mask[self.frame_slices].squeeze() else: - mask = np.ones_like(intensity, dtype=np.int) + mask = np.ones_like(intensity, dtype=int) return mask, intensity diff --git a/ptypy/experiment/hdf5_loader.py b/ptypy/experiment/hdf5_loader.py index 95779f015..6a47b7857 100644 --- a/ptypy/experiment/hdf5_loader.py +++ b/ptypy/experiment/hdf5_loader.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- """\ -Scan loading recipe for the I13 beamline, Diamond. +Scan loading recipe for the Diamond beamlines. This file is part of the PTYPY package. @@ -14,9 +14,12 @@ from ptypy import utils as u from ptypy.core.data import PtyScan from ptypy.experiment import register +from ptypy.utils import parallel from ptypy.utils.verbose import log from ptypy.utils.array_utils import _translate_to_pix +import os +from multiprocessing import Pool, RawArray @register() class Hdf5Loader(PtyScan): @@ -317,6 +320,12 @@ class Hdf5Loader(PtyScan): type = int default = None help = Index for outer dimension (e.g. tomography, spectro scans), default is None. + + [padding] + type = int, tuple, list + default = None + help = Option to pad the detector frames on all sides + doc = A tuple of list with padding given as ( top, bottom, left, right) """ @@ -372,9 +381,10 @@ def __init__(self, pars=None, **kwargs): log(3, "This is appears to be a spectro scan, selecting index = {}".format(self.p.outer_index)) self.intensities = h5.File(self.p.intensities.file, 'r')[self.p.intensities.key] - if self._is_spectro_scan and self.p.outer_index is not None: - self.intensities = self.intensities[self.p.outer_index] + self.intensities_dtype = self.intensities.dtype data_shape = self.intensities.shape + if self._is_spectro_scan and self.p.outer_index is not None: + data_shape = tuple(np.array(data_shape)[1:]) fast_axis = h5.File(self.p.positions.file, 'r')[self.p.positions.fast_key][...] if self._is_spectro_scan and self.p.outer_index is not None: @@ -397,7 +407,9 @@ def __init__(self, pars=None, **kwargs): log(3, "Skipping every {:d} positions".format(self.p.positions.skip)) if None not in [self.p.framefilter.file, self.p.framefilter.key]: - self.framefilter = h5.File(self.p.framefilter.file, 'r')[self.p.framefilter.key] + self.framefilter = h5.File(self.p.framefilter.file, 'r')[self.p.framefilter.key][()].squeeze() > 0 # turn into boolean + if self._is_spectro_scan and self.p.outer_index is not None: + self.framefilter = self.framefilter[self.p.outer_index] if (self.framefilter.shape == self.fast_axis.shape == self.slow_axis.shape): log(3, "The frame filter has the same dimensionality as the axis information.") elif self.framefilter.shape[:2] == self.fast_axis.shape == self.slow_axis.shape: @@ -439,6 +451,7 @@ def __init__(self, pars=None, **kwargs): if None not in [self.p.mask.file, self.p.mask.key]: self.mask = h5.File(self.p.mask.file, 'r')[self.p.mask.key] + self.mask_dtype = self.mask.dtype log(3, "The mask has shape: {}".format(self.mask.shape)) if self.mask.shape == data_shape: log(3, "The mask is laid out like the data.") @@ -449,6 +462,7 @@ def __init__(self, pars=None, **kwargs): else: raise RuntimeError("I have no idea what to do with this shape of mask data.") else: + self.mask_dtype = np.int64 log(3, "No mask will be applied.") @@ -469,31 +483,39 @@ def __init__(self, pars=None, **kwargs): if None not in [self.p.recorded_energy.file, self.p.recorded_energy.key]: if self._is_spectro_scan and self.p.outer_index is not None: - self.p.energy = np.float(h5.File(self.p.recorded_energy.file, 'r')[self.p.recorded_energy.key][self.p.outer_index]) + self.p.energy = float(h5.File(self.p.recorded_energy.file, 'r')[self.p.recorded_energy.key][self.p.outer_index]) else: - self.p.energy = np.float(h5.File(self.p.recorded_energy.file, 'r')[self.p.recorded_energy.key][()]) + self.p.energy = float(h5.File(self.p.recorded_energy.file, 'r')[self.p.recorded_energy.key][()]) self.p.energy = self.p.energy * self.p.recorded_energy.multiplier + self.p.recorded_energy.offset self.meta.energy = self.p.energy log(3, "loading energy={} from file".format(self.p.energy)) if None not in [self.p.recorded_distance.file, self.p.recorded_distance.key]: - self.p.distance = np.float(h5.File(self.p.recorded_distance.file, 'r')[self.p.recorded_distance.key][()] * self.p.recorded_distance.multiplier) + self.p.distance = float(h5.File(self.p.recorded_distance.file, 'r')[self.p.recorded_distance.key][()] * self.p.recorded_distance.multiplier) self.meta.distance = self.p.distance log(3, "loading distance={} from file".format(self.p.distance)) if None not in [self.p.recorded_psize.file, self.p.recorded_psize.key]: - self.p.psize = np.float(h5.File(self.p.recorded_psize.file, 'r')[self.p.recorded_psize.key][()] * self.p.recorded_psize.multiplier) + self.p.psize = float(h5.File(self.p.recorded_psize.file, 'r')[self.p.recorded_psize.key][()] * self.p.recorded_psize.multiplier) self.meta.psize = self.p.psize log(3, "loading psize={} from file".format(self.p.psize)) + if self.p.padding is None: + self.pad = np.array([0,0,0,0]) + log(3, "No padding will be applied.") + else: + self.pad = np.array(self.p.padding, dtype=int) + assert self.pad.size == 4, "self.p.padding needs to of size 4" + log(3, "Padding the detector frames by {}".format(self.p.padding)) # now lets figure out the cropping and centering roughly so we don't load the full data in. - frame_shape = np.array(data_shape[-2:]) + frame_shape = np.array(data_shape[-2:]) + self.pad.reshape(2,2).sum(1) center = frame_shape // 2 if self.p.center is None else u.expect2(self.p.center) center = np.array([_translate_to_pix(frame_shape[ix], center[ix]) for ix in range(len(frame_shape))]) if self.p.shape is None: self.frame_slices = (slice(None, None, 1), slice(None, None, 1)) + self.frame_shape = data_shape[-2:] self.p.shape = frame_shape log(3, "Loading full shape frame.") elif self.p.shape is not None and not self.p.auto_center: @@ -501,30 +523,31 @@ def __init__(self, pars=None, **kwargs): low_pix = center - pshape // 2 high_pix = low_pix + pshape self.frame_slices = (slice(int(low_pix[0]), int(high_pix[0]), 1), slice(int(low_pix[1]), int(high_pix[1]), 1)) + self.frame_shape = self.p.shape self.p.center = pshape // 2 #the new center going forward self.info.center = self.p.center self.p.shape = pshape log(3, "Loading in frame based on a center in:%i, %i" % tuple(center)) else: self.frame_slices = (slice(None, None, 1), slice(None, None, 1)) + self.frame_shape = data_shape[-2:] self.info.center = None self.info.auto_center = self.p.auto_center log(3, "center is %s, auto_center: %s" % (self.info.center, self.info.auto_center)) - log(3, "The loader will not do any cropping.") # it's much better to have this logic here than in load! - if (self._ismapped and (self._scantype is 'arb')): + if (self._ismapped and (self._scantype == 'arb')): # easy peasy log(3, "This scan looks to be a mapped arbitrary trajectory scan.") self.load = self.load_mapped_and_arbitrary_scan - if (self._ismapped and (self._scantype is 'raster')): + if (self._ismapped and (self._scantype == 'raster')): log(3, "This scan looks to be a mapped raster scan.") - self.load = self.loaded_mapped_and_raster_scan + self.load = self.load_mapped_and_raster_scan - if (self._scantype is 'raster') and not self._ismapped: + if (self._scantype == 'raster') and not self._ismapped: log(3, "This scan looks to be an unmapped raster scan.") self.load = self.load_unmapped_raster_scan @@ -542,7 +565,7 @@ def load_unmapped_raster_scan(self, indices): log(3, 'Data loaded successfully.') return intensities, positions, weights - def loaded_mapped_and_raster_scan(self, indices): + def load_mapped_and_raster_scan(self, indices): intensities = {} positions = {} weights = {} @@ -572,12 +595,14 @@ def get_corrected_intensities(self, index): ''' Corrects the intensities for darkfield, flatfield and normalisations if they exist. There is a lot of logic here, I wonder if there is a better way to get rid of it. - Limited a bit by the MPI, adn thinking about extension to large data size. + Limited a bit by the MPI, and thinking about extension to large data size. ''' if not hasattr(index, '__iter__'): index = (index,) indexed_frame_slices = tuple([slice(ix, ix+1, 1) for ix in index]) indexed_frame_slices += self.frame_slices + if self._is_spectro_scan and self.p.outer_index is not None: + indexed_frame_slices = (self.p.outer_index,) + indexed_frame_slices intensity = self.intensities[indexed_frame_slices].squeeze() # TODO: Remove these logic blocks into something a bit more sensible. @@ -607,7 +632,12 @@ def get_corrected_intensities(self, index): else: mask = self.mask[self.frame_slices].squeeze() else: - mask = np.ones_like(intensity, dtype=np.int) + mask = np.ones_like(intensity, dtype=int) + + if self.p.padding: + intensity = np.pad(intensity, tuple(self.pad.reshape(2,2)), mode='constant') + mask = np.pad(mask, tuple(self.pad.reshape(2,2)), mode='constant') + return mask, intensity @@ -765,3 +795,207 @@ def compute_scan_mapping_and_trajectory(self, data_shape, positions_fast_shape, else: raise IOError("I don't know what to do with these positions/data shapes") + +@register() +class Hdf5LoaderFast(Hdf5Loader): + def __init__(self, pars=None, **kwargs): + super().__init__(pars=pars, **kwargs) + self.cpu_count_per_rank = max(os.cpu_count() // parallel.size,1) + print("Rank %d has access to %d processes" %(parallel.rank, self.cpu_count_per_rank)) + self.intensities_array = None + self.weights_array = None + + @staticmethod + def _init_worker(intensities_raw_array, weights_raw_array, + intensities_handle, + weights_handle, + darkfield_handle, + flatfield_handle, + intensities_dtype, weights_dtype, + array_shape, + mask_laid_out_like_data, + darkfield_laid_out_like_data, + flatfield_laid_out_like_data): + Hdf5LoaderFast.worker_intensities_handle = intensities_handle + Hdf5LoaderFast.worker_intensities_array = np.frombuffer(intensities_raw_array, intensities_dtype, -1).reshape(array_shape) + Hdf5LoaderFast.worker_weights_handle = weights_handle + Hdf5LoaderFast.worker_weights_array = np.frombuffer(weights_raw_array, weights_dtype, -1).reshape(array_shape) if weights_raw_array else None + Hdf5LoaderFast.worker_mask_laid_out_like_data = mask_laid_out_like_data + Hdf5LoaderFast.worker_darkfield_handle = darkfield_handle + Hdf5LoaderFast.worker_darkfield_laid_out_like_data = darkfield_laid_out_like_data + Hdf5LoaderFast.worker_flatfield_handle = flatfield_handle + Hdf5LoaderFast.worker_flatfield_laid_out_like_data = flatfield_laid_out_like_data + + @staticmethod + def _read_intensities_and_weights(slices): + ''' + Copy intensities/weights into memory and correct for + darkfield/flatfield if they exist + ''' + indexed_frame_slices, dest_slices = slices + frame_slices = tuple(np.array(indexed_frame_slices)[-2:]) + + # Handle / target array for intensities + src_intensities = Hdf5LoaderFast.worker_intensities_handle + dest_intensities = Hdf5LoaderFast.worker_intensities_array + + # Handle / target array for mask/weights + src_weights = Hdf5LoaderFast.worker_weights_handle + dest_weights = Hdf5LoaderFast.worker_weights_array + mask_laid_out_like_data = Hdf5LoaderFast.worker_mask_laid_out_like_data + + # Handle for darkfield + src_darkfield = Hdf5LoaderFast.worker_darkfield_handle + darkfield_laid_out_like_data = Hdf5LoaderFast.worker_darkfield_laid_out_like_data + + # Handle for flatfield + src_flatfield = Hdf5LoaderFast.worker_flatfield_handle + flatfield_laid_out_like_data = Hdf5LoaderFast.worker_flatfield_laid_out_like_data + + # Copy intensities and weights + src_intensities.read_direct(dest_intensities, indexed_frame_slices, dest_slices) + if src_weights is not None: + if mask_laid_out_like_data: + src_weights.read_direct(dest_weights, indexed_frame_slices, dest_slices) + else: + src_weights.read_direct(dest_weights, frame_slices, dest_slices) + + # Correct darkfield + if src_darkfield is not None: + if darkfield_laid_out_like_data: + dest_intensities[dest_slices] -= src_darkfield[indexed_frame_slices].squeeze() + else: + dest_intensities[dest_slices] -= src_darkfield[frame_slices].squeeze() + + # Correct flatfield + if src_flatfield is not None: + if flatfield_laid_out_like_data: + dest_intensities[dest_slices] /= src_flatfield[indexed_frame_slices].squeeze() + else: + dest_intensities[dest_slices] /= src_flatfield[frame_slices].squeeze() + + def _setup_raw_intensity_buffer(self, dtype, sh): + npixels = int(np.prod(sh)) + if (self.intensities_array is not None) and (self.intensities_array.size == npixels): + return + self._intensities_raw_array = RawArray(np.ctypeslib.as_ctypes_type(dtype), npixels) + self.intensities_array = np.frombuffer(self._intensities_raw_array, self.intensities_dtype, -1).reshape(sh) + + def _setup_raw_weights_buffer(self, dtype, sh): + npixels = int(np.prod(sh)) + if (self.weights_array is not None) and (self.weights_array.size == npixels): + return + if self.mask is not None: + self._weights_raw_array = RawArray(np.ctypeslib.as_ctypes_type(dtype), npixels) + self.weights_array = np.frombuffer(self._weights_raw_array, dtype, -1).reshape(sh) + else: + self._weights_raw_array = None + self.weights_array = np.ones(sh, dtype=int) + + def load_multiprocessing(self, src_slices): + sh = (len(src_slices),) + self.frame_shape + self._setup_raw_intensity_buffer(self.intensities_dtype, sh) + self._setup_raw_weights_buffer(self.mask_dtype, sh) + dest_slices = [np.s_[i:i+1] for i in range(len(src_slices))] + + with Pool(self.cpu_count_per_rank, + initializer=Hdf5LoaderFast._init_worker, + initargs=(self._intensities_raw_array, self._weights_raw_array, + self.intensities, self.mask, self.darkfield, self.flatfield, + self.intensities_dtype, self.mask_dtype, + sh, self.mask_laid_out_like_data, + self.darkfield_laid_out_like_data, + self.flatfield_field_laid_out_like_data)) as p: + p.map(self._read_intensities_and_weights, zip(src_slices, dest_slices)) + + def load_unmapped_raster_scan(self, indices): + + slices = [] + for ii in indices: + slow_idx, fast_idx = self.preview_indices[:, ii] + jj = slow_idx * self.slow_axis.shape[1] + fast_idx + indexed_frame_slices = (jj,) + indexed_frame_slices += self.frame_slices + if self._is_spectro_scan and self.p.outer_index is not None: + indexed_frame_slices = (self.p.outer_index,) + indexed_frame_slices + slices.append(indexed_frame_slices) + + self.load_multiprocessing(slices) + + intensities = {} + positions = {} + weights = {} + for k,ii in enumerate(indices): + slow_idx, fast_idx = self.preview_indices[:,ii] + weights[ii], intensities[ii] = self.get_corrected_intensities(self.weights_array[k], self.intensities_array[k], ii, slices[k]) + positions[ii] = np.array([self.slow_axis[slow_idx, fast_idx] * self.p.positions.slow_multiplier, + self.fast_axis[slow_idx, fast_idx] * self.p.positions.fast_multiplier]) + log(3, 'Data loaded successfully.') + return intensities, positions, weights + + def load_mapped_and_raster_scan(self, indices): + + slices = [] + for ii in indices: + index = self.preview_indices[:, ii] + indexed_frame_slices = tuple(index) + indexed_frame_slices += self.frame_slices + if self._is_spectro_scan and self.p.outer_index is not None: + indexed_frame_slices = (self.p.outer_index,) + indexed_frame_slices + slices.append(indexed_frame_slices) + + self.load_multiprocessing(slices) + + intensities = {} + positions = {} + weights = {} + for k,ii in enumerate(indices): + slow_idx, fast_idx = self.preview_indices[:, ii] + weights[ii], intensities[ii] = self.get_corrected_intensities(self.weights_array[k], self.intensities_array[k], ii, slices[k]) + positions[ii] = np.array([self.slow_axis[slow_idx, fast_idx] * self.p.positions.slow_multiplier, + self.fast_axis[slow_idx, fast_idx] * self.p.positions.fast_multiplier]) + log(3, 'Data loaded successfully.') + return intensities, positions, weights + + def load_mapped_and_arbitrary_scan(self, indices): + + slices = [] + for ii in indices: + jj = self.preview_indices[ii] + indexed_frame_slices = (jj,) + indexed_frame_slices += self.frame_slices + if self._is_spectro_scan and self.p.outer_index is not None: + indexed_frame_slices = (self.p.outer_index,) + indexed_frame_slices + slices.append(indexed_frame_slices) + + self.load_multiprocessing(slices) + + intensities = {} + positions = {} + weights = {} + for k,ii in enumerate(indices): + jj = self.preview_indices[ii] + weights[ii], intensities[ii] = self.get_corrected_intensities(self.weights_array[k], self.intensities_array[k], ii, slices[k]) + positions[ii] = np.array([self.slow_axis[jj] * self.p.positions.slow_multiplier, + self.fast_axis[jj] * self.p.positions.fast_multiplier]) + log(3, 'Data loaded successfully.') + return intensities, positions, weights + + def get_corrected_intensities(self, weights, intensities, index, indexed_frame_slice): + ''' + Corrects the intensities for normalisation and padding + ''' + + if self.normalisation is not None: + if self.normalisation_laid_out_like_positions: + scale = self.normalisation[index] + else: + scale = np.squeeze(self.normalisation[indexed_frame_slice]) + if np.abs(scale - self.normalisation_mean) < (self.p.normalisation.sigma * self.normalisation_std): + intensities *= 1 / (scale * self.normalisation_mean) + + if self.p.padding: + intensities = np.pad(intensities, tuple(self.pad.reshape(2,2)), mode='constant') + weights = np.pad(weights, tuple(self.pad.reshape(2,2)), mode='constant') + + return weights, intensities \ No newline at end of file diff --git a/ptypy/experiment/nanomax.py b/ptypy/experiment/nanomax.py index 395a09c18..f3fef13d2 100644 --- a/ptypy/experiment/nanomax.py +++ b/ptypy/experiment/nanomax.py @@ -616,7 +616,7 @@ def load_positions(self): if self.info.I0 is not None: with h5py.File(fullfilename, 'r') as hf: normdata = np.array(hf['%s/measurement/%s' % (entry, self.info.I0)], dtype=float) - normdata = normdata[self.firstLine:self.lastLine+1, :Nsteps].flatten() + normdata = normdata[self.firstLine:self.lastLine+1, :Nsteps].flatten() # noqa: F821 self.normdata = normdata / np.mean(normdata) logger.info('*** going to normalize by channel %s - loaded %d values' % (self.info.I0, len(self.normdata))) diff --git a/ptypy/experiment/optiklabor.py b/ptypy/experiment/optiklabor.py index 79f69242d..96e757067 100644 --- a/ptypy/experiment/optiklabor.py +++ b/ptypy/experiment/optiklabor.py @@ -186,20 +186,20 @@ def correct(self, raw, weights, common): return data, weights -if __name__ == '__main__': - u.verbose.set_level(3) - RS = RawScan(p,num_frames=50,roi=512 ) - RS.initialize() - RS.report() - print('loading data') - msg = True - for i in range(200): - if msg is False: - break - time.sleep(1) - msg = RS.auto(10) - logger.info(u.verbose.report(msg), extra={'allprocesses': True}) - u.parallel.barrier() +# if __name__ == '__main__': +# u.verbose.set_level(3) +# RS = RawScan(p,num_frames=50,roi=512 ) +# RS.initialize() +# RS.report() +# print('loading data') +# msg = True +# for i in range(200): +# if msg is False: +# break +# time.sleep(1) +# msg = RS.auto(10) +# logger.info(u.verbose.report(msg), extra={'allprocesses': True}) +# u.parallel.barrier() #RS.report() #%RS.load_raw([0,1,2]) diff --git a/ptypy/experiment/spec.py b/ptypy/experiment/spec.py index c1ef67d80..142d3a3da 100644 --- a/ptypy/experiment/spec.py +++ b/ptypy/experiment/spec.py @@ -28,7 +28,7 @@ class SpecScan(object): class SpecInfo(object): def __init__(self, spec_filename): self.spec_filename = spec_filename - self.spec_file = file(spec_filename,'r') + self.spec_file = open(spec_filename,'r') self.scans = {} self.parse() global lastSpecInfo @@ -166,7 +166,7 @@ def parse(self, rehash=False): scans[scannr] = scan self.scans = scans -""" +r""" assert scannr > 0 assert burst > 0 assert multexp > 0 diff --git a/ptypy/io/edfIO.py b/ptypy/io/edfIO.py index f16a04c1b..29b2e123e 100644 --- a/ptypy/io/edfIO.py +++ b/ptypy/io/edfIO.py @@ -125,7 +125,7 @@ def readData(filenameprefix,imgstart=0,imgnumber = 1,xi = 0, xf = 0, bin_fact = meta = [] if multiple == 1: headerlength=2048 - if (rowTo < rowFrom and rowTo is not 0): + if (rowTo < rowFrom and rowTo != 0): raise ValueError('The last row has to be equal or larger than the first row.\n') for imgnum in range(imgnumber): filename = filenameprefix + '_' + utils.num2str(imgstart,'%04d') + '_' + utils.num2str(imgnum,'%04d') + '.edf' diff --git a/ptypy/io/h5rw.py b/ptypy/io/h5rw.py index 61a8e0f74..c786c2d88 100644 --- a/ptypy/io/h5rw.py +++ b/ptypy/io/h5rw.py @@ -169,23 +169,23 @@ def _store_dict(group, d, name): pop_id(id(d)) return dset - # @sdebug - def _store_ordered_dict(group, d, name): - check_id(id(d)) - if any([type(k) not in [str,] for k in d.keys()]): - raise RuntimeError('Only dictionaries with string keys are supported.') - dset = group.create_group(name) - dset.attrs['type'] = 'ordered_dict' - for k, v in d.items(): - if k.find('/') > -1: - k = k.replace('/', h5options['SLASH_ESCAPE']) - ndset = _store(dset, v, k) - if ndset is not None: - ndset.attrs['escaped'] = '1' - else: - _store(dset, v, k) - pop_id(id(d)) - return dset + # # @sdebug + # def _store_ordered_dict(group, d, name): + # check_id(id(d)) + # if any([type(k) not in [str,] for k in d.keys()]): + # raise RuntimeError('Only dictionaries with string keys are supported.') + # dset = group.create_group(name) + # dset.attrs['type'] = 'ordered_dict' + # for k, v in d.items(): + # if k.find('/') > -1: + # k = k.replace('/', h5options['SLASH_ESCAPE']) + # ndset = _store(dset, v, k) + # if ndset is not None: + # ndset.attrs['escaped'] = '1' + # else: + # _store(dset, v, k) + # pop_id(id(d)) + # return dset # @sdebug def _store_param(group, d, name): @@ -231,7 +231,7 @@ def _store(group, a, name): elif type(a) is dict: dset = _store_dict(group, a, name) elif type(a) is OrderedDict: - dset = _store_ordered_dict(group, a, name) + dset = _store_dict(group, a, name) elif type(a) is Param: dset = _store_param(group, a, name) elif type(a) is list: @@ -432,14 +432,14 @@ def _load_scalar(dset): except: return dset[...] - def _load_ordered_dict(dset, depth): - d = OrderedDict() - if depth > 0: - for k, v in dset.items(): - if v.attrs.get('escaped', None) is not None: - k = k.replace(h5options['SLASH_ESCAPE'], '/') - d[k] = _load(v, depth - 1) - return d + # def _load_ordered_dict(dset, depth): + # d = OrderedDict() + # if depth > 0: + # for k, v in dset.items(): + # if v.attrs.get('escaped', None) is not None: + # k = k.replace(h5options['SLASH_ESCAPE'], '/') + # d[k] = _load(v, depth - 1) + # return d def _load_str(dset): if h5py.version.version_tuple[0]>2: @@ -480,7 +480,7 @@ def _load(dset, depth, sl=None): if sl is not None: val = val[sl] elif dset_type == 'ordered_dict': - val = _load_ordered_dict(dset, depth) + val = _load_dict(dset, depth) elif dset_type == 'array': val = _load_numpy(dset, sl) elif dset_type == 'arraylist': @@ -609,7 +609,7 @@ def _format_list(d, key, dset): stringout += _format(d - 1, (key[0] + indent, ''), dset[k]) return stringout - def _format_tuple(key, dset): + def _format_tuple(d, key, dset): stringout = ' ' * key[0] + ' * %s [tuple]:\n' % key[1] if d > 0: keys = list(dset.keys()) @@ -620,15 +620,12 @@ def _format_tuple(key, dset): def _format_arraytuple(key, dset): a = dset[...] - if len(a) < 5: + if len(a) < 5 and a.ndim==1: stringout = ' ' * key[0] + ' * ' + key[1] + ' [tuple = ' + str(tuple(a.ravel())) + ']\n' else: - try: - float(a.ravel()[0]) - stringout = ' ' * key[0] + ' * ' + key[1] + ' [tuple = (' + ( - ('%f, ' * 4) % tuple(a.ravel()[:4])) + ' ...)]\n' - except ValueError: - stringout = ' ' * key[0] + ' * ' + key[1] + ' [tuple = (%d x %s objects)]\n' % (a.size, str(a.dtype)) + stringout = ' ' * key[0] + ' * ' + key[1] + \ + ' [tuple = ' + str(len(a)) + 'x[' + (('%dx' * (a[0].ndim - 1) + '%d') % a[0].shape) + \ + ' ' + str(a.dtype) + ' array]]\n' return stringout def _format_arraylist(key, dset): @@ -686,7 +683,7 @@ def _format(d, key, dset): if (dset_type is None) and (type(dset) is h5py.Group): dset_type = 'dict' - if dset_type == 'dict': + if dset_type == 'dict' or dset_type == 'ordered_dict': stringout = _format_dict(d, key, dset, False) elif dset_type == 'param': stringout = _format_dict(d, key, dset, True) diff --git a/ptypy/io/interaction.py b/ptypy/io/interaction.py index 884619588..07c3da537 100644 --- a/ptypy/io/interaction.py +++ b/ptypy/io/interaction.py @@ -83,7 +83,7 @@ def default(self, obj): NE = NumpyEncoder() # This is the string to match against when decoding -NPYARRAYmatch = re.compile("NPYARRAY\[([0-9]{3})\]") +NPYARRAYmatch = re.compile(r"NPYARRAY\[([0-9]{3})\]") def numpy_replace(obj, arraylist): diff --git a/ptypy/io/rawIO.py b/ptypy/io/rawIO.py index 8cdca3891..df9dabe95 100644 --- a/ptypy/io/rawIO.py +++ b/ptypy/io/rawIO.py @@ -73,7 +73,7 @@ def rawread(filename, doglob=None, roi=None): return dat,meta def _read(filename,dtype): - f=file(filename) + f=open(filename) header = [] header.append(f.readline()) diff --git a/ptypy/resources/__init__.py b/ptypy/resources/__init__.py index f0872bb1c..50bab0b5e 100644 --- a/ptypy/resources/__init__.py +++ b/ptypy/resources/__init__.py @@ -1,4 +1,5 @@ import pkg_resources +import numpy as np flowerfile = pkg_resources.resource_filename(__name__,'flowers.png') moonfile = pkg_resources.resource_filename(__name__,'moon.png') diff --git a/ptypy/resources/default_parameters_configparser.txt b/ptypy/resources/default_parameters_configparser.txt index 2199ceb9b..8dded064f 100644 --- a/ptypy/resources/default_parameters_configparser.txt +++ b/ptypy/resources/default_parameters_configparser.txt @@ -150,6 +150,21 @@ doc = userlevel = 2 type = float +[engine.DM.probe_update_cuda_atomics] +help = For GPU, use the atomics version for probe updates kernel +default = False +type = bool +userlevel = 2 +doc = + +[engine.DM.object_update_cuda_atomics] +help = For GPU, use the atomics version for object updates kernel +default = True +type = bool +userlevel = 2 +doc = + + [engine.common] help = Parameters common to all engines default = None diff --git a/ptypy/resources/parameter_descriptions.configparser b/ptypy/resources/parameter_descriptions.configparser index 40980781e..8a54e0966 100644 --- a/ptypy/resources/parameter_descriptions.configparser +++ b/ptypy/resources/parameter_descriptions.configparser @@ -1088,6 +1088,21 @@ type = int userlevel = 2 lowlim = 0 +[engine.DM.object_update_cuda_atomics] +help = For GPU, use the atomics version for object update kernel +default = True +type = bool +userlevel = 2 +doc = + +[engine.DM.probe_update_cuda_atomics] +help = For GPU, use the atomics version for probe update kernel +default = False +type = bool +userlevel = 2 +doc = + + [engine.ML] default = help = Maximum Likelihood parameters diff --git a/ptypy/simulations/detector.py b/ptypy/simulations/detector.py index 05742785b..4228b1579 100644 --- a/ptypy/simulations/detector.py +++ b/ptypy/simulations/detector.py @@ -272,4 +272,4 @@ def smooth_step(x,mfs): plt.imshow(A) plt.figure() - plt.imshow(log10(D.expose(I[1])[0]+1)) + plt.imshow(np.log10(D.expose(I[1])[0]+1)) diff --git a/ptypy/simulations/ptysim_utils.py b/ptypy/simulations/ptysim_utils.py index 4f1179b99..1fbc5d0d4 100644 --- a/ptypy/simulations/ptysim_utils.py +++ b/ptypy/simulations/ptysim_utils.py @@ -37,7 +37,7 @@ def exp_positions(positions, drift=0.0,scale= 0.0,noise=0.0): return pos -def make_sim_datasource(model_inst,drift=0.0,scale= 0.0,noise=0.0): +""" def make_sim_datasource(model_inst,drift=0.0,scale= 0.0,noise=0.0): labels=[] sources =[] @@ -71,7 +71,7 @@ def framepositions(pos_pixel,probe_shape,frame_overhead=(10,10)): pos_pixel += np.round(w.expect2(frame_overhead) /2) positions = [(p[0],p[0]+probe_shape[0],p[1],p[1]+probe_shape[1]) for p in pos_pixel] - return shape,positions + return shape,positions """ def augment_to_coordlist(a,Npos): diff --git a/ptypy/simulations/simscan.py b/ptypy/simulations/simscan.py index 9e7ca414e..796cefed4 100644 --- a/ptypy/simulations/simscan.py +++ b/ptypy/simulations/simscan.py @@ -249,32 +249,32 @@ def manipulate_ptycho(self, ptycho): return ptycho -if __name__ == "__main__": - from ptypy import resources +# if __name__ == "__main__": +# from ptypy import resources - s = scan_DEFAULT.copy() - s.xy.model = "round" - s.xy.spacing = 1e-6 - s.xy.steps = 8 - s.xy.extent = 5e-6 - shape = 256 - s.geometry.energy = 6.2 - s.geometry.lam = None - s.geometry.distance = 7 - s.geometry.psize = 172e-6 - s.geometry.shape = shape - s.geometry.propagation = "farfield" - s.illumination = resources.moon_pr((shape,shape))*1e2 - s.sample = resources.flower_obj((shape*2,shape*2)) - - - u.verbose.set_level(3) - MS = SimScan(None,s) - #MS.P.plot_overview() - u.verbose.set_level(3) - u.pause(10) - MS.initialize() - for i in range(20): - msg = MS.auto(10) - u.verbose.logger.info(u.verbose.report(msg), extra={'allprocesses': True}) - u.parallel.barrier() +# s = scan_DEFAULT.copy() +# s.xy.model = "round" +# s.xy.spacing = 1e-6 +# s.xy.steps = 8 +# s.xy.extent = 5e-6 +# shape = 256 +# s.geometry.energy = 6.2 +# s.geometry.lam = None +# s.geometry.distance = 7 +# s.geometry.psize = 172e-6 +# s.geometry.shape = shape +# s.geometry.propagation = "farfield" +# s.illumination = resources.moon_pr((shape,shape))*1e2 +# s.sample = resources.flower_obj((shape*2,shape*2)) + + +# u.verbose.set_level(3) +# MS = SimScan(None,s) +# #MS.P.plot_overview() +# u.verbose.set_level(3) +# u.pause(10) +# MS.initialize() +# for i in range(20): +# msg = MS.auto(10) +# u.verbose.logger.info(u.verbose.report(msg), extra={'allprocesses': True}) +# u.parallel.barrier() diff --git a/ptypy/utils/array_utils.py b/ptypy/utils/array_utils.py index dbd7a2366..a6dc3ede9 100644 --- a/ptypy/utils/array_utils.py +++ b/ptypy/utils/array_utils.py @@ -54,9 +54,9 @@ def switch_orientation(A, orientation, center=None): o = 0 if orientation is None else orientation if np.isscalar(o): - o = [i=='1' for i in '%03d' % int(np.base_repr(o))] + o = [i == '1' for i in '%03d' % int(np.base_repr(o))] - assert len(o)==3 + assert len(o) == 3 # switch orientation if o[0]: axes = list(range(A.ndim - 2)) + [-1, -2] @@ -101,10 +101,11 @@ def rebin_2d(A, rebin=1): sh = np.asarray(A.shape[-2:]) newdim = sh // rebin if not (sh % rebin == 0).all(): - raise ValueError('Last two axes %s of input array `A` cannot be binned by %s' % (str(tuple(sh)),str(rebin))) + raise ValueError('Last two axes %s of input array `A` cannot be binned by %s' % (str(tuple(sh)), str(rebin))) else: return A.reshape(-1, newdim[0], rebin, newdim[1], rebin).mean(-1).mean(-2) + def crop_pad_symmetric_2d(A, newshape, center=None): """ Crops or pads Array `A` symmetrically along the last two axes `(-2,-1)` @@ -148,7 +149,8 @@ def crop_pad_symmetric_2d(A, newshape, center=None): return A, c + low -def rebin(a, *args,**kwargs): + +def rebin(a, *args, **kwargs): """ Rebin ndarray data into a smaller ndarray of the same rank whose dimensions are factors of the original dimensions. @@ -184,46 +186,52 @@ def rebin(a, *args,**kwargs): """ shape = a.shape lenShape = a.ndim - factor = np.asarray(shape)//np.asarray(args) + factor = np.asarray(shape) // np.asarray(args) evList = ['a.reshape('] + \ - ['args[%d],factor[%d],'%(i,i) for i in range(lenShape)] + \ - [')'] + ['.sum(%d)'%(i+1) for i in range(lenShape)] + \ - ['*( 1.'] + ['/factor[%d]'%i for i in range(lenShape)] + [')'] - if kwargs.get('verbose',False): + ['args[%d],factor[%d],' % (i, i) for i in range(lenShape)] + \ + [')'] + ['.sum(%d)' % (i + 1) for i in range(lenShape)] + \ + ['*( 1.'] + ['/factor[%d]' % i for i in range(lenShape)] + [')'] + if kwargs.get('verbose', False): print(''.join(evList)) return eval(''.join(evList)) + def _confine(A): """\ Doc TODO. """ - sh=np.asarray(A.shape)[1:] - A=A.astype(float) - m=np.reshape(sh,(len(sh),) + len(sh)*(1,)) - return (A+m//2.0) % m - m//2.0 + sh = np.asarray(A.shape)[1:] + A = A.astype(float) + m = np.reshape(sh, (len(sh),) + len(sh) * (1,)) + return (A + m // 2.0) % m - m // 2.0 -def _translate_to_pix(sh,center): + +def _translate_to_pix(sh, center): """\ Take arbitrary input and translate it to a pixel position with respect to sh. """ - sh=np.array(sh) + sh = np.array(sh) if not isstr(center): cen = np.asarray(center) % sh - elif center=='fftshift': - cen=sh//2.0 - elif center=='geometric': - cen=sh/2.0-0.5 - elif center=='fft': - cen=sh*0.0 + elif center == 'fftshift': + cen = sh // 2.0 + elif center == 'geometric': + cen = sh / 2.0 - 0.5 + elif center == 'fft': + cen = sh * 0.0 else: raise TypeError('Input %s not understood for center' % str(center)) return cen + + """ def center_2d(sh,center): return translate_to_pix(sh[-2:],expect2(center)) """ -def grids(sh,psize=None,center='geometric',FFTlike=True): + + +def grids(sh, psize=None, center='geometric', FFTlike=True): """\ ``q0,q1,... = grids(sh)`` returns centered coordinates for a N-dimensional array of shape sh (pixel units) @@ -258,14 +266,14 @@ def grids(sh,psize=None,center='geometric',FFTlike=True): ndarray The coordinate grids """ - sh=np.asarray(sh) + sh = np.asarray(sh) - cen = _translate_to_pix(sh,center) + cen = _translate_to_pix(sh, center) - grid=np.indices(sh).astype(float) - np.reshape(cen,(len(sh),) + len(sh)*(1,)) + grid = np.indices(sh).astype(float) - np.reshape(cen, (len(sh),) + len(sh) * (1,)) if FFTlike: - grid=_confine(grid) + grid = _confine(grid) if psize is None: return grid @@ -273,16 +281,17 @@ def grids(sh,psize=None,center='geometric',FFTlike=True): psize = np.asarray(psize) if psize.size == 1: psize = psize * np.ones((len(sh),)) - psize = np.asarray(psize).reshape( (len(sh),) + len(sh)*(1,)) + psize = np.asarray(psize).reshape((len(sh),) + len(sh) * (1,)) return grid * psize + def rectangle(grids, dims=None, ew=2): if dims is None: dims = (grids.shape[-2] / 2., grids.shape[-1] / 2.) v, h = dims V, H = grids - return (smooth_step(-np.abs(V) + v/2, ew) - * smooth_step(-np.abs(H) + h/2, ew)) + return (smooth_step(-np.abs(V) + v / 2, ew) + * smooth_step(-np.abs(H) + h / 2, ew)) def ellipsis(grids, dims=None, ew=2): @@ -291,9 +300,10 @@ def ellipsis(grids, dims=None, ew=2): v, h = dims V, H = grids return smooth_step( - 0.5 - np.sqrt(V**2/v**2 + H**2/h**2), ew/np.sqrt(v * h)) + 0.5 - np.sqrt(V ** 2 / v ** 2 + H ** 2 / h ** 2), ew / np.sqrt(v * h)) + -def zoom(c,*arg,**kwargs): +def zoom(c, *arg, **kwargs): """ Wrapper `scipy.ndimage.zoom `_ function and shares @@ -311,25 +321,27 @@ def zoom(c,*arg,**kwargs): numpy.ndarray Zoomed array """ - #if np.all(arg[0] == 1): + # if np.all(arg[0] == 1): # return c # from scipy.ndimage import zoom as _zoom if np.iscomplexobj(c): - return complex_overload(_zoom)(c,*arg,**kwargs) + return complex_overload(_zoom)(c, *arg, **kwargs) else: - return _zoom(c,*arg,**kwargs) + return _zoom(c, *arg, **kwargs) + c_zoom = zoom -c_zoom.__doc__='*Deprecated*, kept for backward compatibility only.\n\n' + zoom.__doc__ +c_zoom.__doc__ = '*Deprecated*, kept for backward compatibility only.\n\n' + zoom.__doc__ """ c_affine_transform=complex_overload(ndi.affine_transform) c_affine_transform.__doc__='*complex input*\n\n'+c_affine_transform.__doc__ """ -def shift_zoom(c,zoom,cen_old,cen_new,**kwargs): + +def shift_zoom(c, zoom, cen_old, cen_new, **kwargs): """ Move array from center `cen_old` to `cen_new` and perform a zoom `zoom`. @@ -359,39 +371,40 @@ def shift_zoom(c,zoom,cen_old,cen_new,**kwargs): numpy.ndarray Shifted and zoomed array """ - + from scipy.ndimage import affine_transform as at zoom = np.diag(zoom) - offset=np.asarray(cen_old)-np.asarray(cen_new).dot(zoom) + offset = np.asarray(cen_old) - np.asarray(cen_new).dot(zoom) if np.iscomplexobj(c): - return complex_overload(at)(c,zoom,offset,**kwargs) + return complex_overload(at)(c, zoom, offset, **kwargs) else: - return at(c,zoom,offset,**kwargs) + return at(c, zoom, offset, **kwargs) -def fill3D(A,B,offset=[0,0,0]): +def fill3D(A, B, offset=[0, 0, 0]): """ Fill 3-dimensional array A with B. """ - if A.ndim != 3 or B.ndim!=3: + if A.ndim != 3 or B.ndim != 3: raise ValueError('3D a numpy arrays expected') - Alim=np.array(A.shape) - Blim=np.array(B.shape) - off=np.array(offset) + Alim = np.array(A.shape) + Blim = np.array(B.shape) + off = np.array(offset) Ao = off.copy() - Ao[Ao<0]=0 + Ao[Ao < 0] = 0 Bo = -off.copy() - Bo[Bo<0]=0 - print(Ao,Bo) + Bo[Bo < 0] = 0 if (Bo > Blim).any() or (Ao > Alim).any(): print("misfit") pass else: - A[Ao[0]:min(off[0]+Blim[0],Alim[0]),Ao[1]:min(off[1]+Blim[1],Alim[1]),Ao[2]:min(off[2]+Blim[2],Alim[2])] \ - =B[Bo[0]:min(Alim[0]-off[0],Blim[0]),Bo[1]:min(Alim[1]-off[1],Blim[1]),Bo[2]:min(Alim[2]-off[2],Blim[2])] + A[Ao[0]:min(off[0] + Blim[0], Alim[0]), Ao[1]:min(off[1] + Blim[1], Alim[1]), + Ao[2]:min(off[2] + Blim[2], Alim[2])] \ + = B[Bo[0]:min(Alim[0] - off[0], Blim[0]), Bo[1]:min(Alim[1] - off[1], Blim[1]), + Bo[2]:min(Alim[2] - off[2], Blim[2])] -def mirror(A,axis=-1): +def mirror(A, axis=-1): """ Mirrors array `A` along one axis `axis` @@ -409,9 +422,10 @@ def mirror(A,axis=-1): A view to the mirrored array. """ - return np.flipud(np.asarray(A).swapaxes(axis,0)).swapaxes(0,axis) + return np.flipud(np.asarray(A).swapaxes(axis, 0)).swapaxes(0, axis) + -def pad_lr(A,axis,l,r,fillpar=0.0, filltype='scalar'): +def pad_lr(A, axis, l, r, fillpar=0.0, filltype='scalar'): """ Pads ndarray `A` orthogonal to `axis` with `l` layers (pixels,lines,planes,...) on low side an `r` layers on high side. @@ -445,62 +459,61 @@ def pad_lr(A,axis,l,r,fillpar=0.0, filltype='scalar'): crop_pad crop_pad_symmetric_2d """ - fsh=np.array(A.shape) - if l>fsh[axis]: #rare case - l-=fsh[axis] - A=pad_lr(A,axis,fsh[axis],0,fillpar, filltype) - return pad_lr(A,axis,l,r,fillpar, filltype) - elif r>fsh[axis]: - r-=fsh[axis] - A=pad_lr(A,axis,0,fsh[axis],fillpar, filltype) - return pad_lr(A,axis,l,r,fillpar, filltype) - elif filltype=='mirror': - left=mirror(np.split(A,[l],axis)[0],axis) - right=mirror(np.split(A,[A.shape[axis]-r],axis)[1],axis) - elif filltype=='periodic': - right=np.split(A,[r],axis)[0] - left=np.split(A,[A.shape[axis]-l],axis)[1] - elif filltype=='project': - fsh[axis]=l - left=np.ones(fsh,A.dtype)*np.split(A,[1],axis)[0] - fsh[axis]=r - right=np.ones(fsh,A.dtype)*np.split(A,[A.shape[axis]-1],axis)[1] - if filltype=='scalar' or l==0: - fsh[axis]=l - left=np.ones(fsh,A.dtype)*fillpar - if filltype=='scalar' or r==0: - fsh[axis]=r - right=np.ones(fsh,A.dtype)*fillpar - if filltype=='custom': - left=fillpar[0].astype(A.dtype) - right=fillpar[1].astype(A.dtype) - return np.concatenate((left,A,right),axis=axis) - - -def _roll_from_pixcenter(sh,center): + fsh = np.array(A.shape) + if l > fsh[axis]: # rare case + l -= fsh[axis] + A = pad_lr(A, axis, fsh[axis], 0, fillpar, filltype) + return pad_lr(A, axis, l, r, fillpar, filltype) + elif r > fsh[axis]: + r -= fsh[axis] + A = pad_lr(A, axis, 0, fsh[axis], fillpar, filltype) + return pad_lr(A, axis, l, r, fillpar, filltype) + elif filltype == 'mirror': + left = mirror(np.split(A, [l], axis)[0], axis) + right = mirror(np.split(A, [A.shape[axis] - r], axis)[1], axis) + elif filltype == 'periodic': + right = np.split(A, [r], axis)[0] + left = np.split(A, [A.shape[axis] - l], axis)[1] + elif filltype == 'project': + fsh[axis] = l + left = np.ones(fsh, A.dtype) * np.split(A, [1], axis)[0] + fsh[axis] = r + right = np.ones(fsh, A.dtype) * np.split(A, [A.shape[axis] - 1], axis)[1] + if filltype == 'scalar' or l == 0: + fsh[axis] = l + left = np.ones(fsh, A.dtype) * fillpar + if filltype == 'scalar' or r == 0: + fsh[axis] = r + right = np.ones(fsh, A.dtype) * fillpar + if filltype == 'custom': + left = fillpar[0].astype(A.dtype) + right = fillpar[1].astype(A.dtype) + return np.concatenate((left, A, right), axis=axis) + + +def _roll_from_pixcenter(sh, center): """\ returns array of ints as input for np.roll use np.roll(A,-roll_from_pixcenter(sh,cen)[ax],ax) to put 'cen' in geometric center of array A """ - sh=np.array(sh) + sh = np.array(sh) if center != None: - if center=='fftshift': - cen=sh//2.0 - elif center=='geometric': - cen=sh/2.0-0.5 - elif center=='fft': - cen=sh*0.0 + if center == 'fftshift': + cen = sh // 2.0 + elif center == 'geometric': + cen = sh / 2.0 - 0.5 + elif center == 'fft': + cen = sh * 0.0 elif center is not None: - cen=sh*np.asarray(center) % sh - 0.5 + cen = sh * np.asarray(center) % sh - 0.5 - roll=np.ceil(cen - sh/2.0) % sh + roll = np.ceil(cen - sh / 2.0) % sh else: - roll=np.zeros_like(sh) + roll = np.zeros_like(sh) return roll.astype(int) - -def crop_pad_axis(A,hplanes,axis=-1,roll=0,fillpar=0.0, filltype='scalar'): +def crop_pad_axis(A, hplanes, axis=-1, roll=0, fillpar=0.0, filltype='scalar'): """ Crops or pads a volume array `A` at beginning and end of axis `axis` with a number of hyperplanes specified by `hplanes` @@ -573,37 +586,36 @@ def crop_pad_axis(A,hplanes,axis=-1,roll=0,fillpar=0.0, filltype='scalar'): >>> B=crop_pad_axis(V,(3,-2),1,filltype='mirror') """ if np.isscalar(hplanes): - hplanes=int(hplanes) - r=np.abs(hplanes) // 2 * np.sign(hplanes) - l=hplanes - r - elif len(hplanes)==2: - l=int(hplanes[0]) - r=int(hplanes[1]) + hplanes = int(hplanes) + r = np.abs(hplanes) // 2 * np.sign(hplanes) + l = hplanes - r + elif len(hplanes) == 2: + l = int(hplanes[0]) + r = int(hplanes[1]) else: raise RuntimeError('unsupoorted input for \'hplanes\'') - if roll!=0: - A=np.roll(A,-roll,axis=axis) - - if l<=0 and r<=0: - A=np.split(A,[-l,A.shape[axis]+r],axis)[1] - elif l>0 and r>0: - A=pad_lr(A,axis,l,r,fillpar,filltype) - elif l>0 and r<=0: - A=pad_lr(A,axis,l,0,fillpar,filltype) - A=np.split(A,[0,A.shape[axis]+r],axis)[1] - elif l<=0 and r>0: - A=pad_lr(A,axis,0,r,fillpar,filltype) - A=np.split(A,[-l,A.shape[axis]],axis)[1] - - - if roll!=0: - return np.roll(A,roll+r,axis=axis) + if roll != 0: + A = np.roll(A, -roll, axis=axis) + + if l <= 0 and r <= 0: + A = np.split(A, [-l, A.shape[axis] + r], axis)[1] + elif l > 0 and r > 0: + A = pad_lr(A, axis, l, r, fillpar, filltype) + elif l > 0 and r <= 0: + A = pad_lr(A, axis, l, 0, fillpar, filltype) + A = np.split(A, [0, A.shape[axis] + r], axis)[1] + elif l <= 0 and r > 0: + A = pad_lr(A, axis, 0, r, fillpar, filltype) + A = np.split(A, [-l, A.shape[axis]], axis)[1] + + if roll != 0: + return np.roll(A, roll + r, axis=axis) else: return A -def crop_pad(A,hplane_list,axes=None,cen=None,fillpar=0.0,filltype='scalar'): +def crop_pad(A, hplane_list, axes=None, cen=None, fillpar=0.0, filltype='scalar'): """\ Crops or pads a volume array `A` with a number of hyperplanes according to parameters in `hplanes` Wrapper for crop_pad_axis. @@ -660,14 +672,13 @@ def crop_pad(A,hplane_list,axes=None,cen=None,fillpar=0.0,filltype='scalar'): """ if axes is None: - axes=np.arange(len(hplane_list))-len(hplane_list) - elif not(len(axes)==len(hplane_list)): + axes = np.arange(len(hplane_list)) - len(hplane_list) + elif not (len(axes) == len(hplane_list)): raise RuntimeError('if axes is specified, hplane_list has to be same length as axes') - sh=np.array(A.shape) - roll = _roll_from_pixcenter(sh,cen) + sh = np.array(A.shape) + roll = _roll_from_pixcenter(sh, cen) - for ax,cut in zip(axes,hplane_list): - A=crop_pad_axis(A,cut,ax,roll[ax],fillpar,filltype) + for ax, cut in zip(axes, hplane_list): + A = crop_pad_axis(A, cut, ax, roll[ax], fillpar, filltype) return A - diff --git a/ptypy/utils/misc.py b/ptypy/utils/misc.py index 5ec395316..eae31e89f 100644 --- a/ptypy/utils/misc.py +++ b/ptypy/utils/misc.py @@ -139,7 +139,7 @@ def isstr(s): if sys.version_info[0] == 3: string_types = str, else: - string_types = basestring, + string_types = basestring, # noqa: F821 return isinstance(s, string_types) @@ -290,7 +290,7 @@ def expectN(a, N): raise ValueError('N must be 2 or 3') def complex_overload(func): - """\ + r"""\ Overloads function specified only for floats in the following manner .. math:: @@ -329,4 +329,3 @@ def clean_path(filename): if not os.path.exists(base): os.makedirs(base) return filename - diff --git a/ptypy/utils/parallel.py b/ptypy/utils/parallel.py index c78f715b2..933cca306 100644 --- a/ptypy/utils/parallel.py +++ b/ptypy/utils/parallel.py @@ -27,7 +27,8 @@ __all__ = ['MPIenabled', 'comm', 'MPI', 'master','barrier', 'LoadManager', 'loadmanager','allreduce','send','receive','bcast', - 'bcast_dict', 'gather_dict', 'gather_list', 'MPIrand_normal', 'MPIrand_uniform','MPInoise2d'] + 'bcast_dict', 'gather_dict', 'gather_list', + 'MPIrand_normal', 'MPIrand_uniform','MPInoise2d'] def useMPI(do=None): @@ -456,11 +457,6 @@ def bcast(data, source=0): def bcast_dict(dct, keys='all', source=0): """ Broadcasts or scatters a dict `dct` from ``rank==source``. - If value is a numpy ndarray, `comm.Bcast` is used instead `comm.bcast`, - such that transfer is accelerated. - - Fills dict `dct` in place for receiving nodes, although this is a - bit inconsistent compared to :any:`gather_dict` Parameters ---------- @@ -497,35 +493,37 @@ def bcast_dict(dct, keys='all', source=0): out = dict(dct) return out - # communicate the dict length + # Broadcast all keys (the full dict) + if str(keys) == 'all': + out = comm.bcast(dct) + return out + + # Broadcast only given keys of dict if rank == source: out = {} length = comm.bcast(len(dct), source) for k, v in dct.items(): comm.bcast(k,source) bcast(v,source) - if str(keys) == 'all' or k in keys: + if k in keys: out[k] = v - return out else: - if dct is None: - dct = {} + out = {} length = comm.bcast(None, source) for k in range(length): k = comm.bcast(None,source) v = bcast(None,source) - if str(keys) == 'all' or k in keys: - dct[k] = v - - return dct + if k in keys: + out[k] = v + return out def allgather_dict(dct): """ Allgather dict in place. """ gdict = gather_dict(dct) - bcast_dict(gdict) + gdict = bcast_dict(gdict) dct.update(gdict) def gather_dict(dct, target=0): @@ -558,35 +556,39 @@ def gather_dict(dct, target=0): if not MPIenabled: out.update(dct) return out - - for r in range(size): - if r == target: - if rank == target: - #print rank,dct - out.update(dct) - continue - - if rank == target: - l = comm.recv(source=r,tag=9999) - for i in range(l): - #k = receive(r) - k = comm.recv(source=r,tag=9999) - v = receive(r) - #print rank,str(k),v - out[k] = v - elif r == rank: - # your turn to send - l = len(dct) - comm.send(l, dest=target,tag=9999) - for k,v in dct.items(): - #print rank,str(k),v - #send(k, dest=target) - comm.send(k, dest=target,tag=9999) - send(v, dest=target) - barrier() - + ret = comm.gather(dct, root=target) + if rank == target: + for d in ret: + out.update(d) return out + # for r in range(size): + # if r == target: + # if rank == target: + # #print rank,dct + # out.update(dct) + # continue + + # if rank == target: + # l = comm.recv(source=r,tag=9999) + # for i in range(l): + # #k = receive(r) + # k = comm.recv(source=r,tag=9999) + # v = receive(r) + # #print rank,str(k),v + # out[k] = v + # elif r == rank: + # # your turn to send + # l = len(dct) + # comm.send(l, dest=target,tag=9999) + # for k,v in dct.items(): + # #print rank,str(k),v + # #send(k, dest=target) + # comm.send(k, dest=target,tag=9999) + # send(v, dest=target) + # barrier() + # return out + def _send(data, dest=0, tag=0): """ Wrapper for comm.Send @@ -750,7 +752,7 @@ def MPIrand_uniform(low=0.0, high=1.0, size=(1)): else: hosts_ranks[v].append(k) - bcast_dict(hosts_ranks) + hosts_ranks = bcast_dict(hosts_ranks) rank_local = hosts_ranks[host].index(rank) del rank_host else: diff --git a/ptypy/utils/parameters.py b/ptypy/utils/parameters.py index adc6a4dcc..96630355e 100644 --- a/ptypy/utils/parameters.py +++ b/ptypy/utils/parameters.py @@ -261,7 +261,7 @@ def validate_standard_param(sp, p=None, prefix=None): return good else: - raise NotimplementedError('Checking if a param fits with a standard is not yet implemented') + raise NotImplementedError('Checking if a param fits with a standard is not yet implemented') def format_standard_param(p): diff --git a/ptypy/utils/plot_client.py b/ptypy/utils/plot_client.py index b5d2d7cf0..e6297a3af 100644 --- a/ptypy/utils/plot_client.py +++ b/ptypy/utils/plot_client.py @@ -344,7 +344,7 @@ def _set_autolayout(self,pars): try: pars = TEMPLATES[pars] except KeyError: - log(self.log_level,'Plotting template "\%s" not found, using default settings' % str(pars)) + log(self.log_level,'Plotting template "\\%s" not found, using default settings' % str(pars)) if hasattr(pars,'items'): self.p.update(pars,in_place_depth=4) @@ -581,7 +581,7 @@ def plot_storage(self, storage, plot_pars, title="", typ='obj'): #ptya._update_colorbar() if channel == 'c': if typ == 'obj': - mm = np.mean(np.abs(data[layer]*plot_mask)**2) + mm = np.mean(np.abs(data[layer]*mask)**2) info = 'T=%.2f' % mm else: mm = np.sum(np.abs(data[layer])**2) diff --git a/ptypy/utils/plot_utils.py b/ptypy/utils/plot_utils.py index e96b25e36..882a2ed20 100644 --- a/ptypy/utils/plot_utils.py +++ b/ptypy/utils/plot_utils.py @@ -128,12 +128,15 @@ def pause(timeout=-1, message=None): print(message) time.sleep(timeout) +# BD: With version 9.1.0 of PIL, _MODE_CONV has been removed, +# see here: https://github.com/python-pillow/Pillow/pull/6057 +# can't see a reason why this is still needed, therefore commenting it out # FIXME: Is this still needed? # Fix tif import problem -Image._MODE_CONV['I;16'] = (Image._ENDIAN + 'u2', None) +#Image._MODE_CONV['I;16'] = (Image._ENDIAN + 'u2', None) # Grayscale + alpha should also work -Image._MODE_CONV['LA'] = (Image._ENDIAN + 'u1', 2) +#Image._MODE_CONV['LA'] = (Image._ENDIAN + 'u1', 2) def complex2hsv(cin, vmin=0., vmax=None): @@ -285,7 +288,7 @@ def rgb2complex(rgb): def imsave(a, filename=None, vmin=None, vmax=None, cmap=None): - """ + r""" Take array `a` and transform to `PIL.Image` object that may be used by `pyplot.imshow` for example. Also save image buffer directly without the sometimes unnecessary Gui-frame and overhead. @@ -357,9 +360,9 @@ def imsave(a, filename=None, vmin=None, vmax=None, cmap=None): vmin, vmax = 0.9 * vmin, 1.1 * vmax im = Image.fromarray((255*(a.clip(vmin,vmax)-vmin)/(vmax-vmin)).astype('uint8')) if cmap is not None: - r = im.point(lambda x: cmap(x/255.0)[0] * 255) - g = im.point(lambda x: cmap(x/255.0)[1] * 255) - b = im.point(lambda x: cmap(x/255.0)[2] * 255) + r = im.point(lambda x: int(cmap(x/255.0)[0] * 255)) + g = im.point(lambda x: int(cmap(x/255.0)[1] * 255)) + b = im.point(lambda x: int(cmap(x/255.0)[2] * 255)) im = Image.merge("RGB", (r, g, b)) if filename is not None: @@ -460,7 +463,7 @@ def rmphaseramp(a, weight=None, return_phaseramp=False): useweight = True if weight is None: useweight = False - elif weight == 'abs': + elif isinstance(weight,str) and weight == 'abs': weight = np.abs(a) ph = np.exp(1j*np.angle(a)) @@ -817,7 +820,7 @@ def _update_colorbar(self, mn=None, mx=None): if self.channel == 'c': self.cax.xaxis.set_major_locator(mpl.ticker.FixedLocator([0,np.pi, 2*np.pi])) - self.cax.xaxis.set_major_formatter(mpl.ticker.FixedFormatter(['0', '$\pi$', '2$\pi$'])) + self.cax.xaxis.set_major_formatter(mpl.ticker.FixedFormatter(['0', r'$\pi$', r'2$\pi$'])) self.cax.set_xlabel('phase [rad]', fontsize=self.fontsize+2) self.cax.xaxis.set_label_position("top") diff --git a/ptypy/utils/scripts.py b/ptypy/utils/scripts.py index 72fa62c9b..268894434 100644 --- a/ptypy/utils/scripts.py +++ b/ptypy/utils/scripts.py @@ -144,9 +144,9 @@ def hdr_image(img_list, exp_list, thresholds=[3000,50000], dark_list=[], elif len(dark_list) == 1: dark_list = dark_list * len(img_list) # Convert to floats except for mask_list - img_list = [img.astype(np.float) for img in img_list] - dark_list = [dark.astype(np.float) for dark in dark_list] - exp_list = [np.float(exp) for exp in exp_list] + img_list = [img.astype(float) for img in img_list] + dark_list = [dark.astype(float) for dark in dark_list] + exp_list = [float(exp) for exp in exp_list] mask_list = [mask.astype(np.int) for mask in mask_list] for img, dark, exp,mask in zip(img_list, dark_list,exp_list,mask_list): @@ -190,7 +190,7 @@ def hdr_image(img_list, exp_list, thresholds=[3000,50000], dark_list=[], def png2mpg(listoffiles, framefile='frames.txt', fps=5, bitrate=2000, codec='wmv2', Encode=True, RemoveImages=False): - """ + r""" Makes a movie (\*.mpg) from a collection of \*.png or \*.jpeg frames. *Requires* binary of **mencoder** installed on system @@ -303,7 +303,7 @@ def png2mpg(listoffiles, framefile='frames.txt', fps=5, bitrate=2000, # Trying to find similar images. body, imagetype = os.path.splitext(tail) # Replace possible numbers by a wildcard. - newbody = re.sub('\d+', '*', body) + newbody = re.sub(r'\d+', '*', body) wcard = head + os.sep + newbody + imagetype #print wcard imagfiles = glob.glob(wcard) @@ -531,9 +531,9 @@ def mass_center(A, axes=None, mask=None): axes = tuple(np.array(axes) + 1) if mask is None: - return np.sum(A * np.indices(A.shape), axis=axes, dtype=np.float) / np.sum(A, dtype=np.float) + return np.sum(A * np.indices(A.shape), axis=axes, dtype=float) / np.sum(A, dtype=float) else: - return np.sum(A * mask * np.indices(A.shape), axis=axes, dtype=np.float) / np.sum(A * mask, dtype=np.float) + return np.sum(A * mask * np.indices(A.shape), axis=axes, dtype=float) / np.sum(A * mask, dtype=float) def radial_distribution(A, radii=None): diff --git a/ptypy/utils/verbose.py b/ptypy/utils/verbose.py index 6e6ae300c..d069444c7 100644 --- a/ptypy/utils/verbose.py +++ b/ptypy/utils/verbose.py @@ -21,25 +21,32 @@ import sys import inspect import logging +from time import perf_counter from . import parallel __all__ = ['logger', 'set_level', 'report', 'log'] -# custom logging level to diplay python objects (not as detailed as debug but also not that important for info) +# custom logging levels INSPECT = 15 +INTERACTIVE = 35 +CITATION = 45 -CONSOLE_FORMAT = {logging.ERROR : 'ERROR %(name)s - %(message)s', +CONSOLE_FORMAT = {CITATION: '%(message)s', + logging.ERROR : 'ERROR %(name)s - %(message)s', + INTERACTIVE : '%(message)s', logging.WARNING : 'WARNING %(name)s - %(message)s', logging.INFO : '%(message)s', INSPECT : 'INSPECT %(message)s', logging.DEBUG : 'DEBUG %(pathname)s [%(lineno)d] - %(message)s'} -FILE_FORMAT = {logging.ERROR : '%(asctime)s ERROR %(name)s - %(message)s', - logging.WARNING : '%(asctime)s WARNING %(name)s - %(message)s', - logging.INFO : '%(asctime)s %(message)s', - INSPECT : '%(asctime)s INSPECT %(message)s', - logging.DEBUG : '%(asctime)s DEBUG %(pathname)s [%(lineno)d] - %(message)s'} +FILE_FORMAT = {CITATION: '%(message)s', + logging.ERROR : '%(asctime)s ERROR %(name)s - %(message)s', + INTERACTIVE : '%(asctime)s %(message)s', + logging.WARNING : '%(asctime)s WARNING %(name)s - %(message)s', + logging.INFO : '%(asctime)s %(message)s', + INSPECT : '%(asctime)s INSPECT %(message)s', + logging.DEBUG : '%(asctime)s DEBUG %(pathname)s [%(lineno)d] - %(message)s'} # How many characters per line in console LINEMAX = 80 @@ -82,8 +89,7 @@ class CustomFormatter(logging.Formatter): """ Flexible formatting, depending on the logging level. - Adapted from http://stackoverflow.com/questions/1343227 - Will have to be updated for python > 3.2. + Adapted from https://stackoverflow.com/questions/14844970 """ DEFAULT = '%(levelname)s: %(message)s' @@ -92,11 +98,11 @@ def __init__(self, FORMATS=None): self.FORMATS = {} if FORMATS is None else FORMATS def format(self, record): - self._fmt = self.FORMATS.get(record.levelno, self.DEFAULT) + self._style._fmt = self.FORMATS.get(record.levelno, self.DEFAULT) return logging.Formatter.format(self, record) # Create logger -logger = logging.getLogger() +logger = logging.getLogger("ptypy") # Default level - should be changed as soon as possible logger.setLevel(logging.WARNING) @@ -113,26 +119,71 @@ def format(self, record): consolefilter = MPIFilter() logger.addFilter(consolefilter) +# Capture warnings and log them +logging.captureWarnings(True) + level_from_verbosity = {0:logging.CRITICAL, 1:logging.ERROR, 2:logging.WARN, 3:logging.INFO, 4: INSPECT, 5:logging.DEBUG} -level_from_string = {'CRITICAL':logging.CRITICAL, 'ERROR':logging.ERROR, 'WARN':logging.WARN, 'WARNING':logging.WARN, 'INFO':logging.INFO, 'INSPECT': INSPECT, 'DEBUG':logging.DEBUG} +level_from_string = {'CITATION':CITATION, 'CRITICAL':logging.CRITICAL, 'ERROR':logging.ERROR, 'WARN':logging.WARN, 'WARNING':logging.WARN, + 'INTERACTIVE':INTERACTIVE, 'INFO':logging.INFO, 'INSPECT': INSPECT, 'DEBUG':logging.DEBUG} vlevel_from_logging = dict([(v,k) for k,v in level_from_verbosity.items()]) slevel_from_logging = dict([(v,k) for k,v in level_from_string.items()]) +def ilog_message(msg): + """ + Interactive logging for jupyter notebooks, prints a normal message. + """ + if not slevel_from_logging[logger.level] == "INTERACTIVE": + return + logger.log(level_from_string["INTERACTIVE"], msg) + +def ilog_streamer(msg): + """ + Interactive logging for jupyter notebooks, + streams a message by overwriting the same line. + """ + if not slevel_from_logging[logger.level] == "INTERACTIVE": + return + consolehandler.terminator = "" + logger.log(level_from_string["INTERACTIVE"], "\r"+msg) + consolehandler.terminator = "\n" + +def ilog_newline(): + """ + Interactive logging for jupyter notebooks, + moves cursor to next line. Call this after + ilog_streamer() to escape the streaming. + """ + if not slevel_from_logging[logger.level] == "INTERACTIVE": + return + consolehandler.terminator = "" + logger.log(level_from_string["INTERACTIVE"], "\n") + consolehandler.terminator = "\n" + def log(level,msg,parallel=False): + if isinstance(level, int): + _level = level_from_verbosity[level] + elif isinstance(level, str): + _level = level_from_string[level.upper()] + else: + raise TypeError("Verbosity level should be an integer or a string") if not parallel: - logger.log(level_from_verbosity[level], msg) + logger.log(_level, msg) else: - logger.log(level_from_verbosity[level], msg,extra={'allprocesses':True}) + logger.log(_level, msg,extra={'allprocesses':True}) def set_level(level): """ Set verbosity level. Kept here for backward compatibility """ logger.info('Verbosity set to %s' % str(level)) - if str(level) == level: + if isinstance(level, str): + if level.upper() not in level_from_string: + raise KeyError("Verbosity level %s does not exist" %level) logger.setLevel(level_from_string[level.upper()]) - else: + elif isinstance(level, int): logger.setLevel(level_from_verbosity[level]) + else: + raise TypeError("Verbosity level should be an integer or a string") logger.info('Verbosity set to %s' % str(level)) def get_level(num_or_string='num'): @@ -260,3 +311,19 @@ def _format(key,level, obj): report.maxchar = LINEMAX report.headernewline='\n' report.asterisk='*' + + +class LogTime: + def __init__(self, active=False): + self.active = active + self.duration = 0 + def __enter__(self): + if not self.active: + return + self.time = perf_counter() + return self + def __exit__(self, type, value, traceback): + if self.active: + self.duration = perf_counter() - self.time + self.duration = parallel.MPImax([self.duration]) + self.readout = f'{self.duration:.3f} seconds' \ No newline at end of file diff --git a/ptypy_core_dependencies.yml b/ptypy_core_dependencies.yml deleted file mode 100644 index 2900fa651..000000000 --- a/ptypy_core_dependencies.yml +++ /dev/null @@ -1,8 +0,0 @@ -name: ptypy_core_dependencies -channels: - - conda-forge -dependencies: - - python=3.7 - - numpy - - scipy - - h5py diff --git a/release_notes.md b/release_notes.md index a028abaf1..8ee1bc645 100644 --- a/release_notes.md +++ b/release_notes.md @@ -1,7 +1,130 @@ +# PtyPy 0.5 release notes + +We're excited to bring you a new release, with new engines, GPU accelerations and +many smaller improvements. + +## Engine Updates + +### New abstraction layer for most engines, new engines. + + * generalised projectional engine with derived engines DM, RAAR + * generalised stochastic engine with derived engines EPIE, SDR + +Engines that are based on global projections now all derive from a generalized +base engine that is able to express most common projection algorithms with 4 scalar parameters. +DM and RAAR are two such derived classes. Similarly, algorithms based on a stochastic +sequence of local projections (SDR, EPIE) now inherit from a common base engine. + +### GPU acceleration + + * GPU-acceleration for all major engines DM, ML, EPIE, SDR, RAAR + * accelerated engines needs to be imported **explicitly** with + ```python + import ptypy + ptypy.load_gpu_engines('cuda') + ``` + +We accelerated three engines (projectional, stochastic and ML) using +the [`PyCUDA`](https://documen.tician.de/pycuda/) and +[`Reikna`](http://reikna.publicfields.net/en/latest/) library and a whole +collection of custom kernels. + +All GPU engines leverage a "streaming" model which means that the +primary locations of all objects are on the host (CPU) memory. +Diffraction data arrays and all other arrys that scale linearly with +the number of shifts/positons are segmented into blocks (of frames). +The idea is that these blocks are moved on and off the device (GPU) during +engine iteration if the GPU does not have enough memory to store all +blocks. The number of frames per block can +be adjusted with the new top-level +[`frames_per_block`](https://ptycho.github.io/ptypy/rst/parameters.html#ptycho.frames_per_block) +parameter. This parameter has little influence for smaller problem size, +but needs to be adjusted if your GPU has too little memory to fit even +a single block. + +Each engine iteration will cycle through all blocks, DM needs to even cycle +once for each projection. We therefore recommend to make the block size small +enough such that at least a couple of blocks fit on the GPU to hide the latency of +data transfers. For best +performance, we employ a mirror scheme such that each cycle reverses the +block order and reduces the host to device copies (and vice versa) to the +absolute minimum. + +GPU engines work in parallel when each MPI rank takes one GPU. For sending +data between ranks, PtyPy will perform a host copy first in most cases or +use whatever the underlying MPI implementations does for CUDA-aware MPI +(only tested for OpenMPI). Unfortunately, this mapping of one rank per +GPU will leave CPU cores idle if there are more cores on the system than GPUs. + +Within a node, PtyPy can use nccl (requires a CuPy install +and setting `PTYPY_USE_NCCL=1`) for passing data between ranks/GPUs. + + +## Breaking changes + +### Ptyscan classes (experiment) need to be imported explicitly + +Most derived PtyScan classes (all those in the `/experiment` folder) now need +to be imported explicitly. We took this step to separate the user space +more clearly from the base package and to avoid dependency creep from +user-introduced code. At the beginning of your script, you now +need to import your module explicitly or use one of the helper +functions. + +```python +import ptypy +ptypy.load_ptyscan_module(module='') +ptypy.load_all_ptyscan_modules() +``` + +Any PtyScan derived class in these modules that is decorated +with the `ptypy.experiment.register()` function will now be included +in the parameter tree and selectable by name. + +If you prefer the old way of importing ptypy "fully loaded", just use +```python +import ptypy +ptypy.load_all() +``` +which attempts to load all optional PtyScan classes and all engines. + + +## Other updates + + 1. Code for `utils.parallel.bcast_dict` and `gather_dict` has been simplified and + should be backwards compatible. + 2. The `fourier_power_bound` that was previously calculated internally from + the `fourier_relax_factor` can now be set explicitly and we recommend that from + now on. The recommended value for the`fourier_power_bound` is 0.25 for Poisson statistics + (see supplementary of [`this paper`](https://www.pnas.org/doi/10.1073/pnas.0905846107#supplementary-materials)) + 3. Position correction now supports an alternate search scheme, i.e. along a fixed grid. + This scheme is more accurate than a stochastic search and the overhead incurred + for this brute force search is acceptable for GPU engines. + 4. We switched to a pip install within a conda environment as the main supported way of installation + +## Roadmap + + * Automatic adjustment of the block sizes. + * Improve scaling behavior across multiple nodes and high frame counts. + * Better support for live processing (on a continuous detector data stream). + * More tests. + * Branch cleaning. + +## Contributors + +Thanks to the efforts at the Diamond Light Source that made this +update possible. + + * Aaron Parsons + * Bjoern Enders + * Benedikt Daurer + * Joerg Lotze + + # PtyPy 0.4 release notes After quite some work we announce ptypy 0.4. Apart from including all the fixes and improvements from 0.3.0 to 0.3.1, it includes two bigger changes - 1. Ptypy has now been converted to python 3 and will be **python 3 only** in future. The python 2 version will not be actively maintained anymore, we keep a branch for it for a while but we don't expect to put in many fixes and certainly not anny new features. Team work by Julio, Alex, Bjoern and Aaron. + 1. Ptypy has now been converted to python 3 and will be **python 3 only** in future. The python 2 version will not be actively maintained anymore, we keep a branch for it for a while but we don't expect to put in many fixes and certainly not any new features. Team work by Julio, Alex, Bjoern and Aaron. *Please note: all branches that haven’t been converted to python 3 by the end of 2019 will most likely be removed during 2020.* Please rebase your effort on version 0.4. If you need help rebasing your efforts, please let us know soon. 2. Position correction is now supported in most engines. It has been implemented by Wilhelm Eschen following the annealing approach introduced by A.M. Maiden et al. (Ultramicroscopy, Volume 120, 2012, Pages 64-72). Bjoern, Benedikt and Aaron helped refine and test it. diff --git a/resources/__init__.py b/resources/__init__.py deleted file mode 100644 index 666bf4ba9..000000000 --- a/resources/__init__.py +++ /dev/null @@ -1,11 +0,0 @@ - -def flowers(shape=None): - from ptypy import utils as u - im = u.HSV_to_P1A(u.RGB_to_HSV(u.imload(flowers.jpg))) - if shape is not None: - sh = u.expect2(shape) - ish = np.array(im.shape[:2]) - d = ish-sh - im = u.crop_pad(im,d,axes=[0,1],cen=None,fillpar=0.0,filltype='mirror') - - return im diff --git a/resources/ptypy_logo_1M.png b/resources/ptypy_logo_1M.png deleted file mode 100644 index 9c5a02e7fbc5c0a9ce9fae947a837e1e2b125cb1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 255113 zcmeFZi9ghR^ggU?ktiX_mPFZ-RCZai8 zr3{7PcjkUx-|zGM56^F2bI)x|#(duI^FHUgu5%sXnh3>nluVRFL`3J5mE^UEh)BbU zh=|G0kimC+uZ}mv|43Y9m9@{n&G(GOD|k-fsHE>gM8w)g`0tc`znc_%^RnwhJ=ez$ zPhCAw&XzS zU+FIAE8QX z6-%UKo8n_{A;?JeK>mMkF5R`O-2b2Fm%^^zzVJV{0cLY0wg3I6!kvt?7ysv_3qNj$ ze)->*UKZX!V{Iec-thP?3WV?T2`d&5_7n?*sQY3@cO9uFNi;Kfj-VTyjYwg{X)Jp3#M(^kkoM)cdAT^Z6KY+uBdj_#MhY@VUmzlMNlY zKa@`leLT*4wcqmELd=oHE481|&9nQ5e)Oj|T1>dgS^71oV#5W}42gUvs&BVhYtz-- zBK+`#ASYMy9q%)It$mHCS861?hkiZzV;e@3FP=WxJ1@!<$pLqUr3btp1w|qsBrEQn zPnr{j5C4qeHYZno+b;TZj~=P#EJy4sw9rokvk|=(y{&ZYeM!Nn4zpJZS(otdUOi2I z%**rpYx4%-q^LqZHM+2eTBM^s)O7o(&y8$tGNzfaPeiG|!erhKGEdf}3eN4E^+<(Z zvf2oru0ETSE^RE~!X@Rc=igXF>Yve`=?Q1sSW#49TV1$K!!>{uE(*8qW+Uq)Tn{VZ z{b>i~YUj3G$nD6KEw6gaKAWtcDZWnkX~K+=Y;mVn?1GU3RfyFUIdcvUj$|@O>33eo zw$NxVPXjQyol zgw<1@HybbC;r=8noOx$XfAnMg_8TL-SZP``w?Gx%$HnE-tA_aXj=JUX~$_)jtz$UdH&go0IpAwe2Mq zDj&b&Xdh`AfwSMXyctFhM9wbUCMIlrIh1+fhqT{zy_;OT_ZGFCAiZ9?0%ie>ys$GJVyVRl(Ljp+qi}!Z0>RpiZNj$P4@+FU#z&jZkToQ zs;k(unyD3`K+}{5dd1vX%wO&JFDUp>mbhP7D!#NgKj#0SYr`K~6QPi`Qti)0OTihZ zyeIf6R)B|*n(0is;tPpl!O`a>QtSQ>9<%8u2d6v<(P=^z9xltZpj0yUVLfWnR8SKY zmHwc1Y$N}H9wN*BTJ%*vttsri`WXT5rZmc+>rc|SD4trJ7NK~w?2$yGl79Z%7Igwi zmsVY(66g8oPL>khxPIkl684@f@)E4liJh6-=g5ewiq#Jv#2QaX^PC^$?xGTEYxQUU zmT&aKi$pu?v_&ra_$~asawEs7gw>ZjUd-}BRC0D%jK5+wCE6F9h!--*lc!mi8a)h; zc3D`t``tdgcbVP@2^r~t?fw&a_4XsBY#xu~f_K{gyh6l+S|5bed$VIkXg^M2KaSYs zZ>X?Ouem-oJ6+_YWXhLWa`aBnOZ#t}N=}SQ&Txza_uwbl692T(sCd@5L$*U>P1XZJ z#wD714(FC~+vZr=r!*2{4IOQz`yyExeIg(9PmQYiIIB#2x=tIOFG=>J`VVC&KC}@P z+?nW?_@y9lyw8JJdI965bLEa81bebHtS*-z)}8hM-+<)$@G0EAAyTIxYsr*^xu)a$_qAA3lsNg~L__qEyhyJ#SEeL2GI;E^7`#0m zF3*wBKhFDp=OUN7%4WK_eT5u4)UarDxJ_Gf)y>cfhwaG2zLk_<&9$nV`ctV9c)$Dk z$FRn|&-eLgx7Y2gr>pM@eSCn(k~J4qH}{K_=RmWNDl&f$`}1CJP(u)NKcjk1_kG{Y zTJzVY6DLFYH-{qr#0&a)!cX;8+#x%qL8XP99ZN!x*E!!ADZiDQ)ousv-uC3kxNxHVu4 zF~zmW--zM=p|*~b*kbK8xe8wvvfE5&}v*kPXuxiw8vx=F*&&4rp0l8pL}6Nj#gCs*Mk_G zb!AS>;io^D`>WJ(@VO=F+zmQ$cCV!_%-q=1oYWAH=xNKp`(5N^QTn`|wC6=QI9qea zPujBCzL>?h)T!TLrp_|ZYl(L9rq;-+|NBvtv}$ROFHM*(?dh}crSG9`*_c6cX%jY3 z>GD(QH($vO3D%|^+i)AUsfxvGG|UK~M|cnjgrm3jYn!Uq3RxE>Ph2Np!QoCvN%~IZ zI^46hZkp6Yc9?ao{JB9#+4ZzSZo!t1;qlAL$EJn4tf7)rsi>V@wSt^rl6HGk@snTo zl(V%jZd_D}I(Rm=HMC_{%;WQd+4Z+7{vM(xu4m@7xuiC=kM;whBzc~Avs-^upBnIA zR|qNhmtA0Q-K@R(8)->n7v#GaO&NJhNHFb}FBPGhHbXqs5msOFeOZb3C+m+BwjXs0 zGH2{*W~#?FG6$Yz7!)mHFt!#gbKXr+ad8*j#9#-Go-EfXMNq6+^R>Rk?;~>I$mX7= zz~>Hm*(WNSa@cY1QmkNFd_r!?T#r-cu4ZGrPNKx{b(Sl`=c>WRRw%e4zzjJTe)3V>9b}%1wMz%Ry zw?#4?8H>0SQtxl#H;xdT_j|Ely;x;xjEtumA}HTnW&jds8C9#6^Y2Vbt!2?oSBqz*W#NU3 zy8nLaU}c&*q>C2cNo8d`)YoW2zfmOps-@5Tt2IrYDF|Vb?!DUhr*P!&D-2{sVb7;4uMi081w(;|rzQr^TvXuevwzFpd(Z__svE z?pIXY(Jnxa*(|i0zJO~E3L9X5Y#5r0NJv}{o`uZ}NnvOHAfOa9DhRB|(d(u1DYo=`~(ObIzsP6-+Od1u|?k#>M z7aO6yJ~bxSGSWsX(1ZUw6FPCo=7W=IMo+hyx7e9xkJU0~{GRmhl3~w%p-=5BO8RwA zstfh1b4e*j%U0dx<);hOKBUF=(e&8|9w{rn@on?UYLf*bT}l)+8;HSTGiIs?NIe2< zpwNtDD7abNfMiluU;nzQ>MoyvfVU1$uGURB>~IM5 zidX0vH`>SA&%ENyTa2126>ML4gyqcsHa4sJBoJl2wW#2*zi9PaVn~=@GGe8Uyv*dl zBF>-Kz~=+=ecB_gxbDoL`&p;WCm4dus5{Nd$`tha|3a{KT615>HW2A@v1DhS7Qu40 zoq5y5dI$6QJ?b`aw&m8C_rG-X7D{!+!&^-=3=|-(x;0xTqa)?34BS%RptbVn=jVwW z=9*db`E8Rw)gK=pOHtF%+?qMRqi@bg_HDVGGDDmu%?aP-_Zfz4 z3y;%`zd^S_q?Nafh zxZygZfMK^Lo;Q72EDy*1mSFpC_)>*iZw6ncRxLF*i3CXB+uN&IGB&dG{!_SjQ!(0m zCU5}~R--?jsiC3a8ZXK7s$|L#8fxlLH0@2_K^rqCrwhx@6N9pC0`V#+H#d4-US2%| z1Ls0{IFUCPBJ}k19&p8#VI(Xo^nW^wcDmEi@~AWYR*AVAEpCSjZKvH8D;fj9k9D7N zPGV(jsPef?MFt4b=6Ba4PCC|Hn%ktg8bT}Fg(Fj1wWQy@9o+nUGRb@GM>l6Eh z(jiXQ@^f!Lk7Ji~0~a2V`|VP!r|=}M9VzGR4AaR=P^^ygi9M5B2rUX011qBN=Qh2fup#yhc(nL z7zsZnPcDXEiNm=)Y4K-)3{!mdkuX!o*RP?J38@xBmmxkORO!hshrWCwaDVut?B-B` z?7%IGq+&Fbtfv*CJFOf|EhUJOV|u*5Nl3FjTOE+MpKhF<39nK9zJ2$Se4U47n5}Qd zs^l=YGdHn>81vgQhMH@buX!*lh$p#_dCDUysQ{xxNWBJy0#lpP_7ii?Yy$SPXhd+doOn4ryhi#e1Z5%6!jTveJNGwW=(2cJ!-8 z4@I*2frYCvISQ!r`Z-MHF%UZw>5JhcZ@Yi?i}9j%IIo?9qRkbz@Y7xDyP1eYk?|K{ zpQGv=Mta8R$41OwB`7eu08U+Z7-@&%Iq5y(_+}x1)Wmd)bWq8^y3mAzfyetbdhVPi zCnqnC)-4zzTxX;2KiVn-JIsotU6~$LzBXmPwn_-S7HOgy7r)6i?sFTf@oIn~$A!BC zIxTa$(m6I-y+hoKgBlgH5fg$`g~i2-gmp1Abiv%FB8rHJ7#|=1JUN+c&K}pdQr6h` z1^{Aj#D8_R%R)%5BtKYdY17px#J}S|n1iT%(^WpPfeSsIVO(NG5olRwS2Gng#kLkS zZBr%D&MC>5wj6DpPZW3c$AN~=-Q-KTJ-B-;dvQbm4!kPV3>rL<$369l5E(V3u}boG z0XQN(hew%l%9~u5uYdOM*leTJn`v8cLWklj>uc3oOLgx)*E?!7P7GmXh^BngM14ja z`41t^*Q`RGN2o^R%^ZSl{$ZVOF5hSpbLN+`C>>=;CPfKn z43o!-I{Lz`D-`CP`1f&+<2UoFG!(|L?gOw&1)(2)e6s3u5}m)jcB)wLVb&uzAu975 zXVM;O{aABLraw4XtB$%Hnn~R@L2OXxCzMo4^7(+obC1{~3!S8>%oV4UJ9OvpIK4*j zfch}?jldi9f<9H~4BEuX?{Y=UeMCzirF49~@swN5_Gr<=-t4UzzJRZUq+v-FzV_{X zN^LPRXc*{Atd-*a48nRm6aGp~Jky3cv~YDU%^R_)V}1WN zW72MlbBd)T;o^#ntf?ejGu0NZcK5R$Ta#m~NjT@Yo6VK0i#sBNYr?eQU-~VDzRAsn zs&&FKC&A; zxf*>{4)#3pZ4ec3wPmHHFU-nTH_o~PjLFxQz4rlmwe;vs=MqnCZ5O4S9GLefI2Gz#&@Xr#NEIKzetso7U8`W&6mw z>m`P~WBd+kmqOOHFn#qT0F7(hX4Is@}wx8ABC7yN7lEd(W0Hn=Z z(sw+WCv5k==^m+jzi89wLrE`e@#&m9#J=2cGc1|2dO7B^=vFs(*qmpxq-^j=WX9b< zGGZby5Geft)PWpfYg{Qw_yN|ZiIq_7=y~HQXPf;t#x-h5~>^E76O_U5a0mz&=^V52CH!+UIj=pFyxnPhN1bY?>Xbce_PIO$qSY* z6@-Z%Y{gYl_ZzAY+uRjqI!DibNPz)GBq}PZw5DdIUQMk%Z+)?&xkUPi zhfq7vDst_Dnm6cT`d0YG^#`80ew;t~Sn!%V^?k3fI7L4IXY$}klyF!<{qD# zYX5NGq1UoaCSRZ#5&+=IP=UUcKZIle6-KJ^k2WNf`g(NWhiAfQo(Q)xz3&y5*7H_8 zE+9MNv}qb}ED039EJUBzOcmQ*YivU`J?y9qx{}nWhR7OK_Gt*u80i>n&^z&(72n)@ zpgwnRJb;FFb8Vr_R#k!2<-mPKqFGB6d1iw)JlOo~E9l8oFFT7*G;g5F_%xQ7Zx9vF zesM=>)A)q6e_pMoHI8Qc`o+tiRC4u>a*XW>o+FVvcfW7Lp=E#VK1uVdJvx7bN1jy) z+ZP!s(4g)-+Y^M9Hh;U0qVU;8KeFb90y7eI3>WO^>@4JZ2#P>wG@E#6%V6~1ou$sl z=coWIjgE~G_)&a3eVno! zv!YDk{2%+9i}YQ_7JA>&1QN4N2wc=OEN1}D(Mymq&rwe{D9G6=c=;@RVY?vRaGHXRaKciP?a}ln<8kW{(dh1PJrQsg`i>;{2`Pz28I|! z?g%d1VNGNqCOB~js{f;svCc`+gneV0t!$$ZTa)a!;FGTy!Oz0~4IgQ z)Zw|vocQpRPd8(gYKtr29F?659?Evv@$|jnnwD)+R{6Qs_R}ND!nrxVuyz@ANM~K~ z(WYAy`$|~1!^17k{VVRcZLjK_ZA!~qLVQmNndFftBxtn{+1`3+B^*l`pdZjQ?*8kC z!am#Rb%*W@FiS!LahPqqTt5dd=W3)cPE=SuUQs-t<1C zjX+O8U-3NLHtKB@QGFnz{ zT8h4Pbv#jwKf6-P6NBzILt0;1*?mHKoYTgtO^3bwrLOD-Dch63$Bflz#E9|;Cn#&q zBoOP9<<5MVjDhkV^cwIn zwEz0W1@Ma>nN|<@3(^lnswV;g{h*kh<(O^@xbvY>)l@ihJta1ucg_^O7Ez*q^nN$> zx^!mrMW0u|cKGn-Il5)6OyW&j2d$wqGe(_`b#q%w0D(Ps7D=IMi~l=2pP_kUekoeo z9i#e$k71{qJKfaUy4%@bEcNTbL4A%i$eK0UMZnhjy2~4tTBek7(5|zoDjOAF(=WPp z@%QXEAx=A`z~FXc>QH=kUw&w#Y&@P zx36$c$yrPY5RLZh`FkT@s+eNjAIP!&5GW3#}m*ndmk>?`V;4w$;- zjr~JN=6N~=a4#koggyeSe*|GqD7FoX7>t{| zLjZz;Dvvnsn*>?P_h_dR_zJUkOJZUoVOyxGu63{c(K9j8J%s=iTKA-y>SE&S(Ts(d zN-0K<%WvJ;W&T<74`AI{t`{UPt7Ugid?m%ir%IeR~FG%w>MuUJ<9eA9{T+jksEd}(j#-# zk5+Zf&elQZcCR;o(XFR;qLdBZ;~LK?N;JI<;@kbDhZITej58f$9(d{m%`21Sb5@&J zP51x(NWA3KW_I`wRh>~=n2v;_QSk!AFS^U8S>IVF%eATl^#E0f(i_ePKszf6f3l!c z#*LmYrH}ub-`EAR^Y>4m^v;+`KuCQ>LeKK{LKvHwi_1`zmWXx9I2qEE4huXi@Ya#Ua?^1Nw0WI<8uV2ZaUWjW)HkX!~>i+^p2g>Pn&3Ei~ zR?8P_Y>df zOIV)P7%%<#yvF`kw||k23A%Tc!cGlM%rBfj3_EJ~yjHFa>41V)b+tS_T_uO_+M}Ni zc(JU>4x0s`28 z901-tdzTYroZ5gBDZrQZqH}^&(~Vvi+5C26uls^v3jwcK_k?WQUhz2!)jIfAHlZOy z=A(8`6bH(#|A7wAeH>25f&WzFmZaSr%0ZY(4r}$ZPN`(ER0R2aQaRmG^4*Zbt&uiw zqC(vZ4OLP7H0MRt#gvbO%qb#qHfEAao9+!!J*CW*&#DZf(r=eD*GysanctP}vysh4 zE0x`H0RK*sngVHSC<L2C6!-^aNY|-IHH+=u8-1o5Y9I+CK5n zP8xNRT6jd(iO4KVFWvvhCF3eSKVKy=F*O&AM1JoR0pMgx$VQG+Nqa(!RH5$W&#Raq z_J=Rc5h|tM;i&UmmBG1aR>`*3)|bo2(9cej4u~S0hQjrS+~M-4?>o$X!A{k%_?!WN zPfs;vNYsV!0pu@`_*lkRC`r4u^zri0orj*3Mh;_Yq{x*ppPW{shHq{ogWcO zP~##L=a=Pbc?|EyvfWb=on`CZ?|`?6>RCAOqmsFpBEM>mZ;X2A9cYJD@e?U%$X<%* z81}|$t6$G7oek2PR9P*$j;X1LX3ChykjG9ND2^9|FVE*T;lll|)TE7n-sMtwM;x)Y zEXWXXHL*t@9kiSg>hG6tKUSdBX{`v23!u$)8a9`n;!2yUf~VZ3+ZIZL>Yaj2>eO1I z@b`?P^G~vOB5iKnMwnt&e*ckBT43OawvlPwy9kMAs1xLXciL*u{m!Y^n7be?CZ;8~ zm$Ox1d>!Pb?VsHjB?6A8olPJl=M*&^<_(Xul zZ$Ujr>qcS^bQBU$CxDakwZGk#FuNh)w->&N=_!0{I=z7df&pE{#R>bxkpf-0Q(7QF z^!8F8AN}bo^Zs35=dwaw4cvlRl@Uy?Y)BDJ5G#B+RwyUALHRbfZe8y@G z1b0BgOnNi_e3aAQ6b06C=%+cS8TR?*3%FAT=Q{PvDv*ej3vq) z%22iJ5@!xE=sdvWdXMw_HoS5i-)ML_WT!|9f@v~qNx$dx=kbD>ZZCnvrOFIOj|p>4 zsIWh2?h03(g3#sYOg%^))h)7B4nD|0p#u4acGYJhDF#!caq3!JN-5(gZ;D4}| zn;DMzT2)>iSX9Ihjka?}43P>>8>9S?0bKG@<^K~~+S=Lz(IQcuOCS|Q$pu}Pc&nUO zo8{iDfV?bD`V~qyG%Dd&xnn{OfBm>3;j?F(S3fSS4jq&QP$S?K>g9g`5T_eFXyDvb zVuYb>5G{3ZhRy$Pre)GM3n7q~HGAv;a4jx=q)g6vE%>bKnxu>RkbIHOS&8J&!s?Y% zc0Kj8&xEzNdAEXCL0^M5)Fz{Xcu4mW(}HE2(LLgP){71QIKuATPgYjxgiVIhe zmVA=s%YPINw7R?y9s>3B&{`>0Z&7|DMBJL(tWMs}3js+>JL@wAI1LWcNq z4el!6l8)*@K5O+{$(XsikaAjF#zM)MB~_@E;ro|6wTY2E1*9EbI`kDWAjx!HfmJ`h zRGApVVl}a|zJEwqbowB`FrX`!YZDV>7~j8+H%RQEiehW#LeZ}~t00COJhq@s=CoR_ z#3e@v-R_lm)AvuqbmPm^JatOOkV?bPgbB8Xp`oEn zl~G7kK;vBVSYG>2K+{6bYZfX&z~R(fD76i!5fYx;L^)c@saA|+(8K`EzR-OY-Wl}O z>s_u)ZJQ56m&oxq-o94DJ6tx(*!LaTsu{7#gfbE8iBeZt5f(N9n9Dcv{s7C#m{5w4 zbN6E{+_gK=`*e^^mq}~2y%8~1H{snixWJ&u>r~c358=pJ8ScVyE(C=jk1gaJi zbDhf-n+=7~xQ+M#P}vm~71w(<;LP)7f{W|3NdP`X`sB!EwG05_PS35DU?JQ61Kh^= z6U?{?eFn%pKWjbabetrGruRP$%uQtI3wa_lL$g&MP@9CmKXEaY655K!IVTi z7N=+z)E2azyF40%+MGA0K6pj!V|p$9`N2yK3V*E04^BSF4GlBJ8=Rgp4>>N3l<2M8 zD@$eG?WdtzyIQilKwaMWt#zQ5WwSbLn~I5NrjRH818o^gcIoMjuhfMV<{7sZW)cw-lg-g8dr|{H@86#l0D7#GG9XQP{{BgkCgmr# z(+dI&Y+aioo1ZWpWx(;jm4qM`!2AF#3knKsF7wB$By?X=RJY;IOzgF8yO;VnTDR$2 z`Ha1xcYM#12$DwJ$b*>{ElP?StQcWs7O(o~xN(Os(~*zC+|i}mEAn1xO_pN;E!ZFB z__cQr2e_Z71V7FZ+_o33BCp+>{Ti$EWw2Q`VW0h)DMxHqKZ*AeBR4yBg}2Cep6~3Z zN~i1;s?sug`Uqh329U}F~MWV#Bs%3oDa*@51I zPW=U456tGK!RenZ#|LMl*`%wdHCpC6w^~kERbuv9$=L{ukCpPp5{Myy?ylUo*9*Me zE?5c>H^1^bNU|$`x^!1exzC5+JcP~xS z=brWj=;v-9Znc<$+_Jcm1Q2~h*W_FkqRt;LCWYS}%3SyfFx|!vxkI^$5Kpl0b&6b@^RdN=!`;}BSjwu%ekAj zH2t#4n=I(%b-~fTEmyIGfqPnZwk7fjdpwAZ*e47MS15D$XoLohJ|>^ zHFggvC;dTqrYchO4`Dekjx_Z~(u7^eCdJ;wxF6?@UUa?dRh6~<*vK~xRhHiT1uv}+?3rdRb-}4Zz35OFiGaY@>ClbQ%r1JnM z|951Ig4K52{`^w!>2=^^kgI$06^aY`OfM|$vU9?DJ@2S;6-R%i2g6u*ewm!$WOyGz z^`R>IhpmY`5iKK#F1*4x-lYemC{>_rl$* zK4Gz_qb@M;e~VreoYWA!0X9x=7~fHk4@UVb$6OQt`pJ56ds~xK9OumfM4?jc;Ll2W zz~b6aZo=W3dxPiS?W^wY?p)r-P-)Wr_AY~96e`f*w!t8Eu$q)^(7B;mVfnG4#$nEYI*^Kt7@G0(pz+F`8UQH5D(Nlk^gLcR z^F_-EeoKyA(SEx2rG_+qn3fv+Ft+ygXve%K0){-B7sKT}K|-^ogPg<+oujYG*_cjdE$FmuKd7irlQYAo`M z6^v~}p`7%JkkjbbE_Er(pI^-eUGZ%3@7j|!s3iG!1P$(lzDM_$NWRESsir7`G<$v= z>szvM{!}kM0$+&~jV|?^HtxVY2JA&g4Th(?Li*7FTn*4^;AVr{F!i5faQwg*%b+t! zA8og5cFZpyRcH4&NX@kL2aZTv2nw!TyJ^}vfgw3 zOW=(=KHhIJ44eny9I{N_vQ%6*L2jj7WJd=7_Ex&yOw#sSddg4%Qfbe>I2{_*!!tf1 zCA-G)f@-}H;QQi=TR-?+<45=M@$+*WqMq3`pJEf#%c+4QHyQUi2`S_T@hrtqU@$#) z;4ZRl&#nQ=#h<{SD#JP@#iV%2{Q;)Ndwk=Fz40`Ubo=II>c^UK!5u>>**hFl|Ha@( zFQ5dU+KexYs5++}8CD>$5-m?$H80RAF~yUgX=u*Lp|*!w_?Eifw}0!bZh z%MlbBIq?zz>rg?;F=ujztU<{x_@k8%E%v~ikD8&q6ja&aA)wb=9h)aKQV9VR&Y6Waby~k;N0l|Hn4nj%*Svn3+V(SOx@+Am4EXdgYarAAa8FZ|HQLY~_}b}x z=H6vzx%58NE?c$3eeC{9B|k-$w@B9)7iYiFcDhfXbmI9=5G(2i$nP1@Sow8X&WzHi zUnK{6@;rEuZ=g%3O}`Cn6XeVy_g?sp{|Vj$F8RANTf7SCoZtS8Jbj$d?ZhS~8>qGE zzP~8|9E#nFRWgO^?J#>ps?cFJK+C19N)aj}Oue>T6efW{?SKyej`8FpDB%Q6D2%I& z@D*YClBW@}3pCP4{m#cASx5mwQ+0gI$4~~`0vZEKoPi-Bq)5M8?LV*^p(MuT&8q$4 zj8vwKp~=IlFgOFQqs;A3Gxi$7Zy%(kH~EolZ$5}IW}#@LY2J0z+tTMNx|7Y5eB%a1 zgr%ehWyErYwh0?-<2vr3{}e~A@vMw8jlB=jNg%PJQ2h7ho2XKf&T@e_L%HA*H8@Dn zpgk{+-^^{2XB=sl2^~G8XxmMfm-)A5$Sll9y~O@{4!u}9rBSK@0QAST&@Xgo_ETk; zpDJfYH*lpbEhSH#=AgiULRRk&f(=}wsc4_DI-!fwg5R4OH<7=SMAdxsTNU(Sy* zHJykYo_qX0J2K9Hepo|~j~sy^*9Ivx`NuE$zMJtX`Ub@?hm{C`Pk$3D8HuCVv=HiK zPye8`%(nZy&`-8L1AG0`W#33~<;3H-XIiMRjv=v(#g#_o|2f(1G4EwB3bWha`(P6W z*^5wJu=CBn{{{z*WqCqyvmb#b%>|s`<>OptntU!n5O()tFoamNpKZ)Z2223MK0BFGySR!|y9CF)x6x1YGii)$lv*1MIJp~iq8PyzU>^QThN(iU^m{ma$7 zt&+I_9EHyLAKGCU=)edC%F1VQHeXZGlOYZ14p?NQ=5t0eXfGnK`$I)1uumV$)B(BT zrxp43x9FpPORGLCYtkB@4du9z^rT1XjU-bf^*M(`iq-75kJ`-q%!>8+?v3F)XR1#j zrh*=o#InA1V#JFJb*C1#*xTK}TpYd26q)J9{U(SPM63y0_tlC@%^P|=k=QYq3wXJI zarPgc>aO~bkj(52s4;&fZ=EUWUSXsTGoRiME6KW3(meCx1ZQDDt{YgLZu%d`hpCVd zj;=47dlc&+Bdr%r+TJ7hm3n&DLDlg8w|uE5v1hErWGRfzpHY0C2f#C0k#Gb79X&Z0 zfA>GfFyLyQ?VDhX2aG9aS>i2H7$ym23xV2AyV7y<1`MhAd8H@b+CiY4Dki>kcZVCW z0X+a`6w*_Ik!t(sp9|z&wgent`~_HPCiFe(#UL7~&zDSmGe^UqBL`NO!~HG8z!5m| zg+)dA`_|Uh6x|kDMH{rW>wdw8MG2Nupu0J`yN7~7EdPOfavtxQ+++0T1{K971A|G; zu71z8626laiK_S*?293dI^X0JS@XkcQ`Tzo!32d8f|=6BPf-1FNayb~@Ou~(-K*?X zn+)Wj^|~LM)fDD&?*mKn^rMzE5_nyi=H$^y&5< zQ-=1I5EX3&>OGREI3&EYI&e*u1_@tGIkYUmYBO*AQ_&cK&a&b35?aoNpS zD!miBI+SlL^BRL&b?-8}Q@&gl?)F!juqbFKdYjKdy@iwGmk}gc56gXW)OP}7NxIQs!`kk+WCAUvybYK{v9-0$ zbIgO73;gNdQj&1a$1-b|Z8WhR@F}d>-cMJ1NhDAZ=em>}Az<$Yq3x=AeA&)_(IM>! z@*u9FPp$=g)C~sX*aw41pXe9+7me4`)4hEtl9+W&aslPoR849gk{-4uWu#1M!1Nj@ z4?Txywv@8{o1hoTp(-2=j=@M^X%XGa&%SrXR-MU))S7?cuC}qg%ZOA@@Z;q*%Xw{j zf21f2iL1@rA~$$4T)u2&yBqtx4)SLpVAPLZpJU#CWe{dhxIF&S!-P6IDr#7B9Mn_Q zsaG&_wAFlwKr(KuV8Mol^VQYW-GR%eLNd?PyPfsennj|J;4A~N(Ni1 zvi0RrJRlv8wgxb@Wih@a;^DBf{WOqH3T;&2075!T6pRB;j1aZ0^->-(b0u&<} z`D%I}$sQl5^>7;e>dwv|L*IEc7-6=ymVW+}Z>j-1)8Bt9>HIR9pfN(?24a0@^bh#v z|Nic|1)}YUS14-UA>i-|2r?sHkdE%#Pd^Z53b9TG7Y@KIXimkjHhc3j&HJ68Qne+c zd}6-d?0TD_LKA?Me2tA8G|F-GgciTui)Pk_ff^S3)~Rgz_lRp}FycqfzZ;AjSk&q% zVV2GEolMPCRb@&{3+~&JLhc=1+W+waWZfQ4gaJ5^d7@dOzAiZ-S@^*6KpE23pB?Q@ z55@CwqUu?0yi{XCHzc-U@(JvV;Kz=4Bd`9JL5C@-t9Zn>-Sm0IxO-2=;Y#q>2J=rz zN1Job$Tv1JPR1K!B3N!NqZ&rKi(vW!NcUAp`2nm`SxZYa)PLiWu*6#?)HqH2X2TZW zegF)5oE)~CTv^XqRfG)+BBz1ox3y@C9^WFs3SEAfW%<0g$N{ZBBvD;yso?Off!T^( zp)&F|1pRx$DBS1YtleL%RU6dF#)m6G%W{J)9ka;2;bXh(6oW zh0n1=ke2-phMlFs$@4W@`dCEgkgQ#B8x(eG+|6TXHaP)V#MM|Q*ScewpsK>$EBZ7B z4*b0j=v1%*;e(sd15y(@G2siaXduyP)}}yrC^G@YXk*4#XC#)Y)AJ6+nAl8S$9hJU zz9yBGd5ZX_{&n);-Sn(c2T6-P7rZ{#lw%S`OR5Bme+^mCn++^nHdVcD5Sx z;#;W)UiBxTZ2VmaE0Yb^$`5vE{-=N>CEjXgw70Wc0FTVNY9>`s;)7ak9{tenPP5yp zxOvN~CSAC1CgS-LapzHQXN&E3znS5^PPNOOYPY39F@`c#7m|0|x26TFl_^1oPAPUTyU;Gj16}28) ztPs#Pcgw+%*^&E1Xo+E>}DrO&ip&CVGW*+OLoC})iOb1vHapn@DkVm5wHyV4Z1lWvr5^M*csBU^x)aEnfL}`0 z)M}t#0j@jxW6YHO#3}l16_RHXgb7cK9>m(64K!ux1Vp8l>$( ztwhj->{#lI=HLHADEpAe%+=59gG&JrzoCH`(0$*%2`g|l!U*pw&YR$JhAFv{F*%-i z5M#AbrOg*dxAyttCPkgj+NTEcn0lHKycDitMWZL4681^`0x%*UtMnw9Mb2w$#-O`P zjDISEeFNRp^rp$7>@jKXktB7^y2`&9<5SF)OnRekqN0+`lETe=n7FBK83V5t?A6l$ zhKeef-|UDzSPFaWbLlYHeec^6j4^sjP(xm~DofvYfwY<7sXZ0<=gg~>9Pe>n#RT|MO^5W#- z)m|P7uarR6%R1Ax_Y|802Is1Q&%+$=y^FM~Mr4Cz4-WKIc!RWgmM`zBu-~}&Rumbi z{K8cq{l+pi-ZXb;ZGLrC32&6Iy?uatj+;#bm^*iJT$59z3MYvmnv{)pz|0091g2$Y zebQGj2)4gD1AZSEZOPQsY=XCmTNa5`%9z{A8hG}X@-&7%%s;eImG?45Cj1G4>wF2{ ze)Tw(DjA$px?ww~JVx{TjkhH3yw{-d(xnbo_6`20jiac1<9OUmufIv+%f|h3`zl~9 z-{6lmz{o?76^z6(+UyLkx%!qwxFaNkpy!^mexKHBEKzUt?nEf@)(SBgrFLJajQagM z!C+1~jbpDDd*dASGE0ZtZh^;h=Ht(kSlpDqq_ku>o{9Tiec?!ZR^UQL=C%YTuon5I!Dt^%@-@pq zQ>_9$-Y0X#=iv#b%#Nk4BFNr9L$BVBq| zkWK#n`rx3=OF>jiP@>_8R8{DM|E#&Wn1|$S$Z4=!9>~7`Z@}JauP04=Z-P5EZlNtw zq1{cSbT{4h9(Y`tE}mm)=CN=Vk`!@Y_q$0>oqac?>7%xT$L)fis3vsnjQtXvjH2g& zmI==1`Xgw}6Eq{s%LG|?e=b0J^uP-mIkt9o`D3}@z5>+^9jF)jPIco_QmG2-TtQ-G zs`j;YxrytZZ?QpCCW*wPd+Q7O>F;}IrN?LGbZAbejvK1isz14}fsyQ9EP;cbW2r3~+c4iR?Ssi<$?)aRF%slW58p61o|-Lb z@XlMJJ5Rio;F53ZUjL-{&Sv?RmFJ;l39I|rP<(LX-c;}5J+d>S4l{QDYWZH4=^}3n zHg1YW`X~J~ZOaR~ySL$4^^)R14|X7tUe1gOjEE%|J(U;Q5S01aL_}aLY&|}1t}nJu zCUkLNCLy=?gGFFH3|i=MeS`T>0tW`>J2D3>u|^x>EctGP+}G(q)a5{vf{`cf835M6 zg=>}xICvw=po6B(Lm25y#BOe)(Tf1N z()|yViyFX(1Cl2Yl%{(1^Dsa57gN#4C+-J`_jA?rvEkA^(8z(=kH}R4Q5hR7GAR_G z^_mONoBaS|pT1Hho7_y120ZlGk#?ch1-{MgI{4EE(T?1-JgT1G?OLB59AM}VzU7_v z>8K0tu9$2eH%9WM-~25)w1MM85<1cl_`gMm?Q6mewEkYt5)H0=IbgzTeTqb{AP|=^ z&dbgK7JP73THwsi`=di^h_YZa~DUoNPbiBY|ra0?_+3lDwsZ!VJJ-IUh z*Iw{~A&|6P6^>iRr*<|si*wSgp<4hE77Y`-ZnH46umdNb+}|I7KBzQpzkYoZD*;3c zO-lKDA4smUr5y8g=(@iux z(2B<$I5;>gfrejA_2>kEZm2=$Ul?ZEnXpRFcY~G>jPXs^I>|}i9}Fy=>u2-ezeWnpT-06_WtP5uTcJ{~6Nq70kmOPlckQs< z62G%Yl^Fr8>wrf?c45C6&xE1 zF?@Fv^*HmM9!9n`zehQRXTqt_ z^n+fKOQ@K|_?aINJfd9WWl0 zhpvF~qJ>wcWr>98Xd(&vJs4gv(|}7EZM%bfK9Hv|$$0+tgat1kJ1tn+QnE_tflK&+*C3U#E{tGcG}z>?EHmUQGI?+fuZh=VvitJLO9xxLx00 zHMP3WZ-W=Tt_jG!sWd=o31Rr`(b%3H?s4P^-$2`xFT#)8=T< zBmodpX%ah(C>p`36}f8;%5D36J5boN3aUd zc<)613y z(N1#e!LMu9C0zEvSA%+^_c!e1QMoj*1BH?@>HSy(F4z0w>>%Jc9&6LE8I&?qTfkpY zMkt`+l{JXAflfS+48XwrJ*|?%O6_Y8y$EWhs3S6;aOF)t)I%r!AB8EiI-mLw|LxW0bRV$ zuLv;J{t(gnDYp#F#-e|U(p`cUa!M>Uq~`v?$c<+Y*~sHJUKs(1*yp)d`uNKl2Q7(L z^_)QPvfQ}QSSjguoFdlr&au(+pX2v2+;KYXQAcweoIl3Q&=j^%G*H+v53o!Dy#n*- zqe_QH!)}?2Bh|{C@eQ}_LBI2n;gGfxv;nO(2ygX~L77g6=!|!kJd>AKm}%Lk{75j1 zuw_gHHo}5b8BPm!lVOcvhk*N2~BgipK&9eg<^L5zo;e_ZvQbanP z&4R{LUGs}C(+fUYW?*;p+7az?WuM>02GM#(n|ircX^&^ChND7}ZsaN(*DZuI=yI*a z3bD9UWbRKdH5j(5Uo6y=$PL+za2lGF`5t}R;Ypr!n>6HKe0-*@a7|k8i za(sbI^@@ontx=3*Q1<_LLI)@iZ}wu`!Gjf_ZTl$k*)OeXCa{{SKTj; z*G4-%Q-XBeeei+~ip(Hl09_a2YhlC!JgtDC5{+S3&-gy}1BC4qz?paguCv#jrZvu} zsO$9Qc%6W!1527;QlMnPfzi<5=2VL1f0dtEPEF{lrsfR!kA8Vh6eY>OSfY&@?ymtk z4<_@LH4C%ygNfVKN*YrKuGvDaT+w~|4dHtb-qWjET_R0R-Meo#Ria34`c+Q&WQ{7K zGlWFr%f7MJy{lhP@34i)Ngxe`6gMbykf+%vd?OR);5$G#onDYr_PQ<_M`QO6OSkb6 z2~T`NT6Y-mpln$Cn9o8jYa8#zIEWP*kDq%U);7(o4X`$kwwr`>$rVIc`qaL&3wg}9 zE|hPdI*60I=c!l3@ee^W2kL~9Amnrii-_PgI2S;VbW6?x_9Z-&f{+iucbp#hT^#6` zpe&I-As{BpZw3(M4xDWm?g!?7z`hN_NJPeQ($|5bLM0VT($Jio;K#iXD;EIO3<6f7 zZU;-fe+WwmP_es~+9Z~VOv(EuGghOIX-)1Y*9ZFzuPnP=4gH)RvrnNS2~iAmpp1e! z3w%R`3}i{RMIgY$VMIK6VRq&k|8PSWKO$!_n7#pBKT(_O>pJY8P7j(diagC>4PaWH z1NCJ9;~+?jVMHD_nqs6}yB!Y5Gn#y90T&8)Yr_-TuLDWa?`{K2r7YlnIkn9sZ>j1< zD4yQhJ4dgmN6&BIU2kwR2zo-fcChJ2D6fYh#vm3;%?a?)o~O?TyMTss4Tbg3k)tzN zj(4nQeP#@*S50e`NLegkw8f$(FBbs|V|w)JV*mp|<6>YWT7AF^=mT<4|NNyFlY3II zN}#E@7~A`){fpKWkQl$txfMCGXejsgaebIB(d#rrl=@~5TRpDt*cmt~O1@4!P$~%2 zX)YS`N$p;p5B+gev}Np_QUy#r>~1kHfBXy8bhV`k2Tj*;4#rQ z=echYG`w58D+BR4-^CySq4J`2t9 z++p>y!y^d2p0Oht_US3u9xf`hD@%jB45>DbgI!I6TO~ZAc5#VS)vtMj%$ zRHr8{W&1nveKCB>4Mh2^er}~toOm~$9oYiwBIyru<3`nOcmhRQ&Qorlc3D~9IDxv* zV}$Y#+R1!Q++R#;h+jo07_&7gdnKe-8xy)6^Q(4OMQtyauxd+bFf7~Uj1O%KB1huvtWIqO-133u;1A_@4tuaJ` z3ID ztnrQag-8l|Ap)M0LE(eNLyNdPqv2=H8M9||a=aZeI56=2!Xo)&evODSS}~cQ?*PsO zKzmnRK~jfA&w=tokQ5>1dn&dSH5o}KiarF-e+11#=?CN&JeA->ghmxcKaqD(>OS`?#)_5PDZyJkD;Lsw)7BfM*yjPOegB^pwAlIza#tynf(egtM`T}&F-fa8CRuo8z=N@=rh z?s*Du0&W4Kbc8>!RQecoFcr_7{dxHqqhqu2fDtGSj9rFu;H`>@mO!aeY}mM(EYsI| zU~WY(<_)|^dwYA?rEd`L1s)`}xE?{#&j$9Yoa-XA4)SxT#ijRH1o8`VwOIx~KoC8k z^kInMCFt9)QVA&eHZwv0JFmux91Ml=hK_P>cqPJ#oaCpL@W|2bE+rIj5LWv68MQb9 zMuaXhjg7ZXcHnP7lf@{>V-D`vB~D0stAQ!??nmfrp}%DYO)pf*xE{qf*jeVw-0Wm- zy;O~#q~%}Pv^a=?#jT6y?)~l+X1+q|d(K#qTtw-M*q2Q#*~pWuRk9{M))ee-l7)1t zh_T3+Cx7e+c;i(pcz=u_;>c_7C&yt!A3=kOcqdHj`$^h733ewz-B$FoIrrpCk;?3G zA_x!=UM75HtQ)UHq#J+zq&H&R&mE)9-rt20F{#ixCpWoDMQF6|TgUBz(cMnpQ6Xk; z==buQlRYXU)l`&E>VaJSj{m&l@d9eaP#>_UM{6tZLpla)8+gnB_>X^w7HiVeBM=XB z$N|dx?E%068c5A?n9lYWqb2%BY7Y;SBbXC<=b(`)BT96xrH2#CTzv2E-}07N9d0+P zSFAODPiA`qpRY#R0`IrI&HpfGSSRYcEVDm=^uL{I1yvL!;H0Z5c%*@&pj!XP{iiAW zjhzQ+AF=@d{TZ)?b!MiU_XKc6(+K@5*PCaeVG}McE(#XQwV9HzFH58@dQ96_+j)FY zxg3abmUyM^HAH_y&IV$aBNaILvc^W@*$3Y`fx5BaevR5W+G@MR3r3kQ3t;U{F!X$2 z@B^F?0KsgXoPqKY^F7o|$Wt(9eWnwP!BAO29?`e`Q&f3mH0Rfb8_w0}omi>9$O09< z8fEg!go6?XS~%ksKgZ(DAMl(D{faniWezRXqa8Vt0fDko{u@b;jv4}vcW*jPErA=T z7{4xqs_{#FyskA=tdTb^O`629v3G%pVSPWv`_by*E_O~`$*7mV$udp1flm89w-q;B42uhy`yz$_~^rp#MO~fk&`42ul$VuVo!i|D|_P3uVldW_4-E; zAjX?#8t^R4wTJ$d0u~QS90W39CDN0HwwrhZp9KXHd&tQ5yo>I|7v<5_RW2Z1F~)a7 zu>x9#=4~s0v=dqW1>Gq;b}acmx7!jDS1&yWQUvy#J{tx?*J<#2jml-h5tdKFdck*H zNa|c;q0y+++aP)Z%0n?2XF&pBX$jGHVAa70ht*bMH`B+xT`=z!V&cxl-Xs4c*cjLy zfG?pDbKhN#O&tN;7Z~aHKE|}Tp!r?!7{wf7Ds9{yegp$H=9j-mQXqP{5q(9WRX*Uz z+b}#x{L)k6;ZLmgaj(^}xwvgA^(;R;Th?N-{P3LCCFk)N@l{D}(!M(6lS%i>K2Ft> z?|XWz!vD;hbZ&?R%)8X&wYbxxxC3%MiLe6vix4+C6nU?`4bjl1{nRO|sYWC#FhJl9 zDV-c@h4Mm%3#-1**lW#otK6^jmd7Zv{jS^Bc=O($Gf62u%*4@|X6GP**ef+-h?sr= zlf;Hk$|o|gYXrN?&}3VRUbXr#tQWg;b>YEDV6Q;=a}ax2S$V|5g5}}2+zaDjA$fP{ zRUqXKu#WL5LaLsnAmS|{T`P4+sdoa-FD5WndPVke6n3B zMVv1Cptqilz90E0IMl;C=XG%KXW?_41A=b{oS=3bb{Iw zb-e#i3ov&y#Az&bEB8>W)ZK94pcl7uWSL^>JQRJH#s6qfyfcqdGvJbZh%MP?e~Xe3 z@(LkI zUO^R5mLgaRnGRY7X&7MYWB@k{{eD)*VKBNlcFRD8>p%!T8pOJ&p`Ypv$Gm5c@M&qE z_W{U+kOx|Qkb{M{*BO>feqaYF0Z?*Xm?&6ypvNSJS3ajs0;?)eY*5P@Eh;Js0x3*5 zGoc4^G(!8VAN6a}9I(xMwEFb;Ec7wwW{vmW=WVT-blW-@XxjYHy7ifGNcm0{>*J3% zTss3Ol!%;ZD5$+6KNwF1JGWhsh5=1?whEzp<(z+*0xeSO$`fr!mDwK^D-v5s-USD5ZO9G4-zgeY|%0& z>w@4$h#D<+k%$Dxm7;9FO-W-209XhgcW0nPuCVcPbAQQ*>CEHNgLU(^1{J8b;Au!QQ&Oj;*Y)OE8q%b}h z^SuV4(=&l2LDU_QluC1ZmDOO^D#sYwgbaD+rgWa)kP!iJ9ZdT0(Y~$*!5={^Hu-_0 z3#W6=fmY^pj`VUwC!5|rSPAPeU z_rJ$iIt_ZEdTiLA*H2TEc|+1A09`-|;*m0b@dqWT_t9bk^oxJ%;H5-|G?-NaP+w7ihq^Zwz}tISKXI+5`JfR)z&De|-n`3LD)&wPOEs*e>%OH&3*nhfP4-yS(nwP166q`A#8&AdLvjhOQIWxju2*EC zuQ$+>1vnfut&n8tBEbMUehdZBj2vvvREvji&NR!!uL)j_oWCz~9NYik?3dT(1C^Iz z^j+W!0#o*>uZ)(K*6*v^t2GuO)!KQFHUcUDk;oZ}{M3X?|Y| zJY(%tazUNXzZ6B;iqS)8LeOiH{mqcaL?V z{=@RwGJUj2nVE^r@=R&sKv5pjmX&+oj z3SvCfvO5&&LU`*C(;h%(cX1I)+{`N=PDSF`i;qs*AH2cxi4ohLlhQttltu{{bh`9Y z#6tpel7Z%l3M1ojgp@fNH4OcbQcS*=rN&gw=7H6sNX>`8o|X zT(dPuOky*(HBuz^XMP9frpuH&^IUEcVMjhcV55npKbs*+F8zkCWy5vc=sohqCKGBl z$I!=7>j$UTV%V+VP9=%&GZb|1*)`PI<^!~o{Jw=}Qu z_|5gC_^GM(9E~24MBap6Ft_grwUCCkgD|D66JKn{B2TWEqv$B!Dj73klqX)dDZgNV zj|h-_upC6E8sKANq9rVVi`+^wG%(m*=Ynba{lm@?*}Rbz#b$8-V!Hz!H2HQARNIb} z`th$c^4LlN`2Xs~XB{~90LCg^Ttv4WP;b`;}tTVrgT)7J_#$TUu0Dr5I>%q!6`}Ijncywn=7(Dn(3rKTCb(62|KV z+U1h3#?7r^(Q^KYv+T4)UsrP?zJJ<4Qqlh?p3BugQhQmrP*XdBiX!fmauV+oU?VzcWs* zxHUCfj(RS{HN**f;Qd1uFt&`X5l04>abE)34%}k1WF?a-x!1@(Pj0l8bC31Bf*5Hl zhfmZs&raW%>x#${NjcgdpZOl1`8s0ZVq!qf8^jUm1~TGfgAdQ&sTKm-aU2qQ%?FL6 zGkoB~1;`?x356JiwY9aaBX7(s;1s~YK#$j3&X#WSZd^+<-kbm*DW zyf|%~-1vHKQI9K*I7+-YU}cyvoN8Y{NdI|>+MHsZsrb!kfxKw=a^>ahzSrJMDZB>6 z<3Eq~e5Up{6*ga>+&ryD*z8>FFG{-yMBLB(28SzibKq;w<&k6<63e5XWoh{Nh!BjP zLy*b@IwUxtdYz$PK=TPbh{fN(v712;)qV9Hyn3MI=P2ji1qoq|(;^{4lG&n|b6Og^ zfQCgPQ!EiZLc#fkkqL)C_#L9L<>AqSEFGq{&$aaeNpJeMJ7y@z`U+AV5}5Dcw2XuZ zt@?*x8ScH@@iprYqv2?=uGE7Ty(~=|+VWTOtyPqh$^d`BJB!}w;yUFMg<>dgY2>XL zw^Vvl9%9RVK7TpniDe(LqBECPV#i&5=FEVsk5Jl)dllGZpBk<{fak*PNsynj^BRnE?Z zzSx~u^1r)6*}5%crSm(OtK`p54_7LqcUj{eFQf}M)kOzUeI} zc-YUvLmeTI2y{U@5jyh*tf7yubo{UuK3&yrE~m1i%Yp62C@i0_D;ml z`7ZBjz*StO+fSh-c%PuUrqOyAo5dN#4KHVWIL74QHxLIQRpgoR{q@yJ3O+9LGv7j1sVjZ@7tL8fEJo$5@%HK3Y24fUXfc?_u zEALv@-sydc($mo)s}@K*!Crjhrm+(?y3>TS)m}i#ee*-y^hLMNB%{Gnu)Z zMn`IZEm+^kb3(V11|xj>&y8GyaMVV+Cc4nB9le8bxs<(!g$Lp+5_(IyFM&ZT?X+oZ zZLYfctf+<#ZYuFTTQl+sQIWmC{R`gVdprqPe6(aE9(4HFJoIGFTZFqW7(p9vYg`ET z3V^Tjnw%CVWg95ppXj3yaU|^4>9c&9%$MSb>pk40Ref&xeY}~r)n_NZRywnNh=+-x z8`6jD7H9fC_IEGgR-J8HZ@$gHP!wCNG{`M2r~NRq*}b~Dnp9|77Y>VCF|qrOzn9)r zST7Lg(|EB;u9>q0#i3ZWI!-4Fan?F{iMPQYre;Mp)@F`WhALkCe0&Yf`@$CkiP7pzS($2ImUMPc&R`4{ zQG665T%Z`1TZEX-mH_L%gk#US{|w5+NbC~J-zn@P;aF6ZJI5y99_1UBARVwjPd_}gK|JBmy#sd2I)dmukz-XpLz<5r3Hka(;2 zyjAZlr=BCx5*}3)Dn*~9?AV7?tpnZ6vFq%QXLh8c={T`rv zpcTQ8hcg#=0TD7O(lT;D>u@~f9_<=kh?WN5Dyb1WSk>A>bDm@gT0 zww#*}`5MOr!Us$yTlqkt^CO7^c?YG>MIK)lKXuA zTh@Kh7FVr#C&C8@GWZ6`gKv4o`-20R4)!0+#*eP#r~6s6{}mDFqkz=TqmKr4qLCoye$=@qY;9@#7VrD$}ujZqn;0bnBp0AG<}W-Gu73 z>VgN&t=vamsbhU>=Q66;oej0&92lJo_b8P$zSyUp@x3T8{0By+^P=mi^%TA7J?K2_ zUcBgaZaQAQ36UGJj5825`%nD1;c+nivQrpclp2nfQV{F@8^irDmxOb)b=my&A0ujI=Wsq?OnbT;Y?-CP@MV_c>6U(I z1yoeD3@Y>p^$VW-ydr0!OATW;yjL&VA;^MV;NmBujPj6y{`Vp!aa2QvWCHn;U; zP`r7DcT$-2CS}9&WPR@8;^5{SjZAa&1|F5v)Wv3L`Bmg{BLwakrx;@ls1OkcweBDy zJxKETy06H!Iy-+ykw=*4qcAVA4VQIc=AmM>Gdc#TXCL^wR7`x9+k|OVG6Vw73w3S= z8Zg$oOYt0C1h=nWy28S*LIip3(g&5ogk-9O%eV@U4A>q1VtS#d@S|^*@VPT)YztlE zT6}oZuFG73C^lC6@_GW($Q*7N7o!^Xr#xZd)%d_Fw!>hMCwK zcr>$0R8jS>wjV#J{e3a=UjFjH1AvWY2LMgVu?65jYku*3s3F;U*7C4BO3)B(cQpRN z%+Cncfrlw0D?-pN+D^(kIDZrUnl;sC@OKi}ldnNOKeO8eIa-{hqmxQ$h$ohRFB-p6 z({fz}^CSGT?|K(AH{U~iZ$ksOLnms71-=(`uArws#dT0|nLbMu?^tv?QnD{ka1OC| z$sqltBU@s?(mNjZR*#^RaMdj!p&j|qX4<9v33(q=B2_8Xty35L9ydZ_j((b;AoLq7F zE&VD^&01X<+Q_^o*@MQ&-&FHt*pfCFpC|%cF5?Bsg?-8xasO`V!c0c?@-N#}Dqj8- zjSG{QKOck%k3C&OWG?;14CX!2iFBg!y3HG^tk);W$(YNOWuf~;CCK#OD)zpGqcjnw zaE|AKoS}!HSSrsxgPtAy+(``|!G?l7UqN;`#Ww*_>khyR#_qH)llN8tQH_!N91eyS zK<|j|&+$$qan4E2`VAf6ez+efW@%Cf2NXDAv4mTV9k^7A96NSeh>1ojf5L3-5i^*j z)AF3mVCUqF+{Y=lTQ#i#am>8Dy!^$@4(11#kVqOB36fG3HUN7>M8PokT*z8d8+VZm z;(_#omEkaLFb&w4b8Y#A+glE7F=AKyU%CY;lQg9cdIFy03Q_mms2qDHAC5*WF?ORD zLB*S+HU&K?B1@6YRDY>NA}_#~NVZ~vUcyS2ELX+BQ9z!7{;zlP591^foE;G z{H-J(sT_y4w`Ly7i)ct~%dw-RSkxIt#Tbx}5c4yY#u+i?g zbu0$SO!UylQWszxm) z74GEV?&Nte?X%-@4%X4)!S!!X1Ly>!a|sSZ9^l+~0s@Sc zl{_K`0G0uwu)%oHrG$-%0Tb+G>I*PE8B~6>3NLuuJC-I3IL5@^7~*!?g6G%Md;od_ zF(3UN5V4@D0x?azc`IsX4#balGSy<_zB8R~;q}}<_yDDr6pAe3cx)E_?&c&T;VZUZ zAmK;Xk+M$cl6>L=^5pGz4unpwQ^muSr&^%c6_%EGuOXPu zzi$0G0ddG+t_jaV@9S*ZcgpMDQV&i$%oi!6F*{ZGr0mqZ)4feM*nj*(dx+o&CF-&1 z!^Vq;^kz^Y!JT$6ozZ(4d2hcW?n5J@V2RqEiU&LkJ%=EUjhEU`w#u=e{X)r~?uZ@UCT|%?&^f9qyl| z>S8xCxIk@<9Go;L2K3bb&CF)PP6zRKHMoEi0yhc+n(KB`qVy4%$hS<{( z?suJMUrkLY%~UKLi$9&X{@OjV#QV2#FAk$;=05$Nb|mS;W7F!S!m&U4COxxGNGj3! z3AeK3W!HzHSV`N?=s{Fmm@XGRNw4sNaIQN!O&Ou(cXtM1jleTf?K_{4->~QGor2Ud z)f8pR|gu_pNGlWG2%q>>aR*CcZ-lnM9~nxX{-sq z|MX;sDExkaNlBd1yD@n;2{-wFLyT1nRNmK0BfHp`qxAF8tPaQthq^;R$;&@ev11U* z!{m3=Ya~@|Zf1tH*{~DEz32qG+d&!1(X- z1NEp*Ak$%kUD{&#{jtW|?}w<1)UN?Cg21AOIZiCbiF~P#N=E}#N4PNWI}}>nqzHE| zH;Xs5$XON2(s8%_(K|S8&5w zE=ptqrhzj)Vj@M-0-k1(gn7unQ?dne7@Eo(2AW*&f2STnejpAJ6z|jh>gGLqSGaX? z3+xuXUW+>(4Uh@(_WT`$v6k+>m4* ztHeH7)3+>?TA4Dm!UcJvK&CiJ!zM<*bAUJ8sh)$m294Osf%+k^l^JFqpuXw#g|EGf z?oRSn!yrtnZ}>r=2Nk-|9;_MjS3$vZc(&=sI|)Pd7VpJh-t>#=ikNA@H@Q7J0s7D` zHn{wWE}|2(DbG}+^~wi#{DWkviZLo&NwLm+R=D4I=t^)3Z87;eGBuwboe84x1`lS4 zPYHNt__BUFsaVmtd0E6msF3!T(C;NKi_4PXICCLB?0nJMw_lD1x&gSpC&egg(MC-6 zczsOl$|noTokK@WqMTy4ElhQauwYpuWC;^#=LR7*<~)zq&PrpK0&#d+A}%u{ZZI!l zDRE$X1#bI*UD|GCme7ib!8;pITD~SC9jTsLDc+26ySLV~oQwxM?KUj+jyqwMDgW@^ zHP#%KZ9(RCKB?(1pRiCcX6nSh0&7bT8^GYrC)1nQ!;r*yx*&6&g_?f?)F67Ozp1ti z*OIscA&jw`;NA@K69I(z6oe5VkKX!Fr(qtS(XpS35M zAEz;GY5n}P?6!v)`&0%|#Aey%k~Kc{Ft)?TQihAAPV)ll{H(QP33hI6GmeHr zBGdgc=XyMh`3F-8372{Kxiw6w?}R$W&v+e83;o9JYLxQRx^uJI$K?vD?ehZ15&`94 zc}yCbKeiQ1{C`>iIFUWCX0vQRE`DIjPWTEFP**>TR+@*b%y|Hhm&GCGnY4d54=vFL9d5WXVj}enAk3gUUlyV zJ;_3@%vqkT86annrWXy3I+#F!Jcr5#=Mr2y3`GUwjy;xRWs5c^Ww|&$RE&ZG7x0}w z`k)2MK3+Cbea&36`HQn=rnv-|cQ4kOrFWkIzn6wbj!aK~C@s^RIxpV+{>q38U1ogZacIKF=`ZEOznFd+D14`(D#V_B`_@;u)*qNT32$a-BcwJk8OFeel$m z`tOS%1b=gd8bc=)hIf?yI`*~fdk@mYoK)=duj0JEkCELQ+&+?SaHaAV%8}eCxZ$39 zA7=jGCGPa!r|BT~!CbHkm{&jQSiRj|li|+zr~W^X*ateYcfAq4V?xTh(qJ>r);mP6 z`(AfrveAsZgfS)_%xB@^5+!0>w+R*LBjUK4nTOHL7p8)q^DVjv0SL zc<%z(z}6g%i}?~}WbFRn2zMuLjZchTrWRbCZGa2G0hcbtc%|EJ+Pi8QTdwvLI&m<( z*+xT#B*cY@_t&c8o1!m~=(kuDe?tzTbxuY3M;TdgnPN8W^&vd|R2`EhL1W%`Ie{A> zdi`Gte$NXvzyQKno%9pv)qV;*484IITtG9bHdes;=~-+*H!VwV7%H%>I~FV`jvKBOO&}CTi4gFML_yVyFG6vuihG$7FT|m+EuYnx7s& zg*|f!MHT|vrJ!>at{tv52(e0rkHUv0mwcEV90TtOUt?JAHg@#FgC^VB>YaPDY#L3* zQz2%zprjG(RQv9ZqiQ)nKRqErdR01FBV2CAMJ~pdtk^Z~YU?7gSyf(7h&nkv`Z<1- zQT#`Ua{_E>>ftJTIq*sd%Yd=41y~wRkH?y+je$nqBE8rmO~>nn$Tf5ii?RE{N&4tF z1%@0vB!OkUr%&Hw2;ikvkYAcZsQyjJ1C|t?t2;9@$t!s<0M~uy2iIas|5suoPRisf zWb<$J_iEtEyeC{#gKD-h_{-m0c@;7SOL9G8me{FeYZl*?kEbL%i{}AMg~m=C5iaxn ztQCpHt>8jIoH;Ka9_kcZf_V{cGJKfB%17ki@A2i09deKZ5DC)O9>S6hEfys{T1tnu zKy{a#g3|HLgNUF~xOxC?&7HP~>^yzu3xHc$wrQZ4fRHH}1vEYK)Vj%v&odgm0xv?uP~xjUQ_}I6E|Sp$GB<>a zKN5riJ{^{Jlk`dVzQ+mXY!B)cA%O)!1R&@2)A57V_SH66XbJ^ZaTdjt#s1wnbh4vK!77my<$!J&#MmDtDX5Ce73_FPq{X9@1l{B}#!{nJ)Eyjj8ahUZ zLh&lkbOYM5gov)H3MS7B7?(|o7fVa4s%$Ix59tP)mXuMPCJlbG{|_GVfF@lvkGr>= zI2`vu|H5rCv6$BHKwAG^LV?k%qGlH{E82V%+3zZ;)botoZ%5ScT2L3-`UM>n;+RCb z4Sgl+4Ygd%1YJc}GD!?a2sQMd%v|6;>DdQ87qry~)pAcu{!-NTlT66j#SGuji?_&Z+xtIfx6&)w^~aBl!V8rPE=(8(Pl)bBH3U|rc5TqNt~ z1wPj65vg&PTPSqk+Hkl~%G^qHkfCn3p(gWM>}%VS!Gmly1_tjb$R)G7xsNBMYfZAN zEdoiV@J4|b46&^02EyxRik4=0LuAfYRMYpP0c(e>*W-;JjO1W1)L^hIM@B~Goy#EH8y?4Dy7-;-ep{yL zQ>zH+P$AZL&A?pPnc~3-Y85O{wa}c6L2@)`)g-@;PSTfp{x(TP&-FdQ!Uz2D&?4-s z=(dit%*Zr5IJszjXD{L@tTe_=gN@lGR=0iq0U{I2b!=^UhfZQX3Aez>_0-@r?D(gY zu%q9N__t@ZZ0)!;XIhidrc?7ZJ=c-q_MLCYIQ+06IId;cFqtt*3U2~Yf#1mgZRn3J zXbKg?5o7bx-?g*1pMS4y zh%va2G1=0s^s+@e{)nBYozwPO1si!FRx;(v+DrDx@<4!tCEcK_{ zEWG=Nka7~Y$%Rb6^XtiWo6uKqb7iSglw(Q=)%G<9&68Wy-oK?CQur7s1?Q${R(Ga< z&K{gB9snHBag*t=*{<_OTDy0nNg*!wP+5k-c;7 zNbLK23-SV@2XhLow`Wh2+HITZb{}7IyFKW1@0Qrytk6DbbiuKqeRE34l>g`B=I`A> zKPB*ONspOE-szvDPG+3@eBZBWl$jiq?l^k6SHA;Zry?{Cmm_=$`U1+YHm)Gsfw2i( znTT14yE1440vqXfUfZAzXE4;zxg*?Vv__sX69!LrRNBjDvaZk+VB9e1VvOjt(6fDj z)6r*$dn{@JQ^1|+Z=k>hkdDHkx}m}Lrh(w48f8>AAv4V8AnfICWV#QGGq`m@TSd6F z1@f8T%;TkD9(h&?eFB9u-)72>fJ9+F?7IBaE5ro9)N;MuV=e~d%jRR)Ou-y)+^irt zqEgR^IKJ21kuLvH!^%B~Bg4E&+)hTb&8(*M`l}5aP=w)~+j<{*2a=8+<&i-U4cyTF z@C0%bVLkx(*kJO=n-Sti(^Ip+3h5N8`)PI(ddQ+U?7ijtdM97_& zzOit*xCSOV0{=IF(5ONV1)_u#Qb5}Xl5A*1YAwEN;`Q-q;_+fnc^B_^Ydoz&6U!}@ z#TY7`9)pJDeDh;Jeo5`wF%;8#zio@EHUrX~vy;sdi{|(Q^ zBc+r&CB?#rI9*bB<1z&kyK%B2)X%O>VW%r0R4bZ4p1eoVv{n;_6GY)v#yP~>(PM{e z8n0ge+F}z>07`XdBgx4U`ImJ$N5>|s@UQts`UqCXQRuDi7m!$s%Jv;-a?nmyJxa56 z#wr|%r=yov{Txj9<%hAmQzT|rTzI$pkK%cgjPc$Jr$E!n{vhK6ZXx{fbUaE)qXnGT zUPny!2t72E_sHhzFp@_#sX=TB{|e$Y1u+7GbN`J3XeUDhsP39Bzx>4s*LP3Vxjtf? zfnVYm;UIYM`7YQY7TpFOa-oA6Dlz8akRhJp0i+#7yf^fyATu9k1T4cY0i~U#?|ejg z;{)Ab<^V_jI(f{dUNkj!N^_yx6BZ}96c$uxe6$_V{oxd%L1#=mv|6w2Yp?VP znEK3-pot9|+XfiPhM-@!uwZf{y(iA~YwzzguDXQLo)0i8g4225%R{qrST08(<-qsH z;?7YARf)v>wOD*Gp+B>az6Nhc+Ou??t!J;oJPlK|*Silr$Vfu%bXVY_OyeSi>u@04 zku`i!vnVXNz=nJFt9SqMkn^4#Gnp(KdF=V!ei{qpf~#vtauCV*rC)!?w~kSpNoF$m zWX|;=d;RTB4|y@kD*EG6ja0V;|c~EtN_nSg1Z8cpdgI2Q#BN z5=cmD<&B!2!jB{FL897&(YzKqZhkjA`GLO~P!LRO|OP~r3V z7zDnd+4{eyaH6RfFRELMq*P7q0Xzf^b6b{>)x z^-^6L;I~Qna|Xrc374=N%bk0}pZM=^KM{M7-I*a$@Jf3Esm?92a=LEpB^ImTD#4Is zU>YlK%s0M$Rd9}dNe(M!nPYTrkbpmszWCV|E6SRvQjPoRxi_QV;EXsZz@8d3=6oe4 zEAUI%M^(`grL&{un-exezQ_*5tQ3<4M)*XRuK&C));GC~L?^fimLAJehW~k6pPg`* z*k-|h1)LatmiP4jbz5Sj-b{gkMRQmFd-XC4#%3N#7*GV@BIOp7rd*cn`^m{u7j+ zt|1)iLK`KjAxZ1H?AxFP*qX(29<-kv^LP_9Ms7@4SN@Lpvk%4yBkbki^S-tmn>DGV zuo3E;zXUaKmV-{v#GF7%i=+WWV(ioaf8^G6$QSFqg{ajI6vKNkF}X?F#6; z-Hlp8k<<(buKURxPT2na>@pGV;!lq61h_$FPqkOEM<6}qnLQLJjO7wNv>?&{+<&8A zbY^$`_tfBsqYg3_D^tE!))sK{-wSq7eaN@gG&u>2kq57M>Im_3{ zmo_zl<6h!gvJS8k?_C){xl$3~+R45rF>_6-&Igr_XQRDW--8^tdOK%IB!@-Yghf@# z8GeLAIX?RkGK1CMlmVke!z^8CjO5%m zw@!aS7+#S1-j2c*NjcOWnD=DOFtY$*wEAE_e@r<1Q}M*s zab0Syqb9{7dG~IoZF)_xCc3oEJ4Q#O6uAG4+g6q2bW?e=Wr=cge?R#w=~%S#dC{>K z@Bi&;Wi)d4r63|Qh`R2#UQs-8;`t)4Uo2e=46SG(&+!E`P9;sp`BF_DJ0Ja%ZABtL zBLuMPqoymu{Fg3Q0dSjF=aZvB0GEaqmw<=?u$p68S*4f5pMQ=&7kZW<9_A%RPhtjY zSm+Hff8vMMes=ruK`=2UuvF_+3%9M157q(#J( z6zNWF{w-nO$PIi4XOJ9quN+b)N`NheWKi;>ZLr`ytOwKN-=l`y13Qrv(E7)9!w-NN z3>G*TQ$X@ZL`4)SQT@F^<14`tyCW&6%mJAo4!i&Q43nY8zS}JR!^nHot?9Z26LspkJOs5Xqk_130(kK+<1e0s|}`r8d2gBhj1{-!9} z$uHs$DBSs|bJ=InU+#BsE#a7hYY)IfswBYiPDNW-6)qi6eoU`rKse~*48GPN>3s0y z6hEzJH};D6*Xg&$J_ftNEHvh_>~Up_3L))tm$2IN>t9lK!2dT}yh`FG@rvW}i?1us z2}9fQU&+t&xMC{vV0>I&S{N&gI6OM@1$q3g=l{_3)nQSm-QPnBNOy}!3L+iDP>LXu zD$*bzB_%DLN=S()ozhYwk|G_FLw9#bNQjEUduE^C%jLCyEW0>-=bm$)b3P>_b^c%0 z8WEUOMJ}`7O>wu+y<&+})q6WlZZticDSz^UY_AqDYb%acr zj=8K?&Jgq}06@jbMmx)f$Qn-iy9d-d%!rEi5bu8<-6q+cL8Mp zF81yfSnhR4e*>>N;`UL_^~&1&*_Ce)i@;rT9EQ#rB<9ACyV%`J0?V+?$6ks?|19e5 zu2WmE`}_jE(T2Huw{FgvRN|)1W<~|kd*t-~B0zRoZJB7LOaEQ?Fx%`5__N=g8nUYt z#?~(+D(jQ2>s`h*aFzEkmUuz>n*_RhD`-z zS;hc=F31{VItWx`=|ewoTgD`=0L>;0@#o(+Kn~isL4*hfv{^dEDkb4&^vm>DI5M8w zDiymXpYs%T)CF?K;aBqG{^1WVCL{>q-FWfNmGUX=ve1)U6%bq#%9Z6Gus0?Q5xLQ5 zu2craBkfg%liwCz&#-gMg1s^D1(NBp;q=2IXS%>P4IQb_{ANgO*JDPUqHX8xOfwBb z8ugK|P@7%Cgb|z@zh?9)*l~an77RZFPiv+x+olqxrZ;7Vf~IMuxdm_?jfqvSObG`P z?1?t{kCml#c+mw|k?9T@T;Vb|d34S;BXK)4Y11^l70JQ0#KTw$WYYI8wAS+KUxLZ72Y(4$`R`FfH4Zz|A-1Q0VeRAVU4=M zdL~z192Ck+PB59)ZTmxqR@vQOgVM^020K8x0G0h=+P|D}m3@6-bnKpySvGAwaafzU zd}&z^1Lp~HZI!tunkpxa`60L7rK(K15ic24d6Z-RcT0r1`{8r)X6;Oo?_PdQ%|vKE}e5ItmQuJh$=^5y#mb)6ziv(C`lm*S2jdkk+fXrq8KI;x5S#NG}rdcvQz_RT~LhCdbb(%KY#}$=zM^Hm-x) zb;^_v3@hLtw%p^j_D&adaRIV$1AhpW!1%_Z)?eY(Z(#YHe|gB?{LQsQr`T&CZtYC~ zEtbV-dxiZAuSe;x9 z(oI(^LZ&ZCpEgkq{`QqM3_y|8VVRdR;!;`zx*Ig?71nC9R?QM}?oZ(~LTJ$?)j06p zBN50S2PsVto6xrg2(O$-J5>i9*2jh!H*GI~t~$|S{y)XIw|MRf*SekwzP~Lg-(`OI ztnk+3A{Od0iA7;W5WOqkCY}u%zN+LsJm(aA;5z4itKT(TUJWUxkhhE z+Ezm*0uX^%C6g9lgVzjpiPqTRgtUR@B(u<7moD}T!tM^rI+nwTed6_+y!{UZ_r9)+ zlTu#gsg#on+(0uU4)8rk6DJ6w?!U(=Hz+02%4$ngrTra1ui`wVhx+@~K>`Z55pcY^ue0XC zQH06_3_=?D0Coppt3m%9YIc|Q2;!9fv+n`=V;aR`r5xme0CJtdJpgWDB*Q{&I(GFi zM#KCy;AgU*Mt)ULoVbnlzKHr=v|U6z9|S|e#?jS83@w86C1gXV8lofUe^P)E1y=!N z4>CyJ1Ctwujqj@Tce1T+`3wneF24{>TV?lsR%HOQP~ikdbXYwZVI#WDFj{SJBYE`` zKUk8G0KoC*5o;4D9nW40(R^4Lth-^WjrLl7aW}p`%zBHN74IOQMCFo0n8>>6+x#gm zcc%0+gE_g%SGn}m3QIH`9~_=Hc6rU@H8xFb5(b-#r6@Qo+-cXS{WrisC^S&Fj^ZBm zTlw2$QsbO(_CKcIZvYWp`O8D@WHmJ;O9g{9g9&Dm1HzEkxn#$-iO;T>{--(+u*A$- z2uFaSjXWD0`8Z*5K4%qy9$a)-nP5+Rezt$fv3Gm>gQ6)6gip^t%a@F_j6q^AKdnrM z>Y$8TxYFrIUF#xU=Y_g-Wl*UAfe+wP`wgtbKf+hu1zILZ(vypBi*$i5W}%QI2e35+6ESxA+XQvmI8EDVBT|u1o2PyogYEu)DP5Z zqplh18X4l7D}ML>>5L93(1#`muM=!?D9N663q0Zz=vJOP&pl~f2s zjDhjEfbpOY&&(cd*Ts{KEkNT*s*j6gy+Y5TL?Lv=e7luRW%r?81 z7h$J3X?j-Q0eTLF5)2>Wvs^QC-?u5!eQ4a^WoR~%kD_+(pGiy9meLBPX^&jTmE@C0 zm8fsvwQU3ynLJ+k+2A~v=6Hx56;`!`atZll5{s9)fp3ML;iA#Yg!S>&UH)8b!#%Qj z!(ut<>>q+fi!2|lX^I0}XXedZtXS>-+fhXGkwk20o5+_Lyp3eY1|==nc4y=WRrE8MO77E7TJqU9;?oq2OL(n`q|R+wIy<0zd#pyDL4~@JfmnL6me-?ySGFU z74^7PKm*j{_YVF8pDh?oMO?{7Xm-|<*lRz40r#4oOOa6G>Eq6R?zys%0TD+LmSB_0 ztknMeH03D6MPWOEL@q^=m$x2DX}k#5&~>ge@^Ggqo{&Ox8?1Zn@{`{w;4qC%)8aO& z-QAWCJ*%GBxeDt@=KC|&`U$(t@L2?!A#4a>*GO3o6miZNbAye@?Vsx_z|cP6O;&rg za`V5zhn<{Y@sivxtn-t{7w)TPK-FZTpP!j&gOw>Tnug$A1xNJy`d2_<*dSPXU;j8A zuiN|Uy!_pgxwer+gV|`dg`L3kX8OQVHm-x!zfaD0KfiiBoTv8uK(fqS!yA0ylV?ri zK07N^5JjhDCB>K{KD|-cjsJyF((huiO~CGiQVV6DNn+U9zptSMffH+z7D?lG2* zm<^N@>;6fC-Kp{XhiJ{ehO%V^()pu%FWasgvFH#CkdzI8F`9SOq?N=+nGd@fBz)!@ zFFIEw^Z!575HM`zZ=j&K zjxVVTjWjp&Y#_!txJdg=1fvNb419m^+~44R{1To_vpvpr4mOqV4NAeu5$hR7(OP2! z4mM!W0AyH@cr*(Lh;1D1AJvA}5tZO`bIbe7!Hj^J0IgzJL2qxR>-!~~e~NgQ5a zLQHkbO=#$kA$oA>>*+iWBBGigtPL&}SeFPAx2U0^j~m3!4u>`dd?W;x>1FV++t?}!`B=`=BpC}bU4B+v=drr_s8ez< zP8Ct!m{4Y1od?~xG=c7%D6z%ihQfq0SZaV?w@T_i7&IejHZ6;3-DB<4`>Oy261rZv z)20{f#pCYfS>P!F^R13>Z2yBNX^fBk=+BtSKi0#2qbf7v+ovIJCOoMAUB;R@$FfCd z_DkA=+kgLkHv8>m)KQ7w;po8RR#tg~4w{wy@?b;mRavsY=jZA&bf5o6K(!l(V?nxx zM_x=*wZ#rj6aRS(HAQF{w*%U9SaTl(Ehg20Nj8)M#J{}Xa0p*}x4+Pm4`}k?MQk4Z1}9p#eEKm_NAs|jCAjYm zO4qmifEf%89KSIuC(>u^=H99Px2>!Pe6Qdkh)ApeTx68r7x>)`2~#SLLdKtSa2R0D zDbl{z99Vzs%h=H_>D99N1_+T*^ud)gB8ndO6lA-wiUK{TeVIzDc4Nk_PWHjaUwGJ> zBchl``8e+Z?~67wse;gM>lTdTuQM$1M50Bc1O0ZTe+zKgO!c^;4K|`M}{`C zyFEcy3q?R#H25w)%w8219;G^!yK;@nU*@Vy+2J`r`4g5}qrELssF%(tq9AoDqU$5M zaziqLDzd{uI0i9OO6GO?;3?@5tU~snRe-esBP096RfA6MoeYp<=-pmjpSIh`M-Uy4G># zs5%}bzR;;CJo*2+5}v0s!^}OGIdl}r)0OxI@en}peDf8O05J+p%?oK@c*4gFZ!nDE zZ?X^-EED0;!aF{m~eER8ATk%H#~2|idK!!Y{<4Ei|ONby6!*A4KeHi*N7n!v{fw>;bx z(8)b0jKaIT_3?>Wy?%tmEVHQ7l#?hU%Osbz51d-zWMZ%w#K5E)OJ=sTUpRM&V zC3SIw_dFiYD)vqw=>QcphDe9 z*nnM$@Bv?9FLr8eFi@m;8IfxI{GI>0R?4t`xOGe>f%S$n#efY##!7@DHjp(SwrXTm z59n>|5h(6SI*HW&Y|=;N>`9gj5XZWj#=xoZqQV%KA0z+TKZ>9I^RMea0;n`58ykTsrL{#Ko0dI;bF3`?R*cC*mGg{9&abb61uh4A=v;k-R^@q!k|j_FXPx z{mHOj6`0{F){jD%SGPGVkN4K0(N1G{+dr94jxx}XngnhSh}Ty2?~3JAPZTMfc^VPO z-5bz*>pZ<-bmDG8g0xmnCd0RM({z<1u`BrFH;K+!^(f(W%sG-;X(+&GxD&=Dp&kva zS~8Suvs;Be1@|Up$h^QrnymiDP(uQ_OmFI(LhskTD45z$#9>jEg+!z#)S_rMzpy+S zlqu1ggT2~kYnVl*OG&G_-#twcmp1}_6iqAqVtU5LG*0S)UM4Vy0cVXVi-Q^30w$s` zzefL#Q_zio;N=>I7N?EN1G2K&ju$sph}{Gpge(f7bvL8{HU=Oj9DsGm9R>dr5|(fP zsJoA?#yJtXT5?6T=qZeBMufam9W#-rAU7bnm6$)xQRU`_K>4$3YY4+jdxo)f7+81j z{MS@dV~xXo{q70l^Y^b*E3u?YfIj;svFFK`k005}{C?gClJuv*9AJBUHl8>B`)T<5 zF*qUui{r2c)@2<4aMX|$$%P-=C zYgJknc+@YG#$vbSWbL4O2xAKHqR?N^T~EJE%igTF0lG|p6t`ynT)x7tb`zNao)E9+ zC8f4~XXc*&LEtNxT}V9L>-Sa^u36avdGk|K6cTaZ69O*e1sCZsL4r{T;$QGRej_^2 zUNoiM} z+_dsR>^s4x08BegVb+|o|4GdMWX}qUt#Gp2OJ2>K&0xr3#*RwgZ~zhnAa+n5K(G|X zS^)fIAhv*E`V6yA-;zvuyq1hEaQA_~bol#kvz>bM%;drX-GoEs6tz=PeK=v<*YLVg z`Gulh8W=y3pT~D8_!G^=rR)EUbJ<0 zf8^4AJDc49AmobYp9N^SXzh+L1~83QQL3;CEpa>VS5HgAyyHwVDrQ2ZN21U)ROD$v=E7K1#uTpQ5|G~DgTcS{5 z$UFdMP2E#EHL{PsMEpmE7r5p97O8xQt)*?vGS>ozg7Rw68r6k2U7Y)9dWFh2>9IVs z!Qc@%n6UW>uEkGt`t53kG0FmuE``#4Fx1m)?&$%D8S$D_c|AKrIbJdxASuA9h?Ua! z22~U#lIq)&J6e@mmf-$?Mh0AV@0tl!l|qk+_<*$Wr@dneY}a;{-G*dMs1mSwk3$IA`mfIdsAB|oe3b$ZQUM`~eAQYJv z7*2I>pv4e!i$Tbo2a=0NT$K&fOAi*pW;!Qa>uQh(OJ2kX=%avg2-4^2^7;q~adC@V zPv2@wKx$wo2wa(UJ7Whc2%Fu5o3{{oBmYptA&p0ojt^<*rO#wFCIM4(&L^YHF4;~4 zhsy`Vu4&yA1)E6g$25^0`1PiboP{k1Ut!xa4>sTOL)gF6ePr|9SCf`3uQs-p-FEW9 zu0pd-62bXar_Pg#GztdDVsSr9ck15a($OV7I7)8X*zZg}xN_X|^_IXG7P6;8I%f7~ zo1~K`Idi%d(}uB0V1@4UAK(^#loYk%k-^FHlgMc9XXGEhX~r>KlI@95mH&HJ*Y7Y= zqT@Olv;}b}HaEx~LJ-pHQ)lcIvwFyTbg5%TutD@S(Ea5Dw7^u9f&e$S=d=*(h~t5A z2wbYwr9(Ev{MvNUN}SwM^u+fnWUP=G1<|McB8s!+U#U`Q^*AU%uxUm$8d7o#Npu@LlwQL4W_c7xpnXM(#jP^b!oK*t|M4 z#&+D{jCg^?AP1F^2}r8fHn%x+E2rG%LSgAOVFM)STy>L zP!7sD*pLo9Y+Z&IE$RA7YD#RovSX|MxfONnoZc!l3VmXSPVj4%zyQ{<_cyoBz@q6$rTHR?T_lF^o@o;iKVreQYf+-iA`1nHV3_o_!RejZEj;zU7|hayGMD zUCNf73VS7ZOWRdch8((=9nrVmwtvpWezJjk7p5zL#5OSFaVYxq5cXIw&48bKRgj?= zqXqMi`aG)iiFp7lKHq*hY}*iGsSn?zN#tuO(WR@{rd_Qov63lxz?&>+U}(rhFr*3; z2rTfRBAemPe@aB~Xz4-C3=2V0+tSApc4#>%N8s=R!hyM*46Q(H5=A-J9z~A9$Nl>J zd$z#;a)L27m8gg-r~x;cksPh_om*;Y@kIv;tv$HOMO(Y_<-$CcVV|L zIq9)WX%~tYLDcK&4E8^Tb8znl>pc(_%v!Gde*-g!jAY1C!s|(cOnE9ep;@ zitL~2*`RdDRy@pqYX1DW?(|c7{0|pbe4Y(oQ+e~)OSa1I@oc|L>osA%N*CeEH;=@U z%(3_b5egp_Ov_Nj_%@=Gn|xkZ%m3n{4ylO00rnArzdlZHDwxO+sBVH^QeMH~qZh3QI`2+;JsVAw;_hNs1ad@_kj zc)C4?)V4zJZhGFn-Iv<%s@hn|i1dM+i688|jguDuC{`k&GDgQEU967zY46{?&MMq7I)Pmj>c^dednY?yMNg(w2{eEq@Q2yy>!2(#+e{4fP>` zv$6H}e!B9`^noNZSFFA!bh@YJ*&}JM^{A)eQ!3X*^iPmdN=w1luHhM)#OYosNAw;4 zP=SXCVP7UhhKvuFQ+HH)_%O!LwQU0KY`}#P_Dg(WW5bq}JBm)?6+#_LbIiI{Brr=UKiV*x7Bm)*>tK3rJMelxziuX@Wt*2eX)5Qu8wNrT&`XV7x87MFFIWmKlAM`g(8eaGP1fGpX*_X)3%Ml5@ z)I`gZ%&}d|=T;jj=lzneJ|5{l6S?5xA!8cecdJ?c-SH=If~ov+hEMfb-Tt%6Vz{i- z?sZe(=qqo0jCssYi~Z_E(OsOv{?H(;-zq{W=>-;k@ba1q@PyeX%puOpMzsD>Vnt5K zsjUY+Wa#qKUY4rKF$(_6g7=XZePr>LvRv9kxx`10JKpUoBhNn1ua&baKlBp1 z?R=^Xx+{YSTV&AjEAro13;eLnnWA3th3p!6jX6_3HGcavLHVTvx_DB<&vEn9kAJnb zTt{bLn6LP2J}2eeH8N*7cJa6oV$x*N$SX^A;B$6eb@*`mUx&BWl|;#kKHt)d_3GqI zmErrFN>oV9$>NL)X)o8e+7Fnto;=|AzKARJHYNcUboZCD*Zvd7U^0DHPrADa5#f<~ z)_-?Zkyf{G_G^;}6K-#iE0dh5v&&?oK{{>!q~bvl0b72r$W91%7@OVc0q`z1y;{fv6Bc3){p8W7YXlJS2BdQWvdMPguHh%AR+Y)KB7}FRfE)G> z8-3?XEkY`+)uj$Zw4LS^@^wbE69H8Q@4UZgU&q^PdrLSe`6uEeVV-tZZN0wMxH^v8 z+ZcC`ku9~0W5+^Id}_As{-<{vWlIN*W=`YoGxO+eH_aSDJvI5H&rx4mha~W*Q+rok zqe}U?^v1G07rOfJD;(Cu9xL;f{PlG>^PTmOlBj@35&!Uk)ZM=+?>HVmupSZikiXrI zu@X*$yuWt+c0dxqWgiiUVJK0~0EYyEss_Q%?%UqXosuV9$6B+6NfEFnc9yZbYiqZd zA2(nlqp?TjzAwaxb8w`*qZ zfTbLLc39DoZ}^D!SEalM3QY@P`)9z>rH@u}k=Y`pC5Z}a%a$}Hd~)nR#B#&ioV!tz z=RM1pofAf&4SD`PvIbmEI@q2nbNuyp3P7ODAfgt8s(In~?v`{Q@ znz5h2n!9^v1DzRmOX;B-#fFPiH|PI_jY0ugJ$K z0rk|+58sp_>(@T56S*#=G;LXM7Lv^Di=T3(SDa1ix^=@UpqWD(L_6?GvxTn0&2seH zNVp`KuqV4$1*-yo2l=Pv)DNOAnmu+bDK)ALZWQSf2tk!X*acG|4jbp6yM1}rYpGW7 z5JM=zIE*q%FP+K4OW`g1e&QVshRg`+Y&#vzL0S(Pr#HyG=i{2wgzAEAOaF9rb@ljZ zF%4Iaa;#vw27IJoxU-M$7CZrt8CF|-x1#)W7|xs|+n1Ki5aC1pjGW>JkbbtPx7Dqp zzNrreFb7L*lZQwL%NSp_(cFhVxfuuE9Ku#IOR9&dK0Q3FQ_5^{3BN!;foc-kK$Je z--tr@DS5(J&T=iMBt)x&%-QB2*>`Gwe~{0gC3&M=t^PcB&*-Z^%ScvY&CLqta_Eez zc9+=xSBBDF*HIx27eaHY9VOUrB~h zn-$*wMSPHAV+fsqI4Ome=@bp&7oCbMMh1SAdu?dby7yFKMp$PJts- zi4D6VZ6c$UKPl|L7B2{Q>Pi_KVOwJK_;Jp}j>=zrG~Zs>56`GrxpR7G<6V5b2HrvN z3=c_Un%M>cc^~_P<%nsaN%<3G`tsr;0-B$|4KIw-{Ey^lSCh*x*mGl$XoA>dFAZhq$?AnW;(xzzjH{Z(sAinP2=JQfD_;ZK;us6d z^dtM?-c5O{{2S7mm6DxP*|&eCa(D*|c-BAtogy4$K5AF*2A$-Gu@B8=dsMr&x%nf! zAg(|?W0Hn6%?|x0w2BJ@N$bkzDSL}l{V-60`pS|u4+=_D3~=R(q$27JO7HdIA-o(~ zJ^s~@ytX5-uP4Hqb>W%jLJK#wxhr?0bk0KCo+9>loan;R_vM8VCA|%3zk;A=jJiT{ zr}YXy%Ia#pnM9-f9-4FS!Qj0hQN!6?A$A&uxxC`z)k!IvlsK{MU*L^wY0H+c(EsNG zwR3cIq{q#lcN8WEb`Xe}FnZ+5=IGohu8qAs){Fx?bwL<$LX#83n=^EmON)q#n*i7GQzS$jm|{c1M>ud(f#6P*p1foTbem*U zm)d4elX`)`9XfWFC@5X=-MAg*LyR+@rtF=Zor5r56a=*qT`LvLk4dK0DBf>su-`Jf z5iGaMl|S=ibCUq9oLS(-gTJcxSCdWm!V~DLAa@KnlV-^DdoM2aYHDfH=Z1ZmZhwL` zJE~$faV@sgZuU;(35}Dh$w#Vg>Y&xe*^ZLT6B}am5l8VPXpc@7K$f8xw0|kb=FO{_ zLY59B-yA+CS3DtObg1NGLZjo2oWSH5Qc%}E@NcwYep43fNlL{*b?~u`m%r^f9mG6G z)R{J1$}A^v!@^~&;Qhzit4g4DmzZr)*ovi}^eWS4Uf(1c6B}uKW5D*|bXw&|D-o%Q_pBC#i#=;D z>uUX??{{1(^a#F>%`BbG*effQ0pAyhRNzr=xX~*+*I`z+3{f1;S+>6$V=F5~oFl-z z4OpS_Zo#~*w|B|8MtKu^m)U`&Q6aG3ZNWZpTZ8eAliF6qA_5n|Xm(~H+~S6$Y3@}i z0R=IvmrBxg{ui&ie4Sw9SW(kV!+_+(owTOkOXZ-;ei@o(3=x3qd^KM4p!e}PW#c|3 zS?L~b1f*O-OKXt>K0-a=QN6vYuqCLgCg?tv9UGRa&e*_Pw(i?C<*Imy{OvDzY8)#m z81^i6Z@J`@F8C=6FV1WBDEU4hap$V`eiPAO>3aKjv@qlBq-`w(9DsSZoJ{1kIx z{WZ;t%=jm^VFK6aKF7!O!c^*lg1=bOFR^!RUbvR9w9e6Ec{7|i;ayhdhT7X)27*~;* zw6E3ZgHzd`4hFgvgkkQ~cM{xPlmAM0|Cp;umE!dziA?u|HFWN)$PYqu?N6l@F-IpY zO%2oMytQgY?j|(U*1o<7IO>-;^p<4iN(m%HU<|vucQobxX`8@ojvz;TDwo8$_XQGk z{Y`J(NZk>HBtNi`d>eL+^l0AwTNQp}NDG^I+ixgLMiKhgxCq38cKvG`8a}U&duN1& zgoHG=o1Hn4*%45VOSSL>7hdgg6VbU&Q+#>Celn%JKQzH{wq2|>F!jk}fy9oWdzKkDs$82@Lyo(PkNb2kJneAcUOeO zdJ(g$$4X-&IYR{S5eO}WaULrUcLQYl8DUFKJkHntNDA#hd)AGs4ZSop+&YUs5UmWx z+rQ4mQ{Q$eYT7)#_xKcfTgqNoIQ>+0F+a?|@}WJ76#}%Nv&Ub4*6Ie$Hp?9_oW`!( ztS%q34N9}YesY5(obcFTf>}E6_~)+lm2+b%;}!A1ZscpK;wfY`fe7K>Pp#%klv_Mk z&_}s#tqlUc3tiA8e>I`=+&XJiWXz4j@A&>LvL5Xq&V<#`pgDu&g!7mq`+4$ydxLv0 zxQAXpMSYbiY1(?jZNzCaf5Oo2hAf}3gC`Ny1??9Cck`3$toTw!KVF$Jy5urqw&&VU zl%_0`d#oWpZO{Gf`gbnG+RM_knZqCTD8P?Z16cdNB}e0hGwp(d$ti62cp%J zbN8aXC?g!FnnMY~NJ5{=@6S_fUYLQO zD?UQ;R50`H1nHAI1Q1G-d}4HMc4U7a`^EyDGo{3kiWTv0v%a3AbLgb?Jkv8VVDIq!E5O@A)M1m)aKL;%1L! zLu}bat@?}MhWuJ|QZg%-Vb^<-LWII88+XqWzpj`xhyv0ILrl5xrKI#*4R_~B|MonG zs|2Qpt%k)$0;p+bW`d599I)pmzo}+`A6*{FMFsAsfB)*0a#oe9!rg8>!KL$O{4?0x4)n z0rF_SI;c_ucL6;y`~hMy4hy-FfSItFbAkh#_J&lK>vSJ4R|8U78sl@ZPtJiwP#dlv zFv;aLGGQ;9sSL@)tWW$CsJ>Mhlm-@)PS$@Xw2H4~kaB(m-z*+`vwu`YE3GQo!jvPv z`N8T*q8xPGvs1Xb&DFBuy&how2$DhObr>jM#RuKcBG`das$_?)hdupjva-BqpS?P}-LqW(W{yzFcVm;mU0r{V1Q6hi8oetWDj^n#Vczy#!5lYF zjg&Lh5Y5&f#>lYW(nOuMmnuR#r!CW}iSO@3;U&EvZouFQ6v1$S`K z$GH5O$K&yT_q*LJ5J^PYWUJMnDN&(MXJ=#IY2EJdaJqiXrylkmFszN=+pw!`wXHIYeK+M3tf2^;L|A=^cibnBzV z6S+u&^Iw0yf9F5ES_CSYnO$soD=i!BWq7PR&L1G+5``irzBv{sSo#@ffZBMr+LKI4 zGHLHleGlQsdFs<3{BdfgdSrZ}zzQshp(_D{3cJI0hw)qdN^mxTrpD}gBzrGY8bwCH>uyBygw)eMFx8VWCS!2fxrZon$~l+&GGtx~Pi1>O zTl{BxB`YZ_HI8h(UX;z^ZzLR_hYo|Bq{8ImXN|E?zNI$Z7*c0i3h|M<`6ETX;_3}= z`?u^h);lkp7o5`9IVzB4N&yQ-nNmS4I~wz0#~l9CUyBp7jr(EqkRhcOnC5X7k1%(g z@sxGaR)*{BnPdYW|5w#5mt^vB{NT30ic-=D^-qDzqwA5DeNlJSGsq*3b+e*wZN_qSIsrt zKH-Eyv24N)K!)KzgR}PHcuF`DQVIIAw)Q2{q0~^8Af?5y?rp|~%5m_NP_skRPWR?d zUSx;lXi9P%F4l>+ao`HH!|?7{RkqlOw%Ul^0*ZC<7}58DIh&e0j_naYs9>xdfFl+S z^oZ~%tm=*aj*gdZj5bN{x&4QoIj18uP1AbUI40ii$^4VrD}d{vZ4YeX*7SC2lSNrL zaBEWg@u74kCSnp5VIvLA+*=Af{tdV!_ZFIBZ)FFcII z@i22OGHtk8xzL>9KN(&l^^= zEbdyk&4-KLS7~agX_*v{S-e;A%h>up4=)US5+?X2G&$X~o!zkaIdLl*uGrmO@?wR{ zwJ!p~0dDD#ymez}HA)xPE2)V;;ZVN5*^OPd&_6_D#*UZ>NW8~6l?W9AhE#agM$`2o zA#CF%JN*vp*1u)uw4r!`K{S}&ESeyOajUV*5>WOFOu%$$e;ceA_vgkX8 z)&+I5C2K>yL?Jb2xE)WKKZ##*qJ27;I zJvB7UTwed8;p=|kK7HdG{;L=zjJ{{>1T%7H&w_V6XAnJ5n88C7_amNsx(4?keIp;8 z5O)Li`xOjsntOHFu?9=tDhxK3wG(fCR^aTcef_&7lw zZlMoe+_o}tqWm!_>`FIT53b+hu$sco1PxGaZLNIy1l1*!tBku;;9?<;evb!^oeQd|ci5M7#)Y9wghzoD^ zTsszj>?&u|Rk#~Q?u1M?7o;~8PwjTLmcoMNA7@5$%ry~unp=xNMh3B{5Mwm<>$o++ zjv*X4`prTsRs?U8vr|@Cm)#7R-Lud%d#V}5-_^`Q#rE~bY)^E)W1-jhS(I^KL|yrT z(qz6k!|!O|-b`BrJS03@Xo)>rs=QKAke=J)wUeB4dX%SNP0*>(xG@|FxXBhBh8@NP z3`m;X%f2Q@_g!q&zjS}?;Nw1}pSex={dhG9x6@lR#A`t;fFMzw-ah0Lmt@TKNf9U0^^8x&baHcgYvGr&u_X19%8tVN z@xS6k?FYEiVM@#$k|(EI%wv1XyX^kI5A$d|$kVV4YdEhMj1WtVncvQ|tOEw@Utb^~ z;`=6Cowr}bo_X^7a7}ebXdlR{7sRt_jR_upZg;0=H9}ez$J;I8!?EjeHhyj)u-(X2 z>NR4)WTo*-K@Y`D+M(|Y2snVDpx1D`zqsxTpjlD+E~9<1~(9oF4yMzH-aVx36k2Ou{ID?tRSx>|O_Q9j9nb}o*{R?u- zUtc?i29g1*!k`qs;q31p19Zp5#2JO8zCQ`+w@di+p4o25mEV^+Z07yis>C#C+y|2N zDYbzc8JSkZf*bB4n=0Kkd2t2HT){PGy0x{>(o8jMLU?02A-q2TH~IA8?#SLa3L zFN9memMj3Mt^FC#$^YepV(tAJ7x>6}jmw!TtS-FYWr#wf0DJ@D?-Gw!Mh#Xt6x1~x z<9d8YnRaPISat+fGD)ejW768j^Uue)u3Wj|k5lD6b>;0}xzqHvIeZ-J*iW&OEP6lN zVdddOO+G(1SDe`5-bAGAoU|imn|_A6a?Ig;e@ATP@lQ^slBzo2oWN?{5j+;LAY)3Y zyWdyg%OW27B0Xmb7ZPeh0#PHsAImRM$NY(^;4&*Y70I(k|7>b56mV+`js+v8i9Cx@E=> z%e)Ldo4@7e&G#Ur%iy*|E2a1(Ofdm4w_8I4LnXc3^ugCz zp0b&}Ct#gCxN`!FL5jjF08>Jdfw)9GgDo3eHhQt_AV6C`ZiXKFJ!TU_iv?fbON6Sg zQ;dh6(a6X(`=sthIGm>r)FG_fpe`Bcf?ashEJhX_1$OryY#ywO-Dqy zllP0{bl~27nc=J<8(h;L0C~YBT%o53U2q_YhHP^6%3V#HF7Gt2d2y}pUK#Qu99c;$ z*Sz(lS6B&p+_@@$`wAzk0pS3rf~wk@o=MWGj=(}{D>vh9Yz3V+Q>}yBfJlANkl<4b zoF3o)Cj)<8Tw~J{CyD6qc6T^4(lqU&U;_#&a=*6R-9t#>QwF~V4qHO(@O_5a8vfWV zZ}Du?l<)|iso5yE`PAlLelOd^pOV`kBjcNwjg300Pi8rJs_P7MEL^AZ-}S2#zj$V? zCzIg*Po>A&(VB6hN+8F}1+#R!u)0!b z_)QWALVyqg4LHz_o)!v|rBGc-i5Ab0n59Em)t9{wNlN!ByI&LVRIksKgP6ARb}oSC z$QVz7#Cv(#&Z3OeJ3Nd`JnO$1@Lu^Xkg3hunB+t)EZxO& ze^f4x5r34HV#~6Do3hqI#%RCX`<0mIBHm7>$xm zonFI=kQt~j;H;oxhK z4SC8jbusd$dlF$2S6EqzsE3{U^4DB=_KjaZvL)z05poP1xL1EWImCXQHOxUG9gV>50t!R7S4R?dz1HQI z!EWJ0LkzShw|{*@a;i{=J`^7+>Lu(|)5BaY^*KIz8}*eTFQ`6qmd*fIhXmweWf7*to= z5J^Ah(iZP+vD{pnY9GRh(r5pSPflND7PI(qmwP@{zhFCw5OHWA?WkM)ZuMejfF>hg z-6Q2}od0r%xA9FmVl5?wS-}ZQy(v93W$T<})FW+fw}kzf9xvSkL0*3GUUK}`@nyO< zPt~2NcL-NMm8h1F7(Je>@85Z@D{)k2*}KdoUeoe7>i?Qxeb_AWX&bGm;}F(Qic*jN zZfjd2hgqazr*F-LatYYd?Kc2ax?iM?-PV07WtQ$CWy}3pN`=lHQc;`|+6Jaf(d;ZD z6ygf3V}SPcr{YZy6A~ieCyXyGx)nUoM+lk4{U-PF^J7VB7(7BjvT<{+=L_;PWT)Hv zp*eTDJtY!WH3}qo$u17#&eDWiH*Mq{ObQCjfQPTpa2MH&<4k?TEndgfHDmvkt*R3O zivL#jdit|}ji_T-H9CuHa8UtZs*GF>9ZNTY zfFd0NN|%Cw(%mH`5{n?+Eg~(_@Lrtf_n&!ZR>zq$hgseI-uHEVl4|qD*z+c2r-$NR zedzc@a~>4zUu%2AG?RS!oB>~FM);0Owsn~AjK$dDMLo8NKpjmY}g6LGisE%Z6GUdcU<=?sj(Jk&IWu>+R+@WX~fA$LdDXCW1d z#pV{|{CkFmO8@OiPNhJ+KT%xTHkE!x(8^+R=r8_O{QQ6GIVhrdpNbtXp!=xPKOC!X z^;%@eRL!q2jD*zXsLuc+0}q8VEqh!tXw`5#h`kNRO&o1{%W6h8QTMmU>z4VQz7=h~ zVyy=#h)QK&S?%~S*Lu>V2hWSOpgxVz=9!glmI_8k-r0f2x1)=|%ICtSULNc&6N0Q5 ze?_2~3=3#d$hrmbA!vU=GZA!*vtaf0W8EO0e}9!e{zPUd7=e+QqUeDV)=E&~4WS&W z41BZ>KUnxSu(9yubma);LHXkI%`aC-%4hj%Jw z=eCN*PqF1I6OGwfGd@FGg2aq^EMJ3au4pVyxfJTpf|$2>)5W)Y)j+zoJ=;@RIa!W2 zlR2Y`u5wVRD^Wg|uOLzGaG@~P;hGnoF@eQ4*QL_rq=QJjS0ti4+u69yzs}-$eK!qX zFWUDUCn{o6vlAR(Mt=ch((nTO^{+nB<6QnFV0Y!OH0jV`_=XE5fZW<}Y{Mg{nQ7T#o(k zz>Krt!+QsJ#jhqhc<7`cy)4EIGN+UmsPYP;o@Vlh^h~m?*Su5wq=T|^CWiSsNTBo) z2M0zS(VcbIdI_?7$N?rA(;1`gzrViGvo>PWO!jsZ#1?UM1Ex;@ejU?Xdg3z`nRq+S z_xQ0Vl%xlGU_FbMD?yq!I863Ra1MI(D5y>Jgs=1`V;Zr(ZbyNF?y*mDl*wEqrVA0- z@#B0)mdQ%m!Y(+@Dm^^4qcDJ&ki-&|swBqlz-ACWzqr0+@Dji;Caf-m**3q>d%Ba6gH-~o&X`=_AO84HQOCYi1!3Q&ebHhzulMLj_Y3Rwk7vI`o!Nuz(whiULY zLl9USSpjj8rAN!}^ru4X9l(BfuDKu5OoqpC1EuK2VezWKQn+dV>1rl zkNiQG-m96Z%;Ku*G9N5>fUT<>>Q2^1o}~2M(hkc74x~YLRW`ExNdyaLiMH(DW`-wp=(6;3xaWjJ(j^{0TcAtOX5et^rrkU*f4Rf_^Hz&vUxQ~5TwKP=m@7dYF~U5wJb4}syPDjb9GvV4F*g{?tsa%Yf>Sa ze2bw4*zg8Gv0?&Ar1Miix)MSmoyWUlwVl)sg`QM4j`+w_Ch2lX}xeR`NwGRF&? zTP@`)IFo|HuRwYXnimt%er?qUd{fvsb2nVR)p|x+Q*h{lv}Rvu{s<5-n7CiT<^enq z=&3+aEOCy(DAm7Abb~^G;=N}wr(3cIMqfKN$*a)1ErtahjwE<&xx?WL8t{L2A#Z zZ3dlKdkNcJHSK$Sr8#VDcqRxEG&`MV56M2M&R82>h$#w3;Y5y%y)QC{WP}T7Wrf9Q z;cQyOP!>SWm+!XBf@y zR+}PDBR>k{6q7yPU`EZ5Q!{r^yH?HsN+VQ-W3aJb-HRc{mr|nk$|RE@YH?`cjsz3a z*xB>frWZbV{U>Sb785?-VtB;FgFR4&OuwIbKbyH3n}GA?G5yc0kuybfzb%Qu`*=-9 z4m#e3!;XW7^!b?Q5`O2MB`ExVoH(X2OGk=c&->plCvp0iHnFyihrX+j?J)83yPo6! z-6$VnBDoPk_0c9Wbz$hK$t_GA2+dP5lP_xLWG&4(0QTr6^<l67CFg@J2d5kpz(@1UvSkv)+}W3=I_Y3#gpD=7q{Q z-1e&=2mM~piD7U@p5J^Dd@sn7YD|@MdiqCTyt(G1&(Eph$y#ECOy0J;stlo)H-!^T&=>w#a$t@oH z>Z#&hjcStQ90T5{n$>-~i5{f$-`AKU=Nzp_92SbZ3CQ);M#_j3M=e7#WMg>G!v03t z<1V3yGs&d!U@Kdc@|Oc!i!K&EcMh{R2bso8Q|MH(@e!LlKrPYSp6N05pxQ)ndls}U zFd}}+V>N5n=ed4aX?Z&h-z?L7%Csm*d+NoPdODB%kFUG*-vsIU8~^NE7aF0Ctn*N3 zksr-cX~@hyYWEME;-6IMZ*{opyBU6X#&>56rR@4V_)m>~lN2j_`6G)_llR?H!4(mZ z-{OH~4khqf_4EPslkjo6tOW;sD*DJ69CIHfUfS-Fx(` z=EDCBufk28$n|kQF>)`iy9Bk8a;i2xl&BP;d2Un*eD2D%@1Y7DFvNXTd0a&4yns9| z#(}0s_r1RC*`ErvPdcc68*Y8`p<$R|?Nrhat>}0|-wGABkf@W$zsw4&bK7nIn91)s z!qKSmp4FMk(Hf+B0NFqmE^y#u?QR34;~(y3$7KK5O6_g{76wC&BIk7?JuXM ztR+g@LBEn!4*A5u6I=wHi371SY-ztO1jn8xj#p$)T< z5Q6Rr@~ckDVFR@iQ)5)ss!?0$#H0!EqkM{=F>;3W4Au$LzIgPw=)a37|OqSS=v zZw&d*=dT-RQztq-2wf{hg7MFP2xhr6r0&W}lWldYxTe=_X{?8D*JU%t34Si3!oFMz z=|SV?(BM1$bqB+dUL)0wum56$e(&;0EsL<;aNxZ)EFK}|q&^(BH7=NQ(42$PUbKXy zYvkZ!zt|Xi^j>jz^3!9`+}QA<9o-j=%P0{Zz!%&a0-;9*$4jmGc|pl6@IVgU!z-zy z_0QPjnPF+z@!%`ZY>HoEdf)$#Z}E)u?K^6sH8`|47QT0A-(nIKRF z7NSMV@dhIr^c2`@nA0p@Zk-j)y~O+Xn3s>SjkojhY_EtmqD){*G;Os^Fk9DidXtU$ z#NZD7>|u&IU71c&N7ExH(i|4@KinT_`}uHF{$|7x>Z1e!k0aE)kwn%a16v_pgyqJh zJVIz@o;GdPhY8{Z;Mh=VOm5dv*kx%=845z<1D!jVkXDBCZmbAB+5-oQ*6SANv#&vs z&$#>Lh{~CYaQ(pN`f}mM86Oe(MjXPF@#mo;LLg+7c3VkA`{1OBnukvYN3lX|hPa>P zZ*GvZNNlp&tX(yeNuU@FVPb9n7t~pB?>z7~+Z;9cyK-j**x)=YBsuZJY;@J<*CTQz{tM z=@Oh97jf&6gZDr@3Y5^Wq?BAa$my6AxP`)KL`AS*Clg2vN;@zYpjKpM5Kiuod5jlw zC9)z^0H2g!EHgQxvb>DZC4hNcnU6VLj0re?bNOmH!H!aQjDRyP$it4RzRLsiDh zL%MW73A1@Sy?E{@=O%heTXRc&`UYA4jjoylyQJ04s}yyf0ij_DvjY#x$u|25*S{|1 z?@j5rYg5)GNI7HT@o>|wlq&JO@Ou6e{m$VF%KP;wQa(nNpbz%^yHOAhXS@A&{%7FZ zG%(;q8D@hrIuvIf(^;{~ut^(?`1-Kem>859+4?tHm^zn zb_$$0zS87{cl7Ta+hOiJZixj83|ujA)49AISa$=d7~DA^WoX;u3}r}LXFF;RS&j;$ zzcaiWf|4$n1``IrB;1lzS8_Ul-e0e>3EH+q>R?v{-`qp8$e}x!RApRLvQzc>q5PXW zw)`%`-AcsdK>bwwddAqlaH(=DJSgp<8S=nUFmeD>|Jh{Kt%Lw!EEjHD&Mc2k)Y9i) zmvXnI=d`g^fy4&UJN?biMx{#4k7;8yy9{>ISL$JEwq!#2#JXy(9JIkQmZ5RV-_>M7 zMZdQ0VGzAD-)TM3rk%W;V7VgWB2lNA61yTL(*5|zova*ZM!9<0!PX?#)`GATbvopW!_y`ZPETebnppjZ zmV)ix;Q%dr6UNBEqNW5tgAG3q`Lp$d#Am%#hF z*5h`*vmrNco$s;WCgQKy5`w7X3UfeB zt^0mku)ZcU^#Pa#1mZ{ZGzcMaLFH4Syvk&g$Z17q3pe)i8A>t2KN}Zoq#VeDPA=q& zc#76|8IhMo1o7KmvkE8@zcDXGDWd^bw(y}8VVUGp&HZLSgpt@1K;qQyIyCFpV04n2 zVShSvAflGubzX!syOCb&vF}V#Gyl$0Ro*Wk{ua z`=(Eo*OPLijv!N014%99Dm6~iFoz$R&KXOBv}~qfd8T;U->xCR^6T;V=k`*E;G4ok z-URM)<~Va*q3J zgRKppb@Gu_io@AAt;;%x-l@gKYohnBV=s&s&t?X+gncInsqjPhv&VOi&{dmr-yQ>F zhf)*G&=5)$9n#-|KNDE(A18axdRT31ieiS9*nLHf(A2V7DJEQx<2RIviu=VRWX72%Mil*@(*hJ$80iQgA&&pxjP*W)K*&`({yXo(FNZ82B84>Pj}SSeRa8lbJf%D&sVSQ^L8jCGsb@J)KVPGr zVixN}<2`KnnrqEku{uLEGJeH(%R_{$gy9Rui$QalHsHaa!#)gd z4xmYvVO@pRN)x<{N`sog5GKx{j;|>M{SM|eoXaeMRJGKxjoVEoMIGKEWZs`x(}&9m zqMntv-_2;Ww^yE^e$Ep7@fYseKj#;ZJ9}4MVHg6@+BGOi<3LLynw~nuu1r})NNg|P zgLw^Z2^DJggrpd%=3h|i1BXp1A8J5k;_r(@6jnw2LA|olt>-G9~;lRRS zY8AgMVWOB^z}u&MN}ro593 zP7@`r-`!*vD4l8?-R4pgJzGDHI7t3fFv{;dcsX8!uTSyyH3g!dvv>n?8`$F^T#^l3Km$*pw%UF{~_ao4-kxHr+ zqC(SWDk%DmZD#%#TesGxP|Q*-(=y)isr!vPE|ncxYQ%fYJ!Tr)thpG=Qec>VOrv$l zH2r_p#gS>1pgCveH=WdCSQw`3eMyg24=b&a#Ki}YvK!R27VObBwgpZgw1mtprQp;l z7k3{Y+Z)R1Gm(~PgeaD_xz@(x9h)k)o$$`8ZHLzB~ z=-@KcU0nF|b68ID{JMv~hsPVZl!7V`PN=WtS9s3L3|1Yfj>ZrM3fgOnr7r_kjAhAv zBkFM{?IRmMr*x&f`*k7;a1FL7Z`qrm*5~H%lzMij1`REE+^q_HMC&c4Dv6f$?(e>eD=zfBdMerWRe+FzAp@y z9r%e5mO)*xki*{WBHHU4IqqJpMN)feRY|0dJ2T_d|KpZv944fUd^8nt5=Lw5XN7b8 zscH*;;hB#0X86+$*JyMBI5NQ$>Kb6}4`96o!(7=xV&Kq`KXkD4ue(8`!?VKYn{0$U z0U4`N4dUHFrj;TM211u#``=5 zjVev4YX+<0$b4<~O*reSL5xL|T*PY2iyEj;LWMO`MM0U&NO?Pq9rqB5?*MH`{YsDhUjaO#0nxes! z5^eRM>iEFU=}9V?Y|Y{Qsu~0M=Pz>|X5W`q;mRN<&{a zHxH2Fu?AOX99Fw5#XJ;?@t8{}{Ois-8EVd>HoO=MAQ?vO!Y~I|Z+jrPFiN9r^pkHc z>ShHe`6Jq zjAk2hLGMSmHYDQ@GUQ0QWkHJ0pD|B4v@ys%;zP~6O(JFc)hGk2*xdW?kvj!1{Wxbr zkA_nyW+f&4=Dzc!Els`#jqkhq`D2PL3_fARNx&;#o(L(YeA@cAPL$+hHKY}^Xaz3VcJ z47r&9pL`$WBVM_6X+@qfKSYISV^^=Hs_j%|Zs)o#1|)p^E;4 z8q~1al9Uq4N&1xX;FK!v&`v0d>{w0^Q6FY6l?--lW9nJ$605Oeo28#xWePmmU zFhqY{ zhngxwIK%v?qrEDY7Ih@&QPULffpAI^&(;=hQdc9WqL7LD%0`%?`N_G3XyfSlv_lxx1T_WUR1i z@z%D{b5o}sUjJ!yM@!ks7vvc9xfVtKefi(PmY$#~o=rk*Pgs=0;?C#t?iV%YD-9Bm z!nffuwL})+&}0x|Y5bGSrFgJ2a_5T`@iBmsP)0h$C zn~w*PNc8%4xaZ7tgfj5q^Z(S}v8XQOd`z3sJmn%Qe|oZ>1%+@QN9`8D77c}bN`7;e zw;AoOJxn>IU*Rs-rCGoquIMQ-f`Xou$;%D77sqK(ilrten)!pYOj!rLOvZ{Lh?n^u|ejmNSiB z1n_om$vm)}{Ri$+(pXy2hS3d0XOPrd#*2?(nZhz1cP+3+$;HueS5~@X!u=$P^DgHO zNz0DXCHGM*yZA(~p^&~`wVnbid3z0J&#A~z+q=HU!n&v!EStQ`3d1N%yu&#{%E^6h z$vw{>%|m3C&$($?GRGg@7+W_{UDhWtdK>}P_q4UN%P$>=SJO6!UF6oR;~(-5&f2}2 zE9zTwnno6?PsO14M_UH<@X2R(sepC>cS;!LKjkbbE5LK|E`-t10#=cyEp$S*8JOJ~ z!}#~nmVtNy-+=_~1RWDgF1jPj9QxP0TtUT{2wi$|8g+@k!5;mOF^22Isw+W#Hvb(T zLMWG1G2aSUz2eX)1~IhHF@!{ehVAV>%PfE4=x;5GoOffQ{TFebOSRhfgj#V3hAl$! zJZ_)0Jc=OB&FU`Y8p3*^I4eC zJ*2tbkz=}FaNLqB$^JpWJ6=+r95#eRa@hnK`v*BE8>}+1mWS4fVfQ!=I9Qe}Pllzs z9+oWm2boR3&^0Mx&$}BbtZSU*wCO+MIV)2icX)*0usjG*xa)G~4!+wxR>Q>qFxfNs z(2Wx&CUQDrQnLNjI*=nHBQkwVOpsTCMg^^%B1n>g`kext%dtVDG<$Vx2Dguy59=$g zP5Gejk-977>g7T-UGW~L5fx+MMS4G57)Uy%pF#>6#Pvjf&g~f4z*S;EDrGq-@1F97 zpD{)2rxIb??x*LE+yigo>BY+xu3dk+Yij6ez;Op1)OlS8Yh3d{|z)%D*mnq%}|%w-SOhVM^-YBI-hVF9Iez4_W0qCp)-Q`KS16O0WA^z9=5>fg+t_>);xdX~J@BIJ zvDedf(Njmfj#}fcXb5)**j(K>4ED%u>btr5@aF68ytIiXzJzaMsBc#)O|QJJ)j+-h ztMq#`Yzku3;?m?1gN$P)t^(A0q57#%mV`#;VYFZ?SubUiqlb$MFI6sOWqAI##tzjKnLffL*NPzSi@;#z_s;oho?7udP|vKa@K) zD1jEl8kKT=QPO_m2=Ex-}WNt!Nyy<)k8<+#MF zd@So#;(1;{5;iN$_|V&Dbg!N>K3diTE@XBf3_GL$qNMGY~(K5fa@1S;>n_b3EBdo|a71sZ{D(fKJqFL_=BR>~d z2N`Dhd`cEKf`y4XZMNU zEYN;W=sgg*t}%guy_4?Z2i>CD)nB!}wE1&PI3t-aSB)>3)x|4DLg{6)NPNFlid|h( zq^otl)|HdlvyPGW$@C2{rUAT^n;i`CTX+FSUI9mnchg21p+z|wdJh0=LH$U2pf8H7 z{Ax;%P30|m9nL|+3J5Ms+(`XtskHk_8j1Y=oaX0eWdVvB|ofzB>O}DBm3ZkhxsN1n}pr>A;@sG^7#0LeWeWutRS6519r-`)7i?WHZ8`j44Us;+c$_i@Ig zf(({sy+Mq~BkTx4pSUrz^0t!`K}co0`34P~vr}7qdc|WIY79qWkSVteMc_Es_3jI5 zmn&+!o5oj^S1?S4^~BOaSiBNrK9pvfi}wd1qwHE@oA)*a1%t&?%qO zps^X^0`O6eBU_Je`JHa$znJmOKhmJ{|4XE*rgnpP*XT2A%`K`mHF;go-Qcf_g2)Su zsgP`d0U*PR(ws_|;GqI?J~chcL*xnzQL0ZfDd8hHl5E$=7v3Q63XH)MY} zPx`)6xtKP{AJky+!=x|8LDU;%Se8n1AW{9*s#IKiF09bZMZ;-PZ;R*LeF2uS!9lNb zbmhhe4$fo2NK-CUh4HwbCuyC<#eGDz1|+{zcc;$-;w_s8PTHNmxML9r7aVt7v5G!I z^zhYsqJWP4OjGI zH_NFZ-3O5FL-7IMs>lhxvj$Hhw*u>QcO#xM(KYucYmn0xqq^jb;mD$*v?Q=-VdDbS zb$o3qUpIDO3}*#Ako3|M^)FO^z>v zU<=>QjmDWQ$ZYF0c4m+iV|8W_KJb`0<;7k1v|*Dcf1Jbmx8g71OB7-SQ!3e#*%eBJ zD}_+sgy%Mh1Nl$WCzE*VMv163vetKU>65Oo*^Tt_x+$-gqS=A))(JjE@a0$sCXeIG&20~#8 zB5a9$s}m2cx=n(+?oY^QuZgir^xwarZ#F6|*Lg_X7^z)&yL*`ng3ng!<-J>V9>RpU zV-ez>zXBl2@rGJJMAqfseDBM1K@isj!GnVpGHAC)jT%2HC{mhoqJYIZt^zEU&&5I3 zmEZV)t1DVrGb`kxgli6SNx~?d_~04L)(VIxjk7Nw&}X%0OflcG^D_-udBv^!uukqe4`3_~LtminMWau~5Y8 zoddZZLqZd9fqXZ>-$_&M@qEYoN9|_hNL|DZC288A&4@#)XS`f~qb5g^G>m}|m+4yH z2}?qe{l~$SDs}Iqf?L-Dko;Qx81Fy2E(FO_s~>41-VL@7#LLZGhv-u2VVGEn&6k)l z-j<+G8pU)h9R0#;;ThgM6iq`jU>b4KC?Q176}pL5x5@ySgv7?E^rIFYr{0^%*Ttwq zA__*FG-V3Zl?o`={xk%iQhHF2?%Mpb-L~aSOfr&&v>1Dy5i*ITUW^Q*47en(iyX7g zS6HvBkut^nDZg=GI#OTR{%(ag4X!5OZ6NdwELmW+gP+eK-XI3FD#+|#H%^G;AE`&n zqJu7H`xB_Ze$%FDKK@^H#`IRpe((Cf4`pF+{Di{627q}=zmV&zk9{Rze!8rERQExS zt_&9g(PgG#Fyu$$MQ6QELKxhMF(YKHE2oAc>1^{=8PESQCyO5o%BR0xCs&Xs)QRMS z-mEP7Qv(a3j-C4~X7hbK!gSu5%?^h>XDkj8+3k$IC#IQH9Ijul&zF0u_{2N93U|3e z<(>G_hQjBEWmQo4@%bC(Cfa854-)VQGmHyAXXp(WKew?QAIRF;@mgA*J zQK#sUvxf&S;r3mn&LgRQ`WdXw&Cg>NtISq{=lG_*iE`lE~1-vbS@BTAoFk;W!;D^Vr_j~oTh2ev*l#9Uxe)cB+Tb-Tqdfdnnd(2^v%31}JQnW- z@_?A#sosDkA~?H|OR;eDKKGZ`W|Kx9Yr8F-p*Hx)TT~VL97*UDW2#QIupjP)1{{Za z@2}vrobUHZtgAjHny}GP_JCWEacZl^Em?T$xzNk73@CcW1|=BmK(Mty+QdKK^5FC!@wn`KFEE;$8BXaGZJ3*cJCQ!8KlCBzZPN4sa>C! zU8|CNcQZINX&yuD_v#gd;7Pc?bEoCXVF{crbI*!a}LZ5$*&eT|}obblyu75Jgm45$`}a6qh$f@;`@Yp-tQS!w}f%LH!Dj zk?RI%l=joHUR%21`X-Rifh6%dX9(!Nqp_&9iO@SiZ8L^zXgnck5-4SMp-!Kk*5BBu z_<6w6xqMlRidbM#5(Mdu0n0M|v7Yq006%XQ>xqAcS6_v_H8&LJeqg^J>t#h8glaq)sKno3pyWqQjk`qL2{&iL1Z)b+n2Y(@(Z_3}?|7++>B7*-(2umeGR zc;+O64^WQ5pzSJc2z&yp7U(F5+iB7^nIM(Squ4Y-r%(T>COwf`U*R%*bc@F^0)@aLhp})^cFcWqT1j#;uXdRy$hsz^0vjJ+=cDsEkp(OxPDhC=EFNg--J1-L1p&ZU{IRl$dT_3 zfD$hOhggClkZUA~QFx&rp+3f(uA5HsrhHjW?nmyZMa5U~i{-w4AfJsdu6nm0ldYxQ=I6x@NF#T)#mt_~fQL&5(Z^PE;gEp-{dy(b$)aYO%UR04bA{~HPK0i9 zUpwy)JcyiJ*5aJa_hs**WBp<0*Z8>TsngBg*HM5&um8F;s10?vFdrdw-EwF@1ZpK+{f z6t8I%->z*fyz$fS#&M~zi10GUpf}7uZ(^ttaB#0au1&try0Zo0}X`Ru>xq$JAHT zSC>vkUR>MH)~$KYlLC%0uTI2Yz7Dve6YFU`JIdPer};zp*I%43Ckgq?H@-es`oy84 z-m(4?z@`}Ex!1=hocWcBFI9hLS@s9Nd=$Oc_KyZHWT1Bk8ns@y#rEI##N4G|wU-%f z**EP-l;%7a3v7b#S7p+OK2qrVUt-@qqSxZKcgrFVG72flGdB&Z>hyYAs_)w8v6}^# z|C*OyJQq37jv+YiKaiv$pdI_+$eNb6;-QFq088JI)s*v;;nfzM@sjw}#rU!K)h5aL z$kkD6%l480g!||M*hBlCl$gYG!%t`as7n;W9Hm%ajlgDzN(jAba^!!+3~#V7Suwo= zyWpeMg&kfF_2w2P4U(CEyqiOg+B}-N>-W%m4LhyKxcUG%by8uu^NA_2PMu9g)ejhH zGoCPtuD8{99bR`}%m8T(j1J%gF$B*!k{FLVz{>?WI*^3{&k>BEyf)Q220i9Yh0fmf zGYkC2hkKjGhLFzP(A|3Z`(`X%Y{0YxrMU>c*LeO9zm{%z9eVhYHE40HJ5Xs7Y#!5z zIV=a9&PtzeBVz&ZJ(`o}x5*!ogw`qOs@l8GO`8Wa7qZacEeQF6Ec7Q=1A2e&hT+(1 z7w*+6T}xNM=~?Msz?Ctw%*d%UF5qlOthv&I+d6qDNqvl3W96(x!0)7$spEX)9fb7u zd8j4v>re(VRC{oq(JXNOzx6AhgDD)*?$2|9o*vPOsHK7ER`dUOJ29} zTSYRy9}JcTc)TeM7$Lvo_mZ!}s`AXE+34&}bRxV^mezj{+3`krA4}5EU1kSmUB+S^ zPr~1)QG92y5;^TO6ZTNmv8Vp&1W{Z!&7btn#?7qDX^P85@t4t8e~;!D&gAqHBr7+T zzF*(Z29Vt}KY6w-pzy_YE8h*N?4>r5qU-sCxe_~!NrN=}<^8am_p`&;3bOdUo5#}+ ze_J=0HL-NwLi_$?%#b-^rN5#r-V!~Hgo?#u&~Tn^S^w-`isJ0^S;JBP%z3Amvm=Hc zgRuAtB7FuAgs^$ylQ9W+vlkR=3^=sqbSNk96V@4*XblT75N0q8*lf_y&HNfrce5;@ zdBVf$7!{_;a5qhZ$SuIKTm&WYHh=n%7U`4cRA?`r_iBl_^j5TE|J)lvzhJ5S6h1)M zskh<`N$OBI#gU|G4jq$F73yKp_#ET4WK>iXeTJ&JtLsz4DPaKt9c|i-4#(Zl0jmc( zmA;hrmt35Bhf9CxZ97iiefj6XX!rQZ^S?!Yt^|qaE*Yn@A1{^!)+RKl-DcQgPI@Hl z{9dkyKhHvjK8Yl|3k_Zur-vR#)S}aM5ph2^A>G;WP0$af=-}XSuE)>$zo5%)6WG)lhL%|`C&_rWkXL%P5RcV6fq7Ic0b>9i<4oE>wQ;l zb%;Awl-WM(<)|r6cL#f^AVsb>$meVa>NjrbtfBew|g zWLOBr1D#j&(|y(_Cv9Ie)D2}LbV|6Z6^Y$G>OT-P$hmK3QliFl#K5vNr&uBM;J#Uo zjE4*%6&`1=*~d70=}2mhq(10B_E7xuU*}g)P!Os<4N`(W`->Pz=bwHiWnp1~LMiCD z=HljlrSouF1by=VX#v(0T)ll8!g^?D-^kIuq(F*@hL0BJl{?sD&L+zH_O0>OAXJz0 zS`p90UmR*2?2hpmhu3CQW0wYWoX6m2hlGUe{?=}#v>z+d$m05IuyDT{@FN@E2rGnSQ_(kk$Q!M3sT` z=I8O!-~;cq4V;Ji+=X}M>h4%+w7FcmzI#y@^9JZRDyJa~ml7?hD+ zxFib-^4>T+Jj^q$%SC3#bB$2eQlnZ@^AzvN1$jk0XKL~XzSn;KX$tYTex4Dz5pMKf zgmtZWSUKExS}$N{icjuQ@kgm_LAhsGU39PiSts#Y_GWCDnJO82<$BEN<6`;qFHmUhbo5xiRgP&hyBEaq8ajf3URYnaq-FWy|S2ZX2{jg@eH0IMwgSb`ksEy zy+k%g4>W~6Q8Q;(=e`No{qqrS%DZ6-ll{n({(j}zTv=mdI^uAd*~fA+o;m9oS<(!V z8;?nEnp#+N9{wJ%d*1GbRE4iwC3>zL?Ob@0m&JhBAIUKE0`nM}4lE8a(w){{Z);8| z&iurvo!e019QB59EFhnLTC>J=#>vZEM7rv#TXHu{SQsB$=ZuH_A;mS03M;e{t*&9 z72d;}q&K`zKjVm8{KRNE+REqTCTF^iR_bs zpOnVTXO#vHZ!jy&H0m5Z9WM9dE|%h@Y+LFG>F0mWYmsV4g7`iGxMOa8^+E%a6$}Wou_4waL*>nB10zut`~)S>Ik2|I#nI!6CxQK&k&m_^Rdx zdFxeX;`<#^$L8g&>*MLi-%F9+Br;v)Ug8tQd%`kYhvc(=1k;h)&Pc=Q-EsZeh4wQq zUX}Pmp}f3^y0tH(*T1|+7dz@!azYo;=|o5mWDgIb1@QEUOf7LY*TlSqcaO;Po;?V! zwl9hviKeeVnd@SvYa&-GnwZ_-#C4e{4B6|CT=x>f4ab+deu}=#1}8VgNGL8zeK1kD zkW#=7{Kr&`{_hf#A^Z@5S2v4-7yRd#h>9rdnKok$C5&?y>>nfQbPI7_ePsJxpKG}h zSdF3W`5eMlCx@&U?%?XFRzYgTChNiu?#iKJKTuehj zoiC%LB9{}6@FB5We^5n6k7qaDHr(toyUlOVihunJi#oY2RNVCr$K~z^owBk+GDh$S zvu1iTjFlKhjuvVcDweCW<>JRTS$Ht~n3m7)tJ_K(xIQhm&!@FWBfAwesNT>#en+v< z)@y3#MEc|hQ}`2R4mGrKWvY*#n8tiZeM?925B57(eBG%#TQJnj^072nd?7Jz|FH3?B3|P_TL9Gmd3vbhb3c{SMAL~d!552Ua_l<)#Kmf+6x)$ z{i<)XF4wfHEMKLwEdBAV^J3I$7APj}P(3>M6tDAj;MbnuT^x8gxOA%1vL#XI79f+* zBjABTU!X5D6>~9qHZcWnf%9;z&NJyvT?s;;0i0gh;tZ~l&R z1*aEnK3oomUTH)H7LsNdB|~JUR?pj6Z}-y^cS5E2$Vg>Ijts*GRYk%N+f^5@k?Yc& zcic0IW%z^(GwTo6RE{@`)40mz=Fy&f6-3Ou{mS36FVJ#$$m%@UNYJL;;v#ZAd%iXNV5e}0C`YRSYT^afG$s&%e`Ldi)dR@ia=mDC51 zaoa+l8>$Vqx*|V&o)$9h%CGjG(PXZ2B4=%I%(|iR1fKpe8GkjU39aM-yl8DUxbljXJFVfxF*%b0E!mdLV6Yg{1M* zemNf7dpn&5xFR@oV=oB8mfeg+Fv*Q8?tDnYVIP(myutUC#mjpZnA2b?qR3EyEn-wx~9Wk<)CB(n}f%4_H!lw6(ufk?nR8@jV zES(yoxY?JSA54h0KW)m-7+n}fBe)Y;$4ShYt3TYXm{fk!@9?-P+cK@4C|Z^sPeSIE zzO!L-?sSDiKp&b?Ui55Zo8f5BvR(5Ki|d8BC+#I;jwM zXfsZ9=zK9KOlW-4?IQ5!c`Buu4csOGvYn(hUlTbV;X_ zuz;j=mq<&4bc3{XcY}0E{V$&H{N8tF$8mHNxbG{@`P4yaeP?-1<+J40 zcu&;fIvp~%w)x|YAsw`_1HD=*5Q54X=@NwvKja+>L{rDjcma}F*yPj3EMiA-Y$*il zRY%5_y22zw^NX*+Mto825u(*tlQ%ZlaSK1GdvnU(iDlhRRdRm4_t?I@EIknUTIzYL zrDwNHhmNA-vVR(K+tG#nT%Gd-NYCWbRT_}R-Ae`dFO+itSjyj^ynMraZNnaBr5CJyDOEGVB=bqlLmG&IuA_*Gq zE4^0!jCQc-YguaG-^@DySx@QTejQa+lHYEr2ZsDzEzZGp3*F@oUwAt*8k3I7WLqHC z(ZWR&NxY$Vogn_&$(6!^J_bgfGOLFD=3=$c!&*Pv80aw(^uQJzV6fvFe}=42iw8!+ zr5U3E!4KY3R8U@#D_O8W>U6wbMR{&KLZbK2FD96kyAyT8Cx9#5kLEDfRC0tSj+N+~ zoeJ(fb#xO=9jqW$R!IL8oiLa#OZcj;Z3xG?DW%=1*)Y`7rv}whWA;rOzw*N;9mX%3B6WGA%NZJ~I&zotvfNm3h&)*L z*h|cizaQaC)z}(vBL>E@QSXixy+0c4aPk_%W1KV&z+4)E7^h(AY;61vdVv%LCZ}R?pc3xt>iTK7+!pSR zYrF8R>!4ISR8+45HJSH!ZmfZ1Rl(9P%gKjFclnzyygN_CLrp%;UixJR%x?Na zd_JZJ2EsW*tzh}@tD1)$TzmFiQ8srj`@EtM`u#478lyF~suCg#HLem0lCorg1*?uE z$HhGRrVv38WNPx#4d=ugC2ByD`0-n|r>7tUfV|v%hq$d9b1%jD_t|SNj+a>p1ePg! z*`G$u&+PKm+O2D>+Nzp${Xt1Y1jr&iwE2K4OH;d}>w{KXb|3uayZz_~2?EQ7*cS`VbmgQ1v^NRd500Au<(pOeAsCa}=S8Rv7NHhI2`_#n) z&E7v6&k=Q5L28BWYsDIWewnWP%!1l{3E(X+GaHN0s!XE&z@w>}9NUiO=gv`H$f1Id z_6S+E5bNDJ=_jo4`Fa-y(x*m_j%vk=tlJFq8}CsccL zb*fAyF=hhZmxe=2L5n`*FJJzp`y#N17p^0pR41n?pV%9lEPWKrY*+#RWDtLu`~z14 z)6jqy_IRMj%-}_7sTyfckmAAZk~#Zkn^aIHmAV4D!a)l*A-drW z7!V&TTbCnToGTf^JiWl&QAbVr}t#?&Ia52 zLbMQcto!f|#u4ws-Xp{Nq38VPwVd6%cA-*o*|LoCu6rZ;sW|O;`-i9Tk!GmnEOc~m zBeZww@N6jvuue!|p|C+A9$tLc*Vp40^yWJ`(WF0M+-E)b^h|Y0btC+jpSwe%rz|!D zVTAZ_aQo@S3(U*)-;jdaiN}Usz4)8)hPlNW%qnMM9ex`I9_g5Iv;q^LggJP5zyEtl zfj0{fZ2MNgNX)QaCU&S_J7ycoIZD+^1n^<>=%V+k5>EAI`v(wtUcx-sbb*x zkP&r7<-2oZ@V=dmu|LkoqGIzgF+qvfcP1-o`ez~27aNJUd@h!gdKm^8J+=-;XG~`K zi^dA+X`lkb3eZvg!>3v7k}>XnH)ju35&l_0;h)Ak9FlTK)RjB>cV)|{lIZjCd*xrE zspV=jdXWc!M*kUMK?TMLLkO6Rp6iLHWNh>Xx%sXW>++2K{)KwGaKOj(#ExWx3lh&` zRhebWMIq|j+d-UzM*gd{^J;=a=`ctmM!Fj0Lg-=f?p^XAB-4qa699_ASZ3C|#0~F9 z`{e%k6+O{@2Q8D|$Ripg9&rePWG63-z4#mKA9{31!mLk1RAox#gx~b*AxvMJ0E?;u z91$>m13+p3`BGaCjd}zoE7GP9F(eNdIXINab#9&j5R;ZVBD=H{_sF%OIJF-Xbm{Rn zEfGG4Pt&{$UTTLj3PzmmM!W8A*DU?Fa<8vTKXHr6(nqxby%xOtcTD84-z;1>ZS9nAh35;FSjGoIuA+>LOl(b7WSpo3NgKp+dta( zDJI*sr!V?3gi~%i%2EZ+&MG05RJBG%MmiJx?__=Yx?_kR4l-QX@CT1v^}I@Bt-hkZ zQNn&&dE;AU1*vr(4_^-?5;am*Hhz+I9PjUern@~Cx{2tymG=BPFjy4@nGSnhvy$JB zIL^<14k|JATMBl;6);{ya&(GLgttQNC9H z)*r66V}b?&U@1<}tb0njrxC8V!}QBbK%kcRXvkKg?Hb6ftWDlOX|CH*Yq+@a7o<|^ zUV8FKW1#|KBZccs0!0Ch9r9FJ@{&nzlot}3CWPQQyn_~omZ||cX^kg__m3AUMRrJg zH?EWqN&g;aPNv~w`4HmmCkgrVXQ7DlrKl)X2Y0QfU~~iShG1&o|UoE{=RYc=-+DG@)yzO zC*4#B4Yuh4k}ON-z9p$*C2=ZKPqT{s6McSOChFTo>qL-F?0ArM!l}E*Y*(neP?AWQ zIyoc!3#0RGUqg92pZz1gz3~8U?)1f1_-55T=a&3ul}n~mkTxNZ9JOA zQQ)yCJfPZn>5c?<*P5_piFoRXZ96DbVfmk!NwStzG2*@44)8Ev(~J=(7vs^>5C6D@ zan*nYMEZ0h-^VR^aZBL$wkjQTxr({v7O3eIKasEm8#RJTUy7C@?){Hw;jm@HX z&yg$Y$aK@=q4&e7%?Km#;d4dfD2l`hoG$3a%5;B*lx;0 zyPnY<&4xy@I=X{+yt-w9H|b6ApL-zNkrAg74O{J-HAfZr*j~&-}8I*6~f20}nl;xtRtbnZ?HPo!ZBWMC3Yu z{Q;?CE0xcxe_iR}f$Xa_;r?zUf=*)nCQ!XiQ z)LdO^@8rrcULM2?J`3?fApSw^z#>9OJ_0wo1zB+y_GD?hW^?T$-5L`egLuh{m74hG zV4lK{hnuV6oh&pE8Qskg)4M(QAbR!qnQ&u z&@P3Bo|K?FDp_}eJF-{X^e%<*%?IqpH$C~-;z7C9^+iC4uzqwuTPgo{YP5*i}V;oAL=yal$3Y-0plp|(pYh) z3Uh$+$BEfUn8*PPg$5ZK0QOGBtOq9y*iWRSq_2H^n#~)X>0-GdN~-{hT-vv-!{%G` zCPqb@-Gn`-drxFTvo)if9kP!N3(U7-7R5vVL0wkKcGd3C$)S1u$OCSaU9HS=;HTW+ zsSY{tSEdpgp%e?fBmL?9$nS4sHs3yTymyN>6UGc=9u&R6(et<^f>;Qw zOpe^bel8aDemtgDIXc0EAT%c*^jktAjlO|#Np;iwVc%YU=5dPDq86)62F(}Fl)NCH zO8E4Wg00VS=cu1LjY&arVKDN3fJ;bL1_%cOg<`B+emWYUKf}Z6qhu>nXcvAl`s3=m z;wp(8NyG8v`NN6&T$cM^+QeeuGU{Q};5zPi$>hAy1}wW*$_;j)xP^nd3UO$MgO}&o z8Y?V|;&xTC@RFISY;-2x`|*9FX>+3YM-Ec%N(9Fadz6%TogQyx;g0l_vc!lzLqPj` zPzcw2qb<=O(sS!%rnK)lyKKEki$f_3$bJ@YS-a&|Z-48=?j-mvt{rPgpr+;k(ilpu zZ3TUgln;)S{ynB5zaH6R2Glt*$R|;e3;~`Bbt&B88(VIAMDe%h&O$$g=(US4$tj{b zq^~LVCxb(3fj3!=8I&_fuTvu!Wb)Mj)|-%+n1AgF%03AR2{tO$4_p;;N$Iy*%;r#? z&^(R5t-4C}Pihvuc)Pl;`&}X<%?Rd1f-8;rT5s(IB&9eTA@4UYuGK%VElQuxtvhXv zKhdg4&M5C$@%z@l2JeqqIKt4)#;~0UB4|6+-QxS>obn8eIsEkRQH}wx-`1PGCy>q; zdyawIbLz}Q0LST17j4enDe(9^^M&2hRKUR1fGIb|jH*EW2~FLl2qBib=Ox2@a!XCD zhOAQS{(ikAAfFyO87l%McZlx(&)w&mI>^NdXL~qBOx6{TUgj24y%8?9+R`~Vd-ok$ zy&_}9i#Pr_BGnTgLjyIKkcANr<@psCLONy1(;CBkesN(8MtiU^1|Kwfyb}4heErkd zqxyrBtgKzb;SJ#+|CQ;@ep*GD-J-8j5Ca`@%Wa=>DlK`{w_j@20Bi5j{ue&e;(QuZ z`FjIeMeSBR9>J9~oVO@TOuWWWbSBKGI$97aaiiB?JY4)U8(ezQUTGTonxmsqH`mQV ztX@HkGhcKRTSa~Lkk?L#Zcbp~dyf2Uz9dYo4S3m-w&L#pK@Jibg95O{qR-$S2&z(t z%U;rEk<}xlTfHK_4j07+PGtNTY0ZtZ<+?cGc|~IS_$5Pm{0_r$Tw!nVn0y%tfVytI zd8X4eQopT%0rTUX&ckA8RbjM)n=Jn!-I}64t!Hb&k{9pylgLu+j|XZ`np~D*Lyg#q zE$ukMLPZ?S(r%SY2v9^tHUk+iaSw_eR(Xnfqq1*Xf&^z(fG`4*>k_JoyY~ zHqeU2?98QWg_5q{HEIx64|EM0RyDnxjUZUaawknFr2T%-iEy`(7u$Dc$7|7e=aTUX zu%l0~h%3Wrn>I_VFQ*tU`Y`Mf)e_2|-`vhJfCl1n?4#l6wjE^If2 z3ALxl;Q34!{QK?8t*eFV-!^{!Fw2og*d2RMd&uFmtAub?oEh@x{)04{D>G$DNJUrp zp_6La#3X?GIHR9X{V@8PJEj*YLAdn6(@rLK1Bn0HQ~!(iX9e4F-`MHiKcV2uIUIa> zA9772oR{0Xcdk7gabNeZGA_0>kfl^>-96gX#GrD&yK}&<{!h;!t)|td&U?4y$*m9? zKZ9iR%3|$)>HA%;?@vmQzH8bfiUF)Hum9RN2mQPCWs@Xv{Vll#BiIY8NBn@Al>aw+ z<@v<$stxnzABlswURK5BpH1raOII2ZJ9`gUu`V|IoTdS7Iiowl9~*JN`0$R%Zq5d? zR$~g!RI+mZpBCVLP9wVgwO5gjGl9?*7?Z-8sR}J4GK;#&LdzPzt;!%li_ll2)K-q( zjp}gE5t&wqyk8MRqf(1!9eMuHOB^=l9nISoOV+XGjTg6VKK>HKKuU3td`q$0KIKZd zy6S~4^XSJo;h055>ab2#^@Z?tp$3t{-t%{>U4#HuHl7?zfeB6&KQP)yO&4>BWLr_J z%(oW`c^>bt5-7RH+xO)d>QQngpt%N#k_kzQd&kx(pvh5UJJ#8KS%|l~*3>_zBVIVa z*?ZVSlX%XM>rkb$4{w_qd}(WEH{2?FzLFp7Vb?2lVKlHqcJh@`O)?uf?CZsQ&j#FV zW975kVLOzNwtsx;Qd_%7<36Xp$5)u(8a5v7;^wuL>+>YJZ+X~m4GzjrVd=kqj%MQv$dlW4q!}472*mfC*Pli6nIb2Bg{R@llYfDKL$Dt>|Ha|-AP9K?aqrjgZU|p zeu}RvhYVlrFYy`px0V6~X;=Jn-VJL%s(Aau=;Zq}^4NDDyzXSa+_Jy9&@>;LKLn{Z zd3Fy?d?}3&o~E9YMV^HHQv)rL4QG|gdAn=cKPB^$4AyyZRRP+McniHkOlQ}fe^}S< z2WZvEl3V5n3%pl=AIy2{3q0XNWUd9&iip#R;^+$nv`3J3y$`}QUT#AU3zr%f8JcpX zS+U=rBO4G`{tU|P2VD9qg=*13OjpI5H}BkkalU%Zo(&*HKbJ)WT3oun1PQK_Af-%( z>$^7Xa~J3wCSO%5B-IyGbXkev)l~FqLpI`lc~kI&5BC#&Zx^hDHBhaTo+BuHNlBtQ zzDBMoJwr%o(IMO#!9Hw^t31#B1=QrkfErm|e&2qa+#0J{)V3*l`>b4hUoyDSZ+RKr z;0%|`HI9(F3tuMuoz)zscf%d_$!=4jnuY6@Z@m4<*JL};ng6u5{9at<^az~%4ZB6NN5jUO zMvkl&P5yn$flUE=0*uQVwYmEsE&vLjL*05FEcK^UnXxQtK43J}r(!BaDcWeFR`+OW z+)sJsmvqbovIl%c`UaBv77}VUw$jF`O=B%8A`)I!#@Sv@A(gAr4!hf?)AL#ffX>+? z=?y9SUz6`hUB4bxsMlBe@K*BYA7eksQny>Z>b% z2!FrBg3qb2W0Zzcm%RMtYb>tN)pjuoqpph%;dj4W}Pi zOLUaZ_f90>(aw-vuT;J~?|kEZC;gx`v#GNuuxYYqFu3u!*ch0qr3<`h*tM-)U2vf# zcM@6t_-gq{tWDnR8w?EL+D!2DSpTmqpwl^HMb(*~w$+rF2>$&mu{BZqPpxz-ni0w? zXxWHcvUY^+9AFNn z{7Cre;E>7o{qF41BPSJXOSPIrY}6&I<`553)oGJgVvC_WD+aIgW@mv2W0e8W5k_U# zjkZ8c6U-oEx3hh{@@u2o;?>^bz#FpYkO^pQ3hqD({MC&~(9=0ygI?lCZ;6A!4^Ei%9;({x|F? zO~`I*IC)~bna?Y#G;r4WzD5Gr8?zqloY3y?bj>QF+vSx`N%HU_O$UY24BEq^`0vdL z+dTDs?NU>@{FCNm^CzE%TdM0-_CDUFWJ8avUC1$EsCvr%-&bYFbtfDm&9}U?O0Ap7 zA3p!zqDf(|FLav0m#Mf-H`Rb_kC%ep>0C!?i?Mj0$x#LS>?Bv)$GT zofG8dn<|NOprS7sj))1K=+za)QT`Bh;DP7v^PA-)o*x?ZyHNJ)QB)vCe0jM?5)M|W zV)iIOg2qxHDYz?D;H&_dC22);I4Q++xKEH4OBV_ubg}FGHCZrRlkzo%d`#`ZGH5@b z=meZw!>YAU=dbwa@VH&nhLu>(hJ!YL`-$o6X_-lVbfv;5mAbIM!D31h1CmRe8-ezSy5^bTQ~P955T z;I8xD^t^DudwTq?x&vW65(7tcB@w4gD+RJg$TTmSOgIMxJw$JIyJ{bmW{<-mTySAA2{gE=7V?r6#L#)b`1P$!(yygeY!`@fV_Js1oc;i^f#4GKP{-%cBN&0P(6Mzy>8WSCly9( z;+oV?rXS5&?hP!<{a8jMGT)AJhSctc7rWkj9EdZiIv4dT`4Vyikr!Ud?cnY3B#b6q znv^PZ(c^;N~iDp zH5L!Y-!>GJz?6#d^2RhAnhi_(dCEh7`Z=F%*Ahw9WTy@_s1*d93^fv5EY>$#J5@uj zY4ExONvQlT3>}~02sr*6U9P1j@jiUpu>CFYvM1`_4t^HY%4@ch2K*iG@EINjbeFwD6MAUQia64(f=H};DQSv z9nHM|WPfLDwD4zEQCuwK-e04-ls$hK0Hf8DT$`km-ETU(Crc0;T zbm}h;rV`|2&8~r_C1&k-Dr~8;yG-&rT$f9`E%D=A2xv9U<-LmA4((751nz0|Tu12m zkG@{_sH__3Y%4p6C8B~X z_Jjw@w{y53|g61Ct1oQ+FUWb+n0so&9(r2^M7s7+y&*-_FKxU8ofAgl0vTy<*?>0F5 zc=8{)J~W*4H@hd%id;sD={fD2Pc@tv-K-q*En~yrezn@*YV_PVky(Ai*EAl(i>-4R zA0hmiYPKR3C!4OeaUW&v_j8PkHY`L5qYhxAYw)w=H19*u@8|AC(qHANRJweg0 z0UtLtvWSJuV5abY(Fj+pXdZw&Bo?MTGi_cx=&^4G?Un1I$6v|(wZ?^r#e?=I2co2J z?r%Ny+y>0GJg45~N$ik=dRnh$ZQ%0a4bAw&&ra0rjbF3SkU#pK8-@MpKSsD7ZVgR@ z295(la-80}s+#dpEifADy~qY1@Ef4jNFViJvwG$V79eGEW*rcA5OHowWjnqp{> zbyjCLdwS{8T!n3S$ohgFW5qqPy`KGezN_>2liEZ7pmVF0d5xw0gDG4W;X|eV#k}Ux z%&D$1HT-x3&vaO@rr&=(-~-lbvM3>bjyeObwFFq^=s!a&FptP*c-5o5>U{WufUd3k;8clO zsz=yfTEb5@RO$1#K7eT_=+WUq5+T#$CS5#jPS^b}zHQ0n|h=P?Ug`Ja5Nx#DwZweELn zWtQj?>43u6Mbop|6R$AZuGNz(Fnt3bGjQiyhx1RPs~0IA=lebD%o`N-=m$a{eLVM* zyFIw@6E%<6@13EjsD781GSpk3{QK#lNqv7n@n$7R)XRUroCyX4nP&LtC}SQ`W4AZ# zAUYg^;8qVJku|FSon*qLy-C!k*?zc+kzqqovIWpUr`bbi0LPCDADC0H0dO6#NR$pe zbc*-XH75Zf11Gt;wd)50M>;R!cZ1c~84UN1Q!-^Cj7tCZM z1@bw1CChCmf7^hx-%{}jTU(nK+F@rYWhk!C8b?044FT~!N%uT%13_N%_WwkQc2>)~ zhTfE$O`EU#DV&;blSruDY-|@9-AN2c*<~w9ObZ$jmr)Mb8idoJF~)PC9N` zQZs^ya|*bo{>{>8LK@(S$y&3iyHxxv2v{*GpLQdO_y}|>fO>)(y(~3(`B1qoxNR5$ z^T7b0Gsd9jHNEGpZfPfHceu0Qx3rF+7s5{o2%dPZW3dQQg|O+}^);_XM^JwO#9f*C zU=oj|-SvKrv6&fqnbuSAdHncsu=FmPG5A9ogR=rn9`JMpy`14I-84R+W(Uq7?CCuN z+)g|GBFNrp0~V@3@KMMz#Q?D%;GGguQUVqay2r){0Y5CBiT7ul8@#jeTT@fhNV(iQ z{L*UoSlMk?q3~pzU-{dMtIiHXHt`Zx^^#IAG`B5U`?E6j<(VkxtUGUOxyTdtu~h1x z?lHOvXe%Ht*P`DVSFT(F%s|9(S@=P*86H2+95!^&PSWJbD)R40lMZ6;MPraf&2W-c zyFXa7I>xsUT&&BLij!xqph)yz<@CR+j5Cm=h;mP7wK@1W#@*%RkN<)TsVYv$%|SBNSHu*C(&o zL5Y7EMd)-`;)g~du#P?>#FWh&C8ea4=iaoFL2!89mY-><{10?(EU)29hA6yhtcg)e}=oIVFcR%)Rp?u^o!H(mN(;+Bp z|6%Ni@r>j43o!cv1Yp)8r_|@l9;}e$g=T&9z?+AgD3IOfmjCp^V|OH8DX+}98^>z? z7ZC-YO-Hr$ELg~DT&(eZfaA*oL=mTSdUfwU6nRI~Vi(}uu`-^K3(c4R3QfJ{LziZA&?Y{J3&hA!F@9@q) z`2~;>t>nZgwPi<$V7@DL=SUtXFfoBbT1Bq+MjfdP-a=-rfA!qQ&Zxh$O_mSPp~d@Q zX}PtKn3mQBz6~(i)?zRhK+J#LuU z^qGuo%tGY{84%_mL_by$c8qn6I?v$*+A_db-TA$q#fg>^Ox`aue#ElIH~4fabhE+- zt5546^-FX0e?w1pHeL522LG~gBK&$|xKpC`>b&A`V$?=Va6dKHg)-#PO?R_MSdd1_ z?v6;{EKCd8oR4nVpvOBPpe7;u1qw`pLLE}WV4pf6As*5H9a#?0Nl-``kv|atoxgRs z_dd#Jy<6C8?P=az2N*u^$$TlMktB@*{o`xl!IdMP6LB0=|DCgkJBB$nveyK-mH<=v z)R@bU#I$YE?vKc2=Q^xj&`lO3r}Xzf1-_=k<34ud*=p;lGGjF7zjFxvdS|-yAqizd zpixGuARq*4ao~UvNe60-2X=Vpj3~5|!*-!TkSi>viF-sW!!k>a8SIsJn}ex44p#sN z0rs}aqS3>?#RiNAvOg-QAs#9CuyaV{OHH$}Xou0p!m&I5asa{MUd2!Wl=1Do0+=+u zb7hNaLp^N&Ozvb&saPXfLg6L~QWLLe({efRSPstT=qxht`f=!wwqycjES+hnto(A`-~sk4)~VDXV$ z{dJ6v!Sd-$!S&|UYM0&k!JBSSPK-n!&-%u``P-`AtREQReRHT3l!e6}rZ~6IB!Bv% zfy*G$jOqbYGQ*auB&=Bed8NXk5{mK&S@Ssp`3GV+*wZ36n$)b{Mtlg3JRup{U1ZZ} zEVkxaC~H&@G1yF+XRs&K?#`R69$&EuLYov7-vbbqAT{6g!CB(sbLj55^`~90YRo{H zu)n{5X+7Rh<373<`aLgCU345!)gbW0QLwmx{>p9Tg2` z67*AsBDQCi{j-7R%!CU8K0qKH6@|~L^|Qs^GUVNG#IB9&OC^5O=gtQfX(;zS>79K<<6y!|15ZN%^f6wEYNTn$O|AANMj$LJ@*Cq zC%^Q;k{cez172}C;+V4zAW?QDT3t`qq&OMZj|{f}l)V$`C$d zflQuvD?5AAuQK%D3OS8LKJT&@W#Ar_?;O8Iw*3IaA2=0(%M)nVfsX)$7kz!BOgP?` zAlt5SE#rdu&}0I7?JsSxd@kf+-+>d6_+r6>{crQVcadHl#B#Fa!8{5ilU#{vL&A(> zD<&^Q-+=WBw)$Do6VrWkX=!P-b!dK&)Q9GYs|{!wG4Lf<+b)Jb6er+c^HeIBqh7Oa zbywYcd?}25V|sb@CcS%x=VkS8{*46Vo#=6M#&Zi|n_AqW7Mvq3=GdKZ{O9}6-&6g( zSjaTq1w5mZ9V@W}6e328*8*M~P$RD#@q-gxO~n{Ux(f=pfg=TkAt_M;e0g5vi`6=< zrjT zHyFyHohT=ydl1a8+Q+(X9UREeN4-7Bl!XHS==Zcw2E^&4bXw}CV-`GC)8$WG7QOg1 zignhvDmKPOFFGfi+!~D6t0;hZVDWA!w)!`Epg8~el=1E!Q;MIaniEhdL=`bmV3Z8z zc=(OAn7k2_bnx*J1qwvq3<4h2ET+=k-QC9=9^pXKtR@bkG~T~^mr-IMe!+s!HAIUl z0gK4GzLKem-&Y=L4b&DML>Puq+`OUw5}u|Ov5MD6g27W8oaSeYXK_uI*77kMlEj+K zu>u7Cl?6RmYY0`le~B=(!LFsdDX6R64C>H!dH?TRZ|5>C$I6AbX3kH>dxTt=?TeR^ z3MbyR|5M9r9}f8cddL6&U3BQ6 z0tT;XzXS@{TOsA>X--D8CaGKu$X{uuQ%6RaojPMvQ^d`^$BL7*5hT z2--B7EYa7hcV^Ql(L<;gYP<(`94HQVctf&iV|stYV1n?FLSGTewN-9q6cHI8PDy65U_mwWnLbG(R@wUi%4hkLWiXf4aYn@<8 zL{gHGAtOD-#V!1B2AFU&Gg-Fyrk5u@)`T{jCpw%x>nOI*2*sZfs)#wGA=mBoOp{a(+j;9+US%3H^SS!wq?g7ak zm{G*5#kJ3NCb$u9tQLo}Mi;tUP~^pSNOwz6{@_umP6G;a9>26`(y2lwUY2f!vJRq$ zp%LJfynOkx$Al}1na)ppGxkQn7cg~k+81q*a}BW5A8x5GEcS-aL@WR!CNXFUr+Nhh zwi}nT&qMsIcthoK9|1mFfhk+Z8+52971|~h)4z^8ku_O~RWX+A_`|?F-ZS#2f#OL! z??;lPb_F@>n?W#9`84aFZO8ewu^E60&mVY`06(?)(vR)-&BxwX$uT37n~HrmpfJC< zTU4$74P-I=M;!$Cp`F0!u$#7fZslneIL^zz{7D|gn47%#I_%o|Q!)lU0+GY8i_yFo z0X8itQ^7aXpUn5BssOYLCCOoAR8+GkGUbXDb8#q{mz)r99Z z`=1wmRtjUA&|%@*e8Fp+u(0BPndG-hI)C2~^xm8p(1zqjPr2Et|Dv!~&~XbVloHEV za~QMPEvmS90Eec^j%U8^0+ZfAatZ+^|C5@U)X#juR)Bxklw^by`^$U@n@8KZ96eU| zBjVwNxo!zxB(Ik$y@nzN_L#`kH$t4YpLwGZ(D)B9ED{w~HaB z_dyc}RP&g2g7GHU;*;WnsU`BPc~zB(!Cv6CH8qKxUR)GzazPM3?kyFGk30f(v++*< zT7q+PXcN@mW4=+qKqr{m)zJ~)UVL}6DGJh0MCbZ5Q~V!HXMKjEgHh#zzM}I#sexPM zo*@=?o(R6oT|o=vgCX`q7*vlIwjZ+jp4<`Cn=2P;5x%3YeVTMlo6_9&RTf9C!dFABQz; z)M8@%l!lyyBYx;rWv`6;|7anCt8fy(E0J+v$Pj}V+OUaNPMZOkWr4WwF*#8G**lak z{GjxHN+cx)ya|X}E8fC?>D%Mhl3UvFl%2M{ z$d70}z@U}@h7GR7qLbo5(~7A^4?eEMe##H?H20S>tcFbuz6=Es_m}<3{3|{9GQTbO zOvgLU8xa?aK0fN>f z3wL+kNG+gG1MjnK*)Day@A9(tm#|wP!5$03dVj%T3K20QrnKSErUsSRoUj(kpWSkB zE;L~oA22*)S}PjsL>O44!_^0fy0U)ju=f2%;e&z5jNs$L%msx$@5< z5UasCk9Y0EPKQ^E<7x^MZ-o^AW-b*vtnpC^o)U)1?bWxzX58%8hjm0fN5BN zgKqE=4D|oi^^H^XC-&`Ig%IrUJW?LW4U+ac17H=hCFhATK2Fg1y+ER=iGY~AaIbDc z^uW={$I9jrC!^d^ISXLT;Na$l?lUR8UONmSVmbUH&pxg#j#rjhlb-bqKoD@%^W9=~AdGVkPiV}DInDnTde?bO+u*4PAsLxd+v%JP^NY@2T%QY^T+1I)Mu zgZM287s`^&yca>#1f&in2|Zi%7kjToR%z*w-4m?XZO|?Y2^BGinMd=He>DQ#1JaoF z5AS-!?%a!@^4ZO$j-NkBCw@(w^=K9ICkdRJUc{R%XG`hu$U#EyPekI)fuk*AeDDr_c*W%8n0eIFWkQ0C5OD%7SDxdl4Q1^w# zb4cI9h+SwwZ=pdR80hJlqs*v;xJ(@R_8je!lp&wQV+vh*8N!yvkUpc*3h}Zj4wC8HfO2|1~xL zuK7yx3)b~TxR^5G-b@u1i)KlOJbPnK{@)D()Ri-kKC14grA(*}f7+jhtAYm%CQck( zLvGyUoh>b&<+fsEnAt`)ybB3SCs^1ucav5LVBGd%lW)O5Xpq##$-|TDp^xa^yJ)@# zfhIHDA7`bHei3Z0f*;qkK1Hbo!*&HAfLg4m;QahAe1x+*>j(a&(4XxJ3863InZM5A zRx-70(OJ(xJ_`U=c0NV^j1U^rimt0w+zOwjQRR5~ zXLnn3L6{oO1u0O@?r{F8*k2lEh^qS#Kn$=NIdl@tC;ziZ151umFD>?q{07sJV*l>| zrGlk#9Z?r%K?ZovN9XRhZn4Q3s-OZ`?!?05T-R?jk&%bOpe9Fzy zg2i?kx(Vw{ssXULOiS%H#&_Do$jIms2)uB*2qMNWSx;{O_EZ@{-Ur1>8Ws0E0G?(o zRsyj|9!+`J>_0~|+EWryJch}gc8}YhidK;U2M|bgKYOup?ckSC81Ad>kp|FA(DE{e zY!e}E45gQfr~;~U-esU|e|63|zpBI8V93Ic#H` z(<~Mvox}azt0%n8tW&I}dQ!)%_oO5gmqr*?tkV2h z7{3Zc%VWoTEecy0y}Au{1{paJn?TJjEKnXm5mcYG^Cb5UPcG=S&7~OQlnw^y`+8Y8 z?NdhOfW|ol)9g`{_}t6dk#GW0CFz{HG$T!1X((rnyBU)k6^y)mx~PCwktqh$a-WKz z=%&Bz8FD$J@B!rAYoc<-1u`XfJVqqK(W4#e!T^X1ezoGYd`YG;TK|jOkrl+|fQT&2 zK)>esKd)3xiQ zk3uJ?OqWnl80A60E|3lbUHQ|HP9yz99S#OW6)R5SrjqOTrO^6Xh1 z?T7rjtsk3R!#<)b;rlfFWz13O8bW3Os9o6CugE{&Ks<6sKL(M4xO6~^fJ4j)(R3g zI3%>dz5=-(knAHAiSfo#BP{2PmxY%Gg-_{&I|F>y^sOfQ<_gWe&Ig=)_=RD*<5_$^ z@ViU}3>nLM>x}s|+Epp69*ByB8up8%s{6K4fC~NraL#K-TDk+Cw=cHkfa05-6~y@T zU_(l9lB-00+%P%>UjZo*qyKtTi9cJ=A@!>t2}(giF^OJ_=2L3Fp8|S1FX=eUuVB5b zUe;Osk!_Wy^@~?)mzA@_o&#(*@8CrJ$wLQQM-V#0m>%rrEkFzS6)*&H|9~TE_ z!mZ+qINd|BZt!bJ=p<}^ceh6~VhMB}73$J?kpmisL6#FU%>KGcQ*I>}kKjV}KE;FQ zLE&WDbwEfDK4(o!yae=@UXnvbavHz)nNZQtM!@&t9yHo$ISHHCkJ!+_b=Y>3;HW77 zvl}sP!NX(w`1WZ1%+u)gLB!3SxnEpbyC+v>6x{OH!X;1ExC}Q#lAE@U3Fq_B zu7=}=PYkCsdm7V9Q*7NBT5N`v>d!8eT<8af+_V%uJ4+26pNQ=~xD-*N*hZ2g_w)X9 zMlED6^>twA30nn1QFqv2W*iCu&?q4#(~|GVSTM#awV#r~M~qj_o(PG|NE=x6y;5N+ z7diCFBVU1|Ph3NoaA5cVuOO<|1TeIlT1vybra=D!-DpabJPkqYnGFMO6#V7Rx6(=~ zZKcTL*yw2dD>yNx^KkL1qPM<%begR3Uwb*)`%Q2nKD=I)=T#{Wjv)lPvTzqdqx>7~ z*{kLQq#v8#V01Y{7%Lxv>u|^6mudcAkaaBR^N9fujA;-Ga}_G-BEt-PNUj3l!9QcL zicGl3WTL0M?&Q0tUSzA*u1vDe%%l@UYNRQ;AIjwo4br{>phn0tnEM+iHS}8+s=~)9 z|JzeptSFa$BjW_H#2ozmKNi{@4Z*OtSK`DEo|{cR9k>?S7>i5QSbfS`u17$r<4=k_ zEnLG+$@|a(r((-siBQrFIWtc4)Cv2{`?>-AMjg7)dMXw89Dn6a^(**O7xDoiz7*Gq zh9gBRyA_IyGJPf3PkRYWm-({d(f74Y`zSf{0RbL>Q?HZ^r3D_{;jrig7VWFg>O;Gl zC@=&fat$Nz^S|{CXEFPe+`l^Tb#PqGdGVx z9fg#Rkx(+2y*l};UQ6<0bJX3lVT-``K@PiGt{qd1GC}6iCE)OOIFsdafy=FUh9)?N zX|Yt>(NaPM)N<+^nzoPMHgY1kK}Q1sA?D|?N_pxlO+ZZoWxe2H!mE?Kivry5vYpl_ zrldl&Ob7dP(BVm;6HT-WkC#l-G{BppSE2}GfO${?U~XWnj(BEdK?)(P<5~VZz#pt( zWghd0lLv>db?nG<5Xtiu?V#pkec3_N^`ot?9^*rf4}w8W>?aulBSpzA7)dzm&xy|=#w(FzV8cMg3+YfP(C5hDK?@;RMTB z^g;2x>f`RTfy`0uS!^iJrQx^9ed{~bnXRz=q~1>n1Z_r%j^PeswZ0P5}V~0)cT>4;J}9lF*zlSSF~6`Tpp&BGJtZ_ z(=8u0lkmH}?s)P%vCc2GhcHPiW9a+$@8BQr#<5ZW3>4{Pb4Z4j7$BqjAdL>BkeIt0 zpguw#hX7dP{c6`&#Z)vLcHAWIlfvfNnRG}NydJ|C;67*C`ru>$n6NI94X4;-QR0fK zeB%J3$&UXifQP_#bstro1p~~n*8@QP=C6Hj8JVv%LIa^yZ5g=YT=@m+ z+#oyIq9C=WW;j&rC4F=;OC~BnH|#d69cs5$C}R~rit(Ts2B~(ui$4SHJZ3Rm8KeP9 zG{ms_1Tm3W?-BgM4IOjaik?$AtlU{uso$`}ALC&W8IhP)GEbYpAT;lGb z1V?4k2L=~CP)t4UY0^#hTym1ER$;pXRO?AS>M3izMKS=B{{85vc2l!|yufvFjAi`LaFXQfAZwI!*AjN8cP?AncU{nq=^};c$FUZlLywhKBG#@ zpZ(Gm3TP9}Ze>NqB6efroj8jqKu>`c5H3%|iZZ}(|JFZeu>I)53$z29#UU2^YYnX! zD7xnsB@s$XYY(3TXVeK!v0CuO005E=$0tJu#D*al2L4@RN$fXu8LmuXGsV0yrI_qq zKbnU}+5<{@Fq+N$9PArRyWy&FoSJT1wHkNQ5up<0Wn=a2(G)+TsS6hE`l`OaXB!kh zHailsxo%^wB&V*xR3*PUoHgG2qHHUH)H%4%3QarUTknewQ4B=_UuFq6M^!wfg zV5eYlKzZLn4o{_=L^4{VP!-bD&LqM%tnQEKhaNtu3XORO1r_^ushl+6X#5}g`UzT` z?8Z$!n|7Wl<7r%Rjin=wl?ujzJaeMGCpgr(-*ZV5@*VfRGO2+ct zAgWr?7^(IZ-STl*Ua1zm0CWT?DKvM>%k;S?pN!yrAl@Ry2BV>XxV4!BG-Pp|RKD7< zVmb7pb!30G(j;)0u_0*CyEhHb;OFXt@~drjJ#&D!4o-aO=73gZIFgBppF{NlCJy$8 zlnJKg{VHxwVl5d}%Zy`+*NOo(3E*15xD}Xd15M-1O~t#n51tTxXDzS)V#z9|*BF;n z60mV@nfId(Bez~5oP-kK>X#zRSXiv_J$cR=pER8mHL&!&VMhURjTCZ)+}k@=l6}oR z8+>Km+h)2YcC5cz78(BezMR#f$>`oK*N>F!y7=91?bh|P>%Zya=2lMz6Z8Yfdt5EA z6~8ucV7?%{jBh(IyFa?`hh8W}UYP`S6#)m8ANqSl9TGo)QDphoJ9n|zwk?YJ30c$6 zAB0{*+>irc#c;gGoQ7WF2oc&)wozhwAUy-r>Dq5tM(AT{KT}7CnyU`<_c2JS*QPNH z`K7)@GRLw*oEb9-)QIA{(==x9Y6^X0*J=|F4_$*b&SGS!23R0b+=Es5cIk&0FZvjB zMeepxt<0VF=7R_TTOvSP&81gAR`!xXn&#=GATuq|-DF*lE32h4FZgFY{8L)BjJTR^L*ae8|D{%l%K8$v(VmEU_2PckRcCI9yz zYZCHXb1=0ibi2@d=6;RoaG|*KGhCoEJz8%S=7kC9bdEfn_*m+52c_48DJ_(eb|6OeEWb|zCaTPSbk+hhEHn!91J#(|g`4-yI_s0Y+zrEf|)4Vm*E#U)QZ z3BZnt99ud(AFD>BKW0k$@iL(BY&<|n<}oB=?1w($bzc(Vig`J?M6vgQA4jaa=;zPe z09N<#XfCHMlTyfQ1)>Mg(n;{8+##}>eHML114A6!GEb?2XzXpm9Jt8Isi~4I@m-l> zo?}~|G?1P1y#yjRU~Z=_VbP2?_U)Aq69qI@C0&%{p@Wh_i~*kF2e5nd-+bFc@D+*# zoc`v;LskfYIwOk^M}W5_3GW%R5A6pcDVH!`uI}V`x({3xMji9@4^Etoj@G_dU)FQ( zv{-tMUcO->?dw&nTclvFdK4!F#`ncWfrJepjBv^P1&h5d=%RT#j60 z^ed5Tm1u(Y97hJO*U~_HGEJ1laxS~>H!bz0-FuP=K_OkVWjX8|2l)xHR-PX_%Jdy< zAiZUqdZ<`F%+6H&78)PPz*4+IY4WF~)La?K%71o~;~h+vSv-ff0jkZTQkL}kPgY-P zOID{4|rY?(DiF^mM2uqa}Yd45hgfs#YjDI{flXk+)mGU77mGmAycC%J!Iv>-^t z7gJ>{I_1|WSvUv2Ia9{QM*vA_I?4vo>QI5EjT}E%#6h}TXoj~zmWw=|5B?d;l z+4WOZ0J;bELb$+&XX(>Q*^Yh*E1SujP)UUi?+ubUA6STKS%0l#|(0Sh|J&;ITuc|U(i^qSLxhf%v=FUkCb^ZEDhsi$Tqpi3Z< zRgj`n9J<@(hJg-^mqj}+d0)F#UbJ94g%uN!+{r}>802x!AT3-S`@y=!;Qd^6S86Fj z=Wt@B(6C-z;m}HEzUN>;LlDodGmU$N9wK^^>N-l;QDO4o^*(|>Adw53XK?+{dfIw# zVemTAn!Y_!3aD8eL|>)(lVMe9rja*XkUn?Xt?f$_dT@WSJDjKrw3~Z-fjp*8IYY6{ zbMMBn?gsHsC8rf-e#mz+YBMAJ+k#l>MOh$t$KKE6;2z5CPhR+RdVKNcWsN+7Q^ZeN z-~ZR&dF>O4Jv}?$ZSx3R55;+wL`6)^fW|-CSZ_s1&u1nl3yME|+@1~wO2Z^S?ySL* z6B7O7*O+}^9nCv%&(s?-l5wNq3~I?;LDQvXXHY<|@n^vW;e z6A1>>bY`}De4?VWN9~3iM^nPEStbVXFq0q=Xs~K+z(^&?*gP22qR4ZPyuMrp$VfIX zVEX%U#Whl4H}R{=qhcH6bHvE(m0d~9wj?T~evClhKg(?K$m6KUV)^;k7o!1Zxt@ZY zzUPPLx>vWq_;cCp{$6Lt1J&Bj7@K8}+8l?Gp1DT`ag8b08MUdEPWNAUmv2wM)8-mv z|K)z_Uw^Vo4#vbAW^0QcyLc`QuLlbng6$GOe1T`X_akQb`e{qb*{LWVxj%+u;GNY`{4~~wGXyM6#;R0-;CI{Z*y7!HPEn%8F2hb2vbkbNQu-Jy#)>@5?1ef7KWHA;`hI6xz70nC9 zm+z~Sf3oa4>?kUc5%6bs#&e;2a;XAb4QOnDPBEr$6-Woy3PXhdp6*}1sZIG(4FF_+ z7Vbvke}KTQG(|(6Ds8u~r$275zKMJHBaw6{aqoqYE8#_hbNDX842^ta|dad5F?84j#Y5 zHf+qCSyH?LY=ddmy@~Ii-UZH$s}JN*O)GRlXn-NAoL)$bGewaMx4aP?9&X^F8~ zpL41xQ(5#I6L=(eOqC=u>d%*;xYPHx6o3s+1~l* z*VS_@_M{&s)eMVw+GhYgtvUe-6j*(s(%S(-U7;WbJT48?8=!TY#vtKk`)&l}iG8b} zu>&H-7^Q;ygJp^0yf{y^2Kb87veR%B)1hcz;_9R*N56>upNOgl?idB(1uQO5N-(gn&?Ku~^{v3i}040o_U8&NXf)=%| zS%}OhYj;v$kOs;{7qy^Erb!zC5C`vQAD{>Jy}ex6PJfVoesWEM;LoZpif`N>eE34G z;_Z%ROD1ww%MT(1X;cG4!#raeoGHUE!qK$4DKRN7|Bm+M% zA(xPP(j)80KW*gBXIA&+)06Z`XvlZxDT2U^`9=;coR%OdOwH~ta#H1SrY%k)(Yo zR%?+aIw!;r`qOqM^;|SRy1bj6G=ADGPO^UR9fiyHgQ12m+0hSFPiCb?UVTmLnc>IF z8K=MN?Exdih!1R!Srd})t$k2|i)7%F0@%)2C$W||4(g>$^;?&d@~>-4rjNh<577#_ zd?tMO&A?5lVgJ{W^lO3&|DB4XZbTR1HE_8LX=!;u81iar4Jfo4NF%0j>U4>2x5dwo z7I%FWyg1{|n5Pu2Dt!&@XC#25qUHDgZd?pJQRC4P{`)hN|I-3wUi@j9NeC`D>&6$hnf&uFP!{*j==j$13sdj%y2IFATp2S5#ohC zs{}la?gy~+%22`y?CMNPAJ04Vf}LtxpZVYW5kQj27RBc-HffccvRM+yqp=N)79wk1 ze3E)ftRClZ0gfoARt%fZ%0!~WXuGDU*K(Vn-?h6tRFtK7;@sUknunWv$cjIx65JQM zV5o^sBCB85g4cusUz7ytT;l6oQaXD2e4e4aF#8$c!Df|Eaci!?#X8^da7p}X;iGc< zLZiY(4(Cp-7~xVgw@5}*#Ql2v+=bn~!xsApv{o$M#rv%XQ~Y?6QBQmZwX~7`i!WYN z;$u4L3fRR}e6^XZOK59IhhK3AWR)~dt^hXurnU>M5d4UdqE`TM%dGPL9Btuj4z z^s6kY5L1OcKGLLP$$(KtMnrU|0U56IL6%&;s9A|tjiJ7N&~!n4%HIznXcN#V7Nux| zRwYj?oLHp7e*Oq)sD*I$xDJc{B*iLEZ+)*BWZGy%L+V9TV3+aYllM~j)D6lxF~0H8 z(ZzkDkXN(w^I;;R8btB>bcEQ+N(I2cU_{B)Bngr%wO^z*Fz7vuRXX!jeXMEk>uv=- zu(r__23<73uYreFRjKjbCxWvNB3$@}ebu6Wf|M*Rh9u*wk18j6B7bYuNxyD0OyUfN zS2d14OBkfMPHgfGSeH8Ho4GXO>jK^Wr-p``47vQho9j!N_&>h;R2|_8ESdNBe9v)h zmhTRz(6(^mc_1}mUUl1jY)l&QV`}qm!s?ALB`oU-AcbqNC&*my$g4=k;vRFv$<}dQ zzNvZnP=aY5suPVqjfTF5MT6#`I#Wrb_w{4-$&-mqc)K!23hevE?11waK0JzpmY{az zI)9Phm2Cg-E8?zf_GJSsM~xSu_Cl-m4cl8o-mg=3&1$T#4m;eO_fExGZccqKiQ;>K zkv3aspxkM&OD`Tg=o#H6BuGjULQmR4$$W7O4H4iiLM&Cv!HYxC7jJIpI;THL^592p z$lFnRfz_t%>%YdF6c=AVF~qTJNT-f`y*%|WF=9f>u1=Q%5`nMap;e7WWzUh=$IKFs z_vu@9NS=8!8yAa58y#Otgd0vAzv+??T}A!+(4Klv3a%+lmtW9=H~z{%mMaFoS@(wtL!bh>87*-$e4(43;~(LEdIK_zFsPG3CJj!0mXG0&Hm9*&%v6R?icD zR&lex71(jhyD#pGWv-~7InG94efAhi!CexBNVDYeMF=(sV zivK}lYwPFs0Y}g%$nH1x{L-#X;CSURc#>cwkcf~k_f zr-Rh|yIijz8a)NcX-MWF zSKJS2XTRB(E3q6uUpf{_zt$lB!{)sve!eUICf~`8cPtuF@GH|pcEvIP3-z6b*ac6L ziADZ9=oK)avbB5@(5>!5M3EF$Ydi7?joI2mL0N?R!x57{M+3i=aJDysSd}cE&0LkL z+mTlF8HTNsD5q?H4;$4bbd(mgPtwh~HoklMoH7u)2X5Al0R*kU!rDLPX-_kn z+cbMt2rx*_JGbKRHhxNikq+etl1P;@t$Y=_!K5s6i65`_scsJ}t1|kpRy!`%WKWaA z5PY4Hm5nPklQwmta>j}gs@}w<(>e7SXj+5p-l6BTsjylJpS{#E(_2rrRm*K5`M!VQA)8}JIUY{d31j0u&q~W zQg2}Y0(mI%F-J&MavLY3w|4hq|0GhKv>5e^R%raBVf!)A9T47Zh+k&pKI&6nUbx!Y zHPKO?Tt}K-UHyI&!{9F-xBpB6L`RyIF^((o>vfdDB#J@gA25 zFlc>aQaBTU0PfIcz~`ymfjuy(j~RqDVCyLQP~%|@yiKPt3VC3~59u(;z#iBhiB9uR z2Ztt?zs#unH?l39bM53sMilC!CoF5_O}<(5{*wlhh6CF zd0^M20phnj<-|8PD5Mdrs+xs6zMT#E*t;Ge<-qGbgm4r&^?}w;rvF?pD>>zDDsq5XS>_+h3FbOgNMYzTNl%UmeK^8YN6~I(m-j04 zPfk>9AZ7R{Nsw}P<>Ufms>i7ecBTfS7YG2{$l zt2~H8y+JFvM@V4&XeLRUC#Wb0fK2USPqt@%9(iTtG!4R;4|4a>UspAbO4p}k%yS_W(N$L9d>+M7mOzBh4#Xp$?e9cXI*A2o*Z~M z#W_9XFB$;Dn+bA_jg6fH1NT!0ETBv)`c#Tu@2t3TD5}rBd|pifKkvMk2Cyuuk+BLk zvMh9n#)bO`R2__Mn(Hj*%B_lKnX?D1A2zKEuk${|RbwOn<1nrM_udG+YR^8TdUo^;@K1Iv&LD8Q<9A0*0z9;mLI1v5H9<(C&Pn!OTf72%rXRh)Qw;LA2 zCTnn~v^D38-p;3}dhx$P@~=o&g;>UP_}OnQG85cob&kYui@s;;9f6XJsTsde-M1G> z3u064%R@aq{y&uV_#Agk4Fcxwvftwf9^R#O`B|H~Kfu_VuAy%mK*-8X`B8%Ie) zFmDpcBy8ZiMng{BN3Mk7z|OR1zCM3Xt<5gZ@Q82%$yLTwh&5r2{3@C9(_}O{VQAw_ z!!DIB2s$p1@@T>}0BHnBA&}n6w8-)+We?O4;MnqIbZVxMJw5j}k43;_Ug7UtH;eKp zj*-bMF01{gbkSmTof^2n^nlR_2*kj}aJxQ80W|zW`*BV$r0Z)A3j1fEQOj#l87GfbFFqZ=BbvF{qT@P;Z4s{Q7`Z`3VIEZF@C zV2A%Efvd&KejEY{56AJC8QahIb{8fJKBOGN(CT+iv~NTwM>qJ3$JyobN3gB2OYK?D zB7o<3FD2T9H(Cb@EgW0c0z3BiZagwv$_)9^{DU3y=N(_SvSUvRW1`MaV&66!C-U~P zQ#3?YLTunCJxAx`&e+$cl%0G81CIR@u4JiD!48L$^L}o=nuyWf0qzpK!(#s@+B2))Je4(FyqUFyGkT0ut*{=&LN{t%gNBH`hmqQVC;u41xb3@ z$i(vi>fH2nbh01I9(v?M86I57?q4UVMrIE6x1XVuCop!I1BvmSgF}93N_%3Wxrq=h zT$Iisrfm%)Dv!zUK0){w5TYAFaqQ4X)U-2E$J)c8IAz3=ckDD9}xoa_?9`y%(BIcC+N80hO)>JB7ZX;ZNRp{t~Sc z@H<9s+-^kN%x46f=XSbIH&1;!{1vyFJj>0BM%;Qq?Qc5REZY9;Z5w@VBr3_8@Q{2c4XYfC2(lSCs$*b{+kn1c{{S> zrX&a|NNT=>tYVDs1up8czSh{hpk@O@K5K`<-&d+gT&{iSi!|i^r5-uIwsMLN^NnNd zKiT6DtmlC<1c_`iy~XL_*D2kmtyOzF$-Z}Zy!!D>%$_-$Ab67=dl9?`W%xb2nZyWU z?6nWBZ>U??=#oxa*MzN(E3KcC=CKgrZ(dNKkJ*nnq^(Ct$$C+{*2O-hYexxvdMfnC z=gj`a-}FH8K6-UoLNwnSBSYy6ko48>eP0*Z<)hbbxCNK_&evy-etP1q`3%_ceZ>fi~IYkxUm}_!anZK z--94Q5`F&sd5)HR!6@88GRxtRW_VDnmlEZ;xAcmCCRqIX(2YB_{VFE}6;hx&fixeX z(v&T2>q?1KFVX;^L3C3N@{JHO^4iZdh}#(dj0_VRo|4eDxXU{dxAKJ#U}cj)H;q-6 zB9L8Cql1jRrn*#$Ya^6#^z;!=)tJbuJt?*rijvS)6v3HN{9Ba{j6h9F$G3ebNgvGc z`BKXWqCOb>-pMB+bKKa?d|W?Z|1lP+s)4*@^Ng1Gy{krkxxFHM2Dx3ot&H@7Wy+s* zxHH8G5v{DJusTCSdGD%P(KpGKQBS4c;6h4Mp`em|`}S?NMrK1p!-4K4L|wI|BzcB$ zv0H&E8^1dJOS2By#0)2^)&Ao8?T>qL?G_L8sYlY1txrJjNErhD@CwC?GgIhbjs1B$ zVDW5rZq8lQmuVt;v$V@p3_&WVOLrK2! z6&Y4)<9N}81jTN6PYx<7U}3#o20t2Q8hsEs!3lEdzqfWX-_7{$Ak5_mi>h3J^+@2; zk$D>*JEs5@UD|-?brcL%_UoT(ODrer&Cwt?@y!nE`@+?QHKn4XyGHJN?f*tsByg+1 zS4%EG04NH;0BU4E(TNc)Pa%s%HXpXg(V>E*a)}@f`3Q8b9g08*#ki|dEw{ofzQ)&I z?>&yTnvn`ffOcpRgd7VB>~d*#h&+2m*5oleSplxwRr#;KjI|!g_ece<#*il8?bLgJ zx%PIhH|Z&&A?BpWvFf7Nzc9gq!#>iBFPk#{JnmZ`Jqz(ASCTrKjbTGfhGNEMESfLp zN4Vex#Ks_5Us8jCk^7L+=@#Jf2Z|AHo{#bLiRRf0yO`RFJB^F^U?Os#*Ben6O@}CF z(A)$?BRtdw4yk9cx+US49Z%?VSrRSVTk=^uY|@rYo`8Tp9N=n_p&R$KoAl=yCJV3T zT!~l;ZC1RM3r4N#baSXD!sNf!9$cjkusn$T{;B5^%S+ItXupY>Ww9<8|Hf(em9;?C z``Mri!xB>(6gE0>crFUW-P7BG;AL#z&P8L`$|twr*V*a?1*1i55g-h+{^-7rRT)Yo z7iD=Df&`;lhMO+Tc1}4-DY|nIW8Q^}W4WygZJ+`NLNqyW4TTH8V#qg0bx6 zox_>luMiKM!utB;_kT>>ARpA4plfZ%(Fl)jeE5c<-urs;jN_X|z-wm2O6SU>Eoy!voqLmfo$=GA zdsmxCLcgZqrsLKvdg`B>?Jxt<-!JkTFAG4xd(7Hm{)2_0vAA(-AH1D;ZZ&ciuMESh zQ{=Ysue-(?uU2pn|H@OPboeJg6wEmqRycTRQH?$GcEgKE@9jXaNu=Vte% zr>7TVmos1^)FvHiGb9F|b98h+Hloa#sO=DthqI;H}IJ;JzfY z8ElN&l1FWpJleR;pcKWkg1zu~jftLbjgR6UhAgL3DT1>Zd)vx$6xQC@`0`HYr1h$0 zE^%-#W$}2;5}>jLV!-7y`cbe}ELgseXP11cQa}KN2~|qNe>f5MYm6VCDvmz|Y4?bm zlECY1Pr?hy8jr`>7kBdO3+8pp;dv`tL0!*1qbg1Mu<+B3;K1(I!jeSNo3k)5|>>9rXQ2;Q^-L5-e}MSUCy1oPsmaJH?f z30MV4WUG)Q08$^hx|-jbrBomtOjtTifwyK+^JGx0lE`Zh7E8DU8|c9=du63)@|8YK z5K7p-NAtx7h)uqXZiF5*&TPxI0DSpC8083bu42XOAOgdy*r0^b6rI?ruT@7r^It2AGyOl-o%QQqK%pRr$tX%0&;I&MnoZV0!~-&4#^ zQ!=DuvbV_PpD#_HX%rT(LW{wq-khkfI7ZrbJk4t_9?seT?P%6@5m&MT70HZq=0gUV zft}Omi_B_SxnV+9;+JQn^bb|n792Bn(K;)#7(ChOQiKM5Ba{JCVzQaKs1U>NPi8XN ztwP2My-Ly$`bTkIcw4y-u{}r?1gZ=pY=@|*wM!61 zPArTRlt5BSdE6>^M9#7=yPSe=!JhCscNp8c|CTu9mFmMox>(#Hb!cGh!8FH=8#Q*lIN?O*URF zBAsGmUyq|J2Urx)v&c!5g8tf-5e#>NY>UAF{*HY83fC9Lag>|K*QUYV+xBdi9`U4J z*qQfL-2((Zga-uETsEpK1ikOo@Cr?NR{rZ;#?6Z!IO7RKw~4qki{|>umMm~> z%O~TxB0_M$sr@MK71SlSy4O}T5>d<+b$8B^>0Lth(yxvMG4mhv8-EE%TPdQU9u1rK z?qxQ3?q5%Nm07<#{HIEbXv=vN1t|QWv56qwUbrDaanf~E_~q)!>Aecg&x_Lf?;o@v zs6Tvp6J$jCT0Fdt4QofeC^Rd69P9Lv`ObC7tqwsCT-4q)Gsn$<^D`1pHhnRLi900( zPbuUui`fVIFV)XB_>sC1C~3TQmzTR=K|6e|J=S5Mb4|lDE@J^~79G!=sjd>5t!8w6 z`cV7N2O4DR(g22CJ?oY%@WCkAdJ~{sFggkk48Iw+f)>l(zZv8-d(*=;IM70#JQ|Sc8;ekB3vAOx+DoZN2+(U^NUYr893xJ`70)zM2vTDh$WS3|6chn?1 zH2!+ZYch#-%TlWgD0ARLj;FsR2k#bs7^T5f2;@nS1EV*Yi4uf3m)^?z zlc2dkCs#a5xv5+8$%WtpF6NOb<1gccdK7O>m|LWE7ZUa<=qc)TJT*}+_1KVizO_Jh z^pl9NtIoT&D6No~##Bkb9%dkqSlf zfJM(V*d^dOh6EQY`{WXA0r;^6+6i=RE(;kyo84hke*$`g+Tyu)myp$KA0tXbP;M`O zeBk;e&m%dr8Nhj>bbUSm&t-}4eSN%7Ob>G#OYfY<6qf0+yLgmp^RD<8E_;YIRd%dW z0qBp0?F6N_ zSiI9RN7)BdTa2gr9G_@n7$v;Cy}2?AXLr0{NuF}|s{W&74sru=e1fQ>1M~PK)B-c7 z0gVQ7DR^F7zBm)mqXOz^TJ*Mn;&jXW`~S26<45mSVKV>rlKU}Sk0d6FJt-4GRqb}V z^T?uxX1?9qbFb|pS3Jsjzc~oX64ll?dTn2)8*D#QX%AL*^dx;5+H^%ZLJx!4J=6tk zF4_)QZP2)hworwqVXhF5Oi7C8m0Im_SLPNND80Co8JTl$%H>w0=^M$Cbc8{@!4(mT zK+)`3W1sM+U)sEQ@5(qWIw~%=yw{Xj_FZ;tmh;{le6Zulkx6gXe$-IrOON4fBq2Bd ze`{1b?%Mm_rYjyEIi2BN`C7LL zxzkN7e#Jo6yzds#WsGJF(yqWhj3C@#2uZFP*QEa|HyKKck|-GMaudC4aPOH=k4#r{ z4l>zSY0KEy6lrwBt4NNY0+?00Oh#Fp@;ePt$cxjGw);iD1)_WF?Ew_aNUIWk|fw-b#2Y|VbM(IX4d^?VfHIP_%7OKD?&VDPER*tRP# zEfI6y;^l6K_*teVyUx`nJ+j7a4m40FvXlb*3<%=ecPhSb*~pPFX^wE3e%{d{omNsm z?OK3MsgB{0K5p)adJqwLM-u>aBhAg%YS(z0DMn=+Sy`X@TN<);Ny~q0BL2g(;8M{3 z1?k#6Kv28v=)|Mr57Dm;xs&2wrk^xe_?CGm9>Z#*55dk+mA5P8>lXpsS$_7mNdrhm zTzSZw;Dr0iM?7?{{-qCxlo+j~3% zskF%jz4|m@4@ijNnPeS3mclUrOv&3igbkrJ1 zenz;`QpTwEKAOXc-4j^Hga*2N(Y!q0agJd4g1BQ?|F}NJ}Zb?~{2^h|fGG-{ksIh)Ml45QOG8s_YIklc@SshMdx#W&PHj zF-koilPiUoMUBwFFVHUQyDnHNSp&vRD1)`?B+RI*vls@Lf6c;cn?A(p?gFOY8}q(y zJ5+7@&_;bTNfx)R^m0T`jh_p83xfb}NA9SYiwWa2-%ta97{Wb%E5tq|3i*5N(JsAK z-&LCdFhzjSX2L&c*wv^!O6bCBGXP8Aemf0WCZAxU{kibIIbW}4*g3sa^NK!oSXe0# zkRFnHE+=;+ugyPf`Ct#C0E(4q#@*fzA{47WKm~t%ECBkc0zWOVSi!03vmk$p0+cy( zg4`>!(5rNEORX}t2nBsuD2gpO8d@Z|;sDBV9Q^`~!xjaTwf#|DIA4m4xHLsoy({CC zd`|x4R&NbnX(oDK_1@W8=p8LfkbpWGG32DogxMJ(b#xBNd$yLJ?uR!w<~BU1IIs)! zdOfmHi)B_fK(=U53*bz~!?Ot6;7WRHuviN4<~3#kBq7J9W1czwJi@- zObAN3*n|W__Brn7vRHH!TuPs8Sx~A|SAIwHi#+$MXI-*%S%b__hC^+tlkF9vXGG*5 z_g^hCN6aARkV`{@*eEM9k4#5gi7Q?WWJ{}GmZY>Do&4wX(~27jvV@;IoTKZZ>VqGb zUv{#%lHp}?Kw1!3vSdQMuB1J>I+8gmB?tjt+OKYpDwz<%8^*Eh{}+afxL83X1iU&s zw0W+aHjt(4cz@_8y7nc`VT}ga;JWh^Pp?tU;(g8dX0>a<)oS{}@=~o55K$lAAT@5( ztovmJ2oh8Wz!)E(uf;YEi=||_)g?Z-xG-nYM80-&b0diZqPrcjDzh$L^(DIT=ZDOk zso?H%PEWNr6;9^0v4pA@B{=X_JQoYzK>Q3wS@DCZo}^BUHjeY>Wpvt$p_CLCFv@Ug z#uP=K&2umA!C3nlwaO^*e>jD97Sqq$J_}ISGD?^hhsqK~zkWQ35jtoLpsVYFb!TA* zc#}R8Xm^+pxBOq_;Am$93mJy8v^a4>KP#m$xYz`mwK+jVsM>L)#R1mbBNuq}`@Lq% z?pidVe@^B`q&qb>sY?jQ{to~P#)4FGd9uaSyv*@`u=XYwSuPdy!6bR z?h{^r&=jitW?#54H2VIbTTbb>kqz>j;jFuS@U~<7TfH(W?)x2VamUXtGXub?{xKs$ zIl}Y;0t}@F7bHL>a0fm<$D`Vor{&)d$Kdvou|j`YGj$ZxhBexcF0=n!QQO)RZ(7!B zP^0EIt=K1*3o)tI2Ez%eQykIMslP%=5t$P4;c>luXR3RRm_3Ge6 zH>#nT?rkzhq#D@=ZBuriE-yWGuB_>&Dvhh?%l26IGdt<;Fy*NAYmNjtx`a#Pr!kg< z+EZnJ$>H@>>}|>2N?As6-z+4$OG-Gv9uKg_%iXZZ4iJ6I^n|4ZAFAf6w3)L$dN^aw z^Y6;#SF6(U#`n4fkp9c!?3-rjkb!|#43NjsKY^fSc45I3)OvY=uw~GOfr7Zc=kRK8 z>08(7R`g9HUiVycmG_5V#?B*FV)(@OL|}1FM&~C>G9(6qS~ZITVpY;4e!`W zy+<97O|?L{B@9xD#T?ME#9GB(iKJaoe1X$3`CwWv!C#*}Y0A>tljFuhT!umz zwP?RyzU|v@2aSiG)btOT@uEd@-Rp(3hqx2@CAs0-iaVCed{(*q22~5Z3eD=aSf&mt zqvvgnWH=$XNguHZm^@>?fbdWfwcpshuii#w?}q;eM}>aVWdtEuAzLZJKn`Bk$xJGp zgX`xu4axGoaR(8Yc|KbFhHdjD<>IhmCn~^ji2uQT9hH<~J!9!B7z~Et7xHhcSc;Cm z>~SH>n(*E&P;bR&%H@A$Nfc-tTB!5O@hH$L=@naE2Gb5JHG{Cjn0C%1X&2~1K?c?> z3uC`@7B(I%z;MjVp-OvkXGaNF?4n`k+3*))aC=^Za-se`+b`kiWVw8()hi}M1D50riU&e;mxbNq_m~#*ouo25b1i!5M{{GN}g<79MMHUxJPs!_` zmo>XJO5E#=fgteQD@v&V)7bv-J$@gaaobaNa{RbY3pRB?5HseCCMl#?pf1d^ZJ+>= z<6$ZoeS#h6uTb9T@U;OagDOD+`s*5O%L5Y-qCs4hOpUr_l;8%FGvr1;<$?l%6Bx=o zBX;(eZNV9RHH<~^0}BCA-}RAz-rbhtSpN+Js>GOyTHfKG=5*??tW#~cRb29n ziSJ8!0y4lb#rI-?a%v<4wZaP?nDzaud|y!5e-KGH$?7!&3SPkT{P}HBlcH^AWlK}W z4a0KqX>i^9D9+M;?t#`PvR%wbB$1)cj!@jfz(#+T62TTO0J5zp{e?inx9RBg`MGI$ z=dL?`xKLq44qcA@OitMG!)Th9%eIf~j_FXTh2uf?Ljr_q3J26zUil3JG{1Km%YdM- z>gUj(s;y=^^ZoLd7??i^Ss-4-+9j2B(bceyBpDEw*N0QuoYHcwbyvx187}i;Rs6k5?4&PA1E0nx4@4RaGfOwX2q%%lgwgSNW+c= zDwoenPwo@Mvw`g~cc&IZ-Dc?Ut-#I5T&Ti5x$_mtFSh|`*MoVzzUm;ARHXtSAm-}@ z%ipXTW*)LXgdm$4(rNaF82kY#50+hk@+GE01NL>)djGq{Os-_BHm6(~8UvIP&jf-k zO8ix4>&WW9y@7;UMDpM|=%q5(odE^7v?S50?+$~uY*6(vY0ehF)&Ns(xEZoIIw;uN zE@a&FVSn7=vPGO4y@*=jYL+Y>*=eKybNvwfheqCP`9;iAVkUR$COFL0llz$^5@g*k zzEV`)^(LiCQ2iXty`2@n2d^cr`1O8>U3cyy2_V!I0zM(xDVmyvvUMtdiGF9WB|Pz- z)=RmjtDLjxcJRcqrL>ZipHUvd@9EF+K%9^j{74mAKacX^4j^w-wP!J`4g=oL*g3Jt zET4Msw!`#THbmC#f5d>yG8Uff71nQQBAaNjxFU^o436$(_SX!ptH{gK-PPj|VtTV! zup(9Ti%d1$s1v|ye=JLprAiq71l2!4{wZg{;eK0E35B-pVQV3sIu;gG4r62{Hqv~M z{3g2Z^3cX9UDNwK8$yC-4!I4M?*^2+^GG@5<9SGCbMY}sWH}9bV z;x7#Spw+>_!Q9_|+U1|5MhV`cSAu|Ue*Sd`L2&n{+xLJPsM)9!VzBNLlu$Or7QT9k z0qlzLnqCsiq2;*d{mig|+gnQ3@g%H61+8c#j@`JE0?lzxHao_rTcHK z2X7cCs+yD^olPPIXGWcx2+ai~lBeDf!nT_51A~K%UXRN^4kK$pTzB%m2(A2cwL0_< z*gQ-XXp!Pxi{-i-Un0rZx=yh%^YrX;5&P=)3xG^WW1^W-M=L1x*Z-)CMU5+X^!EF*u z1BftsWj!JI)ZWv+DHo{ZPHiA|YD$m!Al0OQQj6}<5vP&6Y5&%vh~;PQ9qwPIF={wQ zXh$+&;rv+9fFl&$E$n%mlt5Rlg-2WsF4L*J+MSz=T9FL<3-2nOBSrCNAk}^Dv?B&M zQh>_gxqhgX{priUmZ95`#l4_k#(R2v=?(OC?vw<<7+~JzjOeaF#Q2;D@jzb}A_D86 z^(P}=Lr@yBgz4>W2DD@7sQNTxlAs9|yA`0k01-Q^OpBc&y5o66QSTyvmL=j0E7nyz z(`^2*h4x|ag)OH9Z(WVd9D9ZOvtW10oMAojY#`O~Fw!8l<-og{2-API^#eGgYu#*~ zW1`4CDr_$^8GxSH`<=Cu}+CQC(k8N_K7GHTEfoI6FT&X4VUKa}8 zCu8iF^kZ1cqsYzjxhQJ=1q4tXfr~;>6{|=9Bms18%yGNvBbyZ|x?9Od+ZmiPmbK*` z7lRKXj~G2bP1)$}J1A-R5$q%Ono_NT2q3NGSDD7;g*za{LBm2bvd#uUpM- zUS6NOv(b=hJ+xc7+ULk%RJcFYd=X?YK*KzJV1N?4qJ-v0G57{ER0)IV- zkmU*tJMvV?qgpiSRKq?velc^S0}IHlI`b29WusiwK)a9UnIRGM|~;r)Y_}D zM_3@1`7KDqQJ?nN)fg9C+5 znO5+kWoot7NbC>rvJpD!+M$hp&hmm8f*Eda1Yq+Eqpw5Z+ie4WVKg5q?e#cW&S09q zKyD#N0u+P~6O1Bk-G@*>`ydjEhVn_cu9>2;X-RoSa+h9L@LxRUGX=*SXEGp;HY?hiGT!h+H`jJPGGr9B9B$L}v2 zmMvb4(WA5iLYJGG?4zPz3BZ2uB7oEeNAZ^$aQImWgnWczcCiZ)U?I{vYvPf9gzVT( z6b|VE-XGf3h--Ip2SJUFLW>V(y70H~9KYcF=05OSjI@4|*JgsI+OBd;zH;m*r-tHv z!lpXr@=HZj$K#v6XB-3AAOF0Y*EZ<>SY3Vlnqyz~HgPnPM_N%qpp3moFp&gS;eg8r zW=Qr)m8cjc=3Adcs_ zi#pv5J4MryZmgri8LPg#;?>tBUP*YbE?UM|xZn8X2D@}OL%L7wV@-K5{&h5*^Jfsq)TPgcjWR8eb4J-M)xx_A`JwH=2x*eHRzGcc_m;PZn`%@R| zJ;J7JX_~Si*?iD27>RWx^kYLg`YnV8pw!6y=VuShM*K8$Nwj2*3WqE-9bH`J4R``| zDPQdj!7#pI?Gq*D^>2Z$ZZGuxf_%T04k9T%fEM#EeVqP-YZ4>JgAt`8k>pCNv4v3X zz%->r9e0{Ip&=8V;|?lqJ*HB`o1D@3m_m2ZOKks)EDrP0P-u zd~HMDA=bk`e?Dh&r>U^-FXpE6)4#RQQhtd*ZdNgb2#QOM2*;SH2-P{bxKvZ5uw0qW zb-0eBq9ECdd3~4&!Mb34jK(dcJ?*vBR&_OPx&N8fM8VsXo@-xcm)Up* z9T427K+`FO>Tp+Yq*R_wqa@+? zV|kK#%`X0O`s{2yxANjN@N$H&n96YmZ;D?dQ}wLQSFx1SaJ{WgkT$cP=SI`kkC>-hQGXyG<}igtpp18b3R zn>6>>d#{x+FRFUkBTsJX@&k#`dHKdzY;Jx#dC-OsO9-XpgT{bz-d5N1YZ=4TP2>>{ zZ3LHDJUAFHE_?62cqRJ7d#dT>!Ul1+Xt_a4ICmjG46Hv$9@g>0IaslxSI9PH%o|_v zH-~J)Q@V3k~esQX^O zT;LfJ7DjBEE$YQXv_jlOrlgY`^AkSj+Zx_ zJ|U)gPbDlh{yvfeq+_I{C{|V@db$eGV;Bo`1+m*Jku2i6rhDxsHkJ%or(qmGc$}D1 zRe3BB)^RibzUEq>0m;Ce2nkfYoW%FDqq7_~t7~K&7zm&!g0UMoOrw8E(~*$Y+=D>? zv^$Ws2MY3Y6-W*U)*TVg}STu20HP^ zw+{_bL)jg<4hqAI7cchLXD+~)6s%iRm?dY4mxW)1zqt%xUCFZ;d8sZvoCwgPc=pQJ z6C#rM98RzGb-*lbg?Vpp##)!>o~XYS@g=>0i39tRUUpyUZ}a*leBks8Q<+h!id zbA*^paI!wKjN(6hwoVFD2q$o;C5JOoV8d|Lm9^`vPa!v*~T}Gta>HYCy`BCE-k$^+B2e= z*4g*SM%1z5y&K8rKA|-~N-W)iWTwu0NW9}aj;Q@rKgS_jynSw*Ia@>LE>IO3-X%L73a;TLH(T^m0 z(?T%?Rle2K7isNz_7wuzhuY1X*z!?x0#8cK-rCiMnb=DSRM@_}TYhC%@|-~JbAhj1 zB$)*u#7R5iv08l|IGERWR~|Nc9qEe z3pNuvMk3M`a|0Mcezdwh@94;6!w0R>_zf8Mckm@!i*W}4AkvnIast0l^(|dj9<%r^ z3lTz$u|A~_)%QUQqvol2t6DIEyA14d9C-eklTv;TITJ6_qP!@q*f!!#Q`BH&;BrUj z2)DaJB!21F%0j%{nVi46auo3V zAE+3W1jb3((P7u)@vV{*oZOp6RYMwQfRi4&X5GBiWHi+A6Mi)x}V}%-b7$TpVm; z0qk;%M5KwqTDn%sHZmo>etw9oSLWub_?HoGmp1H{=6YAG!Fs^?K0`mIQc^vpZn*hG33EEd zSJn{5IlOhji)Y~t)^66BFew+G>+y+$N^;0T9;-+M*WdBKeyKsTG3qzU?UH3u%)U{= zMN9gh>Zn69e2GXcECA(=2}lh7dy%WKSd{)UOP)!y_sy>Z(B2xV9`}k)eOZEGji#8E zZqX3-&u=@CxClv;5N8%+K~Fj+T&_}JLaVOvrJ$J3y@+d->i*DJHU1+GGY6++G;WDaM&|G zPyI?Z;v&Ep5%_~+V9Z9u(aUQ^ytLKK2L{PZHVZf@YZ)PwyD(=JA|?qnEUB zT7e-2E&FHT$VedBsi*Z(8Mf!eq_cJ1BsLAeb+(q>qtO- zYDir@?f3nkArY(}z}^eN5%BoCC2n!sf;rk+OIiqg3~%pU05FBJ$6~^AI{k2ME=%YL>gU|^6D>>%wM^RoZc%9rx9G%bWtSFPWo1`6?fLOXXApo2I{b1j*Le`@Ob(a;A1mzawE&`y2az zg;4HzOUJR%W}aF7qPm!nx%9N;R#zy5k4?$n5dEZ$E~XM{Sz~Z61h`_ zk{_g6g(}A_$iGsQN_<3p0R2=JeS|?F)yX+ON_+@Y9!+CeJL&W(T!G%Y8p>%_ZPwJ#Kq;6sqH#pE_0yftncCH(HvHaogYEBE z<6^v!Y(|Kf(c7>6W>PxA^2{1Isni4JgL2~mZU>qtnQOdd75e?@*JV|7ZJSI8%Je9b z@dUIdiE7e;VY>j4GJBF|<28Pr*|96j5Ay^^c5iH7S||tMYLT{X1zNYUH1^=?@$^s^ z?tFKiMiEpK+%Ws7O0xuZ=?r&d=ZM{GZn~NxvUA4$ZG}TdI{(lT%Ko4kp!f~9M$O3Z zD;!XfT=K_VV$DU!Cz2JVk&T!BZ6UAi-ah3FZl$NaYu-^%TC0ZaKQ~BG;Q2 zV?-$z)IJ1AY~8P+HGe7{VNQgZ7L&&Q5%}w_*S~Q@(XOsQeq@|}_vn@kb}W8>H@7{I zTQ<0TKQR*fe}nyfLPFR(7ji$xCHdlV-CqcP*gxLtyStLCu!NYNY6vk`_J;Srg$r=ltgK0SqMA*Byfu^22L9Z;}v5SuK&!$1e5uTIWUSJzaq6hffl&Q$=N*_m7c^n zt7YqT+=9;FoQ5|`C7pI?u0QLSCmCu3BiY>*MTK9U(u&-%<8`Y?%->uo_g)Of+;sS6 zjP7y$;&X-AzoPk8<*j`ZNHQWq;r>Dpc5+pg4kq$?4v(2ewuJfB@i1pP%p8t!IHGs> zkM781D7+f6PlllbyY`s$DA}S}(YHLJt8@$H&rO$K8jr-Ds`TA;rJf!Pc&`8b3y)lG zS1EJEY`l+l%7VCQz1IZ+?<|`Hk(WFW`g3A;JvcoXh7kPHc#b9Q4xue>K&)pms6e+I zFQ~3W{w4r*sx+E?JfxeKIIc>~QK>t#(zIq0&+0n0aH_6gVZeTQQ?-j;(H?DB1^ z$}5oXBN=1(L2b6gh_{=rW#O$YANU7NO0TE)-M4(L_wG5#pvfr-=DFlxUk3{~?k@#@ zqRX}Co4y?B^zD6VW`4iO(d_#rn4*g;-=q67yI&H!VEFXY3ge+W#qIFxzl&-H-qUV~ zl%1?J+!0z5!81@r@C9*72O|IdES-=>m9G--OiehbJRe@uuig3BXQ0ry(o`1gWG1PJ z*V_5E-Paff{0+Gw|SGY3bQPb4?<+gD{Ham&50#S0-vV_iCrSZxH9$ z)e@U!v;Ubg*Zy`)i0O1ZS1xAS0{4Km;GX*Ftq~Omf8dG7;}S!6P_L?K->Z#qP$*6f z+KAlvRS51e0NhGVn#SGvAR$R=F)v7E7TR4!S?GwQzB-sFPSiNQcyX?}B`$wkaDwNq z6eW9^218GRKU=(*>o)u=m>s9fi(|cQjeej8nsU8dff0w zxL>+>yJHwnAfi$$|4ViM$pm=x@w}>}zJ1CY0{^yu-`Ph9T-Xm|XJ({q=A5MHytcxj z9{t7_?v9F?fy+gmoZ~%z&C*Qq2|L+#he)jXZ+zz4|426bolnu=?{~dU7vn|BgHNme zs?|lSFVM?}#(YhecSm>*yWELQD^vC3sP*;L?oy5+Bn`w5CB=ef#BHzVRPj}&T@Uol zHxWe(H2WDZyb;@W>AQTC=hr)}O6Rx#Xk10oih84FuWfdRqaiFo<^d`V3r#a@vg4BT zyQY-Xq9~U@RL{Pp-vU{GU*%AMUGyf4Zo02%H(s9d+@g2f_dvOL4Jhk}zqkQ4eW@-_%*jy$GexyE;jq<=o$=yX{)zO^g zmESCD!JMK@euK9Ox`afkkJb3m!*%chPN!N0~Zk5aS4B7urt`)gc+38MEG2= zy^z#-1I8xYcMbu<1{qKVK>zx&T2;|6?>72wjag?_1)2UOUW_#2nNGw*e5$ckK#(}@ ze34eCb;wc_q5j-rP4Y)9^JG>-+qtA5ms1hZ-_MQt zre0;`Kwjl?nK%S@$t=l0UuW;Oxh~f5a`8>}s!6J{-I%>+v>>0v47ENhCu<|`@P_P( zV5}WRCV(wSxJ~jER)7csp^845%7le2WnfhEK0 z%B5c|dM&IJ$3%Fe&wE$M{R9+6JGR%r5BdST-Zf?V>O|OQ$S;3lB~&nW%{IBGzrM}o zK@CzCul%ur)^85LT$Iar|H!fa!~z4OFbT(OpYA8cj(D{PpdVDweeYPT+T$tZlo zx;DH8kG}F4V?exgIACaR?p=3x-DeQ!&j=eIt9c7HGu)9^OxMyrp@AjmQ#FJ(%M+XcnBlo#5W7otV@hzfiaf@r?nJ zk7kq&GZ5=|xf#*ej#+QKZl^Y`?|i;)c}ws=7;c08cr+ewX9PB*{*OAki~z03YWbp` z?Z{eUMiX9_IZelH=QsWToyD%rVrpCCfGwW{KfPH#9zUYRN`l6glj&2oAD%vWcvC7@ zp!S)aX)S@&UWQi)ud~v9<~0AQ@}!k+9p<2mA(+%A*(ZMcKWTkI@bc#G>aqR3CVdGr z?Iw*4VhDQL)V3!L>td-;j)GGgtp8h7|33;V63awkPQ_}J_gxvsXCH-o!(|YTHSY9- zp;B*Z>#630Ui$!x<-H>S8-1V;KH4qrWS8SBQF#(Z6x{}K2AL^%dSQad)Ry|c@j#nw zHkgzinNW_nWS5!b>mX-?|0&wFSH+tR$nbu1HoQG;ybWX8Tl8;>N8WVIXCOO%iqh8e z6m;5JZ^r-LhQlACnD~BQiOot9`}rE$@R88`A1L{ngW=b$kRVm#yOL1wuwdX<^DDk# z=A7q1oN!Tfy5=&pKfBfde zK#NP84fpg;NK+-ID=2jTMsIm2jh>r-zPNFdLzAH+h7O^e-R{rCbhVa4sTprpU?WVc zCot4A+KZvnc^EI`(V=y6fGoTyW{kRlk@f{mz6@F%c@Fr!`^%ADj6i+?Kon}NJp(H)~YxLTNkVmURwjR`x>x*pqZowTRIZ%9DwVi%D+xBb-a-uP@?ZD^(}01OS)!9+Y~jzhBjRFCb{zP#^V5-t@JOm) z5=Ww+4npSFcema^R_a_xh@h;`OD8pnM11$oY$Thsd!WQR?x!J}0z*efM~ER}#lbae ziewx6x7Vn7a!=i!*Yn930P`JI+7FYSe3zvym}?qY9ERg|{8hPraOX!-4b8`iT^42f zJQlAEQ%BbJyt=~WK1`SUbHysl#SK~l+UN03x++PWDqAa~NPvRC?k}A(hKBV5vv(!x z^%c}3=D=2ZDR!Y?s4O}PzSw)d@5Sqs5BKfCM=!J2_&?XKSfudp&*ehWfJ`HP;RA{Z-+2@)RDNys}PeeIx11uON%9>!Io^orft7 zp+2LDrhL^~K_%|5#Q8vP@y{1=zA$^saSigiGWW^I$ZEY`bCPX&K`I$K>kRZ}W~ z7ULLplOvd|4QS5H>2E@Iq{`QXf>p8b$VVV!k$)%h36dWs=2UGPxcyxog4&v=_Nd;? z1gO*E&WSjeOBjEY{(JcRtXS{af)o%WFf*s3?%>Tx;MOn^1+-i{!Mg;8G9^nHpc7sC zrv3pOcv+E*tt&Tah*>(pt!5LppvK0%LRys}<}0Jbv*9s7rvK8VVHFbZ(rE`fA3hY- zxY@bA3zH5DepRQ@$79ogbcLQe}mPQtknO}+dI z%wSdKhe=zW!Z;=AOW-5U3f5cHeA_$6y5Y)sNkFYxGEk8TEDK-WDoG%#Ua(L+%~?ri zOw1Wi@XBOVcP4-B<;xo_n%>7oX%(M)#*1Y!rU|wamBr}qUCDv(Me^W^Oh$rNB=7M( zYJsCc7-oIg9-iZ#QC$5ield2*=C%z}JtEbVeAwn?)y#ODY6kU&`HbT4jt^vF__O5X zFV)tso1cs~AMoH;8^kb6zZ$uBtgi66d8W! ze;!Y@PW5(>YX^}PoTNtyBsNAa*UVZ5LlZlfaXmCz%ZVK{OyMHvw zm{@@y7*1>i4W*Sx(nPoEV57x`Lqq?%QWCt{G4Q`+Y-X$o5$9(}!afkWrupKE&G0BEDgYE{t zH02{5ZZ_ppaM;5yC|!zz33b}SKDtcXw&xK*S{16rX>&rI(qAfgpp@-;&N{pppUWEZ z2+Rt~5`wqeDtO%0_KOk%_?sUU-1Z%+d}Nsc7x-w+%{gWn^&_U;1B69-5G(#OBgDWe zZRfLH0!!`&v=&T{aMl|APAJQEMHk#us0Cy?_f+?zBs^^X)DhpYQF-z}4%d@*)M_im z|6LTjCPR(w0mV~3UruQVs&Y3KwOzs8k4g8w$flZ*wOme!0c|?Cg?Z>We{~AD5A)OJ z%Z_Plh)%LMo&S4STS@<5BlHD16Ms}uwMhFjWCd9W{D2S(ZPEB{ccnSo{mpK^#~*H` z_idc)O@5x3mn6W9bYce#ulQ2tN#tvtfb2C|0_-z2_g?PZ z9=0f0jqORk&ZbVp!U0UqH|Bo)E57USEsQ-n19g9l2K~=4j_nK*9ny}@-4BIBzYieN zR?einZq7zzLL;$k|JvG|gIK_01CU3~^B|B=I+L+v__Nll56IF=Gf4=wfE_6h1a9*B zbJq}Qi0x{#24_nJ4_rrFu2Aa+(6K9tX)E;TykZQ?-|n&yL>ielQ)Rmur^E`s;Mhcc zvq(GJq96K%(5DQrS*q{daytIdme72VDfJjldXz5*c`*=HK}>^hwtJJ;nw3)ko2tX#qxP?glR}u*4WM^+kc8` z24nh-jWaJdHv|H3Hm-LykY9ngsD~G>mOqaXCy^y73bVnvfmEGP17qI!99h1UC%OPq zZJ{#(f3*Q#)bb=P^cSB%>%U9U0luugy}gP&@FOvPPf6?X!1*Uen)4q@t?1ixF}uV; zO;q~y`VQ89eoE9`e zZuPh~f0_NB8ODv#^f-UV;n>yeIR(xv&Bu;>zZp~h_sEd)^Z3ijDgl8BybI)> z#r_Np!5GFf>CoBu0PP;tZ>joZtU>;S7_-66e>!;O-ZZWUuLeM-J6eFSspLj(YlQ5fx`ypZODKUX!Epr!p!l-B#r zuWj}8w(QRJGDC-_F2kSj1kA^u!c?8B?p}2vdnyn!pygyWYOCI7(|Q-!&ms@))A{HZ zZa+@uo84d_K;n|Fa|fyFCcBeBnC&ini-2$hirW8jv$;?ei#L=4Ywl(zRLG3D@1ReQ zSiTD12FK?Ftnc%m69bc4#(BySSP0Wx(bTK+^K39;4iXzq8}sgySYgZ~WgqBxf8oL< z$#59;P2?hfRz3JwUmtx3Tr<%le}oFVgbZsnWQ$iGLjX0xhN>=eC4|&MVE^0`Ne8Jc zqw4z?%l@|axTrDsJZiG!M@=Fd zKSU@G^?M)PmRDfN?u&5JU_h*{k@eAU-32j{_Qy4j;4A-EXYC7;Te9Ta;y_d1sEDCM zc<&UNb}f}zgBGe|0lkv>M3;0E`l_`Il z+_yewR+t+Cb$I@TEQv6X&Y$FUl1U+nrr}PvjZ|5Vy74{mI|6*6>HaC%g zZ7q|Ql$1C)In8O3RH|yI3e%B5C0%C3`&i&>)x+q~962F+v?mAxQb11`sgJlw<$rDg z&=}(jnR@xLWPBH{k^Eb(*ae)9>S$Xtwbv5JAox6^zpHfwA$S2}_yvPuiLc_?B@IdK63IBz-qH@2kXg z)wf)uh~pHY9x@*v=k3@QXCd{Pbn?$<9v-{f;Gp7{a3pHFcFFm#)hd?_dyn*29aBnm zijzz0Nh2~Z${w1|DE!#qPHkC8#Jso>1 zD>pX}BtgHO6Ve_glcj?U16%d-WH64^+D~El=@35p_@G0mZ3ybBx2d>`)L>}bmJNaaJACI9WgW0nkjhw3T*uVze2eY zFIXWu>=Qb0y5}o6pFzSZ*kI150bd4qog0kHtC?kctfII@qPujevbDG%g@v%IaE0@U ztX#s^=XM|lzx?reo1MT1n0x7Y5Ul~-_cR>aRZ@a+>H)0z!zoI4Qk9E&GuZ!heBhn1 zfa$GX6Lz#G51YU%r$&rV2Z}@q)n_SmK+@XM#H%m2#)bgG|2@=%D^ zHkj=OHU!Ty%jkb-MVn}_ku$Mdq*vk;u1M1PF?3a& z?X|LnSC|+X<;#ihcxpawYXwb4?|Kjrap`+dyAJCz@JF*Byv?9-aN8 z-Cezsiy=Yqe2L0BSrki-3>2l7#(@=YVb&cU9)xvp}G0O96 zA;{Re$Eh{{u-++kE5Uk_|2I#%sx)yYYp^PATxspKPVI4({ip@YvJkfdt77sOY#RgU z*##MI_Wv+Tu_9_9Jixv3#*8<>Px|gqsNRPs*-May3P&fR=nI{#Z29H2Urk&4;och^ zvx;??DdvsbJ%KDJS2j_bDf|#-x;Z(G^;+tgEy-s2*^iC@hLG zM$9wtbW6}{k`x7x=@rgvKIs1>n_dae4$khmx$8cv)zPongBDf4C|Fe+?oe%A7l8S{ zLcSp<)%w4o8xVfuQBd?ugG-Wu)bZ6TKJRbxKZuq;dLRjWf0wZ@7>`gBlb?{lzzV8x zP5-Sc;8Oy9>gryP%Y$JQ#MXkyTsfxVnNxi!dKk7Y$)))NG-#``ciE;H&Lv!}!eE#5 zjEEp#a*xVg52?D68+ZaYRknpea|Uk>%tw*y)9x{x?0(~KYt)G-r^jE*qZ>oc5le1u z)kuD421Q(tB)Z`#bD!5~n>q6VPj9>zBHs6+3IFl+Q zWkO=x9mK#0LF4l6eDgx{;-{L6^@O0-$~BoNW^3UfH2ZN2y9NRFa$>=5yF6zgfY&3Y z!@P8aa$Z9xmZyxDTrp$s-@i*RKM?*gk@N2jcH3D(0l4T66cIsMA(ObuCJ0O(?DdUm zJZksaQevhd1QzC4My96rKcB_qy`MdVtnBug{!C6OJif=w`M||7Ko^FoydxO17kSC> zm&~tj$U$Iaj z@=vU-tQ1#WnXDQ0hA4k3ZJXMO3S$}z7=!Bb(7+Y%C+%_dd{cI{;aiC8{pfHFp%Sq? zK!DA3n0$W4YbI;Rf#gYrYO)2xP2+QG&y9e7JjSERa~45%XCZH!V0vtXB{=NsU%JjN zZ{@;}k%>JHLlxGr6KdUAh8Xmvr8Ym=E7IP3VZI_Kh6Kw>Bu=YTf6|t0k>j0W+?qX) zBww()T|L(-`}J-dN}VK&U6i$1UmT@mor0 z`@Z{|k7|B+xpx@w*nsQ-D$kUrtso?S|GEKT(Q)ucGu!`J#o#m4Hb-{0PIhxpIOyU? z-$yROu;%<>6OGT!WiqI1D8JO_-$@H=1)|Nm`rn3PmU^K$OV#PC-CxHIZOp%jjRn7KdhZl0Qp<+t#?JD%I6q{;l-}Tz7Y8~ZOtwn?Mb{TEqPpkFNrMy% z#-3b$?(HqDy}?NN!a(-|0>1i(4-9`pO*&`pm&_mho> zc^h_JY>0M6hi(~-LYAER__7#t+7GDEG_Su5Q*mBI_cZ%Ha}f|wHqMh-!njnuGcyaj zXneqHUppbX`WDT*k)FS=nyvNyb=yo?Zm52(0N>xkOYC(wy;P39>6eI1D4Uk+=2r#v z6p>TC0uj42?2Y5Wc9{qoZ}p{<hK5;565;# zC>H|dg`g9kNeWOxv4)zfl5hP4#=rc1)E@+6Oq_BE; zSnml2>avE08>s0j>seSw#pJz@)8Zm~Tg_EnO${;}j3@;Tk5$7Q#Fkluoj#_7F-&-MOrQImMT~IxZWC-t^<8=`k zdY0MZs$5<4*g%d(XgX2}1v^INKlDxG48~W78pSjKg#a;F@UN8Xt9+T$;6&MqGDd_Y zg)3AmNy7f^F~*6&eDWIGtKg)C-y@9;X{OVS6S;7UCM+afOxMjb?c*!P>qH`{pZj)% zWh>~=%ci=Q%ed8Nv+bWR>f@t(7QzZZ)B_E*qtN?1B0-+HY33mOtvqXR=N$YfvB#vX zI2oj^c`wG%>fTNC<&SwXf0lWOi|?B_iS?^r?n~fm_e(dya!qxhT1OQ(gw}4iN*fr4^6}cQDa)12P*q;d(Q%jT?Y>1)ay5BQVbI*NWts;SL z{%)f(SR~H!tey>vQ3n(d&fNk z+pOX1L_F|+m#d!sb+d{k0Ux?A=r*H5cA+K@fUg%K*R88BO@BR#SD47T*-uFt1o`+D z%$>8&l2%A%9eOA57R^Irgkz+-%_!q7spY83_jua6!VcLHgKt0HpivmPy=GXRsFqt^ zQ{(!`K~Zi@N8$O)4;o5@Z}fRw+tXc49A=YL*aP3-l>~RdRlc+15>Icp(dI&2>|H4P z{d>yjvl}s*{ZGFhy0b5~h+wTkO+Gg=Z7&Zg#LRBgEq#0+s{gQH{eZ;YI&q~9x{ITl!WIkJTQDjlIsYe^E+uK)01%(H5e z$8TfT*8+&@ngf?;b{3yi8^WD_XpP^-(CN4n!cM1?N&l!>wQInTNcr?u(c@~ zMvXg?wnY++GeV=A^Me1vi%O#yM|pu_iO6{TIgD@`F%m_F?GLAJ~>1RO~J; z;(WKE3j4r{D=dxQfFNvxQ;3>PtoK_5iyOyvX;gx)8;80I{gBk>bMP$3-#V+(*UMu)8c+aLSD;JaAizKUx zTdAIl(hBuH&s=JyWoRUDOFUCyK_6>WaHMBg4tw%+P2#`4Rx3$H+P;6))xy}hjlkg9 zhNS2WuY1DI8Wt(Nq23~6ym=ZN`Lahe7_iyMy~VpVp(e?w2&&{WWWg18&+xfADl8)4 zFI#!{2`;(Jl0FYR=m0Fi?v1cNL)5d${nxhTHPRrhl!%ewEYTsGB+r50Bq122prvE8 z0{-DZUh~ACidbPE8Kqf;72>Yg{%5s!!tEo$_f@Jgg!z3!pW)U<_7lP)@GI`o#xpLo*4c)WbhWlDa zwDR)0lw`?zN{C}x;jyTyvb1jJ9$J^d4cYfvGb^_y;L3~D%9>nvLJVWX!5%ljmpQ!w zv`Fcq|GY4A>+AGbIc600NU(`AO&U$vi26lEm9Vc}{2DqPLy0J1l*^ zS^OMUDK?s^?T<%BM&|9$W2ZLeqAnD|7qX!?EH4lu;dG~G?Frw9Cd-CNUXUa23-nTX zcrjMFFegrDv$J#I7*SvPExhb3fw^49({Jb_LZkE9aZ`ehL7?VC?Vr(4(9|Dv5v(zi@D*N}fG`Xu5JE7c`51!xw$onPNQ!%u&bEeo^w71sv2 zEV1zGiw8R9NtBs@dZuB)719`smfRWzHIt#XCJAB39gL=;3?skNl-7KCYPB%hE$TOZ zamkOs1SOKeyKxH8sTGCMS+@9xnxCXNUOBO2+)1-MGR-<0c@osKB6@4{wLVCnX zvuAOS^gbE zQgnWX@#}WHxbh)33VUO0x!9lg3!w^or`1#KZsy=l15+MKlS{LXoiaCjoD4pT@4NR@ zda`Y3iPj?V&L3rHiyiBoempzzobuH7m?*BO6g($Pj1tNSyAHRhn9J9>)>dDt@Be`B zIM`(S&+YjcIQKjjoZ#o5@u;y$dBfcIRmq*i)#?e0rGJi&M%rp}NriHH0|&y8j;3+I?RVwf-LBftHy1(=Fo~0&CYfq-Mi&^mtPENW+nN(4% z%R%#-;UifC8Y%2PzTx@a7URgpD*gGzfj^zbtG4;5B7`a&W@eo!A1_hE|!ZPjL6 zOa+u+@G+S*lSuR5{I$gP&FXEZ8f!dG6lgFIuis~Vi@w8*zs_8sbr+)+jPH*F;-TCJ zau{=hkT|;`1}>W8zFn*<$(`>N*Q0_t$9w(EB+RhRs|wTmZf$r)_s|T`tPr?TsAE1o z_{*enpUUIqk`MDu_a~E>aYaby34l2y)r8NCgP7oS!3Afhx!pcT93DHej5E<@f)Ypu zYVoWUXz4z!7+h2`3wd=Ra-4`hlPA}?`Ku4EL#nuZMre)9^2jZf!0Sg6(GwDny$s|x zP;EU+FJ&S*!_0J*^BN@n0EAHOt~B#BE+Abpb7b5u~n7+KuQQ+y1DY+o`dA_``N# zVL|jqJG(PKD+B2xCns$}F#iU^;x`+Sm+d(n_XBA|UIQ`gnI{W>#K*w$#Ir3(8CJbLPQR%6L;TtWA zty;J{Tii72c<=a3_)qU#VP+2T@_Bk`)baV?ife}=1p=PvV?@Qrk0Ed0UcU0z^Kda& zJBI)0=twRj+IfBolwnZdmH5^CqPw!f`oCHT@@nZ%sA~)eFS_N);gu+@L(OtvYh|UV z+~f^;`SZkVPrsfvdY*p9Hc7aV0-!d{H33 zU}vg3uI$jH&-3T25n)g}yfqclAq+^~6uN;|i6)~whMiN3>BXf>jqA73%VOQ>clKMY zYz9IoZ+bm>D4)%*yJe%D>1U5ZsGR9ZeTJOcbV^M0t*)L5~RFpvG{C^(W}z1Xb)fcT2fC(_iGL* z9jC3`hWBf`VeTQj^mMqXTiJ zOI&^La*4~(sUCiN9x+L_*5`vFb$Cd@32H+rMP`J++oXiwR0x*)a~pMGN<-GO@~plQ z(uYq9PJo!l@;hYn0v&-U`QfM2@LcX5D`DL(-@FfRqROSNj%E(7=eL|MJ&{Pg2dD1T z?(VLUg5@m;F*Et($;H@RtVgVqx!6<8r1bv|ysm`=*Fhm4-aM&}bt3{Bt{&Y!x~-++vG zp8C&CjbwBf9SVXmON0U4#_TMnh%FGm^wkFqhl7XFKj9se2oYRO?KM%YMd!2K9>D%aShnXS_UJBBpHicW_q9D59oLpC$} zhJ^u5nxs4KbSU2V#Dr5+(Ht;V*gjgHQ8mN^laBDY_mIGR#!FocDf{^MbjEPWvjw`! z3|ep(-EqHt0>lKDfw%sy7v1dVKMIl+~VuEzh#=m~hqxWJw|t6{E>ll$S*XQmnjA-*>< zlC#RBnN+Djm5guRkX+viAVMHRd{AiwRrqu}SEn8havlp;%?B7nzQeh^dzs{4Z#|jQ zEAJN8ju$G=_0NQC*%M~krB!I(Kh}#(RJhPG|F~zz*+=Ig8sTu!_i6csJHJ+zyQ`=J zAAFVce`<7(QhvGCh1q=k5Ha^7D2M)s4)qj=@J2x}7Ovs}TY_~Oik=LV2--}B94jfZ z^{TYlcYa)jXKrkJE5T}P?wU-ajDMR8Xc4RbUh=kV*U4md-1gCw=k8K(F~-7&ikA5O z>sOjeU7EBPH&+FeL9lyZg=!t-D|HZrOFgZ)(%4=MvB0r2|q zMk%=+wtt>;jQ=W>s`lvR%a@jz#v$t&a80;v{dqfT36|FLRbeJ3878F-$M17D1cv3O z8|#(|=)qBbBW)P<<_OZavorbFC(cmOVl-hN^m)DlT~&=Vt)(1KL?MY-d|jCRCVq%; z@|Y>M`QcDVQv!Z#qvY0OXdVwjg~MRSZ_qIA&)@eW@fl4EkYkCji1>XeEI_~|8CCub z`961x^}i06Pquv$v zHVK6e+7o1o`~R-%`mPH|G0yT07<%v!YM=hXi}>``L)fs_BYDY=^#uUol4Oub zq@Te)jdUxRG>iPzb(F-oqzZas#&z`dsr~O#h0d-FWT$`pL+(a5zq7*wtUE zd26ic_m8q2CTf3LCWbTjU|j37P_GTSLmIq)lV#L=Tu@nA+1|q=1ilM8SgXwH?_YlG zcE@#=MZLjiu#6ZiP|^rz(OaN^{FItnlkx+w!isD2Mb==2fE|1$7w81uSoZS$uzA-CtIHv@Zp82e4tF2G2;MSxhr)kX&)g zj6gWpqOkV1RG01UCpoWy#}%VCQ%?lD2^ykXG>tlf`o(Gb@=4RmOJ$D+;Mb{t|1*t-7gz+KR5<2EObt z^&vtrrT|x$GAvXZHmTrz)Fv_FRhe{n-6k3tXWp@%Krxc-p{=hF#<&%l=%!&DeagGI zgW`~9{eN13CWs$JVeeGg!lnIe@}*KMH+Le#;fWa0Vo7*uvX+U&!qLv}b9J)m3u8ii zNr%+wR~SY1l8-`M@v=@nO61&7SH*bNqQIK~!nBcz2^l0A6i8Y47}K6aNd1n!qoSJ^ z=kPg>%fZR%t#bAoH?c5);N^|Ib=3*2lJE+7^|1FJ;rPN1nPFDC@cG&1z+LU^RLp0Y zhqJS35fkufLnu}3ic1YACSX-He_C`fM6T7Ux9+pSmTDo~z(m@i7A_7V*slo>{RwB> z3v%bY^19(LrYI<1{%j`MFw?Rx{d2S4mbukpVws4|b)3#?4R;RgP?YBeqpMJ**=A;^7w|l67`uJUSX} zHdpFij16%od+8m2?-%;YRulXmQv43wIJAZ73wG+=*3)OG=vM=CzCHLG=Et9`RYtU9 z%!H0aj`FrB;Qjqq=}y1=uc(a7jo9r2FpccfD^8gWJotB&`lIkz{&ikFHFt*2fH8E1 zqsz4(WwNIi{c-4!@`lY#4{s$h&q$jLZj_QuRR77u7MALIpznw++{EM_B6Sy~cyq34 z41&Ri-nIFq3B9RXo{JyLoub@wlb+*aMhQ3C%5Gl}+8;d*b|pdHU6HzPb)85IC>ixR zV3m1$(}Z|-&i?J?hR^QrQ$P@MqFrfi=VpDnIzxWjPt4-T5FXUlb ze!9W^`}g6FzTE-7hA&!)bOmZSN~S!NO32XMkVR237pezI6$Ue`6N47F@!j>dfR%tk z?)aTOw`*}%XQ#WO4+e;-`W?1@s1E#vHIMuo3;hY&K00W zf%hz|`+MyMxJL@Ru?tBo`CvI!K-rF0TRv`CviPGUD?`pUc4nOu#IT?6;kYPCT6hxn4y&5t>o#w` z=r;{q50z{-+n~^zj$@;t;ZO&e&CKbak$C`PizabiD z+ZVcvHGB_zO=pW5<^jeSmwZlWkM(KhYfvb)ll%fSq3Q8B8}R1=2F$2xdJE7ULr`0+ z&W}t_Qwyj-H+yj*;d{@2Wnn?4{dVDvOg0BqqyDSvE$^BQ!H36a2qtSxswz!aE7(;5 z_hsjfbIl7#h#oCEd@}IsuX~zC>)1SRbccbhtx|;~Es?BUqYdim<>&qlA22S98y=1pTiYF}F8#hlys7Z4rU-LuN+TfB7_+D|6J~zM-E=^<7ii5-GQdD}-PCuJd}(XVg5Ej&Om+3XUmw^2Woa@D0FO&d_)Cs}H_ z475ZU;7gVXr6S5l1PkTGLf!@<$jSkpyNSFc0$Lq-kXP@*8j(I&miuLN#c3gt^Qt=K z(+$*LbGW-<^;DFRCdi}Vzl1MUXGgNUtM57Hy*5{COoVCEp~>|~>goE{nj`nMKPjpA z7vC$-dAT{&SO(-vROYtut+q&M4`_t^;}^I)$eF+seQM5D@hqb4>bJiPPQF2TK6!U+oH?~lrpqvhc_P;+C@3KQs&U$qg>Pu{xOW?_bzIVpN)}lP)R>Aw~F>$UscMF??geB55abo4b1G=5`_3@Dr zguOtY$L>OK=h`tEu_q6NCh#n{d6pYJfj~b30s>WochZd1+F$ZNaskNmtTqe|H&_+j z8ejoE5MlsP!OyU;2{?b)JOH~uU|6Jok;J9{M@nK!dBboU0D`-qqdHcojlpyYbgq z){`Lg!L8m}f#8*=-l@*M`0N`IPT#+7a@IyMNB(}MGt~`*0n$eIen`lSb6fgr9KATv zTRFMfXF&m#X2`hWn!QG5?9pV`NpG8SRQ#wE%gV;z@Pgqb2R??v9#b+^v6b`t%B^0{ zrYBo|DQ|`8SE8uy>a7ApU)HV6q;7{LWkc57xyy*lGOiep+)3{-=ALqB29yEa#R|@a zHOyfu!ZdZrD5s{Zw&2)wGrTQ8JxkIaaB$uP3e&AC^j-{kaez6rh108eiveH&W-w`s z^X+D0-gvgS&h#cGDHKj`sUcPG+%$}&?R8IeV7(;_9)e6 zrh1Yu=95)7Or|j3Jd3Q=CRI#)IadVn+6N1|4YzZ3%|C}rQEp&$*4On};O*c|e45!S z<1{dnNZr4pk9^vUMi)c^*4%o)oUeVQ)-JKp9Pxf0(kTC)D;ou3e?-ZY5S!EgWT5C^ z9Gi;xYWmfljE2^vS83~MxWc0sShgS1Y|~i^^NW+I&pu~8r^IC5@rr+hvWd#hI&tZb z@ArE2^0t&1pljrNBZ?EQQNpac)C`RqzVwUu7@FbmB(HZFIcET!{!57|UWQbo8L8rT zPqH4ZR(TDtgSEBwQ~F`_<^%FocmcNRPnFf*!&AizkcP-awU)f$HI5k8p#U3L_8u__ z2pl{G$f5c|2jfZG;$jv_3$iPR_7)+ou&Agsi1pKXsi~=>ii!u*%A{4S{O%cj?X!^c zkU$wxRnCi-vcu{*QuO^@@?|bMmJ)%KjSXd14mE&LvJ-qIt-;s2E>yLdrD*NR*Q+JPlOQ z)=IP@{mZD^`^-b9EKc$g_8S@9({kGpX9mxWKL@*@ZnUwc95#RFsr~J= z$zPnrMKdgl&(}oyDU*qg_&(^e3VXjS4T;Oz-eqOR&=ETE5tSLEbWu^Deu@ zyN~-#h#rOvXZA2pLlR}hR@?nfmSDTf|Di{Zu(y6A9st5m#FCJGb z*qF(Q$$mhG3ZFM8&O(`akFFraJfPzLnY*fPAb<}%+aFMIw1LMBoeFD=Jm; ziU#7oud@Q|11OLs@i)WXjc3oLEhvjMr!k*hjKbh^_$+_W-qDe%En}PrpAd*#VE2*H zs1<4pA*s0}nVaKG=kkA0WgCY7LWzZ3jdZ) zX^D|H-*mRaiha?Jv;BCsS~ezE=Uu%+o+{kJn_B|1kBQ)* zbg${kD_umWryQ2ODb0=q#xuQU-FHX{NpO$dJSQw;rm@E<+PWn^ln@M&R$q$KR{_;p zxiU(qHU|3EZX(`$ zi^zZ6OX!82XQLP|Q*>Bn>`|#%vP>}oH{yZ{D@D^lw#ti^KX7?-AIyBw<(ywieI4uE z)6?T%Z|^II#2l~Kfh0gkAOIGp-2|1L+=G=DhN!A_hS?yZSlu7{hkcJ!-R0uL_ z4kRwAsR;!s*bU$M{NULa&u)_NWDJ;dIoo6wdMH$^VUIHAI&HHockL#r zXliHo{#ccpxKn+}`1=d!Wra~9UDB~TckWy*=K}m;h~Q&OWc$YJ4K7g!M-U}D0#}j3 zL-vw|l$(S9ALQh`@Dr1eM6x|Lb?hqTk~C0NOT|#1iqp);K@>?ev%l}Kp?xZ)*c4!L zub46PXctyAd^|wyV%d)htSE9ER@yw&sk1rBda6_qE_;P*e`j^=^Kf>5@~NQr2PNK@ zbe+L97n^#6GDk)FLf4cs$+D8)#-)#3%_82iWe&u}f2?5JaJ zdMRIo5Sj--V4&9TE#pVwqSz3eI0P~8kfA7&(F%@`0gyLAd_*FJxaXl_MKZ|PDl3H! zc)*uCx4r$O;%Ki&GDDpW1B4%34jvu^AWC;|m}PQZQZ2O_{G$2BvJ>AQo7!GL1ojxG zk(k3a@nb0KU(&xHVzEFj#@cYPgNqAGbSoslf(I}zPb>evJ3F%J*!`1-8%25_E3l~W z1^LSm0WhK%@p)ou>gVAhv~?5emcK&@-wJFt1J4kC8zLyR*qLJF@&7&a50b*|ECtK3 zd4-%oiL?^I^0yF8#ik_NfyRdjRKit@(wyz<76BJ*~x z%6&W^V%_J0q{z*>pg2gw^Sgf-44v7<5OxXOon?dSm8)G3=r|l|rz&++3&KAvS+cQx zC%Rm64_C8ZeKovvbLK`qLC|Ejf^CJs)4|QZlIvfbhDVX|b?wGv*=2-3ofvO= zBsxCNP_I)bE~^^<`4bmHi$)aD7dO<6+eacagrK1ag9P8sLm<8sG!*T$$wsn{w!f_! z`deP=Fe`G60`2Z3x=||7%hm^SHboY`m?&GGsN@@6cfj z)K({{s(wev>EKTGb5WeXSiB=whKbRH>dpLw1ilGXO6a2uUY1_EO^?g5r1*;s7DY!I z-+LAh(nr*vh3O1^8|3boci4WD{*n^!W6Pdll!w+m`#a?v#WUTf3_*44$e)yXNhV2# zO=8rqCeAtW92@QhhqnG(Q*rx2JgN79>`K*#?Pf8?##PdY7KtCMlqI@#CE@d55Z zUHlzBgATj<)CmEW5{qDrewL7w|d1jHbrn_`6VmY8?G4?yL`53{tQ`7JBQh40^gMVWnHObmnoE|GXFJW!mWINX!b zWT%Rj_9Wzw*k_SS*WhB`mN88=)#fZOW8tao&;3{M^~tS)OE`xlE&FHeah*|?pT+x^ z{8D2CJc+4pw?AfFc=JQQp&{t8huq17XkmUsHW{S|1NgyYxgS1;V{Q=4p{@01{;x6Xs+2xbq$TN%eS;>V{%vtK|msOBk}ECeNnVJUJV3 zh<8|%f;Do3FyI>Z{TuFn*1vV&;kP8?J037Ic^v_~pZ5D@lk#GtN8%9PT%T73otg8$jVe%Q2|y!(@_W|GVe+Gz!5*VcCfws zSAmwEzOx((y0C}{I&qYh>E;LAyunq))meb5VXYIJT()@hV?P;J*v(q1as>-6iBN7m z{+QIN&h#4+_dxw4kc>TbMTxcVhRKa4f+`QHV=od=YoOt+4xKM*KLE$Z2J!H_76=+R1IyI?KXi@`jHoFd%rn`#!NEJ4YR~)RUWMJ=ZB)L|GrjQ;89N3%ecoPaM(FIJ?U(*LFZ7Y&xy%Nq1f} zc+o#*9>2hMD#>?EpFZ`X?bQxbfD$i?{{HDRE=TK6&v<63n@ke$2!^|H%QoWug0wNo z^>9|FsHF-zY%hv?q#CZ6F$ei|NVJ@sr#0vco)sbW4&&RnUQ97b4IwZzF(kXlF$?HG z?${|sxr*fWzE2j6$7q>lV}(OxFK!@@B$Jkdb&LrNt@93I?z`9s8OuGm%ay&?!6K^f zeGo%Z3DYn-=Zvrk90ssi3Ot$tghn3cIVhr@Zii1dWo;gjmVip)%c4mnW1g60ANtA9 zm;s$E`8uq;yu4(o-N>7r_EG8xm~vJDc(!vxdio8=F9=X3B^D&%>RgMFLjszuu=1!0 z26%54g^<3}B((l2szygZY-0hhiX{}qKCo%>kxBo#&~^eKKrl1T4Jvd-H8($Ge1CA_ zalbJ}qYE_kq5OtPS+991dtyydNdqC4{;Soq+j;FD|0SFb{=jc6q*xI7v*wJS2dyOV z-#|&x($coOaB_0$YGal)ZRI6S)(x@-pK~8Se?*X_oN&nW`y#p9DTkEPx*ZMe^1%3FZ-2Dg~H^GLDjZOOzbT%M?E1iOdiB8;u|6pf$&Drbx zV3>DX^#1*3bU-0N3pz)CUS}v)MauE}?v|J?u?L7Mc2-1?c#!4!tZ*2G{hTZ0D|mTAM-EIA5iv1@h>D}Q zn5aSxt*sTtd_epJ>wY19_3Yo(OKp zCA6LsyV>e*nU8v>sX$oD-9r=^UlIcaLGZ0>X=Nl`^&<+okIRMPj9+I-@*T@R=RlCL z-i&+qo2k_1&e@a#s%w6)ly26%_>YqkyL(;W@ew~2g%6{=rr!gU*!|kEUiPWx`H=Fu z&XRPNpvSrEO44q0{%*QMA#sjw{mxnoH~wjZ67cQU@?_mr!SntDXYWrtR5LIC?-&Mt z5~JRRS7c5Yck61yK3NO!QvO8V7O`MtB!|f`;suiI2TWtK0r0P+X%+LbQ77m9@4&BfYnfe7MW-8 zTJFy6FwD}7R-9c3U$vS^oS5Cxac{Z6soG3kz5}`;NYP^Kkpbw`KmIx~JWWhQoXSbT zc1@m{vkN)sh}HVGxRlAB#&pz&#d0O?GrPCdr?!06B=aPNUA?<{c|EdnqSK0w)QWMi zf!%S#X8fJ)xZ`Ura|5!HrfC$(UNxUwTaVW?77dCdNuv4WyuHz{!XHr^>b)~^+z>Z5 zj2y0A=X+%MDQ{$LWb-Cwl$&6D%j&mZI$Qx?Et7X8@QsRJU0;HgRJAtDk4CL)@1;-l z7^iF`|LISC*5KssHwjhw9muT^*vOs2pZtR4I$yHuLSb1O;UmcDwr5_I)EWcdN2-hVT*S|a&F2Wx|(!!XPdU=-ZB_S$`Uc`==kq^Ef!kYB~yC*bv<;+`G zN)jXtDfNjAEMOD}l>zE@WMqVdmm^YcX0*&4>|dos#dVx{16JksUS99vWxx6ZB%4}K zw)G-~2TTGqg*XVrzneNpa;Zgz^vbeCxN4vZLQ6R0$;gp~U~@axvcfS2sdIW5k`h*@ zp|Owg3TBR^-VH8LP1)HI1J+k6KBmBZpmUnPy2ps>GX0hp&*o&CA%(-!uP$NaUrj=-=!wh!YW6)JAf}<$qs_Aq)a@LJ)N52#`hEallF{_153t zLbNfl-0;I`fDe`)xJ_b1W0W_5k;wkrm+whFw zb|fC1n49kvVmbzNWyhUhhonwHA|fK)`VycY%+1Y#8+7zyXIU2L)x-8kx6XSH1Tny@ znJ19ecOcPt+Uz2Pzi9H~s=AMZku)XedA=X46Bw_wgF^q}sNKdIwxNM*6Xs#g28cqs zcSr_1P~tj2FcZps+`it|x|Y+jAQGiDzhi%0j}P}w&ac~2Uf?ueYB$$={&%@YEYN+{ z9K2m#uO*s@<>zEkMr7oKUh$bWvF7vJKUD)A0UeUx z|N7&(=b@GwE$Wn3yU&XAH3E?@YYk4wUrE=MlrWm~ot%hDoNYg341{I%_2|d-dktnF zbY7&F&%r7s2pjQdSX3v#9p4SBP+pQ)WZ=3WG2Qg4S-V;NM{23i@)=X`Ucy4bT~9!i zG9HI7+$Sq#dDnbzdJvBN-5YYAer08R&|EVv$W26PB~h#EN9W8tJV|S{u8ydC>sP~; z*B5<_j4FDwrwT=iB{*hz`?wCZvImdyfPGm;mf!x?LYlvpWHUgtWC-v}?5)Lh`Cb#3*c4MrOP8DhH(cIn;QJyOS$`_9 zk`H@2zNj!87H}|*=&$f#aC}1qZ4gf{eXBF5c&mwAJ71f>KB#Z)=&2(s+VlJhdA5dW zBHNS0lB4co;jc;Y*P`*BUMw>l)5PoM{O&X|9$PDE7r05} z*O~XaO)Q`F&syB3ZRC-;FCzc{6A|?R@tU%V(gD$6JPKfZIv|37hGf)+U}6=w$Uds#oZC^uo+ zUoG8NJuv02;(PlH_)q2Q-hs?~Pfu{nqP4>C>;HTO$vIh@2Ogkuy9NT81&M%W!;&-x z)hvzrGP3XArh0!F;Fna}`W>QTr>k9u%5 z*yv?=rocFPFx`oBv@q;)K}+tiJpfmO(J1@UqeSb|>J3lyH3nH`$&;rFWL(YBBWpG8 zc!bFw8wcaa{*5AX2So4lC-@rqgNO$dt@}t8#lcGVOQ%H=%9a!FR5@fOy-8m$4CTgj zI@4bz`|}_-sKuod`Kk6I1$RDZ&f$<;Z~DV{VBBO2Yx&s=83UmbFSl|@u7lH>x0`{^ zzAc^k3d%e2UgsG!tJB1afJm4imGM z&m!HGLO5Y|_w0889+B=dS0N1#7P(9!T&x6jfg9IAxdS@Vx%G8I=vY)z#7NWcfFc!G zVG#F&T5<2s((%EtJ{AJ-2Lu9bv6PqCLHU2O;~C; z7THKCQeewmMO;BYrI6L`$q41t*!bc4EpU#2pa+ENvH@)_8Bafn_<_bBHZB?WB;}d0 zjmULvfA7z00PBf~e8co(rbt*A4-4&Nz~+}fNTxu^7F364%q8Y|XtVAR_AqxrKg!LR z&(Fe1AcJ2rq9v3qID5yz)ZXkP?_i5C4o@mh@ibM(*tWv2=~A&^%bI!Fg5|aR;>wC> zOa^S8IMZ3t87taGpWZIE{spo)L$kLP3BAa2y~p%P)LnuiMcq3SPOH^=f!-_pGI8!* zCp9(76vbBQo`Hd4w`Wc1XHCnuiwwzH&R&v9iCH(;M9t6R&AAf{a^%%>zEJ!vQP(~4 zTx#);x7%x6ysreuhAAWl2WSH(9+zw~ej(H1bfRw7Sf8#BS<@^xd?rA#8I{mfR8#=* z!t7k8Q^*9ew)t?$N6^#es$(M1`?*2+2v+w`Ct^zJ$6K#2@5988{tX*0B@GSXFvX}U zMR^(Va6C19s0PIwbC0|QWOaU~+Uay)>`xbC8ioC#V9f;#+Yi7)?Ps10uliBXKbY_a z!*BjR1)B)Vb*=#gT}zHq<5h~a9H`wgTh+}T`0lXvIGKFFj{4T8sX%=4;zG@(r+$x; z-hq5D&+uuX^>_tqOE7xl;ffRE!@PzZ*u8EN;a{JG$b9k?;Hh&E&_0_9YDRJ976p~ZOvs&!{IQ9( zdb@)3psTZiKc>@P3X9rj;PY}Z4e$FU$GY*oi80ILI}#{N{eI*=ap8%>-WDA{#J^}~ zcKM|tylp;;1N#BHgKz%nXYWDd5}NeB9PA$`1fTEEi=%Er^Cyb!0U=*}w!Vj?ybeXbuY@r<}aV`QN@UPB)MpBrv3 z=CvKZ>g!vaAAQhZ4c-E!`U78$My?)Z-$6({u)Ch6N*etcn<0~YF#9cwo*e(93~*Fv zdI-DJypUlcg;Y6_BDlZdZ$}T~^nHSh8!m3Zbcfg;HBZGS<>x?O=Y)X|fk;9$#+dJz zr+U8wp9-u#e^#uA7OMkrFKzJju7U=M{f1C`!$0u>8ET9TG2u}_{Gi1GwDEDxB-${j zNDGV4B72qq8d}^G67A>D z9||Tp=RSia>8w2{E$iJe2U==vr6}KpU?T2>rS=~6Wf0RcY65)-tGo7$Q;oE#;P2rJ zT5}2?qlks$V;Z=y!nU@z?b)S1L9A9u3D4hK)!?%_zi+7%AW1(P$X{woQFJo^C6mB1 z?YrZh@h{0|$l`h#xbWX31+owfM^})^$&EK|kCj+Akc;CEUe`>BuIURU(xcafh^>XaP z?ZE$3AwL?eAVgFde-l!X<92-{5=q&HsA>h>gHch7L^N?Mi1F3Rvd< zuGo58$|zFiZw|^DFn&q>!rl(EGFXWMhaPbImeJAcFq*=PU4OQ#-~~G<;c^5j=6J*I zb*SX!zaAKTQ%^p@{M3MnK;QaczXzIP2BNZ<;a0^!1O^5|WZ>L5+}Y^eovcF=xnq*f zsyA^OH;xq5*dyhF+U!7cYpM;nle8P8QJl?DH$14*YlCm>o0MyL1JnvIhDwVj{~Q{M zC3y|ohTsd@q)~|ZD`($aN^HlS&*kc^rBgpUqIadv znWT^dJpBeBQ|UAYi9s7;B(avw?|g$aBH9EizRuFj_{d?A-7?LlJ7oC4I|r;pbu3&X zw$V|3B1Ie83NdBSa%65mL4+ht9g5bBuR$Sh!uyp`ZZQ{-2rkSKjifs&_^{`CD_dfy zS6uRd0Ksk;^Jfw%-(VDEIFDxVMJ^l5c1sALu7-UaMv>H{+9ALkze zBPC?X*L9fM0G_=xvi+VB%o1&%7~^$ou&DOWX0)6kUB*khj48vTwwF!xJw3LV<8iq` zbsts@5k=;GXFd~4mIiu(Ab(~ZycA})Ua!0S)ga{n+RH0=_DLkQ_tA`_S3b8=2``(x zUx!{xWBF=iuRJZes4X9`5DAJ+6}F(w2AL#S2hh$ubMq@umErbCVbMZ#1OzINVBZqC3O_$gJlKgdV_Ipkzt z9)X6@g1?2U7L-6M<1lr|UMC0u`fW~)g#Om84;<+zc4@LyS|P*n3k~zLx%sAF6&rzW zz3Dh^Sy+pT=M;T;Dp*96tYcQ6>%6M(s8+!7~+CAg7xMonz>%^uk@n^s# zL+t9@HLv0OTjB0$y$sG)G{Yg2Pu)+&GP0IVrt$LvOZa60J!oq8Q)w{*Vc~xtERJJyy$>2aCi95EcEuiYnYCJML^pKJqV{` zN)O{;GmHuV!NN!l$9B+4124c5)IqJUlTQD-Di*R>7RJmX-BD)Xu?rwZ(X25L{8;yM zsS$UKYHmP%wXga1CC#I7dJ6>e@(6ev;-c!uH|Ca?+rPY|3zU_ci<3NcZNf(AdxGWdX^P3%1I5Vt%P#mgUTL9|S}=pCCz)yO%!C>4c0wTu3iW)zQo zRs79&MW)DzCg-kS7&EJ<-z1B1gJ0lwDYcg9rNrvCur`_N&PZ(y=uWK(d3TKoN{{Qu zcTSoYtp59+KkV{RUh}mpJ!OmDaFaUCtM8V@J*CB8Qe#^3Z){Bj{%=OpPf7mIyfRI; z%)g`hnHRsRBCa=<+&78B4C5{rfF{(VvPt-j8!Jh2NTfL5jSoQJhe#hotriBH5>%3G zF-==ONB7ZJd=%Lw{pAk*@z&+VRzgra`aU0SxG2wg2gYKs1#j=P(PJTCeuK#hO-M8# ztF#Ri@;R3L>a#M?f#UV0?OJeOkB!|(?9R%04B4~)vnZ>w#XQMX|2ee(LGn~iXZ7UfHF}Gg)$d{= zB0K7z-j~squq*h}dGxFNb>obSHWvY@$^m|O^l9&BN{AqUM28rT2NB!MqXI=A-~)hT zs{J@Wqx@*sfV&Y4t`ya;Xw6ytX|&!W56kFz5N9WQbMP`>i5hXBO5*?EImG|-?mRyR ztW!n`H)DR#jcX7IyS*j4nL5g{m)f?`@T}1&B}9)v_u3Se2X>$|BYwLj4v)QnUK(>) z(bEUS&WC9b7~}6cCJ*;1Bwu{z{m8FcK-qFOrLJQ&t*>O0Fhp|V^*FMny2uZotCYsq zx+^=BC$Uw13k$6z+EycO=y6E-N4v9i1W@T#m^S{LX?}_Ri5BYYA9eoq|Nr3sQwb8& zBU7e`75O5O!5IV34?I}zilGv^IubZXVC@H#pNKFJf;Ce5)qekew-fDbi0xV01F(h5 zX3hqtZ$4@oA{Ehv0Ptuqqjzk9(Xr10 z0^-%wE^-TomKKD=+=jw-c~Yod-J3Fl)4@~&#I056v0JYM)Su6JOfZ z7)$P|CIgb`!U?L^#tx4ri&rly#y5UXY)-ZThIK#FjJkYVbPf0f==niG!*`9Z~88JA`TlIV2t{5sl2 z%=y;qKlS!;#+ABxZj=<)@;A-Apz^=ih-ZvBmUvI2M0I2f?x6M=nf+wYIa6xtoMgc> zJM(SQTDCCC0}2zfVaj{`Z20y0aM$Y8R>LKonQ>lAF1C+n2fbtwzwL|9njE{T4kgWT<{mt=^`=Cunk@ zg?*E?9tQ;QnM)N9M;m#=(}$I2@JNAEhAbXgMaNU1L7~})Kn@>$8AGSIJIR3ebeoa? zH})yjI-`U^P6)EJInaoXC9~js>k&>hq>}XjX;VZqqD2RyLg4FH%Nv3nH!-5lQWJkT znU8P{_K`Bw-!fMFt|Bw>mE5@NQZmt@1PvMX?K-fzhoe-Aj8#JUAOM$F5>@4YOZ<&m__*>}>fo5JP`CZ6^7<dPe?gVK=6^)%9n%8+o*OQ@b{=ezQogMs+3)_*Yz#4{lUXj#A8g*c3E^xpfC>$jsjW+X57B+Xeuh>3}J zCS9jH9`se%dhK-!NiS4@F7VSQpkaa9MS0VM8K!caPw6+R-I3&%k>30Rf10WrimQ7W z`VLHyB$$O->;T-2%ToQ%dOQah5%m5=O~P3X-*8dE5ZiOMrhnPAvT_&dLc|HwYk2$+ zWdJ}rtfqo~uSih3DZ<1NAtdM9&&vp;BsUGDy3E7a1;qmXz0gM?GpkI^6ga!<8ykiY zY|=gp;&iO&Rs!c8SzHUJ`=6!5sJIo2hjLpz=A>~-SjuZtKFA^G2*@Ixdi_FSsWMP& zAh84T5+WsV$RP0v>X>QiAP`^n_S~<~md!ShIqocUL?;XlY?nnHmr;I!yCGiqTHu4? z%1=fXS?1jKwv(ALO*$ICOh<|N-uQ0mO6bF)`NqP56+FX&j%w%@z7lUzeyt)4S>Q-3 zPGt!~(LCkpst=^n9@9h(KSdN#R&;&p*CeMM24_lKp&aa0u8+2TbDkY{C)b^5EY`nQ zrqI1UOU+SJf%WNuNC=4_YN3Wea^Jb~nx4zmJsV@v_$C~_}%pn49&KBVaP^k!}eFYiAh@_pn^`pS{-nj9-8Nk4&azWpux zLeWJYn35pO6Qvh7Z@DJCww&sBWgJ%Q>+-M%O45Z<0c5XW!Qu@P|AKUk{af)!GGbobTy?%C> zgPOENiy|oqHnAWlpi6)pZ0Ou!0N`<)F45}xJHIT9HbR1u7v@e7BSLGi9=_CeDBa3; zm4;K)zHWX`5xys!NjRK%xtkited;-+``-aB2mgv1c83EkxKDN(O+E+OK2mwmb-q*Y z=-yenaIs2ZOGeiyfMKK^+Zi7H*-9iqQJztPZ@a~Oetlh0tR%3R5jeL{Xh_FvYinC} zc6Pc#E}%n&G6&n;OtKCXk4K~3G%mbk#5Ti!=vUrm-$W z^mDMW#9qcawi_*A`Oy=y;*{FArJ}zeG8>RP%Kq^(kcQY#T`GupV?Op&>nIo-rB!!r zGSKtxr|t)|r;^dV>HeRjFqMuIy=(Ns4LtkX?q9q9r2`o1>bf=Kx;3POfe_ElpXGtt zSX6sWYwmNGdQ$PKsoAXs*d-UQHT~T*hP!*Dc2p$q6|IZZaiMvb*biV0LHGYhVV3wt zps-$*$dV!(p!(IvX83~i({$O)^_e2V-+yV_NQ>um3PH~KmUZ*!^mrj!1%gK5#XvMF zQ3xe<=Y~a&U%(q20_JC0Xehvib9vk*NkR|+!ZR!w8(=)X0h~6#J8kfi!*V(jb4BJ` zvhS=Ed@a?>*{QC)zY~O?S1LjZ2n}GpK-qxU3ZpQG?_rFG zpqfmzyWb_Ddmu< z!}dGwmj~NM{vaESIB@!G#($!n6|L-m+k}OOx8aIB0;L4xVG}{B3W#x2-M!NX9qm2( z6Ft#T+qe>v?80rswZ=PhVDHww>ELy{a{59}^`A#?a)*XLJAS;5fp)aGfBe$u{WWQs zBc3z=O-k)cuw$6cMgZP3DoSWk(qqy)*)MzN}<+p02IXu@qVH zQOsvJ^k)gZpBy&w5H6>dc?VDw-6i^I9RtAsM*sar}jM@&~hC(pk!X~OFtL%4_=q&M^FbHm4KTR z8F5N z0*{g&tRgI|i7Rh#LEkv_S`SiW@4VnvxwMNa64mPT8AcY=1>N23MCNqwA3D&)85IwX z==6CFgW7zlxkl|8cx{cic8|c5qBlea`HkB6f8EjXeQbQ$o1OnrLboBy1W=+gy&u8L z!WNhz*jdV0<~yuLbd)^aXTJB0;>n-CVCclA6joHoCM$f++40jo;w zOhC|rTsR+YIdztTk`KG%n=KxeMfKNDbSjhtIB_~!z6WI@VrgWBt4>qhh zKPIg=qnFI*TF-G=lYQB}I=cD{^f0GC*fW<|J@L7AU9Vp>i`Bd1&uOoZ{uJNpYzb|M z(X0>GFpM##yR4PO0%!e(G)R~cm{G@dMmMCNMgKtZKh6!(4l=*7{7p$b(zJw{?DN>K z#<$d}Vzfj6n1TKudM0vo0f39~$D1pVSb`oUTBr|>8ZN~z&Xy#5WGFzsfu1Yj_5H85 z5WJx5J%Kgs`d){l=Flkup~$6Q-}2@PF#-V%AKI?jA4V>(mk*$_rnQ%cXon8bi5W-J zt3-a&jXJMsm1w3;FbDk0zf%{&Oq6c^I`C#0lI^J$fl#ce}t9Vhj zJ^CLqX;G`KI*F#cz<9J28h8 zd-tFA{lGj-%lPv~FXiXhZ~q?>hsioWx;DZ}6S-re%XE~wq+=)JTo3b7QcoSv`D49* zmyIYWX0WDEZG|wTnE!LPKd$zhuN)XZnq&cqyw}OvLCni(VmvXJH3g6Vj^aZGFLKAT z$zJ%o!L2)@jRHIc!x=^qXf?n%7J{?ssfr^?$0IkW+txC@>Io~Nis@E#MviZBmw+PB ztMdqehBi7C1c0?({~XPj*l&D5k3iBEaAelk*CAMCe)?i#+H5Q~xcI`UqW5HrJhcIf zxy1C}?QSnp=WAs$Hskd>dVg|{^b#-Sz1_Eq1}3TcSihH*&btEP6}X zp}Ao^08Gq{tjsR+SN!>1KE`9ZrJ4^?LR_*u_NMbK7b@m~7W!5%n_F@i=*sx3-V+ho z*9sJgCseRz1s)<5OB1V#@%}skSHolrzxTZG`=`X7k!_u({$>PtK_6sUzeHHbwvaJ^yaOqU?+4e6+nuh*sEnHuLA*S0ag|5xn}xQg)V|&4|eB zTS)xEojY}7l`gbDNn63It&%E%PG*4M22l9;T%JzPbG`l-8j+^&^N$&wu>L9Kx8R5f zv;=UQqBo4H4%d7A`)`-gog9C!?HP<4A8;YkT#;Wp^JSDdO-xv#ZYpIW12m{mm{Z7W zEcipfHe-dPBAplbTm20KQB)*Z$OdwOmKw<7ic9`k<#)hjRawKHH(TBfR4_{fLNr`!z{*o)ro>;)xDU|D z4J@!Y>(5{46AAvP-lc}d7kWULPu&)+Z-lp@Z@{=YNATo=@e2AJ^d)CD#nNXZdVF|! zmgMp8Ur6W>hSo}^O@fxmoXl(Y!y1U|n&gpk3-7r8 z6>NuQGkw)c`vC+fNW9Ns$?+>wt*?lCGeuV$3+@bPqKZ2&UP5S3f?{=Prkp&MP%zIx z5q=d>sbwkZiXMuojDAqwG#MxT$drxM-KHfSxsy}U?Ttrx#f7}`>inPP{C#>{s@p;4 z8mbMQja`>}4vT;C+V1%KFsxH=1IJIY3VEN8pa&MNXc)TZLMMSulZ9`t*9p^fhX5bi^2zT&V7 zDX1Sz+pv*ovI|fk$mgWs}~dhb3VLRDsZLmK(5g-U|uvE)rhNQRKxAe!b4Q@B7^692PT2M}jwR-T)v$9)qo#nca(n0eXr^R0MoLCe`|{)`xT6 zj-o}d^7ig|8&uu#3XFAKshhYu2?y51nj|za}1cM z^zrv$=1@3#*@zS#@$rUN*pG29F?_uQ7&=QUPh_CFxWE{L(y(Lx)$nb%c>sH_R>Z@L zW2a1^B!Zo%hOF@gKUcIIoEnH4rnxf)+Re&o0O{0SQ;jhn%aP)Nw`*V&{bZ`$MUh%nP z?wr!Pe=znTe7`Rpkl!NK9;(THWB6mr7+J&^ID zpaY)vkBWD1e*ffGlSvy#Q9r<2-I*^?-szv2i;qN^g7%POF>jWvs`nJggu?ov+$IHlX1C|NO= zm4z0!Y2Cx9^fvsfKUQBW%~;v~DqPoa6}1((i@o;aTodN1LeiK0QgEs{?0HWr?1!gN zMyT$U=-o(J@aJjM_^-QBdC~z8LtxjVumn_{hbb-a%Z1gE(sCfH6Ef)b)l96T0q&*+-R>Nu&Xi-y2TF+sg=Iuyl zH-0D4pb?i}Q`*|Zf~fLEGfI3R#XZmHFW=CE%^{WSsA}@*Zh_BLeWMh?jh0H4koxh0 z#qk-`KkLNX-hVLz;namt5*i zd6JV?r&l^)9l6C~N?G;-8UT`)he5t?lcLV(fsC5D3yn>tP}>A)I?I}9NWbNq_l>k)<6>QE1C~nh3A#uFqRAPcCSm|`-@eZD|Udj-7!spZhWc650vj>w3qO&%hSo}P0!U4JwGOEm&W|^K{!U)Ifm($|& z>j_u9$+liE(($OaI&dj>v~S)_W0*G`U7_kzvA32g&?MBLxcKZWyxU`%6Q0EU!6qiV zVYSs|F>KjOY=A@(vM2!>%H`!H+(CANaiFo>{QSZ3@uUzS;9h?eaj)o!$~J=5`H#Y` zct8ScXJ2E}|4#S4a))V~tPyF$=ZWR<87cn$v&?2qh1xl!8Wk(3>A-qH+8f zbU6I^<3WnfCqgyFogovhOjQxVV^G#U9aDpNhE# zdPPnSqhX^*bv}<7PjZ>Vf|$T5UG*-+|GzH62D25q?6&@EE&exfjYGJ+8KWG(l*{DI z1;n`?wQboO!N4Q)DNIR(i?GUPnP-owTg{i+iP7NLXct!ZJWl%Y+~XJo4T{< zmYp>1)MWg5<&=Be<+*^7Ov&NBTrboy={wI-MPg4o#nY`yg17doV+cSjvZ_ht+hUfp1AH_*!QHaAk4<5hYyz2%6Mg?}M z;b-+4kPI&7CtN!=qHM~A$z_CDWq0$H8qFy@dg?-QMATWq4#VWix9WVFX^;WfoM-o3 zkZvY+tmD@&1_pUEgXw-tUgdO=u-is%C=n46Ge#<5a45WXJQv!FYv*s3PDH>*U8qxP z_UaYk`M;fzg&hbgEwi(fBGmX^Vl==mLE3@@VaRzKY8|(NrRKuTjPAo0;{sH_Ju6bl zJ_mPfHBl940F=K?Q@1w)D8Kuyyl)3x9)~o4fVHDRiO2JBL$S6qTgN1iRs6e^EVpEgiQdFQ}3901* z=0(QmaUlz!r6s^@G2w!yAH*bWc$zY^k=LG# z074kjJv_~yX~Gk`LBff>OQZQ3NgqFU{Q1K|Kln3U6dTTg_xW)vKr*5*7=C05S(Pac z3nmT$wxo`}35$=XY!e8-R$qjJB%*xAFM%MXCp4DrQA@{y1Dk+U=HIEIBj0D1q<(7II zpnc}mRNzvSmv>VjH8TGb2${2^N0=%XWsjPF&H1J6(=#RY*Jm({Q|zUl-AcJQX#EpP zp6h4nL>W`>HG^e)9L&c8sSjBT~FE zU#k4RKN!3pW|rEoZBf}Cchq2$s6#fgAfl$Yu(znSE|UM5A&KP~g{#`5OqY+C4y=hH zgvE+aA{(Zo6i2i=?hbA-Q9SvyVOstA%i&zf6H&uxGha3qtQik><|=}Y{*L?BjBA#0 zx`wK^v;MlwdM*q`v5?m1T#pXBZVV3LVSbC%y$Rvq$xvu`(kOG!fg36Jjz$A1nxsh_ z>Avpg0g~WU47sDTo$(d5J_C*S;qf270v>~a4w{o#27WdRutfxSn#=WMFDza|_JkA$U{)?Mny*Fol);y!5uoN%FUE-@*mu5*NqM8wqP| zl>~6e{@_9Tk|URc{(iJpZ0G9hWI{XSf8HptV3~>C@@NDQt)-v_&A6rej=5VSJq@w3 zA2G&$xzDg82}4cJi%PxR4wwP~M}=LL_EJ`wd5nJkb#_7*-x%zM9+;2sG&A+5!UA>) z(BHoHE}ZE!W!`KQ39Tl~PO}*FPi$lnz=)s-r!`Xo{#yMUr@WmMT;-bxVAAB2l;;0* z@-?}{#PERHPIJn~F7CPM3jcC~>Pm8%@AXw~sX;!%_3wJa z2jvNVBEPmuWGQwNh|KS{68p9|F9$MjhyM8VO{w1P19omTiE}@}(>b1Q^s4+Ub3Myn zBBz)m|1LbUeBQY*6SO`>Lb6hQi4{A47H^@1Y36+*ru}3cYT}_%uaN2w@e2H3^)uDf zACD|^I6mW7{MVK!$mriN*VgXBx_nn&ezqiR+lcA_F+;rABM{p%L0Is@rfYQN$*h&n z<{tEZzyc<(EjAtDwBX!V3wXLph`AA8vIvU~Gxs_};pdNXA9uOHIdeil#Q0}Cf%N_JAJc5D<3urC`s-%7ihfsA9*aO z>5py1^k-V^NBd3xcNL46u=DdGYyj_jlj7^DsS@^A%V2S-Rpm^Hi5TJq_QT&U^@NeK zg*^oM0Tz0e^;mLLT|0ab0~OJYITHcFPA>4t>py!Y0}FLP2e1Py*$yw10*^!6|F>N(@|y?5x`inQ6x^}cs>pcyn+W90eN%{CUK0HbWcbAG%lRO~{0QDbJL zWLr5!?r+#DD<@B}>l{-Xn0-AKif{A6ovvc<{7?FKEnt-~9StFTG={h9>~FUccaGMC zW@AQlW^b(a#uYX2d=wkWzLPUR+yT~-7b5W3b%;_5fC-T&~}{VRL}4QpYyjC+5#%rAkFk4<;GW6Vcm(; zkzyMgh-E1E(}Oq<0UuDE3?F{5)Vm;IpNofus&CFmY_6Ea(N@+Tj#9s7> z&bEMISkAMSoTQwmbzoku%SYT{b4&zT2DoH_VQBV`8nrlPcDrir03D4#Uofr}($JJ@Dyhc{|r(A2QzJe6h^pKP_$a>>KF^RyChjZ^?{KWGJrOa>VU; z|0J{s`w7HOT2^u!d-0P#Y{tljnL3U$T&XwDGPfp(~LUjFGNK2OfCAiEWWwz|2LJR_NSn zCX7UmKqDV;e%|d^nX@i+UN*;XXjooM;T)Oy-(EP0O3z#>-TQe=L9nc^&{f`o?RaGzjDH z$-TF@6Bic;6ik*b#*Y@0{LUT!u9em|1EO6;OiawoOGh5a9KuTU%?R$k$ob#OKU-U! zFhP8Z>{oCwI*iz-6mcT}Rsz93DI?D z=blWi>>&`TzZ}q~S(OBc$s*8`72l4hT zfVlKEFc%wM374RtPNIcUu}Jj0ceLa<73a6nP#~B5+1Yu~)m;IHWogeXiDJgS7CAf& zCi@a#nz+@uXIH7CT&>f*ND*s}BapeV{nhn_CcnrxN%^8q`v9FiRxCXE*reDhqv3bM znP)fr+$Z<#xO_#`NCcRMrv$u4VmSM6mrx_C5tpy_qSN`U&#k63O@>6%vm`V zi(=MYe|Xk+{WB5YhUWB5jYo#G-=1|$N|J4QP0!5?3>C_Qj+A{P%x~d!6k8hqNs%Nr z4CN_O=?_#i=i}|{3X2(8RF0;f?n;-v9{OT{WrjG(^Zh7WTk>zV`LQ;!1RNHRT_LLa zn@D((8P_5FRs&BMPuzuAr4zk>nPEz<#;K8>UMskz@Tf&X zA#=FkzxesF6&`?n)2SuM&7e#4_4T!^JJAtfB9J-;Z8#lvfOH2XI^(D7)8F&A0(AS0 z0%~UViOm2`ia5W_B8^KE6)`p|r~x^8-XDYz7`@DySh&x~v`J|4sR-7K0~N?UVH~9+ zx7rH|m>_&5wGKleb8Bu0V6yF#z@RV1b>($Xpa9G~x3`bt_&N9pgjOYYPh#K(c$5!Y z8oqTaza2gG@{|dB#hLiLHQ%jbd)&amPKXAv+fKu7YF#c|%%nU&HWS0~b}o})+(uAR z)jpDGKVjOG@v9nk!+zWu&n=1Xfy18;m6$X}IzqcgMHRkuq8~{VAGO)nI_U3e5ot7B z!oX;l5%6W7m?=lF@j2c8Sg46naW7l%DZ<5TR}wd?*!2H<0mRbu(a0|c4D?hz%#S*V zn|ogO6uxzTowTiEotmX7x5>I}Q)QQ3|D;PqAwbvep420<)m}1(RQ2fWI<+tHdmeHt z`Wc&@_H_SI&gwXZSFT4HbC2GRl?!IYbqFCqYvATH<8Sq(Do7iME1QwbXGJd|4*hI{ zl2VzX8c@?8S5U5=ueoaQ2!(-^;Mt5>dCSV42?&e8%>ZM9{C}SovU3!b@Y}Cn9~m~d z5yEd&u&+c3Z?_yCI*l9?LyU*1Po41Cp=fcdb_N#_Doy7Gwi<2`k$2FICKnq7^)Rr* z=8a%Ms!$`jWBRgo=3XyPDtS)@PHO-65{=&dEV5854ORi3WW_OwIddK$EM?7MhMyN| zq}VW;J@vF6(++2#j>h;}!kQtN8l10bmfotF$I?Pc^>orE+q_zTs^rF}A>Haf@Lo*H zbzze#G*Badq9g%9nDl#voB}3s;L%B`sel=tujXm8nnHx{^#udBeiF zmD*Fm>0>ot*<;Q_s{DvkkN%xLH4M&|Xu{PTwWLYkC?993+IyHO*YkZ)CF(qciQpA= zsM##q=&Qf9IvZ~3$W!0f`rgo!h;Q=5;%$_M2I;|0QuKXE;X1eFL=_Erul)S*?t%d3 zANLm;f@L_^!tbid;QUcomd&aXS!zwx;xELKnB%P{-7wAMJtne2bIL2{%4myDw-RCM zwQu<)cH6$u?sveUi^jG4lGo=Ey}_(N(?otxAt5w48z_Sv7WK~&T>LnGDQGW63(OIU zY7o=bhF>gxOG)~XqV4w&RWo+hW}wB24~}=G-8rNZQBhG?=?zyZ<+;RbF3wS>?eTHV&b-y+f2CJ1NzXUD5`IRu_j~p@` z*7#cboLY67u?SHi<7qT?QjPat&B~$jPZZWF=9@lHNg9=~;E$1$h-D!2 zi|l#mfG_p=2~V-o5+$n5{+j5iUlcq8fWRori}9yj$q?SbY5zT#}QY z_Y(~4hdz{c(HMN+kFBxWPHWrrwWPFneUYu_8aNjO7}F-xNA>Ggb9yHa|A2SJQ*|P? zQBLAl*)sCC|CBFIk4caG-eKVU7;QxtCQn%8b=xbo-C%ss_2Pih>;u_$Xx-|K?`kO$ z{3x6T8SjUly4`cYvMHy!btgZsqp+GgNDR`UEqhn>93 zgrCkeD~Fy9)lFMF!66)d(+A~=NR8T6IV>B+!N>7B%4me9%+`016G<*6l_qogGoq;8 zDiiG>D9Te*H3$!knj#52yi|o!%HDrV3N`bI9lE7@1y1$U1_1q9o;YI0pZ!*uMJy}t zG&VMZNeUuf3zRM(=h9ocpNC=J<}8yRIXQXQVDtdAsu1byuiefty%+E%vOH{ZeRTK8U;+&l1te~eETAshwt19YTYDQa4;b`;%YX_J%aCQrNuM#m%gDN; zCP&L(u%En-R!$46xr_hm#n?S5_Ai4mER5^-7w03tk!oR^>ml<-mg<*+7oSg<2bK*v zZ$@+mAYn$mI=Af1r*+Zy#q#hcgwiaJm|;(Aj2xHoGDxV<-vcAvVR=A8ZmWp|w2&dg z!|}%2NVW{2QT*ELuUy>RYOA#z;dB>1;s^I(6;avDRv%NlWhJb%=Usm8<<-y=m2=1I zl;+z+>P|6*7XMenl8sZr0DD!Umso~6PvsTGCO>;He<8G0_`)%*PAi)({rNa)AOcDj zCfgLTCl_BaeKuaC2=HdEl^XWj^H2XYFl6bn# zQ30Xp1vg@{?yXAdekMcK=}VU8-(iARzCGe9Eqgw_Jug{qvz%{8g zsH})D4$@B@XMGuFIo5tCn4$b>wUM-bb2|9z6hr!%nk$5dv+DLgTb1^{CfG|mbc}n; zQn$)=o9MY&o&Kmw{rf*(#Ec|ySaD0Cw!Q^_Yn+;w1V{P@bp5;U{dHyu?#m}&+bo7D z(M^Z8tjSlWr&B{4KNJbw8jX_rE!Q+~Y$sJ<1rd^G^p#F5IW8j6#aN*ZH!ttVVGCU6 z#r3?5?{GGd#I$q*+hj!)i9|+5M#!nDEg5)XV9E|Q912jxV&uSh(zfK-Vp&-(AzVe3 zaAA*&(axkI%P48fMGm#~sruE+keB{mCRoz12YH8lFs=T=iiRNuk zPOy!hL?G*r3oxbEwu*G!i2}-^<+|?(>7gJ4nNQ373Cy1y9!5^4DBL6w0mDO7{$@22 zJK5U4JG~#r`WkBda2d30lnTdg0h#_Z1k=+)BxqG-(lzc%9}{P@ESJ=84}WOZEC_AB zuHR+|V`h5hcFGo@lwr&o4;y!W2A~RrBTq?rsw#E|Ywvz;W*8d(va-9_g5U`E=v%h2 ze9ifMJS%JC8=`Zc-U=Oj6li_}`A?3aLS73tuNS&J&X4)_d66+Y$yVBJ6Fdc{r5}RLmHNK*S{7qG+O`7Pk5`J{*Pk%QTN>Dfb!Rq z7GL8CO8ekyG}UGgUH2kw&oKRod8L!h=5M3b+QbgtRxgT~{I)An5q`V_#Y?NDR`!Z{ zkDsvp4}RJUZ`^YZ)78RgS9|)&C{~xlgbGo^pN^UC@+DOM4wfN}NNfljzE~XvjYKrl zgow4muU)7bfoKDOp{${y?*|{SLgAeT;@>~h+S}St5nNiYXbD=Nvtx?v(h}ycIBtyI zhl51<&=CQKlopITVo)HPn$mk09sL|^CWH?mV1V2RU>1Tu{6BoT)Hn8M#9$hV@dy(V zh)CM8Ip z{`Ca-OEAxFzLxjf7H?Y^5ezBv~7uGqZ{tOC5}890^)VFiH3?8 zKA!$7JfvhAoi1q}BlF>}F5iDB)@OP<)CR9@u}$yuPl?7xjAs%Cq^DJ4Y9M6-t$GZe#bRaIV(4vB(Y zMgVrApydsSIYX?2QL-teqE!Duh zQLT>@d~0ej5TFSM0WSsO;fITAgUlglsC7>3L>gSelz31WRj(`{M?f3@UI(#C3)E2- zn!HngET5jbgTe`NK${5{m)Runot=N6dn0FbCo4+DG6495m;}2*lm?8K`H{gP~ zb8pS@VbTUz%qq_cX7~U8JLl%%$-bX4Ws5~~{o^2I_z#Knke{(vFN%^iw0A0LQ_aET zrK-t>Xh=bpmsm06RV=L!iU_-NWs~+6_AWW6Q0}{W6Ig}dJk#hu&L%|rW|f_)K)UC! zkkYEtde>1J3qRnO8Yc^n~ijB=Ke&j z`t$u;X7jJ5PDOp$Gj8Vae27};^{y>pu%}emBw7@bEUM~OPZ+bz2%AR5@LmY@(B0bc zC~clWY83}6X^$DQ=YRioxmY$hb`5f>(3hFCrBlzJqd6f(T%Gpvo(w*z-YOf(`b0Vy z{~v?37yf{vQgfE}!<128adAx1!2g2We`C>Entg8^uNbv7cj=(dmni^lA(u0+-Ob{7 zn!wf;)M21*tZe4y zMt+;quw{S0BKQ26fk8WH8y=pX$dY70?CR@BAH{vCd3kyJdSSa0G%1<@g#O-F|N)8>!8zF2|CT35w4ee4g$veOBO7HSq{`w zsAkN+0WrH3jJ>dFK#qZ^2rn!fnJd5rMD{+a^gLL~e@dw;fD#^TQc@C9&+Ilg+ak(8 zc9*J9&(AC^jponU1nMZ42d z@IFidH*OO76viMx5xMIoqJ=Wy#$zl`usYQi2p3nmet9D5ML+qJV0fKQ zY_ELVkmNSnVr%VI!x&mCO&M+c2A<0G)JrT8Z=s--+M6}vx*<^lQV>L-8ZxWB8y8v} zwG^#Y5bPdXeWwtMQNFLxNdK!x$>B@10<2Ya!gdkDzGl$x`~NbXSpA-n+@ks- zYRqAgh5da}3CjB116GW3`LdE^u#nm>Qb^)RKb8T|5QyX#Z|^6;-fAfk>e7njtOJ-O z0Y1O_?tyyHE1aE4VY=T8r^Fa29iiajkUiTMOMn8wjT<+#EFLFVkbUHg>jvWECX&vI zO(J#ztF+CrSz6wnWdx}3M|d^8i}w2SNXgoX$icl{AQq-J-T^4OeIAN2H)h)%BFs=dw_T z|K{SW`Z*}wY1w^LADa9j;A)fS-%nlWrQh@BWHUB6EY^IrnAvTW(|cg%*_U|1CRrHUf$Nh;1*l@J9$)pf0qs6wT}H@gP}Ys>hb?S7Pc>NTk*eHwGCu^(!`s1 zd86Xxqhw2q+4Km}p!A z0!W$QcxGdR6=J?=xh@wEPXIhG5W;{*6qS@nk;uSh1xxPQk%Ifb^Gn-7d!FP1)cKfO zsXr8`;}wEWmsyL&Mh9_cwuI2>yyH<&^DkmwaOH>I=K}Ad#jO+dd^9zZY*9W~oKr5|5 zP$nY0K`3&%79?7D*=q{Bc`rEHsXuaLmyWi4mdn*q zv=c_iDJuk>#hTqDH;m@5(=#>u?n@p~ASyqo(fj24=J=$NJwuZm)O=CjufrX~vgqr* zCgSsZt}8|PF#*~`$|xmamM>{qu^*4#cX|nT8HZeFsNhfPet-cWsXuJe$+cNO+y@i$ z7k$~2m394@qh_05$-@|d`@Pq)ry7+_i#w(d+N?&q_#&nBa{V{4iH<^XHzYr8EESWq z3!+MX?2X?o$9K&OCr8Ym4Q53dHP4(4G+!;;-b)XOcI_lr>Y5MU{y(#BjhXOrOorQF zxdD1n;R}g@n}3(=m_vgY)obFxlY_1_v*o`L#*d%=rAC*%&nJ8S;{C$QELD>pgT&rW zrf9_A#KcV~p0BQ296wW0!AJFPVZsjI+j|A&cpxV+?ss2G!t81ml7N0o&=((KU|>x0 z4w&=Qx$V&*%^RSRLHMblH3rWXaEkW~Sdc^jz=FO8irJpq$0?0npG0Z$kvI3+bP0l# zR)a@-sxxy$oO(?Ru)&^Dse%yb5g|O&RFP4GRuxk;q8J${qwC3o)e}T=x!8^$P!|DZ z?H#P*$<&`C3zIG@D{E;8H9)Db%HomffNFXhc!?MPo$KuugLGCog_AMRCHFd_6SaP> z={{|4iWELV!;o6oMe)E)x?J~ri1X*Q`i64W zbYUoE=s4ht^stH7qxK@uRwsJFlgvsKe3jg9Dcg1j2LtpxNK{G%JNA{p7R1jxuumed z!PWDRf9s=sPQmS<58=zQXPoo0+4C!7wj816%Qser+9HQ-0#rh-`wIPQD}JgHb@V)E z;Sdw0ZU{)C@f~~lYN*(%G}g@_+Wm{I>RiEZpH02bYQmPxW9|B`{m!Tv*S!(CMjOg6 zIijC@zac)>aHPt%i0^cJDh0q#vPxR}&h^rs@(YJNN}u8Ck-2&o3c)D}IHY zW#RC_!=1tiff^eK8+DFLsK68bB59v=MNzfy?s9=OXNE`$DppIuw~bnYv2P!Y~ijDFMH||P<#p*5KyMZ{SFc7iO8& zGAo_V7bH5HIEeO9ZV8Ofn3^Vm>`V(wNaF<|huPpih$`_1Aa{)JKoUuni&oDM0wZ4E zz<|zax=nDWS?mAE32HnTyn9!r92_2it(d-)QC^Ccz+^SS%P7AO02Snxg4bGwcr=e* zqbcVdbABgEaN zX=&EoOMI1@J=Uj;rxKSG=-JS@2<0X%Z_0R2H4?o{E!G`CRNdwk>*s&grDEMI9z`NU z67`wNbdRtDZw?yGP5&aw4aQ2jRfA|Db@|2pjQ9<6el6}CdQ7RY?J^I{LXRl5g4p=+ z+ZV5-&0XVSEA;-PcSHt0sE;HlH;5l9?s5Dy-)`eO5dkhe?BMO1@w3ia>OXbWT7u|4 zj9zDPFZK+Yy|HZt(z1t!?)-5fMwU?Q?{4hT=Z2y0$oH@rR>gMk-CNVj4bsLrT-ytOp>8l%&jF#7JK8iw0w#+BC4hSf14v+H+2PSq7IZyWTZg3qGk%HwX%b%u``^@C%on5%5_2n?% z9?ZKH@(dz+iHM0CIx!P0s>S;%IqL7onFbGF1SC}ZAm9BJY-(bPlV@jV2hfvakwDZU zn?|2XY_x}A>*fnPA+iBwN8tR&SM{F3ZblH?v|2a6DE(J8N#p1sIH}pmO|_TeA|Lgl zIrX|j<8{rOGO|uGf4JsNPW6V*TdbPV{8_f_$FYd?`E8g~$048+R6l2rFtN*3-zvdT z$Q_RYs9nR0MD4(S1pF3ijKMRE`B*-75;d0=6D)+St%3dMJL>|BBukC>8Q%x4y5t|G zQIOG=?_GVk>JYhCbU0mn+vb=UEvG;y-%1lBYo*&1&Pc|StA^qqb^6jJ`xpA*CKf&? zK23(4fSl|i+UqH|G^N1P7Y$y4H<7a20 zt`1W#A(<+8;P-Qs7P&~KULH6h@CBkQoEbPd^wGdyQxW@wOYYHDY9#l1Uu(5=SPlh0 z-}we&{%&ky0~&ydhi}&4fT?PUG8jaI8w4U7P!mNaXyE`69@sU2WSEyq+sngN2}WE1 zAdtNvpY_>iYk?;RIC{t8B5mP;=8m1fU5uMIlN}0K!XZv_B`X461};%#3s`8}Ww5;J zhXxA?{5wV3FSS%3AWdpuL@;~bZk{^yVoq@roxwlg}-n-bkt_y~!ZoYVCIXKc4CJ{5qX35de{p%Rwzf?=Q|{FSzer zt^2e}U9>3JaGL@AfNlfzzN725e393OY=T*}r3b9NIcQ~SA*lWcI5fy&@rM{K3=Y*@>DwG4sxwe{ zNrJ-Kl_thjwhX!cm#i?xvL#%flij6+*%1wK{jH5fj^^D(A0<{Zgd5~oXrP!n$gLQ| zxj@0j!9ZEv-#%s-GZREXfI2 zKP1Day88NS!2k!zEu?D(3JDvDcU!aCsW1M7ktz*j6Q7J`q<0$72nF4^IhQhguQ1h3 zq{&*OBMt<08WJbrSS#UkAgDzbN?V@uw?2{G&t-56W62en*a&mx`u|>lp6FPT1w1ET zKIO^HUtE&4saAOKOyM}?sE46X&EfT+6ENDuv~N`;Om3vi`6-~gbJsK)B+N zrNRCK=L1Tn7TTyFts*;-fbYCI-M3hKYM8GHd1`24BBZlZ223DT??%DisjIKw2AVn8 z$j;8r1{W6a0dS^cpN?>HaI^w5-#p?8E@zMjzaRMBfy9(nq(gS$N)@cp8{$=9ihK7Z z)3>3yB&t|)ei&&vppO=53($!f_5>;m#eFEq7W7nsyf!wbg_OjobE=UhbeDQ=F0PiE z$pbV6Ute)B$lmFeTkV1h0W?&CEtv!wa9ho$R80Uk|EMsGTVy4RcqamoAC979{T#A8 zPd|IH+w!T~ACBlu&FQ%yOO7N(jEikg`;iZ_U_b=oM;~&3(xj4$0^QA(e;V z1$Td@!4@NC#^vE7k^Q+~u-uZnS*gu?fA>JjHK1f zgC5}f^j1^I@q-SEBrYb<2LR6s-aZiS$B!Q)A2##?NoK-j2W|>E1zKD>Yp_6*!@KuL0tG!Ta%nDd^VUSa$lsKBA$l#MwKI{>G%G=i&`SWR z7}65Cwc?v0Xeb7Zor zY=n#f`AiYFJEJ#{jQYohOoGM7hp)0NBGh~j)0tnbn^iGdJEMYxPy6;sRemTmq4$f} z=i6GVUEh%KZMK_;>p&hFWOFcB>TWtVMz3Ot&L<`@uLGQefC;G3z=YxDoob&ha~?oO zyyx+ToVD`ZH5C=ZeDW8uiAPJHu0Q2#2uJx|*SaGu#e2l1cgH@GIfzQy5jBn!Pv7Mq zD;^dIFs{>%ZBnR6aM)RQPzb#4Gf*Afr^yZWGQ#S={!TpXR5}xx29e%YU~ z(s5Nx0+xn0YVaQ=rKMSX2BZPT##X=|ppLvc+R##(X&QsFJr^%;U~)3jN(L=bna#}^ z=w_$_J%b?jf@#nZY_ae=07}4A4;WtH5qrD>P!#q_eRi@ysM+u(THMKI*+}oel_Efc zG6NB_^2Zj}rUR;rBjam+_(^x%!8x5=Q1^^LCI(%Ifemy1=E#-{J!p-quge$U20*71 z9CZL+pd^8wBQ}m$bbP2wD@5mqE-AqjXPUqyVzuP|;fdg!lSc1!GBdUD_Y9wl;Dpa( zSaPu_J6D$m{5h~~09p6~*$|li=(V}$;NQkrMuPb_l=X&qiw*-dt>U(t3fC0V0O_I?lOg*EUz0J{FTn{WVtl|$zol;a?BKv4|>BYPdC z9r(=WAh<&mLLL+W5{QwY_K{Oj$-qv-!$UsEW1CGG9uPseKWl4`{*mw@prD`xtChHVvY2 z$BH|nshbzy_ohgT>s_7nM0WiPyFfI@P60?w_0;YS@2-ahW&Kz*jNcbblV#@SrRsVj zb_nA%@T<`seo58`gB4H9bB0CF5WB%5XgIMh;WoD~=W6hEDs#o?@b8hetp{#nJV)mj zM}XbwL!50Tbckw^9Z8U?0LH>Bf*#L$Bk^Tz{ilD?kGPgp#II0&P6AhvdFml0)5W;& zoG7bVTl5^S-@oR6>&RdBI#EgQO!YCPk(I69l7kA8(f|5xYtd&2r4NNmHS;YV485b_ zCVX6l`;Mupm{M_1Qp*ipnG-PZ1E$X**T#pk|mwJ7yQpi zZ-{w$?<(}tv;bQNMW>zy^1(`1G?e~Kq5nEdHFPzDohG)MAvZ6N8_dVGFHGp+q1Abv z@^BhA;ehq=&Yy$Rq?;T_?+P?z!88^C-hZiqtdH3Qw=bEbcUCumn-dp2ut1*N7X5GT zw%ou+_I4YewB6o?v7j-c=h`sM;5oPp>}yl=y-pEIklmp+0f!r2_B*~@2|l0Z3_@MJ zkWZ|tX%MjCc}6GzhJ?ZwnA{*X!j*vc2w4}t)rz9mHiwlQW%C8<72=gu0UMx!qdZ zd#MSuU=3KrpR@r{UolT-NM%FF@R5ATI6aTc(R? z2WtO`nFi-)^~exMKv`y8Q@TL{r6-@`qlNGE(c*|gtvoxYDjH;pLL7hJ-{h1Mm6ZA5 z)1lxX%;D1^a(`C25G#E)x4|KgP5?f=&vum)v&u)T^6K%%6#jCSg=6~h@F-=#46m{D zKETb^76*K!InM!xIzDtf{G&DtvqVyV+=2WBZOzNb&n)Y42;b?2J#y+e;8tW4@51%f zzrDE~pW6eX|0toRa3>~@Qlx9;6_W0QWOOnV?Gr?EwHtzD=HOjSN|WWCqS%^au*ofq;v$TItD5V(!}3t@;>IarV(^q z&_{)J?4Mskh%B;Kb)+|fNt8}!4PZoxQUQg|dGDw2j_o7Ki{R#OK`OrcwogZ9ts5?> zLXaP$!phJSnmKdv4lrGptXDa#6UCmqH2yjr>jd=%YPUs{ckgV`{Ii+_U_LH5bYNl> zoc{l;Iu%s65BtJ`esMheVFnorR*iA1tMxyxG30#i{?$Ex@~)44cHzvldVYZM$=995 z{fJ`Y6YkW0c#&G#2GxT&+!lNkg$+9KXu8FRe;(==X{<>mW9&pIMQmUEBXJyEeSHra zCs$vuqrJkd(lDIvKPscjoRh6Gk$g@ZpszPkKwYvLJR6A_QgMpg*A^^)p+8JH(~jx;B`yMDw1NFsbPxb+)n$KafffwqA^_YlGypjM$h!H) z67*nffCCP!ZXa9&=To(c)kzpW!gIot^T+aD^!sGP}R>;}bqJ$`c{8XTyGcX%HryWc- zUjN%pLG?4fE~ejgbIAx#+I=gi>>`AnvbXA+^gZL^-wUBMTq=saj+Ne|R3#Uoy9Q?X z{N+M?5(~A1X3&>`F)HePI&gHBGEQe~o!!HRVc@SXT|3=aNI2P#vw!k(Kkm(~D=9So zjAIvbN(V_vqpkp2uI6emC^`w@LNCkzO?milZse4=L9zC%(})tdv%A1YC#a`%`0wAR z=4Kig1puv6y1KfP7^ z_BzGX>ty9YYtv=_eUIukTY;5G2QT{hlkb9N*49|YXTyoe#DqMOrpQs6Czn3pxqv&T zMR?{V1jT8nUc6HTC;}DMK7}BBsV5d6HQPWa%w_>SPcmUu=?G@?(o;uQ^1w`QXc&jV zm&paM!K#5AW#HjarHA;k)UCmGa+-087v4EOQ~j4={xW@LaH9Fq4`cchnD5ve7OH9g zCK`5G$5n%!G_SwDyd;d|D`aPOqgmQIld4F|9Ju(}a>Pv& z10y~k$A11sGA!(`%O0)bbAcmvDsF6rJ+z=uCFuC<_ks+^f7OS7zJkI3ycZd$y=MHQ zVpcCEjrFcmlpG$!v?Em66ZUciFYYRflY&6VXKFs`@7lDfn^#%RXfICK()yU%uz_G5 zerKuC_k_e=Y`IgV!MQSQ!M-wzjR#F$>wSJ6jAoRtx%@w}6!?X-m9A1ox( zpVMJS>HkRl@Vb-M)%^jewbm(2Gd3St|UzOTD*V?j;X+<>ov6OncU~M}IxI zJX=j2Yu-|Nxkh-gO+y*dKIE0zqz^gQLXHtYuten9FBo4mgEyhvjD1eQM#sMx86_nLB`Ki+z| zAr$T9ic;G2dsFH68|J+~EBK2)6RV8m!P9}%7e0!4Q$UO5V^|>tAm*}^78BrD>KUaZ z0rahs4?P)|mfjfJQ^@!UKx&JeoZO1Fblr(C?y+y+(b3t3t1GY1LE4kOtmyf%<4sip z$<=I6j<&k-_esp(eqaQs)EW`JWB%sWmMq6rIn~!QXfG*}-j(6K%zkzFe85#PXPO21 zM%H;9te#GnUhg@$IEAP;)@`{VXs&-fbsfV)YnmSuzMOqJ-!9^_UL3s~k{ps=rPGPEO?CV(U65mF0^LVV#x2Xhr(uEgLdog~BlHk`_T|Q2HH+;jUlA zR8z4?>o6u8cw^{tS8XHg{r{usI>51RzrRul*_)8;J<6U%_KJ+M_g*1e_9od`S*dKY zN#;XV_R0>)&ffp?yua&zU61$eQt5fV_kExHoX?*p6)eFG~<+c&u*Zgz!X%ZIE0*zq&RYxdPDW-qLjsB1qd zs1*;?7`(u?s~N|639t+}n*$%n#v&C-gW~7xP-!^B&a#lm8DINJM?Y1w>z06P_7U60 z{b+OQqr6Gc^Ntz6bv*HZIcx8Q{RI{YX+(n3<2?3OYpJX@+~jnzH3_?#T6WzR?)YE% z4%aDs-Yr9y#v#0~G_(Jj@LkVM@xwyPy@)vRc{eP=t-E>?_e`^(mCa%j*ClDwdjI)e z0B)wVV|L9fN6DKP%|!(d=c4`^x3#xi|IVTfzed_%Fu~0X+~4I%(7Z1}yxi+*a|QZ@ z+ZP9_epqo5r(Pbut16bVvUf$#mB@hUdH8Mb&^B{Gp}kIh>%FU{>FXG|W0b#p^s8~p z^5*708@%L9{1i#Abx-|8`kdQk8 z(gY6KkF<{{V&oVFd`ci6(r8TSHAgn#;w67dKf>=N{|+b&vetr{4<=PpApJG2oq=9! z)6`@vB)!W_+t+9oWen3^nVH}Hud3Sxox}JkV?izmBfi_sc%N@cez@*=96TN0+1dHA z%={td$+|%FYniv-d%3!HMXp!EP7bac8to^Lo?Ym2jcb%=2rx${NT!_^+ioLUNR0`g zJU*TDW_(vDP`-yVm@N_Kz0+K4ox7gmf5?5cCOhcb%z%Y*@$U&h0vc^1SNqB$ zE@BMEO1~YN>A9LUuKX7ohMgM)35YymkL_k-yaetH#t`R5Od!A5&aiXsqq#;EK*bqzRp{1d++rJ1FHH zbV}&vu40=jx`hE(h-)(+e%2tEPNgI!9Z7lnbH&=c%Z-xoMGWD?Hai>!A7w%jrE!v)XV z&SLee^vNh{mgDCA!&Y6hJeKZQkUzH9sn9X|;RuBW<4?Fv-!qQ2oQ$LDOF?0MeHDcT zDBgY1T@6$FmSliMAuj~Mhu=RYe`srZ8&X1~ED11*zG+LkE7l~1Bwj;hWhKmOFna?A z&!1G*dS8V4}BQ zavN4umWDcr^Xn7qi(U!kyqOriyY`zBZmzhl@9IJ(RZe>od=JvDRcwC>Gsypn{owZF zjobGlR+C7NUv}aiQL!Z$8d>y=Kj~pq$QOdXgL|I1Y$FeHU%sOU%n~{ttF!-vHT>{#5&6aSX69=T zs@VM~IGFxQ|HZs*q;!`DPwu95u;fj{cLMZpgM;bu6y$E+PfQWG zLl&*fmug}YcxU@|v`Ecw#-cK`f^T7`Mm5p z4?QG_Mo`{3`fZ^mCUds`Ivu-gFbFm7NTUI>*DaKak4OX)S_J|PefoX$BDZ!V2h`msmByqhK(3lBnAGeQu5ip-i^*XWwpx%j|_1{ygW)7fjJXC_rY7dGRU1Y*0@vI#b?iQ2DU!*8>4)hz^mMR&C9`y#!Z!Fus}d0nYZn`ltN8>8^0p3dbzIvw_@ z>N6&Z*zk8YAlL&K%iDGOvX>b<~0k=S9R!)9Dp_ zw$G+4F7|Ly=T}is4!j;wU&6@Z?8^Q)KhgVTx0>e+Bsd#SI4-t&PV2Tq1DJl{YS!4< zbfO+_wQZC=TIsKl{y@ib`vYA?F+Cdr;$N#`p;hL=eZEQ^eg2E^2%~hR;&?h|VO*VO zaV=)Wj0Df67^j;2S|l76#jKC`@Hp!TD^k}yp;R3bNHm`+-&~4~#X-5>^5gw`3P>}7 zssQGvZg#u87`y;3i76=n3@jh4k61Z4Y(KbJ#UAzU9YMt#vcdg7fB!z#)+U{vnHd@x zA@sNG%E8-W%r&k(-<>hEZ#VUy3Zl6ll=eA3U;Z#L;_ytx-OdpaY3{fZ!>q1X+!++t zr*hGH>uXJo$xMws3d)zM+SmWD1!y*i%gv>OsRY@BOgP*(Fsis=&Ke&AhFwdYX}-=_}$)yI|$ZCoarZ~g?NS$n#gxtFTnoc;w9`um;miC%Vy3sRj5iLj&} z4*XlsS_?W>SqeHfXzffHUDj^N41LvQStetl0s1^|(Dtct&WB|1DjBop@$ z{8Cf|1MJU>YvHg#K80xV+~@YY@E9E(g^`0ty0uU9q~LFLMUw}4?ynm6ykkfe_Z1Gs zrNJp0d+#J6$8w;wB-bD;b}|(wV7$3Yy4x{-)V4!&a%HZtaQRx*Xvni{Ek+U>#oxn- zk(Ko@LV^rk3a{L_9StQ%iXm@^`AA)w8&J@n8;8D;`aIaEU@ij!!IG$baGOF0m!!Gb zkNw-iUD4ygfWr?6ZtTAs8+-)e0Y8Jb-2|fFv9PY}o?2$63aywoH66*7KIsuT+S=+; zHoV5mqtsfA4-@Zw89;`j`DIgV?)S3TAmzq;Zu>ThUrzn!fCbV>D2>xtQmRmL?{LB6-8XJzd)CsM`Ib@TvS>Lw?vl;XOv?C zI>k3q5}!_H$>VLbIP_eN6r|_VEqIobpMPs?Y>b(WEeLA=87>wUsV7fRpGK1fL`Gs- zRZo|1y2LI^<9lrXs<*PU>qzA>RnyfauVxj-kCBa`2{Xi)@2-5lDI33hKzpg_79QQR+%Dj zz;mjprIq{X6SGZAzE)Ar$T~EykseAVq6K5tztNi$Bqmt4_q^$HwL&k9j`BqbroXq1_~_pN zu6vreyh{j)^u!JBN@U10UYaD`J4Sr#E=qe^|9u^Mp)AfPmZv=nAy9UWXShjzB2$wP zU_qdPVk2;$vInD4I{ZO)f9Tk)cJADjo2MI)}M4L<{=@T#LGLs-> zV+z@5=idW}jY^ZTzd}8>;s-0)vEmR9y84~(`^zNs&|?Y%mcp5$$ZjLO$tYKmmz9+z zPC^D^KX}2RLU{vHL{~SroV+~L+1Xj+q^W?a#}6wCX`P|ztsX6!{naW;|u>Rx2==veyR;B!)oUn&4U zA8pUFVYag-VNxNakX^6WI)+0*{tA_XyEzTQ$&k5f3GgHSlTbyM`}wC~2nei~{jf8Ndct8E=U&qHpT<|O)} zY>DU{|8oh?N3=L7{%0FhO7HcOH@MA~!(JZig(V?nLrp<917WtPm2<$u>O1!;a_y7{mo2N*+>;+`6on8BUnAah+ODs+(a z2es0A-A~{Lij|d>RZU+%25zoDuEM*bT$o)j6NHq51+<)#SM>9rJ58i~eZ@YiWJUs% zhBxw2`H8;1{x9o3n6(XcCK<08Mpqn7+-HqKles2OGCm8X;d9P+KK)-JpwSH?A#SJh zAi|cXW$!t}uAp6ycOr&Z@g?aq+@`~do=kWfhc?B2p7;t1ZsfIxVCIJQZZMT?s3G)V ziX!G|ANBagAq=cw?~O#Yf=kMvOnZ~ied|Xt_dtG+xsK=TcXppjSc}w$+cJ%z72@0LC|I@`;m@d@0wXwl-<6-`?>-anbRzV|)fnG1O+iSi|}&9vzUWE&%N z>}G$3I{Gd@csME=MRWb9MbP7W^2S@DCE$+M8`MU1l?p$y*dG4y$c(It_l-RO>_~s7vSgidcOGl_h(2?1Hg`RR?k; zPNMnbgYot@|4o<%6dj5WXRo?Z>ULLoClAI5AtUui+MOZ^85#m#oI(13{z8AyWMHz(uc-LO%9z1sPDBb{f}<+c-? zGSjn;YR?^V*`GGgPxeh;{qrk#=>4eGmvKSh=Y=R74Wz>?Db)A)6W7RN^M}=EgObMh z`rEc%SfWPd`sdW0wHFT?8kz<# zam?e;vF~v)#I@j#$ZFQZFdG@k=5-=VRSm?XS7)p^xQ-|9l&qV4|A`||b2o}8WToc) z+b&`@RN=I`VO>LB-Hy-2Pi#`~SqKzM7{iU8h?BC#$^{s{Ph%(UjrdTaRV1@00u2-K zFv5B874KxNE$*KpdvUurwpOx(3LECXKr({-rjsDF5s{w3T(5zFUPEnx(7IbX9UAQ2 zhCvQM6>o1l{FTqRp|5X%T&0u!_Uy$bESue=G8}|V?*=cY1;5%;g=)Iy->VHN1Bg@Zc77!%zMbZ~3Uv=+ey1bocxRwj zss9Hns#eQaJgStI+@XZQjIf^NiQmtqR;;K*joJ^{<`IMb4depX3sgS)FHO}n6a4~z zN?H!C>3b~JKhe3oFs71N?RFE444hV0LwSSGt1Oa>@`ib|6X^rpI1F6#973%rT(euv zfswDBFb^&(QB6-%linhXgf#3Tv^&wv#2K>7Q98?YST7W0y8*CY!V5=sKK6Ou(07pK zCu5)tM?%{gu)2YM%%gdz(C6(|QY2#ps4jBnxu%l4Cj;L8QL6O1BR!h*_?z}W|H^C# z0V#2$=^#6AoCQU#I$!#2sW*dbkUa57EW6YLJlHO6y3PX`ifQB@2+E&IOS_Z>W{LQ^ zJRaWL>iiS>+?pf3teib)osX^DM@B5U>=U9}eH;#v8yudx^8pTzvk2dX(~G9!J_&z3 zC=le5+c+o%96C}A{qE3?O5jQ92$wTfpMZ^X=?%f)KD-HIza{MU51&3^w1?hpha8zV zvVU>cbUL_N(5oX$T|~inv(CildVCLpGX@#FbPn?0^3q|9|z zp7)TS;5HW8lS0M0EBg=sx*8aNInVg-508+bJftAm@hPW@dG*ERp2E22dB17hL2fOS z9W5rj*1Lz4vdibSSqT%#&!5H8yjlo(9#-Ksc7O9UV_Lh@K0yi%{wKtcjij8Hwo|v zqCr^(XcO2P;E&VbXJRWrQL0W9#~v&Te8{Kb;*P@!LmGiDoreO4CZlSs1PIgL%xs+X z59!I)UUtPyPJV zjq@~Ntxtxzb_+F+{Dxv6=OWH`g6jvg1C()P27G!XWljwDF}@?N#Y0H7?sc)*#(ijP zbG;3Do*i2} z*(Y+$k|4TM&Nr@P=!FeA{_@*k^4R3^My`8%B{paMS8C+3hh3NXyeLcW=h#YTukE*v z{lR-({sJ}Fb!~n13nj;#U8kh0$Jn9@Cdk!~sPr#*oY}jA+1s|_Nj*Dz|5{KAuZ=g_ z6s%euH_h`UDNxj@Ky+$E2E(3INP6$kxhQtRw7+|gykETURO(nXtMa)c{rlEHQg5UQ=b&`p1yL>LQDz=ZQp^2D)7AAOw zd9q;sio9K%Yfb^KFmCJ-Sv|(=V-Hafy=&5MGs$)JH=PD?+dsV>8pr&@P0o7g*JuJ)4$d(;#5(F{m)wvg^ILFK<`5k0!S1aN$sdj^-?_yHSL^${;&M$ z%2XM2z0i}f;+}~qA9U?eO69)4tg}<^&4#=l$!qf-YOfiIWP3D?w)%#9sN+hxUAsX-D}yO-??g_e7f}cT0~;P z_<)UC6|btWS?}lVXHikrI^|Z}BwQt(xeQOxitV#z?tOf2S*$#*vX_&7s4h(KIa8*Rd}O$9UXBvW+PepHhB}U^Po%!6 zNHIDryegt*c5T1&P~SpVizwD3i?l?%o0mGSP!(UgY$Cl}e|-(O$7FVSu8mclS6olW zVMFUHD11%jEx9>jscAGFjj5Dw5HQTUVm@~(=q4PO5RUZe@~cA&WaZaXofQ6i-9IDF zwv2{F@g*R4Z7{{J^QIe02VI)zAoQweUE7Z!?}RmmsFPtYdG-pX!A@i2tGbg zaD+IEt7O4wB>qxnjNZ3$M?P~Q^?U{_CvE1E-QK=PMA?9%!A~Vy_jC7t;@WMhNyql1 zk}deR@6OcLELY8DdamQo88#j7C~{jGxRthl_)W%2&@0J1)zY!_1|#8F#n|#*co}Md zq-OTKoU3pqvpAF$Q0J)sHq+JWV;^w+;cRx1pGtuOb?8w~Rx)M@J(~bA8^%riu{`s0 zf>9f{RJE*VGL;U?4`tmPhYwU3Ej}}#q3|eX5PcxLb-$01j%1iW_x>SEjGn})c(@09 z2*xPAtuScIc8?>;y#fX8QXi>}*anu^o)53%{8-15v zBXe`BUCI6SlNZ)($j1Yp&`B`&W%6&nmXj5tizRIhbL%32>B^dqD4=--`WgJ^yc9ev zs}U-tck{Cusu&?{WG7La+(f2uN@iJW&<}ved8s4XRNUtiIv-<6$cQc(uJQ`;8DF3? zbW9B8o&P$0CA8CI;P_+WhZQ7Y?5VXl*;}0K{!7x3Fx(+j7?S7ci4$!qrENV``FdOGV9X1%}6xS7I$N<>2Hhgk1NhRVFf~Z@>}y+ z%u~hl2ogRf=JUX7Jwyxw1@=+Sf$CtK|7l z7nX@V1$txO38Oj=#NCwt*sUkZVbI{iYY*@!7j0R@PrTDwDmg4>nQtk~rLLQt`BU{3 zZ)>tQYZQ(h&1Qz%ym~sQPWABz4Xa;pV75c8)rS`SG*`(m)Y!yAjt?7E3Qt-+K<=?ADeh8wm8^SHVLkrTt>>Lixn=M0HS=_KZuO~mBRbSNlg&kZj*-dcZK^vN z^y!knVCq5bobXGs5NwLGOF!qD+bk;bO&tYm;`m_&;{>-%93O18LniRzLREiNBjcg&C|hdW&Af#1Yuc{J)BU9b zYXNr$M?}CSKdYo!nw^$q;j!pH*hzbPEica|1^*oW6+afLcC#2AOH&i;#>i9|Tgzg4 zk-fQhtJ6C()?IbdSM_B&rEJ_JY(3dl%ee8e^oqsymD?P6s5!bAxEG)CYv*6o)hG`k zp&|fVk$`J(v*EMc&QE-SJn}X?@K*aN$dnf+RAZyAluT;RJ2nar-g_Q-{p|#xZSq@* z*v{5gqNMm(e@;FwAegke#-!n##R@5^{1qZuWQw;&?7}-DOp+og(mL?%edF^VJSJ36 zCMt~@r+$-P!j}KGPw%r@-jJ1ad~$f@XKc)ls0S{TQ2#;-I8g>ga8zVB4KGKg4`+h) zx(l^s;>p+QhN1DlUE>_~@?7oC>~(y&>cx>#as6SEZ_ZvZEP)BHqiiRWQ}HFJKsUxq zf+jYIx9G#S?h46*9`~0+tzfzIfNIQB)T$}=0h0S~Ul|G)Nn`d_3cCFzQczTEKg)Nm zJ35OObZ(0`u`SH80-v0az!y}aBMW4T6~ zPA9O$BxV(o40+GYRT(}Wi(Ur7#SDv0HJM$PDj-#0^4-SX$22otHtY}J;RS6Lf+^%L*dic>^N9VT$?9zMxvox!=*@$3`VuXe zyoZ@=-hRf<0#`EFe?ArG~@)vO1xgllO zsdczl+H!RkUADM9z|tC3#@_XhVZ)k+mQa-IL+ylW2vbNxzmmyMZ|Y70Y)q#{RJnzv zr}1ihli~0bW%Yf}g3?dBcdiAom|{gLj$~fsKjZWfr`FG;c6A%JGh%4}sbqrr=8Dg_ z*L1id{q5Dg4LA1Oh`1rYUIqf$D6VmS_&?!N#HY^|tO&y8f;8`*X>GX~+Q5=gYPziN zinmN-mjNCy#jLKFW10%9kV_Pj3ucI2HrxB2ul6rwXWk2E+uJGGZp(hE@^<6v9g;0$ zPz8gE23X#Ph6d@Ecb@&xC>%jT`{w56>U_ZwTftyEI1lrfh#43d$dAlnY)AFC>3FV< zn^3@^U>L4_xVMbhYelE&9$vlJM_-Jv94HL(ObiSZ|NV?P;xjc7L3kLFP>NhKB3oGZ z&x)IRWqpH7!8m?QO6$j)0BSVex7J%NntTzaQ*>s%4uN)tye95n-3lqtr_d`ZmrY9e z@b@~_ta80`Yx1}7<5SIUFpl6%sU#^dSdhW+Zs&SwEy9YoU3jM?xQRZC z00OrIFPB`>Y>J3ogjq^~V4emDx}mXgXm*x^q@Uh59QuO7cmX%JM`*az(Zj>f{?y^@udwk{w7R5)l;|mAt9U}q> zi$xRIh-KCOLh)CLf%nr9!qw>?exm|JZFk}%6ndBIhZ}RGOwsejB!Oh30Z~>W4NP>e zGPxU2ykLD6^^rX=UXwV6?sM%y3#*ZlA$xoNh=#C6{8##OHzKewH{h`x@o`Mn&SDR|gY9mDQHDGkc>N zsyS6vg#V$j0>$%2x+Di4bY@zn6VHc zk$Q^?VX|eb2-K>u?sVQkL1QB&OmtEeJJjrQ*9xZmCPZ=VbJg~#lbt2e=Sj)HMItB(1|vg=D7zE9iG)CQ@j5+rPnNz91QQlU#1qSS)!~x^k-W zSt2a~Q)T+wJS+X&%XeQ;GP@lD-$wtTs&9JufO~3^K$VhqE%wj z#_j-mFOQd!MW;H}on~>@!6#ca%psEeW!XT#iD8=2CRjJ6soaPqiYQnz;}?xsZf4Ri zqA+N-J*GwcG#0Chpqlw(*XAzFuwsg3rJdE@u7*D$y2BNYMkE6pX;vR zd6j}xg)e>X1(whVDyau0;e~OlfVaW~4pxB+jz&f2vUdJI=$B8H@IV!};+KR%Uw@Z){0r#7NX=FJvMx2dAcfQT;< zA;uS|+>%bK`D{UesH%7y$OeyQm7-1->z4I-%mxs9 zuse#cndZJqI6#HL(iT;^MBoloO{Im_jn12sJWbbE=asr-DBtf%q=oy7x6l^lD&>F} z3`T8q(uKj(z;0gv$4*-SD!SRr!KQt84km~H*8-p|mK<|EmA}LBLZL_1ijgOTU|>a? zeP@wH!L|GZ`HbjCkA)4sN6488 z;B%DPO)JYyBw$uFy$LvoT#(25$v~-1*RtZ#i>NxI4Xl9k9%5>(_pAt$jwE4y`!o^~ zeB2#DQnV*$$rOnfCMV%^7nUOhbyoFF-x`#al_$%MQ9&4W;N`1CN&4t z`WOrsL`q9q=$e5ZMqd0JdT%R|1Vm)NS4Bs#c-|?|m-;Veu46R!SoAW|QKq%W%N0r! z=Gs?jPHu8FMz~H7YSPCh-KFlQ5l$k@?Ig6X*EtU{pAts|L8yP47obuY1TXmYixRZn zO6W6cq|48dqaQh3XrP75yMT+^*A|dBu~0MfSx4^=`wQM%l(l-CjWqKx_PN|fVAuyRf#rUzyN676K=CchVlO|%{mMCM& z+_9>BFJHWQwe_!vqTCvh5BL1J5Tx}WH7qeBu%hJYwAOWJCEyS;!osupwb|U zEVjb*c$?%xf~>1q-3dQ)QpQ|;lTsc}&~e~0tKVY8h`qralfG*7GqrA_c zKn*bk0U-z*NIDfr3+6qvo>QU(e-WBLUSQvpARvf3^kO9;rKr93xM`r@LZnsHG_{Y2 zqd_QgHPd5y4Bw!D5ZY`2lZH@Av?$%P6znaZ_0TeAFMCqMt^ueUvL@r+hFOQNU%!6e zazEBhHYVGgsl~Oox3_kD_0UzA7*Z0Fx$|QND>94t>aE9Zuyb^mhHZzTv)S&?C%8Qg zoXrL?mRZdxxR;*%{nReu6M%8n%7USP(A}BI6knUW%X$HI7r|Fbe z&qv-D#1$_;s<0tGZfP6Mc?P-M!wjLL9CZkUQ&l%F|64u-yCS&HPDe>je%yg>q;FKS zlR!vLW+65@>ViX?(Ya}dr_#vaw@UiB7sTOfm#|}d1Fkn>#YW(u}h@KI3 zS(14i$;hl`YA=PPkQiUoYqE3RBHE6p`(cCcu5y*#!4Vt%0*q@O&`l}z{K{D zX}Z*-S5YRrdypZanf($+zQ&Zdw@YSGRcRQVk%c(P>(}*9*jkkY5+{outR!nJ?V+TL zK{0H*W458abMD^WBK&rfv=(;@NBr~8bYXS_+{bl#rQE6}E%R{$11d-l1|WMj-v6UF zl9G}jwGka$hQ0xnFUatspFX0#>b2XvSYoSN`hr&QnlKWkFhu$71$WzCA^X)^X8UR# zxd{w>Zd<*lZM3*_zp_@Dyw2(&J7-JfjST_4U|&OnpzJxJJ5cC?4j@#q%&ObXL%pX| zu6T2ReOeN?9VNv;oam*ye#F`YXNS#ViEzB}z+Xg-;Ow7W-U%E8g}x&^;d#OQEZ9osx?R*Q`vrErr4MC8-At^idg! zKUjSOuPJvCVU!iu-3otoGi2fYY@hT<+nsMJz^7pJKEHSG-ejF~9`m1qk?VqCQjj!) zssr5c<*$VBFknwo7OG~4_O3)uC94!ZdH$R@GBOer8am0)TMoi!drtxr-w`6Nvs+zD z^mys9Ps1f9yMaO{LV9xR=+lm@LE(6@ZjivdkH*oV_H)YJvzgxAj_WL0nb4bs#;Lbk zPA{>2JTHWcUsU0da#H>MI0nJciSUf zh>Yzp>;JGZP_YuMr7DR}>juK{OXmNk`nZB^@iPDel+gBsMyEL zOA4GvhEdgJ99_dvHp@7Z%zJ0@wi;>}2XftSUAGv~=oHv0nY3p<*AVum>vF~m-h0MT zC(C;$L7#ubZH*vPyjp#z(&e7tc^J9iqz}h-lWnDm7%7YI(7NWy7LA3`a&m8F^5XdH zY)r|^+OFzba>-V{pa6oo(cpnccDtI{+J1mD1H+L)xmPNvRLlSsiZOTaN17r{Rw82J zR;!0cn%QHgwe=Ew7~p_cWO>IqI^*Xxwe8XOTx(Atylhm@pH6pfmf_$m2l&` z9naykJ8nb&gzbL02#q&aV}p9R3XhoKWnZRY406w^`te7o;A@j1_prWqS=Wz^r@w`X z6iC#IblDBn z^Gt$V2$7aoZZ`}(O<6+YKFn)~^Y~gYQ2Utie-riN7;kDIQ%vq0q=*eAkXf?BDSw7W z@}sGdQnGssF8IAo#>9+8S^<}c4i}=EN(C`Wq7i)eU7ADa2sT{P^mij81%G)?m{D0Z zkRSt;j0!HR8GKLls6!Mk)_=uw!82R#kgjkk(I#hU^km5nn}dM>9Pyy^|K;#Hd(-Sc zBptcwMc~$>ES>$ch=hInEK`U$W}ov@ zYa@+*;PLgVJDhrQgKh;COO-j3%{w-~PPTX=#YtE!b-mO%-2L{5MgRTDNJL*^{;`;` z$56NSdIYYMM<;`YDN8`g6IQEPRWdujO#+o7#@ELhp=K}o4XjCU;yZo_Dki&@P*o<$ zQF^=LTUG$u%bn3qD`FP;C2Lvo}b3eojuNR{MDZ|M1MW9 zZ;kR3Xn16K^xW_sl+KZaTyJkGH2Dp;xe?tYj(8QUmyGUm$G7J#^Xk=sf!4Hg!?15* zUPQ;U96>^&qvr=wTu&@wh~Q09wuqr2VIlXe&F>?so9$SG_Z~Zz`N;G!R}5{8fePU1 zGGN$B)5mPk@%eiMA=A&Hp&`VG$h2ianP(QMKU{8m*P?^6#15zdD6s26%OJ@4d!z^; zbbKKSWWUJH&ZV^;UbLY5EY3O*3$LdpULWpGnJF#)AdM zADNzy*93}9gzIDAvC8Q@dqzi{0>A|5LXi$&u(5-Z`y??oK(pRR>aO^#-)$`kf3lW~ zQxZ@}SlH_)jxGw4V3FKy)z-p6fX;xMqUsep^WJ^Z?(Lvb*zJ|-pWJ?ox+rxDgzzmXsxgj|LBt2v#EqluZlK8rpiYLUfhj(B6U99*Q^>fRq<2o zaaQj$eQC;Ol_GamL|*70HPj=wTS`lRC$frt#1%}PRpVgYJAH;po~It;==+-8;d-yb z?=#sJAPWb7hRTA(UbZ=;Eoj7f^3x9Ef+}WPnaLnvCbMp0>Y+wqqAZZ43gw!e~(tafc?LpPJnFB>g71 zf4*>o^5W{k_vf>sF#vy-=2uoMY4kvlsPyrzOc=DVfnE~GRWNP~F7~s;M)f&-zgTzi z0}Vv8mmVhpgS#t>S;ZxB1lg@mlysV0F_0YpZ7drjUh`|8=S!}-ADjyNeuy!1cA6~y zCk(FrCPFe(Q?tCzbY#+xW!SdJ+$Ys&#|K=tM2j~j2`BZt4K-%n50G@VT-b9uG+ye7 zdR%iBpH1BNX#O|e_<=qQxaqS#g}pN&=V!Vt*l4Wk^qix%Oa)w;^aFT8qIN4f{`{Dq zI$vnlh;vO;roDA=w=b2M(DaQZ50&qkevnj?^pv0GJqAcq3|pKZe)C(l@~LUm=;Pd8 z-!u1}J&m0zZhhS%fg{mmdQ+kI41wDK{d&ERw?jaZj3+D$C>YBBreB5!a7IWF7xxBN_mU;BlMw`E{-KK&uRM%5m$LR8`c9(e{N6T!TbN zkQ+d`15_kI>8Lt@;Mz$GZ4v(`l;z{YHLe z#QP+tB>(=Zjz`7(p39vo7p$fDq92uOa&OMS4&;HGVFHAyrDPCf*65sV4iOdbn7u}D$q@CCDwkl z5LraAyLiroG`;O!H8NFxn|o}c7K0y^94x(vMKb!`Btl|?c81vvg|RWKL)TW=^z7UZ z0r%p^o#;;GdGe@xGXUJrA1`*U;f`!BJruldqqw-(W&sh1@I;Q9i{$g_8!eaZ*cZPC zr-Qxliq|^v`BthuIZSCSYaPGojAW zL*DKchID(EO#O8B_+*;(?U$8yAL*R^zjI@IWQ8ddVD7(AF5^fG{6QeB@4)GS7DO@O zZ%R~p-Nn3lnM=u4CKhdfdQyFMMbQSN@;g0fi?a_ zoE-R_wjZ`(rr?6$w)0RgZO>swi3(}olE`|46ws|@i-m_>)ls4!&A8kff75QIY5LfA@J-T9opQP6yk2`jn72diiV(j8#gd zH9T5&J&_#|;nhA(Vdt*F)^s>)jkCd=VYte{kQ(r~{{rbriiXqQe8LSw$1Zq_yF=)O zm~%nV#&6PMp4Y85;MXm&wVyq*O$B&q7x=mld3jGn2kGK$=~5f?IFWgk?Bp7jG8Vmf z=V!@rsp6YJ3c=O~XY}m zU%le9=u5qC%fBxfZ2VZ4bt=`%@gapwoDI|yjAYOW6xbVJbt5|=Kc+%NpauleA|=bv z2o2^wkqNt6wO9nGLTcpST#j-~Rk3V%{ThXAcmo~u^jj!EpL6T zvzZ??^0_HYk9Hef;&ixZl+t!x%vg1@1W88Au@_=l0xo0rI z!Zxw^r6_Fq{l-&}b47MwsbLbtnmV@&$S$8bMt99PQn&wo9)^^33I8Dox?laVYGR;E zAwwjG$fmmTwkiWorN#cVJh{$q12Gnq-|T{D9fLmoADyP>1-c?`O}Mg?EZy1csUf$O z*cHW1Hm|Y}h_}1Zp@aO)I$+DZT|3NiQ&6q@IioW>+89~q5*JPw&5pfb03=0=C5MQg zQ;R)r9+zDJq8B$g+|n`-x#@N|)w8P7En1`>V%bC7)NHbgLl7N%}9ft}i@#Z=^f1awGWcTn3kBuwO(>RW<-yj~E(g^_}61twbbL~wUmw>kZ&}VHQ>WE@Zk!~%p z8j~SCHJfu|5%6J+FB>f27{-czJH&1`QZqe`^g@1M5_XDWkG;rTDl#-sk8*$o7AuY^ z{H`Mn0%V}Pq#H3d!l%Sd(l-&oRR_pH(J88R89l zaIM0Skg9{$aSj7$S+NV>%l|U`hDh7Y_DJhMA+R8{SdypWI+8vYeny|%l{R%H=RH)M z_lzg<+d`TWg`U@`8uDwm>5cNWJ@UNo9;GA79UWgAh)J%yvMQx%1qi(=Dqs4SlPX#u zTDS+N$LDCua?BctI4Gl( z&VB&P2x*(T+4ZxYx(cl;w# zQyN_8Dx`=?YIPwpo{>s9Q@j(g}RKx#1|NJ*2p+uXQ7^fma$kR8S6MRI#7 z?Y;RsI4l)0p$dc6@BcoYDwL#a4qpLI+kdUi{jo~i%Xf!~a!vFkxIHyk!Iq;0!-s^7 zH`VfKtm$$XsHHdKj)c~|<7eK=(Z|+gL+_u56v|IKH;68pZk4nZGd^pz8%L(6eVP6> z!)~f^|3}kRM^&A6T}n!&5d#qAk|Hevk|N!qgmfti$c0Nvhop3OcZzfiNGdHNAbF*v zr3Jo&^Sx`$nl*onGw^$!=fvLo>{AwIjVnQYv(HX61Je z40UXEQW>OIRXzP<&7d6{v6R9K)#uCh**%y4R&D@aD`~{>&&d~4?6y&SBe;6~acPR* z1`4>-a!zZhf!a?lkWOL#GOiCy?;G!P9w}t*0W-`w7fJCwihT(sIENC1Ia3uiHL`tY zIajFg+1!cMk^(a`Gs`i>VWk2QcX%;s<$z@UEh3gtQZi#+W>E+J%-psU7)>qciymXY z!(3hcl3(=Dr00XqwwpN2EC`iPG=e5Bv+I}7mutr~$CLlmd5+7VRTracrN2%>a)mHs zoU{e|#aS2U9iuOXD(!|syOZf&ZRzjM`cI@xmaE1JuLidHgk0A!fg(|r3)`UX6IvrT zKr`QO4Mn(xP{NBf<9zk;fvJT3IzC2*aXL(2JsEO3sdjL!E|MUvyxQAqAJ1QK1;#Rl z_#4PZ%r!o}%nlokp2~pii&VP-IQ8YXGiz5fv!==S5?Pv3f7CZEuWYw%66@VQnw?lP zoq7FY`Aw*Lo71m)+0wX-*9E_Ruknn33nCQ0NO!MaTHHvn|D|d;C#dK(GoteKaoNjL z&na!Zo`8(Q~c&A!O z1er_L{k4OWT^$6iOhQMGibjXg8Hnu9|5l!r@g))C9XMv?bo!0lXaAV$kOBYnZNxg+ znxM)0jU7FS%=sgB_HV{AB?J<$6!S}X(vGYiuP3zJE4mUSLgbVx4MhxaaIL$I@d7tW zh$9Fa7ay{yNPpnUp)FIBxyDJl7|_ioe83+XtWC}F?QMljZa{9=0_(>%UBo{!0cE(nm z;r!6$d4?Y+ zuIm-NEWRrE9ia_j@27)L7(RJ7A6+aIqtz1qu9*`>Py)??{5 zmq&!|>u1-J-H+lYkKn%{ekW#s!Av{CEha=OF$AXjOP}0D7GJR_*eV`-b;1_KYz_Wu zAkMIs$nK6Il1p_dFcmefE7uW#LBAUZJl+_nj}6GjPv`QJYGKuTnH-q+h+LLt^Fp&Is0K z4gL5L1h{QnO#$?ap2AY zAKT^f$dlVUCKWdD+j*MBoY1H8z}_HM!3eCYvcsD2|pCW z54i7tz4rdeyx-{RU2-qM7?y7XA1$cLVY2HDe4L9W4L&ReNvs7+Rb0R?4(g-C zWTwTbZ6~35XBppW)Q9byB|E`!@9qJpZ@BE@@yB7&hH6t>&Z$iHAgJyyhF<*%5baOv zOCoNJRaE;dIjge49nG}A^o5;hXlg11HVtu->cN!hK8ZJ7z{DifzxVl+aB8$}3(r4x1d+#M8*A7=k+deiy_mB3cngOB0)1yRx)Ja=gPE8?|B=_H zW_PtuJ<4YJX|f1H#$H_c7=@tH9ElI=nGiUbS)%y$8wxsZv5d-1LiC2iX3-XXLjQAz zHHOt3ms8uL(Tv~;VjngdQL?Mqs40FXR=8*{RaHsBVM2ja^~2SF06m3Ls?d#J3pd|u zRSN{Vj`M6Aggy8U4pIF2LWqWkkU3!7a%~TbKS|&>N>Dv0BET;Ki@k@I(am(xogVqb zTvfj2z3aOrXOyGk0=#k1KfrY{e#cdz%FGK8D>ktZ-SN|?1Oyt5hL~Y|=Ly(`r!J}L z>aw|0No8@(xq)JUeEnWFNru+3UgTOFj1dkjk>la!$ESHfX91^5B$VwVk9k%eVfwbd z_`{|%1vRxFEcn4-9tpdi?m!-0d7-zBWGTOPSzw(pd((_{P%4-u^|rOCuB{U((}HZW z+`fLJL)3jiCaZh!kX28Hix*|)g^Tg9ylU@O@cL-MAmqX}Ouc5i{f*>{k;}bX@x@#M z>HbeYdPws9?2X%Of(am}0f7D9+XOh0Wyxe*L zz(caE(ouc-)DL9NS*4|=hQ2+px7`>v0K?cEMa$*8*ReA;t6;ABN;@DifQ(|?5r25Y zOL^6T`hE8VXNP){X)bImQ+@f&)MVIz3AmUl6(A z;)c!|RWO!_{ZE!hW=a=x>$6OTno>icr5PD{^&@=0Pq5gc`+*|LckXTd6S=^ z23{ZUg9jNoIhOz#fgbK|qHYIS;KH70#n*O_!qQLvIXML;6xceb0W)igr>&I*;Qd8r zbEatEAZV*Aj?25xg8OY`c;jVojPJ75)YQOc0vN|n7PKb>3rh()5|BG~29VNoz8s{x zFeR$5*NKoE<3@w5^Kj<;)Zk)>>Y$ibP^+O zDI*yBa_GsJ$l}Shm7r-R1fbvEx33Q_=Y!e%tQSp$|7~|I3U2~<(Z;HR?~Dwq-UabSY!cv`IgwZJf7=T( zx=ukw)%E^PDpQSy5F=0Se=9sc>fEn_-LoB1-lkW&e9R{LpBP{Ip-53Jqc9*%==WGv zFo-fx@sD#XnKvx~cX*G4TH|9=&~(ct%SUJlUVVQ2h_c&-Z2eY&VN{R|wW8_!JweqF z9PS62i9JaL97xXVAqkkdpawTTXCw>k*%`K+R|unghxsA7JM~)O75J!lM%gn3T?=i% z6WhQ(yXcr0_^@{sIx@P$=`P=YG6ZsG8sRK@S;8nu+HrE#&Rr=B!Hv6|V$z zs3D&~#+$jbeWJLyo5cJ)As}*S-@ef-P%DKwI03&C#!%UuV&3Fy>5ln@X! z2-84Md|KGXz~2*C!MB6m3qa)?_1RM6HR<2}mB&84uXVyZ{4k+|fwFq~!ZEYvFah2X z47P(W)qirT?epPNCQ1=`Il1(qmoVoFK^{^fK*9f1lM>3xVex(n`#kNO;CKWMAOGaX zfyRtSNsX~VX2YAZUrh?Y>~gd#`;+0@FG8D}SNlPV%Tg z%@>7zV61PW`*%pJApHJ)g&3j&^Y#O(gyUV=&NinR@}p1~nt*W$ApIE#KmVtyW=X-0 zCV?#u;QcNRJp}CC)L^A_6){M=QmfJAmV*#<$e}H%crvfWgLikpqktLc3`x~^{C2TJ zjOfXA5M6nXuU+k9R5ClsZmzyK!Af%A*m^%(G1n%wqNZs3E#sy+m#Mt^}!-EPDO7Lmj9)B?F z*#T(6p+UHx$mftbYT&{ju97G&!=V?t3*J83KM;cO->1}CWZx$}t zDb*xd-!Uq0xc}}s=M>j>!=uY|&6rg92#-q$>+o7h>zelrmv8y9;b>i>S|7RYMPjY< zXGO$)rqEGYfSAj4u~l-X__(W=QiABM=C|kDGC8pHn#WkOBPf8TWv_TCO?>{|a&$o* zV@@D)&Oy-2yw;g}FJ*h3)HTTW!5Hp#h%-ehd-ixZHcG;|%*~bzEnZY;BQ& zX4brGW~l^DDcStcQJ1?ICpC^&P-H;E*VRd?s{2Q-wD3BDqC{C9@a&O;<$EMA#Y@G2W`k=V>3jCvgW(Ro1_TVCBF~eUaHyS zTP_bdNp=GhTi+e~y0FC;PPf0WJFwnux7WK^AyxBSNLcs|J{Csn?rxaNgCi^?eu>?#|A}Y|1yG!3!1` zB!%B06PEcD4(bi3o8^`xuH^EZQ*R%}&u-;7cQj1H&wV8M#z4MG)4${4F&^;;g?WVp zZnNW?yeU&Zo5-C`YjYJ0!nkEzFS*IeTye#X5ad-{3s9sNxxT7yn>E$9 zrH*DKijI!KYonlZ&C_S?yeQTpVn<;O;6JMU5Y6FH5ad^-Q&MRs;lcL9lJ9WN|Mu4Qg0$=3LoN#8 z*%J|1o*49Q&R+ai#f}>-y}7d{DViCg0_Vcxv;76nhLlrV{R+uWr;|0e&t&|z>o@ur1+ql#IYas!gW++lwo?K z9-G$FmTKhcW<5KhAC~1LY>lX2XkCbz$0>!I$KB}{7@tf7Y+ zh%<-t*zRZ+_1rRW9J3M(Y(c|e8JUG25(+X|KXzP7t!E?PJrX1w)F&tF+fT@(%O(%8 z*`1oV=QbI_;X-3u|5!&LercFYRDUtgO4db6E-=$f^(HUS;TxwkYy9XAWRCBTzg$nU zQn1b`>z<+ogzKs@2bR93Sal5!~667 zp?PHjRyu?WD2o=hwP;Lc4kY}@FV1hl0`Y# zKkmfwAL&p_&RlsfvdE|3WHVjFesP+F3+>>-a0H-Cb2DzikItU_|^V0@vf2}Ki9gn+oSm(%;G`1qLa6l zaAMbGygO8_B9ypSN*C(w9g(9Bx`LF4&u%BOd%;szGHa9K5S@^u&e3Jh%l)gIr>>Bv z{&)NKIoIa}uEZ~l8=ITJ5!*OA`syCG#1fPb^t)LPQX=upSHc3BX_`5!T ztk#93pkN4?pAAfoB=#LpkIIVl;YgM$Tk_s%T6efSZXcG(aQG;-0re2uD6f3wEc}~r z{J@fG$urfWF%|YW3G5fuR#|EV$r`gtKRpzVI*zLXtW~i_;iuBAre3zwqiUby+)18o zwyv3kI7?^^{taXME={EyOn)1vYE+FU(T1#Z<*4jkkp=!xL2C{U4hWynVra3)tyYTu z-SW{X-8{J?jf{*hQfTrx*SCtp>415Qb%*CwC29rKb>HiV52wv53qAxBbUOc4z%I>w zyDLDV`cu=4m)NLc)~Vr|Jw@ zj@gLruwjOigJ(RHm9>EvakCfISFg>4#0}&*J@2L4rbH1U_)aUVdxPY$6zWalhVyXK z67i@RM%oodeeiC7W@r={8**huD6KtZA$=yW6NI&M!nYs?Ep7=b|G$j33>+1SsNeKS0f zt<~#;`|xf+ye^kx%hxY+Ip{`T>uW<297u_Gwz~cr-O$Y5OoEL~`ek{?wspGCfLWRT zRBfddn}gfzWQi}Em3`ab>((q^_iLd_l(sLd1SvQ`;G9A1e>}tpS7J}>B{)Opji`z` zHcYEH*g&+2AiGHOkJt8GehakP1w~N$#x^p^Xd-`zAgyQSj{h(dmOd8@&bhwcmVg!A zKgw_ziy=VZ&DcY6JFCU~EyI=A^Tqx6>Mz;y;#sJxYZYW=b2s@c_?m_kI^Q_eTmC|P zy@;-p<0Tid_2flvxwSvLD_YL>e3ked89F6TSJCsp{%XZES&$?qHw_tf9#z>0O^d1^ z)VQeg#M#7D`Q&Wa*yXL~+kv5h%y|7osY6m)hSO@;rOAEo(EGXlHwwbIHf*JgH+)Ib zlh^THEYP8ss@*omLkM7-BCLK{J~$y1A;oe%{zKsLN7^GhH*NPVfCC`F{BQmTnCIRI z=PwphzPC|b72Q8fxmD{b$+i}41s+JIo`gDQL#qRBC-!>$p(fNg+$oc}BBc#mrXf#8 z9pXKcnk^q+`xQcNlk|gO;rgHI?ip$HK;Ow@>M54EzTO9HJeFQQ^4ehuoK`0+;hcmN z*#6xlg0-0WZI~NzdoDD+TMuZMW=XOJHxDGn(e5o}B9nmFk~HbE7oB}VKk2OR9zSj( z#UHq?%^uh5b+WUQ>4~=C*XVP0a#F#@hKdQ^ZQ!_L-4|~E?{IgnU<&$UrjM_|;xm() z$+l`MN`LXZLS4r5%{`Y4W7nx?MARgMy))8vO9K%<5714|&Xfk&Lxa#6wbQ!Nqrz!x zi`9vqPQ#w+KdeHqrk8p@4rKl0>6GmjkE)^GYSL!XIJLiRW&LM>1|#nDOB5WdLc&j} zkz3TJ&^&f8y*b2SiLRI$+`a5GmD?r8!@PY%*(FbcJi6^{sK&OK<^_Mwh;Q_CRN4H11-xC$>wGL?BELhvi1)bu7<2X9wdF?OdHtF^El3X zHNob~FlX5^BVC~J$=!qb@8?GKz7Hy_F{4N64U31$)%H#LMXrYXk4|;k(Of$i{0d)~ zconcdySOSP^TfA^QigZiJ$#kUQAm@gKZB1{XyxyfO&(YpfGNyE}SE5 zVfsU~d9xjvOoEDWZaO*D?^Nvmj(J0()#@c*5@86I|0hef#qQ>Is~AJA)JMa0uYS0b zYoOgCtzX{I<4#b3v<+P`pvg10iTqh@y+zkb$N6Q)Jw(#FV0VzjN#@LEQ9MO`pnMLQ z<>WJVOQOGWntT|5#MoPp5Zo89?Ron58TMNt_vASoR}m3z4uPwjp;15a5HfD-R*FGe z{E{xu?Uz2DJtFu#qf>e7eNz5I_TT}z(UP+^pMKfoi-R=qu^y65mQ*y2gpeB(eNAcE zMoVOQl|3D?(z#X}qE--%|Lki7TX7UFnLNMCs!tkGRu)F+2DidOVziine^LFtM+6(I zeI~etv;yM(I?)QPI#hXb(pBR1@rpAK%&w`8yO%dnLa$LXZOxT7Fl5PB0oed-#mdGh zivv&ehtEQe-65|v>37-I`EH(o>?Xt53KhW}^y%XaL6z_T04b{02b;|&7pM${^2G`A zdi?UrjUb3#jjVWxa|6}>hVK@76!DRf(;S6;fLX)CKJctm-D6WXAvs^Q^w-C5tv7jR z@c&T9XwfOTNly=ZZNXyn$GXF!!{;xS0!+vLeSqC4tFpIs7_y=4AaVb~1J}n8QC_pnHXN?&@S)6II&Y0QPg%U_aQI;nn#%X1L*@`gYJih6#k)iSAHfzM5p zNTqaqE!b9W0aZk-2niJb`DH&WDDHXv^$VIgc!btO{iG8u3R(iUcJ}a*XpO) zp-j|ylQ-hER&S&CaEF@M8v~*ib6g)G^9KyghG{8CW5}Dfg>Qej(Vst*wa%JSnyn13 zeO3hRTTD}bEv8Zh9uXIA^JdZS=QOyhYjbPrW>`hJYXxVIj&uy(x$B}&D7;?Q=}LhV z5B7r#_z;A^_EOM8*w#&TE^QYa`0ly9hc2VJX2Oy)MQM&d^vC80trS_`2vn84rWIT( zmH11Cf8NsL(Hu7SM>7dMpuEc~&igYdp6jZZWNx`3O^axX5*KaQm~Gw&%d?`Vt8SVF z8iUZ&48RQOo{Qe;)JtAqZNmF#?$UoxOZsBY?CrzFG4-NRwD%~V1twB@H z?lambW<$1|uEvhN3f@h<%-RWDiyVW?wVMp1<7KbMF+Ry!2|RtchH&4j4ZL;ggQq=L z|6e1C3Raqzf>er#hUmHy{mIaEE6U?#uYa|Aa>w!OQ;*p{LbJ?61i4FONwnYp=+4{S z;kqM6fry>`6K!wf{2_ppA-E&QtAR`qTSfhV;A1>qvIhPDg?M`Kpunn8tp=;4lGo35 z2SN&i=QYRus2*%}5}fbWHStP$7(`pIpu*T~%vw3sNDPSNUAh}=Z&mXggm%$=W>DX^ z+3Nx3<|-2A&~SCKnkzx!?n%FOje6)5)SAbqHvCVjbe?X#YSK61ODe!JLZ0ej(YUdC zP&AIUlu4*LH*>AU55`wqWU?4J$rMdCl`e~YwIxBbJ*#kb+36wYRSG*P4A^g^QS=m$ zrK{6`u4t$V9XEd#q}}gR+gJfp2HPV}#b*7oBKP}tz6AYsdYeC+c=kP5 zhO9M4_X-@eE#lfQvzj#NUDB~1al*^%qb zI-Z!xlF|{4vXe!gy4+H}uiu6Dy>^r9-Q1||e7+UFx0s?&?yY+kH=BDDe>?wFU3@ZZ z8wBo=Ul~%q`V!=B@<@C`Jgyz@XKH59yZMldng|AXD3~`;g1v6{c!Inn(v)pU$sMx2 z1TiT1?Wm>EQKiN%m*fAZ1$cH3E&!U}{a}OU^8#|-8PIK5Xr}S&o}JnAlGwyjC45CK z>M;>^9-=3`Y-)5@7_z>q|H_3ds4wIXkjBg0OLk6}%v6keg(&@+5j%3oE zhcZlznBhdu%i-wiZEA#&xg|zMt%dM$v!WUqb0`@eQ#KDk_Jz#2%@0$QDzw-_r-tj3 z5-S+t_UNfY`#Q6>6vgJkILBF*L;VuXXPe?1fGkzRGM-iOd?S(uMUfFdb>U08nS<@E zt@Lk@f5zCJ<3tLFld zIj_GX&h&r!IE#>|_3kZyov(>Jdx$&vQqYm%PwdQ61=pA1+Ql~+`DV**!q(_-(}1ZxZ09}HWj`g9C; z@?Bd4qX@`$9~c>tg$qjN&fBYQ?dyb^*T*gFm*L#Vd!nQwi1=ngGu*02jxcv%nr&RJ9Ml=S7{ych>gDXok|8v<-1_RN&V~*{4!A4qaHN7;+f-=wseX z91AtuR{ztwp_l0@%z&c$h^9k20V8{s7L;frzuyb%&y$YSn(4Sic33 zmgSDDsNNnlLPBi-%?gsqH!MX-dYz~5!(-88$|4TdsMqYk-#Ww~D4yxiiN(^kbE`t|k;-<($! zFx;AKTbWslge)2m6u9BFEpHS@lHMmBI;3>?eY*OP{oYI+h4yk z(iHaIMY;xr`sf|Ir#}MY`uIDE8m&ZPmZmsW`epPfsdZC#Dx>KTt0%)Hr~)XKSB7f| z&P1t+w&&XM(1=lSq^=U9WLJLlhC|jGrC2^O#LyVoHU7}V&mw69PuVR2MzxxR_8%?{ z&hx$T-6LJe2b_XFrGw^`fjT9*nXK`oZ1i_9eA6@B&*Z753R>H7be+yB25f_bX=)p$ z*>Ps)J9f1O%*MuL(|g9Lh2{rzXUr=F5?Su%9aK)gmy$TuEgP3mGMOkvteo%?P%vHP zhx}Z6Yt`ETs5nFCG_js*tTR-t-kqj8e;;lx=e9-9M?ML|_O zbRoZ5UQB^WMEuXf0zF^S`{N@tn&Bfylo;0?etQp(+pNPNIt4Av&QW9UonOV6&bo_d zrUn3vE;}^5YU#Pb+n*D+)WA;r=4VUJql5$DW+qHG-E)N?t=d?GWvsQy$mR(9z4aw~ zx>VlpRAbjpo8PXS9YxNxbbfl&`n*GN>ep?dgy8=ku))k~6VJ$a4!m4dS+QsJl84Tx zCp(z@ip?x~?Y67=so1XfnJPBuLi;ZBiO;Lg(=pRzOSh?O)3KK%vBm_sc!s^5{iShK+uXr&sA_Gf)D!0OrFk<;m))RK)%Cy1>)YA` zfGz}6hycS#O-qv)BFE|6J^GvfCcafS@w9(eCajb$oQ;AIjEA(!#<$#VuRGiVpLW3% zFeA9NZO< zM=Y<+i3)N~HDx`Ae0Px79!AKrUOe9) z^Y$*3$m!E)bM0s%4TbPSYW`acD|E4&2_Lj_8Z@g9C=Lpfjc+cM#}KuAv^HKjyB{Mb z9YN0BaFC4U;P+VEi%^@B9pAfS9+{)I(p{4G8af`qM*QA+TiZHOjxWs3WB$4FJb_&c zTu{Qo0mBs!N)1o{zANMEk?_PN?>FLion0c zns2!(c<++Y$p-X)@90maPEY{s z{j{!WH?B}gXhQbkicq~;NGB*Oq3*{ZB7p|$-PEoscij_#TIugfco4nSLyd#RXU1OT zRFB!~0oz9}Mva3>OG_K=qh(I9MtV&({d=|5$4RTIGY~Qy*J-d8Ja#~lWBacK{LWM5 ztkhy-U8)dDZT!}E5`Cth4BJAG{I+81pNy?r8Xx8jJ#RBUI;L1oT&#}k`}Ts?=15ih zyXtzQ#uB@H{U}G>fyZ&J!r9=hqG$J-j%Vm=1esGQOZxr;rtbfIrq7-BFg# zHT-7`hGT87Z}#9>e!8MQRBN~6smNWI9^9Ep`f_;s-t8X)7XEC<*Y;FcZ@*M#370;& zA)c%Y(CRZ{72g}k)}BQf#*cud!n1=Or(mjsjI&EtN<03ERunFULFO$t^ZMnCz%H1D zykMRtELl~iHV>XM-t#(#A`_<*Nj#6rlB24?u^rA~J9$7;iE;(#7VU1Hj4wV4(9fyb zr>6ui)Lqa`0j>++LT?>}d5~y>Ar^%$P}do?cugdTxRQfyL_Eu!A6q!%Tr`foZroI= zdP;Tf$}9#2HE&yazR)mp4<_QsBYJmel$P8kR<81m+l>EOea2f*3toW0@jI0kvz##l zOYpuPBMDr?*nd3Eu)&ci$hTjfRW@HDBO<@4er!Lo+ej~VLH%^nj;~b(#bXe4x${%s z#KX!ItH5b(ZM(td!A?Qwbg+@as?cp5;gTU(M|8Sp$jSK)H=Nx-;CpsU9EC)i2*=62 z7I}YeQF*$X;XcmdI#tkMvV+jBe_N2ICZ(FOS7Auci!c9iH>&M;I&99kT2ISNj8vlf~JKw#_u* zAdvDXVbzV7?Ke69`?vUmDFZX@KZ^zkn!SNNzqMC(cm%A`$e1qeFt(v!lx&4!>JoHE zz^DUm9MZL*q6=f*K5O+5XEQ{sY!6ER%__k|ffV~V0|QFZ!^38Q0=8U`4 z5j>2;f`JTd(XC%mMBQrvI3u-FX_OKFs-&n*J7)&xCzAZ2*tjA1JI?{yw z$U`;A;}4wC;T(XRpS=H~YsVO@m=L*i^AcD>ppE_DNKN# zde*7vQP6ETG-Ti-R>YQsQ%@uvNyxVnH&SxX?$UHjNo~9qcq>WtG9i<>^pb#mjmH#U zBV)8uP>Bq7MA-_j(h00qlE@KQng=|gZc{Wq*ic^`-lluc%%ck=BYMT^Pm#fNZq(ta z|7x7|EOu>4E~g>7JYEdY5~IqA)@rM# zgVvQ3%=tep`6xL%Q6icyIJG8KiZQQp>b(9DuaZT| zFo4m!je~o((9Bfn6nygAahn!M{x|@HC%F94ynxDh6Cg6^m`x(M3i7+}vJlXrHJno) z?bP?R5uN?!CxWWln@(k^!`&l5=K@Kd1d<-B!?wv*bS1qOg3|a}ffcOImJ-utj~jd8 zoSd_p$SvL_m6c%|lC^(zv&@oy^W3&&=jPqbFRGrqEBwUdoy=t*IAe20nrpI;%p0-xbETck`koSe~6=(^}*TEu}|@T%v}(-qWrg< zt~<*WSJjYW(Zj(kLk~Ka3C>&<`I+Z<^j@k;qVcVB?Dms&jlFffIipPZ&;=3XP%}}k zMtF)nHZG+v@Jt~JBuGnGk@JlFtf)YehLaV!69{{fVOtD>xfykHJ#0I}qG8&Y_a>$% zR;RMEGRW`>ZASb0f^9EtI6MM|XK~k=?b_w<)ovOgtgnPs*^LQoB6WW!e{GrBoU3OC zz!0VYZR?VQ$e??GdJ;s1h2Qm(@q=l)!~uY6($~bMhNo6ECTG?^yw{)U0xMmiGi|Hj z-O%4xbUurpy@RKM8oY0`$S^4BNGNZZOZ=HZ7SEjflT-_FN0qjqbXLb-yKDW~00tXZ z@b~6Hf`wT8S&LvLHpW=0232(}SQ2t1ob6u9t11_iTW~PLpb33uGm}w1^~XhSSmJ0~ zr*YyYL<{rSfS*x5Xj^{Y)zzgXX88lJp8On$SJqzzy6g)~qDQj%X^w(4Ks5n)1I&YQ zl)^YJ`SmI`dCI@?Kf;Ee_S^Y*;K_8Ap-h=r2(QUwumtmg=@9ZDhgS|ec!sr5+{3Lf zm|wAh9ZA;bR#wv$t?br=tQ+&6IyrcQ8Te+GIF-%%?!QLYU}onO>f|h_leJ|-nF#`q zNbbQVn)GMP6l8a}wgiH&^9wD@$rLnnvfCeYJM@IiGRv^h)3FCO&+aHH>9LsqNhKGk zfXD^Z)ySU}KKkoQ>aC$0suNOuAK-;*{KlD#$2E`ZL(6coqfguyqpfFom>J8P3*CK* z6>;bUnPHySMvv;$-GH)Y6(zXp2$uOc@(cvTWu3fZqapPvZ}4X6|KWuv*@(ZxNYSiXz#$L)6WCVkpK*0gmNR3^;7ooT`F zph64QuBw%@y`m9B@O73fk1GlrXm3m+m`j4wM($Lg@_Q|pc$Xr4PlmTy<|>-+t8$;Z zLl`)41M@U#DO zoA`ADyIhc{tu9Si;*Q(TIqSbv={Rr`5)$&oeIb>l`WqvWD9G$Hr-%FbnOpZdV3Zn+ zc4g!0OILVW_V$(sBe<^RP1Ts)j@qKePg4#_mr?&7I>~lY5;8hhCGTx&?UVc}_u;Yr8$)m>gjsd%|;uY{G*8X#oYsG)usA^uPAQg3ysjY!m0hrwg( zGIMZJH{yZ{x>xW$e#0eeByLvRBSlIOQEl~Hm_jDM$G=vd0rTqQt+8iy9Lo?XL zpX~Jj9RVB?{b}g{u7oNDn-f!8ar0(WCL;nPst;@4kB5L`bRT7Mv&I17DxED z$j;j*+PGEewCxIA67g@(xS5~fbNx^^TPf8MnB1q)o~QzchUr1K*|RhKFF)p*p%4Mk z76db|%DZs_6xUz~5$djK)&71KY+6fV`oP*Zro1?lks9BXsufe?js+CLix03Tl$9|* zGmcwN@wLQ8PPNBjEU2dp?i`!yl!ZhOwlIa+{b=D*tbZ!=mk&u^bA+e-|IxdqBy5JG zVp6XLf8)XE`ZJXRUHt~ukuYh1DL+J}o8FX3cF?A1{%=>n7UQV*7Hu>)0@2HJpgV zmW@P}lBEExF+Sk9V}CR6c)a-W++T6hCJthM2?&U2W(R6KP%U8pZ1D(#PdH)uZrvdm zG;J%W!XOP&9C9`gyM!xP~iZIkzIsFUt1xc+Xgsxb!%~dYuwhtzs&k zg%5jfA0{lL8@_*FgTua5vut_)S}+vzz0Un2U5!(&B4z2YG;xZ9F~M*R1Yo)AF+Nr< zZ-IgXiGSiQZ3CrBs$_0KW7ZHpRuyXw2Z&_a)|F)QFepg6Y@fKsTqTn|nT-{LLcPJ*i zq(e_yCanGJ1!nsD^VKPn35zO9S+^d1)BPfQg_^d5DT)9pFi_ceN*J8{Ss}kTY|uhL zPnkT^KBppHO@|NG44|kV)v$SdpO#~`awKW~kJTAFk<=5(yIZbC5lsLFCO3mr1K5bo z57%i-nE9_uU>NC$(tx&y2zJ=~hfAa^LE;Wwpo0LfR*+w;BQ?Mo={^3qH26f8szw@* z0U7?C;sy!BjR$Rfaxd?{FwgcH+&S!d{SGD8cV5T-38n1{MIX!TuM-jKF4a!LJuApQ zedrzhL+QXtasJ|lnFQpQDWk`mkisMAhq8GOgsY7J)jng#-2O*8Xr9>B>CPV=2~Y?` zTqBXU7fcz1oHYKZ_r- zZ^8Dx=)QbH0$=op>?ppK?@!j#Ui+Ak7mHNQU~DH$<=XdpsJ4V1Cy6;;U910-+%%0h z{ie=F?|*N*_{|X9bvX zm2|%kCQYCvXO*Mxoo3PVMA-|5W_fa+JZNJmBZU%8+(KWuda|T9`l`2BN*9i%;LDgL z!%_QnjfWK>QQ_yYA1!qxf4#>V_z*0{d8qoW%Dv)Te_Kwk}3GgrWihiNd8a*W+rk7)RpYtdWtcEFEmF$^J<#sVx?tJXIIPr^&Y!N@g#@3 z)Qb|-0}D@rlRv%&#)+&+@uyW9tT6F>aTNeJY?GF&HzTM^Q0_mI-0HV8Z_Eh}MWdNZ|YzjCUOhKWo4 z;(5~7d-S(UA3V@9XH~DadsYodwEqtWr8~lPZ~D-- z2(cILOerQ7HQLo_eqE+-bCUS)dwvW44n1fL`uB-@e!d>Occn>X9w#vpMgP^;D&(aX=yVI1 z4#8w5P_O&@IKvZUdUW`JfL=UX#(g1TcuHQix*IBor9&^7nG1XnN1`nft!**{)qX_g z0_~m=)IweS^xo%-&3EvZ20+W$X{;)KEy0JC{!t`gRrjYv6726C)J5x-;s_qO>PsRu zSYt>?_ym|~x>VgHHa&h5gJX8;l3%Nh&P%2+H$YJU0okjBY6Gb5R>rW~bDSBvQ|>}z zZPZL|=3oDVM!P_uZpfXGe=0uyNc05c*Y;phUju4B8|tN(tqepIOSS^AHHzfP3sM=Z zZ%`dTCpN1G7YP85n_En+GSWJmWT`(pJQsdoqSS3#G)Ic5j`U0{d$C zsw4#i7v zr^x(|733(@+`vG(Y%oGCz@t$bgHD`9vA@ru0jPE!P&-F2?4Z$?U`^=E<^@U1dlTY3 z)O8@*&jeypzs#ggD1>pOf@NU$qxO&AKG7?#;n+8JTP?G`94!2znIP zhUJZ#vopl^>{Y}iVLfK@3U%*aB@IB)i?w4S;!y#zLIi zf!Q*nRc8}?>3wcNu~(;_PIEBl(nMr-<)k@m+o@QLYakCU2pH7)`}>Dy#gkIlp30`j zw`$fGJWBZ*;S=v83K}4|M^G$M1|qtn>i%*Q$NOCWrzh}IkNzy#Z`OCt@R#W@_Tce! zC#$$^bo&Eq67f>$$0kQN+*+mFzoAmQHzijzY}h7y9kzsTJdFCRXN5KMH`tR?}=G>o!TVL0Sf@aJcE)X`B5%HPh|8LG)yoWJlr{`Gh0@1J8 zITVpx!nTh;Q+Km{K|Ivc>2dh*ey2_C&8_ji>TPkg9;fI3(*mrG`ctkn$4=%4mj{RD ze_WHbC9hnjuDN%0a3sT;-7z2qKxsk>&7!B^9Iio1YROc?^B%ue(eRA=;qZ96e6B(6 z4V5{rO!@duu+C-yVhgTA_`nk7%XO6Ce}d%R1mJ+!`UokxgS~A9)1$glN7}p=*o@gV z9VdFmp@fE!6oIFjMKL$Em?;SVVc>yaK_{1!c?W?5LZYJn^R%^BeYc{89AGL200~qRd>>Y6T7KQ}m7Bko zoDJr=ejy{Ut1K^%pKnYzWaVQvDdzni;bk`-+03>}nprv;z@(VKJ8VGk-x@b3XGXh6 zxarI=9^DYYAg_5ZOEUdOn`ZDs37KKugvhC2+ri$an4N=TmjZS3OUSh4N*VSc(IcOw z;O283m-F{8Sk0CG>*4i;|CWDhCoWnfcE@yEI~Y*tx(Ep@1hfF4gdOBnox`~UKychQgSnl5R(im5C5@AtiCDm<^A9!;mu!y_N1wk@-}<{Fw;cjzv?0Y_h4xSy1L$5U(vP@ zsUQ(#?63O79}oQI=_knptl}ol{6YP6=}ipNHo?cvpk7k{`S!Y-c&j!u1vt-*HqG7S zA{TR^LPr1TH?Dr_Z9gJn;(*j~EGd}Yp`Ncth{a9P;WZsOPvokfg}shCQ?_nMO=6q- zU>R)j%X{VRv7>#?I{A)Z!J3-P-(U~dtZ@F|Bw$YdO~5FS){nhqx~K#MpWy}?$bL9X zmW5J}?IYvN!WwT-F9Tx$19OuDI~R=_x9umK`#F_yh61ILj>(AR(BK6+OJRFq%Ud?T z8GmjPZ(l|2lNx3t56YLRZ(|XBS^1fLS#dx#lswE#N2T9BrVm}zsXVnRp`Kym-X2Li zs^}IdIkU_TyzU|NbZUAZp%QzEuD`iv;uxS!Vq$yxUA9GyTP zPREszkK+5Ba`}S|-TyajZOMIn-~oAZH+Hb*7E*au|!rFthWW%_hvP;Ttl&8MB4;9w@q-Yg4z@&qyRp?7+dq~X>a#|-6wOp z(PQL#L$)}-4*UEvTm-cx}eLcIjg*KarFUN2)zGe>N}vh{=fgtj3RrKnHjRPvV~-avS&!y-d47hnLV?~$|ig7O-3Pm zlO2-%zxw>X=lnZPIVT6_HJ<{zxH^*k*O~wI=%0A%|7#dLN{pP`r9@b7BMUg+Wdu^@#P0q{R3LLSZMrVYxHjxJQFb zMPNPoAP}1Q+hU_#q1>i=Xq2cNHH{*~k0S2RdmWEgwe4DJdFqB*vG(tt$*Fy!>}mm+ z1e~3>@Y*BRNB^)@1;2Pj8I?0Xo|2jMFG#KGkpjMb~3G;$orU{kQmwK;RO< zHkEN;U|{fRh`|EvZot7bUZ3#^3hGHcF2c|88JZW|-Q3-8Q5G-QlGS?2_!xWq^a2ob zjdl+51k-bGpO9k(V0lc+zTCpXc=U2v9u_ym{;+rR zURp;#aT95p_)2w|dSkD*$@!&(u!l}m(YV|c)p5#3#jK~VG2rQm>Xh{=INk%z2%7aRIclgVV@Ksz%>UGfFl>xB2gCyo)e)? zEU|qavI_c|_YkKLj^B^+=z|mCFW*@J_V9j8Qnpl?t;N2?Iug`H`#?BsYX{d0TkKaYsbt-xCOlH_w>q; zqT4irJhn=12Qg7n(45Yh(LFsd}~(Aj`jR- zyljShP?{7&mtH+0T-w)8Ql!$RMwf-T<6w;UNO#ApMxQW^%k@+YVezWf1Q_lQiT-PvD?)mHrfbkhgA#(_KgQsn<5*!aI}JB3|cc)6X73~>H(zBIm)=cgUT0ToLz zJ&Jd=KL*y#zuy=r%LtyuKFxYkRS=C9)41zjhMy4JyQmIzeclPrQ%1s=#O@wah1Hp* zInQxePcmzVrK+{prvd{HxA6Q@H@k0dcVI*jq5v9IY4JERFxmOuIO z4n4b1rC>G*s*MT|xlz06jf4>nrwwApE6R%?==@a&G*w@DbPlD0Q?tz-P#{ zi`$u4KsPg}BSSkDb~C$_zPfYZ2fe~Id6Re+tz@#%$k=>C6m>#i!j6UL`$70glW2qR z0QZXL_|$!5XMj>@s$gtMV;!==>UOS6_JyJEZgE`FJ{W1k{tVTmX?k9L%5aNE5`g~8 z7XeHFSURDQE&pLn7a9xkyw7AdzQou9wv}HQmP1e9l4)2Nsh58_DuX zG^FpcOZ3O7J2bJJ@oOO=x%1wPLtGnAe}tK;|Jcnc(($;fFfvYyk%ch4CEnuPSX}2{ zb4#D;Xr+6}xk&0XdRr9ZmV5^#D(*cwQrqdu_0%x!7t^~OlP|7@s6pvI{e|$?HkG~2 z;ZXAbIkxz}7@RNVaLk}(+6&GPT{(eYmJ&2Gx-9 z&#!()5W4?0Jag<;+(6&L3>mTrLlBN8QykGS9p5|%9}VbZ>gVrJa!JWCY`b3yf>LfO zxKI^gm_ctUKB3G2p6574E(Tq+Ny}>1X{jjh#g@4kAhww(YVZU>y@Pjw3-?Jp5*Mh( zpdEsY0ionj-{e$L56P-2>73CP&!%g0*Jka1(h2zT>%Iq{0Z{Q3l+8$XCz21*-#&2H z1i9|CCrjxT0eECr1GD0hPOYS%p#)7WkaBJ=qN&t^SqbL-m+X`k(_O;K@x>32ZK4tU zd1w*3?6wr!w8x3(jk-lUZ;RAfz69t4xN+MPYb z9m_`UJWr;QPrt3y?fAG**>m^PyA0Jng>u}D&t^?Vbw|i_o-$XWRSDx!xfe+{kPP1L zTrM8l9MF=w=rHXUUN)$8)BMBhXFhxGpH*$pUzRrwOXfRj>18O0DS`i;xWnJK`u-Jg zDk6UgKFLTdGOvG;uYJGq!<336PWDMb9To?E@UE?%xIOT!yoB{BsD-BO(n)S^O=8RN zB5JJ6KV>DqXrVC0Dqo*icMje-;K4!o!t~DA_tk1%7PR~w zH6W=1s}^L@cuR>baKF3?X8D%eW+a&J4G{Vt)IG4-^Izy0V9@4SP3;LQw{Q#{5ItF` zUH&{ft?nbl?k7_r2isNiQpz{3Rfio-G7yU@3p zlw_vN&xMhJiFLh{wSimaUXLqTmV<7`7(k-TltXU?yivChwMgcd(5Qw)v^E%b9yjNchIW)-|OD>XXh_71?P zcHoD~y2Uyo-7iXa^Y2FO7}x8cp}9w&Rf#xPhX_8Sq+Wd(7GoXH@nS04&fX4qt1J}D zP`?s#!;^imhZSIS9u|)HDPU$t&6RyxYuN)oAzAZ>k-1E5l#Qoo*gg1P?17s$JL>s@ zShD+u8Ci_9;>#f5>kPEGM}N?7+=xVq+Y5Bfibm_U%a9`dOQF{6R1e)eWh=sDm?2-D z!%%jduE{HiK4k6dMXvu84W=Y}%h%0FI}$JwI7xDpbxdGkt&NiOuo7XXSBL1bJEH}~ z^)Y~55_&D6?3^uD6wHKo?hil!0wesTRB4huq^hU_MsepO62)m7NRkmk9pIiq56A+_ z7Up=^+N!P|xO?{Z?>-&O_YfFtU(6udVLvhI)u7dmWd{-pT_98=RmT{h9)SeX_m` zuiy^JWLN}1X?nY^$c>0$K|txHT`g}~_3*3QbNne&3!*sx^eqJftmUE0SHaVvl@=waVsXA#`(E{%PwUNIJw-R!8L~! z7PHdFLi6CM(<%ZRrF0-99|(k^PF05KRx&ojn$(VgQNhP3#;hR3JJHM;tQrcDq%HoBpXBFBg z%AK#dijN_IXCGxh|5#GCMofu#C{94{jbZr33nA;QrPSS?3nt1cRh6m3(=ku$Q~f(G zN*lvG+-{oI{+D_uO^7=N8S+h67)>snsps~d!`%AvHhN!oo?~>B|CcOOD{`^jbkb!| zixtru)M)nKi%*aw6Btg0xpwkfGLcO`nhBF$O16hpFw)O z;|yMV#%TOx9t?w^uYei>2~hCyFFNk&%H87eH|Q@8xAgCC%%Y06X$yMH(F;!4^@@ig zuzTwb^+zYHMd~0b=v>RJlJJuq-cvFEm6~D$H-`RW4+Ec`~0iI%S4AzbSW|NK604N$xvSxtO`Z%(R0E>Dx3 z+L2$L9OIp(Q$3^&GaoxW@}R%Uj+p1)-mg8h`6^GlzkBiV>NsP!DckdrgCz3*>iwtZ z`8b!CUT66nGa*k*0jyUA@a8T|Q5`~u%hbEsma{OsHPg39JhNs7U`BqN-3Z5MtAdVc z-QM`oic}F1EzZKj9E;RXqzZEUU_A+Zub;A(=aIY|6n#%2AUGLp?;UDLDybq_DpXCf z_?-Aek3wPZa7I!rd>O^qSL0z;C5y(#RhtEZO?rMFa0)_Wrs&T>gk4=%cb$W~=kg!4 z0}>58iY2@7ofmot;^OD5F#4cNzN7Kptc6J&gwSC11tO$q^NX(;JP*M50UqK)n)1T0 zLp6esVmbWeOSVZ5rhl90!!^pyk(R8Gnut==-xUaAdyf&*0$HB*A|vaYUO#*Us-$cA z642rFf{~l$b5H%t9VRtI2yWubADj+t2{!VtKob}Nse?CD?X=#WEs2*-hpnyODFOVZ zx+uTs7*zHLD1W!;S3OV!ba_%!QY6Q>Kr`0!(jMU2 zyh_3v4V}bi9ZixLIx@4=FVFLtkd1>-nSOh=AG|}wL4e9o=X;oAe7}RF*>tw*&v>jF zuj0boqo->n`s)K|u1m2UyBo!sAQp^Y-5s@T65jc(8@o>+SJRvQCnaB=X5Xo<3(z@F zSG&9V@>ji0PI2eytiNQgrhB;mkEK1FyJ#>ls(5N{@ABqi)u!Ux#^>OU{=;oB7TToI zKk3K7zet^QKweE+5+RHi=#*lVSWyb)uaz2WVq}DW0N)1V z_jL>onD~Ke0|_(`^~@x}F7EE?YtNz22S1aGuqaBD#qyab6*aX~8i1rrD=X41thm-8 zT_(^rLyj9Df5654Z7fcU_3MCSsGyg~D(_JJGVMHMRw+}L?%inJ$Kl49Se}ncQ@~(5 z{hj$!%A5hC{jlJbU{>-wd0}%`_R^2`ubVcgGqE*w%T$<|U%0@Wr?t3Zf6^UD#;_5p zgc`JB&yh@NkIM$qDO(EJnH;h(p41`Ytt16T*$%3sRs@nda-Bo@s6&lZku9|P5<@M9 z-oQGXf*bNNn8)9Fg3}ba9yq5zs0%4c51J)Z*_;09N%9)4g>Ep4vt_N}mS0fVuDJQd zY~^gtjcBo%FpnJi^KuaieHM`|o9n$7k$su{$o|NYse%EAH`HNuvrkFL*%7J0Yc0v+ zI7_ens_*I$Ye;#&)WYCt;dAn`8m*}Qymet#byus&#r2ITy<78!cCdj>-VC}6&*(4JAzW+TD~ z$7GJ=wKzATZ`mNxrb)}Km55fiI&qpw;C@Xix7Jq%f%Nc64Ny4>{#H|9a~J$m1p*Lp zrJIh>?%PxKz6q=k-LKf$;p-t1!^a5nSxPcKsd0$DL2}l3d)!fK4*~KUzQp@+teFhU z_7q($2L}$XNZ{81DlYGaM5a2RlVrCf_nCo}-JNTC(G|DrSa&V^MZ(ZjU{*M;LQI!a zKY1ZM4rvnCO2cMx;3#Si^616cIyM8hFepmGOX7LLJ_l<`Zu6G>O^OeE(@k_{sGYOn zsGa3gWDHg%$8@K11 z&2vVsBN%eNx`tWMQ$Jm-l&~SqaVh_}R^3gno{`V@)ZU~2kBF(rG~Wi%SlrOG_N67t z3Lq!gvWDQhyN}epQd@Kr^2x#vgm=Gm@yb=5eM4L_gm#TqTCMQ*uh@fk4VwnV-}BEw z>J>#pWfHE-|Fi)5$^}*4XJ>A_i36D{j4jxI!r(|%8- z;i09s$hR8LsCrrVw?EWvm)lgb$2ZW)eq(qiypR>do0TikrpcKOH>R?5o!>PbJ6|1U znAT@s{vvhhZh%%ld}!`}t^U~D#Un3Y8UY)b={KAFmo+4ptv2Sa?Fkux?eRYYY!69B zM(MGS|JR}yC(RGiLy~rIbV&(NF|BS=KU*jGA??!pXMJxq$&oOLUeI}b^C%*dyAU+c zLX5y^*6?Ow24$&jj2&^}N;)%re_f%H3Sc=H4bU2dhuorC5&v$z^YtK||9}V^7)+L+ z=IhNPB2WZ0cuPh%=HY^2(-32$L!F1Jz)n0rCV^!X3M?xUYAW@qe;X}0rpCm(;4;HR z2+QE%m4k=VdZ6cJ#%T=z$othr z@y+e(vZ1#MqAik9y4kRMOnW_LUlij8xizHRp?`^6VM$uPsEpqJdjkLOQ#)^2l6UkJ zu_c#82zTr0k;5IehmvpZut6zd~K#AhVa)3W33v03TRyixb)H3M00 zWrHjRhNKqfJFJw-z3QTypqk86haUtBhQ|1`femq? z>0hSt3rP~tK;RQ9AP;+M)^Z$me{i6Kg`?<_M)N#qv7tYBX>{V)%9t=hmx;X8+8?Xa zKOS+MAVM{It88#tgHMFO-E?h*<`Rbb8FMH?;O1Cw{0iwmcRoTam{i{_UnD@N_=?3o zvh_(e&57B+hBbGv|aZq#~X{KuG0dP7#eo%JTBn2wBNgM;qKNtp_edL7oxuB^tgdml=nGD!6 zRH|uMs+rq(0H>yk1p8_#Ja>?uh==xrHW1;BV$@wTwGGJm=X;!(od87a6O_4-7}@=c zn!sMfXSQn&c&8R?nrEq(;>-<8fAF8L*bBzwu+XtDS0bloJ|N?e&`f4*<5$wXJwD{Y zo(%ba6bkATGGk>cj%qusC?;4DM^?iv+xLsqJg($&Mo4-J)TntRa&QuB1sj=uW& ziZ}Fz#IkG88R^gfU|uY?8191)ZiwFg(k)7l;gnJN2pdlxf9uzKoQ)6TH^-%0jIHYs zr+pGQd2fjFN2^8;wSN`rwcC|U96Cf7kv~l5SR&F}vZ)cfh!VVPx!RlQ=yQGG5txfL zA8W2O^S^U`)a%ILa;|y=tucR--z)#U*T&Fsq*(k$B4}~uR7Qv?7-|C@1r&0h<*7#} zvOb_+eaEuk!$!nJ3-4Q;*@UV)C+MfsopKxr$6r5O84+3Y@eeJUu_lF0jJdVV|h+QJh4Yp%a8{^jz5hAu<54-JcL z)v?fj_qzT2tOrw*s2Upy#J6dru-mS80ie^kd+mY)zZ{VI^CR0%MpJy(Z9h8mT$5LE zneM1Sz5m`;u?odwc{*3B{psc3)w?ej z#MljNNUOHT-X!A&`3wnGoX)>PQ&%lA7J7b^dk55CnrxEfzlA7P-)4{IvHamF%UJX&` zc4ly;>}6N(8kDSre%0A@62(!rlX&6A^zL7D+hNC1TMqGM@YVU%>BvC9Slk`MfkVgZ z;VzfgT6lwxk%F-sy)|4@MyNgT_60#R@K5O0>n@8@I~6osRYr9)A85X~7gj}mLx6Ej zK*4!e@U{rr2Bf-urB?jyVbG#hTQC~LZczJKYeqlysUkmv-lsL+MJO`jP19i^II!eO ziEwQ{XER}E_)W{=fBGD{v#0E&p?|=^@=vEo4OmdoCQDjxhF){}`pl5$AD$RO_gAAv zKiyz0Cg1=__i*tx(Mv#r{~kWzJY_MfhTFZjhXep2fWQX(!nZSrpR_E}U`9{D|K#g# zgPa_2V31N~Z>3^$nC{EX9TPK0OK(++BwZ?Vok}|6%lZs_y+@X*M)vpChogH2?qU{t zjB6!HKZZ6Bt*dxe@i)DHCv6sE5p~rBDVD?+8MzJ^fA;GanzQ5s83VSI)L&( z?gSpv3iRyRW#Z0jF?2ln9<6&8Mx~Z@6rYXi6gHdq*nSwuS}o}a1VuIP zLEl$P_-LRqsk~uL2C;Ga&Omr+_k7zxzdmVvr0ML1CuP=1T+fTYT!Tsf)Hw>{!v2)K?M9I#Vs|Xt@b^1d3h^9YE3(afu-M&)y>kuVD@HxTURHc1XKrzAIGd;*O=o z*7wX?f3EYwliHqWw8OpE(|oo}e=HXa;DGfqKN%;}%i#8k9VU)bQoP_2<(2EELxxm8 z81-T7hrdDZ2-!U#(*Zm2&W=)t5Z~IMpe`&R& zwYl%!8K;*Nq|vPo-IWtyF*j&0)Zt)%jnY|$mxpVEP;r+_zfXDE%hxIKq*Lz6i~ABK zAtiQtq%bKmvom9&fF6%dmMgil%w>il_nz~feoN8(?R&_My zuz!br@y(n`#!vdIus7zqbtmPQr(;$EM+f7OWWJYr-qjR#vkRfGakb!eIAn0>p_RY% za%MI45&3`FxEuvn2UlbZ&R3gL4>XTCuJU*H)-F4C;;dz|i^bsqFkz4|Mxs4tLw*BE zi7GLM;e8Hz{QI;YG=@$Lw_HGODl5JK$WLc87rAxDgoCaKz|5OR$*`Rir4^3NXldQks|mLQ0gIyA*(CHVb9 zZiS=aJ?TbyLJ%oD)qmJ{bx9^>-srfh?s&vE!!vYJuYd4qW9QcwweLA!a%R^YMCU9? z-b)(YRbgUYb@=_)l$)GFz}8SFT{U4X|J`$3vTrqgLp+HCUm82NKR>&FL`mvQsYK8s z&P;(GEU5Mbm*SgN|JsV^{-YPZb~P9DUx)R)?lB3$ zZb^o?Ph$wK4>_&4KiFUq#hroHMuvpX2(SrzM>K@3_)F_gq9>c}tc_7jg@Pwn?Sdxc z{5fXA?X(7ymCSYY516}rRRWNL47D+k`fuU-iqCv?@RCioS6a`n3xZg=-Luy$f@d1n zbh}XwIak?}PiO>*HxTOzYXdI8z7#%J^Z4UOsB|4ha(XHRX$)`s?}4MAIzK-jdUOHA zdbmBF!{l{P1I?xibI->Iw3KHg822y(0n8oQ;DtE^04~V04Wb7zB5go@W#xyXBS-WO zS9V)1s@n;A6ft57q+A^r=_XqGQ{G^5#Hv;BVj?bn!;R~`9i3W^TfSoVy~@HK_rMiv z_Hc-&w}NGy|2}i<)I!LOOIx>hEoQh6y{ZSC>I#$E8OMdns~z!iWr?vU9jW2qi;az~ zY^W?N^Zowab{KNNOKWStgc?EOj=ui$wJ*D8zs}kaR0$LvP-|hAaX`K3?}L@gU+l(F z`SB{69NE1NJue9asC@hjh zD%ty3(^RHjkthbZj}t zQt~NWv_(rt5IaoLllRKSz}~flCWsZ65FmtY2JiZ}l0OGf=9FJ&j<4E9$D1TQ&FbvE z6^hbv+Q@w{dhCJTi%B6Xa_P5_pkSu++)gN&uhrQ1wYA$b=89LJ+BLIK2NW1h`a5xb zktQvlD-Hnb0P!s~0YK70zP`ut4C$ST$tEu`aBb&K=;5J(SYU<1Vd|7G)4SANp9C9z z%jKY*qqhQ1TVy|e{D?NG2CL?bwTYG0H5CPf{U3m&0kcxsf0Po%-4&Zq;P-j!%6?C> zG9uzW!7bE(gw2(2ERurbhh#gH@MiZu4UX67-%ojW%Dt4L zQy+_WOYOY>b%l1W0A=z@g|^ky{FA1+uG7<6`?@~9{X3PVrCj?VXhC-Prw_reya>A+ zS-xOQ`1WKylcQXVi6I79Tpwf$EO9TyWNP2UzY~P?(7OS#kaLWRi<&f~9Xddt9&A&d4d;uS&r* zdXz9SbY}O1G)tAPG;)1+){e)z#?|V}W>WT`s5!Z^>(Bdyg;GQQ)EYNWcSGN|KZidK z&x-k*^Yu@%T>0sqzi3=^KNB&E(Ig=ll8{SkLi6xb3-J!;x>4qx+64Hy_rq7*loYkOy6>$czJ+f=|*JGPPT@*5E#<6w|2iekvP;gvwq8_twP z7ALOJF)(;h^b^Jjum!?iKj>dt?D%fd{65gp(UC{!C;l94gr+ZsXAF`QD(-hi0GtbT zZe`jMfXrKjWZ=QmVB?7Dfgz4%Jt;ZF7=QAJ*2X00vJh<1gM@tYOqexO|aQJ7}>%7t z>-0GJ@^1IRTF* zmWFAz!?XPlb>Cm#SAkHH%54q_E@avgbf?b1R3yGIehe}NttyyG%}d|6PgTH42{)8p ze-`eiG3Y_z&Ow?MWb+pk6c}1rJ>X@Q;$Jhnt2O~|Kg8R1f83~L$E6Yu00VJF#lw}; zsBfIs;qRs*_&Y*~yUogb8T#KS*3ERnb5mMc>H{N(ear??;q&}o9@AkTKjK(gTIPlr z*G{@N+LDvVE-Mp}Ww$-^rzaQ;RkLO8mA+-EZ|=gj^n39dfOt238;O>)--8EmK5HY_ z!iPRaa7vF$U3L%Ef`=D?1kU~ytPcsY59ZoDo4biF9(CAJjBOsNSnu;jE9FROwLSw* z95x?L#h%oE{rWkGeME$9iGF>3&E#Z?{!a^`k^nMfo=A+S(lj78e-#=3k=WplMPGQC z%~d7qd{RyRMF=m>`$ea$%Cv!u5?*CF&TkLhCUMFhFPShy(Hy@MzK4d+ zd(mW%S$zJHW3Z0A^lcCETI&JZpYo^dQ#z~kS^#D5Bi86 zMxf2(clP)ijYuoJqDc*VR9QQ!ReRz35w&%gT!?05%IePHz52*;!OE(sZR>Zf(=SL! zqsJ=%08MHSk&f67kHD{I->@x(RkP3XEc=90A8#Fp1cgr_^hlYKY+EZSjLdM#Q$ckA z{jOt@W)fG=ak`&#Kl-?d)P$GJB-4yW!5U6qtDSu+me~qdEbgo-QXCdu-}p;+w6ok0 zmj&*TQkJ=#cSa3X+)eSj-@`Hybelu_yIRbF!7fR;SQoo?f9R|ywW|H|=H7OY+HE&Y z3r0CA%X7G$oOGLYF{QVe;nROdxvWEN77Dz+{Z87>a~f^s>=$UC26`}P%o*l}<{6rt z2Col;J~#}Lq6f_Ug-TySo|>&gP0}a!f;!tw?3RstmgtpTLbe|LcVoyqNAYZGv6MDS zV#xcRp(Q4jDPhc2OK*7>ZYi5_9-m!k3eY>Gxo&l$cZ87BJmDq&usG&LLb2qq)TxZr zX0(4#a#rr)$Gh2NzBzXwX(eV~4^9 zO&}bqoe^}h>O?nAf-<2YRHk24?Nl>!-bE--0J8g_k)l~l;>3+uz_C*2b z%IN+*zM6onQRTVYgv@->lY2bThMHkiud1e4oHbMNn-ef0bQ9TK53r=M)I%pHq2%uI z718xOP9o`>DZ_ZrHV}8NH=pLIV~c?HP|Dg!M(s%ejC6OtJ|TD`P8=)^H-aoVwSSVz zvGP4ykuDR4BBqw<4em3-^g?}cJ0eXAi~vV`vjd0l9pe006?%#`|0W1SHJ$iB2b_fqN5U! zOkG{cJB;mgs0z^9<*YxLe*U;5z!C&`PAmGcY5CfPU#4H05n)KA*}q6ooq{9jMB-Ju zBWmIr)dJ1Txu0sk<#z`?R|?a9DRqfQ_p!bpNV$weiAf*Qn)XuPXw~Y~l_8mr8j;{? zp`D^P!DaTf#QJbF4ngQBZEp=ee;UZP$B`$kPzTj3sI2CAGJC)3?Ue7HX=-c#blP^J zaM-bBi2+hw5Zmd!Y0S#Xnx8yuh*ZDs zn%aS5@Q8OeyS>+O)TM)!BmR08NQYS<^CfZ>Gd=|UAkbpaKDwtM*=ni^(;n|`De_gxL^lJ5 zA5KE*DKm~Q612{yZDnb?;P)eMY+j}L*29zg)$*oH+)l&Jy*+AVZ z7U>BF2fz~W(G^Omw*6a}1C39s9(O`G4AvU%o?+Vp{_IF;oP>5ZWyq;gijkloLu`5Y z&wbd!C0L=y0iK8zb!tX|AL+3@5Yv)~mNp_S+^@)Xvw!8_LTMRhowqY>2KXLH}cQU*;uJ&o}_`W^Gu8G(tHzGv=DTPF5t1l~gYhsY@G zIjFA**{DeIHoKmN^#(ku`h2FPPghNyy%|E$9jQv{uIFnq%0=0g^(ZJbgm+7(Zn4 z`ukA#;BsnhCM5l|!a$6aDYdL&)<5Pu=ac$j?*C~4w4Mmd4$~4i(=pkgVG$z86b!Kq zUv;u)ks4>}yuj$3&aOvJ`hfWgEA#`XPl;q$VxEyVa61_%RoZ>xzd3o*Sls*~8t6j% zg8jcC*smdkqXR{7Ti{C?WeNJ-gOmExddxw=C!9UzQcP3yo0{#3QCiin?Q1BmyFZxc zSK7ytJpmQ?C}T2(b6>&&)W1AfaDl-@(i?ts?GQ@`1xr#2JnAgP@mgKYtL9w_Mp(g1 z^h;C-TL$Tgz83se<4#3ea+Eo@-3I>Ub$WLmQ~c2ZeF!!>UrfWy$r%+Pcp%teM8>tOM-Wv1s3sk}AO)1*2L(oM~KwiKDnB$rX=Dh+E4gRJ?k|+U86@T*1x<0C2R z=$kcVOuFCPoZ|=!7B&zh`z)na6LLuxC(j*EJJ+@uvNQ3$cuvkJ1ED0}gVLtD9T|y= z5#^c6^u1H&uGm?K^89+lzS+&K&z{G})IO3%Z`l{+`q7(>FPl&`|3eLw*56TAqk8?u zFi3Xh`S9Abqr>LnPuuFut$aO}n}KTu^n$H^_-_~Zm6*Wx&eEnrVs@8tgE3p}K~&Fm z0`eLiE!d$cAN_2hC$DO`=ZaWO2%11nqZ)^;OvEgB+x7zQG&b3;{7X?YP z16_8JgW9c+yCy@xT4j1`YR z!&}LH>Gc%FU8|YBS3|f6K?4C|y(?w=ZghzQ#!$fk2ADbk-80VPbyY(5A{FM4BM%}p zWSAiM?feLu_&>|*z8E|3EAR{O>p}~5*Kai`l6Ah_H6?|IiRBa_>Q@J zBw4IrQ7g`qVD98kDdp5^^=T;v`@(Nh(N`IcPu5PWrNgqEP!_}J{_7sh@|`cX2V5rQ zFNxJY#dE7Q{Boua&B}5q4~o%J8-P8FM_>(-hKxJw&nOwSzT!^! zrGf=}nVZp@VJu-)tgAlV^f^cH6W0`THi94EpNx*dCyH7n?1O~xHyt&lSpAIX9Z1o1 zpTvVVxdc^x3MD;H+(mh<-0r}ay~4No#MofOP3iR~3euzyLLUj0h4J6Kc{4FFA)YxL z@ZO<+ZpKmv8#+g9UBD#%UdzNFBRPgnlO*5dmN-jH>&OT|hQ9VB;3|(9&}NSV2kZ3~ zMo8(|CnN~nxM*Jv;At4VG{{pYy47!1{$-vLSp$TSQ0&hlp-}L8LwuBBmmLLhT=Vui zc{_s0p+Wa~suR23h$V*vJG_DDaif`RheLX;=%TA`HO0^m0%PxEL$XG3!-%{z{ZSwT zUT7^Yr9%ldL1LKl#Y6kTADs7 z@hEGv$(ik?r zbQ02hi5l!CGAw&XMx!~h5oj~haiGKUj>-ehT1^5Nd}5Xzo*p7elsBvNw;fFEK8f6P zRzwL(Q0xDTRqK2AV`pWerFG&kQOcSXt7Vr7_ifGkC!bbv2#rE6T{%T1YSkSD2hHjO z`b8P~&6m-Z7(v$ovA=La7{+(}g0tes_&D)8*!UrL2vA1BU_tNpBhFq)j!=Q8a{)ma z^Sd8Ee*A`bE9850*M380(5zg*{cnlAs#{7<=b%m{=vsmaPwX`NlSS507L7BO2zEg5u)MHluT7_MSk!;PC>iT^6o2ba0L^4|4iBV zkf=%+TCQaoxKl3oJJ6?a2=WDBw{^O0*4!?u?EdGp_TV6Qm90+A zKMwyOghUQ{*L5Coo+*ZWu@HxP-0+I1#5F15<|ZHv6awBA6&2w(Q>3Ss)m=&SGBH27 z>hoxu!6^(5U@I#{;%HqxJqV4}1n5!gJD3as%KJy#>@v2G;B@b2v(<>!EyKIE z4{L5?6=N2!yj`DV+*@=^LUk2NisD8#mV9G|EuZ!vtWJ)N1oEpjh=vQG8&zQ=k-{|u z7h?%fHxF2i4s{{s4H|vpnA4Zka?YJF(t8zYh426!h2NxMp+rl^}gGv&9xc2?Qb95 z7Xe_wV{JY<$%58kO?+Nhw@tlCtoiEFV0>xla!Ao(@>0NlhWGM!VOVl+ZT5xOw|j$0 zCFOU9OyZJzLbU(d#2^l#J8QuH%pW>e%vD zw@SOv z>Y~+-f{lZN)trM?M0%avv4A__*3+!W-jMC%Gmyv$Ecg+E6u@?Cg3GaJXRe7F$_Q96 z(k*`WW1BUWh8Qi>3RE}$#nw|DH1epe>UZT8WOi$yy7Tb^OK9hoqKs0!w;U|I%m3cm z+4oK-rG_T&!M4EWc`H?1R{1(+5=+6hMn0thQ z(#oC}8d?(Q8S>t7q%t9_PI@np3$^IuxOSHv47!yyKFG}eZg2+7%M8)33dNg?40@K( z%zjPNrAUfKiuCv%OXDn*U(6(jo!<7%gbqhrNmKz;+H&tiag>(zYH-D|BB((oqz?y5hXd%QyPj7z7wP2=B zE100Hpn1>aUT1P|kHt!+x3N;@F|a-YiP=+3#7j)^9({aVH`>QYP?&t32-#NcQqbA- zuOY;`T-*S`ZLf*33-Fv@oE<~JtD%XBRL2*35%a%VgqO&PYiGZHvHUs`;^X6kzC2>U ztQ1}vz$*b$-pwDqBCB)*NAa?BuCth(fufr<3+p74|~A(`Rm>l3#bC~lnuZn%rb5cgc z*JR?)=MOC=QNaS(wzs1itzD_`Zt-M#;2-W9)RJG zjgB|!MKMj<>5oS-WMy@jwltO`mr=lTA+UYPO-{VYsc6@9oza~P;$nEkuw(xpPhS~T z)w=ynhafE>DbgZ>h;%C5f`l|Eh|;ZeD6wgzJ0t{2>24*Z1Vp-}rTd-x-0^=u+%e9F zdyeOm`78&y|>?%EH^*1=~fFO!`j?^`fD^*l}-5X4yvpHuhZ-O82nwEHo7T(->MJd&GY$Tp^E&GX?N<5jJ7*$8#eK34(m7eZF;`H zKXM#ssYrM1LVmik@adujC+67qm{;7;>Pf&tGp`Fy+`5OD>a>KMt8wnqL|b`&ZBTqd zq3h#hpy#2CnY7kfnURcnbIgn$M9X_JYJ;pRPFmZ&CqEsX)bOodrI7RyJ4H+p%v_L? z+j}}C$@nTJD#ES#eR33va?zEGUoU@Fxbew-3-C-NMBckZ4yL1Ki)NJDiy- z^r>5`)JOPUK&ql+G<%Wvfhr!35J>rbMgHLa{Y)LsEO4N5zBNaOkVg2h-&EG!Pfk!7 z1Y|fQ^~c+&?R*x^V1I=(i7-yJS0omX*1D6qWzb$~c*l0G9awIFtvmlC6Jwuwy&!`u zH*03;A6XmO?ZQyZ%)17D#v0##aIX_H*el#X)TRd*9bj)r{aV6tW$ThS(I9I$m>!6Zf+_x(WFd}+j6Iq6D?%2@R%w1^9exMKT+B_l_K+uE*Ir6Jl^UGck_gfl!lxuKs)3D4XXjg(ot zXM1jxM!IEwg4HG0?vq;u>vRWHo&!1JYhq4HN_4YVIG1u(LZb7JQR4a!j|G*yivD1s zf|q)@W&+PsGL+-3Sg)b-XX?m;2EN{P#@r{4!!9U#Dvnf=JVm9nrMS5|OOXT5X!Z9h z?#K64tBd_jAINTXfv`A!9^d=Dp!TEou(yEG#oFRqDeoD*c=61q7QmdNm=8qp@$mq!!TL5P$dGAABR8B{O9E>R-A|r^ z?t!1`?5&)rR3#>V(wvC9Z~5_d>e{6X>fDV$x46G6xc)3oyspCWcM=)-{tFnJJ!T^s zs#bv_Li;5tS|VS!G2v_g30Z2ALdK3QF;ll?fke>ZG_|y}+;qlAZ}+gK5hxPxmii!X zs-k3_fzUCmI8EU+m+cl_WWtgDj7ay4+lW4A9WUrsUn}L~Xp)QltM#JyrKE_LJE76ww{?%@?}= z+oqC)QpILY&TQxSybt(B-(+8VSK%n+(KamZc+=dww>b8)y!_!0sRc|@RNIs_mbh&_ z^3H{u`A($nY4JEDgir{{iz=~vkvn1u4;1Jp5JD^~q)HPD&&VCW7lozVC&_SBZs;_)~8<<`#=RT_Pjf+JM=7A=_(NZBB7<4fB5jT-9Hz z!Y+R$S`Jg^)+|DvQI%(!)27TJq%wa1kpui$G=dIH!UXZ{eA1O63K4y^89$0 z?@jlQ=95MbZl^$nR2|FYHq$WbH>btk@o2PNdz90Bh1-&n%kYDSk4hGXj%M`!acZ=% z?}u{v7uaST2ggb`0)6{8c40o9m@JWR+4(kCN`}3`w5B|)r9g1B=KqL_hAAqZ4NW0 z<9l~!Rwnx1w?@(IyTUx82375!3OHKrG~K~52=GO%{>%zW?tgf#DVwZ7tOBwuO^4Iw z+|W3)O}^;?$bR5=`kr_qPt)!p%KnlblVBsdw#~lcmQqVh^bm;9kZBex-p8ohCmt)knftDt^*Fd# zdpl<5JZj`{a$A$*bFOcFF~YDU&-7teEa;hEp=m(kknaL87+JzBVd*GUjBJ#>lHJZM zG3w_u@s1qRoj@WY8RQ9TUF3Xgo3QlFLnv_B;xPx!uTIN8&|bo@`bG_VA|SCH3*po6 zB_9ZGOih30@}2PwXV6nP6L3F>+cp)}k*c}FO^qWe}b7qX3 zY&TXcVz{p%tHbNmBsPl#xyAyST2?TfLA;ZQf7yI2_KH{E-VKrC1#{>0( z8bi_%Vm{3t8;eM+S`@Hq3blZ!_CFmDo8ybc+l-6zK*cex8qJ1hOo}F-{{lciuK4FP zn5dRzIvvK`3G$m52E~vG0(zzO+PZq3HxObDA4Hp6K)MsfeuDBa3oRLGUuW=^sn`Aa zBKCS0%^&#sxQLPUN6;Q~X`=WsEuTPNAIaG{kVeF=YZB&Ev1yU7TUUrFZTc zE(smrn-*)-1uCnP>a%7)r}WRR4(pbPsG6Jo)2+)9^Me7@s-aM*Exs3;Dn0Ub)}TB6 zdR^IVP~3weRi*sxq|Hz284p~# zc#{LC`$l57-laL19G`nSr?5r^I0tlMyySfP%ceSP4`t*h<4lUujbO#kr4^P*b_okU z_$bRWMtXX9hg)oFn{~x#cSNoQg4!IPuaG;wBX|Z?fPCMd{)9tR4NN@s372f?gN0Hm zG?aHVS(p~yEyEv_MZ#%+Y9HdVzOeVRLfW~T`MlQhi&sik7V}BcHe(!tyv^V@l}nmL za*0KJ67zz;c1pH{i!6Q&L7~<^&DdX3S43a7!Bg zl^0-|9^B8pYVKxS-{7ZhO>bP0xoCd7Ez#VJcoKN?Kl1Ov+1RvpzRiET{vr!fIh5~G zAK}`(LEf-kY1F+{{dEw&wC4qoTu%S);ZeGAxPL`?(no-K)Oc*}6eR1^$-h$J!TXeW z<9BCpOV9_X?@dB`>D2nrg)voSkjVvYg5xE&6`HMX=z}lMMDEf72n+inTBnoXUzJvM z>0O1no<)*a`nPYWr&aoN%q8nA!C&_S)r(cM#_k_Y9Y`YPltBU8Le<%GO- zmL(gC*Di!t2V?vTq}Lbea5X6%_!+(9zPfn8mFUWQ^vUW^04RL-AkPxv+H^T}f*AKi zcb(-+aov1;3!&?AK&sk_NvNCZs!?=Qb9CkXyIx1V?8Y;U7XMbQc_Gp9iDOTY$Dv5z zun>|$tcU`{UjPUW3*8rPpxvJmVQ^^M|JD$}l?I(Pz-GwGv<(IvvX0?SG<`UqxE0lu zv=1Ih@T88xjRk0F<%|16VV)2tfb2TiN;nqjUu3mC!aeo5AH*rSoI@}u?et5@p}hl@ ze43d5<_|xA&hq>xeZb$q@Cd1U@G&9fqxLT|nd_3BDGEV_zzL)-Skb^!B=)zC3%FqT zu8}AXaD$3s09idQDk&+fQXCqRecj&F(O`2qAwQ8#Pnbq3|7Y8YTd|ruB9q|5;Y6^& zy74GRy%LwH!M~GaF!3lAoBDa-eu(KhBRZ0){qSn);Ps8kI1jOsUnXaqxPh;(5f1SL z8W3IuG>k*7zExjO4vK(+y|K75YryTw&xqRi{Ix@>Qw5VOGdT^Uazy)>@J}1+k}kS zGr;Ah0|6Uc0z!T`9Lj>70TE8&@6+-a**+G)6SF+V5Y*@Q#k@AB&NX1yUm-<`Vn5xS zKaiM>SIpOKcUXT$K$LBP$K?CQwC|sLU*r3clUHU7yT4f2%P#yh z5{f(LSc~AD}yS@Ne;>3yBuDRhiJoyq-9Rsh;A_&H(Kw7yK?L4QV4 zyk~ow97P&XhEX0WInRKP7~|1PXo(6pk&)f?upoGBW(aHscDFr@C8Kp&N3s6oY1Mqz zA=X)ni43|bQSm$^B>L;pRZIWuFP(JCgr=oMiU#*<2+X9elqD@Sm}=E={=DUS z375j(3YN%NYZmUuz9xo>(ETh#y$xTkMk!bsD;&a2N=fP)c_F>||BETQ*ijg?%9fK`p%ng(s?rg{DP z&z15so^bR|bso}xz&XheP_!9ttHLKNWVc#A!#Er^hmG8Uv{ z9weT$c**(UPavo#mY0_oyLj+Xu221M6rTm^*^gaca@o{7+b%Q9tgm|Sb?;WWig}qd zC3lZy5g2bCExth#l}eXaC}4%4n7J(0+l?ahqz~&_s#GC2IQ6(a?y>ZvzW96L*mfKc zS6pZxYu3k|0+7({0SN#9La(_jh|xg#G&c;*2Wr6@a6&>p4S#rO>e}J^8!eA--@LWO zV9+%}Hg68r;}4r_4mbQzDqr;1h&!Fu6~D#k9Qls^3-34203$p8s6l6nsYpn+-RMy{ zk-BEpKHG~9_gv|ksO*hYB9>rxosbV}I4=@*HUw1Icm)*HM~(oebim|A^Yf=c8D+p8 zq;8|GixAX9_3?`h_!gS-vsy8a2k$_hpSSfv>M!-b&^v(^U>7sagZ9$!?ppM(>CoYu zxC|IoxV1P9lQsl?d-_bTS9w@ORvesk6lIs#wsk}|w58^mE|V~qaJ-bmjhi4*^NDf7 z)Bu1N3sTxt38i&gU$92D{_!&~k zqcS+zBx1chcpc)^906D1w{MSz#5T#t-WYhSB`J@OtcttyyL{(vCi-vFs%|nnMmII) zff4b)Pw01j-KlW*?zXEZ#m>9qukH`u3MhP#BG>lbl|Kn)O#|tg4y^^K6)9lYB6KG0 zWiKeVGk_nawu=PA{>5HtpV=3~lE66vgBm9yG_^td+h^bIg(sKC;eN!e%L*s;rP$Zb zOI7Ebl2wcQ@$%D%5Ibc~p+Ndz;KCgNOi%KK7Qe9MgftvZT)S?2LSAy8?l@kQns89- z+~|AGajWtxlZ`1#X4XfHW=@e`8;1~8g;uQzFG9Fx-8<%&%q=Tt%ox8+9;bc_rOIHk zGOvfi_uIfxyW!TVw3$lX*U;kle5}20yyQa}Zw7ksQg)3oCecA5=wl7!iNKw=ixx36 z-k@PQ;Cq$4LGUsLST2W~y<2~+A43)O!?SsAVIz)Rd_viiQghnS95xX;mHl2auZrE=s z8+YChBPkxai=!PetC{|UB=X%^S`@?-7g8~3@3cx-crqb=g|g!{e*fezsQ&5&g^SNq z$>yHWyNBF=X2D0HE7ySc>Dz?<<7Akt@LDxb4ZH277-FMH<@Iwg9y{UmP9XCjL6>jJ z3NuqkYQj;!z;T$ytmmxu$ns&EOC1bteq!q33-XejlHY*+u%k%L2+(f_Xc(@j=b_SY zkfe`%+YdP|Uzz_hl+8>z9?g`Ul=VcbZts=)6H(WM-LDX00E$mkVp19x8d*u5klJ=A zXHK|j^$N4TxKO_vY)jH4HN^-Z4X^s#9^Cb zHri`i!(^YbG^4)pSIvupOw|vtYijV37jYU!hd-*_NLZl#bfxRUNO~Qq(M6l+>&Jl< z71Ib{UuTZ0Ra+drulnBcFV{pmlfXu`W&X9KdJlXmVH?Gbq{!o~$-Vb?L-HejgWbsI z9&2W*t(Ph{K0dH|#fJ{RmLhnh0ZuiGpLcrQXh%EUs85J`vvj>{dSXIu^do=;5`Ljb z>IRt!G%;+i6u8ZqMUsQi70O!w2HEXh$B>j8Tm6Q^99t>Rn98J>lTJ=8g^cnD6wz<^ zF#o~}8$zc0NT(r)ATG7R#5DK8;Ju?(^(gJEuB%Gt&2zr)g;-XKR<)=H< zeRRAzt7-WpTAG-qGGtA^FM}(^YRVi8E*`b~{bo3`b zV~$=%rApThtd%3@xi|a;)7y(@4`van-hWj*&VJYLR+jt;G~5yBF$wt@lm7nU%w-d6 zmYUp^__x@xZvZ%P5#Q$#2fxC9mW7H}_t?Z3xBsrzea zf^mJ~1G-8Tp#@wwk6A+LPd_E^PqjG0#=x$_iRc^R`HI+L5?QHbywk89@c30hPgU>i zzjwO%%B~~-CVKNJrY&ili?WL8&sJIJ72OnFODtPLTB3S;(OhC`KCnLjpVGTb2fuYy zp4ag+`JT{SzWV|qeWD^t@_#zzQOgRfb0tYUjb3?`>q9zwx&p1wyT5Bgb_c1EZk|R~+o~%9G04j1QH=fB#TM`9-P96?xq7|&jjo|P zJ$=uNNe_l3&66COG+uNhvsiqLtQp_RI0@>Qs1*XdPlaL6twm=h_P`*aL58GHUi+9^qVMo;`mNN#@_dNoTdZ;3KuMf?5g5q1 z**)%R+U2`Z2S50(r?`WJS;^ZMc9bnuUfdiEzh>V$P(Uws?6+iy!F-E2Fp!XkQ^n76RyeT-35l;Ajc>_>i>WS)w29wKt; zw~OYxs0rqCug|V7dJd1lvJ{v+94`CL5Ua#{gt_M817Q-Zt3{wJYbbo`CPj1`LQ>8z zn>e^J8OVAW5EFZlbSXa?j>I&J-fx1Ot0r_&0PGo0?tHI_&PbRG%7A=;(KnTHM7@`+ zYS2~#=~sY?HCnvL&~d$$2Q@H~8RgGqQE%vDn}91-YmgX!>p;1WafVlUcsfgr(0sq= z#9y5^kX_@5oA#glK&$|N8JWq^zkh%oGltWNev#nf4a)ZULJ+hrxBND@l^!?B_p2M; z`fH}O0}<8xta!hMB>NV79P5xPQSeU$ItxtFsl85||7-=fQa65@u`oG(M(7C9C9+zP zNIt;ZlSiR(tLo7fMpwIcZB7~2x^#msu-&5KV!x&iP5^2z`6SH{e9lHkM}BE}%Cb4VVJQkuKL z@aQtNCBd5z%U`Xv4s?TmI*>gd+fcp@XaVf94r7WnoYn2KXFPXOEU4F)fPrX0YY;hp zCw8-*U@hG4orp7knG;d3b!jTg5HlxYetkjg@0|BD5Ltn>hyll(&i%+}T z$D+i9?k88s+Zy%?_y#JpKvQL1U5wZn=tmu^tQ@j<_5yX#d&qyUj$iC{nnhH~nCXwB z?*?qhJ9*u!Bs=rus));mQX_{@@L z?pozFfR~e_SyjDo`)UK%xwx`ZRNy;GZ7UFJ`^O1m?62Fggq9vhtiykQkA?VZ=sSMk zpV;t%T{D>uXu-TEuetd&Q>_Ig+SLMKRtKV6%$K@eOvnJ`lE58Mxl62x2gp%U-&Lu2)<0RqNg(%+z;Zvr!h+ zD}kJgkuW{F8^YkFFQ61(lr}3I)`~sN*W=Z)3OwTx@#zeJW5D15=;mb3qW~RKoX*@i zPvp!O|M8J>$MuqSIFL)gY){M$hL+2fj4%=YmqW@@&kgZjp1-6Mray0@?@`DlMV4TA z#`$PPphtS||BgD~9pMf6oUOz0BO_Iw1V2fCRo&XzK-+g-*Pzf9k;Sl^W9Rm3h~$~N zPeO^jv69a{>=#ZFG|mJ}Ln_{g_4&y!ZI7$8Uhap8WBg_$^L9Q2(N~*-0lgwff$|d#du6`@GSZ{uq36_g)nL#U`VJZ z4y3dVpt*38t)5?1wKru=|3l;?MTI0=2ls)OAQZUrp=ep8n|#(43Ew$E)eT%Rbq7H!nsS>=+f z4wx=)bZ8_wQgmhUR)W|4eQSw)=1Usx71t*aY2Z2QH&0dj5tSEzhF!wSuT%Z}uEFL% zk7#RJ*Om51hmFFIr8Eq!u@(l_EYh8Y46kz)?G{?6HGJ%nUi^RUb*$2R$zRDf@K$?o zu>IcJQ^M8yf%N_r8o3j5dC&V(9JzP&ga|e5V7Zp93B_^=#UvO^0^bWt5EoXwF&-B` zZhRj<9{D*YM-RLYXpjIQ=m6Jk5|)bbCg?L*(_#yQZ2E1g3v<0m@p;W2{jC{ll+zgo z*$&wUP8@+Pk5@9zayltLUaGN?!L(HUs*B}TY9c4ycYzyHc4&+LVFuhT=M;OrHqqOi zUfjhvcMiQC7Pk3`lnB^8^-<`)Kd7e(H~vJ9#3BhkI#u{VdiV;ehosPoCqj(y}W zr%go91uf>BZ5uFHX?Br2RwW8@enf=Nn(V4Yq%vG&RZvcZq|ViWzK!Tz0?H8zU64rdfDC@_ z_@QKY{Xmn(0g)@e$kIhT&n+p^X(o#BB__c5j^>Pfb$cNn?(n^5GD7>Rf5AG}%5ZWJ z7VXt{pi#{p!l{i_-gs<1juC@fgX^t}5tEL|8;hDh9UQOV~M)vExd2VhILq_@8;E;sKLB;W_nkcsH zwQ<9XcOEMvuKgauT2rwKf^O@*1D!k9dw12@XqqRNMzaiWtP&ktgX3(j4sOYdrNt}z znSKEq=YQ#J$d z$F+R0l`rLj(FMSo%aQ^yR5lqRpNuWBEaO>(u=798irp3W)-T8zl&0a5* zjFO+8!iRΞ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 fiMo2+FK3b#s-xz*L(j5Ke@#F diff --git a/resources/tree.bmp b/resources/tree.bmp deleted file mode 100644 index 9168fe4af0f37871bbf3296782bc0fd99909dc33..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7308054 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%0DGn{GL?y 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

    wOg-V^U4lSYfmce!~7(G5iz4v%evCa zpCp$eh#@*EIDMRS4?>t1up3$n??LD>U(+p8!;qU*g80$ zx_&POps(gpZTCy8t+Gc?b7~$_g~+Vh#G=-?yn1A0qKlg1${r;aI;Y<-Jg5`c_~rt}gAB>))$i{r$UTGyWoL#FKw7z-2{02$~s05Sx+Dr$dQ+yAv@ z;45;zDEw&0B?Nl`WCV&C`~?b4P47>&eV;*NB>45yufQ)opZ>k$!{3Rz+xqI4=I37( zEc2C}))zl_z57Gddi%gw-b#2HT#W`KMiTrMe2$QOX?yl_ujt17+p{nK8u;ly@LB?; z0it2U$OVvret@Oi_ZoqY-+NyDPPiqBg8lLrpq_yr|E>SyKLB|&Ce!f@*QXD}TEcy) zw(}M0zJN20J?{!?yV3G(?fn2~)6o4EK&G_uDXOysSE_94t7{*uZ5gbneOyxch;O0F zv_7k9djT;9D28)E6_Ac0KoYP_PSxXt{Q9uu!iS-WOigb*2qQ#=td1SK{=<=LXRZf% z1g85SLhG9t7?DFXrG)gVnB+1vWa84wlXL5ma;pjY9Fty}S=Lri*Oyk-9-dwi8eb5R zNIj5qU?i`K{Qnm)O2b*KURwaPaaiuei*h z^fKgmGwYrrHG>?qc)jH{qsKzdL^wj1#w)1|K*lGr3^e9pOkqfRO-5}$fzi=|F6sCw zwxA25&cm<*jT(Uv!i~wUepG}sO?@wlE(o*WO#_pJU{(1FlPPX|N`2WvXU(aYqjP9BQr;`XTgRzkO_dH=V6J^S*9mi)yR>FqE7(cb^z(bJFc zz8d>q6WR%2hjSs@AQ9a8^3$V%clbSVbubxlA@(89K%pUu6R-^I8p0|;k|Fd`T;XDCjhRGxbj(%zPjvftm1KD(-w)&i5nY+V{gFBHVdgeoaJb zabR3dVqtAkaRZnPLPNm>{7R}oDSFYyd;rZEj*cw}56Qa-r7Mf|Ek?b9WdJ<{_fY5uxp6M1NWQ~x%E%Rm41f7;=tF+& zaftw$_#YZL!fHWw7mr@Kw(r7ue3#tz?%HwmFqq8F<9pWaa+@`G=9KAh z^;s$g5K-O}%FvJpP%H&8E1?4jAz4`)Je6YLd?#oChOM?kvE^CJb(lSy_{(EWl+zRD zztLE%V6a&>q8B;Maj>?*pfEQvH-)nB%@_fe$q2iN4C%cLVUn}r9spvAErUr2$wc8l z%s<7X8a)ci2gWiO5i?9Cn-OS2yk1MJ#OC8U{ua zv5ehYd51+gS@PZfoSVQA6=*Ad}>m}x@=zN;sA20*H z$GingT^24|uy{G_CS+@6enJ2p}5*EbtSu+=}SU!7> zGwK$$_D+By)2t^=FvS8_w5zcay-PX_w^eOom1Ec{1DTu4y&l43hQJ^3oYEZ(|5@pr zbOwb5(I0m+0!|B^}{XUIR!rfH?w9R(FUdnTtaLk zVv&nSk02Xdlbb6*B1n;VAA{`x3!o7pQK2oS@_1l6igX^$5^Zgh@gka{m&Zo5@ zx{wPwGlalyMNo9v>Q&aWY%vl}PPoO0LAFxvk%V{V@BRhjD6W76-YfT1{Q_M zXex^gZVFM6$&SKl`IXWF*#Uz9ZeT)kb14`J*vMP}4+sJbg39}hD@w`L9j80dlj%SD z-pNn0k>$v@G$z05?!h->kb8JKLpOuOw2K8WUyioDtSKP0Zp6&-eP7x z18_#rFo~Tlm@_HqWmvV`MZ@vP_}EUeTC{rW`JJad58ezqaX0+nb-$xG18xSTctmF0 z3roD}707n%s@K5_5B8t&T)XqkzBBIE9z^(rr9*nT9T4Uj5q;^t_o4IGulfYv3l|R^ zzqqW2k(u{GQtpKiLM0hVTVLdD!&7}C(*xtP2|VP7Iz(pi{lI8<|48rX#Gs@MyoW;K zG6oMNGv7y zib^2JH8>2Rd#Q^@VC2J)7_X2x{Ih&wGVTP%x(7w0MqpxHa@iBs^zQ~GUvv*Vecgkojz_M#U-gX&Oe@W9 z>Q5|dJ@4s{ror^tb6F~ds3lYv!8Y+C{F*z+Sz->w%e=6(x0HdI~?@LAZk6l9-ziVzx<>QZy1HWj0rIr`JHY2)=Xw3V+g23P|LHONAuYc`AIQPvT zz3>0__|5OlPk#cFX?yW|m|Iz#Q@6W#c=gZ&zci)G<OOkzHgvn4CvMrb85QWI_$QRIfjkgy>263W8y-wxG7qDRB688)Z4FLqj7)D1OKFJCY6;71i7xDp zE$&^v|JI~gD>ofE6IE0ZUepknU30-ZcGZsK)()<$FId^kB(mqmJqIBE!IQ!HC?K^u zIIAH%9}S{bAew+wIpUKjdi-Y zCFTPw)%r!2dxjQ02rKrADi6zUPb?kCYxrE$ion$03!8tB%I%ZmX|(}yC4up!9wAw% z=-^02%YbENlszKsT3UT?R?A>)(W9{J#-QY~n1aU4+8!Q_xU$ZOymr4t;#f8Eupn8S zUfYpW*@(<lS_RbZ{ucMaC}J_9xZ zMFEW=F+7=u-WN?zUN!c;tnTXP8{ZX(A%C_W^#^}7-w5l$|f}j-BSr%iPS-nJCz>Q(()u ztZ`ej>%iiTJ7+ImH_g`7*nB#HO34!|Ro?PrFi?zFtXqSJEbq4QQ*1=Mi>ZN$Y*VLA z;R8>S^h|-6g38st{T_RVIr&TnN2dh~cqgvev~?vojN67)>(;X^TE2>~m@^$6kP*h? zl}L`vFCn+H8JZZe?1c41T^Q1dHE`tQiI9Y}C2N0xGK3PE=mJnH#eV>JAQ?4fN;7nI zUPj`74Yodnz%Y?AGBHL^a`H4B)TiQ&OW}1Ic4!qU$tD<-vh=0()NFsmd>+~vh8=V= z-8dNj+VWwd#5y;2G>1eNn`_JEhY<WTk)<60@TjGQ(+vUV@=2LP?{PZu9W9bjpzv^||_+49R2!jS&b=p=46c z{|Sr?6@V%X-zj$VJ~{tipONF_uk+D$8Oda1XXGB~D)as4lq36+$uN8**ZS_8KmPaw z7CPZ_CQh<*UbJcDrbCO@?p?5I*AIs-v$C-F)QyAZ+>c)JJag0U><#bpH@p$J29UYo z;V*7VK4C;zf?2I~2yuJA?&*Ea!wc5*-2nef_wOCKaOvo|i-%61XXng~8-!azJ?6mq ziwDt@Ie%vT{@okd_U>N4YwOCbD{P!C&8AK;Hs^r>w;ZyR#c)tkCu&GhdM`W}>La6# zf=x&ufQ<5m!G>j2V)n?IHNH#ZEfDb(qXWBU%2W%UJFGT>hOl%vea19vJCvpDEp70i z2i3(fQ(zg%lQ|v(8NMF;srWf!*XXOLNF~bZ5rzh6zyv02EO(EcHr`~;ye0eh9d+Mx z@B((|q{+@Uvj`1$@P{ME7-!}$T1Mz4*aE1I$fQuXH)3q^w6h#1QmB)h=PcZQ@`A^@ zE&CX)kn^2kKikX_w|z4#9p<=9E}8gZ8%~*F@8FCF(|p&3OOXZMuw(m%AGWREv30rI z>LsgJELgU5)jBu)(H6{K=;Scl&c>FFu@S2o*DYq|%$Dg+L#>DXrOayj3oWd13ECVR z(9qx;+2FB^7Q6*ZUkAG4ClRD2p0#ooQ$!b{x_m!gmg6D7h~+!R0KvzZj*Hf8*nfKK zkqg_7;iq&K>%Wi=8{nKas*H2!ZzG!?=y+00zJLWE^T{ zTiPyJwr&@q%!r|h{suh~1z{1N6f_>(0Cf}Gyd-**?qdp#(bn+@CL>Lu{K5nPREj_% zZA}^IIlNm?9f820o&wcfH70|AvyhhrKvO6U_2m>9tAS-GrTXwE{aIr&`nAPv6;oUD z!4wTi7*h(ZqVWY2qvFci60nlBgW;aTrRhQ@D94Paj|zuv90-l64Qx`^B^w~g;Ml^u z6+R3xgFr0^&SGafYlh8Cv_Jt*FwyWdWFMmst4F^*wfQ4gQ!p$|EgNV9tw#j&@e_DW z^Bl1v16N15u;@F%;$S@mnG--8j3|Tg&{`1P1uBv7Td-FYG=Y9CTo+=T+1T5WSPn|y zaRH_@Xvw1q7{V$KMj40-l6NA}%dQ#hwdn+JGBdR_#$CzUamn&E^A|56gpIoI6Io-L zIddkS9pov!$iP6bCc9bqA2E?2TW&Nz3D&`XG@5FEZmVj4rN*qRT|M~Fq&%&(j~b4| zgOBR#uEGsfoCnE<8>Bl12gLVr$N+N*Ma@Knf2Ds>P%>f=9ZR>L zWMpDvX}fCEz8m{4``rr9z8aW#_?p)h0F=_kn4IE!AyFr;-}>R`*>!u)Y(98p-x<#% zm%MKH#M}#v2a{o?`%X}(dr-)QJNIE%UiS&Q8xnmhFyc-~%!9}@kFYc_8IQ1JA~N3% zPVkP-2#U{zIfKG2;fI3aGQ7cRB9j9W(f~aGWYCKUiOm9*2~Ek3%qWb{E=?({%qXrd zu5U#O2E`acAVs8PL?ovZ^N0<4OnO0aT0ucl>FCnU(Gl60mmr)&jn*Fqx>dEWfBYPl9d-hqH6vKkU9=_0W4rdsyV%u<)CHz9+6-S+Z`;i(Kh`!po2{P5*_E-Tm0baEn0 zJyTy$3pSn+`i3Y-1MVm!nNg80CkNToY?*sedIwz`<>JAANrmpjIq2R7#|Fc zZI^90?H^B=;AY%CcAvVnV&ksauFHvhit3m1@|8bRolqH7MPdi3a$Y>W)Te={04alC;EIx)D~ zPGA^7svD3;(c6GIl{5{{3YFqFoKok*sb80&Yi_`S{ zeQ|q#O64QWXWW#K`-m^^POj-os_sp!>OsX9k0eMkS?zD2$Dk4;!LM6iX4DVDhe53u zk^^W=Rx^Oii_-4*@L_;u0AvV$UEcc{2PM3dN;~mU`c&B?VU>Vi0AU)Clo|XDOa}5y zWzUZshb;p)rU?(A!CyPx{;lKHAFa?@oeJSHB?b3nqh;5%I6p z_7QRm&Pvc@M4R^oVSoRt_uW6b-~N@vfH0Vrbv+Wm7ndbsVZ*D@UQ1vyNS>mP`sCg3 zLX~;_8@@}u;4^Rk0FWUoh%`Vq9Rr_8kFOKHOTaQUxT`ev=ht*XhN)_O3M^C6`V?)G zlKO5i85DYvIw4qdNo{9Q^`pY7_L7>8in^|f`kt}|h-%$w#T_|S-Oyun@aue>ZgT2k z(kf!p(LyQl2~9e4?LIL*H}5-j=+Zs!$n4<65`sI2CslZdwEJ@92 z$SQ0}&udK2ZyazYdG@McObsEg03A-;21Y6Z$FsM?}% zi{sMGfW+HD$-ohK@%SZ_L;MKMZXucyRGFBpwusE;=z^}u!rs8Nw)v}$nOiSfuzuTB z|G@BqD);F0Eyu1Bss>6YjDks%Ce5_7Td;f;N>IV+MIN!a2m<@1)%d1Wd8L&4rwd~_`lF!vuhl*OE2aFcUt-Ih00=pSe$l0(u@hYoP9c+o zO~iFGsykDvyAmtAA`99;t0*dPQ(S2)F`*c0B6HjPlWN((n$RmwC~e8C@62s{oQQjA zWg}6{klw`$2?9)G_e;K^$~+$Y^a%CoC$DiJf*w=XIndPq67M818R#)p1kUb!1`Y%6 z(a`rCehY948zdS03acN#Bw#(53}KS+IYOHklFZ9r{*J~k;jjT@UVQxPvyXr4eT7u@ zXB?LVlj(j9K7->DF|S3-_bs61dt8=)V!&kBVBNreLEjr#=J_xGjyqEOyDzQpzSa%? z1W%^C`z2JFdWFeAjA?%MuIcF;@FFl7gu$Dif2tq+2t%f%eE>nH;?};x_I@;wQ4@;F zt@2OE4NEI#Y>COQq0v%ny1=Mo3fm4{@|$M2jIeYvXJIDBypFdv^Na5pn=LY2^x!ihv3X;<0-6#F%D0dIL_F_kXbJDX}r6ceTqp> zNyZux8fB)9lauqJh0E8#huO4i-^QJL!DN=MTI;%KF$88SYdduRn5KCG0b!<2W#3}j6kc$M+u%zj!9FZt^aRzTvmJuZEIszy*J5b6XqovOkPqh=r~;ZK~_6NY7O?8-ycl+Q8>quA+blZOiMQG|5D# z(dkFd8Zr5GO8)%wPx_!#L@D0r;%Uf2UkhA_;*DIF^tz6G>q6?*U|(mYGnZr(a=4+` z(bZ>%k3Nw!a*zIJ)#O5|(MHe-c66Qs#fT4@Y+98?*P1>r2AQ~JAUVHAP(bu z?Vc~;t=Vu^y6F{g%RBJK10UimseS(|_a9z+;C0#K{^{Gd2(fh4!|TFr0&zaL?d#24 z@$!AoGq-N;J|zMpZhN+^+P-ny!QHF3x>?V*G@WY16UW4f=@v69u|`?>RZ66cGqRAa z>}9Nrp;1WB#V~CQMkxzgAO+5q91IM=JZ&6iPPdzZ$2;3Zb6g=U@TnIM3npU|jWE-A zHsz6=iR|a>sn*jVEpV>Bin@rf4k!S5GH1h<5pza4eaI0ZB#0jq4)qhpni-6lZeroG zddulmn~%(!zZ?#rnc2*VX0{7fY}t9}G?CqA5_cH_$I?~PZDxrJfZ=#$oT)&`SlEUZ zZO_~JU(Y5qL>xsIsNELpjH)!NmIhz7-Ht_$GI(&h4Ta(1?}v%@a7nm!YQ z5gUq;hhp%IFv?L!=Gydhsk?$c1RT({R(KS*L)(3f`5+kD|48gU$Sn$!G5TI^6CXnZ zhQTS*?B=cBb`VSkw#@e97d9U{v2pMI+^w!44n~ME6#xkrE-n5+`!;!llb_hXMFNSJ}qa&fd|{Y3>{= z8%x6pqX_&&?Rb?Ki}0B8y#kq0d>b;PzA~j(xR3&2lwXxXDl{geJDBFKh>ZjB6VO1G zXbk}V(DOkk5{ihC@pN;`xy#&kA{0+oV~}Si&mCv^Rp#@2z~|{~;&a9O3Ra=CfZPSe zln_%wGEBUQx0x~5^EKG9z~WQrK+r$EINOY zBjK%uJ1|TwRZTLazHIDp7PnY~P8tEAHDm+lR7%?NRPsjWYGQQB>rdPABo>(kU<~Ov zRCbE_WQP@Q_&**&Xcv@B2rX!fSX+zJ*5t`dKG_#m2{;Tvi;T@sqR1SJZmVOqd(su3&76B-9LeGK4>)k6F)jnlaO9 z#acHUqJ>BUv(MO=DC*WWGbje-r-cwWwRN0>(-WhTG#3r7M=*h!MCFM;xiz#R%}B%P z)>gMtj7R1Y^cIRF%%ySSBra}ciugq27x7C{Po-2!Jrt_j$kU-mPBN4(q2Vk=l985F zI@7usY7`w((^B0-SjlpbW}tnADkD4`09d|h7JXBgsHmSb7 z&5j=!Mmvl(10!>b$+oEb+Rj<;x_bXP&&c5P3iq(&^Z2(0MFzwtA)j*W%H`e1PjB9L zV%y=Xd(L{Eb&t5>6?;FFm_cbC!HKv1qV5Mrg2|k|b_>GcEx*9){vqyR(KiCZ5tg|V z6n`5hpitn5Bn8nx9mxzx$PG-)B`P$5hX@Z1_7a?&i8^j*TsEPu`A*8Kip?oy1CU87 zD2vIE@JV2#{LC& zOFD+IM`V}<%bhyOa{grd4f8i&I(a84rm(xP<$cxTA7gSGF5C~@bnvY63O7~+@Csz$ z;;{rRRZ9;tK!IS&)L&ud447;~zOgdO2&^Z4iTj?pwnO=m#T0xzt(}}^y3DtAT`+6@LL39l(JxXSM&wG7 zMbiW1afCx02o=YapnM% zK~iz=V(u2nB=FASYvDvvA3#u%x`g=AP_^-psmg z%*mvR=A^QA!r~-W^uT^ese49L>$JK7lwsJ|$!bO2^f^9CI4GeW1AjnKVqT*X0|Hah z`KF-lg@|voy+FuUs4|b<5KRd{rs~PhI3j_%fW5$zDeo1kOvB)B{8`=mRg-5(05_&d z5o6GeX?yiM-bqaZpX>Ud&HUK#lxQ+Pfu#VgbiDeRt?%Psd*0)SB#JSb`U3Exq+@8pPvTE3-qUC`Ka zDv6_E5j3uKyuOw8q*7#5DEs~0ozF} zY|bq2$f@Xz%Bb><&Gm}R1nh--6Pr~P6rYbv4jRAWo0D9IRLh;fMEBqnkQuy$z+^(w zYGVr9!}D4I8>2E>*kTGgqKh7f7xa0?)J(VEi0YuN%fih^4xfMEyJqi^ne&!Sm^7Wm z1$o^}G@fQTm8G_eckcxxW%{QV`)5@6XIA;7m3gO?JV?m#O)VrglXrZ{eNl({}z?s;~QTGRVE^{F0KIdyB4Yp;jLrRtE1B^ zlM5PB3v1bs0MsdE?NDNn z9gfU@1SaE`R2-38gPT%b>mUGQPTe5>P$8)exMd-OOrWTgsy1YPi3g28AV^Wq8wpO` z+V`%d_bspteGELLspkbgM4~72^gXalruYdaIQ=rASzW@gT zBm&EzEzI`f%RjjU$H8Q9VuE`E8q@mx9TG9bwno}lBCoyp(DwSr4uUa#{b%g}L9X9b z^}S)Me)6Va;C;j3+or)cqz5dL6Q94YAN)`^@S(Kpd3opa252)KPip&LWi~ugQMc+K zk-`X#%B~2{Di6&r56i8IFKavN5n<=DVVsHWs4>Q}Cd12Gga|~XR`Fzp0v71Ezk0

    sK|*SImipZkonm3 z>2^-|!7g!IwPx%3t-E(0KDG1U3AfEVq5aQtbVm9QRY1Zu!eqv$lxYTwn9RmdAVX{r zwFl%ZfMw)`G*r|5N`)&DNL#`ZDdTB#diXFOtqLYX$s$y zCu0>V0}xp}Q(zfL&deua;9yj-8S`R50TKMi#2BcbskWx9fKHIDh7tIt0mWulmFZj!f3ufKJAoko{-_*X?ckuX9K{;@j7=<90E4406SsLV;PFQm&xGM$od zjY~)!hmi-#T=`GwitChmpKm@oPmNdn`Fprjs_-hMZa0prWJ7=qm<%Ktk=jtDqS?9h zP(F%ZG;&4SoVsWPMm4&kBypYy4gI%94f&9R&P3-kbj4x14*87aPd*e)j;Ig&8j~Tx z$Pr1vpTiru{dxQEl(23OH;!MsdDAyQf@1sn-|&8T=JxetS1uhoe|Fp9y&L!MShHipvdt@zew}7F z)nqb8oxmwHk)Bx%S%Ra)9tQ!?_KTP>Vhk#$MrFSXCZN4b6qjHq8TRh@@%V|%oNbRW zZa#%4aKa=@geM3B0`e+e05X>|B0dv-LlY-YpJMMc%fv$cs=yyEB*l7;R{YK3($qYMgstX zFavqR#(E|P7;TuTvUX`OYNCOmo!OKH8-6%;^75_aYt~uY&$68}$93t7)ovTN{jhiE zzJnXK?r@&Jh~?>V##C(4Y^P;*vs?)JY&OLb`~g#Qf`zH^Br^il!3nXOWov6U)4{=E zo~!HXwQifXZQrqT=jI*Tm#=0oekWaKl9cj+UHI#iaX z7L*JF4HF)Ain0Vb$PVTqJQ-sswZ2H_KZX5TW-gfNrt~1xS96f`u%$EK8 zm#$eU5%DGv3QD|(n91|Ba$7M@_3WMIl{|q;bmSoJuQ*SMECyzU03%vdXoOtJ>UHbkCyY0>z`e@`r5%S^bLTrxvqE5*s{Ms|H72y676#u4Rfe3krj6p3 zU>A=-eEh`Sms>yN4F&RY}()f?u0x^8hBckIPOCTP3 zI{_r}(!(cCkP~S%C`<~*A-!r(DI|@{CYF(sUz1Fvg@-&`s1fIKQ8``1GQ+G4>aNh6 z;amUT-ZxTmzyvXQ*k};$n)DyUre|2&F4*+L!9^?9+1Sk{&>;dc$Q(fsWz8MFme@q* zz@gJn43-!u3X{S6n2KoJp5lqwC1{s0iRfL_o2yW9e3xV~MCvUseKM5ywLHqw4s2AJ z_GWIt9Khbu5ln`+Fv%6&i;w{05Q1=But3;x;%CHh(TEm2MED&;IfzFC+N36?JhleX z)Ua?YCr_P8P$$-L07wbi$fGyMb-v?VXN_%Q$^kd=&;k7NG=Y9GyRfpcrvnJXje9iI zXXNpsW*TRs&#Sv50~&Wh$3)|lD7;Q%GIVT! zQ{fLNsVFjMqZz3wXHi*zK*9IOR`)l2wRE>oc%VG`{6d$}My~1%^bLx~9buC;ZtPoG8^RfN~&TTv%6COEYB%91=F0_AV*)N*qxYXKVnZ4_}( znug?@f{elvm@pYdMNne!R7%RuCxCTgZhl%(QA|b#+PpsD(Mq@`pWv_s^)GX42M7-9 z7o7>Y#XB&^_0Lyj0s1~HjPuh2+jWWZ#u z-155V?gL@wwtvvQh)DO)Fj_$5WrCu-f@Apxr}7Aix)&UF%P-)TulKcw_fOxveD?O$ z%N}=k9NIsB#nM?$j!Z;_1}1lwyZ-GMqwfTukb7xHf@7#XgSTwgu6;)C4+Gy9YcQuw}i`P2n;EK{DwvhMUUjU zqs!6B`PRKlJ-&jOu+fuYS)nB`W-Ng0(nFU*63Y6ciaHNodEl~q1A1TPydI5BEr@qy zWXN0^e?tk|WNB$WZ7QP#vwO)w0opv>^uytoxHvJ1X0HGy;s+`PV}p>Rb~r*xG{h#D zjbmNL%tGef7!+VKre?-C(()$a+tO+pAFyIARL;NxAOnw)po+}W#eYyqJV^mW8s3cX zt>$Kq%h&8j@inWyC#|*{eT;;Pmc)wo)T-XJ+NX(?Pf(0Wu793TGmzHs0>315dh^@g z;;e+@5}XMF@b!pezvd8b>#%PoVOa@6AypzCWYMy+l?t=#N zm5|nT&wi~L_#%Kz9|ynG5B$ncHT^%;4SXS{FvJ+3n3}$i^-n%&S0i{bZ7&5>VL85e z@B3>g3Fd67H*twir*7hvFzL#%E2&njG zmo(;AwC0t!cSKrfYEgJrrC&lJc>cE%+0;~Im zXGA0wgWiNC6r$xz4mstmAVSCmC+612WYs1Ywt&n8#1;6(=6XkE1t;W@-ajTMASMsK z4Fa~1K)_`D;|mCugq{pyGGHor)t-(UAuOzb?~EOOYv zYAbGk*8U28q2C(@eyw}*EwBAeV%g)A(kEn1N-6Ck7j{BHBeji8t4YpliO;HoEd%P3 zU)`Qr(u9y~L48M6S6@|IZ^Qj3<*j`wB@IX!BUDb@7A+Q+)fAQ9NEp=Jl*YKi{_Mv0 zU@~cy@6&2NrZ;@fYx%9P^?OFeyWr^7E8!J46RMG-MZ`EXvzoZ7#Nw8mx(Au{eTfx4 z31tsritdGERH2Jf@!%EYkcLMeN?M=g)jck6e}$G5xt`0&`c&7QT+*0aTu-)c2s{KL z(RpB4bv%62*8hs|CE}F;0KsHHV@SZ%{_rJ2zF;!YTIhj|4_=V=uD<6fxJL_Iln2is z&vZVQ#O^GTTL-KL5wyhdL@*JEL~bS)crv~3e(ihzjn5v!n!f$Vy$^qD9sCucnEJ-HI0LsPWEkPwe;JEny85Z zp}uHqhZQE#Aoudd5(^B5HU=j~7q1?I-#L&s3X*-sMjDnGajpfU(0?jWNH?=qOZ>Ib%bQXA;Wlu zE|wiwp=378&Z<_rd_Mnt6`V-_%Kq%hAvBlXQ`h#-JQ=;GX3OXUWoPxLtHkL9dr`=Y zfHPDK;Tn~FN#jnGpdk@m2Ln7Z+;o&Qav{17ddo=ReAVmvSG}|0R|Uw7l+TK;;r~Ej z)Y*0Os#+VcyOHwy`}?==J-%h{(Jj9m-*funu9Fvb9=`x4v-`vq02$tE$1j9{$)F*F zelH<&W2$(ZRE)u(R0_*YM*`uqstzWQq@vMb@_MW!WY^O{%gUW(mBo7A*D`MSgACoy^ zrE4L+>hM&u_?~#{Dz<{zXN}2-)~nLY)CM7x1pFx*Cr1|#=4$QG2FEI6T1}h_1EfRv zrHmUqdXuM40=j{}A$F`9=wwO}r**V=1KRj;Bu63T^1LN0 z_O04_#Bbqh3u^~r9*oDK1!`sE6tMQ^Ul0{X9T8%KXp>@-+S_`0dAYlJSXtZSp|bNN zBbvb8($0VR`W@@H?;`$)jG+iyktvGN36RIfKM-i<=k0qoZQH+i)y}z#x6GNh-oo0` zXp$w2l(7@001GfBNsJaIDU=2LP<%R&VbPWK@twP9@zPZ*H}BlGaqG`ZR;@&c2Cg7{ z5|}&Qv;AiHdZY8q1m(1;VjeK@jh`hTJa`eJrjyNN{8zJ)G#w2hIEKP2fXnnWx_}jG z;Wmk{hXaVmJlPE4X#XV}SMNNr;o#|Y`;V^MeQ@2*-77b5oIQUI0LDZkxp%mtJQ@sc zG_OEmih`m2O~DEjIfwJYX8<7A+qvm-UIhm!*TB$8Fl^xe%wMu-#w_1y<~Gi5Gs&~; zJ}0PC>C{#1)$Ivg&6kYZV2Uo6}h6}6Hz^^ed#~!EZ#KN zDkve6w$m(ZZJnIa6#?7l>zE1C+-EJo3$t-@hm1sP%9J%-Mn%F>vRt^9(p9~Yg2d5~ zMwg$YR_H1Z_f;lv5h@Xkf|KJc;~JPC{fch|%tUkZVio~veW1W)axaASB#SuM1}+WQ zg>-M_jEnOw*C^-W*pb$t0`g38jK<}-1*)m_Rdc;8a;}bjtw~JoNA0Cpmm7RsTCF|-Eg^tUs zlk27a+8NZC44sfgpI!N2V+ojIzMCl<b%@E4>4j6whz#X%A|BoS=ktxirf9whW^$)ye;V{7o(xS5EJMem!8MLV3EUc84tEoM41F)i1gCj5uzYDZO5>y~ zoKCIQ;A(IsRD)zzt(^s%v`l_!HR1Op}Lq&-|p!;GW(nlO*+Jcy>R8s&D$5l zBhK9kyAT=yECbnw5S|OSVy?$z0LU<z9}I)KQ2@9aYtoUXO#Dqv<~If_C}M0HwMj$ zq?-}Zcvu9;&+=b*;KW4)VeZDIl2eI{OGx`B=M`~ya(*F^P%v}I-xQxw7@m+75}9;^ ztBWO-Qv9{ZXyBJ?VKLB9gTmq{;c{p+@YIEn+n4U%I(7Bzj)U9L#t&E==o{$g%s{82 zjd&seF?ihRmcpqTk9^8R@Y1nk$&2A;GHpTNveV}y>T+5?6m<@vNlP$UWHRJ|oaO5` zqgUo1xM0zerHd9VLi&kpVnjgk)YE_HpZY~Ch@u)K`N|U{gELwz!vm)Lq#>X&sI>_f zlV7EqO)z7Ick%k;p;@gN4Np$oNhY}0+R=k7^~?&efOkmP5iA##k{$q72!TR`V>A#1 zS_+d(;=%-b;Vg7%jmfZ&Ji-DVD*RT7{YuA16Wg3FYl;ED1TIe%2=StnqTI3y)U@`zP#^CNzX@UGf4I3fX1}HfFYCL{(`jEEIBBF zkYniar^*L}FuX;@xAx%&WMp*gQt`bZFqziDzc&y370q525(?jY{Z9mb$#V@9!&fjF z9k0~Rmggi|`rP{LQ}dG#EGuTA~%4FruL=e2<+^ITvV0b!oJCD{$Ij3gR<`K9&oTlh09 zX#Wxh1-nLQIcm=?av47pUJWv{+cVer0LPyfAj!DJ$O^yHjs-%4@8cE+oLn9Z^q@plhKFVO(?pX1W%?qF1s-WuOPyBThiXb>UJLoDQ;WOk9;m^@RrW*|_iaBBZDu)p(j-X@Prou@j@}HL#1z|? zxjFh4{TfmhkrZ^}v=p&Rw^J&E z6N^caoPi#1?Ss6wXE|+8C9zk{6JnR5v+ji^H*nRlc}Tm|rV^Z0)mz&1EUOf5Ojl+_ zM_%2%-0Jp};+nML>gh1NqG# za~nP;l?^49zfP(h6Qw-1#E6 zWq?}66yA@>ZOX3i1A9TwmVlkIwkLHxugK?>-`HQ$_7qK(;i%e)ZTv#I78G@ zQ~wazzUadZeXmG?MB3}VH^0%D@4fg$I1(bgq*5X^Hh|3Qum8}P4EjhceXqU&%RrK$ zZ?p8j{)R*_xye9v?hk(MAhpvViLF1O>kGgFCeu00lR@CO^VM$%#nkr?)jxby)Bm#Z z+3RK!VGq53{NdME-~WNgFw`2tnyUI=vD80)4acUgkHDqAg0_3PO=&22r1>}GIfbOknHf}4>O!w(S#6dt|(0%r$G zTBRi`)@!Q=t$qe&pZ4L}33pm{qCfY2ko<;2ynoePb?RfMwrugp)E}+f%!`G&fDMz-Cxbwrz2mEyH zZnLLoFAFdujjug%Nr)_YRfHX_(FRJO9DReRus{cR?jz?_<#Vj;Bi6p0UA_vTMlczK zVKm0V8vE$G&kA2PETFf5W3bVneynp|E0{$JQ6Q4E5+?QGB8j1l15i?TB9m`LD0(o?;boHnY-rPt#{JX&6>!LpTdfETa7sXe0 zmO>Or!YMc%f2>FYQa?`01?o5~Ljx(iMb%lCIr2%#`mS-fzB*R;_1|Y4-ac|VT~#hq zAHsJ1$5Ax3t{dyRhWx~CoWf9N4c83UTpuXE{_w-gmoIl5Jh|i0scnZ(?mcs9&*@A1 z&RpGd>hi%e*NaOEw_Z~e7nQi0l{aX(nK?Gp;iF3P-p4@Zd6rAe)r;Z%Hcx=bv9rISsck^|fZZ~zZ zx$(ql5Z~olW7J?s!LFmDie;sQJ9rkwdsUu@wg%Zj=Jc5hR@*fupzT9gHjF&jYvTDZ zr8~h0TAH1cE#j^w(6$%ITnK`| zm6k_d1S^bT)-kJ&yNXz-m4%(r_^A^nJ34vJTe)GI@7zE_u9%_2P!xB5(qw!?R5Xbc z@R_r4>Dq0pe?GEq+sV}%56zst+}w7Cg^jzlt-FP_Gm;m?&fqhO(kc03l;jA06F~)b zF3wDz1}vJpV(rQ$t5^8Xn-3Ld-r^;Jix#e2zh=qmWtahi&&-dyj0`wQtkjy=%8^L{o$k(D)U6Loq<)&I&9eUcb1>3LKy`G5dwqqH@{5omZWN zqZFhd$O(5xx`f(?SB#C5Etlgy!`If{od8uYKVLvOlW9Oziovd63F%8J$FzoGbpN3! z>L8~Z24v*cD_}&QMZgNRkL)HrKyU-9gU{~hI)f%Mc&YI8jZCN8y7|mq<}||(51m3d zg_Nc$uNgQJlQpaXLhs^LAnibF@ahq~NES{+3*eQINu5ihKLARIHVc!;=GG>r)5Td4 z0)ylQW0Alm(pqsNMuH4TrKNx%dOK&4MblbTyKx665{xkJFH}b3GgOs2urp&3Z+Y>C z)c#z%T)uks%M+?xbx;CnE_RUZV|ibjOfvVIz3kYjt2`3K>!BWlRt#@vo=*~b>uwBliqP>IwKod`eW z>*7~Rqk(v4Xe0~*TYCp!Nv6L6f(Wod(E>J}Icd3FJ^2+FQ=Vnu8+Fr#^P?a^Tv$3A zanPieA_fP+Z6wf{zOl7+ron|z3s{18#?KbkNJ=A63>XNMfjxpl2eb=HgWSznQoUIK z(>e1TP%*jn)Lln*z|Y|;;Y)wQWcVsKP624#Q+a;*mAZjH8;PWk#$=@DE8SE;7=Gmt zSyTs;Zpl4h%vAZ&3>eO^wMNP8sUKC=acpTZeaY&fQx+Y~&YuR}z{Uxf;?!il*WI4> zK^4!!*3sQdvXC>N@eiKS7~Bdo=Bl6$1up)HP!u=sKy-wro7qjBVrgQ+U}qb+X!)^o zSC5>#y7j>Eoxhwqc=FPT3qdC@-#9}Szgw|45(|P7^3Q}NUQf)tDIq_pSfoKQsYK{p ziHJLN?$XJt!MEZQuY^aUFmpB}lm(;$(nv^*5?6^!k4Py17`Z|&?4-PitiptXvV_7C zrkjJJl967CN-IdsuSDrLKBpwHup*(LJTg5uIx`=IKzK5+Wm5CYaw_V|n%e5RdaBwx z5%?{rsVQq{Xz1#yXlN*?s9?z|l6*{rFWrex1ePHUQ(938Ih%4Tn=>j}<8m8H+g_Kp z4ido>m0FBw%*hME2alduy5c7{ProHAH!_`Z;b!=a$XKLfu7*a2CZ>YJfXRUKBxUC# z7o3n)2wjK#+DOgZj!q)HD>lCXOy+uYTySLkTq_1h0@-gR)xuKm7q<}z6cHi1xptE(&2bT1!Y2s1#GjCHzy(r0uJ1Qp=~ye@f8 z1xw+pFc@Y06u^YBk)Z_+A%VKmt*DWmtJmriH?#8EUfoVDU%CCTt5<-$XwcBc5Z1~w zbSYlojA|c17B=Qn zt$4#i=Mn%%D$E-fv14=cmrYN079)RzWlc#5(7nL(B$@5UzMji-$w@M@Cv z6boPX*_$`-y%ii=g=|PtRc~tjQy`}7=BIgW14Zp`GwKG=S*`5-TH5ou@czgA&Nq1- zuZdj(lR-l!w_~tCEdt2Embv$`kd!ywFRT0U;3S_l_zZDL=*CElQvWBB?S1@fEgCWs zxbz$GO7LVFo_%e70U9I8mDt$$^h*m{o_}o}_<}Qtgf9v(kXwLd$f=~*FW-d~^GZC* zXTSb|3ke|8_x5+9neKtKK!cG5?O#cIjgQPB97x6`0+*T}lC$Q6#$@<31TH=QIPm!& z1awFaViNwM=7ID3@HGn{48k20NVF7jQW}$K=^aF~x1>n~W~=T!%dWnM>z!BK30tG2 zt|O-u9hmauoXX6idXSl{;>OIvrrfd?v}GE5UUd(A9r*O0&U;)^3v%78{=a%xD&9G+PfmRf=Q3#6B@ z#(ec5GQATW{Xm0_u+x8w3)*W8Lj zKRhowqYhn~ggju1N&p#@YHr3AUXIAV9F-3mlT!5%jT9o75{uf?O2A}VA_|%ks(Wvz zH_u*nV2X(=vu~J;yb6t&PGFI)EbmwlNB)?)2Mi>Re&&4trQ0_jxO#ct)vJ5XoIh~- z{Ej2XR&Lq0ZttOO$1j};Nxn)3>g2`i-a%o&%RR)s9odb3E-ZVYOBmEo+>9UGRIai%l(m=#e z{ewY-Wl~9Bl~YS9@WlMK=*(8~U&FmgDt(qzJdjd06jks%x%O>F)2FP)Pia-}a%(@u z=Jwr6st?Vok0@#g%dNSaT}9$K6nzD#Y<-^D_#CQCO8Na_GHP`WZ zN>OWnN&Az+#y(IQ1Z^@(n@d`H!DOnso(Nl}Z;0@>#-2f7K;n$ZdDL|ON%zw?55Z*m zUNt{>j(|-4gBK)|LNulnLExUJWL$zj14%|yk6sXJN1pmODlLhC|u<$01KE5 zS(9FU{(Jx6M?T;D`p>}+e`k62{yWK)pmpg5&J0mhtUvznH;^0@gP(l-JD)57GQcu0 zWLWOK{@nlR_kq9upN`kx2p$BJAtn|McbA=kFi>_}9y?k~JIo z-?HvOFqyhXLqsiAbw4WV=q|n2ThiHwO4aFGkvHSg!_!OPVqJ_#KX@T@#=P~D%w0)r zs;xfkAB;3C3I;UBWOXunxXRWMF1jlMe@xSuSxk4r^qb*HDp(Nyd5e}WShjlEPaBr6UcYwZ*1ZRhuHU>J z83)unv8({#!R?6|a(8E%+LJ<@-F#d;yr)~+i34I`0|7>?46#T>(w4a@+!D&&dGPqr zbJyK{7eUdPWFmkJ_!MqA?joitFC4z=Mf>JLmKb*Gv9F*a^SJTY$#(pBjo1u>GcaVZ zQF+}cHi@(|i~a+M;7@z&+T-Ta;Cc^ZG9xZFhX^3^gL1}k$5jQiE(({!0v5q1hvUVw z6E}r>M1?h5M((3RVDy3F-78&Ry%Bd`!7@@uwU?oMsj31KMqq(|R}UzO^jk;>0(3}- zkNoK?lQlu|4490ZQQ-^_WisGxT ztzjQ^y)>Xci?rnb`qRxThp9h)|NoV5C|2P^?82|Iqr#C!jvXnL7Nhcft*EHjcHksg zm<3Kbb>ZOItG}ELI&$I0p>sEmUc5~*!QDKdNk4xs;_ zFd12qDMDgoFmSQ*2;`hX`jsgr2t&Df`7T+tZqM3H2Rvslv+)&`pt{Se$7E{b_fnF^$8)2ybNT2Go{je?f%yyXyD0FkDMQi!~# z#p|C)EC4B3#4((1OWz}atAz{*{#wjABO`^2h^d;R9Dm=n0%&wq)x?|eqTl|QYA zY-nR;MMcG*#w4A@+h4dq({0RW_;`BF_I91&Nj42c{vqVdSu$_#iUkW+Em^#3`QjBT zm#$hvX1c(IO9*Zv@Wk1}Z{dm!KW*N*YQyH)bLQCFS%IQVggd0;T%c!gFZ9ei(KEak zxGBn`r{*eUGQ+B~|ME?1_8wog>&Uw82RH9Iv}xagP5XBTEDW@?oJ!o6Sn_fQFyHmG zJ~u?#pOOtX8ke6>A)|g2uNK@ug_wbOh;uq|!j$PIHqH+IfeZcS%qIml zFAi&a%gLsMwfso?>!R@Msj5cXI15cJ$BHj1uQur($_dr)IGkL~4q_wtgEsq>KPzd5 zu%-yqf{%rI3Bx$8E@T3jI8&|c-2FWL<^kXfbO4D7NM6B5LNsDsL5ozLGtyN-Dzp#I z&a%+?72HA7K;4JiZ%S7tLsG}O!spR5ZNN1-C>MK9f$LO3Z+BzFo4 zAOhCL8pD$bn7d;0_5(`H$Jy4#&dSmnMyLe)BI%%lsxU+0{Rm3KOvHHRtc53o3^gth z&jkw}85N*Qi0h|e1l96#@AyTvp}+;I^0XDLN3X#1lo<({VT|#VDbpduA{9Ykk%SeS ziB2gsoM1H7#twa<0D_M|g$QvH@Je-Kx#{Y9#rMP$1UfP{CB+gF=rlL{TNH6mSr&r&TZgh07RI-#4oHC(S; ztjv9>5lrr>0c@e286l;|4kLuL42yJ5?ub%?VqMo?x+v<|dcah7lkFT!4?%)MejPrG zevbHx!Nzc_ubpbhtyi-f93tmMVVhx7Mq}9ym%+}()6(7rnh^I+L^~J^jje5LX86or zyl%^0BE-qsK!Pzsw}@tfZ9o(l%0D303zw6D?X*%P{p1XDTQL+<~mk`$I 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 cITs6a5o=XeMw5 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 z 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 $~~OjK55bdGTHVaSjoGRq#O6h@@v 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

    &=T$ZV3QgFXpm>MR1t3r0x)^nsUb!Qunr| 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%0Dy)MolUmS*M_=NlnwX?wD$QX{i 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�dQZb6c4j^YrtH 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

    E}I9=NQbEIr!;C!mz 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àiC;RKJiikS?649}UAqz0yt7C@%5iDI6F4klQs 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%0DRdyt(-bz;Vk=wQ>V}2TwukJ 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ʭ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 z z_K(zB`mF2w?$@v1{$2xTknM#YLmtqrC*K3V@CHf@V!02V{_yz4uOu$rSoi={209Al znS0-SI&7_Qs177at!#_weYMd*`n`VblEb z?PpgXJiof|^5VniS08_Og=8y9T>8jOUVZZE*2|wc9*VT@e|i1$zrFeOzrOqZe}DPI zzbw4_Pfx%9>%#lLK$5wuyUb!RZR{urnPhf~vJActbbnPf zHt%d5*;&>xyS8qspmDCQ{}6F{T7Gj-OtzD;Slv%9^V7fnhKiMk&OV zl7_ybx`7QXqq7IDkj!=X+-<5hS2Xssjo#2dMs=i~vAM3%ozz-7d-v0=Z~ybrYro%r z{-<4MzMDJoI|gmM!bqj0q_yN_D5)wL;f!%GMuj{x!WrJOim^{*<&;bX_ojY#zi{Fj zcX#*XRcS>P6@}Hcg_R9OmCfAkwnJCW-}^8!cR9CgI5n$MQn!j~vkI!Q$@z7I<^6jb z$IleD%rp({?jPS(P+Grwbz%0JlB$N@$sNb;J^$$s|N8&@@K68a=C^;{yzfzU-?8qg zYv=C#eBtK1vbrJcd|_?>Ihjyjs)xs;tD{09sZCz8^1~?OwTo4$U5fq)~8-@&5 z7BTP2^xT-l3~J!G`Nr6JBt)lH^2N!$7aIDvfxOi;jF~L=v9SpC_0NjSY@`a_#;vD= zqgLzanN!J*^vUU{{ls+WR>vP**PUQE=7HKdlP zRZ?0`NAH&5@dKG_n>_q8j4VSI8+w`BMaHF6xcj9q(|0vBaksVdqS6OjF}Uu3Gg-2F z|1U3oWk9llBDkSa@>hO}lnG-1iw~mkLw;h7Wf;pInK9eSp!n43Ao68h!0Krp0jocT z3%`O;5SN?J;~ub^hU@O=;Y|(#e`3Ml11u=8qg~wnU0ouUEwN_xU<=3E&W$XLRcotP z=GGS04vg&weq;WQ#d+|@hL*fP}9J5g2Bo}IHkE;iLaAcS3Dd{KDZ z;X%PG;}cfKC1-%$tSfHo>;rD<-!$FTGu6D$|n-zcdc3{A)mOH5x| zTunvksDv!w7daAE$0o1w@{RWJjwEjju1-SjTJDtuHF8sHkhMYwv3B?;G4aHZnGe!0*WTc1jM>J}_-i zu%X-)m`rIyOJ#RY!@wr&!1{_#zkn#=$t;mVT_l$|u*Ypr6lG6nk5Y-meQ-L&!zqYJBDZ2u)0kkOZpyl?+?EKLa*A5;#4-_-FX)|gbO|8AET-50J^tOFRP7aQ3t!?f@LcFrNwY0pZ zs=i@;WhL2Ctv&r@8xhDrG$z6&9+Pkb5nodi$(jM?BwtT&F%d^tSXg{wQo_oV@R<0J zh*;Wo_P{lmbvimux=X1Vk1<1K2so6XVZ`PJRfY*eh@gpKS^PPeWs(@8iX{mSqICY5 zvs{RfATT@(yw}z)2v!)5E;B$T0aFjvT3Z|BH0>N+A#Vs91dP;Bmn|nxFE{_705BOO zQc_nX_YcDb-j>%=c!l!PN5WUK@2~)Py4ZRS!DQgHP+19Qh-Sgn2k$kM^2)qnx19_Q zqAgGttyVH#4rYg+ptT|_gTsr@!UnpT349gbut?IxfSAO*EcuExlcpf1V3<*I1x^cI zql=FZG#E-h*f_gUO>8Xvra;Q-B2V9V)~+RV-!h9Yzk=?9o2t*aAm(*&b4**4 zLk*^glsxZMYe5B5=bR=;5~8vFt#qZx0!M7ozh{_O=S0?Y^i!l0r_VF(aNg2@Qi2=I{T zitI7@p%gVG2$WPf5|_YB2?GhSi82MES5g%;Avw2*z!_Vc+PJ&edwJNnxjFdwIQjX3 z$pFY8tm+#Q&Yeq01OED3xpulqrV0RnN*MtBBo@UhU<_ari1fI!03%SgmMx(xfnZor zaE}E2S1uDvk7AoFM@@y)GnkS@@s_qCbO~Dq(;~aT3Kap9ky9xG180+)S2%`X3%_A9 zyywt7b2g(nh*l(EQDjkh&nGpKgG64^uIfxO4SB=5DQA|4l7L!^;0Ug9*X4^sjbo&L zroPCGCK@2LWrJS5z)GlE0=59Nlq4*^jTp2xyrFoSdiOPPD*^ zeShf32tnF90u{nM0jZ#sxL@v#)&}Hcwc;}h^JLdca8BA>wZ<}j1!2Sg)Z$96s2yCL zze(pQ5*^uCTuvw}N-T~gk9o?#V6IWy#lg|m3F?`Xjitp3U{$WgRAsI)tCtxumxZYV zl?50LL{X|sLy)tuO zJF3`|6N8hKXC4`jkZ(}1PiRC?bX-Vu9F~E@FEZ9AEY>q9S{-3-Uf!fCl1TxCrJ^2H zA)Utr1{CHto&LEd6fHm};?dB*TAU?~pgNxC!es@Vl+mb$1V0s{Oyu0fM^eNCEmwlB z=UcR!jEBELeB{#!zd~UEaAQ=Wlh&ay0R;*WKt_Ht2>ClF;V1V)i!yS+w-GHjwRTux z<80&VXYUc{=+Li&2G1sV|Jcx48mT>P(J%vgLWfA)$5R*jG z+GxQ%%g!m+;tshkk1wkOb_G*HV$v6^iAza5BMmk@GMQaJHe`1mzCyHh>gw|?+b^vx z?GH;SxA#vqunDqqk97}B4~oo9Osmey>&VLO%v{%%vZf^?zoWc)x~6MKcF8c+R4bad zRy56&)lIkd9qJu9+dXu;Z}im0>GJ~g$ z3`fZus*L1_S(sQyP>W>Cp<4$o-tFBu;_vTitf%p^5CpU)DZtjroBAd=Y+y3cNvk6g z5@M1QqLZTCy&SQ-OnK3KR!AuWiGvZvZ2@??`uJmJfn|c@k|^Y-?}nUNA~WLYW!8Fr<3&x2!j;1=?erv|uVcgfv1ipnW*s~Y0c zI$~CJN2PVGtDcxUc76Y;b8Wp{lnHQhae-w@Dlv9gsIY8_uxyb=r^XX4!#1YkcfdK(=YBc7HNd|M8&z48Yko6)mO99m9=uG-KLQ^3D+h;e|8DO%jB zJJbpy|H`Q~j*uDyQaxE}G9q#89-Cg`7n8ffKFTk0T~1&qFelJ$qqUAXk{>52IVhp*j5zZW#-0wrZ1e0$}a z_Z*@gbMF-h48RMyIX9ks5+XCNM=1p&yAyToSzWPn+y84Upj z97d9r-u!&;<@eNA5}98~MEV6N2Hp#0m7vO8fAk(c44BNFg^v%P{dD8uJ92O?-g=2z z3)QiCe}4Wc$5n_rw_ox}(wZ*Zc?m%Up3Jc;Pj(!+w*BDcod+)OKX&ufrAOy)e0}lG zvpdf}lEZTS$=fRnudhCS!)?Qmxkja=Z+^Okc<;Oa`1SXHefjghDop0zzy0xFzy9!# zPu~B-*YEy9p{0j!{)htbT}VE!f4%wi6F14zfmB?7{PEhtM=%*QWG>zQmixH|V0DZ7 z(chf7{tcK6>aT76v)+L#SFCU`(p|wCD19y5IgK`^W`tz(iC#K}5Z{tb6UsNlrY4s) zw2+0=J+`ZPaA#HLY;nuhHC3Cd`u1->^YqA#?+P0>I(UYYv4=x4ZZ z<5bu17HY%;?^JdSmbdi>#bp?pyP#o6T*eBep_H0KB~buYMQLF%Vet*{b(iCo`o+Su zSyS2o@JfZd>~(n+4b+E%&(l;~*;HQFOK)O+YdU8k$z-mrKqWP&pgg;1`T2 zRx@-wyK+l(dYw;jD)+W_O>uEa?cClo(3yVy=l|=?fBZjBKm2pY#EqQtZRv%Z*H%uI zwalHl{^r7+w=;(>7dH)WJA7?y$ElRuitOUL%!2yW`E>|~<`uUlrWc3BX9dNsM$y7I zG<9WWSz=~!NPJd6)Jjq+oV{=W)>Sl(kMBI+J8}5(-FG9K4wx9ZndrM18F?64hlQ=G z>YF^dzN$}8&&p8O4810I&kzWi05~pztCO;tt2?(JI{)~OfBEkxPF-D-Q?v+9sF7`K z>bhMAuY^Wtqr8oLsIGyto{{HrvtV=UI5Yc|mL56Y@eMgO+qNHnar)Z3zKy$(-yuba zL~{7OSn0ybW|CIYv+E^0$t-xWj@wc_moJxE8yGu8$7Lm@7g3*-V%aN9Y%tdnKVgov z9Wguv4U)P1 zTaxa1jbdhIW@ZM9$rh6ZmSiznvLuTQvSnt=%xsz2zP2wz-KwtYx?R;(4R5;R#hZzk zh@N;cFXpeFU#@*`^;2vsj*kxPz4ltUGQa%t%QY74aV!eD(nKa@mp2U+)C?5W4N|8u{_{4>i=dPZ)c;n8>%j#gGWvDW!VMCSKcl7G~-qQdw6pU@3UILr}+ZhH99obdWJmlpS zgboTytAIhav~_lF?dt02Y-?`c($rpBSXEqDT~t()nO#DQ?aBG2 z>QtCaNB5|P$<)<%QM-iZURgzL@y03yWonx` z+PVh@wvA5C&P~qk2G3D|%&vjag{^&)^-bN71gcv)k-Kj}rLChsx3oF8u(71PLBa#S zfar**(2y{2{*cgMAT0l|V0T|1A`#iG#j_BmH!cLGk6b*Sb8>EFR`KSP+?wF%402BITIJkRhdFjZl_TJg1j_o@Zj%Vdn(|D1Nj?6et3=@w{ z7jS?;gX#<?J-0{a~u7!V`Q&Du7b6v&ySBTU+}Aq0o7o7t0G2 zZprE+LJ16spw0!l0=@*X6_^a^Iv506^rl7qE}zYi^>u^2vqA>{iI21WUhXEfJQfC4gtloaRz zvj}bjSq0pNeV0~5G4aVL2Z2|wSw*7FfJ{6|5?SEu*Al%VI75n`4qP7I0Z#5-6el8{ zAD2>KVeJI~sb^qKLk$dpsv;286tIi1*a+mv08Yaa^I-Y~hoyLU2Ai2!!IdRY1>Omc zPC~WV+QE~wDSA5uN+L&WZ3V0iCIe~&CL@JcmR6uBkV7ClfvtT;iI;F;q(%?GMLXm% z2N9H-Zv;^s0>7#MGQ%YuMBr$EdZ0ez3?@Tq6^Mt%X5n2DcTwi25IHKg;5veaX_yRu z#lhvnVL2L@8|awmg2|wMY>y1DuP-DSXMe$DXz)s>Lbyp3jxim6L3=m}e)w2|L#fJu zfiHqN1ieJROam|(&0%IUg22E8!@3eSv2ieem@530w@N0KA9U;yY+%nI!Uqv>b~K{_ zE})%K+7vVc?^?kcS}K#(#O;&)iZ4|)L0Yt>g*k*UxFrBGWG4j@p<+m@QQ~t{ET)A* zY;a67`6TtDPDWrF4z>L;uf@05Uc+1Xul84YlE@w4kzgM3m@%-enLYj25Kl2RrMAez z#vIy`yk22S03cv8i~|=Uu@cdfLYb(nQ7w{%FsHGAc!9iz&DcPnJy#l1ySs{lh=#JL z#J$>SB~TJ)jMSaNWHdy8X9SQz-a=9F`6vZs$ydt&s`y3R098@NRRGrqP!AOrG4 z1rz(YrHvK6u_%t<08K&AmyhMZ$g{+drWJMCU$wpk%^-y%s3S2e^)&i0g)}J`pcq#V zA2&~5?Kcz}A36LW&u~$+cB1PU+lQNvH+B^apViHi6hAIKD9o=`=i z&>db&<7Sjbevzu+OEJiNh;}0+!e-(dm{1t2V`OPy?qFu?#&10nYeN$>vYc$~Jls8l z3GivI5fT-T-GGRwK@Ea-{w)ovLQSSD69Q91E{VCp7cmDoZHx-v$DcUR-Li9VBvA`B zmQ?l^miDA&HN_>>1O}G`gqFsnHOakj2WR?aDo9(f-A zr9MF=J|TsH5t||ss^iic)AQQdYSEB{zFx6;u)KC~Q{7NORcBgpQ*2gkP+X~7P!{P? zd-qgVzr5u9uHMNb^9PT&_I89t2U*#gAZ8|&j07F5WsHphw^7ykc8Zx z*`q6mEYeIlX&m z&!M4R2Rg=QH}`LA9Uiak?yKzR+St@y(cDp7iNll4<|tVn6ab+ADVRmG(%do)pW%VF znl#JIgy-^Q31e?H+)~jbFyh>10kq`x66x@Ok!Lf*NWz#By&bHjs@ReRE`&+t(26LL zv~3cfkQzii3wPhBisoSi65RrGayAasb?%~+Nyp6ZGacv8^c{7~+yf)ho!kP!$}vPF z9ynpzIT@~BWo86P-ZUvA`N+BDTQ6Q+dh+tz%8ScS-d}t1B?2;VV}NBYJ^#pY_31|x zML3Z2r9g=T^%&v9y!ht9`=0AgU)FoYe_z9Q=VhlVP%9lW0u08mivLG-S9$dcr_R`%~ zS0B8k@iY((Fo+a1z5nU{s~@gD`ts=cM|+Q5TRL{_z=<1lYF@tbL{jQ+zXg-I{|;iz z*SB7L1FmxK?T>I{?tS?E!!Lj4c>1kiGBjF3+Lz<)Z~hM$GOxe==a*mqS=03u31X#q z10chB@>>Bi-_iA33Z@=@;^5qXhCroG-FOZlbLz&cJx6bqRrgriK})cb9-I{VF+=e7 z#Ic}oRjh=V0#)3HsfPp)W79Vzu%xzHbzPrmA6{q~Sm+)b-FTVKW zzKgH@WAo{-Y0B10iybrbxY+pafng*@+xo}p|ANFsWlLXiU1w?IKussG%v{Il?uEk_ zu04Lg=jbJ>jT$=ve3ob)y>$BVq01jm-~H+Ioj)A7@YUj}mly9#|7$2fcb|U`0qN5H zH%Bf#+=n_CeVi|+E`auT2WY5i)!)4rk?7~9c>dQn?_DG^d3pbZgqB#3JXgrE~%Mb*bi9u z{a^m$^WXp9$8LV#I(j){<7`&(Xm;^%X6Zm`QCD&8=-94v7gjzkoqsU2aB}X*mD0v8 zGWBqFs0-sr%dLq^Esjnp3`;10Eg2S@ADg}@wWukjs3|Zm*E2Z9J18wQs;H`Q92kFc z@xr@r|9R)`3sx3B=K2msI<~q-?pAJbwHhtcAq1ko|IJ_a?LQSBo8=pl3`8(Ex{J~z_-nfBEOpo0>Fc;!T7@A6v(7j| z-!9d}B{w*E>)7u52bZ7Mv~DBS3OTBOatgJp{Hiu*zZ7Hh;PrZ5>vdh%thHUU)_lDV z{fx}K{laJn;u{=i@8CsmHH-+Blk5y02*g1m(5RzEIMr>#uyw1qe#LCy! zF(f#018f$i;?RzT`8|jCA3Am9#PXT*SI%9zjo$C=ho2ukb7#-eh2Gv7cW3{+4JGF< zT|0H*GJTg0oVlh z#%QqbsMIayR~$N?K?(yGol911ABpi9A;D+#;mp8J#6&}v^70AG%d4@r_J(g@YEDYa zf#8l14`0;VC&0_o*V&OqBi>$K5y{C#v2hzbeIuH-_D{_1b8-*UF>nfs%ov_I(lL2F zI$qZ!RpUic83dj*Z(yz0$y7&)`T)M;E-8+RZJ4 z+a~&lCVKnFd-}$Qs6CwA2{O~tHbU)EWmOxsOZA&ODyo~x%IiT1svFyyJ9=n>hIq@= z!XlMoL*w&PY8yMNH*ZDhm%d9i9lgc1TfBpkT|A;{8av8s>LHc{hlbHE zfxr_cjELFdbSn);nD)#Q3D5}fR#R@Uo_w*Bdq7}hTJnZXnT0he*~RI3)MIsRD5>@g zOrk88##=^)RwNMZtV}nRm+m`wY-I8fBHK=$F@X`8qdN}8Bp2(OxtiN}o0_@k=~;mr z&<>s=GB^L2s@81@xpnlgTdnJ`ZoMTEAL|Uv*BP6yGqhT7WDQ$^jz&-g*rq=tI@4PV zPs7H^mK2+_n{8G>R%vC$#)<~|!3BlH0gRBKN0;^B@w@4{t?So2uUTUzXbyLN^(rm1 z$?gpJEZaKGhiq+p{ryqGz~_@!snAkhO!8e4>{8#2)I)Aj;fDMY3rlx>eS&%;UPd@i z@T+b2IB&6WNu)ucG%&Sro5`@HWu|YN7;kCssH(0H3W}i5+GnfiHE(8a=MHs0Fgn`U z+DX^I!qeRsjuL4#oDa09h3lX&5nvHu8EqAF3vk+nD5KCAeq#zGO9;2wNQa8jyow5H zC&Sa*b&R7{t#u_F_6zbIo0{J-e#+ZV**C# zKzy1FA*LsBp9eH=)>Z)<1QU$Ep4UGpv)#|^la&5QCL|Tk(}-umJkq`92A{O$B^LASZ8NXt%{28 z^$(AOBWi4FPay!+Oh7||yHNpVZpIeZeFgCl zaUk#%p~MIjqw?E4VEEy&nTm4YHmK&*>c8u;wk#9z zF$|?|FX6VWvmK!-oGw64EppMKDlNj|UEB{XjM8E#%^R2Cg;@r5LD)4?DM0lTPlC?? z@yVX3P!T?gMa`k@jC_;~k%BB_+!ParxyO?jH0^nud=CCA5w7Hm8AI?#5n93+64VR( zRH|U$n(8vev{pnEM-UuA6XIkvOiAGbqQ5QwT}Qnqzoo89fhVg`rsXjwMopjU5$0lH z5B@JF&+{w^i6$5;821v;6VbDSNuwF=0teWQh$Qo3#lsgMLMi%k`Rc^^V7XE*javqE zgIutaiwoK{Bxv|NPM!yFnP{%W!5$5g2I3*Wf~G;jh^v@ai&Hom^@PkK?Orf3fQ*>z zoCzSdog?$x2hiKY+aGcuoEgDnynWb2gcw7$l+xJ-kg@mhCP7c27aj`&BN{Tn(a|hM zRE$vc3J8r03QLsV5%F&RK>#wMl5K@xDIudJ+(JS{h8?4#*(?*NEqtMa(zmk3{Yoy@X5UI#taJgN6kVqa?2sbN|bH!~U!3q~?s! zw0<$gD*D6k64wg@iRn{=&-7Dx5jO=FO@ED!;d(<0V@n4rGqIi&Z|ZR1UFhR+*@4nn zyZBM_3nWEbALyD)IkI4~`zTD3Tf?~^M+Hj+ohU3GH<4K?bCn$sJF%KtRy`Xh&-k>w z+NSQok@=;A=PzD;w({)TYxh5rV&1mv+?H*JD!Uf)8b-_8X0s{=Vl$fJvs#jK+EQ}c z^UH@a3p=R#_X$q1b_lh!3AD8GH#POu)%UZsi;v4_Dybi(G|4YC)7mcB#MIN!h|+$D zf3CWQUiyXshQ>iArhz7={-$O@hDJVyroN_@fhLxIl!b~Of~}98W0A=I>ObjsHA?!@WSz-xt$dam0{t&LS8mtB?_h?#(_;upPMTJjM@*w z!VjxM*x%~*Nnp%a3ySq$m<&5L?_yTSWDuWEMvQwc5ge;k_~4=m&)k+D%o`gTouIA4 zVlp85-`aoS+3da}=~)>r_BM7vvIt07Kp?R-vvhQI52B-MWYUJXj657T^(R-7j# zYbXerSirPI3>@@^!#^m%+s_9PCn~&v!3jdS9IO*SoQHR?XFy_bY)M>pTXcGxZ&;bB zUA&WbKD?%#$L}7xcyDxmaYI=}d`3w^Rt3?JUsReK$fv6ZCnZR$i~td?9vLM>+VO(& zHdYKw@9dx7H?r^W!0x54xdo0o3YUh*Ter`4&o0t#iKeg|1A7kjEi8>L9-BULW_0gi zs+>mm9U9+%tY>;JPj1_NsBLVzv2SE^?{HmLZ*>O^Yq|=m>QZv@10y3z1hcb9A)#pP ziUpLh;!a^CRo09ZuV5DCduf(UX?DpH)8HC)-^F>8RV=qyOsK+SBy0z_5qTf6(tk4@ zf7@APgClN|q?8=&P$UPvf|3hs2mBH%lL~rrD#t=n>QMS!V`#rx7Xei>I8wU{2uz0h^zns-ODm5aeL}PM^Xo4@!H|JT0y6{-4D^`uPu?#-cy;FX z^UKgtUVKU0>l?4W2DG{P_6HPZXoQVC3mAn4$iPAY^tk`_M=+2F?|%S_dHLnfFKAcv z{g%7O`oP}dK*xsbg(`!bFYKVJ_dkax1159n{<{nJ z-!0#HeeBA!qnDqK&Yg;kFElf?C&|uKm9?)9u>*LdBDtbRF+IQWK;RaF$*{r2r6iZt z)zNajrDwFMcXG?{0`$Fz$EXq_VP&CjWM^)bnZ2QF zU|UP~wx-Up`YnSsEj?v*ZACS$U>6lzMjAV(n)>FNduJy0oH}y$-oewi(SM*h%h>$M z9eb}HzVh+LtH0iS_0PwyeuI+CwMTG)evf7j%%v+U@0PDWSvq}d+ro1B=52{7MP-{B zw@oiD96CF(?^NIPQbYGxVRcJLY?iHa04?YZbj6RAb*XkDE|ZmkDU+G6ek+ea`~n5k zn$qvs)-yV@td*Wnh1HF~o>eXF4egx`?Oj_3#%5s2y#CF(l`lE@*woU3O|>PWcTq?A zQbX_5(4KR{i`RN)F6}$f3*M z`24$>-Df(6cL67wnK&4(H8#~nVFB04%E*Y0=Pqk?X$#`B&N$S-GSw%txqIr$?jTaxiJ$Uh6d```0Yi(DpwbRkDTer?kqz&0X2(S>fv3IX&=`X9@>f#ba+jQIr z!Z9&c%5A_9iC>NqB-p=--7u}1qt0F<+l_cw(kM&vbh3d9GgfnMMXyxxWOxN1LTrT{ zCJD$r7Vk@uB4o=`ahYH;^a~&nYEG{N+(;)1&&i$f;p$`8vV+jc*TpB8I0bsAuU`0_;zFyx+N8irU#ycV=uc>_;eK|Tc&+lF$W@n1R zN2Zogl|e_2Dzl-fB^C(PbHU+BlrzXqEU6ILd0EH=K@60@F=SBj&Q(p87T)rhq2uED zlc-#hRH2Aj$sOC+x#i?+a&rp;I)L8@o=U!cEw!Xb3Kv{)9y8B03I|s^Zn<2mqk4}z^PH!8X9T=J#QJ4&wudc3%En7xfTL)WO`XHE9 zRBbNVSPL>ku}|C9fxh9<@#(qonVpk!i}2$5#%B9QW{?POYU_h118a2C<~EpZ`IRk> z?ooP1E)@4Qw|7$5OYkcUcHCdqIli#7lerV6Bt9tQATJ=4D&~fA%h9`bboPbjK{Q9* z&4!Xq==Y}PZgldFSa0lLVCD$9MFlgu{yr`Xi+fNJj7_OAwT&{f^&=B8JhnGIyUNBP z82J?VNR&9iHUT39lrXV&iA*cruyKpNndcfEJHSbj^l+KPE!HzeSDetB6`*({;$4d> zf}uVtlp&#z-=iz)YZ|t6P@LlC8DVbeLV#~!VL>U-u`~BJ$q;UnFMEKKMBF4 zZ;>DaEGtPkQsQAGy&yfkrDH7K4r>Mo^uK)Ub*oH`*N27swY0U;NBgtYsA}j+I4vte&$=QX4 zn<|sDvq=`mAs(2R2G(a`?Ot=03TH2?|^4O<#cT)4ZTq|4GKY26whgSB>~ml;F3a7D}zhzIMyqEJDr z#KYu|6ts(dkd=QDKveCr*M!HD#hD1dA)5prffqPA+p6LgsL8}N}2{gotgBhhn zgmlbpEoglO`vs#!X4wzkNtSaVJTX&gwGa6c22eeoVs`zTbcVshUXMl zu}ygTM?uPR^YpW}aS#I`{+X0XIs3U)G&Mkjadr#AfA$TI2#Sp10J5Mg4MfP))+R72 zjz5uGVcvo>P@f=p5q;We$xYVGf_4?qpPY;#ySqAh`1umIO6ROKYebA%9e{gcIU!vG z$eST(44S#-#ya=T=`1Dsy zMm|I#$+D28Fhmsq%G{99n<>v-_~pC!b_K;y&%(fx*ASwqYN^aVs8)l(B;o_1SY--j zl&9rlRT6fM)F7ya)N&?@C(j^&$#8&XacGzf><-DUQdI|`$<@x*)!M|8x};wUxL6Gg zkhbczSdp>d#>sDPGR@aj<0?*oG2u$J-a}e~=9epFB6D>tK%_aW&FGXQVsYlQU6DRb zOchWjluXc-qWlWx3_on^!f_JWA!8;C>=7=XF@QF};K)Q(nP>@vrCx+6kUvO*9)yQ{ z4HZ}bG9ls7*hBURYMNjPg5g7?w05$$b#b(HbEe@hrHC%Rfg#axC~1VnAtMtFPsTqy z+$%7|$3GnEqp!apGmy1xTwLJD!7;;hfKHGM!XQ(%0}up!gx9TNC@xV562eBHngc$P z%7beYk6XYzO{^%M^#;EcfXmz8!Py<&3+A6`2MI=2o-W9sIUw+A9ewry{)Bl94v#3Us_h+_ zqW8hM8!ygWeRlNB{e``k+ItpqiaR0_EB#_N2B$YAl=Kxg&z7~%6O6=Ww`3Ic#%Ht! z$5td{Y)(vXboWU$vGmZ>w>37Qot(WKdM+j=LEZrcsd*jwm3`rH1-4FsL<&f@bBLG* z$wxh#b!%<)be!n?KxYF3?YDsgHOqR24hF`K`X;vIS&WUH&CJ~3!5W#`>KUQjWo2YY zlN~F49UDUk^9!Dyv`_kQ@z@5i6mkFBLCBTRU=te#K;%1M+sgbrhahK{2uo3yG~C z+I8#5_4kX%&K8uGxH>vGSzFK?9`!}kuqjrxvT^ecj0ua+h)K&yNXteIJ~kyWIzBQu z*w@kCT;D*dio`&v&`B%|iBwW6WCEGfW)5~Ps8Hr6=al6Z7rA@8N`{op*Z}<;X>YBu zUwA#46yd3==4GV7P+>xs$-~Pl8W24(AviF=!_z$=D2VRdVG)sjfsxK0;RppqrqqNb zR=Ij7ncIXqxMw8ibZ*;q!J&rYbv&TI0Mx8(!8OuV$P%m>8Ow;*DZ# zL1wU5yisyM@)~}#vxqrk{fcFk;x8Ei@#bAZVhb|M`?9LX(n?1>!phCvQ_Ni>j4Yif z=fpX2cJ+^p%|KHKcLL@lEd>GWElgp9>w364b`SKOy>suzn|F`D`u@=u-=hO_>B%Pu zFu*d%#awvw;q1z5j^#Tqs7n$t76saX+aUZaT$-0(U4QloZVW{(ci()w^7)T&V^$!p zyp_TwFd1Y$o`3lLo3DNbka-J9=Bqz~Z@l~dPZTb3(E0lQ>+cEw@6*-#_1E;graB1_ z<`K}x^KWiF{CM}tm%uXM9v5%Fxp3gFWmdlYGnmXH+FpN$ zjLg5h`r)s%x(1Vh!viM6Z-ApG?|uURft;gB+1z;gwNQf;CPSyED|g-?+j9Emi<38A z9KQH?;qZ-$h7nuGU`rEQSevp1bA#1JiPj3HfV+%D0tfezjf@Nt&D>FBqR^muYj^jy z9ev|-ErS#Fonyt79VL~WImONCCGAP2!}+aC+YUa5*;3OqVq{=rs%Pr!;kB`{s&{mP z{z^oVo7=ZlG<22Lv{2VjTHlVaO#Rl0#-14(D>rmc^-b*GefY}0L)Tt+&75r-Ix@R>y{dk&yu9hiv9o{wmw*57|MNe;`uYFafAQ1Oxi9)AuFURx zd}R6U-otli7cX`U?M}+uZ10ZLSaNh`ZB5tI;+cCFAAK6xc_go*Spb<0<+S(-j?a!x z$pw=k5f1?Xv0nt5T!J!uV@hK;G^G`^lPHf(tghZXJGFRY>cF)ZU;X9aiH8n$A*MQJ zmO=`~&9ySK@ptt}$jfg`NiH%mva_=Cs%Y7MlXt)~+Pr#GM;_xRN20lc?WTcagut0?PCzg#3j)a@y zjbQ%?x6vk*&IsITnJ;!LN1t!xox`)*i9iPR0;KXpGxe&%gE*7V34aKU+@u_9a6HIvJ zu9N!W0Z={5fG7Bor+K|3EG&~!HpIrHp|Z}15NV2jsje_<2|Pt&!p#qV(#0#>!7Uiy zk`}sjb!phzlT}hhKZ3<$mp3*Ig{9ZE4DC(L+myGl5~+&p;*GR?BEv|=P;_V$QgSxr zR#jIvwKn$+j&=`j-_kim{7%=WtzAQ4G8{uA)2!kl0G6StzP{<6o*nJ&BTY>`_4QkU zW%3Ivi%ViR#sNtUVcu_ zzNmb=`1nMprc&#HmK32bzU3+aUSn&CcCD?+9b}{?T)y+5t$)_YDtx_>FHM9)BN7IN z=ZZ?2(PIe+NV2u{ByeF9W_l7!fDf8EctL*S+`tp~6CsGqTz2BsYU<1Mm&zjvMxZpC z8PHHQGdC|SD?0_Dmb}8`4JGz2!Ib_XkcCT3QYj-V>)_GrDH(O^*V=>0pcJF&EfCj$ zLx4-LA_S07tQ&I1gq#kpE(HD*S+G)oLDqqLtX}2r?39(2vZbvVo(#oaOmbQy(LBAa ztCM=M@u}&B`JJbZpS*kT;nSDzp1k?A^6JCOFTVNsJi`04Yne)sOv4=ayeUB7n!=JmTbZ`@g4 zzO?_)vB@2?gTo_T-JKPc8xxWfqZ8u7Vxy=9fcqg1n}xaX``5^Ypihg~HMRfiO(H*A zWet}jBR}op?W?_Gd%c44_4I<)e&($6nF-SuOCrYPSMeNq1PCA;4b=lnnFSRMC|()1 z1rizdU-WxboJpM@r7GYpR+fZaRO_%V7(EG~%uIO#snuMg(ar~$OOeC+q(Mb8(LD!#<$C6uSh#Mx||_IEXw@2 zG|JEb-1vNkol|2S5*wRYnW7H^Cc_y@#uH@#h0HJ?IkbhQAqFgAxEe4o=?d-Y$@;Q2 zv%(RUoVdpMCsvYuM{!y>1y18{emG7whlYD-Toe^;2~~y%Ok;L8mM~+i#cta0a@A_f z6F^3Rj$-7wM8R??h){07yb;PA5i~>;QE`!CF_}fAB-lGR84Zb1=fm`7QbF4gF;cFW zsY9w%(~4y8PMq_EfoFqy!}2xv3j0l^$@ zo`G&2K^|Tq;Qu6ms05VYSBYH!jWOG$jGBT-etuPekxORK*r`xa2BXtj3+ZUUp<>Y> zeMY$t`E%4lC`}cdk^vAxf))S@-l#@gZT<3T%!<{_cM9Ub$!HP9cru;TP|E`;no!Ey z0$0nJh&2>QhDE>#3rwVLnao=?XC!doWdal%m{_B9Z(_{qVAJ6Ryhw!8bLwzNjNqBQ`rzv-ePRJ~;Zlx-jPLyY_Jve#s-t4|} zed7nJS|^ipTZ1Bt-MrFl9AYd`=yixi*w8PrJ}S36I=7n+zY)pR_8!R=wsB_GF&=>% zQga%K-%Tyy09(^HMjBhKH_=^hZer~2>Yf^zSd&)J5tCkJ;~WC0B2{w=z2>@@4y+ce zAITI}JhVsyk$0j+8RTR$TraFK_Mgi%Ffe02vQVTFkk(10J>;Eo2*P9FYGE7W9$Zq` zuzhs*vEGRtd8K(CUUt+Xn?R2NjWJlIZz#XzE-T^_gC`NRFe9YIRz{n!T2Fd%;k`1h ztOX9W7;zGWW5a#cRug~a*2ws)CBu#692Br3rH%?%w8Qi#ti!d-FkaK@eh;IN88V=$PUwwxXZYnI#}7!%7*5!$il zXqQo2?da&}?dum273~)sMENiakggNt$Z$dZ!qQ!Qqa7UmZESpO9i#jrN-H{c?>zJL z(8ZOm?K`7W%Y4K0ydz8e;>*1w^Qj$hcJUMCWa%@`#p$u`Y@FTlDr&ZFpKc$YrKb{n znC|(V&Ew;n$Hp4BjZwbTwtc2!YJme-rfY6*H?Yi}1AV*qBPKJjbMNq;{aw=w!@Cc3 z!=;(o*D^F+-!)p<)K%BsSJ}3;pte4zyppDnK@s8j35=3pP)a@s7)`U@VwTmR#!YT6 z_m0tEOc)s%SVe@x%(A)gm=R)OiuG0v@^}|GjDmJlH#CLtb0f6Rlve`iiIyOrB?^f= z&*~h8Cp=cbvxaA;n{M)M~X?xp??Puw7aJ#>Xh!D z&hDPk@i%a3L`LQnV!2=4dHx9y=Ej51c}$0Ee&2ljf&T(`0LWat`;M9v zp1F97K1wg4a9n-z0U+qyowtY2Jy<+(ovNIrQ&;yMKezkP>0O7;>^yw#{OxCOZ#YAd zzCotu72ULdy7e3-8MIRWc=zKUZod2N^;h5DrRCGdpC5no*H=IN+w&j(_2rNM{PO$1 z2qyFO&vd?i_EFkGQ65D%DB3*1lY!NPyzq@DUqH^eeE)L*nM*fcqbJOH9>4OG?$QS? zJQ+J2@HaSZ( z=(@K4_R*=ju3<_uKp}Dp>yV;ND(p8+eT_O_moz)mesUZGHnB6k8vukv5eBt=6Lzj0Qy>>I_ZDpvw$0ASlGJ_StX+jnOA|mA0$Qe8mWo3zz*|VKuno`gGo~ zcd?~OMp#l-Su>)%Lvu&khvzmnZmntRq;P3uYTwzLua@t8Gro9h+srA-rl`xvD=y0i z&2Q7P z*tx0QHy4ksEZ_Q^21#dcyj|FLmA4dDbr;n1An>yPER*LdJQ)C)nAD@RQQB} z;YqZ^_VSN&^NB=v)FU|2D>BnNa)W<}Xcum# zYXw0BF@M=64C&$MQ@m;G#MDtApExVKz^0zX{mU=xU1C?SvZAGl{(5r=EwYtZ1lT)7 z`3L9cl@FY__WsJFFKG=7vk^BMb$DDFWYz8M9FQ0=psB|iVhsmGfORY*T_Y+Qhfee@ zT#YO02~2Mo-hKJ@tKXfv{G@18BMuIYG-%F5l_`b=1s|7ysM^l))a+`q5||Nzd{qV$ zN8&T;NbrjJ!G*&<2|$AbAP7*q(B?@6(cE$bzMWIgtJd5iF4`>P&`04z?D!r zBGEr)Lqc{9Qa^|xyLd)KL}#U>Zu0R>^74oa3(IJ1?wpvP-@Si{<~yg)T|RyO#-*DN z&tATF{>q~h%eQCd54X1V2YLo4L?#?Qe&X1`{G8G#ySy5?tm*eEeEJu9=2M5PS1@|HCx7>^WGo2tqhHmBzo2Lwl>twG&KSaei&)`r@ex~7)aEgf)=cXalR zp-5A+xxD~x*_NJxp$SBL`v)g`hbEEf?j9KL>!0fHo9@^;+Onm;p`o*?s_d=da&~^-_KBU_r+3kS8!)G*kBX<>>c&h|&d92+sG6ObJ9G9NWpo#>-@APC!P(2V9zK8f{O!lb zZ$7{M_}RtlcTS(Vx^&?5{Nk~x-N#UR-@1KQ>+o#bw)ysfxu%YZ>Xu=S%FVs7BGFph zymfSNVv(+4y<>}`^T$E32geVOPo0>ZJ2AU(WdFf4Cr@3!aPj{2+fV5ZfA8_Dr>{SM z`{CogM=LAOp1%C>`MYnvdH3B9kKTOZPgif;J#_Hs;e!XKXJ<#JW?32qm4i;6DYo`r z^phQ!7}NSTaLp>3?-^k2TO2(2QI0s0o=(P$NMQ#v0KT zDtgfQB(bjA=9(ihf!rS%bGTV>WF%k#Pc}BBfJu}IrGcz9CJ1-l%-YDt#md3W(JMey zxgaz^QcXxo^70J=&tVO-H{-!#msE(Y1Es;q*`66I0FkjVr4vaTiUMO&{KDwC9Y)3z z%!*(E_a2kTnNx~O#kjc*ZI$fd1o{RCk=74Qh(q|oD2#aBZqAH_-r|crFgx&mn$^H|2Grbfzz^oHfjCTlVPUVAmm4qB(Nu>x5 zTg3SDBan=0C6D=ql4HZvU?-SH6@DQRe)wv|)(?u={Kr>a-wVk&z(2 zW;kVDOHTxKwkntLx6_kIkdQ$nWkj-4HfG6|%ZHQTaPe|=^{}_FqVE{p0Yyzh;t^S1 zvYT^A*ejH7qQQ9)N4H_ncdBE@G+!<6}03^aS%Mjs(@UfDh zP)u^s+c2fUmY1)$Ux>fEpC_;k#aXObOaU$gn2d*CFxd(!bbvPlBEtP6LRrFI{sF+V z0QjH~E0Pj3nnJ zH%Jm@g6=Ug{8!>zmGI(@^GdKU#PeC2d=xMmw~r;pQlg*&D2*A3iXD~FP>6L5tm$YB z3&q3?Ib}~*F9t0mDWin0sSPdY9Lya(b%U7Y%*DraI@mfeS5(m+kx<~|9dG3tZD$yJvKC!lsVXH{S#cD_7tbrk}R$GUfjFwZ^K%S*3G3W|yr( z*u`>(gv!Dc*6tgtKzog(2>Bd1X{=2lcv~2vtN7EH$2 z5Td?V25uZTLUa`n7{>&$;uHkRXYq_IL!I@+Wqh)n7%4ZtA0ipGOL}4=I1TQdT4G8S zR?tpfBj$)T$tT#_SkV0$wz#o@r>p0N^0xhxhgS|>xYIE>7~tniU8Z~#yf~7O0L2Ez zCU&mw0g=#LIb=~zgbHe8D6Q@JDDirf?sR}m0hfM6zB6TVao z3#57zQ#ZfRik7a{kts+r-Shj}XLrMpY1+QMadfnGa73&6%D>SaKremSFX~sXH&fGZ_!6kdIgxHj# zi0EW=&=7Gjw{r3iO$v%ghW18{KlnE7u>t};U`tK!Up)W#;qiO-&OUv4^X13u&pv|5 z+;~NEXsefUXW870iZiywaA#XmlHFA#@R13mlV_R~+- z?!8-i@h#AY;4{xZ-FW;Sk>0C!-_mP|uMl0|hwm@nd3o{9%L{j3U3~EV=;cRyPTrun zX3y~}htJ*GfAZ4e@#Wn|PwzRpeB}I1kph19#g#`NIpJ$7)ERwo`^8UpUjN&G8{kED!tAum4s^yKaL zXx)Gy!OzhOrr^n(zxnFo&6iY399zDB@Z8GIqqm0VPUly2Iyr?H>suR>43ViWM1F0h zaC12bw^{oDGWeUe)>iCp>FMdvU0T|^>2i`=R##lzGB~q~4obDH10|Jhd4;ukrOiqC zO+jg!?SgAlH_e}4`TN~RAD}Wpr~9GFnZEIjkXtY$* zIoi-SNz)$=ilLAW9-lipy|_%npyj(?-+lMj>o0zO`Sm}2@#DWd z9PoiNw_oo(dabg)KRdr>Vs?qz0eT_LAG^^rwXeE+IH_^psTa^G^*mZAE# z{^qWc9eYk7p*(l^VO_`G&Vjupo7#%YYVwQ9N-FA`I!7n=o@*aFQrS(Z0Xwl zH~;u=|M7qRumAl1&;N7r%XX)&%ie^ZdB{W*{2#KSGBBHY1LDBZkeqMf&{(&(_USK&rL*soS z(>=p8JwtP1(l-~@PH!GK(lveR`tu*I-TB7fFT>i*71|P+cZ?n3A(|ms`3+|-J}fz`f;EqP*6lT0|UcF zO%Hbh#)_W4g{yC2eP>nE2t~Mfg`@*;NhFqnNsDBH^6kagE3FCfVfb#9XcKP%C!1_3 zHlBDE5;CAYJ{MrW9Afx!B={EIj-AJCK&o2OYHTU8=V9jL1aPSEk)X=p$XVznVMf%Ja}OL@#BzW&Rn{E{>t5Jcb}fU{9ta+ae54G?Ho=|&I}0%otU0E zbLBdQV%K5e$xQ7&zGLSRWMp>iIySNE*!cWmj_o@SQ@%v4P;=*Kaz+{9nv}y}*AbTh zNZ|+D&m}7lT(kCE1^Xt4=B{h_4A0?+ikq+U^+Z5vnYpw#GBviuHIR zK!mxuEhQK!ndy}@er{@}2Q-yOU@sj#+nPK2Hn(mqDXp!jY@#hu@4$9|8Zep8!R_Fl z-8~asUE5o?3^g`&gUOUvHW!sC;iio>^{r54ItNF#vtTB6?A|`P03ai+qXsA2I|nzn zL228PU)`8j)sS1!5T1}l&v!`S^w;R?AKz5E844dT2-nV3;Tm!1Q4RGB41^Ek;Nd|L zM?`D_=$r#Z)t-TPlGKmHBqb)KXNAV5L?vd~Id~zvVQ)umM6j)mgSmxCN%^MBw_j%# zwb?jCczZ{CczAeuxcByL&)iURpn)N!A~cq=vkO2k0YMdU zvhZBluPG2v!3au#sK-#Olno||I8SL^aAca5V}O-&prwPq0pzr`2)4*>Zfj@S+}e8d z^oo~X_PRCJs4-#FL}Hb!sE*2+a`&ZrNfiOpY*c{m=uo?s@SQbn%LM-utP5u+D?INurwrZVQ8de zZp4_VVj4k3_$%lE;RBq=U2%HOP1PB^=QoryJG?Rm)V*SG+>78Nc z?gb{}6C6X(L}4APo)0Hq3oL^fVHz=(h{1x%P`hN~OcyR!#7?2jKthwUJAM=ugfXG= z3rvPlZL` z%^IR7Ih;oNky%;5c#x4Kt)eg)AR3THk076bxTvt?#K`otu+)sO#7w$-vuZJEP{^cg zibIO3U=B#TZGM;%e3w{JoFZ;3k?m)n5r|t-gX09OcWrX)-0aD8nceIKgnli{@kTMugeIlX%oBttnx+ zigy?T43)&rSaq&mh0pwnL$C{+aD`yVi#1e49C!(|<&6sD`Q-yuqaqc!N$n5wNCI#L z(sBYkP$wp^3|GWP$?PT~030SX0NddK(S(+_CBotvB0)})Csh={N2=I>NS_v+Hr8H& zK1ggDnXEx9nX!~>O^Mu#u|@G#FH zf6Dp@Dk;@;a`i&XokTwZ7obM+O)9(+M@N0Nd^`V04yu?-raAB(!>eIgs>B{Z=GS5| z+2XZ>5tALBeV>`53%)OyjKugVDbI{zc)3m5e2_^Z3rPL`-!K^o>a_{RosrOf41E(&DQjDI(j3wS za=qm$zzQ>0pODm&+5t2n_nx|Q@&1QHXC5JDSW-C{9987t7He)3Xle<0)zi@2OV`*< z-^3YqsI-|Nf2U)`p{HwWVCZUQ8)o4Y6%dg}36iCam#%@`+I4ok5dj%Hmq5h-4E4+b z1~iVFnUSrZKXPcrxn*rBIdyLSu~v4TCJ5GcS022&#_Uj!CM!5PF$AS2z?U|)2@(bxG5IE6dQ z1kk3C+!t9*yg{gC%x550!DOr~jVXOFaC33X$f=&0JNX=8fuS8cA|pb~X-8(r`OA7| z29km_Ftc^`3MO+Do18&~GJ8sVMmAKL@R(rwH<}S2D3?-97S?IqDgmGXk=T;(uSxob zCB$VGNY^2ITh5s?(F~?$0k{w@lXGL$$?C$=s2~2zh{}zS<)IHf#vKtSZ@Ms;vMjlB z7~R(PE*x}6wYPJ(wep12=@VSu*nQ;a_1F8(-XaYYm00ZRoe>mM9iGw{9Jk5aFP21y zV4lp|b?XrZbMp?#*|fQRbbjLCnU3k*&69I2RLyf~DozpX@%Ct|-v`y>)ndzS1 z)r|=7uBE=6`%w2C*>iAs*Z$s_-Ti0+&+bCnw|#7uCNfp6z13T~Hf?S#tgXo?DT+>m zr0PS0KyH>Ip>eacLl(8RBr(5YRm7+=4A>iOO>vU4kQM5}6k?ENE-9W2LnqTuHo9Mg z#h4p7jZ90PWITBRj{wIAZe$HAiEQ~gObXg}MrP0q3Tj8nTNgsp>TJDI06FzcJq=9U zOw3))EgkVWs9hp9^bbo9iO%v5jP&yjq?cuASP=5g1KS5r-@dWD^61pcvkOn&+uE1pEK z7h=ra=OWk(Ndtxq*b8Ks3wNGhz4!Y3ji+aBJUw^s)w$a*Kx2@RdHVJ@Xv-Wtdw1Wd zo4b&XIem>Xr6XsrA3l5a=!I(s&Rjfk>DJkskB|bs_ULoCG{7<-40m4s0476;$E`QN zyZ_;jn!4}X-~8*lpZ?pkZ~uv^rI$ba>#N`V%ZqRS^6I;PeEsb|Qg!v@{qJcS_4w^i zoIFUyqu1X88Bt(Gbrt$Hw7upyd;R&jYtK$ycy##8{n`E3dd7}s6mD_$jG@6Xz6Q0# z6ezLH$)S-(z%b#+>FUwL8rmwo;{jwcGc&7d=|$Tj8S2iV+>&Z^diy43d&g(m2PR;= zWEa+D71So?R{KU58aZUShc!11UB3L}PXp5@vPv3|_U#>=fn7rpM@3ybM`3kweihX|S_Ie4cR)sBFLp1%G3+RBUe{$Z>o z;SFjFUY(2#Nb_7hV;=+i1plO#!991!4m@%Rt1xm(_l>FQpFDN@**Di8 zykxl06T>$KZKnZhT4{a%)M3BSj8!BF75swPAz^{FXIH|2%YRiGLXlzcF$g-bK@wI| z7;a`@NS`lQKwE#OCR3j){ zB1fRyM@jf{GJF?a6PlCA5i{%ry6US*2bj31j*ugE5vSMQcdjnk? zJsnzf*!cN{w6=FIEH3RmeC*JP?mnf0Y5&plONW*(T)MM=-{I7h zjIzp_od=H4bZKGf95~GMuH$rB0+yNGdur$Y^YCOkhgfvGhNky*49~!m$uFu$sKgK^ zEmmAkRJ=-jGxi;9vZj#6B@lsfi08&0%0{pG)lx?XsdQkCfDJ z$*rm_s;&y{ZiA^ zH8kEeIMLNJ*50wLsin86rKi4eYgJ8ac}+`BVMS?W15B9aEnC~R_Kb|}*tUIkYN6%khI(2?{$F9cq;qvOP!qS%5#3G-dR5zb^C-)dQKc*ILlwzSvEC&_G zCQ^xSWZ+B%y}6aAyI-ttSceOGO}w^GOI&l z@?CvXpqi7uqye0fft#tZ8y%fY4PAgPd2C|h0>B8To%|Of+a|V-dKUJ^Hm)?TGPCyq zgF?j!=0-$J;>P+`n$8c-oE)4wv3TVAoriDUeD&kSmFKgEE{^P2wsVME^O-4t3@J^C zJ>bX?cPern#-HLH*1|7{fr?}pcZ@%k^iu7`9Z;MiUc>XyHgrjHnX#61bkHy{Hv_@I z=#l$In-?k_&Mw{(u?h=Mb`iWt-oX#*sD`j;4B=llx}F7#|HL6PlC~l#u2hmE__T%1R{F zFAGqSWQ4B6S*gM$x%H|)6l)V`4s(a=3?>5|lIj>+M{5fkGZeN_A?C2QHK&y-3!k3L zwD5qHL75D9jWR&G|Da@I=OhP3SV)LNsNisNgA#x#V8;^X1It{{66J48jI6j2P-Org z@WePYJ0LGp90rN0RZt_)1kd1Rt7I#$`>QoNXGu~qN9LW+2bKYov4`#E7l=9&>&_=Q4C#1RKX1A+NlPX- zcVJdJ%R9M<8a7jhyCSEj<}H()OXD%uF1rBd$%U&MEpeQJP#9$K+qjPa?!Ss2b5pdD z;l2}{@fzV)LAn4H0sYfJIj9$^n>nb9U})TNMVjT-%l#rQ*5(PA40A^D+IW)lQGb-r zlpFZ zOYnyL`mTWm5|P6*XWK^(7u1i2r`6I6#@Rc=&Nac&E#A%{0=ZoS0|yci>vgQw=>X;+ zfC(4JR7#L^jBxj)j!@T}9*9O3-u_{!-u_V(2IGs8A2cws)ibfzHL^COm+v}#X)lXY zx!%;(EhIT>Q&HuXjKT)ruw;5gLG2(+5D$~0RfWm$TN@d<7eI3gfMxP%fiqb!u8Lbm zti)E!YZU&8=8v>%7l%`gIrj^BC2)NceeAWDy;GulKuLUVXY263(S;*}6Vt6*JDXZN z>Ka?>n_H-@rr$wnMfHZF(#+hvl*|m+#kBgOjW|}CTY{ZrGB5)qQ^`_Q8sG-HpBWph zF)|R9S5A_z1|epys@cm%A+nF)t04dUrsukaft87_lcjZ3ddc|Ik*7zmKb_jUHz_5~ z+;lx3BC}3)MHfi6W*Qb4_DN`%Y|~nifE2$8^VzX$UjD zvwM1Gb_2`M@Ot~w(V?A7+ji~mo}BO8F-P<3_U$vxgWIdydhvKGn%l~oTeCKnCg)~T zb4{78T4GXn$*2n6{wu`FO;jdDt$JmdSt5)KgTWwxq-o1p){VA~6mBnr2E6vGl8pA@ zg2_PpW)h0&Ql_3k=1?=1%|gbR%LYU=G_&&!YaE!X?_Knc-e}|yW@6`089u9Hy)JXZ z0Uc$8cWC+O>=qiIwy9uaYfxaco0B_xnvbt%ZFBA6b0;r8d3yEL`|EGNy!G~*haZ2U zSrR0f+i!ok`uwYlk3XJUd4KB8tF!lBU3@5oLQ=c*_!GG^%9H>)u0Q*VF3Hzumi?8O5bMF}UpL52z=l<%QbnnBOo%IpEe3|o=daIs#>Zwb&pI^T7 za_QFdD|cUAxb+k;l?ngv@ z|AxRXm<%so&>H*ezrynYlX>v^H^>5m$sjU(_vu&no_~qH4dqlf?n|#F^kmN6e7$h> z>8Zs>C(b|EGrK%6I$u<=)y^f_z{rIr$RzogJ8jCCHI@XVHC8O&WQt)^Kq#O+8G_gq zHMQtGwDs(0>D^JWxudMUjo!XUEDrA4*FLaIEL&bhYHn$4TA{07(n^CMbEkE|Nj*K2 zchB7UaqFIi`mV9o-m!+3{;Gz~;tGJB_R{K>62xShd#l<98u~|?x9)1{8*AUTt8@Fr z(9}T+H;$gWKfnCu?(4tYd;O0~_rHJr)j$0HAO6SFH$UEf^#1YdA0E8=;l`7%K%C|- zJ*e#(E3fY&pL^iwQrp0us^-zIkwca3LrLq4;ir+=M>S2-7)o%1?Js98C5@t7CkLM# z)nXLn3-!Fj0`7s)KH;gPfN8CgzOJghZ))4_)AZV=U)7$urM9h;JN6tqf9K7_(aTk> zlU0p7QDNOWy1#(Vzon351`pDY@ATdEWj&?ky?YN_`0Sg%{@efazrX*d|9RltyPV>k zDVhB_xjk8#P01rbXmoKMLw@rz6ZknxL%ryYiiS0G6lCs$9pt|0UpLhHB0ECjVu^D2|q*HA5(xW3gh zyf8Vxe(~Ptw;uf_I=j zLno02&1-e-bxZ=yT+?!@cTS#okx??b!Z3WbX{5bxR$gV_)Ul-#=dT?&GM`seLWABF zdL~gBMJNcZFKu6=W5%hY>@$W%iq^$6;iwa?3Qbzn%p|13#lnUwJpnKoSj8~DSh}35 zoJV-+z%m>JOflyaKhEQT$p|_JVFuzqHSVghsjLn|eSAUO2`hVBs1&r%gD3N!n2bX4 z2_J|-z+{LS=_$YwNv&l zAD@{!b>!3q02z2Pmv1}-lev87+4cKxZrpuy_}KZK<9m1Qnr`dr-#v5m@cc3e%-Gbi zk;ysff;~1fwDSn6GTX)vw+~Fvn5=hX|F+$8ZT-87N*Zl!y!2O_NRck%p^Cv-$*gC5 zMY`i|*jRv+J>>x0KLOfcJy&{M^B9gST3BEWNqjh zf*>5>2@3&dk#Uo1HA5p;7l*=4#W$Y5g+k`!mWg}^d@2i3*$G1`>cGj1<*hxLB~=@0 zw$KcSPm52Et!b=jXl~iu+EdfmMVqbGu5B2R_TC}dEz#<_xTKDnqt2e8*6zXP&Vk16 zLHbQMH1)Q34uQtd2pd4AvaYqLq;_3lIc&7j>W11a%^egx4UIyQ85-R)HgRxxWdGps z^!D++aBLbnx0W<@W>?pyZYs;KuA}({YYGklyqAV8T?t7!fQ^897&-)DynK8KlXZ

      ) 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�{}*_ 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∋uL)Dc*T&4ow96VwRsvbnH) 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 z%0D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%0Aw!SdqaJk8_(aZzaUQLCqNiBSPR$)iFx|f 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

      -sqj~CmY}Jfw zY`aH9m1jVTk6#4!CR+zmcwNpWs174XTsUAXN}r1{jMo4?g93jOn5mdT#Q+mFtYohY zZt+0C`r8;tf+eLxsZDg6Fct6u#y=xO@MmbWhdZl*ejZsGze)rBMp~f_j4YryI=hA7 zOXVFB>l+!5sINyv8~`a>NK!^Xd{R(c3aw0`ap_<((VUme!o=KSWP4+>^P)1dBeT*2 zlj3Q2qNyP~Hif2!h=hd5!~|-f@Xgo|1%d>{+V12LZ0!^%w-12f>EM;*7hdEVkfUwl ztDL&34T?A@XqJR&{(lW_D1N!k^k(-56r8H*2@vJ^Jzw^t0T5`OWpmFV}A0UtGU&d}j8{;{43&!s*2e zQ%ei8tE;EZpNIV4-q%-9RmCr&6OcI;`aQs}Kw;_qrvyV0Mn{K=si~ob+|)TDGB+)| zE;u&N#x20W)Kb?#W@GJ|o>p47=Scg3b3McJ`;RS;p1n4`a_`vG+P>b2-3^C34xSr0 zzEHbwFg~Yh-{DCRo3WWIC+62r&cjZ>G;;dF;4x~T;|R`Ny7dYLo5i&|q|9(;=w`yZ zdF9%jh4q_rYu8cHK{{sX%EN`#`*RoX;E6+002Bi^2K@oJ?$gWHP9Qiri*v^^dby)h z7Y0tv^o&h*9y!(AKel`CVVsye{37*@klPg!>fDq5b1i_4fXT>BOe3Sy`i`DGclqA< z;?2Qx8;u9fh9*{<$OAB^&{7dLK(xC}`>%dR z69%vaDCXtYzkBx8kK)0HKfd|!C)}3lT0%+Y)i=L?{N@K5mxP`S?MrWddie4;4_@GZ z{ll&2-`}{8-O^WU*Wa$+e0O>CCDu!ux8JUBJ-u-81|pELvB@-TB2uP}kSvNA(gZ>g zO2c}Nwgj6g4RQ4AhLT#2Kvs<&S}|sq9T0wc<+%D-G`2o^}vs6?>jMi z_EKB_7$9?GY=*l>5aJD#afudL0*D#7i7Oo?qmOcVYeR(a|wGYdOLx2udJnOK&GU8FLeh%{oxzh_2(yD>wt6x6->hB>t zHMAY}4NkyDh8T{e8Precr7A1Yg{rTmX=ZHX?djRo+yCmr&)@yszukTJr>&QNJAeJV zsrl#0@eKx=Ub^ZY8X8^(rm;3|D2yE%K8s)cQbJainht$O6tDz==5jM;e&{ryF22DLzO=i< zB?ZRDdq;$Mg$1}H_Ztz)0?GkLAP5N^crq^DZV0c*tYpMg=*5|s%OT+a{s=Yxkf4x= z;FvgCP-C*P)2r)hj*N`1Zr*(Q{wEImtB?QX>39G6!Q0<&K6ra!d84JR*Vi`~gaHP- zAaf!|uc8HSpSc%Ekc|*WA*)9m%fcsZQniWjkidpZQ_#e~xYV_EWgf^tZg10Ik|2k^H&2D=@*(%nCYCd}d}`Mt)&UXX&29F=?%l zDQ$V>gXx7`VR5@q<_}FQM$FAWBw6Ik*`=tnLW)2+#KgwUGdLCr8hC5y7P6oTMl`Xd z1ywdJx;!ExL&KxufD4gyXxt0EZI^FQI@ow-eskx*nVOcv4J{*?*`oW&-7~nlzS+w! zm{8Qv$PSJW3WTga+CXI{R@9Yf^St}&_erVk%1TaJ%Gek{SrL9@0+T^Uo9UiUgKG=Em1jB|NC47+BUFonxM+;0w=)UUelA}q0lNxmtBLf4taI_yH&fL=3L&=c#pYc<(6X%xU z$xJU@g%~-D7xtO8q49;m(FYM57%d|9&=oH&k)l}ZRucEDEPv4=ABg4I;Kp0Yf20elOy7~tgCiaNBg`Zfbv>MM6*WWjPC-$m>7T$x>J(D@0+Nign{8TlW=3{# zTGp>oasmQxWEo1L1Pot2YYP+XQ

      $ZOoxLX$WKv2B>=b6{h}2zv(b;$t6qQ1u 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
      YgPu$* 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 z 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

      gXDd{|kVO zkWGn6BVp;tA;N&}#1MgCAVQ4oC?>xC{);m*Nne7m3hS_%ybudhBU`9r3?U~H4;H{Z zQMbgyl5r2BmAHf~3oD=bnl_pS&hhERZR@wdAp;MI3J>}RhmnTK#LN*Y6>Ix2OZ(8o zba7V6Tv`N!tcAHX*gK;r1JrzN1M*+Py8@+*RE)ulHS2j~{Lz{Kx3%|5TUs6(mrf>* zppZC{P_JCG9zwA0!Ksa-hlY0_A%EY%_KEcy$2xiilc{U&t6a6Nq^5MSgmWJna!DkCw~Ufk8ZBHDag+rK6p|2E zVIU=_4VYI*!^x{iraw zT^*^Y9yXm=s4PaR$cch5pi8R*nuw(WKBxwudOp{xb1Tc70QHz!k@H@ou0igOEvQSa9`QtzUE{x3{MY+-?2 z#57jSXQ{?(^hUjfS~t~pRtw}fU({W#;hRc|C8aDsVeR0dL}M|_p!M;AW+-OMyg67S zU&bGVlAkicX{cm^8LRaDeMeMd?J6Fj{N-XdwKQ5Mx5{faNVI~Lki zOom%fl&rhc6g01Z0g{=Qs`4*46@L;~r#w6tg@q%Trsfs`I?C#zEP0EZfc+Q}mEs&2 z63L{%Oi4TQ94H}-X;hd7R!^3JlHbIeOE5joL4?$n4`YuT`&-e#A-g6w-azaPGlXfZPb~PTnjy`2-|}MCYPMB^Rv- zNXj6^9vZK?O_aT7iF?Gln9_ZXJ05Mj^i9k3{miy;?~H1v=mOu=<^CBpi*naQ7Imku z94l%$TD|dV>z+ql)6duKf8KrcRo}_aHlF>a|MVAI-~MLj^?x|{=-1~y`qPo8zaG8z z<leFk{nNxdzuo)b_rn*z-Fo3iqgQ{r>&~zC-2L6;JAasZ z^soCL|K<2ce>?f{f9`+wXZC|n{^jI{e>?o-Urs##*E1jf+ld$deCWO3upfB%o5PQP zfAsmEC*S$i=(V40e*265)33S?J?TF5r04MC)`>fHBbTd(FE>xz@0fnCb>D-vyKmKP zzp#Ac(XtIw`RjH?S9SX@UG1M!?~+*VoKWTzTjUU3U>TaJ;}tU>a$_@>S(>J^<{Qo; z0V|$1e3^rXs`ji|8nb3C6zB%>iMcQZgC|&;S_FFpEccHc%BVWK<>VK8?|sv_`>a=H zxqv_Og&$8k>}yyCsTMsDE01U=Fp)Bsse=i%RvU_& zN<`Ycw{W(@*M^t^U>O2EpvCY;Q#IdOPhDz-?s1B_CqiCzWvpy2R}de-p>x-`gqIXYb~4if=jgb zjkK*B?(LiGA38NW@o4Y4AHMzk_b>kGyAOW(?^j=bx%JSA#(~W%JJ#b8v$DN!W#@*P zo{iPLn`-*EtX#jPws(7N*YKL&(UyTdO#_p)-8)uo*wZk$w|Vn{?$KidJCAMJeSGuo z<69?=_m3aw-@SkRj_K~PDKMFy?fd#h_O0K(w|nz0V)miSt8H3e-PlW>slt_QODflr zSR}KkCa0(#Fe*7c&pR-bGy!NDpbA1AqoE_wWjK#9EGmXID2(9$3k6l?JIexi6qp(q zpd|wz51hPq}~B z>d@O0Q|Gsh6Z3u+Oa@2?=&5td-nIR^E7xw$EpNwz!phncZcGCcHzV69OW!4tgyXhZ3BHuw_xLg4_7U=0fk#52YxZk3n{POa?EyEK>Paisa<@lvL=Wf1t@y_$h_g`Ln zB!JA#C!gGVF1|6uD?Rz-+xzc-`S61;o`3eE_domg$wxl~b@@Q`lX>~|$6x-OMA*+h z{)Qbg8F*&+B!Y>Q**MAEdhZkbWUjya(bfAeFW>#}(w&!JGQ^SXJbVShpRK!3Lyqm? z9cg4>!^$p@f=J72Oh$cD0kEW{WMkEWzG-f5?!PEBtDwB1rnP#_1`>5awLw%u zzG-@fZZOGcYujq+*pXk!!al&wC&|JtM9aW=fvybzg@(4JmM$R!j>hI*){ZRwM_M?B z7+Hs!+Q-;?rv^k9#HN;e1jOLyFUw5I;Kr>LjaR%bs2@8D5`?95wJofi1EUkO9h|*k zMdDn|1#{SGf1ZVCM+-A2-_Q*5s_#7d_ST8LxdnMv=EgAjz#7je21T2TcWi0>hNCxM z9=h@Iiq0dk`Geh)cMjb7x_8gz+^Y2+ewmgw;W|d13-ui5Xj_5;v0P3IAV{2Q*upm^lsSfpdR(7;8**iXwiSl2Af%rPc1ZFxe$>iB}X)S}fH z#cQ()TXIX&uV6xcuJdH(z{n^XZp2-uvwKd!OSfbN0%Evsd3aefj>`tEAR?Km-#`GVn|6Ie2R0 z$OMQk2tZs?j)&JGdj}Ws`LZX3$j`$s$OqT_$kgDt?1+@2$dr<(#PWo+Y7*6*zwzwe zlaF@pKUQAX6d03kYU8hK;HsfzGk2~bHrErI-Ws2%23wqA0V<*iKiY=gE?Q z4)JKNWD`!x3Qo-pPRkBXA?LCS2C?W@vbG?asA|Q~bEWSnZf0~n(Xy0t$&#?0Hrk#WPu5UYXbIab-Q1!0u z-Lzr*&aHc=cb_=D`_$VwC@x#OEwiNCKdREgG11sG7$`NVv0?uamnM>zlZ{ z*x1>5czFTK1cU_T6c<#~)m1mORX284)U{N%bg${|U)j*Hq-X_iCpJD41i-^L0K?GP z&Be;W8qWbJ0;1y6J^UibM=6+$n=^14o{cQ@8=2U7`zK^BT@{wFJRq{f!#8E2ruCe+ zbZ{A3Fh_6B90SP&tzm@#J9{S**5nf9QhSl}0ynUG%P?wx945n^N+tY_+{W8eY%la8*VwVf}t)d3-~(5h<^ zVhF{@Jl*-Tb%f_xA^0IN8#~%PFGJS5G6+?r_ojo9h;Ifmpiydl4p%U2ni$_ zg@r4SSau`bv7q z1D;mX*d87e57VdWDoIt|T7Vv7#n1$-1g_E6q$|3 zU`TAHyMMHWgYN<`xnK$wgEc?@i!ds3jzDJG&TBgwciXC;)_Nl?``_^yX-8C=)PfOPEqkedqF(E!nwc#ii9NN$S?r&L<&DaNrbI))ZFOl-I0p&j8o48TiLa$p%RzaWCnfJ21&N?XU< z*VjKNm>k3o?oLsOF(I*0@OJuyh4=&q**m$Z6Ah}ks)VRE9j}{RRztDr1YVdyKh$#+ zQ&030^*F{LkE3cMoS>E<=IUJXacCn#j3;u5;*h}a>g8`fRpU`ER8SX=b4Nx|F)d{j zRc^%9%Eqr$No;Hd!r@blPsRMCkEq`{QK_?_F>k)ioGH&TgVJyWJCsk(=b&0`xv9D- zxBj1#m8;&ACa1kVlTuU^K&=J^s`q_!vi$qnK;~XjfB9cZkdwb(4VikB)BkrpIY)|6 z3VHKIs;yLB%xUWIdaMv*39Q7za>Aq8gPMM=nwB$ID`z!5WeTod%MZ zP?a?9ML7aoD3A+@8U=O1@{y=7OgI53=+W$a;U|s|JSC|g^mL^fT>l!uQ!7ug6h&JD z2;(5?LI$wl5EnOhn6fBIeH>{S2;Gcy?7awcjE0U0ZGcGn!lZ{RbRn7Un_JTi^pIn2h*|&l8eR=qvU0 zr1b><5wR2tT2be4eGw&7$>k@E3OaBoNx#F8ggrnA1eDy+*e9q{s8W;xd_|ab{ZvSr2?ceOW_K#C{f4%SSKOK7Xhr^HlG&VmpIP<}G7hipM;iLaP|Kb1T^UV8yXFvMnuczMs`-M-xJM)q3 zhadlC|GR%Y{P53vZ~u1J&0p=h{hQ&dzZkpu>xujSeDLXCr{4Y3yN&_;lu}R)A#GfuB_U9y=m{Q+Oczmy_2bR1JUIzq4}#kl8Sv7 zS9-*kI7Z~!1gGgbhiF>+EHH+<#)^HGmeo8%Z)4{ikLV2v<%gShJ)C^!+tvfu;#Rb3 z+564XGJDF~MDoh%p}cod5nls%Dm)@coznS5JLOlv2V8Y< z2nT}Tka9j#2fJ8#%7#3AACqBnQSl17R*Cl!3x(dK!Z=E|;x0@;oFFI)jxo|pWFeR( zV~|IZQ&>BN`b5_iH0PgQo@&r7O^HRlRcT%eIk>SQ}T+E@(Kyr1CR+yN(@d;ip^M( znpc)x1RAqEv#=tgpgbq9l7x&YY58&SISC0%6B6>17nfyb)#c zsG(*1nvSvN-o2fJhdKw34Gdr2G=6u}?nfhsKb(5|t7CV6di}%SU3~o0iE|IvZJ8z{ zzpZDayLZpvmQ&kyJ(xK8#kt47fA`zJfBJ{-9{u>YM{Yjq8Q)jeJyg@Vsdn8^UDxI{ z{oB_Ljj!G`wrX$;^4|KMku^PIt%DP5*6*tC-PzDT(Ks;KvT+{)I~zt15A8Ze{Lb*i zagdF{ozs0g_OW!kj?~h_oG?l9NC27U?k&{~-7G|s*M>Y(OUfERV=@a!(NdPMxHvp2 z17~9roPj4`8_JNx##>Q*cv&vw?I^ndGPrCIa6yy>b|Z{ECWgk|J^^LRs_R>NRyOt4 zwr#5G*eXsk8^#-YM(aDbHFRxn=^Jm~Fy1k+qi563O=J7E?%YrA=ANM)8@BCcfpuv7 z(DuE@cOE>u`|$b6qnB`rIdMrJy+Lzp;eqy%*y(q<1O2! zf|E0$9Ouap9vSD6e?{^UBvl)K^T}@v`>JNnY3dg~6&q2Dh+F&{Se`I3w;}Gp($>k` zh7@uJEC=J*3?_rAMW3WtvLV1ejlm@umn_W01Ase9&lR|WbCj`P0D0LNDCjJ}7p&4U zy(p=B1+*kt8Nrf36}GnS-aeUmg)M#kqf-Z`PF*~5>GrAX4=>z$dg<U% z51xH~|LJFBXabXY@cs|s2fp#})wTPt0Aw!S{qXd)r_*Qd?mT*R_wnnUgOe=s+S_}R zZb@cDh5ug~4V^(jVidSRmUU<}bVx86;(f5?;epI6uUS^#Sy9_luxwpcNlQ%n3ZI}X zBU3N<2O!{|H_rejjd@z8_?GCKc&fHMyuP#N>dnE+R>Mq7%Zg;XRyKZSmL4#nk&{|O z-%G>5*Tg>3)jxGnbdE<*l%Ba2cDTG_Hs!tYNt^-|qCUd(rD?=MbA0L&{QMa%crWVk z!fQb@H`3N4DUWY(D%o`>PhHz}HAf#LpVb_c3C304IJFW*1@%h2&yx}Dfd|KAl5)x~WQk{BE*>Mr)dQpZE|4y5c|7T`r^M!zN0XMN zczJAop>IS4Ywa|k^dRN}gda{Ytl7Rpl!q zp|FM)d{Ey0!9n2(E}r3LmVU(V=o-ylamCXWSStIw2P-ta9C7ea5!HGW+9mo4lU{|=H%oAEEAuycu9F_S=}14 z=B;W4VDG71(^j#%b;X)?xX}U@#dtx29GemzoglimyQ{6Uowb9Vsihr(JpMtk=C&@- zj9A*+0UZ$IK;j-)OQ6(F$*T5`C=QJ+50A;y(X}R`hi)Re#$0kElKT?kd|!9JI3lo& zZA07xl1o>#rDT@b*m+`-TRV7?mEP1LloSANfHoodt^rxzVY#6R#nGwd8Ts`qS8v!f ze2}z0V|$PEZ600G*iu}*dQJD{#@=0dl|5d5nRYf2AwlU$NrfqyRT)cbU3?Q9++s{k z{PeV4boHDJj9hTQkf0cCb0cG05=_UZWRu5S=wC=V0tFP^8EFzLMM&CNOQQ2KD=o>( zPtD4XOUooF6+;angznx+yjde72Ruf2DWVPi;4S!jMSFRT$uI)bH<2Q=YlIPt$=Sm@ zE;ZH7&)3q?fplGX)T@9D%o@t-v8eY*nG78obMQ?{PRTJdcbxZ@HvS=a%NSYu<`u2# z+AxA>k#5P>Edb9JGg}{BL+1qxt=U=d3McNXW^Ha^nTs2c9j+RJD*|22(a^PWaJR5? z=BCWJ1n@bydW1y9hsCADC1>+O;c7Ow^EI&W)H8E;^a_tpEA$OX#CeJI0K$=m-A5(N zO$m;W6)`X#Ba@KuXncd|tx#RLc?PCt6&9A)k&Sw7$F`Q<(e=aAU^1+d^lzJ7H!ueM z@2b}R%GI5vt6EFyTQZ85`-H|U&@~XeT`>pgQ08`y2^rb3sTmLy8yJ|GnppVy2Y}YX zTS}M`t2X+&#<9suD{9-d^en+-cvCze>vH(FFowh?EY8j?29qhTSc8Ymikh~SHO;w8 z%E~Ki8=5=n8cD#^QQOc`S-qxsd0o-6+RD0S-e&FEe!|e|ntN8RZj6YHAtKnw$jB!k z5C9Ve5Y?EGg!iHjvwTs91(a}ob6uY>-`Mn&^uofd!VDgHRhdOC{&pb83NqmaG4uAyKu3nW4Z))X{GG;XzRxufDop}ZkV#;#|M!YER} zI#3spV-yCILmjc9C|sP@0Qhxvu#QwTK&>hT%4=5gRdG2}9wr!Ge9rD3UOv9)V8kkj z1*y)qFqN4ac?Jgh_=lO8+RIvzf}+sP1prZ$e*{m;{GRYoTREgGFN(B%Z=*E?mf`dD z7p3AdS@S|UQTa)_C*v)c30e_OXDHP&UrU`?ox)38p9Dc@k~6P{3ZS7ukIXrWhqZl>X9^hzu)TmY0xKzSji6T&h$Ba45qzUNd!Y^#WD9i7 zw2U1MEPWxU_Y5wG$!bL9ATqtMc6)LCzGZFad-r^@>*DWrU;h;jEqm|(diueyj=cM; zWAFU(^n>4Dc>3oPkN$Y{;UACP`{UtTzn{GF+wqJ4wCC#YC$9Zr`1H>>diZ&eK3sp!AAa`U6=p@+4b9<3UB%D#Hblhs=u*KT~be#?8S zw>?=q`mAOA{mzM3?Ylp0+VQM)*YozB&%1Vg(7X4O!9zb9IQ;e2b3faC<9GY+{^{_e z|8wlgf1ZB-yK^6Xclv|>I`ZtV?1vuz`_X5AJNe>20d|hP_}hUe|2F;PF9)9e<>*I$ zJ@)D^N1pw5--Dk{-ucns$!EPsp0w`0-?s0a-lLD3_uQ!7ax$-NXG;CX$kMjZ!lp&p zt9;Ye#+Q$mc3)b5alU$qTA%_cO5hR))j}voR$!8&(pVs zf|98L?TyRDss%8fC$Ut5?I(`DnckXHJnd;hbtbg03{_VH6?tMCT^ws2r zug*UB<*g6@aOc%;k6nK`u;XY)|E~1|(?i4Ow~pN#KlJLvonPJk;%~2h_uVJI`}>s_ zKO8;sHl7}BoAxxWABBbm>Xr5_yV|$y=@_198`{-AGy%lHdi@&q4SPUi+6MPEt>2Bc z*f)G&VC>N5@nc)Zk8T-1I5@VCU?n_cKq|U6!yz-?+Pkf(YYU4?6}4>;GnTAq$}Oo& z&#OuSiA~BQeFF%Fxupx4AY?&}9OV)PD~`K>03r++)P#O8n##yLS5tewfuV-3F4=}4 z;LrlHv$3|1h)y6O!tzyZ%Nu(EVODi-Zywl1g^6HV(>;P)(c12@w!R%*n|2XJwRzV8 zVwX1U*xNt62TW$m?!)YGsO~y)fqgH)%jp>!8Qfz4WDcLXI(_`@gYa6Mx+V+vhcE7$ zIx{wLYIM)ZEn`PFjUCyrZJO|?`t~g~O@mqa_3oZgCI&X7Gd9*XGc$D!j4mOlWZC)? zJyY*&J$ZLYT^sJ+tQ*o35mz2io>2@ZdY3FdF;|NJ8TK)@J5HS1+G?Mr9grzZ0Ex6? zkxw7T5HLnV>>btzt?gaN3xnSmEDHD+Nx&DBZrYk;F}Ad^;uKRWYrHX``9)z=H5z=93aK$hO?FW;QF2fyhu$VuOr9e9e2NH;`>gXn8*WS|?4_~@>^2U4T z@4X;u3FJgVjh=l5CPM;if{)0Zq$XM-`Spv>z7LTQ+I#-M7nHST6*MI0 z*7`?enp^u~cA>^IIc><4qq=V;i^)pFLe2!MhmG_fEcI?c@9d4Ue3oyu@Z!?P)nqnP{H%H*>$cLQHdX#^{{U>VaELJKpKqeQQb0khy&{>)J`5|~TUcN{6=4-XU2clhq$=-UG$7lwA8CF#$~MwotgH?-}TKK|grhrf9D)jvM@;-B96 z;M?2JzPb1On};9$DvI!ylA z+Qv?T6ny=|tgRivWSm@FNC@lZ?Ss=kyGK9($P643-a+v$p0SRu3I3tQsY}{Qs)v>} z4)^am`}X};fUztn<5$4UCl<64pu|%%4YASoVxlNLKvX99_<{A9vlcES6apd?mW|TO z8)FJ;vTNFNR<4as%QCkojr4Fj7oAsnmadM-gQC(A zq#*r{2G%5(qYWl=WKy=R>mog4rv;i8LQA4yp|9%t{O4%$slG9t}gIeSlBq?oiz9TCk#(eD|x@ZC=&ArD?;ilIo3%qAE-*0&T1UY_0v_^tN*h&CIJKF{q)rmzIXL zo`xmiB;@FUyMwujK^1KTt08k~3GClc=BjH4yj)ae22W9t=FLKt(9_j)c5x~!D=Da` zsHksPzPddzbGegyyuOh;Sgw{PS=0rTW8>`zm!9H(E5?EtR052v+7WWYIxK9vr2mdd zO*OHxA(~7`kc2s07OxeJOvIK8P(lb}a`tptoR$s4m_$WE7d#(e+19}=V#O-52o1UU zM?3h0$D|j!`b96)vF6wL3rxuK4s&mEPDyPO`K^{9528(BH;|K=AWSqSx2LiOx*BW<1Pi!3X?h% z@$^~Zk6gV&9oz!RrpbrL@rZOD^t?d`*(St2VaEU7B5tY22uuzW>h-Kw^VWpyiS*MP}1w|6%- zcQv$j*RJg-s;XaB+XO8<#J?*Wde*dWtZnLU?d@MyUE}ENOow9O1Nv@Jr{@TRg!&RO zlvGDf034_D4s`*P}MwF3ROUi8MmA_7pm9Fze+V`>iPZesvV6*|JvVX z=GMwx)CPHT?f*Q8a)bZpsnr_t3pM%vjpV^Oi0Q1nbUxplsTA|SKGd-SITMRpsV5(5 zTZ(R}00;;>SPJj*%{kI0Oi7Rh8W|f~STp<3Ml=pLLd^J;os&gFfc%!&BGo&JnuuJB z=72sxoQ@=bKwAL%RWKQDBu1C`E-R~M=}&}MRlA< zw_P+$5Vzvl!X`y zq!2YA6vjE~$@#!IU@~NQ1dS1*3|27}w`BFc%xG*%^YR@3v#HNQ`MejjF9tUh1PWIx z$*&?I%A-loRMNpqWfV;2f8GvlqEruvNxUC4=4u=2F!1tpw1B`k>JBC&yU4JvrK^#> zuf0#STWG3hShjCeaa8i^#H^02l1-)cyUQE)Rka*l)pw(H+v6Rle{ufVcjrI&zbBvn z`_adL#@A)y(oeP@`(*opkGCKEY+&C9UAvz2j6Z4H`tGWMJ5}A+i(4-hu03Dce7>yd zTv_AU^0ntybY5Pz?qcnR8*8`RTRnKaqV-hv%6;*9J0dd2LefSjc^LGblk8&_-$#`PH-t@A=sig;EmhMR? z+?Pzx;WKl=7>cHjKxz3=?nz6XDseD|-@Pycr8 z<$s;~{JV=^es}51?=F1$e@}gg$IgEp``|y1efS@zKKc9UPyc@S#h>=v`^T+UKHGBP z)xfdGTTZ;c>FBGSmwz&S@8`R3eL3;YXN?mlLJC*TGIx|XoVSonSX$<@v;K#4fu3{qK&P z|Da;sq<2h#ma)SEmW#1f6;y;^zjaMw)e6&b+b0{w6pNHvkLNXPY4Ui%SfrtThdfk+Ox7|sJ4E~+U6Zi?UP*_ zPV{ZQ2rM%+@nq!CM-yj0KYjOSw?F#h?T>zQ@bc3wlV^K39~#(pddt|IvHkB)U;N3X z7yt77AHVzTkKaA~>Nkh3KHjkNSlgxv;(gi%cH-sIH#SYmr1hgyP~h?}KQ#}6&+KDw z-#FFA_YJ$7*YD`uw5Mt8isXPI*{NhMQ*?nLa?pNgYn!Pc#j%cg9`>OkNHnAM&L-BXLY2XU4bC$VAV~ zT+i5qbXH(8nuhxNWRZx9Oo!C4+y>Z7BfXw!(lRFNc9Y1t#_tCfaoxDcu5(F|w;gC6T_3-KIU@`|! zT~?5p%OvaEd+2Qyli56W7)NUWneI&!P2JmBI4i1bB42~KxvPPOk%5N3g@Lt=m2XZ_ z`^cfkyDt1_;OK{ghac1pOa#QG;r=ZhWS)p2;shpxq%qOZ2N7SQvghjRn%di=w7PhC zg1rcmulUTU)H)3QOd?t`{4oZU7ww@*%5w`f23Af(Bu=)l0ZM1m3T7?7r=jJVruLi7_huy?cn(2__4E7 z7p@<=^vT{44^SQH0@?tz^zR6n)EZ@?w*D~=jaR?8H&LKy(t(zCG1_Xw&NMIOc!=#`bhA%CB z3n!n@pye#y{f^^##&!X6E*=u153|< zq{XFu%ev2G*Y0--Z*}l(h)CPIxN`sE6;mCfcRPpQ_KPThkJQsYy0NXNv8@Z14{k1S z5F?`uyJ8rke#ow9fIxAWooEGWqX{O1rv)MjVVBfuA&*RQlbF<{iA&3(a|)C4B?AuJ zx$q>fA33n&@a2IWr&{`^3ziR5)NStExW8x1)bQ@3WK`+jd~nm~nTzjy{^;X>y8rSg zxX0Xm_Vv5(|M=bae?)j1P@dp;k6wYvT)h3>nd=YEUb{~sZ1S+|IdX2t{-gcFJD1lr zN5!OKbD_(z%4YB4Onf>!$zDkt=j`bLGUMvw@8T6`YwK%m69~O+NJK?gY^_T`K~iDI zmVH;BfBN&|=dNL~vSP>6W6~+elM<$cQOpE{8i_ux=r*Dt;ZH+b;WA}x?j9ILoOMQJ zTU>F&l2v_0Yt}=B=i(d4@Get~vQ($eXo`5Cr|Mw|;`$=t{Jd4g+nHCpP)~X;Wn!v` zM;gCrY8gRL5)>VqmPaNjQ#+q|TIO>JO`ET+H4pg!67j_Cs-|riTA|+2W7VzOG74K# zm$b&Fl1-_ZJu<#JEULuaI~I;mypfp@sS-~iW;Js@)MwmoK16C3#Fd06WCFafQov9E zLaPMW+S-#Pz{%Op*^RVfu=L>3ZfOO1s}GEzWQhWhu{1aL^zb4XQSYWrB#$O!33Q!g zUaQ(SR<7wzE2s*LNFkB5m5sZ#t%r+SAT&pdLZk3iAXWmt3p*!wCs$ugbxUhkWF8h- zb|EP>wOSOO6q{UZWgm{48Bs#vae3jfnf4A|sOzHrYA!UjvLyvJM84$HF}85zlfohT zNY5!IyA$=qyOIVpu&~#K_}I!B#wQ(P7d<0a4Q+?HT6S|Zoxo(g7Qr50o>S3W+0frQ zuxEAGNN!n6P*kavU6i4bo4J`Aai%&tHd=a){vl~VwXg>RC+I9Rz_lCh4nmt5U+A;c z%FfXl2k%=Xa3z1Wm9=?%Vj`w`MeXX^=ANvgdY?tf~xbQhoc?wA)A;6==S;~eTz&=v2*tVp%SrvyhO<4Oc5M>1L3&D`2-QCJ94gy9B*bU<(f6RRFYRB zV7rbEQ3kGofdy47qZ3no1H!>5baadWWOxRkchw?C9Up($h!8AIyY^2lE2Mi@dtmkvn|nMavjLzto&(@9qG>Z+byqW^rkH zep%+yiul9=Z|@i*$i9dzWpV*aL!2NApxY|gi7G8Ji%G>n$GH#mgc5YmVB+HG0bMpk zVU!LI#`pt{N}nN?IWj&jK0O5|tI(ME;OOXpP+Zr%QM9B=ild5{g$mxH02LC;A#%mf z3Oqs`)G#0ce*|JlVv zrRGu}$f`8c0ilG)hTY8pbx3UW*oi$$%#_z9IP>$Ez8v z167%g2d55{ER{r9l-I|1+CXh}8eZC7+0L?;RKyHG29=d^C{t~JwI%sgL`zXlW-u9rH&t3gnnD5f z_(Ek+=3#VJBB!*Cbj=)?#a$r2(=j%{r_)erA;Fh&AX~P zrfPc*)pQ=JTD!l#{p8Aq!)3Mm3##@lYdo{O?MmzLi~fCIOkDo$>Bs+Z;pKmiU;6om z10OeUzEjh2zH-&^q7?_T$|uswcBU2XNG%vk%oz?(8H`FFipkuPk~fxDIaRvi(DK@2 z<+TU%t0wbT>@BL@S5UQUaqd7!Y>RJjgNN@L&wyr+fJTp?wVuIiy+WG&!&^h+x_!c0 zlz*E!?iJF^?it*~r*~+JZ+M$uXsb_fb5K-QM8bxUxb?na?Ez6eK9QaNG2MZ2J&WQt zgd`4zC2xvI-4vX(-Y+J?>k@r$NeAw z_1?FCI``3!CvU%4H8Pb@wb~{kcAkyXEFI%nvlkL)C_!a>N>>xDke-EuIv$~rO2T(B zn~to3qdQZ&NG~ESQmufE_>}S9kxVWWDUldMh@RvezR&E8)yjqysmdXr$PYzvFN&q7 z%y_{mo;xyG$(2e7604JQNVJ4dvwr93=pGrHxdQ5v+Q9?SrCZ{c?Z|6CuzbU@teQ>U zQF;32E=1JQA5~f#;eG)~QT$}+aOm4ACPOuVW0WaO_?HCajsP->ucnI0s6CY1Q7{UVATtVG50`q?e4<(D;N z<<~6Estk|Iar23=uyQpvvBT3CrB`S`*p&Aodbl!lLrW$BV&Gj1=QFb~>}%-jKv9b` zyrYY?l{L;A^H`3wu(0sKRU#!PEvFRBhvqezxn)hy_V$6@P2D3@ za?_538%Cx{wA8(A*TCrBo-I2^r;d+JpBmeLcI?pkUB@o%IdMhel}_DaKMbAkiEGEs z+&FUT8h$eSj-KCpM-A>tu89Fzb&jnU$_+TAW!#fIRpT znFSe_jdd-|OfehNT^B9$ith+oGPJaLx?%Waa&e8ZJ>K9F!z;4{(~shIC0#_pOSR0* z44j<9GcwET8x}>y>KGZ)=@37fg5e#*nZaKo?~F|lEfO>X$Pn_6y3P_9jz%DmU^~j} zK+FZyzIM9CMtGj1+vD`2W1uxxL;S%+hnIfvzbs01G@v^$l{4FN7vdVgz6gafHPUl( zbzWLp+P!&r{K)A&r>^WffBX2&r)S@JdGW!k8&AFfIl2ApGjc6~$&kq!K<3fYAF5ow zATvTB^Xex+F^@m^@q?#dJ$fN2mL!7d<+psnqXt(QFqwz%fBxRfuZdb>2jRK*^eg;i z$gE9%?W+$yIgXReg?GmfUmc#hKs;J_bdIU1BkCz`JYX_-y0Ts&f`sCVs}-cV0?2?W zFg*&pFHSOO0zoX!7F5FBl(DobDWg0(DbK+(h+fJJj35dah+CGFz~m^-gtGIBWFD6H zB}MTLpvgrcVdEh8BW?0*EmEKo*)&hnV$MPv4Sf$o>ma|F?4X2fx4;OJn4qz6y%-V1 z;z@v&##<0mywd?8&o)!ymZOpE&O9VFAqyE#0yb#0h9S`LFTj#oP9zQ zvP+{f@*|+W%quUiZ|~l?cgOVQlh@wgHg&nCbu_oU3r63R|m86oYB$bu--h1yo@?Jth9w8(U65f07Jv0q;W17Y` zw1xK2-cOI&aXY)SW_J7Tes6d0{dOMj7ny?X`|?YQR8{85lPBYx6Y)P0|5&qqe{D-o zbZk1dhL6?P*B^_+$LQlr*aEv1>XOh9GLMkmh6o#@r=LL=U^T`07}Jb~T!W=JE_bkD zaOctuXK&yC{??lhhejt{w5}@Z&P>4|BMO=lMkM3ED4}9TFu(C;@r8iJFDNc6ufDIO zV@Y!LKz0AR_VKM19m5IP#pty3OldyO$IzkKY=l6A6*dBM;7cJ3HVXj&K(cZ{{G2mM zhTRYz?xD;MPGlS=%q=Rd$ipYX-5Tz03U$@{;xvdnvs}Q#LeB!hY2W0Qu7z6~d)AOV zJs`BiFQ7Ouq{=_M#xJZoB%(Sct+}wIBP2YPd`3j$QU_*KWJxA0b@c;X4;9=Jg4OIF z5rc=1-eT5zd3u{I__06->K7CY#Vd9kPAo2@q_O&t;0X>BgRjZY-x?YgQe0lqGcdel z`I^D8X^5CQ2bKc1kFDI=+&7t$KaUue8Gzl>YO)6V21oe@L;(Jgwf1SST(>&h7>$jhB;~L2C>opoWCnrFA29^QW5o zSBdzpPu*R71Mt{O479cGj3+|A$`9v6w*#n|L3_|qCX7nam6h)b?IWL6pjV(pyqhhd}< zZ(iJQ$ZDEZRu3T?OhM2-r~@Fr7LoB;L6I4tI_};P4sJek9lYIifBAVc%7#Xvy%%qaJ5HMDnOW&+XSPs+%Soh62`f;@gy{S zT8gV1q0>pvtTvgVG!A+^++?!h+&PMMEk>w-Bq9S0#Z3Kfj_ z!4OUrS5V}T)0nE1InxKA-cQBG9*Q8hVLOhzn5F>_V$ zTJFIicVL)RcYc4ej*l%r(|W2k`m~0Wz$NO19M6=m)KmTG=U>j8raT>0R52OurH<{& zp8`Ix&%hLlflLWMFGOykmY^aYGaZ(1mFH1TmZwl!;pb;^teV~&%-rQ?M}Yq|TAP5qP4r`JBMr!<|Ms=yS&bt84gJVDvuUC=cIc@STh8H9=!0FHok z7b(G0kyR%ZlbI<{eO?v)P@W5^VCV9uFH1d84LVU3P-b9Cb8|&9@y?S_DM?H%hyia} z5h%sc3zjxIB*AyCZUFUuLE&UxV~P~>6YSk=ibzOcy-ee*SDgSs7m;N8IIogTBo<>6 znN!;K=l(^?z$s(k%p>rh3ROvVBuVNdHmsPuitwQ7;5mQoUVGKZ*lozV}Jo9E1G2p$+)2T?*Y>7X5a+-XlzF+VqhI8@H zK_@nNkjKgr8cc>hONi{IKtE5b1tJg+vw@vEY(4e<%Dt~I-EpUP`eN6_*_M$L^Sbs` zH0>;{+MHLkF0W{PdBgtJkt>6%-&(r;;~nRJbLOp|4qX4+l}Eqmn7mrkeYl`%Q(@Wq zto#+pITJA%3lp=)64DpOrVJ-%EzT=lSyZ{Euxw>n)!OokwPmF%^9q(`7mOEHOy!kL zWaJFRC3J)Y*ZEi~{C(z`jFo0n6}!<=ZZMbm`&I`8)P_g3MJLRUitP-K><9{J_6w-D z_|zE9mFxynh0$1UHkStnH$_BsvRLHfTW6vi*=wx+b)gYmVG%vyQGL;g!%>O-fl=Kd zF(dI=t8(i0RrZ`M>p4}@c`UbKZ(7CHgq(GW*=rNB*2HJ7PRQR7owGJ7Yh6OYmZbcx zNd;SyOLt_{?9Zq@lu>sSTA0GFb7egjD*IomTlh-L#I2UacRHuv>fi9e@b*Vzdp?^! z^3{eHe%$xU-yXUB=i_(&;qtrK)IVMS_&?tH;qkk_e*Ez79)J0l$KU+>da#@1ON4EhdS5w0F2g-I!|&2MV=PfW7a zd5|Cm(fuEoQ2`s7T>t<9VN|_c0a%0&5uF4jP`W32fU+pSCxbctNbODZP`U{xup>F_ z9I!E4aj48hu*%Di=%P$*S`Sic+q&%y{A60%%NpB>T`Fy8$ttZ(%g#$oO$!%CQ-6ce zTg$p4zIC=5TrZsG;6km_IvTv){LCJq{)U7wznt{=+KQsSmZr(xzD+|TdlpZgnq2kr z>dkl7?06GohB&4ZH+}^y^TDtF^WGB z{`=nNe>`^i{`!6Ar?(yjlYt;{%3Wj2whvBhTCjM-{1Mz^CYrhy*0&6nl(na3RtJTr znXHlUIs#lkHHqsjmhFrcjHd<@J+D*n2Z@_dtZDLZ3Nk?c4(L!AUc$&pl9g=nH#lnM zy16_1`1nLd#i8Bhl{Zv2E@+xR(K)nw!Ng`5i6!+CVN+{%E?T)0G8rNA-E)f1WgGWT zZ#l4X$3cRawjFw5_lZm7zXp&w^75U-7jGSY@z(M4ubq5RNw;+2_Nnu?PM&-97{8vq zjFZg1<1dk~bH~ARTlbyWu=6+sHKWs8Mwe}ZDyO=kJ31kg?4066VN0a9qsCtAmlsWg zt}+Kl;m%Ayp;^Ed*br$HGiehqZ@t-vHDVIZVgO1!loI8NoFmm(f+%cylP9*7ordbr z*sdf|(&)%PB5g}+O9xS?1Zj0@g8Z|IH771!EK&=w113ZAYn_`bYw1N5__~rHc-`u?S>Giu00d0U{KxsIQ%-4L92%Fd?cG!I(lOdP|CK)XETW^1Xlg!O` zzrK3!6PRRn9Dilq{tINeYUmmd4NWCut1}UT_@e`>f?3f-D2);}DC}@di;5r#*Cg+S z)!c}f#KOvYY%VCZOKLhY3g*Qm<+>aENfs^_15%0UOmK^=Ge2z;nw>#_ZZ7>=Jd0$Z zkXI%%sc5W93R^}muCsN7OX0cM+UMpP<~j#Bc!gV|b7FI9lJcsEV?q(4VNtD>IT}hC z$JzECj-H_rDP=(s$@FrO1@xsk&*Ayw?x-^wNcGd&w`9lmqnDA@iOJOoiK)bW0K|nP zWR-S|RrhbP#ja?z+O*#KDmG@vyX2)!oO(H{INR_Vwq{1q8 zLJ6ie9zJ;X-kuY8CpVmG9avx9G*&!ssJ3-{Wa+j|`(8Y9?)uReuF-w=AHM>0v+cl@ zS6?R>?OQUN-+J>i02vj0!%ya&kH5cr|1;8IU%hjmoJlXfLdvsO51zdW#nbNN=f{?B zBnvsd7NoEB^Yh~$JY9t2F|-oU!K$z&z&|i76sKq_`Iy|i^cruyi^a{}$K5%?%`Gt~ zx*?-{BE5KQUdP(QXWk&!_RPo#*QoEDNem>6@i?zw5u`Xr|sj!E`* zitcBRbb*n2;s6n!8Jd_2U%j1&&s;a7og2BZO(=ml7(~WKRMpkbADLLRYFpRnIubF5 zMpb%xCp$WYI5>pZIfOX7MmxGjYh0rY#$=N z92^>jo0Rqe0r4~t5ra5Egg)EWdlnIbj@~B!I4~K)mq^;qxQC){3W{_!`a8Ls07G1L zUPiyb+_I{?in^ZhrDH4C>Wn@_so;je4wZ<5)(s^X9w*XyhbN?v;;^>8pGg4^88DfS zkqz@lH<#B9`-fzbRgKUv+u0iNnh-u1JlLFx$BB&3!6yo0x2V`eR%y|+Sq=~!Rx&o? z)kaW`e_~c~VRa+rTS2ib7X0wjbFyomGB>!`%V7Fl)wOU{Q|}~Mu}IWN zmTmlS7|IxhvD5aWSP8W%KIlT07=<_Y8x{3@Cui$iiid7O$LGx^`@Q)yUY2uD->M?E|GX zEm?(C(ET+u_cyi=Em*jGWOD7IF2 ziWsQlo(L2Jp(1-?mMSO;KQYH)U4k?-)T#I(gPDwHR8F~uLRhYK!u`$7g{keSrHKhC zlKw2g5;LXA(KsD+OR4nqxcdCR)Ebb%{vpHHB+T0rO8#wrhFk*unLuM8g0w*6UPL3BK1s)QfoW& zlWI6Wxlp~F`Y3j`A`(w7Fv}n)dJ;9<%wqMsXjQi z$!ucWB%lVg1e^rxg}IHBrG_-)oY@YfdloVoVGEZrNO4J`Otm%S90h9bio2AaNi?jBj?V4|p<91&7A~&Y;So zprYFoy97#u?=d!(I`dM0R4=I&&M>@Xig@DPO&6o8YTF_ybR1PMXegd#riM>28GgoC z1ILi2L+zPsgU!aWqo7s9c{t;$>PgHIf-VxRNG2svx>$WUrfFP=76f#{92QVWd0(Qj zqi{N)IlAIrt>UFj7L?DBimrr;#VR4b*>qJDY5B?4hGvmEJP`m@BzX0rMk<>$DQ&C# zAZ`2POjXi&WRVa>dU=(cASS5Vqn^iiVkX=SeZxWT>J{W?2ncXDn?0;1Z{m_eL;SM`eFC~8}HfbO(VL@1UQ&?nOcx-)m%)G?3wyd1qy!;{d z^vv$W&n&80FkbvTl;Ns}$%GiXO=$Nw5kUSq#s?jq+uZ`BZMQNQQ+?^slT%xtE zks7B^zVz~l_4Ch;imi-_E{_N+2?;6k_09INWUyOIX=Y=p$ur5*J;ukJ9O#!}F($gZ zM7TMJxjKcqYeIFdk$RUHqerSimti*Ldz*8Nex(s{^9yS>bu2tx)Vd?SU@9iX$VGDvIhVbEuN|=mHoQ_Fd6`#F6F=tb9 z{`S{^U=OVQ~HOpC5noFOR?aSMZtt^Y-t4y8g`{Pu>4=>*Y5Fw;!un zygI3&)0&>=7!oTJ)=nh{J*EVmn$ezJba=YC zm@d*o&>HyU7%f4SSabuiA{A_tF7bpW6h7d!evzP)? zW3$^UJ2wxnd3pVbw>O@Bf8EK43)Z|+-n&1uZdF81mnl5U!QCWgs;pn53PYABunY%G z76?7xva=$LX2pWPI$?2ZgrAF;Srj4bk`kYtom^NDoskumnjVp!g{urGO@2)+3^VLS zHBIbfWlGG-i%m(7jEfHl53vUN=yWb(ZxXvR+eUcy(e>f@wsFK44d)pTC$q^t#LqiE z(myvfuC64nuc2;gLEp|ri;qoApIf%>((`#y1|MgEVz4`gBGuPMcKeKG>p|yKYZ9MSe=0g{@ zAG@^q;7c11T-<*2+U_&A_nyAJ>*TBW%;100j~B|+W@5mn*6o>Gvy0SDqf^@kCpPvk zUf(^us%-%FRPtB$LdKYpQ56wE2Z_*XEx_O`BE!+kV~JM>EGZ&Q7%R9C2v#8TJ_8{- zlS1%?5&}i7FUz<=L3$q_Xn9I&t0NL3p(QZ;8UsoD7#W+CUXWE(2V-z;`)JF8>F!1A zho-hKTD^OG!``Kv_LJ=zhnCHIPJzjYOV73=ATt~GoY->U%o|1& zHoU%IG5|8i&fXF~ne%s!zi^Yx*MiBMxw_}b`F+PO?m2v6%kEP+$*kRWWPJ7Zk*SRs zCQaSLBo;B40|{6_((t@q3Evp@Prv%zCtv>dgHL~R`;E`fz5M3Mb9caG0A$#oW?2&A-%o!O zGMR_pV5*b+ny4i_WWZ$Z-2dw4{V$1j!BytSg}YmiTwcBFZ2!`&i5ZnvO9&kI zfT~1n6vr6ULU#U?r%-lMh{ErI7eR7nK}}1~ytcl1tpml??TP6n7XJvGWaw4cWpsJz z@8B^CHpQQ8v=W>2eWh^um9rE|7J*?H>lptSE)?f<&Qz{94(2V@uUEus4pkpL}JhI)oX22zm? z+#8&=JVHugWp-5)L?UZ;o!NW(&YE492bLZpvrEBe%t z7jDv(AYWRx=J1PG-h2JQcQ@bol;qcUAAJ5A$lH70!tu)id@{G+{`m4OIDTIzaOupY zTlmQkSGa!n@y4!&0g*}gNI+akGCOaBm%H9WutI}3Z3J3t^7FO$`w@eK>xT~Q%2BIz z(7DXjx!RJ-#Lr~SicaYai<=)5)0JN_wd?TR`;UHo_R>v4pJ)W3!6hP<6=_BBLn)Gh zUTFl}OqeHT+dAQK0YOk{>sV}IXLpT>4Qs9x0nfJhenu4 z5`5w8#DxpQQ1n1CukBoQ(jQ?G!UH5AI@ubQ;^-CPp!0X~3b509JCM`{0K>YgxQ+W-hE^ozw_1F2JUrsuTmtQF4K{OibLIf*dfGUc=h&LqIk0#2C343S5FHqr zVDSm_G+0^T6ADLrJ6=0(B-Wtl@Pw?S>=I%~EFmE@8sQ`WGSKpbM91MHLXZ(|C$w-- zcqma14c(m`LqjcneT_W}ntKNty9V3mFK+Ez+&{c(Xz_Z0=-QS+7pjdV$+K>4bcPLh%jLcvxrKcsxJXRl);F5N8Zz zBqv73UgHUjD&C4!n$jmPZi;f{x4MZGq=_$!s>51uS1c1b4Ul-XmT+`mA8y7T(KKhBWD+bnt55K;JLPBrVfZoiO;F2=@=Q9 zSdm*?0U!e;59%^|wy>HzYfJEQvotF@W!B;yrDV?3Rh^5&XAJ_K%P43lo7a<(RZ5-_E(By?%_}ZGwy2b><&Dj4 z-DJC-PZZVQ62g~;7cN`4X!-b(HKP+N$Cj+=?OzHGlbKhZTU<4-uA{MSL38H_ISZg5 z9$&o`Z<)rf-qfsIc$pX}xv`2W@OI<{0TiGm+Rk$G)Fx)67FSo7*Eg5fwU*U1m6X*( z80g~QZA)TwrNX>Z^;*>;<627KSpZT9k5U8h8R6J573sfF#5g+Z=sto_F|DwU>M$2_ zjEMLca6&Md?4r`NTms5+NDCDn6$jc&QL62U)M3vte~BfId8b5eD8K`^Rc&d6PbN6X zz@eXFj$po1<(4n0Di`v!F+WLo zDw(zUR8bCTiYLeh7joVIuPCKF`B0i!+F3n#`l(icz9wcYCai)X$fsi1sunI~a{kk6 zIZ!Gn->941S24q%Rz@oJvrT=9nR_WffqKko>Mlx!au@X?IbVS?q#cykEl>%@(~~Bp zVzfGUS5K4ApH+s#rxlh0XBtzYvDEVAavPyTQOz{@M2k_z1Mb48fb9mE3`AY{{XxyF zdReGtaxIltZ$ahdPY@OXS-6jE>QDShd#cB3B`F`+L3I=nR~Z!?Q(QRYH0~=7Jc5d_ z_(8rfg6e&PBN)@X%odzBt)Zb|u?c8s^h+7>m`_o?lmKI?hKhvHh6Ek6;0RU&DX1)= zDZ2v7F>-PhC#cOOl~cx89$79YEjythC}~6z;i8O3I+zR?3(MxNF1T3|_>cN1U4RBa z1{6_I$7G-w;3n3Ec|g7wjp&I13rxy|_;aEvOM^dQ`Jm#e=QeP$I1y>xnDkXlhVrQq zpX$cFC=I=lPpT*PRXc?W%P40`eRwHKClyiQMFZO?2kKi8`%|Wb8NVPh%{Y3vd05Rl zla)Mu5`*im5&Cly0kfXv?`I0|=fbS=shG^6h@`%Ns7`ZGv(c~4=z~jVnaR7%&sY`a z*OU}9R9LdPx%ceY>U+D+{jlcP!@jlGDi<6|Dw+(7ZTImjGnsOHtl574nGsP%NvT!& z1ueN*O(}_0(Gi6qL0Eh-UiwgP581ukLjrtY-bnVdMtSRlJTz9l#_H~9(%5^+KG)mD z#^7w{>13;Svo~llYz>hC0nn(%T1^qqa_T$+44%P8uMo2#%-0g-YmDN6qI@lpUhaOb zjs_eRG=%%l)@bc?ZgV~L4nA&ner`^|o?da@W;`64TDo_REZ7wnx z^1M7#b=o-KATMpAw=UI7m%*-gPxExo@Y3fPJWGt;l|H5#t9hQqQt#u}92h)5D6B6a zctL3RNObH(blkGY_+?Q^%M-FUrWJ0_DcQqbRDH0j=|pokAz)WmZh8OoD}Q(C?SHxa z;GbT8^Y1Ud@wZnV{QaFre|hg0|B2E4=|4RF=+BQo`IpD<{oUht{_x+g{p#Oe`R4D> ze)Qw6n-8W>URtpAP~)m?#fw(u3`{1s^!sKN&-S)HW9NtioMa(FNW>FG33tLTT45iR zPgzeVX`j%@2;`^?eGJ+Rs_e{7YS&WSMg&vG+)yBt{{d%Y{z4#?ELZAIYKek6l~0<$2+Tqu2-8!MQMs4z;eSH>P?6jiVtbwK7*?K_kv-CfzJ zI^U}b(oC@+#w^q0Hp>L*;7Df&nT$$G3`>lUNJ$AxN(xC#j!Msr%g#;6$;+vz%B`x& zC0?ndI-{^OJ|ib0F$MbZkf=!CkU+>RwYXZ~H%%5Qvfj*PS$&S}^Rw({li2~^Tw9F| zdF(vh9V`adU>|)#s84QMLQ`AI>fwcZ$0v`CO`Te{{^b=r?yTPP#@1sW9J}(}g?oQ< z@3WskX3pRJ@yOM0cAfk3^o>8g_R0Tw^!vx3{PBOk@%bMQzx?{vqc4-!gII|T`(E5} z4BFe9WVYRM@bZRzFNuG`ju&u}8DGDD;p!a&Q=3Mnw=7z|6*LASUxLB=7O&|ZUfI^W zw4q~BP3yw^^7iD6a&m!^Q$VNn)oQ%)jX`seRYw6XB$bZ}z2KbS2(=Fuj6DlNa{!-V z$AZR|5CgCU)GhcY8D88BW*V@nt)+2(XLx)>a8z(aR8(Y4A`U9)xmAz`6S-gCJppL| zI2i84{km10y|I)ESK&#xU?K5uwUL_uRF}sH`E~lsH3*w}OicF}YYz`2VvKjROow z788}Ck_kE?Sc*8f=-j+?8l9G92wD~=9Oe{fca5_L`5F}e7_=?v73l4_XGmW_D^NiU z(XuGV(UG|bQ#T_wXJiT1;emtaui#L0^4k4NZ+(6K?q^rt`kEX%H=yBt|J%DCeDm(- zzkG+_qffsl;q@oq{O;jb60!s!gP+VB?|yUP$~)WkoI7#u)@yHn1_C3FF`r1HC3XND zsD0o3;ET6E{`&RzzEqiHZol&-JD3cyOSsCMzx6&$GGH=On~ybiPY|i$sWZ9~1R>n~ z3OR@Zw^DODvJ6f9i3c3L(7}P{hC(AGJO-XvqL#3mSZvKJYl@1)waEg<1&=Ly3sWi> z1&2xil%g6)6Up}q`~qtPlRGahPdt#l>Smls8%(C%%-qzx%k2M76 zrWCgp*Y{u!JL_~P29ya3G|Sd?mZR0nKQ$?<+S3@sO1hxiv!1745V>JAhKI!z7u62K z(Y^K1ixbluGxDm#;|j-C9z1*JtHCuVJcEktJz}8FaJ0ALED;`2tJN0=Mh#??Z6?BZ z>zNNv-~Gj^eYc}C+Ff-~j*doLanKL|g$PDsg@{R9Ws^p*u&P+)lmSgqIe2PBlDbGE zD1$ke3=R(=&_-4_^)K59FuVD{D~s2hZ0XxtQoFREaxkxygmIn4<&E%RuG+d6IQQWB zI}kFTym*hU1TFTG<@=7Gy?ghauR&n$yz?oT4EP%nOuXXTZ+}Wu(e>BfzjFJX3)k)u zxCF=VsY`bVEd=#V$*m&J1wI^>?`JR>PpylN90yvx*>m^(0Ze9jWxJ2qiE5lJ+EB4^YPg7bto!=1J9MUD;dDi*`5L{ z=t@GS$_yc7ERekv*7YY8w3W9mZ5`TJ+qa^kYf)}hBl8tD2~&pJZfI;^cHnZ52_qh= z*oYiLEW@ZEaD;(1eZQ!fu%rw_P>ikCXO@%M(=P^#*uxTN3=U1q%q*;~9-dmheB1tk z$!)dWQ_-3AZiYk$$6(vpCVLzG+&LQD(wS$TeV!Mj!NcU)S+4A}>~v&Tw{taP{NnNv z5EO%dI4m(*gWS=}H^476E+jS`!#N^3n+g!~1=fv+jDJM5Z&)N$Jb|H6L^BZ=mRXS7 zyJ%tW*!aM*<-HS=O?@NHeWOHwG_{Skc9Mx^!}4|eag|BQtndp+^70DOd00H$J?Ua_ zS&({$5F5S0NR|y=2SNoZg`b|Y)|j4Kk&#ylToW1@Weo^)g9+Bw^_e-21o2_i;W)%P z3(28kQuA?)!5NIU^|l7Mds}c&0h(rQm()pga?)s^!q zGV`8NY(nm>Z|-PhFBRom88QrA{g-(B4` zQr_ANL95j-EIuKtv1xvJReNDs3kU-&PbU8)gKt7oW=&_`vdGBnxwG8to+H-QURInH zm77ln3q^AfYejk(onE04Pz6b~iy2462*KM0ln=y8=M@|g9uXVuVbIAyB*u-DBqE3S zQG}x%5qw}ot{}Z=H}K)%<2D;gAr?Cvp0i;YCm)Rr^7P$;oL>_T(rIha|8+H@%)j2n8u?w5>2SHKtz*Y*%cU(ji;`gyOF`o-9wA8 zN5({zmX}w~t0i`+vug;B-+`f}Dkg)U%;JgF!(-FKiK70Ga)Utf)v>GZRiXo zRSh|L6~X?|8asEyLrgM7HN|FQe`<--!iu|;q^=PgkO58yJF6$&bP>_kg!XSY#@M-Ib*iZ!q3*MN*mN^qfq~yZp zOIcE9<(uFdXV!l_8ByUGd*(SMvPpSZ>PAzmPbc+M&3~R0xbA1IM4Pbj4Xv#nNRvLx za06|h@C-PfUcRA2u_Vjkt

      23Us1GZ0%&@AsgUeDH+Ln?40(oVP zl7J&PI%Ks%&oYh<6-XA_lmSg1O?e}h9>TU296IW;FyRMZS};DOFiImWTaA?R1puJRGJhae=60Abg6C5 z3sPl_1GTgnfCfwkzdV97HI8Wh?nVRr@I0wvuuFUy&&c8k(u|y86VM=m%p-m;DzbUZ>-vVe{lJg=HcVDy?as$M|^_| zjOIii-=yH6w4}tsq@;qxq=JNmyztOOUvsFZyVb+h2-^g6hu%ex%eT(i%cA$S8vKoV ztEam+M6sknahjtc$*x#nsls)xqfD9<29_4U4EM zEMHtuHX4`G<{MP(ZA^35Mz}iryJ;-oIj;6zS_h+>oyo

      rQfdy9*`kJcs7-Bo;V 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%0A!GGWDtS3U^~b`U~O#f8yFUwoaOEvMyFsZ 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.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°+Q zvHjB{yZ86394W8utgh|?KH9M5AQ}-n51iV${|tc4mhltY_s*c<2}x%4*rDYc_YJMx zO)ih<4RSY#EzscXMFfSs29kt8p)_I4nFou^W1g+Ijh+8I=TIlV2-iT9cX+lwqcWkU zqhw%7`{uE=GsllTKY!`7v)4X5f9I>?H$Fai{e#H|pG-dfbkF@KLr0Efc6Pf)7~b&q zbPn(*ONCdNRa%LtPI3JLB9^j>hT?+C?6mxJOJ0hpA}_VOJbzVd>z>VfZydS$Z2at< z>VZ`iUHywjH?K$IYx%$*Jl_AkX8|&mB>lzf{91`gpW7KA(CDx!0N;@#v%q~M87{-l{r?{NfKEeE$1a-~8pnum1AtH~;+d*MG;D z37wgzpa1UhXaDf_%U{3s!I!t6eFiK8Aanb{Czo%%KXvxaZTn6yTDciT>wz^Jmap5g zX!$4>V~ME+NOVGhlRZL~3i*JtrBW1-dauH01(Jnx$R6XR3yH~3F6djh;_!iU&(7Ze z^2U3=z5C)1H=q8)wReAW@tyCcZoS%h`rS=O-dwZu`rztQU47G4wL1&)M)I;&WT*6I zCwCR4cNb@N=O?$7WOmjREopCBzodU+>-H;$XWqSV@8iplKHPWa^3aA&S>>fPiV8-} z(qn7y;pB|%4yac_WfRlq`r{8j{PpiHzxiZnbcZQ9helNHow$rDJPoP6QERoCMa7PF z%=!^z<(!Y4AfkD12;m=2BIIr?0E|YR$piu~^q2&(Peo7>Ohz9Y%SJ$+3q1zQKlDh& z#MzmUBY;H6!O2%d9=wD7{INldfKvf~CNaG#yKG@)+wz4g$4VD0#1tD$2HrRp1CV6U zoHWEHLDERcFYXu`-ni%3-jg?{u01>d@T)8De1GB1&#ylG%h#z1E=3UdE)~JFjJS_MqcK? z>D&8GT!(A7cxZD&^HRRTQag6x#`v*wdrw~3cIe{7vAZ+ZpPsq(eDd<6{pW6PnLN2@ zbR?-D%hlhFAW$k;N~FggExWT2YuVd{03pIM?3GULYCm0gXhue6^YV2Q<44b|*|H-( zIRyzg+P~SU`E%Of;wVbhvzhgdTgu2>hHQVgpdYsc6P+nQ|)h6-x7vU&Y9euZkNcFDhhyeMD(X>*}538}}cYICb{qjeAGV z-P${SZFt?01)ZZg`7JRq**@OEcr??hjp`;KEgxJqO?^a@ZPzH-(V1b|C8UY8b6)WveZ)68ktq9F~Y`H6O=8o>Xm0*|k9qUlZS3g+(7Jll9TVo@rt?xo_y2z>xUB&}36$RZ(@XTA$?ZA0BE*AR2LW^@l?u(J#vuHDBIMNv23atl_IH2Fiex z`XAOk?%p^o1cb+VX`-MgJA13C27yDr0ojHw6>nk^e;ahF;Q$+xJ@pA5;fY~c6{)qo z#^Uzm1;edlXZv>EORn1J6`1GdZnQ&SjA(0~q}_Z#S!x*WO5*c6#08TisX}%V_Yhw{ zlwDD@@Y6>6Y9ciTGi{7sL1CVOpxS$g*RO%?~JK??X z=XRd%;CxOhU%;gRBj(q6T62zju*JdO9F$OHD(wqRX?9d6d8ng_Ha!ADT~vWi7!dn; z*&yk!h)59Llc^E6Lza-rp`r!@#=_iWJR@jBkN+=VBgsBlzhIjI!EQ?9Kfe{{Zn~9G z*F=wInd6A{nipd1(b%IL=LZfmbaD}JC?cnZ68Ym zeD2qO%{Td#JegdBJIilKRg~5+b|%@Pp!QRHWeib4L1+{a$FQ*2^vty4(v0%Tiq-`+ z9bM?jyvAe}uLO{3?Ooj5(No*BprW>cqq?ybgEkZZ2|JTg@{nC7&EuX5PX=pK&_&*o z91c*%$15Q%wQfN>4sl4z46Q;>W@7E;eIr{Zz{xl6IE-!{E}w*;^ukv)bP-q3ln1Sa z7m+QA!LKMiVi_Erk`|kirwKJd*g#1}kO8t+y1E2sAZtce8g*YgfNM)eT5?`dTzWPF zWr&@!3rj}J13?QQG?hqY;y&Z&?~hUks2V{v{Uh9N#hS#&s%pz+VM!&xCc|ajB6Ad4 zh`mUNa8-qK1qc9%Wj+hO0(2;}5O^|RGO=mNQAzRO=V6A3;Naju?xUk9U<;CI@8+hC zz-h(BNB72jMeImvdf;AJb9`ZEF&TdrhXGrdZ9m7(%^q1$kSY>?>uBV5vpc^omw*P) zJAz-XJ_0HcB@C=haR$_eMTgMWXHN9+Qj;UXypw^!X0EXMe@;0i$7Hp!ViXK=D~QL6 z4GyCSG|2)^Km*?lK!zTuUm_fF>~(W=a2Ku@Ct%I%Ie$)!`6~%9CNK65q)EIbuRyLx z>Ss<$gd+_mL%t1_ipvXDiGp`#VTCa|$=fSPb>Yz# zw9xr1$ajb6j3`KF6y)bsmO-3>9fU}!A~UWyr#k^b37Z5g2owYUFl(LAwFT{Xy;BPl z#(FTR6`a%hRb~x`!ir&NK~Ceo0FiOIWV(ULfa}--G;#68kV}LM*uETWe}%sptPf>6 zqfg7Emhr=~;I9IZp&OA-B_^71V>Adk1S6gTBqfq9&;Y1kDxrdGngE&#O@P%=(o^bX zOeQ58W&Q%r@Zjq5;InX@C4og73N|IJF-qGAiw3|5&jb(Q$;uPhLnKJI3LP`?fjfkz zqI4k%M69exB(1Cuh}LkhcasoXV-iLMFT!gI9-_P%s|S~qT^-z#*WnLY%y}K_Cz3f! z{;M!~tc(k3Z30lR>c9Z9vQiK=QR7pv9U2#?O7Kk1$J$uL>$CntR3l#CV1#h+Paq)9 zf%_Hp<=D$n^9 zPvDpjGBbNN$c#J_7z)7$SCy+z7~4=lSQ4%lsxbVcb&lR@M=w8+EY6<$E;DS-EbE{1 z4X_NIJ65kxk?ypc=jq~zrzfJFhPXt$=c1Alu--r|o8lTCrh>`%s@;8%D#D;pbbG)~ z=;m?p_F$1=k}{|mdosGL4+^%>n4M@u()g$&eS@OC)kZhJFjsF4eu0V#2rwWNP+`S{ z=m|(7D3Q>}Z0F_+`6obY3^ByxcR*(opf|v*AT4ATvY~OWUPsHaMKL`Y;tJDD3JLnB@Z_<*0SryK*etuB<3QKCBeHPbr=GSzVG%p5$Shgc z)wj9@K!#4Js`ku+`rN{1Fqx``?$VkC05T;t&4pEU9EjM^2MQX4a#tes*Q{&+8Dp$T z7p?`43vz_Z{YYQe5;OT`$Rzhq+YwN0^wc`V8cL+CTWIJs;L+f{~9y_>p z`{bIPM>g&|v1R|vj>G2_WM*dDp;Oxr9bdg|ynET|(#jT^S$Y<&SvR&H8VSy}oA;a? z8$U6&>lpsd>$V=@MOLieH#EApduS6P#$?dB#Z~yZpjzokW}w*qB5KOcBAo^7W^-(S zWxVFut886@>^;I9{h~ZH@qWfUeO7g1eNWZ!aL=A?>n}`CKfZG7>)Y@Ac>b+#ChvSY zar@=LhaVq%{>8z!o(=9hlG@OsNlKwR0g2{>g0l3|>WngQsv5YL=_ocwTMQw_NKHaQ zR7Gyu;==sl-l4R?w~Mp@ye6yx8J{c_k+8SKBk-L9?Y4iU*382 z@!hvS5yjdU-#q^8hZo=d{{3%$|MegL{fB@4&)@yq|NQme|MSz|{rl6;{`~ICKR$f= z4_9uynmlrU>&8dgIohKsB z935wgGRKA+ql~6lV~iy#HX$x0n}gyA<_}S^=J=$vw4CCi>Xy3peqe-6`%kXjHQBRl zV`*(?Mpj9<-bAN1$gM1v)~$`V>^*5;Zt>87BR_>lBueO^{< zbsfk|%cj-qP98Y%@XEtauD<*7;DxKbYe!5O>BMHFwn8;_cGF^U6rYKLB5iArKl|-_ zU;T9A;seCJO>vosv{SYq24Fj&IwPyxJUGmh=QwvMq_VNHcuE9F8p29QYpKdlMF|US zC`4mSrf{=4DlyR*pA?;v!hug*R6+`XOqelItudkrX7A_?v4-qwo{jTdxM_As@O$Ff zhZ7>M85(VLL}XI5IWIn=CbNXf>}cEI+Wd+d$Yuy+X~XqkGK67KmJ~};c6~=54ShR~ zoEblUZR*OqXYYS}_U@~*w?9PA_tM>Gw;p_S#FvoOuZ z_D(O|uzPTH$F_r~_Z`16K6P{N^qu`DA52|*3?Os%&If02zjx~9ljB$4-hcAOy3I%0 zyViiotXwlrQ{>^(S9cvdhs^KV9mhtt&rF_qaQx!Cr*1w!cH`ag)0bE8nP}|qiA;_q zu~N1J2@}`|syy^8lPUbZ6YJ5kl+kVMv@C< z2V^6%?(8I~LcdYA5<(q(XA<*rYC1cr+d2|+3KBC4(Oy6nOeR8zo<-FQPQJTOU{F+2 zX4QsWM{!bHy<@_XQyON@%dG5MHF5s>%b)Ik`p-wNf7;fwH$J{OT$c@3q`0iBrfCop zuH?)DusgUbnEJW<`{MTEt;W+wnny?#)u=q=6?CmyyYax(2I!~u?U-wvDaGudnlaSPvkvCLWJ=(tH z;I8SnuD3~3^Ap? zJ_bMUFdt7XSc)Z$W{sYl^8SLl70pZcbd4UZ=-VEXhuD5^ec$GR(c}GVkJWW<&#fG; zZW*g?*^pJ#myzF@l35oOlg){_I;+@(5xPJ($kyJ=!7b2D7497z8yKD(X3jukSrZlm zt%VE$h>mtfzz|0lwS%*IzLUz{$=|^hV>%VO4d~!O^yS)ck%*|dPJ|HT1%wuoa!Mve z3T7`i$Tt9AW|msC5j{O{%+acK@rLB8t`+;+1`p^>^-*z^A^J2|*ANE>+)?$IVyiCED3 z6{v?AP3;e-Zx}47{yKXG*}D1L`|7;HlCf9{&2CO>87}AUW9fKXnGts@|jg_~dm_-gm_(XhV#bo$O3?^Z@yBo-cgNFzCGQHcry2zkNbD+VZ zw`5u}OCu9|c-eUS z+579r)K$HbJ>8cI?2W(%+52!(U<2$c!fpyMjCkQHyj-B zRzy^Xa9tvHySYxJ=}ZmE-{MRm_Oc9VU>N{RU>Tx5YaRhdky}O=7E~f`9L@DG*#8?Q zLycG=&rq?zq60A#jjxuzCpDm`uS!Mkz&%lVr=Ue6QL~PcmH}Dn&Z$8m%t7x` z+oGlIiw4_!`xkU}SJpM+Tv=XIU(>LFG?|iIQF%jZdLfD>U`qnS;@_v#CS=x=z7a%w zx}mR9+1S|B)r-}_;HoXl#Cl2Em%wC3x9lI;yl?56ZLswa)2nOgEi7sX)0yDzz--}4 z6QL7wyZL%i1xUy$L{AAzGB|@)#D>(A3{fVC;>1BNMD`sTZ9uFzIj0~gBi|C26r@(O zIkT5Zen&{E^5NPd6yt*;W&k^puV7-nP;YcD{{DXWmFslWdHG6d0DDub-7xr!l45(h z`5*uY;{rVdp?}a@BpeAvM?%K){CO;xArZQ$1dAy-Ardb_Lj-0Vc%(8~TQinMp|Od2OEM%?7IWy1P#kINGbg2^#4_K`4bV!U1{fj&IWRyJTAI?B!;B*> z<%gVub=4-vrxS-b06>N_Cs*QBNu=S#076Kz13`#=3pxsWo2MJ~8ZZzA22sc=O6F^& z7(ow^{w{<%;e~m7S(1_w5=1x!O$XXB82>=8q0wekks}T9=y@wfJMc%Hk(>?EX-)A- zkfq_e7nD^;#>V*v>FC_#fPqG*vndtB^`ex50;)Nlfq`IdbAgVaX*-KpE6FuO0tamX z1Z$?rUHT;f=a$I@;b3AZ{0HvEYfOeD-8!522{;UxF>t7?Q-Z??Xl84}jewg3B;|lr zf`_Y}k9b>iBM_QnbjirUfg0Q|Fi@Cp`p_V~p4djCMMzEU>*a&34WKMJ2(yMzfd(v? z6@vMZVhemC5t$_53I@V=l6%7UA@`)+Tv@a^e?ggqm?nG%1%Ohdi~&CYC?o)v2QNZW z%I)Jh@)C;wlmg4pz#!tiY&Rk!>k6G!jI@AphztdmQ3?dIk|-d#6%3Jdm*^0p6r2D; zZ@56N2-dQ@2?d4S9B75N<^;fCfMxgzFDOJcg{#I#lfSl8tl0n4e292>kQ#1qT{EGVy#=_z$j!;g- zU0SaIlg5}8X30gc#mO(!)=f1>+G&*nDm7F3i4~HJh#4y1SiL@-=Dy)bt%Jrf-<41*Y-i2V|VaX7g;3zBJ7Zc&;dxsO~KE|jB- zC;C@(E%^i)0c1ERG_&c`0Yq1|9c46b7vT%)wyK~YE%aT{or9|kyOqk6)|f!u1kMaP z#oRtNBbGhoj_o{g z|Jbb$_FcTc>(sSfC$1ejckkGhM<=d7La_A2wKuV7nYn!T_@#R&V;nto9a!eb)TPO( zt5efA4o_X1oTh>0_RQJ)*KR$({otdw9)J4Q)6ed{^NNP12hTo#`tkQKzy0GUKm6tM zAOGpIfBe@kfA_zA_m}_c`@j9)pZ(*%zxUOj?>_$i;&srN2ec`z8Q9-jx283}x6D!r z43!t2mL6=1_X{(+sqj73*g6J6BARRKJJ-$^qfmQqH)pk%PXy|hF_r@K4g3Q2a3N5u zqp+fAe7UeHGLL0`;h4bkYeNBHE?Wt{?V*u|Fp~*Fg)t=|Iyr&3g`$Zmp19hAzAH8X zAeQJb8=@`Iu?Z*#mQ*%j+>A9CBLwv!l%Fx)DydqKnpS}Fo2Q2tG)uq-mRH$?QMPe# zP&wG?T-;(*Apn|-+gFb7ICk>nt!r1G+<)t1{Hk7l{?n_k{|YPvTjt|${`ST9|N83N zfByK_|Mbx}fBWF8pPqd3G3P?96A5y-ji2%PM+O%;3U<( z?j>tDfhcpT76UKZoc(<%>0?4P%g%1rTr{8UXF0jg_6hQdO^>f$*tOx%jMnzT|^i?52 z1%axJ0I!4qS7VS{M2NdC#8snnRqI^?jh;YUAQd-(a*y=O`)x(tS7Qf?(AV1+}F zRw<6aufbf@fmtB|AzPl1qLrE#fh(+IT9yE0v_@e^>rEDz;ikkCQ*v5DP973c7-Z4x z9}$zL4vt2(j22X-eTo?-OD$i>w>^ANix=%!DCGfxVKmDa45_Fko02N?D!ZE&4mWl# zrt=X6KV4*m-WX$uiGx6uOs~kw(JhCLZJ#_le&Wj1<%g$lKbyJ!Wah@>Q`a7FT)g%8 z=36gsKYYb;>E2^z&BWxn9TO)v?wnk)VGrvnmO%KJpSb#X^6c9OP6!}#=GKez_dmM) z@T04bUUBeJ$T+WBJ5f_J(AYGzYGf~@nu(cfJC2>*e)Rmn$llI@ty{;>A31UV_@$>u zFTVp-X7kj{%3V7uJ6j{;qR|^9ie|vG3ji;$?E*(w11;(x5cBXI!+=TUYX}R=C@Ae* zv+2OPZHEfW>ce%B2r;oDv3;}4@aJr`B37nsB?K01M#Qnol`SKO&zAJs>Xq_$=e^@`{I9` zy8pwv@w=sED@_q4m{3O>Qmg6~mDF_SmNg(25ucg`hu+_5I7IdsFuIfhRyQHQAqg%=gLRpz79o-UE&m}f?v2*qF zQ%qlCQi^oZNi-2)g2`{?z;VKrvO5+GzK~u(DM^&0rXLfT9W%U!|(O^OgG-P^*5B3gEM_B67tBHup5}hk&6+*{$ z_P%Z&p`nq2){DLF6q+l|PS0Yv6y(^duVGJP*hlHn++y9DtXXVM*dq7?g z{*Py1jI*~EC<$&125Mp@tTXs(Xi<-GR)zWM6Lm?|N!2Uzx^}j1xHLTdw140I?(v(; z4nAsGaV9*j-PbRk?Sm^Ob3_4qB@|<<69AJAQskmnQlTCb(pyn(`g$<3b3v~pDh3rq z|8Nt+IJA|S)2lArDsVLT1Fd1oF(uTmXfyF`YzP$j=ff?p_6R!%`a&J7nUWLJ`_?65^d&{WMfi>7PBY$>de4|XDSZ4sJ_Ie zq{A&KsA<5;4NRt?Z>XwsQNzOimfpn+dKR_y_O^6%);2a(RM(eQ)mGItSJt;+a$Q{6 zkerr>vk&gHVEar1nF*5oA+sXn4FIU%a6NVp^_@Kn2UiWO+BCR!+p5hIv@ap>g#iQ~z33Q;rv?&d5C{dSR-yL`Mg#+&Min8hkWkH2grgN5B<^DX zGD6V?+G@h1qe2alychl1LAnqU3bbpSyjAwdqld_d#bJ#!k6TG{!K9NkliLKl02yJ0 z=>Z)}(Ej;vP-3B#kA;-t2xtH~EoSud$bx7(@b~2t(HDbLJo!azN-n+$Fdm^Jf)Mgq zQgRCs&UJKCA(8aIG-MP^#yX1lD&KG!6&#O|LsCQ1EvXGqqzEwqSjZn(?=5G`BxS0C z$yfmp?h!YdaV6a-tmkqFf&d5u6eIP0MVNvXFvfpEY8sdf%?`ePYGn%$IvmW;*raS- zSTuV0;Cm1z;e$ZBW_%)U1|>TyuM*|7+_Fkzd@?Rf_}GGc()&Zx88UQn8Tpw-)d`uo zgqPky0fc0XJuWzi0k8vy?Tl* z(%u3f15XCy7{DJp42>20U{@rd165A`KH_a190VXE>d;`Sfebb^w}t^sBR2Mtnvk%d zfIxC!ILxqT*(;?S#)`*cs}LTnni$sVKl9gmC1pCniXoFyzyyBCy^yt9a51HWP6!5^ zmMC!v7HZ|yFb&CAm4md@y0(*8t6&HM!GT^v*MY(W z5Y2d2`pc}C3;>H2h?DeO`E>Fz1^yBLbWY9+f^nI-*K$CDVjw7x3sd74DCU=+SSOAQ zCuQ#Nm61cEKQIDgif;sIv3UbF5TD(_)dSly7ylp!A3sqXg5W`vXniIthw@}QL`Kv zuncS&Cr3YTU(_LRkVhNe-ds)r4m?Ks$iuIDpwdH;i zu~A@PKnF*N=VPEjoFxOJT)nkUo)~}I?x0X} zfF_cC5Ri@GBzTK(3kBoij?L4)l48#Q-;h&5_sVbr^V*vEXcqw66+BSDlxCxNksoP-s#}WGW(i z#-xn6wA}clteBY8Xk$`LOngduPH{$W8u8vE9iw)MvqRvI(%4M|ysgbdJc z8o{7HAti^19G_asWNscIfm%E@a`Gw)${L9h%jy>v*LRgP^^`XCSGO%IU$8X4zAwFE z0jh)X>3Jqg5=J)cyQKy7b=94XjonaX+B*lqWN72X@Vc&{zpj39WBam(HpF`eP|v7r z>aA?-$t!8JBo}1nR27%Cz)=DJLAxfuybeHyh5`}w%`ZyI%8E}*j!lRMkkM*EKRltu zVH8WQ$C?8SLSo{MpswgDxRZ<}m@^t17h(1UPX;?1gkNZ4TDASq`d!D@?wH=N_vH4; zbGwgT*na5Do}(AWC(nb)jP5?PZs$Z}S3j5x*Q#&v+OZvnw~SA1-Fr;DmZ&?!klDC@ zc>Tokk#SxSl1xkYii(Ergw(uXZ8#CEbaXIuz+~vkR0cESnVSx1$zW!AWamZ=+jHK0 zzxlRUV(1;*VjNXT9{OB$a=EdhA)~XmZgkDkBV(H`&7AxA;+@}|yZ4)!d*7US_q)q4 z|MAure?0&G*JCr+7j4_$xNLpx;#F0BOUgPH=2TV#R4N+&0kFjobk&7sW@dLcb!=X_ z@znOCcj;g{e(%MxJI@cCdvp5A+sCfHed7AN$FDy+e(k~e+i#z{_2~4Sw@=@Cc;e#i zV{~MkxN_*&m8ny=&t87#+||dIZazm?20(`1rKc~yfA!TLKlt>wFFyMnO*#mteEgfg zeeuJ;eDv*K-}~%OPd}04`4@kE^64Mn`RI2y?|!~--;JTZT^-fKwOL)|2{oWG>4BDb z-*B_HHrh?4ck<9Uy7=2Va4FEB^qLF#-qzigk~VZlPiMCvFI9{owg{<;xb#vY;kkD1 zBo|Cx_CfXz<}xd%q^Pv6+q^+Ag0~uWOQA6_bh|`lq#D!V+ovStWu@fjCgo;ZQd7ZX zGCEE=X(z9=re z1la_b^UnV2x%hqf`pt51o8{)~sEG(n%uZ?ODjgW@+&sPd*qak~zTR`=+YQq%mhXPp zx8Y{Xvh&T$&UCCiQ`xpFuXIgH#znB$S=tsStIu-PuB={mr!?y zU^g2a(>;A*0ouB#?VM2x(>wbb-9zHl@#%)5ywuj_rjZRh&YrmO-uXu#9lUaN{(M$J^U408E=EP;eEl*y#ck1%}(^no`y7lb* z^~aa)Jw0*ZE?tddJCCkpZCSakfAtO=-1g1fx&QtTHy?d_^6CdO*Iq!gx%lAYYfnDA z^Zcv3&%Zix_1*EqmlrMGQc>DdSJOYZZ0i_0PRFipJ#u!_ewx>Im(?y^G_Z5m-m8aC zJeoZJ&Y_F_MO{aCQC&k>OH*M(O;$xwMp;2w zYkkMkfwjAK?m2mS{N(wqhtI6veR^Pce^uR3PG)nIKFbi27~~o5?dXTyn6nLiEJ6wr zUv)^Y65kUu*bwuu(UWB;g*b&24gZ0nn6PGCX#KNdGK5DA6xIqhXrdLgETtN5?>x`m zg?PXamE`Uoh{%kGy^ptpzn@F6zei-SUtCylZlt~S-m+WoB9YbB!mtn zv=^EO^nRpnX%R9c=Vb}l-_C3f00>!}jM-o98{r<#M;QM~q>XPDMwC)oeZAh+Myzc1Yk>la< z^`XZ6sMuUDZyn_}Cr584H$pU?KB1P>qU_Ro9J+C(qzLeI{(dUwCox$VZ{9k+98HV5j;z1$5h4&KCi+~e2m0;ShaA~Fip3fqAJAk<1L zxgER#919AHCMYsFRUKu);vvwGsxjvHX;Ynj4EAmzY(`El@VdR`+IzhL0yE!hmP>%6 zI&!v`ZkBhbM?`99dUZl+S7GbQj#Pz|6TRpq3 zb#J>|zx;6hqU}{(>#O@V)DLZ`TD&o>t}iO9QftZ7#;0L_>8+)w$rp|{+!%6gY3mCN z0*8UdCMXJcp??6_i#3%1Y_YcKkvzgCWpfnGSgc(=JtTGIDu9kqpHxs0dO`sQ=scxQ zkd+oRfL8{(WM^Y7P*MtMwU9)T5-=HnHIF8seZ9{reU4l>#ugjmzDcm05 z8bN^+(NXXO9HWHS>PG*9IBNvyLSvIsX}iv=sw-R2j+c?H1D*Z- z&FvjE_05$v4P{mJSQwPnHF3aSh)>O-HVWKI9?g3a153ul3E(`e_(=tY8}NOoZR^3s ziS~RB+DPHatlN5Ec;l`$TPK!p*xkEgBhCA*3y10&x{{J}@nsVYSTR&}!ZkQN4gvB~ z+>8PPBN3#cZ%nEQO76+l!pBsmp6CmJv=DB^rDs_Z(KjjCqGVf(QZ!1mW=t8()OZg5_TO1O;-V zrM|2X{-KC~)WLuf2N_Sm20#Chps=V&0v^=!nEv$PhDRA--O#X!lhItPwf#a6Tf_Js zA`17E8_HDUo|0}zLQNjW0_jOYDpeBJ3BCd>NIrtUGr2Ir9X>wvbI}ol^EH@^uSN$t zYKYHF$SlTK%H7=;OfVoYh`I?RIZH||M(wOuoFq^;qXMi|ITT$KnR`m}hE=x~1V*Vf zTLC?xTJZ#dWkfBL2j?rR8Tk-p2qC4|(s{=R=bSkt0jDHq3o?NG4patVMToDU@)hwV zbMk-1WJJ}3JQ2yen8XYu-w8p8MhMgi?S$bXN=qtDa0G2liRn2c9gxp0sX0`{0IrFs zxuICPptBZ*xn){D1)aFGRA4}Gw%1xuKGK86_9L0#&ol-yXu*|~gX=FT{LcwE-&>RV z*FPi$26N+J>OmZKvZcR6ylJ3%g60MKyQ^tUQh~{MhKR+mk05@S%hQ0Rz%mLTgYYTj zD|IjonIIBiXeFc@9K;Kx(xjLQ{3B~1!4en&C&oEgM*<_9MSxq+!7eEqrJZzr%33{J zjK8^$ED;Jk%g7PQU*#rQKb#U&2o=HF&ViGkl^mjUL^(l!kk(7+hyVegE5OLGG)axQ zgRg5P3g3y}vJUgN0@0IB^Nx^8NT%pJz=RRt#aYB;SYCi!6x4+@cplk24^Bol8MNHr zkj0CC@+(3F02wAMABPo8;vB`Ki7}(##!kE)pI0y+S2rZ4o!q_Ly~L7qPxu z1|m0FiIJ>W+$@MW^hDaq0op1EvYS^h^#w0&jEC0btxE)!aqthBP4Snfg5z*4m33ZL zd!_#uN*z7pB(vn&gkfMZ$O~hj8D)+SH<I>6mO2qul2I*3+HunNH~ z6*(a3@>2}U6j^MLG0p_3!cfSu2>DX@KtKjj0@{DveS?Td$iNs(On3pipaMe)4PrSp z1sfAIQOQvWxf*>OQf^Blel)8+pEgUwpMU)9BSfL;icvxc*&_5We zaD*VI5_M4h=T{0$D$nP)3{F^CL`QZWPV+r@n*Fbk^5#X9NyT^r*A~w+7YyYCk>lg! z{exoyLlbn7={iG(F{L0nB@aM2){-6_odQ*lq$4RcD>ttK?gs{}we2fwx>l97FH5Ot zj>##GO39&dDa@RNJPr|>!hj8?qnyne{#z8Rg8z@I_YRNp%F=z+Hd#VB=bUrSIp>^n zKp7<@6p)YzLJ@=jNeD#{AaV{Oi)eze!5Mek?QXk!JTu)hXU^RFoag*=?r(qPo-?3y(=9ai5r37N1cXmsOIGQJ!llPAiU0FN{ge z4~C|QE-;Ot2ZWp8d_M)HBAiKs5ciZD;W zGS{vlhe8S!a2PoWa}zUfuMmhXeDMq!_rfHW8qlFL1)S;YTME>+BJA`aPr#N z;=Q96pUz)@IdhqYytj^Bygz?+b@uYZ`Ku4jq>@MU!J-C z`SP{57gpY#yY}kX%*`F!$4k>2GeYws9K(YwJiPU75I2M!WTmWOt*T|9prlDEm+n+D z?Hwu9Lh3nW&P7~6$-M-&Aml$$$;DrlGj8-Tt-4;E<=c?Ez?v2nnT*t7{# zk3(YX>SE*J;pp$@5gFza8|fDx6OxpGGHp;?oL5K)&I7g2qD+|W)xnF*NKjZJ1?F_g zBrHVjdFK2IWR>EYZGNF~2xY6PX+d_x=!s$nVjbb9K{${{c-&k^-`>P7)Gu~hQ{U+5 z?9{Qda|>6`UR=F!?fJDkZ*Sav4=nTI?N5xSuYY*;?w42Ze|_=UUw~zvzW-(Qv!7O8 ze8+`7d-Ic-a}Q{OeCX8O;h8J6d@5_+m0r>i7@uw6$a+UoL6eZs+NahYuaa)jKG)u!g0ybnVIf zx%<8Qjz>k8y4i=A>svup#N%VBqChAl-PP3v8($Z_7+q-6IPlms+0F|JO+pH{h+1_U zcW(wgDPcr=`-k`ih5Lm>21O-CCFh1GSP8_C@mD~1Y7jKVE ztn_wIaI*9>)3QUzRcn*BDrEumuqGsuYT(ceT=vvj*=+%7XBD@GY;Me5V5NwG@-Z-HVGQ9nwpz+wUx{b zHJpvLy`aswxu$#i<;SG9RBs#a8#{aO#GTVCpI?6VVe#ghf%zMqCyHBkg{Kyp z*|~}q9u^K(GzANYh|Vt0tL-Xi+P!t}v3(17y2h^-w@oJ%4TUCjcm|ZaxMi9c1?XwJ z*x3gcls0W?*ul0K7@dkrHlngb4l)l=)R5x^z=c*&*{o#(Afs>Nqo8e0DvBZ$PMovm zOu?XV=xO6C#Vn#kPzJ($L~Cgwvn?p-!ds<D%!al;oCr(?(ilQo1ZYfa*MW<%U$l4<$A&06T zRehvy%t42^Ga`6jCsLm>&lz*g5YY$8JM#A2N7Apz2AWvoVriN0VwLb>EH5dp&DZ;tcJBOr4Ufy-VGrIs?;&0@0BDTLGypBB^Ua)mX>JiS$OzsTe=$B`Dqxs%Bxz! z-{fGJ74Y%o)@_nozgcd*nw*-cijALrR9;khM^^ht^}u5HvD>?6S9eW6=%0DmGIW-X z;U#THirOX$TaOfPn=J2Itl52`WAah$z@^CIJt3KGVOeeQ<-5vzX1b5w-a2q9XX{{Y z{jQoFqkZG^TUvW;J^eumu&w}QI*4E!TM)d(^HZcRHY3qPyAOym;G%HV&?KZP#K|`> zj5ZDFSy9<}U^4NA6)8m(+2vJ5we_Xdb=d{Q$+TNa$xKSiPE60Ci$P3kCQcxjjFG7= z6{#SFN>Z;40)JIhl#wj9w4o!jy_>&(L}GSHZT^&Kj{1EPxPRkQ)DjU0@_d z&`Jo&S<7z({eUFn9TLu|U?gpAodbiy;BRw0oH9Ma;40WUx$=z2s)>~)Y)n&I8&OnZ z?SRf5O_~f%t-w%(ZVCE7D2uAmnHTPciMF8`;0*VOTg)Bj2Js2}p^=p(;y+NESe1Il zaKO!=OUXKDb6d$}aDN$Q)>fugmVgf=%|(NFRn#6_6jgMX{UV?i3`rq8%QBR$M9u|b z4CN%CQebzy00%&i0yKu{r$#x9g@wM2m7xvCU_~Q!Z4(O?Da1UFz-an^fw*F1$VIy1 zBe(}RxcEah0juG}DfyvO7)fU!3(*4woQFw*7A|r(B&DSYNFfhAox5a zs4)?OKPxa9ehE#835IzWy0YlhszAUJ%vg#?*v3SkBZ4DY-5<9};>ie4&(cmq+d$AB zq#k6XEWuLj+6UwP`#+3p|5LfVr;_=0=Ho<(L|L(Crf)5#4*6G z>9k94bW3YDTYFEiIA895NVv040Qwa|$3uq_QJSm@{~mM4!r_@EBVt3DAP@1N#8BdZ zxfcxaLdLR?qJE*UE&&L#1qZpQ1a6SZdkOtz%1iPJtV#i137l&!n?5@QH-g1WyeTjm1yRn+#S|N&XrJ+a z+j(=aJlJaaLl%O-J2+EmCl&M?CKidF|Axu%71Gyg)>l@dB^+-R}nnQ~$>GSNOJe+O-b z$p|KcyGT$2{6#q;3c4C5cJg{wiu%ZDxa-=vYgpJR=^3q8QDJ))s};OdD*NS&2)7s# zb4^r#P&Gg|YhnNg1Rh=7N#%eWa}xz7gNBTb4h$J(eM2k>=&o!_;#P9^1zeAImWs++ zC8f2BDk%4>vQ%|V5X`5~1T_%|$e=~6qDJ{)wUrkcBaSzDY%0$UC6;4Vy)D4_PbqXQV~r203~)Qfsh@GGTdix8&AhI^=nl zThGoeFSl7;ZnKV@g1+2ZHMx&AfvAeA1PHchL`ZL-4Z+8>bl1{cqoVdZNUi)5b}=^w zO=YBdlpv{^sA|(6%0}J5&cMRc(Aw9?+TX%4)XFo`F)+@_JHp;Iz}CSJ)}4c!FFl%R z${87xm5^RRQ_jS^rljJQu*@>I$V7*LFnjMnGbaz^Au&Ge4)A2yGLY=Hv_<2}+dn8O zIzB5pB~Qka0gz$DW|Sr6)h87+Mx`MlfVzQ{Y1~ zf+OPs!lMw7v3EgC%oHa@OM_)2{BJf*!NOvJiP~jBY9)3i07O`gemY^{i7g#_x(5$! z+db0UGt}5M*wj1LJ}?C)(=#&HD`7JGCQc1boT7FKAqWQYo;BNgfRDnXG7C!@w{`BL z7@1y*G+IJT23=pu0h+r8>)Uq2gDtD;$SSIXmClhHnusD70st8xgUd%jjSQuf0dc}$ z{MX}S%KFw&{ErbQ{?*&K!9;$u%_bE`c^!8pGjDB|Fw3a)fU@$8uI*bVcI`MhJaTn# z{QAhzmC@NdvzOjndGg1{-~7kDFa9>S@^;|FmCnh9ZTkGqDQ zj$O4~!)-$|Z3FZDhcAQ4OkaFK-~cRh?9%G73lApGu1sCH2RL)$#-o$B9?xFCcjC_D z3#)I=KYD%X(Whtch-!<=4?ny4^lQ+AyU#z|Uj6F9^FKU(_0zLAzdU&M!|i+DUcB<@ zxpOa1pMEw!e}D4m?TM*7ho)90=kFgs_x$+zr<1eSd%Gtpi`r7dvO}GMJ&f$^>FA=Q zZYr;AqM)QNuZY~FCin*NlEg+9wo_6}5%?`8m((z8Q{7D6$ivz*EikdxH?{NX@^$d?LI&J5ILI?9JUAs0kSaVqEiOAZEGfk=BErqv z2T3Podpg(3ob!$z>AX8%E)U~~bXS2(G*^fk0isHZZvjR{Zd>KYz8FgH1OVS4fE$#W0RUVd_Y5c;?au_5Q;tl zmU;CDV3{{x{>$^Xzo0Gi?2BI>efHzZ^RKC3I)44x)VW8yr!H>kJd{z@9g|xhm{RN! zmt_%@;Ga`fxbr~6p_4n8?hIdfd2HqDxw{`GSH9^x`K0IMv)yN2w@y7O>^dEqKkOXQ z?iRewC#22AyCFQWr>cE+aQeo;)S0B*Dl8m>Y zMxODn*q(3(8S7JR4r{( zWtM<*3N|}+vLX$#0aLAs-(qQMXlt);ZLeW!zFFUJorX4&J9?%rXku8}1>3tth9%`? zme*ueltrW^IeUBAxw+xOrRSGXHMaNQ?BJ0_S}CD@J$CfO_|%DsnKP3MXHQ?bd-vIA z@4o-#(aUdUmu~DGp6l#6SW~;Ru%Ia?cWd?5-JN~YJN7IN9lm<()N|U1A677?Y~Z5nW_?bdh?j+so5GEcsjczB&RiRso!5#w;#?-OWz#5&aXcE zCdq);lnvxT>(Jx4!RC$HCM6^D9K|Rb7ig zNu6d68O9djT3Sw;>efd36rFh?r$!^cq`V5sf$co}QJ)YsYf>+Q_5_$@j@B#dXqmg(`6t!xoGNS>0}?T{4RQ61*3-8o zc!Ns}%>J?v%}7sb!8UZmrDA#W!WhylA3|&5A+{fx{!fz)uF}H*s)s2naWE z^+VG}+ss8#(`t>puG|LIkL6W`*272Z)~e}P`G&@qG?sQ8*fz4{ED4}YkU*C3)_~OhOYajcNn{88M&uB zhF6B>_T)5A7q!hKmhBEqsf*5S$|&ESTe+QEPcKm1F0Ib4sL$O(_oXVDE~VuZ#wDf4C1xh3=fRW~ zB$>1<(sOJCNUPyx=^L3Fm{@{o&<7k=iJ83j& zF?J3g=^dG9-7{LfeRnx|wDOj`!usTtB70j;pfSikW8&!)VC&$jPtZ>Pq2OS8)gdnlr-IW&fDum^WX8(g z!Pdzc&qP2p<~I6<0tcfghVokO3e+aC8^iXLrxKVRC88lOC>H%nU}zxAU}SD(ZUdwv zp*nUpgx*v<0o1^l0vcjKqY?}^n#`(-6Tz4hY{D2p8JlkM@MK6dLy!Xi;oz}+WZ}OXnn8-?t zcv3`6f<+?&TPit3d?VC2iCHn=#DLfbxB*q%Rq5$sgoF+^+!ZOIu(;IVsALDPKphin_))+bY)%51k^3W84rYAmnAREIJ7YdaFW$S@dn<(5bu;UR%ApMCY(gc z74`uKk6;{�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%0ADZ z2!06d%+`IZwr+#gx{WxaMjJNUZq#yDHgQ+A_0jVVw1|puN9}HFMM+On(}C`tbG^II z42<0vn}0NS_1&4(?~dR7Z05$Zqt_lT-g!E6YxUTz$475GI(Bpm8Zw=y*hjU z{nf|cU3>oh^%uXt^!S_WpM1FU`iDpFex_IT*MI%rKmL#Z!}#Gp{?B)R`#*30^q;SP z{2#Br|2zMBb@j_D55By3=l!|spDkZ}ee(3PsmWVo2QCc`pWQdOyr*xmr+u=!dAy^3 zxTR`fd(+sC&Z#4lH%?!CaqaH=xuv^J+XiEz@&Y^}U9DVfjZ957vQ>?E9H@sRm-7%_Yjp-zcfqlTNdWvqQbp_Oljp=-FlqmPlD6Yi)mhCn6Q z1ys-s^sT6x^AGX~3J1*t<%>ealaUvbnh_oo>*nEUXX|KXVMk9T zcMqgcGqOwTz+@`gcDME)>Kr~?*3uael|sw||DQcT#BRb6iJoW}b_xU_Vri?Wvq8Ez zdgbTW?AkXma^%FJ*^9HMR~DD=o|fcyF5h@{{@ROE=N_HA{OtC<&mKJf>fy6*pS}5! z`Y%LgQ2Iqu2C?5;&%Zu%|LyTRZ>KIlU%2!B!pom7zx!qB#rMY^eLZmLb?fxKmcw^z z2d?L~oeV1+^G)94k=W~z-WOUin%i?Kv-NmT#-MXxvyFSPrDK}2TdKWdg1bkae{fkv z^9WR^lXq8J2Zp`E!Z445rn_Myp(O+Wf?Po=L+3$CMu`)o2`+3SS#pX_m>cAjH~db0 z!y4U9@&hAydpaSEJL}px+?pc%qsvtC(6L_fGT6- z=?y018W7?h5F(*50gmoIw$2{rh(AIoj&E zIN61Tg%p++?;2>IIn{jRc*eHfzG-C+LCI!LA$}2=b?v*h?e4GG-kw#t#V;<_FD5#t zqB^Ilsi?jKmp;FuxngTOh%OyeckCV?n_NcM_x<<3e*4qEUB30ae_*<@q9Z-2Jj5r~ z*F7SdZgCm)Dd{c6<@>f&AEUv@%Jzu~wfFOK4fc=EOY@5k*0nHD(bGWU#~69#_yl?w zwGZzvXlQiu_fsxqw(V_I}el|e@ z)ot%;+S$`NyubI*G;;&0&ynR@aDMhLUOu=edV)_bU0=L-Z~pw9*|T?!EL}fz;?nfF z>&LI$8J}Bj-!qh5Qts;MqNPnU1yKje0>ngMDn%qg%{bjagaZS_0=^_5CgG&XDkdaU zMuy2?Oz>5(!;(`e(ZwYf6uUtTj-Q6*VPJ6NVS1?PD{7c)8#$_K8{uEE9FYH_uah9? zu3t|J7Rvk#b#z@^ypoa&6JpDPd~@6#k^?;R(o@r6Gg`;D`)umt~!>Up{b>PM^5L~_G_C5t7_S6Yg?+S=pn0&8U@(3s81n9t8TDK z-O$v|$JH+ySbKw_Xaqyh#MS0HbK|(S3}Fq#!WRgw2muI9we`@|)G?#ew+)p_0xXhf z^1=la-Zm>89`dGj(1Z1C=oYa?-cnw}%g8CsC%$P**JAOuS%-j9O&t#vMbv#^go$uk zR@o{*p?^@pnLlj7Tpyw^vGs`B0=#UYC!?gN=MWg;8Jl715xQQ>TqMrcE78w7y{2*C z_?auOzgzwOUmt(?_vHs4y2ox5H_e2n?(zt3w)Na%?o#CJS4r8FgIA@MW0ARKroLW; zy0V+9qMeG0jk2n(ikge6mba>2u!&11&F_j^CV~l3@DZI z(K7VXFrXlmNoYY*p3s0CF<=XP30yKg6Kj2QJKzXXW>ytW=vp^Cr=Xl=l$dL6w2SK$SY>pZF{So)bC~LUKg7@&An^L!wr2@`X>2 z>mri-tThpE$wZu_#v&3cMlbOy;ztlgSYBcA86*w!D_cvp?x@+mw{_=O@9ZpWL(p*=K!o4I>-6%nNFYi1?(k2<{$}A3X;!0T`-E2uh2vmoE~`7GpCN10xk( z18fSER`6;u329DbYDTUTWDM-Z#KPIe!5iH|Ig;EaC`704at2NJH?N-(WX* z13Doh#K!%Tlvl+X#+q?u2@llNi2*@@Y~8#-ia_vCgW)Tnz#xWf@8JXAj3!LbcZnsr z)Wp=_JP48q`z4qhDuN*aIHQK}ogp}klSi;`SVBl_I`|A>1!_4!XRIu44PBW)qHG-j z-@<@p0>k6r^qN@Okkkg?r7mL=&COL+gif!DB7h9fpb(<|1q4aTJaP*p+(zi7pb*B8 z32uPNh!Srt$~Um~^arEGSiAZB}3q*ZM3UgkNPQV(tLSnBZ z1_vG82-IdEiq4EIX;Q;Ig|{Z)dPzM7*Gq;A{WcjOcfcBz3YS>p*Z~PAleOd%hyj zZ7Bqhxr+k4Vv3?zE3taSJEhc~bPS?PyV&Vv780p!k;iW3~>znx!Cu(KO&Ee(d8m=v`k)x1jY!Wk#tG9u)ozV z$yhP}Kx2f%BO{f44Cfb+MAF@*I}$JpQdUX|8nlf@l10bFgjt7gEbfp5#qhbmU0Y6B z;yy7$Ks7fjXlUyq%;L(9j{?;i1+@(dT8ipMssW_}I9P;vUIR z9dQy&GrCyHGfUCtwRZHO7n^8UrfUdFL(qX99i1as0-%^+L;}K+m|%o#TuIh2)?3pM z@~54$uF3k%2)PJ=i|I#)Yej8SWkY9Or*K`5SZ(h(b@wO*TR%l>A62^`E$3KM-)z^| ztud8D#RDe`N0)Pk&qTIQ_*C`>Rrkj=9Z27Pu&{fgYR}Bp;f0Q=3w?{X_nm%l@X9CC zcizq2|8nNu7mJU+TX_6|aq5#lEFA@sOh5f~{^j3i zU;XR++rKY<_V<&Y{p;D!|33fhmqRPxjb8g=^y-)0C!TdIJZe35w`uZL!;u@6qZjgb zEyXk)4yhRREf{c4>#>R7ZW_~I72oWT&}J2})jGW1Hm1=cqFUFt(8#~UH@7>cemJ^* z&^dFfd3c_wZ=!2hW^hV*WL8a7;nv8)8o!h*Ti;;1K(cb#oJh);SUFND=^q&h+0QF1 zCNM6I3Zn#MWHQTBa%xZsPRg%?B$Jp|n^V=ENc~R9*0_SI$gJXsjJ)vFl)&g{SnFQC zL5SFdh9^?pL$~X+qNe2ht%@)!35rXg%^cN9u;qP1q64B538?*} zV?9Gd-GT#Yxnl3)j<7SzHf&^scvv;KDAHCbn2pSH(Nb-*Fk=FcF#saBcJ>M;T~gh; zv$}J4-L8S=y`xB{lEG*6jvnhDTiiQ-99Ra8-~AJ(8T-Z;knp9UQsvg2$?03tGAe6p zyE=9Z_w^s?-g5{6888_DnU?MYbsdA%ZF`FA+H%V4lClc@L!(SBY{`AV;G!QlNHYm# zmY_%!5q+}kr5^XRn4$SEMpC#dGPNxUw-g?<_*tl7pxCa8tl@f5&1AfBv(+Xw2PJ)H zbt`v$_W;|7)aatZ?4~UxI~wYTw{4s1>RH-*;L3ry2S?Enz5WuFkCQ8}&#u0^^vSoE zUwydp`uj_-c=7e+SKnTL{o(FsKRy5EpFjEVFRy<8H}IAhU;p~<$NzZs&EG!%;XfJg z|M>rY{qz5R_rw2s`~Cm({OiB1zW?jJSAV?m_}lZhK0S5e`NHW(M`u??_MhL?JGZ_0 zU_;GdUClm5Q{BF%s$I<$I~$6->WX(X)$Hx-onBbFcjeC8b2nZL95|6*+!E-U;BMz_ zrEf_su8yLLmT=h>1sWque4_#+St@b4hz_t+Vha)buGq08jdXBT+SG1Rv{cdaF(R?( zn`0lE=Ng%1=H{!UtuG8I`A*v8X{wO~p|cXSir`3OL(}8a^T@bm6qIwDvdZeyi)&&s z3nNm}f}*0(h<0^%cW`p%#<{ur(^iI(x`Nv6TiSND^^dm?(CoFDtOvda8$6&bwo90F zQI;x>3MY#8f(%nbGav7e%Br?KgHt1iPfjdcoj0{Prh9J+`9V zFUGIG-*^6P>(SNp*5e`B18$KWE}@;C;XN)v9qy4`p#_5lJ5H4LEhkltI|Me^xD=b1 zhgnz$Slb6WxP-fVqyz*P71ZoGc=Fcr!x!D-ha)pHs742_6ijS^s0$Z{2S2fWh{?*1 zA>161FXs37Kh(mY&`xK0I!qa;XgQj@L6t+-+4ym*VgTO{rsY=&FrBPp(F#j5#W&vD0T#ip1?H}`#y;zvg@i; z#t2_UyvC)_(MG%uG{Dl;)!y5eUQ6hOBc;d-^nR%UfdEHx4P7(2jUUU&uaQ$;zgAmG z1y|9*$~nj{G%Y!^zPfT(Put-Gy)!fIM~=20Io7jyvFF6C-RB>7F5RjeolmOou?vzdAJgXlVAq^w}5F=bzAqY5erf11B#Jo;cG#zqn&!qJ96!*4=$IJGvYCdY5ip z-#am$UQt559`vw`@-4;NI%@m&H4ltd_w**0SGa|T7}!~9TNr4X>!_J%s2HnKJ*bN7 zZLM$Nh=^dL`y0PMz>~FrheG!s9}E4W0!R=j()Gp$MHMyag9Xv^k)4h=c(A_GTOtD(LZq zu{a_P2zoAjB(V&@c!U(-=1t04bPGb9mV6CaX1qsm3z5s`+q3`)p;)WXI6Cp}G4fZhvv^(N{;$-r7BWtgdSh z8&KQsqo{i|^etpokHqEg&f9vpW#nS#_{D;@e%HtpEsD5xP~4>fv~x;cMMYyff(CXj zo_O65Auw@bjS&24YZIEO=olMP!DnD4M06$1UXh&AHxS#7%$yS3si>Y%c~lmyO3YM zOW!h({?}xlr7#o6T4eTRZr(_mMpIc)S6P|vEy%Ze8rz2lB-B)POeN-b z7~6zv>A9<@*{LWav~HuKWTviesjX+Lsbi&#ORP?_2`#uKpw>uT0K7nM(Kn?e#DRi1 zqGlQ=p_)Y)F7@l7c)?7l!qP2EPy$4oU(Se7notya3`sU#P%8=+0AYZzT>yQ?#v(cc z2cV2kBvD0?0uL?-m@QX~3=*Ea2muHQh;rC6q-qh+2?8!Q4kB5uB+H4LNc04|Mx;}v z=t33(5Mpx-l;;raaEG1UeJt!;tzCU&m`r?OQP!5K!kWh7>XxF4=4@JU=9G(un@O2q zGEs?HblyzJEQ(Fd35tlfvT}eB&*YI3-Xu~La2EJ#KA4IvQrn2A(0vA(-_*jYoGsgm z8g_1J>u=n#pF~^Fz|p>;DcUq_>mIIc?ysubla=3;TiBG4SnBE;tfi^TiEybAA|_cN zA}Fc$feFLlL|7~$62olUJaLnIkgekX!gY;UU6t2rZOk15_}|v)R!5oj32oAFnf6xU3b+X z`#8|#F(4upn;aUKPH2G>f|L_Cg=Gny#@NKp#@5}@+0V--EF?UhxeB%nC(ZUWEvjy+&9zCIL2(q6{W5bA%@K3_w(PGL$b-B8MRcwc|JZt2#ZJ zH8c_KfH$L~Zz5Bd(leRSUpP&~o^21VUlNX&YNXCsR<@BMQde zvS8URB^*YOl)#9%w&EH}QY|vKP~eb~iU?b)untnhC7vm{T0>(7VNO{oEO#FKUsw<6 zmoi9AAS2T6dB6CLpxg*GT3kVH8DC05jU(i0kmE$95q<>!BpV{|m$a%_ixRXVzKO=@8M%PJ`5Tj1Tcb_F@kC<_J6U_i-LMV zOXI`2t+E;}@E=SiUFiudnGkG1;8#40{Zzs*MME^I@L&z0GED+!J=sp)BZFmR;#0!k z6(kesFvNBv9j!PdR-zaJli?cTh{&#_%m`z4xK>;-jIiuk0>uSe1{g_X_SxKo(uqjx z3s~l3IUIW-^Rga0rV9kegy-6_#k1JOiHoxrm<$iD3=b|5CyqI#L`Y4G8RDdAWFwd= zn^n<8fj7HRMO&U9RjFK75yfuQ#v}JcXuy!jHUvaCQ_vv*cEDux5Mr|PWObNW*pgb( z)i(f3Bn2RLBD8}bgNYVbXjLf6yf4CbE)F>|K#(%5lJM&@hZ1bx!~_)@~u;>9u)H zqua(WHBDTt7&?{LJCogUD0ADv(w@cop(`Cn9&{diJaFaxfd_v$@bs6lr~fo`|A&JQ ze>%4MGtkQM)jyqh^y7)uAI`n}%kqoAoPPexnU{Y#|K`{0@Bi%z0LzQNoO<^2(vv?e zKKg0)-XA7!d^>jG%l+rS8b14OaQU+X7rz=wRax+Ijljj+1YCPk*}W^r!vj z-ZA=4etO{A_XlqNVgHTakKOuV^1;tXAN+jy?oSgB{%Ppi9|x}fG^hwqi{xmvvYQg-KZ$)3wKhwij2Jgz%>C#P>Nq;!XSQnh=0 zc|b;eSYAtHQA=1}rAKV4k&8FT7>gIb2q7#wzR~Ikz{D>)*)J+3HmeAul$>3ikR=!| zFl18l>a)w+a%(!XDz_(0s(u|FEEmxO327S(MJ;) zJSQ=`8ZDZ*%yJ5sB9n7LU_ug-{KFz4ISBQbxFj?_z=AwOf?(-bI5@z}gbGE(hM^Jy zGLU2>aYk%1_L-;;JOuer+AwKLeF~@~1=g-??xm@5%bwB3y`$Uu4|Wet?b$z1Rl>f5 z#|OqwP_HyFd3tE_Bto6ThmZG<&vg$TX=>k>ky9HJpO>6gT3y|-y>qa=d!(cH02(qf zOr~MSNPXu}d2>%ebxTS?Swvj2gR{HnwFhI6buBeJW9Ez5E-?@U$bjh}3>Jc%0+W%2 z!(wf)I%LqL6suyW1a$$GuQh9w*RP>rhT%p9GX-@!4HI`0*HE|Ul<55Q)Ghfr4JE~$ zbz4WfdKbF~mdEDq&YXLORK?jl@6O+Uf91)CyPyB^=-YpN_|31M{P=Ir|M0ixAO7X( zx4#0&Jp1ympZ?+RZ-4l=Hy{4?ETpa13Y+rK=1{g>5OzdU;N zr+d$TxV8G-`I~P~o_kEhG?tKd_%_CdNx=ZugO7mNb^0w7h_0(1Fs4Q%$$lh9= z*HTrmy|%JOHT5SZmHB#v+nYO~>rIs)O&~yHM3#sc0O%V3j*V23 z(dH6y#ke3C3QQ%Jj)A>klfaWvU`yL>ZQC~)Zd0J6zLT)Kq`aYo%{vp9${(g2&&fGh9 zH~+ARWNIaHDqCtg``hWdH9THa-{RsI3a?x2(V}uz6ncov2KjVsw}K+7Ryeq(#+E_B zu?}S~BVWtXP^Nh$8S7FmFV=XCj(O_sn&OP z@}ae-=)*{lN^%8)HpVp+mysLIg~XQzNdw6j-I&xAk+WkEb>fm4nsHq%Y(3l@e0&^z zeI0%Mss6BVb=R@9Rxvc*q^YTCW@72?>=7B7Tv=4IqorkNZ`b(f(EQBwr3=gVA1pt5 zwEXnxjW51@{NtaW{pr^`AO1S`@cqP{_rurT3|@ORc=eNx*-Ob=cZTQIWmoUmabOOO z>ofO1S-SIR;o9x_>o*r~-J8F0cM)x+YY&&M-J=uP^w}%J(l!g7OS$|K^cf}={qqRJwo%Oj$;BqcT`CN;$+)Ws&& z`UU5>dB!=rhP${1d;3Ir`b0aqhM*r}YT}}$jgMy)H$GXsw0d~y%IN&r(Z%y)CoUr=KDm7V=$S{;XP#iGrcbX< zF5Ephb*+EkRA1kGXWOCnZ3lZgCwK3fnVh+Cc>db-(v9(j^CR=84lJGAe{y!mcz;e! zk%gP}M&*r|P!M=Q+L1IWaWimKgpiH|*D$qY`97IriKD>WW->Fx;~%wJ%yI@xfVWF- z5Z)5*+9oPxP`OstrJmY?wgqH4`5XzoTmybXZM228Wl&gPdS+&Lc&v+qkEx!mfrh1- zu49;QQhZo}r%R%{dunk-e?{&7;;PZIhC_8b7P=2y9Gbhef9?{Uq>zs989usmXrZld zrl@`>A%BNYOuch>WmtYsb^l_|vCH-QCee1&uyEO^VS=EFe{^b9OIK2M35i`~8wsm% z*Ts5KVyhD|4sMK|xudF%DS!-1ifE7E6bb}RBj%I`02Z+uF&F+M=fX9Rt!^%hz&Av? zK-d8R#_mEo z7C{j)TN;`UOi$ljefZs9-~9Z)9)I=kmsWo`u&~;>_grDcSX%bp(C}@Jj)g`BaXK1- zIvPIunm)Q3?)usu272BW*5SH_Ug{dQ@|$!wtyhM55AZ}$9G<e_BLJ zy?zn(Y`Yg&6`QMZd+^%-p2H%G~OXqK4ir zZTo6FMp||r>>Zi`mgyawXxljoCR0|qGq1QctDup76Tu-#1i5VM!rve)Wiu2&l*qFa z#mLTuAc*rN#uVQOHA7(&@~XaJ!9lUn!4Z*m4h~w(ROYjY(sj{QzzK2p4WVTZMQ4DI zNUg$9#kCW;4n9b9alu@Pt&kJpOZh-9rfi6x;cSrLQ&ADbGms*+--;=CO|(M%F4!!_ zMrL-l*2r-?x!O270m5+l?3+vg%2WYrsN6Aiaxr!Gv~&+Pa|zJ3v{%xD_oB{pB3cLQ zK(2({mJ%4~7L=9KPMx*PpqvUgg>n(mDiq|?$gVi@RKnwmM7nLDDZga3&RQdDZDt*1AdJgWNo zYd0&b;iEN`mG!hYYpN+~s0wn3BISGlGAwU(?x~PJ6}sFsu@SO+fO0%U%RpjOegwW# zBK4>OdxxG%#$bZx2z1kI%Yf=OO${BOIsh3_VvKobbwJ)gbVpAIN)>`;+$vJ-(8)yD zs~}XxWS9&)rVNk)AYv_Z4aKe}5&fB`m`7H$%rwZBwm@8=UP$B&873pcK>jZ^MOrxj zKaz~>9a7yBI0M_RFbk5J3ZMk@3*r#y2h&n$O@rG@P*XMZHwg4?z z2plc{#3W%q#vV&o>lO2Za6IjT6FW(NNAwn=d4YWgmui#A|iODKZIi=sg zPenEmYCoY}kw_Ld1prfQtWs4PmkxMAAPj73ieftxUOmGZrHx)jL*CW{HG5B2>|HL~dnRN1vB&r%HQH*Y#iAI()T$WChfv z{=n0k{ZFe$p4K0D)_nNo_Q^NxQ=c{;eBL_tN!QWOduBiHKlROli$6`?{`J`7zc0M{ z&zTp0-+$-F&g0L@2G2#;j`-%Z`((C;6m|p_Z1c^mv#D@vAu`e}Y8iP+H>Tp6AWdlU50l-$a?j(yNp5!-L< z9ijjA&i!*lReKLC0LY9^o*6oPYVgQu#AHBe0A%*=KZb5h_110x8Na~z#MFY4vaJn` zJzHD%&|-Z+{zT$@V^pa|1aHu9Wg;}JmL6(FyEjC)VR^cp&7sB!g99Ou$ z0v82c#0p6d;WXpa@Ds(e5;>EIRY15RAYKDi9w7ydO$xe->UM^fUJgFNK9NbNlIB$A z6f_i9bT+mh7(8;}(1|+>S6-jH_w}_WA68!caD(Tk6vh1W^DqAP?5lr$@$KK9ef=*_ zzWC?Ipa12-n?K!u{lmjgf4u+t4>wo8V%&N9_5By$-FXac;|~v?|M=w9pC5nnN+=FPF})PS0K)89UM4cetf>UsY9SNl|k_ZcSlcZAJOEs>L+T{o_-M5R@+7(o|Nxt*ovMDQ4Gc%Uw`}Kg_j>Du6@!nb}piLmsP+PW9M8G>m(!NNIg9qj5ssv z47b3V((V5rTkjoKRhG5;T3uabnL(oDoO8|~8I+uJ&PjquP9i};1eGK~Ltv-fPV@=a^%>;~npq96bH9{mAXm z^mbF*cvTf=Re2*VWnG#v80wi@TKKql#>b@BHw_#gJ9qQo(n?ZAnURAXc_RE8*|jjd zzfDudUD9L!Eq%c40bS>ZkZQPgGJqPYnwEyv4rXp1)!<8l? zL)4B$3GpT&22lgI5==(lj7~LnmM-{{_PVw<22ReV?jE)QfdL8eNu@=!kM0~kJaXpL z+?|`}U%k5V*%vF%UM=2vbmsn(n{U5-_|;E0Kl}04AO3Xz+rK{g;a~54`)}u7{BiN| z&kIj}o`3$Q#n-FG>9RM5ONHGq%2 z!y`jdvLiCfVsdxIX4eJA6otm-heqZ32WR>QW`u<0`G=%CyG2;p_?laJB1GvG6y@X{ zV&g>54mTZLYeYGeRCHGRzjbpP#z=Ty`v6dNOtT z_Wp_GL&q+RE?k8h10VwwGdy#9VEkJ5ftBXnCw4WA6&ClVCf6m!R7Lvbgt{k31>_`0 z@5sw(YiJ(ZH*{iXdKqrX=+cFerLzZ5&hH)>%Bn84bhXF#2bN(j$s#7)HX(RR8j8-D zNL15}NCbeQtQ$9*X(nt7UZ8|~Gpm6d#I%=!PvTEr2rDEiqp?3Y{A6ZTq01_eEz;1Y z7XUd#-a$C9MMvGv-6b$$dsKX^i<`Tdp_PuBA&sbM-r?aEn3`0$Eg;cQ$I;O)xTvrr zJAZe4T1$LpM_5uL_pzd7wC%tQKxM}e>hVWfx{vIr@6Rr4&#UgutJ$AgzAwIfZ&K}G z!|1sd6w!|?M;10{+HGB{WoqgkxIHD8B#6+spp}NU7O)I{yGYWJNmo>%Ohea{v)%iSM9v(>ZQ-ZE8RBS=HhV~c{*7DZd-&E|@mp&;sQ+MpvZuPd=!Ocao@ zU#|?nC8{B$FiKTHgRbZhFM-iCja}9C-PE=0m6QxOty9LcU;DwvwePQ$hyROFWHg8w zl@QHSCizI124Mg`19eFhEI_?rFp;f5E`Z_`Fcw@RRW;;0XymH_OThq+go&}HfgsHA zTP&(5W|2fe(OJd1s?t=K+!e%fb!~V!FvLW^STPSIP)4dg;3eKWH3+|jQ&J%lwM~Qs zB3mkgGVUWwj5|$yM?At}Av%^87veL7KjIK54@;2whEmGLO-y5JdlxV_8+Y%JxFj%{ z#De0qg7WO5s?6-tw2Y#Ztir_fJTMuVk_?y(dNK&h_=iM$`2+((5H$>qIMC%6XjNWT$4w=I%%=tV1}xxNcv0<6uPt8d>9wJ%S^R5?~Q+@=99L^J>W* zB&L-HhQ`q+h?_--B5)GIKJpTR6d(d3*@JlST}Vi=EUoJ{tfNxQ&DYm2EX+43)Y`^@ ze(@rfmjZkxC8!@3Hcp;&3^X#Pr?vuUj3`qe7$mF|sqfz^6a+vhTp%$$aRVjQYvw9T zL(Ed(1;S4`d1iuuVg$zt(N`6jE)ciX$lL;5dQ)o$kQqIC?&wp-0;De#W~gaGa7NF{ z#>mmd#M#H#$s4&&4P$eX&rskYR-qdMT1yoqtP)WVrMiXX1_&U+NC8NQ$_^H_#E1AD zbU~Ij7KWdLI|=<^MGY#&&@}=|g>=Dc($Lq^Gc{oPF(J7-yjzSUkr$N+8zDPWup@8) zFaco-1<5|aHqq1rvI8dsc$5j|(AHVQ*igejA7qBE&=gqVeqlq9c;$)H z6c`vqK#c4f=n0^o!~+D*8_*C&s)Dw0$orr?%BiWSXhK+G`GCpj>KTDMfdK%yup@{E zkeF1vL>$4tFiqSJ$$3Zb5t0zjCoqXB#c0Ns4z~132?+NNjBxi1vaxqJHnpYJT5b~p zL7Hp_;6Idc(df$6Gnlt|g@jp?PO`F8|L9X)*_UrYpl!+Q{r;jhGPVqr2?^73*T8Y=p5 z=ZqA(guOY(n8tV{1_d_mZl>Y{Rrbxb5q3kcY5o2f<=cnDk; zpcB4DY|dN}c!ex~&FvBEYy+DhI53k+MD&uWp-6i_TJf8S(ZwCGPwm2WwPUm^r{$J3H9YB@*)3tW@a(liJDbY5%obD} zJ#f%MJQhWD7;8dU9+D@kn6B~UjIe3%PDb*?*fN+543{`tVfchj6z7Kwl)8?!iFK$~ zNRe-Ry>~*RcXF#|LaSqVt$j$9ePE?;Tw846VAjql8X8vgF74>QP}H-W+kPUUayT}3 ze^lC@;JC(^^v;;n_U*Ct;ZeIXvO2S}_T=PtrKPq+$5tmMH^n8?heg#y#?*&J)@}>i zxh%2s zCZ=RMwPvBD?Q-40M?DK)9=h_UL)U*Dy86fNbKf-2y{emdPBB>aj446!M zSzAh33!7kE-cF8~+{&oj((udz6g>PR<9$NHXqaN}=;PxT9T1Wd8kHTDSQL|76q%Gm z5-=huQxf=%gA?cx5R7yThhQ=U2fGFYpx3HzY@(*2!Db<0F~a3zQi;rq==CW888Qi& zQVt>QtDwM+z-Htf8lG8HTT#CkJzgQn+jgLN?>NL5(%c<=lb|sieZvd=W2g3x%=eAW z(`kiP*A=@ulQK$u0%Pz2@CuSs^K%NSN~+r`8@f^c+}YAs*|fKC=WZDLi3K|V%st^K zTH32BsSu%K55+;E0Ldb2%{uHh5QMSBLRghG=|9_`qh54 znvxkVj&Rt<%E5PQsDEH&Y;qoakK&p=joo8|N6$~6eMr61xd&ffd-lisZ~k`u(T``Z zetLT4l{hYZa^dD5R&M^`JgU5RzFxWY`Gwn`t=#;AGGtwp5`xp~#OxjXWu zqokz1w6w0YWM^q%OGSXp_P=$cT#qOg9G z0PsKj9TjJSGQrqLD-rvHv1M?0U^f_(e;l%3VUD3}u-%~Gi%%!7YN2lx;ucborwINj4#g+SKE{IWAs(e(}aDs4^)1-udLaJ8yrw^XVUNe)`MxPk&i_@LAu9Tglb^hOUWn zTJD=wY~@&j7%utvOm z!_4(9)yeaU?<3s(J(3_YOh$MXQX+Y|H+!}V|%ABBDM77>%YDD{$F4H`0u=+z7MITXJ7yA`8R)i^Ygzx{qE0? z|M2VGPky@m=*wHrzq|bL+ml!C3{1`JXl;+p$_dZRN~@|aY~NGb)nB`RytsWZt+FGh zdUt8#zU=b0gske2=u8j4Xecoj)}9W|0rYE)$Sm@WNp%Vcw{Y^&)VCr-K}D^xy=OpN zenH((LH!gK-Y=rw+9}J~InT?zXscV^w!pH4xcZ{vzJ{jpj_#vf8&JP=Lq*hw_9+6Si^_Kxh@Gg{X*(b|8sO+q7*&6coAuo ziSyUzZ$3sfX#T>zi4&K{<}S~ixjlRC!QA;r$Ce)+J9B^L^qs?#7y1vK**A1*|LEBR z<10Obr`vny>szMFDu&n-W20*Wd@^0_quuPoz3jt0%z_;CJY9{v-7NgKI>$wY73bwO zw|0$F+%&y%cWUM4_}NQG&aU(yJ6c#@YwzVQr!0@16s{n-Hl+51S0fG~`$7_$sVhPX zQJcivmYEcs78yZ{5EA3eAIkn*vcsZhlfcH|#iJ*qtf{1Hsb}M1;o+xbU`&PxhXkb^ z&uu|r$%&zHF_7!@NDwHgD{NANMQ&PGkR z+x?3V_s!of>zQzk$uaf{a|ntJj?eZDi-Y#5p`%NeTf#9MDnJH;8f{}M11lG~EqWrK zC45#9*~t=)LOFf?T1uH@9dZS8SV}d5Kd=EYK43D$M>0%?U5P>9fkj}^L(iaRioU58 zAjxKRZJ`K39H_3t{IquUOU~JWg%6G|Rn>I_WT1B&hFuIG#+#<^aLZEJ|SfhDC7$Sn%bTO!gB?-N1c zs!4fpilx**FIDyIt-a%IgK~m%JF;7+VoLY>N9^#Ff|IfWtie_CIdC{+GGSpAQ|qQQJOUP&}NJ zxYx&{%+)^E+Bn`oEm(D2UD35vZI$E16Lob8WRz7AF4g31LR3Ugo2h~*t9WgoE7~X< z3myWlGS(HKMv~J|pqQU!!;NELF#BR%h~PnVBIdygVpi~iXDQ<>Ko;SqNEL$8LKB`C zgDhw>q7YDg2>Z)NYuU>sbuV($?Cet87osOTb1(!=BQrz-*>9sVa}sll(+et*k-^tW z&nimJEQn3cii*$R2#ZYvlfe^%br28~<>uiJg@QaflH=kaS|xTC5er`++H%3fK!wa_ zdvtVGaa48%P3OU6${G$-w+&ae4%M^`fys0ooT+Zxj|Y`g){dKZ1ad_*$OlTnn=n(-L*z@O2$Ydz^jW6_bnKGcES4aL z1j{H0nGscGA|^_fC~QPy&C=G%7(H7(eI@`u2XX;?qqL1lqGMsBXYFig=VoB#2))YC zitbc42If{;MnZgsQZE)J#fHR6_|t619OBMO4;e1Osj{w_A+odLjy}YO%4oMRDXyF8iTQRBZr{mtpgenB`cCjs1mpV zCW~23cM%G&I74+K17I0Sw73>L1dt!#S@02z2C*B3CRE))F6Y4F5o3Y`^Z6_$x;ueB zQ7A`Y5z0249qb*T9&*0)i56G~kQX`wn5y6SA^eDvG;SidK-?nnKOtbtln}rOWlW@e z6@f0@ed zkHVX}Dda;v7J?A(RYqrt+BAeq2yG<|d#*}wro=?TAh5bblq#-P>L$n!d7zoCuA#1} zg;k-liOD8-E#lsMz+a1?f+7)OZB1=eL*p%mqJ=l7Eow{QY!Gy;SpjsF*eLp@a~; z6O@rAx**-jFdTuCU{xfZjDW)Asg!{xu>mTbgvlrXK~uv{l`g1=1j~r!A+jyFq+A^+ zjwIf~jTV@U4C|BiMUpTXVXS`BlVQITcnj!7M);ROiVp9spt4k$%!m@+<- zO$w_^$iWHl%)FJsp~9XkDTAAVy$Fj3(hQ77H)kP}@~%G=%T`9tVHgCei44vMYxo{9 zJ`y+ta>5I4gm6~`N=v6PfwwR|ya!Vt8+-;yjGI(x%kKPtU@|fep8#Ya3G-3>Er$$~ z5fhiIVd6@AIxqMlG1Rh$Fez(U<^W%!r8sj>LO%$aMF$Wi2v^8=t7AQoBInT27k$;q zIU*)N`y|?3D`;#1V*zOq6?R($b5)eoNi&&!2f`bIz=pQATIQx|1_l&Y@;2TBCIg#G zlqI5RNmu&K3TzfKQl&UgscuX79#Y?A+zAR3Fz-keQyFcj?`md6qt$RT=LDL(*!dUP z_~fA)M^8hx`@u=u9X=!S@-_Na{Bpu|?suquA;?OW*MoxjyP$Im;*-zzK7J3H7j zJCneOM6&O7})GJITuP5_~)|U0pIfJ@S2gOZ)<>{DZ3f0?Gq|YkUK1w+1(O1~+Zp zz9%4ZZ&1YEz_2c#;AW4YM(@xjzwnOWnC|UK{Sm1L5^~0}%1;zDUa07~Q#0`KuHk3( zg1xPw9?kp(&m)nhS=OnikM>ZtE2O(qVp?b3o3$= zGJUp3A_w8%>g(j<2V2HJgv3W`NK|@6Vs>~^R#-wh9~%&v=)ElpLJsf5Y&v=S(zDpX z+ta|zl)Ml|n7|M_g+0OSU^K8NxM#v)1F1vH5bG*ryw~HGXzJ=AFC3Gai9Y9!x?YaT zx_x!6Lrqr!MXlJ^I$SPhfctgLE3lsz>)fnf#RxGP7H!#WMW22PH{$V zS$;`P>CV>b=I-jIuFA$el?^?G)$OUpweW>#L1piE0>l^FP9u}Fusg5D!=0Dlz{!EE~Y)bw9hR5XBr>Fr00#%&2%IXl{R zv>c$j@yN+*2*{j$_!Y;6C*LjI{Nm)L*OMpi4h^60*?V$e@a*vTNwm`-&>kd-w*F=Ye1y;R>9q(N)ARAihMAgU>ZlJ=0lQcKRDGpb)sQ# ztfI3oJUv(6+7=_sG-Kis%P`56-TBl~^x_YzP+Ra-iQrNu3MBBjA(kU?_ zad&#r;n4Ut2d_+hV{c_;1Euv_l-DWI5EoXGks*!JLSoWu+6GS?Jbh#8`h(7yxx^ji z`nKll5L#IOyARewa1_v(kKfU<*zdiryzky%f`Rp%OU;eW4;OmPIzgfQd<++<*E?s`JeC6%ZrMC-b zUmQREbY}6{E7Ev0r=ee^pDqHe0S;Nug=_l4S@E^ zAOH2qH@`gm!w-w8&d0XrHIhkyCHH!>%OOM`OlAqmLU2~wZWqeQX+@8MqzJp6cV;A-vKC}1G zX^!UZ>89PoJDUb-n^D0UZR{Fv9XQ%{Xs&DWjOdPZjLzE2R2B8koavvxIIwWz;L`o^ zi%*W-{AA+%lfe@=hGwrI|8jWY;(?i^@x^Q73)dzVZyY;&9|FwOnL87wZysNHcnrdtutEoO%Q+p`Cuq!vKJvnw)bZAA0cTT8x zrjLD$n^mZtp{JFBqoaw7vw^dTqOq}}zL~12oeoOwAz?w83LlS_L>kEEBES-U%~Q&=xEq(A_WtT>S5%NG115|0rC@J>FT3k zDfDdd&xvIMqZ9LM+T4N?lr=3Bx0qPj`zB{r7gzM8<+PR540H`GPM^Ma=K9N1SDy_Z zzch9F*2MhvuKp8M4TF0RpJY7e7{iONrp`SdU3xlw;nR_&mxq^Lj$U|s@a(hQ$F8O| z?zaz11D5d$jYXcq*2&eu)eX>6WD?0oD68vP*wZ#zLCa|MMp1^tn#GwWswbz+Gjwa5 zC1M=BCcJJ|I;&eaZ$!a6TiYwCJ#=RD|sc-?)s)S6c7n*OsS6#F($2B zOdPx-QVOW{bq`Hb(z7GYO&zf?*usRfi3z*GKZy|p+zO~7uewQ@0xL*%PAEu_yvB(Y z={Ay#?1sFXza*a`sbzxUpfo~x0Q_e~6>ZXGQqYa*kam5+hYa<9aLavOfPVeP7Qt5+e( zV`&|boL#f`@R60f$F4tHdHUUjr$3**`|aU{XI+CgYZ~VBa`(qa)`xhOIU2@Uss-rD zJ85pRRoi5(u3)RFYOk@yT1nnu-A5{GKHMb9WszzZymv;MLrSw!ud#^`5*HNG3#zB6 zFQWVdYPM#h)Omb8qbDatVuI;T*u^{~Lgc`eA-zEIMaLYH3qSadZC8 zp0cKasjkmTIO4u}UL<@Z?> zJVdZ5rLD!6(U*aCnfPW1#=?`3BoJ*K-E{N>hX-aUhY0LJ6E`bSFk)%r=<4QWZDpgO zp~1$-w0~!RglzIE28}~@39>~b;i94(K%50b3=v3zWkg~dfKE=d5*8aM8VssiXvYR7 zgY-S%u#vfywyvIR$ukEyJ+MazF!WK?HnBCab%#?Y>v0dDXKLqYU}a@wWy!1{1Ov$d zQxf%Vl(wn9<0{~N$t;F2q2g?$=#|(O2$oQlS-nL_#Bew1qokxQ#BCsGaSr4trIjm2 zOAH^?kqEd#VOLUMT?oRAgf+>~2H_`zqYJ?~fd+`H1C@jzr=lvlz>{HzH%qH2Gc#B! zvItR%mvIS&BLR*{#_o4e;ZT@FUtB8kq7LFiCYymVNjGh6LxzgwL9W)s+71{E$t?g1 zZWe4C5kXL^Bts-5ZlNq9mfaCy6Jgc~{XJ3Hjl)725#Z<+Rb2xkDyjp01HuAA!hHgQ z9o;;Q&8)Z^bj^cNvw@12O)%RGpbeNidVtIT%iwAvh^J|4PN5c{69q@&Z1H~pLu7?) z>|9_EU?zeF_AYfLd|+4)0z`RN&PJL*NIfg4pmIVTh(L6KoY~*FNi04*Don{NK(=6B zaeqPZm@v$Cuny)M23&lXbb&l`@?vsgo+SK4%&2wvmz$3+P@fGd+_(k0Y_kzpRn;4-9zI9PhbVi;Soz7!R?8N8pfV)Uc|6rw_LwZq3ShO)mB zd$%;;ypXXFWtfZrb41Ok(Ej4!h3uWOEm;;|3J(Y43}P$+{$j*7!0HhY4QoO8GXm;H zr60cm5*Y~r0g$q7p&un9=CK$7ML}bzmen@Whlj}vuo{*mlssx?B}pqQ18aLd8*42K zGc_Z`%4pwAA1hIN$5tpByMyPb2`w!4Wif>?euBTi)kAipuJZ$6Dv9-mSn+B)I4W(R zjlF@^7Ap-+J6%IB6Ps{5_f#9#WJ{+6x2@U1VddMxDtxx)I6J3o^(oluU+nCb>Fk=~ z?3(Cg8)<3i?`R(4%wZbfV&vy;;^$@J?`bTa-3)wu%mV$bLcL7`#1G8^T+DnOO?(_p zd~NhSZFD`XwOp;#9ZZ$2EwdWMeg zA6@J|IM+FJylr5*ao=cJLr-i*SwMISbn(=}^1RAjg_RA3m5rsfZB@;CDw{e>YFg;E zL?KLK?vBXhT$(x=7+b@tMh}Db93bkPp=@ch%e*@zAC-k7>>D!=uAD@P;RWhUZ2jU8 zOOu5s^t4&x1hA|ut``T7_|($P!!0a2GN+`lv8VOGEZt_&R$aLDdil{eE04av{QM_m zWR9G;dthXxZTIxfod;{G4(!=IGdQ#~I(Bht=H{`vyT?x4MrQWp(*4sb50@`}eD2B< zpQFJ_S7_VSJmw%C6=t}pb)auV z5uHl18~Vz74n^dbI|PS0g@k*C#nAIBJhhOU2pW@Fv@55yf#-yr3h|s-7N1@c5tkXf zJs}`8CUARHKzOuYSZqK<{I;n0gpB<3vf9S}(e5KB_8vXeaNtN;dtZEhnYF7AW&Btz z<{M`$0~1854tNNBMAypKE2^xtZO^_@u6=y=oP^2TIR!v*?g6z+XdN$KdAAjEzjz5V&=mw$f#%|Ac;?mwP>`|ppx{M+5Pzg&3!hvRoX z?mfN`Q&y(uV6RD=C=Yjg?*M&EZ#}ahQ=0@UhctbY2t(6AHBAfA>0ph5;u?7^1!YpC zCWa2q?&0Z0&Gb;7M|t)3vyqF}n#ab%b5b_zE3aC+YSkJV?!3Q>smPT4ZQEr#X27`% z(oMk^6z~}9jOc(gA5I3q8kmoflAg1Hr>|X9aYpMv|KhPzw~w5#lvWy41kOS)OIl?gvna8@^|sNg@)C{y3k5_#~# znwp-`k+CyNr*1#E^!&~3x8L3W{O9N2|LyVDf1y$P^Y8!j%H!`ZJ^11D<{@UKb$`G@yya=j#HQ4UcC3s%@@Did;9B+ z7eCOd?83vZmhXIa=GG@j06qHh*B3wi+o!+&&u{+Y@8A6QzrXy;zuo@kkMj>-4=&x@ zw{W?C@yfoF7rJMcnhsAR8tfApZ|3Ofn~8 z*<4iIRa<+gu3@yLZK|bXn#!P(^1THGt@(NN#l;;vs`l124DRX}t?!;}-gm62cXs#S zLf`mV1$yFIgT|M0}+v7^^#=kAXkxr&iFJhn1Aeg5FY*}<{1d-{%2=a`q@7`eSDGPEez zKP$*L&DSN~#eAEKX^5jyfR(npjh>sGo~u2Y!bbMChPE!o4h9NZ+Uu3HH>#lWZ>{4P z?w^vAQlFC0(9k$JJbmr>`9~*jJR4uS3SFmR|3G?0iJgy|qK4Ayjev$961ZfY#i4RRdIQ9Rd;q zlS`zuLU~A9wo_o3k+rMh7QMAtGG_25)T@l`d;$x0?XK!PoKxA2j%fS7iGi`jsrluyE6ijCSk#oJnr}vF6^^GkzbxjqP_9Uk4D%sJ?>qC=QrWPNK9Di_R z@!9P8FOFUO>crLWrZ0azdF88_Ti*^}d|7*FJ~*S?F(}%?#n;}=kAMP6Pe=|BiD8xK znAxi6TW(U*BTo%@%4%it!jr*qQq~kL4@BCLu4hV$U^2qXkxxNsL}N zrox}4C=7WJdV#80*g1pAKt%?1A%G%>3YD1d*akKpp^3TFVfn`wXj{0^@{%x0c<{er zGPs<=_u~sBDh@imh*rQpqD2=udUO>wNX-|>KSFrrehDX;-k{K*H^?)#l=e8f`O#Ze zK~W2-VLnal4&cL5Mni1<+*t~OHY(D!e65P1y7gAq=+flc!!boermi{q=8@P#Gh2TX zI}h4xekdo0Ch+fJwu1s~-1y!`xmBCw)hx^dQ&Q^(MK#j=K@#g!8YiF-o>cX>HvI2eQ(%DZcRWUaBHCs&;D-|UZc{!c6 zYn4}jxJk$yO7MlqcN6AOj6ey9983Vw&4fW_A7}K|ui5<32OF7WBBQ@fjxd!!6bWuo zF-lVaLNE~)aUVr;RsyRDNidH>OGoOuLO383%cV0igb+P*D*!rDx1xAKDrX?F7GW|< ztx8aJGz2lgz|h3XlF*yO*uv7t)Y5>a$wr1K&(K4Mdo3bu;j)Mw7LXiALl27E9r!B}%JgwIv9X~h zg}$7@aS5d4qEquJV~cG37M$$hepOB*+=k8s|b|FM2&_N zyvx2FZ$X44%xV;CRFo`TJwtIRQ;UQbnvc$5V|HaHuuN%FKQw7NIP5t%-L!W&zq&oM zq&}y#KBJ%pK5cS#1(G$u8U!Z5DTM3ngd)t5AO!}5hb+qD+wjeV_X1;9L6N)Q>L2W~ zH2}#(&{}T3kkEgB6(ncY1!I$It*VAMQ8ChYylqE&R2rS`pojK`5{@XwgvSKocbm6Z%}6Ga>1$fdZ|l)q*s~s1caI2Qf%0iWb=& za4Nz3V#g=uWwJAjGRwm=gTUmGf#+hSO9qNLvxz*bjt*)wdZrc-;0?{qKomhKVJ~3z zG5$dGaLVb8$LF&^L=%b43Lk9P07r;+541xiXA8v+l#+o0R|j5(^n%*~=E?e!;SyY_ zSO-jaDZY@+E?JN(dxkwFislFvfn_M>)H0wvjX49y+TCaC*1#Zd{{T-Pe;UXR!*L1m}3d4m7`)y==Ly~L8PS2qhv@WW)Yc6VH8A*Y8e8? zNeWPgauYgrqX>lHGb%T0Hv!0qFqX9_l>&i3zrS%k&EqIiQ!_LL?hqv>}esP;@26+E9=p5}(w~iS2-!jXCE@dLh9wl1&#sMZ3=2afe)Zc!c6vOE>-zsgW@Mu(o1gFg zR{8{4L@B#e))ew)le}WjsD6m$+qc(3A zya)*^!-C1^G0a2Y8qvQ`-@wS+%-GxlVJi#^WH4<@3mV_ks2$`7C!Y1p3{qlOxfrx)I?L0}T}mVupwc;r7lkUcM=T zL0SG=Q>@Jb%=Ne0nFTvoZ@04!F*ort)^j%3aWGc5G*UG)-C}O4Vq&IZVx?+ktzv4a zWNf2q#21=|T2Jh!LSJxAbhtKZ zXl>F|U$3UKNz*_{-%!QWMAOzp+rd!N!C1%L)L^TrfuE^Spou|{xp63momG^BRg{Hk zh>2li`z0wJ2T66rx!P6mo?J7h9eyXkFo|}nb`cwZ7Es4;n8kB z0Wb;SSX$Y-Qi&N95{rf#jSf-Nhbj{xy~i~m$OcJIdj|_UTYL$yIM{uHu`KZkC37uq z8`Df!17Ka;8dNVndSAqSkg_%_z<4Bc5tWjXQBqd0qdvE^KC_^XK1wB(ot3-x);8~N z>ly3lo9gVJ=^B{bbKv-%gD0E!&o=hWRJ0vTDr)eH$q9_lNhqw$tg0_-?kuU_L;Gxw z^5(Ac`u3ulrlP8*tm5j(lpOjkTG@NB;gZT?t_jYznBbxVn(UBmqbwy>glxwV-VddL z64VLiAap4KcVXWPfI`4Epft$9;hJG~@TDPz8rwVj#;3%URafmDhBYz1{BZ8Zo6`^e zu=4Z=dO)1I{s)4`L*tj*JC9aY^cCi`Wv0~bDCz2K9X~X*Fh068b>zbA?DZ21caG2B zSX`n3(A}k#2j?z5ya0LQ`tu9dpPsw&@uh3em(M?(U$`+ld-2HF>B0R|y={j&oBEsT zI;(axm6g?3?`*57+r6`~tG20kS8LzSrhRlSsA}v1p~}v!h)Kxa7MDTu+|K@yfsx~M zr;1G}_4JN1Hg?od(-GYsQ5GQBq25~xj6j@Z*DHKJDmW$R9+ZYd8XsXugprYmdDth( zUqv15LlUwWYZMIh4V}&Hwz&mn$K|(`b&TXRc1IUg`oyKVZjbegPKnMeP0Xv##2G88 zmySBR`r>pYWR%9F6hi&7AI@TxcAe ztlBdakyd1C=dPlr4P=0OECDit>C(p+uD?2eVqyL9W-wYzVS_PuiV)s@??uiSWf;mR{aW^O+G{K3ob zAHDhI$rpcq`Tc)_Haz+2Umkw(>#a|Jxb*sq#m7&EFRs)K^d(hRB=0ESo{^1SpSppI zj*;IMbvIQN+bt?)^rB^hCi$wcb_3*iO0vzU9`}nY+to{I{=%a#PTqYnbMwKWv*-F| zr;1yuJR^L;R#vTh?{{m&=EP*{=)15{-Z)ROKKEkQOyp%iGbGdeO7oAc7!OLKRZuTw`WJYg$}$Y(#B*L_>UZQ*3loc5Yw&?zy)9Gp&PX_fOwBdF9K6 z3!fifesTEdt%H--hi7h%&)u0hb$@2@;oQ=bOSivz{nfue|NOsQd-NT}fGfAZT)6aN zeDUt^iJQkSy`Vzs-WPv+{mXyrs#J^k!Mqhm^TmG=y{PMm6;K3&>7lDcb8S=aFHBg?xdFXpz6+iWjUwT)6X z4&J2Zv|iq5lbjZ15%ix>SVvi}vYMQRrW}m}%`J2spqkj3czf7~`MAYw56X_%Ru~yx zniOA~mfVmOSCtr16d#eB7+sQ@SecvCTu|IqRMuNi(o?o$puBphtnOf4&-Cu$Q=MbW z9b@NvXKoM9Kkb>g-8OWtec*Is=UiLQiMFoUj-I*QU2|>iv(3#jO-)AuxOP^L)YXjE z>^N9cK3G=RQ(3aNs-m~4_0X>712y&gd9JSAlay2x?3d_f7vf~;Yj5IVs%dMgW^Jr) zZKP&lqGq9|Xr!ZLXrXIsu4`*;WbbO@h5)$g202=;g7{hJnkPkMCPx%)-hunF;C0?WKC zb`1a-kr@NnNxdMu#>iIyrMk6O5y=({~SnRxLd{d-DtGLr+|IHo0(rX#7gw;7VijbU|r< zZfS3RWq;YO!@K)Wb?jZpqf29Gaez<8wvd9@*s7fD4(hq8Y9{Jh=39Hu?H#{8eB#;I z;wJ}>zZzTq!^sDKI`jCaJyR=*6|D~bv04@`rVcJ9_O?2vMj#usjYgM4PD5`KqI`lm zBg`wn6zpPsD+_oLq`wK(S!Vb@_^#5Z;L(b}hbzU&#NEZ!XG~b|j1>nP7;6$KNDBvd zEki5XE{niHxTn}Z<;|-48m7+dk8Oifc@4b*3E5gm41OYG z%P3ITU}8Z_T-1r7%82NUGJ$pP+-%?o@y>Oa0u4lgsS7|`3CU&7S>%hQyGfA33&K^g zpU|a4K@IU?1DDXi%(}dmseptwZSxo8aHO?i#BuBxT>78^r77xgU`G*Mc!M(Ot-ZUoH0NHVG$Hm*f}RZxng zyeeZx&PaIUl9UR&AGK7%Tj3_H-vCM|{z|wo43j7Zk_ANkiSTL!E+C=+36l|tV?;jy z;-K8{Lm7ntN+ET%BGSR$b-~v*&UqEFT;ZA}rY<($i8D!;ZjDc&BjSB|Qq+%3=+@iynw4_$yYE zY16D+1W8aDN2PWLoGagJY&;J;?he~vdU94OE_YZ zbC6GuP0Rt4*%m_srda>b2zWAd@C0fic3@-T1Z2?@BhM0M^P(6{)yU9+w`PJ6E_Fq;FbDYnYEh|}6%QIdjKxtBl| zgomI#U@~TwqIOA0%IF)5`>r7*q*PT^Nv4R;L8MkejoMgqTMs0mz?NZdz>_hwwgw-= z%{H~7TeqQ^rMZQzHEB><1VEutH#CG}L+ci-1glk`-*Rhc#)7g8_Y{YLl?iSGCPODg zlH;^b(lNC}gojgMX6Y0YzU6u zyPTbrDiVeZGK&&gbD98p1{M~~WMgY9fFp*Hw7ZwUY~^h0>_zMV{tUK^O_1SlOc*A%uqBMG#3&}B5JL^U1p#%44WPSpOxUa-*%qO7 zf)NpFYLb2k@wJdQ;g%yUWniRkXhGR2laEUmVF?cbp9nbx{wFvUz+a>)P#y!8ks463 zckoWJ(xvq!&|(R55V(*u_r$uBjKe!jhFC`0GWe~Sy3#|SaH2NpUEPg%zXU`8I0z_4 z0zh~{0vg-GC$FXLgr+XXYB{hnCC zOW;rVmDtevI_dH5e8e}3WyK+T!4d|GksY%0(#?-sjs`3#ykL@k#pR} zT96)Ggjn^`Lw26rGJeZDdD}l;^G`0C8!Gz**>6QSiEZX9M1otSS@{?~jr+@O<-Uu6 zQ{t)0>_0{i$dNURqs|L)NZl#%DF7jPW=~@TSgqjgB-cgWK_cw2*HBUomJ7~rXl9Bv zf-QsfFtD-FFfkDw#~4U#5RL#dkb4K}CNB!Xuqv|sMWA8QL!<^IP?Y(PG8vVgaO{!c zQdqNzT(cTY9ZfBLTs$It{SpHF6P@h?b=9rtvtXueZ=i0iqiU+5q^F^% zts$?jC8w^nQGhDs`}8-e=xtEeU9ZGpuu+Y}SYFdqLEB78%Se8U9!(rkqF67-JGC~b zYOPh)_(*ZfhnrMauiNs`I+Zo+X!@(XR*r-A_Jlt=n>BS5b@WsXIrO)f>TB2<={Otd zdl=}t8|r#lnEDy(x}h$pr)8_T#X?)nT2I^2)X2x&G|<5=!qqv}#VOX!G0xs1!rnaA z!>!QQZ>O(cZP2!+u*l}f_}19u-6`4qsRajtyuK0sow)puD<>(#Dwbri7B_q~cZ>GHJza86{Lwv}P7J!B0TABa=2a zMLV;~n-ZbQWS7&1$tx@ptr#nNCrm#`vc03Hr+1KFK!n6ti1FVZ6BLz5>m_F&KPx9E zwh3^1Wp&a$3IH;aIbo;5Ug79TfQ&TF05M?5P!6+h_3uzn7ukGuEi*^g!07mt!eYey z(+YQF6iR%F;>Ntv=JK6g)eZaV+Xh>^##(zOdJip#DhY07G0F@YOHwQf>47bj9sGnB(zOT@ny{6^jeQ@822})U4Q$+~s%qxs<`h$Hy0ErdLkPT|IjI^32?o#ictd7apx#d~oUNW8_WFUw(4_%ExCfJ~(sk z{@nak=rMx_j&^q*>S*q3YuHy=+K60CZCyuwV^>2c@?pLoMBhTe?Ps)^S5O zrD5c@khn=HpjXv_!6S2f`p5H18+`&|t*kwDbxh%l3KtbJJc~=_PsqqZL_(6TCax7b z1?B-;#la8xC-)h9A`YBY!5W1s^B&c!_$VY-6gR1E*8nG0K;W%~v!I_JXmM%V~Qf%eMOAc@tFq!N3KfQeW zHGtU4m1pNJKBj!>%B@c%SmuZ4U;LG(b}L3jUyw8mDPHLOJ+_gnl_u{43IKlK;Q-9sgfy&jHJAA6PS#p8R%wGZOg#asq4$P zUM}Bzb@JZxg?o=r-@9}C+Qq>WlcmiyHa?CYDy&eN**nImT|^c|Zo zX>Icl3Dwlp#FXR7VCpw+{Ad&6GID}tAo9p`Taw?PsG_8}g*2EdSzVODyu-HV*Y4~+ zGJfLfjZ05oo&Wd^(#Kbxe!YD2?ZV2_>A8DDhcE2uKH1PXQ@3lnH19x8QfFp#Q*v-+ zq*qRmQ$m68wE~^YVLY zn#St8j&=?$?K^U1c=rB@bDx~Q_09bGSL4U;9h$yAGIMqG*tLn-8;6cuI52W{;mo7u z3op)H{N(JVx2QJFEq^?E{6^Q{>D>dT4$j;>dF9QyyMMUx;-?$0e!2Db*N?yX_fP-) z|Ni0M{{HoU|NF;3|L5}auZNZ|(UrSk_ukCruA;6(H3yG%9=o___EN*>$(o_r%KoYB z=Ao$4E|=IUWxL3abUc2qWW8#&+N$?AtomRL?u&3{@ZjI4R2f(I_p5)8;=iKYIyFrd z69X-F1bZ_>Hw#m5OOpU=(_jaSP)9R=7j&L2ygY0Iy_~mib&n13NeTAL^!H8=+?o{} zR1g+lS<`-`f9lHEnMcR3emZjMY2*HLC5_XStrJzvV`UYC>1nONJ7K|v;UPs)p=I0s zi$Z-1!u^VZy|RPcGeSMmgWXa?JW{v&W+ugy?yTvls_sVgr=jIQTj#)zswULPZ7f{O z^{w<(^mXL5wdJ(bH>n$H7{PH@*{G_ri8H5y!q|{5%ji$)n*iS_BT1;NVrOoX5|i%d zvfax%+}9yKEVv-QxT~Y@_`vj8ByRQ}r!0%Q>Tyg(LVBuJD5;qOY?mBLO7RtbiN*)Hh=zlZ4&lo}cu8QFP7W(8$bMi;lm zmUaXtRJsLcc>1TsrS4#ZLrjb)uWHYD=g3NJ&wTcdL+Qo)3n~Y)N_(=)_7znR<`(UZ zjjs>zEeZ}U4GFJ^&upn|m}u-gkyEgDdsu~+OM;_WsE2KoziX18dvb_het5`^@bKE` zq_+IZk=^?*^c}v_)OD%4eWh{#)v@Kb=b!!4v1_ku_ZEmA)i9X zBg16y71{4(Srh)pL0l=sT{qBO6x~xgcbgMiakGf>SpMJ`A}AA)zR)p{0XTXFR&L(G z1YnR!@a8Ze;!Y7wkkq5ID}swOve~Rc?a~$#7yIC}^xC21%0Z89RmL`P>*dYXZPr)N zw1UH9NGh^O6i<9w)o)9!*BoP{@4F<`Nf~6&%fDo`0CEq`P`D>=!8z6 zfGSsyB7eUMXPY!9(>O={?FMr8>K|%vS*@!0k)p~*bzOA}Lw#p`JttKa^NkxdK3pwN z9#5*U6>_Y&np_Uh2)ly-2617rcWZ^VFx$UK*B}z`dol627RH&FMCKT<`?I@|iy`Jk zPZCIx0TDbJ_8O_}j$rbG$tWqKULrD;f;ofsmJm8dHI#NaP?dxfkDOr3fNaaM#t_cI zXAo%ww4p<>j=8C!rG>eTE!uY$7It7VxX@&~SQIjU7?++&!5t93I(i6#RW8buSRJyT zh%x(qTbYzmoB(eyF()EEgXT4YBoiD4CWA1G3^Ngtmmryl zP)kfXD#16dBUfYY;T@2Wj*?7bVSRF8Lvntdz+_5WvMSrlTl;D{2RnzRx(`k^b`O@- zb>&tx!;?uZtclO6NXo7Nld-jTN6Liofzh>dvNbX{1$MwA;k$?;`A!)oBcdW1ay18QHj**?SmS+ffQc=@YeVhQ`MFMg~|9D|EbO%m%mG3mG7-}W zxe?-Su1IKTOH>)jyI>;WNs)OcS%<}Dw#%lCaFQ8cDK{s>WQ3_^*0CH|3t%X!Tfp?x z^z>*oC4eJ)J75`-w(5GC$m;?`%Ohv4r9~c-12l<_PE;;Y@~N(+4+oFnk+ooM<)p1^ zj(P@WL@Xphco6v@Yzll50BWqF>|nsfnBxvf^{~u+%31ILWkEU)i#D}dI)F0zdV()w zj@UBvekYHu?tY=ZA<;e|(Uwl$hE~p4QK9-}W=oj>^gsG@>*!fn+qpTp_&U1y7@AmO z%`g_s6Pab;>jV%g#BARe(*v^ET6TMOB|1+Dy&F!P3Bbq*=UEEPMI0e+$GSD}8Pw7A zFyh9c$3?3)0qzk>eAO^(FVqf4Z z`4v-<$8S^_UN9%Y4#Z-VJp}0R?xh5ch-={x#25*a;hBRQEkFqrL^jH=Roa3)G<}d) zQMp3p6sWJ5U{WU|B#q@1U_D7XLPFq$UjZp_GMo}8CiXRc!X#lIVf*H)#EKCQPC~|Q zW3>wRNir8a^WZHUva{r$oQXIY>0Wb10=1AG588Rb-W!?=A%U9ZhCA%ug*^vBX*rY+0VKR&fMnHC8(_~k{NOST$q_Y-w zK=w~z7G&>{N|uDF`3;kijW)&{dnNn%KR%7W)m8LVH*0Dt(E>qBbQzRaR^_zT$t$ehph0~nSjvYR zR6bbGv1N@Mhbjn<1g&VxsqzMm4f1Mh)@!U;ul6Ab%zE`Ta%vxLR{db3()()_e*cl; zhpUy=tdU={R&Mp$&9tZ5qzKxht$_BizMh()ma4wy76Tnk3vEpsU2R8QT~~b_S8Yvu zJ#B01E!B|pSJl;4rxTv7v7xJ(iI<&Cpo`OXI~#u!Jy%0*7jr{@Cx=8AmrM`$JRhIJ zz@VbwZN-t%HE~Hz(XmYt39XT7y-DRqvKmg*3|!wm^|W*Lb=$Gmb<@wAj=$_Y^J&lW zXO$z@iu#sH_bpZoE@ZVGjxXH`-9>3I&2G|iQS+!s$)oLc zF&i%3ntURnUHk*BUEE35(16$mSjOJf-OUdzegDAlfZ#}KN&L5kLjtsNum_OgMgyP< z&jc);Nh9(O*aZ=%%MM|^KV0?E2dmb8_}+%KAJ9dCypOJlxhv(J>A5*oJ5!1((u%8+ z@+z{*>ZSd+0k#a7%+98Mv}N{>oH{spacKJL{>hsMk3Sqd@o41qv$3TohZpbAgr#G6 zzGLJ>(}9`J!;4LQvpe@pRCbIMx9-ob>m>Hy8lP_GzfIlTZk?j$`)lMtcbTbJ2`0Sc z@(atrG!qL)I+*r6SS)N(Y*1oW|E6%u&v~0zDeM3gF#)^ck15J4(&*0FEiAL3cz1v6 z_`<<+_m19tbLQcbCzt#C zC->|**xb+yH)dy5`_5e*lquD<^fvF_-_dihqi-0!oz}kb*52{vJ;S?N`Vm9UEUJ!9 z%mdS))%f7?Q-^0x)pzvKQQE=9&&bpYoi|jy;qu~J2$&RprXa-#gCH`4Qi-mxEAJp* zVWq`uX+Rha4pyreG~NnRa`k&KE?`)Y^i|rVrlDqKWaw?@oS2xiyLWVD@6_3i*qmxR_h2=;!77Uek(gTyk?@z-d_)nJiu`76bsaNv$7Dds z&V#*!Q=>=EP`d;sGq-%_#M!$7kh%2n*~^d5Uw?k?`tvLI-cq7+|MtoE|MljF|N8PT|Lf(?|NiKkUx8(=efrgfm!Hl* zcszRXYSsP$yTEPgrq+}L5VKHCEwN5$L`v(6kLb3!MSin^rk=Hhdvt7mNAKwIvp23h zczyZdCrh`VpL_WF;^SB69z8z)_|f>;Q_Y9^0@Gs^Ote>RLa}WX2aVd_akrR?g4swq zPzdO-%V4;frQAoZ9au(RQPoP*#M8_>E->F5WYnrYuIZ%?>m7mxS4wDdA8S7aTW|tOZ8ttyJ)kVYAMaRX* z($~i}(BEyFzgwukTadqVK&adH5a;kfr?4Q`sI3m+t`>oIM!wEgArag2^NTy`Iu7*= zFVMhfWbQgWrl}&CIrC(0<@w~vhhr!1(A#M2__gVi*N-mV7@xT?ID889Y5)GyqobFO z&fZ>JegGlr;E|Q?{U?W~ZY-RAdGf;RrE8y`z4g_Fd$d3M;nwqCAAIq*7eD=vXFvbn zPk;U&_rL$koo|16`2AlW{rE4}|L{*^m!Ixmyw@{-t9$-h$L#s~k%j8P;}!eo@;fIh z_8za=d$er#VVGK_9Xcb794h=)N znoPN_vb>R|f|<6WiLRmnC1ys-x~6I-CR*lZS~ie5Ep?r(4Lw|KLfxFB{6cf;yQfAL z?jJq>a^=B~r>=dqd*FQjj-lqB*_!&Hl%!ojUK#Ed+Z>I29SpZR8u~jJ_}S=q+i1Dl z>$ux$xjN{2I2(9-SonL}(j%&97h0NS%~^T7YU+Es4~!3tOzo&`^x7JrMb?&f7bvfP zv{_Y7MFT;|&5Fz?L>(!*C&!|#YwE;(vvDLY(A3dFa={h-7H@wVuUl%_I~#39dB)2< zE`=fJ8r?s&czEIL;Ox@>X6ik_qRO_k|Gs_AiJYr|A{9C3oP*>bIjA5giUf&*f&owz zkRVw^P(i_fS{`9I;#ojdc)f99KS`upuuc0W_kdCCHds&n?)d+oK} z^{#hyO-wiU^lomb2~UZWS(5{A1R3)1qNs&*dVQZb0O zzmG?zlVzBl%!?vrS2JICt3XftFmIQ*K>zIclpUMOdTSdei?BfVi0Yc1r!P`k;Ry-RNlDRhI4Wyhy@Qla zo-pL;nnZsSmN5PgJ|WgsWlq_o*mCfQ$XEf7KwLwih3$u5G8$m8$Q{tVTAwZqa%*)h zBeW493KCN4E9@*>Le^%NwvW#BOyAs8cfi>v3e5!K1hG3yU<_l9gDUxhxT?PbHB8TU`T-9X--Ps@Lc#Rv9QXEN#twfyc|`5oK!{XsPRB ztZt^eLRVkS0GH3g!c}SQZ({19qoZ8DTyNP@4d^ix-GV-eiv{sxAay91rwCr8SA=g4 zWn$$j_A>^AVdWpjSGBwG8{r3#lqXanBSU+45;5>&#TX#KzD(62mn-E%1l~evzf{!E zSV6_X-y|Lf=%CV*h?rI~sI8KZf{(#4iqMG+vlwhcTC<22Jl0Buy^V#F1Fo{Yle@dS zFWF4QqKS$*9~G#gx_2xP0#Y$mC}EI9c<_)3cEs!k;iM}>#HJAc82c#o?P2hvPz z)}&vV4a9bku(0!pYRDD(1_B_W{WiUU?A+Y!Jw55*ur@stOlECbesW$3mBpFs%kl~< z))(){+OU0H&gOMF#qeYxQAfqo7$PAgEEYhC5E^e#`DU`=Uj?ds*JP+EZo2nsKE`F}lFDg2TU*u>7xEhq%HmQDc(uHwF-2P=X? z216=wVmc60aL&TutXRRllNlT11A7Jr0D$Pp42g?XVU!4~Bus{w2k}yZQ_y3OQf7;Y znpg&e)gXTK3)VqmNC%7#;seoMXl3sLCIjrC(vK1yRd`5pi%bbb+|=}pEuDM- zQI#%!_HO>P$wqe(t_LzQJb)K)xxp5kJv{B)y%3y%4QS=)fgmu18Eq5MFa_vi3As;= zHKI_I&eW2p3iFNkC>;R$9ATuWBVEGe=ftJ(?cG!%`V}=C;(>YQAi^b}L#ddL0u2x~ z6cPo3XTc*Ai$J^(uMyytN=N`zsCqz31;UuQ4Ha;Zd<3h<($P**DwgXh6nf^C;K?YH zE0p#ombSL;elC8YhH^_01nL_h@N4hrEt4x@r(kMC_MY>Qx+=58P%_~wcq3Mkn~oV| zv^h6nCnZKN|I5J%17#Z-%h;_<74*3>v$nQ|5=_w+x4_QXhYC}V!052}jF8xMULmoL z-k~617-YI~J2-hEqpGW8j0U&0tt$=4Ts{44D4q}!VUp@8=%3VLo}13lL5~pxahhY$ zjSazDyeJ8&6Z3%wgDJVwLVA%sRbN*NDxbL$*)9VU3slh6s5M7zMrb@B%Df80z!X+R z_gGU_D(gs~#nkxHQv^L0APA{(Gm)|g`6YBnwW0+HN6beM6S1*!0t^dy2=5oKIa>+h zP(8mxWcWwGGXiR0hX3zhir>Sg5!=Jk_m{6)4CpK~r8hd53{VvFoP+sKNI-0bUI2>C z+!2wWM`T7r4IGI#@V#I%lBE)W60nT8SwvP##cEYyFVegd64S!uN|+4)r5XXwN_Bb| z5HU+tpeRt7NDxSLK`Ai7m~+V@8!HVUh8-M6r7a@?dV;gW$?*B_&SfG@r75drq z+WM8iYDBv&-UjI%3~bdZU{wPH1N!e^(^wA1CUUS!+W(1CCJI#TY?+g69|Ful*5lWU z$f~okFkCn!EHqIxCzQ&>wR75>A?FQLMS23ufT`s3`8-iJMUxS20}~P>`U+Ep9r`E1 z;fXYALCw{|(ur&l1r!2Zg+xa6Ir#}*fSxT|2~9_fczVeS%|**}m#u<~t-DH-Muxg; zXwqPaJf;yH%s_vZEYV!FM0?3Hou$jQ7B5$Sf0^bY@h6D%X)Im3W(k6EE2vn69Y@ik z2tReqAQ4UUB!iq0GK2Yee$ zxXAZ_j|$r@z)(!YyE_OyMgr}{dX(%2#sP!R+7xC7!Z~(S+8Ts6zL*=mgaRn4^jT2) z8m8u^p02J*@hO$t>ic*12mozM^C3hzgjZG!7FUUQ;FhY!;)=TUo69qqjqBE@Wl^zS zmb1Q`Rw-aIY5AMzv6V@MLUvhhVO?QG+n(N2hbQLA0`J(@7oM1BX6<2MWUj@M2MXdr zK^eQ7kOW^zTAvmd&aS>in|HJvINCKZH9B>1;>`6EXKzf=1sgQx=CgCx9wXg@y6>fh zm*~k*tb~RP@XO_e*XOUkn4N!q;mQkOnTwa%S+Xr9$;r3_0z5M3$b1y&Yp1WAswA(c@YL&h|do(@_=27TN!z^C59MMJt z4Gk-Wxu<(@Ztk`tL#NJNe{kdBhu81Fx{RRB!?)L-enP{bD^Fitc>Hwo*7c(oryBe<9Z1T~M)Xg}EYLJdOSFB&ms?K!LX!uDk&&f| zp`|&9dT3H&-nQ+{NBRcO&Y!vc_{x*F=kLCmx%T1M^uzYUvsIOS1sP2_aaCzSo05Ik zuXV`?vQF?c4)HSZ_tN!tT5a#JN@=fdL0PDewTHj6f4F~CBu`ja27KK?|t>B4}SOeSAY1A=Rf{^{=*+8 z?|d;s9o9#Gxcu?&uYU5!>!1GR;cx!q#qa;;^`CzF;;%n_`>#KJ3(e;5KYjIY|HJX+ zzyHrCfBmn=Km31pKL7sG^G}XlzIS-?T;1XRyz<($83i7}(Z)*W73xOszpwe;dux!_ zQeUR2L-4vr8$JPtTvKMMr7+W@TdJFrb%4Kb(z?9rBNNw;UwSo)ahrWUa_Uh>&!yVN zk@n7$+spSy1?PC%MA+*)DK)JXE6t5pC={zLOjl86Yhk5jVX0|uu3@Isv2rwZ^+5P0 zud=3ke_`Q{_#}aOHn;bWo;<(5yDzt>(B4j|Lkk5O8bRU`-A{4oSBa^F$GuWb6f+oG zQK*8#Hj$c(mnZf=FeuE`-GjzP3Qbd`w$e`K;%pNb9Fk7^^R}MjM~=-7&)gWBLtEzb zo`L@2oi(8;vHIqwg!!xlqEX>ALeP+s%h(Z>4~9v>@(2s0swH7x`Q?GbDzcxP(XXKZ zFj3Ku@(zrNO5GHjU7c6nwWVP^yXbIebfte_iJNzUvv00d93&K zD{*v4b8<{@^+SHx5)72ACQKc=}|n-_o&T=ZUne7BBC7N1JG4Z97v< z3rj5v2GBy!(#nVow@+kPR!&}HUcsJ}r0PK5LVwSaK;P{VkuBL9Xq$EI(DCOp_kKJ3 z=$oP01&V6DqGLg_yhFkx6H_Uj2u(;L-{Bh)PH~5$v$w+BQBQ77e%8p`mc}ST(vjAa z^d7=-#_Pe=()f#N1L+!i%e^oM6gFB3}_H(Ipl%9Q#tCGBpPP}H(Y9bp+Q znU#ZYbX@K>(iX$B52;zUvh_DKFvmRNcS(j_WZlG;hZ~Mm6>xT2%$E}6_!88Amh14;W)1{F}Y7+BgF*gGkM!!s)D_l!;-IeY8G%{Qm6zdky3Z%^lZ zUGsGD*52&AeerSCq5hjZEE1jMk>&;g*5+Z}ZmDjL@zjPZO*}1)>`ipdjSb99O{|r6 zp7t)m7B+$UGN+X!(-y1IZ$mh|5??~Nk)#3%fi=}}CUH?1VSH`LCtoF|9}`bP4^)#- zc%ITPMM%P~Ck6;Fl!gWT=$kGpUUt79cjHs6>eIP4ugom_lKijnr>(>Sqr zo3E5+#ljPizKgclTtsWvcOeoJL&RdzPR(fp$bi`6)38ko&xWuL5QgxXh)L265x4;@ zj*Ude4JvmKIRP@_S_oayS*3{stm&wf^w^9%BxPt`Km{@RkwS`z;K^**o{?9ICkZA4 zPljw=SX7*UU?i9fUNI1dSm2Ty&sPJ;=$k97ef=V`^3%3d=9Y_o6IsPg>4gnE=WX3x zRJ9+TGd!7JFqvI#eHj1kb**IUIKX7!&<2IXQC!EQgs9Ih4~Ymi5zHb)c+jzgLGkXc zNr8>Pqn0jV4kL)=><=f+M`3Bp++|@&4h#2K;?=wl1y$^&gkRGBxlDv>+$uvOR52Y~ zq2kz*S%xf17%0Ls%I4q(;=>bAZh{i+}NP+0gMua4yGu%WGS+mmNLBM zM$&2FJ$T)$ak0!**di#0w9L6F?5@}hZXb~~n+O(z_p9ui3OZ0>FDl!}B2{5Byx=!H zRR1eJmIHZtwB44ir1PDIp&&Q`zc6D22m&U#Z29}Bo~wz1CSHKe;fRU}BWcDmc~}?X za)jQFsIN(lulAytVEUJW4R~{i@<7B z+a-77=h|o1A{Q>UDh(mH%^?vNg}^=^&V3OZsHC6F^5fvsct594RLJ_}5_m0a0R~fL z5hQR)oUQbAs%J4=(pPhaszFoj9jeRW{KY0B-JoB97xB~2$P#~rg;bepE{=~9pCi!& z-hDD938Jr@z}r*-7M}yyLgJfdd4yX02u}uBMn(BUAWMbP{DR2{s+*R!o`C^CF2Dna zk<5@D9c+Uzh`<=3;VB%Qp%#en0jia#E|p{|aTM6mVKrl>)K_!wMCGZ3L~;HcY@kdt z0emsC$UoCT+t7#ur7Ru@r+@=#cMDU`luwto7i4lA`xwe@Y4jv=lAsrKGU_8v)2o{3K0abCe`;fb3f$j*SS6WMmbt%PypsbZl~NL_$VrLRwHlvUk*4 z-^jHd!QnK!arg1}^7eOi^Kx=_cXV=daB_BWbGNm30B|-oHN{mEfQ-b@W9EvDMWmXr zAwmTg=UEUZ76aVDo%pr->g6O2D5OPZEq`-)P3z&R*3QlK`!`nYE+}sTGT2bnym3bh zs%|tu++K5_s{RlMx(7R(hjug!l-G=G+}g8od+)~b?yU_+>)Iyv^vvw-J;SlDckW>S zrH-Rl4-MWtG_ufh@*Z+7C$4?ieR5%7<{lBvzP_`F?q-$N`6s5!oZJ^_=`hzt^}1y1 zgt5YCkRp@NNah=xlnRppmchMYRkDhCk1zrR6YLAPFLsXJu_^gAyY`OF9KCRF>h9Zf z&we}iu$>w!J4iy&)m2DBL|Y*gh=K&Ogx3H_9iXAY@}2Dm z1`hX3^o`EY2I$zSYm;+#PMy0;8z9jM=*p9siw~xeV?BLy;>6YdzUjjq#}4ctY;HPS zS=n4(-dI)LTt~4|ODBO2gsj?bNc^z!trM>O7zU03Yt5oTs#FPii*)sc1=Sv&ev3NwN+5!PFn2m*g;G#DAl zuj7}(<&!WOp2eG`6)Fvy@Ee%`I5sR300BZg(wC-&cHSNd(Xl1#3hIjM4p$!-uIU`E zJv_9jVSi?64T?Znn=99CEX^%0%P%fV$=aBbz5zfccSA+i`ttOGE$GQ4XXjJ5zAm#Q zZCz()?P5$y~bm>deI# zr)M9}U3?BEGduTS{?fCH5;$}H)~7e`e(~(hA76d*&q)5#l=;=~|LyU2|M=jWKP`Om z{pF9oIP>hoBj@JJ+S@(jW0o80l19PoGtQt@+Dn(~tyrbd)pxMA4GoFiTE6r2xocPM zKDqJWgG)D_OmfF37f#OJyK?uV2QR;U{Pw#$AAf%R&8ztjpC7+_eb2;Tc72&+q^|}F zz-xff-@_Xh4!MwL7kp7+;-!5V154{los}z%HMEcd^iq1q1!Qi{Zvw2?yMOXf*V#jT zXFEn_`%lmJotQ2xFL&^8$9u$~5^^8-81U|82HIvaT`LnrUW1b2bGMh(9y;7HaccC! z!kN3T<{y1}`Qc}CH{bM)T;92BtZ4ndtoX{Lpbb$@iGe18zDC~eI?i@$l-8>i)+^*z zOZ3c_=vu7Mr(D#|$jr^g$;ZPlz(0Z`&^I{PCpg4AG|VR=)Hfo~D?Gq0%*Q1(z;|tG zYT@RJT`h+Py2fV4&R(0If5E+*5IiJV`raDUHoWj{`J(w4=&#N z`1IVp{-bAiHw={IH*d_SZ?5SZADzEA|77CS!ob*N1aHSrKOQ|Ls-I@Be|75O=hK&H zL;t%=cfX&z_3iZaZ%*H&G1KQ~9(*=;_p@^kzdZZki_>>MKlkXja}U3pfBqxK^$-6v z|MbW6kA64*^pBT5`17rg|LN|>|9Jo7e|Y%$U!Q*c_g6ps*T;YQ>Fr;BdineRdGY;! zefYco`{K9%=l&OeqvzC%-~98d-~7{yum5!A*_(kg^EItK;i}dH|Z_p@hnW zp%JuiLtTm)EX>TD9h^eeCU2rY?9`Rl;}>5IPCxFSxIK9McI$!Zn%drmy3TdUMPBy7 zXrq~|)R*%Ci#7F@Xz4D41*)siGFE8I43H{rUwQl zm2BO8WN@bM*mUL2U13q73WbrDIDXwc^mFov zPRrct=aXop@2D_xS6T#yL>F$Z>@C>TXA$eEcSV-wapV7;{5EOT%D0^EhX_{Ft@73b%|`?LN<5eCGc5_dfqe)<|`GSH!v; zC%+IU-#}FHy}}|W34t#mGqNx;w9wWz)zYCEu9D8LWQ3^35`qbIuV4w|ZZBUXB>Ye( z($ZR`rAzf78C6tt1ZaZ+Ua_3$!_LbKDF!eZcrrxkcq@38_#_}99^vtMWxI}?xYpKx zacxSuQt6|oX@qDum=+Wf96yz-jQ5DO5bm##w1*3ga6R?@bc!}HwskhLwgr{}RZyj# zaogDOp~doy913*@1i5}8(V{MRl{#Ndu3VhCl*T3IgK1-I>#p>TiOjDpX_-hbAGGq@ zU|_da;Tq){nh=(eTe7#Ud-l@wgEz;nzUZ8MP=DxrN!3t6;o;Pz-6_#^QGS~OT{1kB zu`XtzPBJei6HhxcF9+)YPuEx%he$JH3d4QmMve-Fi-nE1(lN-|ImFc3N5_cB4sj<# z^dF>4dsnu@_ALrYG|}ym{B86^NDAV{^H{l(AyplW3_(2(vOufQ%;3Q;C*lIJ6|y#{ zR|1M*oxmrARm43KGkzjpZCnTp?Hpav!NBJwTH!=gJFjrs2~t-v)FK|{1@aWXaAr7h zaS2i&K&=p40}&9HOt4JxDHdLoph~jR@HYtd@zV7GWQ@@3K#C1g6x*igSs*vFq>rS# zZ%}Y_Vq{WATxNdyhAp&9-~bq*BQ{$z;7nRhX=3^&dIzZbE(M3j_yvYJIl3a_1|~xs z$Z0dkkOxd`l^zk{05S=i%Cak(vbHwmlr(1*HYQ|NB(J6eV826 zF?<{7eC4&R^j*r^T$@+CBQt+XaBv(D9L#L$bH%wL9Ij&kf<(E!o3{_h449b6-Ag51 zGy+C>0Yt(j$S)vvEz8i<%8s}|@D?Pc4(=?sS4;%ld&vLb!Gvr4x0H70J|g%dGp3a_ zV1^THQur-M1~K5=0-%_8As(O?F&(TYfH)}>WmX6Pna+>2mDYnjrE8|NwsCQB@bGYQ z_W(f>w-t0+Rfi(+OhjMuHOo=DM(-MN1@va^U41B-;T};yL~3=P!b~pJqrnRGe>tDcYg~TSI*MF+?LjF z6b`8}y>3z%pc6ftN|z5Rh}w7aL|5%>>z-maSH&WLvPN1Y2*pK&dIYeaAu(zfoZ_ zQf`tSQk1>`=1?3;iIn(?ce}p?gY(_YE|n=3qbKM(qH0Nn5rG=;Au7LDi~uF#l8NTz zd7;9!n6#V*mKm>Dnl|(|gf}HbdsIM~xI98SsaT9R3f`kCRm7T*@K{xT6Vt#~NTHvY zgsQRPi#QlA4u)Fw?buz_s0x4Pe?6E3s<(+)j)1=Q4FpIcjKkLj$n2hQU zvgy3TWCZZ0+NnkDl8^w*ko zNIV3OO&zRL3)+g23|nF4>TYNynIp*vNGB-v7D8PXJJL@C7u+vlCHXq3GD2lE1d=Rt z&e=C~n9NKJj1P=ZZ6jm4+fyFs6Bvaq6UZn18Np;gAO(|6X!(eTYUWegz|Y(@Dd&dS zP!px?RQ|3Jjip#1n0GFLjT^|9Zxl|cIE0B-J@}Cm!AkIfB&3*%P`PxCErGVt6$E&p zwThvMqs-h@ZsjgldK+2!>d4)-3>`G}EotEgNtH4#V{b>LJn}#>- zIFh%yt)%J*+6%ior(x6_yY%4b?6n;SyFJ$?u9BPnYPEp7p?QII1A1fAFa@j{fk4s* zdbzmo94sOhFK)0(n@h)p4#xh`xg}d$dk#-u9l!O#sr#SKzxZM1?$?voK0A8y$${Q0 zJ9nShxM5%7+R`BRG%xEgFLPgag|ml+Q?P45a&$`3`mMWm9o*N}f2jAw!0~ezjJu-5#Yvg3-@KjshX!D_--3O^!+6~VnIde;5*4Bph;pv4J4?g|&`26kC`i`iC z4R-dv2;H;S6M{oA6o!Xeh`TO!W|2VT!Z8FmqLe1#uM5M@I7m4Q)&eF}^_utdPX3T_ zv=&qj0{xdiF&RnhQ9L@zbD&C&7 zzGU5olB~i~x+(w0 z+0G{as0g{0Ijm!x3S1gk&_>o)?h&DJ>tR$hwT_Gqp1*iv;qL5{4`=SZnYsOX?#|n> zv-kHLo}{60QquNNe+U~ft}-829Y=>X=GM!MEEnrqEY&qxqHg@_RffM_#vxm_nkdx9 z+``q#1*F#}Ak;4~($_cG*E=vIAPjIu)JO(IdbdpU*vYPm+5VHF zRTe1avFV$XDUF_9=pDb-J$_^0*R!3!;&ms`88 z9PGW(HF&43=Xyuq&BFtCJI5X!9(&q3`lNUA)scypLo;trUHbwa&V!Ht{PuVM|5yL? zKi~cPPhb7ZPn5h}eDqQ4&_r5snQKTm*$Nto;<_s=Y$#^8cMl1RM-%11!I2Bc=buCW zgFiqO=kb$w>gxORv#OKU=DFDVm>XD`Xvhp!uGV^gF&s`jW(`VlHT11aEDW`DwO6gC zc2BM+GdHyf3W_b;-c(dlyP>cqHD#l#b67%bQQgk&{$sQC`#Z8XZgBT=H#RZCIpM+5 zW*Lc1509Jdn6?3B@9w@4VR7kllfhiL!(@1?P_f=*EKLy)0C~zL{!Z|;T9f{ zQdQZCnDD;#<2^%jqchjWE?i^sbWWY9-oGz2FZub#O6$<2@daOK69hsV!k7HxMAigNJwr*y)?&JlVKWHgP{`f95U zR;!Uiw=uJH(9qT=!zeUK$ndJs^Nf@aI>zeoF7R;R^P`PKBipZJJ?2ml9VV0&+0 zEn_od3nybU2XtWYhY4W-2aK$2LsN4r_wx8Yt^HN9K9=gv7U~Y>>Nb`-R!T!_CcLXtkh^OnicF@) z?$D2ojNPp4f^A(Q6xROwCa&swR!FB~ya*ui@qY1j*{z7_1eBzqMJf&R$RSP@Qwaot zg09qw8_NkYgOkmH2d%L0}WjmCkB9G z!qt}?dl5Vu$;jh#2W93~RD^+y2pJk;Oq3_I)hG)!RLFp02=vVDZOrVfQI#QdrGYPp zxs@$N7f6oaYvHxBF!@6k0!u@{0usML_$1I=Rk>Z_<)wl)DX3`Z0P`e4G4Pq83ZN2% z+N!>ZOiwN&#-!DkP_{wGRYwa}4<{^EBcUI@+^W_1s3@O6f`S0UQlYa$Qtn2Sev{Gl z&D{hsCNXm(Qv56;Fqwq(!l;Cdn8ft(==i{pNC!t(($Ziuz#Amff%g?ob^-BmvFkS? z@}E)Om{Z=euBa|OuQpm?Lyf`ZqoFqt(dElF+}28uZk)Je!p8&G6$M0BjHCqfA-LNwK&=Xpnjg{LHY zhDO4{AeH*gr6*{Xa@nx*SrT9}GzP|>AYym-6RI&=C?0cgwXm>7AxfljC4afpD}ZTr#z=p}RC`IFNrzi-?yQKMt+}2Tp|EDiVUk?qFoF z1egf^7r#XWJOo~H87vgMW#%4Bf(au+%SG>Vz2H&5EGsOS_)(gc#KN!?SbD%CdNMf$ zR)7*_j?PF8!xhmoFh-xm+{wcwAPh^WwD&;q#)0NXUj7JV3Cb3bg*5Y7&MZ~N9Fqvl zB9In7%~Zi91Iq}08gxElH=#KrDw_!Xn9{6G0y=;-2w!G8G@FC3W|=I?@?L;hugwRZsP#T&6@>uBSgkEh0CgXaIVPvs5*Va zxsqz)aID3y$AkGQk@JPjuPS>A`-NgUk{5u95;!349f!oh5I`AbT|z2^M@~c|W$w6@ z0)i%%k&qdTKS%-(6~gciYT!q(8R=OCTnGSyo?MHTQL?mTwK}0U#J^v!T>0x2tND@L z0dSr`82v%E04(Rbof`Wp_G(1K1*eb$8w(BtJ&yzHq%yXUa8%d}r^Na2jr<5oqndmC z_zsOxVKQQE3c91pxQR*!RrQvHL2;VcYOanERZVQMQ4*U zCc|&|FMbriRK=CjX^Y>Bya6DO*kx4z%inTCB?%WnhT(w72PlHNkJyYvleBlmQ_|EB z#)i)Uu7O3s-$7(!D+U&0?_k;s*umI@T>zq;5Ky0Avv1Bogo98e+MyjpOsX#A}%nwRmKd#bu$Drbdr z5T;4O-mr>P|6wkGeY6Zrb&SmPjFko^_ON2)7H$S+&N2%RGy4EruPA%pI19H(9ZOG5 z69)|=OKmwiSC(L;)Djvhoy=T(ZG0kpV>6>Oww`t#CbNhH>+t|+iWA%H+8uyHI)b1XusE1M0TU6SfmR`R$ZhK_()~J|mQL)>@ zW49&c)aGs7Q`I)KZ{%#t$jp{~-2o}tnpSr2tGJnLT$leWlO-VxfO5h`k&p`J z12YHao~ga7Uu;HB<*tUlsUznfoVfS)%+qfmtDn62*|7_+2dAF2c3rHf>Mz{ToDf+Q zF;dpWUFs!Z)5>oGSnxmAg8#ZqN%>|;NJEDFqz(w*`bN~u~Rpv=I)c_CwM$H zd-ufj!pMnBNBU16>=^sJ6Pjx~jFdrnRA|qou8pl$m#uEL%Z8L>l#}Mi?^p|l_X`97M1Voow#)8)o&I)_~P*J83cuVgVL<6 z-PzaxOYu*Ip9k0?g<-;zVz%Q@Nc2>Z99+H_?+<$-hJw5NbGbclKV??&@ypI99uVg#KB*C$5~j{`}nIPe-plsyQ^6zNIo^ zU2afpa&%%QwM!|Pg~?gPWZz=b@?z66ag#l+^(maBJouK&b^1N{@c z4VtT&+)8`3CK|=qBGvt(L{VTetJGu$M$S&&kimAf9qArAMaQM_nVXBgHoFTQ#B_QyM)e0Sr`7jw^FOy0jWa{YYsNKbnCCL?F%uQZpx z2i+Ar3r31zQ$Xs$8P(Kgc2wUD9W>gH`98tR7}>!$RS^1S?=^!aUQ9YjsB zzO_9*CrgQ*p}r0}fyOpUM}Oah{Jb3p+73;fn7n;^;iJ!PfAY=sH{V=&`OUSL-(PzC z4UOH8oxR`KHj=Pzi=#`V!on zoge0({C@r^0rj8HJ^TTQ(V^K7yC)v(KXPeD+`xc791(s&|6hLQMq+u zOX1Lt@~O(Q6J=YESC&t0E1TH1{p8lt$2@9n;D^wh)Yo1b5Q z@y8e6{>P_({J)?6`M;ih^N+LlK4={}o>o$7=Nllib~JYI3`^Uvbyrv0$lU1pM6gNA6FQ>@7tg1cjBTWbTw>9p{DB9=|;7=b?Db_$Y zPAqn|M^Z#Msr?)Z4_=S78>2mcE&>pQ*8*q1?y8BPFe% zac$yu02YO@yRp8VOwWq4Vgo}9a-+WC3F!sf99_dTb#06-J-x#+GB&m(=k0ND&oQxx zFtzjr-JMqJo1z|Lq_C&p z2ps{u8XPd^!0>e?RZX1}TkCtnqDmd?Vhq(4x+}3hqH6==Ovu1c^FkGq3U^TADT!Tx zsxfliMhZLcV87@jYjZm_(PgT!7* zYH~IHpVGl0JTVf;e52-bGItbwS2vHgSzyszk&_>_D5?2N#ZkVz5*PF#-i*9HiQT zIPhRZUYIb1Y@|ps<4BA84qSA>(URmV-(`VuD)ID*1hw?QWI)Ua-c_|rD#u=h$-tB0 z#=-eVI#xqZ27blJ^Er@YbmhqW7@JsIS~%F+I6GK5*i!2O6vN`OR64oqGIhb8HAXyHgLK&fipY-4(J?&&*C=e>Y(7qA#@&ewO~7Nr~nyB zhIA!MiO`9m5H2pM7#1Wo7JxD|A9DALh);`Mmz$8iJ|({>CATmorzkzIn2t*+Ih)vg z!DNy%OAzG8dnDHu7L(*36op6~GlkX4c|svjdV2(>CMT6_Szp(@zOHRUO?%F^X1FoY zYd3nh#h|I^>K>VrTSj6IOlDi-A&RUU+xuD$4mKYcphLm7n!Q`A_Rx|5h(2e-wuq=? zYM0>2tR&F%36Xe5Hd zq^||Or)8jRY-uL5Fh|rEO<-FZB*_%OesC964mSQ55xIz2)Yd=|0h6(Fb`z$9Ij2Q! zlL6BJ1~(GTpnr5vGqra_NQVPvqqV&YpaDr|N$5o`ml=aIU~p9Nj$jr6BZzAk)eG;U zUHm$}Px2@@Px`!59fmG3hzC#`H&+Fli-I@;aAe!n)&Rx=8uLPgz)~M=k-L`KoPquU zl)Y<~ZRZGY2h<27hPaB-)5p<2l;%eYE0kw^Xhlg`7Q>7AgVe9AZ;O7g? z0Pd*V+*Z%fYz-x-%U1|;1JEcr1&O$@L`y^8QYm+EGqQFDLKmu2oDxVP5>U|YR3%F^ zjz?<{&=p<>-8R5=0Wl=b3F}b>b^)|9whRJq16$yi47*Ua6o{H2(ujRiLS_U$BT+aA zqD5#=MS#SjVYcIw^MR^oeiWdGps5HV3Z6XvJb(-j)xN;b;t+kaMO;Uq4iv+Jf(x;T zMS;;XG^YAY;LNLq1ij$)sBESLBMF2a8%x4hTnOt(H8%tx1N(xFOeDmmok+!#!D4Vq zyjI~3s?&Ri(x|RWB8Y+zaxg{3#Y$L>Shy0t#4|TtW!t$-maqf_iE(32ihKvMY-?77 zTK}>G3X3P{+(_prU>PhkR-H`&1WbixFSsL}F|ZOBO}D;sD96D4sORU zm<+#H4KFWL9uB63gFg{(7HBAMkSvmfGO6z1yKFe0yhsT7f*3Cr#_1g_!=G_TA0RHD z&*2jYy@lzbj1qYb+Ls$bgOqW=6JtYW;*k`_2cU`pAs0kfunAN?GJ$C{K=m|Z&PVYO zJ0EwG0A3QD0`w6Zp$Y^OWeUK0erj>3!<}O~g-hlyeiEcp=3R@WQ zz9!bLdZspz;;^DXx9nEHr(!bTSfYb1VK0L4iII~aVm3!+IRC4fHY(Z}-^ID{V0U7k z@E%S;h37E$D7Gc5MQxO}p+Z+~g(cB5wbeIq1dTB?b2GN~F|_hlI0V^v#W)2e*?7mA zI)~_6d+1v@vSFCmx!8F4;W7m#W=3akN-35DU7oUjN5-c5yv!vSU`zGh^;_x^(+cTL6CbxeJ#BMdZpF53yUQ#0 zHSFp}ZKh^-Z_Td$>ZZOO^*vQ}M=EN%wrp?Tu(4@f+V)_->_D$fAJ+V;=hs_PyN%`DWlaTdtTl4b8Lflw!zEa|>;>xD@~UQA1u zCZV>T!LhkpD%*~BOkO#0`{Pp&zM6afJ@rb{x4#@Y^P+3y_TGbM%PWuMWK>57WqH{K zI~vid&=xSxLRV&EtnhSlPl`|9Tv}6A-&(u-(7ul0j-ClXmA=urq2rgwPu-k6wJ2uyuda?(wq5%U4xk&;H8j~hJk>KY(>-*$XJq=w zFwZlcL#Ge+PtsGVZs*>LirVa~!o}@jPQia&{)x4lk8h~SbRued{9t)WK0Hq(h1DRX0Gh%91LH(&e6e(nO^xJ>_>5D)7pSM5$=bP{U{l(Y+^z^Gg-}~(QE3ZGBd-n3^ zYtooV4;A&Vq$D)?_d`hyS8C(+t|$cEB7DI-@ZS4?)rhY-p$$DvLo~I zBl8R6HW#PY)NVc0+H!1k?AqL=7gryA^5CQI?|l62%{QN(fAMtU?#+QqbCrkpp#ZFJ zWBO~2l~j(e&{AJP5+2_h$~2Zz4o*(i%}`-#=49*UfXUr%2A z@Z#++uipO#%<9agryz>uJ6gTHqAcY0RLvlSuD@uxeAx#OA~W<=>tA^a)FAcW3$g^7rq&r`>1c~S?|PSkeT))*Q$0-Zmk?^ z*mGuN`qk`Rv}OK$?#b__Z+|;_@uPw1=k5JhcDJ5hzkYvo@RsO+ts(9kgWWbn`EHI4 zC`$;ah!3nx4BinJTooTulMq@P8(NbXu`?-RS8~{{by0iLV)kSv?p>dEXyb;?qRl-e zWdjxU6Ak-j_jg}Cdg9TAyWc(h>|fsg>Ayew$Nzrt#gAhbu2=5s%HOfKvVFMq*!;lk zgMl-5kDk6YGK8%b`s`xqpwU5xgIEF)IJ*!UIOK zV!0+>1!-1Y9X*n&@F8m&4@5*}ySYR-Dn03NjgoMPPty7gwe>AMR6CaK-ji8W91s~p z@)3(CHf8dpB%W{@)yVT1J9>qr=9M^j2YUubg+#@%n;ROM8tNMp48TS+BTu3$v(Pnj zFm;abPb$i<*;>4>Xk&BJ-r*x-=Z{~wH?#0$>hePW)Txr1YUCXdNXN+($v#NLz`S@I zQrQSz77hun3${q*y$JV4N(J(Qw{ekzr@C^rI}qD} ziLLeUUq`jCqg$MnO(5JD1Yk|&R@O>qAY2Exz~H#_gxt+GZsByRH+Kn-&ZtaWzb9aA zg|RYD+tACv)CG+fWCtkS%`Yr2E-jBi2huyz%E}$-ez}3A?izjVrE1!X5t>_yB%RI* zZ4(_U8@ZpoMNCL=X>MUxWy|#LBUg`1J-ztwhf9xsGjRHPVNH`ybgZ$`mI$3_2uEV^ zQjMi6b*U|*e2MZOA!vsl0%8c-8U#3CG7x$BCD|poxWom^)wSqZxOCNO_E*^B<~EKf zPAu1w%Pn1HW)6tD5RZ@-W2au5nZILy&*u8>@Wic7&M78(9@=P%FJ8HdGF-qIiD)6r zJG+}i5y#&KSm#HTC0`2SWnijs^mGl3Mr^^s%~#jZ1WX1;niCTtKy3rpWveWfEHzrPM4QGZv}2*<3+@M*ZA6E}rY6lUVmjD=L_Q*fmnu}) zvxpRMFPVop>Y|G)eWtiZHFaVlTtwjnN^Ub28*Ym@B!UgkLN10#lS30dLC9#pGWzuP zC14~zCMp-4BB^wOY9DCY|%uufFz@|Q`$P2 znp@K&n|n$GiXaI*2&#?veBr*bYpbc_S~2D#rY6q__^OV`iZ0tOS!|j;q4i259wAyn znpkS5j+_O&ktHx{U=eVQWFcwxEyb-O+Qr$G2y*-eZU^~O=v%Y~4vR}l$jVF3+mM`B zNDo9{8F(@o`6a2j#YtI(Fl2BbMQ%BIG3k8Sas#wV9O?sahk2%*4`^7c^|*W^t#0!q|dYDFVYZ&@)xi$jQ~& z+uPO48^R14IJ}ca=i>dwG6R{Rt|6UKbkQoIku(Q{Nu`yop`HPrj99ZMK1tCC7zrm& zj0uYa%8k8~8^8s4qY!vPR~bnXx-e^@wL)7TrA%pO?j*Q9$O{9MnVMRmtq011oHNjb zkb9DufRg}dVDJfG!4MGEk%Br>gw!7z!ZQLpf0L)2einv2cJ~Il8k}i5vkx9yi_Ss2rR?M z@wco3LDzvcqhnwqHmVA#nqQ45vYruL)lnxkHFxt3@D7QRb+un-C0 z0MH)_-~~<~v>J0K8w*!Q8!zZR0qz084xYZ|cCK<08#PVnz{@EeVHR?X5u(U4gXmU4rrdPE{hC}XgjNns{SkHyGs6^01T0Qk%=KLTsO8UQz@N)gtF)Z<*-V+hzzEzs6(GPfcN6G_XAS{B{>**ib5!7rnD#1ULjo26WCR;T zdf@5#}@Phj2YP_DG4ZEqlk%N$AH_-{>Z^3;qnE@DUB+35dI;y9ize0 z!5JXi~b;!%yk#W8>!mwyRDrDZGmCQ{S+pZ`k$GE&tNw~4>PgJR;5io)ZC9;2-<$57MG9{k5Z zL4$ioT}qY!WGuant$lSAw3qTVa|lt`2b(*FD%~P1T|+Hgf_O%G50*u8;r5(u4H+eM zS)1!KHr1sU)vhb7jm;`g$g7LZs#%*^6P8jH6ki$;RS*=N8@sL~Ij4*RRgl<}4XLPV zWE7{RZA^*HP7F;-3X02$PAy2tDoj~loK;?uUte9(xw~cjK=;Lt;RSrczS%cjvu``j zeo}wzMfK?Os)5I4M{aLyJDc4wl(1!A?E0Fdg7W0-lBBF+8u5_tKQHq4RQ1j0CFe@Z%hDjzCt^~`d`V)z@$Vw8GYx*)8 z(fI|2re_zB?4YSJN$~Q<_UgS|)%%a^*wqp$P`$sOPKYE*DjE-#)$ZR^v72mW zaP+!}=yc!()KH6xs!O*vR93ar)VD!u-O+e>$Ii}*x{k8y_R`AzkZN)^?np~3_HmDK zwhC}G@wGMbq<4nBv9F_ffTweer(2w_-@3ri{D|1iNjY_;4SfxVCfi0YZr;-qlu@W@ zY@MS zgO0)LL~W(pI`XosBLh;r?fmQvtjyI7%+&QvHFT`xrcSo@QPFWl#T7dm+8XwD)2n(< z2SwB4o&8hY1E>0i=LSbE43EtZ4WIApneIG1v43CRPW+RKmb%)u>gxUVjUBWNI?z2% znG$FWDi8z5=Lk;wkDog_J_|C_Jvei?|J44j7VhgHDjq^gu1h?@vEn=f4K1BZ)R`5pq4EnEzc)1!6zynX`|rS)Nqk{O9%;% z2?>Y}35fCWi=-tJ{iKe~TpKxasj0miuBoM&olM6NCk-PbFd4Wyix*Kj1rAL42F!jh z&*1G9jctdA8Kt4g%i}W(r{?a>U4A-y>B)ub&tb@1x$^z`MayHzdZf$#mK_F-uX*S0|Ob`w!o0Z z4|nwRNX^UJ*M0QNwY!(@KRtW-_Q=@j>av~b5vj2*ArV%7v36k@zG*pO8%n4J*|=v{ zZO@VJGbd;6U%mJ7!?)i({`&hnpMQPh?c2+*Kj=MoGNZgi?r#5{=F0chEPW60CXLmL zG*>M{J=R2zLv*54n0os8XXF+nrRUJsK0G=#BywF!*0#ph0WNBM?ovy4Pj=~+*sRRr z>K%Lf`X{g6xb)=1J8!?{5^lWw^6bLPQx~6(Pu}etymF}XLfe6}y#tp|o_Tof)CM_7Smi$K-(Y&_+}K96EnK_20)VW3y=2=i=$ON zo)4aXL_$g!2yj$vXk2Pe@%E}c9gW>1Ekh>{PF?Oiy>NKyX2;m&-id24WSH~4<7bbI z%|MrG>pWfGGLAHB{qEV?rZde4&UX&nIC^a1K=;|g;=Rf1wr{ICICSFb#O%HCxqC;a zZVsHfH#GfhboR~Q*;oD3A3%UPICQhBabm;f?oFjV)s2&#Lw6CDx%lJ{sDd27_WAJn z*GDEFv>iELUeyKjjruHSS&+T1kG-C^qk)f;p|6vnpQC}Vo6O%;9%!c@WUC+IWE9~n zi*%7kyUC)xjpG8WQp4Mw8p_}`!X0}?cUyZYge{d14^4qiGidadjD&Hl-o6kd%?Tpm7lVO#000GB8`BL_2e zx&D&X3^ii=EAYZl62d)0;fy|mX7=jZCQFuU(AyVx9RvUz3|*$})y=`dDGIr>nZBi& zHd_}=7swDvkY{!s7@+?wD%cyhS4AWw<2IuON(C|7KV}dX1f7%-P)*6&%#!4zs9i!U z67P)sECDG31%#b)O+!R%tc=V(9K6Xo6lCtmPTx_qshLXKV>7oWF5DYGkHFW3hK|mZ z^#yRTC~Cls6gaTz0S+uUc7oX}<%~oc2)_lV1#g5bE-!@#E8+hnQBZ&ccOo^pT1^ja z7Ck*nLqltH@{NofOcfsX&e2MTaC?_XC$|XtFe2b)D6>G?F(^FMKO!|Tw=^zyi(6Ql zjZc!-+D%#8I-@f7xCWOhY!fw%+!VH6lp6U2g-6DvrsoueMkZ4vWn$u>qb=9dHAEp( zNQ^F8N?s7rz*WCqqPc91?kXb-MqgLlu~`R?+w?~k0i zvUPVG>{F$imx?XCTGw=`noLV(BUiet&^B5Mg#%4=0|XYd1z|%}+zZJ>Fb1+q#2uh9 zqAMy1Fm>1tatLO2?t$PICQ5fCWtOYKx-dZW08!TU6?J91y4c_x-BKV9>8e?1E!ASI ziDB^vh4Z75d<3t+DV2KD;G>F=9G4&NHbbf-)1)K1g^SY3-#Z}E*4c}W-UL24w4y+R zY8S8w14Cp|?3~=8B>*%@TEuHm4p|P`M$=ns8=Hu@jJl5Mf%E%L-#>ir+3@wZL)Vaw zc{x1)Y+&xmfnzr}RSo%vY_?Ozni={iwB3z$oXun&w9R&P3Ph)vD;K>r;q7S{N}a## z&8YI0J98*3y%m-LMkZbwx^~M~oBn!<&Z0%?i{D>~1C2`}AUk|UXdxOJIFiEiUc6ZR zMoSPFaOYHxCaVKXh6{%b&)+cMIGlu*D)AitmTW1}kSNe5>Vcx7C6cFPQAKd4POUq* z3<8CO!lIP~Q7TzU6$e|2$0=-wreY`n84A#-6{0D&LV*M;&;ija9hP+@~5CjE5f+&iLfD%k3K|nF*oU?6i+YWYG z-MzwIVehr?KIiPa@4fqZ&i!NG-#5$E=iGYcQx;{VIp;UOZ;W@m<9(Y4#+$Z{HNx)h z7%wjGiAyZ=@rw0S`a4)SGZ)d_9G8+`*Se)@!?uRb-RpY>fnqif&|15HL+>CPq2SsL zeU%Lz=*htAMrnr&kdzjJ9T|$K4N_o5{~JAjYipd2z0i$u^f0%foy1w`Lsy3ESRg&R9s&;-JGfOl4RIrSSox(2%yWs6&R15cQu`%YMsc`M^ zQM_2yTf{w`QXo#$=#eJoH4u(CTyS8ll}>PhXg5Qe*d-vuD=Z3P4-RygB7vlVBUve( z(0+mZgDr^g<0k7s9z?*Sw37)rT=thMk?{|Lq2hgkb&}nYqDq^P?_eVV5f?l~cxF?& znV|3J8j_0AxerfT2^lxm4wJGg}rc^1spxL}~?`LY%{&qAZ2Y zktBD*}5XKZSCfzudrIdn!;$2I9gmVY~Y_Pg~F9pUyrlKB~00f_fds` z8VVr8^=xWxN8_loSFmSLOn5?WLS~t7RFaLSztSVn*4c-wP|#P*Z9$0vxAAL)LrYzN zK`14g(0_!4sTd~`F2@5^JjjmoYuVY~qCWmh3@Q|rG~gPWXzCLznd=%0G=|R?{Yp&K z)-G~eYHGd!GFA?O3g=LBWuURb%f#B7KY89t83anhCNXD{1LBL)D_ir|cIDM~rI)Wy z%wL<3y(S{LJT$p1Jh?hJzB)RsDIvQpDs^2*TunfDK}38}YEErhel6V}i5cao8D&}7 zm27mir^V-`(wrZbm>LqB9vYJso{$}pS(H#-k+rsY&GxSDL)!+9?U}eXefIU-jUVRk z{c-fd_kBm-b5%qm|8GDFEDDO-sB0>~ug7DlCJ zh9#wh#Kn1pgt-R>y7_opSes*BMWs&C3jBz`NC!>KevB(N!fB2hbD-GN)aV8^2A8&W z@(rK{o>f|1k2P~c>sFT9*1kO*JH|E*?C&0)>>ZieIy&Doe7Ixh!Hqk{H*VeAxN%!? zO>10w32QwinC!fo%9_^Nx{VEMJDb+^tXsdOsdZ~}`;NxeZBSdeuWIPTq7mWZn5Z;Y zdtW;f2Rug<+Ex}C=C%g*)&};rCQk0Q0q#m65*Qko7a3I+o79k2*j~`EqjvMYzNvG~ zyQiXy*BLnme4=6S$%@sVGJy5;U>n+dg~a64*7b~SpT0PK_091IKU{h9m(ve_cl72r zv*%uoAGy12&*_burvYS23R`1Bv-}+W9Zjw64P`bu`j%R{wlXu+T(KmnsB7HN-M@L~ zzP{n9onvzYSa^@l5AK^EIe2{Rz=^$MOJn25hxaV(>KE!Uo$Wh2+jn4i-P1F$wST04 z@X*lyc^Z@^7tc;CoS8XxY5Mr(iK7?T;K__kER7sGfvzSv&!*m?x-}cpl5#VWiu3c< zwswy%U4HTK%`azeyzJa|Ft?~BIyT?g!QaBvic6Bh3g|bRO0(+|Q9@OxZ9(7|!nM5xYr4})T4FP+Q*+j&W!0vnRuvVsR#o=Yt?6Iiv48Wx;^^$vW0zmteEGW@ zuYQ<3b-kv2OMHGQKxNJ?k_z(b@}0io6oL4e)H(<58wR! zFaPpC{_9`=&;R<{zx~%QfBMhwfByHcKm7gm+dqHt)!)DS{r~*%hyVARKm0%Me*SM? z{Q9pie)`+JuYbM#>chhQ=W}--?YnSg=iGejz|NG?qUh|b>eh{;N0u%;_?+$drCURL zChE!>;wZgXy9b&mgG?MFt$Y(5qw)ju1TvG?)>^lHYxhBPW-i@){qXJ2&%gikgKvI! z>#J{$Ke|7(w9qy>n7^*xKQ+P9+s(v9si(Bmwl&kRG}5t_8`xNyJ3EFZClxo;H+6TF zH#TOJl!eBp1;%FPR5U?1I=FaxWbW9&}>y*+4knq_U8R9^?O^^4sBRB)YP=2wQZnx%f7n0&fvgUbD1SG6KYEG6 z#)240TGI&|jAX_Z_V&bJkdp%=6ToDkMFmDDg(s!Orsr|4J?fRwJqa? zRXf-^w;vmxxHEC$&Dn>4I(h#O3paiQlNmemVEfRChWhOZVY%K`f%ZBM3UwQ6b%m{# z*z9#|9JFohwXBp{*47$!3U#H$Dutz*c&yZNQmQ*DHC#Q6f;?rBUY2p5ilh*i;wYb* zq_Fi_@m+-(+sjLa)~ub_(0O#r$d#G1Z|P}z_T7Ix`ta}9UjA+B+?(;E5BJX98l1W~ zcCUD0WmoaNRYXaxk4L=#C)e zH%vwfwgo#+tj=^vV#f+=S_rSm_4Lj44H4T{h(uI-4(t`E;?DQFtaZP*u`z0E&ny`yiwt!I2lLQYX#6QUX6(P?O* zTibcdWRBX}sOEtG2-hKMJmmIFIHa;{LiSZn%R~pM0(uX8Vxub?TlO_~%&lpiYv@?q zJbd}^`L`$UeSP@iqt4;U)Uq``G0C1`ao*v{w(g;pP62YIw}!FhGHrb|L!lU{ZEOts zAz=lgZpTt8rO!m{!sLQZ3X0&iPM)DLsStj&3>21jUideulNXs;I(mEORo2#bY%i+s z35+NS;cQDd4)j=>AqY3IxQsI&Cl1*S05+)-Mc&da{lj#iOkgB1AtFNwYs;y@Q z=%RG=!I~BkRoMGvKqLi#t6&jeeb7H3RQQI3BPhBOvo@Sr4E0x=n<@eWqbq7lx_7o6 zI5}|gF=)(%H-EkI_V1To{`K6W-_yG{d-;n)C!eqDIT9RMVaMG2zkHSPvgJCTenumUP&X7r zenH+8r6SQBM0p+j0b&fGi{uMKaLy(Y4XHxM@+ZQ6sSHhOqiWMo!7{|L#-=7PVT5h!12VEftzAax*p(J-`{*2qdrqF$nPI zdZf;%Z)%Kqh^dX0D7!nNq~Yf1>SpKU3?TCxCL@wujx{)-!U{7crMo*_Ej0c^mlAv) z$W#JK5?v(1H3*T~73wS1sj%yz^Pp)cB5qO`t|_iEh7)11sjaPCsnnLsc>yavge%@o z9!GMgO4Io9;uPx|pg~H435_8#IXShkFuT0Eu(pv6rC)e5^e*L;)@2k{0mx+LS0(3^ zrRG%-Jrb=2#bvpL#<_(?1SY4XRo7;%U0>X`wV`jUv3oB~(^=UqQQ?KIjv-budpzbW z;6WK$+L${8h9;EMZ>)ke-mwdwOzW1Ro?QpJc8K2OSf;Rl4%k`sQldrW(3PKbewdvuSCWim5=)9ML6B z9rQz}HXDFKaE`#uke#911%(s(JHXIzGgP`cvpIOUyZZWy%BGLMXsU8>HnS9j6ALT6 zX)RH!So7ca03qmSeWRa^Y;LL;LflRyk3 z7e^3-8mLGtB}E`$86oS8w~DPJ^0ek=R>a|k2$mz!pabm=l?hug8Cp?rFM@@|FcV#q z(nvr-f_zzp%#h~<|0$>PS=3p`^i~{l!=S2YESf>cmoPf#&wZjldR#=3C>ceLc;Ecoo1Xz%; z2m#vg$z1IJ`#s={SYlzwNJ=s+y8@FTs*r@TMO_4*3=k-i%ZzpuqaEEW9bC9})pSkh zuq8ZT*ol2W?}ShI2WlbCfpk;tBRGi)lL3xq0K=qW5);sn)IufREukw!0%D`52Lw{6 z>g~_OXvj`Fdh$LR7dW#f0h@>7wg=cucCBSkf0t*Qd;$C$;IS493m%wMVw0Mp9 zkrE+Sz)8|gg~_N!1tXu0cX0~%8NXpNzac6>F)B1hbuWS$33!1#qrzl(o+sG^(jwif zUc)^Hif7oQ)?tCSu&JIWiI%cy>9=uY#g7!~tkSo9{6Nl_>Nm63qFeYcER5O6E&6iWbWqL@RtvW1$OIxI=RNvr_Pt(_V4Hr|0IPR__ygD6S`ARPu9;EZSn zL|9vDa^$gUNg@zpQD#H39(fAHtl&l>QsIR|M|4(jRHo817-E<;R zbQQrsHny^1c@nV=0m({115~xksc-|XP;nllgZ6R9IYH8mq4Ke~z_(MiF@!&?Fpycx z=vT5(3Lc~6tYl*8CAafOs+Zu(+$q4w#?wTBU79m;=m6>TtU!b|we>S|3UvxdN4dAS zX(?Slr1BtTxh?f7bV5##YCjU2FFMHg@t+eM0)tdx`m|r#%G3R6eN__6t{2OFuY~^ z%&zgXs8b$1^TpJa?+#r0e)#lvATupfPnu^QHcs8F99+t58%nC%lw7thIj@HAN=z*P z03k)9avhnJ77`r?YV92o?iLVW>+GP5!8n(ZrjUo{%8=lfWnvwW;4Cq01R%4FnS+gM ziiMJR1&X_;cPIsp+QwGAb*k5GTGzD`k_-!O=g$4zLlc|#9Ns#5q<{Qq-^hIT&~(SH z{nSdT8oSc+s$)PuYI_n#|Yiirp)OXZ1Y+AQrbA5AHLrZs6eH;BL z`GwWVN!j#hup(ON%PqBx&DHg&CL6ERGE+A&(=dhzZDVAwl)Jjy1o}8d2Ki+B`{e~k zlt-pFC6;wJ?>g2ud41E^>71r5=6(^YENr!yX%R83Z*3c%9Xt7O_WGA+pZ$97*&hI8 zmTr8QIQ}_iPrU<6n|i0KYPS^^w#0;`d)RwB$Zf0*jVM4n zt$Pk^AD`a2Z+_>2V*|*=96U8JezbpRwtv^m)~yp;wjAo{7}>afa6?Ofd+YY@&K*6Q zclGZa-LoHCrNx6sP90i2JAM2j+uZ5vGbgS9%RrJDnK(vrIyk;a|25*t>)W^F=at7s zrluyBmB3*iJ9gpTmrvgPVPfG*&Dw2=Y1NQqtSp>lRF-8n+9nD$Ba4-W@>Mc3HVv9{ z6^``1ItN92My7g3W(KC9EL0s|P#c|F5tCDqR#Kl)wl=G5EldVg?JP7gmC{&pR&7pU zYkoyfLCxljvJHv(4Kdku!AYeNX_Zl_l~IW$3F#H78Rco|r8zlOdAYTP1x-~|@SR3c zn%%NGkr$bg5u1`88Wt5A7#`pi8W0edTL=Ss z;qaL|)2A*sZQ4q3WozvKXiHiIEG~)$RL#JFSFbSC)uCD6#lbBvx4d`j(D3--$@z0M z+AN&BbLzt5GnbxTz5Vvu-M82+-F*0#-X*qM&)(mB`sJOcU)_5A<;A;SaNN$_{Nln* z%$VNYd-CP;_dkKg{Pa)%{_9`=^VdKB=Z7Eu?d6LNB3_3 z`1dG`MJgO@Yc?v9^6KeBY9dvtvJ z!O7{fSB_o3w{-o%^s)2p9XrxvGs7G`y=9iJTE?#GhVI&?{zi7;7TyUC5!nG*d67j` z*)8o&11JDb&0afm<<;F6KVJR({n^LQk3M)fbK}O|lgIjxOm*$w+d8tlZDgoZzWrkzy9a7IHWfE+ShHyh7G0xQPodIio_ZLA=$;-4{|cx;Gnn^|JY=RF-$e_>3ONS zC5TB!>*HhF8rK~fo49}M+!ym_o@3RGclQ3dTN8^9=gz#IKKbUr z@z-E7V@uEW&OO*Ne5Sl%IJ<01OV7m6DgH5I4Dhg+)X2bm6?&AMMf3ec(CpL6h3ClQ zTz&kPE06ws;nD9eKmEhPwJ%1FT-|l>Bu%VJw{V%E6-5h7&GZEP1r#opY*u#S7Ha5_ z`lubKX&4A|0$PU6t!J)lZf{NxOh{~E<+_b~ zhbPa^p1F5m_H_5o!Q#5=h~#K{R|jm8;0m(-n$UM=@9F9jnw(w4`fCpJ#L|`(Szt1h z)y?fmn{CXkt>qT>=2lK9eFVnjXIABAugT18XxX@T=)l>@6Sv0~F72K<+A};}*}UG> z*9VwRtQ5aF5vVBEQUkT94oOQh4^**=Sf-_$Dzp$Vf(A5ix~45*&zf4;Al4ymBFq4( zz)B-7J{OXVm6=jzWN9pUBbu1GDLtcesyp%;wuEM_ODfw|w&8G6$*@oK2G58!e$mxQ z`Rl0H(>lj$=;jt?XYXTX?rbcxMJ@pO0+c!kO9XFUrCYdCT?$!ILKe#Z6lOpH-3CSQUZBXVSFyZ;DBi9+cx0+7)G2eC#RBG|<%lqxK+2?maw3)m4>PEP*O z(T$sW8`^e6r&QP}!;KAb4K^jwg0Y6&5OuGQBpFI;QX(L#pOR-Q(GKH?f+&U->MJ!@ zuY`kSprvlAts$2g+gRJUI=c#!7b@4JilQiwwh8tKpbauJ2Tva}Cr33Ix-W85caNZg z!t$*e7y9s8Biu0EHPF+i0j8LjM5c0BJPEB*ihv-Zg^8G$UhYO?8XaD~&*Z zfg?oB&+Stjy+w3Nkw}aXv>C`%)iqT$XljIPs^TehD?&R_Hxh0)9Ai;-=PzPcU>Wik zHgZ4)Cpy^}M4MQkV`&I1Bk~>5>mZUuKq&#p(6}M&K=r_6Aaau-vcVPrlYtLFz6Ky8 zium}y;1r{KIA|}z0vo4bxG@gcg1aI!;)2;O8wd;;J$?|R?R1M++1qh) z?L9n5>S@oRHB6BIC1o4Z4Mres5T8;hU4>Gm4rVBf6M|l_0+Gs58RyKRsGzTJWNmBV z>TcmI2nn1xH61)+G*_@#O6&-z5x^Qm;G}XG`y&0p7M_?GpPikQSA?ESQB8ARg>b%x zDMu4iMo}f2{7D(b@#!UrS>ZDS)dg@d<$ zXkvPNMqzMNGKM>L_8uhNNSD~VVNMF5cpP@V$oG3Go!)C#ayWbz9X3u_ya2`zS|_Aj9Jx9 zD*AJB!SSNv;+2k0yqyc00ZeV3oQtR%Y*O`WDJS!>!bjWC7~KbfS_mqfmXMvXvg61w zop2SS`AlIQF&x-sjC^u2@-kH`ABi*AKN|x>$WtJb3#ej^7_}>82~ZTGUGOM6w%9Bv z(wUh`4qw6-$=FP20<$Ar0^pVu+~K_dv!LJ0^}++z4J@G@J?VOgaP|*mgo9}S%TRV_ zL%)SSEG{Sk6-xJ9r=)BGSO$?N^_HeH_K4?6GkIRhusKw4EkS8TbC6(5uu6U^s_i_< zyaznVh0j6YvK7r%IPXH|;bK!dSvxtwvvT(e!jsg=0Z$VT9wTla7MGopN83V{dq4;v zDwJ^M0r7TiVGu(<6lW7VU8R#7+M6K>31LZTK9PwIeo;nNPKKtmdYN+gm?^}M7otr9 zUSq@xVhLaozgo)W{}(zTa!;X83k`;4{2x3GRilT%+{BYQnr!0iFiNDhEJhm36UN-a z1|6pcKo7tfgl&=UK-rb%G6P*O9Nx7O8&E(7pavKtzcEh$I>__EI)uW^GI7`-;I0-( z7P&JTzf8rVLss8}9xjE_4G9s!{K4&1A5A-T5C)DdyCa|m38_%6*MfQ@>636u1f_=w zM&ikEVG4k<@cOyC?AL>DEGIZlQEk^bQ~&ADLN<#&R33tWpnGN?6d0DihU z0;*CmUjF|i89o6JMhq_zwFsSF6#~QON}!84AUwnK;)e^2D6=LNTD06YwHkac?LgRzbmJw44JS9!Q8KyX90Hy`58gV76YqQXRF;bt= z(lrA3#iP&3#SdY=(9l#D_b|D&v)s;wDS~*67ij8WZEXq?Ky(VKsb^sYRR&t4I5iks ztwd2>Ad_4j;sTNEpHyhfKWHAJV5d5X0L4@uwT&&*4J=?9>&R>j<@Pd5C%M9fd0TGn zDN}f%_HSk{Fd1`4UsFdfV_O%|JVgVzfe9dzuD*q_+||U|$HFB%D4{&Fva_ImYg$QL zY<5FXe5rp_secU0EzQ{#-H|D4eWR*;BE;qwSqUZ+6o!s{No;CSTzVm}3}uMq98^z5 z>uy3?VSG|yTwG3MXkv&@n4dd^0k<#*pJd6 zM*pq4VdI*Xj)vBrHEmmw_C-tvl1%6BgS~ra`}ZH+zHd>5$!s2;*)(u~MY*7|nYBJ4 zvzX@PnspuZ8+vM*y6PIcYu9$s!BkehuCBhVuD-Q)ZCh1CYsH%N`K2{!sd*s*VGhLN4S z3mV6|MlbI<@o3xZ`HIa08S6UAH}CA+zc70G{v7HV4}ZsY>duez7v3E@`ebn5m7e~E z^&7|5)Ne1$Z%mHK_QU$q+zLx7GaW6twx(QH*T&4!)zv#Ct8m?>E#13Eb{v@5dFaT% z#IfBICw3n?wS9D{Z*aDI+rbSR2U}VOTAFq?HEdtkxUG5JwvJ6ZxApHG9GTdA@bLKb z(L)QTfMO6)nLm4z`y;1sP93`pTL$LL=;RW{k^Ot7d-}&VbZo7xZbY>vJ~}-uy?V{M z9fuaK-TeHA^S9ri98yr$9vq(KigT#FmzQUxUrm*igD6OPRYy7t0=2zEGuiSThp_C z{q9Yj``WwqwRRoo*fO(q&+)PO8;e&ypE`SM{MgyjmX7eW%+SQ-z_3Vv?*MN%e}A7C zcB+5R{M6D7T30F>THU?;nN#47GuN;LvuF{gsjvEs^@z^dwX5RLZio1Hjv z_VBT5M^E27eeucJ%g-*|cqMo;w_jenC)$^8KKkO;lec%Cy#u0wHY4PJAASj8=I)aZ zPhbD|#W#QW_UC{3_LslE|Nfs}zWd{or$1b~`1;t?t(oC-2e%&`?VcIyoF4C)n;JNK zdhYR^Yu~(l{ikn#_upTC_s@^s{o&r*Uv9qn`O2#wETaM;eP~o3nw5QbWgHUE5}rhNFg|r;de>o=vd1M}%!~vVU4p zVogoK#*XGadj^glKk?}N%~zKmeSypQnI|t#J$|})@AlFAcNQPqJ#zov(Z`QYJbHBM z$&-^09?f07HFx9Au{-yc?%g?Y|MrQyw-;|*J97Ej^tsD(=daD4y*7L9)}iB9W=`L} z`QnEsU;X*~-LIw=?hlQf>*}3a+qko~yfZ(kCM&8aJG3y)Jw3oC+Q&N5+cv_>Hp0_B z!U=^{xrdn{-EeZs396h(h4Zrpi5dz@3_4ms_w-i4+=g3@l8j#zw(u$8i5an}IqCUj zStZrQwN2|f`??24cOE=EIJtml&F;hJ_MN^zb@|Qlhre8Z_uo$3{b~06%YF0L_Z_)_ z49@h0e=&3B-OTy-`%k=rCo?d4tEFeQsAgBunt|StllxCR9GQPGIP-Aw^w&pk{QlUj zUzsz9XC8EIKUz}O;pq}=VQ48MC|RvzvP#=jO;ff?1GgKQx~4G?R;tsnrSs`B<5epR zmM=40@tN_;RXoX@BU3Yw>zD#lxY)VanA#et8Jn$E*z3Ew$^&SIiuNr_jczW;?pxb% zuz&mcEq$lD`%d)_Upch+`NapnzxDcW_uv2PmCygMaQV%ay(bcL*0TC6TS>`=b)Wum zC~b5aLJ{%0x!DW{`JKMpAA;&YJYp>YUsbFrT4`bNiRBj~_k1Yw}3@ zj)AuUCMGL1JPA`a18oys4eE$8LnA9FG-$p--pgCtADP!)vSA{l zYTPTb)y|{DJ-9qJqbZ|!Lsr@P`1A^-M{R7pX@&xjfobF66G&mg#m^6QO7s~Jl%V26 z-3Og9L_DDCu;k$*prQ{0S`l$oikzP6kqAJjDsi9^UFN!Uyf zNPI{DNt{EpEZEXg<37w6!^XS5WAjpd z<3w5INK5Nn_pa0X7avcZc`-bFwZ3I{NJO@QfiKzLUwiC+S= zgdz%D8l+>`Q<0mn(ZxW~*~C=GQej|YZvu@RCa=Oq$IL=UE?cFq`4v!?qOwKP&FRV^4f)&Gqip1<9NrAtd05v|NG&#RIrJyFYv>~;8 zZAwLBHip;hI?G$Pl{Rh7E#H)q(GU|+=U_3ZpC3!R7(HReatozL ze0F)!n)bT3ZD2BOTZhr0>)Lf-%kWh1?n6imA~0Cjvbk)Hz+~bRv*|q%X9$RdnLzl) zuVm>5g#ef(m)A3}@b(Q?*f>MALWPp62D>H9=<$&93y6}N*#plql^L7aQD)UQwIQUp zuy!@KaADrk)w9ypx6m@M)HAlCs)j(@XP>P`T$6z$a%Ukc!QrOUPh=$s?{Lf+KA;Wg zFmq`@9TY+b$ouFC*L76}L}rBDIr1-HG65lx&aS>tYLJfsx}#(XR0601OhBJJ&^KLb z7(Ag)43fjg5>|8e$i+lXr_z9e;RXz$rwgwmJUYhN)s0RCk!hhyswsv#?~;C%=-Lq< z%WEZvSwLff7^(|(O-kPQz=}M@NCwDES`CMRYz}aVd!c7SFBGo1pu}tvX!B7l)Jg#+ z1Mx#{;{;g(onAXhx*YIOz%rKRu*;0(GG=w&1*Z$_QDon`*bobx6GT_IDd`!Z{US>6 zk_eJD^40<2PJRJy{z34F9NlP66v{0iHe6F&j2vOrzLT(7Px=E^J>&J6Qr99k^ryW0Qm9 zGhO^+DbQMq*B8R+c~sexA57BZ>AR!daoC!p5oN zH}hiti{}Ndf~^>xH7XS^Ni#~!P7*Q$63GlBkQoDguooegrLO}fqq+x*VPgmhXje!0 zf&NB8;fDctha1Yre`2vCsU>Q{rLQ5VNAdL!=x3%eBKFEU92J0*%oV*4W&$amk3KP}M^O7RCEm1-Pcs zsn!=#U2Lky{8|-HMgXMJ>$&H|F%*GQ{sEo{nviORRsCia(!y)RCrdYejQBmOU&w!m zUn(}3}=CJ%BfM^v&1m` zSa3z2CEb{05Lu&kfnqjFeYBK%d55|<`6(=&O-!x1pdi*#r(p2IcV%OK6AV97`n9d# z1A`oLoH@UIg=&lmBpJk!Z)7Ym3?+^SJIj$|jpOt&+TnzO^B@YMBeU0o%_y@sFmp7v zbirat2*_A_W3gmrC)r*redKoTa(g%YADOZQ)rX3M7PFj!!kmRekY7w*PE9*2R7zn> zaBOKnXr6aau3uzHNK#!wQCDVFKLUe+iOm7=&EC=VzTuTYQ5E4arIGPP(a9wV*_BCj zFcmdrRkWs;HK!J@p<^pHwJb8BkgyZuHcxLKe=qLd<@ccKMW*>Ad+-sY@Sk-?hwZ0=TDLW`8 znQoEDxJ1wx4R@q$VubK2`hllU1VYO`I~$mS~3*a2(f> z!~#ZzO_M?r3rA#pO6i*B`nI06?Y;FIw={JPwDpal?z?H{_~t!RTSgCW+jpe@z{0li zIX0f@-hBWH1g?t_iP;&2b=6HBO&xty&-sM9maeM$_PV-`;*z!G+NBlsC6#N7D%a+f z)h1`=MMlQM{WVA39ilNupWe!qE7|nW7hSm=WQGKaEJ@I2R_mI>7uQA;!PVI+$jd3g z$2-?Qs3JIaU3}q|+RcZzPG22bx;1e0>hRLFeP{0-yZhCt2j8E$_v7*FU(cR=F+O=~ z*YN4yZF4Pcd#Y=?it-xLT;C$FoNPJt%&9Gc(0=Mc?J8$0`Js+)4M3KF7Ia4E{kYi{3s zaN)w^8_&LFV^Ie0A9DT$y&c3Nm?g{oT(Rhz4-6C;&H?njzG_#|(8fi(n%-z)3 zLoWAL*ag_Rgn9-h1xBRP>=2h&keZ5zb!mELNmhPEabA$aboTMvw!zWRjBKTkA0r&bi?3@~Y(gKVk9$A;<RoZatk?y0oEt zM?z9AxRWE^URt^ckBEUw(M(R`a8*^vxpT73`?Da3E=Wh3J zUuT}uy0CQV+SKBimbNY7 zVQCK5zK&)-9yZawj@jV>wW(>{8+(r)Jo0GY?48}C7kBJE&jdI+cYopPw{us%-hcA> zfm1K~#;#Vj>@TPrYV4jyyk+Xb3v93V&OaGle0%8Zhr?HX*njHn;MD!~Ju}()EzZt? zSgvE{MOg^79Nksw7}*euAebgS5D9|%vSm6eKhs^lOmD?!IxAKnZmg%KL7l+N(8SBt zJw7@iIX*SeHy9f%;2i~`F6OQ-mbh`G#DrBAWOui>Os=gPEiW5t*)Tmke*MJduNE)A zgOYdQ(O>Sp`;X_}{m+}P{(0ZAJH;)1R^Abx8k&EiuJwtA`ltA#>T6OUqb^28gD3(u z2{Q)==g=@NpUmpD6)l}9`L+0KQ=kMlfIBUI^YT@CD_7%}4ZT%q;q2oc6A@8RSlZsc zd30cGZtujx)}ejaWLGw=$0Q4=2URdEhRG9CGjeR~osCQ|Sah^gdQu`m>ynZv8U98)l=9zJdPX zaUT8=zQGATfeH3XUqb^6YF$E{gymRYL?F&Sk>$samu8X zH6^<#DxuudFPRdwqcWJTFMT6BbR?*)ySV$i_yprad?YBX zLRaCn8upZ9pq*EgS9q#>M50qrB%GN~L<6aC77!8=thiE5lfDd7OKX?_@a%OB%<$1x zSC^@&84@0o#3A1imz!U^vA3qBHzX?8%F4@>yix*WINgFvAc;v5^AOGvNq&qQRfK6t zVv#3_32D^FmWf^_$Zl$%(ZHa)ayd&VO+a#lqg~zo9kAI|+GD`JOk4XCgjH;nZt=-+ zH4Vkx{cvOUU4C%<^B+!p{`1+Ve_Xis{l3NLpo=YShbzm53o^E*MYqQUH6%v0WMy@? zbWV>gKAJlJa(wB2OYeT~uoOMHEgG0BG<0dp(~~>eyM>!5+%@P&Ggq2(ik04mmL3Lj z7urTvt<>S?35t(sE*JOGND)Cfqyj0T6M!B8q=+FA=#_k1#JnVG=Aufi8e04*O;XEA z0*K_rWVLd+3S$wW4iOx}r8JR{vf0`|U7++&&j@iPsRWx!dX#*G4H|&JLx8^oeMq3>b@0ZCyn`%L!fv zxtS-I>F6ytFj6y-Yg;JvumQ#U#?8~p%iGe^%fQACWoB(!t7OLd3Ud^ntehRK-Q3)Q zLvalYPtK&9I4Ug%G={DvG=2-KTCz(Ts1k}=VL?@LNo`t1V{TnrVM7;6i6!;j#dX~| zC2i4BB}nLrqO$2?=YB5{e~^Hy%(0&gUR4i#YK%+nL3>cDkp0K`qf$x#^_IEgaD$tIQu~1 z<7|>PkZ#j>84;cA;TddZq|jC~Kp~t65oH!wO&Z$9TG}$OM|fEptMr*2Y5YX56(bKS z!qgPV^%zbd!zw9YhL~hFEBfHbXW0n&;gF!G50?ZCf#>0cQd<_KW^}Khzd2aD_=v6? z-=JtG_W+E}VPA<(A`OO^wkm*O@X#BA0SZebTq$d%J&6^-AYcnbCUPqhb3yor`hhSt z3>dkoPY_*No~Y1}Z8661fr9TrUlNEA(nkCe-~y6)@mmDvMp6#M=Z@5eqe98pKt}CY zq_n zgyRxFlAj@HSjbHo$ys!en1h5S`lE$;v_4~=y^wZ9a9yPJg`E>O@y~C73BOaaj^bDW z9tyT0y};_4Our)a=0pkl>uN3^G}VCtI1~b_k#d2DpU30cRv) z3GY(9QQ$R#ks>;Y#8N?TE@D3D)3V`YC%8I-M#3%&oJ3j~1zG~72h7Sq9|Qox7@R|9 zV8*iwlacU{k1rO}f`q7ie6RE&D%6D+e>|ts3&hJLJWw24_CvyC1oH5aAtMSRs*mDc z^%WxQ0dl_~pcA^cpiQ z(9$RnQ3DZcF&;P$MkZ*BdfIq~+WLl>Iy$d1Fjz(aMt2(nmE-VH!9~c%0)>hTM^doi zzc`PaI9v{`EFGL2y`0^=?H%3B&Fqcz%>bO~spLz=ECel$Sx`+~Fq3qsP{>dlqkT!& z%#i66XT-bv;vso~e=uLC@TodjoT4Lo;Up z86$IeBc4J`#?ISP>BAd{tD&y6l>rX%#z@igrY0^@e411*f$6$2J5+Rm3FM#H3cnWz`@%LvvGR zc}HeV7fnyeB@KyrH8B}g(W&JyTj&CSFXs~w==~9Ao{|)nlo<_GBCD8wq}=Md zoW`co&enCi+czET-+N|w_U^uuuaDgMW$w=J4_y6z@Z9Uc3(vdet`=|J6P8!y6Pt$W zreAOvXpD!ikGrR*gOd|T1M{kw8v!q&Km*CCuUMwJ^3&DJK4Y@v2Dl}#TnUa@y#l{2 zHlTN)e#+u_Db{Y-RNvlP*U?+wwY{llc>UJV_U&UmyASmYPj22j4JNZ~|6Kq6`M$AP z@yyU6;Fq+5^04^K;+hRYe5PmT`re%l9b49{@2*+fUR}4bx^{hGNlj5%HEm5S+WL0)@0%H#L2Kpc z_`*qml)V!t2gZ(V-Z8VGb5G5h&1L0nCB-c@RqYK8J#Cu?`-i564<6Znl;??bXNM?ml>?WKC~$e4)F0sFS@XdNLk9DX`2vBkMxa+Y?H*`X<)f`R7=; zB*<(djIDwV&HQC(5ts!UnFY!$LXFLXOfCH7=DucTJ{EExQ@Mwsk&~f`QjhRPSH`BV zYp$zhuCHlfsAo;V*2d8N=bhHnykFavfAdl^_waiTi3R2ZrrfB zvAMUQvA4dyo87Od?5S@YXz$*S0Lab*=NGQLdhqo>-FWxY(88(cyken_XhDazyPr>d zWNdzRQDar@#;B+?Cwmu}ff2!nV516Hkn11D0!3DcS}gg-?Vw>uDypwCl{v{ z&L25`z`kL{ZG%{{_^1Y_cSq`JOB9j(OZXxj`!5j_UnIt^wYmyd-wCDm*1X! z{Ke9Z$D^~S${X4c?X~m zK6jjUD)=z_7Ow6)dQ&(Moqc}r%=4LxZzj)tK7Q;LT`*`0ow$0Jp1#JG?!bU3rNTvN z>Y$Xnd)mbMxa5R})|S)^ZXP(%yZdDCj-|~zPtc}BQao|?&D^zbr_R3}Ir@0xj*~@e zN6K6Fw+$TMcjEDp>t9Y?cs;)KV)xAFdl%o$T>5eH{8wAXt~GW}CZyFWtUXMO%&6_^ z68*104Uw5p4I(>p9pVN=%~E>!8554?3K;dvNIIA;`7h+AN$ec#lxeA%wY81)_06?4 z^=ZkefnNUZN;el94-aLqr)ykHcv)FtS7B~vR@$cOs-a!OXP3^sK6?Jmk@N3n&wM*~ z?x*wj|M|%`|MU6J|8@7nf1G&qL)ZReiPbIUzQLamE#UA-!Asw8HS(UO=2oumE};=Y z8M!Hy4W%vJ*%i%T2+p1%aN~)B0WDDm21gQ>SSvrHQiVLPogBND;Gp32jJ$@mt^Gay z2Ri%5H*^ma*EFLZL&*cCE9)=#d{#~_M!CXh23HAl2beR|^a<1{jACtLiVYKG5(HfA zoITzAlj8(cCMCWkEG)0EY*W{+!$Z?&Mi$NwOko&3Q`faQv9Q1^Bt&?TI17POhyk$3 zDM1o15iBuyL?}hYMtz0wX{8zt z?C26q|BIHo0aSiK36cKj8&l)+2#Kp|+g07UzpVXWVatB^ka{bJ3~OaVU`Tg@MV96lcb3*}FDUQJ%HNWc-=CbhIU%F7YQw(0NA3d4OkaGted1htMZ4T7bh&|2 zPvN8Ri1v!g!UDkFJ9xFB>=P6P$p$gXq0VKXYif;cloQsmD8z!fvH$9tz-cBLS|%7- z+Ijf|Bqf)(wxc8ypH<=J9mS55Sus|@s6|+%DpN{zcEOq;1SL!*TgO@RA5}kq7?J6q z0mTI@j5j}{9J?B^9MDG~KX4M_88aJG8+%JvXJaR&G3=_S_~g2^Eu#l_9ltVp>&3#O zZ;n6v@zm2_kKX=q?C9q^Mz6JY94RT2I4J2l*I3*iWgjH*QJV`M8yBl0vmF0wx;A{vs>r*s4uP7Es5aUew?&g9071#ZO- zOPCD7pAJzjOc;b;j4aKl1(LFnf6=BvrmRXcA%OD&VbURq{gRpy_%Sl6PU3lFWNED@ zw}7OLKoDvbLSe>6VdLozbu_92npiRrpCjeZ7r$o$}ek;Nh}Kr&TzF2vo>@#*R-I2oQjwp&M=>Tir|=3fnQFTjiZfgV03hL zIhags`?i*zflYlQU^2Y}liT;qZrd~6xovb~@6ehJJzz3L<@M>A#lAjahB`8+TBw$( zQQ0Qn5=pieno%%bG}w7ld+N6E_rQF>G|07)i}4SP1gJ4Hu+Z1ghY3b(D7XhwI}!@W z1c~@|Nyeci6&o(__*3TOJIJa8Kfibz&E`vGN}(fFxngsKB^3)zZr1QXi4x+EP;r+9gb<~3^t ziV!jjGjm&o+#26u;dU+2u4D{IxvfI!?uJqgBL_$v9t*pPObxIM`4_+-qZEJzJ#OFv zL6Q+16Vd1=E*0<@OCEF`{+(V8%YC$AEd0j^;KoB_S$C~;)ygdp`M z`8Bb%mpfwH?d1^^N!J-55581FSQsJ-EFEN0w2@Mwc~fY@aKVcC38^hD1Wtr=pSXCX z0U#1^X*OU&;7O6cv$xWXRGo>ANl(msBtvBzm#I!~mOAd&I|*zr*mMyNC8t zzmWLQ@OXC*A6mmi=Lcm&042$0U0~j9Xt@B4LxocPP?3;Jj0kC_0?H8QOX8UbMuEii z$BG#ea7I#lMz5G89W(>@SFkZSZ$?-zxzM9bPYP5c@f$$BsRv20jG(j% z4u=q`1zS)dCn6?fO;Mc?9!toK=z-;?g|v&1r{+)y-yimZK2zFAH8DkEsEVdD&aXIo zy#EvUJ7U5YhzB>xC5q$o+kxU686+P!-X{Sa0^Hz739v<^|IDadL`=(qO=OHSo$$OC zpZkxOLDpT)6(fi=P$f~W7U&IEiul5RESCTyd<*x#J);6r#4bzNiui5puRw$ZNk-T+ zNyG9Vhzfu3yf{>#fJp1o#O<4Jyx0A8fGtGrq86F6tlsKm}YJtwtB#ITauvr%ks<5hn^0YV*dg#3%!(!nUWET)&;pw9;H-#s| znBibXvs7(gE>R2$c0anuNa^R?+J#D zkfUaaWKpA3VWP03e^$%bRFF9tW=zIt>`NP$34tHq!8v7(<^iLTnH~g{0tYLgj*NxX zQD5%DCNLRzGUjv$BF64wY~gOI@DQ7oE9^&@kcjUw;8h$Uh-`*3TMIj%!04Rhg8H25 zw$!4v;qe7d9?@1d0T$LlP!2qTaGI`-&1nzIXphL~iOARzma`==wId|GH8y8sYSBiZ znE2erq@oQerJWg7Thpt0Q_DLNiW*~cYY_(qlL?8)0sfjsR zsd?Ec+4(6sWf>)PIknYUYpQbBt*xPzY5$Hrr}j?Y9y|J!67a!u@5e8`8$A2@j?<6p zh8Hr|@AOMAcMXYk@eLFj@-9vej!IP1nUJJQThQbHg8^q4%q;g9Uob0*c@=pvWF$1; z(0&TWh6bX6jy4o3@bl=TY@&MBQxKK<&aG>Eb^yp=#ItF~0s4jMRHAEX_vFd#`{(=j zEp8i|?;AaW^-^PZe_C-hR>+iNnmhXOLu~Hd#oM9T)HHXN*SD6|tjj7WP0J}v$u2A`oWp8l|STg1(_3tsM?s9 zSCgEW8y*PDJsG6Q`Zg~Hw2Cpjxu=wl4--*s?q`0&!m?D6sWQ{#tE z4~`w}8<^R&WnV+f_Nuzh;<9xW)vZk}TQ>F#_3fSlYyr2KK6zE3F_-R-+f@dfA7TR{ymM2o3hf1VngEtJ%fdbX<~8Jn!ce!=MhCY zeCB>@-$Zg=Q*c;{(#Fk-W(AoYxQeM&sD(1c-n-Djr@+cN+0-u5K<=Y!=&G%!)X}xm z)v=}ZicL>?tgmBbpk-;KWofK!rKe%8xmqTQO3d{dLSGJaUWe{~Nu?2OE-7y=!~nXqy{xKdP2-N{){)M> z*};RCrcOS-{QT!fKmN<{yUz>in`O2RbOqA=?GqaB5g6^}5$x#TrI1^}g=GwiS}@!; zi6p~geJyHoRxpA}N*lLq--{s6zL}+o`O`;ETs?Z`=E+MBPG5O+>Gq3Dw_agsedEsC z+xOnwyz}z@^Y=F%y@n)%whXE=05XqX{`}$5Na z>CyYYJ^A)uAAbAy`(OX<#%s)dzCHKw-Qu;!V+*HSx9?8OE5N(Kh~g5;ZLrAIxTJ)} zC2=7XFS*((vsEjpOxSB1co-;x%-jRV8=mX@WC z{^1?tQ@i%hjLs|_m_NO5cIn{4nS+ZL_b*;PxO9F0iCg=QKL9qFIP+@e!WV}xyqY=p zbQ;dsnOj^hd4=`f?m@N`p7mwch$fi0Ia-H$dZwpkw^lU`wQrs6+_t!V_-y~!#hnw^ zM;D)rAOC!8>1p4=YjqvdIW@Z*dJk`#xH5V1&9S@RFWmZW>cUsUM_vpbemQymyF=%` z-hKE%&BpQIm;&@psW&j#;KK+hQNnVV;Y^8yKoV=39Vc!Vy}kGqqL9D*Gl@2+hQ<#4 zvr+P`O)Wk@F#ED^==R1f=eLbM99#J6^rL^f`R@O^`Tl<#x%Xk+-ua;XT1^M9Pqd6a z0UxroH}eW`3Xcy+$&V|nqYywj07i$cV*s=kOgF%e5XQtoTbQ+cDp)=Gt5+IpYEqH4 zp$FL6HzljQws|v7cC}4gi^?}f#N;_R`A{+j(12<0r>UrbFzL(2%oOWFivmi8zd z;%zFNI0(WGjTIJFG%?|i=U#SyAPWSsiM0#St_9gbz5q1g!cp(RQCuqshAK!(FKnIgeD3ex+apA zk6hotFd?(HXKz#g?3yie$z}cC zk+pVi>H5YV);0lhGfyjpuf1yssIsM{Gfp|WdS+k|#xe@fcI=r@meVuWfTN;iuBmIQ zZRnz90+()Q#ypWyT|(nu#6G{Lf_WpBlRwDMMU>QrrULZQT5H&8!650nti5QcOd8Ur#F+ z7j3yYhLu#8fMt*k5nhnSa(mx^nEayr=JoYk`g5wAJcDDctX&9=NESIx+_(fqFew!} zg};VWEdFFA(Jc)TpMZ2pfuG1$q{^*GXGHug5*;D5CT z3#E?$WGo%k49w`Xqj6BB4Jhy<5wwZek-(c9e~M65Vt^CSvQq@%T#^KP6kZ8Yh_ngF zNiG;d3?zaXQJ9n5H$;{vR11V@lTZ?n)CR~d$qLC0O)Sj}<&w2AMR1TA3rm??j;j)Y z46>=ZT-zo{Rtnc?)h8ptL|>ATwKa|N`qbaSSgaMu^D5jt+(W_wW8;;co;FTOOM3;F zjJ2aZ(!K(Xw6`<2rrp-kK#m}ZA!rQote8W|4h;1TtgWm(+-Y!Aphg=WY2oH7Q`(z2 z+M78m6<%&OKAx5yt_pWIYfo>dz+lhl7}xL!r;t$B&=7~<0Ef^Z@5K1wMqHq zDaAF!lG0XRSi7NV)6TB`1M9noE7tZ#2Oixik=pXb#R7}*byY8)b35p?bS6+WHLLYqc<8* z97fV)@Ct0Bz5Rl)A42#N>`dgkq5vxfxipFd!3zA6RZI+iRi_5bN3v#e6Uwy^$b-SH+SCT1cg=G*6H*P9r{u3Ji3y7!#3&)IvefBozK#RDQC8$fV0 zromp*)FJBu-w=&Im|<~faK;ryks5;@YiDOL1*9f6E<5O}c+$z@=^KEnqNXYcEpR!|A>n)OY?3A;Q;1$*FTe{} zs|b%3FnJ;Ctt~v8aE>-aqZkB?E>#N?b89R5m`p86#N;Q!xloSB365We?n1W65ME=r zgp=f|{_2zsAjA2pnV4fiZSNiI;2ntX5`+{m8Dmp3epw((NZbG^D5GUfek;fZ9J5H< zp;z!j&;tpRA+?o=5+a2aLt>uDR|b*P%F|?Cxe5XWQwEI@%r}VbdLny;7lhWaxwVbG zlNUiFC7#jhzgIEq5<}S5Ggj(uq|`JUM0#Lofs+JA1Gc4p$5TIY{IR35OB95q==$ z_|mM&6|hA2lUUOES7-}h&X8mvF96gCHzEmJX3+;Q6kR5QUBgW)kabZX5^~LgJcGn8 z{3Tt{m?koJb)lCc*fqk?oLC+t2j?b5W`_aqPEhYyFr}Z++XyDZV~e`G=+T4!BOnyf z>BF+g8F5qb$gsKmipg*a(phlKJaKZEg4q#IpM=ct*mA|VZj|*|>li}2SXqhbW(^k$ z1=mG-S_QttTLEuK)SF)~m$+mC?hqG*f0yXxeF29^)FZY7eut}s`Ud%moL9_R zjbbw?Kd=B82pb|FiNw}kaH<26(~ySHK?2tW#NdPE_z7<)jzMC@NPEq%2nok34wnz& zQ^oX&83dLQlPLA3apL?w-!q{MIVL0UBHoJs1T~W0S-gpa$%sc)pfrNODZRPiu!K;QzWYthK2gHkMIxv`l@hu0$1IKv`RB@Gd+sb~F9d}2>j@ntnU|A?H-2h@ zgd;uOL~deEX$$^huK=-W0VR}xwg(qaTaPe|Y8oUK;+apxj*Pbefd&bW7y@X8n)Ru` zh4@|!MFsF`FdSOLDb1+r*lOrGY8pDhkkQn)($+_K3W+K!4IOK31AAQqJAR_6Yr(0} z9m#4eU?_EVa1+QgGXI3c?1Q;gok=-0Sa4z|YHjCZZR=-l>u=*6=Hi{?9++eAo$cUX z;u>1-5#8>Y*yWkr?wi~iUp$yuHIjR9G^2bVwQL}zY$UyEGOc1PDz`l>v(`VM81>YE zm^{D8bm1Kw9ftuitP*4i@n%X+FG^0!OG(ek%_z)(Zjw?|oK{wpR#leMR9@5rEHg5B zZg^&QX!;U9u;eDAryuvPJ!m?5wQOuXvZBW!EY--#!@$M{<63!C%(KiR$$iUH1F%NT z)WF(a0hzS}qGJ(6QP5&lls=;@Ct#b;4yY(;Yp7dU+WH4YrDvCw)^viaG<1#BbPiT` z4%PL}G!HI-$XpDli!Yez8GpAD9J`IoLY_ zH@kpZNqJp*VMTgDNqkynL_&H%L_CZ~ZVa{z?h|k}QNR|_C|coS0L##04%SC7fJ~c2 zn*CH&;d2$J2(+&&)7EQ%&VVd18Nr{1k=4nyd#7%Gxc=2YFwQ^z>Ez|NhmPOq8{fuU zslIjoVEuGi)nHL^TTX6uQerliKn}>A(R@m?tO9@x?Ep%`@yFWUKRBYWy0LS325Xx` zOQ&bow&&L`AWw>E_2~3k*Wl5{j;Zq6zTA=~8nO;H_OP|Vh? z=e%y;e$6YG%*Mt0r_bL*6a}qX@jlDv#txtC8$Z(Aj>2$xxL>q~gQthRm%nFJRCIoA z>-5Ium$zR0IDh&^al?2>Y@v&bKPCjati`JOYAR-`>UR4zTr~83)O9>m54b36*eI)- zsi+t#DQGF~)!z5Hn$lj4{hZBShK4EvEqlQ|)l|MvWu}$re)vL(LN4nuWp~O|^4cwX z8DS632qDoasQ-bGEd(A;pwYCJ$(Ah_1oWEy7tvMM4s1fEFa&U z9A2s|YESS^3^H;I)G+bhujQ$v;j{mM-+tX-4U1?!*JR7!QlIRq$m;s^jze85Yb&>J z-Td(I+0Rek{nN|e{;#jT|8LKJ^Ispn|I4j6KV5qC{@k6H>o*^+UcJ?~a3m@-Ro~n| z0aYym5J@PV-IraQ8&!4BXBvAx)!Fxjp`rraOwMXXUfOnnMqW|2k@2$hSm;#&F*czH!>lzzlXs@8EwO0u= zhC(&irs(CD8u^KFSVLK{1rCF-iNtpl$hcIeCM2M0CX8QAO^6}Q?Cfk@TyO%SDLXhS zHaWkrs-wGi>d45E<*DVh*^?VbPM)1#-8{N>4mYS{r!O8qduktL z#o0SQ-g)=0yN`aicKOxfnY+~u<3S;5j&|;-%i@PYfTgEqWMbe-s;8T_UohPzMR{9IdI+4 z2tk#BpiXx^g*a1FM>~5TZ|}(1*zA<#+%USg0;AAbN=+}y&Z%l_>@O^A$jYwI$ZG8F zKYnEK^7!oeiMdO2#~*d}?dBIB%P(2UtK4WDxHG-_e);Opa2-!P_+|0t`>CDB`5lM6 zQ%mh5GMwUad^5^|va4f@TVnGX9Q_iFth{J2L~M;ck;&mPfyRT&>i*9^htjiu&nIe% zUudfCH`dda$$T^NDsed}uYuiB3%SL{+K&WBOUnQq0ALxoh{2~A3l%MA-j_w-B*i!7~eo*SFnK78uZp%YuZ zbI0oj$KrGH3~iyHh{CI`u@w@6MpllrX@Ie_<7;W_6ZX@zA#?^T=OzkIe| z^|SqIpY2C6)Y#l5FuS@tyQ;@0JR5T*LqmHtWo@{d+?V2fMThi0{tCgC;Pj%Jk)^iT zovMNLjOrxrbb3iwyuFLp7eQHXlUpHMlr}r1S*A8qZ+*la4l76 z=b;z&lP`2W+pD)vN&ky|+K8XfB%z{WYM}3IWf>F_QdC$vkW(@co!A_e&=Qx>9-Gh_ zo7~#eeUjZ|YV{s4;Kcfa`JGooE4NZ>$8}ty_ZYZ+rfH{Y;$q_DYwh8uYh|N?=AMSi zKAi((-%3WtA1UC4Cn)7YAOSE?SKrXd)i)tMtFgUm_)u<3mt$bm0b^_UYeHy94#LpY zLVBX0@X>xHF(6ZEAK0s_wMXZ`r<%$itL*zo@zam?(X%8$G$MGGhtMLv6@euML>M~? zbiwQcjWPA|_s`19XlrkrKQ?mi>dJ#RJ74{L^SggKbN|Q1^KU1Y9&`?!E3Y}6l+qR) zRN^Pg3USZyFb}rVw6|0-#hA=O+0<0U1W^%7eK#w!AbZDT-;nCevZ;Xu*lX|R&ONQ{ zn{y9KQ#Z6%P%}|dHqp|-+r^EpaAj>%z&9uaB#cBOJb52~@&!Tv-|OH6Z-k6eO;Nu>N*3U2>1+!uV`ycLYN!d}mZcg0X=G)L=qQPawf zKVMl)tSmagH!&?JHOo6L(IqU>J3b*KGd(ynJtQ+LAT^yvMgOGq(Dc06{Icl0(%6FX z_@eUolCrqc@`TEog3kWbx|aCr#^m}oMoN8KMnhLpbxU$(OJaFbY*~FuRZCh`OG;To zT6uj6P0&RLGfV4oE1LlNGD_-`3-MiQ%Bg71C~nBBY%6aV1dyq28Oy8a$SkU7BxF~{ zrdRk!X1n<$I66ic>AUKwn?s@0+@p?qjN&JsWBx&_k?_QkoL0!-;C(rI26=_VIr&D) zg5#5ms`G2x4z`Ve$w1PBD$_r?L`2j-ajau#x~^l0*7bt2hSaR$u!sblodwh&c1e+~ z@SbFLs4Zc)1Xe8CmuzL0cJBMt&^}`BwC$YWsd&o&M-Ya~AdwAFGNY$SlSUo}AIG_17|mX7?Cjwj6bXIN$tMJ9 zEHXPYEUPRKYysv1FG3cUR8F|X$RBf&h6n-x6taC{&m{>KJc^H54ftNdFvJg8!Pu0g zZ$!>39)CDB%)JJJkGeYMrut@>%LDsskUVm1v}I95ws)3^r5;Nfnh@y<5*eW&RKaNC zN-`0kUTk*m{t=NWIY>r_#UzJB#Jae9**Q3(Da4gz%D^u)06Sl6E@he0+FTRm587ck$du}e08Wuo)Su_)ot%?>v z!M$N>`6aFfca*?C1iCIqC+PeFyW|tObl~|QEkGzxL^x|0Ab=9wesWBP3oe1u!f2bN z4DgEI7YK&Hb5y{JxkV|3&;bk#$ZAYQo=1b_lwamOnHN%PL8_tf^Pg_c0;6C-mcGO- z_@A60W>boxpxG$%hr9`87cnGEhGQ0UDSgRjmJ7mk%TWvYyUEW{{8%CsanX2BZfP;s ze2{c0c%H>o;|!}0LZjKBY(^d{Vy@|8wxSPX&v z3VMuKhWLgdM|H$~E|l~Hpvq+v9V?i!sj6VM#r6c54L}AQRc>uB2zB^PYiR9-X{n*d z_(Dzd3l$AW)D(IEqnJ1r6ZSIx5WbVHnS-94r?E${k$2z$d&fNov_$a0CrZ&Q=gq-z z!-_Ly(U1y_0+2x(Tpx`{W1@ODe}88mA0c#xauj43(aEdKL9)njuX4bmwtzF9q`k(P zfN2+$V;wUGHAB-c;C50sp_+-=I~9Hva0Ug@+$VIxM4-*`%VUL$fug2?vW}UOwxx=$ zy&RK)B%`KHY-X%MkF$ocsw%JO-Qh%Fq^fQ}-H=sF?C-*i%Fw{V6-kY7N`yHz(Wzyg zK?zQ>5GNNuM@JtA2X9B0Am8A$n8Y%7-!yaAL{rxcTi*)j@Mh2CF1Lghzx0lX-0lQ~ zJ`PS4)E+8ooXu-ElHYVJw|)+LpuqHc?}ReHxYB^QLjU-j;H2z;q)fkr^w8vdsuk%4 zH5rA~sd?q;`DJWg8JWeIh^M8NM;+B)n#ciw*(PoMdhS;^neNl(@DqJ*v8Gk!Dqjb{pVW7pQ!8Z z(KA+svt(nhYHZ4MvvO*wtD%bL>g)j^m6=shSkeUGfMN!W5wh~y_KA*>#evBagR>`x z<~A6hF_2`?_#HdC)qi*m!_d0nsoc6&EJ zkeNd?8WNk}85Bym4jK>Nm^lYV7S%BjVwxs^lz;7sgNgkK#R9notO8-?-j84-kkM0c zF|~5`2u;qY?552he69*6yY1n#rQlf#UN1{NnDy()O&} zgQ;l+kr6S-MBp|8v0Gh1k){R!85VQQfYABDHL|t;(BRDS*gHCMmx~=9g$==|nf35E%gY-=n?V-}^7Vdy3BO`#(SV@=v!P{{Gs{-|k-gYHRz|;_}V8BfFD_R!0UFa#Jb-or2)j zJE|P8*{5WyplGM4Y^R{&tfb|sZW5wx8*Su~?hsuTTna2R)HuH~f91l(H}{|Z@#(w& z`uzPrKY91JhhNh!^aJv|_#9n*{q?2SZ%*C2H?VvxxuQVJ!ifHHmOfTymNV*r4EEjq zdq3Au*rTJQpubPSL_x(`QO8-u%w5CY*T5shIw;B|GSNFZ$tN`#l` zrL8u*yQOTjuVsE=_WXqlFK*oV=K9@lb}qa)x^S_#<5+9WczITHSyp{cT4ic{QD%Hu zdQ?$jNLG|zlD}(+o2|Q@u^9%#+Og`27*Bfi*i6Mz zO!6=1sG{hmDGFpT|K*sBwVR8r%*{Q}KQ<$+s=cl2(A1&htJBM;53inC-rPO0b!lbu zB7h8IVeS0!&8y4ju7gspUw(G#;_HRYXUEQexqbf++Yf$T-g!AVyPcfX;x3D}z-13u z9NeBBadiXSc6XSxBl?trLPekJ#p#7z`~7+j^)g%$@2E4 z;pLl0&c9r`@!i(5znp#Yr=u4?9NBz7b?VLG%?~H8{(kZDw=Gkf9^qN6|AT*?sem(>t#l=gueAk9ek6xhIx7N9F0;`=f-mpRJi- z48%-qbP}0IB9&pSprH7Pvf5sKV_kPoSsERoLQs7G@?KPAu8o0lDh9VDx!mPD$;^u!c_DMMfxBYi_)85meRkmBi) zl$_ekayqkgVQ&56_{v7l;iFZpogRT92=)pS2gzd*CNA$RcMO4hBZM^Ug~~1twr=iT z@DC9OHgj;$v$D}e6xYC9+uS)kwY;EyEIh5=-ZNgu$Q4;yJe}dqN)M4h3z-1K<#g;^ z6Uy5<=PwMMxL-GXCa-2XF16mm(pOCp^%Y1DXtP?I*}&ED$ID5i9$Gk(NTpsKUGfMb z4W^!~jlLcleS{11=lk&>rmbIy^n4Dz&sy+F@hpW zi)tpOS8tE4-mV;4uN>a&TD&{G{dW2GZ`+PuOsyX=@{HbNoL^d6aBgl?Sy^sZcj?e@abJJ=&`{~{P{}}VZd*e^dwp_saYTMrKzg!M zM2Mlglab7sMmt3lqkY)yV!mu=XX@wYnF@7_j>Z#{=dUeXyMN^BgQZ(<&OG@ZBf^VM z|GaYU>*1;EWu>!;aV=qig?{Ld8F||o$y`i5tu?JoRP>PKGgj0_!_7chS6f*}Pue|s-KpYZ6w*!aMhDBp-sS)jL-n*+bEZ)L7$W5LR=ZDpit zq(iHbmZ_1Rt*M#J(LOlPgWu1}3(YN#Dy(G06jnwTR3w(wrc^eh)-+``bfi|dVseyR z-k4BapH$SCP*4v(nOWJ9QPG~)(3{=RlU|4W-b8kNUp7Wa%|n^BJvj~iXz*rKwx*Sd zkzLz^4oqfwM^K zs3j$*CLyytNdPjH05Tr_Nj8q5#s(f*8n!A5x`Ip1wjdDe&!p^1N;%mXNG6QU(cEzN zkFj$LGP88IcJz%%%E_;8sc52CeFop9)`8i<$>T&gLzBmQ$L0>U_E$9vncvLZikP@G zODj7%C5iWVXJ!`EfkXfR0Ua1nQ(El|&7EAmLh=5fM$A-N+1T3HJBt<@T|-Q81UE)x z7-G35qnDr<(XS`6d$cwsC`Keu95$>-vT^)tRMAfslmOA8M$n!2Ux*aaA1V+E20}k5}+pSWr#dQg*z1Xu(MBK2+diny@c!HpP(;*#t`Ts zIt>gao(55>78$LS1CrUXaf@n#w1v|J#9OhFgT_#D#f=5|UoNH`iw2OP{4E|9b)lq0 zgA#iIKV(pbhCIR|3Cse5M1qD63_~=9 z&cQ#-IWWq>8MHVk#89*c?Qj>;}fu@NOElWcAQ%zIeeFG*y&4|t^47qUZVxuRT1%#l$ zD*_qvcq!uLXJS7xG;{Y0^$3izc0g>?6W45S|B!&t2#_?Ciy%#*TmglEJ}_Rv<_=7CpWpxdV~l3P`Yw9Fq~P zO#G*47?I|VyA|oumFd6CB00}W21C|tBw`_?t7t#ZT<`vil z*HMxj2V3AY`QqV{AQWa)NZB*Qw4!x$0LqQB=vHI;#N3G?zLA4eEclF%rPp7PD>)-Y zOf(=B&=aq64=DlHNHCrFhA#np@xrbE&q|=6=x8Ck2LPxOpd;JI5Kjq&SDw1!N2+R2_*bn+VM6 z4$kU~Dd@|r9L+m8o_BDfxcO*d^I~E1(TszW;kg~YNi{yP<-v*NAt@!12+`-1gl84S z=2j*Z)n=46Cg)eu@S9aq%PYM<8Cj*-+2z^UmD!mG3vya&Du&uyW@@U2DvEo{ics?y zuWp)a9y-%|6$*HNuX=!Bz#SIN@!`02b zv?14Z9O@W43MMl=w?2C0%=p44g13XXFU@U?&7U1Oyw)?b(mXO#+yuD@8|9SLoa&mE z(T0KPgMDK)JrgBO-MQ5bnWdEoZP6JN6cy#{<%tRbn+4O&F2h5?ZO?5ie>$Z95)Fbt z#r&J_N@kbZi(1uZ1Z2pvv96*om)|tpySQ`w%8PT4zrXV0mrDkaZX65vi#nlVbM^BHs+uAF|yFX#uH&XfHSguBr*2v$0qaB zFBI_+pnlGSL-+(9K$kUW474JaBd(ihC;arIy_8!ep$xG`Nt*~)m}MRs64Wz#6xn}F zEv;O=Mc5e-lN6ee5uK8UO&Ff$=>=5~kBO=1QfcX%Xz!oK!kBUx<+iM{_JV`G_+aLh z(Z1ALT-cVK(O8hxQIgwVk~>&Yh7Quop~WjJm!9lA|IOmHhdn1Z3VH^-6B40?6CQ}( z1Tn;sOC*^uP!l2`urjj=2#Tq19T=KAI(=*ngDPyQHg@lBUV1?9(#1Qku0D8s{o#9L ze(yf{miDEG&%Q-Q1{dtdU;gm;)$bm^{^R{;zg)Tb+s$)tHqJgjdFsLVp>th*#~T_) zYioO{`@=`F(>FF(Q#Vplgu7y>sDwEUX{w#7mb;q1m%3TFku1?ZGRrTgD50*k;?U^8 z`ufJx8+U(t^zzS--u&s|SHIkS^TVUBe)sspZV`}*6RH*b&My57ICm{L`$Yi<51 zS^@M~a%BOEx!Ocfk|?4eckS7u_4!_-Jt}5uCyntSLwdg?m|nD_*m z1&3Nh1zSW%+s3APrWZw5m!&sN^e=C3KDv1I&F;$$oEDUs9g&+5 zoE+sJALE-8?UNYk8z1T&?c);QV&i6IVyX*=A6EywMlqNrK>dtEqYxvw-0WsYpVIC=S-g|jaQ zW-cbAHrv{V8R}Z1RST7YJqc50jQN5hGfHav8++zDMo(brHL-YY=G0x(JZ9G)4;;DH zJhEBcxsq2i(=>8s`t+0e3vW-{`sv)$|8nZ?&+|L)=Qh5YU3)uq>Z`e}59_ynH?{E~ zDzBczpVeMaFC<)paGn7sBZkB#6;&H~frE0S1XzipmC&vbnjTyYux-(vu0(XJr3){_ z$j(sD*3!%sD>RubJRR;n`AE|Mu4Ks><(>W0BqO7)R0)H&Ix-**E)qap(8bXTBX+dUoi{S10cL>B8IpxcuQi&OZNZ?}=NfO*1y3xu0s= zex#`Vv7$QdC!+q2mjT)=#28Y|WuMZgnuZzh0hG?TVYXJ=P82Uj?aacjC+HjgxZo8DPTZgR9;YQp=WTa zi)Rc*NN%!tzmV+olFqT^OB3t2T4pY$HyulFTr3&bte)QKS-m}T;rZ~XYiUh`jxp)F z&c3=%o<^=duHkVh<+VNYOT#C(`c_W&ojg5yc60gmot4}7XLqj*p4@6bvNpPQdHnR% z(Y1^H3#YoLj}0DO9$Z`+SXmi5wbr(9yz}_UzO{|9b31caZmvFjwtDaBsr%2?9=|;E z;`Qds7gs*K-+u98{lUYvdym%cKUlbU@$k;MnXT>a#g&5-GZmwgRbw;FbI1Emojr2x z{>l4q*B`%MfB0_s#+M5hUyhx;(>HgqZRl)M`>E>6`SkcUU)NMy15Y%ataMQ7bh6g9 zG*HpjRa8M3g;y;lP%S|wpun%Irf+QM;@}+T6Hpu)*Id+ceB{J^V416^Lg89QleS!imRP@0!?M77CA$xKL=NnS)f6paW;##Y4PQtT~9iHVANFh%Bx zB!ZN=^Ge(rqiMYk6Iqnximr&Lzo{ADTS`$LfLXQ$Z^DgyvQ10K4c{7r& z1jAxYGcl&NP7DkVLl=N3D=P~Z3I{J4>zkF#-PF~^#KqatL*^D7WaH_fZ)1lHHN(*- zK$2>S2u_UkiU@J?_qF!+u<~-Z@OF0z5Au$Q^ofZMPEHC*PYKVry2 zQrVtR+MHC{oKf9g)Hn!=l3m+X&@`A))sLZg&iB}_Hi^5|I#E8xd3d;q9~ZW`$1crz&a$iZ*WkZhp~bw%)?SRL{o1z{brl9Ix$?x}M5r zJRK%FM~{HXFa{1S^iRyU4;-R>sidYetDrhDB?m?yz%O-d=2zr+B;2CS#}Il3)dOWU zT>~>mN6%mf&j8XB(g)g7ggmvmwV|OoEC>=aaU%$rLOjD{vpmZrb>bV*04K`a;_l)* zdZR!#s8E3kkfxC{!lH))qpbt+UI~#O10%SZ3`Lef4nRX^uQKTpiY_{WB?6NlDv6b? zm6Hb|;jVt6&ffmy{s1W)4BA-`OGt3Iw*81Tr`hd%-?;CMg-2yz71Mf&2% zP@0 zmz5ka0hoeUz)#*5ltx-PHF*{1i%NvHKxSw@0%uTF)dGzHHA1(O#D^gehy$9Oj(}wl zoY6A_mJ!S)Z9S%*ioAvnTQnHH(7F+R%}6a78XGyuWMT0TrL0_hVGx->AJWt39eDcq zHGu=rGOH!1Yb4QJeA0ht9?XSk`GNT$`c1%M_&>pm5Kp)Ki^-G*iGWxZDD;EG8R%)5 zn1IQ^lRor{-^Bf^PRYO1(bLxG|Niz2TGccI<`i!mddCIlyZ z3LxjRC(`g_YHsi1?&lE@j&lLrUsMzzK>-7zt0SeL>>1P=G&wK&(Xgqqc6BwgcVgPW zE`$m<8MlN^a2K<1iNpVu^(O%l0tpbEGJl5xNc_dzp-j7PufSv^uQxDZ)*o&Ofjo%r zEzVvva|wEe;BtsKMBLJZB4|%@0g;ld2UsLhH4#*a`04L}hFJ4|MP~R0Q#7H;BR@Mi?j&B}nMg%3 z`ECE}tFSf_cs(d6?NJ;a=fx1KJ&kf&nzY!9CM?)KwBzH>%+^i^Iv0)p9YK@%NWQbk zaTxiG$kR-*j!1wE-~2k5MwrwD@Nhq9YEu;;51-4WkoOVG?@w{}N`EVXFaoaOu9n}t zg3|VdXej=KD!9~vD`zE9L|{u2)1eD!YQP?Z>N~d++%{e@`xCQZXliWhV&(3K$R6Fz zcpo@=`l3l<;UeREJDDE~ql1SxZI8HTqJ!t^8->LHhBW3u!Mcu4fTaK z$fu<*X**Q}0EaLJhnYwZlBbKemw|;j@MN9FbZk|@XS57K zdc~T|k|&W3ltBZfFpO?G)+ixg12xUm&dS-}I}AUOg20GON7pbrM?Z5LSG2HJP&EmfG)Y_St!hZai(n}e7gSGD z(JN^^n%i(VseCl0ay+h}CoZ=QYI<~Dby!AmY(YhGX?<#GLqT18c6mciS$$4vBO{}* zHmkS>I(kN4b#7r(VM#}I%}7oC2&$@?>D4*u2lI1Uipu&bn-7zlw9j7ZUb@|~bgSa< zc3SUTSanBGLA6745_Bd-Q{z2)+I#i%^&CB%LXushay$}CeKQV*6}EV#R{Cevh8MMZ z#OEX33>k@qS4U6Z#tH+uz=)89#JF5+lAy{obdJ@uk2Z8ow+=4!POkJ%pB$W78=Ko0 zo;o=;yEc62^UUC};L(%hd{)0$CS zosgLunUEY98Q~~%g)}I_DpnPi8WvD#2_kZ)#y~>EbI464fCYx6{J=uQQloE#2S-3m z&cVj<<)O73N3VZ*{>ASuzxu=W?Qc(=e>r{RT1VGvc1~}0W@~JTupHsS(V?KCf})v~l|xWSTuDtEX94+k<$ z-n#sJ>(b+m^Y>0{TwPkdu&{J)Vs5o}biSc&FgLdnK^u1~CtDp;XCqsGr{F-J^t{5J zx#PPRZ@*bsyINe+7aWo6>=bCKXN(<{P$*@w0rqFfkd&@@)PP=DQp6Pl)fVsz-G8FI z#nt0-vRv?B3QeB9pV61W5PX3DWJicjF?6}e+zfQhog8Gr$QmUE#HEBJW+r5nB~oPqz;u$aDMTt=GqIJnLWEOl@d1_3->cMg4OqJfH7j;+bnfCc%P6 zc|VJVjkRrLY*KUg(5NKvJHK*n_3ZUCJNI|5J->M4`Q-#mWv^YgdAyng@J`%iv%>Dv3#XP?i`T^k-fi#|3zYsKY#`DJa?>AZcyEX{3= zwCRo}*`sMwQ5`PiepM}HWs?I3Y&3Oj)%5^LWO@z(Hh~ecr1-$%s-m$&!&@7tpWe9r zo4e0`c<|NFPrmu(%@2Qj`_tcE{`l92KmPIBH{b8PdAIuD?$GLTMr|d&H6#eq9n20a zzQoE#@E~Y2pQ-QNO9usZ%m(|^4fd$AyPGMhS}JMTsuDwq6Iw@PZs@eHyI{F*P z65Qi5Li74srq))kubsWSasJ`bi7P!_vw6woVJ=~zcK-1mVUe+YkC zoA*v#y1BY@4Plw3vsX@>zrTLz#m>ENckX|```}01h>o5XI-(WzM}xylFq+ZUFhajk zkDZAa$ulH6t)#kbqOSW$*XVl3@Y>-Mw~wBC2A+e=Z*9*ic1zh+lT{r{y@xMMtv^}V z{jhfTk7pkIjb^2z=ReG>eL1oGVq)nPY?;+7-=Dtyn~I(z)?VSD(p2ogp+I9qs4Tjd z_K89Q7%-2DAeV}AkZ6|KL%1aMLQ9*PD2Q=`N>u|moapTl-D;^o-KHJF&{*Hv%1VY5 zc0)s7R#pWdc4l79#O#S9D`)4IH+C=IJAV9JSy79dU5LGDkgaiyt9`zgUsG)QbYt)J z$)&G*XP#AdUuqh=)p_`F_rmMB-CxeX`j5Lm{y$g0{U3)fe3jESrSBa4(HH6;eY_7! z0RnDdmtU|1sP0qORkw1r4o!;6K3G}P-Ph33&w5hTFql)&AX!ORP6X=v=_kBWSP_-t zeS~K`VbtVMNf7)Qf_6FrOzoT?k;{T(lZxufTE=}NOZ6>+)U_S7^(aYthDIeLH5Qwa z>lc#f;Tz)uHiuxuh#rhUnMwVn! zBoU+r0+0cmfrp80fz&R+#ESkQxdfkFQBYKn#4RC;+RD`HE$rPwknssiDD(|Y^7M}i z2#vFK_I2}%$*AZUT-u&IbGvQ!LTc^dkevRQibI+0ijcG1u_$y zchEI1$37w@Agio#YWc+Vmlt0Au>0b-TTkAv-+p!a&g(Px-Y#Bxa_r*Mjk_OieD#-` zU;kzO#>+FeUY@)6di~bZGmpO9eDe0}ldm=&igDuhv#n=eZ$Eo~`~4s9efPJUAO3vx z{VxxG`iJMg{PXi){`KK+|MvX%|MLE?|MBF9zr6axKRx>4uQxyZvi0(}YfnC`-ha1n z_1V!YPq&_azw_*;wOj9w?L6r{vQyEym|EN)kyIZTRvHmr868rZ7*QN7i*+=2vC^}$ z*0*-DbT-j379pDGX%=GF&>BhJ=;OocM)X~fnOpffIK(=;XNJVLRCcZP9lJTSdS`6) zdVF!SzN5D)l0GJmTDsN;4wwP5q3T0hfuPD9(1fKRcrqf}l44r6D5*k998UNs_BXjm z;OC!{YY-pG2@!G}l?+a##*0qpqQ#t)r;5E4RKar>?cIwYR)$ zw5(&iw0$hUVKBdDD5t7Fv%E8-xGg!mF)^z)Df3_=FiTn$G?kc)s>syxh{RF^$rID+ zViPOFqw<5pvZ?*~ho$=mr!f$q4hl{W3QYC%i1Cnx`*=tD`^EYB#(I0l`uN0odBiw5 zAcPy}LT9~GIIn&INx@;MjL?X*u$c7F=(Om>yabGvQt~Od#HJL3)x;zhC1q7}B(W*w z5%C4Sfyv@ch(w(HU1k0sUm-K=b#Sh$#Zl2;N929GVU4EPK; z5m69Bo>j4)i*h`x_&($&aHaXxWr;+U6d0!-4MRf>W1$*^%n^fo0%QihA5<9taL`8* z7SIgJl<1bgjdAh}aPbes@tL&U&cy?a8Cy~zoNH`?8Vor*m2O~dxFVn{kWR>x#oba+H~%VC4e2)d>K`Joh|uIcLOgITJrlPmATCn6idKeA0xQWJiFa*H1@84=8V zOodWxRO0^UL(qt%M?>T<94(LzKM_Hq1lRCrh$je@6jpQOLsYRCQwN9PPb4-7X3_$t zktRYghy<5j3u!UbhRxB;AtB;O1Vpc=4_8DI$_A&Wh_8*}G~!6MKB9Szx+raI$o_+7 zNKceQI9?V4K>W`+2bs%Tp_Y*K)FSM8LkoPQbI2ig=BH1 z7-YokQ`QcSj&AO7u8?SBe>66;b8z=}@eA_^ior)RBsS4OCPUT($thqQ79g$+_ou+D zj7;Gwa8C+c&d~)pSB@{Sosi>;1fR*3?BN8YAYlsB?NFLT=zNiRG zoj6P!a|);!aQD)#Mop

      ;l7VfRJabmA~VFxNJle`0E5&vP=7SE(=xUJ%waB|jS1=(A(Yfx$L334 zyf6|`*4T?}rV49<35;1Z1lTpyv@BH)7@`sbAj5VqcX*+BSac~fd3!-a)!|GER{~R% zNBz9QlKe484o!A)54EuNG&Oe;fU1$1P#~x1Os5kZL47L=OLr$(l%sFDZ+vY+;dpNS zN=ffV)yP(E%Y0(lV0><8d{!%76^!)!?(EW`B9u(pkET^kq?C_mR83@6kET`jM(5Q; zWR>DVm{!q5BXCAVUH-x5f~w}M;`+>zMp}TW7N-Nt6gOlPHRY9dRMd_fY#J-B>cTK6 z6P=lYrrNq;{BGKYPPLA2HBVpYTz=59a<6Xja{0`e!tur8(fRm>Hox2goA7WQSN8+< z?izMJ+Rh=`F5!CKar!>-Iv%n5UP(s2sk*Z01CCxQX4a~P#`ps0p#5X%>}c;59-f?% zURrvvtGQ>gp=%0EM!+)tbL~TOorCjTgY(_}M>@JEyLx8ZJEz(@ChMAqpf{9MHm0WM z2L?o8A(Wn4QC8gvhygNF(%73{(?LBYE-g1KI?mJI&%)N4@D4y*fCFTVqHjV_Qc04S zefe|9_wr4Rrx4*aEY3}A-8{mQa_jor51*Ocd3O5oPdjh^eBs3(w(ftsy8V27YP-H} zE-$MmF{U~uqA)QoFFGY_VNqH^clSr z8lnMY1`Zt`o?Px4L?dOUwq;n*V_JrUnN;6I@8tZ%u~nRy7PqdQ*uArU`7xbJ@_wZY z58mv;lezKg{EaVnuD{;A@Z{|718jqqPhC8Ia(DLV>7j{Zt=(hA6%8B=L^K;c6B`|4 zFc}}mprC-fl8TY(g>&mW_xmPKQUW8gvbA)D{Ed|lvayI8@^DE5kV@?F41t9T;N@d7 zO1|eOJdCV-@^yy2UErm_#RBgVs~U@j{13@A*|pi`ga?bar)OA1NOD?ON>)T_ZgO5( zdQnwf`ydEg@xhkz`i_pl$&SG(^o8o$M=RUMvk&&=RgaX^PZd;;CgzALTXI@yQhZ)a zP*R{%u)Cp0pmkV;EF&(wDmQ@Z!lex&@$M+n0GlW zBU|T3{?-ByPSMR<>9^V^>;z5Dv~qx%!5S2Jp=Ox>K2Y2vIzz7OY= zTvhV=A^YQIhA@NtulgPZ6fSi43411keM*LVl#KW8H{YvfxlhYxpN^xFo`;rYu$6a$ zZ$fQp=i+ zS=qR-+;TB-9}rF%(yby61^`^)b0u}Q2}MX3`~&3-LO8LT2wIh}I}zL9p3g~MusJp~ zqu1Qp%Ff=_6|f{Iu^^|at8L)O?84d8i`(Z{wgo+Ab?f?>3wO_5e|+}Zqn!uOFFt*B z{^7IjJC8T7-8*ynE?)3UXK$T2|6u3N`^!(hfAH=f&foscp`-WO`ga;TPZw28hC~#a zntNy*Fw@X9p}Eq*)FeFqyfH$0G~ZF?>nL@6RY7Yn#{{ zKXGsL#N+9WuNE);w0!C3qvyVZBr|>T)x^@X(PPht79P!SzQu!kaQSLratT`QEcG<- z35blihy+k7X^F>29xIa({{1169u{f;{}_BmAZv2OM))!9;W5O8kv?r2&-HbXF>#2C z&&|s_7#Eil8JSsJ(RO@wXZ`&3wXMsiw=S=&Y_&J{`?>{~>)Ki9c-k08xww@EMN?2d z*VKQ#y8Uu}&yA+O8`T{bvk#uls5)CUc>D0VpEsZU`<>tZ-;aO(KUvngX4n1W^EJ$! zKl)se*mbYAhKUnkTtsqdUS)Sj`{d#J{;Arwk;2lp_~bHw|3rIBPXl!`ZB;{%F6f<^ z`DI8`;y?r@uNV}V7!*KR_DwB_2Vlz(zp*b0AsviIbS=F-!jq_{ zClmw(B)Pgp#U@rYw9gGruTL(YpIF>rCCn+Uuyt}I-VnLMXCJW;fyuC(i+f4b)IAQgFt!(CPP*ZAVc=eE2qO} z3d~;uWW*v#4NGG7vJx_wTyd;)uwqMreuRIdYe0-&M3R4Gf-E2;ATlN}CLyJus=9lk ze{u8BnH$3^H-Kg8$F{15HX3GkI~K3^pS(S@{e0olm!qfe_O4uRKYG4?axJf8I;OlU zs4zuCO?)!Ezc z&fWid?dI!^+wZm?es})SZ%JebhI$zQubKj-ZyFk{jSbu^EJ7XKGh;IQYKPDD9J_h+;_HFsixK&CmY!kw zS{~50q)%K^)0B!Ft$&hOpAKq5$Q8<|GDN>(Cn6bPyGK7$B6|})5)Lw0nuyWlEC?cN zb~X`TOS%GL;gUj3s+ojxcXc-tc^#KuFkp6S`zo4LBXg@i?BW`w4v1tg|~r5D8HmZeqH zrIy#ypk2{9P}15{+}cy#Gg#3(R5Lu)F@3ykVxh8gOjMwnhKd>n@~eBWmd>y0&B$+$ zO{ocvEbs|T^YBh^c8QR=NBR0BI6+FW53+L#wss1#u(hAdZ%89-JJfo8ZZ3ZSY$V@_7CBr`~)m0X1sAs3A zZLO_sjyW}|9i$1mme%B<)-FCIt!{y_2w7X%`D zR@aSs3_Z@YeuKsgA3DnD8J%tJ9Y=ngCg`;6655v#v62#JRZ;6Fhmu620PA=L;bCbT zS_rE@YbPrgFT|;!;X!Qh@C$}gf=m#xi{K;hKX?S(6#|nXml6UF4Du{8EP=K2ve|w^B)kSC%`jEdxx33>{5fo)=o|IU=E^5M;I#M&L%u`03Tr80LU1b zTA>CkI+Y|z8LkW~D)oIZ7D6;bdpj!lmablw4jwixUR)d~)*$VypVDuNwn6X?7G9o5 zRI+s~%*Z{tl2ic%e*=t&9vlUMEeN0qg+#wOGnP^Hi%-vqZ2To*~-mD7}CG8BI`v<{ftSX z0mumopRuKbjjOL6?TDfA0g*|eafuN4G0Z|~nZM=25+s8^2wJHY{f(9ucFw?boU)OX z6)+TtA2FVQQ}~i-Gb~(kLIwAtggXnG6aUC7ze%jc4G*j#unr|5#w(UDRW+7D{*hZ* z{%b(iTm%WlS5l^{*BSl-HFkqrQg_sY}0hkgjZUA8pMP2}YfLIp_$oB;uY0A_6OXzuK4>FREUdX({x-MRv8pgIJ4&I)jiIJ&=U@~?t z0cPf|!oES*9FCD7M?sW=#H6SMd(TMM%+}V+)hpI52u+x#)Z*#9+7pFsYdI~8+4Zx@ zWdjM>t;rb;$r&|hEygF+BAbw1Hc;9+ms&oGeRfvmp^UPjl(L?LqNecl5^MystJ~5m z8qzE4v#J{MDjJbg&8=un1BxkYOf9KND{D$CY0WC_s%oBU8$4E4KaibwFt4B*`GS^~ zv99jJtz8SX9g9^xt4))ax|bgetUc=6xYxLJse1lw)!eDliTRAKzJ%H)@3aD|;6!yh ze?@Z-C0lQG=fDHbVaC2mhCV6A0m){;apu7hrry3zpPk#72h2GeUxhg}jg|T3`1@`IfyD&Y#WEM~COwX_N4$oHCcci4{1(H>p zSXpZ6S?d@$nb^zhgM9t-N^2&kkMABib*ZZTP z7ne&sJ5rwoS5IV`WEnuYLhDZSGxFQ=)I-8yg!~lSAlFu;naDC7&@eK$5F#NV!G2M3 zazG|3JwL0orl_{Lq^_;9rHgMESRQlwja}oAlS`V1Gpl-XDu;3_M^f^-uV2x^X%)tJo@tYT=v6@JG~=I9X&@o`xd$fk22bN=g>7OZR`w9 zOvNLHevQwS)jry%^tqbGK22Q(sP*Q~#&+JeZb5Dm$wcNH80w#dUT)*T$+5mO^M|eu zwVvpyo1f`jTVJ~M@ZtC0{P?fG`-lJW)8GF0Z~pY(aH;EuApqEq2pod80ryLR?u|x*!k6Sch@gGI=+61dlG=r6S}awPq2q~kcXe2yRWya zw}-2jle4>}jiZ5)m64&9wT%M?k!%43KR{pdz9cquv0tmh_TNW<$GyP~MLj{hiqe8) z5I{JmxQ}*Mv@6X>k)0e_x@AEDaoL%5{XN5r3v(N%mv(kfU%t71@#fh}ch2nI*}QOH zbe7$Ie&OM(8?WDAfBo+A(=T`LJ->MW_4!*b)-F9-+PZW4>a!a!zJKz~U(Vfp*FLbB zk~^MVG+j}Dyu5B9BnDICKt*j^W2Zph*xZulk-DDwy6$65eJc~kE-#$9w{-sb{N|J4 z`Rf24$wh;eUB?HGU!B=}K6>ia&@$uoq1AWTEsZZdA36GH^w{J6x%=JIx5th@TEF@I zkqfV~8i%c1gV0Q(vqnq;AuBd65}wI?uuY3+gzCKDp9<(wJ_L*@ek?#6u|SD3K9vH| zZO7aZ+M@eUwZq87J~25jHMKA>Fg`pyy|T9F=<@c-vsX`UTs*OUetG3=f6r)$U$Ci; znYosOr9ptqvnVBhvY~gkrfVm+YBj55IU{dAA$2M&dOR$CCbRr>S?iUO)@z-!FIR8; z<;MGefAPov>)O}x2>(budjV}u4`tcs(mu2s3SBqmm0T; zzMYYlsgA1N0cGqJ%|b$xS*WdSy)cH>(zZkuEh!_{Hz-)_XcRHw59lCZtSQe^jJaVb z#5lRprzTkLDry3B(l)oTl==I|rll1D(Yv{Y$~+S@b2~amSMgw)K6znuajm9nAS^x! zGL>{~g)lD{ip7U3%q1h#6kp(fLibcCF2YTvmrCE<1<|(Lif-SCJO}qEZGA^I6@ASE zM(7gj>e(3LifHJfZ{lI<5b7RYnAb9ktnT=!N5#!6DMh0JF(np`ewx~*aM7uh5k=6z zBC5b5%GQFCLHhuJ486!$;c%Mt&a=6Q!;xS&c!NOJ6p}bXR!cEZt)Xg-(xsD(`jnBq zyS-0PP<&!k22va~HQl|P(?GI3<=_UP!vxg)n1Pdqqr7VWZcw{CvFb>pYa>pz~n_XLR*VpgoAaV_M zH?hI}+S4rk33#eR>f<3q>KfJ`rA!h5nDb(~^|Zkl0oTz>gd(nOq^p5Ql8K&U_s7EkpMDmP`@JopIjZ5^#W;!-GBqb|0w>Z73uAsRi z^I%hMZC7Q-MAPtG{lHAy=&`23Be)*a_D)uIjFfi_*Y-?TcT85bj>B%H8z>>YA}X#R zJTf~Wu{1NQE;uC5*)@i?I5RUh16^DExGaqvWp=)9c77l&CWa26k@NvsS$YKc#(KB} zfx18)1U%AF(*YXQR;3AnW*a?ybpx&abX#d?D;?k!85BJ=eIrg!%}8I}*o1YB9tNKHCW2l;evZE`Ak50PM18R%mt zM5lm*rze;Ue&}>3i4GUZL0ek~8Y%b{!vcDVj=l*b8GvGXXV^-FO1Egf`AF16q-BPK z3n%(__ZQQ+#tnG-(NPc)OM4nDn0P>hLC@HWti@aMDF9qVw zvng;>ej=ibU*#-#Uib)p&bmu<4J^Zh%+~+^GWC|xao*XwXS(B<#0(`WRY_H)Dls!N zGcz-@Y)iH*mTj3N+mcC=nIXp50Xud$orZL}``o^#&t2!-b!N?cyYpe@%l!UtrO#Zg zHx*ebsY>sk_I~!WpGS0{NI(s#JD`xDilUarx;7X2J{L=#aS=X7GG{_!8be6E;U17` z3BgI&h%793CFOfg3Iu;}@Nok%3k-r%1+oMrPRA3Z8lg+(AY%vCV={7`2ljlnuCC4+ z(~e3{rAMH*KQ-I*#H?KZ$ViN_gb9whDWRJ*TnN9=lq>wQ;Y7ifp_k1~>tpAvhs4A|RL00BIXzghV{S9}6ZUYGFX$_#zq85yB}3IZA{j`VV3eK^9`) zL!Q7w9Btr=qJu`tm-WwKw-k|y#3vCk9D>li9ziDY4bwzoNnvh4;Zg83tc7S27Q?^KytP5enj#9KeW5fax63R%DT8K+(TD2f&2Y8{sgmx9+N^YE(71(s> zrG2ILC9oR4rQeN3dM+`|KxROP1ezqES0T^G-wS}F2XlC7Z~!4+}}Cu}mfje}DW zkceprGt=JEOlHM-WGS--lR;{pIS(Moa2V6$Wdjizjaw(UF)IH+bwCgmF=8;R*ky7x zMJwnBf)!?A&J?8`*IZN%909BWbl|v#&FX9X0_K+X6oo>?&{^Bi*UkLDL6SODL*tZmsVD1r6*{N zos|pCU9ctbPvm~`mRQ@gsmmSQJiQ`9qH+V{D#Fv+(~GAH>yDIm9M5Z6%&6U$Rz8?k z&;cNmo?V-jQ+R z(YpGPnuf{xj^)UwDvbaG)kI4618H za%Nh7ZeB%BVHF?`YArDdseS>0I3Vbiv1y1TZDi&Bn)pbk42yyf#-HzUmI8gVZTd&2 z=QodZ&7PavetzNAA8&v4uXo@7e)UoB_?gP;eep46(Lp)keo0ZmN%4^> zk)hEs5pl7R@o`ZJU?73ML25S@+%dvS7&2UzCdM*5J7jG_!G^pYCf%u!=*K!vic zr>3K?xqq}{WPjKAp{}v%-iZY!L(9lKvKi&AlSQ=?>G?frS#6oQ4aq4*(cwwn?mh|& zd!>nuhq;s1Ru!O%&Pr_<9Y1kuv43N#@Su_c!jpy?OsV zwn}#&efRW>pI?9X_a|TcapUTRNT;hoMP#-3d#KBE5lx|ejg+4dO;9N1?n>x=q%hE9cuArlk{6Wsb{Omcli>{Fjfta*4@fdlXoMl8 z5adS&Q|(Rt$jdV@ATTB>Dm}HPt7G4h#hJC$mCdcy?VD$=+}XH#|H9Qrm#;qsG26QR z;@YE6?|%B#!!N&k{QiggZ@zu-#kco9{r1+&ueKk(S-bKSWajC+pSjjHpSAX^#HaR! z$9BY}4CWS3*S4R?sodumU#W@Aj>xaCAD*urm~R|7(m%B^bNcqug+~kP4-cf zhuSqZDyhA``^?DU`_*lyb4q4ok_Nr~sy)4{J#`HUi3f_yPZw98%PL+?FJ8^9S?id* zJ9FXP)~Elt``v$Tz4`0$hhI#rU+-U8Z<{~fba1|R;bhIg;e@;v-=J)FMTE@8!`j3F zlN+KdQf6o*898-%MXlf)05U=>(=#X|zbGjy6B}R7Uud+{4K1t$RR;T1wQrzaxxgp<9yqpb>W`ndQ^q|syIGIibwQSlY^9kWwMugsjiId$sd*wTrH{-J=V zC_*x!4o3hbTq{M{PV7bOIUrrqwgl`ag0sE6Iisss2;4gttt-Kq#oM z-=Q8uhDb=s1h#V#IzYzVg2o~?Qdo`J{?%RSvPd1r2R;B=SqF|N^R?r+UBL=lKllm zqj?3xdD3H6PJe1zM@nitkC|CLDaoyIvGvIb4JnC@NzrvNp=Hs*g>hjeNnus-Ayx4a zwK1Vp=`l@t$=wAheL3;nl{phl6*H|3i_J~TZS5-^-KW|*PIh#iZtFSK)VAEvI9pk< zzaXc-B)`9;XrQKQqNV9jZ_mQ?)Y;8TPaZ$~>gx3uXD-}AO}%Sue_eNPMtPNgbRx82 zWPC_Y$pQ$BiOU#G=mUgy!UJ*FZm=~ALklZYXImRz58u4ZvdOZ}69Wskk6wRw=E1l9 ziNRdf*6SYBod^U*gB#JAyN|2xG$*P%6d%TcMqHO19aiv*S?*dLV` zuSkY9G$|Eztn8TlqU5s5jH<@0>K1}A>SY9G zH9ZrwU03%`w2jWU49^0^bWI#-?3r%tI#}O2SynqJgmcTgjV zFk!c0lMq03-BtDQ1PprzGeDK!%J>2r2CR0Fz?58yKke4M4XX>mpI=mJDS11SmlK6a5r(YlW-Q#>R%Ng*V2(iXW1h%Qz( z0NQMx!tjMkIv0+;D6~`9A{yr{3vplv2gGlKBO{R65nfIXau6!GLoydZYat)!R^u$q zkAO8HWXcc#g-9F<6VYo!UCP7|ngm17{f9lohQnmg+g?K%66l$&j9d@cLV$QiNKfw~ zUu2vqG;u=^_vSe?Xt zfO>>QxPuZo8W&d`w9=sHc+|Y3Q__7yLmk{)*~a#R z22ffbe}H}fK5)8$&Iz=NQ%u?k1u7|FG9sjrCKZposQz`uhROIc_Q(L!qGTmVgXB?G zG8dgsI2U@z{2^kVOD5U^d6S4z0xZK|3za#1)nzX5PT@E5gL)bafDD~DAa%SS77Hs2 ztcFCM;o~=eg0j#+u_SRDR@|>3CwHFb^8{|A0CspL`ZJOZH$M(0!>?r%5U>ohn|xj3 z-Y|lKU_<*MM}p*T&wUf~d(TenFbQA;5sQ9U3o$wXP#{03Q~~osh!QBJC`$`j9u}Rr z^HN_DpePsjjeqJNB`o(>{)~uKM4T=lO|giir|}y^hzMdMPA1`g#oa)KPsoEK3~r7u zk~xoikWjX>qYI330H7vaesD68d^ff=$B&PY8v`j%C+sqTj>96g z@$t?9erC>&5LbBH;?E(-M}$xcXr)|aC(8oblw6_Eg#~$p2RnGEP3&!{Xi$e`C^1|S zA_n5j7X=Z~c)~iQX`wFVZit5JDZOgCg zt8N{K_kubH2R)S6($0~h)}h?GZZ0sH+}h5PW>9_bi5GCX~@X<(+NeH2)x zy=$VSdAO>iJvXDaD8IA5ak{npWY74e14kb&ZGJJk{rT{jk6RYEtEbL19$f8NywE;# zwrT1VgzB2H#nwY7+7F-Vo81^*+?qUnclP3=xy}32mu^g*-{xA_rUrd?d}U+bu?thD zt{lDeU}kk|d~vONVxg&Te_1msbG5Wy#-(IO#iqu_r$l8l^mCoPGCp07?Iwm0^Dk&@?Auu3FA(xXAfN@EYJKeR6J=&FeOpat#G<|Sh zaBRV|Vzb3xDLgs9vU_s)*w(`JR~KLZ;pV%)-+%v)?I(Yr6gahfw}-g5d@MPkD%3AI z*fTQNJB&n?bTv9OiYp>e&m!jwAam@}jrChkFFkmD{n=L-BHw-etNPd3^l}aZei(cZRerz z2@cLqFBlx1xpMj8muK#LQq?!@7nkqq?kk9HMzC*1v7X&nY}%9*guo8Fj@X2M{Q%Jv z<^v)jlKPlL9>l)Qb67i zw}0vQfg>wj`z8kt&Gb#q3{NkOOdsi)m>W5G0!ioosS}kQ2Wq+xB1o8$(~P=cTtX4W zbYE?d!d~fUV&!CHCO5Uz*t`0wLQ;~-MkbCPTg8dyawF0%t&2Sq=MSB}zjp7<+~qs@ z9X$vuvqf_z%Ph^PHii2~HZ=52O`lj=xp;EpCMd+&D-X`!_;~B~^Xm^j5>?Za4hvf{cA9BZ9C);_(~IeVdN`eOay$-K((=!8lSZH&q-TqzGzI7g^lW4$#g zK8pAVx5P}J+|rZzIjlN-k$KDhV&^H)F9F!kp9|NiQmzrOh9&yTA8#9OS6y0)q=J+)KNu;CM5g#Np2R6J@6z zY`h#95ZDwRDvh7FHpt&6JTyE7g)MX_$EQvlUs&Hbap@}lN*As_+_>@(Oy=U%kFVeP zG4Pzu(8NhAwm+x<0o>yWFQWBMZ*n;Xv`?q!BT!Ffd{*h+~&piPY83+96&Qpa1HdD1v;N zTnKczQKAQspcr_QWRggS(vy`PtWnQ^$fAno)bt`qR^gE;2reC%Id$yJ)$>;$(R|m{ zd!VASnXFam;O^?^r_v;6luR@XoUdwGEvq@2o;l>>S15A~w|5BFsdHn(T2tbN!vnj5 zgNCA`CZiLklCtO0%NME!&hKA+efq&4Z@&MJ+u!{A#aBPiU47NNbTO@A&@-{vRuh4} zpuN4$!bFDgy_JZ)u;L)yP*bcAj?AIa0EmM|5~bQdJ}WP$tW53WO;Aa#feH+jGNKxK z1Tdtav|(YVq)cOjfR(kqwWYl!`J;`(Rj&2+3Q361%+4;4jL!A)OUo+k={<1z@R^&_ z>({2wTpC+GmRnurqE->D=_j^`1Ss-KIrOgp7n58%(9y4QazRcet+aj+0S&+447r<+ zumVAkT3|Y2+vhnpyc1Vntjtkh1C8mQx!JbwVtU!QUsPFkNk>U_4+6TGMKwMVakfhL zT~y-OL%^AwozQk5?E;N~H9?u1$~eI}7N3MDqFN>eX^bh%G5q{?m>U{8Tf2q%`K2bN z*VNYZk5u&z)sBw#%*~A+J3e*l?83(O@$K6uuio9b{}R;~nu#vn|K`rCzutQKw;KOXdN{ssyS3|7WzAA?}=WfA@b!MaQzb+W%U%}<@==N=cRiuYH>__{`VI|q9@1bfK> zd>sA!oC3Y=0=;D+p0W@xhfqIRc$jNKh;w3$IwvcrDmS7&Eu=ak(grk^Tg>ia4#db*!R6ATR}Go%w~G`T6bXDRr@t zMNttsVIk?EK}mkPNFPOLoD<5h}O~_a4fm_99uHT zmI(fs8HyB?J>QNPU#`;Vcu@@r7rYBfEuk^cgflVSE&3 zAY+g_6IYWhGOwh3O<1?syUK;6l_azaEMx18=VS9YfHSU$(Yd9VQT5i*=`y*-cA5AWPqfy;*u0g$h-I)Idw-zM`kg*pFRPk z7B7HAQbQ6$iT%Yn!VTt;tQ?dH_iegL584WorY`?jdqs$Og26 z?xul7yh&120n|WdlNy&ep2Q)}*(SRG2n9tlMffKYOsVv*e^I_d^Arss+&VtzXTfbG z=8WLXkkx`w;8-U>dpjgAWZW?W%!Tc30b~#bC1Rvki}wl)Wyyz)l^g1H;o%&GDD{AD z5p@8_z$JmezyfEP)3tv(Of}!1>TPMlkuy>!;nD((m`rt#~wr87T}4%Mx?HM;4&`WFhHW1u?&sG#N}-= z0{|0%6iC!TGeqYL^Fr#Kk*YyEKtxf?VF-8*Gl$=)pG%A>zl=H0aP!BCz(uP1G0+Sv z-xX^_Lf%*iU~!<_(oMjB*@4oGPhb>Vgy~ zEJMqE7jOzoPr_uxP9d>kxM}|d#pw49v5`oD0iTFqSW2T9KK{uw`3+)Cp?ikWGv!pK zr8V2F3+4z`a)oHDlPheMN*jfO-b1E3I~e*lh*9scG}~itvdhe1kM!3u3Ls!~3nE_Y z;-+x-^ziWZao2j$^Qae{Mw^SiQ7(wY;-EB_oX(8RMItOFpU|fISeJuKW_r!}^>r`<@;mLZOXa0E?>dB}DR8VSutrO|kXg?L1U zIq5v$CGc*+9(e%~DM<&ee$xQmWiIgs;2^PAFi)6J>~coHLgq3{N3EU8-%6n|uy@=^ zN0ODZiLJYplg`@37m-v82MwGVFc}s&+Z33a7(vQodx*zOcN)bVltz0 zYhsJq12P&s(;7pH`r~WI((6Y9Yb@y2UbRx&UGGKsUMjw?>T@ze|kl0PE98rOdt`Zbwjny zc>T=v?mr18Q`J6-4^BhdFm}~hNyUj_S=osdB{^M{#bafqlOQw0hp$tio8NxZf9!6> z$mz2F<;DZ69W&?KXU=ubob8@HGjjC8ffL)Kv*)ojnL2i3=FFYB3wI|@UfjR7HFNRS z^o838&RiWmc47bVO)iR|i|f~?PMjY+ywX3tTsJV@I(nda0D0lj+V(!uLk{|k!m6yI z%H*7agv{KiPM2zThG3_`|Rsm55J^Y>H7W8uipP0Kt_NAS0Cf!3?OrK?GipL1Sg%n z6O^07f+Ey%r2u5i%t^hG@YQKT!=j1{tEUd1e01gI_p5h4sU2PRjVp9f`A~U*e+rPo zPQqQ{k((xtU$$atmloSG=d4r~VKWhTk~K&RhNw{sQ)U5pva&b=L>C6BC2YH0><^Gj zA>~FUrNw6!q~?{Q>s!^rv}|u3+P`vPd*RIb#KN)B+2xVL%Y##k!;`|}lK!>s(Z$Bz zLmgvFjs1sXvuk5h%HxwuL&8&ieIwmmG!(b2iI?{pIGUKc**k(Yp+qq_x;V3Zk;p&4 zxIZnUE4N^*rfsSJ(8cAg=gU_gSM-gj0)l9IwXrsLl{p3If=Y`T$HtZxk6r>-Id$RQ zsmu2++%Tqv^ru@-zuvt4 z>hi5m*0&x5%bdP&`y`K-AFXabJ+=AqvGezrPv1bHbnNiCjEj)N&x!_fu(A?Y1H z5mg%BY`JTMovqHwQf+DOjwPtQrB-I);bf-LSZIUo{Nf!$3w7y@F*SX8gA)x)Ck|h~ zdik@*AOHBtn?Iv4{PL?`p1l9#-8aZ-etYi8t0On>j-Fhp9O$7V&CuQ&BCh_J7AXf| z7?H1`kPGA3W^`BrLKf_!4-lBu%N^U8o47hU0A|KVrnV3CY(TLrK`q=KqELXE+!^3J+r*Db#!EOapB;}Q%5!~ zp1OGL^u-&<$S}7zwjP4XT)X{JU@{M0KX~!}>6bs@NcHmjU!H!0EB#OShF|;m{jKNU z0?530`=?7cUbT16CdO8U_~z-{Q&sXbovtD}X}GBQIIc+>&;NMp(Kqv3&$?$fD*Knl zR<15@KjWHRe=v6BYR7@I%@eCr>-W#U{^{-?{`347f1kbiyL}t)hfjVsavVa!)BgDf zU^2Z^+pQB9u!E`WT&?IiGkW3)X4&JXZ-!)*8QZ%E)dC<&sSycGh9gFtwgk@vGXj$# z+!K+HILGyXjPwXH!ou`YlzfPSP;Fas` zp5-P>RXAk3yB6tmbpavmVabCTRkIxjZX7uEYMJ!^!OvT-{&D;Le_np|w?pTj){Pza zORg|>@cQ7l7Qg+-0y9~{DT;sOyk3D(NJh|WU~a_`?<|-nXmp0hmDD#!BqX42N|lqG zg7PT*c?c(3zioVPoM&afkJp0+=6JJZU%gQAP@HdtvC56_rxv9gr$> z@S(khC|7`!2rTa*@Yz8m1~;A(NkV>8Ro_bU*oC5|#k#KJ$@$$1&qS3jHZU|jEw>J_ zwVbN9u(Vvb^rm)>23RerJrJNpuU=?|SX+xqtBoxoA1_V9!ay^);*tJuut_@$@7S=? z-sZ0P$?p02eJ9oyHntYeZy#E}ID2tx>GHLcSMHytS!w(6`mJZzp1iyMzSM zdv5E?<0oGpp1!w#;!0oFT4Tj*Y3^8hTw8p2ePnQrpLaz}Y=1)fL~6lg&;Dyi&c8o; z{_XI=YbDh)iD|uYiS3b5H9`LQ0bZHmzS-fr^iXZGpIfxbF+gsqb2eAIm?)hLoE!}t zoQ<3u_Sie_l{xLTao%mCG;ns=>*%!CQDNlbZm4iKRBBChUY33V4iUjFG2x2D0Oyzh zc^sFYJl;nh>*XA-vGdhhdvkf&`0K3wyd8pdvLG+#Fh93QANNRq&!j-#te}A0h^V5l z=z{3fa>Qoy>jzqf7y9g zUfn%d($ZB>+e+7Md{$9Ne7a{)G-g0Z)+glV=hZgk)HD?~bRuUb`j19uS|{d_-o@&u zq-ms_hMJm=)Z+Tg^5&%c+T?<|)S{-eq84O$xzOWH%V~z~oS0l1n~)zCnI0ON8WfNm z9+(m4m+G&M^HPQfXd-=8!5U|s+(zka?#ks#gNKtwr}or(=-8sYz0u2Z66TkVa(g=& zA*CpH8sq(gm6a*fYddo*5)9H;qIG9iRb*5gnH~+x7D$-xVxLAE;RA%oNJ4i5Tz&AX zH~;`9msHgfv?UfkzycOU{06LZ@Ry<55|Id=o)0lbkICefH>4LZk^(tB zJQ>n+iN|7ze;Q`TkQwxp71Cbp2k=7mfo+|bN7M}_Lw^bY0=u+8VOYi@i4w`_|9 zU>Wjp{xq-!Or>#eMB0=M8MX|WJD=!T79!I!$J86CF-ZZ;(t>*_@B(V#JPHjQI0_7@ zDS3f7slhfVE3s8rSs};a?(I*@8$>9e9P!slEf=CgOcI_IFGQsRl)>G@T_>Jt1uTj; zlN48rTwdtUSP82auu|Tuvr4Y=f(9e}0VBdW*Mg#=Xz3O36u%IG6az_84nV=&-qv2} z;_B(92>|O*Xna^NyG?{&HlPakmPlKl<49PG1k*@+9nm1;!BB`B&uxd6WogBo7Z8f{ zbrR|iK?QB>teoV48zN}YV={V(K+mO-C?EVHPBjLa4@Oy_l;A!BkP(RjUlADr*o$6I z$=Z&f1-~8)(?zr=T2mzw1@sewK>aiTCPIaXHXKVk7(q--xH_y*{#-B_I)$a7*~`#y zn)4Ob2oVuWM!*I@e3C9Me-4xzJ>!MMSr5xF#LNf49B!kYSHmZOJo-x?o$@&oo;Aze zfb_!eAsFEPh&@4K*X*^x;7PzZm?8gp!jxAEy2<@s= zG>mdN;u_%pfddjfWS8>`p?|NbBLQ)zP%bc8vv? zwUv{VnFFn(5GiFc6;v4zPHsNalAS@!eHyuTi+)ksybO1fCVXhJ`y;d6ADQmlX>DkT zzpA~B9dHmDXu7CqkBCT_hwdXYGdRJb3s}@%MMaE$A;=|o4MRj$dw3vd?-?DX3Jd_% zL`3NS$7Dq9UP>@oXuriB21rP>bL!J`0pFo-AnY3uXLEN}2RVB9naR}#HgY3dcQcvJ z(#hM-)yK}&+sa8z3o6S&bfPiS0Fa^G8k<3VZJ~w3F%@Is`K=zIsSa-5+zO;i$Y=yDb2p?aQ%cS_iqZ#dr&PQ9hU!8vxKHn0~J% z8-<@KtrXURbX*7tEY={^G+VjWD>ON$y07QZ+T!J>m!AD_=ga^0=-dBs_4UuEu6;4P z@(`YOdHI2~gI)}1{(bc)<~B(jC7Sw%`s~0Xk(6y5lUykfxFC% z_u8@&9G!zgqlhIc8#+N_y88Cjwe;7v4plYv(-|$|io-__A3XyggRAex?PuGMagcd? z=acX5y!`(D>)+jZ@y*?r-(t{wcr1t25JA<_r;kbUMO{HlH{vF+HJK|T2v`!?G+sVF@x z5^T;A<9MZ-7MYk4otl$YRFPNNSlQB3*Exvo_5OuphmM{apE)uyb8PI;v7rOY{bL9n zAFgW|uW#Fj1$NuWLV4?WWLjBxTrQDnU~sI;-J22=bY8Xydt*aq3p3>VRSNH%oVv-` zwdGS+x(DZkmqb``Tx4Z@d~;C+opI+EE<9h}dQ?Apz#}A>_J0>=IS2#xyA5@NhiA{M ztX*Hb@PIoB;|M?o^_aU4zrAzs{e`V(C)REsIeGQm<;Ra-|L)>b&E>fDu=*PniK z^Tjs^8DYYnRZtoipA1jN7mqx5oePdL=C%Zc9I^C65h@cU!sDfjl?tZHON%%R(HiF+ zd6eG12L~Tc7^xQ)Yfiz|7Mge_d!a1@;6vaIijR%X%t$XS>6tvR@8~fAnfbMIN6%e4 zec{@f%ePi9-e!8!lz0Bh!^=`<8EQXZGB4i!{*$l&{PNphKKbrnxFJv8{VZ0>CqI1p z^S_2tpqUmv~oZuauau@kos zZ#+J7!U&U{C4K~^j|9J58|9SE4-;X{1d2;LPq0_H>SDsIt`E=y? zlfk*$T~k}_`_^mvPeMm2Y+7j?-#UHwcPqEwmh??J`-bc^vl4ayf-LhZ!b#UQ@%(?C z#e^`d6b@qQtt>CXdzkV#8|r1}DbjJ133^E!h|IaOL6J#0MYa9`QNDf=S@{*ilM9Qd zx2`?>j6LD%y-&7oJg%+pqM?AWO&5aA&`{@r^DV>Y!xMVqlY0^p>Rjc4cxrp=!gU^z zDrFdgt2SmHmL?w7mcF)j;Xc77$pr&-y~hEXrj9*1eCqYo@lOt|y*N3vyFq+)ZEd;M24h{oue9q3ACZ2 zlG8|sIoBwR5||O^%Ly zS9K<5)aIA>bsabfXn$z+GJKMrgHyTHp~K zu}Re~iVznUKNlAYOktkEDdDN*iG^@ni@l@MRbg>%VR7!^@yg(67hMqDcThFS4k)+j zH&1~;iVg9%Onz&*oh~Ahc`BlZQeYweQ$+p>;8$&hnsglyLRs# z*zcK(k1kw!efGjDWLpj&zCO@%vZZRSGG~8b;$T{EOM*{%geoi0CDvaaqjQYZIwg3y z<#=gJ{R115GRA9~&m3C*I`6e}Gevzv zp|(~j&6MsIY7ZM7j|yWxSGpM5xft3ijO>)g_HM=w?j}xdCUTV->7v}tLg{9!RyugP z$b9H})2d>$>R4~@WN-iUpqP@1=7V{aBT2a(*_EROP5VkZ_T{wq!V5=MLGDi|tt%-7VOGwP@%dei#tehQOxOeK_Pir6lzI$OSFtNhc#n;H#mbP)W zCJrL{Vm@MuQfq{}AakL~h}adRln`B15%kg-5Ce><1)6+Bwr+20rI0&%X*HoCfypVc z1;uGq^?8k*c}>`GA7~k$17K<65hljKbY4X#l)iw7RR7QKQ$M8+B61BD9%&EEA$qzDjm*i&sO$0#)G%yifguq--o6g@_K*WaZ3P7d zE=iDtM=tU%&UE%{z!2^#`xV(IbPI3>s;=~Lpaq84d`Nt9bXrzydR}UNSvI{(Wwkja z7%f$CC1(_Z#$;rbq-PbSq!mz;3Xh7@XtlfzdeiU+6wKNkJ0U6CE9hVicX0MJH+2Al z6Y2>t;3PwNwn`ya3$fD(+!n=Qby{W~m`q(;Z%Z%!jFX@-z%o4cj!kzB9cu2LsA}#l zs%%QjDAIcQ>+^TPlR;y_Qsm<(jSDJ;tm^Rw5Hyoh?T zv9T-2gPk2oH2eiF-Vb{qn-9AXyP}BHSVB_J%Rj|WNhSa+3FtR=G{v~9Xb8gU7Wo>O zm=OOUi?i;891{ZO?A`crSj%>qTI?_|7Se&g5h|mgnk0=;}hJ@LY z1|$@AZEQV!16)0P9UN7{hZ-AhG-u2wz zU>rdv#h)o+W8rK8vcW~W4UJde8^XLsf@LH%7eGkxpUA{7MgBh0X_YY}(=&3t$;B zw)*a{y;Q=4=@PR-a9}tV2|%RIO@@G&1n_~GD3CzNGt{OT0$dTDTa>1D5;#aZ%gS6-|89)^PTi_u6DUdzM+MA*e_y*_! zGl%C3yber@ah3|r0x!ZQ8}tJ(2bCmK&M2W&^S@&eX)aj$bQb|KaxvVz zH;R2W&N^Z(I*%}0G{NoKQA^j71-pU00(&OZeL3pcQ3dyvoS#9pm)olYe;rXe_YFfhAQ6;j z#Z^CC-Z<3IJJmciQ`>i-eqdkEzQYxbU0FG0!Cv7$a&MiT+RIiO<{X;nnVAz_Tb4cC z+v*$>ojlg|obR_kLPej`d9*=juOrd~o_?&*bvx{OOT}Q{zX^POojwp1nG|aeZoa zb7*XbLrD{YiW| zawBn^vA&u7ECCoG(pJEMVq)(E_!gQ1Mg7p&(d{EwUTr-74i}OKU;cgj>F-Zm`E38v z^^V@-*;zdaQI%o7=@hC|4obBn@^-F1YK=~%p?M1H8CW_B7gtwjxs0|BVjjA)L4YwR z!)^&B85wAzXIxTxVOc#AJyms`m9-t!^ehqvcV1li z_zS9~5MyYQdGPATkH7f+=@A8hCz?i!uy-#;@ty@Ykb{+Sbfn1Bx; zEV-||cA%)dC$F@Fp1baerOeXyfT-+{sML_~cyHfO#O|z!Za7^HcUc?lk(ryQToiuZ zQ6*&^2)wMU-)QYQ5E`E8tBdtf#Rhw4CB)R{7Ed(ypPD>*d*3xd~ zOHEI$=;=MYaBOq!!b32YYj?l6^Wf|I55B#;`TF$g{rSbs#g(n|SDrk1{o~Wm|M1|& z4_EHJKfnFy#@6dI7oV-1xi@?C%D(Bf-jSu|u7f2t!x{M(F+$iEO8_%FxQk*e=pW z6Km_AtIn*8Ztl(-Jv?xFb>$wiHh4ch{qmQ`Z+?FG?w9*-|8(V(Z`YrEws`IK*y+>d zLw$ZJ@y1RzbSSau5g`aL-^S9!M)-s9I(oJYqs)m+?GE!v02yz}s{xS-@%h==&HaEo z=RUrC?@RQHu=>J>y{e%-HZF-aK($KifTF3nEv#MMImZ;f=S&hRr{vUTrm%EvMIhv+ z6pTts%${CbJiD>7 zvAMc=eRbp7$+O$*Tlddy-UE{nk}@}*T)QU}nD0M-_u|b@uigvR(6e{HJb(Weh-9~( zfA{#a-@p0(@3$VlnV2}4m0pX*n1{VqZssbt(rR4eef-M9lKV@#)+W!sn%{nR=Fy+7 zefF;>Zhm#-%I7C!Euk56xpPv7Vp-KuR}YwF$X znY?@O)aQrKe17`o?{2;MpU?jEzn=d2e@&f#7E|86NACH7sr6nLx2W8b=*&_ zOD7MdcS2lNRdr`;=VWnJUvcC3$ox77!Sw3+v8Cn8_SWE-NL!hmz}w+KO5rqj5`c>^ zf)*GvCl}OOBGXE!HAEy8TRVI1F|^;k+j0+yDSpeGwg@=Td*rFrMJL3UHdYMG^v+zW zYF~*??hX#GDlQv}h|F`4X>F~P))okHDXbi{GWRe|a9TuKMPbWuMtxskb|t60Haf>U zG8+#sylWj?iD~&+dBr5ip5DmkDs1e~#IuC74JpM87xa&I6P?pVZn<-> z)klVQdrW0U77iv9cR~2=Wd^t%*f|*3If+M0huua_2F7^0$#xsq?J{=Qi_)%z?MKFt z_QZEh5H@wNGnd<0D4lGza(i!uV~|P}?H!PrTQ-TmW&ngR7h@LoY|kAua?CZ)FSeGsTGA3h+K%MfQ?Ix2w9P_2?0O*5;?mzAOwv#WLV-d@{@At zN-obSt>nroE=T4!DI*`Nh0L6i)XcopjDp0}tcd7%Pj4SHq!=VXhDd{hfm$#&mtZ1n zAbWS23YDMV>_BEzwB<;Zdht$n?BoEU6U0g87#1E~Tv=D&-dEo-)IP8uB^i2`Mh`B5 zR0Gkp_ECQvD6DGEDku+)j6;Za!Ns)-EdV zusE-fIE;Qs1c-G=n#f7@kG}>z(pU8H4__gNC6(aE$@kf^A*PCaA6UTAi2^Htj6gyp zOonZTfM4kUTG??{@_e#*k?VnnNeXOaI!MTR_=af%BGG$+k^yWY)MIE7Mr;S|3rt+4 zSf~Nu72Q3EnJ6qB;Wdy_p6)Q?%2vwa|SdH8XPPaz=BB2w1>$W}@MdWk4%2#WNIp{X=b> z0gI?R*byxwAR{0(sjnYc2D}ngQ%rloH!$-;2?yZ}@J|GO>68_hgn^KCN?aZ6b*-5R zaB4(*otc#=zNpm*JBKGEv!LKgL52ZL29^<+hVZU}oPolJJxR2nIk{1NAe&}p(q~B93`$c3|J-L$i{t+2m%N~H ziDaA~5o-e)3`*G?{=7HQ-zAKV1hs~^K!RU*9=DgwM5No&S+Ael0?J@pk`j3_TSRw~ zz+@yqMv%B9QXD$}mcSD5KQ6_^b7O~fJ6-4bw>=EJnSYz)2uod_c=LIVl z4AGt=S)uX_i3m^21jDg+NB+|ZNo{sN{r&)Bio3voax0jlwmTrNJn*&+$YyNz9}HR-6N*L(L0GAC=&}On1QS#wpM->c`KN++{05H z5au2jrHe=jO)U&dD+)=?3rNTbNiL4cs7}mj$|~>8sT#~E>rKgTrEw`St0E#Hms}Mo zd-$%nl-75QVQ&rN1(Hlv^I&!JKzW0(SSoGkD{C06Z61Su(9ktm-#t~^c>o4N_r4Q! z>kmw>jZLq24j--RI8fF)+A?yOdQju=K};A24$f6JcTwFSNLJaoDNJMbN!{8=#&t@Oan6(cS~chYp^^l(~QMSl`6*(A3e<>EjdgtCP#;rcZ26 ztz0^IYHOSpr&HS#r?(EQT^>7mu5)tslrtVRCxM&6++&@c&3zwh9 z*75f4DKMGb;YPx3rHci1=Ye}Cvvrx2D=<-{!yp{ z{Nq9VPG7ovbmMy4!2W=ccxJ4Jv$vO1V6Y}JJdjddZ(Zl&#M0)((is}!VCj^s?6nQ?@vE?Hh=Zn$m+?eeM4R;aRv^y zJ27yxHbv7!(#P&C$N5+fR$$qE7%;aLLJ~sVQ~Mt+Puf?_a+C zo_Tm``@zhq^Oa5A(Q(N0ty~m<%-YtC zbC+(3YxCaP#oHIJ(Vce-5oS0c*B`uQAw2v1$4}q?^6LFx0IBXi|9<=7m*;POcKhkK z_n&=z{PeZ9=6&&D*#Qb)cPkecQyUjc7aVo9UTi|6P2-m)*IsfhUH<0W-9I0{_U-D; z?~h-3ySVXubm=PMSCeZuuD$)k>wo#b-u=h_^X`BCzjuE4w~L?sb@{>fOAmfL_VJ%q z9{usa`PaR(Hz1<4kFT|jo@wsiD6Bh{UOrFZe*MYsX0{%u)_2>eeW6@ZtY`6v6{IgB zN-Kp(Mg%jGhBl`*$G3Qb{!5Y&JqIF-kOPXTjtVZMQ|Kk>xh1Jt#gJs;6SB%`+80k= zUcdUuv9k|OpMQ*fIlg#|ps#maNJMsKMfc?K>!Wkm5_0;yf=jasdgBv|QM;8psT^f; zdm9%K+8N`OC__a*BqBDiq!CV9=ipL%-*QX)LSyqnUJjC3gV~u=CFMuj2WdWi(l&9k zarD~g%Imq!9~Q6wGZyQ*wC06TEYJ@vr^f)_-g`EVzTS9YKKy*2B=pnc!rD=DKKLPEKPA2 zp#zPtFLdESC@7LM&FFVORdhtY$%rR@XL82*+mKYMbJ&-@=ARo6LI&TI7`X~J4INweYBIyl!#dx7c@Xf^67%HL?L+(@tn2A zUaTyPP|>yAxy$0CT~@pIQb#l1xeIMre#!#AKlj~`c5ZsYF?^-P%g)XOW{#_qotK+7 zDk8D8tZvjhBwy`U;1N>c6kjv>x#)&lH(Y}PGpwF*^y zN_J0v<>A7{W6fjRi<|E*zxXR|St(_`u%QStnNcv5kQNucNED0r8t$~P+C#0xO=+ce zv-5CQ1R%!}6qJ%2S6Gr++mun)LKIQhI#Ap>N<(+U$b7@#Tus+>UH9Rt)&oUVgLx(0 z>DkR`84a29I`b`8s(Q$A$7D&& zv;euI8Y>5~T+(1i2R9t+ob26f&77=_>}6(h7i*QfqX$G*cNd(J6dG5R2Asv!&6OHD zJq{q7c215cfxrteLz@Y0Z5l8L;=v!yiLs%k`-eu6)WMU%)d-plUr=y-a#WfqxTF@Aa%GoS=2g|?l~<+Z7bj)pa;0Y%q-EzNrDbEe6%n1F@$k}j z;)txu&;WH-G(g}LAkqXMK#0r&Fi=3oU`Bc;BJhyPsRSn+H)z6Q{Fhq{ExZLj3<%8N z_#E*AOyiNMMKBr2Gxc3V*fR-|XL6d8+zlqbm8~@gpP&d?+aO-#VXZYD6h9RC#EL&)3W_-td1A|*aAd_|v(fE^)VD;l``!aah*07+olpv57; z9O;AHggsN_OOo6K5D>EoVk$Ly-Y0vY2*7sj6t*)`Wlf*ykck6;NSDOukhljV_`;xt z_8)7?@y?hR%hg&GhIvF&l*+U~XARBJ%7MBFlN`1T6dHbryw#9?A4^N*MrkO-?ga5P zb_gbi$W^70;+~Kkk(-MfB!Wii9!jq(Rrg5t=t&bCEHD`W8FPfvbzZb7p56jH zt~<;2?Iey-lEqR!)M`NQ68uf3Mq(}$r2JO!hPB#|Zp;0Sg? zq;WkAp(-E|Ye!CAQPiR4DQP?RR1BEhppRja0!KpnUrflDFa&g3XLk)fWn}u`HXQsG z(0~k`2ekljHwLz3+-y={1Ljhglws)rWoQpn6EG;Y6-N)fyCID0z;q*VBY*bCA=Od$jtTHHXVr8UTwsG22#mKLrXeNP}WL|kMvCS-=UkhzL{ zptO^iY@LzPdX>q~*fU`=ERurNz|O!-T%%>=qfsO5AO#8GuNmqbO5~4llA`I%Yf1B( zFr5U4;Txe~DJYymT;TtHvl7r4XoXRV*e`=0%^3%sC(TXTfFK;JHNFOZ!nENJ z*|AN$H~>IkD=ChGdZD_54-wv;JD?v)X-pxmyuv7kT_xwLAWMAZ%*h0a2dDx-eL*PI z$H&J%m~Q%*;Dog3g0j%O61S)rGj}ci1&Ajw@L2H}?bvY9AE?!MLGq4D&DKZ7yBGrP zb)EzQtX<%2tc@I85@qDjo(fY)mQdDGp1|dm8ZMqk=DVmPIJp2lg=qa_UG!15I)jB; zYvv$rL{ums%V)mtR2ZN>&YrzG8< z5I<<#uHngm$y78CApcw2GSb{WQP&DqGtt^R+uTbl)1mIMBYk7Xho;YrE?n3*eY|yO zsYAhJx+a&qCKu=~DQRenh)dD9c)3_RxtQB(&8$4kYz@|$aF_5neO6*bb$-qeE)Nrj z?j5@E;riW=1~+cyG!6TNq#%mtrwcF;nQHuF3{eFcMOBr}ZCxY%ql=UChv7vm96CFB z;MC0Oh3S>e$>p=NYn%LYXli|O;pq6>#?<0baGU*yHy4jySw4Ad;lz#klQ%i$PFZHPJ!MoP;0yr8vuz<=r!-LP zfX~ZdR(tsyjOnTM-Q6o^_g{YN?3-WR{NZ0e`TXy0y!-9uz0cRqJ?$GmU0pkunchmj zQiLJS4=yp98K8A;ZeCh!;UFUpjViYxDNgYmYy;`6htO*A)Gqe)RLF zAJD7vvv)uI#&kS=`IP`N?|ky$?T_z0`RK+QKLnGJwhjf8Svz)Vapm~L)KX(}x6zp5 zsrAq}|YtTt{%aZPAFIt zB`HiIAr(_KV|ucHfPTvwtW-IO2tZ~`L7t>SiU+}K6i*aPhDDVE93d8Kg0-_NX^|nt8Cjj}`_`9^-#&QucK_UJC)KpBvAU+=j=qJ1M{iubDb?yT z7v4U8>hZxtw-)zbSXsVu=G^0(Z@hf}vtNAmH~;PVXMcU|?gy(!?hcKe=XbHn?5%gRYTJr?AD$qLMdB54 zDB3Q_hA6Ws#3b>b5ICAh&T+?Xx1Hubdu)UDx*8n~8M@fAu!5HC-igk&(?=dXeEjvh zAN}U}7k>*?=HaKmy!*j7H{SpJ{5$U-dH7)J()q@P>Db~tdvBeYldXf+jhKWY6hW6I z>$74(C>E3&H=5V|3_*Ioz>tur$nd22xPr`#ruxRY*~M#MGS?q}eBs{n!x!%i&Mal- z7J2*X*>{L(IaSzG)LS9R5Z)8bk{VEChboW%l1it;^*|pKj=&um0egz2Ga(%HDd|_@ zbFy52zv5vy=jRs?Lpxe_PIYa4-@w??+L4RbInLa=bLEXE7w0+aD*97^8VamENvU+ds#M8m0dz}-vff^~GA2H$v53Br}QJ*@fAU!DL`}629^fYOo+P65J?N zCpIP}#t>^N2{edAZK-UyknHQc4cUcd(Fy4RK~bq`1+eU94xHLJ^S4#&nW*H}u(+z?ir)Cd9C*}H-LteMn#Hz5>#2`PNX{uK zDXwWCuW9L?Zta|=+bb`-H94*(%1{{OnHT0;ff{gW#ZvdswT{uP%&No2{FT(IW7%zI z8yD^_Y<+hA!{6Na^7ji{??%`3nCqin0dG<3T=ik$NjbsBEW8D=T+w(25Jid)A%Oss zz|wB}PRs33fFY%du0FEV5>-jSg#)-EC<>ZQc}0X}LX#^hy1-i7`j$FJ*Jsu*ubkOh zJ%4j{<7D$de|$!&quPOln~O$uh8T&`EgCODi5dR*?Hcpr^V^d0TU|UO_Uv`qDYRgm z9kqBJLOSvZj`4|3j?Swu>R#$uy4f*%HLq?lGN#?vrvO$PQZ}KX33k@bDl13Y(Xna} zcFkTVD|=59EEAAW8lBymQ8gBm-QgaTZRHjMu@?7Fk}_KMAl&-|_!`sFlCtv{-nr0y z_OBeec;noix3Ap);jwd%#->hobu6_u&em6r)szo5)Q;BGq4B=Z)H2=JFxgZ;(b+Ol zThfshmG5Kct1Ci5q8`VxBpV+;&+iv@AgdUvCED^D_+ifit!WM3hRtA-0f{V5w zFseJNW^Me~^8?qvSh(={+~&sPr$HT@ZlMjc^bB(gPx4F3 zO{r=v>7K0Uo-AwW&nT{Dxpvig5%S6H*(pqTNh+y+O7}mW2)jvS6jekJS&>`>x3NIO z7$Xa1ao|=;`cJ;aJ>R)Q)B?@SL1yTXvfN3QVry@vvbWNx)PDGk=a+THrPjE5rFaGu zcm|jGMAe06?u*PDh|BGA_KY;&>%fA;&H|RpmhGVS1YUD=4NgdJDy*8$D4xr$IW&0S z{`p7WUVirL-UF9H5=*R{Jg^F-Yx4EIyI$G5>s6YPT-3Hc@K9n5si~0#dC>)Vam9rh zwRLqPW9`!ix)%<&O&w|;Uuhm$uIiqx>Xv;FrYT`|1#u z570XJxmf8`Ebr!ypiD@Vf>TK)8w*@>8{A1jz=3F-9b7c79x=w`n7C9oS09bq8(Tx< z5>$?A*oHKuIH_D%H1Yk#_EoM4XccDDNJqK3d+U4xaW0_LP2WE&EVL(f;z)u3= zg}EpY3U`1XvG_W&wjd#3@qGQlz-})((?-S0fG3jq9+eK4t!X6skCmXHLOJtPNYfzF2YyVMHS8)5ux$v zbPv(&M%xRC8{Id`YOR#Nxhx8c06<3AAEwS6SSw@>f*g>Dve3HH_#?0e=m^;f9S;f( zLrIf`yTy9PyaC)Gj{^vjvbCar&RS197^>0wuvq`-So(?Z4kLM&d|cr_@C`GNI|0l> zeofa2l`jZUs9Pxcl(K6;-iOJ`Y~3xS8X z!OG4KT}yyC@JT~>d`t@MkR`}4`UM5MxM`U1EWCorn1gWe7f`;O5P@M1A`K0}hARNj zN&?OxAvpzElIhHd-L;dB=vSEhUY^+AS>V+DN-uj7oZXWYOE}oXfl=*-59}SpcVp@@nBj(ms0$>Bs#DWVIEY^} zbJGNpAV6(m+6c`C?Q4RyzhE+4SnfL)lZnq8vHMH!k|`k)SVOu9P2h%tO$y3I$j2-2 zAG5#&Uh%#lKj>!wjAN7GL?InmMgz>^Xr%(}0sG@rtQqF4+mPG2l6*=sH4bJmI}ekW zdMmDB$V(x41SUiBMaPp+-O#>fV}fg^H1GlxGX>;wG1?{Ok~EI5l7R57NIr_+1WOyc zfO6*YPkzo2MpBFkiMPAX-QCB_%bSNUN-<%LLtwjMTG%hVDE>RO0tn&2TW#_<9l>06T5Z6O42!nwWW7;wYxgAnF=H7`qHk_4R zECoR5YWE;dLxM+eg4!?4+}WMifpW%{$TG{uL5xZEDl5ZoHcYjXYmm;6=%$ZX>mscj z^p^I%Ruspb5UL7y^G%9OX^1cE56x_K2}(0__S+2+*wT(6!EBYOO5>H<4W?pTMnPP5 zc|v}DVqs%)Nn=Wxd`&25K;SevuPLjv8>8y7`bikSIc0rxD<|hv8B_9!x06$fa*G<# z>Iaa44`VtiTLux6DQ_J>oKP^C`u=J}W*YXPNYByKG1AaF+}1PK+&SOav48?b_vo?y z>62aKYkf0^2lsC@4^DLqOd)krSl0$vgdVs(n7SD>=H0Hl%(Ui|th~Hbp_n+tM%QKK zk2dt47+-(5a{Yq?w_Xe!zm?lQ<{g!$^9-Ub+Sknwr`7sUJnU%c&1`Zx;Bx5^vvZkQ? zsB!m1OD!!gFSoD^A&Anl7IYF?dL{;^R%Z{LK6Lupu?u(4Z@mqh{pOpWAX17Z#*>#{ zzw_ZY05WgC`108YUvs?u{!iX~@5g+7{Oq%PPd-5D^xEC$S8l(Hp*5aCN6+5ef9TBU z^h#&<2(8uu{(-P|oM0#eSMQJtrjz+zsI=a0`lyH!Fqx6r8y6pZ{rL0WoxJ}+^ThEm zqGFF=GBsfaGM$u=Ou$mb2nKSIGBE{;;o!F%JcYfCrG~l8GpR$>I4!QwI(Y%^Ya&LtGk=Y7$tcp?$oi zYo?}oth#k~tWKhew+Bk79X(lgm_m9*L?w3)P6Noy zA3s;x*zFq-NrlmcQihqOyS07%cH_toG0pB&##`MpS`sQ>40i@>|}G4YDAq4Rtb9mQS>g+j1$#1RznJBEQ2t~ zSwdKdNWobbF|d{k|C-RtUl&0w)y_RkG~KSf1`Ab;$|ut+z9g)qHK%W?>&S`qhg;B` zKKSj^&wfk$(xcCQ`QX!^-FW%qi_d>_^zmC$o9EjWW@3tRRRLahURq~gA17~L@#c2b z+PmqT#k|!EO+PQc0L+Me{DKUA7Z**19Z#{VV#*%k8(W;%N8W^F}pMr>ZV z2P7E^0~Y8hxjDL^9+^?xKD@BGc>Kxa>Kk=Er*kScD%&sgFFrbO`sMt_vzddBCsyvQ zoO$d1N5A;Rzy8O!|MH(4Kl|7J{OLda#~1(Ye}484|Kq*C{r4x|{u$29!CRkT(6evu z`o5X-4PC4GWitusXs1lp_gy&q;IAJ4_`fckd6PoFTI)~9joTkl4I7+k5=m)EfnsE5 zR~{xnhV99O$zZ=r?7=d^)&S=g8AIYpG!LOPBd3XLNnt@{eSLRd-#lY=X71wQjl1B7 zr8#ZUp}A;N#HZJFj2szSypmBe4oM~~sxZH(Avi2fi1cjV@J`)5!(!tzN@#NJ>lmHx z8l7i~mDly==GG@f<%N332DpWx7UI6w%iA$5$TK}UqOPQ3p|R_9LCtzl?1&+D*gLL2 zqF_3$X|3zfgO!J09)0&`Q#ar5JAJ2SW<8^MAgZ9j&zSFSz-u)jHMa@^3DF}&U-B;! z77`EvsZatZdSm}2enT6Nq?^b9aTp-V*SCRMs_bkLX-`Vb&dIDSE$L`%of(-qIk|Fi z<;?9vo3~faUmaaNh!m86XaG44mrDXwOIuOvjYu}c<$6YB0h^?ibO*&2*{HlMES<0r zMI4ec0d0=7NH}?gaFSUK6KyjWd-vZiZdr>+>QGn1=wGn=s2NlUKD$*eCc zX>Vy9Xlv}RuV~Fm&eG$su-6V(VpaxNDD)P=PGN-AF?M~=O+e6_H13Eu(lxFV;JRJ)KQx7gf( z^!oUs-kiFTvi3>1vc=8&l8P#Q!=tJBB90-Ls^uODdd!3pPt+~zFOB(1-p4IN7=(pO zs`HA(F*j43tzkfkwYB^mYc(4pD`pVgtSKj^2 z(v{~$opTey`uHnP%X`m4lt3}P1I_TlRZ#RtmGr?fefWs z6qC!7NhpdR)cnQS*WQs13VIHsjq!${UnQg4V+TO3hh}KhLQol`{efMNEkh~yNXr3{HaQD`42uK1t#5D?OjI&KOB;zT ziEt>AvgW(^2D8B}cR={G# z4ME95o)Z~4o;-NUU>IJ#YJUgCqjcMs{mcks;n-mt}m}`s%vg5EGtjT zEy&ELeW@%hzc?u?izp~IISt4N(NaPMAO#GD{G$_8T0g=v)`P!rV?@fvRH!upGOVAn zIby;^+bh_KT7$P{RSoU%{e%r;Gpii%ji*;PM&_3LCg+pyeoz?>( z8m^*J4u-EHlsQFlNGeSXTGBM~T#{UkuYY7xCJ~FPmp_C$aBLD)$r_->{H2e{v~CN= z&gKo#l@yrP1`dc94h~>4P)bC?M>^)296U+rBkTfPTfWM6Ko$WWMMa)g8cXsGaRTD5 zL5iRu#WyrGC#=up^+sFrd_{Z1Ua zf568_A_dga*Uu*`in|Z~fGiOy5KS3kpUbQQFS5hjjt&beAzkn<3KM=INHG&t;RXd# zBmj|xLLx#U$(D$MZa*)wPFT2XD{{FgncL!VJpm{oJR6Z z+&DVa1d|bD zMuHY51)oM4X3Da_vLu(Ck;Y}DOB6{rLu4%aNWfd*0(?5zFW}>u?O|w{rUNqq)C-gn zq|0;&iAdqM$ZbNpR$MCN`3!p*iVBLrY~meF(~A9w&&bP4x4xq0BtRKzFf^AbO21qU zhJpN3L1}<)1dIc>10^Emx1+_$5)gnx{;704@j3z*qv+zoj_&fk9VUzWipYTt9$avs=K{{v# z(dl$_5wo9ZoYkzWSP}WhXN2UGd8K691{%yX&KR7r_;A9~zGTV9sY5ayG5la-l22r` zi{5~K5zUXXcq-LNNg*ZvlWW55X1<&5qv^7nFd1eNJC1{k9`=iGShACEhzXOC>kkUZ zXy7$O(G-RyWj+{J0Gv8YI}ZyRt+kCi#uGL+y1iC9JA1u@I@mWXJ36!3SkN1l)#_qM zFjsl*vTzVokgAhR?>*MknO)tzgTjy(i_fi0Dr`(GX-O+<7+@KZ_H7-N@4F@|+lKMEh9pzb zxUZ_dud24Yrm2@QYh6RPbkNif)He**Hcr&H%rv3I+rQj1wl=YRdT@Tdsc*ajK1173 z)4s8k(h6!BOb|i{5x&4^YbVQ=T4f)o(s+H``~Uf9QM!{L-&u)OyUi_c53b9wS~0{OGmEkU%xnyMDW_?*viS_1ILCIj|?ns?3+J~ z1RtfY%D$PrrrwOYmZY-ksJw!hq7q|SSwclwPIG-=O1!zVidY1AA0@Yhg4*`kjoEYe zkH7iZ^-q3#_w)a9>*en+Kl#Pc%?~E`Z#B2B=I8Y%8>^!OlKtKNeVjB}I|o{p^jdN5 zg{?v51?-xG*qc5nwYx?IDI2jknI}6TdQl$~-Dyi}A~9ruDM=HYsi?=i`0~9EzIpcYr_Vl+12pEX=U=?_ z{L6<=1(U%WNYs6AKRt2&&c^BMt4A+VB2avZB^_>7Rja?Xl zjrNQmm|i`8{Nl~g`IUzDerjILouh5N)Aem*@VIaaYwVqyUO5HJD>x?ACm@`zB?44H zWo8X~8!I?8BzW7-_KrxMKp~(LYHjoC`07S_Q5CJY&OpzU9(JRpW2M>aich`Z@kt2(Xo9i35&~`Yr`Q+|f zpML&}|N8Maf4ctQ!&4XDK6CM{%`0zjoVs!N-1S4}udbfIx_s)=^6?80r`rd{;c3G_ zkn)oR>SCyWp8T9+2q+CO#f0G=?di!>V9Xr)KcIkFo z81_0wIC!Oc7)v6{>N2~=+t-0*?%n_L;d5-De?=41+h6|X$(O&r_xWFKKL62?M{iD@ zKhwH6o7r6J9Utvr&}%|MAq}d13@$zfy0$fXy=PDW+c%1We*WQLGN9P;ahXYprNyPa zV^e34l)3rnQwHSby?0j5U+x$mGv;L2xjJK|L=}M8PuS7BUT45l)uAh25)Bs@4q^lB z_HZ09ghcxU38mKAO9w1N&%3jmhVCcg2jU{aB(H#g;8-l3b8~Cz+eXGlR}LLGxq0&H zowGOZ)3tQ|)*BaYKRAE${S2#JY_Nl%YSNzcqF%*`pSscNgQ?eFZ^-`YIi(X!A`J(?6%91)Zi8C#N9 zH8^_UN<;r)LsYG&e@<#Yf=+Ln8in_(>mLpyPEpGaH_rL~^$ku?Af%uC3 zg+ph$jy{>W@$tov{&@A1zg^vWzh(BcUwny^N4Ul(9888`z^aRqD(0j_IN(CE`6?>w zM1WivxQlH1P-U48WI2p0_8Bh^U1UU5T5?WWVu3L_H$S(zd*8~~-07tgw>B<4IJkN1 z(8X)R2Nnw|%beZSNYcp()j%B~IGtz1A9hItX#K9szJOtnECk zoxJUJq58Oz`r#AMr5gG-(~D=k3}uFZBCRe#tBb6z?FbD|zzhQZ19redw`Sj`#)!1I zvj+rPH@`@)(3D_f8GeZIIc>>>?QywP;Tie*=s0aqAaZ;#)36xO$3$a}+%-M3c;X!5 z?Z-FoOwXUFE$>ST$uoMy$GS!ZtAYd7!69Bz^wK29l@;W)Cd3tog`|ZAC&tC3XQUN1 zHgxs%4pdfDMTCZ9d`o)-Q5i51osUAglem(op9qAg&EDGDL**Q;^(l!+8m=3;-nsZB zrRJ!2{D3yL#V4UHx#mF6@`IVp7emM299VzQbKu(0>W$gc59Tkt)iiU)SUl(%QQ;F= z5t34$UbU~Xd%Avb4zp%sR!Oii1)T>cPaXEb*whleQ=n?nkcnL zER9GGE*@k?q)0o6Bx%G%^3((VV{mv}UTRize0pm{LTh~XQ0L^;gV#RB^=$Ig!=j#< z)QbA3yqxfytfZ=nnxT>A>G`_x+1fFV#fGuvx`Em9j**Ja(Zc!xaG02++K8Bvppa}& zPou^q)Xh0SukTEY``dk8oUWpVN+vMtEA@E_>oBPmue8KD({6%aP7F)sBD zAiW~7(s+2XW`cFA-C(#O$go@LfQnHyGllF%0Y)4FMl{fBf}#->bk!Ni8Hp{yc*K>* z%?s}nH@`rAWHd`LDL|s&6coE zBrT^fySNHWCOJ3Pn3*1voQyFmmx+*@nG%YkQDl<6isHl#X~66b&t;zxYBoDTv?Z#l;-2< z4PBY!m+QJhjBZz4+R;f-W5unbq#&RL6i9S9p!j1`-Q@IbJ; zHDy@BK-fV7LYf0o0ba39P$qktwc&IDU(!}VCMoN@QUz8TKIJ2WuL1AUOGkg#gF^%h2>qGbnd~OqmC(B{>HVnQObYVO>p&jkIMssU)cpIWi$Q znJ$-1NwyNDg2r9r!Ob%vGs<#?|9r0Zz?i;9CR>PnaQUh5}@r# zs)V3~v#+-fz4@p(-|$$SAslj&ql*_FUeb|4f=RCyD;w=XF3wbQAYJUVvbA^hB&0-# z87nBE?pRm>Sm7^5%E>(iRwCsD&}3$TFEKd;97aZoG6aGG?(T59uyYbmVHfEH5wZl7 zr5zIAeqT)FPZSLq;Yiro32LcQqdLe}y0ln!s4dz$xpQYZH^u|wkfo2C$N}}28HKb3 zQI?xuu#48u(LsYc39}pUiyJ35jZPxSoC?6DWXhI;rfA$504yGSWX_pq^3np)SXiSv z;Nav2Z;H@2JT{p|``Dz+pr{0DUIbm-GSiTd#UDh<-a%wnJ$-aOegt(sg3Rd9rv;{X zRk2l~_X;(BOBXl%l;s{NAQi1o5SyVqp<6YN71UL^I6^T26K&86`0Ea)}dJ6l5VUJq7nb^1s zf`>K>6bprW#)o1&@Kp{)M~H3H1j~TS@h%*k6$e>AWEmsF7v*e6|4Ae^KCmZ%7DN{Q37{q$tI-IA-RL{;9p!8R%3Qa8r%u0 zp@hK=<0mZjLLh-5z!Q`}os|UW5?F`TgOm9_p;MMMRt!#+p9m(SWO?#?dWy*Plof#U zWuZ{3oIO1~HH;QJcx>isTU-2vy&!2tB?Tqtg=7`^rKa2a`7+qJtvq;Zw46L#Jiugv zV^U~z3Q0-Vh6L|XIs5=45~4qWQsi7@$n8)tJq6?9lCl^=>5)qTwFx11$`WE>@8+oS z_Xsq)`bXG%=y%!*jL*$y(DEuQcY=T^>lMHgf4>`YuDLbE4%QOOy()}u>{Na#ZA754 zBr3ZpF0V5%pTN=>K}||w zeOhU2YH?dyNqb)PKuN=RVa-@U^(cKz7)l~06PK71pF|}BU9}Ey7`QQjFcqyMpfR2z%`W(`%odMs_P{At#0V7sq3h!YAY{mtFG*+s@_*!H&hQ_x@Ej;;D9uY z%&s){jl#XjE^2JvH&M{k=^vYf!RxDgY=3|}qotFTnzSxGF{h)Vd9k*0t!3a$-^`7P zwMYBUK3}>1A+XHk<##*QZ{&8bM&x!zq%{;&5Aga8t&{EDi{1NHdj^)f2M%=gFLn!_l&D2JQq$`@U%~nXY}~o%=?IC-yI_oLpMpTt0kh@zCbV#^r^B=jT?=PA#1t z*?)9+etqA}!M>@3T@wfCx)PhG>GhW3g_^#Jl8&L`&f((T;fATXy0MAak`hf=xQbC5 zmzmqJuY3RTrAtrFzWv43AN}g?=YPEW;U55GHcr178oAWca4;vWGcl?>!avzpt!EL} z*w_JRc;nGXw}*c)gpI(kNFo_(Og;hrU^2j)EaB7;2tyfNltw_|F=uBtr&tyk8bxg= zH77r>q*{=N?(zPK6#$vlvp0@he&f>pA6|d>!M%5WeDB?#Jc1#^@%~TW{orR$UwjQ9 z^X`wnrf~@+82}l0GH*Wr64RwSPkyxZ=*5+L@1DQ;CYa3Hi7RO24vx*&)^#Kr({Vmi zJ2;BDJRYpOwu!&|PFnkS!;|rIr?8xpmfF+Nf9m4hFRs1w)$-<}^3M6Ngc4Vc9!!Q6 zm9cFa-U=l~W~dzW{IM;Y#=L^bn4ZSGW7-0uOYuiZBu#q+ur06*y9x5i05VB=Rf)Nk zxs|PD4PDi3eGT11T_ZF5rk18wj;)=#4Br@~KJ2|3JI0zi@jaiZ>z=B^y?uOjcI_O0 z;vXF6;T6FC3t5|KZo*`w_PWc=&cX_l3HsC7v&Q!yJaqbe-_#5WY1DhL{)EKI2e${e zF|&0wck*#Cgn1_=8LP{yM(36XpI}>!thWuDx;Y%ENP49-q4S01NVq z*Pq_J_u~FLpI>|U!_BQXFWr7}b?dFeM=v)vP8eef5$s`i*WTUhE;Zk`?i;YlUM zEwg>In`6tjTKhMOYi84O#|tW#mQTEU=jm@R-~Rc=nGe^_e{k;3S5JTP4}bL!-~Hmh z3nugJKmF&=|M@?D`ETF->fgWn_FupI{J;FakH7r;joY6NF5T^)x!&1-tg>b*&e#wV zQXLu9otiT{F#q7x?VlrxThy}XAC>_cz@0ZEntnwwnMEp_nPhsf6|qed<3oa1WF$@V z%M|Aj%@J!6$v8Nx^&uhY#l^|_`Is^!r)3uvR@3}QQxCL?q`0d1@IqX5{5|4BgRtgk*skUnJ9v4bAVgFnF^TeE z9~LZ1k_f^*sU`8*iAE5Li3YEWONO1O65zR980*Roh$uEKs2^$ zUspqXY+iTo{7nFvoU*0F%mJ-Wj<0{Vw?4tkH!82FHXtYlx-ZeP30ROqGq(fHP2V82 zCiIaB$nOV4=LN(T1sY4kQ>qe+Tk@Ox(kmOHv-3g{k|NVm)62_B+uJ&3rlyY_2iQEa zd6Uhnsc{6EqX3tXKs#?e{sFcc9|tXIv!8o#co25N)hWqfGVwkhfgbKiON569#>7S? zflZ~RX8YrftHq3ia8rnagzg+HEG&sqkd-DvcSolXwKhW^(U?|wplR$zMD~;>w9&=C zSQAw09oZC-HIhXm zD*MvPyAtvm5x|ejDGg7{2{fj}W)-BC)MnK*$L5!KMaJN%VD6-TWzQao{P*m}NE((G z<~@vLNgI{uj`7d3$5*bT=|SX6F$(kmuLNfg|MbG@g6d|iUpOr(7Uu32mKe8r+B$ft z)Osg39|)?Hza2C>@+qxJPqjm@jr{Svpsk)*4UDJnKN0zHQr}JtCGfKNt3tH&=4mB3|1}1xZ7`5t9jVi#! z&WmnSM+;{aY9)KD?7>^e@+@HaTR=&of6a0yomo5Ss)Ow#TMwQa@Xei^)Hv!=*vGj; z?2f5gQ%e+u0SdL$YZ6k^bUsj~?PYnSpUF{e>maEXAU4Htk~`C?&($E;gO%atsYlSm z9XAaZcQ$_^~?Gn)jtD$*Y)SKxi5@d`$}##bLk{|qO{>OrhX=y8I3r@s{9IMrc*5K9@7G;cxjfc31A2A>U2@WU#JScd- zrgVwihllA_^5QhBLXYH}xi$KTsMySGj@06!oXYB)imH;T#?p$0lJa_5mJs;O$Sch( ztVqo(O3N>bPfv@+6xHBIj1AhX4~-0rO5)^Uph@R0g&qKHMlK7ZIjIl%4|*$G*t}ZG+Q|T|=eS4Vf7^ApxQEbV0l) zJy8nI(t69>F<~-FRabb4+&H{t!{d`9lG1>isP7}_MOzGt#O&83)|`f^UC9*xgFuob zN@8wq#svqQ0oFj_fi69SVkp~^gv&?awt?rMOhT}vxZ%(?LQ+N&$MfOUfCEUnXR(*u z3WZx1e0^vHeIMRIp&&d&W#nR9e_1M(>mYywLr3xYACB!h%)EUt3V zVCJUt^f6EZ0}`ZPgK&lOH!&roVTz5P zT9aUtWQ^uJMRNvG(R0jQIQoM2-JOXe+J>Q zf+=kVV}LGQVZh1^QaEPBePA5vcf1{mh|sH)50-FOP~g~ z74@^+(wNj7zaU(;1$ts43sHybMHI#&1HXp#z|)uBKto8dhr!QYquJ~1j9iR^hnK6b zKVl=?7aYe(tvP_FAgW1s50?mOTx+ofXOMHI3^RtDEZT|=Fwh>rrBI$2(R?*!z6v1o zJuIVOGMu<98A$qrY|ty@qf8B! zHo-}_w!9wL0tZ6_P=!OfgcLaxE+OZ`N+<_Y8L#$T*f0ww!)4)Rd2v=`K9{V?ikJ-F zn7)_A4OMTu@5O~oIE=iVg2tGh!&gpHdY2sR0A%Pe!imXBB}z~ntni=&3T|Kzm6TBm z0SQco7@h;!2d1ME)Nu2K5Mn~N0JLTK<+A`z;#@|d%GFsR#yE0uOef6fg8Z^$7c|9J zIE2lmyp*Y`E7*eqh_N!W6!Wo$AoUgSA^7T$={ zk=Ot|U*zb_Ew}Hr1_E$u#vYG<46^w2fCZ43yS(Rn&D>)V38>HeuUQ zR@qou)=*jATvpZsGE-L8R$kp(SwD!jM%U0n@5CZdOj>qTa(ZQPT~B%YP+WeMHX;en zC7dQA^6HYR`f}0Ej;V(B$(Ej(j{b%A z;r)$+bB&`*)gy~7a|gSY4;S|IN931AW>*xqj}Nb3I&|~h8!vu&|I7lu6$K`P z`7hG<4o+z3(pxBi4F4wuW3z)4>aIZsFO+~MAuT(zsH_w~rf1aDvP9#|#^pE8-hOuB zjrXrV{^-GbUy82pi*Mfi;n(lH{02qer$7AZyDz?a@zKvfX7E}9kil*Vo94TZKc;cx z%AI#O&R%_Z_|&zP!)K@VuZh=EMqx-m7_kRF(M%a6aK&GK$2Kdb#vXGp8NJ3o#6LSJ zsja>DIGD`VyWcFFzE|8l8DcEbxckBCVQZ3oU)kABbC%7WZ)B(g%P1q?w9zw>81NFM zC{uv_?SIGK5<;*pIH)mzpneyfl9y53$SA6A8?NgaZ|E6q?j7qGoMw!TEUY0bG&;N1 zIWS8zSEC|x)VgoJrhBS>-`vE(b7Lzf@++JDLt?e=db(}}@R5#GrmnEKiIW|zY&GOb zhT#12Iy|+HUbxaTF-4sVJp_IQCc|?OIuQ@2-+-#T~u`Mu{~KKuNyx1M}@^xXZ`<2R0- zy?6G~uX zMivUWUINj`iljVDSCs{ji_EnJlc7M5G&yV;^fMi|@6hZq_qMbPuyv2uMdpVWHDq*+ zwymDnxPR~APu~0Zx9@%ayZ68O)0 z$kp46=PyhgIov!t(|3)fCwxr?7W>M?XGfytb`cIWclC-gBv znBl+|8ylt*XSa@=-daC#`=H?H*v3l~^+{(l0vgi#R~WQR zAb2v21gHfii4 z=7vWW(WVa4C+XdyeVl_mRe?I!P+vn5DQDaGk(ROJa56OkX)fN;{$WOG94IU;tZl4p z>nLt&sp%Q)7@unym|!_dO)G&OL%4=kn4_6BR>+pGZnu2xb+jI+nK^|Vy%Gl~3S{WE#9TM9ZmDW?*b~q|`G&plKr{#F-?Cp-Zn^nC>Qw#dM{1PK$ zvhqsmeL^D%(KUX)m{c3H3hfktk zV3Lb2C_TFj4;`AP2?b3#DWMtx5B8&m2qP+>$l>~iCj`ahuyRJF)qu&QmUX67b|jZK zB@|bcclE-J>0Q`AzJB?XtNssEjq2;X9svwUj4=as_nZ0(8jmFH%-Npg- z34-MQ`k0*T>bklf8VPmo-mVU=E_QCtHZJaJPdBxvmuCR0oR2{qw~-tqM3E3iq6k@A zAPvG7M^R7Z?5}b)sywrd1tSeZ=OQx(9X)cLJd#zqBnM5JN|&QCl)L#?XoD*~B5L%; z#?Z{pgwhdX;b5?_!8@qP%P-qMv@krrDk7;iJh?WpperV$3EU|tu`n#HI3m3`ySk%! zbg6&w_~^m2!z(A-rLXsA_)qos$RM^FT&C%j8oYEE=! z5k6ljg^dOEgOwfoo5xOf&t024_3YT)FK>SEhcj<|J$md`>&&r=p4p}Zc5 zae}U9hW820r$owBSrMv0u-H}@EUvDOXlvNpO53{?NC7gP5?7N3l4T>F9+#BNmPC!H-)7k-hE5s4H8x!4R^B3SZD)LF%I3TZX}2zT!gdnZp|8Tu@U zaydxDd0#J|Aisc!kcim8$VlJdAjoV~ZzZV_|9WY7kqN8pQ<9@m$EWkul_He`i7+Vu zQncYoNs0M+DMf`@Wo7vl)dgj>SXCF6*C9)unOBY%c3NI(Mqw%PN(mVmQN}nAZ%?>G z>^{`ceFCCg-1P8EC{~aGNFsny4-Zp`S!}2k6BD8m6E&BHI1)5#_7=~?l$^@?w%Vrd zo}uY|qjO*~3+pHM(@MO4df(Ja=g2}!?`TC`Yfes4Ohl{)m)A)x?Mqx7<_nZ>MLhtF zf&0o2i7v>q=-B}ep;6Q~FiaFw#BW)4bIDqihnyM@IZLrNK&zI4%|S{CJpfQe_y)*` zDRQ2sXL7$t$~gFji%EJ5{K6aIO(XpyY8QqF7aSfw-_WKCCIcYj9}yiKV?+*xw3Nwi ziV%2T)2hjSA%p>?eTJGK3j#mkw_Gj>*c430^iKu$7c58saJrC4t`%}FaR;doLj4N+ zK!nx>60x*Jq!!B}Z+##wX2Rk?w|vhoNiyNZ?cPBn47o6=&}-Xwzp`!Tt2la@*_hGP z>FVvM@n+LUdsYNz9MsqYfeHeiKyER!ccFEfl2CA5s$WFBj=pAZJs>1(5d0dEQh||( z4H9q+7Y6SgGD+!1F%xzrbPlv!R62iW&p?&d08`P*!4*R&=(xxzF~}K*(!ybZF*X+D z8m=cpRFXJQHUI~NO&o=ZB*h?aJrohK0+d!h)FzRV5nVraUeh|yN8{EA4NS^R^e(yM zN(G?g<{jXmp$|fw&85}LWa0y%6Y7Q1yTqi1;pF8X;iUCtaB@D3F%FOxrn%g7QfXz$ z=K6!lkTOEcp=V79V>Gp+{tFWmo(wcJpfjcSlMleJxFY~%LO%`&hjWg5X>>v=WnOsB zDtC958qj&J0B9n?7++!LBU9ty%jRkD36C_y8hs*T5Rybj0Pz{XZH$!__hc2o0u>Mw z`pO`u07QZ>^Br0jIHK~92wx#*0RS@CSiJ!urI}Q@bo{MEgMgbr4Jf0cUk!-}2nA$= z6T@G^#|N&Lh)COGSuO`&UYsIG6z9rPDaeK*_QIWlnggj=6lfJ-MA$6oZ{v85k~w@X z_!3-js40rkHj5ayiB*)J2#l=YlgvRd854Plul!0-a>e^w{v51BIe1Nm2P-z`!}JDH zt?vm@WYpJAq(09d-=hS_KGtrKjE z2M`K7H6KUuX#(-Xt;~{EN|-O0?{-NsI@@zNV2f)X+# z^GfuIX-)=zbCrsF!Dc}tgPIxZYoKYuKQi7B74H!q<>0F~Q#)_7w3Jeg((la2A%m9H z%o2q>m6@X}627lnJ8iSH-$u)uAfGb00m<3yoV~&{L2)X-5G$=GxQ(>b$<86$1gFha zB6~tl4osZ>L~=zwFB61tj>dCWUn30asNA;bg3h?2cDKO9y^fyZqm8<+Yz(`Z-56A{ zCz9!hM#M)(r=(<3O{hpKtW3=-=Sa&_V41?^^wN&(%6<8@L)3aw3ftqeYa@~h;?fF| zGwIc>E2wC#ZW#pJXc?HR?ij7^9Z$Z5XK- zUT>H?T{Uu~y8mcH|EbQ2O9QhvMyGF%Ox+lqxH2?(b#UUw;Oy;*BhTh9e>#2T)2@vt zdHoyF<%1#VLi5fl+E-kK8`K0`h_<1{_OS!|=GKQ6kJ5!SvT}T6_2|U<31m8E51pjm zv2f@FEg=gBPs5Wruy%f7_00UrX}-=JI59DQWOQa73nz49TlY_7r=vVsr$!nkP zUwhQkcdV*-Jjd7&=bsg*3CCp0%|@jH3ABKJW$oeS>ZdmZghm*`qeF~Ip>YYp(a~Ts zUVgrGnxeua)dP-QSOc?@>|ic9shstCz?+1a#EkU(vYfKo+KzsJi1C%9izhB`T)GD! zaPH2#7w^A7xC2b)jb~pxeEt>mn0H=$4Il#=^Zp0l0L#3i9AGloE!}(a$(=_ZZ9RB- zY3pqOnWN{n4jsR|uyVYAXsWEN#uypr@8zquvA5c_+l0yN-u?)it) z1M`v+TDp2qT)z9ogAabWw0Xa>b3Qn(Q0?kvs=6{q#mWR}f9ZP`S}*gLxhbLG_gIa< zr##2>TfP^NQ_tAT>n{Di$A3AVsaQRqPWm7d?t?6ljlhq}MF$|Ky6 zh;YjA)RFbGcMo59W9j&{ndOs1V+UK?CL5c^s%!cOhnIo=AY+`r_3Xx5pFID`Z{Pmp zmsjq+JaOUC+KC&}izmmXHb$m4kf7PWehC3;+`$$OpX-}iENy5(A`eUkfEp-<15Ae1 zOtPlGU@|O;BB#Lu0=7@2rmO>8KG~&d-Ic2^96Z(-Slp~Cw6c>O+ic(FuyZ>+U9Y{i zA@;f?&*;LCf|}IU;r5lIYjHvSQ$S`eCfP;sYD23bP=-}+`tikdl%r7d3tg>cga^l3% zlW!cq@Zj{-hi7g-KK;hygV(Rmoj+6A-|gb(jlVnR&q{roIp%K zeTRbV9z+BkXqDyVb?{d?s8XpsJ-wsClZ%UL_x1PgKQMFr3%l-+lS}|MBrJ|4*K9`rc;~tGD|m&NVhKRg?_}=rg=MQ}p`$!0^Vb;-#65mm4>J z+PnXnA-cfP)mK;n+eKiHE5?IpN2-`2)g)U8C>&b}H(kO)n!?1BYA0JM`5m&!A(2sq zRkfv!?S+l)arp(I$*J@OAmu$cxIZo`$IB_e6R6nA%@t!eO%Q(ZHT?^d$8S^*912RU z3osT2#$?8)7U0&DRaB3ZQ*K2A;$SU9)9oV*v=AmBgzFjP=HQN22|ny#C5TI#z51$% zmh9L@=NgpCLlIzcl+qRBc*ScvN+TNggR3?4zKxDG&kRu(Q^ zy2yn1n1n>=h?G}YvYaezoy_e#9drh5NO*8|QSrW^$x}5rdxtsef+CHX8m&J%ri7QwP(nLu*(l%oMJ)3mK)u#HP>NK$is|FM|NUVBZvgKLPjy{{$0{C2@s zHo-Rb;Wmzu05z~;+zh$;=&JCPMy^$OTt#GbMOZ|sAvoJ7Ff$;sI5xdGB&GsEJZ(^l zPh*_sp#~jV_e+4AM9pnvz8#;2scU ztI_Pn4Fn#$wH1=2#9*jRLc@4VP!^jb76B|W!D&>eNFdl&&-+GqYoz!KiYrly+fBjx%%vPH(&f=`O1ry ziBmZh!%3MfkMZ*DKWg`AU^@X$FI>E zyg~w6bFxJ;9WpF-A7N?Y+JoDXB!5n5t5U=#q9(r}s3u}WmjJ%KR8i6ERXO^FhQy|% zaKCsq3nPpdpbWSr9Q5_0Q^8axV>4w^z%{fV0L7rq1vQSm3P6V9HFufB0YJu4<$!T9 zO-#g%f&g%a&d!KzSUS4V1qSMfki@T35eQ;@S*iM9-xva{CD+1+66=m~nm zKOwRTH^SP6CLnCxaJ5FOhwO<;lOZ^Std=S~r$>;?+mTDk2FCiN5D)mUD&CqBGZv+e z4zO!N;vsA2Cl?lEl$7L_m(!!2TU?b>Qk_vy&f=4vQ<|AyMprLXnfSEKm^h;!@T{AL z+E#FQqT0m|dtWjBV2d=_CL^ZHI{6n&h97e96Osp^cL>Ry4BQIsozTcQXfQP`-JN}7 zP-RADR{><$in4bqNq4Xo&p zk@B}2cIF8Qh^A5p=e=Zdalv0xKo~Lm1z49AOHsm9U>QXvhOChEobfHftdeGS@X;o`$e6a3Pd-;2?Pg1@VHUVnh+J z6@=O$Ed~N+^L!2#0Thh+LtdF5%5I|YWJtI``-Ox_{}=lVsE)ug+k~=%dW53UD%Y0$ zQK?gN{ULS0xB~>BC(li*2l0TVhPDjVd>8__C~m{q+d>Qqq?%5r$qsa40aH-G@E}*> z8&E996$e8D^bWIO+6Q**wx+;sjyep2v|j$0Y?1ZA8AF6cNGA|NsjuzcV|y^0xFPQI-n&*=~>@RfoN1C_-`A}a&|4B;WMsWdUAW)~!6=0qhY zYXkkQ)GF8-Tm%`|XwU)hItb7QCIcA>t*6kW3@~k#hYz>`R8M{dLdAdq4kFCp;tAHw zWQK(ToM>il8Yd=~F`0XW{RE{%_Gn)zEkbk&nUEQ-mFaTvRWJ>@Kd`?+&xg1du^)`S zy*%7$-c&hJU^1Z`%s7EW6l_Gfh9bbronnyl3S{Pd1)t;<=p>Sn0N(@cEYV_AmLr84 z#NtV8$v6eWlwLF79R~+?4OD=3T8fI1i0vyBCSHLR+q7u&0p(r((%;1Q;BSl?Zma37 z8Q6?E-krmAN^*-)a&{2CUzq|b8%wpl1+wn=F@dE3EK>+09z#1t!A`mH5sC z4v-IVO%!a9Rx;u&@*;LT`hVf$u~W#%R6e5&VJSAV)QHM~s7=by5llu|XC&U1)r3Gv zsoarWFk9$#0+4}7MMo^lGH=8HV}W6PP+H1B%K)5rVX$W9V2#Kr02+q^wkbVd%EBsW zp^1YBNk+kB1PD?98M*KDb@E<&%>iVfYXX+aN$z;feEVzGufJx$<8_xkW*#E^>x~4r ze?od#W}aVMf|IWwAdYkanOQhHI(h2-d_%%fFQ--6D%LSt2iP)k>j z*Y;WwUjJYRXtnGbd^`~)d-WBWN1P{|Baxo6cXZNv8)73;s!~e(!?W8W^V-958{I;Z ztkqt)y1`oH-FY4)H+K(Y)?)ku!+Z?EhJc9F^um;^La3g}*+r?jC29GU8HIHjrLF1M z?AGintRKlN?@cLciO;Eu%_xaY%}dEG%Png_5TK@&evrkceKR#Z6ZQQwHNBJc^3VWM z*@C>xXcdw&4PB)*t;N+%g_R9uHI1c}RYj$hC1rJ`<&9V;7Zl=s($(11UsKbAv2VxF zLigx_oZ_ZvW5NH=)O$eHd0*+?ZYm(rdpW>49D47)_uhN&qJxAGqBkLg03krAqTah~ z%a&wWu5!1NI1?w1Qzn_r+{~RMcgmXYyX)RN@%P*BalUm~Z&;WhIOl!;|NYx4i(mkm9`KxjspgKo zHBCK*r46YmCGpXDQ9;S!fk{zOS@CJ*`0$i1kDq@2=F`tnEj@VjF|(F# zzxLtPJMUh+@f4EA*(fuR{@Eyc$r0mwL6Lkc8Wmk}8HTVA3;Z>YZo zTWaDCm6wO3UuZyXQbG%u%;~Ei-Fo)Z!xvsFX&a~8%Zdf1WeWqaD284NY;10QSMOwLWp`eFGsxb=%(1mow-_>h{@y!x-v09Or@wsg-q%+j ze0=80<71n5A!$s^p4>ZpWLM9D+O`oePe3G0IjWkm-7cg(L1&W$PsbQ!VGzv-VgyoM z7DSYT-j5huF^X6Ccyz(Iaf&q`g{p)>1(V?)NK|2LF!n@SUpC(IqOIOmrycrk24(`w zXu`7mGb>tEde(T^{D@cznc_Xdxz zrMI>Eq^0?%rzcgEf^bh3!FK?k;m;`K z8Eh?`AHE)r`M=)& z;!n4qeYbS(>EO(zuDu%#%`@4VyWF&~YKL%~wLE=_0>aztdd`imKdTws2urKAcL`+1 zB}93liLwT0LP$4)NuV;HR5<$VECryGek-ejlK~@SOB0n=9YOQCq`b7DCAFw3v%0Bd zS7*cSy$r(Z8JI}Vs&LZ=sm(R?X6y|t)Hco<&#=V8#yy9R&z-;DJi3}yKbTU|f@Uzg zuqGwFG(09dGA=hdF(<#WnPZ~1ZEsR)iMwkcGj?T8vHngo%7Is2G2Zry-b*j=V9B|t zMQIeNY@MA{-VP4_T5YtIO#mCn*qFiY-sm8a1x2LQW>xI<3@t~>6q~*;GI_u|u+Gz~ zz|%85z&9;5wLB;^1(XAuUuVxCckeJ9U04j{$pXuO$zWCWipT+2^Q3UrY6ri_aO@^L zy#1L z=DiUqWtibdCpT!_Q_QUVaFZ0jO?^W~yPDW*J)_c#yQfAr9yE`g3rgewewsVIJupr5yC5KC-M^L11WHPOg#Jm~+ne^h?jKaE@^wP-W z(y*iw4&}18eT{o2_a0mwJ$iEb#Mzk>=Ru8@H}5PRzcD<%QB%1mHZ;fG-q#*Vx4wzB z{!Y#pd**84UTN#7)p|O+pdpFN%BsLgM(gYbl1QC`ScXm$SO64!L1;`sXb{BOGXNKZ zR#@r)cO;pTdr_T{j2hY+o4Fg?1bc>;)buVV<@MWZ6HG1L`BVCOHruyZ?a;H|sqbK5 zs4+0{Ft)<(DZwM8AR@UgF0D2wBHzU$QRNVBs|vJM1$y|Vg~wI8c%;~?BVBwG-2;=| z{S$mc(p>}K2<3Q%6-8yVCKPt3RSgt0j+S>!)$|?co?7jgSZ*6Tgl9`-*S^x0o{Z93 zrX>4C#xh#PEhxw}D8$~w3quK#F@PFeG4;%BEu7qglQRpOTEkPb3EfPb@d}IZi;4D) zjq!?)4MYmB-{S%jZhA;O`-aLBg ziwlo_bM)qCts|$xlbT%IQtT~#fMQgJ_Gnk_3~VfSVB=!p$-HQHPi7XFVFI&5pJT$1 z@`n-Ldiqp|7Bps+ex;l^!j3VPTu~GaG)&>Kix3F{8z2aii20h*KT%apVutok3erRXw921=aCIg3o7aPJxMd zQ52@og#54wPEL%?&VnbCl%JcLpPyA+4j_}lnDyL}fi3drA0x1X)g)fANBJNwnNJ0NOK&1!3PbtR@uMk68hB}qj zH6dT>=pXLcH#K(fD0360mQD`M9PJ;TZ|fapc0gH0Q({7<7e*iUPE-l(6AEwM4qFD? z4dxSI8dV$bi1)=)27rY!O;c z$yh;ZXHfG|J_%o=988Oj2fQqW^y zl0b&Rx`8kY_#mN(-^7+;q7j4;QZVpvnICPANtcKSn5~0gXPcffKS>$QhC`~62mpB^ zI{JiysBkLSp&L^BggJSK+i3i()r>Uq7m&o&2kTIJJ#0X59qys%06JimFlZtaRB0e}QE+is0Dj^kECL}T5 zD?C(OM4)Y0T9SAZvIrgA3PJ>8C1<$(QE^P%VCDi47OxhBgqR?R1W|%>1u7A&O9gI~ zZyNnT4JEr{=roTWfsZO>Bh&W(LL4KLkuhxAlk& zJVBnCa)u}>Dh>`iTQD(z1rfyAIS3r2;9*P&mq)KNohI!U-J`&StOS0K?kNC~u_{=f zEKblEP62K#ntYYB24sds&T?e|6BdMUqIA;vOj*I=C%(b<(K9w6OtG-|JrYn6Bofd7 zkl@e>1yP9`O30NIRq4MAkc)zi+hAdVgqF`d6louCdwIvUmrS<4WWMDksY*s7o<~%)rMuf!Q0_#PHg#0t z2n~Qk1IpY6b1FZzf4om@K|o5aOJu%{PppMopsACq5&arlXKa4$Gy!UlNKHV3Q$Vb} zPpGlRW2=Sr3s`;$wMbf2T-*S*5APJf69yd?;AC{3zVQiJO<9b~%x(|Q+2xyBY3mbh zV&?)q7PmSuJG!z!M;;`Dg|1jp8(MiS8 z@#U#`9ko3N+9rpl4yS(@|yb z?duyD8A(3~uYi!mFiv8`cX;w0n7JmBEym{?pnE2>+1 z1(2Cpp5C}{@buM{%l9ytz4+<}=kC38<>B+2Z+?9D(Wm#He9m?EjgKM80LZ-Y)@M&( z$h`I0gGZmbo&^qED3s1(KOpaEJ z^kQBSe;5Tw5H_svWE7J+K1*sL5Doaui?87I1+^FeLHQsA5fX?kAim6`#?QH}XJS|HbX)(-o)Mnx;oYN4`{y=B z7EkUwypiA58<3PqlN~w-cU1r%4yjjOA%zx9#$Y?nIWDfuSS#$@ePCtt&cx9(W$k^g zfuZ=8AbT{x_lsM>zv72?B6Kp;s+>Gr0`l_e21b`=kDi-eJvTDH0Z)dPkyFr|o!`{E z=fL{u+m~;@efjP?RQk8x`W%wX-Df`nlfh4B^~~L)CvF{Fx;#0zIW%#ibI(F`^GJ5- zE;!V&DY=1Rki8mh&t{-cenravs8ChFfyl`o9Z39P< zn2an`s2o_QntG=Og zc5Zm>*zD=e`OS07XD_dwyLR%*y<->doVajz@voo%_J6+rcmH^4+WN{^5hK|Kqc7{wJ8sji*1K*?7=Des)*?YE{E{ zY(kBTCd$b^#KA5^>yqZ`S(#Ea+kNm})8x5;w0f0iBx(hL+!S>-)daf*NdLthTVB$C z`9-~#Uf%HvU%a6I%FBjZUozgpWoU2W=&g-RPcCk#%Pz0P{wk%Ux^4gD%*N^E3s;9` zmkTS~y!;}`{pii}Htnr!(3^*(6qNOhO`f_svw5dsXt|V_v7fZ*W=!~Y+;(niqs?hkxz^EE8-(q+7Y-e?xvtu~&v6!e_XXhYG8#hyH zXN`N1yH|up>xZGn1hq@a6d1{?Vbi^}P#MMvp(P-o4=-Qe~@7w6+V2j4g0+4>PmWBJMD@1U&TM z_A+@=(nhwishPFfg;rx=Y&s`zWNINCa@T+et-qi&A&L3%`86E4yY|oRJ+R8*HGlHz z!s+V=k6)WRc4hYPxxt|o242U7WP3XW+8f)OZ#RVN01k#}3B(GTs?6U&h{5h~bq@>+ zOA82y(`ejL#{fa&GC&dbOxo?+hMkC zhYGO8IViuR^0p9HvvTN30zg zYvR7cNWIep`MuG7_g>j8a9jS4Pck@jPi7p9Y zW^__*cxp{dPIG!?e^zyWUj3f()}hL_eZ_U%S;Y-`6-{ML-IX1K=%CZen!?laLsPTy zs0mNc3(LrlD=5!vY)>n1V6;JEVQpq*YiV0wX-98Sdrw9GzRIq#!iIsox;{SFbWSl9 zy>oD}wsow$Zm6hYu(*7ryk@qrY&O5*K<~tj<;$O(dGyWb`u(`K~LyUu!;{#xy5{7T`r?Fsl@$x6JN1jB0r4RIAqqs;M?aJ~besiEGU1c~6r#_LQjAK;!UpGLPC|F+F)#r@Z1~6YZRy_HyLe#P z$b2_+D}0k2o)d^;oe0K`r9J{jV*iqyOHFEIfNDD+GAukL36cy~az657=?9!Ty zqRQ0#vV^o;(#zDW-1NLca@zRRoQUXTipsF4)R2f|2S?aw)(iySDOTU$Eds&_W}u)S z|2HNh_y?E_rz65&PEv8>Frg%;GOegzVQg;tKUF4ykBT6*&O~Hg{DR_Q=p+-%va7 zSn0!~O*5Ba)6`iI=e@&1ydxv%HX#W_zJ!kglm_lSw@Ied$)p-lz{rOlBVnxw2)qFP z3dgY|4U#udO26>J))zthVIfLc&5adgO9;9YWxCtTfEZl~#`@<&SRKOjH)Cm0JhC1j zioh)a#PA6T!KDNmk5Kh6zhz-NX~k&8&6k-(`27L~^3VAt0vCyBKx%bmUXCDC#8N)M zd?dEBE)lwbHXvZ6j7OxR*m$x9SnZM&kvSppK=J3~%Xi9sY&_2#j(Vc%9=r45CHJf0lLAsjDcs^ z7Fh!X0X0Zr0PWR4hc*aO!NCV60|f{`6C+mKRDd1$bux=nl6E0O$s>{vmYbC4i1qaJ zBq$l1+p09IOVCAUXAh*TDCMJ5Q{%IPqd!+yV~g@5ze@LeKx33(t9bcxBNUWM z&`5>*Av+O(RACvh(g0ET=#rom?E5ayJTTnwj!;pp4q{y|n z?byfw+Q_A&+<@>%WK+aw@O25xtR;RPK8%r#nW42QfD9w5L7B`P>;&}FXxNpotx)2l z?KXALSh)KTjKE~racJUr*^)TGYqSvRooJl^@a?dUabR1a>4QW9wL)p3W&>A_?Oj|4aVFIEBV zeuGzDFx~o+l^$%FR~$`^oovwsdNFJ_C^01@BU2L=ZlreNHu54}eSNrHoH!84G+yDZ zK?&Z`>HbMsJ_)Jz0YR4T9)|XIJFP5sm|Ac)**GyP5IRkce`1|qay^8Wpo}UzpKxQf z=MGEl4s(sEji;r9pRIeOHaM9viw=P?=5D@v)^=Nsje%uez>f?B5wsha6Bl=86z(*I zW^8JPZEr|Kd_`nxV?aV}WL`%|X1$eX1hXt465%2a{A=Uv>Fg8i<{zQ)41iOIu^Uk@ zA}T39F*7+$1_;t z)}Wcn&9BPHEKg1-NK37(s>6qNv9)I+qo9$g1PLh(^*smb`WCWkh9fiDy+Vt%Ua8L7 zSglipt8J*KU8t8`khg7subqFOQ&^~baztQJW_D+F%fXJ}bAwB-jh=pg`0V?AYp*xW zoGu;~!{b2pxhsW-Guy*6EW0xM!EnV;JKT=XWm>gFZ9+(l} z7UpWBb~LfT6cj)PM+I@mHQZrsWyaWR|B%q2n3$mW#L%RapoDlFO37T1lXIBTQxh+l z?XN&f6tg$Ooz@H$RJ-{3(m+Z`OwKK>Y(cGq<;WonF|NOM^4^mxkDgz7_z`n$uDt#s zg+D%}52!2O`~=|=fXwS}eE~fNH0DhOnE{i**B3JxBuki@Ubyz;)P+~qPv1Paa&~NX zt#|h%Ud=I43E0Tcb+x3e2B@sGb=a2xGCGzB5+2x!8asC|nYh@N=GNuo=ik5m&fhIu zdaZKzoPT@)m<&8^62Bkt7R91ULc`xM88)(<<_c$qZ41c_do<2{dO))Ml@^0Ucd|B9 z0|#fdZ*Wj}Tp|NH6S7J&iW_U%h8lY&p~?)*tnHs(!9#{YQG*kU10xG?WA=<4**&^E zIDUjwYGh`eK}bi=-vPO59+`>EDdybgpdrL@eACSoKxWGp=1Ex^?Q{?)@Sy1UA~2Z) zs}~u?h1Q8}C2UFN+HZfEa0jnOfGPcLU@~fZ2OnCzr66R7!DMD&Pc57nKe)~e?&S2U zqOy*eh0~1nxqAP7bY!o8@Y8$Gz5VeG?l~bLW;;ZyjE}HMMwg zVB#3dte|pNWKuTmMUl#quNuSM71a_UksJd!U)BlQE3p&D+t3m+Fi~304j_F39pMA` zMM1h~fw7i!Pl4#CyU6{3l?+~a(PYbu4*Gg(yk!hc{Vg1mv=JrYg>`8yBOQlNtUkE+ z>Q^6p_77iv_m?k!^{3B&^Dpmx`;Sk*{r#&y`sVhhU!8yZy~XP{mapA7^YG0xuRc0? z`?bNj#lqS~Xwqb!_!ThN4w99NmCDsp9qJmE6q;R;-?49SWpVBHnVaukee(I{qxX-$ z{%G|0dQp3`bC5SQW{w^qErCl5axMrA*%hf2rilC}QITcAF%30T{DrLTAR9AdG^@I< zV`6IW^6L2U({racmoEq)bM)-h6PNFU$s9i~*U57?PhGfq?CiCpo0pbPUO2RVW_o^Y zWNf~xeW)P2Dm$U1FtxfWzhijd@aZ%6uit;~%4^S$Uwz!Me-Vy^r%#lF%GKTiMk%?f zvyD2?Kei;hW+9z6a1>mU5#+T&kLu0H4<-E8hX zQdBh*5mTyh46(EDwzKwCJH}{S3d583woP8|Tf7^=+#io<++|V2azn_nI4mW@LGNp3 zU_w9K&CyCrnQm$8u5k|W^-YQl&q+=y&rd8ZU_N+7OM7B&aav(zV?W#C%+X6Xr;nZ@ z?j>cEy3lTL)H>LyT(#PW==j{q`m*l*yO&NMyl`(~<0|8QaUM&`tqzV!^YjaM_Y85g z_u>i7G`eP^m=(jhlQr%<$|vomKCmE z!SoQJxKg)}{E(nYMy6C@>=8SSV|Y?Rbb30TmW-n%kLD*t=nsPzK=Q>G(H_#BRay5}R8Unowq?3I>qbvc*go z5Q;{C88iW@CFQ#pV92zOUoLK1aP=>=RYjPYd-(XrVI*#9iS>tuw`O6bHs%n}6J-!- z39JTF2PX$lUnk#SwQs0PV5D1Ugl|lIY;JLSWkcDn{>FicuCax^b8Az}XAW&#T|Rkd ze(l=Au^ZEeHe1>zaxM3$n8GG)EN$pk!!cW?*f^VPc>%F>o?Bb+NPYc2EU4I>FnIaq~{m zdL=u0C24$9v03&B&kl^v4UNeUi=%l|om<`xEZ;M>(!6J`s&f=h5n8AEJ(FdfgM}^K zTv;`{^6Gl?nGuPx*uZSp#3Ft*ZNmrod9j5l>&z|dOv`P{EAB3>-V>Kx5gM8s6qp?v zRFoLknv~cT5!+c*cWCs;!*h>+e)^4{H1ApW4#>APcVlXj8Do<4^vrh}pp_8I1%}JJ zd%JmgQ<2d_7QT%QQc!bXJIYn+8Gc4iSH(&N5hxr6oGxgWvY^wtykNl` zXmU!CYbs$G0jbK>%tlMz3&?0~E3gcbB};p?c!1bBfbDYeYf%+p`Ag1Ec|vJMDM01M zMb1yDEd>irXV5GYBTQAjLW5$nGT_O?WM!rl6aXXVmeuE1HKiAqrxujpf0dS*m!6ZG znwu+_3=mv&N_ccyNO-E7XE;WEJM~N%#f5pA&Vd1_Lx;(bcmNtumFOxI`p^6yI$4fj zGMH}|81e`(>%+LFqPDHIYacD1z2k?$WX2C2C&wVQfKu4FYfoiudwyXxskM`%vkbTq zQmSHOg=&)Szf%8@+vwH+H8PJCvWjm|AQlbWJ?=aO3oqyYe@VP5X*4S&0(p^CPwZ18 z1MEO`m<%_H`vVSK_v zy&}Rr!(+XpVsY#tVPJKUJ^;H4B^y3AD?+Kfcsx7~26oZYmxrY|k|6|;Qh7Uy3rwu(D_-tPA;xg{o+CA;;!-X zV_pOUOt~CA1J#~Eh!BY`+$4@Uu|ZZCP5d1mAB-pEAyVS=TEJmsf*9mbY##)@;R6tW zq8(0xPAYw|DWgb@Bo&*C~k@z6MxC1BhIUe+A7Fk|3ISY)lL= zkySexTU$|XvoZN#D@)|$@9vO^^I)VZR}U~5=ro|L>~6N9^uvUoqOg>e`3nMB0J5@e z+ybp^w76#jp2%WQh9JMfQ?r&a^h^(M@d<{sgZYf5g@Yvpuu$Bvl$CAE!v#F#y%2KQ z-MmOf$nhd!ba0UY@>dX*DJR`ldXD6Q{0Z5)3QvZ$$y#MOv6DgXnHWN=*V$2PZ>@4v zIWrmtzh4RyOfS$eg(cD{4&^aH^up+gV8zAXW$(kj!;Kp^ZwNLNGdw{K3rHjUb>a`t zKzGTqVg1OsYPo<7b!ZHq1)fF0rzqg~%-SQ>7brl{%ka#Z=cH>WQBY+4%lLT#3 zFd5z;yH$`DOG|hTz+BvFf+yePh~y%?vpjSTy(ro+%L1p;UDODm>u?Uy*Rv!@P{B;( z2iR-KWbC0kIx=k36w4PTA~`zncC0i`Hd+lO2O(WYhUCZ0u~23?`G@%=WdO;%3?ReQ z9}qi{om#`=(qS?r{6I#eH&DwE%gCS~EI$dY_^Tvfe)euW=EEmFnM-b*laU4dr2Q7Wq~XNjZwBd ze~6n)oZw$cSi__OCmE&gARx#g0*A-Y2!|rbc>HyaJN^a{1LQ;R5#A~hren`tK0ZUnARAc*W#aAt_{zy_l>h~4lz^tncDjr z+WT6%h9N$3j!1D1kGJsf-D#)V$~ed!+g{i%?~0hi4G|I=*34PUT5JJzSCN(Z;n5+Exro62?B0`kyzNF+0?pw`1yr|MI=PUq{Js@Bxe>RXgXh>=LrIt8pydm}xA_#+A zvQZV^Q8}g*8L|$OVWIPX(f3gRnHTv&hM%&9rNrV7gE!;7V29yTWJ+RGT3Sp-PC{;J zZe?p-`*2(TbjQAf`=(Yg1sWVbJUF?qZ)Qo1nh`6FE_01c9~+xJKC^IkVeQ)b<%et6 z-(0wKr*-T=Tuu@Dg;>o&KurP60`mtt5R5{m$7!7fliAfbHF@~tp7F)_%wjll!ro*! zfWD|Qbt90Bp*$HIks15@MpojuG`<8HBRrYICngVVlvQ^oB$hR`jx4QTIeYyv4nJ>v z_|3Dge)Gmh-!Kg8_LDC!+i*o?jp?=Pg9~Tc_8m+u zu4lp)D~4m2-a0Ug5R4V8bpBJQ?@X+-wh>Y~p6!77iiDQ1$+;#uA{8;ch^^Qyyv#oY zlabg;uY`P05}TK)nzz6Fg3;EOEcLhAY}@Lnx5LB8BE(9Y;ucvHn%7p)Gc~ZjdE(Kd zC%^dWXaD-ucmMX;um1e}SATlXg z#BgI_^Zd$%%g4@NXYBRaYp)+Wdu#ptZGmMrub((~eSP!lky96$%r$-Z*wDx!0GYDf zs@Q-8uH^8{g7lh6cy$+Ezxnz{x1M}?=KlMGi)Ryxnr#ut*f=m~5?a2cgBKHa0urm! zDh5+Z_r>M+ho`hO^vthbd=)sZY1bH-Ohe=7*!1bk4?p?n*MI)mKmV^^{punE_Tt@dj^FrdbosT;k@GcOOSxsc36BIr z8#7lcGgo`N5RG$QKvZY_;Q6k(o5>YJPQJ+i5il;;j^sYFM`)j!n^?O#`Nf4N6lJHD z6=l^`R`>UCSNEaN% za3qq_(zA<7OX_#+8k+5#K01B+*2?8K_RgHFY#2^Tukj6t^Y#sAVyv%ku&s>-oQkRh z8h=(^r3c!4Q+qQ#BPeG^NZS>a9N|J)bqJQF)gmV^?sT*cF>-tvhe_#8OCbirNbOyjkj434lg~#6;s`92ga6?Whq1Pm*>SbxA{4l6Gd0ZP|*~2cFSB9>HnZRbvaM zPThFAdGFl|uYYj;>BlGUJUV#h^61*>?%Bn(s@9;Cd>hwLJ!8i$_(;JP z&N(R1FCj6GiSg~NO+$M-CMLV45AK;?89cOs=k4g?CLZ92SFbJ{xxRn&M9=QSt*zsE z*^Qw-3EuX;YGak{4kIy7-m%?y$98i@v{2h3Y$Rgi4oh6Hb%0Bza`0Ab{PB$;Z{!8Y znxTxMXNC0?drY^A6n{S?()NyS{vpZf1$8Bj9km^OS*4X;A<>3bF8WqJw%!>@mBU3H z3l6?n#+Dx7X%gENawEEO5+skX7_Z1o_wWp_h;0Ap+^~egxU}+^)Z*xr!q~Lp*tC+! zgp$DUJimYpwIm z?EM`yA+`51LXJB@f zkg+uHD{C1lZ`xndG>DO1UQJ(d?O;+yeOOd(U~sCBSAws1VoY?tzi)!p!B1=F=k5>^ z>YE)KSsM^k9hcf))3vsG{qvh2{KLYT_cBZNI;lb}cG}S1!&HqMPJss4Mfhd73{)A7 z)&&S%P;tCd6lZz>M#E zCYDg+6dx_BMjy%_>NT(q#_6Km6w4z!jU>qoh}YAX=B7z)ywQ)0v&P;)+)I-fRaY54GhMa79S6hvFPd=9W7H?U(QVF zrK-hCdAk9k2^6bp8wWSO$=qkMP%E`NjY3{3gR{fqAHv-^2HXTnfspLt}s^sNK-X@$4|hkRe`}5TmbR0J0Y@J($UOg~v1O481(Q ztWsv8v{Gs!B}9v*3>SZe)Cf!lwGPEB7sw9)k$g5W1gy|qe9cPW`@9SV+o15Ew#2e2JAHR=ycR=F)Y5|NyDoPkoCzQ9Xkoo}bAcJhFqgRE7gtlI_W1QvLi@xrza z_HKUeK~aq1lUHJ+q5#LQ7=8vEGPbf9gun|?@N*q^MW~DnfClulvZ9u!@Q2{R?G;Uq zY=M^rlaW6wi8LQ9BQ_m>QL-uh9c*E>)*VX(8j*GkHf85S=~t=ME;y3<2gXE2r=`Sa zX3C7k;4l|&KitIuD9AVXZ3G8IVf0e@_%iIC?= ze}Te8Ps|P2fJ8Fhp=?FvZ?PyfnLfGLi@*QFtuT7q^!l)6RjL6oE zgp00-mH3(q2#8DIboohGXvnBAE;9qz1kK={2u`A$0s^7)pVrKyw*f5&DhH6Uz(rrN z?FF9^1)LR@gjTF5bL650doZA=OsXO zw6tOwlkgMFiRwIeeG_w1WHFUBGKb>G!^NF|c9=p(lJLUKCHo!Q zWkN9qxqd+~U_-Lc*csnN1$0c6mtdI!dN1jczqr1&Ldd&Q@F#-&+# z`C}YsWba^PPI+Y3m-fQ{}(i z-pAN2%*H>?Av94H9BtzlVyt!9W^47r&h3~3$W~P-KvJ7-N8e_F{7~f>VCNhe5Lb#P zUT{XOjaRgxy}OaU){22~-u__Ve$mM^-8cs!_ApW*ATX3s^ti%C#U)24W(b3&pd!7v zKBKfXv#h(YVWhNes<>siq-8L#x}%_~rLd|6MG_pC{EF7H#=frohv?QZ76G>w41Vjo z#!DJ^%TLy{71!>9CzD%Nl~r7pmS2=sSc));7F&E;eoS%>{C4Iy#l`1_1|^1gMThw& zrKi+Y*6!=tdkD!%bV6xCaeGc-TUcbC);Y%B8uvwSmATr+#2PK1NaME}sPqgSb{ML6 z8hTjRda2yQd}4C4tLvMFy80PPxH)*}-VpPc&b~K$^}~tNk4KK(*?;81*vh%t5u=OxAXe zl(+0HZyqde9LTNifz{m5x6nCqVsz>5?1?w$PIJ9+=YVBa;}Vychvw_@5m9;@AoQ zA2$`qTiAK{d8fog*H%@{tZY0!|Jo-@*B;_~9Fks!7?wc|lD8|EjP5fhgdD8Om>6;) z7CBWmJC@&za7n4v1a6h@5I5oH7#cvH^bGQkNJ~mC%x5@eOg8olWvsy3_I<5=Q;b;$ zlNmq2*er0ExsJg}=54j_nZ?|rZTB3mGP{QkW7V>6Y<>8^$?@fL2Toi&eC}rN)O>nb zrM;^w)H|ZI-0kh6LB_`iLN@NEw9XkXzHjCTt};Op$tp)TnxS~{8{)dWeVfAmhWBr1 zWoo8YX~IJjo7)D#WLRkvN6zd&v@v#IwX&uwHLbd*f9~kXn-}lBbNA_2&%XToXJ7pm z;nMwQKe_SdXJ>D`y>#O4{^`xu-UVDnm)7qbIrHkFQ+LMKt~17~YkIw9=wM)CE@NX} zGBBZsq8un<>CaI@Bb8nW@mY5kkn-uYx14v*ibj8@uc>vIjcb}mbXiPEOHtpU@v~PhzW?rrzx(`WfByX2|MA7& z|NHar{`~Q8{_^yjKfLkdU)}lS>vNCaUA%mA@BB)2=Rj6TT}W)2cOVixUjSi9UnCMN z5{;RatGS)Oy+?#=RC;uIYs2L5*qP;%5077Y>-62XmoD9yK801(cuIMRm5X|tXjFN{ zFL54|T!G2ZpdrK5C5I$tLN!OwX>R7|;Srghi?VFr;g!ja(KZD`uSp0=fTj?l4NQ;9sw&wv zJ98YA5(?9uXFq-T_geDC6`1+8-)q4^fpuAuZJgp#+==`c06chUI8L?jgE742&2m>3&AvchDm zr5iU_AG|($@!HVQ(}RajbPUdy)%IhFz-FI0dGqDHp8oxfZ5<6Q z9X*3%t-Hs;;d^J-=Fi-jSh`f(GM<*v5EPiIRr|ZU_yXI6hDF(9si}5}j+3Ai5}8E7 zK_`+xM{od;!A)9nDdFKWNkh7~k{C#Kif&HnQ7K(2QUcOKRPAIGuqp5u0h5W#Y^CpD zsq#hmV`OBv)4&Q-M@mKDAhoj(<5Vb7X|00$8JJk&mWwT z;Y;_HufGn8Tf2Kq8xp(C%!ce%P(g@Vi*$WSi?ybtkH6$P|KfAD{k=fS!78fRuuZ^#-PHdc* zJ9F{C$;$|-4xYF*b>!lKg>#I)Zf%?>E$q!sYs^h=hz?5gbq+!@ZL4RBHx2`ROm^y- z8Sk{D5K}T7@>13Y#UKbjej?`PPV{6+pD9d8r-`d%N<0O@rW7T(WT%QwoP3PJ+{Gix zFEk@Mt)v2ZY~N6MV^?}%lV^CYCafr~e5j~v(K)}<6##c62s zXnrt)P_S`~o6rPV8DlbHX8{+;Ok-`KMMSQ$^|ZBe1E{gL^Rlz^A|0|21EKhZdlU*it z@zxi180o{GByWe}jw*_BK+<@uI7z$#?UiDUl2)m}cZffdo(Y{+=1`!m5L;lyQh-`5 zC?o_VM<^LPMffUw4C+Wqa~y&lwRBz_oV|A%Spkje8&EsigU{GFdNPv9-o=;okKZz= zk)@+ERU1xto`C`Mi0PP1I-xU(-M0Njda?@PlRJRdv`27Ya6(*cW_EIZA$+a0q6$uy z+{)&nx~81+YGz?$`J0@PnORtvSyB<7T^N^96cUrE(FB^CI-qo5EeRJ+N(q5Cbj1i? zaa*J$p*B%Is05{C0OAlAlpnkrcnVrKZ&>B1*V}uC862>8e386pdim7!VPKi1{(aN! zefw)$dP=LCGII(&T;0vFJ=-BwuQWckOVfl_8bl;18*%(KmNJL)nj)H}8`DfELwNcG zMjZ$vg_6SF;R}hD3VDVEiA5s&i^(8n1S-)Y@T3Sn{9EoGNC@>2Wg5jAI1Gpxa2D-* z&;zPP>@NUwDBLLO0U0215iqH#T?24;iw}%TgItRIgxJfAAyrUr&JQwYSwFyK`rD!O zP;XL%@_zWt>c!9l97Zw3Fazk|!mSk95c~p|%&a%wI~pi)%u?8RtP}d>6yv;RX}sgl zAT&uCMkBZZ6S#H)x)?LY7fgl`_6}|#jvkR(uUHrF76|kBNP)F^G$Iy(3WR%v zlZtp~Vl6Y6ul{rliA55%-YF^<^qx#un}mJCiYGa9sw@?;cOX4 zS3j9DiG>XDg({e-O^W^zFox#>vLU0|7(%32PVpkSft39CO;P^y=((%Bb=C?iOM(IY zeMK8Z@R5zrhdvxh;VOvXu*Oy7THF@euX;v2P9PwB5&#cjBjCoCkd+l0m&lBpi1?&{ z@F-?@5l_UzUr0M9Ou2G!a@V>eS@m@f40QAJlcU+q3vL6z4oir2$g}1)lGMpc0N2$Q zX0J2|Ig=FzEsL5DUFOQNmzA$$^3Xq2-~jU1ZKMLQc)SVtS~jWJJBZN?=HrqWN_ipy zRhTxqTcpE(SaMuCOos1p9|VU{_<_Ja9D(w~m;e~zKVu?_QEsV1N0;UX@HqWV*;|76 z@ikA60L6j_vJ=Z+njqjRirQ3Ok_^aJ$dCfRGi}Xcr&Co=WeJ7G zjNx}E>9lTG44GTm%XBScGvSh{@t=ziip%f_hy{}on|JJll#2z-GUgKYj`+Zv)5jqA zGdK);bVR1yUfv}QSwTWTLIYBLDmN$ zl%APVmVwDg=pki-OG~G~#ulm@n2eE)lRkrMQOlYcW7I7DT?#iaV^ViQ2y0(~m)Qcc z2=Ndi9E1IQRv#lJGZ`w*QM1qvAcv39PA{bL;cX+g($#>D%@ z1FWUEhQ>gcK@#p46722k2P^|76CRxq6Q7=#mLH!{lv-GuRoanVy{DjgqHf?w&A>w8 zuHk})eufJ(N~xr#13)IXtfjoZzkC1Tp7A5KeN!!a<{JBEaFWTdYA>kka3?!|I}6Hxd%}(>OyC`2gJ{XM9Vf=^jz-3=*0$an_prdI;^M{zY+d{3 z`^Qf1IdFN;!p))eH>S@$JACc=+=aL1&%QZ&^yYj|Z~`sCp3>E7`ZO?%gy z22Zw+UKludd-B-Bl`9`!e)7%Lr@y%K{C9Vr|HG9h-)_G8ll2?V=g&NBA6ZQ++!Yd> z?yC*)v~kno|6^dpTM)gH7?sdSlw6BmiL;LncD~`s>Esfyi6Rp+sT~4BLS5Y4Bmk3C z3ug?$8t|b$VSyvS-Nzqa^o;z9LL8OLo2qKN2KLP@uU^@_{3Zipu0DKz3z^c}UqQXl zVKT2h{p`Wxk6wN9@%_giJ$Ul*>rX%BKkq&I2x_?Ct@P61%^&veJz5%8c@=942K{x0W~bw)Ks-56)osz3#tZVmy_8xj$)AG6h03rpnPGd`__RSy7t!;Mn@*yCTN}=w-X^dVo z4(8cIIwu-(8le#Q@2Oft_&<)Xq{MV89SQWIvi8bXzdaD!VWWF8RbNi(Sf2H zH8vy7<6__fOaOU85;zs*wc_n2DI$Q3(zha#2#XQ2=--}&E^h0>;La^CnJQzLY_`0j zR@gETcCM*jQRRu1z4fExgX@f8diVKnKKkiDfAa00zWm*PeD<4vg)jqK=E3Jbzy99m z$L_q=H+v|vyp|EP9=>6&9sw|5IhRSm!nI?UZk)Pu2TbPFr8~^RhAOjm=Emyj>qk#tIk&(sYM)%QhR&HRyVGny72JSmA6h^|M23QU%&eKKi+)) z%hg+N)ep`3rW9K-*El@KC!-;*v@gDRPh>_%cw%#A{+^cZ!z-sB99X{C)qSv{an=f5h~|M}HlzW@2Z{GXrw%YVK5vwwN;?%!X3_}#f%KU>-S z{J_S?^Jl+WxbW4;`qS!x6J9aZCYFAN25Lh?#7I6i>NxMv+JeTVkt2^pU_2wI^x1UU(yfM0TzGLs~Vs4J@OsO{X}Kedc|NzdR? zOhRRFV5*xs(AnO@&oii~urwkn8tV*=iwCBf1blQ)&^S5pU`|jx&|6W+T+-rVRg(Eg zvrHjq$r@DRi6mX((1^P!4s~iHW?HEO1LI1Pa@&1E3hmV4=zXX|;iGVIm@=Zm*FTa1 z5K{tj8`{3~?7(WMB_Y_6+7VCqL%>tc9_~1zB&20)wBBfbAykoI?0jVl1Rkjmbem-B zR&iF*M-z(aT4-!aMbEy~nT1;$=bv49?Xw$ieR1`z&raTdXZ6P8m79+MXXejcs~Z^f zjEvB;FnS4ryP27#yPsD|L2lPX&Cpt8Ua!V0+sY=))XdGm0EZmVcQXTqb_PXxgvJ`! zI2zd4;Xn&3#>!pml@J|QS^$fweSBnOWohQb#_WlcOBXM%T)DP#`NolRx0cS_UO97j z{oHE@kKWibbhN2{e_lp?YE(&VKt_yzdboF@k8`k_%9AMzwnppQwqx%wm$^p*FTqucdb>@m9>H_$-ZPxgnSc4rjI8KCy#pj}+ zEUxKn-#ypVKc7;yFS&lauy4sDv059Hs`Za{4Ga!XPR=Z=ARy;db*GnhBdiXJtq6$B z^$bXMc8hRw3AS_c!$1!&Uw6Mm_ka{f*GLN+Z*wbGD_eJ!+S|(~+{Z7%LG6Lrq~I9j z&&Z&dE=P`xesKw#!7k_457ldXk=mAMMaxRsU4(i)o@7kiDLvuBKdL{4H( z6ShCqP2=S?gQ?kdxrMlb41`2xxOqec2Bc^;Au2mxS8W&~ICtl8SEm4MMjdfCHg~Wz z#zj}_s_`L9#<16Fhn1}{!=7UT{PVp7%EJ=ci`$kKFMWF9t>4a^e41Oa-$4^;W#)j- zqtH%dh83SJNvhE#Fs>Sl42oHbBkE0QwNpJqJ28=3i7bFPCJ>^Y{wtJi#5Hp8O4&8 zZ}LIGqGR1l^@?2pNT#s~Modw$sU?+7XqUibdWQ}S&#ZvSzU-32gjE-{x?n;?Pxh*0K(nsm= zi&qa%Q0wdK5fbJTl>jCa9GB)B8beIr{qn{M%luvCmI#a`-5>q!Ab6D3;5HBjWS)x! zwp9kKXFdb_KotQ0p;QDP5X}d%M-0S;iXn4J#EwWGuxLBq5rPevlt}h?*08zgt#2_h z!qJ!O70@edYbN-pTp3I4PuOvE372to+8`IVK$XfF=TT5Z0{eDUZ#(r!V}vuK^RXe3 zRG=-^JWoJSK4=f3d10Z#4$yA}uCt(b+{+FEKf=qN;-qWC?6ZRid)o+D2OxQPu81;ScmZ>3?k znux+nQR0)(0wqaG!w6<44>RW=6DO1uf$09IqwxcQ_U7mw02%{~X<_d|5JnfsR3Xq9 z3IXmAx;`Qyi;Oo2{3G-v8TTXpGYkfTqCxx}TIAVoB(vzMWm#*o_HW#v!6ctVE3vvF5_V^j6zmuJOCGxi(=}F zWKCus$#gt+BIqmNAs07a0ZXw&wqhAh2 z7>k$yBZPI(xCBK6#H9I0B)K^I5yJS3BA8OPIct~=CR<5y3}y|;s6mn<3+73(_bqi# z8P$?*YY;O88w8V)>t*gX&f%ajFspI4fzt&#B+#zH#A8W|DYr0+w_>viEW;bu_1E~n zxaFKvbb(p1#y0k7mv|`n>O;*EQkfys?M1|-17Rei(DCI6E+DB2K*TfUcM}?LfCt_r zu*iduhpdawFA2j3s?5tTfXP^Fdl6R|>m3HP2i)C#gQ60{lCyzj;IsQBrZHQ_-aE+E zpJ4&v%z8i!sPzoddPlegB>KhX`p4({#OJt0CffN1?XiD(P4J0Nat)88 zMdukB>Khv38yH0XjPHF!Ok!+8Mr=}cYIa#tc4cNsdr{+P_w?C)M{e~TyimD&zNB@3 zL2XZ2ZFgmTcX4%lc2Q$R-R|zaiwvLHwST#}|6py`L{-Zm1#e;PuDq(2{EDXhvU-}N zv@KxB#Ag;DS;CbxJSr(9JU$>O#@!=GgT1YdtGBI}uY-S-Z)#pvGs#jZovgaP;>xzL z@KhWLRQMm#TVcZ0c4(MexG4F-F=+pxes?rAce8i&^YD$2NyRa^xqS$^O3&z#{)yAP z_@24TLq{LXZoa*A?fKfRj}M%AWAfOov7?u!)-T{B10cghoB5;X=8v8|h_x>hmyVnS zlNp{{#Ymqje(%^at|R@UE4wE*1`nQ@I&x)v@zUhdwV~Pb&AXRtdk$B2ESI)3q5D|h z+|7e$o}Rk*)$MnGd+&qa-~aF*&cFWCQ@6fYzxsUb%KHaTzuq~%hCh$Lf4pd~Ol%y{ zRnXtp+h!r-ibU=TV+7I{K4AXQvGLjY@wvrG`G}({q7t)!%Y6L&9UL4)$I6&CwhVEX zVPVk3Z0#5X5S0uYpuVE1yP<2Ks-?HOvA4H>W@-82iPQJ5-F@%MgAdTfAcwj0)>mkk z?mhkt;nIUQp1=0^qx+AZgUP)1)+gXI05Z2;fB)92A0Sy0K<4f{=dV55y!;SAX659y zgGbK5Gilj1n4VeU&omP|4F{5>#N-poS;y9(I$T#*xOi`Ow8x1(t!=L9rnF z6qTo$IWTfC7$2!ueN%2-BPdEfS4~T4eMkMSz0KVtjKhY_MfbmN|3PMZp+18@)7U*y z-M$~GU47edL)&mo!$3u4PkBXmSyfMASyypY@2?qtXv1WFhlLRbDE%Fr z?E#~BM@1!VSkv^69YoFN<`WDnfF(-OK{J>3D1ZzTFYN79e4imr$!R6H3ippJjT}6Q z2x55l7_O&AT^n3J-#ENd*glipI9@lnQrbD`7MZc#+?Iw2=NiW` zxeehLY@aWP&qN!VHKcLeV_mY%-BxNYnqLBN@m=6?9g&!)Aa__HH%?G6l?$yC{42;S%uN};D>Mj|5gsV!9u^vZyMS1q z^upBU|BtEjfUEPo(!5+$ED6zjxtGqR_uhN&O>_`KbVL=sijEKhL>C|=K&W?F&9*FA zZgCvjV<&N{GjS%9+00C4GCMoFGwc1o-*qy}?=wbl;eO>U=RD^*&r?$|L`TNi^LOUA z?@n)CoxXIfZD!_3M_W*4s)@brUJW&rVWA5GJrOo2b4m7Tb{tl6Lvu6t;9#7uTPM!+ z&7bQzyF9qChH~%h+V=GN7LH4cpfT&0moHvl+5Da-bLQO6*xY*m>G}4-Q^%Wn4riBy z`$l?Nx!4(+Im@lR9lTQFGF#dQ*S7ARzw~%=;pWhp8&ez4)*gI0d*j2&ou~7+UoPDJ z!I|qH4sN~EFmUoV!mtoucl8OmHx3m^$#l^|TF z3mBCNbiE478;a{X`p=wS*m@J*&fMmkBa7Etht5?TAI;3F_i~B$bBzl1jSKOMkMPe7 z_sfV5$V!aJ!K^$iFu~6!!qqhpS|iFZ_?l&x9&aC+?LW1Q4w$=pJfbTyJxjTsxwpG- zN$Jsm&=6z_Z0wvp{leY6LdnaBY?b9{v4a!9h!E*7fQ;k@MN~lfl{G|p5c!ab;=BkT zqo!}JW~eYn=sC8?H?qLcEC3`5QYcIhf;2%#R?*Oh9AM{xI*Nv#F~3Cz2lU{52h`|nLE1q#K$C8 zl~zsEH!XGcZ=OB(Xy^V9t~~wW+MO43m!FKCzjbnHt8ZbwX>=_0SgEbAo2rSyLAj-E zcye5IXI|$_XkNRKOM-@>r>dsa8wa$(Kt;4kVOK*>-_F%NJkBK~$|p9#FCjjzC_lHM z_DFYo_1IwB?3t4*EB*6}!%J)9=je*vn%=m+uz6>8_2#MBOT8yo>Kn%qi%w0gjE~Is zaR{TX;VgHxH*vPoS71|apl)ca2`d_Q^&vFBDXgIdO7=z6B(PR;QUY3BXoWo}6<@)! z5Xm?dJ#|rZ7Wtsy5QvplP-P^Z06`Z)DcFdy%vML=M%To_KP=TRG|kmJE1|@^sitYBt|8x#jEpYA!yZl^p>BTB?g5eLt`nxR|FHuK+i1}nAmU=8 zY7`PFKw_j0Y(cOK-4q4@EJ2Fe=D07oQwz#Z$*xMv!7Z^iCbl#*G{@C7JUBQxx1h$+ zF;He?Zz*>&HCE`Uo9L+;!N^7X$lAot5-TzTW4apDB*{K{@ni<(2uWx_wo)~c8#yU# z!=2r;Tmz1Tq;)or-(9%#lhp@5t?E37sW&7a7Jo^j6QzHBpnIjQ90U!E=xSgW4 zA~YmPxIka!b_#QQC&(v~HmS3b%mLL)T|F}beqwbgA(ch|S*qG0UG$;w(Xh0@=Elgv z0v!w7vFVdyW}&SFS3~T{$`2?jQqu>K2lO5wCQ>{EBFwC9X=#*OSaNP;xa7G+^=v>q zDJh||(A76Zwg}c3?@qqJX+W6St3v*cE2A0WiXd`8b1-KRoIwthn!AgiAIK8C9m?p? zhMCA{FDPxhL3+_5vv%T<24I&K5)+e{ot>1MpO94mCX;Yj^e#mu3JXzm3#kJ_p-IXs zrHp9r6sU=k%sxCJSq_A#xPW1xu(6(9|7sG%woq%^Sh~BZetDS-`+dWEjXIP z#V-^AD3UDp5!PyDnM?#_oC*D8Z|voXn_Jruf&vKw268Y0m1(sworgc8^1VWc$ZfGg zf+QpOh~ioarIeTqd@A;CfwsZ*;>zVv`cWgWKB#ZHTTSnEHJt-!#aSz8b3@=o!@yck z=19dsM;8GuGkrsI$~p`Q2)E2s^f%~U5$}6Y%pj4f!*L=96m9RX5&?aG4uT{iY>C89 zgWD0@7y|<|H-t{LWOl|K6KEC1ER^8^A^8s<0SOqPMFO#FsnJP?M+wgmj=E6oKo!K& zLT2v>911#0UJkv2F(Vq_B%T#WD9jTu8K5duTlFnvM&@#uHUO9cMB+d!1DPm8V_k(i z&MYcM_F86+RQUl{A?I+&EF9R@)O4s{=|P`E{0YQOiLt|$2V`Lku|z8|8PHq-_DZ%; zTpGP3%tz=zV)c+vK?z;}+*JkpB#Q9Vkl_qgQ zBpGf$#$h^I$g+6_1%k&Q5=EDj!qEk)jAv*#het>l9scIl_B1?VE<=(ogg)%-kiB9x z&__zpSkQ{7d6?VS0m~ptBbFd@GaxeIiKC`Qdb z5|k&p$7JS69|Hn|q=9VnkSU>p$*|e6;c;CeWe_ok_@@A+r8omXhRf$**ArJoW3ME^ z#FOGj0*E*$6uHIs1*1j)GJJr^DE}0HjkHwMagZvK*gK3X0mw+OBm+Z<&oG*pMC?<1 z7SuRUGMJOB-IDhl>l?8;U;s*jivR5M#u?pvp<|Kp|F%eFOnL$<#?Kyjc8z`Dk-Kg1pMLE7vr!(Q`M1 zh7bBvyBRZrTLqA-tE+9K4Hp{nW14&q!!XLLUgg~^<5l)U1mx3xSc#crW=iZ{37*b<+D?+ zJVcMea{3jh`*>5lqJaeo&evM_pWAx*hWZ4@uyBQ><+y~$nY#yAx(9&CnAv$y6Qn7F z&k$y;9fKU)qwspQ^^LOjj*z+f0^MlJEP?%*=*SY$d&V}Q`UbI+iMpDFnzo~!Ie${UTb1$Z^F@m=p)@xWnH01PPk=OTE*s>1SiXb5{6sa%U$8 z{~-6^c%R73q~eB*>W;wda__Wa_n2&#@D$gG1jo=Q02%wBP%s&V53N<+jy_(l-d-NQ ze!fAWU^1RQLLN3WG9^4AH#Vax<48|==W^fTgZjyxlFnHyo>K}NGV^P*aw-5!;*txq za_TDUAf=o=c0yn>xM1UVfFc1Dg_OL~l3fqG-#>ln zqw$L`M%NzqoV`9UyM1!z!qAj}Wzem~`I_Q5m<)gnLJDm|v$*gybx$>RPdD{0H21Hx zk8cjn-8{8)w|9K2p>wIIawH|MGb-~$Y+heZ&Ghl1ozeAo*6;nzo%etD;KSde$+>as z^RwrlpPafoHuvV#`qQDMJ2eAmlZ%c!c?6@8PWzSizWoRQDh)nZ=qSj7f*Qc*^YZbD zh@rR>m61z8i-3<;P$aj@44rLB+LzUU6__Q5U6}0^x~YFeOmbdHUU@@lV<#{{am|V1 zik6zXzTuITbE|jo?Y(^K#pU}Sz>vZGTIk8#e;-N=n9OZu`_jV?Xkrr1*C+sAfBOe-mPy1T^1Mc0wkENnepyZ>I(>2skuWyba%DCd(jNzjXA zOn}Ok5K0nUI3;vI`JA;*u;WOYCe?q8d(Jd8lJv1 zws56?`a;LV+Of7Np&1ob9-P*cRN5Pvd)(N`_n@H(H6~U<;B=UCphyB*N5o8OzZC&C zH9-+zikyoj5&jR`iuf*{rJJtob{Ea#5-h`yIQR+aDn>av`}gU+vDaYVUJDIP2P1ii zTVQ_Lk%7Lm+uLtHd+(P|U;N_Phrj;#tN-!o&;RA4AOG>gAOG>$7r%Y*>Cdjc|HJhM z4+rKKlJkn>c22M;5zx>zka6HFpstF%f;P;18N^<7eM=2fPjeJWA~Ir2>+46y&TKAh z-aB{g;nddEiOrps>6s&4UD5fu*4`fbb+vcF+1AiPE0SnX#395I8tT|>U zH?ndbhRn#~#@ONpP|Wnb2}S7nVr5I`B6W&fb7FZ`bN$yUAVchakqcsBI`i^VJOm&AQ>4X5AjTKu44{6R*|8Hex!HLD;MlOPqNFdL8Ju;lKf!ZADFTz$D4 zIx6gL%upgsEnP#zrV^5JvT|$6s(Sl}Ry+F_2S(TXhu0fhrgQUJBSZ4M9U~lN?oKji z2NQccBU|Lt-Auh*OuZdsE_QNfh1|i+#MV&H8iP3p2R}Mbi%_>bv((gcDl{t3&Nk4} z#Lk$$ULBdIr~i@i3aC>HabG>UTCogPFU%7F5^U9fvS5L29J+pcp^EF6TJp;>a?X#7~`brB)3=of&7 z4akp3hUl!(r5A?LLQEv-?h(7bCR9CX1{5&WYb2!L0|-x`&9176sDOP$T(+lAH2N(z zia=+tWdFpP^qNyGQ`bw{7XlNj{G&>oed8@{eM~JVXFC|^I_PNFsUI-YRFR`eud*Kt zJ9?@}QP9*>Q2E1GOFArY-GWWDXCK`?%A5YVDrit&fLZ-ifHN=D)F#EkOD*!m@sBCN9c>W`Q>O3 z8R%J<8C#hemSE9TO3?X!a5O5W%t0*P}WwU>OKcLPNUtJsMg@oPa3Wl48@#KpzK5GYhAg3_!-n+LASsMqR4>v~18P zC2lY~uT+s{1dzpu4MIq}h`u~v8PI-!AZ`+cX?%!WJcWBQ=fL;5g}^mXXh_6Z>M6S@ zUAg~SlBNa#+2&P5*Kl|>P#Bmv8*#`SP{D$SK!M3UAlShR{)`PJbqeU@EP@z-h_Rte zW@-jE1EP_epKoATcu-VSa9m7GS{gm_!gop1_zjOshbj}Elopzh5}lqCms!9-MaWw1 zpe~x#3>z?4(W?vGA>bIX8}hYC?nw8j;_@@8W$CXN2q*-(HAw-B4bTcESk(9v(y|N6 zYAPB!8as#D22SCKO&HlbHj8?HW9R76+D^g`G-tvh5^ONX(ZLKspGQE@LY61M0Wq&Y ziUst=!IHxsEl>^{Yw|C$DzR$u0bC@(G6D%veklLR4$cFj(Fa%+$rngUQb!PJ5rBX| zdj#Gi5Lc);Fe&JrfmIAuiRwHR^Vjwr5KX>&cZ=qC%7L2rNtwv3txO#p?7jV+1H&Et z!W?{pFkBYx5OV8GfGweh4Y#Uwfs&-^lT$hGKz-i+=Mx zuW-4n_8=tSGn@{C5Znfyi2y)AKJ{d}<_;!~en$5Gy4Kzra#uZTFFh+)eJe-I>s54Q zhqO%$WH!Kvv=q^x$}NTIM*@o#DNv`Sg9CIgGI|`Dsc#Bo=8b*89hg87zVMEsrb|95 zcphpbUceWmqQpqdFK!E%47jM&pCUR0m1`r5p>mxBE+R<;?Zny)42m@q+!9~}&{fE^ znw#s}*qS&v8{62U(92I*kr+roF@l%I4yCRIHiEz%M#g#;7ACf~mguWk+wwO#VY*lL z>*#2iTN*oin7Id8dWLZm=(Di*47RXyH#DIY08?ONz;on+rRR!q8|(vJ@BuPbaZuXi zL;+5T)tI`VXtc|zLATHc&y?h31-A#VPAM5K>W8558k$@_s||pRSbx|cfU4M0p~3+d z7@0GF0SZK#EbXJ*LLt&3&-cjv4418ydsmP*^!2py=-v78Mwi z;1?F_bz92&RLU9xDUm2d*8+1Ne;0+FEdFoZZYE9gQq)=-h$- zNS%=rV;~742ZJ9RRRCSmv=xfklnf6XGBA?aVFd_6Nauu>NbTRCM-gJ1Kx2Sbl&A}z zxj#SXPD5ZaQs4*X{5@O- z9g(Iv9M)tqM4K_E5b+uB#40UnL$8nt(u+adCOVkj*aMgaCW9%Un@50)SD>4JglA-e z!Z*y?BgDot)Y`?*+}?xXXKCk(u92<1mo5Fs3O`GGKP%Tj3-@4ik6;VW0DXniUJV^u z=vj+_$QdqNgT^5PJ^G+cJZ)U!y~7HF5-K7x8UmAR0#c3#q}E3kv?tb_jH&96s_ym7 zt+PuimWQSq2gDkC1sJ<~TDbe#`GvSd#QG;?VOouKb#`S(c3pQ^LA6hMiC<#AM?|U< zG7kP>7pOMse4X7BmX3 zw$0us>s`pM>`TqBPsyrGNk5XDQka-nkeO9oQr1&eKXI&i;%L)wPI-G;QEhrrC2BJX znT07?1qk4y3>g6+6P*+gi4s&eAS!l3xDOyJM(Iwpgdb2hQPHu|mfITJc{_zgMi-^# z)Pu=HCg)I6hwe-LOQ=_|2<)RN?RE4z;3`liqwruvv|)(&m%_(8BqOW%$gu_}qvcJ# zHCD#T^X2vG<@!z@ry4fx8EOIe=@vyb6|S2e{%i*$7Im;=oz2K zr?_oop{akid0>tnrKbMX=E04&@k@Qv*V+fq*ECP(l=Ma>9ruf>2uW$qI5q)8W_;t_ zjYmJZ_wnD|e(}w{7vEmI{-f#Trvnq$Te~mxj9wXAdN445^Z3w0Zf%EKU?edQgbG0^ z7ycrWN(sHQs;VqX)@b{LM1&-ygePYTl1y4I@^r8P6?XQ9hK4K;Qfs3CWW>^no|TP_ zPk1!tA(T2QJ5JVg57+jL9Bb?$7^to99T{F;SiF95`^na|XWO@)!{Kj$s)tj&z2+1znI%Z2of62PRqXc2Fwbb1A9$0wXNk2UT*PWp%sBjigLg(>$??wosuTGY&G}_b#g(n4bzO)vAF1gsZx}e%JX~DY zhw4#rZFhcUJFcmD__i0+Cufz1#^gAAMcOz8TPXq+j$!tm(H`OHK}ki2tJ~U6O_#NI z1STeEnaadAOjCxrgO6`?OhR^SN{)A67}Z!}1Bpb6U?1F}1IVuvDVUnuQM;#2FDdgV zCxCoSQO!VQ^C$|#nfcXd{B{q{A>H%*hd=-DZ+`RS=DKQ!4 z@(U&=+_CrXB@{5%)pfMANsCYG>l)qIxck<#uRi?bcP~Hu_QeO^eDKNdKK|klKl<69 zKK{u+e(+;KmAU)rPp`lK@!Yi=&7)(E0YRK0O?vdC5U$f_PDY4KKX;6!)kH&&T9+*u zxS0nwOqmJC8XCq<&s{#dar^A{?Ws%G2iG<`<`-&*hH{SAg5a9CIBHs2?bFrYwNEVX z`!v;&_KM9p+&+1FcIV3J&CB@XfXSRZyLx(c8$f3I+$PA(!o}+xU^2-3BKAxB($vyL zNHPPb=9_wk4;NKLN2Pe!d)gYAS!n9o=o>p*+535ihb2z zb7S)lV9QKxzSB6qoqc>ZyK$j*9`@vU#{QR3g|J}cT_sc*1-=F>IKe1u@;kWwwY%qrr)a@e^xd8^!UWPoeS?bPTec*Iq#X!sI5rdrx&SX zm9B4>u3;XIN<3`|ESZc(^a{Ac)>cmL?x8^eDG71KX~`8?=`|&VtrcZG*{N0GK50&- zJ_&lOHv>YEg zSvNA#FnWeA+TrD`f#vgE3o8RF>qBc7MlNoiT)S}k;?=415M%C*ow+zLa;~xYR8`eL zeooWjl)C7k93B}xN>1ipz-11m4#=sQ>A=6&F`|Bfwemi;3U&zqS<&CkdL;yx^z^8I z!O9>ZLM)xhuFS8=(4|VcIvy)vGBDC9v~kloxD!NnVojG2azTI4)I}Kpo*TVRrfB*k z9(HjF(bcvw(6g7D`6|59qw~9(PF*YSSqn{T3Qef8bBon8a@16l9ony>iU-|ZJ+<91 z4mGGl5%wtg0SrzWHh??!AJi3%T`Ib7>{I91vrp|+c6$|qRZ~p^1@=sGd}*znN&1Lv zNkAY`bC4>Mj)<&b-(CVX7BhlE;#er(PVQc`^ag|_hR5Y__y#8Xc*VLo1ln79!HO|P zY{k*L_~>y@?@(RyK|iZUMOtzC}=F8i#MLJ^0!3t-q=5Tk!}?6&w{k6Lt(yIwaWELUO_owhS#o zuv;D7++l4&m4RL^U>PYnVqfEs%C$7_b1rI>I4Qo+)KB`ubEFC{byWySUWT-eA&wrR zZ3HZugaV!nQ2~0ndU9)FC!tA}WQj8iFpJP-l5DlfD9QbqUw}CVrY1^E20#YDNfi>0p?M9v|*6|B+KOV3hqJg#A((olF+g#n9BsH#mw-5S|)Vp42x*HYXj-Tskix zE|L0?hKPhn6aqxrqMY{V=h0=zJ*0&n2`pWGQeH1le^FkC%m!PA(mB}y**YCh5@kr2 zN(VH4^q^dQeZu48;mL%=$0lUqJ&}!_M100!;T)Qf&Jh}ygoYuZ6b;~k!ErX$E&yv{ zUV!;ZtB}a=qz_ghL5blrl!jdpX9QbD&}Sr?y>h)`izF!^?;xdOMYT~lL?xu=msOTG zwAHr{bPi6^?LK&Vad2`O52m{Ik*cPC!my0PrEv*a3^OfFBSBm|q)I{rnj!XCP)<=T z77>mz!vrE=-7_*3T0P_}{D>ED3gYaz_xw-#_#UE>a#C_|F&C6Q7a}84;S=8!kr*9X z{GWVN7^&g8jM_GiGY3eB$hpux5L6tP`m_O}r>lnAs4nGrGkbd*cTXojDz-r=azhIt zYX*j59+J57mzC%oKnGVr-iJuI$m^w~j}b2Vm^7h}=(FZxRtGhW4yg0|%}D>5 zN@TB0E1KH~h8fSa;E~Y_vtV;`xvfyk1S$aorwaqvM|tp$U@|mJ35gr19~5!WZem@d znM_L?R*A@e!OhSI5G$yFWr&?PdG0Wh9Y8%O)S+$5G!(a5lH?NCD_|BY02#Txt4u++ zpdAq12Xd%@{j;fVMN+&?;QQ2R7c*jst}o4NWJ+j*He z`TQ~~o7_^0Hz+~{SsKEvVdL!fpSLB()m1AEM4+RK9io=!Bnt;DR9w5&M|06?~ zjc7peH7^E`0W<}IW6cLN1Gxf6C0|w^(A${WKnk!afRE5{V}`PMiV-E&S&81uUkU$Iso z$Du7_B@yo7oUT9#V7Q=MBsC0js-Q?bQ&u4*`-MBmKY5YZI`|$W6C!vJ81_$Yv&41b zn?mp$eHcOw>4X0ZJW6zU3Eduva6*tQsOH2EVgV72R4^O~yfg&9Cw=D5iyjBmfcZ8o z7+n;K^nd|*E<7NijC}1H~1rf8)|Gs3LCkLJ1M-QPY5L^B*65c zh{FdHJQ*DjMX_k$GsR#A2!iOrhQc#qeULuHw!RlND*@IqJj4j$`z(jBXy_W#RNJqo z^#+ZioSWqC%?RO_!TFTeNJcl(SKYOnr8}~qK=RiC65GIkSovV=rQVCAT zQd^kYo0~dVm^mUmi2Sdalb5wuARHBQPe0}$wQNQd1DkULM5S;nr;XM<%9}b)2yECi zN8eOS=QvB31cg_cM`UqCZc}1qe@4q#PR~qw+o`bfPS2c5r_?;VxDYGTbXHOjy-~ zMf-$=P)YDMu2M@}r~EV`HT$vF-PsI9~ECx#ZAhn8DM*6L5L)emjd z4_>V4S*`6{EUz8UE9#1huL_E;OwQ{qZCUO-eRuBar}QsedG?E)w|;uz&W{#1UYs1e z(b2h4RXtr^jf~0p{;6x7Q#&V4pFh$u46DjS;lR8jFaYbLGY*uA=$SnQqCZcE_O7t_ zjKHX5?}!B7s3h<3NQ{G#_GOZ?8h~}MHL^so5>gRBb|&_4UVcr}vDUu&lM@Ytr+cAsn0xPE#d_(Upv2&F&7oBKy>aKgotw{SS;F~x z^Xk*hYi})IynS~4`uy6}sfEp4_yZ1@*0Y$D4!GGUbjAurl;aEFp0@ zx%j~ZFf+9U=w}I~R>eBTaHSXr!ho9{4YXD^ZV=D%%Z?XToj|^(v|+HSZQ@wt;Njwi z>c;-Lb61}{|NPUR{O;LDKe_YhlbsvyZe4k2WBbYa_M?rRCu=*8SGL}qTD^&qXI=YL zL0MN_%jnSLTF=B%L;q)VZEmax2&J`^<(1t;dGNLL0=NRfySaCSds1dXc~jHG`0S;X zE0341Kjb*Id8K!G?ZnJ%)yUxCruvwYQt#wsyU+mpFh9TKgu`_;-7~XiuU=of_ZVu; z$m+$B<&9B}#r4UB4Ja{-n>Q9WZ_Qu0ac<`h_{_}OCP2-p1p&xV?mSj|0wmeP*+*ew zh4Qeenx?s)p`(oh66giTjnykZ}4ebkC*FS##(YFuZ`RRja zKYizuzy0EyfBp73%|GA&=w~Z8Ud(L2)4%xe#F_hT({HuT zK5shxEVt!)M(y>Ywg-JHpHA$2**yJLe8pL-pei**%5LM3U0P0iG|lM_U>_ta=f+~q zzz%L{YOgSL#gWI`DLmLGF+TEeWMGnyLlAwVR+<*_gZhR9p0DrI-*-@N?*V?9Wm&i< z?%B_Q0};tSe@9MJfvZn)QCa`l71XK|vdZlof=p$0XoC_`fXTq>uV`%ajf}*%f(BJz z|46n%s8CV`j_6#Ez~iYN~pOkWdp5p_Ie|VcFS*X$-2^rV3k+u+YRJznDCq@Ek|Cc)6*csj;tv zO+<+Q;qaimV<(kCwKd&R={4Z*6pbXME{$|J->xn1&JR*}OHn^|*KSVdKor z#xvI&$9F2a<}%6}g=1i8lhJ4Jcf2fNz%(Dp0SHnpHSXl#iZ z2=o|rV#<9gAQe&#Py~@8b3tmwKt?)1M?Vo4ktZ7u#VMjPDY+JnFw~lbWdl4JEe#SS zMvjQ?Bo>XRD$-LX^cShNsez-i{UCY?r6Dpp)!fWg;}F{WX2KQGCc-Tosici#0~>J# z1AeiUa+@F!6nm`*jr(4ob2dgnCdY zg_r{mOI81nnjy3qEgd;42G3n^3j~NS;xqzu!gFcU;CJ?tufd16aq)2R2@VKP01}4@ z!#Zqj>0+v9Nn@88_s!6XMkM;zGV{wYN;WdI#7{)%GoVU|Y=Q`&QQ6R<5)Gn4@sivI zy>?~bx!r!k#o;C9{zN6{ZU+Q10xnr5xh#e zs6?c#t*^vnpza$On*qxxoZUzs$xsB9asMHLYR2kcFd5O^A-D}t-3<*%IXTGnm=Qbz zp>#n)s;@^|qUbmyqCgB7HxFY&eN$7oD?laSnS{PDbBJ&$xe_yoLOJGuVn~QiC>1nPnajH_=5P$zf_tX&{G zvSx-H2mKykGAtX+WyX^9j70D*&<+t^?-5j2O~ZqSn9F)tGLe|@>!^)6x&wiSJ9+!T zCIY`=yrI8zU_VVXbp7yn^&v&L_;?FUCN7Qx-I%0|oYdUHq^trWPkfhXT*3t#stnO= zKt#MZ!V6~1deOT_Rx4l-spc*U?))e9D8Y~sPz*f!S0qeEsU)LpZGtDph!rWIh}fwT znps$e#>8hIId<%LQ*}#M`@lr^@Dx;;(do6Wk-5gM$(p8tBNZ*Vg_UU;g|vJc=$j)} z%VNcH#7HIk5DhgF*M*be3xT>w!nyPqqA^QS0Fd#$ny&;Jix)^|E7mI^zaaRojDO|R zky2$47^-&rI8`ZN60oZHu_!Xb*bp;Cz_9fF>BBuxBfp}FfY$@w5?~WyvPiPJ1L!F{ zd=%b(cD@oO1KA0*MMH}Wk@ZBh#_X5KCjfQ$Q|Jnkj562b3r?M6lXaWy63-nDo)$bY zP!8oU3I!F2k!%JM4?*P2EaNKZ;L#qUhB>Uh!o$=p+`==#$|qgnlS%r+8lr84+ASg> z7#@+%8tdyB0i6h$YjsU#s?f{wz#D(T!k7sA-_(WQM;yMSNq0lSmKU z0(9iI+A@W{< ztTt|5upq#xpoK7&PZbmZ0oBQ%8Ig$GK)cFMTPq*v=YH&I0OO) zdrf*@zGlR7?UbBY9w{do$gR=9p*NGYnuQwZhLOoS!#j$N7~n`thp67#H-v5%g?EUB ztqU24E^6mMg{Wff+I2uf8*?T4cfmcBeXQdA0b3+Db}{`0^ec$(tlo@gmUZRsFSRv+ z`Ka&FR0jZotVM)?%pAWi9xf*!?bH&n7PJXSj1)~83DVjm)pw8?lXhQed1O;&x^U|x z&ZGqKAy~u*RURN>bQQRt7!e{;q-y{^%+(2?XWwps7qQt8&;f_Q>@~B{wy@f7pubmJ zlNL5|4-OtTS0Pqu7BjK7y~eZPF0*%|Cu8sA&i3Kp=?lradQx`7_FJGCnn}*Dk^TDKyqPC{Y+}zF;rnHl9v~xg$ zdtj2-%`NNu}{e+A`~ha@rrap1aPRO~uZTFW@JRpI zn83J%p!me#xFpI7!7=ej*$2g?1jc5@q#cdVIDWXazqE0tykoAoVIsAlB{{1qmL~D2 zjPUT}sHlwi*rLNZO-E`5D^8rM?mSg~VmPO)A*;9wyQTQ_-1yY27-ZIB62hY6{KFyv zWIX(QX`?nVHx=#ezN~ZDqcIs-@5Dm)_;TCG^6|d86Qk=L zlRIsbmum+$j>- zW3#v0JJ%}9CyMfVveQrG=JwPyo$Wt$rQ`Ia)-#)BeWw#js}Y3;1LUIEpG6br0W91h zj+)wgK=z3Zl6rq_ChW|~`0<{v&9=ow6+O4|t?eBhHp z&zwsTMN}9qqF4zg!WsKA{!DQSV!h`&eWapn8oVmIF;FGhr-|t(y zS=c%5k#P8siR~^`on3oDW?mO_9x-mA#|_{t=o%Ot?s`o+2rB?(kR@YXMFPu2ZsFnW z9-ZKulogs$no!)3Qr?=|&|lIrT-G{@5g2Vpn1yARx0N&uRCY|F=Tp`-Q+0B+WA=LQ z{H?arm+A&rYX(-TdzPxY7wb;0HJ{on?_Wx57*43|OKIp&Z|sjLZLkSV({Tzi@(lG( z$&Ec)msD{)CcnfzBHASL{igFogq%}fB(tnd_H1ic(3t^+tOX%Y4#zy+xwGB%^M zwzaIO7gz4e*72r+xyHVky0$UQ%4raL`tom{y!Qp}S3qQ&SKb1UId|dy!s;!Ae^)o( zJb&fs%=tSfr#D-N77Hu8ORKuu`)4|b&(?N~=9Qgr_f3$SxC?7tO*?fRJ8hY>+|k!H zB-S%B-pIy&ubObaBXE+~ORUQh*g_J@V^VU_`QBdu8Ma*|CIdXC1Y`hV1k5JkV9GCu z$Jy<;MyPJNB}Ye3&tABE=fTsDuHAZm{=(yx`TMh{uFsBL-(G+AyV_VnR)$PYvQ{8y`)5~vtxN!U7)V13K=Qlc+mOJK_nx@XQoSE!f zSr}YDH?g&K_WJGRTlbf)-KF*8)cW?RwJna*Yg;rZVXlPNlHkc~-xT1?)^(x!ySg!5+lVc)N2+NUtE!n9n%LPphaf4^(oM)cIB~9}Wim6RHa)32Be|xe zsJn0Q{F!t2mahr$q;X`sv~3Lwr0nwP!rHSL#RHkeJtdVR#T7%@#hnpxV9D@EbfTE(y-XIM`PD+B3{u;$N0qT7Ka-2UMvi(9gtLU4fS&kvNvly-?PGz_Io39whI*#xA>s`K zCIf@?Xl(=fPV8v5&R%Hz(k)IlMDr=rm&PEmzY{n9CAwpPN%dO+%aDshFDFSLHYSoG zZV?f_un#cQF|yW`JGuuZqn4&+Y>kfq2?#3(D=pawR?-(Pp4Mz0?UjqUL9S&I=p;!{QRBC z?Z-$Ajch&dn7`LJxl_@*lv^W~qp}mdou}rwZ~Y4w`j##Zp4%BYcXe{*`uygDg`NA0 zmmjQLd$e%r-rUw5nw8p5&gGRf$He4@1*L{~#`-#jdf5bcTKl_L`q1R-s_;~pVnj$_ zrh^s}#6|jUF!~YshA8`qJd3za1mU7}5hZnFJyTogLq<3wo0zhLP&g(KBGe=%Co(6m zC+Q#`r1=F7Gjwqf6j7m5JtS6l;vZ4Ae@*=D1F9lHKBNhyflgU|Dk0l1BpyN|NgZ!Qa?0Mqn~K<2YVGF_ z5=4`$A^iu3huli)n-IY^DGcc+=%1;Lk4JExN7%85%&wZ=t;L%^TDkk9vW_|Dz;yJ8 zcq1}XVS$HgC?pkKV+61u03#La;Nt1z=8Y5sFbg-92%JQdAcw7lhsOQqo1$Q6B&qL8 zT|AUl>0;n7K;$9j2cV#Q>Oa_t+>>56U=TPJ3l8H13kh!&j!3wWK$zr7tD$1Q;QG)iv37|{@v~KC(?h_KN z6xcMiut#kh?1;1r77aThNfr~3lter=vB?M;3W0)njx_MAX(P}LdPwgmsi*R%yx_mN zG@QBg!BtRB#Ha{`;f&%VB{lU`E$t_IhT8hadq&P+6~XR&qJQf6iJ@aP?FB_uNh!I( z!SQkgwE%(Pt4KMH0AzT7=|i~^G9#4PG~98zO$kw|5v*N7AS|2(@H@VuNm34|o= z+DddrFpZTT{1UHc9&ttFP~zewY5`k6WCPM$j#pVfi4CMw69|{(0wR{o(gLcCwY#Ua zr;oLp7r-V(e40VDg~7nLnFz21n0w@LjBZh*N6#1TD`TG0KlqGL z&DG^#)B&EL9m)YEgM3i5HV^?z+zhBY`!sbA8rf)Dd&^y8EIm_9|0`yJj!!-r9 zqj?a7mMmVR{sOy%iy(bKKLDLU)CE6xq@fMj4$L{=SD=z42DYUQaJ0Yy3=Du}2q1Y! zu7%`Ruo2*l2t8FH{lV$69tvnn5*XoSjCSxMu9}rl@COVHp~_GXU_ zQ@}}GV-%Sbm?D`foB>rZ(N@=hWuyn#1T7OOb#%7bm4w(e#nl6>DoEg(7@FBZ%QUoc zmfO0swH;J9z@!XSVWs>O*DD&31usLm2$7VEIGeDT_6-%bL2V*W5z(=wD%pJ4NeT$V7~+ry z4&m4^h4gvHp@j3y?zg#tYp;j`}I?dBip6%vQG7zrjU zIDxd7TCt9SqHvAOYsLe^UNA$XgH;HKk0=ae1`QwhGf;OR4f0U9UQR^-AYAi)6-_fs zxw9t?Zm8dY@Cc0^Sh)v<>J1wqsTNOAAo;*(Qdbd=p6APFZXKVMm<&*W^sEJqgoAhC ziF1qi%+2JVOca4cfs6?%yzrPK7-pd+Vo~Di+%Y#z1N;_>J$n0k;6{`h@5|a_2x)90X+POOM z+~G=TX&lni<2b0Thq4L_E&DHv6??5RHQ?#99k7ys%y8pbc0^P_Pm?f~7r-yC^uD3+Ndtk3GB{Pef=D3lx++3#V^GTL)cRCv7W* zCg6;@nYxLQy0J{tNXE$Ix8U<&=d@c=OkxPp*=OtEYVYi!aP_eD@WGqR(9((4KZQq- zv7HM981_U|r>MDrElaxRT3~+$blV!6vPu}+JDPcT+xP_=J9(fjQ5X9 z3XDw-O-%QXO%6&(qhBU8F*PhHEeK>L9_^QO+LvNe(1fWcl}ImYP0nvjK3o%>R1_VT z6BV5q8J$M&QhG)uy-O8MW0L7oe*(%A zx2%DI0h<~S9MCSZFe!rP1+eC{lBqvYu$+WW2gktBwWN1aY7FKldQljILvz`Ep zF&&7Ogr%acjydgh$o{*y#l@xM7MH`5fh1GgJqC;5#L4N-q4~~{rLNKC-bu(R+rTmd z(|7vMO0dkum(x2R&TPFuvGQzV!C5Ht+vzb=O2Ucb{48omu8{ z=jr+Cj+2O}9Ifaa9yvF2_S)j=gXN9KE89=kcb;Nz&4H&9{W7;7esuf(2LLiR?!TvO zToNRiD{rA+id)n4%C*x=mrl)}KY41twR5!hY!Jw zRZ?X{Ra%M3faGI(tBItHs;Y^O+)3dd>R*_e($+b+wR!`~l8+YeeX{oCvvZGsID6~m z;D!4wix)E6>B}p$ib>FL_ISnEVwaZ5E)_l6QFiT7-SyfV#BosEcD+JZ>A_tGwD#cU z;1_8do#viW7@Av^QrVtf-JR2LvaE9wljw$_`IfPj?lW7%OE(6VZ*6qz zwb{#`TzdNREARYj@z$qPmtLOPdT-&{Cl?<6{PKH$ck|PKy!hd_tIvLR;r(Cj{O~uc zFTU#BxSP^C>{n1_pLEzGqa^xhV^&>9$%&r)`j*J-!!{mXEMlzoVqpi2*U~VM8M8~m zPN05dYHVXJce1kbL`Fb_YW0vI~?X0XHZ0Z`XZy%=n$=NN`NZ&?V zO{S_ULt#V9&|Yrq=Ng)nTvY855_dpbY+-D3Yy?!Ph%3apsbm;RwG|PriLG3Ca7a0q zWKs8ho2)=%_&(92pcIOJhgTs9BVvH4ep*pU-_*>-+i%`}^78tfch9fgJ2SR9+PTtS zKXbBv;q1wss~29p_2lapAOH44RAqkgPf%sv`trBHG8do!VD8PgI+oW{>zjaO-Y_&m zm7VQ_>NJ}&rz*Ie2M!Yane11!R@L_~vJJ8ejPcJrQqVRqyuNYeGUx4~hS?mXCd{Pxz{&sXm}Ubu2+ap$I>!K`08y>fAC^&(77r&%gikcmMG3 z-~GdXefRtS^WE?M_jgKRnXmrvpYMJB&zIl+dgA=Eu9*i-`KtJUy}WUi7nf!MoH=cI{T#h1$j;O$wp9gsmF7 z=0>I-jvgHLmbP-K;YDlDK^=%O6a!y<7439nbE*8Oys?iIMo=RNUof_Xr+w%UdYf!{ zsU_uIvvZRdFBjMMIeJFPP~6crL|sZpUBg%(nM3fps=}&z|LAx-Z(pzAFpL#g@QHNj zIuw}@91SUZU>_${kN_Fs6bg9*L;;jQ#0fa39um5g?Cc^?gg>QYOjD9yWV(%82o!h0 z-=V}yWOYbGIF=e(>^`V1n)OsPGz=|h!?(2agv&wX!^EUC1DoA9GMZLU8wXF~WUwkC zTatRF12M!wElmR(Yx;TJ!_pl6lgu1KOe}rWwG^s{%+wCZ)eo4UGjCy{u#!32nRy0y zCC8z3bYk-KxtlB3-sPBBx`obI|Mbqpxd&5Q?@nL-V0itV-o=N&zt#QAndLnRx%E)v z2B$Z$Oq#uTck1H(@wHokIpYi0$ES8CXRi#M*&dnMUfj69apmm`*WW#R;oj)nR#j6U zaIU*sfRnYWlev=}R0d;(ovDMu)DA^2WCCEuV}i@-gQP8^l-!3@jWAwC9`l;D(5 zeD{8peX4qpi;OHhOl`ff<3UIhCk{4NdglRQ7#HZxQajQ#(uW6($cL)FK2a0(EJ9l% zFv2;Jwh<9PN(Y2c(S=0Z2u&ZDUy>38 zxfAI;V48&65G0DERrtvQ>hELirGJ6yhJ#lKxSXqZ7~Erh0}B92+J`g|{}v9~Y7}DO znSzZN8CwSgC;9}%QmGVmTRxE9kWe6!Q0n`nZTyP}ll%)z0Go9!T^W)ElsFldWDWdC z&roh`?(FKH?h|p$H|BU&#pKx9TX-*?TzoU3pw-GLfND6IDX5O}^&(3J#-~b7E@xp6 zE@WftPBWd57!`rKXhGtAIbTkIbeKLMvJ$8@=~J)s~W+G!1p0d2^zFf<{#APW6@9IlZRiZv6-EofdzyRPLH=nD}yEu9DC6i zA>-pg3$zUwO~7q?Nft;Mc-+iTHc*BctysJ}Dm47Am7Sv~;o;%p>F4b31JRC)rGm#` zU=PwaF~U<1cXjvBkbt<@AgYRS2?>V}rx%qZWfu!yiIi;m<&l(uEfW@>91t4e>Fr}_ zZjP=B%bGwfrR?A@sD{vCWmvKgio{dmTuB+O_@{vTqz@%XC{mAo`$VBzPuDj*JoCuW zVhNLJ=^5x47=tQva&n<(FeXCrN!y7Iw{|sF)r{TPDeUJG2|i7NdM#v`9)>k#3SQJ{53v{{8=op zl9Vy86P zoZ;z%%#d8a4r-yV(6jb6afmXo4pB95R?|@+0}h}8V5bkHaaIg$<~ym0l=TZ( zm<*cBWMkqyMXIZR!X#VP_s1Cj|K1t0*{s*V4J99{=b2=vitv7&sh zW+L&u36KTfVh>)_5H(Z@b~Lro`?aU(N#DX=Ro4UvMRHOSa5O6hsF48JB_9pSpX^zp zLxxHM!aOhvbg|JnAoxC&W@b!J@Cq83 zWTvKO78tI{38UbCAby3+jJXXyzrns?@$AAJK4GyQ0pW0N;S>pbFTB9OxOklG=~BCm z*u}VhO(C&DX$C=HgnB3_@Q5Kh?Lwy;>vJBEuv>DIDcp2qHgHZ@FhNSxfLrzp@(@^x zuqS3>a08{rCC04)XW;Tnj4%GF3?u~dCP6WP6%vvIOexGV7@YhOUc-rT8;K_9DFSyQ z9s8cphbZH%wIx4OCf#u#(`HX+dA)l_CfiAheK;;x98_Sn$Er0IuPj z3ORIr69mWDcX%|y6TFBq&owfa#dL-wpuf9UQ z$O~B1xS#l`p;xSGXpF-9v283sX#~+SPDM-jHP0p^!E^NpsXh;!2y~$vA{18QOcOQ74is82@y;K#vKCNeYQi4~|PiLN+uhD>xw| zEF~*6B|Vhh+a%0JGs6?Jqm%PNU=q{HQxDg~rW_54&W%hch)&3hh|U6&36D+#oJmQq zI9kYCHZdeNQS?KFM&PylWiCoX*jCqYKqwtkS15Uxcb&_xpUODepODoY znoyCP2isw)XX?t_m6w;F{p`x~UtN9n>kIdPJhAYkyKlR?axyoyF)6q(&Nm~G*I)d_wouZ=5yJXllwCY&9xp{_0MrGw^mQ|NDw>R{SwGL19&#Vm6c`>)z zH@gB=hTOlhVW6VAZ)jwFe&P1~>chngkC!e!A=*E`^Jx3}(@Qs>U8iyB&U+l!?mp+Z zdhhwxji)Hdh<=%^hl}fXPA^`bnBSyRqkC|&y0$efHP73{+g5IcIE)S}9t)Hp$p{J~ zQ;eMp9EOFODJQ}R3SbDT?FMbzjRcdniV6Z=3UhZqx75Vg+Ln%$<*gU1w|;PX>zz|u z@0@?~<16of`}n7Se)!9OdHmadz5Dau?|k-)?GJuDd+)u`ohLo#Zq|*gly*+$Hw_%F z>qtG;l60ggp|}zFC9`QbziX;&c0>Aj!*@!3y)|K?}k-2VJm z+aG>4|M>a9=9R-O?Ivy>$jC#Lk#b3iWh#|~fcW+HyM>G-()@*;h4UCKU0dG1wsh$_cGzSKv6Q!qAHME?@M``8i^U4P#1!e9+Ru%FWfCwFG841u7cbxZ5hPy~gG))OM*m31%zWkCgF{^$-~h2XP(o z5%H~SNO)0G+wA2VV{6+<1+~_W0R|{$pe3ku5Y#aure}A^!2_;_KGxD8kQrwe6iFdP zKs)_!BYP<^7XhTyj|?pv@Ps%)1n`*1z(AHT8A3h+dr>-}8X~jtiAaI=N#F`iS5%QG z(}5DoY>*n*b5IlTVedigyQ~=e3g;jUcF7rG=@VgsV^f2GIALz(uAzZ-mL1|Ub z@YzdCSKgVq@CbyhvT3@ZYk73x&84fK&0YEI#MsTop`D?{ySVjbA8QYa%TLa!Zs?qB z>6z&oS#2L$ZRuUW#=53?}xjkXGoKn`)Vv95T{VGd9#RmJ=fp+L0?s=?N*J zI9MdereR)@fY>>D1_sA+GZBH|7MobQdqw2M*r%+;e!38fsqxRKXf{XAw@DOs?MsS=+B7MF#^hR z^CWgiGc>mqv=b6E2D;!?(J&>kWAL<wYyYi%CcIe-7l`RhL{Z9D50oJ<{D)Ic?LCFfj0`+kNv zPfwmZ>GsSs=iD>*dG4S0v)*0RbIyL=rYR)6`}h9BTHp0u-!DI9VZ)Q9`{K3P|8+2yI8C3V4(o$F{40ZB-cX;0Eb5nszZJ#ro)i= zKwiy%`l>gtw zFF^?h861>t5cvd?;Uf;Yhz27EGnS`9Y z#QeOxs+#&L`ob7~RKP?b`GjB)1WcUi%8JG-A3_Vj73y+eGbT^Q>LVm#!2uTmM zh_R@>a9^SYAP9q5$PA)=!5tZqT3fKsFpKDoe7px7B3@}>k#P}mDfQ;5=p z$Q`hzC!RiLoCA;VMa5~EYy;BlveuKb53MK=* zz@T~f`q8D#>?ZF4wN{M8aniL-zc2l#^Lh`SbulW5D3acJon(PQEkVD02%V5*{0 zAln=|Y7j=@c;gttRK!YKk7X!itEW zdobPD#m?~Fdr%FjMnPEwAqO@j(BpU#jx=&WIz~J9BJZyY$6bn6L{A5W435(H`>e9rWt0wS=C(r78nS1#1im7P;YmrRfjFC9IF zLTU05P&~f#%8tj6%hVNtcP-XC)mRlmAWV9 zJ4dFvha`E2B)JE~dWXhyg(l{P#ur2;mtcVeYb7qdFfp|tAt5g=Iy)vZGcr6YI;Jo> zzC0nlKBKffyRNscd$y^6zUkDZ_Q7S!vOP1KB(oKrV+Du%q6=$0qLXPubMy=Ij*1OQ zPQ_;#>_voR`IuSA1tue~4B!lsyg4N)c@3MZ&S=Gtul`)A0aS26niQGd$ zJeW*MVSHL?a#l@g?Fj&xyqcrgrH8q1LlfvT?L!+WYqoWXHbMp3} zA%IRpY3XH(iUiY6jgB`5JSQ#nEHB^anB=0!9-h7YWc=#esg=*KY<<6Q_t%rxKOI?o)-kbuWOTJ-YV*Y8#<9^gx|XVs z&lMjS%&qKB%s-M**;R95hPIb0_kMBvlfT}4_m}H0|8nW}cVib`ws$O7RSab(H6{k- zMY+dBxkW}IqwJTK9#hj$e{OjE?zx5MrLS4UE?x9;j>V@9Dj8ZhZaH@{6lCKUv=Vc=5&yR7xPj zY(98*^Wn#LAANf7@n;)%-`u?a4ov3y?U(5KUfp=Uxb|cQ^Xn^{V;5F?ho{=R2FoiN zVj`2A?VMDY*+FCAD5RxW@KDhfV;QomX+CE=@BZ}Y z*Z=wacmMVJkN@A3-~8v(-~Ny1KmO1Azx>nfum9!FH~$Kfv-Qc^$WznZ`Q<^0{xF5mii?CRr@g~xp}cRJ2*w4dE*8`@|(d9Aho#*x8|mj3Is zo;7tZA85Z^(>k;N;B;B-Oi9&rPQ`d;`B>qB3#Eq_tGccopLuq6^V=I={qxg5{Lg#e z|I6U&i;U)hjK-7I-J>ldvt2WbM~A1=D(Y;#y|(G=0*{;8+EAL2eOPawovp2~W^KLv zeBw(h+i=0|Iky1gWoGr^+{V*uk3W0z*^eLp@^2r!`i=&r)y-G8?tKDWwt4UE^{p4z zZa!VzdUkc=F&^1hZ@rnj`etiA3ZffU_!Uig@lsSlz*n8<7l^}rdOF{vOEqO`g#%Zol7uZxaPz;d>hdT!r z7&!T|P!nNk>S~!-o4NS=WLH*nV1;yj6Wn9-;b#lWk52VWA1pmyp18j}x~M#=@IX>s zM@jc!%f!WVHy=Iv^~c}*(-*(_zd!%OpFa8BzrX$czrXt3pB{Yw_iJDL_R_P@doEuK z%PTQayRd*v4vmsel?-GkSExPI?jwk$gA@*4W%3yy>(HwH%4dHR;Qd+hfO zXpT$-mRUGF^y<)=R|iL)pTG6H<+uOZxBA_QE1yo@`QhTjA9|*@vg^Wezj`rSjP z&W9!y(G_ceAKaepps(02yL-n1=aXM^mXL;1db9Tk^a_cy z_Xsn$^8>Ze(pT@%GTZi{&dv|1v2lP?%iM0X}JSxAkw)52R(s{8& zzui5sdZ=x#u4S@oaC7v+C&&8lRvnzHY#2Y%eYtOJwS8bZzos=jslYcR6$Sg0q`Ktz z>ZI6;)R;1;R>@JN>G3uBxkrkMj_2kc$;)diC_GwwV6dz2;>6{xv$NNlPxMjXz;PJz zt(65S0S>{IWb1^i?6F`neB^TuR=QDyQ>0X@$xV2^Brl9LzPE@AY3UL5LE?2cv2>uG zNUfYWko}4*7_f)pl!cRvg_D!1Jyj}46P2@+dQENkStS{i&IdMj;mK@gp;9F@gpTgz zAF)@@5~&AsTMrw@5GUX4z{IAs>N72;H?nKbrIvKN2BcZr`=BrFt2r75D3LkWkT3-|<-hA3R28zJo?-(zCVSedES;Dlf@d?%=hwT+9TQ@DR{L1a>M zMEbGfLlfiIKA*k)%eIm0iA7D!Ms^WeT!CdM`%>KJc}cCGcSzo7hMBKgW$%u10yS&i zIB`BRUo-jPCx{>n0t<9pk>HSN;@-mB!LP*Bl01c^iEtV`ic2sVK8F~?x-hfC_)IDN z8KkUWC(f(kFa)j#7fczHlE zlhzN}s6neZ?4X3&*kXZ1hXRdAq+cQsL8F$5DVza#GGwp(6%=2&0ir&hA4iV_=RC_D zJ0(vy1DCP~Pvbjb1lc>e`38i*MaMy#rZX-pTLlMHzQLM1|9jA zv@(m4B_N5p+LnOR(c9a_H-O98(@$xvGu6>N)jyrYn@l02W|Wgqk~mY8rquu29pp$!mVPvIEIHmWIp31UVtEt=$P!sMRj z4vLkwQl$dC1#00lD>r64{6g|Ub1gTte*2b`{H z^CaTq2AFj~kvxB91TRg*F6bohPH9tRU02=&S ziSxm1VM_32%)*?-B8?r%+)9N)H5jad#0dV(1?N@TMhwmI*YolXrF|Gy1KeX=asX#2 zMx*Hs00^Cl?j&(pQv8FYU_uv<@}f2*Tk<}36l*IxHOCg!mJcY-)9>i&YYU)lu7*0x zrivhjGxA>?9dnX zGGAeJ$jSoDk}g_UyXLwUX83B+R0vJQloFwniV{-onw-+C3O2Yp;kDJa^qg6Q#*0D3*XEATpMAOM0}OyhA+#<0#<)%eaOo zS-5*?o11;4Ed~cWcYXk5hffgI8IDy9Za1Zy1DGtwXj;TE6pIh&rQQ;Mvh1H{H zP&|b^@p6hz4vtNaOeu;;E{smir=$j4Fu#Z(w;*5G5)OX;&Y{7+3E?5RnR(5y z;%kqN)wfSHo|vv}9j$FW*KlH@;pFtu(dE|R%Z+^#703Dt4|XJ%)`z6!hNS0&WaLKX z6hzU7rd$I;wW&*=~4T()p&Z+bX%Wx0QPAF)uY#*-eJ)e8zxNTJAc5{;tb%g*% z9sv+a1E`IywUe`>pPyf#zkje_Kq7xWr=q3xWc$f;?fqjNLsKWm=0RglPp$NyN5XgE z^!W17)GE>(Bt#<@Zl9gIKYR6)sg*A-ZhkjU@^bf=gGYY@1uI95_>WyfdM?COjuMATb3C zf#{UH*tCL}-XNQ-GNB+eDTJkD{D`t7H*!ubRA>I&Qs@_nmbaGbI|IdIBQ10 zkH$GWigH}ZKE}?h6l++ItYW^R2?qE&nvj&;`F_1!+fDZA;BNMpCW*~zj3sp_H0@0*}CTGn%1f6BU82Q7n-}Sw)U>I4s0AfcdvW;*{REKPF;C3 zu=MfirBD0j-}cXc(s%Lo(3Q6+Hjga7J#+QV@XA~Ik_Ik58NBr9)Xc5Hxm*3Sn(3GqkbV~@l}x5g$M zP0Hv_FFKuBHd53$TX1Nu_3WLq*FGD$_O5Mg143GP`&ns^>YHjkJ=25S?&MZTjki3pbuD++b?x@Y7q7vSx!*Isc6@lHqIozm zry;+*rLyiYeGMwLh!q$ZAeN<1tc4CMUNhQy<}`W`VDS|~0``9n4o&x;X0zoOH#V={f3a}m>Dbg}d)sJv z&Y_&B!pwk_4DaZC|AdN=tcIkjV@1aY4o@syeD>tok6;U5{O;dB`|&?M`NMyH`ZxdU z#qa)o{fj@&Kl{3W>2^-TQCp7yj#pw`HUvJ(K}?u{-~C7L>uvu4LW9jNZKr(}{^st% zs-SqU;J2-dI?CdgJD&_aFbTardj+Pru%H`0=$nFBaGDUs&3jonM=| zv;rn`Ve!Vy!Wx(i7vRkNjav&_cb0D7Te;gi zS?w9$8n|%x+|s??@ukMjGq`}Y^o|}qGt)h_*fV*hcl=7tp}v-5qqB?mHy?cQ`0Wob zKKt>_mw){H7yt0pxBu5S-~IFF-~1!jCtv(6*V|A3_W8R%K6~@W%}3u~TK^cUxYmJ- z1qXV#=S2^OkIJNra?$1Ho-62F+EX_eC@tv3!1Jek`3-L=>M);a%G=HaEB)`jZs zwXxMN*I)hq;;m0w`=^tN>zzVlcUh|5)6#hl`UE6ZO*LFeZ#l3yVaa@j7ETPJs8ti- zfXt9;QB83556i4RFnD=s{QBL3`r|%f=@=rDYU*om2YrQdgT)2Fg|)e(ot?L*Pjpm# zUV2sq9WM3`E;L`$eT<4P1s8eNipDQ-5xAcQlMw+8D8Wj5g@(>RtVlpdph(_JP>mp4 zKx7)~ZS+lx6dO4+_AcgX3{n+AW88JYi}jFnGf{h)sRIz7@eED0a`txc34#|&7m0UJ za$s00j53mIeD3gufFNOM=V5B=0bZe{YqMM1eCKY%?O@3t?xJIl6+p}d<&_NG1j~nO644hpY9$)VsyxP`r>0rxLVR>Is#b9OaR8HRMl;rlfSmZsA9qXDJ znOT`x-aK-0I6N-b!z~6y8gF%kk2=gx9U9;e?q?qr@Ho<8B(3DjP;K!7f)Oo1fhOPi=p!OMGC1m$njD-!n$Vi8L_ki( zc@19%)MzoQ!o!;2jqsHy4%P=1a0^>CVz)5oQE#(x^Rjey$IjK#!OPUzMaR$r9S_;k zrITE80hk1$>9Gf;Arok~DB$fiRNFcQdeXw?6lUd=VDDRq)NMiIILazfnTLHta!oB< z5ydq$wnpvN+|~`!h&(bQ%RL4rAK|h}+^8eu8FCZCJ4qplnaR8eap{Oh516koYZPh) z8>e$HXw3;RQl1xf|Ey1Z}wez-9B} zrC`K1&>27rN*YoWLmx>f=!O&O5)*?j^2;ITgvZ1p{K6PY2Zu<_=n?I66pF40`X08l zL|Gx`jHfrnVd?^!5;mGej30Kg@0+5MKObd;OMRE}4D*2iQ zkYU%6X{FT7`Amb2{27qJc}Y5b6t)as6u5?qbQ)9;Y978z`ub+pR)9j8Wfc|8hZ~Of zG#>A5IWf?6dK@Ec5dN;gvG(pW&BsnQ9XYYTzBwnqJT5-j&BX-~RPuIavD|><$s&sZ zmI8L7flp*VWVU094cf48A0sSZfu+NJCr2G1b}hjcqLH3v=@IcJlFY_3_8D9Vi3QBw!E% z2_CDZH4E8_)+$M{bamh?!OA15XINOa!tx;_Q+NoHc6F?u#WLXXh_$(^|@e`$) zjxAAx00^-}?neg z;;*FY9Doo5t*o$^SGjvzf-rjpI(r9+WwVR3nVk)&lz^5$BRTva87Pkr_8MRjEDsJl zcF=7UAF!xU&={VoY-BuqHZ+I>+S)8hN**u)kW^w3DTotVs3sarhSZzq$T$BqT{*9z zGk`f+no*plAPDHn)*&1rbail>LhwNvq@-m@;bjTEP}pf2hS>XX9u&eMo9E8$Y&9gy zta082M=e_fzk%NaU00myj5Q-GZ7k)&Z9ULn}%a|2T4pKgLaJ8@&^pyp| zuN0vPYPdWNXfAvAfyt;HJbe7Z@R0|IW@ol@a78%^RYr7K{X?Sy!lJ!`!;z(erHNuK zlarm0B_P47@GoRukrB*{j(lW9%wfDqf$I8hE7XWUICkG&-q5FzwsDO~tvoFd~ zKd)$pT{GtFU<5q;a$d4XcnMqs6YHm~k7SbvDJYHdlA9**pR8X_Vy z6Sft>iAG0@1BlxNCSnjYuna%0`9yFYddJ9x4NUYcY-qq?{)6WrlVYe+TYGrh`G&v% zv3B=G8xIL+Y8g0wamv6+HW6VaeRG(ywCRCr?h@Z6O;ar`z(_iajy|0V!ugR_?p^w3 zdree2CiYs$5bYbC9-3a{5tm}=1CdgX|%xOIqu>cM%;_IE0QmfsreB}IdCU} z!()7X0z7HUw{dW@Kz+v6)y&Sr0)cPeaPP#-)Y{6LQ)P916%BnAb-fieJ;jyBX>ls7 zY0s-UjsesDw!wz(bIk)&744^Mdd}puw8vD`h31z=<`l=~mPDrIX?QYmIYnSHNx7vN zr8SwQb(y6HfMv2vaJAkapIQ)=kR2MG0b3?9qdYaI3gjdyw+d66%EqpOnj@+7%w`qG zV0ay!5FQmrnZw&Z0O~1jk8WPxv@D^z2gQ*UEp-+JEmR;iaVe!9Pcde(}Enwh9r({AjG-afuKgn0)0 z_-7A*; zFUOZYnO^&5X6sj%9{zUZ#@9zD?>3yiR(WE&{MdL^$7Dm#T+_g%uIZaoTc57H{0jh? z8*hGGe(=lb#g_xa8wki0W*te1tc>(Z4X_LFFmrG>ws1Ew_q1{hbPi38EI(K~JbeE4 zPpW8M3E25Wjp8vDl%pP4>3JbQ9#p?`K|czzv|j&lp^qv-L@ub-Tl z2a{%3pm8SzZU4C{-^FaUV!s;7tti9`Uap}o~=!TS-gIP&OvQmx~ z=5?18oGLCjU0yO;zJIK^@_ga`^Ldq{c~xVDwUZ@vQ>FFO6^(P12QSnfzI3o-@yNhx z+nKfYb2qvswn&G2#x}rVx<{||PFz1Zy3#qc*fDseeQ^Fz_gvG7>E_P41MO2>RV^c> z4Fknhy*Wkgi7EBrp~ap~sqU&IXX{vZhh#6$Y#+bEh^U5`_#+8voymE9nI&h6>(5sl zo;cV&hpErOuF|IQZEYNx6sFKl# z+CtM9+y+`Rc4|q+y@PF2&JL;}oJ|sYDWN9EkUTn`8F8t6MT*XvEte;#IhCkF?9tm} zWMQmwcEH-WsJ^amdgk)2yEk8bx_bZh)ZFc3N5_hD55)&%M0-TWx&$S<1!Q@J7Wl-J z1*g}>l{e=d9%{e1cJDoU^?w6?!*u=69+9ouPQa?~;QG*tOpdIsBt#dxIV#Z=W5 zv>!h>a=K@JX8iWm<>&KD_i6ZAT)lT`X>;z35Hx|M2qd@4;a{ z{_=0$e*RalKmN9;cJmB}Fq4#$k4+)*Jd+T4 zA|@S=`p=jQbCSS@@;8AWF(CmVlUW)~_7V0ApMl_(*c)>TYkRNYm@F$tza4r;+ej46 zte|sXfej!7As^Ew!hUi<6h{p#U35)c?Jy?_OGh?8I3_bBF2lsu!^sPs`2-_#HJKnD zF%BO7hUvJCQj%zSp`0M%3kFt3w$|3}enBZ!4V^>h zmwV4FwscHa)en_b^=0QB4GAp|@F@#$FY>Za_jk>V2`?)yYU?|5`Re9VWTmSQ9S;bI zu>i!twnfj*Ue8Xgt9CGSaklXBag0ugEXho(kB=z}@JbHyN{ovx%r9y_)G^jSxjK36 zc1z!Ie0HJA)q`M$RDyt+5E|5gh?&2Pbbw?@+Z@h=r361Zk?(jFq0bJ)StoQOfSXiyV+rtfB?N_M)X{ zjN>Hoch0`?ZvM%h!Kt<`5$3iL)=tST!6k8pU2%ChCm!+(%CoZe)zL9Wo|i!;h0rln z0e=}=1N-=5ackk=Wn`@)Afz`$2$m%JM7@;Jg?O(G=bXRG1|>P86nhm>U!|b~5;93D zp(DX3QW9qNb{-*N@Rp(XfHi>{AxDEEC|nEpCltyx^NIkQ2!zaw@1@;#}@W2H(rAE7u6_?Uhw=NgLu1`D-CSp6EeP)${x^1gU8@jQ%eZESoz{c|Ey zn`5$1u30CVvmBxh4(e<Pw`TdM4- zSJLhv%yyOm=!%gs4-|Nc)RGk>9UllXD_+C=AfNE(!DJxsSlSR>TJSkvVJ5(;!oCLq zD8LW~lU$e?!X*h8M>*YU);7>r)Gp2dGVo*^UES19&Y(0Pdy@Pr$p`@(t50G!Z7m7H zl^lnmfpsYrb_JGUSb)5I1B2Xs{NeBrax>pF-%oT0VE|?k!8Q~HYUo&r6S+aWL1TgZ zkv!DKfpzLdUkUACz(*jZp1yw0xC0xRfgeF2028K-k#!9yYwzODY$c&~_4Pq;CO9S@ zKqe+5D=DuaCATm$zbrFne_Ccmaz-JsD40xiQYxJ7z>r9H7zkz-botSY3(6uHvGS6~ zN@K553t%n@1%-cBGB`=%l=&ur3|}Yppzs8WKw^r z9z8YMP1pPo))G_4x`vwCx*HC6R2?`}Twa};k>l_0kAx3Y8AguztjWg(Y>~Akkc(tP zN{-BwW+&t!GX9*2+!$+6E)ADP`GKGA>d&7mY#)9Dx2k-7ayl$Rd?oNI<1>!Zrwg6>>iaWa5T{8Zh9DtEV5#8BE-~f+FobeCQODjyCa*m*yi)ud6H# zeIN;QA~Q=DAE$sAl}89lG62`ajd&)LbO`lV@v~sWxR^gO53#Feo`bNm;8Z?EuWf0Dl0-tIK&3t6cmBH5l>7vZT zqF~udTb|Mt%ama9FbKk?BVbc-9)LAdduP@)pD-Z6=|;kwG?!9>Fh5NgD+p#X&k6Pv zaxY(Jx50@FI+dM^FM%9jl)04y2%ed_wYjAgM*zNurj|}t4!&yl5Nws;vG_-2_(i4p z!-5Wr_rTSfx{|GfDSSAUle4R@S8!}_Vs1cMp<6ano9resyO&$EnbN$nj606d)59SoK z;)WB|$A)UVM;ivG4voxI_73N_b*9ud#T8dYWEMqd7scerm6BhcT2PT$R-04Zm|NMH zxBn2B49uAr;p${XCFdq&l&0iXrR3M77uRK#Hsbukm0Q&euLecmu=wQQs95MRKrviS zo<1B~^eLn3i@ZO?NH~hX@wB25=m?m`%0>ImLT00ti-&haLO@I!OcJrFG>fosPs(}a#)(vfK0ZC3a*Q%yStl{uZL%RNK8RSapS>b z-2^0*2PZC%Of8?CTpga;JUe@DWcJC~%df{* zzL>fB{p8m7XRd$QG4tTSz+!Fhh328f6O%X2EIk5{S$_V*+N&Qo-~N92-ZyY;PWCO= z*A5hBHYbG@g}B9eT6?<~shkNn_4Vxa4P4Ca{9QugLJOK2htH1Rp1SgUdgbN0%Ma-+ zYwf+%d}^|7WcKLj#oC^cf~KPx`f>{&6La=MH%iVcGFKi55yw))?hq+Hv`&dWs z#WUk;v&)Y!Tz`6L<*{Hgn{Te)d<`bUwR-cV*j{gmt}mZlU4I5iW`6ZPfXw*ib^K*c z^pDooAC8YpceZz-zGcX1wtI)pF4z+a2a=6RfEji>Id*p|9#XhI{o|+RvvLjxdFOc8#Q57K1v{pNxn>19XU6(e z#Q4|5hSbG`*2hOT#Y7#9jyf10*OCy|5+B=~m~c2Vy9-$w`Z(_sjr=Zr?sxLm7bG@fvcH;yMtA@yF;p36PxX4uhkzrSJBu}QgtvWBGy*zMC^*>H6a9NgyzLTEC;t@ zEg?ag@LDD9C5je&`)5psXGiSBck&3OT@+-E=c&X$92}gwkXVh(3~d}$0nw2~wY5XD z7ndJA-FWfw`jfX8m+y6UP8DV~#fN2sJ^HCUL+srn9X(_0JrW&#GCjhJ{F5uAOOBSF zoEh1qgX!&8|M=Y>|KHDk`=4)q^B;G=`Ul$0W*__ldz$)_=fl(Uu)X8Nmp@GrmKQbg zZSTwRy8ZpV+uqmT@uAtCT`1q#?ACGCwRAIZ@G|iVS4Sjzq25?jl6s)F^ms$<$rC5e zjZH31&Mr^QU7fwKGQY4se{~(6%*^6-T9&|MX0P7BV(H@A*3#C)Yj>Y+Jbbyhac^Y$ za$8q_X?a5mTU>aoi<>(sw<(?DWD-c#sT?TWBoqieYJM$9iOakp(ga@^S3{~`|5AseEL^UUi`Rm=NC(> zpIlscId%ET?8?iF>u;{!`E29GFRnlR0z+^lqz-nUPART-4NbE0PO$aQ^G!HX+`KTo z@$0ecKNKIm7Me8}7<1e!pvf<&DKN5y+WnzZ*M{d`F5LefuiguHzBx9!Qrz6@lbpTB zTK(QGo%cT4`5q>)TpuE%jpL+**BVTQ!6l&#VJ=~Zo)H`mN4L<(gkpqhwT-Ny;G&2Ki&fje@`If}A&|uR zvL zlchimNQDhI09`Es45^Rr+JkSXsez@XrK?Xs5<2SVrdQkhW~-V8({fu83_Fv+0vhAO+rBk zO`=3bNq$5sK@vyIOj<#z&i_bQfMxg|E`nqY=bQ|ORZr>!r|A9d;IyD^@P)il>2dOp zwRS_;GfL$eY+~yv0D_(wLm<0^Gh;4~cZ8 zgGrDad_wi$Zs{>gscuUGNQxpbhZz=BcFs}05fzac?b)>xHGS(Rmp>g?`=aX9LVn{& zKzyZZaGJ_Bh=dLT2~Py*kr$K$9u{8#_5_mwl;D>$8br2)vc#@LxnMy&XsKeOK?*I+ z*n|s796m}GDa{$C*v67+@;PZB(}3zW1#6Tw2~Gvzf^@G?=owfpey#Atz+{|VoZP+C z&H~8Ts3}1rL1V&q%03KtQ2;733bDf=f0x68ukRKq1`+vTfhY+K5jCYZ0zV{(>8sK- zr;wzue*i8q@-WXqoWRFGiYNt(-jT5}coCbZ3O7;*S2UgIAEC_zqK=b?yP1_W1SAbr zPZ$+YiuUO6o55u0wBnv!e7pl9!o%W|z+|G*GgAwT!DO&of+UlaS{#?0gN#gMQYvDG zQL#zEVbLC*zF;!^D)LZCNPm)V5sCsg$vai@_dR540?23x3<|FV7(@UWpbw>3%zG!L zVy%&@+B#rP8<$y9QQC00p`#DD9=oN^fyut%3%w8{`_IFZIna8%x~a8fe_cj)epFPH zgW680GK{41CxniJ^R~j1QJ644r-}$pP^@^X8%MRHmph@mlb1{kVJMkl z+$?@K+z$jE02x@ow4(|Dh+7BZg2aHDHYo*rQScxoG!z&?-X#l{cR^$*`UCoVMSKI$ zU^n`r$dMQ$Id17lJFRqEi_y<6Z6X#hqCW>DkTev~UJuNf;2%U$k~<2}< zph8O!5I`X$XfPRoebxdOM+sAj$;?~e&LtltD>TD_&CbNu9+4$NaP&?2PLloM;(v}^U6I>I> zfrU`o;BS!#FetFCsBn3E2eMZrG=ZqucoQ?>&Ob8C`ldq+=K_drj-aCiSO8&^*& z7dOnuX~hD;;6c2P1eqd!yIoJu(9YQ{G*0CcVdWA4wjdJ#GB~-mW_1IvZey}5M~X-z zB8ehvNB~#OLXgh{mSSw#)p*Gi1vgU!quAAC|C3En^cggtaHjB|a7@m5nVuk2a7X_ld!xF}y|U0u+iUTyS=vH)LW8CL@Q@UOg%-9O#Jf zv+y-mdVUHNhHad zWqvBN6iGZS0a5u6rA=6*hYU?+6*#+FIklbMYPc@t*q^&W?`dp!^%+Q64@UVpN$P`+QvWgFs9O$S$K78QhMC-_ zmY@FW_Gf>y@%r~G55K>>{wXj{d*_9^s@}ZR`h<`ya#Al_Pqn@Uf~qQQ9edqFb8;AJ)^yy42Jn0|bXgE4i+1OuwsJHS^7kaU3Tls69Ug4znZQM;d*W*MvIeG|(=bJrloj4j?gzaW4N zh17}VtIY!YTQP64HV6o8E-7bN+rJk9}+{Mc=I>N80rgE_N%aw_Qz!U4CWm?F zq$boOzp($nK;036S=vs`ksJZP9PODrc5>>_iE}4TUpPK6%YSzCV!w5%t!J!5?59Ut zx<~7d3^M*@b)5zK+fs6BsN>UzqB69z)3dhJF*Ds`WVF-3Ld()pi)JJzJ40_*nRtZ6%X$9e~+YY!YxNiGlaPmKu7i3u+P3#~oU-*oD9Nn4w9M5MmG1LE-L7`Qt6 z1_vZmRvqm*J$L@{`jxF`05Z=$`|Go<;z=JcV0h!{msL- zzqt4A+pX7MZ9MyI{pn|Gk3PG4_mc}ZUZ0tN*fq5UEYmu;P}bC&UEY{mTJ7NzKkk41_lwVdJ$>hk@f*)TCX>sm ztliy+j^z9X1K{G=%*|sd5r;z{oX5?kyxeI;k#G23?N(4T}x3b!J=nSxJByF9#XsN4nyL_XZMCRCHg4?S~hoB)E;nvR}6H+zH4 zC%>vQI<+Pws<5!Q$8 zbDWWdr;e_jE|-C`u{y#pp)R4g$0w@R#y-K!+}~E^WoPeB`_hNvWDTQF@1xzuyYy_d z&D~W#v0y>?z#7>&;-EpPj?{oBPN1u(2hswo7%h=wpuxy&VFwdDNzNLHkdc+pH^CQ; zc5lz1XmWq%kJ66uk#q*(!9j2g`e5%u-bb%J;0EzC50n9cP!9}3GZ#g-cnG90ihhRuxD|wUnB1zp`@zN##A_s$e!u-XH2zgt^!OkNkG^r)0ZnC0t zt$psz`8&UE8oiTTHxiuL7Ms@+pIh(j6A4>}sYH56_6Su5vJGJ>K{YY0c(`DNjFzvF zG+9XJ5u>4W3b0HFj3tp&Vtx(wLYBldFr{#8VZrBI05Sy6WM{l}G<%VV0h7^ql1g=$ z#6oM&Pne9I8hk@(Tyj%6IAULGZf(OdBvfXmklJf#MI;yeLJh_uBct#wkr!ZmBzZw9 zKwB3P82{i1<`PJkz^WMHD7qXhVZMmjE4+F<=+T~GW|Bt(7*a5$s*VmY7Z5jbJ9mZV zFz%e-Tl_dksOI8k0N5BGf^)DVH*X)00Du3eh|t7j0GWi`{FH*CjJ)Ek+|tafinR1n zFq!DYw3y_yn3R<0xTK)qa91}kNRPm(bR%-Uz*W$2PI!-u$xmC5o*sXc*)CsHWL^|t zgA`6)oRUm~pK>dRdjt_XuWIgWJbwCE?}P@E={Y@h^33Gn&Vk0GU3IO; z%j*v17M3L@r}+5zSelzNXEd`*vP1=wA*3DX{&6DJf>Y1Evg?*IV)qxZyR2!xX| zDG;=Q4t>h5KAsFRO3OS}5*!?t*ivN4h<=g|YAt|fHum^FTQki-x`f07YD!`&X1P-N zk#k)3(w{Icxm7kErPl*YW|tlqBc9aKyP;=c$NqzA1lrBgf(-hzNCy_sxrEF5q@wm48nNz9dWRflX(4lD>mYfgQ43xfK#fLTMzT>wk%m>upaJ-!-N(5`yB?_}698tKt&_b2-Cmw< zfHV{$7$VK8;jc4RoFKHhfoz~;Bv2fbLxm^BTN|HBk8cL8gnbMU~*x7>PPnWSnbfm%hAcQ;w+EGP;W7arP!f@zAZZp;l)aUwz{bLZkO46^ zg9~Bq>}ls4tnvzg5y2CL;Kx(Y+yJKymna0ne8iK*)&XHLI>*?jAaUaDf+LY)f};)Y zLv9ZnL~ZM0r$*k&3wR2-SHO0cfB?6E0CRhLo(mks_jUGuXlP{Y>g5;`;}8&I<>Ci? z!4||25j67RPlKJZV=K6^!VucIU4ymCnEy2XxX8Z`Zo_|S<||W{Pb6B_a9~&yG)xf{ z@DD5`>PUie5$h-fB*iM4Ly3#Ur7%)AOf z=Y7Tw`lb%DMO)c1{}p)L5*r05G_(+kMh&v?GzrR~BPwAWPxKjK5CGWD^5KinBL$5| z^vuK@x{kgvu4mS)Ci=^m{rnT7!EwvQYLx**pc}&K&%7f6F@d=_MkLaMiAFoQlc~x9 zNXJs`$RC2z$r+B?7#iJ(>L3AUK5YR9~Tsx9g>jcACm&h$jre>YEr=F zy8A4Qj9JnEefTi?CgucWm%1fqSO*5~GBf^Y-)<3S*dOGSae2QHCk4J5JBV!S3awd2WL4DWR36B!IFwm@Ffp$> zImNh06)lf|iO-T=kjrWO&!p6eh+t=3J z8_O!Sw=Y&!ww@ktVWHl!F`?-h=-4EcROQw;mmEG`cC@>?d+6}c*x|v^11I`{fI?%k zGxKU18#|j?PSW&o@YtC{-Qz$>jb|?ubPWXNmq0+$RXbuS?idi{A0OwRn8e56M6q@X z4hoAz1u{OX5>M_EX9mw*7KY5kBCL<0@he=|rXZ7oUm@huzL7bS<&*TDoLd<>dt>nI zt-^@JI|#-VlT{s(SQwF*AC;7!nU7RmeSTSUeRJQTj!{@2r)O>qU)&g) zTN|3aK0LEFGPgE1kHhcH@hh8COSh)4-I=|9Z)WB8_|nah%hwQ@IW{oc+&$iXX8!!8 zo3pDAXIAfBy#8o$9og9DKr!?vanY;}<04DP7SVeVL(?*4$#II0~gnA5t( z=qwoT)-n`v3T@M!`sO>0Ew!!H#_lev;ONNQn)+j%Cr8?j_Ge_2h4{sLs)Iaif&$!P z!-6wW!`^?S>p*W`R(+FSVhVx`psfDbQKyz3Z0VzWZhrmo=JPM!{Nj&~-u-&(@s}5u z?zgm_?mT|}{JF)kvBjyWmCai(1(SL6?cKNE-g@;l7vH~f_v5A8?`E&R99?)aaOr-> z*o}idGf72_v1!H8$ywAKV5cLV#;(FK#6#g!QZN}oW(3*bqY@WMlEOYs#ez>1%^#v% zd4il*3X&srXR4ZnLfU&E2-Ca+CS#|v^7Qk`D=X_eKY3;2-i=4^Zan;WdVZ_3cWi$- z^suZ*&nPdIhpVllvlSAbWV~uOOIuHK8*fwFa4W}Dm*CQn{MN#b@xkjiZhZFov%miG zw|{!~!#_X#>TgzG{>8<+pO3FU?Veh|#K${2O5fa!kb~2YONm#-3W{)%(h^x2^&SXU zI@>?g-L}nqhnCGQU3(n^2VGnFWCYwavwATMJjWrmtMT zaCIFmU(gr@mRY;FBCyPrwYw`@k2mhWK<^g=)5^L-sp*BW@tF~^X)%de;gN}8=FmSJ z9NhfEARCq(K7Dq0arMIO$CDd(MwV8G<`*VcZ(O-`cjeLZYmZ)DfA;C(gO6v{UX5OP z)_4A1&(Ky+-)iTHOKr{PkF}obI5yVUFo3sCL*1#`nvSy4rntDA*r?33gu?RTLp@!S z7v>*4dHWaN|M5RR{q7%LeEx?!Z+>;>_4jvQ|K`@S-)!9f_0q;SGYg13zq_>Y`NHk5 z7H)nyzVLi_=I)u(ASN;XwCR=iHmg`@dfK{2#Zz`O|~H_^$`Q z`(HE9f5__`GY(4n$jJ7C-Dq-3r5wJLgPX5!Xj*kk9~kfG<*n?J78j2w$YAKCfyoGW z4ze7n1a#mJ;mn{2M3|sW1dBp)bYezWR6Laq;#H{`Au6f7B-o)ph`&IPOQuPfZD2@1 zE^K3^7oOvr)0{8>2Qh4Ye1g-%ql--}eIQy;_o2SC&(w~B4%|yZBVs7#HpLoxkomf~ z+S}Pbnl@Nq8PxL81XA1?ydB&Fj4hpZ?=^+C@!>Z7reyabF_SxDvGAKPWY*q}yCp#g zNiiv_p$TTX=H^-k7JCd- zx@OSIoou|loFYSlb2E#N937nP8J(>-c!=%{3{XWVXO{$}#Qg?)O-+sHu8#~1O1HK4 zu{C#dRYNw74i3n~=PD(qwYv4}DTtkmn~lAFehKl0DjRq*RCO6NCKP%s&lTZGyp%1q^}Ybs@H z>6)PoO#_8sGVigcfK}<5+dKHj`@|MG1!n781?w2P?bf!yeThroh#Vo%BdR=gf1g|A zer*GPZCw{LGYPY;RWA4|;RNx)j(uDoX&Zl}Yin#DXyF!Y;^1TB7J#4)kr<&JQ9bf9 zOeG6-CqkYMFG}A^e@3yn)yWb8#zNvJaD zt5DM;+u|D->YobYgqI=AB8eH55XYQ<>Qfs6Z3-t52jb??>BvRW@V#Wr}x zR>$Qu`h=v40K1-{;2TVTco#@m=%5Bh?x|4Ut*xQx5gWts`7NWE4zBLJ&3$MGF)_hBw8{z>35G1#&hOzd2Z)o%Khjv_;< zcto=LlxeI-?~DW@GM@#g7sNnucj8|GAGjY8bk+VzG={MPZWZWK{D0+q(Y#;2&QAdx zfm(yfXkIK0)(Dskh==fG(EhcNgp?GLoRt5>0|>|;of*T*6Yi2^eJFD~BVT0hSobwJ1Ys*_{obc9IWOD3rdf%j z3=~0$rkGb6xR2$p!DNKW&VitOg9f1B^rNT&)XYIFsI?;U1GAbVgKdy^A&9Xul6>S1 zvhxV0!qC~-BY1+k6Z$6_OhyQVJlVZ^vMunE(?(eIvQ_J`RXdXT8X8#g0ATYVV~xZU z)fYbMfne?2LxzuT8-yfGny@3Vc5<_IM=>VAGc+7YZQn5bh(lD~zLs9TcEJ(OVX=1J z;SOFQYG)r)OBLh8&c^=3Y@y8!f~#O4pi@jaEx-zCR+0&+Sw0}3%un!F4ipGTlFi6> z5+}122rTn6CPR3j!DIx1VK{Ks<|lbu5^an63X6-m%?2x6MCKv0lsy6-5zv-s`BI>Q zn}rk-h^Jy2fWRX?S#Vx#94)*;ox_tnB2rMrp;d?OOcV5h^?@DrahD*}097z$3eh@^ z$}#$ma{6%zJS1DOY`y!~rUdO&Hc8$EPnH*JfOo^2qFmtVAKn;P7ZJvh%Q< z_`1APX^S@CBhQ^034OSf#;7lFK~&`qnVgIp>tAMsLO^98<#T9M+qXfZVxn=FGR@$2 zI=Fb^ya0#ULgh>`1p=E$&7h|ZiIlzo=*^1x_5Y5^_(i6NBL!zS2?@*A^Gc{lpmN=7Lc89>F=*?WBK0R-O%>fF!0Nw4Mc3q_klWDS(`g> zYC5^Od-?g}86BINO8d|MPu5#T)tP7OzNxOHaCi5GySuwfumA}}fDqi>AwUQaED4g3 z5O%^I!*`Dcjco!p^x5jqv zkL=#-UBB8mb-ui9DF1j%!SN=6Wok~996Mc7)r^=zcKNByvg4WMwOQpSP>-o;8U&50 z>li&fc($r_D5th9wftmKaTU@uG1+<1>DhE0O)0F%IdY<~uBo!AtE{2DqN$_uOlR?_ zrlakB6%Fkrv^c3c36hfq!gHd%E6=X*0|J?(1`Se*xan-qO9bC!$q|f6-`yO zJ@wrSt+QJvCNGq94n>t$J4YqB$0kSS6vrQ~q$_Dkb!}QrO?m~AEQB7Z(cwwCX~n0G zclPz29i3X8S=>IiehuEZ)GjS;Po29oI=eP{c70@aeQ0uRU~F|{d}C;Mb7Fdbbnf2p z^0WE9ub}te_~I`QfBi3azW>{u@BVTBi$7g@_~ZFYuLg&&oT?o^oZFNdRTATq9OfEI zjS>QaHoAtkI{J3ndUgP1`bP98@^%jjkIJk$+2238wQ%Y2{N*Q;E4Q2bSB}&T79Boa zP;e|auPQx<_Tp6;`88Y!^&p`f6P1QnpOKQEmsMJrS97$w{rHLg&c4OD<^9D=_kdz% zR`&#u*}P485lXx(TlZJ5DuB%OM_@85dk@a-+?>6%-#fk8)PHVtVP|Fc;rflI7jHk` zzVnL4%Jjm%a_cpGm}_@lU%&eXNg4U)?U&GFHm^Qd-?_WAxj%p5%INemrO?@Vr8qOL zPA+J8Du9giAQ4DdiKr9@Pfl5mW3gn4MyuNH@ozD2VAY2-P%coYGMW_3Qx2(e3=H+j z%}#4Rab{(D^EutC>-x`zq!gN2s!X)ZEHw-*Khv`~q-#!F#DfOrhm0*XD0DOh9)wagPc}$df+o$E#0tA3HsGvURL`bQ#p8mn_xDV&}jdy|;RX&vgwgc8;#V zmg$>V1)u32JKs5WzIkx=bl+56>+q3=o}#18Xtxq~)6>DmgglBV*pace4p=mwneRRw8ccE_`3(WLjp5Ld&@7_D=s#^5cINfXsUZ|ja+tI zPEmMVdVF$TPT{eZ?z6yXH(z}BMn7NAG@n=k>4mpMJY@|HIm~*NZ#PXD&V(S-#aYw31v@ zMJnEOd|VO5nUv#L$*l-P!+fa^5JmDGGme9V+lf8o=Q3BEC-lnJ zA;yssOEO3_FtDM&VW59{eqPJK(8l$9_g;N-|K$%Ccb^OlE>%@DlAetBiw>iSJ0)87 zPF$XjE-LzbaFm)^P+1vZVjFMoQxKSTETwj+asKkk(`T=K|Mk!R^}{d!`r`Y)-u>|R zH{Skk3D_nvQFx!E@|U3s)2Gy8C2a&AI$VPZ;AKtPOxgSV}Xn}=s`WOCM#ruOl* zt;K71w;sKvVrcvEi@lexZ-4&fz4zbVe)Z+$yRWwHy}NMj&G{>D=hk0!4ed9#T&^q` zF3WB$PCi+bTz9m%wdQc^;ha+?c_)unHJv!wdaALd>gb95?9!a{(yEHqp5B$c+h2YA z`~Tw~|Ih#Dr@#Eqmp}Z&qc8t>>(wvUpZt9F?r$&be!X(}!|Ii9HgEp0b@!)>``^#4 zz8IL?Kh<&$N#WN16RAEqwpyDeC%ppQ(79d4uIQhUb z9J1mw8<~;vNXab(+#&$POM$PYK8snRcoBjLz{OSAu$<$Z>9{>oIZp;dM+b)%=iki1 zfm|xpG(N#;f#F#eHom%|#A|v`%lMEERUQ(mt9>LKay$w%drFwST>WGHV{*L1GhG9c z60@sAWAmK7!pX*>T0nS?vw@lld<*<5whg;Roj`=+hjt=46b&;YeTCMJ_&j0b-h=o}Im2U_fB1N)=&m!S(}@=uNC ztVyWKE@?g0vpBwfbNteks`d_#uu#;F2*B|pphOVVjMIn@iD)ftSZNRB77*v)8ExktskET-rmhDyU{qNoj#kukc|HVn|H!P! z^qPqDTIYatT{F+mbgj_g0RWNy&ZbUA4xxU@M-R6ydMDTFT7+uqsdNp9$MMiy>|DIa z$BF#7uE9aZU)LNpW>ZHW13OO(=K$)bpfiyIqgU@i4P7$#U}fBcEEJ^_Ny=yB5;i80 z7w{d_8fy=~kdy)nz)7Ehu`mX>dE!;0LZPS60weQItq$$K$-9w>#y~5_`;2UB9p>ju{1y=*c1YAakJdBlK*8( z^CCP5*W|QOI3{XLh72j)tBEBUZSDm;mKWhcoT#Hi5KS{>QC()U6R}Fj1Fl1D8I%Lq z?9$rX7CMt7O*JCo{X?TjiNZhtZe(M?ePGc_f&nEKnq^p8s4*D?e&e!pQ;JKoN-KpY zQ(Ow@k&#`Tl$x86mJKF@m`q|?W?WKoSX8v9w-4Jy_J<-C&5Ln^AQl>?EZhff9C zrjCC(ABDA|j-3URks=793X zII%*riMD~MhK`}i=NFg9C!~0|dxFWZ#IS_yLy#5$Qq<*9pg_<}6wOSQD0__! z4idoC`@CT`*dV&-(>qWitnQkI1SQ(TOK*0hYR4)nncnWO9 z?XYqPe${{s69+8AhGlr!bX0`0!l_lHV-8iO_P$}(o-=ZqSSb3jq-hQV)4eYZ@5oF(#nOYTOJDjf0MfWxN=CW}FX$dM#lr z!%Gz*WqPy*#yFD`;c&!=ae;7Bq9V6Rvm^w4ot)s*K{^uJ1n2=X&T3UKv5)8+i~OMA z27*N#IKZ&*cKnL1%|R@STzVVhX=xI4tGPykDG9eqPIUE20X8cmDY7930D1s2pj8YJ zF*3r$l)k$7N5Tpxd={+6)JhIb(O3onB`>H*`U7Aan^7-pWkV$a{mn%zSPjUCkzuhT zKCPi?jP$$?r-%~#Q=SHI(8(2c1mbU=L7`CbP;n1V&J4-O4Nl7qOa{tG@C=L#2ut?# zk3z1WvkA5plcktJWXU0k$ui*LrUV!i>_v7HL&W`Y-|QgykQ|ZNH2Tgc&7_3fqws6g z{wJ@&hvYfTkvvVH4q0E~!zkbJF1$WN#JW-s6yLB)u~+P3z%J}33d!{SIb=x5lA$Kh zhpV?sc#>ay4pbkH;Aj_5Kje`S1{2aGeujyOjit4{l?|fsU<(BMBqd25ad9XDAxR<$ zCm$=Jqsz2%GqSW4%A8m#e$Dfh4@yRfHKS)hpEbnZZS+kYOzkLQ!beiUnSnf`Z{%QL zWQ+bh7z>Ca#Y(W(=*xzWr1SzX%s?f+g!uSI2S%iarxeBHmWHI|szM`ZdyUZ$6RoF9n_vX% z9ZW48tsFhPLP*kuWE97i)dc4iIYdNhJJ@|{s4sm?bPiDlLbW_lBkeU+u3lcgfkELB z2`Q;yGSLai1oN)$-aykrYQ=9uItb7BGYwEOnhWcF_9>bka%pSP2hqvGHPk0DF|i^p z<|_V!j9O!+rPTkGQD=RbEKfIxv2JZLCxvIN84y}4JMOOegZ&-pVTzD^Kq^Ym?SW8+_ zO>%Bo3=w5QR!D4maCAmsOjcMzVO&N&#I(#&xx<0?5BmZ<)VM}*$TX%6wM{)g`%)>_#60?(I zG7B>+8;^JO_RLJpuFtRTK#zeWLrD(gnbETw9Gb&3Yr|8kgQF{hL(BbxtNp{5M&@pe zo`1M>{p+1azkTxkzrOv$|9JY-f4TAgk2JrY+kDnDvQ=9(l#_HUEwVV;Co#w|(8I!6 z02w_4GF}#1IyTyR*1G!mG;U6+;P52wsB>g(>cX9~7axJi44u1vy!~wXvEKaRQ`y-S z>8XVzbR-N+Er?IdiH=T>3QG$02@6GD&DAf=D=aQBF+DQ7DE&xXb;r=~%H;eG{X4*9 z7S?Z`zj$Zq;?0dKG*o)Jw)X_3f=hQ^@OAClLn@f&FW-bG!{pMl1A5Hb{*%pH&o1A7 zzH|5W?#)-1uRVhjL&If20FW8PC()4Ez9E>*%B7nCGUKxsdWX%74eHuC8mC7f?c8=(boHYv!hs1s|`M8?v=$~8PZ zxwP`+>5l%BO&wsHzV1P8*3K@p_R}|WF|qe{3JMEKO-d_=d(%C&Hhg~Tbk7)yK=g>o zFF)1Xzi{sI{Ri)V{_wkhruj88BfGcXE^pjvZkg!rI=i`f>(ch!#S43vuRMJD{h-S)Gu*B-nY zSie-=-5r#asBdnD<>#PL`wSRxS!`mq`J_?-t*(zFWsONRGuCreIi}}jxAgVRuC8xh zzlCh??blyC{NmetZ$8|5`u6($ms>X&`AkpQ;fAWJuHM1T?ftJ_e)xx<{`5b;`_sR@ z|K-0v`tT>3#naYp^~zVXtFIQfKCJA0x4Qq`{Kng%sXI+AYsH6q^9ovvi`#1|dtu=8 z51c>0ejDkbCtv^h@rS?O`TP&tkH1>pe>AbWQP~=_Fd;i1*#{>tUq}~t zu*@V55C%koEc66eaMC-&9Kr~j9_NtwhxMtBj|k1+mV?QdJ9TDU zJ$m>es1xH#sa+#p5KIPV!_G6*BQ(`JGTT44ASCH9>TM7qtepKRqei%ZGMR%0CI>_W zTc2v{0|zxI!;r5U8V9sB59n%tVs5JA=w#^Xsb_~8F#Jag;!J5cfx~C#Zs!_|)Np;r zSZn`$ab;)8k)G)IvZ%NMI!tl&I61n)$`+0>TxL8>JyTm#I%Ne zRc7|eje@%4jy_WHhu^D&y^cyG{2c70xzVqX$Wi zJ9y9x;-H?jriqieW1xd7(%moKCnS-E-B4DD+$FA5{9d(Rjh=u+c2GEQ9DL)` zBD2c8BQi{_-Ed|FJp(1d3zWV_LTC|(5DJR11s*$Z4bVXhrFPVXk)>;-Wo%>X5dtPd zS9H`4)tHPL=3?BG)F0}^9iN%y|8oULj6OsWua;PAtHa=i7;VGwMvirkR z2V!$4j`iNyc=XrV+rLXYHSZW)u45jeV??uca{>Mp$|A1-_J}(Qd?bu70!>SER1}EL z(3BwMM}S5Is!r|`tExj+Q!5zb)R0)B2}5WM2~7(2MLtLbg@~--2Jo^xp9%=L-%K3Q zD3dM=M)Zx1&^QJ9pmvFdM_@7pfHav^V=}Uq6rg~pP5y*425^9o4Wb3~Drif@k(B?C z^JmF%7c6x%^RVbRJZiQu1HugOr@W3#lLkWtY-lFAR0DRLz-(MRffwc?d?Ti&FoVtI z6By;>?gwXv(~Z{e2p8Kr*a1Cpv)mL3SYmeg0}-)tv1ysf1x0Cx%V|j_dNTP1nYnqX znR#hh`Jgdso(xnOnsn3p)5p&rcbbU<+y8hbDhK69Oa_~!2ybwA7$}CC(c^pdNyJGi zM=Hl9S$72!V6_WRMh}J=RXi?n=>=dih`crTOttpSbPX@yjSP%0lNdVPIo8-YTt~vO zs=lzeIwQLPwP7S6z;>u;kW*L*>;6AXMj@8Shf&~1LOFW!a!w2S^{Ht5$^&dhbZ7*b zQD5rs|AW;dPf?;X`9?WU#VB(TM8bKX+Q`@#Y(yeB%r!(bg*C(`W3CxwO9xxpqzX?a zz+Wobq)JIev`CZ9+#GGwB(}VrCnHu7LlrQ{>1XrLI)dFa<0~ z0SOgAMloXgJQ?SaJqYfHomPjC#Kme2Ql6~FWYmC+*aSrzN0^Wziw(GK0s0U20?G;F z0%27Q1%QlP&ThapT(o^*Sup9;V2J)N76g|BoiXSb#v<_qI?7I@t2+=Vn?>SuqGGHR z#)DSdG!3`H>?m@nP*&8?83(4qQDIX+w4f3MVhp<&=n{SojrNe#-~gpJ9w-OIDWGpk zm_8$n#HK-E1CqD02GJMfS#3>(&-L#LMaqJ}*%Ls9*;jrp3q#&idZcm_90!8RiFYVT z6tS`7I6kr~CCumLWUDHe42mw0c67|lIAj5foW1?++VPb<=5cVL z>2Po$MoqovUC|Je$N1W1YUp{70;QW<0t9|TZX5p zx2iZZ9OFpcDiSpuGW@49Kk&8osa;X@W^#6~JT$5}ZsnENLXcg_v0;PM|jRgBwxk@oYQ6WJtVX zigg)j8+gSOE^+CaI>D1Mv31k8M7YdaM^8{b9X(OSXGM{G5v)%%WY7`@I!0hkn76zX zr#~x%gMh8X&QhNROdP+GwTGSO&G6cI61x$k-Q0qwDe#c|3jaZ@gvesaiW7?_nKx2m z2QYPNOok(t?M9hA=^HCsFMB6{C-)!+l|Q=uruJ@h#3r#q?Kr3@BZlUZ%FWNqD-3nt zh}7b!oU+i20LTjmm-Xz1#8 z&{$uSph64ok^xqZ4xtnv1V_b2C#3@EN5v-*YEj2THJORX5kn?}*+nN6_|#N|32h0+ z0$oSpij$XuNMuW%$uBV^IzKe72yS^ma1!pHorSZrt&@wrL#Tg1QcP?{T3SJFeqnBL zQC>w^$?=NPQ%9@LG}QN=X&GzjnMHh~YifO9{_?=m?%3w7iLHCR=eACdovS$An_JVA zfAmc8@ixApk2a`F-jPO78hR}qZysqIUThy_o67T(1ZZQaZ1aMw4Cgm?q0mqePQdw*g|pZKyH0!N!ws~ z&v^CVOx5sA)zCym&*0&vwxY_~%#0$yoT7~KmXjSr12ePd*5@v4Pt0$Q&ut(hBMh18 zRWOfjyY z7MvcET98z7vbL+MZ=R0cXE&}bUB11xb8q$Xy^Y;Rn|seTu0JC-6yRn5`Ns7p$o!%( z(?7jQ+0OLR-lgjT#SlyKb?f#^FqxhG7qqA0x`DjRjaP7HkoMiU_HY$2XZ7mz;$=uO zb@gp2X?gwuA&zuOpr(MG2;{HqI!;D0L^u*knKQeL@QR(tgPn_o$KdlEwknPnxILCZ zFd5B5Aid^>MlLogbT1=v4ADkYi{HTAdKC$+-hOvPD?%T>2W? z;4=czXzTFjIG4Vj{_%0?5E}~1PE^*l9&7AvBsl6l3oC{cRnN#mYu`j`-#D;L=iu44 z!MTpnrLOU%uBqjYiSx~)^Jj)H-e6e00xFfLwYge zcLMSA6H8MEH@85#tk<6IZ0hPOtFA){mU3SQj$puLePde#3l}Suzh@N1O$a*GoEStn zVs!o@gd9LfRGL9)F5i9o>W4pn@ykEoefjI_4?gVQe}8WI+NqQMBST9UE?isP*k9SW zv3BY9(^ucW{_x9-cfW&6gXYZL*FW8O`fD(mwY^u1+m9yKZVfE#)|?p$ip>s=Oz`mb zr=*%w4}TY{$l<}o$a7d=?3f)Uf(JiV(j5vY&9S1GaV)u{0~ExDgNWlDOh%FkdK%;< zseQ(^2#$?Ce7vr0bbNY!dw%2E*>hL=dd}69w`Ro`$M}Q?JFEOreWih`g@uE)75W%l zz;~9&r)z0b|K*@-;G%03V(p&d6;m8lT3^&LGqAC@`|AFa?~zP-@a}iF-~Dp!&5vvM zU(a5@+q!Trqxy)0uQwuc9BrI^SZ&slEF>5`vV?GLu=qro2T4;}+gSMq`=uA;)^~SJ zt!^w`y}teE`Hk0K-g^5rJ)xd{{o}*eU++JJ0QO|(=A*3}_hHCvT)BQ>>&nW-z2%MT zi>p_cSNFEI?o3awo;=Z2Qc{#>35h zQDj=b@`Nq6eGhTqcbE3xF41y*dT(I-TJPA6&e2=FWA|&1uVy8;MSJH4+eP|X1o&C_ z2H5#g-WU~-m>8E=Ti-D}x3svky}Ea0WoPI7`bFxknwy7fj`nwUuP(1Wx%>F%?|%Pp zfBx_P_xFGQZ$K+hWzO%sKfC!_6v%hKp1=IX@Y#p0-IpuMN0Z`eQ)8>rqbqXbDofLk zR~MXas2%ETUmBmhwzlzNbN9{m-FNps|Ka8LKLb*&?B8l0o6M;>84#CcVC|uy@2s!u zX=5Jd?2zW6DhLfZ78cbM7B>)=aW*bzHmhd+@adiMGwT_}?Op-N$fQXQ(ZPW-fn$xG zjcudZImbNRqwUSz&GoI!h$f|~krNkRMs__FX9qu%&PoKkxYJ-V7S5`~+`{q`4c=i< zWc2V56qr^?OG$AF8BY{21e3uL<|^L7GVt|YkOqq$eWI_?1HZznq265kfR^C_1JeVRwuS*={`r*=7(!44oGnVV8;52aJq=Ep8JYlJH^h4B5}@BMh^Qq=F$3JBY`n=z%a${8M5p zg?r2t(?$eD0)B5$T$Zyh1mGYC_YfD)5HK|yHlhIj7Jm%hvW=S$y_Rg8+m@e2^*q-||sU#!LcOOWG$P^yCUGL%1V^Z3ULWXO^z$#I};rHh~X=8ZChy z0V#`tp;3{30f921a${1s#HD@^&Io@%NGKAhia(=tyJqwl zF7+|0{w+8IyM`E(C86F>0?H9XncIXx@2+W}T)w$ylB>0M3g4q|^nCx=Qd8G>L;J|7 z=Ar82ZRJ(BpEd_!>#-WRffqCoQI!qU*J4&Z>X>!_+bR7!7(vsrOB_Pl14&2UYS2( zF;bL;{JBSFU<)eUEZKV>}-xG|4F5TF5krFt6Nk3}L*p@PXUP#_PG zs%ez`5kVDtj4)(?!4K-2>03EDc!xT8gqb_|nmhO)GzwHpm@kT0>MXP(NWvSb2S;`a z-T*yhsJ&*)@OLPtF%@|ehDaSqDs>aUXhv{II7cw3tTf_cF5%ml&`=#3fYkJ{fN!RZi85>KI$@{qJ&RDVbdms4VJEuBz%M}Svfn+GLs-M zK;mpS^nwKT{ETg`%q^B!&PgslHfM_zouLH;-e}=$Xo(sR0>2*m7H)dxE=bByIY@&8 znkztS5$!&XNL+3uStbx4ZKMEa$l9ollrZd+I##eyxFux4WSOulCGE@J14v6_jatB)7rt$-X+M< zBh<+&gbGJMB(gbRGHeVA3;~2menEZ!MhFT^j7cp@DyqQ~a1DFW*VaZ73%z@9ui&7l^qAbrgtAlcIy~Z%P261dXa$I}x3wMIR8%@cViQpG1@os~ ziTWk@Y6zmyBZ}k|HKzjIi3|IgWMa4!tPC|pE*uW3_3cSuhNjS3A}BuJJ0uBY$<)}M zJ;Mi9sZ=phQIKR(Q&Y1tv-5J$@is0$_`H8ml!XwE!rMdZ)c?Cz(P)AA3Pe>>T2}H6TMJ3l!6V33Nyn+WY7GCf1N`nO(oXe(l}0M?XIK@VDn*|I_U^f4_bE z+lA#vt?kRjC2gsRm2rXT!7d?QwjM5I3G~fub*Q-0l{KxcMT2fYP1M&zVq)?tYie4D zI%Y2R&+m_|+@HDhd~E%3^TbYN({x60ePY^S{E7JZ)VTQM=(yylxa5%Vm>^VA99>{| zI~o|<>lt$I-lkT*ruLCezA1qTMOjBqpB|vc;@tY)ih{`?`~oJkarMd8tv8o$z9fmi zedo>PTdyu$dxXdgsLfI~>YtGsSo8G7JM7Se zck>U$R4DG;r?OSqeb`w2L%%`^4)Uv`rL(VFOqhR3N=ip_&$V-VUoG7Ex_WrcE9J1E zt%@vw>}ySFW=E8VWyVT_nX?l}Q6e$UM+yy%2F1$ADJwqGP@!Nl^=%_fT@zd_z0+O8 z^PM9zoukt|W3$~OvqF^_U2Gp+Xd64%IlbIAvDiFz_5_&B;A~y@MCF-YYV@L0bI6R~ zW(ceVdl@#Ga=+q?<8xTK1cbyFSJ$@dPJvND z$%!$AIXNeeofty92Em`<`OEEN%Rpq0zxw6<&;RuN>p$Lj{Oy%HpM!(V&R?oM+R@W7 zJvVo0W$oI+`JL5^w;sRv_Qkv3y!!BaFd0ZPcVGWz|H%(KcfMNQdA4x*!OZ&Yf%&bf z#(vmk_;pS$u6$-rJv;(2dI}SU+2O(IEBR$5LB`LSHSC|-49a|vqfv|@_E4Q1P%s%y z&SXe3BqD8HT|7cU@~V%vP0mbhZZBWCJvO)5+BQ{IRG%JQ7~&r8XYb}|frh)eBL%`F zpRFvR-0}eDmu5M-VD7qb#wg{3$r@_wmE;yz6kXO-**!D7xqss=ordnb`svo|-&}w7 z>r0P6EZu!RcyasKz(8P1qMoH0vVQ8YOB@DP7pz{~K(ce3HCj|W=+SKiUSUp2@yX8i z(eo>dS8mdpdH>aiYcIdrfBDs&x8FSf=C=>td~@g7`>S`JUA}%Fp3K_rjg{@IE0=c{ zS9cdycIVD*&CYI~onG%~9W5`Z&(5lhkIM)Nig2@clM*)C=i0h?`GlnxRJ4!Jo=2eO z_Hzhnm##kF+i)y~#6te$GSa=L53uy``Wugupz*2B!p zRo~G?-_G5{!QaUzCNw22vmBBhkkO5|?{=O(TfcjI_1gaG_SNaRwYK(YIwqg0pBx$6 z-MRkdi}(NV_Pc+1{?*^EJ^9Vf!yhl~e|7fqoB5qDrZ--74PQIau#leG7!i;k=AIPk z9v7pEOZ8373CqumEiX(tQI^+wvSzfaZLxb`31O)HNAKVM^rz4N?$0+q|8ji&a$Wa8 zRBjP%W(-VSw6yI%{nSQR&(p{_#L_y+-mTQZ^QepOao50;uEDj=f#uF#>2|K+RGQ!d zd4`1)9XoouXQ-yW9bDbn!Qal@Maa0Mzi5FC0;3RPundUip*lh`ic_02U0SZVxF;7K zZtNQbnE_fMj#l>t;Lyj-lk`38bfvQlo&bM|dnrp7KTw%&f=amDMAN3$P|8&VYn=E1 z4J-`tHpx@rnc$;n5>Xt|F*87Ln(pfKqH+#Qaqvxc4b3ulkFoZSv-FNSU|@4V*9`e$ z4O`dGY~3{+yiGkLoWs*-3+|m#;ux9hlTndg-&Hkwu4ZbZVd+N8>Yak-iJ;_CGh1(f zAe00k7eM^MH=v7Cc1c}oer;k#ZF+Bunb6q zw7_-<_6y0*t!gFZ(J(R00fcd++xa`aNU`FneW zdwa%)1{Wlz)|DI`I5T$P+>J-Q%WJ?g$UMp`h(ja<7;%;uH(1jji`hl71k0v=z+B=V z5|s|FeCkW9@Tfn$jG0c1?=?O_h% z*BM*UsVB<9+5=AtH=g<8l?kiy{lH|xvrnHI+aJ69A**`C+ATrP(4KIK4DUe=!YGs+ ztjML}D%}kakhr z9l@-$_NKL#1HutzU^2wKgrDlrM7D#-$e61E8Dw&3R0O($15Cikc}1R@dL>%o0&=(0@P6Uy801F`Z3WB9%Z6s)w%}!Z|@J}%Bq#P+# zfuzY(WQ`ga65=_z`WPBpBk;;e!g6IypiEGfMO_ubIBwovPAWGVGl9v(q@~4YXD8+5 z!NJQdttcoj&&bV7%g#eXI|X&$%p71DFqx$EjOc`T|G*$r8U+7Qf(UikBKC^V_}?)Z z3AKno6h? z$PTa%Hh~*AMWD#t)zgm-={^u(0VOE3WF5+a$H;)mpg3xYq={7dDSBVhIfsQJZ_2IU zAyWRSr~RppT(U>#v8$~|_iYUmD+60s3za|7sI^NVVq+BX(ZH9I9N9s#AGE<#)uJeB z*nxYI^+U7>ScNC^*{`HXLfsb|j72bK;rN0CQnx5Z1`DImJirfS#TvnF6nRoA{=h2b z!{99eJ)zO7bg5%Os&|$eR}pyB#ERa#AjWJ-G^N1-=w61ofNaJl0&GEF7d%P;Mj}?B zIm&8at#W}Iz$pcmu~(@`y7P9dA1=m?H6#6ntVPd?6oUHa%rA7oPc?{dnw zZV+h*kAQH$$XJSuxP49&Fd2%qfT4)rkq^Q+&?(6fx~PYrnU$*^rXKKII+hbR%Y)s| z?J$DBz?zNle)UU($o2sf!-&2dWXRO z4fGD6n5jjs=hIL4MiD_0Mj03ygd)b19mK|g4J=d-K}k59KGD)Tpsjt7c|^8X*FeM2 zgqzhcF#&|pCTMYXwNiQ5P;ubp;}j5N@9U334wb?dj$Y>0Zk85~beB&G%9KrVr32)L707gU8S{*Dma*kMcy`}*V7Mo&h}EfXad-xCEeq;h@<3E9%b ziWW;g7A~Qt4#6gN{yJtVEi)%w3z##~=1g`F0Ed|EaFpHabN_$v&BT6LK>;-$D> zwh!Xf;EzBq1pvGRECIz|m1fcSh1Q5C%B1Whh|va4;&TpR!Pe zB~EEK2RVc|Q*(P~RbXIbntxP=cX+b1w+K-4Lr@(jHW&_2K z!iL`Ly7r=zT~%j>XuVNg-*>!e=ycaK9GlvG~(%jHKHaa&myFPh#lK^vQcD-+MrDuGpZ~T1M z*t!16wb8|^vzrfB_rKVA`0I!7{_^txKhO%_(tZkpU?|E`jcr zj_{zUqXCUElh&TpmXdI!^4`WfjGme~r6(JXcMZ3WU+A3PZW-BX9ltuU`D}FkN&WDp zyt=`p+}haGqUiXP*!YC#*tn>;_|T|W|DZ58cMp3jYr=dBEp0OmO;v?f+jdHk4#$m7*B&Tj;c?B-cLfYjz`ktEL2Q zU^4KCtjTuU2M7BW#K)Yju3ed2f4g+=$20RcLW}CHy~5Gf<@}WuPC`V%d-+=uQ?U3T zX+xCtVKXJ9BE*_oe5|nI6qwA(mcjbY(T1)uzMkouY9F5M9G`6)o#>gE>7ATw>!0Zv zJ=ZFc}4?=Y3(aaUv6v zL?!1QZ|mb_YnwVy<#3^dmV-%O;YVp|6HcHS;bQ3==oT366O$00lb%v}2F2_wMAI|mLa;B>|Z zgZa@Ki&>Tj=23kji{+FGAhDl(Pq3`Ef_o0U2eLr-vuT zRxhvLe6)D!MqBq(Rb_KxL{6A@w3n^B3hsl6p)+!eMn;xqMkumV_|Jpb1q=;p6A>l_ zXja;q=v{l6*hD!7C3_~6#Fd_@>A7(3`j!1RcVGN?@9ocbKmX;%o1Zowznj{--G2T; z-l-FwQQ^Qcz|9f1WU7MGTGu3y-@yN~$r>u>JA z|LM-#A0UU^d-L7ncfY>(g8pJJuiSh@-zB7GF6`{huWeDoIK6Oje0*hMWTmrpqN=

      6qErxp?O(8wWz#?*8YuAAG;I_59rO{o$eQ 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�FV5UX@AuK<@#{l#XW&7#^zA6CZpq0h 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

      v0$U@ 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

      ;OzFd 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�)QTVH1V#@gP|j{UP+ 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.8',\ - #'h5py>=2.2',\ - #'matplotlib>=1.3',\ - #'pyzmq>=14.0',\ - #'scipy>=0.13',\ - #'mpi4py>=1.3'], package_dir={'ptypy': 'ptypy'}, - packages=['ptypy', - 'ptypy.core', - 'ptypy.debug', - 'ptypy.utils', - 'ptypy.simulations', - 'ptypy.engines', - 'ptypy.io', - 'ptypy.resources', - 'ptypy.experiment', - 'ptypy.experiment.legacy'], - package_data={'ptypy': ['resources/*', ]}, - #include_package_data=True - scripts=[ - 'scripts/ptypy.plot', - 'scripts/ptypy.inspect', - 'scripts/ptypy.plotclient', - 'scripts/ptypy.new', - 'scripts/ptypy.csv2cp', - 'scripts/ptypy.run' - ], - ) + packages=package_list, + package_data={'ptypy': ['resources/*',], + 'ptypy.accelerate.cuda_pycuda.cuda': ['*.cu']}, + scripts=['scripts/ptypy.plot', + 'scripts/ptypy.inspect', + 'scripts/ptypy.plotclient', + 'scripts/ptypy.new', + 'scripts/ptypy.csv2cp', + 'scripts/ptypy.run'], +) diff --git a/templates/accelerate/ptypy_i13_AuStar_farfield_pycuda.py b/templates/accelerate/ptypy_i13_AuStar_farfield_pycuda.py new file mode 100644 index 000000000..1e7f14645 --- /dev/null +++ b/templates/accelerate/ptypy_i13_AuStar_farfield_pycuda.py @@ -0,0 +1,115 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses a simulated Au Siemens star pattern under +experimental farfield conditions in the hard X-ray regime. +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +### PTYCHO PARAMETERS +p = u.Param() +p.verbose_level = "info" +p.run = None + +p.data_type = "single" +p.run = None +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False, layout="nearfield") +p.io.interaction = u.Param(active=False) + +# Simulation parameters +sim = u.Param() +sim.energy = 9.7 +sim.distance = 8.46e-2 +sim.psize = 100e-9 +sim.shape = 1024 +sim.xy = u.Param() +sim.xy.override = u.parallel.MPIrand_uniform(0.0,10e-6,(20,2)) +#sim.xy.positions = np.random.normal(0.0,3e-6,(20,2)) +sim.verbose_level = 1 + +sim.illumination = u.Param() +sim.illumination.model = None +sim.illumination.photons = 1e11 +sim.illumination.aperture = u.Param() +sim.illumination.aperture.diffuser = (8.0, 10.0) +sim.illumination.aperture.form = "circ" +sim.illumination.aperture.size = 90e-6 +sim.illumination.aperture.central_stop = 0.15 +sim.illumination.propagation = u.Param() +sim.illumination.propagation.focussed = None#0.08 +sim.illumination.propagation.parallel = 0.005 +sim.illumination.propagation.spot_size = None + +sim.sample = u.Param() +sim.sample.model = u.xradia_star((1200,1200),minfeature=3,contrast=0.8) +sim.sample.process = u.Param() +sim.sample.process.offset = (0,0) +sim.sample.process.zoom = 1.0 +sim.sample.process.formula = "Au" +sim.sample.process.density = 19.3 +sim.sample.process.thickness = 700e-9 +sim.sample.process.ref_index = None +sim.sample.process.smoothing = None +sim.sample.fill = 1.0+0.j + +sim.detector = 'GenericCCD32bit' +sim.plot = False + +# Scan model and initial value parameters +p.scans = u.Param() +p.scans.scan00 = u.Param() +p.scans.scan00.name = 'BlockFull' + +p.scans.scan00.coherence = u.Param() +p.scans.scan00.coherence.num_probe_modes = 1 +p.scans.scan00.coherence.num_object_modes = 1 +p.scans.scan00.coherence.energies = [1.0] + +p.scans.scan00.sample = u.Param() + +# (copy simulation illumination and modify some things) +p.scans.scan00.illumination = sim.illumination.copy(99) +p.scans.scan00.illumination.aperture.size = 105e-6 +p.scans.scan00.illumination.aperture.central_stop = None + +# Scan data (simulation) parameters +p.scans.scan00.data=u.Param() +p.scans.scan00.data.name = 'SimScan' +p.scans.scan00.data.propagation = 'nearfield' +p.scans.scan00.data.save = None #'append' +p.scans.scan00.data.shape = None +p.scans.scan00.data.num_frames = None +p.scans.scan00.data.update(sim) + +# Reconstruction parameters +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda' +p.engines.engine00.numiter = 100 +p.engines.engine00.object_inertia = 1. +p.engines.engine00.numiter_contiguous = 1 +p.engines.engine00.probe_support = None +p.engines.engine00.probe_inertia = 0.001 +p.engines.engine00.obj_smooth_std = 10 +p.engines.engine00.clip_object = None +p.engines.engine00.alpha = 1 +p.engines.engine00.probe_update_start = 2 +p.engines.engine00.update_object_first = True +p.engines.engine00.overlap_converge_factor = 0.5 +p.engines.engine00.overlap_max_iterations = 100 +p.engines.engine00.fourier_relax_factor = 0.05 + +p.engines.engine01 = u.Param() +p.engines.engine01.name = 'ML_pycuda' +p.engines.engine01.numiter = 50 + +P = Ptycho(p,level=5) + diff --git a/templates/accelerate/ptypy_i13_AuStar_nearfield_pycuda.py b/templates/accelerate/ptypy_i13_AuStar_nearfield_pycuda.py new file mode 100644 index 000000000..21846666c --- /dev/null +++ b/templates/accelerate/ptypy_i13_AuStar_nearfield_pycuda.py @@ -0,0 +1,117 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses a simulated Au Siemens star pattern under +experimental nearfield conditions in the hard X-ray regime. +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +### PTYCHO PARAMETERS +p = u.Param() +p.verbose_level = "info" +p.run = None +p.frames_per_block = 20 + +p.data_type = "single" +p.run = None +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False, layout="nearfield") +p.io.interaction = u.Param(active=False) + +# Simulation parameters +sim = u.Param() +sim.energy = 9.7 +sim.distance = 8.46e-2 +sim.psize = 100e-9 +sim.shape = 1024 +sim.xy = u.Param() +sim.xy.override = u.parallel.MPIrand_uniform(0.0,10e-6,(20,2)) +#sim.xy.positions = np.random.normal(0.0,3e-6,(20,2)) +sim.verbose_level = 1 + +sim.illumination = u.Param() +sim.illumination.model = None +sim.illumination.photons = 1e11 +sim.illumination.aperture = u.Param() +sim.illumination.aperture.diffuser = (8.0, 10.0) +sim.illumination.aperture.form = "circ" +sim.illumination.aperture.size = 90e-6 +sim.illumination.aperture.central_stop = 0.15 +sim.illumination.propagation = u.Param() +sim.illumination.propagation.focussed = None#0.08 +sim.illumination.propagation.parallel = 0.005 +sim.illumination.propagation.spot_size = None + +sim.sample = u.Param() +sim.sample.model = u.xradia_star((1200,1200),minfeature=3,contrast=0.8) +sim.sample.process = u.Param() +sim.sample.process.offset = (0,0) +sim.sample.process.zoom = 1.0 +sim.sample.process.formula = "Au" +sim.sample.process.density = 19.3 +sim.sample.process.thickness = 700e-9 +sim.sample.process.ref_index = None +sim.sample.process.smoothing = None +sim.sample.fill = 1.0+0.j + +sim.detector = 'GenericCCD32bit' +sim.plot = False + +# Scan model and initial value parameters +p.scans = u.Param() +p.scans.scan00 = u.Param() +p.scans.scan00.name = 'BlockFull' +p.scans.scan00.propagation = "nearfield" + +p.scans.scan00.coherence = u.Param() +p.scans.scan00.coherence.num_probe_modes = 1 +p.scans.scan00.coherence.num_object_modes = 1 +p.scans.scan00.coherence.energies = [1.0] + +p.scans.scan00.sample = u.Param() + +# (copy simulation illumination and modify some things) +p.scans.scan00.illumination = sim.illumination.copy(99) +p.scans.scan00.illumination.aperture.size = 105e-6 +p.scans.scan00.illumination.aperture.central_stop = None + +# Scan data (simulation) parameters +p.scans.scan00.data=u.Param() +p.scans.scan00.data.name = 'SimScan' +p.scans.scan00.data.propagation = 'nearfield' +p.scans.scan00.data.save = None #'append' +p.scans.scan00.data.shape = None +p.scans.scan00.data.num_frames = None +p.scans.scan00.data.update(sim) + +# Reconstruction parameters +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda' +p.engines.engine00.numiter = 100 +p.engines.engine00.object_inertia = 1. +p.engines.engine00.numiter_contiguous = 1 +p.engines.engine00.probe_support = None +p.engines.engine00.probe_inertia = 0.001 +p.engines.engine00.obj_smooth_std = 10 +p.engines.engine00.clip_object = None +p.engines.engine00.alpha = 1 +p.engines.engine00.probe_update_start = 2 +p.engines.engine00.update_object_first = True +p.engines.engine00.overlap_converge_factor = 0.5 +p.engines.engine00.overlap_max_iterations = 100 +p.engines.engine00.fourier_relax_factor = 0.05 + +p.engines.engine01 = u.Param() +p.engines.engine01.name = 'ML_pycuda' +p.engines.engine01.numiter = 50 + +P = Ptycho(p,level=5) + diff --git a/templates/accelerate/ptypy_id22ni_AuStar_focused_pycuda.py b/templates/accelerate/ptypy_id22ni_AuStar_focused_pycuda.py new file mode 100644 index 000000000..d14913301 --- /dev/null +++ b/templates/accelerate/ptypy_id22ni_AuStar_focused_pycuda.py @@ -0,0 +1,119 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses a simulated Au Siemens star pattern under +experimental farfield conditions and with a focused beam in the hard X-ray regime. +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import numpy as np +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +### PTYCHO PARAMETERS +p.verbose_level = "info" + +p.data_type = "single" +p.run = None + +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False, layout="weak") +p.io.interaction = u.Param(active=False) + +# Simulation parameters +sim = u.Param() +sim.energy = 17.0 +sim.distance = 2.886 +sim.psize = 51e-6 +sim.shape = 256 +sim.xy = u.Param() +sim.xy.model = "round" +sim.xy.spacing = 250e-9 +sim.xy.steps = 30 +sim.xy.extent = 4e-6 + +sim.illumination = u.Param() +sim.illumination.model = None +sim.illumination.photons = 3e8 +sim.illumination.aperture = u.Param() +sim.illumination.aperture.diffuser = None +sim.illumination.aperture.form = "rect" +sim.illumination.aperture.size = 35e-6 +sim.illumination.aperture.central_stop = None +sim.illumination.propagation = u.Param() +sim.illumination.propagation.focussed = 0.08 +sim.illumination.propagation.parallel = 0.0014 +sim.illumination.propagation.spot_size = None + +sim.sample = u.Param() +sim.sample.model = u.xradia_star((1000,1000),minfeature=3,contrast=0.0) +sim.sample.process = u.Param() +sim.sample.process.offset = (100,100) +sim.sample.process.zoom = 1.0 +sim.sample.process.formula = "Au" +sim.sample.process.density = 19.3 +sim.sample.process.thickness = 2000e-9 +sim.sample.process.ref_index = None +sim.sample.process.smoothing = None +sim.sample.fill = 1.0+0.j + +#sim.detector = 'FRELON_TAPER' +sim.detector = 'GenericCCD32bit' +sim.verbose_level = 1 +sim.psf = 1. # emulates partial coherence +sim.plot = False + +# Scan model and initial value parameters +p.scans = u.Param() +p.scans.scan00 = u.Param() +p.scans.scan00.name = 'BlockFull' + +p.scans.scan00.coherence = u.Param() +p.scans.scan00.coherence.num_probe_modes = 4 +p.scans.scan00.coherence.num_object_modes = 1 +p.scans.scan00.coherence.energies = [1.0] + +p.scans.scan00.sample = u.Param() +p.scans.scan00.sample.model = 'stxm' +p.scans.scan00.sample.process = None + +# (copy the simulation illumination and change specific things) +p.scans.scan00.illumination = sim.illumination.copy(99) +p.scans.scan00.illumination.aperture.form = 'circ' +p.scans.scan00.illumination.propagation.focussed = 0.06 +p.scans.scan00.illumination.diversity = u.Param() +p.scans.scan00.illumination.diversity.power = 0.1 +p.scans.scan00.illumination.diversity.noise = (np.pi,3.0) + +# Scan data (simulation) parameters +p.scans.scan00.data = u.Param() +p.scans.scan00.data.name = 'SimScan' +p.scans.scan00.data.update(sim) +p.scans.scan00.data.save = None + +# Reconstruction parameters +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda' +p.engines.engine00.numiter = 150 +p.engines.engine00.fourier_relax_factor = 0.05 +p.engines.engine00.numiter_contiguous = 1 +p.engines.engine00.probe_support = 0.7 +p.engines.engine00.probe_inertia = 0.01 +p.engines.engine00.object_inertia = 0.1 +p.engines.engine00.clip_object = (0, 1.) +p.engines.engine00.alpha = 1 +p.engines.engine00.probe_update_start = 2 +p.engines.engine00.update_object_first = True +p.engines.engine00.overlap_converge_factor = 0.05 +p.engines.engine00.overlap_max_iterations = 100 +p.engines.engine00.obj_smooth_std = 5 + +u.verbose.set_level("info") +P = Ptycho(p,level=5) diff --git a/templates/accelerate/ptypy_laser_logo_focused_pycuda.py b/templates/accelerate/ptypy_laser_logo_focused_pycuda.py new file mode 100644 index 000000000..0274aefa2 --- /dev/null +++ b/templates/accelerate/ptypy_laser_logo_focused_pycuda.py @@ -0,0 +1,99 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses a simulated Au Siemens star pattern under +experimental farfield conditions and with a focused optical laser beam. +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy.simulations as sim +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import pathlib +import numpy as np +import tempfile +tmpdir = tempfile.gettempdir() + +### PTYCHO PARAMETERS +p = u.Param() +p.verbose_level = "info" +p.data_type = "single" + +p.run = None +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False, layout="minimal") +p.io.interaction = u.Param(active=False) + +# Simulation parameters +sim = u.Param() +sim.energy = u.keV2m(1.0)/6.32e-7 +sim.distance = 15e-2 +sim.psize = 24e-6 +sim.shape = 256 +sim.xy = u.Param() +sim.xy.model = "round" +sim.xy.spacing = 0.3e-3 +sim.xy.steps = 60 +sim.xy.extent = (5e-3,10e-3) + +sim.illumination = u.Param() +sim.illumination.model = None +sim.illumination.photons = int(1e9) +sim.illumination.aperture = u.Param() +sim.illumination.aperture.diffuser = None#(0.7,3) +sim.illumination.aperture.form = "circ" +sim.illumination.aperture.size = 1.0e-3 +sim.illumination.aperture.edge = 2 +sim.illumination.aperture.central_stop = None +sim.illumination.propagation = u.Param() +sim.illumination.propagation.focussed = None +sim.illumination.propagation.parallel = 0.03 +sim.illumination.propagation.spot_size = None + +imgfile = "/".join([str(pathlib.Path(__file__).parent.resolve()), '../../resources/ptypy_logo_1M.png']) +sim.sample = u.Param() +sim.sample.model = -u.rgb2complex(u.imload(imgfile)[::-1,:,:-1]) +sim.sample.process = u.Param() +sim.sample.process.offset = (0,0) +sim.sample.process.zoom = 0.5 +sim.sample.process.formula = None +sim.sample.process.density = None +sim.sample.process.thickness = None +sim.sample.process.ref_index = None +sim.sample.process.smoothing = None +sim.sample.fill = 1.0+0.j +sim.plot=False +sim.detector = u.Param(dtype=np.uint32,full_well=2**32-1,psf=None) + +# Scan model and initial value parameters +p.scans = u.Param() +p.scans.ptypy = u.Param() +p.scans.ptypy.name = 'BlockFull' + +p.scans.ptypy.coherence = u.Param() +p.scans.ptypy.coherence.num_probe_modes=1 + +p.scans.ptypy.illumination = u.Param() +p.scans.ptypy.illumination.model=None +p.scans.ptypy.illumination.aperture = u.Param() +p.scans.ptypy.illumination.aperture.diffuser = None +p.scans.ptypy.illumination.aperture.form = "circ" +p.scans.ptypy.illumination.aperture.size = 1.0e-3 +p.scans.ptypy.illumination.aperture.edge = 10 + +# Scan data (simulation) parameters +p.scans.ptypy.data = u.Param() +p.scans.ptypy.data.name = 'SimScan' +p.scans.ptypy.data.update(sim) + +# Reconstruction parameters +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda' +p.engines.engine00.numiter = 40 +p.engines.engine00.fourier_relax_factor = 0.05 + +u.verbose.set_level("info") +P = Ptycho(p,level=5) diff --git a/templates/accelerate/ptypy_minimal_prep_and_run_pycuda.py b/templates/accelerate/ptypy_minimal_prep_and_run_pycuda.py new file mode 100644 index 000000000..26226aae4 --- /dev/null +++ b/templates/accelerate/ptypy_minimal_prep_and_run_pycuda.py @@ -0,0 +1,53 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 200 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda' +p.engines.engine00.numiter = 80 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_DM.py b/templates/engines/moonflower_DM.py new file mode 100644 index 000000000..8cebace19 --- /dev/null +++ b/templates/engines/moonflower_DM.py @@ -0,0 +1,54 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) + +# saving intermediate results +p.io.autosave = u.Param(active=False) + +# opens plotting GUI if interaction set to active) +p.io.autoplot = u.Param(active=True) +p.io.interaction = u.Param(active=True) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM' +p.engines.engine00.numiter = 80 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_DM_ML.py b/templates/engines/moonflower_DM_ML.py new file mode 100644 index 000000000..18fd7603e --- /dev/null +++ b/templates/engines/moonflower_DM_ML.py @@ -0,0 +1,69 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 400 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) + +# saving intermediate results +p.io.autosave = u.Param(active=False) + +# opens plotting GUI if interaction set to active) +p.io.autoplot = u.Param(active=True) +p.io.interaction = u.Param(active=True) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 600 +p.scans.MF.data.save = None + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=1) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM' +p.engines.engine00.numiter = 60 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.probe_support = 0.5 + +# attach a reconstrucion engine +p.engines.engine01 = u.Param() +p.engines.engine01.name = 'ML' +p.engines.engine01.numiter = 20 +p.engines.engine01.numiter_contiguous = 5 +p.engines.engine01.reg_del2 = False +p.engines.engine01.reg_del2_amplitude = 1. +p.engines.engine01.floating_intensities = False +p.engines.engine01.probe_support = 0.5 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_DM_ML_pycuda.py b/templates/engines/moonflower_DM_ML_pycuda.py new file mode 100644 index 000000000..8ea2584d7 --- /dev/null +++ b/templates/engines/moonflower_DM_ML_pycuda.py @@ -0,0 +1,67 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 400 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 600 +p.scans.MF.data.save = None + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=1) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda' +p.engines.engine00.numiter = 60 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.probe_support = 0.5 + +# attach a reconstrucion engine +p.engines.engine01 = u.Param() +p.engines.engine01.name = 'ML_pycuda' +p.engines.engine01.numiter = 20 +p.engines.engine01.numiter_contiguous = 5 +p.engines.engine01.reg_del2 = False +p.engines.engine01.reg_del2_amplitude = 1. +p.engines.engine01.floating_intensities = False +p.engines.engine01.probe_support = 0.5 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_DM_ocl.py b/templates/engines/moonflower_DM_ocl.py new file mode 100644 index 000000000..4a8119fe4 --- /dev/null +++ b/templates/engines/moonflower_DM_ocl.py @@ -0,0 +1,56 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="ocl") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 300 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 1000 +p.scans.MF.data.save = None + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=2) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.1 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_ocl' +p.engines.engine00.numiter = 80 +p.engines.engine00.numiter_contiguous = 10 + +# prepare and run +P = Ptycho(p,level=5) \ No newline at end of file diff --git a/templates/engines/moonflower_DM_pycuda.py b/templates/engines/moonflower_DM_pycuda.py new file mode 100644 index 000000000..e09aca720 --- /dev/null +++ b/templates/engines/moonflower_DM_pycuda.py @@ -0,0 +1,56 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 200 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 1000 +p.scans.MF.data.save = None + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=4) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda' +p.engines.engine00.numiter = 20 +p.engines.engine00.numiter_contiguous = 10 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_DM_pycuda_nostream.py b/templates/engines/moonflower_DM_pycuda_nostream.py new file mode 100644 index 000000000..4970bfe06 --- /dev/null +++ b/templates/engines/moonflower_DM_pycuda_nostream.py @@ -0,0 +1,57 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 200 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 1000 +p.scans.MF.data.save = None + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=4) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda_nostream' +p.engines.engine00.numiter = 20 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.probe_update_start = 1 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_DM_serial.py b/templates/engines/moonflower_DM_serial.py new file mode 100644 index 000000000..fdc352d4f --- /dev/null +++ b/templates/engines/moonflower_DM_serial.py @@ -0,0 +1,56 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="serial") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 200 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 400 +p.scans.MF.data.save = None + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=1) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_serial' +p.engines.engine00.numiter = 20 +p.engines.engine00.numiter_contiguous = 10 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_EPIE.py b/templates/engines/moonflower_EPIE.py new file mode 100644 index 000000000..12931b06a --- /dev/null +++ b/templates/engines/moonflower_EPIE.py @@ -0,0 +1,60 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) + +# saving intermediate results +p.io.autosave = u.Param(active=False) + +# opens plotting GUI if interaction set to active) +p.io.autoplot = u.Param(active=True) +p.io.interaction = u.Param(active=True) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'GradFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'EPIE' +p.engines.engine00.numiter = 200 +p.engines.engine00.probe_center_tol = None +p.engines.engine00.compute_log_likelihood = True +p.engines.engine00.object_norm_is_global = True +p.engines.engine00.alpha = 1 +p.engines.engine00.beta = 1 +p.engines.engine00.probe_update_start = 2 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_EPIE_ML_pycuda.py b/templates/engines/moonflower_EPIE_ML_pycuda.py new file mode 100644 index 000000000..c9635b82f --- /dev/null +++ b/templates/engines/moonflower_EPIE_ML_pycuda.py @@ -0,0 +1,74 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'GradFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +p.scans.MF.illumination=u.Param() +p.scans.MF.illumination.diversity = None + +p.scans.MF.coherence=u.Param() +p.scans.MF.coherence.num_probe_modes = 1 +p.scans.MF.coherence.num_object_modes = 1 + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'EPIE_pycuda' +p.engines.engine00.numiter = 200 +p.engines.engine00.probe_center_tol = None +p.engines.engine00.compute_log_likelihood = True +p.engines.engine00.object_norm_is_global = True +p.engines.engine00.alpha = 1 +p.engines.engine00.beta = 1 +p.engines.engine00.probe_update_start = 2 + +p.engines.engine01 = u.Param() +p.engines.engine01.name = 'ML_pycuda' +p.engines.engine01.ML_type = 'Gaussian' +p.engines.engine01.reg_del2 = True +p.engines.engine01.reg_del2_amplitude = 1. +p.engines.engine01.scale_precond = True +p.engines.engine01.scale_probe_object = 1. +p.engines.engine01.numiter = 100 + +# prepare and run +P = Ptycho(p,level=5) \ No newline at end of file diff --git a/templates/engines/moonflower_EPIE_pycuda.py b/templates/engines/moonflower_EPIE_pycuda.py new file mode 100644 index 000000000..4ef869bb6 --- /dev/null +++ b/templates/engines/moonflower_EPIE_pycuda.py @@ -0,0 +1,58 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'GradFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'EPIE_pycuda' +p.engines.engine00.numiter = 200 +p.engines.engine00.probe_center_tol = None +p.engines.engine00.compute_log_likelihood = True +p.engines.engine00.object_norm_is_global = True +p.engines.engine00.alpha = 1 +p.engines.engine00.beta = 1 +p.engines.engine00.probe_update_start = 2 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_EPIE_serial.py b/templates/engines/moonflower_EPIE_serial.py new file mode 100644 index 000000000..785f04933 --- /dev/null +++ b/templates/engines/moonflower_EPIE_serial.py @@ -0,0 +1,58 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="serial") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'GradFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'EPIE_serial' +p.engines.engine00.numiter = 200 +p.engines.engine00.probe_center_tol = None +p.engines.engine00.compute_log_likelihood = True +p.engines.engine00.object_norm_is_global = True +p.engines.engine00.alpha = 1 +p.engines.engine00.beta = 1 +p.engines.engine00.probe_update_start = 2 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/minimal_prep_and_run_resample_ML.py b/templates/engines/moonflower_ML_Gaussian.py similarity index 64% rename from templates/minimal_prep_and_run_resample_ML.py rename to templates/engines/moonflower_ML_Gaussian.py index f0d5619f9..9e1334c02 100644 --- a/templates/minimal_prep_and_run_resample_ML.py +++ b/templates/engines/moonflower_ML_Gaussian.py @@ -7,27 +7,33 @@ from ptypy.core import Ptycho from ptypy import utils as u +import tempfile +tmpdir = tempfile.gettempdir() + p = u.Param() # for verbose output -p.verbose_level = 4 +p.verbose_level = "info" # set home path p.io = u.Param() -p.io.home = "/tmp/ptypy/" -p.io.autosave = None -#p.io.autoplot = u.Param() -#p.io.autoplot.dump = True -#p.io.autoplot = False +p.io.home = "/".join([tmpdir, "ptypy"]) + +# saving intermediate results +p.io.autosave = u.Param(active=False) + +# opens plotting GUI if interaction set to active) +p.io.autoplot = u.Param(active=True) +p.io.interaction = u.Param(active=True) # max 100 frames (128x128px) of diffraction data p.scans = u.Param() p.scans.MF = u.Param() -p.scans.MF.name = 'Full' +p.scans.MF.name = 'BlockFull' p.scans.MF.data= u.Param() p.scans.MF.data.name = 'MoonFlowerScan' p.scans.MF.data.shape = 128 -p.scans.MF.data.num_frames = 100 +p.scans.MF.data.num_frames = 200 p.scans.MF.data.save = None # position distance in fraction of illumination frame @@ -37,23 +43,19 @@ # Gaussian FWHM of possible detector blurring p.scans.MF.data.psf = 0. -# Resample by a factor of 2 -p.scans.MF.resample = 2 - # attach a reconstrucion engine p.engines = u.Param() p.engines.engine00 = u.Param() p.engines.engine00.name = 'ML' -p.engines.engine00.reg_del2 = True # Whether to use a Gaussian prior (smoothing) regularizer +p.engines.engine00.ML_type = 'Gaussian' +p.engines.engine00.reg_del2 = True # Whether to use a Gaussian prior (smoothing) regularizer p.engines.engine00.reg_del2_amplitude = 1. # Amplitude of the Gaussian prior if used p.engines.engine00.scale_precond = True -p.engines.engine00.scale_probe_object = 1. +#p.engines.engine00.scale_probe_object = 1. p.engines.engine00.smooth_gradient = 20. p.engines.engine00.smooth_gradient_decay = 1/50. -p.engines.engine00.floating_intensities = True +p.engines.engine00.floating_intensities = False p.engines.engine00.numiter = 300 # prepare and run -P = Ptycho(p,level=4) -P.run() - +P = Ptycho(p,level=5) diff --git a/templates/minimal_prep_and_run_ML_Poisson.py b/templates/engines/moonflower_ML_Poisson.py similarity index 83% rename from templates/minimal_prep_and_run_ML_Poisson.py rename to templates/engines/moonflower_ML_Poisson.py index 374622217..7c638d65e 100644 --- a/templates/minimal_prep_and_run_ML_Poisson.py +++ b/templates/engines/moonflower_ML_Poisson.py @@ -3,28 +3,32 @@ of actual data. It uses the test Scan class `ptypy.core.data.MoonFlowerScan` to provide "data". """ -#import ptypy from ptypy.core import Ptycho from ptypy import utils as u -#import numpy -#numpy.seterr(divide='raise', invalid='raise') + +import tempfile +tmpdir = tempfile.gettempdir() p = u.Param() # for verbose output -p.verbose_level = 4 +p.verbose_level = "info" # set home path p.io = u.Param() -p.io.home = "/tmp/ptypy/" -p.io.autosave = None -p.io.autoplot = u.Param() -p.io.autoplot.active = True +p.io.home = "/".join([tmpdir, "ptypy"]) + +# saving intermediate results +p.io.autosave = u.Param(active=False) + +# opens plotting GUI if interaction set to active) +p.io.autoplot = u.Param(active=True) +p.io.interaction = u.Param(active=True) # max 100 frames (128x128px) of diffraction data p.scans = u.Param() p.scans.MF = u.Param() -p.scans.MF.name = 'Full' +p.scans.MF.name = 'BlockFull' p.scans.MF.data= u.Param() p.scans.MF.data.name = 'MoonFlowerScan' p.scans.MF.data.shape = 128 @@ -60,5 +64,6 @@ p.engines.engine01.smooth_gradient_decay = 1/50. p.engines.engine01.floating_intensities = False p.engines.engine01.numiter = 300 + # prepare and run P = Ptycho(p, level=5) diff --git a/templates/engines/moonflower_ML_pycuda.py b/templates/engines/moonflower_ML_pycuda.py new file mode 100644 index 000000000..9d86f501e --- /dev/null +++ b/templates/engines/moonflower_ML_pycuda.py @@ -0,0 +1,62 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" + +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 400 +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 100 +p.scans.MF.data.save = None + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=1) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'ML_pycuda' +p.engines.engine00.numiter = 300 +p.engines.engine00.numiter_contiguous = 5 +p.engines.engine00.reg_del2 = True # Whether to use a Gaussian prior (smoothing) regularizer +p.engines.engine00.reg_del2_amplitude = 1. # Amplitude of the Gaussian prior if used +p.engines.engine00.scale_precond = True +p.engines.engine00.smooth_gradient = 20. +p.engines.engine00.smooth_gradient_decay = 1/50. +p.engines.engine00.floating_intensities = False + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_ML_serial.py b/templates/engines/moonflower_ML_serial.py new file mode 100644 index 000000000..6f4cccfbe --- /dev/null +++ b/templates/engines/moonflower_ML_serial.py @@ -0,0 +1,62 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u + +import ptypy +ptypy.load_gpu_engines(arch="serial") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 100 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 600 +p.scans.MF.data.save = None +p.scans.MF.data.block_wait_count = 1 + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=1) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.1 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_serial' +p.engines.engine00.numiter = 20 +p.engines.engine00.numiter_contiguous = 1 +p.engines.engine01 = u.Param() +p.engines.engine01.name = 'ML_serial' +p.engines.engine01.numiter = 20 +p.engines.engine01.numiter_contiguous = 1 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/minimal_prep_and_run_ePIE.py b/templates/engines/moonflower_RAAR.py similarity index 72% rename from templates/minimal_prep_and_run_ePIE.py rename to templates/engines/moonflower_RAAR.py index 28d8bced8..c01bb236c 100644 --- a/templates/minimal_prep_and_run_ePIE.py +++ b/templates/engines/moonflower_RAAR.py @@ -3,26 +3,34 @@ of actual data. It uses the test Scan class `ptypy.core.data.MoonFlowerScan` to provide "data". """ - from ptypy.core import Ptycho from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + p = u.Param() # for verbose output -p.verbose_level = 3 +p.verbose_level = "info" # set home path p.io = u.Param() -p.io.home = "/tmp/ptypy/" -p.io.autosave = None -#p.io.autoplot = u.Param(active=False) +p.io.home = "/".join([tmpdir, "ptypy"]) + +# saving intermediate results +p.io.autosave = u.Param(active=False) + +# opens plotting GUI if interaction set to active) +p.io.autoplot = u.Param(active=True) +p.io.interaction = u.Param(active=True) # max 200 frames (128x128px) of diffraction data p.scans = u.Param() p.scans.MF = u.Param() # now you have to specify which ScanModel to use with scans.XX.name, # just as you have to give 'name' for engines and PtyScan subclasses. -p.scans.MF.name = 'Vanilla' # or 'Full' +p.scans.MF.name = 'BlockFull' p.scans.MF.data= u.Param() p.scans.MF.data.name = 'MoonFlowerScan' p.scans.MF.data.shape = 128 @@ -36,17 +44,12 @@ # Gaussian FWHM of possible detector blurring p.scans.MF.data.psf = 0. -#p.scans.MF.resample = 2 - # attach a reconstrucion engine p.engines = u.Param() p.engines.engine00 = u.Param() -p.engines.engine00.name = 'ePIE' +p.engines.engine00.name = 'RAAR' p.engines.engine00.numiter = 100 -p.engines.engine00.average_probe = True -#p.engines.engine00.obj_smooth_std = 2 -p.engines.engine00.probe_center_tol = None -#p.engines.engine00.compute_log_likelihood = False +p.engines.engine00.beta = 0.9 # prepare and run P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_RAAR_ML.py b/templates/engines/moonflower_RAAR_ML.py new file mode 100644 index 000000000..5745a6c3f --- /dev/null +++ b/templates/engines/moonflower_RAAR_ML.py @@ -0,0 +1,70 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 400 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) + +# saving intermediate results +p.io.autosave = u.Param(active=False) + +# opens plotting GUI if interaction set to active) +p.io.autoplot = u.Param(active=True) +p.io.interaction = u.Param(active=True) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 600 +p.scans.MF.data.save = None + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=1) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'RAAR' +p.engines.engine00.numiter = 60 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.probe_support = 0.5 +p.engines.engine00.beta = 0.9 + +# attach a reconstrucion engine +p.engines.engine01 = u.Param() +p.engines.engine01.name = 'ML' +p.engines.engine01.numiter = 20 +p.engines.engine01.numiter_contiguous = 5 +p.engines.engine01.reg_del2 = False +p.engines.engine01.reg_del2_amplitude = 1. +p.engines.engine01.floating_intensities = False +p.engines.engine01.probe_support = 0.5 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_RAAR_ML_pycuda.py b/templates/engines/moonflower_RAAR_ML_pycuda.py new file mode 100644 index 000000000..75f0e7b27 --- /dev/null +++ b/templates/engines/moonflower_RAAR_ML_pycuda.py @@ -0,0 +1,68 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 400 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 600 +p.scans.MF.data.save = None + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=1) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'RAAR_pycuda' +p.engines.engine00.numiter = 60 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.probe_support = 0.5 +p.engines.engine00.beta = 0.9 + +# attach a reconstrucion engine +p.engines.engine01 = u.Param() +p.engines.engine01.name = 'ML_pycuda' +p.engines.engine01.numiter = 20 +p.engines.engine01.numiter_contiguous = 5 +p.engines.engine01.reg_del2 = False +p.engines.engine01.reg_del2_amplitude = 1. +p.engines.engine01.floating_intensities = False +p.engines.engine01.probe_support = 0.5 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_RAAR_pycuda.py b/templates/engines/moonflower_RAAR_pycuda.py new file mode 100644 index 000000000..404f2925d --- /dev/null +++ b/templates/engines/moonflower_RAAR_pycuda.py @@ -0,0 +1,57 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 200 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 1000 +p.scans.MF.data.save = None + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=4) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'RAAR_pycuda' +p.engines.engine00.numiter = 20 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.beta = 0.9 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_RAAR_serial.py b/templates/engines/moonflower_RAAR_serial.py new file mode 100644 index 000000000..7f43c8112 --- /dev/null +++ b/templates/engines/moonflower_RAAR_serial.py @@ -0,0 +1,57 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="serial") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 200 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 400 +p.scans.MF.data.save = None + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=1) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'RAAR_serial' +p.engines.engine00.numiter = 20 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.beta = 0.9 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_SDR.py b/templates/engines/moonflower_SDR.py new file mode 100644 index 000000000..f0b4926aa --- /dev/null +++ b/templates/engines/moonflower_SDR.py @@ -0,0 +1,62 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# Frames per block +p.frames_per_block = 200 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) + +# saving intermediate results +p.io.autosave = u.Param(active=False) + +# opens plotting GUI if interaction set to active) +p.io.autoplot = u.Param(active=True) +p.io.interaction = u.Param(active=True) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'Full' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0.0 +p.scans.MF.coherence = u.Param() +p.scans.MF.coherence.num_probe_modes = 1 + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'SDR' +p.engines.engine00.numiter = 300 +p.engines.engine00.sigma = 0.5 +p.engines.engine00.tau = 0.1 + + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_SDR_pycuda.py b/templates/engines/moonflower_SDR_pycuda.py new file mode 100644 index 000000000..819315492 --- /dev/null +++ b/templates/engines/moonflower_SDR_pycuda.py @@ -0,0 +1,60 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# Frames per block +p.frames_per_block = 200 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'Full' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0.0 +p.scans.MF.coherence = u.Param() +p.scans.MF.coherence.num_probe_modes = 1 + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'SDR_pycuda' +p.engines.engine00.numiter = 500 +p.engines.engine00.sigma = 0.5 +p.engines.engine00.tau = 0.1 +p.engines.engine00.probe_update_start = 2 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/engines/moonflower_SDR_serial.py b/templates/engines/moonflower_SDR_serial.py new file mode 100644 index 000000000..f72d388a6 --- /dev/null +++ b/templates/engines/moonflower_SDR_serial.py @@ -0,0 +1,59 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="serial") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# Frames per block +p.frames_per_block = 200 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'Full' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0.0 +p.scans.MF.coherence = u.Param() +p.scans.MF.coherence.num_probe_modes = 1 + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'SDR_serial' +p.engines.engine00.numiter = 100 +p.engines.engine00.sigma = 0.5 +p.engines.engine00.tau = 0.1 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/nanomax_zmq_run.py b/templates/experiment/nanomax_zmq_run.py similarity index 83% rename from templates/nanomax_zmq_run.py rename to templates/experiment/nanomax_zmq_run.py index 78d8625f3..f23109cd0 100644 --- a/templates/nanomax_zmq_run.py +++ b/templates/experiment/nanomax_zmq_run.py @@ -2,18 +2,23 @@ Loads data from a zmq stream published by Contrast at NanoMAX, https://github.com/alexbjorling/contrast """ - from ptypy.core import Ptycho from ptypy import utils as u +import ptypy +ptypy.load_ptyscan_module("nanomax_streaming") + +import tempfile +tmpdir = tempfile.gettempdir() + p = u.Param() # for verbose output -p.verbose_level = 3 +p.verbose_level = "info" # set home path p.io = u.Param() -p.io.home = "/tmp/ptypy/" -p.io.autosave = None +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) # max 200 frames (128x128px) of diffraction data p.scans = u.Param() diff --git a/templates/live_processing/moonflower_DM_delayed.py b/templates/live_processing/moonflower_DM_delayed.py new file mode 100644 index 000000000..fb2230335 --- /dev/null +++ b/templates/live_processing/moonflower_DM_delayed.py @@ -0,0 +1,57 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" + +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="serial") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 200 +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=True) +p.io.autoplot = u.Param(active=True) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 1000 +p.scans.MF.data.save = None +p.scans.MF.data.block_wait_count = 1 + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=1) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_serial' +p.engines.engine00.numiter = 60 +p.engines.engine00.numiter_contiguous = 2 +p.engines.engine00.probe_update_start = 1 + +# prepare and run +P = Ptycho(p,level=5) \ No newline at end of file diff --git a/templates/live_processing/moonflower_DM_delayed_pycuda.py b/templates/live_processing/moonflower_DM_delayed_pycuda.py new file mode 100644 index 000000000..6e59390c2 --- /dev/null +++ b/templates/live_processing/moonflower_DM_delayed_pycuda.py @@ -0,0 +1,59 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" + +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 200 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 1000 +p.scans.MF.data.save = None +p.scans.MF.data.block_wait_count = 1 + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=1) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda' +p.engines.engine00.numiter = 120 +p.engines.engine00.numiter_contiguous = 5 +p.engines.engine00.probe_update_start = 1 + +# prepare and run +P = Ptycho(p,level=5) \ No newline at end of file diff --git a/templates/on_the_fly_ptyd.py b/templates/live_processing/on_the_fly_ptyd.py similarity index 100% rename from templates/on_the_fly_ptyd.py rename to templates/live_processing/on_the_fly_ptyd.py diff --git a/templates/on_the_fly_rec.py b/templates/live_processing/on_the_fly_rec.py similarity index 100% rename from templates/on_the_fly_rec.py rename to templates/live_processing/on_the_fly_rec.py diff --git a/templates/bragg_field_of_view.py b/templates/misc/bragg_field_of_view.py similarity index 98% rename from templates/bragg_field_of_view.py rename to templates/misc/bragg_field_of_view.py index 4376e6ebc..dea88e759 100644 --- a/templates/bragg_field_of_view.py +++ b/templates/misc/bragg_field_of_view.py @@ -2,16 +2,17 @@ Example script which uses the 3d Bragg ptycho code to calculate and plot the 3d field of view as compared to the incoming probe. """ - from ptypy.core import Ptycho from ptypy import utils as u +import ptypy +ptypy.load_ptyscan_module("Bragg3dSim") import matplotlib.pyplot as plt import numpy as np # Set up a parameter tree p = u.Param() -p.verbose_level = 3 +p.verbose_level = "info" # illumination for data simulation and pods illumination = u.Param() diff --git a/templates/bragg_prep_and_run.py b/templates/misc/bragg_prep_and_run.py similarity index 95% rename from templates/bragg_prep_and_run.py rename to templates/misc/bragg_prep_and_run.py index 40ab60f9f..d6ced5020 100644 --- a/templates/bragg_prep_and_run.py +++ b/templates/misc/bragg_prep_and_run.py @@ -1,16 +1,17 @@ """ Simulates and then inverts 3d Bragg ptycho data. """ - from ptypy.core import Ptycho from ptypy import utils as u +import ptypy +ptypy.load_ptyscan_module("Bragg3dSim") import tempfile p = u.Param() p.run = 'Si110_stripes' # for verbose output -p.verbose_level = 3 +p.verbose_level = "info" # use special plot layout for 3d data p.io = u.Param() diff --git a/templates/misc/moonflower_DM_object_regul.py b/templates/misc/moonflower_DM_object_regul.py new file mode 100644 index 000000000..7b8e7d7a0 --- /dev/null +++ b/templates/misc/moonflower_DM_object_regul.py @@ -0,0 +1,62 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +from ptypy.custom import DM_object_regul, DM_pycuda_object_regul +import numpy as np + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +ny,nx = (492,492) +xx,yy = np.meshgrid(np.arange(nx)-nx//2, np.arange(ny)-ny//2) +mask = xx**2 + yy**2 > (150)**2 +mask = np.expand_dims(mask,0) + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 200 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockVanilla' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_object_regul' +p.engines.engine00.numiter = 80 +p.engines.engine00.object_regul_mask = mask +p.engines.engine00.object_regul_fill = 0. +p.engines.engine00.object_regul_start = 10 +p.engines.engine00.object_regul_stop = 60 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/misc/moonflower_DM_object_regul_pycuda.py b/templates/misc/moonflower_DM_object_regul_pycuda.py new file mode 100644 index 000000000..5ac11fe91 --- /dev/null +++ b/templates/misc/moonflower_DM_object_regul_pycuda.py @@ -0,0 +1,62 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u +from ptypy.custom import DM_object_regul, DM_pycuda_object_regul +import numpy as np + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +ny,nx = (492,492) +xx,yy = np.meshgrid(np.arange(nx)-nx//2, np.arange(ny)-ny//2) +mask = xx**2 + yy**2 > (150)**2 +mask = np.expand_dims(mask,0) + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 200 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockVanilla' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda_object_regul' +p.engines.engine00.numiter = 80 +p.engines.engine00.object_regul_mask = mask +p.engines.engine00.object_regul_fill = 0. +p.engines.engine00.object_regul_start = 10 +p.engines.engine00.object_regul_stop = 60 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/probe_sharing.py b/templates/misc/moonflower_probe_sharing.py similarity index 94% rename from templates/probe_sharing.py rename to templates/misc/moonflower_probe_sharing.py index caa2a4dd6..8cec73cc6 100644 --- a/templates/probe_sharing.py +++ b/templates/misc/moonflower_probe_sharing.py @@ -1,16 +1,13 @@ ''' An example showing how to share a probe across two scans ''' - - -import sys -import time import ptypy from ptypy import utils as u from ptypy.core import Ptycho import tempfile u.verbose.set_level(3) tmp = tempfile.mkdtemp()+'/%s' +tmpdir = tempfile.gettempdir() def make_sample(outpath): data = u.Param() @@ -40,10 +37,10 @@ def make_sample(outpath): p = u.Param() -p.verbose_level = 3 +p.verbose_level = "info" p.io = u.Param() -p.io.home = "/tmp/ptypy/" -p.io.autosave = None +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) p.scans = u.Param() diff --git a/templates/pars_few_alldoc.py b/templates/misc/pars_few_alldoc.py similarity index 100% rename from templates/pars_few_alldoc.py rename to templates/misc/pars_few_alldoc.py diff --git a/templates/minimal_prep_and_run_probe_modes.py b/templates/model/moonflower_blockfull.py similarity index 83% rename from templates/minimal_prep_and_run_probe_modes.py rename to templates/model/moonflower_blockfull.py index 8dbcb4dc4..e83cc2538 100644 --- a/templates/minimal_prep_and_run_probe_modes.py +++ b/templates/model/moonflower_blockfull.py @@ -3,25 +3,31 @@ of actual data. It uses the test Scan class `ptypy.core.data.MoonFlowerScan` to provide "data". """ - from ptypy.core import Ptycho from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + p = u.Param() # for verbose output -p.verbose_level = 3 +p.verbose_level = "info" # set home path p.io = u.Param() -p.io.home = "/tmp/ptypy/" -p.io.autosave = None +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) + +# Block size +p.frames_per_block = 20 # max 200 frames (128x128px) of diffraction data p.scans = u.Param() p.scans.MF = u.Param() # now you have to specify which ScanModel to use with scans.XX.name, # just as you have to give 'name' for engines and PtyScan subclasses. -p.scans.MF.name = 'Full' # or 'Full' +p.scans.MF.name = 'BlockFull' p.scans.MF.data= u.Param() p.scans.MF.data.name = 'MoonFlowerScan' p.scans.MF.data.shape = 128 @@ -34,9 +40,6 @@ p.scans.MF.data.photons = 1e8 # Gaussian FWHM of possible detector blurring p.scans.MF.data.psf = 0. -p.scans.MF.coherence=u.Param() -p.scans.MF.coherence.num_probe_modes = 2 - # attach a reconstrucion engine p.engines = u.Param() diff --git a/templates/model/moonflower_blockgradfull.py b/templates/model/moonflower_blockgradfull.py new file mode 100644 index 000000000..fe97d1c94 --- /dev/null +++ b/templates/model/moonflower_blockgradfull.py @@ -0,0 +1,64 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +#import ptypy +from ptypy.core import Ptycho +from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) + +# saving intermediate results +p.io.autosave = u.Param(active=False) + +# opens plotting GUI if interaction set to active) +p.io.autoplot = u.Param(active=True) +p.io.interaction = u.Param(active=True) + +# Block size +p.frames_per_block = 20 + +# max 100 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +p.scans.MF.name = 'BlockGradFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'ML' +p.engines.engine00.ML_type = 'Gaussian' +p.engines.engine00.reg_del2 = True # Whether to use a Gaussian prior (smoothing) regularizer +p.engines.engine00.reg_del2_amplitude = 1. # Amplitude of the Gaussian prior if used +p.engines.engine00.scale_precond = True +#p.engines.engine00.scale_probe_object = 1. +p.engines.engine00.smooth_gradient = 20. +p.engines.engine00.smooth_gradient_decay = 1/50. +p.engines.engine00.floating_intensities = False +p.engines.engine00.numiter = 300 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/minimal_prep_and_run_resample_DM.py b/templates/model/moonflower_blockvanilla.py similarity index 79% rename from templates/minimal_prep_and_run_resample_DM.py rename to templates/model/moonflower_blockvanilla.py index 08c12540c..346e3fcc3 100644 --- a/templates/minimal_prep_and_run_resample_DM.py +++ b/templates/model/moonflower_blockvanilla.py @@ -3,25 +3,31 @@ of actual data. It uses the test Scan class `ptypy.core.data.MoonFlowerScan` to provide "data". """ - from ptypy.core import Ptycho from ptypy import utils as u +import tempfile +tmpdir = tempfile.gettempdir() + p = u.Param() + # for verbose output -p.verbose_level = 3 +p.verbose_level = "info" # set home path p.io = u.Param() -p.io.home = "/tmp/ptypy/" -p.io.autosave = None +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) + +# Block size +p.frames_per_block = 20 # max 200 frames (128x128px) of diffraction data p.scans = u.Param() p.scans.MF = u.Param() # now you have to specify which ScanModel to use with scans.XX.name, # just as you have to give 'name' for engines and PtyScan subclasses. -p.scans.MF.name = 'Vanilla' # or 'Full' +p.scans.MF.name = 'BlockVanilla' p.scans.MF.data= u.Param() p.scans.MF.data.name = 'MoonFlowerScan' p.scans.MF.data.shape = 128 @@ -35,16 +41,11 @@ # Gaussian FWHM of possible detector blurring p.scans.MF.data.psf = 0. -# Resample by a factor of 2 -p.scans.MF.resample = 2 - # attach a reconstrucion engine p.engines = u.Param() p.engines.engine00 = u.Param() p.engines.engine00.name = 'DM' -p.engines.engine00.numiter = 100 -p.engines.engine00.probe_support = 0.05 +p.engines.engine00.numiter = 80 # prepare and run -P = Ptycho(p,level=4) -P.run() +P = Ptycho(p,level=5) diff --git a/templates/minimal_prep_and_run_blockmodel.py b/templates/model/moonflower_full.py similarity index 89% rename from templates/minimal_prep_and_run_blockmodel.py rename to templates/model/moonflower_full.py index beeaf7342..6347b243c 100644 --- a/templates/minimal_prep_and_run_blockmodel.py +++ b/templates/model/moonflower_full.py @@ -3,28 +3,28 @@ of actual data. It uses the test Scan class `ptypy.core.data.MoonFlowerScan` to provide "data". """ - from ptypy.core import Ptycho from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + p = u.Param() # for verbose output -p.verbose_level = 3 +p.verbose_level = "info" # set home path p.io = u.Param() -p.io.home = "/tmp/ptypy/" +p.io.home = "/".join([tmpdir, "ptypy"]) p.io.autosave = u.Param(active=False) -# Block size -p.frames_per_block = 20 - # max 200 frames (128x128px) of diffraction data p.scans = u.Param() p.scans.MF = u.Param() # now you have to specify which ScanModel to use with scans.XX.name, # just as you have to give 'name' for engines and PtyScan subclasses. -p.scans.MF.name = 'BlockVanilla' # or 'Full' +p.scans.MF.name = 'Full' p.scans.MF.data= u.Param() p.scans.MF.data.name = 'MoonFlowerScan' p.scans.MF.data.shape = 128 diff --git a/templates/minimal_prep_and_run_ML_Gaussian.py b/templates/model/moonflower_gradfull.py similarity index 79% rename from templates/minimal_prep_and_run_ML_Gaussian.py rename to templates/model/moonflower_gradfull.py index 28c9daa1c..641055a04 100644 --- a/templates/minimal_prep_and_run_ML_Gaussian.py +++ b/templates/model/moonflower_gradfull.py @@ -6,28 +6,34 @@ #import ptypy from ptypy.core import Ptycho from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + p = u.Param() # for verbose output -p.verbose_level = 4 +p.verbose_level = "info" # set home path p.io = u.Param() -p.io.home = "/tmp/ptypy/" -p.io.autosave = u.Param() -p.io.autosave.active = False -p.io.autoplot = u.Param() -p.io.autoplot.active = True -p.io.autoplot.dump = False +p.io.home = "/".join([tmpdir, "ptypy"]) + +# saving intermediate results +p.io.autosave = u.Param(active=False) + +# opens plotting GUI if interaction set to active) +p.io.autoplot = u.Param(active=True) +p.io.interaction = u.Param(active=True) # max 100 frames (128x128px) of diffraction data p.scans = u.Param() p.scans.MF = u.Param() -p.scans.MF.name = 'Full' +p.scans.MF.name = 'GradFull' p.scans.MF.data= u.Param() p.scans.MF.data.name = 'MoonFlowerScan' p.scans.MF.data.shape = 128 -p.scans.MF.data.num_frames = 100 +p.scans.MF.data.num_frames = 200 p.scans.MF.data.save = None # position distance in fraction of illumination frame diff --git a/templates/simulation_test_OPR_scanmodel.py b/templates/model/moonflower_independent_probes.py similarity index 91% rename from templates/simulation_test_OPR_scanmodel.py rename to templates/model/moonflower_independent_probes.py index f98e9f8ac..00df68ad9 100644 --- a/templates/simulation_test_OPR_scanmodel.py +++ b/templates/model/moonflower_independent_probes.py @@ -1,23 +1,23 @@ # A simulation template to test and demonstrate the "OPR" version of Difference map. # Note that it is better to use "ptypy.plotclient --layout minimal" otherwise 92 probes will be plotted. - from ptypy import utils as u from ptypy.core import Ptycho import numpy as np +from ptypy.custom import DMOPR, MLOPR +import tempfile +tmpdir = tempfile.gettempdir() p = u.Param() -p.verbose_level = 4 +p.verbose_level = "debug" p.data_type = "single" p.run = 'test_indep_probes' p.io = u.Param() -p.io.home = "/tmp/ptypy/" +p.io.home ="/".join([tmpdir, "ptypy"]) p.io.autosave = u.Param() p.io.autosave.interval = 200 -p.io.autoplot = u.Param() -p.io.autoplot.active = False -p.io.interaction = u.Param() -p.io.interaction.active = True +p.io.autoplot = u.Param(active=True) +p.io.interaction = u.Param(active=True) p.scans = u.Param() p.scans.MF = u.Param() diff --git a/templates/minimal_prep_and_run_probe_from_array.py b/templates/model/moonflower_probe_from_array.py similarity index 87% rename from templates/minimal_prep_and_run_probe_from_array.py rename to templates/model/moonflower_probe_from_array.py index b089bc443..6895c4b60 100644 --- a/templates/minimal_prep_and_run_probe_from_array.py +++ b/templates/model/moonflower_probe_from_array.py @@ -3,27 +3,29 @@ of actual data. It uses the test Scan class `ptypy.core.data.MoonFlowerScan` to provide "data". """ - from ptypy.core import Ptycho from ptypy import utils as u import numpy as np +import tempfile +tmpdir = tempfile.gettempdir() + p = u.Param() # for verbose output -p.verbose_level = 3 +p.verbose_level = "info" # set home path p.io = u.Param() -p.io.home = "/tmp/ptypy/" -p.io.autosave = None +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) # max 200 frames (128x128px) of diffraction data p.scans = u.Param() p.scans.MF = u.Param() # now you have to specify which ScanModel to use with scans.XX.name, # just as you have to give 'name' for engines and PtyScan subclasses. -p.scans.MF.name = 'Full' # or 'Full' +p.scans.MF.name = 'BlockFull' p.scans.MF.data= u.Param() p.scans.MF.data.name = 'MoonFlowerScan' p.scans.MF.data.shape = 256 @@ -39,8 +41,6 @@ # Gaussian FWHM of possible detector blurring p.scans.MF.data.psf = 0. - - # attach a reconstrucion engine p.engines = u.Param() p.engines.engine00 = u.Param() diff --git a/templates/model/moonflower_probe_modes.py b/templates/model/moonflower_probe_modes.py new file mode 100644 index 000000000..c526c96b8 --- /dev/null +++ b/templates/model/moonflower_probe_modes.py @@ -0,0 +1,54 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.interaction = u.Param(active=True) +p.io.interaction.client = u.Param() +p.io.interaction.client.poll_timeout = 1 + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0.2 +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence=u.Param() +p.scans.MF.coherence.num_probe_modes = 2 + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM' +p.engines.engine00.numiter = 80 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/templates/model/moonflower_resample.py b/templates/model/moonflower_resample.py new file mode 100644 index 000000000..5c6567ff7 --- /dev/null +++ b/templates/model/moonflower_resample.py @@ -0,0 +1,62 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockVanilla' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# Resample by a factor of 2 +p.scans.MF.resample = 2 + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM' +p.engines.engine00.numiter = 100 +p.engines.engine00.probe_center_tol = 2 +#p.engines.engine00.probe_support = 0.05 + +p.engines.engine01 = u.Param() +p.engines.engine01.name = 'ML' +p.engines.engine01.reg_del2 = False +p.engines.engine01.reg_del2_amplitude = 0.1 +p.engines.engine01.scale_precond = False +p.engines.engine01.scale_probe_object = 1. +p.engines.engine01.floating_intensities = False +p.engines.engine01.numiter = 100 +p.engines.engine01.probe_update_start = 0 + +# prepare and run +P = Ptycho(p,level=5) \ No newline at end of file diff --git a/templates/minimal_prep_and_run.py b/templates/model/moonflower_vanilla.py similarity index 89% rename from templates/minimal_prep_and_run.py rename to templates/model/moonflower_vanilla.py index 470ffd011..88c70b586 100644 --- a/templates/minimal_prep_and_run.py +++ b/templates/model/moonflower_vanilla.py @@ -3,17 +3,20 @@ of actual data. It uses the test Scan class `ptypy.core.data.MoonFlowerScan` to provide "data". """ - from ptypy.core import Ptycho from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + p = u.Param() # for verbose output -p.verbose_level = 3 +p.verbose_level = "info" # set home path p.io = u.Param() -p.io.home = "/tmp/ptypy/" +p.io.home = "/".join([tmpdir, "ptypy"]) p.io.autosave = u.Param(active=False) # max 200 frames (128x128px) of diffraction data @@ -21,7 +24,7 @@ p.scans.MF = u.Param() # now you have to specify which ScanModel to use with scans.XX.name, # just as you have to give 'name' for engines and PtyScan subclasses. -p.scans.MF.name = 'Vanilla' # or 'Full' +p.scans.MF.name = 'Vanilla' p.scans.MF.data= u.Param() p.scans.MF.data.name = 'MoonFlowerScan' p.scans.MF.data.shape = 128 diff --git a/templates/notebooks/moonflower_dm.ipynb b/templates/notebooks/moonflower_dm.ipynb new file mode 100644 index 000000000..85341b9b2 --- /dev/null +++ b/templates/notebooks/moonflower_dm.ipynb @@ -0,0 +1,195 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PtyPy moonflower example\n", + "#### scan model: BlockFull\n", + "#### engine: Difference Map (DM)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from ptypy.core import Ptycho\n", + "from ptypy import utils as u" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# create parameter tree\n", + "p = u.Param()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# set verbose level to interactive\n", + "p.verbose_level = \"interactive\"" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# set home path and io settings (no files saved)\n", + "p.io = u.Param()\n", + "p.io.rfile = None\n", + "p.io.autosave = u.Param(active=False)\n", + "p.io.autoplot = u.Param(active=False)\n", + "p.io.interaction = u.Param(active=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# max 200 frames (128x128px) of diffraction data\n", + "p.scans = u.Param()\n", + "p.scans.MF = u.Param()\n", + "p.scans.MF.name = 'BlockFull'\n", + "p.scans.MF.data= u.Param()\n", + "p.scans.MF.data.name = 'MoonFlowerScan'\n", + "p.scans.MF.data.shape = 128\n", + "p.scans.MF.data.num_frames = 200\n", + "p.scans.MF.data.save = None\n", + "p.scans.MF.data.density = 0.2\n", + "p.scans.MF.data.photons = 1e8\n", + "p.scans.MF.data.psf = 0." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# difference map reconstrucion engine\n", + "p.engines = u.Param()\n", + "p.engines.engine00 = u.Param()\n", + "p.engines.engine00.name = 'DM'\n", + "p.engines.engine00.numiter = 80" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BlockFull: loading data for scan MF (161 diffraction frames, 161 PODs, 1 probe(s) and 1 object(s))\n", + "BlockFull: loading data for scan MF (reformatting probe/obj/exit)\n", + "BlockFull: loading data for scan MF (initializing probe/obj/exit)\n", + "DM: initializing engine\n", + "DM: preparing engine\n", + "DM: Iteration # 80/80 :: Fourier 5.32e+01, Photons 1.55e+01, Exit 4.71e+00\n", + "==== This reconstruction relied on the following work ==========================\n", + "The Ptypy framework:\n", + " Enders B. and Thibault P., \"A computational framework for ptychographic reconstructions\" Proc. Royal Soc. A 472 (2016) 20160640, doi: 10.1098/rspa.2016.0640.\n", + "The difference map reconstruction algorithm:\n", + " Thibault et al., \"Probe retrieval in ptychographic coherent diffractive imaging\" Ultramicroscopy 109 (2009) 338, doi: 10.1016/j.ultramic.2008.12.011.\n", + "================================================================================\n" + ] + } + ], + "source": [ + "# prepare and run\n", + "P = Ptycho(p,level=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting the results" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "

      " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "obj = P.obj.S['SMFG00'].data[0]\n", + "prb = P.probe.S['SMFG00'].data[:]\n", + "likelihood_error = [P.runtime[\"iter_info\"][i]['error'][1] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "iterations = [P.runtime[\"iter_info\"][i]['iterations'] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "fig, axes = plt.subplots(ncols=4, nrows=1, figsize=(18,4), dpi=60)\n", + "axes[0].set_title(\"Object amplitude\")\n", + "axes[0].axis('off')\n", + "axes[0].imshow(np.abs(obj)[100:-100,100:-100], cmap='gray', vmin=None, vmax=None, interpolation='none')\n", + "axes[1].set_title(\"Object phase\")\n", + "axes[1].axis('off')\n", + "axes[1].imshow(np.angle(obj)[100:-100,100:-100], vmin=-np.pi, vmax=np.pi, cmap='viridis', interpolation='none')\n", + "axes[2].set_title(\"Probe\")\n", + "axes[2].axis('off')\n", + "axes[2] = u.PtyAxis(axes[2], channel='c')\n", + "axes[2].set_data(prb[0])\n", + "axes[3].set_title(\"Convergence\")\n", + "axes[3].plot(iterations, likelihood_error)\n", + "axes[3].set_xlabel(\"Iteration\")\n", + "axes[3].set_ylabel(\"Log-likelihood error\")\n", + "axes[3].yaxis.set_label_position('right')\n", + "axes[3].tick_params(left=0, right=1, labelleft=0, labelright=1)\n", + "plt.show()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "94f4d5375db2f655aeda185c89beeef42bb9cecdb7e33c656c383e802f18953c" + }, + "kernelspec": { + "display_name": "Python 3.9.6 64-bit ('cuda11.2': conda)", + "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.9.6" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/templates/notebooks/moonflower_dm_pycuda.ipynb b/templates/notebooks/moonflower_dm_pycuda.ipynb new file mode 100644 index 000000000..db0a1094a --- /dev/null +++ b/templates/notebooks/moonflower_dm_pycuda.ipynb @@ -0,0 +1,218 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PtyPy moonflower example\n", + "#### scan model: BlockFull\n", + "#### engine: Difference Map (DM) with GPU acceleration" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import ptypy\n", + "from ptypy.core import Ptycho\n", + "from ptypy import utils as u" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Import pycuda engines (DM, RAAR)\n", + "ptypy.load_gpu_engines(\"cuda\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# create parameter tree\n", + "p = u.Param()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# set verbose level to interactive\n", + "p.verbose_level = \"interactive\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Nr. of frames in a block\n", + "p.frames_per_block = 20" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# set home path and io settings (no files saved)\n", + "p.io = u.Param()\n", + "p.io.rfile = None\n", + "p.io.autosave = u.Param(active=False)\n", + "p.io.autoplot = u.Param(active=False)\n", + "p.io.interaction = u.Param(active=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# max 200 frames (128x128px) of diffraction data\n", + "p.scans = u.Param()\n", + "p.scans.MF = u.Param()\n", + "p.scans.MF.name = 'BlockFull'\n", + "p.scans.MF.data= u.Param()\n", + "p.scans.MF.data.name = 'MoonFlowerScan'\n", + "p.scans.MF.data.shape = 128\n", + "p.scans.MF.data.num_frames = 200\n", + "p.scans.MF.data.save = None\n", + "p.scans.MF.data.density = 0.2\n", + "p.scans.MF.data.photons = 1e8\n", + "p.scans.MF.data.psf = 0." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# difference map reconstrucion engine\n", + "p.engines = u.Param()\n", + "p.engines.engine00 = u.Param()\n", + "p.engines.engine00.name = 'DM_pycuda'\n", + "p.engines.engine00.numiter = 80\n", + "p.engines.engine00.numiter_contiguous = 10\n", + "p.engines.engine00.probe_update_start = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BlockFull: loading data for scan MF (161 diffraction frames, 161 PODs, 1 probe(s) and 1 object(s))\n", + "BlockFull: loading data for scan MF (reformatting probe/obj/exit)\n", + "BlockFull: loading data for scan MF (initializing probe/obj/exit)\n", + "DM_pycuda: initializing engine\n", + "DM_pycuda: preparing engine\n", + "DM_pycuda: Iteration # 80/80 :: Fourier 5.29e+01, Photons 1.58e+01, Exit 4.87e+00\n", + "==== This reconstruction relied on the following work ==========================\n", + "The Ptypy framework:\n", + " Enders B. and Thibault P., \"A computational framework for ptychographic reconstructions\" Proc. Royal Soc. A 472 (2016) 20160640, doi: 10.1098/rspa.2016.0640.\n", + "The difference map reconstruction algorithm:\n", + " Thibault et al., \"Probe retrieval in ptychographic coherent diffractive imaging\" Ultramicroscopy 109 (2009) 338, doi: 10.1016/j.ultramic.2008.12.011.\n", + "================================================================================\n" + ] + } + ], + "source": [ + "# prepare and run\n", + "P = Ptycho(p,level=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting the results" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABb4AAAGBCAYAAACpeKcTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9ebxl2VnfB3+ftfc+8zl3rrm6W7MQo4VkA44xYLAwGAyOjTE4MbxOTHBeYuzwYuMh4DiOncTYOCEYbBOE7RCMGWIQIs0ogiVAoAGk1thSV3fNdcczn7On9f6x9rPOPreqW9UgqaSu9avP/dy6++xh7b3X2ffc3/qt7yPWWoKCgoKCgoKCgoKCgoKCgoKCgoKCgoJeKDIPugFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBH00F4zsoKCgoKCgoKCgoKCgoKCgoKCgoKOgFpWB8BwUFBQUFBQUFBQUFBQUFBQUFBQUFvaAUjO+goKCgoKCgoKCgoKCgoKCgoKCgoKAXlILxHRQUFBQUFBQUFBQUFBQUFBQUFBQU9IJSML6DgoKCgoKCgoKCgoKCgoKCgoKCgoJeUArGd1BQUFBQUFBQUFBQUFBQUFBQUFBQ0AtKwfgOCgoKCgoKCgoKCgoKCgoKCgoKCgp6QSkY30FBQUFBQUFBQUFBQUFBQUFBQUFBQS8oBeP74ywR+RwR+fciclNEUhG5JSI/LiKfe491v0tErIjs3sd+3yQib/qYNNrt/+tE5Fs/Vvv/eEhEXi8iV04tuyIir6/9fKG67p/1MTj+Y9X9/IaP9r6DgoI+MRWe+Xft9wuqc/wzH+19BwUFBX0ySkS+oXou6lcuItdE5IdE5OJH8ThWRL73o7W/oKCgoAcpEfmM6jn5lIgsRGQiIm8XkW8Xke0H3b6goKBPHAXj++MoEfkW4M3AJeDbgS8Gvg24CPxHEfn//j52/1eqr4+Vvg741o/h/h+Uvhr4+7WfLwDfCXzWA2lNUFDQC0bhmR8UFBQU9Dz0jcDnAl8C/EvgzwO/JiLdB9qqoKCgoE8wich/CbwNeC3wvwBfivu7/t8D/xXwgw+udUFBQZ9oih90Ax4WicgfBr4HeCPw1dbavPbajwI/BfwzEXmHtfbNz3f/1tr3fLTa+jDJWvuOB92GoKCgF57CMz8oKCgo6Hnq3dba367+/ysiEgF/F/gq4P88vbKIdKy1s49j+4KCgoIeuKpZk/8c+AXgq6y1y9rLvyAi340zwj8pVT3741PnFRQU9PtQSHx//PQdgAW+uW6AAFQ//5Xq9b95j20vi8hPishIRIYi8m9FZK++wr2mvYtIQ0T+joi8T0SWIrJfTQda27Za9+tE5NerKUITEXmniPwl3Tfw5cCj9amYz3WyIvLnROTnq+n9cxF5r4j8o9OplQo/MhGRV4rI4yIyrbb5m9XrnyMi/7Fa/gER+YunttfpoV9SndtRte7PiMiLn6uN1fYedSIiXwD8VvXSD9XO9bue7RrXzuHKqWUXROTHRGRc3bN/B5x7lja8RkR+umr7QkTeISJf85HaHhQU9Amth+2Zf0VE3iAiXy0iv1s9yz4sIv/Ns2ySiMg/EJEb1Xn+ooi84tQ+v0RE/oO4Kf8LEXlSRH5ATqFgRGRPRP6FiFytnfebReSLT633xSLyS9XxZtU6f+y5zisoKCjoAeo3qu+P1j4vf3r1+XoM/BKAiGyLyPeJyHVxSK0PV8/X5r12KiLfVH2mXorIe0Tka++xzrnqeXut2udTIvKdIhJCU0FBQQ9afwv3Gfov38scttam1tqfBhARIw59op+N74jIvxaRS/Vtqs/V7xaR14rIr1WfEz8sIn9TREy1zl71PPz7p48pzsuw9c+99/MclRUK9durz/BPAUvgC6vX/1T1uXpZteevSoVGPHV8EZG/Un2en4vIsTi04otPrfcRz7O27qaIfHf1ul67N4rIK2vr3PffHkFBD1Lhw8vHQeJG7b4Q+G1r7bV7rWOtvSoibwO+SEQia21Re/mngB8Dvh/4VBya41Ui8oestdmzHNMA/wH4I8D/DLwFeBT4e8CbROQ11tp5te5/j0uU/CTw3cAQ+LRqfXAGzb8AXoKbQnQ/ehku6fg9wBR4JfA3gD8IfNGpdZPq2N+Pm6r0dcA/FJEB8J8C/xNwDfgW4PUi8m5r7dtO7eMHcaO+XwdcBv6H6jw/w1p7cp9tfjtumukPVdv/bLX8nvfs2SQibeAXcdiU7wA+gDOR/t091v1C4P8BfhM3LWsIfC3w78QleV7/fI4dFBT04PWQPvPBIaK+B/gu4Bbw9bhUe8Na+49Prfs/4jAw/wUwwD3nf0ZEPqV2LV4C/Drwr6o2Pgb8dRwm5tNr1+LfAK8G/jbuebtZ/bxTuz5/AfjX1TX6i0AGfBPwuIi8zlr7S8/jPIOCgoI+Hnpp9X0feDnQAH4a+AHgHwGxiLSAX8E9L78T+F3c74HvwD2Tv/zUPr8S9/vpv8N9Pv8rwP8lIrm19sfBmTXAW4ES+O+BD+EQLH8H9xz+xo/6mQYFBQXdh6rP2F8EvM1ae/U+NvnnwF8Gvhd4A+4Z9veBLxCRV1trD2rrnsPNrvlu3Ofnrwb+IXAD+NfW2n0ReQPwF0XkO621ZW3bbwTSavvfy3P0v8F9hv02YAR8UES+FPdZ/f8F/hzOu/s24Ow9zvMHgG8A/lec57KNe86/RUQ+01p7+37Ps2p/H/iPVVv/J5xX0QM+HzgPvO/5/O0RFPTAZa0NXx/jL9zDyQL/10dY70er9c5UP39X9fM/ObXe11XLv7627E3Am2o/f221zp8+te1rWKUQAV4E5MC//QhtewNw5fd4/oJ7UH9+dezPqL32+tPtrNa9Uy3/A7Xl21Vbv7u27Buq9X7y1DE/r1r+t08d68qp9a4Ar7/H9fmGe5zH2jV+tv3iDGwLfOWp9f7F6X0D78UZ7vGpdX8G98vHPOj+G77CV/h6fl8P4zO/epaWwGeeWv7zONO6U/38BVV7fvbUen+2Wv45z7J//T3yyOnnKzAG/ulztK0DHAI/fWq5Ad4J/OaD7jPhK3yFr4f3q/ZZ9g9Vz7kezrC+gzNAzrL6vPyNp7b9pmr5nz21/Nur5V9SW2aBGXC2tiyqPot+sLbs+6vn6iOn9vnfVvt41YO+ZuErfIWvh/Prfj9jV+u+slr3fz+1/A9Wy/9BbdmbqmV/8NS6TwD/T+3nr7jHszUCrgM/Xlt2X89RnLFsgSeB5NS6bwWeARq1ZT3gALC1ZZ9T7eOvn9r+UvXM/59+D+f5d6v1vvg5ru99/e0RvsLXJ8JXQJ18Ykmq76enlJ/m+v0Yzrj4wufY158ETnAJuli/cH/k38KZD+AK6ETA//57bvU9JCIvFpEfEZFbQIFL1/1q9fKnnFrd4tLh7geHAXgSuGlrDG5r7RHuj4BHuVtr18ha+xbgaZ77Gn2s9IXA2FZTrGr6kfoPIvJS3C9kHRmu36c34kZTX0FQUNALVS+YZ36lJ6y1v3Nq2Y/gEt2vPrX89PPxd6vv/vkuImdE5PtF5Cru/DPccx3Wf4+8FfiGaqrl54hIcmrfn4cbOP3hU9fG4GbcvFZC8bigoKAHr9/APefGuMHHW8CfsOtJvZ84tc0X4ZLbP35q+eur76dxTr9U3591M2z+HfBSWU39/5O4FPmNU8/Mn6te/6PP98SCgoKCHoD0c/Pr6wuttW/FDfidfj7eql6r63dZ9x5+Dvdsrie2X4eb6f1/1JY93+foT9varM7qc+lrgP/bWpvW2j7BBeTq+pO4vyX+7alj3QJ+h9XfAM/nPP8E8AFr7S/y7Lrfvz2Cgh64Aurk46MD3Gjbiz7Ceo9V6x2dWn6r/oO1NheRQ2rTuO+hs7jp3umzvK6MVOUvPS+cx3NJRHrArwEL3HSeD+DO6zJuuk771CYza+3i1LKUu6+DLm/dY/mtZ1n2XNfoY6Ud4PY9lp9uo05T+sfV1720+yzLg4KCPnH1UD3za3q25zDc3fbDUz8ro7ENHt3y87g/JP4+8C6cuWNw5lD998ifw/2u+S+qdSci8lPAt1trb7F61p42hurarvYfFBQU9KD0n+PMmBy4ba29eer1mbV2dGrZDs7EWBtAtdbeEZGcu5+9H+k5fQ33zPwKnAl/L4XPpkFBQQ9K9/sZG1bPv9PPUnAzq0+H6U5/NgX3+dR/5qw+k/8b4FtEZNM6pOo3VMd4vLbd832Onm7jFi4gcy9P4fSys8+xLsCHT/38Ec8T9/fCM8+yv/pxN/nIf3sEBT1wBeP74yBrbSEivwJ8qYhcsvdgvlYpi88Gfs6us17BcZiu19aNcQ/yez20VAfV689W0Xhcfd+vvl8C7oeTdT/6IpxZ8QXWWk15IyKbH6X930v3Khx5Dpcc/2hpAWzcY/nph/ohbgrVvdpTlzLF/iFuQOBeev99ty4oKOgTQg/hM1/1bM9heO6230ufBnwmDg31w7qwmimzJuv4jN8KfKuIPIJj2P4j4Azueuiz9ltYFYs7rWf7YyEoKCjo46X3Wmt/+zlePz07CNyz9Q+JiNTNbxE5g/s77+DU+vfznD7Apf/+9rO048ZztDEoKCjoY6bqM/YvAX/i2T5j16TPtPPcHfi4wN3Px/vVDwH/P+BrReTf4T53fs+pz/PP9zl6+vl+XC27F8/7Xp6CxbG27yr2+SzLPpL2cX8rPJfu92+PoKAHrmB8f/z0D3FTRr5PRL66/mCsijT8c9xI3T+8x7ZfD9SLOX4N7t696TmO9wYcdymy1v7mc6z38zgUyTfjiog9m06PAj6X9MF9+iH7Tfe5/e9FX09t+qeIfB5uFPdfPc/9rKUOT+kK8GdFpGmrCtIisoObRl9P4PwK8DUi8pWncCdfV9+Ztfb9IvJBHBP3bz3PdgYFBX1i62F65qs+tSqgU8edfB3ug+/bn+e+fk+/R6y1zwDfKyJ/DPjD1eI346Zivspa+73Psx1BQUFBn8j6JdzviK/CFUZW/ee11+v6YyJyVnEn1e+jPwd8qGYgvQH4smrZ8ceq4UFBQUG/R/1D3DPqX4rIn6qjQAAq5N2XAr9cLfoLwG/VXn8tDpn3D34vB7fWvldEfhOHO4mAJs4Mr+v39Ry11k5F5LeBrxKRb9NzrGbW/8l7HOtvAhettT/2fI/1LPo54L8XkS+y1v7ys6xzv397BAU9cAXj++Mka+2bReRbge8B/qOIfC9u+sgjwH+NK2jzrRWb+rT+dDVd8ReAT8VN5f4dHPf12fSjOPPkjSLyz3AM1Aw3cveFwH+w1v6UtfaKiPyPwN8VkTbwf+EKkb0K2LXWfme1v3dV7fhmnCFTPkcq5S24UcrvF5G/Vx3363HpvY+VXiMi/wr49zikyj/AJSa/73nu50PAHPh6EXkvMAFuWGtvAP8GZ7r8WxH5l7gE5rezbnqDq4b814B/LSJ/G/gg7hff6+5xvG8Cfk5EHsfxx67jptx/CvBqa+2ffZ7tDwoK+gTQQ/bMV90AflpEvgs3ZfMv4Jjif8NaO/sI257W+3DP438kIoLDwXxFtT8vEdnADTb+SLXNGHgt7g+enwTHQxSRb8ExvrdxyJM7uGmcnwnsWWu/+Xm2LygoKOgTQf8a9zvlh0XkMdyz+z8B/hbwxnvwWQ+AXxaRv4/DO/0VXL2Zr62t89/hnrVvEZH/FTf7sIXDc30Z8F99hJRlUFBQ0MdM1tpfrz6ffh/wNhH557jijAnwB4C/DLzbWvvVIvIvcFiSEmfmPob7XH0V+Ke/j2b8H8AP4JLjb7HWnp6l/dF4jv53wM8Cj1ef7SNc0nyC8wsA/zfHvwB+SEReA/y/uOf7edzvg3dZa//58zy/78ENiv4HEflHuL8r2jg2+Rustb/Cff7t8TyPGxT0sdGDrq75sH3hqu7+exxPL8NNr/4J4HPvse534VJvr8YVAhvjTNYfAc6cWvdNwK+cWhbjKge/E2fmjnHswO8HXnpq3f8M97DS9d6Om2Kur29V7T4GSmqVhJ/lPD8XZ4BPcQbDv8T9IrKn9vt6YHKP7d+E+4V1evkV3MNWf/6Gap9fgvvwf4zjfv3sPc7x9cCVe+zv9aeWfW11ndJq399Ve+0/B95TXacncCmbe+33Is5c0Xv249U1WTv/at3PwBUWul0d8yYuofNND7q/hq/wFb5+f18P0TP/Ci758Z8C78YltZ8C/tqp9b6gOsc/c2r5Y/f4/fApuIT6CGd8/xhuYNM/l3Epm3+OGxgYVs//91XXsnPqGJ9ftfGwetZeq37+M891buErfIWv8PWx/GL1WfY1z7HO67nH5+Xqte3qOXij+j1zBfgfgeap9SzwvbgZP09Wz8H3Al93j33uAv8Mx4ZNq+fmbwP/A9B90NcsfIWv8BW+cOGF1+MKny9xhvDbgb+HCzWAqw3z7TjjOcUhPP4NcOnUvt7Evb2H13Pq7/xq+aD6zGmB/+JZ2vcRn6O1z7/f9iz7+CocMmVZneffqPZ5dI91vxGH9JtUbXsS+GHgs38v54njd39PddwU9zfMG4BX1Na57789wlf4epBfYu29cHFBn2wSkXfgptL8mQfdlo+nROQbcFOLXms/choxKCgo6AWhT7RnvohcwX2QPj39MigoKCgoKCgoKCjo96kK4/JO4Lq19o8/4OYEBX3SKKBOPsklIi/HFTL4dODfPuDmBAUFBQV9DBWe+UFBQUFBQUFBQUEvfInID+LQhzdxRS3/K9yMyL/6INsVFPTJpmB8f/LrO3Dc03/N8+dZBwUFBQV9cik884OCgoKCgoKCgoJe+OoD/xhXlybDoVy+zN5dvyEoKOg5FFAnQUFBQUFBQUFBQUFBQUFBQUFBQUFBLyiZB92AoKCgoKCgoKCgoKCgoKCgoKCgoKCgoI+mgvEdFBQUFBQUFBQUFBQUFBQUFBQUFBT0glIwvoOCgoKCgoKCgoKCgoKCgoKCgoKCgl5QCsUtg4KCgoKCgoKCgoKCgoKCgk5JRAS4AIwfdFuCgoKCnqf6wA37kBd3vG/j+y1veYttNBr0+32uX7/ObDajKAoajQZJkrBYLGi325RlyWAwAOD4+JjlcglAlmWcnJyQpim9Xo8kSQBotVoURcHm5iZxHCMipGlKFEXMZjOm0ynNZpNerwdAURSMRiOKomB/f580TSmKgvPnz9PpdAD40Ic+RLPZBMBa69sxGAxotVp+e12vKAp6vR7dbpeNjQ1arRabm5skScLR0RHHx8dkWcZwOGQ0GtHr9Xj00Ud59NFHybLMn3ez2cQYQ5Zl/rotFgvKssQYw82bN4njmKOjI7/ucDgkTVO63S5JktDr9SiKgrIsGY1GWGu5efMmR0dHzOdzrl27RqvV4lM+5VPodDpcunSJnZ0dzpw5489/Pp+TpikXLlzw+1wsFgyHQ4bDIY1Gg/l8TqvV4vDwkGazSRzHGGNI05SNjQ263S7b29vcuXOHXq+3du8eeeQRlsslV69eZW9vD2PcxIHpdEqWZYgIrVaLJEnY3t5muVySJAllWbJcLomiiI2NDabTKcPhkGazSZIktFotGo0GIsLJyQmz2YytrS0WiwUnJyc0m02yLOPJJ5/kypUruM8gcPv2bd7xjncQxzHvfOc7mU6ntNttsiwjz3NEBBEhjlfdvdfrYa0liqK1fr5cLimKwre31+shIr4/ZFnGZDIBQERYLBYsl0s6nQ6z2Ywsy5jP51hrSZJk7Vo0Gg2azSaTycS3q9ls0m63/XplWbJYLEiShK2tLYwxNJtNptMpZVnS7/cB6HQ6NBoNiqIgyzKyLPPvSd1vp9MhTVPm8zntdpvhcEir1eLChQucnJywWCzodrvs7+9jraXdbjOZTNjY2KDX69Hv94miiDNnznDmzBkAJpMJSZKwXC557LHH2NnZ4ejoiK2tLd+vzp49S5ZlLBYLRITz589jraXVaq31Bb2f7XYbgK2tLYbDIXEcM5/PWS6X/h4bY8jznK2tLf8sARgMBv5+dzodRqMRBwcHDAYDyrLkNa95jdzvM+6FpBf/k++2NgYbWaiugDUWyd0PkgsmE/daiftuwerbwVisAZtYrHH7kFIgFxCLFOL3C2Cr/5vq0Sfl6sUytmCgbJZgLJIbyAUpQUooY0Cq38PVHCSblFCIa6+AjS1oO1KDbZSgv7oFiK07D53DVMjq56h6DaAUKMW1v8BfD6omWANSuPZLdQgp3bJ4JiRTaAwtprBI4baLMouUYFKLjdz6RcO1O1pYuh8+QeZLsBaWKTbLKMcTKKodiMEWBWLEfY8iJI6hen7oMpvnEEVQlr7NFAUYAyJ3LbNFAaW7SDbPQAzY0n0HKAu3nbU8fuOdFLYkktUksPrPr7vwWW5d3Qfw+PV3UNiSL7v4aiRpYPOMN1z7bRKJ+BMv/Tx/fEli1249X8BmOdgSiWP+yft+mb/24T/LB564xBe+9gme/o6XkxzNWZ7tEk8ybvyRLtEC8g6UCUQp7mf32KB5bJmfERpjyFsQz10/juYg1rp7gdveFGBSt23es5hMyHolO78rtI4L9j8zxmRVP7AgOdjY9e+y6Y5bRut9xcauD5vMfZWx63fWuLaA2wYgWkJj7NqUt9220XJ1HCyY3B3P5BYr4t+TUrj95i3Xx/T9Fs/dPU6mluawoDHMiMYL9/p4jh2NsfMF5XzOT139TYZlCsDYCgsb0ZKCllgyC+Myoaje2FPboCUZDUo6JgfgVtHlarbDtGwyKVp0zJJzyZAL8TFdyTHVmzISy6x0v29HtsmiTJhZ95kskZyEghJD38yJsPRNSksKXnb55kP5vBaRh/oPkaCgoE9OWWsfpmf2BeDag25EUFBQ0O9Rl4DrD7oRD1L3bXyreRvHMXmeY4whiiJvEm5sbCAiJEniTdVWq+VN0WazSZ67P54WiwWj0QhwxnSj0SCKIm/wNRoNdECi1WrRbDbZ2Njw26ZpymKxII5jZrMZjUaDOI4Zj8c0Gg3SNGVzcxOA4XCItdab3mq0Hx0dsbGxQVmWFEXhDVA9rziOaTQa/hyKoiDPc/b29mi1WkRRRJZlWGvpdDoUReG/0tT9YZmmqTcA1YwGvFFeFAX9fp8kSbyBOZ/PiaKI+XxOWZYcHh76665G8mAwoN/vc/nyZW9udzodhsOhv2az2YzDw0P6/T7T6dQbh9q+RqOxZhAvFgsuXLgAQJIk7O3teSNUTdFOp4O1ljzPGY1Gvr3dbhdwZvJ4PPZG72Kx4OjoyF9HPW5RFMxmM6IowlrLdDrlwoULdLtd0jQlTVP29vZI09Qfq9PpMJ/P6ff7bG1trV3PGzdueJO4boC2222Wy6Vvc1EUGGMwxjCdTonj2N8HNaoBut0uy+WSVqvlTfOiKPwgjhrf1lqWy6XfdxRFfuBCDfRut+v7koj4/qhmdJqmxHHsv8bjMcvlEmMMJycnNBoNZrMZeZ6T57k/dqvVotfrkef5mqEfxzGDwQBjDK1Wyw/ClGXJ9vY2o9GID3zgA3S7XabTKYvFAmOMv7cABwcHgBsE6Ha79Pt9rly54t9/OjDyoQ99iJOTE/r9Ppubm/T7ffb395lMJnS7XQaDAc1m05vc+h7XZ4iI0Ol0SJKENE0Zj8d+ME3v++7uLuAGzvQ8syyj1WqxsbHBcrkkjmPfv9I0pdPprD17HkZZ44xu9wPOMLZqdLu/U8rEGbaIcJftUgpiqw0jZ4C7/Tjz2VaXVtQ0r3ZgI/GmnP45JLbySut/HhkLpWClet2/6PYjuVkZ8pXprudjY+vPwTe85gVjcWZ3xMoAr84JizO9y8qcr5v3xm1rY7Cl9eamScWZjgJFA9IN8SanyaFoih80MJlbzwqUDWdWNoZdolmC5CXmqESMQZYptnp+SaMBiyUYcc2pmc+Y+sXW0QU1rktIEvfdGMgy911Nbz0vNc5Ly+PX30FmV68lEjlTG4jE8LqLfwCs5Y3X3w5AZgsMwuM33uleq+l1Fz6LN15/Oz99/bf4youv5fEb7wSq/YlzfN947W182eXXgi356WtvBaCwlqXN+drLn8ePX/mPfPrP/lX+zGt/myvHj/B1e7/Od9++gH36Omb7FYxe3K4GPiDvWIqOxRwY0g33czIR8o5gY0vW1X69MqSLRJhdcB2gcWQoDEwvFbTuREQzoWxamkeGZFowejRGCmdc672MCigimD2aEw8jQCgjiynED3yoSW5jIMcPIknpu7N7P8argR4bORPelm5wxKRQtGqdUcAaqd63ILmlaLp+Fy9W/dzk1vfNMhasEcqGwTTd7zKOxm7woyx5/Po7mJUQibCwzpguEBJKFsCsjEkxlNZgpCSipLSGVKjcfMhsREsyIrN6wxXWMC5bZJKRVBclspaFjVc/S0lRmqrPQUMKjGR0JSORsvoiKCgoKCjoE1VjgKtXr/qAX1BQUNAnukajEZcvX4YwW+X+jW9rrTciO50OURRxcHBAo9EAXNpXDSw1CI0x/pfDYrHgzJkzLJdLyrIkjmMmk4k3yfM8Z7FYeONLRLxJqcYWrEwvNSz39vZ8slfN4d3dXZ9+TtPUp2b1/yLik8nNZtObZ0VlFmjKVI20KIq8Odjr9Wg0Gmxvb3vzW81dTUxPp1Pf1tls5k1QYwybm5s+Ndzv970BaK3l+vXrJElCu93GWkscx+zt7fkUbRRF7O/vs7OzQ7vdZnNzkzzPiaLIm6SwSnxPp1NvLur9M8ZgraWsUoNRFLFYLNje3mY+n7O9ve2TzWmaMhqNODk58QMbcRyTZRnHx8fEcewHJMANbqiR2mq1vEkbxzGLxYLd3V0ODg68mSwi5Hnuj6P9SkRYLpccHx8zGAzodDrcvn2b5XLJ5uYmvV6Pra0tbty44Y+7s7PD1atXGY/HvPKVr+TOnTv+ntZndWif0lR9WZZ+oEW/5vO57yd5nrOxseFT1cvl0pvJ+nq73WY8HtPtdr3ZOhgM1sz02WxGWZaIiO9PasprG3WAIo5joihiOp36gR01kXXwSGcEJElCnud+BoEOpLRaLebzOXt7e0ynUz/AVL8eapJre3q9HlmW0ev1MMZw69YtTk5O/HtedXR05NPnZ86cod1uMxqNiKKIwWBAo9GgLEuSJMEY401+TX0vFs65yfPcm9xZljGdTr053m63/QAUOBNeZwmUZelNe70mw+HQX1MdHKu3+aGTUDnPLm2t5je28oqr/0Nl2qnBXDPALS4NjBUkx+2n7jfX1q0b0+ihdd/Vdymqg5Tr+/Jt8k12pqKNqg0NWG2kxZvm7viyaoepJbv1/CK7bn7j9iXGJb5tfWxE2y9AIa7d1TplAkW5+r9YwaQubZt3xBvmAGbp2m6NM8Ynl5vEiwbt20tkkSHTOdJI/O8ZjEBUGdaa0C5KTEOwhWu4tXbN8JYocu0T105vfpel28aWfl8uLe4S34UtMdWFL2s3UA3vx2+8A4DCrl6PxDgzuzaQ9Pj11XoxEW+8/nYya/2+JU742Su/wdK6ZLcz3N32M7tkakv+z6tv5q9d/+OYWcTNxQbxVPhv/9k3Ef0Ry+LvJ8z2Y9rXDfG0GoxIYPM9wvwMLM7lRDPDcssChqLlrnuUrmYtpO0qfd9zv9eTa4aiCa3bEZ1bLiVuBYomnLwsQnJ3b+MZpFuWZOrucdaF5n7k0uFdd01M7pLaZezWLxquT0vhutHawBDO5C4iNxiy3BRM7tLgRmcLFFAWFlPg36v6ntQUuY1ct48Wbr0ycsfL226QqmhCY+LMbz8rIHfXv0wzClvy1Zf+ID9x7TdY2BwjltQabhc9Z4CrSU1JYSMSKWhQUiCkGDIbMS2bZDaiY5aVOe6ux8ImFNbQqqZ8RJQUGLIyZmHd78BE8uo16431pLpAhRXG9uEdqAwKCgoK+uTQYDAIxndQUFDQJ6Hu2/hWE0uxHFmW0e12PS5CER9qPmtaVg1rNejUkFLTsNFo+MS2pqfVsOx0OozHbnAiz3Nv2CpeZTQaeTSEptA1TVo/riaWNQ1eTyR3Oh2fsB0MBhRFwXw+9xiG+rm3223/vZ5E39/fJ8syiqLwBhzgTbg4jknTlK2tLW92qoFblqU3/RTPEEURW1tbxHHMaDTi/PnzPhF86dIlb9zruWxubnJwcODxLmo6amJXzXtNkouIT51nWebNR8AjRTThXk9Ia1p3Pp8znU45c+aMvw+AN/z7/T6Hh4fEcUy/32c+n5MkCbPZjP39fTY2Nrwpubu7y2Qy8en9Xq/njWZN6V+4cMHPLFDsjCZ+wX0IOTg4YD6fe4zH1tbWXTMT1OCOosj3hSRJSJKEOI4ZDodkWbaGNdEUtqbVta8BPsU8Go3Y2trygxzan6MoWjOq1dSdTCa+f6kZrCa89h0d+NH96XtFzTIdrNH3lSbOp9Mpe3t7Pk2vqXNNXmsSfnNzk8lk4rEqih/RRL1iZnSASQcxAN+nlssl169fJ01TLl26xMte9jKuXLniZwEsFgs/QJIkCd1u17er/t6cz106VK+DJtXr2CBFESlWRq+dPoPUENd+du7cOf/seCgl9/huAVulrMuVAV43qdf3scKkQLW9AUq3jegy3U6NaTWy1UcunCkuqWAbmtaumeRmdew6IsV73afbUcoqDV7izG2LM7iFlQGurxd3R0mtWPfbr6wS5FSJ+NIl5R3KxV0gG7mfy6S6YFWYVprOdKS6nppe9yiMyrhcbBmSqQXbpF1akjRDbAsrboAYRZjYCguCQ4H4pHZt4E5EsNXgZd2IdtelXF/XyMr8bjSwacqXXXx1lcx2gfjXXfwDSBytJcQLW1JiKVmZko/feKdPhtexKlFlpkdiqEOjbFGQ4/b5xmtvY2kLFtY9C/dLy62ix1HR41c//FIax4Y3v++l9ApY7EDRhmLqfpeZtEKU5LDzO5YotczPRLRux6QvmdN6T5vmsUOWKP5ErDOK1VDefJe7YfM9sJHl/Jtz7rwmwaSQTISizWpWRJUUjydSzZpwy+OpUMbOWNc+qoZ0GVddJa/O3dT2VRvciRdVf6suVBm7daRCm/iZEhGr91C5en+YrDLWK5xQstR9W2+62wiKliGOqr7RasJigSQxc5vyhutv8wMQLSmIsJRiKBCyauQmqhriDGpLYev3u8RISYkhwtIyKZmNKawBgUY1m6DEMCpb/v8tySgxDnMiOaU1NGTV50rEI1aCgoKCgoKCgoKCgoI+mrpv43s6nbK5uemTulEUeaNOzVw119TYjuPYG5zKdh4MBsRx7LnbnU6HO3fusLe3R1mW3sxsNpveMF0sFp4frUbseDxGRHwb6hiLupmmiVHlNS8WC2az2VraG9aNRk1ML5dLb06rIacmnhqNimdQ5IViQwCPp+h0Oj6RO5vN6HQ63pAFZ/j1+32PxWi3297oV9NSBwTm87k309W0Pzo6Ik1Tbt++DeBZ5WrC67E1Aa5MbU207+zseEZ7kiRMJhOPbVkul/6+Aj6ZrvgONWbBcacVL3J0dMTZs2ex1nrzXlnquo6iSjThrSllNTPTNGV/f9+jZBSDo+awcqefeeYZ5vM5w+HQs8y73a4/Dz1GmqYehZIkCdPp1CNl9D4qb1uNf03r67nXB1UUG6ODODqrQFnl1lqfeNbtFVuifVMHbrT/6eCOzmI4nc7XbfU47XbbY2PUBD85OfHJfd1OrwHAxsYGURT566Hr6PtpNpvRarXodrs+vV1/P+kzQPn6WZbxzDPP+EGJs2fP+kEX5YhrYl5T3XpuOoCjMwn0eJq412ut912T6YvFwg8kjEajteS4ptj13B5KnUp1q2HtHdnK8HaYBOsdurXUtmHFCK/QKVJHjFjxhq8affXja9obC1LFyW1eISLUJK8wKYo6UfPP41E0Ga5GeqQJdl1ffLDdJ9up/VyySojX0Cn+2BHeVLdiESurc7Timd02tq4JpjaWUIBEVDzm6pqWzqQtKy60mqc2EqwYTN4kmneR2Ypfb6czZ3iXbsaJY3Tf2wSsG9TuHrmkuGd967alY3GL7qe0SJxgi+IuA1v36fAm62Z6YS2xODNcze9V2ruOu3BmuUF44/W3E4khs4aMjBLLrMyYVuuPywb7+YD/7coXkZ002bhmyTZioiUsdyzRXDDNnPJW06WcG5YoFWZnDVLActvS3heKqy1MBskMlluQ9Ry3OxkKedfSPHIIn6xXXYLEUrQsT38VYHMkE5KhwaRCmVTomsLd1yh3SfCiBc0jWG5D0bR+PyarBj2sS35nPUgmbpv6LAftLNHCpcltpLMf8Ox4TNVdq8S5yVbmeL0fR6n1eB0p3UHKRIgqJnmUVmn0ZYmtjG+bxJA0YL6gZ1ocFFNm1mLAG9pqOGvqO7MxHeM+F0UVs6WwEQWGrqRExmIoWZAQYVlUaJSi9uZIbcSsbK76hxhaJqUrKQVCq4ZFUZUPFSo2KCgoKCgoKCgoKOjjpfs2vtXoUkNOuc2ANyzrph3gk7aATyOrET6bzTxnWDEIasSqiaXpNU3J1hnKakDXEQjKnFZjE/CGmqJK1KxW47aeRlWTPIoijo6O/P406a1GrRrIdc74cDgkz3PG47E/V2OMZ09rSl0NRjUC1YQEPLqkXnBQ8SiaStZ9TSYTj/NQVrQa0HXDvc4eVwyJmqx6bdUwVFSJctobjQYbGxscHh6yubnp7+disfCp4KIo/PmORiNarRYHBwfe3ByPxz7BrfxyHRxot9u+qKeiR/R1Nfs1oa5meKfT8eem3Gk1hlutFteuXfN8bB0QUeNfESya1K4Xm9TBAGMMk8nEDypoP9J96s+qXq/nUSKA59XXOd+aLtfkvb5PdACpPgijJroWqcyyzM9y0H4M+FkHURSxubm5xpYvisIXf+z1esxmszXUj85A0OS/mtVlWfo2zudztra2aLfbflBJ30/b29s8/fTTbG9v+6KnynnXY21ubvoZAfX3iqJj6nz0PM992j9NU19wVfuqvuf0PXNwcOC30VkGURT5wpt67Waz2f0+3l6QWrGzqwR0lfhepasrI67AFbOEehC7WmcdYQKspb692VzDpngTvb5N6RLVInZliOtKdcOrnhave7C6SikQlZXpvjK/XXvsah1AMS0uAlzbR83oPh0ytVFl7kerbZyBXbHLxWKtS7H7iHON5Sy2QlLob1ZxzcnFbZP2DclWizg2RHll/M0r7Iq1SByvzO3a7A+f5FZzuypKSVF4rMXpQt0r1AmVGW49IsUtj1ZFNat1181sSyRCToHBJbo1La7rlVgSiSrj241UlJR82YVXV/iTkpldcFI6FjTAlWyXt00f4+qdLaSTM7nsqjqe/d/egnz2p3LtSzZYPtWlMRKKJkRzZzAXLWcKJ2MhGVtvWFvjTOfpZUvZsO5+RZb5Oci3crofcs9sG0PrwDDrF5ixIZ5WhSNN1QWr5HXZgjJ3xyrakIwtWd+1Q0qwhTOyxXnC5N2qQGXVdxWBUmd8gzOsyVkVxTSur1hbexvpDAxbS4BXszMkdcuKBKJMO7HDpShW55SXjBQl1pZQFHzpI6/hf//Qm0itIRJLhvGpb8B/ryNJwBnSEZaWZG7Cg819Ojyr3gSKMxmw8MdOK/feJb0LkmoGwGnD2+Dakp4adAkKCgoKCgoKCgoKCvpo6HkZ32qcKjZDWcDWWp+S1f9rGlSNb2OMN0yV8a2GnRq2mqzWNCfgsSNqoGqyVo3xfr/vjS41hYfD4ZqJnWWZ35+apHEc+ySzGqJaAFLPZTweM5lM2NjYoN1ue8NUOeVaOFITsXW2uUoHCfQ66fqafNZz1gS9ctA11armqKZbNzc3OTw89KZsHTWjSXM1/7rdLicnJ2v7n8/nPs2shmaapt681vV0QEBT+mrIa+IY8LgJTQM3Gg2uXbvmTf5+v8/t27d9Ul37hSJTNBWsAyC6jabaG40Gu7u75HnOYDDg3e9+Nzdv3mRnZ4cbN26wv78PuGKMyotfLpf0+30/QKNIFD1PxX9oWlrvd70ApybydWBEr1s9Ca7X+XSCWY12vXf1fq0msKazNfGsRWG1j6o0Na5YFE1067G17+o9EBEmk4kfbNHZCs1m05vEdaP98uXL3shvNpsMh0MajQbdbpdOp8P29rZPwSvORq/F2bNnyfOcJEk8wkcRKootGo/HfhZHp9OhLEuGw6Fvax1ppOls5f2r2a/mtV7rvb09b/CNRiNv1Od5vlZYVFP8D63UPKNmfqvpbf2P6+60Xd9ePJWk2kuVal4zuWvfV9sqN4J1k3sVpF5jbt+1/al2rJza6v/ZacRHda5ZlbqOXVutjlEVgljB4hLdmuy2sbr3tYZ47gvO2LZqhmuyXdbMRY980XR5DWVx+pyV+100I6Kp+FQuJnKmtFjH+gYkjqvilTG2KJHIeN63R42IwKkaBu562PW0d2V6Y6raCtHq+tmicKZ3hSsBfPHLjMKfjJF1s9t9LzEYljbDVP9025+69lby6uTHpWW/6HA93wLgvfOLvG98FjtsYOZC0bJEM+Hq3/48x8JuVX2vKlJpcsfQjhfu59ZhtTyFZGqZ77njxFNBRkLntuVH/s5382U/9m2QCdMXVciyQcqv/Pnv43N++q9jMqExFI9R0duedyzRUigbjt3tBjKE5lHF8caZ3sr4zturgqZFY4UhUVyJDo4ohsSnuSvzu0wcP99aZ9hHaTVbwKwS6LovRZ748R0tlllVhZRFSZTWq7xWx242kXYbm6Z0BBZWKK2QWUNphVHZoiEFBUJhIxBXnLIQS8IqEe4NcnHGdyQlmY0oEBZlQmZjjy8xlGvolJZJaUjhzPNKEZZESsbl+mByUFBQUFBQUFBQUFDQR1PPy/ieTCbeoNLU9WlWtBYABHxyVrdfLpecnJx49vPh4SFbW1u+qGWdK52mqd9vFEUeu6DHVaO63W77wo5a8E6TsoBnYCtmRM1rTQBr+9Ww1/9r0UJlHBtjfBJ6Mpn4NPFyufQGm3K4NYW6u7u7dr3UGO10Ot7Uq+NTkiTxzPPJZLKGnRiNRgwGA18IUhPzalIPh0NvnGr71YCtm7ya5lVDFFbpe71eeh3UzG23296MVoNWDXw1VWGVWFdj++joiKIouHjxIv1+3xew1KTxZDJhPB57E1c50sYYRqMRo9GIXq/H+fPnOT4+Zmdnh+Vyyf7+Ph/4wAf48Ic/DMAHP/hBJpMJN2/e9Caw3rM61kZRLoA3xdVw11kCmthXA11Z2or+UKwP4FPTdeNZ+0i98KKavNrv1LBWhnh9UEbT+4BPgCtzvd1u+8ENvU6z2czPfADY2dnxg0CdTscnzfU9p6ihxWLhC2HWcSNavFXboIUk9X1cn2mRpimDwYB2u+2LXOrsC30vbmxscO3aNc6cOePZ8IoJ0gEVvZY6I0Pvjw6sAP7ZokVC1cBfLBY+Pa8DWDorQfv0wyipkqVQJUdrXOa7iklWy9zKp/ajqWeLM749noS1VKpfXu1DTTq/W1vto3QHVa42sG6C+/1VB621SwpxvO5IG49z5qUy5SscyxruRFdVTIsmyU9hWeoXYy0JXkemVOlcDBBZrBV3KSouOFJrQ/3i1i+9ceclWblKdEcGm1O5y6W/VxJFIMYZ4uXp0QGwee4N7Xu9Tg1xZE21v3J1sa11hreqnvYuKYkQz/kukfptoqjel4VeSHEmuG5bYCmtYEQ4KRu8a3GZp5Z7ALzr5AJXDrcxC+Fr/thb+LFf/MP85J//p3zHF3wNxVafp/70AJNWhviiwomkVZsjkIUl6wnx3CWdl1sOaxIt3SVf7Ahf//e+jc6mMD8TrQZWBil/6Bf+Kp/+aU/z4Z97MdnAEk8d41sKKGKHSonn7vrnXWe+Lzddf0h3CtrXY7K+Q684TNCqn0RpZWyLuyWyGjcgmdlq0EN8fytjTYpXhnKV6FYEio7DRGqml6tlmhp32BTrDXHJLdGyJB4tVv0tz5FmA4qCjomY2YKFjchsxNgmLKqvhhSev62jOwXiDe+04npnNsJISVqZ3ZmNGZdtSmtoldXnLslIJKdlMmdwU5BW27milgVGLAsbkUhZmfAh8R0UFBQUFBQUFBQU9NHXfRvfakBpWlVTrIpfUKZyq9Xyxms9IZwkCe122yMmrLU+9Qx4jIEagmpuaUpWTVhN785mszVEirWOj6rmuD/BikmsiWhNgCvjent72ydvlVetZq+a7IBPm6vZHUURw+GQNE0Zj8cMBgN/bK32rGadnns9aaxcYjXo1Kisc6Q10a6ICL3mil/RpLuaw5q8nkwmnk+t2y6XS48QUVNRi5BqQl2vCTgTW830+mCCbqv7PT4+XuO4TyYTRMQn8ev9YbFYMBgMfBJYE8ya7lZ8hyJ0dFBBcSg62KCc9jt37gCwWCy4c+eOL1JaT/gr6kPZ83rNFA0TRRE7Ozv+3HWAQNfXPqT9X89b3wtqZOvrmupXU1bRJlrEUvt4vail7kf3rUloRaJMp1N6vZ7vU8BdSBbdVhPneZ4zmUz8tVMci5r8Gxsb/hiaPtfrpIM3iiFSoxpWyCK9T3ou29vbnive6/X8YNXt27dpNpt+XzrjoigKRqORRxHpNdLBKJ0ZoIMh2u8V9wP4a6X3U/u9psu1rQ+rtDge6rXJ3fgFzyEu604vHvGhiyQXTOZ42ja2K7O6jioR68kiyu2+O8297qxLWR27MovrxS21zX65Ni2TFXtcatzxCkEi5aogJVSmd5UGl0wgUrPcrPYDPtFutVimmtx1I53qdcRxlgupDTBYz/Z2Bqat0u2C0cS4hSgtMcsMyarZM0niClwWeFa3DqiJmtEucu2LW9YN7NXrhTO7SwtR5FEmGIOU5V18cI8+qSW+1fwurKXAEin/+XSqnJXB7XYlOBvcbVNad11bEjvMhRQ8MTwPwO1Jj/l+h86B4Y8P3s2X/6fvZGEjipu3ef93nOUPf/p7ectvv4JkbFyCuuKkS+lS3jYSl9I2QtarUtKJez1KHWcb61LZ3evCYs+1sdlOMR/s8MTwMdoWTOrud9GyJCPXtxsnxg/iOCZ3ZSrnQnISuQKTNWPaF9FM3Ve0tGRdh1DxqW+c4V0mFQLH4hnfNqKaReBmFZh8NTOjXvBSSoup3ssmZ23wymTWrxOlJSYroMLoSDWQor+fWhLTlIJplfSe2SajokXXpERS4idJIBiEyLqik3UOuCuEGTGzTaZlk3HRYlmlthfV98iUNKSga5ZE2CodHjtz3GQ0KD3TO8WZ3inrM56CgoKCgoKCgoKCgoI+Grpv41v5xppe1bS3moxqFmpiW00uNY4Xi4U3AmezmTcA1cxtNpseeaEGrSI/FJtQ51IXReGNU2UWazuUyQ0r1IgWANRUaJZlPm2tZrymodVA1IR2URTs7+/7JLoazPUEtBqAGxsb3nDTttQT6Hq8wWDgU+R1VIyavWpUaqE+ZTRrMlZTu4vFguPjY28QAgwGA27evOmPqWl7NdrV7FTG8mAw8AgONYeNMQwGA8/e1vS53nPFeGg/AIcc2dvbW2OpDwYDsixjMpn44pStVovhcMjJyQn9ft8nzHVQol4QVPc9HA59yviJJ57g8PDQG9BqiiripX7vtW+JCDdv3vSM793dXdI0ZWtryyeJNbVd79OAvy6qOu4F8IZtfSBIETSwQpZon2q1Wt6k1/bp+StaRfE+ep807a33WQcUjo+P/b2Iooh+v+9NdL32aiKXZcloNPL9U5Pcytmum9/6Xp/NZn7AQa91vUjpaDTi5OSEk5MTX9RT26B9cTab+VkKjUbDp/71Wuv104Gr+rI6skj7CuDfg5rC12M1Gg2/79P36WGSN2PVLK4lqT3Ro8bE9ggULXjoER7W/6zoFKkM8DU0iO5HE9eVA259cUW88V4LlK5t6w5ElRi33pAX8Alzo7dUqjbo8TRhG6sxjd+fM81rae9Tie662Y4OFkTWtcnWltVXq8xvXxzT+PC545mXrF0bNW6j1KW9ZZGum9dRBEXpi1taxR5poltc7NwWBVjrTWxbuEyuP06Wr1Lc1XtBj+MS5FWSHkBKyuUKPeFu07rBXTe/I1mZ4GUt/x0ha4b3kpLCWhKE0mbMyiYHeZ/rww0A0ty1d7lt+cY3/X/YfmtC+qVDfvB9P8xf/KHP5hu/+Nd4i30l8cQVqWwdCHnb3QdX7LJqawfKqCo2mToeuCrdEDcIEUPv6Wrh1U3KDTeAM7tU0DiqsB4zt226VdA8cAnxrOuKZGYbkAzF8cVT910N67zt7n08r9AkuaVoudS/4k+U9W4yS7TAJdVnlrIhDo1SJdmlWHUXU1RGNhWGpRp8MWuzFKx/L5jMYmMwqUVKiyxrK+qgrHHX/Csvfw7/8sqvEmErUE1ZpbYLKBskpiCquN919rcmv7MaxyeRnIiERAqaJmNWNvzrC5uscCeS08LSMnN3XGsoxO2zQVkZ44VnggcFBQUFBQUFBQUFBX00dd/Gt6ac1UA+jSVRQ1yl6ASVsrwVkaGFHeuGXz2tq4Zbr9fj4ODAG7+j0cgjIeopZjUatZ1rJ1kz31ut1pq5q4gRNV/H47EvxKfGtrKf1chXnEf9uGpS93o9bzhr8UdFSmiBSkVJ1AtWLhYLb/oCPj2vZrimXdX0Pjg48MalGsKK8VATuz4ooBgVTe/6RKEIo9GIM2fO+KSxpqqXy6UvMgh4vrsanEVR+EQvrIzHo6MjPwCghqbOABiNRnS7XXq9nucy6/7yPGc+n5NlGTdv3lxDkGhqGZz5eu3aNZ9OPzo68kapzhbQ9mZZ5o3a5XJJq9VaK1ipswH0Hhpj2NjY8NdFjVU1o3V/sCrqqv1LDVdNMWs6vn4N1IyvF2HU94rut46qqffNxWLBcDgE8H292Wx6lnccx4zHY38eRVH495PiaTTpD3izWnnyimcZj8e0Wi1u3rzJ2bNnPbMd8H1bBzP0vahmtSbnlWuvAyiNRsOb3/r+UlSP3ofFYnEXxkffyzr4o0l2fX/qgIK+p3TgQDExD7WkjjuRu3zqNRNc/c46RtqySm0r3gRWRvMps9pziKvlFi0IeY+mVUUz10xn3VfVtpVrj0Oc1EzulfHOWrp7vS2VgVicOk+72tdawlzbY7iraKd6yzYqHR/c2MpErw6Zr1LpYtevjRTOCI2WluawIJpmsExdQpsKWZJmjret+JKicJxvn+DGIVHK0pnbQJ3jbfPMmeO2BGt5/MY7+dJHXlOl5o1PhIvIihVeQ5s8fv0dNYa3+5cQrRncsJ78Llj9v7SWEkuGpbCWhYUMS1KZpu+bnuPk0M1aIXWp6mIjp3ErIfsTJ8zGLf78f/gWeNmcv/u3/0uSTxfSTUs8c6luk+l1xRvg1jhUiCkcdqQxcintrIPvc9ESZ0azMsxbB5aiaZAC8ralMXTbX3hzwU/84D/lc3/ov/Xvg2gh2NiZ61JCPHdc8EjN7rRif4tjbbtinO5elw2gOnY8h/meK8qp3TueVea1N7xXDHCXCLfYSPz7SruUyax/X2nKW2aWxsEUSjDTOaS1AY3lEptmflBEud19M2daNumaJQXGFR8toWuWJJJjEBJxxjQWTGVWJzVTvKg+G0RV32lVkHNTEeDd/iExM/omJcJyUjYpbExXMp8gL60hOtXXgoKCgoKCgoKCgoKCPhp6XoxvRYqo+aeml5pOWhhPubtJknBycgKsEA1a9FJN3XoCVhO/akYC/mdFYSh2QlPlRVF4tESSJIxGIzY3Nz0LuW469/t9b9KXZcnW1haAT85qCnd7e5vxeOzbCqyxoTc3Nz3uJcsyer0eGxsbPs2t04q10J8uV763msdqMtfT5fP53OMytra2/HaaSD/NU9eCjnU2tBa21IEJvYbT6dSbr/VEvh4D8AlgZULrNeh0Osznc4+U2NrawlrL5cuX2dzcBPDoCsWXqLE/Ho89tkbTwIvFwpu7AFtbW9y+fRvA42y0HTogMR6P2d/fZ39/n6OjI2/CGmN86levK+DPSw1mEWE8HnukiqJl9B6pyayGrSbAt7e3/XXThL5K+7VeUzWDdVBF+5diSxRvongXWKWodSaDiDCfz2m1Wj5tnuc5o9HIG8GKe+n1eoxGI/I8931Q+eR19jzg3yfKPY+iiDRNOTo6YjqdesSMzmrQFHj9mu7s7Ph9aQpbZ04UReFnJShKRY/R7/ex1nJwcODRSMo/bzabflBsOp36AaV6MU/l3FtrffpenxFHR0f+WupgmM60eFi1ZjjfTalYM4LrierTm6jRuHYla8lmG638aY9MOb1cpT523dw+ZYx7D75aSRyFw/1YiF9XrGIiWOFczCod64+luBOPH6leKytEiVk1UoysEC5F9f/KyNeCmFKNHHhzX9teHdfjZao2SLkybB0mw2Jm7lm1MqDd88Gb3qqiwFaDQmqS++8109oWxZrpjQivu/BZYCxiBJtnLu0NWKkVtiyt266snpe6DwxGjc36iIg13gh3hSxzjLi0t5EKb4IjtlRIdE5KZ37enA3cbIDq2pqZoWyVlDGkv7tJLC6dnbynzclL3bXK+gVlIrT2nUldT0XbeIUZgcoYrgYn4jk+3V8aNyjhzzmCxbaQTHRsxaW4kwlc/yMJX/i/fBvFBeuRJvHEbZMULkGuKJs6jjpaQt5xrxUNaIwcg9xktWKXsmqnWFfA05veVZpbWd0ULj0uJRQGh8kpIV6UDvOSWkxuiZYFkpVEy8Kdy2yJZDnlwRFSPQ9tnmPTFJvlvPHqbwFws4DMGhIpiKRkM5r5RPeobLGwCYnNnbldFb0Eh7MprSFDmJZNFtYxvhc2YVEma8Z1QwpS61LhjvftUuR9UzAuLSmR329mo6rQ5elpIEFBQUFBQUFBQUFBQb9/3bfxvbm56XEjyhxWtrGmWtWUVkNTzWlYZ/Sq6aamoxqJml4dDoe+6N7x8bFnbWtyWYvZqbGVZZk32zudjjcKAW9U1tuqaVI1ZNM09YxtwJt9il7QRKruY2dnxyd6t7a2/Llrm3Q/mlLXc7TWelyFrjOZTNawGGVZ+nS54l50QEGvX319LRZY51qfnJz4NHez2fSJajVIy7L0SAgteGmtpdvt+gR63SxVBvne3p5vY7vdZnNz05udgE+7a0pa75UaqoDHXCg7fD6fexTNfD73BTn39va4du2aN747nQ4f/OAHef/738+73vUuxuOxx36MRiOWy6Vvp6I9wJm49SKWihfR86jjYLR/aDpe2w/OeNU+piarJqkVU1Nn3Os10T6hx9UCsbpf7Z9678bjMZubm55TrW1RE1z7vJrwZ8+e5fDwkGazuVbUUwcpNJmvAw167zRd3+v1fH/RQSFNqmsfVbMeYH9/37etzmLXgq87OzvMZjM/kNDtdv3AVpIknDlzhps3b/pZHvp+LcuSXq/nkUX1Iqv6HtdttK2aYn/sscew1vo0vA466AyBh1KK9qgcbp8QtauXgZXTbGumM7XXTv/sTWs8XsSjSTyrYWVI1vfv91euXtKXpbZfAWeg57YyCtVsxqdf15LrBizO8FWUii+GWaee1AoCeuOyfsKKQqkHT0uXKMcbrDWjvFg1Yq39mvyuWNAmh3huaY5L4kmN7V1qYUiBrF7BsGqcMevYE1jVElCzW7dxL/L4jXcCOOO7LLBWfJr7yy6+mjXUSaU3Xn87WbVsVcxyVawS1ABXOEbJ0ubO8EbIbEkihqJKe1fIaY6KhFvFgCvpLncmPezS7a+1H/HiH3yG93/rJaKlXkBnUJsc5tuWolvQ3I8pE0vesTTGzniO0srgtitTWQcVlAWu98Gkbr+KQFFUiI2rsYkYythiMpfUbh4LWRfihRBP3D49l1uqNLaBeCbEM2deR0u3f+138RyKRPwx9JjLbXHp8KaQTC2tw4rpna3eeFFWYUsMxLMSGwtiLSZ1ye/GKENyi2QF0XjhGO2LahBlNOHH3/U4iUQsbUbPuGfzpFyQSMTC5hyWJc2qz7Sk8OZ3SzIyG5NIzrRsUljjDG0sp0PYJ2WnYnzHTMsmmY1IbUyBS2wr49sYt2FDCky1k0RKCgtGShrWGd714plBQUFBQUEvJF07nvFvfv1p0qLkO7/iUx90c4KCgoIeat238d3tdimKwmMN6gXvZrMZy+WS7e1t2u22515r4hTw6AEtiKcmm5p+WvRRkQlqYmlhxeFw6FETmghdLpc+ea4c5XrxQT3udDolTVNv8iqTG5z5ORgMmEwm3vTUgpG7u7se6bJYLLyJHUXRGt9cTWI1VtWc1BS6mpHK2ga8aatJdxFZQ0do+lcHAwCfblf0Rh0FoUUQAba3t1ksFmxtbbG5ucl0OmU2m3lDv27+aipZTfVms+nNZk3a1w1jTWGfO3fO40n0XBRlUh98UFyI8sF18CRNU78cnHnd7/c9Y1oLM56cnFAUBW9+85t561vfyhNPPMGVK1d45JFHfKpfB0QU76EJ5TiO/bVTU1wT1Zoe1m0Vq6JJbGVh19Pdan7X0SaNRsOjTYA1A1kHO/T/2rc03a/9VNPSOiCgSXy9vpqi1gEM7T+dTofpdMpiseDcuXP+vaOoEL2WOhilaJw0TRkOh8RxzGw282l2cIM1w+GQzc1NP1vg4OBg7T2lMyVEhKOjozX2dqPR8O9H3a+el85i6Pf7voDr7u6uL/CqA1DGmLX3uvbTemHM+qCQMcan1judjsfo6KDbwyhvxBan3Gs1rKklvu09Q+FrZrVfR9aXr+FUKryIrQ6wlgSvb1v7v+7TY6epkr1UBnJs8dgTK66wZr19a0a8M7/X2n7ayFZMil4jxZbotarhV6xxKW9bT2FLbX+aIK9dRy246Qxm99947lLArcOMeLhwGIqiWKW3cclcxGBLi5gSSuMgIcroNsbtU9uipndZgKzM7QoPzeM33klRK1gZieGN199OWZnVrvnu/8r1zmzF8a9OMKOolq+MbU15q0pbK2a5uiwsbMQz+Ra/PHoVH57scnJlkyhz25kUPvOnn+EDP3+ZogWd60LWx3PfG0OBUUzetpQJRFXSO16yVuQyWjjz2ixBrOPJq0mtfG2TV30AKOJq4CPHJ6vjqsBl2XDJ7qJlHfO7BUXbHbdoVbMPCodVMQvIuzjzu6n9qD6wYokWd882KdrQOLEkU0veFkxuSWbWzY4oXeLbZC7NHY8zbCREixwbV6ixSYqkGUQG9o+QJCG/dRvE8Marv8X1IiXBsdhnhfsssLCWjhQcldCqpiPMrJBZw8LGPqVtKqRJy6SOyw1MbYPURkSKOwFSG3FSdIjEMi6qdHgtqT0rm9VxE/pmQWENpRgyGzEuE1pSONO94oUnUlBag5GSsh6jDwoKCgoK+iTXIiv4gf/3w3QaEX/ny19FZO7+bBAUFBQU9PHRfRvfwBrvWVOuJycnvnBenXdcL4gHzsBWU1zRHGoiq1GpKI4kSdjZ2fFm83K5ZDgc+mR3q9Wi2+36pHm32/XH6Ha7iIg3vdSQVGSHYiXUuFdzU420TqfjzWFwhrAyoLMsY7lcerSHpmj1XBuNBpPJxJvRmlhVI1ST2ZoAVrNT0R86MJAkCe1226ej1YjWJLgazZquVi62mqJacLLZbPoUsjLRZ7MZaZrSbrfX+NW67Ww2821QE1PN5729PYwxnD171puLmswFlw7f2dlZS+Vq8cjpdMp8Pqff7xNFEcfHxzz66KMkSeIxJtpGxWcoT16N06eeesrPItjf3/epajVE9drrtdZEspqmWry03+8DLl2tAzraV7VPqXmv/HS9z4pF0furaXkR8WgYxcKowa1t1DbVizfWMSza99X81tS/3os4jjk8PPTtfPGLX8x4PCaO47Xipo1Gg/F4zHA49EUxdcBFX1eDP03TteusbP16qrqO/NEBp3a7TRRF3rC+c+eO78vb29s+wQ/494M+H3Z2dhiNRjQaDf/s0Ouuzw7FKumyNE09v10xP8YYfw7NZtO3VdPlD3fi232rf8S2as7e4/UVYqT6ub5e3Sw/bXrr+qdZ3ca6/ZWyYnNbV6hSzUt/4NPGdFTz1z0re4VF8TXwNDJea6cvbKk7qLfLWMpYVoU1KyTLuhNOrRCnGvgrM92nyGvH9vuzmkoXvzuTOZZz+7AgPlkioynkOTbLPKvbVoNKtvb7EltiM+vY3FG0jjiRdYPw8evvWPu5xBJV3zUNvrSZT2tnNZP6dMFKgzO4EyIKClfY8tTx1OTWopaJGDKrZrnjR09tzIfTM/yHd3wWvZ0ZydjUUvPwo+96DXajQDIh3YgoG84sztrW899XKBrB5PhilVKsUv1WXCrbRuKT/Mre1sKQikARW5nhBeSdKuldFassE0tU3VtTVBiVHMq29YZ3PK22r+Gzo4XDnCQVEsUUeAPe5M4gp+oSyXSVDE+mlihzRncRCY1hjslLysjQuDN1syZu7DvOe5JAnrs3X5JQngyxacrPfPgtHJcLxqXliSymLzC2UZWsdvd1szZDIbNwUkZk1jC1FWarMptN9YZMKFy6nZKCiIzIo0gKhHHZZmEbZGXEcd4lkYJMIvpmgRHrE98A29GkMrfzCmWixyhJpGSJddtU6wfUSVBQUFDQC0kv2u3RSgyztODpwykv3us96CYFBQUFPbQKEZugoKCgoKCgoKCgoKCgoKCgj4IiI7zi3ACA994cf4S1g4KCgoI+lnpeiW8tVqhpTC2AVy8kp0gNTV5q2rNe9LHT6dBoNDyHWPep+AddL0kSj2LQoopRFLG5uenRKbpuvYhhnXety8uy9GnmTqfjcQ3KH87z3KeVNXWryWVtg6IXNGWr2I96EcmiKDw+BPD4Ek3xapoW8DgRRafoddJ0sKI8NKk8m804OjryuA09phZhVByFsqEV/6HnpEgNxcLoeej10cSuJpijKGJ7e5vRaAS41O1gMPDHUFa0Jmv1uFEUcXJy4hPM7XYbay2Hh4f+vu3s7Phj7u3tsb+/z507d+j1ehhjfJHSo6MjnnjiCYbDob9+Z8+e5Z3vfKdvi94DRY/ofa4jZ7StWhBV0+yKENFrmKYpo9GIM2fO+GS8iLBYLMiyjFar5ZPk8/nco0R0RoCm7QHfZ+oFNPUYURT55HR9GbhU9WQyYXt72/c5TT5r8vrSpUucnJyQpimPPfYYN2/e9O8Zfb/EcexnQfg3fBwzGo387AFNUidJ4lneOjNBZyJsbGz4PptlGTdu3GB7e9un9ZX1rngSfa+dO3fO88Ynk4lPpjcaDY9HUVZ+/T5q/6vjSrSIa57nPrGfZRlHR0c+tb9YLDzrXDEsD63uldg+BfG+V+1Pn8Sup5pPr6csbDyBZPVSBFLaKkkNRNYXlgSLZLWV6/vVUPXppPopxrBLYVecawQiu1pZC1uWtXWppcChSqLXmOHU0+3izsWsuMt3scnrqJeyYqeX4nEXa+21jgEdzy3JMCUaVmnvooQs90lvimL1fxFsaapilNUsiyx3P2v6u9Silblneme2WONyF7asfo7IKSisi6MXtbR3RkFpxRWqrI5VUJDZ0ifBgVrRSoc1qReyTMRQ2lXqW0fSb+RbvHd6nvgwYX68wfYHYHauSpe3wOYGaRWYQQHnCsqnenRuwXxPKBoujZ2MwSZCuukuajwTTOES9EVrldyX0mFEtCCl5FX6Oq8S1vopx1Zc7whMKis0SQlGMSy5uAS5T467n81yxfPOutA8dv+3keOOW1OlxKv9RUtL0V61MZ67/hktXbtMYYmWJZJbkmmJlJbk5ghZptjpDNKMH3vPz/M1n/Y63vj2x5mUmouG92eGTZPyjrRJRMLUNjgpOmxGM7qSsl906Ru3/qyAR+OMllgKC0fFitFdV0JOJCVdsySzcbVO5P5vTcXjNhTWLR/mHWZFg06U0pGCRAq6ZgnVR58IVzSzJRl9s6ArOf0KeF7U3o6zqh2NKgUeFBQUFBT0QtKrzvf5nasnvOfmkC//jPMPujlBQUFBzykRuQI8eo+Xvs9a+1+LM9i+E/jLwBbwm8B/ba19oraPJvCPgT8PtIFfAv6Ktfbax7j5z6n7Nr57vZ43upMk8YXxlJutxqKak1mWMZlMvEk1m808IkQLIqpZqaiTerHLPM85PDykKAqOj485PDzEWsvu7q7Hl+g22iZFJ2iRwvo6ypKGdV55FEXeIFbTUPEiURR5vvdiseDk5MQXtlRjURESg8HAM7JVWlhQj6EDBsoY1+Or4a94i8Vi4c1fNWiPjo44OTnxxqRiOBSHYq1dYxqriWqModfr+eOreTidTmm3276gpB5nc3PTs6jryBA1QHVwYTKZkOc5y+XSm6IbGxsembJcLj2nvCxL+v0++/v7vgCjXv+iKLyxLiLM53OuX7/OxsaGH5SI45g3vvGNPP30055nXS+YCQ7DM51O/XVVxrd+qSGr9wKcwayFMfv9/prhqtdejVkthGqt9UUfAd//FVuiTPf6sesDCVowdTwe+2uV5zmNRsMXMa2b8oq50WU7OzvAihGvKJo8z7l06RI3b970BU+73a7vu8q2V5TJZDJhMBj4depFNBWbo8UxlaWt90jf37pc+8hwOGQ0GjGbzdje3mZnZ8cPaGVZRq/Xo9lscnh4SL/f98VQ5/M53W53rSioPhN08Of27dv+/VxH/fT7fRaLBUdHR/6+KjpFnz0Pq9SMXcOKcIrnbWvr1bAjHidSrXyvYpiw4ntbz7Zevb5CVVSY7rLG07ayMqrr5rriU8r1hvqinBW+RKw7li3BxhZBsNXxpdqZR7sobqXifcuaOV47dnUcf1hvcOvPVfFMcS9qsU1tm5TuHMVWPOgMooWldVwQD+eO7W0tZCm2KDzqBFgVpbz4Bxy327iTs6WpTlKwmfUGuM1WXG6HLykqTIkzFyNxhnaOW66dIBLxLO+EyBeqVKm5ndmSDEtHVoU1VXXT22AopSSzjgy+rK7F78we4VevvBRroHEiHH1GSftmbSBiaTBTQ9E30IfObWGx43jaydgVhyw6jvHdumNYbpeUTbevdODuQ7KwFLEwu2BJRuJR8GId6kTNaOr9X7nv1f3Sfq6DM/XBECmcUe4GL6BorMx1NbyLRoVEaTpzPF5YiqbD8kRzxx0H93oZQeeOdcgWK0huidKSeLQEY5DpnOLgEIkifu7JtzAp4Y3v+VU+kE15NG7wi/M+Cc5gvl44s7shBWllUJ8UHfbtgERyFtY9CzfNjHenLVqSYaT0zG7Ab9cyjg2e2ZiOWZJIwaxsklCQETMuWxTWUFQXzhniEcsyxoilY9wzux/N2Yzc5yxDSUMKtqMZLSmIsB633xKHxMHi2eFGbDC+g4KCgoJecHrVeRfSes+N0QNuSVBQUNB96bVA/Q/ATwN+Afj31c/fDvx14BuADwB/B/gFEXmFtVantnwP8BXA1wKHwHcDbxCRz7bWPjC24X0b35qerSeh1ahVdq8ai3VWryZUlUWtCWQ1ATVxrExgNYqHwyHj8dgb2/Xjamr08PDQF3DUNl6/ft2zuwGfMlUDWNnZyt3Wdqt5rknYLMtot9tr/O69vT1/Xnr+yiE2xtDv99fS72riacp5NpuRJIk3AesFDDUtrslfNdXjOObWrVscHx/7xHu73WY6nXqzXYtz1q97kiQsFgs/EKFGohbYVCO2XlBxMBj4exhFEb1ezyftd3d3GY/H3swWEZrNpudyA56VPp1OfYJYk9BlWXp2+qVLl9aKGCqj/OzZs+R57vuJiNDpdDg6OmI+n/Pyl7+cNE25evWqT2TDapaBctrBGaRqfKrJr0aqzgjIsswnqvWa633XNqvxqoMAOpAC+AT46b6s+1MDHPCpZk05d7tdf2905oDy7pvNph9cUG78ZDJhZ2fHp9z39/c9L348HrNYLDg+PmY6ndJqtZhOpz7Rr4MEOjAA+HuhzG0133X2ws7ODsPh0HO8Vc1mk/39fW/ANxoNP7CiAyHD4ZCiKLh69SqDwYALFy744qE6OGCtZbFY+HutA1XNZnMtkb72sIpjn/zWQRodONHBG923XveHVXeFue9hIp8uNmnrOOfKCCzv9j1XuzQ1Q1pW+yACm9wNGbda/dFWDRLHzK4nxpUHbs0qRV3nja+8scpEv1f7BBeWFpfu9mZ2lVS3lcvvjesae3rtuljx18eb5Ro4t+J437rfWjuVL51MLM2RpXm4QKZz7GIB1mKL0iW8y9XvfWdci4+826IAa3n8+tuAyhAHbFGdmy15/MY7ySxrKW5w5nZ8KumtxnhZi6SXlMxs4VPambUkImSVSemWld4ML6ufIxGSiu+9sJkzwEUw1tIRuFEkLiF8pUfzRIgWIAeGvBovzLuW5CTi8muvs9ee8I5ffgXphq1Y3RYphLzr2NqNEyFvW+TCAvPhNtnA0toXorm7zkWjSlqXFXtbwGSO5V4m7h6k/SrhXwCJ43KX1eNB+4ChYntX/clUYwFWB3GqBHmpBnmxYnojEE9c3yqjKlGOuMKXZa1PVDuMlpBMSxDBLAvMIkeGE+x0CkWBNJscFzOmtgQWfDDbYVYOef/iAmeTIbdyYSeekNmYgVklwVuSMSubZDbiVukGwe9In5bJOBON6cuC0r0BKmMab4Jn1kHNs2okILURJYbURhTWMCubLGzsi1ECxKb0629GMzbNzCfJO2bJpklJsJRAR1y/PBN1mZQLFrYAU1KWQgK0pCC5xwyUoKCgoKCgT2a96kJAnQQFBX3yyFq7X/9ZRP4m8CHgV6u097cC/8Ba+5PV638RuA18HfADIrIB/CXgP7PW/mK1zl8ArgJfDDz+cTqVu3Tf7pAaYoBHQCgOoW6gaiFBTYyqOamG77lz53wyUzEIh4eHHolxcHDgzVbFaahBOpvNmE6nLBYLNjc3aTab3mxUw10LKuoxtA1aaFCL6el3RXNMJhPSNGU4HBLHMZ1Oh+3tbZ9yVrNXC/b1+33fPkV5qOGtidTZbOaLSSrWQ43POrpCzcXlcklRFBhjfKHP27dv+0J9msxVw7tu1KvZCqvEq/4/z3PfpvoARVmWbG1tYYxZKzDY7/c9dmI2m9FsNsnz3Bf+HI/H3qzXgpngzNTJZOLNTTVch8Ohx1YMBgO2trZ84v/o6Min3Y+Pj2m1WmxsbNDpdLhz5w5RFPGSl7yEfr/vDe9Go8H58+d5+umn/b04ODhYw5IMBgNvKPf7fX+/dbBhNpt5U1gNZzW/1cCtD1zMZjMajYbv59qn6/dVzX01gdXc1+uu0gGjJEno9/sYY/wghxry2uf1WLu7u+R5zo0bN3ybdL+Hh4ekacr169c5e/asN+c7nc5dszHyPPcmt6J9er0ejzzyyFrh1NlsxsWLF31hVF3ebDZ50YteRKPR8MVqtaDsfD5f+7p586Yv2rqxseGxMpcuXfKJfx3wUbN6uVz6JLi+N+rnf3R0RJZl7OzscPPmTT9b4MUvfjHL5dJfu9MzAh42SXGPlDasMCVVulVTsjY6tZ7cveka5qNWc9KrFKSwVQE/wSalN7clrxWFhBUKxbexlgyvfi7FoSc0ub2GraAyICsUBZXhLtYlv8Xojix3jSvf67pU10xT3VBLs9eS4v489PhFdX6a8F46FIcpoDG2JOMCczzBDkfYNHMokzyHolilvC98FolEvO7CZ60aYy2P33gnr7vwWTx+4508fv0d7v/X38brLv4B3njtbR4ZEYmAdaZ2IhGFtRTk/jX3s/XFKhWH4lAo1a2r1i1xRrqpfpe5VLd1Bri1ZO4yu/1Z683wRAwRwgLLpkl5UXOfolMih1FlRle4D6B5bIiWlhsv3eDDT52F3YJkGGENxFNDulmhVdoWk1em9dNtj5IpY5DEJa6lhOaRVLML9H5AVFqSKSy3xCe8yyq9baPKJNcZBxbM3O2raOKLZ9qoSu7nbh01zrUfllFluOcO32Jyh2bRAZtkYmuoE9cnWoc51kD7ievYfpfyqauUtkTimH//5Js4KnP6YtgvLQlwNS9JKDgsOxxkPTIbcalxxH4+oGOW3Mo3KDB0zZL9YsCiTCgw3pBuCQ5BAhwWXRY2IZGcvlkQUZLZmKltuIKkRdcVopSywpvELMqEWdlkXLRckUspSSq0ST9akEjBpcYhF+PjteKULdGZB9AVoScJX335D2F6PcrxmDdcfxsdW9CSjMJaP5gSFBQUFBT0QpIyvm+NFhxNU7a7jQfcoqCgoIdUffUqKy2ttcvn2kBEGsBfAP6JtdaKyIuBc8DP6zrW2qWI/CrwecAPAJ+Ngx/W17khIu+u1vnEN77VMFXDLU1Tn+LudDoej6Hsb+XtajJURDg8PCSKIp+61eSxJnE1vaqmqpqzajg2Gg2fys3z3Kc81WRM05R+v8/29rZvd57nPhWqaec68kJxJt1ul8PDQ8AlY3XdLMvY3Nzk8PCQwWDgTX9NzNZ54np91HTW16Ioot/ve0SMGq0bGxssl0ufblb29sHBAZPJxONLFCtSTxX3ej16vZ6/XpoCBzyeQlPHaqq22+21dLQxxrPOj4+PSdPUm7aKeJnNZvT7fc9GN8Z4o7u+b1WdZ63oGd2fpvdPTk6YzWZ0Oh3a7ba/bmr+6zEajQZPPPEER0dH7O7u8ta3vpWXvOQlPoHf6/X8dW61Wmt4kTo+p9VqkaYpvV7PI0M6nY5f1xhDo9Fge3vbt2c4HHJyckKWZYxGI59W7na73hBXg7XVavmBAR1E0H6l+BAdRNCk/8nJiTeE6+lwY4xHwmiCXfEi9QGMyWTi97tYLPxMBuV7N5tNWq2Wvwc6Q0AHcHTgpNVq8ZKXvISzZ8/S7/f97Avl7p85c4bRaOSNZDXzFcmifV3fZ/peEBHfpxQ/pNcC8O/DOidfB6nqg0zj8difb7vdptfrsbW1xWg08lz4xx57jKtXr9Jut31/zrLMp+MfSp1OStcQHt6fUtcbnLFb29wb57qfyiT0yWkq31gNcsWfVAtNZp2tGldIEmNXpnKFD1G0hI1XjRNFpNSS5KJ4Ck1o66EKqbZdsZQxzvxeZ23L+obF6kzrjPIKxLFKcper16WGSNE2OuNbHP6icKaqfiUzS7wsaYwyZJlRFiW2em4A2NJ6o/vxG++kqBLcdfNbl6lcwrvgjdfeRoklkchhUCqUSUR0V/pbFT2LqaiMbg3OZzgT0iW8rUvmAotqHYMzxlOgIUJqLQ0RlhXfW/fzRZ0n+eGX3eH4ynmXrhbIK/6zyWH4qgIO20RTg+RCRcugbKw6VzJy9zVeCjaCvGeJp+JN6axXzUKrsCa2SlwXTXEIEluZ5DUsj85M8FgTHcTRVHe2WhfwWBOTO7PbZCsj3JvgUbXO3GIj1/dMZtEJDno+aV+QMmHjnfvY+Zz/860/ya0CLseGhS3YLyxjG7OQgqv5gK6kHJZdMhszyltcbB67e1EmnsWtSm1E1yxpSeZ53OBM74TCv16WhgIhonQQHCnpy4Jx6Z7LmY1ZWGFWNkmr/Rsp6UcLCoTSmsr4djiVlmS0JCORgpYULKptIix9sWyYBh3T4E+8+HOIzgyQdguJDF/58s/H5jl2ueSN199+z74ZFBQUFBT0ya5eM+axnQ5XDme89+aIP/zS3QfdpKCgoIdTp/nafw/4ro+wzVcBm8Drq5/PVd9vn1rvNisu+DkgtdYe32OdczxAPe/Et/Kx68lKTX/O53Om06k3JNWcBnwSWJO0mgifz+eewa0ICU26qglZN2zVjFQEiTK59/b2fME85RGDK4qnXPAsyzwKAvDGnzKNldGtRt/BwQFRFNFoNNjc3CRNUzY3N/05a+HCyWTikR2KdgF8SrvVavlkNeALdHa7XX/d1HQ+PDz0+Jh6AUIdGND9qTGsRqteJz0vPV9NFiuXXE1yHTRotVreCF8sFiyXS1+IcDabeXN2Pp9zcnLisRf9fp/hcMh8PvdIEeVEK65lOBz6dLUaomqmd7tdj5dpNpskScJwOOTw8NAPjABcu3aN3/iN3/Cp8fF4zO7uLmVZ8sgjj7hOXOFe1ODVoo6AN2h1PUWOKJtaBxGstXS7XT7t0z6NLMs4PDxkOp1y9epVz/+eTCY+jQz4xPPGxsYan12v9dobrTKa69geNeGV7a1GdqvV4oMf/KBHeGgByf39fT/wpJzxOnam1+vR7XY9x1v7+cbGhv+uPHB9b21sbDCdTpnNZpw5c4aNjQ1GoxHz+Zzt7W0mk4kf2NJzVo73mTNnAJfoT5KEvb09jz2aTqdsbW0hIgyHQ4wxvs2a6rbW+ufBfD73/VcLbmr/VY3HY9I05eDggNls5ouJnpyc+GtZFIV/rwat5JPdUlsAnkltI3t3IUlTGcx2hXxQFIo30Wv7dIa1+MS3FNYbjfVouBUwtVS11IxoW6FO/H7r7qEalHWzvRBMCTapDOuiOhd/nqyKVarhfrrNqnphT91/takpqm0rTrmUYApBcmd6x3NIxpbmqCSZlUTzkmiRE42W2MXSFbAs103puqkdiVlb/roLn0Ukxie+C1tWTVzBSl538TU8fv0dRFAZzwYjMLOu75fWXUstPNmUeA11UmeCAx5xUrJKdCtZpdTl1qV4M+vMTU2Ie7Nc4Kxxz/rjX3BFnGy0SlCrGoeRf01KTWOLIuHdQIap9RWBaF4luyNcwUk1oFklvYnXk/o2XhVUVTyJDtDoPqyBqKy2q/Utqfav/rI1zvi21UCMG/CwlIkQFVA03OyD9r6lbLiUd++6uxfxJKNMDMkzB+TXb/A9T72Z92QtFjZhWKZsRwWzMuFWMcBQMrNNpjQrIzphEC0YRAumZZPCCtPSfa7KbMSsbJ4ypQu2YzdAuigTUomIsGQ1LpBLfhd+ncIaIimZlk2mZdMVPRVLZiMSKYikqpmCIaKkZTL6LGhJxsAsKlRJyXaFXtmJLP/Z5f8E0+0irSbmbBebxJStJtJuYmYLKC12PufLX/y5rlFFwc+Hx3ZQUFBQ0AtMn3J+wJXDGe+5EYzvoKCgB6ZLQJ259Jxp70p/Cfg5a+2NU8tPJ63kHstO637W+Zjqvo3v6XTqzUE1DBeLhU/4Xrt2jZ2dHZ9ins/nJEmyhtioJ6wBn9xWw1UTwZ1OxyMt6gX+0jT1aJU0TRmNRsRxzPb2NvP5HBHxWBA1WtXg1GS4cq+1TZpobjQannGtxp1iLZQtroUTu92uZ2BPp1OGwyFZlnljTg18TRtvbW3RaDR80cFms+mPpYgMvRZZlnF0dOTNSz2mJukBb/Dt7+97vMd8PvdG52Qy8YMDylLWc93Y2GAymdDtdr2xqFgMHdBQlreanZpW1sEPRXKkaeqT2wAHBwdsbm6uXWe9BkVReIN0Y2PDm8lpmnLr1q21NPN4PGYymfD0009zdHREp9Ph137t11gsFh5/Mp1OecUrXgE4M/bmzZtcuHDBG62aQNYkuKaqNUGsmBJNWrfbbba3t/19VXN+MBhw48YNP2BSFIVPEmtSXAdClCuuBRt11oCeqw4QpGnKdDr1qBFFgOhAkTGGxx57jOVy6VneysBXs3k2m1GWJb1ezw+K6AyJS5cusVgsePGLX0xZlkynU9/HNzY22NraYrlckiQJOzs7Pql+9uxZoihiY2PD9xltl0qxOjo4oilxnQGyubnpmePaP3RmxMnJib9fyudXk1uZ5vo8mc/njEYjf621T+l7czKZ+AKhOnADMBqNuH37tscUPazyuA5ZmbX1gDdikXJlOJuiVniyktUUuNRMw1Oq71N5ydXuoQRrBYz15roVhwtRk1GKyoWuH1p/rMxqa6iY3Xhshf/VWVYp5GSVzPYqay7mqTbX+d91tImmgP151Tx0XddfN7tKeidTZ3q3DzLMoiA+dM8ymS+xy6Vjdvt2FWBWF3MNcSLif37dpc8G4/jfiURktvAmszu+9Ya4M6kLb2xrAcoCh8xIZMX3Lk+NcBRaYBB80rusLrlKDfFIXGHCSFava3sGpkVOQUzEV37OV9L8UkvWE/J4vW/YeJWW13ZGuVBWgxf+nlQYEbFQagI7Z9UfZcXY9pevXJnpzqhepf8VXeJWXK0j1png9eV6f9Uo19S6zSsjXs+n1v+tQGNkMbl7YefNNym7bjDvX77xX/FfvvKP8+8+8MtktuQ9WYt3LS6zF48ZS5vDsktSXdESw6JMWNjEmeAVaqRfGd+ZjSitYWFjZkWTZRkzKxvkZUTTZGwlM4rqonRMSkPc83taNhhEiwovYjyvO8PxvAvrjltWie/Muv21JKNlMp8STyT3+JSupGxHM7ZNQSLChnHP4a947HOJdnrIxgBrhLLTxDYTyEvKToL0WkiaY4YGE0WQ59jpqgB5UFBQUFDQC0WvOj/g5959i/fcDAUug4KCHpjG1tr7fgiJyKM4Jvefri2+VX0/B9ysLT/DKgV+C2iIyNap1PcZ4C3Pu9UfRT2v4pbKSVbDVJnU8/mcixcv+kS1pmOVVwywubnpkQ2awFVMhprkmrxuNBp0Oh1fSFETtaPRaM2I3t/fZ39/n42NDZ+YTZKExx57zJteW1tbHB8fs7m5ycHBgTfQkyTxaWk1HpWF3Ov1fIK6np5Wk01NdTVrlZejiV81ChWHkiQJs9mM4+Njf/6KC5nP58xmM4qi8JzrO3fu+H0qkiOKIm+gK1O6zilvtVp+Gz0HNYittf6eaXJeedRqOgL+uqhh+eijj3pMiIhw8eJFJpMJx8fHtNttn1RW6fWqG+6KzdDrcXJyQrPZ5OTkxKek1fQcj8cehZPnOfv7+zzxxBOMx2MuX77sOc/WWra2trh9272/NjY2OH/+PFmW0e/3fapaTe92u+1T9ppWnk6n/n7p4IEm+M+dO0ee59y5c4ckSbh8+TLve9/72NnZYTqd+v6rxSKzLPPXbTAYeDSMiPhrqentPM/9PTk8POT8+fN+UEUxPjowcnzsnhVxHHPlyhU2Nzf9rIFer8f29jYnJydsbGx4Fr6+D9S816KSOgCj/azX63Hnzh1vpGuSXQdAGo0Gu7u7fpBLtbm5SZZlXLlyxSf+tbiqcva73a4vyKnvWzWwG42GH+hSrn+73WY8HjMcDv3sDp0lUB9E0oS48vT1faYFLTU9rrUD1Gh/GLVmclc6/fPpdaUQ1pPSVAZxDUHCChdRN4e9QawmYLna3qVmqxW6OeUicseybme2MsZXDdIG1xou4g1NqZLbfhVNctewFevwcXxhypUZrudWO2fdtEp0lxGrdvoXV8ao8p2jpSuY2BiXmLQkGi+R+RLKEpu6Z4pE0Sr1bSIkipyxrTuqS8RF7G0J1mIQljYjq7AjpXVpbYc+ca/XlVktWOiKVeqyRAwF1pvNp1XWLr5iSwq/HM8UB2d863pNMWyYNl/6yGswW1tkr7rE4Ze3KFoOOWKy2qBCJTWkjQhlVCXoc/Epa+1XVqBsrq67mtXKpLcVZ71emBJbFaJMqhOotfv0pTbK847vXs8PpFSpbz2O5HZtX1JaykiIlpbG2LG8O7dTbBIjtx0+LQK+970/z9vTHuOyxbhok0jBft5nO56Q2ogz0ZjDou1422WThU08qzuRgqLq01HFJSpLQ8lqWU7k+d5agLK04pcZsQxYFcPMbMTCJtTVMhnjvMWsbNA0K2xKUat8G1UXqispLcnoSs521ORPPfaHiXYdZi662MB2WhTNBGJD0YrBQN6KsJGQTHMkMSCCtJvIeLY2GBQUFBQUFPRC0arAZTC+g4KCPmn0jcAd4Gdry57CGdtfArwDUA74HwX+RrXO23A5qS8Bfqxa5zzwacC3fzwa/my6b+O71Wp5jIFyeZfLJYPBwCe71dASEb++moRqiinXVw04TUiroQ34dKqiTDSFrQUPNTl969YtJpMJd+7cYTwee9TDeDzm0qVLAB69oondzc1Njo6OvHGmDG5NWyuqQhPYypLWxLoapmo+a8p8sVgwn899W2HF/L59+7Y3g7VIpyZ0j4+PGY/Ha+Z4URQ+/VyWpTc7t7e3OTo68piIxWLhCzcqTgLw5mVZluzs7DCfzz36Yrlcsru7u1akcTAYMJ1O6XQ6dDodbyJqkly55ooyMcZwcnLi77sOMrRaLY9p0X2osannXxSFR8C86EUv4vbt2/48FouFf+3JJ5/kgx/8oE98nz9/nl6vx9WrVxkMBmxvb/vk/tHRkS82KiLs7Ox41Im2R83tnZ0dms2mx2toMl5NcGVJ1wtCarJZCznWjWAtTLlYLIiiyJvN/X6fbrfrkTz7+/u+r+ksAd2/Dj5oUc3lcumLiCqP++zZs2tm7+bmJltbWwwGA0ajkceUtFot3v/+93Px4kV2d3fZ3d317Ppms+mZ+nmee+P80UcdkinPc65fv+7vS6/X8yl3vdZ6fR555BF/r5QvPplM/KyORqPh0+CKZ7HWcnx87LnjdXNbi13qzALF5GiSW5E7OmAEblBLBzh0Zki99kAdk/IwapVgrozlyqmWUmrIk5phXfdPa0gUYWX0WVN5y5XR7FnXddOw0FRv5UKbCj/SKOkOFsiGpdtMORp1wArZuOEN6WhiMFX6V43POlNbje26gWlNVQQzsuvoErErs1vs6ruVtTR4Hf/ia36ouR8rAkbcb0uxUFTnVq0jhSWZl0heIlmB6GBNnoNxvyOsCEQRIpWhXW9mFK1jUPR1a3nD9beRV9azYT21ndmCzBYOMyLijXHP7b6H6Q2rhHeE+P8rskTRJiq1IjXtrWpVfO+9qMmfevRzMZsbmJfvMH3JJoutCBuLw5csnHFd1gYroGZgW2eCK4tbDWZbpek13e2ux2rb08jysgKQK+7kXrMUxFYmfFxDluj+akxvqPU77TqmSpuXYCNxZndDqp8d0ztaOmO8Mcxpf+iA4tpN/tcnfwWAozJiYSOupLtsRjNuZFsYKemY1BvJd4o+swphMiubvtCksrwXtlHdP9fYpnFs7cxEjIsWsVkVntTEt6nemB2zJBKLoaxeM5TWEGEpkGp59fnBpJTWeHxKaYUFDRrkmFoxgNRGdMySvhHXB7Y2KHc23f3oNbCRwcZC0YwoE6GMhaKhxWNjsNAsLRIJkkTIcjWzKCgoKCgo6IWiTznvjO8n70xYZAWtJAz0BgUFfeJKRAzO+P5ha63/gF4VuPwe4G+JyAeBDwJ/C5gBP1KtMxSRHwS+W0QOgSPgHwPvAn7x43oip3TfxncURR6JoGbV2bNnfVE6TUarmVoUhU906s+ATx8XReGLGGpCs9PpeDNZ0Rybm5veSJ5MJuzv73P9+nVGoxFPP/00rVaLxWLhDfjFYsFTTz3l07KvfOUredGLXsRkMmFvb88bwNpmLXSox9XEqJp13W6Xsiw931nNYE2l7u7uYozxuIkkSTwiRAcC9Bw1SasGtSbk1WyvF/ZUs9YY4xPAij7R/W9ubnozU5Pyeq8UGTMajTzTe7FYsLGx4fEjmtbV42pCfTabMR6P6Xa7HlnSbrfX0CiKiEmSxN8fNZTr6efZbOaTvL1ej36/71PQTz75pE9/b2xssLu7y5UrV7h9+zbXrl2j2Wxy7tw5FosFFy9eBGBvb8+zvJXjfPHiRW7evEmn0/FIEO1DcRyvDU7s7u6uXVtFlai5rXx5TW6fnJywXC45f/480+mU3d1drl1ztQH6/b4vNqr9Pk1Tbty4wWw2Y3t7m06n4xEgjUaDM2fOePN2PB4zm82YTCYcHh76gYfJZLJmjmthTr3vAJcvX2axWNDpdDh37hwXL17kiSeewFrLI488wtmzZ2k0GhwcHNDr9fw+dcaADl5om3V2RlmW7O/v+wGq0Wjk8TiA53/rQNb58+f9QIdeCzXwe70eOzs73mzXIrN63YwxjEYjjDFMp1OfuFdOe1mW3LlzB8Bz7XV/Ooig10XbpaiYPM89Guih1V30rcqQrSeczXqaey15XWc4eJ7J3YfxqW/9v5qGOONYujmNVs5Gb8653phWlHGuNWLr4ozDtMfvHl3gxqEbPLOzlmM311AUKyA3K9O7rB1Pm4hg68Z+VdTSm/4ApazM8WpjzxjXxPip8RLHdF6NDFjjUr+RpsErM97GhrIREQ0rp1YHfIoCdLDMltjSIqZETLW/0iXCbVEgRrClAVtUbG8hs5aSsmJyW29Yq9ENzrQ2GDIKSmvX1osQnwIvKowJQFljeqf3SIFHp75ntVUKLJsm5qs/5Y8Rne2RX9xhfqHNbC+iSMSjQ2xUmdL2dN9a9ZsysQ61IxXapOJ114ucIrUUN/i+UN+fX673rOpDdePcZJWpnlcB5ur+2RrWxBqHM9GaqA7P49Yrm9X+rLjzqgz3Epf4jpYlzTtz/u//+JM8k8+5km9U19AytQ3P7E6koFnhQ8ZlC4MzuCMpSW1MIrnnaWvyelY2WJYJvWjhU90FQmENG7H7nZKVMYnJvZme2YhISiLRAQ5neCO5N72L6g3RMimUkInjei+KVpUUbzkeuIGWpC6FXjaIKtxJRyIkjpF+l3zD4daKZlQl6Y0zvROhSNxgkTWQtw0mt+TdBGxCPMuQ5nr6PCgoKCgo6IWg8xstNjsJJ7OMJ+9M+LSLGw+6SUFBQUHPpS8GHgH+j3u89j8DbeD7gC3gN4E/bq2t88P/GpDjEt9t4JeAb7DWFjxAPS/UCeDxFP1+n/l8znK59EZTnRetqWbdTlPaiubQberf1UxTA3V7e5vbt2/zlre8hatXr/Lkk096BMbm5qY3wepp7H6/TxRFnuX8pje9iePjY86fP8+5c+d8Ul3NM02NajJYzb+NjQ2fvNYU9HA49CaeJtU1kdzpdOj3+0wmE0YjN5VJk9KamgZ8Uns+n3N8fOxZ4srRrvOKi6Lg5OSEwWCAtdabtWpY67b1RC04/vNgMGCxWHjDfTgcAvhErnLJNVWrCV3FriwWC8bjMcvlkgsXLlAUBYeHh/7coyjyiBpN1iqjerFY0O12aTabHB8fe060FlXc2Njg5s2bLJdLnnzySXq9Hr/2a7/GjRs3/CBAv9/3+I39/X1vAGv/ERG2t7f9cXVA4datWyRJwu6uKx6igxo6ANPr9ZjP55w7d47bt28zGAw8rkWv1Z07d+h2u2xvb/uk+MHBAVtbWwAe26Ht0cGQTqfD4eEh7XbbF2Hc3t72zOvlcskHPvABX/xVjXBFwkynU4+QuXXrFgcHB/4aR1HEmTNnOHfOFcNtt9ucnJzw0pe+lPe+973cvHmTzc1NptMp29vbbG5usre3x7Vr1zg4OGAwGPgU+fnz57lx4wZFUdDtdhkOh5w9e9b3p4ODA389h8MhZVl6Y1/7Zp1dria5onS04KkWljXGcHR05N//o9GILMs8a17T8mqAHx8fs7Oz4016vVaalldkS6vVot/vs1wuaTQafmZFURT+/fLQytQNPy3IuHKtvY+tBqL4Vf1yKWQdb6KyKxqHpm/rSIgyttjYmd6NnQWfefE6rSjjU3s3GeZtmibnOHd1AfYaYz5j+waPDdyshN9KHiW96t6PotxxH71lzfCUKsGtvPB6UctVccxVm6Fm9HtjvEp163nl4jnTWLs+MCDWJbcBI1CWYIxLABdNIZ6BSau4shGk18MuUyjcilIUIIJNHf5LU95iZJXyFoOYEmtdgtvg0txYl/ZOiNYY3Uubk7BKc6vpDatkN6wKVy5OGdwNEYrasgg3N81U3wESnDmeiFt/wzT4qpf9UczWJuVLtlic77DciCgaLtFbxqsEdpFwF+ZE+5NUSBIp3QCCR8zX+uNq8KPibNfT/jrjoIYz8ceyq9f9oE6xMs7FrLatI0387IUSbFJLlytnXo8Tr9onGZjC0tkv6D41xD51lSezJftlzxehjKSs8Ca542rbCGNLMiK6sqTEFZcsrDO7IwGDpaz66LJ02JPCGmZlo7rXq+kNHeMM6SQqvKENVAnwFZNbTe5EoEDIbExqq+KX1bmZymxf2JjIlizLBEzVBonom/l6qhyDdDuUvRZ5d/WRUlPeNnLf/ftX8O/ZomFcer4ZYc09RtWCgoKCgoI+ySUivOr8gLd86JD33BwF4zsoKOgTWtban+eecTeX+ga+q/p6tu0XwLdUX58wet7FLRuNhjeUNLVZZ+1qYrnZbDKfzz1mQc1wXa5YCEUStNttb7Atl0seffRRPvShD/HMM8/wO7/zOzzzzDPeGOx2uz5NrkX01IBP09SbYuBwCG9961v57M/+bHZ2dnzyVo1dNRWVBb23t+cZ5Wr8KXZFj6NGbpqmTCYTdnZ2PGpjuVyuFfQEvPGpBunR0ZHfhyZbtcji6aKXmljWIoXz+dwb8mpO6nVRA1qNdE1919EcipdRpWnq1zs8PPSGpA4QqJmp3OjxeOzT22rqa9FGTXqrEQ/4tLmysHXf8/ncn7+avGq4P/bYY1y6dInBYMDNmzc5c+YMx8fHPPPMM3S7XV/U9KmnngJc+rnb7fp0/snJiU9x6+yCJEk4c+aMN9+Pjo48PkTN1Y2NDabTKXfu3PFJ4tlsRqPRYLlcrhU1BbwRq9e6noTWe/ihD33Is+G1jw6HQzY3NxkMBjz66KN0Oh1ffFO55Z1Oh+Fw6BPgaZr6AQdwyfezZ8/S6/V45JFHMMYwHo99cU0d3FAmtyb3tc9cvHiR4XDI1tYWw+GQ0WjEdDplc3OTKIrodrscHh7y2GOP8fTTT3PhwgXAzVLQfqH9UtPYOouj3+/7WQhakFJnS1hruXPnDsfHx75Qpr4Hu90ut2/f5vj42PPc9d6IiB8E0oEzLcyZZRm3bt3yg1Xj8ZiNjY2HO/FdJ2ecMr3XdAobUS/sR90kZmVWSY7DfcgKJaGFBmUpZLsZL3/RLR7rH7KTTOlEKQZLx6QQO5MuEodluJluYKRkM3H36rWXnubq5hbPPHF+lbg1IGXltvuGansFk1mKBivDVM14i2NsqHfumeWyQlrEdmWkV4a3jSxUKXBNg0vlyvrUclm7ViWUkdReW6FKyFKX9i5LyuXSsb5tiS1Amcn1wpc2d1zvx2+8E4h8qjsSobSrwpSltZRSS3FXhrdSO7Ia6qSOK6lRPcisS32riooGU9h1tncGpNbQkpKuCF95+XOIH9ml2Ntgfq7NcsOQdYUyqjjs90pdq4Gtt6+sjWfUUtmnOfL+XqspW61XRtX/TW09W7G+xZ30XZz7+kyHOuaEVd/2/a1KmLtEOqvZBsVqPVMvcFmCFJby/R/iu5/8NcY1PjfAomywsAmFNRwVPWZlgwKhJTnjwn2eapqM0gpGLMsyqfAkDm3SMcsKf1JgpHSYktr/6yzwzLrENkBDcl+4smVSoEqTW0NmYwpcIcvUxkSUroilWFqkRFFJZiOGRYdJ0WJojcOgRIaGFBRlk5ZkzOzI8etriW1rXMpbr+cagsgC4hLzEgO5Y3+vvb+DgoKCgoJeQPoUNb5vBM53UFBQ0IPQ80KdqPHdbDa9udvpdDg6OvIYjkaj4XnJWpQR8MXp1IRV40zT1t1u1+8/SRKefPJJfuqnfoof/dEf5dKlS7z61a/22IN6qlqN+PF47JOnun9wKd6NjQ2uXbvGi1/8Yo+LEBFvEuZ5zmAwYDgcslwufcJ7NBrR7Xa92Vc3/YqiWDPy4jim2Wz69QGfAlYsw/b2NsYYX0hRkRNqfqtZq9gRTXMrJkIxJ1okUkR84UBFS4Az3IfDoTdp1ehuNpu+EKNeA0W71Atg6j3UAQk1txuNhi80eubMGeI45uDgwN9jwBvYACcnJz75q6b41atXPVc7z3OuXbvGlStXODk5YW9vz6NIdAZAvSjqaDTyeA4t2AiO8a39Rg3WLMu8kb1cLtfS04rs0XPXFLka14eHhywWCy5duuQTzYqsuXjxoj/fOI59ElkNV73v4/GYnZ0dut2uZ28fHx/7e3pyckKj0WB/f5+LFy/6wqy7u7tMJhMGgwEvfelLuX37Njs7Ox4to/1bZzVsb2/z6KOP0uv1uHnzJmmaMhqN/ACNYkPiOGZjY8Mn6vf29vwggg4O1Pn9ms7OsswXrwT8AE8URX7WgxrgOnND26n3R/n8ivxRVv+dO3c4ODjwMw0Aj3UZDoc0m006nY7vu1q48+TkhM3NTT+gobx5Zcqr8S8Ps5FS4xNLKWsGdh1N4pnZd5Mu1tYRCxQ1M7HmKjpjUzCpMwvN5oKvv/gbXEt32I4njMsWWRl7c25WNrwxtxHPOc46Pr3aNAUXu0Oe3t4hutGkrOEurLFILiujWs9DOeSl+Fkvd7UdTfWKM0u9SS53nbvDtdQGC0p8kUtNBptMMFmVWLa2SpxD2Y6JGgnWGFhUM75qRrgtCh6//g4AiirlHYmhsCWRGJ/yLipTWo3uwloSiarXTZXYrdLddpXoVk53JOIxJhmW1FpWT2l/Wi7hXZ1/UTE/MoQIS6oFEhESKdmOIv7ci/4o8tmvYNFvMDubkA4coqSsYSx8QloN4mLd+JR6iL82gOBN79hdS5/krpnePileGeDK8VYUid7nMl7tu9RPOfV+LqvjapssrEYFqKXJT22rhS/9fqqqn8vNiNZnvoIN8yaupwMWNuGocL+TW5KRVjHxZekM8NIaMqKVWW0d3gRb0jFLX5RStwEwUnpj2/O5paQlGQubUFpTvbY6uY5ZurR42azua9O/pqZ3ZiNXKLPEJ8/rZnrHpCzKhKWN6eP43qVN6Jol7077FMMRZplhMtfOvBUhORRNwRrBVAVBrXF9zFT31poqfc/d78OgoKCgoKAXil5Vcb7fEwpcBgUFBT0Q3bfx3Ww2vanUaDTodrvkec5iscBa6w1ELS7XarU8HxjwyBA1VhWNoCaaJnHVlGy32/zMz/wM3/zN38xb3/pWNjY2eOaZZ9jc3PQIDkWcAN5w1iS2muRnzpyh2+0ym8145pln1grmaRL38PDQF+RTAx/w5raacpqaVeNW0+pJkrC/v+/xHJubm2tt6nQ6NJtNn4RVExjwgwHNZpNms+kN8NFotJb4nk6n/lyVUa58bzVi1ehTI13Nv7pJ32q1aDQaPuk9n899klsNbx3AUMN9Y2PDG6pRFNFsNhmPxzSbTW+UgkOObG1t8dRTT/lrPB6PPRbl1q1b3Lx5k7IsuXHjhk8ab25u8uijj3L58mVmsxllWXJ8fMxoNPIJfB00UC54nuceUXJwcOCvnZr4an5r6ns2m3k0iZqps9nMm8I6A2A2m7GxseGvZZIkHB4e+oERnSUA+L4yGo08qkbRO4ql0YKgrVaLl73sZUynU05OTrh16xbXr1/32/d6PTqdju+TjUaD3d1dj6j5jM/4DMqy9HiX5XLpWecvfelLfTJd8SF6ftq/tre3fSp+sVj4+3vhwgWfwD979iyHh4d+wGM6nXLz5k12d3f9PuumuBr9Ozs7tNttPyuijpbR/qLr1YvADgYDrl275u/NycmJH5Aoy5LNzU3/XtTBDx10WiwWHomkz53BYOAN90aj4fvlQ6uasesStDUzV2qIB1PzsetokFrSdlUYc2UCI+J522Jh93dzvv97v4dfnr2ClsnoRKuZHyXC7WxQMYtzOtGSWeESrL1o6YvwjfIW7ShlZ3vCya0mJl0V4hSqFK5KU7i1xLCyoe+JOrFSFZespdc1tXsPnTZmpXRFNMEZrVIVNiwTIW9bFpsO11DGfRoHM0zecSyUKMIulng+zCkVtnTJa1tWRrcazqXHkJSUlFbN7oIITXM7jre5a58rA1z3oR7uGqv7VHMWlfusGIuljUikZNPA11z6XKKXX2Z6rs18OyJv44pYRqvrbCM8mkTyKsSrswdOIUr8LIHKSDZ5ZVLrPazdaymrlHe+Wn/NaLe1gpUVQkWPcXqQpz4DQIpqO02qq2lfuy4mX81s8OZ3sdqnmrlFQ5g+2uMvPfpH+Evv/7DbtjKgp2WT0oobBKpM5vpAkMGSSOH+LyWt2snrvSgQsjLxRS3V5O6aJYU1vjglQMu4wXddz0jpOOMVJkWV2tjjVBY2cVxx63jjRkpmZcPzwiMpq4GSiHHZpmuWTMsmrciB081kATud1bX2987W7vH6wJRbLj6hHxQUFBQU9ELUqy444/u9N0f+79SgoKCgoI+f7tsZunDhApPJhPF47M3FxWLhTVs1EMGlQheLBa1Wy5uyap4qlkOTu8qF1iSz4kD29/e5desWnU7HM67rrGhNa2u6GvDp3HqqWfESzWaTp59+mpe//OWAYz2r0RvHsUeHJEniOdtqkHa7XSaTCa1Wi8lk4o+jBT01Oa1FNtXoExGOj4+9Ebq7u+uT89ouNag15awGrrXWJ4fVqFTjUwuNatK2KAqPqIAVW7zZbHrTu168Uwtwqik+Ho994U1N5qtprmlnxdho0VH9rsUwwRmty+XSXwsdpBiPx4xGI46Ojrhy5QqHh4dcuXKFxWLB5cuXOXPmDC996Ut9Qrjb7bK/v89kMvGG5+bmJo899hhbW1vMZjPu3LnjjdfHHnvM88eVa76xseERKzrIoIMOes30PmliW03Zoijo9XrcunWL2WzG/v4+aZrSarX8oIduJyK0Wi1fXFP31e12vemuiWpNzms/yrLMm/+K+tjb2/MDIyLCxsYG4/GY17zmNVy/fp3z588D+LZtbW153M9gMODo6GgNc3P27FmuXLniDWJliN+5c8cXwHzFK17BnTt3aDQavOxlLyOOY973vvexu7vr+epnzpwB8CienZ0db9pruryenldMTJZltNttb4TXmevT6ZRms8nR0RE3btzg5OTE98XpdOpnSWifbjabPtWtA2w3btxgPB4TxzHdbtcP5AyHQxaLxf0+3l54qpu2oonWFXpAU7d1Jvbp7e9pCNdYyFAzDwvovesmV/MNdqIJs7LJZjTjKO9xnLlBk4jSGWsVnqETLcnKmKbJfQI8iyLy0nC+P+KwvUUyMq4plRHqTfeacV03N/3r4E1ub3qXalJWJ3yPvznqPGrFcSjz2WTi8ReaPobK/I6EvA2IYxbngxaRMZjIIGPXIGMtNk153YXPWsM6PH79HXjGN6ylvPVng2N8rwpbrjAnsEKbFLgUt/qyq33oz6tzrZvlaq5mGJ8kLq2wHWWcjZp89ad+MfLaRzh5cZe055jmmBXL2xpnWltTpbFrJre7L+upb0WV2CqWrul9KapEd1pbN6ktz1emtzfKT6W4y3iV+PYFS2HN9KZcme5lstpX3Zxfw7HUkt/WQFRYrDjjX8/VRpB1hPiRS7Tk/eznA8/WnpVNMhuTlbHnbOv3WdEgMQVZ3iWSkmaV6naFJd17pbDmriQ2QFMKUhvTNUvGeYsIS9Nkft96LmkZEYmlIYVLa1c9qiE5KTGGwhfadLzvyB+rEzlj3aFYjE+ju37nPvP99PXf4k//kcdWhyzxDxhbDSb4a4gzw60RbH0aQkh8BwUFBQW9QPWSvR5JJIwXOdeO51ze7jzoJgUFBQU9VLpv41uLIWqhRmVxa+pazVgteKmGl5qEij0ZjUbehFOjVtOrmg7XNPW5c+dot9vkee6NWT0WsIZcqOMn9Jj6szKpDw4OPP86SRJGo5FPr3e7XU5OTphOp2RZtsa+juOY6XTq9wd4frGmWHV9TWzDOttbDXFFasRx7NutbRQRnxbXhLGI0O12feFBEfEG63K5ZDAYUBTFWiG/ZrPpzfs8z4miaK0QYavVwlrr0RZ6PpoeV9SLJvmVEa2FAxVv0263vQFevzbgjMoPf/jDvljilStX+NCHPuSvcafT4dWvfjXnzp3j3Llz7O7u0uv12NnZYTwec/v2bXq9ni90eOfOHV9QUdnQyo9XY36xWPhih61Wy+MxAHZ3d9nc3GSxWHgTXg1iZcLrIIzuUxP+rVbLI0I2Nzf9+bbbbd+HtJ9qP9SBFx2w6Ha7fiBhMBhw7tw5P2NCzVxlhmvfbrVavPa1r+UnfuInuHHjBq961av4jd/4DQBe9rKX+aKeivkxxvhZBmma+u/nz5/n6OjI876TJPF9/vj4mH6/79ureB4taKoJfu1fyu621q6Z0YqeUR65okd0cGAwGPhUOuAxJZpaHwwGnD9/nv39ff/+12uumk6n3ljX94eiXBQ50+v1PJ/9oU98szIb60a3Gn93mYKnzW5N6nosxbOkU8QZmZ/2f1/lw+kZj1yYlY3KOEsZFy06JmWUt8iMe4+YyvwGmBXufdcyGRh4rHvIu5JHPMoC3PGVFe3RFpW5L0ZWRSq1wbZmgteKFmqjrdgVs7l2yh5/oqlxcyoNT2X4VhuUsa4nlfkbu+UNQxIbTBwh8yWYCKIIFktsnq2lvxV3Ymp2dFaVl9SUd11GhMzWy1xW+2FVlNKwMsEd91uPtVq/sGqAO7RJ3fR+UVLydZ/7tWSP7DL8ijZFszrXeJXC1yKPanpDdX+ozG41j80qrW+jatyibo7XDOm1Apa1QQ5f4JJaAjyrjPFawl8HL3Tcw88S0HtYmd4++W/X2+63L1bH0hkR7jwq09us+pf2lTIS5i87w8X4hP184Ad0irsy+a6vL8qETpQyKxp+1sOyTFzxyCqprcpshMGSlTGtKK9McWEzmjEtmxUXPK3usdvO7Wd1w9X0Bvz3huQYShY4BNGyTNx7t1y50lGVGE+qtHlLMo9U0XO00xlmueG3ydsRprBYLSJrXBHQVVre3vu5ExQUFBQU9AJTIza87Eyf99wc8d6bo2B8BwUFBX2c9byMby1cqIUPNcGq7Og4jj1aQXm/mrY1xviUs6IN1ChUZIemnfM85+LFi5w7d84bX2rEKtZAzUbFpChSQtOidZxJv9/n8uXLfPCDH/TbqYHa6/V8unhjY4M4jjk8PPRFBhXhUE8D17/UjFc8hoh4HrKa3pq8VlyJngfgU8mLxYJ2u+1T8kmSsLW1RavV8uzpyWTii4xubGywtbXli0Qq8xzwxuZ8PvdGppqkiqpQtIreC01Wqxk5m808IkZNWzXJx+Mx3W6Xoig4ODjwyXg106fTKYeHh0ynU8bjMUdHR/z6r/86V65c4eLFi2xsbLC9vc0jjzzCK1/5Ss6ePeuLZrbbbay1nD17luPjYxqNBoeHh76P6HVtNBo88sgjgGN8a8FDxbxoAliTwZq8VoM9jmOPk1ksFiwWC3Z3d7l165bvN71ez7+uuBJrrTe+b9++7dPNOuBSliX9ft+b7NrvJ5MJ/X6fTqfjmd9qWPf7fV8UU4uqKnbn5OSEz//8z+dnf/Zneeyxx7wBPZlM2Nvb8+iW5XLJ0dGRx5vs7e0xGo3o9/uM///s/WmwZFt234f99j7n5Jx556mq3tRvaLyHBigA5gCRNAVaoEBKFEWAFinRDklBh4KywhGyFEHSDIcsfbAVEiVZYYUVVsj+YCmooCCLFEGCJilQFIQmQTYgNECgux9e9xtruFV1p5yHM+ztD/uslTtvFYAHS90NvMr1ol7ezDzDPnvvk3nvf/33b00mvPbaayyXS46Ojnj33Xe13cfHx4ouEYFanO3tdpvd3V1Go5GKyJ988gneey0ye+/ePZ48eaKoHLkHRXQXYVzuWWGJL5dLFdt7vZ4mbySZIPNaxlzmluw3n881iSIufmm/4JRi9vwLF5GQtMH01hef3W6j0GUk6Klj3LBWgCPMhKsxEX/70ZvsvLTgcT5gkC5JjGPpMpaEcS58wspltH1Bx+Y0bcHKZSxroQ9C4cvKW04bY7AeWxjK1K+FyMjd6w1YvylUBjb0mo2y4QiPxetY9L7VV8/0l1n/U/Z03TdqrDWhHqa1hsJ48CnNSQW+QeYctnKYogRbz+dpwV97+HP1zpaVLwjlBddCZ2aS2rHttIAlBGZ30zwrpFaRkF5F11p4yH6VFbWZmpYdS5+Q4EmM55/5gT/O7LccUvQsed+EIo/SX1G/qSgcd1mEB5HkhI/mlorJsdDt14dVXEqNTIG1yE5UKFPaJE5zdexH7bzNto/d3YpKue30rp/bMjiTjcy3GtWhmm0VeNU+DfOi6BkmLzX413/3H+YP/M1/oGgRF4nYWWR97iQrnLc0bYnD4DDKYhexeSXFKuuLToxTJzgmYFSk8CUE4byV5PXYbxa9zP36Vz4ppKkrMWoRuzCJ7muNx2Ho2AJbF6TN6gHp2hVLF4p4PqmmkBfYVT1YxmAzG5IDqccbE6ZjnGQwpkbg+A3e+ja2sY1tbGMbn8V4586Ar56P+er5mN/3naff7uZsYxvb2MYLFb8uS6QwqUTUloKIgigRkVo42+LEBVTQlkdxu4rIKwKzOKwXi4WyemPRXIQzcfbGfHER8Lrdrrq+xTkrCJSzszMWiwV7e3sb6Id+v89sNlNmeafTYTwec3V1hbVWiziK0CYF9MStC+h5RRhdLBaKxpjNZuR5zs7OjqIvvPdkWaY/i4guAqAkEMbjMZPJRAXbqqp48OABg8FAMSnz+VwF6FarxWg0otPpKGJDBOrYAS0YE7lmwXS0Wi263a66mGMkSKPR2Ci4KbgOCIL02dmZCr3L5ZInT57w/vvv89FHH7Gzs6PX9sYbb2y4ooXnLEmL/f195WWPx2OWyyU3NzeK1BBhH9CESafTUVezvF9VFaPRSMXcNE05ODhQPMmTJ090TkqSQMTVPM+1UKfMxfF4rOPbarW0PbISQRI5kmSQ5Icggtrtts4lSSwcHh6qW1rc/UdHRzx48ECZ4r/1t/5W/sP/8D/kT/2pPwUEAbrT6TCdTjec5tJfq9WKk5MTdakPBgMVlA8ODnT1hojEMQJG2iHJhDt37nDnzh0ARa9UVUW/3ydNU3Z3d7UdIuIXRaFFLq21miyZTCaa3BFUjhQlleKskjCT+Sz31vX1td4/gkuazWY6p2U1RJz4emHDRm7bW9iGZ8TtSIC87QBX/dsCJjhdBT3iLfjUq9jYSsvAL/YW5w2L2sWdWqdOVAhO18In4ALf+DCdMq8FwsxULF0WnN9pEKfV9W1RhkdUWzM8T7xemwqakaN3Y980lmhRZVQFUxfpuiLoJuCcx3qzPibrNniL0kuMM1QNT9Ww2KbHtjNM6TCrHPICn+f8jYdfptBCnK5mcpcUVGQkdXFKS0WlOJMKT2YsmUdRJ8HJHTAnEMRvSxCzC9Z6buHXTu+sfq0i6PAtYwIz3MDEV/SN5Y//0L/Ak9+7j6mCSFx2I1EZNGmg86kWlEWEFkHarhdsrMdL5mT9WsxZ9xaqxnr7ZLV2WpsILyNiuS2hbK8d3Do36yRFzIQXvVmLXcaCvdncRpIs4dHjU1Ofv97Qeozz2maXBH68LTz5wPDhP/cK//W55Z86+3kA9tMpF2Vf2fatjY5xNf4nCNzC8I6RJoIeARHEHSufkQETX68wq1q0bMFeOiMOOdbSZSx9pq7+zFTMq8AMT3Aqgid4ZY5b42masha8q5opnmvbQrHNlIlL8KsVdlkXF2+k2NxRNe26z6LPm41HX4vf5a37chvb2MY2trGNz1C8LQUuH20LXG5jG9vYxrc6PrXwPZlMVCgToRnQon7i5hSGdbPZVMerbAdsuMLlnwiggkvodrs8ffqUwWCgbmV5TYTx2H0uDlAR0YVfDQEZsru7y+XlJb1ej9lshrWWg4MDFYxlXxHUxuOx8rZvbm5YLBY8fPiQTqejxT1FFJQCnjEzfLUKy/eXy6WK/K1WS93egkmRvhTXN0BRFOpuFTdwWZbcuXOH5XLJcDhU3MNyuVS2ugi8EBzQaZry9OlTrLXaF1I8cX9/n+FwqHiVRqOhQr6IzXIt0qfi+pU2T6dTLcgoY2ut5erqSlE3FxcXvP/++3z44YccHh5ycHCgwn5ZllxfX9NqtVSkFYa4914d7HJ9Ipq+99573L17l7IslfEtTPTRaMTl5SXHx8ea1BB8y2KxUJSMiLVyDGGCP3r0CAhCvBTjFByMjJ0UeJXtZLwFByPOdCnSKaI6wHg8ptVqcXh4qMcTxEqSJNreVqtFv9+n3+9zdHTE48ePOTs74+joiB/7sR8D4Id/+If54IMPePvtt3n06BHHx8eMRiN6vZ6OmVyHiPfiwpa5sLe3R5Ik3NzcqGgdF+aU6+t0Ojx8+BAIBSoFOSJOfWMMx8fHTKdT3V8SRJK0yrJM3exyTxhjGI/HHB4e8uTJExWwpbjpbdTJcrnk7t27mkQ6Pj7myZMnKsZLbQFJ4LzQjm9Fmfi1WlgLg0QvwS3kxK1Q4Tzex4K3Xmki4t5dFBmJcaxcyqpWF1PruNe44euLYz3mvGoEvEMtdgsSRSIzFef5Dt3dBVWj8Uy7YgxFzPf2CRtuZOMj13HsUvZsYFtu94XWFRSEiQFnQ9LXJ35DqDUejDUq0EONQWkaVgbKZhrQIKklMwbrPNZ1+f2f+x381ff/LgBTv2Liareuh7515M5rmUsZniByVxscb+V518UsJQqC2L3B8b4tPLIWzls2oWky9kzCH/gtP8jDf/YA11ijRNTxHiFBNGESrRQQcToWybWQ6i1dU7E10c8QRGxXj6VL1yK0njtBC4tWdl3IUk3R9Vhr0cqNQpTr+Rq3yURFNjf66DkrI0Tw3uCMm1DkNIj1YaXCRz97j6//o+cAvNy8BmBUtenUwrEkg5rGUbhUHdvO21DslCB4i3CdmUo533PXZO4a7CQLTTYVPqkLUyYkz/nVrsJyWfQ3HOcOQ9NlZLYMKJP6vcSEIrTAxnstE9osKJaly2iYiqVP+LGv/xR/6Pf8kTCGZQPfsCEhUniM92sBXFZO1P0o7H2z5Z1sYxvb2MY2PsPxTi18f+3xVvjexja2sY1vdXxq4VtclMYYFfoAFU1j4bvVailOI+Z47+7u0u/3VdQUAVRc24vFQsXAg4MDdnZ2WCwW3Lt37xkBfbFYqFAGwY0u7tjpdMre3p6eI89zvv/7v5+zszO+9KUv8SM/8iNcX19r2+/evavYi8VioYKfXGOz2eTevXvqvs7znNFopP0h6JGiKJjNZnp90+lUtxEH+/7+vp5HHNSNRkMZ3nmeq8As/XtycqJOZEFAiEtcnkvhUAgCp+A+xNHd7XZpNptaFLTdbvPo0SOstcpEFreuXPNgMNAkg1zDcDhUod85x9OnT/W8cWHLb3zjGzx+/JiHDx+yWq1488031UUsbv3Dw0MV88XhLmOYZRmdTkexNA8fPmQwGHB5ecknn3zC4eGhOoJvbm4AdEyk/w8ODrS4Z6fTUbyOIEbE7Syitbjdd3Z2WK1WWvARUGe+IE8gCLRS7FSc8WVZMp1Otf8hFIYVdrw4nYWlLgKzFMOUBIY4xmUeXlxc8L3f+7383M8FPMK7777L6ekpDx484OjoSJMstwuuyhwQVJDcywCPHj2i0WhwenqqxTubzSaHh4eK+3nppZeUFy77pmnK4eEhq9VK+0ec3SKaixgtiQ2Zr5JIkOtqt9s455Rtn6Yp+/v7XF9f64oICMkcEeal4OXV1RUnJyc6T2VFRuzuf2FDRd612KQCZFRMUJVVe0sAjgTv+FiGteANIhgaSDyX5zvM7zb47t4Dfml2h91sQatGJJQ+ITUVg3RBZoO4lpmKm6KjzG+AzFZMy4Bt+MLJOT/bHZDOzdptLo7siLvsslrgrp8bUYQlYic7BBRKhMK4LcgKj9q7+jhxP9Z9uSGeRi56X4O1K2FhJ56Vs7g0o2paWoBNLD4vWPggIo5cxaOyjTWhuKDwkyVaplIsRatmNifGq3M3UUe42XitingkMswVhmUt+jsMHVOBgR956ftJdnfhzjGr7+7h07Vz2ye3xOyo76paHJd+97UY/AwqJu7CSM3XhEoSJTEcJOLy9+tEh2ugCQ0RymMBu86jrJ3a8fylRvJESA1Fo0QJkjV6xWuCyNv12Bvn1232a4E+iLjre804T+9jw1/7m78VgH/od7/Hdw8ecpX3KNIFO+lC0SFzbTgqiM9dA4snqQtdynywNeZEHOCTqsXKpyqKN23B3DVwNQqnY1dkpmLmmkyrFtOqSekSxa40bcnSZGSuCvdqfc7K2405CAGNklivSarch4KZltCeuc8xs7AKy3Sa0ExIlhWuaeukW+2QN2aNwomTEelzMm/b2MY2trGNbXxGQoTv+9cLRouCnXb2a+yxjW1sYxvb+J8qPrUytLu7qyJXnufqlJ5Op4q/EO7zeDzWwoJxIUrBoohoOhgMmEwmrFYrRU2I67iqKk5PT/m5n/s53nrrLR48eKCs5t3dXUVOLBYLBoOBOkhFNBWXa5Zl7O7u8ujRI4wxKrTJfuIiFzSDiLxXV1cqFMZ4FhFjx+OxiovCxK6qijzPFcHhnFORUZAtjUZDudnStrIsOT8/V8cvoBgLccW3221liWdZRlmWFEWhYvNwOGS5XAIhKRDjSbz3inERZMjOzo4mK8bjMWmaKuNcCotWVaWFIkXEPDg4oCxLLi4uGI/HXF5eqvA8mUzI85zr62smkwkPHjyg1Wrx+c9/nv39fcWriGNeXNoyVoLpmM/nnJ6ecnx8rHPq3r17dDodjDE8efKER48eKWKm3+9rIkNQM1mWcXV1RafT2eC9X15ealJGxGARi3u9HtPplIODAwaDgSI34gKewvuWaDQa5HmufHFjjDrvZQ40Gg06nQ69Xk+Z1yKyi3gviZ+9vT3tO0GAtFotdfB/93d/NwBf/vKX+YEf+AHFlohzvNPpcHNzo67ybrfLarVS/IzMhzRNKYqC6+trjo6O9P4ThFGe50ynU8bjMb1ej3v37un1rFYrjo6OdOzk/hOESZIkys+HNcde7idxuMf8/oODA/I8Z29vTwtuCn4HQjHM3d1dsixjOBxq/+7t7elxpD+vr6/1vnxhoxbmvPW1+BeJSqLRxS/d1pwioVxxFmqP9et9DUiRRjtLGJYdXm89ZZAuebjY5bA5pWlKGrZkVjaxxnOYTKm8ZVy2qLBMqya9usglgDWeh4tdHk13cC2HmSaKbZHT3xbpTcBph2bVbuA1ekQOHF1zjN2w0XYiqlvWhT2tXHsQzH19LBXsrAdniEzrofhiGjrWD4IbuGoYoEMztdjZQgtZXlcZn5QhmTOp2rRq9ETLFuQ+oWXWqx5apsBhyUxJ3y432NGNiA8u4nf2HHhyUV/w2DfBLnglMSTHR5SfO+P6nQ5V0yhuRBnmemG1YBkJ18rIviV2a+Lk9nyTREu9XYwwUdRIfKwIdfI8tnhcCFN48xtjEU/biC3u4/nh2Wi/Fq6M54tdb+etISlCMsY1DKb0G0K9Tw029zSvwgF+9v1XsG949htzVi5Vl/bKWy0EK0LzbcQJoOK4uMQzUzEnrJQoXEJBQi9ZRRiTst6vydKHP6yrGkHkMDifUAnj2ztcfbMkxpFFaweSWpwPgruvky7yXkCjhHYVdEwjFG+FgPZxPhS3lPHduGc9zlqM9yp+P/shtI1tbGMb29jGZyd2Ohl3d9s8HC5493zMb//cwbe7SdvYxja28cLEpxa++/2+IgzKstTCkuKmFUf2YrFQUU0K3gHqzpaic8PhUBEW3nuWy6WKXSIg/47f8Tv4y3/5L/P++++zt7dHo9Hg6dOn6hgVljKgjlXhNIugOBgM1GU8mUz43u/9Xi4vL9nd3VWxeDwea9FC4TunaaquUym42G63Fd8yGAxUvBTOM6DuYUAdwvG/m5sbFXOljYLhkORAURQqtIqwKgL5YDBQIXE4HDIajVTYFDe8XIMxZqOIYFw8UfAT4nwWQfHg4IAkSRiNRipkC49aWNsQ3N03NzcMh0Pu37+v53369Cmj0QjvPf1+X0VfKewozGvBWEifjEYj9vb2uLy8BEKiRZzZkkARFvjNzQ0PHz5UR+/h4SH9fl8Z4ZeXl/T7fcXBCL9d5srJyQm9Xg9rLUdHR7rSQITroigUKSNCsYyPFMuUPpCiluIYF3SPXJ+4x6XwIrDBoXfOcXh4yGg04vT0VPnsMsYXFxcqzourGuDtt9/m7/29v8f3fM/38LnPfY6vf/3rijfp9Xosl0vlpgvO5vDwUEVicZ+/+uqrPH36lMViQa/XUzZ6mqa8/PLLej7p69lsxmAw4Pr6WueWFESdzWZ6T0g/xfx3caUL81zus/l8zs3NjbrJpSin8LrlXpKElTGGXq+nmJU8zzk8PATg/DygBSSp9MJG7MyN4ragKIJkzKrW99h0yHq7dl7H6BARtZKl4W/88tvYz3tOmyOKZsJ13iEzFaOiTeUNRzXmoXAJhU+YlU266UrRKBWWlUtpJiXXsw52aTed3M+hIQQB2mCq9ZviTPYGFbDDG2wUMiQSTkXbF375Zl+aTXdqLYzrGdNQBNDeOo9rgE+MHtNWCZg2reUBP/L2/wKA//dX/zqPqyVXVY+5a5IYx8w3qbDMXJOuXSmj2dYX0rUrhqYgMyUNU2Ej0bsgFKjs2BWJXxdULHzC0mcMq/D5VfiEVqPgUZXDTp/h5zsUfbM2Lkdjq4VMb80XZWFLH8YJiqgLbR71qand9JHoHRcUVbf2LaSMzDstSBmPhwjysfH6uYL2uo0uqdngrI+5sSLitss9vp7Sh3mRgKlqBriDqgmmMiQrj0shm4aTt77R4u+71/iuzz3kC4NHVDWaBNaon1WNO5nToHAJnWTN0i5comO/dBk2cVjCnCt8uJf2sjXbW8TugD8JYnh8LIBV/SjFNQsfxPPKW5KoEGfLFMr/LnxKYnxYlcAai9IyFZYG7jokwa0xJFmCt01S53GJpWrW93Llaz57bSxITRDIX+AFOtvYxja2sY0XI94+G/BwuOBrW+F7G9vYxja+pfGp/9SQApaCcxDXpmBBRGiV7cQtK8LZbDZTZ3WSJPT7fUajkYrKgjsBFPuQ5zk/9EM/xJe+9CVlKwsGwTnHfD6n2WxSFIUKttZaFaYhoE56vZ4K4vv7+8xmM3WsN5tNhsMhrVZLhTkp3ifCnIiigDLGRWTu9/vqdBVGtaAYiqJQZEfsdJ9MJsr4loKCIo5OJhMV/wUbI6xxEUrF2S7okjzP1TEr1yzID8HNSNFFKQwpiQNhQEuhyuFwSFEUXF1dqTDd7Xa5ubmh0WgwGo20YKcU3RQHrqAmxHUsc0RwI5PJhL29Pd1X3OppmtJqtbRYapIkOhbiVD84OODm5oZms8nJyQnee66vAzdV5pswrEXoB9RBLdxtYYaLYC1tlcRBVVXM5/MNsVnmgTjFxZUvc0KSAzJmIi5L8VPBcIhLXeaMYH6ECZ8kic7bV155hZubG95//32Oj4+ZTCYcHR2p6P706VPefPNNvvzlL2Ot5ezsjOFwqMx4Kf4ovPA4kdLr9RgOh4oOaTabXF5ekqYpw+FQk0VyvbGDXVzcsp8kv+QeiXnqcp8LwkZWO8j+ck/KtrICQeawMOzlM0E+e5IkUZ74fD7fKF4rxwEUefNChjgsn4fNjYXrOp5xz8bCsR7PR+5v2XF9PFOCedLkx+ffzT/9W3+Gjs2Z2SZPVn1yl7LfmCvmpCKgFPrZkoQ1T7jwCaVPuFl1mE+aJOLQrQyRtrtuU92GDcE+EkaNj0TvumjlRp/E7OaoQGLcPyrMuuh5vG/URxvtkH6uHcgug1XfYiqo+k3SOycA/HPv/BBuNuf/8eFPcu0aTFwLaxxLl3GUhGKgE9ei8CmZKSl8ytJlzFyDljUMqw6J8WSm3MCe5D6ha1daFLEgYekaPC53gOAef1TuQXpDUS+/tWWNLxFWdxolESzKPzeRcB0L5XEx1Tix8Izx3Ebvy7wTsVkE8bo4ZezMlvfEfa24k+h4wvV+Hldc8SUR9kQxLtF4+qjt6ji/fR0mOpeFqrXun1pTpmqGxjdGwAdNvto44+j1Kd/RO2fpwvfUZdEjwVERxPAmJc4bxZlkpqKqq9WK8zupRW9xiTdrDneMvgFqN3nGyqVMqybOW0pvKVxC6S2lS0htRWYrcpcyrY/lvKGZ1IzvGqNicTgsLVPoc4CMisJbSipc/flumk1slpKkFqyFTgo5VA278bkS+t3j0nXCZRvb2MY2trGNz2q8c9bnJ772hK+ev8B/o2xjG9vYxrchfl3CtyAaqqpSAUpERGEaDwYDFbfiwn4iihVFwXg8VseoiK+C6zg8PNRj7+3tcefOHc7Ozvjbf/tva+G8brerrOXZbKbuXinQlySJuj2zLCPPc0UvFEVBWZZatFKKR1prtViivDedTmm1WipGikgphfuEpSwCdZIk6raV7QU7Is52773yuwUZI1iGqqoUNyEJBeF3i5grDPSdnZ1nOORy3Ol0ys7OjjpwZZvd3V1FzJRlqQmB2WzGdDpVsVkczIJDidsaJxdGo5EWCwWU4yyu8qIoOD09VVFZ+mm1WqlD+OnTp+zt7VGWJbu7uxsu3evra0W7XFxc6JzKsow7d+5w584dbZsI8MJRF9H55uaGXq+nTvJ2u83FxQUXFxcq1N/c3CiqBlD8DqDXJuiZNE3p9/sAOpeF2y3s78PDQxXshQsvBTgfP37Myy+/rImHLMu0DwAePnyoCJePP/6Y4+NjFYl7vZ6KuYvFgslkwtnZGe+//74mhcTZ3m63OT095ebmhvF4TKPR0P5pt9ssFgt2dnZ0JYMU07y8vMQ5p3gVQbXInJaEgSSqvPcMh0N1fss9J0VvxW3e6XS0WGtRFCwWC00ozGYzvT+E+y0Oepl/Ug9A5pGMx3Q65ejoaCNxUVXVhtv8hQ0RH2umcyxiP8/FCpuu3GcK/N0+9i13uLi+TZHyX/7C9/E/e+MjumlO01bsZgH/dJX32M3mlM6yqoW/kkSFb+cNhUsY5S38Iq2F1aCIxlxnw1rsDGKrV6euoiziAosRkmMDlSJOcrnOWPCOL/05gviGkziRjQzeB4czFqjA1MKqS4MrvWwZikGGqcJ9nnBCOprwL3/XH6CazvjRT77IdVUxsWn9vqdrchI8ed3phU+YuWYoLGgzFbkLn7L0GYFGYln6TJ25wa3r6Nrw2VZ5y66d8/mspGwleAtlK1xf1VzPB5+gqBHXiBjeUd/F80lfi/v11jy5nTgRzne8ny3r8YoFbdlHyDMxskbn+6223UKjbIjksbs9co/r/Kk2VwC4xATON3XhTRHPk9rVXv9G5Rqh4Kk4yl0G2Rj8e21+rncPh+Fua1iL0YbSZxTeKpomIXC2F1WGs4ZZ2aSd5FTO0rJFcH3jsXiatqRVs707Ng+oE0mA1M7yuWtQ+oRFlVF5Q+4SSmfVRb6q6hUX3lC6hHaSq7Be+ITEBNFbjpeZUl3hiXEsfcJ1teIv3A8FW//YK7+bxBoS7/GdVujndloL3KZOYIRBDAVO/fOTdNvYxja2sY1tfIbinTtBU9gK39vYxja28a2NTy18x25jQUCIqCpogzRNlfc9nU7VGQwovkQY2sLfjdEbgi24f/8+u7u73L17l36/z/d///dzcnLCz/3cz/HzP//zWkgQghDX6XRoNBpMp1N2d3e1TQDz+Vy37/f7OOdU3Fsul+oWjcV8EeLFoS4M7NVqhXNOhWFAed7tdluF+YODsHRJCk6KACju6rIsVdiWwoOCABGnbYzOECe9tFkEb3GMAypIA5ydnZGmKScnJ9r3UnjQe6+uXcG/yLnkeiRZcXR0pO7r+/fvq/AojvRut6tudgjFJY+OjphOpwyHQ4wxWmhUEgSTyUQLiIr7/OLigoODAyaTiZ7PWqsIGXFSi7tYWM8i6APq2J/P5xweHtJut3n//fcpy5Krqyt1KAtnWubg5eWlOv/FUSwJkNj5Le1YLpd6DGmDjIM4/CW5Iu0ry1L7A+Di4kLnbafTYTwe64oJwf9IgdijoyM+/vhjZXWLmLuzs8NyuVQG+E//9E/z1ltvcXx8rIK6iOEPHz7EWku/39fVA/v7++qklyTSw4cP1d3fbDbZ39+n1WoxnU51TkiSRhJJxhgtTipJCRG1Ze7GYzmdThWzI/eErN4Qx7tgkCTJI2GMUc4/hCTI2dmZFrI0xigOaLlc6gqIFzEUx+E3RUkVdUU0dhEiIsZCCM9YRcf6vrmlT62FQhNY16YW+x43+Jn56+zeHfOdR48ZpAsqLM6jjGPBm1jjGJdBBE5txdWqw9NxD1OYNf/Zbrpr1TFavwdrJ3CMxdhw6MboDLv+eYM9HbnkBb9hbom0wgHf4E3XRS298XWhRQO+7kZxfdcCatUw5IMEW65rBSTOgffYPGfHtln5GYkvEXqLCKLN+sKdKenbnMJbOtQrRurGFD6hwgSXsFyat7TslAYV+8kUCI7vXZvTMg2yaUm6TLGlCbiOMlyfiLu2CNcghSxvi5QbSQbpu6gPNXFQj5kpo3G65bBWgdqskwaa1CB6JIjdytauxzBuX5LXbmI2kyDxzxtub2rxugyPzqzPrc731ECN63CpwRYeU4Jr1sdLWa8eqAcwqaBsGzqPPfkX9/k739fgC3fO2Wksg4BtPCuX4Gql3BmDdaGQZOUshbe4qklaFzolYaP4ZIxO6dg1IsVhgmjtDZU3pMZR+TU2xRqvPzsMuUvBljT9GqGSmZLcp8rzzn1Ci8Amr7ylMCkJnoktqOpt/qtP/g5/5PXfg01TDGATg08tNrVhvOxa/JbioXER0W1sYxvb2MY2PovxzllYdffekylF5ciS28VUtrGNbWxjG9+M+NTCtzhgRZwVnrIIVOK4FBSGiFDi2IwdsyKaipguzm/BlogzfDabYYxhf3+f/f19vv/7v5/Dw0N+/Md/HAj4AykUKQUxRcAVEbjX6zGfz7l7964iINI0VQ71xcUFzWZT3bkiQAvSQgRMEWtFABQBUhAiRVGocCpiXYyAyPNcHakiboogLf0i/Sn7L5dLLe4n7ZD2iag4GAzodDpaKFLGStjOgpKIuejWWi1AuLOzw507d7TvRAQGFNkiAqwIlPF1jEYjdWPP53MmkwmffPKJCtjL5ZLJZMKjR494/fXXgeBaFwe2CPL9fp+zszNarRbX19fK2BasTbfbZX9/n6dPn3JwcMDx8bEmHe7fv89wOMR7r87i8/NzTWSIYPzqq68qp15Y3uKkFgSI8OkfP36sgrugY8TZLUmP2Wym81XGV0RYmffCvBZGdcxTlyTS/v6+FpeUefTLv/zLLBYLLaYpAryEFBoVEf3w8FCTIsJul3GXYwsrXXAze3t7WmxTkiuSOJBkgYjWMu9hXah2Op1yfHysqxbiFQe9Xg/vvd7nMt9EzJb7UxI/7XZbneXiEm80Goo6kZDPFlld0O12dcXCarXi+Ph4g83+ooaK3rFDOX6MXLCyXVwQMLxZi4L63KyPZzxU69eCkBjEbxEqG9cJs9EeP32vzefvPeHtwWOwwdW9qBqU3jIrG/TTFVkS5s6oaHM+GzAftknycGyXAtbjnVG3sU9uiaZRm/G1sA1rPEkCSWHqfULbfSzuS7/cwpUo4sRs9lUs0iKFFyPutzceWwY3q0vAevBVLYjjcQ2Lq+/ntoFkusJkGV6+t0wGFCzxZADekxioqB8j0d4Bed1oh6FlKkVeFN7WfOaAwQDYqYXyhnF1ky3Z+ZCe3aNstsh3DGV7LQibqv4X/azok3gesRarN5zcPuojwBa+FoiNisS2Cv0U96eL5qOK2zH/W+gYEdbEZejcthX4xGgb3S1etylrp3ZVj3Et8mt7YI03ifEoHrwx+KwuphnjXiKXuy08ZUdEXWmfoXnj8V/u8eXZK3zfWx/RSXOapqoxJB5bZ0jK+oa03lPWQPJV1cRmnqXLtKBlyxaaSJKfmzYkBzNTsXQZmakoTUJZr/5IjcMmQfRuJwXWODLjGBYhASXIk6UJ+3bMqk5cGVr1sStv63kW0Dpzl7LUDEKJX61gtQJjMO1mfc/4NSpI3N5Rkm4b29jGNraxjc9y3Ntr02umTFclH1zM+Pxp/9vdpG1sYxvbeCHiUwvfgrqQ4nTCEgY20AgibBdFoWgUQDEX4g4XDne/3+fBgwcqzEIQRhuNhhbru7y8VB7wm2++yQ/8wA/w1//6X6fdbrO7u8vOTsieikAnIh7A+++/z8nJCZ1Oh3a7zfX1Na1Wi6urK2UKx+71GOkg4hqg4qAIkSKwyr5XV1eKGJEkQa/XU3e1iIVyHkGNiLAnbnAp4Chs5TzPN4oCttttFUClv8UxLogZKe4oSBFxaIsD31q7wRufTCbqEn755ZfViSvJiKqqGAwGFEWhxxKxf7FY8OGHHwLw4MEDjDEcHBzQ6XQYjUYqgh8eHpLnOVVVbXDdV6sVu7u73Lt3T93xw+GQR48e0Wg0ePnll9nb22MwGOhzwX9IP4sADqGY6WAwwBijY9bv97l7964Wbjw/P1dBWua0IHHi5IY4qmVspI9knnY6HS2qKnNdxkuOv1qtGA6H6owXjvp8Pmc6nWoSyRjD5eUljUaDvb09Pv74Y87OzijLktVqpQJ+XCT2yZMnmoAS97iIy6vViqIotOgnwHA4ZGdnh3a7TZ7nOg8lqdPv97m6umI2m+k4x3MH4OWXX9ZiqnI/SD9IEkNWBcTc+/l8rkVErbVaIDfm2csx5f6N0S7j8Zhut8ve3p66ucXBPh6PNZkWo5jk3nshw4Otahd2/RzYEL1h7azdEI8lagFYHN16HBNe9NZj4wKCxm84yW1hoAB/3uKj9j5n7TCW1nh1oDZshTWeWRUSRefzAVejLuQWU5l10cG67er2rsVUdWc7g0/9+vqiIosqOiZeRdUYd7Hhcq+vcaPYZ/3clpGz3at0Fxzdt1zj2l+C44ic9j6pHc9RQUi8h8Ri0pR/7N738Zc++WmyWtmtatHbAjaYfbG14F34IDomxlN5g72lHmaRDTup0RiubowFMgNTt+K/+O//Av/LN/4RDhZv8OS3DfDdtXNZ21kFx3dNqNkUwG8VpJTX9PQmiJ46h1iLxsqNl/CbGBEAm0sBSY9P1n2rzG45X+wkF5G73lywIyJO+6R+r8b2xNcpiJVk5alaRkVyRJgv64RGPY4+rfE2vsbB1PttFPSsz1U1DbaA5DrjwWSXe/0hLinJXYI1TrnblTcsqox2UlB4y6xo0LAls7JJaYO4LW5tcX9b/Ib7GwIjXpjhhUnqlQGOpnWktiIxnrbNmVZNSm8VjVMRilwGVEqTrAaYV94onzxsF8555Trajr6Z8pcefIk//NJvJwHMokWSJWCbmNRQZTY45+sxtKXfLCi7jW1sYxvb2MZnMKw1vH3W52c+uuGr56Ot8L2NbWxjG9+i+NTCtwirp6en6myVApYiZmZZpjgQcYbHwrFwwGMn9WAwUJE6dn8KQmKxWLC7u0u73abdbjMajfiu7/ounHN86Utf0nMKXsQ5x2w2U/Hy4OBARbiqqri5uSHPc3ViCxbh+vpaOc9ZlqmY5r1XHrWI+XJdIr6KMCgoldilKkgHEaClKKUIhXFbOp2OOot7vR7tdpvVasX19bUeJy4qKte0WCy4urpS4bvZbCraA9jAhBRFoTzlLMu070UA/frXv06v16Pf77NYLLRQoff+Ga67nP/09BQIQv9sNuPw8JCLiwtt98cff6wFQQ8PD1W4l7bP53Nubm5UVO50OhwdHXF6eqrbxy7z8/NzHj16pNcn3PUkSdTVvVwuGY1GNJtNXn/9dXZ3dxmNRjx9+hTnHMPhkIODA93WWst8Ple3OQRWtyRDRqORJneEwd1oNDg5OVFxd7VacXFxoYkKcfIL71r6zlrLzc0N19fXmkS5c+cOzjkeP36s7v/z83N1VIv7X+aWzAVjDL1eT/svxuVkWcZkMlGBfzwes7e3p+M3m830OkQwPjk54eLiQldoyDyT+/ji4kLvzzi5IPfIcDhUd3eSJIzHYxXYhT0uqzRkDsj5Jem0u7vL/v6+Fk+V6xXBfj6f0263abVaDIdDde3HqzWkDS9qqPCKuGj9M69vMI6jAobAWtythTW/hmnXO/hwrFj09YFhLSKfywIOIp0bqnf7/OTqTXYGM3bbS17u3ZAYT+4sv3h1xnAa7qnVtAkri8kt3OIsu8RDajawFOK+9taHApgivkcYjZgHHbAj9YuRKKtdEjmTpV82sSpe+3AjWWA23c7eeow32g4jQn0Z3MKm8tgyXEg6zTHLHPICkgRcFcoIGoP1HmmONLeor7+IGl55Q4Glpaouz0TBprLogLk3FN4Bjv/s63+LP/7SkhP/nQy/o0/RM+QDgxNudRYEaSsCeErtbEYTDXF/qeAv4nQaJQOqgCHxtnZOZ2vnr7rsPRsOanWJm/V5lM0tj+FSsLLao3Zn3w7jPRizxvzouNUub+/BBdROOg/zuDRhPF1WTxlbC7YJ2qY1GiggY2p0fThFhRZyNA6SFYxmYd73myssnka7op2uSOtik67mfI/zNg6DSwy9NCBucBmFD67vlU8jNEm1xqCYCuvXn4PB/e9UMC98os/byRodlhkXimpqcU0DPsXWrO+lt1gcSc2dmfvg6N614XeQpbdMfcGPPfgSf+jV34lNEqwxeGtxrTQw6DNb35c+OOi3wvc2trGNbWzjBYh3zgb8zEc3fO18wh/+nm93a7axjW1s48WIXxfjW/AVIqQK3kS4v1JEz3uvGAdxfLdarQ1nbqfTUScooE5QcUXLucR9KuKrMIrffPNNjo6OuH//PtPplIuLCxU/j4+PFRESi9ciposwHrtCheUtbRWxUAr8CQ5D2Mki5IsI1+121TEsIc5YQWV0Oh11w4qjXPpVRF1rLVmWkSSJCsHdbled5sKyFhFaHNLi0Ja+FPFQsBBFUej5hbUt1ykYDBF2Bfkym802GOgiuuZ5rsJlu91WdrXsLysCBAFirWWxWPD06VOqquLy8lI55CJIy3FeffVVZrMZd+/eZbFYsFqtSNOUV199lclkwmAw0NdkPsmce+2112i32+pAl6THw4cPefz4sWJXBEeyWCwUQyLtFbyIzHnBblhrSdNUxVV5X/okng8yPtKPh4eHWrjxzp07dDodsizTNvV6Paqq4pNPPlF8idxjIhhPp1NdBQBsuKnjIqaj0Yhut8udO3dYrVYqCM/nc3q9nmJ9ms2m8rtbrRaTyYTj42N1hcs9E6NxAC2GKtgUcaPH962wtReLhaKFZL6VZanObBHUO52OFpoVBMvl5SVFUej9ZIxhPB6rG1wKdC6XS8UDidNe3PUxnuVFC9W9anHUY57LZn5mPxWDI7d4HSrg1gK4CtAuEjlr8VkdziK6e7D3W1zvZlw3HOPjFsZ4ijJheN2Fola9KoPJbRAMa3etMLXlHB7WvG8tiGjwiV8LkFGbpT/kPeWai4AaCW5xUUPFV9zKn0T5gFrRrQtr6jGM9osgUdbMZ0iXnmzmSed1fYbpCpYr/HKFXyz4sYc/w8RVFJHoDWvBu+4SZXoLwiSrpfHC2w3ndyIMZ+83Xpf9XP3zxHl+9MFP80dfb7Jr32L8uW5AdfjgaPbUrunakY1fF3S0sXM7FqajApOaVBGjryQAfBCgN7apBWlfO7+9M4oaiRErxq0TEWvXeRDUbeVx4g5nvX2MtgnzwYfETt1OUwVXuS19uO5oO1lJoU5xOW8aHztaHRGtJrCS9CjBNyBZGZazBhPraKUlzaTEeUNaW9NTU2GNCwJ4fczSWVZVGratM1Xi7s5dGrj5NjDdw1xIqOqfrfH0klVghBNQJiKUC3e/l6wofEI7KVQ8rzDY+lhN48jrCp4NU4J3YCy5D07yvG7LxGdQFeR+xV/88Iv88Kv/MBZIvMfsdHFVQmoMVdPircFYHz47trGNbWxjG9v4jMfbZ3WBy0fbApfb2MY2tvGtiq3HZhvb2MY2trGNbWxjG9vYxja2sY1tbOObGO/cCcL3187HL3Q9om1sYxvb+FbGp3Z8A+zt7eG9p9frKQ4CgqtaXKeC0JACi+IMFldmmqZcX1+zv7+vzmnhSIurO89zVquVujbn8zlZltFut5VNLa7ts7MzVqsVr776KsvlksvLyw3UiOwvxfeGwyGr1UoL6YlTtNvtKlN7Mplo2wXpIo5XKWDpnFPHe9xWa61+iTnnFHkh/G9xjQOKiRGMilyjOLvFsWqtZXd3V4tkxhiZyWSizmw5r/DUZSyEzywOWsFQCGpFXN5ZlqkDX5y20gZxiss1FkWxwSIHFLEhKI3j42P29/cZjUY8fPiQDz/8kPv376tjd39/X7Erh4eHdDodLRa6u7vL3t4eBwcH6myW4qlpmnJycsJXvvIVIKweePvtt7lz544Wh1wsFrzxxhvkec43vvENvvGNb1BVFS+//LIiSBaLBZeXl1RVxc7Ojs7R29cp6Bi5TmFmTyYTHQ9B3gi6A4LjeX9/n8ePH3N8fKw4j+PjY3Z2dnjw4AGj0YjpdMq9e/fY39+n0+kwHA61X2WFgGB/ZO7IWOd5rozu6XSq/X98fKxjmySJrhoQh7/gdHZ2dhRbInN0MpnQ6XQ4PDxktVop41yuPV4x0O12lSsuqybE9S9IlBjrM5lMODk5wRhDt9ul3+/r9Ukxy/l8zmg0Uqc9oCswZO7kec719bWy+8fjMcvlkv39fb1P4mKgL2REmA9gzcqADVyIMpL92kEdaCCbDkwrjkxBeIjzVs5Tc5G9NVi3ubvBQwnpKME1LFezPWVym8og1mZlaItTvcaHxE7ujYKTimSpN7abrm/Bn8h+WjzRycGfRZ5ssrdNjS2J+zW4U630lzNrV3jc31E/K0Kj5lwnuSddCJak3qiq8JVj6UttUssYivp9yVIXdeHKzMCy7uQkamDLVOTeUmDJcFTeqGPYYdZObx+KX0ohzI4tua4q/p9f/1ucJH+XP/QP/RCdL7zE8I0mq11DTAyxReSeV/d13cfRtYsL2iuoHWzUD+q4FiRJjNtJokdhp9eFJ33N2fZ2E30Tto/mTu3+Dier3/MBryFt8InMH2qUSXB7Vw1Dkvv1+NXM8ioJhStdGljdZWtd4NXbtSs+yeNGgRR3tHWh0LJtYJqyoMWkUTAYLLHGk7uUtHZhly7B1mz23CU00uD0LurKn6U6uy2zsklqKiosnSTUv7DGYY2jcCkdm2thyqXLyGzJqi58mRhHZkMhzBSn28lj7CB33pKZkqUP+zocS5exm8z1cpc+YFjmvmTlc/6Lj36KP/r6PyL1XzGteiWPT3GppWrYAK/fxja2sY1tbOMzHm+d9LEGrmY5TycrTgatb3eTtrGNbWzjMx+fWvgW5IIIpiKmShE9wUcIrkOKLgpDutFoqKAtwrTgDrIs4/T0lOvraz2fMUYxIyLsiggmwp2gGfI8V7H33r17KoJJCPLi4uJC2yMoCRHQsyzj4OCA8/NzZR/HuJS9vT2MMcxmM+UaSxJAcCLtdnuDK5znuSIqBPvQbDaVtV1VlYrnsq+1VtEigq+QtskxJaSgprRVBNc8z5VdLWMiYrqcW/pBthWRUXApMXolbo9zjv39fQBFT8h4drtdjDEcHx/z+PFjFouFFjxstVrs7Ozw8ccf895776lwO51O9Zh5nnN8fMydO3cUgSG8eClCOR6PFbcR8+Ml0VKWJa+99hqj0UiLjg4GA1566SXFllxdXWm/i9h8fX2txTKdc9onq9WKTqeDtZZOp0NRFFxeXuoclXkk2Bkp7tjtdpXrfnJyouKs7Ctturm5IUkSLWxZVRWPHj3SpIBwvmVexRgWuWbpJwiC+Hw+58MPP+T1119nb29PRXmZz9ZaqqpS7vjOzg55niv/W7A5Im5LYkrmhfDeAcUHCe5I5qvMOWF/y/6NRoPxeEy/39dEifQRwGg0YjabaYJJEmfdbpeyLGm1WozHY5IkUTRKURRcXV1p38s90e+/wAVjYoxHLUiv8RysxdmYf/2c9T+KR4kF7vg91q+JIK04CkRU9yoMBh3N4DwgiAq3eQxTmfDeLe5yaF9Qr13qa5E8FlEN3ovgGgRrb30Q7D24hq954T4U3rSoWC6XIQiV8EKNNKr3V453XQzRC8okQlooK10wH54IyxEe06UnWTrssj5RWeHzPPwrCxJEzA6PMe4kpq4UPrC9k1vKb0XgfTtvmJOSGYfzpuY7+2h/S47FeUtlHLgUazxdSp5UC/7Tn/uvOUy6/NA//se5+cKAxXFgXtsSLTIa1VDcnB4x5kNE3zjZYjd58PE8NFXdt9KPt+atS2o+uAkCtZMiiXEj4jku+Rq7Hjtnorl36/0YbWNKIAnX6VJDUnjF10gmwniPXYbXXFoXtmwGFrkwvrGQFIE/H/DcQTRPJxa3ypi2W5S9qRZ9hYS8hqs7TC1eN5iXDVLrFFdSOssqCduV3lL6hNJVrOrikxYfxGtb1smSOoGZOBI8ST33K29pmhJbP0+E8S0YHVNR+ESRJ5kpw3wyDkvg/CTG0aiPn+AoaiTKxHmapuAvvv9T/OGXv5+kqjCtVijSmmdUnQxIqZrbBYjb2MZvmoh/h9jGNrbx64pWlvD6UY+vP53y1UfjrfC9jW1sYxvfgvjUwrcIqzGPdzab0el0VICT4nvNZpN2u70hfIv71FqrBfuGwyGNRkMdp1LocjQaqTgnbtM8z1WwTZJERfKiKFQAnc1mOOeUkQyom1iENykaKWK9tZZGo0Gj0VChbTab8fTpUy04KQ7WLMs2HK5SzFEc2cK2jkX3PM8ZDAbqJhbxWIRISSRIkcLBYKACvw5S7WAVUVpctCLwyfVLMmJ3d5fVasXR0ZEWOOz3++qaFiFXxkSKRzrn2NnZ0URAmqbqEhcBVPpYxH4RkyG44efzOcYYjo6O1N18cXHBkydPlGvearV48uQJk8mE3d1dDg8Pubm5YX9/n+vray3MmOe5Ft0UrvhwOGQymXBxcaGMbxF+7927h3NOizi222329vaUb/7qq6/q+Lz33nucnZ3R7/c5Pj5Whvvjx4+VuT2fz1UMz/Oc3d1ddU7DWoQWfvv19bUWNx0OhxweHqqbP01Tjo6OVPjN85y7d+/qvXBxccFwOOTtt98G0EKs8ihJi3hJnBRJFVe4JCvk9V6vp/P1jTfeYLlc0m63+eSTT8iyjP39fS3sKYzy0WjE3t4e3W5XeehVVWmy4+LiQueXtZbpdKpFNmUlhQjU0tfGGL1/pX2yuuLg4ECd3tfX17q9fFbE95EknPI8p9PpKCv9wYMHuppCuN8xa/yFjFti60ahQHlJeMyRsCjb+3TtkN4QbiNB0Uei4cZ5Y862sJpF1KxdwbY0OPzaxizHqdYs8g3Rvf7nbTimceuGuawWKKXwpPHKJw+Cfv1zff1JXjuezfoaJZTt7Vm/+bw/7G8JpLeF3TU/eu0UNiWkC0gXwe1tl0EVNWUVCcYei6VpPM57KjwJQfwWrTWvC1lqU7xRdndifBDD8XXhwbBdjqXh3cZ+wneWC1n6lIyKGSm5d8yN59rN+PG/+p/xB3/PjzD8vhNcFhzOUtgyiL23JoEkCRLqjMt6VYGMiSYIiBzX0q914UnQB01uAKR5fW6kUKRXl7c4w4XBHa9iEDf5Bo+9qh3hMdfdBPf5mndfJ2zqAbaVDwJ30JMpWzVfPmaY1+zyeO444dF7sHmYW+nU4JpQ5AmLMqOXrShdQgmkxrFQd76ldOEEpbOULsFhWJUp87JBI6lITcWiqgXvunDqTrpg6bLa0V2QmZIKS+U37dVJ7QzHrX/OTIXzNrwezZkET4XF1ikZh6VjV7RMOD5Qz7/w+0iFYeUJxS7v/z3+yZd+B7ZyYSb2OtjEhCKntz9LtrGNbXx74laS+7nvb2Mb2/gfFe/cGQTh+3zMD3zH8be7OdvYxja28ZmPTy189/t9daRmWYa1VnEnxhgtZjmZTNQZHheXE9doWZYMh0MVnkWEFuentZbBYKDCrgiygkvodDqh4WnKdDpVkUsQEyKEi+i1t7enrmURU0Wonc1m2u6yLOn3+yp0ihtbrlkc77EDVfALV1dXdDodxanIdadpymAwUBFe3LHSHnHpdrtdFSilDVI0VLYVhMpsNuP6+prpdKpCofSFOFyNMezs7GCtZTKZ4L2n3++rKN3v91ksFpq0EHdulmUYY7QIpvS9iJByXSLaDwYD+v2+9rW1ln6/r0Jkt9tltVqxt7cHBFxFlmXqBP7ggw8YDofs7e3RarVUHB2Pxyqw37lzRxEhH3/8Ma1Wi36/T6fT0ePe3NzQbDa5f/8+u7u7fPGLX6SqKn7Lb/ktzGYzdemLqF6WJcfHx9qmTqfD6ekpFxcX9Ho9RXKIgJ1lGcvlkvF4rIgZQPt1NBrhnOO1117j8vJSCz5eX1+zu7vL0dERvV5PsRxXV1c8evSIRqPBq6++yi//8i8zm830vjo4OKCqKsV9iDPaGKNjsLu7y3K5pCgKdb9LsUprLdZaRYNIosB7z9HRkWJrpBikXI/ct41GA2MMJycniluRgp6np6esVitN+Mi8FAySuOBlrAFd0TAajTQZIMcUt/bx8TGLxYKiKCjLkmazyXQ63UDuiFAvRTqTJOHm5oZ+v6/3iPSJzO0XOm47u28Ls7GYzObfsjFWRAoVbhxThN54J3lNCh3a+rWqdlebgCGpDaJrxImJChS69Wm0aOat824U3fRrwTI4h2ssSd1gX4vhPvXaFkVoWF8jM0RdDWKkt7UgL4K16H4uFmLXfXdbqFe92Qdh1BaQLD3Nkac5LMmmJenFBLOo52dZ4mdzXF7wXz34e6y8o8BTeU9iDBXB3Z17S8M4ksi5XdSDlxjP0ie4KDFW3LLwV5jg2o2EzAqjGIsKQwYsfUJiPM4bWqbik3LOX/7J/w9/6Af/GcZv77HatVoAMsaJSPFHQYsYH5ISoa+jIRM3fGLWuBRbi8Hqko4VY9ZidnQsbyBZ+XAO2Vzmci38erP+mUhg9ybgSlSEjsV5EfTr7cW5L25tGX+78BvbmwqqJnXR1eBol2TLeiVCNFeMJ1kZjDMUBppJcFFLcUvnLe2kIDUOi6f0llZS0ElzpkWT0qWU3uJccPN3GjmFS2jY9e9dSyc4EsO8bNAUYfpWxdaqFrgFbQJ18VTjaqHbqBDetOvClwB9uyQzpYreEBArLXV/e3JvWXoHLucvfPxTDGyLf/zV34EtCpJVgR10MVvH2za28Rsjfi0X99blvY1t/I+Ot88G/OWff8RXz7cFLrexjW1s41sRvy7GtziaJdrttvKwhSUtzGYRtkW4AlTUFLyFiNEiwgIqDmZZxtXV1YaTVXjFMTJFXNQi/ol4LKJymqaMx2N1xQpnXK5nsVgoK/vo6IidnR11N3/wwQfqghaHK6DbCBJDHNTCChdUynw+p9lsqkN8MpmogC4ucu89zWZTnbIx61xERWnv06dPef/99xkOhwyHQ7126TsJ5xyXl5eKeBHBXFjZi8VCBfB+v89wOFR8hbjPB4MB4/FYhXxhQ4vgKPiMZrOpyQAZE3HlCu7Ge89gMNBzTCYTdYPf3Nzw5S9/mVdffZV79+6RZRmdTkdFWElWPH36FOccRVEwn89V8IWADRmNRuzs7JBlGbu7u4zHY37hF36B09NTXn75ZZbLJefn5zx9+pTd3V12d3dxznH//n2SJGE0GtHpdLi5udE5IXzv4XCorwkfHYLjWxIDIs6fnJywWCw0WXN8fKyrHtI0VWSOONcXi4Wy5A8ODtjZ2VEmvDC5nXNcX18rHkTuJVnFMJvNuHv3rvLUJfnz0ksvcXFxwXg81pUE0+mUwWCg6Bq5z2QFgDjQ5f6W5JMkudrtNtZa5XsDKlQLFqaqKl0BIisHZN7LHBfnt1zHP/gH/0Cd5cLPl7kMqMguyZjFYsF8PtfPF2H1y0oMaduLGs8Ixs9zZhO9fgsPoWK3iNzRPkaEbaJj1O9tvB6J7YH9HNjfzvhwKj232RDaqQ2/Pjruxnl+JZe58LylEXUn+MTr/oEJHlzA6maPrdrG107lWliNRW/PBg9cTbPi7I6vtxZCkwVkc0/rpqIxKkmnOXY4w8wW+GWY4361wi2X/NjDn2HiKpbeb+COCx+43hBEaQgIC4fRxyrqeOF2VxgauFoQt9r0oj5GS4TKWty0Ef97WTt7xUk+dSv+0n/z5/nhf/iHab90wOiNNkUv9INLTD0nzNrhHzn51UkdjVeMt8EE8dm49bgIcsZbSER4lmTKeqhwWXCcm6p2ipeBse2SWkDfcHzLfDBERve1Ezxy+xsHScQhF4EbqLniHsGuGBcSOj4N5xScjokSN84YDH6No6/7KclrdMyoAXfCuCbGs6pSUlthvSGzVRDAbUVmHM2kJDGeUd6itJZlmZFaR8OWZHViZFVjUgqf0LQlzhucN0xpYo2nadcCuMVT+IQOkCUrdXUXPgmJkXqgKgwtU+K8JTEFXbuiwm4gTiQSPBlO2fKJ8RQelh4yHAUL/uKHXwzok6LEpAlJukWdbGMb34y4/bW8jW1s49sf75zVBS4fbYXvbWxjG9v4VsSnFr7n87m6Q4WlK4KXuEHLslTRLUaEAIr3EPFTRGHh+YrLVIRBcXE/ffp0Aw8iBTEFE+K933A+i6AmYiPA5eWlitxZlqlILyKdOF+leKHwnaVwoLCQBcEQY08ARVcII7vdbgNBGJ3P54okkX4Udnmr1VIxcDqdqpAtx5U+n06nvP/++4xGIx4/fszNzY06j0WIFUEa1txuQZJAKMQoQrgI08vlkizLlKcsfbNcLrU4oAjesq2I8IJIqapKRVFB0UghR9mu1+spHkeE9aOjIzqdjnK/R6MRg8GA+XzO5z//eWWiS1Kj3W4zm80Yj8fM53MdMwgYnk6ng/eeg4MDXn/9dS4uLgA20DSSmBCnfpIkvPbaazx8+JDlcslXvvIV7Tvpf0lASOIkToAIWkYEXmlPs9lUN7o4q3d3d/Heq4v73r17WGu5uroiyzL29vYU1fH48WNGo5GOp9xbcq/IOXZ2dnSOCEJFCl3e3Nzw3/13/x2vv/66iuGSTJhOp9pmGY+dnR2MMUwmEyCslFgul0ynU9rtNvfu3QPY2EbmiySXpGCsFK2UJJUUw5QVCTs7O3pti8VCETG9Xk+RONZaFouF3seyqkTc6uJmF6669JGMiyR/XujwrF3Xgn14zhJlEbmf+/5tRIWPto11quhcyhePj+lYF68Tl3Z9bsFShOfrBpj6pCrAgwqfytr2bGBPlO0dXYe6st36+KZcH19eE3e4qdbFLKXQZm0m30wOyDWIm7datylZerIZNCcVzcscm1ckowU8ucAvV1R5AS4c4Mce/gyFr5jXSR5HELuBGncShO2VT8hqtbbABnGStVtbnLmAOsLluTVOBU0JEcCtcer8trUILvtKgcyJdyyrFf/l3/mv+CPf84+T3n2d1a4hWcmAR/MgSnaYFVqcUozILt0UmW3pN5IsPqFGl3g9pk+CyO1NEJ1tUYvjruZ9R3PRJesCkzF2J3aKW78WteUxnouxO1vd+4Ukg/zG/NZxr0V+l67PL6K7rcI+Os+J7qEEkkloXDfNQ4FKaxikS2ZVk26ywuJp1vNAil22klLd+r10RWYctkbd2Hpe2LpIZlYXvSxdonMhzBNHap26wl3UkTJ3Cp9QeUtmy1r8LtQx3reLiOu9ZogLasd5o3NWXi8wzJynMjl/6ZOfDuJ3u4XJfl0+jG1sYxu/ztiK3tvYxm+ceLsWvj+8mjHPSzqN7XfgNraxjW18M+NTf8oul0vlRAN47xWLELudAeX7ijgl24swCKgjFgJ3u9VqMRgMtICgYA8ERXF5eclwOFQxt9/vq4guzGERvpIk4fDwUM8rTlcRskUoFpzCfD5XvrG4pweDAYeHhyqgSnFCEQzF7d7r9ej1esznc7Is20CdCP96MBiwXC4VuSFicZqm7O7uqugvvGYRpauqYjweMxwOaTabynwWYbnb7arbXnApcs3GGJ4+fUqn0yFJEhWOjTG6rfdeRVARjmPeeSysS7tiLIokB0TYb7VaeO/pdrs6TwAVq8UdLQmHu3fvMplMaLfbfPDBB1og9Jd/+Ze5c+eOFli8d++eiuDi3J7P55yfn4dJXDv/G40Go9FI2319fc3h4SHdbpeTkxM+//nPc3l5yS/+4i+qO/wrX/kKy+WSTqfD1dUVEJzrwg8XtAYEvnWM7xGXdKPR2HBCF0XBZDLBOcfp6akKvtIn4sDe399ntVppQUr5F4vekoCYz+cb/HdBegg25ubmRp3jItivVivF8MhKBEEWJUmizuq9vT1dabC7u6uO7MePH2siR9ou/PB2u72RDNrd3dWkibjSx+OxJqsgJCFkdYT3nvPzc+X4C9Nf+k9QKnL/yT0pTnBBDElhzKurK2WISz/s7u7+Wh9rn9nYQHCI8FeLizHlwIM6wp/LYY5RH2vj9Oa5xMVqaqd2cmt7EQXr51aEZnXcbiru8fl8Ytac7hh1ETnZfbCTi638VkHE2p0rP0dC56btHC2oaSuDqQs43t7+NsYkRqGYMoi4poJkBY2po/NgTnJ+DWmCvxnx197975m6JRZLZkJHzX1J4R2ZsRTehwKCBLRJHNb4GldSfwbUYrcI1eKuFRE8/llQFesOZAN5IoKnOMNFAC/qKqUzV/PDXY5fLuk+XJL32hSDuohjETnib/GytWBlbGM363kTHNub4rWtlX9vwTVCMUhTemyNU6kaJpxHMCY+cmYT3k/qIpOmWju9va3bUUaOcEGYWLC5JIkCP9zbWsSuonsqanucYKmy0Ncy35M8up9ih7sMgQGXhQmbrAyFS7QIaTspaNpSOeyFrUhwTKsms6rBospo2JJBY8GRrbDG0bQBlRLG0ehjQJSEx8QG0Vvex1is9zp3bN2JkgipvK1XFFg6JnC8ASxBLG+YipYp6NjwuSx4kwxHy3gSKpomJHIyAxMXcZV8mE8/+skX+WNv/AA2Wh24jW1sI8T/FG7t9X7mmVd+1RPL5u7W65+6MVuv+Ta28SvFUb/JUb/JxWTFu48nfO/Le9/uJm1jG9vYxmc6PrXwLQUQhe+c57k6lAVZIMKTiKYiBEuI2xnWyARjDKPRSIV1OUbM9hUB/eDgQMU0EcDEJSsivDjRb7ddBPP5fK7F8QRxMRqNaLfbWrBRhGZhVouzVvpAsCriQBUOt4h2IlqKK1swGePxWEVKYU9fXFzgnNtgTpdlqRgNwYsImqLVaqlYKe9L4UMRgk9PT3V8BCMjaBlJSAh/HFCBXZy2gmKRAonC3s7zXJMVIuoLxkSud7FYKFdcRHlBp4iLX85RVRW9Xo/Dw0MWiwXvvfceg8GAV155RfnkzWZT3cRlWXJyckKr1eLy8lIF5YcPH1KWJY8fP+b09JTT01Pu37/PYrFgOBwq2/zx48cq0ApfWuZBURRcXl5y584dFYXFHW6MYTab0e12dY4AOk8lESOMbZkLsgJgtVqps14c6GVZqqgrRUGfPn0KoJgQYwxXV1ckScJLL72kr8uYOef0vplOp4zHY50fcmy5FyXB02g0GA6HinuR1QuCGIq5+UmS0O12VSgHePz48QbiJssyptOpInsODw/1nJ1OR5Misr/cnzc3N5oMWS6XNJtNLi8v9X1BrIhoXhQF19fXTCYTxRUJ8mg6ndJsNhUlI+eME20vXMTu5BgP8ry/PW+5dIE1zuRX2i+mg0Ru142iWIKNEF3arQVDPa5hU3xmc19pk7rGTRCYBRUhTnNTmfW2iQidYdvw5FbRzNv8cGnGLbEeD+l8fW22DIKo4jl8KFYpmnJj4uq+8DSvV9gPH+GLcD/4xYKpW7L0FZnxuFr5X9WPc1dRASu/Rppkxj3D6o6d3RAEceeNitzJryAwuOcI3g0cOfa52yamCsf0hjkpLSrmOP6jX/r/8idf/d30u9/H6LUMl5nQL5lZJ0u8JCHM5nwAbMy5lv6/1fcy5skKqkZwe6e1kOxrEdyogzycP+Zth+KRgQGuTm+7PrbMb1sjabyLBHADHrMuwGnW7ZKVBj5dby8FNG3p127x2vG9mcQRd7gPOJY09I0pPUU/jOHKpbTrKpiFTUhw6tROrFPutyBorPHsZnOdA/Iofb3xWr192xZaKFNeC05xy6qGsmemIjEVWf0PoGkLWiZ8/3dtTsvmyvZuENzm/XpQCgx9Y7UdlfE4oGsdNfadCmgZQ8fUgrd//rzdxja28WvEc75C/8fpzM+kt9cvx9/xv+5GbWMb24jjnbMBPzm54KuPxlvhexvb2MY2vsnxqYVvcXaL81cc1iL0iktUikUKj1tQG7dFKWE3d7tdFXalmGRRFCr8Cu9ait71ej0V14Uvnqap4k9un7csS1arFc1mk+VyqccVHrW1Vt8X/rG1ltFopMiU+XyOtVaFT0GBiBO6qip2d3cV2SIhbRDMhoigSZIo9kOu6+rqSkVxcX/HhTXleCIAQ3DNi1Nb+hSC4Defz1VAl0SFOJJFXNzZ2VFXveBlYpFTkhkQ2OuCiJHioZK4EHe0JAAEfyN9ba3VZIEI2dK39+7do9frcXNzQ6/Xw1pLu92m2+1SliUHBwfqlt/f398oTiohDt+7d+8CodgloBzvx48fa4JBEhVPnjyh3W7r+M5mMwaDgYq/8XVJ8c2joyMmk4kysCUhkGUZq9VKndFJkqhjWYT3wWBAURTKEBfczWAw4Pz8XItiSr8LPmR/f19RIQcHBzoekgix1nJ+fq6oGuGnC0Lk4OBgwwkvbnBxbGdZRq/XYzwes7Ozw/n5Oe12WzEhSZLoPJU5N51ONZkyn8/p9XqsVitNMMg5YizQ/v4+ENz0T548YTwes1qttCDu06dP9f6QPri4uNDPi9FopJ8fgpGZTqfqhpfCt3JvyLFf6DA869a+jevwazEv3k7jVxLK40f5Q9iuX4tFQmmHWZu2azZyeG9D143FdiI3dc3vFmO3XIOymQmucBHAwz63ml3rgSKYWnn/Fl9cBdIqbJMsPY2JJ5vVvPkazZHkjmRekkxWuE6GKRw2LwOOwznMzZgf/8X/ln/s3vfxV+9/ibnPmbiKAsBXGwKgNEO6wtYYk8on6qIVJ25mHLYWpCEwvW87vGMxOy5gGYfsk0QKbYxDWfqaE82a+QxBFP23P/h7fGfjZ/kDf+x/w/SlJst9G8RmCMUtxa1fF76MHf+qy2oiwm/ytes5KY56bw3p3KtrPFn4IDwnaFFN1xClF6j52toF9VtJ4dWtH+Np6k5Qprirx9/XyJSNeSxJGF+L8s3QTpcGh7dLavRKVEgTgtgdVi+EtolQb0ujBUCbSUlmK1JbUYr47RNSnCYrMlsF1EnN6W4neRCn7XqyV94qiqRwyTOiuDWexAZBPYmsnA6zMcZSxLJlchyWjl07vuWxa3I6tqBrSvrW0KxXMWQkNM3618uSiqbJmLu8Pn7CyhdkJuGfuPt92H72/ATYNrbxAoWJPjT8rSVWz3wVGwPWrH+W72HnN7c2shRL3iP6bPrVsttRCHpqI4m5Xm3z7IXEjf7/V4H/1Ar7NrbxmzbeuTPgJ9+74GvbApfb2MY2tvFNj08tfFdVxdXVlYrR4hIWQVyQB+KUzfOcZrO5UXhR3NsxW3i5XGKMUWFauNIieI3HY912Op3S6/XUjdpsNhXPIVxfcXeLaCnCtBS+E9e2ICMajQaHh4fqppZHcQULAkIQICLkCvda3K9SeLHb7W44voGN65JihuIgFuEdglAruBNx78ZJBeFFS/vSNNWCh0VRqLhojKHX6204YWOmswjgNzc36kRvt9sqzs5mM3UBi2BflqUmNURwF7Fc+lIEXelrEdmleKYIw+Kklv6S5MTZ2RnD4ZCbmxt2dnZ44403uLy8VEzNw4cP1XHe6XSUNS3O8Xa7rUgdmS/NZpPd3V3u3r2rSYBHjx4pjzpN043jXF1dsbOzo+MZO9qljwWhMR6PVdyX5I2cQ5z11louLy+ZTCY0Gg11gt+/f5+yLJWXL8kUgOFwSJZl6iKXJMt0OtW5AnB+fs7BwQFJkrBYLOj1epr0EAxPo9HgwYMHHB8f8/Wvf52DgwP29/dZLBYcHR1xdXWlqxwE4SMFPQ8ODrQgqoj9MmbiLG80GkwmE3XOt1otPvnkE52jMY7n6dOnuuJCiq0Kr3u5XKp4Lv9ms5m6tkejkfaTJId2dnY0YSQrSQR50+12X2zHdx2KN4ncpxtkkE19buPPTME6bL6Iis6xCKg7R07e2NEbY1dihIi//Q0U/2Ed/T0ehNFbsoCNzkEQEYPIvnZ/Qy1k3nIdx+2JUSWCMhFnbrKC5tiRLhzZqMDmFaaoBfBVgVmsYLnCnOdQVfi8AGNwZclffP+nuKwK/vzH/z0PShGTLQ3jsKw1CwdUPmgLc79ZqFJwI+Lwdd7UhQLXOIrMVCx9qs7cWPQWbvcGA7wWwZNbmQFXC+ixczygVVIq4+pzleS+QcsU/A8r+NH//P/OH/2n/yVc0qFsR4P4HNFXL8tEuRdDwIgIC7tcO6yDsI0iS2yNEamaNee7DOeqatHb1BxtTeJESRdtmVnzt+PiliKqS5FKU6znakh0mI1kjXFB7PZJrbVHi8y8rfEvVdhPXts4Z91NSY1WSVaG1DqKWvBeuZTUBT63NZ5F1YAkD/xu42knOe2kqJ3ZjqYpI2Z7peiSzfE1ikIBFIFijScx4dzWBk63NQFlMrALWrbA4ujaVb1PmFNdk7Nvc46SlB+597vCuaUmQ6+LSVP8KseXJX65wjQy8B6f55hmM7xelNhWhum0IU2eafM2tvFZj+grVYXv26L3plAd/WjNWtg2pl414W59j0bCd330zQPLLwHPEZo3nkbn9pKh/BUu6PkHuHXFv1rE7duK39v47IZwvr+6Fb63sY1t/AYKY8xd4N8Gfj/QBt4D/oT3/n+o3zfA/wn4F4E94O8D/7L3/ivRMZrAvwv8M/Ux/hbwv/XeP/gWXspGfGrh++rqSpnGgAqj4poWMVoKTgLqCIU1dqDZbNLv95nP58o3FmfmarXS90Q8FSxJs9nk6OhIhW5xUYsoKK8JKzh2Lff7fWUNi0gtQpk4XkV8lUKI4iwWx6q4V8XpLCgGcQ2LE1bEP7l+YYAXRaGudkFhzGYz3Vb6t9/vM5lMVEAvy1LFPHEdC0u72Wyq0H90dKRjI3xnObYIgSI2i4NeRHRx9IpoKoI2oG5tEc9jxrTwpSWk8KEUWxSUxc7OjhbDhODQlmSA4Gt+8Ad/kJ/6qZ+i1Wrx4MEDPvroIz73uc/R6/UYjUZcXFyomC7z5fr6GgjFEiWRcHp6yqNHjxiPx5ycnDCfzzk7O6PdbnN4eMhyueStt97SxMWTJ080EfD48WO63S6PHz/WMWs0GlxeXjIYDLSApMwdQYWsViu63S69Xk9XMkwmE2XKS9957/Hec3Nzo1iPs7Mzrq+vVTgvikILXUpfyVhNJhNl18u9I/NG+O1StFPuBcEQyfs7Ozvs7u4q7qbf72uiYz6fc3BwwGq1Ynd3V+e8rFAAlBcvKya63S4XFxfK+TfGcHBwoPdRURScnJxwfn7Ozc0NNzc3HB4ebrD3BY3z+PFjFdpFHJd52O12VTQXvFGe51xfX6u7XPpfrutFDhESn3Fyx+K0r41ZhrXdWERH+5y/a2//DRrpm/6WuzbmbJtbAqSgRnzkEL+Nw9gwrMXGsvp9W5hQJNGBS9cbS/HBsL2phVCzIZD7hGCzFrf4rWuyxVpAtUX92sphS4epHKaoMEWJmS/xeY6fTPF5zl/++KdJ6wqeY7dk7j1z71l6w9KnJHgVsAuMFrAMRQEDB7nyRgtWbhSirItM2luiN9TFBzHEEG1bC9WhMGZChQ0CunEktcc8xqWImBk7vnOSDfZ3OFeKNY6lz2iZgvuVxf7cuwwa7zB6rUXRMSRFEKON8+tER+Xx6XOsi24tCtvSr8VlGUsrc8mrIzsp1u5vcYp7S2C0i9v71jmo544tWSdV6kKUxtVTuxa9BUviDSQFKl7LqoUqldchXYRjKHaHIHhXiVEkynpehnZ6E/ooKaCokSnFTkUrKdS5XXqrSY7gvi43GN5NWz7j1pbHaqNApaXya9FbfhbBPDGsUSZJSWZLTaa0TE4/WZDg6dsFfZuT4UiMp288+0mTf+qtfwzTaJDebePLEtOua7qkSVj50GxgKgfdEt/vgrXYosT12ySjGVgLqxzfbeOTZ1clbGMbn9Uwt54Ec3T93SWfUcaE+0jE6/AuWiCjdndnJiEl1E5xPhzG1/L5el9ffxYaPb/H6Pfq5ldv+L/xZrOd+pbB1PtW1q8Pu+E6/9UuXC/41+ilrei9jc92vFML3++eT6icJ7HP3HHb2MY2tvEtDWPMHvB3gL9NEL6fAq8Dw2izPwX8q8A/TxDF/4/Af2OM+bz3flJv8x8AfxD4Y8AV8O8Bf9UY833e+2+LO/FTC99PnjxhMBho8UIRvgW9IWJnq9VSDreI0ICKZSKWV1VFnufKf44FbxGUi6JQQc05x83NjTrIhcEtztNut6sCIsBsNgNQvINwpcVhHeMbhFMsWJFYtEvTVAVXEc3FIS3bGfnFlLUgCSjPOXa+y3WPx2N1wwraI04OiIgtfSTub+FKt1otZaLfZpqLw1YE4ul0yuHhoQqKi8VCr1Xc3P1+X9uepqkKpdZaer2eFmsUYbLdDvY+YZBLu2UVQKPRoNPpbPDQJQkynU7p9/ta3HJ/f5/pdMr3fM/38I1vfAPvPT//8z/PT/zET3B4eKjHEbd5o9Hgl37pl9SJ/ejRI/r9vhauvHv3riJL7t69S6PR0JUCWZaRJAmPHz9mMplwcnLCarViMplwfHxMp9NhOBwynU43nPLi5JaijxDcxYeHh+zt7WnBzjzPdb4NBgN9LuMn4y2rBz755BOdN81mk4ODA+Vx7+3t8eTJE52HzjlFkMQYIAiC9Hg85uLigp2dnQ1EyGAwYDabKUde3OySvJGik4AK52VZ0ul0tO9ljOXemc/ndLtdHj16pGx3Oefe3p6uuBBh/fr6WvEm4tyfTqfqhi+KgqdPnyoCSAptyhyWBILghJbLpa4eAbT9cq/I+bfBujDjc7An+mdl7IQGdctuhH/+z7HoHdXMgzI6pvy7JZDrsZ632vrWNub2+9F2KrCKi92ZDZHfW1HPNy9qo+CiOtyDah+b7HxqgwBh62qHzgXRezrDLRb8pft/n4krmHtPRihOmcGGuA3QqN3XscCd4Vj6gDCBdWFCaUCGU/QJrBEkEhUmCJxAgotQJdkzYnbhk6ivE91eBHI5XmiHJfcJDkvLFOoEF5F87po4U/Dv/PJP8qe/q8HAvsnoteZa6LYmiNO+xnxUetpQvFKTJEaLSdrSb1ogWYvVwt9WvTeaz8YFQRy/3u42xke48JJ4cQlRG+ouV7RO/bq4/73H2SD0CJokuM8j8b2eSy6t3eFJSM7Itq5GsyQ1f9wldV+UQCqcbcOiEghOnQjxCY7A/wZoJ4W+n9Xu7srbjaKVt53di7rRK1evDDABp+MIInjlLZ2kxkwRUCaJ8RzYGTt2xVHiaZmEH3npd2I7HUyrGVzd98L3gmummMrjsqTuawPWYvKy7kdL1WtQ9NM6WWXg5T6m9GTTuij5cvP3mG1s4zdd3P5e+1U22Vy/FP6/LtRM7ea2kIQkkrq7fRUSt95D4cBBk5QOCRWeEoOrP9Pla9zUBxUnuanPHj4K/cYCK8kbWswzX9fr/LTBEgohLxOHk+LThiB6+3KzIGYcVhKJ619ApFXrE20F7228GPHaYZdWZlkUFR9fzfjcUe/b3aRtbGMb2/jTwH3v/b8QvfaR/FC7vf8V4P/svf+L9Wv/HPAE+GeB/9gYswP8CeB/7b3/iXqb/xVwH/hHgb/xzb+MZ+NTC9/C0xZBVVzEIoBLgbvr62sVpMURC2wwwUVMy7JMhVFxlY7HY/r9viI4RHgWp6wUJRRsyWq1Is9zxYGIq1rO65zbwIWUZalivWAWRNCVIoZpmqpIXBQFh4eHNJtNFf5FjJMiiPJPREhx64owGTvAY2a2YE92d3e1D7z3jEYjddGL61VEaBFUBTUiEbO5e70e19fXKrxDENCXy6WKk/K6uJqFJ+69174R17iInVJEVAoSdrtdFouF4jcEPTOdTtUtL658Qcc458jznKurK2U1C0JHHPLHx8ecnp7yS7/0S1xdXXFwcMDR0ZG638XpLu7zVqtFt9vVhMTTp0+VR19VFfv7+7RaLfb29vjoo480+fLyyy9rf56fn/Po0SOdKyLACu5lZ2dn45xyT/T7fS3OKggbQDEynU6H/f19dYILPkdY9TL34hUT4v6eTqfKWRdEj4QI07KCQJIg/X5/g10vbSuKgna7rQice/fuafJD7gdZETAYDBgOh3ofyT0KcHFxoYVKYz78+fk5d+7c0bYsFgtNXn344YesViuur6+1qOfR0ZEWlRUm+enpqd5f+/v76qaHUCNArjdNU958803FDskKCkkKzWYz5vO5Cv0vYgij2riIZQ0boreIgIL38HZTCFbX2S3nthwnxkbfxo6sReTN54qxEKExEkPjdqnI6dftUA50vZ/1wVEbeMyB761tqsXQtaBpgvhtfM2FDq+7NBxH+y1yBHtT4yxE1LQGl1msSzBLA87j84Ife/AlJq6g8MFRWwCZgaWH3FuSumOySPRe+WSNJDF1wcpaDBfhWZAnQZzcLHKZ1YUnAXK/Fkpv40yctzXzuSL3CUntBJdY+oykxlqE/QP7Wdzirm5PrqI4NGrcBcDMN1hWGf/WP/gJ/g/fDd3OdzB+WdReNPngY8MiKAPbFr4Wh80z4y/JDBmLGIPiUlQEt6XfwJZszNlIQJf54A0QzTeXoe5xW0SJmvp4gftdzy0bUCu2DJzxdB4Ee2/DXLTFrfuiPk88h70xmohJVqEoaOthhv1O/wyLPTNOed9xkcoER2Y3kSbi6i58QuHWr698ysplpPZZc4WsQBDRO8FTAIlx7CYz7qUL/sSrvwfbamL6PdI7Kb7dpNrvgQ1uVJuXYMORXFrPu1ZS93kKDspuGhA1FRRdg7cGW3loGnySYQtH1dw6vrfxGYlPrdua9Sql+APS1kI3BtGUcWET622o7+BADFMJBoerXd6uPnLIM6+/SsUDrp+2gNf314J8+L/sL5cTf6V7E5ze4hbf+A71YHz9eWD8ZlfcSmo+95eEbWzjBYrEGj5/OuAX7g/56vl4K3xvYxvb+GZGP9YOgZX3fvWc7f5J4G8YY/5L4PcAD4H/yHv/n9TvvwacAn9TdvDer4wxPwn8w8B/DHwfwQMWb/PIGPNL9Ta/sYVvEemEDRy7VqfTqTosxSULQRgUp6g4hoXlLY5wEQDF3R2LzyLEitPaGMNwONTjSzG7+LhSCFHcwCJ8C/9bxEMR0mDNHhfH7v3797m+vqbRaLC7u6vCoIjQ8nrs4i3LUsV4f8utUFWVnl+YztJuEcdFoBURVNzYIhgDKpoK1kXEahFVpV8kqSDtlmKTgr0Q0VvOL4K8CNvyWrvdZjKZqLsdUGHSe89isVDBWo4HQXhfLBbqBhdEDASBfn9/n9lsptiKvb09FfxPT09ZLBacnJwwGo344IMPSJKE09NTTYJMJhNarRbL5RJA+el37txRJMp8Puf09FT77urqio8//piqqri8vNzg0j9+/JijoyOWyyXtdpuqqlQ8BTg9PdV5enl5qckLEV339vZYrVbanngut1oter2eupBHoxGLxUJdy+LOlsTMkydP6PV6KqSLeL9YLDDG0O12df4KGkcY6oIwOTg4IMsy7t+/z+/7fb+PDz74gKIoFEEi/O1Wq6VFS51zVFVFt9ul3+9TliXX19fq/BcO+nQ6VbyPzAXBvMjKC+m3J0+eaF/KSo5Hjx5pH3U6HXW29/t9TV5UVcXOzg6r1WrDOS4s83a7rX0rySyZZ4PBgJubG13F8KKGKdfFAWMBGNavSXj7jBF6052tOz57LHkdIqE8fkscXRHXO95GBHd1ftXnMJ6wmttEx1FHWRAZtShlWTuL5VrrYoraTidi5loYd5nH1AK4rBo3fi2ASjt9AmVbOiIjnVfYolYgViv++sdf4qYqAqebgDAJgvW6g5c+UVZ3Zlxw6Nbu6ThixEn8/hpX8izeJD6G85bKOHV/3z6GhIjYjrU4Lts5rArkElUk3lucHivBs6xF98yX/Jv/4L/l3/itDRYHb7Harb+zylrkZj3GoahkUHOcFIH0awegOrSlyGgZuts48Fm9bZwEcTyTpAnHZuN4cdJmA31j2bgnBNPj0lpsj1cFOEgXoZ3C9RYWuakLYYpYXzXXc9CKuVESQEnA75QNgy2hMYRx3uKsPcZ5y6pK6SYWh6GbrFhUDZq2DPiTem5V3tKyhbK9C5+Ah0XVUJHbRckT5w2lT9QNvnIpnSTfwOIkpqRjc47SMXeTEX/i1d9DcrCP6XXwrQYuSXCdDNdMtVhnlTaCQzMxioVxicGnFlO6kDBKDT4xlG2z7iPqBEIS5p1JN++HbWzjN0XE33lqfLb10/BfEJGNCsiemv8vRSkTy9rlXT9aSCpoLSFxXt9qkdH1LQyeyld4HDNWLFnVDu6wXcgNmtq5Hc5dIh9B6893ab6tfeDyn7TU4SlqyVz+VYmnbNffA0tIy7XQbrCYelXS0joKdYN78B5buFCQOP6O1lvfI6J7lDfdxjY+0/HOWRC+v3Y+5p/47jvf7uZsYxvb+OzGbbb2vwn8G8/Z7nPAvwT8+8D/BfhtwP/NGLPy3v+nBNEbgsM7jifAK/XPp0Duvb95zjanfJviUwvfjUaDfr+vQpeIszEKRETvVqul+AJBYogoLMK0ICdEdBOxEoK4JpgU4RcL81tEt5gtLliL8XjMZDJR0RxQF60gWJxz6mTu9XoMBgOur69VnJ7NZhRFQZ7nWpxRXKTiBs6yjCzLVJAX9rM4vUX4jkVicfGWZcnOzg7tdpurqysguOGzLGNvb4/5fK7iOKAu1tFopEX8REQWZIk48QX7IIKs9I+4tdvttvb5dDpVvIq4bvM8176TsRbnt4jznU5ngx0tgnp83SKaA8rkjrnrgnIRZ33MVB8Oh3Q6HY6Ojnj48CFHR0eK9xBBU1YOSPR6PR4+fMgHH3zAK6+E+80Yw2g04t69e3p9aZpycXGhfPHBYKD4kHfffZdms6mYDsGLSFJHCnMKFx3QNoxGI2W2iwAtLm/pF3Fwp2nKYDCgLEs9j/S1iN/z+VxXBAhzfblc0u/3VVyXxJMw8AXlI3zrd955h69+9auaKPiu7/ounfv7+/t853d+J/fv3ydNU/b397m+vlZ0CwRcyYcffqhzq9cLLoROp6NjC2hhVcHHvP7664zHYx48eMBkMtFVCzHDfj6f02w2mc1mtNttDg4ONpItkrCRFQWACtkyB+NCqiJ67+zssLOzw3A41DF6UcNWawH3eaKgCsORUAebgjjVervAUCZwsd1aHBQxzxAJhJHYLUKfiR69bGuDAI1fYzA2CmJSi5eEc5uKtYgt1xY/v+VIXwuqrMVOaVsa2OC2NBvoirUz3aha6VIoW1bbZlcVtqpwqxUrX1DVB13V7xfYZ/5af57QvcHw9naD363O7Wj/omZ1i0iZmUq53fJa7sJnccM8h+Nd72sj0UPeFwHb4nDY4PwW1zgWS0FBPWhe9l1H4VO6puDPf/mv8Af+1L8akgwJJJWvxQ2z4er3qYkSF7XobVA0CAZsHsZJh1QM8o5nnP3YtQDtU1ML034z4VPfEzESJ7jOWRc1FXyJq5MgRbjcsmVIlz4U2myEn4uOCcJ9fW/4BC2QmvcMjYnfaLPeA5VXzIprBESLTw0fX+/x0ks3OG9pJiWprchdSuETrHFrTImMpzcsXUbhEzITCmE6b5lVjeCmBlJbKULHGk9aj5oUzZxX4XeWnWRB4RpY69hN5nxHdslJkpLs72L6XVyvRdVr4pqJ3iMuMYEB7NZOTV9jDLw4v7P6sWEoW+GfqdD2+cQEHrEFNl0o29jGZy4MBqcfBKyFb/1nFJ1orCFxntQ7rA9fRxbIsDRMQFbZ1OKMx9gKZ2vHtzebSUZj1+aZWGD269NK2wwmbK8ecVlTUt+v+HC/pp6qAcaHz0TjPUkt94eP+xoNZkCLKNTf/+tzStLztrS9fm545qt0G9v4zMU7Z8Gk89VH2wKX29jGNr6pcQ+YRM+f5/aG8OvGz3rv/2z9/MvGmO8kiOH/abTd7a/oT/O1/W39av/UwvdgMFB3aiw6i1gnrOnhcMjZ2dkGTxrWzmthdss+aZoqBkXEWhF9ReRKkoQ8zxmNRhvMZeEuG2M2HNTz+VyP0e/3VcCWdghfWDjZwlaO0Qni2BUBVY5hrWVnZ0fFOUExSF+IUA4ohkWcuoKAke0PDg5UHBwMBiyXS6y17O7uslgsFJUhYuaDBw90X3ENt1otPa9cY+w8FzyHYE/kGoR3LngV2Vcc59KXwqQ2xjCdTlXAHI/H6hoWQVsc3xDQKsK3ns1myoXe399XgVOuURIDeZ7TbrcVF9Lv9zk/P6fT6fD48WOOj49pNBpMp9MNF3me59pnwvsuy5LxeKzt3dnZ4ebmhv39fTqdDi+99JIWSWw2m5yfnzMajTbGMkbTjEajjfkIsL+/r+KsFHGcTCaKCBExVuYqoOMiSYO33nqLJEl4+vSp3jvirpbEkrCsV6uVnnu1WukcdM7p6oWjoyPefPNNfumXfom33nqLb3zjG+zv73N1dUWz2dRVGB999JEWTZ1MJipuy3wej8cMh0Pa7fYGa1tQKjc3N7RaLU3SXF9f0+v11CEujvyPP/6Yvb09LRrabrc5OzsjSRJOTk4UpWOM0eSCJFakyGYcMs+Pjo64urrS7WWcLi8vNaESF1594SL+SrktfD9v89hZXe9vnvO6l7/TRfSOjytO7ciZDWvR3MR/jPv1bvJczxsJm7fxKvHzDbdY7e71twT+WMyWfYUBblg7daF2+JqAKLXRrwLehveqRvC0ZWOLWRXgPJX3KiNnBnJXc7AxylCOXbeAitvrE2yOhduwxz8/RDTfcOviVYyOXdsuEssBqprzEQvbmLJ2dq+LI+aR1VmQKNpG1gJ6gscaR9NUZMbSvihY7TTw3qgojfPPCJvGe+V7exseTeTmdo3gqnbZs/Mq7h5T1dvU4rMUJw0dFG0riYsyjKkV9Ek9d8TBrW5yHwR5UxmymScpfBC6ITiX0yB0C8bFG/AZJHlAmNh1bhaXhGSULb0iW7wNonvZNBR9qPKUvFb+U+PIXcqqSqnqIpcNU7JyKav61zZxbjtvWJlUhW9AsTjWe1zNDgdB5AQeeEZVJzNgVLXp2Jy72Q0vpde8mnb4J9763djDDq7TwjczXDPBZRZTc9g3Ekm1gCdC9zqpZtbP676VMbaV35z7W4VrG7+ZQr8b159ra5hI+LKRZ94YnLHhgyKpH618EXpsGcTtDEuKYWBa7Jo2hS8Z+wll/QlvsMzbnumgwHcz/GsH+F6D/O6A8qiDzyuY5VA6ikWOKR2m3YB2A5zHrcrwWVyW4Bw4s/lZCtDMMFmdcUwMHkNVfx76vMAXJX66gvMRfp5T3r/BjZakLqHtLGVmmfdTKgt25mivand3LbYnPsUAeQJlQmhPVakAHhez/pU/EraS+DY+O/HOnbBC/avnW+F7G9vYxjc1Jt77T/NBcw589dZrXwN+pP75cf14Wm8rcczaBf4YaBhj9m65vo+Bv/vravX/hPGphW9xWgt6Q0SvmBUtQmuapioGigtYBF4Ri9vttv4T4XO5XCpP+razVxyhMXPYGKMis7jNhZEc40EAFXlFXBZ8hOyTpinHx8da7HGxWKiwPplMNgpP7u3tqdPZWqsFIcUxLiKnXG+e58xmM/b29kjTlL29PS4vL9XpnCQJOzs75Hm+IQAvFgt1lkufGWM2ONAiWAsGBVBxW5z4h4eH2jZxBy+XSz2WuHolqSEudmstk8mEi4uLDfFeih4KH1zEWDme8KcbjYYiLcTZLO3q9Xp473n69CmAiq7i/JYihnfu3OHRo0ea9Hj77bc5Ozvj/Pyc8/NwrwkXfnd3V13Ri8VC+dwi1CdJosK4OL6991xdXelcWywWynZvNpvKspb5I+gXyWYuKwABAABJREFUQIVyQBEqrVaLPM/VnbxarVitVlqcU/p9f39f+fHz+ZzBYECv11PGNqB9IQkLQXoAuqpCVgSUZcnZ2ZnOxV6vp/eWsLTjwqbCwH733Xe5e/cusObOX11daX8Jw1ui0WhocuLk5ITLy0tNNIlQ/+abb/Lo0SO++tWvMh6PFacirHLpT1kRImMh8xzQgpnS1/1+n5ubG105UBQFu7u7yr2Xe1keu93uC+36fh5WBNYC4ga+wfAr6qziVHXC0hZUSC3keTmXCIVi/rxt3jTg6rqQylmuI0akaHHBWsQUodqKYOZZO7sjQd9br6q8ICc22iWu75K1aVmcvxHSpapd6qYCKgO1GOuTUJDPVAQWcWIxjYyCitx7EqASx/ctTnOOpWUqnDcqestzQJ3eKszWnSAIizWuxD7zmhSuVDzKrYEsfFqjUmqMyq33HbZ+L/wq4FT0Xu8v44cXl7dMniCud+osQWI8c1/R/spDiv4rrHas8rRNBS4SNmTFgBS19GlINkhiBWrRu0bYbBSftEDNr3dJELCTVZ3EiLo+WT2ngKVZO74lhIUfz9k19mSNx6kaZo3s8Wuet6mCM93XQq+3QcivGh7XqK+loE7MmHqlASq228KTTQxZO8fi6WdLZmWTfrrE0iS1FaULhSsXVYPMVhQuofRWC2Fa/AYDXCIzToVz5w0Yi/OmxuJ4eslCXePf0/mI39W6oWVS/uDb/wh2t4fb61O1M8puqqK2DRNlfe/4Gl+SrF39UthUBfHUaL/ayocipoSfvamLmm51rG38Jg0Tidyw9kfH4YXbnSY1yiR8uZqywjqHddD0kGHYo8EdesxZsWSGk+VXJKyaMN0p8fsZvNOHoy584SX43AnMC7ieQV7CaBEed9rhX+GCKF45yHMoq/AdV4lDvLaUd5vQTINAnyZ1wrL+EJwvYZnD+QRsAqM57nKCmwacS8NZfGIpepYqMbSWBZkLyWH55knr74/SEr5KjAMXvln0c/dW7z7/w2Erfm/jsxGfPx1gDDwZr7iarjjovcCmnW1sYxu/EeLvAJ+/9dpbwMf1zx8ShO0fBL4MYIxpEHjgf7re5n8glL36QeBH623OgC8Af+qb2PZfNT618N3r9VT0EvSFiFcinAp6QATjfr/PxcUFEPAlgnQQxIQIuJPJhOl0ynw+3yjMJ8KVvCaO8xiRYowhyzKqqlIcigiwgL4vIrxzjslkwu7urorSIsCLKCxuakCfSyFDYQqL23k2m204fGMxXp7PZrMNMVgKWYrgN5lM1L3cbDZVfBVBfn9/n8vLyw0BW5AkIsCLw1rO65xThERcFLHVaqmjVvpGHMgirENgYouoHRd6FNZ07NoXwV0c4nJ9IvRKv0thSnHdS8FQEXcl6SAc8zfeeIP33nsPYwzX19d473n06JEKw2dnZwCaAKiqivF4zMsvv0yj0dB9ut0uOzs7Ogcmkwm/8Au/wMHBgbrFsyzT4or9fp/r62ucc4xGI2VFxzxzQBMaMe++LEuWyyWPHj3i9PSU0Wikrnbhc+/s7DCbzfiO7/gOXnnlFb74xS9SFIUyxmXOS7t6vR55nvPw4cMNBI6w0qW4p7ye5zkffvghnU6H1157De89q9VKxXmA4+NjFfjF3S7j3m63efjwIZ1ORxndgjpJkoSrqytdKSDtbrVa7O/vs7+/z8/+7M/yV/7KX+HP/bk/x5/8k3+S8/NzvvCFL7BcLjk+PlbcT1mW7O/vM5/PVcyW46ZpSrvdZmdnB0D7WT435LMmFsHn87muUJD6AC90mE1RV1ypwObfi7GQHDllN9Ao0aNiTmKNrRalpX6euyWsb4xEvb+zwXmtwjSbgqRavsSlHbXbVOF6nBzPrQVKU7ff+7Vwr29E50KEOxt1iQ1GOHX/1mK/cTWGwxtcw+J2uthVzo5tc11NcQbmWgBysxil85a5txsFKeOBsbVwHUdwaFsarJElMYtbt/GWll0FrreynlPdR7Zv1OeuovOKKH67PYlxa8EbNpzjwRW+/gxsUeC8JTMlla9d7tMZjVGJLROWe4FI7RM2Xf2shWvtfI9WYru90sCuv8LCuCXrZIxb1/ZUnElAcWwmdIwkRQS5Us97ncs+CLGmZsHLSoAkDw7yqmFU7I65+D6tt7VByDdlQPjEyaX1/PY6B72BdOGCSGyglVYsqox2UlD6IFCPyyb7jXm9gqAeN5cwKZvMywarMoxTloTGWuNJTUWjfl54i/WezJTrAqYmdFRqHR/OD7hedfng8oC/8xd+O4NfuABj8C9nuFZKMWjiGlY598nKrRn6dXtcGtjePkoyiDM+9JXR/rKVD458XdkhqJS6b7axjd+EEReN1FlsCJk4I4K3rMKoMJWhWVmaJsVUKbZGTUmtiHHXwaAk7zWZvfw5inYCrQZkKYVb4asF9Bpwdw92O9DMgoubCpq1q7zMoGGhkdT3pQvO6tIF8dv5sF2WhC/LyoVH58I2pYO8AGuh0QiPzQY0UiABZ2C2gkEDhjPymWM2dZTG41KHrxxuVOAIf5cErL+lbJp6pY8jK339+3GNPIo7VX9X8dHz+JeJ7efFNj4b0WumvLLf4aOrOV87n/C73twK39vYxja+rfF/Bf6uMebPEkTr3wb8i/U/vPfeGPMfAH/WGPN14OvAnwXmwH9ebzMyxvy/gH/PGHMFXAP/LvCLwE98ay9nHZ9a+O52u4oiECFP8CbiEBYUw3A4VNyEiJRXV1daMHIymdDtdpXZLG5vQZoAKgKKk7nT6XB9fY0xRs8jxR3FHQzB7SwuUljzrkWkFsE8LuTY6XQUFyHiflmWHBwcsFgs1IEuwrw4aEVsF8FWeN4iukvRQXGxT6dTdYt3u12yLGM8HqsDe7Va4Zyj1+upW7jb7SoPOxaGBRMCAXtRFIW644XlLf0sfWut1fdjoTYWriVxIc5+6UtjjArHcbFQ6V9Ax67f7z/D8BZBttlsqgNc+OxZlineQ/AjIri/8sorvP/++9pPgqjZ39/n3r17QGCdn5+fK6da5p24jcW13Ol0ODg44NVXXyXLMrrdLpPJRJMX0+kUCLiQe/fucXFxofNGio/G+IzxeMx8PlfkjIjFnU4HYww3Nze0220t4ir9Llz1/f19vvzlL7NcLtUNbYyh1+tRliW7u7sURaHCcLPZ1GSQOKQHg4EWuBTe+3A4ZDQacXx8rGxxSTYIMmi1WvHw4UPa7TZHR0c8ePCAp0+fslgsuLm5YTAYcHV1pcmgGIEijn05lyRYxuMxP/7jP87777/P4eEhf+bP/Bm9j4bDoSawer2eXqMkaaQ4rNzL4owXvI8w+WXOScFQuR5xvss9HydkXsiIRe7Y0X3bAS7OanFS3zoGRO5ccdvGx/XRceSv/ppqccv4HI4VsZmfd65nd4C1jRzFK4iAaataPHVAGrAUsL6W2EEcc09xPPfvZuENu6w2umHqAotehVOXGVw7w7Zb/P43fyf/2bt/k6X3WDwrn7D0KRWbc09c3OLMrjA0EGf3Jtc7xpLkJOrCVlRJ/bxhKrq16L2M1d/4vDgqknVByg3Hd0lVCy6JCUxvKaTpanZ4OF+yedCofS1jsaYI7HEMDo/Pc5pPpvizHlnTsOrb565bl4SCFhQ1kXAt6BpJSiSRM7seJ1uwwZXXbeuVBSJkiwirc6ZcI1YQwTZaFSCrBUJxy7VLXX6WGaVubxvtXyeQbEXAoMRJloQ1m97WxzMGW3maN55GGrjehbe0k1C0cpCuyF1aJxWCGL5yKaWrndsYSmcpvSWzVeD7pmBrMblhAwolMMIzrHFY4yldwnXR4JPJPp98/YTWo4TJXXDpMUnuSZa1IJ9C1bAhyVCFGQWQ5K6+DrPphN9w168Fb/kMslXdN3Uh061pcxu/KeI5CeM1kmMtemv+2JrwBZIk4Z8FUlMzsXOSyrPnOuz5pmZfKzxXLFhQcrHvePS5Av/yAPcHvweOB3DYhH6G/+QGvnYehOij3SBGtwyslqFR3TrrlzahjG4y76AoalG7CsJ3lkCnFr6XPnwvOgfLMriwqzy0f2Agy6Dbgk4LToDvOAvHeXIPZkuWT2esnkxhnuMfT2G2orqYAY4UQwNDlcCyZ6lSQ2vsaC6DG7wkfJYV0sUGrbEhCTFP3af4tRi+jW18RuKdOwM+uprz1fMRv+vNw293c7axjW28wOG9/xljzB8G/i3gXyc4vP8V7/2fjzb7d4A28B8Be8DfB36f9z5miP/vCXW1f7Te9m8B/7z3/tsm0Hxq4dt7z2KxYGdnR8UqwSFIiLBZVZViMAT7YYxREVnEu9FopAX6pLifYFS63a6iOsTlHbupRSwUh22j0VDOsZwTgii8XC7pdDrMZjPFU4ibV9jJwowWx6jgUIR5LYU3hf0du8WttaRp6ErBe0ifiXDZarVUnF6tVoqjEDSIoEBEEL7NKc6yjEajwdXVFVmWqWAtbnspBghsMLdjHIa0MW6/OL8lESHiv7wmrnpx+Ms4ZlmmLlxxiQtqQtzi4r6H9YoBabM41+WYUkSzLEtOTk6w1nJzc8Pe3h67u7s6pvP5nOvra5IkUReycM7n87kmA7Is4/j4mKOjI8qyVPF7f3+fdrtNt9vVOVMUBVdXV/ziL/4i19fXPHjwQOe5CNRVVfHkyRMtdCr9KH1+dXXF7u4uSZJogUxBx+zv7zMcDvW+aTQa7O3tKUf76uqKO3fuaOFUQMdfjrFYLDQhIn19eHiown28/SuvvMJsNtPjC2ddCrS2Wi2GwyHdbpf5fM50OlU3+NOnT1XIPjs74/DwkPv37zMej3X+ywoJuR9lTozHY37mZ36G3//7fz+ffPIJb731FldXV/T7fbrdLpeXl7riQxjsMg+FjS+Js+l0usE073a7pGmKMUZXXVRVxXA41M8PSTTJfJI2v6hhIhEvvLAphusf85HzVcLzrHAdu1w3nLS1qCliY/y6SzZfU5dsVPgS1u7aZ4QFR3CWxS7gSACNOcMOs34eX/etYyrrO6Ct12KduHxrpreVrqnA1qq+y6BsW8puhu23sfkuf/zl38Wf/+SLrIyjwNKi1IKC80iQLnyiRSRbpiAXjV64zJH4XbHufBGZC58qV1uKV8aubRW19XqtMpwrbze43BIJwQ3saoyKNS64xKMBXqNWNotuJnhmrknuEwY2fD4vvQ8YjNGUrN+kGKQhORGdMyAw6ha6IIJ6E1zPNkrExMUoYZ1ciVcW6DyVuVSL5/HKABtNAFOu2yBjH6NU9Dy10B6KxHp8YiJ0TrixBL1jKkiKMGcEyyPieyWkGF+fz9cOaBcKWvoE0iUUPUPPBl6785Z2siIzFc4YZmWLyhvKusAlQGodDV8GURtPN1vpXBK3OEDpEpLEU/qEyhsygt61qDJWVcrHDw4ZfCOheROK1VWNIGSbjoj7Zt3n3uOy8LpLLT5ydeuKj2LtzpTPC2Woi+B9q5/lGL8G1n4b2/jNEXXSR53eBiyG1NWrL1yC9R5jLYUwv5sNqgSqdkqVOcqTBuV+E/Za0M2gk0K3Ab0M+k3ot8BY6DRrB3YJRRW+tKSmgn431j+4qF26NMOH/bwPgrjcn57gDi+q8FdiXn8xljWWxAqv3AS3uXPQK/GLKuBRFhVkCf54EL7CC0e1crgEXDOpV4KED+r1f9TImM2u3MY2XoR452zAX/vFx3ztfPJrb7yNbWxjG9/k8N7/VeCv/irve+DfqP/9Stssgf9d/e83RHxq4VtE7JubGxWLRaxarVYqQK1Wqw0GtLiAxe0pzmlxVcfCqjiJxZksDueyLJlMJlpQUYTkxWKhTu3xeEyz2VSHsYQ4yqWAX7vdVuFUONCdTmcDwZFlGVmWKRM5doOLKC19IkgFcY3nea7n996rS1z42CLaCXJEzrdcLpWRDKgDWFAh8TaCfBBndow4AdQFXxSFoiFEwBfHrPQxrB3jIiBL38rxFosF3W5X+cqClhHBXcRaGcNWq6UCpBRxlKSGCJ7iYJZkgxQyFMfvbDZThner1eLo6Ihms8njx49ZrVY8efJExfB+v6+Cc5IkWvyy0Wiws7PDwcGBjsloNOL6+lpXEYjz/vDwkC984Qt88MEHvPfee8r9Pjs7o9vtcnp6SpIkdDodhsMhANfX1wDq0m80GpyengJBIB4MBhweHpJlGRcXF0ynUw4PD2k0Guzu7vLJJ5/Qbre1sKqwzXu93gZ3XIqbxggeEXql8GW/39fCnW+88Qa7u7vkec75+bkmlU5PT5lOp9y5c4fRaMTJyckGw344HKpb3TmnBStlzskYS7JnPB7rfB0Ohzjn+MpXvsK/9q/9a3zjG9/gzTffJE1Tjo6O1H0v824ymTAcDhUpc3Z2RqvV4vLyktVqxYcffqh9L/0pcztNUy0imue5usnlM0mSK3EC7IUMzxoPclv0rv8W3hCcIiFaD2HW229gSOrjmBreuYEUYf33dszZ3hCva/e4/l0uh/SROG7WAqS2061FcilSuOHkFhFeig7ebrM4xlkLnxv4l0ioE/S1ifpJ+OFV0+LaGabbxvZ6/PFX/uf86CdfhKpkyToZrCK2Tyh8QuFTMlOSk9Dw6202ON14MlMoz3vps1CAkk3HthSwFPyI4EksLmBJosFMjIsSBJtYE3kuKBZxnUNwqsftg1ioD2J5x65o+aJGu1T4IocsxRSVjk829+SDtWtfhiXgY4JDOe5fNfmrYFoL0FIsMTahe/BpNA/q90NhzDVKQ3AcKk4bo85jI3O5npAiZIc2mrW706551bYMbTKuvi63Fr21f+uPIEWceNln3cayFUT1486EYd5mt1sXBPeGWdlkVaW0k0KLWWa2wlUGazwNW+GsI7XByZ1X0DDheRhrQ+UNRc0Il6FPbUUbSG5SGsOaua2s7tCLkjSTJINEEPijpRQeRQvJzST3onC+w/hGA8+6n0JSYT2229jGb5jQpFtdDJk1yXvjq8VIEq4WltO0Fr4DN6tTphyuUhJvSF0bMIx6cL8D7Gbwah8/aFJ+9wnVcRe/LAOvu9cMxSMmS+gm0ABsCvt7QTA/bAfX9uUYRssgSKf1zbjyYV9ZpVX54Nq2HnwV0CbzEm7mbFyUtUGwL8rA87Y2VKLMCliVkK/CAU0Sti/LIKp32nDSDOL40Q5UDveFO7iipHo8If/4GlYlbjKHVUk1KykocQYKUwvfzoZvT++h/i5w8reK9/pPP3rkc8g9MyLb2MZvqnj7LKyO/+qjF9uws41tbGMb38z4daFOpDikIDqqqtrgA3c6HUUWrFYrms2mOpa73a46MsXdK7gGEajiwpZyjslkouK4iLeC5BB8hyBH9KJqZygEcVr+iXAsrHEp1ikObUEo3NzcqJgphSI7nQ6TyURRGoJiEazCcrlU0V4c7eJalwKasl3s1BbBNBa+RRyfzWbs7+8rRkL4381mkyzLtECiiMvS13meM5lMGAwGzOdz5YULo1oc7rAWbzudjhbQrKpKxWJrrY699IEgaVqt1obLWhID8/lcueCCLomF3XgfcfU2m01FtIiTXq7njTfe4PLyUhEoBwcHTCYTPcZ0OqXb7XJ8fMxyuWQ4HGqCQgpf9no9FosFi8WCd999l0ajwec+9zlmsxkvv/yyOurlnLLaQLjRT548UVFehP47d+6oEC1JAXHQC25FkhTHx8eMx2MuLi44Pj7m8vJSxXpZ5SDuaUmoNBoNut0u/X5fVz3IyoNWq0Wn02EwGGCt5eDgQNEnT5484eWXX2Z3d5dHjx6xu7urfPD9/X1arZY65mezGVdXV1xdXeG95+zsjKqqePr0Ka1Wi48//pjd3V0VuGXsRFgW7M7BwQFf/vKXOTs7o9frcXJyQpZl7OzssLe3p5gccZnLvX19fc3x8bGK73Jvt1otjo+PtX9lnI0xKrKnacrNzY1icmazmSa4tkH0ByFrZ2vM/I6EYi1UJ39jRoLwM3ztSJQUcTt2a0rxQB+dMy5oGB9XjreBZVFVFEWPPINric5txaUt79VtUCdqtb5GPUfsCo5d6AARQkMwKsH9bbCJD2iHxOCTIDDYbgfTavHH3v59/IWv/U0elZ7EeCpv6JpCBejMOuYuIyehZQoVkm39fow0qXyiru/EOMWfWB9c3Al+w71d+Wfd3OLyjp/HwrkI5LlPaJiqFsfXzu+YKR6L6IJAwa/Z4w5LjqXw8GMPf4Yf/r4ToBewIknoT+F5x2xnQY4EnEx9/A17eM3drsVX430Yp1psVua2X88jSVwIA3w90VA2vIrrz0nmeBsS8UGIDVmSKl2vOvAmcL/DHDCRwLs2U4pQLw5pU6zvhZhXXjUMLoGqrsO7qlIWVcbNYsCd9hiHoZmUrFyKNY52UpDZitQ42jX2xBpHViNMbOa04GWYOwHBU3obHl1CaisS47nI2zQvLdncKdbFpevrkZBCtmHs5EZG3eC2Wov6eg/JZ039vqndpt76OrlhNj5rqI+1jW38RoxPNTXFTR39E102A1qVISUhMRnYhJumY95zsJPASSO4u9/cg3s7cLWEi8Wav52XQYjOa7E5y4LAnSWQ1R+AeRVEbUngFbWDW4RvD0hFZ8lIVz5gTTyseeT1F15eQe7CMVdlwDQ1TRDfsWxwnCA4vdtpOGcr/L7ok3Cf+0YGiwLmq5pFDj5LcEnAYzn9XSB8vki+3d1Oxj/n81oft7r3Nn4Txzt3gvD9jYspy6KilSW/xh7b2MY2trGNX298auF7MpmoMHl9fY21doPLLGgLEW7FFSui8vX1tRawrKqK3d1ddnZ2tFCmcJJjF3mz2SRJEkVLHB0dqdguSATBHIgwJ21YLIJrqtVqKXN6tVrR7/cV+SDIESmwmKapurvFuR27pNM01edlWSryI8syFouFIiDkmk9OThgMBiruStHKGFUiDOnxeMxqteL09HSjeKCgSsSVLdco1yboCBkTQFEP4qYGlJksRTHlWkVwjYs2inCbpqniYyTJIIUeO52OCqCCo5BrE3yNnEOuRdq+s7OjbnhJLmRZxmg0YjAYMJ1OWSwWDAYDlsslT548UX76arWi1+uxt7enyQ7pS2mzFFAcDAYsFgs+/vhjms0m3nuqquLu3bt88sknmoh58uSJOtr7/T4nJyfq1AfUkZ6mKU+fPuWVV14B0ISMbCuuf8HwjMdj5XoPBgPOzs64vLzUIp2SsBEOebvdZjabKTdcClw2Gg197fAwsN/SNOX09JQ0TXnllVcwxmi/nZyc8PHHH+O95/XXX2e1WvHKK6+QJAm7u7v0+32+8zu/U8dZnPFSzFKKXlpr2d/fZzweq5O9LEvtt+VyyXg85uzsjI8++ohf+IVf4Atf+ALvvfceR0dHem2SPNrZ2dGEmdyfgouRz4HZbEZRFOzt7anjHNBVHnFByzRNubi4YDwes1gsNhJrsvrjhY2IN6xLnmMHduzEJhIM6xDhOBa11f3totdvOTgF/yB/fCvuJBK7XUbtrA5uWUFcQBAypY0uCz+7hseUJgiZco5yfX55tAaq5rrdGwiT2vAcmc83hH9k8/oaHWvhzjWAsm6jqftG+iqxwemWJthZRs80gWWNC4EMR0dZ2Ya+zZlFxSdvR2YqnLfkJCQEF7fgTBK8okskRNyO8SPq0DaOwv3K94AWqxRxOxLGE+NY1s8rb2mYiry+aNk+MZW6xJc+47rq4bzlJCnwlaPsN7F5KGZYtNeu6Q38iPHq5NfkhszJWsCurMGaW+MaJWHi1QY6t4RTQ8Tmjs6/kYSJ50kVRO0w9zxVFuadjHeyWou7cXuet3LCpeYZfEfsCJfETNWEfMfz9asjzgZj3h8fMlk1mBVNmmlJL13J3iwqy8olJMYH8TsJvxNktqJhSy2OKVG6hMJbRe8I33tSZXztySlZDknhqRo2iNp1vzhJVkVJKwhFK/X+Nl4TYt4ablenM74W/GV/79eMfh+SHroqhXW/bGMbv2Ginvji836utpqIYEz4EgJwFYmHE7rs0WRpK666Jb4J5uUB9JvMTlpw1Agg/l4GzRRyC9d1kYPDTkCIzJcwA1Z5KFS5crCov1yfunADrVwQqanA5+FerHxQjo0JX5zOQ1G/5uqssvMBVeJ9oHAK8sTXH2KNRl2YMw2s79LA3IXXMrlWtxbBTc0z94TztlpBpD/0sKxgsQrolmWBOx7g5wV+vITHIyhK/CrHV46sNGRlaJLzofdt/VnhjYmE8nqYtqL3Nn6Tx+mgxW4nYzgv+MbTKV+4u/PtbtI2trGNbXzm4lMrQ+fn55ydnSliQXAWIv6J27mqKhXvRNwCFIEhjlFhBOd5rg7PXq+nxTCF8TydTimKQgUwQUiUZUmv19OCfSLmSlFIEXIFy+G9p9/vayE82SfPcxUVZTtxaMu1idM4ZmcD6qQWIV6Y2dJWKQjYarUYjUb6vojuwroWQXs2m/HkyRN2d3dpt9vav/P5XMX4NE1ZLpcb1yAolVgIFie6FEyU85a120IcuIKOEWFasClZlqlQLPtJMUJhTYv4KNe7WCzUqWyM0b4X17Q4m6VQpRxXziXXNJ1OabfbOjbNZlPHtNVqcffu3Y3kysOHD5Vv3el0uHPnDu12W4V0gCdPnmCMUWSKOMDFaS54GCmACcGxv1gsdF41Gg16vZ4Wwbx79672v2BHBoPBRvJiPp+zWq3UhTwcDnn99dcZDocMh0Neeukl5aXf3Nyo4N1sNrl79y79fp/Ly0v29/c5ODjYwAC9+uqrdLtdut2uMvWPjo74+te/zu/9vb+Xd999lw8++IB79+4xGo24f/8+y+WSPM9pNBq89NJL3Lt3j/Pzc23TYrFgNBopBuj6+pqjoyO9ZnFUP378mCzLVHz++OOPcc7x6quv8vM///N8x3d8B0+ePNlIOkmRzclkwtXVla48kDEWt3un0yFJEp4+fcrl5SWAJlNms5kmJsTBf319zWKx0PkpiSJZ1fBChlmLVhuK7y0H1TNO7Fi4cs/ZRt6MhMeNn+MmCJIkcm37NDqONyqOa4hg6dEih6Y02h7FLsgfvjU+wXqjBfieK2qaZ69VRLsNBnr9uCGwRv0mrt6yaSm7KcksC0vBAbKUP3D3e/lPPvkiFlj5cPDKGxrGkRjP0ie0TKUFLSWctxuokSRyb2emhEj8lv3EzR2/HtzilopN/nfsJpdCmF2bM3MNGvV5Cd2tYjewUfBSYl2A05LgAg7FWypjyElY+iWsVtjCUfQawfVnUEe38q5BcNmbfR8J1IqirZMgyvuOxtQ4jyx+VyxOPV/UXSxzJZr7IdmzxmwIEsVlRE50jy0N1EVUjffYKjoI9et1ImhjlcOvwqw2Hpwx4bo8tC4Ms6/u8bXdgc73686ApFUx6M/pNXMS66icpZmWNJOSQbYktRWDdBUKi3qjRUllvFcupWnLsFqhvlFXLuVi2WN52aa1CK5zSfiII33jvo7uOcmjaIJCxsv5Tcd3fe/Yyq/Z7daE7ep+tnlwxG+d3tv4DRubObNnwxBEYGsD79oSEjyrEuvgyDd5xe/woLXgk/aIYgB8vgvHPXh5B+4MAkd7moeTFBaGDnYs7GcBdzKcw6paI0lk2YlzsFoE5na7A81mwJeUxVrUBoLL2wYhPK8QNBGWINo3krqWRhVc3ZUL/1ILjfr7LUnDthWhCGbqlV9O6cP5rIek/owVl3nz/8fenwZbl6X5Xdhvrb33OfvM547vlG9WZWZ1oaqmkUAhuhGDECHcGgKwQRgJsCFCDoeFw5jwB0E4HGH8wV/ARBj8AbCCsAErTBCWhVoTDcigluimu4263d2Vpeqa8s033+mO55757GEtf1jrefY+N7NFdlNdWa08K+LNO52z99rjzft7/vv3dKGbwzTC9u0upMZ3Fc7ZsB0v7wIU3xZ4U0Ppsd6QVmHPF/Fvk7BIs/dkV6M4OZDvw/itPYwxfPXRmJ/+9jXvv5wfwPdhHMZhHMZvwvjU4Hu9XvPBBx/w6NEjTfJK2lmg3m63U++uaAfaoE40DePxWKGo6EuOj48VzgrMluR3kiR7OhBRakAAmkVRcHR0pKng+47vtudblB2iTRDQK6BbXOQyyrLk7u5O3ccClQGF1t1uV79XFIWmokVPYozhwYMHmkIVn7akyJfLpc5TGm4CmvQVKCzwte1Ob8Nu0ULIx9Vqtef9ds6pykPS9YAmxAVcC2iWxGyapnq8RqMRxhhGoxHz+ZzhcLi3TGk0Kt5lSYrLckTxIk8JiEs8yzL1TXc6HW2ieHx8zPPnz7W54/n5OaPRSKG3HDvRigBamJEU9mw2U2gsvut2Wnu5XHJycsJ2u1XQPZ1OdZuKouD8/FyfZphMwv+QXF1dcXp6qsUbKQDc3t4q0E/TlNPTU5xzXF1d8fjxY4qiYDAY8N5775HnOS9evNBiiBRz+v2+NjudTqfqP5dxfn6uCe5Op8OHH35Ip9Ph9evX+tTCZDLhd/2u36XzefjwIZ1Oh5ubG37yJ3+Ss7Mzzs7OeO+991itVqr+OTs7Y7FYYIxhOp2S5zmvX78G0Magy+WS1WpFt9vl6uqKbrfLo0ePuLy81ELC1dWVQu8sy3j58iXGGC4uLpjP5wwGAy1S3NzcKNze7XZsNhueP3++p5KRc1meNEmShMvLSy2syNMJ4pSXa+RzOXwL8N5LyN5/Qln9pC1QrDDa60taoLEFxu7BdNWLuOa1AgGdAZ8161R4dv9vVnPvNab53Nv9VLhua+2DMkTTZg1w1wKALLYFJDWhHrfPVlGRcX/7oxpF0t4uhXKQkIy6JJsSU1QYa7F5zsQmOO+DSMQH7UlX4V6tiW8Z7WaSSST+kvoG1N19f1gcJYmCbmleKUBcHOF7jTJjejt8P0xKGlpmkUaXPo3O8NCMs/aGpLUDa98C7/HcSkytsPzOeXxVkV4tySYZdSfBVqaB1jXNkwAuMBlZTvspfNn90iRRjpVwn/YxtVVIZ7cBtDRbvd9QEWipVsKqksLvud7FOR7OhVBcSSKIN+0GcKANLnX7vMdZg609LjF76w3wvHkKQq4NW0L31pDN01AcqsHUCcbB8ihnNnTY0x14Q5pVJInjaLDhtLeia2t6SUEVj7fzIRUux1YS3wLHX6wmPL84Jn+TYryn7BuSnVd3uTct2K3HxOt+k43WpqC+eWJDm5bG9KgUAsKx8np8XWq0GCb78MCuDuO3xGgXaqTBY2LIvKVbWYyH1KckxrAdpbzqwWzaxz0ewiiDp1OY5kFTsi7DMnqdCL6roBVxJkDwysXHLwwk8RdmTfgH7PmC9GmZ+AszlV/+8gu0dd+Sv5GSFLI0vi8JsDyrAvg2tmliWUcnuI3bK5oUG/eBwHW5ITipENeQVAF6S5EgycLcbBLec9SHt4+CT/w2g11BfbOjLHc4PNru0hlM+4bhZWMO4zD+1hgKvl8dPN+HcRiHcRi/GeNTg2+ByhcXF+rQFrd0WZbqIa7rmsVioU3qBFZ96Utf4ubmhrIs1V89Ho81xStQWBzKkvgGNBnc1hcURcHt7S3X19cKgwGFnQLZZa673U4945KGLstSge9ut1N1iAxRaJRlyWq1Ik1TBariHpd/4shO05Tr62sAfa/M+6233mK1WnFzc7PnQ59Opwr1b25uuL6+pq5rhsOh6iJkXpJgFhgujTKlGAEhqdxWfYi6QooCopvJskwbckoiW5YpzTFF+XJ8fKz7UpLZ7eajECDxdDrl6uqK0WiknnY5pu1iiTwNIDBc0vPD4ZC7uzvVwEgBRHzqkjZu+66Pj4/54he/yMnJCbPZjBcvXnB1dUWaphwdHXF2dsbDhw/ZbDZcXl6y2+3UfS7nF6DzkhT1fD5XpUqWZapQqevwV0ev11MFh3is1+u1urTrumY8HlPXNbe3t/T7fY6Pj3n9+jXvvfeeNmgcj8f6/rIseeutt1gsFpycnLBer/Xau7u7U7g/n8+ZTCY8f/5cG1NK01J5OuDx48d8+OGHmmoXzcmHH37I+fk5H330EavVSp3ujx8/ZjKZMJvN+PKXv8xyudRjI4qVi4sL1RStVisuLi40DX58fKzA/MWLF/qkg+hfJKF9eXmp9wmB9uKR73Q6XF5e8tFHH2lRSIY8wSAFHCmyiTs8yzItvrSP6+dyaCI6fC4wS+GcpGflb+GUPcc3Vevv5BagorU8dTG3U7R2H5qJFoX4d/De36ttkN6C0QLLmm8E2LynmAikV+EmEAueBkRNEaFdtDJoMvfX8oEK3LZ1A/BMjTbYbM/JpYa6A+UwxVSOpIwbnQXdyY4KqFjhNLstZ2NGgJDo9/1eajvB44CkBbEFUrc/1nGJ7YS2OLsTfISeUasS4XXtTSTNYVs7plYtiozcFqxcN7i8fXCTO9/A8+b9UeESgXvtM4Xtf+lbP80f+l1/kM5sQN3NKQcNNG273W0JddZK8rdTw+1j41qFnHbRg+Z9tmq+r6lx36S8jUNBtE9ABLzeGlzimycc4rXRboypRZxWUWZ/grSKMya+tnmRT5qTLoD7pnmkFJzsjkbpUkOyC69PdgaXJZTXfXzicR0o+o51r0/6BUcnCYqTcbal8pa0dSwzE53fNgDxm12fV7dj/Jsu2SJsY7KNae3oYpekfLsgZHxMhnuB9QYrbvb2Paatl9HXNttkfOM912MtBaVD8vswfuDGrwFW2y7vFMigv0s43XVIvSUng8Ty5kmH774F7u0T6r/rneDAHprwy+B6Ddeb0MDy8TSs69kt3G2aX4pZByZHUTUSK75lHUA0oH/CuSTAcKlgGxOS1kkS7tPSGLKOie8qAvROBv1u+FkvvsZV4T0VQY1Su+DnrmIKXJLfaRU+T2LaPT7BhQPkqZgi+sPrMibCLXS6YLKgWOkkYfvPh7Ar4dUClgXlN19TrS7C/z94H/i6/E/AXsX8E6rme78D/K91BA/jMH7ghja4PIDvwziMwziM35TxqcF3kiTqK95ut0wmE4WSVVUpJF2v16zXa1WACKgWmCjOZ4G6AgelKaT4e0WjAeh7RKki7uu7u7s9lUSv1yPLMlUlALpMY4w2r7y7u9P1iaJlPp9rClpeK+sWD/f5+Tk3Nzdst1vdTgHGt7e32hBRkqcC8AeDgcJIAZOi/Gg31hQIXZalepB7vZ4qOaRAIMoQSY9Lwl2KDOLeBhR6brdbbcA5HA61iWjbnd12ggsAF0AvGpHNZrPXcHMwGKiDXZLKsk8EjktxBNhLlYtCRhQj4mqW91href36tSbAr66uFDofHR0pBO71ekwmE7IsU1B9cXFBv9/nG9/4Bg8fPlTFjSh6BLQCCpdlHw8GA/I812TxaDTSfX18fKwFBjnPl8slRVFweXnJo0eP9Hzu9XqalhfQ3u12qetaf7bdbul2u0wmE7bbLavViuVyyZMnT5hMJkwmE66urnjz5o0+GQDosXj58qUqaSSx7b3XFH+v16Pf7/Od73yHd955h+FwSJIk/PzP/zwPHz7UIoe1lsvLS02H393d8SM/8iMURaFNMiF461erFaenp5rons1mPHjwgL/+1/+67kNJixdFof7tbrerihc5R0Xfc3p6qjobeY+8v30PkPOsreKRwohcF71eT5t1fq5H5MBtoNT2EItKog3AmyaCDZCD/cStwmxoILKsxzevM3XT2E7+Xq17IelpI1BuUmqtecnXrhVY07RtAwtt1Jyo67umab5XNXoMOoCNgTlZrvyB3hqmFjDZ8lH7qEl1rXlB4/mWQkJZQ1GCc/zBJ38XP/Hi56m9RzaRuAmWpuGgJKcFdtsIpmuCMqRDzbalL5GhHu644zS5HZ3guSkVeJc+NNIsyWii/jKfRmeSU4bkdwuiyxB9hnwuy7U4MlMF93hsiFl7y7Xr8ravcfMFdndEsnUUw+Z/Nfb2o2nONRt1IpK6T8qgINEQI00jRTnvBDIH93STtG5W0Lw3JP/j78oqHmcXzhlp2KpPFdTgnW+KLa3g5P2mrPevk72nH1opcm9N47aWdcUEeADFRlU/xnuSqPa2pafODckOql5Q+qSrhLpjeXH9iA8fnnB6Nue0vyJPSqzxpLEqNa/CIxbWOFZll8vVgN1tTj6zIWle+LjfzcfuE6qGMSZA73gcmoKYAe+xVWs3t2E5LRBe+wj7G3ju0/B+WcdB1HsYv6VGVH1kpKTOknobGjUmUPcyyFLKcUYxSWGcQT8LTR87PgqrTXwM6hMqsQ5UH+Liv8REh7iJPzcBiGNCejxNwdcBalvTKFhcBMT3fs/qNugyYwXLJs2c4u9YTYm3b8ayXGua5Qn81t/hUZvi4/ZaG+fsQlPO1IJJw+8ma2FYgU1h0sePe1BVmMLgXbxpOBP+3xZCFlzvr7/WvePXqHIfxmH8AA5pcPn1V3P9O+4wDuMwDuMwvnfjU4Pv4+NjBbiS4nz8+LEmiAH1DA+HQ21YKfD6+vpa1R6Apn/7/T5pmioIE6UGoE0o297toihUUbFYLBS4393dqR+7rYQQrYWkjgV+CjiU5OlkMqGua220J25r2Y71es3l5SWbzYaLiwuccyyXS7Is4/r6WvUdeZ7z4MEDIChHBoMBl5eXPHz4UGGuJIfFMy3wT5LhAvQEBIoKRDQionJoN0SU4oNs83Q61W0Qz3ee59rMUuC6956qqrT5ZdvXDmgSvtfr7TmZ67rW5LwoPhaLxd52zWYzRqOR+szlF7mcA3I8BdDKPpvPQ7V7MBhoU8WLiwsuLi4UlEtaHuD169eqD5FU8NOnT5nNZkynU169eoX3nuvra4bDIcPhkMFgoCloSRrP53OKomA+n9Pv9xXA9/t9TRpLg1ZA1SFStDg5OdHzTI6luMyPjo7Y7Xaa7peiy7vvvqtPANzc3PDy5UvefvttZrMZ8/kcYww3NzdcXFwwHA4Vum82GxaLBbPZTFPjcmyzLOP29hbnHG+99RbL5ZIvfelLLBYLzs7OGI1G/OiP/ijf/va39ZjM53POzs5I05QvfelLfPOb3+RXfuVXVDcjTxpIEeTu7o7r62um0ynf/va3+fDDD3n58qU2yhwOh5RlqT0BJMkt16w0DJUnFqQwJGqhdvNZCPqa8Xi8V+SR+4K8TgpO0mz08/w/je0k6d/MNbznvL7/utbfjJLINa0keFuVsvcx/sw4H5UNcVGtNOn+4+Kf8N4WYHctOO8lEdv6W1bSqT4C8rT2+AhQAWyBeqZdJnOjaaooq436C9MC6t6EdJ6kVe39pLkHW1SY9Ra/3eKrCozBalI7hOa6MeSHCV+HRpVh5LHaYPFsSSh9wsLlTO2a0qesXJfSpwqZNUMe1STS4FKS3mvXjesOzSsLEgqfkpsChyWJz8nX3uBoucV9RnIPIIRlGDrx84TgLBelSulTtkIffMLWZDhvWbpAbV0npRqExomi0tCiQqsiIH5oaf5oJWEf7097KozWeSm6krZTek/rc597GCls+AChMa3j3hxT4wjKkQinvfiCWuepNITVNHprbi4N518bkmPAxdS7AuFSYHwAvy412MrruStzlgadiTGYDMwWUmPwKXDd5eb8lKvzEedncybd7d4TBRCaX16uBtx+NCFdJnQWkGwaXYlPZd9E/i732Rr18t93mYfCVUjLyza2tTLhe1K8MPo1BGglbnXZl9oY8DAO4zMZ98+/1vXe9iBBKFB1DKlJeLscc7TtcWtWvOnM8ZMc+zumcNRne96DaQf6HdhsoLIB7GbxY94L673bhHV1O8HtXVfBuY0JBdWqCuntzIQ09SbC7geDANNNVI2UZWgg6TyNBsVH97cLLm1Hc62ZsB34uFzn0Sd6rA+LKGtYV2Hbswzy6CvbxV/uLokNPm2A5o7YIJNQbfZ1+CVuswD9p7GZpo03zi2w60AGPO2FOR334Z0TmG1w370K/u/5GrYl3crSK0zos9mJ1pcq6lnwQXEGzT2ndVwP+e/D+EEe750N6SSWxbbio9sNT4/7n/WUDuMwDuMw/pYanxp8C8yqqorJZKKNEUWZIeng1WqlGo7RaKQQWho2iiNbktSSiJ1MJnt+bwHcAggF0pZlyfX1NbPZTBPAV1dXXFxcsNvt+MIXvsDZ2RmDwQBA08eAepcFokviVOYuQHm327FYLJhOpwrCpYnf3d0di8VCm3hCk+wW/7FAY/E0Hx8fs9lsFILWda2e8bqu9Z9s32g00v0qDTIFjoraQSCrQHFZNoSUd1EUuo8hFBpGo5Fuu/yTdL2sV/Z9kiSaor6fCJfjK8sQOCnpcHGlC4iUfeKco6oqer2eJs2Hw6G6vtsJZSmieO81ZS/NPOUYiQtdzq/T01Pm8znOOcbjsapBZrOZKmeWy6UC7W63y8nJiSb6Zd9JwUOKOqJnET3P0dERgBYJNpuNeufPz89ZLpd6nCFAaikUiQpkuVwyHA41SS77TNLpAuuHwyFXV1ccHR2R5znn5+dAcLvPZjO22y0nJycMh8M9iP/8+XNNfff7fQXrd3d3vPfee3z44Yf0+32ePHnCfD5nPB7z8uVLnj59yi//8i/z6NEj3rx5o/tPXNuS+Bd4n+c5u92Ob33rW6zXa25ubrTg0m58K9egvGe1Wum5fHZ2pk+ASOHMWqtPl8j7pMAjjnVR7ozHY8qy1EKB3HM+z4lvBdqfoCP5mEZEQpfxb1igUQ+YBnaZmn0gF1+nr28luAVG2zJAO+Ohzgy2CH9P1zl7wLI9H0mLI3DN33sNra/N/vsEfAqY9jYkh+uOocpDQqzOTZPuTttptY/vI2NaOgdo0u4RjiZbh91WsCugCOovkoSdLyl9UJZYAvTOYqo1Nz6mwcMKLR6HocTifIDJCZ6Z6wewHJtRJoTYfBaT3QLX1e3tMxL1zDQu7q3v8EnDRTAujSlLn5Lb8mOvS4xX7Yl8HfaX21sOBD94QUJmLL4oSFY7vMlVpSH7UIsbLbbUbg4pTyK41Oi5YGu/55CX0eq7GRfE/vlxD4S34TjW7zdydAFCtzUkXhKNpimOeGMUerdT3uLwbmtTZB5tL7mkzNWBXQdulOwa6K3NIuMyXBbS38a3YHEJdRfyK8Mm63BhxhTThE4azoNOUuO8YeG63M37dK4Tkm3Qm2TrpjhV9ZrrICm9zslFBZIk8dOtp8r3AWHdMSSlb56kiNtrCx+f9PC6D10aU5rydJptjveBSR3GD8y436lZvx8v4lioscYydF2Oqx6rbMc6q3ED4EkXzvow7geViCXAbGOgto0bO4np5yJe9NpE0kb47aF08Z4ZHyHxBioT0tK9DgwytJvkzgSvtvOBCGs/Ah8+r9r3PqPbAUQ4bT7O/12cK5LYToLfu4wV7cQ2+wSahLonvE5verb5ZQjgK6AO75f5jLJQFDAEoN9bBiVMkuC3BdShaWjmw/9/axPNWiA3+vFwOzmM32qjk1q+dD7k/Vdz3n81P4DvwziMwziM7/H41OBbhqS0Bcgul0v93HuvQEsaAQqcFA2IpK8Hg4E6vcfjMZPJhOVyyXK5ZLvdquqkDauNMQoYBapKCllUFeL+lYSqNMyTBoiyXHFQC0AVsCeATuBru9mhc443b95wfHzMcrlksVgoaBX4PB6PtfHi6empwttHjx6x2Ww0QS4paEkU397eKkyUFK73XoH5arViPp8rjJeEt0BoSSTLvpYkrDT56/V6CsFXq5UCfVmPQFJJcotDW+ChpMYF1GZZxnA43NOYtP3su92Oo6Mjbm9vdTminZG0tgBSgfenp6csl0vdjtVqpcD5zZs3jEYj3rx5o+uQc0s0Lnd3d2y3Wx4+fKjn4PX1NWVZquZF0s3WWs7Ozri7u9NmiuJ7l0Sz957JZKIJfkm/yxDViexL0f50Oh0tUojj/O7ujsePH3Nzc6Pp7Kqq2Gw2qld55513WK/XfOMb32A2m6mi5vj4WM9PUZ1Mp1PW6zWDwQBjDEdHRzofcZhL0WKz2fD48WN2u50Wn7rdLk+ePKGuax49eqSeb3ny4tmzZ6phkWatst7Xr1/vNSq11jIajVT3s9lsFELL+Sj7T5L5UoQ5OTnh/PxclUBybstxbTu+peghxRm5TrfbLbvdTnUp0iT08zwUvPn9j5qANc3r2qlYCck7+c3QBsstYNmG1tJAMiRFBZT7vXS4cQGAZ8sA8Orc4DMa77hvrU7WEz//mAPctviDcF4T1mmrCAcddGclpnSxGRdUvTQ2pjTsxgl1J5ybnUVYeZ0ZXIemuZ+EfD8hiGqcDyA2NZog9kWBK0r+/POf46OqYhEBduktW1OTG0dmQuJ75xO2UUey8hk1ltInZKYmNyU1hlUdircDW1BjFIp3WnAbiEnvRkeSmZrSJyQmpsPjvm03rYSgRqlb8DwxjiRS1kaDYujEZpuA6kwgAPAEx9ZnmjIXcF4TH9O1lqTwVD27p9nR43gPHKv3maYYI8Bb0tBy/oraxmGaBqqJUbAtQHtPT94+l1rnpqzQW6NFHFmeFndo3N17fnxRz94roLSVK96EeXlxjEeFi3Fe565PLthm7tpUtQXIidsnHMxW4BODf2Mpt11uVynpRBRRJlhEHHDVJVuGuSfbsO50G4pCpo7NYKu4vNb2yLyTsrlImyJF+JmkxpNW3USKVuJVd1k8NqZJe9vK6z7/mz2ZchiH8Zs7PgmVNs0UvZUbSrhZdX3GSTEksynzY8eyu+buyRT/7lsw6sI7ZwFK74qQwB50YNQLv0w2HtYugOBREpLdlTxCZNAOzcYGSCyFohrYhgITuQ1J7aJCH6fyMbFtk9YNJFYcLUH5FZ+6Cb+oCY0ty7h8AeC1ayB56QLgdvGX8qaEog6vTW2jSfEmfL+MDcWNiwqUjNA0U5ZB8wvVpmGumYNcXOB1cIxjoNuDIwtf9rDewbeB64TS7liV2xAor0L5t3Y+PBn2CbTbt/57GIfxgz6++ngcwPfLOT/+ww8/6+kcxmEcxmH8LTV+3eD7MA7jMA7jMA7jMA7jMA7jMA7jt/Ywn/ilAaw0DU7qlu3EkPuMR7sRaZby7emGq7MN/I5H8A/8SIDJJgnw+KMLmK+C33vYC/z1YhOUI5MIvgsPywi0MREM27AMQ9CbQKiYqh8rQvGiDoWwOjqZEg/dWHHy0eVlk+gHt9BJY9U4/qyOlVhroBsrylVcXlXDrmoc3d7B1kV3VwLDToDzAut3O1jswrxyE5LcPv7MuzBPQJuCJjbMKashJ4DxoggfTRKaX3Y7MOmF4sF8A4WjrGvKdY11kJfhyZmd8br7Gvj9N4Pd7WN+gOKH8YMzvvqo8XwfxmEcxmEcxvd2fGrw3ev1tCmhJDIhpHzbTfdElyGNK0X7If7oyWSiqWvRYVRVxWq12mtuJ+nOPM9VGSFJ1uVyiTGG09NTqqpit9tpMlQStaenp0CjN5GGgtZalsslvV6Pm5sbdWyvVivquqYsS02wi8t6Mpmw2WwYDof89t/+29VzPJlMeP78ObvdjpcvX1LXNfP5XHUU7e0ULcNut2M0GtHr9SjLUr3Uso3isLbW6v5zzml6W1zcst+899pkVLQQ0jTRWstisdDGf9K4UxzconfpdDp6bCWlK/qaTqejqhnnHGVZcnZ2pr520bIA6kgXDcpyueT4+Jj333+f6XSqKhdJdIsWRZ4guLy85OrqijRNcc4xmUw0eS0KkaOjI0ajkaowZL03NzdcXl7S6XRU0SFPB4xGIwaDgepf5Py8vLxkNpupd10UMVmWcXd3p0oTmau42WW9ko621qr+Z7FYqAsc0Mad0tBUUs8AT58+1XS4fD/LMsbjMYPBQD3hosG5urrSJxmWyyVnZ2eq7NlutyRJwvPnzzX1vdvt+Oijjzg9PVX//YMHD3j9+rU2eJWktVxb8n1pQnlzc8P5+bnuC1Ecrddrer0eb9684Tvf+Q6z2Yzr62t12d/d3dHpdPScms/n6n9vu/pHo5HeO05OTlTX45zT60+uRXkiQs6zPM/16QO5xuVrUdd8Xkc7xWrqlmZB/g5tPROsqgGIwsyYOUuiuqHeT6QC6vwVJYUkaW1JSHpHx4e3kOygd1WSbCrqXsrycYe6G3QnqkX5pLSnb/2jldyVtG/d/F0tj2N740k3jnRTk2wqTFljao8pKjrrLT5LoZORPRhSjmLyuQgrqAaWwtigdahbaWRZt2ntN0KC3ZYOU9fB7Q38xec/TxUt3AvXITcVK98hp2TnHZlxsXllcG9DaBS59RkJUX9iavVuO2/JbUnpGq1T4ROct2Sm0iaW0iCzvg9xgMxUbH0Hp800Y2K7ne72oWnm1mfkpiTBUcRkeE1YV3iPJzFNrLfGkNuStevGNHhYR25S7MkxxaSLqSHdOG2Q6K3RgKJP7x1fA0kheg2jCWhRjLjEaLI//Mw0bmkfm6m2GqF+bHe0n27wYKqm+SqgLngITwDI+d1uvqlhyqj2kPd7s68CksR4WFcANM40jR4xIcWuTxbIfA2NL9w066BuPYlAPP8j4zK1J1sZXNdg6oRq2zyZ5GyYV7IxJFuo+mG/13FFSeEbFzk0x8k0CXWI2xLvCaRx3TEFL/tTVEmiOfLxHuHSmKR3aGrfVk6975IyP4zD+MxH64kob9p5YUPHp3R9SidNWY4cpusojnM46sFwAJ0sprq3ARwbQvI770LWDQvKq6gUMcGTXflwkTqC3sTHRhImpsJNFiZUV43GRJpdGhvc38QbhI9JbIivi9vUbnapjWRjYrvT6uArNx7TuhFFRq6PhlnC+8XjbaoA3Ks479rDMia+6QSoLYoTbX4Z5yZCbtPaFhOBuLPxZ0lwix8NQvo8AcoKX9bUqxJTe6w3ZBicCZYY4u+EMOOD2fswfuuMr0Tw/f4BfB/GYRzGYXzPx6cG3wLWut0u6/V6T7Uh+hKB0OKens/nqsEQD/RkMuHy8nIPgolbW9QGAuS22+3HfNICesXXLGqFzWZDt9tls9lQlqU2IDw+Pqbf76uGAwKcf/36tYJfQAHdYDBgs9kAqCd8u91ycXHB+fk54/GYFy9ekKYpg8GAd999l6urK31NVVXc3NzsvV/0IJvNRqFtXde6v1arFZeXl+rQFhWKKEBE4yIecYHSq9VK4a5oYwDdfwKVZbtFZyK6FQGe0szSe6+wVRQogHrZBbqvVisFuQLbZT+Jf1zgepZlfPGLX+Ty8lKXvVqtFExLs8jhcMh6vVbtB6AqlLfffpurqys9px49erSnHZFmiMCe1uTm5oZer8doNGK73bJarUjTVJsqiiJFwP6jR494+vQpz58/5+LigmfPnin4FygrChPZn/JPoLWodmTuMj9xxo9GI6bTKY8fP1ZFze3tLVVVaVHn/PycL33pS/T7fd68ecPd3Z1eSwJ0B4OBerql6DEcDrm5uSHPc+bzubq4Z7OZNnUV6H1zc6Ne/ZcvX2pzUTk3R6MR6/Wasiz52te+xo/92I8BqJt8Npvx7Nkznj9/rmoi0d6Iaqiua1WurFYrHjx4oMc5SRL9vKoqnjx5wnA45Pr6WgsKVVUp+BawLeelnJPtc1marcp75Hr4PI69BpKiDZE/6OPXbfi9p5uggVBtfUO7+Z+AxRaPbb3OKyQPXnCPLRzJusRUjqTMsFWAcPL+PaWqaZYvjSQFkMrf3qY1BwX6BD8xHuy2xm5K8B6zLTFlhV9t8KsVppPRveiQ511wDj8JWpzt4xF1luFzE0F/SMIZ7/FOoG0Al+nWY3ceu61jOq7C7XZsfMHa11zHhpQJnq3LcMaywJBFbUhuStWHbH3G1sm9O5AK0ZYUPiHztcJqGVlLd+J80JwI9A4NMIOmpPaWGovzJsJ0uwe8O6bSryE0ytwSDorFkRiv0Du8x+xpTwS8T5IVuS2Z2jUPkxX/2Lv/EMmTDt6aoLhogU2XRt0FNM1KI/S1ZdDsKARWV7ZvNaUMP5OijIvnhq32NRrtIkX7/FSNR9R0NJALPcY+NtTUho7t98miErRQ1FarSGEmfC8iswjHkzLAe7nmfNyG+9BXz2taRau4T+Q69JY91Y8tPMnGgDNkdWtbLNgyNgi1kG4Dq7LxXzmwDcgXNy8NrNZCU2xUaVrr1oKBNCCV6dRgrVfwL8fZ2+b/K7w3qqYRAH4Yh/H9Ga3zTS+09rdiYSqRX6ShsjVxPc5cn+0QXrxXUow81RcewckEHp4GwL0r4PIGtjvo9eFsCqMB9McoOC4LmO9gtos3niyA6vU6NLNMCFA4zcB0AvzdbUOqunCwiW7sgQugO7VBY9JJwHRRNYonAPKE8Po0VqIqE9bXSUJ62/nQwLL2ATynNqTL6yq6wmmaYsq9ahN/kDgaR5kLKfHrTVjmUQ2DHEYdOI6NPUTXYlyE8IRUuo0fBYwTCwJVEtzn7z2GJ6fw/AqyDn61pXh5jdmV9KqEjrPsElh3AthPdhXGOd0N+0ffYzCf2D7kMA7jsxyS+P7odsPdpmTSu/8/2YdxGIdxGIfxGx2fGnyLy/ry8lJBrADYdoNGcVqXZcl4PFYILA5lcSJLUlWaOG42G00AC/QVWA4oGBRoNh6PFYYJNBcvtYBfGZvNhvV6TafT0YaW0uxP5it+Z3FvAwyHQxaLBUVRMJ1OFW4eHR2Rpimz2Uyhs6RRt9utJlhXq5Um2WX9y+WSq6srdWbLvrq9vSXPc7rdrrqojTGMx2OqqtKmhVmWafpeHOiSoBbgJz5ygbaSoJZ9tN1uSdNUQTegyWJZv4BbAabiGpcmhAJh5fhBAMGLxYJ+v890OlWn9+npqTapzPOcXq+nAF6862dnZ3zjG9/gwYMHWiTodrs8f/6cq6srFouFgv/7nveTkxNteJrnuYLpm5sbvvjFL2qBQDzX19fX6rmWc1kKFh988IFuy26306S4bP9kMlHgLq7wPM8ZjUaaJj85OdGGkDc3N9ze3mrq/uzsTJ9UcM7x0UcfcXl5qen8hw8fkuc57777rj6NIM7ttv9cGo4KaG+nnN999131tMuTDZPJhK997Wvkea4g/PXr1zoveSJAoPJsNqOua2azGXd3d3pOyzm6Xq959uwZ3/3udwG0kCTnTlVVPHjwQJ+eGI/Hel3JEx3iOc/znCzL9CkR6RUgBRm5/qXI1m5GOxqNtJiRJAmr1UqvFTkPPo/jY2nX1t/2mnC9l/yWdGv7PdLQcg9qRQDWfE0DzgR4x/cmpSddO9L5FrPaYgc5nXlNMTSUg5j2bAG0j/UUE9BdEZzgPsDCuhN+mOya5pPGB2iX7By2qDBFhVlvoXb4zQa3XOHLip/81k/z40/+Tn7yxS9Q+pp/7G//fQD0Fmtc5xHpziqo033ifQD6LoBvW3iyRUmy2mFWG+rNlj//0f+Xq7rixiWsXZetD/fFte9SEtLZmamovaUwTUdGgccAJSHNXfsm7Q0ofC59Gl5vKpLoBQfYukybTpagvnBooHVYd4dEIro+gO5kz9vdQPD7LvHgK08UwhdxO3Nb0re7AL3TBW8lGXY6oT4aUOWJAmM9xq7Zt3L8jfPUMdVtXOPy3nPTG2JSOsCjtofdW6NeeoukrPkY/N4DyolpiikCoiP0bs9V59F+KqGVHJd17TnDpXgjADoe7rYzXI6BDGnI6lIUuts9uBwd2l4KMGjzS3k6IdnF96YNcBYPuLlHgFwWvNuhaWazYb4F+03L9y0u8PDm1nGRwkUrOQ9Q5RaXtu4fMaHuiJC8dU1poekwDuMzHgbzse9ZDMaHvytMYvFdQzGEYpjCMA8ak04aiqB1LIbWLsDmbhaAs94XTNPQsWpVlp0LKeq6jsA6fr/yYOPyXPxYRQ93WYWLyscbgDEBXlvC4yWx2CWrCJ2s5eYkc5Fkd5yDVgLjzyWN3b7JOcI8xC1iTAD1lub9xNeUFdSpbLx+COuIlULbnmT8vpdqaHxNNwvv6+cwCNoYn2fxtfF+ZQyJMS3didlf7t443G8O4wdvTPoZT6Y9Xsw2/I1Xc3703ZPPekqHcRiHcRh/y4xPDb4Xi8Veo0hJWwt8nU6ne4nLXq/Hbrfj+PgYCKBOGs4JMBeQ2oba0vBRUrP9fl9T0Nvtln6/r40RJXUs6d1ut0uv1+P999/XBpNJknB0dMSjR480kXt8fKyATGCb6DAE/BVFwc3NjTawTNOUL37xi3Q6HYbDIcvlkvF4TFEUHB0daZPCoii4uroCQuO9i4sLXr16xWKxIM9zzs7O6HQ6CnDX67UCPknBSkJcmk6KKkXWLU0L5XWr1QrvvYJgOUaSnBWtRFEUe6oIUaRIwWK32+G9p9frKSwWnYQ0OJTCxWazUdgv4FvWs1wu6ff7jEYjdrudgnDvvSpA5KmAJEkoy5Jer8eXv/xlbm9vmc/nzOdzrq6uuLm5UaAt55/sE9neBw8e4JxjtVpxfHzM3d0dAD/0Qz+k6xwMBszncx4/fqxwVZ5OkMaiq9VKVTySXi+KguVyyWg04ubmRiExoAUJAf6SSJ7NZlRVxYsXL7RAYYyh2+2qgkZUIqJOkQKEnNsyhyzLSNNUGzdeXFwAaAJfCih5njMej7U553a75Yd/+If1iQLZlxAKQXL+yXkpWh0pOux2O+7u7iiKgru7Oz1ukny31uoypdgj5+nR0RG9Xk+36e2339Zmls+fP6fb7VKWpb4nz3MtEMl5KE0sBbhLI808z/e2Xfa/NDOVlL2k+j+vIzSNi6CQCKuTRksAEZa1dCVtlYcCaIHZkvq6/3dkC04GwBW0CdLoMt06OvMSO1tCUWKqms6wC4/S8HrXpHx13IeIcT4CTNtQ3yVgi5j2pb0tBrMrYVfgqwq/2eJjEab0NX/6+c+wdLBwFX/ql/4CAH/kC38/g7LEPTimGnWpBimuY3FpALLpqo7p9RpvDcm2wi63+PUGv9txVW9Ye7h24emJGqPwe+s6QXESNSXONvqQ2jcAu6x7mvausdTe4mITynby2nnL1lvVkXzs+LcorcNGnUmq6wv7IcEar1+3f9Yxlc7deheWEdPj7cT41mdY73lo73iSznmceP7x934P9t0Jrpsq2Gwfy/C5VwYSFCVo2jiJDR8l8a06j/ieNqRunj7we1wG7iWl47mh75WfRYBdZ6aZayTm+mS/nFvJforcimpH5iDXQkx6txUqYT4GSWy3G1juJcElFS/XpZGfA1WrYWbs/xbOTbQhqy3Z407eBnidbpv0elJ4irEhW3psfI/sy6QMzUIlNS/HTWD4XkHANJ+LtsbEHZQU4Ri21S+SbtdjQygCODx4v9cM9DAO4zd3+F+TiXoj9xkDJsFiGNc5HZ9SHVk+Oi6ojvpUbz2EcQ5vn8HJMDRl/PB1WEi3C70eTCdBgbLbwZvXEWhH3cgWKE1o/FiuA3gunDZ3xgFJBeUyAu3o2y7iPwOwidoUG/71XUhHiz/bxHUUBHheVWFZeRpgvLHBDVJWwaNd1sHhXREbWKZRpUJY964OXvGqDj5u76OexAS3eSeqTZ5G1dK2CuusXJiHtZBHHYwrw7YnNryPuC+8byC/pMxrFxxYxsDRMMx9uYVuhl/v2F7MKO/WJM4z3IUnnjbWUFli8n3/IB+S3ofxgzy+8mjMi9mG9w/g+zAO4zAO43s6PjX4vry8VMjsvdfHVQVG3d7e4pzb05GI+gDg6OhoD1a1ndGbzUaTyaKj6PV6FEXBcDhUKNfr9VStIennk5MTnj9/DsDt7S1lWSqIBri+vlaNQzsZLm7jLMvUtS0AWvzBg8FAU9SSND07O2OxWDAejzU9bK3l8ePH9Ho9VbVAAIzn5+eqCFmv11xfXzMcDhWwb7dbTWZL0lb2rwDm8XisyhLRzUhiuKoqTk5OGI1GekwkEe2914QuoIn0uq4ZDod0u13qulZH+2QyUSgsgFeWsV6v6Xa7mhiGoNsQXQiE1Ph0OmU2m3F5eclgMOD6+pq7uzum06lC5aOjI46Ojvjwww8Zj8d7ipp+v8/r16+1CCKAdL1eM5lM9JjIkwEQ9Cbn5+eMRiOGw6G6vJfLJbe3t6Rpqt5vSV/vdjsWiwXGGD1ecvyPjo5IkoQXL14wn8/Zbrc8fPhQFSyy/XL+SwFDzh0pRAjgfeedd/Rpgc1mw6tXr7i+vt47DoPBQItHdV1ze3urhYt+v6/qkrbeRfznR0dHDIdD9YUXRcF4PGY2m6lTXfavFDystVxfXzOZTFgsFmw2G923q9VKwbxAcLme5DwSH7gsazwe0+l09NrN85w8z3n06JGms2W/vf322+oi73a7ei2ImkTO7+PjY4X1zjk9PnmeM5lMMMboeSD3HHlyoa1J+TyOJD5BbZzXtKm34fMAmyJ1FG6qadf4Zd1AaXF2B6ht9PV78DsmPlWHEr+fLWqS5Q6qGr/ZQFWTLLZ0ljlJAbtpAHcCvjUtHrULbVj4cZDYhMEETrvE4DqWepBhZwaTJAF+1zU/+fIXqb2jwlHjKX0goov48T989lP0TcIf/uLfR3Z0RDYZUp+OcN0EU3nsrsJsq+D0ThJMWcF6g1uv+VPP/2ve1Akrn7J1GSVJBMXEjyHBrWlpn7CNnheByYVPQmrbh++VPgkA24Sfr124j2emDgD9Hox2uD2I7RBdSorzhsSgH/U13uzBbGu8fk/nRapgPiy3WUBmajqm4jhZMrE1f/Sdf5Dk0Rmum1H30qjGaBQZctzaaez2920L4jYHGk2Mi/dbv9/CF805w94TCZ8Q4Nwfhj3o6o2J105rfpKydl5h897PQHUgbbirepekOY91Pybt5LZplpU2wFgBPc3XooTR69rEJHVG8NnXBt+2PBmou2HZrgM+NSHJnULZNQqpgzYmJsXluBmjhQcg+n1bgL9dmPJNkcNW8ZpuFwriNqnK5l5R60CiDuP7Nj7FPUHgt8XSJaXnU2a55+6ohqmFySgoTKZDmPZgtoDrZYCy01GAub08/CsKWCzDOZ73AyyufLgGKhf0KM5F17dRZXdoLFk0FULvYzPLeBEqAE/CP5tAGYFxRoDGjrBMeezCGjBpSHojP/cRZpdBRVL4AKg7WVhvmoabc0mYg4vwO6atsVG1QgKZhVH0T12voIi6lJoA2rMkvL6oQ7odG6C5zqVdIQ3HAPGOGxOc6Z00zG+1g3xLvVxRryEvoFN5nIGNFCr1l83hBnMYvzXGVx+P+S++/ob3Xx4834dxGIdxGN/L8anB92q14ubmRgEeoL5pAaWiXmj7pwXUlWWpLl6BheIAds4xn88VxEp6WhoDbjYb0jRlsViwWCw0ISyA9+nTpyyXS5bLJbvdbq9Bpegu7u7uND2eJIlqUsRBvNlsNDXd7/dZrVZst1sFygJHRa2SJAl5nnN6esr19TWvXr3iyZMnmk6GAEjbTnTxdK/Xa9V8CGCXpLyAWEl0Sxq71+sp+JOEvahTpHGmqB3aaXzxKAOasJbErKg+BCKKwkRUMZKKlkSxpJVlOZJkluKGAOzhcLinVlkul3S7Xc7Pz9ntdmy3W25vb5lOp6rieP36NVmWKYy+urri9vZWoaZA1dFoRKfTYTQa7WlayrIkz3MF9dLUVJK/Aptfvnyp+1wSwe10sOhLRKcj57DAZDlHZQh8ds6pgma5XKrz+vT0lKIoePnyJY8ePVLdiySdZ7OZnmOyfVVVaSpb/Pf9fl8VNbKvpeiUpuleIluate52OyaTib5eALOA6bIs99Q6RVHokxeS3JfihSSpf/VXf1W988458jzXRHyapgru5XwTNY9zTht3fvDBB2w2G6bTKYPBYA94A9r8Us5V+ZmoeOR4A7q/pBgCzZMHrv0H1OdsZCtHuvUK3mzl2Y0TXBqUEKYTAJ407Gu7u4EG/N2DUuoAlpSrNL70ER62EuBJ6bGVw6x3+NUKt9liygp7nTH+Tsby7T4us1T5PszcV0jE9K2kyuOl54LtQx3GEuBzadA3AOGP9uU6eLqThNLXCoPXriYzhjZfLbyn8BX/t+/8V/Rtwv/46e8mmR2T5jn6OHdVhUZb3QxTO/x2y3/63Z/l26Vn5rosXI/CJ5Q+1YaTqiPxWQtUZ03DSOMj6E5xOE1a7wFtjGpJynsp7wRHYhwWhzWtdHYLtNu4DlmujNKnmjC38SDIa503OJL4efCIJzh1hXfi/B+md/xtWcUf+cofIHn7BDfMKY9y6tzq8WwXVTSpTfOzcLDD8fPWBIArKX/k/UYZxt75Qguea0o5Hi/fOqnlLffn0U6Py/VSN05xmZuoVto+fCnIaOq8XaCJr5f52bJxXuv74+Ld/iFttovg7vbGaPJclu9Ss58MF5+2bfapy0LaW+asTWFT8CXhHpG05huPU0izm70ihABw20qeN6/9OKC3pd9X1cSRVjTHXfZP7TGf3zrlYXy/R+tpDx1yjsbGkykJ/TrDWEPRcxRpyW6YQ55DPgwAtpvAdgOzAtZlfKwiCynvPINdCZtZaHZZEl3am3BBlFXzb1WEn5kEbTop94oi3gRlsrWPBWsTQLchQPY0C0DYSVw83gNtElPmcf0eWBZNo0tMmOftJnwsfITxaUx1E5LgzjfJae8CuJffi8aEdY/z8HEU/l8upLxDMjvMywfInYqeBcg7MApPb7IrAgxPfNM8U7Z5kIeCQVkFjzgGHp/AtgzfswnVYsu6XoHzJPH/RWpjYlNig3VhgbUWEr4H59JhHMb3eHz1UXjC+uuvD+D7MA7jMA7jezk+Nfher9cKZiEAJ/H0FkWhkFN0BbPZjKOjIwVXAo/TNGUymTAajVgul1xeXqoqoSgKBoMBaZpqs0kBmXd3d2RZRpZl2jhRvNviDpf0aRtkVlWl6WOByqKfECdzGwZOJhNVitze3rJYLBToigdcttt7r77uo6MjTd+KgkPAoMBncTCLV1o83AKSz87OdD9IgnUymTCZTDQB3uv1FOCLIkJgfNv1vVqtVAshIF7S7aKkkH13d3e351OWgoCASElbt3UosryTkxPm8/DLWdQn4/EYQIsJ3ntV5ZycnOj8bm5uuLm5Icsy3rx5o3N9+fIll5eXCtFFT/Puu+8CaPpagL64sKUhY5IkLBYLPvjgAxaLhSaX5WmCqqq0gDIejxXMSlJcoHSSJJyfnzMYDOh2u8xmM92vMsTXvdvtVA+y3W7VYy4p6vfee4/hcMjl5aU+HbDZbHj9+jXf/e53cc4xGo148OCBng/i3d7tdqrdkX0rUF2ePJAmlbe3t5o8l32TJImec22ViADji4sLjo6O1EMPoWgj6fF2Kl6KUlVV6bblea73BfGdi1ZIljGfzxmNRjx79gxA97k0pu33+4zHY30yQp5+kHN6t9vtNRCV86+d/JdrS34mBbrP4+hfFNhN4xnwicWWGVU/qDt2I4u3IR1qBPrd06AYJ27gFoWT9K18FFjQguOxL1iAWZXHbAtcUcY/aMNj0aasSTcuwLssNGIEVAHxMd9vm11GQOkysFWYlPFBV5EUPgC3MmyMW62hrvlL3/ppXlUbLl1oOJkZwwjPnUsoIyXsmpqOcVhgXdf8Xz74ayR4Jtbwzzz9e7GDASZJMKMkaFScwxclt/Way7rHzPVVaeKihiQxntqbCMJDitt5S9/u1MkNNPqQFqyGBn6XPlW4Le+TxHhiAozOTBVT5c3PrfEkUZVyf9TYPa2KjWUAAevtJpYyrPEkxjGyG3JTkpuSp+kdf/Rv/wOYt85xWUJ11KPKEy1AKEBtwWoptrSbNmq6mAZy29I36eOkOd9s2UDgBnq3lkmT/t47b9pp83aBpfU0gUBdQ+v9kdm4NEBjRNNTB5idVF491d6aFhj3e+sgjQDcmJDsjpoRn4Qn+dvu8wCq41xiU8/29hgXAgc+IapIvLrOxdld90KBq+p78uugFimHkK4DKK/y2Hy2lVLX7Y1z0IKECXPcUyJJQl/gvwDxmGA3LuqIRINkTeBNAvq97DeaIsNhHMb3Y+jp1qpCScLYWDo+YVJ3wMDVsGTTczAaQW8K/T70u5AnsNkE+FqnUGdguzAZQi+DFzdwtYxubgIsnm1C2jmpQ4p6V8OiiGoTH4B0LwmNJ2sP2zreI+XGZhTO68e8G+ajcNs37R16NjSrbCtENlV0hxOWsS3hahWAsrwmtbBKI/h2Ybn9LAB9Bd8EQG+jy3zaCxB+NAz7tTKQSHMOF+bQiUlySYv3cphE8L2M2pWS8DiXId5E4vs7GWxKoIBON6ynivoVm1JlM6rlEls58sKQediloYmucZA6j4/3dScnwd/ktnP/dngYh/H9GF99NAHgV18vKWtHlnz8/98O4zAO4zAO49c/PjX4BtTdLSoQ0R8ITJZmj845haPtBnMCo0Td8PDhQ7z3fO1rX2O9XtPv96mqiidPnmhjR9GhSOPKJEl48+aNglhJf4sDWVQjkoyVFK54o09PTxV6CxSU5UsTw+FwqG5wUZF479lut+pyluaWxhg6nQ4PHjwA0O9BcE9Lilb2icxX9osk3EejkSau+/0+vV5PU8DigG6nwAX2SSJZvNCApsslWS66FGniKdBb9g+giX1J/wrY996rn1mUFpI6B9SNDqh/WtLX0lxRUt7r9ZrlcslqtWKxWOCc4+rqSgslb968UdgpWo40TcmyjEePHvHw4UPVh7T1G9ZanHMKs2U/ylMFkkyXJxRELSP+bFlelmVMp1OGw6E6uQeDAYPBQJPvoueA4L2HUBiQoo08TeCcU2jf6XSYTCZ7SpzLy0t2ux2z2YyPPvqINE15/Pgx3nuOj4+18LFer9WjLX57GaJ3keKRFHfk493dHXmeK3wWVc10OmW1Wmnh6Pz8nOvra32dFESqqlLALTobcdBLIUN0LYPBQBt/Ssq7fc6J734+n2t6XYoo4imX80SeFpBrTe4jcl5I8UauJ/la7k9yzD/PI3sxw1R1+KPYOXy3Q7LukExzykFKnYU/mNu6hDZcFmhlS78HwT6xWaBrAb7Wz20Npg5/Xpo0xW13UNf4XYFZbsjfGDB91g+yj6sjErMHDcU1LnNQ/Ur0QYdEVwPNvTWh6eRyyZ/68K/xYeWZuZSbus/WZzxNZ9x4FHqHVRgKbymxlNG7nZuKlff8yQ//Gqe2Q9ek/KEv/hgmC9vzHz77Kd4ve1zWY1au+2tC5iRGlx0Gh91rIln7AFrEue280fS1APGB3elyZR3txHiCC4oVn6oSpcbgXAO3k3ggpcgQCgBtb7jRRpuSVtdjGeF6gmNkt0yTFbkp+e2dgj/83u/FfuGU6ngQEvy9BNcxDeSMyd62pkbUJd4EDYitfQCfdQONvSE8DRCPveg49miEFGMcTfowfgxwu9FvyDJ1/QLBW+cdNMUXfKNekRS1NJPUcxW0qSo0qhC5LtRdL+urvS7Htp5YaHvQfSKJ82Y9bTC/956kWVbVCUn5dNvsa3sTj4FpLszOHJKdb4oRrX9th37756YOHEo83dqsVAoI5l4RIv5HvOLIca78x/YRJoJwd+/mchiH8X0YJv5HztkUS0JCYixlHs5Xl0d39SCHSQ6DTrg5EH/HmiQ8CdTpQjeNMJYAZCUtLYoSF8Gyq8FHp7YUjqWpo7PRTd1KdftWd1p1HiUN/Jb3a9ONmPKuXHBtex+W4QnLt+H/DSjroCMpo77ERJDt4/whzJu4rCI6uzWBHpUnqx3criGvAuxOImyX+RkIVfY4T2ju12VcT1XHxp1xG71UHF2A77Iv5VYhkL7XCe7vuoLlGL+tqO+2+LLG+FBPMETllDeYKOzyH4v9H8ZhfPbjraMeo27KYlfxncsVf9vD0Wc9pcM4jMM4jO/bMAGkvg1ceO83/12v//WMT02HjDGcnZ2RJMmeskTUJhcXF9zc3Cgs9N4raAa0sWVVVeoWFuWFNCqUZa7Xa9I0VbWDADJrLa9fv9YmdqvViqIoePr0KWVZcnFxwWKx4NGjR5rKFWWHJKnFUS7aBFFSrFYrqqpSX7msX9LP8/lcoeJ6vWY4HPL48WOurq402SsKEoGEl5eXmsydTqfM53NN20r6uixL3Y/iNJfEblVVqteQ9LsoNaBxUguMFRh+d3en6fLdboe1lsvLS1XSyEfZP7KfRU1xfHys0FP2v3irJaWeZRlFUfDq1SttfCmO9s1mw9nZmSZ9t9stX//61/V7AqCvrq64uLhQAPxLv/RLPHnyhMFgwHA4ZDKZMB6P1RM9n881+d5OnrfTyMvlUgHskydPGA6HfOMb3+Ds7EyLLpLaluPabqYoLux3331XE+Rv3rzBe8+7777LeDzm+voaCEWO58+fc3Nzw6NHj7i+vlbPuBxD8aaLmqfX6yng32w23NzccH19zXg8ZrFYMJ1OtWnq1dWVNhFtu7Pl2Ita6Pz8HICrqyuurq64u7vTpyYk6Q0wnU5VBSTn/+3trWpshsOhqlPkKQ4pDEihQ8CyFKXkqY5+v0+n02E6naqORIoL2+2Woii4vb1lNBpxdXWl4Lp9PsqTCHKc22O9XmuDVEnCSzq93+/jnKPf7+u1Ijqiz+24nuGju5o0he0Ou+mQeo9LBqS5xdsAFtuKkyTWKW3ZwLi9tLUhurx9UI0krQZ2vvl5uvMB8hkDicUXBXjHf/rdn+X3v/Oj2LIg2ezgQT8kt8tPWofATo/FBN4of+ObCEONCcn1tpYFsEWNu5nxJ5/9VV7WKaW3JHhyU7L1GR9UR+SmJDM1uQkrX7lMtR5b36hIMmpmLgUKRqbiz37wX1N7z40r+E7Z43l5wkr92xUOS2b209OAerPL6Pe2NqbSsTiPprPlCfc6AnIb9SK5KdnGOdbekNtyH167LlvfofQJpU+iksSwrbvktgza15ZPop32lnR3e76lwG+f0LUlA7vjYTpjajc8Tgr+Z7/7n6J8+xT39yTUeRI802kA3kGf0XjXoYHObWDqrWkS1i46tJNQ+NgDvc5gywYIKwj2rY/q/zZNMUaptqz/43C1rejYa4Yp67aoQsXGJ+ytpB1pYHxbV+Ll+75ZrkBwb0w4d2PqXZLfLg3FIlEUaQNJvw/QTZyHNKZNiuDwVke6bRLxoj/p3sm6CU9htAsIcbdo40ovMN3rMSQ2ojR1cwy8MWB9s52te7ZPCKn4eE/wyDFrQe/afwzoH8ZhfD+HgdgoAoXJA58x9B12fc/tSUXdSainR0Fx8tYxfPEkJrNLqEtI8/BvkAdlhwFWa1g6mG9gXUWHto8fqwCg1wVsCoLaJIvXekw3lwRIbG2A6cZAtQsNNGsT0txJ/Fkam0sKPPY+JLm78f3rIuhYDOGCtCaoWDoZrDYwXwfFyboI4LnXDbqSXRW+Zwhe7sSEtPWmbFix90Hj4lzQir24gVEPvlg2TSxTgfNJ+NwRQLoPm05ZhxS8JzjGaxd/YML+qKMLfLEL67aEuZQ1rLbh9acjOB/DzRSmE/x8TfH+dzDzFR0H3dJQJZZdJ/Q+SktPUntqA7U1H7t/yTgg8cP4LIa1ht/2aMTPf3DL+6/uDuD7MA7jMD5vwwDfBH44fvyejU8NvgWwCmSUxLCkgiVtXVUVo9FIk8sCsCTFLF5iUUqMRiMuLi50Ob1ej263q6oH0Ua8ePFCfdSiqpCkb13XTCYTTk5O+O53v8v19bXCQAjQLM9z5vO5pkMlnSugT7zk8j1pDiigtigKdrudvjfLMubzuQJGSWPLNgLqUG6DS2l0aYxRzQegCeNOp6OqFYGH0qhSoKMk1QVKJ0mijQwB/VySzJKubc/FWstoNFJFh6TCRSMjx6/T6egxnU6nqryRNPf19TVXV1fhZIqKkPV6zWw2Y7vdcn19ret/9uyZgn5JC5dlyatXr3j16hWLxYLtdsvjx49VMSLnifjM5XgCHwObnU6H8/Nz+v0+s9lMveAPHjxgPp/r1+3tOjk52Tt3Zf+9//77CrCPj4959OiRKlnafmkpBkgDzsFgwM3NDScnJ/o0wGazYb1e881vfpPdbqdPH8i5/eDBA1XerFYrXrx4oeelXAvSPFMaRMrxmc/nWtBxznFyckKSJFxcXGjqWdz1kp6WNP+rV690P8qTEJvNRpclup/NZqPwXNLgMrder8dqtdKnLKqqot/v6zkm3vaXL19qKnu5XGoDUdlH4iwX9Y6sQ+4f8hSGLLfT6ehHgeWyPlGxSPHn8zj+zK/8ZwB0TcaPP/4dmG4XOxxguhnZIsOnBpemIYHpjCoLGpc3+wCwnQ6Vce85YHEH2zowAVt4rKTIALxn7Qp8UeCcx2x35JcnpG+n+LShcEFvsb9smVNbdxEI4P78TB1UJ3ZXQV2zcpaZyyl9QoIPIDg6tFeuS24C0AUYmIKtT9j6jK3rME2q4OXGUFOzcJ6tcSRuR41h7TLmLmfluurEFvd17UOyW4Y0nUyihxtopastuSnomEpT1bkt1RUeVCdhXgnBsz1ISiyOgd0xMAU1RgE+wNp12LVUKKJfAVrrTyhp9ov8TJLeQ1sytqHQPk3WTO2av6NT80986R+A3/Yu9dOM9aNciw1ybHwLdFt/Lx18b0iqX1PNcp7VHpKm4aOJKT9Vanhw2oAxnAdNk8RG3bGn1ZDUc4SxNupJfBKThS1Hdlsr4mOa0sjPavavl/braABu4nx4soIWKI/pZkmDawPZGvXPyhxt3YLCrdR3G1rbyuv8wudoAQIaJ75cyzbuGxPZkhYREjkesi1SVGq2S7dTtk90M/V+qh5ConwvjR+PtUtNBPSt1OYhdHkYn9W4d08KXNiQWItJfUh8d5OoNemFj/0McGjTSWujRzsJwNg72LkmvVy7cD8roupD/tUxxWxN/D3WSjh7mmSzOLTFx73nGopw20eoDjR9DeJ7HM3vYFGbxGIWNQEgi8pEg9wRBtdxDmKNc76Zl5WqnGxjHZZnLax3YR7dLMBuYorcth/7oUmWV3HfVDHBLVTcy7Jb/3Q/0HyvkwY1TK8bGo7WHt/J8KmF0mNdc0/38b2mffM+3IMO4wdsfPXROIDvl3P+R3/nZz2bwziMwziM79/w3jtjzDeBEz4r8C1p0CRJmEwmqlEQbYToL5bLJbe3txwdHSnYjhvBcDikKApNnIrS4OzsjOvra01fC+gVv7ekYwXwidNaVCQC5AXOzudz1W5473n48KGm1EWhIg0BZVuMMTpXAZvyGkmJ9/t9nZs0nRTnuLiJpQEkoABb9tvFxYUqKQQmCtQtikLh59nZmTaYlASrKCgkfSvvKctSE+2SgJUGkIDqP6TZYVEUuj+laaik2ieTCcPhULdJnMuj0UgBPITUvoD6x48f7+lsBHpK2n2xWPDq1St1VT958gRrrc5D/OBnZ2c8evSIXq9Hr9fTJpqTyYTNZqPvkX0imhsI4FZc42VZKpwVyD8ej/XzNmQVpYgkrQWsX1xc8OLFCx4+fMhoNNo7Fu3XLRYLiqLg9PSU0WjEzc0NH3zwgTYLBTSJLw0usyxjNpvtJbIF3kpBZLfbMRgM9Hy8uLjg+PhY9R9ybkpR5vz8nPl8ztXVlRYL3n33XXa7nSpJRHtjreXm5kbT/ZL27vV6XFxc6P6WYo44vKVAI9qfLMuw1rJcLjUtv9vt9pQ93W5XPf7yekl9V1WlIFuuD7nWpLHmZrNRZ3dbwSNPnYhGxTmnjUjFlS7ans/ruKyjCskU/Mcf/QxD0+UPvfv3hD/qtwXdYow3A4ph1jh2oWkw107M0mJUvgGD2vRSklvxfcEZ7Em3NXa1wy+XuKLkJ178PDd1wZ9+/jNYLA7HP/F0R++dH2U3Dm8XaKcwTVZc+fhUdGzo1/KSi+JE5mdrh52vqbY7HIa166q6o4hpa0AbQQqAXhEaUJY+bYHm5q/hFZD4AInl5zPXD2C5FVctfKqNH9vfT3CUZGSmpvSpAviR3SokL30SIHQ8dWtvWLh+VJh06NuCri1ZuS5n6TwmwcO6tiYL2+RNWIdJFHbvXKYJ8PvRWkcDvMP7g4N8YHe827lgYCr6puaPf+kfInlwhnmnz+64x+4opRjZCIK9pnl1mOa4fExz0j6pCMey7Y3GNl5oQBsoKg9B1sm94og0mGy+6VqaD1P7CLqbNLItfVRt7ENveV0binzMRS3J9YQI4Y02eW0rTGwdHPTadDKR9HT8PG63gmqDAiwF8O1EeWvftQG6alSK5j17T274pjEsNLoVWzVFB3V202y3pPJdasKTHvKkRd06prZ1DH0D6BXex8JCeG3ct7a5x3xSYeQwDuN7Oe6fYl4hr4mM2bAeOIpeRT3t4986DlqTp6chydyzkLoAnJNR+Chw1xrYbSPItTGZbYLKZL2DWfj/RvIsAt8kJr0NesO/7zNyQFm27kFJU/A1JvzMVY1OBBowbNPwtFfHBI2QcyFR7X3whtdlUKAI9E6SsD1l3UD61IblJUmYs6vDXL2Pqe1WVdO4cD0XZUh+ZykcD0MSftiDYUynZ1n0gucRbPswh9qH5Lk4u3d1eF0n3visCc1EnY9allg0cAZuV8ENbmxYjwWensFkgL+4o75dhf8f3MWnnJwLHS18S3aihdGDAOUwPvvx1cfhf4q//mrxGc/kMA7jMA7jMxl/AvjXjTF/3Hv/K9+rhX5q8D0ajej1epRlibVWIfZqtdKkcJZl2oRyOBwq3AJUmSApbUlyiq9adAlFUSisrOua29tbqqrag58CRuu61vcJWP/CF77At7/9bU17ioYkyzJWq5VCXOccx8fHqg65vb3VdHFd15piF4AnXmNZpqxftkFAsMBZgPF4rE0DRUdycnKyp5G4ublRF/Tt7S1Pnz5V+CegXZQrAgTPz8+5uLhQOCz7TxQoon6Q9K2k9W9vb1kul8znc169eqUpYkn6CjiW9O94PKbf73N0dLSXaJamhUmS6DGAAMRfvnzJer3m+vqaPM+5vLzk9evXqsERZ/qrV694++23OT4+Zjwe7zXCtNaqv7vX6zGfz/eaeLbBvhwPea9suxRjxM0uKWBJ3sv53Ov1WK/XqreRBPfx8bFqRcqy1IS2JJUBLQZI0vnk5ISHDx9S1zVXV1cKgXe7HV/72tf48MMP6fV6fPTRRzx58oTtdst8PlcdSlVVqgZZLpcK9uUaubi40FT6cDjk7OxMC0hZlnF6errngT87O9Ptf/bsGU+ePOH4+FivsdFopE9OXF1dKVyXhrXSuFUKQHKMBdJLul32rTSk7Pf75HmuTxPIfpLkuxSvTk5O9rQ+7Yaesi8EuMtxl2tffPNSWJDzRq4laUL7eR1rb8jwlN5jrWPJjj/7nb/GP/r0x7B5F7PdkvszytGEKk+0wWXj2m4Rb4HbkuAETYSLslMAmK0CgEs3jnRRwM0d9d2cn/jo51i4gq2HzNc4agrv+Ysf/bf8o3/f21z/7kdAVK+krXlEeCYA1fmgPSH+/W1rr1oUW/uQ4q08GINJEvqx6SM+DalnQtNJh8V6R2lSCtMQxa3LtHnkou6R25CsLiJ17Ig+xGd7UDskymORJnb3tDglLY0KpcZ5w9Ll+v7clNrEMokwfht/tqh7vCnHzKucRZWTGsc43dBLgrJl7boskg0Pkzkr11WoL+sqgdKlqjhJ7v05L8C7a0tyU/AwvaNjao6TNce24th2+Ce+8j/Anh5jfnhAOehQDlPKYUKVh8akpNA4ZlEGEqC02Wtq2B56jgn0jmnmRrnRgFU9/+4TCQ9JW5Mj37am1WiyARoyT4HTtvaNnuUeFRNvPIRijktMhORhEuKsRlQonsb3beK2xMNRZ0aLA+rorlvMyEdXvWkB48Q0epQ4v+BCb8C5N0YT29LU0jZ1aG0QKs1fgebJjIJWU0rULqDqF1mfC9d11W2OsfGNpsS0HhVRuF15hd6aIqcpLDQ+9db5cRiH8X0c8XkFRHEiOeCi49kNaxincHwEoxzeOoFpDuU2/LMW0l5IemcG0njTq6ILqU4jbI5FzF0J81WE1qPwHm/ApK0qMsSbSfxHTGbHqrTeAGkKzXWsWFkbfhmrS5vwtU0g9dAhgGHKJuXtTAOQHUGdYnwAzlUdoHIaU9om6lS0CQcBWrcrmMYG11LlAoiWBHyaQD8PapU0CeuxttkGaiiKqIGpwzzXBazLoFihG1PxJnrD6+hK9832rnew2AbIfjQM3zseQ5bhF1vcbVA1UoterBnS07StepKtOsDvw/isxlceBfD9/qv5np70MA7jMA7jczL+H0Af+P8ZYwpgz/XtvT/+jSz0U4NvgccCcAU0CbCr65rT01Our69V7/D222+r21vS0W0fs/iHF4uFNlEUYLvdbvWjOLHFpy0AVfQfksgeDAacnZ0pKIWgaJHE8fHxsTY97PV6mraVNGlRFCyXSwWxRVFwdHSk6VPxci+XS/WMt13FAtrEtS1pbfkokHm5XKq25PT0VNd9dnamOpThcKgeZ9nPss8F9Eni++joiE6nQ78fOqMLHG2rIiRNX9c119fXLJdLttutAkKB8bIvjTE8ffqU8/NzvvjFL+7pQM7Pz1VDk2WZQmrRt6xWKy4vLz+mjhHoLvB5uVzypS99SecsMF/Oj3ai/ebmRpU2l5eXun0Q1B3SYPPm5kaPa6/X08LBfD5Xr/VgMFA4KwUZcWvXdc0XvvAFIDja5/M5s9mMu7s7Hj9+zHq93ju3ptOp6kW+853vsNvtmEwmPHjwgF6vx6tXr7i4uODi4oLZbKb78c2bNwp6BVSfnp5SVRVlWXJ1daVqmbfeeksT2wKC28UBebJAzgs5NoPBQJ8MePr0qTZBlYahAtnlfBNnvnNO97ecy+Ktl8LF0dERd3d3TKdTvUdIYUTOC9HtWGv3mo4KCO90Onp8ptOpFsTkepTrRobcf+S4Seo9yzJub28Zj8eqSmkfp8/jqCN87RuPIwDjO1/wp579FP/sO78HnMNed8kWQ5Iji+uIF/negu4lXvVzAdNV872gOPGkW0dnVpJc3lFdXvOnn/8Md65m5cJcFjGNW2K4qNdU333G0SgU7a7/ziMofHAeJ62/s9thNmm0FVOlwg2MC3oVnMfnHex0woOkw43bMHM98CnCSAufkpuC2huS+Bd4jQ3Q2YXEdo2hdu0/0GHhGu926VOcDz7vgd1RxOS4NKaUFHdYV1hzSHRburZsebVTMmJa7d5f2kFRYni5mXCxHmGNZ1cn9LOSs96SeZHzI9OX/B3953xUHNOP1FMS7ompKEmxxlG65iNAbktVq4zthsfZLVO75Uup5Q//yB/A5F38dATvphTTnKqX4hOoO5a628BiQwOu9bRJ2slhAc/NOWRcSO9DPHbe6/vke+19oUHIFvzWY141jSC9lfR1WJFrqXFCw1T29CptV61hH35rsSWBZAdWqj406w/rbPzXCq33D2P0ZUeAjtGEtUJnmuXuaWH8x5cvCW+fNNvrDeofh0ZDUmcGlxmSndc0vLdgyrB96hm3+3PYG5IS9z6S+QDciVDciK/XR6ULzTbdv59oPwDdx36v8eZhHMZv5rj/60wruXhsLNLVLsVXET53bIDUroKygGX81wWOXKPqqCNU9dGBVEfAvCtCAtp5SKUKRrgwXExOE4q3+0qTODdPcINjIAFtSBkLS8hTUZ0Msgi+BYK79nttaGhpYiWqqMJEypgWh5j4JsBr2UPOh22S5gGeqCuJv5Q9zWt9HVLu1oT1JDasZ7EJyfPeOkLwTvhZkoaPpQvJc+cg64REuItVwMQ284vFdoroR3dxO1wE8KmNrvFNBPoesNTDHpyNMbuSfBECNoUFZ+J+935/Mz52jhzGYXz/x5cfjEis4WZV8Ga+4+Ek/6yndBiHcRiH8f0c/9JvxkI/Nfhup70lLSrNBKGBvAK8JIErGox2UlOArDS9K4pCk8uid3j58qUmedfrtTbsk6aW3W6X0WhEURSqUphMJpRlydOnT3n27JkuR1Lbd3d3dDodxuMxJycnAJpoFSAqEH8+n3N7e6s+alFoiA9bmnGKtkQAprirAYXqAuiLotCfnZ6eahJcEridTkfBqaSbZX7ieZZ9JtsksF5eA2jDQpnLYDDQ5pTHx8c8f/5cNTOSqF8ulzpP2R+//Mu/rIWEwWDAe++9R7fbVSDaVs3IuL6+ZrFYKFRtq1gkYS9JdHFUn5ycUFUVp6enui3tZqRyjnU6HfVTt33zbee7uLtlG5bLJbPZjDzPyfNcAbfMuyxL9bLLXB8+fMjd3Z2qaa6vrzHG6D6T9Y5GI/WdSwPLbrfL69evcc6xWCxYLBbc3NxweXmp10vbtd7pdLRAIOeLHHtJ38vTB6PRiOPjYz1vl8ulvk8UIJeXl/q6LMuYTqdsNhveeecdIDTAbKt4pBHtdrtlvV4r+F4sFnrNSiEFUKVQG0AL4J5MJiyXS22iuVgs1M0t15Wcp+2mlgLh1+u1FsTagB9Q6C8FHiniSKpfzttXr17R6XS02PF5HS7StzXg8NR4blzCyNZ4ScIbQ7qusWWmUG1P4wAaiBO4KbBxHxqiACzdejrzivR2jbu64U89+yne1J6tKDwIiegCSwdHnpT8R89/mn/6q+G+f9TvsH7Uo+xLEg/00W5JYrXUDQq+ax+8wh5M7XDdjKTbITMJuSmC5kMS1rYkJ4DnGqvKEQiQWlzdNRaomNV9+tEDLs0ky5ggl6R2SULHVCHlTQO9a281CS6NIxNCqls2pGtLTXu3U+S5LRklobi17ncoXMqi6PL6gxPSu4TvPCjo/2qXV3df5D/3nnJo+Pf+hX8T5y2v6wmzuh885rYMIDymu7NkF4+DJTclT7JbzpIF76YVf/RLv5fkaIqZ5tTTIfWwQ9VPQrPJJEBU1wKu7US+JpkjE9GGjq0Uswz5ucBa9WNrqNA3aWDTLFOguZwHxt3/eTzHLOH/bnwDsD8J6ALafBNaYcuWDzwpA9Cto/okQH6zl1g3dWjoGpYHaRH83tJkUpLV7QR0G+Drawg6kaT0uDTOLW6zrf1eYlrm6CQ0GhtepluPBP9tbGSZbgMok+XZ0utx8W23ed28r61W0fnFRrK2XTwwLYAuuzJp9r0ok3xq1NUu+8wnYAjw+37i/jAO4zdj7N0GDGCC2iLxPvyaqcEVSTg5cxv+uTLoP2ZbuNjCGJiKODompksf/qnz2oUk8nYXwHjWjZCc5jU+3hicKEXaaegIdEuZdbz4axcUJ/E+CQaGESQbE1Lexkbw68Ky0rSB1g7Y7EK6OjFRO2L3b8omLluc2iY+vZSYkG5v6bjUNyZPjVgT4LUxsC0D/Jd1d1IoexGE59DthCaaq12Y87gfXkNKcxOJBQLnQ5p8W4Z0t4vpclGyZWnwjM924fsCvidD6kGX7mzFYB1UKvMECgtUDq+F9L1yyGEcxmc68izhvbMBv/pmyddfzQ/g+zAO4zA+V8N7/+//Ziz3U4NvSVpL8zuBXKI5kDSpAFrnHKvVSgGzJJZlWd57dQ8LXBMg3u12efDgATc3N1xcXJBlmeorkiQhSRJNd/Z6PdVkHB8fa9M7AWfdbpeXL1+qq1qaN97c3HB8fKxubkmuTyYTVZAsl0uyLFMgLtAuSRJNr+92O1arlapf0jTl6OgIQKHefD5Xr7Qsp70f+v2+boOAfWOM6mNkOyCkyQVoLxYL9ULPZjOF6s45NpuNpmgFTI9GI87Ozuj3+5rgFb/0W2+9pd72uq7Zbre8/fbbWhAQB7Ok8+/u7vjwww+1IAAwnU65vLxUUCvrlPT4YrFgNBrptvT7fcbjseprut0ux8fH3N3dAbBcLhV8StFEihdFUWiRZLfbkWWZFkJEwSMwezweawFBGkiKT132u4Dlth5EijGSjr+9veX09FSPyWq1Usi7Xq9555136Pf7PH36lIuLC169esW3vvUt1us1FxcXPHz4kNVqxYMHD5jNZozHY16/fs3Z2Rnj8VgLOg8ePFBPtTSHFJWNQOi7uzsGg4Gqg2azmWpH5HyFkNDu9/s8fvyYDz74QB36aZqyWq1UISNFKtH55HlOt9vVJwAEIh8dHeG9Z7lcakFIrgvRy0ynU2azGW+99RZlWbJYLJjP5+qU3+12jMdjPa7if28nzEXh0j5X5KkQKTLI9STH0nuvKXl/H+B+zsbCBRVQbioWGHJTs/UJua/5yRe/wB/4ob8XEoupXPQDt9Ks0KSf4t+4HhREtl8nQE+VCKXH7mrMtuDP/epf5YPKs/Ip20jRnLfaMDI3JX1fUXrHn/zaXwLgrXTI7/9H/hnWTweUPRvTrKZJ18q8Wo8lixtZQKipHXZX4suSLGpMti5j6zNyU5KZitpbtmTgUSBfRugNKNx22JiK9uS2UDBtcSRYSlANim1IQPO1IdrMLZmpFIhnvo5gndgMM1jPpfFkbkumdk1uS3648xo78NwddfmdXfh9/+Yfpxx6yl6HpHR4Y+gsw/v+1d//RzHLNe52xn/0q3+ZXym6vKiOWNQhUT+wO4X4LprWHyZz/uV3fpTk7Az77pRq0qPOU+quxVuD6xj1XQtclgJIUrcguGvBaa87YV9xQVNIgQCJfQuSytMEPjVR6SGKkHgeRBBu955Vj9zIC7z1EbKyF92Txpfin/ZJhL6mmQvxPBcInBQ+JqubBrDBKe91PrbV3NE4TyKvExWPXDtVXIcVqB/ek5QNvHdJ8x7ZJ15qQBJFlPPfNPueOnCmdONxWXO9iAZIoLdPoo4oOseTylOlYTs1iW/2j0nb+y2JbfV5myYMSqvwgG/2iY86gnYB4j7sv6edP4zD+L4M4yPXJRb2rMF3Uuh1oJtG1YcJCWIifJXvuQi5bbwQ8A2gLapWc8t44qdJKyF9L168l/RuveR+0U4aY6oZRfQmegHGDWs+bb4wIdXtCR9dXLCnaVop3u5fK/JsoHkyybfmKNW4eLNoN6+ltXxJbXsf9qkvo3alXaGM++O+HitJmm2QZdfxvfI/Bi7CehdhvIB4a/GJpU5sLDaAjb9LQgHRH2j3YfzAja88GvOrb5a8/2rO7/1t55/1dA7jMA7jML6vwxiTAP9D4CuE39LvAz/hvf8Nu2x/Xc0tnXPaOPDm5oZer8dsNtNUs0Bheb2oJoC91LPoDkSzkOe5Nq5L03RP8TGZTHjz5g03NzecnJxoQnez2WhCVlzMAvQkVQzw6NEjTf2+ePGC4+Njjo6OFOYWRaFpUnEbS+pWlBHytegl2sCvLEtVjOR5rpoNGeIiFrg4Go1YLpe6P/M812aColNpK0Rke1erlfrIBQ5K808BigKMBZKKs1ya/0nC9qtf/SrL5ZKrqyu22y3dbpfxeKzNLQVCSmNEUdC8efNGU9Dj8VjnL+Bbigvr9ZovfelL2jBTXNridJb0dbfbZb1eA6jDXWCrFAjKsiTPc9brtUJ3UVyI8iTLMsbjMev1Wr3kshxxUUujw7quVaMijSvTNGU4HDIajbi7u+PNmzcsFgvVk0i6fjwe70FlSRYXRUG/31c1z2Aw4Ed+5EdUkfPs2TNGoxGvX79WkA8BnLfVOoPBgOFwqJqUuq5ZrVbM53MtZojSpSgKut2uAufr62t6vR7j8Vi3W66D6XTKmzdvePPmjRZHjDHM53O9lkTF03bwF0WhRSEpMkhhRAoqcqwkcf7o0SNWqxWTyQQIT1yI51uS3aPRiDRN6ff7et1Jcl2aVErqXa7tqqp0n0jBS65dUfRIYUCa57b39edtrHy4B4VGjCllVG10Dfz4W7+TZBhhbeVCI0lvwt/g94B3e7TT4KKikLQ1RNVJFZQKrDdsfEHhLWWE3bkpWfkOW5+RUZOYkATPcNTxr86vF2v+3E/8B/yjP/7PsPzyhKpr8PJbyjfrbc9DVAvGB8e33ZRQVpgs4/d/4e/mX/vmT7H1GWO71X2y8D1yU1KSKoB2OE1wh9dZMqqgQ4mkdWB3LFxvD3IH77fXRLeM0qckxmnzzMzWOB9AeEHarCcmz/EpmalIjA/NLH2XJ3bOyNbc1BkFCUu3xtQhDexthJelp+6GdPHurQnJdog9P+KP/vg/j7meUV9d829866+SGcfWJ/wrv+PHw76bTvCzO+h2sb/jlGrQoe4mwTWdWVzXNGloYQMWTRma2jepYWk6KueMnD8xMKiP5cdP24UKKTYIBGqnovf8z7I835x7EIFuvNRtDRhDug3noYtJdSA6sqNuRMC4BxJwWVineLBt6VUn0qg+aOai55vMk0Yl0oLjzXka1qnp+LgO1ZVEuO2S0BzTtYC8DJeaRiUSYZMxRp3ewRkektNaGIpzrbpGG2Aa7xWwexvhvtwqBaarIz1ua9140cU3LKlvfW/cB7KvJbCpKX0pQEj6X86p+DpZ3mEcxvd6yKV0/wxLMHRdgKLFIKXOLP7BGE6HcDSAfhZS2LdFAKqdDI57IV1cVAG05t2oMakAF4D3bBUUJ5sqOLPTNCg+8FCVAcw6E5pfEhPXAtN93ap2GcA2TzwJPK5jUrvfCUA9zcCkCnnVy23TBk7bNLi2nQufl3XYhm3cto3MS25icVkYqQ6Er5MkpKmrCJ1dHWCycw3UdvEilyJBReM8DzQ6KFCK+Ler9+F+UcVKnY/rci6815jQXDRJwmtXm5Ak38V0t6TcRZviXVheEquipaW0CYs8wZSQFBXdylNaS5WF+5atwk3KCW8/3I4O4zMeX3005s/+4kvef/n5fXr1MA7jMD6fwxjzJeAvAk+AbxD+L+TLwHNjzB/y3n/7N7LcTw2+BYilaUqe58znc3a7Hb1ej8VioZBKgJSkmAVsCiiVRottHch8Ptf0tEBw770qFIbDoQK4oijI81y1FgLXl8ulQuvpdKow1nvPu+++ywcffEBRFNzc3CigfPHihaZ3RZ0gsHk+n/Ptb39bNRJpmmoaXFLpklaV1LTA+3ZDT1FaSGpXvNoC6UX/IHMSoCjbL6lX8aqL/kS2WzzGAoOBPbgpTSglvS5NEE9PT7Vh4+npKY8ePaLf7zOdTrm4uGA6nXJ3d6fFDAHQkhaXtO1qtdIE+3A4VKBdFIXCz+FwSL/f1zT+ZrPh7OxMwelsNtOU9tOnT3n77bd59uyZAmrRcLQbFkpKWM5NgZ9JkvDw4UPVxlRVxd3dnTZbBTSl3laEQPCD393dcXV1xcXFBcvlkvV6rcWSfr/ParXac5pLkn+73fLmzRuF7lIkGA6H2hxUijzf/e536ff7LJdL6rrWItHx8bHCbykqVVXFYDBgvV5zenqqcxUtyWAwoNfrqeddmrmK49oYw+XlJbe3t6oUGg6HH2ucKUC5rYtZr9f0+33KstR9V9c1y+WSfr/P3d0dk8mEqqq0aCH7bDQacXV1Bew/4SFwXUC3JP2lUCE6JYHabY2OnItyXcm50S5SyVySJFFY/3kcmanVKx30HOG6WXvDf/Tsr/JH3v57SToZuDFJGZ6m/liPrU9YrqkaaNn8bR6AXFI40k2F3ZT42rH1NWufsfUppU/UaZ2bktKnzF2uQFxGQcKu2PETP/mn+IP/1B9j87CL6FaaSQDOaApWoGO6rElXJRiD73Ywm52mu8Z2S2Yqtj5j5bqsXFfBc2aquJ8aEJ0YT07BONnq62ufa+PLgd2RGEdOqY0tSxL1fDtvguvbowqTrcuCdsSb2ADT6msh/I2+9R06VOQmNNXMTc3IWPppRW48/9SP/ZNUP2YxNXRWAYCLL9pb2E1TkiLBn3aC+uXpGJ+8zb/4x367Fijc3x31QQay+REuT6jyZC/9vH/QaZpVyrdazRBVDxJ5hixbHdICPk3zXlNH2FA3Txu0U8SSppYn/IF9TYZHU8WSJk92EcQ7UWc0wBsC4JV1BZWHoewb6giFTTyvVfNhwr6tM4IfvGw82cEI0ILy4ihvFYzaDTPrjtG5CTTfS7G3Cgx1ZhT+y7UGrSQ4MSVuw04OH4POpI6FIttq+OmysM/SXXDnh+IU1N2wzjoz+1oTH9dlWk7u+0UwTbKHOQqUlxmKAuU+9A7gP+wDTYJL8vSTzr3DOIzfxBEwrMEZg08TfCeBXgaDDuQRehsCUC0iwE5tuFnX8Remk5sWEfq64M4uqqZxJDRubNNc681F0jr5fetfe9z/vrFhPlnSSn6bX+M9vgHXxoSGl96E7XJER3kd1SatebWht3xfPOEyD+9pGl3K160EtjQ+FiguAL+sg7bERIiPacC3Nq6U9RGKDZ00fBT3dxuyS0JcCmjt3IMJPSmqLMF4T1KAjYFw2b4Q/DbNDm59ehiH8VkMaXD59VcH8H0Yh3EYn7vxbwHfBn7Me38DYIw5ITS9/LeAP/QbWeinBt/iTF6tVtzd3WmTyIuLC4XVMvr9PqPRSB3BgEI/SaG2QZtoHTqdjjq9b29v1UstjfGm06mmQcW1LAlSay2LxUI1JAJIBZxlWcYHH3zARx99pOnbR48ecXx8rL5iSaYaY1R7MhgM1Jl8e3urr1ksFtrwU0C0pFoFBAOalhboL+oQUUqIHsV7r2ldaT4o2yDpctnHSZJosUEULdJ0EFB1R5IkbDYbBa+iqRgOh3z5y1/WVLBA3bfffpuzszPV00gqXQD/er1WfYs0F2y7xb/97W/rfOWYbLdbBbyyn733/MIv/AKnp6cK00VBcnNzo8BeGphCcMQPh0PqumY2m2laH1DouV6vNcEsMFpguWhPBoOBwluBw+Kcds5pE1Ap8Jyfn3NyckKv11PYLPoNKXicn58zm8148OABX/3qV/nFX/xFvvGNb/DNb34TQJuu3t3d4b1nNpup51uuHXkCQea32+10++UJAzm2EJLX2+1WdShy7UiRQ6B8nue8fPmSq6srBd6S6J5Op9R1zcOHD3n9+rUWA+R4SlFGrjc5tm01kbxGUvPb7ZbHjx/rdSOFpMvLS91/x8fHCtjFRd+G2rJ/5V4i65VrTRQ1MuRpCinQtD3vn9fhvKUkNFLsULP1afRcG0r5a66qwh+EAp/a+gj521bSn64F2uTvYIGZJiZpC0+yrrCLDW6xYOu9NnOEJn0eFh9AsahPZNQY1nSpiwXJz77P8O/4ITaPBkG3YRtdQ9vtbOqgeEjXAbqzCwUeqoq/8Ozn+Pldxsp3SKJiZeszEpwqSrS5pTeqJyl9Qt/uInwuWbkOifGhaShBb5Lg9zzfokEpVX1Sx+WGhpjtn9VYShe1KcYFcB5/VhCaYQ6ikqRvM/6xL/w92OGA+svHjWvdB8ApugsXj6WoLrxtOaFpYLOLqWZvDesneUge2+b3N6Aqj6CwCARAQW4LdusT+wIZRIdhWqHBsvV6ZO5+P/UdG09KstHQpKfDOWdaYIVGd2Ja37PN+UDidXurno3rFQ1IWFCdGeqOUbWHMUS3dkjRy/ptFRqhCeRVBUkrFX3fed/sx3g5CUyP73U2JKb1/W1ndjw2ENcvTzS4jy9f3+OhysN7bNm8to7Q27iQ+s63ToG9qF+sIaQqdYHNPOV4KdiXfdza334P6McptpqUSiFC0ur3zzWB/Ped4odxGN+r8TF+GQu2tbVsrYVuijsahAT18QiORgGy7lo3mcQEoL2Iye80NjCo6vCS9Q4W6wB0SxdT2UmTUl6vw0QqF0G0ha4Nn1cx+ZymMb3sI8AVYgxaaUzT0AQyTWDYC+A7ScL76jr4v+sayh1QgK/DMqwN0NiYMP9uJwDv5TbMoZZ1SgE0QnxjwGYRQEdwnljoZuHn6yJsr7VhDsQpGzTcjXMBctfxdYkNnvFtEdZb1AFczzdhjr0O5B3odGDUCds36ISf7eI6V9vg+vbxGIgypZOEZW5ikj2xMEhD88/Uwq7Ev7zBV1twHlMFaO+QYvqBdh/GD8YQ8P3d6xXroqLf+fz+TXMYh3EY379hjPlXgf/9vW+/8d4/jD838ef/c+AI+Fngf+m9/1prGV3g/wT8UaAH/GXgX/Def/Qpp/F7aEFvAO/9tTHmXwH+69/IdsGvA3xLc0hJYwv0E9WC6A8ETgEKG2WIj1q0ClVVadJTmmOuVivW67U6gfM811SzNLKTRLekyKVRoUDE8Xi8t16BmY8fP6YsS54/f66O8rfeeos8zzWdvF6vmc1mLJdLVSYI7BYgLQ0YZ7MZ6/Vak89tn3brIKkyQlK8x8fHnJ+fKzQUrUuWZdo8UwCx6Ek6nY4CXUk2t2F4lmUKRUU9IfPZ7XZ0u10FlE+ePFGlhChGnj59yvHxMScnJzx48IDFYsE3vvENNpsNp6enrFYrTf+K1x1QVzQ0MHY4HDIcDjV5K1A+TVPW67Wm/CE0+Tw/P1dtjcBKSe+Kf1xUJbJ+Wadsr4DT3W7Hd77zHU3py3IvLi4U4ApUF0gqBRh5wgBCweLJkyc45xiNRtzc3LDb7TDGcH4eXGuPHj3SZPN4PKbb7fJLv/RLPHv2jI8++ohHjx7x8uVLdZNLQ9QkSbi+vmYwGCg8LopCG7iKW1y2WfRC7ScoZH/LdeS910KMaGp6vZ4+CdHtdvWpA4HHcp3e3IR7Sl3X6t3f7XZMp1MWi4U2yITw5Eaapur4ns1mnJ6eqrZmOp2qB10aVcp2yJMNkuyWOch5kmUZRVFo81hREAF6fcs5IdvdPm7S4FIS4O1i3Odt1BiIDRgxAYQneHYkFL7kJ1/8An/wh39vTK2hTe3acFJTu7RglYBP0wA3W4e0d7aqsLMV/uqGP//tn+aDKsxj6zJKYgGSGodl4XpBA0IDkSGkoxNTcl0P+Le+9V/yv3qnZnD3NsVbR9Rdi+tYXGaoMyM8lmztyJYV6cUcs1zjdwVYQ3V7x4fVmq0fs3Jdhe5BcdLEwQRmO0IqOzM1pQ/p7atyhMNwns3pRDqYmTqk11sak6JF7SQ57ryhYwMQr73VZHkZixCuVWmo1SXugoM8Nt0svGXrqwAcsk70ycbj4Hxw04LC4OByVlYdDyrUXYstAtQQdUzZsxFityBrTAOrgkIaKLaVJ7JYYzQZDREKE5fRBuICREUL0vY7x9S29QKAm7no6mowcYHazFQamsU5N8nh1jqr4PpuA1dx1Hsb5l71jHq8k01sLLmTk97H1HrjNG+7vDUY6JsiUft7mjwEjDWBdcWCRdLWosRjpSDZygGNl1sbetNA971msy4206zDdgsEl/2sSpYYjlQXequxZXv5ba3Mnr5Ejr1t7gEK/U3ruLX3k5wTraKLONblfS5rFTYO4zB+s0dM+brEBAVRJwkqjWE3NFgc9iBUQNET05oGLDsPg0GAulWshm2LAJErH/75mGS2plGKON8kxLs2wNjaBR0KJnxto4daAWz86IivSUIaPU2CZiVLw+dJgLps4/zKMiasS6AKzS97/QCRuzE5vd41qxA/uYLv+ANNQrfBtwnbHjdd/j+CRB75kcdU4mu9b9Qwtgiv2+6CDmZbwXIXlrspw7xOxgF8ZymMh2H7ehH2j3Yw2IT9mGahkLCrQlHCmPAaHBQ+APlhBr00HOMsC8fhcoEnAH9bu1BeMJ9fNd5h/GCOs1GX81GXi8WOv/F6wd/19tFnPaXDOIzD+PyMrwG/r/V126v9J4D/DfDPA78K/O+A/9wY87d57xfxNf9n4B8B/ghwDfwbwJ83xvzOT+no3gGf9Oj+ECg+/Wbsj08NvqUJnuhNRI8gzSJFoyBATNLBkthcrVaaioYmuSogThzGor0AtGmdNPETjYqkpOU1kmQVUJ1lGQ8fPtT1TCYTbm5u9KMoICA0RhQVyXq9VsBYVdVeM83NZsN8Pldg+4UvfIE0TTXZLCBZmlnKtnW7XYWvV1dXmkyXObQBnzRdFCAtShHROUhKtu1Uf/r0KXd3d6oKAVS3If5k2b8Cr9M05cGDB2y3Wz788EMAHj58yNnZGWma8vLlS7Is4+zsjAcPHtDtdnnrrbcAdF5VVXF6espoNFII/ubNG9brNev1mizLuL6+Vk/31dUVzjmGw6E2RX316hUAk8mE2WxGmqa8fv1aj/doNCLLMvr9PkdHR5Rlyd3dHdPplFevXtHrhYZt0vBQzsl2wUUaU4oHvSgKzs/PVRXT6/U0LS3p6cFgoOn73W7H9fW1zlOKFbLsqqpYLpccHR2peubq6oqiKPjWt76lBZejoyMtjnQ6HY6OjjSpnec5ZVmyXC4ZDAbc3NxwdHSkAFzS1qLVgdDAVIou4lyX+cq1dnNzo41I5bqTBrDta1bOJ4HGAqPliYLZbMZwOARQoJ3nOYvFgocPH6rfvNvtcnp6uqcqMsaogkgAt3xe17VqVCR1L2BcmuS2/f3ee32CRDzmm81GC0er1UrPd1nX53WUPqXGkRjH2oUEfY2hIGHkS9auwBcFRMdv3TF78Kvt6BXFhI+JKOtoGvr5kJJNlzXJvICrW/7M1/8yG1+zEu0HVtPQGBRyFz5RcCxlysQ78qQkMY6bOuff+e5f4X/xxb+fjrVUJ0OqQYq3CVnpMRFoduYlyXIHVze4osQXBb6u+b8/+6u8qUNTS1mP+LozKuTXn4BviwupeCylT3lTjHmzC4mbYbKlk1Rkpg7KFJfhYlK99pbSJ0FtAqqVqVvbLa7vmo//cW2ND+nv+D5HAB8r1+XS9cnrJf/ps58LhYoWTPVJk8BW8CsgVFK5pjmePkUbN8poFzh0ueH5b1zaKDAEfLd1G0hSWtUlRFdqG+DuQ9v2eiW134al3sbmk/r1PnC97/f2re+pu7sG1zG4Lo0yJW6XqWRfBcAj0FuVKbXoRXzTyLP2CuTDPFtAu5VU3isWmf39ahytppc+ABrvY2PICIMrr4UGaCC1aEXajnHjfARxAaLL9qUbh7eGbO335ifKlqQIP09qr2l33a/3RruAEb6xfz5ZURHH/SYe9L3jItvRYnjemuAZkG/db2J3GIfxmzwSb0LR0EHt4w0li0A470C/G2DqMoLhfidA6aoGVwUILW5skwFpALCVD9+rRdcRE9bi8TY0xUsbq17GBOe2fE96k3jC+0Q1krQc3nWcszSNTGxIcTsfEuG1hzSup/AxUZ2ElHeahH/SlFP0I+r7MAFwe7nZgupMqgjuRUHifPhoIxSXeUs1tpL9UEEaHeKZDdXZOi6rzfedg7oKafB5EsB1FgG4c2HeDhj0wpzG/ZDiFl+57jegmwTo3s0C8LbhZugd1N0U383wVRV6Ksi+B4yL+ikOt6XD+OzHVx6NuVhc8v7L+QF8H8ZhHMb3c1Te+9f3vxnT3v8S8H/03v+/4/f+OeAN8E8D/64xZgL8MeB/4r3/L+Jr/lngOQGm/+SnWP+fB/6vxpg/Bvxc/N6PAv8O8BO/0Y361OBbALFoF8SNPJvNFEgZY1RBMZvNuLu74+go3KgF0gn8FpVIVVUURcH19TXL5ZLr62t2ux03NzfqBJakrACt0Wik8Lvb7dLr9bTp4G630+aREIDZ0dER4/FYU6KSQp7P59zd3anKRIAcoKlTUUdI48THjx+rtkPcxG3FyCelvsWz7JzTZWZZxmKxoCxLVqsVo9FIt1M0JZPJhLIs8d7rfhKIKM5vQNPhAoLbvnFpJtnpdHTdk8mEyWSiae6qqvaaasocBKbmec7jx4+Zz+ealpYUe1EUuq9FMwIhmT2dTveOfZqm3N7ecnt7q+n8Fy9eMJ/Peeutt3T/7XY7TYxLcaGua7rdLg8fPmQ+n1MUhapg5Djf3t6qM7osS9brNZeXl6pQkScVnHMKgM/Ozvac5ZvNhuVyqQoYOe9kXwuQBbS55tnZGaenpxRFwXK55PHjx1pImU6n2gz26OiI+XyujmzxWHvvOT4+1v0j8FZc5JLur6pK1ymFqKIo1P0ty1yv1wyHQ01PS5FH9u/z5891mbIcSWfLNZxlmTaurapKj3FRFDo3SZRLiv7hw4eaPhdfvyxTzi+5NqRYIoUvuTbl/JX9IsBewLisX46xNF8tioLdbqfvkx4Dn9dRYyii0qP0KRYXtBzecm26HNsSX5TYuzWdWU6dZcH5K3/pxaeq1XPpwRCgpq2CRiIpw8d0XdO53ZJc3fEXvvZf8mG1o/awcP0Iew0OS+ETOtTUmoi2wXfdAsS5LVm5Lrk1JHguneNPP/8Z/vAXE7LiMclkQLLLAzSMjbHsusQuVlSzOzCGn/jo57ipd9y4hLnvRvCdqHJkFQsB95tRhv1m2bmMq2rIsu6ycwlnnWX4mbccJ+HzGzfU1ycRmAv8DuA8aFy6UbYs2+e8iYnvqml6iSTBE1yM2tVYtnX4vZKbkkG9whcFtqhJSk9lDa7921vSxLEgIToRafwYYGyA2U422yhrD/oLgZrx2BsPdSIO6giFWz5x1aGaZn06nRbQlq/vA3AfHa1tVYgkk4OOI0zykyC6qFi0iaQCZq+Jdm/MXpLY29A40lQBBidF2GYXAZGcz/iQnm6gtdlT60AE/XH/ijfcJeE9Lvl44SE0kG1vu9fUszQJFVocmlTGfW2bRLvXaPh+QtpKc9PKU+U2uMzjcXWt7cw24X1SDDCxaOWSsG/0fDICzE14qqButlkUSMrnZUqixPENcIdYaJDjFV3kn+QL1yLOYRzG92rcL5jR/HrLvCHzltJA7WIFt5fCoAvjHkyGMFvCPD5hO8xDY8hNGZ5cqQ0sNxH49sN5v6uhiNC7rFCdiTReTKN3SNUpMT1tkwBvIapRYtXZJM3PjQmJ5SRp/OGYAI+TCLt7ebjhpFVweAv4vfMB4icZDPsB8LevX4HnkuZW+E0rdR41IpWL64xPIAHqGt/zlPtmnwSPSNzxaZhT0gbfrV8mVRm+dwesChjkYfuzmNhO4rqOYyJ8u4P1BtZlSNtDUxzuxfnlnVAUqH2A38ZSDXKoCtK1Id2E/0d11sZ7vGs1+TbN9hzGYXwG46uPx/yVX73k/YPn+zAO4zD++4/Rvafhd9773a/x2h8yxrwkJK9/Fvjfeu+/A7wDPAT+M3mh935njPkrwO8G/l3gdwLZvde8NMb8SnzNpwHf/yLw7wM/Q5OPSwnQ+3/9Kd7/iePX5fiWZLI0ggQ05VxVFfP5XBPPxhiePXumqoKjoyP1cgskF/XF7e2tgu83b95QFIU6tKVhpiREJeksCeg2XDs9PWWxWHB7e7vXVHM6nWrieTab0e/3FYpK087FYqHzE2/2er3W1Kp4qAGF48PhUPeJwDtJoMo+AzRJLsnaXq+nr0/TlOl0qgnzNih0zinoaytkBIKORiOWyyW9Xk/hsPxc0rKiWpF0flmW2uiwqirG47HuyzRNtWmppI1FtXJ7e6vbL7BfFCiS0JdmmEdHRwp1ZXsE8G+3W3W6C/xfLpcsFguyLOPk5ISbmxtmsxmTyYTj42MuLy/3HPBlWarWRIak9B88eEBZlpp8Fn2GtVYVHgJ9Hz9+zGaz0WKOFHHW6zVHR0fawNQ5R57nup2S6JdGq5PJhLfeeovZbEaWZVxcXJBlGV/4whfUzz4ej7m4uODq6krT83mec319zXA45O7ujidPnuj2LBYLJpMJ/X6f3W5HURSq/wH2tqPX6+G932ssKdBbUuUXFxdYa1Xjc35+rteSXJNSgEnTVBuCilZEzmU5nqJSaafopUCw2+3UVQ6oekSAuhSY2v54KVwB2gNAtlOuObnXSHFNjnP7yQo5PwG9Xj6Po9QmizZqOBLwAaLe1ENemhn/r+/+FP/kV/5hOv0udW9EVdugvyCAKwfq31Xvbx0cwknpSTaOpHB0rjeYV1dUF5dc1Ctu6iykmH26l+qWpHcZm10CoVmkd40H3Bu2ZJR1Qh3vs98qN/zb3/6v+OPv/YPY2YDswRnUNaaqoazwqxWurPj3PvxrlB6+VSaUPqOI6pLCJ1hccGkbr35vyz6JlXkt6py+LShtQtatOUrX6txOjCPBk9uSRd1TgG3vRWYTHC4C8KS1nnb63rWi13X0Tzj1oVt9/azus012IZ22K7GlxyZega1AUYcncQZvIygVumECsdVkcpxqAJ7x81QgdIDD6lJvwXN8SPUG8B3BsDzRXrWAp2nB37YCpPX/Wi76sgMojhBXngKrAtwNipEIl1vwV0C3iZoUHbI+dcCbPSWJreP3Ilw2NjR8rOI+EUBsfKNtURgb2fR98C5NIMO6mv0p+0gPgffqvfWx4CBJadGKtFUhuklW9rXHVp665ceW9L2tQnobYgPPqlGYJIUnKYJmBAd1bkl2jqpnQ2FDGlv6Zj3eRIGOlyJKs5/1lNX9YnTectzCeeC1GCKJbuPivOJxcmmTxjfuXrr8MA7jezU+4bwK90uDTw30kkarkcabZFU3+g5JRcvTLpLIdoSbRVVDFZUlH1uXFKhMs6x2slp+JvcKT4TQ7IPk9vr2EtIRWte+lTKPyzWm8Xr3uiHtncR0tmupVCRFLs03Pa2PcT2VC09pyHs8aENLQ5Ni180WYBznVLuwDOoI4V2T9q5lLhGsG8DHql8VG25aF/7sFUCfxjl3O+HnnTQk4vHNvNqw2thQIMhM6PbbSQMMF8WMbFS7OHn/UB7GYXwG46uHBpeHcRiH8b0b9/3a/wfgX/2E1/0s8D8laEweEFQmP22M+WEC9IaQ8G6PN8AX4ucPgcJ7f/sJr3nIf8eIqfIJwQ/+GPgK4Zf1+977b/13vf9vNj41+N5sNpoiFXAt8FWSoWdnZ6p5WK1WLJdLhVDSnPLy8pI8z+l2u1xeXrJYLHjz5g2r1YqLiwtevnypTf8Gg0GYZHSJl2XJZDLBGKMJaQG6gKaU67pWb7HAS3ndW2+9xXq91rS4pJfFbyzOYIHCJycnCvTzPGc+n3N8fKwJ1jzPWS6XmoKVwgCggE5SsAIYl8sl0+mU3W6n7wH2gKB4mYfDIZ1Oh1evXnF8fEy3293TVIgjXdQP7SEFCWhUM7I/rq+vVUUizSrbmov7DSYlAb/ZbBTij0YjTk5OuL291fl3u13qulaQKSl1SQg/fPhQPel3d3f0ej3evHmjDTCvrq4UkMr72yoTCGnyduJ9Mpmw3W41NX5zc8Pd3Z0mjAeDgapNyrLUVPfFxYUWRebzuYL14+NjBcfb7RbnnOpPNpuNNv/sdDoK58fjMc+fP+fNmzfc3NyoBz5NU87OzrRAIMUH0ddIwUPOi263y2QyUUWMNKO8ublRlY/sa9GmSANPudbEuS+FInmPKEiGw6H6vgVIy75sH+vVaqVPeYhuxTmn57t878GDB1pYEBg/GAy4u7vTosp9X700qRX/vNxj2k9NyPktQ5ze0iNAzmUp0LTP4bYW5fM4BDgnuOiPrkIjSYL6Y+E6zNyGP/31v8wf/urvo18+YPdojJmEXwlVr0l9tWGcuHqTjaN7uyOZb/HPXvBnfvW/4qNqx2WdsPVpANixmeT9eTlvscZF77gjs45EnqjAMXc9BnanKfGtTxlR8h98968wNBn/+Ht/f1hYXfMXnv0cFTULV/CmTlhFeJ2ZmrXr4rAKmDsSXSUA96YJZaB6ktTuJztyU9K3BWvXYZKsFWzXsRIgCW5rPBbXJLlpktwQCg87n2EjOZSPO9d8D5/EVLzX1wSPeEjor32XlbPBL2stpvIhueyNglFJ3NZ4bB180nt/zydNU8f28XRpC75GeFF3jIJvafwYp6nnhGhubATTmvq1DRxtKy7aqW2ZE7QAOg1UdpnBtGCsJpBtq0lkfL1qR4RSmAaqiv+7ddgVisuc6sRqylznIElHUQz41vdb6zItCBRS8abhUqZJ2ss+l9NCmn+2QW+TWm8l9DU53sBh+bkk6m08dkkRUt+y/6QQka1c4+J2Huc8tnDYCMrl6QCXNgUP23pqwBZet9u00t8K9ROv0P9jowXBJX0f9Cke0c00qfd758dhHMZvcOhl+jGIaWKa2lBaQ2XAHw/gyVFQm5xOQ0p4W8Gr2wCHh+EpSnY1lNug6cizCMIjsF2XsK0jtI1ANo1Fd2MbD7bA7ySN348wODEhbe4J+pSqDgA+i+4g2SBJeVvCe4wPCpMaMNugBalcmDcEsOwsHE3gUdaAcu+jE7sOML3XhSxWAmsPu11sfG3BJGF5m234OOgG7YsnvAYChDZJ8KFXcd1SQCjKsPFVHRpSGmCxCx+l0CD3PudgGfUx/S70XEh5V/FmVNbhdV0fEvcemE5gMIS7bUjb73awWoVlbMqwfWkK3bi+USfsx/kU0hRf3+KW4W8cUzu99cuTV4ek92F81kMaXP6NVwtq50nuF5kO4zAO4zA+/XgLWLS+/sS0t/f+L7W+/GVjzM8A3wb+OeC/kZfde5v5hO/dH5/mNfK6bwI/7L3/JvDfC3a3x6cG3+v1Wt3LkkgW6DsYDDDG8OrVKwWBApTFIV2WJYPBQDUa3W5XE6+bzYZvfvObvHjxgs1mw3g8Zr1eqxNaoKX4w+u6ZjQaKQBtp79FqyEQWNK5g8GAfr+v0LnT6WhTSoGOq9VKGwweHx/r9kmjPFFwAHuuZVFMyD4RINjWMshcjDFst1tVYUwmE4V08v67uzt1Wy8WC1XElGWp2ymQb7PZqOJEPsryRCsjr1mtVtrMUl5vrWU+n6uSQ4CxgPU8zxUmyjZLiln2q+zr9Xqt/m/xiQvoFOfyer1WoLxarRTMt13cjx49Uve0OLSloaL4pOWYQyiqiGNb4LKkt40xTKdThbXD4ZDnz5/z4sULAG5vbxWyT6dTBc7z+VyLENvtVptDyj6G4HkXyP/Nb35T0/Uffvgh3W6Xo6Mj1b845zg/P6eqKu7u7lQvI081SGJ9Op0qxIVQsNjtdur3Fme+7DcIxR0ploiaBdB0tfdezxnZd+LOloJPmqacnp6yXq8VgkvD2XZTTZmjFMDkHGg3J5VrQIpAAu9lfXJeCIiX/dZ+6kEaorYT33I8pFgk55qk1tupdHn/53UkeFyE3qI7SQiwucYyc31GrmBgKv7i3/gpfv8X/m7yzUOSJ8cAbM67VDl74Ft0FEnhya+2JB9dUl/d8K9986f42V1O6XNNddeYPehtCUmuMiawc9PA5vavwBpLx1RkpiI3JWO75SzZ0DWw9R5Lyf/zW/8lNcHL+aL2bL2h9oaFC8d74cI1Kg0nJT1d+IROdHhvXaZak0kSm/OagjwpuKmH9O2O3C51X9YYclMqPK8J8L70CbtWQ0zZ9tyUmiAXyG9bdFC+B+Fv89pbnGmUKVKwyE1J4RMG8RFtvCfZOeo8AFuXoqloiBA8JnVddFdbUaB4gmJD/nByzbFtUr/xmIvSgsglYlDOJ2GdSWwr4n0Ape0nA9qNUlWPIqnv1nkkr9Hzy5rGZ01z7rnEBFWuD9DUVK11xPpMk7qOqWKDKkja55epZDsD3JfXm9o3BQAP2MCM9H2xMeMnLbOZMFqIuA/JxRUuqfMArX3TNDYWJyQprj+XfVM3RQLxaUM4xmkJJHF7CTA8NDJt9o8pw+P7nXlF1U90HTq3eExs1BlJArvuGk2WN01P9//wFrC9d6+4D8Ij6JYigUtMs78P4zC+H0NS1MaEa9sQnN7jfgDekvreFQHYJjaAV1GKVHXUdJhw03aEE75yaDNHCZ+op9vsr1/82aa57vdeLzoRK45t0yxb7pupacByHW+6RQ1UaFNMTZSbkIoe9Rr4LGn2sg6vTeLv4MSHjRJlkSHONUJ+UQsmtklxyzbb+AiPb/bx3v5wvplbXYXX5T7Abnm/i3Mq66g2qfcT33WE9raGtA6F2k4Xkjo0+cw7wb/eXmc7BZ/YkPQ2cZ90O/g0VcuKcV6Llm1t02Ecxmc53jkdkGeWTVnzwfWK986Gn/WUDuMwDuO37lh473/dj49471fGmF8Gfgj4T+K3HwKvWi87p0mBvwY6xpije6nvc+CnP8X6nDHmm8AJAYB/z8anBt/SiE7c1pKilsSxKBH6/T6PHj3ag4cQoOizZ88YjUZMp1PW67Ummefz+V5KV/QkAutOT08/plkRVUae5wq/RCPSTnoul0suLy9VEVFVlYJbSaJK+na9XmvKWlzEktqVFKlANUm1CiwW4Cj6FHnvZrNRMDkajRiNRtrosd/vqzpCigKicxCfsWhG2u7qdhIaQrJclC9yrB48eMBqtWIymei+MMboNiZJoqlf0dhI6lkSzpJAlkJCu8GguLOvrq729q2cE51OR9PWcvwlLS6g/Pj4mNvbW00Wi4ddwKYk8cVLLgoXSeu3G5zudjsmk4k2+hRlR7fbVZ3I0dER19fXmjiGAElPTk4UugpoFk+6NEyUuW+3W92ncuyKoqDX6/G1r32N169f67GXVLJ4urvd7l4ByTmnDVsldS/+fCmeAOqzF5c2oE8fbLdbLVBUVcVbb73F1dWVFmoEFBtjVM0jhYher6f++fY+kHOsrmsF0QLK5ZzMskwb3Q4GA/XQi8an3axStkWKIHK+TqdT+v2+FqGkuAEN6PatPz6k8CPnqyy/nfaWOUtz08/rSIxTDYe4vSXRvHXB/d23O3KzpGTFn/vgZ/hHvvCjZLK/3TG70y5Vz+6B73Tj6N4U2O++5N/+63+W/8/6Xf6bzbuM7YbM1OS2UPgNLbd1TG8XPtEUdjuJLjqQzNTkpiSL8LtvSybWsPU+eMO9JzHyeUoZG0vWxIS5t8xdHrY7Tlyc2g7LNs5n6zOct3uu7WmyZuU6TJM102TNwO6Y2g01hoXL2fosJtAzdi5j7TofA942Kkyu6hEWr+nzxDi6kQaG7fWUum9iUjd6yHNbUpJq8js3JStn8XXdAIlPGJIMdknUefgm6RsAs1FVSXtoQnsvgdx6XVxOUsTPk+Z9Ab6HJpEubZLGqkGJwTx8o+YQMOxaye1mHgEQCxBPImj2CdgtsXmn1/kZTCth7qOD2mvavJ10b3zUBk2GZ01q3qVNY8vgG29ti4Fk5+O+NJjK4zpGl6s6GNMkqduNQJvjYJoGmLZRyNTxOvORH2nKXPhZgvpmjQupfvFwh6czUOBlS4ctG/LsMovLLOmmpu7aBrbL2+K+8DbAc20gKvoR0+ho9tLzsbDhIxtU9Q6AJLt9s9/1fRGSq7LGhX0h+/swDuO/z9Ba072vrQ+81BgoDThJU6dJ8F53kuDF3vkAvrsd6HQC/C3rRnUiSh/1GrXuL7Z1UUHT3NHHJLZAb5tAx0AWnWKbskk+JzY2oIyp8Tb4llG6cBNxsQq4jZXILA0QP40+8CwL6xPQvdkFmFyUAWSX8nkLEqcJ2A6kHejmYcVHg/Cx3wsuceeCa9zVsN6Fz7MsJOLrGjZFbFQZbwBGgD96T8O5kJSXbfNxWy1QlrCMKe/axdR2Fj7mHdjmQVUyHoZfSMeT8LPVBvJ+SKNvi7A9vU6jeTExRZ8kIfGdpdSdFOOcqppqE+6Rxjn93eHgAMMP4zMZiTX8todjfvH5jK+/mh/A92EcxmF834cxpkvQjfxV4LsEsP0PA78Qf94Bfg/wL8e3/LcEQdk/DPzH8TWPgL8d+BOfcrV/AvjXjTF/3Hv/K9+bLfl1gG9J/Io6QaCfADfxA4tzVxK5AmMFUG23W9VZpGnK9fW1JjdFwzAYDBiNRpyfn3N+fq6AWJKhWZZR1zW9Xk89wzIncWGfn58DAQpfXl6y3W41XSsQVRKy19fXqrgQTYToPKy1CjoFcoqXWJoPtgF8u6mjqCkEEO52O+7u7jTxLklscSALeIT9tPhut2O32+1BPe89s9mMqqo4OjrSJDg0yhFpXCgJ4MVioQn5tvLj6OhIQbwxhl6vp451Ac0CpAU2j8djTdVKkSBJEv262+0qmBXILP53SRwvFuFpi7OzM+q6VkDa/lySvWmaKpDvdrucn5+rckRgs6yrnWiuqoqzszPyPOf29pYkSfjKV76iIHuz2ejxr+ua5XKpTw4I5BbdhwBdmXdZljx9+pT5fM5sNuMXf/EXub6+VhWHAON2c0nxiQ+HQ1ar1Z7aQ86hq6srjo+Pmc/n6vCW1LckziV5vdvtmM/nDAYDnj59qsl5OYfkvJX0t+zD0WjE9fU1SZLotXhzc6P7TdYhBQ/ZZrm25ekHaZCZ57keD9ke8eRLqhtQzdFwOKTf75Nl2V5BRCC4JMLbqW1ZZrvRqNyT5Pi170+f6+aWESy3R4Jj6zNyW7L1WfBfW0vtHXdui68q/F0oBGdJAmaCHWXBgwoh7b11pJcL/uIv/WX+k9VDXhZH5Db4rzNqam/Z+pTcFtTeKniHxjtee0ttbATTjZpEfpabML/EO7Y+YesrEmBNSHaX3uK8YeUzTW87LDVBN7J1WVxvSI+HVLmkr702ngQ0VR3mFxLh1pTq4k7w+nPZnkXdC6DdZdQmNMysFV7bCMDDOZqZmsxWlC5l57IGbPtEgXlmanY+xeKpgcSH5eVUbF3GwO4osQEy1C64pSuPyzy2iung1h/kxoTE932QqIqMpDmekipWd7XwUu8/5m11kRnYgrh+o2lfHxUnqvaQBHj8WjQaYR2+cXvHr31MAAsQDjqX8N504/aAt0tNw4BaSW8kVd4iX9o4Mm6vJI9dZqi7rXm7CL3br6eB19Kk0ZswtwDUwzKdNMJ0MYkdQe9eIaCW/cVe49Hm4IS3uSRAqnaTTG2whsB+mgS/9+rqNs6EBp3O63pdakg3NS41lKM0bK+oacx+ESIk9kMaNvjOo+c9Qnxp6NkG5412JibFW97xT3yYUdKVLWWKFBr84RHuw/hNGKb1MfMG68E536S+FXzbAG59hLqdLDRwjI56vTlW4j0yrXO8lSpu011XRvWIRz3WJvq0ExOWvXOwLAOkzUwDrdOUfbd4XJXzAXxD0JlAgNdVFRQhndjUMol+b9GqlC4A6UqS1HV4T1HFdDQRvCdhDt0uDPphObkNH7s5ZHn4XVRF4F3ehmVnaUhUb0tYbMM6jBwA20D/+EQO2/h+50MxwRCOgyU28CwDqJ+vw3yOhkHLsusG9Uwvh8EgrHMyDnNdrCHphG3b7cK+V3+6HK8EbHCC+yzBd5LYtNtiiH0UrMF4o79SPuZbP4zD+P+z9+fB1mVpWh/2rLX23mc+d/qmHKqri66q7irZpu02BN0GSeFQIAm3bUAKG1sCJNnC8qAQsmWHpEC2CEK2RSBCQmE5FA6k8IBs8wcoPBAgWhGCoAG1hKMl6Cq6q7Krujozv+lOZz5nD2v5j/d93r3OzSwqa0zoPCvi5r3fOfvsvfbaw837W8/+vT/A9oU3BHx/6f0lfvq/9ObH3Z1TO7VT+zXenHN/BMD/G8A3ICntPwBgDuD/nFJKzrl/HcC/qKnsrwD4FwFsAfx7AJBSWjjn/jiAf805dwPgFsAfAfDXAfzMR+zG/w3AGMB/5pyrARxBnZTS5Xeybx8ZfFN7wEQwQfR2uzUXLwEwncJXV1f2Mz3ZhGZ0ArMY5P39vW1rMpng6uoK8/kc87n4rfJ0L0EeFRVMIRNMc5tcFwsOUiHSNA2qqjIlhvfe4C8TrVwXk6zD4RAhBMzncysomXvIy7LEYrEw7QnHjIU49SBZsUL+m32p69oSwBxf773BeY7/zc2NwUImh6uqMpUHAMxmM1RVZen33P3cNA3W6zXatsX9/T2Wy6WB8jfeeMPSySwASmjLYoo8vm+88QY2m40dV0BAKxPNLBp5fn5unuyiKHA4HHB+fo7NZoPpdGr7Sa83lRdXV1cYDAYGelmYkhMLk8nEJglmsxk2m43tG4E9oTL3ezwe41Of+pSNK5UuBN+E7HyygdoZKkaYvCYczvUx77zzDu7v7/G1r30NV1dXpsohhPfeY7FY4NGjR+YAB2Du8xACrq+vbVkm0wl5WQyW5xK96vnEA5+w4NMLKSVL7FNpwnPy7u7OEtJ8YqKqKiyXS0tfc3x3ux02m42d53yfkzX5fYHXHJ96GI/HSClZoVEeD54rVNQQWHM/gR50s+Vqld1uZ2PF85daIF5//P5JbLliA5CikfKUdkSt2pNtGmCVSiA2mPmIP/3uz+F3vP0bAQC+aVE2LcLFFKmS4+HqFv71PdrnL/BX9x3+xu5tbLsKwUUBtMUB2zhArQlsAJbsZh9iBuPp2e6SPyo0uUcp/UXCyg2xcC2GrtN0t8dNHPfLphL7WB0Vi1x0ck/u4NC4YMnuDh5NFDBfug4BUuhyH0vb7uNipSA7aUK8xCbp0yFZ34euQQx7gd+ZxqSD9Dv4RrYfCzSxkHVqOj3G4z+iD6nQdXSIcHLskgc80EUHtMDM7/AnfvVn8Xt/4zP4eoZu5BUgavKYLDJmjCYHj15BbehfTwGAamPZzLfdye8nJsVdTAiNrl+XDweBFU6T36ILYfK7XycfJbfEt/47qJojBnV3K4APqgDxbbJUsWsFYLBQosF7hdtMLAu47h91T97ZskfJb8g2DzOPYi/w2DQm8XhZQtqHnweApAqW6PvkOfeRaWmAgLcH69SWGHzTxmKUXenM381tUlsSFRwlyDiklE046Lp7RYocE6eQuh14GdejwqjHEx5Mp8PJJIcFWwsgJSbNuXzfd98cw25C8KNtZfvLMTkB71P70PYwsv1tNrv8nFO9kEPnPaL3iPMhMC6By5kkgstCnddJgPN0LClhpx0pQl8AMteSAH0KOKXM862fS0kT3+iBd1II3kQA9Gyrg5uP13jqUPSznIhk3QHqSagbscR6JRd0NOKsLnEuy0dMWlW0QEC3hwJ+J/A/OHWRO+n/9qCfc8BQly/1z0enfWE6u2769HjI9oNaE04OJPTFOfMxzDUwzmX7rfA8Od2nFqiZLNcv54HxUKA7kgDwmM+G6n6yoGdVAuMR0qFBOmioQpP3CQkPPnlqp/axtC++KRzkS6cCl6d2aqf2g2lvA/i/A3gE4DXE6/2bUkq/ou//YQAjAP8WgAtIMczfmlLK/eH/LOT/Pv6kLvsfAvjHUkrZs6N/y/b7v8t9+ND2kcE3oSWTxTFG02bQ1XtxcWEu4s1mcwSxCGCZpAVgahKmwwlcz8/PMRqNcHl5Ce+9pWPzYo5M4TJdTI0HoSaBIV3D4/HY3Moswsdk8XA4tH3y3huEJyh0zuHs7AybzcbUGIAkk+/v73F5eWkaBvqUuc+En7m3GejTtCzo17atJa6p9mCynBCekJypbL5PpQjTsXmhwcViYcUf5/M5Xr58aUl0QtL7+3tcXFzY+OW6mMvLS5ugYMHL8Xhs2g9CVwA26TAcDs3F3batFaJkmprpaYJ1JrqLorBjRPUJgfV2u8V8Psd4PMbd3R3Oz8/Nt0639263M/jLVD0nWzgZMBgM8PLlS9zd3WG73WI4HBrU3+12mM1mprVhEplFPgeDwVFRTR5Xajs4OcKUOJe5uLjAZrPBfD43pzzHgMVD6TTPgTOLuZZlaece38sB8nQ6xWKxwGw2M6BMIMzrYTqd2jjkT1hQ00Lw/+TJEywWC4PaXddhs9nYBA/PU26bahNOWszn86OnDbgf9HDzmDClnT81kBe3JLTmOBK0E9xzQoTrzOE7J9dyXcwnrdUpAJpgpuvauwifpBBjRMAmDvC6mwFhhRhbVK7Bn3735wAAY1/hH/zsT8GtNxKWqmukwwH/z6//Jfxi4/Gf7D6Dr20f4bzcGjimykSAdn+vo3KErXStvUb3N6Hy0DWa1O4Mim9Sgb3uwz4VeN3O1XtdZ5oRr2nwwtQnuYYEmjynhiUmj+C6o2WoJGGfOi0GCgCbOLD171OpxS8Pltw+6BiUrgOyCQcC7636x5soqfOYjQk97IdUaLFMSX7H6BCdaGFet3O8DGuk3Q6+7gCUVjDSoKXyBYOkucIkAwoGoBPM7d0vl/3M5nr9hTm1s+0YANd++DYpbOrXdawBSVlBS7n30TpgHuhOvvtWQLoLUtTTnNWaPOZyyWUJd4VBsSSx1W8ZnKaWw+k28uKbBPLQ8eE2cggtKe/j9LPtK/cDPTRnAtol9WEH/aym5X2jbvLECYCsD6Y7cbafuVYkPzZWxFL33TfxqIBoO3QYrBK60H/W1CYJ/YSDqluoCmZfXNLjQeVLpnlg8VEbc54DCX1aNZ80YIE+ju2JMJ3a97glQGBoERCDw2EgqeT0mafAk3OB3vORLLk9CCSdjaVoIlIPt4eDHkY7TYVTPcVJxroBDo0sM1BozAKW3gGh7M9/AuK6lWKZFxNZ/67Wgpea2u6cbCsmSFJZgW2RAemY5PPzkQDvzsmMmulWVGnSZjNWdZQCl8mJJ9sp6PZe+lPpRMCuE+3I7UL6e9EC51HGbTYVvYkvZLv7GqgPvVYF6NPrTJc7HQcPGbcWOobqoIkBx+ls1yfQi0I+myDjlgAsV1ogMwDwsg+X57LPC9ePcdPKen2SvjLlPxnLejY7dJsdXIxA7PR3mUNnEP50czq1j6998Q3Rmn75BL5P7dRO7QfQUkq/61u8nwD8y/r1zZbZA/in9evbas65EsDfC+APpZR++dv9/N+qfWTwDcBgHR3M1IEwIc2CfkwfE74CffKToIxJzt1uZxCb0PXy8hLz+dwgKVUbTLzmDuw8gU4VBJUjgEC37XZrCpXb21uDuiEETKdTg4Asnjkejw0OV1VlDmMqT5hwJnQGBOITyBGMEmjyi0ntGCPm87klbtfrNdbrtYFLeqEJLgmCc4XDZrOxdHrTNJZY51hz++fn55YkX6/XNilwe3uL+/t77Pd7zGYzA7pPnjyxyYXz83O0bYv5fG6p3ZubG7x69coKhD558sTSyyEENE2DpmlwfX2NyWRiBRV5ngwGA+z3ewOWD1O9PDeYvM4nTq6uruy1169fW4HK4XCIuq4N+tLJzqT5s2fPbP2vX7+285f9vry8tNQ9VSmHw8FS6/f39yiKArPZ7KiI4nA4NDhPyHt2dmZJbZ57t7e3NlkRY7Rt0Ym/WCxsfavVCk+ePMFwOLSJjvypgfxpAjq/CaPzCRvqVrgs9T0hBPOff+Mb38DZ2ZlNTvD8ZD9Y0JKgmseBfe+67ujaDCFYKj8vTMm+8ykDTmzxfKXf/OLiArvdDre3tzaxkifHR6MRqqqy1/MJHE5Q8Hrg9fNJbRFeCiYqcfJa2LJyHRqlcftYYu8qrNwQjWtQuh1qJ+fXOjX497/yFwAA29hgkyIOCfjltsCLbo7bdopDLDAtDpiFPYKLBrv3sUSpbohoae8eBEf0Ce8mFT1sRg+wSx9RuQ4RHts4sPT6PpVYxpGBY/q7+TOhd1C/9iGW8EgYev19AGev+RDN9Q0AQ99IPxmUg0OXaVGoTwFg2yxdl3nMJa3d5RBcG5fzSiCpXGE7xAKj0Og4BgSNMDcpYOBabOIA93EAKDT2h6heagfnIcA09MUPE+FsByCqNsScy7KDyWvamt0kBOU/M3Zi7+t3Kwimy7mkOgw+ga9aFAPSTDNmzUVVsqB3cjtLR+p2CoXV0cHhGLA7Fjuj6iRKKjJPg8MBNgdDWO/71HK5iQqL+3WmAFGbuA+mmKkG8U2S9RJMc+xc6tku94d95eeh23OqD9Fkt7nJOT5kyMqH0SV4cmaOtY4Hk9Q2YUDlSJfQVR7dyKMZy7ndDrM+2MZgEw0MY/b6G51cYOLe9fuRp7XdAziUMtidT7DY8plWxj148uDUTu27at9qIqUIAnerQn6OCpdbLdAY9LWksJYFGG0myPUKlPwrVy45HH/W0s+QBez10CtJQtd/lkloprzzbTv6mXRjQQEzlzFI73p/dxdhCXQC+WyClN06GkSmrRNgSXXeayOy/mUJ9IcJbv7eyetTpAfbYl/z99LD9/L3kxyfutUkub7N/fbuWBXTcXaQs7O6DF3fQRL9ycnvGZcYmj+B71P7+NuPPpvDOeDl8oDr9QGPpoOPu0undmqndmrft5ZSapxzvwPAH/per/vbAt+ndmqndmqndmqndmqndmqndmrft/ZRWGMOUh++xh9TRGojfOdQth1c3aHZHdDVjSSzq6JPRR+YEO4EqLaaRK60OGLUdDIgsBeQJHPLRLXO9rFSbVkK1GahyZSkkGUXgekIGBZSxHKk+i4XJGG9Vbd18JKu9pyFzCb1igCca1q7LIHOC+ydaF8rTZ03nWyTBSnbTopA7vayfKmAuNUn5LalpKHLChiOpBDn2QRoBuLV9oUkte92vT5lOADarEAnMv0JXd+E0pzwcg4ovM6woofXCVbPAr6A+LlCnyQPqoxpWuBuLR+aDOUYda2ky50DRiP5qmrgUMu47vayfFFK0p3FPQcluvEArvCoDg1C26H1HnUIEP2TfEVkfTy1U/sBtemgwA9fTfC16w2+/HyJ3/K5xx93l07t1E7t1L7f7U8D+O0A/uj3cqUfGXznOpCmaY4UJ3nyuSgK0yLQAw5I6rQoCux2OyvY2DSNFcTMtRZlWVqBSCoUvPf2MwsEMnUO4KiAILUZ/HxZlpYmPz8/x4sXL7Ber80LztQoE6NFUWA6nVritygKjMdjKwrJ1DtTuU3ToG1bU2zkxR6pKuEYMcVNtzIAvHr1Ct5703SwoGHXddjtdrZNer2rqjINB/UgAHBxcWHrOz8/x2w2w93dnY3XarXCfr83N/dyucThcEBRFFZQcbPZYLVaWZqWyWlqI7gfHG9qZLj929tbHA4HxBjNn07NBj9PnQUAO5eoyKEHmt73t99+G0VR4OzszLzVTJ7TXZ4XfmTqmJ7r6XSKuq6xWCxM28HUOx3t5+fnGI/Hli5+5513LFXMhDP3MffOswjmu+++i3feeQdt2+LNN9+0Ao3r9dqeGpjN5FE1ak7Yr1z9w+uEug4qVljoNISAm5sbAL1Hm08fOOewXq8xnU7tKYGLiwtLngPAdDq1NDhT2Uxqc2zoUl8ul/ZkwWQysf2nmoaqEqb2D4eDOf1HoxEGgwHW67VpTjieTLBPp1M8fvzYzmEWxNztdnj8+DG22615wQGYvoVPiFAz4723JzWYAudXrhb6pDXqRzpTiNQfLHap6eJ9Ki2tPdFCjgPXYRMPaCDFJPepMtf163aObawwKQ5SvFG/qC8JGhVl6jxv9m/9+7107ZE7GwAmvtYCkdF0InstNrmJA0lEQ5Lj3BaT4yyUGZO3pHaEFKIc+gYxeUzD3gpcbh8U1mTKu1IHuCTIvRbMDEfFMLntofq8qTvhNpnopu4EAGJyOMQChe/jtjE5FD7iEEV1EqAwQT93APUqrbi66xa+K5Ga3oFtwxpVlQEpUiivZankB35m3/aJbS7D9wgjLAXO8Ju+RkuFgQBdh2+10CEd2wwpZgljFmCUQpaaFo7oVR0hS1bTVkO3tbq8H3qtewd3T77ywpCiZnG2X8lpEcfgEIMoTqTIJleMI8hhKefAfXXwjRSt/AAI0fS1pzYlS1SnAHSlP05IM3XO7TG9ne1P0OMNJ8FQS4c7LaSpiUoW0QSAdhzQDr0VtAx1svPFMbGJ/hjHwvUpctOY+H65aJs8Utk8TLTn+5UrYrifPFaiTcmWPbVT+x61/skL9dYjIXQJLjm0LRPQUCAbj13RXfZvSxF7ILECJHrwnVKfdD7auhdm6yHguyoV+qoipSyAyQDwWkQzAShaXX8tAJ7QPARNWGc3JO/E6R0Uikft46BUF7nrk+NN1IKUba8dafRJSwL9uunT4E0AxvqVg/+C3m9IEcuoF3gIfeo7T2uzsKf3fbKciW3o2Oe/c8CEuKaz7ReM71PeXscgJilyCeg48T6l/amqftx4nJyuj0l7H/qfi0Kejqo7BGjBak31O7158dfHCX6f2g+6feGN2Ql8n9qpndonqX0VwL/knPspAH8NwCZ/M6X0x76TlX5kMkSnbtM05qYmpCQEpYc6dz8TPlH1kRdjbNsWr169MijOzxVFgaZpMJ/PDYjRH527xgnBi6Iw1QiBHCEmAHNNUxlCB3NVVbi+vjYwPRgMDKxxfXQT52CW73FfCBY5FquVuN0nk4lB9bwAJ2Ejt3V5eQlANBkEzoTu3Cf2gS7x+XyO29tb2w/6mDnmXdfh9vYWk8nEfMe5E302myHGiPV6jZSSaU8IIWezmb1HLUiumqnrGrPZDOPx2I4x4XOMEfv9HtPpFMvl0rzWnAihEiZXoBwOB9sWtTXcTg7Zue5Xr16Za/1wONhEwcXFBZqmwf39PcqytIKH1I/w3DkcDhgOh5hOpxiNRjYey+XSvOfD4RDL5RLz+RxnZ2d49OgRnj59aufWu+++i5//+Z/HZrPB3d2dTQaxwCbh/n6/N03N48eP7VxhPwmVedwPh8OR154anhijTSrx3J9MJnDOYblcmg98MplYkdLD4WBObl6T9/f3BuMJ2pfLJbbbLZbLJfb7vY3bZDIxwM9+n52dYbVamQt+v9+bnoWOb07W8DjyvCvLEldXV1Z0tixLK7CaO+oHg4EVRgWkcCdhPe9BHG9+hhoYXpfs8yexNeq0HqLJwO4xmPaIRzqOTRwcPfYc4bBXdcg+lVa4chMH6sNOmIY9vALnhzqTh42FNQGgRIsmFVYUstJ+UEkydC2GrlHInRBcg02q0KSAiT9Y/4NLWrgzKrhWtQqcrFsd3KXrDH4TjO9jiQiHoP6IJgXRqiACvi/MyXErXQevf+1u48DGmIB9oGDdI4nT28X+Mxwj9ADcZ16RgIhh6NDEgNLLd0BUJ7uuROkm+NX2En/mS38Bv+3v+++A/mkA2WPwPZRGSgi1M+hz5Ir+4KERtWoGLAhYk3dHzmprqQefOQDwLbUlqjGpoxaYhClIDAbrensQm1Q14uxnqjqSd/Bd6os3Eki0UXUrmeIk85m7lJCM0PbjRejt24S21EKTBRUoCjl4aeR+6gSo5UZ1I8n4l+yPjk2BbF3HoBfugafbCQtjQUkAcE02UeCTFca01+w9IMEhHKJNcJSbFp06vrtBgEtAlx1flwDXHgNvIAuUkuvpMeYkw0PQ7bJl2e9Y9sf4w/Qm1hR+h/abLXBqp/YRWj6xkr/2If+MRUAzGQKDEnE2AkYDAZvbg8DeogRGCkM7hbXjoUDR8VDA9b7utShNpg4BYMoP72UdwWd96yfcUNLfHYHVASgiMNIbLvVsVQnMpwplC4W90IKRoU89+0I/p8qPGsChlOV3OjPZaoHHTkFxqy4sXwAuKDRPkliPCpvbCGAPuKLfh1DIfjle2AlAlDT1vpH0tAvHs6Ih9D+3+rrnMeMMH/rv1JYUpXz5oKnyFmiKfgKi1H4N6Cxv5YvHIRTAmTrIqXihX7zQxHeZgElS33cBrHdI4YDu0MA1CTEl9bgDSc+i093q1D6u9sU35vgzf/0FvvT+yfN9aqd2ap+I9j8EcA/gJ/QrbwnA9xd8EwbTT5wneAn1mGBm4tplaSu6npmiLcvyCCQTRNLly4J+TMYSrjKdSrBHiMnWtu1RMT4ABswvLy9xf39v62Pil6AvpWQFDwl4AVhCm/C2qiobB4JJbiPvKycHAFjhQqa++TMgKWJ6rTlu3MeiKLDdbjEejzGfzzGdTnF/f2+JXgLGw+GAzUYmQ2azGZxzuLi4QFEUWK1W6LruCBYykTyfz61w42q1Mn/6fr+3VD5T6EyAOedwfn6OxWJhMB+AJb2n06lBaqar9/u9uc7pm86LgeZOcwDW5xcvXuDi4gLD4dCSvTFGPHr0yI67c8786ABsIoLp5XyM6KHPx5eQlwn+J0+e4P7+Hl3X4VOf+hTefPNNXF5eoigKvP/++7i7uwMAfO1rX8NqtbJJgfV6bTB4tVphOBzi5uYGFxcXmM1mNnnECYCu63B2dnb0ZMT5+TlSSlgsFphMJmiaBsvlEpeXl3jx4oXtGydDQgiWLOdx4kQAwS8T45vNBofDwRLfPLd2ux3u7+/x6tUrc8iz0SHOgq0hBNzd3ZmXO4SAp0+fYjQamd9+tVoZMM8L0nLSh+51Xj/T6dRS+oTavNaY6n/27Bm897i9vT1yfPPc49MVvD55jX1SW+laeCgIzv5ao087aLK4dC1KSFHH0nUGZm/iGKXrUKET8B1LA+Axeay7AWaFJKfHvjboXCkV7FKfxmbxRjaB2eoDT9UH0ugeEQEJ+1SihBSLJFQ/D1sso5yLMXkr3Fmr37vf/w6HWEphya5C6TqMQw3vorwOh9K3KF1nCW7vkq0nwqNOBSrXHu0bf+Y4xOThXeyLZkImDEIWbz4o7O+SR0ySBPdIdlyCFtNsooBxr/eCmBzaKPB70Y7wXnOBX6hfI/3Keygmvw6x6o9tCpr6bXuw7duEmBev1C7l6XA4Bx9ZNFLS2ceJcHVeZ9A05eltpoMfwiencDVLZz+s430EvNssAZ4B4KgJbN/Ia6lwBvYJgl0XJSHu2X/Xc5mHAWQdDxfVZx2hrnQB4bKPPWDOE+OWri8AX/fHz7dSsPLIWd0cf7YP8cs+xlKT1Xk6UrfHopm+iZpAlz5ZWrqN5nNPycGzVsKyRjMt0ZUe9ZkGDnTCo9gng+3Jc4zS0bYJ5HmumNtbi2q6CEupG+AP2bkAWJJT/PDOfMf0uT88Jpzc4H6f2ql92+3BafMh83Hy7yKguRgL8J6NBGanBGz07wedeJdijApExyMtgjgSiBoTUNfyuSb2vmsH9UZr8rnQJDGg0LV/agJVkAvk0ALbGqgUGAenKWdNcpfV8Z4kfSSm8PK+05t1AhBroKmlH3Ujo7BvtVCm+sXbKK91euNlMUsWkmTSvY0wJUkL2ZfJUPdJ988qeiaB3hudPPBB3usUYOt9GW1UMA4gxH6SIPeWA3pDdH0CO6VeIdO2cj8pSgHy3gGlju9qC+wPmtLv5FgBMk5FIWPmvBbHdDK2PMYjndxYbADnEcMWLYCYohQKReqffjn6hXK6X53aD6598U150vjLz1cfc09O7dRO7dS+/y2l9Jnvx3o/MhlarVaWzKYWgolWplcJOwnkhsOhQbQcxPH9qqowGAwsEZwXVGRaleoG6k6YXHXO2fqp0yCgGw6HBuFvb28BCBhbLBYGm6nwoNaEqXImipk2JrRj8rrrOtsu9SNUbYQQMJlMbNsEuywcOZlMsNlsMBgMLJUK4Ci1yiKXfA+AaVYIzQnZqdF48eIFZrOZjXWeemeKmgCV4+qcM33IdrvFq1ev0HUdnjx5gsePH5v6oixLLBYLKyDKdVF3wXUCsJQ3E848BzihwNQvX2dRxqZpbBwBKTY5nU5xfX0NQAC2c86SyUwp839GY4zYbre4v7/Hs2fPrG8EqYfDAbPZzNLQIQTM53Nst1tTzhDwssgin07guXo4HPCVr3wFX/3qVz9wbAjPOSGy2+0wGo2w2+1wdXVlEzz5UxPU/fBc5jHb7/f2RAIbk/nT6fRI7+Kcw4sXL1DXNebzuV1DnHio6xqbzQbn5+emVKEO5q233sLNzQ32+z0WiwVub2+xWq3w+PFjK5xJJUl+bJbLpZ2zm80G4/EYq9XKwHN+zRwOB6xWK5t84PX11ltvHU0C8Lqm4odwn09/cLs8pzgGfI/nFyCQnxMwXO6T2Jg0jslpatnr47sCcAM6KRgJKYAZEBEQcdNNAQDvNxd4s7zD3O9RutYS3/K9wq6rUGhVxCYF+VsVPaAmcCeMjgiWeBbFyKAvQul63QgVLRN/gHcRQ9ccrXeTSgQkg/AE0VSXcN+ZQD/EAruuQqN9ZZHJcThg6BpLgAOSiN+nCot2jK2vEJCsqOZAk+gBEcFFHFACLmKg73dw2HYDbGOFQ5TzcuDlD/VOi1SWroN3CQPfYtf195AW+nSUzwlir6lpU4BPCdfNDH9t/yn8n7785/D7fsPvRBi8iTgrtThissKDAI4SuvYanzrPVR4Q8Eg4mbykdnMQfvRYN9lu9vd/niSPEOWGpaVzjUX2qHuvJYEV7GTS+yhFrIXdqOZwTN9p3JiQmMnqFNyRksQp2GaLwSHUSYpvxn5Z30ifgybURRlznBTvC2DKOgmjEQHnU584120TrMsGYCl1e4+Bx5j6tLnvj5FsLz9WCpRL0QZE7XvYSYHOWAakwvcTFciKc+oxDHWUpHmn28yOK5Pw+X5ym16PV3K9UiaFfmzs+HzY5ErWXEpIkOOVCllXVMjuHkyMnNqpfZSW3574b0AnXvLJp1KT25OhOKmrSiCp/v+GfNj16otQCDQNTDkrPHWqEfGQLedKDu974A3gqCBkyJYBgIIzn15htOvveUUh20fSFHbqv8wXDi3ayG1BgPOhlZ93B4HGRZCvLmqfvQDdh8AbOl6E0bafri9yyUKcdvPyMpYRQOMFlHdREugJOpa6LftfWh0vwm9LfUPGOaUMsCfAp/44JvQ6FgeARZuZVI9JAHsCsN0LLC9L3f/Uu9hd0tS99s3rZEUZZAKV2zKf16md2sfbvvCGgO+vvl5j33QYluFbfOLUTu3UTu3v/OacqwB8BsA7KaX2u13ft6U6oYaDAG69XgPo9ScEh0xLE4bnbb/fm0LCe4/ZbIbNZnOUoKYiZDabGYBjmpTQN097EnwxncwUKwCDcVVV2WeLosBsNjPXdF3XpqZ47733bB/oFWaCdLvd2n7Rbc7EO/eBoB4QdclisUBVVTgcDpaSZcqccJIqDu4rYSSTyfSgU43B8d3tdkd+dQJDKj943NbrtaWbOXGQqzgIVuu6xt3dnSVwCfg5HgTtVHB473F5eWnpfyounHMYjUbY7/c4Pz/Her3G48ePrQ/0VgOwRDDhPnUu2+0Wl5eX2G63qOva9jvGiM1mY1oPoE+aP3v2zADoZrMx7QqfUODEDb3o7733nrmhN5uNqU/KssQP/dAPGYx99eoVvv71r2O5XGI2m+Hly5cAcJQin0wmeP36tfne6a/P9S75uPEcImSmFqTrOhsvTujc3d0ZnM8nSXicqBi6vr7GaDQydQzVIJvN5ujcmkwmuL29xfPnz+1adM7h8vISIQRL/XddZ09DEFQztU+FCdPu3M9ca8Lj7ZxDCAHj8die6GBanA5yprUXi4X583mNATiqL5BSMj0MVStMjt/c3JjPn+f3J7GVrkXQZDKBt8DoiDq77cckEG2fSnTOm6KEqeYJDqjjANs4wCYODDIDwKYdSOoYkk6O6P9H3Ltk4NY7AfDSL5ETC5gO6vKG6UuoFalTQAVgD/kDX3QnTJA7NKkwtzjT5AThe4XjpW/hY6XwuleLBNcnyhGB2hW2D6s4xLobYApgm8LxNmOBs2KLQ1f2yfHkUfoWTSwQIf7uWsE39SrsY0zO+uGzmCzHyqdkY+VdQpcy+B1l4mDRTfBuO0JarQ0q5jqPI+e3Azx5isJF3zwAtLp87sx2UdLjsdDXnPug//sBDOaj5C4JUA11QqwcfJ16jQi1Fll/XNtrNCxV3hHwCFxKzhmcR6fb9lk6uUsI9IKzOWhaL4OwSTlGkHERp3ay/fX7aHBaAP8DCM+WA9p8kwTC6v5O3vXp/QwYu1YmF3wjfY6Ft3GT/ZH1CpjWSQntdw6xXRSwngpJcwr0xwed4zxWTN5XGbTnIdFzyGvg1HG8nbznOk4k9Gl4+uJTyIB4dg4dQe9sssO2DR7z/tw7tVP7dprLf9B7iOckUQhIno8cABgPgKeXwHwMXJ4Dswmw3yt05syPpoIHA2BYSnHEEOQ1p2qRQjRWGAQBrjtVhDinqWhC2iiwtUtAyQ46TSw7TZArdK5ruSaqUrY3GQJnc1lHfZDvLptpglPIfTAdBxKAugP2W3lvs8nAr8LfUSWqD7q3m04UIUylB9/D71ILf3ISIARJUI9GsAu4i+LJmtbAbgdsd+IOjweYx7zwAvlL3demVj2MTijo/Vx2jTdrnWAAYb0emw4CrutGfx/osWv1ptRGSaBDC1p6JxMcVYWjSQdEOSbJAa0DXCGTIl6PIffvm/4v5OmGdWo/2PZsPsTFuMTdtsFXXq7xX3z77OPu0qmd2qmd2vetOefGAP5NAL9XX/o8gF92zv0xAO+nlP7338l6PzL4JpQrigKbzeYocZurQAgjWUSPUJbQlIlfOpcXi4Wla8/OzmwdRVEcqRuoOGEyG4BBPIJpJtGLorC0J5PCXEdRFJjP5yjL0pLYm80GXdfh5cuXGAwGBg/pJGYilQUKqUIBYKqWvGAi07FVVWE4HJpvmPvFvpydnWG9XmO/31uxTSZgCQe5L3nyfLvd2rqZsnbOmYKD+gsAlqamN5nrzj3lg8HAiinSpUw4TNDIIpg5wN/tdnYseI7wvMhVLkzBc/8ITlkIkVCUCg5OWrD4Y67f4ORGSskg8Pn5uT2JwKcHCJCbpjEPNicUDoeDwfL9fo+2bbFYLPD06VNzpz958sTOGz5N8PWvfx3vvffeUfFWTtLwyQIqZ9g/urpzbQ6TyjwOBNU89/mEA8E6YTST4zzGfHqAY/ns2TPTi7Rta+fr/f09AJgT/erqCq9fv7Yxpvt9OByaOogQmeOdn0+5u5sKHE6UEHwTsvMapK+fTn5etzyfmCynTomTDhxrjtvt7a1dl3mBy/yc53H4JKtO9qlPFBNWByREeJRoDXQHF+2PO++jeL4BBbXe/i0FMMWBve0qRDhMisMRwOW2CHnZmDrn6yzgWPoOMTmMfa+qqlxnABsAoIUmI2AJ8Q5OimLqMnUKCErOJv6AkMQl7lNE4wvsXImDFqdsUsBAi1ECOHKcRwQ0sUAHUbl08OoDd5Ygj60zvQsnANbdEB5JnOHJGbw/xAID3yLC2broCI/JI2offEqWKOcEgkdCG0WN4jV5LoVIC9zHMf6vv/jn8Xv+/reRSo9YeGMt4SDQOFa+13oAD3QZfYrYiZsFoZbEXCpEreEVeMeHoaIsXsniiAYtCT5dD2l7mN6DAvtcl3o9SKa6oN7Dlu+oNZHzF96pkzzZuZsKSSVaultT2HnxRPq4j9QsCt1l3GBFGqmBscQ7A5GxTzfnLvGE/r28mRc7S7iLFoWwGAaMNWcoEFpBcq9cwfGYtBGx9KIJ8c4S80iqYeF5VmZjqWYc+rd9mznDs1ClS72D3HUC6vFg+8c7if6pASoBsqS9FS6Nx+cKC4laWr/4EPn8qZ3at9Py+DfT04Ce1E5AblVqspfp7OwDlixO/b9Z0fBoMonv5efsw89n3/kZbtN7CNFVBUjbZQlpJs7Vv83vTEFHyL32wy6XmCR1TeVH28rnOBtAsB283KS71O/L0b6xDz7ziYf+NX7GR4HbXQKKRotJJlk+pj4tnqATBxzXfAzRf9kMhr5ulZG1bzwOUSdH6e+md51fKQFJk/xMttOX7riibJ2A7VtyDu7oRGK/Hn7g1E7tB9ecc/jim3P87Fdv8OXnyxP4PrVTO7Vf6+1/B+DXA/h7AfzZ7PWfAfAHAXx/wTcL0TGZS7BIGA7AwCbBMOE1AEufErYyOc1ENp3bLLjHNDQAS4JTtUHoTIgGwED3YrEwEA3A0tRM2m63W9smQR/fy0FhDoipT2Df2X+mwLmt2WxmiWYABvKYNGa6lboU9oVQjzoXplXPzs4M7BGI52l2Ana+zoQrlRIsTki4meto8v5cX19b8UTCZ4J/AmWCbGo5ANgEAVO5/Az7xsmCXL1CwB9CMI833e7UgTClzqKdVKoQhNLNTuUIxzFP5J+dnVkam4CbkxM8NlSncAJls9kY7OX+MWnMyZ633nrLUuXU5TDJTec5C20ykU+lDM/bs7MzmwSiq54TKHwKgY51KlpyXz6vJ8J8an8AWAJ7OBwaHI8xmnt8PB5jvV5jt9vh8vLSntLgd36O5xMnQHid8fzlGBJac5KLE1wsqsnJkdx/zwkoThTxOFIHxCc7WACT5zj1LkyK83N8ioFPYDCVntIn9w+UgHjkvB66xpLQ5tPW4dmkgRSHjH0hRyvCqJqUOhWmOWlSQKFp67zlxSo/rFFBkkPxYaYQAaAFKalKKbQgZl/8EpCfPSL2EM+2vaer7ZLH0NWIaaDrTJb67pLXBLbs/D71TyQdouxfGz0O+qsx6nXXRS+va5rbI4nWA0l1K+rkTsES3/2205HjXOB/RDQNjMMhSoqcOpQ29oU6uR6u474bI+JWXa6664muafnum/QBp7Ylh/lPaj5SDyEFGjB5LJNyBL2JaldbX9Lk9DFIp8fatUmVIQBiljLXProuCcCtQg97oZ8pCH7T0TapynCapDxyjkcpuGiqE0/o2wN1gm44QuEswZwSHvKOoyfdya4JxzuhMKlQGJVk5TwOtr68KZA/AsNdv11Cedt3he/U03DskADfxA8Up3RJdC55It/Gtk2Ipdfj1XeM7+dAHFH1LzzuCuwffkYKmWbjZyfX8cSE6XXyCZBsPE1zc2qn9l207JRTx7xD6BKKNiJ1QFOUSJUWf4QmtVud1RooDK9rSVm3raS+QwCcBjyapofUNqul6eSUJO3sIPDZQV3VqiYZDQUeF0WvAPG6ngj5AHk4nKTRnQJvqGqFfo8Uj2Gv84AvITc4vdEzuTwcAqOxAOqxFvQcjhWSt0Db9MUtE3qtCZUvRZB0fFmIGzuUMoEwHghc39eSNOe+JQcMFUoHaJ/Q/26hpsXT8U1QnR1IgnBqYpzr7x3576Co0Htfy7Hhk0IxifKFifqmltT7YKDrYlJc+4nYF7n0kqx3QD9R7fKx/65O0VM7te+4feGZgO8vPV9+3F05tVM7tVP7frffDuC/m1L6q84dPRf6JQA/8p2u9COD76ZpzC+dF6ckFGRBylxPQMcyP58DYOfcEaylPoWpUcI+gnOqGggsmRwHYKoHpk1vbm7sPQLg29tbXF5eoqqqI2UEtRy73Q4XFxdYrVaYTqcG+1gMkmnbXMGQF9wk2GN6HIBBvsPhgPPzc4Ox1LkQOg+HQ3OdM3l7fX2N1WplMHK/39t4cxKAqWsAtgzHnYUMmQgnGKSfmz5ojtHz588xGo3w+c9//sghzpQ407pMnTNty3HmMeK4EkDm22V6vK5r1HWN2WyG+/t7OOfw+vVrPH782D7HgpdXV1dH+8ZzI/c/07E9n88NhjIxz7FgcU+C2PzcYn8J6wlunz59aonww+GA9XpthTYBmMalbVvc39/bUwzz+Ryz2cwAOQC7ZjgWhP1MpxPwxxjNVU4NSl7s0S5cLUzJiSCeZwAs4U74ThDPCRA+McBjNZ1OMRwOLVHN85dwOU9O8xykHojaHR4PTm7x3ODEEych+BQDzyNOJvE6Go/HR4Vy2UeOUV70kpNWHCcqkDjJwuP0SW3UZhCY5loQvk+4+hCUA6o7iaUlxvll8Nelo3V2JmOWzzORTaCbr1+847BtW8uWseWdfGLoGlSuw2VYo0kBN90U0fUFLun7BhTYw1sBy+ic9V/GQlLveUTX+unFqW1+8iQKk5g8muRROkL6ZONKoO+RDIoDQB0LtFFS5oXvk/DeJXQKg4OT5QnCkZCl4pONt6Tm5ZideSluFoMXRYaTtLO5odsoACDTlFCXEUtn25GxUtezFkwkX3Gd/OEv4JPpXViK0aU+rQwwaazQVqFFzIBmr7pAf1z5PmFvytbR9rDXmoJjraHau8g9i16iTxOrRoWTF3Rp02EedKxCnWw/pCDo8bhZX+1nB9dGVaXI9thFX0fpk3ptjY2lHiAfFfVk4jmfMNDXJSnZO9jBw8DQJPujkDyVXrfV0z9RqmSDzkmCB+5ahx5+2/qZBk3ZZ9zxZ2S88eGNaXYC85hNVCTIxEXMCluegNKpfTctZd8sUSz3sKITl3xDmJsns7OnTgR8NwJRQ1Bth57kTBjTJw0tLKmAHZw4RH+tybZ8D799EADrvShHCge4oNAaenOIoh/ZN7LcQDUredGGlGQ5er+hv3ddlBQ2tR7BC8wdDCTlXlWZ7sMBXQt0jfS97o73h60oRHFSaf+9l9dGQwHfoZB1OU2GB/2Mj5DZ1xxYK8hnopsHzEIKJN7Zj3yf99v8QDPt3bYyYeF933f6vJEUdGu/nNPjqMeLjnbvDMYn3bD8CtCJAJn9k3vlRzkfT+3UvseNBS6/9P4JfJ/aqZ3ar/n2GMCrD3l9gu/iL4aPDL6pYiCkIqDMPddAD3u99wZlARgso3OYSov7+/ujFCjhFSEYt5s7gZnwJISjdoGaDSY+AUmlMj1KiM31ESIDOCrUSFXHcDg8SqXTYc3kM+G3996UDAAwn8svJ8JEOqTv7u6sSCSB7/n5uYF0psq32y2KosDr168NlrO/LKDIsWQ/qPgABPrymBwOB4O/dCNT3bFarbDZbI4c54fDAc+fP8fFxYWNz2QyMVBPqMrihrnOBuiLHwI4SplT28HJg91uZ0UmCX8Jj5kifvToEVarFWKMePLkCRaLhfnOmXYGYN855gBM30KlDc+5tm1tEoVObypQ5vM5Hj16hNlsZuOxXq/x9a9/HTc3NxiNRpY4B4AXL15gu91is9nYNUGYy2KuhLPr9Rrn5+dHsPf29tagMSE5j9urV68wm80wm81M7cJjnjeOK59O4DnKCRoeNwJsJt+pSJlOp0gpYTqd2ljznKHXm2PE64l9zBPaTFczac2nQtgXQntOIvEa3u121mcqaDjplety6H3nEwX8PCfieB3w2iWE/6S2JgVLG5tXGg8jwH2rU3EEoKWgpEODEl61JzF5NJHguLPCkN4lg8pBiWR84HwQ1UrUnwtTdwAwSGzb1nR2kwp1ebcYhgZD15gLnM5v9gsQP3jlOpRZH6RAZbJ9etjo6mYf5XPO+tu/JtA7Jo9D8ih8h4FrBWQ7oI0E7uoST+Llhu+wiyV2XYlRaCwR710yPYtHQpM8gktoNU0fk9PgmrMJhpgcVt0Qj4olFrE2eBMOUrDQJ2dKEDgH1wiESR69BiSiL1oYJB3sNGFoYJoB+pSAjkUXk+pSssEj3zHAiR6wW+I4GUA9UqKwRcClaPuSCtdzjbLXn9gsSUpITiBPqgJ8FxGDP1KMuAS4Oto+G0AvXA+cFUTbPEvKEsc6f2NAluu1KGnSdQscTgqobSKARSyz0zrlY+MzqJyNH4FwnoQmhAYA38U+za6P/1sqnMdXx4faFHrQfaPnXSMp++R6TUpy6It1sp9M00P3q0s2kXKkeMn6QHBvYwTY8v1kAPQ87Cc27HPHt4FTO7Vv2ezyyK4TB06sRDi9PzdDhzT0qjmp1F8dgC0EMjN9bIUsFYbWHRCSgFVCZpJ1wvOiELC9q4FaU9qVQmCn4NsXPfBmhzlpxKqwDpq21nR3KPrt8ZpzTp6ecV4mKMtKAXMDsOZTVEJML3lZCTwvgvi2qS2BV791EgA/VIe40/3rVMESgo5bKX3yhQD1Vt8n4C808Y0OUlwCCta10AS1MoT2yO4VKcn746GC+qHA+tgJ0I5Jk/ZRXh8NZVKCjvOjAqA6w+i9HDumtbskKXDvJbFeellHo/eqViZBYlnAjSr4toVvGjlMDke6KblN5uT+1E7t+98Ivr/8fHmk+zy1Uzu1U/s12P4TAP8NiOcb6H/Z/pMA/sp3utKPDL4JmZqmwXg8Ng80YRShE72/eToTwBFEZhKZEK6ua0tjE9Ax1czig0ySEs6x0CPT24TseUoZgBW1JHxl4pnwjboTQKBt7kgm6Ce4yws+Uh2Rp2sPh4NBaABHYJv9Z9p6PB6b7uL+/t5e59jR9VwUhaV6qb7Y7/eYzWao69oKIzLFy+2yMCHB73w+x+FwsGKUw+HQdCJUnhCCElgTLuYFGDlxwFRtnvAvigIXFxcGg51zWK1WluI/Ozsz8Ew4T+CZJ64B2BjWdW2FVZfLpWlcXr9+bQlnKl222605w1n8kZMnTPW/fPkSo9HInhh4/fq1nbvPnj0zsJ1Swu3tLb7+9a/j1atXWK1W5v1m33h+pJSw3+9tcodO73wSiOcuX1utVri4uMB0OsV2uzUFSa6CqarKAPx+v/8AYCbwpR6IAJuTGQBsP/PCkFTpjEajI/0QlSt5kdrFYmHKEl5fPH+o5gkh4OLiwlzuvCdwsoXfqS3htUWtChVGHFdODlG7A8AgO/vBiS6e67w++UQJj8sntTExTLc00Pu3g4u9Q1ubLNdacct9Kk1zIoUu5VfFIRYG1MsHupNDLFEGVlaE6jz6RHkP4QnAw1EqHBCgPnEHTVEXCvAjzsMWc79H6TpsUoV9LNGkAnUK5vgOqjRptAinFMGUApXsMxud5QHi5mbbxsrANceLfeB+xeRQxwIxOZSuw64rbQy7rIBlTA6bdoB9J2N2iAVGocHAtyhdY49RHx23B6/lfeBYR3iMXYBrWvgmihaEjJSQMk/mtjCamrxDZ15aJ+k8B3Vmq9M59v5tC7ppAcO8EQ4j5LoQ9EUmvULzok/82n52Cb7uJyISenhqjevMgG8Pi5PpNrgtAKYCkUKPCqT7RxAQaqAbSOo71Ald6eBb2D6w78nJMr7NktoecG3qC0Aq6HaaHHQaLpQ+p6N+yUoVXhGAI5kuBV4nLVIPwGU8kyauJfFIoE09sBxF1b/EPmFPb7Zr+3FOXqG7d6ZJIXBOanNwCUdp9qN0fp7M7KK9bP0EjhPuTpZPR2PAy8jBOem3jzFLc57aqX17Lb9juuwrtAkeEe0QqEceGGlxxmogIHig6d+DpruhaXDPtLITKO6cFEokBGZiOQBWPLEIQK1Jbe8EztKN7XSdpSpWWFhSJxalw50mjhUql6pPaTtgs5d7ZwFVoSgc915S3AXhuN4QWoW+RQkkTXsPBzLxVGoiuqhkP2rXg+vxuE+DJwhw3u6lP4NBD74J5OtW+gcnQD0WQKewvdD/L9jrmARNuqckMNwgtevhvvfAfCLwe3YOzM5k2d1Ovq9WAroHqm7Z74H7hUxKUF2ST0wED3O7E3x3jbw+1nMA0HuZA5oINBGpLJCmI/jdHkXTIDoZUp5YDx6WObVT+4G1H3k8RRU8VocW797t8KnL8cfdpVM7tVM7te9X+xcA/Fnn3Bch/wf0zzjn/i4APwng7/lOV/ptgW8WliSEZWqXvuGyLK2QIl8jFK3r2lLiTGnf3NzY53K/c57Ins1mWK1W2O12R4UiqfDIC1wCkkxnKhyAeZSpZiFI57YI8KfTqUEzbov7eTgcDNDe39+bRoPrJoAkQM4LPr5+/dpS7IR2HEfn3NG4MEXLhHnbttYPwnIm0gEYEN/tdkc+ZI43HczD4RAXFxdWmPT+/h6z2cyUIi9fvsQv/uIv4nOf+xyKosDTp08NKjIdzeKhVGrk2ppc+UJYPhwObT+4Txw3FjHd7XamCiFoXa1Wlnjnes/OzqyoIZPcuUaEfWISmUA1V2hwMuXs7AwvX740zzahPF3bnHR4/vy5TSx0XYdHjx6ZE5tFRDmJslwu7ZyiAzv3ibMI5mazMZXHeDzGfr+3iRdCcxaKJLhlAno8HhugB2A/c330reeFJnlNcGKE/m0C+7woLc9RTnpst1ssFosj1QuAI70Mt8n+3N/fW9qd1xEhOM95XufsByAp8odPlPB97u9kMjHPO7fJ8aOCiYoe3nfyJxE+aY3O6CBuiExH4oEkqWoABsCH6jCtU/8roUteHdvy2qqTJx2Y8vZIOMQSA998iCZFYrO5/sSDn+vEFR4LbBVMG9R1Hudhi1qhd+k6PCsWeBxWtm4p8tjf64ZWGNIrEA9oUmFQfeBaIMj+MM09dC0OyaNzzsYCAGZBnmwIqI585EyWS/FJh0NXoPMOPvR/ArfxGOS3qUAdA9oY0CaPGPoClrkLneA8KrgHdSo6Jt4liPlClCibOMD7XYc0HqIb+B7yetF65AUazSOdebjDQbYdS68w1ElALwePmgIGdR+Jrx3D0Fi6IwpABQmBrSWCZUfkWxPhmnicCodqQSIApq2RjjQpKUjKkenllLusOwXG3pn6xfafsDY6xIFDDOrhJhdpqUCRRDRVMLHAEWhPQQ5JDM7AtYzhMbC3FPjDpulnrz5yGglkvx9oQBKOilzmLX8tn4ygC9zlapTUj2FXBPW/R/lcFlj06mOnPzxXjyTC+my9PP49yJbjYYUq0afIrb+p3x5T4D5XnXzzB1JO7dS+dUvZN6eTVwBSVQCTUoBqoWAZsMkbgdm+V2YwjZwgqgy9PmXlqb+fQDfEL69KE89ZMtd/eafQmDNI6B3dtowXiF4WmlL2gG+A7QGmWjFdiNc+KfCly5opbU6ymadbt134/nWnyhKkHkznxT5TAgZR3hsOM9VJ0LHSRZn0jhEo9QZeqOScY0ug7pwsn9CrYehvKkI/scDini5JOruFgPcY5f2Hx8H5Y4VK4mHRYxF09hI+O9Zdvw6nTwM4yDGoGyTfIMKpMj3f1vHvvFM7tR9UK4PH555O8QvvL/EL7y9P4PvUTu3Ufs22lNJfds791wD8cwDeAfBbAfz/APxkSumvf6fr/cjgm8B6NpthuVzi7OzMoOBD+JnrCQig27Y14L1arbBcLs29zAQqi1oSgJ2fn6NpGkuV7nY77HY7g96EljngYkKa22XKnIC+rmtMp9MjAK4DbAoRpoeZRCVMJyBkopyAPYfYu93OUqpUqxDMMXlNoM2UNycJ8gKSTJbT5c0Cm5vNxhQnTPDmCWcAlooPIWCxWODi4sISwoSsi8XCjs/l5SVevnyJwWBgbmp6x/f7PQaDwRH05qQEHdWEk4TwPF8IPAlXCYU5rkCvotlsNrb8/f29ObCdc1Zs9NGjR0fHnAB0uVxakUrCfhZ15NixOCgVNkVRYD6fG1Bu2xbL5RLT6RQxRux2O3z1q1+1pDHPpYdqFybZd7udHRc+UUCvPcesqirM53Ocn59jMBhgvV7j1atXqKrKJhg4EcSEdtM0lmJnKhyAXR+5q77rOivOud/vcXl5aSl9QmpOKjjnbAKDKe+6rrFcLu0843XDNDuvY8J6Ft7kdcDzlhMAfFqAehNCcZ4PvO6aprH94v7QQU+tDBPmAOxa4IQTnxzheclrlVqUT2JbdUMMfYOBb0xxcuTM1j/cgovwCsVDFmXKtSBNCmhigXU3QEwO87DH0DeSHNdUNQDVcXgEA7YCcZn83qaAbTdAhMNe9R9NCpgXe0mKa7ttp9inAk0sMC33GHo57h2cFeisXIe9pcml042m1ZkUz/vPfS1dUk92DwwtgR4LeFWoDHwLnySlXaJD5xIK31mKftN++LnVA29ZV+U7FC4K+NY0+CEWGKQWhY5T4TvTnox8bcC/8BEjJ79LvN5jXxzmeHd3gX/vG78Bs2EhKeXKKWR2cCn22grIcXZtNOjqnP4bgG8jXOsRB14BMSwtnrxDGqBPgDeyMiaEuyoD6poczl3dNh4KN0wDoo0+ah14ez85gecuxv48ZXK7i0BUrUfhEEuFP6oz8V0CnKSeU4BpPHJQf+QhV/1sPmcTq75gY2ikSCgAA8UGc+VFqaVWR/hWx53O7gzq66Ly7y5Thyic812y9ffj4DJ4A0Tv5TpVNYxL0KS/pKaFkRHi4Oj4GxyPeTI/IdInDpkwSd4hFtKH6P2Rc5x9Z7Mio0xtcv3U6OhYwPcQnX54H7N1ESpFfADwn9qpfcuWTd7wR/7miqWA13Q5B966AOYzYDqR9HJ3EKAco6SHAWB/kGQ3QW1M8hpcnxpOkNeDy4Cuzl6VJTDXdfF1U5IUPXgfaPJ7s5c+eKe+7wK4OAcmI8jsXwA2W2C1kQKUrGXM9HgXxUXeteIl39WSrl7rOudj2dZ4BEwmmvjmDQXS56oAipHC4aFsVyriqlJkJH2/upS0PMegaSSJ3bTAuJE+VRVQNvIavCaxo4wF4bz3wHAk/WN/g9Pkuu5XUfb6GDj5K5WJ7qISuF/Xsn6OdTUASl2uawGf+vEvVNPCCQgkSfkfGj2BgqhpLguB4XUjk/ZtRHQbuBThuw5wDtF5xKDnRjzN1J3aD7594Y05fuH9Jb78fIl/4L/w7OPuzqmd2qmd2vetKeD+vd/LdX5k8E1FBWEpk7p8L/c2EzzlSVH6qwmvmdrO3d/D4dAKQdJpTDDGdCrBGtCDSELfHHITTnrvzQlNGMtEcAgBy+USs9nsSN1AZQQBLfdrMBgcOcXZv/F4jMVicdRfjguTzXRlM0XM5Vj8j0oWpp65XY53vo8sZkh/c4zRgCUgTmZOFhCect+ZqCYc3m63OBwOuLi4wHg8Nm0HU7+j0cggI8eBRS6LosB4PMZqJWnMHCovFosj3zrBNycOONFBSFrXNd59911cXFzg6uoKRVFY0j7XXNzd3eHi4gJPnz41nzgT+oS/hK78mf559vv8/BzT6RTr9dpAOs/fuq5xf3+Pd99911Ll47H8MUN9CxvBL+F2SsnULjwudLyXZWk+87ZtMR6PDUYTvAO9szuHuFS1xBhtcoMTHw+Ll3L9hOWbzQbD4dCS0QTh1Ow8evTIjjW3DfQTWEyJE3zzuiLwJqhvmgaXl5d2fuR6IY5D7t3mz9QUMSXP9Hp+DQMwLQ+vJU5+5Cl49qeua0vCf1IboXRMHlFT3+bddp0VgSzRGnTtskKYweEoCR1cRBulsOXAtxj72oB2zOJP1ILE5NFAktI+g+PBRTSqFvEuiQcbyHQsDttuJOtBwnUzw3nYoPG9a7t0LTo4LOPQILYpVTKdCaF8hDOFSOk6S6hLIj4ZTyh9iyYW6JKXFHkUINgg2GPkHQRgl777gNaETZLwhb3Wat8KH023wsS49Cmi8B3GvkbpO/Ooc1n2pUkBA98iJo83JktsdwX8qFR3tTPAnE9syPHOUs/8txxwhBgNvBKWdgNN2nV5ahq91sMBQR9qsnqcBLUE8ITgXfpQoJkvI97aiBS8wO2jfiYrYAlAC3RmBSB1V13KCkNq6BApU54APYzOVTAOoMXGlgvqM8/qsplOJEtCs8XC9bHnogfueerbtbFPcrOIp44V+23rRw+Bmdh2DzYqEwS6/1WW+i6y8wD9WBF+Jw/VomTroiYmCEC3wKvP4Lt+y/UyRylI7mf34DwjG0p9n6z/Rij7107t1L79pk+HoE97w+kTJA4CdycjYDToE9lNFEAak6aVExBbyAyM61PIHf+dQ+4P3gPAFHZJLzcvGnf8ftBUePB94UuvQDb4Hv6yAAHhr04amc/K/NgxS3tHSai33QPwrt+Z9Ea+LicpcITe++05A6ep8LIUqD0YaDFIyNjUQcdP+5kn0lkQnYA+ahqdY+S9HIM2wopKckwsJQ4Zx6Ap9KIQuJ1N6h3vk/6HyimXLaN1IWwCo+1s0lTOF2ppnCbz5dgc/RpN/L2Rz6ae2qn9YNsX3xDP95eeLz/mnpzaqZ3aqf2d1z4y+CbIW61W5ktm0piub4I3AqhcOULAdzgcTOPBpObl5eWROoHADYAlQwmlqUvIwRidwEw/s6ggAFM8lGVpQBmAAfazszNLrBN+sq90K9OXTaBIPzbd0kx804mcu4XbtrUkcw7yqN0g/KYPm32m0oNJeu4fAPNyr1YrS5LnapD1eo3dbofLy0ssFgvc399jt9vh8ePHeP36tcHP2WwGAJb05hgtl0tcXV0ZwGdqnV7mtm1t+Ty9zeNaFIWpVwgmWRwxP84sgrher+Gcw5MnT8zdfnV1ZQn1tm0t/T6dTm0ig+P56NEjm1RZLBaW2Gb6nxMqBNez2cwS35ysuLi4MHXMV7/6VazXa0ynU1snFR2EuxyXyWRiKpXNZmPu9cVigaIosF6vj8aJQJaTGpwoGo/H5ganVodpaV4LHD+ev7kmZbfbWcr97OzMtkPovN1uTTFD9cpoNLJjxwkCFiPlZBTd2byO+UQGwfd4PMZ4PD46Hzg2+YQArzHqSYAerhOQU1XDa5fXH+8DnATh+Zsn+znBxfPrk6w5AUTrIUoSBdmI9jNhrUFufa90QJXkXKuVaFIZ0qSAwnda4NFZQcoODp4/mwPb6+s4KmLZRH0qyEUDw4XrNGHd6PaC+YsJqQMSNqlCQLJ+dcmjIixPwUB+k4Ikw2OJQyqwj6X5xce+Ni1K6TotfBkxRGufjRkRLF2HxgVNfMt+I8kkgk+955wKEvFglJIKSw51DAavCytqSb+5R6FUcOAbTIsDPBKGvsEevcYlL/wZIEqYstjh06Mb/JVFBXc+EtgYk3pWU5/CpvYkg470LrO5LlqqG9SJAOgqBQ+AJYgNLLc9iI2lR7v3q38AAQAASURBVCo0baxMIU/zUn1hyV7+rBHN5J3+rEDJZW7upPD1SO0hEBmq1TgGraJB6QahXzb3XXdAKnrgSnWJua9j30f+m+AYQA/qdVvQ9+GAtvSiT3GwopEPGx3eemB7KO3dhypNuM1eBSLjkxcPteKdmnCnxoTbj4U6zKHb08QqC57225FzgfsA4APKFRnTHs4/dL5DJ1/6zx5PWkiHUr/dh5MDJ5Z0at92c8c/OSB5hZytgtVBBTy9Es91qX/yLDbAagEMxsD0TMDsZqPQOFN30PE9CNl5rOnlptM0t5PEdgxArOQc76JAV0JfJrIb1Zt4L4C2KuW+PSgFttYRWB10M0k81skBLijcTkBbSxK968TB3XbAtgb2raStu1Y+0zSync0ewFpS1WN6xiHLtAnYQxLbAwXPo0ImCzrI+4WCau5+hNwgi4HcRMNAfOfFAJg4SVInJ4ns0RhWzDKx4GXS9PYAGDWS3t7vZR8nM0nmV5X0pW1l31ICqqH0cb8Hdnt1hkP2ebMV/7cpTKAAW8ex0SQ/NPldDWQcOGEQoxQybVvpT1NLott76XqKOq+bvsnEx6md2g+m5QUuT+3UTu3UTu3bax8ZfDO5OhqNjrzWBGl5oUhqH/gZtv1+j9Vqhbu7O9zf31salUluplLrusZ2u8V8Psdutztyg3P5uq6PiuPlxffyoprUTdzc3JjWg0llJnnpjM5d5YTn/DcBPxUp7AthORPa9/f3mM/lF9Pr16+Pkr273Q4pJQOCHFcCQ6bOx+Mxuq4zeLndbjGbzQzsHQ4Hg5JMBufqD26TKhXqS54/fw7vvcFE6l2urq7w9OlTDAYDVFWF9XqN169fG5RsmsZgMY8pgWju0gZg8JLJexZ5nM1m2Gw2NnFwd3d3tC9Pnz41VcyrV6/s5/Pzc5vMYEI7P/4A7HzjObfZbLDf720CY7Va2WQKPeOEwbPZzAD0arWyApQ8l8/OzjAYDLBcLrFarazAKCDuceo9mqYxjzcd1xxnpqDz/QVkooBFKbuus/6yWCw1QjyX+XkApp9xzuH58+dYrVZwzmE6neL8/NzOaZ574/HYrhdqdXIAD8CeZuA1wWuLxWUB2KTTcDjE+fm5AfRcTcMJkpSSXVd5cVsmzjebjT2RAMA+C+DoXsMx5HgSfPN6pTaIsJvf8wmDT1qTgo6SvC59n/AGYNC7dO1RQjogYejl/BrCo04BTSfakC55/YwCXCQ0sUBwERHJktVdkj/og4uW+O6SR9T0dek6dMnDu4SBb1EgYhr2lvie+AOGrkEHge0zv8d52GDoGuvnMg4R4a0oZQ69ARwV3GyjANzSNZZgZzo8h/MAMHARTSf7yqKYQ6bDk8DtQ+ZA9y5qQct+3CPE3y3f+4Ka3iVLiQf1o5veRN3fwUXsY2njmBe0pKbFu4SzYosfHTzHX149QbGYwTcV2kmJCFVgOC0YCPTQm7oJfQ1AD5n1Z3hZxtcCbTpVoBwpK0Bgq+uOCa4WrYAVd7RkNXovdAbEc42HQPoHKeeY9df1aWxn6UsF2W0GopOsXxQoDr5JSKVDrHwPzX2/rKUB8/4m0aSEOqknnAc2S6d/GPBwwn+S1nmLReZZ1+++Tab0sOPSwSZ5bFUpfQAuP/wcW+5Pj6XvobrLAqddDv4FOucTBvlECBUsTHaDx4EKncIfpcANiHMMc6it6zbHvMJ6x/OJXU3Hx/DUTu07aQx3w7QkEOidkgDf86kWZ1RNxXYP3K2BixK4HAj43O7kInYKgCME0iIBFbfCyTudiEqxTxKHAIQkJ3vUAo4xAVAYW7eyTqcpZuckKV0WCmK9gOaukc8gCoRNAOB7oB5bgd9tFJjOdTPtHfVG1EYgdMC+AbCXYp4lVD2i121UiB8i4CsdzFL6xd0NRQ/9ec+EF1genHz3ncDyqgQKBfNtkXnDdX86hfScYGh1kne9lSKdwxEwnfUHNEH2LQGYjgSIAzIOXo9R2wls3x/6yQbo8XBO9Sed3KS9QvxCJxyaFohND9CbVuB31/bH1rn+tpv0Px/ytMupndoPon3hmfCFd+92WOwanI3Kb/GJUzu1Uzu1U2P7tsA34Rz9w23bYj6fW5qVkJSwLnd/O+fw8uVL3Nzc4NWrV1gul9hut6ZF4DKTycSSzgRdfG8wGBg85noJvwjCcjUJACtqOZ/PLYXMf9PpTcUCVSNMdm82G0uZUw1BlQVBNt3It7e3eOedd1DXtYG8J0+eWDFQpuGZls01HNRJMPVKYMxCoYSj9DPXdY35fG7gluPDRDihMJUiTEg3TWP+bxb35GTA5z73OSvSmPvBuY6UkhVMzI83tw3A9CocL04apJQMjrKPt7e3VpyUn5/P50gp4erqCs453N3dWYJ+Mpng6urKYDDHC+gT/23b4uzs7Cglv9vtzFVOpcZ+v8dsNsN0OsV0OsVkMrHU+de+9jVMJhM7xvP53CY+6L2mYoWKH7qkedwAmMaFY8++TCYTxBiPijvySQgCcMLp/X6PzWZjyXTCfQAG16mJITAfj8e2v/Sy86kAerj5xEZd15ZIX6/XllKnWoXQeTwe2znNSQOm8C8uLiw5zu1zn6lPod+bfeFkyXK5tCc4eI5xWWp3uL/8XP6UCScseB3x+uI1khdA/aQ1Qu/gukzHIZoQQPQZTHpXCqOBXm9SoUOt8JdQm3oQn8Fyfq5TwE1g3MQSQ9984H06tCMcggPGrsbM7zFR4B4QcR62qikpMHYHlK7D0LXYK3TOobf0MRmcFxWJTp4goYNHgYgmBmxRYeBa+KBPL6iTnGPCceP+BvQQ3SMZ9GZxSipO8u8yhgmTUGPXlUcaFK9ali450Z4oRKE+hsU3D7Gw4qSt8xiFBmNfI7iIsTvgMmxwFdbyZNWhhgsObljY1EbSRF9f0DLTjXQpS+oK1Eyll6KYMfX+77rTYoW6vk6VHvrUOVySQpa6WhZFPILKEEjum6giAmlHieEE6QMIWKEFz5Clq7M0eOE14Q6EtkMqnKTxC3VlQ6B3rMQrm8NxA+pMmkfY/hHaszik8wLuDc7H4/3SAyrrgjO3tW9TrxpJGcwnKCED4j5FBwTY5IItq7qWPj3fJ+BtrHQiIGnSPRXuGESDiXTdFgF4ggBwh+P0uIOMW0xwCsZMy6KTGNbPfk6gHxceR+AIgB8dQ5522WTHB+D+qZ3ad9VcD6MBAbdlpeA76JMTHgKTIXBZn3gxpQjvFZx9o1KD6WDvFPq6fpv0VLe6TGLhySTwdrMXoNyp17pQn3VseqUKQXHbSOq4acUD3naa5laI2yqsLQoFyFScuP4+HBXOt52sCx2wTQq+Qz9O1Jrwc62mn10AQtkXhkwQMF+zOIJez5WCt6KQr+TEKR6jfB8MJH1e7xU0b+Q77yFlKcuUlay3a3t/ut5X+s5lv2dS6jUvPE7QdDxb4vngZV8GQ9mfQaXaG4XhjbrJY5R9qPRcSbKfFOkkbv80S3dqH1M7G5d463yE9+53+PLzJX7Tr7v6uLt0aqd2aqf2d0z7yOCbagWCZ2onCPHyYosEvYS7AAwUb7db02kwOUqdxXq9thQ2dQtMpuZqByZjCQipvWC6mBoLALi/v8d+v7eClXRZ5+5nqkW891iv15ZqTilhs9kAgGleCLLp/CYMvb6+xte//nXUdY2rK/lFxGJ+bdvi8ePHVhySMC8HdnwvB91MnucqE6Zv2XemiXM9zNnZmSV3N5sNnj9/jtFoZBMNLFhZliUmk4kVEWXqmbCa66cHnMdwvV4bnKR7Pd8fKjum06kVpiSgBHAE97mOu7s7U8YQuj579gybzcZ873S9r1Yr83UDvf6DPmwen+12i+VyacoQOsMJXT/zmc/g0aNH+NSnPoWvf/3rdk4yJT+bzRBCwHq9tgmGfGKDCg9OnnAMOfHC8zV3Z1PxMx6PbaKoLEtLLHOfxuPxUTFHTsDw3IoxYrPZ4O7uzpzznLSggiQvLpunqVkckjqf5XKJu7s7KxzLY++9t6cP+FlCb445FSuXl5d2XrLYJyeXOOacMMvHkD74fOLiYUKejRMyuSop16bwiRHeL7iNT2I7xBID36CEJqJTNFibF66sXAefaVBYKHLoGuxdiX227LzYY9nKeNObbSlqCLAFehjOFiFqlJgcokZ46bEehBazsDf4fBXWaLJUNcH7BhVWcYhNlEmmOgVEksIH/m3vosH1sa8llQ2PEh2aFHCIJUrXYdHJut6s7mx7+1RiEce2X95FSYLHAgf9dUlQDfRgPEL2p3Ad2iSKk0lRo00enZLFQyzM9x1cAstjbroBdl1lkxUcRwBovRS5PKQCA4hbfeIPmLgGiBGuixJMayNSCAYiU+hhsf2NzpSterSTpg4tlatFMI/UHoDpKsyNraxHtBi6TOGPVB1Hn1EQa27oh/AU6BOFXTSQaunntj8HReUBUZ0kAF0SzqHrp4KFhTLz/bZ90n2MpetT6ZosZ19927vNbZ+yQo+2PYXivomSulbQbj70LhufPDGfdEP62f4YSGr9mzYPIDqdlAg2nqlwiBnYTkV/DSbPYwEc6Uf051yDQzVK0r7kzc6H1I+jzbZ4yNhnxS2Tc7BL+cFkwJErPIP7p3Zq300TzqknZdD7VVUAg1EGOjtNA6s+ZH/QBHcGqrMnUQSie/lsl1T/wfNfk9sOAm4HQ9Ga1KrK6CBfh1b0KsEDoyBp4+EYGDj5/dV1so6hesi3O0lBxwQc1Efd6jrbTpQpwQPTqSpBFG53WTI76rabRiB8o+oQ5yTV7TxQeins6HwP/GsFwNUQGFYKvjlJ0AG7RgB7oWMzHMq+e9/DcrrFHz8GZlPRyCyWMtbRSxFR6IRCTMCoVT86pI8+yOQA75N2L8/gd4QC/9YmNOU4lQaspekxKitRrxQBGCrQr5Ks46CFTVMSKN4Ndfyj3if5i5XU/YMtv2uf7mSn9v1sX3xzfgLfp3Zqp3Zq30H7thLfdHcD+IBqg5CaoI8+ZULe9VoSauv12rzZTFQzvUrAx8QqE8lMKOfbYxHFtm3NxUz4m6s3CMkJEW9ubiwZCggwm81mBuiKorDkMwBLkBK0MTlcFAWePHmC9XqNpmkMmjLBDQAvXrywlPrFxYWBcipT6IbOQTBVKNSncAKBsJeJYqaAx+Ox7V8O8qnrAGBJ6/Pzc6xWKwPrLBhIQBtCMLUI10NISTBL9zgBKyc5AEnlTiYTU8vkCev5fG4TAMvlEk+ePDHIyjQ/fdfz+Rx3d3emNOE5BMCKoz48N3MVB/efifPFYoGmaWzMAYH0v/RLv4Tr62v8+I//OObzuek7CKSprSGwpV+cQHU2mx0V6uS5QP0GrwUm5JnqZsKbhT7zwqaE9hxjXm8P0/Wbzcb2i+lngnoAVgh1v9/bmOTjlU9M8XqixuRwOOBwONg2eZ2w8drn9cjJnd1uZ0oeesH5JAUnBTihxIKeTPDTBc+JAE5m8bjmKhMeX57HTNwDsAkarvuT2pgmliKRDhHe4LYVtsw0GrJsgb4aHeAVenfJY+xrNClg50qBy7p+Qu5GPdulOruZ/s4T32zUgIx9jXE4oHQtngSpb+BdxK82V7htpzgLWyzdEEPfqDfcm86E66Szu4kelWtRowBSxNjX2CfRtCAKdN6mCk0KeFKusOqGWHcDDHyLp2kBgCn4fr9sfCAFMPNEd+73DojwSVLnLXUrXpPiKaKOBQ5dgW1boVXNCyAFLtkGoUXhIkZBClyyQCYgCfMuSSq717lEuLJQiBuPlRFQmBicgdc+NQfzeFN74dsIV0f4pkMsg74uWouoENbXOoHGYpdQMF1KQtjX0YBvDA4h81zb8uyLpp4dFIDz1Oh6aKw7LjxG082+7hCrIMnKRh26/kPSwk5hcOl1ffpyG+VnJ/oP18q2e6CdgW12tRXtiXO9O506dwQF877XifA09wrEDRYDiIXviYj6xDkJ4SL6VLx+zrgbPeD0dtt+5RMNmlpXeP1g7qmf9EiE0oCzWLiAPp+A1CV4nayQ8eqfAuB5QVd5YiLduSwha4dAzrMOeOgCp6/cJilSnzo/tVP7tlp2udrZxwk/awpYWeDQOQgM9T0kz9eXIDCa8DuiTxbnBbOZBA+hL0pZKnQNmlh2MesLZ35cv12Cdv6/SqvfszoJR32zVDq/Ur+/IYiypFA1CYtO5sUtORb8nIFlHQuffeVjyP48TMUDAqld6NcPSGLauX5MiiIr6Jktx0q6LGpJR3fQG7fzMhngIJqTopD3y/Z4osz0NNmxtxtotk92XPQ7oBMgXbaMKlrY19Q/r5QervvB4Tndxk7tB9G+8MYcf/5LL/Gl95cfd1dO7dRO7dS+Z80596c+6rIppd/5nWzjI4NvQi62XGNBoEVIHGO0xCoLNjJlmqcx6Q9OKeHu7g7Pnj07SlxPJhNcX19bqpvAkAnz+XxuMPHq6uoIrhNOEugSDj9MlBLcErTt93tst1srillVlTmkCZmZRn/16hVms5mBZX6WKfGLiwsrBjmdTg1MEtRut1tMJhNLKtOHnCtLCFUJ5qkY4T60bWuFES8uLngy2PFiIczXr19bQU5C9Tz1vl6vAUhafLPZYDqdHiW1OaGw2WxMRZIn1DnWbduat5nFCXMNC8eJ58tkMrExLYrCwGu+TSZ9gb44JiE0AIOoBPGz2ezIBz+bzWxdTdPYMeJTBvf393aevv3227i+vrb95pjlkwif+tSnAPRFRnl+8fykw53XA53XhLz0rPOJCY4dFTVM0dP1zUkBXlsAjtaVF4jMr0t6vTebjU0qADCv90NFDY9lngwHcPRZ6ofYD+pY+AQIJ214veVwm9cQE+5chssRWtP/nW+HfaK6huccJ2B47KuqsntCrkr6pLXS9/oOKk9K16FyLTwiJv4Aj4iha0R1AocSnRWMFP+3OK5L3+KumeC+HWNW7NFGcXYPfIMmFrKtCKzjAC28gXQiahZo9Oq2BgC4iHU3wF0rT/hQXRLh8bXDYzQxWMHLKnWmTdnHEts4wNgfpBBkLNGkgCYVKF1rafEODqXrMPY14DkBIAn1sa8xC3u8Ucn+EybvuxKrbohdV2IUmg/A+pgcdrHCritx6AoMgoyxR7IEPBtT3q0m2+sYUMeAQ1cc6U8AoOkCRkWDaan+ft/CKwSX4+ew61Sh5BvUWsATziMNSvsjnGnhWGh82clBcElTirTgZmA57FvEwguA7aTYZyw9YhkE+CZZr6+7o89a0Umfep91SojB9+BUNRbJqwKkHxw9B9yR5sIlvqZQPQf0zgOHVhQsXUSsCnn9gVKDSWIC+3CIx8UauVyXhI+oUoQJdNfBClQemTeyz7IApOv6RHMsBQjH0ltxS4eElHr4f6T1AEx5kkNfFvZESoCX49KPg4IX8nEWq7TEO3QiAH1aW5PWebKbkxRHu+ccPIvn6VgRypvOISbAZQU6OSZ5MjaHZapycf4BJOqO/80E/0l1cmrffuvvawa/9TyF15uKcxC1hxZOTkmT36VqUEpN9uoTHl0HtE6+N5qQ3tXiy+a9wmvaOwRgNpavshJX96EGNjvpV/JAaiThHZwWshxKutlpgrzrJCEOyLyzL2SXhiOBvN0BdqNKXvvpRJPUdgKPQwEMJ0DRSuLae+1ToeA+SV8HlfSrbjRlrtC+KIFSk9sDTYI7TWB3SVLeHNvgZLwOrQDk8QgoKkmjJ84yDqUPozFQDoDioNBZJx3gtJCkermHuvxe3eWDgYzTaAA8fazakSD7PdwAg7UUtFyu5HgWpazT1f0EBYtoVoX0r1J3ufVDwXyhBT83lYz7ZCJjuNoAIciv0Sj/F9OFgOh8n9L/JmfkqZ3a97N98Q15ov1LpwKXp3Zqp/Zrqy2ynx2A36Gv/af62k8AOAfwkQH5w/aRwTcBFUEkwSnhMeEYVRxMMTMNfH19balNajsmkwkASWEzSUwtwng8NiUHAIOiACztnadA7+/vzaE8Go1s3YvFwuA0U7bb7RYpJSyXS4zHY0ynU0vYshAjATSB8WQywW63M8UEAHND030+m83gvbd0LUF1jBGvX7+24or0HrM/VF9wefrTuZ71eo3RaITxeHyUtM+BHxPpbHny3A62gtP5fG7ubCabuf9d1+HRo0domgaXl5cYj8e4vr5GSsmS7uzb5eWljTMbVR9Pnz41AEpfdlEUuLu7s3OEhVCpztjv9zg7O8N0OjVA+o1vfAOHw8EmH0IItk3C+vV6bYUwmQaeTqd2HjKRvFwucX9/bzCZ2pcvfelL+PSnP42nT5+aB/3s7MwmZLi/VMMQku/3e0vhDwYDPH78GKPRCKvVys57XhcE4vS2AzDVSF3XR09T8Lzma23b4uLiwq4vQBzpZVni8vLSxp6KGZ5DeUKfxV3zSQQm2QnKmTDP9SRM3RN8c+KKMJ7bJYBmWp1PcNBtD8hEAYuL5kl+qmc4McQJkRz0E2ZzgoqTLDxnOZGSu9I/6Y3AGxAQLMUpO0koK/Q217emtaMluAvRnaDC0LW4aSbYdSUq3yImh7tmjGlxsMKU0XkDugTGTH+HvE8KKdbtAIdYYtcJuH7PyaTdNBywaEcY+xoxeUzCQSC3a3CfREGy6EbYxgpvV7fo4LGNAwPnUgSyMx85ICnyM1+jdC06eAy10GWXBNIT1G/iAItuJEn1zmPg216XogqSQ1egiQH7rkB7CKYnGRe1FankOIxCg+g8Dl2BynfYu4QuevjQoY297mXbCEivQotRaBR6N2ijxy5WuG9GKF3EITZabFN/bQePFALSqJR0dskEmwBZA6MpyZPtLLDYJC5mf6XHQYGQWnNCu5gQDllBxsyz7evOko/+4CUdXngJUUZ1ZGeaFPchJICA19dRdSEKuhmoC/LovRXXJE+NUWCNd73TGlD1hyzbVR6hlkfUXUrH21fYnbwTKO61gwrqqVlJ3sFpH0OdjvqcHGzbKQCuVV1JcH0qEzhWryTZho9RE+y6TOFkwoKp+EzRYsU8dR8SHFD0EwoOPew26N2lI5BusJtAuxUYlKfFc/humps2HiWxXYKl2m0sPkpT+J23XK3C7UsnP9oqT+3UPqx9mNqob0w7I0tc65fnrJHLUtRMfOu/7f8nCE11nUxWl6WA1aqUzxVBYHTIksQ5MPecrUrHX0jqmeZyMgGGmPp9SNnPkYlyJ+sstL9eoW5VaMFMBd9Bf3fkBRos7R36vvnsURym0h82TjC40BfA7Br5bBH69DTXx4R8rg2JCvSDJtO7CKBV93nSxPdQ9qXVybHYAp36z5neDjqeXddD7chjlCfZ3XE/OHkR2F8mvlO/T3qvdfkxf/iICn9vfPPT89RO7XvW/q43BXx/5eUaTRdRhtMvz1M7tVP7O7+llP5x/uyc+1cB/EkA/1RKqdPXAoB/C8B3POv3kcE3vcsEUXVdG8Ql3CLIIvBarVYGJ5mipuaESW/C2uVyaV5gqkam0ykAGNDabrcGX5mQzZOk9P8SwOkgHqkbWLiw6zpL8TKVykQwANMoMJEcQjAPMSEs+8t07XQ6Pdr23d0dlsulgfKrqyucnZ3hs5/9rPWBoM57j4uLCwPHhNLz+RzX19dW9JOpXMJK9o3r4v7kRQbruj5KTPNrs9kYIMwLQb7xxhtomgbvv/++OdnPzs5wf39vjubZbGYJe/qvARxNiDBVz3XHGM21XpYlVquVgV0mlemqZrqe6X6qXLquw3a7tZQ4AHsigPCT48JUeF3XWC6XaNvWtj+dTk3lUlUV7u/vcX5+jouLC9zd3cE5h67rLB2/WCxQVRWurq7syYfBYGDnNSdHCGxZXLHrOpv8IPxfr9eWAmfSfb1eW9qaaXQWeeXEDCdruM88jiyEyacHOP58eoKaFnr46avnGOfaH05M8ThzP3me5E9HEESPRiPM53MrPsonJ7gcvwi9+Rmm+pl05/XKBDphO/vG9H5+D+F6eW1y3PL6Ap/UNg37vtCji+K6Tg4Zv5K0sxNILg7wPnbZpaCw2GHgW9wcJhj4DqNQi0M8tthiYMnr+PCPQUiSW4pdyv2ng0dAxMAL5H02aOCRLKE+9jXOCpnwmwVRGu1TiaiAexMHAsZDjU0cYBsrS30PvUDjVTe0IptUljSuUK1Kr2LZxsHR/h4Unt83I6ybAarQ4VG1wVqT5x2k0OR5ucWyHWHVDrBtKywPQ7RJUvCjIPtT+M5S4gPfolE43kaZIPAu2ZiUPiJ48a+XXvQpbdTjhoQ2BoQgqXL2u0SEKwokLwoNUWFI8jgVDr6Bwl/YH+W+iwK/u36f2VwXRcWhEDV5SQC7poevRwUK6WduVNWRkiTH3TGwhfegncbV/XYFkEekwgu8Dk4Dks50HPAE21E91gIv7DTrElBmwDgI/Ddg62AFKgH0nCd7TJ9A+uHPCeIWj6XXdPcDmN8mDS66Pq1O3Yd3ovKgbgZZApt6EK/9j1lqPaU+8Z0fmyxZ7RoZhxQgJoAMbKcIU5zYac1VKxQXj7uMRV9kVBfLXjfQHWV/Evq0+ZG6hK5wPW4f2h6cM+Ywj9n7D+D4qZ3aR2sfct7wPPRePdRer030eguCUcJXFrDtkM/IoIe/6EGvKpIMoDOFDU2RFwkYjXSCzvewGU5T2nqzIHiFA4Lq/LymtWOnzmkogA1Ao35vThBy4lInsyQU7oBRJbB5MBKAPC5ED8V9YCq78fJ+8tov/f+lwvVKkFDqEHPfY//0UFGgV6hAoHXbAVUAJlNJm1dDTaDrVwFgrInq/RY47CXhXqquLnXSz7IARpoCX0ryGuVQlq0GAvSrEbBpxBt+2IrjfFPo8VQ1jT1downtupXUPXUwMfaFLdtOx7hVb3iU7afU68Q+5MxL+c3z1E7tB9DevhhhNiiwOrR45/UaP/Zs/nF36dRO7dRO7Xvd/gkAv5nQGwBSSp1z7o8C+MsA/pffyUo/MvheLBYGrZiqJdADYFCN6WPqKgi26fbe7/domsaA7/39vUG8xWKBr33ta+aBHo/H9h7BNQsg5gUoCb622635ognhqZ1gGpbJVH4HYElhQAA906RMjhJ0MnXOInpUYVA9QkDIbaeUcH19bRDu/v4eV1dXVpRwPB5ju93i8ePHSClhu91awU7vPX7oh37I0tBMoB8OBwOczjksFgsMh0OD4dwu/dn0bDMdOxqN8OrVK6zXa9OVMJ3Ldd7f36MoCozHY4xGI0s/Mw3MtDk94gTfhLmr1Qo3NzdHyV7uG/eDcJbHk+PJ82s+n2O321nSnftelqWl7An6x+MxJpOJwU9OghDq8ufcU84JiouLC9Oi5KoNTkDwPB4OhxgOh3YcAeDy8hKXl5dYr9fmuOdYLxYLO9aEwLvdzvzf1ADxHM+LWfL8preeTxkQlAPAW2+9ZRNRk8nEEt5VVaGua1Op8BoAJDW9XC4xGo0wHA7teuH5S7ide+3zcQZgxWx5LRDWE9jnrvrdboe7uzt7wgGQCbSqqixVzu0RuA+HQzve+ZiwHQ4Hm+DKi9tyYoBPDlDB8kltQ8fii60WffSIiGhQSL47RUR4zNxOIDHEUW3FGpNHQEKlihQAqHyHQwwofUDhOnToCzEeYmEFNaXAZBIvdXIoFegCQInO1CClrvssbDH2co5FTWR7Fw1Mx+SxTx51KrDuZIKEWpGQ/bFZug6rbig+71ihdB023QAeSbQsCscn/qDJ8NZ82wCwRYVVO8Q3Vpc4dAFvTRfwLmLZjtAmSW6PQoMmeby3PcPiMETdFtgeSuxHBYpJhEdC4xJGobG0faM0chga+EFCoVRyXPQqk5gcJqFG5Vsb7yYFRDjMyj0G+vo4HGRf4IHREHFYIhUe3SgglgJRu4ECRqfaDYe+WKNHDxk1/WjFHYPrQa0WZhTYy8SzfCwFZ8Dblk0QD7beQwTOeksJG3AFeuiaF4/MEsTHieUMOGfqE/GuCpglkLUUte6Lgf+sWaKZ0DcHZ9SeRJinx4o4yoESoOyZgIbC62TFJJPPxobryrYLNSqgw9/SbW0TAPlYRPGWu5TgO1gy3XPSAgrAMx2KuMzFx83U91HBzmzZfhx0jLrMXc7l3IPjFJzAQueQcJyuz5PdkliXiQArGkoNT/wg7D+1U/uozbgjW9IXPCfUCLmdJq31/XyyiuA4clmuzKN3qCgkTwrSzRNN+O0FzIYkmg4WjNT7lIDYDHwH3iCcwnGXJadb0ZE4DxQDBe36/2FMjwPan6y/zgMD9VOXAwHqkyEwHQjY3R0EAEe9H4egfUfmFy96iB5Uu+J1UDoInHZOU9L0YEP2sY1A5YDxWJzcdH+HAnCF3FeHQ/l3NRAAXpTyGgDs97L+opDCmgnAeif7PAnAIMj+jSYyLhcKvnclcFC9zO7QT2akJGC7axXMtwCK/hxJSd5rW+l7p4C8a/tJTM6iZqeZy35zpA/cQE/t1L6/zTmHL7wxx899/RZfen95At+ndmqn9muxFQC+AOAXH7z+BXwXz4h+ZPD9MIFK+MnXCFZDCLi7u8OLFy9Q1zWur68BwFKdBFssbJknjw+HA9brNd58800ryFeWpSWgCYGZUM2d24R5TAbnRfGKosB8PrfkK7UehIgsEnh2dmbAdbVambO4LEvc3d0dOa2Z2t1utwYvc2cxAHOdE0KOx2Mr6snU6mg0wsuXL1EUBa6urtA0DT7zmc8Y4L69vbXE9HA4xH6/x2KxwGQysXR0XvwRgIH5uq4xmUwwnU6PHNDn5+dIKRl43e12uL6+tmKNLFBJTch+vzcfOxPK5+fnAGDFHbm/TKAz/cvkMXUgBL8EroTBTAmzCCUBK8fs8vLSJhE42UFwygkZJuQJhAnZqW958uQJdrsdbm5usNlsTOnC849ueILd0WhkEJoAmgVBeU5zMoPqHupPcs0PAHN2M9HMcaRPndfVcrm0lDrT7k3TYDwe2+QOxx0QkMwJh+VyaUoePhHBcyCEgJcvX9ox4MQIJwyo6+G5TQjNa5uN2+f1Q2jOMeJTE23bYrPZ2BMZ/AohWKFT7sNgMLD95djy2qb+JS+2yYkhaloI+jlWdO3nRW4/iS2m3rcNSGK5RA+2vZNijh2cJJ+TpLEBWEFJ7yKuwhoD32LdDnBeyfHfdQKW6c/uIInnXaww8K1tt9TkcxODFIJ00XQngCS8h74xt7h3jXq3C3hESZJDoPdBk90D32Ic+smYoW8QNMV2VmwxdA0W3diS4LJe9XBnihMWpmSBzG2ssG4rvLifIYSIQeiwqEfyXiOJ9lKT2e/fztGsK/nV2zq0ZwGXoy2Gmo4/RNWgwKF0EU3yKF1Eqd7uJnkUem4XQfa98J1pWga+/dAAWRMLhBBx6Vtgf4BrIlyI8I1D8sHgdFc5YTwNhNcA8C0EPChNNfcz8IFt+brrYQZ1I/nPnlAnGTjy+3j8vyKEpAqv3YPH5ekJt8foY+o/4gHXwtLnAk7FeZ33BckBpUfMH/V1ri/GmQFV06IwrZ5SlnrO3tOn5uUUTpKuTvxKcJ1AaD5NwcCni8m0wrI/2c5m++4UINtERLYsVSe2Dvb1CMDjaJyTgidLrPsM8HNiAFAdTOiLjMZjLYpMgkRJeHN87T3tM+F36tPs/SMkzsKk9oSA/nzkMTeIDqSkDvDk4Jt8wE7t1L51s9Mq5f/QFxJ6qJ1PsFkhxuyzfI8FGFW1lDku9N+q1iAo9k4ANSF1KDQ9rAniVl3TTCE7r+lj9lET0wTyVKo4J55rKExPED83U9e1/j+Z8/0Emz5hY0nywaBPR3svQL4o+tR7Vcq6fZEVfewn+WRMVA8SQj8WpabGu0ZeiBFIrSSua3V57w6y31SRpCQu8LoBDo38ezIWbYkPAuhjlKR75yR5vdKC7DH29/pDLeC7UZBf6oRBvZOJAedBFZZNengvMJ96E6pbWFQ0KhA3BU5/3+IXT5GkswwfON2ySd1TO7UfRPvCGzP83Ndv8eWT5/vUTu3Ufm22fxfAv+Oc+yyAv6qv/SYA/7y+9x21b6u4ZV3XBuwIsmezmYHpuq5xe3uLV69eWQE9pkiZeF2tVpYubprGFBjL5RK3t7cGf8/Pzw02suAhndYsAMjkeUoJi8XCVAeEfoAUmKRzmXCTae+u6zCZTEy9kCelCeGePHmCEALOz89RFAVWqxXu7u4MqBMK02U9Go1sn3e7HX7lV34Fz58/x2c+8xn8/M//PD796U8jxojPfvazuL+/N9jOpKxzDr/8y7+M8/Nz08ksFguwQCThOhPiZ2dnWK1WBoMBAflMWOeQfjwe4+bmxiYpFosFXr9+bQU0mQi+uLgw6Eh4+OjRI4OcuUeaQBeAjT3XRbUF/50ninPNRq46IRAlyKT//HA44OLiArvdznQ3TOLz3OQxfOja3u12dg4yPU+ovdvtrC88puPx2FQuPAfZP05aAKJ1efTokb1HEE+VCos0Mumew968SCsngMqytMKc1P3QW991HZbLpTm9OYaTyQSvX7821cl2u7WJiO12a8eSkzb0fBNU58oYQmQe84fOeACWes8LxLKIJot18rocj8eWBudExHQ6tYQ6QT2vVfaDyqDBYGCpbTrw85oCfIKDKXAWVeVYf5KLWwK93iRA0l1D16C0JLgUsvQuYuzkvA1ZXHPoOsCJG7wplrgothgXNbZthVpT3lKEsUaDgDaKRiUmj22scOblmusewHdA0toE0ttYYeAFdgPQ5HmBJgWs4ggB0ZzW21hpPyMCBFqP/QHbOLB98gq0JUVeqBM7mPKECfHSCao/D1vsk5x3b5Z3uLxY4y/9tS8AncOvTEcorvVR7wR0owgEILkE13iUO4cYgFQk1GWJ290Yl4OtpNFdX9jy+JhIAUlEoAzRXhP1Sy3AOwJt9KhjYdoU71Kvb4HHNjmktoM/aOG0A1R34uE6+Ss80jkNtW+oA9vnrpsE+EY82y4BSRUdvulMN0JvtEsANAXs2uyY5tqQNkkf0Duij6AtVM2i6fLkxBnumq5PgEfN0BGME8A6SX3btmMCwjH0jsEdQd9Y9GoUFt20p9KzXXBIH8wPZPAbWpzSAHMEHK8X58xtbvtgpCT1Y0OPufUhWVpalpHXLCmdF7XMgYrHkfvc3OK6XgPb2X54LuuysXwQN3dtPJrsANAX4yQwKrz6giUZm4K8nzvKAXzzYpU6bpb6dpKYdIRMp3Zq30b7AG88OoVUdWGFDqGgNClo1hkrgnGmn8tCl4tyHqfYrwtOQDGcANwuCuQNqiKpFd7uDwJm61aKQHKC0CUB453PdCJBVCTOyXsxAsOBFIY0JQtUj1QB6z2wU/A9UMhLH7kn+C2A+USS1/QwOSdp7ASB0A4yDr6QvrU62RpVWVJCQHkIMh5MgBeFAOj1Wva/Vuf2YQfsdgKTRxPxcjOdXlXAxbkU8Tw00pfLC+ljB6BOkrL2SQD6oQaWO/RFSh1QbqWvg0o0KEUFTOfA0Ik2Zb+XVLnXP2sHpYwxi122nRbTVOANp/2ptdCnTnwAPfTWCYtk8DvZlyW9T4HvU/sY2hfV830qcHlqp3Zqv0bbPwfgBYB/FsAb+tpzAH8YwL/2na70I4NvQkEWDGQS+ubmxiD2YrEwnzK9yISO1H0w5UrA9jA9e3t7i81mg7fffhsALPlMCEjlA+EdCxcOh0PTehDGA7DEKP3VhNpUOxBYEtBRMXF1dWXAlttlKpXQlHoLfjVNg4uLi6MkeYwRv/Irv2Kvvfnmm7i/v8fFxYUB+ru7O1xeXuK9994z4O29x6NHj0zHsVqtLPlMWEkYyGKDOei7uroyqDwajXA4HHB/f2+foa4jhIDb21tLbjMNnxcqHI/HVvSTievNZmOfoQqDwJZ9o8qFapbr62tzbVOfUpalFfkcDodH3nEek7IsDYYy+c5ziecIwSdBs3MO6/Uaz549w+PHj22C4v7+HpeXl0dPDRwOB1xfXxucBcQ5H0LAs2fP8OLFC9s/JqQB2FMGHJftdmsJ+f1+b08f8PxgYp9PJHBs8xT4arWypxOogaFn/OLi4iglzfOT48inIaglYiqaE0fj8dg0MbPZzBQzBN7UyXD8ch0Kt8unIzgJQ+DOCQ+65HnecZIKEGj+6NEjA9o8ZhxPADYZwD4wbZ5PdHACJgfd3GZd13Y9f5Kbd9HS2yzoOPEHSxRPtGDkxNUoXURMDmPfYqjUrQQw8wWaFDFxC/xqdYd3wmP88vYKs+pgao7CdwgpipYjebQsjhkDSt/p6/1fhk2UdDgA06SUWSHSyrW478aW7s4bIfq2q+CRMPYHUao8+MtzGytL41IbQr0K0+mS9O4w8QfMoRNZrsWnii0+9ecS7j4XMLgvDc41E4d2EhALIFYJLjrlJ0kUI9sCN/dTTKoaV8ONHgMZy8JFHQvRxxTIADikoOcoNLgs5HOrbohtrFAkKTY60IKiwYkzvXItxi4h7fea1lYg2yVLOgNArBw0yN97pB3QFf14OQYMuY5WE7+FP04pZyDXVB5ZchrIIKl1QCYMXSsub4PfGVSVH2T90Uvq90jvoXoArlsKSkpa2sUkvmgNAwIKeDVdnnKgzO77HowfJSV1cOgqJ+CW7SLbZ+lvysaQY+8SxGPuYHD+CEL7fh8s3U7PbLYuA/Oaqk7OwemlkDQpnoK62AsvSWkC8Hw9EBDtu2iw2kH3KR+fh6Dcjl+SACR0AuMh4dFwZHLZ8cn78E1UJgbs1SfPJP2pndp30z78FNKYMpO/QR/fCJpEziaCJHnMlLLrJ97oNuL1CmTAXCFqo+Jv1/Z+6Vy3kXWlh6q88aUHoJX/BoDUQ20AfZFGn4Frp5N2TopKVoVAZ0LrpOTcOfF3J8gEFtPYLhxv18Ylv941DZ0XgnQPxtYHLerJmxX6cbSimQVQVplrXCccnQO6ADT69Gp9kDS4U9DskqbqYwaoOQa6bvZN/9YS8O4EpkcA0EQ6J/cQj8eeY3607/3YO+7T0XmWgBP5PrWPoX3xjTMAwJfeX5qK9NRO7dRO7ddKSylFCOT+w865ub72Xc/0fWTwTTBH6EU/NyDQmpqIvDAfASBbrqYYDAZYLpfoug6LxQKAwMabmxuDiARuBFmz2cySsUx3L5dLLJdLK45H1QPh6XvvvYf5fG4wlrA5V4nMZjNL4FJ5wpQ1AffhcLDCmwSpuSd7t9thNpsdgdH5fI7tdotHjx7h9evXKIrC0uLvvfcehsOhFWHkJMDt7a0lyQn+9vu9wXYqHAhPN5uN6UAI12OMODs7Mzc6C4zO53O8fPkSq9XKwP4777yDd999F2dnZ7i4uDCIzuNFD3q+r4TbfC8Hkhxn9p0aEkJe+pnphCaIn06n9uQAHePT6dSeMuA5COAD/mduZ7FY4HA4YDqd2rl2f39vY1NVFebzuRU7ZVqdXmwm4JkaZyHF8/NzvH79GrPZzNLiAGyyYT6f25MJdNZXVWXaE6bOWViVsDmEgOVyibOzMzuW9MRfXFyYO5y+8XyS4dGjR0gp4eXLl2jbFufn5zbOPGcJ1+lOp8aFEza5l59PbORPVxDS87jn9wL2kxoeTn5xe9SeEIRPp1O7zpgA56RHl4FPThTwOuV1zYKVTN2zOCzHltvNE+u5ouWT2iTZnFC6Vp3aoiEZK/geOgGyY9/isXeYehnvn37rJ+AGA7iqwv/rb/5H+PHBr+KXBs/wn1+/ibNqj1UzwCIMMQoNov4Pd0yiNKljgbGv+4KXTl3f6I5gdpMCFu1IilV6LaTqWyzboek+YnIofLSilE0scVtP0JQBZ8UWh6609VHXcogluuRxVmwVHDcIiJbsBoA6BczCTsdAzpNzX+OtMMbw9R7hU1MkD0xedGhHDt3Aw7VO2MGGBRgV9nYA4NGECu8VZ1iOh3hjtkThOrQpYBgamxCgA9y7iIFCxYFv8bRcYuAbrLUwZ0wObQrokoOPBWLyaJLHuhvgrNji9/2X/1vwj+cGQl2SwoXeeUkd+gfQAkAKCsDJejrlN0GctaGOcMnJ8Sy9FXRMXtZtAWd6pAuBCgnO1CdJJzXE6e2QCodUaqFp+r6bDs47sdtqUcqUciCtKXOm0GOSRDYAFJJq5/oM4mp/E45BakquL/ioqzBA3wkMckkAe3QBsXwIvQV8JO/g26jQGhoWdVpINAKxh/6uiQZ3H6pUqFehniQHK9aMw7veN069ia4z0WFs48Bgp3jILfWuUJtp9VS4PrHOFGo2NlbYkkUtVUtikwcd39d/e+mvO6JD+OA+MTGe7CAcMaPkPoDVT+3UvrtGDUhVSrHJ8RCYTuScGw0lEVxSgeGlKGRyMutbOiB1kjZOkES2h9z0j6BoBLa1FLysWmDYyTleNwKT6xZootwrmeqOTlLOhVLU2PVPR/C6YZo8JkmSI6mmJIgXezaVbgRVkVQDcWUPSmAyEgBcVOhnrpJA6fFI7tWlKk+6KOqUGIGSXusAU7rUdZ/yhk4C8CtC9mc4lnWNJwKrQyGvhSB9GZRA9PJVVMBVIenu2xtguRSX93gqEwh3lRS8dCsgbmR8UyPjsD3IWE5qfS0C7ZlA/ErX4XSMUjqeuEAANmtgu5Xt7GsdG93fGDWJr8nvsuz1M5rt1ju4vuRgB83uad+b0/bUTu2jtM89nSJ4h7ttg5fLA56dDT/uLp3aqZ3aqX3Pm3PuMYAfBZCcc7+YUrr+btb3balO6IQGcFQIkAUAWYSP6VLqCACY+5kKhLu7O9zc3GA6neLq6grb7RZ3d3eYTCZ48eIFyrLEW2+9ZcUKCdQJp/kzNRRFUZh/mEAegKlRchcwk7IE63QRE8qxr6vVynQOhO+ElFVVWUKX2ojD4WD9AQQIM0VNLcP19TXW6zXW6zUuLy8tCf3mm29aupdFCa+vr3F/f2/rePbsGa6vr/HDP/zDWK/XlpBmH/k5Jq3pyQYEHL7zzjuWnmaBzZQSvvKVr+DX//pfj+l0asqK1Wp1pDNhIp+qkcFggNVqZR5zQIqETqdTHA6HIw85HdODwQBnZ2cGMYuiwKtXr2wsOX6Hw8HS0QCsyGPXdeazzpO+dD0TzvKpg/1+j9VqdaRW4YTB2dmZTVjc3NyYDoZQu+s6nJ2dwTlnkzH0cXNMmf7nxAThN8EuoTGfluATBdR4cF/qujaIfnFxYU8XMJnNa4DnLgBzdhNw8ykMTkqw4Ck9+ZxA4tjnSX6mp3kN8bwmdOZ4AJLaZrogP9/pas+PIYE4dUIATNvCVPtyubRziJMB/KJXnseY2yLQ5zWcq1Q4IZZrej6JrUni5OzU271Kcl4/K3aY+APO/UGc05DCkxPn8bs+9VPwei37WYDT4//f/vF/AHG5xO/8+V/F0+kK+65A0wXsuxK7rsQoaJFSpWNMdQdERK0SKBqSZPDbu4S2C7itx/iV1YWhhPPhDj80uUPhOiuSOfQNBgqng4+4DRNs2gHeO1zAu4RZkPuETxGMMEc4HKL87hmoHoRwXfrlTXsyU8f32AG/7VO/AfiNkhyO/O3oHHwNYAaEGj1IjRri20NTyQGHOEIzKzAqGzwZr1C3Ar6pLIla8HMUOswLeSqp9FKUc69KlyYFbDq9zl3SdHiHqEUpf2r8FfwHT38jYlVIktr3ANjVEa7Qf3cCF2Plpc/JIQ/RJy/DFQtJhsekChKF0a5LCE2Eq/Uvep3Q5XspRsD3n3HI03UKZLXIpa87S5A79auGQ4dUeqQqiMKk6RALr2AYpjVxmspLZbAkdKK/1anShYdKlQa9oiO7KB5A2VR4c5kbmI5JxkM93rK+BEd1R+iBe74+84XHPtHM/QSEsTAZDTAJ3WtNYul7OGzJeGRALAkso1Kk1W20st1Y9pMBefI6BQd/6GwSgrDfhiT162d/WSgzZdqY/gPq+eatNen+WjI82z/AQLkjxNNtprqTc0NdvLI/J/R9at+rlie5vYDbohBASogcNC3N1HJQ/UnQ89nHDI461fe4Y4VPSloUspX1hNC/xlS3KVJ0W3zKhJM/SeG3c/01wOuFQDYl6VtZSJ8qncTlfbCqBH4PK2AyVf1Jth04Abll1atLgheoTsDPNLoj3HbSD2Te8Xxs2QpNcrtSZx29vhakn4OB1Jqo9RofjgRoL1eA0z6NR6qN0YLk5QEIe9mHqDdCqmNKB7RB4HmMPawvC1HBDIcKzDkZV8p2Dgfpe9LxRVKnu+4rx5vp9m92P3rIuU/A+9Q+hjYsA37k8QS/9HKNLz1fnMD3qZ3aqX3fmnPuXwDwvwXwb6SUfr++5gD8bwD8PgAXAP5jAP/TlNIvZJ8bAPgjAP57AEYA/kMA/5OU0rsfYZsTAP8mgN+D/q+Ozjn3fwHwT6eUtt/JvnxbiW+qDAihCMqYlr69vTXYRJXBZDIB0KcvCaxZRHKxWODtt9/Gzc0NvPd499138cM//MPm1maqczQaGZxk8papaH4xHf1QrwDAUtsEjOPxGOfn5+aOvrm5wWg0Mq0JQd92u0Vd1+bFHo1G2G63poxg6nW5XJrbmK3rOtzd3VlymRMEu93OHNxVVZl3+/r6GhcXF6iqCuv12tzMeTHA8/NzA5nee0vtskglALx+/Rrn5+dWoHOz2Zgu4/Hjx1gul/jlX/5lrNdr/OzP/ix+9Ed/FG+++aY5owle8wkGwu/9fm8FN+nVvru7AwCD5UxR5+5nwvnBYIDLy0tbFwE3x5TAksl2alJSSuanZrKZjZMvPE8BAcPT6dQUJ+v1GiklK+A5n8+x2Wzs3OF+sygj1//48WMsFgtUVYXVaoXNZmPHmGNKVzYTynwqAZDJi8FgYJMvuat9Op0aEGYRSp7fhP6EwCwQulzKUx4siPrQx83JJapKqMUh9KdWBYCNNY9tVVXYbrc2kUCFUF6ok5Cb68nd9BwzFtXk5ATT3Uzpp5TM1c2Cnkz2c/zya4jnFmE4r39Cbhbg5LHc7/c2ifVJbixOCcC0Jw2CpcADEkoHXPoKv+OHfhJhPrE/qF1RSCoOQCoC/OUZ/tSPA//V//hd/Ke3P4RtXaLwEZVvESuHyrfwqvTwLmLXlb1mRP3UXr3c3iXE5HCIBZbNELu6RBflWBU+ohkFTErRqUzDQZLemRPcQxLTm26AwnUIiJoO9zgkjy558WxDHeVJ9jkmJ0UzXUSJDq/aGc6rLS71NPlHPvWbUXz6TWwuBwgHoB0ChzOP/aWHbxVq6ldygG+ZopavYi/FAzsP3KzHGBQtzqqdOLyDXD8D38hEQzjYRMFNPcWL/QxPhmt8ZvQapevQJSfQGwl1LNCpy+MPvfEz+N3/0D+F7kmJsG95oIVVdAmp8HD61H0sJM1MfUgKDmj7P+apB5GgvEMsCXwlJS3gU3Qurr/d6meZfNP3YjwCQqnwCkQTkkvHQBcAH7t3CQiHrl9XigbMCbxZtI26FsJS9sMlAG2fODYI3SX4GPukOVPrmuL2TGP7/n0kBw/fp7LZVBVCVUqeqKbWxNedwHrd9pFiRS4EuC726/WSkyas/0ABSU1uG/gPHq4VvUvyWUq7TVogskdSlj6P/T46jlF6UNQypQ8B3Lr+7DgbmA/ZcQD68eW4A5n3vYfe+TacSPCFtQWvwB6ndmrfVkvIz6kPYZDJSUJ6NJLfZ8OhnJTDgQDZAgpJoY5rBaFMgTvVaQS5X6EhzCZwdUCpJ3vXie87pR5WJ+gTG1ESy3ACYZ2XfhFQdwTk/Mou0IReFxKcJKr5OhUl2x2w2cp+OidgfzDotSNR19nqBGTX9dsm8G07AFEgtncyHk3TryvpxFkTJQnOJ+qOIHLoxw4O2NUCq9son3MeGGjKPhTAYChJ9QSB/4ca2O21f15fa3sgXQT5nCtkEmLfyL2/Uy2Kh/S/a8X73WlFZxdEc1Ip+K+1qCX1Ld4rEE/9eJhu5sPOrJTPe57aqX0s7YtvzPFLL9f48vMV/us/9vTj7s6pndqp/RpszrnfAIHb//mDt/5XAP7nAP4xAL8E4A8A+PPOuR9NKa10mX8dwH8TwO8CcANxc/9/nHM/kVJ68JflB9ofBfD36Od/Vl/7zQD+mK7nf/yd7M9HBt9M9RI+ETRSN0IvL5UouZoAEGDG5ZjWLMsS+/0ef/Nv/k1cXV2h6zrsdjv86q/+qq1vOp0aDAZg3mJqGeg2ZhKUehGmgc/Pzw0Ktm1rCVqC46qqMJlMzKHNQpUsoBdCMBjHFC/dy9S0XF9fW0HPV69emQKEqeHPfOYzeOeddyxhTvXJfr830Lndbs3VTA8510Fgv16vDc6zwCjHhhAZgKWqU0pWcNA5h6dPn6Kua7x69QrD4RB//I//cXz+85/Hj//4j6NtWyuyyYKXdV3beCwWC/OscwIAkAkOAkYCT2pkdrsd6rrGfD63c2cwGOCtt97C48ePDYxTf8LJBfqded5wEqVtWxtboFesnJ2doa5rg6NMUPMY8smAFy9eYL/f46233sL19TUWi4UlmwlyD4cDbm9v7bxdrVY4OzvDfr/HdDrFer22c5+TKIPBwPQhuYIl97Dn/eWyVH/kx5VKllwTwiKsAOz7zc0NLi4uLDnNJxLyopM8f6kdor+ex4SqFabIqQnhOcjE/4fpiljQM78eOEHBCR6eF9yfhz56TqLxWhwMBva0BdfFpzjYf54XTNp3XWfaEyphmJbnZz+JLSYPuAgPmOJk6BstHhkQXQsP4NwX+J0/8lsQzsZw41G/gkGFNChNU+HXe4TLC/xLj/8S/kAs8JcOvw6D0KKOBe4OY1wMtmii6EmYUv5gnxxaTTV38Ch9hzdGS0lE6/Jt9Fo0U9ZxiIWpP3axwqHLfmX5DpWXxHpw0SD/PpaITNYBgJcUtYD+TgtmBgQUmPka/8gP/WYAQPH2m2jevEQ3ENAdDgSdOFKExBKici16EO4i4BrAN0Dae2zvRng3ehzmBcZljX2Q+0kVWhQuYhdKVF7AwV09xvVuijoWOC+22MYKm3aA83KHCAePhHVX4Z948pfwe37H/wjdrERyTtPRgO86RD7WnQAgwbUJBR3YmcM5lT1AFo2JQ1d5c1SzUZeRPAT4agpYIHOEU9CdvJeUNz9nDmtNRgeBvXBZejiD4JYWzyC3g9fE+gdTwNb3JioAhyWsqSThdxclSe27jMjHZHDcHOb2SHzS1LykL8WHzR3rU/WW5gYEcB8pWqLsr37GPOidKGM4RjZeVJHQZR68bSMH0rJfHD9nhTpdEthjKpPgxPOezfnJ+AigT2U49ovL6dKPb+ATBEfDDof+NStM2b9p/zYXOmHdA5UKNBUPzwKmWqz0ZKU6te+g8bTKs8hHrDJBwOZwoOB7ICfjYCBFEn0HpFZSzy0EeA4KhdOu110Ucq9BGwV6x6jFGH1/H2mjJKijfk8JqIKoONpOIC2cTC6HILOmet9By/uRak0irxOF2EwgE4A7TZbXqgHZ7STR3LSSoK70SxVU8qgKpB8u9iNHuJ90f1Lq/d9dJ+svOmDUyHKtJsBbLQgJ6FMkScco6OArSN7rRECrHvQiAGHS+7irobwGhc11LUUqCb4TBJyzDgKT5C4IiD800ifX6SybU/AdZT11DVOzpKiJ9wg0+34ygOA7Qr9iD74/IGD6sNdO7dQ+nvaFN+b493/+fXzp/e9ae3tqp3Zqp/aB5pybAvgTAP5JCNjm6w7A7wfwr6SU/pS+9nsBvATw3wfwbzvnzgD8DwD87pTSz+gy/yiAXwXw9wH4c99i8/8QgH84pfQfZa/9GefcDsCfxPcbfJ/aqZ3aqZ3aqZ3aqZ3aqZ3aqf3t1I5zuen4FdLwshQOOhoCkzHEFX3oi1G2CejUR20TTUkT2VAgmm2CKhLX9MuzM5yIbAmxNQVNh3aEAGE+MZOyJHmCTtIplM2LSaZ+Qk3AvDuGy4da/r0fZH2Oul1dN7fjNPWckkJtfS0puA90ZlMF0onHO3Ywfzj3IennfABCJX3kZ7pOE+WuPxZFCQwgoJ3+89FYPlMvBZq3TT+mKWri3AE7AFUSrzogf8lyvJtWjmdZynHYt+oq91L4MyWg0tlqjz41z4nKBJuEzesSHJ9bp3ZqH3/74psSKvvS8xP4PrVTO7WP1GYPCuEeUkqHb7YwgP8DgP9vSulnnHN/IHv9MwCeAfgP+EJK6eCc+wsAfgrAvw3gJyBVU/Jl3nfO/Q1d5luB7zEEpD9sr/S976h9ZPBNrcBgMDCfLgvTMQHLAnMpJUueMjkLAM+ePbMUMQvSjcdjLBYLK3R4d3dniePJZILPf/7zuLi4OCp6B4iCZDKZYDQaWVKU/aReg33Kk795kpZ6BCZti6LAZDLBer02P/Z+v7figABMp7BarbBYLLBcLnF3d2dFBg+Hg6Whr66u8Pbbb9s+vn792goMXl1dYT6fYz6fm5qBxS+bpsFwODS9RVEUuLi4gHMOMUbc3d1ht9thPB5jOp1iOp2aggXok8ht2+IrX/kKfu7nfg4/8iM/gvfffx8///M/j7Is8Rf/4l/Ej/3Yj+Gnf/qnAcB0JDc3N3j69Kml8amqAGB9YfKZCXaOPRPXXdeZuibGaInh/X5vBUq995hOp+a7ZsFC6jfoXb+7u7P1U2/BY8cE9eFwMFUGfe/0a49GIxRFgaqqcHFxgbqucXt7i+vra0tX83hRscK0/P39Pc7Pz03N0batJa7Zn9FoZAn1qqosCQ1IwpvO7dFodJTiz4sx8kkDqmtYgJKqFm6XiXSeh9xfqj+oN6GnnmPgnLN10XmfF7ukN59j4L3HarWy9D71JBxr7neuE8p93HxagIqX0WhkDm9qczh+D13mo9HoSCG02WxsWV7H1O/kmpm8GOZut8NyuTx6OuCT1jo4IHlEJHTOY+gShq6R4pYQhca59/iHf/g3w1+dwQ0HSINK01dAHJRIpUesAnwrLmffdfjt/+DvRjsf4um/8hxfuX6E+XiPQRC9SUwe5aBDE0VrYqlThrV8VN2IPsmQHErf4WqwwcD3kc9n1RJRFSUskCkFK0WPMvAtCt8haIy0dJ0WsOz/HTWVlbu+PRL2KFH6FodY4qLY4H/x2d+C8LlPS3/Oxmjm+oRSB6SRBsAKSXIXOyhIEM0J9L3kNentgWIrupC4L7HvHN5vAgYDubZCiBgUHYrQIWWR2kNTYF+XiHOHb5SXKH2H59s5BtMWTfKYFjXOyx3++f/178PwcYdQx6O/vc13bSk+ASGu6eA69XEHZ+5mSxknSYb7Olo6Oznxmyff/wxoyrfwYPFENKK1cIjqapbH8BN9uaa8yDua9a+NQOGtCKYoUwQypELHl9Ah038w2czQnW8U4NDzHbPUudd91BQy0+IAkJwz1Qla2Yej+OhDNYvvxy0FZ0lvF2VbvmXSOQMoQJ+SDt62K8cgHiWrXYIm89lXOZy2TXc8rq7Nrq9Oj4nX11MSDQCgnvJo6X7XdMK+gpwv5kLPzyUeo+y45QlwS6FnyUdzocf+uCdVxtg5wO14ZJCJ+xPtqYJTO7XvtOlZLT+lmKk8IBB5PBbIenUJbDug3gG7pSSH71ei1aicpJdb9I7ug6o0YpZmZgp5vZNfAPpWX0QyyH2uVa1IUapvXL93SQpjAv010nXHSWPv5b4bNIXO4poJAp4L3z9FcajlvVCqPsRLqp3XWlkAo1J+ZiHHbNRMWdJCkvBF2etSkhOAX9cCo1kgM0EKRbaxLwpaVsDkQva/aQWU153qRQjuvUDuoabYSy/LXrXAaAosNsDdQrqmdSykUGgHNLUUqRwOgWoMpKrXn7Q1sN3LfkzG8jTS81tguZZjMp2oMmYg+3vYyler6X0WxmwV1uvZFDlKCbLulE74+9Q+9vaFNwR8f/1mg82hxWRwyjKe2qmd2t+yPXRr/0EA//KHLeic+10A/isAfsOHvP1Mvz8E0y8BfDpbpk4p3X3IMs/wrdtfAfAHnXO/J6W01z6NIF7xv/IRPv+h7SPfJenF3mw2VuSQQJAqDYKspmkwmUwMqgHAW2+9BUB0CtvtFqvVysAugSEVETc3N0gp4Rvf+Abm8zlms5mBbxYDHI1GaNsWNzc35r2mhoWFAAFYcT16oPPCfizo1zSNaVp2u51BQ+oZqEMBRPmyXC6x2WyseODhcMCrV6/Qti222y0+/Wk55kVRmFKCGhKqIKiXoPOb/mvCxtwZTbjvvcft7a3pIA6HA+7v79F1HQaDga2zbVtcXl4ihIAvf/nL2O/3ePXqFZxz+Imf+Ak8f/4cP/mTP4nPf/7zmM1muL6+xng8xqtXrwxartdrADLB8Pbbb2O73eLq6sqgKrUZ9/f3BmMJmDlm1FCs12sDlKvVCi9evEBVVdhsNjg/P8fjx48NFi8Wi6MCjAStPK+o76BaA8CRjiaHzbPZDABwe3tr2pzLy0tze1PTMZlMMJ1OMRgM4JzD+fn50TlGOE4lDcEtx5vHlV5s9qlpGoPSdHwTlC8WC4PKLLxJPQnVJvnkQl64E4BdB9R/UPvjvTe4TXUJwTDVQ5zQ4PIcB6p/CMg5uZWDcU4m8GfCdmpbOGHF41UUhalchsOh3Q94brG/hPS5J5wTbBxf6lP4cwjBFD+51oQFTD/JqpOtFkcc+j4xdRXWmPk9noUDLn2Bkavgx2O44QDxYgakhDiS67AbFvL3tXemx3DNGIcnE7gE/LYnfx3/x/u/G+v9AGtdv3MJ0/KAIkQcYq4k0W8podN/eJcwCg1icpiEFuNQ66JSrLJJAYtuhJh6gC2fi0fQG5ACnoAA7yYFBHGT2Ht0hNP7jSiu7Yk/wP+6T6N5IveJVHqkQosDeoeucigbgYq+S8JhVXkS6qSqEwGsSAprG8C3otlotyViVaCuVCGTgE2ZpOikT32hyQS41uHVdobl9RvwbUJXOSy2b6HYyvbLXcSw6Xq3NBNqMYqmRIFJ8qLL8K0kGK0wZfJwXhJ4nRZCdNHBa9JQigt6AclaEJGwFg95pMJlA5la3DB5hRi5A9vI7zEAdykhERYHWWdyrkepBMhdkvdVm9HrUnjS6bIE4gRBmRLFPqOQN8FZAc2HRh5nXtcsWOkcohPVgVNAT9DtugTHx/RpVFF4HDOQ67powJkTETK2Cshj32cpFKp9MBCtx6FTZ7v6eQ1ox2Sp1NxPbtv14tA21/uDftm/qa3JufeDcUqcONHjZseFeho2hfvyof7a0xfkuBLaAXD1yXdyat+jdpS+1pR1UIBcsOhiBaAF2rKvEcCCtLwPPEz+WkHKbFtMNdvkmyadncLkLsK83rkzP7+HcuIynzTsd0CvR018P6yVwLfYl0YLbdaN7js91tp/ruthuvloRdm2WfjRUfESs+Wy5aMCY6fA3ztN0mcw3+X7kOlbnKbaQ9GrXY7GhuMc+3sG4bSpSVzvL3eA6Wp6Yt2n5z10+/543zn++fEHJ/r0vyfifWp/m7RH0wGezAZ4tTrgb75Y4Sc+ffFxd+nUTu3U/vZubwNYZf/+0LS3c+5TAP4NAL+V0PmbtA/5H5Zv+VvyoywDAP8MgD8L4F3n3H+mn/lxAHsAf/9H+PyHtm+ruCUTzq9evcJ6vcZkMsHFxYUlppfLpSWEQwi4vLw0+EgP72azwVtvvYXb21sDWCklS3wDfVHIyWSCly9f4vz8HOPx2NzFhJKDwQBFUSClZLCTyVKmgZlIZpKVad7D4WAwdrvdGpimh5rreOONN6xAIosbvnz5Euv1GsvlEvf39+YOZ/FNwjsmiNl/QuCiKCwBTC+0cw6PHj0yoEx4yYmBzWaDsiytUCABMCcfONnA7b5+/doKY/7Ij/wIdrsdzs7OcHNzg+l0is9+9rNWUBIA3n33XYO7efFS+rnpX2dafzAY4P7+3mApAMzncwyHQyyXSwOuAOx9AtO6rvH+++9jOBzixYsXeP/99/Hmm29iNBphNBphsVgcpfKbpsFms7EJASb9uQxT3oTGgBSepK+6aRqcn5/b+pumMW83Jx6ccwaip9MpdrsdRqORJZfH47GdO0zAc9wBWAHToihwOBwMuvIpg9FohMPhgJSSwWJeFznUZio+xoj5fG6FOTebjXnG+bnlcok33njDoDnBOx3dPD84icB0PYvQMpGfUrJjw4kG7iOP3cN/c9KBaW/Cd6btOcE1HA5xfn6Oi4uLo0kyPoHBCRJObNHRzvHgMeakFpPdfLKDRV05+bFaraxfn+TE9zbqcdM/TAe+wbnf4s1wwMwHjFyFn/6Rn4J/NEM8m6AblZIKroKtI3lYkUEXE9qzIUITEbYt/vH5r+Jnrl7jF14+QxEilvsBqqJDrZ5vcWwXKH2HOhYoNIVtIFu/j0KDoW8w9gq+FVI3KUiRSi2MyVa63tfcJYc2BmxjJR7z0Nln2ZoUJD2u/QJkMuCyWONxsZQ0sYLgrmIiGvo9oauAWAGhhhR/zP7md/o3vjsA0NS3uI0lCV4kwK0duoFAcWHxzr5byN0B/gCUm4RwEMjeVbIunytZE8Q9vmvhmyiO7y7C1a0krrVrLmWO6aMU+PE54js+7q6QVOGPAWwD2zhen7m7cQRp+tQyjhK9BmbZFHLLY+bIPp/6ZDNgiUpJnysgztLVSddvaWvIfSl514MsLgdYqtJSyN4JcIYmjgn69T0m4mOhEwLIILAlm7MdeDhBkP+vnXeqEpCUtzjMezCcgu+XZ7HIDEon5/o0N/SckB224+Y+7H7HfdTtuwzaJYfjMTgCetlxJfjKdssW4TYTxPvOt3ScUnzQp8JrP5IWu9Nj20aZvDm1U/suWsLDE9wBwwq4nAHnU2AyEvA9nwOXLXCogIEHyh3wYgnE+kOgN/oTOirMdqn3fyf9D0/1LkohS+d7KOsq0X8AkpCOCRiUot5g0hiQ5HmX3/D1vh0V3hf6iwGx72NUjUlVyf7u9pL+7qKksoda2NOpGzsUQDmQ++zhIC7sPFkdyr5IZUxA6oC4t4lWSZsn+b3goEWwvXizD3uga4DmXvdLlSLFEJhMBGqHQpbnfZgp8FbXGZ0sN9RgifM6gQBJjYckX22jhTCj/JIug+63pu930KdLCmA8kfURfPN+60OmkcnGM3Yw3cvRffXhxMCpndrH27745hyvfvE1vvR8eQLfp3Zqp/at2iql9FHcSD8B4AmAv5apUQKAv9s59z8D8KP62jMAz7PPPUGfAn8BoHLOXTxIfT8B8Je/VQdSSn/DOfc5AP8ogB+D/AL+fwD4Eyml3UfYhw9tHxl839zcYLFYYL/fGyQtyxJ3d3fY7/e4vLw0EFUUBR4/foxHjx4ZUAMEQrPA4Oc//3m8++67GAwGlnimyoBJUhaPfPXqFc7OzjAejw2qU7eQA7n1eo3FYoHLy0uDwCklzOdzA5b39/emk6BSAoApNgCBfMPhELe3t5hOp3j16hWm06lBSkI1pp2XyyUWiwXW6zUeP35s+0yQf3Z2ZkU6WaSvaRpTfRBUUolCjcV0OjUAz7G4vLw06EftDHUihLCcJBgOh5jP55Zk997jyZMncM6ZQmO/31vqmKnhpmnw5MkTxBht4uDi4sIA63w+txQwCxsCsGKdBMzL5dJUI0zR8+fNZoPr62tLWA+HQ5ydndmxICAmJM0BKME/4THTv7mOht+3260lzYui+P+z9+9Bs2XpWR/4rLUvec/8buda1dV1qtVSd0liwIBgJGSB7OEW1mCDAePAGAcGhnF4RgMxwMBEGNszNuOBAM+MJ2wzjLEdQxCyxyCQueNLiMsIhJFB3S2pW6qurqpz/S55z9y3teaPdz3vXjvP6dZR0e2uUuVbcSq/L3Pn3mutvfbOL3/vs54Xs9kM2+1WFf7xSoM8zzWJwXNARTWBMyBQncclXN/v96pqpgKf5yPP8w6E5XnheLHQK1X7hMM871xlAQBnZ2cAxFaG54oJCwLhOJkTF4s0xqiKnEmZ2F6G9iuE4qPRSOdIvEKBamwAWC6XmtzidUm7n/F4jOFwiNPTU3jvsd/vMRqNtKApx4lzmIr9WF3O49IKiOPN+ZRlGbbbrUJ1JluoWv+oxqYOqz+sBVJg7PeY2BJ3kgG+5+O/CHY2hb03gRsN0Ix7cL0kqIXbL3YuEbWUtwbepjCZg8ssXGLxz37b9+CX/pUfx00xxHw3QBOsFfaNWJOk1omiuzFIbYPUAIXLkNoWbiVwSAL5pGqb4HvV9LFrMjSwqF2Cxhu4AMKp9nbeovBSvLBvK1R1C7y3Ltd9O5+ggdVkQOFSNDD4rdOn+H8McjQ9eZ83ArddYnQsgksKmjxYmKTt77aKYEdQhUuBQcAGZaCtWpDukwDLXQSzgZBYkG3zjYNLAwHl6wqT0dpMGAT1cVBsB2joEZR9hM60QYmuBRtBYdC2I6iQmehQGN64Flz7FoobY4JiPVIPV83zdhXei+o7WHFIA9C2ic8lAj6M963QL9hnCPTxQVkeHY9gOFJbi2WthQ9KaG4nxzVq7UEoSxV2DKI7AN85sb2BgBLjBZIDaFXQB7YgHRisSmcZU9N4PXdxe9qTY1poHNYoGCrkmXRRVWI4fPx+QuzoNPhgKWPKGj4JheTUHkeOybG2tWuPnxDKR6pSD70nvKB+rW6r586YjuKeY+OpzDdivyKrJo5WJ8f4mQevvijV1T7rIaC13xMAnmUCvns5MBgEmF2GJIxV3twCb0T3TtM9kAlLfQ4SQGKx0gCg0jnAVCYf60ZgbZ4G0GwF9HpIcsxxR9F7fDieDUUafbgY1fop7KNxYgligoq6rgXuZhmQhRuICXYrSQDKKGR7FnlM02BvEu65nh7YHINonIxpt2+qVv1eF7JtBrnXpBAwT6CuXXTtOEa8X9qYREkHtLY1xgtQd430DwFkwwerGNeOM8chz4OS3ET/0ELvw3u4eq5Hn/HxhPvo/ml5jA9YfPreFP/djz/D544+38c4xjG+evE3AHzrwXP/CYAfA/B/AfBTELD9vwDwDwDAGJMD+C4Avy9s//cBVGGb7wvb3APwLQB+78s0IgDuP/GP0Y/n4qXBN7231+s1ttutqkLv3LmD2WymEO7s7AyDwQCz2UyhJQC18YhV3QR8t2/fxvX1NZ48eYLpdAp6WRdFgcvLS5ycnMA5h6ZpUNe17htARzEKABcXF2ppAgCbzQaPHz9WGD4YDPDs2TMAULVzXdeYz+eYTqfaPtq5UBkeQ8GmafD06VNcXV3h5uYG7733Hj7zmc/gwYMHqKpKVdK3b9/G+fk58jzH2dmZeh5TVU418HA4xGq1wuXlparYabuRJAm2223HVqOqKlxfXys4jG0/AKjy/eTkBL1eT1Xml5eXmryoqqpjjzIcDlEUhQLeuq6xXq9xcXGhKmEmHYbDIay16jtOKAsIoDTGqEVIr9dT64n9fq9932w2akuy2+2w3+/x+uuvqwc4x7zf7+v76GnNBMUh2IxtRmiJUZYlyrJUexNCaPqxx/ug33S8CoFJiX6/j1u3bmE0GmG5lD8w2G6gTZwwsZFlGcqyxHK5xGg0UqU+2zeZTHTlAZMftB9Zr9fq275YLGCtxXw+V8sfXk9nZ2fIskwBPRMiVJvT952rCKju5thxbg+HQwwGA01AcZw4zqPRSGH09fW1nhPCbc7Z8XiM+XyOLMvUm5srMMbjMS4uLtSepCgKLBYLtVhxzuHk5ESTGHw+vs6ttephTiU7V2PEfuCcB2z/RzEKl6JwCTIjc+61vMKrKfC//MR3ILl7Dj/sw/UzNKNea2sSgC8AtRKVX9BCVAs0PQt3McPvOPlRzJId/ouHPx/X2wEmvQJPN2PMenvMejusqh6GaYkUDQqXqlqbau/EQKxPHJAlMq+3TQ+VT9QqZVP3YI1D7eRzxAbaZuHhvIGDwabuoXApxkmB1DrsGukzrU+s8ahdgspb3JRDvLM6wWl/h//2uz6O6lv7cJm0p+7LF2AXWZB4C5gasJWHMHsBvt6G1xp53huB2j4R+JoUwQrFi2q7w2KMbEPFt/hZA+newZYetvTaJvFoboG3Swx8P0WyrwWs8oQ7wGeJMInEBvVuBBaNeFp7n7R+0wFoU/lLKxBCX4JN03i1fyHI9GkEDKjg9V6U08bIyeWSdCqBKQi2aEGRibYDOopvXZXfeBjjW6V0KMxmTAD1NVq1sBNFvQLwxGh/TePEliSEglvnhXkl9gAiB8BdHYBuoIUih9YE0e+xopv90Z/D2Lcq93aOmANlOhMRPjUCsAnyAQE3UbjUPm91QsCfp2pLoxYDcX+MaVXgoY3iM86TwwfTnRNsK6IkDV+jYjUaT5+JslT93aPzfYxj/EzicMqoSZCBgO5eKrD0Zh1U1QHssigkAC3+qJYZzO64AFYhnt8JPxTDUhUXbty0P3HhwCZkjsBrLMDXkBxGGgBzngG9flA3D+TYuwIoufLYA4kDkITHNbDfCTxOg1I8Cypm5+T5qgZM0d6TWLixcQKCi0LgcFkGWyonUJyD5iDgHOFDy4drNAu+5EkWlOepjK8J72m8PN/rtb/7thuoamCzk74bJ491+KxJEqBnIMrycA7yHBhPg30KVfNG9pMGKG5sKKIZKbZtAtBaLA2qbrYlCT7ixgJI0bFXsSEz642MzW4rVjG0mXmBiOL5hMsxjvE/fbwZfL4/+/AIvo9xjGN8dcJ7vwLwo/FzxpgNgCvv/Y+G3/84gD9gjPk8gM8D+AMAtgD+dNjHwhjzJwH8UWPMFYBrAH8EwD8C8Ndfph3GmE8A+F4An4Z83H4OwL/vvf/J99u3lwbfP/ZjP4b1eo26rhU00cuXKmJaXZydnan3LlW82+1WPY4BgWm0Lbl16xZ2ux1Go5GqXwkskyTpFEqk1QH9vuntTAUrQSOhF60j1us19vs9zs/PtQ2E8rQUobr1UGlKKEjYR9gIAA8fPsSP//iP4+zsTNXghOeEx3GhzcFgoKrX6XSqSQSCSNrHOOcUWhImz2YzPHnyRPcdA2ACQEAsOLbbrYJOKryvr69V8W6MUYsVWs5Mp1MtkngI1TnGcRFHHpug//r6Wv2sCUe5DxYuJAA2xmCz2aCua/UKB6QAKsd4Op12io3GXuZUSAPQ16jSprq/LEusVisd39FopMr8q6srBdQsqJjnuXqnM/lCdTPnyP3793U1wZMnTzrFXNmOOBlDaxX2ObZ9oUUQFedAqyKPFe5USgNQK4/79++rVz1V6977jgUJ4TCV2FVVYbVa6fnlvKHfPRMMvNboMU8VNwA9FpNQ9MSnJQ236fV6qtTnNcH54L2HtVZV8VxJQHDPegFUg3Oecc4TxN/c3KAoCuz3e01AUDkerxL4KMai6mNZ9nHR38Aaj5Nki7HpwcymcGcTwFo0w0ytTVzaVXCqTXbMxqiMtR71tI9/8Tt+A/783/5+/L3lA/SSKdZlD8Z41N6ibFLkSY3aJSiNRx4or/NGrFCCKjyBEzV206qxC5dh12ToJTXqQJhpawKIPUpqBaY7b2CNhzXiH944i03dQ+UterZB7S0GSYWikY+603yLyWmBH/8j34zRJ7aoB0lQWEPAX9TnpPJqUZLuAZeIWtqBaucAWBvAZwjQEqrqTsh7ua0P24Zj0H7dNgK3k8orOLRAp5CjCSI/46HAseOnrG86QEFNC6NNMInm+1wWlMCqjEZUhJH9861KOQBvlyUdQGy4TJ3wGwC8bdXM3qsVywvDteA0huIm2p8P46eK4cS2SmUgtNHAuEY8ZryFNwLUzQGaMPTwJaQOfabaOQb1JiR8FD4r03oBpXUAbBivcD2pjUikoudYys+t+lHU+9F+Cb29//LHY8YgQP7n7E5sSGaFBApsdN6aqGhl6JvavZjQRwM407036Hu8aZMniSjmVR3uoEpz2TZKdLBNXB3grRTdjG1jjnGMn0H4QwRujKi8R325RC5XonKmQpngm/cU5wQIN01QHpsAXQP47uVBHZzIe10DVFVQF4cbOqevQVh1gxbKGknwyvHDB0LeE+Cd58B4Isd6diV2IQToNuzf2vC8l6KOw5HA6FFPHk2A4EUhgJ19aXzrM17VYmtCNbf3MkaDvvxcBUhORboUtwgwuQfYTI6R56FQpqy4xGYvbTeJgPzGSTFQKq+dl9+LTYD+BN8AaiPJiSyJzoGT40xP5Pd9Je0byfcqpLm83tTAZiPngktckgzoh/HlOXDhPLgmqOEbab81AeJnAtdNOI9FIfstS6jiXpfX4Ei8j/GBijfvy/fvH3u8ROM8EvuCvxWOcYxjHOOrH/8egAGA/yeAUwA/BPEEjz3E/3eQT/vvC9v+DQC/1Xv/03obGmN+BYA/D+BHAPwtyKfvtwP4jDHme7z3f+39NPqlwfdbb72F9XqN3W6H6XSK+/fvY7PZKNjO81wB82azwXQ6xb1799QWguCOBeum0ymur68xm83w4MEDBZZvv/02ttst7t+/r6AOgILm8XiM/X6Pk5MTtYIgDKcSmepyoPWmpvqXFiGLxUKLXtKbmNCMSlIqS+lHHKtUY7uSN954Q98TFzhkn9brtR6XYJ1wzhiD1WqlSvDdbqd2GTwWQTnVyoPBAE+fPsXt27fR6/XUzoQxGo1w+/ZttTipqkoV9lRcx7CUELauawXaBNe0BWHhSkJw2oLExQ7jYp6EyoSctMChpzbnAc/fYrHAo0ePUFUV7ty5g9FohLOzM5yfn3cU97PZTJMcHGe2g/vPsgxFUWC1WunYsh2EuhxvtiP2i2ahRrYPkKKbBLHs72w20+RG0zSa3KGSmor9wWCgBSzpX07VOK8dwmQCac7X3W6HPM9x69YtbDYbBcH0VqfXOf3qi6JQcE/va3qHJ0miCaf1eg3vvfrME1rH/RgMBgrKOdZMPjH5w3kdz/vYqohJkDhRAUCLstZ1rYp6Ksc5J2J1f57nanHDPgJtgdG4GCZhf1xI86MWzhtM8z3+ydOfwK8c/QR++2u/BH/y4hw4m8D1M/gsgctlybJPqfI2He5GH2Fv0CrBU4EM1ThF/ak7+J5f9uvxv/qv/xL+zNNfhHFWYF9n2NUZVlUPWZMiTxoB0/DIEgcX7Ax6tlYv8MZZXFXy+VC6FHl4fl0Hn3Jv4bxB7S1qZ+FgYBuP0omaOzfdz89RWuC6HGFRZaidRZGk6CU1zrINpuke/9zsf8DvffsB9rf6aHoWTU7VKvsK/XJrgo+piwSCtCZJSlFrN1nYLoLUxgNNGsaLor/g6JCUAmltgLZJKVBSVOWt7QgCUJR/AJyo7cWpwsA2Dg4pkKewXN4e+sGil95EdhpFBeSpOkoYwuxwbl0vEVDuuQ/ftiFenm6o+nWqho4LU4qS17dgE+gAWe9M9Hz7frU9IQh3rlU0U1XuBDCZSLncqo0bfb8MVniNwDkljG8Ba6sGl+MZWrIYAwQ+JHCdABwCaA+V3hxQ+sNrsiHqP9sStbnjdR78r2PQLZYicixbu9YLm1DeCED2cDA11MJEYX9IfD/X1toBiWmTCfSID0kVb416jdNLHY3XuS9j5oDEtsr2oCyXcyDKdE1IMIFQu64ljmmV3z776CYqj/GC+IqAsX2xzcMIpDQIybY6wOnNFriZA4NUIGoeVMu9vvhS89rIMoG6+rd0ANYGrQ+3i+xGGNYC4Ha82QelMEmp3s9M2FeArsa2cJxFKJO0hcBAUKMD6jmd1AE0B0jbhG1NTGVNq552etOW98UJJu8jr3K534uNCCXsTdt3wmUf4Pg+KNMb1yYQuA8mbRPTAmVuU1UCoZuggq8QgH3U1iwTK5qqAqqgBDeJfK5kqZyn2gJ216rSYcMHLM9fsD2xqSj2HU3J0fX1jtvrvYxlVQXblIMpqPfmI/U+xgcjXj8foZ9Z7CuHL15t8Ilb45/+Tcc4xjGO8TMM7/0vPfjdA/hD4d+Xe88ewL8e/v1M4w8D+GPe+98fP2mM+cMQu5WvLfimIjfLMpyfn2M0GmEymWA4HMJ7j7OzM3jvMZlMFFI/e/ZM1c4EpjEwI7AltCbs/vznP4+6rjEej/Hs2TNVqxIWp2mK1WqlympCP8JNqm4BqBLYWovlcolnz55hNptpccMYULK4IVW2hOi0ZqAKdr/fK5Tm8VlMczabKeSnwjdJEozHY9y5c0dhY9M02jeqWQlR+b7RaKTjzu0mkwkmkwleeeUVhYK0RiGkZfupqKWVRpZles4IWa+urnB9fa0wlueR3tBAayfjnFP7Eo4P28bjUjFOuxmqmql8Zhvpwcy5QkXw48eP4b3HycmJqo/H47GOPS1P4sKcVNqnaarnlHOFkDwGs/SSpk85kx7L5VK9znkut9utAn9CbL7OgqeE3Uw0xMeazWYdL3mq5VkINc/zjv3Per1Wy4/9fo/lcqle3bQBAqAFRuNim5vNRo/D52gBQmBN6xwqw+Pir7xWqBQnwOZ1zzm9Xq/1fZPJRK8hjiULcdLTneeOAJ0WR5yDWZYpBOdxOKfYD9r18PqhnzeLaNIaidc6kyQf1XgwugIAfKr3EK+lYyTTKcxkDJ8morhM5YuoqkFZzPBQLeK9FLcLX/hsRcsLAebbT5zh3/+dvwn3/k8/qRYmxnhkpkFqnSq9AaDyFlnw8HbedCxNCMQrl6Bo0o4XOCMujMminWVD1bdDFopo3s5X6Nkaj/Yz5EH1XTQplmaAZ+UY2czBbgq4VwZdkOcBYw1MDdS9AKwTeUwagd+mFnW3wEFRzNoGaHpoi2J6qnoR1GZQJThV5PBewTeht2mgX8BtJd7aHlD1vfGAqRwsgbY1MCFZ4foZ4gKEtgZ8kCD6XhIUbaKqi32nfXy+mxZceoOw7xcrtX1ugdrAlk0Lb71t1d2Exy9Q8eoRCUpssBhp0KqW2cZY7Uz4ASgkN1XTQqUAaMUPW8C1JBF0AinMBa068qSjJIc9eE8MOZgIsvbLq5Oj9saWI53+a9HOtt/yVul3xwc89kznuXPtPnSMTQSNA9Tm62IZEx4r344dbWm4b7Y5az3vZUxC4iNY3SD4Gqs6HEx8RDCICQRdAdAW4VR7BKr7Q5LmRXPlGMeIgyxZrXzCig4fgLLxHklIQjabPXxZAe8+AtLPAZtXgG99ICA27wPnOeBr4OqJTPbxSFTNKaA+01kmB02CP7U17c24MvK+NBOlsffQewWvFV4SjRcLkySRIo9ZFgpVJhDbjaBA7vWBYQVsd1K4MXHBisOKArluApy2ksgsgyJ70BdVugltcl6sOpoGGIT7Q+MlCWBMKO5oguJ8ID/T8SSxwYesEZU4TNsGguu6keMb09q1uEZU2I0TWA0AWVCHNz78a4BlKeNkM4HSpQH24cQ2kLEYT4DpWNpbFKIXo3VSfwCMpkGZvRJ4boKK31q5Z3ontjAOAZSH5+gB3jQt8K6aMK7hcbeT/VY16DmudyYmhP0RfR/jgxGJNfjU3Sl+5J05PvtweQTfxzjGMX62xKcB/IYXPP//htifvK94afBNKwNaEcxmM1xcXODk5ASz2UwhK9WfBKW0IKCHcVy4jwD2/Pxcodl6vcZyucQXv/hFPHjwQG0M0jTFYrEAAC0SySKJPNZgMFBoG3s3n56eot/v4+LiQm0/CORiSDoYDFTpS3UwQRr7RaUx1adN06iS/PT0VNsAQAtfpmmK8/NzXFxc4Pr6GtPpFOv1GkmSYLFYwHuvns7X19dYLpe4ffu2gk5C1GfPnsE5p8D3wYMHuH37tirXqSIeDAZYr9fqH03vZirJY6/n4XCI4XCoEJ7K6ul02oHHu90O4/FYwTbPC5XMAFRNfX19rfYpADCZTLDZbNTKBoDCVyqvafVC0L9YLFTt//GPfxy9Xg8XFxcKdgmbAXRsLQi1mQQZDAYKdgln4+KKq9VKFeCxpUmaps9Bbs4FKr5PTk5wdXWF7XarKyFilTH3xTGKfau5cgGAAmBrbcdu59A2hgUdAQHDm80Gk8lEExNMJCyXS01Q0PeayYq4fTy3tGHJskyvibgYKeE0x3c8HmthVhZRpb837xNMfmw2G1xfX2M0Gul+6fvN6ybPc8xmM5ycnKjanWr8w/sHrzeq/GlBFBd5pb+8eQF0+qjErzv5YWSmwR948G34w+dnMOdSyNINMzhVW8q/5ywZgBaAuwgCUnFrBVA2uQDw/VmCXzR7C4/KGf7O5QMAwCCtsKlytSHJAshObYMEDrtQaHJd52phwqi9Rd1YVYo7GIXeAFA7ea0MVifOGbjKhKKXGV7vX6FJrMBw49CDqMALl+IkKzGxDj5P4Y1BumtCwT+01iKQ79BS4DKMT/CNJo93uVef76RqFXW0LQHCewpIkdAQthK7FFu32xG+GxcU3wFI+6gAoXECKm3t9bw5a+B7wXakDkkLL3DXIcDvoEJU32/3/DVhGh+8oUO7DdvfghtV8novwDO4crg8kXHTApwCnH0AEKZCALHowmwGASgCPG1omwFVGSNBq+omFPemC5VjVTNha9UEAEwQ3R5b9xclCzgW/gDMKmQ7bH/cj6gtYrkiIP6598THigC/t7aF8eH9zz0XJwRMmB8OQZEZdkolvDamTVxRfx77cJtofywSaoMi2xijSQ3jIPMqT9qxNgg2J5E3+k8Hr5kYsDKfDf17rdXr8BjHeFF8+U/zrtLZkErStmNXAMsVsFoDRSlA0yZALwtgO6it0wzIvGQiqeg2AFdpgEruzjGDopkKb17m8b2J9x0m5/h+77uvOQ/1nTZoE4OHSmr+Q7AvsU5U7MrdQ7sU0gZyq5lYACZrC9zGxwQEHPPzn/lny+s+qK9pnWKMFM08VHqzjxy7uD91yEwk4QPUIxrfVD9D5F+A2dYFsG0ipbw5+Ef1fBL+Tgn7tqH4pgtZaBbr1M5F5wk+APzmy9/LjsT7GB+wePO+gO/PPVrie/5n97/ezTnGMY5xjK9GPAPwcyH+4XH8XABP3+9OXxp8U02bZRlGoxEuLi5wenqqRRvLslTgTdBKqwNA7Dd6vZ7ajsRWDfQarusa5+fn2O12ePLkCebzucJw55z6Bi+XS4zHY1xdXWEymWA0GmE0GqmKeDgcquqaQJuFClnoryxLTCYT7RN9jAlhJ5MJnj59qgCNUHo2mymw/eIXv6h2KOPxGFmW4datW6qEJgg9Pz9Xj3FaWBRFgTt37igYJ4SMbTaoCia4JXBdLBYYj8eqyGWhzJOTEz1f4/EYjx49QpZlWCwWmM/nCr4JwwlmgdYTmgpbwtN+v6+FLePikYSOm81G7SZonwK09iM8Zgwu2e48z9XHnAmI6XSqlhVUoidJgul0qgkHgmKq7GnZwoQGCzYSRhPGEuqfnJxgv9/j6dOnCvDZns1mo/YfZVl2AOpgMFCgzD5Op1MdByYTYqU8VdYE51TeUwVNCx2CYI5/bDFDpT1XJTDYn1iJHxct5fNUvbNfsf82QThV3gB0TlOdzesfgCZ86LX9yiuvYDqdYjweY7PZaEFYFqnkvmPlP73mgdY6ZbFYqH3OcDhUlT+PH6/isNbi6upKIT3thJiwGg6HODs7w507d1729vazLv7Qp78dAJC+cQ++n8NZCzfM1GKgVcy1xfWoJJYNvPr1dov6BfZGLp4YZFuPv/htr+J3/sj/iL/59BPYVRkmedEWogyPpUvRszVqn6FoUlTeYl31EEeeNNg3GZw3GKaleHxH+7DGY99ksEaKW9bOwnuDHTJsgzXK7Z4kzPZNhnujKxQuxUW2RmYaPOg9xe/4ll+N5pszpDsBEcmeUl7AWn5xl+M2PQMXlHCmBuq+wGsquGlhku/E37jJ5Lt8WrQ+3GkAHKrabjySvWv9qQOwMM7DBusQWMD3Wk9phePewwTVfdOLzmWK1o7GBH/xqoHrpQoqRTHeKnVt7UTdG6wqfATOZWl9OPGJEf9XQD2deRyfJTBlA58Z2Q8ALon3iQHq1u4jLm4Z+5PzvtnZjtAhShq09h+tLQcV0mIz0o4d9+d9e1yftMpkBcmN7x7jMExkjUJoG10jHcAVAK4qugnA2XYX7Yd2CgEuGxbVi9plvNgMaFsDmG4hM1pVdVDLa3B8qarW4yLUrWshup4LwjdrRBkOqIpWILu4xLssga0a7XtsHaPD5j08TOvtznEilLdWLHdS6LGOHt/H+Erh4x80kRQ/Gi09CWNgjJV72noNvPOuqH6fzUXhfH4neEiXwOUTINkBGw9khXhRF1tJ2BVhnudpKNgb+2AFKMvf46Yc1l9wHqjC/Wa7B9JalNNFIbYdTS19UuuS8E8vGCPq6cSLwro/kOeqoFQuK7nv1kEBnkBU2PACqNdrgcapEQg8HLdqbyqlea0We6AqZf8+AOUkAOfaBzsmIyp3ILSzCvePsP2gpwkuOMj7KifQmcp4F3zAh31gPJP3cdVTuZUCk1UpCQn6jCeJjO96DTSVQO0sAHMES5YsbGMT2VeWylhUJbDdCtS2wZ4lDb7lje9mVrzcw2y4tzXxPf8Yx/iAxadZ4PLR8uvckmMc4xjH+KrFnwDwHxtj3gDwtyGf2r8EwO8D8Eff705fGnzTf/fBgwe4d+8eLi4u1NaDIJPQk4UBY3DWNI3Crtj6gQUP6bFMUDcajbTYXVmWmE6n+p6nT58qMBsOh2oHQcsIKlEBdNTcbOfJyQlubm5UZc120Y+cYC1NUxhj1EqhqqqOgjhNU7UeGQ6HOD091T4B6CQDrLXqyU1LivV6jdlshrIs1dri7OwMb7/9toI+Wkas12u1P9lutzg/P8fbb78N55wWOLx79y4AKKDebrd49uxZxx6GfWiaRi1CjDG4f/++jgOV1k3T6FhTdey9V1uVuOglx202m2G322G326kCPPYzpxp4MBh0fK2rqsJkMtFECZW8b7/9NoqiUAX8bDZTn/AYhDJBALQFIgl4WZSU4Pfm5kZXBVBdPJ/Pkee5Fvgk6OXjYDDAZDJRKBwfl97ZhP1xUcYYItNapaoqTdQQhnMsrLWajGF7WaCUSSMAWkiT76GXe+y5HrefimsACtBpg8P98ZGqdI5NPLYAdE5zrsTWMFSz8/xwRQFXN0wmE70HMNmUZZlaHvG4sX0NI7ZH4RzhedxsNp0kEPf3UY3k1gWau6eoeqlaYMTqThNgrEtE6SX2HO03P6qfPa0fgnJYIVtqgs91UH6+dh//9OBv4Ptnl/jM1V3ktsbOZEhNg7JJkAY/EectqvBv32TYN2ElgQ2v1+LjDUAf+VrtEljjkBqH2luF4Q4G2yrDrhRP78olmOU7WOMxSfZ40FvhVrrCJ/OnuJ80+E/PvkvGqGjQ9BK1OmmVcQZJIf2i6tsHosLClT7wTwrs0p1Yk9g8KOE9kBROfLvL0LeMwDZYm0RqY1MLCDeNU8W3za0UHSUg5/ah6KHqY8lGQkLChL64LIHPbAurax+WgYfdpLZVhFPhR7icGJg6WJ+UrT2KqZ0ofBsn3tKZhUMiliMRFPYGbWFDyzkXfm+gkLgdAKOKSBMAr4xVKJjIZfacx7FSmdmYxLbwWwGF6SqgQ9ss90F4G9l+qP82DKAKdN+OC205Yhhy0BeF1XrQMLes10QEt+3A8UNgFsN194LnuU/vpXhpUMPrZq7bJz1unHiI2xosEGJo73levRRKTehfHiUEaP9C0K12KYcibi2k6juWL7y2jnEMja/IGP3zP3n+EpJtVAEXhSi9b2bAagdsC+BuDkwmwDgA4AZAfy8feHXw/XZOQLKuhvDxQUKC7+C6YkN8LP/mj/KZKhYkYaVDUwcQG65denBTPW19+2FDC5IsE2DrIVYnzgUrq7q9F/HRhsTmfh+8r8PfU0kqdi9p1kJvFr2sGxkvqqcTtGpqz6RoAOG899ZN209rBeYb0yqnXQDmQpRlW3qQwwC9gbyvcsEWZivWLk0A+TaRfaapeIsX+3APpjo9gdxErBTO9AGG+5C0SINifV8EZX0YUxs81alo13nkQxLFB0G67fp8H+MYH6B4k+D74RF8H+MYx/hZE/82gBWA3wPg3w3PPYR4iv/f3u9OXxp8D4dDTCYTzGYzfOITn8C9e/c6RejoUR37XQ8Gg05BOwLBGHbxd9pKnJ6e4vr6Gnfv3sWzZ88U9j19+lStUWazGabTKR4/fozJZIJer6e2HoSRtNmI/cGzLFPA6ZzDl770Jdy9exfT6RSr1QoXFxdYLBaqVKcil0Dz5uZG/Yvn87nC1bOzM8xmM3zqU59S5TQgAHq1Wilkv3PnjgLd8XisntVAqw7e7XY4OztDWZbaZ/anLEucnZ3h5OQEzrlOwUAmEIDW85sq5vfee0+V5t57hZW0uOj1eurVTp9kQJTlVCZTWcwxpc3GdrtVmMnkB6E9gSktOGjRQh9ujmuWZRiPxzg5OcFkMoH3XuH0crnEu+++i91uh9u3b6MoCi2USQ9nKrqpkqaSOQa3AFRBD0D7RYBMKxhagwwGA1WfsyAo58319TUAqG0MAFUex/YacXHU0WiEqqoU+NImJvbb5jmJt+M5os88FfpMqsTAnMkYqtUJ3DkfaAvE65WrMmK4zG05RrR3YT9jP3Oq0Ok1TnA9GAyQZRk2m43CbZ5zJiGY7OBqjcFgoEkUzp3Yroh9iucUkwH0O99sNuj3+x1v/o9qlJ+4HYpVCvQUSwG00K2BFLfT4oVBWUzoF1TgsdrbNF6AtwfgvMDh8Hx1McZv/I5fj9/33/4F/I3BN+NxMUVqHbZ1jtQ0qux23iC1Dcrg7d1PKuybDEXdzkEHg8w2cN6q1zffJz9DQXqeNNjVck0XVYqiyPBemeJJOsF3vPpTeNB7hk9kTzGxJX7PN3wn7MkM7vUpfGrhMgvjfGtFQmuPSPllG4/GG9gaWrTSpWJ54q2AvaY2qAcW2boBYNFkAr9tLdA7KQTe2qZB3U/gLeByq+puBdtNKAhYCxS2pYNpAsn2YTsf7Cmc10KECDkpE/l1mwCATe0DuIgmR6QM5zJ0nx5ahwCA1eKVgIByWzYCyo0V2wtABiWxgPVqj2Jr19puONOBBd4YGIJiJ0UZWyuPCAIrbBdbGfUNj19n8cS4b6r+lnuEz/B8RBDdN3geVAMdGxZVY4dz4JOkW7DyAMZ3LESAAH26++r8TPU5+0hQTpsX51Q96Y1pVercbQzTYzV3rFDnduFe3mk/ICrsNLJX4TlimxQARtMptMn4plV4xsNMH3C+gXMDEDuVJsA9a+HNwfgf4xg/TejtmlOHauJ4A4LXqhLoXAQP7fUGWG2A1VaeG/QFrvpK7kNJBVQ7qI1HXYvC2AbImibd66dp2iKTBMouusZsdA0xUecDmC6q0JOgyB4MxQM8TYHJWPa124fCkB7Yl2GfAVo3DnBluw/aT+n1ZSI7l6xVjYe/JxWeh4S4qqVdgOn0u2bb4/sdhzsJymoTssQI96kkQG8XLE4oks9yUY3n/XZ7/tFB6G4h3uM8B/QXb0I7tDAnM9O2VZ1nmTzH/ISxwVfdiv93WYb7aviAbIJHuQuA3vvOx6Z+EB/jGB+w+NTdCYwBnq4KXK4LXIx7P/2bjnGMYxzjAxyheOYfA/DHjDGT8NzqH3e/Lw2+7969i/Pzc5yfnysEjwvmLZdLVZWycOB2u1UADTyvvo69lYuiwNnZGVarFT72sY+pj+98PsdkMlE/7/F4jDzPFWBfXV1hMBhokcHRaNSBZoTXgIBcKkHrusZoNMKTJ0/gnMP5+blCyLiIHpXcq9UKP/ADP4Df8lt+C37wB38Qt27dwn6/1yJ65+fnat1CRSrhMC1MCITjMdjtdjp2VPnS25njxzElrHz99dfx+PFj9Ho9XF1d4dVXX8X5+bkqXCeTScfSg1YQhM1UrdOHm1CdIJjK7BhOE9bS55wKcqBVuLOIItsAQBW89NKmer7X6ymkJHQfjUZa8JQJFY7BarXCbDbD48ePcX5+jjt37uDevXsARPnLpATnAfdPsH91JcX+CG59BAY4X6lkZmFQWvYMh0O1bCmKApeXlwBEUU/Pab6XNjhA6z1OT3WOD4ticoy4LaE87VX4OyFvmqad68lai6Io1GqI48kEUFmW6sW9Wq3UVoWv0xqlaRpNSnHM6BfP+RCr3Jms4Xwry1LHiePw3nvvqS8+g9Y5XDVAkB37nvOcAK1dDtBancRWQVwNQcBNKE51Pu2OPopRjVLQPkNU2UatNrog7CvsxKN9D6BwHD4UhKQtQu3hMoviwS38O9/0bfgPvvDf4PtXPwfX9Qh/5/JBKD7p0Utq9GHgvNXn+K8KDaF/NwAtYFk7i9S6trglDCw88qRG7Sx6iUFRp2S4qKsUdQX8k7OfwHcP3kbfWAxthuTeXbjZGPU4h08MXCI+yS4LIDiyItHvuB5I96E9iYELIjIWr2x6siHfZ42osV1qUA1byw9bezS5hctbkE2wmBQCuH0aQDPvTVzqTrgYVICGUBlBdGhMKIRpQU9aQmxb1OrBrGCb59xIkVN+vTfO62vOGim+6eUcuwA+XZ7Ap0FF7qWvpmlhvBROtVrcjKA4bpMMSni+ESglnN3oPhR0aFONqJeN71qdELQSXsf7JgxWFXuruO+0I4bQUYQzK7A5sjBpV0xExwjPt4r3yL4EaNsZ2ZPoew4V7Aq9TbcPcX/Z5pCwMM1XkEurOjxSqeMFAD1pj8F+x8fqJhjCezpuDJEyHq61STEmJG6czA9aKHERkbXhua90MzrGMV4c4SMJqj7WAgTheqldsBUpRfG7L8TvO+0BN0vgOnyPOjkRWwwDubFu92J1QtVyJatc1Pc7zeSYTbDNaIJSOrFSaDJJWssSG0A5wnbeh4KQIdnnA/i2RgBybxgKQ2aiSjcGuLoCVqtgl7ITYDsaynGKUqC+TWS/TKQ1XsCxgbQr6wncHwyB0ViSogj32n3d3nNtKtC7KgHTCDBmWzsjjwCaw3gM+uhYvSRBkV3ULfgOSVX0+0B/JO2Bbf/AoFKf3tx5JuNf7sXepKxbJX6SRffvcN5cUK/nA3msSwHaJhHgbytJYlAYYVN5X9XIvl3zfALleG86xgc4Rr0Ur5+P8NblBp97tMR3fvLW17tJxzjGMY7xVYuvBvBmvDT4Pjk5wWAwwMXFhaqgaWlgjMFoNFJrkLhIXuwhTfU2fYIJTKk4NcYoID0/PwcALRxY17X6ZD948ADvvfeeQrS6rnHv3j2cn5931M6AQDnaalAZPhqNtOAg7S6aplFwT5sFws4vfOEL+MEf/EGF4I8ePcLp6SmqqsIbb7yhvsrj8bhTUJB+4lR3A20hQ9o+0PuYcDU+7nK5xH6/VzsZ5xxGoxHu3buHhw8fKoDOsgx37tzB06fi9b7ZbLDdbnF9fa3WJqvVSmEwCzvSjoLKZQL72EubKm7C2NgTmspfAnAq9jk3rLVq6xIXJGTChOchngeE8UxglGWJ6+trpGmK6+trVUDfunVLAezZ2ZkmEQhqWciRSmvaZhRFof2i/UoMyYfDIdbrtcLcoigUjNN3nUVWLy8vMRgMVBHNfm23W+0/+8NjcVuCZnqtU83NuUgYDUDnM5XtvFYI3WnpwnZyJcF0OsV+v+9sQ/gd25fwes2yTFdt8HywP/Hc2O/3Cqs5nqenp8iyTBMQcWJsOp1iOp2q5QmBPa1ZaKPEVQVUsnOlAduSpimWy2UHetPWZr1eo9/vYzQaYTKZYDqd6j3koxj0l7Z1AFGhYKCPv8wFaKVA2yDy+JYHc/DonQ+2KOH5AImN87BlA/NNb+B/8x23AO/x//o734cfvn4Nq7Inim3jMC8G6Ce1WJZYh9KlCrrjIOSO4bgCcd9EP1tUTQLnDfK0RpNZZFmNXtrgP//mB/jPmtdgkgT2/Azu/gxukHb6F9dFo4e2tyaouUXd3hDUORHoJRXQBLGe8UA9AACLZB9AdulRjSxMA7jUAAMr36Vt+N2E80OrhwAcbdkITG484BqYzELtLADYfRVZgPguSLam7QdhsvMwVSPQtmnEfiLA67bzYThMW8hTFH8mANAW3iPAfo4PnBGFuvetrQnhiAlWGLQ0if2bCU2BLmwmLKFtCoFtgLYGgLdJxw9b9011ngtKSkImQNtmrFG1ewdYA1qM8jn4HVuPeP+8PUvchwguH/pVa9FMBl+20XtT045TDMd5jBiGA6pSN3yNyuy4wKW+5tvfEW3L55Ko7+5gfh2Cfdq16DQiPG/7bLyBT8M1Fan7vU0CqG/nvhQ0te25OcYxXjJ8/FP4zJBbmIcWdzRGfJ+tFQheNnKPoa0IEK6/ROBtnguUbVx7HzG+BeJ6SN4sw7ylXUiatOrnxLdkXpNlAZ57L+2wCFnXaHcmAPAkFQCuvycCfesmrOQx8hxCX30TJdKY8PKt9zcV3WyTM9FxZdWOwG9+MFpmV+UfxxTRWNAmxHJbJh8Q7s3Qe7TsJvJG5/7Y5rpukwUesk3so65gPhwrCcduQkHSyOZJrV7ifpumbau18r46zIUmQG9asHgfGdu059noc8c4xgcn3rw3xVuXG3z24RF8H+MYx/jwhzHmDoA/AuCfAnAbBxlo758zU3ypeGnwPR6PcXp6itlshldffVUBHSE2/bypbiWsowKYBSAJzah8Dp1Tj+Rbt251gKD3HsvlEjc3N7h79y6KosA777yDO3fuoCgKhXu0M6FlSuxZXFUVlsulQtybm5sOnLfWYrlc4vT0VFWqLJb47NkzpGmKX/7LfzkuLy/xmc98Bq+88gq89/jUpz6Fj33sY3j06BEGgwFOTk5UjQpAoTf7OBgMcHZ2huVyqarfpmkwnU5VVU1lM0EfIS7tVGgBQj9yAAoDacHxUz/1UwqdV6sVvPcdJfpgMEC/39e+FkWh7aE1Ra/XU1XwdDrttIftpL0HYzKZ4OLiQtvLwppXV1cKx2mJQxU6z1Gv18NgMFC1dVEUyPMct2/fVvi63W5R1zUWi4XCUgC4f/8+xuMxzs7O4L3HYrGAMUZXCiRJgvF4rAUQOa+oXqZSm5Yy/X6/A4U5VgDU5gYAbm5uMJ/P1dua/twssApA5zktRegPT3CcJIn6obOQK68fa61eY0wYcb/r9VrP22AwwGw202QOj8kEDNXssXc4r0P6tTPZwoKYABRO02uc54/XdpqmuHXrFk5OTtDr9bBarbDb7bTNsaKbfWGihKsXWLSVUJ/XaPw7AB2neKUC7zlU2dM+iWP0kQ5+bz38htaBpQFYR9/dO6rgGHDHDM50f7ZNUDnnCdytIeykh/TZEv/qt/062O0K3/+Z78PvfvdX4Z31KdZFD720xiCrQhM8sqTBIG1/X1U9eC+qbucNciugO7MNclujThIULsW2zrBvUuxqKXY57pWY9gv8/PMv4TunP4H/EJ9CcnYKMx7Bj4eoZz2xFwljYysH74zYibA/1sAYL0puLwOg0D8BbC3jkm49mlwKXxoPuJwAG+oZbrwov23tkewaJJUTq5PUdLy7k6JBUjQwVQMT1GzGWpgqkWPXDsY58dEG4PMUPkvUqgUA4LwotCHbwwbgG+Coz1MtbKrgNDWtzUt0Pg2gvuScJ8m+hssEIBgrwKQtsuhFrV40MAh+4JxHtj2mcU17EN23DUv+fQtA6DUbv58+9UXdLtv3rae0QufIoxpJgMABfNuwT29t+3qksFa7E33OvRh0x5A8PCfwFgFo++c8tX1qWzgdq6RDH58rhBlD7wCc/cG5kqEMbU5tq/yOEwsW8L2ke8zoNc6RDli3Xr3BdfsEz6vKYzD+AvW7qcP5oU1LgHDWs2YA++51DI9xjPcXAlsd1PkJvnZikzTIpIDioAdsa2BZAKcFMC4EdKYBjvaGQK8n96dBD5gvgc022HwcXHvOCzSFD/YnFugFpXeaAoOxPOa5wPTtFgh/NyLP5R5W1sBuJ/e7rAowNtyTsl6wJOkB/aG8NggFHdcb2V8eFOH9PrArBKI3VGlDns9TgbrFPiisQzHLOsB/a4AmwOMsSMPLQupBmFSScTYBkqBgZ+IgDZ7btE+xSYDQicB39TAPILksW+if9WVsGgPsSrm/UP2+2Up761peNza85gC/DRZWibTVWlHoA1IIsy4lOWBM254sC5Y0oQ11I+cr78m5X66A1RLYrGUf+x1MXcq9znupAwyj8Js/HeH3MT5o8el7E/zX/+gRPncscHmMYxzjZ0f8KQCvQby+H+Gr9LH70uCbSuE0TRWOEaQSHAICVWkREauIqayO1d30GCYYtNaqPcd6vcZms1EYPRgMcHl5qT7CT58+xSuvvIJHjx6hrmu89957WK/XuLy8xCc+8QmFd4BYnFA5SoBIqEZ/cVqu3Nzc4Pbt26o4JbB79dVXcXl5iaqq8Oabbyqkn81mquylKpdAfzweYzKZIE1T7RM9vg/tRtbrtSrOqVq+desW3nrrLQDAfD5X3+l33nkHi8UCt27dQpZluL6+xo/+6I8q7KeXc1mWqsjP8xyz2QxXV1fY7/eo6xqnp6eqdKa3N+0kOFa0p4k9pOlbTasObs8xp984ld+M5XKpliuAAO/lctnxoKb6erPZKBS9ffu2wmxa21xdXem+e72egmnOt7gQIucqLUgIp2mbQRV5kiSdwpjWWmRZpvOUthpMMNAipigKLczZNI2qwDkfuC0hM9CucuD4ci5w/KjIp20NrzmeY/aPc4bnjfCXcJm/x8Upl8ulbs/XeI6pbKenNu1Q4mKd7MNoNNJ5RhU37V14DCZN6F/P8xGfh81mo/M+tmqJ7ytUf3NVCK9P2vNw5UOaphiNRjg/P+8U+fwohoIkj9YWIoJeMQxTgMrv93yMFGEdoEnmlZiWdTkPZy2aYQo7GcL0ezDFCL/5wXfh1/6jL+CvN59G1SRatNJ5I3YmEU8bZQUmWaGK8NQ4pLZBYrz6ejNS6wSIJw0y26DxFpNsj7u9BV5Pr2AGA5gsg+/34IM/tU8s6qGAwHTfqEc0EEBwKn1LCgHdLoVYvtpW6ewSIN0DtkEoUilCsnpg0ZvX8NYg3UkywAbVt8ssksoh3TdoMot008JRS+hdNfLlP6gMbVnDVwJoxd5EFIjqyR77RlvT9ZF26Cp1g5JcC1oCMLXouennzue14CXEl9zUMpeSpobLLOxO7FOkwOkBtKT6myCa4JiWJxDwbMK2UlgzWJDEqmTONXq5mq5au2O7waAiGWihdoLWFkaLMoa/SWwir6mi37XHZ9QRtA1+uVrsFWiV1GHMn/MJP3yN7N9F7fS+VZxzrKLXFK6HbXxi9No10biacBygbYd3Rs+Hh2nnjOled6pI9/55dXo0tgTtHQgfJ0EiNTpCO41zsnLAcjVDyD01TTt+L4D6xzjGl4svDx69lLIAoKtATEg8GQhs3pddtXeStMpgm4q1BnptMUUHuSl6BFUxr6HwPAs/WgRP66AcTwNg7fWCP3hI8FkqnsP9Hk4+TLhaxdogMA77prqZKmUgUlDznhcl6+qqm5jzPlJR+1aB7XgTCZlvVbObSG0dYDb7yNe8gSq3WRzSsh1MGvsWgFP5TQ9zm8jfFi60q2laZXpF1XW456tCHtG4JG0CNJx3OTfsS3ReTMiy2YYzo1XnU2Ue/TNOkrdyuBZ6v8TkO8Yxvm7x5v0pAOCzR/B9jGMc42dH/BIA3+m9/5Gv5k5fGnzTOoFQbzgcduAx1aF8jjYaMeiOi+XFPr5UGfN5giuqb589e4bJZIIsyxQcL5dLvP3226rkPTk5UTuVXq+Hi4sLAAKfr66usFwu4b3X4okshEgbkfl8rp7Ajx49AgC1VNhut3jvvfewXC7xTd/0TaoobZqmY99BWwkqvln0DxCFLhXMNzc3ahWy3+8V/NG6hPtksoGFFcfjMS4vLxUkJkmC8/Nz3Lp1C6vVShXUHEPC7FjBfH5+jqIoNIFA1TALZtI7nTCUj7RZIeCfTCZ6DulFHauCuRKAYDdNU0wmE1X9045lOBzi2bNncM6pSpxWJITytNHhsVhc88mTJ3pczk2qralQpxc5ATBtQA6La3L+cfziIq3z+Rzr9RpN02A+nysEpiUKbWDoGx/PJyqtY4sYJl4YtCHZ7XYdCx56djOB1Ov19DzShoW+92wvveEJgbkKg2puQupYwR8rpON+81qJPb5pwcP7ABMrhNr7/V4LxPK80ds7ttkhtKaXOlXpXM3A80X/bqre5/O5XrubzUbHg+dsNBppEoTX4Uc2jAFMC1ilSKDpAnAEeBaea+FjUJNyyTi3PQDk9Lv2iRErCQ/Y2onKFIBpEphv/iT+3LdP8Ef/wV/AH/zSr8GjzRSrood+WsMYURDnSUvh+mmFUVKi8ha9UNCyZ2sB4HDYmVwLYNL/GwByW+DB6Aq/cPAWft8nvh3p6+dA08D3UgWy3hrYqi3CCANY2i54UX8LWBZoYIJdQ91nh8XqJC08qkGw/ICMnUsFjtvSoX/jUQ8tmjyosm37WtI0SNelgmpThaSUQtPwxb0KHvcVujYQLmIUBAz0WQ0JDrGgiRS5MC3wDufQJ+LPbkLBMcdChGyFgmoB9zKHHEzlYBInUJ72IWp1wja6g8RKC8EV8qq3M+RnFk7sKMZNC/HZp8ToPuJirAYtcBXQJbDaBpsxAGK7Uftg/xJAEU9iDOtjq5JIxU1gHYNljmVHNd45n+han8RQmUrrYG3Sgc4ByquSWxXnaNvCsXJOi1J2jgsRYCI1MEUTKa8jpXfcRn/QP2MO1OkCg3guvQGM8eoT30m20O87rBRQKN80bT+DGtx40x2XYxzjKwTTXp6e0d50nvOQ1UMGgC8rYNUA2Q3whZ8EbubA7RPg1TvAcAxc3Jed9noCrvOgbi4dMDkR7+y6DrYYAZCmGZAPw7UEuf8mRjzAk0SU1UkKjEZAvycQPE1lH/tCHkfh9bICNhu5UEcDUTF7L9s5AL2d3Ad3O1FEN07U22kqSm8mRbPgOV6H91dNKGKdAMNMILwJhRz3JWC30jbWYSmqcJ8NtiFJKspzgmZC5yRYuSSZJAqynvzuHeQm6No28V6RpECO8BjGpgrjWpXAKnwGNnLmZD8E+U3XksaGxAIQEgdBnW57Mu7jSZvE8FZU72lY9eIWoX8yZ9A0ogTf7YDlHNhtYcoq2LlJEWfe+9E1ijvGMT5Q8ea9GQDgJ59tsK8a9LP35QJwjGMc4xgflHgHShu+evHS4Hs0GqliliAtVjonSaJQjUCVqlkAqlaNIVpchI+2GYSrhOGDwQDD4RDL5VK9vFerFS4vL7FcLlUJnOc5lsslhsMh3n77bYWiv+AX/AIsFgvc3Nyg3++rYpjqW0JWWiZQ6cp+3dzc4MmTJ3j11VcVPp+cnKgKdrPZYDgcqsKWClQAOg7s4+npKYDWU/n6+hrb7Vb7yDEhAAWA2Wym9hhpmuL+/fvY7/d44403MBwOcXFxoYCTkJBWLtfX12qbQisI7z1msxmKosBut9P2Um07m82wWq1UwUuoORqNsN/v1eqEYJLniEEoSWsP2l5Mp1OFvVRUb7dbTQ6cnZ1pG+PCijHwpu3KbrfDdrtV+5THjx+rdQqtPmI1+nA47CQkCIF5juLCjVT+xzY49Liez+eaAAG6KwmYoKASm2Cd54TWOXGygDYiVMDHXtu8lnit0SM8fn8Mh+lLz/HO87zjNR/Db/ab84KJDb6WpilOT08VZLP4LCAqbXrXxwU5+Rgnagi+Celpk8LnOF8I+blShP3lMbh/JlR6vZ6OPZ+j0pvq936//5FWfCugBoKfdBd6a4G5WKFKgMp9WKrD0IXl3rcKuigIUr0xcKmFdR4OOZBamPu38Xt+4a/Bf/z3/yz+1PwX4P93/QDz/QC9NCRyjABuG5TdqW3gnME03aGBRWaC3Ul4TE2DwqWY5XtULkFmG5xlG/zi8U/iD7/5C5G8cR+uLyDDZ0HZa434aDsPn0XWEwHQ2Vqgobcs4ijWJi4Tf3TToPVMt2JhYppQNNTKd+ymZ2BLIN3U8DYTCGDkvVqcEgCcgymraPA8TOPgI2/qthhapNarwz2L2yQHwNDH5z0qLkjo3Di1PGF7YAA4AxsgpLcmfOmX+43LrLDPYI3h+ilsWQu8tEnkuxrNEWNEzevbfz4C3wpDga6dCN8LhGXp5vnnvW/VkUzqRPYl3ga7k1CAEyGxYYoSvpfLWOcZfID14uUeAdsI2h8quDvKbPYlbr9FC9bj83Ggvo8hNh8Jx/k+9qNzTO81MdAB7NH7dXwAwBqdbzAmWBhQuR3D/edB+CGI9nGbrbzHxOcEaAuIOt+quENijXOR0FvnZnAvwMFYH+MYLwoCbk10hef4UxdPepi6hm88sFwD7z0Cdntg9y1y3+kPgOlZuE9XkAspQOpeLWA8rYBiJ0pqQK6tLBVIba1YfzThfkTwnQXY3e9LwccsKMCrGmjmgC8FyGYpsNkBixXUjzyVwtQoQsHLspD7YFFIEUsPUaWbJEB5rhRKo8QdVd4QSNwLgNsm8kFV1QLW0xRaVJhKazSA8cG+pSdt4DGMbVXphhYnVMYHn2wf7jPOH/iQmxamJ2lrFdM0MoYwsi/YNtkeg3gPqK93wgKedbhvJHKsrC/JBNhQiMMIoM9zGT/HZGeYQc7LWJQlsN0I+K6q4IYWfbZ2inoe4xgfvLgz7eF0mOFmW+HzT9b41ldnX+8mHeMYxzjGP058L4A/bIz5nd77L361dvrS4JvAigUcaVlAtbf3XuExVaBUMMdByAVAi/7FqlLCaHorA1DAfnp6iiRJcHl5qXB8uVxiPp9jtVqp4vrRo0e4dUuKO/zIj/yIekZTYToYDJBlmRbsJKzcbrcKqkejEd566y08fvwYgFgt3L9/H2dnZ7DW4vz8HPP5HJvNRsE5xyEuDsg2UdU6Ho9x584dVbrHinGCP6qIqYjmtmma4mMf+5j6ShdFoVD2+vpaC2iuVisMh0M9V7QRoX3EYrHoeEGvVitNVFC5S+UtExabzUZtQAgn6S9NhS3b6ZzTdvEYVGFT4f3kyROFylTy03s6jthCg8CU0JjQebfbqRI7SRLMZvKB3zSNvpdw+NBCI89zhep1XasFzWQy0dfoMf/w4UOs12s8e/YMALSt8TwfjUaq7mZCh/OLqx3ouU5gW9e12oewfUwkUZHOZELsPR6r1Gm7Mh6P1Q6E85B9JRDnz0yuUGlNRTjby/kc+2bH9kXz+Rx37tzRlRns82AwQJ7nHWsXay0mk4kqvXleuM/Y7388HmOz2ej1wrGezWaYz+f6XqrrqRYfjUa4f/++JgA+6opvqrFN5zkjQDss19XfdYPo59jSN/ysQL3x8GmkdjWmqwY3oYiiFlLM4T9xD7/zO/4FuOsb/Ly/+R5+xL8q3txZgVEi965eIvM7tzU+1r/BONmjcKLuqnyCnq1QuRQOBpVPsHcZamfxev8K/8TgLXxLXuBPfsOvgsvD506w9lBAZ8XuwRZBYWbaL7cuswJ9U9v6X1vpsw2bJ6WHrTxcJl+Ns61H3TMwDnCJqMWbHpdmC7y0dWSNAYHPAjjC9WmtANQA/9XSJEuC/Un7pdtUojw0TSq+3bAtfI2YOc+JN1bUd97DQNqnim8TQHhiVe3rEdrOFfVBsa6K7zRACRssU7gva0S1i6Aadq7re00IgvBzZOdhykjxHsPXSCWMJMAcQhogFHgLz5sItAZVs/HoWIHAGPg8g9kXUHsRawX48L3x/I8SPe0JiLaL5g4QwG4HlhyAXBb+TJNWUU3bknj/Edj28blvvJ5XTSiEdmrBT/qkx9C6icC5lfeaw9e9b8eS2yFMY2cAE8aLibEi9kl5gSAjtFHHP9gfGEASLz5SiR+Z0jFeOoyWGexeXc8nTXgbcwgfgnUDrBby5HYXrvsUOJ2J+nhxCVQFMBgBvQFQG2CyFShqHFCGvRJO570AmSsAjUDsPEWn6KJzchwqqD2k0KYLCcOykm36felDmkF9rQnP2b1eHxi7YAnCVTNJSFw2rf0J7UtoTeJcOE4AxGnd+ozvE2AZrEeyALDRAAjtDaJt9ILyexeORasRXW3SdP+pvzdPRNKCd+ehNi96jwwrdPTkRoCaRZKdaz87DJXlQaXuwz7qGlivgxJ9IO0sdkC5B9Yr8fEuC2C/k8eikHNfVbKvsD/LGcXEim9nnD96nRzjAxjGGLx5f4q/9YUrfPbR4gi+j3GMY3zowhhzg+4H7AjATxpjtpD1zxre+7P3c4yXBt+E0ZvNRgEaAd1gMFArCCpWCfUIzKheZVChSpV1URQKybKw9M5aq1Ymw+GwY51AqPrs2TNYa7Fer/HDP/zDuHfvHh48eKBq4LOzM4WH3nvkea5AbbVa4fT0VP21l8ulqljfffddfO5zn8P9+/fxyU9+EqPRCIPBQAswNk2jVhBUo282GzjnFLoT5NO6YTQaKQB+9uxZR2nMIpRJkqhalUrc7XaL2Wym/f74xz+ugHm5XKIsS1xdXXUsVth3Ko8JJtlXFoGkr/NsNsN+v8dut9MkAZXC9PVmUoIq2yzLFHADUHhKr27a0wCtDUrTNKiqCqenpwp5h8OhJj+2262OHeEvwSgh8mAwUKU8902FdFmWHRuek5MTLBYLHU+qqZumUUU0EzCcG/SmPj8/h/cel5eXuL6+xmq1wmKxUMU30HpPLxYLjEYj3VecCKEVCVdDxH73VEHHKx+YYKiqqpMIokIbaC1JWCCVSQACDdrbMLFA727uh4kUgnMmSGJP/n6/r20icKf/elysk2Ce9wIAGA6HCuu3263awRBKx0VGae2SZRkGgwE2m42ugmB/qDLn9cS5FkPvwWCg95wsy/Qe8FEMUesKKPThyyeBt6NCld/uPDoK8Ti0qGUM0w5Al/GQ5eXhe3BrndJCvKafwicG9nQMM+zjR37DHfzbf/XP4C+tfg6GtsRFKtfUyJZ4pzrDrXSFV9IbNDCofIq9z2DhsPcZXLCm2PtMfL2THb6z/x7+lU98N+zZCdxruQDe4MVsAncDAqCFtE2LRVKJnBjxrg5w1YaijRYCHC1BbkVbE8BWInwzwTHDpQYYBAsPI9sZL9tJ4UwZaxaoBCDgN7YIAYAqKHsjOND6aTt41ECSwIAABC0othBoTvsRqtqth0Hk8R3+trC1k+eCgtrUXr7oO0kGKIxAq+h1B9/9RVlNcO1aexKEtkU2Kj5LW8sNKrITC58kXUuQjgo7jEOA+B1A7lxriRJAu6nrFq6nUQIwMTBVrcpvVR57qFWITw5U1hGMbq0/omvAyTY+QUfN/JwSn3A5eu25go6RQl6OYtv96YoMXl9h3KmMr5mdiscGbTvo6Wuj1/UEmlYNScUo/ccB+IbHqtv3et+q9QnBDvuC7pjE/uSxqt4f1M08xjGej3Z+0c7kIK3b2dqi/YgDjMDNp0+kkOF8ITYh4wlw5wLYbYDLh8BqBYymwMmpgGfnBI7CAVsDpA1QZQK5h+Nwre3kBp/nQGeVWbgmXdEWWrRWtvMA9ntRcBsDTMZtMtRaIO8LgKdvNgCMx6JmrhpgH4B5XUN9xxuqotMWfBP402O8bFrbFXjZ16YU8H7vTmhbsCxxkHtoauXYLCRZ1Wg90W0XdDf0yq4CjJddYZAFJXYA5a6OwLZp2wpE/WlaJbp3QBXaxJ26YFPiHWCDAr4oBG5nGXCaArkRG5n9Vh4XN2Ktsl2Gx3U4D3sB4VUB4xrm7tsEYPg7SZN10YqbIwI/xgcl3rwXwPfD5U+/8TGOcYxjfPDie7/WB3hp8D2bzdSagbYaLJBHtSnhHtWtBGOAgLXRaKSK0VgtPh6PVb1KuLXdbuGcw3q9hnMOvV5PrVKyLMNsNlP4Su/r8XiMqqrUQgMAptOpWqL0+33s93tMJhNVmt/c3GA0GqlFBwD85E/+JBaLBWazGb7xG78Rk8kEt2/fxuXlpdosPHv2TJWysX/5drvFdDqVwU1TbLdbVcATfHIMb25uFAjneY6yLHFycoL1eo3r62t88pOf1GKJ0+kU4/EYp6en6ul9fX2NJ0+eqEc2jxtbYMTFQwmYaS9BdW9sUzOdTkGP6vV6rcpqjhe9yan0piUFgA6cpuKXfSbM3Gw2Cn1ZyJTK+MVioYpkqrI5pwiyAej7GYTrTBL0+32sVistssl+s415nmOxWOj8pF86kw69Xg/n5+c4OztT73rallAdH7eRyQLawRAgx0VB9/s9+v1+x8Od40MVPRXv9FgnVK7rWmF1rNiOx76qKn0v53FRFMjzXK1eeA4JreN9xb7qaZpivV5jPp/rOeZqAp4DJkZ4rdGyhsVCaZ0DCATP81xXWLDQJ6/v2Pec84LJiVjVz4TMbrfDYrHAfD7XOUvQv16vNUFHiP9RDJ+0wFe/TyrIg3yJMxHYdl1A/FwQjMmeAixHWxiQ7/VoQV2A32olYQDfy+CGMu/+wG/8bUgfXuPP/dCfRxXI16Ur8a29R8jgMbEGe++x9QZzl2NiqqD0tmhgkMDDGo8TW+NfeeOXInnlDtypWByZWiw9CH+Nb/ltpxBj44HMsFcwTuCnaQRUOyMw26UGTSb7camBS4LX907U1nVfLE+qgUFSATYVaOgDZPQBeBsC3Ma3kDeC3pqA8E7a0zhZmp/Ksnh/AE4VkpoWGqt/tTFtcUaexiryik6tqPJDAsCWDRwtbCj8LdtiwbBoEwoEAs53v/mzPQSbhLO07NDtQoFO7wWEA4FSBYBaN62akImJumlteyLls3Ee3olXvPcQD+k6qByNaYFNnsnzddOxUYltf2jF0elPHBzLePwju5y4KKR/rs++VV+bg/1ynwqsfYD5LhToY19pZ2I6gFxV24e2MYd9YILiwM+9q7KP2hwpv9sideF8BgsemZMGSKwmk3Rf0TlCYsVnnM9b064kYZ+PcYyXiOdnyovmTpSxMwEgk2jWochlP6z2sKGAo9px5EBWhUKVqViiGCP2IB6totsYaNFJFqW0pn3dBgU4izSikWu1rtv5bsIxrWmtR3gdex/uYwj2IqEfPBZ8m7CiIlrrchAse6hVBwF1XUsiwKQCtuMCmoTRSbhGU46Nlf4kwbaF7dHVJpHimypsWqMkoUgm+8SkLu1d2C+2PS546ZruWLGQJ4/hAS0Sany7TV3Lz6rorrvFNpk4KEt53TWILU0Ua3sfz6RjHOMDG5++Jwzgc48+uqKfYxzjGB/e8N7/p1/rY7w0+CZYoiKVYI9AMgaTVKUSCAPo2G2Mx2OFXQDUToEgkbCX8I/2CYSEWZbh7OwMg8FAleIE6YSOd+/e1ePyH9W1BIOEhFSc7vd7PH78GGVZ4t69ezg9PcWrr76qXty0WqAtB6F+VVXa7n6/r7COIC/Pc4WwhO2Ew9wHIDBxsVgoRL+5uVG7kuFwiMlkgsFgoN7Lb7/9Np4+fYpnz55hNBop6Fuv11rck1AXgCqcqVIm7CYUJzwFpChoDPZpq0KbjuFwqFA7VvXTJobA/OnTp3qe9/u9zh2qeTmvmASh3UisKE7TFIvFAkVRIE1TVQbHFh5MxlhrtZ8XFxd6rOl0qtYlRVHouSTU7vV6GI/HmE6nCqTX67XCf4L5six1/wB0fuZ5rp7pcbFPY4yq0KnS5nXBFRLOOZ0H7DfbScV7bE0TjzWhNhXsPC9UjY9GI21TbCsUJ7Go7Aeg13Rsc1IUhZ5D2gtRQU4/+sVioWNCNTeV+rQYouKeqxUI02l/wm0vLy8xnU5VsQ4IxKedz5MnTzShRIU5rU1YpJUK8Y9qGCqt9AkolPYG8GkAfBHkBJ7ncQS2ALp+ywk9lMN3T0JE68NzATLw+7sRr+imn4pPdC+BaTzq+2f4Z3/Jr4W/ugEANKsV/sp7/wC/4v7PBQD82Xf/LhJXIrMFgvMI+sZh7z1yYzA0Cf75138pklfvw48G4cssYZ0TS5aMBSYF3qvqtJehSa0APAgQN+HLtk8tfB5U3o34edc9C2eh6m6xfxAobnw73i4NdiLedJT06kfbeAGEMWxsXAvFAQGejQHKCr5upCgj0CoCD9W0NoKMVQOYyMubKmkvticmgF5nwn5oH6Ltkf8ZQgnIeXSJbX2lWXQxgHEfYK4hCOJ2FvAmJCAaKtBbGOWj/ceqaRbMNM5LodFojokqPVI3cwyDwtw0XgqDrrdAmra+6dbKeE5HAr5ZIC06P4d+2gqTIygubW7713nkvlzkwX0YVFwT+FA5eAjKO1YAoa8W7fg2rt0XEwBsB8G2a+eT7oPQKRpPbqP70O0QrSZojyPATZIS6k3fHIwdH9OkneNV+/eOj+G77vcYx/hyQfx4mJh6MZJ0ADw8HEFolgLTKTAeAZsCePep3BNvywpNZAOg54DhBBhPw6qHRFTQr35MwO3lM+DZ0wi2+gCBwz2mDMrv2VTgOYEyAWtdAfOV2G70+0Avl/emwTZl0AsrVDzgKlFXr9dyrY3GogQPSWQYuc/pvstK3ufD/b4IwNiivU8kQem93oji/VYOnE5kv1kuYJv3vSwTBbsx8odADSlMOQt2LDaRdq2WopZu6qDk9iGhlYjKO++1xTCpTHch6VWHJFwaCnNWheyj2EnCl6tcDGRckkza0kDOnc2CKr+UsRgOgNlEzs9yI0k+twdcKWrwupFjNuH8bTZyPnfr8HoN52ROOe/Vh9zFSf/nfjrGMT4Y8eZ9gu+lftc7xjGOcYwPSxhjpt77JX/+Sttyu59pvDT4JsyL/aaXy6VCNPoi0+4gVmcDUF9eWn2wgCSLEhIQUv3K9/joix/9kQkLCYOHwyFmsxl2ux2m02mneB7hKgC1YaHi1BiD2WymAC5JEpyenuLi4kIV2tvtFmdnZ2qdQDU1ASAh5XA4xPn5OdbrtYLRpmmwWq10fMbjMdI0xdnZGXa7He7cuYOrq6uOnQuVsoTB9+7dU4htjMFbb72Fuq7x+PFjPH78WOFmmqaqcidg7fV6WryQil5aZ1AdPR6PO7YfhMPcjzEGZ2dn6qtelqXaStDj+9DTuqoqVfYSKjORAbRqZZ5felyzkGZsaxN7NbM9tAVhAcu4uCMh8X6/x83NjfpK53mOW7duqUJ7v98ryCccPz8/x3A4VMi6XC5xdXWFJ0+e6KoB2sEA0BUGMZCmFQv7mqZpx+aE54YrHHiuCYOZMKAHOBM7nKM89nw+V/sQnlcmUqiwpr1Q7BEee41zPvP49MIHoH7vXHHB/hB683pkm3leAWgfmqbRVR6xl3tZljr29LFnwqiua5ycnCioj/tNm5XJZIKqqnBycgJjDEajEe7cuYPXXntNbXCur6/x8OHDl729/ewLL9+LbR0sMw6+pZnwuj5vBVZ34JP3AtBN+7u8OYDj8H0YCI8GoiKGk/chqGgjYC7qWquq2maYwd87QTqUe3S6O8Ov/q4HSB80wG6Pf/5bfwV8UcA3DUySwFc1TJ7BZKLKM5MR7CdSuH4mliWEdkaU5j4zrUAsKMBF0S3LptNtqZYjPjHqDW5qh6R2Iq7rJaiQIsm9WJc0rQq8HFO5DNgasKFf6d7JdpnpjmE0DqYmcAyqsiRAeFW6iWLN9AWG+F4Gz/tMGFs4J5YntG1J2gOZOgKRfExMC8TJVV0LHU3jYBoH10thGg9b1TKOiUXSOEmc5FZtRXxmYapwnAY67qaBjGuA28bVLYytgx9uOFemdpIo8b61ZwnQ3VujPuRIklZNSOgbw+MmKrZoguqyrmH2cg/xaaIqZTfuhza3YJvqPoW8LOIW9ke7EbUxCZ7Xh/MudKDrkW/tV/5rS1dJRG0JSkr1ZE/CuKOJ+twmPOSwVIQTzNv2MQbNzncfwzbexG0I+6kP2sFxpzK1c184AOxU74e2+cRK0oLjeDAGxzjGV44X4UbOv/hlGjlFYNxYue+kqSh81xtRcGtil2rmoGhW1XYitiNZLqA0zaB+/d4HVTNaNbGHbJv3IoUyAF/K+8pSQG0WADL/2URX9og6OViHFIXsO+sDiWuhN+8RLH7sXOhvrMAO/WeSk38LxIrzPJdjUtVN+6wklddgQuFLL23ME2hxSA9pJxXTrm5fM1bGM8tDH6M/GHhqPKI/HgD186YqXfdlAKTtPvRvl7BCqfFyn/EIhTYDRK9qwFcA6uhzNVLHV1Xr9x180mUEeU+N/0g6xjE+2PGJW2PkicWqqPHuzQ4fOxt+vZt0jGMc4xg/k7gxxtzz3j8FMMeLP4D5117ygtd+2nhp8D2dTjsAkmCbFgdFUajdxmazQb/fV9AHQBWfBHkxDKSqdDAYqNUJ1aJU4sbF8wjbYtuSfr+P09NTnJ2dqeITAE5OThTErVYrLYS42+0URMeFNHnc8XiM27dvK9gmhI3hK9vN59M0xXQ6VdU0rTqMMapep4KV6tcY7vE9PN50OsVwOFSQen19jcVioYpX771aiFAFDkAtXabTqSp5Y7DKZAUA9V/e7/cKSama5X6pFD4/P8fNzY3Cbm4fq32ZUKCinEr6uq6xWq1UAc/xoPqZiQvC0DzPsdlsOt7SBN6xJQsABeBUOdO2hJY5g8EANzc38N5jOp1qMUtAYG2cHOF8XiwWuLy8xKNHj/DOO+/g5uZGrTUIeKmwp0qbc5xjsF6vtT18pH0JVyDwfBAi87rhHObcYJKI48GxoBc3ATj/sY9Ua7OtTA5QPR9byvA5Wg4x6cRrGxAA7ZzDarVCnufqA87rgKtC9vs9vPdaJLTf76uNinNOVwXwHjGZTBSyTyYTBd3x/YOrIa6vr3WOnp6e4uTkBHfu3FFrGsag47f50YqOethHANoAsEZ9rI1HUNUaGLRFGI1HF14BXRjmBQAbLZaH1u7Eiu1Hq45Fq5AzgAsKbOM9bOVgK9cC2574oPpcfFRNLX6bKEqFaj589iDLAhCVL9XGOSnOmBo4KrlZ5DHYdMBaQSGhXT6zaucBB9hSvFB9ULT7xMIlBk1P7E28MbDew1I1BsAFKxexNZFkg618ANsWtpRCjyaAXQHPFiKhQ1DNBqW59zDeyhdxQOGLT6yAZIdWlUxQCmkXEgOzr8QvO4axh6rhyFrFBniq3tZVAOCqEhfbF5gAm7MEZift9qntzA2fWIXPPm2PawiXYyjqHIxvIby2KYan4XevimOB8i2choB8Al3vo4KXMkY+UoebkCSQ4qDBr53vo4r7cLxeNP8PftailvG24ZyY+JqJ930IeQ9fj7fx0fl+0eNhxADemtbrPHipd6D3Yfu+Qj/1fDoAihXd8+0GdPwP92/qbrHWTptf9PwxjvHThumwUxs+xLwJPuBeLIJsUSC/nsNsdig//wXUuz3ga+CNjwvQnc6A/lBg6OOHAsUbyIdaWYVkWwJMpu1XMe/lsykogwG0K0maJsD1fQCsW/GVbiq5Nxd7AbNpIorrJJGvcT4PViR1sKoKnt1ZgPJqKeIpaw/XvBVQXgY7FpOIjUmStKrq3kDA8GAgUHs0FjidZK1vN/sFAKUL0Dq0jSC4qkUxTsuUJtiEOAjonpzIvmonfuTGB6Ye7tG897DYZSg4jLBSSpb+pNBCl4D01zuB8FUjnyl5aHeWtox6w32FIp11BTSFtHcTzsF6Lqry1VLOS7mHdU24l9uwSsDBhAz+4e3tGMf4IEaWWHzyzhifebjEZx4uj+D7GMc4xoctvhvAdfj5l30tDvDS4Js2HQRRALTQHH2bgdbmgLYj3J5K7X6/31Gy0uuXthbD4RDr9VotJAjcYrUq7Uz4fqpqT09PteDkyckJAOj+m6bByckJttutQkiCP6pj7927h9dee029r6kqXy6X6vtclqX6NU+nU1xfX6silqCWfSa8o1dx7AVOD+y4UCj73+/38corr6jf9GKxwPX1NS4vL7HdbhWeAwJ9qdAmJCXIjwE1i/4tFgtV4/J9cQFNQmuea1panJycaEKDinsAnUKP9Jyu61oLejI5wTnAOUIQz/Yy2UHLGo4XCxYSnhLw018egCYvqK5n8oJK6PV6jaIosNlsVOXOedg0DU5PT1X9X9c1rq6ucHNzg0ePHuHhw4fqp77f70HveqBrI8P3nZyc4OTkBK+++qoWkyTwpgI6Lm5JIM2xZpKE5yhOHsXK/LgQKq8JJlMA6PM8VlmWmM1mukqB++Oc5FwAoH3ksa21ePLkCQCB4CwCy+QFYTbV7/T/Pj09VX96rtagBzjPU2z9UlWVWuBMJhOsVisFlLSz4bU6Go30+j5c1UD7nGNAv4v7A0AmxQxN62vs+cU0bEdwFau9DWG5DzA22mGAXKLQbYE7gEhxbuDop+yoHPVwqUVStkpdLSBoMvh+JrC3l6lVguF2WfTx5WhX0gToftDX0BdnbRCQhb47q4pvOA9bixrMwMKlAsAF1Ifm0QrCA7bySPceTW7gMgNvBIhnWwdbONhGEgu2FJW5LRpRnTfBbqUJx80As/dQn5m6adXNdR0KkaHrz83zUzcw1ogSvPFqKyHFJqE2IS8Mi9abOjGt2toECxP6g3sPU0OsRxoB0D5LYCoH30u6thk2KC2ZWAnKSCkY+fx8oQWKib3LuT+qmeM+E24TYodzAviuEpnRNPC9LIxfHeZn6FPRwPdSnXMmbluknFfQHoNhbae+KayCaGGyJEOs/tyhJ7FNyYsgeASsCfY7ViY6378MLNYx890xMaYL0uPtY5uXqN+dJFrUf/V5b1old7y6Q7d9UTs5dkeV9zG+SsGEpnkh+PZInEN/sYRNEjRf+hLqzQY4PRFLjf4AGE2AoQdWc2B5DS3MiAC+TSgQOZ7o55lcCxuB3/TEtom81jgplrlYCGwtdwFYBxBcFEC9k3t2vxKw3e9BrVGqUADSBuU5leg1wmu+vTchHLvy4l0OAwyCup2rZbIsWJqkAu/7PWA4ErsQG+xaTPhwM0E9XXnAeiBLQhLZy6BUEFhN/2zXtMmANAdmZ6IYv74RsIwGsKHYJXMEBgHWNzJ+ANpinsFP3OtJgHqCV7UcO00lUZ4kISEA+bDfhX0RfDe1nL+iAHZB3b1cAvuNWM7sdzBNiSQo5msYWf0WfSYcufcxPizx5r0pPvNwic8+WuJXfsvdr3dzjnGMYxzjpcN7/9+/6OevZrw0+D5U+dKaZLFYqHKbxfQIsGJv4LIsUdc1ptNpRzlNiNvr9dSSIi6audlsdH+0MKH6mArY1WqF09PTTtE++k6PRiOs12v1GTbGdKxMaCvBYo1UnFJ5vd1uMRqNtLjecDhUYLpardSz/PHjx53CfQxallD5ulgsMBqNQBuY8XgMYwz2+z1GoxEuLi5wcXGB09NTVFWlRSafPHmiHtgElSzqx/GNFbq0FxmPx6qopnfzfD5vJ0AA4rEfGM/xZrNRj2hCeB6bvtLcHhAPcUJVWsLwPcvlUoEnvdCZuOAKgljFHFto0Eqk1+spAI8BtPce19fXHcuVWFlOBfJisdA5w/mcpikmkwnG4zGAVkl9fX2NZ8+e4fr6GpvNRr2+mTDhuY2BLwBcXl7i7OwMb7zxBkajka4KoGKd/YzV67w2OCc4RrwGCI3ZV6C1s2ESiSCf/eY+4kKzcVFTJmBiZTkLaNLPnckIPvI6tdbqvKMHPdvEfgCS+GHBTyrdCdhvbm40uXFycoLVatWx42GigPeP7XarFjRJkmC9XuPs7AzD4RBnZ2d6jtfrNa6urrTg60c2Io6qT0VQyhy+zqGKFKlSGLOr2iQo53uMDeDc+e4q5ohX0hZFwF34gm4CJE9EJa3KXy8FJz2MAGkqxxEYfB0dJIa/LIaY2K7SPMBrnyXwTYB1iSjC0QBIIWpdCKCWooktaETtkO5pYZLAJ2JzAsj3eHh5zQcDctsIM7CNwH5bumCvEpIPBq3ilkkA+n17H5SDB+fCtwUcCelNVXfgLBXjsAY+Fx91T7jpoIBWkwo8fzxG7bvHjOGvj9pLkMkihhXa8eb2xkixSc4vVR/TNiQCqTEA5u9sM4FtDF7roHY8VCdTQR4pmv1yBVcUSMaSJENRAuOhgKEAl03jVbFPUN1RafORfr5AgNKHIDeA7gada6SzL+7HRucF7bnpjP2BqvtFgLsthBq9j8FrPfK27wD8+N54CLVfpD4/3A7hvMdq+6gN0t4XjOOL9nmE38f4xwr9dJBEP38LPxiYUDfXoEosTJrANbUosecL4J2H4v19+67Yk2zXkvQzARZ38GcAsyY8eg8tCsnnTBK8tI1AWRuSTfuiVWr7AHdZJIOJ+qJo958mQGOCmhoCfG0oxFiGFVDWBmsPJ9umGRCEJqIUN6KKzjIB0r2ebNMfAMMh0OvL71kuavc0EbsS1wQgnuvnKoBgEQLpY38IpBXQlNI/S7uWrFWBNwGKm/A+79U6SeXqjQuQ2rSQnzYqcaEQgvkUQO5D4tOGPzYCKDeA2qUUIdFQ7oPtSdnasZR7sTipCmlj+HtbC4aGuXRoKX+MY3zQ4837U+Dvi8/3MY5xjGN8mMIY83Nedlvv/T98P8d4afBNmBbbEhAAs2gloSIhNhXWANTSg6rh0GhVldKiIFYD06s5tmAYjUb6/t1uh5ubG/VAjgv/0faDgJPwll7C2+1WFblA6ztNwE3lKI/PmM/nuL6+Rr/fVzVtXdeqMs2yDOv1GgAUGBL2rddrTKdTsLAnFcZURU+nUyRJgtFohF6vh/l8rkX82Efui2pjFtrMskxVsFTRrtdrnJ6egoUfCTzPz881YcGkBRXEy+VSbSj6/b4mMAi6B4MBlstlx6Oa4044vVqt4L1XNT5tL9jXfr+P3W6nfvAsSEmYy0QFofLJyYlCZMJ2KsEBdMDvZrNR32qq2jmX6rpWuxI+T8Uw98XzfXV1pV7g+/1e1dkE0jwHVO83TYObmxs9BkE/38dEEYEz7WN4Xjlesdqb55rJFI4R0FrycMUC909rGV6PhNpM8rDd7Av3ERex5DVO9f3Dhw9xdnYGALi+vlYLnKqqMJvNdOx5bVF5Pp1O9fwAwHA41Pfx2ieIpxqeqwVY7JTX8Wq1QlEUWK/XoLUS59B8Pke/38dqtcJiscBut9PXPqphqI6igCqEN+j4chsgFKmMYGN4Dd6rWlptTOIvgT4CDgdKTxPA7+HxAbTgl++zrapVPYytVZDKdiIoShUCHipxg3enqWotBukD6JCfEwHHqRUWkSV6fCBYsFjTAYpJ0QD7Gmg8km2GepyhHkRgnOPXiCWILb0AdNt6fwM2eEkHUJLa51W0MWhUaJ+2QAQQUEuoGhcmdAhL2a281vgAyx0oEfbxSYgZ6mEb9PwHtZv3wfs5KMIjX24mKeAcDO1hkgTGO1li33SJgdrZOCOgXttzAEij/qrXdlzMkuMTfvY2qMl9sDUJ88MnCUyStO/t5a21QB3mmPFqHdNZFUGoRA/dzjyL2thRfSOMeVRU6hDQx9BcoX3UXz5/4LWvCYdD/h1dA6p4j8c0UuKLgt8+N87Gtf7ynetY2+6efy56r8w1hPnQ9k39vGPQHq8O0DZGfTnGMd5PKLQEPAR+++B/YrxFAvHi3w5zsY2qKmC5Ar70LvD3/gFw9y5w/1Xg4gxYzsXiI8+A/kjmb7UX5bAxEM8PgmsnkDt1UL8Vk4oft7UBOIfVO4tQpJJFLxF2472okKsqwPYCGI+B6SSyEnFBrVyG50qBvf1wnCZYgAx6wEj+VsMuWLD0h8Cg31qdZBlwci5FPvOBQPBeHzg5ldfKSo5hE4HJ8MFv2wNFJWrvJAdOxzImdYDweV/2AwC7jVzfxV5eZ8K78dKHxgEu2L4YK2NqrYyVsTIwsX+NMZEdSyYJCg6gA2CyFtrXlYzPYh6KbgYIX5XSlroENitgtQA2a2C/h/eNFLMEOvZNx1vSMT5s8el78r3rsw+P4PsYxzjGhy5+BLGa4cuHx9fa43uz2ajalnC2KAqFrVQZxxYMu91O4R0tJwjTCB4BAaar1Qp1XasVR1VV2O12CrwBqOKXtijcV6zsJFilApeQ+c6dOwCAxWKhhfuohqb9BZW7V1dXCrbX6zUGgwHOz8+x2WxwcXGh7X/69Clef/11PHv2TBXsQOstTLUsCzQSDLII59nZGejTXZalKrSpAl6tVthut+qhnWUZ6JvMIpIxhOW5mEwmOD09xe3bt1VdTjU94TQVsgDUXubp06cYDAZ4+vQp+v0+JpMJNpuNKunTNFU7EcJSKuDZX/aDQWsLqqPZVhYlNMaoVQ5hMPvKcd5ut2qvwddiZX2WZZ2CmRx3qvb5yATAcrnU80uVNdXV19fXuL6+VujKR8LrOGILEkLluq7xzjvv4OLiAp/61Kd0/sWJmNhOhhYsTFbEx4ltc7hygICeNjzb7RaTyUQTLM45rNdrVbBTbU3LEvpxM2nC/VFZTksjXj+0J2L/Dr3HY49wJgG4GmE4HGoijIkznp+4aG2cPKO3OJ9jEone/MvlEtvtFtPpVO1M6DnOdhG+f5QrmptGYFSngJwniPWt3yZfskbLgQHoei77Vs1NeEkPcAFfgDFBuWva/dKWwVB5572ocg0UDPskqPFqq9uSFVMdbowPX6yz4Hva6LG1+KE1rRUEl4gDCsBhjBTEDBYZftAD6gZu2BNICwHfVLoDATI6B1M1otpuGtiyQdoLVkE9C9cTxZnV4pBe/K35+yHANJI9MLVrrUX4Wrwt5264tyrcTEz33ABi4dGIutAcKqRN8NGOrYxUPR12FFlOqFI5VgTXwQvci/+pYVE371vFdt3A+FZtr5D8BaBVjhmeP5iHCpyZVIktOqg89Amo2FalpbWtEpye3qMhTL8nkAsABuOO+tiUlXjJ29Cn0H+F/s59eSjfCSaOYriLFyczDiF6rO4mNI4TOYdq7MPoQPEw/6NzjSayNfFe/M153UR9ixXlz1nHHKq/Y9X44fmN5o0mIazpjqOL9sHfLZ5X0R/jGP+44U3n25MP/5mmgfEV/G4Hv1gAo2Gw7ggFFZNg/SFvghaftIgSNQTd4TWPVn2sCanwmiEsZ2sO/zax0fXgoIUzEYCvcXr96rVjg4WJTQSmNxDf7n74+9sFIJ7nwSYla3/OciAL6u8kbftrEyDxbXuMbT9PtL4CuxBeT5JoH8GehPeu+B5qIuW2ZwIhJAxYsJIra/zhGMUQnGMffjF6kuT9TR39a9rCn4TfZSmPVSnbeNfWaThcpXKMY3zIguD7vfkOi22F2TD7OrfoGMc4xjFeOh58rQ/w0uCbKutYSUuoy3+EXoDAVCp5AahamMB2PB6r4jQGnFSssjAg1ayj0QgnJycYDAbq9btcLlU1SqUswR6tTqjG3e122iaCWSqR6VFMSMj9UUW9XC4xm83UA/vVV1/VPlKFenJyooDxUFlLZXFRFAph+Y9KWiqPx+Mx5vN5B3rT65qWGHykRUmWZaqcZsQFHgeDAU5PT3U8WUCS/WVfWQDy4uJCExxVVWEymehYsbgj1cyE3gD0PG23WwWPw+FQVdMcax4vLgBJuEp4Wte1qpTrusbNzY1aacxmMwXF7CstbXq9HqqqUqDL1/k8z+3NzY2e99lspvY2TBJcXV2pUpy2OGma6moAoPWzZ2KDljXr9Rpf+tKX8Nprr+HOnTvY7Xaa9ImvlbIssdvtOnOF9h4s9rparfRYZVkqcOZqBLaX0He73eqKC153vEaogqbtiXNO4XdstUKFOP3GaXcDQAuFsqjqfr9XL3uugOB1T3U+7W74OoMJFIJ4WuDECvDY45tJgpOTE0wmE4xGI5ydnWkih9YtvKd8pMG3gxaQ7NguGFH/yvdzsaSwLvoyG9svUJSrVhVooRXCozP6KRIXxhRAK3YXqigHQqHDsCEV3dweotIz9EmhXzi/RMfH9V5Ar/PwVHRTqRWpbH1ZtYNSlAGkG7EKsQG6B69wWydw/ZRsWoYjT4VhNh6mqJEUNZKgTrfjHsqzvhSydKHgpfNo+gnSXdMWtKxcq8C3AQo3vlVEE/o511Es40XqW6BVS1f182DVefX57qiYmQiIxbsBFHvYwCBcmyyJ4KxPjFih+FYdDYQ2Z2log9fzotedAzxvw/FxD1XmtFCpI0jL/YeCmTIeAeCnaIFu3HcqtLMUvpfB7Ev48JkCQFYMZCl8mqjKGd7DbvfiAx4D74aK9m5SRd/H48YKeQIiKu2T9vNYYbQ17YUSRwy54zkMdAA1FfjPQXWOPUX+BNABUJtD4H4Y8fUJSB8PgXfchhh+x2D9UOHO8/gVjnmMY3w1wx/85o0kbr1v4Ldyz+uZGplJUOWPsR9lwG4J/NgnRJWdJmJ7UpZA+P6C3kAUzakDegFA7wu5r+UBIBMKew9sdwHiWmAwASoHTLeinGYhSA95f5rKahRrZT/Wyr1wuxNAfXFLoPH1tbQnz4DRSCBz1heQPD6Ray9NpT3GyD4cAF+LEjrvAZNTgd+zUylwmeZA2pP3NWH0siEwyAQM73fS5vVWlNT0Am8csN1LP/KhKMB9SMqaoNx2DdBsRSWeBR/xxIrS3IQ/JrwXe5fVRvZVVACCIpzwWz9vmnbsWGg074ek4T5YmOxEyU1fb9rEwIj6/OkjsUCZ3wC7NWy5h0UjTbdWvL21yOXhXDrGMT74MRtkeOVkgPfmO3zu8RK/+I3zr3eTjnGMYxzjpcJ7//bX+hj2p9/kGMc4xjGOcYxjHOMYxzjGMT5cQaU36gamqpGUJbKiRLLdwixugPk1cHUNXN0IMB6Ogoq6FvBrrEDiLA+q6TSscLLB6iRri09aK0nJqgJgWnV1Hv7Zg69dxoqqO81bH2vvW/V5fyjtSdJgX2ZlP72e7DcLRSqnM2A8BYZj+TeeAdMTYDAMhS17sq/+UIBx3u+qvgnik1Se1+ectKWs2oQa21c3sl3eC7YoQZlNv2+PkNQFREWeCKzP+0BvJKtw8gFgUsnY1eFYTVBwywAFqO7apCQThfRXBwIQD/7dZRH8vKOEeV0D243YmxRiG2PqGhY+5CPtl08MHuMYH6J48/7R7uQYxzjGhz+MMf+SMeZvGWMeGmM+Hp77XmPMr3m/+3xpxTcLV8bexFRYUg2epil6vZ7aLGy3W1Xexurdpmm02CAtC6hopa0H7RNomzCdTlXZSXVolmVq80AVMhWnsS0GbR3m8znKssRyuVRbFaqWaWvCwphU4gKi7I49mzke0+kUV1dXeOWVV9Q3nLYOOsDB43m/3yPLMlW+0v96Mploe2PrhuVyifl8rspkeo7Ty7woClXMU/nL4/b7fWy3Wzx9+hTD4RAXFxeqbp5Op1iv16r4pR3FbrdTZTBtbXgs2nTEViVUR8fqanpX8zzRAiT2o2ahxVidSyUwvbabpsFisdBiobTJSZJElfy73a5TRJT7pN85FczxXB0Oh1oolXY3i8UCn//85/HgwQPMZjOMRiNVQNMHnv7tVBXTs5rK6rgf9JHfbDZ47733cHZ2pqsMaDXCeUCltjFGbU5otzMejzv2JLSDoYqaqmgWm6QiOi4KydUS3J7H5BixH7z+AFkFwXkU+21zbnLuU1HNAqa8Tngu2QdeXzwm+8pzxnN8enqqc4vjxb5ybg2HQ111wRUYp6enujKD1krr9bqj+D9GCIPWDxmixjax2jsOh07xRDi0lgTBFCX2RKZSuOMDHhTlXJrsrekeS5WsaJWz1ogHduOlgKKLbDdot5GlMMHvuxP8Apylne31OK4Bag+fpoAvYcKqBhaUND5XNbXPErg8Db7VFj610o7GdaxWTO1gjEVSOiS7Gi5P4LwUu1QbmGApYiqn6mbjXNSvyO6CfWhc628NwKeJFF6snXhXR2pvn4Qv/+qd7Fp1uRFo4E3wB++cU7HXkPskQrFC0yr9g5WFaXyr2k0j3+s0slejLQaLGgaltgGegwlsCxXpWpgzVgvHcCiyxRD7m2BjFCv7Yz9p79tzlGXqk06FN4yB76WtOr5uYIpKVN/xfGEYIypqY9BaEEThALX6oX2MMe3+D/vRGYxWzW2Cit3bdtuOVc5Bn7/iPqM2mroJgCqyu2nC+3iPte3YcH/PeekDrQqf1gdxYdLDAqCHPvZfrs3ed33Tj3GMr0oIPH3R9KoSA2eBuqng52sAOfDFL4qKefgtwMfuB6uM8PlIVTZX5KQG6CNA4SrYK4X5nqQCsb0Pr9UCc3s9+SzcNgKRkxTohRWT+71cM4TUaQb0gxJ7vw+rPAD0A3T3SVhVEmxG0gDA81ygN+/F3gObAI3TXgDeuXhx5/3Wx9vY9nOoqgGUQFnLZ4EL0N9YqPVJ40QB7r14aPumXcVkrajSvRegT1/xNNi97KXuk0LrooAW1ORnlwkAHYDWGOAYUBXPpVmNl9VcxT7Aeci/Jtib1JW0cbcTr/ZqL23YbeHqCuqsEtk0HdXex/gwx5v3pvhrn32Czx4LXB7jGMf4kIYx5ncB+LcA/HEAfxCtp/ccwPcC+P73s9+XpkODwUBtEACxKaBVBq1PWNSuaRoFZYTgLOLHonS00GDBQ++9gjn6QRNexZCPELLX66lVBoFkmqbqOU3bj9gaYr1eY7/fqx9yr9fT/dJChVCOhfhoFXJ9fa0+17PZTF8ry1Lbcnp6ivV6rfYlLLRHy5A0TTEejxXM0leZYP7Ro0dwzuHZs2dajPL09FRhJIEs+0av6yRJ1MIEgBaFpB83/bCbpsF4PFaLDSYjCBM5rq+88ooWSCTMrusaaZqi3+/rcwAUOALo2KAQPBO4EwgTPhO0cu7wXF9fX3f8pAeDgSZBCMHn8zmMMVo4dTwe6zkAoOCd1h9Am0jJsgzn5+cKsi8vLxVcv/baa2o/w/nAMWdb40d6f7PttGjZbrfo9/t47733cHp6ijfeeEMTHsYYHXsmZWJPaxZhZfs5z3a7nV4bPPdxIoKWOnxfv9/HycmJAu/NZqPJBl5ntKSJx5/FSPM870BvXkexnQktc5iw4LmiDQnPOe8XsUc5Exjsx3A41P4zeA0AbYFMjluv19PjAFA7GVr4DIfDjtf8Ry1oJ6FwOkBvBNhtXGtr8EJ4RhGVaW1K1OoEEEAa7RMI+wXk9xoq1GJhTHp9c1v6enqLFsiG54x3MEWjVi3GOZiiakGdMWrf4LMA6xL5Uu5zSbAgtjnx4Qu1D/6pjezDrzdQ71HvYAPg8FkKm2fwhN+phbchoZnI8VyeiEd55ZBsayS7Sv2TAcAWDWxRw+7bpJHPEjkn8ZjHX7gT21qVpEkXRAaga6uitaJQr2wjALdx+ppP0vacWcAlIUEZ22CE828qF6xCEAH1RIs1dqC6MW0bAQHynCNpoudLoeiBdYsBoAUzCZpjv+hDRSSPq/PQwgdbE0k+RIUyw9iaKsAmQOAQALMr5L39XKxQyrq7/9g+hYCc4xzZerQwmiDetipERiPFM82uCOc9jSx+7PNQOEm6xTV5hACrCcU7x9CNouuYCZVDOE9YXdVtciAG6SbavmlgwvWhcDveD+MQbsfnLj4nQHt+gfa4h0Uuj3GMr3rEhS75DFAmkG8/dQXcrKRg41tfBJZr4BveACYTAbINwr04E/BtaoG8JmkV2NhDdhDdx2gBWJTyOVRWAr59gLFlCYwyKU5ZlcB6LddELyqK2R9AQHFBhi/g22YIZv4BegeFdjYQcD47k880Fp0knKfSOu+JyrrXRyhG0L3v1bX0q6qDxVVQrSdpC/4b19q2FNvglQ3ZVxJU71TJ98LnRRaKfG634f4YbFOqMoBvqrl98FI3ek8DIGNubQD4YSyrIoxnEYp/VgHWowXfxV7+7bayXVnIz7uNCNI5KbzT+XKMY3yYgz7fnzuC72Mc4xgf3vjXAfx27/2fM8b8/uj5HwbwR97vTn9GskhjDKZTuaHSC5uQtd/vd+DeoaqU0IsgmapRQODXdrtFXdeqaiZQp6q2aRpVkFdVpXCVBf7YPsJNAkICTgL33W6nBS3ZVoJMgl4W+aNylrB2s9ng7OwMNzc3OD09VXhPVTM9pAmFB4MBJpMJdrsd7t+/j6ZpcH5+jrOzM4WZLKg4n88xn8+x3W5xeXmpwNU5h8lkAkCKVrKPVMazICDV3Awq5alm576urq5QlqWqzqnK3e12CgqfPHmCJElwenqKPM9VlUswTmC/2+2w2WxU8UsQzIKH0+kUq9WqozJmwoSwl/7k9D+nKriua0220P+dwDZWkMdzk3ODvtuEzEBbZJPnJU1TrNdr9Pt9bWNd15hMJiiKAicnJ3j06JEWZaS/N48NtACcSQEmJOq6xnq9xmw2w9XVFe7evYs0TbFcyh8hVIZba7WfbGeapthsNnpt0De8LEus12v1/D45OdGVBKPRSH3YCbdns5kC9t1u10mYEGQzaQQIiGbfuOKBIDr2y766utL2OOdwfn6u84ze7RwXzlXCal5v+/1e/f7pJ84x5Dzltc/iljxHLOZJFTzHnWr5sixVtc+k20cxxFMaHYDNWlwCvsJ23rcKX7Tb8z0KntHdH1/vQG9u60OhKA8F4TFXi2tIyXtbCC9e2VL40ThRV5sAtQkPTQwoga7i1Iva2NPLO8ukuGGDAO0I3yRxIwq2Rt/vjYMpSphC7pGWSnTvpVBilsKP+nCDDC63IQEQQQPnYYOnty2boFp3ChyN923JrioCr5GqmUDbJ0l7/pJECrI5C28y6UvdqBrXFC3kJ/zmufXGtKrkFwHRGIBHUFwV7ofKeu4jAEwWdiQoN1Tt0Z+bgJQAPAnQOgav3G+877goYpgbnjAkVvwZ0y3WWDcCWpoGvnEwY0my0cvdD3syXsbA7Ar4xRImz2GsFdW3811IG33OKPjXNkG85dme+HXf+s8rMH6RopyRJt3XIrDsE/v8vO8U0zwYx8NCmYRyMYA+nAs8H5yHTHi4+DFs9+WKfsZJlRhaxa9b28L/UMBW1anHOMbXMIyqwMN16BsYVwFVCV/uxQLj+gZ4+FiA82jcqo/LWmDtoB+usXBv5+oJD7QfiOFHFn+k97ZzApw9BKbTKqUXvKqTTACvCYpua4OFiAeKAHitA1IPNFnr511VABLZZ10Fm5HQlrwHjCbyGnj/DNvSl1vV1QhJq6btFwzEpiR8XjKDzT8oktAPSutNWBUErzBZX2OtC+ckgcDnjA2fdVa2J9AniAdCIc9w73K+TSA0tSQpimBvognlJry2B3YbYL8RD/Byr59zvgP9j8tOjvGzI745WJ18/skaVeOQxQnrYxzjGMf4cMQDAP/gBc8XAEbvd6cvDb5jWEfFNABV+BJyT6dTVX4SngEC9Lz3Cia5T0JjqmtXq5X+TiidZRlms5kW1IsL9lFdzkJ90+m0A+pYeC9JEvT7fVxfX3fAKCEcgTVV3ZvNRtXat27dwr179xRcUg0eg0VCVgJYAFo4kqB1Npvh7t27+NjHPoYkSfDkyRP8w3/4D/Huu+9isVgo+KY6m1Cdim0WDCTIpg0GizASElprcXJygs1mo30nHCfwPDk5wXg8VouW6XSK4XCI1WqF/X6vY8DnqPQlxOZ55HjxuISvvV4P+/1egTZV+VQms5CitbZj28ICnP1+XxXRBKoA1HaFinIACtvZFiqvi6JAv99XiMw5t9vtVNV9cnKC7XaLzWaDhw8fYjweg1Yd9+7dw3w+V1i/2+2w3W71uJzXLLZK6FuWpVrILJdL3Nzc4OzsTFc30EaGNidxUcskSXR1QV3X2Gw2WK/XqKoKu91OVf08Tyx6ulwu1WamKArc3NxgMBhoAojngCpxgnyO33w+V0uS3W6H6+trhc9UUcfjz2uMxyb85nXFaylOKnEO0SKH8ynLMqxWK0168d92u9VrbrVaqeo9hvGxbcxqtdJ5wr585MOJmlqANNq6euE7q4dp2dgh1H5BdOxNVOmJznPeiApaVeERQO9s7+N9RDshMONjrGpOMmBfdgEe38N/xoiCtgeYooIJRRE9IVxdy8DU4Zi0N2mcFPz0Tr6IVyUcVWNJAtQ1zHgk4rDEoh4kAj6joTIeAu0b11q17Eu14tDirtaqUrkDNZ0DbDsWPkuDLYj01/doM+FhEq/Lwr33rTVFDC9Na3Hire0Up/TOoXOWY+isAD7aF9BJLrRwVMZXi2IyYluMGIC66DzF23N+EIoCAeiKmt2zLdF51+cQRJAATJYKiC9KmNEQvi/3AZ4H+2wu6s2ggPb7AqhqmH6v2zYev0HXciQep3i8or6o8j4eC/bNu+77nBNrAKAFy3qdOel/KLJJQKXzhdcFf25cd7xDYvO5cx7D7w7ott1zHZ8zwnUfnRuuEND3RLYEhxFfszrfj7D7GF+riO9uIeEYMrGmdvC1h0WDBCWQAPVmDp8D+PEfBzY1cOcO8OabkpCa30gBxrPbwPkdmcvFXj4b0kx+RlA5N7Uoin0tANdYUW9PpgKhax8gbVh9lGbiu20MkPQESiMHfCoAvN+X7Z49A26ugoo62JokieyzagBbyLF7ees7zsKXJ7dCQc69AO2sBwxG0paScDokUsP9UJTkAcTbAKlZnNf69obbG8m40gbMO1Fxey+/u/AhqVZhwTcdTRgzwnMfFjI7sUfpD+Q9ZSn71KQbJAlRl8B6KcdazsW/O01lXBzk+bIAljfA4gpYL4D5FVCVMHUFA0hBS5sA3sGGe/QRfx/jwx6vng4w6aVYFTV+8tkan7o7/enfdIxjHOMYH6x4C8DPBfD2wfO/CsBn3+9OXxp8xzB3s9kobI6VmrPZDHmeoygKBVC3bt0CAFxeXqqtBsEVodpkMlFINRqN4JxTsEVIut/vMZlMMBwOcXl5qerb3W6nUL0oCuz3e7WPYPT7fd0/Yft+v1dISDU3PcpjWMf2ENaXZYnxeAx6PVM9TosIKnH5/izL1DJiNpthv9+rkvatt97CcrlU+JnnOfI8x2azQZIkuLm5UZU020+wSqhO73W+BoiieblcYrvdqp81Pcydczg9PVXFemz7EqvDCWjfffddnJycgNYiVMR779W2JU4yEHqWZalWOPShBlobEsJPtjvPc4Xi1loFx4TDhNEcT4LjOGILFgDqcU3faAAd1TkATKdTzOdzXQ0Qe3nfuXMHJycnqKoKjx8/xnq9xmAw0P7GViRcmUDbECZvNpsNnjx5gqIoMBwOkSQJlsulJjbYHj7yWuL1RfBdFAWWy6X2Y7PZaOKC1xoTD5y3seKatjaE61Tps518HxM0HMftdvucrcpkMlGAzf0ernbgvnhOmaihxzfnEmE1jx8D8O12q6s5VquVQvxYcR8nzph0oXI/ngsfybABVEeiz87PgEJRU7f2H0BQxoX3U42tdiRdnqD7IWRnqIrb+uf9uPmesA8Fi17a4JNEvbEVglsLJEHd61sIZ6iK1TZRoWoCaEzavsZQ0wSlabA6MWmrBhfInohwL1bWRlDZ1l68yBsvdiaNhylr2HA8NEEFT8/xWEkcQ1Iqt6mSdk48vWOv8sYLbHDoAmaqZQFVFxsC58Pxrprn4XQMn2MAGj8fez2z/x1FsesqgBXgR4rvGObG58C/eEw6CuZGEgmq9tbXLUxVd33LAZ0vbr2BPT9RNbxfrYGzE7jzKexiA5QVfFnCFwXMZNLu+0AFr/s8TAbxWmlcq+w+SOCYoOr3wfNWf4/6Z5yHJyCK7V54zCiZI+NxYCNy0B40TfdnQJImUZ0Gvab4GUoQbdGF0fHcOLSCQTRf2PZYKV/X3TGLx9La5197kY3LMY7xtQgvn3GSSvLwTQ1TFsBuD79cAtdXwHgs0DvNIF5RAGAEJhvTKrZZkNKEFUUmvI7w2Ut1dd6X5/oD2aYuRZ1tTADkRtTdJunuk/tSlTqTW4g+j9A+z+vfJW17856owk0RXcPh33P7du39QT8H4uyugQJrBBW2NQLOef8g1GeBSXtwr/ABhmviNGnbhNAmY6Er1KgEpyF3E/rZBFU3f7Y26kMT/NVLKXhZhfGu2/oYXz5M3JhjHONDFcYYfPreFH/3i9f47MPlEXwf4xjH+DDG/xXAf2CMCX884duMMb8JwP8BwL/6fnf60uCbgAuAAlKqcQkr+TytCmiPAbRFHpfLpSpzq6pSL2AACq2aplHwyQKLhKllWSp4LIoC2+1WrTvyPFe7FcJgglkCdFqjZFmG5XKp0JvexLTxoK0LlcRlWeLk5ARf/OIXMZ1O1VLl6upKCyWy7wSyo9FIwSiPf3l5ibfeegubzQY3NzdaMDRJEpycnCjcLMsSVVVhsVhgPB6rNznHmvsEoGpuwv6iKBR+AlCbEAJPQkKqiAl6e72eKqCXyyWePXumalpCUwJTKqMJytlf+q6zbfRkB9pikIAkIEajkUJ+9okAnnOE8yQuiMjkAPs7Ho9VIc55mec5JpOJrjjg/IptP5gQSNMUo9FI5/JisVCwfnJyovNoPp9jv9/j+voaADqJHgJpzossy7DZbGCt1Tl/7949PadU2sfFHjebjb53u93i0aNHqmRmIU6eU/p4M4HDa3O5XGI4HGI+n+t4cT7GwNta20nm0Kt+PB5js9moXQrHKh5rAOqBzueZkOE857jTm53jBEBtWThmTPxwX/v9Hs+ePVPYzznc6/Uwm83Q6/VwenqqdjVMxrGftM+h1/5HNlyAzmAxQQgMBuGpbKZe3wRfQNfbG5DvuSx+CDz/nTAoPw0tuAmjCaBNgOnhvWqHEh8fUN9uAKJQzlKYfQmqmvW1xMoxCFlDIuZFTUNQAAMpTF3DE2w7wmQC3iZYogQAbWWJuglLrk0u3t+mamDqBNmylLbXDnZbtFAzS+EHuUD6BsAgly/qoZCiqm8D2DZF2VXqpomMw74Q2Nk0MEm0dN0Y8dJOA2isgxrOAaZppP/h2npOuX8AZqXfrguaaWnx5Sxl4t+9B2Db98dzSfcfgdHD12LQHns+xyrmF0EKI2DCP2fVQrjikbxyF27UB3ahbsDZCUxVw2z3QF3DbbYw/T5gLHxZwtQNjK07KnKgncsvHCtuo8pGL+fMORjYTvLC7EtNSBheaJy7VR3B4wPI7Bz8aNA9/1Ut85rAinYCwd5FVeVJm/Th2Ho4WQVBK4F4TAmfD8c9hmCEbYc+5c5pksgYIyso4gRMrDqPwX50DR/jGF+9iOd2yKn67mvOSBLK1jX6X3oPNrtEsatQLecAKuDTnwKGIwHS/ZF8RiyuW5U2fb6LEgqDvRdoSysR2oEMxgJdp0tRMa9ugPU8AOBUtusFFXeShDoKRixOXFBBz05kv1nw6p6cifobARJnubTR+6DktkDaB2wuhYl7Ifm1KwC3lH4lafDC3oVrMgme3sFyBR5wwS7Mmxb698OgWgQuHgpLNrWAZhb1bBppa98ArpbX6yp8LgSoTquUJkDpMukW0fUOaIIXeHBiQV2FApyhzWlPjrVeC+RerUThvl4CmwXMbgMbVPoegLNBINXUgBhWtZPlGMf4kMeb91vw/Wv/ia93a45xjGMc42cW3vv/xBiTAvj3AAwB/GkA7wH433rv/8z73e9Lg2+qWQm2CKXpw0sw2Ov1VCU9Go3UfoOqz7qukec5er2eWmYwaI9AME0/Y/pP0z4DQAdycbuiKDCZTDAejxW2UhUOQOEalbqxfQuLI9IigRYfZVni6uoKg8EAo9EIr7/+uhYKpBKWylfuI1Z8EzZSjbter9Vnmz7Vs9lM+3N1ddVJANDChMdbr9c6Dnw/bWaocCVopBczC2PSD5mq69hr21qr7bhz5w5oCdI0jSrbJ5OJJgLiQoksVEhIzHNNBT59xKneJQyPPbNpr0LLEyZPqGhn/7fbrdpxEJRS4R/b48SFOQn74zbHFiBURFPNvN/v1aYlyzKcnp7qKgeqiQGo7Q7tPahy5r4J2p88eaKe3+fn5wCA+XyOs7MzHb/4vNA+h4kd/iNcBgQEs48sVhrbjzDpxG2YYOH8ZuKCPuHcnttxjqVp2gHmQOvlHieJOBe99xgOhyiKAuPxWBNi/Jl++1S30z5mPp8r1GfyiEr8OGJVP8ebqxPoR9/v93Hnzh2dlx/JoAUBOSvV295/WRsTbg+E77sBnMf7Mx4K0umrrPsjFFf7gwC1gxDOWate4KJcDpDMQ9XdxvmgboZ8Ufe+o2RWT+1YIRpDVCpTA7jzAQ6qxUeStEWvjG1VboC85gPYrGWpt7FZW6gstMMnRj20TVmLtUkVvrDXDYxzcMMekCUwVQOfWhjj4EHP1ugcATBl1cKKROC4L/cweSbHTBJ4NECeSZHNLLKvaLwcx3vZobdAHimoqeb3RqA7fbeBVhVOwMB9uqZVNdJLPJ4jYduO5zbP+QHUVqU2fZ3j+fkiFfWh9QUhf3x+XxCqmgeCmjjMmyaaJwzWIMgz+P0esKZNLBQhsc7ConG7YhE9IS7nZlnBp0lbaNMY+Z0+7nUDvy9g0qS7giB40fvGwa9WqvT2AWLbyUS2yTM5ZlEKuKkqGN8/UHGHuRyDb64GANpkT5rqtaXjpfsJQDoes3huxFYoQOcajFfZ+ShB4L0X0E01avy+6Njx+49xjP8pwhu5ZRrXIJ0vkcKiHvRRpQBu35KCibQMsSGButuKJ/cw1BBxiK65oPJmwWSqttNcrEWcEwhelYCvgXov9L0OCu9eLgktKp0bH+BxeN9gANhMYHbeE/iet3+b6fXZOHmvD/ug53eaSTvrUIwyC5DeNVIY0jVS+JKJX0MFNaDqcBhJGKc52hc8YJ1YogDBzqQSlbkqsYMNim/kONpGRKr1RvbV1O09yUPuW1Rr828EqrxdAPwmkTEtCxlf+n6X+/CvgG0kwVibJCTeo8//5+Ko+j7GhzfeZIHLx8uvc0uOcYxjfNjCGPO7APwuAK+Hpz4D4N/y3v+l8LoB8G8A+B0ATgH8EIB/zXv/mWgfPUgRyt8EYADgbwD4X3vv333JNpx47/8EgD9hjLkAYL33T8Nr3+C9/8L76dtLg2/6JlP9HENJFkWkKpj2I7QhAKD2GfR1ttZq0URaXXD/tJ+YTCbq+b1cLhXWEcbFhQYJP0ejEUajkSpTe72e7rdpGvT7fXjv8aUvfUkL4BFaUn3Lwnn7/V6L/lGhyjZfXV1pX3a7nULk1WqlSlbCPipmaXPC9lJ1SzXsfD7veGEPh0NVP69WK/W+pg82YePZ2ZlaRACt//NisXguyWCtxWKx0ARCDDWXyyV6vZ4qf+mJTnsYwvWiKDS5EftGM0FBcMz+EwTPZjP19Kb/dgyi0zTFYDDAbDZTRTSLJhJaA61CmckCwn/ui3Y1PD/9fl+TEpvNBnmeY7VaqRJ+vV7reMR9oA/248ePUVUVXnvttc4qBsJbJgIGg4Geeyqxr66uMJ/PMZ1OtR1cbbDdbjEej9XzO/ZrJ+Cm/zkV8UzyHK6e4JgSAhN6D4dDTRwQkFtrMZ/PNSFB1X68OoK2IbSg4dziXOI1faj4pvf9zc2N+sazeOlkMunsJ7ZK4TmmH/3NzY2uigCgRWaTJMF4PNYEQp7nuLm5URshzkl6s3+Uw7igiLXR78bAOtfC6ug7X8cDXFXYLcg04TuiwvD4O6H3QT4ncNywiBUgCmtnYKxX5SmtTUQR7vR3U0lBSG8tfD9Aay+qb9pDmCYCcwRskV2GCYUkdXtVhjcCCuMCWGkqX5KB9gswl12biHRmqYxlnsHnAia8tUBQwbeKWoEKdl/CDXNV0LlcVNy2kuSCy1MYE4F7a9sl6sZIQcYI9GqCgX7lIclgwOXtUKsZ07AgaUg8xCrlQ4UvIQmjaUGt2FU03fdFql+fxiQYbf95HlQRbF5ovaLnIFZ7A93zqc/Z59XIzolvelw4MoTvBV/vsr0H+FEfZrkFernYnoT4y2/9EH7FKz8PSZ4J/AGAXg+GPuBsJ68JByC1HbsSn6Wt5YkxMHsB6H4bEneTEf7vf/PP4F/7hu/GX3777+JXf/Mvw5/90b+Kh3WBH1h/M94tT/FffubnwTcGWb+GCdLUpk7Q1Bb3bs/x21//m/hF/S/i9/zcXwXfOLFyGfRlDgfw5hsnsCkev3DOTBqKwya29a2Px5QgCQcQ2nl5TwSuY5jt61r2FY01/b99OL7veLZH5yocX4sNHuMYX6t4wfSSzzQxPSkTi9pY1PstcHUFfPFt4Id+CDi7AL715wC3LoDlGlgsgLyA2nzAC3wuSgHlxgAZE4d5q/4e9OR+utuLJzd9thsAvHTU8sMEK5MEGAaw3c+ApgJMKgpuJuv0uSC9diE5TH9u78T/Wnos7aZMu3EC1uMVOY0ThXfi2lUdem2a9n1lEe6P4R5S19Iv50V9bRKxWzGNtGmzk7Y4C5hMILVvZH8mJAxUbW3a4s1cDeIhY1mLJY0oy3etpYn3cu/bbgV0r25Exb5ZAFtRgTvH/URz4MtOj+P96Bgf3vh0AN+ffbgErSmPcYxjHOMl410Avx8A4fK/DOD7jTE/L8Dt3wvgdwP4rQB+AsD/EcBfM8Z8k/d+Fd7zxwF8D4B/AcAVgD8K4AeMMT/fe/9lPBs78ReNMd/tvd977y/5pDHmmyAQ/dX307GXBt+xL3Nd17i5uVHQSHhN32JjjKp6qQJ+/PgxRqNRB3DTooMexYRv3F+SJOoBTDhI8Eb1MqE5YTGtSwhJAYFsg8FA91MUBU5PT3V7FqukCjv2PyYspqp6NBopkOdx0jTFcDhUdSoVwU3TYDqdwlqLp0+fot/vK0DmMQiVm6bBYrHA+fk53nvvPbU/ib2VCcPH4zEuLy9xdnaGy8tLhfJUVMcqWe+9KtTX67VCTLaRfsuj0ahjVUG4fuvWLaxWq06CgOp1Wt0w6rpW0Ller7FcLrHf79UShHY1hJMs1llVlaqR2Q/2lX0ZjUYdSxHamrCPnC+cS/Q2HwwGug8eh2NAj2l6fg8GA1Vfp2mKhw8f6rymdcw3fuM3qo1IVVVq60LlOFdGMEEQ+38/ffoU77zzDs7Pz+G9x9XVFfI8x3K5xGKxACB2J5xbVJ2v12uFwUwyca5SpU1IzT9wbt26pZCYSvLtdqtjxetwvV5rMub6+hr7/V6TKxzD6XSqY017Fl4bnJ/r9VqTO1TF0wrnEKizEOZ8PtcxIsDn/rjagasnYlU8EwhMErDfvK6YkIvvAR/VEACNFtKR6XofPKjRwj3n2++DquSNADXQ8f029Jy2oiz2tC2ohaCbuA1wStWND/sL9hwAItCOFjR6L3A5j1TELvoiDLRANXoPv8Qb11Vni4VIExXZDPsh4G4a6XdVigVGmraqZyPL0F2eBtW1VWW6WrUQYNPCpwiep7VDUlRSQHG7B9IEifPww37b9jwDXNIC1DwT/2prtGil2RVAncKUtlV+O0hb4AIADSAi9mU3wVLFuC7kdu3vCpAJ16n6jeHoC7446ftiQKxqaCngqR7WL4DnWgSSGRe2wbnW8iQu5BjDeu4jVqRbK/ujypBjC8Aut0BZwS1XYh/T68GOR/jVP++XI5kFiJOl8Ls9TJLAheQfshRmOBS4QuW1c+0qAu9b6EuQW1b4D//Hv4Df/vp3AQD+1N/7r/DZaoY3/rbFb/ipfwrP/vNz/M///m8GAKSJw9XNGG4j56msLWDl+vJOQPjDh2f4dxe/Eq+ezzH78zuc97b4bbf+Nv6NN34+7HAoXuXOt0mdKGljgl89jIFJcrEgSZN2fGiPAqgCXdXj0X4UTnuZF75uWisT9dgN57HyckxrWtUoV1hYo+Dch783OisvjnGMr3Yc5GoDvg2KaPlM2/fCfN1ugP0O2DfAxgF37wGf+ibg/BRYrYGrm1BA0cs9N0lEeV2UAl0NpCBlkgAmF5id9YDxRCDzYgWgEs/v4SRYVYX7ow2tdJB/WSpFMZMEcBO5vpEASINyO3hXZ1aegySZkViB8Wkq71kvRTHeGwS4bls1eFPJMU2wF6kaeS7YbKkaW0ct3JN3tEZx8qHehASs92LFkjjAV7K/ah/guxFrFQQLFd7TqXA3Ach7BHW3i+oUQF6vKulPU8t+vYPC/LIENmtgvwGWV8BuEyxlBP650A9WBDHw7Z8O/IvluPLkGD8L4pN3xkiswc22wuPlHvdmg693k45xjGN8SMJ7/xcOnvqDQQX+i40xnwXwvQD+z977/woAjDH/MoAnAP5FAP+RMWYG4LcB+Je89389bPObAbwD4J8G8Fdeohk3AP6cMeaf8d7XYR+fBvDfAPi+99u3lwbftOmgYpcKZ3rwAqJwpic0oTiBXp7nODk5wW63U7hNEMmfCbI2mw02mw2qqlLYTW9ntoWwjMpWwuO4cCDj/v37mE6nqlim0puWI7FNApW3tIOgupxqa4Jaehyz0CQV1wTvQGvZUFWVglaCxd1u1wHR3nucn59r0oBg+OzsTO0jWLQyTVNVOLMQIK0zACiYJ0gk7OXxCduttbi4uFAl/mQywXQ6VQsPnsfRaKTA9FBBz3MIQM8jleocQwA6jrdu3VJIytUD2+0Wg8FAoW2cUFmv1zg7O+sUnWQhVYJ+AArjCbq5PxZzZMFUtpfH4rnlagUqpIuiwO3bt7FarVQRTZ/3V155BQBwc3ODq6srXF5e6ooGoPWVp9p9u93i5OREPeSZ7GECiRZCy+US6/UaZVni+vpa1ejX19cK9eNECH3N49UPTFCwHywIyvHjeec1xIQSEwp1XWO5XGIwGKiNSOyfHfv581oCoCtAlsulJjiGwyGMMUjTFLdv38Z0OtXrMC5EyX6ykOdoNNL26Y0qJLpY8NM5p/ZHbMPp6akmddj+Y4QIbFStR4BQmLEFXgoaEb77eXQKUHZVue2jgmSuHE4MjDNqb6pe4h21lWmtPlywItEDR/tPBKT7LBS7tBALibiYYvwvhE9s67VM/2UA6OUwSQIfVhiIWjUC4YDAgkFfChI2TVh6bgQiW0g7aDfiEJR++xYUpMGXvJ8DlYdBLT7egNhYDEcwyw3Mvgh9tQp6Td3IcQH4QU+Aqj/oaxNgoaXaHO3rgABOH1T9rh1LDxtgT/TFPlifxKppKRgpUNSUVeh7BLcJTF1bcFJXFzBRQMCJtm16zlwEwZ2XpftMGjDUdz2oul+kWAdCYoBzJlJhE57H1hzRMcxQvgT6uhEIPBrJXGBBRgLgJAGchy/LoHymZQALTYrC2ldVB87/l//or2Box/g3v/B3AQD/qDzFn3ryS7Cs+lgWfWz2OZwzcI3Ysrgq7juTTNLuapXDDmrkeY13r06wn6VYVX38f7NfgJ/zPwCfHHwRI1ugbypM7A6vZ3P0w6SY2QS/4WPfDtQ1/vJbP4Rf9Q3fLskfn3WhkrEw/Z4km6oKJrHwvr0n0HqlO/hOttFVF6Y9b9bI9dSEc5nY9vpyNry9Ccc5Qu9jfG0j+hjS37vP8TPIwvtGYG5dCQCuCuDmBnj6TCDuZCrXOi01sl7w+kak2A7JuboGvAVKC+wy+b0Jdh7gvTQkrJjsAwRC27S9f+m/gw41wTok8cJ+ec+yFmoREq+o0eTV4YAwuWygfuEe4XMzAGlNUPn2eVVr6xui0bVos9uaaoDWJDA2QPDwu+d48F4Y3tPpe7gPuWCbwm2qStpU7ID9Fii24XEnyYZ47KJzzgdd6XaMY/wsiX6W4BO3RviJJ2t87tHyCL6PcYxjAMDkYPVH4b0vvtIbjDEJgF8PYATg7wB4AOAugL/Kbbz3hTHmvwfw7QD+IwA/H0B2sM1DY8yPhm1eBnz/OgB/DcCfNsb8RgDfDFF6/3+897/7Jd7/wnhpMlQUhdoiEGISEidJomCWamx6TBOKUvUaFzJkAUB6A7NQJVWghHWAKGFpk0BY1zSNwmpCMR4zhmGr1Ur9qZ1zGI/HmM/nCsxZ5HEwGCiMA6DWJ1TLEhoSXFIJvN1uO+CT78/zHNfX18jzHIvFQsH8arVSaweg9Wvmvqm4JfwnnKW6dbPZ4PT0VNWzhMfcH4uGUuELtODZGKM2I957VS+PRiNcXl6iKArcvXtXx6soClUGxwUnaaHS7/d1rDk3sizD66+/jpubGywWCwXUxhi1X6GynMUcaVVBCG2MwXw+B73GacFCxTNtZwDoPnhOOGd47tI0xc3NjSrQ+/2+zhuqqqkm5nmmcpgrDNbrtarwZ7MZAPEqH4/HGAwGuLq6AgD1Y2eCgONS17Uqy29ubpAkCZ49e6aJDo719fU15vO5JoFo9cNriGO92+00KUS193A4hPdegTATTLHqGoCeA87nuBAsC7JyDjL5wbkdFw9lWziHAHTGn8kg7o8Kbhb83G63mkyjNU+SJKpw5yoNjuvFxUUn2UU1PpNLLFLKJEG8GuGjGD72bnaIfhalLf/xOflCGz4QUxvZoXgRbR4UfTosgEnPZ1NH3zD1C3UIKxYkTU8U2baKvuzH7VSPVBOUw4BPCZ1TURADrbdzDPCB4C19oAbnY5aKTQMgIJNAL0073sRgYU4rYyEWJ/KaLWoB9kUpoLhxajdhernCAPpxm6IMBdAgUNw5+CysLJoNYdeFQPp9AORpIlD70N86bYtcmrIGsgQ+SkKYAAm8ent7wLfn0lsbJTPCI0E11cqJbb259bzZ57cnSPa+bQNV0C8oAKkRq7cRki/GSHmxWDke2qhe8i8oeBl7aitc96KY1/bG2wCwo6GA6kosOrx3MJlAKdPvw+/2QFVLcsSGIo1MgPCe4kIhRxZwy9LWOz7P8FbdwGKLnyhfAwCMbIknuwnefnKOJG3Q1AlcbSLAZLoe4h7wVVBlZnJe6jrBsF+icRZVk+Dt7RnuDxZ4rzzF0Ja4SFdIjMN108fEyjw6swZ/8d2/j1/9sV+IX/nxb4PJJdljer32uisr+CaC0CyQqvOE4Ct4AUtj5LERAOXLsHIgPndJ5EWv5z5SfzOc7/5+jGN8VYLzLtwrTKzqbbfywaojqTwMDBoKnEcVkNZAswX+4Y8Cj6+Bb/hG4Ju+GVgtgC98TjykhzPxxXZOlN8+2A25Gii3AHbANgGWSzlwVYVrwATf8EZ8w2tWbfTAcAqMx7JNVUfwNiSuEyuK5/0+rPLIxV7EJsCgH5TRAd73+sFyxYi63IT7NutlWNMF4TYNK21qSbwaIwpuY1vf7mDhJfsJQ+0a6bP3gA+KbkQKdXqkV1JMEllP7FvqWsbRGMBkXVssX7XKb8+inUHlTnju0dqZrG6Am4cCva+fCviuq/D3gWkLansPY7yi+kP7ky83h45xjA9TvHlvip94ssZnHy7x3Z+68/VuzjGOcYyvfxz6a/+bAP7QizY0xnwrBHT3AawB/HPe+88aY749bPLk4C1PAHw8/HwXQOm9v3nBNndfpqHe+70x5p8B8N8B+C8AfCeA/8x7/79/mfd/ufgZSSIJwQh6Y5sB/qPtBtD1jyawImgGoMpeKnAJxVlsjxCYAI9Qm6Cbz9Gug3YaMaijIpv2GcD/n70/D5Yty877sG/tc07OmXd8r14NXT0RDXZxMAhQkAlBpBxBijBJMByWZFMOKSia1BAULZuWTdm0wqJlUZJtkqb/EA0Gg4qgFKYsyeAIkAY4mEQ0CKIBiCAAVgPoqape1ZvuvXlzzjzD3tt/7P2tszPfq+5XjW50N16uiPdu3sw85+yz9z4nb/7Wt78VlLree3Q6HUwmE1Uvr1Yr9Ho9BewpdB+NRgpNqf4lrGZRwc1mo+pqAKqMvrm5wXq9VtBMVS8AbQeVtPTHpv0KwSQBIIHebrfD5eWlenDneY6rqysAUF9yqtIJKXu9nqplr6+vNXHAfXMsT09PcXp6qrCUFi9VVSnUJSzlmKXjOR6P0TQNttst5vO5ennTU3s8HitIZ//3ej0sFgtVpa9WK4WZTdNogdB+v4/RaKRzkX3C5Am9tQngOQdms5nOESrS08QKC2cSrjK50e/3dex2ux2Wy6Xa9xCgM/lBL3AmBni+qdKcSv66rjGdTvfALe1o+DpXMTDhlBZ25LnRYiX1f6fnOLdh/zRNg/l8rqsNOD+oHmdyhGpuADq/+TuTIEVRKFznMVkclOPEx7xm2VZeP1zxkFrd0G+90+moFQznNOfxZDLRxACTO/RKp1f/iw69AexBxABCIwBwvv2nFiO+LRwJKOyGY0FLKBhXj29AgWoKwH0ukMrvw88IJr2E/ZgEjhN8sh3wXotd+jwC/NwANvpXm6hcVmifKuKk/eKcqsAJTGmFUeTte9gOKs9FQlHMCJp9btp+FMDnBmbbwFRNq4LjPooiwNQ8C+2k0rysApAAgp1JY5OkAwLQbgDf62hBSfEm2KMQ+iIce89axfrg8y3SLjP3vk0g0A/8WYLavay/b33G4z7ExgKREYZqexvZV1bHn9LY0G8ckwOVduvR7pPxkAB8jITzlWTfUVneWpmIAnkhqKfa0Pv9n2ybieAonQ8iIclR1QFoZ0aP5ZsGPvpfB5W3g9vtQjvyInhqZxl8WcJFC63/5v4/wP/ktd+E73v7U3AA/s7mE/h/3f7TeFxO8GtGDwAAP7m7wKP5GHZZwHYNTEHrH98KJwu3fxomzOfBZIfdNq52qwp0iwbdrIERj8Zl2NgODDwKabBzBR7hBOdZ+Hv0sfUAGnz/Oz+KrhT43o/8JkgRfe0JoY1AkMFzVUJaADVVYqcJqqju9t7ve4rnyfgjFpA1yXxQW794fdtkf4eK8mMc46sSh3rv94m4zEk/75yFuKD49vNZ8NV+7XWg6ESFd1QfNw1gotWRMdGmhInEuDPaagER4nK5U7xu9DPMaTt0ZU266kpV0MnvVELrainahfhW3S3JZ6Jug2S/yU+hOjt+tunHRNyO+0RUq2vYZL9MUKafMUnbeRye416bOF7p57pr+42KcZ+0tamBchc8v8tthONRkX+4mkQCAn9K9X6wmugYx/hmjzdemeCv/PQDvPlw8eXffIxjHONFiNcALJPfv5Ta+xcAfBuAUwT19V8Qkd+SvH74ofk8f2x9yfeIyOTgKQ/gfwrgbwP4fgD/Z77He/8V3dieG3wTxNFPmArtbrerStOmaVRJTNUs4STtOgisCLcPi+tRFU5/b6BVohJsEUqmXsMEn4R3k0nouyzLVHW6Wq0UTqf+3VTEDofDPXBGgN3tdvfUq3meq7fzbrdT9TUVyNyOwJSKbAAKQ7fbrVqjUM1NaxQgqHK99+ofTV9jeqy/9NJLePLkCe7du6dJg8FgAKBVOnvvsVqFIl4sBklbCfYB90//9k6ngydPnijQJPwFoHCUiQKeKz20Ce6pvD05OVGQTVBdFIX6tt+9exf37t1TcA4A19fXuL29VasUjjPhbQp3mVTZbrdq40Hf69lsph7yVCGfnp6qXQutSNintCNhkcrFYqH9yeTMfD7HYrHAO++8AwC4uLjAK6+8gizLcHl5icePH2s/85wJ13kdXF1dYbvdqu86z51guixLLZbK86TFCVc6cIw5d6kaZxKFiRQmjGghwmQEFf+85tLkFK91AnFeQxxvrsZgO5mYOj09VY/0breLk5MThdTpsRaLhVoE3d7eYjqd6jGZ2FqtVpjP53vFMJlEExFst1sMh0NtN/uZKnBC+NQK50ULBd3e7303pae32AiXU/9mJ/pFVtAWpPOCdsm0LocOsFtV4UC7ohnY86aGEfic6mm0Fie2Bdx7XzqdD19kpROsTTphowBiCUeRFE9E4gOaqsXSE0+gPh8TePKwIgFUR/qo6uioOndF1kKA6Gku8fyk1w3nWeTBB1phrwnFNntd+G4BX2TwRQaTt97ZvpsF2Cp5tBnJAvSsmwhSgs+q73a0cGVoQxb6M4XdsW3irCrV9wuY7icDVLVPm4oDiCyExqlHd5FDvOjSfFqc7NmR0PaE/e39vj3NIXR3Psw978O+qQBPQucTpLUxSceZIJzzIcuCVQrPga/FcZXhAPZ2BlPkAXiXFaRTwJyeBNXzdov/9nN/D1e2QSHAqckxMj2826xwbQs8sSNsfBc/vpvg+97+FP7Tx78Nk3yH62qE23KAWdnHZ+d3AAC7Jke564RztALnMj0XyR0kc9pEMR6wEY4DyIxDt1dh2KvgvWDYqTDoX5xSAAEAAElEQVTu7DDMKuTGwohHz9RwMLDwWLsufrZ8GQAwNlucZhtc2dBX/9nn/i4+kg/wOz/y3w/+3EURwDXnk/etZU/q8Rv7OSjD43x1HlLkcFWNH7j/aXzvh//pZLAEYvKYSOGYxNecbxNPWZx3x8KWx/iqh3/fX13U/vrkeYckQSdAvl2j/8W34YdDbDsD2O0cGHTCfC5y4Pxu2HC1CoptE607nAtqaxdXD4kAMEGR7R2wW0VLpehNnXeB4SRcK/U2qKbzLmC67fYiYd8mJqUaF67PcdGeXBM/L3a7mNSi1Qj/8Z4rgGSAxLY2jTLp0Cmu7RiTR2iehX8mD7Yq3od9prC+dsCubDs0Jky1HgMtU/IivMe6YBHmXbvapamD0ty58LlnmwCynUsAPIKC3bnwudRYYLsCVlNgeQMsrgPwruv2syauTNIVUc+eIcc4xq+oYIHLzzxcfpl3HuMYx3hBYvm8wNh7X6EtbvmTIvJPAfhfAvi/xOfuAXiYbHIXrQr8EYCOiJwdqL7vAvgHX+KwMzz7o1kA/FsA/k208Dx7xvu+bHwgxTf9den7y2WtLGKZ+j/TeoOgbjweY7FYYDQaKQSnypXqTCqcaYuS2kVQWUw1Ku0nWEjx0OqC0I5WH/fv31eQlnobc/8snkeAzvYQDtOrmKCYgLXb7e4pp+lxDQCPHz/Ger3GdrtVxTl9q6maZ5FG+l0zqZDav5yfn+t5n5ycYDQaqQq92+1iPp9jMpmonzbHiiCTdh9VVe0p7ssyJHqomj8/P8dqtcJgMMByudQxom8yPapps1GWpSr9eczz83M457SgIgCdJ8vlEtPpVIHk22+/jX6/j7OzM/T7fYW3JycnWK/XCn6zLNPEB5XBVEmnc6NpGu279XqNLMuw3W73rFmY2CAIL8sSZVlqEuP09FTnF61uiqLAdDrFZDLBdrvd87VP522v18NkMtF5QysOPs9kyu3tLW5vbzEcDlXtzqQP5wPPkefGuUEQzPOkuptgncf13qtNymq1QlmWei0ygZS2n4kDjiUTJ6mlCN/LRBXHl7/TW/zi4gLn5+cYj8c4Pz/XebLb7VT5P5vNMJ1O8ejRI1WiG2NwfX2t9QBog8T2zOdzVX5zhcVhcoPXTKr4fxFDvG8LTioc/lIbBAC6J3qipQXQWoj4RECVuhNEhbF4hGMawCMBk1T5HiqPBQGcKgwPXqfCL8vWQnymx/NIVNQmfqGlIjgFqj74Zbe+z1QbJyphoW93eyKeBTjrsE+fJfsj6I8gXDKB73f2+sn3kuKHhNTOBeV09KuWOl433bhqQyQ8dq5NDHgqBqHjJ1Udi5blWliTcFucA3LZT2T4xDs9gnyqqwGE9iT71/4BWmCRzoEih+924ng7iE28v6O6XIF0Ou+433RycayS8XoaiCfJDbZFYkIljqsqv12yvQkJCZ37PCe21Rj4qgbKEr4sg5/7roQZj4JlzXaHP/2zfxNv1af4q+tXsbQ9/Lreffyc62NmB5jZVzG3A3xucxf9rMIvLu7C+mA/UmQWy7KLqslQ1jk6eZhHm10HdpMHaCYeafFKADC5127ICwtnPbq9GnfGK9Q2w6hTorQ5jHicdLa421vhNN+gMBajbIcMHjtXYIcCRjxs7Mdf2L2Mk3yDQizu5TMYcUCzwf/niz+Ckenhe17/jRAW6OO8YdjWG58WKD/49qcVEDo4zF0FA2DlBH/97R/H937su9rtOd702s+y/X2nNkMH8/AYx/hqhv+Sjw5+j5w6q0p0N1fAcoXqzh1YY4EHEyAbAOcXwCffCEnOzTaoi7McqpK2vCchePWLhOKSzgZoXdVhFVNmwvO9QYC8sIAl5D4ortyJXuJ1DTRluI93OxF2b4LKuYn2JCYLCnUTT8YnH9YSAbSYFh4L4ldIqsmT5LBEcE7LI8L9mEQPPv4ufCYxiZZaX/G9PHYW7UmaOibW0NbZiAm1YJtio7VK1X6+CPeRh75y8XOq2gHbZQDgm2WE57ZVhevnjHvm2D8dier8GMf4Jg2C77du1liVDUbdY92jYxzjGF9xCIAugC8igO3fBuAfAYCIdAD8FgD/XnzvTwGo43v+m/ielwH8WgB/5Esc43/wtWh4Gh+ouCUAtWEgoD0scEdVJpW5jFSVTQXpoZc3gSpV0QSUBHJUsXY6HVhrFaTREoVKZlprAFDleNqeoiiw3W5VFUr/coJo/s7tqTJPASTfR+Da7XZxcXGxZ2PC16hw3+12aJoGNzc3T1miEHayMCcBOz2kU+9MqrsJXE9OTnB6eopHjx4BgPqre+9Vccsio1RvE5zSVoJjw/4VEX2uqiqMx2OF/MPhEL1eD9PpdM9SoqoqLV46n8+1T1kok2r+09NT7VPu6+TkBGVZYrPZqPqeEJkJD/Y77TOGwyEAKADtdrt6Xun4sw2EplRgc78cK64S4EoAvs4+5mqFFPi+++67WigVACaTCVarFUajEYbDoSY+aNNB5XY6t6jm58oCjgcTNATLaXu5YoGJByaK6FnOJAxtReiJnxY6pTc4x5V9xXHj+R4mS7iig3N0MpnoeZyfn+P09BQnJye4vLzEeDxGlmV46623UNe1Jj+WyyWePHmC6+trAMB0Ot0rlDqbzVShDwCLxULH4qWXXsJ6vdbEGBX/LK5JCyPOjxcxfPTtlEOY5P0zFicJnorkOV36zaeogk63MwiKbusjgE3eG/eXWnZI41SJLqnaMzeAy+F98GAWn0FKq1+kCXLF+hZ4M6hYJfCkgjku8yb0lsZG+5T9ZLEquBMAG+C1B73PwzkEWO+6OUxlW4U2z5Xq68bq/qSsFdT7Ilfld+g7getkEBv6TYyH97EtEgpE0rPbF1mwN/EeXqKKrXFROevCcQ9z4ITgtDE5VNkTDBBSqKI8AhcTB5/q9RRo101MIJi2X4F9X21r94+X9rkRCAc3Bf1xnCDSqs2TApu6osC5xJYjjoEmL5LxAFprAmvhdzu49Qb/5f0fxb/6+nfDdLvBwmS5gtvu8APLX4dPzz+CXVPg8WaEx1e/Hb/rjZ/FuunisrvCk3KMedUDMMCm7sCIRx2LNq7LcH9vmkwTKU2dAeIhffZLGOe8Y2EyB+cE8AKTORSFxeVojX5e47Szxc7m2DQdnHR2yI3Fvd4SRhw+0X+Eteti4zoYmBIWBhkcnBfMXbj3DbISK9vDdT1C1nd4NZ9hQMbkXVC6Ow8pYnIlTVg4B28dvLX4oXd/Ck/sGj9VdXAvK/GFeoKZG2DnCpxnK+x8gW/vPsEPfuHHAAC/49VvD0VekwLDnl69xgBZFuZ3liXX6LP8eI5xjF+eaD/ewv3eAtjl8bq9vkax28H6Ag5ZgKyXF0B/GNTTwxOgqoDtFq0NCBNvPnplR+UyP1/qGihpLRUPnncCtJYsQN8s2189w2tTk4tooXBRhG09InRvws+8CSpyrqSCRKgezbmzqMD2LLqZtW3n3/d1azcFIKrTq7btVHfzMZ+3FurNzeOx3SZ+TsKF/TNJ6X14TvslHpMrypqoUq9KYDENFieLafD53q0h8T7jIa3QXdXezzsbjsD7GN/8cTnq4qVJF48XJX7h0QLf8eHzr3eTjnGMY3wThIj8xwD+JoD7AMYAfg+Afw7A93jvvYj8aQB/VEQ+C+CzAP4ogA2AvwgA3vu5iPx5AH9SRG4ATAH8CQA/i2Bb8szw3v/9r9U5MT5Qccu6rtV2gTAvVY9SZUnPa6BV+9K+hMCNMI3wjKCbUJ0/RQSj0WjP2oIQrt/vYz6fo6oqVQwT9BGg9fv9vePyeAR4zjksFgtVBV9cXKj9CqE7gTiLUKYK35ubG9R1rR7gLMoIBNuOm5sbVFWF5XKJxWKhxSIJQgnnCGR7vR5ub2+1P5lgYJtYmJDnt91u1arj7t2w9JIWKlTI0l8ZgBYWZD/SqoRwtSxLPH78GE3TYDKZKHSfTqc6roTOJycnCusBKNhn0oB+4oS2r7zyihZsZJ+zGOTV1ZXahKTWJv1+X/cHQKFrWqyRc4QFU+lLTXhMy5nBYKDjTDuS3W6Hoih07my3W9y5c2fPgoZAmYpmJg9ub29R1zUePXqEq6sr9Ho9DIdDnJ2d6TxMEwof+tCH8MUvfhHWWpydnek50D+dEDn1kOdP+pKzL2gpw+uN85UqfiaoAGg/EJLTvoarAnitpR72TH7sdjsdX86fdFUE/cX7/b7anaSFNplcsdbi8ePHmE6nWCwWuLq6wmw20z7nior0/kJvcM5V2iqt12v0+/09IM9rBgDOz8/1mnmhg6Klveek/WLK3yWxvEjV3PT3jt87CX0FAoqw9RjWB/hqI5SmSpnHT4AqfZq9AOIipKcKuQ5gTESC7QcAyQ28aWmubKsIct3TFidpEcaD8/SZUVDbKpITgG/Q+mRTdZ5FpVvsD4JdLwAyA5+5AG4jGJCK9iRhmbvPsgDro283sgxoLHy3gMvDvlwRfhrvw7m68A3fG/ojhwSG75hWgZtH6G1bpXBQwoVfVAXOF6mIdm7PcsQT/qdABQg+5CxWShhRNwE48LoijI5KdmTBQsRnvu1ja1tVdhpJcoHFNNuVCS5MDHMwVxsbkhUxibIX1sZ+gxYu3QNGQGhDlgUAW9f4oXd/Cu82Pnh0v/7dwGwOMx7hz33mh/BH7n8v3l2eonEGs1UfYjyuyxE2TQdr28Gq7kaPbQMjHuuqAxGPXZ2jaWJi1AmaqLR0tYF0gvLRFA7eCgbDEtYaFLmNvEiQG4e7oxWKzGKQV1g1XZRNjiKzMOKQG4dhXuI8X6PyOXpS47TYYOcKWB/aAgADCZ8DFgaFWJxkG/y63n0U4rDzQM87GDT4G+/9d/gdr30HfN0EC5PUKxiAtxbf/86P4t2mwc9VF3invsBbu0u8sz1H5TI4L3ilP8fdzhI7X+AjRUhk/uV3P42u5PidH/5OQIwWzhQmWEAxpmnVnkfF9zG+jiHxHwXKTSZYFxkEDt1330HHe5SLJarFDLj3GnB6DpycA2d3gNNTYHoF3FyFJE5/FO/1Tbt6popqaPp3b8tQkDHLgW43wute/GySoCL3OdDptJ9r8TMrFDlGUDC7qIDO8/ZeH5YNAYj36yYqxTebuH0vKsJNsG2hEl2V1RngotrauVhc04X2FZ24r3X8DMjaBKeuViLIjsprGEDiaii1qIrn2cTCz0xi+vi3BJXhe5YqCJ8DVROOf/VuUHjfPACWN5CyDCujgPD5KQbibbstjkj7GC9WfPLlCR4vrvDmw+URfB/jGMd43ngJwH8J4GUAcwA/gwC9/1Z8/f8KoA/gzwA4A/DjAP55733qq/SHATQIiu8+gL8D4F/z3lu8T4jIrwfwc957Fx+/b3jvf+YrObHnJkNUaKfKz1TpTYjMx1QM8z0EUfQuttYq5KMVAxXdaeE+AlkAalPS7Xb18WazwUsvvaRQdrfb4bXXXlM7DdqEEGASKhKwEWiuViucnZ1hvV6rYpxFJlO/ZVo10Abk8vJSCzVeXV3BWov33nsPQIBx2+1W7THYd7RV6Xa7GI1Gqk6m7zltKQimHzx4gNPTUwW+w+EQo9EIm80G/X5fbVZSG4xOp4OzszMFjyxsSesSAKqQpjULldm0pSDQJFBNbUE2mw1GoxFGo5EmPjabjar1D4snnp6e4uzsDNvtFuPxGBcXF3v73Ww2WrATwFN2I4TABNf00Aag/UdrEM4jAve0+CoV11Sb3717V5M43nsFt1SN04eeiZnUfqcoCgXui8UCn/vc53D37l2cnZ0ptF2tVphMJjg/P8d6vcZ6vdbriCsj6DtP6ExrFBHBer3Wc0w9vnu9niZ0eO6pVQ7byEQLkwhpgUkWAU37Ju0zJqaY/AGgSnCfQIo8zzEYDPScCdS997i5udHzurm5wdtvv43ZbKZWNkwqUWHPlQC8b3BuseAp7x3j8XgPbKfe9ZzL6SqJFzUItL1IYIDOqQrcZwKxLUT19OCOoYpsj+D3nXg4SwMgBzxEbVWAAL3Fu+iTKhEQR79sF8G6CJAJTGkh1sPlBobFLIsAwqSqEwDtA2jPWhDKL7eq9gXCF2q28RCMRtDt8+xpaKrLstGqvuOSbN/JW4gbIbD6jOcChxymtpBN2apZqSyv6nYOGgN0ou1KnoVzjG3PdgFWqK1HBN0BBCCquBMlromAnbYt3kPcAeSlGpqAWc/BtKve+f74Pj1+YyHR83vPE5zn54JSWPI8LpNPwKWP3rlZMpEYh8mW1LoE2Ffsp9sQ+kRPdrU4EQGsg+fy+pgE8c4H+M22qTVOPF6eA6Mhfqqs8BenvxmlK/D6j+VYNx041Ph9n/2Xsao6qtbOcweRBp+bXWK17eJ8tIH1gm5mA+xucmzKAlnm0DQZ8tyirjOYzMHEQrCu0xauNOLhjMA5gbUGxng4J5gMdqiaDNebAe4M18jFoWxybJsC3bzBqChxWmxxWSzxUj5Hz9TYuC6WtoedL1C6AkYcCrEYmPA5kcGhRoaPdK7xoDnDh/IpnAA77zAworYlAQxJa3niAmj6a/f/IT5Xe/x0+WFcNWP8w9nHsKq7uN31UTU5RDw2TQcP8hMUYlH7cE8ey31cZDV+8O1P43e8+u3wNoMYgXM+WJ74tpBsGBv/9DV7jGN83SKog/l3Tvj7yEPKHcxyDt8fwt88iYnAbgDF1gFFt92eK2g4z3Wu8/5G1E61dAKR4y6Cetu17+XvzsbnTHjT3jbpip64YqZu2s/Kvfs12vuyR8zoxhUYHtj334/30rhqRkE86wDQ2kX3gxZua7fyDUj6x++3xcdsux43C4lQWi9VZWtrslsHD/C6BJoa3tk9K3CO4xF6H+NFjTdenuDv/cIV3nzwXLa+xzjGMY4B7/3v/zKvewB/LP57v/fsAPwv4r/njZ9G8A5/Eh/HP2Se3j2+1h7fVDkTUtJPmtCRcDKFViwUCEDtFwhUCclT0EpoBUAhOT18WUCSVhy0KhmNRlitVqriZrHC1Ff64uJCX2ebU6sNFi9k0UaqT6mApjc0iwKenp6iaRoMBgMMBgMF5vP5XNXKABSK0sKhLEtVyHe7XbW8IIQnbKS1Bj2OCd7pYUx/dSYjJpPJnqq7qipMJhPkea79R5uJ3W6H4XCo/UfbFFqF0NqCxToJfukxTsU3Vezee1XiUxlMBTwLYbIf+F7OCfqdsy3n5+fqeX2oUOa8okqaABRo7UxY1JAWIoTwbB8jTXqwnZwbtB1J/aFpwXN6eoqrqyt9bTweK6geDocYDod47733kOc5Xn/9dfT7fXzsYx8DAIW9KVhOQTMtVLiSgAmg1EeffQO0yQ22jSpuFsZk0iT15k77KC1cyfenxURpj0LLHLaD23IFBwvYcl70ej2UZakFUm9vb3Fzc6MQ/+bmRm2TqqrS/ub9gkkGzhEel23hSgDuI+03JsKY9ErvJy9aqIIbCKCwSZTP0varz5Mv5PnBV8ZMnoZR/AiK8Fvg977XSlQhe6p1RYI1B19P9udyA98z0S4kgvPGtX7g3kN2VSgYmRtIbSFl06q2WbQwnhehMTIDFMnY88t0pwjHqYMCz+e0QGkV0HvQNbadKmrtCw9kuwauCMDebOvQpqoO/dvvttsDrSo9y4InLMckggjZ2dbjPCYpYKA+4wEqYB9YpDYvEpXldbOXnOBrVNinVjMADlSEyTlr8qBV1HsfYLJvGkhU5CsIJ/zwLbRhUVBItCXxyTxLgWfsi722UgHeviPph6iwV0Di2/61VIlb+EZU+a1gHAhAxwTA+0c/+p343W9e4W9dvYEmenSv6g52dY7aBisO5wXdokYl/JvGY7HrBuTUK5GJRxUV3nWdwzmB94KmySIIf/rvNecMnA3Qm0NljIfzgjxzGHYqPFmNsGvaz6DGGVQueHxnCMUsl7YPC4OdLzBvBihdjq5pUIjFdT0GAIyzHXYuvP5SMcd5tsI5KgxMBus9LCx+6L1/BOsdfsdr3wFYix949yexcuHz8DNVhreaO/hvH/3GYLlSd3C9HGK37kAyjyxzsE5w2t/h7d1F8BCP8aHiBnfMBn/+nU9hKAZdyVFI6Kvf9ep3BOVoTOQi+aw7xjG+HsGZS5wM5+CrChCDqggWJMVygf5qAXtzhbKu4McnwLf8BuDOa8DkBLj7alA5z28DoLXRh9rEQsQigCnCfSjvAt1YwHGzCa8NJRS1ZEusD2poMS0UJ/gWE0C7RO9rxM9ArriidN0CKJvQBtqhcN/OgkWFg52XAMiDOts3QMVkawG1Gam2iXe3b1XaLvpzI56jfp6axJLKA74OP8sAq9vt0nt6hN+InuLeBkuTagdMHwMP3wLKNXD7GKh3wPIW2EaRiGGCIFqvpLg7/Xzaf+UYx/gVGW+8Eiw8P/PwCL6PcYxjfMPHRwFcJY+/6vHc4JuwmMUol8slLi8v9yBkalFRliXG47EqVEVEwW+qBqcClUCPit1ut6sKz1Sxm9qW0EqCKnAWyFsul2ohQosSbkNglx6L7aPfMf2SCVS5DeEiEGDocDiE9x7D4VCVvY8ePdL90++cylmC26Io1NOZ7UoLXRKCUwnLJEBd1+ohTYg8n89VSZ6C9Pl8rlCXCmYCboLS1OKDHt5UB9PGhNCTkHO322E2m2lyYTAY6NhNJhNVj1NRzMej0QhZlmmCYLPZ6Dke+pezr6lIp2UG5xZVxQrv4ntomUEgzblFyMv5S7sY9gmPyaQMEx20GLm9vVWofHZ2htVqBQB71iC0frm+vsb19TV6vR5ef/11OOfUjme73apymm1JvcjZzzwfJo5Go5GeW5pkoE0KbXZoKcLXmLihfQx/8h+TRBwH7perDjh2vD4YTN4QgBPI93o9jEYjtUCi8p72Pw8fPoQxZm8FxbMsiTi2/X5f28H7AD3TqRjneTKRxvMkKH9Rg4BZvIeHRHV3Czm9AFHb3Np2pLCc453Jfq41/abovSq7kWznc1FALlRxuadhOCT4VqfHM7UNwJegOap6AcAXGaQKHtliXVBOP8tGg/eFCHvFecA2Cm8D+DQJ6UjAtyYLTPDEptLaBegJAGIbSGmRVQnIJcyl0pn9t93B817V7QQ4nmWQ2rVKcxGID/BA1eT0cI1+3goZgHDORWI3IsEWRo/LvgEUkEsdPF6F4xUmSTseKVRn0LIFCCrdeH2ppQiwX5xQQYhE9b2JKu1M1d2h/+JP5zX5wL5XNTfblarEUxubNBR4R4W8mGB90jR78yeMuQWQAd7BjMf4N05+Cj909WuwqroobYbGZijrAs4JsszpmK8XPciJR13lQKdBt2hQ2wxWgh97+Ad4J6jqYEPQ2Db54mJBUzEekjlkuYvd4SECdIsadZPBGIdV2YX3gmXZ0eKYtctwsxuiYxrcLZaYNiPsfIGV7aEQCwfBykYrOMmwaMJn8qLpoWsanORbXDdjfKRzhY3PcOo9MiPIkeG3v/Jt7XhHtWhXckxdBSDDz21fQ24sdmUfq7KDqsrhncBbA3SAqsmxrjr4wvICizocdz4YoPYZptkGr+S3GEqDgVQoBBibDH/53U9jYDr47a98G0yvF+ZO8dx/jh7jGL8M4cMtUhychPsY6hJZtYMXA7l+BL/bApc3QHcE9PqhAGVNtbQL11OapBPC5aiqlmhCzSKPqn7m+xBX9nhmyFrwbbxaaul7U9U09wUboHaO1jaFkNwDYdkXks/2uD/ui89JSCqGz5RESZ2qttPtJTnPFGqzTyz3RYX6Yffzbw8Jj20sdllugp93tQ2Po9pbledG2r48xjFe8GCBy59/tIB14XP/GMc4xjG+EcN7//azHn8147m/aaQqUCpiUxXvZDLZg8qpYhYIcJLbsiAlPXpZAJLPr1YrBWaEnykY5k9aXxDgEbS5BISs12uMx2M9BwYBHKGq914B+UsvvaRFNsuyVMuT4XCI6+tr9b+m3QSBJtuSelyn6lQqytO+IVynuj0F1ewPWobQNzm1wKCVxXg8xuPHjwEEJTLV2lRqd7tdLSDJY6Ye0hy/sizVeib1TTfGYLvdarsI6AGo+p9+0YTe3Me9e/eQ5zmur68xn8/Vnzq1yyE8TT3j2U6g9UCnnzuLaALQsSdMZRuYbGC/p4VP07lDQM5kAB9zGyrWU0sXznEeg/YkPO+yLPHWW29hNBqhrmudI8YYrFYrnJyc7CV8gNYyiAkSYwzG47EmdtJVAhwHJjHG47Fa7HBeZFmGfr+vYJ5ziCsdCPoJwjkuvF5pH5QmGdg3BPSp3zzvDyysWVUVZrMZrq+vsVqttPArr+U0+TIcDnW1AY/DuczzoYc8rwEWt6XHOeE4felfZMW3KofjYzi0BSi9D/7TwJ5vdXjuAIAefnc8+JuZvt9PvR6/FEtyLyaMp/2JtgcepgrXuTcGIm4fZjsHqW0L46ki5hJohvetr7MP0ALOtfA3ggefZ8FHHDZAAKrhCSbiNsFDPO6/g1Cfmp7bdQOUETBH727f7bR2HEUWrFGqOigHvW/V7pmBOAcfybfUtgXd/GfYUb61X6HKm4CQ743jmVqC+Hj9CPuHfuGpqtYlUCaFzNy3d639SDrEEuyUfFLYuAXoEZ5GX2egCEpxtg/JlOJ+E+X5ntc3gUq0XdlrZ/qewy9ytO1wPvq2UxEef3biddHtwEAwKXZYlOE+vN51QiHKGE1j4DoG3UENaw1cXN6w2XWiBUqwKeE/2xh4H6CRdwI0BPsIoMqE570B6jrDYFBi0KlRNcEvuyw7MMZHwWYB363Q79SY73oYd0ssqj42/Q7OAfSkRm0ybGwX86aP0uVYNj1c7UZoYqHNTmZxp7tC7TMUYrHzBXY+Q40a1vt2kUf00P+h9/4RNs5i6iq82/SxcKEw5pPNGNfLIaqygKtNSG54gbeCclcgNw4r01WP8U1T4L3dKV7tzfBScYFxtkVPatzL5zjPNhhKhXPf4Pvf/Yf4Fz/y3cFffE/lf4xj/PKEJoCRqIAFeqMS72GqEjA1rDHY9QaA98geP4S5vYXt9OHnV8DmVwE5C0xmQNEPq4X0MyVd6RLBb1x9FJJxCN7VFsHzu9sJr5W7cC/TJLQJ/8QAzTaqwfN4Dfu27U38HM0l/PMSCwXHZGDmg4e3FqnkZ10dimy6Jt7/EbbxiBZaTQvfqRT3gvCHgEugv0db5DMq2/Xun36mJKCcf7Pl3dCGcgPMrqPS+z1gswBuHgKL66CoX80D9GaSUwH7++Trj0rvY7xg8ZGLIfpFhm1t8cXrNX7V3dHXu0nHOMYxjvHMEJHf/bzv9d7/ta/kGM8NvglFqbru9XoYDAaqkCZcY6FE2jgQjvInFZxpUT3CYFqOUEFOexRC7uFwqD7HhOIsdHd7e6sAfblcqvI4Pc5gMEDTNKoS5XlRyW2M2QOCLIZIlTShGwD1kKZlBm1OUj/k1WqFxWKB+XyusA4IanEAur9UDX5ycrLXl48ePVJ1bQqFy7LEcrlEv9/HYDDAZrNREMz9ErbyfFmUkup7AKraXSwWGI/HGI/H+j72CZXg9Fnm/jn+bBMQrGXG4zGKosDp6SkA4OrqSm1HqNRN5xJBKoP9xDlENTDHhf3P4xKgcr7Q5oP9xpUFqVc4lcFMNtBTPLVr4WN6cq/Xa1Ur87iLxULnL9s6m8325gP3d3t7i+FwiPF4rGNAf2y2k7Yn3D8V7oT33N96vdZrxRiD2Wy2p8xnIoBto9qbc34+n2ubmTjgHOHvKexmMLFDdTbnD5XjTEzkeY7lconNZoO6rvH48WMt7noIpZmkSZ+jNQsTAzxPXoe89sqyxHw+V7V3p9NBWZYYDAY6/17oIPDWpcwI6u/mGV/9VJGWRAqyJfkJtApe124XbC0S4J0UyBQfjg1BVJ9Dtyd8V1U1IXHTQIo8AIE8AF3xsYCkbVqFV9pYa7U4455imMUqgfjFXJ6tCqNyTPtAgvpbpLUcofpOBChyuEEW1MvRnzs8zoB+NwDgqg7HzrKkMGW0ETmA0rR98SKQPCr86qSddTh/382DYj4dN4X+LUAOKmo8BbA1CIjTaOx+33kfiqSxiGTab6outO3+sgzeSVCKR3sSLYiaJAG8tMcQgv1DxaJNzi89BxusVqQoAoSPqnQqvoPSEPqZLZmBt63HPazF7/qW78Y/+w8f4vPzC6ind2HR69SwzsBag6oMfyY5IzASVN9Z7mIz41h5gW2yFnrXJlxv8ZoL6kwJXSQC5z1Mx2K3K8K2NgBz5wSAQ13lMJnDtuygthmMeFgnyMXh4e4EAPBSscB1PUbpcjQuw201wKru4vFqhH4RPkOsF8x2fUy6O/yak4ewSZbKUWlpgv+2bxpY75CJYOkMLARvlq/iH09fxYObkwDyCfSdACbUBfBe0DiDxhmUNtZmEI/S5lg0PWxtgdpn6Gc11k0XH+5f406+DEpwU+IH3/40ftfHv+v95+cxjvHLEMq6pf2ptyfbQCzguj1UnS5M06CY3oSkXq8Du50BWQGcvhKU36NJgOAdE6Bz3QC+TD4/4/2toVo6Xpf04i46YXtfBzsga5V3Q3JAOiHpS9uvoojw27SwmolbQ+U5E8rRTsz6/SKVPvqGWwAdF9rJz0sL0Pc/WJO4AJsBhGIfmkGDqrm1V/mZy0LUz1KcRqhv8nDf7vSATj9A+U308755BCynwPImAu8qtJ37ZRyA7+Nd5RgvcmRG8K33xvjp+zN85uHiCL6PcYxjfCPHX3nO93l8rT2+WaCRSk8CLoLLoihwc3OD8XiM1KqBVidUlhJYUf1KeEdQS7g5m83Ut5pgDYB6a7No5OnpKXa7nQJV2lDwuFR8p7YhbMNwOMR6vVZrhG63i9lshtPTUwWjALRI5OPHj9Hr9XB2dqb7oKXCbrfDZrPBdrvFbDYDEHydF4uFqrNT/28qifVLeXyNim9aWNDmgtDTWquFKieTCeq6Vs91KsupyqUSPs9zVUlPJhPMZrM9aMrxIWgl8N9sNhiPxxgOh5jP52qDQisaFuc8Pz8HEKxOCHcXiwUeP36sALTf7yvMJMQn8CbcpXXFfkEhpxCXUPNQFczVAZ1ORxMPHFPCbCqCU4sdJltojwJA/c05RgT9TKxwrDnHmqZBp9PZUzTT+obzKF0pwbnA62OxWKCqKp1TBL1N02C9Xivop10Izz21kXHOYbkMhXQJuLmagnCb87nT6WCz2eytlCBIph0L+5Hgu9Pp6LVAqx+q8Tn/ab8DQBNYNzc3ePDgAdbrNa6vr7Fer3UFQ6fTUYU/r3HOD45RmqBi4ox9CWDP25+JOWut2urQ7uhFjNS2RC09EnVv6qsMifBZDkDwgerNpxoqDzz1ldL7Vj1nWhuT9HWfZXv+1gD2LFj22gkE2AoAVQ2ppbXw2Fs6jqcUy9I848uwWm241naF8PrwfT4UwkSeFBsjzPd+rx2+CDDbZyZ8DLsAFXyWBTDSKYK/eLcT4H2RheKU+53ZngfQJiwsWg/yNKyF2Kc/83XcbfDnFlrBSCwmmdpJOA+pG/gijgfV8c7BNzYAe/rKauHI6PvN8aNK0Hl4a9ul+PH+5k0dZkSetbOHtjDO7S8g4JhS9Z3Oiczsj/fh60IpfoQseWsFI3ycKr+dhytL/J5//EX8V+99J1a7rvpz28ZgB6CucjS7HJ1hBdtk6HUrNE0KqE38iQCuUzBs9ocV8bVgOeCC/ZALKkcWuaxWHWQ9C2eDB7j3GerawPXrmHfIMBUoXF40PTQ+w6rpoHEZPntzB0VuMV8OcFu3gNsUDrNBD3d6KzzqnWJoSpy6CsZYdEPlWnhn8Dfe++9Q+gYbX+PKDbFxXfzk/CPY1oU6Drgm2jhkSeJKPKw16OUNTjohqd/LGpx3NijEop8Ftfy66WJaDTCrP4SXe3NMOyMMTIk3is/CVTVMb78WxzGO8csZPnmgq0Ml/K3m+bqzMHUF8R4uy8Oqns0m3Pa7b8N3RwF6v/6rgP4QqExi+xT+llPFdJYD3V60LanidVXElTEZUEYlMw/uY8JJQtJpT6VtMrD2Brzdvz8SUnsAaMJnVFWFk6vr1l+bqmv93PcBeHPFmGcGOwHrHlGJHm2keI/lfZh2L7aJim8gfO2MQFwyhJ3Hez7bud2E969mwNW7oYjl4gbYLoKXd10FpfeeRws/G/bH8wi+j/GixxuvTPDT92d48+EC3/vfe+Xr3ZxjHOMYx3hmeL+3hvxrEs8NvgmVCAvp6UvPab5WVZXCydFotGcvQtjGfaXFHKmupbVCVVVqI0LwRoVur9dTa5B+v4/79+9jt9uhqiqMRiMMh0NMJsHXqtfrKWAnIKPi2lqL5XIJEcFoNNLtD4tfEtjdu3cPvV4PIqKQm8UZm6ZR7+GbmxsAwO3trQJJWkAQllL1y34hBBwMBntWKGnb8zzHarVSC4vUmiOF6rRpWSwWqihmuwlOCW+5j36/j7t372rSgp7JtL+4vLyEtVZhvrVWVc1U1lprVTFPNS7HkftlAoRKcvqG0/qERTUJr5moSAtm0iaHoLXX62m/sj85l9LH6biygCbnIdXGqWc9/3G7pmnU5oRBxf9qtdK2c+UAASwhPBMK6/V6z0qFc4X+2Cmg3+12WC6X6o9OmCsiWriU/u9pMoMrHnq9nvqDA+FLHC160tUWBOic21R/U4VO4M39ighub2/1GgYCDCecd85hOp3i5uZGVzwQwNOeh8kKJgU4/kxY0M4kvQ4Ym81GPf6ZhBsOh6r4B9qVFS9i7Nmb2FZ1/SUj/YYoeOobY+r/rVYqHtFfOYGSz4pYcErbkEDo9Eu6lNH3k57VEXhK2QBF3tqdEFr7qC5OijfqPtU2pPWG9nkCi/X1pN1UdFvbWobQtlvVbNGfm1A5y1rm6j2kakJ72c4iD4pm78PS9sYpAAcAqZqoZA/9IIQNXva8vaWxAV6bALBVOc7l8s4FD/N47qp4T57bU737A492F5R6XoFKfF/TwKsa2ylUD16qVFXH87VWEwQegDRN+OkcYA6SEcYEgJP6kxOKp9DGvM/fQVFZ6K1r25WGGEiRqSc5KkCsha8bwFr8F5/7u/gX3/xX8Gg6gUR7kZD7EZTbIvhylwa+LxiPttiWQZ1dFBZNY2AbAzEB+rZQKo5V3B9sksgIkyi81wKuyuCzANol85DMw9UGkjs4fc6h3uUwhUNTC5aui21VYFMXGHYqvDxYAACudiMMuxUePDoLanMW1RTAlh7LVYEfbz6Mu90l7uUzLF2BsWmwciW+//6PoS8dhd6fq3u4X1/gQX2KymUo6zww+yaeH1cCdSxM5pHlDsNehUFRYZCHe28/Cz8n+Q6ly4MPuQiGeYWbcoBpNUQhFhYT/IPODf7G/Z/A7/zwdz57nI9xjK9hHIJRQVi15BEsiSACy1osTY3cNnAmQ9PtASLIb6fIb67QTKdo3v0icHkP6BbA+R2gyQFngPEYuHsnHGC7jp72neC53TTBtsMDML2g6LY1sCoDxLYRSrsMah0ChHteUyF8+LAgpWthuCBcr7YJdl6ZA2wWFeCbsApJ61Og9f5WhbaHFojUTjKx+GYJVCzaLEGpzc9tMeHcIIDbBUBdV8GuRAzgs/jZkcUaGhZwdbifl2Vo7/UDYPoQWC+Aq3eCj/d2ATRlsH7ZbgHvIC74jbdJC39Ueh/jGAfxRvT5fvPB4uvckmMc4xjH+OAhIq8BeOC9d1/2zV8mnht8L5dLtceg9QXVnmmhSVppEDASTs7ncwWkBLDD4VDBFdWd3CdtMQCoNzGh96NHj+C9x2QyUUhOf+/DgoYsAHl+fo6zszP1W2ahPGutFuKjXQItPAjoqT4dj8dqt0A1LwEuASTQqs0JfZfLpcJoYwxOT0/hvcd4PFbPaeecqpMJLgkVeRwCXnods1joeDzGZrPBxcUFAOwV/iNQJignZOa+B4OBHrPb7aLX6yloBVooT1hKeL9ardTmhqB/Npuh2+1iuVxq4iGF3UVRaN/TDoPWHCxkmhZXJOykxc3exI3WMJwfQAvAOe5MCrBvUw9qKq4Je3ksnmtVVajrWq1LCMdTH2rOV2ut2rncuXMHdV3j5Zdf1vMYDofo9XqqtKc1De18CG05PzgmTKakiYQUMtMCJfXMp9I/nVdUs6d9n8731MKHQJrzl4UqqUTv9XqajOj1eri5uVGAXlUVnjx5gpOTE3Q6HU0MpTCc+2XCpdPpqFURi82mViYE7rTG4fzYbrc6R7jyhEkBJjtSr/8XLqJCSxoo4JRn2HqIb5Wbe7A7ftfmY/ULty6yu1g40nq43AQVtRYqjNsZCdtFhbUrMrjCtIU3rVOrDqqaxXvItoSv6wBxqfTNDHyewXeK4K/tfbAEISgFgm2GMRHI+9af2rk9hbkCb6BVbgNxf2htQiQod30nWoqkFihUSDMJAACNg6kayGbXgvZBTwtWSuOCcr3I1SJDwwCo3Z7ftTcmroqPgDeF3pm0BThjXwefVcrdfGtxAgTP8kP4nyXqeUaWBTgck5VCEA7EJe6EzRbwJljTmATQO7efaKgqiHfwLlMfaQBBTU7Q3TTBgiQPkFoIulPgTTsWjm3sf2+jmjEtsmkivIm+4jqNjQDI4MsSvqrwXy/ewMObE+SFRV3lEPFwXgLgBQK07lkgPt/pNOgVDWbLPpwLsNuVAd6bCKm9E4jxMIWDqw08wTcEYiUgGkv1N+CdCXCN4kUB0BiY3MF7qsI5TMFOxTmBMTl2dY73rk9Rrwv8um95F7NtPxyvkbA6AgjHNIA4YFcN8Xd7n8Bv+Ja3YcRj7TwK8ci8w04sNt5j5nL8k/JVfGr+LShtjg/1b/Ez5SuwmxySewX7WTf0S15Y9LsVhp0Kk85OPdABoJ+Fz+LaZ5jVAxTG4r3NCQBg2Tg83L6GUVHio90LPOlc4wff/jSOcYxf/nh+RBo+LiMJ9vEn70NVGUBttweZPgG8gzcDQDpAJ49FKuOqKtYuEIT7YlbE6z8LcLhBtPDwrXe3j+AbEWZ7B1V3s/BjqtoGohKb9+ZEJU7grff+9LMj/q6q7PikB7RQJQtzEoozee18tHXyyd8TvB9HpTfPkUlna+M9vAnK7roKXt7rebA54XN1GUB/07RK8r3hO6LuYxzjWcECl595eATfxzjGMb4p400A3wbgC7/UHT03+E59t1P7hcUi3EipICXso1r0UHFLaOucw3a7xWazUc/h5XKpPsq0auB2/X4fjx49wvn5ObrdLi4uLjCZTPZ8nwkKCbP5XFEU6oFNf2Had7CoJWFdr9dTJTJBaVmWGI/HODkJX9qur69xe3urPsls75MnT7Db7bRPvPe4urpSaNztdjEcDhVGv/POO+h2u+rTPRwOFdwuFgsFtJ1OR5Xoo9EIi8UC5+fnuL29VfV7aqORjhfbQS9r2tSkELcoCoxGIxhjcHV1pcp8Qt2LiwvUda32GkwKcHtau4xGI5RlqVCVPwnRqa5m8cFU7W8TcMHfOU9YAJGQmsA7LYK52+3Up5t9zf1TBez9/h/GaVFLWrFQ3c15R1uX1IKDqu/NZoP1eo0nT57g0aNHAKA+7QTUFxcXOic5X+l1zWKwtHcZjUaq/K+qCsvlEovFYg8+c4ypiOdqCEL4FIjThoXHSYEwkw70d2e/8zw57+j1zusptc9hsuTq6koTMlSEU4E/m82w2+00aVbXtSZ46rrWhAdtbFK7FM5bbgeEpE6a3CL4LooCg8FAITyP86IHvbXF+VYR7eKXWCNBgS1oX1Pw3X4JprpbrGu9uKkW5uP4vKmdHtNFEO6LLByHymlam3goEJY6Xv9NUBJLqvpNrEYkvYYz06qXGSKAb5XaYn3rm4p4npns75cR/bkhEkG7UdDqM4FsgjJZ6qYtNJkZoG5gqjwC/GgXkgfoLuu42kJiUc1OEfZrfXvO8dgt1A0e3b7IoNSyaMFJsKQJquLQ6Qc2ICwGmWXwxgfbFyPqB6t9SH9Y6/ZV+3kegHfi0/7McLFdYvYhdTp2hCGu2VN8e3QAX0N8Hvy5mwbex8K6EQoJLQIOrWj4kxBHl/tzXFufWX/Qft80+MEv/BjeaTb4H/2jfz3ajEiw66hNy3sAmH4D3xg0VY5lFdq2yQPQliwmajKHLHdo6gwiHt1BjTy3KMscyAVO2+ZDksBGGG4l2IU0AtQCECrbYLfiWXXSA0KI3vC4GZbbAqZw8I3BnZfn+PmHd9HsCqA0kNrAUERvmRQCxAI3b5/hT8lvxX/0rX8FyJeoYxHMmevjXrbCm+XL+MXdPSzrLj4xeoKzYh26XwBfGUjHwXQC9M4yh0GvxKRX4iPjKba2wC7x+DbSQ+0zNC58/l+XQ6yqLpwXbOoOulmDTdPBF8s7eND/IgamxNmzZ9oxjvHLFj6ibYGHcbIneHYSPjPFeeTlDhCBy3LYogj3y+Ucstui+P/9dUi3j+ZDH4e9+wpQvRZU31kRVv04hOs/k6DU7g8AWo/YCLRdFaB3bxhgsY8rS3bLAIYJxUWAzQrABuh0gdGotUsJrY6A3LT2JD5N7ubhd668yV1oV1ZEaywfLbB8u10GoDMInwHWBSW2rcPr1gM2/L0XLF66QDeLVi8S1OmISm84YFUBtzfAbgNcvxv8vJdX4V9ZAstZgN1NGVcUNRAXCmWqVeTe+B3jGMdI41ffG0MEeLIscbUscWd8tBU7xjGO8U0V8uXf8nzx3OCbIIuK39SigkCZheyccwqa6blNb+f1eq3QjiCVQJxAq2kahXHT6XTPn5sFKi8uLtQjmyrd+XyudhOprzYtMqiy3m63uLm5UVDLf+fn5wrPUl9jAj4WUKzrGsvlUhW0ANRnvCxLPXa/31elrLUW4/FYFeopzCXgu729VXU74ST9knme3W5Xwd7JyYkq1JmUAKCWF6ktCACcnp6qj3iq7KV1Ci1b7ty5g81mo2pcAufZbKaAkXB0s9moKpeWHoTxHNvUk5uezLTSYLFDqnd53pxjVKOzn8qy1AKLBN/06ybEpsKcgJUFKVPvcLZtPB7vAVIC/0PVMBXyhwVGrbUKwu/du6f9SqhM2xjOg9RihtcEkxH0u67rWhMg9+7dgzEGm81GVfZsD5MG7B9eO7QISRMDtFYhCOc2fDybzfScuU9eM9w3+4P3ALadKw44t1PYTYsTQmoqxtlW5xxWq5V6vnNecEUG52iqSmfyQyQA0m63qzYyAHBycqIJphc2fGJvouDQt4Uko0BYP0liEco0Uo9uQdwfIhymYg1orU/SzyXngmUHAB+/nHsRmGgTIrWHaegr7VqQ7FzYd2L3FBoQwXtZBcuPaB/iEyiq9iuxCCYygbcexrkAGKNiOxSfDFAgFNtUSS1cFqCveluLBHjeRHV3WbWWGi7ahkgszBj9sdUGhDDYB3AgdbT9QKE2Jdp2+mJbn6jrqdA2YSwOIX/qOZ5atogEcBFf885BvAGKCLkJgtMVEQQoQPRZDWO857YWwYcndOZzJhbCNQEStT6v7dh43/q/BzDtAGSq9vPWQSQCeDiI5Mm5mKggTIB6spoMRSf65EbQw4SMSKsIByKUsVi4Hf7Dh/9DLOfhc8sbE1iQDTYjPtqNeCuQLNiOFP0azU0fthuKzHkbrD4k82p5IsbDOcF224GrMkC8NteID6dtERSRAPYKX1LtbXxrjxKV5x5G3xtEpuGxs4KsbzGdjWDLDLLMkVH0aZO+j4koeIFUwPVb5/gPzO/Gb773eXyi9wgWBhfZCq9kS/wX/8y345//+59HNnK4qsb4uUXwAzUdGwpZNgbeZQF+Z4BzBtYZLOsuxkWpiu/GGyzrXpwiBqXLMMwrTLo7bJtg1VJkFufdNT7ee4IbO8TYzI7g+xjfMEH4vSdc5mOEJKeIwOYFnMnCPaiuIFUFs1rBZDlsvw/0u8BgBOy2QG7j9Z0oszMB8giiGotorN3eI7M8wOm4ygSQaHGCUDjTmKiCRvzcQrz3RuuSVLGtCUPffm5I/GNAVds8SROO7aN6W1zYn3cBxJs83NBs3a4GQjyGi4UyTR7vywIU0Ruc58CMgnWhb7ZrYDENqvnNFNjMQyKg3Ib9NU3cLz3Bv+pDfoxj/IqMYTfHRy+G+ML1Gp95uMCd8Z2vd5OOcYxjHOPrEs9Nhg49uQmiCM+o4KUCutfrqcczEBTMtEdILVBokUCbB/oLF0WB6XSq7+E+d7sd7t27p/YkqaqYcJ5ewQAUahKsUhVL+xJjDE5OTpDnuVoonJ2dKcwUEfT7fZyfn0NEsFqtMJ/P8fjxYy2ESauO1Wq1Z69AdftoFKoo93o9LZBYlqX+Ti9xJhIIEY0x2O12GI/HChpphUGwyUQCLTQA7IHJtFjkfD7HxcWF9gXtJrj/brerylt6VBPK8rExBnfu3IG1Vt+fqvrTAphU7HMOpKrt1Feb++L+eQ4Eu7TC4T/OQ27POZiqvTknmAzgcfg8YTDnAW1haP/hvdfzIoiuqgrr9VqTOXVdYz6fY7FYqD3K3bt31efbObfnb01lfzoPee3Qi54FTCeTifp60+qElilAsC0hoE8hPfuafQpAr1eeO5XrhOEcR85LwvO0WCyPy2uKCv1D1TpXCfA6SJX8XEnR7XZV5c3kzGaz0aQT//EaYqQgO/X952NCdRFRq50XNQix97y96YNNECaUg4fCh0/ZoRh5qrCiSWB4+oon+IxqOBgTjp3Jnre4p8I7Qu891TMQFNNZVKalhSyfOsH4RT1rd+7j8mkqzH1mIMbB1xmQuwCX9Yu+DwUXrYcvjO6T3ui+l0elt4HULtZObG1V0DT7ViHWwVdVW/jR+6BY7hRte50L0F4kKWKGPXuQPQ/zpL2qPue+AKBxrUKdiQMjbXFIVYAbVeyrTQj7jAnQZNm759J5IDAYfbNTqxO22xMqR6W9iISinvzciZ/1QfVOC5PYLmvhxQQ4zaXrzrTjrucZi2YeeHjrsfIcvpFQxJJ9yc9hI60i3Hm47RZXzuOt5XmwJRGgKbMAowTBH7sOIBy1gS8cYDyaKofvOEhUWef9JvpeM7no4FxIxLjGhKlZ+MBpYrgIo03ugn+4+PAXWB3tA2hrEj3A4aWF5EB4nUUyBTC7DLY2MOMaZpEj20Zbk2QTJi58Fq57bwBvPBabHh7uJvhk/wGsN6h9hv/k4ffA3kzxT/W/gD+7+Ofw1uIC18shmjrANFOE83dOkBcWeW6RZw7dvIHzgtplMPHg550NVk0Hzhssmy4MPBoAg7xCLg6FsciNQyEOc9tHXWTY+a+oQPsxjvEVhQLtZxW0iOGT94bfwweqR5ufkqZG5mz8XhPutU23gGQGxewJevUGzZOH2L33XlBvv/yhUPhyeAIMxkDRA7J+TAhGpXbeBfrxWq8qADVQdAOILnKgGIZG5b1wv8sj2O52gwe3yYKSXAwgDWCC+ERtVqo6KLPzHMiLcO9XKyofC1HyM8S39iIsUtlEIE0FuGYGoqVV0QnHLorwOz2+XQNU27CP+XWwM1nNgOv7wdLk+p1gb1Jvw/uaJlic+PYzQgjxnzFOxzjGMZ4dn3x5ouD7N3/iCL6PcYxjfFPFfwxg+tXY0QcqbklYeqi0pW1J6v2b5zmm06nCSapjabFBn2NCwe12i/l8jtlshtVqhcVigfl8jn6/DxZGHAwG6sNMtTHVwovFQgElPYKBVr16enqKzWajdhG0smCbaOuQ5zkWi4XC5X6/r4Uob25u8PDhQ4WB/X4fm81GAT99h9Nz7vf7CvuoMKfvd7otfaiptGZyIAXetOw4OztTUJtlmXpRE7DTcmK9XmuBRKD1pKaKm9Hr9TAYDNSre7PZ4OzsTC0kUsV5v99Hv9/Hyy+/rP3JfVERfX19jclkorCYKmq2gZCXrxGCEngSgqYFQfmP86Guax1jbpsqqJkM4D5SoM3xIHBm0obJHJ5v6iPOhAo9twEosCXwHo1GOD8/x2q1UnhMdXpd1+opD0B9t9k3HBv2E8eFbeCKCG7POX1YCJOJlDS5RMifXhe8hmhNxL5n/6b+9wTn7GsmE6jO5woOPsd/TFgAbVKEyQX2Ky10qqrSBAIAVZvzuLwHpN7zXInBuUl/c26bJj1etCDcPrSSpj2JRqqYpgfo+4Vz0CJ9mcDUDraXw9RW9xt8qD2kcXBFArJ8oHVig9Jb6giiHYLCOrkf+TyDGBOgsxZVjIjCuqD2phVJcg4+D9YYrpMl522A3ABV2C+V43vbpOcnAt/L4ToZTO0ixEcAEgTMmQFM0aqQU0sQ9l9VBz/yVAUHAHUTzkkEvh9Xmji0NjCqukvGQUQV7NoPTEB43xbGpG0Jj8fnolLci2Bv9BsbvcOzpwtD6rZRle19BNe2fS72mfc+QGcgJlcQvMK9i7a1JgCWFHxz2TzB+d6xY4ekc5GPswSAi0CyLCRZiqJNaqTB4pcxvv/+j+H/dvOdeO/mJOmH2K6osJZG4H20PYmgOQggmU0CbBULk2YuOquE9wXv7zgUu0y38d5AstAOVzNhQsANSGXgO76l1lYCzAICGD+8bK3AZ6FhvjHwAwvXE+SLDLBAdI2Byz3EAT6L94IsqDetNXiyHePB8Awf6z6BEYc/9drfxPf8/v8N/q3/52/Cve+5H9stMFk7QfMijHueW/SKBp28QT+v0csaFMaiasK5rZooOHDtPaDxBrk45HmFTtYgF4du1qB2OZa2j/sIBn7HOMbXMmTvsXxJ+L0Hvj3fFT7LbHwys01wcfIGFgbeZGh6XUhm0J9fo3/9HnZSoJR/Aj+cAL/hO4HLu0DzGoAc6BmgFz9nEBOEeTfA46YGVqvwGZNH9XeeAZ0+ABOguWRc0hEgtukE2Gy6UZldhYSii0UkXQTZmiCl33bWJoVdAr59Ar6bKv6rgTrWsqBnd7jZh8/G7jDsL48JXi9AWQXYXq0D1H7yDnD1IFi3LB4D5Qa4eRfYrVrVuW0CNKc8/P1zFMc4xjG+RLzxygQ/+LMP8ebR5/sYxzjGN1l47/+Tr9a+nht809eXgJYAkTCXqmdaJxBcU4WcFrykQhQIQPH6+hreey2ER89oegR3u10tfEdwPp1Oce/ePUynU1WjE0imvt/GGAXF9E5Oz4mF8QhDCcoJZdmO5XKJ2WymgJ3/6Ne93W7V+oQgmN7MhJcs7pgqv+k3TvhJkAhA/c+p7k7BLqElIeW9e/e0r2mXkhaW5L5oF1PXNXq9nkJIQvbdbofJZKKgl8rzJ0+e4M6dO9pfLPS5XC7V6oTglf3N5MJqtVLAyYQCFc2EsgTQTKbQb7ppmj2FNcEnEx/p3KTim97jVARTZU6QTFUwlcsEx1xpQEhO1XrTNFiv11gsFthsNjrPmKAZDAa4vLxU4AoAk8kEt7e3Oi8JkW9vb2Gt1SRCcwB+qFzmXGB/pMCZQXjd6XSwWq302JwXnM+ck2lhTo4Xj8n+6Ha7mlBiYoWFNdP3cg6mSRkAe/7iqXo/LTTK6yO1eeFxqDqnrzrPie8lYOc++TvnFpMNqcf9ixqH0DtYg+wD8Vb9jbYgFRC+XEZ1eKr8Flr/mKAQN2UD18nCPqL9ifcIsPngS6r46IHtgr+1FpG0B8UnsyzU8UoV2qktB59LQGdQnJvWvzu+T6gU43a0OclMAL5AC1UJmOP5BysY2ffjrusASPNcfbzDUvM6FGfchUKL3nuIkaB443HLEmrz0evsw/4IpX0mkNppn/sM6leeWrLoWDQ2WISky9ffL6KyX3vIRWCdZa1y2/l22XpS+PP9Qu1G0uNmWSxKKpAIu4UeuEBIasCpmlw6RbJM3gVFZdOEdsZxVRBPWJOqutvGgEp5T8ucVN2+K/G5WvAPrz+6t0mY68nSe5+AZSvBz7aOivAyg3Rc5EUeecfCWQNnQyFKb8O/tkgsZaFRKUp7EwfAxiKUnH61ABD4PF6HVvYtS4wPv/N6je2UaQF/VkNWOWzPwVTSWtRIhOAO0UccgPGwTQbrDW7qIVb2Q/gXTn8Sf+id70Wx8bj9NR5vPzmH94Ist7BNAGv09K5thl7RwIjHSXeHxhnkxsLAo5fF4sviMa96cN5g2xRoYoP6eY1JET53+vG9K9vFo+YE1VHxfYxfhuDl80vfS3ykAmQfMXr0y7YGjQNKyVHTH6kpkd88gtQ72E0Jt1gCw0mwCym6UcHNFS8+3iP5WWpikrQAutETnMpqF5PHEu1NPOK9NG1rVGS3hTwizK6hdRrEQLOwtO1Kd+HZnjy01aO1MskKIO/E12NBzt0mQPTtOqi7qy0wfxjU4rMnwPo2gO7NIoD0Oq6aYh0STwLuNflwjGMc44PHG7HA5ZsPjuD7GMc4xjd+iMifep+XPIAdgM8B+Kve+w+kBH+BTXCPcYxjHOMYxzjGMY5xjGO8KJFga6098KWYqk8ywvoobhAdp2HEIxMLeAe/DX7Yu6LALitiwUwHU68w+OxPIzeCTe8Uu95JUH//6l8fAPjlx4H+WXsA74JPNnxYttGYYIsyGcc6Eggge1cF+xKTIayWEcBWYAHpYC+VtUWMmeGzdXifxFVMYmJxyyxCcRue60Qg7wVABNxFLFIpEZgPJ8G+pamB5SJYm8weAMsbYLsEltPw88Hnw8/tHChXQLUJANzWwHYXVN5JG83eaD09Hsc4xjG+fHwygu8vXK+xqy16xTHRfIxjHOMbOn4DgG9HkB/9AkL2/lsQJAE/D+APAviTIvLd3vs3n3enzw2+qeSm6pLKWnoEU7VJSwPaYFBhmnpQd7tdLaTIfXa7XbVDAYKH8Ww2Q7/f3/P2raoKdV1jNBqp1QSVwVRH00YCCGptKtSB1vt4uVyqHQOVwlQU01ubanEquu/fv4/dbqf2ELRKWS6XalPhnMPp6SkAqLcpVbsigtPTU7VF4bmxHVQ/09KC/wBoodDLy8s9pa73HqPRaE91S3sVoLUf4Rj1+331QB4OhxARLJdLlGWp/Uy1/HK5VJsOjiUtNIwxKMsSnU4H2+0WQCieuVqttP+o6qcCl37ftLvgOVBdzHnC99Hig97Xq9UKvV5Pxyv1Fk+V3SzW2ev1dDyXy6Wqiqn65jZUfNNGh/NpvV5js9lgu93uqb05p29vb1GWJU5OTvaKZ56cnKganTZA1lr15eY8pvJ7MBig1+ths9nstW02m6kqPy38yX6jDQ6D3vbsh+12CxHBYrFQGxz2FdXf3W5XFdjsO/Y7Pdq5Px6X/UVlPFc0HCrLqcDmGPAaoH2KMUY9x7n6gUHrpENbJa4koAqe/Z6uruC5vNBxqA6mqtSjtTs5VAfTggLYU2CL9a3NSaKOFufhcwNT2ejvHQtQ8rHzwTecYl4bimtK7SB10/pKR1sT7tcXefTajgps51p/ciNAnoXnRbSwZns+oucpjYXZVJBt1dqLxO1D+10oHKg+yFlQqqP1Mvfxe73PBOIM0O9F3+/45bysgvqb12FmtK0wmRa/hBGI9NrzRWJXwuXkev5Z660e1d5p/4hDKHhZNXv+4KqOBoKfeBwfOB/akYciia3+L6rWnQt+5FzSnsV7GVXYtDbJs6hEt6H9eR78Z7MMUkQrE0MlvgHg9jzYn7omJdjiIM9bOxXHwfBBhS4Gksd+sLY9P/ZN2ndxH57FOesmPI73t7/+1o/hb27OMN0O4J1pN3WiSmqpBdIIXMeH18Xr/IADUPi2qwuHehs+c31lYPpNECiKqGJbr6ecx9IpGuecV1W3LzykEogTeBPV2Y0EexIX1d02KMKlDvPAdcP245/tohkC5blDthPYHudTPE4i5Axj4fFkOcIPzT8J5wT/9TvfFa7T3yDwmUO9Cn8DNFkOyUOj89wiMx6ZadDLG2TGwXlBbhycN1i7XCFVA2DTdFC7DLsmR20zWCeoOxk6pl3lxPffNkPUR8X3Mb4u8UHg6ft7bezB9HjdO+/b5z3CCqQm2oi4DGg80C0g82ugqeCL0/CcZG2hSt7nQDuSaC3C5ohECxRAi05qg3yyOgoRfAMtrqeyWrizuG28/zvXnjLV3kbCTxbP1Pe7WOCzDiruchv8uwm8V1NguwrK7906QO96E1Tgddmq1ttlOE8V3D7GMY7xlcVLky7Ohx1M1xV+8fESv/610693k45xjGMc40vFX0Xw9f593vsFAIjIBMCfB/ApAH8OwF8E8H8H8Nufd6fPDb5Tv2BCR3pqswBhalcABIBKSEiA5ZzDbDZTK4uqqtDr9XB9fa1e2yzwNxqNsN1u94pn0p6CkJc2GE3TqN8vwR0AnJ2dKWAryxLn5+daoJP7L8tSwerdu3ex3W73QHxZlvjc5z6Hx48fw1qL4XCIyWSCzWajNh4E6cPhUKEz/brZF4Sg3nv0+319TLsLFhYcj8d6Huy7wWCgVi1MPmy3WwV+fAxAiwt2u10FxbRkIUw8Pz/Xfup0OlgsFhARXF5eKihmPzPRQLuN1BqEbQOgkJr2Ht1uVy1HiqJQf3OCbPpRHyZORATD4VAtO4bDofqPA62VRwpKed6cT2mhRfpGE8JyHhK20maHSQprrR6DEH+9XqOua8xmsz3PdELX1AqIx2iaBovFQufQarVSeEvgzDnd7/d1/GgHMhqNFMLTuoPX4Xq91vfy2qKlCt9HX29C8rRALM+Tiar0fDudjo53mlDg9ZbaFvH4aRHTPM91+263qz7xqTUJoT3HkYmJQ3uftEAn28DzSn3YmYTjGNN254UNhXXRZoNfkFM7DNqEwAdQbJ0WV/SZaeG3j+CNHthFFm0z9kGmaQiy4/NJMU0IIC7AXqlt244iDwUKY5u8CJCHeSENkH7z9cYH6B0LPfosWrD4oP/yPkB6H7eR0kLKJkDqWDRTiNriuYi1oC+EL9pzSR0q4BDaXDfBt7tugs84AJFuBMYBykqcr76qIZ0iQPwI3WGtFsSUurXxQbcTxoj9YL0CfY6H0E+8id7o1rcFLYF9CCwS+pXjl0Wozd+ZTIpzQBob8unWgn8SSDpHfAunfQTbkgWwLJ1OOKcUeBsWIY6daK3anAARlbgDoiHRCoDJF4J+7wBkLRAh6GfbUvDNJEnqQZ6Eg8NVM8GuzuO5e6jXTywsKTaZcg5A17eg2nhAIhB3AlcH327vA5z2NoJ82pF4tHNLXNwe0T6FCaZooUIbkyzC8FraYwIQJ62/fmLLYnYBhK8+7GEaBJuTDJCG13HYn+/w+vJA7mEbg8Ya1FWOelsgswLXd5A6dLdUJlxvtcSisUAtHtuigHMC2xFkxsN0Paw3eGd5hkFRITehkYuyh3VVYFcVqKscPhYE3BQWlc0w7sY6ER2Bg6BjGqya7lNjdoxjfK3j+djqHtZ+9pZeYON924gPP20Vyrp6AZyBF2BbdAADWNsA2xmyJxt0t1Mg66Ds/SRs3gfOL4MSvDcGzj4UrE0GZ8DoLADl9TLc+zrdcL/rngDjXmgTC0429b7NF4D2DwMmC6OdiZhgVUJbMU16xudQhJtJpxfU3nUFbNbBxqTZBWh9+zjsbzNvVd3XbwGrG6DcBehtg90LnAV2C6DcQGwNUwW/cBfdWYjVfXJ7922r1Zn9yMWPcYznCxHBGy9P8KnPXeMzDxdH8H2MYxzjGz3+twB+G6E3AHjvFyLyxwD8sPf+/yEi/yGAH/4gO/3AVidUaBIc04+bhR63262qOQm3gVDMryxLVbACUBhL5XCn00FRFOpBXde1ekmnBQ4J2Gez2Z5ylT7YhMoAFOxREc4infQQHg6H+jq9kkejkaqGWTxzu93iyZMn6HQ6OD09VTgPQAEuleW3t7cAoLD68vISWZbh9vZWixDyHFIvZvYBgd5kMlHIyj6ltzdVugSoVI0DUAU4+1hEMBqNICIYDAaqCCcEZYFSbrfZbHBycqL+3IPBAN1uF7PZTMeXiv/0WPSs5nbcb+r1zP6ivzohfXr+DCp7gdbPmn3R6XR0bjGRQRXwfD7XIoc8NttMBTPBaaq2Z9FTgnkWH729vcV2u8V0OsVyudT2EWoDUMDOVQNU9QNQ32oWXCT8p+KewJ3we7lc7inmASh8Tv3FeS3y+PTmTpXvqU85Vykw0sKn3A/P/+TkRM8lLWjL9/M8qPzmGLLNnPuE52lSim2jzz3Hh0kgzqHUM53QnH7wPIZzTsed/uhMeLzQ4Bt4SqGdKryV+bnkW+X7hfUtCEWA157LJKlorS2ktPC9HKay0XMbUb3sVBEO72NRy7bAJAzgzdNqT5+bAHhj8UZCYPXi5lTWNeei1NI0DmItpKpbQJxsH84rqroJ8F3sGJGgqI4gX6g07kR1rzPxPBI1XRGBQVTESbxetGCojUA27gOu9TV3PJ8s+KOLZ7IiUcFTOR+F1DoWrgX9e+eWFtXUImbSJiUALWbmYxJCnLTgIw0TVX4m+oNHRbVPVmLp8Ux7P+PPsGw+AhkQuEevc5H2tXSOchuzP2/35rOez/45iwl+tT6e9w989lMAgCe2xD9efwjWGhgJ8HfP3xsRFBsPsYg+8wLpN/BlFjyyXfTJj4UqvaXCPvp3K/CWvaKlcDFZUDh4RyWnhy+AbG0g1sCxmGUnwu8Ir00ZPLtDckrgbdzWAKaJckwPuBwwDnCFh6laFbk3HmYb1OLN2AYVeQEY41EvOpAy7tyF4+r8EuwV0XS7HKtYCLTqFsgLi5vbuJLIeHS7Ncb9ALQ3VYHdroB3Bs7R91xQ1gazeJqFsejZBgYeW1ugdk/fA45xjG+W8PqfIGRLYwLRupAAc+E+XktMFDY1YGtIvUO+mQEQVNIDpABeeQ2QHTA4B7rnCNkoCZ7e5S6sNKI9CbIAo3ujcB91dXs/TT26aUmSqtbFAYiJWUJu3wQwzVMRE9ov9PbuAk1Urts6KLZtBey2wHYTFN7vfRbYLoDpO8D6JqwM2u0irO+E/ZbbAL6dhWnqcI9BSODKQXohhd7HOMYxvrL45MtjfOpz10ef72Mc4xjfDHEC4C6AQxuTOwAm8fEMQAcfIJ4bfBMiUtlJlS6BM5WrBFnL5VKVywAwnU7VhmSz2WA4HKqdwnw+37MzIWijzQjfd3FxoXYTBJ+DwQDb7RaDwQDz+VxVzNwfIWyv18NoNNLnh8OhAmMqr6uqgojAWouLiwtV4i6XS9y9exfT6VTPdzQaqb1DlmWYz+fw3qvCGoD2FZMDBPMAtFggQePZ2RlWq5X2MxW4tOugipbnxKKVHBMmEBgsHsl93d7e7gF2jpFzDre3t1rgcz6f79nabDYbjMdjrNdrVeafnp6qLQitNXh+PN5gMNDVAallC5Mm3D8tUwh6U2Uvx4KFKwk0U8sVAJpMmUwmClzSBIkxRqHpdrvVApYcc+6Hymj2zWw2w6NHj3B9fY3pdIqHDx9it9vtFVHluXBFAot3pokWqsI5dpyDLKbJfmJ7aeGxWq30WFSos294bFr/EHYTAnMMU5U4+y5VRXNucV+cB71eD6vVCt1uV5NHvDZTxT1XS6Rt73Q6Om+ZaOE84EoBnjv7jSss0vsA53h6nRCip7YmHDvul0mzFzqirYhaZCSWJz7Ko4NaOrxsGhcV1E7fh6g+Fqqzo/2GG+RBHV7kAXQ2B0rwPFHkAlqoURoLUzXRN1SCeruTh+3YPtqqMNh8QuC43z17kwSoe5Mo1R1apXCiZPcirdUKAGERx9qqvYrxvrUiQQT4bDsQCkISGLAvk/bR4iMAa6NKb0/1dV605+xctCAJgF+hLhD2kyTAQj/G4mnaRy2YTsda25qq/giT9cTYhmfAc6BVXnM7F9Xf3rdtTa1G2B+E3oTayRio5weLstl4LmxXZvYU4Wp5QtuYtO0OraLdiI65j/Y4cA5bH+7pn21GeLSboGkMmjIH6gC+pQlQVmIzxAGugPJ0X2YBFosJSu1GQvLDBODr04KT/GcBFFH9DQA2buME+TyLlkOAHTnYsYVsM/jCBdBsYhIiKsldJyjFpQz2JpDQZqq5g1UKV220KnIgKMDhgnULEN/bCJzJsNoMIbVpFe1egsLcSVvwVmIiBgjAXQSSezSbHK4bVP3eCrDLUE4ETdPC66bKw7yujfYBCoemzrEuO+jlDXLjUB2B9zG+6eJZGLZVIdPRKFUoG7HhUePhXVytFD9vyizccFzMbGarW+QPLHz+EPXVNXzRB959Exifhntj44BuH3jpdaA/DPfesk6ODi0ejJgIDEtEkiShd63iG0AwKEKyusYCTdU+TleLbRbA9bvBomQ7D6rvxoZ/1RaYXwH1NkDwzSJA/jrch1Fz1VMJiX7eba7N64qbuFjtfaH3EYQf4xgfLN54JbCiNx8ewfcxjnGMb/j4qwD+cxH5dwH8BMLH/ncC+BMA/kp8z3cC+MUPstPnBt9N06DX66nCk3YJnU5HbReoyqQ1hC7lRgDNeZ5juVwqZCOkGg6HeozJZKKAMwVr3W5Xlcj0/+31eliv1wphU19xgtbNZqNwnHYjBH6Ek4RyBNl5nuP6+hovv/wy1us1+v0+JpMJXn/9dW0Ttx2NRgqVCfQJ3VarlcJYAKouptUFgT7BI6HhswAwFei0dUi9tunZTduXoiiw2WxwcXGhUJ9gsigKVWKvVitsNhttH0E792GtxeXlpdq3EPoT5lLlnCq5h8OhQmrafhBoMiGR2rUQhFONnc4ZQuhut6sqaiqNCU7Zr3xOJ3bs09ROJ89znJ6eKiClPQbfx7Gg7c3NzQ0ePHiAJ0+e4MmTJ2oXMp/P9Ticb7R2oXUKVdZMWDAhcHhdVFWF1WqFk5OTPSBMiMw5Q/W51S8p0PGnP/2hHQjtSAiqCclpHwJArzO29bDvuWKAfct9UFlOGM05wT4l9KbNCwE6ExMcD+/9XuIptUfifAVCUoW+7YT7fD6F/FTtE8a/qKFe3gnw1sdoFa5COAmowjn8EoC2T2GlQVD9WhcBbtzeCFAnkDiqpb1Afb+BCHirOmzf68AbA9fN4TOjntqwNmwbva0Pler78BQtUI3/xHogtUeh1Yi1QW0tAqnqAL7j/rz2kVfYGBR6LrSlkwdVeJFBGgvZVfD9bizuhfBlv25aD+pEXU1VuM+z/fNIQXCqhE/ArirR43vVrkYkQGDnw35Ty4/D/kk9sVUZf9AGkTCemQFyH8ZLYTbtUWQP6EMknHd6zCxrVYYp9D4MbeMzXjNZC9idDX633gFFWAklPMZhXx4C/aYdj5kLY/3Z8h5uy0HbFZzqEVzTYtoXAUjBhmtF/bbreN3wd48AfYEIiX0oPsf30PZEzzv8a04sOtMM9Z0asgtKct+zYe41ETR7AHlQakOYrBLYToDXktieiI3w3gBSA64bADgQIL5YwBeAxPd2pgauMOgsBJtXnUJ78QGu+yxuT/uXKFhFjgDvdwGQ+zKDHzQwuYM5sWjWBSxXbnhEy5ckKRD73HugLHNMpQ/nBd28QSYO5mjoe4xvivgS85R/6wMxoRSu/wxAJrE2Aj96fAbxGbxkKLNOTEyGhGy+vEF/+QiNEzRNSIpifAL0+sH+ZHgebE/EA5OLkLTdVfFzJ6q6pQNIFj6nCn5GxPtRHf24nY0qcRfgtOfNQIB6B5TroOrexZ/bZXi8vAEefQ4oN+FxtYX6i3MljnPAIvp6OxuU6NpHQdEdcbwy+hweElLKT7lhPecIHOMYx3ifYIHLzzxcwjkPk/7NdIxjHOMY31jxbyL4d/+/0fLqBsBfAPCH4+8/D+APfJCdfiDwTeXmcDhUOE0Q1+/3FRiu12u1iCCgSj2ci6JQQEowR/uR1PpkNpspQN1sNjg7O0PTNGoPsVqtFLYCUHuOq6srBbiEpbS3IDwkHE9tFYDgCQ4EoEaV83a7xXq9Vi/rfr+v7SSQM8bg7t27e1YM6/V6D0bOZjMMBoM9yEp1LtXraV+xzQTOhKq0ckkLP9K6BWjtT1hAlGCS2xNM0k6F2xFGbrdbLYzI/js5OcHV1RXG47EWaWQCILUToa95an/CRMdwOFTFOeFm6stM5TjHI1Vls58BqNc4Y7FYqOq51+uh1+up9QY94lOvb65W4BwgmOd8YCHL29tb3N7eYrlcYjqd7hWqBIJqP/WbJgAnTE+9zVO7jxQec27wGjjsm3TFQ6pO995rQqPb7WIymehxgbYYLcE5+4ewOS06yxUUbDNXEHAOH1qi8Pw5LryG0rmetpPP8/6RWrbw+bIs964NnivPhwpvrsLgfEuPyfsUx5XHeCHD+wDtBHt2JqFIYwsJPRme83hf7uQPXmBCzice1OnrtPeIFiUwAtk10d87fuu3DshNAPTpMbxvoffhsVO1bwo/D9unhSERYDctTQ6VzrGNe/YZQGt54uJzjQtf6hMFu8JW5wJYb2IhRSAUexQJymig9Z5OFdmpqtuF/YsPqvugYpbWbgOt6hYmvAYXIXSqwos+5tq2VK3N92Rm3xvcey1Iute3af8aCfuWvVEOrzdNC1uiUlC9xQ+V3mmogt+1MD0dR6q3LX2/IxhmH2ZZe+5VHZ6v29UtcB4oOhBp8FoeVkrtfIGb9QC2yQKUzQOY9hHuEib7SIHFSbCRsQKpg5e22qJkvp30apUS6XEGwHiYroWj2rlrIascPvMwlUE9CpBcKomrFKKlCHMIG4PmhAp6wNRR4Z0H8G3pPe4BmwM0xpUitIee3vGEABe28V2HZiDoLARNH8h2ApcBrhcBeBZBexa2E0foDrVeCZA99l9t4LYZXN/G8UoSLXuWPDG5IAauDhd9ZTxWpgPrJdbdO+KsY/wKCp3OAg+/5zzm47MSPbnFNfAIBZfhfcyBGVjdxgf1dcVkUoTkj98KqurRFOifJJ8rglgVOHwOFXl8Lgs/PZOTrlVzp+AbCMert+H1ahdW5pTbALk3c2CzjHB8G35Gm5LwL1pZNVUL1/X+vn+d+/d5fIxjHOOrGx+/M0InM1iVDd693eL1i8HXu0nHOMYxjvHM8N6vAPzrIvKHAXwM4Y+Tz8fn+Z6f/qD7fW7wPZvN0O/3cefOHfWIJlQlbNpsNgpC6WdMwNY0DS4vLzEYDFAUBWazmSqMaatAawsCyNvbW1UvTyYThZlUVlN5S/uKoii0SB5hGOEsFd+EiCk4JUwfj8cAoIpbgk3uq9frqfJ5tVphPp+jLEuICPI8V2X0IXAjaB4OhworgVZNSxicZdmeQpvJgKIo9GdZlgoyCbIJLAkJ2W7CTr6X/VJVFU5OTjAajRSGssjkfD7Hzc0NLi8vsVgstC11XeOll15Sv2rCUCYagH1rivF4rIkMwnsCbtp40M88BZxUrQNQpTZXG2RZportFGzyd6rXqcZP30cvcwaPy+TLZrPRZM5ms8F0OlX4SvicQmu2j3OdtjmE3/ydBVuZjBARbLdbtfdpmgbr9RpVVWkigspyAlwmaoqiUCU2Vw3QS5tAu9/v63GoOmdygfMgLQSbgnKOHRMhqX0IkxIp5KbKmvunXz3bknp6p/7d7A8CcPYnt+NcTBX8TNTwOklXGaRe7RwnFp19UcMXpvUY9lC4qb7UQPw9qDl9bmAqC1NFSJxLhOdoAbGLYJbbCxWhHsgTgGwE3mSh0GQmMLtoK9JYgGrvIofrFU9ZsXzJczq0OPE+FrMkgQyvCVwLY8UHdbZ1rbUJwa85sM4QaYtKIjkWWR5V6fxyTwsR5wL0bhp46yCZgS86wdN57wS4v0QVzkNT7e1iQiH6OAevawBoX1fgm9qPUD2dKPgBtIptFn0EAFq7RNW2qsYJXThPeBzrnx6fCE3UHzxe70+pvBXu+7YfqQo2AjjTKrXTgpTWBkV7PL6IaUE/oTzby/sEX0tU6r4sUfuw3+/7hX8W5a5oFcgcTvoSSKuUhkhQftsIbSWBt7TJzXyr6JY4XlQ41yYMQxEPUgVLEVOZ6KMtkNLAdz3EC0wlcAX21NzShASHiczf5xHGF8wWhePS/5tw2ptW2GlqgR250IeNAJWgWIVj0RXBuKgSd+39QIE3sPccz1c84BuBINxnfMMVGrHx0UKFSnRVlTdhdYHzgsYAK2uwqwoY41FkTxckPcYxvhlDP5GYhwPAv0baS9fBSCyOW9Uhd+UyiBe4PMMmrnLxmQtbNXWAz5sV5PZJ+Bx58AtAlsMPToH+GO3REO/FCPf9LNPrHZCQEI4Fi8P90gWQ7uM2HhFWu/Z3MBnqQzvqMmxTrtu28V4s8UydjZ9HupO98pqHV7xLXnu/GqLHOMYxvrIoMoNP3Bvh595b4M2H8yP4PsYxjvENH977lYhMw8MWen+l8dzgu9frYTgcot/va1E5EcFyuVQVNW0d8jxXG5CHDx/q9s45LBYL9aqmUts5h+FwqEUEq6pSv+60cOH19TXyPMd4PMZ0OoW1VlXe3J6Qe7PZAIDCVUK91WqldifcN4E6IW9qDQJAASOLRBIcO+ewXC7V6oSFOalIJfykCjz18M6yTCEvrUEAKChkoUjar9DahOrlFK6Px2PsdjtVNAMtlCWYTQE7ldAcD7Y9z3PkeY7XXntNbUnoWc1jpn7bBJpUABO0EpTTi3kwGKiKnXCT/UQrEhY65D55nuxDKta5soCwHwBub2/1OVrfUEVsrdUCpqkKmSsPOPapUpjnRMsZYwwGgwFmsxnm87me7+npqc4NICRgqFZObTYIgzkHmDDiGKYKeRZw5fsYh1YkQCjuOBgMcHp6qisVeD70uq/rGo8ePdJridcB35da/bAd6XXH8WGkKzgIr9nnqX89leTWWoXz6Xxhsii1NUqTF6nXORBWDqTzhWOYFrWlpctqtdJVGi9q1IMcWRm991l00fkIyiQov72Hy020RAGybd3aa9ACIzdB8Ur4nVpnmNZ+w0tQDrtOAN7ifVQvRxhtfSg0Gb2ofZEF6E01KVXaIkExC+zDVr9fYJPQO33eswgmobExcJ0cEj+rgn1FBOAEvVmr5A4e5/EYEdoHH1bA2GZPKS11A59FP/H4vLc8TgJ/D5XSedbuJ6UitEUnSDYm+MBG2B78v13y/ggaU/9uAmSzP4Z4v+WsBMRA6+ua9AWMtMXZqOjmew/HBwhFJcUHkHMIwDOTHC8qmZHYmqgi0AUY7tvtRSQ8toAXF21ekn1b1x6L0L9TwC/D5+tDG4oMr6YDSOHgd5mCbmS+hbpoobbPWujt4dUmxGdxrKyo+tpnPkDwOpy/VEHB7dqP49hBAV4rJI+8CUBUnYd9iQvwOl8Y9QIXF/y6fWxvGOe428jb2W5vAvDWY4pHVmZw3eAhXo+izUAFZFU8L2Pgcw9TC1wRPcaZuJHkGK6F7MgD/NYEQEKr6FW+R7n40wpQS7AXNhmaOoPJHapnFLg9xjG+6SMmfd6f34aEoSAmnxCSZg7Jfdwjfn67AKv5t2G1Ca/XFbDbIKHW8Z6OcO8m+G7iPb7bCeDbuXhf9oCP4HtPms4sIe1TJEk8RiV30wQAbmOxy72LXT/i37drvtTvX3YHxzjGMT5QfPLeJILvJb7n17789W7OMY5xjGM8M0TEAPj3Afy7AEbxuSWAPwngj3v/LL/MLx/PDb6995jP5zg/P1cwRsB4fX2NyWSCyWSCuq7x4MEDNE2Ds7MzVVF773F7ewsRwenp6R5MpfqasPrm5kZhaFmW6PV6qKpK4SzhXZZlWnyRSmz6IacFF6n4pd0EFd9UvBLy0b6D6mKqo2mhkapvAai6lBCOdiyEdaenp5hOp+pJfH5+jtFohNVqhcVigX6/r9YiBINU73IfBJhFUWC1WmEwGKDb7WI2mym0p4Ke3s2LxQK9Xk/Pj8pbKsZpodI0DZbLpUJgWnPQ6mIwGGA4HCpQJ9idTCbY7XZYrVYwxqjim0URqbxlX6VKYP5MldJUFlPFy5UDVKKnczBViRO00q5ls9loX3Mu0Z86yzKs12sFpdvtVlckLJdLTZbQ3iYtAnl5ebmnGieATi02qH4muGVSp6oqjMdjbQf7YDQaad+k58iVE5xbBLpUWhOoU/U8HA4xGo0wHA41McXEyqNHj7BcLvHxj38cy+VSvfcJ+mltc2hzwqQPVdQp3GdbqVDnuBM+08c/9cKfzWY4Pz/X82UwGcakB8+ZSTUmC9K+YVvZ3sFgoPO81+thuVxqf6WrOl602NzN0ZtbZLv45dN5mIrAETC1QzUp0AwNxAJZ5SC+C1MGKMuClWHbxHM7wlHxAGz4au4T4GoSX3BpgtIUTYTDBM15Bl+YoAavbKsuBgJENyYooOPve+A4hcUKZQM8FW1boHRBCRueCxYvaKF3VCf7TqtUl0TZLM7BRwIvVKtn0U4j+oZrEU2RYG+S5wEEUGHHc8hMLDRKyOv3z8WY0E976vNE2ZyeOxXpPE+RFi4e9CMivFYYzATIIbBOgL5C1UNbGQZV1uwnSeCMMcGjXSTuJ2tV3N7vA/m4refzjY/tt7Hvkv0XUZmYmdZrXLskAHJV2vPcVmu4qsafe+vv49/54r8QnqNXrmM7fLAFKRykMsFJpQF8jlgwEqqiVvCLqFruJOBaEApZxiKZPouqyVgoMvRb2JcWrrTSvi4++Gp7KPQWePhc9pwHUoU6x8lHKM3Clj4HpBbYXlRXVgKzM/CFb88j93A5YHthzpgmgjUfbV/4PoM9CxZxAfzT+gQOyBqBy9s2Ss3EiW+LbLL98ZzFSjiXMsI4n8FmHi71Qz/GMb6Jg3dY4aMkKcSHDj7afKFdtSQOJtqfmKbZSwq7ZL+eliWsg1HVQL2MiWV56pgtPI4XZF3G5xIiT6sha9vPSYkbekDV3qAKPLZIfcLbs+bNKi4K013wPJ6LZR8p+DGO8VWPN16ZAD8FvPngWODyGMc4xjd0/HEAvx/A/w7AjyL8AfDPAPhjAHoA/g9fyU4/EPimhzfVmUCAof1+HycnJ/iZn/kZ7HY73N7eYjAY4N1331X49Nprr2EymSg87Xa7sNZisVjg/Pwc8/kc9DymqheAAjECL1pP0GKk0+ng5OREwTUBMoEZQSn9mWn/kaqpCRcXiwW22y3Ozs5grVV1N4EuQV+n08FqtVJlb1EUePLkCYbD4V5BvjzPcffuXQBQawkC2VQlTBsMKmjTooCEtgSBbC9BNuHv+fm59nVRFDg/P8d6vVaF7HK5xNnZmR5vMBigLEtMJhMFzJvNRhXvTCKkXsy0XqHCdzweo2kavPTSSwCgCQXuj21br9fY7XYK0lOon9pkDIdDLU5ISE9Q75zDaDTS/qDKH2gTIIS2DCZL0nMghGYhRBb5JKhPYS8TAASueZ6j3++r6pkqZKBNsHD8eV4AtG1nZ2dqWZJa29DbmwmAdJ7So5zQ+9B2pygKTCYTjMdjXF5eqo1IWZaaZLm+vta+urm52VPoUzWd2qUArf0Pzy21WKHaHwjqbs5pKubZJ0wuGGMwm80UiDvnMB6Pdb7RN539z35gooPXEq1mWID09PQUy+VS70/pCgHeK17UWL8SFLWdzCHLBaZ2Ub3rIc6jHuW4/USB3d3wjbSzyJBtCwyuwhfWztKiWDTIlyV8kVhjpH0av+iaCMldbtRDXFjsMhOgDgppNBa+2wkqchPU1Kaye/v0RQDGQeF8MH5q8dEqo/decwiWKxHOShX9wvPUezSeQ92E5d6Aqth9biB1LFQpEhTMtEepmwg2Y0HJ6Nnt83BNSuwfT3sd2r8cquSTJBe9132SUEjPM/i9KjXU1whJPI+rFiNJfzxL5U2VO9uTqqZ5TOvVAuYpT/QD6K375O+E3Olz9PK2TbKvALd9ExWGJmtV385Hj2wJyu8Mao0ied4q9DUBEhMNTELUNbx1+K++8Pdw3xp838134f7iJPYJ9kG0SIC8VkLBOSqoY7FIV0RIa7z6gNMvGxVCkdgohpSuhd9m8F0XgXhUQtMXm2pwqjfV3D7pFnZ3ZFM+85A6QGiX+9aSheFi90YVtgJpk15PXkG8QAKrErTFLxNluLHB89sL0Aw8XIEA4dJ2RRBvYqFPAeC7Pqz4aKS1ivFJQyV5KlGre4l1CHIPqY7Q+xi/UsNzHUT8DS1L5tPKxz1cvDeItWELd3htmHDhp0nhxgK+Cc/n9GJKbcTihSvJvd9zqZG0iVJgrzCwfo7QB9xbBPCtCD5pV5rlSqA39vn54VbPH4c3omMc4xgfNN7QApdH8H2MYxzjGzp+L4A/4L3/a8lz/1hE3gPwZ/C1Bt+DwUALPRLwigheeeUVvPLKK/iRH/kRhWef/exn8eqrr2I8HuPOnTsAAnDrdDp49dVXtbDjbrdDlmV4/PixAl1aetCbuNfrqVp7Mgk3bALB4XCI8XiM4XCI6XSqYIyKVwAK0glbeQwWSCzLUmHoe++9h1deeQWPHz/G6ekpBoMBTk5O8O6776qNS+ojTbXwcrlU1elut1OV+2azUXVqemwCc0J9qqppBcL2jcdjBYK07ACCXQvV3Tw3AkmOFX3PAajv9HK5xGQywXw+V7sI+j0zaVCW5Z71CSHiaDTC7e0thsOhqpdTywoAmM/nCpOZoEgBKlXVbDuV6Cycmh6L0JogmMUnaYsBtLYbdV3j5ORE1eqz2UytPDqdjiqRF4v2g56gn2O42WxQliWWy6VC6TSR0Ol0cHFxobYtANSf/uTkRAuZUvFOu58UjPOc6fvNPk9tWAh4OZ7ee71OUsseWpJ0u131j59MJnj11Vd1bi0WC3z84x/HgwcPVPF9584dVcfT95tzjwkEWt4wWXPYd0BbNJbJEdr+cM5dX1+rKptzhQkotg+AKtBTGxd6lYuIKsxXq5VaJNV1jbqucXV1pYmntK84Z15k8L17ycH2DPpXGQZPHPIt4CsHUzvU4wKblwps73nUZ7FQ6SVgNgabV8L8Ov35HEMLmNrCS1ByHyqVhZ6fEaianYPvZq1vNxCKWlY1/DrMN+QZfG7CPmsbQDMA1wnj7/ll2aA1AFWLjfi8AVC7FnbSezszLbSumwCli6gqVlW30/ew7aq206KYCTCwsXilqrczfY/Ps/CT16UIkOfRpsQpOEj7IwDtg3mZWoiwP+smOZYgFL88AP1UvKcA25iojE6OiWckCXSApIXaQExmhESGIN0HN92H3D4Ca0mvXxcB9h44T1buWNcWWBUDKQy8N2G8CyYoor+HmGBtEvtaYYzzLaDhPxH4psEPvv1p/GyV4dO7j+JxOUFj2Y9RYe3Rek87iUpvge8G9bP6YzcJqEJQY7vcQyRCaC+hKCS7ONqXSGOQrQ2ajtOCkMjZb9DjUmAZ/OTj9l5aKxEBIIm1STKcyPCUVYoC5sS6BYjnyqGIftse8T18b8yxVCdBzSkOMHXcsXi4wiPbGLUxp++47UVobQSmSTuLbQn2KZ6uRhbKrSQTwAKmNMjKBJof4xi/QiJcxvIUHvZPvyk+3E8uP/svGB/qWHjAO2bJSJUdxLXLQTyPdpiI5OeHSPwcR5uschaAh/e2he76Gfp+0Pvp3316L/iq/CnGjnpx/647xjF+qfGrI/h+b7bFfFPjZFB8mS2OcYxjHOPrEucAfv4Zz/98fO0riucG34SVRVHg85//PObzOb79278d7733Hn70R38U0+kUd+/eRVEU+LZv+zb17yUIG41G+MIXvoC6rvEt3/ItmM/nGA6HWK1WqjzOsgzX19dg0UsqlgkiqYIty1KLM15eXirkonI2VagShhPkDodD7HY7tUTp9/uq7u52u3j99dcxnU4xmUywXC7x6quv7vmL0+uZdhsE3VmWoaoqrNfrpwrvNU2j++90Ori+vlZAzG0JNgl3q6rCYDBQGE7lLM/JWqtQnR7iqdKcdiGE2rRIITSkkpgq4lTFTMhONTK9sKmCJvimxQXV+UVRKPxnEUsC3rIs1Xeb9i+EthwzKr1ZpJS+5VQYN02DxWKhFhiEp1SoU+0LQO1jqqrCdrtVZTMtbuixzlUM9MPmubKfWOiS581imABwdnaG4XCoMJ7WHewrrhRIfa3ZT7TloEUIx42e+ev1WhXUhNCp1QmTE51OB71eDxcXF2p5wuvp7t27cM6h3++rZzgV7oTUHFN6Y3Nb+poDUDshADpG7OPZbKaJqX6/j7fffhvee9y7dw+73Q6z2QxFUeDhw4e6yoPzj8kzzmUWM+U8N8aoojv1W6cveGp7ROse+qO/yNAbANyoQdkX1JMM5alB/0owftejvtPB5tJg/SGP+rKB6TdwVbAc8F1BEwHd7JMG5VmB8X2DwaMSPhP4+KVZvA82JoltiM+COtflwZdYqgZSBugNEWA4gM9MUHvHffg8eH1L1UCSwoaq5rY+qNCi/QkKtPYpqlpOlNK2Bce+W7RQ10b1NCFxke8VfZREqUyfcLioCo/nJoTDdaNgQao6Wd4NoNsJ0DvPwnYISvE9S5TUioTnmyi/xbp9UB7tSQT2AGajVXknEB+ZUZiv55wkJ/Y92lt1fDCVTSgqfbRNlBQzuXBYSFMAiIG3LgATk4WfEqAmxKAtcNaGb2KCgspvSpd5TYtAiW+0kglt5muhbVIU8FkGiXPTNw1K3+Dz9R38yO0n8NbiHFUd/8yRcAhxol7bWRmgjy9C+1yG6N2dNjZuQyW1F7iOh2kCSC/mArfq4ZUfd+g/KpGtSnzhXzpDcZ2jGcZtGgTFN4E7Iugml6JIM7E/CKpvtFBKLW2wD5h9fJ8k4JzgO7VESa1SEjANRO/wVKQdIb+pAThBVocim03fI1+HN2bRyiQo40Mbsq3EJka1PFLFuqhVis890ISinsYGyK6+5Mc4xq+YSOBz4nktB+9JFeBeXyXM9gfv9rqow9JOiIldHy/5g1zns0Jza+/DkrmK5Okm7G+wfy4e6duf0fxfYrzYf9cd4xi/1DjpF3jtrI93b7d48+ECv+njF1/vJh3jGMc4xrPiHwP4QwD+nYPn/1B87SuK5wbf9Oymt/fFxYUWdsyyDHfv3sXl5aX6eKfewQDw8OFDnJ2dYTab4erqChcXF1itVloQstfr7RXzox0DYR/BHwD14SaYI1Skwjr1XmYxRyqNU39pwkd6hFPZSisQtp02HSzmmRbiS2E7i1dut1ttJ1XABPgEdtwHbV8AqJ0MwWlZlhgOhwoERUT7jCCQ8C9VXhM8E+ReXIQPNkJlwtZ+v78Hj9k27z2Wy6UmL7gv9rtzDpeXl2iaZk/R7r3XhARhaOozTtU2CzgCUPBJmE2Qzr5iXxAoE3zTEoP7IKhNkxxU/zOZkCqrqfZnMUrOPVrlbDYbzOdzPHr0aA/sAq1Nzfn5uc5J2uZw/qT2JYS1HCMqmdNEBRBU1LPZTMeFKyNoucLkCPuac+v8/ByDwQCTyUQLvlLNzblyenqKxWIBEcFwOMTHPvYx7HY7Vdovl0ucnJwAgK6YSJX15+fneq2dnJxo/52dnWnyZLlc4qWXXkKn09FVElwFcHl5qeO32WywXC41KUFbHNoTUSWe3geGwyEWi4XOC0J03psIw3nN0ZLpRQ3TtfBO4AxQesD2Bc2ggO0C5ZlHc97A9EIfS+4gxsM1oirdZuSwu2OQbwyysoPOsm7tS/jd07W/iPfwRRasS9JIvULztpBk8OSOu+vkT39Ltwdf9vdsP9B6drNYJIsnEhrznpRJ4gfeepyrKlqkhbIGrbd4ngGVa0G0Liv3QFklhcFsC2YJvfM476xTP3DtB0B/0kqE4Fts0lfpe2nj4mwCfg/7JyqDm9AeEZeo9JLwXkG8N8GWph2TBGhbCf2TZ5ow8Ieqd0ZqU+Ia7cvQNwb0Pff8fHdxf97DNyHpIZ2OKrlVHexDkc+0zxTWiwDWqrWML0v4qsL3vf0p/PD2Hv7Cw+/CZ967h2abt6rFxENafADztDPJtgJXsC/ZVxI8qdW3WmCqcG6miq95wOVhm3ogyE47yLsZOktBNfFtgUgroXAd8wap5QcB+N44Qa8z8TG5pLC79eDWiygquSERnD8t1gcPQpjuI+TXgpU8rkRQzeszHqfptq9Txa1FOU3rIR76MCi4xQOuCL/DBfWrsYBswvXLbUwdkg7HOMaLGM/Euc8Brls4njz/Qdnw+7zfv+++jvD5GMf4Zo43Xp7g3dstPnME38c4xjG+ceOPAPhBEfmtAH4M4Y+P7wLwIQC/4yvd6QdSfNNuoCgKvP766+oX/NGPfhRAUIZeXl5iPp8rvCKE/tjHPqZK6ffeew/ee0ynU7z++usoikIVyoRZBH8AFGDRK/j09FQhYup9PBwO8fDhQ1hr92w+qAZNAelqtVLg2u/34b3Her3GaDRCp9NRyEZgaa3V9lN9nKq7WRiStgtsb+rRnBaPpJd3CmOzLNPfU7sXngPV66l/eb/f1+MyCBSZfKAymP1KiJh6Nad2JCmsFhEtOmitxfX1tarb2Wa2n97s4/FYleIAVLlPwMv9E1ISnJdluWczwvFK+5WgNvWjJuSmF3y/38doNML19bUegwUUqeamp/d2u92DrJy3i8UCb7/9Nna7HTabDe7du6fnS8udoiiwXq91rNOxIeQneGfCgH2UJnaY3OCcp4UI+5zzIrXsSdX0TEaNRiP0+331Xud1wcTKxcWFJlo6nQ7u3r2L9XqtCngmGowx2s/0O08hMxDgP+ceYfSrr76qHvDD4VCtXlarlfp9379/X1c93L9/X61JptOp9v3haggeN523vPZ5/vSWp6I/tUl5IUMAMR4+d3ADQTX2qE8NpBa4kxpZx0EiJBPj4WoTCvRF6ucbg+rSYZHnaIY5Jm8J8q1Dvqph6uih7ai+RrBuaJx6akttWyVxEexPfAJMJf3u3LjWX5Q2JkAsMGmivYlpCzoiKr9py5EuDS8yLQbmM9kHpSLB/sS6AKiBfR9TgmeqndlWm0BrdwCUU7V1agXD9x8qvCVan+z5fqeK8/Y4oSCm2Yfv9uC4PIanRLhtixatfFa7AO0n3d6YAKedD/Yiziks9nF1Rlj+zuRCgM86zlEJ7q1Lks823qefvha1uCUBeDxHkaR4sPchyUB7E9q76PkY+N0OvqrwV9/+Mfx4OcJPrj+Kt2/P0GzyAJxLwnMEz2vxESYjJDtKUfAs0cIDPlpv2ABq4doz8BLeJ1aQzwS241GfOtjC4MFvzvHhH6gxeOixvevV6sRHtbl6f3O45BnQO7ZV35P4bEu0HvE8H9PuSxIvYB8vMHHtuXnKQQ+9wk1MmqRD5ETvDT4Px6Cvt+tAnwtJgJBE8TlUpG/qCNajOt00MUHQxPdk4Vbjuh6dWWijHR2B2jF+pUWSwUqeefo9H2yP9vDzJT2aJojT1571HOD3bFi+suvveNUe4xjfXPHJlyf44Tcf482jz/cxjnGMb9Dw3v99EfkEgH8bwK9G+EPmLwH4M977B1/pfp8bfLOYXK/Xw4c+9CE8fvwYL730Ej760Y+qypnK1KIoFBASuq3Xa3Q6Hcznc2RZhgcPHiiYohqVRf0I/gh+6T0tIhiNRgq9AKiNBwsbEray4B5tM3q9niqz1+u1qroJCB8/fqz+17QE6XQ6uL29xd27d2Gt1dcIpgeDAW5ubjAYDPYUyoSEbHtaUJNAjmpkQjwAqjLnOdAru9/va1FKgnBCYQAKVQkbaN1CwMzxy/Nc7T2oaqaSvK5rBYZp0oCJBf4k0OXrQKtY5lgTcqdFO621Ct2pMk8BN1XZqWUNATcBLp+n6p0e3FT8pr7ehLnpSgCC7lRpzH1wTNfrNebzOd566y31emfCwnuPs7Mzhf5ASD5sNhtV2VOVzzk0m810jFarFe7cuaOrBVgglAmS9Bpg+9kfaR+wvYvFYk+NzxUCVPVvt1v1S59MJqrKHgwGGAwGmE6n6Pf7Og+YSOAcZ18STnNucWypogeAy8tLPa61VguZFkWhfb5cLnF+fo7dbofz83Pcu3cPs9kMm80GNzc3qOsaT5480XnHsWdw3vAYzjlNYHClABMq6Tx9EUMMF0y7trhdr4FkHkVKnb3ARbgpSVE8dCwgQGMFa5Oh6WUYPDaYvO1CUcraBwsR74Emwsssg2kaoEILkDMTYG6eqW1Je+xUrUrVc4SzucBzAZCL/2VZOKZNrDMaG/btvfpAHxaL3CuESRsUIOwjM2EfQATeB2A1AuFnhkugu3PBziIz7Ta0XUmtS551/nyfSUA9AFgb2i4S4Hfqmc1zs08Deo/ooZ16hqfnxCBMT5+j7UrTQIpCi5wpyKaCmyr0uom79XuKcd3joVI7aUNas6Ddt99//hDwJ33n6xqoG7jlEt/39qfwf3zy3fjb734C88UQ7rYDZB5mZ9S2xBWAROsO33WIpUGDX3UWYTYQClKy2bHQZbYDmtG+HUi+FvSuPOqRoD6P762B4naL3W8caHHK0Ne0/kBbiDINtVFB++LhtJPYzwkU5/MA9DpPobaXZL8FFFan7guSHi+9ZRof1OEcNlWKt0A/2wH5RpBvgOoMqKO1S7YDkIXXbN+rPUu2izYxVbA9yVfh+Wrij1YnxzjG1zx44X/Q145xjGP8Sok3XgnirTcfHMH3MY5xjG/ciIB7r4iliHxIRP5z7/3//CvZ53OD7+FwqEXvUn9gqnRXq5VCJ/oes3Adt6dierPZYDKZoNPp4Atf+MKeTzetLNIvxLTbMAmAKIpC7QyoHKNaGIACTYIxAvlUAUtbClqZEKgSVjrntMglFbePHz8GAFV7TyYThdeE7KmCm4CeFhq73U7BHAsb0nfZe4/tdqvWKOPxWItp9vt9VX0Ph0N0Oh0Mh0OF7vQNB6B+34T6VCEvFgucnZ1hvV6j1+vpPouiwG6321NXs783m42C2uFwqEmDtDhiaglDSxfnHEaj0V4ipCgKVS0Tcqe2JWwLx4tFEKla5z5OTk7Q7XbVUqbb7e4VDuXcZDupbC/LErvdTlcLUImeJiym0yl+4id+Aq+99ho+/vGPK7zn/CKUBVrgzp+E7/Q/5/yiUp/zoWkarFYrPS+ODe06mKTgNcHzYXFI9jV/n06nePnll9VGhvY9VFyniZU8zzVhMRqN1H+e7aNfOvuHAJyFJXmuvOazLNPkAOfD2dmZJnhSCxuOPb2/AWA2m8FaiwcPHuDx48e4uLjAkydP8OTJE/R6PW07i8lyNcehpz/tWlL1+h5Ue8HC26AslQiBjfEQ46LwOdyfnDXwXmKBLADiIZnf30fh4QYOlTNwXYFpOhi9C/jcIK+a4PsdAbjUjRaVDDuI+yryfeB7OC7J7542HyaoQ4FW+R18rhFVs9LCV26btYUqtRCkc9Hv2qvqu4WxB8c3BrCNtl2LUKY+2Ht2KYl1SzxntRwhCBZ5Cvo+5eNNOC6yp/QOQN5qm4VK8WfYl6QKc2Eh0kPYHe1BFOTTGsY6gCuP6M/tfavyruq4nwPVtvP6WYc0yeRikoKJg3heewkEidj5QIUeXkqgN7dhcqJuApQXCX7i3Qy/9qcMfvuP/UHUsx7MzgSHkiooo2m5EcYmzi/j4Wg3U4TCjVJLy5MdEruToF7OSsB1Ba5ggiY8l1VA2QFGry5w9maG8f0O6rM+qtPod00FdGKl4grgKaNfJwfLINiY5H3PgN1tp0WazuqTOHgffyY+5XoYKuCBBLb7YF/iJBTSRFSeRw9x+qDbHv3Sgye4j/cPnwUlqe162F4Lum3PhwSEDQA9KwW2C/SvBOVXXKrmGMd40eIZgFq59bPg9fsB7SPoPsYxXrR4Ixa4/NyTFarGoZO/j7jjGMc4xgsZIvK/B/A/RlBabwH8AwD/nvf+F5L3CID/AMC/AeAMwI8D+Le99/8keU8XwJ8A8C8D6AP4OwD+oPf+3V9C884B/F4AX1vwnfpvU9m5Xq9xcnKiwJJFFcuyxHa7xWAwwHw+BwAFhPfu3dtTXK9WK3z+859XKEaFMEEnVaf07k7hHwFhCrloZZHCSaprCTC32636BG+3WxRFgcVioaC7rmuFw8PhEN57lGWJbreLfr+PxWKhcJo+1zwW1acAFPJTKU2InXo/0y6Dx6SKFYDaNhAkU6lNoJ2q2+mDDkATD/Qc53bs04uLC/Xr3mw2qjSnHQqtOWgfQ9uN1JZkuVxiu93i5OREt6ONjHNOx4z74XacO8YYtcThfOE+OFZUg9NOgz7f3BcLLtKrOwXxBPZU2dOWh22hxzaheFEUuL29xf379/Gxj30Mr776KrbbLSaTifYv7V94LdAih3M2LVg5nU71fVVV4fLyUpX52+0Wm81GwXC328VyuVS7H54TgT4AtXYhCE6V1yxKSb99jt9LL72k3vYs6Mqisuv1Wu12bm9vNTFDD+/VaqWFXAndgX01eJ7nuLi4UNU4bVaoxq/rWudP+pOq86Zp8PGPf1yV8Dc3N5jP53jnnXdw584drNdrTWRtNpu9pBiTcLwv3NzcaKKDvu1pouxFDGMcnDPIjIf3EuB35FvWSlgSLR6SBci9p/gGYAoHF/myHQAQg+WHBPAd9G4tsl0o/mjqSotCeiMKPMUlamlJCkceWoPY4A8eDhreK1Wzr9RmOARP8MZByrjygsptbTiCRQoixPQ+2pkk0Ds9PpXUjW3V2hKtHlLVdyB+T7cpVWJ7D7G0opC989c+IfyOsNxTCe+cKrhlV7WQ/RB2p/2XWrBoH8U2JzDa770ej6FQuQnFKQm2k896JhL2jumSfXO/e/1p9gF7/KlA24iq6/fU3d4BptPuj/tJ9u3pTw4f3n9+ir/8qY8DuVcrjnwrUC8Qsw+xxQAOAlMG5XG2kWDTE32uxWPP4zv93RuvNiFUPJ98scTdv/Eefu2/9Bg/s/vV6N4ssfz1L8F2QhFIFre03aiUtq03NtXWqo8XtH7k/F0HAk8rvfceJ+fM1w738SypuUAtUp6yXYm+4T4mELSQJhm9hH26AqgmEYYzV1SgTTB4hHPOfLjPOMB1AjivR2Ff9ShA8mMc4xjPEe+XBDuKto9xjGN8mXjtrI9xN8eybPD5qxU+GUH4MY5xjGPE+C0A/jMAP4HAiv84gB8WkTe89+v4nj8C4H8N4F8D8IsA/n0Af0tEvtV7v4zv+dMAvhfA7wFwA+BPAvgBEfkO7/3XZVn+c4Pv3W6H8XiM2WymBSnpnwwE4ExYnOc5rq+vsVqtMBwOAUABM+HhZDLRfdLKg4rT6XSqilBCV8KsLMuwXq+xXq9x9+5dfW40GuHx48eqqE49lIuiQK/XU2iXZZm2v65r3N7eAoCCUFpIUI2cwlRCW1po0CYiVTsTXG+3W4XB/IJP24eLi4u9Yo/0n+b+i6LQ49I6JLVAYRuaptFxeOWVVwAAt7e3WK/X6vVMdTVBsTEG5+fnagmS5zkGgwE2m81TFiWEoCwYSLsQtoEWJQC0vQSStF/hPnlehNxUGjOhQbU5+w+AQvVUvU41MY/L7Zg44NyZTqeqgOY8oYKc1hgAcHV1hS984QtYLBY4OTnBq6++itdeew1PnjzBaDTS5AvBOeHzcrlUm5F0xQGV4bvdTucFky7L5RLr9VrH9fb2Ft1uF7PZTOcj5wohNvc5Go00uZHnOcbjMTqdDk5PT7XfqS6fTqdgAdfNZoPtdqt2OZw79MymDzfV9svlUgF+qpYHQlKFyQkmG3g9i4iOT7oKIrUhYgJlMpmgKAqdZ/1+H+fn56jrGpeXl1gul3j77bd1FYOI4MmTJ+qJTgU65yILe06nU0ynU/R6vRe6uKV3AttkgacCyDIH56RllzYLyu+o+JbMh5/xW7PJov+3BI9f7zxc49GMgdWHBN5k6E5N8PXOoxLZmqDuRlCEY70LINc69fdWRTegRSflwBrDG4EYExTH6UmxKKCPdicpjPUeUtsA0CV8+xfnAriOcNZnWasEZ9jEruRgfwpbO0V7DGOAqm7Bb5YBJniYB7V3VJxHz2ufRWhOCOya9nHcP2F4O3i+3XeqpPZei1cq3TAIIDr1wI7nrLB77/UWgHugLdCpfXEA0Ln/9Fj08k7aLEmthzQk3iufKojpHWBigVK2Lc9Dn/moBme7IgAPfuAu0Os7Z7j/Oy/hM8BUPtjMRIArNqq7s3CO9J3ma8bFnzZcHD6HWnqEbSWIp5vwO2K+Q4tdRkiebYHtZYH81Uv8zO89gxsUePLPnMFlArE+WKNwqLN4rXFFRSTEXvw+1E4H5/2AVvI+2qcEuOyf3jYF4IfQ+3B/h3lC38Jw7lv34KXtMw/4wisUB8J9A07i6oeglOeY6C5MgOUe4Xnz4jpTHeMYHzwOr98j9D7GMY7xHCEi+OQrE3z6i1O8+WBxBN/HOMYx9sJ7/z3p7yLy+wA8AfAdAH4kqr3/VwD+uPf+L8X3/F4AjwH8zwD8WRE5AfD7Afyr3vu/Hd/zrwC4D+C3AvihX56z2Y/nBt/0MqZKerFY4PLyUpWpBNu0YBgOhwp5AeDs7EyhMy0vCN0GgwEWiwXqusbFxYUqe8uyVAU0gRuhYL/fV9sKqm4Xi4XCPgJTgjWqXQknZ7MZsizDcrlUcEwwenp6irOzM3z4wx8GAIXpi8VCz49KXIJK2j/wJwBta1qgkI8JQhkExWkRzKZpMBgMdFu+1ul00Ov1sF6vMZlMMBgM1I6Ex+U2BNpp8cssyxTspwUKU9sR9ne/39fXVquVtpFjniprqS7n6/zJ/qfiPFX5UTlPCwxagdCXncCb4DctXkgLl7ToZVVVuLm50QQGoXdd12odwrlV1zUeP36MR48eYTqd4iMf+Qju3bunNjpnZ2dwzmEwGGgBSZ4n+5kK/6ZpFOgTiG82G+27tEgp5wFV1+v1GlVV6YoAXiPcd57nePnllzGZTDSRxAKVRVHg8vISg8EAZ2dn6PV6arvCJBGtSxhMGNCqhO2m+v7q6krtZvr9PqbTqc4fJnfW67W+n5Y5acIjnWfee+x2O31ft9vVMb25udH5TGh+dnaG6+trnJ+fY7VaAQgKeK4WERG88sorep60SKLqvNfr4fb29pkg7oUJfgk2HkY8RDyszZRMaWFL8TB5hHBOgjXKs/aDAKpcForb2R7QDHLk6yYW7QuAm/Ya4kxbFDJjgUpENTTVzwTS0ha3BNSfWgh6MxO5XaI+fkbsFc8kNI1q7b1t1X6DEDJ5jWpo1z4GoLDai4NkJvhLA5BOofvwGcGra/eV7UPuFKirsviwbQqa94tsHm4fG7R/LjzuU0p53xbRTPsmfd3aFkIbCRC6SgpVkmo6D09Fd2yj3tPj9joWWdYq4g09M1yyryYAb2mLjIpIKJBJ+xf+axpADPx6jXf+wLegvHSQRmBqAJAIwZUpt5z3EAIjKrurKJTOI/BOXs/K8H7XaX+KRyiWaYP9SXUCzD/pMfrwCV77/06xe6kPcUB5J8L0dCGAwX7ShastopI6gOX3UXunz6WQPP2HqNz2UKV2OEwCw99vAQzV51aePm4E6uJlrzimzwLYlr3+ldYeSAm4j8+3yvL0mD5pqxzB9zGO8ZXHC/znzjGOcYwPFm+8HMD3Z44FLo9xjBcpxgc2sKX3vnyO7U7iz2n8+VEA9wD8MN/gvS9F5O8D+C4AfxYBkhcH73kgIj8X3/ONDb7pM02VNlXWBKEEfIRchNOEsTc3N5hMJqr+pV/vbDZTKP7w4UN0u13cuXMHg8EAV1dXCr7ow8wii/RTZlE+gmwCNQL3tLDhaDTCdDqFMUaLLBpjcHFxoe3t9XoYDAZYr9dqyXBycoIHDx7g+vpaVa5UHQNQJTcV7SkYJZjj+7k9QTDfw/NKwSwtVowxOD09RVVVGI/Hqlyn+ng6nWI4HCoIbpoGl5eXePjwoVpY0NZiMpnseSKzwCS9nblPKngJ4efzuSp0Uz/tXq+namCgLXAJQBXDhON1XSuEZRKDSunUaxqAqpnZL7TC4cqAFOayL6lkpoUOPbOXy6WCZyAkQzabjdpqEHoz8UE/adq/EETz+Az6srPNzjlN5Mxms725wJUH7DuCZbafCmmOK48/HA4xmUzw0ksv4ezsDJ/4xCee6us8z/Gt3/qtmuQYDAYAguL99PRUkxT09GaBWUJoWhVxxQTV7al1C69D2gRxXnH+1HWtynuO+9nZmVqmLBYLXFxcaJ8yIcSVGOw7WhB1Oh2cn7emrw8ePMCHP/xhLJfLPd9wWtksl0vM53Pcu3cPb731FsbjMZbLJV7UEPEKsZ0XuDoPQl0BxESFtZfAS8mqrLQsWHlthGGZh+84uFxQ5UGVbTtdTN7J0AOQL3aQxgZvakLiQQ8+ql+lCUUx/aG3c/TBluYA8B4qvuP7pWz2AHUKskUc0EirQAcOaKa0QC61OaF/9CFYNybYkRx4UMOYVslMC5NUOc79GdnbVhob2k2wbJ4Bxd0BvUhV36ltCtDaibAvE6DN+4iqpNN9H6qvI/T23gOWyl7Zb4s5JKJtSBHBdWI3o0U32QdpRkUiPbUsWOqij3QWoLkBqPyGTeaAdQAcfvE/+vXIyrZtruujpzcAAzgTwLR4AHVyWCcB4vIJH1Y4mDKov6UBIAF6206A1y7zyKrwmjetKrlYAbtL4OKnMmzuAdvXx7j9RA7bCT7W9Ob2B7BZFc8mfY8Pv8duUduSAyW4wmcFxXxfMjbGhwKV8Tmj8z2oq/lY98vilc9SiMefBNYsBsoimHuW5E5a/3DuSJLHbBLtVgjEfUxC2OTYxzjGMY5xjGMc42sW9Pl+8wi+j3GMFykOvbX/TwD+2JfaIKq7/xSAT3nvfy4+fS/+fHzw9scAPpy8p/Le3z7jPffwPiEif+lLtQfA6Zd5/UvGc4NvwlPaTVRVpdYJqRVI6rFL2Mag/cDp6Sm893j55ZcxGo2wWCwUSBNQE3TfuXMHt7e3qiynRzPb0O/3FVjyZ1EUCtzZdgKy/z97/x61y3bXdaLfOavquV/f23rXZV9XdkIg6VyNgVaBowimQcULjYrclBZwaLcOldEcbT0O29HDI7Z34CAIeBAOgm1zQto0coRz7KA77CSCEpMNyd7Z6/renvu1quY8f8z5/dWs5107WaElO9mrfhlrvOt9n+epmjWr6l3Zn/mtz48p0LBZIQH4cDiUpoIHBwc4OTlBv9+XRpCNRgPz+VyUGoDzPBPoEmRyHwTMhK7WWvT7fZlHbou6DDqSmXQHIGl3esUJkAlUb9++LYA01FFEUYQrV67I+9is8LHHHhPA+mu/9msyDwAkIU6QzxQ8AEkXszHndrtFr9cTDzc/z/Q4k/FsRsjFEepCwiaaXBQgwK7VanJemTBmgpuwnU0WgUJRw1RymqaSuCYoZ+obgEDn8/NzXFxcoN/vy3lkcrterwuY5XVCd3roj2fDUaVUqVllv9+XBQXOBbe/3W7lXHEsXPDgnPOaa7VauH79OobDIV73utfhDW94AwCIRoYKm729PUlmc07pX+fcnJycyP7ZFJXJbTaGpP6GvvGwOSjHO5vNUKvV5Fo4OzuT+z98SmG9XmOxWEhjXK01+v2+aHx4rnhdceGGTwkQqAPAU089JYtVnDOeI0L209NTHB4eotPp4MUXX8Tt27cf9tfbq7ce1OgOkIaWhdnDO75fnm86SKcsEAFZU2HbB5aHEfS2Bp0ZqKRoaKjnaw+NE9jYKVFgDECXd+5gX1lPEhQT32y+SPBqrQPsWpXUIgJYcwsFc2l7yloYHbnXfIpcti2TYn0S3X21yc4/j2FaPFS28DVCbWNcs8sougy3jXWvhfCe2+Lx0m2dew1JuEgAlLe5k+4uObOVKlQukiJXRfIaAEwOm2VAmrrtRpFLWkcRYHwTSaa2xStuoTjvxgr0Vv7fFancADoqkttcEMkyYOuOzWaZNMNUDS6aRm6bfsw2y13a2xrgwC2GWQXojYPdRnvAbNwTCSGQVWHTSJ+wdtoRiHpDMdUMB7hV7kGsgvw/JGWct1qn7mvuflVh9AYLU89xtxlDZ8G6ijRO5b4hnusQeCsCYwWB3gK0FRzE9u93mytAdgHEIXOifCJd9u+T3m5+vFqGl62BNIcVTQovrbDhZQDfdyG5YlKcQyoHvYtzIeP2x8sxM+luL/8KqKqqV2eFF3q12lNVVVV95uvzrxXgu/T/G6uqqqpXc90AEKYCHybt/fcB/BcAfssDXtv9PzHqAT/brU/1nsmn+PwEwA9/ive8bD00+KaeoNVqCSjWWmOz2ZQSskyAApDGkCw6nq9du4aLiws0m00MBgPRSbBh3dnZmRucV3GwQSYhGMEcU7UEk7PZTACqHGAcy3jZcJN+YjY/bLVakjwllGUTvjRNMZ/P0e120ev1cO/ePdk20688RgLeMAnOVC0BcOjqXiwWkpBlyhuAaDuYEubr1Ihwn3SRs3Eg/+HiPPOzHFvo1Ob3TJQTzIfKCq21pMsJb8NGnkChzQAg2hV6vAm0R6OR6D6ouyBUbTQa4ozn11qtJnoUzgsBNt3sXDzgWNbrNRqNBtI0RafTwWQywWAwEAd56ENP0xTj8Rjr9VqeQOB2uEDCz/H9BNxUvoTHTnUN55vjr9frkpQHCl894TNheBzHsl9es61WCwcHB7hy5Qpu3ryJw8NDvPWtb8VgMAAAWUCx1srxdrtdGTfT0lSXfOxjH5P09WAwkLmjcof3MJ+g4H2zXq/R6XQk6c5FhTChnqYpptNpaU622y1Go5EsHHDc1K8w2c39tlotzGYzDIdDWUyLokgWsMK5pUKH4+aCGq/vWq2GdruNK1euPPiX2SNQ1irfPFA5rYn/yuBtGG5WdDcr/zkUX32HxyKNqhQQAXk7x7qmkTcUsmaCbkNDpxbJPEM82TiAnGYO5FqXShb9hbingwEHUFeluWhDBAbnBgq5QF5pApn5JpHUqnj4jch91irlHOKxb76plAOxQBl6+xLftkBeVeg//PathlOcEDwTLnP/SVwksf39IAqISJeBN48R/hxEqgDo9gFjsRY2y5xrPATcfjvh4q7TvChIJ0Ued6gUAaBUBrvbCNZYB7wjjVBD4sC9KhpgGv81THSHzvLQ2b3rHM8hmhRkGbBy+1Q17ieWbQCAajbx4u+/6hQ5ysFpG6NoPpm45DchtSp6dPo3KA+/fag6YbNJf+175YlJCnBstftZtPKJ79RBb5UD24GBzuDAcgzksXXJcGpOtC2DcA+9bQjDvfub94I4u4ECbrPJpN6B0RpArookNeA0QhGK/0tJ2C6gmXOgJH2ucpQ1KBaFNiUcCwH8TipcALdR7hj5sg0+Z1EAbxmb+54PlZhHtyVDVVVVVVVVVX3G6jVHHURaYbxMcW+6xtV+85UeUlVVVfUbXzNr7UM/5qGU+nsAfjeA32atDdPihKHHAO4GPz9CkQK/B6CmlBrupL6PALzv5fZprf2mhx3fr6ceGnx3Op1SQ8AQWm02m5L/uNVq4eLiQuAl30/YpbXGlStXYK0VRQg9v6enpwIsCTnZrI96DMBBY6ammaimR5iQGXBwer1eYzgcSlqXx0DFBpvrUWlBhQuhPn+2t7eHg4MDvPDCC+JjptaFDStDxzebRdJLTEBKlQX91XRrE4gSUHa7XYGwTGAvFgu0Wi1Jeg8GA4GrvV6vtN/VaiVAn4lepsaVUqILYfJ3PB6DTSYJGdlocj6fYz6fSzKac0RfO+CAfbPZlAULuqwJSJfLpSSBAcixM+nbaDTQbrclWc3rh2lgwtjdlek8z0vwv9/vI01TvPDCC+LEJtAPIToAAe1MltM3znkh8Ob54bUDQH7GBQ0qWTjH6/W6tCDD6zFMtzONzkUjLp40Gg0MBgMcHR3hiSeewGtf+1pcu3ZNGpRSwcK0OMfNpyCm0yniOMaHP/xh3L9/X3zjURSh2+2KdoWQO9Sy8LpbLpfY29vDarWS17goxGuA55Xb4GJBFEWYTqfI8xz9fh/WWsznc8RxjOVyicFggCzLMBgMMJ/PJeXP65fpd84b/04VC/fHBZ5er4fz83MZc71eF+XLo1g2dwAs/Kpin9bFDtNi4tu7wEvbwQ5osx7cxRY2yrGtu0aXNopQm1h0UoM4UrC1BGqzdenqGA56h7YLD6GhtShQ/AsOTufBONjQcVcDQhjM8loM66GzbMMYqLSA38iNb8JpypC2mIwCGu+mYAi/4dQt2PrfB1pLWtvGEVTugLxKsxKg5mulfeY+IR6OwY9bYLf1543JHL6H2w584KURh8DdA2y1C7mD41ScZw4n9KYrBUQerDM1Xiv2ZsNkeegcBwpnN/dnlfOER5GD3nkuY7Bbvy9r3OfiGHa7BWoJtkMLlTlFhlzIHtKqVIknWqcAVRrFNew+a2MLnfkFDAvxTNP3DRpjlG9wyQaOykHvvG6RNwBbN7C59vC8SJCXQs6cHm2LVHV4A/JHuQLyYJzGjVPOg0Bmv/ATRqv5uvLzHbi6S/0std8hFeu7ANyo4rWStgQF3Sa45gKZgltY8zssvPUF0JbjVzvXZmn7L/dCVVW92uqz5WJ/ubvx5cb36b6/qqqq+mytRhLhNYcdfOT+DL9yZ1qB76qqqkrK603+HoCvBvAl1tqP77zl43Bg+8sAfNB/pgbgiwF8h3/Pc3DCyS8D8OP+PVcBvAHAX/gNPoSXrYcG32zwSMAHlNOiQDlpfHh4KLANgHyWoDxJEtTrdbTbbcznc/FJE5weHh4iyzLcunUL1lrMZjN0u11pyJemqYCyPM8xnU4FBIepXCZqQ2geqlLa7baMhelfgmIe38XFBWq1GrrdLlqtFrIsw3g8RrvdFu0J070hrCOMDKEn54CNIply53xmWYbFYoH1eo29vT3xUzPhulgsZF7ZBJKwfzRyCypsWMk0LtO6hOo8/jA1XK/X0Wg0cH5+XlrgoJOa0DpMrvNccZGh0WhguVwK6Gcyvdls4vz8XBY22u22wH96xukl57j5hAHTy1yEYEo7TJpz4YFNPDmnnU5HUsyEpkyFj8djSfKH2pUwRR766/k9gFKjRwL5MOWttUan07nkOyf0DzU7PO8cM+e1Xq9jb28P165dw9NPP41nnnmmBIe5YES9CLdBUL1YLPDcc8/JYkCtVsPh4SH29vZEp8PjNcag3W7LIhDT3MfHx7IYw/3yOuQ9xfv24OBAEvN8SoPKGHrp+X4+tRA64Kn5mc/nsgjBz4W/g7gAxyc4uGjGxY8kSXDnzh0Mh8PSIsUjWUZB+QSmiqz8/UH/maqUT6NSgaKt+zsb0jH5DeUAWuwAGnLnWE67CiZWiLYxgAbqAKKNW/QMm07CoGjy513BpbK2eD1MRovKJPjAbuKZPzYGVpwNn+Q/ypUnkB4EKwHsxv1sV2VC4MzXHrRtqliSuHg9c00jbRI7+B3pMhCPdBm450FTTAJtD79hLCzPoFZlCB683/oFVpfUjvzhKgeaQ++4tbAmcsyUSpnd9LbJAR0V+700j7qA2pEqthNCcDq7+T3g3ODGwlIR5pujKsAthFj3+wJ5DrNcYvMln19KQLvx+z8GJY1HKTkdQGCbeNirITRbZd79HRwe08p6rWAiIG0DUeogeW2iEG0BqyLoDMhz9bKNGQvlCS45umFQNJTkNpjijovBWH9vhk0trU9LP+jxZLurLPKLVpbNNDX8tVa8l3qVcLxuY8GEEHirYK4E7ls/50qOW4VQPpjT0rgAn/z+ZFS8qqqq+s9bn+xm210ar6qqql6N9fnXegK+f/vrH90nZKuqqqpL9Q8A/GEAvwfATClFJ/fEWruy1lql1N8G8J1KqecBPA/gOwEsAfxTALDWTpRS3w/gu5RS53CNMf8mgF8G8K8+o0cT1EODb8Iowk6CcMJhQm8AkoQmKATcf6ARPMZxjG63iyzLcHFxIZ5fJjm32y06nY4A4dFoVIKeTNRyv3meixc5HCMASfgCkHQtUKgTwkaU/Gye56JjoLeZWhQmurMsw+npqaR1mV5vtVqyP8JdjiMElwS3oYuc8LLf72O5XOLWrVvo9XoYDocCtXn8HE+SJJKk5QJE6EFnM016lTmPSZJgOByi1WpJs8M8z3F0dITFYoFGo4HFYgGggKw8FsJHpmr5H99pmqJWqwmY5Lk0xkhjRWozmDxmg8jhcCjND6nQ4XXRbrdxcXGBRqMhCxxUl3B8Sim02+1Sop8LJEyW81pZrVa4d++e6ETC+aNmZrvdlpQkVMLwHIXnrFarodPplBLcbKraarUE9J6dncm5WCwWsmjE65famn6/j6tXr+LJJ5/EU089haefflqUQCw2hOS5Wq1Wcu2enp7izp07ohDqdDrodDo4ODhAp9ORRR3eMzx2Hh+bS9L1zkQ+ANECcd8E6pyD+XyOJElwfHwscJ9Kn8ViIYsy9JBvt1tZ5ODvGC6a8IkC3p+E5lxgoR5msVhIM9Tlcoler4fT09OH/dX2qixFvYFn1YoJTiY1pTdkAEFh5X2E3paJWrqSpSmfT0T77eQNt6PVoUbaTtBJNFrbDLYWF40r/fVrI9+kUgX//BC4meJ9UtYfBKGz8U00SwesgvcGcJ1gmE0SQ6gMeOVGkU62kfaaB1vA7rxIXl/6AwRp60hS3Uhi97Nterkx5IMc4dwHj4GqEX/MCoA1AVC2bn82yx10NsEcMxWuvGKECw+7++RruUu+q3hnTgEHvY2FW+EogHsxf87/zUXlkl9cdDWmDNMB973SgDZQtZpLf/uyaSb7sMbip1/4t/hP6QZf+w+/EFbbwqXNdZgU0KmC8aoTAE6DEnknd80Pda1g6rZwehsliWhNUE4Ga1E0u/TrZ1YBtYlFtHaO+/rYfd5qexkY8++Ev2wsy4UjoFj0MUrGqyyKBpil7Tx4+6JNsT4FznWOAEzbQD9C8K7YQNO4/VuFkqYEwfzK90y+QxWu70+2ruSbiX5ShhZso5ROr6qqR752V5/+c1Z4cz/otU/3M1VVVdXnWr3+ahf/yweBD9+rGlxWVVVVpfo2//Xndn7+TQB+0P/9bwBoAviHAIYA/h2A32mtDR3ifwZABpf4bgL4WQDfaK19mbjQb3x9Ws0tm82mJEOVUqIyODg4ED82U8ZhGpqfZ8M+Jj2ptWCTR6auR6ORQDLus9vtCihcrVYyDupC2DCT72Fylw0WCTcJ+qiV4PetVks+z7GETSQJZKkOybIMJycnSJIEg8EA0+lUHMMhgG61Wlgul7IQYK0tNWjkH44p9G/neS4ebEJgutQ5l4TNhH8AZD4PDw9l/qlc4TG2Wi2kaSrQe7PZiJKC54pwPdx36OrmAkColCBUByBJeqa1qaXhXDNhTNjfarUkJc7PEYwyCc7FiLDJJAEpX6P2hoqU8Xgsnm82Xd3b28P5+bkodkIATNc6k9TUkwAOpoeQh+csTGqHT0Dw/I1GIwHg3FaoKGk0Guj1etjf38eNGzdwdHSEZ555Bq973eukQSWvDQByzpVS4lBfrVaYzWbyxMDR0RE6nQ5arZbcd1xQGAwGko5fLpcClakXop6GjVO5mBDqh5hQp1ObUBsowDyVR3wv7wkCMqbNqRaiCojXPK8tnl/ONe9vzufZ2Rlms5nobKhyeaSLwJv/HevJkgmb54XJTRSJb5srH5Hl60F6U1nRS0Bb2Mh5kblR1/gyRuOshrwZIxmt/WcVlDWwOgLyHIpNHlUB0BWd2dHLpKoJloHis6L7CCB1yFnZcFIr7+S2BQwONB9WGkum/pCtpLQlCQ64ZDjhbBwXiW0mwbWWlLdrEhlAbW6LDnD+jEXv+K7fm/7u3BQgOc8BpSVhTdhd0p+E25cEeLCvPHfbI1APFwW4/8jPqzX+eIL3+f3y3w3xiytdrK6E54Fzzm1Yr+ABgCiC3W4dBM8BmBw/dfv9+Gia4v+3fAbLqwYqUzCxhLVdytv45LI0avTQ2r9HgGpSQG0yYtecMbi8qPrgYeRu+9BAtAb0Ftj23Rgc9IYktS0QgGL/bwTvJ96HHiCH96RoW5QV7Qo0Cmgddq/kPnbZ1O7PeD9zwSuy0jzTbcoWoHxXlxI0vSxrWdx9Kpcrh2ZRpOiDspLkDsavggUHZQsdjEWhSamqqqqC+hQrTL/u+vVs80G/eKqqqqrPxfr8q30AwK/cqcB3VVVVVZS1nzqKYt1/8P0V/+fl3rMG8Kf8n8+KemjwzSSvMQbz+Vwcxf1+H7VaTZQmYWKXjRABSKqVyW4qONI0FX0CAeBwOBSf9WazwWazwVNPPSVajziOMRgMxC3c7/cFwGmtMZ/PS6lrNrekCzzPc0lq0wfMBHIURej3++JnDps9coxsrLlarQSUE/jxM9w3E+1M2LL5ILUXs9lMQC5VKgSdBPOEyWEylyCQc71cLiVNTqDMhodKKVHEnJ6eol6vY7Va4eDgQFzKACSt3mw2MR6PpZFgr9dDmqYYDoeSZAYgAJ2pde6D2gmmpwlBW60Wer0esizDnTt30Ov1JHnf6XRwcXGBvb09rNdrmVsmhe/fvy/nF4DAV6DQb2y3W6RpirOzM2y3W1nwYHKdkLpWq+H8/BytVgvtdhu1Wg3Hx8c4Pz+XueFnCVgJakPwzeSy2UmoMu3Oz2y3W7kG6XPnNji/rVZLHPLXr1/Hm970Jrz5zW9Gr9eTRSVui195TfF64XUKAE8++WQpBW+tFQ860+PhdRHO7S70BiDXVrj4ADi9DRcKuLDS6/WkASkXeNbrtWyLC1eE0+H+Qud9FEWYzWaleWcKnb83eL1z0QkA9vb2sN1u8dJLL32yX2mv6qK6RCmUfL0m08V/u1JjQo2BBpR/0UIViXEb/D2yBVS2ADINq60D30bBtC2iLYC1wvJqE7VJBtOIoVepS35bC5XmQM0n+akZ2QXcofc6BN3u4KThpYBcJrM9TGdTS9coMmiqqJRTkQggDmGwd3IDzjutNZTWDojnuQPegIPeee6gdwCtLRteauXAt3VaE45JjmE3MR5+bwLwXa8Vc6GUS3wTJjOJrW3h25aBMGVsCrUJYXPoSac+hXPzoFK6aGSpCtgtfze2BDyVCgFo5MG69ezGFD+X7TnfutLKJb198vu9t57DxqZIbY47eRe/tHgMNrKIl049wvQxjEtrWwVorzsRJzfK6WkTFYoOAmlCaBXA6JI6BYDOAWRA89xgPdSuV2sEYT5iL9EoGk3uhjWtCp6WQHBv+Zcj61z8HkjbcBsK/qmLYNylc4Qi+Z0X45LPcn/GaV1KYyPo9oqV4nO2eI///7+ikgkBefB6yRVTWnEI3mMD6O0hP89XxdCqqupzrX4jgHxVVVX1majXX3VhuRcvlphvMnTqD42Eqqqqqqo+J+uhf8ux4SCTtFQcUOVAuBlCZYJPACUXL5s3zmYzjMdjgcOHh4cCXQEIUO71egK6CTHphqa3mkCz1WqVUsfUNGitkWWZQFqlFI6Pj9HpdAQOUhlBaE8QuF6vsVgsMBqN8Ku/+qv41V/9VWnAx0qSRBoNMh1LyE0wSU0GoTrTzYSis9kMq9UKTz75JJrNpsDcWq0m0I/JWaaFqVPJ81wgIaGrtVZAIgFHmqY4PT2VJpGDwQCNRkMgIxcMut2u6EXYqHK9XiOKIkkQc875mf39/dL+oigSZ/TVq1fF6X10dIRGoyGJcG6H26Jzm/PGBPOdO3dwfHyM6XQq0J3zPJ1OcXFxIQsEZ2dnuLi4wHg8lnP14osvotls4hOf+ATW6zVe+9rXwlqLbrcrLvAoiuRc08dNjzkXY8JGj1yIYKNIFpPlbIyZJIkAfT6RQGULG1keHh7imWeewed93ufhscceE7hM9/x0OpXrn3CYKWguzFhrcXh4KAs9vP55/ri4xAQ+E9L8LF3ubEbbbrexXC4FKvOa22636PV6JaVNp9NBFEVYrVbodDpQSklKvdlsCpynf5vX/3a7xd7eXikBz6cKeC9xUYM6Gp4TAvPtdisLR7xOO53Ow/56e/XVDkQyGZ3X/otRPg1eACrrtQcAHAQrJb7dH1UzUMrCbCOBcXydXuJcOe3E+GaExrlGYxwjXtZQm2wRzTYOSlPJoTVsrINgtyoPnQloY6A8nLVhatnYIukNAGnmmkdGD3iKiv5tJruZ0hb4G+g2styZWIxxAD1Mn+c5bJq6cdZrrqFlFGwnbF7JzwWfF793mO72x3ip8p2fMUltirG4bShY79qmC1x5YA+qmQR+l9Uz8lp4jKJTCV6XMSh5TQX/trhDceeUxywKE61E7VGC45mfG6WhGnWoJIbNDb7i8bfDGov3vPR+vL0+x7f+f96C2DePVMYlra0fClIg3gC1qcVmqGBqTr1jFRCvFPTGjy1i+rpIeUvKeAe8Fg0fgXjhIPTsMY147Z5usJG/PaJiLLI9pXyi3BbgXfsFozBN7RPQNkYBui0KRzfT1GmwAxkgyu9R6vJ7AAfRrXUOcT6lEcJ4jjkv5sI16PwkFDpcKAiaXLqNhQMM9sH9kn9DQafuPMg8Rg84gKqqemSruh+qqqqq37ja79RxpVfH/ekG/+b5U3zFG66+0kOqqqqqqvoNrYcG32wmR8g9HA5L2hK+hzoMJj4JoNlMj27v2Wwm3urhcCjJ1yRJ0Gq1cHZ2VgKh2+0W+/v76Pf7SNMUaZri7t27eOKJJzCdTtFoNHBycoJ79+7h8PBQgNl4PBY4x0RsqEAIVSPr9Vo8w2xcCEAaci4WC5ycnOCll17CdrtFFEWYz+dot9sCDuknBiDecKo7mDgHHNRngj5MyyulcO/ePXFGK6VE3dBoNERNws/yeLioALhFAY6dKgmeA601ptOpJGo3m40AZALUfr8vqVymd5m8pl+dypfRaCSfD73sTLk3Gg1JGjM1TA0L52q73WI2m5WUF/1+H5PJRM4Jof7JyYk0Pp1O3eNZ2+0Wk8lEtCaTyUSeBuj1evKzJEkE+l+9elVc3NwvU8/NZhOtVksaL+42EOPccr6YRqYihMCcCpHpdIrVaiXwlroaXpPtdhsHBwd4/PHHcf36dbz+9a8XTUmtVpNENpUznEP6x7vdbmmfIcwmLOa1Qcc3NUPh53jN8tqO4xiTyUR0MzyvjUYDe3t7ooWhkojwndciv3IhimOnH7zZbAqcZgKdrnPeS7w3wqcmeD3S/R/6xamb0Vqj1+s91O+2V2MRalsPp5RyzSqtUZ4zBq/DA0RTfF9KeYdlHwDFmOKMAZVBkpymBmx7CjrXyBoK0cY48J34ZLW1sFHkEuCiG/HwNTcFpAYczPYDVcbCJmqneWKRoLZx5NLZVIwQcK/WQLPhPq8tEGm3Pzb0jCNRlCjCceMnIfJ/p/okdoBW0X+tVQHR4wjY+vEymR5pqM0nabbKiWdC28/BJSc3AbJWDmob653OLv5sswJW29Q1pVRxHKhFigS8NQFA5z65kLCjU5GvOgD5gJuDyOtWIn9ONOT+lfNjbJESJ/QPYXueA9rPaRzDKtf59IVsiS//Z3/OqavXCqZmC9e0T12bxEJnvjmkX8vhEwyWsLm4VEFFx6UH+Xavdb/YY2L39ICNgaxRQHGrUVbq8PO87HaT1/49oj9RwedfhjOXYDXXrsRPbgtXNyto/BluQ5pqcj+85pl4Dz9D7q5wybIiCW0T7JfHalUBzyX5zsU1yP7DeVGmCLTbKmxWVVVVVVVVVZ+x+tLXHeHH3v8S/vSPfQh/92tRwe+qqqrqVV0P/Z8a6/UaeZ5LErfVagl8YvJ1Op0K7CIoIwhlk0g6vdl0kY5h6hg6nQ7W67U4rlutlkBeay0ODg7QaDTwwQ9+EKPRCK997WvR6XQkmUs3cOhRphpEay3J4uFwiE6ng8lkgpOTEwHq3W4X+/v7kpblmKm/CFPObPLIP4Sa/A9+NlJkgpYaltBxTVUGtSL8w0QzgSeVL2maotlsynb5h1CRc07IzaQvgBJc3m63pXNHXQgXK3gu6PSu1+sCSdmAMFRoAE51ws9QA7JerwWKstEkrx2eVy6cEJASlrLZY57neOaZZ+TzdFqH3m2eV0LTg4MDbDYbfPjDH0atVhPw3Wq10Gq10O12sVqtZN4PDw8BQFzpy+US8/lc3N9hWpowFoD4wcP0vjFG/OCE6/P5vLSwwkWOWq2Gg4MDXLt2DTdv3sSb3vQmHB0d4fDwUOa8VqtJOpuJb57nWq0m55pPYnBBhE8vMDHOBqxMfAO4dK9w/NwO0/w8R0z7s0Ht6empnDNe8/wdwAaUzWZT7oHZbAattdxj4b3Dp0Zms1lpm/z9sVqt5HrkogivQ6bLuXBCr/gjW1ZdamAp/m4mNQMCZWGLtDfwYO0BaZjXJog6wb+HGgWX3FRIuxamppC1FHSukKxi6G3DKU/iCDbWUNuslLpWmS1SydaWgDesdX5vwmT/uiS4CVoJkcM0d567FDccGC+SzYDidcakttZAkhSKktCb7QG7pJYJb5UH0VEkqXNLWO5BL5PqKvc/Y4o63yGVPF5pZOnGpKyFzbJg7DvpbILl8O8a5QWAUCkTprp5nBoFpA5S2qHapAS/rYHN3T6tV9lY4+bCck45Ji5MpH58JhhPEhfnPc/xL198Fl9+/S0Ymxr01gFVE1tJahsFaT4JACYGNntBktwCeutSxfYBl3Loli5eRAGHPa9VANIeEC8V6hcu7Z01vdNeo0hn+32+LMimTkSUH5f3J8MI78MwKe1VIwKyw3HDA/FclbfHW9f7ucWzHS4Q8K3hmIPDIhgXSO6bcYb7fxC3Z8JehqqDffgBhOerCrhWVVVVVVVV1Weu/srv/gKcL7b4mV+5j2//kQ/gr/6eN+Dr3vnEKz2sqqqqqqrfkNKf+i1VVVVVVVVVVVVVVVVVVVVVVVVVVVV9rlcjifDdf+St+EPveBzGAn/xX/wH/M8/89GSwq6qqqqq6tVSDx2JZHKUvm2mcpl2Zfp3NpvBWltKwgJOZ0KFCOAUI0wFW2ulsR8A3L17F71eTxrnMc26Xq8xGo0kNUolB9Pei8VC1BlMe9brdUnpMt0MQJQQTLyGSdkwrdtsNnF0dITVaoXpdIrNZiP+YqaBmUKlE5z7CNPgeZ6L1sIYU1I3ML2cpinY0DHLMmy3W0ynU0nZUyURNn6kWzqc6yiKRIvBZHGe5+h0OjI2etiZHKfaRCmFyWQijR/jOMZ8PhfFDQDxhwNAr9eThDuPfzweI4oiNJtNSReHyXnOB1UoVLeEXnYmlEONCLfFeXviCbcqTd0MU/nXrl3D3bt3kWUZhsMhTk9P0e/3cf/+fXGmL5dL0bas12uMx2NRbQAu2TwYDOSY+/2+3AN8T6fTkacNONdM/bOh5Wq1kmarPMf0srdaLezv7+PGjRt45pln8MY3vhFf8AVfgFqtJk5sAOI4Z+IZAKbTqTTmZOqbCpX1eo35fI4sy+QYqDthIpoe+Ha7LfcWXd1MY/N6omcfgPjK+Xc2T+Uc0DvOeeOcUNnDpwvCpDefIqD+hyoTPv3AMfD3B1PhbKbJJy+Wy6Xcx/fv3y8lxh+1cuFexmELZ4FonOkxEFWCV3683P/XpaaACe9cSQLVpWrd521EpYJveKkKPURejzH8TwpRatG8p5zixEZQm6y8rzx3ChGvHZFEtVIuKa41VJoVzSaZnPZaFKarFRPc1gLb1Dm889yli30p6kL85LhEuU+Vc5/WFk0vfXraemUVMqdpodfaMmXONLoKFChMjUeRG18WXJ+7vu2wmHa3Pomt4I4lilySWtRaWaEX0UXq22aZ051k7viLhpZ5eR+7+w8bXjJ9HjYTtbZorBkeHxtaMlEeReXXgVICXOY+SwGtYTYb5Nbgf/i15/A9J1+KrGNQP49gYuftVsYnuX3TVmUUbGyRq+KJA51dVoQ4fzZKCW0bQdLLovbw72PzTL492lpJMUO5/TOxzIchXrascgn1IMGtGHg37t/UBzadlIR08Vket+s/a8uv70YZuB3ApcEtHnB9BfsMK7gkOS/cRtgMtPTZ4Kukyqmc2ZkPywcpfLpcGVRVVVVVVVVVVZ/BiiONv/7Vb8Bht46/+7PP4+/87PM4mW3w137vGxDt/v+FqqqqqqrP4Xpo8N1oNNDr9VCr1cSbHTaeoyOY4HmxWEizOwA4OjoSaKiUwnw+R6/XQxzHOD8/F6UHoWfYYFJrLY5s+riTJBFIOJ/PS2A3bHxInUSj0cB8Pi9Btna7jX6/L/Cu3+8LwB8OhwIOqVG4d+8eZrMZjDFYr9fo9XqIogiDwQDj8VgaK4Y+ZDqgQ3UDQSAbH4b6C4J3zlGSJOJNJ1QFIDCTiweEzgAEKIeKDkJDbovge71eo9vtYrNxHcA4huVyKQCTjTfb7Tbq9bqMiz5oVugw5/mi+oLOaTYs5GJFnufodrviLuc2CaGTJEG/3xdom+c5HnvsMXz84x+Xa4vg+vz8HADEEa61RqvVEngPQDQrV65cKTWE5IJCrVaTxRu67Dmn1LbQVU7FCgBpxMnzGy5cUOXD446iSBaQbty4gZs3b+LzP//z8brXvQ5JkqDb7coYqMOh1oT3Wb1eF53HfD7HbDYT5zobVHIBJMsytFotuU+oHuF5p86Evu75fC73HBeRqMvp9/tyjY9GIwHaBwcHosnhNcQFJYJ1XiOcC16zvA7CBrNsKMtz3G63kWUZJpMJer0erl+/jg9/+MNIkgT379/H0dERNpsNTk5OcPXq1dLCwSNb1DpYuJaRdHrTPWAC2Mame6GKQYBWoPkIPhP6hVUI1wDXzA+AidzfrQK2A4vxayLEayCvtVC/SFGbbB0AD5o4qlCBAQiALnzfeQG1c+O1Ix5UZ3mg4fDakm3qfNaA+54Vgl0AKs2cjsQYB8fp2OZY/Lat8VCZ0FkpIFXO451mBcT2bm8Zh5/DEpQHCsgewmFjnWrFECIb1wjU+MUAq5xTO4dzfHsNl9uFhVKRHBeM3QHewXFzcSiKCg84z3UUuilwGZiy7M488TgI57m/6JP8BxQ930rh//2x92Fut/j5+Zvxr3/tGSRTLY0PlVEOqGqv64AHrFBOhWIUVK5KTRNLQFcFgNUE3xdrQw56EzorIE8gwF22pwqIHja3DOG5G4AfN8HxAxQjKleXGzvmKHzdu++3hepEWVUsADyIvD9IIRKAd7m1dwE7ivngsSgTHltxPA8k/mzmyTWPcN8oFhZscIwlxUtVVVVVVVVVVfUZKaUU/uyXvRZH3Tr+0v/6H/Cjz34C5/MN/u4fegsaSfSpN1BVVVVV9TlQnxb4BhxkJMQiCCTQZhqTwIsucADSWHK1Wgm8U0pJ0nh/f19AG7dpjMFyuZRmja1WC7PZTFLW9F2zgSFTq/SDAxBwR+jNppv9fh9HR0e4du0a+v2+jD1JEoGK6/UaaZri/v37eP755/HSSy8JWL969Sq63a6AdIJgY4ykcsOGifwZE9ecs/F4jFarJXNK8E+gnySJgFwCzbCJIkEyIS4AAZt0dhNoEqozdUtYy8aLq9UKSilp7NhoNHB+fi5zzXQ2U7gE0fyeDUzzPMfZ2Rl6vV4JQNLRHTaHJChn4nuz2aDX68n5WCwW0lSz0WjIMT355JO4uLgAAEm87+3t4eTkBOfn55hMJjg/P8dLL70kiwuLxQJPP/20uOOZEE7TVBLSs9kMy+US/X5fFkUIrBuNBvb390veeqbleQx86iBNU0wmE2w2GyyXS0ne8zj29/fR6/VweHiIZ555Bk8//TQ6nQ5arRam0ymUUthutzJ2Or4JiwmEuZjB60UpJQsi2+225G/v9/tyndKVzuud2+IccH7CpwJ4z4dNM7nAQBd5uJDARTA2iuX5I+hmzwA+kcB9ctvT6RRXrlyRa4vbYVqfHne6wdlEdTKZoNvtynX5KJYloA693gCU9g5mQi0CvhB4AwWIsgh8wkGKlvDbKHEhh4lNo1Ckbo2CrVuYyCLtW2QtQGUaJk4QpQZAQ3av1ymQaiALQK5WDqBqB7YV4XZWNMUkHH65UklSeMC1ArxnHCGAlkR1kfQGHBCX1PU2FQAs2wQKwA14EO4+o4wFTF54xa31Pwv2S0AOdQnGu8R7COs96I+C/xCxtgQfFdQlSG1zA3F/h0lvprjZvFL2y+2b8kICj09pwOZFclvtjv0Bx/GgzwNurvw5tqsVDAxaqoYf+9hbYe83pJmkMoDO3JAQ+Ysusm6IiRVwqn2yercxo0Db0sQUoFvS4ArQuXuSQTziFsjrzu1tI4jbuwSMA3h+aRoCwBw21rzk80bwfhP8PNgPXd6S/N7dzu7+w0S32pkPBVkk2F3ECoG3AOod6C37DSG5H6j1Ue5So08m5P02bFwswpW84VVVVVVVVVVV1We0vu6dT2C/XcN/+2Mfwv/+K/fx9d//LL7vG96OfjP51B+uqqqqqvosr4cG31RgMO1KqNRutzEajQBAGtgRaCql5P2bzQaDwQAXFxeizWDymHBWKQWtNQaDAabTqQDder2ObrcrCd7VaoXT01MBr+v1WhprssEfYSuh+Xg8RqfTEUD22GOP4fj4GIPBQJoqbrdbdLtd9Ho9TCYTWGsxnU5x9+5dfOxjH8N4PAYAHBwcSAKXY2fCNdSpMLHMBpu1Wk2A9WKxQKvVEm0HoS/BOtUonGPAAe16vY7pdIrtdivgn000CYpCrQsT75zLRqMh46RuZTqdivqiXq8jSRJZcAAgCwpM4EZRhOl0in6/LwlwAKKeoAKHc8B0ORceOFe8jqgR4TXDBQdCUb7O8fFYCWy52LLZbASUT6dTSeffv38f5+fnOD4+lmuIYJ3Hxz+NRgOdTgfD4VAg/2QyQa1WQ6/Xk2QzzweBLRPhbCxKiMxrgbA5jmO0Wi10Oh0cHx/j5s2b6Pf70siUDRtXq5UAeS7EhCA3bFbJY+d9d/XqVbkP4jhGv9+XZH8URdIgs1aroV6vy9MZs9kM2+1Wjid82oILFIvFQhaFlFIC6Zni5n3K88hr8eDgoLRoxmuTCXHOT/h0BM8Tr6PBYIBbt27J75Fer4fFYoHBYIDlconxeIxGoyGNUR/pEtBloaAc7DYB4AqTmmFclUWVATUM2ieJQ+DmAR7Dz9AePpoCAErSNQMAhbxmoaGwOrbImxrbbgO1qUWUug80zlPEsy30KgWWawdLY/9/uJWS5ocCpyUFbgrGyPQ4oXQcwcYRlLGSGof2DTKNEeWINMk0xiXJuZ3cXALJKtKwxniFiG84KU0mw3k0rjFllsNGutgm4TcAsAlr2KwyVIrwq1ZQNvbH6NLU1tgCIPNERFEBlwm1AQ/I8xKgtnkO5ICKIpccD9PaYQq9lBb3FwZQpLhtMOZw/A+q3D9ewCalWsGmGWyW4V9+4hdxkm/xDy7egdm9LhoTjaxloTIUmg2/e+sD6QqAzgtwGm3ca4TUAlRpfwlBMjxQzwF4ABxtXbPMUOVjEiCveei9e2j8PlwQ4hQxQK+K13YT38XJQAGprSqDewt5ioJPVajc3ZfylEXp8w/YfGRFeyTAmk9q+AUqOaRwGx7WK78PAnMbvCb7Dz6vcgWjrf8dAr9AEYwnhPDalpvrVlVVVVVVVVVVn/H6XW+8imG7hm/5oV/Esy9c4Gu+5xfwQ9/8Dhz3G6/00Kqqqqqq/k/VQ4NvQjyqM6hD2Gw2yPMcURRhPp8L6CIcpA+YaU4mQAmMqVwAIJCNgI8p4IODA7RaLdy7dw+dTkfAXe4f76avm6Ct2+0KjB2NRpJATdMU165dk6R3q9XCCy+8gOl0il6vh2vXriGOY4FtTO7evXtXdBVMThMUE/RyLPQ7Aw6MMnHbaDQEphM+U/9Bf3Or1RLwx4R7mNYmTGbSmD7jTqcDoLwYwfQxVRxMwgOQuSFcp+aEIJupc6bu6Q/nIgOTyJPJRM4v908XN5UgPEam36lAIVRlgn1vbw/T6VR+FibjrbXodruSeOdiBZ8mqNfr+MhHPoLFYoE0TbFarUThkWUZxuOx6HPChDMAgf/cFlPL9+7dk20rpXB0dIQbN25gb29P5rnf72M2m2G1WmG1WqHZbMr88BpgqpnHwsUSPhmglMJgMJBFmzCRz/uHrnv+HXAAerVaYTwe4+DgQNzlTPvz2mi327JAQiVOvV6XNPp6vRa9DxdImCLvdrtYrVal+QqvBW6fTxoQkIc6ok6nI/cUn0LIskwWgvi7I/Smd7tdXFxcoF6vy3kBnNe80+lgOp2Ks7zdbouDfLlcyvyFKfVHsgTGeUimLWzo8RaKhVJKswTxQscwinSnsj7NabETX/V/jeASnIEHuKRz8OFoEwPbnkLWVPK+rKHQOtGonVpECwubxIUKJNChQGuX9g2d2mFy2+tFHMyO/N89KGdSPIDesk0PqmEcFLdx5LabGdj12qWTkxhotaAyn1SuBTQvhMTAjsLFFPumIzwspsZLbm1GZP12mVKPogKcS4Lak90QvIfQezdNThe3pOaNP3nY2QYXElTh+ub3dmebSnkFiymg++59yG34FLpNM5jVGkorLM0WubV4bvQ4klEEvQFUI1hI8dcUU8ma0NdwccWB6qzhr8UdT/UuD1Z+W0w9aw/UdVakwFXufm74q4gGGAtJo1+C3g8C2yjeswvLBV6jfHyiXdFwi1c+4S6VBTsN4+QhNdfBgXt47tQtwVitWzjYZfilwzDB5nkM/mmDXT+3pT5mN02eB+lx6uFjC+QK+uXmrKqqqqqqqqqq+ozVO5/ex49/6xfiG37gWXzk/gy//7vfhx/65nfgNUedV3poVVVVVVW/7npo8M0Gh5vNRr7W63WcnJwI9KXehIoE6g0ASAq01+uJi5mfSZIE5+fnJY83lQ1MGed5jl6vh3q9LioTJmWjKMJsNhPvc6vVQr/fl3E3Gg2B0oS6HHMURbh7966Ax8lkIuoGpRRms5nA2+VyKc5rbi8E4IS0hM30bxMYUxvBBo+LxUJgOqEz/cZA0YCSipDtdisLDWwmGHpdqcFYLBZy/JzPbrdbGhfhKqEkk9BM7RNAb7dbSeAyJU1HOnUybHwYQkp6y5vNpgBtHn+Yumaqfb1eS5IYgDRdZHKYOhHOu7VWEvhMvI9GI3Gtc4EhbHjY6/XQbrdxdHSE7XYripx+vy8LJNPpFADERd9sNnF4eIhOpyMNKzlmpqCbzab4wakUIbxnyjlsnBpFETqdDq5cuYLHHnsMr3nNa+TaYeKe39OpTSjOc8htsrkmgXYcxwJ9CYU5LgDi0GbzVgCyaJSmqSw80eFNvRCfOuAiRuhlD/3yXExJkkQWbPiZ0PFOhQvhOWE7UDSk5f4AyOeZ9OfTD91uF+PxWH7nZFkmc8Xz9EhW0NAS8NCMkCxMVxJOW3UJvgFFylaa0/nop6LuwwQpXJR26TYhnwNU5iBcXrfQGZB2PFRMlbzP1DTyWoJ6N0L7dgS1yaGXGyiCYgLcPADHIYglII8jB83Fme1jp9SWcIyRDrYT0DtrnZ4kbNiYZrDbrU9Ha8Bw0Lb4PME5ICntUlo6BMUEwtYW6eAQTpsAcFPTwuNgaeV80LJNDfjfXZYaF+/4vtSgUiuoWgKb+3vLAIBPhD9o0Sic5/D73W3z57IgolwqntsM35fUoIyFbjZgNxtcmC0+sDnCeN1E1nLA1sItkqhQSh2khTXZfuRgbtYo4LUNjTAEroBcs/wZv+Z1IF4CtalF1lQuOR4Dxqe9TYLCL84GmMW6TVnXocr7K7nGdyHvzvc22vkZ7zGvMLI6XHAK/r5b4Q3JhQBCbr89eSojGAfB9qU0N1Pzxt37XDRQuZ+H4H4XL7v//QLAaZMsSg0vVa6gtwr6EW/JUFVVVVVVVVWfLfX6qz385Ld9Eb7hB57Fx84W+APf8z78wDf+Jrz18eErPbSqqqqqql9XPTQZYnp2u92KloAglmCV0I6NIQlRAQgwJ9wj+GJKNM9zTCYT7O/vSzNJwmGCbvqUCcuZLgUKnzbgkqFMha/Xa3Q6HRwdHQlQBCBAtF6v4/DwUGBpu93GarWSJosXFxcCW9lQMvRnM/3L4wxhG1UZcRyLN5kwld5qAkWmcunR5iJCCNXZbJIgPgSFoXubIJj7YXNKrbXoXgh2uVDA5DyPgzoS7pcJ4OVyWVJshI7rdrstMJzbOTs7E7UHdRvcNnUdhKNhQ0t6q9kck1CTx8RrAADG47EA1Nu3b8viw3g8xnQ6RZIk4vAOE8vhuSL8JVBm0p0NIqnPYFNUzhG1MEz6c8GA1ykT0fR7t1ot9Ho9OWZui08/sLgdnlcmmpnWD1344R+m8HkNUS/DhZ2TkxNZTOBxx3EsTzSESerBYIDNZiOefJ7jKIpED7RarURXwvuj1WrJueV1RUUR7wvCcMDpiOj55tMUXDTjNc5zxuuWi1lU0ITJdCbjuSDzqJYV/64CPMC+lADd1QuEYDBIh0uAlN94aMbkqHz1/uHS9sJdGAWV+9RpVKRZTeIXOBKFbc8RtHhZR320gU1j17wxzQqoKkDalL9n2pullXi8pXkl3+dT1Mpv02rldShwkNZaqM0WyDIHkZMYql4vYHYI1WV/HlDT6c2ENyF4nEAaR4ZjZsVBktswjuwae0o6PUi0K8DpTiJ/bkNPtzWFfgVwx4AgTUwY7cG6zXMoROXPh0lyOYcPiOYqjTKBRwG4Cd9jHq/vyGmN859bCxVFMFmGmlJo642MM2xg6c6R+0blShpQ2gRQKS6ljoEgYQwIiC49iRB66RPvB1dA2vGgNvbQPQdsDYXbG34bATQu8WfZl9+O/9zLNptE8Llw20GIe9e/b7lTfgW8XD+4vyWarlwinsdP4G12Ut47sJ73NrgLVcD9cB4vjV/2XSwUOMVK8JKyRQPPAI5XVVVVVVVVVVWvfD2218JPfNsX4Zt+8P349y+N8Ye/79/iH/6Rt+L/8nlXXumhVVVVVVV92vXQ4Pvi4kKgNQABnJPJpARvCb0Wi4UktIEivdxoNFCr1aShIlUUTPceHBzAGIP5fI6TkxPEcYxut4vZbCYNGTebDVqtlgBhpoq73a7AU44PgDQGZFKaqe5Wq4UkSXB8fIz9/X10Oh1orQXi37lzR6AnoT0A0brweAhv2RCSVavVRM8wm80EIBNYEt4yUc3XoyhCs9kUsAwUQJ3wnvPZ7XZFhRE2ilwulxgMBgIUmQyfTqfI81wAMMfOpCzhJeeZx0SNDN3fhPBMggMQIMntnpycIEkStFotgZZMvxNaEn7y79TSAJCEMFUsVHE0m01MJpPyheyT68PhEKvVSkA3t9XpdHBwcCDXKf3UXCzhcY5GI0kx9/t9AbvT6RTz+Rzz+VzS9DwHTCtzrumtp3aDkJ+LMHme4/HHH8eTTz6Jp556Ss5Zo9GQJxy48KO1Fkjf6XREV3N2dobZbCZAntCaHu9w34T3k8lEEuJMw2dZhpOTE2mOyScDjG+i1+12MRgMZJGB9x7nkeoY+rpDxQ3PGxcyuODBe5Mp+OVyKV7z/f390sJW6DUP7wUqcnht7z5Jst1uS78DHskiSAqaTALwELycCC95goECaoc/I4ST7z2ADGCewHL/fv5dgDhf9uBNGcAE+oasaZE3PIS2MXRqUMst1HrjN2SLr7w2RHeiHFAOk9rGikLEQVNVSk6rIIWt0hy2lkBtUwes46gA197dreo1l17m68YW+8+CNLnagXhMdSsb6E/8sYQpaZgyMPbp9ZJv3NqyQkQrnz7f9U347aTBefYLqaXvAZlL6+dVRq85ngDGc59h+d/5ykAWvCRFbryDxP874YC+hc0NlAfq1j99srUWv7x+DGfTdjl97KGr9R55pq2tAqK1A9Rqi0INUpqH4q8PguOAh9v+OtYpoDMLE6mi8WWEAjgHjnvZbgiRNcpPO7zcOILUOrdxiSMTPFv/egRRELnUebAQRS94rnY2pOTzoYJI7lst73ogmC+pW0KgHq5v8Vi5DqUBxcQ9nz6Rgw3Gm9tgseABCypVVVVVVVVVVdUrVnvtGn70W34zvv1HPoCf+8gpvuWHn8P/9PveiD/49sde6aFVVVVVVX1a9Wm7AAj6AEhCM0kSAdOEoaFGA4BA8zzPBVzSbz0ejxFFkSQ32diPIJrJ7EajIcnsyWSCi4sLAZdMojabTSRJIo7mfr8v793b2xM4fHZ2hu12i36/j+FwKM30CGQJA7fbLZbLJVarlUA2voepdyodeHzcByH8crkU5US/35dEMcE7QQThMGHjYrFAkiQCTgkCmdzmcXMBgECSIJTAlI0HAcj7QtXEarVCHMeiDuG5CBuZUidDKE4QrgLAQx854Xyv1xNNSRzHcgxMfjONTJe5UgqdTkec7Uyq8wkBgmBCZjZVJYDm0whpmiJNUywWC2RZJnPMxQUW54DnlulwNoTksSyXS0ktz2azkj+e+pztdiuA+ezsTDQ29E9vNhv0ej10u11cuXIFN27cwNNPPy1pfQJ2joup7FD5wfsCgCy8rFYrHB0dYb1eYz6fi3YlyzIMBgMYY+S80S1PYM1ro9VqQWuN/f191Ot13L17F4eHhwKza7Wa3MdcGNlsNojjGO12G+12W66RWq0m+6N3PHSHc1v83cHfKUz2E4I3m03MZjO5v/mkxe5iEM87UCh8ttutPDnyqJbNVeHzppub2hIP8YRCe2jnPlhsg3BOvhc/ryNxyhQNBUtp1pDBEqox+brLg3eaDRqvy047gLIK8TqBzixqY+Xd2wF5D5PS1IHkrmmiJTi2bkAqN5Kats26h4MBPAeKhpZZXkDaPAfi2Hm+E5/WTpLCx524NLqDkSrQeZiiCaf2TTM5JoJuAfdRoTDxaXjkfuyE9EAZpnO7AJS1zrnum1mW4PZOOtsSmvP7PL/s4Q7URQ5Oq9J23DZs6f6yu+fCb48/392GmzMDu9265Lk/pltZEx9eXEW6df/XRIAqrytZYCn+2KARpSIgRtGU8oFJ8F2HNoeeACZ3ye+s7V53CybBvj20tZEtQWRRbKP8fn7GBvuVe0iAfnn74bpUKfHNY+aYgOL+DuC0MuHfeXMVWphwbOEVUmLP4QJWuC1lCz2KKd4TzqMN7mlRnci2VaGL8dusmHdVVVVVVVVVfXZWqxbj+77+7fiOn/wl/PMP3Maf/4lfwul8g2/74puP9H9rVVVVVZ9b9dDgm3qN0A/N5C6TtUwu02HMZDIASbD2+31st1sMBgOcn58LFCXsI/imKoFQjWliJj0J0qiA0Fqj2WwKEN7f3wcAcRdvt1sB7ISU3W5XtkUlA1Un0+kU4/EY4/FYmlfSXUygTyg3GAzEYx2mq6mEobOcAJxN/waDAWazGQaDgUBCNoakqiFsFkhgGOoeuKAQ6ivobw6bHAJFYpaOdrqVqYmhvoQwPISMhJ0AZB7ZQJJKCc4t983rhHPG5pOEr61WC+12W95vjBE1C9PHvN6azaYA8SzLsFwuJeGb5zlOTk5wdHQkKWCqS+iOT5IEk8lEEunhwgWvI8LWTqcjmpC7d++KpmU0GskiCeCedqAqhICe1wq3CxQu8OFwiHa7jePjYzz11FM4ODjAcDjEer0uLdzMZjNpIErgb4zB2dlZKXnNxYdw+wBEFUJQzicMptNpqcFnr9fD3bt3xXk+nU5hrcX+/j6uXLkiyX6qfrgPgvOjoyMB0rwfRqNR6QkCJro5ZjY/DbU2hPvr9VqOnws3/P0BOLDNxRUuQAGQz/d6PRkr/fKPdAXQu4Bmaic5675SkSDJb4K2HaAFFMnRS2AMKLzHD0i7iqbCwukYfAK85Abme71PedtVaJ4oB5gzuqThiFkUCUCV8o7r8r49fA1S02rrHeEB5PVxZZc+Nq5Zps0y5/Su16RZpjLWucKBIs1sLRDHbnzbFNaPSaaGiW/WDnAvjTV8jTBcKUdkQ4e4fMRCdCTGQ3CgcHuz0vTB7u4H/Iyp7TJE33Gg8z92fM8LeZ/XOL1c2TyXY7CZ09fYPMePv/Q+/F/vfgn+zUtPw6xiFyonQNWAiYA4VTCJhUpdGhs+WSzaDeW+j/wijWZzRewA4yBFDbjrTVMFkhVA3CQIrt3gIAJtR/AjvzH/PcprMwKAw8aTitcmgg8F2wrhsSr/rATKtfW6ofKTG/IEhofUKg9+ptzTFg+E3Tvfl5QnpQa55Tm9pB1/wO8IKFv4vQNPeFVVVVVVVVVV9dlZSaTxXX/wTTjs1vG9P/8x/I1/+RGcTDf4H77y86F3nwKsqqqqqvosrE8LfAMFSCZ8ZHNHpl7pEyZkpKJjPp/jypUrWK/XmEwmoui4desW0jRFu90W2EmgZYwRmEvNyXg8xv3795HnOY6Pj0sNJwFIorrb7QJwcJL6CgJbgl1CaGpZeGzT6RSnp6c4Pz8XVzjBPRPYTJsywUpIHB7zbDbDcDgU9cJ8Psf+/r6kaA8PD+V4O52OfO10OpLQDRsOMp1MVQXTwo1GQ5LNnOvhcCgJ+TRNxTnNeQQg6XSCfyprms2m6D4IPAnYCbbpwGZqPbxOuFABFIqW8Dwxlc0FE+pSmJgHHMRcLBYCX+iH5sIIdSoAcHJygk6ng7t370qjzvl8jvF4LDqY9XqNLMswGo3Q6XTkuKIowsHBgah3Dg8P5Xjn8zlarRam06mc88ViIfdCp9OR8dDRTZc7oTH3z0WZN73pTXjsscfw5JNP4vr16zg7O0Oz2ZQ54fml5oWNX6mk4TyE6hQ2M+ViBRuINptNOefU2wCQhPhkMsHe3h7Oz8+R5zn29vZkQYrXLBcaqImh/5tKFIJoLmBQQcQ5brfbJW0OG3Vy8YZNY3kd0E/OxRteW5xLLi5RJwNA3seGq5vNBvfv38fR0dHD/np79RUT33BJbwHcAsGCFHioOSHo8o0orYfcNrZQmYK6RMZQhmX8DApARhjOdK74wAEHLvNgv2y6pyysVsgaCtEmd9AbcAA41u7YcuNgc+jbDiAuU94CbNOs0J7UEklkCxD371VJApumsGkKVasVkDbmtoM0dpg+9+lyaF2MN1Ll5HdYHFfY5FLm0Y/75dLt/Gro8bZw7uyg+DuS8JtKlpcrAuw8h/Ie/petnYQPYbZAbUngu2O3Wu/A/tztRymYbIv/5aV/ByDCL54+huWk+QBdhz/kxJaeGtDbYtFEWUCv+YK7lkwNiPzamYnczwi5meZm8jhcfMlaCsb/vyMb7SzM8JgDhs3vL88TB64KWK6K+0I2EsD50gaDNLn7vCo2q63zdvv32theur/dayg04LZ8ryulXMNJxftw56D4VoHctth+kPZ2zSyDz/B3ye6c+EUuBcBoWx5nVVVVVVVVVVX1WVtKKfz3v+v1OOzU8dd++sP4wfe9gLP5Bt/1NW9CPX5AsKKqqqqq6rOoHhp8z+dzgVtsFkjAOR6PBR5GUSTJaOpDAAjgWi6XiKIIo9FIIDVhJ2FalmWYzWa4uLiAMQbHx8eSaGZ6mSlxpjoJPAleQyVEo9EQJzSBfavVEmBN7zLB43w+x8XFBZbLpRxDkiSSPmdCmQ0q6RgOATjg4GSz2ZSUdhRF6Pf7yLIMh4eH6Pf70sSPYLrRaKDb7UoDx+FwKMlf6l/omW632/L58/Nzgf/tdluaD9K73Ov1ZEGATTnzPEen0xFlCDUjSilJMjO9u91uJSHebDYFKtMTDTg4effuXTz2mPN+RVGEyWQiYJRp41arhfF4jNVqJSl+LnIQiFLBwbQwUChX7t69K450wCWBz87OMB6P5drjuAjX1+s1Wq2WaEXCORmNRgKa4zgWPzhT1TyvhPOsNE1xenpa0sbwGuMxMHncbDZxcHCAfr+Pw8ND7O3tSSKb76N6h85wpq35RAPVJYDTrBwfH0tKnkUvd5qm6Pf78iQCFzd4/YRp7EajgU6ng1arhfl8jslkIiluPrXBfXBRhM1f+TuB2wufhOCTCwTxHCsXeTabjST8tdZy3RLqd7tdSXxvNhtcXFzIkyA8z/SqM8XPhpxM3j+y5aEz9SYl9/ZOwpOwzTUMLLQIJR2DB9KG0NonYkOFiY1sKbFK2C5KCu3GpTzJU5Zp3SAaagGdO6hmlQPlaTdBfKGBjVNoOP93AJ7p7QaKdLdPhSs6sQmJk9inqN21obK8gMGhPxtwUD2KXIo7CjzbxulUkHudidYuGR5st2goCacfAQoQDUAFjXVLqWzCcTqzg2NyH1SwxkARKgMuCf7JrvXQ3w0Uj6X6Bp4hlJf+CiEsD8e228iTqpRQySLjMsV5CZPq1JykGSyAn7r1LNY2x8TkuJi0oScxTCuH3iqYuoXeKAGvdHGbyCLaBk8nwKlNbAREGyCvex6bu5+HZanw8bBXZ4BpumuRzS3DEh+3h+RmB4LvNrTkZ2xU/h5KlRz5sl1PlksubQTblGn097A0hPTzoj1QT9Ul574kvW2RqrbaQoHw3coxhHD8gd7tIGnO9zPtbTx0L6fHiwak/LyJXNrbxFaa27LpZtXcsqqqqqqqqqo+++uP/9ancdit48/9s3+Pd//SXYyWW3zP170N3UbyqT9cVVVVVfUK1UODbyYt8zyXZpGEc4Rj2+0Ws9kM7XYbeZ7DGIOLiwsATpHAxCf9y/fu3ZOGhpvNRoDuYrHA2dmZpJ0nkwnSNJXkbBzHOD8/F8XGer0WeJZlGdbrNabTKQCIfzyKItGfPP/882i1WgLXCNAIMPkf/wSGrVarBIL5hyA3iiK0Wi1MJpNS+pnp7dVqhcPDw5IDudlsotVqCYDlogF1FwTC3G+tVpOk697eHmq1Gnq9Hqy16Ha76HQ6AgmZcqcj2lorMFIpJXCV54gp9jzPZT4I76fTqQBfAmoA4i5fLpclvQzHyUWBbrcrMDlsbjmZTGRRBIAkkgn4qcLgkwRMPI9GI0me37lzBwCkySOVL5PJRDQyw+FQYCzd5PV6HbPZTPzcBPpMnvM62G63pbQ8zxfHPZlMSk53vo8J8DD532g0xCf/9NNPY29vD8vlUlLdvF54/RIUUz/C7RO806Efqkx4vdDrzTR/6OKnWoRPPIQqoo9+9KPSTJZPJDBlziT8+fm5wO9arYbbt29jb28PSqmSh573U/j7g/vnfRpeJ/Tkh01Oz87O5LqlQ5/3O73tvHa58MXzwZT5o1rKQ8EwdQ3ApUK9m7uUxFYu5U1wFTb7c037lPiF3XYLqA4P35w7nBA58H+HSXICQA8kVRaME8H2c6eZyBSw7UVo5i7ZbJMAclN7wkcsQwDOEujNAzPu/Xnweri9zCtKCKbjqNgGwbhSDnwTGOd5WTFigw5/QKEBEShuC++3jEkXID+A2jYLgDZ1JtbAGlvsx1g5PipK+HfZNtUrgZJEBcoRlgrT2TuJb3mN5RcTrLVOBxPCbXq+gzHIuACfPnfHs7YZIih8aHOELI2kjyYUoFOFaK1gatY1jfTXo85U4JwvrlWdAdHWwsQFFC95wlHw6WgF6NTC1BTitd9uWnjmwyS4DTQeovHxi0MKttB6cH+78Dy8l4LQtfvLjis/HCs/FyxQyUMAyl8OHhrrvDg2nRXb4eKTiS0QWTdv6vIYQw+3Cn4kZha4hSjqZDgP4byEUD/Us4SLA1b77fj54Hmuqqqqqqqqqqo+N+r3vPk69to1fOs/eQ7/x6+e42v/H/8WP/hN78Bht/6pP1xVVVVV9QrUQ4Nvgk6qRwiymG5dr9fYbreSgF6tVqJfAICDg4PS+2azGc7PzwXMUXVA5QPh3GAwEA0HmwcSoBGg8+dshsifAxCozs9Mp1N0u11JcdOjze3P53NpWDmfz1Gr1UT3QNgW6hzoigYgkJcJaK01xuOx+KMJqglx1+s1BoOBOxFBgpUNBPf29mTs3B4Aaa7ZarVQr9exWCwEkAMuHXt8fIw0TQV687OEgkysU1nCSpJEjiNNU0nQs7li6K5mM0QqJbgAkGUZ5vM51uu1aEgIvfv9fsntzLQzAHkaQGstiykEOUwGE+ZSRQMUEBgAXnrpJdy7dw8vvfSSnBfC1dlsVlJu8Prl8QAQ1QivQabkqbDhQgIAcdwTDvP88RwSzLbbbQwGA9Trddy8eRMHBwdYr9e4e/cuer0e5vN5yWlPnz6P9ejoCKenp6JqAYBWq4WLiwu0Wi00Gg1RyDB53el0xHdeq9WkUep4PEan0xEAzUa09+7dE3VNeM212+0SxB4Oh9LUdDqdysIXk/kE8Uyvh157Xk98H393cMHg4uJC1En8PcP3U2XCa4UqmmazWWqQynuh1WrJgsQjWQTZ3n3sYJN1DflsAZ4sXHRTEqoC4FysU2ceLgt0U04TQTtHBOfrRpEWVbmH4iZga1QpAE5D4RPgNrEu4c0iN6+78cZLhfpF6pLZUdGk0r2J4BdlgP1J50WJhkQS3Glx/0ujx50EeUm1wiaVgIBf9x76vr2ChYeUG/ezXZd3mNLeAdRuVyrwdXP/EKAu27FGGmaGkJ2pbf5MeVD/wFnacYerJL7U0PISSOe/R2E6/JLOxEjinU0sbRp40RVgrIWBxd958XfAbrWDramGpt5fB00qva4krzsVjrvWHFg1NQeuN323gMPPyDqEJJ6BeGuRNRVszCcjIE5vnfkHJhTc/0PSTrHyIG81E9NhhQnxEPyK+96/7tL8cE9TyHko7g3wdQTw2YP+8HVlVOE5V35RIITjAYCWtRmOO9DEuIaTqtxY0wTpb+2gOZT/XcLtcftBurv0OVWkyq12vzOonJHPhWOsqqqqqqqqqqo+6+u3PnOIH/tvvhDf+I+fxX+8M8Xv/+734Ye/+R148qD9Sg+tqqqqqupSfVqO7/F4DKBQOdDtvVgscP36dYHSBK5nZ2e4du0aAKdm2G63yPNcmvcxHWqthTFG4BmTn9SHMB06m80AQBLBBKytVkvA42QyQZZlAr65XcLck5MTDIdDgYxKKQwGA/FCh8dG6M00MrUKAEqwniCQPyfsZ1Kb+6beoV6vCxAkPF2v19LoMI7jkgebaex2uy0wNdQ9HBwclJQj9XpdNCFM9eogcRdFkag/+H7qQK5evSr6mNFoJAsDSilJJ1NHE8expH8B4PDwUJQlTO7SL83GlnwigMlyjoHXAVP1bOrI64lwmSnz7XYriX9qdagrAZzihtcnG08uFgvxpbPJIrfLVDi92QSuV65cEeUGG2OG9wFhPJ8CYPqYSfJut4t6vY7hcIher4fj42M0Go3SogfVIbw+CGw3mw2UUrh9+zba7Tam06kAaTrXuVDD88ik+WKxkPuKipD5fC6NRpn0p9qHDnK6vjmvxhjs7+9fanJK9Qp9/vS+U1MEuIWM1WqFdrstQJqfDZ8YaDabODs7E9UJE+vUBPGeT9NU7mU2VWVKnzoVPpkAQJz1j2LZyEPuXEnDSptYB5mo4fOaAdERWLhkLQBNjQS5nncmS8rWFOlSNqO8pFDZVTcQfgfJcWoVCOIin+RVkYOP0QaIV2WVhzK2gMiEzoThu2llY72qRHs4bKBSH+XNcgdjue0ocvA4iopENyuJ5TPYpLC5gYp8E0emr62RRo1K+UmKAkgNFKltoOzQtq6ZpjtAJeNR8OCcZfLyuPK8SIEHae9CMeIbCfJr0HxZQLe1/thN4RvncURRoT0RJUxefA1B94PKGsBoWAT75c95PL7GqwaQaXfdbJ12R+VA3rJF01RCbAtR6yirEK2BvBYki/kUA3YgsS3S0LyOqQ5hQ1VFsOwd4E7rU9DgEpiWiDUKCAy/8ON1HoC/H+EhdQCKVfhZoPTEQ+guL4FhHUBzi9KTFe5etrBBV0yji/06JVFwGlR5+ybwhIt+hc0o/bFKWtzC/S6R/QZj5Lj9ExkmcnNhIwfNAfc7RqdObRSe26qqqqqqqqqq6nOj3nijj5/8ti/C1//As/jExRJ/4Hvehx/8pnfgDdf7r/TQqqqqqqpK9dDg+/z8XEAq4SshGwHtdDpFFEWYTqelxopA0ZQQgKRTQ50F3dvUcxwcHEjqOkyKU7dhjMHJyYkoKQj4CNbo9Ca4TtMUJycnWK1WuH79OhqNBvb398UrzW0yIc3GlrsgOgTuTEEfHBxIeniz2ZQaEBJyEi6zySPfH7qnCfyZBh+PxzI+OqBDtQq1MwcHB8iy7JJbnIleAnaCwPV6jWazKWqKK1euCJyOoqgEUpvNpoyREJ/zTUjJ7XKhIIoiAfxs6kl9B6+FXq8n54jXEo+BaeTNZoPlcikJZLqkT05OSs0t6SW/e/euOLkBCIAmQOX3bAZJ4MvKskw0MPV6XcAuobZSCvP5XMBuuAhCeA2gtCjR7/dxcHCAmzdv4sknn5TEMhcFuBhANQfd2rwnCOTpSec55lwwhc7tEuwrpXDnzh05b9ZaAcRMU5+dnWE0GuHmzZsC+0MdTxzHkg6nOohPNHS7XUwmE/kM3emcezaTnc/nssDVbDaRpqm8xqcJ5vM5ptMp5vO5POFRq9VwdnYmiwPz+Rxa65JXn3MHQHQ7PP7BYID5fP6wv95edaV8Q0oYwNQNVKqglxq2bmGVS3YSiCujkDcM9PZllAOhrkChSL6a4u8ldYpPnDJFyw9bbYt0Odmrf11viv0y1RptFWozi3jkPf/GumaR9HVTbRKCXGn8GEBl40meVkXjSa9HcalqX1kG6N0Off7zTDiLW9w4f7cN9CfGFjCbju5cFSoW2a5xwJ3Jbb8NG+7bT7sD60EyPPSaW1tOfwMOUvvXHcDn53bAuMzNg5Pm0ApKs7tj4Obmfvm50pwX+2DSW47PaJg8SMRbi/fc/gAAYGU1ljbH6LwLvdKw2l0PTnfjUsaaKengeiMYV1lZTyLHEShTwtKZRV7zi8BbIGtB1DoAkPsHoEzQy9QlnZU7/ODpBUlOBylw58r3axzy4EABznl9h7BcYHu4nSC1LXA+TGP7+0sZBZO4e0vS7dyOh9elZHqQGFfB/uRYBW5buedlDOFCgS5/VJ4agT9vmXIPg/i1GUPo7fdB9/8lgF9VVVVVVVVVVX3O1JMHbfzEt30hvvEH3o9fuTvFf/29v4Dv/aNvx2955uCVHlpVVVVVldSn1dySIJUAkxCsVqtJEjOEuPfu3RMgR0BO9/J0OhVNBGErE9QE1ZPJRJK/TGPX63WsVitRYXD/i8VCoBhBGgD0ej15LxtybjYbNJtN8WrP53PkeS6gk80FCe1Wq5Wkh/M8l4aBi8VCYCiBH9O/AErzROBNQMjjWiwWl6Dmer3GYrFAu93GfD4X+Mh5JfRkmnowGEjDSACynVCRQjhN4Kq1Rr/fl3O7Xq8lIcyxcR+EOUw9MxkMoAT6mboHIAATcDCS7m8AsuAR6m3C5HKv18NyuSylxheLhSyM1Ot1dLtd8cdvt1tMJhPMZjOcnZ3JtdputyW1TPhLOEtAzmu42WxKYnm5XOLg4EBAPlU7vBbC88rFEKa1ueDAlPfe3h4ee+wxDIdDScTTU07gT6UKv1LbEkWRpKCzLJMxcH7H4zEajQam0ym22y2uXLki49daSxqfx8+nH7iIs1gs8MY3vhGz2Qy3b9+GUkpc/NZaUYtMp1NRnfAcLJdL3L17V56e4GIHG8DyvVmW4fT0VBaZkiTBaDSSpqetVgvT6VQWzdbrNXq9npw3zkWj0cByuZQ0e7fbFcUJF2fYDJS+/XBR41ErG9vCwQ0mVuHc31EBDQnT9NZpTQj7tAfZNgRxKJKdVB44+K1cutwUyVLqTsI0KdPhKlclWLZb9APrLVCfGGDrlTUEqXlAFPnzMOmcZpBmi7sJaKWctzvNLqeVdVSG1ITnWQa727jRWiDPSmMSFUioQaFHm5oRqlJyI4qYAtLnHu67ibcApHElAbfeORbxTZNKohifbxTMMVxa0ggbTwKucSjhOFPkaVboXwJIbq2FCjUvoVZFFDQe9BoLpctje++dDyH1n02twTd8/ldA/+VEFBma1xfBceybVBKYeje8TgtQq/MdMCzJ5eCQMyBrej947GC3iYDIQ1sbrCOEqW6VBX+3BeClGsRGxU64f50r5D7dTLDN94X3pgBtf//wXjK18tgRHGOpmOSOA3icF0BeBTBbkvP+crncgDNIdPv3U5Mk4/bb5SIWEHyGp1lzIlTpdfnKcWt3n5f0LVVVVVVVVVVV1edUHXUb+H/9iXfiT/yT5/C+XzvHN/3gs/iur3kzfvebrr3SQ6uqqqqqAvBpNrcEIO5cJloJSZn0JVBjM0r+hzFBN1UOBMgHBwdYLBbS9JCJWjby2263oqAgsGRileCbDRGpWRiPxyV4SKDJNDng0slM/FKlQkcywTN9z/w53dsAMB6PEXmwQNAYOsEByCLBZDIRDQWbanLOeOybzaaUsqXWwVqL8XiM5XKJ4XAIrTX29/flmJIkwd27dwWkApBUbZg8TpJEVBfUXfDcmCCpF6ag2RCSMJN6Grl4vEuZ54PXAjUWfM/+/j5Go5EkiQnhQ2f3drtFp9OBUgqz2Qxaa5lXpsHPz8/F080FAADyGc7ZSy+9hPPzczzxxBNYrVbodruyKBI+pRCmlfkkQxRFGA6H6Ha7or0hHKeih/PGeebCDZ8u4JMOs9kMjz32GDabDQ4ODtBoNATqc44JfhuNhgB+6lcIk3kN8nwCkEaqHONms8Hdu3fRarVkXtgMtd/vyzyy8axSCjdv3sRoNJJr+sqVK3KtMy2dpilGo5GM9/T0VBZOmNxer9fY29uTOQzvE841n1zgtnkN8L7l7wr6iOmDJ0RvNBqiUtput5hOpxgOh7LQYIyRxrB8MoK6o0ex1NZDURXANDq/PXmiCoIJbKuDJCtcSlRAZFa8PwR2CoR2PkHNFGpW6AsIybXsEGXdCRy0AyDgTGdAbWbRvLdGKdX9Mp5pSUFnuUtuR1EZ2EaRg4HGuvda62B26Nm2Bkonbju5ccCbLm76u0Wd4rev42IbfnuW6hBrHQT26W6VxLBKQUU1B5W37mAFhhvf8DELwLHXpwB50ZRT6QK4czwsNsZUqmjQKSns/LKHOyw/t1ZrKO7XH4Okz30jT2hVul85lt0GnzaA3/zZe+98CLktxvCHnv4SjL/mC5BMNbKWRW2hYGIHRFWunHfbWkTr8jVmtQPBJiogd6jc4LXM60wH3/OP1XCNLYN0dZgaLzXPBEqQWhLaIYhmIhw+ZR2Cay4ARf7eygFkLkVeSjszcc3t+THrzA9QW1nwMDGgtIWNHVSnloWfVwAQKOwFOvPYUF5Dws5r8FCfgJzHxEUt698TwnXZhtrZTpBcl3ni/CmU56qqqqqqqqqqqvqcqm4jwT/+pt+EP/vj/x4//Ut38ad/9IM4m23wzb/lqVd6aFVVVVVVDw++CUyZ+AUKsBvHsaSZCcQIBQlK0zQVhzXVGXQJMwEcxzEGg4HoGAi1oyjCZDJBnucwxggUJFxdLpeYz+cCrQlgAZdmJnDbbDbo9XpotVqSZlVKCbQ0xgiIZoNCfo6glWATgKSyCeQ4J0y5U+nCz1JhQkAXakE4HjZqZJqcAJCalFqtJuqI09NTPPnkk1itVri4uMCVK1cAQFK/1HTMZjP0ej3U63UopXDv3j3s7e1hu91KM8X9/X3MZjMcHR2J35qAM4S5PJ9sWMmELudjtVoJmOfxp2mKTqeDer2O4+NjmScqOZikJ9AkoI6iCKenp3L+rbU4Pz9Hr9fD+fm5JMin06kkzy8uLpCmKfb39wUCU5nDcxQ2uOTxUGkT6ml4bdMZzwQz4XMIeHm9Ud1BJU6appKs73Q6kvxfrVaySMTFEnqt1+u1nINOpyOLHKvVSu49Hs/9+/exv79fus8ajQZGo5EobZji5z6uXbsmwJ7X63A4FM0K52i1WpXS1Pw9QNjF5plMcXPuQm0LU/KEY7wmqa9hop73wfn5uSxWcV88Lj4twm3xiYl2u41msymLUHwffz88kmVdwztRHCiX2rQeUNNzrHLfzC5TJR+yfM4rqW3kYWHYlA4oNfsrOb2VBUKfsYeSJnavaZ94VQYwdRTuZg81kynQvZUhWmxehsx50G1tkW6VlyyUqEb817D5JeFwoAVxO9ewaSqubYHWgVaJiWalvK7L2AI+hxA9TWGzzMFmpXcSz6Zo8AiIW1y8L8H2JEUOOOitNRSbkJaaXHrnONPwXBCINJTVbgx8azhZAQin05tjEKC9q2rxjTQBiD/80ntKJ8SUxvrl19+C997+ICLAAXCtMH9Mw0ZA7OF2vCzSxiSsNgb0Bt4L7aGvD8OHnvoweWx1kda2CohyC2SASZQsypgEiLmeSzBMaBtqPQLIXXJ8Y+e1yBZp6rBUcL8Q9jJ5LcfgF5s8GKdbW2ccgxV4zt1Ceze3jNUWoD5TAJPgvD8fBOwRjIE+b84BBx2OXVs3FKvKzTyDBQLZZvD7QTT29JvvLBpUVVVVVVVVVVWfu1WPI/y9r30LDjt1/OD7XsBfffev4GS2wXd8xesu6/aqqqqqqj6D9dDgmwCPDSGpJKGOIYSc4/EY9Xq9BMyoKiD4I/gkZNxsNgKMuV0mibkvpj4JxgnZmfheLBYCqZkUJZBkepiAndukYoEgnSCcgA6AOLWZRGXDP7qmmXRttVqibwEcGOXn8zwvNfcL0+9RFInnmf7iXq8Hay3u3r0rTSWXy6UAceorRqORHA9VJzyGLMvQarXQarVwdnYmkNMYI5qMLMsErlK1wUUOJrIJjBuNhgB8Kj7oaAcgShl60sPkcZIkskjA9/O91FOwYSXHydfOz88xGo1kvgh1CXupxjk/P8d6vcZkMsGNGzdgjEG328V0OhX3M9U4BLz8R5jHD0D2G8cx+v0+RqORXF+E3vzMYrEQqMxmlK1WS9zzTKLTQc/X6bfWWstY+v0+ptMplsulKF5CQBzqbAi3+TNCeC7a8JokvOLiwmte8xrEcSxPNXAxCHCqmtPTU7l3lFJYLBbyZAe3wwUpPiHA/QGQRS3e45yT+XwuqXCedyb9W62WpNw3mw0uLi5weHgo7wEg9wDvJz4VorWW65eO8Ol0Kkn4R7W0cFXv1mZzPm2LZpcEWNoD8ICjitIgANuEbNLkTqNIfdoyS5N0JyAeXxPDK1gAmALm2SDBqlOFeOU8zLWLLVRmJNlttYKixgQow2/v2BZQ7RPZOxzOD8gnq3MjKWQA0tjRMt3tE86lJpRRBBVoPdygCxAMoJx8DoCv9fempSs8+Lmb6kA14ptLYue9yPNCu6I1VKRLEFwplzZ3ny2AfmmchOKBCoZNOi1ypzAhAPdPNZWaYiIAv7vQWyTTfo7990orUDhu81wS3xlyrH/7fyHebJ15fYlxQNoljRW0cQnweIVioYWpbSawI7d2YAFRi4RJ6tL3tvB769SlxnUawvby57i/MIkNFN+LysRf91wckusv/FXEZHr4c0J2r25xqW13ryj/RuvvVSbXLfxiljyKUYxNrpgA/PM+lPu4GI77OIF6mNwm7w596Uy92+Bnxi1McMdM59vIIk+COczdsUhCPw+US5XqpKqqqqqqqqo+50trhb/8VZ+Pw24d//f3fgTf8/O/htPZBv/T738jkt2m71VVVVVVn6F6aPDd7/dLidlGoyHAqlarSVqUSVpCXIKr2WwmcI6AkToLwkgC1UajgfF4LHCVIPb09FQSokybM73L1C9VFgR1hJyLxQLXrl0T9/R4PBZg1ul00Ov1oLWWlCm1I0zuMu3dbrexXC4xmUzQarUkkR6qVThP1lp0u10BsyHwJ9zv9/uiE2ETQzb3IzxWSkkSmolxay0ODw/leK214jUHILDSWiuNQdM0lcUFnpPj42NJExOyUj/B7dBbzkaR3A6VEqyweWW325XFi1qtJs046/W6pMzX67X4sYfDoeyHWhqeAy5shMnuyWQiLnOqcwCn4jg4OJAnENjUkqn7UJkBFA0qeZ3wmA4PD9Fut7FYLDCfz3F6eopGo4E4jsVpTtc7VTC8jllZlmE8HmM2m8lCBRP7bBDaaDTkuuO5pqee1w3nhQAeKDQ/SZJIw1Eu3rBBJxcgeN91Oh1xdqdpKkCv1+vh1q1bAo+73a7MEc8d7yde71mW4ezsTJz5XIDiNrnAA0CeEmm327JoxXuMrm6eS15zXKzgz/f396GUQr/fx2azwd7eHvI8FyUN0/m8f6k8eWTLJ7ttYgqorfzPA1gIq5xSwuzAYf/2EPSFCghpgoed1wPVA6xTJFjvFOfnwJQoHGx08NG9nrUsoq1C88Ignq6BbQrlU8yK7ujQcW0CMJ6mDnynmZc2M65efHVpbT83YcIZcAcQuXQ00q1LgIfNIms1II7de7apT5KbIh1N2J7n0pBSxbHTfCjt3qfhwHKQDndNKCN/SKoM0v3xXWpMyaQ23w8UKhRW6h3kOw0wS6oTQvAs84sBgGU6PNSiaH35815fYlMLpZV3eQdzywaitRoUYTwKRruxGX7fU78Fp38ucdA6c9cHF0TyGoGyJ60W8uSBToE8LuA3fdPhNcknFATy+uszrymo3MJCIV4CWROIJFGNYAOQJo9QquTDflA6WcA3intHnqCg29vfc+4bW/jCtXsaQ1tApcXxMv1tI6czYZJcQtheaxKmw2U/cJC81GRWBcnrYF5Kh7VzLzvlEQrArYPthSnyoJRx7zUJkDcK/7/eKh46dKpcgj8PGolWVVVVVVVVVVWf86WUwp/80tfgsFvHf//Pfxk/+YFbuFhs8A/+yFvRqj00fqqqqqqq+s9WD/2b5+DgQJLUrVZLwDbhHME106qE1QRm1lp0Op0SuCZAo2ai2+2KS5ppbxmoT7zyM9RUMIlLrQFBL/e7WCwwHo9x8+ZN3LhxQ5Qf9XpdwDfTxsPhEBcXF5LUpq/4ypUrcnztdhvT6VTGSnAaggl+vtvtotlsihZiMpnIcXS7XXE0E4hzvpii5meZzJ1Op5K4b7fbojBhap3QlUnkWq2G09NT2TbVKmz8l2UZ7ty5g6OjI2nAyQaCPNYwAU84S6DN5DlhJ5Pz1F0QzNK13O12sVqtJLUepp0BCAQO3dnGGElNUztC+M/tUiHzkY98BLdv38aTTz4pPmsuBhAYh4siPPd5ngvcfeKJJ6TxJ3UkWmsMBgMAECDNcw5AEtC8F6IoksUUnkPOPY+PTnPeU2x0uVqtpJkq55bOczrIgUI5AhTaGKpatNbodrtQSmF/fx9aaxwcHMg1tN1ucX5+LgtWn/jEJ2TxYG9vT5L17XZbGolyrtkMlk84cGEhz3Ocn5/LwkKtVkO320Wj0UC/3xd1EZ924PYI/5kCp4t+MBig0Wig2+3KvPPYm80mOp0OxuOxPHVAsM4moFT0PKplI+sbRCoHlRVgtU9/B7Fs0RQwrbkLt4u/lnQkJoEANwCINpAkp0m8BiMqtqlz0H4CZYC84dKqbFKY9vw9mQCdl4Der4yg1lvX2DLSBQjWARiOI2BryuoSwPu1vaM6UUBqARTJbXFVYwd+W0Z6A2AOoKQOscZRQ+3nLopg81SaWnIf7779HDQU/qsn3wmVKNEDKaVcotxYl9bm9hH8GxKmx3ebRhLi504RIml3rZ3TmxDcUsUCBq09APcgn0XPeZ6Lj1uFEDIE3nleQPgoAmIFu01F46K8+9ymGVQSS1NOal2Kp2vcfn7fzd+K0de+1SW8tw50RxsPW5VLd5sEMDW3OGPq7nUTleEr/fNA8ZXvUxaF41oBeaIQbSzyerEQo1NI2pnw2GoULm6LUt9QbgsoFoNkIcknxi3fowLgTRounSaLFLdiTJ2APbwGAHkyQkHJExYcv0u7++S0sqItKn02grj2S4l2D7hLIFsFc+DHLAsQ4bFwcS3QmXC7ec263zvB9uAXJhyIL6A3igcPqqqqqqqqqqqqV1F9zdsfw367hj/5Tz+Af/2RU/zh7/t3+IFv/E3Ya9c+9Yerqqqqqv4z1kODbzqAmfglUKS3G4BAXIK8MP28t7cn+oZGo4HZbAYA4u5uNBpYrVaiRyDYJhiz1kpDvFDpYK0VMDudTiV5TdDJhpL7+/vo9/vY29uTJDlVEwTxTBYTYGqtUa/XMRgMMBgMpIkhAT+BNlAA1UajUUq0A4W65eDgQOaEZ9K/FQAAxEtJREFUXwmYqb7gwgE/f+PGDQHVy+USvV5PPM/UwzD9S/DNFC33Tzf7ZDLBer0W4K61FkDIZqJsJBlFES4uLpAkCVqtFgCXMqYnnMfLcw44IMmU9Wq1Qq1Wk1Quk8Gcd46BMDhUiPCcAAVoPT4+xna7xcnJCeI4xvn5eUlXcvv2bXGJs1HpZDKRRRL+jOePiw2E+wS0rVar9MRBCHmn06m41lk8Z5xrNpOkZ31/fx+AU+0w4UwvNV3fzWYT0+lUxhguGtVqNdHe8LpnEaBTjxM2neVTAUynh/cKzwOvNSbW+/2+zOve3p40wuR7AJQUNrzG+PQFx7BarTAYDGSBhwsq4TVC7zrvz9ATz/uPDUUByEKEtRbNZlOalbLBLKE40+pslvuolsodYJO0d6AWCJOzocqklOgOEp7Kgyn6vUu+Y3qFvSqCn6X6wUFvVTTSzJ17HAmg0gLEN868qsMAhx+cOegN+AS2CoCzp7JZ5kBzlrlUtW8giWzr09OeehoL1BKAPm6C4dwB2VLiO47dtnID2Mx9hUssI/Jg2atVrFJFutwDYcDD3STGV15/G6AUdF0D/t9A7dPZdrW+5MQOU+juL1bUKIgi2G0qiW5JU5uA/gZal0+m+LG70Nv/zBorKXXXuFJBmTKR5HjKyXNVqFakEWe4Q3/eciXAGybHu66/Fe++/T78l9/5VtSmDtCnXQ+4gyS3qExyQKUOhHMBJdoW6Wc6v21cpJ+VBeKVRdb0/5asiyaNKrd+2woqClLRSeGhF50H1RyleYSHw9brOryaBJAEtLWAJhxWxfvdSSrgt+K82J3zxu0H6hE2nJW3cFxeY6KYFOcmd9Ut/n4nPFcAkAfbscU9zrS7MkX63MTFRKhgexyD7DcC8tjNoQBw/x6dut8Bmt5xFYyzqqqqqqqqqqp6VdVvf/0V/Mgffyf+2A+9Hx96aYw/8D3vww9/8ztwY9h6pYdWVVVVPUL10OB7MBigXq8LkOv1ekiSRDQKTAHfv38fV65cEU0C/yOZEI1A2hgjjewIuZjmrdfrpSaTeZ6Xmvox8cv0LcEvoexuYztCRq21uLqpfWi32wJDAQf22LCRKXRqMqiC4DysVitJvVOJQnc4j5Ggbz6fl5pc7u/vC6QjACSI7/V6oocIvzLJTcUJFSF0PBNyEnTTn8xmkcfHxwJqCYO3260kjOfzuSwybLdb8TtvNhtJ787nc1n8WK1W0lgQgMBIAAJI6vW6wBYufDAdTWhKoM5mkDwXTMffvHkTtVoNFxcX6HQ6on3h8VJbw8Qz08+TyUSgPNUfIWBn4ppNPnu9HtrtNiaTicwjQTRVIZwroGiSGT7ZUKvVROtD7/fZ2Rnu3r2Lvb09ZFmGfr+Per0u0JpgOcsy8XZnWSYpc0J3aoEA59KmSofHx8UZurGttbi4uJDzyPnUWkvTSuqCuHASptQJsBeLhSx+hM1j6fkeDoclTU6z2USz2cT5+TkWi4Uk1cMnCWazmTRtDVPyfKKAqXMu5sznc3nqgqluPo3A3z17e3vydASAkj7lUSsHqZWAKQFyKEKn5VgoxI0c/mxXcRA2sFPUHvhtipIiDEv7H6kQkOliDCYmXHQvNU4tkPkPU9VBWJvEQEY461Pepkhvq0jDhs4ENpzMUSTFgQLmal1OfOcGVpkC4Oa5e2+eA5Eu3N+5KTWelEaVAcxW/D0TNo+kMsUvQglY9+MAnd7BUzTW2kJDgghQWhLZoS4FWkH5f1ttkNK2SolyxI29gPSWqXGvZnnvnQ8BcM0nFQBLn3m4PZ+WV8HvUWnOGZaxheKFu/dg/b13PoSNTfFVT/6XSL7aIm8orA8UahPrPO5eUWJjQGVAlLrrRJ4aiFzzS5O4a5CqjFLyO3KfzWtlSGyUgqlZpzsxgKk5d3hpAcjrRNz8BdcwAXTpvim+0blygXwPzRE0gVWA70upAqAMuXkKsA0HsZlWD5hxSRfETfPe0cH3fk3EDYrb9XPr0+uK93YIq8Njs8V9LePyO+V9D+10MeIcf0BzSwV36fKcRhtVJM9VMM9haryqqqqqqqqqqnpV1dueGOInvvUL8fXf/yw+drrA7//u9+GHvvkd+Lzj3is9tKqqqmqnlFK/DcCfB/A2AFcBfLW19l8ErysAfxnAfwNgCODfAfiT1tr/GLynDuBvAvhDAJoAfhbAt1trb32GDuNSPTT4plOXWgwmswmbl8slWq0W2u22QLbQ/0xNBgBJ/S4WC8xmMwF9q9VKVCYAxAceNjrkdgjdCLkIU5lCJeBsNBp47LHHcP36dRweHuLGjRu4d+8eHn/8cYGZi8VC0uadTgfNZlNc3hwzmylSt0EvMR3WTE9z3AAEQm42GwG9dFwT9nM7TAmzASeBJJOzTF5TGbG3t1dqojkYDCThSm1Js9kUQE79AxPGxhis12uB1vv7+zKX/EqIvNlsMBwOJRGfJAlOTk4wHA7lvAMu2c4mhhxLq9WSNDn92CGQXCwWsjhAYL9arWTRgI0SCbl5brXWOD8/l22EDvpGo4HFYiHnh08PULPDOeLxDIdDUeBwYYXvazabqNVqOD8/x2q1QhzHJdDPxRBumw1Oa7UaOp2OLOKMRiOMRiNcu3ZNPssFFmMMptMplFKy7yiKsFqtcHR0JCqWe/fuydxZa7G/v4/5fC4LEIT71KIAKMFy3jdcSOGY6aFnwpxPNNTrdVkE4DVBWM/riHNEnQ7vxdFohOl0KotkBP3r9RpXr15FkiRYr9fyBMJwOJQ0+nw+l6c9uFBGwE/9EHsJ8AmSNE1x7949WWBi8v9RLia0BdjtplZVAL0il+yUt1CBQhuHh1pskAevcxBFArcZB8SL0I+JUhMET3PA1Bz8q00VGmfuc71PbKGXGwdj46jwWEde7wG41wjDrYH1iWOX+vagXDzgugDSxrrtcAxsNLnbnDHLHFRmY8cokkaYNjew2634rd1HvAICUaEviWMHjMNGnIBLbgMlEE/47tQkpkiv253JZWJdlCRRsS3vD5f52W06KdsooLoD/LoE0HOf0LbGQiEX3zebX8Iad7yE5sHPlHbJfHF7R5GAdWuswPIvv/ZmvPfOhxBdu4LVnkLWUohWQN5Q0vTU1F1CO68VDmv4r1HmgHW4IAPtL1lewAGM1Vv3w7yuoFOL1qnB8qDQzPD+MN6hveurLq0ShZcKYTihLZPWyi84KSvvl2avBMqlDpTBdh9wj8pbTPk9AqBVAZYlre3vQ1GcBItYITDnfKlcAZF1rm0bvM6BSVLd7yOyQKbcYgMPVRXjVf7cqNwtCOgMRcrbFOM0teB3SgW+q6qqqqqqqupVW6856uInv/2L8A0/8Cw+en+OP/g9v4B/9PVvx29+ev+VHlpVVVVVrjaAfw/gHwP4yQe8/hcA/FkA3wjgowD+IoCfUUq9zlo78+/52wC+CsDXAjgH8F0A3q2Uepu19hWBNA8Nvg8PDwWU9vt9LJdLdLtdSWI2Gg0sl0skSYL9/X3xMzMJGzbuI5Dkz/j3PM9FpRB6rpkeDxUkVD8QyAHuP86ZIGVStNVq4cqVKzg6OsJTTz0lOosw+c2UORPPBJEEalRKEBASOBPuUmVCVQjBAuEiX2ezQaoomIrmQgBQwHIC9TRNJXFNjcjVq1exWCzQ6/XEL03Yx3kghGXClr7t1WqFTqcjipnRaCT74Xxx/pnsJmiO4xhxHJeaEmZZJjoPpn1Xq5UsZISLAEzE0//NlLtSCqvVShLWAGTf9Fwvl0us12uMx2OcnZ0J8OX8E6IOBgNJdocJbyaUeQwcT7fbxZUrV+Rpg8ViAa21pNeZ2qaWhsCV55fXOBPNbKzY7XZl3qy10gw2z3NRf1BhQvhbq9XQ7/flCQalFC4uLmTeut0uTk5OALhFiXBhhgscvN6oHZnP5/L3PM9lkaFWq+HKlSty3nnv0rHNe4P3Ga95XoOA8/7zfuNi13K5xNnZGS4uLgTmcxGDCzTh/c30NueKizI8X9wX1Tn1el3840yKU2tTq9Ww2WzQ6/Xk/nlUS+BW0NSOgE6S2Uym+hINA+DhXRAFtR5g05ecOaBl6lbA2q6pAb6hHdO3kj5VgKlbaW5nFdC57a7D2vkKKs2kUaSDvFYaWBJ6S1oZcAA3igrlBsdRSjp7l7VE0TWgDZDv0Lbcw+3NxmlPosiBXO+qNqs1YHK85/YHAACRbxz55Tfe5vdZ9naXmlCGCzFhQpow2RpYpT1ENgXI9/tg0ptwXWD0zrEqpWDBxHqRVHcNJoN520lq5yFoNzmskN3i5zbL8N47H8KXX3+LS5/7ppbFzgMXunL6IxtFLgXN49cR3vV5vw3mtX1kLSVNLfMEQAzR5pjYPT1A4EtAGvqq5br2zSn5WRsDKvXvj4uktEkUJk9FSOZegaK8RzwOoHFki/SzxK13Es2ShLbiJKcOJNSGSOlwO7z/yu8JG3Xu6ocuLVztLGbRm20SCxtb8ey7ZLVvKhksXHFOpfmmtqVUN/dtw4UA439nxLZwmUfOKX7p3vdQXWfe5Z0FLnX/xIepuX4ADtqrS4toVVVVVVVVVVXVq6uu9pv4Z3/ii/DHf/j9eP8LI/zRH3gWf/dr34KveMPxKz20qqqqype19n8D8L8BuKTQ9Gnv/w7A/2it/ef+Z98A4D6APwzge5VSfQB/DMAftdb+K/+erwPwEoDfAeC9n5ED2amHBt9nZ2f4vM/7PIzHY9E5UKXR6XSwXC6lISHBGpOoAERjwAQwE8S1Wg2TyaQEOZkMpiqDjmhCb8I0QkimwAnPmVIGgOvXr+Ppp5/G448/jitXrogChOCN7msqV+7evStwnvtkM0/CUsJOaksIeXu9nrwPcMlvgsfQO023NJ3FYfKbyVYmyNnYkMdMNzUT4mHTRPqQmRpPkkT8zVS9MEnM4+v1elgsFgLG6Utn8pcQlD/n/BFML5dLAdDWWgHpXNAg5A/hLhs8EsSvVisB94TI3O9wOMRiscC9e/dkPJvNBvfu3ZPjXa1WuHfvHuI4FuhJDQaT7QThXHwI0/1nZ2doNpuSSOb7Cb0J6HleCb7DZqLUtBDcs7ljr9fD4eEhDg4OBCSPx2OB5rPZTBLeBO+8X4BCacInALjPMLnOxRE2ByUopxKISXAu5IQNZXnfcdFhPB4jjuPSIgrPNwDx73PxiGofqmp4HcVxLEl5QnM2auVTId1uV64Vzh0bjq5WK1HJABCPOdUz3Ge9XsfFxYU0ueUiCe/nR7WMB4B0JDOBKoDKp1HDJKp8D0Axoazc353CQZXSmTby0DvQmhimWgNgxzSszgo9RbRSyOsWKlYY/Kcc8dJBUT1dOlCc5UV6m8W/K+W0Jt7zHaa7VaQLuEsgy6aQQJGE9rBchfA3UJxYD40V4FLhxrm833vrOWxsipXNoX3sPVGR03hoVQD6QHFSDD/YT/DUi0096PbAGwBsnheA2Ro3TupOANfMEoDFyy+YOyCdQyGSsakg8W6tlW3bPBeIL8qTa28GbA7LfXrgn1ueCwObWeddtwbWeA2LVsU4i8HIX9kEc3mjVTSptBBlhomBPExRe+0JWTHBLTUlosywxcKMygK4Kwsh3vOtFdKO90z7ppmhZsMt1vhU/SdJISsLl9yObAHFtYXZhcAA6MOX5rJhUtxva1c/UnjBi+OQTYfjlaS5A9ImRim1HvrSSw0uAQHYpRT5AxawLi+E2RKofpnAukvw50C0Lo7JNNzvJ5PYUmL90n6rqqqqqqqqqqpXXfVbCf7JH/vN+FM/+kH8zK/cx7f/yHP4q7/nDfi6dz7xSg+tqqpezdXdgdgba+3m5d78SeopAMcA/nf+wFq7UUr9PIAvAvC9cIqUZOc9d5RS/8G/57MbfLP5X6fTwYsvvgjAwT1CQCo9ms0mlFI4PT0VMAa4JDFBchzH4vwmKA4b0W23W0laM+VJwEa9CbfbaDTEOxwmg8OGi7VaTZLqeZ5jNpuVEseHh4eYz+cYjUbY29sTCM1UNpOooX+YMJLQkwldqi4ACGSkV5tOY+oYeEybzUYaJBJuEjAzSc+kbZIkAviY8CVsnM/nAICrV68KNOx0OgIzuagQNmJsNBrSxLJer8uCAOePSXQmstlAkvsdDAaS6gYcdA+bjFKHQ+9z6MgmXN5ut/IEAaHser3GfD7H7du3MZ/PZTEjTPnz62QywdnZmahSCIGZpg4T2u12G+v1Gvv7+3Ics9kML730Evb29jAajeR6G4/Hcu1Op1NJGp+dnQGAwG5Cca01kiSRRYpOp4MbN27Ikw5swEq9CuE4wS+/Z9KZ0JvXUPgkw2w2E9UHFzF4jqlfYQNWNoYlBOc5IWTnwky4GMDthO5u3vNMZPNc8XhXq5WAai5ijMdjaap6fHyMNE1LSp7wd0e9Xpd7hL8DuNjAr9w3708mvXmekyRBs9nEbDZ7pBPf0RqiI9HGhzUDIidObhWET9XlJCiU8/gqDVhlYawqlCXUE5BxBgAcKNKvKg32qRwIs5Hz/erUKSiS84V/k3XQOwTaQVLamgBgs5QWoE1vNtiska7uKAK0caqRKHLaDQ9sBRKmVrzdbC5p81wWATiO3Fqk1hFKrVyS9t23n8NX3ni7G07ov/bbgvokVI9A23jIzIaQnA9AUtVKeVjo77NSwtp/bwP8SP1ICURrNhI1sEzWw7m933v7g8itwbuuv9VvoDzuSGnk1jgof+NtEImz35ebryJRzn+nDFUoPJarh9h2tEDvaO3myCofxG8CyNywna7Eg+Lc7dLEEHgM+Nfj8NqDLOaE17Tx6W+VFcDbBKeLjTOVCUAvUCwKhdPxgNdLjWSB4omL3Sp1rIQAftmsVVAoGmyW4LeFu2Z3ALlYSbLA8W2UqIaYJi+e/IDsXxYgdoLopQS6xNqBEqX261OlKyVIjavi/x4gr7vFL5sEYzY7UL+qqqqqqqqqqnpVVyOJ8N1/5K34S//rf8SPPvsJ/MV/8R9wOtvgv/sdz3zSJu1VVVXVr7t23dr/NwB/5dexHT6ecX/n5/cBPBG8Z2utHT3gPa/Y4x0PDb6TJMFHPvIRtFotAbVPPfUU2u02FouF+I6ZciYIJKAmDOXPCLQBCJDlZ9igjooQAt8oijAajQRsJkkiEJvbYSqcUE0phfF4jF6vhyiKcHFxIalVY4zAVuoYAIhOgSoMahbYiJGKBsLIxWKBTqcjoJzHTC2K1lo+z+Rt6CYn4CNkDsEzYSZhPiE8tS+E5Ov1GkdHRwBcI0A25ZzP52i1WgLsmepOkkTgJJOIp6enuHLlivi4Q9AKQJp5Evgzmct5o6KD22QiPc9zAeUcO+Dg7WKxwHQ6xWAwwPn5OcbjsSSWmYgnmGe6nPoPQlamgKlsYbPJUJ0SNka8fv26pPr5tEG328VoNEKappIiZtKfCyq8ZrhNLiDkeS4LFaGje71eI89zDAYDdDodGVun08FwOJT0OsE3tTftdhuj0UiOjVA6dJS3Wi0sFgs5TzyvTLrz/uHneC01m01p/MnFKC7a8Lrn/U13PxcMWNxPmHLn91EUYbvdyv0GAOfn57K/JEkwnU6lqWzoIufxcI64AMW55lMVAEpPl3AhKVwkyPNcwP6jWMoo7yt2RErlKBpRAq55HqEWIZXBZfpkVQmuUU2AzAPE4P0EkwLAfcrUcl+ADMAkFtHKbbtza+saWQJl6J06SA2/eAOgAN5ZVqS6lddqaA1rqNNQQObT3TlAP7fTewQJ8AcUdR4saj349/fceg7GH6T21FxD4b23P+jeC0j6XNQnom1B+Ti4Tya8r71Zfpbaohkkt2tzyPH4wRYbCVK5IWQuNbcMveNR5OZRkYS6bb7r+ltLjS79hgClRIfifu7n3SfGRddivJ88z6HiBBYW737pWZeM9/Wu3/Y4TKwQL/3iSxgQVx6WKgelo01xDSkD5N4LLf55A0QbizRRcq27n7snEvK6nwsNxGuL+THQvg2kkYPCTH2LRsUWizSE0Jd4bwi9ed+EiW6jSsBX5f6+8wslohzhkxYIoLkCxLbvQXWxX1xqQqv8uEOQrVL3AZ0FzUK9Cx3B3Mmh5MVnS4B/5/cBFwS4SKYydblRbnAsoT6FT5dkLVu8x7/2oG1UVVVVVVVVVVWv3oojjb/+1W/AYbeOv/uzz+Pv/OzzOJlt8Nd+7xsQPahPTVVVVfV/pm4AmAXf/3rS3mHtPuipHvCz3XqY9/yG1W4bp6qqqqqqqqqqqqqqqqqqqqqqqqqqqqr6DSmlFP7sl70Wf+33vgFKAT/67Cfw7T/yHNbpK9L7rqqqXs01s9ZOgz+/XvB9z3/dTW4foUiB3wNQU0oNP8l7PuP10InvVquF0WiE27dvo9frodVq4fz8vJTMpbaCjQHr9bok9ZgMpvaCTQSZ6KT/uN1uo9FooNvtSoKWTu3pdIpWqyUOcOpBqHBYLBaiXeB+2Xxxs9lgPB6j1WohyzIZB9Pj9GADkAQpmzBS76CUwnA4lDTsaDTCdrvFarVCq9UCANGhABDtxW5qlwoJ/oxOZKZUsyzDcDjEtWvXsLe3J80FmWi11opSJkyUM9nLRoZMIgOFsiTcJwDxZPPYwsaGTOgzuc3zTL9yp9ORMQCQMTHBXK/XS+OazWZotVqiB+G5Zer+1q1bso9QX0Of/Gg0wunpKUajEWazGZbLpVxb4RwBkHmm8oTHuL+/L8lwKlSYJqdLfT6fY71ey3GzOajWuqROYaKYqfxGoyE6nhdffBFpmuLpp59Gu93GbDZDo9FAp9NBr9fD+fm5uNa73S46nY48NXFyciJPLvD6onf94OAAgHsqYDwey7W0XC7RarUwmUwkGc6GrdQDsUmr1rrUnJRPG1BnE7rRwwarvH6YsOf3VLksl0u5Njj/3Cef8gBcensymcjTA7yG+LM0TbG3tyef4/Ub3gPtdlue3ggbxQKQxqFhSv1Rq2QOZO1AWZD7lGzsg5U5ACjXqO4BSe+SiUFS44EqJaaCw/mQ2aAOEQAN10wPkHSr9o0xlXEpXpUpmDqQMyHLFHIcAevMKU3yvPBz08XNpHPY2FLFPmmsihQ4Xd47ChTrn1ZA4v/pUxrI/RNDbJxpLL78+lvw7lu/iNTm+Klbz+J3X/9NpXi7hkaKHKnNRHeSeJ2I84NTj+J840qpYsxMRAf13tsfxJdfe3MpaZ4/SHpschnHe249V3opUloS4xZR4AWH85ZHERQd5DzPSgER9xPhK554B6Bztx0dufPund02z/Eu38RT0u3WuBS6tYB1qfXcGhhYaCg3putvwVdef1uxz3od+ukY0dYirysYrRCl1vnfecF6FYbeMlnsTzd1HimQN/z2DJA3XbI5WsM3uLSSIubTBiZx22mcKajMwsZA6htbRlsESg8fgs9900blvOByUzBV79VBNrLl+0UBiCwMfONO+Gs/AkIl+6WUM8fKy4NJb/9H/PsoHoqwwWc5FzCqSDRQR4Rge1GgO5FUO8rKE5ST5XSDmwiFUx0AYu+GAYqmnSh+3+jUp9Fz38wyLtQyCnC/e16x3EdVVVVVVVVVVfXZUF/3zidw0KnhT//Yh/De/3gfX//9z+L7vuHt6DeTV3poVVVVVbk+Dge2vwzABwFAKVUD8MUAvsO/5zkAqX/Pj/v3XAXwBgB/4TM8XqmHBt/05kZRhPv37+PJJ59ErVbDyckJAAc1N5uN6BNarZY0ywNQAmp0YlNLwEZ0hGx7e3tI0xSr1QppmmI6nYo2hACwXq9Lg0iC181mI25jQjaOezweY29vDwDQ6/UE/mZZhtlshr29PVFoDAYDnJycoF6vI0kS8W6zgeZyuRSdAt3J7XYb/X4fQAGZCeXY1A+AQMbQzbxarbBYLBBFEVqtFrrdLgaDAZrNJpbLpYBXNtpkc0g2rpxMJuh0OphMJnK+CHRD0E3oSTC6Xq/FuX5+fo5+vy8AfjabiV6Guhm6r+nSzvMcBwcHuLi4AFBA0GazKceyWq1Qr9dFSzKfz0XrwflfrVYYj8fyPi6A0A292WxEGzIejzGbzTCfz0VxQ0hNvUi9XpdzxkUOKmLq9bospERRJI5vNkWltzrUeMRxLOOI4xjT6VTmOcsyudapDKH6Y7vd4tatW9LYkmD2/v374toOdT6cFy6ysPFjrVZDv9/HdDoV4Nxut3F+fl5yXxPkE3ZzkYTwmD+jTojbpgKHx8jzCDjtz3q9lnNcr9cxHA5LPv1Op1Nqgsrrml7z+XyOTqcjPn+66ekSDxeL2ER1s9nI9c1ri5AccIsO2+1WFtf4PjbZDI/7UaxkbmEjBdtykNlG1gG9rYdW1ESkyqkUCLJDdS+9wuFTSYRk/JGyUHmgOxCXsIeFNJRowkSI/sTEFvFSYfx0HVeeL3o82DQtgLcKHkradWUrVWoSqbSGzfw5DwF5DqcdMbbwe/tFTmxTWL+oY+nNtgY/+dIvYGOB1Bok0Hj37QIyZzAwMN7z7Y450ZGDu9pTS2tgM68CsQp2x8VtQ4hvLXJrisaRgIDjEISXGn0CeNeNt+G9tz8oShRjc7z79nMCnL/i8beX3g9jPdh8QNNNrXyjT8NDAkzu5srPsVLag24Hxt9z+zlpiMmiCiW1ORIVwdhcxkjVyVc88Q5R24i7OgJUXiyCaA+ibeShcV5oSEKPd7QFslbxHmhAZxY6dX83UQFpCXT1tpjHZAasji2SpULWLK5N0XSwIaz2bnUUizxWF9sRgGyU0wFZnq9CsyLebxQqFTcwFHOuSj8qAW8euIUqbgMFWbgSR/fLaUP4c8L8cDAqeE/xpfD/o5h7eU1uvUBXIw1oAWuV+1nmoHfeCHzqyt/OGrIYUNLdVFVVVVVVVVVVj1R9xRuu4oe/uYZv+aFfxLMvXOBrvucX8I++4e14bK/1Sg+tqqoeqVJKdQC8JvjRU0qpNwO4sNZ+Qin1twF8p1LqeQDPA/hOAEsA/xQArLUTpdT3A/gupdQ5gAsAfxPALwP4V5+xA9mphwbfH//4x7G/vy9g8f79+9Kkbjqdivuafu88zzGZTARoEV42m01JghJO0elsrRUwSWBJyMztHx0dCdieTqeYTqdoNpsC8wjjCAgJ1phEJ/Rl8ptJbbqM+V4Cdh7jdrtFu90WmE1gSZBHSM6mfADkfaHDPDw2HqvWWhoREiQyLR2m0gmiAWAwGIhPervd4t69e6WGlOv1Gr1eT5KwPCYAAtkJ8c/PzxHHMRaLBQaDAbbbLfr9vriqCRuZUF6v15LoDxuJsllomJ6n85w/C8E0QXEIpQEIuGTTzk6nI1C22+1iPB6Ls5zFlDkbJXIemM7e29uTZpDj8VhS4HS5M9EOuDQ1U+ZJkohvWymFyWRS8q8Ph0N5HxtSEpATyK7Xa1nMACCLQVmWodfr4eTkBHme4wu+4Askdc0moATtXDzhNkJozjkMF5V47HTLc6GE116apnLfhM75sHEsn7JoNBricVdKyaIIz/d4PJZFqDiO5fh5T9D3nSQJut0url69Kun00IcfLo4xRc77mOeWiXsuXIQLX/y9Qkd7FD26JCVaA1EdsMpB6bymCk8yQVMAvOHTrSVeFkAsKFU0DLSXRcNWWyjjzMQ2IuS2Au6UUVCR9ynHzvGtU7edw/ePYH1jXtXtQsUxbF5AaNdZ0++L5zTP/c9zsBmkAHNJVociZO26JsL9m6CyzEdmHciV4zAW77n1HKbGIIdFai0SpWFgoOG+rm2GCAoGQBLMmDR83Jk7SYCHKe/gmN5750PY2Fy2X3yNBBgzEV76POAB9AdgYAWAR0rB+OR6eZ8WClHR/JKJeD/HFnmRTPePmFrvJldaufcYKw0wjWvFWRoXQb2bH78AbA1ya+X7n37h3+KrXv8lgL0CEyvotKCpOgOMtYhyd80K0FYOaFvlLlKduutNGZcy1oFPG9aBVmWA2txi0/Pwue6aK+Z1BeMDRJt9IFor5HWU4a+HwzyH9HFbjRIAlyaUwe75MRsF0Jr+bnrwtb82uD+UoX6pmWYIqIPtI/jsAy17wbHIZjnVQXL90rYCeG4RLE7sboMfozu8NAnuHs8bPmlvFExsy0lzoNz8s0p+V1VVVVVVVdUjXe98eh8//q1fiG/4gWfxkfszfOnf/Dl89Vuu41u/5CZuHnZe6eFVVdWjUm8H8K+D7/+W//pDAL4RwN8A0ATwDwEMAfw7AL/TWhs6xP8MgAwu8d0E8LMAvtFa+4olEx8afJ+dneHWrVsCsOr1Ou7cuYP5fI52u10CvFRehM3rqCQhFObP2OySTfpOT08FyK1WKwFy1loB0QcHB1gulwKIZ7MZZrMZms2mgDMmrAkZqRHp9XqSPO31epKijuNYoD0BIqEoGwIyJUvQSLBGsMikMJPI1Hww+RomvXcTrYPBQLQs7XYbx8fHon0hkCWk1FpjPB6j2+1ivV4LAKS2xBiDXq8nqWeeC+6PqVhqTAgw2YAxhJxcIJhOpzJuglOeS+pUOH9h6rnZbKLVapUafVprJSVNwMv3M51N2M8mlnyKYL1eYzAYlMbJNDqfOuCxMPVOiJ8kCRaLhVyn1H/wHHBuFouFaGp4TIS5IRhm80vqaNigkaqPbrcr2pmzszNEUVRSz/T7fYxGI1lk4UJRq9WSNPNoNJKU/sHBAeYeEPLJCKb/p9MpDg8PAbgFl/Pzc7TbbdGSsNGnUgqr1QrdblcWY7iAwrES3mutZbGC9zEbp7JZKBUuYSPJdruNJEnkPHY6HVmo4fWYJAlarRZOTk5kUYbH2Ww20ev1MJ1O5f5nspvXP9PxoT6l1+vh9PRUtEp8yuBRrGTpoJMyqkiXpihAtPVgziqYyAHqINft/u4VBohsGboRDBolIEtguG+eJ035/Osmco0GlddqRFsl0Gtz3EH9V1O/fQubZQ7GUleyU66JJWmhj44aW3SsCJP+YdJaaZdg1kreY1ZrWJ8+VlpBJTEipZE7WQiMgiS760o7gGstNjBIoJAoDfc/5QCwMgH0VgLlXUdBKw0s33v7uSAdbZFbF5XnV8Clvlm5NUXDyWtvlu2FFfkFytxaaAW856X3lxLZX379LbA5imaXRgv0Z99Jay2Q53jP7Q8gUhqpzfGVN94Om9lirgFk4uyISk05qWvR0EhUhKXZyrgI5tfIYPMc9XGO+WPaKXKYnjb+EoqAaOueWgDgAbe7PjSVOcoi2jiYbWIHzXVqYRIFvXWQNa8pxCs/Zq2QN9yFbnySPLLwDTDdYpGpFYAbKOB12JxVBZcXU9+yruFfN3GQHvevh5eGJLV9ulxS37uJbVv8nMRY7l++bbdTiyrfx6VGlTZIcBuXWueilcDr8B7n7w5tZdErZOa7x1eC51TFREBeK+LuYXJcKRRql0d3nbKqqqqqqqqqqvL1+qs9/OS3fRG+4yd/Ce/7tXP8s+du4Sc+cAvvesNVfNuX3MQbrvdf6SFWVdWruqy1P4edPNzO6xbAX/F/Xu49awB/yv/5rKiHBt9UHVy7dk3SyHmeY7lcYjweYzAYSDqT6VdqLAAIiGIit91uY7FYlBKf2+1WtBJ0HDOZTO80lSitVktgbKPRwMXFBTqdjqRTuV+6oZmkzbIM3W5X0qHUcoRgkEnj+/fv4+DgQJK+AAQCMqlNXzJQdoPzmAn56KvebreiMWFyFXCQudPp4PHHH8fVq1eRJIkkdJngPTw8FMgberC5LSazt9stsizDeDzG/v6+gE+CZapVOPeE/q1WS8AxE7tM1hKgEooSii+XS0lVE/guFgtJAPO8MyHMcdBNTT/7arVCr9fDarWSfVJVwtTwZrPBbDbDjRs3REsDFKnt+XyO+XyOfr8vnvnQVc5jJjjlOWFimFCVQJhpYnrsuSgS+uO5CERFDRPlBLmAS1GPRiP0ej25zlqtFg4ODjAcDnF2dobJZILxeIzhcAilFBaLhfjQO52OLHYQ9vNa6vf7pUUUQmTCeC4a8FpN01SgN4+NC09A8fQGdSdMUBNA85h4jXEhiQshURSh2WzKNcv9xnGMXq8n2+AiUa/Xw2g0kkR3q9USBYq1tqRyoS5lPp/LOeK1CUAc6Hfu3BHI/qhWsjTImhFy4zzKkU9aWx98NjHKkCrzkDrYhhYAGFDxMGEqegdIglV0DgG8M4Tj1CHQuVy3iFYK45sJvu97fw4A8Jfe8V+59LZ3cqsQiOU5EO/8k0WSaE2hTMi5A+ezLvm1mRi3Bna9cXoTvw3nxS42ncMB6ZaOoD1dNDDQSkH7JHhdJaIWCbUkDm4X3u7cGgfUrcG7bz+H1EIS0Lm1Aodl3wEAT8mEbS76k9T/3Y3JaVG0n6i6v0dTm8MEi+r0clsjKwSSCLc5oOgoN1bGChQu8Xddfyvec/sDSK31+3ee80QV8JtzQKf3T91+vxsLchgugiuFf/HRn8Pv/NYvQF4DohgA1Sb+GmXK2/kw4LQ5AFTugLbOHKguPODuOs8a7smGaAPUxxarPY3mhV9IqAFWKdjYfU4ZQKXua9Yskshuf8WigkBrjguQtDeiIv5MPzdyBY0i3RyWQHOmu61869+wk6b2gFxpeOVQ8Tm5YnZANYDy/1MNQTq3r6zbnr9nCdaVUZeMQtS8EGw7j7hLcgsQN8opj5i851xxrLz3i7WTAngrwCa2WFyoqqqqqqqqqqoe6Xpsr4V/+i3vxAc+McI//Ne/hn/14fv46V++i5/+5bv44tce4k9+6Wvwjqf2XulhVlVVVZ9D9dDg++7du5LEfuqpp5CmqTQE3G63ODs7g7UW169fx97eHiaTSanpI5v3EaQRlM1mMwHOTIQT4IVNCY0xOD09xf7+PlarlSSdAZe8DZtjAkXSmw0yT05OcHh4iG63i9lshn6/j0ajgX6/LwCVcHa5XCLLMvT7fUnjjsdjAamTyUSAImFfnucChAmzCUXzPBeYxwUDgtkQDrJhJNUbbPY3HA4RxzHu378vWhTqQZhaDpUPq9VKFgVWqxUODw8FuALA+fm5JNqZTGZaudfrSeqWkDjPcwwGA0wmE/T7fZl/wm8mv3keQ+UGtR0EqUz2E2pz7sPGkUxeX1xcSHNJJoiPj49xfn6Oo6MjvPTSSwDcAkOj0RAoz/Oxt7dXUslQDcI0M9PpPF/h0wlh41SOhwsEnGdec1wooPuczVR5TtM0FSc1IX+n08Fms8HBwYGAYsL/W7du4fDwUJqcttttvPjiizKPAHD16lXcv39fXPd84oApdTZv5Xlnsh8oGlTyvHGRipofLqrw3LL5J6/p2Wwm54QLOfw8tUVc0KBOiAsHvV5PGlhybBwfx8zmrRwXx8gnLRqNhlxHSZJIA01ed3yCg+fpUSyVWcRrr4aA93B74Jc3fCq15gFfQNoKsOfSoJIYDdKsTMMKMEOQ9gyTqrp4TeVF8hsJoDKFeOE0LOsDha5216IZT6B7HQe5Q1WN93NLstvkrvki38cEuG8kyXsZxuemc0AlsfNc+99TNsvwnlvP4V3X31ocv99nQ0XIYUvqEQMml41n/eXrizDawIqvW9QfPj0NFMA7rDxIbxMqUw+SqBCOO1qY2lzGFikHvaNAfwIA7779XGn8wGVlSpgit/74lXbpdX6ex/ru288hg9u3S8GbS8dC+M3t5jaCgUVDxZhZ9wTGwhjcMRY/8Pf/Ft71T/481Fi566oWRIkVYCIFnVsYraRhpdUKigsVHizrzD1NoHMLlRVNL1d7GtHGYtv2CwSJKhLcBOuAuMJNjMIl7q9/afiIcoLbfdDK+2E8OA9gNlU+brDFzwU2M2EdLip5IF9qOqmE/5drZxHqQQC85OwPPsLxywv+FVGQcL9siBn+jvBPkSgTesLduKmccc52NwdMwJvE3bt8EsQqD/QvDayqqqqqqqqqqqoKeOvjQ/yjb3g7PnJvhu/+uV/FT/37O/j5j57i5z96irc/McSf/NLX4Etedyjhv6qqqqqql6uHBt/T6bTkWSZ0GgwG4qdmans+n6NWq0naGICkrQlS6eNmspvJYepMxuOxuH4BiHJkvV6Xkrj9fl/SysfHxzg7O0Oe5wLcAQfBj4+PMZ/PMRwO5eeEZlEUQWstKfKwkV7YYJCNAwkNG43GJYAIoOQ1ZxNINh7s9/tyXDwmqlLYVHI2m0lDQzbmbDabAsU5H2Hytd1uC5xk+rfRaIi/md5sNoykBmOxWMi2CScJErkIEcexaD0AiEKC+hTOKZPKPOdUvTCZznkmaGY6njCTifPQaw44kL+/vy+QutPpiAYGgFw7TKhzfNRwcD98P887vxKS8RrmfIUNQTnn4TzwGuE+CHRD0MvzyqQ7oT+1K6Efnv576lI4908++STiOMadO3fkWjs9PRUtCa85OrZ5/YZPAXS7XYxGo9JTAby2eT9yLnhfTiYT0QJxjjqdTul6DR3tfCqCaX3ODc8RvfZ0pDOpz8aknAettSwwhItfvPYPDg7k3E0mE0ynU6Rpin6/X2pYy0WwR7FspKByi3gNZFCINhYmAdK2g3EOegcf8CnaUGmicg+Qg4Z/KlNQyhYaE6AAdnnwVXwMKhhTWXeQdovGmFciN5h/+eKz+F1PvxM2N64JY62G3SaX1ngNivGULYDe8nWbOeidG9fYUmunNLHW6T18cpyQGnDNItm48cdv/QKMtaj7/dZV4qfJIoJBopi2Llzc3J6GEhWIsVaaOoYVgu6y11uX0uU5rItjA4j8fiKlvMebp047LQoT2v544D3kBk6hkvoxsVGnhkJuIWl1aYaptFtU2ClC7tQapJ5UJoCMiXoUd3xG/q6hkKgEqV9VSW2GmjL4l4vXw8ZAtLZFWtq4dDdVIXldCVS1kXKAmYsvtlhU0ZlLIEepRd5QqI8Nth2NvAHRpZjQca9Kl2axLa8jcYDcEWfeF44Tu2ua6WQb+cXS3G1Mp9Y1bt3xcbPxZAlOh09c+K+APzYmo0M9Scip/f7DW0wULcECFPcrWn4UqfbL0fJiPPIjZcvv1RZIlTtVPqHP/cgiADdjXAJcM/kN32dAWXd+bXGspUWzqqqqqqqqqqqqqqBed9zF3/7at+DPfNlr8b3/34/hJ37xFn7xxRG+6Qffj9df7eHbv+Qm3vXGq4geoEisqqqqqgI+DfBNKDUajXB6eipgrt1uo1ar4ezsTJQH5+fnJSUJ4BzWBGVsgJimKebzuTQ5ZLp2s9kIYKaCgelpAKLTIBhut9s4ODhArVbD/fv3RY/C94ZNDwl9mQ5NkkTS1dQ0AEUDSELvTqeD+XwuDToJFukaZsqV0BhwDRUJFemIprO50WhIyhpw0JXah5OTE9y9exdJkuC1r30tbt68KXMQAkrCWwAlAM30a7/fl88x4c0x3rlzB3t77hGhi4sL8SpT2zGbzWQeqZOh8oKAdzabie4GQMljTnULk7xcFAiBMOCAKJP2bGCaJIkk9qnlCJs18hqhYoZaGzaopM7j4OAAgEuEM8XPxD2vNW6bKhQuEHARh053LlDQGQ5AQOtkMhFfPOAgLb33TI3HcYx79+7hypUraDab2N/fBwBZXBgMBlBKYblcyrxfu3YNy+USy+VSFDCE8ExPD4dDrFYrTCYTGGNkPsP3ZlmG0WgkCzL9fh8XFxcYDAYCqKnMoaaF7u/wOg+vLZ5D/l7gfZUkCebzucBxKl2iKEKn0xHwHja2JaDu9/vodrs4OTkReE5wTu0JHflUzozHYxnnnTt3JA1O3dKjWjo1qKWAqbHzHACroBMIdELuATmsg33KQypAwJ7KfUrWv8E15mNkFYXTGx50hclWq1zCM9AsiOrBuG1HG6el+MO/5b8GAPzU//EvBFa7fVogt1CxdoBbGSCjH4IecNegUiEqUuI+9W2ztKBxUSRqE6UUEEX4yutvEx0HvN8aSiFBhCVS5NaioWMkqmg0mSJHBOW/xtjYTFQlAqGDYiNId9imBL1ZYXKa2yLYpmOc3vEITr1SV7q0jQy5bDtSCrF/H6H8xqaSEPdXicxjtLMtWAMN5Zt7FjQztTlSr4ABgBQGWlkHev1lESktCfdERSUFCmtmEvzW1vP4+yuXrDaJv05i//shKqCoMgG09soRG/mFmtwnjXOXBrdKIVk4t3fWcos/hpeET2VTzaPgtmUid93zHgD8pZuhUKwwhQ1VpLuDtDPfD+OfsFDF2OXzXvVxKfAfAHDhv/xZsC+5jXZS5NwXTAC2d8C4LCyw/L0qfm8eB0F0+McWxyHHVHpNyTYuPQ2i4OA3f2zcRlwK3DqNUTCPVVVVVVVVVVVVVS9XT+y38de/+o34b3/7M/j+f/Nx/D//7Yv48N0p/tSPfhB/62c+im/94qfx1W+5gVr86D71W1VVVT24Hhp8Eyoy4UlNhrUWe3t74gWezWaSyO71eqWGiwRRbDZIIEpIxkaOhK5UVjA1TW8voei1a9dgrcVsNkO32xW3dJZlpWZ71D8Q/lLPQBjOR98JOwlXoyjCfD5Ho9EQDUSr1ZLXCE7ZiJDQksdJBQnHpJTCeDyWhoHUQQDAlStXcHZ2hrt37wpIjaIIJycn4i6nDiR0badpina7LS5xwIHu8/PzEqSma3s+n2O73WK1WuHOnTuiUWHKnA0L8zwX2E+vMmE9neGEo6FLmcl5wn+CUC52NJtNmY/RaITZbCbOcupvCC553fG6un79OkajEe7cuSONLrlPgtheryf6DM61tVbS8dPpFABKmhmeA26PCXUmkQmw6doeDAYAivRzlmUCXwmv9/b2BNSGzurpdIpOp4P79+8LuKYuaL1ey7Xe7/dlUYEO7KtXr5ac+FEUYTqdCqwnxGf6m4tOvK+YwOe55jmi8uf8/FwWl/hEBRc7uK3lcolGoyH3Ext31ut1dLtdmSsez97enuhnbt26JVoi/k5ot9ty/nitshFmq9USWM+eAFTG8L1cDNnb28NHPvIRuQ7G4/EjnfiONsZBv8x6RQRgagpRqrExClAKecPDpxDE7aRO4fUkDtrZUmM/ZVB4tZWDaE4j4RKxNnb0y2qLaOMaRTKRamtWUqBZA5i87SoA4Kve9GVQkfvdrZRynm5A0sywyhFhD72ttVBwTSmZ6FaRhjS8VL4RpjXlppeA+z7wdwNwjTU9GG6pBAYGMSLRg7z3zoeQ2MjBY5uX/NzczsamAqnrSpegN4vp7vBzgAPWIRiPoJCoqPT+3FrEkjgv3lvAaBe91aqA4MVJLd6XI3eObkSo+/8rYPPc6V6UxrtuvE383sbD7hwWGsAaQG7dKxEUEiiXVVcWxuYC2ekkX5qtjL+lIxwgxbvnr8P6OEO8ihGtINcb1Rc6d1Da+uuG8NhG7gkGgl+duycZ4pVLfed1wGrtlSVB6ppPJBgrvmz4dSG5rhV2dCbF1CnjwXSYsjZB+ltgt4LO3Juo/nBz6+838H1BQpulC/gtjmz/85Jj2yfQmcq2JRBdjFtc4PxsDuS1Yt/KKLn/dQ7kdX8PZy6trXwD23CMnAu9VVCZcqn3XWitvNpEOd2J3gCoFal1txYTKIlkAquqqqqqqqqqqqo+eV3pNfCd73o9vv1LbuIH3/cCfvB9L+DjZwt8x0/+Mv7nn3ke3/LbnsYfesdjaNUeGnVVVVVVr/J66N8Gm81GIOL5+bmkrQnr9vb2sF6vsVgsBFyyKSHgAGao6aATGHAaFYJbKlXm87k0lmQanIqV+XyOwWCA559/HtevXwcAaVz4ute9Di+++KKA7+l0im63K5CXqVICOiZ9lVLSVJPNLqkLYdqVaeHQl03YGUWROJGZtKV+A4BoPgiwQxdyp9PBCy+8IOCXx8MmouPxGEdHR9hsNuILbzQaAgE7nY5oWoBikeHk5AS1Wk3UIVR+MOlOqEoQSahtrRXYzzGEOhGCzV6vJzoMFhPETOrTlU2FBQHxYrHAarXClStXcHFxIXPPJojb7RaLxUIaGj711FOifeF5YNKb8DdUq1DzQQDL+Q69z2F6nPoVAt3/f3t/Hi5ddt/1od+1du2aq06d6Z3VmtzCFrIt1LbiEU8YG2FwCMRkcpiCwU4AX+cBgiFcuOQBkhvA5NpmCkMYroE8AWOEcoVDPCEbWW5ZRh6lVqu73/mMVafm2nuvdf9Y6/vbq0532y3JUkvv+/s+z9GpU7WHtdfeu/T29/fdnx8TwzReacTTpAUgiWYWb2jw8jxevXp1q1kj0+y8B3gMrVYLx8fH6Pf7cuw8X1yW55Dnar1eYzKZYDabCVJkuVxuNV7lurw+UrQI09dskklskbUW9+/fl3s9TXfz+JkwB2oDnslsFgrYbHY2m+HatWtSyFqtVlIs2d3dFfzQer3G3t4eHjx4IE90cH55jtnEc7PZCKu/3++j3+/j+PgYt27dkvN5cHCA+/fvv7Ivt0dQKQvZlA7GGnhrYItgQteYE4Oq5WOa1khTP0mBmiR9i2j6xbSt0EyyYIIFs9wHIy6rTTlbGNl+3bSQAw1/Lg+iKfrkLTR+4Tm45QqoqmDaCdvbBLM6RqF9NLK9czXru6rC30A0wF0wvk14bRo54B3cpgh/Z9lWovnd9z6Ar7v1FH7bE18czPKXSGd3bfi+ayDwq2lKE/kBBMO6ghcDGKgN6GCav7TZbaPDGbZXm+UcI432ElVMdBsZg2wPNMXr97bM9DiOyns47+FMSKT7shTEibEGQIZ33HoK8B7vvPt0xKsYFMlcLDxgvUfbeFhTAT6MlcdcxqaW6VgWrkIG4F3HnwsYoIpPIWSrwNqWVDeN5KQhJBtbukYwv40PTO+qFa7tsh1MZ5reLjdbiWrjwjrylqu3DZ+kshFrLJmvsT8RGSLNVpkeDyeuVlx+i+sdr/OUHU6lLO/U/E+fnpD75iW8YeNM7XOLUe9l22LWe0TD3NeHHGpg22z/9AmNWAci2ojjSbnnXGerYHDJfM8XHlVl4HIIqqYEAFPvz+t/m6pUKpVKpfoYNOo28e2/4U34/V/+BnzfT76Av/mjz+LBxQp/7p0/j+/+vz+M3/Olr8fv+uLXYaebv9pDValUr7Je8X9qMA0LBPPr4uJCUr/j8Rg3btwAAGkwaYzBcrkUdAgb76WNHGnkMg1L9nWe54JJoeHKxoE0Z2meEW1BFAqNV46HZnyv18N0OsXJyYmYZUDAkdCoLctS9gGEppmtVkuaTS6XS6zXa9kHx83j4m+a3TTNmSwnAoSNDNkE9PT0VBjPnA+a/A8ePBBDknPI4+U83L59W1LHALZMSiJKyI9matl7L2MmRoJcb6ahiZpggpgJdfLBmTLmfi8uLnD16lVposjU9P7+Pu7fv4+DgwNhSHe7XWl8aa3F7u6uJNFpjvKaoKnPJDZT+mnjQxYcmP4np5tNDvlDXjULAADkuIjxYBqaxYpGoyFPNwA1WoWpfLLAWRThXGdZhitXruDg4ECMbB7ncDjEzs4ONpsN7t+/j9VqheFwKGgQmvycTzKyaWjTyKYJTwzPy2FOeE55T/CHHPhWq4Xd3V2sVivs7OxgMpmIqU9UCwCcn5/L98ByuRQkUb/fl+uMczYYDAR7Yq3FYDCQe7rdbktSfXd3F8fHx4KWYYGmKAop5mw2GzHIDw8PBfXC1DvvLZriacHqcZSJbG5busAqltirFS4xm/3RoUoNbppzRtgLEA4xTUmfA3RBq1ZMF2+MrM9d+gyoaIrFobiGR7YxcE3AFpE9DqDqNJC32/hXP/dD+M2v+yL4soSxNvyO12DgjjNmG1kPlxuZ8nNjAR8G+a47T+Mdt54KieaYICfTOywbxvDuO09vNYBMRWyJhUFmLEpfRKRHvYwks8n5hkNuMjGt2bQyTXBnxqDwFdY+vM91uR6XqTElddo7xadcNru5v9Rcv7xs4R1y4/Cuu+/HO17zhQEPE9EnbPYZxmFgDRnkBVbwWMR49soDmSdro0atrH2JAiEBT7WNxYMK+KLdj+KDrZsohhkay5rzYQsAEUHCwgpNaaaZTSx+CMYkMr6leWI0cwX9AUgaOpjKsfErb4vEbHYm+TsiQbgeTJ0W3+J305xP0T7Yqm/EtDodcG4/ubhopNttMzwtBDDtnSrcq6a+36wX5ng4PV5S9AFtUhvegitKnsYw8Ti2WOFlnMvYIHersWa9WJ2ET1PiBhFt5IHMwG48XNPI+oJueXzJVCqVSqVSqT4B9VoN/Fdf/gZ88xe/Fv/s/Xfx13/kI3j+dIG//IMfwt/4kY/gv/ji1+L3fdnrcWXQfrWHqlKpXiV9TBkbGpxkCafmFY0pmoRkCtNcpBlGnMZsNpN0aKvVEoOy3W4LV5s4ECAkbs/OzsSUpqm+v78veIiUrc3Ed7vdxgc+8AF8+Zd/uYx7tVrh5OREDFCmUtvttjTKo+lLnAmNQprFPC4AkvBlWpfsaQCCGEnniub4+fm5mH1lWUqamQgN4jrI6F6v1xgOh5LoTpO+9+/fl7liQrvVaqHX6wmL2XuPTqcjx8N5p0lLQ3k2m2FnZwdlWcpn/JsNKGlap12UyVC/uLgQJAyZ751OR9LGrVYLFxcXYizv7+9jvV5jvV4LDubi4kLMWybqb9++jYcPHwoOhqljmuBpQ0omvnmd8voiOofngg05iaKh8crlWeRIG5am9wGT3DTSq6qSBpvE0fCeGI1Gkrom/53zeHZ2hhs3bojRT5P64cOH6HQ6ct44jgcPHsiYiTHhvZMWW2ha87rj/larlTz5sFwupSBCPM9yucRoNJIiDcfD5DnPvTFGUv8sDHW7Xezu7qLf72M6neL09FTwMJ1OB9PpVL4LZrMZzs/Pt9A2AISNz7+JTjo+Pkaj0ZAnHsbjMRaLBYwxGA6HMifXrl3DgwcPPpavt0dKxnlJoZoqvLZF4rJ5G4xCGDHCXFP8Tklv+vg/cpcn6UwPhP8HoclYmq2ErCAgiDdpRAOOfOEMkpitQq0Qx7+uhcH+67D0m8jn9kCWvdj0rqoXm938LEuip7Ex5rvvPB3QHMaGpLixIQXvkoPzLhjeNsOLXLjY6PAdN9+Gd9/7ANa+gBNkiIdNTGU2pXS+3raN74fTsj3uy+/TkE6T4mx+yff5+jI+JX2d8r23O5nWsmbbRIWr4rGycJCH4sDNXwf40Ai0ZQLXvGmAwnus4radc6hMhYE1aKGJd9x8G37g7vtQ0GiPv8fOYT8z+MDFLZjMwzU9Ko9gRCNcF2JoewQMSjwEQXRcSkAbFzA81gesT7aJ+7RmC88TDGQDW3nAkgsOMaKJTuG+kgkNNZS0aWtEh5jt2+rFTRu5X+trgzmawXWi2wQ0EPdF07uqE+KCbTFMbNfnLjXu4dIUtd9CGRkPoDRAw4dLPFKBvEGNfLl0SZiqTrB77+Ga9fiJX2HBQbDxcR4FBWMAu4E8LWIrj6ppIGgZ/+L9qlQqlUqlUn0sajUy/KdvfwL/8VO38K8+eB9/7Yc/gl98MMXf+JFn8Xff8xy+6Qtu4Q/8+jfiNXvdV3uoKpXqU6xXbHzTaGWamWgHmoQf/vCHcf36dbzxjW9Ev99HURRYLBaS2Fyv19jZ2ZFELVOx0+kUh4eHgqPY2dlBo9EQPvNsNpMGlK1WC+PxGGdnZ7h27dpW48h+vy8p306ng5OTEwAQFMp73/tefM3XfA3W6zWOj48lsUyD+OzsDAAwmUyED0yzOcsyTKdTSV2nSVuajOSHpzgNzg2NPjYybDQaWCwWMqdMmzcaDfT7fdk2t+Wcw/HxMW7evCnp7KqqZDs064mFuHLliqSJuZ+U18xtO+cEKZFiL2iMM/HLeeh2u7LPdHw0gpvNJqbTqRjoNPiJIZnP5zJ+Ngmlwc/kPhPCxFosFgsxNy8uLvDgwQOcnp5iPB5L8WG9XgvWpd1ub6XBafxyTjmfKeaEyXWmtgGI8Z3nuRjfaWNWADIvXA6APLFANjnPebvdlqQ80+SDwQB37twRbjjTyzSqd3Z2xMydTCbyBAD3Q348iyssXjD9PBqNcHFxIU9gpEY9Dfj06YK0SPCGN7xBDHLnnBzffD6HtVYKKovFAjs7OzJ2APIdsdlssLe3J8x4crp57Cx0LBYLKbDwZzwe4+joSAxzFtOGwyFOT0+xv78vSBseF/ny7XZ7q5nnYykHwPtggBsTzTQHu66QLS18lqNahkht5YIBVVW1+QgkKdIqIB/E3KJJiEuJViIcfOD72iKa4Y2AO4E30QyDbMCk5hmAog8c/zqL3/nFvwPAXbzz7tP4La/74pD45vkkqiF+fwYUSuo+1k/ieOcjtiPo3XeejiauC5zhaIADgC85V+Q+1PHVd90ODTAzY1H5Oq1d+NDokkZzQJJkWPgNrDGCPAG2De+Qsq6HTDM75X4Tb5Ia2unnfD/FmHBf2cu4iFuJ8Mghrw33YGxnxkrinTgZeB8bVAYz3cZCQFjPoPAWBSxyU6LwDn1rY4EgHGvaW/H1eR/3yxl+5u5NGONhyoDbsZuIJolFGGneWEKaqIrvHBus1kidkPj2WbjW4YKpbUof3kNYxscOkqFBZngdmljGRXyslYQDk+Q13ydP29RTHlLiEZFCA5mokTSdbZwB8+IpysQwYu5QN6pMjW6fBKzjooIXiU9WcH8etdEcTzLI2Zf9oDa4Ux9f+ODuUrLbR1RRCTgT59Sm925yXDzJcdthXAZVM6JpSh9RNXHeszpN/zK1GZVKpVKpVKqPSY3M4hvfehO/9fNv4P/+xSN8zw89g/e/MMY//Hcv4Pt+8ja+8fNv4Fu/8o148urgV96YSqV6JPSKje/UOCSCgg0nae5mWYbRaARjDAaDAbIsk1Qu1yVSg5xr4iOILmDimCgP4lSYACeihOllmmcXFxeSnr64uBDuNDEnTzzxBN773vfirW99K6y1OD8/x2AwEOTE0dERut0uJpMJTk5OsFwuJUFMzAkTzORj0yBmE0SmTVOONE1iNtWk4QxAzMjZbCZJ7vPzcxwcHEhCm8YtGeQ0UdfrNS4uLnB+fo5er7dl8tGsZ1PP1WqF09NTmRPvPaqqwvn5OebzuSSMiRRhgn65XGI4HEoC/cGDB+j1eqiqCt1uV9LAbGBKc99ai/F4jMFgIOeCbHPiKLrdrpjdZVlisVgIYoRGaGpoLpdLnJ+fYzwei9FOk/r8/BxVVWE4HIphz6Q18SA0k5kgds7JfHI7KToFCEY+iwxpInk2mwGAHBMT19wGTXOePyCYwTs7Ozg/P8eNGzfQbDZxfn4uhQEmwFutljyZwLliE1OazLxfeD0tl0tB0nC/vN9o+nN8nG8m1Jm8rqpK8CJMa5O9z2sRgCCDer0ejo6OcHh4KEggmo0XFxfY29uT80kT/969ewCA1772tYKL6Xa7gm3h0xhEG5VliWeeeQYA8OSTT0qzVqb9uc/9/X1peEsjPeXOP66iQSgmnQfspkTVbSJbeTRyB59ZmCoaWaURd9JlJklCA8iTRGqaaOXfCbaBr70FfGxwx+aYgJGktzTv8xFvgWBeGg/c/W1P4OY/LYJR6x3gbG3CJvKVC4Ybje74W+Ygmto0ct919/0huusq4VnXC5sYeU/Y3t7j3XefBg1fSUIj4D/YyDKOHi4xkgFsIT5S0zk3duszRNOby2SmNtMvm+Ky7Zfgj182vLlumhYvkjS7fO6BPCa4c2R4592nYWHwjptvw7vuvh8OHuvk2J33WHmPAgZV/LGoE/BhfA6Fr7Did0d8nOA3fdaX4P7veyuKL1ghb5coG4E7DwCuGYxqn/n6emrUbHiX14lsXktijEcD2rrA/A586zr9bKtouG5kymErD5cFY5cGOJtYXjbEA/Pa1CiQKCadt5LjLyFTAcabcAnRsE4YIQY1kkQMccS0dbK/reaaib8uxnZ6/XMbpUkWRFjG1mlw32BavB4rANi4niTCXRxPPMfG1YUEPtUR5taEBwdM5LfHuUm55VtcdUAT3yqVSqVSqX5VZYzB13zOVXz1Z1/Bez96hu/5oWfwYx8+wT/76bv4Zz99F7/xzVfxbV/1WXjra0av9lBVKtUnWa/Y+PbeS5KUSANiKtLGgPfu3cNqtcLh4SGqqpLEJhC+fIi0yLJMWM9Me9JYZoKWidpOp4PZbCZJU2IWiOSgKcyEMk1toDbsr1y5gmazife85z0Yj8c4PDxEo9HAzs4Oms0mDg4OsNlsxCAmiqPX68E5h1arhc1mIzgVJnlpHqbv0eynWcqkNY1yGt5p00cmrTmewWCwxeFm00mancSc7OzsSCqZPHWiWpbLpTTAZBK42WxK6pvL0pxfrVaSoudxnZ6eotfrYW9vD9575HmOu3fvYmdnR9LuWxdUTDrz+GmssoFot9uVtD0bMzabTeR5LsgYFgeYxia2g0Y5WeRMGM9mM1y/fl0KK+RSc145h/xhAp4GGZEuacNTAGK+dzodtFqtre3yc16f3Da50rwmyMF+7Wtfi16vB2utPJ1AXE+r1cJoNJJrgCl4nh/uj5x7AFuNTmmec0xMqLNwk+KD+v2+sOFTJjjnhcUoFplYhGJxg+uPx2Ncv359q3Enn4ZotVrylANN7c1mg06nI8x9HivvAxrsXJ9PPxBZNB6P0e/3ceXKFbRaLUwmE7lHJpMJnHM4OjqSIhELOY+rfGZgKhdwIJWrTSVjYNclGhbwphGaAzZDY8qqidBAEvF1FDEk8CaY5PGzLVPQ16+lCSB9uAq1kckkayRFGRdN7zi+0NzQoGoDL/yXb8Q3/Cffgiz7edhWC26xgGlxMJCGlrxXhAPOppf8bjI2mNze4R2v+UKZB+F8O1svFxtavvveB/B1N96Kd9/7ACrv8I6bb8M77z4tTSUBYO0LtEyOwlcoUCE3WUhDxyR1mr6m2cz3MxhBf1hjUHgHa4LpTLQJdRlrQrOaXPCXMsYvr8N9pqY3G1tSKx9PSpy2zJhQKIjHyu2vfYmVdwEdA6DwFhk8MmGOAwu3QQGm4YHCA4N4bZVvexM2I8BYj820CSvFD4Oq6SW97BpJGrjBpHOoSRhXG6YuB1wrNMf0jcCT9xlehCGpWvHYDOCNEU44m2GmzmsMYMt+xGi+1AwTQN2IM1kXbA6b3Beyjgn7Mh7BfI4LBJPaCy5lm0mOLV02za1Dneq+jA1x9To0tANeJO7PJO83knnztaltAPg8FA2MjYnwmA43HrBVeLLj8vcAGiG977PwPQMAaIVjdHk8F9JXACqVSqVSqVS/6jLG4IvesI8vesM+/v2dMb73hz6Cd//8A/zrn3+If/3zD/Gln7WP//orPwtf/Mb9rQCNSqV6dPSKjW8mmefzuRhpqdkFBJPv6OgIi8UCm80GvV4PV69eBQAxaGezGcqyFGQDDbbUZCOGIssy7O7u4vz8XBLG5E1zf2yCCASTcLVa4dq1a/KlRZTDcrmE9x5PPvkk3v/+9+Mrv/IrpfHfYDDA2dmZmNPEkZAFzSQhmc2z2Qyj0UiSskz40qSkWccEMhsIMqHOcdG4ZNKW7zO1SCQMU+bko3OfxIHQ8CViotlsotVqyd/n5+cwxmA6nYqpyGOiOc/jY7qdxmSz2cTZ2RnOzs5wcHCAi4uLLQTG7u4uer0eAMi8GWMk8UvzmGxtmvdsoknsxsXFhcxJ2vx0b28PJycngj/heamqSozv0Wgk6XLOV7fbFT735aR7+jttBJo2syQ2JEVwcN5pMp+dnWGz2eDg4EDmnfgWFku47/Pzc4xGI7mOj4+Pkec59vf3pUjBQg8LKryGaV6zsANAzPLRaITpdCrFIRr05LBfvXoVZVlKkj81nGlgs+hDs/7g4EBS+CxI7O7uyhzyKYDFYoHhcIj5fL7VbJWFo729PXQ6HZyfn0vR6tatW8IEJxO9LEvMZjO5Pzj3k8lEClfEIvE64hzfv38feZ5Ls12m6PkExeOqkOKOaU/v4TIbzKhG5OYXDvmshK0yuNygalm4zMAWdNiC6UWeryFyAsHgMsQsVGabuZwadEn6VRLhJqZyaYinJhqisVYFU6xqAc/95jauXn0rBu/6IGAs7HCA6uwcqKqAMckAuMCh8M4DZSkGtmk04OP1Y2wj4C/i/WOyLCzvqnrn8f9Hgtlr8a677xdz9wfuvg+M3Tr4mPZ2YnpnqJtHZsbAJfMgvO+4bgUPB4PcEJfiXsTaLny11chyG2dSyX5S9EnawDLsKzXDa+54uq8imv8FvKybG4cMBjksrGGjTh9pI2E7FYACBqvoPlvjQ/Lbh2VnKJDDxEagwMpn+KZbXwwAOPsDoUDr5rkkkU0JVM3Y8LQRCiXehtQ1USJ8QkCaXUZT1cQkN5rRTI2ykcbCpwm4PddAZN4b2JIOd5325j6I4gCC6QtgCxESJz68X4f+a/nk/cQkF5xJKmGGm7o4FI/XkMNNfri5tB735UzElPh6XmlEs96RjDOgSYJp7sgNjw1uTWyOKU9uxCc2pCFoNLslJU5OdzIefh+4PPC8ranntGqZiKZJjO/HmEylUqlUKpXqU6PPuzXCX//mp/DM0RR/7Yefxb/4wF2855lTvOeZU7z1NSN821e+Eb/hc67C2sv/WFOpVJ/J+piaW5IFba1Fp9MRDAcbFtJMLMsSp6enWCwWYiwuFgsMBgO0Wi3s7e3h2WefleaRxHEwPcoULRPUw+FQWNXn5+fY2dnZaipIs4xp0dRI3mw2Yoju7e3BGIO3v/3teP7556WRYsoG7vV6YmBuNhvMZjP0+31JcTvnJJWdNg6kwctUN8UEMdEu/X5/y5Cj4TqdTqWIQGOVx1GWJay1go/hsacYjHSbg8EAnU4Hy+VSkvPcDueWuBGax1mWSXGAJn7K8/be4+TkRHAmN27cEB4557rVaqHb7Qpag0YojXsgGMBs9kjjmclxGq1E5Ozs7MgTAjRZl8slut0unnvuOUFnvPnNb5Y5YkKbiXWiYYj34PHw2ksxJ0xWc2x8zacRAAiTHQjpZ7LBU5OaLHTOOzEt+/v7cn3PZjPs7u4KB3y9XgunezQaCaaFaWkAODw8lHEQH0L8B4sW5OJzGW6fiBpec0zbs1hEE5rnnMUHay1u3rwp88Z72nuPbrcrRvdms5HiFk1/3sOLxQJ7e3syZ2zIyoLMbDYTLAyf3iAuiax+Fn6IHCL3nkx4HmO/38fBwYFw3B9XGReTnJF17PMIovABbUKT125cwBJU0XsLpxlVy8Abg6oZmgsWfVOjH5xB1fawEZtggLoBnvE1NoHp78TY8tYHfEI04AQvQX82rufy8LuxMBh/Vgb8ps/F8OfPMHnzHoa/uAMzW8BfzICqgovXZkhwh2R3aGJJNz2aeJmV5Xw0ywHg3Xd/GkAwm0Nq28P5Cg4ODWRwwug2sMhQokLhI2/bODhvtlLXlffRcI6msnfIjRWTOTf2JRnc6Xu5ybYY3jTBUxwKsJ0CT413+O3ltpArSVNOxFFufP0a3sMZoPIVWiaXsYWEeUyrS5rdw8HDeYOWqZCZgJXOUZvpJ1WOri3RuBX6bWwGAT9i1qEYk21MuCbS1LSr09Yuj9dRwt72jToRLjzpRlJEMSF0LegQhER41QEa8+10sePXxOWkdHxPxvLLJZLdtiltXECrSEEnmvOO/+KKYxMEianfF3xJ0mAz5XZLg8/EVE/fM4WpDfgkzS3rR7M6TXpnaxOKD+1gVAu/29VmtYtIFzavFdk6lS5jMpDmnd7UCCNnAXgTUuCcD7PNH1epVCqVSqX6ZOuzrgzwl77p8/H/+Non8bd+9Fn84/fdxgduj/Et/+BpvOlqH9/2lZ+Fb/i862hkv9w/AFUq1WeKXrHxTXOLqJPBYCB8YwCCVUgTpzS0AQjW5Nq1a+j3++j1etLskoYqADHOiqLYwigwDc4Ggc45YVszcc1EdtpwMTXl2+02dnd3sVqtJAU+HA5xdnYG7z3G4zEePnyIVquFg4MD4YkzLcvUbcqq5lhS852Jb6I6AAiDudlsyjo0+oBgsA4GAzFrz87OcHFxIQZev9/H/fv3MRwOxaRuNBqYz+cvasxYliXm8zkWi4Ww15msHo/HqKoK4/EY165dk/cBSJKe893pdKTAwbQ2Cwvko3N5nuPlcinpc5qnvB6Auqkmk/BMe7M4QaQGU715nmOz2aDVauH8/BwAcOfOHbzwwgu4du2abPMyoiT9zeanvGaYqmaRhgZxep6Gw6HMHQ3p1BQGINcw/+Y9kGJW2GSx2+3K3F+9ehW7u7sYj8c4OTmR42DhwXsvpi0NaxabKK7LbdM4393dxWg0EmwNjXYWG7ifXq+H1Wol55zmMRvTNhoNaYpJI5rjsdZiMplI4YKcbjK3O53OFlKl3W6j3+8LU573y2QywWg0wnw+x3A4lOIM7/8sy3Dr1i0AwLVr1zAej8Ug51MHl/FDvAen06ngjh5LeQ9bOMCawPFOI8jegxxg431gJnuHxgpimGUbA58ZlGVoTMf1XW5i47tgfqfJzrDtgENBNCLBj+IyWVEnWsH3Ua/PFChNTVMCjQUwv5phtXsA1wDWwz20piPYwqN7Zw777D1Ukwu8687TeMfNtwE2C0lwawDnQ1NMF7Ev3gPIYEz4De/w9U98QRhC/A54152ANAkmM03vOu1dv3ZicheokCOTRHSODLnJsPKlJKytMbJMiiVpmWBS5yaLRO+w/DfcejuAYMwTu/J1N96Kd959GkDAj3BsDg6FD/vOfMCpkK3djEnwzBhsvEcarK3CLGwFlQsE1rcF0PaFNNkEojlvQmK/beqUuE1My2Y0yBce2HiLDSw+sHw9nv19rwUQzicQzq9rOZjKouy7YNgCsGsjzG7vI6XGengXsCk+Cyxw+FiMiddQGREa3gLZygReuAV87CLqs4DSgQcaq9B8tWyH1HNIZ/s4ITE5TePZbCNHJHFNcxeJQZ1cy6kkNQ3UDTSZ/KbRnZ4Yvp/+pvmdesRuO9Ut47z0sAvRL0B9HCBjH7W5LwZ7PE7L7fFBipTPb7a3J4ijeIxWcEZG0CbSPDOeJ1vWJrojCkWlUqlUKpXqU6Rbu1382W98C/6br34Sf+c9H8U//Inn8aGHM3z7P/kA/tIP/hL+wK9/I37HU7fQzvXRNJXqM1mv2PhOE8VMafK9siyl6R1TzVmWiTEFBPOYKXAmcg8PD8UsOz8/FxOLzSMBSKqUCeXZbCaJWhrIg8FAEuNM8XJsrVZLmv81m02MRiNpvsjkK41dALh9+zZms5kgWQ4ODjCZTCSZzVQyTVGabavVShLHNFFnsxkajQYuLi5QlqWYxzTOaeKxoJAmvWmK02jlfmnsM9nMQgQbInJ9spXJkiYOYzQawXuP3d1dwVPQWB0Oh8J6plHMY6SxnOJLjo+PcXBwIOY+GdhlWWI6nW41MKWheXFxIeZ5lmXCbk+NUqazuT5xGq1WC0dHR1gul1gul3jDG94AAIJsYZNJJq1T/AvHwX3QLCZjmngZomR4LJ1OR1LzPE8siPA6Z4KZ4wXCkwacP5rQ6/Uaw+EQ6/VaCig8VmJrOF5eF7zG0waqnGsec6vVQpZluHLlCkajEcbjMWazGZrNJk5OTuSJBj4ZkKb4eX8wnQ3UBnKz2ZT0OHE2NL2zLMPJyQlGo5EY5ulTCSnL3Hsv5+/i4gK9Xg/Hx8eCkJnNZpJmZ8o9z3PhnvOavvy9k46RT5SMx2M0Gg0Mh0NZ93GUa2YwmYVvmNDg0vna3MsMUAXzm6afLR3M3IfPAbiNhWsY2MIGLMHaoGwHFIrPmCgNuAJTQYzKYNDFRpipUZcgIticMG0mKLrUNNDYgDwxjcQYMx7LpoUtgE1/gPyJN2H4vjv4za/7IsBWePedp/F1t56CQRaM/6Ks095Mekcciq+qOm4e2d6VDynrKuF25yYTM7zwsYeByQATzO882sk2sbTT9x2cJLotrGwXqBPaNL2zOB4a3ilr/J13n5b1pIkkqhphElEjpE8UcUoZ+n0p07sCBOmSXfIeV76q+eC+QuEdCmleidDM0zAtbuI6tfO79hkelDv4Cz/z9ZAnRqNRmi1NfALBwK5D+llwHr42U10WticmdBWXJV7DAj7zqJq12eqiCW5ceGIBqD8j3iRbe5Sd+ukDbwyM9wk7G2ICm6rGcXOfPJY0cS3vAcLG5ip8+iFlj7NJrE/uHzGP49DSbb8ItRImXsx54lXS1LgcX6M+FqBOflNcX44h3YcJBrUw19ms1pjAZPfh3NkUqZLM3VZTy7QRKOejAkwBlUqlUqlUqldFh4MW/vjXfzb+4Fe8Ef/w3z2Pv/1vP4rbZ0v8qe//WfzVf/Nh/Fdf9nr851/0WvRbHxMwQaVSfZroFd+50+lUzC1yd7Msw/n5uaRyiYGgocjkMBDwG2VZCrpgf38fm81G8BvdblcMuKqqsFqtMJ1OMRwOJQVOs5pmYlmW0mSx3+8Ld/rk5ETQGjSFySZn8vvKlStilI5GI/mM+z47O0NZlhiPx9LYkmY0m+kx1WytFdwEDVMAYlimxj33Q8O0qioxONOmlzTIadTSjGezUKZeF4uFpMhpuAOQRqREoZDLvL+/L+n0NK2/v7+P4XC4ZfAS0zGfz7cwIEVRYDAYiGHLdP10Ot3iVQ+HQ+zs7Ag/mvPH85VlGfI8F7PUOScNLFlIYGNMnkdu++DgQI6XXPF+vy/mKg1wFghYZEjPDceT8rSZsN9sNoJDYYNMGulMSe/t7QnznGOh6Zw+EWGtxdWrV3FxcSEp+cVigd3dXTnXRJywsEHTtqoq9Ho9HB0d4fT0VFLfk8kE0+kUV69elTFz7pfLJfr9vhSiaN6njUtTbjxNejLr2TCTrPbxeIyzszMAwezndbOzsyPHTYQOkTG8Z9JCkLVWmqxyrtnwlN8BRVHI/KaYl6OjI+zv7+Pi4kJQK3zSodvtyj3EdHm32xUUzuMoUzr43EbjyW/hTWBMnVyVz90WacBWAUniCg9TBgPdVCaY4RVQdAMeoWon+AZEc41uahb9LxpxVW22pUlaIEnDlgg8ZRM4xaaEmHA0Ol0jjJ8c8Kpp0H79FTTOx0Bp8HW3nqoHFBtgIsvgY9Eo7DCY3yZDwJ6gZns7eElgp00kwwCdsLXJ4U7Z2pcbU6YmOVPXNLjTJLU1wDfcfGqrqebX3Xgr3nX3/ciMReVrhzIdT8rsdt7XZrj3YnZzTRvPfT0H9QmPoeit5Lfjj/dYwyGPjTkr7+WzCgaFuLIOK2+QRa73xlvMfQ4Hi/JeFySKVHk4z9nG1APzpjZA47XDUL5rhgR3GDO2UDpAML19Fg3iaO76cOmjsTTC+E6fMrBljfOhjIuIDxPHlJqzbjvNTDSQrBvH4xMT22f1dBufmNfJ9e/y2vwGjWheFqbeDoCtdLtx2CoSERGUIlHko0adsOZ9xeS7TY5LUCgvlxxvbB+riwWHMM74O32SwyE27Azb4fiF6x3T6tyHraBSqVQqlUr1qmqnk+O//qrPwu/90tfjn7zvBfzNH30W9yYr/IX/8xfxvT/8EfyuL3kdfs+XvA67vccXqalSfSbqFRvfNL2Z/qVpe+3aNeEFG2OkKSHTpTTqiMCgMVdVFbrdLrz3YqT1ej1BnDABzkR2r9eDc05SoJvNRow+oDYymYa+nLzdbDaCByGOgkzwPM+xs7ODs7MzvPnNb8bzzz8v+ya3uygKMXqNMcIap+l22TAGQuPOPM9lvoj7oHHMNDcRFIvFQtZPsRNAnbLn/JC3TiRGisIoy1LmltxmJqyZ1k3Xa7fbwhjnOSY/nEnj8XgsiXual1euXNliXjN9TtN0sViICcy543niOeN5TdPNNL+995hOp5KuPz09lacGrl69KmY1De3BYCBNV1l0ocnKogIxHil/m8eQFh44N7ze03Q+E980rpkmJ8okNWEbjYaMm8UfzulqtcLu7q4krFms4fkHIE9DML3P6/r8/FwawrZaLezv76MoCpydnYnRTOO6qio8ePBACjWNRgOz2UyKB0SrtFotaUxLhjyvidRw5/mjCe69x+npKfr9PgaDgTwRwLGyqe3+/r6k540xkhrnGIklYjNPoMbokM/ORrQ8x5wjFmfyPMeDBw+EN/7YKkZ3TeXhcgtTJg6WBTwCysSUwfB2zSwsQ6fOe5jSIysrGO9RtTI0otlslg7ZxqLoAI0lULUNXBYMrQqhmWDVinFVxmRNMMEk/YlocmfYTrlGE9CUZms544LBbl2CW3ARvWKAxbUmBp/9Ovif/kXYTjuY3DHN7TebiDsJzS2NNRFrUsmxhikLZvbaF8LMJrqEaW3nQ2K7ZRPTGgYNA8GiADS63RarOzNGmOHvuPm2lz93NsPX3fx1QLI9ym1Z0zH1naS8gZrXDYRUtjUBs5KFDHy9G4kjMzlee6mFD2b4JhqalfewJiBQUn/SeYMKwex2kfkOAAufYeUzfGRzBZOqB5/5mjUdZarQYNJnfiulbEoDxBpF1fKwCWc6WwJVvNZcwyOrQvLbZ2mKOIzZFgHH0xpH1EmSLhYkytoH3nR8imGrGWVqICcGbRqKrg8GNeojRZiwoBD52ClCxMTPq/i+mPkWLzajE9SKGP7Eq/j6s8vIEWFsN3zYrgWMDTs2VXz6gssSd8IGm+mYPIAyMdHTooCviwNb480QUEql2TLSec9z25I0f/HlrlKpVCqVSvWqqNPM8Lu/9PX4z/6D1+L7P3AXf/2HP4JnT+b4X/7Nh/G3fvRZfMPnXcebbwzxpqsDPHm1j8N+S7wJlUr16adXbHyTwczUKBPTNBppdqXmNw1XAGKwARB0xy/90i9JSpd4k729vS1Ti2YYEQZEqZCZTCQCk7I0IWledrtdnJ2diRFLrjixFjs7O4JGYAPF2WyG6XQqzSHJpKZpzmQq2cc03mi8p196NHC5P/K3q6qCMUZMeBqhbLjJ+aAxTXZyp9PBarUSFjSRF+R9A5D3aTwyacv5W6/XW3gYpspp8KcmLMdO0ZwmvoTmMM8xees0ulutFkajEXZ2doQ5zn0AIcnrvUev18N8PpdmlmRBbzYb3Lt3D/P5HGdnZ3I+ON8AxFinaZ0avJxHmtA0hXlcPA7OIZ9eoJnfbrclFd5oNHB4eCjYD3KwWczhnHEeZ7MZrl69KvfM0dGRnMt+v4/Xvva1Upih+ZxysYnbSZ9o4HXN88qnJDjfu7u7ODo6EqxKVVWYTCbCSaehvbOzI09N5HkO7z0uLi4E9UI0D+8bXkudTkcS2mSnV1WFvb09QQExHT+ZTOQ+ns/n6Ha7Ms/tdhvWWty9exdXrlxBt9uV7wqm0QeDAW7fvg0gmOd8+qLdbiPPc9y8eVPm9eDgQPbL64uFpsdV3hgY67f53sScICZrjZFEqc8tTOmT9UMK1m4c7KoCDFAMcnhr0FxXsKWFN0C1Cklwb0I61xtgMzIx3Wkk0WoiU9iQEcwxJEiIsOPagExToGLSMYGb4CGKrkU5aKHZ78Gt12Jyc0NusRBT3yfH+M67TwtTO6A7gtFNfEjLNGKbyrqJJFA3wgzrOWTGooyGeeBth+1f5nmHbYT9hYR5MNy/7sZb5fN333kalXd4x8234R23nsK77jwt+BMXzXgAkRfuUcAjh0HhQxqdgXsa4QwHV5ecRYdgaK+iye3iHBB3wr8Bv8UBbxqDlfeokrNG87vyBrnxKLxFBYOmqfBLi2vw3QpVKxxDtjZ1ujmRj8WR1FC1ZSh4VE0fEuK8jiJ6QxqnJqa3qYwY7Y15kuhOmNYwgfft8lA8MWUo2PgsPO0QtmfqGTP1NSlp79RgTpPdNLz5lIIcYJ2mFpM4xZOk46NRnmybzJo0eb6VAOc8JIa753binLoGwlMONqTbXTS6eezwYR5S7AmfujAeKHMel5dte5/sh+c0BsCNM1umNs1+SagnT4D8ss1DVSqVSqVSqV4FNRsW3/QFr8Fvf9stvPvnHuB7fugZ/Ny9C/zvT98Bnq6XG3VzPHmljyevDvCmK/1oiA9w0G+qIa5SfRroFRvfg8FAmNBMxuZ5LsluAMKHJlN4MplIgzlyldk00RiD6XSKqqoE/8A06NnZmRji8/lc9nNycoL9/X30ej2Mx2PBKDCFzcaETPkC2GrsR740GzbSQD48PNziL49GI1y7dg1HR0dbmAYiPVarFVarlZjaHAPT5mmzQ+IYaHhzjNPpVIxvHntVVZjNZjKHq9UKzWZT9ks0B81JjmE+n4v5y+WYruYc0HBcLBaS+OXcdDodbDYbSZHv7OyIudhqtbYaDzabTTlvTO7S+GZSl6YmzV8eN83d9XqNo6MjwcWQ08z3vPdi/vJ4AEgxImVp83w456Qg0Ww2JdkNQOaF5j6NcxZimMwnj5pGcFVVglqhoQ5gqxEmn3Yg2oRG9tHREXZ2dpBlGaqqEizN+fm5LDsYDDCfz7HZbKRR5ng8lmsTCAY9TWE+NQGEpyNYBCKvncn99DpkIYpzv9ls5IkBps9pZNNw5rlKiy8p49s5h729PWw2G+zt7WGxWODi4gLXr1+X4gGRNGyayaLSeDwWlArT/ru7u5jNZmLuE2+SZRn29vbkePkkCI/r/Pwc3nsZB5tl8trk+X0cZTYOtolgZEfHznjAV8EI9xkbPQJwwSAvWxkaLjrN0RR3TQtbONhNiarbRD4r4ZoWLrfIpxVcbpEVHi4zcLmBKwKKxF8ArgUUvWheRsMsNb+BSylZQAwyl3vYgqn12nT0je11DcK63D6aOfx0CtvtwhcbmMxsGd3vvvvTwVS+9RTeeeenAABlkmGufEh30yReJ80p48gEc5LyuAFs8b8LFGJ4M1ntxIIOhnuWoE7efe8D8pqIE4rG+LvvfSCa6oE1vvaljBkGwcCO43ayLj83sAj8be61AM3+bdP7svldeMBFnEUV91d5BKM7Mb/J+l74DC1T4bTqYuMzOBiYppNmp1jF9L40P4znkyZ2NFU9MR82NrwEAB8M6yKPxvgGAAJn2uUB4wEkaBQALh5wtq6vg7RwYhzQnHmUbcg+fCzkbDG442dyLSZmuEuv32jupp+TbW9Tczui5tnwMR0bN5U2kARQY16StDficuIpX/pvKx5HKEyFA+A8hTR2TICX9bZk25e+QlMj3/hkjCa5H5Gsl/wW3IsHsqJOgAN1oUOlUqlUKpXq01GZNXjH517Hb3rLNbznmVP8xLMn+NDDGT78cIrnzxYYLwq877lzvO+58631drs5nrw6wJNihoffB/3Wy+xJpVJ9MvQxoU6Y2KyqShLgNNistWLmkktMgxUIKc47d+7g5s2baLfbGA6HODo6EkONJjCN706ng8FggG63K2Y2t3V2diZN+UajEZbLpZjnnU5nCwlBJIoxBr1eTwzloiikSeZsNpMEcFEUgnHpdDpiYpOHTLOQaJfpdArnnOyz1+ttsadpHNJUJJql2+1K8SDlFROXQbwL0S6tVgvn5+diVqfmaNoQEQg4inQbHD/njFiWFC3DJDVT0MRbNBoNmXsyymlUsoBAcdtM/DebTezu7goOgwgPYkOIbwHqBDaTxkwkE5/Ca2A6nYrhTGObZnaa5qZBSyOd12n6HtVqtcQo5TZp1tLMNsa8qGEiE89MfBM9wyJKyqImKgaAoFMuLi7kKYfRaISLiwspxnC8bB6a4k94PrMsw87OjjwFwCcFeIzkpu/u7mI8HmOxWCDLMnS7XWGhE0kyHo8lvc1rq9VqSaNYjp0Yl/V6jYODA2RZhoODAzHie72eFG96vR4WiwXm8zlWq5XwxVm4GI1Gcv5ZTOJ6nDtev8QbMaXOa4zXSqPRkHPB9P/jnPg23gNFLEjCRBcRCQLFwcfml8Z5eGuQbZwwj00GoAq4Ey4LBEPQFA5ZGREqVRXMcXgUsSCRVT6YjcYgawQOty1q828LecF0b8L6JrYiRSqQ20yDL42IuwzIPFB2MuTLFWAsfFniB+6+D7/11tvxrrvvxztuPYUfuPOTqHxoUvnPb78XDgYrX8LF74KWaWyhTRz8lukdEtYOBSpkMChRoUxY24WvZP04MkmAp7Jx29v8byeolXff+wAK7/HOuyFGUnmDH7j7Piycj8Z3cErnCfd74fxWrjwN3wI1/qTwwfAGgJW3aBqHTQQub7xFM64VkC48iho7nabIN96K+Z3FY24aB4tgfr+uMcHctbCXz7G/N8PJPHy3ZosGXO7j0wBejFO40JQSiKlqYnDSgdj6/FdNHwxxH1LJJjP1EwIGgstJ2d4+NmMkbsTH/fo0Ab7Fg9k2klNzVhLXlxLYW6nvZFlbosapJOux2SvlsX0/cBxyWbHBJbaPDUj2n+473VbmA5c7btMhsNZ9FlYSJAnCPFjOn4nzYnxIjTOpHs8Tz6Op6gIF72ueA5+F74GIdIdNx6Wmt0qlUqlUqs8AGWPwZU8e4MuePJD3VkWFjxzP8OGHM3zo4TQY4kdTvHC2wPmiwE9+9Aw/+dGzre3s9ZpbZviTVwZ409U+9tUQV6k+KXrFxjdTuEyCMuFME5PpWCaN2YiPBvRgMECn05HEJ7EcTI+yEV+73ZYme8vlEjdv3pQEeVmWYq4bY3B6eor5fI69vT1JTg+HQ0nwApBE82QyQa/XE7M45RgzBbtcLrcMOOJImEjm8ZHRPZlMpHEiGdqpeUpTOF2Px3Z8fCwMbzYCpMHNY0xxHvfv35c55raZtm80GsLWBiAGJJPKzjns7OxsNcwcDofw3ksqnw0wnXMYDAbCvKbhzL+Xy6UUELIsw8XFBQ4PD2VOnXOYTqfodrvCzu71epJ6Z9Gh1+shz3OcnJxIY8putyvG6/3799Hr9aRB57PPPovd3V2cnZ2Joctri8lnbnc+nwtmh/vlvDEFz2INCznr9Xor9c65TZnc5+fncv643zQlTwOdY+D9QsOa1zjTz/fv35c0Pu+pzWYjY+K1RewLMSi8poi+IZqH7x8cHMh9uFwuMRgM0O/3cffuXTGJiUjhOPkkB1E1QDD2F4sFRqOR7JfXcJZlsux0OpVrq9FoYDQaSep9NpttIVPyPJfikPdeECUsKtFYXywWuHHjhsw1zymfEkjvtbQhJoCt8/k4y+cWZuMSVIIBDFESBrao4LxFtixQdfJgUBWVLGvWFZAZeGvgGxamcqiaDWSbEjDBaPWZgXFhH0zRemvQWBtseha2BMqOQdUCMiZKoykmDS2TFK00vnTBxLQFts3PZHkaejTVyo4FrA0876pCy+T4gTs/SVw0WibHwm3QMg1x39umgSImvpmgDhsFcmNRwSNHJg0lpXkkPGximJeo4jJ1YpymdwtNlKjQQBbT5XUynHJwgGcqvOaCr3yJHFmd7o4s78r7kMRGMBLZnLLwQNvU5jZF9EoBgypxRSsYOBhJbvN3njDDgZACJz6littwcdkMHoXP0DZVNNGBrqmw8hb72Qy5qXBzMMF4JxTPymkGuwGqtq/PL01u1KarnGsXGNXWG/gKqJoAPNCc1OgTm7BIXB6aWvLpgmzD2DWAzEuzS15T2cYLQ16Sx7EYxFS2Y9HlUhra+Po6TrnXaUJcfpOhnbwmtsc16nUvp9G5PTHM2SQzuYTSdV6U+M5iFcOGC8bAyDZ8Fjjq4fug5rBXWTDBEefQNcITHGLEp4l2B/njcgNQwbfwaY/E7Ad535xHfQpYpVKpVCrVZ6DaeYZfe2MHv/bGztb7y000xI+mkg7/0MMZbp8vcDbf4L0fPcN7Lxni+72mpMLTpPieNtNUqT4hvWLjm0zrNEFNvjTxG0wHkysMQAwzJlD39/elESDZ3M8995yYZUzZ0lQ8PT3FcDiEMQaHh4dotVqS2G2321itVsJwttZKEphGWFmWWC6XkhxPU9j8HAisaSZdHzx4IOnl1WolrGTiKsjyJmKFBisRDCn6hZgJGulMstII73Q6wp9mSjVtXkkkCZsmNptNYUGT2c10MFPM3W4Xe3t7wrrmXLK5IjlTu7u7kqwmTqPZbIop3ev1xNTv9/vo9/vo9Xpi/g4GAxweHm6lgdnIcD6foygKVFWFdrsty/T7fRhjBFsxGo3EaE6540yen5ycSJqf55znkUWBlDNPE52GNQ1uFgAAyDb4hAGNcTZ2ZFGBCWOuw/OSIlIuLi4Ey9PtdnFxcSGNIu/cuYPT01O5HtvtNu7fv48rV66ImU0e9WQy2UKzcKyr1QrL5XLr2gAg55asdyJmeG+en59jsVgI9qWqKmlmSVQN71vem7wuyIEHIPcKP+N9xEIDnxxYLBZy3YzHY2w2G3lCIE2Zz+dzuYezLEO73UZZloJM4XkfDodibgOhgHV8fIwsyyShThxPr9fDycmJMMZ5Hh/n5pbeGrjMwmaR8W2M8LF9EkU1lYfPM9hNBZ9nqHpxzjzgezmMi6nvMpjb+cUGVbshjTFt4WsW+DoY6y63cEVIkmeFRbYOZqXLjSRHpUme3U6B0zzMimh6+9r0E1MwNf/KmG4HsN6x6G828GWBd9/9aQCQZpI/cOcnMXHBRL5wKzGwi+TJj8yYgAUBpJmlRRiP8yYmrYNyE0zt3AQzmwY1AHRMEw4eucmwcJu4Hbs1ntRkJwe8Qom1L1EZL4iVwjvheNtL463XhxismZGWnVvIEprhLmFzF7BYuMDizvj/HSjRNE6Y3ysfTO7MeOTwwWD3Hqt4rGKUmwoVjBjex66FqWtjXPXwa9r38UJrD8PBAgBw3m3BGxuSzg0Ia8WWCExoBNRNOL8hjexywOfhd7YyyBdAPvPYDAx8Oza99MHsdo06iZxys01MhqcJcpqtVTMmkjdA1U7mc+PhGgbG1tedt/WYgfpJBL7m9rfS4a42e7dS6B7w8dhpMEu626M+mQk+RT5PEtVb+00T5MmTE1vjzLwY60CY4yoD7KZmtmSruhLhbUjY81GCrUabNP4tpDduWggDiwPxoRMeK6TIsD02lUqlUqlUqkdBnWaGt9zcwVtuvtgQf+YopMM/fBQN8aMpbp8tcTrf4PTZM/y7Z7cN8YN+U1LhT14dBGP8Sh+7aoirVK9Ir9j4Ztp4NpttGbuz2WyrYeR6vRZDi0YYEExWsq13d3cFE/H6178e9+/fR6PREMQDk99ZluH4+Binp6doNptipNGk3Nvbw3w+x3A4RKPREEY00+FASPbO53P0+31pBuick/E9fPgQ7XZbUBJsRMjGgkw0r1YrjEYjGRsTuEzWMrXK9DgAMVHZzI9GIZOqNK6ZinXOielJQ5apX6avuU2a58PhUBpu0sxnypgp2na7LSnZa9euodVqodVqSfFiNpsJN5znkUYvz9/h4SGGw6HgT2i2polmjpHnjvxr55zwm/M8x/PPPy/IGxrlRHrQJOW5f9Ob3oR79+4JroMG8vHx8RY2hgxsjiHFmbCZKucYqJtWApDjAYLRnLLUiZYhroXp7PS+YEGk2+2Kac/mjNxWipk5OzuTAhCxHix08LpiCr/ZbGI0GuHu3btSMEiPmQUnJpz39/eFfU1MCFnzTKafnp4iyzIZD4sjbF5LtAwbytJAB8KTBsPh8EUJehYLWIgh1qTVamFvb0+KNzTR2WCVGBk+FQFATG+uD0AafL7wwgsAgOPjY7zlLW+R89VsNuU8ERvEtPjjKKJJTOXhG/F7IZrVvhG43d6SGxKUzTewZCObkPJ2eRZQKHEblQ1p0WCEB4RKMN4iIsV52IpRVh/NcQOfGWz6wWDMV4Db1Elw4XwDW0lSl0VTPEVDVCGBu3WsxsDAYz0y8JsN/t7zP4ajKjCtD7IeLqoF+jZcR2tfom9bmLl1kt7mhupGj/AemTFbqedWkg4XnImvk+OV93DeY4lgdhOLEhLbBXKTCZ+7SCY+vFdJwnzty7B9T2/VY5OwuYFgYhcJYoRJbHK4qSpBbsSeppLUZgPKwgczHgAWAFwgeW8Z5PAuNKuUxpoOBSwKnwnqJDcOE5fDGo+Vz1H4Bgqf4bTqo9dYY9gO9/d4tAHWLSA2p7Rsnlgl1yMN1yw0q0TuYUkuisUTl/7rxUScjg3Gb9X2oYlmyo5mQ0lEsziun2JVbBUbPrqwkLch+WxKwOfYNmcTQ1mS3AaSYE7vLbK9UxyKLAsIGsVWIV0uTSoRizsISXbzEl9psmw0kwN6JB5yHtAkW80oU7xMFvfNZH3TB+b/JTNaClVZYm6nN4fx9Rygnk/fCNtO9yHnIbk2L+NeVCqVSqVSqR5VdZoZPvfWDj731rYhvtiU0RAPKXGiU+6cL3Ey2+BkdoqfePZ0a52DfgtvurrND3/DQQ/9dgPNrA6vqVSPuz4m45vG287OjqR1aSy3Wi0URYGDgwMsFgt473H79m1JsZJ53G63cXZ2hmvXrmGz2eDo6Eh4xTTGaI7xJ03eEq8wGAzEUO33+8jzHGdnZ1iv17i4uJBxM6F7enoqbOpms4nhcIjlcikmt/de0uH37t2TNG+e55jP55hOp7h27ZrgI4hQ4ZjZGJGmcTpvAKTR32W+dNpAkCZyiljh3BljxORjQpyJ50ajgW63K9slnoQMbo41z3PBz3DsALZS4Zzr/f19rFYrWGvR7/fRbrdx5cqVLcTE2dmZMLB5jOSS8xo4PT1Fv9+H9x67u7vSrBSAJJiZVua4aHoSl3L16lXcv38f7XZbksZp0082+CQGg7x1zkdaSEhxGcTEMAnPxoksSrCB6nq9lsasxOMAwMnJiYyRxz8cDgWNwoLAcrlEURS4evXqVlNOFhkWi4U0fLy4uNjCCrHYtFwucXh4KOsXRSHnrdVqod/v4+DgQK79fr+Po6MjDAYDwYpkWSbXD1P4TFizWMT547XBIgIT+71eT46NTPCqqiT1PplMpEEmU+ksmi2XS0HP9Pt9QaYwqT0cDsW0t9aK8Q6E5HnK0e90OphOp4LSYcqbc95sNh/r5pYAgrkdze7whg3JbudhNxVcM3x/eGuQrUq4Zga7DteXb4Z5N5WT7Xhj4JtWUqseCdrAMc5pgMrDOgfjPezGIFsholIsqlZI5W76BlkWmcr5tocWNog4tvg3sQ+NYPRl6/hZTPVWLYPFTYfvfe7HcOYy7NkK1hjcKWcY2AwLv8FZVWEvy3BSLZFHU7sAkD4XQGTIygO9+HrtA7e6aywyGDGwgYgeEX428SQVCu/RNg4FPJxfy+chuV1JspyKpPAYJPbBRDexkSTq+SmiMV/5upFlAYMcYTm+LlKH1vstREnakHLlczhvUW11VOSYYvraG6yRwRqPJpzgUQpvsUFWrx83MXdNVN5i5XNsIhsjNxVakXVjrEfVcfDGBnM6mqA+C00XBWFTBh638cHUNi4Y47aMhZHciNHtotHqmuFvW5ra/I3/ysnWQJWHbbnGJZM2psErPvAQkT2m8klRp96WS5AfW78v6TLCx1Rx0cT4NfEzl9VjsVVd+NlqkknzOTGZRUnqm4l5bwHf8NGI9vDGv3iskXnufV28QmngG0nanVzwWAyonfvk+H19+Zg4rw4+FKoKExuRYmsdSYSr6a1SqVQqleoxV7fZwOfdGuHzbo223p+vyxcnxB/OcHe8xMlsjZPZGj/+kdMXbc8YoJNnaOcZ2g2LdjNDu5GhnVt05DV/LNp5FpcPr1vp340srJNbtOR12C63Za2a7KpPX71i43t3d1dMaRpyRHjQoCZvt9frYblc4saNG7I+zbRerycpUZqeNE/5flVVYgY3m00MBgMx6MherqpKzNErV65gs9lgZ2cH0+kU4/FYDEIagcYYXFxcoNVqbTWqJBaC6JDLxlmn0xGu9DPPPCOfcR/EahAZQRMcgBjHPEb+AJCUKpsmMgULYMvY3t/fF6b2YrGAc05M7M1mg0ajIYY2zUkmwZla5uc0bff29lBVFc7Pz4WFTRzHYDDAYDDAwcEB7t+/L4iZ5557ThLbPIbU2AVCCpmpbKbQi6LA/v6+GKhkwzN5z5TyZrMRTAWRMGVZ4vnnn8d8PheWNU1bNs/k9cK5H4/Hci7SBqdEgtCUJq5lZ2dHiis7OzuSkibvPW1cyuIMedo8vna7jdFoJEUBFkCYsifSpNfrSZqdSJ7BYCC89GazKYUhnmNe5295y1uk4AJA1uGTE1mW4e7du2g0GphOp3KOmIDn8sfHx8IjJ5aIyw+HQ7TbbUynU0wmE+zt7cnc0dxfrVaS1LbWium+WCxkXBwTsTPr9Rrn5+dyjADke4C4GSbEed+xKSa/E1is2Nvbk/uDxSEa5ZdRQjyXj6W8h6miyWVNTFUb+DwLrxs2YEwqDzgHn2cxuV07UGZdwTQsXE6GQnBc2QzTlnXTS0l/FxWMDSY5sRXemthosxGMTgDGWxRlGNNmWA/buNhkMP4/E411e8kZdzmE7V21Itf5NXP8y9lb8Fv6P4sfW93EZzcfIofDSWVx4VtookJmlmgbg9xYrL1DDmAR3bo8BISRAWhaIw0iOSPEj1QRa+LgkMEERAr8Fj4lj+8BQBET2+2XSVwwxPsijEnyd3XJZwQCxmTlQ9qa7O7MeCx8Bgsv7O5gtnsxqyXJLaZ0iSoeZQWDHCENzr8Ln8Eah8x7bGBluxUMFq4V1vEVVsjRNBUyeMx9cJAdLJy3aFiHKm6z1SqwyPJgrMZmiI1lTHzzfBesqETjN2mmSI51+pSAiaarYD5oFJuI2AFgI+vbNeO1w9UTt9a4mLjOTDRkTZ2ibiT7lHP04t82Gas020yuX5r1SI6LTV3TppdMR5s4Ruu3Dft07OkxbzWKTJAnYZ4MfLKANz4wvw2EAe6tAbJoejd9LEAwmZ648OlcXDbho6ntDUKjXHhpfOkvFw2wbe6rVCqVSqVSqWr1Wg18/mtG+PzXjLben6WGeDTDnzkKhjgQ/lNisamw2HxqnoJuZhat3NZme3zdin93oqHesBYNa2CtQcMaZMmPNealPzP1e/KZSdbjZ+Zltpm99GfZ5e0Yg/Q/2cyLXiD825mvX2pZYCtpv/3+S29H/v3/K2yvYQ3aefocsOqV6hUb3yqVSqVSqVQqlUqlUqlUKpXq1VO/1cBbXzPCWy8Z4pvSYVlUWBcVlkWFVeGwktfh73VZYbmJf5cuvC4rrF9iWW6Lr1dFvd6mrNMdm8phUzlMVyVUnxz99rfdwl/6ps9/tYfxGalXbHzneY6iKLaa6i2XS2H1MnlJTAPZ1MQNFEUhnObBYCA4kPV6LQ0yiRVhepcJ7tlsJqlhAJLc9t4LyzfPcxweHiLPcwyHQ5yd1Q0BuDwxIykmod1uo6oqSVuToc20OdPgy+USeZ5jOp0Kx/z+/fsYDoeS5CYig+MkR5osa/LAmQJmKnez2aDVaklzSaIl+v0+dnZ2pLnjcDiU8ZHRzfPS7Xaxu7sr2xuNRphOp5KyZbNPJm5brRZu3LixxWzv9/vY3d1Fp9OBtRZXr16VlHOr1ZLUM+fncqNQjgeoE7pMVJMnPZlMsF6vJfnd6/Uwn8+lKeTZ2Zk8PXB2dibp/PV6LeeK1w0T3WSVM9HtnNvCm5D9nTaBBIDBYCCMcWJPeG0bYzAYDDCfzyVJzLHMZjM5Rs4bG4HyPaJIAGBnZwe7u7uSDAdConw0Gsm5W6/XWC6X0gy01+uhLEssFgscHh5iPB5jb29Pjplcbz7BsFgssL+/j6OjI6xWK+zt7QlyhuO4uLjYSqkTE8I57Ha7W9feZrORuWOVsSgKYX7zHJyfn8sTC0y2kyFO/nmKc+F3B5n24/FY7hniX4hHSZ/YYGNVsv75FAkbwJZlKUn0lBn+OMp4hKaPHgFanGcwm6rGN2QWpor/UInJaTa4FDUsUDrYmAj3WZ3yNo7AaB/fM4DzAXWCuO/Kh+S39zBrh7z0cLmN2/GwpYXxofll2WUqNzQU3AxNwFk06lSsoCGY/L3ECV6ft/H9d9+Kz33jbRS+geeKPbRNgZuNC/SwwUeKQ6z8FG/ILwIaJHK8LXsBQPr0YeM9msYgR0huZ0nNPYMJ/O6k2WWFiBOJaJK6SWZompkhSXQbs8Xh5laql0jN8n2muysf9r3yGboI6WqLOjW+inHaImFHMKFdj7V+3Yws7wwOuangvA3bND429MywQYbMm9CUM/mMae/CNwADZPDY+IBPWbgWNj6LyJMG1q4BG2PBzUaFRZwc48M5F9wIiStZjeoIKW8jzU55DchvNltEPRGmrFPUtthOKNuiTleT700+uMtD2pvTx6aRrvli7I40qGT63NTvSTNLn+yzUW9D+OKuHoeJiXKm1tMmmGzqyuW9qZtlps0w6+OJmBrwaZ0Qk/dZSHh76+PyJq5rQuJb2EWITUUNTBaS4KaKu7LmRfsNr+vEPjcZ4OQRe5LHxZI0vkl2iU9NGEmlUqlUKpXqkVazYdFsWKCT/8oLf4KqnMe6fAlTPBroq5cwzEvnUcWf0nk4F/67rHKXfrxHVf0yn11+75fbzit8z8X/xk3/syzFp8oDlvqk4mecXrHxTcwFsRAAhBe8WCyETU0j7jLLmiYazciLiwthPJO7TOOb2z09Pd3iBJPL3W63MRwOsVgsMJvNMJ1O0e12t1AcNGCHwyGcc4KWIEaBCAk2LSyKAqvVSvAjVVWJeX/37l10u11cXFwIG5vGJs1KsqfTxxrm8zmazaYUDHq93haiodvtbpn+5G/TVO71etjf38doNEKn04FzTuaNWAwa6I1GQ0xVmr6tVgu7u7uCo0kRLGy2CWDreHkMNJCNMXjw4AH29vawWCywXC5x5coVMSuJ0OB2+v0+ZrOZNHukqcz5nkwmcM5hsVgIf3w+n2M8HsucFUUh1wSvlX6/L6Y5zx8bH04mk63CC7EbRF7QLG82m4K0oUlNA5a8cBYGOAbOU9qclLgRom445/ys2+2i0WhgtVoJ+57XLLnaNGp5DfKeoqk7nU4FO8Nz3W63xQgmB3+xWODs7Ay7u7s4OzsTdjfxIjSwWZRh0YdYFjay3NnZEYzQYDDAarUSo5noIQCyfqfTwXA4RKvVkuJTt9uVZpUsRk0mEylqNJtNKUARITOfz2GtRbfbFYQKGe+cE15bAOS64P0xm82wu7uL09NTwcvwOyrlqT9uMkV0kayBcYEXDWuD81RFJIkHXG5hvQ8muPfy/+JmU8I3G/C5hWtmAYkChOaY8Vx4Y8J6pQOMFQSKyHkYJGiUdQlThKaZdm0A30C2dii6FtW85ijT1HQZ4IZETiSGt01QJzYYpzBA9/kcD+/dwF/4878Lf/7v/g38yPyz8Zr8DPvZHIfZBgN7DwMTGljedhZ71iED0ItjzmFw5hy6BuiZ0IDSGoMcFhYWa1+i8A4OAZVijUEGgxV539H0ptlNYz39TWUIfHEqNb3ZtLKIjiBf5+yECCA3DqvoojaNQxWXdfE3G05Wl0xvdwmmbI0TVjgAZEn3RK7rvIWDRRGXh6+3U/gGVi5HFTuOtu0GK580/4XF2uVYVjnmRfhu3ZQZ0HTClJamjQ2PbG62DFkfWdU23so0ymkKu4TJzQIJP0dsmslr0ttg5NrK1yY7iycIr10esEAuMalhI3onLmvqekecVASOdfK+YEqSbYvRm2F7v9jedmqwA9EU92EOHKKxze1HQzrgi+J6ZY0TMVVg6rsm4KuwjIMPyBObONBxfzSihRXug8FuK8AUofjh45wkPrdgjS5LUC4GcI1wYxNjJI0+0wa2KpVKpVKpVKrPGGXWoNtsoNt8tUfy6aEtk5z/1H65zy8tF9578fqprDYr/bj1io3vzWYj5hu52DSjaayuVitsNht0Oh3M53Mx/wBI80KaaN1uF3t7e2g2m8IRnk6naLVamM1mwldOU7k0MgeDgSS3qbIssVqtJJnL9DPNWzKEgdAoj4nv8Xi8ZebTlGs0GijLEnt7ezDGYDKZyDEuFgtJzNLUY2qbhiIQEsWnp6c4ODiQxDQNSwCSAOc8AIF9TMOx3+9jb29PzOssy2RdJsfJKu/1evIZuc5MoxtjhEvNlDyT2/x7vV5jNpthPp8LU7zb7WI0GmGz2WA+n4sxOZlMhK9Og5jngOY6z6O1FhcXF5KS5vXARpJlWaLdbmM+n8MYg4cPH0qa+fDwUK4LjmG9XkvqnueT10pRFFv8bB5vysVmoYH7prHOVDPT+5xvXmfkT1trpWBAM5npYjK7eT13Oh3s7e1hNpsJ3xuAFDk2mw2m06k85cAmoovFQsa2t7eH1WqFRqOB5XKJ/f19AMDDhw/lyQEmxE9OTmRf3ntJV7PgwsalrVYLi8UCjUYD+/v7UkDiUwdMxnPZ1WolY6+qSs7P2dkZdnZ20G635ckIXods6EnG/XK5lM94r/J7pdfrSQNUXkMXFxdYLBaYTCYAQgFrPp9LrwFjDHZ2dtBoNNBqtYSVzl4BPGePq4zzgeNdVDDC5QZMEd6HNXCXuLq+kaSE23lYv3Rby7Ahpi1cTKB6+LxOgJsqmufGBEMc0YRvN+L/extZt7mp4BsW2bIhRlvZy+CtQW5jA8xVYgQiGp5FDKgWSap3DTTHHqt9g+O3tvFtf/4Po+gZjD5S4v/43r+C//Lzfgu+74PvwsPK4Qfnn41rjQkOGxd4Q2OGPRufgjEN9K3HuVvFv8OOF75CK05CHt+zkQDONDh53kyMW2Ab0hZFAzykwvkepPlkFrdTRR63jWY3m1I2jRMjO5MxIY7FwMJj5UPDSZjtCO1l0/ulJGZ53F/gdddPAdjE1Gaiu4IFPNC2hXC8Nz6Dg0UGh0XVxLRIGz4z9hxSxXZtYEvArkPS2pZ1AjvbmDoR7LcPiQlon/EJh9oEdln9N81x42L629dGOhA9Zxq5lYdrxsS3TZLcVX0dehM+S01tMb3ZrNFEM5zjjcbuFifccufbhvfl6x0xlC2mezTZbVEfFxqAd0lKnIWCMhrLzsA1PCprxJRHBoCG9SVwuG94oOIjB6ZmcHM9DyDz4ZZOwOfyiqa8k00GHn/ma8M7SbMbZ2Ae369rlUqlUqlUKtUjoC2290t61J8ZxrUx5tsA/FEA1wH8HIBv997/2Ks7qk9Mr9j4JgaCjQRpjC2XS8znc7TbbXjvBQ3B5C3TwNZanJ6eIs9zSYQzGbperyWhSUM1xRSsVivs7Ozg9PRUEsJ7e3uSyJ5Op+j3+2JCAhCDsCxLMShp7jENS6wIjdLFYiGmMRtTHh8fw3uPg4MDTKdTeO9xfn4uBjvT02yomCIuxuMxRqORmKo0/5hALooCo9EI/X4fh4eHghhpNptimuZ5Lk0pT09P0ev1xPCbTCZotVqCB2EqlwnzzWaDoii2jnO9XosRzsacxJmcnJzIMXrvcfXqVazXa5yenmKxWEjR4eHDh2g2m5hMJpLw5jXCFO/Ozg76/T7G4zHm87mYmicnJ1sG5Ww2w2AwwHQ6leuCKXxiMlhQ4bXHZDINaL4mPoUFF5731PxmSrvT6ci2mdbm/llMoAmbFjPa7bZc091uF61WC91uV84przcWE7rdrjT7LIoCw+FQjo0NJgFI8eTOnTu4evWqNKykQcz0+9HRkVzfvB4mk4k87cDj4Vzx2DkuFm+YDKcZzvubBQ4WAVhc4VwTwcIGmCw+sSjD88pCGXEsk8kEJycnW/gVPjlBxApT9RcXF9IwNS1u0ein+c55s9YKBob3L783HlsZA7sqAR+Mblu4kO7eVIAJaJLgl/ptB5bFMw+YdQlE9I9sNmmIaYyJzf/CbybAjQvGt3EuNMts2GQfAEoHQ4zKpgpjirJlE1U7C6gGb1FtQvPKqmUEe5GtIrYhmozZJhqdDmifeZgKKDsGvQcOZdvgd33J74TpefynT30j/HSGw3/TwJ+98S70rMEvFn3cie7k//ONT+EH7vwkuibD1JVowyI3Fnn8B0rX5li4cB+sUW6Z3i8RAg7Hg1CZdwDy+JvKEpRJmBqPTeJ6MnG9dgZWuhgGw5vLZsaj8OxhGBAkTTis4js0sl3S1HJLEpWul2UzS+ctNqhN7wIZmr4+Vw4WmXHIUWLlcrRRRLPbo20LrFyOs6qPtWtgVrYwXYXvumLdACoDU4b0b7aAmKc0mH00hX0Wze6IDqGZSuO6zCEoDUGG2Ogzl6hxHEDE8QSzndeSLROcjgFcI8aYo+lNBAvwEknvaOZuGbYpAsXX6/qYGKeR/lKGOhtCSgJ624sOy9YPZYjJ7WmEo05QS1PYNEltTHh8k/tMTW8T/vYmbMQUZrtxZkyK19tKfhtfb8snH7NQweON50UacfK3AbzxsC+TGlepVCqVSqVSqVSfGhljfieA7wLwbQDeA+APAPg/jTFv9t6/8GqO7RPRKza+q6rCZDIRnAJNMZqLNM9o2AGQNDQAwS2QKUyj9/z8HEAw1DabDS4uLsTc3tnZEVYwU7H379/H7u4uzs/PBRNBZAj36ZyTxDcxJMQgMD1+9+5dTKdTYT/PZjNJ6tJ073a7Yvy1Wi05TmutmOT7+/uSbL5+/bqkh7k+EEz/2WyGK1euAIAwmK9fv47d3V1cv34dh4eHgi1hcYApceJfrly5IqYfU/ZHR0eYz+eYzWayv7OzMzSbTWRZJoiZFB0CQJLTTM6uViscHx9jPp+LAUyjksiSe/fu4YknnsDJyYls+/DwcAsTQmTN/fv3ZV65bDq3NMI3mw3Ozs4kOc753mw2kszvdDo4OzvDfD7HfD7HarUSg5fbojkOQMZPM7rRaMj1kc4D10/RGxwrzXkWYshpT010JuM3m42gbqbTKXq9nhi6TLRzzokfIfolyzK5J5hYPz4+FsQJ90+0z/HxMQAIVmaxWIjpyycKxuOxPPXAgkt6LbMwxXu41WrJeJj05/w656RIlIpJbZqiWZYJS5/FBpr74/FYOPXdblcKYmS2p9gZay1Wq5W8lxYGiCQi636xWIgRz/PHoshoNJLz9LjKGwOQzT3bwJbRxMwAU7jA+jaGrilMUcE345yVDmgEHreJXG8gYiOch282hBFODIo4ZTHtTV6496jNciJYvA84lTyDXRbi5uWlQ9bMUAybaBcOxSBDWRhULYPNEGidB7Ox7MZdOQAF0Jp52DIcz2ZgYAsPlwH5Blg9eRXNsyVQOpRP3sCD7/CYfl8D33f++fjo8gA32mMAwPc+92M4q4ArWRe/442/Hv/iufeggQwdAyz9BlMXnwpCwJrk8Xs+NxbOe1gTON6ZMQzlbhng/G0j83vja5eQWJMiGseFt8iNg4XHGlnN7DaA8z6a7cHkRrof44XzvfINMbMz+Mjudiji52R6h0vCy+/cFgGZErEmTVthgwyFyzD3TaxcE5lxmLsWssTKH1ddSXwvXAvPrfZxf7UDALg/HWI2Dd+Dbp7DFOG6yxYGrglU3QqNqZXEd0hlB0wHDWq7YRrcSwK54Q2qdih+eBOxKXFaXY4XpbFtAThrYMqYrM8Sk9kgsOkR9usjTsclpjpFozxbxacOEg/ZFrXhW8WgO5E8xsbt+fBe1UZtFvuY0KaxzzQ797XxgAOqTigY1DiTcMs5IPyLLjG7fWL8E73inYGBj8UFD+MS7Am35xMCCtnfOWrDmkr2lYbGuT/5jAa9Qb2vKhYZ4i/feInnOVUqlUqlUqlUKtWnUt8B4G977//X+Pe3G2O+DsC3AvgTr96wPjG9YmcoTX4yXdrr9aQZHgAxztj8rtfrieG4Wq0wGo3Q6/XQ6XTQ7XYFmTGbzcQAu3btGrz3klhlQnc2m21xgpfLJYbDoSSii6KQ5Guj0RC0Bxv69Xo9XL9+HYPBAHfv3sW9e/cENXJycoJut4v5fA4Akng+PT3F/v7+FgO63W4LB5xM8CtXrmC9XuPk5EQYzADEfCPCgqnYJ554Ap1OB81mEwcHB9jf38dwOBRzlXOxXC5xfn4uBQNiOs7OzsSoXq/X8N5vNfNjQaGqKmw2G5k7Jsq99zJWMpGLopAfGrXee9y7dw+9Xg+DwQBVVeH27dvY3d2VxP50OpU08GazwcHBgRjRAGR7qWlcFIWkqWlmFkUhJiqLC2dnZ3I90YRl8psFC6B+pIRmaVmW0qASqA35tAjTbDYlCQ2EBpVpU8zVarXFEU8xMkz0M91P45ipfz6ZQN48G0QypT8ej9Fut3FwcCDXIE1vAHjNa14jzHNuk8d648YNAMDx8TFarRY6nY6cb56HwWAgmBMWTVKjf29vT9jneZ5jMBhgMpkISoXmPNfpdrtbx8xjWywWGAwGghUZDAbCY1+v19jf38fZ2Zmcc84hnxZxzuHg4AAAZJxsYnl6eioJb363sBDEogb3yycW0sQ+r/nHVWZTAsbAOwffaMC3G1sg6dDgMrhlpqjgus3QtLKILmFMZMMELEowEH3dvJKNMW1EmsT7TRjfsYsdTXGfmcAVzm1suknzKxjiYrjHbdsyYBSa4xJZO4uYCoPGEoAH8lkYf9mJxqMF8rnH4kr8LrDBKC87Bpt+E+51TWQbj3zh0T7d4L976h34ln/3k/hbP/4V+JF3/GUAQNsY3C5zdO0a/7/nfxLnVYGW8Vj7OtKbNrCED+x06+vml1m8xjMEc/syCoUmuUvivDwthbfRcAY2CJiTlNFNw9olZrY0jIwIFBrcWexyeBmfknqWKfqk8Bnal1gT1nhYOFmubQLKpDAOuSmRmwwL14KNzjJN75XPJTl+UbTRzgqsywyeiBNp0OhRdRyypUW2tMFsjUatLUydKk790MiMlmywqZPZ2SY2p0zS1MB2AlsaLlpTO7Xs8drANqOeiW5fJ5VtSo+h6ZuOB9ufb9FmTLIO32IzT36GS58zER1T8CZZLyHQCAbFFIAtfUiux/WrJoSd75nQ9jT8Q8PLlO/NMdkqGOLGma3igMyZqU+QuTR272PyPkl9y/Ek6XAmw7cY5SqVSqVSqVQqlepXU4MUwwJg7b1fX17IGNME8BSAv3jpo38N4Es+ecP75OsV/6cGzWA2ZqTxSLMbgOALmHSlOQVAzC8mpWlg05jmb+JP2MSSpihT0Ddv3hTG78XFBay1GI1GmM1m8jfNagA4OTnBzZs3twyy3d1dvO1tb8PZ2ZmYv+Qq0/CmqU8eNs3h9XqNg4MDdLtdwaCQp01sCXV4eIjNZoPd3V3s7u6KAdzv99FqtbC3tycp9GvXrgkSZbPZ4Pj4GJPJZCsZ+/DhQ+Eekw3NdHKKeSGag00meY7YaBGAYGqee+45MSKZ4K+qSgoPPK9MYxtjcOXKFZyengrnnAWDXq+Ha9euybmnecrGp0z5M41urcV6vcZwOMTFxYWkwondWK1WYgwzjU7ed5roBrA1ZvLkaZZynEzTO+dkzFyOJjVNZiJneCw0yDk/XJcMa84Nmzeu12tMJhP5fLVaYTKZCHpmOByiLEtcv35dCh27u7sYDoeYTqcyJ0SjkMnNcRMj85rXvAaTyUSY+jT/ORfL5VKeJqD5TvM4yzJJY+d5LgY5m2jmeS4mcnr85KOPRiNpVHpycoLXv/710oyW3PadnR0pSJE1XlUVBoOBFDR4b5MZ75zD/v6+HCvF64ZJbu57NBrJd0ue53I+U1zS4ybXasCuS8BF/EjpAOeCWVV4IDOwq3Ad+8zALjah+SW1LuKy8e88GODkCMMHRIrPmUS+ZIgDkig3PjTT9K08jKEKy/uGDb+R1esvN/DdFhrTNXyeBTOehpuxqPLAKG4sg3EaUBEGVRPYDOyWOeeNCZiUJmArj7JtUbY91sM28qtvwnf//tfh9Y0Kf/BPfSMA4G+//1/gMNtg6oC1n8dmlCUKeOQwKKLhXaQmH3nmNLZhpOklAFh4OO/RNsGlLHzggs+dR/EyjDfiSmhsF7BigG98ExkcqsjPrmDQTQxrSYn7DFWM2QoTPEl1h2UrFJEHbhN2uIWHNV4aZdrosha+gU10W+euhSI6lYVvoIKVbZ2VPZwWPdxZjDBedbAsBphP21LrsBsL13SwGwtvfWR5B+O5sTCSTDYltpuahsEFUzsxjC0fGPDBmHaN2ki9bBCnXHgxYGP62WemTmOb7bS0PMxwqfmka2wvw7S08fHav2yUkwFOI7uCmM5MuvM9VikkeW3qdDl/YGr/mU88+OQftd5Esz7iTdgQlE0na8Z4NLmZwr6EHUkWrU12/m0TDjsnyiLgbJDMF5ne2JYUI5R0olKpVCqVSqVSfTJ059LffxbAn3mJ5Q4Q4KQPL73/EMC1X/1hfer0MTW3ZAM+mteTyURMPRpim80Gg8EAq9VKECMAxCzvdrvCGiYihOYtTT6mPr332NnZEfOTDGOiO3Z2dtBsNjEej7FeryX9OhwOJTFL9jgToBzb7u4uDg8PBcnBZpdMmAOQtC5QIzJ6vR7G47E0n2RTxvl8LpiHNKV6/fp1jEYjXLlyRYxuNh7sdDrI8xyj0UiwH1VVYT6fYzwei+FJg4+Yj4uLC1xcXGAymUjC/OrVq5IY5nbW6/UW55jjohkOALPZTIxNmtsAJKXMAsd6vRZMxsOHD2GtxWAwwHK5lO0OBgNpIspt0ahkwpp/p0ibPM+FiX1+fo5ut4tms4nlconZbIbz83OcnJwIW5p8bhr9TF7TkDXGSJPIdOw8N2xQSZb4ZcQKTWGeQxZ0iFKhaCSTqU7jmMbvYrFAq9XC+fn5lnm8s7MjRQsWTbgvNsW8uLjA/v6+4IKIEOIx8144OTmRBrO8jmn6ZlmGTqcjCJCiKOQJAmOMGNssxqRs7pOTEylS8DrgfcyCAq9PYop4Ttg09vDwUK5fGv7WWnQ6HeF/Mx3OpwdovDvncP36dXlyo9/vy5MAfIqEBj4NcrLWWai4fv36K/16e+RkN1Xga2fB+PYmNrVrGOnA6AmZNibEji2CMQ0EzELLxmZ2YRuogoHs82hUZwg878pHRASkISZhxAYInPA8C+Z3ZuSzYHBG3vgm3Bu+1YDdlDVipWFhKgfXMGheAJthcNFMAZTtYCwW/WDc2dJLOjYGnmELj6pjgLURw9N5oGwZXLy2hebcoXXtEEBgcMN7FKhT3WPnkJmQ3GYNgNZ+IW5gML/p72UwsfllnFLjYGGx9qUkv1NcdOUNXDS2rQmYkwweeXR3uyix9hkWvoWVz0Oi2lu07QYDu0LhM3RtEdjapkJuPDLjUbkcU99Ez2wiq9vBAujGrogrnyE3FVa+gTYcVr4Baxwyb7BJGOGraHC3TYFVbG65ih0jz8o+unaNwjew8g2cFz28sNzDRy/2sFg3MV+04JyFm+aXks71kwG2DPiP5jhgT4g2gUnM4AT/YcoaY2JcYMBL4jgaxz5iOdhUEQjvV6242yIxZGFqLIqv309xHxwLk9kmMabFDE/S2aFzbDIu9+JUtySsfb1fMerTZeNxhXsHggzhGFwca7YKL6q8nmhbAT4m7K1gY+J2Mr/NHI/NOL2JbHAgJMKjuf4iEElifhsTt3cphY7IXE9554JA4Tb5OlPUiUqlUqlUKpVK9UnQLQDT5O9fKSF4+R/ml//r5DNOH1PimzgCcpDZdJFmn3NOmkQSf0JEA5O4ACSdSeObRiUb4TnnsLOzI6brcDjE0dERBoMBjo6OUFUVhsOhpGivXr0q5vNoNML5+bkYwv1+X8zMoihw+/Zt5HmOW7du4dq1a1gul2IeTqdTnJ+fY3d3V5jiNKSZGmYTRCaCmfRlY8d+vy8NCLMsw2KxEPwHE+fGGJmrVquF09NTSaSTZU0ztyxL3Lt3T4xapnvPzs4kBbzZbPDCCy+IsZrnOabTqTSdpNkLBKO7KAoMBgMxMDudjmzfGCOoDwDSDJSmbrfbxdnZGZxzuLi4QFmWkuqnQc9labxym0yqEz3CBHqv18NqtZIx8Jry3uPhw4eCQeG+eJxs5pliTWhiMzm8Wq2keSJT5lmWCeqD4j45VyzI8FjW67UYspzLNDnN4g+LGmzoyYT6arXCYrGQQtHh4SEePHgg/Pf9/X1MJhP0ej1p3np6eoonn3xS0vjee7mvyMOmQd3tdmVueX2ymJCyzPkUBsfKJxmOj4+xs7Mj66SFhDRpzlQ7iwe8xnmvTSYT4cazWEAMCueM2B5y0efzuRRQmNgmezwtCqSNVM/OzuQ63dnZ2cLxsMGlTRPMj5lcuwE4H1Lf6WNNkbMt5nXlYbyDazZgnNviIYuBfSn9aRcb+Iatt9EISBWzTton0kxv2LBPNi8sYvqcyXDnYPIG6jiwBZYroNMEKg9blnAOaKwqlDFBW7YNbBXS3vnco+wY+EYwBPOZx2Bc4uI1jWCWVoBZ+GCQEomUBQM02wDroUV3GNzQaUxh54jJbhi0Y/PI2F8RALDxFg4GuXFYOYOeDfNk4/YreFSo4JKmoNZ4FPDYeI8MQG4CIgUAcuPRNsDUh/3t2UY0yAMWpYDHNDbVnPsSmyrDyufIfAML18LYZxhhgYVr4TCbYmQ3KHxIYBe+gcqERpNDGxvlkifuM2SmRG4qzKOhXfkMY9dFz64Daxwmmto5Nj4Tw7tOe4exLKoWJlUHH5kd4PnJHk7u7gBkNq8tTFHfi6YE4A3yqUHZi9ztPH7mgKxAzaNODNuQ6PaC7UjNYiCkr12jXl6aPzIx3Ui2y3/5RGOchnuaLOe4BHeemNVMhNuK6fFtE1uqIGlSnElzJr7ja1PVqWya/ECyfR5jHCvRK4JAicdiN7XRn24jTajbwsA4X8+3bMvXY/Woud5y0uqXl1PwyVsv/ucwYfeJTBXe9zb+jteJN1CpVCqVSqVSqVS/+pp67y9+5cVwgvBfJZfT3Vfw4hT4Z5ResfF948YN3LlzB6enp1sM4dTAvbi4kGaUTKQyOTsYDDAcDiVVTZOaZllqXhIFcnp6ik6ng81mgyeeeALHx8cYjUaYTqeYTqeCB7HWYmdnB+PxGOPxWNAoQOBdL5dLNJtNnJ6eSpqYidyqqjAajbBarXB2dobRaCTLM4nMlOvJyQl6vR5arRYODw9hrZWkLA3FdN80kg8ODrBYLMTAJRs8NStpwNMU5bIXFxeCN2k2mzg7OxNu92q1wvn5OZbLJY6OjgRjQi41Wek0KpmsZfKXuBhiMJgopmHtvReTe2dnR5o3kvFOnjJT8cSCLJdL7OzsoNvtYr1eI89zSfNPp1MpgpyenopJT4wMtwEEY3uz2WA+n4thzFQ2AEk/s0iRJtSZTud7afPDNNmd8rOZ7GYqncY80TwsBrAZZYoTYcqaJjkbcLJIROwGnxa4ffs29vf30Wg0cHBwIEbzZDLB7u6umOTPP/883vjGN8ox8diZDJ9MJrh//z5u3bolhjeT2NPpVHAmZLkTJUQTn/PFwhD3S/QIU9Y8ZjLX1+s1lsulNNZkEYlMcD5VwKIQn4xgkYPM96IosNlspPjV7XaxXC4xGAyk2ME5n0wmaLVamM1mgjvhd0iv15N7jU9G8H54HBXM5YjhKF3sqsgPiZMISXCfmdB0MjPSkBIAjHPwWQbDApEYxzSxIyolzwLWpN0QtjiA8HfpthEqNIMzC7NYwecNmNUmYFDi577XDknvTQlvQmrdNWxoatkx8BZwEWPirRGjr2qZmBxtSGK46BtkSw/XDIZfGH8w7TaDYLy+8PWhmPSDizfhre3nMbKbmHTOUHkHB4O2qSK3OrLuvZUGlHNn0TQOLQQDu/C1wU3lMOibHLnN8A03n4LJm8huxScSygpup49q0EL+wjGQN+A7LaCs4G/fg71+Fe7+Q9jDwMP/Iz/0bvxScR2zqo2u3eDueoSbrTGmVRu/vv+L+PDmKq41JqhgcFqFp5dOqz6apkJoVhm+rytYzH0Thc/QMxtJk+emxNy1EHLqDgWCgT6uuuH9BJ9CI/zOehezsokH8yHGF11k0wyuHVP9EZ9hiohcWcVENsJ7Lq8T2HYDafDIJLUtgGzlYcvaQM5WETNCIzhJQad4FOOArRMRaTiXWdvZMq5TxicE2IM1XWYTkunG1vtIjXdb1sZ5alaHA0XdBNPW5jmyZOwxae2zOAf+0nZMPSfCNo/mt2sA6BuZoy0Z8stj0QEGJouYoLQZpjOyP+PM1tjTxLbh8Vz6vbVLFifSqY7j39qej/vN/YsMcpVKpVKpVCqVSvWpk/d+Y4x5GsDXAvjnyUdfC+BfvDqj+tXRKza+79y5g9e97nX4hV/4BTEAyemmOc20NtnWNNcACLOZSWMmqAFIKnVvb0/4yuQbn5+fo9friRndbDalgR65wcvlUpKn+/v7uHPnDm7evAkgGISve93r0O12cXR0hNFoJKiJe/fuYTweixk4Go0AANPpFO12eyv9TDOZeBViMziW4XAoTQCZbF+tVtjb2xN+NVEOqaFM0aQbjUY4OjqS1Ct5xZ1OB6enp7i4uMALL7yA1WolqW42iaThToORBifFZoH9fl+wE9euXUOn0xGDczweCyqFKf48z/HgwQM5bpr4RFYw8c2GhjR7Hz58KPzr6XQqPHY+NdBqtaTJIRnyZVliuVwKexsIxjavkdVqhc1mg16vJ2Yy09A832SSk42ebp+G92KxkGsybfbI7XA5AMIMT3EtAIRnz+uERjrNcmJW+OQA+dabzUaaqRI7QkN3b28PZ2dnODg4gHMOnU4H0+lUTHLOCY+bRvjZ2Rna7TZ2d3dxdnYmBQweF5tS7u3tSUGARYlWqyVJc+JhWKBZLpdixFMpnqaqKjGzF4sFhsOhPFXA6woISfzZbCYNVk9PT7cKZ3yqgIWltBkmAEwmEwAhtT6bzbaetGDD3eFwKE1vieF5XGVWZUCUrML3is8bNW6k2QimdSx80N0Ljei2TW5JgcdmlbA2GOo0E40Rs9usysA2bgQXz5TxSYNmFtAreSbpcVN5+GYefjIjzS1dM4PLYxc/34zvWZSd+NOGNCCs2nVKN9sEvrHLDdatS0ngPBivLjfI1h52E0zysgsUPWAzCgv+xOSNeCI/RYYpBraQRpPka9PoXriGNG+sUAkzu2scVvH746TKkRuHtqlwNWvgd7z+18M0c5gbV5EdTvHwt31WjUPe1Ole+7on4PJg6m8GBra8huaFh8tvwJThmP/4X/n9KHvx2DKgGIQNFaMK/whfDNMvkbdKVHe6qLoO+e4KnXaBP/+Wf47KW+F0D+0KbVMitw4Pqj7mroXbxT5G2QJVvCZWvikJ8QoWa5djWrXhYLDbmKNtCzy/2sedxQh3JjuYzdsox000KgO7JEonFhbjV5drRpa3AbJ1YnDHYgXT2nYTGpjawsPyHFvEhSC8bxcLH7YESiJOaJzHNHa4DurmlGn6OtsEPnbd8DExs6s6yV21gglfZXUSW+43F5PbZRizi4luWcTVKe+tpLT1MDCyLR+3Q0PZxkcNhBnuE8eeiW/2DI24lsalrz3XCAa3JNYZ5vYG8KF5JT8L95ORudhCuyTHQSN7i83t6+JSapzLt7hPfqdz5wHEpwBUKpVKpVKpVCrVq6q/DOAfGGN+CsBPAPgWAE8A+Ouv6qg+Qb1i4xuANNM7Pz8XQ3E4HEoqt9frYbFYYDweo9PpbPGL2+02+v0+Go0G8jzH2dkZBoOBJLi73a6YpOv1Guv1Go1GA1euXIFzDg8fPhTzjE0Td3Z2pAFmlmX4oi/6IkwmE+zv7wunm80jsyzDzZs3cXx8jA996EM4OTkR9jSxDefn51iv17h27ZrgONbrtRht+/v76Ha7YnIXRYGyLPHgwQMxVy8bhJvNBs888wxu3bqF8XgsRvJ6vcadO3fQarUkld3pdPD8889LUWAwGKDT6eDhw4d45pln8MEPflASt0ykj0YjGGPEpAQg46Pp3Wg00Gg0xHjn3BIB0m63hYXORqNMuk8mEzF42ZyQpjpxNTQlU6OeGJvJZILhcIj5fC4FktTA5dj6/T6Wy6UgQ1arlRjKTDqnHHk+JUDRpN/Z2RFjncsy6ZwWMnjNsLEpTWuiY1iU4e+0QSYT6ZzfqqokEU6Dm69Xq5UY8NwnALnm+fTBbDaDcw4nJyd4wxvegE6ng1arJRgfFky4b74ejUa4d++esK/ZEJRPCHAczjlcuXJFmk6m18ZsNhMDnNdtek0NBgNBlYzHY5mjwWAgKXNjjPDEeU/OZjMMBgNkWYbj42OZa2JTyPAnDxyAFDPyPJeGtwDE3Gb6fjweYz6f4+DgAHmeY7lcyvcPz9PjrOKgi8Z0DdPIQrM7C9h1ERpKloGrjSwL5nRR1siROG++YVA3boxGdWbCcs7BwwrXO+ywqE1sa4OxbhEMcBdN6WYGU0V2dwb4bhcut/C5hWvE/WYmNvGL6W0bTMGia1H0QjrdEe0Qmcvhd8SdEGOyhCSJjQcczcF4XFUnfO5aHtkifPgLZ1cx3u0iN2Wd8IYV5vbcN5D5wLyuonN3UbWRGYfcVJj6AiO7wXHVQW4qXLUFft9Tvw0YDbD+6j1UHQvXMCg6VwX3AIRUOlO8QDDnTZk0YozmpmvH+YkpaFMCaAH5LBjl+SSDawBmlsGXLeRrg9aJhb/TR+mBP/lvfi/mtzzyi3BOf/rb/iqeL0uMXRP/dvZr8HPT6zhfd/FVhx9CEfnfk6qDnWwZsSkZnDeYVS20bImu3WDhmrizGOG5810sFy2U0xymNIIJcblHRr76JVxGtgbKDlC16mUay3BsNFSN85KkFoO8Chxrb4OJnq0hGBObNMTk3KUmq49pa6JLXOSD27WRJDYA2HUwm8HiRyuMwTVqg15Y8jGt7RuAfznz1iS/k9uGrHOef+dD6lvS0tHjD+az3zaaTW3wyzYQ8SwJf9xWod7kIwrG5dGc9qiNbG7Hm+3xpWY19+nrc2EqACwuGMAk0W9ZNTmGrSlhUt/F9S5jUlQqlUqlUqlUKtWnVN77f2KM2QfwpwFcB/CzAN7hvX/+1R3ZJ6aPqbklmwQeHByIQQVAzDU2kKTpeHp6KqnN0Wgk3GWywjebjeBROp0OnHM4PT3FbDYTw+vGjRu4ffs2bt68KexmJsMbjYZwkWmePv/889jd3ZWx0cA7Pz/H0dERTk5OJHGbIiuIGCnLEoeHh2JKEinCVPju7q4k22ez2VbKlugOGrJXr17FCy+8IH8Ph0MxZ4n8AEKKnHPHpLD3Hh/+8IdxenqKn/mZn0FVVbh16xZu3bqF8/NzQVoQOUJEBRBSsUSo8Hw0m03cunULd+7cEeORPG6a3EyIM4Xd7XZRlqWkiZl4ZhNPGpA8VzQ2F4uFmN/NZlMQMdPpFGdnZxgOh+j3+3IMLJIQb8GCA43pfr+Phw8fCm+daJnU3OR6ZKmzKEOUS8otJ4KDjRCZHiarm40kWQzgfjgecqbZ4JNNIXneHjx4AGMMFosFdnd3xQwHIE0mmV6nYcynIcit39/fF+wOU+FMM/MYeC3v7OyImT8ejwUBVFUV9vf3MR6PMZvNBC3CwgPxNyxCsXkoDXriR2gy89oqigLdbhd5nkuDTGJozs/PAUAKSnwqg9gUYmSI3Vkul/KkRXrtsBjFe+T8/FyO8+zsDEVRYH9/Xwx5Hi+fBJjP5/LZ46jGdA1TMX3pgFUBWAtTlLW53QopcDQjooRNJ4FgXJvo0rFRZelDcrxh4bOs9sK8h+82UQxCQjtbV/AmBzKaegYuM/ANC7txqHZbtTFpIqokSeICIZ1dtg2q3EQDNRrhidlHvnHZ2n4/o3laBROwakc/L+NycVwmpq3jPk9/9hD/w+od+NJbz+KpwfPI4DDIlnDeIjcVxlUXbVug8gaZ8Tgr+zgre8hNhYVr4mp+ga/o/RL+3Jvejuf/5NvRfeDR+mofk7QeVcuIiW3Ler9hErGVOHbN+L4Hyq4JqWZfHwcNSSaNjQeytYkFCiDbGDFE83nEcJQeBz/j5br4yj/6hzC/bmEcMHqmxPxKBuOB//UrD3Hl4AJ7nQU+erKPRqNCv71GWWXo5AW6+QaVtyiqDIWzsb+ngXMGZmNDcSPiORrLcP585pFtWEQJv8sOUHVi0pp4kzgvZHrznGdFmMd84WGcR7mfSdrfNWMRIJ5Pl0eDtxk53clcch0aw+3jYK5XHYPG3GO1b9CcRiO9NLI8jW9eL+kTBdy2y8KPrSCokvT82iIUYFxMmxsHOa+SXE9MejHxBZ/CYtCltHnEc/sGUDbCvplsl2afsWGmawa+d5gDL59LiNzV671IvOYum+FMyaeGvZVNhsXS7fI+jsY7r5UXIVpUKpVKpVKpVCrVp1ze++8F8L2v9jh+NfWKjW9rrRjDm81Gkto0htnEkGlm8njJYaaZaozBeDzGaDQSA4zGWJZlyPNcmkuyWd3h4SGuXbuGk5MTSe4CkGaSbHT54Q9/WEw4ml7ENBwdHQmKgengw8NDMd7JQb5165awgplcnc/nggBhAne1WmF/f194wpybxWKBK1euAICk0+fzOc7Pz3F8fIx2u4379++j3+9Lqvfu3btYLBYYjUaSbqbZePPmTXzO53wODg8Pkec5FosFbt68KUYuk9ztdlsS3zSyx+Mx8jyXeayqStjNRHDQFAYgpj0Z7sSAbDYbFEUhmA4iO7z32N/flyII2dZM23c6HUFnpE0gaWwSE0IMymV+N/e32Wywu7uLi4uLraaKxMPQdGYjzjzPxeAlLofL8frkeKqq2jJPmexOUSs0vpkgJ1KGzVhTRMpkMhHT+PDwUI5jd3dXECBsGkktl0ucnp5KQ9fJZIIHDx7IkwqcD15LHCuNcj5hQf7+Bz/4Qezu7sq5YJL/7t278pQEELjZDx8+xMXFBVarlTDYiRwhN/vhw4dybZHDzfGQsU8mPdPf6/Uau7u7OD09xenpKdbrNQ4PD7FYLNDpdOTe4TFaa+WpB5ryy+VS5rXZbOL4+Bj3799Ht9uVMXjvt/jj0+kUvV5PUEiPrUxITiPPQkobObApgCwDrAkmeFWDe9mo0qeIE+KDskYwt/MsaRQYzXNr6v01iEywsp2Qlg3mqmsY+Cx85k3AjZgKqJpmG/9gAsvb5ajN4mgSmzJZjsleFxO3TE1HXLBls8CEZZzuJ+A0jBiLrglsfmmIH7z7efh3r3kdvuDabXx2/z6ONkPsNJaovEVmHBZVE/1sjV+cX8WqyvHR8T4u5m2453r43z78DpTfatA6C0Zn0TPRZDSC1qjaAd8h46h8SKJHQ9A1Iqs5Gt00U12jNnq9B7IymKOuCcABVdvXx5J5WJhgBDdiIQABn5LF2yJfeuFDFz2LqmXQmji0P9TGsfGY9VpYHXcAC7hDg/WqiXVvhcobNLMKxngUVQbvDbw39TmIWBDOtWt42NJIE0aXezTHBr4Cym4sVmwgpi6TzC4P85RteB49bOnj+xBmtUXEojSMYE+AaDSTYc25dtu/XStcA3BAMTBoLEOBwLUMstKjatTnzRZx/qMZ7WL6mkZ2ev2yZsR9B/O/TpTTjJYCTuYFD8KCjjO1cW+L+qkAjgcxAO55XRua2QZVVu8HEYGSFk18I94rzoSIuTNywmRM/lJS22yb06kBzvS2LOq2zyXXT3+zWCXvq/GtUqlUqk9zXVy8kt5wKpVK9ekh/c6qZVJchEqlUqlUKpVKpVKpVCqVCjDG3ARw59Ueh0qlUn2cuuW9v/tqD+LVlBrfKpVKpVKpVCqVSqVSqVSXZMLj5jcATF/tsfwqaoBg5t/Co3Vcnwrp3H380rn7+PXxzt0AwD3/mBu/H1NzS5VKpVKpVCqVSqVSqVSqx0HRMHqk0pJExwKYeu+Vh/AxSOfu45fO3cevT2DudJ4R8JgqlUqlUqlUKpVKpVKpVCqVSqVSPTJS41ulUqlUKpVKpVKpVCqVSqVSqVSPlNT4VqlUKpVKpVKpVCqVSqV6PLQG8Gfjb9XHJp27j186dx+/dO4+AWlzS5VKpVKpVCqVSqVSqVQqlUqlUj1S0sS3SqVSqVQqlUqlUqlUKpVKpVKpHimp8a1SqVQqlUqlUqlUKpVKpVKpVKpHSmp8q1QqlUqlUqlUKpVKpVKpVCqV6pGSGt8qlUqlUqlUKpVKpVKpVCqVSqV6pKTGt0qlUqlUKpVKpVKpVCrVIyJjzJ8wxrzPGDM1xhwZY77fGPNrLi1jjDF/xhhzzxizNMb8sDHm175aY/50VZxLb4z5ruQ9nbuXkTHmpjHmHxpjTo0xC2PMB4wxTyWf69y9hIwxDWPM/2CM+Wicl2eNMX/aGGOTZXTuPg6p8a1SqVQqlUqlUqlUKpVK9ejoKwB8D4AvAvC1ABoA/rUxppcs88cAfAeA/wbAFwJ4AOAHjTGDT/FYP21ljPlCAN8C4N9f+kjn7iVkjNkF8B4ABYDfBODNAP5bAONkMZ27l9YfB/AHEeblcxDm6Y8C+EPJMjp3H4eM9/7VHoNKpVKpVCqVSqVSqVQqleqTIGPMIYAjAF/hvf9RY4wBcA/Ad3nv/8e4TAvAQwB/3Hv/N1690X56yBjTB/B+AN8G4E8B+ID3/tt17l5expi/COBLvfdf/jKf69y9jIwx7wTw0Hv/+5L3/g8AC+/9N+vcffzSxLdKpVKpVCqVSqVSqVQq1aOrnfj7LP5+PYBrAP41F/DerwH8CIAv+dQO7dNW3wPgX3nv/69L7+vcvbx+K4CfMsb87xGx89PGmN+ffK5z9/L6twC+xhjzJgAwxnw+gC8D8K74uc7dx6nGqz0AlUqlUqlUKpVKpVKpVCrVr75iUvQvA/i33vufjW9fi78fXlr8IYDXfqrG9ukqY8x/AuBtCDiJy9K5e3m9AcC3Ilxvfx7A2wH8L8aYtff+70Pn7pfT/4hQoPpFY0wFIAPwJ7333xc/17n7OKXGt0qlUqlUKpVKpVKpVCrVo6nvBvB5COnRy7rMvjUv8d5jJWPMawD8VQC/0Xu/+mUW1bl7sSyAn/Lef2f8+6dj88VvBfD3k+V07l6s3wngvwDwnwH4OQBvBfBdxph73vv/LVlO5+5jlKJOVCqVSqVSqVQqlUqlUqkeMRlj/j8I+Imv8t7fST56EH9fu7TKFbw4Ufq46SmEeXjaGFMaY0qEZqF/OL7m/OjcvVj3Afz8pfd+AcAT8bVedy+v/zeAv+i9/8fe+w967/8BgL8C4E/Ez3XuPk6p8a1SqVQqlUqlUqlUKpVK9YjIBH03gP8IwFd77z96aZGPIhhpX5us00QweH/8UzbQT0/9GwCfi5C45c9PAfhH8fWz0Ll7Ob0HwK+59N6bADwfX+t19/LqAnCX3qtQ+7Y6dx+nFHWiUqlUKpVKpVKpVCqVSvXo6HsQkAnfCGBqjGFKdOK9X3rvvTHmuwB8pzHmwwA+DOA7ASwA/H9fjQF/ush7PwXws+l7xpg5gFMy0nXuXlZ/BcCPG2O+E8A/RWB8f0v8gV53v6z+JYA/aYx5AQF18usAfAeAvwPo3H0iUuNbpVKpVCqVSqVSqVQqlerR0bfG3z986f3fA+Dvxdf/E4AOgO8FsAvgvQhc6+mnYHyf6dK5ewl5799njPltAP4CgD+NkFL+du/9P0oW07l7af0hAH8OYV6uALgH4G8A+H8ly+jcfRwy3isDXaVSqVQqlUqlUqlUKpVKpVKpVI+OlPGtUqlUKpVKpVKpVCqVSqVSqVSqR0pqfKtUKpVKpVKpVCqVSqVSqVQqleqRkhrfKpVKpVKpVCqVSqVSqVQqlUqleqSkxrdKpVKpVCqVSqVSqVQqlUqlUqkeKanxrVKpVCqVSqVSqVQqlUqlUqlUqkdKanyrVCqVSqVSqVQqlUqlUqlUKpXqkZIa3yqVSqVSqVQqlUqlUqlUKpVKpXqkpMa3SqVSqVQqlUqlUqlUKpVKpVKpHimp8a1SqVQqlUqlUqlUKpVKpVJ9GsoY85wx5ttf7XGoVJ+JUuNbpVKpVCqVSqVSqVQqlUr12MsY8/eMMd8fX/+wMea7PoX7/t3GmPFLfPSFAP7mp2ocKtWjpMarPQCVSqVSqVQqlUqlUqlUKpXqUZQxpum933y863vvj381x6NSPU7SxLdKpVKpVCqVSqVSqVQqlUoVZYz5ewC+AsAfMcb4+PO6+NmbjTHvMsbMjDEPjTH/wBhzkKz7w8aY7zbG/GVjzAmAH4zvf4cx5oPGmLkx5rYx5nuNMf342VcC+LsAdpL9/Zn42RbqxBjzhDHmX8T9Xxhj/qkx5mry+Z8xxnzAGPPNcd2JMeYfG2MGn9RJU6k+DaXGt0qlUqlUKpVKpVKpVCqVSlXrjwD4CQB/C8D1+HPbGHMdwI8A+ACALwDw9QCuAvinl9b/XQBKAF8K4A/E9xyAPwzgLfHzrwbwP8XPfhzAtwO4SPb3P18elDHGAPh+AHsIxvzXAngjgH9yadE3AvgPAXxD/PkKAP/dKz56leoRkaJOVCqVSqVSqVQqlUqlUqlUqijv/cQYswGw8N4/4PvGmG8F8H7v/Xcm7/1eBFP8Td77D8W3n/He/7FL2/yu5M+PGmP+ewB/DcC3ee83xphJWKze30voNwD4PACv997fjvv/ZgA/Z4z5Qu/9++JyFsDv9t5P4zL/AMDXAPiTH+NUqFSf0VLjW6VSqVQqlUqlUqlUKpVKpfqV9RSArzLGzF7iszcCoPH9U5c/NMZ8FYDvBPBmAEMET65tjOl57+evcP+fA+A2TW8A8N7/fGyK+TkAaHw/R9M76j6AK69wHyrVIyM1vlUqlUqlUqlUKpVKpVKpVKpfWRbAvwTwx1/is/vJ6y0j2xjzWgDvAvDXAfz3AM4AfBmAvw0g/xj2bwD4V/B+celzD8Udqx5DqfGtUqlUKpVKpVKpVCqVSqVSbWsDILv03vsB/HaERHX5MWzrCxA8uP/We+8AwBjzTa9gf5f18wCeMMa8JkGdvBnADoBf+BjGo1I9FtJqj0qlUqlUKpVKpVKpVCqVSrWt5wD8B8aY1xljDowxFsD3IDSW/D5jzNuNMW8wxvxGY8zfMcb8cqb1RxCM7z8U1/lmAH/wJfbXN8Z8Tdxf9yW2838B+PcA/pEx5m3GmLcD+PsAfsR7/yK8ikr1uEuNb5VKpVKpVCqVSqVSqVQqlWpb/zOACiFlfQzgCe/9PQBfipDMfjeAnwXwVwFMALiX25D3/gMAvgMBkfKzAP5zAH/i0jI/joBC+Sdxf38Ml+S99wD+QwDnAH4UwQh/FsDv/HgPUqV6lGXCPaNSqVQqlUqlUqlUKpVKpVKpVCrVoyFNfKtUKpVKpVKpVCqVSqVSqVQqleqRkhrfKpVKpVKpVCqVSqVSqVQqlUqleqSkxrdKpVKpVCqVSqVSqVQqlUqlUqkeKanxrVKpVCqVSqVSqVQqlUqlUqlUqkdKanyrVCqVSqVSqVQqlUqlUqlUKpXqkZIa3yqVSqVSqVQqlUqlUqlUKpVKpXqkpMa3SqVSqVQqlUqlUqlUKpVKpVKpHimp8a1SqVQqlUqlUqlUKpVKpVKpVKpHSmp8q1QqlUqlUqlUKpVKpVKpVCqV6pGSGt8qlUqlUqlUKpVKpVKpVCqVSqV6pKTGt0qlUqlUKpVKpVKpVCqVSqVSqR4p/f8BNmkV4gDiP2AAAAAASUVORK5CYII=", + "text/plain": [ + "
      " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "obj = P.obj.S['SMFG00'].data[0]\n", + "prb = P.probe.S['SMFG00'].data[:]\n", + "likelihood_error = [P.runtime[\"iter_info\"][i]['error'][1] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "iterations = [P.runtime[\"iter_info\"][i]['iterations'] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "fig, axes = plt.subplots(ncols=4, nrows=1, figsize=(18,4), dpi=60)\n", + "axes[0].set_title(\"Object amplitude\")\n", + "axes[0].axis('off')\n", + "axes[0].imshow(np.abs(obj)[100:-100,100:-100], cmap='gray', vmin=None, vmax=None, interpolation='none')\n", + "axes[1].set_title(\"Object phase\")\n", + "axes[1].axis('off')\n", + "axes[1].imshow(np.angle(obj)[100:-100,100:-100], vmin=-np.pi, vmax=np.pi, cmap='viridis', interpolation='none')\n", + "axes[2].set_title(\"Probe\")\n", + "axes[2].axis('off')\n", + "axes[2] = u.PtyAxis(axes[2], channel='c')\n", + "axes[2].set_data(prb[0])\n", + "axes[3].set_title(\"Convergence\")\n", + "axes[3].plot(iterations, likelihood_error)\n", + "axes[3].set_xlabel(\"Iteration\")\n", + "axes[3].set_ylabel(\"Log-likelihood error\")\n", + "axes[3].yaxis.set_label_position('right')\n", + "axes[3].tick_params(left=0, right=1, labelleft=0, labelright=1)\n", + "plt.show()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "94f4d5375db2f655aeda185c89beeef42bb9cecdb7e33c656c383e802f18953c" + }, + "kernelspec": { + "display_name": "Python 3.9.6 64-bit ('cuda11.2': conda)", + "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.9.6" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/templates/notebooks/moonflower_epie.ipynb b/templates/notebooks/moonflower_epie.ipynb new file mode 100644 index 000000000..8ea2c1575 --- /dev/null +++ b/templates/notebooks/moonflower_epie.ipynb @@ -0,0 +1,200 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PtyPy moonflower example\n", + "#### scan model: GradFull\n", + "#### engine: Extended Ptychographic Iterative Engine (EPIE)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from ptypy.core import Ptycho\n", + "from ptypy import utils as u" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# create parameter tree\n", + "p = u.Param()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# set verbose level to interactive\n", + "p.verbose_level = \"interactive\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# set home path and io settings (no files saved)\n", + "p.io = u.Param()\n", + "p.io.rfile = None\n", + "p.io.autosave = u.Param(active=False)\n", + "p.io.autoplot = u.Param(active=False)\n", + "p.io.interaction = u.Param(active=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# max 200 frames (128x128px) of diffraction data\n", + "p.scans = u.Param()\n", + "p.scans.MF = u.Param()\n", + "p.scans.MF.name = 'GradFull'\n", + "p.scans.MF.data= u.Param()\n", + "p.scans.MF.data.name = 'MoonFlowerScan'\n", + "p.scans.MF.data.shape = 128\n", + "p.scans.MF.data.num_frames = 200\n", + "p.scans.MF.data.save = None\n", + "p.scans.MF.data.density = 0.2\n", + "p.scans.MF.data.photons = 1e8\n", + "p.scans.MF.data.psf = 0." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# EPIE reconstrucion engine\n", + "p.engines = u.Param()\n", + "p.engines.engine00 = u.Param()\n", + "p.engines.engine00.name = 'EPIE'\n", + "p.engines.engine00.numiter = 200\n", + "p.engines.engine00.numiter_contiguous = 10\n", + "p.engines.engine00.object_norm_is_global = True\n", + "p.engines.engine00.alpha = 1\n", + "p.engines.engine00.beta = 1\n", + "p.engines.engine00.probe_update_start = 2" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GradFull: loading data for scan MF (161 diffraction frames, 161 PODs, 1 probe(s) and 1 object(s))\n", + "GradFull: loading data for scan MF (reformatting probe/obj/exit)\n", + "GradFull: loading data for scan MF (initializing probe/obj/exit)\n", + "EPIE: initializing engine\n", + "EPIE: preparing engine\n", + "EPIE: Iteration # 200/200 :: Fourier 1.26e+01, Photons 7.42e+01, Exit 3.96e+03\n", + "==== This reconstruction relied on the following work ==========================\n", + "The Ptypy framework:\n", + " Enders B. and Thibault P., \"A computational framework for ptychographic reconstructions\" Proc. Royal Soc. A 472 (2016) 20160640, doi: 10.1098/rspa.2016.0640.\n", + "The ePIE reconstruction algorithm:\n", + " Maiden A. and Rodenburg J., \"An improved ptychographical phase retrieval algorithm for diffractive imaging\" Ultramicroscopy 10 (2009) 1256, doi: 10.1016/j.ultramic.2009.05.012.\n", + "================================================================================\n" + ] + } + ], + "source": [ + "# prepare and run\n", + "P = Ptycho(p,level=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting the results" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
      " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "obj = P.obj.S['SMFG00'].data[0]\n", + "prb = P.probe.S['SMFG00'].data[:]\n", + "likelihood_error = [P.runtime[\"iter_info\"][i]['error'][1] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "iterations = [P.runtime[\"iter_info\"][i]['iterations'] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "fig, axes = plt.subplots(ncols=4, nrows=1, figsize=(18,4), dpi=60)\n", + "axes[0].set_title(\"Object amplitude\")\n", + "axes[0].axis('off')\n", + "axes[0].imshow(np.abs(obj)[100:-100,100:-100], cmap='gray', vmin=None, vmax=None, interpolation='none')\n", + "axes[1].set_title(\"Object phase\")\n", + "axes[1].axis('off')\n", + "axes[1].imshow(np.angle(obj)[100:-100,100:-100], vmin=-np.pi, vmax=np.pi, cmap='viridis', interpolation='none')\n", + "axes[2].set_title(\"Probe\")\n", + "axes[2].axis('off')\n", + "axes[2] = u.PtyAxis(axes[2], channel='c')\n", + "axes[2].set_data(prb[0])\n", + "axes[3].set_title(\"Convergence\")\n", + "axes[3].plot(iterations, likelihood_error)\n", + "axes[3].set_xlabel(\"Iteration\")\n", + "axes[3].set_ylabel(\"Log-likelihood error\")\n", + "axes[3].yaxis.set_label_position('right')\n", + "axes[3].tick_params(left=0, right=1, labelleft=0, labelright=1)\n", + "plt.show()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "94f4d5375db2f655aeda185c89beeef42bb9cecdb7e33c656c383e802f18953c" + }, + "kernelspec": { + "display_name": "Python 3.9.6 64-bit ('cuda11.2': conda)", + "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.9.6" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/templates/notebooks/moonflower_epie_pycuda.ipynb b/templates/notebooks/moonflower_epie_pycuda.ipynb new file mode 100644 index 000000000..34041850e --- /dev/null +++ b/templates/notebooks/moonflower_epie_pycuda.ipynb @@ -0,0 +1,211 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PtyPy moonflower example\n", + "#### scan model: GradFull\n", + "#### engine: Extended Ptychographic Iterative Engine (EPIE) with GPU acceleration" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import ptypy\n", + "from ptypy.core import Ptycho\n", + "from ptypy import utils as u" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Import pycuda engines (DM, RAAR)\n", + "ptypy.load_gpu_engines(\"cuda\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# create parameter tree\n", + "p = u.Param()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# set verbose level to interactive\n", + "p.verbose_level = \"interactive\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# set home path and io settings (no files saved)\n", + "p.io = u.Param()\n", + "p.io.rfile = None\n", + "p.io.autosave = u.Param(active=False)\n", + "p.io.autoplot = u.Param(active=False)\n", + "p.io.interaction = u.Param(active=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# max 200 frames (128x128px) of diffraction data\n", + "p.scans = u.Param()\n", + "p.scans.MF = u.Param()\n", + "p.scans.MF.name = 'GradFull'\n", + "p.scans.MF.data= u.Param()\n", + "p.scans.MF.data.name = 'MoonFlowerScan'\n", + "p.scans.MF.data.shape = 128\n", + "p.scans.MF.data.num_frames = 200\n", + "p.scans.MF.data.save = None\n", + "p.scans.MF.data.density = 0.2\n", + "p.scans.MF.data.photons = 1e8\n", + "p.scans.MF.data.psf = 0." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# EPIE reconstrucion engine\n", + "p.engines = u.Param()\n", + "p.engines.engine00 = u.Param()\n", + "p.engines.engine00.name = 'EPIE_pycuda'\n", + "p.engines.engine00.numiter = 500\n", + "p.engines.engine00.numiter_contiguous = 10\n", + "p.engines.engine00.object_norm_is_global = True\n", + "p.engines.engine00.alpha = 1\n", + "p.engines.engine00.beta = 1\n", + "p.engines.engine00.probe_update_start = 2" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GradFull: loading data for scan MF (161 diffraction frames, 161 PODs, 1 probe(s) and 1 object(s))\n", + "GradFull: loading data for scan MF (reformatting probe/obj/exit)\n", + "GradFull: loading data for scan MF (initializing probe/obj/exit)\n", + "EPIE_pycuda: initializing engine\n", + "EPIE_pycuda: preparing engine\n", + "EPIE_pycuda: Iteration # 500/500 :: Fourier 0.00e+00, Photons 2.03e+01, Exit 0.00e+00\n", + "==== This reconstruction relied on the following work ==========================\n", + "The Ptypy framework:\n", + " Enders B. and Thibault P., \"A computational framework for ptychographic reconstructions\" Proc. Royal Soc. A 472 (2016) 20160640, doi: 10.1098/rspa.2016.0640.\n", + "The ePIE reconstruction algorithm:\n", + " Maiden A. and Rodenburg J., \"An improved ptychographical phase retrieval algorithm for diffractive imaging\" Ultramicroscopy 10 (2009) 1256, doi: 10.1016/j.ultramic.2009.05.012.\n", + "================================================================================\n" + ] + } + ], + "source": [ + "# prepare and run\n", + "P = Ptycho(p,level=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting the results" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
      " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "obj = P.obj.S['SMFG00'].data[0]\n", + "prb = P.probe.S['SMFG00'].data[:]\n", + "likelihood_error = [P.runtime[\"iter_info\"][i]['error'][1] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "iterations = [P.runtime[\"iter_info\"][i]['iterations'] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "fig, axes = plt.subplots(ncols=4, nrows=1, figsize=(18,4), dpi=60)\n", + "axes[0].set_title(\"Object amplitude\")\n", + "axes[0].axis('off')\n", + "axes[0].imshow(np.abs(obj)[100:-100,100:-100], cmap='gray', vmin=None, vmax=None, interpolation='none')\n", + "axes[1].set_title(\"Object phase\")\n", + "axes[1].axis('off')\n", + "axes[1].imshow(np.angle(obj)[100:-100,100:-100], vmin=-np.pi, vmax=np.pi, cmap='viridis', interpolation='none')\n", + "axes[2].set_title(\"Probe\")\n", + "axes[2].axis('off')\n", + "axes[2] = u.PtyAxis(axes[2], channel='c')\n", + "axes[2].set_data(prb[0])\n", + "axes[3].set_title(\"Convergence\")\n", + "axes[3].plot(iterations, likelihood_error)\n", + "axes[3].set_xlabel(\"Iteration\")\n", + "axes[3].set_ylabel(\"Log-likelihood error\")\n", + "axes[3].yaxis.set_label_position('right')\n", + "axes[3].tick_params(left=0, right=1, labelleft=0, labelright=1)\n", + "plt.show()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "94f4d5375db2f655aeda185c89beeef42bb9cecdb7e33c656c383e802f18953c" + }, + "kernelspec": { + "display_name": "Python 3.9.6 64-bit ('cuda11.2': conda)", + "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.9.6" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/templates/notebooks/moonflower_ml.ipynb b/templates/notebooks/moonflower_ml.ipynb new file mode 100644 index 000000000..076acccee --- /dev/null +++ b/templates/notebooks/moonflower_ml.ipynb @@ -0,0 +1,202 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PtyPy moonflower example\n", + "#### scan model: BlockGradFull\n", + "#### engine: Maximum Likelihood (ML)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from ptypy.core import Ptycho\n", + "from ptypy import utils as u" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# create parameter tree\n", + "p = u.Param()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# set verbose level to interactive\n", + "p.verbose_level = \"interactive\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# set home path and io settings (no files saved)\n", + "p.io = u.Param()\n", + "p.io.rfile = None\n", + "p.io.autosave = u.Param(active=False)\n", + "p.io.autoplot = u.Param(active=False)\n", + "p.io.interaction = u.Param(active=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# max 200 frames (128x128px) of diffraction data\n", + "p.scans = u.Param()\n", + "p.scans.MF = u.Param()\n", + "p.scans.MF.name = 'BlockGradFull'\n", + "p.scans.MF.data= u.Param()\n", + "p.scans.MF.data.name = 'MoonFlowerScan'\n", + "p.scans.MF.data.shape = 128\n", + "p.scans.MF.data.num_frames = 200\n", + "p.scans.MF.data.save = None\n", + "p.scans.MF.data.density = 0.2\n", + "p.scans.MF.data.photons = 1e8\n", + "p.scans.MF.data.psf = 0." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# maximum likelihood reconstrucion engine\n", + "p.engines = u.Param()\n", + "p.engines.engine00 = u.Param()\n", + "p.engines.engine00.name = 'ML'\n", + "p.engines.engine00.ML_type = 'Gaussian'\n", + "p.engines.engine00.reg_del2 = True \n", + "p.engines.engine00.reg_del2_amplitude = 1. \n", + "p.engines.engine00.scale_precond = True\n", + "p.engines.engine00.smooth_gradient = 20.\n", + "p.engines.engine00.smooth_gradient_decay = 1/50.\n", + "p.engines.engine00.floating_intensities = False\n", + "p.engines.engine00.numiter = 300" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BlockGradFull: loading data for scan MF (161 diffraction frames, 161 PODs, 1 probe(s) and 1 object(s))\n", + "BlockGradFull: loading data for scan MF (reformatting probe/obj/exit)\n", + "BlockGradFull: loading data for scan MF (initializing probe/obj/exit)\n", + "ML: initializing engine\n", + "ML: preparing engine\n", + "ML: Iteration # 300/300 :: Fourier 0.00e+00, Photons 6.88e+01, Exit 0.00e+00\n", + "==== This reconstruction relied on the following work ==========================\n", + "The Ptypy framework:\n", + " Enders B. and Thibault P., \"A computational framework for ptychographic reconstructions\" Proc. Royal Soc. A 472 (2016) 20160640, doi: 10.1098/rspa.2016.0640.\n", + "The maximum likelihood reconstruction algorithm:\n", + " Thibault P. and Guizar-Sicairos M., \"Maximum-likelihood refinement for coherent diffractive imaging\" New Journal of Physics 14 (2012) 63004, doi: 10.1088/1367-2630/14/6/063004.\n", + "================================================================================\n" + ] + } + ], + "source": [ + "# prepare and run\n", + "P = Ptycho(p,level=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting the results" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
      " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "obj = P.obj.S['SMFG00'].data[0]\n", + "prb = P.probe.S['SMFG00'].data[:]\n", + "likelihood_error = [P.runtime[\"iter_info\"][i]['error'][1] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "iterations = [P.runtime[\"iter_info\"][i]['iterations'] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "fig, axes = plt.subplots(ncols=4, nrows=1, figsize=(18,4), dpi=60)\n", + "axes[0].set_title(\"Object amplitude\")\n", + "axes[0].axis('off')\n", + "axes[0].imshow(np.abs(obj)[100:-100,100:-100], cmap='gray', vmin=None, vmax=None, interpolation='none')\n", + "axes[1].set_title(\"Object phase\")\n", + "axes[1].axis('off')\n", + "axes[1].imshow(np.angle(obj)[100:-100,100:-100], vmin=-np.pi, vmax=np.pi, cmap='viridis', interpolation='none')\n", + "axes[2].set_title(\"Probe\")\n", + "axes[2].axis('off')\n", + "axes[2] = u.PtyAxis(axes[2], channel='c')\n", + "axes[2].set_data(prb[0])\n", + "axes[3].set_title(\"Convergence\")\n", + "axes[3].plot(iterations, likelihood_error)\n", + "axes[3].set_xlabel(\"Iteration\")\n", + "axes[3].set_ylabel(\"Log-likelihood error\")\n", + "axes[3].yaxis.set_label_position('right')\n", + "axes[3].tick_params(left=0, right=1, labelleft=0, labelright=1)\n", + "plt.show()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "94f4d5375db2f655aeda185c89beeef42bb9cecdb7e33c656c383e802f18953c" + }, + "kernelspec": { + "display_name": "Python 3.9.6 64-bit ('cuda11.2': conda)", + "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.9.6" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/templates/notebooks/moonflower_ml_pycuda.ipynb b/templates/notebooks/moonflower_ml_pycuda.ipynb new file mode 100644 index 000000000..720748a1b --- /dev/null +++ b/templates/notebooks/moonflower_ml_pycuda.ipynb @@ -0,0 +1,223 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PtyPy moonflower example\n", + "#### scan model: BlockGradFull\n", + "#### engine: Maximum Likelihood (ML) with GPU acceleration" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import ptypy\n", + "from ptypy.core import Ptycho\n", + "from ptypy import utils as u" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Import pycuda engines (DM, RAAR)\n", + "ptypy.load_gpu_engines(\"cuda\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# create parameter tree\n", + "p = u.Param()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# set verbose level to interactive\n", + "p.verbose_level = \"interactive\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Nr. of frames in a block\n", + "p.frames_per_block = 20" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# set home path and io settings (no files saved)\n", + "p.io = u.Param()\n", + "p.io.rfile = None\n", + "p.io.autosave = u.Param(active=False)\n", + "p.io.autoplot = u.Param(active=False)\n", + "p.io.interaction = u.Param(active=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# max 200 frames (128x128px) of diffraction data\n", + "p.scans = u.Param()\n", + "p.scans.MF = u.Param()\n", + "p.scans.MF.name = 'BlockGradFull'\n", + "p.scans.MF.data= u.Param()\n", + "p.scans.MF.data.name = 'MoonFlowerScan'\n", + "p.scans.MF.data.shape = 128\n", + "p.scans.MF.data.num_frames = 200\n", + "p.scans.MF.data.save = None\n", + "p.scans.MF.data.density = 0.2\n", + "p.scans.MF.data.photons = 1e8\n", + "p.scans.MF.data.psf = 0." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# maximum likelihood reconstrucion engine\n", + "p.engines = u.Param()\n", + "p.engines.engine00 = u.Param()\n", + "p.engines.engine00.name = 'ML_pycuda'\n", + "p.engines.engine00.ML_type = 'Gaussian'\n", + "p.engines.engine00.reg_del2 = True \n", + "p.engines.engine00.reg_del2_amplitude = 1. \n", + "p.engines.engine00.scale_precond = True\n", + "p.engines.engine00.smooth_gradient = 20.\n", + "p.engines.engine00.smooth_gradient_decay = 1/50.\n", + "p.engines.engine00.floating_intensities = False\n", + "p.engines.engine00.numiter = 300" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BlockGradFull: loading data for scan MF (161 diffraction frames, 161 PODs, 1 probe(s) and 1 object(s))\n", + "BlockGradFull: loading data for scan MF (reformatting probe/obj/exit)\n", + "BlockGradFull: loading data for scan MF (initializing probe/obj/exit)\n", + "ML_pycuda: initializing engine\n", + "ML_pycuda: preparing engine\n", + "ML_pycuda: Iteration # 300/300 :: Fourier 0.00e+00, Photons 9.00e+01, Exit 0.00e+00\n", + "==== This reconstruction relied on the following work ==========================\n", + "The Ptypy framework:\n", + " Enders B. and Thibault P., \"A computational framework for ptychographic reconstructions\" Proc. Royal Soc. A 472 (2016) 20160640, doi: 10.1098/rspa.2016.0640.\n", + "The maximum likelihood reconstruction algorithm:\n", + " Thibault P. and Guizar-Sicairos M., \"Maximum-likelihood refinement for coherent diffractive imaging\" New Journal of Physics 14 (2012) 63004, doi: 10.1088/1367-2630/14/6/063004.\n", + "================================================================================\n" + ] + } + ], + "source": [ + "# prepare and run\n", + "P = Ptycho(p,level=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting the results" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
      " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "obj = P.obj.S['SMFG00'].data[0]\n", + "prb = P.probe.S['SMFG00'].data[:]\n", + "likelihood_error = [P.runtime[\"iter_info\"][i]['error'][1] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "iterations = [P.runtime[\"iter_info\"][i]['iterations'] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "fig, axes = plt.subplots(ncols=4, nrows=1, figsize=(18,4), dpi=60)\n", + "axes[0].set_title(\"Object amplitude\")\n", + "axes[0].axis('off')\n", + "axes[0].imshow(np.abs(obj)[100:-100,100:-100], cmap='gray', vmin=None, vmax=None, interpolation='none')\n", + "axes[1].set_title(\"Object phase\")\n", + "axes[1].axis('off')\n", + "axes[1].imshow(np.angle(obj)[100:-100,100:-100], vmin=-np.pi, vmax=np.pi, cmap='viridis', interpolation='none')\n", + "axes[2].set_title(\"Probe\")\n", + "axes[2].axis('off')\n", + "axes[2] = u.PtyAxis(axes[2], channel='c')\n", + "axes[2].set_data(prb[0])\n", + "axes[3].set_title(\"Convergence\")\n", + "axes[3].plot(iterations, likelihood_error)\n", + "axes[3].set_xlabel(\"Iteration\")\n", + "axes[3].set_ylabel(\"Log-likelihood error\")\n", + "axes[3].yaxis.set_label_position('right')\n", + "axes[3].tick_params(left=0, right=1, labelleft=0, labelright=1)\n", + "plt.show()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "94f4d5375db2f655aeda185c89beeef42bb9cecdb7e33c656c383e802f18953c" + }, + "kernelspec": { + "display_name": "Python 3.9.6 64-bit ('cuda11.2': conda)", + "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.9.6" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/templates/notebooks/moonflower_raar.ipynb b/templates/notebooks/moonflower_raar.ipynb new file mode 100644 index 000000000..60f7f4fe1 --- /dev/null +++ b/templates/notebooks/moonflower_raar.ipynb @@ -0,0 +1,194 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PtyPy moonflower example\n", + "#### scan model: BlockFull\n", + "#### engine: Relaxed Averaged Alternate Projections (RAAR)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from ptypy.core import Ptycho\n", + "from ptypy import utils as u" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# create parameter tree\n", + "p = u.Param()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# set verbose level to interactive\n", + "p.verbose_level = \"interactive\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# set home path and io settings (no files saved)\n", + "p.io = u.Param()\n", + "p.io.rfile = None\n", + "p.io.autosave = u.Param(active=False)\n", + "p.io.autoplot = u.Param(active=False)\n", + "p.io.interaction = u.Param(active=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# max 200 frames (128x128px) of diffraction data\n", + "p.scans = u.Param()\n", + "p.scans.MF = u.Param()\n", + "p.scans.MF.name = 'BlockFull'\n", + "p.scans.MF.data= u.Param()\n", + "p.scans.MF.data.name = 'MoonFlowerScan'\n", + "p.scans.MF.data.shape = 128\n", + "p.scans.MF.data.num_frames = 200\n", + "p.scans.MF.data.save = None\n", + "p.scans.MF.data.density = 0.2\n", + "p.scans.MF.data.photons = 1e8\n", + "p.scans.MF.data.psf = 0." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# RAAR reconstrucion engine\n", + "p.engines = u.Param()\n", + "p.engines.engine00 = u.Param()\n", + "p.engines.engine00.name = 'RAAR'\n", + "p.engines.engine00.numiter = 80\n", + "p.engines.engine00.beta = 0.9" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BlockFull: loading data for scan MF (161 diffraction frames, 161 PODs, 1 probe(s) and 1 object(s))\n", + "BlockFull: loading data for scan MF (reformatting probe/obj/exit)\n", + "BlockFull: loading data for scan MF (initializing probe/obj/exit)\n", + "RAAR: initializing engine\n", + "RAAR: preparing engine\n", + "RAAR: Iteration # 80/80 :: Fourier 3.97e+01, Photons 2.19e+01, Exit 2.67e+00\n", + "==== This reconstruction relied on the following work ==========================\n", + "The Ptypy framework:\n", + " Enders B. and Thibault P., \"A computational framework for ptychographic reconstructions\" Proc. Royal Soc. A 472 (2016) 20160640, doi: 10.1098/rspa.2016.0640.\n", + "================================================================================\n" + ] + } + ], + "source": [ + "# prepare and run\n", + "P = Ptycho(p,level=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting the results" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
      " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "obj = P.obj.S['SMFG00'].data[0]\n", + "prb = P.probe.S['SMFG00'].data[:]\n", + "likelihood_error = [P.runtime[\"iter_info\"][i]['error'][1] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "iterations = [P.runtime[\"iter_info\"][i]['iterations'] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "fig, axes = plt.subplots(ncols=4, nrows=1, figsize=(18,4), dpi=60)\n", + "axes[0].set_title(\"Object amplitude\")\n", + "axes[0].axis('off')\n", + "axes[0].imshow(np.abs(obj)[100:-100,100:-100], cmap='gray', vmin=None, vmax=None, interpolation='none')\n", + "axes[1].set_title(\"Object phase\")\n", + "axes[1].axis('off')\n", + "axes[1].imshow(np.angle(obj)[100:-100,100:-100], vmin=-np.pi, vmax=np.pi, cmap='viridis', interpolation='none')\n", + "axes[2].set_title(\"Probe\")\n", + "axes[2].axis('off')\n", + "axes[2] = u.PtyAxis(axes[2], channel='c')\n", + "axes[2].set_data(prb[0])\n", + "axes[3].set_title(\"Convergence\")\n", + "axes[3].plot(iterations, likelihood_error)\n", + "axes[3].set_xlabel(\"Iteration\")\n", + "axes[3].set_ylabel(\"Log-likelihood error\")\n", + "axes[3].yaxis.set_label_position('right')\n", + "axes[3].tick_params(left=0, right=1, labelleft=0, labelright=1)\n", + "plt.show()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "94f4d5375db2f655aeda185c89beeef42bb9cecdb7e33c656c383e802f18953c" + }, + "kernelspec": { + "display_name": "Python 3.9.6 64-bit ('cuda11.2': conda)", + "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.9.6" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/templates/notebooks/moonflower_raar_pycuda.ipynb b/templates/notebooks/moonflower_raar_pycuda.ipynb new file mode 100644 index 000000000..18ebab653 --- /dev/null +++ b/templates/notebooks/moonflower_raar_pycuda.ipynb @@ -0,0 +1,217 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PtyPy moonflower example\n", + "#### scan model: BlockFull\n", + "#### engine: Relaxed Averaged Alternate Projections (RAAR) with GPU acceleration" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import ptypy\n", + "from ptypy.core import Ptycho\n", + "from ptypy import utils as u" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Import pycuda engines (DM, RAAR)\n", + "ptypy.load_gpu_engines(\"cuda\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# create parameter tree\n", + "p = u.Param()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# set verbose level to interactive\n", + "p.verbose_level = \"interactive\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Nr. of frames in a block\n", + "p.frames_per_block = 20" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# set home path and io settings (no files saved)\n", + "p.io = u.Param()\n", + "p.io.rfile = None\n", + "p.io.autosave = u.Param(active=False)\n", + "p.io.autoplot = u.Param(active=False)\n", + "p.io.interaction = u.Param(active=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# max 200 frames (128x128px) of diffraction data\n", + "p.scans = u.Param()\n", + "p.scans.MF = u.Param()\n", + "p.scans.MF.name = 'BlockFull'\n", + "p.scans.MF.data= u.Param()\n", + "p.scans.MF.data.name = 'MoonFlowerScan'\n", + "p.scans.MF.data.shape = 128\n", + "p.scans.MF.data.num_frames = 200\n", + "p.scans.MF.data.save = None\n", + "p.scans.MF.data.density = 0.2\n", + "p.scans.MF.data.photons = 1e8\n", + "p.scans.MF.data.psf = 0." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# RAAR reconstrucion engine\n", + "p.engines = u.Param()\n", + "p.engines.engine00 = u.Param()\n", + "p.engines.engine00.name = 'RAAR_pycuda'\n", + "p.engines.engine00.numiter = 80\n", + "p.engines.engine00.numiter_contiguous = 10\n", + "p.engines.engine00.probe_update_start = 1\n", + "p.engines.engine00.beta = 0.9" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BlockFull: loading data for scan MF (161 diffraction frames, 161 PODs, 1 probe(s) and 1 object(s))\n", + "BlockFull: loading data for scan MF (reformatting probe/obj/exit)\n", + "BlockFull: loading data for scan MF (initializing probe/obj/exit)\n", + "RAAR_pycuda: initializing engine\n", + "RAAR_pycuda: preparing engine\n", + "RAAR_pycuda: Iteration # 80/80 :: Fourier 3.85e+01, Photons 2.40e+01, Exit 3.33e+00\n", + "==== This reconstruction relied on the following work ==========================\n", + "The Ptypy framework:\n", + " Enders B. and Thibault P., \"A computational framework for ptychographic reconstructions\" Proc. Royal Soc. A 472 (2016) 20160640, doi: 10.1098/rspa.2016.0640.\n", + "================================================================================\n" + ] + } + ], + "source": [ + "# prepare and run\n", + "P = Ptycho(p,level=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting the results" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3IAAADpCAYAAABhngX8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAk6AAAJOgHwZJJKAAEAAElEQVR4nOz9eZwkWX7ViX7vNTPft9gjIzKzMiurq6qrSurqTUJSAZKQ1FpArJKGQQMMi1gHGJiB94ABHsPw3jAMDDDDMjADaIS2BiRaTdOL1Ei9qPetlq7uri2zMjL2CHcP32259/1x7XfdI7uq1OoudWW17FefrPBwNze7ds3Nw46d8ztHWWspqqiiiiqqqKKKKqqooooq6tVT+pUeQFFFFVVUUUUVVVRRRRVVVFG/uiqAXFFFFVVUUUUVVVRRRRVV1KusCiBXVFFFFVVUUUUVVVRRRRX1KqsCyBVVVFFFFVVUUUUVVVRRRb3KqgByRRVVVFFFFVVUUUUVVVRRr7L6mgZySqmLSqn/oJR6Sin1jFLqHyilSvlrf1Ap9b+/yPt++cvc3u9QSj3wlYz5y9jm31BK/Xf547+plPqO/PGfU0rVvoz1DV/uMRZVFLw6zseXGkdRRf16K6VUppT6tFLqcaXUW381f1OKc6mor/VSSm0qpX4y/3v2WaXUO5RS977S4yrq11d9zQI5pZQC/j3ws9ba1wD3Ag3gf/qV3mut/eYvc7O/A/iqArnFstb+NWvtz+e//jngVw3kiirq16J+PZ6PRRX1NVATa+3D1tqHgBj444svKqWCV2ZYRRX1ylb+N+1ngF+01l6z1j4A/GVg46s8juIc/HVeX7NADvh2YGqt/ZcA1toM+G+BP7RwV/GSUuqdSqnPK6X+urxxkZVSSv33SqmPKaUeVUr9fxae//35c59RSv0/SqlvBr4f+F/yO5jXFgejlPptSqmPKKU+pZT6eaXURv7831BK/Wul1LuVUteVUr9LKfV3lFKP5WOL8uWuK6X+Z6XUR/N/99y+w0qpf6WU+j1KqT8DbAH/WSn1n19gn36PUupf5Y+vKqU+lO/j/3jb+l5w34sq6suoO+18/FdKqX+qlHq/UuoLSqnfuvDyVj6Op5RSf2fhPf9EKfVxpdQTt237/5ffjX1UKfV38+fWlFL/Lh/rx5RS3/IyzGFRRb2S9X7gHqXUtyql/rNS6seBx5RSFaXUv8z/Zn1KKfVtC+95sXP6h/O/Y59WSv2z4mK0qFdhfRuQWGv/qTxhrf008AGl1P+Ss9iPKaV+CCA/b35RKfVvlVKfU0r9G+Xqe5RSPy3ryJf7ufzxd+XXZ59UjhFv5M9fV0r9NaXUB4AfUEp9b77ODyil/qFS6u35cnWl1P+d/w36lFLqt+fP/0Gl1L9/kb9z351v7zNKqV94qfUUdWdU+EoP4NewHgQ+sfiEtfZMKfU8ICDoG4CHgDHwMaXUf7TWflyWV0p9F/CafDkFvE0p9ZuAE+CvAN9irT1WSi1ba0+VUm8D3m6t/bcvMJ4PAL/BWmuVUn8E+IvAX8hfu4b7UngA+BDwu621f1Ep9TPA9wE/my93Zq39BqXU7wf+N2Dx4nNxP/+hUurPA99mrT3+FebpHwD/xFr7o0qpP/Ur7bu19n2/wvqKKuqF6k47HwGuAL8Zd/79ZzW/OfIw8HpgBnxeKfWPrLU3gb+SrzcAfkEp9fXADvA7gfvzc7uTr+MfAH/fWvsBpdRl4F3Aa3+1k1ZUUXdCKaVC4HuAd+ZPfQPwkLX2OaXUXwCw1n6dUup+4N1qLi/7onMaGAE/hDtfE6XUPwZ+H/CjX709Kqqor7ge4ra/aXn9LtzfkNcBq7jPvVw3vR73t3AX+CDwLcB7gH+mlKpba+Xc+Cml1CrwV4HvsNaOlFJ/CfjzwN/M1zW11j6ilKoATwG/KT8ff2JhLH8FeK+19g/lf5s+qpQS1dbD3PZ3DpgC/3xhXcsvtZ58vEW9wvW1DOQUYH+F599jrT0BUEr9e+AR4OMLy35X/u9T+e8N3IXk64B/KyDJWnv6JYznIu7kvACUgOcWXvtP+R+0x4CA+R/Lx3AXm1I/sfDz738J2/xS6luA350//n+A/zl//GL7XgC5or6cutPOR4CfttYa4Cml1LPA/fnzv2Ct7efj+CxwF3AT+EGl1I/gvjcv4G68fBb3x+9f5Bepb8/X8R3AA0op2VZLKdW01g6+xLEVVdSdUFWl1Kfzx+8H/i/gm4GPWmvlb9gjwD8CsNZ+Til1Ayedhhc+p1PgjbgLXIAqcPhrvytFFfVVqUeAn8hVJwdKqV8C3gyc4c6bHYD8vLqS3+x7J/DblFL/Fnfz/i/ibjI+AHwwP09KuBv9Uj+V/7wfeHbhfPwJ4Efyx98FfL/KfRSACnA5f/xCf+eWgPfJuhb+lr7Yep788qaoqJezvpaB3BPMAQoASqkWcAl4BveH5PYLy9t/V8D/11r7z25bz595gWV/pfpHwN+z1r5NKfWtwN9YeG0GYK01SqnEWivrNpw/RvZFHn8ptbh85SVek3rBfS+qqC+z7rTz8YXWL7/PFp7LgFApdRX474A3W2u7ykmTK9baVCn1DcBvAf4L4E/jZKQa+CZr7eTLGFdRRd0pNbHWPrz4RH5RuXgnXvHi9ULnmAL+tbX2//1yDLCool6hegL4PS/w/EudD1/0tyV//FPAnwJOgY9ZawfKnWjvsdb+3hdZl5yDL7U9hVN4ff7ck0p944uM5aVuuH7Reoq6M+pruUfuF4BaLkOUhtD/FfhX1tpxvsx3KqWWlVJVnDHCB29bx7twPTyiS95WSq3n6/5BpdRK/rzQzwOg+SLjaQO38sd/4Mvcpx9a+Pmhl1rwBcZyoJR6rVJK46RgUh/EXYCCk7dIvdi+F1XUl1N32vkIrrdAK9c/dzfwUn+kWrg/nH3l+lu/J99WA2hba9+BMxh6OF/+3ThQR77cwxRV1NdmvY/8b0cuqbzM/Fx6oXP6F4DfI39P8tfv+qqPuqiivrJ6L1BWSv1ReUIp9WagC/yQUipQSq0Bvwn46K+wrl8E3gD8UeZM24eBbxHJv1Kqpl7YEfNzwN1KqSv57z+08Nq7gP8mB4UopV7/K4zjQ8Bvzm9cLv4t/dWup6ivYn3NArmc1fqduIu1p4Av4CRQf3lhsQ/g5ISfBv7dQj+OzdfxbuDHgQ/lssd/CzSttU/g3PZ+SSn1GeDv5e/7SeC/V64Z9Jy5Ao6Be6tS6v3Ar9S39mJVVkp9BPizOKOIl6r/E/hPKjc7Af5fONnXe4G9heX+LPCnlFIfw4FN4MX3/cscd1G/zusOPB/BXWz+EvCfgD9urZ2+xPg/g5N0PgH838xBZhN4u1Lq0Xxdcl7+GeBNyhmgfJbb3P6KKuprqP4xEOTn5E8Bf9BaK3f7v+icttZ+Ftf78+78vHkPTqpcVFGvmlr4m/adysUPPIG7zvtx4FHgM7jrrb9ord3/FdaV4a7Pvif/ibX2CPiDwE/k58mHmcv/F987Af4k8E7lzE8OgH7+8v8IRMCjSqnH899fahxHOFnmv8//lgqo/FWtp6ivbqm5iq8ogPyu/iettXfUHUKl1HXgTV+CeUlRRX3N1K/V+ZhLI1/KCKWooooqqqii7vhSSjWstcOcMfs/gKestS+Xj0JRd3h9zTJyX04ppbZw1PLffaXHUlRRv96rOB+LKqqooooq6lesP5qbpzyBU1YV3ga/jqpg5IoqqqiiiiqqqKKKKqqool5lVTByRRVVVFFFFVVUUUUVVVRRr7IqgFxRRRVVVFFFFVVUUUUVVdSrrF40R+69732vTdOUcrnMZDJhOp0Shm7xMAyZzWaILPP09JQ4jgGo1+tEUcTS0hJJkgBgjMEYQ7PZ5MaNG4zHY87Ozmi1WmitSZKE2WzGeDwmDEPCMOTg4ICTkxOCICAMQy5dusTGxgZJkrCzs8NkMiEIApaXlwmCgLvvvtuPczAYkKYps9mMpaUlrLUMh0OCIODw8JBKpUKSJIzHY9I0ZW9vjyRJ0Frz7d/+7YRhyF133cVzzz1HqVSi2WyilKJcLnN6eopSCmMMcRxz6dIlWq0WjUaDZ555hiiKqFarVCoVJpMJ1WqVWq1GkiRkWcZoNOI1r3kNh4eHlEolgiBgMplQKpVotVpEUUSSJCRJQrfb5ezsjDRN6fV6PP300zz55JO8+93vpt1uMxi4bGFZd6lUQmuNMYZyuUyWZVSrVf9cvV7n7OwMpRTWWvr9PktLSwwGA5RSaK1pNpv+uI3HY2q1GkEQUK/XSdOUMAyp1WrUajXOzs5oNpvMZjMajQZhGNLpdAiCAGMM06kzAYzjmNFoRKVSoVqtkqYp4/GYJEmoVqssLS0RRRH1ep21tTXW19d54xvfyOnpKWtra/4zVy6X0Vozm838fs1mM+I4Rmvt565arfrjORwOWV9f5/DwEKUU3/Zt3/ZSmStf9br77/+v1gZgwwWJswWVuGGqTKEMoMBE1i2n3TIYUEZh8z1SFlQGGAXKYiKwtQwyhR5rUPl2LC523ua/BxYS5darrEuMCew8nSZT+fYUKnX/rNuEK+Me61gRDhXhFIIpREO3DqvduEwIQQyt5yZEhwPUeIrp9kBryDLMZIIKI1QUosplbBy71wCSBFUqYbMMm6aQZW6q0hSAt936GABlFfGWrYd51+6necvWw7zt1scICfje7Tf46X3HrU8ysymRCvit22/k7bc+QaQCAPpmQkWFJDbjB1/3vTz1l+4j25hx/5+/zsG/WuXB1X0O/uxdPP1765iyoXIYurTHfOp0AjrGzb2G6ZohnCiyUj6V9YzGsyFZBcIxpHU3L1nZEo0UKoO4YwnHbs5l7lBgSpbKocIG+WFK83kt58tYMCWwCnSKTwQKZhadwtKTE0q3utjeGWYw4J3Pf5zjbMROGtLWCVOrCZQlsW7OKyrjxJQxVnNmKoxtmZqasRkOqKiMzCpmNmBkI6Y2oqmnlDC0dcK1S3t31HkGoJQq+giK+pora+0dda698Y1vtNeuvZBJcFFFvXrrrW996yettW98pcfxQvWiQG44HLK0tES5XCaKIiaTib+Qn81mVCoVLl++zMnJCfV63YOOfr9Ps9kkyzIP9OTCfXl52QMvrTWj0YhOp+MBRrlc9hfg1lqUUgRBQBRFjEYjer2ev2ivVCoEQcDGxoYf797eHnEcMxgMPPiazWYeYBhj2NraolwuMx6PqVQqHB4ect9991EqlTz4azabpGlKqVQiSRI/B8PhkCzL0FqjtWZ5eZnRaESaphwcHHjAdHJywurqql+HtdbvQ61W86Dm+PiYK1euUCqVmEwmHoAJaK5WqwDs7Oxw11130ev10FrT6XQYDoeEYchoNKJarWKtpdFo+GWm06kHiQKG+/0+WmuUUnS7Xb+tVqtFpVJhNBoxm80k8BWllAd4g8GARqOB1pp+v0+pVCIMQ6bTKVEUEYYhaZpyfHzM5uYmYRiysbHhQfXy8jKnp6eMx2NWVlY8iJfxGWMYDoekacpkMuHatWtUq1XG4zHdbpdGo0GlUuHChQtkWUYYhvR6PQ+AgyBgPB57YDgcDplMJrRaLay1HsjeaWW1u/A+F+mZR+a6C3iL1TmYwwE7iwNIygjYy5c3oFJBdQqVWZhpBzSUrNO97ltjgxzYCTi0ah4JKuNSFhUH/jlTMiir3DoUkM5BR1a12ECR1mC2pLA6BxXWgY9gBnG7xtIXQkpHE4Isw04mWGPQ5bL7zjDGAbX8O8BmGQSBe81ayDKssSitQAcorQgJCJTmLVsPg1K8Zeth3nHrk6RASsY7bn1y/jp44Pa2Wx9DEzA0U8oqIrGG02zGx2bbPP3f3Uf5RBFfTnn+n19g9tkWHywv0/gWTTC1VA5DJtsZ9ecDpiuW6qEDuGnVAVYbwKVfyDh8fUSp60Bb+dSBOJW5ZZKWm98gzg+9gqjvjpEpW3Ss/PENZm5egxjIHEBDAbGbZ2UceM7KCp1YghlkJTf/4dSSVQJsGECgeefzH+d77v4N/PhT76WsMgIFAxNRsoZIGSrKAeUAS5J/ODt6TIZiagPGJiImYGoiSiqjohLGpkwnHBDcUZeVRRVV1Fezrl27xk//9E+/0sMoqqiXtZRSz7zSY3ixelEgl6Yp/X6f9fV1jDH+gn46nVIulymVSnS7XQCiKPIX/QLG5AJfKUUYhmitPQMmF+7yepqm/mK70Wgwm83QWp9jmSaTCfv7+xhjqFQqfpzGGIIgoNfrMRwOiaKIIHAXaUEQMBqNWFlZoVKpUC6XWVpa4ujoiK2tLcbjMVmWeTA4Ho8xxnB6espsNqNcLlOpVPxYptOpB2bC+iwvL3N8fEy73SaOY0old+u91+tRr9fJsozl5WWyLOPWrVvU63W/nkqlQq/Xo1KpYIy7Uo/j2LNlcRxTr9dZWlryTNfR0RHHx8dUKhWm06lnorTWlEolPy4BvNZaZrOZn+MgCFBKUSqV/LESYJ2mqd9XYQmzLDt3PKy1JEmCMYZSqcR0OvXAV/5lWcZ4PMZaSxzHnp1sNBoeFCdJQhiGXLlyxTOQQRCQZRndbpfT01Pq9TrNZpP7778fpRTD4dCvazKZYK31Y6pUKvT7fdrtNkdHR9RqNcrlsgfnURRxJxr7CECzArbysoFFqLb8mnrOqCmwykIwB2bK5OxNDsKUAZ0qstDOwZuwaPnrnp3LwRpGOYYvlG2fZ+8cu2Y9gLQ6B5TKrdwGFqNUPnZhjZTDkcat0gSgM5ishkCVyrAGozwPPAggTSH/3CIgLmfsyM8RABUE2DQBpSEI+N6Lb/RzhLW8a/fTjI1j64L8xsRbth7m7bc+gQFMTqNl1qKVJcNiMAyM5ciU2YlXuPvfD3n+u5tkSUDyVJ0wUWQGsrKAKoutZZRPtWfQpmsw3U6oPx0Rdyw3vzPANGL0MCQYO2QcjhxjpxM3qWndHaNg4sCfTvN5mil06ubR5symm3cIY+tuAgQKnVpMoFDWOpYumM+3sIRWbs5kBjOL87n4IF1jKSlLsnBq1HJgBw7INbVDmYkNHbCzARmagamQ2BCY0dRTAhf3R/QlfO6LKqqooooqqqivvF4UyM1mLs9zNBp5dkUuipMkYTgcMhqNvCSuXC6zsbFBr9cjy7JzwERrTRiGHviIrG4ymZAkCbVajbW1Nc/6TKdTKpUKnU7HS+iUUhwcHDAYDLjnnnu8lPP69eseBPT7fRqNht+GgEuR4pXLZbrdLleuXCGOY05OTrhy5QorKyueDRImUFhGASW1Wo04jr+IrTo7O/NsnkhPl5aW6PV6jEYjtNbs7u6ysbHB+vq6n4MgCCiVSoxGI5IkodFoeBAroDMMQ27dusXR0RE3btzg2Wef5amnnqJcLjObzfw6BEjFcez3ReScSimSJPGMolKK0WjkJbO1Ws2zYDqXsVlrPeMmYFqOA+DBrQBAAfeyvSAIaLVaTKdTD9yvXr3qAdxwOKRer7O1tcV0OmV5edlLPqWq1aof09HRkWcoDw4OyLKMZrNJo9HwQFPmQtjPRqNBEATs7u4ShiFBEPjP9B1XCgei7ALYMvMLeJTFBu45BLihvLRRpJfYxfWRA7Z8TkV2SQ7+lAMCaDyj5kFh7Fg5G+TrypQHmSp1Ekwb5BvTDgBabTEli55piJzMUqUCKHMgkq/PKEhqiqAVUK6VUUHgVh+FLiJ8EXBbC0niwN3tx0/lyMZYz+bZ/HtByiAIN8sllRmBUiQ2Q6MJlGJmExJrGJsZvzS5m914iXfuPcDOH6zRfAr4QpVw5NizYOb2Kxq4x7W9ElhLWssljTFsbHc5Gq2y/BnFyRss5dYMdbNEVnFzlGWKpGUxZYUJLFFfEy8ZlHHMqw0gGjnAKMfWBu74yTHPSsrLKwXgOaksKGvROSOojPsXzhxTirXodgszHNI1U2Jria1mbENKGLRyDFyEZWxVztZZAj1jP4sYmTKBmgNqjaGuZ9RUygxLgCWjqKKKKqqooor6atSLmp1If5O11l9QVyoVz4YJkybyw2q1ShiG1Ot1zzoJy5ZlGUEQeIAmPXPyWpqmKKVoNpseIGR5D4wwLmEY0mg0WFpaAqBWqzGdTplMJozHYwaDAeVy2a9XerlEgilgpVKp0Gg0qNVqdDodLzM8PT1lOBzSbDap1Wq+385a6/9Vq1UPUOXndDqlWq161kr6ssIwJI5jhsMh4/GYOI49UybAqFwu0+l0vLxQJINnZ2fs7OyQJAlpmtJsNnn00Ud54oknGI1GHsQaY86xUwJYqtUq9XrdP1epVMiyjCiK/PaFnZpOp14eKgxXFEUemAnDKOBcPhe1Wg3AA3sBv41Gw6/bWkur1aLdbnt5roxJwK611gPelZUV2u02zWaTbrfL5uYmly5dIk1TL9EU8A/4OZXjLscpSRKOjo6YTCYMh0NOTk4APFN7J5X0QC0yZcJmwUIfmkgjjVtep3iwJqVszpItEo9m/n4l65eVCmBMlQNxXqqp5qBu8fFMmL05iFOxxirrgF0+RmENZf+yiiWr5MBxQbbpmcYwdGxckuZjdTdJVJTfZwoC1xuXSywBbJbNX7cGtEblN1LeceuTXkIplVlLSobBkNiMxLqJCQmY2oyKCkiA52Zr7M467B53+GO/6b387H/7d7jyk/v82J/5e6TVuQxVev5QkLQUccuiLJT6MP6FdS69K6P3WqhfHBBPIuKOIatY9ExhShaM64szZbcOnSiySt7jpt26/fEyTpIajs8f82BmUcYSTEFnFp05IBlO5gAOk7+WWqJh6oBxGIDS1FTA2CpOTYWRLaGVxVhFZhWJxTNsmVWMbMjIlBmbMlNTYmpKVFRCXc9IbIhBUdMpGpjdecR3UUUVVVRRRb3spZTSSql/rZR6v1LqfUqpa0qpH1JKfUgp9V6l1KV8uQeUUh/In/+Ol3MML8nInZ2dUa1WPQiz1vp+Nnlea+1ZuCAIvDGG1po4jr20Lk1TzwoJCCjnd9HlIlzAQpIkNJtNoihieXmZUqnE5z//eX+hfnp66tkiAXBKKW+4Ecexl9LVajVvKiKSwoODAz+uKIo4Pj5mNpvRbrfp9/uEYchwOKRcLvu+NmGpwEkwNzY2vNxUJIZRFHkg1Ov1GI/HBEFAHMdeBikywsFg4PsN5X0nJyd0Oh2iKOLChQsexF2/fp1PfepTNBoNDxpLpZIH04PBgFKpRKlUYmlpiVqtxv7+PqVSye+n9MnJc2maYozxxynLMmq1mjdyEXAUhiFRFJ1jHOM49oyjUorBYOA/D3IsxJxkMBickzWKhPPg4MADacAb0Ig8t91us7GxwXA49IYnN2/epNPp+GMgkl9he0UKWi6XPYCTPkCARqPxcp47L08tSObchfeclRRgpoxyF/DRHIApk7Nk2tF2IqUjB1VW54xNzr4J1adyds1E1rFrClTiwJp7Xy6HLM2X9X1wCn/rR2XKGaQYBaH1fXhi2mJKOXArOSklZgFcaAc4okGK7o+wJoNAY8Zjx84JsAMwBpsZB9aUk1j+xxsfJVCa7778JnSl7CSXCyA9UJp37X6axAaMrdt4hiUgJBNwgmVsE2Y25dTAss5ILDzW3+Izz1/Edkv832/7Dt79ja9l+vAaf+GZH0BfGVH6UMOBrXxzaQhpwzFhOoGkCVkFRpsh0ZliMi6jD8vUbymSJnzf7/wQb/8P30Q4duswkXXAPHbH1YTOKCacQlpxAC4rQzgSoOwAnwBhUcUGU/de7U1lLCp2vwcz4wxPZqnTwaYZulrh91x5hH/4zC+RoZmaiH0TsRKMCJQlyj9yOr8TMLaWksowOuEsq2DQVHRMU0/p6ClRztIZIDvX8FlUUUUVVVRRX7P1MFC21v5GpdR3An8a+GbgNwJvBv4H4EeAvw3818AB8E7g51+uAbwokGu3295JstlsenmhOBvKxTPwRSYhIueTviZwbpbVatW7FgqIASejy7LMm1F0u11WV1eJ49gzY41Gg5OTEw9uBMS0Wi2MMSwvL7O0tORBY61W8wyXyPREAri7u0uapqysrFAqlVhdXfWGHqenp3S7Xc8qLgKdbrfrzVfE9KTT6Xjjk8lk4kGLUop2u+0BjgCnarVKv99nZWXlHOtZq9VYXl7GGEO/36darXJ2dsYTTzzBjRs3iOOYmzdvMplMPFAWhktYSAFJ5XLZ7/+ioYkwoNVq1YMwwO9LlmX+OWut77GT30Um2Wq1iOOYarXKYDA4x0JKr5r0sgkLNhgMvHuofGZ2d3cJgoCVlRUeeughut0uWmvW1taw1rK/v0+lUvGfJ3ESrdVq3jRFwKIAUZFQVioVSqUSZ2dn/gbDeDx+uc6bl6107GSJVjMHcV5TyRzEKeZGJsJogZdFot1Fu9ULywgxpnIzkkCd612zgfXrtIHFRva8bNIob4biQdhMzb81gnysYsSSSyx9n53Qb6kDlTp3WcRCeWCIzmLHECkFcXLO2ETlDJz//OXmJtZYvvfSm3NgZ7HTmXscJ6gg4F23PkWWs20z676fEmvQSpFZS2INAYpczEmSywGPMs1u1uLTz12CfkSwOkMf13j+k9uUXqM4+thFzKWpd6PUMzcfad3tT6mbz7FyssvxpjMp0TcrqMwZoMyWDT//f30TuuWAHwaCeA6WlYVg7Naf1tzrVrl+uumqIhq5eQ7HC8DOul47Eyp0BqWhwQRQ7qbo1BKOEjAGPZxhd/Y8QWvGY96281F2U0tHTwn0hBNTZWRLBMYS6QQDTG1ApAwDUyFDkVlNRSeUcjq1REaEoaYsx1nkpZhFFVVUUUUV9eugdgCUu3juAEfAE9baGPigUurv5stdsNY+lS97opRatdYevxwDeFEgt7q6yvHxsWc5xuOx7+kSICOGFeJYKGAsiiJv+d5utxmPx7RaLfr9vmeslFJe5ifPicFIGIbnmDdwQKLT6XjmBvCRBosmK7LuLMt8/xTgGcXpdOoBWr1e94BzNpt5K3sZ12Qy8RLNNE096yNgTeSUMgfiNmmtZX193ctBe72eZ++iKKLdbnvnSgEXcRxTLpfZ29vzbNvh4SFPP/0073vf+4jjmMPDw3MAS5gykaGKqcloNDonMRXmUZYR0A0wmUx8v5+wW+L0KTJX2XcB2sYYarWaX2en0/FGJzIvMgbAg19jjI9TqNfrfjuXL1/m8PCQLMtot9uelZXYAtmWxBecnZ2xsrJCFEUe1IkrpTCP4uzZbrf9DYX4tv6pO6kWpZRWHCTBAy/xHuG21wDPkokDpjA1soyV9S9INoEFFo9zPXY2cmycN7U2aj6m3NgEkXAqnINlYJHmKOsZurnbpluP22YwgfJpQjCcQZxAmmKk/824njib3wBwURkZWMM7n3cgzUcJ2Ix37X6amU187EBinXwyu83YxliLWRiMZ+asZWRDTrMav3D2IAwjsIq7N47Zeeyy81+pW2q3FGNbIWm6uQlzUBXkw45GjkGTeZXetmDs2E1ThuqBZrrmjk8wc4YmacM6v5aJQidOFpnk4DDMWbZy15LUFXo2jxIACBJLFinKZ4a0qolGWW6gAtFZTHA6RE1jbJLwHz75n0hs5iMXfmbno0zt3JkS8M6TU0LKNiNBY6xiYErENmCURxFMbUSgp8S2zIoeueUw1HSa98gVjFxRRRX1xfV33vk51ptl/uC3XH2lh1JUUb/auqiUEjvWt1pr35o/PsZd8TwJlIHfB6wvvE/kQot/GPvAcv7er7heFMhJRlscxz4zbjgcekZOAIAAmWq16h0jRfJWr9fPGVYI8ImiyLsmyvtqtRqnp6ccHx97AxQBCo1GwwMPYWqAc/JCMVVZBBxpnjEltvoCtur1ugc5Ai4ODg4Yj8ceTO7v73PlyhUPklqtlh+jsFdJknB6esrGxobPlRMWbHNz0/ekiRFHvV7n5OTEM4RJkvj13rx507toCvO5sbHBj//4j3uJprhdjkYjv/+AZ0LF8EXy1oIg8MYkAl5FZir7sLy8TKvVIk1TptOpl6hKtp/0P4rsVXoMZRydToder8eFCxc4Ojri7OyM8XjsjVFkuwJaxUny5OTE91w+99xzBEHgM+wkrkKMXGRZkWNKL50wtgLKK5WKzx4cDod0u11vuiIZhXdiCesmGEky5M7FAAi7JmApf04kfueNUZTvY/PyyGwO3BQ5M6Yca+RMT9yGbH5Rb0WymWfGyXohNy/Rau56iQNzPhIhH6Pr48v3JTfxKJ1YKj1L+foxJCl2MsEMR7zz+Y/z3Xd9g9t2mrpdzubA6123PuVB2rt2P01mDQbLzBo0mplNeNutjzHLTUzcVFkCFCYfpPTFjayhrjRZbswxtQF/9rEfYrDTon494H/8Yz/Kn3/HD9Puw2DVUj7WzqlyokgblnDkGDMbODkl1oEvMXaR3j8T5v2MiQPCSd3mQNrlyvmMOByAM+F8PeHYMXHKQNx02XGlszymQLk4gdruFFMKqDx3DGkGWmFL7jvTXN/hp597HwOTcmRCdtKUtcD1sr3j1id5PnU3NfomImaeGxfoKRmKI1MjwDC1EQNTZT9pk9iQdjBC4xi65WDIcjD1x2hZQ9+4nrqiiiqqqNtrME35wsGwAHJFvRprx1r7gy/w/FuAibX2fqXUG4C/BIwWXhc3gMXb2h3g9OUa2Ite2UovXKlU8gAOOBcXIAxXEAReyicsHbiLeGMMg8HAg0Exwzg4OPD9dHLhL8HWYpoi21rssYvj2PfBSV+dAMRWq+VZGZHSCWiT3i+JBBgMBpydnfncOgGQSinfVyfSTaUUnU6Hk5MT7wYpDJ9IHMVhMwxDvy1hy0Tq2O12qVar/vX9/X3uuecezs7OCMOQ09NTGo0Gw+GQy5cv83M/93OcnZ3x4IMP8tGPfpR2u+2BTqlU8hEOAkgFnMl8SCD5orwT8MYqMg45XlEUefAsMk1Zv/TXyXqF5ZPPQqfT4eDgwL9X4glEaiuASySs9Xrd9+stxiQI6FxZWWFvb4+zszPuv/9+D1RHoxHLy8s+4F0knNIXORwOfRC8gOuTkxMvB74jSxgcnMrQPeA8KyfP5UpKz6LBgslJzpwpAWMQiKvhwvKyPmvn27U4+3pbwvfCqQQfMeDeaxeAHQ6kaUFy+boz5Z0sF81bwIGWcAKlQeZAXJqCsdgsI7PGGZjk0lATO9ZdRSEYTWYNGkVibW5ZkvdcCmgT8x6bESmLsS5SIIFzMkrAg7jEWgKgl9UYXm8TDRW1Q8tffOt/hapYel+f5u6h2gNmE7r+w9mKpdRThGOYdXLwNcmXyQGYypyEUnogg5kDgsE0NzSJLDpxEQMu0sCxehIUHo4hmFqykmPrdEruaGmIRoZglBCMEkgzzGkXVauR3dzlbTc/TGYtH48rbAYjeqbCpWjMjdSyrHOFgtXMbMCZLRNgqKiUinIyyQTtmDkbMbZlMut+j1RGSWUsB04eXdEJkT8Obp5dR2IB5Ioqqqgvroe2W/z8kwev9DCKKurlrm7+swesAncppUq4HrlH89f2lVKvwfXILb9cskp4CSAn7E2aph5cSP8VuIt+yYUT+Z5c4ItboASEL/Y5PfPMM56h2tjY8CyU9ONJrxjgLf/FmXJpacmDCQELEj2wurrK5uamB0jCJEqe2fb2th+3gAFhCcW5UpwkheESiWAQBBwcHHiHTgE8AgwF7ImsUuZAQJIwWhcvXmRvb8+biki+3PLyMv1+n83NTR+RcHh4yI0bN3jwwQd9OLu4NkZRxHQ69c6dQR6W3Ov1vLR0fX3dg+ejoyMPugTwCasmLqTlctmDXOmpk2B3AYwSqj6dTtnZ2WFlZcVHPnzkIx+h1Wp5pjHLMlqtlgdPwq7V63VWV1e9oUoYhn65s7MzOp0Oy8vLnqUU9vbChQtUKhXq9foX3TQQUC+AeTabeRmvfHYWezLvpPIATkCbOc/UiGW/ytxjuwDGFvPfnEV9ni1Wclb2VlmMyVGEZm5oYvEGKSK59OCQXFqZ99Atgj8buB46hfLyTcf+5eOwruePvN9P5/1w4UQ5N8UxtJ+dEh0OsNMpNk6wccw7dj7hgJk12AzesfMJgjxaQAK+U+ZM28ymfv4kSiDDEhGQ2NyKE/LHbnoya5laaGrlZZWRchl3PVMjOlOUeorhNnQ+bzn+LTF/+OFf5vtbn+a/+Od/HjTEHbfeS4/c5JkntphsO7lkkDigBblsMoNwbElriqQBYR4lAC7s2+ZMncrmcyQOlTqPbMDk0sslkVxa0io0b2ZUjqeozKKfuYlqNkh39/g3z3+Api7xL/tX+LGzS2xGPdf7hyGxAR+btdlNl9gKu2yHZ5yYKit6Qp3Y9b6hOMqqVJSb25OswciU6Gd1ajn4y1BEKmMlGNHMQdxaEPK7L38LGCdzhTHJuRuPRRVVVFGuHtxqs9efcjycsdoov9LDKaqol6PeDfxXSqlfwkkr/zxwGfglXKDS78+X+8vAv8RJLf/ayzmAFwVyZ2dnnpVRSnlL+maz6SV49XrdOzzKBb/YxEtmmVzQ9/t9RqMRvV6P9fV1lpaWPHO2vr5Or9fzkkPJa5N+uFqtxtHRkQeFGxsb5/rXxKBjNpsxHA5JksT3qQmT0+l0PGAURm48HjMajTg5OaHVanlwMxgMaDab5wxEFvvjALa3t+l2uz7QezQaUSqVPKgTSaYxhtFoxNLSEoPBwIMQsdy/fPkys9nMM6DiMvn0009Tr9e9bPR1r3sdOzs73rFScvaEZVs0kZEesde+9rUEQcDTTz/tA8rleHY6HR8FMBqNyLKMSqXiQbkAtqtXr1Iul8myjBs3bnhWVExNZrMZ3W6XKIrodruMx2Puu+8+er0eYRiyuroK4KWVDz30kM+Pq1QqxHHM5uamz/0TI5d+v+8B9dNPP+3D6R944AEPFCV+QG4MHB0deYDZ7XbZ39/n9PSU5eVlD/TuuFoAU15CafBukxL0jSwiwGuhV84GAuYsOgETqtwEQ8+lk4JvJLA73+C5nrpMOUZQ5aBPet3InxPnyoUxiHQQLdvMDVfUvO+rNIBgYql2DdHxEE66ZN2+Ny8BiJQzKnnL9uv91GTW8LZbHyMk4Hu335yHed/W55ZTZVEuQ6/kADDBEihFhOLUGGoK6loxzVm4gVV52LXiN1Ruedt/gMm6ws4Cfuxnv41/Xfo2wtC5cCoDlWPNzvsvEYWWYKpIWs74BO3cKpP63IlSWddPZ6KcSRvkxytxx1iMU1DOdZLcfdKxdc68JpxA7SAjKyvCqaX+bA/zzA3+/TPvp2+cPPIgi9jNAo7iCneXDtlNl6iohKmNOMkaVJRDmZ1gjEEzMCVKZB7MJVbmLOAkq9MzNUoqo5XLJg2ajahPpFI6wYi1ICaxcDms8dse+i2ElxoQBHzfGzcxwxE2jnn35Ms4F4oqqqiv6bp3o0kUKJ7YPeM337v2Sg+nqKK+4rLWZsB/edvTvwz85G3LfRZ45NdiDC8K5ETCKBfgYn4h4dVBEHB2dkaz2fQX7eKGuJgrJkYm0hsn7JTkf2mtPbMn1vrSVyWRAMJ09ft97xQptvgSCr27u8vh4aGX7klP2mQy8bbzYmAiMlGx0ZfA8clkfvUhkQjD4dD34h0fH9NutwE88Dk5OfHmKPJakiRUKhUPcgQIybq63S5xHPu8Opmz0WjEYDDgwoULlMtlrl+/zqOPPsrFixdZWVnxpjEyv8KQiuukHDMBbNvb2x6oiTmKAD1hxRYlqiJ9ld64ZrPJ2dkZly9fJk1TNjY26Pf7fu6kn288HjOZTLh06ZJnJNvtts/Lk97Jzc1NWq0WV69e9aY5k8mEcrnsgfwiO3l6euqXk6zAw8NDVldXCcPQR09If58xhiAIODw85NatW0RRRLPZ9PEId6K0clF6CJ7YcuXTwd0y+nZWjhxM5dlwKssjB2JnOGIV8zNcsuAM2Ig5QNOwmOCsMseo+W0EzEFmxtxsZWFoQgpqAzqdg8NgBkEM1WNDuZcR9WPUcIKNE8e+5WxhoLQDcNYxgIHS3phjZuZNZzObeOZtZlP3WJ3PBnTPaWJjqCjl5ZSBUoyMzS31XUU5eVhTLuRbrP6zEpQOQwdQ7TyqoTRVmAC3bOZey0oObAkRGE4gy81hxLhGGfceyQH0LqQLktrF3kUbuLFY5dwpg8TSvD52x+Skxx997EnePl7jmyu3GBjNyEYMsiojUyaxARWVsJ928ty3EuPMhXgvhSPWwzNGtkSUz2liNRmKxAYMTJWpjUhsSGJDJ7nUCSZ3qlwOhqzoCW0dEKD4ba/9VthcxgYaGwXYpTpBt4I9ftmk/0UVVdTXUJVCzb0bTR6/1S+AXFFFvUz1ole2YqQh7Js4O4rMUuzrz87OPNgTNkys+peWllhbW2NjY4Pt7W1u3rzJ9evX2d3d5ROf+ATGGJaWlnjooYdYXV2l0+nQbDa5efOmd4oUFqvVanF4eOj7pMrlspfKCRgRQAROQnl0dOR77SQ7bTqd8txzzxHHsQeiAggB/35xVZTMuzRNabfb3ohEHBCXl5dJkoS1tTUvXxQnzjiOvZGImLt0u10qlQqtVssHVYthjFKKarXKJz7xCT7wgQ/w+OOP8/DDD3sms91ue3t9cdhUSvHa176Wfr/PdDrl7OzMu4eKVDMIAi5dusTJyQm9Xs+Dr2q1Srvd5jWveQ2tVsvLYYMg4Pr16975cjKZkGUZq6urrK2tcePGDZ577jm/75ubm96oRNZ57do1Px9LS0s+UL3RaNBqtahWq9RqNQ+Yv+7rvo5ut8v169fZ3t728s8wDLlx44Z3nTTGcHR05PPyRqMRe3t7DIdDlpeXUUpxcnLCysrKuSiJ8XjsQeidVB6IAWJff+71nB1zvziUp5ST3dnQmWfoJEcBItPUYKoWAoOupWSzADUO8rw4PEvnnCaVZ4WUcXlmaQgEC/1wOmfmrII0B4l53pwAHRRYq+YmKZkDcdHAUtuPCUcJwd4pduRcWlUY5VLKjLdcfCPvuvUJ3rL1MO+69SkANIpZnvOmUbz91ieAiEgFjE1MpDRYQ0JGgPI/AWa5qcnUOuAWKRgZyzi30i8rS13B77/72wk21jj6LZepNZWz/M9Lxw7c2TzEW6STbvD54QjyeZRjqB1gU0EOynKDF29+Es2B3KJ7qA3y/roFpjWYQjSyrH74CBUn/N3//BMkaHbTNr2sRk3P2EldXMDIlDnN3PdXpDLqekZsA2amQWIDDIrERAyzCi09Ic7BXkUllHRGhjrnNjnIKmhlaekJrdz8ZC0YsKZnrAUhP/Tm34FdbmOuhaSdMlk5IG5qwomlVCsRNipf+glQVFFF/bqqh7bafHb37JUeRlFFfc3UiwK58XjsowPE0r1Wq/nwb2cLbn1PkjgFisFHqVSiVqt5CWCv12M2m/HEE0+wt7fHaDTyRhTr6+sopWg2m96RcZE9EeAiAc/iUCjW/WI6IsAmTVPOzs687HJRVjccDplOpz5aQWSGwm6JAUe/36der/tAamHUZJ8E6Irr5dHRkZckbm5ucnh46Bm0lZUVL7EMgoBGo0GtVmN3d9ezm8PhkN3dXabTKZ/61Kfo9/tsbW1x3333+SDs09NT7xwpBieLmWrD4ZDBwOm3hA0T2aE4R66vr/u5kZ67wWDgDWskNiGKIk5OTrh+/TpnZ+5LV0B6FEUsLS0BcOXKFZ/jJ8ejXq/TaDS8WYrk6gn47Xa7/rMkzpXHx8c0m03uvvtub2JyeHh4rmcyjmNOT0/9cRXXVNkPAckrKyscHR15+aiwu3d0LZqbAGJD6Qk5CQb3eQL4PjfgnB+S1UA5IyxnLLVHbDYG3OgucXbQQI8Cx5oFuWwz37bKFthBCypReX9eDh4zeY+aRyEsSjw1YJ0RiNV2AXyCTgwqTiFzwd82jlGBxqZ5yLc1vGX79agwcD1xwM/sfPScjFIeC0jTaBIyaohxiSHJp8Hlxc0Zt4pSnFqIlKGiLE0d0NZVgs11Jq/dJG67fbIqD9QOHKD1IC2fb3ndyhznjJoPdM/ZNDkmOstDtYXx9H2NeMMYiYwwYT6f0hMZW0pDA4cn/Nij/5Fn05CpDclQaGXoZTXqekYvqzMyJWp6xti477ipicjQRColUvN+Qq2Me36BgpW+t6mN3PMKtLIkNiBDE9uAQLk+O4CqKkG1QlYvkTZKZBVNUtdYrUirgIpc8HhRRRVV1AvUQ9st/sUHnnulh1FUUV8z9ZLxA4tSPOnVAnzvmJhuiMW+sEoA6+vrnuV661vfykc+8hFu3brlJXpygb26uspnP/tZHn/8ce69914uXbrkXxfjDunFk4yxOI45Pj4mTVNu3boF4AHj2dkZ0+mULMs8ABKpofTwAV5qNx6P6Xa7Xr4ZhuE5A5JareZDr5Mk8WBFmCSx6hdAurGx4YO+W62WN2gxxrC2tuYz1JIk4eLFiz4Y+6mnnuLDH/6wn7tv+qZvYm9vj6OjI7a2tqhUKly+fJkkSTg6OqJWq2Gtpd1u+1Dw5eVlz1S2Wi2Ojo5oNpusr6+zvr7O448/7nP+JOctSRLPsNbr9XO9bVeuXOHBBx/0sQZ7e3s8++yz3mXz/vvv9+Hdwpatrq5y7do171Ta7/fZ2NjwvwsreuPGDd/vJsAryzK2t7cZDocecA+HQ1ZXV1ldXeULX/gCJycn7O/ve3ay3W6zt7fnGcOLFy/y7LPPsrm5iVKKpaUlwjBkd3fXh0vfSbUIxDxoU/I/PJhzgMs98GYZZs4K6QRMCdLlhGpnypWVU+5pHhGpjMQGfH37FgcXWqRW874PPehYIqN8Zpye5W6RkZ1LAhcZQss88FtMUyRQXNhA5TLXACfPHIrxiXVsotaQGVRuziP9ceR9bdY4uvFdtz5F3ziGLcpfG5sErVyQ99hmThGaSzFn9nxunMCUIH98lIPKpjZcDBt873f+ELPNBv3vKrneuGCeAaeTPCIvD1gPx46Zk+n3x83mTJuaAzmdQKbny8gcmmAeL+CdPBfAnF6UtuaGJ9UTS/ujt/ixR/8jT6URY1PmzFRIbMhR2qITjOlldSel1AmJDb1cspfVSOz8q70dTEhsQCcYE6mUpp54yWSGZmoiv3xExkow5ChtMsgqnKYNanpGEFnq0YTfeu9vxHxdi7hdYrYU5vJShc4ciM9KkLRKX/Q5L6qooooCeHC7zY2TMf1JQrsavdLDKaqoV329KJBrtVpkWebz24Ig4OTkxDNCs9nMMzvi4FitVul2u77f6/r16/zUT/0Ujz/+ONeuXWN7e5ujoyMvm5tOp/T7fY6PjymXy95B8dKlSz4zTPrcgiCg1WphjKHbdU6fwhZaaxkMBmxsbHj2TPq+Op0OgO/7km3cniEnAdLD4dDLNEW6J+Yi8t7pdOpz9CQ6QQBVv99nbW2N9fV1Op2OB4PCtol80lrLrVu3uHnzJv1+n0984hN84zd+I9ZaLxHsdDo8/vjjflt7e3t0Oh2UUl5G2u/3SdOU1dVVyuWy712TeARw0s2lpSWOj4+9pFFcPw8ODjxD1m63WV9fR2vNrVu3GAwGbG1teVBXr9e5evUq73nPe+h0Oly8eJFyuczGxobPlTs6OuL09NSzstLDuLW1xXg8Zjqd+ugJAcXCPo5GIw4PD/2NgwsXLnB6ekqr1QLg6tWrft+efvpp/1k4PDz0YLnf7xPHMaurq5757Ha7rK+v35lmJwrfU/aC8VvKumiAPI9NWSATaWN+4T9TVI7hB/74LwCQ2IBIZcxsSDuY0M+qlFWKyTfQurvH2XMdB/6CnGXSDsAFsVsmq9g5eJOsugysUv5595wzRdHJfHw6c0YnyjrwMlstUyppSn1nhAFgxmMP2sC5U/7MzkeJVMDQJAQoyipiZp2mMcOiUQsh1gqjXDZcnEsosxxoGSC2mmn++8wGXAxTmrrMd/2eP0D/DTXipsKU3RyaEO8eKQYkQS6lDKbzvsSsap2BS7YgpxS2LgRr8oBwweAC8PJtwILcctGt9LaeRyxMVhTt8ZjdTDHIAdzYlDnJJZRTE5EpRWJD6nrms9sGpkqkMpp6gsa4XjdlKOVo1FhNQoAxjm1zn5eQgamgMdR17Ni5/AaAMHNnpsLNNOKfP/ku/sjv/hM5kM37D+Pz+5xVz/ctFlVUUUVJvXazhVbw2d0zvunayis9nKKKetWXfrEXhBETi3iRKMrFeblcZmlpiWq1itaacrlMkiS+F01rzfr6OtZavvVbv5WHH34YrbXPYVuUOoocs1arsb+/T7/f99JAYd5EnigGLNLLJtsUcAXQbrc9uBInSulRW1lZYXNzk0aj4cFSu90+B9QWYwTCMKRcLqOU8hJFkUhmWeb3tVwue6ZS+tQGgwGVSsUvKxl53W6XGzdu8Nhjj/He976Xt7/97XQ6HTY2NqhWqzz11FNMp1OazSZXr15la2vLs4W9Xo8kSbzpTKvV8oYxw+HQ97VlWcbp6SnD4ZAwDPn85z9Po9HwhjPWWh/9IO6hApIkJmA8HvP888/zzDPPcPPmTQaDAcPhkHa7zWtf+1o/L2dnZx5siaRW8uBkDqvVKtvb21QqFX9zIEkSdnd3KZVKhGFIs9n0rK+MJwgC//vW1hYrKys0Gg0uX75MGIacnJywt7fH8fEx3W7X9zWORiMvsZUbAeI4eifVop8JLDxW9pybyOIykAO4TLleLgNZFVajAVulLhdKPWrBjHYw4SBpUVYptWDG1doxl6unXOr0sJ3EsU/J7cAM75p5+08f7g15z5yMc27coVMIpi4bzQQ4yV1FETcjTLuO7rRRUYiKHGvzlq2HyawL+Rb5pM7/MximebQAgLHW98FlWGJrvZmJDClQ+F4vyTMrq4wlXeV3PvgdjC9USBpzJtMIeWTnwEvl1v+y6mDm/ul4LnWVIHDPii5KY88xq/MeuSCev08OsZ7N1yOHXBnrnEc315jagMSG9LKay3XLBzy1EadZg35W48xUmdqSZ+VmJiLOGbZAGTrB2DtXRio71w9n8j8BDriFjEwpZ+gCD+hmOWPXM1USi2NXczbV6rmJjsoco5qVXuiORFGvulL+f0UV9bJVtRRwba3BE7t3Xs96UUW9GutFGTmRDoqlvACaMAy9Q2C1WgXwlvQiq2y1Wly7do3JZMJ73/te/vpf/+sMBgPPlgijJz1UYixy8eJFnnzySc7OznjkkUf40Ic+5JmV4+NjptOpB2OAjz0QV0OJHZDxNxoNH1xdLpd9r9bm5iaVSoXnn3+eXq9Ht9ul3W4TRZF3hKxWq57NExAgAFR64SqVigdxi86PSinPNgrw3N/fZzgc0u/32d/f57HHHmNnZ4crV67wPd/zPbz+9a+n3W77oGvpKRSjl8FgwF133cXp6SlhGNJoNDw7d/HiRU5OThiPx1QqFe+O2e/3vQxT5knC3QU4TyYTarWal2qura1RqVR43etex2Qy4ebNm0ynU2azGcfHx4RhyG//7b/dG45IhIDISSUYfHl52fcRirOkMIcC5rTWPipAPg8C5mSsEu1Qr9d9zp/se7vd5saNG8xmMyaTiWdDhYE8PDz0Us7Lly97qe8dVeIG6fvOlL+gPwfyxClScuaMOhcNMOtYjpMmy+GQz463uLt6RDsY89hwm2ZtysxETE3ExdIp/UaVo406vWc3ADt3ScwjBCBn6ZQzQglmyj2tHZhxOXPMTVLS+RiDmfKv2QiSAIalgHBkQbWoliN0r4IOepjhiHc+9xHesvUG3nHrk1RVyQd9G0we2C2Aw7FvkVKegYtw8kpxopS7UkGeeD4zAW2d8Ce/749w/A1L2B+ArOziACBnycRJ0socMA/xXugFVDh2Tuf7akp5b9tC+LeEtQu403PDTe84KmWVA3XKzrPjRCJrlfsMHL9pmf2s5R0pAc+UAQyzigdaizW1IUkW0IomaJUwNRFTG1FRCZFKiW2AyXvopsY9H+QU4dRE7MTLRCoj0imRjr0xiv/IJhnBNEPZkCxyANUqCGcWsxCAXtSrqNTiA3v7k1/uyhbWVVRR83pou80TheFJUUW9LPWif3LFREJcEqUPS3qhRIIoz49GI2azmXdJFHv+CxcueKlllmWe/dJae1MLYUparZZ3xlxZWSEMQ5IkwRhDqVRiOp2SJAm9Xo+joyN6vZ4HleI+KeMLgsCbc5RKJay1NJtN38vXarW4cOGCZ+y63a53uRS3zF6vR7/f99sTIxVZn4APAbjVapVqterDyMvlMmdnZ76PT1w9H3vsMZ588kkfZH7hwgVWV1c967exsUEQBBwfH/t5uvvuuz2DuLW15SWns9mM09NTVlZWuHr1qs/DE0ArAFSA5tnZmWcMZf6Xl5c9aO33+5ydnXkge/nyZdbW1qjVanQ6HcrlMpPJhEcffZTBYIBSysccAPR6PVqtlnfNXFtb8zEP29vb3rhEGNOtrS22t7eJ45jhcEir1aLT6XgDnSAIiOOY8XjM6emp32eRhl64cIHl5WXq9TqDwYDBYOC39+yzz/pohOl06jP37rjKr3vUAuPlQdyCfE8tXF9ZnTtF5g6SybKhm9YYmAqjtIyxmqmNmGXzezU1HdPPajSCGVpYvkXTjUAYITyA8Q16MjT5XYxWjHLyytvW4x0d859ZWZFWNVklhJI731WpxFu2X58HSbvSKAI1n4epnRueuPDvXC6Mw78ZTlIZ4MxNAMoKKsoytSF1reg/1CGtKJKa6+Gy6nwPoIzd/xMWbQEoO5fQOfPoHUJzJk+y4vwhXXQHXfyWXWDefG+cgPMUVGpBu+3NOoqpKXknSshBKg7QtYMJOgdg8jOxAQHW98tNTcTIlBmZMln+dW9yE5OpKfnPSWwDHzcgoK6Wg7hIpVRyyeXAhg7ITRLHwCagE4tOrQuHD9QXscdFvQpKXI+Qn/ObOir/r6iiXq56cKvF47cKRq6ool6OelFGbn9/34dgSy8W4C/wm80mk8nEG5IsAi2RTTYaDd70pjd54Le0tOTliCIBTNOUtbU11tbWqFar3H333T5X7jWveQ2np6eMx2PiOKbT6RDHse/f6vf7PqNuc3PT58SdnJyQpqkPgk6ShOl0ShAEbGxseAbn8uXLfn9OTk7odrucnp4SRRE3b948N06RirZaLS8djKKIKIqoVCoeZCVJ4pkliWiYzWaMRiNu3brF5z//eT7zmc+wubnJfffdR6fTYW9vj4sXL3pgNRqNfA/hc88954PNxSDm6OjISyolWLxWq9FoNDyIPDo6YmVlhbOzM/b39z1AEuZyOp3S7XYJgsCHsIvRi8yZRAlIb6KEpB8cHPAt3/It/OiP/ig/8iM/4tnber0OOHdJGZeAcOlhE0C1ublJvV7n4ODAy16Pj4+ZTCZMJhPa7bZ36pRcOsAfx8VQ82vXrvHss8/S7XZ9fuDKyooPmJdoBpFt3lElxiKLWXA5oyMGIrKcACVhb2xg57+Hhl7iQNqFSp+9uE1Zp5QDx7o0oinHSZMLpR6DrMJGbcBxZcMBi2z+DxxT5XPNJNpAAB7KAz1hnaS3DAtJ0xBM5v1yKlMEM/f6eF1jwjKlTkQd0MMxZBk76ZBx3uOVWUVJGeemiCVSMDYZwgflZpFoYJY7Uxpgap2sUgN/+PIj6EqF4//y9aQ1RXpxHrBtcrBKDqaCeD6fnqHLbjsuIqHE5czJPAnQ9r4iFn9rTECdFivNRTZV7icIqEOAZQ6uU+vC0jX8rX/4w/Tvz/gT3/rzBFjKOqGtJwTKcpQ2MVajtcFYx7BJlECkUo7SVt7jppjlzFtFJdT1jGdn60xzJq+iE8fAqZRIZTTyIPBIZVS0W14A5GlWg8MT9MoSwbSGMi5qIisrjHay0Bfs9Szqzq8FMKdgAbqZ84t8aSv6FWuR+yvq11c9tN3mb7/jSSZxRrVU9NQWVdRXUi9pdiLs1XA49PbwApZmsxnr6+ue+ZJIgJs3b/p+scFgwCOPPMJjjz3G5uYmZ2dnPoBb+sfEmVDYq/vuu887Ky46SQLncsDExr/RaHjG5eTkxLs6SuTA5uamD4Yej8c+ykAMSMbjMZcuXfLbOjg44OzszPfm1Wo1byCys7NDu93244vjmAsXLnhDEwFa6+vr9Pt9hsMhN2/eZGdnh93dXQ8oHnnkERqNhp/PXq/HL//yL/u4h5WVFS5fvszVq1c5OTnh6aef9lb9URR5Z85ms+n7BWW8kmeXJAm1Wo2NjQ0PhE9OTgiCwId0j0YjKpWKZyKlL3FlZYWTkxMqlQobGxsemH7+85+n2WxSrVZ54okn+O7v/m4+/elP87rXvc5/Zrrdru+xi6LIz8OFCxd49NFHufvuu5nNZtTrdZ577jkfF7C7u8tDDz3ktyW9hGtrawwGAw8ux+PxOSmtGLRI3uAiIzydTj1TKs6ad1oJo/NFaiS5+E9vY3oAu0DP2RBIIToJqYczKjqhG9eITYixitXSEHAX5dfHKwTKMMkiDsZNJ6mMFSacX06J/T0KVMIcPKoFw45cRqjMHHQKu2RzjaPJDT2UsqQV1zNnAwfmpsuatLpE5aRBtH/Ix2eb9LIaGkOgLJlVGDTNPMNMwEekMioqIbEB9Vzq56zyHXrKUDRVgq7XSd58H7MlNZf6KRfejSLPwsuNSZizZt6ARGSOOaCT6dbJAmuZ5a1iYf5anINZNQdvOsuNVNL5+qV3UAkAFEAc41lQGzqDGenTaz8Z8LP3vI77O4fcWz9gJRi6frmsjEE5A5MFwNYIpiTWxRXIMuuRkzH1sppn3MamhLGKsSkRKENNx2hliFRGTcfU9cwzcgA1PaOuYogTyDLCSUYchZhIOUYul+IWOO7VXPYcOQ2qAFtFvez1wFYLY+HJ/TPecHnplR5OUUW9qutFgZwwbYC/GJYYAJHtiXyyWq36i+bl5WWq1SqVSoVyucy1a9f4zGc+w9NPP83dd9/N+9//fp9ZJuxMqVRiZWWFK1eueKOTXq9HmqZeNij9cWKbL31dYucP82DtcrnM8vIyy8vLxHFMqVTyMsjBYIAxhlu3bnlnzsFg4EFMGIaUSiWazSaDwYDJZOLZMJFTjsdjarUaZ2dnXnYKri9vUfIobNfBwQG9Xo/T01PvLilB42dnZ176KH1mMj+rq6uEYcj6+jrPP/88gGfFBoMBrVYLpRSVSoV6vc7y8rLf/2eeecY7dcp4JVdOXCGVUgyHQw/8JG9NAsVFAquU8nlukglYr9c9M/j000/zdV/3dT4qQnIGJXxc4iKWlpbQWnuG7/Llyz7sXExrZHsSqi6fxTAMOTs7QylFFEXeeEbYW4ALFy74mwj1ep3Dw0OyLGN9fZ2dnR1vnHJHlbBu0hMH51m4xV4tKQFxyr1fGJD/fPM1fNulp9gud7kxWWViSqyVBkQq46nJBq1oSj+tYqwiyQIPUnR226W3SKpMLhkUdk6ADg7EeAYvyEFOSB5RwHmpopoDRJNvM4sgboWUL23xjeVf4EZa5fl0mZLKOEkbrIRDzjJnPnSQdbhUOmFkyqwEQzIURzZkLTgjMaGXFUootr3/CpP10hfLJ4Vl8zvBfA6S+f65EPT5sbELZi7C1rGYMWfnctJFI5PFvD0fF6HnczEHxKAzJ1k1ofLsoBIwGMHRJzcYP1ji2tUjzozrTZ7ZkLJKGWQVKjphZqJzPXORyjAolsJR7myp6eemKf2sysyETLISoZbzLENbTSVICTAESN9ciaaeONZPG7LBgKBcRq+1CCONiZTrrwwsmMLs5NVbzhkW5vDNyncN7pzPX8Q/+RVtrahfr9WqRNy1UuOJW/0CyBVV1FdYL8nIiXGGyBqF2ajVavT7fW/33mw2vTtgkiSeeZO+r7/1t/4WH/zgB/nABz7A1atXvQRuOByysrJCu91mdXWVyWTiWa29vT12dnY8SDo5OeHo6Mj3ngmjpJTyGW0S1i1gAlxEgQRei0QyyzKq1apnqHq9Hs1mk1qtxsWLF+n1emxtbfkgbDFlEaAkJi9HR0feCKRUKnmDjd3dXW+Asr+/7xkkMfcQpury5cucnp5ydHREqVRic3PTRw8cHR2RJIk3g/mGb/gGjDEePIEDgdKruL6+Tq1WYzgccnZ2htbaL9Ptdj0YEjdK2TcBsFpr9vf3qdfrfO5zn2NlZcUzrnEcUy6XabValMtl1tbWuH79OsvLywyHQzqdDp/+9Kc9o3blyhVvGnN4eOjz9GazGWEYMhqN2NnZYXt724PwTqdDo9Hwoef1et2HvAsrKwBwOBx6Vk9Ytlqt5jMPZ7MZvV7PS1LL5TLVatXfmLiTymfEyeNFdk5AggAGzoOSxZw3ZWH6eIefe+5NfN0bnuOB1h4Zmm5SI7UBmVV0ogk1HfP54Qbdfh0tvXAsbFNAi4wFkX3mi5j5eHzenGgdF5YFfEB2VrVgcjdLC9ZAUnduluG1Ff7wW/5rVPeM//jJd9E3E3bTQxI0RHi2LbEBWaB8n1diAwamisZQAm/msRmcMbjWZLShyUpgynbBmTMHnRMgmc+pSvGMoey7YQ64rJq/7s1O1IKsNGf6dDoHfSbAz6/Mo5dueuYND/KykvJSTek9g5zlM1A5VqQfXObnSg/xyMaz1IKYxAQkBEQ6Y5Y5UJdZzdiUaAZTairLYyc0I1OmqSdEKqOb1hlnjo07S8tEylAOUo6Thu+tawcjD5AzFCXpubMBb9v5KN+//Waicgm1tYwph8TtvO/RLjZUFvVqqXkbp2+M8/c57MJ3w7kHi7mchb9JUb/KemirzeO3CsOToor6SutFgZxkksnF9CJjI3JK6f8SQ45ms+mZObHKF4fHK1eu8NRTT3H9+nU2NzcJgoDl5WWiKOLChQsMBgMODg64cuWK7+UyxvhtCAiQ8aRp6m34W62WjwtYjEIAfOi1MDjCQIktv9bau2iKJX+lUvFskjhfpmlKq9UiDEPPCAmgkmo2m2xubnJycgLAZDJhaWnJZ9VNp1Nu3bqFMYatrS1OT0/RWnujEck9Eyaw1Wr5sPWNjQ0voZR9FrmkmIgIWyj5eXEcM5lMzjFbJycn/hhKD2C73fYsnOTyCbhd7Jur1WoeBK6urjKdTmm32x74PvXUU2xtbfmYBaWUz/UTd0zppZxMJozHYzY3N/3NAgmLl8+U9GAGQeCPn2TUNRoN0jT1wFB6OcWIRj4nMv9aa3q93q/BKfSV1WKmGODRmQCCF3KunDstKlRuA69y5iaYKD7z1CWuvP6ESRZxV+WUflZllJap6ZiZCbkxWCIdh5QMmNASxGoxf3zOHOWZZt5Bc0Fq6IcrjKCYgOg5+7T4uspZOZtLCk3JNbdNV0LKxyWCQchbLr6Rn3n+QzR1zExMTha2Nc3lg8aqPEMt8GCjyZRIGaY2oHoYEzfKpDXZcJ4Ll0sgpVdO5lb2F5ibmNz2UwDduXnJ3L44p8mckbRzWabMJYvHl/n6jDhb5j2G1kCY2DmjlctZdS5xxULvwxvsveWE7WqP1LhA7xqxA3M2JDEBMxNS0YmPGNDKMDalXJ46N/xxeYMGnX/AjFVMTIlaEGPQGKsJcgCX4TLrtDWMzZh/t/NhfvDh70PHGaYUoGyed5jhP5NFvQor/37J22FdbuQiqrt92UUw5w1SXu7j/zJRgEXdUfXgdov/+OjeKz2Moop61deLAjmRFJ6dndFsNkmSxIM16VkTuaKYbEynU9/vJCBG5JArKys88sgjGGM4PDzk4sWLWGs5OTnxDJ4wQIv5ZqVSiZOTk3NsnbBg4naZpikHBweMx2NvkiHW93LxXqlUvOSv0WigtaZer58LIxemTmSOEgoutveyr1EUebA0m83Y2NjwUtTLly97ACyARRi6559/3gdmb29vc+XKFW7cuIHWmmq16iMHjo+PWVtb81JFceYUlu6uu+7yYEzA0qOPPspoNKJardJsNjk5OaHT6ZBlGb1ez8+HyEbr9TrWWo6Pjzk+PvbzKOAInMvmfffdh1KK3d1dgiBgOp16l08B40mS8Oyzz3pZ7WI/22g0Ymtry7OBe3t71Ot1Go0GZ2dnHvBJJp0xhk6n4w1f5LnT01PK5bIft7DCAiYFqC1KXQV4TiYTKpUK6+vrvwan0FdWaqG3zC6ANCWySumX0w50CfBwEkbrLpwt8745BeXdiJ8bvIkH33CdVjhlZkIMis/0tzmeNNjbX0IPw/n6he0LwIaiRcwBorB2ufukjhU2sOfA50LcHSSgU4Up2fOvK7duaxWGOUAxoXL5Y6UIXSlT0yUSMjCZf38AjC1UVObAiXKmKKiUBO2NODSW5SDlx/+ff8QfuO87Ofp9ryNuKrLyvC9NmC5vfOLjHBbAm7U+AkCnlqTuegGDeOGYCTOK7AeQzuWXni0VSWcw75XTicVqRTix3tFTeurSqvKspjCBJsqBegjhCD74+Gu499oeW/U+Je0MSpIs8FLJSGdkiSaz2ufGJeDNTco6IVIlEhXQjKaUtZNSzkzIzGoSExDbkNiGVFRMoCwjUyZQhsQGPJbU2A6GZCenhJUKoWmCUmRlTdoICJLigvvVUucgkrpNEYACHcw/6BZ3t+GFCNcXPeRzOk/lXza/+k9H8Xn6WqwHt9r8/fd8gTg1lMIis6Soor7celEgJyBODCTEaEQs/QXUiYmESBoPDg5YWlpib2/Ps2Gnp6celH3913891WqVmzdvMplM6Ha7XLhwwbN9AE8++aSXGC72kJXLZc/MNRoNb0l/cHDA2toa7Xab0WiEtZbRaMT29raXTO7t7fleqlKp5HPjxIVRHCBrtRrdbteDBWH3hJHsdrveOl+CsHu9npdbSr5cqVTiwoUL3q0TXFB5v9/nc5/7HI8++ii9Xo9Lly4xGo1ot9usra0xHo99Bt/6+jqVSoVOp8NkMvEsoACUnZ0darUa169f9+vvdrtMp1Mfrg6wtrbmAdPp6amXV4prqDhBClu5urrK2toaN2/eZH9/3x8LYeo2NjY8sB0Oh74HT4Cr9LsJwBoMBly8eJHT01Pf+ybgWALDRXoqPYthGPpsQomEmEwmNJtNH1OxvLzMeDz2LJ8AcPldgPvS0hKDwcAfhzuucuCkjDqvtYQ5yNK5o6F94WXEcEOYpWCi+Pz7r/LY8mVUPSUsZSTDEmQuLkAlzggkmOWsYEYO7BxQg0VWSkE6R2ve1TFvOVwENtJ/5pZxY/XyT+My5nQmoMoSjQxqPMOOxpjpjKGZMjaZd6ZMLCTMowV0nhsnbFOUG6RIzSwk1vK/P/lu/vRDAdNvvo+TB0uOrZzxRWyiSC51Kj1Brt9LpRDEjh0TOWVamQM+2WdyGSUsMGey637+LNY49tRqRVqVCckBXIzvuRPAZ8I545eV8kDyfO7CbsizB6uUt1M6pTFrpaGTSZoKqdVunVgHzAiZ5UHhAO1gQkWlrJfOmJkIrYwHwv2sSoMZGouxyoeEByphbMo0gwm9rE5TT+ipEv/0+vv543c9QjBsE21toNpVTEmTlYuLsldLCcE+72vNWWykqRXIzALT5vooJY5A5111FkPiOFkCAr9um5unvBCZBy9MVhf166Me3GqRZJYvHAx4aLv9Sg+nqKK+rFJKfQPwd/JfLwDvAD4M/DlgAvwBa+1NpdQDwP+J+3L9H6y1P/9yjeFFgZz0TslFtNjiD4dDb7ihlPIySjHqkAtz6Wey1jKZTLyBh1yES8CzRBt0Oh02Nzcpl8vnctrEgVAiAwQQgpN/TqdTqtUqo9GI6XTqxynM1srKijfwiKLIu2WWSiUGgwFJknDhwgXfq9Xr9fy+iZX/xsYGx8fHrK6uelZQ1gfO9GU4HPoMOWGkyuUyzWbT940tjnd/f59Pf/rTVKtV7xAqQKTdbvPAAw8QxzF7e3scHBx49vLee+9lbW3NM1aj0YhPfvKTvh9xPB5zcHDAhQsXPMMmxiqSAyh5eMIsVqtVjo6OPNDd39/n0qVLHpALiyn7JT1qQRD4sO7JZMJwOOTk5MT3pMk+yWekXC6zsbHB0dGRl0aKnFXAnID0NE39NrTWHljLnEsEhOyLgNcgCOh2u1QqFU5OTrhw4QKHh4dUq9Vzrqd3SvnsOHvb7wvPWZEBeqCXG4p4hLS4Pve8sg7sBRONsRFJEDpp4Uyfu3paNOg4t101/+mlh8ISJcrHH/jcufPDWGiscQydgB5/1z9ft84sKOX6F01Glg+mkvczzqx1mXEWElwkwVwFqYiUIbOKBO0klyhqKsWg+AePv5Or4S/yvT/0h9n/DTU/jxLE7XP0FuZ6Ll21uew1j4SwkFYhHM/fp9K5ZHSxF26xf9CHtysnJxV5ZjjJ9z+1+brda8F07nSJdcSoMInSWxdMFbNeidPlGpUgwVjFMCuTmoBBUibUBhMoDAqd71g1iGmHEAQjankmXVO77+ypzc8pGzgWL0euWT6nGPLw8BKJDSjloeQDG/Jvbn6Q33f5EcJmkxDIqqGTzRb16ihRQ3oAJ/phld8gsj4iQ+VvECOUbCEfRXg2i8VgzoE3OfUF1L0QsPsSh+q28eWuoKg7qlYbZS60Kzyx2y+AXFGv2rLWfhT4VgCl1L8AfhYH7H4j8GbgfwB+BPjbwH8NHADvBH7tgZwx5hzAkMy0NE29fb2AvXxnuHnzpmfrNjc36fV6KKXY399HKcXW1hbggI8wMAJ0sizz5hmrq6tUq1VvlJEkCc1mk+eff55Op0On0/Fh4ZI7d3Z25nPKRKpYKpW85LNWq/n1SM9XEATeiEPke/1+n8lkglKKu+++2/eOGWNYXl6m2+16J0ax8jfG+OBxcb4UJk8knGEYcs8993jgc+3aNbIs4+bNm1y7do1ut0uSJCwvL7O/v0+322U4dNbxYn6yKNNstVpcvnzZM02rq6s8++yzrKys8OCDDwJO+irgbX9/n0qlwtLSEkmSMBgMWF5e9qHqFy9e9H2PAuCuXLmCMYbxeOzdMUulEjdv3mRlZYXxeAw4Ga7sZ5ZlnJyccM8999Butz2IazQannGViAVh5crlMoeHh17eenZ2RhAEHlyL+YkEmQN+LO1227PAh4eH3nRmPB5z4cKFc06X0rt4x5UFlYOdc66IgtMszl0D8EHcC71rwqidCxTPQYWOFSpV2NBiolyKmczjfR3rY1FJDjLCec+dN+4IrXdDCKaKrGxZNPeAOdvmt7sQUbB40SUSxWhkicaW2s4YNZpgRq7vamoNUR78LSRhgnJSSnDxBMxBSs+4mzoB1meoDWxEYgM6esZz6ZT/49/8H/yJP/RnGFwqMVtSRGPreuS08leHJlK+X9FqUDkrp4xF51LBcjeXUZbm+2Ii5Y8FItHMwZmRcGwB6Xn/mIlyNjS2+fw6UBhNHfjOKm5sws6Je6XIYKMBKBMyvhgRZyGJDUhzelT63RKr6U8bpCagEibUg4ha4EK9A1zEgMQQRLhzqqxdzpyLdHANjRnabVOlBMpQ0TE1PaOEIcIwtpZ/8/wH+H2XH0GXy1QGq4Tby1/iB7+oV7TO4e0Fq9kcvCtr0bh/6rbFLSYXEtgvap8z+fLnNyRA74vvnXzReH61IK0Adq/aejA3PPmhN7/SIymqqK+slFIh8BuAvwc8Ya2NgQ8qpf5uvsgFa+1T+bInSqlVa+3xy7Htl3StFBmjMcabZohxhbhHlstlxuMx3W4XY4xn2SSjDPAsirUWY9zFg9jEC4NlrfX5aFpr36sl/Warq6vexXI0GhFFEZcuXaLdbpOmKb1ez1/kC2MnDI8wbEEQePAlIE/GITJCkXuKY6fISoXNW11dPWfmIZJPATviqiiB4bVazYegy3x1Oh3Ozs680cdjjz3Ga1/7Wi5duuT7A1XOUvT7fW/ZL7EMg8GAGzduMJ1OvQPmYi+jsG4Clsfjsd93wIPOwWDA1taWZw/DMPTh7J/73OfY39/3Ie6lUsmDcjGfEXAvzKvISvv9vg/9/vSnP83y8rLvc6xUKmxubqK19kYyt27dolQqUavVvMFJuVxGa+3HFkUR3W4XpZQH1xJdoJRiNBp5RlEcO8UwZjqd+v7NO7LOXyHNDULy3+XxHDTd9vZsztbIDfVFgxJnRqLQMzVnohbWDU66KevybJ9vfpuzaFnZYvOeLcjZqGyeI+clh2Lff9sFlk4gmFqqJxnlXkKwd4odjTCjMQOTEinXQ5cAUwFvWAJlia0mthqDY95EXikgzlh9TqqVochsQGI1pQ89ydLoHg7f2HBmIjJPMl6ZkoWECp1ZB8Zy845F0xFl8MyTzIVQDx4MWiepFKAd5EYmaqHNyMUWuD5BEwn4sw7whWoeiSDB73mOXTADpSyxCSjrlElWohokPkoAYJiUSa0mVMY/30/nOXIuBNw974xPslxOOZ8EFzmQEShLTc28e6VWlooyZBamWH7y+Q/S0GW+/97fRFAtU9QdXsr/z9G+IqM0FoUlROXQzqAw/pzOFhYPAzBm4TRfODcW2Wlr7dxMCDAp8+8I8Oyf/8KTuu27w77I80W9euvBrRbve+rolR5GUUV9KXVRKfXT+eO3Wmvfetvr3w78EtABFu1Y5Q/q4pVeH1gGfm2BXLfbJcsyL1cT8DOdTkmShEbDZTYJGyXsjLWWdtvR5JubmwB84QtfYDQaMRqN/EW4AAyRLqZp6p0Lhf0ql8vs7Owwm824fPkyDz30EMfHx+eMWC5fvuxDsvv9vpfQdbtdWq0WN2/eRCnF+vo6w+HQs37gZJS9Xo/RaMQXvvAFZrMZ29vbWGt90LgETPf7fS5duuQBrTBb4nwp8kUxRBGrewE129vbAOdCqh988EHW1tY4ODjgIx/5CFEUeUZP5lwC2Z955hnCMKRSqXDp0iXuvvtuTk5OWFtbY2VlhWeffRZwIGZnZ8fPm/SuiTxV5IwCbDc2NnxoehzH3rny/vvvp16v+z7FLMt48sknPWgTqWm5XGZ9fZ2TkxPfn/jhD3+YKIrY3t7m4OAAcDcGhKFrNBoe0M5mM+655x4AdnZ2vBxVDEtE0ik3Cba3t5lMJty6dcsD/vF47G8giBvpYDCgWq36aIgkSfyNhTupFp0TuQ1kAfNT3+TKpwXARi55EiWUBxQWVKY8Q4S1ML++R88cQyfh3TZviVnMS7PasXDWr8/91JmCzL1utQsUt9qSVSwqFdfCHFwuPNYJlHuW1vNTosMhHPewoxHpZMLbdz6OwTAwirG1jIymlE/E1Aa+hwtc71diNVq5Pq4SxoO4DOWBCVaT5M9VVMY/+9y7Wdbv5bf+sf+G3rVo3sM2b/1Dp5asovwxMZFCpdbPtYkcUxbMckYydmBL+utMzqKZ22IubAjh1LGAKrOEkzxWAJFNWi/7DBILBpKmIpi6njqdWoKpA3HO+EShYxiMKqzWxiyHIwJlGKZlWjp1vXEmYqU8JrWakk5phVOmJiJT2jlaWs2pqRNgqAUxGkstnJ2LdzD54wBDRSWUVOZdLysqI1BOAjsylimGQTbhxz/3Hv7L+7/zV3EGFPXKlMp1u8oZmhjHImtU3h2XobRFaevll6mFLMiDGJUCpbFag9KglQuKt/kpFQKZxWbuJgvyPtFq+5s9IisAbJYHTcr68zFa67YhX463u6IWwO5VWw9tt/ln73uGzFgCXUiyi7qja8da+4Mv8foPAP8G6AKLlvZy9bV4n7kDnL5cA3vJHjljjDfEkIvpIAh8tpkETgsTlWWZNwa59957WV5eZm9vzzNT4noodvEiS5SMs8UMOrkYF2ZvZ2eHCxcueBONwWDA6ekp1lovy1xbW/M9Yc1m04O+s7Mz9vb2PDCTjDfAs1pRFKG19iyh2N5LX2C1WvU/p9Mp4/HY9+SJpFD61E5P3fGR/sBarcbp6Snj8dg7aiqlPNCNooinnnqKxx57jE6nwwMPPOBB9OXLlzHGsLKyQr/fZ39/38/V8fGx71cD19u2trbGyckJw+HQM1SSRyeZa4BnI4V1FBAZx7EPHJeYCYlDEKDUbDbpdDr+mB4eHvqg9m63C8DNmzfPPbe1tcVoNGJ9fZ04jun1er7fcDwe++D2ZrPpAZqwdvJ6EAScnZ1x69YtbzZzenpKHMeMRiNu3LhBv9/3sk/p3avX6z5U/k4ryVrzOXFi3y9smWS4LTgZnnOaXIgIENDnQWG+jSBVLrNM3q9yoCcXQKH1xhrnIgeYgzsXK5DLDTPyleTLGkUQO9OOcOKYJR1DNLGUBhlZWRNMDeEkI/zY57FKYSZT/t3zHyTD0jeGaX4+ZvmYhG2rqIzMKmY2QOeySnBW+U4CqH0Mge+dywFcbEtUVMLYRBirGBjDT/yTv88P/Ld/gcmKduBJqzmDqRV6hmcTpT+IXCYZJBZSS1ae9yCakmPUdGo9axbEuXQzZ/N0kpu8GAfETAnvSCnsq06caYqJgHDeE6dj69lDE0E0hLjpQGe7MeUsLjM2pdzcJCLUhlAbEmvoRGPKOqWikxwAB3lfYeaAm47zOXcDH5iKZ+XkX0mlVFRCXc+o6Rl1ldLM2b1VXSJSATWVUFYRfTOlrEJsOo84KOoOK6XOfX/4Pti8FzXAMb0oM4/a0MLLKWwU5XeUcN9NQTD/3WZzcOjZNZEG6Pm2XxB52fmPF7ueV4s2u4We8muhHtpuMU0Mzx4Nec1G85UeTlFFfVmVyyq/CfhjuK/RB5RSJVyP3KP5YvtKqdfgeuSWXy5ZJbwEkBPzCWHbhMWSviQJ1xYZGzjg0ul0SNPUAxqRvsVxTJZlXLt2zWeZCcgRSZ2Al/F47KWVkvkm5iniXLkoxROGUKSOYpYigEzcKKVnbDabeelit9tlfX2dwWDAysoKpVKJRqPhDVxEpgn4bDoBPMKsVatVH7AdhqEHkwKCZfsiGRwMBgC+R1DiCMbjsQeYIlEUyWMQBDQaDa5evUqlUvGOosPhkHa7Tblc5ubNmxweHhKGIcfHxz6fToBcu90mCAJOTk4Iw9BLZKMoIkkSdnZ2yLLM5/qdnp5Sq9U4Ozvz7GmlUvG9kmIsIswf4IGVAOyDgwPuv//+c3EPrVbLz0u5XD43v8K8iRxVPj9ZltFqtRgOhxhjzkU1CKDe3d2l3+/7+e71ej7O4uTkxPfc3UllIvuCBidyvaIs8/s5co20AOq89G4xj87yRfLLxSBvLwGUayKJC8ift2H+0zN0CqsWow/m/2SM0dBSGlgqp2lurZ8SjFP02QS0wkYBaveIbDzm7bc+wdjGnJqMCAiUYwEyIFAOpAVYIixjG6Bz6WSWP6+VZWoDSvb2nXQVqYzYlghwjozj3MxjaqFnFK1fehr9yDWGF4L5fItNpgDo0M2LOD24SAK3jCnnvYeZPZ9BJ9eicjjza02d98KphW14YkIaAWVT9vy1rhyzIHHHOEisd9FUyhJpw9REHswKwAVcrIAylHXi5Kl2LqnMrPYSyyzfgZmJMEoTaEszmFBRCTU9o6IS1oMhbZ1QUXAhbPCW7dejGw3+0+ffz2+78k3YNOFdtz5FZo1XIxR1B9Y5faIAsuyclNLk7qlWudZcE0QOsIUBlKrurQaYxDlAw7FxqXJ3YqwBrSFT7jlDzvzh2LQkm/+OdfpMaxdTyfPn50BNWYMN3HmsM+nLU/P3WEuB6159tdmqsFIv8fhuvwByRb2a69uA91lrDWCUUv8bTmY5BX5/vsxfBv4lDuj9tZdz4y8K5G7duuV7zMrlspfDBUGAMYaTkxMPYqy1XLx4kcFg4IO50zSl2+16gNZsNn3fkzBw1lqfBSYsjGxLLuqbzaYHa5PJBGOM760SsCGgc29vj3a7TbVaZWVlxbN94s548eJFH3QtzFGj0WB9fZ1Go+ENXsTcRWIFZB3CUAlwnM1mPgRdZKci7xSgKNLAfr9/zmZfLPFlLh544AHe+973cvPmTXZ3d7n33nu5fv06SZJ4g5N+v0+j0aBarfo4gnvuucczjKPRiN3dXcbjsc9pk1iHxbGur697VlVYq8Fg4I9DHMccHR35OAKRu9brdc/q7e3t+f49AaYiXVxeXvaMLeCdKTc3Nz0AlRy+SqVCpVJhMplw/fp1VlZWiOPYg/cwDOn3+/6YCZje39/n+vXrvvdOguCttezs7DAejymXy5ycnKCU8iziHVcarLKQ5P1WCyBM2Tljdw4cLNbC9dhiW5sPpM4vugyQ4xkWPQ28KUnqZJMmymWYamG9ef+cM0tRji0SJ8XcwCMaWaKhIRwkBJME3Rtijk6wWYaZTvnpnQ8REXBsYr6QBFSkNwsXKSA1tdo7LSZ5H5wEgUPey0WGsZpYud8zNBJbp5XJTU+cocfUuq+4mHnf19/+2Dsoq4w/8Sf/LKON0AWUh04SqZQDsjrOwVs4ZzC0tWShkzUGMweoTGpJGsqD5yBeYBayed6eCefATZwrTQBBztJh8e6XjvA6f1VqFWQVhRm77aY1xWuXjohN4Ji2HMBpZZ2RSWCo6GSeI2cD/09jzzlaVnSCVoaKSolUSk3PuL+8R12lXAwhsYa2rvA7vvF3YSu5ucz9IWSG73vz9xJcjLDVMt/1A68j6E/h3ts/5EW94vUCBJbKTUkkQCAj/1xqIFDYMIRKwz2ZGZgZB8LSDJ0aOqnGqgSDwVjDhq1gsUxJSSYZkQ0J0GRYstjdCAmsBkKMNZjMndUJhhTAuFs2mTXE1pCWQ4LUAbeEDLLcJhY778lTiiBzDrbz3SsQ3aullFI8uO0MT37n61/p0RRV1JdX1tr3AO9Z+P0ngZ+8bZnPAo/8Wmz/RYHc6ekpWZb5sO+1tTWftSaW8LVazZuGiBW8OEEKoBPWS/rjarXaOUv6IAi8zXwQBJ6J6/V6Pqtssf+p0+l4ZktkfWIOsmiuopTygEqWLZVKrK6uYozx0s7JZOLZNaWUZ8mELZT+KmMM7XbbO2Aqpfxr0tsXBIFn0iSs++zsjEqlwnQ6ZXl52ff3nZyc0O122dzc9GYd9913H51Oh3e+853cvHmTe++910sEn3/+eW+1//TTT/v5ajQadDod4jjmNa95jQfLt27d4vj42DtuSh7d3t6eB7MyrqOjI2q1mjeGEQmtxBJkWcbGxoZn78SQRBhOkYwOh0M/l0tLSz7brd1u++MpJiwStdBqtTg9PfXAVNwlt7a2fM+eMJvgJJu9Xo/T01Oef/55SqWSn4sgCAjDkFKp5Mdz4cIFf7PhTsyRcxK7HMQt9mwtsGt2EbzlrI2R2AABXAtskKiapH8OlYOEnAUSswK/DZNfzFm3vDgkChtngoVLJFnXuZ1Y2H7g2DcAMx7z9p2Pc5xNGBuoKMvUup612GrnQGmVz4ELsMzylZfJnAxQjBZyuaQANZjb5guoCzBkObALMBirmdqIzGpKC8MdETGyEbWPPgtvvpvBpdDJIPP9FyW7zXPelLXonBFT1nq5a5q7SwpDSn5cpK/NzQdfdF3p/Ug0fhmVuWDwcCIfgPlx9/EGgQPPcQNUaulEE3YnLQIME1PGWLffaGgGU+c4uDBf4ELBpY8wA2o6RucfhLJ2UQYVnXB3GNPWFX7b3d+MbrVQtQpmpYHVGhu5niirFbpdIysHJO0IqxTZhTLRYKEhs6g7pM5/icwBXE5G5/2wRoMtlXLJpIbYQmbRGUSpJVAZOjOUjGHDhsxsmscQQBNFhpNojm1GkLN8EYoEg7XuVvQ8qkCjsGgCR4ADkmqoMDm7p1AoKgTESmHUF4M0/4x6oScKUHen14NbLT71fPeVHkZRRb1q60WBnNj2y0WxuFRKL5kAMDEpEVAGeNZKXC7lPePx2Ev+RN4oDIuAQa21l00KY/PMM8/Q7/e94+XW1hZnZ2fU63Xuv/9+oijyodbi2AhQr9e5cOECp6ennjWSkG9xMBTJp4BL2X6apl4CKGMslUqMx2P/r9ls+ow6CRJvtVporZlMJp7lE0ZpPB6zurrKeDxmNBqxubnJZDLxwEfGf9ddd3Hz5k12dnbY2tpiOp1Sr9d91ECSJD44PAxDjo6O2NnZ8bl/Z2dnbG9v+/Dtk5MT2u02SZJ4dm5lZcVvr9VqUalU/P4OBgM/XlnfycmJB0eAB9xKKf98qVRieXmZ9773vdx1112+V1HY2AsXLrC3t0ez2WR1dZXj42OeffZZz9y12212d3dZXV3l+vXrnsVrt9t87nOfYzQa8alPfcqP9/Wvd7fwptOpB5QrKyssLS3R6/VIksRLWheB/p1UOhUnR+a9cmI4EjA3LFFzJuecUYdybM85F0bJLxMQqOavC0CTHDhUHhug3O/hSHmgZkKHBnWmPHgxkc0ZK2ds4tRRiqQOJgqwQYnyaUKQpLx95+P0zZRIOROTqTEE4J0nKxif/6axTJlb6Augc4ycC7Q2VjOyJQ9EpBcus5oARUJAYkOXeWYj77Bo0DnTZwiUIbMRUxvxFz7yi9wX/Qd+69/9i3MZay6fBHL3yIU5zI/XYilj0dN8bso4OZm9bXk5TouMKO5YSfA3yhmiuHnP35vJcXLUajBx/XngPjOvb9zg2eEbABikFZajEaF2TFxiA98DN8zc576fVt08ohjnGQrGKtq5/HJsSjT1lCvRMX/gzb8Logh9T52sXiJtlOZOhPnnx0QaNKRVTVLTmABKI0vSvB3pF/XKldwNON9XJkDOACYH/1YpZ15SLjta2gDjBJU6xruBJcxjJyrABoo+hlhZwiAksk6FEubMdmYtBktoA1TulqSsyW82ueBway1hfsKlNvM3hZRNIXVaZI2mRkCmLEYZzOKeWAcM/V6JQQpuG7YAcnd8PbTV5sc+dANjLLowPCmqqF91vSiQazQaNBoNms2mZ+WkP20xBFxMUKRHrNls+r4kMZcQ5ms2m9Fut5lMJl5uJ710WmsPLg4PD/3F+drammf1nnvuOXq9npd5lstl74ApTJLY2UsswNLSEq1Wi8PDQx+DcOXKFQ9YhDWT3jTpu5tOpx4QCviTGIZms0m9XvdGLyKP1FoznU49KBWHTmGirLXs7e0xnU7P9QcumosArK6ucnBwwP7+Pm94wxs4OTnh5OTE2/FLv9rHP/5xn5knYeVRFNHpdHjsscf8uhuNhjdAKZVKbGxsEMexNwbp9/vUajUviR0MBp6B3NjY8JET3W4XrTWnp6ceqAsLWalUuHr1KmEY8tBDD3FwcOAZv93dXe666y6Wl12+1PLyMtPplMPDQwaDAbVazTN+EuUwm834vu/7PtI05Z3vfCeHh4eUy2XuuecearWal6aK/FIy+6RvTz4f8poEoN9pFUznF/7+ZvMCcMDi+6qEafM9VIs3nC3eJVLWIdJKu/DY98cZxxzNmbdcnqQXJJQLAE7Ahsr/0NrQBWQHMQQLgDJuaFQWEU2njG1MgGJgDQPjPtuRMsxsQFllJLlsMlpo6JNeOHns5IAhAZaYIJcKGpJcMplZjUGfA3WSJyfgLc7XUdczTI5GKsplpiUWGrcyxmsaneVMp3IXtc61Mv/duigCm1N7Osl7BlMH1kwpfy5bmHvjXoec6cznWbaTlV0wuDByYp4izGBSU84QJbXeGCUaG7KyRhn4n37+t9O5q0e0nLEcjZiZiLKe+J63QVZhZkIfJxCbkEAbZjakpmMinVFWqQd8d5WO+LrSIX/yvu9A3d3GVCOm67W8l9KiU4uJHGAzofJGMSZUHnyqzM4/u0XdAWXPPV5sQ8uU8RJFE4ZQqkCpDOOEYDYjyCyKkA4xbRSrhKTEzIAEyzExx+WMYbvM6OoaKrbYWgmWqtCIYJDBOIN0BpF1ACu2EEXzL7PYgAohU9h+Cmc99HBC2HNZH3XKNIgYMUalaQ7NNGU0mXWmPoBzzcwZdLmNkGn58rt9Hoq6k+qh7RaDWcrN7pi7Vu68PvaiirrT60WBXK1WQ2tNu932fW3CroWhe5uwIHKBLCHN1lrPuAnwE2mcsC9irS/Zb4vSOJiHhi8tLbG8vHxuueFw6Hug6vW6l0JKD9rixbuwZiKLFHmi9LIJqzQcDr1Vv/TWyXikl2w0GtFsNv0+NhoNjo+PKZfLjEYjL+MEl5OXZZln02SdIiNtNBpEUeRDqyeTiTf/qNVqbG9vMxqNvBOlsGmLhi+S9WeM4amnniKOYy5evOiZwNls5hlGCUsXp1EBTv1+n0ql4sFwmqbMZjPW1ta80Yi4RVarVW86s7e3R6VS8aC63W57EN/tdr1zpMgxhbEMw5Bms+lZVjFgSdOUer3uZZ4yd0899RQ/8zM/w8bGho+paDab7s5vGLK8vOw/Z4A3RpE+QIlKqNfrPiLjjiphyIKF3+W1hQtikTx618kFyaU3zFgEcWKqIe/P1+/jBRSgnL29gA6dnGefFscgxiiLuWYEDrzpvN/LGbEo5+pYrWKsJcHSy6/yjT1/hZ9Y7Uw4mEcKuOeDhXyzL+5xy9Dn5ILuOXUO1CWQM3AKgyZSKbENCJTx23TsFLQ+c8j0N286YKbx2XE+1lg52WMwc71lyswNR9AOkLn4gnwezAJzp87P26IJjZZ4hnQO3vyx8RJb16enE0NaUcxammCWRxaUDKNJmZqOGVJGK8PMhITa/ewnVd8PJxLWUGWUdernemxKjE2JXlLjdzaf4I/9xt+LXkpIlmqk9ZCsol38wcySVbSTT5aVl/eaUM17+zxoLZDcnVZegb14g0hpd6xCDWHJaW2HM8LEUDOKCooaKZoEFJzplMPAkKy3MSsNVGKZXlwjXWtjLy9jLzWhGUDVwiiBUQZT44BcHkfANHOGKSaDLINyAKVSLuOM4aiHuXVC+tldeH7KJIY0tdhxhrKaMOfZbheKauNaOwwZZvEL1C7ovou6I+vyco1mJeTxW2cFkCuqqC+jXhTISW6cME2DwcD3I928eZNGo8HGxgZ7e3uEYegdDafTqQdWi2yV9KSdnJxQq9WI49i7LkovmxhpDAYDDwSXlpa8zf3ly5e9k2GSJB5kioxRWJnj42Ofd7a+vk65XPa2/N1u12fkbWxsMB6PvROnAL3FEHEBQ0mSEAQBKysr3mhFLPIFuK6urno2Thwzy+UycRx750illAeM7XabbrdLEARehtpoNNje3qZWqzEYDLzBx3333ce1a9f43Oc+5+ei2+1SrVa5evUqaZr6+ZAetEXzFol9kJiInZ0dH/adJIk3S+l0OmxtbXm55zPPPMNoNPK5fgKKAd+XNxwOPfsqLqabm5t84QtfYH9/n1/+5V9mfX2dSqXCbDbzjN61a9e4ceMGjUaDo6MjOp0O9XqdXq/HZDLhb/7Nv8nnP/95ut0uGxsbPpKi0Wj4HkQxj4nj2LOaW1tbHjSfnp56oH0nSiuB8+xZDsBMMJfWCdCTfjeYyyy9G+KCk2RWXpBRCiBY/LkAFsUpMZjhWbXMM3b5BaCAEutMQATESe9dVnUAzoEUS1LXZBsdfu/d38p/uP5BbqaWmko5tRUqpJ51EzAWi2bPOhAXYBkYd6xkmQhDhvavi+tiQnDOgdGtT0BfQGCd42VJOfbO9eglaAyRmKj0zqgfrJE0NNNO3t9mQS2GgyfWzcML9Qdq3EVwvhvh1AGwLMplkDnbJnbuEi+hp84cRY5J3HRGMuTGKOHEvWawpBWFiaB8Ng8Kr12PuPqWHcA5VB5MWnSiifOksJp+XCHNzU20crEEpRxtaWWZmZDTuM6jx1tMf3GVX9JvpPUNGTqDuK49CA0St32b5+SJrNdEDsipzEVNSF+g/Czqla8XhNTyHaK1y3fTeTdbmqFmGVU0dRQVoKxSZoFhGmrG5YDjZh1z3wW4e82BpEsXoN2EegnuazkQF8TQnTi/tsRCMnPLphYmGVRqkKaQJFALoVqGUghhBmdV2KpgahqqZySjlGSSEO1MUTMnddYabObueOgcomrcOXWuh+72j2HRMndHllKKBy60eHy3z/d9/YVXejhFFfWqqxcFcrPZ7JzFvmTJCThpNpve4EPkdRJ2LcHQwgwJkFkM8pYeu0ajwcHBgXeBFLniZDLxmXXGGGq1mu/zEtZN2DVx0hTnSwm/7nQ6fn1iuiGyzuXlZe+c2el0vFX+4nqF/VoEOYBnj9I0ZWVlxYdPSzC1SDLFFj9NU28QIrb/lUqF4XBIlmWUSiVarRZLS0ueJatWqywvL3uZ48c+9jG2tra8y6QAoSRJWF9f5/DwEHBfihI+/sEPfpBer0en0/EgaTEofDabce3aNdrtNv1+38sUpZ+s0Wh4UxtrrQeH4uIJzt1UgHa5XGZzc5OjoyMODw99aPxkMmF3d9fPk6x7Nptx8eJFdnZ2vDuqOJcGQcC73/1ufvAHf5Dt7W1/PGVM4/HYm7acnJz4PkWRiAqjJ0zj2dmZ73W8k8pHAMhFhl641sjlkrKcgLfFHiwP1uwcIPhgcL+R+bK+wQQHvhYBoNV5z16q5uuVXrwFULjI/IEbl4nmTJTVkDVKRO0m37/9Zv7xjQ+ggYpKmeYyybGNiFR6rt/NMWRuIx7A5b1xiQ29KYcDZpk3O3F9bzpfPmVqInTOvInMcr5cwNRGGDQV8s9DmhJOMtKadhLGDLJKDq4XpKiuX9HmczRnN7KyIjDWsZNp3uNm1TwmIJdlehdS5QBcWlY5WFde0hkkrs1OPgtinhIk7iLWhI5BzUqKpG05mdRoB2PX/6Yzz76lJqAUZEzjiFZpSqgMaT5HWlkmWUQ1SKiHM453OqwdWeKWIqlpD+gXj6cJc0mtcv2MKpszbyqXpTvjF4t9QfRQ1FelXgKs2AAXK2KUA3C1snvDJKWc5IoGFJsoqqSkKuN6lDJpBthmC9a24A33wSP3wJsuwSUFx8ewcwIfvgE/fwazKSRTWK5DELn8guEMTifO9TLT0ChDmsEsgeHUjaNZgUtLcLkJ96zBG18DhwMYJHA8Jvm3H4Vnj2CYQK0JwxGlxNJIFZaEGEOKxVqI8j1JcYoDZXPH2cXJWfxOLOoVr4e22zyxe/ZKD6Oool6V9ZI5chcvXmQymdDr9TwokX4xyXILgoD9/X1/sS9yRHGAlNw06UcLgsA7RUpPVKPR8I6FjUaDyWTipZNyAd9sNn3A9r333uuZrOFw6H8uLS1Rr9fZ3t4mjmPiOKbb7fqeNmH9JPctjmNvXS9Aq1KpcHx87Fm4UqnkYw+std5hUuIFZNwCZoRdE3ApvYGSsybsXaVS8VJQYesEDNXrdfb3973RTLPZ5NatW0ynUzqdjncPPTo6olQq0e/32dnZodvtcu+99xJFEXfffTdf+MIX6Ha79Ho9BoMB7Xabe+65B8D3FooxjcxRuVzm8PCQ/f39c2xoqVSi1+sRRZGXdEpv3F133eWlpFmW8brXvc6D0u3tbdbX11leXvbHMMsyH5DebrfpdDr0+30fBC/s2Zve9Ca++Zu/mXq9znPPPUe73fY3GJ555hnvYrpoclOtVtnd3fVg+vnnn2c4HHoW9od/+Ie/CqfVl16e+bLz36UWHQ9vl0ouAje9gE+9BFPPgZ/EF/gcuPxnVrFOqCQ5ZjkAFOMVF3Y9B3QSYi2ui0KkmQiShrsR7zLxLEktJFpZImw2+FPXQn7suV9iYA1rwZipVSTWse+jHNiVVMqZLTvnSbQHZiKXdP1srtetpme+70uWAwfU5HXA99ZVdMzUlIhUSkk5xm5qIqYqYqoDbJygZxlWRW6u8jBvnVh/TCQ6IEgdQ2UChc6PVThxIM5qRRaBCi3BTI6FW1aOmQkhnLn1pnVFNLFkeeumjudupDoDayCMpWfRefypzGIjRVaBB77pWY4mdZ6frXCS1FmORiQ2oKozskCzUT7jJKrTCGaUdcpJ4mRLqZnTioezJisfCwhiSzSEtJaHk4cSWJ4D60j5fEEShdJuTNKD5N1SYb6/RX3164uAiTvxrcKBqEA5SisMITYExlJKDWWgjKVExoSE4zBgWi0xu7CC/YZ74Z4tuP8inI7hxrPw+MegMQWVODZtaQnqZSCCoAFb6xAriHGmJSbvhxtmcDZ2DaOBda8HJWewstpyj88MnJ44C81J6qSfP/wI3DqB3sSxeu97ivRowOxs7ABbEGCVppwmZD5Yw7jPr5KbI5Z5eHmB4O6kemi7xc9+6pa/xiqqqKK+9HpJ18pnn33WO0IKGyNOlcPh0F+MNxoN78woLomSzba3t8fp6SnT6ZS1tTWfS3Z0dORjDAaDge91E7AXxzG7u7u89rWv9aHeEhQt8k1ZlwRAB0FwLmB8MBh4p00BdtZabty4QafT4dKlSx5MipwTXK+fsJHS45WmqZcPxnHsYxfk/QLWJDOv1WoxHo89AFxkEqvVqneGrFarPqNNJJBhGLK+vk6pVOLWrVue6er1egyHQ65cueIBp4Cb+++/nyRJODk54fT0lDRNueeee3juuef8F2OpVPKOoJKTF8cxly5d8rJSiVS4evUqJycnLC0t+WO1vLzMysoK7Xabra0tH31QqVRYXV1lMBgwHA75q3/1r/KLv/iL3Lhxw8cE1Go1rl696hk1kc52Oh3Ozs5YXV3l1q1bnqn72Mc+RhRFfOYzn2Fzc5PNzU12dnbY39/3LON4PGYwGHgH0c9+9rOsrq5yeHhIp9NhMpl4x1IBmXdkyTXF4g3jBRMTE+YgyuRknJ0DNjHJEHmm9CoJvkkrOCYpB302wLssKnFYXGDcpF9LGDaRAy4GjstyIvfU6Xy8VrkL+bSuMa0q2Ap6uMTvu/wI//zG+wEXQxCQOWbNGmI0kTJUSHIzkgU0i+t1c8Yn7utqYCpkOUvnAV0eOeAcG91ygcrDsrMqWa57nOZMoFaGqY3omQpve+r9fN8PvIZwZkjiAKshSK2PbAji+XFAQRooH+MgLJu2ed9afqwWAbO21sUbGItOVT6nilI/Z/HkODJ3rBQJpoB5YcQInMTSBPDM268Rdyw/2VpDTzVmfcaFjR6BspTDlLubx5R1ylI0JrNujoXVjFTGKC3zxOEmFZH0qgVmNnHjyiLlTXKC2fyYmFARTp0roc6cnNKzjsU18itY8y8RNRdQu+cCySJRaGPcjQljCS00AIsl1hBXKwzbVZKNFrzpCmwuO/OSYR+GXRgfw7gLkxms1F2PW7XqpJMaiDRENfe7NI9GgfsCi2O3sTBfbmIgLDtgaXSeQWCdKUopgEiBjmCp7tbdnkBvCtfWse0KaW9I1p2gpikqNrgQE5tbooDxrDEFU3wH10NbbU5GMftnUy60q6/0cIoq6lVVLwrkOp0Ozz//PK1WC8CzTBI3IGHQi3JIMTRZZG0ErDWbTbfBMPRZYWLEAfgeNHGbBHxmnQAnrbU3OllaWvIxAfJ+iSAQNm99fd2bhKyvr3N6eupldlEUeRAgvVUifVyU90lEwuJPMX+RfRZXR2EsBTgtLy9zeHjI+vq6D66W/jjplcuyzMsVBahZa2k2mz4gW3r/Wq2WB7DD4ZDNzU06nQ7Xr1/n4ODAz4+wZeI8KWC8Xp83Eovb5Ww286xgo9HwIFJAVrXqvlTFEKVWq3kHSIkyaLVa7O7uMhwOPXi6fPky+/v7Xhb5nve8hyAIePjhh3nzm9/M2toa4/GY/f19lFJeWpokCaenp/747u7u+vXv7Oxwenrqj2Or1fI9iXLDQD6bh4eHHtCLLPZOBXK+B05Ys9suhAUc2MWcuQUA5hYCcvdDlZHnnwFVx+joWS6XzJ+3+XZN5MwwbH6Rro2F1IXsLkYdyPiEGfS9XpkDNEbGoN2/tKxIWiXCUYIql9DlMjWlGBjL/5+9Pw2SLkvv+7DfOXfJPbP2qnfrfnt6ujEzPQNwBgNQ4gJBEjcREila1BJaKJIRoBfJkmz5iyRToQ8OyRGWHLbCkm1ZNhQMSqRA0kFAgACSoEWQWEiMgNl61rfn7e53rb1yX+5yjj885zmZ1YOehZyZbgj1RLxdW+a9J2/eqr7/+986NlxYeimwTrwnC1UEiakpQjSkC+DLspZUwpqF0zLwBBdBHIi8Utm5pi1ZuoymKWNRuCRcStDK0mVcuRnJdAX7jWsSU+/WZd1y0NfHYh1Gsj5GIM+xPgCbIIOMgTJsHDfnJRkzFVlltvLUuWGDYJTtvePiU4+/rYXBS2eGdJaId/GiycnpIe5ghc0cjaTiVmuMxXNVNbFGXrvDsHIpJ4s+s2c90qaJklBN3YQQ3LJxrig759INH6Fbg7hNqe3NvBej0G39Bhgr75N3FloplB5TOdKqJCEhwZBi2AXOEjjJDdzah5d34bVb8C//Lvi7X4avPoG//iYc1HCvBy93YdaE116C3gAuDfhC2L4khSHCnK1qWJaQejHfzgrYakMjgzSBxQLSpqROXkxhkAmoS5oBIIa7KasCshRaOcw8/EMv4Rcr6tEcfv0x9tEl9nxGQYahwOBJMLjURolwlQBO78BoEMrNvB/mA/tdmpnl9afjGyB3Mzfzbc67AjkFXtontlkIruXcRVHESPnNUJA0TWPkv8oF1TOnkfPaezYajbh37x7NZjN6r1Ta2Ol0mE6ncZvqy0rTlNFoFDvUNOhDgYp2lu3s7DAej+n1esxmM+bzOc1mM6ZEavCHMlSdTidWAGgs/vb2dgSLmmypQSjKgKlsc7lcRpkiEIu13377bay17O/vx5TIuq6jj0x9fuq9297ejizVV7/6VbIs46WXXuL8/Jxms8m9e/d4+PAhT5484fOf/zyNRiP21zUajbgOTcacTqfs7e1FX6ACGk0i7Xa7MXFTQbLKFm/dukWv14sslzKHn/3sZyOj+JWvfIWiKNjb24v+utu3bzObzaL/Lk1Tzs/PKYqCk5MTzs7OaDab3L17N4agzGYziqKIPr6rqyvefvttbt++zWc+85mY4jmbzXj27BlJkvDhD3+Y4XAYWTotMFeZ63Q6ZTAYRGnr+228IYZkwIa0MrBnm1H26GM17XCjbkAvuAlsWWSUMNjSrC/Q/RoMmAqsSuMCwJDeM5EjuVzCN7wmM7o1c4QVVZWuR1+CLQJIsQJSzKrGlyVYy79073fz/370S9Te0wxeq5qQRhvKwSeuSccUnLl+kEKuwbd2xGkK5cw16NhVBCiFT3DeYo0jD9utw9frSoIkPL8mMxVz32DpPXY0o3nWYLHTXjNMqYkSSb0YNDV4DaFRFjJZJ1aC+uDWIE49Z/YdHkaXy/uQFFA11xffPpFj6gMDGP/p+RL2ayvIg60kWXlhEhcGf9zEW3jjwUt8NfN86RMnbDUX7Den1N7gvOXJdIvHp9s0nyUxnETPMVvIR5cJMDVoGqcJjK8UpGOkDsEnBqMhPalZ9+XdzPdsrlu+QqqjAeeCnDK1sILc1aQ4UlI8NS0MO2R8JYdiewvu7sKf/J0wSMXr9t/8NIxnwsj9wXtAEz54B27twZtj2N+VHc3PoDsIdH4Fz8YhwCQRNs7VsshOAGh5IuvKE1jMoajkX5JD20LHihSzKsRPZxNodyFrwfQUegfhb88K2i3q4yn18QS+8Db50EJds8prWiuRVRaZISkrnJHfzXWv3vqo3cx7N4k1fPhWny88G/H7P3L4Xi/nZm7mt9S8K5Ary5J79+6xvb0dI/I3L8a1uyzPc1arVZQ99vv9CIhUium9j0ze48ePOTk54fT0lLIsY4HzZiiFXnR3Oh2eP38eWSmNj1fQ9Pjx4xh04b2Pnq579+6xt7dHXdeRYdva2mIymcSuMecc0+mU4XAYn3/r1i1u375Nv9+P3W/aT5emKXt7e4CwU8rOKWjQrj1NUpzP57GYe29vj+Pj4yhBVfZPAaCmg966dYvlcslwOKTVarFcLmm32xF4NhoN7ty5Q1mW0QOnYTKnp6cMBgOOjo6iFFVL07V+QMGn9z6GsNy7dy++53VdRzCk/kdrbQxL+cVf/EXKsmRvb4+DgwP29/c5OTmh0WhEeeV0OuXRo0c456Kf7/79+7Tb7djf9+TJk1hv8eabb/JjP/ZjNJtNtra2eOONN7h79y5/42/8DR49esTLL7/MgwcPuLy8jNUUyhKnacrV1VUEw/1+n4uLi5gIOhqNAK6do++3icwaRKAVvxcYMVsSvVsaPpKs2CjpXrMgxkuQRlLI95pIifRqJ7ByEBkdgCpfX8BrGqFKJbNjR7qS9MU6N9S5+LqiDNN7TBkYmkJehFYkeAvpssbOlviRoI2ffvopnlXBpgM0jWESssIn4eq/9ClLfGDbTGTlMqr4c4Cly+kEL9zcNYS1Cx665oZpUHxyjsyIlFN/VvqUs6pPjeU4vcKdX5Js9zZkpSaCNaOySoiAJcomQ3ecCSBGwZqCPxBgmwQwber1RaNxUOfhvdgIOFHQ6PINltaFuP8sdPeF4+0y6aJziWwiXQqzB8RAkotfOeLprYqdu0OyRNIrnz7co3mSkk2hOfSULXmOSyCt5T2PHXrvuAFgyzU7VzUlHEWZxFiAfjPf09FAfvPO76UipzS1wboaj5NAobQmqxNco8nF7oCiZ3AfPIRXb8FiKuCpWgmQ+uA+7Pfh1i48K8B1YGyhMvB8FHZmJNHVe6kVcFVQDNiwrfBHJgm/VBZIzfruhrXSY+ecADqLJFumaeidszBeyPZvHUIJVKXIMDtteKkDhzuwKqieXWHGc+xkFipPQqgQofvRGJFcRhnBzbwf5qO3B7z+9Cbw5GZu5tuddwVyy+WS3d3dWBWgMkpNm1R2rK7rGDKxWq3odDoMBgPG43GM59fnaeVAr9eL0j8NMFHpW6/XwznH3t4eV1dXMW7+1q1bPHnyhDzPuXXrVizt1lj909NTqqqi2+3SbDY5ODhge3ub8/NzQC7+Dw8PGY/HMYbeOUee55yennLr1i2893F/mwXoVVXFOgYtBq/rOr5mZba0B06Bk4aqGGPY2dlhNpuRpilPnz6NYKQoCjqdTvRwqfxyNBpFpqzZbNLpdHj48GH8emtrK4IzfQ0a2KLHWCWcm2ufzWbs7u5G9k/797Isi+AzSZIYGgPEIJvVahUZWO89T5484bXXXgPg9PSUN998M8pd33jjDT7xiU+QpilbW1ukacrJyUlMCdUkSwVfmnD5/PlzTk5OGA6HdDqdWCiu56CCyyzLyPM8HlvvPcPhkPF4fC2IR8Ngjo6Oogfy/TSaYggiydN5Z31AjK7Xa5+NTrnI2tVrli5ZedKVo6gti3xDaqXyypooxdQL8ZhemQjblq482bSmUThJJnSw3MtZ7FmSZQCQiYAK3b/LwnVZ5XFJWDDgipKzesXEpyxDiW/TOOY+i1UDO8mcLTvnwnVoWqkIKH16rVpAvF4VGJFaLl3GzDXo2UVk7GpvSNCwFMNm9sYmw3fmerFTzm4NKNtZZNVi1YNKURtEP+ImQNt8v/TYa8CJpjkS/HMKcl0KPjGRdXWbfjgF55sgTn2Q4f1zCZAHn54x+HDiGC00JwA6rwwaQMqlHWDbFSbxZKOEZKnnkkjNYll5qDdw+cbrtxuSU71p4IRJtPV1maXWLtzMd342CNl3+amcnAK+DSQG44RZT5FUWGfBpJDYJkW/z+ilAzhM4WO34fsO4bMPwK3E07bVgY/chb0d6GxLCMncwHwJ8wLOZ7Lr/gDqoEeuSqSPY4Px0nK3JIA4awS8WR+UBla8csUygEAvn3fawuBZC6O5fLx3G06vAmPnBOhtd4X9G86pU4957rGTecRqifdUEGoKPM5ajBHT8dcfz298lG/muzMfvdPnF7508l4v42Zu5rfcvCuQq6oqll0ro+a9j4XO1tp40a+gQUFMURRMp1Occ5RlSbvdjt1saZoyHo85Pj4mTdNYW2CMiSCu1+uxs7MTQ0p0/1tbWxRFwfPnz3n8+DHf//3fT1VVlGVJs9nkK1/5Cm+++SaPHz/m/Pw8hmvcvn2bL3/5yzjnODk5IUkSBoNBBH7jsdwFms/nMZVSfXoq0dssN7fW0mw2mc1mkVWz1kYGcDabcffu3chcanKmFljneR7ZxV6vR1mWnJ+f0+v1YiG41gGcn59HJurw8JDpdBqPnwLRbrcbZYzOOc7Pz6O0cjQa8cYbb7C7u8v3f//3s7u7GxMylUFVH6EmeX7sYx+LssyzszMuLi5oNBr8oT/0h1itVnzuc5/jzTff5M6dOzx48IDJZBJDWsqyZGtri9VqxcOHD7l9+zZnZ2dR4tlsNlksFmxvb/P222+zWCz48pe/HEHl5z73OY6Pj3n+/Dnb29vM5/MYYAPEcBgQEHz//n1OT08j66YS1bquYwrncrmM3sH32wRMEr6QDxFE6NcbQSO2DimVfn2BDXIRn6wEwJlawFXjqsSWoVB7Wx4YkyxDoEXdCM/X9MwAJNKVPD8drkhGMyhK/HRKWlb0+z18v8v8g9sstxLqXDx10btVeZrDmuxqiZkt+O++9itM/YovFS0KkiiDzE1N05SMXVOYuFAnoB44F8GYJTOSNqlgDYRV00RLfWxiPDPXYOmhY1fkpo4yyjpsf+Ya1N5wL7ukZxd8OIPyxX1WOw3yqY8hLhr0ERNDlY3yPnjbRB7qTQAzCRugJojcrAC6CMB0/Br0viPbJb4/6XIN5pQdtEupRnDhfUxKAdE+BWKiqHTeJd7H97R5aYAM15Dzwa4M2UzWUXZsBGeSwGmu12KoRzLRc0Rks9nChwTPjUt2S6xduJnv7Lw7PDbhz4WTU8lYATyZJVtZvK/xlFQkNJuePLHksy0uP3SH8qU+fLQD/8iLcDmCtx7CQRfKXLxsv//j8GQBz+Zw/LYEmJQLkV1WIX0pMcKkXRjILTStgMB2JlLK3VwAmyZXqtSyrCDvwnwuHji3gIsh5MBeC7IuPBvC5DncvyP9c9bD46ewMpBnsL0Do2fC1jVy+B13YdDB751Tpwn510bUZUlJTQNDaQ2VMaR1TW1NkKPfgLb3w7x2e8Dz0ZKL6YrdbuO9Xs7N3MxvmfmGqZVJkjCbzSJIaTabeO+vMUgaQqJBH8pk1XUdQ0OUOVHWKEmS2DfWarViPP54PKbVasVAj8FgEKWLi8WC0WgUI/1v376NMYb9/f3oRXv27FkMT3nrrbeo65r9/f3ItCm7poEdKnHs9/uxTFt9fpokqaBBmUNNXTTG0Ol0IuhrNBrxOHU6nWt9eCq53N3djT12l5eXUV6oFQyz2Sz6B5fLJZ/73OdI05Sjo6OYEPnVr36V0WjE9vZ2BIo7OzuxR08B4mQyif5BBW/qEdQuv729vcjS6Wvu9Xrs7+9zeXnJaDRiuVxGZrDX6zGdTtnZ2eHy8pKTkxPqumY6ncZAl83uucViwd/7e38vVjQkSRJTLk9PT2NB+a/+6q/S7XbZ2dnh+PiYq6ureMy1szDP8+jXXK1W8Xwcj8fx5oFKXbUaQplX9QWq1/H9NJEBc9fvARu/vliXb2wwaeHnfuOG96b3Si7cC7KzGekoBd9hXFuScv3czf3H3rBsLd3zBuyqxq5KWBX42Qw3W+CrErdYYs7O6RQlfPiAspvEYJQkFEPb0pOMZvjplKlfMXF1SJ5MYqXAUn1tWGHXvISSgASWbKZSJj6l9Cm1N9dAHxADTZSNc97Efjog+ONsLBJfuoylz9hK5nTsiv/Zy78XPikH01YS/qIySf2e0JYC0Fy6lpd6I0Bt0zNn6zUBQQR0a1AW5bAbvkSn54BuJ7CjLgcbytptGQJUrFREuFxuBLhsg1k1xJ47h3ysG+vHJHMTmdeqDekMiq6RGwAa2KLnXGAMv46gCMDSJRuPDefoTfXA92iMQU2x67crSBcR5ikvLIWp8KE7pJ866ipjaZvMXzmgGjjolnCQwtUFnE5hVMAf+IgANge8NYInQ7icwcVMAFhmRbJpnCRXVsC0kmJvn8ga+l3xu1WpAC5jgBrqpUgwsyY0Eji/AJNI/cBK0y2BQn8hwl2K2Uoenydgc2gEINfIYKcv20hTYe8Oa3lsv0Ox/CLmfEwynVPiJYjIQ5Wm2GCpEPDLDQn3Hs8rh12yxPCFZ2N+5NX993o5N3Mz3/IYY34U+LMIpvo/A03g3wIWwL/qvX9sjPkI8F8gfwH/rPf+F75T+39XIDeZTBgOhywWi+jh0o9acG2MIcsyvPf0+/1r5d/K1oFckGtXW7vdjuDr9PSUN954IzJRd+/ejbH96nE7OTmJxdyHh4cMh0OstQwGA27dukVVVfFC/ROf+ATD4ZCrq6vYHVYUBWdnZ5E1bDab5HkekyoVuHjvOTo6isyiJkkqA6fgJE1TkiShLMvIVuprVLloo9Hg7OwMIAKk1WrF22+/HY/jCy+8ECsNtJbgpZde4sGDBxHITKdT7t69y+HhIXme473nB37gBwBiF9ujR494/fXXeeGFFyjLkqurK5xzTCYTjo6OGI/H8b34vu/7PmazWQTCuj5lPHX9T548AUReu7e3F8GsMmvqxXv27Bnj8ZjLy0sA9vb2Ins4n8/p9/ux0F1L4vUc0LTQq6srLi8vuX//Pl/96ldjrcX+/j6dTodWq8VgMIjnjAIyBWrz+ZydnR2SJKHf78fSei2s19dUFMX7Esilcx+TJEEuuDW9sJZ7EtcYGvEnbTA10au1ZoHSlSd7PobLITZNaS8K2nf2We6Ei/iNLjirNQJmg3UJQGO105CEu9EUX5T4quS/f/LrLHzB3Nc0jOWfe+H30Ll9RH1rh7qRkI6XkWHykxn1eMrblWHouixdxtzLndaly0JfnImVAVryPXMNCTUJQSWlTyOLBkQQpyCv9EkEflIvoEEnhpqEBMskVBDIY2s6dsWH8jNezTrYD95n1U0DoDXrVEojYCWpQ7VAYiLjpYDKG7C1pDgmhY/g5p39gJrq6FkDoKS4/v5udvmZcGGZBBBn3Ib3LSRM2nKdLLmZOpmEIBIbQJ6EtniyZB1EYguoWuG8mq/BpkvWCZtJCZRrwBnlt148mC5Zs2/r17n2793Md36uHVkDxpsoqFSptcVgnQkdapL1mgCZSahMTpG1qLcbsO1g20iwyXAudx+2+zDohc63At6+hIuxlHrPC5E9NjIJMslquVHhTKgacMHrBmS5aIYLBJg5XSRQe5FgOqQnLknlH+W6IqFAwFijKSd27eROk00FtDXDGvJU1luHA5I3oNuS7TTb1C+eSpBmXVEtV8GeF8yovBvLeXP+vhfTSBNePezx+rPRDZC7md8yY4xpAv828E947wtjTAb8EvB7gR9CAN6fAf5D4E8BJ8DPA999IHdxcREDSZSxurq6ismGytQou3Xr1i22trb49Kc/zXg8jsxLmqZRpqjAqCiKWN6tsfnz+Zzz83NarRa3bt1iNBpFsKUeueVyyeHhIQ8ePKAoCh49ehRLvp1zvPTSSyyXS54/fx6BnPrSQNIs9/flD4SmPO7t7UVw0mw2YwWCc47RaBTXqh11ynypV0u9Y7qPNE2jjFRTL7VYXL+nxdqDwYDlckmr1WI+n/M3/+bf5PLykq997Ws0Gg1eeuklfuiHfih6ws7OzqIM0xjD2dkZ0+mUk5MTlstlDIxpt9vs7OzQarVid1+aplxeXtLr9Wi326xWK6bTadx/kiQxSGV7e5vJZEJRFPz0T/80AC+//DKHh4c0m02ePHnC+fk53W6XVqsVw2i0dHs8HtPv9yPYN8ZEdm00GsXAF2UU+/0+Dx8+jGypAriDgwOazWaUeQ6HQ87OziKw1j7B+XxOVVUcHx9HL52+Jg3ZUSb5/Tbd5xX5VYEtKrCW1W4TlxlmRwl100jIRgAVtljLKjell7YUoKFet3ThYDTBrwpBes7ROnesBsm63mCDCdQ0TL8h/fPWkBQOUzvq03P+wsO/xZnzfK2CnvHMPQxx/Fdv/SITb2gaSaL8k6/9E9BqYrKMn/7MX+PL5Yq3qm0AhnVnDbgCothMply6jLFrSSm4MSTGY0O1wNJn8nlADLUXf5w1EoziAjUkANCAsdQ+x3lh+hTA3c6uuJNe0TQV/5sf+RdwvQ6LF3u43AQZpBwbY4PPzcmx8Mma1apaqnlVllTklAq80XRKt3FxvVEMnpQerx1+6m8M70eUJRpIl05A/UahuMT+m2vPUw+dhqAou+cyE74vgTcmZEjE1Eu1MSlbGHx6yty+c5JQkJ6s5FxL3Pr1eyvA1m54CG/mOzvBCRl+70Wum2Co0RsBHnxNsxYlwpwliRfyqmENdblFtd+g3s6ACbxyAPcHsNOCz8zh+1+ET3wAvngBoylcjeHhE2g2JTWykcIygaKEYiXosNsT5q1E2DzvoIE8rnbgSgFldSHhJp0mLAs4H8HZBJI2bKWQIR47k4pkc14K0zYIPzsdSSpmnkK1hEE3sHcGOh2pNVhV8ljbFMawv4J/+DXc4TPcFx7CF58g+T2GpCqprZUES+dusNv7ZD56e8AXbgJPbua31vwuhHn774wxc+D/BHzBe18Av2yM+Y/D42557x8AGGMujDF73vvz78QC3hXIvfnmmwwGA/I8jzJKTUNUZkZDK1Q+uVwuI0M3HA5j+qMWapdlGaPoW60WR0dHnJycsL+/T6vVipJF9TqBMDtJksRy6qIoYvqkJksWRRH70qbTaWTZ1M+XZVlMLFRf2abnSjvhdP0qu1TACsTgEw0OUUauLEuyLKPRaMQAlsFgEINOXnrpJZ48ecJsNmN/fz/WDmjZ+Pn5Od57RqMRP/uzP4v3PiZnagKoc46rqyuyLGM8HlPXNTs7O9ELpj178/kcay3D4ZBGo8G9e/cwxjAcDmk2mzQajVjA/fz58+hn0/j/LMvY2dlhPp9zcnLC8fFxlLWq7FVZWj3ep6enEbRpL5+WlR8dHUX5qrKYOzs7kYVsNpsxZVL9lFpj0G63abVadLtdvPcxFMY5R7fbZTgc0u1243vgvY9yy8VicS2xVMG1Si3fT9M8W2KHM0xZ4dOEhvcUO01smcgFevgNlVj/8KTA0HhjYsDGJkuHB5Pn+MkUv3SY4YTWaZ/hy+sKBp9sgA0NVtHuuMjASH3AX3nzl3heO2pvmfuU2lTkxlF6y6WHmU/pmIra1PzUl/4H/sm7n8QkCX93BRf1LkufkbzjSkkBXWJ89L4tXRYSJis6tiAxjsIn2FAWrjUDw7otMksMztnIwGWmIgusnljWBACuXMYgmdO0JXfSKz7ZqPmj938P7od28NZQN+y6+Ny8o0bACgNlKgn2qHMTAZyympupjZtF4Hqc5ZPr75s+z22AaafeyMjOCrjEC1Nma4/LpHdOWQ4tZ79WT7AhuYV14iZB+mo8FH1DNpYAFgGuRMbQB+AZzxVrvm6bIrs0AuIC0NTz8Ga+mxM8mOGrNYgDsKS1ZYU02DcQXFT7jEndwKdzORe6Gfyu2+JDqyx8bQY/cF9A2VtjeHIKjy9gEnxnhRFwVVbB/5aKvFHL2UoDcwedTLrqTAKnl8KypRm0E3n+sobxUkJLRiuYFJBWQV7poduQ3rnKyHazC9jvwU4b+g0oV1IonicCBtMWtDqyrrQW4FhZaOfy+zHxsGXhw/fgaFeYw6cX+PGCKm2S1AI8PSHF0vsbv9x7PB+90+e//KU33+tl3MzN/GZz1xjzk+Hzv+S9/0vh80PgJeB3A/848B8AX9x4nl4FbAoARsAOcA3IGSmh/re99/8x38a8K5BT8KMgrdvtcn5+ztnZGcPhkIODg1gyvbe3F0uoNz1zWpitEfp6oT2bzTDGcOvWLX7lV34lMnGnp6dYa7m8vOT27dsxHERljcrEgCQpXl1d8cILL0TWB4gX8uoJy7IsblMv7JUp01Ju730EZOrxWywW8XWdn59HUKfAcjQaxWASZaqcc7HIutVq0W63o+xQ16UdahqC8uzZM46Pjzk/P2c4HLK/v89rr70WmVCVlip43NnZodlsMp1OSdOUwWDAarWK4S1a9zAajfjMZz6DMYajoyP6/T6vvvoqz58/p9vtRrnheDyOHj318D169IjZbHYtFOXy8pJms0mv1+Pw8JAnT54wGo2iD7AsyyhNVfCkUsrNc0E9bhqMoiAwz3MODg6i/FGZtKIoYlCMMrBaK6CSUJXyanpop9OJMlhNtCyKIiZjvp/G/4+v85cf/z3+2N0fxqQpyZ1b5LWnnRjKdoZPRYGUrOSC3XgfOspMlOIZ56NnK1lBuqjx0xk4x889/Lv8oRc+SfasTTpvXwtOIbBPm0mE3hh86jGlJxsVmLNLntQlb5XCqpXhb9KWncfXMHRt5qagaUqWfsV//tbfYekTvlwcMqzb1FhyBVkuEwbOWEovskhly5q2lF64kFap8svdZErTlOwkc0pv+Vq5z7DuMKpbsVYgwVMj/jeVZGKgZ5d8rPmYD6QjbqcN/tg/+i8w+oE97D+lEsfrJdzqYYtVABvXdUkA0/adwMkKoElCh54yWz5I3zzCpEXAlqwZLP1e/NyH95g1aNz06MXEyEqsQ3bJugfOh4qC1JBW66ATYR1kyS4TljGdX2fzNC0zJmmaNWCN3XEbbKEgPgmGMXWQdfqN8/FmvifjNz7Rt8WFPwbOgLEZzuTUWYrvAnd7cH8bDvpSE0ACWwMBcYsCng9htISilnOiRuSPDjBG/HANKwmRq5BSSR0kk07YNyMqgCinJBQj1rWweXPthjPynDo8cF7IL0KNPPb4UpIrFx0YdCBJ5I5DkqxffO0k6GRVCli0CZRO1l+Wsj5jRW75wTuAheQKJnNJCTaWyhqs84Ljvgfv2c28+3zk9oC3L+aMlyX95k0h5c28r+aJ9/6f+02+PwR+Kcgq/3/AnwOebPxcb/lu3ubcAi7fuSHvvTfG/JAxJvHe1+/8+bvNuwK53d3dCA52d3djt5gydNPpNHq3rLXxottaS7/fj/45DSdReZsmOGpQytHRUUworKqKyWQS+8fSNI3SzeVySZ7nnJ+fxwAUDSjRx6lcsN1uRx/aeDyOHq80TaMHTtegkj2tD9jb24sBJgcHB1GaaYzhwYMHPH/+nMlkElM08zyPEf6awLm1tcV8Po8Aqa7r6FubTqecnp5ydXXF9vY2Z2dnUUL6gz/4g5FhbLfb1HUdy9G3t7dZLpf0+/0oJVXGcT6fx/dK/WMqO5xMJrEQuygKDg8Pqeua4+NjBoNBrJPQHsDxeBxfn+5bGUwtd9fuOAWXeZ7T7/eZTCaxi248HkfADjCbzSIrqgyietwUMGpnX1EUEfyp51JfrwLVTqcTgZuyeQrINVxn81jq+fN+m598/CtMveOnn36Khsn4wx//A9i3ntHI7sJLWZTDqTcJ1mAOrjMn4o/yZMMl1DVuuWTuCn727V/D4fnd/+6/TtEXn5StQgeaX0sHN7djK7DLCqoqlmjDusdt6Nbs3sw1yGyNNY65T5l7CRjRcBNrPIVPgzetoPRJlFYO6zZbyZwk/I2rvaUg4azqc1r26SZLJnWTo2zEll0w8zmXVZcai/MWhw99cx4b9tc0FdY4tpI5+8mYV7IRP37/HyF94Q7l3Z706jXMWlbq1zH8EdBaE9kzb821vjgFWoSnG+dj+IxPDIluJ5SCqzwTNllT2Yb68bQrcP0myIfoNzNBOhseb9waxOm+Xcqa7QvbkPAT2YbLTayG8DaAutqTVIGNRD7aeg3gdE0xrMWp5DSsa+Mx8Sr4Nzce3cy7zDvJzm9l/OZnPkiC8dQb1wplAtiWyBFbCRy24ftvwSt7AmyeD6GZwwfvCgt2fgFvPYW6I3LJloXZUtizNIFeA8qQSplaGDph1FIvP18UyN2ZBLptWWRRwXIhaZb4ALCCl66ZwKKW+gAcLErx1uGBCp5cwKmBQRN+x6uw0xSGsPYC5ryXtMvToXzPWOjk4u1brGC1gKUeZAMffhFsJvv7/FdJSMONK0iLihp/A+Te4/nwrR7WwBefjfmHPrD7Xi/nZm7mW5lfQ4JNAD4O/HXgI8aYHPHIfS787NgY8wrikdv5BrLKW8CXjTGfRW+Z/uYAMs67ArnBYMDW1hbGGPr9fvQ/aeKgMh6dToder0dRFGRZFuVx+/v7MVJ/NBpxdXUV6wzUW2aM4d69eywWC548eUKr1eLw8JBbt27R7/cjsHv8+HEs5242m5Fl09CVra2tuF+tMFCflK4DiEEbQGSclElUoPrkyZNY/n1+fh49ZyAyz2fPnnF6esr5+XlknzQB8uMf/zgf+MAHePbsGa+88gqHh4cRUGktQlEUjEYjFosFb7/9Nru7u7zwwgscHBwwGo1YrVbRB6bgUF/narVitVrF5E/1fF1cXER/3+bxvXPnDtZavvSlL/Hw4UMeP34c2a2DgwPa7TZf/OIX2draYjAY8OUvf5nT09NYNF6WJS+88EKM/1fQqeB0NBrF/S6XS7a3t3HOce/ePRqNRiyPV3CrnjwtPZ9MJtEzqdJJ9R+qDHdrayumW87nc4pCEiK0R0+TVfW99d7T6/W4c+dOZPf0vFV29P00Iyc3XRq+Yukrfuo3fo7S1/zxH/wnaX2gw2LHUjeJIRgqtTPh9rEJN7NtDdnc07woSZ6e8xNf+DkyDJfOMXI1bVOz97NfZfk77jN6OY9sjCQbiodK/VSSeuipOxlJr8u9xPGskvj/2ktgyJKMpi1jMMlZ3afpSubKqJGQ4OklciVV+oQEFzvjmrYkwVH6hMKnNE1J4ZMgi7Scln3Oih6fnd8F4GzRYVFk/Guv/CJLn9G2BYNkzqhuC1gMl2CH2Yj7+Rm7ds6/89o/it3egkZO/SM7lKmh2EqpGgKgfLqWItZeQks2O9JMbTakpxvoxINRids7WCifGPGj1esky02gB2ZdZ7ABInXMBi2QLv2aYVv5dbS/3wDwQQ5ZN8y13rkYurKRZpms1oEpyQpc6klXuj8jDKSCuPCt6POL6wPcuhMvduptrv0GyH3b8+0CCL2N4DFBHihf5xhKPN4bTJmSlQVuu031ygF8rAf7XWHCLmewvw+9Nlyt4PIErpbgW0EGWcJ8BacX0OtIwEmzLb65opAwEbeS0m4bEiNZQdKQPri8IR1wSQbHQ/HQeS/3pleV/MLVRkJUOi1Ic8RcGg6GB148gGUl4O/tS6kqyFNInQC2ZthPoylhK7WHszm4Qu5+NXsCNC8mcDKSoJZBC77vLjw6ZrlYkVQV7ZVjkSUY50lrJ4Au3Hjhhl3+nk47T3l5v8vrT0c3QO5mfkuM9/7CGPPTxpi/jVxS/Wngh4FfRG4l/Ynw0H8X+AlEovDvf4NN/ivf7hreFcgpiNPo+EajEYM/jDFcXV1F+aDWDKxWq8icWGs5OjqiKAqePHkSAzuUxdKwiw996EP0+32ePHnCb/zGb/DSSy/x8ssvs1qtooxOg0HOz8+j/HI+nzObzWJ/WFVVUUZXVRXOucj2ee9ptVq0Wq34c2XMNHlSGbDxeBzDPlQWqMDwxRdf5OTkJCYrHhwcRNC3yWDN53Nef/11tre3uby8pNFoRGlnv9+PwTAf+chHGAwGzGaz6A2rqorLy8sYtjIcDgGi/FQZNi299t6zs7MTu/SUjbp9+zatVivKJ4fDId57lsslOzs7XFxcUBQFP/zDP4y1luPjY375l385gl4NYtGOt+3tbV555ZUo31QvowbezOfzKEfVY/jyyy/zuc99jrpeX6mqf7Kua9rtNtPpNKZ2alfhO0vj8zxnNptFD6P6AdXDqYmkyvL1+/14k0HBtnPufZlaeRYSMiauxuI5SlZ0rYQD5eOasmXwodcrhl4YoCImUOrFdDatyc/n/H9//Wd4oxQGbeYbAnySKX/u0z9Nz+b84T/xv2B+kMUYfYwkF4o3Spg6kQJ6fJbSt83gP6vIzJzjagAIm7Z0GTvpFIDEuBBI4pi70MOIE5kjBBmkrGsrmUmRd7IM6ZKWfrJk6TJu51f8Y+03SAz8+P1/hPkf/STzOwntU8d/ffljpLOK7GTEX/rbP8nPzPeZuwYfazyh9Al30wX/89/5x/Hbfaof6lB2UnxiKNs2VgfYSo6fS5E/qQGQSG/cWgLp01DWrRH/ylIFz5iyXSYwcTH4JLB4LhEwFhmzzATfWwBWpbBbSeGpGmufmTeBLa09iTMSMuLlscKmmWtX/hEYbqRL2iCZdHn4XhpSJksfk09NIgyeysqSwseSb/G7yWM3gVksC0/XzJ6ARx+Pzw2Q+/Znwxr5LT0WfXzwSloMBhNYJY/BkOFwWJypwRTCgA1nMFrA/qGEhAA8P5cut9IIW7WqxIO2WIVESSsSxaUm0gYzpH6OEcCTNMDkcmIluQA1VwuLNl3AagXzGXQ74oWblnKy10H36w1SxogEo0Ry0cNkCcOpfJ56uXKpjay50QJTAlWoOkhFVjmZiiy0CJLL2TxIPj28eo/kS29hypIisfjw/cjJ3Xjl3rP56J0BX3h2E3hyM791xnv/nwH/2ca3HgJ/8R2P+SLwe76FzY2A/zXwQeAB8H/7Zk94VyAHRCAwHA4xxkSmBIjMjwKIqqrI8zxGvitQm8/nsexZ+75arVa8qNbS636/T13XPHnyJLI1IF64brfLdDqNa9GqgFarFSV1KsVT+aSmQ2o1ggZ+qK9L2Rx9rrI2Z2dnMUBEKxP6/X58zbdu3Yrx/Ht7e7HfbTQaRfZxuVzy+uuvR8bs4OCAsiy5e/cueZ5HYKQ/15L03d1dRqNRBEuz2YzpVC6StXD7zp07HBwcsLOzE6Wh0+k0Sl5VypimKU+fPuXi4iKyWcqinp2dsbu7S13XzOdzPvnJT9Lv93n27FkEaVVV0ev1IljTJMl2u83Tp0+jL04BkoaSKJBdrVaUZUld1zHpVL1xytxqLYOGkGiCpkpptcxbQ2SSJIkyz36/H2W9WosB4kXUPj9lDVVa+34EcplxOC8yRICZr8m8dBDGi2NYR/onKrNcs3SRFanlrvTIFVECKUEjjolPwVVcuoLGZ96E3/ES09t53I43xMh7KQv3JLMC0oQ/fOcT/Dtf+5xIJ12D3NSxtDszNQkeh4ShLMmEMcJRYzfCR0xg6STAZOlyEjwTt2b2kvAc5y1NAyd1hvvd3w8I0HQJrHYylrsZzU7KP/3P/jjZozOqp8/4i42XMB9+GXs1oXh5F59ZXGYFUGVB1mjNRhiJhHQERVoM+IgR+6GLbbMaIHrUNBxmQ5Kp3jNBdR4bPlfgpSBO0y03S7OVFYzvo1u/x96sJZvy2OCVS8K20o3HWQVYsp2k9FQhiVP9fS6TfSWlvyahlOMT1qIsYh2OicpErbxWuxGK4w2REY6+wc1uuZv5+5rrwG791TUQZ8JngYm1GMrwh8LiSfBUeYJrGMjDCTVbyd2JOy0JIilWUsLtPXI5YOVvTVmLjy3LRAbpPCxXgJps3XoRxojU0W7UA2CFSQPpdnNz8bEtVrC7KymWrgz7C566GMVrpGS8LNeAalnCeC4/bliRhFZA5gW4JXKzgzwATwPRd1c5YQzLSthEa+HeIclbz/HLFSVA5WKnnMHEWqFv5126me/MvHa7z3/7qcfv9TJu5mbeq/nzCAj8SUSa+V8DP/aNnvCuQE6Lpk9PT2OqoF5U7+3tcXh4yOnp6bXibGW+lCGrqorZbBZ9ULPZLKZBttttDg4OYnjI7du3aTabPH/+nF/7tV9jPp+zu7vLSy+9FD1hKn88OjqK8kFlXDbLsFutVvy+sjQaZqKAQuWSxhhmsxlABKGXl5d0u10uLy+jhNNay9bWFh/72MciW3T79m1efvnlmKo5Go3i6/jIRz4SpYKTySTKC7XnbDKZRN/c3bt32d/f5/j4ONY6KEjd2tq6JuO8vLzkzTff5OjoKCaCai2C+tu899H/1ul0OD8/58UXX6Sua7rdLv1+n8PDQ8bjMS+//DJf+tKX+I3f+A0A7t27x2Aw4MGDB1RVFX2IWnCuTNpisYgJlMoeao+cpkm+8cYbEeRvb29T1zWLxSJ29Ck4res6griyLGMiabPZ5PDwMJ5jDx48iKBPmUBlfzdDVZrNZvTWbfor349AbhkMRs5ZmqZi7h1NX+OXSwEBCdiNXi6XmcjIbTIfSeFpXK4wx2fUXnxjE9cUnxoJyzrjEo81jn/vU7/A92UL/sV//n/F4rBJnYtvrs4M2cKTj2uax3PscAq14//x9i/x+eKA3NQUPmEW2La2XZEg8f+9ZMGw7sTgkaYtWAZNXoKjJKPGxy44Ba7a7QYi3ezYgp1kzp/6wI9itwZUP5hQ54YsALk6gKrVTsZqO8XcuUc6uxPBVflKL5Rgm+gBrDb8cOrzimEjtYAQl6573TS4w9YiBRP/WQBlAfxJaqUP7JS5BqbThaPs2AjwIHQDGii7hmzmSYLnTpk6DUOJPrywRlsJkKpaEnCjkkplEBW0eS38LtfeNU3WVEmm+uhItaoAksJRtmz0X3or+9CbBJvl57b01wCc9teBylTNNWnozXxr866HK0hxN1Mq4+NFywoYEg/OWmpjwTlSDxjDwmTw2gG8tAv3d+D8Eg4OYHcHej24nIqPDERieTqD4yuRK6YZdKyEjQSwjreSGJmETpR6Ca02tDsw6MNoJrJNn8LlWABdlsHBDrQW8jva68CwgvFK/qUK3hLZb11I0EmlJ6BSzQgQXFXQ6cK4gHEJfgbGynabzbDOAjoN2HsVPvVlAavGin9vMZd1bO1Q3N6T7JTjS+pWMyZz5khQp9M3wW9mFNzMd3teuz3ga2dfYlHUtPLkmz/hZm7mf1rT9d7/+fD5V4wxP/7NnvCuQE57urQcW793fHwcwY2GbWiSZFmW8eJagUdRFBhjmEwm0du2vb3NdDrFe89sNqPX69Hr9Tg/P489aePxmIODAx4/fszt27c5Pz/n2bNnMU3TGMPl5SV5nnN8fMzdu3cjQCuKgrqu8d7z1ltv0e/3OTg4iD4+BRSNRoMkSSIjp59rH5uGcKhfDYRdWywW7O/vc/v2bbIs4+joKB6fTqfDdDrl6OiIsiwZDAZ0Oh1OT0+pqiqyg5p4OR6POT095c6dO/FYNhoNptMp9+/f5/z8nA9+8IO8+eabcd2LxSL6DdM0ZTKZxLh+DVjRxMizszP29/dpt9vMZrOY6jgej1mtVlxdXfHmm29SVRV37twBuOa/c87F0BCtIlDgq4BpPp/HIvRNsFwUBZeXl+zt7cWwm6IoYqm6gn89TloarvJcZUL13Op2u9eqBlTy6pyj3+8znU4ZDAYx6EQZR2VXNyWe75dx3kZQAzB3KVDhl6sobatz4s3fTZbGhuuLpPDk05rk+Ip6NGHuYelTZj6nZ5fMXYMiBJZYHLvJlLerjOTzD8nar0IvjcxMunTk45Lk+AK/XEFdM3IZDsvSW5qmvCaXXPqMy6rLl5a3qb3lw61nYCqWLsd5S+ETclNHD5yuQesIclPFrjidy7rNz779a/yTr/5ebOWvsUwCxgwu8Rgv5rayl5AUjjq31Ll4tVTyF4vTk/XnLtkIGalVxigAWRm0ZOWjZBAFUB68+t3Uf+ZlHQrEbOFjbYDxYAsXPvcUHYvLpLBdRxkvTcKUEuf1+aBMm/oiNz1rMXAkXPDbakOaqUmSyu4FBjJZitwyWQmz5pJ1amcEt+/skVMFrjJzJrxud72/MJ7GN9LKv++5duiMDYyUj53afvNB4e13iDzWhnC0GotvN+GFPfGEZYkwXnUK8wqYwvFcwkwooVxIUMkKAUOVERlkXYokESMfTSbSxbKQ7XUH4oEzCWQpbHehKqBcynOWpUgb04mwctYECWchjF/t5fGuEoDYakiXnPdBzhkiUY2T7Ve1rHNRCLtW1SKbdCl0V9Btyuvd24NWLuxgpy0hKkUhRzDN5EQeTWBrIDWbRQkr+ZuUYKmo10zgzbn8PZ+P3O7jPHzpeMwnXth+r5dzMzfzvZ6nxpj/EPgU4rV78k0e/409cvP5HGNMLPTWi/tms8lkMokpjSqR2yzTHg6HMaLee8/BwQF3796NHW3379/HGEOr1Yog4OMf/zhnZ2c8efKE09NTPv3pT7O7u8vV1VUM/JjNZhHstFottra2InujQRlAZKmOjo7Y2toCiNUCBwcHsQ7BWstoNIr+OQUCmkSp4FT76NrtNi+99BJXV1fcv3+f4XAYQYYxhoODg5gaOZ/POT095fDwMAarKCg6Pz/n6dOnsRvu4uKCw8NDnj17FrdhreVDH/pQlC+enZ1x//59BoMBzjkePHjAeDyOoSMvvvhi7JdLkiSmYX7gAx8gyzLefPNNptMpw+GQTqfDhz/84ShtXCwWsfdtMplwdHQUAVqaprGWQPv+kiTh8ePHDIdDkiSJ4SPPnz8HiCXdzWaTq6urKLXVmwLe+9jvtlwur6VNKrN7dXVFu92O4FtBKxDX1Ww243tZFEW8waBJqhqao9LZ99vMvHjkSp+yNNK3NvMVP/21X+aP/BP3ybeyIBHcuK4JUrlk5UmXnnxU0Xw+5a/+3Z/iyi15ULaZOEkInbtGSHW0Mc4fxM/2f3395/k3P1zTvH+XatASRdO8xJ5cUh2f8Bcf/TIT73hWtWLXW23W6ZVLJ0Xb51WX0iVsZzN6dkFuaoZ1OwahaJn30ucC2AzMXM7S56xcJszehq9u4va4lz7kr371b/FH/pmXSZcpRdcG0COgKSlCf1mQ/BUdG6sCtNxa++DqfM2+mWpNbySlABxbgU98fK56BH0igCwJfjWXGbk5bwIDp2Cm9thS/HdVy2ADMybsVWAlQ1l3NiPKV99Zvh3hnV+nZ9YNAWhJGQJoMoMNwAwvALPOhOWDNZNXZ3qeyM9dYkiXfg0cNRAlMSR6s2BjEbbyMYRFpZ8RwOk1rvP4VF+PAGFn1+zkzfz9z7dEavp3+yIAr2YG/VCOvSig0ZA3cVHCNJhEMy+M08qL7jbJBMSFv9PkIUXSWPnnkI8JAoq8FUBW1JJMGW6ukDXEH1cjX7dykUsuFqEo3AlYKgsBXAlr/xoI6Esz2V8V/HjL8MvSSGXbWjOgz6tq6ZBblQIEW6kUh8+WAtwMIe0y+PI6LfAOP5tKgmc0HdZ6FH8zQevNfJdn0Mp4cbfNF56OboDczfx2nH8T+FHgVeB/BP733+wJ7wrkzs/PY1y7MSYCu8FgwNOnTxmNRvytv/W3uHv3LtPpNIKPRqPB22+/zWc+8xnefPNNbt++HTvhlBFTYFJVFQcHBzx9+pT5fM7+/n4EjZt+M5UWqi9KWSJlZNSbpcBAZZx6YX96enotKl/LqPWjMmQKQo0xMZlRAZrWEGjFwdHRUfRrPX36lO3tbQaDQaxP0ITNj3/84zx58iSyfcoUGWPo9Xq89dZblGXJl7/8ZR48eMDe3h7z+ZydnR2MMUyn05jI+OKLL8a6gadPn9Lv96MU8/j4mIcPH/L7ft/vwxgTPXiDwYBPfepTeO959dVXuX37dvTgqY/u85//PJ1OJx6f5XIZj6t67zRlVMHv+fl5lElqEM7V1RWDwYDRaBQBYbPZvNYnN5vN4kf1uGmXnMpjN28IbG1txaCYzbJ1TdXUaovpdBrXoUEsaZrGc03Pi/fblD5l6WVdRZAYJsbxRnnJz/38X+TH/uF/iuS1I1ZbiVwz5Qo2hNnpf+mKn/zrf46lr3lSeS5dTulTslA0NgtALg89bYVPmLgWHbui9Jb/5iu/gDWGf/7+7wUj2Y8/8fB/4KI2PKsNM99g7Jo0TUkzUDW63sRIsMmrzWMmdZOmlcck4Uq+xlK6BtZ4clPFgm7nbGT0Sp8wcU0yU+O8pfQSiPK46nOYzDFlTTp3VC0BIyAASAM5NNQjKaEO8lBNaqyaG0XfKaHfLZSo10QZoEuJKYw2pFRWTRtlinVurqWGKrADImhxqYlBIj6QGIIo16xVsjIBIEmqYJUavPGkK0fVsFI1oIApvE7Zp7xGlwgw09eUrlyUfOpa5Odewl08UZqpBfAKUl1qSILsss7X4SbKZCalj1JJG3rxXCKvR4+vLX2U+mppuktNlGnezLc/8cgF0Iz3a1LoXZIUE6Q7rgyPSbzFlI76cgqffEFYr5MhvPqiALZVAD/LlWygm8LcALn43OpJAFK59LdNC9mnd5Ii2W4KSKxK0TpXHuoxbDXlFyhNYacvVQUqAe9l4nmbpuveuMQHgGmAVAq79aV5JIylnkl6Zr2CuYdZYBfbDaKfzhqYL+X1bLXg9FyA4/3bcHdfWL6roQBG5+TxjVzkl43QcffsktqJJD3HYk2NM7J8bNBZft15fXOef7fmtdt9Xn96E3hyM78t5y9473//t/OEdwVyGpqhQSPqN9MC8CzLePz4MW+//TYvv/xy7AAD+MpXvsKzZ8+iYfju3bvXmBf1PanETsvGNVreOcf+/n688H7y5EmU3y0Wi8g4aRR/o9GgrmtarVaUHq5Wq5hKqQEtu7u7EQAo6NMSbyCWXyuTtJlqqQybpnhOp9PoxdsECOohU3mhgsLhcBgZPZWsjkYj5vM58/mcuq4pyzLKA7WA+/z8PJZrKwPVaDTo9/uxpqDVapHneUwU1fV57zk5OYkSUQXmzrm4Jj0+mio6n885ODjg0aNHdLvdmCbZ7XZJkiSCy36/H4+lcy4ymSpJXSwWEXRuBqZot9x0Oo2JlEmSxPdDAXmn06Hf7zMej6Ms1Hsf2TpNtNRKBg1oAZG4zmYz2u12DFxRhu79NhZH26wE4GCpvcXhmPiM0te480s6XzSY7ztguZPGyPek9GRTh/vqQ75SWkqf0TRV9JvVQbIZvWjekhhH05TkpqZtVvRszdJDguEvvPm3aduMs3rF0BlKLEPXFJ+dtxG8gfTGNU3BVjJnXDfZT8bcSa+AAPK8gNJVYOzadsXMNyJYa9gy1hHUQZenxFSNlW3bBRYbARMQWbJ1emOoT1D2LUgUFUyoZNCGmgXsOqlSYvzXgTKbUfogwER72Yz3GCvMmK0DCAphIOskTAF3PoAdrSgwoS5A2K8Nu01g86IXbqOuQPa/vkyM/rsAOjX4pEo2SsWR7ct2ZD0q8bSVF/ldufYG5qOKspfK8Qiv3W0o2VxqguTTXKtaUE+frlsXqTUNSZCS3sx3YHyEKkFWadbeOC8plSmGGidkk4GalPrFI6kZuN2ExAnBlDdgZYPMsIZuAuVM7n4wkEj/ZQnLuQCtViaSzKISj1npBLQdbMtjJmPpfFMPW94QSWUrgXYGVTixcgtbDfHnzRbS+9ZqCEhsewFexoqXbntL6g4SC1s9SbrEi+yyCImUHikKb+XSXZeksPQwXwjQaiYCztJUPHjbfTjcExDXbMKzSwl8Sdqy7UYOR3twdEB6PiYdz6mlUl1emvehiPw38X6GYKOb+c7Pa7cH/Nzrz9/rZdzMzbwX88AY86cQaaUDNPHyXeddgZzKELWCQC/Su90uh4eH9Hq96IkaDoc8f/6cPM95+vQpjx49YrFYcO/ePT7xiU9w+/ZtLi4uot9Owy+Uter3+7Tb7Qha7t69Gy/YtSxcawY0fl6767RXTuV1CrSUqVJvV1EUTCYTWq0WvV7vmp9P5Z/qh9M1bbJ84/E4bldrBnZ3d6OMUqsSlJXTYvGnT59SVRX37t2jLEvm8zm3b9+OctHN/cznc7z3sVrg+PiYPM/pdru88MILtFqtCHi1L63RaLC1tcXh4SHz+ZzhcMjFxUVkEhXMNBoNnj59GusXXn31VYwx/MzP/Ayr1YrxeMy9e/diBYNKK7W8u6qqCPy05H21WrG1tRX7/jRARgFqr9cDiGscDodRprm1tcVkMolAdjQasb29fc2vqIBR16yM72w249atW1HOuwlQtZJB9w1cY/jeb1OSRJDlwkeAs7rHlbvgr3zlf+CP3fudtMsK+323qDoJpvK0ns/gwdv8qS8+4MvFLXp2ERkzh41+NOdVSllHqWNuaiauxdIPaVoovGfo4bK0WNNg7qSy4KLukpkKF4CcgEOL84YlOU1f0rEFS5/FXjgtCh/VIsO2xokkE8PKZTRsydyJpHLNwlkBGnj52iYc133a9hJTVCSFw7hEAj6sgNhN/5pL14Em8fsQGS6XitxRKxuEzfLrmP1NqWBg7GwV4vq9BppsSi5FShnTI+HrQJyycCBgsG6YWAugjJgNyZjGh5h/L8whobqgzvT51710egzK9kbISgCF6nlTWaVLhLGwNSRLR7qo8dZQ9tLYKefCdaoeC2X4bASarF9XpevwmFC9oMdYi8+Nu7m4/QceH/8TvvzNwbEnMLjWCCAieMmMh70uLJbiYet2BczUK2Goshx8JgycsyJxrMNdB5wkOyZJqBVIgAQyK5LGxIaY//C1QeSbq9Av186Fues0pX+urAQIOqRjLlUaHSTIxIjsc38filK66fASemIQsKa+O2tF7llV8nOqtYYa4HII7ZYEm5hhkG0msLslEksyqTJI86BrroRZbLchmwOOOsb3arvDWmR5M9+b+eidAf+XX/gqReXI05sY3Jv5bTUt4EfCP5A/Pn/6Gz3hG6ZWrlYr9vf3cc7FABEFSgAvvPBCTHYcDocsl8vIBCVJwu7ubixp1jTD+Xweg1S0DkDBS5ZlsXdN2TWVdWr9gV6QW2vp9XrUdc3Ozk4MzlBw12q1mE6nkbGazWZ0Oh3quo6yTWUMd3d3I6sDXKsjUACrpePPnz/HWht9bWmaRh9XmqbXisuLoojBIMvlkqIo2NnZYTqdxs47IIbFKBvY7XZjpL56EFWSqiEim0yaPl5rBsqyjMXoGsN/dXUVEx0PDg5iyqXKI3UbGoayCaR0/So11bRJ7308xt57xuPxNamrspZaP6CVD5syV62VUG+jBpMo0N6sVVAWVs8NBW0K/FSqqf7CzSRTPcfeb7N0OZmpYl0ACJtV+ITjOmHfFvz0k1/jn371R2k8btLIMyhK3KOn/Gdf/Zv8t6MfZJDKa8QSZZWb29OpvSHBUuNJjGPpE2pfMXIJF67FPAC9iWvF4u9h3aZjVxHElT6hacoI8LaSKS58X0FpjQkpllLWnZhKggRMzcqtmb3SJ5Q+YV7nWONp24K5y6kxDOs2l3aOWRYRmMXEyQScMaSR3VpLI4GYUKmdZpvSQ5eYWIItXrsNKWNgr2IFQ72+eLZBZhnZt8pHf95mhD9eAJMCPJeaWBVgg89NJaLpSiLcVapovMdZG71rKmPUKgAssbw9rtmsAZfuzzjxxcUyc70uTUxgK6Fq2chiXgOz4VirHzE+NwA0b9ZATUNfYq+eJYK5m/kHnXeAhw1wIeRQ+J0AvPX4NBHQ4hvicasKYbsejaDVEamjFREmvoK8CaYFJCKNXC5lP2lgmWzwxNkA+vJEQFpVClPXzITZ88hjWykMlwIKTVNkjoOOSCDPL8QnZzIJLUnC3yuPgEzjhS3b2Yb5FGZTSct02q9iJa3SGwGG3TZMxyHwxEPeFmCJh8sRrBwsaglasRnsDmC7B4f70OgKIzdfQLUUgFhX0G7j8wyHx1kpB7d4LPK79pvCuBs27rs2r93uU9aer55M+OidwXu9nJu5me/JGAEhF977/92387x3BXK9Xi+mTm7K66qq4oMf/GAsxlYv19HRUWTU0jTl+PiY+/fv0+v1GAwG8ftlWcaLbr0I14/NZpOXX36ZJ0+ekKZpDPXw3kf/U7PZjJJM9buppE677bRHbjabRRBx9+5dLi4uKMuS09PT6NlTgKLbefPNN9ne3ubOnTux224Z/ie3Wq344he/yHg8ptlscufOHdrtNnt7e7RaLS4uLiLwevjwIS+++CI/+IM/yNnZWQyA0WTLTZnm4eEhJycn13x6WZbFInbvPV/60peiR1FDPJIkYWdnh+FwyOnpKc1mM1YXtFotxuMxV1dXERDfvn2bF154gV6vx3A4jCmhW1tbpGka379Nf6BKI1W6qVLWxWIRC7c1fEbBm/r/1P+mnkX1OaZpyunpKYuFRF93Oh2qqqIsS5bLJQcHB8xmMz74wQ+SJEn03Ok5otUDCl5ns1mUUBpj6Pf7cVtZll0riX+/jfrDEpx8NI7c1IzrJs+qActkysQX/H++9Nfo2ZSJq6iBZ3WDLxQHrHzKVjKnaUpKn0ZppX60gelTn1yNpWcXocMtZxI8dY/KHQByU5OZmtInFAEMDus2SaguWLmMxIrXbSuZUyIhKMoALv2GnNI1KH3C0qeyBm/pJfK7NHd5BIsrl5Jah8PI95x4+47rAZQVpnKxSqDODaaSi9c618AXcFF2SfSZrcNP1lJL430s/raVABcTHp+UG2EiYR8q54xgKkzdtALoNG4/yApBwGLdsF/Xp9a8qik74Xn1GqTpc+L6Yf0YT2T41DOnwSrSDbfB2oSkTH0+xghrFsCiqT0+tSH8BDZJngiCjQlAOXwvhNsowN30v7nMrH18m9UDNzjuOzD+6z4zTuS6zoDxCQmQ4Vg4xMzVTOGVu3CQwFYKiwkMtqHdg1YXTs4gQwJADnZgVMKkhNMgp8ytBIls7wcppQHbglYd/Xr0tqRYe7oUgJcFxsu04YVdYeaskbCTwkkB+cIDTUnBHM1gXgrA67eAAp5fwrNzePAUDntyVVIV4GupSBjOod8NGlMHq3kIXdFwllL2mxiwTej2xMeXpQHYleLz2+kJyCsrmCNA0XkBn7cOqWdz6uEQsKSFx9aVSFqd412gHOuT/QbUfSdnr9vgqN/kC89GN0DuZn7bjPfeG2P2jDF97/23bBL9hvUDmgjY7XYju7FZQN1qtWIqoHarPXjwIMrotCxbmRgNy9Aia2VLFEwBHB8f88ILLwDE1EcFNRqsocyLBnQURRH3aa2NFQTaIaehG8qwqVdK/WTK8hhjuHPnTuzLOz8/p9vtxgJrIAKR6XTKZz/7WT72sY/F0msQJnMymdDr9TDGxOASlR6enp5eYxe1dFv9fwDD4TDKR4fDIavVKiZrqj9wuVxyfHxMt9u9Vi6u3sBWq8VwOGQ+n8dkzw984AOkacrz58/5lV/5FYCY4HlychJj/LV3TX1lGvKilQn6c/Wv6TFSUKeBLVVVMZ/PYwBMr9djNptxenrKbDaLz4F1lcHOzg5bW1scHBxcK6BvtVp0Op0IEDVZVL10yv6pjHYzvVLPOWX93k/TNKWAH4K3LfSwdWwRWa+zukVpV0x8zdKnlN7yVrnHsO7QCL44BYJ1iPfXKX1KgoC5LHjjOqbAGonbLkiwxrGVzJm4VpBCCiPovMF5G1m0hi1p2DL65VSq6byNQSqZqVi6jEndivJJBZmjuiW9dl6Yu7nLadqSbipMqUpMp3WDudvnsu7gJxPSaZ+kyCnbNvahJaXHhRbzOicCCmWJ1Ed3rSqA9cUwEK+9hGEDF0I/XPDQSQWBx9dgy5C2moivzuX22vNxHpfZwEwpa2UiqExXnropfX1aNaByRPWu2cqTeB8ZOtnfBsNlFDzJ12uWUENfJM3TOC/ES6hZyKY1PjHY0lE1k8jq4FW2uT4fY11DZOp8qMFYh5/oRy04l6WFBM/K3zAV38HxG5+YiNJNYE69uLks8oatHDw+hoMjkR8u6pAeaaUY23vxlnWCt60yUCLAJkuE1Wrm0g1XBallvYLtjrButROfW1EGdiwXIGUTAVIYYchcKBKfz0X+WDjZ/7KSQvDJBKYWRilstUU62e/KfjOEFey0YHoJjTYMGiL91OLFNISyqIMwzyVIpazC57UweAb5WPkQsOLl8yyD/W0YW0nRdEY8eL2u+PTOziVYk0SUBM7hrMFniWz7N3+HbuY7PB+9I4En//wPvdcruZmb+Z7ODwOPjDFvEEQX3vsf/kZPeFcgp4EfKltcLpfxQh2I3q00TaP/TQHdcDhka2srsmd6Ma5yt005nAIoBVM7OzssFot40a1SPv1a5YL6eZqmUaKnkkL19uk+lQ3TYm8Flfpa1HenoEXZrE2P4Hw+j8mL6rVTiWOSJJycnFwrTr9161aUICr40h604XAY167Ho9Pp0Gg0uHXrFm+99Rbj8TgykioT1ToBBS4KWBQk6mtT0HX37l12dna4vLxke3ub1WrF48ePYyXCYrGIQFmPp0pR9ZgroNOybmW+1LOmYFV9lFrOvSnH1b47WNcSqO9OmTaVkSoI18dq2udsNrtW7q3F6hpEo0BOAfxqtYrb1a6696O0MgsIY+kz6VwDcnu9yKv0KUNH7F6b+TwCo8xKD5s1EhxSe0NmiDUDm5LHxKxZPzx0TBF73hIjXW4qydyUZs5dLjKjEJaS2ZqmKWKlwdLn1NgIJlXa2bAlzlsmrknp0sC+ZcydeBorZwOjl8jzbI0LiGzlUs7LHv/V5/97/tQP/zPYWx1RgkEESyqBFJkk63CTCqyRsBIglmgD1xgjn4D3RpRktQvyRRNljiaAqqQUCVndsEEKGaSVBEAUWDGfmmvVVy7VYBABXXUeWDS/sY4AzhTYJYUToBQ8d6ZC0v02WC5Te+kQ1FCVIK3U8u+1by7UNITnVq0kgsBsJomXAsZ8lGGKTHNDYlkFiaVnI/TEX5NPbvrivBUAfDPf2nzr7iu/7pBTUIUPIT4GTCoM1Wwu/1dvpCJntOEuR+UFrLVzYcNqA6URJk8DPdJEIv9tKvJL58GVwnSlqZyHo6mwtI0QHmLyIPsMlQJ1YLxyI+CqCszedCkAsKhExukczC3kqYCyRg67QVqZGJFuukTWbA1cFQGwIuEtqhk2iDzTF+INzJD9WyuPLx2YUrZRI6AxS0X2uQz+vayGzIhPrt+FszOcMVhvQlyUx2Dwdl1NcDPf/Xnt9oC/8+DsvV7GzdzM93S89x/5dp/zrkAubDB6lhToKDOmjJymLe7u7nJychITGzWuXy+qN9kQlQ9675lMJhHIKQhqtVp0u90oEzTG8OTJkwikFJwpGNKLeSCWYV9cXETJ4O7uLkBk3/SxmkqpLFO73aau67h2rUjQVEXvPfv7+zEh8eTkhOPjYw4ODmJJuq7r5OQksmXqXcuyjMFgEEGPFnQ3m0329vYiUDk4OGA+n3N8fBzj9be2tmKH2/n5eWQTR6MRi8Uieho1kOSLX/wir7zyCr1ej62tLbz3vP322zx79iyCIgVdGiwDxK+1sHsz3VOZ1bIsY1BLu93m8vIyAnMNV1Fw1e/36fV6nJ6e0mg0uLi4wHtPu91mMpnE46oBOKPRKL4PuqayLOl0OhFwt1otsiyLZeSnp6fxvGq1WqRpGtMx9b3S8/D9NklgwGwAUQ5LUScxREQ9b0snbFbHFMxcg7Oqx6hqM0jnlD4l9xJmApBsMCKxMoCMnl2GbQmQqo0UfM98ztLltO0KFwBg05RMXBPrPZmpGVWtCAQzalxIoTypBkFKWUQZp6ZSqqRzWjdZuozKWRpZFVnEbrqidAnWeGESw77mLg+l456/s7jFT/zaX+Ff+hf/deqmrE0LwiNoMWA1uj+BZCngxTWMyAhDj5rKApVtWnfFCRtnQ/cbVWC7fEiiDIBLpZMCWiTGXIM/5O6/JDbWDRNBkiQ5+uC5WydVmhBy4lIBRMlyzaIa/DVwJDJPI2XjOXLhbOKDSZcuAttk5ddySxcAWhrYuNbGn/uwbg1GUeDow7FU5g2CnNKIfBIb1u881Co5DcfqHT67m/lOjg9EpwGb4k2Fx2GsF4Zqdxe2tiAv4NYO7HYFCK06wlK1MwE3g5YwbyNgOQkJlanIKk2yBl1uBaYA7+BqKkCr0YR+T8JEmk0ogMU8lHhbmMyEgasrODmWxzZbUhsQ/aylBK+4wNyWVvZtUwlCSQLIWzlJwlzUAgabuazfe1guEC1zAIFFJetMkI9VKb8jPpHEzDSA2a89lec3Mrh3JD672oscs5NCryUAb3cHczXFrgpShLR0+FBdYDXO8j04B357zUfvDPh//u2vUTtPcuO7vZnfJmOMuQ38O0AfCTn5E977n/hGz/mGYSd6ca7shyYNbm9vx14xfayyS3qxrP6lJEnihbQWjCs40lARLXNWFifLsgg0tKy6qipeeOGFa/UDvV4vpkkuFguWyyWXl5exJkGlnMpqKTOnPioFCptsljI6Ck5UIqo9ZaPRiH6/z8nJSVy/bkcBRLvdjoBzsVhEOWY86MHjt1qtmEwmUf6nqY/qUVNGqd1uR08YrENR9PgqoNHtXFxc0O/3ubi4oNfr0W63Y2DMxcVF9LBpmbkmbyrA1LRLZeo2/YSbjJoyoY1Gg+FwyMHBAe12O8pxF4tFlF0qYJvNZvR6vcj6ae9bXdeRld0MmVHmbrVaRSZXQaz+0/RR3Y+Gp2jtgobTeP/+/Z9vYjwgTJY14kGrnaFpyug/q70lszVLnzGtm0FSKa+pxkZWrPZSAG5xlMh7qMyfBpNYucKPj0uMo2NXDOsONbJfiyM34j913jCvc/bSCW0rv+Nz12DpMlaB+rJ4Vj6l7RMatpQicm/jYyqXsHpHCMvc5WSmFgbNG1z4m5JaR+UsM5fzsGySTAvsIAveNmGs6qYNYR1+nThZha8BX4tM1ScmJORBDPeI/wK4CkF62jcHgXnzIlEkAJYIsDbSKiNwCf3IGiqiISub1QaSUHndS2Zq9bf5+DXJOljEq5QueN2sc9dBVpRAgqlcLEpPCheloN4EoBq+ViooXa7rE5yciGHNASy+o5JBvyeF5CI5jcEo4fjeeOS+82MBZ0PCY+nJvDByPgQ3Siqkg3tbQqvOl1A116wYS9gmBIQASBk2vpZ/JhFQ50sBbVmQWW61BQjNS7iawZ0DYbSslWw1X0KdSKXAeCY9dRUCzMpwkrlaQJJriKTSIUEplYNWK4C4XFi/gwMggLGlgWQFZgX1PASxAGW6LhTHCWuIlzW1NfjESGDKIhHtsJaQrwphBC3ymh3gFtDuCBvZyKWexFgslgpIQm5lbUy4ieLkRsf38gT4bTgfvdNnWToenk155bD3zZ9wMzfzP435CQTI/Sfe+9oY8y+H773rvCuQU6madnBpRL1e7K9WK3q9XmTQJpNJDJ7w3nN4eBjlfNoblmXZNZYFRMI5Go1i7L32rulzlJU7Ojq65n3alOappFHB48HBQfSdKRhRCd/Ozg6j0YjpdMpyuYweK02A3Nra4uLigmazyfPnz6+FgaRpGisXrLVcXV2xXC45OjqiLEsODg6YTqdxfSpP1DCOJElIkiSGhABRkqq+uHa7HX1qzjkmkwlADJrRNavEVGWMl5eXEaiMRqPIXjUaDTqdDqenpzx79ozd3d0IeMqy5OLigjt37sRAEg2fmc/n7O7uxvUr0FJ2drNoWwHnbDaLnrzZbBaDWTQMxTnHRz/60QjG9DhfXV1FRnYzEEdBmEph9YZBr9cjy7JriaIK/HWUuQNiCIsC4ffTLIP/LMGBsSSmjMXZCY65b1D4hKaV/rfLuhtDRCpnI0CrvXjPcitgUMq6Pc6L98xqrLa3sRJg7hN2kim7yZT9ZMHEZVIWbkpmrkHHFkxck26yZFI3scaHIJSUeWD/dOa1HNuVSxnRYpAusPi4viqkeEyrBqlVCWYdf76oMxq2og6vSb/e3I+CNVu4a/H/EuJhotqqNnbNZtXBgxbAhQ2hHyp3BKLfy6cmMmUiVfRrD5jzUXLpjSFZObBQZxYfWDWn6ZSFxxYSTqIBJt4KaFonVxCBWWTQPCQrh8ttCDpxEeBp1YIJr8Vu3pTwPvbYuTSsbUN+ihFZ6JoNFPDlMhv3GysTCh/9gMo4yjEKH+v1WmO3lifK3mz1/gsUer/Oty6r1CcYMBZTO6xoXaVv2xl86UL6YpAjYqDwAtx8BdaDy6QrznvIQ3iImO8CM0WQJIYAkzyRYBSbCzu3dMLuJfrLhAC4eqOuIAsgqka2g5Vet06LWCVQI961opLaAZsK+EpTAY84AYQ2CWsMsarh5kEs6DbIWhoN+bk1sv+8ESSYK3lOXYvs0m+81tFU0jxBwG5D1xc66GzMrFwff+/l+Gs60g2U+67OUb/JTifn9WejGyB3M+/bMcbcRzrfvhC+9c8C/xjwbwEL4F/13j82xnwE+C+Q28p/1nv/C++yydR7/xsmmqK/+a3RdwVyg8GAq6urmFwIaw/VO7u7JpNJ9CQNh8MoFdS+sUajERmayWRCURSxy02Lsr33UYaoCY4KGpW50Qt6ZeA0Kl8LxJ89exZDVDbZsaqqaLVaeO+j9FBfR5IkLBaLKOtTkKbAodPpxH/9fj9WCpyenkbP2vn5eUyX3GTONIZfwaSyV9ZaBoMBjUaDq6sriqJgOp1GQNtoNGKXXV3XTCYTJpMJo9EoSk7rumZrawuQsJjHjx9HhnB7ezsCxr29PT772c9yfn4eqyAmk0kEzQpogZimqZ695XIZawxUvliWJc1mM0plNTF00xOpMlKVz6qfLssy+v0+5+fnURK6KanVY6MM5mQyucbI6X4Wi0Vk29Qvuek31JJwfY8VGL4fUythnSyZRfbL0rNLCQVBgkSct8x8yqRuAgKIrPE0gp+u9GkMF8lNJexdCBopSJi4Fpd1l7Yt2EqkEsPiuJ9d0jMVD6tBZPeAWEOgQLNtCxyGiWuG8JJEGDctHA/9cqVPmFWNsA1h2pSxcxieLwc4DINsQWI8vXTJpGpGiWXiRVLZSkqaIVjFGodrpbHMOvbErdbvp/MWlwVZY8NEf5itQjrlxjWXS83aP1d5ccAok6fesNKt4/Y3GCxbOgFAXhBSDA1JpNTbhYCRZCVSuCqUcot/z0eGzSdEWaWtwa4C+xfi303Yl7cmhKis/5YrUNMqAaPpmfqzcMFqlI00wSfoFMAKWMR5ktKBsxEQGw/Jsg7A2Fxj/tbpnybIWMOaNm1DDkz9/vw9+608oqoUgJZQkFrJMMGALRNcWeGLJeRePHBkMKqhKIT5chUUHSnPdhkcCZsdmallJamXWQZZU7xmzQRawQeXNqDZFvZOgVWJyCRrD1cTAV6tDDoJ+IWcszaRBMmttgSibHsoLCwLYcfwAu7yAMCS8LtlvACs1QpWCyCEpoA8xgXgmafQ6Ii/zxjpl2u15cD4VNZa+9CtZ2UfdQ3DMSQNAaAKeJ2TbTca1NkSn5SkNZQYvPMYX+M3Os1uoNx3d4wxvHa7zxeejvljH3+vV3MzN/MN5xe9938cwBiTAf9b4PcCPwT8WeDPAP8h8KeAE+DngXcDcl8wxvwHwJ4x5t8DPvvNdv6uQG4+n8fIf5XQaQ+beqRU0gfS/zUajWJIigIbBWSLxYKyLGPHGkhSoXbBKfOnzM3BwUH0q+V5Hi/IlV1RGaYCCvVEgSQ3KkOjssmLi4uYYqkAsyiK6N9T0OGco9frRYAHAlZVcnh+fk5VVbTbbd58800ODg64d+8e7Xab0WgEwOHhYZSjKtDRtSmQ2qxhUDlpURSUZRllmJoAub29Hfv5xmNJJN0Ei8p6TSYTdnZ24toVOKrMU1k3TSDV16EetPF4TKfTiV6zuq4jw6jrWi6XbG9v0263Iyun4FPXoJJPIAI6XaNKcieTSWQqgRiIoq9rtVrFDrvVahX7+FQKCgJg9X1erVZ0Op3IhG4G6qi89/2YWln4hNI16AS5ooaMZOHqOEHSJcsgm9THWONpJxIKo8EmjY2QlNIn1M7SNAVz14hSzMzUMaCkb+X8XoZqgCQElRReKgWWARgCzE3NKtQb6PcyUzNIFkxosnIpmRV5ZCOposctMzUrUhyG3FZRQjmrGjRsRScxrOqUVhICkQLiykxN7S1vzA+lSmFDuiegya0j7xFJofUGn6xZpgiUKi8qspAA6a3cUPd23buWrLT4es2uWWWhKgeJgBofWDkdZQhlu2F/wV/njY2MVhIqA2xgyFTaKWuRS0KfgIapABH0AetQl9KtX7sCNB9YxcRiKhfApTB3phIZqLJsphJGziQmkh2brwWPMIKxK269ff35ZofdZpm6fPPm0vZbnW/5SJlAqJk1sE5S8ElClTQEePWbsN+F77svSYyjEqZV8LMFGeQSmIdAkkkJnbaElqxCl1qSy7+dLXAF4ATgqWTxYAvOToUFy1LIWtLVtiyEFdMXVSOF3MqymUrKxPOG+PYaIeRklUC/A6TygppWWMCikGCUTkt+H5spjDzUCznpun1YzZAb203YPhLWr5XCrX0p/p7M4eJS0i6rKnTrhf2aEKAyW8pHZSLzJrRrqS84n+K8J1SIAxJuWaViNSHIt2/A3Hd3PnpnwKcfXb3Xy7iZm/lm87uNMX8H+DvAfw18wXtfAL9sjPmPw2Nuee8fABhjLowxe97783duyHv/bxhjfgyYAV/23v9332zn7wrk1HOmQKAsywju+v3+NUBljOHy8pKHDx9GOaQWVqvHrqqq6BdbLpcMh8NYXQBwdHTE2dlZ9Drpxb6yPM1mM4KHN954I6ZAqv9NR8GFVhWcnp7GkBBli1arVawtUI+Zeq2azSbT6ZQkSWIJ+HA4jJ48Ba79fj8CDQUSCkbPz8/Z3t6O4EQLtxeLxTUPl8oEt7a2ePLkCVdXVwwGg3j8VcI6n89jvcB4PI6gSCP8NShEawLSNKXf7zMcDnn48CHPnz+n0Wiws7MTaxJeeOEFlsslz549A4jdet57jo6OosRV2VBNjmw0GhE0aVhMURS0Wi3m83lMsFRZpALanZ0dms1mLCxXmaq+Z8qsdTqdCOgVsGmnoNY1pGkau+cuLy+vJYDqutU7WRRFZE7NBqvxfhntXmtSgg+l3cbHLjb1xiUhmdIaz9KlOG9EXoX412x4ToK7lli5cuJ5G1Uidyx9wnnVl8emjtJbmrZmK5kzdw1qb3FIwmWNVARM6yYNW9I2q9h5102WTAM72E5WkZmzxtOyhazBARtdaqOyJZUBBBYSw6xusNeY0rYF7WRFguey6sRy8IYtebzcIb2aU2xlhOyWNcBBQJ0FzMqRzmsIJdVVK1k/1sv1JKknWek2iKIFlwVGSgGMY+2HCxfQysZtAjllt1xqMJUjXTnKXhqj/9Olxyc+1iG4fC1XTIo1YEMBXVi7sCUS0qLBJKbyAuICU7Yp/dS16OuN7KI11KmNEkuDx+ehJmEzNAViAmdch1kDQLyP8feaAhoPg2I4swa/N/Odm6hgDcQwRkCEgJ8WtLagawUg+fBL56345spaEiRtAvOVBJTggk/MiKwxa8gJb00IFEEklJmRlMsqEUYuzWBvR/ZRh463ygqbVVYCIMtaGK4VkPmQeGlC6mUqd1OyTABaYqDfl/VmGWz3YTmTtZY19FwAV+IdxwawuN2HKw8mlYJvlU86K4jXemH/8oaAQmPFg1c5YeZUmZGoD7QWmSfIa8xzYSKXBXa+INSo32ScvAfz0dsD/vyvvo1zHnsTeHIz7+3cNcb8ZPj8L3nv/1L4/DnwQaSd8v8F/FFgswNuw6EfZwTsAF8H5AC89z8L/Oy3urB3BXLNZhPvfWRhlGXRi+Ows8gInZ2dxfRI730su9auMH2sMmwaaT+bzWJs/HK55OrqiizLorzSWktZljQajcgOgbAxGuCxyagNh8MIZIqiiBH+Gs6h4SfKNCpLoxLOqqpi4bcxhvF4HDvZ1M+mIKPZbDIajRiNRhFgbNYz6H41tl+rCra3tyOwVPmfJnXmec7FxUUsWt8Ei91ul/39/dgt55yjLMvIfHa7Xa6u5O7VrVu3+MpXvhILzheLBcfHx+zv718LAlEwvVnmrZJKfd8VaGkRuEo6gZggqSmVClBBfIn6mhXYa7DNcrm8VksBUkKvx059klmWRWZWj796AfU93zwHjDHXtqs3E/T4v9/mmkcOYmm3DekYmalomzp65eYup3RpZK4UGK2LwOVn6i3TwBENOGnbIlYH7Kfyt2bpkyiVzE3NzKVxm/qvQRmZOA07mdKU2gMtH8fTsHJBtAprzExNhSU1Nau6RWprEuNJw+srXcIgWZDZiiR46ppWZJUgqZ4AZllgamHQpCrAo0EnBM8bIFe7wQeXmFDMnRJLtE0FxviYKBl9csF/E1MqN0e73UIlAQHwecAnIkv06k0L0kMNNYmdb7UwblLEba4HnnjWYSeBJZREyXXYyabUM4Iy/RpEPqYXx/GqU6Sa6ltzga30ASAaR2A1wZTymvT1AZhNL5TbYERVXaAhMOECV0JYuCYDvZl/sNEj6UDeUxMOr0eYpUYT9rYgL6HhQ7R/CiTyPpaVAByThS65VIDOcgnNhoCmFDDL9fu2qiX0o5kJK7a00hfnDQwGUK2k5uB8CGlL1rIsYDoXD97KA00pEseLXNFaAVQeAXTGy367wfuU53BwCGcn8mIrD30b6gtqwEI+l9/v7Y7sz2TQ6gkIswgLuFqEdEkjvrfJVMBqoyk/q0r55wPYMyYA3mpdv5BZaDcwyybpfBlbD+R/O4rkTPjVvUF238157Xafyari8dWcF3c77/Vybua39zzx3v9z7/ym936F3LrCGPNXkKTJycZD1Hyw6TnYAi6/Uwt7VyCnF86aJqnAI8/zGMChpdxf/epXefToUQy40IAN7Z1TWZ9eSLfb7cg0KahQj1ySJOzv77O/v0+e5zEIQ4GcpkQaY3j27BlbW1uMx2Om0ym//uu/HqWBOoeHh7FywHsfGUGVUSqLVRTFtfh6lSPWdc3+/j5vvfUW5+fnDIdD9vb22Nvb42Mf+xjHx8dMp1PG4zH9fp88z+n3++zt7dFqtWg0GhG0bG9vX9t3o9Hg+PiY1WpFnufRZ6bspdYl7O/vR3+X+vAuLi64vLyMtQdlWbKzs8NHPvIR8jzn7OwsArdut8vh4SFvv/02jx49otPpsLu7S1mWkXVThsxaGwvR+/1+9LHpe7hYLFgsFuzs7FyrKXj06BHWWu7cuROBrko2gSi51HAbZd2UidMyb+cc7XY7AtvNUnKtbOh0OhwfHwMitWy329eK4pUhXK1W12Sl6gV8P07hk8jEqbctD1LHzNTkvqbwCW+6AxwmyirLIHeEdQKkfF+645q2BOMYpAteaZzQswv2kxlndYddO6fGMHRNhnU7JlhKaXcawaUGmYB40VQGqt6+0qVspyJ9vao6zOsc501cCyAyyrQIPjpLbuW5WkA+LRsR/AHY1NNOVhzaEb1kwa+d7ZDe28YbSYTEgF1K0bWAnbC+RiJAqPQR/FRWvheZqsrLjfuN469ATZIv/RpgJQZTm/Cz9TN8ZiNjVVuLLQm2nAAcw6m2WUZeN0wIWwlhJInul3VCpoJLL5JOqVfwm9ePIuVUWWPKGng5D8Evp2s1wWfnQ1l51UnXz42BMPJ662YC3pOsBCib0l3br7I1xkm4DNVaZhrZTH+dJbyZb33eKdNT6R76fe/wmPXVQOVEPnnkoJfCwMLFGHp7Al7MXOSNWYrWY0ABSQ2rXMCTMcKwtRIBWoWHx6ew04ZeQ+SHzY48pyjhdArFSvxtNcK21SWMxyJn9Il4z1YlXKykdPuwK9tOGlClkMyCFDKTYBaTyis9OQnbTSBtQzckWaYp7N+ByUj21Ujl9V1O4HIIgx7029DNYHQJ23eh14YB8gs2m0mK58V0TSMbBCC2O1KgvigE2PkaRiNYrfDOIS4+izGO3HpWGphiLTh3/f25me/4vLDTptdI+cKz8Q2Qu5n35Rhjet57BW4/AvwM8L80xuSIR+5z4WfHxphXEI/czm8mq/z7nW+JkVO/kTJqyowoQ3Z8fBx9X845Op0OZ2dnvPjiiwDXfEx7e3ssl8tYjq2JiOpn2/S8KRBUCaWyYXmeMxwOY7y/+qfeeuut2DH3+PFjfuAHfoDT09NYFD4ej+OF/mAw4Pz8PEolNWFT2aRms8np6SkHBwcRPGhJ+Hw+Z39/P8oir66uory03+9fk2dq0uTOzg6PHj1iPp/T7Xa5e/du7MVTxkxfR7fb5enTp5E1Oz4+jkXlWtuwu7sb96P7KIqCX/qlX2JnZ4eXX345SkM1WXJ/fz8CK5UaXl1dRbZqZ2cnHiMFzfv7+/T7/RjuogyZBrlMp9Mo8dzf3ydNU27fvs3FxUXsg1NWT/2Be3t7XF5exnNA0yf1hoEygXruKLup61ZPpYJMPVfV/6i+Q2VgdQ3vx/oBrQxY+pzEO5q2JDMVualp21X0yGHqIK10ZAiT17AFS5/SNBWjOiR0GsfSp9FjtnQZvWRJltT07ILaW/7u4gPMXc697JKeXYi005Sc1X32kzHDuk1iPG27Ek9bJhLLeS3dccO6TYKPgSxag2CNpOkpGLXGR4mmpY5sXeotJ4s+lbf0syVvuZTUOPbzCZmtmdc507qBCzUIHbvCpCl2UeFTS93IBC/kVmSIzsdI/GRZYwNgq5tB0eAgH4UgmdTgU7vhayPWBLjEkCzr+Bxln4wTT4xPwK7En2ZnJb6RCFtWCTJSqaL22MVCbiudcpIsSbzqMxugJ/rabKhUCMBOZJUOl1icNdfKzb0hsoPyDUSOaQwuTyTtUrvyjIk9cbqv9YZkrWlVyfZqfy19Up+juzG1w1dWWI+Nn0tFg4vfv5lvb97510kJW6P/8UEiHLI+vIL8VgOaRsJJ9nZgmYq3rfYCYJIaspxY/K2l2FkuoKjRhLIh95RXCBtXOWHwciM0cu4F+E1W4qerjaRZTgths5Icen15XuGE2fKh321ZSDCKNwIU+43AhlnZThpe27yETgfSCiYL2NoOtQFe+uDaDVhO4fJYtt9sQSdUKDQyCV5ZJdDbAlKYXRErBlblep8ulf01O9DpwWAL0rkARu+hP4BpCbbANzvkq7G0HhDekPB7azG4TU7OmBuP6Hd4rDV85Haf15+O+MMfu/VeL+dmbuY3m99jjPk/INLKN5FwkxXwi4gz+U+Ex/27SI1AAvz779yIMeYneJd7Qt77P/2NFvCuQE4vsDUqXpm15XIZe8aGwyGj0ShG86v3a1O6CET5JBD7yjbDKRaLBfv7+4xGI5bLZdynBpKozFFZHb14V/+aMn1JkjAajSJIePr0aQztUDmfJiJqSIdKA5UV1M8bjQZHR0eAACvtO1MZ4Gg0oizLa/UGQJSL5nnObDaj3+/HnylQUYBRlmU8RlVV0e126fV6PHv2jFarFbe/s7PDdDqNyZPqW9QEx+FwyHA4jNs3xuC954UXXogVCcp+FUURPY6tVovnz59HhhMkFVKBlHoJ9XN9HcoCbr7n2v9WVRWTySQWfivjpjUG6l/U91079TR8RY/LdDqNQSwK9FSiqSmX3nsWi0U8JgrE9cZAlmWUZUm/32c6nb4vC8Fjv5s3JEaKuJu2oG1XdExx7bFLl1G6lLnLWdQC0Jqmiqzd3OU0KGmaijrcK175lMTlPF7uRIC1chltW9CxK/p2SekSLusupU84q/uM6g429MoBdJMl3WQZ/XG9ZME8lJI3Y0Km1B5M6waTskkjqVi5lIatqFxCltSUgTYrXMqyTvHeMPQtSpew25zRTyV8Rbx9wjTupRMyakwjl8S4AEiqzGLL4GszRvxbfkNOOKswmY3Jjkp3JCuHD2BI0idZpz46s06qDAEnkWXakDmKPEwe41oZMeo/jE/CNpUpA2wp15sC0uRxGrQCAQyx9qzFKoHCyYVogqyhdMKGOYhx6mx8JKxN0yXTtRQS50kCSHOpxa60MG8NVrFmnToZt69gLWx/E6h5L+t2sl0FjTfznRk9deUkU1AX7l2E0A2RSNby4EFfvHCrELdfVoJACrNmS40NksrQFddLocoFvLhwkhK8ZB75WNWQOGHhavVcplAshKmzVoAQoa/NpoGOdkGWaeW5lRc/XGpFBuxZy3ZrBHhZZH2Npuy3qsWzllvEJFsHL5uDRiXA0gT5ZyeHdle2mc/EJ2cTAZTt1np7iRMgm4XOvEZznYbZ6UI6lPM8SUmMwftgL7w2N+f592I+emfA68/G3/yBN3Mz78F4738O+Ll3fPsvhn+bj/si8Hu+wab+j+Hjv4aweL8GfBL4+Ddbw7sCOQU2ehGvksVOp0OSJEynUyaTCdPpNKY/jkaj6LHSyPzDw8Nr1QHK/mhCY3iBTKfT2PWlYGlnZ4fLy8uYODgYDFgsFlHSd3p6GuPx67rm7t277OzsxBqC58+fc3h4SKfTiQXXL774Im+//XbsjLPW8ujRI1566SV2dnaYz+fRK6cgQpnCXq8XPXSauthsNrl79y7eey4uLiLD+OjRI0Cknc1mk7OzMxqNRgwFUeZQj6WWfAPs7u7Gwm4t7dY+vfl8HhMstRPPOReZMgVTeiy1xLwsS0ajEbu7u/F72iGnFQebIGs+n0dGTcGQpkcWRXEN4GtQjALFxWLBYDCIaadlWcbnboJuWCdPGmOitFP7BqfTKQDD4ZDZbMbh4WH0Juo2tVOu2WzGuopmsxk7B1UqC8QKhffbNE2BM1IXsFkEXiK+tqapWQaPW9OWjOoWZ0WX7WzOpG6SGMfc5cKGuRQslE6SIjNT07AlH+08Ee9ZSAtZ+ozCJxzXA4Z1m5NyQDdZ0jQlS59S1ilT0wxMXM52OqeXLGnYkkndIjGOad3kq8stJlWDD7TPqbE0bMXd1hUXRZfPXd4hS2p2mzN2ckM3WTGuWlg8B60J01IqFCaFhKY0bEWNpZusuCw7ZF5YvaXPoNnANRLq3OJyE71tBEbOVC5InkCSF5PoT0tnVQQlpnLrrrgqieCs1mAUBXEbozJKIPrV9BFSwL2xnaZ0wCWFXAS71MTS8NjJpjjJ2Jj6GBm8hYueO1MFUGlFJuo3zXvqW7PIBbACwsREVs0EUGWjLHvjNaxqbCFx6qaqQQNUio0wCLMOZtHnyfp10X5tHtKahBtC4js+G9xo8JoLkeVcSJXstGF5CeVSPGxvP4PFUkARhXjCVk7AXGMDPDUa0G2LjLJcQlLI46ceklLYuGYnAKFE7jE3ewKcyloAYlXL9k0p28iawswlWQBxFvYGMF0JU+essIKNTNhACNLgRIJLxqGsu9WW/aSpMIR5AxZzuQvS2SYWkS+cMHiFh3kFL74Ira7sf7ADiYeqgOkEdo/g7ALGk8C4GwGuizmYXNIty0KAXC43aKiKtbLZsv7dgFihuP7Gzcn/3ZjXbvf5q59+Gv3wN3Mz/1Mc7/1XAIwxH/Le/xvh258zxvyNb/bcdwVymxHuGmiiUe4gkfAK5oDInGkipfqu9MK/1Wqxvb1NURTs7OzEjrDLy8uYKrm9vc1sNosl33qBvlkroBf82rmmDB5IZcKmhFDLqc/Ozjg/P+fo6Ihnz57Fx2vQR6vViqBKg1yOjo44OTmRgxSAQLvd5vHjxwwGgwgyNEHRGMPR0RH9fj8GtWiYiUoDFRRtdp8pK6ggxxjD3t4exphrxd6bNRDb29sRcLbb7QiG1F+WJAmTyYTbt2/H7ejx1PcDiMddwbj6FefzeXwvtUpCGcnxeBy9flmWsbe3FxMigZgyqkmgmnaq7KICTX0fy7KMNQ/6h1rDTZTp1aROZemUIVXgq8d/Uwas/kb9qN9/v43zwe+FC6XeKVkiLJe1jhxJlkzwEYRJdL8ANOmOc7GHzWEkAdNWoZuuxnnLxDdjgMhOMmXihCGvQ/VA2xbyeFvRNBXNpIqeOykBFwllzyyw4dLyoujyeLZFah3TWjxuo1K2ezzr8/yqT7NRstucUbqE3Nrgq0vop8L2NWxNal1M4Gzaknmdk6o0M5Sj+zzDZRYXQFXZsWSzOnT0htLs0kXfjk9tYOsUbAkjEcu1nSOpnHjabBI71hR0bYaQAJL2mG7UHWxICI33OLtem1UmI8oYA5sVpJe2qPGZlQCUULqtwA8DzooPMFs68f5p0IqC142LGR9qUQjqNO2gA4mr1/63aMBSMOnBJ+uaAX0dOLdGDqm5zr4F6djm9vR4OGMEKN9cy35Hx+t/Ikgw6y+9w1Dh2x0oxqH0Whm1RFjcRgOoYVYLwKo9VEaYunnwhaVOWL28Be0Mri5F0ugNTJcCivImtHLxsBW1VBbMCwFKeSIgzuQit8wykStmoZy814R6LPuxuQC0yq4769IG2Ex+ZmoBU4ulvIZWIkBuayCMXKcHt+7CgxNgCr4BV+fCrCUpPH0iUtB2D+7dEw/czp6A2qQlXriyDoErVo7ZbC6y1Dr07k0mwuClqdygCH2Z3nl5veEGhvu6d+udLseb+U7MR+8MuJgVHI+X3Bq0vvkTbuZmfmvPKEg1fx34BDD8Zk94VyCnhczqZ1OW7PT0lPl8zsnJSZQrXl5eRnZGA0GOjo74xCc+QTtEB89ms1jirSBouVxyeHh4DSgoo6MBH2VZRlZF/WfdbpcHDx5Q1zWj0SimTN6/f5/5fM5sNuMXfuEX+NjHPsZf/st/+VqB9nA45JVXXqHX63Hv3r3oNauqitPT0wisNFREmUUNXXHO8fz585ieqKXdaZpG39zh4WH0vWmQSqfTif10l5eX8Rio5FEBzGKxiBLWZrMZY/8V1GgQzGKxiB4zWHv8AC4vLyOI3t3d5e23345gVF+DspHaZaceRD3+CkKVbVMJ6OHhYUzhVIB9eHjI06dPY9rkxcUF3W6Xg4ODeD5ph9+mH059byo11Q5CLTJX+aUypVqSrsE72keoAHEz6ESPp4L78/PzeNPh/TZNW8bQkl6yiL6wjqmwCDjr2Zq2MZw1nzF3OZ8b3+GL09vs5VO2Ux+DQhq2whrHpGqThCARkI65rWROZirmvsHSZzwud6LPTUFh05bMXcXSZ7yYnzN2La6MSC0btsTi2E3l3P3jO5/ir9pP8Df/wg/zYOs+tjTUTU/Vc5hK7vyPW46L3pS05WLHXAWBLZT3/8X2JTvpLIanjKpWYBIrJq7JfjrGFCXJvMLUCZVJRKnV2AjfMAk0E+lZC543W9TysySAOk2UrMNVWKgMSGpPsgRT1tSdHOM9dWALbFFHAGNqIohyuXTb2VWFS2xg0BzG2CiLxJprZd0ga3V5EsNZjPPXisg1kCVdhNdQ+bUPLl7Lrx8bO+usiRJJb9YsojeSWhmLzUHS6VPR6PmNq1G7qvBZgilrsCGNc1MyaoOu75q/bv21T618/vVXuDfzDzwK4sNn4SaBxVMnmbBmCrBtAEmtXBIYy5WArzwX4FI7YZ+WSwHrDSNSyNILmKlrYc2wMFsJmEq83FBYruTn1krKY5ZKwfjSy9VE3pLi8EZDZJuNTHrg2pWcF41QDG4D2PRGqgGyRpBjNsPPClkPVkBe6eS5zaacY70tYeQwUM6kHw4PowmUwW+XN+XxnZBsWSJJlu0KkpWARvUeLpbXcdjGsdTGOKPvgxLScNMl9z2YD+x1aGaWLzwd3wC5m/ntMP8C8E8DrwCfBv6Db/aEb8jIDYfDyKooQ3d+fh4ZnNPTU6bTafSVXV1dxQv0R48eMZlM2N3djWXaGhiiDI121Wmq4/3792Ox9unpaawQUH+eJhm+9dZbtFot9vb26HQ6EYjt7e3RbDa5vLxkNBpxeHjIn/tzf45XXnmFj3/849R1ze7uLiByvc3ybCAWjmvQiu7v7OyM27dvc35+ziuvvEJRFPzUT/0UT58+jYBTGaiTk5P4nE1/n8b+t1ot+v1+ZJEuLi4iU6ZMmgK3vb29KCM9Pz+PYOeNN964VomglQZVVXF+fs7e3h4nJydRXnn//n0uLi549uzZNWnjZqKmBtIoc6YyRfXLqSev2+1yeXkZqyaMMXE/yp4p+L+4uIjhLNoN6L2PgFPBsgJX9S6qVNcYw3w+j3UW2kWnXkYNMVHAqwyngmdNqtQgmM2+wffTlD6lDhq23WRKZmq27IrMOJrG8+Mv/l5suCHyM1/9O9xLP8Mvnr3CaNWily4Z1S2pF8CT+ZppkFsCoejbcVr0I/ADaCfFhj/P8nS1RT9dsvQpg2TBlp1zXA1o24K9dELTliQ4Cp+wa2f0bMFh4viPfsjT+NOe/c8ULPcyxvcttrTYQi6E6obhjeSIp9sDPnRwQmoduRW/XGI8nWTFy81TdpMpvz67T8NWzKoGW9mclUt5Xmzx13/kA7j7PakUWNZ4A7a0Ecx5a6g6Eqdftyy28KGzzQqQcp5kXoaQE7l4c800smOmrKlb2TpuH0iWFVU7ux5gEKgQZdd8agKgI4Ino8Ayk3WZcOHnrSFZCoNcN9PgRdtg/8L4IMW0AQCaymPKWsBoYBNdFhIpN4JPe/KRRgABAABJREFUjA9rSN8hPfJrj5zLLMmqjimXkW3cYHxUouoNIe7erFMwI6u4lliaEEZhACondQw36qd/oPlmwMB7IZgMQVlrUwFezso30lTAWd4CNxIGzLngFyuhDP9msxCWkoEJYG9Ryvue5gKoRiN5Xu1gVcF4GmSROZhMAJQH5sHPlreEDWtk0G4KmMsM9I0AssGWPH4Vki9LpKsuawpYTNuyzSQVOWaSATkMl3BrS9i/q4lsJ8kFTJq5MGhVBaO5bHOyhOkCPvn90PGwWEE5F6mozyCbQyV/C7GZvM5GQ4Bp3hCgihHWzmz4E52WY+pJLu+W/PcGzn03Jk0sH77V5/VnI37fRw7f6+XczM18t8cAHaALtPkWzLjvCuS0k0tZj7IsaTab0dOl/VwKzlTip+mTi8WC09NTXnjhhRiOoTJHZfhUpqlyPpUeLhYL9vb2GAwGPHz4EIDBYMByuYyySy0CL8uS3d1d3nrrLTqdDrPZjPl8HkMwNvvlzs7O2Nvbi+DhyZMnNBqNKJW8ffs20+k0xu/PZrMYoe+9Z2tri9VqxWKx4Fd/9Vc5OjqKz1Mf3HK5ZDwes1gs4jHqdrtMp1M6nU7svhsMBuzs7FAUBVdXV/FYzOfzGJCiLJn3PnrCJpMJ1lqazSaLxYL5fM5gMIiJnio7nUwm7OzsxFCSg4ODCC63trYioEvTlK2trfgclVeqfFFrArTgu6qqCPo2kyCzLIvr7fV68Xnqr9RSc2VdnXP0+/0YapPn+TWJqJ4H1trIpOkNAa1B0PNTA1NUaqmdd+qt1FL292PYiYK4pc9pmoKlz9iyC9qmpmcNA9si6fUgzzCNBn/kd/5TUNcMfnKB84bKJyxqYmy/JEQKi2fx2CCLPFn1eDDcJ7N7fGLvMQ1TkRgn0stwATKumoH9WzLzDRL8Wl7pK2oS5q4RO+62bYuk3w2sGKRLh3EC4mwlwCLBYCcJi7pNeuTopAWpcXTSFc4bWknJo9Uup1ZKytumoGErGlYCXF5snPN67wXqViaSRJtga49jHUZiS0/VEgChfW1eZZGpIV3UAlY2vW/WCPNEYJIAF+SYPrHYVSX7M8HTZuQ5aM9aGvxpmMhcGecjG2jqdYG3fq2pksZ7vCMyZZElDOApKUXeaGonLF8ZAFJiARcZPJcna3ClgSxVSMysPaQ2spCynwD0atm31ivEGoIY7BK8e06B2XXAp11xuj42AWW6Bpo3812YQFKJws/jjYdGR7xxLvSpdXqhQy6B6SgUZvsAurwEjlBLAEnhYDiHhZXwEp8KoKmc7KzVgFkJszHYqQCs4VQCTvb3xEtmQ8dGuw+tlkT/N1JZT7EC2xQ2rdGSMJbzixCIkqz9asu2VAisQm9Hswtbt0RuiYX5SD76kLrpSwlL6TRg+4MCCmcLyY07GwmDlxt4fiG/q3kOe32ozqGeyr5GwHwGk7GAQm8FzBaV7MsENjPQ1g6+7pLKf/23bua7MB+9PeD1pzeBJzfz22L+PPB54JeR+oI/j7B07zrfkJE7OjrCOcd0OmU+nzMajSLboRK5druN957xeEyn0+Hhw4dRHvepT32K+XzO4eEhr7zySpTHFUXB7u4u8/k8skJpmka/3GAwYDAYAMRwlcvLS8qy5PLykl6vF3vfRqNRTM/81V/9VUC8b7u7uzx+/Jjv+77vi69nNpsxGo1iOqKCrKOjI+7cuYMxht3dXeq65tatWxRFwXg85kd/9Ef59V//dZ49e8bP//zP81M/9VP8wT/4B+n1erz66qsURRGBkMosVTo5nU55/vw51toYz68F1QcHB3z4wx/m8PCQ58+fs1gs6PV6rFarWCmgx0Z75xQUaXiMhqw452Lyp3MuykyVTVRGTUHRbDaLgSnaGTedTmMipoIhlcK22+1Yrq5MpRai63uq+1CAtVqtYmhJt9uN4Tkqw1WAreybsmtABGbz+Tz2/SlzquBWgZ2yluPxOCZj6rEeDofxMWdnZ3+/v1jftdG0x6Yp6NiCBE+NoWcN/8or/zim04bDLcgzqk6OKR3GOf7z+/8lf/prf5yvjA74QO8CgFbolnOY2CMnKZUpt5pjunsFpZPkymndoGErnheDa+up/foiXEvCAeauQY2laUqOkhW3khY/9kf/BNXHc/KZ5/wHGiQLj9NuNMBWEnCXzgx1nfA/fu1Fbh0OaaYVnUw65bbyBcs6xXnDS50LzssuizpjVm/x+vktOv/3AcnLbkNCCXgJMHHNhFTrAkyKXYULrlwi/G0ANXVusQH0mKLGFJX42Ky9Jh1UYBWDUTyRcQIBfLZ04D1On6chJsHn5hIBdlaBW0iXjNuG2GNnqiBH28CXSSnADUTqGEu+g5fO1l4Ap6uxqyCp1KCSRSVgM3rY1kyiwWNXXrYJG+mUdsNHJ6DSp8E7ZzZ68zauVm3lrrGBsPbKUdbXqgtu5tubrwMF6kVcfyJA3ciNrQRLlaSSyGh7AqSyBVgvgGe2EjmkC3cjkkTqCMZLokw2SUTGmDj5Nw/l4NaKL61aBrlmLo81EqgkYKkhrNiqgtEQ5hMBZTtb4o9LAjiyifxBGM8EdOlNgzoAp6QUf1oZGK/ag6lEGmqt9NSlCCBbhfO824V+H67OpF5gvoDRVNg35wSATUfynCSBnBD8soBlLUEnSSag0SFfVwHEeS/PD15BZ2If+w3v9h7Ma7f7/MKXTt7rZdzMzXwv5tB7r8Dtrxlj/tY3e8K7Ajn1G6mMTmV80+k0epsGg0EMvBgOhyRJwsHBAU+fPiVNU87Ozvjyl78cQZGmHarfS71xq9WK1WpFt9uNHXEaqKFJhtoT1mg0mEwmsdNuOp1ydXWFtZbPf/7z3Llzh/v37/ORj3yEz33uc7RarQiINMBD2RzvfUx4PDk54Wtf+1oMG3n48GEEjv/pf/qf8vz5c5xzfPnLX+aDH/xgBDyPHj1ia2srBogoe6ex/cPhMDKD5+fS/6fAR5klLVav6zqyk4vFIjJcmuSprJsmd65Wq5hCqUxinucxxMQ5x2g0ihURypgqc7Ups1QPW57n9Hq92IOnyZwaJNLr9WKK5Xg8joyXAnrdllYraCjNarWK8spNtlGLzyeTSfTx5Xkew0kWiwVVVcWqCpVfAjHgRJ+n3j0NNcmy7BrD934MO1n6LISJpNRIquSWLejZHNPtYDpt6kEblyfUrVRYn8LxJ//An+S/+Gs/wR/97J/mkdmmk6243apY1FmUTCbG4TDUWJw3pKYmTysG6YK2LRjVrVj6XW/UY2u3XWZqLCYwcw3mLmcvnWCBP/raP0b5iQZ1UySOVQtMbUgXxCsdp8F1K4MtoXINnrltsmaF9wabONrNgvGkha8sb27vMlvklOMGZpGw/UWDLcu1Pyz4vEy4Q54sKupmGiSKgDUkc7nI88pO5VbCTlKDqWQb1B7ja3zDRomjB7lS08oBCH4vL8ycyi69FwYvWbNUtvL44GMzQXJpVk5u6m8ycoliq5CM6UNvnP4ceXz05bFmC/UxWgMQy8mtucaYeRfYwlg5ANa5wPp9fcdbXB/rvrkY8hK369dITiPvAxAW/15g5awcX1tU39rJfzPX5jcFcfrRmzWIMCrnEyCHTYI3zUlMf8NBXiNdaksBTja8ZyYIMlflWiGYpkF66SFzsFgI8ElTCSKpKvk6C/xTkgJJYKYTAUppKqydR7x3jVzSNG0i4CzzAujquQC3wOoKWxhkkUUpcZyi64VqAS0vcsfFEqYJ5KEwvNmCVkfSLc9PpatuvoDJLGzHSQDLtC2PaTQFSLqQsjmfQTMTJq4dtu+cAEuVGnupUvDhaEf2zauY8hu9kzdw7zs5H70z4PloycV0xW638V4v52Zu5rs5E2PMnwE+Bfww8E3DHd4VyBljeP78OScnJ1Fyd3BwQFVVXF1dcXBwwIc+9KFYuPzaa6+RJAkPHjyIBdyPHz9mOp1y584dFosFR0dH16SKWrB9//597t69S6vVinK4zZTHra2tmISoUf0qXVRp5+npaSyLfvnll8myLDJqVVXxsY99LPq/1O+XJAmr1YrLy8tYCaDVAsPhkMPDw8gQ3r59m263y+/6Xb8rMo7n5+ex5Lqua7rdbjx2W1tbMTVzf3+f+XzOcDiM7JoGtfzGb/wGq9WKD3/4w7HeIM9zqqpitVpxdnaGMSb23/V6PWazGZPJhO3t7ej7U8/bpz/9ac7Pz7l9+zatVouXX345Sgo/8IEP8OjRI6qqigEmm6Cz1+vFNMnVakWj0Yi9cpuyxu3tbY6Pj2P5uyaR6nukXXYqA9UUyn6/j/eebrcbj1m73Y6eQJVcbtYaKDuoz1Pw1mq1YniOMSZ667RLT99rTSTN8zyWob+fZl43mNbNmAz5Q42n3E4b/LHf8Yfxt3ep2znFIBdfVxZARyfF1I4f/yN/hvw/kvf28Xib7VwYSy3ebthK+ulwYCz3mpcxxbLGUDqR8yrQa1jpfmuaUioNKvkf5txltJMVbSu+uj/zg38M7uxQ9hNhoCwUfbnMyUcC6tKlAIukQIgED0VpaFw18LYRNUmFhyaQTSEb5+yWnjo35BMnkkgFSIUjWUiwT93J0bJuEF+Xxv+7XAJPBIggnjDksT4TOWW8BAvBHC6VYA+MXQeP+BD5rw924BsWs6jkongjgCSZr4FL6mvxwIEwa0FO6TJ7DSDG0m2zAZDMurfO28A2K2DTQJHEbsg810yYrZzI4dSb5zf2D9h67V+LYFFZtAj6AkuZJcL6BaYuspber6sZrMUEwGY0TKUKDMbNfOdmTaoqTqbOE8qyCu+PF1Zpe0dki40WvLgDAw9PxzAcC7O13YXpHEjX0uC6FvZtUYj3rKoDw2YlJCQLASJJQ4CczSSUJGqpEwFO6VJ+J1odOTfzHCaF+N2yEONv8hDIEhi+JJGfUa773AovXjkTaixOjqHXE9no/mHwywH1EnZvyWs1Bjp9eQ1ZCG8xQF3CZAqdJmwZAaTTqWx/sAsY8QGmoRh9vpTj4jxUQYIfysSl9FvouICp179X19+mm/kuzSuHXbLE8IVnY37k1f33ejk3czPfzfmXgT8D/DjwBvAvfbMnvCuQe/jwIaPRiOfPn0cwNZ/PabVafPKTn6Tb7bK7uxsvnJvNZgyTsNbGQJK6rnn8+DHW2gjmVC6oP1e55Ntvv02WZRHsKGs1HA5jgMjV1RVbW1uxgPpzn/scDx484PXXX+eVV14BiLJJ9aF579nb22O5XMbOOJUEqt9OwaMGdty6dYujo6P/P3v/HXVdlt/1gZ+9zzk3pye9sXJ1VYeqlroRCiC1hYkagkwQwtgEATMwGHsNAwtsw2CPZy34w3hYGIYZExaMPeMZLNlDEoggYLWQAEG3LHWs7uqKb3ryfW6+J+09f/z2b9/7VNdbHaTuelt6dq+3n+e54Zx9wr11vuebODg4YH9/HyDWGAyHw8hUjkYjAKbTaUxK1MevX7/O+fl5ZCIff/zxODcFF5qG+eM//uN84AMfuJTKqDLGuq4ZDAZx24bDYYz11wL0nZ2dmCypnjkgMlFJknD9+nUajQbT6ZT5fM5isYhgSb2PQPQQ9vt9zs/PIzMK4qkry5I333yTp556KobNqAxTmVwFedPplDRNWS6XMV1UGVaVYGpKprKTrVYrhrcMBgNmsxmj0Sj26+V5ztnZWWQoNdlUQ3e0006DdTSYRZnkR2nczXdY1RkNW/GezjH/+6c+QnrrJu6pPQFwiFQwhE/iAkOzPmhhC8dffv9f56+cfDefqG7xYDVg0FjTrKsY56/sXCfINnOXMatFvjqv5ZhWPqFtC6zxrOqMTy4fYz+bc2e9Qy/JhaEru0yrNi9PDmg+O2B5s03RtxHMNKYGWwRvmDO4BJJCWB5JVoT2KeAlACUpPFVLftoSktzTnDopwc5l7i4zeJuQrCFbyfkcpY9B9pjmkoaXpBL0YIJHTSSHiGTKbkCNTy2uk4kPrqwDuHISYBd8YeL52dxx91nY+R5MXcvyfLK5mAteO/WKJWGexntclmAqF0u4Y0plWQtbRpDKbZFeOGLBuQadABtGLfj4jDKG3kPlAnMWwGvl4pX/pv+tlmWYIJ9UuaemTQbNnoI9EySZ+jfWXu6YS21I/wy7JzA76j28Gj+bEU6GUGKWYMOxMGATSleTOkuWpAJeWg0BLSCgrGMk9r+q5YTMGlI5kAQw1WgJGFM21aSSSllUAdSV8hnoj0TyaNjIKtdLWC4ljbKZiPcubcLurrB/6xzWC1neModOE673RWa5mAsY9E5qBtpdMBlUCPiiKf66dit44ax04J0ewd6uAEyTyfqXK5mnD9SiNQLSmrU8570Uh5tUKgkWc/EHlrX06K1XAlwbXZmbceArYekcmKomxWNweBNkzCqZDh9+H39eja/laKYJz1/v86n7kysgdzV+Xg/v/dQY82+Ac+Dz3vsvaQ59KJA7Ozvj5ZdfZjqdRjnkjRs3on+t3+9f6gQzxtDv99nb2+Pi4oLDw0OAmIqohdgamqJBGXmex5JwIC5nuVzS7/cjO+S9j7HyKsXL8zx2wd29e5fd3V2efPJJTk9Po4dLwzvKsoygQh+r65p+vx/TIDUFUYNV6rrm5OQE731keVTeB8Rut8ViwWg0otPpRDCXJEksUFeApbJDBbzqUwMYj8fcu3cPYwy7u7tRwgiboBn1J3rvWa1WsRphb2/vEkOp89D3akpomqbs7u5irY1+R5Vzap+ezluPqQbK6LEpyzJKLKuqIsuyKK9U0Kj7SeW0eqwVXOrfCpy1fkADVXR96iXU4+WcYzabxW1tNBoxXVOX02w2Y6qlpoAul0tgIyV9lEZep1g8N5pTvrn1Jv989yP4QZeqmwmTkwrjtYnFlh8+kRTC/+xX/4d86w+9RCcTIFbUSQSGmtHZS/JYGr6sGyxdgwRH5RNKl1AFX5x1EpKSUlN7y6xskRhP7Q172YJ2UtBr5Mz2W1Rtgzbi+sSQLsP0HBEUGSfz9FbC8oyDuinbUGeGbOFxqSiebEX0wdlSwJ6t5OLJVh6fJfgAJrYLuzUqP1lXeBNqAd46HLGGIKY66v70HptLMbYmMvrAeJnay8VhWJ8N68KYLwYrPkgMvZeergC4L7NwQcboCR1u4UI6EYBkgJgSqdY/5yL4Ek8RAWS6uDzxM4F3mwJvW9fyWmvFq6SyOre18T6k7W0xc96aDeu3XbQeXh/3ux6DSrcpgIxkS9Z5Nb702GJ3onSPDYDetA6EPwJYD2eLAI31Ck9DQMu6BJywXd1OKOauBaQ7BNRZK9LEfLn1vZIGP2cdUiytMFJpMzBkoaOuqiVxcrGULrheK0grrfjzsCKlXCzk/R6gkhCTLJP3d1qh5sDJ/GofvGnI++VkFsYPI8BruYLOWuaSJDBfyMurcJ4nIW2yOxB5aNoUUNbuCvPmwrJd+GBlLcjnYX/6Ta+c7pCqhrIiwePwOLmr8UXj7QHcFaz7WowXbg349FXgydX4eT6MMX8JcfR+DPgBY8xv997/oXd6z0OB3E/91E/FcIjd3V1u3LhBs9nkiSeeiL42jXvf39+PF8vPPvssg8GALMv4J//kn3D79m2+8IUvsLOzE2V5epGvJdL693A4xHsfwzzUn6WSSfXQnZ6ekqYpr7zyCp1Oh4ODA5588kmuX78eXz8YDDg4OGBnZwdrLUdHR/HC//XXX2c0GlGWZawp6Ha7EeioRFJLy1U+mmUZt27dikmKSZLw+uuvRwnicrmMZd1ZlkXZJRCrFowxsdZBZZTKXr300ku88cYbvOc97+Gxxx7jqaeeYrVacXJyEiWiWlq+DaBhU8StbNVwOIwslSaEWmsZjUaxl208HrNcLmN4SKfTiWmPCr739vYoy/KSTNIYw+3bt+PvCtKUAWs2m5FtVLCn7FmWZTGtstVqRdCmbJ520al89uLigsViEWWR7XY7sn/6t/r+1Afovcd7H19X1zUXFxcxLOVRGr9o8AYJjt/c/zw/8MFfi3/yOnWngWtY6SJjA4hs6fFWwIHLRGp5/q0H/L6d/56Pj5/gemvG5y6uMWxI8pvzhpKEpWuQO+mpq1yCNY5FfbmKYVVn1N5QuYRuWuCyJd82eo1l3eQTs9us6ozCpfyfnvhh/mhHvlPStTBoVbi5b0tPtpQ5uswEf5wEoCjoM/UGrBkH2cILK1eJ14xSWDyVZCa5wzUsVTshbQg48sZgawkFcZ2GAI4AAkmCN07xXNA+uSzBpyEUBEgn+YZp02CHkEhpjIEgyTTVFkiBrWJxAU0+sdiiFCBWb3nHgmzTt0K6Y1njm2mUThqzYQwNW0DNmA2os1aAkoIjlVdauwkXCa/ZhI0Eb57KHLeAKGlIoFSNnjdBHhmkoEUlnr2t0EmfJZhtIlvXV9ahm66OANhomXh55ZH7asc2mHvrMArkihqPxRjIfA7378N+A/bbcHYiTFzWhJ0+dEewnoknrpcgReGZJEveWwQGLhOWy1VSVZBlIqdMm/J4vwnFCqYT6WebTaU0e1IKeCKTZMpWCzqJSCjP5hKqYnMoZyFNsyfJlkl4TZJJGtJqKedqqy9MIQ4mY/HZeYS5SxsCUuu5BLLMl5C25PWVk1TMnQyKVCSavQp2BsJWVpWwit0hMJc93BvAxAiwK9eyv7ImrFMBqsscsy4w1JQ44m0b9c9d+eC+7uPF20P++o+/9m5P42pcja/1eNF7/93h979sjPnol3rDQ4HccrlkNpsxHA65fv06jz32GEDs/Go2m1GSuB333ul0uHXrFm+++WaM9dfiak0g1JCMuq4jq9fv9+l0OpHdGY/HEagMh0MuLi5iSIgCyjzPuXPnTvRzAZeAQ13XUaKnf3c6neg/6/f7ZFlGnucRKHW7XYbDYQz3aDabnJ6eRiBS1zVFUXBwcEBd1xweHsZaBA3zUNZKJZUKgFRSqrLJTqfDfD6PgRwKXo6Pj2NlQJqmkYHU/d/v96NsUUGarltTGyeTSSxj7/f78a57o9EgyzJGoxHj8ThKWbUmQNMwla1Thk23R5enATXat6eyRgWUyhz2+32AuB4gds1pb58Gx9y6dYt+v0+v14v9fspGKghWELtcLmM3nAbFFEURGVctY1e5qMpVH7XxG3qf5WbS5t/7Zb8TrluqfhMSE+/GGw8Yv7mY9kE26JWVM/yeH/g/8Bv+4j/ln52+jyypGecdDlpzVq7BKF3ivGFVN1jVGdZ4AXjekhmHNZ7SJThv4l3+3CWMyw7DZEXuU9pJyW62oJfm/J/f+0uwv0HCRUQeCWke5pIayi5oYqQAsYBrgnIpKbYZOk9j4bbAnXjSNMofiN1oPvjMpAR7gyxcAGPJuooBJ6Z2uEYqckoN8Ahg0jqHqUJ0/1bBtcobjff4SpJBgcDQGemI21ovlcMkJgavSOpdAGRVKH/YCkTZ9qOJpJENYFKmxIGptkBQmIMpa3wjjYEikQ1MrTAb+loTSotztwFTjsj0ef1dmTqdkwKwqsYY98XeOQWUIEC5FGbGZGkEcRrcYh5B+fIjPR6CBSyS+yHHyZDWXk4xfU/iSfA06hJ+5lPQbcCgB0/uwN41SbCcJLC7D6e1MGQ7tYC0RhPWFWhwSdoQsKROvNkSTCkf7MoLjW69VBHkK3l9ZwhuDTaVFMmTscghrWrASwlaKRK4cSABJaUJIHIk7KEWjpOKRLJeSwKldxJY0u3JeVc56PQ2Vytl2AlVBVUhISv9jrxmALz+mjy+O5DlVEFq3GlIQqUtZXv3D8QTt8zlS2m1EEA5m0tgSyU3GR2BtXb6kVSofQXkvp7jhVtDXj9bMl2XDFrZuz2dq3E1vlajMsb8KoSR+zZEeP6O46FXtnmes7Ozwwc/+EFu3brFzs5OvHDXgmYFLdPpNIZUKCPV6XTodDoURREZtjt37kT/03ve854IjrZli4vFAmMMk8mEW7duUdd1ZI6Oj4+p65qDgwNef/316NVSiePu7i43b96k0WhwdnZGq9Xiueee4wtf+AIXFxf0+31OT0/JsozJZBLllQqSGo0Gd+/epdPp8PTTT0cAce/evQj2tqWV/X4/JjMqSNX17u7uxth+9cydnJxE1klTHzVR0znH008/HeWAL7/8Mufn57zwwguXfIgKZPI8x1obPXWLxSICa5U4TiYTBoMBdV3T7Xa5du1alE6macrOzg7j8TgCviRJYsLm7u5uDEHR9epxV3ClbJ5zjsVCpC7bwHB3dzeCagVUOrRCQpM0VW6rrOlwOIysrQawqDxUZaAg0l31D2qVBRCTMrWCwDkX/YyP0viD3/59uOu75E+2pew6FVlb9EyJhUv+tsReMFODxZOuhJ37J7/hQzz7g/c4z7osq4xx0aZha9q2oMZyUbYpQriJ84ZWUmFtTR6klRYBeACvTPaZr5t8onObJ/rn/Mqdz/BC8z4vNgzf+y2/j2TlJOEwhXTtSUpP2ZGGYlNBWkIxMHgnbFtSeMqOIV170qUjXddUrQTXED+cLSSsRAuzi1FTmInA8tlFtQFkRhg5l1pIrVQLlE4uKGth5FwmJcWukUTfmC1Uq2iomwk0E/GSeY9vprFWwCuzpOwYss8JtQ9aJyDgJjB16kdzga2rNeVyi1txbKSQiGTSJwlGpV6OTR+bevsSA6kAMJFgmk06ZHgs1gCE5YGsP463yCEjm6eAsXaYqg5+vCp432K8Jma1BezUO5hYyFLZxnjhHuZSu0vrvBpfwdhiXb/occSP5dXHmVpq78mrWkqwz2YwXsDT10L6KhIUovH8FzNwextPnA/SaFdLV1oSQJg1Et+fBS/YOgcr6yNFmK88JBmlQc6YJALavAsyy0zkvHX4nPgk+C8TYfpsElIlC7nhUOTCBCZsis2NAxryGE6ApGUrWdLLY8ZBJ4SqELYnscIkZi0BaTaVhEqsrD9L5aPZ7QWpaC1zM4Ep9D7up6ABQH9cOeLevfH+m32sgc/cn/Idz+y929O5GlfjazV+N/CfAX8EeDn8/Y7joUBuf3+f69ev88ILL3BwcMDu7m4M8uh0OrTb7djRtS3fU7bm+vXrfOd3fief/OQnOTk5iX6wp556ijfffJPPfOYzPP744zH2XlkjBQr7+/tRNtjr9Viv1/H1s9mMP/fn/hy/5bf8Fu7evcvp6Snvf//7efzxx9nd3Y0M2oc+9CE+8YlPsLu7y2KxoNlsxiTK8XgcgVaSJLz3ve+NUfd5nnPjxg2SJOH4+BggAo7xeBwDPoqiiKwaEKsZNDBlOp3GLrWqqhgOh7Ef7ezsLLJm165do9frRQ/ZwcEBd+7c4cGDB5Hlev/73x+78Y6Ojmg2m9y8eZOyLDk9PY0Mp0ouFYSen5/z2GOPRcCnoHQ2m13ymXW73dhdp1LETqcTpZLqm9NzQMG3JlRqaqb61YAYcOOci4DMGBNZQWX6VBqpy9D3atVCkiS02+14fgCR/d3b28NaGxm3brdLlmUx3VS9gI1G45EEcvNf/ARAKKIO8frb7JvigSBNJEgrI2haCxOzfG6fL/y6JX/yX/1D/uKDX8m8bFK4lKN8QGZrumnOdDUEoJWUFEFiCdDQlEtTkdcpRSW9bm/c2+O9Lxzxm3t3+W3f+hvxu0PqgxTXFFBVtQxJCDJJV8DKU7WhCuyXt1D0DIM7FcZZVnuJyC4bhrIjpdNVC5oXAvZiWmQRmCjnSZYlJiQuuqb0VxkxCWGcJ12UQS4osf91ZmOBd9202MJJSXgoqa5aiYDD0A/ng2zRLMuNx8sRAJIPARFWIJnz4SLRhPCDAIqSTZ0AsAEzETS5zXLf6jPbiu1nq+Jgw9a5+Frpd3OXKwu2GLAIQIOX0GepgDrn0VJjQ5BCxh68jTQyAtewv7E2SDMlJMWbsL4gHzUkeCeyTp/aUPFQy8X41fgqh37YN245jMHj5B4C8jnxNqX0njkVflUKiDuZgXtM/GTtBuz2YXcI9yzMJnIelLV4x7LgF65rSWlst8K5bSXMxIRCyHUOVALMmg3o7MDawLIQQNRsCsu2niIl40Fa3GpCncr8KyN9dDaEojiE2Vss5bnVQs6p4UC8ex4BfyYkaDaAchXOzxrqPHwWvUgnd3ZEFlqsBWS2WrLerAXVWIJeOj1YVTKHBtC04qcrCum282bjv8OIXNs5CY16yz0ZOSo+Bp1cja/P6DRSnjno8al7kysgdzUeuWGM+e3AX/DeHxhjfhvwh4EV8Lu993eMMR8A/gpye+pPee9/9O2W472/C/zHX8m67cOe6HQ6DAaDCFoUVGk0vBZAKwAAYbT0ovvGjRvs7Ozwvve9Dy17Pjk54Sd/8ie5c+cO6/WaV199NV7Eay9cnud0Op3ohzs8PIyplbu7uzSbTf7+3//7jMdjDg8PuX79OqPRiPe///0x5EMZnjRNI9DQC/2yLOn1ejz55JMRUCnQAGJKozKIr7zySqwy0AqGbfmggjWtHBiNRpEhKooigpXr16+zv79Pt9slz3MWi0UEh8pAqTev3W5Hn+FkMuH09PTS+lXGqiE03W43es0UVCu40hAQlYoWRcG9e/diT5z2uQHxfXr8lf0ryzIeQ/XaqQ9RGTkFU3qu6Pr09epb02OhvXLdbjeCO2NMBMMq4VV2T+ekxzFN0xhoo68HIouo3XHbSZVaMv8ojbopgSbak0aIzQeVVXLpmg64dEPYlj5G5rvHr/Fnfvlv5L9/6h+RGseibDAvm4zzDqs6IzU1raQUGWVg33ppwSDNaSdy/syrJu2sZNBes38w41ePPk3bNKgfO6DuNiIbaALbJgEmJmyLXPsluUgrfWKo27J9dSOwCvH9ROmoqSVwhABEknVFsqo2IC5LRAoZ5E2mkhAOUwsLZMtaQjpCmbVrWFxmN0ERTpgzl1wuADde992WHDCEH/jUhsQ/NdldBmmmrANIeouU0BgJadhmzBITwdel9WzJN9WfJ+uSfWJC8fal8m2zBQiVNdwqLccYfCPbzDueU1v/0kTYO+c3LJsL9QTbdQfObRg7fUyXEQBdBI86/+Sh/0m5Gl/W2DrW7u0e38hda2Mo8Jh1KWmRiyW89Hl4+VV4856At/c9Cy++H555j7y1qsVHaQJIz1Jo92A0kq41DNy4DZ0+mBR8eH1pRCbpUrh+HT7wnEgm87UUgePCHBZwcR5AVAB8szn09yVR0hfitzMW2v0AyFrQ7AmIKxzkAB2pFFivhTG06merYBUkzFkiCZcm3LyojHjw+nvit1uWgAXbkHWs1rJN7T7s7kC3K8CyTmUbi0IAZlFhq5LEV7Jd8TNy6QhcjXdhvHhrwGfuXwWeXI1HaxhjLPB9wB1jTIawad8N/KnwD+DPAL8H+DXA/+UdlvWfGmN+2hjzL40x/8oY8y+/1PofysjdunWLwWBAq9WKF8waeKEySvWeaaS8hp8AXLt2LZZBf/CDH4zhGq+//jrGGH74h3+Yvb09zs/P+fZv//YYmhE2hPPz8yi9XK/XdDodLi4uuH//PgB/4k/8CVqtFq+++irf9E3fxO7uLg8ePGA6nXLt2rXIKnW73cgcqi9rPp9z7dq1KPsrioKPfexjkZ1SkHnv3j0uLi5isIkCKAUdvV4vyv8UsDSbzZiueePGjQiANISl1WrRarVid11RFLEGQANh8jxnf3+ffr/PK6+8wnK55NVXX+X09JTHH388HgMFOtvgSo+HMobKpCqgubi4iP8ODg5i2bimRqpXbrFYRFCu3rPt2gD1xGkfnHr3ms1m9DcqmAKinFP3oy5Pga4CRg1KUblrnueMRqOYkqqgTcH/2dlZPO+Wy2X0CZ6fn3N2dhbBtCaqPmrDpQZjPKknJgFKH64kChqnnjiJ9Y+jkotqbwlJg4Z8v00jtfz6/+D384P/77/Enz39Dj5+/gTGeKq8S2ocqZEy3tTWtJMy1g5Yl1I4+ToYNNd00oJfs/dpvrc75ns/8luobyXYylEMU7KFfMartrBfjdJTdsQT5pJgqSnBW/k856OE5qTGZcLiGW9pzKQjLl3XmNJF0OKNIb1YSYgJoEmKpg53xoO+yYSwE5IQgx/wgy2cBK344NMjgMfSiTqrqGMgCgjIM3ktoR5lSMADifhvpvhGillXkIXjU6msy8ZqA2pl9pJN5H9qZc55uQlVscjy1UunbJyWgYe0Sg1XkaoDGwEVysQpANwGoG8DoCLYc1ugDzZhKsoO6nPbsj4FnonFJ41LjB3byw0BHHI8KgHBV2DuZzVkr27dODCeWrg4ILBBZQne4G1Kz9Xk1BSmFiZLgX+jBddvwvkZ7I3kXEtbAmzytTBSrhIvWKMloSZpKoxdmoi/bLESELXI4XwGWUfeb6zINo/HwvIlDfGgVZUAuqQMvWxGwNliHpJcW1Icaa2cs72h9Lu5WiSVaYi1rWpJnPSF/FsWMjcjEu4No+xkjmXw0iVNQpeBLKfdk/dRy3dmmorXLzXQHkKZgD0WsLheCZu5mENd48OSvIbMACYUg1+Nd2e8eHvID37szrs9jatxNd46/gPgfwb+KPAc8GnvfQH8hDHmvwmvuem9fxnAGHNmjNn33p++zbJ+E/Bh7/2X/VXzjoXg165di/4pDfpYLBbM5/NL7Ms2W6ceryRJuH37Nt1uN0bVv/LKK/T7fSaTCa+88gqLxSL6zJ566qkYuT+bzeKFe7vdjsmOd+/e5d/8m38TC8CfffZZ3ve+98UEy9lsFue2Wq1i2uHBwQEnJydxucfHx0ynUzqdDjdu3OBzn/scTz/9dOzG29nZidULq9WK4XAYPVoKchQwDQaDWKGg/4wxkSXT/aTrzrKMXq9Ht9vl7Ows1jIoKzWfzyPISdOUxx57jNPTU46Ojrh7926ULQ4Gg1idsFqtIqBU6aHG9msfX57nfPazn+XNN9/k/v370bf2xBNPRBav2+1GJgyIwFNB9mw2i69RQNVoNCIg1eOkgEu3f7Va0Ww2Y6iJ1jA0m80ItPT1WjOgrJ7KdTXtU/fnNgh0zkX5pEp+t2WerVaL69evP5L1A7b00Q8XCbetlEJT+42sD73gJ0gXPaRb6Zaloxg2SNc1v+23/UGSRcGf/Fv/X/7CPZFatrISh2G/sSC1NdeyGUvXIDM11niatmKYrbjdHPNc84i/+st/Gf/zzi+jut2OXWmt0yJKQCWcxFB1E9K1w9aGvC8X8enKU7XkdxdCWXpvril2GqErToBbMpUAHbuWn77VEBBU1gKsNBwktdLJFgEEsu1ZqAOohN6zHowXNq5u2gg+rJEAFZvXwSsmMfumFlYp+tB0KEAkACsNRWlk4oGLMkR1zZiQnG5xrRS7KjGrAt9pCvAKzJy+R8NOVE4aj7cefwAnElajqZAqg9Q0Sr+5wKR2gQl0m9dpAEpZXmYiywC2AiMZf6/qLwZrQUoqUfE2ALVwHCwb1nJrOXEZV+MrHErB+62qMjkObgtAWMBXNd5YSBp0nMOVOUW+EjCUhILtLBWwtbsD+3swnYmnzTZEPtnpAU5+T1PxjPW6sJxDlUrYySqwWmUpEsQihyZgGgK0uJBzO0tDpYEkPlJUGyBXeZFPNpJQMq7DCAuY51D6wACGmx4J8px62IoKbCZALstCp124GbIsAgNukPRNwneEke01XgCmTUMBeAaZCYA0C37XQsDtahVSNDdA7mGeOPPQZ67G12q8cGvIF44/y6qoab9d1czVuBpf52GMSYDvB34jAuRGwDZtrCfq9n8YJ8Au8HZA7n8FbgN3v9w5PBTIqW9Ny54VoOjFc5Ikl9gVvaBer9cx8TDP8/iaLMt47rnnGI1GHB4eMp/POTo6imDo4uKCmzdvMplMMMZw/fp1dnd3Y9z8ZDLhk5/8JOfn5+zu7nL9+nXquuaZZ55hNptFJkf/KVP0xBNPcOPGDT75yU8ymUzY2dmJslAFI8aY6K/TSoLDw8MYx6/Mm/eeyWSC957hcBjDX5IkYTKZxPJuTXdUH5fKF5fLZSzz1rAP7YbT16vHDkSqqhLX6XRKURSMx2N6vV6M2leA3W63Wa1WUSKqYEmL0RuNBm+88Qbn5+cxDbKua27evHkpkVPf2263Y4BJu91mNptFVk+ZWC3f1sRN7W9zzrFcLun1erHkW5M1W61W9PKpbFJ7A9VLqGEqWv+grN5wOLx03NRfuS2l3e600/1XVVWU6j5qw8e4fIN3G9ZDgF24VAjx+lvXeRFcSKqjSBo17bHOLNYa6naHP/Nb/0P+yt/6y/xHr/5WbrRmDNIVw3TFfjpjlCw5rERu2jIlNZbSJzzbOOa92Rn1/lAqnVKDr0wo964h92ANVZaBCddeYX62Brv2pLknXUtPnEuhbFvSViK1CSolBblLr8EfdS2gx4RkxKIUL5Zz+KSBjWmPoeS6crIvnAAzATsOvHjTjDJeiF+PUBociShz+ZvV1NJXt2GcwNTbKZJeUh2dx9gtEGUE2PoQ7+8D+CRLN78HcBpBGmykc/qe7RtwKuPaZsvqLZC03SG3nT6pzwVwhXchzbPesGyBQbsU6PLWkJK4TFmGqWq8C6BZvYJvlVTaZMNYXo2fxTBf5L9yVuo8VGmdeHBZim+1yC7W2Ht3oF7Bkzfgyadg/4YkRzoPe3vwwRfh4x8TyWOjB8MdoBSQMxjBch2AewaP3ZAkynWI5Z+t5Utmp0EMF9kZCtNmu3IOVR5cJmyeCQye80G+WYfy7RT6bdkC7Y5ztQDAbl9+np8LK7dzTUJWChcqEtpAKmBsty8Jlx4Bb4syFH8b8eqtVsH7KW9htYZ1Afu3A5D0MNyHB/dhOhcAWeawmsN0LFLQKlQ8UG0p2re/La7O8XdjfODWAOfhs4dTftETO+/2dK7GL6zxmDHmB8PvP+S9/6Hw++8AftB77wKpNUbyc3WozmdbLD9CCr/jMMb8W+SLJQE+aozR5733/tveaWIPBXKPP/44WZZdYmcUpChA0Jj6t/qiNCa+2WyyWCwoigJjDAcHB7Tbbfb29uj3+9y7d4/JZMKbb77JaDSKwKjZbHLt2jWKouDo6AhjDJ///OfpdDo888wzfM/3fA/L5ZIHDx5wenoaQZeWTysjBpCmKWdnZ7GfTLdlPB5z8+ZN6rrmN//m38yNGzdYLBb82I/9GIeHhxRFwe3bt2MKY6vVAohgSRMXtTZhtVpFgKL+MwU1uk2a3llVVew0u3nzJs457ty5E+sEdD+q7DPLshjYYq3l+PiY8XjMU089FdMnFexqjUKz2eTGjRsMBgOGwyEPHjxgsVjw2muvRT+ic47HH3+c0WhElmVMp1O63W70PWqiqILEXq8XmbBtL6MC/cViEX2K2yCr0+lckt9uF4erb0+ZOz2P9JzRagPvfQT22smnNxR0Prpfz87OuHPnDuPxmDzPuXbtWgxNedSGxO0jgEhZEyVFuAw09MEovRPVVQBxlxm9KrO4hsG4Jr/vd/4nmMrz3/7g32fsVpTes5+0ebNasW4c0TE1iZGb4pmRJE2/O4S2oRw0yaY5dSvFZxYXkhNNLYEh3hiSlaPeYt/KjoEJ2ErmVbUNdRNc2iApfQwbMaXbgI9EJFhmVQjQKEpIElwn27ByDfH1xDh+wGo8eTMkcmYJtqgFbATpo+5XlxjKXkq6rmUbnI/PqaxTdqD403wzC5drWyBIAdS2byx6xzKMr0nPc3AON+yQnM+lOmHUxeRlkK65ywANohxT/XHemBim4o25fB7oOtNky7tXx9TMyKBBTKTcBnHR/6br1/NOWd9wQ8Bbg8kLNEDFvNVvt73tb2XzrsZXMTaQQf/yEPe3MRLU6NgcBufhAk9eOvGEnc4CO5tKP9zFFIZDuLkHD07E66bFjiYA8KwpkstmMzC9GfhS/GjzIJFsNKDTDZ2GIVlyvoThCFodODmBfCE+s7KG5RLpuzBAUyScdSnL2bshrKG14l1rpBsJcbMjss1yJXOsaulhKGsY9WWb6lwAnpdqBvGIruS8W+TCHoKEsywmoaLDSJdetZL6gnoN0yVMpnB8PwSlFOLLKyusqzGIpDVeffmtI/RWKfLV+LqMYTvjid0On743uQJyV+PrPe5677//bR7/APBhY8zvQGSVvx/4gDGmAXwr8InwukNjzHPAEbD7Vlml9/5bv9qJPRTIqYxSGY3VahWDM/QCXy/29QK5LMsYnKEsSrvdjh43IF6c9/t9rl27xmOPPYa1lizL2N/fZzabsbu7y3Q6ZT6fMxwOGY/HFEXB+973Pq5duxaLwEejEefn5zGRUsFbVVWXQIPWAehz6kMbjUa0223KsuTu3btUVRWLoxXYDAaDyKhplYImQirjNp/PabfbdDodzs/P47o1KVK9c+v1muVyyWAwiCzeW/1iCooajUYEe5rsqMBZ56Iy0r29vSh/VL9dp9Oh2+3GKobT01MuLi6idFNZNJ2frkePpx5TlY0WRREZNvWnaSKl9z4ysJ1O59L26PHWfajyS/XjKZMHxOOi55tu87b3TeeiDGmWZdEDqfJMPQ+TJKHX6zEajeh0OpGtfKSGMmzuMrCITF0q8foa2PHW9/rIOEkdgBHrDBiiv87mNeWgwW/4d38rZjrH1w6qir/zqR+l9DVN0+TXPfUdAjDSFN4zkoCRIGX01sgFnCeCOBAppwkeNowPckWZe92AWu59kOSBGduaviZNAptI/0ugyOCzdAPYViW+gQCsxGKLatOFZreAmM43XmhtOukIklBvDCayiD6WYBu/mY8PTKF5KOBBAM+6DCAs7CtnoK4xqxyGHbk4bbWiJNFbi6mKL/K0xffqvgnF4x71B+q6N145ubJHeuucF3bDWmBzHmmAjLzWbkCXSiYv+eICMnAeqINE1V/24m1JfCPrF+ZKVV0lVn4txtvhhfBZpK7JvaeuKmGdpgsopOePIrBirQ7sDWGwI0xbTYjwTzaBJ5UR8JcE+eEiJFYulqF7Lgk9cWHZi6WAtaxNRDir5YZlW6/kRoMyYGUt/5wNXriwrkZLXhfSUWk0QzVBGeblQ8l9QxhfE0KMahfudIVztCqlwqAow2c1vDYw9CQN8OGmRuWFiVvmwjrmK9lXq+CRcyJkNbjNrg/fFdtfYlcw7t0ZL94e8OmrwJOr8YgM7/1/qr8bYz7mvf8/GmP+feCjwBr4XeHpPwH8DYRx+y/euhxjzB/w3v9lY8yf5S1fL977P/5Oc3gokOt2u7HIW8FOnuecn5/T6XTY3d2NF8fKMikTs1qt6HQ6MeJ+Z2cnAoPlcon3nieeeILd3V263S7vec97yPOcwWDAbDbj9ddfj8zfwcEBo9GIRqPBc889h3OOwWAQ+9oUzDjnuHnzJkVR8PLLLwNEMKGABTapjv1+n5s3b2KM4e7duzHURLdD5YNAlEwqQNTAlF6vR13XUXqp81UA1mg0IujQUJNGoxEL1LWSQfexFnkPh8MIdjqdTpQe6ntVxnp+fk6e51xcXPD888+TpintdjsmOo5GI5bLJT/2Yz/GxcUFr7zyStwm3Q9a6A3S7aaAXSWMyq62Wq3Iam0XnCtwUmmrcy5WBahUNEmSWGugTCAQ5aZarK5AcLlccnFxAYg3U0G7Mqp6LLXa4cknn4ygcr1eR9DZ7/djUMrTTz/N2dnZO30W3t0RbpB7I36yyLZpRL4ycVYuMZSpkeAPL9czlmgx0XTHumGpmw2S3FHt9UjawYNWOb731/4OzDLHVDXJY4icqN+h7jWEEUotNq+peg2Jlq89rpFK75uCuXCR70Ogna1kzknpsZWEuXgrYK45kdfacvMd5ZopdhXkWGkCZYUpSnwjwzdTTFFF6SFa1B2YK5/IPpIJiFzQVvK7Ty22vnypZVKLrRyukcSScTC4Vho8X1bWp941q4C1FrC3zUIF6aX0uwW/jnMYa6HZwF9MsatyS7oogMd4Lxeo214yDVLYArK+htgX93ahJFusGyb4/baYtui909dYxPfTyDC1+WKZJWykcLpsV19m7sK6ZHnmMjsZPtM+fH9eja9iRKAgd3cunb3OE1o3AK1Sc+AKajwUOWY2w48vYLKC6QqSU0hH0OhAFjrlSrc5b/M8LMghrHPoXmulcFTAeBaCUq5BOxHmzJiQTDkRySMLwp0omEzkA5laAXWDgYC/ThvKFGxbwkdc0DymLWHYTNjmLIW2l3ktlvLeKjCNN/bDeVkLoxgL6nVbCgFjpRN5qAlsnUlEqpn1wBWyTm/g/FRA3DqXS6ZFYOcuLrB4bNj/3li0D0aPivplr8a7M164NeRHPvXg3Z7G1bgaXzS89784/PybwN98y3OfAb7rHd7+r8PPH/5K1/uOQE6rB6y1zGazKHdToKM+Le99DLFQX5WCrLIsGY/HkRVT0LZarcjznKeeeorr169HpuvatWu0223m8znr9ZrhcEiWZVy7do27d+/G8JN2u83h4SE3btyIIElZGmXMlE3r9/vs7+9HAKIeuyzLeOWVV6IETwMzhsNh7H3b2dlhOByi8flHR0cxNh+IUfea6KigUdkj/Vt9Z0AsJdcKAS2r1hoELdre3d3l4OCAuq4ZjUbUdc3Z2VkEm0mSUBRFTG5st9sR9O7v73N4eMjh4SGf//znmUwmrFarKJHUi62XX36Z559/nlu3bkV5JHBp3nVdx32qPjoFoOpJa7VasQRembf1eh1ZRJVPbnvhnHM0m83Yg6dSVA0qUQZN99vx8THdbpflcslisYjMnwJ5DaHR7jiQDsJer8f5+Tl37jx6aVe28pfSFaOsMpEbyLFTzohPJvwa/XG2lkJwZfbUJwcBGAbmyWUW2qlIEZ3DN1JcZrGpFcARhrcWu642kkdrN0yhMVTdlLqVyDWS86RLsLXDTh3J2oLJKEPlQLpy2Fqum7JVAH8BrPrEYLzZYp+2JHshZdHkFa7XjKAq+ueqAC5CaiXGbIJQynqTEklYTylMlW67XTqRXAZWTEJPfGTnjBMvnim3Qk22mEKMwayLEMEfAJ+XGHifJphVjjcWM5njhz3I5XvTK8uW2k1SZV2HZEIjDFdVx0AIDXuR4xDkZcEHeKnnrd4CWduBLZc8d0GK6X0oXXab12h4ir4u2VqOMnppenl5WyDZl+LFMomVC+30of9ZuRpfwbgstAQnn/qN5NLVWO9x7Sad0pHlKyb/+qeENfvFH4bf9Juhuy81BD/1qrBajQAW00Yo4pbPJMkc6gKmJ/DyiZwT60JkiId3YdWH7FZg7sJNF9sUv1xdw9kpXL8hIGy2gOEutNtSA3DwhCRBdjrQGQmYazbCMoK80qbiictXsuHNFkwWArwOOsLUzScigXS16MDTpmzPuhTg1uoI+FuvhNFbrQMbpwC0FIBbV7Cew+Qc1jNYnsOd1+D0CFaLDWAz4TNTe4z3JLDlmLsa79Z48faQP/+jn6eoHI30KiH3avy8GWXomjv5St/40P/iajCEXphrpL4Gc6h3S/1MaZpGgJfnOWmaRrZFAywUbHjvGY/HMchCO9J2dnaiJHG9XkepXL/fj2BFmbDtdMaLi4v4nm0Pm/qnptPpJfmeSg6n0ylacq1eQGXdlMlRf1aSJHjvOTg4AIhdaOqJe+qppyLbpcXaKift9XpcXFxE0KdJj8pyaVVAXddRSqismyYyKphULyEQlwXEbVSWUEHlYrGIIFclk9sl3GVZcu/ePQaDQZTOKqOl+0WLuHU+eh7ouQBED6AGj+gctsG/nhez2SyeC51Oh+l0GlldIG6n7vdOpxMBugJAPZ4KLr33nJ6extRTTQldrVaRJf4K0ly/fsNvYvJ1GEdIovSXgJmmRfpEwI5xet8+yB5NYKnqwFR5H5LcdMFQNxNswQbsRPAUQJL3UvK83oC7ZFXg2w1cI6FxVlINmuKVs4a6aUlK6XRLVo7GxJAuLVXHBlZREhpjGEtIuwT9O/yuYR+B/RGwsiXTU0BV1rggt4xpktsjyEllf6hMkHgHPxZ0b8kxjQIpCJGA8VJZXq/hIbBh5tIEk9cbBst7Kc4GfKshDEFg2ExV4zUwdYvdist2bsPSEY6bmhY1wVTnuH0OKyu47XuDLRbuIRedb5GwXlJx6HOwWZ4xIplTeWb0NSYRxMlbAxh+FD9n38DD4PH+MkvnETIq9Z48SShdYOgA7j6Am7cEaE3PhXVKGrB3ABdj+bvblhsDBLlhlgmTVgWwX3oBbe1OSKEsYL6A/q4AdWvki6osgoeuJV472wDbgmYunrt2AGHOCDPXagjAa7dDgmYmHrjaiSyy2ZYKAVtDGsBYUUqiZB1o6qwpe6AsYTkOOynMqazkfDRJ8NNVG5mlqwRoFmvxzpVL8fXNJrDOsVWF9R7l3SRYSW5OGE8In3rL5+VqfN3HC7cGlLXn80czXrw9fLenczWuxs/V+GMPedwDv/ed3vhQIKeSOA2fSNOUqqrY2dmJyZCaZrgNagaDAUVRcHFxwdHRUZQetlot9vb2IlDS987nc+q65saNGxHcpGkaPV6np6cMBgPOz8+5ffs2rVaL8XjM/v4+t27d4vz8nFu3bvHGG2+wXq9jMqIyfsvlkn6/z4c+9CEWiwVHR0eMRiPOzs74mZ/5mRiRr76zfr9/qTut2WxGid5oNIqhIVqWPZvNYsKjMmT6HgWeKjeEDQBU9lClim+VJM7nc05PT2MqpnbDdTqdS+mOzjl6vV4ENHVdR8/cxcUFp6enEVDp9ijzqHLQz3zmMyRJwrd927dRVVXsuHPORa/aNvjb9uet12u63S7NZjPWDGhRuXrudDlalaBAUIGrzkkBnvoT1fenVQ/bITAK3jQFtCxL9vb2WK1WsSNvZ2eHg4ODOCftIHzkhtsAL1PLhYItAxunckpD8GIFoGMl2c7HSHsgsGQgN6KNExAo5dg+gMNkA5acjx1o4qfb3N30rQyzKgTkrNaYRYJNLL6R0ViV+EZK3W3gMkvVTrGJI8lr2ndneGOo+03yvab49raCH7U3DoDEYCvpkMM5TC4x+b7V2EgtVQbm2HixVProQpoJkCyLuF02rzbSwuBNM6E+IcobQ12BQUAkIXFSjocwfdrpBsQwjwiNgofP1A6fJtK31pQoc9/IpE7BGChK3LArd/WVSQxAyOSlsIHOi29R/W916Hnb9rcp+FO2UlMmVdq5PbwX4KmATreh9Jgy/K3sXAxt2QKJYS4+3LSJ/Z5Jgq+qyL75sry83ipcNFcVV+OrHQoSDJdvU6jscnPzxgIZntwYSmspE6DZwByfwb0j/LqEiyMBPv2RgK3FEhbrEMu/Elml95L6aAPD1WzCKofaCvgqQoDKbAl7N4XNw0C9FNbOAa1e8Lwl0EtEtthoyL80hV4Luh1oByDXG4SeOAvztZSEL9cix8wM+FKiOYsK8pnotkHW3RxAUkN+DpMxjIZy3nlkOQ5h+FptYfiSVObrKijXUrcwnwI5FEuYTqAoSWpPClTUeONxMdRn6/Bc4bh3fez3mtwYtPjM/ekVkLsaP2+G9/736O+hYHzfe3/85bz3oUBOL/K3o/q1CyzLMvr9fpQjaiGzBnVYa5lOp/HiHojl4iol1ARHZWaA2NGm4E69Y2dnZ3S7XZxzTCYTqqri5OQkLtMYw+7ubozIv7i4oKoqjo+PGQ6HUZ45HA45OTkhz3POzs4i+BkO5ctAJZJ5nkdGTH1c274sDeNYr9exUDtJkghEVSKpkkhjTGQ2tdtNgYmuVxkvBUuakjmfz2m1Wkwmk+hFa7VaEWit1+sI8nSd9+7dY3d3NzJ9CrZVHqpMnTJcSZJw584dvuM7viMGtug+0HmplFbPDWVedT56XGezGTs7O1GaOR7LHVP1FeoxV/Cq26DhKXouKSOnKZjKJCrL2m63o+zXGBPBu/6tqZnbkk1lSB+l8VYfl5JBVlMVI5tm4vNWVW+ZjRcWMdAjpDSKn45NibgCQaNAwGPLOviq5DlTShGwdwJsRFbkNiEZIP41L6mSiXPYJMHbVkiwRNgyBZdOgEO6rKkb0vlmSic+tcAIbveo+SzdBG6kiZR01/XlWgCVVmovmwacZEECFUCfVwnkW9mhLRli7OsLoNBscKG8xG8lRiqwVPCTWLApniqymb7bCuA3yCP1mFkr3XPWyj6GDVtmzKYewPtNSiF8Mfumr63f5kry7fxzEZi9JVHSGGFBthhw7apTBgJ9DCKYUxCHd+LhAwEC23P1bsOCXo2f27F1DG1IU1wjN2lsVWBKucHVcw4++zlm/7e/BL/zt4vMMWnCyZH8PromYKbZFDDVGcDREVRrSXV0iZzr5HB8DN1EpI7NLpzMYdSFfkuCTpoDCS+pjPTVNZvChNlKzq/aQZHCwS4MOjDsifyx1Rbwt1zBbAqzmXyxTedy/hS51CTYJnSH8nkrAyNn2mAKqSxIvbCCZR0qDYyAOhKRXtcEiYKD6YUwclUlCZzHxzA+g/GE9PABVGsqHIn1FAYBcjUkXr4DgnaAKyT37o8Xbw/41P0J38/j7/ZUrsbV+DkdxpjfBvxBYNcY82Hgf/Te//vv9J6HAjlNWhyNRhE8bQdjqIRRu7u899y5c4f9/f1LaYsKlLYll0C8yFYWS0GQSuOUtcmyjMFggDGGyWTCer3m1q1b8XctEVegMZ/PAekcG41G/NJf+ks5PT3l9PSU4+NjPv/5z0ewkGUZt27dYrFYxGj9s7Mz6rpmMBjE/TCbzSJDpFLBvb29WHeg3XlPPPFE9KGph2w4HMbtUeCjHrLtoJDtJEgFcSovnU6nkW18/HH54tJ94r1nvV5z7do1hsMhq9WK+/fv8/GPf5zd3V2GwyG7u7us1+sIXJXZUvZQ+/4ePHjAtWvXACIA0nkvFouYYGmMYTqdMplMYon50dERN2/eZLFYMBwO6XQ6LBaLOEcF5tbaKNvUoJzZbMbJyUn00SnDOBwO6Xa7jEajyOxpCmmr1Yqpqgo68zzn+PiY2Wx2SRKrMlA9po/U8JAULpZ6x96zRMCILZ0Ecxg2wR7Ox7LqtwI5FxgevdZQL5v8IXJM44TRMWUtyzEJZqm+uCS+1icJZD5E/lcRYCkbZKZLqB3JcZA3OYfvtvGdJr6bbUJaSkfiIckd6SzHlCF8SDdBwRwIWGmlMTVT0ikD0KqDfDG81mXZxseWmCCLtFssWpBQOi71uHknrzehl87Uob/B+8vMlDECDEEYt235p0ods3QT9hG2w6wLWOf4fhezCDcXykrYt7zED7qyr7JU9qvKGQN4il1zCsy0ZiCwbxHsaWqneusAU7hNx1vojvOVOHt87cTHZi1UlbCAcFmCGVjAyMIpeKjrIE/bqsTx/jJos0ZeY68udH/2w8f/j0fHb0CEM2ACwEjXBc4aXKsBzrBqtgTE/PQn4Ht/g3jHklzYNGW4Ww0Y7Ekk/3wOvZ6UgBcWrh/A/RORNY76woxhJZp/J/gr13kAa2moBwCamRz7TgqPPyWdcLN5KBrvyzp2RvJZcwjbti7D/LLAmFUih6xS8a9VhTzeCCEpRQnTY2HkqrXUFDT6IrOsKpGQmuC9s4l02FXyeRRWjlBpsIDZBYzP4ewC60pc+F9iEUbPy+dKg08cWwfj6hR/V8cLt4b8i5e/YivR1bga3wjjPwE+Avwz731tjLn2pd7wUCCncf4aOqJdaGVZsru7Gy+6n3zySV555RUajQaj0ShK41QeqeyUSgCVWdLONE0ZtNbS7XbjezRS/uDgIKYZFkURQ1hUdrlYLCJAmU6nOOfY39+PPrNPfvKTJEnC/fv3WS6X7O7ucvfu3dhZN51Oo1TRGMN4PI6gQcGK9qwVRcH+/j5ATOZUwHZ2dhb9WCBAVZmp4XAYAeZyuaTb7UYPnfrdttMiFUQrg6TplrofNfBFaw7Uf3dxccHOzg7Xr1/ntddei0Drgx/8IIvFgvv37/PSSy/RbIphp67rmCbqnOPVV1+NYSjqN+x2u9HjNplMWC6XTKdTTk5OmE6ncc5aOA5EKa6ypQrYtZfQex+PYaPRwBgTGbj1es18Pmdvb+9SgExRFJfmpqzt8fFxvHFwenrKfD6PHj+VYGqthFZQPErDFht5pLAtIbUysC4K2GKvl+dSqbTcbJYLapdJaEdSOGHrCEAuxNebYNoHAYWm2gJzaYL2kBnnwFspuE4yTGnlgnKb5fE+FnbTFE+YX60wzUb0o6WLmnRZYteVJEOGIBKfSqCKdwEoVbX4yLR6oZ1h1hVJUcnVU2qDp68Gk24qAdjsC6MpdtseL91P1kPlgh8uABwttw6vjcybAjXnNt64RI+BuwS6AAFjThm98HxZ4XcGAkp7HenEK0phHzpt8c+FY0oR5IlaR6CySe1l8x5vt6SnzUyAYhoAd5ijgkLfyGQZq3zjbYPgXwtMmiZSguwDE/o/9XW1Pmc3rKcJwSokGxZOUy516PvKK2nl12Z8MXtvvMdWFa6RiYQYR5UkmLIiu3ef8s498b/t7Ii00iPnaJZAZcEGSWMrVBAkwI6DyTIUcWfgQm9b7uXvJCQo1ZU8XgIV4mNrNwTs9IYhLMULCGu1xf/W7m1VIJTy/rQh0s66gmq5kQyXS3mN9tF55DXLCTSNnMN1jVzGBJArKIxNMBHC2M1nAcQi75lfiKRyNsPMZ+GGjcMbJ6GayHKMr+Ke30Drq/FujxduDfgrP/YqtfMkD/MCX42r8Y059I66N8YkXNIJvf14x9RKlbBpf1ie5/R6vRh4oSBG4+STJIkR+eozU3ZJ4/wV5Gkwhcbga0Q9EP1Yi8WCyWQSS7f7/X5MnlQvm94xVoZwMBhwcXFBlmWsVqtYoq0hKqenp5FZ0mRJIDJt+rvKH+fzeWSttkvHNSXx5s2bzGazGGCi8+j3+5H9yrIs7sPttEqVXKp0U8uvdR7a96YeL2Wj1B+2zVIpY6r7u9PpcHp6Gr1o24XiWZbF8BmVRK7X6yiD/NZv/dYoQVV/XlmWjEajCJxUXtrv92M5utYTaIBMq9WKCZSDwSDKUpWJ032vEl4gJmEqOF8ul5FBbLfbUeJalmUEv3oeHh0dAcTjrctVYKj75lEayrKZQKJpymQcCizCRUkEeFJCsHmdNSLH1J631McUTFm2l+c1WMULq2fWwrD6LMEUG5nj9k+pKwhgrqoFiKQpvqoxSbjwtxaaTZFHBrmidU4SMWsvwC21ki5ZO1wjFblhksTAE1PVUsYLQWZp8Q0b+umsfJsZg1mVkR3zZpMAKQmVIbSlrHFNYewu+dysiQElMZHSGGHlQNa5DerUY6fgMTJUWwEpW/vK1E48fiF90kxmUkdQVbj5AptYqShIk837q0ouhAHaLQHsZS1ASQFaYNlMWUXA5JWFsAmm08IvlphuRxjbosQ0MnmNsZs5b+qNI4PmA7PmXbUly1QhWWPzet1HVbVZZllFOayva4yxV11yP4dj8wnf4uYsci54eazGR3Y1dTkur8k87OA4/uG/Tf3LfhV8z/fC+AiGBxJYMhrA3Xsiob55G+ZjKIKkutGDxzLYWUBeC3BarqQAvDOEroWGg3kijF70coap1sBkJsvZH0oJeactYI6mALpFLkmWSTPcVUIYNBdCfzIvlQnrBeRL8brlhfz0a3DtEKrShxwgE8BqauI5rhULkws4O4akHx4v4M4rcHSMmU5IVhMqHMZ6UiPYktAjl8YaAjb+OE/8Qx+6Gl/f8eLtIauy5rXTOe+51n+3p3M1rsbP5fjTSAfdc8A/DX+/43jH1EqVQ6rsT+V48/k8AhcNvUiSJMoNO51OvOB+8OBBjOFX6d7FxUUEKVmW0Ww28d6zXC5jR91isaDb7caLeu999FgBUYJ4dnYWL+SNMazXa3q9HnmeR1mg954HDx5EUKpAS2WTKnNUlquua7rdLicnJ9GX573nxo0bscxcAdZisWB/f5+iKDg9PY2gaLlcxn2pALfb7TKZTOh0OtEjp/1w0+k0+gzVR6f7GYihJxpCo6/V7dFtmUwmFEVBnudcu3aNqqo4PDxksVjw+OOP8+lPfzp2vum+Uq/fgwcPePDgAd1uN3bXKRCrqioCpaOjoxgqMh6PYxDOdgm8dr5pQfqdO3ciK6dyWF3//v5+9F4ul0vW6zWnp1J6r6/brsNIkiT64ZSpUwa1LEueeeYZdnd3I3jUsnBlPx+l4ZPAyqUmsm7bKZYSvS8XErZCgibCNZ1Pt5g8t1XUXXts6fFpuGtfeXwWZI61wxa1eNSyhDTIDalcDMfwIcrfFFUsyxbGyQcGKFyouxoaGX65xvS70G5Sj4RF1g46gp/OLCpcv40J7JopRSpZDZoyhzp4WxLxoZm8gDrBJyFYwci8tsu+lVGMUf6KU6zUCNj5aiN/dG4D4NSrlqWb7jZlGxvax+Zj4bWxG3Y0hqZs+/V0GYndMHNJAss1vnb403N8UeLLAr9c4SYzbLe96Z/bGqaqMescX5aYXhfKivr4BNNo8Bc/9SNY4L+8/2s5XvX53EtPYWqDT7zI37xhcGPGR26/yqvf08VN1/hwg+rvvvITZEaO2/c88YuxnY7Ix6oqBqP4oth45EDmV69lm7IUX4Ty86qS4vgtCapI2ays7wrI/SzHl9DvaaCRESiReQHhHkNlMnxqcN5zWsGNn/kky/4O41uPw63b0M2hmsG9C+jvAHN49Qvik0taEkRSe3jPDZErvvoy+FrY+trDqBUAUwLDoUg2Sy+BIjevB3+chdNz6O1AqynhJYUTAFaegU/F05bXkAHtTMDcZCJAznqggszK33UCp4cim8RCYyByy3UuQI9UwJ6rYG8HyuCDq0ph47yF9q74AidncKHeuDPpu8NTU2Hx4ePYwOjnGE9NgGxWJcwm3ETzVyDuXRo3hy12uw0+dW96BeSuxs+38Smkb24fOAU+8KXe8FAgt1wuY2z+arWK/iaVQWpnWFEUDIdD1ut1DNDQ2PrxeByBXrPZvMS4afrgYrGIISVaIaBsioIrleqpl2w7QVPnpzI+DehQFkvTG3WeyrApENCAEGXCNNhDWSeVVGoQizEGa20EWNuSR01Q1P2ynRC5u7vLeDyO+1UZKa1v0GUogNV9AFzaFvXXJUkSu+eACFi73W5kw5QVPD4+jgEl3/zN38zZ2Rnz+RztalOwrvv59PSU0WhEWZZMJhN6vR7j8ZjZbMZqtWI2m0U2U+fYaDRioMve3h7tdjsCWK0M0JTP+XweEy71vQpGla1cr9dMJhOyLIs3BrrdbiwBV+nseDyOHk09ho1Gg9lsFgNQsixjsVjwxBNPfLUfrK/d8HKdgQt3d+2GDbOlgCfvwWqXWwRx9pJvziWSYudCRYFxHgLBIrUEW8vTMJTE4toZOLB1tYnSh8h4xYj/RoYvK4yX0m7xbqUSzd1p4dtyLE3tIuCylcPkVWC1LCavMI0UUznsMpfAlNRupHhZGi9STVXLpuY1JnFUjebW3ORSSmoYDIbgT3OE+oTAsAVvmTcGo0ybcyJ11Mh/EMbNGJmHziXISzfyRhtCVtwXx/r7sL9n4eZNmmxYClfjqwo7kBsbMXjEedxqgW23wn50wnLOFwKUEos7G+NXK/7rL/w4/6/zX8Ife+M38an7N6nWGTZz2MJGhsADWJi9MeTvj1/kl/zdV/lDNz9Ky1Ssfcqni4on05ymSfFVha9r/GotgNILOIsgTtMzt7vm3i7AZKsGJCZZ1k78S1fjZzE27Jv/osfDUDZZwYRHzvVETghvoMxSitWa+s078PGPw+4BLBdh0Q2RPlZOSsBXucgbs0zObw0eyoKUMkuh1ZLzNEuESUssdJrhJlBF9KB5L11zlRPAlmbhZosLX1iVPOecAK2UeLOIOnjkfAUukydsJutzwVtXA4TPWOkk8MS78J56w5qVNSyXklDrvDCAkzMYn0jASr6EupB+PhOYN28B+e6zuMDG6c0j2eNvd2Suxtd3GGN44daAT92b8Bs/fPvdns7VuBo/l+OvAb/be39sjPkW4M8Av+ad3vCOHjntJrPWRkB2/fr1yJJp6XZZlvF1Z2dnMVxCL641AOTmzZuXOtI0PbEsy8iW7O7u0ul0IjumckBlhoAY/HF0dBTljMpo6UW8As7pdEqe5zHoQoFbr9eLoRjD4TCCKQUnn/3sZyO4UNZMWar1eh275iaTCR/+8IdjRYKWUu/s7DAYDKLUMEkSbty4QafTiRH8w+EwsoYK7jT+X4GhBoO0223yPI9yQ90eBcNJksTi6/l8HhnOZrPJ3t5eDCu5du0azzzzDBcXF9y/fz+WZC8Wi+iZ29nZYTabUVUVn/vc56Kk8u7du3H9AP1+n/l8TqfTietXtlErKoC4LJBOPQWq6pk7Pz+P0laVnmqSZ1EUHB4eRsml7j/1Rs5mM5bLZWSKtd5Cg2/U46fM7yM3jKRP2tpHYGY8ku5YSH+RSAsD66aAjvC6kGxpMNLttr1oLyDGpSYWi3tjsM6Bl5vdrpUJ+PJeQFFZC9BRpmjbi2UtvpNJwXUtLA3e47ttSau04JoprpmQrCvsIhfmqxTWx7WaUneQWcxiJeAwDVJD7WnLEnwrjSXlPhNZYzrL8aE/zhti+InPEpyxMp86BLMX1YZ5s4HdSxO5AKuERYzSNOc2qZTa5RbCYNBqAedkjirL3AqPoaplG4tS2IeyEr9gty1AOMuwgwF+vZbvL2v4oc/9U37LE9+JsYZ/8JmP8j1PfzsmSTBpSn1xIbJF7/jvXv8X/IPF+/nR+Qf46IP3cPraLj7xmMLibIimD9f8ycriMo/P5EB//O7j/Oni13OzPeVma8IwXfKRzud5JlvzV9/8cXZtSts0+PXPf0QqEpZLbKuFy3Mwln909+MsXcFvevzbZV9lDQlKCeNHXv4JQNg9H1IufWUwaSag8Gr8HI63EfBZYY6Nc8H6FWh7H/xnNoV2i5OigDfehPEcvvO74NzCqoLrj8PpGLBw8Di8/JKcd802tBNYLQQUpamsPk2hm0pVQNKWc70G+n1hvs5PYDGFrCFevP4whKIsoTkMGUoWfCYMnw/+tTwHapF02lRYtrqU7SitgLekBcMbMJmLD69YQaMddkn4PJvGxv+WpMIguhDkoqXn58dwcg/OD+HiDKo13kvNemplH7oAEBPvMJJJG1UC1C6aVfwVG/eujxduDfnpO+N3expX42r8XI8/APwNY8xfA/63wPd9qTc8FMjpxbKCB+1YUxmjgqb1es3+/n7sS1NA1Gg0ODk5YbFYAES/VJqm7O7ucn5+HqV1GtLhvefs7OyS/05BQbfbjSyaslXKzmikvXOObrfL4eFhZJy2vV6LxYIbN26Q53lMlmy1WlHa99JLL/H444+TpinPPvtsZOQODw9jYMZkMqHZbEYp487ODicnJ7TbbXZ2dtjZ2Yn1CioJ1VqBa9eusb+/z+uvvx69hZryWFUVN27ciGxZs9lkMBjEfam+wLqumc1mnJ2dRYCpckwg1gHkec5oNIrs4XK55Pz8nE984hMMBgOeeeYZ9vf3Y0AJEFmv6XTKP//n/zxWROhd94uLi7gOEBDZ6/Xw3kcWTn1o3nsODw+ZTCZRrroN0DVAJUkS5vM5i8UC51xMQd3d3eXWrVt0u10ef/xxhsMh7XY7hu+8+uqrnJyckGUZ4/GYi4sLHnvsMa5fvx6logr6tKvvkS8q1rvstccGCSSAbwqLFZMqtwCcdswpM2drHxMwjSd2yKkEUHvbvDHQSXHGYL2nbmdSR5BXwoYlNjJWYr0NQCsx+H4nXJNpKTZgLS611C258It9dq0GZCmu09wKHzH4dhPfaeIaKW5XJI52VcocZ8LckyahTsFurF2VwyRy598buetvNRxhax8CGz+ZDRLJshJgpkA1CSEqDslHqJyANPWgqS+tdvgUIKRPBimrT5OwjsBgrXO56EvTyLrJghxuseR/efMn+C1PfCff/82/lmRQ83/96R/h04Xh//fKv+DvLq4zSpb8w8kH+WDnLj94/xfzh179fsbrNrWznNwdSYOEM1t+Sg8ZeOOpRzXNfo5zhiTxjHpLUutwGOa1fF7/1uRbGCYrWrbkva37HCQz/u+f+UdcTxrhMDsslpKapZPvk7915ycpqWmZlNp77tYlT6YNls6TmYS/88a/ovaejm3wa25/GF8W/IN7P/XVfgKuxtZ4R/9VXW8FcBiRBeKoa7nhYPCk6yl13cCXK3z1AP7mD8H3fx888wwcPQDTlsTJ6ULAEiWUC1iUAo7SVPrnKg/jMRwfSfqkbYFrQDGVjjqD9LO1b4Q+txraQ6kQqCqRaNqW3EQZn8BwR5adZFCvJOwksZJC2e6Ez6AThtsEVnx1IR65ooB1Db4QwGfWAu6MC5EARtjFopA5pV3IpzA9g3svw+mDUJK+jHJg66qgmBTmzfoyAjUHMh8NNwr//4j/l+QXxHjx9oD/8SffINanXI2r8Q08jDG/duvPfwz8BeCPIAmW/+Cd3vuO0kq9iFdJpF6QqyeuDhc86t9SWeT2Y41GIwZzqHxvuVxe6iiaTCYMBoOYYqlySpURauw/EH1YGvih0sAkSeh2uwyHQ8bjMcYY5vN5ZOxUFqpx/9bamMoIAjSffvrp6O1SYLlYLCI4mk6nAJckkOpH086zTqcTmSZNlFQgocBX5Zr379/n/PycRqPBjRs3Ivs2Go1ot9tRUqjyRO18032g+0sZJ92ObUmh+v3SNGU2m9HpdKIMNk1Tut1u/CLUNNFOp8Px8TFlWbK/v89oNGI6nUbpqG6f7sftgm5l3rRnT48VEEHtW7901+t1BLZ6zLX6Ymdnh2eeeSYCPpWnKkjM8zyWvK9WK46Pj2Ni5cnJSdxX+/v78fg9SkOCNTYsG95vfG2J3Xi4VFZoTUxf3K4lME4CA7wBo8uqfOydk8Jvg0tDaIj3EgySWAkSKeuN5yk8rzJCo+yWPp9aAXSJxSRuSzZlNwBOZZsQmDN5zhQVphS/iSZN+oalyixpYrHrMgIrFMDZsE4DJtXIfSPMmz4fZJXx0jfsN1O7KI3y7eYmDVJZTe1kq7fe4/zG9xVCTuJynMOEcj/tfsN7fJ5jms3olTNltSnG9iL9+r6nvotk0IU05f/503+PP/zmr+dX7H6WPz99lqatyF2KNY7/z71vY5Y3WawbVFVCuU7D+gw+9bhGAK2psKg0a7rDNb1WTllbEutpJjXXWzOatiIzNas6o52U3M13uNW8YFa3Gdkla2+Z+5IMQ9PIeiT70FF6x7lzrH1C3+a8XA6ZuV1a5pAM6NuUcDZRe8cP3/0YmUkoH/UbJt8QYxssfKn9KfJnj5V+ObV9WgKnZEkq6Hzhk6z/7eOUtYPbj4tnzQV5br0W31vSlMCQKvji0sCIpS1h29KWgLdGBqYj/XIYOHhMSsZrJ+f9YiZTMzbcZVIwpFpv5IZJWQqoI7BvKPsl0nCqwNCtlvLlljRCd9wK6kKeb2ayTGekzqCsw3vF+8lqLkEvkzNYTITRs8J6G/XFebth+EJHX9iAcEPGb2SsV+ORGC/eGjJbV9w5X/HE3qPXEXs1rsZXOL71LX//NTb+uK8OyDWbTc7Ozi6FWGjoybZsUn1eKrfTi/XZbMZ6vb6UUpimaWTzlP0py5LBYBCZIPW6aR3A2dlZBIS6fCAuW4NR1AN2//59Dg8Pmc1mHB8fc3Z2RpZlMcCj1WpF6aX62NQTl2UZs9mMsizZ29tjMBhQ1zWr1YrT09PImHU6HU5OpMNktVoxHo9jeIkyfU8//TQggLCqKubzORcXFzGkRBm8PM8jgNEQmMFgEOsbdJt7vR7L5ZKqquKyLy4uIut3cHAQpZGz2Yxms0lRFLTb7XiMGo0GL7zwAvP5nAcPHnB6espkMokBIvfv3+fWrVvs7OzE8vfRaESSJAyHw8hqArFPcBuYpmlKnucR3GqaprWWwWAQ/XyaaqnHuSzLCLK1yHswGNDv96N011rL0dERn/zkJ1mtVpycnEQQrDLKqqrodrsxkEZllYvFgldfffWRBHLiVTObwI4grVTlUQRtSQhkEwuHsF4+XBD5zXsjC6SJlSEExXhP3UmxEsmGXVcky5Jy1BIGcF5E0BgZJ+s3QCkxEl3vCHJEizch0bIODB5EgFkMMhpO1mvqCptX+Ib0w5nKSeF3KqmUdTMR4GqNSD2Dx06BnthqnAQlWk1glO2KyZN6x1wrBUJ4ic9SkYqCpPKp/8uYTXCKMo9b9QrxOWuD78ZvlqPLCEOlhD7P5XWdzoZ9NAbSlD/+hU+w9hk3kikvFTf5va98H3cuRvzM4S3KIuXxgzFlneC8Ybpusl5nuDohSWt8bTFNh68s1GBHJW6VYho1NnP0u2uGbblp0kgMu60lvSzn+e4h47LLvG6SmRrnDbvZgtNSblaNkiVdU3LhKlrGUVOSYCjxnNWGiWvyUnGTn5o/yY/ff4bEetpZya+++Vk+3Hmdb22eYcWwRElN6R1926Bpsq/ik3A1vqKxlZgqzJ18KVhc9LU66R7BYki8oX3/NeqP/STVqsD/un9PpIw2FQ9aXQorZtIQ6hH8oHklAMmmIplMGptKjrQrbJpNYa8rDFi9lvctpiLTbLQQHXe4gZJkIZ1SZMkUlXgqnd3cTKkdFHUIRAlSymINpgUmg7SGZS5ATqsJXKhPKQKrXnkovKRcLi5gfAizcwlHqYrAHFby/WQgRIGySWvlKwDSV+PdGE/sdug3Uz51f3IF5K7GN/zw3v9XX+17Hwrk1LulDJCyPhom0uv1mM/nMX5eY+qVOQHi65VNU4+TyiXVC9Vut1mtVgwGg+i1U2ZGQZa1NgaJaMmzplNqX9tsNqPb7UbmsCiKCACNMbTbbWazWZRnasqlbqdG2StLp8tRdlGj8LW8XIHbdgecBqncuXOHuq65ceNGZJjUB6br0gAU9QFq0qemU2o9gDJ6uj0a6qEJkMvlMoJl9eKp7LTf73N6ehpDWjRcRQHjyy+/zLd8y7fQbDbp9yX9SVlIrTRQv1ur1YpBI7rvut1uBPTa+aZyXL0BoEEuKqvUoUBPu96UrdN9pCD14uIinhP37t2jKIooxVQP4nZSqoJrZQe3Ey0ftaEBJhG8RXbNCHgLj1+SDAbvm6nEpO8yYatsubmP7AwRTLjUYMsAspSJKmtIjMg3QwjINiO1ATICZnwq6ZVakK1x3B4DmcU1Q59auB6ytQBUu6pi+qVZlbKMUmoHZB6OpBbJ5/bczHbYhgO7LnAd6aiLVQFftDP9xgfn/YYxCwmV6mkjC+sJMePebDrbNjvZRDbOp8kGLJfV5ljo/KpK4v7TNCZX4iQF0mQZOM/fOv/FfG56TRgTDGcLufDY6y2Z5w0OJ32SxJFakcd5J0xGXVtMGkCc9UJYFAlYj0k8aVqzXDe4OZgyzVs004pOWtBOygjiFlUTazzXm1PurUcAPNWSVNgaQylpO2R4Zt7TMvCZ4iaJcfzE5Dk+dvg401mbJK1ZZhlvrPYYJituJFN2bUFmYOlrOsaw9hUpyZcuvrkaP4tx+VyVIhI5F2sSAXNGzjPrEnxmKJqO42WX3id+mtGd1xg3O/DBb5GC7mYKrZH0ti1PoAhAvM7FU+YTWWezKYBvcgarCTz+LMxmApw6A2HY6hLcGmxnk8o6m4qvrt2W9bUH4o3LHSRdqSKol/L6ogj+Nkl9FaCWireuzOVvG74oW22RYi5qSc6sjbCH5VQ8fhcP4O7n4PQOHL8Bk0MwTXlNldMIJFzpZS+GpBbg7UHcFZx7tIa1hveHwJNf+8Gb7/Z0rsbV+FkNY8z/w3v/B40x/5bN140BvPf+297pve8orVSJnUbsa+CIlnZvh48oyxImFAGHLqPX62GtjbH9Gm6iXrfVasUHPvAByrLkwYMH7O7ucnZ2xsXFBe12G+cc/X4/gh71YmVZxs7ODlmWcffuXU5PTyM4UBDUbrcjg6TAUiWH3nuOj49jR5kyPJ1OJ4ai7O3tMZ1OY/3BtiRxd3f3UreZdtsdHh7ivSdNU/r9/qWSbJU35nkeWTYFZ4PBINYxqJdMAUir1Yr7WpMrjTGX9kuWZezt7cVlaLz/crmk3W5z9+5dWq1WDIPZ2dnhs5/9LI899lhM5tRUSd1+F9Lpqqqi1Wrx5JNPRpCkIHMymcSqCZVKKnhWkKnni75320Oox1O9bd1ul2vXrpEkSWSHP/vZz7JYLFgsFvR6PYbDYdxmYwytVisym4vFInoLlf17FIctlUmC7Z449Xs4LckOTFNMrtweelHnAzPlIVEwlmyVixtIKoctKghR+j4T+aJrZ9ilxM97BVFJ8KdUNXYmYMgbI0DIBhBYi8wxneUSPOIstnakM2GtTC7dcLQb4keZLmG1hn43lFcjoS6hXNrHeoJa5u1CCmYjjX9jRdqJcZjF+lIATARkxmxYQr3Lr6OqN945YwScpYkANv2pZeCw8cioxHX7d2UE9bW1w6/XG58dQFnxyncnnP9P8h20WDWpqoRms6SZVhyeD3DeYK2j0agpy4S6tALYdCF12L7EY7Ma7w3WetLUsV5n3LkY0UgrKmc5os9TvXNqLM5bxkUbazyLqsG0bNFJC+Z1i4u6w0EyY2hruQ5GDu25S7ioO3xmeYt/+tJ78ZXFzlLKpqNsOH7cPcMnuzd5/foeHxl8nr5d0bdrGjiGtiRJCq44ua/l+KIvgK1HnKQwhu8CZz2J89g1lMMWxdLDdMnuP/u7TIs11dPvhaffA70m0IAC6XBbL+S8v/YkPLgvEkhjoNsRIJUkMJ0Ka4aVBEwC6Eq74olbrgXUJR1h7moLk0UIMUH65ZwhXoasCiB89sqlgLEYMJQHJYIXDx6ppDUVSfD65eJ9TdYwP4HpMRy9CSeviaxycSHzqsHUjowKb1RCKYhOSgXCvoyM59vt76vxqIwXbw351P1HT2lzNX7hDGPMi8BfRgTdc+C3Ab8O+MPACkmgvGOM+QDwV5Dopz/lvf/R7eV47/9g+PlWieWXHA8Fcp1Oh/F4HHvhNKhCfV5ArAhQP9i2Zw6E2dGYeb0g19CJ3d1dZrMZ9+7dI89zbty4wXQ6xRhDs9lkuVzGgAz1Zhlj2N3dZTKZRAan1+vFUJOTk5PYpaayw3a7HV+7Xq9xzjEajSKYUVCnDONsJtp+TVWcTqeRKbx27VoszdYwFgUe2pGmjJQCWfUMKkNWVVUsQ1dWqaqqKCHUCgQFcRoeo/tC9/O2V3HrRIgdbbo9ChS1yLyqqliPoDLPs7MzXn31VXZ3d0nTlNdff529vb0IiFXuunXixkoG3V4FqkBM2dS5qaRyu5dQ2U4FcpraqTJaBc69Xo/j42Pu37/PG2+8wenpaTwf0zRlOBzGYwuSpDkejzk6OopSUGWEd3d3v9LPx9d8+MBgQfCxGcRPphUCEDxegf364mu4Te+cCcsKHjvSzd8+lfoBlSJSOShKkoVcoJnKSQx/kMrhEBat3vLOacl1WW/61IwRGVTYGFvWmzAV43G9Bm7UCjYZD66FSRNcv4VPLMmqxDWCzFLljsg5hndybVhrKflG0mgqJx65hrD+4nkJ7FsMjQksow0mOoCy3oTehPMCYzDNJsZpSqX65tyGYfMek28xuprm6T2m0RAZZ1XhV2v5OwDTWKfQbArItY66kgTNskz4whvXaXQLqCx1lbCqEsGKlYXKYGqVzyJsXAnOJthGTZUnVEv5zC2doWwkOGc4p8OyzHh2mDItW0zzFpWznEx6eGdIUse15pyddMHj/gyH7Ic8EKo/nT/GX3r5uxmf9DHLBFsZbGHEk+lk3y6LjM/NrnNS9GgnJWd5l/f1j/iu3ucZ2fHDT/ir8TUeG0bJ6P+HdEtjHHViKfOS1p3XSF/6FL6Gur8TfGaJAK4qlMgnBhodedyVwVdqxEuHlZJwF/72OZsvslS+X/JSfjZbAg5N8MRVRpbpjUguMfJFWBSbbsN8LRLIJGjJjQtySCPLpCXvqRJh7yon4SosYXYCF4dwdg8mp7Cch4CjNtZXWF9jjacEnDHgjarVt/bg1fhGGC/eHvB3fvreVeDJ1Xg3x+e8998JYIz5L4HfBPzHSEjJtwJ/Cvj9SI3A7wGOgH8IXAJyxpg/y0O+frz3f/ydJvBQIDefz2MqoEoklVHTC/WwgsiwKQhRr5QChzzPI8MFRA/XZDJhNpuxt7cXgYkmTx4dHUWAoHI7TUvUZEP1Ri2XS/I8j8mZeZ5Hr5u+TpkjLSGv65qbN2/GZE6VcirA0WoEXb+GrigIUQZIQ1o0HVFTJtfrdXxsMBhEOSBsglqUhVIfmlYAKLhRwKIyVyAmUKrUUENOlPHS4BXdZg1IUampdvjpOs7Pz2m327Hnr9frReCWJAnT6TTuA00G1X2rjKcyqspo6jbAhn1Tf6RzLqZ66nmj61e5ptZOqDzy/v37nJ2dRU+cnmfKDGu9gXrplEHUigw9pqPR6J0+C+/KUPC2CdhQBo7NXWEFaBBDTeQ1wtK51EbA4BODjQyceN1cw4rnrHRRbmlCX5opgr+rkWLqEM5hLaRBRqlgpgpsu3ObFElN0YQNO6UgLt2SRiYG7yCZl8KmtTJhy6wRtm2bOfMy5wgeE2HAjKbKeb8JXtEQEy0tx2BIoawExFW1zH2LkfPKzPngpVFPjAmgVasJdH86J8uCDQu3vc3aO6cPJUnwD6XhIhV85fmhT/4I3/RP/yPSAMCSZk110SLplzQaFcsyiYusV8nlq0oPxhm88Ri7AVNUFlNYfLvGrRMqK/vP1YZ1kXG06rMs5fvhbNqlmDcw85SyVXP32oi9xpyymbJwsv8bxnGn7pHgmC9a2GYNs1SsQ0nwTFpPq1HSaRakxtG0NbOyxd3ZCOcNiXHcSH6KPa7G13OETzU+JP8Y/cJwRqxjxpGdj6nbLfJORj6vGf3bn6Dx4B5TAP9dsLcL3Tac5NAayHm8nAmAytoC2HInHXEJArgKJ2tvZQLcGhl02vK7TwQQlosgB5CAEfwSWUC4/Oj05HtvNQe89MjlRdioQr5HGo0AEA3kTemmc+HGTV7CcgqrM1g/gOO7cHYID16B+ULAo8vAVzTdmoSKlYXaCDC03gdF+FbISbw3ts12bn0RX41HYrx4e8jZouBomnNj2Hq3p3M1fgEO7/22Z6cDvAl82ntfAD9hjPlvwnM3vfcvAxhjzowx+9770633/vBXO4eHAjntMlPQAMRAkHa7HcGOyuJWqxWdTidK8BTA5XnO2dlZZO6ACJjUa6Z+L01M1At5lW8uFgueeeaZeMdF5ZL7+/scHh5GT1ar1eLs7Cx6pzToYz6fc3BwEJmonZ2duE4NHUmSJHbgab/bfD6Pskpln4AIQtrtNteuXWO9XjMcDqN08uDggJdeeonlchlrEBRo6e/KUllr4zw1FMV7H19z69atGAijKZpauj4cDiOwU+nkNmg5ODiI+321WsX9NJlMOD4+5uTkBGMMTz75JGmaMp1OY2rn+fn5peASBZ7acwdEeaYyaXmeR6+dvl7nq+eScy7KNtUzqOmUaZpy9+5d7t27FxnLXq/HYrHg6OiIs7MzQOS0ymAqkFfPpAaaaE2BMqsHBwdf7Wfkaz60Q04Ay0YGaZz4zCR50kvpd+1x2wmSnkvsnT5WN22sK/AJpIsAxAqHna0xRYnvtiMQ8tZgNI1SmThj8M0Mo9JUI4mZPknkhnomy7e5pxq1sHmNqQIgW5WYusa1GiSBPTN5hW838M1M0imNoe41Ywecbr8PElNTOemnI7CUpQsR/G4LONYy10RkkcrAafn3JYlkVW1CF4wFH0Bs7TAU+BKoncgkQ4WAcU4Kuq3d9Elt++mCF06KtAMLVztMt4XPC9x0ii8KPvLxHwAQz5sBXxtMuyJrVHhvcEWCzWrqIoQ2pALYfTMUHs8TfOaFoasMbpHFcmSzEhBYVwFgJ56J6zKdtfGTBteePqMqU9KzjGRlAMunJ89w7wNDPvzeN1j7jJYpqTG8Ulznr7/2S9kbzTn6wr6sG3CJx3QqkszRapTUAfyd5R3uzkZUteVT92/yyvk+zWcqftHP2afjanw5Q3k4Qx0TLA0Oa50wVy6lyjy2KEiLkqrVYJZ7Gof32f/7P8T53VdwT7wPnngfPP8CLMaSANnZgf3HhH2bjqHfE4lk4aSXzYQbF64WOWYuPlZ6fVivQ4dkAGHWSkDJYF/mVBtoJEApYC21ArpAEjLLpfjZmm1o9KBMZD3VTABdtYZyBicvwewY5qdw9hqcn4p8O3fyutph65wmNd44CmuorbCGxnsSoOZynYPu1SvY9miPZ/a7tDLLp+5NroDc1fhaj8eMMT8Yfv8h7/0P6RPGmF8F/NdACfwdYFvvq7K5bcp4AuwCEch57z+6vTJjzB/23v/5L2diDwVyWsI9Ho8jm6ZMiJZva3CJBllooMZ2CqFevGtoidYEaCl2WZbRT7a7uxvleP1+P6ZIqhRSGajFYhFli0dHRzE1UcuwlYnR8I5ms8nh4SHdbpdutxv715SVGo1GkQlUEHRxcUGz2Yz+NJ27+tQ08GU7oETlljrUu6XzVYCpTNR24ItKE5WZVOmismcqW9z2m+lrNVxGQShsZK/a7af7Qesa1us1p6enpGkag1Z6vV5k+LbBm0pP9Rgok6iAXdk3ZexUGpplGaPRKM6/3W5zdHQUzyOVvip7qOtrtVqxs26xWDCbzWIhvf7Trr1taanuewXCelxUtqn78FEbLpFuMOl6Cw8mEnbijbJ2m1LvCNpUD+SJIM9UEn6izB4Q2CwBR7asQ3+aRto7CZu3wf+mHW1JIkDNGsgRKWXtJBhB0yOt+O/qbgMTZJvWSR2BycVvZ4tq4ykD8bRZC2mC62TYosalVhiEwOiRab+bi8Eu4pUhpvMB4O0mfOQtssqNbzCsW1li5zeJkonKKN1GTulqvKs3l3L6XueFbdtevvdbrGMCWbjQtAm+LCHP8XnO37zzL/lF//hbSNoVvjb4SsCUSR3rcQsyB6XBVSkkgXF1QMOJJ6g2+K7Ewatlx64tPoA9gk3JqOfIeagsrlnT2F9xdDTEzFKyXM8fSFaG8y/s8upT1+glcoNtYFc8KEY8MRhzbz7ENx12nkjWhfXY1JNmNc2kZl2lVN6yKFp0spL70yHGehLrOC77X/mH4Gr8HI3LIMREJOLw3gbOyWHritokEu64mtN+9fMUsyXl+bncEOm0NtUCeGHahkNJkIQgu2zIDREc5EsJMPFIPcG2h7QqpSYgzeR9dSEplQ7x0lkrq0mbQT5JqEUI1QdJF5KBfDe4dUgnqQXEze7B7BDGD2B6AuMzWCwlbbPy2KqQ1FxqMI7aGGpMqCvZMG4bEPfFe/MKzD26I00s77sx4FP3J/zKD1x/t6dzNX5+j7ve++9/uye89/8E+LAx5o8D3w0Mtp7WdLYtoz4j4PxLrO97gT//5UzsoVe23nsmk0kEW/pPmRRNalytVkwmkwisptMpq9UK5xzj8TgydKenp9y6dSsmL65Wq0uAT6WHWkWgrM22Z0wZpevXr2OtZTwe8+DBA5Ikod/vxwJyBSXr9Tr2iykjpR49jeZXid7Ozg7tdjuCOmW7nHNxu5Xd2d/fj6BL5ZD7+/tx2+q65vnnn48ddlmWRWACRCngdqCJ1jEAcf8ul0vKsoy+PZU3KiOq7JaCMS3k1uf0OIKAuKOjo7gsZbi++Zu/Ocb2j8djVqsVN27ciImVugxl9vr9fnxc2TvtlFOAqD48lVUq2NUaCA2k0bTLt3bQGWNYrVZRFqreRg3KUUC9WCwude1tB76kacrOzk5MSNXUzUdueI91gLJvCZfTJevAzGhoiQNjvYClRHrhRIoo/jJjQ7/cVlG4LR2mlJCTWHqtKY6oFy6sP0uiJ881ROJnAzNlVoW8riHrlQl6qk5KNi9xqQSlJLOFeM1AGLPlWtiwNMU3Q7fcKscWJW7Qxpah8qB2MZjEZwk0M+m9C3NW1u5SYl8rLC+X8u9Y0L0lB6Wq8Qq4vMPnUm2CNZCmIscMz2EMJk1FgllV8tj2DYDt6oEgATXb51UdWNBcbp784N1/xX/+4JeDM9SzMNfS4q3fSEqtBiwQvHA++Ig8sd9KN1lllnYD5n3i43KNBwqDrQx+ZahmKa0LSzF0GCcnhLfSR2dzw1/97HfyBz7wL8hdxivVNV5o3+XTs5vcv7MnsryWk3m1atKsotPKaaUlrVRumpS1HOfd4YLaWYzx9JL8S531V+PneGzgm94FCH97PakcprK4FDCetCjwjQ5lklCmcO3+HezhA8pXPospcvwHvwVuPgFlITdImm0YXYcvvCQArtmEfp9YBj4eS/CJTYNc2QUfqRFmri5EktlqSQecI/jwGnIVYhNotINEOoE6BdcOdQdtMCNwcwGEeQlZDusjGH9O2Ljze1I2vsolsKUEipykWmOpsMYJOae1DM5hwwfLRebNfNGevDyuIN2jOF68PeDTV4EnV+NdGsaYpvde/6M3ARrAB4wxDcQj94nw3KEx5jnEI7f7Flnl242/9+XO4aFAbrVaURRFZLWGwyGdTieGl7TbbR48eBDBhXrkHjx4QKfT4e7du9y/fz/6wowxPPPMMxGYKNOiMsXpdMr169dj+bQmOu7v70fJnFYfKLD4whe+EH1px8fHHB4e0m63uX37Nm+++SZPPfUUjUaDw8PDKMtUgAjE3jYFdcoGnZyc8OKLL0ZgoqXlmlapIFFfqwmR6/Wa+XzOiy++GJm37cCTi4uLCGC1263dbpPneQSOKk/c3d3l9ddfjyXqOjRExXsfAZ0+r6yT+udUsqnhMOfn5zFc5uTkhCeffJLhcBiXoQBXGdJt/1+WZZFVHQzkZkOe59EnOJ/PIyDf9ullWcZ8Po/VA1mW0ev18N5Hr+RsNru0jVpjod2A2lGoyaLKGuo+Vy+jPqbl7Gma0mw2YyiK9vI9UsOEe8LbfjN87H8DYkG42QIwxgm7ZKwRBs5JUp1LbAw6Mc4L+7KuBMxV4m/zHfGamlpCS6R3ig2Is2YDBlODLZwwcpn0wHlrsJXDZZaq3yApHS5LMM5j81IAyjZzlaUimSpLTJYKCKlrTFFiOk18kE9K+rcX5skYfENqFbw3mLwWP1+Qd6q80qehEy5LBQdZK2xgZC2NrCuEofg0xbi31FA0Qsai85hGJmCOCm81hr0Wpi4vRHZpjPRfqdxSqxtAOuVqkWNSlvx342/iR195XmRkxmNyYR9MZSToxnpJp1TqNRFQTvDB6evlD/DGowE2dm1wWQDrRZDgVmYL9InfsOz50D/oI7h3qWDEskz47OIme9mC47zP3/7h30o5ks4+bzymW2EST6td0GmW7HUWNJKa1NScr7usypR1kdFplnQbBa205KTofXWfhavxVQ895EYyK+OjgZfDYEmSUqotyKiaCc16ja+hKFJO+gN8UWPnC/Z//O8w/fhHWY+uwwvfAt/+K2C/Axi4eSBpk6UBs4KGF7nlY++D08NNGuxoV26ElLVUE6wXEmDiHQx2wzkOdEZgm+H8XwANME3IutAoxS9XlLA6kdqD6TGcfQ5OPgXrqSz3zpswz0UKmq8x1ZLEl2RUODzOyMev2r4fTk1w921jtzjMFWj7hhkv3hryzz778rs9javxC3f8KmPMH0O+0U6AHwg/Pwqsgd8VXvcngL+BSC3/i4ctzBjz74RfPx5+L4FXvfdHD3vPQ4GcBlnohXFd17GwWwMltGNOy6ZVppimaWRRTk9PY5R8WZaxi+z4+DiGU6i3SwNJVIaobKACL/VhrddrxuMxr776KqPRiPV6HZkm9dqpNFQBaavViv4zIAIX7TvT34EYopGmKaPRKM5Ri7G1S817z+HhIdZajo+PL81Z36/v0xAPZZVUGqneuG3A1u12o/dQWUhlwbIsY7VaRU9ev9+/5B1TYKospvoR1XO23Zun+7rdbjMejy/VIZRlGdNEu91uLA7X46rv1X2qQTDKnNV1zXw+f1swCERvnSZgahVBOJEjQ6cBLFmWxZ4+fa+yw/p+BdTqL9R5aFjLtgzzURneIBJFBTEQ0w6jP67aeOCM8xtCKoSZJHm9qSXQixINlXThwr9yoQtuAxg9xJv3rpFsKg627kWb2oufLSRW+iADpXK4brZhDw1S+p1ayJrC/JWVeMissFxoKmUS5mGt1Bc4J7LE4M8jMIJA6NGTQIIYcmIJoQ66Dw0mMXhSmb8PHXIaCvJWOWQDYe0a2SZV0tqNDk0lYd4Hdk79b1xejr7W+w2gM1Y63ozB1Y5/fPR+6YTLHBRWWLHAsPmmk2447YirgkzNGUxh8BkhFdCHkD/xyPlEfpraQOaxRQB+iY8yWm8hyaFuQevUUHWkS9Cn4DJleT2J8fyLN5+lKhOSz3VFHrmwVMMam1tc25A2wvevdeS1fEetfMZk1WKxlDROHVlSs6qvygfejbGRAb4VhMjf8TiZGls5Kq9wpcasV4DBpYZ52qJeLUiKO9i6pJxO4ebj8MTTcPA4NPrClPkFdPckrCTtQa8GV8nNiM5I0FPt5TKkFVItUxsYthRIYIl8Dm2GfLCT8L5CAkzKOVRTmN6FybHIJ49fhcl9AYbrEiarkJBZklQLLCXG1Dg8lZL4b9kXJuytSHb7bf7Nxa/SKzj36I8Xbw+5P1lzNs/Z6zXf7elcjV9gw3v/w3xxUMnfDP+2X/cZ4Lu+jEX+EUR6+VPALwJmQNcY86Pe+z/zdm94KJDbBiMKHpQxOjw8jECu2+1Gr9ru7i4XFxcxsbLf78cYe73gVoZOkyL1AlsvzJW92d3dpdVqMZlMYuhIv9/HOceDBw948803AQFdOh9jDBcXF9y+fZvBYECWZYzH40u+Nk2RnE6nXLt2jTzPY5CIAtVOp8PJyQl7e3uRAdRuNpVf3r17l7IsowwxSRJmsxlZlvHgwQPSNKWqKg4ODqjrmkajETviNE1SZYjqBRwMBhHAaYXAZDKJBdxA9PFpSXlZltE3p2EoIPLMZrNJXdcsl0sODw958OAB5+fnrFbic8iyLAK0+Xwe++NU8qn/0jTl8ccfjx1z6rvTcBaQcJFtwK2ATwGs1g1okqiCMmVUFUAqk6fb1+v16PV6EdzqeaLJlAo4rbXRc6fHWMF6p9OJ4PmRGxszluAId/nSwVahLHsLjNjSxch+YWlMeK2TfjVAO+VsUWPXFcZ76lZDgKHWBTQVPJkYjCK9cPLTGGEB7Wwd1w2Id03rB0DSMMMcNIUyKdbC/AVJph90N74Z7/Et6ZWTFMxM5pAlkhAZysh1rsZ5CSbYSsw0CqaUYkqtePrKTTBLDB9RGakxmCzdSC5DMEkcwQ8X/XR1LSDOWEjApElIsaw34NAYyCTpkjTFJImEnCyn/A+vfZTv+V9/r4SQAHZlBXQBtoaiY4Rx84TtDWDOgakNtgz71AYpZaLH1WBKAf/pQuS4eLClwVYivQRwqYC8uo08XkPdFLBnDAJojad4o4ctDFVbnvMJpLPgVZpkVMuUqleyutuHnYJWp6DIM1xlYC6gbZmlrFo17BIka1fj6zm+9Debx3kLRhItTQ3OJArxMEUBSYLPUpZpg6SYY/MVdrXEnp3gr93Cj98Pz387DK9Dpw/5CmyQPtYIi2Y8NIyAPZeI1NgCzRpwYF1g80IAynIeWLxEHvfC3LNawewUynPIT+Ho8wLiZheSSLlaSV3BqoBlDnWFdQWpX0kTCVD5jTnlrWzbJRLOb57ZBm9XZ/E3xnjueo/UGj59f8q/8/yjG2p2Na7Glzu8978MwMhF698BfgXwr5EKgy8aDwVy2iEWFhaZDb3YVv+Z957XXnuNXq8XQylUqjifz2MAxsXFRWRvFDC12+24LAUTWvKswRpaCzCdTmOxd7/f58aNGzHy/vr16xwfH0evV5ZlUV6or9GExP39/cj4KMBQH5U+piyg+vK2/XnD4ZDT01Nms1msBNAExZ2dnViqrczTdmiIAkmdy3bht4KXbQZNA2S2mc/tsnIF19sSTWUX1WemMsr79+8znU4Zj8cxFETnMJvN2C4jn0wmkdXSZEqtbVBv2sXFRZRiVlUVZZLqQ1OmTeWwQEyRVNmp+gl1KNOn8lOVR2q3HBD3gZ5L6ktUIL/NwinD+dbQl0dqeGJdACCyxnCVYcvAxNUeUhPTKfUfXhIsvQ1dcl7uI6u/zhZOJJWhVNs1rMgkfVy1vHaLzfOJ3YCpym2FJcgwtRdglqXYvA7v9UG2GJIlnXTSeWM2F5hVLZ4ZlUMqfgo1BQo+Lq3LswmBSQxe5bfKGiqDWwcBWQweER+s2fp6i3LP8Nn4IkatqgOjFv52l4+JMQEMVpVsV7N52S8XV+TB1dIlB6yLDL8WlkGBWd1x+NxiVxZTBd9aCqQb1i2mxzcEjHkPNGuu/dOMo+9y0ABXC5hzDU+yFqbUZWALsKV8BpNcAJzLggPIBWYuEY9cedEirTbnnPGQrrYPghHlaJ3h+xXUhtV5WzruvDCHGk7hDcxXTRrp5UqGq/G1Hxtp5eXf9TmvqTje4r2lpiahBi++sdo2sHVNWq2pqoLaG+qsCa0h7dUZ7o1z8tc+jfnH/wv+4Bm48Sx88BdBmUN3JH1ugz2RTbb3hBLOnegZTSKfE1dLrQCBcSuXsLqA/EgCUfwKFmewOJcSbzeD/ByWZ3D4GkxyyC2YnoC/1VTKvzFkFGSUmHRDBFYVsm48WjOi+8RdgmlBxszmNVcg7htnNNOE56/3+dT9yRWQuxo/H8ZtY8yz3vtXgGeBG957b4xZPewN79gjp0mS+reyOxr3fnx8DMDNmzcZDAasVqsoRZzNZpycnETmTaV9Kp/TqgENv1iv11G+aa2N4SDKwmnapC6v2+3yxBNPREnk3t4e4/E4sloqfVRPmbIxCvI0yVDlh+12G2NMlGgqkFRZXlVVNJtNRqMRzWaTXq8Xg0YUCClAVfC3Wq04Ozu7xHx1u90o8VM/oG6feueUATXGxDCPqqpi0bkCNd1O9e1pkMt6vWYymUQg9/LLL3N6esrrr78eu9kODg7icdmWO2rSpDJqFxcXdDqdGExSVVUEqtty0Rs3blySMFZVFcvTdf/pnBUQqgR0uVxGaaWeH9776LvcPmbaq7dd56D7R9nN0WgUmTmVcyrIfdRG3bLYWfWWlElh52ztAlMlcfrJusInNoSRBLYmeNi8NaSrkrrTEA9bKb4tk0t3m2umsXB7W0WkgRvyx4bVi8mYHmHWKreRFtoQyx9KuoUxFDbOtVKSRY7PEkmsLCtMUQrzlaX4RobxFtfMLnv+Sq0FMLitfeETI6BBfWiOTeqkQ9RYwTeHMdiyDCxZijcCzqQHzgS5ZQB79YZFxLnoc/NaP2ANJm1u/G/G4KsaX5TyXRLYXq0nADDBu2laLUy7zQ98068n/wsZBBmkD+rNZGklkkLJ06ColGMfJJMWkVcmjrrnMOuE5LTB+YuSWCkSSgF9ycqQ5CK5tKWwd3UzyFKtoW56fAJJbsgWhFRSQ/Mc6klKOfBR7okTsOcSj60NthDAV7cMZh08i0HOqR2I6LYUlvW88SWjuK7Gz/W4LKp8q+XLICyU23rUsmUjxeNdiQ8eSkmUdOBKWE/JPdDsQLOLn06xk0PM6hx7+jl8s41rD3A7T8Dt98BwJCEotRdERSJBKZThrgywzjdUWL6GfA51LpLM8V2YnEu1gauloDxpQLUP1VxYwOUZiZ9hXA7kgMEYJ9P2RDkl8WbPNix7e4hmtvbf1fjGG1eBJ1fj59H43wH/rTHmAAlG+QPGmBT4kw97w0OB3OHhITs7O1Fe2e/3KYqCJ554IgZovPrqq4CkMGoy4Wg0YjKZcHZ2xnw+v5TWuF6vY5AJEJml+XweL7bruubk5CQCGg31UJCgLJRzLjJI4/GY09NTnnrqqegZazab3Lhxg9PTU6y1MaBjMpmwu7tLr9djuVzGWP08zyNg0BCP8XhMt9uNzGGWZbFrTkFEr9eLgOP69euxzw02YHixWNBoNCIo0ud3d3fZ29uL61wul5c65pSVUomkc47JZMJ0OmV3dzf6CoHIhCnY0sTRxWIRAz80LVQBm/eei4uLeIw1vdN7z+npaQRaKolVAK+MoXMuhsQ8+eSTtNttsiyL9Q/tdjt68raTK7fBmJbF63y0SkIZR+99vHkAXOr0U2Cm82y1WhEkKuunQSzj8fjSufiojIvnEoavQrpymMqTFFJBUDct+Y5IIdunpcT0N5MgYySGkZhKvHQus7hWRtVNMZUjWW9YEddIcJklycXr5VMbpZdAjPiXEm2HQYJBsAafWOp2JsmRlcOupVbAJyaCOJzDN1JsrqmYYKtyI1vMhZk1aSJ30kEYtloBXPAuJkiaXMkmFVO9ad5uLsoU0KU6T7/pvdvu2EuD38YFz5wybfq8glhl1up60yG3XkOWSY2ACa8rhdH1IVkzvhekakClnM7z2T/zFNlJipvVAs5Ks7HgeZEv2tIEKaP8ZGWoG8KW+dRLwmDiMesEUq85MNg8yCqXBpcK+5asoW6GS/hMUik9SEUBYCoJOKk6XhjcEvJdwEH3rqFuQjEA4+QfKXgrYTmmNpD76L2rmkHSqoxpDclakjjrdUY+vfLIPUpjG9xtHnkrcyffOy5iwvBZqQqcMZc9ZHUhzJoWfWdtuJjC4gJ6XakuqMNJZBLphKPeyJxX4sfDGJFRVivwFTRSmI1hMYfJVFjypCG1BHWGXa0x+QpTzEjMHE8d8ya9UexocCq5/jIEp2+3P67GN9548faQv/7jr73b07gaV+NnPbz3P22M+T7gFnBvKxHzJx72nocCOU0WXK/X7O7uRlnieDzm7t27vPzyyzz22GPxon9/fx+QWHtlQjRCXi+ylWVRiZ2mUWqQhwI9LRbXi3gt5+50OpRlGb1qIMBFwYmCmOFwyHQ6jRH0ygZNJpMI/jQdUhmbfr8fwZTKIJWd2+6t04TO5XJJv9+nqqoIxAaDAf1+P9YGbIetaP9do9GIUlL1GKqkUkvW1+t1DGjRYA8gRvorG6WMoHoSgViI7ZyL7KVG749Go9gvp+BQX6v/tj1sevybzWb08ykrux0moh7H3d3dCLJOTk6iDPPo6EhP0Ng9qMtW6aSCeCDWWrTb7Rg8o71xek5ozYJ6ApXp09cocNV59/v9RxLI5bue9djSKSW+w5cGg6cYJCxuJngLrfOKupeRrMX/Jayaeq2cJFU6T91KREpZewFkYX/6xMYESlNK7L3RCLdtHZEyYeFckt46J+9PNj12PjHSERdAHNZiy61UySyRgAMbet6SRHROxsT+OVl+WKAlzNkHBs5JeInZMIMR7OA3ssxteaTKT73bgCv3Npdm6q1TNm7bI6cjMGzUAfyxWZ5JbPTefZHn0tVAgruY8MzTR7xa3RD5pAOfBjljSJeUGoHwsyYwdsGjlso+8am/VClgXEilDGDLW2K4iWvIT+NERWYrg0sFiHnA1gafboCX8Qi4LMMuTQMgK2S5tjCBttH3qHTTkywt6SqkbgZWUNZlSBcCUq/G13P4d/hLhnvLs9tCQ4/4Gj36karic9Y5HAbcGoo1xte4RhdaXerUSt1AVcPpm3D6BWHLs0ROwqQBJMK6JVa8pI02VAVygsvNE7JUOuaaTWjugm9B1oN8AvMZrMdQLWhQklKR2BqXQunkn0E+ks4bWY/XFNltMPdwsPblwr2r8eiOF24NeP1syXRdMmhd3Ui6Gt+4wxjzA8AfAl4GnjPG/EXv/f/wTu95KJCbTqc8//zzHB0dxfCNxWLBxz72Mc7Pz2MJ+HK5ZG9vDxCgcf/+/Sjx03AK/V0vrNM05datW1y/fp27d+/ivY+gSkFbXdcRJA0GAy4uLmg0GrEOod/vM5lMWCwWsXNtOzlTmR0FQufn55FdU5medqM1m824nMFgEINCdnZ2LqUjlmUZu9gUsCmjpFH/Kp1UoAjEtMh2u81isaDdbkep5nakvjEm7h/1nW3vQw1i0dROZa6MMezu7kbv2Hq95ujoKPb46bFptVrcunUrbpuGrGjAjPr0VJq4zaI1m03u3bvHfD5nuVzGIBGVpQ6HQ1544QX6/X4sUv/c5z5HkiSxWxDET6gATANpjo6O6Ha7zGazKAdVwKideuoBVI/mtv9RWVsFrXmec/fuXdI0jcezKIoIzB+lUT+25myYUX02pXXuSLoJSeE4fyGhfH5JnSfM3pOSXVhu/ivECxU63/BBFhWAkK2chJTUUgOA91SjDj612NLFVElTB1aPTaiIqV3scfOYWFVgQgiLvEakmlrW7U2CsVYAHAGMuVrurEMMJPG9jrw+3Vzhm8AYGh9ApwLLysjFYBX8dbXfAnrhNdtVDepr099BwJn3mHprncqibQPKqt4whFvySQVyPnESYGI2F7wSamLEAxfCUgzgswZ+vcavpvzAp1/hT3/mPZGxAtl/tg77GjCF/O3SAIQykUXa2l+6Dm2eJuQ7LvQBmsB2hs1NQ0BOJSAt7tsaTElkAWOxfA1p8LS5TJZjS6g6GwDnrbB7SXh93ZTnnO7GNITQlLIMQY/ENE6fCpi7Go/WeCfflw3uMA0BMf6twE+ltwZPAkUOZYHxTtJjbSJAzHSg1Za6AdMIibQGeulmGQSJtioebRG8c04SKIs7mLoicQWpq0hMhTUVPvM476kcrL2EYxLmWnk2N4h8uHPxlvjet8pNt8cVE/eNP95/c4Ax8Jn7U77jmb13ezpX42r8bMYfAH6J974yxmTAjwFfHZDTC+CzszPa7Tar1YpXXnmF69ev8/73vz92cmVZxuuvv87BwUG8YL527Vr0culrtkNEOp1OTHlUtknLxJXNm8/nGGMYDocYYyIDlyQJy+WSs7MzdnZ2Ym/Z3t5eZOcajQaTyYTr16/jvY8+NS2NVj+fzkW9cSr1VLmgAgZNTFSgqCEaWgquQEuDStI0jf14+j71cc3n8xheslqtuLi4wBgT0z9V/qgVB3mes1qtYnKjMnDKjuny1Ou3XC5jGInOdTwec35+zsXFBaPRCCAWpYMkYap/T5k9lWpuh4RoaqWyrBpu0ul02N3dpdPpxPOiqio+9KEPRYZwOp0yGo2oqoqTkxNGoxGDwYB2u02z2bwU4KJhKyqRvX//Ps652DuoJezaH6ehMNsJljpn7R8cj8dx2x6lkWY19dAzfd6wnFnaRyIPzJ/KSYBmtyAvLcWu5+LZjNHLJUnucKkRGaaSRZmUehsDyTLHN9KYaokFl1iSNZjSSYl47SJTZ/ym3sBn4Yq9rnEdifM3ZS0XQt7j280N6LIGZwzp0sUOOuPC69dF9N/5diOCLbMUlYABfJIEgKXyqMAC6WOW0H9mJEBE/ZNhLpeYta3XXaoH2D7m3gs7qH+WZUy4jN44V8vFoPNycZmmIrGM7GES5JfJZt3eAzV+nfP33vhJfvurv4b5UQ9TifQRNkyYbCeQgAtslnEC0nwiF7utE0vrzLO4JSApm8tyTCBKpNQ5sG8ekV3awPBVW/xCUMRFIBeuq42CwS2Q57INw+casi4THk/EhkS6gKoL6ToAvDy8tgaTB1avuKzCuxqP8pC7BZv/h8v8lKY7bh6zeLx3Wx60CryUaztjYQ3WexKSGFbkbBKXZb303HkvNyysr+R7BYdzNb4qMa7CuhqPozYeb32UTjov0Ew/3nYz1a2fbw/NrgDbz9/RaaQ8e9Dj01dA7mr8/Bh9YBx+fsn/oj4UyD377LPMZjOee+65CELe97738dxzz3F6esrZ2Rk3b96MIRivvPIKnU6H0WgUg0TyPCfP8yhJXK/XLJfLyPiojE8ZKE28vHbtGq1WizRNowRRQd9kMmE0GsVETGXllN1ZrVacnJyQZRkXFxf0er3or1sulzFhUoGPMndaBq6ATxk/7z2j0ShG6Xc6HfI8jzH8KqvUJEwgsmgaxNHpdKKPq9lsRnnktjSwqqoIbPTvg4MDyrKM+8o5x3g8Jk1TDg4OePDgQfT3vfnmmyRJEkGbMo55nvPRj36UPM9573vfy2g04uDggMPDw1gergC62+0CxJRSIBaG37lzJ/r/lDHNsix2/jUaDfb39+l2u5HB6HQ6LBaL6K00xnB+fh4DcdQXNxwOmc/nMbBFfXBZlnF+fs5HPvIRtLPv4uKC9XrNz/zMz7C3txfDYvQ8a7fbkcnU9Wl65qOYWpllNWlaU1+rMddhdrOBbdRkiaPbzqmcpe6VGOOZfWuJN226R47muMJUHptX4BNsUUjYSCaySZ8loB1vDpKqll66xGKLOrAqUoqrcf8EdsxnFlqhYD30vpk6RP8bLwXeicGuJcHRpzbKKgHMOuxnH7xpRSKgLbX4VrapD3hLHxypjaybcTWkFlPWgUXcAmf6Gu8FdGnKJoj8UeWSdS3gKUmC9kpkoFLaHWSnYZ44j8/rS0AP56Eo8caKvy+EnMjKw/7KC9xiCXXN33jln/HvfvJ3cf8LB6SLIKlMhDlDgZZHqgy8yBdtyICogzRSgkvg7Ftqft23/Az/4DMv0Hi9RVL7GJhCKhe2Im2UXSDBJuAbPuy/8HzcSOmU0xbk7aASTQzVZahHrkqEMNFlNOaepBTAVjfNRoYZmL3UeVy68QJejXdrfDH/9PBDIudSElg4H1/rt4SJmxPJGqeZOHiTgq8wvsZWNQ6DKdckqwlNiHWQLrDLBmF6PRtQlobFeyOCThcmYJC/FZeZoJiWZQXNb2QOt26o+O2t/3K2/2r8fBkv3hrw6XuTd3saV+Nq/GzHnwR+xBhjkftW//mXesNDgdxkMqHX62GMIc9zXnzxxdj1NZvNGI1GjMfjGPW+XC65ffs2r732WvSUaby/MkwaQDGbzSKo293d5ZOf/CTz+Zwnn3wyyhjVV7derzk7O4tMUqPR4OBAImZnsxndbjcGipRlGS/WFUwpg6TrPTk5uRTMov609XqNMYZbt27hvef8/JydnR2Wy2WULyojptUJWlGgwR1aTK1ySw3oSJIk+v4UoGjdwrYvTnvVlMXq9/vRJ6a+O+1LU4bu8PCQyWTCeDy+BKq89/ztv/232d/f5/nnn780j9lsRq/X4+TkJD6epmlMFdWevfl8zsHBAVmWcXJyEmWfWgWg+0mlnMoO9vv9yE7qslqtFsYY9vb2SNM0+hSBCLY1OEb7+zqdDgcHB/HYXL9+nSRJODk54UMf+hBVVfHSSy9x9+5djo6O4lxAvJPL5TJ27K1Wq0eyENw5Q5I4jHHUtWVnb0ZZJ2RJzXLdxDlD1qhw4WJ7+k0Fs1XC7k9ndA8tzbF0xWElrCRbFAGwBflg8JoJGyXnvWsIE2ZWFcY6vE02kr8AaurWBrAY54PnDXw7kyuqAKzM5Y2JYEvj/n1DfmpRt1CGQCXMnQ/HRL1xWDCrQl5XGtmucusyzIdgk9ptAkyMiRJLnwTfTe02ssnUi1zSBzBXVSH0JOT41XKVaJLg7TFW+q7Cc8aaGIZCXQs7t950603/Ny9w9O3wkf/pmzE1NAo2vrEa8AbXlG2whe5oYbZMtQFd3huqnmd105H0S37H3r/kR8YfxlaSOFk3kSAUswXCwv+pIyjuJrsF5LaG5rZEVq8i6j9dQvTUQWDxnKHsCeu2uGnisk24mt/4JgXMtWaOunFFyb274yuELd5/kQBRQVgV5JBC7Pvwt76svORCwxg8niosyik4TDOoBZYZVVhuL0dJcxsY/a2HNejSGFVMWuQLRBfiN7+Gueg9nfoKvf2CGi/eHvKDH7vzbk/jalyNn9Xw3v8z4Dv0b2PMHwX++Tu956FAzjnH2dlZTCM8Ozvj/9/en0dblt1ngeD322e48/ymePEiIlOpTKUyNaSUFrZsa2GBsGTZGDBuU9jY4F4LM1OUcQGLWrC66Wbowr3a1WVmCiiMgbKhTYMsS9UecHmUSKVsJMtIOSiGFy/eeOf5nLN3/7H373fOjVSkhJxSRqT2t9Zb7717zz1333Puizjf/b7f9+3t7YkitlwuMZvNUK/XUSqVhECxJY7DJzgQg1W99XotUfts27u7D43tg9PpFOPxGLPZDN1uVxS18XgsZdlEJIobEzQOSlksFhvEhgM6is/PkfVMxNjex0EjaZqKEsWWykajIRH73KPGiharUUxquIialUtW6DhQhJMnWTVicuNOIOI4lm46tl3yvCIHxXDMPx+39XqN559/HgcHB7hy5QpKpZKco2I4CPfmcYE3z5gBkN8XiwUWi4VULCwWC5RKJTk2rVZL5uUWi8XGseEkUC6V5/cHK4FsMQWsvZPnC/m+Vqslx4zDWZbL5UaxutYanU5Hzhe/p7gagQNiWJm7H5FlCkoZxFGKQLF1yXaHKWUQBBrGBIjiFOk6gIkJ0ysBgnWAeEQ28CSKnNLmZsuUgg65qoDVFjf7FjjVREF64ExgO+AAOOLl1DhjrJVSIe9M08iDShyMu49ncSjNLKmKnLJH+b6KNkxEsPtnZpKaXO0ybpGclW4KV2ZMyvi2TFvlEPm2RmuQUhuplEY+1t84AVaJU2QvFANlPwfjC0uuewjsbKCo70Sgchnnb7FBLMq1W6g1ISvbK1AOIwnm5CyMNhTEBpwUVDV34JK6wX/41h/Ct/+n78OFriGc2foA2w9HQs5EgXP2NU6UZPsmb8PnS664TU7weG1yNAoqH4ecsCWTA0zIuHk6cgqf+25TMW05uaRnejxgKHwwY7AxJ1egTHc9okinciKoneJmgEJo0MtTTDLG/hNj+E+UOBzV/p/O0t1dz5o/O0GRednn8Hjt4on9Jp4/nWKxzlCJ778PbT08vki8F8D/8+U2uCeR6/V6ePHFFzGbzaC1lovq2WwmKhQrb9VqFfV6XYJGlssljo+PEccxDg4OcP36dVHmeIZpOp2iVqthOBxie3tbwi04JZOJCwetGGOwu7uLbrcrPWkXFxdCBDjJkNM2udcNsPNenU4H1WoVx8fHcoHP1kutNer1ugSpsBK5Xq8lzZJJIO+HqwTq9Tp6vZ6QtTRN8fzzzwuhm0wmQmRYpQQg1kROWAzDcKOInNfIyhLbQJmUjEYjHB4e4uzsTEJSLi4uMJlMcHh4iPF4jNe97nXIskxmAtlOqrXGbDaTc6G1xng8lsRHJnscIsP2Tg45WS6XePLJJ1Eul/Hwww9Da42rV6+i1+shiiIcHR1hZ2cH+/v7QrZZ2UySBJPJREgVF3rz7COQK4er1UrKwHmdYRji6tWrUnnxxBNPII5jfM3XfA1u3rwpgTT8unnO8/j4GDdv3vyi/5K+VMgyhSjKoJSGIoPFOgKRgTGEMLSXUut16MgcQYUGWWawbmsMHieUxhEqqxSUZFDjBUwU5nNucCSJ7Mfj5CoFhCiRDU4B4HxOCsYRPQBWHUvhCrzdxVKmXeCcS740BrRO85m8FYAgsN1xpciVhGdWRdOU2y8dUaNVChOFTgm8a4aRb9soTFebSpxTEJG5kJIgyK2T5Kygq1VBisqkIgBRbOfdotgqcc4ObQNg3HZhKGs2aQoKQ7v/JIVJU9z4o2+wtsI5kNZs5xplm9ZFtXLKgrYqXbhALiQE9sdo7rZ9+wSfWO3jP73zH+Ed/+j7pXmBA05sWbglg7pUsFjiLiM9k0iTWx1zK6XZKADPy+DsDazE2aJyY8+byUmiDgvP6V4nOQUwqReZoccrg5daJb9UsJ8JED4XHXq5CeOcphnZVvZgvsDZZP5Agpj3FUySmn/PiRzd9eANRdq/B7/i8KbLLcShwv/0M8/hL77vDS9NFfbweI3inkROKSWzbBxLPxwORXHjeTG2z3FPW6lUQq/Xw/n5uUTEh2Eo+2Aiw4mOTLqm06nE4/M8HM+vcc8Y2we3trYwGo1EJeK5M7Y0KqVEReNKAlajmPhxFD3b/tj6x2mTcRxLeAgrTt1uF6VSSfrhVqsVut2uxPmzYsfhJ0zMOJGSQ0L4Hxi2Z7KaWKlU5HizKjWZTKRPjq2tbI/kigVO1ByPx7i4uMDZ2RkODg7Emtrv9yW0hclUkdhxEiafDz5XrA6ORiNZp9Ya3W4Xu7u7ODg4wEMPPSQpoKyWFpM779y5I2orh7+MRiPp6uPi8ePjY1Fxeb6vXq9vKLVcfF4ul6WWgq2uXNLOgS5c1B7HsdQi3I+KnCVo9uckC6CUhtbKCVIklkr5mQwo0DDlDGmoML4SojQIEYzXMGVLnLJKhGCRQK01dCnMr2qIrJ2xFOZKnFPp3JNIiiQAa7lU7sqKCZj0pyG3NCol99sXRZIWadMm2eIYWDVOuZw8IiAMCjUEKlfZ7roSI83zfoV6AaUkoVIeq3NLJTl7J0iB4sgSMBXa+8MAFEf2+zqB0SRF3zI/N52BggAmjoAksSRuvgBiV/y9vwsTAlnFFXBrQMd2lk2tbZKkrbNyt3GSZApLhp2VUa2BYGWw2CGspiX8zPAJ/NPDr8vJGCBF3Cawx94E+aU2uRkiuY5217qkSa6+WYEluSB2+73Lgsn1W6zG5ZIINh4ju3Dbsi2Tyb/Hgwj3bw3wxVFHJmy517J45z2fj+83cG0gVDBsmuKbT8u2n/PpYXhMzuMrEM1yhL//h57G9/3IxxAo4Ae+0ZM5jwcHRPTjeOk/XwTgzZ/vsfckcqVSCbVaDdPpdEMd4tCPYi9cGIbY29uTeTRWsgaDAZRS2N/fx3Q6lVCQfr+PLMtQr9clTTBNU+lP4+TDLMtkJi4IAnQ6HYzHY3Q6Hezt7eHTn/40hsMharWa2C45MIWti61WSxRAVsR4XopLx6fTKXZ2dkQx5FoADm/hUBYmDp1OB+fn58iyDEdHR5KayJUEWZZhtVqhVquJklav13FxcbERmz8ajYQkVioVdDodUcVYNeNUR07xBCCx+p1OB9PpVErCZ7MZbty4IaT0+PgY9XpdKgl4xm06ncp+mLBnWYaLiwuZUWRix2sF7Hxiu93GW9/6VrznPe/BQw89hJ2dHQCQxNJiH98zzzyDNE3R6XSwv78vShwTZ+4Z5JoBtsiy2srvEU4GvXr1KrrdLm7evCkElOcVi8foypUrQuZ5hvLy5ct4/PHH/6v+sL4csDNyBlnm5te0ApHZ4Ej537a1DiE0yGINExqM3pbBBBVUT0soX6QoXSwRjpc2kIRTJJ2ixSXbxL4n5MTMqmZcFp7fJ2mWQuRMrti5rjoTBHI/3H2mXAItV0LWADjiZaCSxJK5QOUkD8iVMl5jUXUrdMoVDl6u2oWh3b8xwHJly8yNAQUBqGyJK/H9xf/ciz1ykoCpAL2GWScwKgWt16ByCcapehRFMI0abn3bJaQVI2mSJgQocTZEZxFTThVjUmdCgBbOVkk2FTKtAmQISUvj0s4Q//Hn32JLvlNOkzT5Pt0In3GBKZS4GoPAWjkl2r1AtIxyNxVeqqRpals3wNZJExTsmylt7k/mlPLb7k6otIQTHg8kzOf46eWRE76CemY+1xb3+r14O0vHn399d+/FkzcPAPiGN+zgH3730/i+f/4xEAh//hsf82TO40HBD3yxD7wnkRsMBhKqUQwNCcMQ7XYbQRBgNpvJH0kURdjd3cV0OsX5+TmWyyWuXr2KnZ0dfOQjH8FqtZJYfA7sGA6HksDIRdVMIOr1usxs1Wo1NBoNqRE4OTlBo9FAvV7H9evXMZlMJAGSUy6ZUDIRYyIXx7GkWvZ6PWRZhnK5jBdffBFBEKDX62G5XCLLMpRKJVHueMaL1aarV6/KnOBoNBJ74mAwQLVaxdbWlgR/MLHjhEm2kWZZhlarJQokkxMuyW61Wjg/P98gcazIVatVSaqM41hSP9kGW7RssnLJxzdNU1G72BpbDGApHk8m2dw9d/nyZXzd130dnnrqKZm94xk7Trv85Cc/iePjY2xvb+Py5csyBxlFkZBbDnfpdrvo9/t48sknJeXUGINHHnlE6iE4FIbVR14PEUlAymKxwN7eHrIsgzFGyt955q7b7Uqq6P0MIoNQaWSGYIydnWOSp5RBkgZOlTM2as4A06saq45C5TRGM1ao3pxY9QqOgJGbgSsSNLZcyn9yBUKlnSVTkQtR4UEsSIccGWNJm85tmO4F2Pk3s9nPBgA6DqFmLiSkGsKksO9rJnOuaBvGlp5TUrg9KKh+MqunRR0zoQtwSTNQyc7EEs/MrtegMMyJX3jXP3vFOTouA1cBKApF/TPrBFgn0MsVaDrD0Z/9KlHhwjlBR5AuOGtptGRNR3YbcvNz5MiZSiG2yGANVE80SkPCxXQPEcf1sdLGoqjbLwCoFUmFgI7y42+C/LFZbHLyZixZzGIj5E65VApdwiYxI9clWFDqmHiScWvncaXi9XdRqfN4BfFq/btVOLn3wBe2MnOPn++17ed+E91rNff/v+oeX058wxt28A++52n8sX/+MQDwZM7jSwoiehrAD8FaBk4AfBeAbwPw5wAsAPxhY8wtInoCwD+ETWv6K8aYny7uxxhz44tdwz2JHBOWZrOJ+XyO0WgEwAZ9hGEoagrPsJXLZfR6PZydnYkVrqiQsMVuvV5vBH+wLW+xWOD8/FzUKO5lC4JAAjJYseGwgWq1in6/L4XVnE7IIR5sa9RaS/BJlmXSOcekiIkBk4AkSTAYDGTejxMVWXUCgJ2dHVlLlmUYjUYyyzefz4VMsZIHQFTC8XgsdkZWo7rdLra2toRsaa3FJkpEoojy3BdH7HOKJMf5Mzll0spddxyEwmSGrZudTgcAZDaPZ+CMMWKn5HVzeMrBwYGQziiKRBEs2jL39/clqZQVSVYf+QOBLMugtUaj0ZDAGSbWly5dEisqb8tBOdyhxwSZZyn5fJ6cnACABMjw+5Rn/+4nWOVNQXFKoiEQGSQyK2dVO56bA/LLHOVm6HTJINUay22FaBYgHpREhRPFzUX0i0URcB1y+Vps79xd/+FtzMYVFS3jLJKZFHYbl5BJmVX3eHujXGBJ6PrXmFAHBJMVLtu068WTkqiCYlewh8rvPM+mXvqfNCklhI+4cgDI/0MnyhVAZ+8W0uZmCcm9X5EkMC6x8l/f+AUcZYRv/ydfZefiKpvPG6xtx5pyMf0wudWQ7YpMhFSS2yuTKmGxQwiWKBAqOFJGoLRQzO7CUriPzi66oLzxS3RpmGx51NhU9ozix23umxdrQJ8zPEVInHteIZqyj5ecDo/7HJ/bSvlfQ5HuRbHuvY972zfv/Th62Xs9PCzeXSBzRMD3/y5P5jy+ZLgN4L3GmDkR/Q0AvxfA9wN4F4B3APgrAL4PwN8A8L2wZO9DAH76c+7ti8A9iRwAsSSybbFSqUiSIhFJ8EgURRJBv16vMZ/PoZRCuVzGaDTCcrnEE088gcPDQ2xvb6NSqWA8HqPX62FrawuHh4cyD8fqWa1Ww9bWFi5fvixkiJ+HL9C11jg7O0Oaptjb2xPyxhf9SilRDdluuVwuce3aNdTrdVHewsIn9Exg1us1Tk9PpQaBC8sBW1swHo8Rx7EUejcaDSEa8/lcCCgrQuPxGHt7e6IwsvI4Ho9x7do1ua1Wq+H09BTNZhNHR0cSAMIkEwDOzs4ktXK1WmG5XGI6nWI4HGJnZweNRkMSJofDoXS5seWSCXEQBEK2eD4QyIvO2eYJAI8++ije9a534S1veQuefPJJCU3hyH9jDEqlEpIkwUMPPSS21UajIbdzuApbXPnYzudzOZ5cN1C02LLyxyXnPMMIQBJJjTGiGvP7k7sEeX7z9a9//SvzV/MKIggc0XJXyWkaYKkjNxtnCVwQaGhN0JmyYyiBJXFBoG2KZaiR1VgVIuiwgu6n5rYzbmlZhImUVeUyY7vfogBq7chNZqzSxgqdMUCWkxvKDLJqBBggmNtqAOmOM1wjYBUfZAa0crOIrJZFbg5Oa2v5ZBgDStINK6dxUf8SaOK2wzq1Slq4mUbGs3jQzgaa6c0uOEAUtw0SZwqf/LuOOOPmZ+0mBBNHdotAwUxn+MkbH8XtTOPXVtcABazbRlS3YAXAWCKWVnLCtjGzlgJKZs8g5GvZM1j27D7ikU2B1EFudxRVzpEyTpG0CZi8YPtFGpJGSdo9dZFcGdiGhcwRQgMXoOJsoIS8C87k+wGTNOQkTqoHkJO8zTx6jwcFX25i5N8iHl9qvPsNO/gH3/00/tiPfAwE4L/zZM7jSwBjzHHh1wTAYwB+wxizBvBLRPSD7r5LxpjnAICILohoyxhz/kqs4Z5Ejq156/Ua29vbMhPHX1prCR3h3rDDw0MQkcylJUmC09NTVCoVRFGEdruNi4sLUdvK5TI+9alPoVwuS9E1zzyxunZxcSHksVwuY3d3F0mSgIjw7LPPiuISRRFWqxXSNJWURb6IZxWQ57B4ru3SpUsbpeVFMklEQjAvXbqEfr+P2WyG2WwmpItnyy5duiSl2qVSCS+++CJ6vZ6oQJVKRebCWH0LggBHR0d461vfitVqJRbOyWSCra0tsVsyqSUiDIdDIZqcCsp21evXr0vQCCtas9kMWZbh7OwMq9VKysZLpZIkZnKxOtsf2VrJNQeALQV/97vfjXe/+93odrtotVoYDAaicPF7hF8DEcl8IgBRb7nQnesLlFIyjxcEgeyDZ+JY/azX66JANhoNCW7h50qSZEM15eccj8dI01QUzfsx7IQJHFcQaE1OlbNcw2grn2RpgCy183NGE8Ios2pd6tQuGJhIY90DpmkIoIrS2KDx2dTWDWSW5JiAoJIsty3yE6lgIyGSjAGSTPrZgtkaNF/BVGIYpaCjAEHqisRct5tBPgtHSQqTulARVuWIAKMLSZYGJgqhZguYMLCkLLAJmUaRU5JIwlegNZAUZueAnNi5fW/cl9qScvO50jCNAdaJU+0Klkpn7zTG5AmVUQxVt4rWvxg+jX/6yXfarrjUVgMAlnypFbBRObCwtxvliB4KShsAHVviFk0J7ecTTA9CrBu0MXfGJE5m2lw/XbFH/SXWS1baCuROnptdsk5BK3bB3U3cUNinKihzov59jmsilXlFzuPzY5M4fn4L50sf4+Hx+fHux3fw97/77fjjP/IsQIT/7j2PejLn8cXigIh+zP3848aYHy/eSURXAbwHwF8GsF24iz9ZLr7xRgC6AL60RK5oX2Rlhnu8mPiwla3dboOLpLnsWyklwRccj8+9YlzCvV6v0Wq1MJvNxNrI82OtVksi8ZMkwc7Ojqg57XYbo9HoJcmF4/FY1s19Z0xGjDFC5NgOynN0WZZha2tLtuF5uFKpJJUIbN0r9uElSbIxf7dYLNDtdgFY1Y6j9VkpZOsgK4Qc4hJFESqVimzH6Y7GGPR6PYnmb7fb0um2vb0NIsLFxQUGgwEWiwW2trbQ6/VkX3Eco9FoSLF4MVWzqHDWajUJV5nP55jP56LEXbt2Dfv7+3j44Yext7eHarUqVQx8rJvNppA37S6aObGT6wY6nY4QXX49nOYJQFRPIpK6hEqlgnq9jvl8LimnnGyZpqm8/4r2VQCigLKqV3y/3m+wtkm4VEp3oyFb1K1tfH6aBpawIbdeCsnLyNkRSf6ZSJoa40cI8UihNCwhWGQIstSSOTcLZkIFtUhctQCsYuXqBEwcWsFKLvIN1GQGE+VR/CrV0lm3UXewURVglTsT2DVSkhV8fzlhMcFLm6tJO0LG1kou5HaP5aRMSlKYMLDWzyKJK6p5slNL6ii7y66ptS0Fd2sGkAejBIF9Xm0QUYBqsEL0qSp0DCFF3Aen4zw7RSVuds3db1+Tm5lzRAgAgrVBuDRYdQKkFdvDVvSc8bbFImXSjnwHBZWusD3Ydslzc3cTQ2NJMqXIZ+qKz8kKnCq8Rv7T4cAV45IqTWH/fD3uiZzHF4y73zweHq8sfsfjuzmZg7VZenh8ETg0xnzH57qDiJoAfgTWOhkAaBbu5o9Bi/8ztgH0X6mF3ZPILRYLCQphWyInLnKoRr1eR6fTQRRF6Pf7kgjJASZJkmB7extHR0eoVqticXMvHOfn57h69SrSNMXW1hbOzs4wHA6lt+3q1at4+OGHpTaA7ZNs41wul9LrxioTWxA59ASw5dxcOs5kMcsyXL9+XRIqB4MBilUGnOjIKYo8r8XkjYlkEAQ4Pz/HwcEBFosFbty4gStXrkhKJFsImRyxlZCDUKbTqYSX8CwXB6J0u11JDD0+PhY7Jc/LMTG6ffs2Hn/8cZn14464KIown8+xt7eHTqeDfr8vfXk8RxiGoZRl37lzRxSyZrOJWq2Gd77znXjkkUfwNV/zNWg0GmKjJCJRxdjyyLUUfD+TvWq1KkXh4/F4o1OO30etVkte/3q9xtbW1gZZ5uMIWNWyWq1KyAuTaX79XM4OQBTd8XgsCZv3G7S21QJGK5CyV85ZGoBLwe3Fsf2ZXMBJlgYwGdmwkYysrRGAIQNd0dAlIGkBh60I1aMYvU+tEI3XOWkzBkhSIC4DsPZJSjIhctbemEpACohsRxsnXzpbpglVPjvHVQOKLDkjsttRJBZNG5YCmDi0qlxSKOMukCnjyrnJsF3SzrmRUxBNmoLiGBxwArZi6oK10nXA2X3kkpIUhQN555ycDGWfn62Y2gBpCr1Y4l9POvg7P/lNiHVOqtSacsUrsGROJTn5AiCzanKbU9lIA2mVkJVsUqQOczslPy4nWASli7e5C1/lrJGFYUcmYBtg/pwx0S3s++5OOCaeTl3jgJOXKHYlwLBS6Ijmxtyex2sY7kOc3zL5KniPPTy+RPgdj+/i7/2ht+OP/4vcZunh8UqAiAIAPwrgrxljPkNEEYAniCiGnZH7z27TYyJ6FHZGrvtK2SqBlyFyPGPGF88808VdYdybxqoXX7SnaYrd3V2xE6ZpilarheFwiL29PRwdHYmSU6/X0e/3obUWVYmDNa5duyZ9YMYYieafz+c4Pj7GjRs3UKlURPnK3MUYd5PxfjhNkV8P/84zcsVI/zRNJe2Q5wL5OZVS0kXGpdlM+rrdrgSqJEmCXq8n3Ws8M7der+V5i2ACqrUWOyE/JweZLBYLlMtlmfk7Pz/H7du3cXx8jOvXr0sSJc/FhWGI+XwuBLc4B3f16lUhWRzRz7NuPMcWBIGQq3a7jYODAyHJTBBZlUvTVNS7arUqYTEARA1klfPk5ETSSHkbJlwcKsNr5eoJJtV8HxNQPm5BEODs7EzUT1YGuQKh2+2K7TUrXrDfRzAFycRaJ52FEs4xKBffVtkyBJis0AJN9oKKjCN0KUAJQZc10obGYkdhPIvRuGkvuKPhEkYTUCsjq0RQyzS3WrqKADvMZefpoABUSrnapeG2sdsbJkuhApYZgACUZlbBA4TEQWsgJZArHodTADfAFQNR6Eghv8485GjDGqMd0+XutzSz/IStnEVr5udLLSVl7ZkZLGk1BtAZTJLCZBn+2ZseRfg/2FlESrA5nwZsqG+yy7u3yVzYiQGiqYGOrJJaLNjWRSMGE3m3/40ZtLw5GaTJpWCaze3dfSKd6Xwf0h9XFC01XnpNfReBKyqMSN17NNgkrB6vdXwuCvfFEjJP4jy+9Pidb9zF3/9DT+OP/wubZunJnMcrhO8A8LUAGkT0VwD8PdgUy58HsATwPW67vwzgn8J+1PlXX8kFvGxqJQdQjEYjmWdi2yFbBHlGaT6fo9frodvtygV4qVRCu92W6P31ei3phRxvf+vWLbFmaq1Rq9XQ6XQ2FLpOp4NutyvVBc8//zwuLi6kKLtSqQgR4Fj7ojrH81iLxQLNZlMIZr1eRxRFQgg4yZEtiJVKRRIVubuNVTHAqpavf/3rZTar2WwiyzKcn5/L8/EsGgd/zGYzNBoNsU6yMlUul6WOgW2PXBRerVbR6/UwmUzwqU99SlRLDjFpNBrodDro9XobnWxcI1Aul9FoNPC6170Oly5dknO4Xq9xfHws84HT6VQII6tojzzyCK5cuSIBNXwhza+JEzR5No9DSJg4BkEArTXu3LkjdkoOKGElrd1uC5lnYsdEjnv7AGyQP/6QwRiDnZ0dIdtcDL9YLOQ47+zs4Pr16/dl/UCWqTwokgx0pmRezmja3FjD3eaGopSxFQRFlYVfIm8Waax7BsNSgMVOCcEKaD8XoHSxgko11NqROAWbQulus/tz6pwxMCVXgs2EDHD2SHI1BACtEtAqAYIMJo7s/owBrRxzCZQNPVlbeyetXbgIJ1kWg0yIYEqBVQ2zzKpuYQhKUyAIcutj0SZJZGfdQmeHDIKcGAL2d2evNVwczuode0mL+yECsgxmtcJP3PwVvOln/jjKz7tYf0VQ65zcRFObVmmUnRPjxEomXSqBkCBdAuKhQbCyCioIQGSVPTl9nDjpzmkx8KQ4v2ZtlnLIRJm1peEFoU5TTgKLbjYOPimSUAP7fpDnyNdkbZV2hpHTN2EgVlOjcpXOw8PD435CkcwRAX/uPZ7MefzWYIz5VwD+1ee461/ftd2nAHz9l2INL9sjB0CCJDhIpNfr4dKlS0K6mAhxwiBgUxW552u1WqHf76PVaqFcLmN7exur1UpqCniuSikl82B8od/tdiXSf7VaIUkS3LlzB4PBAPP5XFIYWc3iWgMmmKzwbW1tycxVs9nEarVCvV4XQsekicMwuL+MbYac5jibzRCGIWq1mvSXzedzWRtbD5m8aa1xfHyM3d1dUdtWqxX29vZkO7YPcqk1YNVBtloySeV1sXWyVCqJythsNtHr9bBer0UZnc/nYnflugVWDFnRGg6HMk/H++EaAlbTtre3JYSkXq9LrQQHmUynUxwcHGA6nUp4CpPf9XotFRT82rjTjmfd2GoK2LlC3r7VakmwidYa0+lUCt+5foDVXg7PqVQqSNMUw+FQ3hvVanXjvXY/IstIBo3SdQAKbNWASe2VvMncLBxb6Ir8LnUqC6sgbgbKhAaUkVNKCDoyWHUBGCAth6ieBGg/t0Q4WNg5syi0JMsFlOTqW6F2oIjQJUFqDR2FUIu1JXxla3c01RJosXa9cAWmIfZJZVU3QO43Stn5NW1DUOw8lrbzb0Q2CMUEdn1KAevEJk0yYUtTa4tc22RN4vXzczDp08Yqb8BmyAlHOjK5S1OArKUzQQYzD5HFRgq4dcn2uQUuQ4fJlkpc6qSrGBA1y1kjo7E9h6Wxho4VsphygmZcsAinUxZUOSaJG3DbbMzQmfy7CXKCJlUEDG3VQUmoLD4+LfA9tlimNiXT7tOA5xxVBmBdsIX6GbmvENytwN1/H5R5eNyN3/nGXfy973oaf+JHbWn4f/ueR1/tJXl4/JZwTxMMz1mxcsJkitMsy+WykCHA9qrxhTxvu1gsJLiECR8rThxkcenSJXS7XSFenHZ5fn6OxWIhc3jFvjQmI5VKBbPZTEIseG6LlSpWBieTiYSkMFGp1+sSZc9WLZ5VazQaEjzCyiLvP3CWK1aHitH7xdJqTtxkeyMXUsdxLAEwTMQ43KTYrcb754CXyWSCJEkkNZOPQZqmaLfbG8eA18nqItsV0zTF9evXcXR0hJs3b4oqmiSJqF9More3t7G/v4/HHntM7K1MRFlVY1Xs5OREQmGuXLkiJJPBdQOs4gIQ5Y875niekVVQANKpx2ElRQsvdwzyvCYHoDC4UD1NU6ljYEJ8P4ET/7UhKf42qa0ZMJosiWO7G2fXF+bm7g6qAKwKJ+DbFKBDAx0brHoa813CqhsVyFJhzszNmnHSJPfLGaVslUAhNIWSDGqVWnWNCLRcO2KlN0u8Abt/R6wsYXPEMdOAdlUEAGCMtWpqbJLAQsiJgINudOYKzB0JNQYm0zBpZtMzgTzQxGhnoywqevquWTlHLtMU//bwV/HZxP1TqQAd2D42DjjRoVXj5KEBNpQ045Qvlbh5s8SlWBJsiAhfD/PLciRObJBwRMqRQUmkLBIwoDgmt6muFW6jNP9S6eY+hcQV9lf8esm+USCbBfjUyq8UeOLm8WDiPU/s4u9+19P44Z97Dv/TTz/3ai/Hw+O3hHsqcufn55IgWC6X0e/3US6XsVgshCwUkwPZBsjhIK1WSwJGmLAw+MI8DEO0220hZdevX8fJyQniOEYcx+h2u3JRn6apqHGTyUQIEc+csZWOS7OL1s9qtSqWTp5na7VaEjrC5IsVHe7Lm0wmMgM3m83ELtjpdIQoslpXq9WwWq3QbDbR7/eRpqnE/w+HQyEZbDXkZMXd3V1RO5nwcDpmEARCnp9//vmNhMb5fI4XXngBp6enUiTOql6SJOh2u2KZXC6XGA6HGAwGaDabQqiNMVgul1gsFvI6AJtU+fjjj+Ntb3ub1E0AkNm7er0u52GxWMixiOMY/X5/4zHGGAwGA+zv76NWq0kwCmBrBThMh89zt9vFYrHYCKVhOyeTcF5DpVKR+ggmmEyq4zgW4sfBOWdnZ6/MX80riChKsZiXoLlaIHHqWwn5hXpGGxZKShVM6Hx4hbRKo+zcGvEslEtANIFxyYNW1TOhwbptsGwHqDlyZCJnV2S7o1LW2shkKtWgUAGpyVMqUw1kLjiFbO+aKUfIQ04o/woD0HxpQ1CMyYnU3UmTnHqZZvl+nfWSeC2cUMkF3lmRuOa2z+LvJoMle8apgspY5S/ToCCASVJQENh1ZXYuDsbgp57/ZfznNfA3br8flGymSuoICNPcAqkSAGvYc7CyFkMmTSC7PYehpDGQlZQlg44UghU8BvN0PkzcD1ckaXeReLE7ApY8up47ICeSABAs7X5UapDFlFspdcHWqfN9WwWuoLq522wxubWF8ijexmvw8PDwuA/xuxyZ+5M/am2Wf/Z3emXO48HEy6ZWdjodIRIcosFWOJ6zYiWkVquh3W7js5/9LABIRP/p6anY3CqVihRTr1YrKXpmJajRaODmzZuIogi7u7uiqM1mMyyXS5yfn2/MwDGZZEWJ18Mqz2KxwOXLl2GMEVWK4+ijKEK32xV7JadA1ut11Go1TKdTIZy8Da+xVqvh5ORElLlWqyVqHCt43GHGFQlctcC2Qk7VnE6nUk3A5Idn5JiI8GzhxcWFKFJKKQyHQ+m0Y9LG6+TfAasaaq2l848tlkyiqtUqRqORkLGDgwNcvnwZ165dk963IAjkOBfTKJmUrVYrScbk52cS1uv1hGwxqTo8PES/3xdizASW1bVOp4OLiwtUKhVJtuQPBLiTjovD+b0QBAFmsxmq1aokW06nUyF1bBe+n5AW++E4wMSQnYUrzD8hUTlhCwqSTPFD8YI9j3+mjOwcllPwiMfADJDUSAiPCWxaBSX2NumeA/LwXFMgcZmBcnNvYqkERA2z2xQIVlqQcTgxkyhPmWRi5sq7ZV9uf5TpnMAVyZ/rfUOSWRIGtyZS+XOpwKlw5G4vKHNab87Rmfx3k6RYmQT//cPvxGf+yUOgAKDEHlsdufOg7axYsHZK29rY9ElFdtuCRdKETr2LuYjbiGonT19Utwo/i/2xSN64CqAYPoKCeuf2Udx/0eIJuHW6Q6pcZ1xRZZMagwSF91/hfcnfC7N3lAvjHh4eHvctftcTu/g73/l2/Kl/+SwIwJ/xZM7jAcQ9iRz3rA2HQ5RKJbEDHh4eYjweS0CJMQaPPvoozs7OcHZ2JgpNGIbyWMBe6G9tbeHk5ASz2UwIIXeX8ZxZp9ORoAuO4dday8X5crkUq1y1WsVsNkMURej1ehJCwp1zDz/8sChuHLXPBGl/f1/m/9gWOZvNhNxxqiarRZcuXcJ6vUan04HWWqySvG9jDC4uLoSo8nzg4eEhLl++jHK5jBs3bgjh5XWv12uxfLISx8XdTHzSNMXJyQkmkwlOT08xHo+loPzKlStCzKbTKQBIiAunWfJXo9FAuVxGlmUYDAYbihyT4iiKcHBwgK//+q+XLr8oiqQjME1TTKdTHB8fS1E8J3oWO/rYNsnHjYgwm82glMLh4SHSNMXDDz8swTCATUTllE5W5XhekEl9tVqVmc0iIWaiOJvNYIzBfD6X180dfDzXdz9hMSlZ4mZg590CY7/YWgdYQgdYksW/h8bNRjkiFmp7IV0kfxxzD4JaKYmSZ7vfqgMbTgJY9YtVVK4UABzRgZ2fM9ZmScW0yYL1kdy2lggGoGRl++B4P458UeYIlDEwcZQTOLc/upuwGSMzcFzuTWFo5+MybefiMg0iY+fueGaOSZkwnIKT3M3i2edxqh2rfgDMOgGMRmYMxh98HXA9QDhx1QspgQKDYKFs5QArXitrmcyiQgCJthbRcO2UMkOIx1YhXTcJOnT2TMePg4LV0hRJWMHeqIO7yBrycypqHZeCw9k4nVKm0gJJYyXQhajILJy2CjgZSz6NAnREOSHl53cKIbBpL/XWSg8PjwcF3/jknpA5wJM5jwcP9yRyPOu2XC5x584dtFotifWv1+sYjUZiBTw7OxO7X5IkiKIIFxcXMrvFs0kXFxcwxiAIAhweHooVczgcYjqdYjabSdn3ww8/jFarhVarhZOTEyFdURSJ6sI9afV6XTramEg2Gg1sbW0JgSiXy6LWMWni2gK2ee7u7mJnZ0dslgAklZNVIVa5tra25HWxglar1ZBlGSqVipA6DlgBIDbQs7MzCWvhMu3VaiUWVZ4jS9MUx8fHyLIMp6en2N7eRr1ex4svvojJZCJqJqdITqdTUehYYeQ6BJ7Vm06nEhjCxNEYg62tLbRaLXS7XSGeZ2dnokYySeZOPCZ2bEsNw1Dm/AAIOeTzFQQBRqMRtra2pICc+wO5toDTTSeTCW7cuIFutytBKJ1OR6yqHGDC1st6vY7pdCqvdzKZSCgLW0ijKLoviRwRADKiwFHJDiwZ4+5kQpBQTtTIODUItvw53lToaF1IKAQ2wi6QASqx4RrNG07lisJNFUxb1UU5kifKGABaZXaWLctA2qZZmiCwSYYB2QTMdeKqzsiSJLc9lAJFYU7MuM+NawVc4IgJlH0ObWwipspVNFIKRmvb/5amtivOGFDIVQemUByubCiLIhdqou33IID1ndo5PeOIo1mv7f4AmMTOeGpo9D+2Yw9RaBCulLMTWkVOJVbl5ALwdYOsfXINOXfx1CCp2e2iqUFWBnRIuaXSWLJVtG2awHW3ZZa46XJOnlS2SfJUCmRx/rOOIEEmAGTeTogY81n3HpGwlNCeLpWR3A6+L8gJZG7jNNABwYR5Yme4sLd7eHh4PChgMvcnf/RZEAF/+nd4Mufx4OCeYSer1UqIF6tOy+USs9kMx8fHYlljle727dtS9LxarTCdTjdi+jkWPo5jKctOkgTD4RDj8VhIQXHmjC2OXIOwWq0wmUwkyIMJ1mKxEIIxnU4lofHs7AyDwUAu7lnR45k0/p0JaPE1F1Ml2+02ms0mqtUqsiyTugKuIygqSpVKBVtbWzg4OMClS5ckOKVWq6HVaiEMQ1ljlmUSjMLBHlwczhbCOI4xn8/lOwfCZFmGdruN7e1tKWrnY8/7ZlJYDKUpBoawzZPj/Hd2doQssoWV18IdbPza4zjeKIwHIGSai73jOMZwOMRyucTt27c31DO2kbJ1lN8jR0dHmM1mQs6ZaBarD7ijbzabyfFngs2kdrVaSRonz9ex/fZ+AoXa9sSRAVUymJUbuMrIzXGRjZhXVgkykVXeKCFXBF3YmSZQQlDui1KnsmQkShwHXFAGlIYukASwKltR4clc8IkEhDhbpYJ9TBTa0m7tgklSV+7N3W9EG8qbBIukluiJ2uZqACxx07kix2qZe+6NgBNW08LQkjUiS9aCgp2SFCgMQHGUWyfvTt7UZsPKSUSWIBqDD9z+GCgMUaEY4ZysozEjBEtIEqRKmXVtkiOSuTmDYG1JmyFrqUwrhLRMMlfHsf98Tl6iZvE2bm7NqJx4ySaFfbGaV9w32zr5cVJlcFfIiih1LhxUR1ZpYxWOt+cPBnRI8jheFwpEz8PDw+NBwTc+uYe/811vxw/99HP4Oz/3/Ku9HA+PLxj3VORYbeIkR05RLJfLoroMh0MYYzCZTNDtdsX2GEURjo+PxWbIM0p8Ac4/1+t1sQoyKWDSslgsMB6PN4JCFosFlsulqE6AjeRnIjcYDFAul1EqlbBcLnF4eIhSqSREazqdygxcvV4Xi2Gv1xMlzRiDfr8vfWus4rC1k2fCyuUyBoOBWP0AS0qazSYGg4GkcoZhiPF4LB1y9Xp9Y84LsBeQPFO3Wq1wenqKOI4lUIRJHs+EPfPMMzg+PsZDDz0kyhurjDz/1263US6XsbW1JSSOrbL8vMXn1lqjUqng8uXLePLJJ6WTLwgCzOdzNBoNCYfh1Ey2L2qtMRwO0ev1ZJ9cUcBW0W63i0qlgtPTU1y5cgWj0UhK3YlILJZMHtkuy+s4OTlBo9GQhE/+PplMpKS92WxCKYXRaCSdfFtbW3LOikma9wtMquTC17jZNrMM7MV1ViAvBlIpYOeqSGa0iCPuU5JOMGSw5AbuvkKIhUoI8RQo9Vd5ofc6sWqZ1nYNQQBa2iRKuHJvSiy5o6Uj7soRKK3zxEmXXgnA2TKd2uWi/JEsLPkrxVYZWycvTaIsdsMxiSOyxE3qBDQoimC0BlGYB54oI/dblVMDyTqfpQOsQhgEMOu1CzuxHxZQEEjQybccfBVUJca3vuvbYP4gEC4tMY5m1goZrAlqVVDHnKKFBHZ2EC5chAmYmyuLZgZphXJbI3KCzfZKE0DIYdFaCeRhKcbYuTyZaSuUewcrp5A54ZE73hDb5ynaK3Xk7lP5d+NuZ8XQhHafxRAUnp1TiVVi2aIJ/u7h4eHxgOG9jsz9qR+1Nss/9e7Xv8or8vD4/LinIpemqcyPsWLDoRetVksu5LXWUrzMF/tsveNZs9FohPl8jvPzc7H2seo1Ho+leoBDTSqViuyHLYRsreQZrfV6LQEh/DggLypn6yTH4rOVj5VEwBJRVhF5VozVMbaE8u8878dEdDKZSDee1lqel9MmWVHkxEwOiClWL1y+fBnNZlM68KIoEnvifD4XtZITJ9frNW7dugXAklJ+Lt4vf+f1MIHl2Tfu0uPnYPWTVTEAMkO3Xq8xHA6xWCxk/o0JOathHGrCs3mz2QwAZJ6yVquhVCrh8ccf3yDA5+fnknTJx5pDVHi9TOSZlLFil2WZEHkmfay6MuFnpZiJnjEGaZqKCng/wayclJER4HrjEJl81i1kYgJHsIwkDMLZMvn2u2PgURDsuNuM/+LDBaASbQlGQELYmDRRsX+NiRpXBQDAam2tkEmaWycTZ3fUdm6NyZfhlMo0ldk1k1kljmfehLw5JdCkNiiHFbuNGgJOl1RKrJlgUsmE0O3f2jODnMRpA5NlllgC7nHKkjjYDyHsfhRMkmL49K7rULNKVFYGsrKxJC7lgBNWPiGkGWCC5mYZtbGE6q7zU5xR+1z36cIcm8zOFQifCSA2SlHsOK00zJU0E+a/A7mqZo9B/vz8fFyhIKSyMH9XJJg6IrFf8v1s6fTw8PB40PDeJ/fww9/5dvy//n+f8cqcxwOBeypyBwcHACwxYpWNL+hHo5EoY2x94zRIANJ1xuEnQB41z6raer3Ger3GaDQCALHDNZtN7O3tCZHo9XpikVutVhJ0AkBsgZxiyeoZpyAySQvDEI1GQ4q4WRHr9Xq4uLjA6ekpGo0GjDHY29vDarXC9evXhVjwcx4eHqLVamE6nUrkPwd5VCoVISYchLJYLDZm+drtttQHcDcfk8NOpyMkq9/vS2XApz/9aTlubB09Pj7Gk08+CaWUzIExOeW+NbYUNhoN1Ot1DIdDmWXjdEeuTOCQkouLCyGz/X4f8/lcVLYsy6SP79atWyiXyxgOhxtpncPhUEJQ4jhGtVpFp9ORnjnux+PnLBaD8xzh6empEPPhcCjpolw+f3FxIcenVqvJbOZyuUSn05G5zV6vh+l0isVigd3d3Q0Cfz+BUgUTadAqsCQtBAA3/xaa3KqmYNMnFWBg8hRDBSAlUFiYZTLGVg3Ihb+Bjq0KlJU0us8r9D45g5qvbbCJCx0hF0hCizVotbYqHHfLSTBIwY6oNQjKEjgmXKy0FcJNhLytVtbqCAA6E2umWSegQAmxI56t0womSyxp01aBQ5bZoJPUkUd+rmLJd2JJOxllVTwVFI54BoL93bi1GeT7VKUSKAjwbz7xYXzb7/leTK4GIAOEM0tu0nqBBBEQzuyxBSCEDcbNyMHaKVVqz5MOgbRiA07uJk9KHg8hbbqwbJ6lU1lO7LIYMp8HOKVO5QocK2jFNMlgBTcDmb8GUyCJ8rtbT7AuKI4uEEVHQOCI69qNnYYLu99wYXz9gIeHxwON971pDz/8nW/Dn/6XHwcR8Ce/wStzHvcv7knkLl++LH1jWmsEQSCJhNzftr+/D621zC7N53OcnJyIMsK3TyYTmdU6Pz8XksOVBrPZTFS07e1tABCrX6lUwmg0wsnJiYRaPProo1KSzcoZB3eUy2UhlWztYzWR5+yYRGxvb+PatWu4ffu2WBGLPW0HBwcSbw9AiEsQBOj3+9KBx8QHgHSbserFc2O9Xk9mvjjVMggCebwxBlprIbNRFGE4HKJSqWAwGODGjRuiVHHq5WKxENuk1loUslarhStXrqDT6YhiBVg17PDwUOywfI64ZiJNU5ydnWG1WqHdbkswDBMu7tm7fPmyzOpxcXwcx2i1WqjValIqfvv27Y0QGLa+NhoNHB0dodfriapaVOoAyExekiRilV2tVtje3hY1EgB2d3dxenoqit1yuZQPH+r1uszHMWG+72Bg0yp5/mipctKWklgpAWunJKfUmcDAhMb1xgFgRciROZ6NIgAwhCw2iEcKNAzQfmFpSRyRnY0D8noAY0DOSilLdORLZt5WtvTbhLZ8m1YaCAOYCscWEihJYZZ5NyEAS+JKJUvUXBqlMXnMonGEzIBn83ROzkjBsDKnrMLG/77YRbpZvCyz22UZDCIQONwE+awcE0hW+bQRhU4X+hSnD9dRGhikZXsgFVmSRBkhKwO0ALIyufk2a900ytY2BAmQRUBatSmVWUyIZraaQIeUK2eFebUiWZJCcCZ7fC5UTiQ5eITPNxlLsoSYcTgK8veGjgr7cM8RZJuP0XE+g0faKXlwpyzMg10ohCSh2pJzS+Jeogx7eHh4PGB435su4Ye/E/jT//LjADyZ87h/cU8il2UZDg4OhABxKiLbHPnCvRhAUUx4ZDLHXWIAhGgwaWHLG9cPXLt2DZVKBQcHB1I5wISIn6/VauHi4gLNZhPT6VTCNVhlY4tdtVqVubJGo4HLly9jvV7LY4lISAW/Bu61azabWCwWaDabGI/HEqzS7XYliROAPCcAUeZqtZr0nS0WC3ksd7wxeWMbJltGizZJTtF805vehGeffRb7+/vS53bjxg0AQLvdlvRJtlEySeSwEe6p4wROTspkBYtDQrhMHID0+/G6+dgzcWw2m1IRwTODtVpNQnE4dZJtjd1uV5QwDjpRSsmHABykwuS3Uqmg1WpJyiYA3Lx5U+b9giCQuUcmdJz6yRZNrsXgMvDZbCYVGvcbaE0wFUtemKTBAATb/2aCzdvtg2AJnCZR6ZCStWMqkxM/Vm+UgUoteYinQHw6s6qVI2iGyAaWBApInFIGR9yKPW5AbnF0hE/m17TZUO8MzyMWiJidcTN2TWxtdDNwMuNmdH4fP45tkRyYoo3013Hipe2Yu2uNWlsCwkTO1RHw3zsRWdII2NRLY2wROIBve+RdSL+dsOxZIiaEyZ0LxeEk7hgzdymqZSoFyn0N0rY7nWP88wJ3SECJKKw8z5i5U+mskVRQzTZ63thmy5ZJJoCs7jnLI+k82VIUOseV2RJqwpzA3V1RkM9X5kohuXk7SoFgYVViXUje9PDw8HiQ8b43XcL//AeBP/OvPg4C4U98wyOv9pI8PF6CexK5Wq2G7e1tCZhga1qtVpPY/CAIJAGx3W5jPB6LlZKJzWq1kuCQ9Xot82psEwTsvFe328VTTz2Fxx57DG9+85sxGo0ksp6TGHn2yxiD4XAodQO8BrYm8pzXeDzGzs6OkDomZcvlUkhnp9PBlStXQESI41h60ZiwtVotNJtNsQ8y7ty5g+FwKLbTdrst5JQDPMbjsayX1UPAEtoioeOAl93dXYxGIyEpTNQ4JIbn5tjWyaSY582iKJLwFQ79YBUwSRLUajUp/uY5xHq9LkXnTP76/b4QxN3dXUwmE3kMAIn+54thJqxMTrlSgkvIsyyT98t0OhXCxgE6rJLW63U0Gg1UKhWpaDg/P8fR0ZHMGe7v76NaraJSqSCKIsRxjG63iyiKhKi1222pLWi1Whvq7/0GCTDR9mdE7irdXdQDgAm0XFkbY2xipQs2MVQgBqHrQXM2PILjdq5/rvmiQefTM2unpOiuhbBa5WyM2ljFrZgcady8WdGhmmZSLQDAErjVyhIi915AqQQoAqnIqXBunxJQAmC92lDKiMjWIvA547+9QlCPWa7uUtkUuOSbKwWIyNo1g0Bm48j13EEpy40ynds73RpUo47FtkI4t3ZIILcwsgoFchH8EUmCo/S5uXOSVsgpbpat6dgRKtrcjtVT0i6AJHQF3Qy3PVss7YMcoWQ7prtN1DSe2UstIcsq9r1GKRAkdltLLvM1wJE2QoEkkrNTrvK1cHhOPDII1satm7BqeRbn4eHx2sE3vfkS/mdYMjdcrPGH3/kQ9tuVV3tZHh6Ce4ad7O3todFoIAgCSSbc2dkRCyLPQLGFrVarYWtrC51OB9VqVax5nHrZbDaFyHDSIgeFAECpVEKv18Pe3p6QpjiO0ev1cOnSJQkbieMYcRyjVCpJ9DwTBrYrzmYz9Pv9jTj+09NTTCYTHB4eSggKh3xwqAvPVxWDR7jqII5jmQfjoA0uq97a2sLe3p5YMPnxxdk+nj/r9/tC3lg5YjWLw0gGg4HE6HOAyWAwwO3bt6WmgRMaeb1sF+XXcuvWLUynUwyHQwAQdYqVRw6iYdtho9EQxZH79RqNBhaLhZRx8+OLPXylUgnValWSMDl8hsG2TCbPbB0tEn62PLIiWfzQgENz+v2+pHhyGTzPR7KdltMrmUxygArfXlzX/YJgodwcnCVnMCSKiiQwKjj/mv0yoYFRebhJMZHSuMo1gv0erAEqqCiGFbZC8AvPxiGzoSZ3k7i81LswI6eUJWJpatMfOeQkTWGS1P6eJC7OvxBYUkynNPqlNsciXAm47ZwzeSCKLmybZXnIiSooewzlZgBdrYA96AWCqlQelCKl5BrotBAsjbVJrgzUGkhrBXLk1K6sRKJCscWyWCmQxYRoahAujVXZklzJK1YIiBLG/yI7gqWjXJWzG0JIm8ryfXEgyQaK5A/WErpRdVCYuZOAFPf+kZoBctum2CCQ/FwqBYK1VVl1WNiXh4eHx2sE3/TmS/g73/V2fODX7+Br/9bP4vf93V/CP/6FF3F7uHi1l+bxKoOIGkT0ESKaEtGb3G1/gIh+hYh+loiuuNueIKJfdLe/55Vcwz0liv39ffT7fekUOzg4EDsdx8uz9TEIAilsfuihhySmnisJ2GrIM25sP2SCwva9breL7e1tUXv4Yv7w8BC7u7vFAyel0hxqwmpdrVbDbDaTAJbZbCZrBKwdcjweo9lsolarIQgCTCYTbG9vS6Q9k8N6vY5qtYo0TaXku9PpYLlcolqtQikl5eNclM6zXJVKBdVqdcNOOp/PRQnjYBTuwRuPx3j++eelFLzf7yMIAjz33HOYTqeYTCYyX8ivnUkyz+1xeijXH3DaIxNPAKLk8TnieoQgCPDUU0+h0Wig0+nILFqpVJJ5OK01zs7O5DgeHBzg6OhIjj2vI0kSeR4m7dyDxwXhYRgK2a7X6zIHN51O0Wg0JFilVCpJdcHNmzdx6dIlTCYTIWsnJycbgTZcCE9EaDabUlZ/cXGBarX6Sv7tvCKIxmTj27nny83LGdxFbJjMOdXEKMBE1nZp2JK3tmRQpUCwst1lOjYwkb14D9YGap1KrQAxseJkSmelNFFoiY2ocdqSNq2BFHYWzhg7B8eKXJJalQvIY/ydKobV2kb8Ay6cxFjLZBDYebfESj1CwrLM1h9kGcw6A0WhKHy8DgoCe7sjnyiVANgqAVBs11SciWQCS7R5O6yKSEEAnaQgZ+PUzQqCtS34jqZuHtGemDxgxNj4/aRGqJwZJA0XbMKCY2ztisuOKpBh5BbJ4qwbIGEnQoqCgs2SZx6T/HHWNot8TvIua6MQfEes1Dq/jQNXisqv1AoAouxJsEuQr3NT/bPvoaRmO/JMmAe9eHh4eLxW8N4n9/CNT+ziPx+O8MFP3ME/++Xr+L//5G/iqSttfPObL+Gb3ryHg879d43h8SXHAsC3APjbAEBEEYDvB/AuAO8A8FcAfB+AvwHgewGcAPgQgJ9+pRZwTyL30Y9+FG9729twcnIiao5SCnfu3EG1WkW5XBYbIM9YFWP46/W6zFLduXNHFJw3vOENWK1WWK1WWCwWOD09FTsiJzJeuXIFW1tbmM1maLfbuHbtGj796U+jXC5Lt1m73ZZkRSaSbCvk6gS+D7Bqz3g8xunpKfb399FqtcQqyLNu/DsTGC6h5rk7DtNgQsMx+zy3xYRkNBohiiLpqmOljEu02TLJwTEc3MFzXlzufefOHZyfn0u5OVsDeZ6M7Z87OzuIokhCXyqViiQ/rlYrUcPq9boQ8XK5LMcziiKcn59juVyiXC5L0XYURTKzxgSt0Wjg9PQUW1tbkt7Jlk+ulSgWqrPNdbFYCFFmOyj/fH5+jq2tLRCRzDWWSiVcXFwgjmNsb2/LPGUcx6JEcscev++uXbsmaair1QqHh4cSLMMfOtxvqJ4YkFZYd4yNtV8om14ZuMEpFo+o8MVwhECIgYa174UEHWurwGggsM0c6H7kGLpRscSH58tcYAmUgimkUVopp2CrDFReK6A1aJXAjG21g1mvYZLUkqtyyRKxNIXJMlAYWXIFWHWNZ9mY0GXuqt+lXoqtki2USlnSB+Rzd1kGQwqqZv9eTZaBdIG4BYG1Uq5Wdr+FdenFEhudctqAwgg/ef1X5bC+/+DpzfJ0bQ8zH0cgJzUqBeKJyUNGHAFSie1yiyZGZuGWPUv0dJjvg5NG2TIpM3P6rtvTTfWs2C939zwbY6OHDq53ju+j3EpZtGPK+6rweFYEed1SQK6BtExIKzb0RUf58fLw8PB4rYGI8NYrbbz1Sht/6Zsexyduj/CTn7iDf/6r1/HXP/ibeOtBC+9/8yW8/82XcKXrSd1XAowxKYAzyt1GjwL4DWPMGsAvEdEPutsvGWOeAwAiuiCiLWPM+SuxhnsSuSAIpPeNycpyuZQLZ74IZxscKySccskKjTEGjUYD4/EYV65ckbm48/Nz6Vjjkuosy6QjLkkSUb1YfeJEw+L9rPgVVS9W/4oX7ky2eJ6KlScOJeF5OyYoTBjZ7khE6PV6UjnAHXNsNeV5Le5g4/2xNXK1Wsn8Hacpsr2Qy8g5wZF77crlMrrdLo6OjuT4cFBJMaWT7Z58LFgF4/ARJoG85nq9LrNxg8FAbG3T6RSnp6d4+OGH5TwzYWq1WqjX6xiPx3IOAEgIDb8/uA6BbaZKKXktbK3lMJzVaoX5fI5qtYrz83NUKhX5YID7BItzd+12W/r3Tk5OMJvN0Gq1RPFlO2qxnqL4OxP1+wmlkUZaDZA0AbV2CYiGgNSmBxpW4YB8kEqZPO1QGXfhT9BxIYgks6wiWKjcthcGMKGCCQOrvhXrBJSzVnIYSTHghKGUJT6uEBxRaEkhkyY3J6nde4Ncn58QJ20AOCtkkifbFknc3SgqaFQIRTGs+CWuUJxJHLk5OfsA+z3LYNZ3ZeLrzefSMFiZBAoKHzh8Br/nGx9D5mbHgrUtvba2RDsTF6yMrQ1YW8KWle1tnDxZHmZY9ALbyxYAWUgIF3ZbhlH28UUlDrDkkIu6TZjbOIvbccolz7m9pEag8JYpkn8mZzxLaZCTxY1AHZMTNglYCTZ/NgpIGnbmTrb18PDw+AoAEeEtB2285aCNv/S+x/HJ22P85Cfu4Ec/chN/86f+C97iSN03e1L3WsEBEf2Y+/nHjTE/fo/t2gDGhd8LZT+CEYAugC8tkVsul/jkJz+Jhx9+GLVaDXfu3MHJyQm63S62trYk/p8v0jlkhLvbhsPhhvrE5d6XLl2CUgpvfOMbMZvNcHx8jBs3buDFF1/E008/LQSw1+uJ7Y7j7XlfRITT01OMRiNJTQRsf12SJGi32xLOwUSKSU273cajjz6KTqeDkotCL858nZ6eSlgHr+XRRx8FAJnF47kufq2XLl2SmbkkSYRcVKtV6ZIrplTy3GGn0xHb4gsvvCCpma1WS5TKer2O7e1t9Pt9SV88OztDp9OR186ki22QTLwByMxcmqYYj8dCzDqdDrrdLprNJg4PD0XBnEwmmEwmqNfr2NrakkL2z3zmM/jqr/5qABAyx5bFRqMhQSP8WrnqgWfU+Bys12vMZjNMp1OsVitR7bhmAIBUBXD4DBNrTsBkUs2BLp1OB7u7u2KzbDQaSNMUW1tbEtSzs7MjlQv3E4K1QbgwiCbWYpmVLDHTEdvabAUBX7hbpU1tXKznrd+Q2yklkAHSqnER8gaTJ7dQPl8jOB257cle9xNZi6MjdpYsUKGfzVkwXVKkmS0gNQARYBa5VGXWaxhtQFFokyABVxvgFD0AKDgbDc/AMdEzGoYUYNZCxIpknKLQKYYGZlGYT5CKAUsQyYWZSN9cgQB++PBjeO/+U1CuusNkGr/7oXfiQzc+ipFeYKVTfN+/+0n8337wux1hsQRapXZWjjIDmFzhCtY2ej9cGSRVDj0xOemBtSCmsT2PKkFujy0QLU6jJKfAUQCA85UKiZFFAkfAhj1Szj+/PwgbFQc8B/e5VLOilVPUPSaPhfdZsMjXCCDvrnPksEhWPTw8PF7rICK8+aCFNx+08Bff9wb8xpEldf/qozfxt37qv+DNl3NSd7XnSd0DikNjzHd8AdsNADQLv/MVT/F/3TaA/iu0rnsTudlshsPDQ/R6vZcoccXURQASZhEEgQR18EzZfD4HEYlKxfNhbD0sqjSLxQLn5+d4wxveIN1iRSWO0xg59ZIj+zn9kJMJOYSDA0dYvWJVK01TUQb7/b4oREweWPHiua35fC6vfz6fY7FYCNHkMJBmsylWUJ4Rm06nEkrC1keeDyyXy6IQceAIv0a2BzYaDUnG5BkwJmYApGy8WHHAFtfZbLZRk1C0mHLXG9cMcBk3B4jw8bp9+zauXbuGOI5x+/ZtCZTh4Bp+Dp5ZZAWTZ/i4CJ3nAQEIkWPLKldZsK0yyzK0Wi0JSeEPCPjxfAzm87lYKDkRk2cWOY2UaxOYJN6PYSes9ARLq77AuOLu2BEBx4E4wZAS+ze3ocYgv3CnhDbi6XVs3P4JzV8/hj45AzrtnIiJaqXz+gAiS0TIyTtZZtMjuW6gODvHJMx1uwGORDEBBOxjODmSkyQ5HIUhZI6TJ9WmTbDYGVdQ4IxT1si9P4wxoGLxuzaWWAaOUOoMmdH48NGv4X0Pf7XdpyLZd5lCJMiQGWUJVxnIys5aGBAoNNLbxlCpPcYcKFMaGyzbgZBxldp/wYMlhKSbICdmRmFjts5ujA0bJlshmRhKZYGzPrLVUY6Zeen3YkH4SxIwUVD83H0SfHKXysckTqUGKgWyiGw4Cwem+LATDw+Pr1AQEd50uYU3XW7hL7zXkroPfuIO/rf/dBP/jw/9F7zpclNI3bVe7dVerscrj+cBPEFEMeyM3H92tx8T0aOwM3LdV8pWCXweIheGIe7cuYMoirC3t4dLly7h/Pwcn/nMZ6SLrVKpoNFoIEkSTCYTIW6lUgmDwQDj8Vish2y15AvzdruNd77znTg5OZGZqEajIQRotVpJwiSrZKVSSUrDj46OUKlUpFCbyQFH0bNNkwupuVPuN37jN3B2doZut4u3ve1tYv9jayYRYWtrS8gcz7GNRiM8//zzMmvGgS5cSD0cDjeUxNlshsFgAKWU2A2r1SrG47EQNK4ZYPAx2trakpAZDojh9YzHY1QqFSFPrG4lSSKBI2x3ZVIIQOL9m82mEOc0TbG3tyeElUng/v4+dnd3UalU0Gw2pYePS8vL5bIQcSaPSZJgNpvJDCWHw7Adtd1uS7gKz8FxGA3P9SmlhNgxcZ7NZrh06ZIEpvCHBmwPZeU3iiJsb29jsVjI/CKfu0996lP3Zf0ADBDNbIR7WiZkMSGtAeuOrRmwbA3OKgmQY2xieeMwCwOoFckcnYmMqx6wj9URMHjHHlqfrgLDqS311laaIWNguJetaKdk+2OS2G3S1KpsRJImaYyxt2n7nYIA4BRLwN6nCGadQLtzIrN4gBA4tsXKYUkTgBRIEcjZpk2m8xk74tm5DDAa2lknSVFOPOEUPOMeozP828NfxcIAEQJ86LMfwXsPnrZBJ1mK9+4/BRDhx279Mp4qHSGt2uOWVqxt0oSASS35NoEBJU7dWluinQVAaayxritkpdzCyHZLlRXJuSXsygBIkXe5sQpmYINNeBYvKZAwLhLnebkCWVNOJZM0S1bqHHkTVU/b5wWTNWDTGun2VbRian47EoAQMIZAS4PAGAQrIHM1DdoTOQ8PD48NUvffv/cN+M07E3zwE3fwb545xP/4oU/jiUtNfPNb7Ezdw1ue1D2oIKIPAngKwBsA/AMAPwTg5wEsAXyP2+wvA/insFbLv/pKPv/LEjm+MGdViysFgLxculKp4Pz8XLrWeG6O+8+m0yn29vaEBFxcXODi4gKXLl2SoI7HHnsMR0dH6Pf7iOMYFxcXuHr1qig8rNqEYYharSZWuzAMRWliNYoJXdFayGrber3G7du3sV6vRXX61Kc+hf39fTSbTVQqFbz44otoNpsYDoeiEPV6Pak+2NraEgLEpInnwrhAnMkc2wq5oJwtixy8wfvgguvT01Mp6NZaY29vD+PxWIJVWBnltEauSGB7KABRImezmahWbGvkJE+ucGDFbjKZYG9vD4888ogct/F4vGETZWsqR/lfuXIF4/FYStaNMaLULpfWatdutzGbzTAajSRtMo5jXLlyBZPJBKenp6hUKgjDUMJS+DxVKhV0u10kSSLns0g+ubdve3tbZvPYygnkCs7Ozg7m8zlqtdpG8un9AtI2ml6nHIRhy7uzkkLStBUDJrAzXPYi3l1tZzZBUcIqXOVAWrbqECUEcEede8jwMQUyTbQ/OoVZrkBlAEHseuPc1XyaAiqy6hsgYSMmSRxxSyxRChyDSFNQtQpgnitwSkFVqzAcLmK0JXlM1pLUplgak6tvpjDjRsraCjnkJLNplEZhI3HSZBlIEUwG+xxBgA/dfAbvu/bb3L5saArFsUu9DFChGGO9xNxk6CgF6AzGaFAYAVEIs1ohMRpro7DcwmZlgC4on9oqqDbUhKx3wgCJIzOsvpGxypVRJDZJ2yNnoBXJbJkpKHOsnJETPItkUDvSDgWpEBAi75ItTVDYjyP2lOVzd6oQ1JKVHeFjQuf2q1aQjjkmkQEfegLgFMh4ZmyXXgBkK9unx710Hh4eHh4WRIQn9pt4Yr+JP/+Nj+G/HFtS92+fPcTf/vCn8cZLTfz2x7bx9qttvP1aB1t171F/UGCMef/nuPlf37XNpwB8/Zfi+e9J5NgSx8mPrHy1Wi0JIQEgc061Wm0j0j5NU0RRhE6nI+QvjmOMRiOEYSgWxyiK8NBDD0nxN6tIp6enosLw7Bd3hvGMVpGwcTk1z2hxcAiQl5Ov12vZDxPL0WiEra0tGGNE6eIya15ztVrdsDMaY6QEm9UpYwyazabMi3FKJb8etkQOBgO0Wi0hJcUqBiZmXHY+n89x69YtzGYzjMdjUam43oDDS1jx5DUXFcq7bZVMgPl5i3ZVVtl4Vo8LxEejEba3t9Fut3Hz5k10u12pACj2zfF8XqlUkufnGgcm91tbWxKOUuzpu7i4EKVzMBhgtVpha2sLjUYDFxcXYq3s9XpI0xTD4VCqHLimgG2VzWYTWZZBKYXhcIjT01MpPL8foVKbNBmsjLtoJltEXbXvax1ra8E0EM+kCfKBKlbreH5Kwk0CRyAon7sbP6TQ+vklzGplkxzT7K7FqPy7O+bQrl7AGFAcCcGytQOJnZ3jxwEAkZ2VY3UvCDYCUaSz7a4agA3IzJvJEyYLdkpybMTcFVqSFYJOTJpam6ULYcEaeP+Vd+BHb/wfWBqDuVnjA7c/hm85+CqnGq7xwdvPYqCBK6HCuqURLAnBkpBqu4Yssr1xFFplLlxoSbjUIWwxuMnPKc/TFWfXihZIsWg6tc3eZqz8xbdRbsEU4p7l+2Sixj8XIbZcnqMrzNMZwHYOmnxXbNdVTg0sWkhFmYsghE+eI7UPNoo2HuPh4eHhsQkiwhsvNfHGS018/+96DJ8+meCDnzjGR168wD/75c9imWg81Kvi7dc6ePpaB2+/2sFjuw0Eij7/zj2+4nBPIlcul4WoaK1xenqKOI7R7/fxrne9C3Ec48aNG5jNZnj44YclGr7RaKDRaMh+2NqXpimOj4+FaLH6xFUElUoFR0dHiOMY5+fnMkvF82eHh4dIkgS3b9/emK3jCPrZbIatrS0kSYJeryfWUK45mE6nEkXPZJTn705PTyXKn5XI69evi3L0yU9+Eu12WwhPMQiFkyiZOMznc7RaLXntXFkwHA6FePJjkiTBcDgUssUzXev1GkEQ4IUXXsD169dxfHyMyWQiiub29rZYWXlGjok1p0GuVitR6TgMhve/XC4xm80kpIZJKmBVtHa7LUXfaZpuqGFc+8A1BlwF0Gg00G63ZQaPXwMrgKzGMakslUp43etehyRJ8Nxzz6HVaiHLMrHgsqLbbDZlxo5fe7lcxvb2Nk5PT6VGYTAYyHu0VqvJudjf38dkMhGV9H4DZUBWUgiXGpTadESVGmSlACawpIBSZS+e2XqnDHQZAAygAV3WIM2pkLBzdGQk8IQSjoYnrNoGt7779bjyzz5tLZNc7m1MXtp9N1QAk62sTVEWTvk8mlPQTKZdsInJO9+cNZKiMA82AWBw17lwaZMmy6Di6CUJlncXfVsyR5bI8WO1wfuvvMOqea72w7gPSQoPREQKkckw0RlWtMQHDp/B737d1wIAUmQoU4Bv+z/9MZg/liBZKYSzyM7JBUW7oz22OiQEa6tIrZqUh4U46ySzpiAx0AEHoTj1LIGQK72RZkkyGyfnnMkb5XZLu22uFvL7iYkUE3tDsD1waf47K3zh0iqETAxV4oJLTD77l1byIvFgbVM7sxIQzix5DVZAsNRQAUFHxtcPeHh4eHyBICI8vtfE43s2qyDJNH7zzhgfuzHAszeH+Ls/9wJuDxeol0K87Wobb79qyd1TV9tolr39wePz1A+sVivp72KiNhwOMRgMUKvVRPngaHtWwTgqnpMXmeQwOWSlhlUypRRarRaefvppPPPMM7h165bMVpVKJQlO4TksJiRss2PFj9VBJp8cwpJlmShpPJ/HShTPvq3Xa3ksWyh5PzxzxWvhFE4gJ6o8C0hEuHPnDprNpgSeMLlipYp77vj5mWCw0sc9a0WbKj8XR/RzyEgQBHIMAavGcf0DK3Ks1PE2vObifdVqVSoaKpWKJEc2m82NcnUmSEVSyr13lUplY90HBwfyeni/bB3l18R1CEQkvXrdbleUTLZp8nGfzWYyk1er1UT95ZCafr+Pvb09tFotmSmMoggXFxdCaO8rFNIGKbNELlhqxBOFrGStd+GCkMLOaAGQvjIAVqEBrC3OWLJmApPfjsKcUwqEKWHdMbj+J96Ah/7ep/NZtiiCce8FAiypk3ARsrNvrMQZ68HjoBD7/CwDuu+uFBzaztYxUZRwEgSQmgDkNkm66xNH7qArWi9ZjcsfrPHh2x/Hey+/ze0L+b6DICeYOsOHj34N55lG5g5ZZgwUSNS+kV6jSgFOvroGYAVVTUEZEzmDwFlVTWjthzq0RIeTLY0GFNk6d0NuzsyRryCzQSmi2mWW3JG2qiqTKcOl3kXFzalhWZC/B4qdbcXvOszPeX5C8/2Re6/BuOc2eSoqULBsKnd/8TkcAWTLJivJxecxtHkOPTw8PDy+MESBklqD7/06e9ud0QLP3hji2ZsD/PxnzvB3/+PzSLXBYzsNUe2evtbBQ73q5geXHl8RuCeR49AQnuEqWuF+/dd/HY1GA/v7+7h06RLCMES/35cy63q9jl6vJ3NtrOp0u10pveZ5KFZsAODOnTt49NFH8cwzz2B3dxeNRkPSDHd2dmTWbLFYiI1ud3dX3rhcQk1EMhcVhqHYIFkd42REDgvh9MhqtYpGo4EoihBFkYRzXFxcoN/v4+LiQtInR6ORkFZOobxz5w6CIMDOzg5OTk4QBIFE4FcqFbTbbSFts9lMYvJ5zvD8/Fxm9zjOn2fEzs7OcHx8jN3dXSFhXIDO2zIxZJWNLZ9s/+QZN55FBGwASpGQHR8f4/Lly0LOuI9vOBxKqXi73RZCWqvV0O12Zb+lUknOSxRFcuyLaiPbbZVSQhKL835cybBYLMSKGkURdnZ2EIahkHjut8uyTJRUfh9y0M3169dFoWQiez+BUoNAG6i1RlYJ7AU2gHhs3ydWmVFQiSV1aY1VO4IODbJGBkqVteKRsb1yTAQ40RCWJJjQKUoZkNQNPvun3oDX/ZOb1hpJBMzmQBzlkf1BAKQZKAxgSiXLUpiopam1I2baPpHOiRP3wlEcA0liiRQyZ3E0orwJaRM7pLKzcDwT5+y5llS6NEs3b2dY7UMGIMB795/Ch48+DgCY6zUiCqChUaII77v6VVa9M4TEZJgbg8QAJQICIqxMKkriUAPf8+1/FNnvAFSkQYdlNytmX7eODJR2yaIlW4jNCZSsdqmZU7Yiuw2lVh0LEidWprA9gSFgSs6OyFH+IUR9Y2WNyZRRgOIaBkf0WFkTElgUTV2NQNECSamRBFSj7GtSawiBJJdSSW6uzyjXo+dUQem6czN3aQW2nD01SMsK6zr51EoPDw+PVxCXWhV881sq+Oa3XAIALJMMn7g9wrM3BvjYjQH+1k/9Js6na3RrsczYPX21g7cctFGJ/T/Ir3Xck8hxGfR4PJYZOO4x01pjMpngN3/zN3F4eIjt7W2xs7HCdXp6islkgt3dXVFHuFyci53jOMZ4PBaC2Gg0cPnyZezs7OD8/ByDwUA66W7cuIGdnR0AwPb2tlguOTSEg0XOz8/FFsgdZayGNRoNDAaDjURMDho5Pz+XC/75fI5ms4lbt25tkKxiETmTvDiOZd6uVCrJ6+KibC5EZ6snJzEmSYLT01OxX3K0f7VaRb/fRxRF6Pf7WCwW6Pf7ODw8xJUrVyQgpVwuiwWRA0NY6WLCygSoVqshiiKMRiNUKhXU63U89NBDEjCyu7srqZsAMBgMcPnyZVHAeCauVqvBGIMoitBqtZAkCebzOc7OzqTcPQxDjEYjRFGE9XqNOI4lTXQ8HqPT6YjStru7K8eEZ/QGg4GcO+6KOz8/x9HRERqNhii6HMbC/Xir1QoHBwe4cuWKnL8XXnhBSCbPe95vIG2gAwVdUi7yH9CRvVqOxxmyskK4zGAUIakQkgYhLduL6KQJ6ETZYBMDS6yUVeMM5UqLEiXFAAEhiyHk5MZ3XoVKgNLQwKh99D45Q/DcIcw6sWpYqeTm3xyx0wbkFHCzWoPIWBJUJMmurJu0FkskOYJnNnLsHTnjcBPAkr0oskQQVqkrWicpCGxCpVPXViYv+p7qDCWKoKExdwrekkkaICS0SoQljLR0rkyKH7n5ixhq4L0/+2dRfU8JICBbK6jYYLmvrRo3VYCyBDq8IKQViPXRWldZTcv74sp9Y9MqAWSRJXEqNWK7VCkAMpawG1hCXhAcyRgJMRFrY8DDdLntkrc1pmDv5GAUFklXRoiazFOmQMB218xWLHBHnlEGmSOqbPvlNEsOQdEhgWKDdV1Bh1SYl/Pw8PDw+FKgHAV4x0NdvOOhLgDr5rrZnzs75gD/4dfv4Ac//GkoIjy538TbrnbwtqttPLrTwENbVVTj+zDB2+OLxj3PJqsXHHzBNkYAG2EZSZLg+PhYyFyz2ZSADCYPPE/GhIYDLiqVCqbTqRRfsz1za2tL4ug5en8ymUjJOJMVAEIgOQyDZ2s4ybBoKywWgPPPnLrIXWT8+PPzc1SrVSyXS4nE39nZwXq9lm44wKp4g8FAEiI5pZGtiHt7e9KbxgXqnFrJdQiVSgWdTkfm+QCILbBcLmO5XGJrawvdblfICBMktliyglZUnVihLCpfcRwjc/NDXGXAls7ZbCYF47xNtVqVqgk+xkA+/wdALJVbW1uYz+dihd3Z2ZE0SSbTHHTDHxSsVitRS4v7bbfb8h7jgJY0TdFqtTCbzUSFDcNQ1M7Dw0Mhz6wg8jnm0Jz7DTpWLo1QIVhpGCLomBDOtQudME5psXKPjqyvLTMAxgQdunk4bQkGgYTEAZuWO0POHUmwc3ahnXUyClhsE4I1MHyshq3bVVCUQM/mILZYSkVABpO6oJGUZSSTK3iO1JF7H4rJo1gv4OyRFIUwhQRLsYSw1ZgJmCKYxGzeRiTBJgoKGhqRY4MKColJETkr6L8//ChKFGFlEiTGYGkMnI5orZUFJ0p0EoutMbiIbBl7SpJeySEfkubo1LiMq+scmQtnkLoAPv4qs8fcVgGQ9MC5l+Neu0seITdn584nAAku4QoK4/bF9/HcHjL7XJmy85as3BUrDkxAos65kT9LFLVBWiCKNgzFwIQktQWUuRyWLJ+jY2vp3Z1zHh4eHh5fWhARrvVquNar4dvefgAAmCwT/PqtEZ69aVW7f/drtzGc22u4S60yHt6qydfrtmt4eKuOg04FUXD/OZc8Xh4vm1rJqgqnArJSwvczEQOAF154AU8++aQQh06nI6EYaZqiXC4LEeK0xNVqhUajIR1vbHvc2trCzs6OzHpxJcEv/uIv4vT0VGadjDG4uLiQ8BAmOUw4eH6sXC4LqeNyayYpaZqi2WxiOp2K1TGOY3Q6HSFHXF4+n89RrValb41tmxy9nyQJlsslyuWyEAxOseQ+ObZ9xnEsc1/L5VIIzNnZmcygjUYjHB8fi0LHRKTdbmM+n8vxAyCq5tnZmfTWFQlStVqVx25tbYlFMYoi3Lx5U3rqOCCk27Wf9Ozv7+Po6AjdbleSInm9WZZtBJLM53NZe7VaxWg0ErskHxMm5qPRSJIv+bxMJhMJTGEyvFgssLW1JWow1zDwLCMRyUzd3t4eLi4ucOXKFZyfn+PatWsb85j3YyF4WiaEC6vQGFfEHSzz340LqVCOyFT6GjoAkqoCGSCaEpK6vYBPaoCJLMnQkYFKyM5epYBaE7KysQKYBpASwqVVb7KyDazISsBsnxB/1WXUbs2gPnMTcP1xoEJFAJBbLBlaCymzyZRuhi4IYFyPIYWhVeuMAYX2vUxxZOsK2FJJJAqfCsO8e85ofODwGUQUYGUShAiQIsO3Xn4HAOCDt5+VpawKJC4xluAlJrMEDwkCAInNiUHVcZaLjPCJ9SXrEo1sfUA4t+plqU8SRkJrd2zX1saoAyCtGKkPAAGYEMIpEC4MKLMdgUA+v8aqXFqifNaNuZM7rFyuDQA6dkmlZFW10BFHg01yZtMr8/OiklzN41k9HVnSlZUBrcmtx8j8mw08MTJ/Z8hI7YFxX8E6n8NTiVPgJHHTvpc8PDw8PF49NMoRvv7RLXz9o1sA7PXyYJ7gs+dTvHg2w2fP7dfHbgzw2fMZVqlGqAhXu1VH7Cy5Y6K30yj5+bv7FPckcpyGyP1pHNvPBAaAfNdao91uYzweI01TdPcIcrkAACedSURBVLtdzGYzSZfksunBYIBGoyEqi9ZayCKrJ6y+JEmCWq2GVqslF+71eh39fl9UtTRNhWgWLZpMxiaTiYSO8IV8lmUyPwVA5v9YHeIwDb6/qPywPZTLzIfDoaQkApDn5i40Lho/OzvbsGHu7u6iVqvh9u3bQv7YwsqBLqwUsn2QUyp5Bo1LtJmoAXmZOFtGeQ0cMsO3s9rH8f0c5sKve7lcYjKZ4PLly0iSRMJVmFjx7NxwOJQ5Sg4g4a8wDDGZTERpZEJVnJvjDwV4hrLT6YjCuLe3hyRJZHaPQ2S4y5DVHa5kCF1P2eXLlyUgJQgCjMdjhGG40Tl4PyFIDMhwlKC7sRARDzjVZ2mgDBCsMiT1AFlsL9LjMfeBWdKWxUDayPdTDMSw+2KS6G5wRKJo0Vt2FGqHNvFRVSu2Q269AuLIJlGyKsadfU69lVoBV/htlLICDds0+Sn5PBhjSV+SwMDZNbl0HBCVjs+1AuG9+08JacuMwYePfg2JyVwFGmFqNlmEIjsXF5HdPqIAiSt0y0DIYFAlhQSEflpHVjYgAwRLglpblZPnznRg5+N0bAlXMAPSMmzvX2Dyc0b5XBsroSqzNkSVmoL8BiFhbHk0PPNmcq7MQSQb6ZROzWM7riFra7SzkvbYigrLfXIKkqbJXW86BFRCUGv7XgTldQVcZaGDgvJXJKxF9c3k7zcPDw8Pj/sLRIRuLUa31sXT17ob92ltcGe8xGfPZnjREb3PnEzx4d84weFgDm2AahzkCt5WDQ9v50SvVfHpma8m7knkWq2WqEycDBkEAebzuaQvcnBHFEXY398X0sZ2Rp6r2traAhHh8PBQFJW9vT2Z42KCw6SLiQXbMXnWrd1ui3I2mUywWCzQaDQwHA6RJImQDk5GZIWI0x25Y+zi4gJAbrccjUY4Pz+X0BOuKGBljwM1OEkxyzIkSSKqY7EDjgNFWH3i2gGO9GfixooY2w0BbCiUTIiKKpLWWpIoebZsuVxKcAmrgVy3wMRsPp8jTW0P2HK5RK1Wk2RKriBg4rpcLnF0dITd3V2Uy2X0ej10u11J3mRV9vz8XFRZDqXhMBROBi2Xyzg9PRUyzl/lchm1Wg3L5RL1el1K31utFi5fvixzeLyu2WyGs7MzpGkq4StXr14FAFxcXKDRaCBJEnS7XVF1tdZSzq61xmAw2LCG3i8I5xppRSGcWwsjzzXpyAVgGJ6pIpiAC5cJ5X5m1btagHgKrJrKWeaABRHSOgBtL9JNYCRwErD7JBQIQqEfLFhblTBpxohd4qMeT0HlkiNl61xtcx8cQFvVRubg3L8LFMfOaknQ6wQqdmSNiR8Ho0hnnJWmjEs+tYmXCT58++PIjMbC9b4BBA2DBBmmeomELZZE0MYggw1UyWAQkZL7E6OhQHAuRAQwKLvHAIRHS8dovX6A4a02gmVg59YUkJWMWCh1ZK2E66ZV7bKyQWlI1u5acWXsqT2OEoCiCGqpQc5aaRSfzwJ/L5IgcrdnNuofBJBT1yRQJcnVMpVCzj0HjWwQqgJZpMyGmOgAEqyiQpt3A6LC+w1S+s1F4jx3l8WQFFRiMmnsE4VL113o4eHh4fFAQCnC5XYFl9sVUfAYqzTDrf58Q8X71c/28S8/egvnU/vBaa8W46BTQacWo1uN0a7G6Naiu36P0alF6FRjb998hXFPIjcajUSBY8sh2yZZBeHSag7maDabcqHNqZcnJyfo9Xool8tC3vr9PobDoRA/DqRgRW00GkmS4nq9xosvvohWqyVWzSzLMJ/PpSSbFSaO8mclcblcCmnj2zhmn5MPoygSVYtJDhFhNBrh6tWrmE6novB0Oh2ZpSuVSpjP5+h2u3J7s9kUi+TVq1dl9qxcLmM4HGI0GiFNU1Gprly5gtVqhfF4LN1wgLU/MvF47rnnpBhba41erydkmucN+TUwcQvDUMrPoyjCdDqVlEsOiMmyTIJHtre35diu12vpret0OpjP58iyDO12W8geB7c0Gg1sbW3Je4KVsqOjI1Hp4jiW9wfPx/HrTNMU/X4flUoF3W4XOzs7ch+rmtw/1+12xVqapqmkohaTQ7vdLkajEebzOS4uLkTB5A8Ebt269aX4G/otIYuVVUFSg6xEyEoKwVI7RcRArazaZhRBrQ10rBAu7FV6VlFQa7ZccsolQaUKSd3Ov6VVgEyh38uFVdj5plyt0bG7MM+AtA4suyH+w6d/Dt/+xHugahWYJK8Q0LMZPnj7Wbz/4OlcNiIC4njzxTFJY2JXLsEkKcxiCapVLRFcryVExWQZPnz4Mbx3/ymAaKNSYGVS9z1BiSIoEKoUQ4FQIoORXmKpNZYGSEAIoLEVBAhAEnwSkcLSqXeAHUebwyAxBsdpCzW1wpu27+BXphUkswrU2h6TcG5DSZK6QbAi6Nggrdi5xOZnLamzFkNCuHCHw83E2V+ALKacTBlAK7Y0ujTScn4fx/sblc/RcUG3SvMEyWDtCspjd7uGBJLokBBonl+DkDkd205BJny6lMu/ogSuCSqxz5NWKS8VZ6hciLPKHslrtemZfkjOw8PD47WAUhjg9TsNvH6n8ZL7xssE1x25uz1cYDhP0J+tcbM/w6/dWmPgfh8tNj9Eb5RCdGqxI3qW3HVqjuxVY3Sq0cbv7Wrkyd/L4GULwZkksRLEs07T6VSULFaq4jhGmqbY3t6W3q71ei1JkUSES5cuodVqCbnhomzeP8/NcUcYR8xPJhMhbsVuO8CSL1abOp2OWCGZeE6nU7HWscWTFTBWw7jTjefxmITyXF25XEalUkGz2ZQ6gTt37oiqxMepqBhxuAf3m9XrdVEoOTlyMBiIKlev1zEej1GtVnFxcYGrV6/i+PgY7XYbFxcXomZ1u115Lax8FhMx4ziWBM1ioAhbPieTCQCg0Wig3++jVquhWq1KIA0nj7INkVUxDqIBrGLJFQYrN8PU6XSgtcZoNNro+dva2sJoNJIicbaDsj12vV4LuWYrZLVaRa1WQ7/fl2AYTjU9Pz8Xks+vv5jKORqNJBF0a2tLCGmpVLove+RIG2SBQlZW0JG9gGYFzl7AW4uiSjVUopHUQ6RlJXNXEi/vRJBgbRDNDFQCrBsu8CSzF+RprXCBXegE27BxKvu17CpMTWLVtQzQiyWUK/qmMMT7D54GBYGkSpIim2gZR4Ax0C60B8gDSrLx1G5ntCVw3DFXKGp/78HTAPJi8g8efgzv3X87/vWtXy6oa4mkU2oAiclciAkwdwwlAbBySlwGIIPBUqcIyAbFLI1CTBqJ85iWVYKLrI5KkKBRX2AUl0EpSe2DTZV0pGZNorwlNVc/kFnSbJZW6TKF/3OsCuZKwBWf98L5d6qbDrnXzW1rDDQRKDOOxEEYlMosOeRzSe48G6eOAoVuOKfwmZDc/CRgQrNhr7UkD2KRtMXz7rWQc2xyNQE7a2M7D2cCAKklrlJA7uHh4eHxmkazHEnn3cshzTRGiwSD+Rr9mSV3w/ka/fkag5m97bPnMzx7c+B+X2O83Iw/LoUKlThANQpQjgNU4wCVKEAlDlGJFKpxiHJkb6vGASpyv/29eF+5sE01ClGOFUrh/Td684XiZYlcrVaTJEWeZwrDEPV6XWx6jUYDzWZTFCG2YhZTFXd3d2GMkQtzvvBvNBo4OTnBcDgUhY5j+1ld+sxnPoNyuSwEJI5j3LlzB6enp9I1xmEnnPi4Wq1EWeN0SgCSghgEgYR+cGE0K0U8M9dut9FsNgFAyBl3roVhiP39fSFNTz75pNgZmahFUYQwDHF+fi7HdHd3VxSuWq2G09NThGGITqcjPXSsdt68eRMA0Ov1hGgyqQVyxYqDYpiQcUT/arVCq9XCer3G6emppIMOBgOMx2MsFgu0Wi05l/y6F4uFpHXevn0bV69eRa/XE8siE/bXv/71sgY+1rdv35bzy8ebbZ27u7syt8izk6vVSoh2kiSYzWZiaWU7rFIKtVpNVFiur2DCBmAjRGY6nSKOY7z1rW/dUGr7/T4Gg8Er95fzCoEj5Sk1CFe2S84oe/GuMgO1ysQOR06NCVZGQlCooITYeSlCNNOIJwbxVCGpWjvmyhCyCgANBCuSyHy5EAfktuVuhm/5jo/gVhrh737qw1gahV5g0FFlfMuV34YP3vpPeP+Vd+QJkjqz/jwgLxgP85m3YgecySw5e//B0/jw7Y8DsEQMsDNuABA4H+jKJMiMwb89/FVww7mdedOYmyUyYxBwh6RT4hQMNAhlyrA2NtQkIKCvgQhABIO+jpGYAA21hoLBma4igMbSRKgHK3SqCwwqTahVCJNZ1Ywy17dG+ayacp184cwSvZBnDR1J0wEhYHukI0fKpVJqPuaBSw6lnMRJnUAGBC5ZMlgZmUtT7rwTd7YTST8dh6TwDCUZS8KKNQl2bs6lZ7LPVuVCmo6AtJbXGHC5PJNQU9hfUierRiZWQdYB8noEDw8PD4+veISBQq9eQq/+hSeHp5nGcJEIsZuvM8zXGRZJhsU6dd815kmKpbtvskxwNlkWtrPf5+vMbpNkyPRLHSNRQHjur7//lXzJX1bck8hxpH0URahUKkKSuCaAVZ8gCDCdTkUVY0RRhMlkgmq1ivF4jDiOpUgagPTDcbohp06y+sIF5IvFQqya9Xod5+fnuHnz5oYClWUZFouFBFtUq1UhUxxAwkXhfGHPqZWNRkNCVLgfLo5jqUHggm5+rWzd5PTKdrstMf88d8bEiENLmPBx0mStVpOZryRJpL+NiDAcDjGbzbBarSRgpVj6zcEurKDN53N5PcUCdt4f2xu5zqEYxjKbzSQ8hElTr9eTWUW21PJxZUtokiSi8rXbbQkj4dJ2rTVarZaskwNO2ObIJLdYvs7KHldaVCoVUfeMMULQmExPJhMQkdQlMEnkBFFWQIuE936sHyBnf1OJveA3AaQf2xCQlQMXkGEVFZUaFwmP/Lvb1gQkKYms4hhl/XImUMhKJMEmOnS2uhXJfrhYWq0Jv3L6MB4pn+IPNF5AP8vw3dd+O37i5q/gA7c+ivcffBVUvQrj/k340M1n8E2Pfp0lbdrYqgJXKQD3j+aHb3/cWiZV/qkXB5dox3zY8phywqTJ7FybI2sRAmTIsCwobcw++LEBGcTQyApJHEtDSJyvMXK3ZSBMdAxFGksdQUNhmNUQKo1MW7trVtFQayXzYYjzObFgtTmHpjIXaBI4myr3tUV5rxppI8qYUbk6lsWUl3+ncD2AudWS7ZF8jtyW8hzF+Tomgiotzui59ZcMgmVurSQDm8ZZUOF4e65XIMfDdeQOcoHE8bEwbr5Sh5SXint4eHh4eHyRCAOFrXoJW/8V5O8LwTrVd5G8FKv0wf5P655EjglBtVrFdDoVssR1AnwxPhgMUCqV0Gw2US6XxW7HNkie/zLGYDaboVqtilIUBIHYDjnkg4kNR/tzETnbMLvdrgSGzGYzNJtNITNssWNC2G63QURYrVYol8vodDpotVpoNpuIogi7u7uSsMkKE4eiMOHi9E0mPhzswV1rg8EA0+kU5XJZOs44cCQIAgki4Tm2RqOBs7MzrNdrTKdTnJycoFarYXd3F9evX0eSJDDGoNVq4ezsDIC1TnJPXb/fB5AnPWZZJuSVw2i47JxDQFhFZJIKWGWT7aRMhLa3tyU9ktfLNQF87BaLhZRuP/TQQzL7ZozB+fm5HCuemSuXy5IEyu8ZYwzm8znK5bKQK66F2N/fl26+omWSA3CazaZYZJvNJtrtttRJTCYTjMdjmbnc2tqS188k9n4DZcbWtCW2GFunubrGF/M6JOjY9swRl0Onhdk0IFdzwHZMAqUa0dRaNeMhUB6EMK66IC0Dyy2nFDllLitbEhJOFfo/dwk/FPxe/BABD/34KYLtMRJkSEyGDxw+g2995Oug2i3o0QTf9LqvAWDn3WwipQ1J4bJvGG1n3QiAzqziRla6SpHbKuc6kcCSiJSEldjagMz2xBkgA6dUWgtlZiwxS4xCREzigBWncJoAiVFIjMKSDDIQZrqEgDQCYxBThtPMqnJ3lk2cT2ugWAML10vnyBWluRWVVTm2tVJm7bDxxCCpE5IqIZoZBIlNgyzaGDXloSH23LkXw+NqxToCtjMaN2fHqZIOxW43IC8MD1ywCYetwADx1CBbWdK1brteONeRx/14KJSbw9j3hXY1C8U1yet3HwysmyRrZ9uvh4eHh4fH/YQ4VIhD9ZpK2rwnkeOAD55rYnWGi7w5qp+VKA77OD09lcAPJjJHR0fY3t6WOa/JZCJx8WEYYjgc4o1vfKMUT49GI3z84x+HUgoXFxei2PBsGxePz2YzmQ/jFE1Wc7gqoFar4eDgAPv7+9jZ2cHe3p6UipfLZRhjxEY6Go1wcnIi+7hz5w5WqxVOTk7Ernjjxg3M53OZ2bp9+7aofQcHB9BaS8qj1hqdTkei97lzj2e7OK3x7OwMd+7cgTFmowKgWq3i+PgYFxcXkvbJBeVMYplw8izfYDCQubaLiwuZV+Nid54/BCBWSn58o9FAHMdSEs5l3ZxCOZlM0O12N147z0fyrCCAjRnGZrOJMAxl5pKJP9dJMGHn9XCNBCuurKS1221RJbmnjqskeM1KqY1k02LK5nq9xsMPP/yK/wH9lmGsGpdWrfIWzl1oSWTVNx05lW2lN2bajEsYJGOJmw6t9ZKMgY4UglUGSm04CmC3sfswCDox0opCsAZGr7cX6jZ0w16Al8+c9dI6izF66xYWvW1885/7c6j9f57BO55d41uevY1//6YdUBCAGg2Y2QyqWoVZJzbEJMtsamXRxkAKFJCbg7O/f+vld+AnDj9qSSJs5r4CAKNFeQuIUHVdcABQJsLcGEy0QtnJPxEMIsoJHiMiR/wMYWYiwABDXUWEDBNdQeYkro9MHsEwqeLXTi5juYxgEgVUMyRKIVgFklqpMstPw7kR1Us7pS6tuH43ApQx0DGQcTG74Vk52ggzYQWLUiMhNPYBue02i6w9FrDnP+MOt7XdJlxZu6YJgHBp5bW0TMhiO3MZzQ2ymJMu7b6DBUARRF0DHHnTgGKVN3QNEyZXfuVUslrIYTnu/0TKbDiPh4eHh4fHVwKI6AcBfDWAmwC+1xiz/nI+/z2JXLvdxmw2k16ycrksgR4MVtEAG9HPShDb24qF3AA2qgFYvRoMBojjWObFADsXxnY/tttxwiWTptlshl6vB6UURqOR9JZFUYRms4lut4tms4lGoyF2wW63i0cffVTIA1vvlFI4Pz/HYDDA2dmZqJD8mieTifS2LZdLPP/881IBwIpYGIa4ffs26vW6WCzjOMbZ2dlGeAsHgHBP3ng8FsWIZwFZDZ3NZpIkCUAUQyaErLQVS9oBSF8ck1smzUyQsizbKC0/PT2Vc8Sq6nQ6xfb2tpA4DkBhBbRUKqHX6wnhY2snz8AxUVssFnJ8uNeP11dcI6+P7aL7+/uYz+cbtQIcRMPvPQ7gASCEldM5ueCcVV+ew7vfoNYZdBxY5SSwgSE2NMLNycEqcnCErWhbI7YDsOoC42yA1n6ZlQNksQJpA8WR8KzapQbxxCCaBpaMhHZ2Lqnb3jTtQi7SqsHkisKyZzDfC1C7+QQ+9kcy4DPX8YFbvwAA+N2v+1pbBh6Fdg4uTcE1Apa8BZD+A0fOKLCevJ+89awoZ0BOwpjEzY0lRaXAeUkBBG4WLiaNgKwipwGUCJhoG2Jyd75VBrJEzygEMNBQUC4lZG0CjNMKVjqEMZRnv4Qa4cx1ZcYGap2TZybaEjYDSF2ASiB2TOMSK1Vm36s6dOeZX29qzxmrbMX9sSIbJJbMUS5wWhJZ3M6RKrtdcW7SvR8MSbddsHZBOHfxrbyiALld06mHKkHeP+huQ0GR5OMiNk4PDw8PD4/XOIjobQD2jDHvIqL/AcC3A/iXX8413JPIcQIh29QuLi4QhqHMORUJAl8kM8krl8sSRc/WOQ6v4Dh5TlCsVCrY2dnBYDDAYrEQa+a3fdu3YTKZ4Jd+6ZfwwgsvYDweo1KpyONLpZKodZ1OB4Aln0yaOp0O3vKWt8AYgytXrmC5XGJ3dxdpmuLo6AhEhKOjI3m+1WqFfr+PW7duQSklqhpbOgFspGMOh0NR5li95EJurTXSNBWyWqlUxEZojEGj0UC1WsXu7q70xRERzs7OMJvN0O12JdDl+PhY5gy5UkEphUqlgul0KnZFVsVYteIZw2JJevHcsv2T1bnhcCh21/l8Lorbm9/8ZiRJgitXrkAphcFggHK5jKtXr4qaGEURWq0W0jQVayfP+zGJ4llBrk3odDpikTTGCNFlm+jJyYnM3LEyyOpct9sVuy8HptTrdTz22GNYr9eSfLpYLHBxcYFutyvzg/cdiMSax4oNkP8OAKEjbIYIau1+5nmmgECZU9tgf1epho4slQkXmZuXs/NqKskQzhVMoKAjhTZZq+WqZdWhcE5IqpAwj9KQkFaAaGLv7z9Zx7pJ2Gm9Ab/72hr/4cZHYJIUH7z1nxCQwnv3n3Jdbza85P0HTwNBXCj2DqDiAHq5AozG+w+exk/c+ggSoxGBkMCgRErm5taaoEHQ7gOjhjs+bRVibjIMNatxNthEu544DUveilH42igMdRUXWR2ZIWgo9NM6frH/CJ672MZ6HWI9LgGZOwerEGptj3U4y2P41QoIF06RSw3SCiGt2HqIYG274ji90YQQe6Mp5edN6gl4eYV0yWKRO1cN8Owb2x4Nv7SNuTlHMkMmnEYKvMOVfW8FTpULF1x3gY33k91Jvh4dFAhhCikTN8qRO6cQS6JmsLkeDw8PDw+P1zDeCeB/dz9/CMD34n4hcnt7exiPx6KE8GwV2+b4ol8pJbZLVt+YRNRqNVHlOByDL8jX67UoSf1+H8YYsWJmWYZWq4UgCFCv1yU1sThXx8Sk1+vJPtM0lQJqvsBntW9nZwcXFxfSC7dcLiV5c7FYYDgcYjKZSHrm6ekpJpOJPBeTLU7qLKqT/LrYusgVDfP5XI4bp0ty2AvPfXU6nY05LgA4OTnBaDQSm2TxuDMxM8bIF9/OtQRFlQyAqF2cyglAEiAnkwmUUjLzxymlvLYbN26IFXU+n+P27dt47LHHhLzWajXcuHFDFLF2uy3pkUzA4jiW2ofBYCBl30zKAQjhGw6HQlQByAcCRQspHxN+b1YqFVFMWTlkUstplgcHB7Lm+wk6ttUD0TS1XXGZlpkmGJOrGzybpW3wCaX2Qj0NA2SlwKp1mcltl0wIUm1tlosEphIhq9h6AAQutVCRU97cegIgqxrEA6sApVWg1Lfzcya0KYVpFRg+Usa//5H/iJEmQGdYmRQlhPjA7Y8JCZMoxCyD1sZWD5ACAgBGQ5VK0Mslft+Vr5YkSwojwFUZmCzD3//sz+NMl3ArbSOiFG21QJVSVEPgVhqhSikSV2ymYNBQGRIDrI2Cdv7EpQkw0WUsTYSliYTEDbMqXlxs47mLbczGZctwEgJlZCsG0oJkZYAgyYNLGHaG0aZK6simR/KMmA0V4QRSR4g4OIUK5OiuCgiGyowoYIAjZkTQsXt/kLFJmsX1uP3rwL4PstimSIZLOy+nXcgJGUfmyoTMddjJSyVrrzSU71OInluP/OyODc/UgVyNgYeHh4eHx2sHB0T0Y+7nHzfG/Lj7uQ3gyP08AtD9ci/snkSOrYdKKWitJZKeyUsxcZBtedVqVUJNer0ehsOhWCN5/o1nv7gEejgcYrVaIYoivPGNb4RSCrdu3cLP/MzPSGomq3/1eh0AcH5+jiiKpGh8Op0iCAJ0u/b4jUYjqUSIoghnZ2fo9/syE3flyhWZjdNa45d/+Zfx/PPPY7FYYDAYiL2Rg1D29vYkTTEMQ4zHY7Fdaq1lTo9VLQAS19/r9WT+bDabSTk19+uxKghASrw5CIT7+pbLJcrlshwnXjtbJFmF40AaVj/5O8+U8c/cFQdAbJpso+VwGK4AKM7jVSoVtFotAJD3RZZluHTpEs7OznDlyhVRTVktjKJIUiT5HD733HNSwaCUQr1el4RKwJLW4XCIRqOB6XSKarUqFQJBEEiHHVs+uZOQu/uICBcXF0K2q9WqJGzebwjmKdJKyYaTJBrGKWnByjI4AwMTKlHaAEArhWCdwYSEaGr/HjncxLiZOFppsWzqSEHXq0hqIaScOrDWwFWDkNTd3FYARDM3LxcCmVNj0jqQRa67rAIkLYPzaxk+PH8dfkf1RafABUhh0yYzY7AyKZZG43+5+YvYDkoIEUDD4Fsf/wbQpR2oagm6HGLweA2LbcLX/cWvRvJH7SyYJCkS8C1//6uhUmDVNcjKBrqsoerWIqsnEVDWiCoJ/sXX/GO8LlyjoUr4wKwHAIgoxdLYD4sSEyIzhLkuIYPCXMf44J03YZmGmJ7UEcwUsooGaYJaEYKVJUFZCSiPgXDp1DCXMGpLtwGAYMgeL2inWIXOVhnaRFATWjUyXBgEK+PKwQlhYpBWcwZnCiSJiRGfJyP2WWdrNECmCIacDVc7ssgziSEJWdQhkFQJ4cqI/dK+SRy5dBZQleXPS66brkjmgFwplKRTtoLereZ5eHh4eHi8dnBojPmOz3H7AIBLFEAbQP/LtiKHl60f4HmzZrMpF+az2UwKvGezmfSmsRLU6/Wws7MjM25hGOKRRx7BYrHAwcGBkJDVaoXhcCgKVavVwvPPP4/5fC5zZDs7O3j++efRarXw6KOPSl8cF3X3ej0MBgOs12uEYYijoyOZPzs7O8PZ2Rnm87l0m7GaNhqN0O/38aEPfUjmvsIwRLPZRKlUwtWrV8Xq2W63Ua/X0e12JfikVCqhUqlge3sbSimxPR4dHaFSqSDLMuzu7gLICRK/LrZe8u2XLl2SKH62qqZpKgmdJycnYtnkeUS2uDKBXiwWWK/XUEoJ6WNSVq/XhQiv12tR7lqtFrTW6Pf7GI1GSNMUW1tb0Fqj2Wzi7OwMo9FIlEZOK2XyxOSwaGN88cUX8fDDD4sV8/j4WOYagyCQ5+FKCS43f+GFF6SzEICouRcXF2i1WjJbyaodgA2Sxq95PB5jPp/j6OhIagle//rXS/UCK8D3FcjOW9n5JQNaZiBjkFVCm1ypCGqVuZkrDRMFUNqqdmk5sLUFsUJaVXnlQGAv+m3RdCTF0dw/Z8MzgHVL2Xk41wigUmDVMW7OiRA4ATOpAVnZ5PNTGgjHAf7aR78Ff7OU4h981b+AIo0yafSzKqpqhX7WxXHSwp2kjavxBf7B3/p9WLcItW/SVvWLrbKX1AlpDZhcUTKHpRKISkTOThhNCJQCeh1AL60CF64J5eshoGP82Z/8M0jLhFWb0PuNBEkjwPp7+nhq+zY+dnKATnWBSGUoBykUaWijsM4CzFcxKHEziEsFXcuARehqBAzCGYmSBW1VrGhqJGAkrThFs2YJVxoRkoZNhFSp655TQDSxxz2eahdcYm2YWYmsmueIFydZmgDIAnsfw9YC5CRMK0BX8sJwDaekOZVVpfb2VdPWKaQVm6ppAiAtW/JpwkL/nLNqvqQ+QLtqhRCiBvP7hUkrq3OGIO8bDw8PDw+P1zh+FcCfB/DPAbwXwC99uRdAxe43Dw8PDw8PDw8Pjy8GRPQxAC+8iks4AHD4Kj7/bwV+7a8OvpC1P2KMefpz3fFqp1Z6Iufh4eHh4eHh4fHAg4h+7B4WuPsefu2vDh7ktQN4SUq3h4eHh4eHh4eHh4eHx30OT+Q8PDw8PDw8PDxeC/jxz7/JfQu/9lcHD/LavbXSw8PDw8PDw8PDw8PjQYNX5Dw8PDw8PDw8PDw8PB4weCLn4eHh4eHh4eHxQIGIniaiXyCinyeiHyOiiIj+ABH9ChH9LBFdebXX+PlARH+QiM7czw/M2onoG4joZ9yx/z0P2NoVEf2v7r3zfxDRIw/S+u+Gt1Z6eHh4eHh4eHg8UCCiPQBjY8yciP4GgI8D+AEA7wLwDgB/2Bjzfa/mGl8ORKRg57Meho2v/0U8AGsnojLsun+/MWZNRBEekLUDABG9HcBfMMb8N0T0uwC8H8DX4gFZ/93wipyHh4eHh4eHh8cDBWPMsTFm7n5NADwG4DeMMWtjzC8BePOrt7ovCN8J4N8A0AAexYOz9q8FsADwH4joJ2DJz4OydsB1xhERAWgDOMODtf4NeCLn4eHh4eHh4eHxQIKIrgJ4D6wqNC7cFbw6K/r8IKIAwHcA+N/cTW08IGsHsAurIv5uAP8QwP8FD87aAeAcljz/JoD/EcB/xIO1/g14Iufh4eHh4eHh4fHAgYiaAH4EwPcCOAXQLNydvSqL+sLwhwD8mDFGu98HeHDWPgTwi8aYNYCfBfA2PDhrB4D3AlgYYx4H8PsB/Ld4sNa/gfDVXoCHh4eHh4eHh4fHfw2cqvWjAP6aMeYzblbrCSKKYe1+//lVXeDL4wkAbyOiPwRrq/w+PDhr/yiAP+d+fhuA/x0PztoZA/d9CGALwLUHbP0CH3bi4eHh4eHh4eHxQIGI/iCAHwbwCXfT3wNAsArLEsD3GGNuvUrL+4JBRM8YY76KiP4bPCBrJ6I/BeAPwFoU/88AfhsenLUHsCruZQAlAN8P4CoekPXfDU/kPDw8PDw8PDw8PDw8HjD4GTkPDw8PDw8PDw8PD48HDJ7IeXh4eHh4eHh4eHh4PGDwRM7Dw8PDw8PDw8PDw+MBgydyHh4eHh4eHh4eHh4eDxg8kfPw8PDw8PDw8PD4MoGIHiKif0NEf8TF3v9W9vV7iWjH/fw+Ivp9r8wqPR4EeCLn4eHh4eHh4eHh8eXHHwHwBRE5IrrXNfvvBbADAMaYDxljfuIVWZnHAwFfCO7h4eHh4eHh4eHx5UUHwFMAfoqI/g1sufk/BtAEcATgDwN4F4AfgO1r+7dOeXu/2+YvAXgewPsAPElEPw3g0wDqxpgfJqIfAPD7ARgAf8YY8zEieha20PttAP6dMeZvfrlerMeXBp7IeXh4eHh4eHh4eHx5MQDwawC+xRgzJaIfBPD/Nsb8LBH9eQC/D8A5LGn77cYYQ0RVY8zfJqItAD9ujHk3EX0IwA8aYz5JRH8EAIhoD8C3Avg62LLrfwzgPQDaAP4mgFsAPu5+9niA4Ymch4eHh4eHh4eHx6uLJwB8NRH9VQAVAD8CS+SeMcYYt813EdH3wCp0ey+zr4cA/LoxRgO4TkQtd/vAGHMDAIho8SV4DR5fZngi5+Hh4eHh4eHh4fHlRwIgcD//FwA/YYz5BQAgoghWUdOF7X8AwJOwtsxf/Bz7YFwH8JSbq7sKYOhuN/B4TcETOQ8PDw8PDw8PD48vP/49gB8joh8D8NcB/CMi+r+6+/7C59j+5wD8Auyc29jd9lMAfoiIPgzgGACMMcdE9P8F8Euw5O3PfulegserCcrVWg8PDw8PDw8PDw8PD48HAb5+wMPDw8PDw8PDw8PD4wGDJ3IeHh4eHh4eHh4eHh4PGDyR8/Dw8PDw8PDw8PDweMDgiZyHh4eHh4eHh4eHh8cDBk/kPDw8PDw8PDw8PDw8HjB4Iufh4eHh4eHh4eHh4fGAwRM5Dw8PDw8PDw8PDw+PBwz/fwT27mMHZakuAAAAAElFTkSuQmCC", + "text/plain": [ + "
      " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "obj = P.obj.S['SMFG00'].data[0]\n", + "prb = P.probe.S['SMFG00'].data[:]\n", + "likelihood_error = [P.runtime[\"iter_info\"][i]['error'][1] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "iterations = [P.runtime[\"iter_info\"][i]['iterations'] for i in range(len(P.runtime[\"iter_info\"]))]\n", + "fig, axes = plt.subplots(ncols=4, nrows=1, figsize=(18,4), dpi=60)\n", + "axes[0].set_title(\"Object amplitude\")\n", + "axes[0].axis('off')\n", + "axes[0].imshow(np.abs(obj)[100:-100,100:-100], cmap='gray', vmin=None, vmax=None, interpolation='none')\n", + "axes[1].set_title(\"Object phase\")\n", + "axes[1].axis('off')\n", + "axes[1].imshow(np.angle(obj)[100:-100,100:-100], vmin=-np.pi, vmax=np.pi, cmap='viridis', interpolation='none')\n", + "axes[2].set_title(\"Probe\")\n", + "axes[2].axis('off')\n", + "axes[2] = u.PtyAxis(axes[2], channel='c')\n", + "axes[2].set_data(prb[0])\n", + "axes[3].set_title(\"Convergence\")\n", + "axes[3].plot(iterations, likelihood_error)\n", + "axes[3].set_xlabel(\"Iteration\")\n", + "axes[3].set_ylabel(\"Log-likelihood error\")\n", + "axes[3].yaxis.set_label_position('right')\n", + "axes[3].tick_params(left=0, right=1, labelleft=0, labelright=1)\n", + "plt.show()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "94f4d5375db2f655aeda185c89beeef42bb9cecdb7e33c656c383e802f18953c" + }, + "kernelspec": { + "display_name": "Python 3.9.6 64-bit ('cuda11.2': conda)", + "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.9.6" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/templates/position_evaluation.py b/templates/position_evaluation.py deleted file mode 100644 index f471c9d12..000000000 --- a/templates/position_evaluation.py +++ /dev/null @@ -1,195 +0,0 @@ -import glob -import matplotlib.pyplot as plt -import numpy as np -import os - - -if __name__ == "__main__": - - pardir = os.path.abspath(os.path.join(os.getcwd(), os.pardir, os.pardir)) - - # Office pc versions - #base = "D:\Github\ptypy\\templates\positions_position_refinement\\" - base = "./positions_position_refinement/" - - engine = "DM" - - filenames = "pos_*.txt" - - filepaths = glob.glob(base + filenames) - norm_coord_idx = 0 - delimiter = ";" - psize = 56e-8 # 512x512 psize - - show_original = True - simulation = True - path_original = "./positions_theory.txt" - - # show trajectory of recovered positions - for i, path in enumerate(filepaths): - # iterate through all iterations of the reconstruction - print("Load: " + path) - data = np.loadtxt(path) - if i == 0: - # [number of iteration, positions, (y, x)] - pos_trajec = np.zeros((len(filepaths), data.shape[0], 2)) - - for j in range(data.shape[0]): - # iterate through all positions - pos_trajec[i, j, 0] = data[j, 0] - pos_trajec[i, j, 1] = data[j, 1] - - print(pos_trajec.shape) - # show reconstructed trajectories and cycle trough all positions - for i in range(pos_trajec.shape[1]): - if i == 0: - plt.figure("pos trajectory") - pos_trajec *= 1e6 - plt.plot(pos_trajec[0, i, 1], pos_trajec[0, i, 0], "x", ms=12, color="b", label="start") - else: - plt.plot(pos_trajec[0, i, 1], pos_trajec[0, i, 0], "x", ms=12, color="b") # first iteration - plt.plot(pos_trajec[:, i, 1], pos_trajec[:, i, 0], color="b") - - # show original positions which were used to calczlate the diffraction patterns - if show_original: - data_original = np.loadtxt(path_original) * 1e6 - offset = pos_trajec[-1, 0, :] - data_original[0, :] - - print(data_original[0, :]) - print(pos_trajec[-1, 0, :]) - - data_original += offset - for i in range(data_original.shape[0]): - if i == 0: - plt.plot(data_original[i, 1], data_original[i, 0], "x", ms=12, color="green", label="original") - plt.plot(data_original[i, 1], data_original[i, 0], "x", ms=12, color="green") - - # label axes - plt.xlabel("x Postion in um") - plt.ylabel("y Positon in um") - plt.legend() - - # Distance after position correction - distance_after = np.zeros((pos_trajec.shape[1], 2)) - # Distance before positon correction - distance_before = np.zeros((pos_trajec.shape[1], 2)) - - if simulation: - # caculate distance - for i in range(pos_trajec.shape[1]): - distance_after[i, 0] = pos_trajec[-1, i, 0] - data_original[i, 0] - distance_after[i, 1] = pos_trajec[-1, i, 1] - data_original[i, 1] - - distance_before[i, 0] = pos_trajec[0, i, 0] - data_original[i, 0] - distance_before[i, 1] = pos_trajec[0, i, 1] - data_original[i, 1] - - plt.figure("Residual Shift vertical") - plt.plot(distance_before[:, 0], label="Before pos corr") - plt.plot(distance_after[:, 0], label="After pos corr") - plt.legend() - - plt.figure("Residual Shift horizontal") - plt.plot(distance_before[:, 1], label="Before pos corr") - plt.plot(distance_after[:, 1], label="After pos corr") - - norm_dis_before = np.linalg.norm(distance_before, axis=1) - norm_dis_after = np.linalg.norm(distance_after, axis=1) - - plt.figure("Norm distance") - plt.plot(norm_dis_before/psize*1e-6, label="Distance before pos corr") - plt.plot(norm_dis_after/psize*1e-6, label="Distance after pos corr") - plt.xlabel("Position") - plt.ylabel("Distance in px") - - print("Mean distance to original position before pos corr: " + str(np.mean(norm_dis_before/psize*1e-6))) - print("Mean distance to original position after pos corr: " + str(np.mean(norm_dis_after/psize*1e-6))) - - # calculate error by relativ positions - # Contains the relative shift of the position to every other position for the positions that were used to calculate - # the diffractio patterns - relativ_shifts_original = np.zeros((data_original.shape[0], data_original.shape[0], 2)) - - for i in range(relativ_shifts_original.shape[0]): - for j in range(relativ_shifts_original.shape[0]): - relativ_shifts_original[i, j, 0] = data_original[i, 0] - data_original[j, 0] - relativ_shifts_original[i, j, 1] = data_original[i, 1] - data_original[j, 1] - - plt.figure("Relativ y-shifts original") - plt.imshow(relativ_shifts_original[:, :, 0], interpolation="none") - plt.colorbar() - - plt.figure("Relativ x-shifts original") - plt.imshow(relativ_shifts_original[:, :, 1], interpolation="none") - plt.colorbar() - - # calculate the relative shifts for the uncorrected data - relativ_shifts_uncorrected = np.zeros((data_original.shape[0], data_original.shape[0], 2)) - - for i in range(relativ_shifts_uncorrected.shape[0]): - for j in range(relativ_shifts_uncorrected.shape[0]): - relativ_shifts_uncorrected[i, j, 0] = pos_trajec[0, i, 0] - pos_trajec[0, j, 0] - relativ_shifts_uncorrected[i, j, 1] = pos_trajec[0, i, 1] - pos_trajec[0, j, 1] - - plt.figure("Relative y-shifts uncorrected") - plt.imshow(relativ_shifts_uncorrected[:, :, 0], interpolation="none") - plt.xlabel("Position number") - plt.ylabel("Position number") - plt.colorbar() - - plt.figure("Relative x-shifts uncorrected") - plt.imshow(relativ_shifts_uncorrected[:, :, 1], interpolation="none") - plt.xlabel("Position number") - plt.ylabel("Position number") - plt.colorbar() - - plt.figure("Relative y-shifts uncorrected difference") - plt.imshow(np.abs(relativ_shifts_uncorrected[:, :, 0] - relativ_shifts_original[:, :, 0])/psize*1e-6) - plt.xlabel("Position number") - plt.ylabel("Position number") - plt.colorbar() - - # calcuate the relativ shifts of the corrected positions - relativ_shifts_corrected = np.zeros((data_original.shape[0], data_original.shape[0], 2)) - - for i in range(relativ_shifts_corrected.shape[0]): - for j in range(relativ_shifts_corrected.shape[0]): - relativ_shifts_corrected[i, j, 0] = pos_trajec[-1, i, 0] - pos_trajec[-1, j, 0] - relativ_shifts_corrected[i, j, 1] = pos_trajec[-1, i, 1] - pos_trajec[-1, j, 1] - - plt.figure("Relative y-shifts corrected") - plt.imshow(relativ_shifts_corrected[:, :, 0], interpolation="none") - plt.xlabel("Position number") - plt.ylabel("Position number") - plt.colorbar() - - plt.figure("Relative x-shifts corrected") - plt.imshow(relativ_shifts_corrected[:, :, 1], interpolation="none") - plt.xlabel("Position number") - plt.ylabel("Position number") - plt.colorbar() - - plt.figure("y relative Difference") - plt.imshow(np.abs(relativ_shifts_corrected[:, :, 0] - relativ_shifts_original[:, :, 0])/psize*1e-6, interpolation="none") - plt.xlabel("Position number") - plt.ylabel("Position number") - plt.colorbar() - - plt.figure("x relative Difference") - plt.imshow(np.abs(relativ_shifts_corrected[:, :, 1] - relativ_shifts_original[:, :, 1])/psize*1e-6, interpolation="none") - plt.xlabel("Position number") - plt.ylabel("Position number") - plt.colorbar() - - tot_dist = np.sqrt((relativ_shifts_corrected[:, :, 1] - relativ_shifts_original[:, :, 1])**2 + (relativ_shifts_corrected[:, :, 0] - relativ_shifts_original[:, :, 0])**2)/psize*1e-6 - plt.figure("Total distance in px") - plt.imshow(tot_dist, interpolation="none") - plt.xlabel("Position number") - plt.ylabel("Position number") - plt.colorbar() - - tot_dist_uncorr = np.sqrt((relativ_shifts_uncorrected[:, :, 1] - relativ_shifts_original[:, :, 1])**2 + (relativ_shifts_uncorrected[:, :, 0] - relativ_shifts_original[:, :, 0])**2)/psize*1e-6 - print("Mean distance error to all other positions corrected: " + str(np.mean(np.mean(tot_dist, axis=0)))) - print("Mean distance error to all other positions uncorrected: " + str(np.mean(np.mean(tot_dist_uncorr, axis=0)))) - plt.legend() - - plt.show() diff --git a/templates/position_refinement.py b/templates/position_refinement/moonflower_posref_DM.py similarity index 57% rename from templates/position_refinement.py rename to templates/position_refinement/moonflower_posref_DM.py index c3a348c24..86dcbdd07 100644 --- a/templates/position_refinement.py +++ b/templates/position_refinement/moonflower_posref_DM.py @@ -3,26 +3,30 @@ of actual data. It uses the test Scan class `ptypy.core.data.MoonFlowerScan` to provide "data". """ - import numpy as np from ptypy.core import Ptycho from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + p = u.Param() # for verbose output -p.verbose_level = 4 +p.verbose_level = "info" # set home path p.io = u.Param() -p.io.home = "/tmp/ptypy/" -p.io.autosave = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.interaction = u.Param(active=False) # max 200 frames (128x128px) of diffraction data p.scans = u.Param() p.scans.MF = u.Param() # now you have to specify which ScanModel to use with scans.XX.name, # just as you have to give 'name' for engines and PtyScan subclasses. -p.scans.MF.name = 'Full' +p.scans.MF.name = 'BlockFull' p.scans.MF.data= u.Param() p.scans.MF.data.name = 'MoonFlowerScan' p.scans.MF.data.shape = 128 @@ -41,15 +45,17 @@ p.engines.engine00 = u.Param() p.engines.engine00.name = 'DM' p.engines.engine00.probe_support = 1 -# p.engines.engine00.probe_center_tol = 0.5 p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 10 p.engines.engine00.position_refinement = u.Param() p.engines.engine00.position_refinement.start = 50 -p.engines.engine00.position_refinement.stop = 990 +p.engines.engine00.position_refinement.stop = 950 p.engines.engine00.position_refinement.interval = 10 p.engines.engine00.position_refinement.nshifts = 32 -p.engines.engine00.position_refinement.amplitude = 1e-6 -p.engines.engine00.position_refinement.max_shift = 2e-6 +p.engines.engine00.position_refinement.amplitude = 5e-7 +p.engines.engine00.position_refinement.max_shift = 1e-6 +p.engines.engine00.position_refinement.method = "GridSearch" +p.engines.engine00.position_refinement.record = True # prepare and run P = Ptycho(p, level=4) @@ -58,26 +64,39 @@ a = 0. coords = [] +coords_start = [] for pname, pod in P.pods.items(): + # Save real position coords.append(np.copy(pod.ob_view.coord)) before = pod.ob_view.coord psize = pod.pr_view.psize - # print(pname) - # print(before) perturbation = psize * ((3e-7 * np.array([np.sin(a), np.cos(a)])) // psize) - new_coord = before + perturbation # make sure integer number of pixels shift - - pod.ob_view.coord = new_coord - - #pod.diff *= np.random.uniform(0.1,1)y + coords_start.append(np.copy(pod.ob_view.coord)) + #pod.diff *= np.random.uniform(0.1,1) a += 4. +coords = np.array(coords) +coords_start = np.array(coords_start) -np.savetxt("positions_theory.txt", coords) P.obj.reformat() - # Run P.run() +P.finalize() + +coords_new = [] +for pname, pod in P.pods.items(): + coords_new.append(np.copy(pod.ob_view.coord)) +coords_new = np.array(coords_new) + +import matplotlib.pyplot as plt +plt.figure(figsize=(10,10), dpi=60) +plt.title("RMSE = %.2f um" %(np.sqrt(np.sum((coords_new-coords)**2,axis=1)).mean()*1e6)) +plt.plot(coords[:,0], coords[:,1], marker='.', color='k', lw=0, label='original') +plt.plot(coords_start[:,0], coords_start[:,1], marker='x', color='r', lw=0, label='start') +plt.plot(coords_new[:,0], coords_new[:,1], marker='.', color='r', lw=0, label='end') +plt.legend() +plt.savefig("/".join([tmpdir, "ptypy", "posref_eval_dm.pdf"]), bbox_inches='tight') +plt.show() \ No newline at end of file diff --git a/templates/position_refinement/moonflower_posref_DM_pycuda.py b/templates/position_refinement/moonflower_posref_DM_pycuda.py new file mode 100644 index 000000000..e09ffbb79 --- /dev/null +++ b/templates/position_refinement/moonflower_posref_DM_pycuda.py @@ -0,0 +1,109 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +import numpy as np +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 100 +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' # or 'Full' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=1) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. +#p.scans.MF.data.add_poisson_noise = False + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_pycuda' +p.engines.engine00.probe_support = 1 +p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.position_refinement = u.Param() +p.engines.engine00.position_refinement.start = 50 +p.engines.engine00.position_refinement.stop = 950 +p.engines.engine00.position_refinement.interval = 10 +p.engines.engine00.position_refinement.nshifts = 32 +p.engines.engine00.position_refinement.amplitude = 5e-7 +p.engines.engine00.position_refinement.amplitude_decay = False +p.engines.engine00.position_refinement.max_shift = 1e-6 +p.engines.engine00.position_refinement.method = "GridSearch" +p.engines.engine00.position_refinement.record = True + +# prepare and run +P = Ptycho(p, level=4) + +# Mess up the positions +a = 0. + +coords = [] +coords_start = [] +for pname, pod in P.pods.items(): + + # Save real position + coords.append(np.copy(pod.ob_view.coord)) + before = pod.ob_view.coord + psize = pod.pr_view.psize + perturbation = psize * ((3e-7 * np.array([np.sin(a), np.cos(a)])) // psize) + new_coord = before + perturbation # make sure integer number of pixels shift + pod.ob_view.coord = new_coord + coords_start.append(np.copy(pod.ob_view.coord)) + #pod.diff *= np.random.uniform(0.1,1)y + a += 4. +coords = np.array(coords) +coords_start = np.array(coords_start) + +# update the object storage +P.obj.reformat() + +# Run +P.run() +P.finalize() + +coords_new = [] +for pname, pod in P.pods.items(): + coords_new.append(np.copy(pod.ob_view.coord)) +coords_new = np.array(coords_new) + +import matplotlib.pyplot as plt +plt.figure(figsize=(10,10), dpi=60) +plt.title("RMSE = %.2f um" %(np.sqrt(np.sum((coords_new-coords)**2,axis=1)).mean()*1e6)) +plt.plot(coords[:,0], coords[:,1], marker='.', color='k', lw=0, label='original') +plt.plot(coords_start[:,0], coords_start[:,1], marker='x', color='r', lw=0, label='start') +plt.plot(coords_new[:,0], coords_new[:,1], marker='.', color='r', lw=0, label='end') +plt.legend() +plt.savefig("/".join([tmpdir, "ptypy", "posref_eval_dm_pycuda.pdf"]), bbox_inches='tight') +plt.show() \ No newline at end of file diff --git a/templates/position_refinement/moonflower_posref_DM_serial.py b/templates/position_refinement/moonflower_posref_DM_serial.py new file mode 100644 index 000000000..5a43401e7 --- /dev/null +++ b/templates/position_refinement/moonflower_posref_DM_serial.py @@ -0,0 +1,109 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +import numpy as np +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="serial") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 100 +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' # or 'Full' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +p.scans.MF.illumination = u.Param(diversity=None) +p.scans.MF.coherence = u.Param(num_probe_modes=1) +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. +#p.scans.MF.data.add_poisson_noise = False + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM_serial' +p.engines.engine00.probe_support = 1 +p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.position_refinement = u.Param() +p.engines.engine00.position_refinement.start = 50 +p.engines.engine00.position_refinement.stop = 950 +p.engines.engine00.position_refinement.interval = 10 +p.engines.engine00.position_refinement.nshifts = 32 +p.engines.engine00.position_refinement.amplitude = 5e-7 +p.engines.engine00.position_refinement.max_shift = 1e-6 +p.engines.engine00.position_refinement.method = "GridSearch" +p.engines.engine00.position_refinement.record = True + +# prepare and run +P = Ptycho(p, level=4) + +# Mess up the positions +a = 0. + +coords = [] +coords_start = [] +for pname, pod in P.pods.items(): + + # Save real position + coords.append(np.copy(pod.ob_view.coord)) + before = pod.ob_view.coord + psize = pod.pr_view.psize + perturbation = psize * ((3e-7 * np.array([np.sin(a), np.cos(a)])) // psize) + new_coord = before + perturbation # make sure integer number of pixels shift + pod.ob_view.coord = new_coord + coords_start.append(np.copy(pod.ob_view.coord)) + #pod.diff *= np.random.uniform(0.1,1)y + a += 4. +coords = np.array(coords) +coords_start = np.array(coords_start) + +# update the object storage +P.obj.reformat() + +# Run +P.run() +P.finalize() + +coords_new = [] +for pname, pod in P.pods.items(): + coords_new.append(np.copy(pod.ob_view.coord)) +coords_new = np.array(coords_new) + +import matplotlib.pyplot as plt +plt.figure(figsize=(10,10), dpi=60) +plt.title("RMSE = %.2f um" %(np.sqrt(np.sum((coords_new-coords)**2,axis=1)).mean()*1e6)) +plt.plot(coords[:,0], coords[:,1], marker='.', color='k', lw=0, label='original') +plt.plot(coords_start[:,0], coords_start[:,1], marker='x', color='r', lw=0, label='start') +plt.plot(coords_new[:,0], coords_new[:,1], marker='.', color='r', lw=0, label='end') +plt.legend() +plt.savefig("/".join([tmpdir, "ptypy", "posref_eval_dm_serial.pdf"]), bbox_inches='tight') +plt.show() \ No newline at end of file diff --git a/templates/position_refinement/moonflower_posref_EPIE.py b/templates/position_refinement/moonflower_posref_EPIE.py new file mode 100644 index 000000000..80a2026d8 --- /dev/null +++ b/templates/position_refinement/moonflower_posref_EPIE.py @@ -0,0 +1,103 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +import numpy as np +from ptypy.core import Ptycho +from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'EPIE' +p.engines.engine00.probe_support = 1 +p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.position_refinement = u.Param() +p.engines.engine00.position_refinement.start = 50 +p.engines.engine00.position_refinement.stop = 950 +p.engines.engine00.position_refinement.interval = 10 +p.engines.engine00.position_refinement.nshifts = 32 +p.engines.engine00.position_refinement.amplitude = 5e-7 +p.engines.engine00.position_refinement.max_shift = 1e-6 +p.engines.engine00.position_refinement.method = "GridSearch" +p.engines.engine00.position_refinement.metric = "photon" +p.engines.engine00.position_refinement.record = True + +# prepare and run +P = Ptycho(p, level=4) + +# Mess up the positions in a predictible way (for MPI) +a = 0. + +coords = [] +coords_start = [] +for pname, pod in P.pods.items(): + + # Save real position + coords.append(np.copy(pod.ob_view.coord)) + before = pod.ob_view.coord + psize = pod.pr_view.psize + perturbation = psize * ((3e-7 * np.array([np.sin(a), np.cos(a)])) // psize) + new_coord = before + perturbation # make sure integer number of pixels shift + pod.ob_view.coord = new_coord + coords_start.append(np.copy(pod.ob_view.coord)) + #pod.diff *= np.random.uniform(0.1,1) + a += 4. +coords = np.array(coords) +coords_start = np.array(coords_start) + +P.obj.reformat() + +# Run +P.run() +P.finalize() + +coords_new = [] +for pname, pod in P.pods.items(): + coords_new.append(np.copy(pod.ob_view.coord)) +coords_new = np.array(coords_new) + +import matplotlib.pyplot as plt +plt.figure(figsize=(10,10), dpi=60) +plt.title("RMSE = %.2f um" %(np.sqrt(np.sum((coords_new-coords)**2,axis=1)).mean()*1e6)) +plt.plot(coords[:,0], coords[:,1], marker='.', color='k', lw=0, label='original') +plt.plot(coords_start[:,0], coords_start[:,1], marker='x', color='r', lw=0, label='start') +plt.plot(coords_new[:,0], coords_new[:,1], marker='.', color='r', lw=0, label='end') +plt.legend() +plt.savefig("/".join([tmpdir, "ptypy", "posref_eval_epie.pdf"]), bbox_inches='tight') +plt.show() \ No newline at end of file diff --git a/templates/position_refinement/moonflower_posref_EPIE_pycuda.py b/templates/position_refinement/moonflower_posref_EPIE_pycuda.py new file mode 100644 index 000000000..e25fe2bc9 --- /dev/null +++ b/templates/position_refinement/moonflower_posref_EPIE_pycuda.py @@ -0,0 +1,105 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +import numpy as np +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'EPIE_pycuda' +p.engines.engine00.probe_support = 1 +p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.position_refinement = u.Param() +p.engines.engine00.position_refinement.start = 50 +p.engines.engine00.position_refinement.stop = 950 +p.engines.engine00.position_refinement.interval = 10 +p.engines.engine00.position_refinement.nshifts = 32 +p.engines.engine00.position_refinement.amplitude = 5e-7 +p.engines.engine00.position_refinement.max_shift = 1e-6 +p.engines.engine00.position_refinement.method = "GridSearch" +p.engines.engine00.position_refinement.metric = "photon" +p.engines.engine00.position_refinement.record = True + +# prepare and run +P = Ptycho(p, level=4) + +# Mess up the positions in a predictible way (for MPI) +a = 0. + +coords = [] +coords_start = [] +for pname, pod in P.pods.items(): + + # Save real position + coords.append(np.copy(pod.ob_view.coord)) + before = pod.ob_view.coord + psize = pod.pr_view.psize + perturbation = psize * ((3e-7 * np.array([np.sin(a), np.cos(a)])) // psize) + new_coord = before + perturbation # make sure integer number of pixels shift + pod.ob_view.coord = new_coord + coords_start.append(np.copy(pod.ob_view.coord)) + #pod.diff *= np.random.uniform(0.1,1) + a += 4. +coords = np.array(coords) +coords_start = np.array(coords_start) + +P.obj.reformat() + +# Run +P.run() +P.finalize() + +coords_new = [] +for pname, pod in P.pods.items(): + coords_new.append(np.copy(pod.ob_view.coord)) +coords_new = np.array(coords_new) + +import matplotlib.pyplot as plt +plt.figure(figsize=(10,10), dpi=60) +plt.title("RMSE = %.2f um" %(np.sqrt(np.sum((coords_new-coords)**2,axis=1)).mean()*1e6)) +plt.plot(coords[:,0], coords[:,1], marker='.', color='k', lw=0, label='original') +plt.plot(coords_start[:,0], coords_start[:,1], marker='x', color='r', lw=0, label='start') +plt.plot(coords_new[:,0], coords_new[:,1], marker='.', color='r', lw=0, label='end') +plt.legend() +plt.savefig("/".join([tmpdir, "ptypy", "posref_eval_epie_pycuda.pdf"]), bbox_inches='tight') +plt.show() \ No newline at end of file diff --git a/templates/position_refinement/moonflower_posref_ML.py b/templates/position_refinement/moonflower_posref_ML.py new file mode 100644 index 000000000..08af0d5d7 --- /dev/null +++ b/templates/position_refinement/moonflower_posref_ML.py @@ -0,0 +1,110 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +import numpy as np +from ptypy.core import Ptycho +from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'Full' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'ML' +p.engines.engine00.ML_type = 'Gaussian' +p.engines.engine00.reg_del2 = True +p.engines.engine00.reg_del2_amplitude = .1 +p.engines.engine00.scale_precond = True +p.engines.engine00.scale_probe_object = 1. +p.engines.engine00.smooth_gradient = 20. +p.engines.engine00.smooth_gradient_decay = 1/50. +p.engines.engine00.floating_intensities = False +p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.position_refinement = u.Param() +p.engines.engine00.position_refinement.start = 50 +p.engines.engine00.position_refinement.stop = 950 +p.engines.engine00.position_refinement.interval = 10 +p.engines.engine00.position_refinement.nshifts = 32 +p.engines.engine00.position_refinement.amplitude = 5e-7 +p.engines.engine00.position_refinement.max_shift = 1e-6 +p.engines.engine00.position_refinement.method = "GridSearch" +p.engines.engine00.position_refinement.metric = "photon" +p.engines.engine00.position_refinement.record = True + +# prepare and run +P = Ptycho(p, level=4) + +# Mess up the positions in a predictible way (for MPI) +a = 0. + +coords = [] +coords_start = [] +for pname, pod in P.pods.items(): + + # Save real position + coords.append(np.copy(pod.ob_view.coord)) + before = pod.ob_view.coord + psize = pod.pr_view.psize + perturbation = psize * ((3e-7 * np.array([np.sin(a), np.cos(a)])) // psize) + new_coord = before + perturbation # make sure integer number of pixels shift + pod.ob_view.coord = new_coord + coords_start.append(np.copy(pod.ob_view.coord)) + #pod.diff *= np.random.uniform(0.1,1) + a += 4. +coords = np.array(coords) +coords_start = np.array(coords_start) + +P.obj.reformat() + +# Run +P.run() +P.finalize() + +coords_new = [] +for pname, pod in P.pods.items(): + coords_new.append(np.copy(pod.ob_view.coord)) +coords_new = np.array(coords_new) + +import matplotlib.pyplot as plt +plt.figure(figsize=(10,10), dpi=60) +plt.title("RMSE = %.2f um" %(np.sqrt(np.sum((coords_new-coords)**2,axis=1)).mean()*1e6)) +plt.plot(coords[:,0], coords[:,1], marker='.', color='k', lw=0, label='original') +plt.plot(coords_start[:,0], coords_start[:,1], marker='x', color='r', lw=0, label='start') +plt.plot(coords_new[:,0], coords_new[:,1], marker='.', color='r', lw=0, label='end') +plt.legend() +plt.savefig("/".join([tmpdir, "ptypy", "posref_eval_ml.pdf"]), bbox_inches='tight') +plt.show() diff --git a/templates/position_refinement/moonflower_posref_ML_pycuda.py b/templates/position_refinement/moonflower_posref_ML_pycuda.py new file mode 100644 index 000000000..62cfd7fab --- /dev/null +++ b/templates/position_refinement/moonflower_posref_ML_pycuda.py @@ -0,0 +1,115 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +import numpy as np +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 100 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'ML_pycuda' +p.engines.engine00.ML_type = 'Gaussian' +p.engines.engine00.reg_del2 = True +p.engines.engine00.reg_del2_amplitude = .1 +p.engines.engine00.scale_precond = True +p.engines.engine00.scale_probe_object = 1. +p.engines.engine00.smooth_gradient = 20. +p.engines.engine00.smooth_gradient_decay = 1/50. +p.engines.engine00.floating_intensities = False +p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.position_refinement = u.Param() +p.engines.engine00.position_refinement.start = 50 +p.engines.engine00.position_refinement.stop = 950 +p.engines.engine00.position_refinement.interval = 10 +p.engines.engine00.position_refinement.nshifts = 32 +p.engines.engine00.position_refinement.amplitude = 5e-7 +p.engines.engine00.position_refinement.max_shift = 1e-6 +p.engines.engine00.position_refinement.method = "GridSearch" +p.engines.engine00.position_refinement.metric = "photon" +p.engines.engine00.position_refinement.record = True + +# prepare and run +P = Ptycho(p, level=4) + +# Mess up the positions in a predictible way (for MPI) +a = 0. + +coords = [] +coords_start = [] +for pname, pod in P.pods.items(): + + # Save real position + coords.append(np.copy(pod.ob_view.coord)) + before = pod.ob_view.coord + psize = pod.pr_view.psize + perturbation = psize * ((3e-7 * np.array([np.sin(a), np.cos(a)])) // psize) + new_coord = before + perturbation # make sure integer number of pixels shift + pod.ob_view.coord = new_coord + coords_start.append(np.copy(pod.ob_view.coord)) + #pod.diff *= np.random.uniform(0.1,1) + a += 4. +coords = np.array(coords) +coords_start = np.array(coords_start) + +#np.savetxt("positions_theory.txt", coords) +#np.savetxt("positions_start.txt", coords_start) +P.obj.reformat() + +# Run +P.run() +P.finalize() + +coords_new = [] +for pname, pod in P.pods.items(): + coords_new.append(np.copy(pod.ob_view.coord)) +coords_new = np.array(coords_new) + +import matplotlib.pyplot as plt +plt.figure(figsize=(10,10), dpi=60) +plt.title("RMSE = %.2f um" %(np.sqrt(np.sum((coords_new-coords)**2,axis=1)).mean()*1e6)) +plt.plot(coords[:,0], coords[:,1], marker='.', color='k', lw=0, label='original') +plt.plot(coords_start[:,0], coords_start[:,1], marker='x', color='r', lw=0, label='start') +plt.plot(coords_new[:,0], coords_new[:,1], marker='.', color='r', lw=0, label='end') +plt.legend() +plt.savefig("/".join([tmpdir, "ptypy", "posref_eval_ml_pycuda.pdf"]), bbox_inches='tight') +plt.show() \ No newline at end of file diff --git a/templates/position_refinement/moonflower_posref_ML_serial.py b/templates/position_refinement/moonflower_posref_ML_serial.py new file mode 100644 index 000000000..acfc34885 --- /dev/null +++ b/templates/position_refinement/moonflower_posref_ML_serial.py @@ -0,0 +1,112 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +import numpy as np +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="serial") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" +p.frames_per_block = 100 + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'ML_serial' +p.engines.engine00.ML_type = 'Gaussian' +p.engines.engine00.reg_del2 = True +p.engines.engine00.reg_del2_amplitude = .1 +p.engines.engine00.scale_precond = True +p.engines.engine00.scale_probe_object = 1. +p.engines.engine00.smooth_gradient = 20. +p.engines.engine00.smooth_gradient_decay = 1/50. +p.engines.engine00.floating_intensities = False +p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.position_refinement = u.Param() +p.engines.engine00.position_refinement.start = 50 +p.engines.engine00.position_refinement.stop = 950 +p.engines.engine00.position_refinement.interval = 10 +p.engines.engine00.position_refinement.nshifts = 32 +p.engines.engine00.position_refinement.amplitude = 5e-7 +p.engines.engine00.position_refinement.max_shift = 1e-6 +p.engines.engine00.position_refinement.method = "GridSearch" +p.engines.engine00.position_refinement.record = True + +# prepare and run +P = Ptycho(p, level=4) + +# Mess up the positions in a predictible way (for MPI) +a = 0. + +coords = [] +coords_start = [] +for pname, pod in P.pods.items(): + + # Save real position + coords.append(np.copy(pod.ob_view.coord)) + before = pod.ob_view.coord + psize = pod.pr_view.psize + perturbation = psize * ((3e-7 * np.array([np.sin(a), np.cos(a)])) // psize) + new_coord = before + perturbation # make sure integer number of pixels shift + pod.ob_view.coord = new_coord + coords_start.append(np.copy(pod.ob_view.coord)) + #pod.diff *= np.random.uniform(0.1,1) + a += 4. +coords = np.array(coords) +coords_start = np.array(coords_start) + +P.obj.reformat() + +# Run +P.run() +P.finalize() + +coords_new = [] +for pname, pod in P.pods.items(): + coords_new.append(np.copy(pod.ob_view.coord)) +coords_new = np.array(coords_new) + +import matplotlib.pyplot as plt +plt.figure(figsize=(10,10), dpi=60) +plt.title("RMSE = %.2f um" %(np.sqrt(np.sum((coords_new-coords)**2,axis=1)).mean()*1e6)) +plt.plot(coords[:,0], coords[:,1], marker='.', color='k', lw=0, label='original') +plt.plot(coords_start[:,0], coords_start[:,1], marker='x', color='r', lw=0, label='start') +plt.plot(coords_new[:,0], coords_new[:,1], marker='.', color='r', lw=0, label='end') +plt.legend() +plt.savefig("/".join([tmpdir, "ptypy", "posref_eval_ml_serial.pdf"]), bbox_inches='tight') +plt.show() \ No newline at end of file diff --git a/templates/position_refinement/moonflower_posref_SDR.py b/templates/position_refinement/moonflower_posref_SDR.py new file mode 100644 index 000000000..47b5f5618 --- /dev/null +++ b/templates/position_refinement/moonflower_posref_SDR.py @@ -0,0 +1,103 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +import numpy as np +from ptypy.core import Ptycho +from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'SDR' +p.engines.engine00.probe_support = 1 +p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.position_refinement = u.Param() +p.engines.engine00.position_refinement.start = 50 +p.engines.engine00.position_refinement.stop = 950 +p.engines.engine00.position_refinement.interval = 10 +p.engines.engine00.position_refinement.nshifts = 32 +p.engines.engine00.position_refinement.amplitude = 1e-7 +p.engines.engine00.position_refinement.max_shift = 1e-7 +p.engines.engine00.position_refinement.method = "GridSearch" +#p.engines.engine00.position_refinement.metric = "photon" +p.engines.engine00.position_refinement.record = True + +# prepare and run +P = Ptycho(p, level=4) + +# Mess up the positions in a predictible way (for MPI) +a = 0. + +coords = [] +coords_start = [] +for pname, pod in P.pods.items(): + + # Save real position + coords.append(np.copy(pod.ob_view.coord)) + before = pod.ob_view.coord + psize = pod.pr_view.psize + perturbation = psize * ((1e-7 * np.array([np.sin(a), np.cos(a)])) // psize) + new_coord = before + perturbation # make sure integer number of pixels shift + pod.ob_view.coord = new_coord + coords_start.append(np.copy(pod.ob_view.coord)) + #pod.diff *= np.random.uniform(0.1,1) + a += 4. +coords = np.array(coords) +coords_start = np.array(coords_start) + +P.obj.reformat() + +# Run +P.run() +P.finalize() + +coords_new = [] +for pname, pod in P.pods.items(): + coords_new.append(np.copy(pod.ob_view.coord)) +coords_new = np.array(coords_new) + +import matplotlib.pyplot as plt +plt.figure(figsize=(10,10), dpi=60) +plt.title("RMSE = %.2f um" %(np.sqrt(np.sum((coords_new-coords)**2,axis=1)).mean()*1e6)) +plt.plot(coords[:,0], coords[:,1], marker='.', color='k', lw=0, label='original') +plt.plot(coords_start[:,0], coords_start[:,1], marker='x', color='r', lw=0, label='start') +plt.plot(coords_new[:,0], coords_new[:,1], marker='.', color='r', lw=0, label='end') +plt.legend() +plt.savefig("/".join([tmpdir, "ptypy", "posref_eval_sdr.pdf"]), bbox_inches='tight') +plt.show() \ No newline at end of file diff --git a/templates/position_refinement/moonflower_posref_SDR_pycuda.py b/templates/position_refinement/moonflower_posref_SDR_pycuda.py new file mode 100644 index 000000000..2e71311af --- /dev/null +++ b/templates/position_refinement/moonflower_posref_SDR_pycuda.py @@ -0,0 +1,105 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +import numpy as np +from ptypy.core import Ptycho +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines(arch="cuda") + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.interaction = u.Param(active=False) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'SDR_pycuda' +p.engines.engine00.probe_support = 1 +p.engines.engine00.numiter = 1000 +p.engines.engine00.numiter_contiguous = 10 +p.engines.engine00.position_refinement = u.Param() +p.engines.engine00.position_refinement.start = 50 +p.engines.engine00.position_refinement.stop = 950 +p.engines.engine00.position_refinement.interval = 10 +p.engines.engine00.position_refinement.nshifts = 32 +p.engines.engine00.position_refinement.amplitude = 1e-7 +p.engines.engine00.position_refinement.max_shift = 1e-7 +p.engines.engine00.position_refinement.method = "GridSearch" +#p.engines.engine00.position_refinement.metric = "photon" +p.engines.engine00.position_refinement.record = True + +# prepare and run +P = Ptycho(p, level=4) + +# Mess up the positions in a predictible way (for MPI) +a = 0. + +coords = [] +coords_start = [] +for pname, pod in P.pods.items(): + + # Save real position + coords.append(np.copy(pod.ob_view.coord)) + before = pod.ob_view.coord + psize = pod.pr_view.psize + perturbation = psize * ((1e-7 * np.array([np.sin(a), np.cos(a)])) // psize) + new_coord = before + perturbation # make sure integer number of pixels shift + pod.ob_view.coord = new_coord + coords_start.append(np.copy(pod.ob_view.coord)) + #pod.diff *= np.random.uniform(0.1,1) + a += 4. +coords = np.array(coords) +coords_start = np.array(coords_start) + +P.obj.reformat() + +# Run +P.run() +P.finalize() + +coords_new = [] +for pname, pod in P.pods.items(): + coords_new.append(np.copy(pod.ob_view.coord)) +coords_new = np.array(coords_new) + +import matplotlib.pyplot as plt +plt.figure(figsize=(10,10), dpi=60) +plt.title("RMSE = %.2f um" %(np.sqrt(np.sum((coords_new-coords)**2,axis=1)).mean()*1e6)) +plt.plot(coords[:,0], coords[:,1], marker='.', color='k', lw=0, label='original') +plt.plot(coords_start[:,0], coords_start[:,1], marker='x', color='r', lw=0, label='start') +plt.plot(coords_new[:,0], coords_new[:,1], marker='.', color='r', lw=0, label='end') +plt.legend() +plt.savefig("/".join([tmpdir, "ptypy", "posref_eval_sdr_pycuda.pdf"]), bbox_inches='tight') +plt.show() \ No newline at end of file diff --git a/templates/ptypy_i13_AuStar_farfield_9p0keV.py b/templates/ptypy_i13_AuStar_farfield.py similarity index 86% rename from templates/ptypy_i13_AuStar_farfield_9p0keV.py rename to templates/ptypy_i13_AuStar_farfield.py index cf2ad546f..731d5da53 100644 --- a/templates/ptypy_i13_AuStar_farfield_9p0keV.py +++ b/templates/ptypy_i13_AuStar_farfield.py @@ -1,18 +1,23 @@ - -import ptypy +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses a simulated Au Siemens star pattern under +experimental farfield conditions in the hard X-ray regime. +""" from ptypy.core import Ptycho from ptypy import utils as u -import numpy as np + +import tempfile +tmpdir = tempfile.gettempdir() ### PTYCHO PARAMETERS p = u.Param() -p.verbose_level = 3 +p.verbose_level = "info" p.run = None p.data_type = "single" p.run = None p.io = u.Param() -p.io.home = "/tmp/ptypy/" +p.io.home = "/".join([tmpdir, "ptypy"]) p.io.autoplot = u.Param() p.io.autoplot.layout ='nearfield' @@ -59,7 +64,7 @@ # Scan model and initial value parameters p.scans = u.Param() p.scans.scan00 = u.Param() -p.scans.scan00.name = 'Full' +p.scans.scan00.name = 'BlockFull' p.scans.scan00.coherence = u.Param() p.scans.scan00.coherence.num_probe_modes = 1 @@ -100,9 +105,9 @@ p.engines.engine00.overlap_max_iterations = 100 p.engines.engine00.fourier_relax_factor = 0.05 -#p.engines.engine01 = u.Param() -#p.engines.engine01.name = 'ML' -#p.engines.engine01.numiter = 50 +p.engines.engine01 = u.Param() +p.engines.engine01.name = 'ML' +p.engines.engine01.numiter = 50 P = Ptycho(p,level=5) diff --git a/templates/ptypy_i13_AuStar_nearfield_9p7keV.py b/templates/ptypy_i13_AuStar_nearfield.py similarity index 86% rename from templates/ptypy_i13_AuStar_nearfield_9p7keV.py rename to templates/ptypy_i13_AuStar_nearfield.py index 65e000d8b..a07f89dce 100644 --- a/templates/ptypy_i13_AuStar_nearfield_9p7keV.py +++ b/templates/ptypy_i13_AuStar_nearfield.py @@ -1,19 +1,24 @@ - -import ptypy +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses a simulated Au Siemens star pattern under +experimental nearfield conditions in the hard X-ray regime. +""" from ptypy.core import Ptycho from ptypy import utils as u -import numpy as np + +import tempfile +tmpdir = tempfile.gettempdir() ### PTYCHO PARAMETERS p = u.Param() -p.verbose_level = 3 +p.verbose_level = "info" p.run = None p.frames_per_block = 20 p.data_type = "single" p.run = None p.io = u.Param() -p.io.home = "/tmp/ptypy/" +p.io.home = "/".join([tmpdir, "ptypy"]) p.io.autoplot = u.Param() p.io.autoplot.layout ='nearfield' @@ -60,7 +65,7 @@ # Scan model and initial value parameters p.scans = u.Param() p.scans.scan00 = u.Param() -p.scans.scan00.name = 'Full' +p.scans.scan00.name = 'BlockFull' p.scans.scan00.propagation = "nearfield" p.scans.scan00.coherence = u.Param() @@ -102,9 +107,9 @@ p.engines.engine00.overlap_max_iterations = 100 p.engines.engine00.fourier_relax_factor = 0.05 -#p.engines.engine01 = u.Param() -#p.engines.engine01.name = 'ML' -#p.engines.engine01.numiter = 50 +p.engines.engine01 = u.Param() +p.engines.engine01.name = 'ML' +p.engines.engine01.numiter = 50 P = Ptycho(p,level=5) diff --git a/templates/ptypy_id22ni_AuStar_focussed_17keV.py b/templates/ptypy_id22ni_AuStar_focused.py similarity index 86% rename from templates/ptypy_id22ni_AuStar_focussed_17keV.py rename to templates/ptypy_id22ni_AuStar_focused.py index c09071fd3..34baa3926 100644 --- a/templates/ptypy_id22ni_AuStar_focussed_17keV.py +++ b/templates/ptypy_id22ni_AuStar_focused.py @@ -1,21 +1,29 @@ -import numpy as np -import ptypy +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses a simulated Au Siemens star pattern under +experimental farfield conditions and with a focused beam in the hard X-ray regime. +""" from ptypy.core import Ptycho from ptypy import utils as u + +import numpy as np +import tempfile +tmpdir = tempfile.gettempdir() + p = u.Param() ### PTYCHO PARAMETERS -p.verbose_level = 3 +p.verbose_level = "info" p.data_type = "single" p.run = None p.io = u.Param() -p.io.home = "/tmp/ptypy/" +p.io.home = "/".join([tmpdir, "ptypy"]) p.io.autoplot = u.Param() p.io.autoplot.layout='weak' -p.io.autosave = None -p.io.interaction = u.Param() +p.io.autosave = u.Param(active=False) +p.io.interaction = u.Param(active=True) # Simulation parameters sim = u.Param() @@ -63,7 +71,7 @@ # Scan model and initial value parameters p.scans = u.Param() p.scans.scan00 = u.Param() -p.scans.scan00.name = 'Full' +p.scans.scan00.name = 'BlockFull' p.scans.scan00.coherence = u.Param() p.scans.scan00.coherence.num_probe_modes = 4 @@ -106,5 +114,5 @@ p.engines.engine00.overlap_max_iterations = 100 p.engines.engine00.obj_smooth_std = 5 -u.verbose.set_level(3) +u.verbose.set_level("info") P = Ptycho(p,level=5) diff --git a/templates/ptypy_laser_logo_focussed_632nm.py b/templates/ptypy_laser_logo_focused.py similarity index 77% rename from templates/ptypy_laser_logo_focussed_632nm.py rename to templates/ptypy_laser_logo_focused.py index 937265217..e9946f3fc 100644 --- a/templates/ptypy_laser_logo_focussed_632nm.py +++ b/templates/ptypy_laser_logo_focused.py @@ -1,20 +1,27 @@ -import ptypy +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses a simulated Au Siemens star pattern under +experimental farfield conditions and with a focused optical laser beam. +""" from ptypy.core import Ptycho from ptypy import utils as u import ptypy.simulations as sim -import numpy as np +import pathlib +import numpy as np +import tempfile +tmpdir = tempfile.gettempdir() ### PTYCHO PARAMETERS p = u.Param() -p.verbose_level = 3 +p.verbose_level = "info" p.data_type = "single" p.run = None p.io = u.Param() -p.io.home = "/tmp/ptypy/" -p.io.autosave = None -p.io.autoplot = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) +p.io.autosave = u.Param(active=False) +p.io.autoplot = u.Param(active=True) p.io.autoplot.layout='minimal' # Simulation parameters @@ -43,9 +50,9 @@ sim.illumination.propagation.parallel = 0.03 sim.illumination.propagation.spot_size = None -ptypy_path = ptypy.__file__.strip('ptypy.__init__.py') +imgfile = "/".join([str(pathlib.Path(__file__).parent.resolve()), '../resources/ptypy_logo_1M.png']) sim.sample = u.Param() -sim.sample.model = -u.rgb2complex(u.imload('%s/resources/ptypy_logo_1M.png' % ptypy_path)[::-1,:,:-1]) +sim.sample.model = -u.rgb2complex(u.imload(imgfile)[::-1,:,:-1]) sim.sample.process = u.Param() sim.sample.process.offset = (0,0) sim.sample.process.zoom = 0.5 @@ -61,7 +68,7 @@ # Scan model and initial value parameters p.scans = u.Param() p.scans.ptypy = u.Param() -p.scans.ptypy.name = 'Full' +p.scans.ptypy.name = 'BlockFull' p.scans.ptypy.coherence = u.Param() p.scans.ptypy.coherence.num_probe_modes=1 @@ -86,5 +93,5 @@ p.engines.engine00.numiter = 40 p.engines.engine00.fourier_relax_factor = 0.05 -u.verbose.set_level(3) +u.verbose.set_level("info") P = Ptycho(p,level=5) diff --git a/templates/make_sample_ptyd.py b/templates/ptypy_make_sample_ptyd.py similarity index 93% rename from templates/make_sample_ptyd.py rename to templates/ptypy_make_sample_ptyd.py index 09153fe05..539ea7a38 100644 --- a/templates/make_sample_ptyd.py +++ b/templates/ptypy_make_sample_ptyd.py @@ -2,13 +2,11 @@ This script creates a sample *.ptyd data file using the built-in test Scan `ptypy.core.data.MoonFlowerScan` """ -import sys import time -import ptypy from ptypy import utils as u from ptypy.core.data import MoonFlowerScan # for verbose output -u.verbose.set_level(3) +u.verbose.set_level("info") # create data parameter branch data = u.Param() diff --git a/templates/minimal_load_and_run.py b/templates/ptypy_minimal_load_and_run.py similarity index 79% rename from templates/minimal_load_and_run.py rename to templates/ptypy_minimal_load_and_run.py index 3705d42e4..21ad514fb 100644 --- a/templates/minimal_load_and_run.py +++ b/templates/ptypy_minimal_load_and_run.py @@ -2,21 +2,23 @@ This script is a test for ptychographic reconstruction after an experiment has been carried out and the data is available in ptypy's data file format in the current directory as "sample.ptyd". Use together -with `make_sample_ptyd.py`. +with `ptypy_make_sample_ptyd.py`. """ -import ptypy from ptypy.core import Ptycho from ptypy import utils as u +import tempfile +tmpdir = tempfile.gettempdir() + p = u.Param() -p.verbose_level = 3 +p.verbose_level = "info" p.io = u.Param() -p.io.home = "/tmp/ptypy/" +p.io.home = "/".join([tmpdir, "ptypy"]) p.scans = u.Param() p.scans.MF = u.Param() p.scans.MF.data= u.Param() -p.scans.MF.name = 'Vanilla' +p.scans.MF.name = 'BlockVanilla' p.scans.MF.data.name = 'PtydScan' p.scans.MF.data.source = 'file' p.scans.MF.data.dfile = 'sample.ptyd' @@ -25,9 +27,8 @@ p.engines.engine00 = u.Param() p.engines.engine00.name = 'DM' p.engines.engine00.numiter = 80 -""" p.engines.engine01 = u.Param() p.engines.engine01.name = 'ML' p.engines.engine01.numiter = 20 -""" + P = Ptycho(p,level=5) diff --git a/templates/ptypy_minimal_prep_and_run.py b/templates/ptypy_minimal_prep_and_run.py new file mode 100644 index 000000000..ea46b6320 --- /dev/null +++ b/templates/ptypy_minimal_prep_and_run.py @@ -0,0 +1,54 @@ +""" +This script is a test for ptychographic reconstruction in the absence +of actual data. It uses the test Scan class +`ptypy.core.data.MoonFlowerScan` to provide "data". +""" +from ptypy.core import Ptycho +from ptypy import utils as u + +import tempfile +tmpdir = tempfile.gettempdir() + +p = u.Param() + +# for verbose output +p.verbose_level = "info" + +# set home path +p.io = u.Param() +p.io.home = "/".join([tmpdir, "ptypy"]) + +# saving intermediate results +p.io.autosave = u.Param(active=False) + +# opens plotting GUI if interaction set to active) +p.io.autoplot = u.Param(active=True) +p.io.interaction = u.Param(active=True) + +# max 200 frames (128x128px) of diffraction data +p.scans = u.Param() +p.scans.MF = u.Param() +# now you have to specify which ScanModel to use with scans.XX.name, +# just as you have to give 'name' for engines and PtyScan subclasses. +p.scans.MF.name = 'BlockVanilla' # or 'BlockFull' +p.scans.MF.data= u.Param() +p.scans.MF.data.name = 'MoonFlowerScan' +p.scans.MF.data.shape = 128 +p.scans.MF.data.num_frames = 200 +p.scans.MF.data.save = None + +# position distance in fraction of illumination frame +p.scans.MF.data.density = 0.2 +# total number of photon in empty beam +p.scans.MF.data.photons = 1e8 +# Gaussian FWHM of possible detector blurring +p.scans.MF.data.psf = 0. + +# attach a reconstrucion engine +p.engines = u.Param() +p.engines.engine00 = u.Param() +p.engines.engine00.name = 'DM' +p.engines.engine00.numiter = 80 + +# prepare and run +P = Ptycho(p,level=5) diff --git a/test/accelerate_tests/__init__.py b/test/accelerate_tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test/accelerate_tests/base_tests/__init__.py b/test/accelerate_tests/base_tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test/accelerate_tests/base_tests/address_manglers_test.py b/test/accelerate_tests/base_tests/address_manglers_test.py new file mode 100644 index 000000000..7e27c885a --- /dev/null +++ b/test/accelerate_tests/base_tests/address_manglers_test.py @@ -0,0 +1,96 @@ +import unittest +import sys +import numpy as np +from ptypy.accelerate.base.address_manglers import BaseMangler, RandomIntMangler + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +class AddressManglersTest(unittest.TestCase): + + def setUp(self): + import sys + np.set_printoptions(threshold=sys.maxsize, linewidth=np.inf) + + def tearDown(self): + np.set_printoptions() + + def prepare_addresses(self, max_bound=10, scan_pts=2, num_modes=3): + total_number_scan_positions = scan_pts ** 2 + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + max_bound # max bound is added in the DM_serial engine. + Y = Y.reshape((total_number_scan_positions)) + max_bound + + addr_original = np.zeros((total_number_scan_positions, num_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): # + mode_idx = 0 + for pr_mode in range(num_modes): + for ob_mode in range(1): + addr_original[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + return addr_original + + def test_apply_bounding_box(self): + + scan_pts=2 + max_bound=10 + addr = self.prepare_addresses(scan_pts=scan_pts, max_bound=max_bound) + step_size = 3 + + mangler = BaseMangler(step_size, 50, 100, nshifts=1, max_bound=max_bound, ) + min_oby = 1 + max_oby = 10 + min_obx = 2 + max_obx = 9 + mangler.apply_bounding_box(addr[:,:,1,1], min_oby, max_oby) + mangler.apply_bounding_box(addr[:,:,1,2], min_obx, max_obx) + + np.testing.assert_array_less(addr[:,:,1,1], max_oby+1) + np.testing.assert_array_less(addr[:,:,1,2], max_obx+1) + np.testing.assert_array_less(min_oby-1, addr[:,:,1,1]) + np.testing.assert_array_less(min_obx-1, addr[:,:,1,2]) + + + def test_get_address(self): + # the other manglers are using the BaseMangler's get_address function + # so we set the deltas in a BaseMangler object and test get_address + + scan_pts=2 + addr_original = self.prepare_addresses(scan_pts=scan_pts) + total_number_scan_positions = scan_pts ** 2 + addr1 = np.copy(addr_original) + addr2 = np.copy(addr_original) + nshifts=1 + step_size=2 + mglr = BaseMangler(step_size, 50, 100, nshifts, max_bound=2) + # 2 shifts, with positive/negative shifting + mglr.delta = np.array([ + [1, 2], + [-4, -2] + ]) + mglr.get_address(0, addr_original, addr1, 10, 9) + mglr.get_address(1, addr_original, addr2, 10, 9) + + exp1 = np.copy(addr_original) + exp2 = np.copy(addr_original) + # element-wise here to prepare reference + for f in range(addr_original.shape[0]): + for m in range(addr_original.shape[1]): + exp1[f, m, 1, 1] = max(0, min(10, addr_original[f, m, 1, 1] + 1)) + exp1[f, m, 1, 2] = max(0, min(9, addr_original[f, m, 1, 2] + 2)) + exp2[f, m, 1, 1] = max(0, min(10, addr_original[f, m, 1, 1] - 4)) + exp2[f, m, 1, 2] = max(0, min(9, addr_original[f, m, 1, 2] - 2)) + + np.testing.assert_array_equal(addr1, exp1) + np.testing.assert_array_equal(addr2, exp2) diff --git a/test/accelerate_tests/base_tests/array_utils_test.py b/test/accelerate_tests/base_tests/array_utils_test.py new file mode 100644 index 000000000..06646b813 --- /dev/null +++ b/test/accelerate_tests/base_tests/array_utils_test.py @@ -0,0 +1,296 @@ +''' +Tests for the array_utils module +''' + +import unittest +import numpy as np +from ptypy.accelerate.base import FLOAT_TYPE, COMPLEX_TYPE +from ptypy.accelerate.base import array_utils as au + + +class ArrayUtilsTest(unittest.TestCase): + + def test_dot_resolution(self): + X, Y, Z = np.indices((3, 3, 1001), dtype=np.float32) + A = 10 ** Y + 1j * 10 ** X + out = au.dot(A, A) + np.testing.assert_array_equal(out, 60666606.0) + + def test_abs2_real_input(self): + single_dim = 50.0 + npts = single_dim ** 3 + array_to_be_absed = np.arange(npts) + absed = np.array([ix ** 2 for ix in array_to_be_absed]) + array_shape = (int(single_dim), int(single_dim), int(single_dim)) + array_to_be_absed.reshape(array_shape) + absed.reshape(array_shape) + out = au.abs2(array_to_be_absed) + np.testing.assert_array_equal(absed, out) + self.assertEqual(absed.dtype, np.float64) + + def test_abs2_complex_input(self): + single_dim = 50.0 + array_shape = (int(single_dim), int(single_dim), int(single_dim)) + npts = single_dim ** 3 + array_to_be_absed = np.arange(npts) + 1j * np.arange(npts) + absed = np.array([np.abs(ix ** 2) for ix in array_to_be_absed]) + absed.reshape(array_shape) + array_to_be_absed.reshape(array_shape) + out = au.abs2(array_to_be_absed) + np.testing.assert_array_equal(absed, out) + self.assertEqual(absed.dtype, np.float64) + + def test_sum_to_buffer(self): + + I = 4 + X = 2 + M = 4 + N = 4 + + in1 = np.empty((I, M, N), dtype=FLOAT_TYPE) + + # fill the input array + for idx in range(I): + in1[idx] = np.ones((M, N)) * (idx + 1.0) + + outshape = (X, M, N) + expected_out = np.empty(outshape) + + expected_out[0] = np.ones((M, N)) * 4.0 + expected_out[1] = np.ones((M, N)) * 6.0 + + in1_addr = np.empty((I, 3)) + + in1_addr = np.array([(0, 0, 0), + (1, 0, 0), + (2, 0, 0), + (3, 0, 0)]) + + out1_addr = np.empty_like(in1_addr) + out1_addr = np.array([(0, 0, 0), + (1, 0, 0), + (0, 0, 0), + (1, 0, 0)]) + + out = au.sum_to_buffer(in1, outshape, in1_addr, out1_addr, dtype=FLOAT_TYPE) + np.testing.assert_array_equal(out, expected_out) + + def test_sum_to_buffer_complex(self): + + I = 4 + X = 2 + M = 4 + N = 4 + + in1 = np.empty((I, M, N), dtype=COMPLEX_TYPE) + + # fill the input array + for idx in range(I): + in1[idx] = np.ones((M, N)) * (idx + 1.0) + 1j * np.ones((M, N)) * (idx + 1.0) + + outshape = (X, M, N) + expected_out = np.empty(outshape, dtype=COMPLEX_TYPE) + + expected_out[0] = np.ones((M, N)) * 4.0 + 1j * np.ones((M, N)) * 4.0 + expected_out[1] = np.ones((M, N)) * 6.0 + 1j * np.ones((M, N)) * 6.0 + + in1_addr = np.empty((I, 3)) + + in1_addr = np.array([(0, 0, 0), + (1, 0, 0), + (2, 0, 0), + (3, 0, 0)]) + + out1_addr = np.empty_like(in1_addr) + out1_addr = np.array([(0, 0, 0), + (1, 0, 0), + (0, 0, 0), + (1, 0, 0)]) + + out = au.sum_to_buffer(in1, outshape, in1_addr, out1_addr, dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(out, expected_out) + + def test_norm2_1d_real(self): + a = np.array([1.0, 2.0], dtype=FLOAT_TYPE) + out = au.norm2(a) + np.testing.assert_array_equal(out, 5.0) + + def test_norm2_1d_complex(self): + a = np.array([1.0 + 1.0j, 2.0 + 2.0j], dtype=COMPLEX_TYPE) + out = au.norm2(a) + np.testing.assert_array_equal(out, 10.0) + + def test_norm2_2d_real(self): + a = np.array([[1.0, 2.0], + [3.0, 4.0]], dtype=FLOAT_TYPE) + out = au.norm2(a) + np.testing.assert_array_equal(out, 30.0) + + def test_norm2_2d_complex(self): + a = np.array([[1.0 + 1.0j, 2.0 + 2.0j], + [3.0 + 3.0j, 4.0 + 4.0j]], dtype=COMPLEX_TYPE) + out = au.norm2(a) + np.testing.assert_array_equal(out, 60.0) + + def test_norm2_3d_real(self): + a = np.array([[[1.0, 2.0], + [3.0, 4.0]], + [[5.0, 6.0], + [7.0, 8.0]]], dtype=FLOAT_TYPE) + out = au.norm2(a) + np.testing.assert_array_equal(out, 204.0) + + def test_norm2_3d_complex(self): + a = np.array([[[1.0 + 1.0j, 2.0 + 2.0j], + [3.0 + 3.0j, 4.0 + 4.0j]], + [[5.0 + 5.0j, 6.0 + 6.0j], + [7.0 + 7.0j, 8.0 + 8.0j]]], dtype=COMPLEX_TYPE) + out = au.norm2(a) + np.testing.assert_array_equal(out, 408.0) + + def test_complex_gaussian_filter_2d(self): + data = np.zeros((8, 8), dtype=COMPLEX_TYPE) + data[3:5, 3:5] = 2.0 + 2.0j + mfs = 3.0, 4.0 + out = au.complex_gaussian_filter(data, mfs) + expected_out = np.array([0.11033735 + 0.11033735j, 0.11888228 + 0.11888228j, 0.13116673 + 0.13116673j + , 0.13999543 + 0.13999543j, 0.13999543 + 0.13999543j, 0.13116673 + 0.13116673j + , 0.11888228 + 0.11888228j, 0.11033735 + 0.11033735j], dtype=COMPLEX_TYPE) + np.testing.assert_array_almost_equal(np.diagonal(out), expected_out) + + def test_complex_gaussian_filter_2d_batched(self): + batch_number = 2 + A = 5 + B = 5 + + data = np.zeros((batch_number, A, B), dtype=COMPLEX_TYPE) + data[:, 2:3, 2:3] = 2.0 + 2.0j + mfs = 3.0, 4.0 + out = au.complex_gaussian_filter(data, mfs) + + expected_out = np.array([[[0.07988770 + 0.0798877j, 0.07989411 + 0.07989411j, 0.07989471 + 0.07989471j, + 0.07989411 + 0.07989411j, 0.07988770 + 0.0798877j], + [0.08003781 + 0.08003781j, 0.08004424 + 0.08004424j, 0.08004485 + 0.08004485j, + 0.08004424 + 0.08004424j, 0.08003781 + 0.08003781j], + [0.08012911 + 0.08012911j, 0.08013555 + 0.08013555j, 0.08013615 + 0.08013615j, + 0.08013555 + 0.08013555j, 0.08012911 + 0.08012911j], + [0.08003781 + 0.08003781j, 0.08004424 + 0.08004424j, 0.08004485 + 0.08004485j, + 0.08004424 + 0.08004424j, 0.08003781 + 0.08003781j], + [0.07988770 + 0.0798877j, 0.07989411 + 0.07989411j, 0.07989471 + 0.07989471j, + 0.07989411 + 0.07989411j, 0.07988770 + 0.0798877j]], + + [[0.07988770 + 0.0798877j, 0.07989411 + 0.07989411j, 0.07989471 + 0.07989471j, + 0.07989411 + 0.07989411j, 0.07988770 + 0.0798877j], + [0.08003781 + 0.08003781j, 0.08004424 + 0.08004424j, 0.08004485 + 0.08004485j, + 0.08004424 + 0.08004424j, 0.08003781 + 0.08003781j], + [0.08012911 + 0.08012911j, 0.08013555 + 0.08013555j, 0.08013615 + 0.08013615j, + 0.08013555 + 0.08013555j, 0.08012911 + 0.08012911j], + [0.08003781 + 0.08003781j, 0.08004424 + 0.08004424j, 0.08004485 + 0.08004485j, + 0.08004424 + 0.08004424j, 0.08003781 + 0.08003781j], + [0.07988770 + 0.0798877j, 0.07989411 + 0.07989411j, 0.07989471 + 0.07989471j, + 0.07989411 + 0.07989411j, 0.07988770 + 0.0798877j]]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_almost_equal(out, expected_out) + + def test_mass_center_2d(self): + npts = 64 + probe = np.zeros((1, npts, npts), dtype=COMPLEX_TYPE) + rad = 10.0 + probe_vals = 2 + 3j + x = np.array(range(npts)) - npts // 2 + X, Y = np.meshgrid(x, x) + Xoff = 5.0 + Yoff = 2.0 + probe[0, (X - Xoff) ** 2 + (Y - Yoff) ** 2 < rad ** 2] = probe_vals + + com = au.mass_center(np.abs(probe[0])) + expected_out = np.array([Yoff, Xoff]) + npts // 2 + np.testing.assert_array_almost_equal(com, expected_out, decimal=6) + + def test_mass_center_3d(self): + npts = 64 + probe = np.zeros((npts, npts, npts), dtype=COMPLEX_TYPE) + rad = 10.0 + probe_vals = 2 + 3j + x = np.array(range(npts)) - npts // 2 + X, Y, Z = np.meshgrid(x, x, x) + Xoff = 5.0 + Yoff = 2.0 + Zoff = 10.0 + probe[(X - Xoff) ** 2 + (Y - Yoff) ** 2 + (Z - Zoff) ** 2 < rad ** 2] = probe_vals + + com = au.mass_center(np.abs(probe)) + expected_out = np.array([Yoff, Xoff, Zoff]) + npts // 2 + np.testing.assert_array_almost_equal(com, expected_out, decimal=5) + + def test_interpolated_shift(self): + npts = 32 + probe = np.zeros((1, npts, npts), dtype=COMPLEX_TYPE) + rad = 10.0 + probe_vals = 2 + 3j + x = np.array(range(npts)) - npts // 2 + X, Y = np.meshgrid(x, x) + Xoff = 5.0 + Yoff = 2.0 + probe[0, (X - Xoff) ** 2 + (Y - Yoff) ** 2 < rad ** 2] = probe_vals + offset = np.array([-Yoff, -Xoff]) + + not_shifted_probe = np.zeros((1, npts, npts), dtype=COMPLEX_TYPE) + not_shifted_probe[0, (X) ** 2 + (Y) ** 2 < rad ** 2] = probe_vals + probe[0] = au.interpolated_shift(probe[0], offset) + np.testing.assert_array_almost_equal(probe, not_shifted_probe, decimal=8) + + def test_clip_magnitudes_to_range(self): + data = np.ones((5, 5), dtype=COMPLEX_TYPE) + data[2, 4] = 20.0 * np.exp(1j * np.pi / 2) + data[3, 1] = 0.2 * np.exp(1j * np.pi / 3) + + clip_min = 0.5 + clip_max = 2.0 + expected_out = np.ones_like(data) + expected_out[2, 4] = 2.0 * np.exp(1j * np.pi / 2) + expected_out[3, 1] = 0.5 * np.exp(1j * np.pi / 3) + au.clip_complex_magnitudes_to_range(data, clip_min, clip_max) + np.testing.assert_array_almost_equal(data, expected_out, decimal=7) # floating point precision I guess... + + def test_crop_pad_1(self): + # pad, integer, 2D + B = np.indices((4, 4), dtype=np.int32) + A = np.zeros((6, 6), dtype=B.dtype) + au.crop_pad_2d_simple(A, B.sum(0)) + exp_A = np.array([[0, 0, 0, 0, 0, 0], + [0, 0, 1, 2, 3, 0], + [0, 1, 2, 3, 4, 0], + [0, 2, 3, 4, 5, 0], + [0, 3, 4, 5, 6, 0], + [0, 0, 0, 0, 0, 0]]) + np.testing.assert_equal(A, exp_A) + + def test_crop_pad_2(self): + # crop, float, 3D + B = np.indices((4, 4), dtype=np.float32) + A = np.zeros((2, 2, 2), dtype=B.dtype) + au.crop_pad_2d_simple(A, B) + exp_A = np.array([[[1., 1.], + [2., 2.]], + [[1., 2.], + [1., 2.]]], dtype=np.float32) + np.testing.assert_array_almost_equal(A, exp_A) + + def test_crop_pad_3(self): + # crop/pad, complex, 3D + B = np.indices((4, 3), dtype=np.complex64) + B = np.indices((4, 3), dtype=np.complex64) + 1j * B[::-1, :, :] + A = np.zeros((2, 2, 5), dtype=B.dtype) + au.crop_pad_2d_simple(A, B) + exp_A = np.array([[[0. + 0.j, 1. + 0.j, 1. + 1.j, 1. + 2.j, 0. + 0.j], + [0. + 0.j, 2. + 0.j, 2. + 1.j, 2. + 2.j, 0. + 0.j]], + [[0. + 0.j, 0. + 1.j, 1. + 1.j, 2. + 1.j, 0. + 0.j], + [0. + 0.j, 0. + 2.j, 1. + 2.j, 2. + 2.j, 0. + 0.j]]], + dtype=np.complex64) + np.testing.assert_array_almost_equal(A, exp_A) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/accelerate_tests/base_tests/auxiliary_wave_kernel_test.py b/test/accelerate_tests/base_tests/auxiliary_wave_kernel_test.py new file mode 100644 index 000000000..93e753a51 --- /dev/null +++ b/test/accelerate_tests/base_tests/auxiliary_wave_kernel_test.py @@ -0,0 +1,429 @@ +''' + + +''' + +import unittest +import numpy as np +from ptypy.accelerate.base.kernels import AuxiliaryWaveKernel + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + + +class AuxiliaryWaveKernelTest(unittest.TestCase): + + def setUp(self): + import sys + np.set_printoptions(threshold=sys.maxsize, linewidth=np.inf) + + def tearDown(self): + np.set_printoptions() + + def prepare_arrays(self, scan_points = None): + B = 3 # frame size y + C = 3 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + if scan_points is None: + scan_pts = 2 # one dimensional scan point number + else: + scan_pts = scan_points + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): # + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + return addr, object_array, probe, exit_wave + + def test_build_aux_same_as_exit(self): + # setup + addr, object_array, probe, exit_wave = self.prepare_arrays() + auxiliary_wave = np.zeros_like(exit_wave) + + # test + AWK = AuxiliaryWaveKernel() + alpha_set = 1.0 + AWK.allocate() # doesn't actually do anything at the moment + AWK.build_aux(auxiliary_wave, addr, object_array, probe, exit_wave, alpha=alpha_set) + + # assert + expected_auxiliary_wave = np.array([[[-1. + 3.j, -1. + 3.j, -1. + 3.j], + [-1. + 3.j, -1. + 3.j, -1. + 3.j], + [-1. + 3.j, -1. + 3.j, -1. + 3.j]], + [[-2. + 14.j, -2. + 14.j, -2. + 14.j], + [-2. + 14.j, -2. + 14.j, -2. + 14.j], + [-2. + 14.j, -2. + 14.j, -2. + 14.j]], + [[-3. + 5.j, -3. + 5.j, -3. + 5.j], + [-3. + 5.j, -3. + 5.j, -3. + 5.j], + [-3. + 5.j, -3. + 5.j, -3. + 5.j]], + [[-4. + 28.j, -4. + 28.j, -4. + 28.j], + [-4. + 28.j, -4. + 28.j, -4. + 28.j], + [-4. + 28.j, -4. + 28.j, -4. + 28.j]], + [[-5. - 1.j, -5. - 1.j, -5. - 1.j], + [-5. - 1.j, -5. - 1.j, -5. - 1.j], + [-5. - 1.j, -5. - 1.j, -5. - 1.j]], + [[-6. + 10.j, -6. + 10.j, -6. + 10.j], + [-6. + 10.j, -6. + 10.j, -6. + 10.j], + [-6. + 10.j, -6. + 10.j, -6. + 10.j]], + [[-7. + 1.j, -7. + 1.j, -7. + 1.j], + [-7. + 1.j, -7. + 1.j, -7. + 1.j], + [-7. + 1.j, -7. + 1.j, -7. + 1.j]], + [[-8. + 24.j, -8. + 24.j, -8. + 24.j], + [-8. + 24.j, -8. + 24.j, -8. + 24.j], + [-8. + 24.j, -8. + 24.j, -8. + 24.j]], + [[-9. - 5.j, -9. - 5.j, -9. - 5.j], + [-9. - 5.j, -9. - 5.j, -9. - 5.j], + [-9. - 5.j, -9. - 5.j, -9. - 5.j]], + [[-10. + 6.j, -10. + 6.j, -10. + 6.j], + [-10. + 6.j, -10. + 6.j, -10. + 6.j], + [-10. + 6.j, -10. + 6.j, -10. + 6.j]], + [[-11. - 3.j, -11. - 3.j, -11. - 3.j], + [-11. - 3.j, -11. - 3.j, -11. - 3.j], + [-11. - 3.j, -11. - 3.j, -11. - 3.j]], + [[-12. + 20.j, -12. + 20.j, -12. + 20.j], + [-12. + 20.j, -12. + 20.j, -12. + 20.j], + [-12. + 20.j, -12. + 20.j, -12. + 20.j]], + [[-13. - 9.j, -13. - 9.j, -13. - 9.j], + [-13. - 9.j, -13. - 9.j, -13. - 9.j], + [-13. - 9.j, -13. - 9.j, -13. - 9.j]], + [[-14. + 2.j, -14. + 2.j, -14. + 2.j], + [-14. + 2.j, -14. + 2.j, -14. + 2.j], + [-14. + 2.j, -14. + 2.j, -14. + 2.j]], + [[-15. - 7.j, -15. - 7.j, -15. - 7.j], + [-15. - 7.j, -15. - 7.j, -15. - 7.j], + [-15. - 7.j, -15. - 7.j, -15. - 7.j]], + [[-16. + 16.j, -16. + 16.j, -16. + 16.j], + [-16. + 16.j, -16. + 16.j, -16. + 16.j], + [-16. + 16.j, -16. + 16.j, -16. + 16.j]]], dtype=COMPLEX_TYPE) + np.testing.assert_array_equal(expected_auxiliary_wave, expected_auxiliary_wave, + err_msg="The auxiliary_wave has not been updated as expected") + + def test_build_exit_aux_same_as_exit(self): + # setup + addr, object_array, probe, exit_wave = self.prepare_arrays() + auxiliary_wave = np.zeros_like(exit_wave) + + # test + AWK = AuxiliaryWaveKernel() + AWK.allocate() + AWK.build_exit(auxiliary_wave, addr, object_array, probe, exit_wave) + + # assert + expected_auxiliary_wave = np.array([[[0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j]], + [[0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j]], + [[0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j]], + [[0. - 16.j, 0. - 16.j, 0. - 16.j], + [0. - 16.j, 0. - 16.j, 0. - 16.j], + [0. - 16.j, 0. - 16.j, 0. - 16.j]], + [[0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j]], + [[0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j]], + [[0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j]], + [[0. - 16.j, 0. - 16.j, 0. - 16.j], + [0. - 16.j, 0. - 16.j, 0. - 16.j], + [0. - 16.j, 0. - 16.j, 0. - 16.j]], + [[0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j]], + [[0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j]], + [[0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j]], + [[0. - 16.j, 0. - 16.j, 0. - 16.j], + [0. - 16.j, 0. - 16.j, 0. - 16.j], + [0. - 16.j, 0. - 16.j, 0. - 16.j]], + [[0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j]], + [[0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j]], + [[0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j]], + [[0. - 16.j, 0. - 16.j, 0. - 16.j], + [0. - 16.j, 0. - 16.j, 0. - 16.j], + [0. - 16.j, 0. - 16.j, 0. - 16.j]]], dtype=COMPLEX_TYPE) + np.testing.assert_array_equal(auxiliary_wave, expected_auxiliary_wave, + err_msg="The auxiliary_wave has not been updated as expected") + + # assert + expected_exit_wave = np.array([[[1. - 1.j, 1. - 1.j, 1. - 1.j], + [1. - 1.j, 1. - 1.j, 1. - 1.j], + [1. - 1.j, 1. - 1.j, 1. - 1.j]], + [[2. - 6.j, 2. - 6.j, 2. - 6.j], + [2. - 6.j, 2. - 6.j, 2. - 6.j], + [2. - 6.j, 2. - 6.j, 2. - 6.j]], + [[3. - 1.j, 3. - 1.j, 3. - 1.j], + [3. - 1.j, 3. - 1.j, 3. - 1.j], + [3. - 1.j, 3. - 1.j, 3. - 1.j]], + [[4. - 12.j, 4. - 12.j, 4. - 12.j], + [4. - 12.j, 4. - 12.j, 4. - 12.j], + [4. - 12.j, 4. - 12.j, 4. - 12.j]], + [[5. + 3.j, 5. + 3.j, 5. + 3.j], + [5. + 3.j, 5. + 3.j, 5. + 3.j], + [5. + 3.j, 5. + 3.j, 5. + 3.j]], + [[6. - 2.j, 6. - 2.j, 6. - 2.j], + [6. - 2.j, 6. - 2.j, 6. - 2.j], + [6. - 2.j, 6. - 2.j, 6. - 2.j]], + [[7. + 3.j, 7. + 3.j, 7. + 3.j], + [7. + 3.j, 7. + 3.j, 7. + 3.j], + [7. + 3.j, 7. + 3.j, 7. + 3.j]], + [[8. - 8.j, 8. - 8.j, 8. - 8.j], + [8. - 8.j, 8. - 8.j, 8. - 8.j], + [8. - 8.j, 8. - 8.j, 8. - 8.j]], + [[9. + 7.j, 9. + 7.j, 9. + 7.j], + [9. + 7.j, 9. + 7.j, 9. + 7.j], + [9. + 7.j, 9. + 7.j, 9. + 7.j]], + [[10. + 2.j, 10. + 2.j, 10. + 2.j], + [10. + 2.j, 10. + 2.j, 10. + 2.j], + [10. + 2.j, 10. + 2.j, 10. + 2.j]], + [[11. + 7.j, 11. + 7.j, 11. + 7.j], + [11. + 7.j, 11. + 7.j, 11. + 7.j], + [11. + 7.j, 11. + 7.j, 11. + 7.j]], + [[12. - 4.j, 12. - 4.j, 12. - 4.j], + [12. - 4.j, 12. - 4.j, 12. - 4.j], + [12. - 4.j, 12. - 4.j, 12. - 4.j]], + [[13. + 11.j, 13. + 11.j, 13. + 11.j], + [13. + 11.j, 13. + 11.j, 13. + 11.j], + [13. + 11.j, 13. + 11.j, 13. + 11.j]], + [[14. + 6.j, 14. + 6.j, 14. + 6.j], + [14. + 6.j, 14. + 6.j, 14. + 6.j], + [14. + 6.j, 14. + 6.j, 14. + 6.j]], + [[15. + 11.j, 15. + 11.j, 15. + 11.j], + [15. + 11.j, 15. + 11.j, 15. + 11.j], + [15. + 11.j, 15. + 11.j, 15. + 11.j]], + [[16. + 0.j, 16. + 0.j, 16. + 0.j], + [16. + 0.j, 16. + 0.j, 16. + 0.j], + [16. + 0.j, 16. + 0.j, 16. + 0.j]]], dtype=COMPLEX_TYPE) + np.testing.assert_array_equal(exit_wave, expected_exit_wave, + err_msg="The exit_wave has not been updated as expected") + + def test_build_aux_no_ex(self): + # setup + addr, object_array, probe, exit_wave = self.prepare_arrays() + auxiliary_wave = np.zeros_like(exit_wave) + + # test + AWK = AuxiliaryWaveKernel() + AWK.allocate() + AWK.build_aux_no_ex(auxiliary_wave, addr, object_array, probe, fac=1.0, add=False) + + # assert + expected_auxiliary_wave = np.array([[[0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j]], + [[0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j]], + [[0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j]], + [[0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j]], + [[0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j]], + [[0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j]], + [[0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j]], + [[0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j]], + [[0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j]], + [[0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j]], + [[0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j]], + [[0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j]], + [[0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j]], + [[0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j]], + [[0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j]], + [[0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j]]], dtype=np.complex64) + np.testing.assert_array_equal(auxiliary_wave, expected_auxiliary_wave, + err_msg="The auxiliary_wave has not been updated as expected") + + # test + auxiliary_wave = exit_wave + AWK.build_aux_no_ex(auxiliary_wave, addr, object_array, probe, fac=2.0, add=True) + + # assert + expected_auxiliary_wave = np.array([[[1. + 5.j, 1. + 5.j, 1. + 5.j], + [1. + 5.j, 1. + 5.j, 1. + 5.j], + [1. + 5.j, 1. + 5.j, 1. + 5.j]], + [[2. + 18.j, 2. + 18.j, 2. + 18.j], + [2. + 18.j, 2. + 18.j, 2. + 18.j], + [2. + 18.j, 2. + 18.j, 2. + 18.j]], + [[3. + 11.j, 3. + 11.j, 3. + 11.j], + [3. + 11.j, 3. + 11.j, 3. + 11.j], + [3. + 11.j, 3. + 11.j, 3. + 11.j]], + [[4. + 36.j, 4. + 36.j, 4. + 36.j], + [4. + 36.j, 4. + 36.j, 4. + 36.j], + [4. + 36.j, 4. + 36.j, 4. + 36.j]], + [[5. + 9.j, 5. + 9.j, 5. + 9.j], + [5. + 9.j, 5. + 9.j, 5. + 9.j], + [5. + 9.j, 5. + 9.j, 5. + 9.j]], + [[6. + 22.j, 6. + 22.j, 6. + 22.j], + [6. + 22.j, 6. + 22.j, 6. + 22.j], + [6. + 22.j, 6. + 22.j, 6. + 22.j]], + [[7. + 15.j, 7. + 15.j, 7. + 15.j], + [7. + 15.j, 7. + 15.j, 7. + 15.j], + [7. + 15.j, 7. + 15.j, 7. + 15.j]], + [[8. + 40.j, 8. + 40.j, 8. + 40.j], + [8. + 40.j, 8. + 40.j, 8. + 40.j], + [8. + 40.j, 8. + 40.j, 8. + 40.j]], + [[9. + 13.j, 9. + 13.j, 9. + 13.j], + [9. + 13.j, 9. + 13.j, 9. + 13.j], + [9. + 13.j, 9. + 13.j, 9. + 13.j]], + [[10. + 26.j, 10. + 26.j, 10. + 26.j], + [10. + 26.j, 10. + 26.j, 10. + 26.j], + [10. + 26.j, 10. + 26.j, 10. + 26.j]], + [[11. + 19.j, 11. + 19.j, 11. + 19.j], + [11. + 19.j, 11. + 19.j, 11. + 19.j], + [11. + 19.j, 11. + 19.j, 11. + 19.j]], + [[12. + 44.j, 12. + 44.j, 12. + 44.j], + [12. + 44.j, 12. + 44.j, 12. + 44.j], + [12. + 44.j, 12. + 44.j, 12. + 44.j]], + [[13. + 17.j, 13. + 17.j, 13. + 17.j], + [13. + 17.j, 13. + 17.j, 13. + 17.j], + [13. + 17.j, 13. + 17.j, 13. + 17.j]], + [[14. + 30.j, 14. + 30.j, 14. + 30.j], + [14. + 30.j, 14. + 30.j, 14. + 30.j], + [14. + 30.j, 14. + 30.j, 14. + 30.j]], + [[15. + 23.j, 15. + 23.j, 15. + 23.j], + [15. + 23.j, 15. + 23.j, 15. + 23.j], + [15. + 23.j, 15. + 23.j, 15. + 23.j]], + [[16. + 48.j, 16. + 48.j, 16. + 48.j], + [16. + 48.j, 16. + 48.j, 16. + 48.j], + [16. + 48.j, 16. + 48.j, 16. + 48.j]]], dtype=np.complex64) + np.testing.assert_array_equal(auxiliary_wave, expected_auxiliary_wave, + err_msg="The auxiliary_wave has not been updated as expected") + + + def test_build_exit_alpha_tau(self): + + # setup + addr, object_array, probe, exit_wave = self.prepare_arrays(scan_points=1) + auxiliary_wave = np.zeros_like(exit_wave) + + # test + AWK = AuxiliaryWaveKernel() + AWK.allocate() + AWK.build_exit_alpha_tau(auxiliary_wave, addr, object_array, probe, exit_wave) + + # assert + expected_auxiliary_wave = np.array( + [[[0. -2.j, 0. -2.j, 0. -2.j], + [0. -2.j, 0. -2.j, 0. -2.j], + [0. -2.j, 0. -2.j, 0. -2.j]], + + [[0. -8.j, 0. -8.j, 0. -8.j], + [0. -8.j, 0. -8.j, 0. -8.j], + [0. -8.j, 0. -8.j, 0. -8.j]], + + [[0. -4.j, 0. -4.j, 0. -4.j], + [0. -4.j, 0. -4.j, 0. -4.j], + [0. -4.j, 0. -4.j, 0. -4.j]], + + [[0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j]]], dtype=np.complex64) + np.testing.assert_array_equal(auxiliary_wave, expected_auxiliary_wave, + err_msg="The auxiliary_wave has not been updated as expected") + + # assert + expected_exit_wave = np.array( + [[[1. -1.j, 1. -1.j, 1. -1.j], + [1. -1.j, 1. -1.j, 1. -1.j], + [1. -1.j, 1. -1.j, 1. -1.j]], + + [[2. -6.j, 2. -6.j, 2. -6.j], + [2. -6.j, 2. -6.j, 2. -6.j], + [2. -6.j, 2. -6.j, 2. -6.j]], + + [[3. -1.j, 3. -1.j, 3. -1.j], + [3. -1.j, 3. -1.j, 3. -1.j], + [3. -1.j, 3. -1.j, 3. -1.j]], + + [[4.-12.j, 4.-12.j, 4.-12.j], + [4.-12.j, 4.-12.j, 4.-12.j], + [4.-12.j, 4.-12.j, 4.-12.j]]], dtype=np.complex64) + np.testing.assert_array_equal(exit_wave, expected_exit_wave, + err_msg="The exit_wave has not been updated as expected") + +if __name__ == '__main__': + unittest.main() diff --git a/test/accelerate_tests/base_tests/engine_tests.py b/test/accelerate_tests/base_tests/engine_tests.py new file mode 100644 index 000000000..2b9379511 --- /dev/null +++ b/test/accelerate_tests/base_tests/engine_tests.py @@ -0,0 +1,171 @@ +""" +Test for the ML engine. + +This file is part of the PTYPY package. + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" +import unittest + +from test import utils as tu +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines("serial") +import tempfile +import shutil +import numpy as np + +class MLSerialTest(unittest.TestCase): + + def setUp(self): + self.outpath = tempfile.mkdtemp(suffix="ML_serial_test") + + def tearDown(self): + shutil.rmtree(self.outpath) + + def check_engine_output(self, output, plotting=False, debug=False): + P_ML, P_ML_serial = output + numiter = len(P_ML.runtime["iter_info"]) + LL_ML = np.array([P_ML.runtime["iter_info"][i]["error"][1] for i in range(numiter)]) + LL_ML_serial = np.array([P_ML_serial.runtime["iter_info"][i]["error"][1] for i in range(numiter)]) + crop = 42 + OBJ_ML_serial, OBJ_ML = P_ML_serial.obj.S["SMFG00"].data[0,crop:-crop,crop:-crop], P_ML.obj.S["SMFG00"].data[0,crop:-crop,crop:-crop] + PRB_ML_serial, PRB_ML = P_ML_serial.probe.S["SMFG00"].data[0], P_ML.probe.S["SMFG00"].data[0] + eng_ML = P_ML.engines["engine00"] + eng_ML_serial = P_ML_serial.engines["engine00"] + if debug: + import matplotlib.pyplot as plt + plt.figure("ML debug") + plt.imshow(np.abs(eng_ML.debug)) + plt.figure("ML serial debug") + plt.imshow(np.abs(eng_ML_serial.debug)) + plt.show() + + if plotting: + import matplotlib.pyplot as plt + plt.figure("Errors") + plt.plot(LL_ML, label="ML") + plt.plot(LL_ML_serial, label="ML_serial") + plt.legend() + plt.show() + plt.figure("Phase ML") + plt.imshow(np.angle(OBJ_ML)) + plt.figure("Ampltitude ML") + plt.imshow(np.abs(OBJ_ML)) + plt.figure("Phase ML serial") + plt.imshow(np.angle(OBJ_ML_serial)) + plt.figure("Amplitude ML serial") + plt.imshow(np.abs(OBJ_ML_serial)) + plt.figure("Phase difference") + plt.imshow(np.angle(OBJ_ML_serial) - np.angle(OBJ_ML), vmin=-0.1, vmax=0.1) + plt.colorbar() + plt.figure("Amplitude difference") + plt.imshow(np.abs(OBJ_ML_serial) - np.abs(OBJ_ML), vmin=-0.1, vmax=0.1) + plt.colorbar() + plt.show() + # np.testing.assert_allclose(eng_ML.debug, eng_ML_serial.debug, atol=1e-7, rtol=1e-7, + # err_msg="The debug arrays are not matching as expected") + RMSE_ob = (np.mean(np.abs(OBJ_ML_serial - OBJ_ML)**2)) + RMSE_pr = (np.mean(np.abs(PRB_ML_serial - PRB_ML)**2)) + # RMSE_LL = (np.mean(np.abs(LL_ML_serial - LL_ML)**2)) + np.testing.assert_allclose(RMSE_ob, 0.0, atol=1e-2, + err_msg="The object arrays are not matching as expected") + np.testing.assert_allclose(RMSE_pr, 0.0, atol=1e-2, + err_msg="The object arrays are not matching as expected") + # np.testing.assert_allclose(RMSE_LL, 0.0, atol=1e-7, + # err_msg="The log-likelihood errors are not matching as expected") + + + def test_ML_serial_base(self): + out = [] + for eng in ["ML", "ML_serial"]: + engine_params = u.Param() + engine_params.name = eng + engine_params.numiter = 100 + engine_params.floating_intensities = False + engine_params.reg_del2 = False + engine_params.reg_del2_amplitude = 1. + engine_params.scale_precond = False + out.append(tu.EngineTestRunner(engine_params, output_path=self.outpath, init_correct_probe=True, + scanmodel="BlockFull", autosave=False, verbose_level="critical")) + self.check_engine_output(out, plotting=False, debug=False) + + def test_ML_serial_regularizer(self): + out = [] + for eng in ["ML", "ML_serial"]: + engine_params = u.Param() + engine_params.name = eng + engine_params.numiter = 100 + engine_params.floating_intensities = False + engine_params.reg_del2 = True + engine_params.reg_del2_amplitude = 1. + engine_params.scale_precond = False + out.append(tu.EngineTestRunner(engine_params, output_path=self.outpath, init_correct_probe=True, + scanmodel="BlockFull", autosave=False, verbose_level="critical")) + self.check_engine_output(out, plotting=False, debug=False) + + + def test_ML_serial_preconditioner(self): + out = [] + for eng in ["ML", "ML_serial"]: + engine_params = u.Param() + engine_params.name = eng + engine_params.numiter = 100 + engine_params.floating_intensities = False + engine_params.reg_del2 = False + engine_params.reg_del2_amplitude = 1. + engine_params.scale_precond = True + engine_params.scale_probe_object = 1e-6 + out.append(tu.EngineTestRunner(engine_params, output_path=self.outpath, init_correct_probe=True, + scanmodel="BlockFull", autosave=False, verbose_level="critical")) + self.check_engine_output(out, plotting=False, debug=False) + + def test_ML_serial_floating(self): + out = [] + for eng in ["ML", "ML_serial"]: + engine_params = u.Param() + engine_params.name = eng + engine_params.numiter = 100 + engine_params.floating_intensities = True + engine_params.reg_del2 = False + engine_params.reg_del2_amplitude = 1. + engine_params.scale_precond = False + out.append(tu.EngineTestRunner(engine_params, output_path=self.outpath, init_correct_probe=True, + scanmodel="BlockFull", autosave=False, verbose_level="critical")) + self.check_engine_output(out, plotting=False, debug=False) + + def test_ML_serial_smoothing_regularizer(self): + out = [] + for eng in ["ML", "ML_serial"]: + engine_params = u.Param() + engine_params.name = eng + engine_params.numiter = 100 + engine_params.floating_intensities = False + engine_params.reg_del2 = False + engine_params.reg_del2_amplitude = 1. + engine_params.smooth_gradient = 20 + engine_params.smooth_gradient_decay = 1/10. + engine_params.scale_precond = False + out.append(tu.EngineTestRunner(engine_params, output_path=self.outpath, init_correct_probe=True, + scanmodel="BlockFull", autosave=False, verbose_level="critical")) + self.check_engine_output(out, plotting=False, debug=False) + + def test_ML_serial_all(self): + out = [] + for eng in ["ML", "ML_serial"]: + engine_params = u.Param() + engine_params.name = eng + engine_params.numiter = 100 + engine_params.floating_intensities = False + engine_params.reg_del2 = True + engine_params.reg_del2_amplitude = 1. + engine_params.smooth_gradient = 20 + engine_params.smooth_gradient_decay = 1/10. + engine_params.scale_precond = True + engine_params.scale_probe_object = 1e-6 + out.append(tu.EngineTestRunner(engine_params, output_path=self.outpath, init_correct_probe=True, + scanmodel="BlockFull", autosave=False, verbose_level="critical")) + self.check_engine_output(out, plotting=False, debug=False) + +if __name__ == "__main__": + unittest.main() diff --git a/test/accelerate_tests/base_tests/fourier_update_kernel_test.py b/test/accelerate_tests/base_tests/fourier_update_kernel_test.py new file mode 100644 index 000000000..fb057408f --- /dev/null +++ b/test/accelerate_tests/base_tests/fourier_update_kernel_test.py @@ -0,0 +1,570 @@ +''' + + +''' + +import unittest +import numpy as np +import ptypy.utils as u +from ptypy.accelerate.base.kernels import FourierUpdateKernel, AuxiliaryWaveKernel + + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + + +class FourierUpdateKernelTest(unittest.TestCase): + + def setUp(self): + import sys + np.set_printoptions(threshold=sys.maxsize, linewidth=np.inf) + + def tearDown(self): + np.set_printoptions() + + def test_init(self): + attrs = ["denom", + "fshape", + "nmodes", + "npy"] + + fake_aux = np.zeros((10, 20, 30)) # not used except to initialise + fake_nmodes = 5# not used except to initialise + FUK = FourierUpdateKernel(fake_aux, nmodes=fake_nmodes) + for attr in attrs: + self.assertTrue(hasattr(FUK, attr), msg="FourierUpdateKernel does not have attribute: %s" % attr) + + np.testing.assert_equal(FUK.kernels, + ['fourier_error', 'error_reduce', 'fmag_all_update'], + err_msg='FourierUpdateKernel does not have the correct functions registered.') + + def test_allocate(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + G = 2 # number og object modes + + scan_pts = 2 # one dimensional scan point number + + N = scan_pts ** 2 + total_number_modes = G * D + A = N * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + f = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + f[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + fmag = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured magnitudes NxAxB + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + FUK = FourierUpdateKernel(f, nmodes=total_number_modes) + FUK.allocate() + + expected_fdev_shape = (f.shape[0] // total_number_modes, f.shape[1], f.shape[2]) + expected_fdev_type = FLOAT_TYPE + + expected_ferr_shape = (f.shape[0] // total_number_modes, f.shape[1], f.shape[2]) + expected_ferr_type = FLOAT_TYPE + + np.testing.assert_equal(FUK.npy.fdev.shape, expected_fdev_shape) + np.testing.assert_equal(FUK.npy.fdev.dtype, expected_fdev_type) + np.testing.assert_equal(FUK.npy.ferr.shape, expected_ferr_shape) + np.testing.assert_equal(FUK.npy.ferr.dtype, expected_ferr_type) + + def test_fourier_error(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + G = 2 # number og object modes + + E = B # probe size y + F = C # probe size x + + scan_pts = 2 # one dimensional scan point number + + N = scan_pts ** 2 + total_number_modes = G * D + A = N * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + f = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + f[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + fmag = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured magnitudes NxAxB + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + mask = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE)# the masks for the measured magnitudes either 1xAxB or NxAxB + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((N,)) + Y = Y.reshape((N,)) + + addr = np.zeros((N, total_number_modes, 5, 3)) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [position_idx, 0, 0], + [position_idx, 0, 0]]) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + + mask_sum = mask.sum(-1).sum(-1) + + err_fmag = np.zeros(N, dtype=FLOAT_TYPE) + pbound_set = 0.9 + FUK = FourierUpdateKernel(f, nmodes=total_number_modes) + FUK.allocate() + FUK.fourier_error(f, addr, fmag, mask, mask_sum) + + + expected_fdev = np.array([[[7.7459664, 6.7459664, 5.7459664, 4.7459664, 3.7459664], + [2.7459664, 1.7459664, 0.74596643, -0.25403357, -1.2540336], + [-2.2540336, -3.2540336, -4.2540336, -5.2540336, -6.2540336], + [-7.2540336, -8.254034, -9.254034, -10.254034, -11.254034], + [-12.254034, -13.254034, -14.254034, -15.254034, -16.254034]], + + [[-6.3452415, -7.3452415, -8.345242, -9.345242, -10.345242], + [-11.345242, -12.345242, -13.345242, -14.345242, -15.345242], + [-16.345242, -17.345242, -18.345242, -19.345242, -20.345242], + [-21.345242, -22.345242, -23.345242, -24.345242, -25.345242], + [-26.345242, -27.345242, -28.345242, -29.345242, -30.345242]], + + [[-20.13363, -21.13363, -22.13363, -23.13363, -24.13363], + [-25.13363, -26.13363, -27.13363, -28.13363, -29.13363], + [-30.13363, -31.13363, -32.13363, -33.13363, -34.13363], + [-35.13363, -36.13363, -37.13363, -38.13363, -39.13363], + [-40.13363, -41.13363, -42.13363, -43.13363, -44.13363]], + + [[-33.866074, -34.866074, -35.866074, -36.866074, -37.866074], + [-38.866074, -39.866074, -40.866074, -41.866074, -42.866074], + [-43.866074, -44.866074, -45.866074, -46.866074, -47.866074], + [-48.866074, -49.866074, -50.866074, -51.866074, -52.866074], + [-53.866074, -54.866074, -55.866074, -56.866074, -57.866074]]], + dtype=FLOAT_TYPE) + np.testing.assert_array_equal(FUK.npy.fdev, expected_fdev, + err_msg="fdev does not give the expected error " + "for the fourier_update_kernel.fourier_error emthods") + + expected_ferr = np.array([[[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [7.54033208e-01, 3.04839879e-01, 5.56465909e-02, 6.45330548e-03, 1.57260016e-01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [5.26210022e+00, 6.81290817e+00, 8.56371498e+00, 1.05145216e+01, 1.26653280e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[1.61048353e+00, 2.15810299e+00, 2.78572226e+00, 3.49334168e+00, 4.28096104e+00], + [5.14858055e+00, 6.09619951e+00, 7.12381887e+00, 8.23143768e+00, 9.41905785e+00], + [1.06866770e+01, 1.20342960e+01, 1.34619150e+01, 1.49695349e+01, 1.65571537e+01], + [1.82247734e+01, 1.99723930e+01, 2.18000126e+01, 2.37076321e+01, 2.56952515e+01], + [2.77628708e+01, 2.99104881e+01, 3.21381073e+01, 3.44457283e+01, 3.68333473e+01]], + + [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [6.31699409e+01, 6.82966690e+01, 7.36233978e+01, 7.91501160e+01, 8.48768463e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [1.23437180e+02, 1.30563919e+02, 1.37890640e+02, 1.45417374e+02, 1.53144089e+02], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[4.58764343e+01, 4.86257210e+01, 5.14550095e+01, 5.43642960e+01, 5.73535805e+01], + [6.04228668e+01, 6.35721550e+01, 6.68014374e+01, 7.01107254e+01, 7.35000076e+01], + [7.69692993e+01, 8.05185852e+01, 8.41478729e+01, 8.78571548e+01, 9.16464386e+01], + [9.55157242e+01, 9.94650116e+01, 1.03494293e+02, 1.07603584e+02, 1.11792870e+02], + [1.16062157e+02, 1.20411446e+02, 1.24840721e+02, 1.29350006e+02, 1.33939301e+02]]], + dtype=FLOAT_TYPE) + np.testing.assert_array_equal(FUK.npy.ferr, expected_ferr, + err_msg="ferr does not give the expected error " + "for the fourier_update_kernel.fourier_error emthods") + + def test_error_reduce(self): + # array from the previous test + ferr = np.array([[[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [7.54033208e-01, 3.04839879e-01, 5.56465909e-02, 6.45330548e-03, 1.57260016e-01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [5.26210022e+00, 6.81290817e+00, 8.56371498e+00, 1.05145216e+01, 1.26653280e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[1.61048353e+00, 2.15810299e+00, 2.78572226e+00, 3.49334168e+00, 4.28096104e+00], + [5.14858055e+00, 6.09619951e+00, 7.12381887e+00, 8.23143768e+00, 9.41905785e+00], + [1.06866770e+01, 1.20342960e+01, 1.34619150e+01, 1.49695349e+01, 1.65571537e+01], + [1.82247734e+01, 1.99723930e+01, 2.18000126e+01, 2.37076321e+01, 2.56952515e+01], + [2.77628708e+01, 2.99104881e+01, 3.21381073e+01, 3.44457283e+01, 3.68333473e+01]], + + [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [6.31699409e+01, 6.82966690e+01, 7.36233978e+01, 7.91501160e+01, 8.48768463e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [1.23437180e+02, 1.30563919e+02, 1.37890640e+02, 1.45417374e+02, 1.53144089e+02], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[4.58764343e+01, 4.86257210e+01, 5.14550095e+01, 5.43642960e+01, 5.73535805e+01], + [6.04228668e+01, 6.35721550e+01, 6.68014374e+01, 7.01107254e+01, 7.35000076e+01], + [7.69692993e+01, 8.05185852e+01, 8.41478729e+01, 8.78571548e+01, 9.16464386e+01], + [9.55157242e+01, 9.94650116e+01, 1.03494293e+02, 1.07603584e+02, 1.11792870e+02], + [1.16062157e+02, 1.20411446e+02, 1.24840721e+02, 1.29350006e+02, 1.33939301e+02]]], + dtype=FLOAT_TYPE) + + + # print(repr(ferr)) + #print(ferr.shape) + #print(repr(ferr)) + auxiliary_shape = (4, 5, 5) + fake_aux = np.zeros(auxiliary_shape, dtype=COMPLEX_TYPE) + scan_pts = 2 # one dimensional scan point number + N = scan_pts ** 2 + + addr = np.zeros((N, 1, 5, 3)) + + FUK = FourierUpdateKernel(fake_aux, nmodes=1) + FUK.allocate() + err_fmag = np.zeros(N, dtype=FLOAT_TYPE) + FUK.error_reduce(addr, err_fmag) + + + + expected_ferr = np.array([[[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [7.54033208e-01, 3.04839879e-01, 5.56465909e-02, 6.45330548e-03, 1.57260016e-01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [5.26210022e+00, 6.81290817e+00, 8.56371498e+00, 1.05145216e+01, 1.26653280e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[1.61048353e+00, 2.15810299e+00, 2.78572226e+00, 3.49334168e+00, 4.28096104e+00], + [5.14858055e+00, 6.09619951e+00, 7.12381887e+00, 8.23143768e+00, 9.41905785e+00], + [1.06866770e+01, 1.20342960e+01, 1.34619150e+01, 1.49695349e+01, 1.65571537e+01], + [1.82247734e+01, 1.99723930e+01, 2.18000126e+01, 2.37076321e+01, 2.56952515e+01], + [2.77628708e+01, 2.99104881e+01, 3.21381073e+01, 3.44457283e+01, 3.68333473e+01]], + + [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [6.31699409e+01, 6.82966690e+01, 7.36233978e+01, 7.91501160e+01, 8.48768463e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [1.23437180e+02, 1.30563919e+02, 1.37890640e+02, 1.45417374e+02, 1.53144089e+02], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[4.58764343e+01, 4.86257210e+01, 5.14550095e+01, 5.43642960e+01, 5.73535805e+01], + [6.04228668e+01, 6.35721550e+01, 6.68014374e+01, 7.01107254e+01, 7.35000076e+01], + [7.69692993e+01, 8.05185852e+01, 8.41478729e+01, 8.78571548e+01, 9.16464386e+01], + [9.55157242e+01, 9.94650116e+01, 1.03494293e+02, 1.07603584e+02, 1.11792870e+02], + [1.16062157e+02, 1.20411446e+02, 1.24840721e+02, 1.29350006e+02, 1.33939301e+02]]], + dtype=FLOAT_TYPE) + + np.testing.assert_array_equal(expected_ferr, ferr, err_msg="The fourier_update_kernel.error_reduce" + "is not behaving as expected.") + + def test_fmag_update(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + G = 2 # number og object modes + + scan_pts = 2 # one dimensional scan point number + + N = scan_pts ** 2 + total_number_modes = G * D + A = N * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + f = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + f[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + fmag = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured magnitudes NxAxB + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + mask = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the masks for the measured magnitudes either 1xAxB or NxAxB + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((N,)) + Y = Y.reshape((N,)) + + addr = np.zeros((N, total_number_modes, 5, 3)) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [position_idx, 0, 0], + [position_idx, 0, 0]]) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + + # print("address book is:") + # print(repr(addr)) + + ''' + test + ''' + + err_fmag = np.zeros(N, dtype=FLOAT_TYPE) + pbound_set = 0.9 + mask_sum = mask.sum(-1).sum(-1) + + FUK = FourierUpdateKernel(f, nmodes=total_number_modes) + FUK.allocate() + FUK.fourier_error(f, addr, fmag, mask, mask_sum) + FUK.error_reduce(addr, err_fmag) + FUK.fmag_all_update(f, addr, fmag, mask, err_fmag, pbound=pbound_set) + # print("f before:") + # print(repr(f)) + # print(fm.shape) + # print(f.shape) + # print("f after:") + # print(repr(f)) + # self.assertTrue(False) + expected_f = np.array([[[ 1. +1.j , 1. +1.j , 1. +1.j , 1. +1.j , 1. +1.j ], + [ 0.6955777 +0.6955777j , 0.8064393 +0.8064393j , 0.91730094 +0.91730094j, 1.0281626 +1.0281626j , 1.1390243 +1.1390243j ], + [ 1. +1.j , 1. +1.j , 1. +1.j , 1. +1.j , 1. +1.j ], + [ 1.804194 +1.804194j , 1.9150558 +1.9150558j , 2.0259173 +2.0259173j , 2.136779 +2.136779j , 2.2476408 +2.2476408j ], + [ 1. +1.j , 1. +1.j , 1. +1.j , 1. +1.j , 1. +1.j ]], + + [[ 2. +2.j , 2. +2.j , 2. +2.j , 2. +2.j , 2. +2.j ], + [ 1.3911554 +1.3911554j , 1.6128786 +1.6128786j , 1.8346019 +1.8346019j , 2.0563252 +2.0563252j , 2.2780485 +2.2780485j ], + [ 2. +2.j , 2. +2.j , 2. +2.j , 2. +2.j , 2. +2.j ], + [ 3.608388 +3.608388j , 3.8301115 +3.8301115j , 4.0518346 +4.0518346j , 4.273558 +4.273558j , 4.4952817 +4.4952817j ], + [ 2. +2.j , 2. +2.j , 2. +2.j , 2. +2.j , 2. +2.j ]], + + [[ 3. +3.j , 3. +3.j , 3. +3.j , 3. +3.j , 3. +3.j ], + [ 2.086733 +2.086733j , 2.4193177 +2.4193177j , 2.7519028 +2.7519028j , 3.084488 +3.084488j , 3.4170728 +3.4170728j ], + [ 3. +3.j , 3. +3.j , 3. +3.j , 3. +3.j , 3. +3.j ], + [ 5.412582 +5.412582j , 5.7451673 +5.7451673j , 6.077752 +6.077752j , 6.4103374 +6.4103374j , 6.742923 +6.742923j ], + [ 3. +3.j , 3. +3.j , 3. +3.j , 3. +3.j , 3. +3.j ]], + + [[ 4. +4.j , 4. +4.j , 4. +4.j , 4. +4.j , 4. +4.j ], + [ 2.7823107 +2.7823107j , 3.2257571 +3.2257571j , 3.6692038 +3.6692038j , 4.1126504 +4.1126504j , 4.556097 +4.556097j ], + [ 4. +4.j , 4. +4.j , 4. +4.j , 4. +4.j , 4. +4.j ], + [ 7.216776 +7.216776j , 7.660223 +7.660223j , 8.103669 +8.103669j , 8.547116 +8.547116j , 8.990563 +8.990563j ], + [ 4. +4.j , 4. +4.j , 4. +4.j , 4. +4.j , 4. +4.j ]], + + [[ 6.618852 +6.618852j , 6.87398 +6.87398j , 7.129109 +7.129109j , 7.3842373 +7.3842373j , 7.6393657 +7.6393657j ], + [ 7.894494 +7.894494j , 8.149623 +8.149623j , 8.404751 +8.404751j , 8.659879 +8.659879j , 8.915008 +8.915008j ], + [ 9.1701355 +9.1701355j , 9.425264 +9.425264j , 9.680393 +9.680393j , 9.935521 +9.935521j , 10.190649 +10.190649j ], + [10.445778 +10.445778j , 10.700907 +10.700907j , 10.956035 +10.956035j , 11.211163 +11.211163j , 11.466292 +11.466292j ], + [11.72142 +11.72142j , 11.976548 +11.976548j , 12.231676 +12.231676j , 12.486806 +12.486806j , 12.741934 +12.741934j ]], + + [[ 7.942622 +7.942622j , 8.248776 +8.248776j , 8.554931 +8.554931j , 8.861084 +8.861084j , 9.167239 +9.167239j ], + [ 9.4733925 +9.4733925j , 9.779547 +9.779547j , 10.085701 +10.085701j , 10.391855 +10.391855j , 10.6980095 +10.6980095j ], + [11.004163 +11.004163j , 11.310318 +11.310318j , 11.616471 +11.616471j , 11.922626 +11.922626j , 12.228779 +12.228779j ], + [12.534934 +12.534934j , 12.841087 +12.841087j , 13.147242 +13.147242j , 13.453396 +13.453396j , 13.75955 +13.75955j ], + [14.065704 +14.065704j , 14.371859 +14.371859j , 14.678012 +14.678012j , 14.984167 +14.984167j , 15.290321 +15.290321j ]], + + [[ 9.266393 +9.266393j , 9.623572 +9.623572j , 9.980753 +9.980753j , 10.337932 +10.337932j , 10.695112 +10.695112j ], + [11.052292 +11.052292j , 11.4094715 +11.4094715j , 11.766651 +11.766651j , 12.123831 +12.123831j , 12.48101 +12.48101j ], + [12.83819 +12.83819j , 13.195371 +13.195371j , 13.552549 +13.552549j , 13.90973 +13.90973j , 14.266909 +14.266909j ], + [14.62409 +14.62409j , 14.981269 +14.981269j , 15.338449 +15.338449j , 15.695628 +15.695628j , 16.052809 +16.052809j ], + [16.409988 +16.409988j , 16.767168 +16.767168j , 17.124348 +17.124348j , 17.48153 +17.48153j , 17.838707 +17.838707j ]], + + [[10.590163 +10.590163j , 10.998368 +10.998368j , 11.406574 +11.406574j , 11.814779 +11.814779j , 12.222985 +12.222985j ], + [12.63119 +12.63119j , 13.039396 +13.039396j , 13.447601 +13.447601j , 13.855806 +13.855806j , 14.264012 +14.264012j ], + [14.672217 +14.672217j , 15.080423 +15.080423j , 15.488628 +15.488628j , 15.896834 +15.896834j , 16.305038 +16.305038j ], + [16.713245 +16.713245j , 17.12145 +17.12145j , 17.529655 +17.529655j , 17.93786 +17.93786j , 18.346067 +18.346067j ], + [18.754272 +18.754272j , 19.162477 +19.162477j , 19.570683 +19.570683j , 19.97889 +19.97889j , 20.387094 +20.387094j ]], + + [[ 9. +9.j , 9. +9.j , 9. +9.j , 9. +9.j , 9. +9.j ], + [16.35309 +16.35309j , 16.64565 +16.64565j , 16.938211 +16.938211j , 17.23077 +17.23077j , 17.52333 +17.52333j ], + [ 9. +9.j , 9. +9.j , 9. +9.j , 9. +9.j , 9. +9.j ], + [19.278687 +19.278687j , 19.571249 +19.571249j , 19.86381 +19.86381j , 20.156368 +20.156368j , 20.448927 +20.448927j ], + [ 9. +9.j , 9. +9.j , 9. +9.j , 9. +9.j , 9. +9.j ]], + + [[10. +10.j , 10. +10.j , 10. +10.j , 10. +10.j , 10. +10.j ], + [18.170101 +18.170101j , 18.495167 +18.495167j , 18.820234 +18.820234j , 19.1453 +19.1453j , 19.470367 +19.470367j ], + [10. +10.j , 10. +10.j , 10. +10.j , 10. +10.j , 10. +10.j ], + [21.420763 +21.420763j , 21.745832 +21.745832j , 22.0709 +22.0709j , 22.395964 +22.395964j , 22.721031 +22.721031j ], + [10. +10.j , 10. +10.j , 10. +10.j , 10. +10.j , 10. +10.j ]], + + [[11. +11.j , 11. +11.j , 11. +11.j , 11. +11.j , 11. +11.j ], + [19.98711 +19.98711j , 20.344685 +20.344685j , 20.702257 +20.702257j , 21.05983 +21.05983j , 21.417404 +21.417404j ], + [11. +11.j , 11. +11.j , 11. +11.j , 11. +11.j , 11. +11.j ], + [23.56284 +23.56284j , 23.920416 +23.920416j , 24.277988 +24.277988j , 24.63556 +24.63556j , 24.993134 +24.993134j ], + [11. +11.j , 11. +11.j , 11. +11.j , 11. +11.j , 11. +11.j ]], + + [[12. +12.j , 12. +12.j , 12. +12.j , 12. +12.j , 12. +12.j ], + [21.804121 +21.804121j , 22.1942 +22.1942j , 22.584282 +22.584282j , 22.974361 +22.974361j , 23.36444 +23.36444j ], + [12. +12.j , 12. +12.j , 12. +12.j , 12. +12.j , 12. +12.j ], + [25.704914 +25.704914j , 26.094997 +26.094997j , 26.485079 +26.485079j , 26.875156 +26.875156j , 27.265236 +27.265236j ], + [12. +12.j , 12. +12.j , 12. +12.j , 12. +12.j , 12. +12.j ]], + + [[23.484367 +23.484367j , 23.793953 +23.793953j , 24.103535 +24.103535j , 24.41312 +24.41312j , 24.7227 +24.7227j ], + [25.032284 +25.032284j , 25.341867 +25.341867j , 25.651451 +25.651451j , 25.961035 +25.961035j , 26.270618 +26.270618j ], + [26.5802 +26.5802j , 26.889784 +26.889784j , 27.199366 +27.199366j , 27.508951 +27.508951j , 27.818535 +27.818535j ], + [28.128117 +28.128117j , 28.437698 +28.437698j , 28.747284 +28.747284j , 29.056868 +29.056868j , 29.36645 +29.36645j ], + [29.676033 +29.676033j , 29.985619 +29.985619j , 30.2952 +30.2952j , 30.604782 +30.604782j , 30.914366 +30.914366j ]], + + [[25.290857 +25.290857j , 25.624256 +25.624256j , 25.957653 +25.957653j , 26.291052 +26.291052j , 26.624447 +26.624447j ], + [26.957846 +26.957846j , 27.291243 +27.291243j , 27.62464 +27.62464j , 27.958038 +27.958038j , 28.291435 +28.291435j ], + [28.62483 +28.62483j , 28.95823 +28.95823j , 29.291626 +29.291626j , 29.625023 +29.625023j , 29.958424 +29.958424j ], + [30.291819 +30.291819j , 30.625214 +30.625214j , 30.958612 +30.958612j , 31.292011 +31.292011j , 31.625406 +31.625406j ], + [31.958805 +31.958805j , 32.292206 +32.292206j , 32.6256 +32.6256j , 32.958996 +32.958996j , 33.292393 +33.292393j ]], + + [[27.097347 +27.097347j , 27.454561 +27.454561j , 27.811771 +27.811771j , 28.168985 +28.168985j , 28.526192 +28.526192j ], + [28.883406 +28.883406j , 29.240616 +29.240616j , 29.597828 +29.597828j , 29.95504 +29.95504j , 30.312252 +30.312252j ], + [30.669462 +30.669462j , 31.026674 +31.026674j , 31.383884 +31.383884j , 31.741096 +31.741096j , 32.09831 +32.09831j ], + [32.45552 +32.45552j , 32.81273 +32.81273j , 33.16994 +33.16994j , 33.527153 +33.527153j , 33.884365 +33.884365j ], + [34.241577 +34.241577j , 34.59879 +34.59879j , 34.956 +34.956j , 35.31321 +35.31321j , 35.67042 +35.67042j ]], + + [[28.903837 +28.903837j , 29.284864 +29.284864j , 29.66589 +29.66589j , 30.046917 +30.046917j , 30.427938 +30.427938j ], + [30.808966 +30.808966j , 31.189991 +31.189991j , 31.571016 +31.571016j , 31.952044 +31.952044j , 32.33307 +32.33307j ], + [32.714092 +32.714092j , 33.09512 +33.09512j , 33.476143 +33.476143j , 33.85717 +33.85717j , 34.238197 +34.238197j ], + [34.61922 +34.61922j , 35.000244 +35.000244j , 35.38127 +35.38127j , 35.7623 +35.7623j , 36.143322 +36.143322j ], + [36.52435 +36.52435j , 36.905376 +36.905376j , 37.2864 +37.2864j , 37.667423 +37.667423j , 38.04845 +38.04845j ]]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(f, expected_f, err_msg="the f array from the fmag_all_update kernesl isnot behaving as expected.") + + # TODO: This test needs to be redesigne to NOT use components from the archive test + @unittest.skip('This test needs to be redone') + def test_log_likelihood(self): + nmodes = 1 + PtychoInstance = tu.get_ptycho_instance('log_likelihood_test', nmodes) # noqa: F821 + ptypy_error_metric = self.get_ptypy_loglikelihood(PtychoInstance) + LLerr_expected = np.array([LL for LL in ptypy_error_metric.values()]).astype(np.float32) + + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') # noqa: F821 + addr = vectorised_scan['meta']['addr'].reshape((len(ptypy_error_metric)//nmodes, nmodes, 5, 3)) + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + mask = vectorised_scan['mask'] + exit_wave = vectorised_scan['exit wave'] + mag = np.sqrt(vectorised_scan['diffraction']) + + aux = np.zeros_like(exit_wave) + AWK = AuxiliaryWaveKernel() + AWK.allocate() + AWK.build_aux_no_ex(aux, addr, obj, probe, fac=1.0, add=False) + + scan = list(PtychoInstance.model.scans.values())[0] + geo = scan.geometries[0] + aux[:] = geo.propagator.fw(aux) + + FUK = FourierUpdateKernel(aux, nmodes=1) + FUK.allocate() + LLerr = np.zeros_like(LLerr_expected, dtype=np.float32) + FUK.log_likelihood(aux, addr, mag, mask, LLerr) + + np.testing.assert_allclose(LLerr, LLerr_expected, rtol=1e-6, err_msg="LLerr does not give the expected error " + "for the fourier_update_kernel.log_likelihood method") + + def get_ptypy_loglikelihood(self, a_ptycho_instance): + error_dct = {} + for dname, diff_view in a_ptycho_instance.diff.views.items(): + I = diff_view.data + fmask = diff_view.pod.mask + LL = np.zeros_like(diff_view.data) + for name, pod in diff_view.pods.items(): + LL += u.abs2(pod.fw(pod.probe * pod.object)) + + error_dct[dname] = (np.sum(fmask * (LL - I) ** 2 / (I + 1.)) + / np.prod(LL.shape)) + return error_dct + + + def test_exit_error(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + G = 2 # number og object modes + + E = B # probe size y + F = C # probe size x + + scan_pts = 2 # one dimensional scan point number + + N = scan_pts ** 2 + total_number_modes = G * D + A = N * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + aux = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + aux[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((N,)) + Y = Y.reshape((N,)) + + addr = np.zeros((N, total_number_modes, 5, 3)) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [position_idx, 0, 0], + [position_idx, 0, 0]]) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + err_sum = np.zeros(N, dtype=FLOAT_TYPE) + FUK = FourierUpdateKernel(aux, nmodes=total_number_modes) + FUK.allocate() + FUK.exit_error(aux, addr) + + expected_ferr = np.array([[[ 2.3999996, 2.3999996, 2.3999996, 2.3999996, 2.3999996], + [ 2.3999996, 2.3999996, 2.3999996, 2.3999996, 2.3999996], + [ 2.3999996, 2.3999996, 2.3999996, 2.3999996, 2.3999996], + [ 2.3999996, 2.3999996, 2.3999996, 2.3999996, 2.3999996], + [ 2.3999996, 2.3999996, 2.3999996, 2.3999996, 2.3999996]], + + [[13.92, 13.92, 13.92, 13.92, 13.92], + [13.92, 13.92, 13.92, 13.92, 13.92], + [13.92, 13.92, 13.92, 13.92, 13.92], + [13.92, 13.92, 13.92, 13.92, 13.92], + [13.92, 13.92, 13.92, 13.92, 13.92]], + + [[35.68, 35.68, 35.68, 35.68, 35.68 ], + [35.68, 35.68, 35.68, 35.68, 35.68 ], + [35.68, 35.68, 35.68, 35.68, 35.68 ], + [35.68, 35.68, 35.68, 35.68, 35.68 ], + [35.68, 35.68, 35.68, 35.68, 35.68 ]], + + [[67.68, 67.68, 67.68, 67.68, 67.68 ], + [67.68, 67.68, 67.68, 67.68, 67.68 ], + [67.68, 67.68, 67.68, 67.68, 67.68 ], + [67.68, 67.68, 67.68, 67.68, 67.68 ], + [67.68, 67.68, 67.68, 67.68, 67.68 ]]], dtype=FLOAT_TYPE) + + np.testing.assert_array_equal(FUK.npy.ferr, expected_ferr, + err_msg="ferr does not give the expected error " + "for the fourier_update_kernel.fourier_error emthods") + + +if __name__ == '__main__': + unittest.main() diff --git a/test/accelerate_tests/base_tests/gradient_descent_kernel_test.py b/test/accelerate_tests/base_tests/gradient_descent_kernel_test.py new file mode 100644 index 000000000..453edc2ff --- /dev/null +++ b/test/accelerate_tests/base_tests/gradient_descent_kernel_test.py @@ -0,0 +1,279 @@ +''' + + +''' + +import unittest +import numpy as np +from ptypy.accelerate.base.kernels import GradientDescentKernel + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + + +class GradientDescentKernelTest(unittest.TestCase): + + def setUp(self): + import sys + np.set_printoptions(threshold=sys.maxsize, linewidth=np.inf) + + def tearDown(self): + np.set_printoptions() + + def test_init(self): + attrs = ["denom", + "fshape", + "bshape", + "nmodes", + "npy"] + + fake_aux = np.zeros((10, 20, 30)) # not used except to initialise + fake_nmodes = 5# not used except to initialise + GDK = GradientDescentKernel(fake_aux, nmodes=fake_nmodes) + for attr in attrs: + self.assertTrue(hasattr(GDK, attr), msg="FourierUpdateKernel does not have attribute: %s" % attr) + + def prepare_arrays(self): + nmodes = 2 + N_buf = 4 + N = 3 + A = 3 + i_sh = (N, A, A) + e_sh = (N*nmodes, A, A) + f_sh = (N_buf, A, A) + a_sh = (N_buf * nmodes, A, A) + w = np.ones(i_sh, dtype=FLOAT_TYPE) + for idx, sl in enumerate(w): + sl[idx % A, idx % A] = 0.0 + X,Y,Z = np.indices(a_sh, dtype=COMPLEX_TYPE) + b_f = X + 1j * Y + b_a = Y + 1j * Z + b_b = Z + 1j * X + err_sum = np.zeros((N,), dtype=FLOAT_TYPE) + addr = np.zeros((N,nmodes,5,3), dtype=INT_TYPE) + I = np.empty(i_sh, dtype=FLOAT_TYPE) + I[:] = np.round(np.abs(b_f[:N])**2 % 20) + for pos_idx in range(N): + for mode_idx in range(nmodes): + exit_idx = pos_idx * nmodes + mode_idx + addr[pos_idx, mode_idx] = np.array([[mode_idx, 0, 0], + [0, 0, 0], + [exit_idx, 0, 0], + [pos_idx, 0, 0], + [pos_idx, 0, 0]], dtype=INT_TYPE) + return b_f, b_a, b_b, I, w, err_sum, addr + + def test_allocate(self): + ''' + setup + ''' + pass + + def test_make_model(self): + b_f, b_a, b_b, I, w, err_sum, addr = self.prepare_arrays() + + GDK=GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.make_model(b_f, addr) + #print('Im',repr(GDK.npy.Imodel)) + exp_Imodel = np.array([[[ 1., 1., 1.], + [ 3., 3., 3.], + [ 9., 9., 9.]], + + [[13., 13., 13.], + [15., 15., 15.], + [21., 21., 21.]], + + [[41., 41., 41.], + [43., 43., 43.], + [49., 49., 49.]], + + [[85., 85., 85.], + [87., 87., 87.], + [93., 93., 93.]]], dtype=FLOAT_TYPE) + np.testing.assert_array_almost_equal(exp_Imodel, GDK.npy.Imodel, + err_msg="`Imodel` buffer has not been updated as expected") + + def test_floating_intensity(self): + b_f, b_a, b_b, I, w, err_sum, addr = self.prepare_arrays() + fic = np.ones((I.shape[0],), dtype=I.dtype) + GDK=GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.npy.Imodel[:I.shape[0]] = I * (1+np.arange(I.shape[0]))[::-1].reshape((I.shape[0],1,1)) + GDK.floating_intensity(addr, w, I, fic) + #print('Imodel',repr(GDK.npy.Imodel)) + #print('fic',repr(1./fic)) + exp_Imodel = np.array([[[0., 0., 0.], + [1., 1., 1.], + [4., 4., 4.]], + + [[1., 1., 1.], + [2., 2., 2.], + [5., 5., 5.]], + + [[4., 4., 4.], + [5., 5., 5.], + [8., 8., 8.]], + + [[0., 0., 0.], + [0., 0., 0.], + [0., 0., 0.]]], dtype=np.float32) + exp_fic=1./np.array([3., 2., 1.], dtype=np.float32) + np.testing.assert_array_almost_equal(exp_Imodel, GDK.npy.Imodel, + err_msg="`Imodel` buffer has not been updated as expected") + np.testing.assert_array_almost_equal(exp_fic, fic, + err_msg="floating intensity coeff (fic) has not been updated as expected") + + + def test_make_a012(self): + b_f, b_a, b_b, I, w, err_sum, addr = self.prepare_arrays() + fic = np.ones((I.shape[0],), dtype=I.dtype) + GDK=GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.make_a012(b_f, b_a, b_b, addr, I, fic) + #print('Imodel',repr(GDK.npy.Imodel)) + #print('LLerr',repr(GDK.npy.LLerr)) + #print('LLden',repr(GDK.npy.LLden)) + exp_A0 = np.array([[[ 1., 1., 1.], + [ 2., 2., 2.], + [ 5., 5., 5.]], + + [[12., 12., 12.], + [13., 13., 13.], + [16., 16., 16.]], + + [[37., 37., 37.], + [38., 38., 38.], + [41., 41., 41.]], + + [[ 0., 0., 0.], + [ 0., 0., 0.], + [ 0., 0., 0.]]], dtype=FLOAT_TYPE) + np.testing.assert_array_almost_equal(exp_A0, GDK.npy.Imodel, + err_msg="`Imodel` buffer (=A0) has not been updated as expected") + exp_A1 = np.array([[[ 0., 0., 0.], + [ 2., 6., 10.], + [ 4., 12., 20.]], + + [[ 0., 0., 0.], + [10., 14., 18.], + [20., 28., 36.]], + + [[ 0., 0., 0.], + [18., 22., 26.], + [36., 44., 52.]], + + [[ 0., 0., 0.], + [ 0., 0., 0.], + [ 0., 0., 0.]]], dtype=FLOAT_TYPE) + np.testing.assert_array_almost_equal(exp_A1, GDK.npy.LLerr, + err_msg="`LLerr` buffer (=A1) has not been updated as expected") + exp_A2 = np.array([[[ 0., 4., 12.], + [ 4., 8., 16.], + [12., 16., 24.]], + + [[ 0., 12., 28.], + [12., 24., 40.], + [28., 40., 56.]], + + [[ 0., 20., 44.], + [20., 40., 64.], + [44., 64., 88.]], + + [[ 0., 0., 0.], + [ 0., 0., 0.], + [ 0., 0., 0.]]], dtype=FLOAT_TYPE) + np.testing.assert_array_almost_equal(exp_A2, GDK.npy.LLden, + err_msg="`LLden` buffer (=A2) has not been updated as expected") + + def test_fill_b(self): + b_f, b_a, b_b, I, w, err_sum, addr = self.prepare_arrays() + fic = np.ones((I.shape[0],), dtype=I.dtype) + Brenorm = 0.35 + B = np.zeros((3,), dtype=FLOAT_TYPE) + GDK=GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.make_a012(b_f, b_a, b_b, addr, I, fic) + GDK.fill_b(addr, Brenorm, w, B) + #print('B',repr(B)) + exp_B = np.array([ 4699.8, 5398.4, 13398.], dtype=FLOAT_TYPE) + np.testing.assert_array_almost_equal(exp_B, B, + err_msg="`B` has not been updated as expected") + + + def test_error_reduce(self): + b_f, b_a, b_b, I, w, err_sum, addr = self.prepare_arrays() + GDK=GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.npy.LLerr = np.indices(GDK.npy.LLerr.shape, dtype=FLOAT_TYPE)[0] + GDK.error_reduce(addr, err_sum) + #print('Err',repr(err_sum)) + exp_err = np.array([ 0., 9., 18.], dtype=FLOAT_TYPE) + np.testing.assert_array_almost_equal(exp_err, err_sum, + err_msg="`err_sum` has not been updated as expected") + return + + def test_main(self): + b_f, b_a, b_b, I, w, err_sum, addr = self.prepare_arrays() + GDK=GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.main(b_f, addr, w, I) + #print('B_F',repr(b_f)) + #print('LL',repr(GDK.npy.LLerr)) + exp_b_f = np.array([[[ 0. +0.j, 0. +0.j, 0. +0.j], + [ -0. -1.j, -0. -1.j, -0. -1.j], + [ -0. -8.j, -0. -8.j, -0. -8.j]], + + [[ 0. +0.j, 0. +0.j, 0. +0.j], + [ -1. -1.j, -1. -1.j, -1. -1.j], + [ -4. -8.j, -4. -8.j, -4. -8.j]], + + [[ -2. +0.j, -2. +0.j, -2. +0.j], + [ -4. -2.j, -0. +0.j, -4. -2.j], + [-10.-10.j, -10.-10.j, -10.-10.j]], + + [[ -3. +0.j, -3. +0.j, -3. +0.j], + [ -6. -2.j, -0. +0.j, -6. -2.j], + [-15.-10.j, -15.-10.j, -15.-10.j]], + + [[-16. +0.j, -16. +0.j, -16. +0.j], + [-20. -5.j, -20. -5.j, -20. -5.j], + [-32.-16.j, -32.-16.j, -0. +0.j]], + + [[-20. +0.j, -20. +0.j, -20. +0.j], + [-25. -5.j, -25. -5.j, -25. -5.j], + [-40.-16.j, -40.-16.j, -0. +0.j]], + + [[ 6. +0.j, 6. +0.j, 6. +0.j], + [ 6. +1.j, 6. +1.j, 6. +1.j], + [ 6. +2.j, 6. +2.j, 6. +2.j]], + + [[ 7. +0.j, 7. +0.j, 7. +0.j], + [ 7. +1.j, 7. +1.j, 7. +1.j], + [ 7. +2.j, 7. +2.j, 7. +2.j]]], dtype=COMPLEX_TYPE) + np.testing.assert_array_almost_equal(exp_b_f, b_f, + err_msg="Auxiliary has not been updated as expected") + exp_LL =np.array([[[ 0., 0., 0.], + [ 1., 1., 1.], + [16., 16., 16.]], + + [[ 1., 1., 1.], + [ 4., 0., 4.], + [25., 25., 25.]], + + [[16., 16., 16.], + [25., 25., 25.], + [64., 64., 0.]], + + [[ 0., 0., 0.], + [ 0., 0., 0.], + [ 0., 0., 0.]]], dtype=FLOAT_TYPE) + np.testing.assert_array_almost_equal(exp_LL, GDK.npy.LLerr, + err_msg="LogLikelihood error has not been updated as expected") + return + + + +if __name__ == '__main__': + unittest.main() diff --git a/test/accelerate_tests/base_tests/import_test.py b/test/accelerate_tests/base_tests/import_test.py new file mode 100644 index 000000000..755a80866 --- /dev/null +++ b/test/accelerate_tests/base_tests/import_test.py @@ -0,0 +1,10 @@ +""" +Import test +""" +import unittest + +class AutoLoaderTest(unittest.TestCase): + + def test_load_engines_serial(self): + import ptypy + ptypy.load_gpu_engines("serial") diff --git a/test/accelerate_tests/base_tests/po_update_kernel_test.py b/test/accelerate_tests/base_tests/po_update_kernel_test.py new file mode 100644 index 000000000..953c26b54 --- /dev/null +++ b/test/accelerate_tests/base_tests/po_update_kernel_test.py @@ -0,0 +1,512 @@ +''' + + +''' + +import unittest +import numpy as np +from ptypy.accelerate.base.kernels import PoUpdateKernel + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + + +class PoUpdateKernelTest(unittest.TestCase): + + def setUp(self): + import sys + np.set_printoptions(threshold=sys.maxsize, linewidth=np.inf) + + def tearDown(self): + np.set_printoptions() + + def test_init(self): + POUK = PoUpdateKernel() + + np.testing.assert_equal(POUK.kernels, + ['pr_update', 'ob_update'], + err_msg='PoUpdateKernel does not have the correct functions registered.') + + def prepare_arrays(self): + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 2 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): # + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + object_array_denominator = np.empty_like(object_array, dtype=FLOAT_TYPE) + for idx in range(G): + object_array_denominator[idx] = np.ones((H, I)) * (5 * idx + 2) # + 1j * np.ones((H, I)) * (5 * idx + 2) + + probe_denominator = np.empty_like(probe, dtype=FLOAT_TYPE) + for idx in range(D): + probe_denominator[idx] = np.ones((E, F)) * (5 * idx + 2) # + 1j * np.ones((E, F)) * (5 * idx + 2) + + return addr, object_array, object_array_denominator, probe, exit_wave, probe_denominator + + def test_ob_update(self): + # setup + addr, object_array, object_array_denominator, probe, exit_wave, probe_denominator = self.prepare_arrays() + + # test + POUK = PoUpdateKernel() + POUK.allocate() # doesn't do anything but is the call signature + POUK.ob_update(addr, object_array, object_array_denominator, probe, exit_wave) + + # assert + expected_object_array = np.array([[[15. + 1.j, 53. + 1.j, 53. + 1.j, 53. + 1.j, 53. + 1.j, 39. + 1.j, 1. + 1.j], + [77. + 1.j, 201. + 1.j, 201. + 1.j, 201. + 1.j, 201. + 1.j, 125. + 1.j, + 1. + 1.j], + [77. + 1.j, 201. + 1.j, 201. + 1.j, 201. + 1.j, 201. + 1.j, 125. + 1.j, + 1. + 1.j], + [77. + 1.j, 201. + 1.j, 201. + 1.j, 201. + 1.j, 201. + 1.j, 125. + 1.j, + 1. + 1.j], + [77. + 1.j, 201. + 1.j, 201. + 1.j, 201. + 1.j, 201. + 1.j, 125. + 1.j, + 1. + 1.j], + [63. + 1.j, 149. + 1.j, 149. + 1.j, 149. + 1.j, 149. + 1.j, 87. + 1.j, + 1. + 1.j], + [1. + 1.j, 1. + 1.j, 1. + 1.j, 1. + 1.j, 1. + 1.j, 1. + 1.j, 1. + 1.j]], + [[24. + 4.j, 68. + 4.j, 68. + 4.j, 68. + 4.j, 68. + 4.j, 48. + 4.j, 4. + 4.j], + [92. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 140. + 4.j, + 4. + 4.j], + [92. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 140. + 4.j, + 4. + 4.j], + [92. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 140. + 4.j, + 4. + 4.j], + [92. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 140. + 4.j, + 4. + 4.j], + [72. + 4.j, 164. + 4.j, 164. + 4.j, 164. + 4.j, 164. + 4.j, 96. + 4.j, + 4. + 4.j], + [4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j]]], + dtype=COMPLEX_TYPE) + np.testing.assert_array_equal(object_array, expected_object_array, + err_msg="The object array has not been updated as expected") + + # assert + expected_object_array_denominator = np.array([[[12., 22., 22., 22., 22., 12., 2.], + [22., 42., 42., 42., 42., 22., 2.], + [22., 42., 42., 42., 42., 22., 2.], + [22., 42., 42., 42., 42., 22., 2.], + [22., 42., 42., 42., 42., 22., 2.], + [12., 22., 22., 22., 22., 12., 2.], + [2., 2., 2., 2., 2., 2., 2.]], + + [[17., 27., 27., 27., 27., 17., 7.], + [27., 47., 47., 47., 47., 27., 7.], + [27., 47., 47., 47., 47., 27., 7.], + [27., 47., 47., 47., 47., 27., 7.], + [27., 47., 47., 47., 47., 27., 7.], + [17., 27., 27., 27., 27., 17., 7.], + [7., 7., 7., 7., 7., 7., 7.]]], dtype=FLOAT_TYPE) + np.testing.assert_array_equal(object_array_denominator, expected_object_array_denominator, + err_msg="The object array denominatorhas not been updated as expected") + + def test_pr_update(self): + # setup + addr, object_array, object_array_denominator, probe, exit_wave, probe_denominator = self.prepare_arrays() + + # test + POUK = PoUpdateKernel() + POUK.allocate() # this doesn't do anything, but is the call pattern. + POUK.pr_update(addr, probe, probe_denominator, object_array, exit_wave) + + # assert + expected_probe = np.array([[[313. + 1.j, 313. + 1.j, 313. + 1.j, 313. + 1.j, 313. + 1.j], + [313. + 1.j, 313. + 1.j, 313. + 1.j, 313. + 1.j, 313. + 1.j], + [313. + 1.j, 313. + 1.j, 313. + 1.j, 313. + 1.j, 313. + 1.j], + [313. + 1.j, 313. + 1.j, 313. + 1.j, 313. + 1.j, 313. + 1.j], + [313. + 1.j, 313. + 1.j, 313. + 1.j, 313. + 1.j, 313. + 1.j]], + + [[394. + 2.j, 394. + 2.j, 394. + 2.j, 394. + 2.j, 394. + 2.j], + [394. + 2.j, 394. + 2.j, 394. + 2.j, 394. + 2.j, 394. + 2.j], + [394. + 2.j, 394. + 2.j, 394. + 2.j, 394. + 2.j, 394. + 2.j], + [394. + 2.j, 394. + 2.j, 394. + 2.j, 394. + 2.j, 394. + 2.j], + [394. + 2.j, 394. + 2.j, 394. + 2.j, 394. + 2.j, 394. + 2.j]]], + dtype=COMPLEX_TYPE) + np.testing.assert_array_equal(probe, expected_probe, + err_msg="The probe has not been updated as expected") + + # assert + expected_probe_denominator = np.array([[[138., 138., 138., 138., 138.], + [138., 138., 138., 138., 138.], + [138., 138., 138., 138., 138.], + [138., 138., 138., 138., 138.], + [138., 138., 138., 138., 138.]], + + [[143., 143., 143., 143., 143.], + [143., 143., 143., 143., 143.], + [143., 143., 143., 143., 143.], + [143., 143., 143., 143., 143.], + [143., 143., 143., 143., 143.]]], dtype=FLOAT_TYPE) + np.testing.assert_array_equal(probe_denominator, expected_probe_denominator, + err_msg="The probe denominatorhas not been updated as expected") + + def test_pr_update_ML(self): + # setup + addr, object_array, object_array_denominator, probe, exit_wave, probe_denominator = self.prepare_arrays() + + # test + POUK = PoUpdateKernel() + POUK.allocate() # this doesn't do anything, but is the call pattern. + POUK.pr_update_ML(addr, probe, object_array, exit_wave) + + # assert + expected_probe = np.array([[[625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j], + [625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j], + [625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j], + [625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j], + [625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j]], + + [[786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j], + [786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j], + [786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j], + [786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j], + [786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j]]], + dtype=COMPLEX_TYPE) + np.testing.assert_array_equal(probe, expected_probe, + err_msg="The probe has not been updated as expected") + + def test_ob_update_ML(self): + # setup + addr, object_array, object_array_denominator, probe, exit_wave, probe_denominator = self.prepare_arrays() + + # test + POUK = PoUpdateKernel() + POUK.allocate() # this doesn't do anything, but is the call pattern. + POUK.ob_update_ML(addr, object_array, probe, exit_wave) + + # assert + expected_object_array = np.array( + [[[29. + 1.j, 105. + 1.j, 105. + 1.j, 105. + 1.j, 105. + 1.j, 77. + 1.j, 1. + 1.j], + [153. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 249. + 1.j, 1. + 1.j], + [153. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 249. + 1.j, 1. + 1.j], + [153. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 249. + 1.j, 1. + 1.j], + [153. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 249. + 1.j, 1. + 1.j], + [125. + 1.j, 297. + 1.j, 297. + 1.j, 297. + 1.j, 297. + 1.j, 173. + 1.j, 1. + 1.j], + [1. + 1.j, 1. + 1.j, 1. + 1.j, 1. + 1.j, 1. + 1.j, 1. + 1.j, 1. + 1.j]], + + [[44. + 4.j, 132. + 4.j, 132. + 4.j, 132. + 4.j, 132. + 4.j, 92. + 4.j, 4. + 4.j], + [180. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 276. + 4.j, 4. + 4.j], + [180. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 276. + 4.j, 4. + 4.j], + [180. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 276. + 4.j, 4. + 4.j], + [180. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 276. + 4.j, 4. + 4.j], + [140. + 4.j, 324. + 4.j, 324. + 4.j, 324. + 4.j, 324. + 4.j, 188. + 4.j, 4. + 4.j], + [4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j]]], + dtype=COMPLEX_TYPE) + np.testing.assert_array_equal(object_array, expected_object_array, + err_msg="The object array has not been updated as expected") + + + def test_pr_update_local(self): + # setup + B = 5 # frame size y + C = 5 # frame size x + + D = 1 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 1 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 1 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + auxiliary_wave = exit_wave.copy() * 1.5 + + object_norm = np.empty(shape=(1,B,C), dtype=FLOAT_TYPE) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): # + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + # test + POUK = PoUpdateKernel() + POUK.allocate() # this doesn't do anything, but is the call pattern. + POUK.ob_norm_local(addr, object_array, object_norm) + POUK.pr_update_local(addr, probe, object_array, exit_wave, auxiliary_wave, object_norm, object_norm.max()) + + # assert + expected_probe = np.array([[[0.5+1.j, 0.5+1.j, 0.5+1.j, 0.5+1.j, 0.5+1.j], + [0.5+1.j, 0.5+1.j, 0.5+1.j, 0.5+1.j, 0.5+1.j], + [0.5+1.j, 0.5+1.j, 0.5+1.j, 0.5+1.j, 0.5+1.j], + [0.5+1.j, 0.5+1.j, 0.5+1.j, 0.5+1.j, 0.5+1.j], + [0.5+1.j, 0.5+1.j, 0.5+1.j, 0.5+1.j, 0.5+1.j]]], dtype=COMPLEX_TYPE) + np.testing.assert_array_equal(probe, expected_probe, + err_msg="The probe has not been updated as expected") + + def test_ob_update_local(self): + # setup + B = 5 # frame size y + C = 5 # frame size x + + D = 1 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 1 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 1 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + auxiliary_wave = exit_wave.copy() * 2 + + probe_norm = np.empty(shape=(1,B,C), dtype=FLOAT_TYPE) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): # + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + # test + POUK = PoUpdateKernel() + POUK.allocate() # this doesn't do anything, but is the call pattern. + POUK.pr_norm_local(addr, probe, probe_norm) + POUK.ob_update_local(addr, object_array, probe, exit_wave, auxiliary_wave, probe_norm) + + # assert + expected_object_array = np.array([[[0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 1.+1.j, 1.+1.j], + [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 1.+1.j, 1.+1.j], + [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 1.+1.j, 1.+1.j], + [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 1.+1.j, 1.+1.j], + [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 1.+1.j, 1.+1.j], + [1.+1.j, 1.+1.j, 1.+1.j, 1.+1.j, 1.+1.j, 1.+1.j, 1.+1.j], + [1.+1.j, 1.+1.j, 1.+1.j, 1.+1.j, 1.+1.j, 1.+1.j, 1.+1.j]]], dtype=COMPLEX_TYPE) + np.testing.assert_array_equal(object_array, expected_object_array, + err_msg="The object array has not been updated as expected") + + def test_pr_norm_local(self): + # setup + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 1 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + probe_norm = np.empty(shape=(1,B,C), dtype=FLOAT_TYPE) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): # + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + # test + POUK = PoUpdateKernel() + POUK.allocate() # this doesn't do anything, but is the call pattern. + POUK.pr_norm_local(addr, probe, probe_norm) + + # assert + expected_probe_norm = np.array([[[10., 10., 10., 10., 10.], + [10., 10., 10., 10., 10.], + [10., 10., 10., 10., 10.], + [10., 10., 10., 10., 10.], + [10., 10., 10., 10., 10.]]], dtype=FLOAT_TYPE) + np.testing.assert_array_equal(probe_norm, expected_probe_norm, + err_msg="The probe norm has not been updated as expected") + + + def test_ob_norm_local(self): + # setup + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 1 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + object_norm = np.empty(shape=(1,B,C), dtype=FLOAT_TYPE) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): # + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + # test + POUK = PoUpdateKernel() + POUK.allocate() # this doesn't do anything, but is the call pattern. + POUK.ob_norm_local(addr, object_array, object_norm) + + # assert + expected_object_norm = np.array([[[34., 34., 34., 34., 34.], + [34., 34., 34., 34., 34.], + [34., 34., 34., 34., 34.], + [34., 34., 34., 34., 34.], + [34., 34., 34., 34., 34.]]], dtype=FLOAT_TYPE) + np.testing.assert_array_equal(object_norm, expected_object_norm, + err_msg="The object norm has not been updated as expected") + +if __name__ == '__main__': + unittest.main() diff --git a/test/accelerate_tests/base_tests/position_correction_kernel_test.py b/test/accelerate_tests/base_tests/position_correction_kernel_test.py new file mode 100644 index 000000000..50544c43e --- /dev/null +++ b/test/accelerate_tests/base_tests/position_correction_kernel_test.py @@ -0,0 +1,326 @@ +''' + + +''' + +import unittest +import numpy as np +from ptypy.accelerate.base.kernels import PositionCorrectionKernel +from ptypy import utils as u +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + + +class PositionCorrectionKernelTest(unittest.TestCase): + + def setUp(self): + import sys + np.set_printoptions(threshold=sys.maxsize, linewidth=np.inf) + self.params = u.Param() + self.params.nshifts = 4 + self.params.method = "Annealing" + self.params.amplitude = 2e-9 + self.params.start = 0 + self.params.stop = 10 + self.params.max_shift = 2e-9 + self.params.amplitude_decay = True + self.resolution = [1e-9,1e-9] + + def tearDown(self): + np.set_printoptions() + + def test_build_aux(self): + ''' + setup + ''' + B = 3 # frame size y + C = 3 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 2 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 2) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 2) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y):# + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + + ''' + test + ''' + auxiliary_wave = np.zeros((A, B, C), dtype=COMPLEX_TYPE) + + PCK = PositionCorrectionKernel(auxiliary_wave, total_number_modes, self.params, self.resolution) + PCK.allocate() # doesn't actually do anything at the moment + PCK.build_aux(auxiliary_wave, addr, object_array, probe) + + expected_auxiliary_wave = np.array([[[-3. +4.j, -3. +4.j, -3. +4.j], + [-3. +4.j, -3. +4.j, -3. +4.j], + [-3. +4.j, -3. +4.j, -3. +4.j]], + + [[-6.+13.j, -6.+13.j, -6.+13.j], + [-6.+13.j, -6.+13.j, -6.+13.j], + [-6.+13.j, -6.+13.j, -6.+13.j]], + + [[-4. +7.j, -4. +7.j, -4. +7.j], + [-4. +7.j, -4. +7.j, -4. +7.j], + [-4. +7.j, -4. +7.j, -4. +7.j]], + + [[-7.+22.j, -7.+22.j, -7.+22.j], + [-7.+22.j, -7.+22.j, -7.+22.j], + [-7.+22.j, -7.+22.j, -7.+22.j]], + + [[-3. +4.j, -3. +4.j, -3. +4.j], + [-3. +4.j, -3. +4.j, -3. +4.j], + [-3. +4.j, -3. +4.j, -3. +4.j]], + + [[-6.+13.j, -6.+13.j, -6.+13.j], + [-6.+13.j, -6.+13.j, -6.+13.j], + [-6.+13.j, -6.+13.j, -6.+13.j]], + + [[-4. +7.j, -4. +7.j, -4. +7.j], + [-4. +7.j, -4. +7.j, -4. +7.j], + [-4. +7.j, -4. +7.j, -4. +7.j]], + + [[-7.+22.j, -7.+22.j, -7.+22.j], + [-7.+22.j, -7.+22.j, -7.+22.j], + [-7.+22.j, -7.+22.j, -7.+22.j]], + + [[-3. +4.j, -3. +4.j, -3. +4.j], + [-3. +4.j, -3. +4.j, -3. +4.j], + [-3. +4.j, -3. +4.j, -3. +4.j]], + + [[-6.+13.j, -6.+13.j, -6.+13.j], + [-6.+13.j, -6.+13.j, -6.+13.j], + [-6.+13.j, -6.+13.j, -6.+13.j]], + + [[-4. +7.j, -4. +7.j, -4. +7.j], + [-4. +7.j, -4. +7.j, -4. +7.j], + [-4. +7.j, -4. +7.j, -4. +7.j]], + + [[-7.+22.j, -7.+22.j, -7.+22.j], + [-7.+22.j, -7.+22.j, -7.+22.j], + [-7.+22.j, -7.+22.j, -7.+22.j]], + + [[-3. +4.j, -3. +4.j, -3. +4.j], + [-3. +4.j, -3. +4.j, -3. +4.j], + [-3. +4.j, -3. +4.j, -3. +4.j]], + + [[-6.+13.j, -6.+13.j, -6.+13.j], + [-6.+13.j, -6.+13.j, -6.+13.j], + [-6.+13.j, -6.+13.j, -6.+13.j]], + + [[-4. +7.j, -4. +7.j, -4. +7.j], + [-4. +7.j, -4. +7.j, -4. +7.j], + [-4. +7.j, -4. +7.j, -4. +7.j]], + + [[-7.+22.j, -7.+22.j, -7.+22.j], + [-7.+22.j, -7.+22.j, -7.+22.j], + [-7.+22.j, -7.+22.j, -7.+22.j]]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(expected_auxiliary_wave, expected_auxiliary_wave, + err_msg="The auxiliary_wave has not been updated as expected") + + def test_fourier_error(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + G = 2 # number og object modes + + E = B # probe size y + F = C # probe size x + + scan_pts = 2 # one dimensional scan point number + + N = scan_pts ** 2 + total_number_modes = G * D + A = N * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + auxiliary_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + auxiliary_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + fmag = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured magnitudes NxAxB + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + mask = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE)# the masks for the measured magnitudes either 1xAxB or NxAxB + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((N,)) + Y = Y.reshape((N,)) + + addr = np.zeros((N, total_number_modes, 5, 3)) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [position_idx, 0, 0], + [position_idx, 0, 0]]) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + + mask_sum = mask.sum(-1).sum(-1) + + + PCK = PositionCorrectionKernel(auxiliary_wave, total_number_modes, self.params, self.resolution) + PCK.allocate() + PCK.fourier_error(auxiliary_wave, addr, fmag, mask, mask_sum) + + + expected_ferr = np.array([[[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [7.54033208e-01, 3.04839879e-01, 5.56465909e-02, 6.45330548e-03, 1.57260016e-01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [5.26210022e+00, 6.81290817e+00, 8.56371498e+00, 1.05145216e+01, 1.26653280e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[1.61048353e+00, 2.15810299e+00, 2.78572226e+00, 3.49334168e+00, 4.28096104e+00], + [5.14858055e+00, 6.09619951e+00, 7.12381887e+00, 8.23143768e+00, 9.41905785e+00], + [1.06866770e+01, 1.20342960e+01, 1.34619150e+01, 1.49695349e+01, 1.65571537e+01], + [1.82247734e+01, 1.99723930e+01, 2.18000126e+01, 2.37076321e+01, 2.56952515e+01], + [2.77628708e+01, 2.99104881e+01, 3.21381073e+01, 3.44457283e+01, 3.68333473e+01]], + + [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [6.31699409e+01, 6.82966690e+01, 7.36233978e+01, 7.91501160e+01, 8.48768463e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [1.23437180e+02, 1.30563919e+02, 1.37890640e+02, 1.45417374e+02, 1.53144089e+02], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[4.58764343e+01, 4.86257210e+01, 5.14550095e+01, 5.43642960e+01, 5.73535805e+01], + [6.04228668e+01, 6.35721550e+01, 6.68014374e+01, 7.01107254e+01, 7.35000076e+01], + [7.69692993e+01, 8.05185852e+01, 8.41478729e+01, 8.78571548e+01, 9.16464386e+01], + [9.55157242e+01, 9.94650116e+01, 1.03494293e+02, 1.07603584e+02, 1.11792870e+02], + [1.16062157e+02, 1.20411446e+02, 1.24840721e+02, 1.29350006e+02, 1.33939301e+02]]], + dtype=FLOAT_TYPE) + np.testing.assert_array_equal(PCK.npy.ferr, expected_ferr, + err_msg="ferr does not give the expected error " + "for the fourier_update_kernel.fourier_error emthods") + + def test_error_reduce(self): + # array from the previous test + ferr = np.array([[[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [7.54033208e-01, 3.04839879e-01, 5.56465909e-02, 6.45330548e-03, 1.57260016e-01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [5.26210022e+00, 6.81290817e+00, 8.56371498e+00, 1.05145216e+01, 1.26653280e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[1.61048353e+00, 2.15810299e+00, 2.78572226e+00, 3.49334168e+00, 4.28096104e+00], + [5.14858055e+00, 6.09619951e+00, 7.12381887e+00, 8.23143768e+00, 9.41905785e+00], + [1.06866770e+01, 1.20342960e+01, 1.34619150e+01, 1.49695349e+01, 1.65571537e+01], + [1.82247734e+01, 1.99723930e+01, 2.18000126e+01, 2.37076321e+01, 2.56952515e+01], + [2.77628708e+01, 2.99104881e+01, 3.21381073e+01, 3.44457283e+01, 3.68333473e+01]], + + [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [6.31699409e+01, 6.82966690e+01, 7.36233978e+01, 7.91501160e+01, 8.48768463e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [1.23437180e+02, 1.30563919e+02, 1.37890640e+02, 1.45417374e+02, 1.53144089e+02], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[4.58764343e+01, 4.86257210e+01, 5.14550095e+01, 5.43642960e+01, 5.73535805e+01], + [6.04228668e+01, 6.35721550e+01, 6.68014374e+01, 7.01107254e+01, 7.35000076e+01], + [7.69692993e+01, 8.05185852e+01, 8.41478729e+01, 8.78571548e+01, 9.16464386e+01], + [9.55157242e+01, 9.94650116e+01, 1.03494293e+02, 1.07603584e+02, 1.11792870e+02], + [1.16062157e+02, 1.20411446e+02, 1.24840721e+02, 1.29350006e+02, 1.33939301e+02]]], + dtype=FLOAT_TYPE) + + + # print(repr(ferr)) + # print(ferr.shape) + # print(repr(ferr)) + auxiliary_shape = (4, 5, 5) + fake_aux = np.zeros(auxiliary_shape, dtype=COMPLEX_TYPE) + scan_pts = 2 # one dimensional scan point number + N = scan_pts ** 2 + + addr = np.zeros((N, 1, 5, 3)) + + PCK = PositionCorrectionKernel(fake_aux, 1, self.params, self.resolution) + PCK.allocate() + err_fmag = np.zeros(N, dtype=FLOAT_TYPE) + PCK.error_reduce(addr, err_fmag) + + + + expected_ferr = np.array([[[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [7.54033208e-01, 3.04839879e-01, 5.56465909e-02, 6.45330548e-03, 1.57260016e-01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [5.26210022e+00, 6.81290817e+00, 8.56371498e+00, 1.05145216e+01, 1.26653280e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[1.61048353e+00, 2.15810299e+00, 2.78572226e+00, 3.49334168e+00, 4.28096104e+00], + [5.14858055e+00, 6.09619951e+00, 7.12381887e+00, 8.23143768e+00, 9.41905785e+00], + [1.06866770e+01, 1.20342960e+01, 1.34619150e+01, 1.49695349e+01, 1.65571537e+01], + [1.82247734e+01, 1.99723930e+01, 2.18000126e+01, 2.37076321e+01, 2.56952515e+01], + [2.77628708e+01, 2.99104881e+01, 3.21381073e+01, 3.44457283e+01, 3.68333473e+01]], + + [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [6.31699409e+01, 6.82966690e+01, 7.36233978e+01, 7.91501160e+01, 8.48768463e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [1.23437180e+02, 1.30563919e+02, 1.37890640e+02, 1.45417374e+02, 1.53144089e+02], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[4.58764343e+01, 4.86257210e+01, 5.14550095e+01, 5.43642960e+01, 5.73535805e+01], + [6.04228668e+01, 6.35721550e+01, 6.68014374e+01, 7.01107254e+01, 7.35000076e+01], + [7.69692993e+01, 8.05185852e+01, 8.41478729e+01, 8.78571548e+01, 9.16464386e+01], + [9.55157242e+01, 9.94650116e+01, 1.03494293e+02, 1.07603584e+02, 1.11792870e+02], + [1.16062157e+02, 1.20411446e+02, 1.24840721e+02, 1.29350006e+02, 1.33939301e+02]]], + dtype=FLOAT_TYPE) + + np.testing.assert_array_equal(expected_ferr, ferr, err_msg="The fourier_update_kernel.error_reduce" + "is not behaving as expected.") + + +if __name__ == '__main__': + unittest.main() diff --git a/test/accelerate_tests/cuda_pycuda_tests/__init__.py b/test/accelerate_tests/cuda_pycuda_tests/__init__.py new file mode 100644 index 000000000..04582430f --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/__init__.py @@ -0,0 +1,43 @@ +import unittest +import numpy as np + +# shall we run the performance tests? +perfrun = False + +def have_pycuda(): + try: + import pycuda.driver + return True + except: + return False + +if have_pycuda(): + import pycuda.driver as cuda + from pycuda import gpuarray + from pycuda.tools import make_default_context + from ptypy.accelerate import cuda_pycuda + + # make sure this is called once + cuda.init() + +@unittest.skipIf(not have_pycuda(), "no PyCUDA or GPU drivers available") +class PyCudaTest(unittest.TestCase): + + def setUp(self): + import sys + np.set_printoptions(threshold=sys.maxsize, linewidth=np.inf) + self.ctx = make_default_context() + self.stream = cuda.Stream() + # enable assertions in CUDA kernels for testing + if not 'perf' in self._testMethodName: + self.opts_old = cuda_pycuda.debug_options.copy() + if '-DNDEBUG' in cuda_pycuda.debug_options: + cuda_pycuda.debug_options.remove('-DNDEBUG') + + def tearDown(self): + np.set_printoptions() + self.ctx.pop() + self.ctx.detach() + if not 'perf' in self._testMethodName: + cuda_pycuda.debug_options = self.opts_old + diff --git a/test/accelerate_tests/cuda_pycuda_tests/address_manglers_test.py b/test/accelerate_tests/cuda_pycuda_tests/address_manglers_test.py new file mode 100644 index 000000000..2704dcf97 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/address_manglers_test.py @@ -0,0 +1,77 @@ +import unittest +import numpy as np +from . import perfrun, PyCudaTest, have_pycuda + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.base import address_manglers as am + from ptypy.accelerate.cuda_pycuda import address_manglers as gam + + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +class AddressManglersTest(PyCudaTest): + + def prepare_addresses(self, max_bound=10, scan_pts=2, num_modes=3): + total_number_scan_positions = scan_pts ** 2 + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + max_bound # max bound is added in the DM_serial engine. + Y = Y.reshape((total_number_scan_positions)) + max_bound + + addr_original = np.zeros((total_number_scan_positions, num_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): # + mode_idx = 0 + for pr_mode in range(num_modes): + for ob_mode in range(1): + addr_original[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + return addr_original + + def test_get_address_REGRESSION(self): + # the other manglers are using the BaseMangler's get_address function + # so we set the deltas in a BaseMangler object and test get_address + + scan_pts=2 + addr_original = self.prepare_addresses(scan_pts=scan_pts) + addr_original_dev = gpuarray.to_gpu(addr_original) + nshifts=1 + step_size=2 + mglr = gam.BaseMangler(step_size, 50, 100, nshifts, max_bound=2) + # 2 shifts, with positive/negative shifting + mglr.delta = np.array([ + [1, 2], + [-4, -2] + ], dtype=np.int32) + mglr._setup_delta_gpu() + + addr1 = addr_original_dev.copy() + mglr.get_address(0, addr_original_dev, addr1, 10, 9) + + addr2 = addr_original_dev.copy() + mglr.get_address(1, addr_original_dev, addr2, 10, 9) + + exp1 = np.copy(addr_original) + exp2 = np.copy(addr_original) + # element-wise here to prepare reference + for f in range(addr_original.shape[0]): + for m in range(addr_original.shape[1]): + exp1[f, m, 1, 1] = max(0, min(10, addr_original[f, m, 1, 1] + 1)) + exp1[f, m, 1, 2] = max(0, min(9, addr_original[f, m, 1, 2] + 2)) + exp2[f, m, 1, 1] = max(0, min(10, addr_original[f, m, 1, 1] - 4)) + exp2[f, m, 1, 2] = max(0, min(9, addr_original[f, m, 1, 2] - 2)) + + np.testing.assert_array_equal(addr2.get(), exp2) + np.testing.assert_array_equal(addr1.get(), exp1) + diff --git a/test/accelerate_tests/cuda_pycuda_tests/array_utils_test.py b/test/accelerate_tests/cuda_pycuda_tests/array_utils_test.py new file mode 100644 index 000000000..912b68bfe --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/array_utils_test.py @@ -0,0 +1,540 @@ +''' + + +''' + +import unittest +import numpy as np +from . import perfrun, PyCudaTest, have_pycuda +from ptypy.accelerate.base import array_utils as au + +if have_pycuda(): + from pycuda import gpuarray + import ptypy.accelerate.cuda_pycuda.array_utils as gau + +class ArrayUtilsTest(PyCudaTest): + + def test_dot_float_float(self): + ## Arrange + X,Y,Z = np.indices((3,3,1001), dtype=np.float32) + A = 10 ** Y + A_dev = gpuarray.to_gpu(A) + + ## Act + AU = gau.ArrayUtilsKernel(acc_dtype=np.float32) + out_dev = AU.dot(A_dev, A_dev) + out = out_dev.get() + + ## Assert + np.testing.assert_allclose(out, 30333303.0, rtol=1e-7) + + def test_dot_float_double(self): + ## Arrange + X,Y,Z = np.indices((3,3,1001), dtype=np.float32) + A = 10 ** Y + A_dev = gpuarray.to_gpu(A) + + ## Act + AU = gau.ArrayUtilsKernel(acc_dtype=np.float64) + out_dev = AU.dot(A_dev, A_dev) + out = out_dev.get() + + ## Assert + np.testing.assert_equal(out, 30333303.0) + + def test_dot_complex_float(self): + ## Arrange + X,Y,Z = np.indices((3,3,1001), dtype=np.float32) + A = 10 ** Y + 1j * 10 ** X + A_dev = gpuarray.to_gpu(A) + + ## Act + AU = gau.ArrayUtilsKernel(acc_dtype=np.float32) + out_dev = AU.dot(A_dev, A_dev) + out = out_dev.get() + + ## Assert + np.testing.assert_allclose(out, 60666606.0, rtol=1e-7) + + def test_dot_complex_double(self): + ## Arrange + X,Y,Z = np.indices((3,3,1001), dtype=np.float32) + A = 10 ** Y + 1j * 10 ** X + A_dev = gpuarray.to_gpu(A) + + ## Act + AU = gau.ArrayUtilsKernel(acc_dtype=np.float64) + out_dev = AU.dot(A_dev, A_dev) + out = out_dev.get() + + ## Assert + np.testing.assert_array_equal(out, 60666606.0) + + @unittest.skipIf(not perfrun, "Performance test") + def test_dot_performance(self): + ## Arrange + X,Y,Z = np.indices((3,3,1021301), dtype=np.float32) + A = 10 ** Y + 1j * 10 ** X + A_dev = gpuarray.to_gpu(A) + + ## Act + AU = gau.ArrayUtilsKernel(acc_dtype=np.float64) + out_dev = AU.dot(A_dev, A_dev) + + def test_transpose_2D(self): + ## Arrange + inp,_ = np.indices((5,3), dtype=np.int32) + inp_dev = gpuarray.to_gpu(inp) + out_dev = gpuarray.empty((3,5), dtype=np.int32) + + ## Act + AU = gau.TransposeKernel() + AU.transpose(inp_dev, out_dev) + + ## Assert + out_exp = np.transpose(inp, (1, 0)) + out = out_dev.get() + np.testing.assert_array_equal(out, out_exp) + + def test_transpose_2D_large(self): + ## Arrange + inp,_ = np.indices((137,61), dtype=np.int32) + inp_dev = gpuarray.to_gpu(inp) + out_dev = gpuarray.empty((61,137), dtype=np.int32) + + ## Act + AU = gau.TransposeKernel() + AU.transpose(inp_dev, out_dev) + + ## Assert + out_exp = np.transpose(inp, (1, 0)) + out = out_dev.get() + np.testing.assert_array_equal(out, out_exp) + + def test_transpose_4D(self): + ## Arrange + inp = np.random.randint(0, 10000, (250, 3, 5, 3), dtype=np.int32) # like addr + inp_dev = gpuarray.to_gpu(inp) + out_dev = gpuarray.empty((5, 3, 250, 3), dtype=np.int32) + + ## Act + AU = gau.TransposeKernel() + AU.transpose(inp_dev.reshape(750, 15), out_dev.reshape(15, 750)) + + ## Assert + out_exp = np.transpose(inp, (2, 3, 0, 1)) + out = out_dev.get() + np.testing.assert_array_equal(out, out_exp) + + def test_complex_gaussian_filter_1d_no_blurring_UNITY(self): + # Arrange + data = np.zeros((11,), dtype=np.complex64) + data[5] = 1.0 +1.0j + mfs = [0] + data_dev = gpuarray.to_gpu(data) + tmp_dev = gpuarray.empty((11,), dtype=np.complex64) + + # Act + GS = gau.GaussianSmoothingKernel() + GS.convolution(data_dev, mfs, tmp=tmp_dev) + + # Assert + out_exp = au.complex_gaussian_filter(data, mfs) + out = data_dev.get() + self.assertTrue(np.testing.assert_allclose(out_exp, out, rtol=1e-5) is None) + + def test_complex_gaussian_filter_1d_little_blurring_UNITY(self): + # Arrange + data = np.zeros((11,), dtype=np.complex64) + data[5] = 1.0 +1.0j + mfs = [0.2] + data_dev = gpuarray.to_gpu(data) + tmp_dev = gpuarray.empty((11,), dtype=np.complex64) + + # Act + GS = gau.GaussianSmoothingKernel() + GS.convolution(data_dev, mfs, tmp=tmp_dev) + + # Assert + out_exp = au.complex_gaussian_filter(data, mfs) + out = data_dev.get() + np.testing.assert_allclose(out_exp, out, rtol=1e-5) + + + def test_complex_gaussian_filter_1d_more_blurring_UNITY(self): + # Arrange + data = np.zeros((11,), dtype=np.complex64) + data[5] = 1.0 +1.0j + mfs = [2.0] + data_dev = gpuarray.to_gpu(data) + tmp_dev = gpuarray.empty((11,), dtype=np.complex64) + + # Act + GS = gau.GaussianSmoothingKernel() + GS.convolution(data_dev, mfs, tmp=tmp_dev) + + # Assert + out_exp = au.complex_gaussian_filter(data, mfs) + out = data_dev.get() + np.testing.assert_allclose(out_exp, out, rtol=1e-5) + + def test_complex_gaussian_filter_2d_no_blurring_UNITY(self): + # Arrange + data = np.zeros((11, 11), dtype=np.complex64) + data[5, 5] = 1.0+1.0j + mfs = 0.0,0.0 + data_dev = gpuarray.to_gpu(data) + tmp_dev = gpuarray.empty((11,11), dtype=np.complex64) + + # Act + GS = gau.GaussianSmoothingKernel() + GS.convolution(data_dev, mfs, tmp=tmp_dev) + + # Assert + out_exp = au.complex_gaussian_filter(data, mfs) + out = data_dev.get() + np.testing.assert_allclose(out_exp, out, rtol=1e-5) + + def test_complex_gaussian_filter_2d_little_blurring_UNITY(self): + # Arrange + data = np.zeros((11, 11), dtype=np.complex64) + data[5, 5] = 1.0+1.0j + mfs = 0.2,0.2 + data_dev = gpuarray.to_gpu(data) + tmp_dev = gpuarray.empty((11,11),dtype=np.complex64) + + # Act + GS = gau.GaussianSmoothingKernel() + GS.convolution(data_dev, mfs, tmp=tmp_dev) + + # Assert + out_exp = au.complex_gaussian_filter(data, mfs) + out = data_dev.get() + np.testing.assert_allclose(out_exp, out, rtol=1e-5) + + def test_complex_gaussian_filter_2d_more_blurring_UNITY(self): + # Arrange + data = np.zeros((8, 8), dtype=np.complex64) + data[3:5, 3:5] = 2.0+2.0j + mfs = 3.0,4.0 + data_dev = gpuarray.to_gpu(data) + #tmp_dev = gpuarray.empty((8,8), dtype=np.complex64) + + # Act + GS = gau.GaussianSmoothingKernel() + GS.convolution(data_dev, mfs) + + # Assert + out_exp = au.complex_gaussian_filter(data, mfs) + out = data_dev.get() + np.testing.assert_allclose(out_exp, out, rtol=1e-4) + + def test_complex_gaussian_filter_2d_nonsquare_UNITY(self): + # Arrange + data = np.zeros((32, 16), dtype=np.complex64) + data[3:4, 11:12] = 2.0+2.0j + data[3:5, 3:5] = 2.0+2.0j + data[20:25,3:5] = 2.0+2.0j + mfs = 1.0,1.0 + data_dev = gpuarray.to_gpu(data) + tmp_dev = gpuarray.empty(data_dev.shape, dtype=np.complex64) + + # Act + GS = gau.GaussianSmoothingKernel() + GS.convolution(data_dev, mfs, tmp=tmp_dev) + + # Assert + out_exp = au.complex_gaussian_filter(data, mfs) + out = data_dev.get() + + np.testing.assert_allclose(out_exp, out, rtol=1e-4) + + def test_complex_gaussian_filter_2d_batched(self): + # Arrange + batch_number = 2 + A = 5 + B = 5 + data = np.zeros((batch_number, A, B), dtype=np.complex64) + data[:, 2:3, 2:3] = 2.0+2.0j + mfs = 3.0,4.0 + data_dev = gpuarray.to_gpu(data) + tmp_dev = gpuarray.empty((batch_number,A,B), dtype=np.complex64) + + # Act + GS = gau.GaussianSmoothingKernel() + GS.convolution(data_dev, mfs, tmp=tmp_dev) + + # Assert + out_exp = au.complex_gaussian_filter(data, mfs) + out = data_dev.get() + np.testing.assert_allclose(out_exp, out, rtol=1e-4) + + + def test_crop_pad_simple_1_UNITY(self): + # pad, integer, 2D + B = np.indices((4, 4), dtype=np.int32).sum(0) + A = np.zeros((6, 6), dtype=B.dtype) + B_dev = gpuarray.to_gpu(B) + A_dev = gpuarray.to_gpu(A) + + # Act + au.crop_pad_2d_simple(A, B) + k = gau.CropPadKernel(queue=self.stream) + k.crop_pad_2d_simple(A_dev, B_dev) + + # Assert + np.testing.assert_allclose(A, A_dev.get(), rtol=1e-6, atol=1e-6) + + def test_crop_pad_simple_2_UNITY(self): + # crop, float, 3D + B = np.indices((4, 4), dtype=np.float32) + A = np.zeros((2, 2, 2), dtype=B.dtype) + B_dev = gpuarray.to_gpu(B) + A_dev = gpuarray.to_gpu(A) + + # Act + au.crop_pad_2d_simple(A, B) + k = gau.CropPadKernel(queue=self.stream) + k.crop_pad_2d_simple(A_dev, B_dev) + + + # Assert + np.testing.assert_allclose(A, A_dev.get(), rtol=1e-6, atol=1e-6) + + def test_crop_pad_simple_3_UNITY(self): + # crop/pad, complex, 3D + B = np.indices((4, 3), dtype=np.complex64) + B = np.indices((4, 3), dtype=np.complex64) + 1j * B[::-1, :, :] + A = np.zeros((2, 2, 5), dtype=B.dtype) + B_dev = gpuarray.to_gpu(B) + A_dev = gpuarray.to_gpu(A) + + # Act + au.crop_pad_2d_simple(A, B) + k = gau.CropPadKernel(queue=self.stream) + k.crop_pad_2d_simple(A_dev, B_dev) + + # Assert + np.testing.assert_allclose(A, A_dev.get(), rtol=1e-6, atol=1e-6) + + def test_crop_pad_simple_difflike_UNITY(self): + np.random.seed(1983) + # crop/pad, 4D + D = np.random.randint(0, 3000, (100,256,256)).astype(np.float32) + A = np.zeros((100,260,260), dtype=D.dtype) + B = np.zeros((100,250,250), dtype=D.dtype) + B_dev = gpuarray.to_gpu(B) + A_dev = gpuarray.to_gpu(A) + D_dev = gpuarray.to_gpu(D) + + # Act + au.crop_pad_2d_simple(A, D) + au.crop_pad_2d_simple(B, D) + k = gau.CropPadKernel(queue=self.stream) + k.crop_pad_2d_simple(A_dev, D_dev) + k.crop_pad_2d_simple(B_dev, D_dev) + + # Assert + np.testing.assert_allclose(A, A_dev.get(), rtol=1e-6, atol=1e-6) + np.testing.assert_allclose(B, B_dev.get(), rtol=1e-6, atol=1e-6) + + def test_crop_pad_simple_oblike_UNITY(self): + np.random.seed(1983) + # crop/pad, 4D + B = np.random.rand(2,1230,1434).astype(np.complex64) \ + +2j * np.pi * np.random.randn(2,1230,1434).astype(np.complex64) + A = np.ones((2,1000,1500), dtype=B.dtype) + B_dev = gpuarray.to_gpu(B) + A_dev = gpuarray.to_gpu(A) + + # Act + au.crop_pad_2d_simple(A, B) + k = gau.CropPadKernel(queue=self.stream) + k.crop_pad_2d_simple(A_dev, B_dev) + + # Assert + np.testing.assert_allclose(A, A_dev.get(), rtol=1e-6, atol=1e-6) + + def test_max_abs2_complex_UNITY(self): + np.random.seed(1983) + X = (np.random.randint(-1000, 1000, (3,100,200)).astype(np.float32) + \ + 1j * np.random.randint(-1000, 1000, (3,100,200)).astype(np.float32)).astype(np.complex64) + out = np.zeros((1,), dtype=np.float32) + X_dev = gpuarray.to_gpu(X) + out_dev = gpuarray.to_gpu(out) + + out = au.max_abs2(X) + + MAK = gau.MaxAbs2Kernel(queue=self.stream) + MAK.max_abs2(X_dev, out_dev) + + np.testing.assert_allclose(out_dev.get(), out, rtol=1e-6, atol=1e-6, + err_msg="The object norm array has not been updated as expected") + + def test_max_abs2_float_UNITY(self): + np.random.seed(1983) + X = np.random.randint(-1000, 1000, (3,100,200)).astype(np.float32) + + out = np.zeros((1,), dtype=np.float32) + X_dev = gpuarray.to_gpu(X) + out_dev = gpuarray.to_gpu(out) + + out = au.max_abs2(X) + + MAK = gau.MaxAbs2Kernel(queue=self.stream) + MAK.max_abs2(X_dev, out_dev) + + np.testing.assert_allclose(out_dev.get(), out, rtol=1e-6, atol=1e-6, + err_msg="The object norm array has not been updated as expected") + + + def test_clip_magnitudes_to_range_UNITY(self): + np.random.seed(1987) + A = np.random.random((2,10,10)) + B = A[0] + 1j* A[1] + B = B.astype(np.complex64) + B_gpu = gpuarray.to_gpu(B) + + au.clip_complex_magnitudes_to_range(B, 0.2,0.8) + CMK = gau.ClipMagnitudesKernel() + CMK.clip_magnitudes_to_range(B_gpu, 0.2, 0.8) + + np.testing.assert_allclose(B_gpu.get(), B, rtol=1e-6, atol=1e-6, + err_msg="The magnitudes of the array have not been clipped as expected") + + + def test_mass_center_2d_UNITY(self): + np.random.seed(1987) + A = np.random.random((128, 128)).astype(np.float32) + A_gpu = gpuarray.to_gpu(A) + + out = au.mass_center(A) + + MCK = gau.MassCenterKernel() + mc_d = MCK.mass_center(A_gpu) + mc = mc_d.get() + + np.testing.assert_allclose(out, mc, rtol=1e-6, atol=1e-6, + err_msg="The centre of mass of the array has not been calculated as expected") + + + def test_mass_center_3d_UNITY(self): + np.random.seed(1987) + A = np.random.random((128, 128, 128)).astype(np.float32) + A_gpu = gpuarray.to_gpu(A) + + out = au.mass_center(A) + + MCK = gau.MassCenterKernel() + mc_d = MCK.mass_center(A_gpu) + mc = mc_d.get() + + np.testing.assert_allclose(out, mc, rtol=1e-6, atol=1e-6, + err_msg="The centre of mass of the array has not been calculated as expected") + + def test_abs2sum_complex_float_UNITY(self): + np.random.seed(1987) + A = np.random.random((3, 321, 123)).astype(np.float32) + B = A + A**2 * 1j + B_gpu = gpuarray.to_gpu(B) + + out = au.abs2(B).sum(0) + + A2SK = gau.Abs2SumKernel(dtype=B_gpu.dtype) + a2s_d = A2SK.abs2sum(B_gpu) + a2s = a2s_d.get() + + np.testing.assert_allclose(out, a2s, rtol=1e-6, atol=1e-6, + err_msg="The sum of absolute values along the first dimension has not been calculated as expected") + + def test_abs2sum_complex_double_UNITY(self): + np.random.seed(1987) + A = np.random.random((3, 321, 123)).astype(np.float64) + B = A + A**2 * 1j + B_gpu = gpuarray.to_gpu(B) + + out = au.abs2(B).sum(0) + + A2SK = gau.Abs2SumKernel(dtype=B_gpu.dtype) + a2s_d = A2SK.abs2sum(B_gpu) + a2s = a2s_d.get() + + np.testing.assert_allclose(out, a2s, rtol=1e-6, atol=1e-6, + err_msg="The sum of absolute values along the first dimension has not been calculated as expected") + + def test_interpolate_shift_2D_UNITY(self): + np.random.seed(1987) + A = np.random.random((259, 252)).astype(np.float32) + A = A + A**2 * 1j + A_gpu = gpuarray.to_gpu(A) + + cen_old = np.array([100.123, 5.678]).astype(np.float32) + cen_new = np.array([128.5, 127.5]).astype(np.float32) + shift = cen_new - cen_old + + out = au.interpolated_shift(A, shift, do_linear=True) + + ISK = gau.InterpolatedShiftKernel() + isk_d = ISK.interpolate_shift(A_gpu, shift) + isk = isk_d.get() + + np.testing.assert_allclose(out, isk, rtol=1e-6, atol=1e-6, + err_msg="The shifting of array has not been calculated as expected") + + def test_interpolate_shift_3D_UNITY(self): + np.random.seed(1987) + A = np.random.random((3, 200, 300)).astype(np.float32) + A = A + A**2 * 1j + A_gpu = gpuarray.to_gpu(A) + + cen_old = np.array([0., 180.123, 5.678]).astype(np.float32) + cen_new = np.array([0., 128.5, 127.5]).astype(np.float32) + shift = cen_new - cen_old + + out = au.interpolated_shift(A, shift, do_linear=True) + + ISK = gau.InterpolatedShiftKernel() + isk_d = ISK.interpolate_shift(A_gpu, shift[1:]) + isk = isk_d.get() + + np.testing.assert_allclose(out, isk, rtol=1e-6, atol=1e-6, + err_msg="The shifting of array has not been calculated as expected") + + def test_interpolate_shift_integer_UNITY(self): + np.random.seed(1987) + A = np.random.random((3, 200, 300)).astype(np.float32) + A = A + A**2 * 1j + A_gpu = gpuarray.to_gpu(A) + + cen_old = np.array([0, 180, 5]).astype(np.float32) + cen_new = np.array([0, 128, 127]).astype(np.float32) + shift = cen_new - cen_old + + out = au.interpolated_shift(A, shift, do_linear=True) + + ISK = gau.InterpolatedShiftKernel() + isk_d = ISK.interpolate_shift(A_gpu, shift[1:]) + isk = isk_d.get() + + np.testing.assert_allclose(out, isk, rtol=1e-6, atol=1e-6, + err_msg="The shifting of array has not been calculated as expected") + + def test_interpolate_shift_no_shift_UNITY(self): + np.random.seed(1987) + A = np.random.random((3, 200, 300)).astype(np.float32) + A = A + A**2 * 1j + A_gpu = gpuarray.to_gpu(A) + + cen_old = np.array([0, 0, 0]).astype(np.float32) + cen_new = np.array([0, 0, 0]).astype(np.float32) + shift = cen_new - cen_old + + out = au.interpolated_shift(A, shift, do_linear=True) + + ISK = gau.InterpolatedShiftKernel() + isk_d = ISK.interpolate_shift(A_gpu, shift[1:]) + isk = isk_d.get() + + np.testing.assert_allclose(out, isk, rtol=1e-6, atol=1e-6, + err_msg="The shifting of array has not been calculated as expected") + diff --git a/test/accelerate_tests/cuda_pycuda_tests/auxiliary_wave_kernel_test.py b/test/accelerate_tests/cuda_pycuda_tests/auxiliary_wave_kernel_test.py new file mode 100644 index 000000000..4765aca3b --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/auxiliary_wave_kernel_test.py @@ -0,0 +1,666 @@ +''' + + +''' + +import unittest +import numpy as np +from . import perfrun, PyCudaTest, have_pycuda + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.kernels import AuxiliaryWaveKernel + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +class AuxiliaryWaveKernelTest(PyCudaTest): + + def prepare_arrays(self, performance=False, scan_points=None): + if not performance: + B = 3 # frame size y + C = 3 # frame size x + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + if scan_points is None: + scan_pts = 2 # one dimensional scan point number + else: + scan_pts = scan_points + else: + B = 128 + C = 128 + D = 2 + E = B + F = C + npts_greater_than = 1215 + G = 4 + if scan_points is None: + scan_pts = 14 + else: + scan_pts = scan_points + + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): # + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + if performance: + print('addr={}, obj={}, pr={}, ex={}'.format(addr.shape, object_array.shape, probe.shape, exit_wave.shape)) + # assert False + + return addr, object_array, probe, exit_wave + + def copy_to_gpu(self, addr, object_array, probe, exit_wave): + return (gpuarray.to_gpu(addr), + gpuarray.to_gpu(object_array), + gpuarray.to_gpu(probe), + gpuarray.to_gpu(exit_wave)) + + def test_init(self): + # should we really test for private attributes? + # Only the public interface should be checked - what clients rely on + attrs = ["_ob_shape", + "_ob_id"] + + AWK = AuxiliaryWaveKernel(self.stream) + for attr in attrs: + self.assertTrue(hasattr(AWK, attr), msg="AuxiliaryWaveKernel does not have attribute: %s" % attr) + + np.testing.assert_equal(AWK.kernels, + ['build_aux', 'build_exit'], + err_msg='AuxiliaryWaveKernel does not have the correct functions registered.') + + def test_build_aux_same_as_exit_REGRESSION(self): + ## Arrange + cpudata = self.prepare_arrays() + addr, object_array, probe, exit_wave = self.copy_to_gpu(*cpudata) + auxiliary_wave = gpuarray.zeros_like(exit_wave) + + ## Act + AWK = AuxiliaryWaveKernel(self.stream) + alpha_set = FLOAT_TYPE(1.0) + + AWK.build_aux(auxiliary_wave, addr, object_array, probe, exit_wave, alpha=alpha_set) + + expected_auxiliary_wave = np.array([[[-1. + 3.j, -1. + 3.j, -1. + 3.j], + [-1. + 3.j, -1. + 3.j, -1. + 3.j], + [-1. + 3.j, -1. + 3.j, -1. + 3.j]], + [[-2.+14.j, -2.+14.j, -2.+14.j], + [-2.+14.j, -2.+14.j, -2.+14.j], + [-2.+14.j, -2.+14.j, -2.+14.j]], + [[-3. + 5.j, -3. + 5.j, -3. + 5.j], + [-3. + 5.j, -3. + 5.j, -3. + 5.j], + [-3. + 5.j, -3. + 5.j, -3. + 5.j]], + [[-4.+28.j, -4.+28.j, -4.+28.j], + [-4.+28.j, -4.+28.j, -4.+28.j], + [-4.+28.j, -4.+28.j, -4.+28.j]], + [[-5. - 1.j, -5. - 1.j, -5. - 1.j], + [-5. - 1.j, -5. - 1.j, -5. - 1.j], + [-5. - 1.j, -5. - 1.j, -5. - 1.j]], + [[-6.+10.j, -6.+10.j, -6.+10.j], + [-6.+10.j, -6.+10.j, -6.+10.j], + [-6.+10.j, -6.+10.j, -6.+10.j]], + [[-7. + 1.j, -7. + 1.j, -7. + 1.j], + [-7. + 1.j, -7. + 1.j, -7. + 1.j], + [-7. + 1.j, -7. + 1.j, -7. + 1.j]], + [[-8.+24.j, -8.+24.j, -8.+24.j], + [-8.+24.j, -8.+24.j, -8.+24.j], + [-8.+24.j, -8.+24.j, -8.+24.j]], + [[-9. - 5.j, -9. - 5.j, -9. - 5.j], + [-9. - 5.j, -9. - 5.j, -9. - 5.j], + [-9. - 5.j, -9. - 5.j, -9. - 5.j]], + [[-10. + 6.j, -10. + 6.j, -10. + 6.j], + [-10. + 6.j, -10. + 6.j, -10. + 6.j], + [-10. + 6.j, -10. + 6.j, -10. + 6.j]], + [[-11. - 3.j, -11. - 3.j, -11. - 3.j], + [-11. - 3.j, -11. - 3.j, -11. - 3.j], + [-11. - 3.j, -11. - 3.j, -11. - 3.j]], + [[-12.+20.j, -12.+20.j, -12.+20.j], + [-12.+20.j, -12.+20.j, -12.+20.j], + [-12.+20.j, -12.+20.j, -12.+20.j]], + [[-13. - 9.j, -13. - 9.j, -13. - 9.j], + [-13. - 9.j, -13. - 9.j, -13. - 9.j], + [-13. - 9.j, -13. - 9.j, -13. - 9.j]], + [[-14. + 2.j, -14. + 2.j, -14. + 2.j], + [-14. + 2.j, -14. + 2.j, -14. + 2.j], + [-14. + 2.j, -14. + 2.j, -14. + 2.j]], + [[-15. - 7.j, -15. - 7.j, -15. - 7.j], + [-15. - 7.j, -15. - 7.j, -15. - 7.j], + [-15. - 7.j, -15. - 7.j, -15. - 7.j]], + [[-16.+16.j, -16.+16.j, -16.+16.j], + [-16.+16.j, -16.+16.j, -16.+16.j], + [-16.+16.j, -16.+16.j, -16.+16.j]]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(expected_auxiliary_wave, auxiliary_wave.get(), + err_msg="The auxiliary_wave has not been updated as expected") + + + def test_build_aux_same_as_exit_UNITY(self): + ## Arrange + addr, object_array, probe, exit_wave = self.prepare_arrays() + addr_dev, object_array_dev, probe_dev, exit_wave_dev = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave = np.zeros_like(exit_wave) + auxiliary_wave_dev = gpuarray.zeros_like(exit_wave_dev) + + ## Act + from ptypy.accelerate.base.kernels import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + AWK = AuxiliaryWaveKernel(self.stream) + alpha_set = FLOAT_TYPE(.75) + + AWK.build_aux(auxiliary_wave_dev, addr_dev, object_array_dev, probe_dev, exit_wave_dev, alpha=alpha_set) + nAWK.build_aux(auxiliary_wave, addr, object_array, probe, exit_wave, alpha=alpha_set) + + ## Assert + np.testing.assert_array_equal(auxiliary_wave, auxiliary_wave_dev.get(), + err_msg="The gpu auxiliary_wave does not look the same as the numpy version") + + def test_build_aux2_same_as_exit_UNITY(self): + ## Arrange + addr, object_array, probe, exit_wave = self.prepare_arrays() + addr_dev, object_array_dev, probe_dev, exit_wave_dev = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave = np.zeros_like(exit_wave) + auxiliary_wave_dev = gpuarray.zeros_like(exit_wave_dev) + + ## Act + from ptypy.accelerate.base.kernels import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + AWK = AuxiliaryWaveKernel(self.stream) + alpha_set = FLOAT_TYPE(.75) + + AWK.build_aux2(auxiliary_wave_dev, addr_dev, object_array_dev, probe_dev, exit_wave_dev, alpha=alpha_set) + nAWK.build_aux(auxiliary_wave, addr, object_array, probe, exit_wave, alpha=alpha_set) + + ## Assert + np.testing.assert_array_equal(auxiliary_wave, auxiliary_wave_dev.get(), + err_msg="The gpu auxiliary_wave does not look the same as the numpy version") + + def test_build_exit_aux_same_as_exit_REGRESSION(self): + ## Arrange + addr, object_array, probe, exit_wave = self.prepare_arrays() + addr_dev, object_array_dev, probe_dev, exit_wave_dev = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave_dev = gpuarray.zeros_like(exit_wave_dev) + + ## Act + AWK = AuxiliaryWaveKernel(self.stream) + alpha_set = 1.0 + AWK.build_exit(auxiliary_wave_dev, addr_dev, object_array_dev, probe_dev, exit_wave_dev) + + ## Assert + expected_auxiliary_wave = np.array([[[0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j]], + [[0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j]], + [[0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j]], + [[0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j]], + [[0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j]], + [[0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j]], + [[0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j]], + [[0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j]], + [[0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j]], + [[0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j]], + [[0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j]], + [[0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j]], + [[0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j]], + [[0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j]], + [[0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j]], + [[0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j]]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(expected_auxiliary_wave, auxiliary_wave_dev.get(), + err_msg="The auxiliary_wave has not been updated as expected") + + expected_exit_wave = np.array([[[1. - 1.j, 1. - 1.j, 1. - 1.j], + [1. - 1.j, 1. - 1.j, 1. - 1.j], + [1. - 1.j, 1. - 1.j, 1. - 1.j]], + [[2. - 6.j, 2. - 6.j, 2. - 6.j], + [2. - 6.j, 2. - 6.j, 2. - 6.j], + [2. - 6.j, 2. - 6.j, 2. - 6.j]], + [[3. - 1.j, 3. - 1.j, 3. - 1.j], + [3. - 1.j, 3. - 1.j, 3. - 1.j], + [3. - 1.j, 3. - 1.j, 3. - 1.j]], + [[4. - 12.j, 4. - 12.j, 4. - 12.j], + [4. - 12.j, 4. - 12.j, 4. - 12.j], + [4. - 12.j, 4. - 12.j, 4. - 12.j]], + [[5. + 3.j, 5. + 3.j, 5. + 3.j], + [5. + 3.j, 5. + 3.j, 5. + 3.j], + [5. + 3.j, 5. + 3.j, 5. + 3.j]], + [[6. - 2.j, 6. - 2.j, 6. - 2.j], + [6. - 2.j, 6. - 2.j, 6. - 2.j], + [6. - 2.j, 6. - 2.j, 6. - 2.j]], + [[7. + 3.j, 7. + 3.j, 7. + 3.j], + [7. + 3.j, 7. + 3.j, 7. + 3.j], + [7. + 3.j, 7. + 3.j, 7. + 3.j]], + [[8. - 8.j, 8. - 8.j, 8. - 8.j], + [8. - 8.j, 8. - 8.j, 8. - 8.j], + [8. - 8.j, 8. - 8.j, 8. - 8.j]], + [[9. + 7.j, 9. + 7.j, 9. + 7.j], + [9. + 7.j, 9. + 7.j, 9. + 7.j], + [9. + 7.j, 9. + 7.j, 9. + 7.j]], + [[10. + 2.j, 10. + 2.j, 10. + 2.j], + [10. + 2.j, 10. + 2.j, 10. + 2.j], + [10. + 2.j, 10. + 2.j, 10. + 2.j]], + [[11. + 7.j, 11. + 7.j, 11. + 7.j], + [11. + 7.j, 11. + 7.j, 11. + 7.j], + [11. + 7.j, 11. + 7.j, 11. + 7.j]], + [[12. - 4.j, 12. - 4.j, 12. - 4.j], + [12. - 4.j, 12. - 4.j, 12. - 4.j], + [12. - 4.j, 12. - 4.j, 12. - 4.j]], + [[13. + 11.j, 13. + 11.j, 13. + 11.j], + [13. + 11.j, 13. + 11.j, 13. + 11.j], + [13. + 11.j, 13. + 11.j, 13. + 11.j]], + [[14. + 6.j, 14. + 6.j, 14. + 6.j], + [14. + 6.j, 14. + 6.j, 14. + 6.j], + [14. + 6.j, 14. + 6.j, 14. + 6.j]], + [[15. + 11.j, 15. + 11.j, 15. + 11.j], + [15. + 11.j, 15. + 11.j, 15. + 11.j], + [15. + 11.j, 15. + 11.j, 15. + 11.j]], + [[16. + 0.j, 16. + 0.j, 16. + 0.j], + [16. + 0.j, 16. + 0.j, 16. + 0.j], + [16. + 0.j, 16. + 0.j, 16. + 0.j]]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(expected_exit_wave, exit_wave_dev.get(), + err_msg="The exit_wave has not been updated as expected") + + def test_build_exit_aux_same_as_exit_UNITY(self): + ## Arrange + addr, object_array, probe, exit_wave = self.prepare_arrays() + addr_dev, object_array_dev, probe_dev, exit_wave_dev = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave = np.zeros_like(exit_wave) + auxiliary_wave_dev = gpuarray.zeros_like(exit_wave_dev) + + ## Act + from ptypy.accelerate.base.kernels import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + AWK = AuxiliaryWaveKernel(self.stream) + + AWK.build_exit(auxiliary_wave_dev, addr_dev, object_array_dev, probe_dev, exit_wave_dev) + nAWK.build_exit(auxiliary_wave, addr, object_array, probe, exit_wave) + + ## Assert + np.testing.assert_array_equal(auxiliary_wave, auxiliary_wave_dev.get(), + err_msg="The gpu auxiliary_wave does not look the same as the numpy version") + + np.testing.assert_array_equal(exit_wave, exit_wave_dev.get(), + err_msg="The gpu exit_wave does not look the same as the numpy version") + + def test_build_aux_no_ex_noadd_REGRESSION(self): + ## Arrange + addr, object_array, probe, exit_wave = self.prepare_arrays() + addr, object_array, probe, exit_wave = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave = gpuarray.zeros_like(exit_wave) + + ## Act + AWK = AuxiliaryWaveKernel(self.stream) + AWK.allocate() + AWK.build_aux_no_ex(auxiliary_wave, addr, object_array, probe, + fac=1.0, add=False) + + ## Assert + expected_auxiliary_wave = np.array([[[0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j]], + [[0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j]], + [[0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j]], + [[0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j]], + [[0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j]], + [[0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j]], + [[0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j]], + [[0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j]], + [[0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j]], + [[0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j]], + [[0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j]], + [[0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j]], + [[0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j]], + [[0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j]], + [[0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j]], + [[0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j]]], dtype=np.complex64) + np.testing.assert_array_equal(auxiliary_wave.get(), expected_auxiliary_wave, + err_msg="The auxiliary_wave has not been updated as expected") + + def test_build_aux_no_ex_noadd_UNITY(self): + ## Arrange + addr, object_array, probe, exit_wave = self.prepare_arrays() + addr_dev, object_array_dev, probe_dev, exit_wave_dev = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave_dev = gpuarray.zeros_like(exit_wave_dev) + auxiliary_wave = np.zeros_like(exit_wave) + + ## Act + AWK = AuxiliaryWaveKernel(self.stream) + AWK.allocate() + AWK.build_aux_no_ex(auxiliary_wave_dev, addr_dev, object_array_dev, probe_dev, + fac=1.0, add=False) + from ptypy.accelerate.base.kernels import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + nAWK.allocate() + nAWK.build_aux_no_ex(auxiliary_wave, addr, object_array, probe, fac=1.0, add=False) + + ## Assert + np.testing.assert_array_equal(auxiliary_wave_dev.get(), auxiliary_wave, + err_msg="The auxiliary_wave does not match numpy") + + def test_build_aux2_no_ex_noadd_UNITY(self): + ## Arrange + addr, object_array, probe, exit_wave = self.prepare_arrays() + addr_dev, object_array_dev, probe_dev, exit_wave_dev = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave_dev = gpuarray.zeros_like(exit_wave_dev) + auxiliary_wave = np.zeros_like(exit_wave) + + ## Act + AWK = AuxiliaryWaveKernel(self.stream) + AWK.allocate() + AWK.build_aux2_no_ex(auxiliary_wave_dev, addr_dev, object_array_dev, probe_dev, + fac=1.0, add=False) + from ptypy.accelerate.base.kernels import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + nAWK.allocate() + nAWK.build_aux_no_ex(auxiliary_wave, addr, object_array, probe, fac=1.0, add=False) + + ## Assert + np.testing.assert_array_equal(auxiliary_wave_dev.get(), auxiliary_wave, + err_msg="The auxiliary_wave does not match numpy") + + + def test_build_aux_no_ex_add_REGRESSION(self): + ## Arrange + addr, object_array, probe, exit_wave = self.prepare_arrays() + addr, object_array, probe, exit_wave = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave = gpuarray.ones_like(exit_wave) + + ## Act + AWK = AuxiliaryWaveKernel(self.stream) + AWK.allocate() + fac = 2.0 + AWK.build_aux_no_ex(auxiliary_wave, addr, object_array, probe, fac=fac, add=True) + + ## Assert + expected_auxiliary_wave = np.array([[[0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j]], + [[0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j]], + [[0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j]], + [[0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j]], + [[0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j]], + [[0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j]], + [[0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j]], + [[0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j]], + [[0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j]], + [[0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j]], + [[0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j]], + [[0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j]], + [[0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j], + [0. + 2.j, 0. + 2.j, 0. + 2.j]], + [[0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j], + [0. + 8.j, 0. + 8.j, 0. + 8.j]], + [[0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j], + [0. + 4.j, 0. + 4.j, 0. + 4.j]], + [[0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j], + [0. + 16.j, 0. + 16.j, 0. + 16.j]]], dtype=np.complex64) + expected_auxiliary_wave = fac*expected_auxiliary_wave + 1 + np.testing.assert_array_equal(auxiliary_wave.get(), expected_auxiliary_wave, + err_msg="The auxiliary_wave has not been updated as expected") + + def test_build_aux_no_ex_add_UNITY(self): + ## Arrange + addr, object_array, probe, exit_wave = self.prepare_arrays() + addr_dev, object_array_dev, probe_dev, exit_wave_dev = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave_dev = gpuarray.ones_like(exit_wave_dev) + auxiliary_wave = np.ones_like(exit_wave) + + ## Act + AWK = AuxiliaryWaveKernel(self.stream) + AWK.allocate() + AWK.build_aux_no_ex(auxiliary_wave_dev, addr_dev, object_array_dev, probe_dev, + fac=2.0, add=True) + from ptypy.accelerate.base.kernels import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + nAWK.allocate() + nAWK.build_aux_no_ex(auxiliary_wave, addr, object_array, probe, fac=2.0, add=True) + + ## Assert + np.testing.assert_array_equal(auxiliary_wave_dev.get(), auxiliary_wave, + err_msg="The auxiliary_wave does not match numpy") + + def test_build_aux2_no_ex_add_UNITY(self): + ## Arrange + addr, object_array, probe, exit_wave = self.prepare_arrays() + addr_dev, object_array_dev, probe_dev, exit_wave_dev = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave_dev = gpuarray.ones_like(exit_wave_dev) + auxiliary_wave = np.ones_like(exit_wave) + + ## Act + AWK = AuxiliaryWaveKernel(self.stream) + AWK.allocate() + AWK.build_aux2_no_ex(auxiliary_wave_dev, addr_dev, object_array_dev, probe_dev, + fac=2.0, add=True) + from ptypy.accelerate.base.kernels import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + nAWK.allocate() + nAWK.build_aux_no_ex(auxiliary_wave, addr, object_array, probe, fac=2.0, add=True) + + ## Assert + np.testing.assert_array_equal(auxiliary_wave_dev.get(), auxiliary_wave, + err_msg="The auxiliary_wave does not match numpy") + + + @unittest.skipIf(not perfrun, "performance test") + def test_build_aux_no_ex_performance(self): + addr, object_array, probe, exit_wave = self.prepare_arrays(performance=True) + addr, object_array, probe, exit_wave = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave = gpuarray.zeros_like(exit_wave) + + AWK = AuxiliaryWaveKernel(self.stream) + AWK.allocate() + AWK.build_aux_no_ex(auxiliary_wave, addr, object_array, probe, + fac=1.0, add=False) + + + def test_build_exit_alpha_tau_REGRESSION(self): + ## Arrange + addr, object_array, probe, exit_wave = self.prepare_arrays(scan_points=1) + addr, object_array, probe, exit_wave = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave = gpuarray.zeros_like(exit_wave) + + ## Act + AWK = AuxiliaryWaveKernel(self.stream) + AWK.allocate() + AWK.build_exit_alpha_tau(auxiliary_wave, addr, object_array, probe, exit_wave) + + # Assert + expected_auxiliary_wave = np.array( + [[[0. -2.j, 0. -2.j, 0. -2.j], + [0. -2.j, 0. -2.j, 0. -2.j], + [0. -2.j, 0. -2.j, 0. -2.j]], + + [[0. -8.j, 0. -8.j, 0. -8.j], + [0. -8.j, 0. -8.j, 0. -8.j], + [0. -8.j, 0. -8.j, 0. -8.j]], + + [[0. -4.j, 0. -4.j, 0. -4.j], + [0. -4.j, 0. -4.j, 0. -4.j], + [0. -4.j, 0. -4.j, 0. -4.j]], + + [[0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j]]], dtype=np.complex64) + np.testing.assert_allclose(auxiliary_wave.get(), expected_auxiliary_wave, rtol=1e-6, atol=1e-6, + err_msg="The auxiliary_wave has not been updated as expected") + + expected_exit_wave = np.array( + [[[1. -1.j, 1. -1.j, 1. -1.j], + [1. -1.j, 1. -1.j, 1. -1.j], + [1. -1.j, 1. -1.j, 1. -1.j]], + + [[2. -6.j, 2. -6.j, 2. -6.j], + [2. -6.j, 2. -6.j, 2. -6.j], + [2. -6.j, 2. -6.j, 2. -6.j]], + + [[3. -1.j, 3. -1.j, 3. -1.j], + [3. -1.j, 3. -1.j, 3. -1.j], + [3. -1.j, 3. -1.j, 3. -1.j]], + + [[4.-12.j, 4.-12.j, 4.-12.j], + [4.-12.j, 4.-12.j, 4.-12.j], + [4.-12.j, 4.-12.j, 4.-12.j]]], dtype=np.complex64) + np.testing.assert_allclose(exit_wave.get(), expected_exit_wave, rtol=1e-6, atol=1e-6, + err_msg="The exit_wave has not been updated as expected") + + def test_build_exit_alpha_tau_UNITY(self): + ## Arrange + addr, object_array, probe, exit_wave = self.prepare_arrays(scan_points=1) + addr_dev, object_array_dev, probe_dev, exit_wave_dev = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave_dev = gpuarray.ones_like(exit_wave_dev) + auxiliary_wave = np.ones_like(exit_wave) + + ## Act + AWK = AuxiliaryWaveKernel(self.stream) + AWK.allocate() + AWK.build_exit_alpha_tau(auxiliary_wave_dev, addr_dev, object_array_dev, probe_dev, exit_wave_dev, alpha=0.8, tau=0.6) + from ptypy.accelerate.base.kernels import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + nAWK.allocate() + nAWK.build_exit_alpha_tau(auxiliary_wave, addr, object_array, probe, exit_wave, alpha=0.8, tau=0.6) + + ## Assert + np.testing.assert_allclose(auxiliary_wave_dev.get(), auxiliary_wave, rtol=1e-6, atol=1e-6, + err_msg="The auxiliary_wave does not match numpy") + ## Assert + np.testing.assert_allclose(exit_wave_dev.get(), exit_wave, rtol=1e-6, atol=1e-6, + err_msg="The exit_wave does not match numpy") + + @unittest.skipIf(not perfrun, "performance test") + def test_build_exit_alpha_tau_performance(self): + addr, object_array, probe, exit_wave = self.prepare_arrays(performance=True, scan_points=1) + addr, object_array, probe, exit_wave = self.copy_to_gpu(addr, object_array, probe, exit_wave) + auxiliary_wave = gpuarray.zeros_like(exit_wave) + + AWK = AuxiliaryWaveKernel(self.stream) + AWK.allocate() + AWK.build_exit_alpha_tau(auxiliary_wave, addr, object_array, probe, exit_wave, alpha=0.8, tau=0.6) + +if __name__ == '__main__': + unittest.main() diff --git a/test/accelerate_tests/cuda_pycuda_tests/derivatives_kernel_test.py b/test/accelerate_tests/cuda_pycuda_tests/derivatives_kernel_test.py new file mode 100644 index 000000000..1c4fe3b26 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/derivatives_kernel_test.py @@ -0,0 +1,334 @@ +''' + + +''' + +import unittest +import numpy as np +from . import perfrun, PyCudaTest, have_pycuda + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.array_utils import DerivativesKernel +from ptypy.utils.math_utils import delxf, delxb + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +class DerivativesKernelTest(PyCudaTest): + + def test_delxf_1dim(self): + inp = np.array([0, 1, 2, 4, 8, 0, 6], dtype=np.float32) + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=outp_dev) + + outp[:] = outp_dev.get() + + exp = np.array([1, 1, 2, 4, -8, 6, 0], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + def test_delxf_1dim_inplace(self): + inp = np.array([0, 1, 2, 4, 8, 0, 6], dtype=np.float32) + inp_dev = gpuarray.to_gpu(inp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=inp_dev) + + outp = inp_dev.get() + + exp = np.array([1, 1, 2, 4, -8, 6, 0], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + def test_delxf_2dim1(self): + inp = np.array([ + [0, 2, 6], + [1, -4, 5] + ], dtype=np.float32) + + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=outp_dev, axis=0) + + outp[:] = outp_dev.get() + + + exp = np.array([ + [1, -6, -1], + [0, 0, 0] + ], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + def test_delxf_2dim2(self): + inp = np.array([ + [0, 2, 6], + [1, -4, 5] + ], dtype=np.float32) + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=outp_dev, axis=1) + + outp[:] = outp_dev.get() + + exp = np.array([ + [2, 4, 0], + [-5, 9, 0] + ], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + def test_delxb_1dim(self): + inp = np.array([0, 1, 2, 4, 8, 0, 6], dtype=np.float32) + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxb(inp_dev, out=outp_dev) + + outp[:] = outp_dev.get() + + exp = np.array([0, 1, 1, 2, 4, -8, 6], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + def test_delxb_2dim1(self): + inp = np.array([ + [0, 2, 6], + [1, -4, 5] + ], dtype=np.float32) + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxb(inp_dev, out=outp_dev, axis=0) + + outp[:] = outp_dev.get() + + + exp = np.array([ + [0, 0, 0], + [1, -6, -1], + ], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + def test_delxb_2dim2(self): + inp = np.array([ + [0, 2, 6], + [1, -4, 5] + ], dtype=np.float32) + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxb(inp_dev, out=outp_dev, axis=1) + + outp[:] = outp_dev.get() + + + exp = np.array([ + [0, 2, 4], + [0, -5, 9] + ], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + def test_delxf_2dim2complex(self): + inp = np.array([ + [0, 2, 6], + [1, -4, 5] + ],dtype=np.float32) + 1j * np.array([ + [0, 4, 12], + [2, -8, 10] + ],dtype=np.float32) + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=outp_dev, axis=1) + + outp[:] = outp_dev.get() + + exp = np.array([ + [2, 4, 0], + [-5, 9, 0] + ], dtype=np.float32) + 1j * np.array([ + [4, 8, 0], + [-10, 18, 0] + ], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + def test_delxf_3dim2(self): + inp = np.array([ + [ + [1, 2, 4,], + [7, 11, 16,], + ], + [ + [22, 29, 37,], + [46, 56, 67] + ] + ], dtype=np.float32) + + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=outp_dev, axis=1) + + outp[:] = outp_dev.get() + + exp = np.array([ + [ + [6, 9, 12,], + [0, 0, 0,], + ], + [ + [24, 27, 30,], + [0, 0, 0], + ] + ], dtype=np.float32) + + np.testing.assert_array_equal(outp, exp) + + def test_delxf_3dim1_unity(self): + inp = np.ascontiguousarray(np.random.randn(33, 283, 142), dtype=np.float32) + + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=outp_dev, axis=0) + outp[:] = outp_dev.get() + + exp = delxf(inp, axis=0) + np.testing.assert_array_almost_equal(outp, exp) + + def test_delxf_3dim2_unity1(self): + inp = np.array([ + [ [1], [2], [4]], + [ [8], [16], [32]] + ], dtype=np.float32) + + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=outp_dev, axis=1) + outp[:] = outp_dev.get() + + exp = delxf(inp, axis=1) + + np.testing.assert_array_almost_equal(np.squeeze(outp), np.squeeze(exp)) + + def test_delxf_3dim2_unity2(self): + inp = np.array([ + [ [1, 2], [4, 7], [11,16] ], + [ [22,29], [37,46], [56,67]] + ], dtype=np.float32) + + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=outp_dev, axis=1) + outp[:] = outp_dev.get() + + exp = delxf(inp, axis=1) + + np.testing.assert_array_almost_equal(np.squeeze(outp), np.squeeze(exp)) + + def test_delxf_3dim2_unity(self): + inp = np.ascontiguousarray(np.random.randn(33, 283, 142), dtype=np.float32) + + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=outp_dev, axis=1) + outp[:] = outp_dev.get() + + exp = delxf(inp, axis=1) + np.testing.assert_array_almost_equal(outp, exp) + + def test_delxf_3dim3_unity(self): + inp = np.ascontiguousarray(np.random.randn(33, 283, 142), dtype=np.float32) + + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=outp_dev, axis=2) + outp[:] = outp_dev.get() + + exp = delxf(inp, axis=2) + np.testing.assert_array_almost_equal(outp, exp) + + def test_delxb_3dim3_unity(self): + inp = np.ascontiguousarray(np.random.randn(33, 283, 142), dtype=np.float32) + + inp_dev = gpuarray.to_gpu(inp) + outp = np.zeros_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxb(inp_dev, out=outp_dev, axis=2) + outp[:] = outp_dev.get() + + exp = delxb(inp, axis=2) + np.testing.assert_array_almost_equal(outp, exp) + + @unittest.skipIf(not perfrun, "performance test") + def test_perf_3d_0(self): + shape = [500, 1024, 1024] + inp = np.ones(shape, dtype=np.complex64) + inp_dev = gpuarray.to_gpu(inp) + outp = np.ones_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=outp_dev, axis=0) + outp[:] = outp_dev.get() + np.testing.assert_array_equal(outp, 0) + + @unittest.skipIf(not perfrun, "performance test") + def test_perf_3d_1(self): + shape = [500, 1024, 1024] + inp = np.ones(shape, dtype=np.complex64) + inp_dev = gpuarray.to_gpu(inp) + outp = np.ones_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=outp_dev, axis=1) + outp[:] = outp_dev.get() + np.testing.assert_array_equal(outp, 0) + + @unittest.skipIf(not perfrun, "performance test") + def test_perf_3d_2(self): + shape = [500, 1024, 1024] + inp = np.ones(shape, dtype=np.complex64) + inp_dev = gpuarray.to_gpu(inp) + outp = np.ones_like(inp) + outp_dev = gpuarray.to_gpu(outp) + + DK = DerivativesKernel(inp.dtype, queue=self.stream) + DK.delxf(inp_dev, out=outp_dev, axis=2) + outp[:] = outp_dev.get() + np.testing.assert_array_equal(outp, 0) \ No newline at end of file diff --git a/test/accelerate_tests/cuda_pycuda_tests/engine_tests.py b/test/accelerate_tests/cuda_pycuda_tests/engine_tests.py new file mode 100644 index 000000000..71542d4f9 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/engine_tests.py @@ -0,0 +1,172 @@ +""" +Test for the ML engine. + +This file is part of the PTYPY package. + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" +import unittest + +from test import utils as tu +from ptypy import utils as u +import ptypy +ptypy.load_gpu_engines("cuda") +import tempfile +import shutil +import numpy as np + +class MLPycudaTest(unittest.TestCase): + + def setUp(self): + self.outpath = tempfile.mkdtemp(suffix="ML_pycuda_test") + + def tearDown(self): + shutil.rmtree(self.outpath) + + def check_engine_output(self, output, plotting=False, debug=False, scan="MF"): + key = "S%sG00" %scan + P_ML_serial, P_ML_pycuda = output + numiter = len(P_ML_serial.runtime["iter_info"]) + LL_ML_serial = np.array([P_ML_serial.runtime["iter_info"][i]["error"][1] for i in range(numiter)]) + LL_ML_pycuda = np.array([P_ML_pycuda.runtime["iter_info"][i]["error"][1] for i in range(numiter)]) + crop = 42 + OBJ_ML_serial, OBJ_ML_pycuda = P_ML_serial.obj.S[key].data[0,crop:-crop,crop:-crop], P_ML_pycuda.obj.S[key].data[0,crop:-crop,crop:-crop] + PRB_ML_serial, PRB_ML_pycuda = P_ML_serial.probe.S[key].data[0], P_ML_pycuda.probe.S[key].data[0] + MED_ML_serial = np.median(np.angle(OBJ_ML_serial)) + MED_ML_pycuda = np.median(np.angle(OBJ_ML_pycuda)) + eng_ML_serial = P_ML_serial.engines["engine00"] + eng_ML_pycuda = P_ML_pycuda.engines["engine00"] + if debug: + import matplotlib.pyplot as plt + plt.figure("ML serial debug") + plt.imshow(np.abs(eng_ML_serial.debug)) + plt.figure("ML pycuda debug") + plt.imshow(np.abs(eng_ML_pycuda.debug)) + plt.show() + + if plotting: + import matplotlib.pyplot as plt + plt.figure("Errors") + plt.plot(LL_ML_serial, label="ML_serial") + plt.plot(LL_ML_pycuda, label="ML_pycuda") + plt.legend() + plt.show() + plt.figure("Phase ML serial") + plt.imshow(np.angle(OBJ_ML_serial*np.exp(-1j*MED_ML_serial))) + plt.figure("Ampltitude ML serial") + plt.imshow(np.abs(OBJ_ML_serial)) + plt.figure("Phase ML pycuda") + plt.imshow(np.angle(OBJ_ML_pycuda*np.exp(-1j*MED_ML_pycuda))) + plt.figure("Amplitude ML pycuda") + plt.imshow(np.abs(OBJ_ML_pycuda)) + plt.figure("Phase difference") + plt.imshow(np.angle(OBJ_ML_pycuda) - np.angle(OBJ_ML_serial), vmin=-0.1, vmax=0.1) + plt.colorbar() + plt.figure("Amplitude difference") + plt.imshow(np.abs(OBJ_ML_pycuda) - np.abs(OBJ_ML_serial), vmin=-0.1, vmax=0.1) + plt.colorbar() + plt.show() + # np.testing.assert_allclose(eng_ML_serial.debug, eng_ML_pycuda.debug, atol=1e-7, rtol=1e-7, + # err_msg="The debug arrays are not matching as expected") + RMSE_ob = (np.mean(np.abs(OBJ_ML_pycuda - OBJ_ML_serial)**2)) + RMSE_pr = (np.mean(np.abs(PRB_ML_pycuda - PRB_ML_serial)**2)) + # RMSE_LL = (np.mean(np.abs(LL_ML_serial - LL_ML)**2)) + np.testing.assert_allclose(RMSE_ob, 0.0, atol=1e-2, + err_msg="The object arrays are not matching as expected") + np.testing.assert_allclose(RMSE_pr, 0.0, atol=1e-2, + err_msg="The object arrays are not matching as expected") + # np.testing.assert_allclose(RMSE_LL, 0.0, atol=1e-7, + # err_msg="The log-likelihood errors are not matching as expected") + + def test_ML_pycuda_base(self): + out = [] + for eng in ["ML_serial", "ML_pycuda"]: + engine_params = u.Param() + engine_params.name = eng + engine_params.numiter = 100 + engine_params.floating_intensities = False + engine_params.reg_del2 = False + engine_params.reg_del2_amplitude = 1. + engine_params.scale_precond = False + out.append(tu.EngineTestRunner(engine_params, output_path=self.outpath, init_correct_probe=True, + scanmodel="BlockFull", autosave=False, verbose_level="critical")) + self.check_engine_output(out, plotting=False, debug=False) + + def test_ML_pycuda_regularizer(self): + out = [] + for eng in ["ML_serial", "ML_pycuda"]: + engine_params = u.Param() + engine_params.name = eng + engine_params.numiter = 100 + engine_params.floating_intensities = False + engine_params.reg_del2 = True + engine_params.reg_del2_amplitude = 1. + engine_params.scale_precond = False + out.append(tu.EngineTestRunner(engine_params, output_path=self.outpath, init_correct_probe=True, + scanmodel="BlockFull", autosave=False, verbose_level="critical")) + self.check_engine_output(out, plotting=False, debug=False) + + def test_ML_pycuda_preconditioner(self): + out = [] + for eng in ["ML_serial", "ML_pycuda"]: + engine_params = u.Param() + engine_params.name = eng + engine_params.numiter = 100 + engine_params.floating_intensities = False + engine_params.reg_del2 = False + engine_params.reg_del2_amplitude = 1. + engine_params.scale_precond = True + engine_params.scale_probe_object = 1e-6 + out.append(tu.EngineTestRunner(engine_params, output_path=self.outpath, init_correct_probe=True, + scanmodel="BlockFull", autosave=False, verbose_level="critical")) + self.check_engine_output(out, plotting=False, debug=False) + + def test_ML_pycuda_floating(self): + out = [] + for eng in ["ML_serial", "ML_pycuda"]: + engine_params = u.Param() + engine_params.name = eng + engine_params.numiter = 100 + engine_params.floating_intensities = True + engine_params.reg_del2 = False + engine_params.reg_del2_amplitude = 1. + engine_params.scale_precond = False + out.append(tu.EngineTestRunner(engine_params, output_path=self.outpath, init_correct_probe=True, + scanmodel="BlockFull", autosave=False, verbose_level="critical")) + self.check_engine_output(out, plotting=False, debug=False) + + def test_ML_pycuda_smoothing_regularizer(self): + out = [] + for eng in ["ML_serial", "ML_pycuda"]: + engine_params = u.Param() + engine_params.name = eng + engine_params.numiter = 200 + engine_params.floating_intensities = False + engine_params.reg_del2 = False + engine_params.reg_del2_amplitude = 1. + engine_params.smooth_gradient = 20 + engine_params.smooth_gradient_decay = 1/10. + engine_params.scale_precond = False + out.append(tu.EngineTestRunner(engine_params, output_path=self.outpath, init_correct_probe=True, + scanmodel="BlockFull", autosave=False, verbose_level="critical")) + self.check_engine_output(out, plotting=False, debug=False) + + def test_ML_pycuda_all(self): + out = [] + for eng in ["ML_serial", "ML_pycuda"]: + engine_params = u.Param() + engine_params.name = eng + engine_params.numiter = 100 + engine_params.floating_intensities = False + engine_params.reg_del2 = True + engine_params.reg_del2_amplitude = 1. + engine_params.smooth_gradient = 20 + engine_params.smooth_gradient_decay = 1/10. + engine_params.scale_precond = True + engine_params.scale_probe_object = 1e-6 + out.append(tu.EngineTestRunner(engine_params, output_path=self.outpath, init_correct_probe=True, + scanmodel="BlockFull", autosave=False, verbose_level="info")) + self.check_engine_output(out, plotting=False, debug=False) + +if __name__ == "__main__": + unittest.main() diff --git a/test/accelerate_tests/cuda_pycuda_tests/engine_utils_test.py b/test/accelerate_tests/cuda_pycuda_tests/engine_utils_test.py new file mode 100644 index 000000000..5299146b2 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/engine_utils_test.py @@ -0,0 +1,54 @@ +''' + + +''' + +import unittest +import numpy as np +from . import perfrun, PyCudaTest, have_pycuda + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.engines.ML_pycuda import Regul_del2_pycuda + from ptypy.engines.ML import Regul_del2 + from pycuda.tools import make_default_context + from pycuda.driver import mem_alloc + + +class EngineUtilsTest(PyCudaTest): + + def test_regul_del2_grad_unity(self): + ## Arrange + A = (np.random.randn(40,40) + +1j*np.random.randn(40,40)).astype(np.complex64) + A_dev = gpuarray.to_gpu(A) + + ## Act + Reg = Regul_del2(0.1) + Reg_dev = Regul_del2_pycuda(0.1, allocator=mem_alloc) + grad_dev = Reg_dev.grad(A_dev).get() + grad = Reg.grad(A) + #grad_dev = grad + ## Assert + np.testing.assert_allclose(grad_dev, grad, rtol=1e-7) + np.testing.assert_allclose(Reg_dev.LL, Reg.LL, rtol=1e-7) + + + def test_regul_del2_coeff_unity(self): + ## Arrange + A = (np.random.randn(40,40) + +1j*np.random.randn(40,40)).astype(np.complex64) + B = (np.random.randn(40,40) + +1j*np.random.randn(40,40)).astype(np.complex64) + A_dev = gpuarray.to_gpu(A) + B_dev = gpuarray.to_gpu(B) + + ## Act + Reg = Regul_del2(0.1) + Reg_dev = Regul_del2_pycuda(0.1, allocator=mem_alloc) + d = Reg_dev.poly_line_coeffs(A_dev, B_dev) + c = Reg.poly_line_coeffs(A, B) + #grad_dev = grad + #d = c + ## Assert + np.testing.assert_allclose(c, d, rtol=1e-6) diff --git a/test/accelerate_tests/cuda_pycuda_tests/fft_scaling_test.py b/test/accelerate_tests/cuda_pycuda_tests/fft_scaling_test.py new file mode 100644 index 000000000..8449adae0 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/fft_scaling_test.py @@ -0,0 +1,265 @@ +''' + + +''' + +import unittest +import numpy as np +from . import PyCudaTest, have_pycuda + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.fft import FFT as ReiknaFFT + from ptypy.accelerate.cuda_pycuda.cufft import FFT_cuda, FFT_skcuda + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +def get_forward_cuFFT(f, stream, + pre_fft, post_fft, inplace, + symmetric, external=True): + if external: + return FFT_cuda(f, stream, pre_fft=pre_fft, post_fft=post_fft, inplace=inplace, + symmetric=symmetric, forward=True).ft + else: + return FFT_skcuda(f, stream, pre_fft=pre_fft, post_fft=post_fft, inplace=inplace, + symmetric=symmetric, forward=True).ft + +def get_reverse_cuFFT(f, stream, + pre_fft, post_fft, inplace, + symmetric, external=True): + if external: + return FFT_cuda(f, stream, pre_fft=pre_fft, post_fft=post_fft, inplace=inplace, + symmetric=symmetric, forward=False).ift + else: + return FFT_skcuda(f, stream, pre_fft=pre_fft, post_fft=post_fft, inplace=inplace, + symmetric=symmetric, forward=False).ift + +def get_forward_Reikna(f, stream, + pre_fft, post_fft, inplace, + symmetric, external=True): + return ReiknaFFT(f, stream, + pre_fft=pre_fft, post_fft=post_fft, inplace=inplace, symmetric=symmetric).ft + +def get_reverse_Reikna(f, stream, + pre_fft, post_fft, inplace, + symmetric, external=True): + return ReiknaFFT(f, stream, + pre_fft=pre_fft, post_fft=post_fft, inplace=inplace, symmetric=symmetric).ift + + + +class FftScalingTest(PyCudaTest): + + def get_input(self): + rows = cols = 32 + batches = 1 + f = np.ones(shape=(batches, rows, cols), dtype=COMPLEX_TYPE) + return f + + #### Trivial foward transform tests #### + + def fwd_test(self, symmetric, factory, preffact=None, postfact=None, external=True): + f = self.get_input() + f_d = gpuarray.to_gpu(f) + if preffact is not None: + pref = preffact * np.ones(shape=f.shape[-2:], dtype=np.complex64) + pref_d = gpuarray.to_gpu(pref) + else: + preffact=1.0 + pref_d = None + if postfact is not None: + post = postfact * np.ones(shape=f.shape[-2:], dtype=np.complex64) + post_d = gpuarray.to_gpu(post) + else: + postfact=1.0 + post_d = None + ft = factory(f, self.stream, + pre_fft=pref_d, post_fft=post_d, inplace=True, + symmetric=symmetric, external=external) + ft(f_d, f_d) + f_back = f_d.get() + elements = f.shape[-2] * f.shape[-1] + scale = 1.0 if not symmetric else 1.0 / np.sqrt(elements) + expected = elements * scale * preffact * postfact + self.assertAlmostEqual(f_back[0,0,0], expected) + np.testing.assert_array_almost_equal(f_back.flat[1:], 0) + + def test_fwd_noscale_reikna(self): + self.fwd_test(False, get_forward_Reikna) + + def test_fwd_noscale_cufft(self): + self.fwd_test(False, get_forward_cuFFT) + + def test_fwd_noscale_cufft_skcuda(self): + self.fwd_test(False, get_forward_cuFFT, external=False) + + def test_fwd_scale_reikna(self): + self.fwd_test(True, get_forward_Reikna) + + def test_fwd_scale_cufft(self): + self.fwd_test(True, get_forward_cuFFT) + + def test_fwd_scale_cufft_skcuda(self): + self.fwd_test(True, get_forward_cuFFT, external=False) + + def test_prefilt_fwd_noscale_reikna(self): + self.fwd_test(False, get_forward_Reikna, preffact=2.0) + + def test_prefilt_fwd_noscale_cufft(self): + self.fwd_test(False, get_forward_cuFFT, preffact=2.0) + + def test_prefilt_fwd_noscale_cufft_skcuda(self): + self.fwd_test(False, get_forward_cuFFT, preffact=2.0, external=False) + + def test_prefilt_fwd_scale_reikna(self): + self.fwd_test(True, get_forward_Reikna, preffact=2.0) + + def test_prefilt_fwd_scale_cufft(self): + self.fwd_test(True, get_forward_cuFFT, preffact=2.0) + + def test_prefilt_fwd_scale_cufft_skcuda(self): + self.fwd_test(True, get_forward_cuFFT, preffact=2.0, external=False) + + def test_postfilt_fwd_noscale_reikna(self): + self.fwd_test(False, get_forward_Reikna, postfact=2.0) + + def test_postfilt_fwd_noscale_cufft(self): + self.fwd_test(False, get_forward_cuFFT, postfact=2.0) + + def test_postfilt_fwd_noscale_cufft_skcuda(self): + self.fwd_test(False, get_forward_cuFFT, postfact=2.0, external=False) + + def test_postfilt_fwd_scale_reikna(self): + self.fwd_test(True, get_forward_Reikna, postfact=2.0) + + def test_postfilt_fwd_scale_cufft(self): + self.fwd_test(True, get_forward_cuFFT, postfact=2.0) + + def test_postfilt_fwd_scale_cufft_skcuda(self): + self.fwd_test(True, get_forward_cuFFT, postfact=2.0, external=False) + + def test_prepostfilt_fwd_noscale_reikna(self): + self.fwd_test(False, get_forward_Reikna, postfact=2.0, preffact=1.5) + + def test_prepostfilt_fwd_noscale_cufft(self): + self.fwd_test(False, get_forward_cuFFT, postfact=2.0, preffact=1.5) + + def test_prepostfilt_fwd_noscale_cufft_skcuda(self): + self.fwd_test(False, get_forward_cuFFT, postfact=2.0, preffact=1.5, external=False) + + def test_prepostfilt_fwd_scale_reikna(self): + self.fwd_test(True, get_forward_Reikna, postfact=2.0, preffact=1.5) + + def test_prepostfilt_fwd_scale_cufft(self): + self.fwd_test(True, get_forward_cuFFT, postfact=2.0, preffact=1.5) + + def test_prepostfilt_fwd_scale_cufft_skcuda(self): + self.fwd_test(True, get_forward_cuFFT, postfact=2.0, preffact=1.5, external=False) + + + ############# Trivial inverse transform tests ######### + + def rev_test(self, symmetric, factory, preffact=None, postfact=None, external=True): + f = self.get_input() + f_d = gpuarray.to_gpu(f) + if preffact is not None: + pref = preffact * np.ones(shape=f.shape[-2:], dtype=np.complex64) + pref_d = gpuarray.to_gpu(pref) + else: + preffact=1.0 + pref_d = None + if postfact is not None: + post = postfact * np.ones(shape=f.shape[-2:], dtype=np.complex64) + post_d = gpuarray.to_gpu(post) + else: + postfact=1.0 + post_d = None + ift = factory(f, self.stream, + pre_fft=pref_d, post_fft=post_d, inplace=True, symmetric=symmetric, + external=external) + ift(f_d, f_d) + f_back = f_d.get() + elements = f.shape[-2] * f.shape[-1] + scale = 1.0 if not symmetric else np.sqrt(elements) + expected = scale * preffact * postfact + self.assertAlmostEqual(f_back[0,0,0], expected) + np.testing.assert_array_almost_equal(f_back.flat[1:], 0) + + + def test_rev_noscale_reikna(self): + self.rev_test(False, get_reverse_Reikna) + + def test_rev_noscale_cufft(self): + self.rev_test(False, get_reverse_cuFFT) + + def test_rev_noscale_cufft_skcuda(self): + self.rev_test(False, get_reverse_cuFFT, external=False) + + def test_rev_scale_reikna(self): + self.rev_test(True, get_reverse_Reikna) + + def test_rev_scale_cufft(self): + self.rev_test(True, get_reverse_cuFFT) + + def test_rev_scale_cufft_skcuda(self): + self.rev_test(True, get_reverse_cuFFT, external=False) + + def test_prefilt_rev_noscale_reikna(self): + self.rev_test(False, get_reverse_Reikna, preffact=1.5) + + def test_prefilt_rev_noscale_cufft(self): + self.rev_test(False, get_reverse_cuFFT, preffact=1.5) + + def test_prefilt_rev_noscale_cufft_skcuda(self): + self.rev_test(False, get_reverse_cuFFT, preffact=1.5, external=False) + + def test_prefilt_rev_scale_reikna(self): + self.rev_test(True, get_reverse_Reikna, preffact=1.5) + + def test_prefilt_rev_scale_cufft(self): + self.rev_test(True, get_reverse_cuFFT, preffact=1.5) + + def test_prefilt_rev_scale_cufft_skcuda(self): + self.rev_test(True, get_reverse_cuFFT, preffact=1.5, external=False) + + def test_postfilt_rev_noscale_reikna(self): + self.rev_test(False, get_reverse_Reikna, postfact=1.5) + + def test_postfilt_rev_noscale_cufft(self): + self.rev_test(False, get_reverse_cuFFT, postfact=1.5) + + def test_postfilt_rev_noscale_cufft_skcuda(self): + self.rev_test(False, get_reverse_cuFFT, postfact=1.5, external=False) + + def test_postfilt_rev_scale_reikna(self): + self.rev_test(True, get_reverse_Reikna, postfact=1.5) + + def test_postfilt_rev_scale_cufft(self): + self.rev_test(True, get_reverse_cuFFT, postfact=1.5) + + def test_postfilt_rev_scale_cufft_skcuda(self): + self.rev_test(True, get_reverse_cuFFT, postfact=1.5, external=False) + + def test_prepostfilt_rev_noscale_reikna(self): + self.rev_test(False, get_reverse_Reikna, postfact=1.5, preffact=2.0) + + def test_prepostfilt_rev_noscale_cufft(self): + self.rev_test(False, get_reverse_cuFFT, postfact=1.5, preffact=2.0) + + def test_prepostfilt_rev_noscale_cufft_skcuda(self): + self.rev_test(False, get_reverse_cuFFT, postfact=1.5, preffact=2.0, external=False) + + def test_prepostfilt_rev_scale_reikna(self): + self.rev_test(True, get_reverse_Reikna, postfact=1.5, preffact=2.0) + + def test_prepostfilt_rev_scale_cufft(self): + self.rev_test(True, get_reverse_cuFFT, postfact=1.5, preffact=2.0) + + def test_prepostfilt_rev_scale_cufft_skcuda(self): + self.rev_test(True, get_reverse_cuFFT, postfact=1.5, preffact=2.0, external=False) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/accelerate_tests/cuda_pycuda_tests/fft_setstream_test.py b/test/accelerate_tests/cuda_pycuda_tests/fft_setstream_test.py new file mode 100644 index 000000000..1220702b7 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/fft_setstream_test.py @@ -0,0 +1,98 @@ +import unittest +import numpy as np +from . import PyCudaTest, have_pycuda +import time + +if have_pycuda(): + import pycuda.driver as cuda + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.fft import FFT as ReiknaFFT + from ptypy.accelerate.cuda_pycuda.cufft import FFT_cuda as cuFFT + from ptypy.accelerate.cuda_pycuda.cufft import FFT_skcuda as SkcudaCuFFT + + COMPLEX_TYPE = np.complex64 + FLOAT_TYPE = np.float32 + INT_TYPE = np.int32 + +class FftSetStreamTest(PyCudaTest): + + def helper(self, FFT): + f = np.ones(shape=(200, 128, 128), dtype=COMPLEX_TYPE) + t1 = time.time() + FW = FFT(f, self.stream, pre_fft=None, post_fft=None, inplace=True, + symmetric=True) + self.stream.synchronize() + t2 = time.time() + dur1 = t2 - t1 + f_dev = gpuarray.to_gpu(f) + + # measure with events to make sure that something actually + # happened in the right stream + ev1 = cuda.Event() + ev2 = cuda.Event() + rt1 = time.time() + ev1.record(self.stream) + FW.ft(f_dev, f_dev) + ev2.record(self.stream) + ev1.synchronize() + ev2.synchronize() + self.stream.synchronize() + rt2 = time.time() + cput = rt2-rt1 + gput = ev1.time_till(ev2)*1e-3 + rel = 1-gput/cput + + print('Origial: CPU={}, GPU={}, reldiff={}'.format(cput, gput, rel)) + + self.assertEqual(self.stream, FW.queue) + self.assertLess(rel, 0.3) # max 30% diff + + stream2 = cuda.Stream() + + measure = False # measure time to set the stream + if measure: + avg = 100 + else: + avg = 1 + t1 = time.time() + for i in range(avg): + FW.queue = stream2 + stream2.synchronize() + t2 = time.time() + dur2 = (t2 - t1)/avg + + + ev1 = cuda.Event() + ev2 = cuda.Event() + rt1 = time.time() + ev1.record(stream2) + FW.ft(f_dev, f_dev) + ev2.record(stream2) + ev1.synchronize() + ev2.synchronize() + stream2.synchronize() + self.stream.synchronize() + rt2 = time.time() + cput = rt2-rt1 + gput = ev1.time_till(ev2)*1e-3 + rel = 1 - gput/cput + + print('New: CPU={}, GPU={}, reldiff={}'.format(cput, gput, rel)) + + self.assertEqual(stream2, FW.queue) + self.assertLess(rel, 0.3) # max 30% diff + + if measure: + print('initial: {}, set_stream: {}'.format(dur1, dur2)) + assert False + + + + def test_set_stream_a_reikna(self): + self.helper(ReiknaFFT) + + def test_set_stream_b_cufft(self): + self.helper(cuFFT) + + def test_set_stream_c_skcuda_cufft(self): + self.helper(SkcudaCuFFT) diff --git a/test/accelerate_tests/cuda_pycuda_tests/fft_tests/__init__.py b/test/accelerate_tests/cuda_pycuda_tests/fft_tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test/accelerate_tests/cuda_pycuda_tests/fft_tests/cufft_init_test.py b/test/accelerate_tests/cuda_pycuda_tests/fft_tests/cufft_init_test.py new file mode 100644 index 000000000..c1894cc31 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/fft_tests/cufft_init_test.py @@ -0,0 +1,28 @@ + +import unittest +from test.accelerate_tests.cuda_pycuda_tests import PyCudaTest, have_pycuda + +if have_pycuda(): + from filtered_cufft import FilteredFFT + +class CuFFTInitTest(PyCudaTest): + + def test_import_fft(self): + ft = FilteredFFT(2, 32, 32, False, True, 0, 0, 0) + + + def test_import_fft_different_shape(self): + ft = FilteredFFT(2, 128, 128, False, True, 0, 0, 0) + + + @unittest.expectedFailure + def test_import_fft_not_square(self): + ft = FilteredFFT(2, 32, 64, False, True, 0, 0, 0) + + @unittest.expectedFailure + def test_import_fft_not_pow2(self): + ft = FilteredFFT(2, 40, 40, False, True, 0, 0, 0) + + +if __name__=="__main__": + unittest.main() diff --git a/test/accelerate_tests/cuda_pycuda_tests/fft_tests/fft_accuracy_test.py b/test/accelerate_tests/cuda_pycuda_tests/fft_tests/fft_accuracy_test.py new file mode 100644 index 000000000..7c30c3221 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/fft_tests/fft_accuracy_test.py @@ -0,0 +1,48 @@ +''' +''' + +import unittest +import numpy as np +import scipy.fft as fft +from test.accelerate_tests.cuda_pycuda_tests import PyCudaTest, have_pycuda + + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.fft import FFT as ReiknaFFT + from ptypy.accelerate.cuda_pycuda.cufft import FFT_cuda as cuFFT + +class FftAccurracyTest(PyCudaTest): + + def gen_input(self): + rows = cols = 32 + batches = 1 + f = np.random.randn(batches, rows, cols) + 1j * np.random.randn(batches,rows, cols) + f = np.ascontiguousarray(f.astype(np.complex64)) + return f + + def test_random_cufft_fwd(self): + f = self.gen_input() + cuft = cuFFT(f, self.stream, inplace=True, pre_fft=None, post_fft=None, symmetric=None, forward=True).ft + reikft = ReiknaFFT(f, self.stream, inplace=True, pre_fft=None, post_fft=None, symmetric=False).ft + for i in range(10): + f = self.gen_input() + y = fft.fft2(f) + + x_d = gpuarray.to_gpu(f) + cuft(x_d, x_d) + y_cufft = x_d.get().reshape(y.shape) + + x_d = gpuarray.to_gpu(f) + reikft(x_d, x_d) + y_reikna = x_d.get().reshape(y.shape) + + # cufft_diff = np.max(np.abs(y_cufft - y)) + # reikna_diff = np.max(np.abs(y_reikna-y)) + # cufft_rdiff = np.max(np.abs(y_cufft - y) / np.abs(y)) + # reikna_rdiff = np.max(np.abs(y_reikna - y) / np.abs(y)) + # print('{}: {}\t{}\t{}\t{}'.format(i, cufft_diff, reikna_diff, cufft_rdiff, reikna_rdiff)) + + # Note: check if this tolerance and test case is ok + np.testing.assert_allclose(y, y_cufft, atol=1e-6, rtol=5e-5, err_msg='cuFFT error at index {}'.format(i)) + np.testing.assert_allclose(y, y_reikna, atol=1e-6, rtol=5e-5, err_msg='reikna FFT error at index {}'.format(i)) diff --git a/test/accelerate_tests/cuda_pycuda_tests/fourier_update_kernel_test.py b/test/accelerate_tests/cuda_pycuda_tests/fourier_update_kernel_test.py new file mode 100644 index 000000000..3d7cb5fa6 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/fourier_update_kernel_test.py @@ -0,0 +1,685 @@ +''' + + +''' + +import unittest +import numpy as np +from . import PyCudaTest, have_pycuda + + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.kernels import FourierUpdateKernel + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +class FourierUpdateKernelTest(PyCudaTest): + + + def test_fmag_all_update_UNITY(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + G = 2 # number og object modes + + E = B # probe size y + F = C # probe size x + + scan_pts = 2 # one dimensional scan point number + + N = scan_pts ** 2 + total_number_modes = G * D + A = N * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + f = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + f[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + fmag = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured magnitudes NxAxB + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + mask = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE)# the masks for the measured magnitudes either 1xAxB or NxAxB + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((N,)) + Y = Y.reshape((N,)) + + addr = np.zeros((N, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [position_idx, 0, 0], + [position_idx, 0, 0]]) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + # print("address book is:") + # print(repr(addr)) + + ''' + test + ''' + mask_sum = mask.sum(-1).sum(-1) + + err_fmag = np.zeros(N, dtype=FLOAT_TYPE) + from ptypy.accelerate.base.kernels import FourierUpdateKernel as npFourierUpdateKernel + pbound_set = 0.9 + nFUK = npFourierUpdateKernel(f, nmodes=total_number_modes) + FUK = FourierUpdateKernel(f, nmodes=total_number_modes) + + nFUK.allocate() + FUK.allocate() + + nFUK.fourier_error(f, addr, fmag, mask, mask_sum) + nFUK.error_reduce(addr, err_fmag) + # print(np.sqrt(pbound_set/err_fmag)) + f_d = gpuarray.to_gpu(f) + fmag_d = gpuarray.to_gpu(fmag) + mask_d = gpuarray.to_gpu(mask) + err_fmag_d = gpuarray.to_gpu(err_fmag) + addr_d = gpuarray.to_gpu(addr) + + # now set the state for both. + + FUK.gpu.fdev = gpuarray.to_gpu(nFUK.npy.fdev) + FUK.gpu.ferr = gpuarray.to_gpu(nFUK.npy.ferr) + + FUK.fmag_all_update(f_d, addr_d, fmag_d, mask_d, err_fmag_d, pbound=pbound_set) + + + nFUK.fmag_all_update(f, addr, fmag, mask, err_fmag, pbound=pbound_set) + expected_f = f + measured_f = f_d.get() + np.testing.assert_allclose(expected_f, measured_f, rtol=1e-6, err_msg="Numpy f " + "is \n%s, \nbut gpu f is \n %s, \n mask is:\n %s \n" % (repr(expected_f), + repr(measured_f), + repr(mask))) + + def test_fmag_update_nopbound_UNITY(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + G = 2 # number og object modes + + E = B # probe size y + F = C # probe size x + + scan_pts = 2 # one dimensional scan point number + + N = scan_pts ** 2 + total_number_modes = G * D + A = N * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + f = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + f[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + fmag = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured magnitudes NxAxB + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + mask = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE)# the masks for the measured magnitudes either 1xAxB or NxAxB + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((N,)) + Y = Y.reshape((N,)) + + addr = np.zeros((N, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [position_idx, 0, 0], + [position_idx, 0, 0]]) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + # print("address book is:") + # print(repr(addr)) + + ''' + test + ''' + mask_sum = mask.sum(-1).sum(-1) + + err_fmag = np.zeros(N, dtype=FLOAT_TYPE) + from ptypy.accelerate.base.kernels import FourierUpdateKernel as npFourierUpdateKernel + nFUK = npFourierUpdateKernel(f, nmodes=total_number_modes) + FUK = FourierUpdateKernel(f, nmodes=total_number_modes) + + nFUK.allocate() + FUK.allocate() + + nFUK.fourier_error(f, addr, fmag, mask, mask_sum) + nFUK.error_reduce(addr, err_fmag) + # print(np.sqrt(pbound_set/err_fmag)) + f_d = gpuarray.to_gpu(f) + fmag_d = gpuarray.to_gpu(fmag) + mask_d = gpuarray.to_gpu(mask) + addr_d = gpuarray.to_gpu(addr) + + # now set the state for both. + + FUK.gpu.fdev = gpuarray.to_gpu(nFUK.npy.fdev) + FUK.gpu.ferr = gpuarray.to_gpu(nFUK.npy.ferr) + + FUK.fmag_update_nopbound(f_d, addr_d, fmag_d, mask_d) + nFUK.fmag_update_nopbound(f, addr, fmag, mask) + + expected_f = f + measured_f = f_d.get() + np.testing.assert_allclose(measured_f, expected_f, rtol=1e-6, err_msg="Numpy f " + "is \n%s, \nbut gpu f is \n %s, \n mask is:\n %s \n" % (repr(expected_f), + repr(measured_f), + repr(mask))) + + + def test_fourier_error_UNITY(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + G = 2 # number of object modes + + E = B # probe size y + F = C # probe size x + + scan_pts = 2 # one dimensional scan point number + + N = scan_pts ** 2 + total_number_modes = G * D + A = N * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + f = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + f[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + fmag = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured magnitudes NxAxB + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + mask = np.empty(shape=(N, B, C), + dtype=FLOAT_TYPE) # the masks for the measured magnitudes either 1xAxB or NxAxB + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((N,)) + Y = Y.reshape((N,)) + + addr = np.zeros((N, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [position_idx, 0, 0], + [position_idx, 0, 0]]) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + mask_sum = mask.sum(-1).sum(-1) + + from ptypy.accelerate.base.kernels import FourierUpdateKernel as npFourierUpdateKernel + f_d = gpuarray.to_gpu(f) + fmag_d = gpuarray.to_gpu(fmag) + mask_d = gpuarray.to_gpu(mask) + addr_d = gpuarray.to_gpu(addr) + mask_sum_d = gpuarray.to_gpu(mask_sum) + + nFUK = npFourierUpdateKernel(f, nmodes=total_number_modes) + FUK = FourierUpdateKernel(f, nmodes=total_number_modes) + + nFUK.allocate() + FUK.allocate() + + nFUK.fourier_error(f, addr, fmag, mask, mask_sum) + FUK.fourier_error(f_d, addr_d, fmag_d, mask_d, mask_sum_d) + + expected_fdev = nFUK.npy.fdev + measured_fdev = FUK.gpu.fdev.get() + np.testing.assert_allclose(expected_fdev, measured_fdev, rtol=1e-6, err_msg="Numpy fdev " + "is \n%s, \nbut gpu fdev is \n %s, \n " % ( + repr(expected_fdev), + repr(measured_fdev))) + + expected_ferr = nFUK.npy.ferr + measured_ferr = FUK.gpu.ferr.get() + + np.testing.assert_array_equal(expected_ferr, measured_ferr, err_msg="Numpy ferr" + "is \n%s, \nbut gpu ferr is \n %s, \n " % ( + repr(expected_ferr), + repr(measured_ferr))) + def test_fourier_deviation_UNITY(self): + ''' + setup - using the fourier_error as reference, so we need mask, etc. + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + G = 2 # number of object modes + + E = B # probe size y + F = C # probe size x + + scan_pts = 2 # one dimensional scan point number + + N = scan_pts ** 2 + total_number_modes = G * D + A = N * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + f = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + f[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + fmag = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured magnitudes NxAxB + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + mask = np.empty(shape=(N, B, C), + dtype=FLOAT_TYPE) # the masks for the measured magnitudes either 1xAxB or NxAxB + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((N,)) + Y = Y.reshape((N,)) + + addr = np.zeros((N, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [position_idx, 0, 0], + [position_idx, 0, 0]]) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + mask_sum = mask.sum(-1).sum(-1) + + from ptypy.accelerate.base.kernels import FourierUpdateKernel as npFourierUpdateKernel + f_d = gpuarray.to_gpu(f) + fmag_d = gpuarray.to_gpu(fmag) + addr_d = gpuarray.to_gpu(addr) + + nFUK = npFourierUpdateKernel(f, nmodes=total_number_modes) + FUK = FourierUpdateKernel(f, nmodes=total_number_modes) + + nFUK.allocate() + FUK.allocate() + + nFUK.fourier_deviation(f, addr, fmag) + FUK.fourier_deviation(f_d, addr_d, fmag_d) + + expected_fdev = nFUK.npy.fdev + measured_fdev = FUK.gpu.fdev.get() + np.testing.assert_allclose(measured_fdev, expected_fdev, rtol=1e-6, err_msg="Numpy fdev " + "is \n%s, \nbut gpu fdev is \n %s, \n " % ( + repr(expected_fdev), + repr(measured_fdev))) + + + + def test_error_reduce_UNITY(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + G = 2 # number og object modes + + E = B # probe size y + F = C # probe size x + + scan_pts = 2 # one dimensional scan point number + + N = scan_pts ** 2 + total_number_modes = G * D + A = N * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + f = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + f[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + fmag = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured magnitudes NxAxB + fmag_fill = np.arange(np.prod(fmag.shape).item()).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + mask = np.empty(shape=(N, B, C), + dtype=FLOAT_TYPE) # the masks for the measured magnitudes either 1xAxB or NxAxB + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((N,)) + Y = Y.reshape((N,)) + + addr = np.zeros((N, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [position_idx, 0, 0], + [position_idx, 0, 0]]) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + # print("address book is:") + # print(repr(addr)) + + ''' + test + ''' + err_fmag = np.zeros(N, dtype=FLOAT_TYPE) + mask_sum = mask.sum(-1).sum(-1) + + from ptypy.accelerate.base.kernels import FourierUpdateKernel as npFourierUpdateKernel + f_d = gpuarray.to_gpu(f) + fmag_d = gpuarray.to_gpu(fmag) + mask_d = gpuarray.to_gpu(mask) + addr_d = gpuarray.to_gpu(addr) + err_fmag_d = gpuarray.to_gpu(err_fmag) + mask_sum_d = gpuarray.to_gpu(mask_sum) + pbound_set = 0.9 + nFUK = npFourierUpdateKernel(f, nmodes=total_number_modes) + FUK = FourierUpdateKernel(f, nmodes=total_number_modes, queue_thread=self.stream) + + nFUK.allocate() + FUK.allocate() + + nFUK.fourier_error(f, addr, fmag, mask, mask_sum) + nFUK.error_reduce(addr, err_fmag) + + + FUK.fourier_error(f_d, addr_d, fmag_d, mask_d, mask_sum_d) + FUK.error_reduce(addr_d, err_fmag_d) + + expected_err_fmag = err_fmag + measured_err_fmag = err_fmag_d.get() + + np.testing.assert_allclose(expected_err_fmag, measured_err_fmag, rtol=1.15207385e-07, + err_msg="Numpy err_fmag" + "is \n%s, \nbut gpu err_fmag is \n %s, \n " % ( + repr(expected_err_fmag), + repr(measured_err_fmag))) + + def test_error_reduce(self): + # array from the previous test + ferr = np.array([[[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [7.54033208e-01, 3.04839879e-01, 5.56465909e-02, 6.45330548e-03, 1.57260016e-01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [5.26210022e+00, 6.81290817e+00, 8.56371498e+00, 1.05145216e+01, 1.26653280e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[1.61048353e+00, 2.15810299e+00, 2.78572226e+00, 3.49334168e+00, 4.28096104e+00], + [5.14858055e+00, 6.09619951e+00, 7.12381887e+00, 8.23143768e+00, 9.41905785e+00], + [1.06866770e+01, 1.20342960e+01, 1.34619150e+01, 1.49695349e+01, 1.65571537e+01], + [1.82247734e+01, 1.99723930e+01, 2.18000126e+01, 2.37076321e+01, 2.56952515e+01], + [2.77628708e+01, 2.99104881e+01, 3.21381073e+01, 3.44457283e+01, 3.68333473e+01]], + + [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [6.31699409e+01, 6.82966690e+01, 7.36233978e+01, 7.91501160e+01, 8.48768463e+01], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [1.23437180e+02, 1.30563919e+02, 1.37890640e+02, 1.45417374e+02, 1.53144089e+02], + [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], + + [[4.58764343e+01, 4.86257210e+01, 5.14550095e+01, 5.43642960e+01, 5.73535805e+01], + [6.04228668e+01, 6.35721550e+01, 6.68014374e+01, 7.01107254e+01, 7.35000076e+01], + [7.69692993e+01, 8.05185852e+01, 8.41478729e+01, 8.78571548e+01, 9.16464386e+01], + [9.55157242e+01, 9.94650116e+01, 1.03494293e+02, 1.07603584e+02, 1.11792870e+02], + [1.16062157e+02, 1.20411446e+02, 1.24840721e+02, 1.29350006e+02, 1.33939301e+02]]], + dtype=FLOAT_TYPE) + # print(ferr.shape) + scan_pts = 2 # one dimensional scan point number + N = scan_pts ** 2 + + addr = np.zeros((N, 1, 5, 3)) + aux = np.zeros((4, 5, 5)) + FUK = FourierUpdateKernel(aux, nmodes=1) + err_mag = np.zeros(N, dtype=FLOAT_TYPE) + err_mag_d = gpuarray.to_gpu(err_mag) + FUK.gpu.ferr = gpuarray.to_gpu(ferr) + addr_d = gpuarray.to_gpu(addr) + + FUK.error_reduce(addr_d, err_mag_d) + + # print(repr(ferr)) + measured_err_mag = err_mag_d.get() + + # print(repr(measured_err_mag)) + + expected_err_mag = np.array([45.096806, 388.54788, 1059.5702, 2155.6968], dtype=FLOAT_TYPE) + + np.testing.assert_array_equal(expected_err_mag, measured_err_mag, err_msg="The fourier_update_kernel.error_reduce" + "is not behaving as expected.") + + + def log_likelihood_UNITY_tester(self, use_version2=False): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + G = 2 # number of object modes + + E = B # probe size y + F = C # probe size x + + scan_pts = 2 # one dimensional scan point number + + N = scan_pts ** 2 + total_number_modes = G * D + A = N * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + f = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + f[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + fmag = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured magnitudes NxAxB + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + mask = np.empty(shape=(N, B, C), + dtype=FLOAT_TYPE) # the masks for the measured magnitudes either 1xAxB or NxAxB + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((N,)) + Y = Y.reshape((N,)) + + addr = np.zeros((N, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [position_idx, 0, 0], + [position_idx, 0, 0]]) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + mask_sum = mask.sum(-1).sum(-1) + LLerr = np.zeros_like(mask_sum, dtype=np.float32) + f_d = gpuarray.to_gpu(f) + fmag_d = gpuarray.to_gpu(fmag) + mask_d = gpuarray.to_gpu(mask) + addr_d = gpuarray.to_gpu(addr) + LLerr_d = gpuarray.to_gpu(LLerr) + + from ptypy.accelerate.base.kernels import FourierUpdateKernel as npFourierUpdateKernel + nFUK = npFourierUpdateKernel(f, nmodes=total_number_modes) + nFUK.allocate() + nFUK.log_likelihood(f, addr, fmag, mask, LLerr) + + FUK = FourierUpdateKernel(f, nmodes=total_number_modes) + FUK.allocate() + if use_version2: + FUK.log_likelihood2(f_d, addr_d, fmag_d, mask_d, LLerr_d) + else: + FUK.log_likelihood(f_d, addr_d, fmag_d, mask_d, LLerr_d) + + expected_err_phot = LLerr + measured_err_phot = LLerr_d.get() + + np.testing.assert_allclose(expected_err_phot, measured_err_phot, err_msg="Numpy log-likelihood error " + "is \n%s, \nbut gpu log-likelihood error is \n%s, \n " % ( + repr(expected_err_phot), + repr(measured_err_phot)), rtol=1e-5) + def test_log_likelihood_UNITY(self): + self.log_likelihood_UNITY_tester(False) + + def test_log_likelihood2_UNITY(self): + self.log_likelihood_UNITY_tester(True) + + def test_exit_error_UNITY(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + G = 2 # number of object modes + + E = B # probe size y + F = C # probe size x + + scan_pts = 2 # one dimensional scan point number + + N = scan_pts ** 2 + total_number_modes = G * D + A = N * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + aux = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + aux[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((N,)) + Y = Y.reshape((N,)) + + addr = np.zeros((N, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [position_idx, 0, 0], + [position_idx, 0, 0]]) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + from ptypy.accelerate.base.kernels import FourierUpdateKernel as npFourierUpdateKernel + aux_d = gpuarray.to_gpu(aux) + addr_d = gpuarray.to_gpu(addr) + + nFUK = npFourierUpdateKernel(aux, nmodes=total_number_modes) + FUK = FourierUpdateKernel(aux, nmodes=total_number_modes) + + nFUK.allocate() + FUK.allocate() + + nFUK.exit_error(aux, addr, ) + FUK.exit_error(aux_d, addr_d) + + expected_ferr = nFUK.npy.ferr + measured_ferr = FUK.gpu.ferr.get() + + np.testing.assert_allclose(expected_ferr, measured_ferr, err_msg="Numpy ferr" + "is \n%s, \nbut gpu ferr is \n %s, \n " % ( + repr(expected_ferr), + repr(measured_ferr)), rtol=1e-7) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/accelerate_tests/cuda_pycuda_tests/gpudata_test.py b/test/accelerate_tests/cuda_pycuda_tests/gpudata_test.py new file mode 100644 index 000000000..d3b4c2fe7 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/gpudata_test.py @@ -0,0 +1,258 @@ +''' +''' + +import unittest +import numpy as np +from . import PyCudaTest, have_pycuda + +if have_pycuda(): + import pycuda.driver as cuda + from pycuda.compiler import SourceModule + from ptypy.accelerate.cuda_pycuda.mem_utils import GpuData, GpuDataManager + +class GpuDataTest(PyCudaTest): + + def test_to_gpu_new(self): + # arrange + cpu = 2. * np.ones((5,5), dtype=np.float32) + gdata = GpuData(cpu.nbytes, syncback=False) + + # act + gpu = gdata.to_gpu(cpu, '1', self.stream) + self.stream.synchronize() + + # assert + np.testing.assert_array_equal(cpu, gpu.get()) + + def test_to_gpu_sameid(self): + # arrange + cpu = 2. * np.ones((5,5), dtype=np.float32) + gdata = GpuData(cpu.nbytes, syncback=False) + + # act + gpu1 = gdata.to_gpu(cpu, '1', self.stream) + cpu *= 2. + gpu2 = gdata.to_gpu(cpu, '1', self.stream) + self.stream.synchronize() + + # assert + np.testing.assert_array_equal(gpu1.get(), gpu2.get()) + + def test_to_gpu_new_syncback(self): + # arrange + cpu = 2. * np.ones((5,5), dtype=np.float32) + gdata = GpuData(cpu.nbytes, syncback=True) + + # act + gpu1 = gdata.to_gpu(cpu, '1', self.stream) + gpu1.fill(np.float32(3.), self.stream) + cpu2 = 2. * cpu + gpu2 = gdata.to_gpu(cpu2, '2', self.stream) + self.stream.synchronize() + + # assert + np.testing.assert_array_equal(cpu, 3.) + np.testing.assert_array_equal(gpu2.get(), cpu2) + + def test_to_gpu_new_nosyncback(self): + # arrange + cpu = 2. * np.ones((5,5), dtype=np.float32) + gdata = GpuData(cpu.nbytes, syncback=False) + + # act + gpu1 = gdata.to_gpu(cpu, '1', self.stream) + gpu1.fill(np.float32(3.), self.stream) + cpu2 = 2. * cpu + gpu2 = gdata.to_gpu(cpu2, '2', self.stream) + self.stream.synchronize() + + # assert + np.testing.assert_array_equal(cpu, 2.) + np.testing.assert_array_equal(gpu2.get(), cpu2) + + def test_from_gpu(self): + # arrange + cpu = 2. * np.ones((5,5), dtype=np.float32) + gdata = GpuData(cpu.nbytes, syncback=False) + + # act + gpu1 = gdata.to_gpu(cpu, '1', self.stream) + gpu1.fill(np.float32(3.), self.stream) + gdata.from_gpu(self.stream) + self.stream.synchronize() + + def test_data_variable_size(self): + # arrange + cpu = np.ones((2,5), dtype=np.float32) + cpu2 = 2. * np.ones((1,5), dtype=np.float32) + gdata = GpuData(cpu.nbytes, syncback=False) + + # act + gpu = gdata.to_gpu(cpu, '1', self.stream) + gpu2 = gdata.to_gpu(cpu2, '2', self.stream) + self.stream.synchronize() + + # assert + np.testing.assert_array_equal(gpu2.get(), cpu2) + self.assertEqual(cpu2.nbytes, gpu2.nbytes) + np.testing.assert_array_equal(gpu.get(), np.array([ + [2, 2, 2, 2, 2], + [1, 1, 1, 1, 1] + ], dtype=np.float32)) + + def test_data_variable_size_raise(self): + # arrange + cpu = np.ones((1,5), dtype=np.float32) + cpu2 = np.ones((2,4), dtype=np.float32) + gdata = GpuData(cpu.nbytes, syncback=False) + + # act/assert + with self.assertRaises(Exception): + gdata.to_gpu(cpu2, '1', self.stream) + + def test_data_resize_raise(self): + # arrange + cpu = np.ones((5,5), dtype=np.float32) + gdata = GpuData(cpu.nbytes, syncback=False) + gpu = gdata.to_gpu(cpu, '1', self.stream) + cpu2 = np.ones((10,5), dtype=np.float32) + + # act + gdata.resize(cpu2.nbytes) + gpu2 = gdata.to_gpu(cpu2, '1', self.stream) + + # assert + self.assertEqual(gdata.gpuId, '1') + self.assertEqual(gdata.nbytes, cpu2.nbytes) + self.assertEqual(gpu2.size, cpu2.size) + self.assertGreaterEqual(gdata.nbytes_buffer, cpu2.nbytes) + + def test_data_resize_shrink(self): + # arrange + cpu = np.ones((5,5), dtype=np.float32) + gdata = GpuData(cpu.nbytes, syncback=False) + gpu = gdata.to_gpu(cpu, '1', self.stream) + cpu2 = np.ones((4,6), dtype=np.float32) + + # act + gdata.resize(cpu2.nbytes) + gpu2 = gdata.to_gpu(cpu2, '1', self.stream) + + # assert + self.assertEqual(gdata.gpuId, '1') + self.assertEqual(gdata.nbytes, cpu2.nbytes) + self.assertEqual(gpu2.size, cpu2.size) + self.assertGreaterEqual(gdata.nbytes_buffer, cpu2.nbytes) + + def test_datamanager_memory(self): + # arrange / act + gdm = GpuDataManager(128, 4) + gdm.reset(124, 3) + + # assert + self.assertEqual(gdm.memory, 3*128) + self.assertEqual(gdm.nbytes, 124) + + def test_datamanager_free(self): + # arrange + gdm = GpuDataManager(128, 2) + + # act + gdm.free() + + # assert + self.assertEqual(gdm.memory, 0) + + def test_datamanager_newids(self): + # arrange + cpu1 = 2. * np.ones((5,5), dtype=np.float32) + cpu2 = 2. * cpu1 # 4 + cpu3 = 2. * cpu2 # 8 + cpu4 = 2. * cpu3 # 16 + gdm = GpuDataManager(cpu1.nbytes, 4, syncback=False) + + # act + gpu1 = gdm.to_gpu(cpu1, '1', self.stream)[1] + gpu2 = gdm.to_gpu(cpu2, '2', self.stream)[1] + gpu11 = gdm.to_gpu(-1.*cpu1, '1', self.stream)[1] + gpu21 = gdm.to_gpu(-1.*cpu4, '2', self.stream)[1] + gpu3 = gdm.to_gpu(cpu3, '3', self.stream)[1] + gpu31 = gdm.to_gpu(-1.*cpu1, '3', self.stream)[1] + gpu4 = gdm.to_gpu(cpu4, '4', self.stream)[1] + gpu41 = gdm.to_gpu(-1.*cpu1, '4', self.stream)[1] + self.stream.synchronize() + + # assert + np.testing.assert_array_equal(cpu1, gpu1.get()) + np.testing.assert_array_equal(cpu1, gpu11.get()) + np.testing.assert_array_equal(cpu1, 2.) + np.testing.assert_array_equal(cpu2, gpu2.get()) + np.testing.assert_array_equal(cpu2, gpu21.get()) + np.testing.assert_array_equal(cpu2, 4.) + np.testing.assert_array_equal(cpu3, gpu3.get()) + np.testing.assert_array_equal(cpu3, gpu31.get()) + np.testing.assert_array_equal(cpu3, 8.) + np.testing.assert_array_equal(cpu4, gpu4.get()) + np.testing.assert_array_equal(cpu4, gpu41.get()) + np.testing.assert_array_equal(cpu4, 16.) + + def test_datamanager_syncback(self): + # arrange + cpu1 = 2. * np.ones((5,5), dtype=np.float32) + cpu2 = 2. * cpu1 # 4 + cpu3 = 2. * cpu2 # 8 + cpu4 = 2. * cpu3 # 16 + gdm = GpuDataManager(cpu1.nbytes, 2, syncback=True) + + # act + gpu1 = gdm.to_gpu(cpu1, '1', self.stream)[1] + gpu2 = gdm.to_gpu(cpu2, '2', self.stream)[1] + gpu1.fill(np.float32(3.), self.stream) + gpu2.fill(np.float32(5.), self.stream) + gpu3 = gdm.to_gpu(cpu3, '3', self.stream)[1] + gpu3.fill(np.float32(7.), self.stream) + gpu4 = gdm.to_gpu(cpu4, '4', self.stream)[1] + gpu4.fill(np.float32(9.), self.stream) + gdm.syncback = False + gpu5 = gdm.to_gpu(cpu4*.2, '5', self.stream)[1] + gpu6 = gdm.to_gpu(cpu4*.4, '6', self.stream)[1] + self.stream.synchronize() + + # assert + np.testing.assert_array_equal(cpu1, 3.) + np.testing.assert_array_equal(cpu2, 5.) + np.testing.assert_array_equal(cpu3, 8.) + np.testing.assert_array_equal(cpu4, 16.) + + def test_data_synctransfer(self): + # arrange + sh = (1024, 1024, 1) # 4MB + cpu1 = cuda.pagelocked_zeros(sh, np.float32, order="C", mem_flags=0) + cpu2 = cuda.pagelocked_zeros(sh, np.float32, order="C", mem_flags=0) + cpu1[:] = 1. + cpu2[:] = 2. + gdata = GpuData(cpu1.nbytes, syncback=True) + # long-running kernel + knl = """ + extern "C" __global__ void tfill(float* d, int sz, float dval) { + for (int i = 0; i < sz; ++i) + d[i] = dval; + } + """ + mod = SourceModule(knl, no_extern_c=True) + tfill = mod.get_function('tfill') + + # act + s2 = cuda.Stream() + gpu1 = gdata.to_gpu(cpu1, '1', self.stream) + tfill(gpu1, np.int32(gpu1.size), np.float32(2.), grid=(1,1,1), block=(1,1,1), stream=self.stream) + gdata.record_done(self.stream) # it will fail without this + gpu2 = gdata.to_gpu(cpu2, '2', s2) + tfill(gpu1, np.int32(gpu2.size), np.float32(4.), grid=(1,1,1), block=(1,1,1), stream=s2) + gdata.from_gpu(s2) + self.stream.synchronize() + s2.synchronize() + + # assert + np.testing.assert_array_equal(cpu1, 2.) + np.testing.assert_array_equal(cpu2, 4.) diff --git a/test/accelerate_tests/cuda_pycuda_tests/gradient_descent_kernel_test.py b/test/accelerate_tests/cuda_pycuda_tests/gradient_descent_kernel_test.py new file mode 100644 index 000000000..6caed13f2 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/gradient_descent_kernel_test.py @@ -0,0 +1,327 @@ +''' + + +''' + +import unittest +import numpy as np +from . import perfrun, PyCudaTest, have_pycuda + + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.kernels import GradientDescentKernel + + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + + +class GradientDescentKernelTest(PyCudaTest): + + def prepare_arrays(self, performance=False): + if not performance: + nmodes = 2 + N_buf = 4 + N = 3 + A = 3 + else: + nmodes = 4 + N_buf = 100 + N = 80 + A = 512 + i_sh = (N, A, A) + e_sh = (N*nmodes, A, A) + f_sh = (N_buf, A, A) + a_sh = (N_buf * nmodes, A, A) + w = np.ones(i_sh, dtype=FLOAT_TYPE) + for idx, sl in enumerate(w): + sl[idx % A, idx % A] = 0.0 + X, Y, Z = np.indices(a_sh, dtype=COMPLEX_TYPE) + b_f = X + 1j * Y + b_a = Y + 1j * Z + b_b = Z + 1j * X + err_sum = np.zeros((N,), dtype=FLOAT_TYPE) + fic = np.ones((N,), dtype=FLOAT_TYPE) + addr = np.zeros((N, nmodes, 5, 3), dtype=INT_TYPE) + I = np.empty(i_sh, dtype=FLOAT_TYPE) + I[:] = np.round(np.abs(b_f[:N])**2 % 20) + for pos_idx in range(N): + for mode_idx in range(nmodes): + exit_idx = pos_idx * nmodes + mode_idx + addr[pos_idx, mode_idx] = np.array([[mode_idx, 0, 0], + [0, 0, 0], + [exit_idx, 0, 0], + [pos_idx, 0, 0], + [pos_idx, 0, 0]], dtype=INT_TYPE) + return (gpuarray.to_gpu(b_f), + gpuarray.to_gpu(b_a), + gpuarray.to_gpu(b_b), + gpuarray.to_gpu(I), + gpuarray.to_gpu(w), + gpuarray.to_gpu(err_sum), + gpuarray.to_gpu(addr), + gpuarray.to_gpu(fic)) + + def test_allocate(self): + b_f, b_a, b_b, I, w, err_sum, addr, fic = self.prepare_arrays() + GDK = GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + + def test_make_model(self): + b_f, b_a, b_b, I, w, err_sum, addr, fic = self.prepare_arrays() + + GDK = GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.make_model(b_f, addr) + + exp_Imodel = np.array([[[1., 1., 1.], + [3., 3., 3.], + [9., 9., 9.]], + + [[13., 13., 13.], + [15., 15., 15.], + [21., 21., 21.]], + + [[41., 41., 41.], + [43., 43., 43.], + [49., 49., 49.]], + + [[85., 85., 85.], + [87., 87., 87.], + [93., 93., 93.]]], dtype=FLOAT_TYPE) + + np.testing.assert_array_almost_equal( + exp_Imodel, GDK.gpu.Imodel.get(), + err_msg="`Imodel` buffer has not been updated as expected") + + @unittest.skipIf(not perfrun, "performance test") + def test_make_model_performance(self): + b_f, b_a, b_b, I, w, err_sum, addr, fic = self.prepare_arrays(performance=True) + + GDK = GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.make_model(b_f, addr) + + def test_floating_intensity(self): + b_f, b_a, b_b, I, w, err_sum, addr, fic = self.prepare_arrays() + GDK=GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.gpu.Imodel[0] = I[0] * 3. + GDK.gpu.Imodel[1] = I[1] * 2. + GDK.gpu.Imodel[2] = I[2] + GDK.floating_intensity(addr, w, I, fic) + #print('Imodel',repr(GDK.gpu.Imodel)) + #print('fic',repr(1./fic)) + exp_Imodel = np.array([[[0., 0., 0.], + [1., 1., 1.], + [4., 4., 4.]], + + [[1., 1., 1.], + [2., 2., 2.], + [5., 5., 5.]], + + [[4., 4., 4.], + [5., 5., 5.], + [8., 8., 8.]], + + [[0., 0., 0.], + [0., 0., 0.], + [0., 0., 0.]]], dtype=np.float32) + exp_fic=1./np.array([3., 2., 1.], dtype=np.float32) + np.testing.assert_array_almost_equal(exp_Imodel, GDK.gpu.Imodel.get(), + err_msg="`Imodel` buffer has not been updated as expected") + np.testing.assert_array_almost_equal(exp_fic, fic.get(), + err_msg="floating intensity coeff (fic) has not been updated as expected") + + def test_make_a012(self): + b_f, b_a, b_b, I, w, err_sum, addr, fic = self.prepare_arrays() + GDK = GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.make_a012(b_f, b_a, b_b, addr, I, fic) + + exp_A0 = np.array([[[1., 1., 1.], + [2., 2., 2.], + [5., 5., 5.]], + + [[12., 12., 12.], + [13., 13., 13.], + [16., 16., 16.]], + + [[37., 37., 37.], + [38., 38., 38.], + [41., 41., 41.]], + + [[0., 0., 0.], + [0., 0., 0.], + [0., 0., 0.]]], dtype=FLOAT_TYPE) + np.testing.assert_array_almost_equal( + exp_A0, GDK.gpu.Imodel.get(), + err_msg="`Imodel` buffer (=A0) has not been updated as expected") + + exp_A1 = np.array([[[0., 0., 0.], + [2., 6., 10.], + [4., 12., 20.]], + + [[0., 0., 0.], + [10., 14., 18.], + [20., 28., 36.]], + + [[0., 0., 0.], + [18., 22., 26.], + [36., 44., 52.]], + + [[0., 0., 0.], + [0., 0., 0.], + [0., 0., 0.]]], dtype=FLOAT_TYPE) + np.testing.assert_array_almost_equal( + exp_A1, GDK.gpu.LLerr.get(), + err_msg="`LLerr` buffer (=A1) has not been updated as expected") + + exp_A2 = np.array([[[0., 4., 12.], + [4., 8., 16.], + [12., 16., 24.]], + + [[0., 12., 28.], + [12., 24., 40.], + [28., 40., 56.]], + + [[0., 20., 44.], + [20., 40., 64.], + [44., 64., 88.]], + + [[0., 0., 0.], + [0., 0., 0.], + [0., 0., 0.]]], dtype=FLOAT_TYPE) + np.testing.assert_array_almost_equal( + exp_A2, GDK.gpu.LLden.get(), + err_msg="`LLden` buffer (=A2) has not been updated as expected") + + @unittest.skipIf(not perfrun, "performance test") + def test_make_a012_performance(self): + b_f, b_a, b_b, I, w, err_sum, addr, fic = self.prepare_arrays(performance=True) + + GDK = GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.make_a012(b_f, b_a, b_b, addr, I, fic) + + def test_fill_b(self): + b_f, b_a, b_b, I, w, err_sum, addr, fic = self.prepare_arrays() + Brenorm = 0.35 + B = np.zeros((3,), dtype=FLOAT_TYPE) + B_dev = gpuarray.to_gpu(B) + GDK = GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.make_a012(b_f, b_a, b_b, addr, I, fic) + GDK.fill_b(addr, Brenorm, w, B_dev) + B[:] = B_dev.get() + + exp_B = np.array([ 4699.8, 5398.4, 13398.], dtype=FLOAT_TYPE) + np.testing.assert_allclose( + B, exp_B, + rtol=1e-7, + err_msg="`B` has not been updated as expected") + + @unittest.skipIf(not perfrun, "performance test") + def test_fill_b_perf(self): + b_f, b_a, b_b, I, w, err_sum, addr, fic = self.prepare_arrays(performance=True) + Brenorm = 0.35 + B = np.zeros((3,), dtype=FLOAT_TYPE) + B_dev = gpuarray.to_gpu(B) + GDK = GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.make_a012(b_f, b_a, b_b, addr, I, fic) + GDK.fill_b(addr, Brenorm, w, B_dev) + + def test_error_reduce(self): + b_f, b_a, b_b, I, w, err_sum, addr, fic = self.prepare_arrays() + GDK = GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.npy.LLerr = np.indices(GDK.gpu.LLerr.shape, dtype=FLOAT_TYPE)[0] + GDK.gpu.LLerr = gpuarray.to_gpu(GDK.npy.LLerr) + GDK.error_reduce(addr, err_sum) + + exp_err = np.array([0., 9., 18.], dtype=FLOAT_TYPE) + np.testing.assert_array_almost_equal( + exp_err, err_sum.get(), + err_msg="`err_sum` has not been updated as expected") + + @unittest.skipIf(not perfrun, "performance test") + def test_error_reduce_perf(self): + b_f, b_a, b_b, I, w, err_sum, addr, fic = self.prepare_arrays(performance=True) + GDK = GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.npy.LLerr = np.indices(GDK.gpu.LLerr.shape, dtype=FLOAT_TYPE)[0] + GDK.gpu.LLerr = gpuarray.to_gpu(GDK.npy.LLerr) + GDK.error_reduce(addr, err_sum) + + def test_main(self): + b_f, b_a, b_b, I, w, err_sum, addr, fic = self.prepare_arrays() + GDK = GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.main(b_f, addr, w, I) + + exp_b_f = np.array([[[0. + 0.j, 0. + 0.j, 0. + 0.j], + [-0. - 1.j, -0. - 1.j, -0. - 1.j], + [-0. - 8.j, -0. - 8.j, -0. - 8.j]], + + [[0. + 0.j, 0. + 0.j, 0. + 0.j], + [-1. - 1.j, -1. - 1.j, -1. - 1.j], + [-4. - 8.j, -4. - 8.j, -4. - 8.j]], + + [[-2. + 0.j, -2. + 0.j, -2. + 0.j], + [-4. - 2.j, -0. + 0.j, -4. - 2.j], + [-10.-10.j, -10.-10.j, -10.-10.j]], + + [[-3. + 0.j, -3. + 0.j, -3. + 0.j], + [-6. - 2.j, -0. + 0.j, -6. - 2.j], + [-15.-10.j, -15.-10.j, -15.-10.j]], + + [[-16. + 0.j, -16. + 0.j, -16. + 0.j], + [-20. - 5.j, -20. - 5.j, -20. - 5.j], + [-32.-16.j, -32.-16.j, -0. + 0.j]], + + [[-20. + 0.j, -20. + 0.j, -20. + 0.j], + [-25. - 5.j, -25. - 5.j, -25. - 5.j], + [-40.-16.j, -40.-16.j, -0. + 0.j]], + + [[6. + 0.j, 6. + 0.j, 6. + 0.j], + [6. + 1.j, 6. + 1.j, 6. + 1.j], + [6. + 2.j, 6. + 2.j, 6. + 2.j]], + + [[7. + 0.j, 7. + 0.j, 7. + 0.j], + [7. + 1.j, 7. + 1.j, 7. + 1.j], + [7. + 2.j, 7. + 2.j, 7. + 2.j]]], dtype=COMPLEX_TYPE) + np.testing.assert_array_almost_equal( + exp_b_f, b_f.get(), + err_msg="Auxiliary has not been updated as expected") + + exp_LL = np.array([[[0., 0., 0.], + [1., 1., 1.], + [16., 16., 16.]], + + [[1., 1., 1.], + [4., 0., 4.], + [25., 25., 25.]], + + [[16., 16., 16.], + [25., 25., 25.], + [64., 64., 0.]], + + [[0., 0., 0.], + [0., 0., 0.], + [0., 0., 0.]]], dtype=FLOAT_TYPE) + np.testing.assert_array_almost_equal( + exp_LL, GDK.gpu.LLerr.get(), + err_msg="LogLikelihood error has not been updated as expected") + + @unittest.skipIf(not perfrun, "performance test") + def test_main_perf(self): + b_f, b_a, b_b, I, w, err_sum, addr, fic = self.prepare_arrays(performance=True) + GDK = GradientDescentKernel(b_f, addr.shape[1]) + GDK.allocate() + GDK.main(b_f, addr, w, I) + +if __name__ == '__main__': + unittest.main() \ No newline at end of file diff --git a/test/accelerate_tests/cuda_pycuda_tests/import_test.py b/test/accelerate_tests/cuda_pycuda_tests/import_test.py new file mode 100644 index 000000000..8e445acf3 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/import_test.py @@ -0,0 +1,10 @@ +""" +Import test +""" +import unittest + +class AutoLoaderTest(unittest.TestCase): + + def test_load_engines_cuda(self): + import ptypy + ptypy.load_gpu_engines("cuda") diff --git a/test/accelerate_tests/cuda_pycuda_tests/multi_gpu_test.py b/test/accelerate_tests/cuda_pycuda_tests/multi_gpu_test.py new file mode 100644 index 000000000..64cc5110d --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/multi_gpu_test.py @@ -0,0 +1,84 @@ +''' +''' + +import unittest +from mpi4py.MPI import Get_version +import numpy as np +from . import PyCudaTest, have_pycuda + +if have_pycuda(): + from pycuda import gpuarray + import pycuda.driver as cuda + from ptypy.accelerate.cuda_pycuda import multi_gpu as mgpu + from ptypy.utils import parallel + +from pkg_resources import parse_version + +class GpuDataTest(PyCudaTest): + """ + This is a test class for MPI - to really check if it all works, it needs + to be run as: + + mpirun -np 2 pytest multi_gpu_test.py + + For CUDA-aware MPI testing, currently the environment variable + + OMPI_MCA_opal_cuda_support=true + + needs to be set, mpi4py version 3.1.0+ used, a pycuda build from master, + and a cuda-aware MPI version. + """ + + def setUp(self): + if parallel.rank_local < cuda.Device.count(): + self.device = cuda.Device(parallel.rank_local) + self.ctx = self.device.make_context() + self.ctx.push() + else: + self.ctx = None + + def tearDown(self): + if self.ctx is not None: + self.ctx.pop() + self.ctx.detach() + + @unittest.skipIf(parallel.rank != 0, "Only in MPI rank 0") + def test_version(self): + v1 = parse_version("3.1.0") + v2 = parse_version(parse_version("3.1.0a").base_version) + + self.assertGreaterEqual(v2, v1) + + def test_compute_mode(self): + attr = cuda.Context.get_device().get_attributes() + self.assertIn(cuda.device_attribute.COMPUTE_MODE, attr) + mode = attr[cuda.device_attribute.COMPUTE_MODE] + self.assertIn(mode, + [cuda.compute_mode.DEFAULT, cuda.compute_mode.PROHIBITED, cuda.compute_mode.EXCLUSIVE_PROCESS] + ) + + def multigpu_tester(self, com): + if self.ctx is None: + return + + data = np.ones((2, 1), dtype=np.float32) + data_dev = gpuarray.to_gpu(data) + sz = parallel.size + com.allReduceSum(data_dev) + + out = data_dev.get() + np.testing.assert_allclose(out, sz * data, rtol=1e-6) + + def test_multigpu_auto(self): + self.multigpu_tester(mgpu.get_multi_gpu_communicator()) + + def test_multigpu_mpi(self): + self.multigpu_tester(mgpu.MultiGpuCommunicatorMpi()) + + @unittest.skipIf(not mgpu.have_cuda_mpi, "Cuda-aware MPI not available") + def test_multigpu_cudampi(self): + self.multigpu_tester(mgpu.MultiGpuCommunicatorCudaMpi()) + + @unittest.skipIf(not mgpu.have_nccl, "NCCL not available") + def test_multigpu_nccl(self): + self.multigpu_tester(mgpu.MultiGpuCommunicatorNccl()) \ No newline at end of file diff --git a/test/accelerate_tests/cuda_pycuda_tests/po_update_kernel_test.py b/test/accelerate_tests/cuda_pycuda_tests/po_update_kernel_test.py new file mode 100644 index 000000000..27c6abb56 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/po_update_kernel_test.py @@ -0,0 +1,943 @@ +''' + + +''' + +import unittest +import numpy as np +from . import PyCudaTest, have_pycuda +from ptypy.accelerate.base.array_utils import max_abs2 + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.kernels import PoUpdateKernel + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + + +class PoUpdateKernelTest(PyCudaTest): + + def prepare_arrays(self, scan_points=None): + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + if scan_points is None: + scan_pts = 2 # one dimensional scan point number + else: + scan_pts = scan_points + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): # + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + object_array_denominator = np.empty_like(object_array, dtype=FLOAT_TYPE) + for idx in range(G): + object_array_denominator[idx] = np.ones((H, I)) * (5 * idx + 2) + + probe_denominator = np.empty_like(probe, dtype=FLOAT_TYPE) + for idx in range(D): + probe_denominator[idx] = np.ones((E, F)) * (5 * idx + 2) + + return (gpuarray.to_gpu(addr), + gpuarray.to_gpu(object_array), + gpuarray.to_gpu(object_array_denominator), + gpuarray.to_gpu(probe), + gpuarray.to_gpu(exit_wave), + gpuarray.to_gpu(probe_denominator)) + + + def test_init(self): + POUK = PoUpdateKernel() + np.testing.assert_equal(POUK.kernels, ['pr_update', 'ob_update'], + err_msg='PoUpdateKernel does not have the correct functions registered.') + + def ob_update_REGRESSION_tester(self, atomics=True): + + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 2 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y):# + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + object_array_denominator = np.empty_like(object_array, dtype=FLOAT_TYPE) + for idx in range(G): + object_array_denominator[idx] = np.ones((H, I)) * (5 * idx + 2) + + + POUK = PoUpdateKernel() + from ptypy.accelerate.base.kernels import PoUpdateKernel as npPoUpdateKernel + nPOUK = npPoUpdateKernel() + # print("object array denom before:") + # print(object_array_denominator) + object_array_dev = gpuarray.to_gpu(object_array) + object_array_denominator_dev = gpuarray.to_gpu(object_array_denominator) + probe_dev = gpuarray.to_gpu(probe) + exit_wave_dev = gpuarray.to_gpu(exit_wave) + if not atomics: + addr2 = np.ascontiguousarray(np.transpose(addr, (2, 3, 0, 1))) + addr_dev = gpuarray.to_gpu(addr2) + else: + addr_dev = gpuarray.to_gpu(addr) + + print(object_array_denominator) + POUK.ob_update(addr_dev, object_array_dev, object_array_denominator_dev, probe_dev, exit_wave_dev, atomics=atomics) + print("\n\n cuda version") + print(object_array_denominator_dev.get()) + nPOUK.ob_update(addr, object_array, object_array_denominator, probe, exit_wave) + print("\n\n numpy version") + print(object_array_denominator) + + + + expected_object_array = np.array([[[15.+1.j, 53.+1.j, 53.+1.j, 53.+1.j, 53.+1.j, 39.+1.j, 1.+1.j], + [77.+1.j, 201.+1.j, 201.+1.j, 201.+1.j, 201.+1.j, 125.+1.j, 1.+1.j], + [77.+1.j, 201.+1.j, 201.+1.j, 201.+1.j, 201.+1.j, 125.+1.j, 1.+1.j], + [77.+1.j, 201.+1.j, 201.+1.j, 201.+1.j, 201.+1.j, 125.+1.j, 1.+1.j], + [77.+1.j, 201.+1.j, 201.+1.j, 201.+1.j, 201.+1.j, 125.+1.j, 1.+1.j], + [63.+1.j, 149.+1.j, 149.+1.j, 149.+1.j, 149.+1.j, 87.+1.j, 1.+1.j], + [1.+1.j, 1.+1.j, 1.+1.j, 1.+1.j, 1.+1.j, 1.+1.j, 1.+1.j]], + [[24. + 4.j, 68. + 4.j, 68. + 4.j, 68. + 4.j, 68. + 4.j, 48. + 4.j, 4. + 4.j], + [92. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 140. + 4.j, 4. + 4.j], + [92. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 140. + 4.j, 4. + 4.j], + [92. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 140. + 4.j, 4. + 4.j], + [92. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 228. + 4.j, 140. + 4.j, 4. + 4.j], + [72. + 4.j, 164. + 4.j, 164. + 4.j, 164. + 4.j, 164. + 4.j, 96. + 4.j, 4. + 4.j], + [4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j]]], + dtype=COMPLEX_TYPE) + + + np.testing.assert_array_equal(object_array, expected_object_array, + err_msg="The object array has not been updated as expected") + + expected_object_array_denominator = np.array([[[12., 22., 22., 22., 22., 12., 2.], + [22., 42., 42., 42., 42., 22., 2.], + [22., 42., 42., 42., 42., 22., 2.], + [22., 42., 42., 42., 42., 22., 2.], + [22., 42., 42., 42., 42., 22., 2.], + [12., 22., 22., 22., 22., 12., 2.], + [ 2., 2., 2., 2., 2., 2., 2.]], + + [[17., 27., 27., 27., 27., 17., 7.], + [27., 47., 47., 47., 47., 27., 7.], + [27., 47., 47., 47., 47., 27., 7.], + [27., 47., 47., 47., 47., 27., 7.], + [27., 47., 47., 47., 47., 27., 7.], + [17., 27., 27., 27., 27., 17., 7.], + [ 7., 7., 7., 7., 7., 7., 7.]]], + dtype=FLOAT_TYPE) + + + np.testing.assert_array_equal(object_array_denominator_dev.get(), expected_object_array_denominator, + err_msg="The object array denominatorhas not been updated as expected") + + + def test_ob_update_atomics_REGRESSION(self): + self.ob_update_REGRESSION_tester(atomics=True) + + def test_ob_update_tiled_REGRESSION(self): + self.ob_update_REGRESSION_tester(atomics=False) + + def ob_update_UNITY_tester(self, atomics=True): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 2 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y):# + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + object_array_denominator = np.empty_like(object_array, dtype=FLOAT_TYPE) + for idx in range(G): + object_array_denominator[idx] = np.ones((H, I)) * (5 * idx + 2) + + + POUK = PoUpdateKernel() + + from ptypy.accelerate.base.kernels import PoUpdateKernel as npPoUpdateKernel + nPOUK = npPoUpdateKernel() + + object_array_dev = gpuarray.to_gpu(object_array) + object_array_denominator_dev = gpuarray.to_gpu(object_array_denominator) + probe_dev = gpuarray.to_gpu(probe) + exit_wave_dev = gpuarray.to_gpu(exit_wave) + if not atomics: + addr2 = np.ascontiguousarray(np.transpose(addr, (2, 3, 0, 1))) + addr_dev = gpuarray.to_gpu(addr2) + else: + addr_dev = gpuarray.to_gpu(addr) + + # print(object_array_denominator) + POUK.ob_update(addr_dev, object_array_dev, object_array_denominator_dev, probe_dev, exit_wave_dev, atomics=atomics) + # print("\n\n cuda version") + # print(repr(object_array_dev.get())) + # print(repr(object_array_denominator_dev.get())) + nPOUK.ob_update(addr, object_array, object_array_denominator, probe, exit_wave) + # print("\n\n numpy version") + # print(repr(object_array_denominator)) + # print(repr(object_array)) + + + np.testing.assert_array_equal(object_array, object_array_dev.get(), + err_msg="The object array has not been updated as expected") + + + np.testing.assert_array_equal(object_array_denominator, object_array_denominator_dev.get(), + err_msg="The object array denominatorhas not been updated as expected") + + + def test_ob_update_atomics_UNITY(self): + self.ob_update_UNITY_tester(atomics=True) + + def test_ob_update_tiled_UNITY(self): + self.ob_update_UNITY_tester(atomics=False) + + def pr_update_REGRESSION_tester(self, atomics=True): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 2 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): # + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + probe_denominator = np.empty_like(probe, dtype=FLOAT_TYPE) + for idx in range(D): + probe_denominator[idx] = np.ones((E, F)) * (5 * idx + 2) + + POUK = PoUpdateKernel() + + # print("probe array before:") + # print(repr(probe)) + # print("probe denominator array before:") + # print(repr(probe_denominator)) + + object_array_dev = gpuarray.to_gpu(object_array) + probe_denominator_dev = gpuarray.to_gpu(probe_denominator) + probe_dev = gpuarray.to_gpu(probe) + exit_wave_dev = gpuarray.to_gpu(exit_wave) + if not atomics: + addr2 = np.ascontiguousarray(np.transpose(addr, (2, 3, 0, 1))) + addr_dev = gpuarray.to_gpu(addr2) + else: + addr_dev = gpuarray.to_gpu(addr) + + + POUK.pr_update(addr_dev, probe_dev, probe_denominator_dev, object_array_dev, exit_wave_dev, atomics=atomics) + + # print("probe array after:") + # print(repr(probe)) + # print("probe denominator array after:") + # print(repr(probe_denominator)) + expected_probe = np.array([[[313.+1.j, 313.+1.j, 313.+1.j, 313.+1.j, 313.+1.j], + [313.+1.j, 313.+1.j, 313.+1.j, 313.+1.j, 313.+1.j], + [313.+1.j, 313.+1.j, 313.+1.j, 313.+1.j, 313.+1.j], + [313.+1.j, 313.+1.j, 313.+1.j, 313.+1.j, 313.+1.j], + [313.+1.j, 313.+1.j, 313.+1.j, 313.+1.j, 313.+1.j]], + + [[394.+2.j, 394.+2.j, 394.+2.j, 394.+2.j, 394.+2.j], + [394.+2.j, 394.+2.j, 394.+2.j, 394.+2.j, 394.+2.j], + [394.+2.j, 394.+2.j, 394.+2.j, 394.+2.j, 394.+2.j], + [394.+2.j, 394.+2.j, 394.+2.j, 394.+2.j, 394.+2.j], + [394.+2.j, 394.+2.j, 394.+2.j, 394.+2.j, 394.+2.j]]], + dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(probe_dev.get(), expected_probe, + err_msg="The probe has not been updated as expected") + + expected_probe_denominator = np.array([[[138., 138., 138., 138., 138.], + [138., 138., 138., 138., 138.], + [138., 138., 138., 138., 138.], + [138., 138., 138., 138., 138.], + [138., 138., 138., 138., 138.]], + + [[143., 143., 143., 143., 143.], + [143., 143., 143., 143., 143.], + [143., 143., 143., 143., 143.], + [143., 143., 143., 143., 143.], + [143., 143., 143., 143., 143.]]], + dtype=FLOAT_TYPE) + + np.testing.assert_array_equal(probe_denominator_dev.get(), expected_probe_denominator, + err_msg="The probe denominatorhas not been updated as expected") + + + def test_pr_update_atomics_REGRESSION(self): + self.pr_update_REGRESSION_tester(atomics=True) + + def test_pr_update_tiled_REGRESSION(self): + self.pr_update_REGRESSION_tester(atomics=False) + + def pr_update_UNITY_tester(self, atomics=True): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 2 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): # + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + probe_denominator = np.empty_like(probe, dtype=FLOAT_TYPE) + for idx in range(D): + probe_denominator[idx] = np.ones((E, F)) * (5 * idx + 2) + + POUK = PoUpdateKernel() + from ptypy.accelerate.base.kernels import PoUpdateKernel as npPoUpdateKernel + nPOUK = npPoUpdateKernel() + + # print("probe array before:") + # print(repr(probe)) + # print("probe denominator array before:") + # print(repr(probe_denominator)) + + object_array_dev = gpuarray.to_gpu(object_array) + probe_denominator_dev = gpuarray.to_gpu(probe_denominator) + probe_dev = gpuarray.to_gpu(probe) + exit_wave_dev = gpuarray.to_gpu(exit_wave) + if not atomics: + addr2 = np.ascontiguousarray(np.transpose(addr, (2, 3, 0, 1))) + addr_dev = gpuarray.to_gpu(addr2) + else: + addr_dev = gpuarray.to_gpu(addr) + + + POUK.pr_update(addr_dev, probe_dev, probe_denominator_dev, object_array_dev, exit_wave_dev, atomics=atomics) + nPOUK.pr_update(addr, probe, probe_denominator, object_array, exit_wave) + + # print("probe array after:") + # print(repr(probe)) + # print("probe denominator array after:") + # print(repr(probe_denominator)) + + np.testing.assert_array_equal(probe, probe_dev.get(), + err_msg="The probe has not been updated as expected") + + np.testing.assert_array_equal(probe_denominator, probe_denominator_dev.get(), + err_msg="The probe denominatorhas not been updated as expected") + + + def test_pr_update_atomics_UNITY(self): + self.pr_update_UNITY_tester(atomics=True) + + def test_pr_update_tiled_UNITY(self): + self.pr_update_UNITY_tester(atomics=False) + + + def pr_update_ML_tester(self, atomics=False): + ''' + setup + ''' + addr, object_array, object_array_denominator, probe, exit_wave, probe_denominator = self.prepare_arrays() + ''' + test + ''' + POUK = PoUpdateKernel() + + POUK.allocate() # this doesn't do anything, but is the call pattern. + + if not atomics: + addr2 = np.ascontiguousarray(np.transpose(addr.get(), (2, 3, 0, 1))) + addr = gpuarray.to_gpu(addr2) + + POUK.pr_update_ML(addr, probe, object_array, exit_wave, atomics=atomics) + + expected_probe = np.array([[[625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j], + [625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j], + [625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j], + [625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j], + [625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j, 625. + 1.j]], + + [[786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j], + [786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j], + [786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j], + [786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j], + [786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j, 786. + 2.j]]], + dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(probe.get(), expected_probe, + err_msg="The probe has not been updated as expected") + + def test_pr_update_ML_atomics_REGRESSION(self): + self.pr_update_ML_tester(True) + + def test_pr_update_ML_tiled_REGRESSION(self): + self.pr_update_ML_tester(False) + + def ob_update_ML_tester(self, atomics=True): + ''' + setup + ''' + addr, object_array, object_array_denominator, probe, exit_wave, probe_denominator = self.prepare_arrays() + ''' + test + ''' + POUK = PoUpdateKernel() + + POUK.allocate() # this doesn't do anything, but is the call pattern. + + if not atomics: + addr2 = np.ascontiguousarray(np.transpose(addr.get(), (2, 3, 0, 1))) + addr = gpuarray.to_gpu(addr2) + + POUK.ob_update_ML(addr, object_array, probe, exit_wave, atomics=atomics) + + expected_object_array = np.array( + [[[29. + 1.j, 105. + 1.j, 105. + 1.j, 105. + 1.j, 105. + 1.j, 77. + 1.j, 1. + 1.j], + [153. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 249. + 1.j, 1. + 1.j], + [153. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 249. + 1.j, 1. + 1.j], + [153. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 249. + 1.j, 1. + 1.j], + [153. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 401. + 1.j, 249. + 1.j, 1. + 1.j], + [125. + 1.j, 297. + 1.j, 297. + 1.j, 297. + 1.j, 297. + 1.j, 173. + 1.j, 1. + 1.j], + [1. + 1.j, 1. + 1.j, 1. + 1.j, 1. + 1.j, 1. + 1.j, 1. + 1.j, 1. + 1.j]], + + [[44. + 4.j, 132. + 4.j, 132. + 4.j, 132. + 4.j, 132. + 4.j, 92. + 4.j, 4. + 4.j], + [180. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 276. + 4.j, 4. + 4.j], + [180. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 276. + 4.j, 4. + 4.j], + [180. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 276. + 4.j, 4. + 4.j], + [180. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 452. + 4.j, 276. + 4.j, 4. + 4.j], + [140. + 4.j, 324. + 4.j, 324. + 4.j, 324. + 4.j, 324. + 4.j, 188. + 4.j, 4. + 4.j], + [4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j, 4. + 4.j]]], + dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(object_array.get(), expected_object_array, + err_msg="The object array has not been updated as expected") + + def test_ob_update_ML_atomics_REGRESSION(self): + self.ob_update_ML_tester(True) + + def test_ob_update_ML_tiled_REGRESSION(self): + self.ob_update_ML_tester(False) + + def test_ob_update_local_UNITY(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 1 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + auxiliary_wave = exit_wave.copy() * 2 + + probe_norm = np.empty(shape=(1,B,C), dtype=FLOAT_TYPE) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y):# + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + from ptypy.accelerate.base.kernels import PoUpdateKernel as npPoUpdateKernel + nPOUK = npPoUpdateKernel() + POUK = PoUpdateKernel(queue_thread=self.stream) + + object_array_dev = gpuarray.to_gpu(object_array) + probe_dev = gpuarray.to_gpu(probe) + exit_wave_dev = gpuarray.to_gpu(exit_wave) + auxiliary_wave_dev = gpuarray.to_gpu(auxiliary_wave) + probe_norm_dev = gpuarray.to_gpu(probe_norm) + addr_dev = gpuarray.to_gpu(addr) + + POUK.pr_norm_local(addr_dev, probe_dev, probe_norm_dev) + POUK.ob_update_local(addr_dev, object_array_dev, probe_dev, exit_wave_dev, auxiliary_wave_dev, probe_norm_dev, a=0.5, b=0.5) + nPOUK.pr_norm_local(addr, probe, probe_norm) + nPOUK.ob_update_local(addr, object_array, probe, exit_wave, auxiliary_wave, probe_norm, a=0.5, b=0.5) + + np.testing.assert_allclose(object_array_dev.get(), object_array, rtol=1e-6, atol=1e-6, + err_msg="The object array has not been updated as expected") + + def test_pr_update_local_UNITY(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 1 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + auxiliary_wave = exit_wave.copy() * 1.5 + + object_norm = np.empty(shape=(1,B,C), dtype=FLOAT_TYPE) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y):# + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + from ptypy.accelerate.base.kernels import PoUpdateKernel as npPoUpdateKernel + nPOUK = npPoUpdateKernel() + POUK = PoUpdateKernel() + + object_array_dev = gpuarray.to_gpu(object_array) + probe_dev = gpuarray.to_gpu(probe) + exit_wave_dev = gpuarray.to_gpu(exit_wave) + auxiliary_wave_dev = gpuarray.to_gpu(auxiliary_wave) + object_norm_dev = gpuarray.to_gpu(object_norm) + addr_dev = gpuarray.to_gpu(addr) + + POUK.ob_norm_local(addr_dev, object_array_dev, object_norm_dev) + POUK.pr_update_local(addr_dev, probe_dev, object_array_dev,exit_wave_dev, auxiliary_wave_dev, object_norm_dev, gpuarray.max(object_norm_dev, stream=self.stream), a=0.5, b=0.5) + nPOUK.ob_norm_local(addr, object_array, object_norm) + nPOUK.pr_update_local(addr, probe, object_array, exit_wave, auxiliary_wave, object_norm, object_norm.max(), a=0.5, b=0.5) + + np.testing.assert_allclose(probe_dev.get(), probe, rtol=1e-6, atol=1e-6, + err_msg="The probe has not been updated as expected") + + def test_ob_norm_local_UNITY(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 1 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + object_norm = np.empty(shape=(1,B,C), dtype=FLOAT_TYPE) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y):# + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + from ptypy.accelerate.base.kernels import PoUpdateKernel as npPoUpdateKernel + nPOUK = npPoUpdateKernel() + POUK = PoUpdateKernel(queue_thread=self.stream) + + object_array_dev = gpuarray.to_gpu(object_array) + object_norm_dev = gpuarray.to_gpu(object_norm) + addr_dev = gpuarray.to_gpu(addr) + + POUK.ob_norm_local(addr_dev, object_array_dev, object_norm_dev) + nPOUK.ob_norm_local(addr, object_array, object_norm) + + np.testing.assert_allclose(object_norm_dev.get(), object_norm, rtol=1e-6, atol=1e-6, + err_msg="The object norm has not been updated as expected") + + def test_pr_norm_local_UNITY(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 1 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + probe_norm = np.empty(shape=(1,B,C), dtype=FLOAT_TYPE) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y):# + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + from ptypy.accelerate.base.kernels import PoUpdateKernel as npPoUpdateKernel + nPOUK = npPoUpdateKernel() + POUK = PoUpdateKernel() + + probe_dev = gpuarray.to_gpu(probe) + probe_norm_dev = gpuarray.to_gpu(probe_norm) + addr_dev = gpuarray.to_gpu(addr) + + POUK.pr_norm_local(addr_dev, probe_dev, probe_norm_dev) + nPOUK.pr_norm_local(addr, probe, probe_norm) + + np.testing.assert_allclose(probe_norm_dev.get(), probe_norm, rtol=1e-6, atol=1e-6, + err_msg="The probe norm has not been updated as expected") + + +if __name__ == '__main__': + unittest.main() diff --git a/test/accelerate_tests/cuda_pycuda_tests/position_correction_kernel_test.py b/test/accelerate_tests/cuda_pycuda_tests/position_correction_kernel_test.py new file mode 100644 index 000000000..8cbb89c96 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/position_correction_kernel_test.py @@ -0,0 +1,149 @@ +''' + + +''' + +import unittest +import numpy as np +from . import PyCudaTest, have_pycuda +from ptypy import utils as u + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.kernels import PositionCorrectionKernel + from ptypy.accelerate.base.kernels import PositionCorrectionKernel as abPositionCorrectionKernel + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + + +class PositionCorrectionKernelTest(PyCudaTest): + + def setUp(self): + PyCudaTest.setUp(self) + self.params = u.Param() + self.params.nshifts = 4 + self.params.method = "Annealing" + self.params.amplitude = 2e-9 + self.params.start = 0 + self.params.stop = 10 + self.params.max_shift = 2e-9 + self.params.amplitude_decay = True + self.resolution = [1e-9,1e-9] + + def update_addr_and_error_state_UNITY_helper(self, size, modes): + ## Arrange + addr = np.ones((size, modes, 5, 3), dtype=np.int32) + mangled_addr = 2 * addr + err_state = np.zeros((size,), dtype=np.float32) + err_state[5:] = 2. + err_sum = np.ones((size, ), dtype=np.float32) + addr_gpu = gpuarray.to_gpu(addr) + mangled_addr_gpu = gpuarray.to_gpu(mangled_addr) + err_state_gpu = gpuarray.to_gpu(err_state) + err_sum_gpu = gpuarray.to_gpu(err_sum) + aux = np.ones((1,1,1), dtype=np.complex64) + + ## Act + PCK = PositionCorrectionKernel(aux, modes, self.params, self.resolution, queue_thread=self.stream) + PCK.update_addr_and_error_state(addr_gpu, err_state_gpu, mangled_addr_gpu, err_sum_gpu) + abPCK = abPositionCorrectionKernel(aux, modes, self.params, self.resolution) + abPCK.update_addr_and_error_state(addr, err_state, mangled_addr, err_sum) + + ## Assert + np.testing.assert_array_equal(addr_gpu.get(), addr) + np.testing.assert_array_equal(err_state_gpu.get(), err_state) + + def test_update_addr_and_error_state_UNITY_small_onemode(self): + self.update_addr_and_error_state_UNITY_helper(4, 1) + + def test_update_addr_and_error_state_UNITY_large_onemode(self): + self.update_addr_and_error_state_UNITY_helper(323, 1) + + def test_update_addr_and_error_state_UNITY_small_multimode(self): + self.update_addr_and_error_state_UNITY_helper(4, 3) + + def test_update_addr_and_error_state_UNITY_large_multimode(self): + self.update_addr_and_error_state_UNITY_helper(323, 3) + + def log_likelihood_ml_UNITY(self): + ''' + setup + ''' + B = 5 # frame size y + C = 5 # frame size x + + D = 2 # number of probe modes + G = 2 # number of object modes + + E = B # probe size y + F = C # probe size x + + scan_pts = 2 # one dimensional scan point number + + N = scan_pts ** 2 + total_number_modes = G * D + A = N * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + f = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + f[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + fmag = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured magnitudes NxAxB + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + I = fmag**2 + + mask = np.empty(shape=(N, B, C), + dtype=FLOAT_TYPE) # the masks for the measured magnitudes either 1xAxB or NxAxB + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + w = mask /(I+1.) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((N,)) + Y = Y.reshape((N,)) + + addr = np.zeros((N, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y): + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [position_idx, 0, 0], + [position_idx, 0, 0]]) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + mask_sum = mask.sum(-1).sum(-1) + LLerr = np.zeros_like(mask_sum, dtype=np.float32) + f_d = gpuarray.to_gpu(f) + w_d = gpuarray.to_gpu(w) + I_d = gpuarray.to_gpu(I) + addr_d = gpuarray.to_gpu(addr) + LLerr_d = gpuarray.to_gpu(LLerr) + + ## Act + PCK = PositionCorrectionKernel(f, total_number_modes, self.params, self.resolution, queue_thread=self.stream) + abPCK = abPositionCorrectionKernel(f, total_number_modes, self.params, self.resolution) + abPCK.log_likelihood_ml(f, addr, I, w, LLerr) + PCK.log_likelihood_ml(f_d, addr_d, I_d, w_d, LLerr_d) + + expected_err_phot = LLerr + measured_err_phot = LLerr_d.get() + + np.testing.assert_allclose(expected_err_phot, measured_err_phot, err_msg="Numpy log-likelihood error " + "is \n%s, \nbut gpu log-likelihood error is \n%s, \n " % ( + repr(expected_err_phot), + repr(measured_err_phot)), rtol=1e-5) diff --git a/test/accelerate_tests/cuda_pycuda_tests/propagation_kernel_test.py b/test/accelerate_tests/cuda_pycuda_tests/propagation_kernel_test.py new file mode 100644 index 000000000..93fbad431 --- /dev/null +++ b/test/accelerate_tests/cuda_pycuda_tests/propagation_kernel_test.py @@ -0,0 +1,158 @@ +''' + +''' + +import unittest +import numpy as np +import ptypy.utils as u +from . import PyCudaTest, have_pycuda + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.kernels import PropagationKernel + +from ptypy.core import geometry +from ptypy.core import Base as theBase + +# subclass for dictionary access +Base = type('Base',(theBase,),{}) + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +class PropagationKernelTest(PyCudaTest): + + def set_up_farfield(self,shape, resolution=None): + P = Base() + P.CType = COMPLEX_TYPE + P.Ftype = FLOAT_TYPE + g = u.Param() + g.energy = None # u.keV2m(1.0)/6.32e-7 + g.lam = 5.32e-7 + g.distance = 15e-2 + g.psize = 24e-6 + g.shape = shape + g.propagation = "farfield" + if resolution is not None: + g.resolution = resolution + G = geometry.Geo(owner=P, pars=g) + return G + + def set_up_nearfield(self, shape): + P = Base() + P.CType = COMPLEX_TYPE + P.Ftype = FLOAT_TYPE + g = u.Param() + g.energy = None # u.keV2m(1.0)/6.32e-7 + g.lam = 1e-10 + g.distance = 1.0 + g.psize = 100e-9 + g.shape = shape + g.propagation = "nearfield" + G = geometry.Geo(owner=P, pars=g) + return G + + def test_farfield_propagator_forward_UNITY(self): + # setup + SH = (2,16,16) + aux = np.zeros((SH), dtype=COMPLEX_TYPE) + aux[:,5:11,5:11] = 1. + 2j + aux_d = gpuarray.to_gpu(aux) + geo = self.set_up_farfield(SH[1:]) + + # test + aux = geo.propagator.fw(aux) + PropK = PropagationKernel(aux_d, geo.propagator, queue_thread=self.stream) + PropK.allocate() + PropK.fw(aux_d, aux_d) + + np.testing.assert_allclose(aux_d.get(), aux, atol=1e-06, rtol=5e-5, + err_msg="Numpy aux is \n%s, \nbut gpu aux is \n %s, \n " % (repr(aux), repr(aux_d.get()))) + + def test_farfield_propagator_backward_UNITY(self): + # setup + SH = (2,16,16) + aux = np.zeros((SH), dtype=COMPLEX_TYPE) + aux[:,5:11,5:11] = 1. + 2j + aux_d = gpuarray.to_gpu(aux) + geo = self.set_up_farfield(SH[1:]) + + # test + aux = geo.propagator.bw(aux) + PropK = PropagationKernel(aux_d, geo.propagator, queue_thread=self.stream) + PropK.allocate() + PropK.bw(aux_d, aux_d) + + np.testing.assert_allclose(aux_d.get(), aux, atol=1e-06, rtol=5e-5, + err_msg="Numpy aux is \n%s, \nbut gpu aux is \n %s, \n " % (repr(aux), repr(aux_d.get()))) + + def test_farfield_propagator_forward_crop_pad_UNITY(self): + # setup + SH = (2,16,16) + aux = np.zeros((SH), dtype=COMPLEX_TYPE) + aux[:,5:11,5:11] = 1. + 2j + aux_d = gpuarray.to_gpu(aux) + geo = self.set_up_farfield(SH[1:]) + geo = self.set_up_farfield(SH[1:], resolution=0.5*geo.resolution) + + # test + aux = geo.propagator.fw(aux) + PropK = PropagationKernel(aux_d, geo.propagator, queue_thread=self.stream) + PropK.allocate() + PropK.fw(aux_d, aux_d) + + np.testing.assert_allclose(aux_d.get(), aux, atol=1e-06, rtol=5e-5, + err_msg="Numpy aux is \n%s, \nbut gpu aux is \n %s, \n " % (repr(aux), repr(aux_d.get()))) + + def test_farfield_propagator_backward_crop_pad_UNITY(self): + # setup + SH = (2,16,16) + aux = np.zeros((SH), dtype=COMPLEX_TYPE) + aux[:,5:11,5:11] = 1. + 2j + aux_d = gpuarray.to_gpu(aux) + geo = self.set_up_farfield(SH[1:]) + geo = self.set_up_farfield(SH[1:], resolution=0.5*geo.resolution) + + # test + aux = geo.propagator.bw(aux) + PropK = PropagationKernel(aux_d, geo.propagator, queue_thread=self.stream) + PropK.allocate() + PropK.bw(aux_d, aux_d) + + np.testing.assert_allclose(aux_d.get(), aux, atol=1e-06, rtol=5e-5, + err_msg="Numpy aux is \n%s, \nbut gpu aux is \n %s, \n " % (repr(aux), repr(aux_d.get()))) + + def test_nearfield_propagator_forward_UNITY(self): + # setup + SH = (2,16,16) + aux = np.zeros((SH), dtype=COMPLEX_TYPE) + aux[:,5:11,5:11] = 1. + 2j + aux_d = gpuarray.to_gpu(aux) + geo = self.set_up_nearfield(SH[1:]) + + # test + aux = geo.propagator.fw(aux) + PropK = PropagationKernel(aux_d, geo.propagator, queue_thread=self.stream) + PropK.allocate() + PropK.fw(aux_d, aux_d) + + np.testing.assert_allclose(aux_d.get(), aux, atol=1e-06, rtol=5e-5, + err_msg="Numpy aux is \n%s, \nbut gpu aux is \n %s, \n " % (repr(aux), repr(aux_d.get()))) + + def test_nearfield_propagator_backward_UNITY(self): + # setup + SH = (2,16,16) + aux = np.zeros((SH), dtype=COMPLEX_TYPE) + aux[:,5:11,5:11] = 1. + 2j + aux_d = gpuarray.to_gpu(aux) + geo = self.set_up_nearfield(SH[1:]) + + # test + aux = geo.propagator.bw(aux) + PropK = PropagationKernel(aux_d, geo.propagator, queue_thread=self.stream) + PropK.allocate() + PropK.bw(aux_d, aux_d) + + np.testing.assert_allclose(aux_d.get(), aux, atol=1e-06, rtol=5e-5, + err_msg="Numpy aux is \n%s, \nbut gpu aux is \n %s, \n " % (repr(aux), repr(aux_d.get()))) \ No newline at end of file diff --git a/test/accelerate_tests/ocl_pyopencl_tests/__init__.py b/test/accelerate_tests/ocl_pyopencl_tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test/accelerate_tests/ocl_pyopencl_tests/ocl_kernels_test.py b/test/accelerate_tests/ocl_pyopencl_tests/ocl_kernels_test.py new file mode 100644 index 000000000..8dbeeeb3b --- /dev/null +++ b/test/accelerate_tests/ocl_pyopencl_tests/ocl_kernels_test.py @@ -0,0 +1,780 @@ +''' + + +''' + +import unittest +import numpy as np + +try: + import pyopencl as pocl + from pyopencl import array as cla + from ptypy.accelerate.ocl.ocl_kernels import AuxiliaryWaveKernel, FourierUpdateKernel + # from ptypy.accelerate.ocl.npy_kernels_for_block import AuxiliaryWaveKernel + from ptypy.accelerate.ocl import get_ocl_queue + have_ocl = True +except ImportError: + have_ocl = False + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +@unittest.skipIf(not have_ocl, "no PyOpenCL or GPU drivers available") +class AuxiliaryWaveKernelTest(unittest.TestCase): + + def setUp(self): + import sys + np.set_printoptions(threshold=sys.maxsize, linewidth=np.inf) + self.queue = get_ocl_queue() + + def tearDown(self): + np.set_printoptions() + del self.queue + + def test_init(self): + attrs = [] + + AWK = AuxiliaryWaveKernel(self.queue) + self.queue.finish() + for attr in attrs: + self.assertTrue(hasattr(AWK, attr), msg="AuxiliaryWaveKernel does not have attribute: %s" % attr) + + np.testing.assert_equal(AWK.kernels, + ['build_aux', 'build_exit'], + err_msg='AuxiliaryWaveKernel does not have the correct functions registered.') + + def _configure(self): + B = 4 # frame size y + C = 4 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 2 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + pr_npy = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + pr_npy[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + ob_npy = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + ob_npy[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + ex_npy = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + ex_npy[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(Y.flat, X.flat): + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + exit_idx += 1 + mode_idx += 1 + position_idx += 1 + + return pr_npy, ob_npy, ex_npy, addr + + def test_build_aux_unity(self): + ''' + test + ''' + pr_npy, ob_npy, ex_npy, addr = self._configure() + aux_npy = np.zeros_like(ex_npy) + from ptypy.accelerate.ocl.npy_kernels_for_block import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + AWK = AuxiliaryWaveKernel(self.queue) + AWK.ocl_wg_size = None # (1, 3, 3) #None + alpha = 1.0 + + ob_dev = cla.to_device(self.queue, ob_npy) + pr_dev = cla.to_device(self.queue, pr_npy) + addr_dev = cla.to_device(self.queue, addr) + aux_dev = cla.to_device(self.queue, aux_npy) + ex_dev = cla.to_device(self.queue, ex_npy) + self.queue.finish() + AWK.build_aux(aux_dev, addr_dev, ob_dev, pr_dev, ex_dev, alpha) + nAWK.build_aux(aux_npy, addr, ob_npy, pr_npy, ex_npy, alpha) + d = aux_dev.get() + np.testing.assert_array_equal(aux_npy, aux_dev.get(), + err_msg="The gpu auxiliary_wave does not look the same as the numpy version") + + def test_build_aux_capped_unity(self): + ''' + test + ''' + pr_npy, ob_npy, ex_npy, addr = self._configure() + aux_npy = np.zeros_like(ex_npy) + # now use only a part of the stacks + sh = addr.shape + addr = addr[:sh[0] // 2, ...] + ex_npy = ex_npy[:sh[0] // 2 * sh[1], ...] + from ptypy.accelerate.ocl.npy_kernels_for_block import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + AWK = AuxiliaryWaveKernel(self.queue) + AWK.ocl_wg_size = None # (1, 3, 3) #None + alpha = 1.0 + + ob_dev = cla.to_device(self.queue, ob_npy) + pr_dev = cla.to_device(self.queue, pr_npy) + addr_dev = cla.to_device(self.queue, addr) + aux_dev = cla.to_device(self.queue, aux_npy) + ex_dev = cla.to_device(self.queue, ex_npy) + self.queue.finish() + AWK.build_aux(aux_dev, addr_dev, ob_dev, pr_dev, ex_dev, alpha) + nAWK.build_aux(aux_npy, addr, ob_npy, pr_npy, ex_npy, alpha) + d = aux_dev.get() + np.testing.assert_array_equal(aux_npy, aux_dev.get(), + err_msg="The gpu auxiliary_wave does not look the same as the numpy version") + + def test_build_exit_unity(self): + ''' + test + ''' + pr_npy, ob_npy, ex_npy, addr = self._configure() + aux_npy = np.zeros_like(ex_npy) + from ptypy.accelerate.ocl.npy_kernels_for_block import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + AWK = AuxiliaryWaveKernel(self.queue) + AWK.ocl_wg_size = None # (1, 3, 3) #None + + ob_dev = cla.to_device(self.queue, ob_npy) + pr_dev = cla.to_device(self.queue, pr_npy) + addr_dev = cla.to_device(self.queue, addr) + aux_dev = cla.to_device(self.queue, aux_npy) + ex_dev = cla.to_device(self.queue, ex_npy) + self.queue.finish() + AWK.build_exit(aux_dev, addr_dev, ob_dev, pr_dev, ex_dev) + nAWK.build_exit(aux_npy, addr, ob_npy, pr_npy, ex_npy) + np.testing.assert_array_equal(aux_npy, aux_dev.get(), + err_msg="The gpu auxiliary_wave does not look the same as the numpy version") + + def test_build_exit_capped_unity(self): + ''' + test + ''' + pr_npy, ob_npy, ex_npy, addr = self._configure() + aux_npy = np.zeros_like(ex_npy) + # now use only a part of the stacks + sh = addr.shape + addr = addr[:sh[0] // 2, ...] + ex_npy = ex_npy[:sh[0] // 2 * sh[1], ...] + from ptypy.accelerate.ocl.npy_kernels_for_block import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + AWK = AuxiliaryWaveKernel(self.queue) + AWK.ocl_wg_size = None # (1, 3, 3) #None + + ob_dev = cla.to_device(self.queue, ob_npy) + pr_dev = cla.to_device(self.queue, pr_npy) + addr_dev = cla.to_device(self.queue, addr) + aux_dev = cla.to_device(self.queue, aux_npy) + ex_dev = cla.to_device(self.queue, ex_npy) + self.queue.finish() + AWK.build_exit(aux_dev, addr_dev, ob_dev, pr_dev, ex_dev) + nAWK.build_exit(aux_npy, addr, ob_npy, pr_npy, ex_npy) + np.testing.assert_array_equal(aux_npy, aux_dev.get(), + err_msg="The gpu auxiliary_wave does not look the same as the numpy version") + +@unittest.skipIf(not have_ocl, "no PyOpenCL or GPU drivers available") +class FourierUpdateKernelTest(unittest.TestCase): + + def setUp(self): + import sys + np.set_printoptions(threshold=sys.maxsize, linewidth=np.inf) + self.queue = get_ocl_queue() + + def tearDown(self): + np.set_printoptions() + del self.queue + + def test_init(self): + attrs = [] + aux = np.zeros((16, 3, 3), dtype=COMPLEX_TYPE) + nmodes = 4 + FUK = FourierUpdateKernel(aux, nmodes, self.queue) + self.queue.finish() + for attr in attrs: + self.assertTrue(hasattr(FUK, attr), msg="AuxiliaryWaveKernel does not have attribute: %s" % attr) + + def test_all_capped_unity(self): + ''' + test + ''' + nmodes = 2 + # pr_npy, ob_npy, ex_npy, addr_npy = self._configure() + addr_npy = np.zeros((4, nmodes, 5, 3), dtype=INT_TYPE) + shape = (4, 3, 3) + L, M, N = shape + fshape = shape + shape = (nmodes * L, M, N) + + X, Y, Z = np.indices(shape) + aux_npy = (1j*Z+X+Z).astype(COMPLEX_TYPE) * 200 + mag_npy = np.indices(fshape).sum(0).astype(FLOAT_TYPE) * 200 ** 2 * nmodes + ma_npy = (mag_npy > 10).astype(FLOAT_TYPE) + err_fourier_npy = np.zeros((L,), dtype=FLOAT_TYPE) + mask_sum_npy = ma_npy.sum(-1).sum(-1) + + from ptypy.accelerate.ocl.npy_kernels_for_block import FourierUpdateKernel as nFourierUpdateKernel + nFUK = nFourierUpdateKernel(aux_npy, nmodes) + FUK = FourierUpdateKernel(aux_npy, nmodes, self.queue) + FUK.ocl_wg_size = None # (1, 3, 3) #None + + FUK.allocate() + nFUK.allocate() + self.queue.finish() + + # now use only a part of the stacks + sh = addr_npy.shape + mag_npy = mag_npy[:sh[0] // 2, ...] + ma_npy = ma_npy[:sh[0] // 2, ...] + addr_npy = addr_npy[:sh[0] // 2, ...] + mask_sum_npy = mask_sum_npy[:sh[0] // 2, ...] + err_fourier_npy = err_fourier_npy[:sh[0] // 2, ...] + + # copy + mag_dev = cla.to_device(self.queue, mag_npy) + ma_dev = cla.to_device(self.queue, ma_npy) + aux_dev = cla.to_device(self.queue, aux_npy) + addr_dev = cla.to_device(self.queue, addr_npy) + mask_sum_dev = cla.to_device(self.queue, mask_sum_npy) + err_fourier_dev = cla.to_device(self.queue, err_fourier_npy) + + self.queue.finish() + FUK.fourier_error(aux_dev, addr_dev, mag_dev, ma_dev, mask_sum_dev) + FUK.error_reduce(addr_dev, err_fourier_dev) + FUK.fmag_all_update(aux_dev, addr_dev, mag_dev, ma_dev, err_fourier_dev, pbound=0.5) + nFUK.fourier_error(aux_npy, addr_npy, mag_npy, ma_npy, mask_sum_npy) + nFUK.error_reduce(addr_npy, err_fourier_npy) + nFUK.fmag_all_update(aux_npy, addr_npy, mag_npy, ma_npy, err_fourier_npy, pbound=0.5) + np.testing.assert_array_almost_equal_nulp(nFUK.npy.fdev, FUK.npy.fdev.get()) + # err_msg="The gpu fdev differs more than single precision allows.") + np.testing.assert_array_almost_equal_nulp(nFUK.npy.ferr, FUK.npy.ferr.get()) + # err_msg="The gpu ferr differs more than single precision allows.") + np.testing.assert_array_almost_equal_nulp(aux_npy, aux_dev.get(), 80) #, + # err_msg="The gpu auxiliary_wave differs more than single precision allows.") + + """ + def test_build_aux_same_as_exit_REGRESSION(self): + ''' + setup + ''' + B = 3 # frame size y + C = 3 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 2 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + ex_npy = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + ex_npy[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y):# + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + auxiliary_wave = np.zeros_like(ex_npy) + + AWK = AuxiliaryWaveKernel() + alpha_set = 1.0 + AWK.configure(object_array, addr, alpha=alpha_set) + + object_array_dev = gpuarray.to_gpu(object_array) + probe_dev = gpuarray.to_gpu(probe) + addr_dev = gpuarray.to_gpu(addr) + auxiliary_wave_dev = gpuarray.to_gpu(auxiliary_wave) + ex_npy_dev = gpuarray.to_gpu(ex_npy) + + AWK.build_aux(auxiliary_wave_dev, object_array_dev, probe_dev, ex_npy_dev, addr_dev) + + + expected_auxiliary_wave = np.array([[[-1. + 3.j, -1. + 3.j, -1. + 3.j], + [-1. + 3.j, -1. + 3.j, -1. + 3.j], + [-1. + 3.j, -1. + 3.j, -1. + 3.j]], + [[-2.+14.j, -2.+14.j, -2.+14.j], + [-2.+14.j, -2.+14.j, -2.+14.j], + [-2.+14.j, -2.+14.j, -2.+14.j]], + [[-3. + 5.j, -3. + 5.j, -3. + 5.j], + [-3. + 5.j, -3. + 5.j, -3. + 5.j], + [-3. + 5.j, -3. + 5.j, -3. + 5.j]], + [[-4.+28.j, -4.+28.j, -4.+28.j], + [-4.+28.j, -4.+28.j, -4.+28.j], + [-4.+28.j, -4.+28.j, -4.+28.j]], + [[-5. - 1.j, -5. - 1.j, -5. - 1.j], + [-5. - 1.j, -5. - 1.j, -5. - 1.j], + [-5. - 1.j, -5. - 1.j, -5. - 1.j]], + [[-6.+10.j, -6.+10.j, -6.+10.j], + [-6.+10.j, -6.+10.j, -6.+10.j], + [-6.+10.j, -6.+10.j, -6.+10.j]], + [[-7. + 1.j, -7. + 1.j, -7. + 1.j], + [-7. + 1.j, -7. + 1.j, -7. + 1.j], + [-7. + 1.j, -7. + 1.j, -7. + 1.j]], + [[-8.+24.j, -8.+24.j, -8.+24.j], + [-8.+24.j, -8.+24.j, -8.+24.j], + [-8.+24.j, -8.+24.j, -8.+24.j]], + [[-9. - 5.j, -9. - 5.j, -9. - 5.j], + [-9. - 5.j, -9. - 5.j, -9. - 5.j], + [-9. - 5.j, -9. - 5.j, -9. - 5.j]], + [[-10. + 6.j, -10. + 6.j, -10. + 6.j], + [-10. + 6.j, -10. + 6.j, -10. + 6.j], + [-10. + 6.j, -10. + 6.j, -10. + 6.j]], + [[-11. - 3.j, -11. - 3.j, -11. - 3.j], + [-11. - 3.j, -11. - 3.j, -11. - 3.j], + [-11. - 3.j, -11. - 3.j, -11. - 3.j]], + [[-12.+20.j, -12.+20.j, -12.+20.j], + [-12.+20.j, -12.+20.j, -12.+20.j], + [-12.+20.j, -12.+20.j, -12.+20.j]], + [[-13. - 9.j, -13. - 9.j, -13. - 9.j], + [-13. - 9.j, -13. - 9.j, -13. - 9.j], + [-13. - 9.j, -13. - 9.j, -13. - 9.j]], + [[-14. + 2.j, -14. + 2.j, -14. + 2.j], + [-14. + 2.j, -14. + 2.j, -14. + 2.j], + [-14. + 2.j, -14. + 2.j, -14. + 2.j]], + [[-15. - 7.j, -15. - 7.j, -15. - 7.j], + [-15. - 7.j, -15. - 7.j, -15. - 7.j], + [-15. - 7.j, -15. - 7.j, -15. - 7.j]], + [[-16.+16.j, -16.+16.j, -16.+16.j], + [-16.+16.j, -16.+16.j, -16.+16.j], + [-16.+16.j, -16.+16.j, -16.+16.j]]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(expected_auxiliary_wave, auxiliary_wave_dev.get(), + err_msg="The auxiliary_wave has not been updated as expected") + + object_array_dev.gpudata.free() + auxiliary_wave_dev.gpudata.free() + probe_dev.gpudata.free() + ex_npy_dev.gpudata.free() + addr_dev.gpudata.free() + + def test_build_aux_same_as_exit_UNITY(self): + ''' + setup + ''' + B = 3 # frame size y + C = 3 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 2 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + ex_npy = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + ex_npy[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y):# + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + auxiliary_wave = np.zeros_like(ex_npy) + from ptypy.accelerate.base.auxiliary_wave_kernel import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + AWK = AuxiliaryWaveKernel() + alpha_set = 1.0 + AWK.configure(object_array, addr, alpha=alpha_set) + nAWK.configure(object_array, addr, alpha=alpha_set) + + object_array_dev = gpuarray.to_gpu(object_array) + probe_dev = gpuarray.to_gpu(probe) + addr_dev = gpuarray.to_gpu(addr) + auxiliary_wave_dev = gpuarray.to_gpu(auxiliary_wave) + ex_npy_dev = gpuarray.to_gpu(ex_npy) + + AWK.build_aux(auxiliary_wave_dev, object_array_dev, probe_dev, ex_npy_dev, addr_dev) + nAWK.build_aux(auxiliary_wave, object_array, probe, ex_npy, addr) + + + np.testing.assert_array_equal(auxiliary_wave, auxiliary_wave_dev.get(), + err_msg="The gpu auxiliary_wave does not look the same as the numpy version") + + object_array_dev.gpudata.free() + auxiliary_wave_dev.gpudata.free() + probe_dev.gpudata.free() + ex_npy_dev.gpudata.free() + addr_dev.gpudata.free() + + def test_build_exit_aux_same_as_exit_REGRESSION(self): + ''' + setup + ''' + B = 3 # frame size y + C = 3 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 2 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + ex_npy = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + ex_npy[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y):# + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + auxiliary_wave = np.zeros_like(ex_npy) + + object_array_dev = gpuarray.to_gpu(object_array) + probe_dev = gpuarray.to_gpu(probe) + addr_dev = gpuarray.to_gpu(addr) + auxiliary_wave_dev = gpuarray.to_gpu(auxiliary_wave) + ex_npy_dev = gpuarray.to_gpu(ex_npy) + AWK = AuxiliaryWaveKernel() + + alpha_set = 1.0 + AWK.configure(object_array, addr, alpha=alpha_set) + + AWK.build_exit(auxiliary_wave_dev, object_array_dev, probe_dev, ex_npy_dev, addr_dev) + # + # print("auxiliary_wave after") + # print(repr(auxiliary_wave_dev.get())) + # + # print("ex_npy after") + # print(repr(ex_npy)) + + expected_auxiliary_wave = np.array([[[0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j]], + [[0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j]], + [[0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j]], + [[0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j]], + [[0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j]], + [[0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j]], + [[0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j]], + [[0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j]], + [[0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j]], + [[0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j]], + [[0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j]], + [[0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j]], + [[0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j], + [0. - 2.j, 0. - 2.j, 0. - 2.j]], + [[0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j], + [0. - 8.j, 0. - 8.j, 0. - 8.j]], + [[0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j], + [0. - 4.j, 0. - 4.j, 0. - 4.j]], + [[0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j], + [0.-16.j, 0.-16.j, 0.-16.j]]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(expected_auxiliary_wave, auxiliary_wave_dev.get(), + err_msg="The auxiliary_wave has not been updated as expected") + + expected_ex_npy = np.array([[[1. - 1.j, 1. - 1.j, 1. - 1.j], + [1. - 1.j, 1. - 1.j, 1. - 1.j], + [1. - 1.j, 1. - 1.j, 1. - 1.j]], + [[2. - 6.j, 2. - 6.j, 2. - 6.j], + [2. - 6.j, 2. - 6.j, 2. - 6.j], + [2. - 6.j, 2. - 6.j, 2. - 6.j]], + [[3. - 1.j, 3. - 1.j, 3. - 1.j], + [3. - 1.j, 3. - 1.j, 3. - 1.j], + [3. - 1.j, 3. - 1.j, 3. - 1.j]], + [[4. - 12.j, 4. - 12.j, 4. - 12.j], + [4. - 12.j, 4. - 12.j, 4. - 12.j], + [4. - 12.j, 4. - 12.j, 4. - 12.j]], + [[5. + 3.j, 5. + 3.j, 5. + 3.j], + [5. + 3.j, 5. + 3.j, 5. + 3.j], + [5. + 3.j, 5. + 3.j, 5. + 3.j]], + [[6. - 2.j, 6. - 2.j, 6. - 2.j], + [6. - 2.j, 6. - 2.j, 6. - 2.j], + [6. - 2.j, 6. - 2.j, 6. - 2.j]], + [[7. + 3.j, 7. + 3.j, 7. + 3.j], + [7. + 3.j, 7. + 3.j, 7. + 3.j], + [7. + 3.j, 7. + 3.j, 7. + 3.j]], + [[8. - 8.j, 8. - 8.j, 8. - 8.j], + [8. - 8.j, 8. - 8.j, 8. - 8.j], + [8. - 8.j, 8. - 8.j, 8. - 8.j]], + [[9. + 7.j, 9. + 7.j, 9. + 7.j], + [9. + 7.j, 9. + 7.j, 9. + 7.j], + [9. + 7.j, 9. + 7.j, 9. + 7.j]], + [[10. + 2.j, 10. + 2.j, 10. + 2.j], + [10. + 2.j, 10. + 2.j, 10. + 2.j], + [10. + 2.j, 10. + 2.j, 10. + 2.j]], + [[11. + 7.j, 11. + 7.j, 11. + 7.j], + [11. + 7.j, 11. + 7.j, 11. + 7.j], + [11. + 7.j, 11. + 7.j, 11. + 7.j]], + [[12. - 4.j, 12. - 4.j, 12. - 4.j], + [12. - 4.j, 12. - 4.j, 12. - 4.j], + [12. - 4.j, 12. - 4.j, 12. - 4.j]], + [[13. + 11.j, 13. + 11.j, 13. + 11.j], + [13. + 11.j, 13. + 11.j, 13. + 11.j], + [13. + 11.j, 13. + 11.j, 13. + 11.j]], + [[14. + 6.j, 14. + 6.j, 14. + 6.j], + [14. + 6.j, 14. + 6.j, 14. + 6.j], + [14. + 6.j, 14. + 6.j, 14. + 6.j]], + [[15. + 11.j, 15. + 11.j, 15. + 11.j], + [15. + 11.j, 15. + 11.j, 15. + 11.j], + [15. + 11.j, 15. + 11.j, 15. + 11.j]], + [[16. + 0.j, 16. + 0.j, 16. + 0.j], + [16. + 0.j, 16. + 0.j, 16. + 0.j], + [16. + 0.j, 16. + 0.j, 16. + 0.j]]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(expected_ex_npy, ex_npy_dev.get(), + err_msg="The ex_npy has not been updated as expected") + + object_array_dev.gpudata.free() + auxiliary_wave_dev.gpudata.free() + probe_dev.gpudata.free() + ex_npy_dev.gpudata.free() + addr_dev.gpudata.free() + + def test_build_exit_aux_same_as_exit_UNITY(self): + ''' + setup + ''' + B = 3 # frame size y + C = 3 # frame size x + + D = 2 # number of probe modes + E = B # probe size y + F = C # probe size x + + npts_greater_than = 2 # how many points bigger than the probe the object is. + G = 2 # number of object modes + H = B + npts_greater_than # object size y + I = C + npts_greater_than # object size x + + scan_pts = 2 # one dimensional scan point number + + total_number_scan_positions = scan_pts ** 2 + total_number_modes = G * D + A = total_number_scan_positions * total_number_modes # this is a 16 point scan pattern (4x4 grid) over all the modes + + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + + object_array = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + object_array[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + + ex_npy = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + ex_npy[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((total_number_scan_positions)) + Y = Y.reshape((total_number_scan_positions)) + + addr = np.zeros((total_number_scan_positions, total_number_modes, 5, 3), dtype=INT_TYPE) + + exit_idx = 0 + position_idx = 0 + for xpos, ypos in zip(X, Y):# + mode_idx = 0 + for pr_mode in range(D): + for ob_mode in range(G): + addr[position_idx, mode_idx] = np.array([[pr_mode, 0, 0], + [ob_mode, ypos, xpos], + [exit_idx, 0, 0], + [0, 0, 0], + [0, 0, 0]], dtype=INT_TYPE) + mode_idx += 1 + exit_idx += 1 + position_idx += 1 + + ''' + test + ''' + auxiliary_wave = np.zeros_like(ex_npy) + + object_array_dev = gpuarray.to_gpu(object_array) + probe_dev = gpuarray.to_gpu(probe) + addr_dev = gpuarray.to_gpu(addr) + auxiliary_wave_dev = gpuarray.to_gpu(auxiliary_wave) + ex_npy_dev = gpuarray.to_gpu(ex_npy) + + from ptypy.accelerate.base.auxiliary_wave_kernel import AuxiliaryWaveKernel as npAuxiliaryWaveKernel + nAWK = npAuxiliaryWaveKernel() + + AWK = AuxiliaryWaveKernel() + + alpha_set = 1.0 + + AWK.configure(object_array, addr, alpha=alpha_set) + nAWK.configure(object_array, addr, alpha=alpha_set) + + AWK.build_exit(auxiliary_wave_dev, object_array_dev, probe_dev, ex_npy_dev, addr_dev) + nAWK.build_exit(auxiliary_wave, object_array, probe, ex_npy, addr) + + np.testing.assert_array_equal(auxiliary_wave, auxiliary_wave_dev.get(), + err_msg="The gpu auxiliary_wave does not look the same as the numpy version") + + np.testing.assert_array_equal(ex_npy, ex_npy_dev.get(), + err_msg="The gpu ex_npy does not look the same as the numpy version") + + object_array_dev.gpudata.free() + auxiliary_wave_dev.gpudata.free() + probe_dev.gpudata.free() + ex_npy_dev.gpudata.free() + addr_dev.gpudata.free() + """ + + +if __name__ == '__main__': + unittest.main() diff --git a/test/archive_tests/__init__.py b/test/archive_tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test/archive_tests/array_based_tests/__init__.py b/test/archive_tests/array_based_tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test/archive_tests/array_based_tests/constraints_regression_test.py b/test/archive_tests/array_based_tests/constraints_regression_test.py new file mode 100644 index 000000000..dcaa5e3a4 --- /dev/null +++ b/test/archive_tests/array_based_tests/constraints_regression_test.py @@ -0,0 +1,977 @@ +''' +The tests for the constraints +''' + + +import unittest +import numpy as np +from copy import deepcopy +from ptypy.accelerate.array_based import constraints as con, FLOAT_TYPE, COMPLEX_TYPE + +class ConstraintsRegressionTest(unittest.TestCase): + ''' + a module to holds the constraints + ''' + + def test_renormalise_fourier_magnitudes_pbound_none(self): + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 3 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + pbound = None # the power bound + + fmag = np.empty(shape=(N, A, B), dtype=FLOAT_TYPE)# the measured magnitudes NxAxB + mask = np.empty(shape=(N, A, B), dtype=np.int32)# the masks for the measured magnitudes either 1xAxB or NxAxB + err_fmag = np.empty(shape=(N, ), dtype=FLOAT_TYPE)# deviation from the diffraction pattern for each af + f = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # the current iterant + af = np.empty(shape=(M, A, B), dtype=FLOAT_TYPE)# the absolute magnitudes of f + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32)# the address book + + ## now lets fill them with some values, these are junk and not supposed to be indicative of real values. + + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + err_fmag[:] = np.ones((N,)) # this shouldn't be used a pbound is None + + f_fill = np.array([ix + 1j*(ix**2) for ix in range(np.prod(f.shape))]).reshape((M, A, B)) + f[:] = f_fill + + af[:] = np.sqrt((f*f.conj()).real) + pa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + oa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)]*num_probe_modes*num_object_modes) + ma = np.array([np.array([ix, 0, 0]) for ix in range(N)]*num_probe_modes*num_object_modes) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + expected_out = np.array([[[0.0 + 0.0j, 1.0 + 1.0j, 2.0 + 4.0j, 3.0 + 9.0j], + [0.97014252 + 3.88057009j, 0.98058065 + 4.90290327e+00j, 0.98639394 + 5.91836367e+00j, 0.98994949 + 6.92964646e+00j]], + [[0.99227787 + 7.93822300j, 0.99388373 + 8.94495358j, 0.99503719 + 9.95037188j, 0.99589322 + 10.9548254j], + [0.99654579 + 1.19585495e+01j, 0.99705446 + 1.29617079e+01j, 0.99745872 + 1.39644221e+01j, 0.99778514 + 1.49667770e+01j]], + [[16.00000000 + 2.56000000e+02j, 17.00000000 + 2.89000000e+02j, 18.00000000 + 3.24000000e+02j,19.00000000 + 3.61000000e+02j], + [0.99875232 + 1.99750464e+01j, 0.99886812 + 2.09762305e+01j, 0.99896851 + 2.19773073e+01j, 0.99905617 + 2.29782920e+01j]], + [[24.00000000 + 5.76000000e+02j, 25.00000000 + 6.25000000e+02j, 26.00000000 + 6.76000000e+02j, 27.00000000 + 7.29000000e+02j], + [6.79099767 + 1.90147935e+02j, 5.68736780 + 1.64933666e+02j, 4.93196972 + 1.47959092e+02j, 4.38406204 + 1.35905923e+02j]], + [[3.96911150 + 1.27011568e+02j, 3.64424035 + 1.20259932e+02j, 3.38312644 + 1.15026299e+02j, 3.16875114 + 1.10906290e+02j], + [2.98963737 + 1.07626945e+02j, 2.83777037 + 1.04997504e+02j, 2.70738796 + 1.02880743e+02j, 2.59424135 + 1.01175413e+02j]], + [[40.00000000 + 1.60000000e+03j, 41.00000000 + 1.68100000e+03j, 42.00000000 + 1.76400000e+03j, 43.00000000 + 1.84900000e+03j], + [2.19725511 + 9.66792247e+01j, 2.14043168 + 9.63194257e+01j, 2.08875234 + 9.60826078e+01j, 2.04154957 + 9.59528299e+01j]]], dtype=COMPLEX_TYPE) + + + out = con.renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + np.testing.assert_allclose(out, expected_out, rtol=1e-6) + + + def test_renormalise_fourier_magnitudes_pbound_not_none(self): + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 3 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + pbound = 5.0 # the power bound + + fmag = np.empty(shape=(N, A, B), dtype=FLOAT_TYPE)# the measured magnitudes NxAxB + mask = np.empty(shape=(N, A, B), dtype=np.int32)# the masks for the measured magnitudes either 1xAxB or NxAxB + err_fmag = np.empty(shape=(N, ), dtype=FLOAT_TYPE)# deviation from the diffraction pattern for each af + f = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # the current iterant + af = np.empty(shape=(M, A, B), dtype=FLOAT_TYPE)# the absolute magnitudes of f + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32)# the address book + + ## now lets fill them with some values, these are junk and not supposed to be indicative of real values. + + fmag_fill = np.arange(np.prod(fmag.shape)).reshape(fmag.shape).astype(fmag.dtype) + fmag[:] = fmag_fill + + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + err_fmag_fill = np.ones((N,))*(pbound+0.1) # should be greater than the pbound + err_fmag_fill[N//2] = 4.0 # this one should be less than the pbound and not update + err_fmag[:] = err_fmag_fill # this shouldn't be used a pbound is None + + f_fill = np.array([ix + 1j*(ix**2) for ix in range(np.prod(f.shape))]).reshape((M, A, B)) + f[:] = f_fill + + af[:] = np.sqrt((f*f.conj()).real) + pa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + oa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)]*num_probe_modes*num_object_modes) + ma = np.array([np.array([ix, 0, 0]) for ix in range(N)]*num_probe_modes*num_object_modes) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + expected_out = np.array([[[0.0 +0.0j, 1.0 +1.0j, 2.0 +4.0j, 3.0 +9.0j], + [3.97014832 + 1.58805933e+01j, 4.96039867 +2.48019943e+01j, 5.95060349 +3.57036209e+01j, 6.94078636 +4.85855026e+01j]], + [[0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j], + [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j]], + [[16.0 + 2.56e+02j, 17.0 + 2.89e+02j, 18.0 + 3.24e+02j, 19.0 + 3.61e+02j], + [19.81278992 + 3.96255798e+02j, 20.80293846 +4.36861725e+02j, 21.79308891 + 4.79447937e+02j, 22.78323746 + 5.24014465e+02j]], + [[ 24.0 + 5.76e+02j, 25.0 +6.25e+02j, 26.0 +6.76e+02j, 27.0 + 7.29e+02j], + [27.79103851 +7.78149109e+02j, 28.77031326 +8.34339111e+02j, 29.75301552 + 8.92590515e+02j, 30.73776817 + 9.52870789e+02j]], + [[0.0 + 0.0j, 0.00 + 0.00e+00j, 0.00 +0.00e+00j, 0.00 + 0.00e+00j], + [0.00 +0.0j, 0.00 + 0.00j, 0.00 + 0.00j, 0.00 + 0.00j]], + [[40.00 +1.60e+03j, 41.00 + 1.681e+03j, 42.0 +1.764e+03j, 43.0 + 1.849e+03j], + [43.58813858 + 1.91787805e+03j, 44.57772446 + 2.00599768e+03j, 45.56736755 +2.09609888e+03j, 46.55705261 + 2.18818140e+03j]]], dtype=COMPLEX_TYPE) + + + out = con.renormalise_fourier_magnitudes(f, af, fmag, mask, err_fmag, addr_info, pbound) + np.testing.assert_allclose(out, expected_out) + + def test_get_difference_pbound_is_none(self): + alpha = 1.0 # feedback constant + pbound = 5.0 # the power bound + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 3 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + + backpropagated_solution = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE)# The current iterant backpropagated + probe_object = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE)# the probe multiplied by the object + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE)# deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32)# the address book + + # now fill it with stuff + + backpropagated_solution_fill = np.array([ix + 1j*(ix**2) for ix in range(np.prod(backpropagated_solution.shape))]).reshape((M, A, B)) + backpropagated_solution[:] = backpropagated_solution_fill + + probe_object_fill = np.array([ix + 1j*ix for ix in range(10, 10+np.prod(backpropagated_solution.shape), 1)]).reshape((M, A, B)) + probe_object[:] = probe_object_fill + + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array([ix**2 + 1j*ix for ix in range(20, 20+np.prod(backpropagated_solution.shape), 1)]).reshape((M, A, B)) + exit_wave[:] = exit_wave_fill + + pa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + oa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)]*num_probe_modes*num_object_modes) + ma = np.zeros((M, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + expected_out = np.array([[[-390.-10.j, -430.-10.j, -472.-10.j, -516.-10.j], + [-562.-10.j, -610.-10.j, -660.-10.j, -712.-10.j]], + [[-766.-10.j, -822.-10.j, -880.-10.j, -940.-10.j], + [-1002.-10.j, -1066.-10.j, -1132.-10.j, -1200.-10.j]], + [[-1270.-10.j, -1342.-10.j, -1416.-10.j, -1492.-10.j], + [-1570.-10.j, -1650.-10.j, -1732.-10.j, -1816.-10.j]], + [[-1902.-10.j, -1990.-10.j, -2080.-10.j, -2172.-10.j], + [-2266.-10.j, -2362.-10.j, -2460.-10.j, -2560.-10.j]], + [[-2662.-10.j, -2766.-10.j, -2872.-10.j, -2980.-10.j], + [-3090.-10.j, -3202.-10.j, -3316.-10.j, -3432.-10.j]], + [[-3550.-10.j, -3670.-10.j, -3792.-10.j, -3916.-10.j], + [-4042.-10.j, -4170.-10.j, -4300.-10.j, -4432.-10.j]]], dtype=COMPLEX_TYPE) + + out = con.get_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, probe_object) + np.testing.assert_allclose(expected_out, out) + + def test_get_difference_pbound_is_not_none(self): + alpha = 1.0 # feedback constant + pbound = 5.0 # the power bound + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 3 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + + backpropagated_solution = np.empty(shape=(M, A, B), + dtype=COMPLEX_TYPE) # The current iterant backpropagated + probe_object = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # the probe multiplied by the object + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32) # the address book + + # now fill it with stuff + + backpropagated_solution_fill = np.array( + [ix + 1j * (ix ** 2) for ix in range(np.prod(backpropagated_solution.shape))]).reshape((M, A, B)) + backpropagated_solution[:] = backpropagated_solution_fill + + probe_object_fill = np.array( + [ix + 1j * ix for ix in range(10, 10 + np.prod(backpropagated_solution.shape), 1)]).reshape((M, A, B)) + probe_object[:] = probe_object_fill + + err_fmag_fill = np.ones((N,))*(pbound+0.1) # should be higher than pbound + err_fmag_fill[N // 2] = 4.0# except for this one!! + err_fmag[:] = err_fmag_fill + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(backpropagated_solution.shape), 1)]).reshape( + (M, A, B)) + exit_wave[:] = exit_wave_fill + + pa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + oa = np.zeros((M, 3), dtype=np.int32) # not going to be used here + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * num_probe_modes * num_object_modes) + ma = np.zeros((M, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + expected_out = np.array([[[-10.0 -10.0j, -10.0 -10.0j, -10.0 -8.0j, -10.0 -4.0j], + [-10.0 + 2.0j, -10.0 +10.0j, -10.0 +20.0j, -10. +32.0j]], + [[-766.0 -10.0j, -822.0 -10.00j, -880.0 -10.0j, -940.0 -10.0j], + [-1002.0 -10.0j, -1066.0 -10.0j, -1132.0 -10.0j, -1200.0 -10.0j]], + [[-10.0 +230.0j, -10.0 +262.0j, -10.0 +296.0j, -10.0 +332.0j], + [-10.0 +370.0j, -10.0 +410.0j, -10.0 +452.0j, -10.0 +496.0j]], + [[-10.0 +542.0j, -10.0 +590.0j, -10.0 +640.0j, -10.0 +692.0j], + [-10.0 +746.0j, -10.0 +802.0j, -10.0 +860.0j, -10.0 +920.0j]], + [[-2662.0 -10.0j, -2766.0 -10.0j, -2872.0 -10.0j,-2980.0 -10.0j], + [-3090.0 -10.0j, -3202.0 -10.0j, -3316.0 -10.0j, -3432.0 -10.0j]], + [[-10.0 +1550.0j, -10.0 +1630.0j, -10.0 +1712.0j, -10.0 +1796.0j], + [-10.0 +1882.0j, -10.0 +1970.0j, -10.0 +2060.0j,-10.0 +2152.0j]]]) + + out = con.get_difference(addr_info, alpha, backpropagated_solution, err_fmag, exit_wave, pbound, + probe_object) + + np.testing.assert_allclose(expected_out, out) + + + def test_difference_map_fourier_constraint_pbound_is_none_with_realspace_error_and_LL_error(self): + + alpha = 1.0 # feedback constant + pbound = None # the power bound + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 4 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + npts_greater_than = int(np.sqrt(N)) # object is bigger than the probe by this amount + C = A + npts_greater_than + D = B + npts_greater_than + + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE)# deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32)# the address book + Idata = np.empty(shape=(N, A, B), dtype=FLOAT_TYPE)# the measured intensities NxAxB + mask = np.empty(shape=(N, A, B), dtype=np.int32)# the masks for the measured magnitudes either 1xAxB or NxAxB + probe = np.empty(shape=(num_probe_modes, A, B), dtype=COMPLEX_TYPE) # the probe function + obj = np.empty(shape=(num_object_modes, C, D), dtype=COMPLEX_TYPE) # the object function + prefilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + postfilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + + + # now fill it with stuff. Data won't ever look like this except in type and usage! + Idata_fill = np.arange(np.prod(Idata.shape)).reshape(Idata.shape).astype(Idata.dtype) + Idata[:] = Idata_fill + + obj_fill = np.array([ix + 1j*(ix**2) for ix in range(np.prod(obj.shape))]).reshape((num_object_modes, C, D)) + obj[:] = obj_fill + + probe_fill = np.array([ix + 1j*ix for ix in range(10, 10+np.prod(probe.shape), 1)]).reshape((num_probe_modes, A, B)) + probe[:] = probe_fill + + prefilter.fill(30.0 + 2.0j)# this would actually vary + postfilter.fill(20.0 + 3.0j)# this too + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array([ix**2 + 1j*ix for ix in range(20, 20+np.prod(exit_wave.shape), 1)]).reshape((M, A, B)) + exit_wave[:] = exit_wave_fill + + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + pa = np.zeros((M, 3), dtype=np.int32) + for idx in range(num_probe_modes): + if idx>0: + pa[::idx,0]=idx # multimodal could work like this, but this is not a concrete thing. + + + X, Y = np.meshgrid(range(npts_greater_than), range(npts_greater_than)) # assume square scan grid. Again, not always true. + oa = np.zeros((M, 3), dtype=np.int32) + oa[:N, 1] = X.ravel() + oa[N:, 1] = X.ravel() + oa[:N, 2] = Y.ravel() + oa[N:, 2] = Y.ravel() + for idx in range(num_object_modes): + if idx>0: + oa[::idx,0]=idx # multimodal could work like this, but this is not a concrete thing (less likely for object) + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)]*num_probe_modes*num_object_modes) + ma = np.zeros((M, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + expected_out = np.array([[6.07364329e+12, 8.87756439e+13, 9.12644403e+12, 1.39851186e+14], + [6.38221460e+23, 8.94021509e+24, 3.44468266e+23, 6.03329184e+24], + [3.88072739e+18, 2.67132771e+19, 9.15414239e+18,4.41441340e+19]], dtype=FLOAT_TYPE) + + expected_ew = np.array([[[-4.24456960e+08 +3.33502272e+08j, -5.54233664e+08 +4.81765952e+08j, -7.26160640e+08 +6.74398016e+08j, -9.44673984e+08 +9.15834816e+08j], + [-4.24455232e+08 +3.33500608e+08j, -5.54232768e+08 +4.81764832e+08j, -7.26159680e+08 +6.74396992e+08j, -9.44673792e+08 +9.15834752e+08j]], + [[-1.60761126e+09 +1.53736205e+09j, -1.97845542e+09 +1.92965094e+09j, -2.40919706e+09 +2.38405555e+09j, -2.90427264e+09 +2.90501248e+09j], + [-1.60760742e+09 +1.53735821e+09j, -1.97845261e+09 +1.92964813e+09j, -2.40919450e+09 +2.38405299e+09j, -2.90427085e+09 +2.90501120e+09j]], + [[-8.77013248e+08 +4.54775968e+08j, -1.05411565e+09 +6.40012672e+08j, -1.27632653e+09 +8.72576064e+08j, -1.54808115e+09 +1.15690163e+09j], + [-8.77010560e+08 +4.54773344e+08j, -1.05411462e+09 +6.40011584e+08j, -1.27632589e+09 +8.72575488e+08j, -1.54808205e+09 +1.15690304e+09j]], + [[-2.33229235e+09 +1.83610880e+09j, -2.75933594e+09 +2.27424461e+09j, -3.24923520e+09 +2.77745434e+09j, -3.80642586e+09 +3.35017344e+09j], + [-2.33228800e+09 +1.83610432e+09j, -2.75933338e+09 +2.27424154e+09j, -3.24923290e+09 +2.77745203e+09j, -3.80642509e+09 +3.35017293e+09j]], + [[-1.32365261e+09 +3.21670784e+08j, -1.47709235e+09 +4.69934400e+08j, -1.67268250e+09 +6.62566528e+08j, -1.91485875e+09 +9.04003328e+08j], + [-1.32365056e+09 +3.21669120e+08j, -1.47709133e+09 +4.69933312e+08j, -1.67268122e+09 +6.62565568e+08j, -1.91485837e+09 +9.04003328e+08j]], + [[-2.69611136e+09 +1.52553024e+09j, -3.09061837e+09 +1.91781939e+09j, -3.54502349e+09 +2.37222400e+09j, -4.06376115e+09 +2.89318067e+09j], + [-2.69610726e+09 +1.52552653e+09j, -3.09061555e+09 +1.91781658e+09j, -3.54502042e+09 +2.37222144e+09j, -4.06375987e+09 +2.89317965e+09j]], + [[-2.15481728e+09 +4.42944416e+08j, -2.35558246e+09 +6.28181120e+08j, -2.60145664e+09 +8.60744448e+08j, -2.89687424e+09 +1.14507034e+09j], + [-2.15481421e+09 +4.42941824e+08j, -2.35558118e+09 +6.28180096e+08j, -2.60145562e+09 +8.60743936e+08j, -2.89687475e+09 +1.14507149e+09j]], + [[-3.79940096e+09 +1.82427738e+09j, -4.25010765e+09 +2.26241280e+09j, -4.76367002e+09 +2.76562253e+09j, -5.34452326e+09 +3.33834163e+09j], + [-3.79939610e+09 +1.82427277e+09j, -4.25010458e+09 +2.26240998e+09j, -4.76366746e+09 +2.76562022e+09j, -5.34452275e+09 +3.33834138e+09j]]], dtype= COMPLEX_TYPE) + + out = con.difference_map_fourier_constraint(mask, Idata, obj, probe, exit_wave, addr_info, prefilter, postfilter, pbound=pbound, alpha=alpha, LL_error=True, do_realspace_error=True) + np.testing.assert_allclose(out, + expected_out, + err_msg="The returned errors are not consistent.") + + np.testing.assert_allclose(exit_wave, + expected_ew, + err_msg="The expected in-place update of the exit wave didn't work properly.") + + def test_difference_map_fourier_constraint_pbound_is_none_no_error(self): + + alpha = 1.0 # feedback constant + pbound = None # the power bound + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 4 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + npts_greater_than = int(np.sqrt(N)) # object is bigger than the probe by this amount + C = A + npts_greater_than + D = B + npts_greater_than + + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32) # the address book + Idata = np.empty(shape=(N, A, B), dtype=FLOAT_TYPE) # the measured intensities NxAxB + mask = np.empty(shape=(N, A, B), + dtype=np.int32) # the masks for the measured magnitudes either 1xAxB or NxAxB + probe = np.empty(shape=(num_probe_modes, A, B), dtype=COMPLEX_TYPE) # the probe function + obj = np.empty(shape=(num_object_modes, C, D), dtype=COMPLEX_TYPE) # the object function + prefilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + postfilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + + # now fill it with stuff. Data won't ever look like this except in type and usage! + Idata_fill = np.arange(np.prod(Idata.shape)).reshape(Idata.shape).astype(Idata.dtype) + Idata[:] = Idata_fill + + obj_fill = np.array([ix + 1j * (ix ** 2) for ix in range(np.prod(obj.shape))]).reshape( + (num_object_modes, C, D)) + obj[:] = obj_fill + + probe_fill = np.array([ix + 1j * ix for ix in range(10, 10 + np.prod(probe.shape), 1)]).reshape( + (num_probe_modes, A, B)) + probe[:] = probe_fill + + prefilter.fill(30.0 + 2.0j) # this would actually vary + postfilter.fill(20.0 + 3.0j) # this too + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(exit_wave.shape), 1)]).reshape((M, A, B)) + exit_wave[:] = exit_wave_fill + + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + pa = np.zeros((M, 3), dtype=np.int32) + for idx in range(num_probe_modes): + if idx > 0: + pa[::idx, 0] = idx # multimodal could work like this, but this is not a concrete thing. + + X, Y = np.meshgrid(range(npts_greater_than), + range(npts_greater_than)) # assume square scan grid. Again, not always true. + oa = np.zeros((M, 3), dtype=np.int32) + oa[:N, 1] = X.ravel() + oa[N:, 1] = X.ravel() + oa[:N, 2] = Y.ravel() + oa[N:, 2] = Y.ravel() + for idx in range(num_object_modes): + if idx > 0: + oa[::idx, + 0] = idx # multimodal could work like this, but this is not a concrete thing (less likely for object) + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * num_probe_modes * num_object_modes) + ma = np.zeros((M, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + expected_out = np.array([[6.07364329e+12, 8.87756439e+13, 9.12644403e+12, 1.39851186e+14], + [0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0]], + dtype=FLOAT_TYPE) + + expected_ew = np.array([[[-4.24456960e+08 + 3.33502272e+08j, -5.54233664e+08 + 4.81765952e+08j, + -7.26160640e+08 + 6.74398016e+08j, -9.44673984e+08 + 9.15834816e+08j], + [-4.24455232e+08 + 3.33500608e+08j, -5.54232768e+08 + 4.81764832e+08j, + -7.26159680e+08 + 6.74396992e+08j, -9.44673792e+08 + 9.15834752e+08j]], + [[-1.60761126e+09 + 1.53736205e+09j, -1.97845542e+09 + 1.92965094e+09j, + -2.40919706e+09 + 2.38405555e+09j, -2.90427264e+09 + 2.90501248e+09j], + [-1.60760742e+09 + 1.53735821e+09j, -1.97845261e+09 + 1.92964813e+09j, + -2.40919450e+09 + 2.38405299e+09j, -2.90427085e+09 + 2.90501120e+09j]], + [[-8.77013248e+08 + 4.54775968e+08j, -1.05411565e+09 + 6.40012672e+08j, + -1.27632653e+09 + 8.72576064e+08j, -1.54808115e+09 + 1.15690163e+09j], + [-8.77010560e+08 + 4.54773344e+08j, -1.05411462e+09 + 6.40011584e+08j, + -1.27632589e+09 + 8.72575488e+08j, -1.54808205e+09 + 1.15690304e+09j]], + [[-2.33229235e+09 + 1.83610880e+09j, -2.75933594e+09 + 2.27424461e+09j, + -3.24923520e+09 + 2.77745434e+09j, -3.80642586e+09 + 3.35017344e+09j], + [-2.33228800e+09 + 1.83610432e+09j, -2.75933338e+09 + 2.27424154e+09j, + -3.24923290e+09 + 2.77745203e+09j, -3.80642509e+09 + 3.35017293e+09j]], + [[-1.32365261e+09 + 3.21670784e+08j, -1.47709235e+09 + 4.69934400e+08j, + -1.67268250e+09 + 6.62566528e+08j, -1.91485875e+09 + 9.04003328e+08j], + [-1.32365056e+09 + 3.21669120e+08j, -1.47709133e+09 + 4.69933312e+08j, + -1.67268122e+09 + 6.62565568e+08j, -1.91485837e+09 + 9.04003328e+08j]], + [[-2.69611136e+09 + 1.52553024e+09j, -3.09061837e+09 + 1.91781939e+09j, + -3.54502349e+09 + 2.37222400e+09j, -4.06376115e+09 + 2.89318067e+09j], + [-2.69610726e+09 + 1.52552653e+09j, -3.09061555e+09 + 1.91781658e+09j, + -3.54502042e+09 + 2.37222144e+09j, -4.06375987e+09 + 2.89317965e+09j]], + [[-2.15481728e+09 + 4.42944416e+08j, -2.35558246e+09 + 6.28181120e+08j, + -2.60145664e+09 + 8.60744448e+08j, -2.89687424e+09 + 1.14507034e+09j], + [-2.15481421e+09 + 4.42941824e+08j, -2.35558118e+09 + 6.28180096e+08j, + -2.60145562e+09 + 8.60743936e+08j, -2.89687475e+09 + 1.14507149e+09j]], + [[-3.79940096e+09 + 1.82427738e+09j, -4.25010765e+09 + 2.26241280e+09j, + -4.76367002e+09 + 2.76562253e+09j, -5.34452326e+09 + 3.33834163e+09j], + [-3.79939610e+09 + 1.82427277e+09j, -4.25010458e+09 + 2.26240998e+09j, + -4.76366746e+09 + 2.76562022e+09j, -5.34452275e+09 + 3.33834138e+09j]]], + dtype=COMPLEX_TYPE) + + out = con.difference_map_fourier_constraint(mask, Idata, obj, probe, exit_wave, addr_info, prefilter, + postfilter, pbound=pbound, alpha=alpha, LL_error=False, + do_realspace_error=False) + np.testing.assert_allclose(out, + expected_out, + err_msg="The returned errors are not consistent.") + + np.testing.assert_allclose(exit_wave, + expected_ew, + err_msg="The expected in-place update of the exit wave didn't work properly.") + + + def test_difference_map_fourier_constraint_pbound_is_not_none_with_realspace_and_LL_error(self): + ''' + mixture of high and low p bound values respect to the fourier error + ''' + #expected_fourier_error = np.array([6.07364329e+12, 8.87756439e+13, 9.12644403e+12, 1.39851186e+14]) + pbound = 8.86e13 # this should now mean some of the arrays update differently through the logic + alpha = 1.0 # feedback constant + num_object_modes = 1 # for example + num_probe_modes = 2 # for example + + N = 4 # number of measured points + M = N * num_object_modes * num_probe_modes # exit wave length + A = 2 # for example + B = 4 # for example + npts_greater_than = int(np.sqrt(N)) # object is bigger than the probe by this amount + C = A + npts_greater_than + D = B + npts_greater_than + + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(M, A, B), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(M, 5, 3), dtype=np.int32) # the address book + Idata = np.empty(shape=(N, A, B), dtype=FLOAT_TYPE) # the measured intensities NxAxB + mask = np.empty(shape=(N, A, B), + dtype=np.int32) # the masks for the measured magnitudes either 1xAxB or NxAxB + probe = np.empty(shape=(num_probe_modes, A, B), dtype=COMPLEX_TYPE) # the probe function + obj = np.empty(shape=(num_object_modes, C, D), dtype=COMPLEX_TYPE) # the object function + prefilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + postfilter = np.empty(shape=(A, B), dtype=COMPLEX_TYPE) + + # now fill it with stuff. Data won't ever look like this except in type and usage! + Idata_fill = np.arange(np.prod(Idata.shape)).reshape(Idata.shape).astype(Idata.dtype) + Idata[:] = Idata_fill + + obj_fill = np.array([ix + 1j * (ix ** 2) for ix in range(np.prod(obj.shape))]).reshape( + (num_object_modes, C, D)) + obj[:] = obj_fill + + probe_fill = np.array([ix + 1j * ix for ix in range(10, 10 + np.prod(probe.shape), 1)]).reshape( + (num_probe_modes, A, B)) + probe[:] = probe_fill + + prefilter.fill(30.0 + 2.0j) # this would actually vary + postfilter.fill(20.0 + 3.0j) # this too + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(exit_wave.shape), 1)]).reshape((M, A, B)) + exit_wave[:] = exit_wave_fill + + mask_fill = np.ones_like(mask) + mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + pa = np.zeros((M, 3), dtype=np.int32) + for idx in range(num_probe_modes): + if idx > 0: + pa[::idx, 0] = idx # multimodal could work like this, but this is not a concrete thing. + + X, Y = np.meshgrid(range(npts_greater_than), + range(npts_greater_than)) # assume square scan grid. Again, not always true. + oa = np.zeros((M, 3), dtype=np.int32) + oa[:N, 1] = X.ravel() + oa[N:, 1] = X.ravel() + oa[:N, 2] = Y.ravel() + oa[N:, 2] = Y.ravel() + for idx in range(num_object_modes): + if idx > 0: + oa[::idx,0] = idx # multimodal could work like this, but this is not a concrete thing (less likely for object) + ea = np.array([np.array([ix, 0, 0]) for ix in range(M)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * num_probe_modes * num_object_modes) + ma = np.zeros((M, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + + expected_out = np.array([[ 0.06855128, 1.00198244, 0.10300727, 1.57845582], + [6.38221460e+23, 8.94021509e+24, 3.44468266e+23, 6.03329184e+24], + [1.89878600e+07, 3.28113995e+19, 4.72013640e+07, 4.89360300e+19]], dtype=FLOAT_TYPE) + + expected_ew = np.array([[[0.00000000e+00 + 0.00000000e+00j, 0.00000000e+00 + 3.80000000e+01j, -4.00000000e+01 + 1.20000000e+02j, - 1.26000000e+02 + 2.52000000e+02j], + [-6.60000000e+02 + 9.24000000e+02j, - 9.66000000e+02 + 1.28800000e+03j, -1.34400000e+03 + 1.72800000e+03j, - 1.80000000e+03 + 2.25000000e+03j]], + [[-6.90095424e+08 + 5.49665856e+08j, - 9.02111168e+08 + 7.77216384e+08j, -1.16220429e+09 + 1.05506266e+09j, - 1.47481139e+09 + 1.38764147e+09j], + [-2.52512358e+09 + 2.52505446e+09j, - 3.05479731e+09 + 3.08208256e+09j, -3.65618765e+09 + 3.71304602e+09j, - 4.33373184e+09 + 4.42238157e+09j]], + [[0.00000000e+00 + 3.60000000e+01j, - 3.80000000e+01 + 1.14000000e+02j, -1.20000000e+02 + 2.40000000e+02j, - 2.52000000e+02 + 4.20000000e+02j], + [-9.24000000e+02 + 1.23200000e+03j, - 1.28800000e+03 + 1.65600000e+03j, -1.72800000e+03 + 2.16000000e+03j, - 2.25000000e+03 + 2.75000000e+03j]], + [[-1.49062272e+09 + 9.55004032e+08j, - 1.78523661e+09 + 1.25600128e+09j, -2.13328819e+09 + 1.61265498e+09j, - 2.53921434e+09 + 2.02940147e+09j], + [-3.17395840e+09 + 2.71720909e+09j, - 3.73343309e+09 + 3.29248486e+09j, -4.36517990e+09 + 3.94225101e+09j, - 5.07363635e+09 + 4.67094528e+09j]], + [[0.00000000e+00 + 0.00000000e+00j, 0.00000000e+00 + 3.80000000e+01j, -4.00000000e+01 + 1.20000000e+02j, - 1.26000000e+02 + 2.52000000e+02j], + [-6.60000000e+02 + 9.24000000e+02j, - 9.66000000e+02 + 1.28800000e+03j, -1.34400000e+03 + 1.72800000e+03j, - 1.80000000e+03 + 2.25000000e+03j]], + [[-1.73131635e+09 + 5.37834304e+08j, - 1.96699507e+09 + 7.65384832e+08j, -2.25075123e+09 + 1.04323117e+09j, - 2.58702131e+09 + 1.37581005e+09j], + [-3.66090240e+09 + 2.51322291e+09j, - 4.21423872e+09 + 3.07025101e+09j, -4.83929190e+09 + 3.70121421e+09j, - 5.54049946e+09 + 4.41055027e+09j]], + [[0.00000000e+00 + 3.60000000e+01j, - 3.80000000e+01 + 1.14000000e+02j, -1.20000000e+02 + 2.40000000e+02j, - 2.52000000e+02 + 4.20000000e+02j], + [-9.24000000e+02 + 1.23200000e+03j, - 1.28800000e+03 + 1.65600000e+03j, -1.72800000e+03 + 2.16000000e+03j, - 2.25000000e+03 + 2.75000000e+03j]], + [[-2.92006195e+09 + 9.43172416e+08j, - 3.23833907e+09 + 1.24416986e+09j, -3.61005363e+09 + 1.60082368e+09j, - 4.03964314e+09 + 2.01757018e+09j], + [-4.67873485e+09 + 2.70537754e+09j, - 5.26187366e+09 + 3.28065306e+09j, -5.91728384e+09 + 3.93041971e+09j, - 6.64940288e+09 + 4.65911398e+09j]]] + ,dtype=COMPLEX_TYPE) + + out = con.difference_map_fourier_constraint(mask, Idata, obj, probe, exit_wave, addr_info, prefilter, + postfilter, pbound=pbound, alpha=alpha, LL_error=True, + do_realspace_error=True) + + np.testing.assert_allclose(out, + expected_out, + err_msg="The returned errors are not consistent.") + + np.testing.assert_allclose(exit_wave, + expected_ew, + err_msg="The expected in-place update of the exit wave didn't work properly.") + + + def test_difference_map_iterator_with_probe_update(self): + ''' + This test, assumes the logic below this function works fine, and just does some iterations of difference map on + some spoof data to check that the combination works. + ''' + num_iter = 2 + + pbound = 8.86e13 # this should now mean some of the arrays update differently through the logic + alpha = 1.0 # feedback constant + + # diffraction frame size + B = 2 # for example + C = 4 # for example + + # probe dimensions + D = 2 # for example + E = B + F = C + + scan_pts = 2 # a 2x2 grid + N = scan_pts**2 # the number of measurement points in a scan + npts_greater_than = int(np.sqrt(N)) # object is bigger than the probe by this amount + + # object dimensions + G = 1 # for example + H = B + npts_greater_than + I = C + npts_greater_than + + A = scan_pts ** 2 * G * D # number of exit waves + + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(A, 5, 3), dtype=np.int32) # the address book + diffraction = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured intensities NxAxB + mask = np.empty(shape=(N, B, C), + dtype=np.int32) # the masks for the measured magnitudes either 1xAxB or NxAxB + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) # the probe function + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) # the object function + prefilter = np.empty(shape=(B, C), dtype=COMPLEX_TYPE) + postfilter = np.empty(shape=(B, C), dtype=COMPLEX_TYPE) + + # now fill it with stuff. Data won't ever look like this except in type and usage! + diffraction_fill = np.arange(np.prod(diffraction.shape)).reshape(diffraction.shape).astype(diffraction.dtype) + diffraction[:] = diffraction_fill + + obj_fill = np.array([ix + 1j * (ix ** 2) for ix in range(np.prod(obj.shape))]).reshape( + (G, H, I)) + obj[:] = obj_fill + + probe_fill = np.array([ix + 1j * ix for ix in range(10, 10 + np.prod(probe.shape), 1)]).reshape( + (D, B, C)) + probe[:] = probe_fill + + prefilter.fill(30.0 + 2.0j) # this would actually vary + postfilter.fill(20.0 + 3.0j) # this too + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(exit_wave.shape), 1)]).reshape((A, B, C)) + exit_wave[:] = exit_wave_fill + + mask_fill = np.ones_like(mask) + # mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + pa = np.zeros((A, 3), dtype=np.int32) + pa[:N,0] = 0 + pa[N:, 0] = 1 + + X, Y = np.meshgrid(range(npts_greater_than), + range(npts_greater_than)) # assume square scan grid. Again, not always true. + oa = np.zeros((A, 3), dtype=np.int32) + oa[:N, 1] = X.ravel() + oa[N:, 1] = X.ravel() + oa[:N, 2] = Y.ravel() + oa[N:, 2] = Y.ravel() + + + ea = np.array([np.array([ix, 0, 0]) for ix in range(A)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * D * G) + ma = np.zeros((A, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + + for idx in range(D): + cfact_probe[idx] = np.ones((B, C)) * 5 * (idx + 1) + + expected_probe = np.array([[[-361.18814087-1000.74768066j, -148.70419312 +206.73210144j, + -91.97548676 -9.23460865j, 16.05268097 -41.11487198j], + [-152.72857666 +109.68946838j, -62.70831680 -58.41201782j, + 37.14255524 -17.69169426j, -4.25983000 -6.36473894j]], + + [[-749.64007568-2050.26147461j, -401.52606201 +451.15054321j, + -218.26188660 -36.93523788j, 41.09194946 -91.68986511j], + [-350.60354614 +226.57118225j, -109.65759277 -124.06006622j, + 68.98976898 -24.72795677j, -5.64832449 -11.25561905j]]], dtype=COMPLEX_TYPE) + + expected_obj = np.array([[[ -0.00000000e+00 -0.00000000e+00j, -1.27605135e-02 -1.07031791e-02j, + 1.80982396e-01 -1.77402645e-01j, -2.30214819e-01 -1.09420657e+00j, + -5.07897234e+00 -9.75304246e-01j, 5.00000000e+00 +2.50000000e+01j], + [ -1.48292825e-01 -4.61030722e-01j, -5.86787999e-01 +3.41154838e+00j, + -1.08777246e+01 -8.06874752e+00j, -3.86462593e+01 +1.36726942e+01j, + 6.36259308e+01 +8.40691147e+01j, 1.10000000e+01 +1.21000000e+02j], + [ 1.10468502e+01 -5.40999889e+00j, -2.75495262e+01 -7.16127729e+00j, + -3.61000290e+01 +9.38624268e+01j, 2.70963776e+02 -2.03708401e+01j, + 2.82062347e+02 +2.01701343e+03j, 1.70000000e+01 +2.89000000e+02j], + [ 1.80000000e+01 +3.24000000e+02j, 1.90000000e+01 +3.61000000e+02j, + 2.00000000e+01 +4.00000000e+02j, 2.10000000e+01 +4.41000000e+02j, + 2.20000000e+01 +4.84000000e+02j, 2.30000000e+01 +5.29000000e+02j]]], dtype=COMPLEX_TYPE) + + expected_errors = np.array([[[ 1.30852982e-01+0.j, 7.86592126e-01+0.j, 2.91434258e-01+0.j, + 1.26918125e+00+0.j], + [ 2.88552762e+24+0.j, 6.12232725e+25+0.j, 6.29929433e+23+0.j, + 4.21546840e+25+0.j], + [ 1.75457960e+07+0.j, 7.23184240e+07+0.j, 4.43651240e+07+0.j, + 3.27585548e+19+0.j]], + + [[ 1.28861861e-02+0.j, 1.27825022e-01+0.j, 2.06416398e-02+0.j, + 1.36703640e+11+0.j], + [ 2.88552762e+24+0.j, 6.12232725e+25+0.j, 6.29929433e+23+0.j, + 4.21546840e+25+0.j], + [ 0.00000000e+00+0.j, 0.00000000e+00+0.j, 0.00000000e+00+0.j, + 3.27586977e+19+0.j]]], dtype=COMPLEX_TYPE) + + + + + errors = con.difference_map_iterator(diffraction=diffraction, + obj=obj, + object_weights=obj_weights, + cfact_object=cfact_object, + mask=mask, + probe=probe, + cfact_probe=cfact_probe, + probe_support=None, + probe_weights=probe_weights, + exit_wave=exit_wave, + addr=addr_info, + pre_fft=prefilter, + post_fft=postfilter, + pbound=pbound, + overlap_max_iterations=10, + update_object_first=False, + obj_smooth_std=None, + overlap_converge_factor=1.4e-3, + probe_center_tol=None, + probe_update_start=1, + alpha=alpha, + clip_object=None, + LL_error=True, + num_iterations=num_iter) + + + + np.testing.assert_array_equal(expected_probe, + probe, + err_msg="The probe has not behaved as expected.") + + np.testing.assert_array_equal(expected_obj, + obj, + err_msg="The object has not behaved as expected.") + + np.testing.assert_array_equal(expected_errors, + errors, + err_msg="The errors have not behaved as expected.") + + def test_difference_map_iterator_with_no_probe_update_and_object_update(self): + ''' + This test, assumes the logic below this function works fine, and just does some iterations of difference map on + some spoof data to check that the combination works. + ''' + num_iter = 1 + + pbound = 8.86e13 # this should now mean some of the arrays update differently through the logic + alpha = 1.0 # feedback constant + + # diffraction frame size + B = 2 # for example + C = 4 # for example + + # probe dimensions + D = 2 # for example + E = B + F = C + + scan_pts = 2 # a 2x2 grid + N = scan_pts**2 # the number of measurement points in a scan + npts_greater_than = int(np.sqrt(N)) # object is bigger than the probe by this amount + + # object dimensions + G = 1 # for example + H = B + npts_greater_than + I = C + npts_greater_than + + A = scan_pts ** 2 * G * D # number of exit waves + + err_fmag = np.empty(shape=(N,), dtype=FLOAT_TYPE) # deviation from the diffraction pattern for each af + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) # exit wave + addr_info = np.empty(shape=(A, 5, 3), dtype=np.int32) # the address book + diffraction = np.empty(shape=(N, B, C), dtype=FLOAT_TYPE) # the measured intensities NxAxB + mask = np.empty(shape=(N, B, C), + dtype=np.int32) # the masks for the measured magnitudes either 1xAxB or NxAxB + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) # the probe function + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) # the object function + prefilter = np.empty(shape=(B, C), dtype=COMPLEX_TYPE) + postfilter = np.empty(shape=(B, C), dtype=COMPLEX_TYPE) + + # now fill it with stuff. Data won't ever look like this except in type and usage! + diffraction_fill = np.arange(np.prod(diffraction.shape)).reshape(diffraction.shape).astype(diffraction.dtype) + diffraction[:] = diffraction_fill + + obj_fill = np.array([ix + 1j * (ix ** 2) for ix in range(np.prod(obj.shape))]).reshape( + (G, H, I)) + obj[:] = obj_fill + + probe_fill = np.array([ix + 1j * ix for ix in range(10, 10 + np.prod(probe.shape), 1)]).reshape( + (D, B, C)) + probe[:] = probe_fill + + prefilter.fill(30.0 + 2.0j) # this would actually vary + postfilter.fill(20.0 + 3.0j) # this too + err_fmag_fill = np.ones((N,)) + err_fmag[:] = err_fmag_fill # this shouldn't be used as pbound is None + + exit_wave_fill = np.array( + [ix ** 2 + 1j * ix for ix in range(20, 20 + np.prod(exit_wave.shape), 1)]).reshape((A, B, C)) + exit_wave[:] = exit_wave_fill + + mask_fill = np.ones_like(mask) + # mask_fill[::2, ::2] = 0 # checkerboard for testing + mask[:] = mask_fill + + pa = np.zeros((A, 3), dtype=np.int32) + pa[:N,0] = 0 + pa[N:, 0] = 1 + + X, Y = np.meshgrid(range(npts_greater_than), + range(npts_greater_than)) # assume square scan grid. Again, not always true. + oa = np.zeros((A, 3), dtype=np.int32) + oa[:N, 1] = X.ravel() + oa[N:, 1] = X.ravel() + oa[:N, 2] = Y.ravel() + oa[N:, 2] = Y.ravel() + + + ea = np.array([np.array([ix, 0, 0]) for ix in range(A)]) + da = np.array([np.array([ix, 0, 0]) for ix in range(N)] * D * G) + ma = np.zeros((A, 3), dtype=np.int32) + + addr_info[:, 0, :] = pa + addr_info[:, 1, :] = oa + addr_info[:, 2, :] = ea + addr_info[:, 3, :] = da + addr_info[:, 4, :] = ma + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + + for idx in range(D): + cfact_probe[idx] = np.ones((B, C)) * 5 * (idx + 1) + + expected_probe = deepcopy(probe) + + expected_obj = np.array([[[ -0.00000000e+00 -0.00000000e+00j, + 1.00000000e+00 +1.00000000e+00j, + 2.00000000e+00 +4.00000000e+00j, + 3.00000000e+00 +9.00000000e+00j, + 4.00000000e+00 +1.60000000e+01j, + 5.00000000e+00 +2.50000000e+01j], + [ 6.00000000e+00 +3.60000000e+01j, + -7.95981900e+06 +1.43803590e+07j, + -7.64522750e+06 +1.61365070e+07j, + -7.34606000e+06 +1.82074500e+07j, + -1.48699840e+07 +4.33746560e+07j, + 1.10000000e+01 +1.21000000e+02j], + [ 1.20000000e+01 +1.44000000e+02j, + -1.60912900e+07 +7.23797920e+07j, + -1.52878190e+07 +8.04868400e+07j, + -1.45362140e+07 +8.92972240e+07j, + -2.90441140e+07 +2.07500928e+08j, + 1.70000000e+01 +2.89000000e+02j], + [ 1.80000000e+01 +3.24000000e+02j, + 1.90000000e+01 +3.61000000e+02j, + 2.00000000e+01 +4.00000000e+02j, + 2.10000000e+01 +4.41000000e+02j, + 2.20000000e+01 +4.84000000e+02j, + 2.30000000e+01 +5.29000000e+02j]]], dtype=COMPLEX_TYPE) + + expected_errors = np.array([[[ 1.30852982e-01+0.j, 7.86592126e-01+0.j, 2.91434258e-01+0.j, + 1.26918125e+00+0.j], + [ 2.88552762e+24+0.j, 6.12232725e+25+0.j, 6.29929433e+23+0.j, + 4.21546840e+25+0.j], + [ 1.75457960e+07+0.j, 7.23184240e+07+0.j, 4.43651240e+07+0.j, + 3.27585548e+19+0.j]]], dtype=COMPLEX_TYPE) + + + errors = con.difference_map_iterator(diffraction=diffraction, + obj=obj, + object_weights=obj_weights, + cfact_object=cfact_object, + mask=mask, + probe=probe, + cfact_probe=cfact_probe, + probe_support=None, + probe_weights=probe_weights, + exit_wave=exit_wave, + addr=addr_info, + pre_fft=prefilter, + post_fft=postfilter, + pbound=pbound, + overlap_max_iterations=10, + update_object_first=True, + obj_smooth_std=None, + overlap_converge_factor=1.4e-3, + probe_center_tol=None, + probe_update_start=2, + alpha=alpha, + clip_object=None, + LL_error=True, + num_iterations=num_iter) + + np.testing.assert_array_equal(expected_probe, + probe, + err_msg="The probe has not behaved as expected.") + + np.testing.assert_array_equal(expected_obj, + obj, + err_msg="The object has not behaved as expected.") + + np.testing.assert_array_equal(expected_errors, + errors, + err_msg="The error has not behaved as expected.") + + + +if __name__ == '__main__': + unittest.main() + + + diff --git a/test/archive_tests/array_based_tests/constraints_unity_test.py b/test/archive_tests/array_based_tests/constraints_unity_test.py new file mode 100644 index 000000000..9c9588768 --- /dev/null +++ b/test/archive_tests/array_based_tests/constraints_unity_test.py @@ -0,0 +1,221 @@ +''' +The tests for the constraints +''' + + +import unittest +import numpy as np +from test.archive_tests.array_based_tests import utils as tu +from ptypy.accelerate.array_based import data_utils as du +from collections import OrderedDict +from ptypy.engines.utils import basic_fourier_update +from ptypy.accelerate.array_based.constraints import difference_map_fourier_constraint +from ptypy.accelerate import array_based as ab + +@unittest.skip("Skip these until I have had chance to investigate the tolerances.") +class ConstraintsUnityTest(unittest.TestCase): + + def test_difference_map_fourier_constraint_pbound_none_UNITY(self): + ab.FLOAT_TYPE =np.float64 + ab.COMPLEX_TYPE = np.complex128 + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + PodPtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + + # now convert to arrays + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + + first_view_id = vectorised_scan['meta']['view_IDs'][0] + master_pod = PtychoInstance.diff.V[first_view_id].pod + propagator = master_pod.geometry.propagator + + ptypy_ewf, ptypy_error= self.ptypy_difference_map_fourier_constraint(PodPtychoInstance) + errors = difference_map_fourier_constraint(vectorised_scan['mask'], + vectorised_scan['diffraction'], + vectorised_scan['obj'], + vectorised_scan['probe'], + vectorised_scan['exit wave'], + vectorised_scan['meta']['addr'], + prefilter=propagator.pre_fft, + postfilter=propagator.post_fft, + pbound=None, + alpha=1.0, + LL_error=True) + rtol=1e-7 + for idx, key in enumerate(ptypy_ewf.keys()): + np.testing.assert_allclose(ptypy_ewf[key], + vectorised_scan['exit wave'][idx], + err_msg="The array-based and pod-based exit waves are not consistent", + rtol =rtol) + + ptypy_fmag = [] + ptypy_phot = [] + ptypy_exit = [] + + for idx, key in enumerate(ptypy_error.keys()): + err_fmag, err_phot, err_exit = ptypy_error[key] + ptypy_fmag.append(err_fmag) + ptypy_phot.append(err_phot) + ptypy_exit.append(err_exit) + + ptypy_fmag = np.array(ptypy_fmag) + ptypy_phot = np.array(ptypy_phot) + + ptypy_exit = np.array(ptypy_exit) + + npy_fmag = errors[0, :] + npy_phot = errors[1, :] + npy_exit = errors[2, :] + ab.FLOAT_TYPE =np.float32 + ab.COMPLEX_TYPE = np.complex64 + + np.testing.assert_array_equal(npy_fmag, + ptypy_fmag, + err_msg="The array-based and pod-based fmag errors are not consistent", + rtol=rtol) + + np.testing.assert_array_equal(npy_phot, + ptypy_phot, + err_msg="The array-based and pod-based phot errors are not consistent", + rtol=rtol) + # there is a slight difference in numpy in the way the mean is calculated here. It 1e-13 and a diagnostic so almost equal is fine + np.testing.assert_allclose(npy_exit, + ptypy_exit, + err_msg="The array-based and pod-based exit errors are not consistent", + rtol=rtol) + + def test_difference_map_fourier_constraint_pbound_less_than_fourier_error_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + PodPtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + pbound = 0.597053604126 + # now convert to arrays + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + + first_view_id = vectorised_scan['meta']['view_IDs'][0] + master_pod = PtychoInstance.diff.V[first_view_id].pod + propagator = master_pod.geometry.propagator + + ptypy_ewf, ptypy_error= self.ptypy_difference_map_fourier_constraint(PodPtychoInstance, pbound=pbound) + errors = difference_map_fourier_constraint(vectorised_scan['mask'], + vectorised_scan['diffraction'], + vectorised_scan['obj'], + vectorised_scan['probe'], + vectorised_scan['exit wave'], + vectorised_scan['meta']['addr'], + prefilter=propagator.pre_fft, + postfilter=propagator.post_fft, + pbound=pbound, + alpha=1.0, + LL_error=True) + + for idx, key in enumerate(ptypy_ewf.keys()): + np.testing.assert_array_equal(ptypy_ewf[key], + vectorised_scan['exit wave'][idx], + err_msg="The array-based and pod-based exit waves are not consistent") + + ptypy_fmag = [] + ptypy_phot = [] + ptypy_exit = [] + + for idx, key in enumerate(ptypy_error.keys()): + err_fmag, err_phot, err_exit = ptypy_error[key] + ptypy_fmag.append(err_fmag) + ptypy_phot.append(err_phot) + ptypy_exit.append(err_exit) + + ptypy_fmag = np.array(ptypy_fmag) + ptypy_phot = np.array(ptypy_phot) + ptypy_exit = np.array(ptypy_exit) + + npy_fmag = errors[0, :] + npy_phot = errors[1, :] + npy_exit = errors[2, :] + + np.testing.assert_array_equal(npy_fmag, + ptypy_fmag, + err_msg="The array-based and pod-based fmag errors are not consistent") + + np.testing.assert_array_equal(npy_phot, + ptypy_phot, + err_msg="The array-based and pod-based phot errors are not consistent") + # there is a slight difference in numpy in the way the mean is calculated here. It 1e-13 and a diagnostic so almost equal is fine + np.testing.assert_allclose(npy_exit, + ptypy_exit, + err_msg="The array-based and pod-based exit errors are not consistent") + + def test_difference_map_fourier_constraint_pbound_greater_than_fourier_error_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + PodPtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + pbound = 200.0 + # now convert to arrays + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + + first_view_id = vectorised_scan['meta']['view_IDs'][0] + master_pod = PtychoInstance.diff.V[first_view_id].pod + propagator = master_pod.geometry.propagator + + ptypy_ewf, ptypy_error = self.ptypy_difference_map_fourier_constraint(PodPtychoInstance, pbound=pbound) + errors = difference_map_fourier_constraint(vectorised_scan['mask'], + vectorised_scan['diffraction'], + vectorised_scan['obj'], + vectorised_scan['probe'], + vectorised_scan['exit wave'], + vectorised_scan['meta']['addr'], + prefilter=propagator.pre_fft, + postfilter=propagator.post_fft, + pbound=pbound, + alpha=1.0, + LL_error=True) + + for idx, key in enumerate(ptypy_ewf.keys()): + np.testing.assert_array_equal(ptypy_ewf[key], + vectorised_scan['exit wave'][idx], + err_msg="The array-based and pod-based exit waves are not consistent") + + ptypy_fmag = [] + ptypy_phot = [] + ptypy_exit = [] + + for idx, key in enumerate(ptypy_error.keys()): + err_fmag, err_phot, err_exit = ptypy_error[key] + ptypy_fmag.append(err_fmag) + ptypy_phot.append(err_phot) + ptypy_exit.append(err_exit) + + ptypy_fmag = np.array(ptypy_fmag) + ptypy_phot = np.array(ptypy_phot) + ptypy_exit = np.array(ptypy_exit) + + npy_fmag = errors[0, :] + npy_phot = errors[1, :] + npy_exit = errors[2, :] + + np.testing.assert_array_equal(npy_fmag, + ptypy_fmag, + err_msg="The array-based and pod-based fmag errors are not consistent") + + np.testing.assert_array_equal(npy_phot, + ptypy_phot, + err_msg="The array-based and pod-based phot errors are not consistent") + # there is a slight difference in numpy in the way the mean is calculated here. It 1e-13 and a diagnostic so almost equal is fine + np.testing.assert_allclose(npy_exit, + ptypy_exit, + err_msg="The array-based and pod-based exit errors are not consistent") + + def ptypy_difference_map_fourier_constraint(self, a_ptycho_instance, pbound=None): + error_dct = OrderedDict() + exit_wave = OrderedDict() + for dname, diff_view in a_ptycho_instance.diff.views.items(): + di_view = a_ptycho_instance.diff.V[dname] + error_dct[dname] = basic_fourier_update(di_view, + pbound=pbound, + alpha=1.0) + for name, pod in di_view.pods.items(): + exit_wave[name] = pod.exit + return exit_wave, error_dct + + +if __name__ == '__main__': + unittest.main() + + + diff --git a/test/archive_tests/array_based_tests/data_utils_test.py b/test/archive_tests/array_based_tests/data_utils_test.py new file mode 100644 index 000000000..2062c0d2c --- /dev/null +++ b/test/archive_tests/array_based_tests/data_utils_test.py @@ -0,0 +1,54 @@ +''' +Created on 4 Jan 2018 + +@author: clb02321 +''' +import unittest +from test.archive_tests.array_based_tests import utils as tu +import numpy as np + +from ptypy.accelerate.array_based import data_utils as du + + + +class DataUtilsTest(unittest.TestCase): + ''' + tests the conversion between pods and numpy arrays + ''' + + def test_pod_to_numpy(self): + ''' + tests if the vectorisation process works + ''' + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + du.pod_to_arrays(PtychoInstance, 'S0000', scan_model='Full') + + def test_numpy_pod_consistency(self): + ''' + vectorises the Ptycho instance. + ''' + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + addr = vectorised_scan['meta']['addr'] + view_IDS = vectorised_scan['meta']['view_IDs'] + + # check the probe references match up + vectorised_scan['probe'] *= np.random.rand(*vectorised_scan['probe'].shape) + + pa, oa, ea, da, ma = zip(*addr) + + for idx, vID in enumerate(view_IDS): + np.testing.assert_array_equal(vectorised_scan['probe'][pa[idx][0]], PtychoInstance.pr.V[vID].data) + + + + vectorised_scan['exit wave'] *= np.random.rand(*vectorised_scan['exit wave'].shape) + + for idx, vID in enumerate(view_IDS): + np.testing.assert_array_equal(vectorised_scan['exit wave'][ea[idx][0]], PtychoInstance.ex.V[vID].data) + + + + +if __name__ == "__main__": + unittest.main() diff --git a/test/archive_tests/array_based_tests/error_metric_test_regression_test.py b/test/archive_tests/array_based_tests/error_metric_test_regression_test.py new file mode 100644 index 000000000..a35408c50 --- /dev/null +++ b/test/archive_tests/array_based_tests/error_metric_test_regression_test.py @@ -0,0 +1,103 @@ +''' +A test for the module of the relevant error metrics +''' + +import unittest +import numpy as np +from test.archive_tests.array_based_tests import utils as tu +from ptypy.accelerate.array_based import data_utils as du +from ptypy.accelerate.array_based import COMPLEX_TYPE, FLOAT_TYPE +import ptypy.utils as u +from collections import OrderedDict +from archive.array_based.error_metrics import log_likelihood, far_field_error, realspace_error +from ptypy.accelerate.array_based.object_probe_interaction import scan_and_multiply + + +class ErrorMetricRegressionTest(unittest.TestCase): + + def test_loglikelihood_regression(self): + ''' + Test that it runs + ''' + # should be able to completely remove this + PtychoInstance = tu.get_ptycho_instance('log_likelihood_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + propagator = PtychoInstance.diff.V[first_view_id].pod.geometry.propagator + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + mask = vectorised_scan['mask'] + exit_wave = vectorised_scan['exit wave'] + diffraction = vectorised_scan['diffraction'] + + probe_object = scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + log_likelihood(probe_object, mask, diffraction, propagator.pre_fft, propagator.post_fft, addr_info) + + + def test_far_field_error_regression(self): + PtychoInstance = tu.get_ptycho_instance('log_likelihood_test') + af, fmag, mask = self.get_current_and_measured_solution(PtychoInstance) + far_field_error(af, fmag, mask) + + + def test_realspace_error_regression_a(self): + # the case when there is only one mode + I = 5 + M = 20 + N = 30 + out_length = I + ea_first_column = range(I) + da_first_column = range(I) + + difference = np.empty(shape=(I, M, N), dtype=COMPLEX_TYPE) + for idx in range(I): + difference[idx] = np.ones((M, N)) *idx + 1j * np.ones((M, N)) *idx + + error = realspace_error(difference, ea_first_column, da_first_column, out_length) + + expected_error = np.array([ 0.0, 2.0, 8.0, 18.0, 32.0], dtype=FLOAT_TYPE) + np.testing.assert_array_equal(error, expected_error) + + def test_realspace_error_regression_b(self): + # multiple modes + I = 10 + M = 20 + N = 30 + out_length = 5 + ea_first_column = range(I) + da_first_column = list(range(int(I/2))) + list(range(int(I/2))) + + difference = np.empty(shape=(I, M, N), dtype=COMPLEX_TYPE) + for idx in range(I): + difference[idx] = np.ones((M, N)) * idx + 1j * np.ones((M, N)) * idx + + error = realspace_error(difference, ea_first_column, da_first_column, out_length) + + expected_error = np.array([50., 74., 106., 146., 194.], dtype=FLOAT_TYPE) + np.testing.assert_array_equal(error, expected_error) + + + def get_current_and_measured_solution(self, a_ptycho_instance): + alpha = 1.0 + fmag = [] + af = [] + mask = [] + for dname, diff_view in a_ptycho_instance.diff.views.items(): + fmag.append(np.sqrt(np.abs(diff_view.data))) + af2 = np.zeros_like(diff_view.data) + f = OrderedDict() + for name, pod in diff_view.pods.items(): + if not pod.active: + continue + f[name] = pod.fw((1 + alpha) * pod.probe * pod.object + - alpha * pod.exit) + af2 += u.abs2(f[name]) + mask.append(diff_view.pod.mask) + af.append(np.sqrt(af2)) + return np.array(af), np.array(fmag), np.array(mask) + + + +if __name__ == '__main__': + unittest.main() diff --git a/test/archive_tests/array_based_tests/error_metric_unity_test.py b/test/archive_tests/array_based_tests/error_metric_unity_test.py new file mode 100644 index 000000000..d2db3d160 --- /dev/null +++ b/test/archive_tests/array_based_tests/error_metric_unity_test.py @@ -0,0 +1,106 @@ +''' +A test for the module of the relevant error metrics + SHOULD THIS EXIST? Ptypy has no in built functions for these, so I could refactor so that it does, or just not both testing. +''' + +import unittest +import numpy as np +from test.archive_tests.array_based_tests import utils as tu +from ptypy.accelerate.array_based import data_utils as du +import ptypy.utils as u +from collections import OrderedDict +from archive.array_based.error_metrics import log_likelihood, far_field_error +from ptypy.accelerate.array_based.object_probe_interaction import scan_and_multiply + + +class ErrorMetricUnityTest(unittest.TestCase): + + def test_loglikelihood_numpy_UNITY(self): + ''' + Check that it gives the same result as the ptypy original + + ''' + error_metric = {} + PodPtychoInstance = tu.get_ptycho_instance('log_likelihood_test') + ptypy_error_metric =self.get_ptypy_loglikelihood(PodPtychoInstance) + PtychoInstance = tu.get_ptycho_instance('log_likelihood_test') + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + first_view_id = vectorised_scan['meta']['view_IDs'][0] + propagator = PtychoInstance.diff.V[first_view_id].pod.geometry.propagator + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + mask = vectorised_scan['mask'] + exit_wave = vectorised_scan['exit wave'] + diffraction = vectorised_scan['diffraction'] + + probe_object = scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + + vals = log_likelihood(probe_object, mask, diffraction, propagator.pre_fft, propagator.post_fft, addr_info) + k = 0 + for name, view in PtychoInstance.diff.V.items(): + error_metric[name] = vals[k] + k += 1 + + + for name, view in PodPtychoInstance.diff.V.items(): + ptypy_error = ptypy_error_metric[name] + numpy_error = error_metric[name] + np.testing.assert_array_equal(ptypy_error, numpy_error) + + def test_far_field_error_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('log_likelihood_test') + PodPtychoInstance = tu.get_ptycho_instance('log_likelihood_test') + af, fmag, mask = self.get_current_and_measured_solution(PtychoInstance) + fmag_npy = far_field_error(af, fmag, mask) + fmag_ptypy = self.get_ptypy_far_field_error(PodPtychoInstance) + np.testing.assert_array_equal(fmag_ptypy, fmag_npy) + + @unittest.skip("I wonder if its possible to put this in.") + def test_real_space_error_UNITY(self): + pass + + + def get_current_and_measured_solution(self, a_ptycho_instance): + alpha = 1.0 + fmag = [] + af = [] + mask = [] + for dname, diff_view in a_ptycho_instance.diff.views.items(): + fmag.append(np.sqrt(np.abs(diff_view.data))) + af2 = np.zeros_like(diff_view.data) + f = OrderedDict() + for name, pod in diff_view.pods.items(): + if not pod.active: + continue + f[name] = pod.fw((1 + alpha) * pod.probe * pod.object + - alpha * pod.exit) + af2 += u.abs2(f[name]) + mask.append(diff_view.pod.mask) + af.append(np.sqrt(af2)) + return np.array(af), np.array(fmag), np.array(mask) + + def get_ptypy_far_field_error(self, a_ptycho_instance): + + err_fmag = [] + af, fmag, mask = self.get_current_and_measured_solution(a_ptycho_instance) + for i in range(af.shape[0]): + fdev = af[i] - fmag[i] + err_fmag.append(np.sum(mask[i] * fdev ** 2) / mask[i].sum()) + return np.array(err_fmag) + + def get_ptypy_loglikelihood(self, a_ptycho_instance): + error_dct = {} + for dname, diff_view in a_ptycho_instance.diff.views.items(): + I = diff_view.data + fmask = diff_view.pod.mask + LL = np.zeros_like(diff_view.data) + for name, pod in diff_view.pods.items(): + LL += u.abs2(pod.fw(pod.probe * pod.object)) + + error_dct[dname] = (np.sum(fmask * (LL - I) ** 2 / (I + 1.)) + / np.prod(LL.shape)) + return error_dct + +if __name__ == '__main__': + unittest.main() diff --git a/test/archive_tests/array_based_tests/farfield_propagator_regression_test.py b/test/archive_tests/array_based_tests/farfield_propagator_regression_test.py new file mode 100644 index 000000000..5bd6fb660 --- /dev/null +++ b/test/archive_tests/array_based_tests/farfield_propagator_regression_test.py @@ -0,0 +1,92 @@ +''' +Test for the propagation in numpy +SHOULD REFACTOR HERE to be less dependent on the main framework. We just want to test the propagator works with 3x3 data. +''' + +import unittest +import numpy as np +from test.archive_tests.array_based_tests import utils as tu +from ptypy.accelerate.array_based import data_utils as du +from ptypy.accelerate.array_based import object_probe_interaction as opi +from archive.array_based import propagation as prop +from copy import deepcopy as copy +TOLERANCE=4 + +class FarfieldPropagatorRegressionTest(unittest.TestCase): + def setUp(self): + self.PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + self.GeoPtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + self.vectorised_scan = du.pod_to_arrays(self.PtychoInstance, 'S0000') + self.pod_vectorised_scan = du.pod_to_arrays(self.GeoPtychoInstance, 'S0000') + self.first_view_id = self.pod_vectorised_scan['meta']['view_IDs'][0] + + def test_fourier_transform_farfield_nofilter(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + prop.farfield_propagator(vec_ew) + + def test_fourier_transform_farfield_with_prefilter(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + prop.farfield_propagator(vec_ew, prefilter=propagator.pre_fft) + + + def test_fourier_transform_farfield_with_postfilter(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + prop.farfield_propagator(vec_ew, prefilter=None, postfilter=propagator.post_fft) + + def test_fourier_transform_farfield_with_pre_and_post_filter(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + prop.farfield_propagator(vec_ew, prefilter=propagator.pre_fft, postfilter=propagator.post_fft) + + def test_inverse_fourier_transform_farfield_nofilter(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + prop.farfield_propagator(vec_ew, direction='backward') + + def test_inverse_fourier_transform_farfield_with_prefilter(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + prop.farfield_propagator(vec_ew, prefilter=propagator.pre_ifft, direction='backward') + + def test_inverse_fourier_transform_farfield_with_postfilter(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + prop.farfield_propagator(vec_ew, prefilter=None, postfilter=propagator.post_ifft, direction='backward') + + def test_inverse_fourier_transform_farfield_with_pre_and_post_filter(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + prop.farfield_propagator(vec_ew, prefilter=propagator.pre_ifft, postfilter=propagator.post_ifft, direction='backward') + + def get_exit_wave(self, a_vectorised_scan): + ''' + a pretested method + :param a_vectorised_scan: A scan that has been vectorised. + :return: the exit wave + ''' + vec_addr_info = a_vectorised_scan['meta']['addr'] + vec_probe = a_vectorised_scan['probe'] + vec_obj = a_vectorised_scan['obj'] + vec_ew = a_vectorised_scan['exit wave'] + return opi.scan_and_multiply(vec_probe, + vec_obj, + vec_ew.shape, + vec_addr_info) + + + def diffraction_transform_with_geo(self, propagator, ew, direction='forward'): + result_array_geo = np.zeros_like(ew) + meta = self.pod_vectorised_scan['meta'] # probably want to extract these at a later date, but just to get stuff going... + view_dlayer = 0 # what is this? + addr_info = meta['addr'][:,view_dlayer] # addresses, object references + for _pa, _oa, ea, _da, _ma in addr_info: + if direction=='forward': + result_array_geo[ea[0]] = propagator.fw(ew[ea[0]]) + else: + result_array_geo[ea[0]] = propagator.bw(ew[ea[0]]) + return result_array_geo + + +if __name__ == "__main__": + unittest.main() diff --git a/test/archive_tests/array_based_tests/farfield_propagator_unity_test.py b/test/archive_tests/array_based_tests/farfield_propagator_unity_test.py new file mode 100644 index 000000000..f14d24bb9 --- /dev/null +++ b/test/archive_tests/array_based_tests/farfield_propagator_unity_test.py @@ -0,0 +1,166 @@ +''' +Test for the propagation in numpy +SHOULD REFACTOR HERE to be less dependent on the main framework. We just want to test the propagator works with 3x3 data. +''' + +import unittest +import numpy as np +from test.archive_tests.array_based_tests import utils as tu +from ptypy.accelerate.array_based import data_utils as du +from ptypy.accelerate.array_based import object_probe_interaction as opi +from archive.array_based import propagation as prop +from copy import deepcopy as copy +TOLERANCE=4 + + +class FarfieldPropagatorUnityTest(unittest.TestCase): + def setUp(self): + self.PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + self.GeoPtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + self.vectorised_scan = du.pod_to_arrays(self.PtychoInstance, 'S0000') + self.pod_vectorised_scan = du.pod_to_arrays(self.GeoPtychoInstance, 'S0000') + self.first_view_id = self.pod_vectorised_scan['meta']['view_IDs'][0] + + def test_fourier_transform_farfield_nofilter_UNITY(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + pod_ew = self.get_exit_wave(self.pod_vectorised_scan) + geo_propagator = copy(self.GeoPtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + + pre_fft = 1.0 + post_fft = 1.0 + + geo_propagator.pre_fft = pre_fft + geo_propagator.post_fft = post_fft + + result_array_npy = prop.farfield_propagator(vec_ew, prefilter=None, postfilter=None) + result_array_geo = self.diffraction_transform_with_geo(geo_propagator, pod_ew) + np.testing.assert_array_almost_equal(result_array_npy, result_array_geo, decimal=TOLERANCE) + + def test_fourier_transform_farfield_with_prefilter_UNITY(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + pod_ew = self.get_exit_wave(self.pod_vectorised_scan) + geo_propagator = copy(self.GeoPtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + + post_fft = 1.0 + + geo_propagator.post_fft = post_fft + + result_array_npy = prop.farfield_propagator(vec_ew, prefilter=propagator.pre_fft, postfilter=None) + result_array_geo = self.diffraction_transform_with_geo(geo_propagator, pod_ew) + np.testing.assert_array_almost_equal(result_array_npy, result_array_geo, decimal=TOLERANCE) + + def test_fourier_transform_farfield_with_postfilter_UNITY(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + pod_ew = self.get_exit_wave(self.pod_vectorised_scan) + geo_propagator = copy(self.GeoPtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + + pre_fft = 1.0 + + geo_propagator.pre_fft = pre_fft + + result_array_npy = prop.farfield_propagator(vec_ew, prefilter=None, postfilter=propagator.post_fft) + result_array_geo = self.diffraction_transform_with_geo(geo_propagator, pod_ew) + np.testing.assert_array_almost_equal(result_array_npy, result_array_geo, decimal=TOLERANCE) + + def test_fourier_transform_farfield_with_pre_and_post_filter_UNITY(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + pod_ew = self.get_exit_wave(self.pod_vectorised_scan) + geo_propagator = copy(self.GeoPtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + + + result_array_npy = prop.farfield_propagator(vec_ew, prefilter=propagator.pre_fft, postfilter=propagator.post_fft) + result_array_geo = self.diffraction_transform_with_geo(geo_propagator, pod_ew) + np.testing.assert_array_almost_equal(result_array_npy, result_array_geo) + + def test_inverse_fourier_transform_farfield_nofilter_UNITY(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + pod_ew = self.get_exit_wave(self.pod_vectorised_scan) + geo_propagator = copy(self.GeoPtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + + pre_ifft = 1.0 + post_ifft = 1.0 + + geo_propagator.pre_ifft = pre_ifft + geo_propagator.post_ifft = post_ifft + + result_array_npy = prop.farfield_propagator(vec_ew, prefilter=None, postfilter=None, direction='backward') + result_array_geo = self.diffraction_transform_with_geo(geo_propagator, pod_ew, direction='backward') + np.testing.assert_array_almost_equal(result_array_npy, result_array_geo, decimal=TOLERANCE) + + def test_inverse_fourier_transform_farfield_with_prefilter_UNITY(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + pod_ew = self.get_exit_wave(self.pod_vectorised_scan) + geo_propagator = copy(self.GeoPtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + + post_ifft = 1.0 + + geo_propagator.post_ifft = post_ifft + + result_array_npy = prop.farfield_propagator(vec_ew, prefilter=propagator.pre_ifft, postfilter=None, direction='backward') + result_array_geo = self.diffraction_transform_with_geo(geo_propagator, pod_ew, direction='backward') + np.testing.assert_array_almost_equal(result_array_npy, result_array_geo, decimal=TOLERANCE) + + def test_inverse_fourier_transform_farfield_with_postfilter_UNITY(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + pod_ew = self.get_exit_wave(self.pod_vectorised_scan) + geo_propagator = copy(self.GeoPtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + + pre_ifft = 1.0 + + geo_propagator.pre_ifft = pre_ifft + + result_array_npy = prop.farfield_propagator(vec_ew, prefilter=None, postfilter=propagator.post_ifft, direction='backward') + result_array_geo = self.diffraction_transform_with_geo(geo_propagator, pod_ew, direction='backward') + np.testing.assert_array_almost_equal(result_array_npy, result_array_geo, decimal=TOLERANCE) + + def test_inverse_fourier_transform_farfield_with_pre_and_post_filter_UNITY(self): + vec_ew = self.get_exit_wave(self.vectorised_scan) + pod_ew = self.get_exit_wave(self.pod_vectorised_scan) + geo_propagator = copy(self.GeoPtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + propagator = copy(self.PtychoInstance.di.V[self.first_view_id].pod.geometry.propagator) + + + result_array_npy = prop.farfield_propagator(vec_ew, prefilter=propagator.pre_ifft, postfilter=propagator.post_ifft, direction='backward') + result_array_geo = self.diffraction_transform_with_geo(geo_propagator, pod_ew, direction='backward') + np.testing.assert_array_almost_equal(result_array_npy, result_array_geo, decimal=TOLERANCE) + + + def get_exit_wave(self, a_vectorised_scan): + ''' + a pretested method + :param a_vectorised_scan: A scan that has been vectorised. + :return: the exit wave + ''' + vec_addr_info = a_vectorised_scan['meta']['addr'] + vec_probe = a_vectorised_scan['probe'] + vec_obj = a_vectorised_scan['obj'] + vec_ew = a_vectorised_scan['exit wave'] + return opi.scan_and_multiply(vec_probe, + vec_obj, + vec_ew.shape, + vec_addr_info) + + + def diffraction_transform_with_geo(self, propagator, ew, direction='forward'): + result_array_geo = np.zeros_like(ew) + meta = self.pod_vectorised_scan['meta'] # probably want to extract these at a later date, but just to get stuff going... + addr_info = meta['addr'] # addresses, object references + for _pa, _oa, ea, _da, _ma in addr_info: + if direction=='forward': + result_array_geo[ea[0]] = propagator.fw(ew[ea[0]]) + else: + result_array_geo[ea[0]] = propagator.bw(ew[ea[0]]) + return result_array_geo + + +# + +if __name__ == "__main__": + unittest.main() diff --git a/test/archive_tests/array_based_tests/object_probe_interaction_regression_test.py b/test/archive_tests/array_based_tests/object_probe_interaction_regression_test.py new file mode 100644 index 000000000..06b607bea --- /dev/null +++ b/test/archive_tests/array_based_tests/object_probe_interaction_regression_test.py @@ -0,0 +1,1303 @@ +''' +tests for the object-probe interactions, including the specific DM, ePIE etc updates + +''' + +import unittest +import numpy as np +from test.archive_tests.array_based_tests import utils as tu +from copy import deepcopy +from ptypy.accelerate.array_based import COMPLEX_TYPE, FLOAT_TYPE +from ptypy.accelerate.array_based import data_utils as du +from ptypy.accelerate.array_based import object_probe_interaction as opi + + + +class ObjectProbeInteractionRegressionTest(unittest.TestCase): + def test_scan_and_multiply(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + # now convert to arrays + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + exit_wave = vectorised_scan['exit wave'] + blank = np.ones_like(probe) + po = opi.scan_and_multiply(blank, obj, exit_wave.shape, addr_info) + + for idx, p in enumerate(iter(PtychoInstance.pods.values())): + np.testing.assert_array_equal(po[idx], p.object) + + def test_exit_wave_calculation(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + # now convert to arrays + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + exit_wave = vectorised_scan['exit wave'] + + po = opi.scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + for idx, p in enumerate(iter(PtychoInstance.pods.values())): + np.testing.assert_array_equal(po[idx], p.object * p.probe) + + def test_difference_map_realspace_constraint(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + # now convert to arrays + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + exit_wave = vectorised_scan['exit wave'] + probe_and_object = opi.scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + + opi.difference_map_realspace_constraint(probe_and_object, + exit_wave, + alpha=1.0) + + def test_extract_array_from_exit_wave_regression_case_a(self): + # two cases for this a) the array to be updated is bigger than the extracted array (which is the same size as the exit wave) + # b) the other way round + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + extract_addr[:, 1] = np.zeros((A,)) + extract_addr[:, 2] = np.zeros((A,)) + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + update_addr[index::scan_pts ** 2, 1] = X + update_addr[index::scan_pts ** 2, 2] = Y + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + opi.extract_array_from_exit_wave(exit_wave, exit_addr, array_to_be_extracted, extract_addr, array_to_be_updated, + update_addr, cfact, weights) + + expected = np.array([[-9.50000000 + 0.5j, 0.20000000 + 0.2j], + [-9.50000000 + 0.5j, 4.80952406 + 0.04761905j], + [-9.50000000 + 0.5j, 4.80952406 + 0.04761905j], + [-9.50000000 + 0.5j, 4.80952406 + 0.04761905j], + [-9.50000000 + 0.5j, 4.80952406 + 0.04761905j], + [0.10000000 + 0.1j, 4.80952406 + 0.04761905j], + [0.10000000 + 0.1j, 0.20000000 + 0.2j]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(np.diagonal(array_to_be_updated), + expected, + err_msg="The array has not been extracted properly from the exit wave.") + + def test_extract_array_from_exit_wave_regression_case_b(self): + # two cases for this a) the array to be updated is bigger than the extracted array (which is the same size as the exit wave) + # b) the other way round + # + npts_greater_than = 2 + B = 5 + C = 5 + + D = 2 + E = C + npts_greater_than + F = C + npts_greater_than + + G = 2 + H = B + I = C + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + extract_addr[index::scan_pts ** 2, 1] = X + extract_addr[index::scan_pts ** 2, 2] = Y + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + update_addr[:, 1] = np.zeros((A,)) + update_addr[:, 2] = np.zeros((A,)) + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + opi.extract_array_from_exit_wave(exit_wave, exit_addr, array_to_be_extracted, extract_addr, + array_to_be_updated, + update_addr, cfact, weights) + + expected = np.array([[11.83333397 - 0.16666667j, 4.80952406 + 0.04761905j], + [11.83333397 - 0.16666667j, 4.80952406 + 0.04761905j], + [11.83333397 - 0.16666667j, 4.80952406 + 0.04761905j], + [11.83333397 - 0.16666667j, 4.80952406 + 0.04761905j], + [11.83333397 - 0.16666667j, 4.80952406 + 0.04761905j]], + dtype=COMPLEX_TYPE) + np.testing.assert_array_equal(expected, np.diagonal(array_to_be_updated)) + + def test_difference_map_update_probe_regression_with_support(self): + ''' + This tests difference_map_update_probe, which wraps extract_array_from_exit_wave + ''' + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + extract_addr[:, 1] = np.zeros((A,)) + extract_addr[:, 2] = np.zeros((A,)) + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + update_addr[index::scan_pts ** 2, 1] = X + update_addr[index::scan_pts ** 2, 2] = Y + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + dummy_addr = np.zeros_like(extract_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(update_addr, extract_addr, exit_addr, dummy_addr, dummy_addr)) + probe_support = np.ones_like(array_to_be_updated) * 100.0 + #(ob, probe_weights, probe, exit_wave, addr_info, cfact_probe, probe_support = None) + opi.difference_map_update_probe(array_to_be_extracted, weights, array_to_be_updated, exit_wave, addr_info, cfact, probe_support=probe_support) + expected_output = np.array([[-500.00000000 + 500.j, 400.00000000 + 400.j], + [-500.00000000 + 500.j, 571.42858887 + 95.23809814j], + [-500.00000000 + 500.j, 571.42858887 + 95.23809814j], + [-500.00000000 + 500.j, 571.42858887 + 95.23809814j], + [-500.00000000 + 500.j, 571.42858887 + 95.23809814j], + [100.00000000 + 100.j, 571.42858887 + 95.23809814j], + [100.00000000 + 100.j, 400.00000000 + 400.j]], dtype=COMPLEX_TYPE) + np.testing.assert_array_equal(np.diagonal(array_to_be_updated), expected_output) + + def test_difference_map_update_probe_regression_without_support(self): + ''' + This tests difference_map_update_probe, which wraps extract_array_from_exit_wave + ''' + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + extract_addr[:, 1] = np.zeros((A,)) + extract_addr[:, 2] = np.zeros((A,)) + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + update_addr[index::scan_pts ** 2, 1] = X + update_addr[index::scan_pts ** 2, 2] = Y + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + dummy_addr = np.zeros_like(extract_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(update_addr, extract_addr, exit_addr, dummy_addr, dummy_addr)) + #(ob, probe_weights, probe, exit_wave, addr_info, cfact_probe, probe_support = None) + opi.difference_map_update_probe(array_to_be_extracted, weights, array_to_be_updated, exit_wave, addr_info, cfact, probe_support=None) + + expected_output = np.array([[-5.00000000+5.j, 4.00000000+4.j], + [-5.00000000+5.j, 5.71428585+0.95238096j], + [-5.00000000+5.j, 5.71428585+0.95238096j], + [-5.00000000+5.j, 5.71428585+0.95238096j], + [-5.00000000+5.j, 5.71428585+0.95238096j], + [ 1.00000000+1.j, 5.71428585+0.95238096j], + [ 1.00000000+1.j, 4.00000000+4.j]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(np.diagonal(array_to_be_updated), expected_output) + + + def test_difference_map_update_object_with_no_smooth_or_clip_regression(self): + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + extract_addr[:, 1] = np.zeros((A,)) + extract_addr[:, 2] = np.zeros((A,)) + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + update_addr[index::scan_pts ** 2, 1] = X + update_addr[index::scan_pts ** 2, 2] = Y + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + dummy_addr = np.zeros_like(extract_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(extract_addr, update_addr , exit_addr, dummy_addr, dummy_addr)) + + opi.difference_map_update_object(array_to_be_updated, weights, array_to_be_extracted, exit_wave, addr_info, cfact, ob_smooth_std=None, clip_object=None) + expected_output = np.array([[-5.00000000 + 5.j, 4.00000000 + 4.j], + [-5.00000000 + 5.j, 5.71428585 + 0.95238096j], + [-5.00000000 + 5.j, 5.71428585 + 0.95238096j], + [-5.00000000 + 5.j, 5.71428585 + 0.95238096j], + [-5.00000000 + 5.j, 5.71428585 + 0.95238096j], + [1.00000000 + 1.j, 5.71428585 + 0.95238096j], + [1.00000000 + 1.j, 4.00000000 + 4.j]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(np.diagonal(array_to_be_updated), expected_output) + + + def test_difference_map_update_object_with_smooth_but_no_clip_regression(self): + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + extract_addr[:, 1] = np.zeros((A,)) + extract_addr[:, 2] = np.zeros((A,)) + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + update_addr[index::scan_pts ** 2, 1] = X + update_addr[index::scan_pts ** 2, 2] = Y + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + dummy_addr = np.zeros_like(extract_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(extract_addr, update_addr , exit_addr, dummy_addr, dummy_addr)) + obj_smooth_std = 2 # integer + opi.difference_map_update_object(array_to_be_updated, weights, array_to_be_extracted, exit_wave, addr_info, cfact, ob_smooth_std=obj_smooth_std, clip_object=None) + expected_output = np.array([[-5.00000000+5.j, 4.00000000+4.j], + [-5.00000000+5.j, 5.71428585+0.95238096j], + [-5.00000000+5.j, 5.71428585+0.95238096j], + [-5.00000000+5.j, 5.71428585+0.95238096j], + [-5.00000000+5.j, 5.71428585+0.95238096j], + [ 1.00000000+1.j, 5.71428585+0.95238096j], + [ 1.00000000+1.j, 4.00000000+4.j]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(np.diagonal(array_to_be_updated), expected_output) + + @unittest.skip("Not used at the moment.") + def test_difference_map_update_object_with_no_smooth_but_clipping_regression(self): + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + array_to_be_extracted = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + array_to_be_extracted[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + extract_addr = np.empty(shape=(A, 3), dtype=int) + extract_addr[:, 0] = np.array(range(D)).repeat(A / D) + extract_addr[:, 1] = np.zeros((A,)) + extract_addr[:, 2] = np.zeros((A,)) + + array_to_be_updated = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + array_to_be_updated[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + update_addr = np.empty(shape=(A, 3), dtype=int) + update_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + update_addr[index::scan_pts ** 2, 1] = X + update_addr[index::scan_pts ** 2, 2] = Y + + weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + weights[:] = np.linspace(-1, 1, G) + cfact = np.empty_like(array_to_be_updated) + for idx in range(G): + cfact[idx] = np.ones((H, I)) * 10 * (idx + 1) + + dummy_addr = np.zeros_like(extract_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(extract_addr, update_addr , exit_addr, dummy_addr, dummy_addr)) + clip = (0.8, 1.0) + opi.difference_map_update_object(array_to_be_updated, weights, array_to_be_extracted, exit_wave, addr_info, cfact, ob_smooth_std=None, clip_object=clip) + expected_output = np.array([[-0.70710677+0.70710677j, 0.70710677+0.70710683j], + [-0.70710677+0.70710677j, 0.98639393+0.16439897j], + [-0.70710677+0.70710677j, 0.98639393+0.16439897j], + [-0.70710677+0.70710677j, 0.98639393+0.16439897j], + [-0.70710677+0.70710677j, 0.98639393+0.16439897j], + [ 0.70710677+0.70710683j, 0.98639393+0.16439897j], + [ 0.70710677+0.70710683j, 0.70710677+0.70710683j]], dtype=COMPLEX_TYPE) + + np.testing.assert_array_equal(np.diagonal(array_to_be_updated), expected_output) + + def test_center_probe_no_change_regression(self): + npts = 64 + probe = np.zeros((1, npts, npts), dtype=COMPLEX_TYPE) + rad = 10.0 + probe_vals = 2 + 3j + x = np.array(range(npts)) - npts // 2 + X, Y = np.meshgrid(x, x) + Xoff = 5.0 + Yoff = 2.0 + probe[0, (X-Xoff)**2 + (Y-Yoff)**2 < rad**2] = probe_vals + center_tolerance = 10.0 + original_probe = np.copy(probe) + opi.center_probe(probe, center_tolerance) + + np.testing.assert_array_equal(probe, original_probe) + + def test_center_probe_with_change_regression(self): + npts = 64 + probe = np.zeros((1, npts, npts), dtype=COMPLEX_TYPE) + rad = 10.0 + probe_vals = 2 + 3j + x = np.array(range(npts)) - npts // 2 + X, Y = np.meshgrid(x, x) + Xoff = 5.0 + Yoff = 2.0 + probe[0, (X-Xoff)**2 + (Y-Yoff)**2 < rad**2] = probe_vals + center_tolerance = 1.0 + + not_shifted_probe = np.zeros((1, npts, npts), dtype=COMPLEX_TYPE) + not_shifted_probe[0, (X)**2 + (Y)**2 < rad**2] = probe_vals + opi.center_probe(probe, center_tolerance) + np.testing.assert_array_almost_equal(probe, not_shifted_probe, decimal=8) # interpolation obviously won't make this exact! + + def test_difference_map_overlap_update_test_order_of_updates_a(self): + ''' + This tests the order in which the object and probe are updated + ''' + smooth_std = None # anything else currently not supported + max_iterations = 1 + update_object_first = True + do_update_probe = False + # this should mean that the object gets updated but the probe does not change + ocf = 1 # spam this for this test Not needed. + + # create some inputs - I should really make this a utility... + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + probe_addr = np.empty(shape=(A, 3), dtype=int) + probe_addr[:, 0] = np.array(range(D)).repeat(A / D) + probe_addr[:, 1] = np.zeros((A,)) + probe_addr[:, 2] = np.zeros((A,)) + + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + obj[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + obj_addr = np.empty(shape=(A, 3), dtype=int) + obj_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + obj_addr[index::scan_pts ** 2, 1] = X + obj_addr[index::scan_pts ** 2, 2] = Y + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + for idx in range(G): + cfact_probe[idx] = np.ones((E, F)) * 5 * (idx + 1) + + dummy_addr = np.zeros_like(probe_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(probe_addr, obj_addr , exit_addr, dummy_addr, dummy_addr)) + + original_probe = deepcopy(probe) + expected_object=np.array([[[-5.00000000+5.j,-5.00000000+5.j,-5.00000000+5.j, + -5.00000000+5.j,-5.00000000+5.j,1.00000000+1.j,1.00000000+1.j], + [10.33333397-1.66666675j,10.33333397-1.66666675j, + 10.33333397-1.66666675j,10.33333397-1.66666675j, + 10.33333397-1.66666675j,1.00000000+1.j,1.00000000+1.j], + [10.33333397-1.66666675j,10.33333397-1.66666675j, + 10.33333397-1.66666675j,10.33333397-1.66666675j, + 10.33333397-1.66666675j,1.00000000+1.j,1.00000000+1.j], + [10.33333397-1.66666675j,10.33333397-1.66666675j, + 10.33333397-1.66666675j,10.33333397-1.66666675j, + 10.33333397-1.66666675j,1.00000000+1.j,1.00000000+1.j], + [10.33333397-1.66666675j,10.33333397-1.66666675j, + 10.33333397-1.66666675j,10.33333397-1.66666675j, + 10.33333397-1.66666675j,1.00000000+1.j,1.00000000+1.j], + [-21.00000000+5.j,-21.00000000+5.j,-21.00000000+5.j, + -21.00000000+5.j,-21.00000000+5.j,1.00000000+1.j, + 1.00000000+1.j], + [1.00000000+1.j,1.00000000+1.j,1.00000000+1.j, + 1.00000000+1.j,1.00000000+1.j,1.00000000+1.j, + 1.00000000+1.j]], + + [[4.00000000+4.j,4.76923084+1.53846157j, + 4.76923084+1.53846157j,4.76923084+1.53846157j, + 4.76923084+1.53846157j,4.76923084+1.53846157j,4.00000000+4.j], + [4.00000000+4.j,5.71428585+0.95238096j, + 5.71428585+0.95238096j,5.71428585+0.95238096j, + 5.71428585+0.95238096j,5.71428585+0.95238096j,4.00000000+4.j], + [4.00000000+4.j,5.71428585+0.95238096j, + 5.71428585+0.95238096j,5.71428585+0.95238096j, + 5.71428585+0.95238096j,5.71428585+0.95238096j,4.00000000+4.j], + [4.00000000+4.j,5.71428585+0.95238096j, + 5.71428585+0.95238096j,5.71428585+0.95238096j, + 5.71428585+0.95238096j,5.71428585+0.95238096j,4.00000000+4.j], + [4.00000000+4.j,5.71428585+0.95238096j, + 5.71428585+0.95238096j,5.71428585+0.95238096j, + 5.71428585+0.95238096j,5.71428585+0.95238096j,4.00000000+4.j], + [4.00000000+4.j,6.00000000+1.53846157j, + 6.00000000+1.53846157j,6.00000000+1.53846157j, + 6.00000000+1.53846157j,6.00000000+1.53846157j,4.00000000+4.j], + [4.00000000+4.j,4.00000000+4.j,4.00000000+4.j, + 4.00000000+4.j,4.00000000+4.j,4.00000000+4.j, + 4.00000000+4.j]]], dtype=COMPLEX_TYPE) + + opi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=obj, + object_weights=obj_weights, + probe=probe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + np.testing.assert_array_equal(original_probe, + probe, + err_msg="The probe has been updated when it shouldn't have been.") + np.testing.assert_array_equal(expected_object, + obj, + err_msg="The object has not been updated correctly.") + + + def test_difference_map_overlap_update_test_order_of_updates_b(self): + ''' + This tests the order in which the object and probe are updated + ''' + + smooth_std = None # anything else currently not supported + max_iterations = 1 + update_object_first = False + do_update_probe = True + # This should mean that the probe is updated, but not the object since max_iterations=1 + ocf = 1 # spam this for this test Not needed. + + # create some inputs - I should really make this a utility... + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + probe_addr = np.empty(shape=(A, 3), dtype=int) + probe_addr[:, 0] = np.array(range(D)).repeat(A / D) + probe_addr[:, 1] = np.zeros((A,)) + probe_addr[:, 2] = np.zeros((A,)) + + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + obj[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + obj_addr = np.empty(shape=(A, 3), dtype=int) + obj_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + obj_addr[index::scan_pts ** 2, 1] = X + obj_addr[index::scan_pts ** 2, 2] = Y + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + for idx in range(G): + cfact_probe[idx] = np.ones((E, F)) * 5 * (idx + 1) + + dummy_addr = np.zeros_like(probe_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(probe_addr, obj_addr , exit_addr, dummy_addr, dummy_addr)) + + original_obj = deepcopy(obj) + + expected_probe = np.array([[[ 6.09090948-0.45454547j, 6.09090948-0.45454547j, 6.09090948-0.45454547j, + 6.09090948-0.45454547j, 6.09090948-0.45454547j], + [ 6.09090948-0.45454547j, 6.09090948-0.45454547j, 6.09090948-0.45454547j, + 6.09090948-0.45454547j, 6.09090948-0.45454547j], + [ 6.09090948-0.45454547j, 6.09090948-0.45454547j, 6.09090948-0.45454547j, + 6.09090948-0.45454547j, 6.09090948-0.45454547j], + [ 6.09090948-0.45454547j, 6.09090948-0.45454547j, 6.09090948-0.45454547j, + 6.09090948-0.45454547j, 6.09090948-0.45454547j], + [ 6.09090948-0.45454547j, 6.09090948-0.45454547j, 6.09090948-0.45454547j, + 6.09090948-0.45454547j, 6.09090948-0.45454547j]], + [[ 3.08270693+0.07518797j, 3.08270693+0.07518797j, 3.08270693+0.07518797j, + 3.08270693+0.07518797j, 3.08270693+0.07518797j], + [ 3.08270693+0.07518797j, 3.08270693+0.07518797j, 3.08270693+0.07518797j, + 3.08270693+0.07518797j, 3.08270693+0.07518797j], + [ 3.08270693+0.07518797j, 3.08270693+0.07518797j, 3.08270693+0.07518797j, + 3.08270693+0.07518797j, 3.08270693+0.07518797j], + [ 3.08270693+0.07518797j, 3.08270693+0.07518797j, 3.08270693+0.07518797j, + 3.08270693+0.07518797j, 3.08270693+0.07518797j], + [ 3.08270693+0.07518797j, 3.08270693+0.07518797j, 3.08270693+0.07518797j, + 3.08270693+0.07518797j, 3.08270693+0.07518797j]]], dtype=COMPLEX_TYPE) + + opi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=obj, + object_weights=obj_weights, + probe=probe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + np.testing.assert_array_equal(original_obj, + obj, + err_msg="The object has been updated when it shouldn't have been.") + np.testing.assert_array_equal(expected_probe, + probe, + err_msg="The probe has not been updated correctly.") + + def test_difference_map_overlap_update_test_order_of_updates_c(self): + ''' + This tests the order in which the object and probe are updated + ''' + + smooth_std = None # anything else currently not supported + max_iterations = 1 + update_object_first = False + do_update_probe = False + # neither the probe or the object are updated + ocf = 1 # spam this for this test Not needed. + + # create some inputs - I should really make this a utility... + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + probe_addr = np.empty(shape=(A, 3), dtype=int) + probe_addr[:, 0] = np.array(range(D)).repeat(A / D) + probe_addr[:, 1] = np.zeros((A,)) + probe_addr[:, 2] = np.zeros((A,)) + + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + obj[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + obj_addr = np.empty(shape=(A, 3), dtype=int) + obj_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + obj_addr[index::scan_pts ** 2, 1] = X + obj_addr[index::scan_pts ** 2, 2] = Y + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + for idx in range(G): + cfact_probe[idx] = np.ones((E, F)) * 5 * (idx + 1) + + dummy_addr = np.zeros_like(probe_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(probe_addr, obj_addr , exit_addr, dummy_addr, dummy_addr)) + + original_obj = deepcopy(obj) + original_probe = deepcopy(probe) + + + opi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=obj, + object_weights=obj_weights, + probe=probe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + np.testing.assert_array_equal(original_obj, + obj, + err_msg="The object has been updated when it shouldn't have been.") + np.testing.assert_array_equal(original_probe, + probe, + err_msg="The probe has been updated when it shouldn't have been.") + + def test_difference_map_overlap_update_test_order_of_updates_d(self): + ''' + This tests the order in which the object and probe are updated + ''' + + smooth_std = None # anything else currently not supported + max_iterations = 1 + update_object_first = True + do_update_probe = True + # both the object and the probe are updated + ocf = 1 # spam this for this test Not needed. + + # create some inputs - I should really make this a utility... + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + probe_addr = np.empty(shape=(A, 3), dtype=int) + probe_addr[:, 0] = np.array(range(D)).repeat(A / D) + probe_addr[:, 1] = np.zeros((A,)) + probe_addr[:, 2] = np.zeros((A,)) + + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + obj[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + obj_addr = np.empty(shape=(A, 3), dtype=int) + obj_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + obj_addr[index::scan_pts ** 2, 1] = X + obj_addr[index::scan_pts ** 2, 2] = Y + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + for idx in range(G): + cfact_probe[idx] = np.ones((E, F)) * 5 * (idx + 1) + + dummy_addr = np.zeros_like( + probe_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(probe_addr, obj_addr, exit_addr, dummy_addr, dummy_addr)) + + expected_probe = np.array([[[ 0.34795576+0.32689944j, 0.34795576+0.32689944j, 0.34795576+0.32689944j, + 0.34795576+0.32689944j, 0.34795576+0.32689944j], + [ 0.35228869+0.48999104j, 0.35228869+0.48999104j, 0.35228869+0.48999104j, + 0.35228869+0.48999104j, 0.35228869+0.48999104j], + [ 0.35228869+0.48999104j, 0.35228869+0.48999104j, 0.35228869+0.48999104j, + 0.35228869+0.48999104j, 0.35228869+0.48999104j], + [ 0.35228869+0.48999104j, 0.35228869+0.48999104j, 0.35228869+0.48999104j, + 0.35228869+0.48999104j, 0.35228869+0.48999104j], + [-0.14553808-0.24420798j, -0.14553808-0.24420798j, -0.14553808-0.24420798j, + -0.14553808-0.24420798j, -0.14553808-0.24420798j]], + + [[ 2.74465489+1.76501989j, 2.74465489+1.76501989j, 2.74465489+1.76501989j, + 2.74465489+1.76501989j, 2.74465489+1.76501989j], + [ 2.46576023+1.78177691j, 2.46576023+1.78177691j, 2.46576023+1.78177691j, + 2.46576023+1.78177691j, 2.46576023+1.78177691j], + [ 2.46576023+1.78177691j, 2.46576023+1.78177691j, 2.46576023+1.78177691j, + 2.46576023+1.78177691j, 2.46576023+1.78177691j], + [ 2.46576023+1.78177691j, 2.46576023+1.78177691j, 2.46576023+1.78177691j, + 2.46576023+1.78177691j, 2.46576023+1.78177691j], + [ 2.47635674+1.60818517j, 2.47635674+1.60818517j, 2.47635674+1.60818517j, + 2.47635674+1.60818517j, 2.47635674+1.60818517j]]], dtype=COMPLEX_TYPE) + + expected_object = np.array([[[-5.00000000 + 5.j, -5.00000000 + 5.j, -5.00000000 + 5.j, + -5.00000000 + 5.j, -5.00000000 + 5.j, 1.00000000 + 1.j, 1.00000000 + 1.j], + [10.33333397 - 1.66666675j, 10.33333397 - 1.66666675j, + 10.33333397 - 1.66666675j, 10.33333397 - 1.66666675j, + 10.33333397 - 1.66666675j, 1.00000000 + 1.j, 1.00000000 + 1.j], + [10.33333397 - 1.66666675j, 10.33333397 - 1.66666675j, + 10.33333397 - 1.66666675j, 10.33333397 - 1.66666675j, + 10.33333397 - 1.66666675j, 1.00000000 + 1.j, 1.00000000 + 1.j], + [10.33333397 - 1.66666675j, 10.33333397 - 1.66666675j, + 10.33333397 - 1.66666675j, 10.33333397 - 1.66666675j, + 10.33333397 - 1.66666675j, 1.00000000 + 1.j, 1.00000000 + 1.j], + [10.33333397 - 1.66666675j, 10.33333397 - 1.66666675j, + 10.33333397 - 1.66666675j, 10.33333397 - 1.66666675j, + 10.33333397 - 1.66666675j, 1.00000000 + 1.j, 1.00000000 + 1.j], + [-21.00000000 + 5.j, -21.00000000 + 5.j, -21.00000000 + 5.j, + -21.00000000 + 5.j, -21.00000000 + 5.j, 1.00000000 + 1.j, + 1.00000000 + 1.j], + [1.00000000 + 1.j, 1.00000000 + 1.j, 1.00000000 + 1.j, + 1.00000000 + 1.j, 1.00000000 + 1.j, 1.00000000 + 1.j, + 1.00000000 + 1.j]], + + [[4.00000000 + 4.j, 4.76923084 + 1.53846157j, + 4.76923084 + 1.53846157j, 4.76923084 + 1.53846157j, + 4.76923084 + 1.53846157j, 4.76923084 + 1.53846157j, 4.00000000 + 4.j], + [4.00000000 + 4.j, 5.71428585 + 0.95238096j, + 5.71428585 + 0.95238096j, 5.71428585 + 0.95238096j, + 5.71428585 + 0.95238096j, 5.71428585 + 0.95238096j, 4.00000000 + 4.j], + [4.00000000 + 4.j, 5.71428585 + 0.95238096j, + 5.71428585 + 0.95238096j, 5.71428585 + 0.95238096j, + 5.71428585 + 0.95238096j, 5.71428585 + 0.95238096j, 4.00000000 + 4.j], + [4.00000000 + 4.j, 5.71428585 + 0.95238096j, + 5.71428585 + 0.95238096j, 5.71428585 + 0.95238096j, + 5.71428585 + 0.95238096j, 5.71428585 + 0.95238096j, 4.00000000 + 4.j], + [4.00000000 + 4.j, 5.71428585 + 0.95238096j, + 5.71428585 + 0.95238096j, 5.71428585 + 0.95238096j, + 5.71428585 + 0.95238096j, 5.71428585 + 0.95238096j, 4.00000000 + 4.j], + [4.00000000 + 4.j, 6.00000000 + 1.53846157j, + 6.00000000 + 1.53846157j, 6.00000000 + 1.53846157j, + 6.00000000 + 1.53846157j, 6.00000000 + 1.53846157j, 4.00000000 + 4.j], + [4.00000000 + 4.j, 4.00000000 + 4.j, 4.00000000 + 4.j, + 4.00000000 + 4.j, 4.00000000 + 4.j, 4.00000000 + 4.j, + 4.00000000 + 4.j]]], dtype=COMPLEX_TYPE) + + opi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=obj, + object_weights=obj_weights, + probe=probe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + np.testing.assert_array_equal(expected_probe, + probe, + err_msg="The probe has been updated when it shouldn't have been.") + np.testing.assert_array_equal(expected_object, + obj, + err_msg="The object has not been updated correctly.") + + + + + def test_difference_map_overlap_update_break_when_in_tolerance(self): + ''' + This tests if the loop breaks according to the convergence criterion. + ''' + + + smooth_std = None # anything else currently not supported + max_iterations = 100 + update_object_first = False + do_update_probe = True + # both the object and the probe are updated + ocf = 4.2e-2 # chosen so that this should terminate on teh 6th iteration + + # create some inputs - I should really make this a utility... + B = 5 + C = 5 + + D = 2 + E = B + F = C + + npts_greater_than = 2 + G = 2 + H = B + npts_greater_than + I = C + npts_greater_than + + scan_pts = 2 + A = scan_pts ** 2 * G * D # this is a 16 point scan pattern (4x4 grid) over all the modes + + # shapes and types outlined here + exit_wave = np.empty(shape=(A, B, C), dtype=COMPLEX_TYPE) + for idx in range(A): + exit_wave[idx] = np.ones((B, C)) * (idx + 1) + 1j * np.ones((B, C)) * (idx + 1) + + exit_addr = np.empty(shape=(A, 3), dtype=int) + exit_addr[:, 0] = np.array(range(A)) + exit_addr[:, 1] = np.zeros((A,)) + exit_addr[:, 2] = np.zeros((A,)) + + probe = np.empty(shape=(D, E, F), dtype=COMPLEX_TYPE) + for idx in range(D): + probe[idx] = np.ones((E, F)) * (idx + 1) + 1j * np.ones((E, F)) * (idx + 1) + probe_addr = np.empty(shape=(A, 3), dtype=int) + probe_addr[:, 0] = np.array(range(D)).repeat(A / D) + probe_addr[:, 1] = np.zeros((A,)) + probe_addr[:, 2] = np.zeros((A,)) + + obj = np.empty(shape=(G, H, I), dtype=COMPLEX_TYPE) + for idx in range(G): + obj[idx] = np.ones((H, I)) * (3 * idx + 1) + 1j * np.ones((H, I)) * (3 * idx + 1) + obj_addr = np.empty(shape=(A, 3), dtype=int) + obj_addr[:, 0] = np.array(range(G)).repeat(A / G) + X, Y = np.meshgrid(range(scan_pts), range(scan_pts)) + X = X.reshape((scan_pts ** 2)) + Y = Y.reshape((scan_pts ** 2)) + for idx in range(G): + for idy in range(D): + index = idy + 2 * idx + obj_addr[index::scan_pts ** 2, 1] = X + obj_addr[index::scan_pts ** 2, 2] = Y + + obj_weights = np.empty(shape=(G,), dtype=FLOAT_TYPE) + obj_weights[:] = np.linspace(-1, 1, G) + + probe_weights = np.empty(shape=(D,), dtype=FLOAT_TYPE) + probe_weights[:] = np.linspace(-1, 1, D) + + cfact_object = np.empty_like(obj) + for idx in range(G): + cfact_object[idx] = np.ones((H, I)) * 10 * (idx + 1) + + cfact_probe = np.empty_like(probe) + for idx in range(G): + cfact_probe[idx] = np.ones((E, F)) * 5 * (idx + 1) + + dummy_addr = np.zeros_like(probe_addr) # these aren't used by the function, but are passed as a top level address book + addr_info = list(zip(probe_addr, obj_addr, exit_addr, dummy_addr, dummy_addr)) + + expected_probe = np.array([[[ 45.64985275-4.16102743j, 45.64985275-4.16102743j, + 45.64985275-4.16102743j, 45.64985275-4.16102743j, + 45.64985275-4.16102743j], + [ -9.70029163+0.79768848j, -9.70029163+0.79768848j, + -9.70029163+0.79768848j, -9.70029163+0.79768848j, + -9.70029163+0.79768848j], + [ 4.76249838-0.31339467j, 4.76249838-0.31339467j, + 4.76249838-0.31339467j, 4.76249838-0.31339467j, + 4.76249838-0.31339467j], + [ 3.71407413-0.28579614j, 3.71407413-0.28579614j, + 3.71407413-0.28579614j, 3.71407413-0.28579614j, + 3.71407413-0.28579614j], + [ 2.35006571-0.19345209j, 2.35006571-0.19345209j, + 2.35006571-0.19345209j, 2.35006571-0.19345209j, + 2.35006571-0.19345209j]], + + [[ 3.99001932+0.07404561j, 3.99001932+0.07404561j, + 3.99001932+0.07404561j, 3.99001932+0.07404561j, + 3.99001932+0.07404561j], + [ 3.36987257+0.06362584j, 3.36987257+0.06362584j, + 3.36987257+0.06362584j, 3.36987257+0.06362584j, + 3.36987257+0.06362584j], + [ 3.10962296+0.05934116j, 3.10962296+0.05934116j, + 3.10962296+0.05934116j, 3.10962296+0.05934116j, + 3.10962296+0.05934116j], + [ 2.90126610+0.05487255j, 2.90126610+0.05487255j, + 2.90126610+0.05487255j, 2.90126610+0.05487255j, + 2.90126610+0.05487255j], + [ 2.51116419+0.04660653j, 2.51116419+0.04660653j, + 2.51116419+0.04660653j, 2.51116419+0.04660653j, + 2.51116419+0.04660653j]]], dtype=COMPLEX_TYPE) + + expected_object=np.array([[[ 0.04918606+0.05905421j, 0.04918606+0.05905421j, 0.04918606+0.05905421j, + 0.04918606+0.05905421j, 0.04918606+0.05905421j, 1.00000000+1.j, 1.00000000+1.j], + [ 0.11200862+0.13464974j, 0.11200862+0.13464974j, 0.11200862+0.13464974j, + 0.11200862+0.13464974j, 0.11200862+0.13464974j, 1.00000000+1.j,1.00000000+1.j], + [-0.51355976-0.61082107j, -0.51355976-0.61082107j, -0.51355976-0.61082107j, + -0.51355976-0.61082107j, -0.51355976-0.61082107j, 1.00000000+1.j, 1.00000000+1.j], + [ 0.99391210+1.14208853j, 0.99391210+1.14208853j, 0.99391210+1.14208853j, + 0.99391210+1.14208853j, 0.99391210+1.14208853j, 1.00000000+1.j, 1.00000000+1.j], + [ 1.22169828+1.43459976j, 1.22169828+1.43459976j, 1.22169828+1.43459976j, + 1.22169828+1.43459976j, 1.22169828+1.43459976j, 1.00000000+1.j, 1.00000000+1.j], + [ 2.36522031+2.79235673j, 2.36522031+2.79235673j, 2.36522031+2.79235673j, + 2.36522031+2.79235673j, 2.36522031+2.79235673j, 1.00000000+1.j,1.00000000+1.j], + [ 1.00000000+1.j, 1.00000000+1.j, 1.00000000+1.j, + 1.00000000+1.j, 1.00000000+1.j, 1.00000000+1.j, 1.00000000+1.j ]], + [[ 4.00000000+4.j, 2.80242014+2.70098448j, 2.80242014+2.70098448j, + 2.80242014+2.70098448j, 2.80242014+2.70098448j, 2.80242014+2.70098448j, + 4.00000000+4.j], + [ 4.00000000+4.j, 3.59294462+3.46147537j, 3.59294462+3.46147537j, + 3.59294462+3.46147537j, 3.59294462+3.46147537j, 3.59294462+3.46147537j, + 4.00000000+4.j], + [ 4.00000000+4.j, 3.99926472+3.8498373j, 3.99926472+3.8498373j, + 3.99926472+3.8498373j, 3.99926472+3.8498373j, 3.99926472+3.8498373j, + 4.00000000+4.j], + [ 4.00000000+4.j, 4.21914482+4.06092405j, 4.21914482+4.06092405j, + 4.21914482+4.06092405j, 4.21914482+4.06092405j, 4.21914482+4.06092405j, + 4.00000000+4.j], + [ 4.00000000+4.j, 4.60679293+4.43693876j, 4.60679293+4.43693876j, + 4.60679293+4.43693876j, 4.60679293+4.43693876j, 4.60679293+4.43693876j, + 4.00000000+4.j], + [ 4.00000000+4.j, 5.59837151+5.39574909j, 5.59837151+5.39574909j, + 5.59837151+5.39574909j, 5.59837151+5.39574909j, 5.59837151+5.39574909j, + 4.00000000+4.j], + [ 4.00000000+4.j, 4.00000000+4.j, 4.00000000+4.j, + 4.00000000+4.j, 4.00000000+4.j, 4.00000000+4.j, + 4.00000000+4.j]]] ,dtype=COMPLEX_TYPE) + + opi.difference_map_overlap_update(addr_info=addr_info, + cfact_object=cfact_object, + cfact_probe=cfact_probe, + do_update_probe=do_update_probe, + exit_wave=exit_wave, + ob=obj, + object_weights=obj_weights, + probe=probe, + probe_support=None, + probe_weights=probe_weights, + max_iterations=max_iterations, + update_object_first=update_object_first, + obj_smooth_std=smooth_std, + overlap_converge_factor=ocf, + probe_center_tol=None, + clip_object=None) + + + + np.testing.assert_allclose(expected_probe, + probe, + err_msg="The probe has not been updated correctly") + + print(obj) + np.testing.assert_allclose(expected_object, + obj, + err_msg="The object has not been updated correctly.") + + + if __name__ == "__main__": + unittest.main() diff --git a/test/archive_tests/array_based_tests/object_probe_interaction_unity_test.py b/test/archive_tests/array_based_tests/object_probe_interaction_unity_test.py new file mode 100644 index 000000000..06ee40196 --- /dev/null +++ b/test/archive_tests/array_based_tests/object_probe_interaction_unity_test.py @@ -0,0 +1,44 @@ +''' +This is a unity test comparing to the pod based framework +''' + +import unittest +import numpy as np +from test.archive_tests.array_based_tests import utils as tu +from ptypy.accelerate.array_based import data_utils as du +from ptypy.accelerate.array_based import object_probe_interaction as opi +from collections import OrderedDict + + +class ObjectProbeInteractionUnityTest(unittest.TestCase): + + def test_difference_map_realspace_constraint_UNITY(self): + PtychoInstance = tu.get_ptycho_instance('pod_to_numpy_test') + a_ptycho_instance = tu.get_ptycho_instance('pod_to_numpy_test') + # now convert to arrays + vectorised_scan = du.pod_to_arrays(PtychoInstance, 'S0000') + addr_info = vectorised_scan['meta']['addr'] # probably want to extract these at a later date, but just to get stuff going... + probe = vectorised_scan['probe'] + obj = vectorised_scan['obj'] + exit_wave = vectorised_scan['exit wave'] + probe_and_object = opi.scan_and_multiply(probe, obj, exit_wave.shape, addr_info) + + ptypy_dm_constraint = self.ptypy_apply_difference_map(a_ptycho_instance) + numpy_dm_constraint = opi.difference_map_realspace_constraint(probe_and_object, + exit_wave, + alpha=1.0) + for idx, key in enumerate(ptypy_dm_constraint): + np.testing.assert_allclose(ptypy_dm_constraint[key], numpy_dm_constraint[idx]) + + def ptypy_apply_difference_map(self, a_ptycho_instance): + f = OrderedDict() + alpha = 1.0 + for dname, diff_view in a_ptycho_instance.diff.views.items(): + for name, pod in diff_view.pods.items(): + if not pod.active: + continue + f[name] = (1 + alpha) * pod.probe * pod.object - alpha * pod.exit + return f + + if __name__ == "__main__": + unittest.main() diff --git a/test/archive_tests/array_based_tests/utils.py b/test/archive_tests/array_based_tests/utils.py new file mode 100644 index 000000000..42d638a2a --- /dev/null +++ b/test/archive_tests/array_based_tests/utils.py @@ -0,0 +1,66 @@ +''' +Created on 4 Jan 2018 + +@author: clb02321 +''' +import unittest +from ptypy.core import Ptycho +from ptypy import utils as u + + +def get_ptycho_instance(label=None, num_modes=1, size=64, length=8): + ''' + new ptypy probably has a better way of doing this. + ''' + p = u.Param() + p.verbose_level = 0 + p.data_type = "single" + p.run = label + p.io = u.Param() + p.io.home = "/tmp/ptypy/" + p.io.interaction = u.Param(active=False) + p.io.autoplot = u.Param(active=False) + p.scans = u.Param() + p.scans.MF = u.Param() + p.scans.MF.name = 'Full' + p.scans.MF.propagation = 'farfield' + p.scans.MF.data = u.Param() + p.scans.MF.data.name = 'MoonFlowerScan' + p.scans.MF.data.positions_theory = None + p.scans.MF.data.auto_center = None + p.scans.MF.data.min_frames = 1 + p.scans.MF.data.orientation = None + p.scans.MF.data.num_frames =length + p.scans.MF.data.energy = 6.2 + p.scans.MF.data.shape = size + p.scans.MF.data.chunk_format = '.chunk%02d' + p.scans.MF.data.rebin = None + p.scans.MF.data.experimentID = None + p.scans.MF.data.label = None + p.scans.MF.data.version = 0.1 + p.scans.MF.data.dfile = None + p.scans.MF.data.psize = 0.000172 + p.scans.MF.data.load_parallel = None + p.scans.MF.data.distance = 7.0 + p.scans.MF.data.save = None + p.scans.MF.data.center = 'fftshift' + p.scans.MF.data.photons = 100000000.0 + p.scans.MF.data.psf = 0.0 + p.scans.MF.data.add_poisson_noise = False + p.scans.MF.data.density = 0.2 + p.scans.MF.illumination = u.Param() + p.scans.MF.illumination.model = None + p.scans.MF.illumination.aperture = u.Param() + p.scans.MF.illumination.aperture.diffuser = None + p.scans.MF.illumination.aperture.form = "circ" + p.scans.MF.illumination.aperture.size = 3e-6 + p.scans.MF.illumination.aperture.edge = 10 + p.scans.MF.coherence = u.Param() + p.scans.MF.coherence.num_probe_modes = num_modes + P = Ptycho(p, level=4) + P.di = P.diff + P.ma = P.mask + P.ex = P.exit + P.pr = P.probe + P.ob = P.obj + return P diff --git a/test/archive_tests/dls_tests/__init__.py b/test/archive_tests/dls_tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test/archive_tests/dls_tests/dls_auxiliary_wave_kernel_test.py b/test/archive_tests/dls_tests/dls_auxiliary_wave_kernel_test.py new file mode 100644 index 000000000..0d943c28e --- /dev/null +++ b/test/archive_tests/dls_tests/dls_auxiliary_wave_kernel_test.py @@ -0,0 +1,57 @@ +''' +Testing based on real data +''' +import h5py +import unittest +import numpy as np +from parameterized import parameterized +from .. import perfrun, PyCudaTest, have_pycuda + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.kernels import AuxiliaryWaveKernel +from ptypy.accelerate.base.kernels import AuxiliaryWaveKernel as BaseAuxiliaryWaveKernel + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +class DlsAuxiliaryWaveKernelTest(PyCudaTest): + + datadir = "/dls/science/users/iat69393/gpu-hackathon/test-data-%s/" + rtol = 1e-6 + atol = 1e-6 + + @parameterized.expand([ + ["base", 10], + ["regul", 50], + ["floating", 0], + ]) + def test_build_aux_no_ex_noadd_UNITY(self, name, iter): + + # Load data + with h5py.File(self.datadir % name + "build_aux_no_ex_%04d.h5" %iter, "r") as f: + aux = f["aux"][:] + addr = f["addr"][:] + ob = f["ob"][:] + pr = f["pr"][:] + + # Copy data to device + aux_dev = gpuarray.to_gpu(aux) + addr_dev = gpuarray.to_gpu(addr) + ob_dev = gpuarray.to_gpu(ob) + pr_dev = gpuarray.to_gpu(pr) + + # CPU kernel + BAWK = BaseAuxiliaryWaveKernel() + BAWK.allocate() + BAWK.build_aux_no_ex(aux, addr, ob, pr, add=False) + + ## GPU kernel + AWK = AuxiliaryWaveKernel(self.stream) + AWK.allocate() + AWK.build_aux_no_ex(aux_dev, addr_dev, ob_dev, pr_dev, add=False) + + ## Assert + np.testing.assert_allclose(aux_dev.get(), aux, rtol=self.rtol, atol=self.atol, + err_msg="The auxiliary_wave does not match the base kernel output") \ No newline at end of file diff --git a/test/archive_tests/dls_tests/dls_drpycuda_test.py b/test/archive_tests/dls_tests/dls_drpycuda_test.py new file mode 100644 index 000000000..57f62f9dd --- /dev/null +++ b/test/archive_tests/dls_tests/dls_drpycuda_test.py @@ -0,0 +1,83 @@ +''' +Testing on real data +''' + +import h5py +import unittest +import numpy as np +from parameterized import parameterized +from .. import PyCudaTest, have_pycuda + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.kernels import PoUpdateKernel +from ptypy.accelerate.base.kernels import PoUpdateKernel as BasePoUpdateKernel + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +class DlsDRpycudaTest(PyCudaTest): + + datadir = "/dls/science/users/iat69393/gpu-hackathon/test-data-dr/" + iter = 0 + rtol = 1e-6 + atol = 1e-6 + + def test_ob_update_local_UNITY(self): + + # Load data + with h5py.File(self.datadir + "ob_update_local_%04d.h5" %self.iter, "r") as f: + aux = f["aux"][:] + addr = f["addr"][:] + ob = f["ob"][:] + pr = f["pr"][:] + ex = f["ex"][:] + + # Copy data to device + aux_dev = gpuarray.to_gpu(aux) + ob_dev = gpuarray.to_gpu(ob) + pr_dev = gpuarray.to_gpu(pr) + ex_dev = gpuarray.to_gpu(ex) + addr_dev = gpuarray.to_gpu(addr) + + # CPU Kernel + BPOK = BasePoUpdateKernel() + BPOK.ob_update_local(addr, ob, pr, ex, aux) + + # GPU Kernel + POK = PoUpdateKernel() + POK.ob_update_local(addr_dev, ob_dev, pr_dev, ex_dev, aux_dev) + + ## Assert + np.testing.assert_allclose(ob_dev.get(), ob, atol=self.atol, rtol=self.rtol, verbose=False, + err_msg="The object array has not been updated as expected") + + def test_pr_update_local_UNITY(self): + + # Load data + with h5py.File(self.datadir + "pr_update_local_%04d.h5" %self.iter, "r") as f: + aux = f["aux"][:] + addr = f["addr"][:] + ob = f["ob"][:] + pr = f["pr"][:] + ex = f["ex"][:] + + # Copy data to device + aux_dev = gpuarray.to_gpu(aux) + ob_dev = gpuarray.to_gpu(ob) + pr_dev = gpuarray.to_gpu(pr) + ex_dev = gpuarray.to_gpu(ex) + addr_dev = gpuarray.to_gpu(addr) + + # CPU Kernel + BPOK = BasePoUpdateKernel() + BPOK.pr_update_local(addr, pr, ob, ex, aux) + + # GPU Kernel + POK = PoUpdateKernel() + POK.pr_update_local(addr_dev, pr_dev, ob_dev, ex_dev, aux_dev) + + ## Assert + np.testing.assert_allclose(pr_dev.get(), pr, atol=self.atol, rtol=self.rtol, verbose=False, + err_msg="The object array has not been updated as expected") diff --git a/test/archive_tests/dls_tests/dls_gradient_descent_kernel_test.py b/test/archive_tests/dls_tests/dls_gradient_descent_kernel_test.py new file mode 100644 index 000000000..f62834e2e --- /dev/null +++ b/test/archive_tests/dls_tests/dls_gradient_descent_kernel_test.py @@ -0,0 +1,261 @@ +''' +Testing on real data +''' + +import h5py +import unittest +import numpy as np +from parameterized import parameterized +from .. import perfrun, PyCudaTest, have_pycuda + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.kernels import GradientDescentKernel +from ptypy.accelerate.base.kernels import GradientDescentKernel as BaseGradientDescentKernel + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +class DlsGradientDescentKernelTest(PyCudaTest): + + datadir = "/dls/science/users/iat69393/gpu-hackathon/test-data-%s/" + rtol = 1e-6 + atol = 1e-6 + + @parameterized.expand([ + ["base", 10], + ["regul", 50], + ["floating", 0], + ]) + def test_make_model_UNITY(self, name, iter): + + # Load data + with h5py.File(self.datadir %name + "make_model_%04d.h5" %iter, "r") as f: + aux = f["aux"][:] + addr = f["addr"][:] + + # Copy data to device + aux_dev = gpuarray.to_gpu(aux) + addr_dev = gpuarray.to_gpu(addr) + + # CPU Kernel + BGDK = BaseGradientDescentKernel(aux, addr.shape[1]) + BGDK.allocate() + BGDK.make_model(aux, addr) + + # GPU kernel + GDK = GradientDescentKernel(aux_dev, addr.shape[1]) + GDK.allocate() + GDK.make_model(aux_dev, addr_dev) + + ## Assert + np.testing.assert_allclose(BGDK.npy.Imodel, GDK.gpu.Imodel.get(), atol=self.atol, rtol=self.rtol, + err_msg="`Imodel` buffer has not been updated as expected") + + @parameterized.expand([ + ["base", 10], + ["regul", 50], + ["floating", 0], + ]) + def test_floating_intensity_UNITY(self, name, iter): + + # Load data + with h5py.File(self.datadir %name + "floating_intensities_%04d.h5" %iter, "r") as f: + w = f["w"][:] + addr = f["addr"][:] + I = f["I"][:] + fic = f["fic"][:] + Imodel = f["Imodel"][:] + with h5py.File(self.datadir %name + "make_model_%04d.h5" %iter, "r") as f: + aux = f["aux"][:] + + # Copy data to device + aux_dev = gpuarray.to_gpu(aux) + w_dev = gpuarray.to_gpu(w) + addr_dev = gpuarray.to_gpu(addr) + I_dev = gpuarray.to_gpu(I) + fic_dev = gpuarray.to_gpu(fic) + Imodel_dev = gpuarray.to_gpu(np.ascontiguousarray(Imodel)) + + # CPU Kernel + BGDK = BaseGradientDescentKernel(aux, addr.shape[1]) + BGDK.allocate() + BGDK.npy.Imodel = Imodel + BGDK.floating_intensity(addr, w, I, fic) + + # GPU kernel + GDK = GradientDescentKernel(aux_dev, addr.shape[1]) + GDK.allocate() + GDK.gpu.Imodel = Imodel_dev + GDK.floating_intensity(addr_dev, w_dev, I_dev, fic_dev) + + ## Assert + np.testing.assert_allclose(BGDK.npy.LLerr, GDK.gpu.LLerr.get(), atol=self.atol, rtol=self.rtol, + verbose=False, equal_nan=False, + err_msg="`LLerr` buffer has not been updated as expected") + np.testing.assert_allclose(BGDK.npy.LLden, GDK.gpu.LLden.get(), atol=self.atol, rtol=self.rtol, + verbose=False, equal_nan=False, + err_msg="`LLden` buffer has not been updated as expected") + np.testing.assert_allclose(BGDK.npy.fic_tmp, GDK.gpu.fic_tmp.get(), atol=self.atol, rtol=self.rtol, + verbose=False, equal_nan=False, + err_msg="`fic_tmp` buffer has not been updated as expected") + + np.testing.assert_allclose(fic, fic_dev.get(), atol=self.atol, rtol=self.rtol, + verbose=False, equal_nan=False, + err_msg="floating intensity coeff (fic) has not been updated as expected") + + np.testing.assert_allclose(BGDK.npy.Imodel, GDK.gpu.Imodel.get(), atol=self.atol, rtol=self.rtol, + verbose=False, equal_nan=False, + err_msg="`Imodel` buffer has not been updated as expected") + + + @parameterized.expand([ + ["base", 10], + ["regul", 50], + ["floating", 0], + ]) + def test_main_and_error_reduce_UNITY(self, name, iter): + + # Load data + with h5py.File(self.datadir %name + "main_%04d.h5" %iter, "r") as f: + aux = f["aux"][:] + addr = f["addr"][:] + w = f["w"][:] + I = f["I"][:] + # Load data + with h5py.File(self.datadir %name + "error_reduce_%04d.h5" %iter, "r") as f: + err_phot = f["err_phot"][:] + + # Copy data to device + aux_dev = gpuarray.to_gpu(aux) + w_dev = gpuarray.to_gpu(w) + addr_dev = gpuarray.to_gpu(addr) + I_dev = gpuarray.to_gpu(I) + err_phot_dev = gpuarray.to_gpu(err_phot) + + # CPU Kernel + BGDK = BaseGradientDescentKernel(aux, addr.shape[1]) + BGDK.allocate() + BGDK.main(aux, addr, w, I) + BGDK.error_reduce(addr, err_phot) + + # GPU kernel + GDK = GradientDescentKernel(aux_dev, addr.shape[1]) + GDK.allocate() + GDK.main(aux_dev, addr_dev, w_dev, I_dev) + GDK.error_reduce(addr_dev, err_phot_dev) + + ## Assert + np.testing.assert_allclose(aux, aux_dev.get(), atol=self.atol, rtol=self.rtol, + err_msg="Auxiliary has not been updated as expected") + np.testing.assert_allclose(BGDK.npy.LLerr, GDK.gpu.LLerr.get(), atol=self.atol, rtol=self.rtol, + err_msg="LogLikelihood error has not been updated as expected") + np.testing.assert_allclose(err_phot, err_phot_dev.get(), atol=self.atol, rtol=self.rtol, + err_msg="`err_phot` has not been updated as expected") + + @parameterized.expand([ + ["base", 10], + ["regul", 50], + ["floating", 0], + ]) + def test_make_a012_UNITY(self, name, iter): + + # Reduce the array size to make the tests run faster + Nmax = 10 + Ymax = 128 + Xmax = 128 + + # Load data + with h5py.File(self.datadir %name + "make_a012_%04d.h5" %iter, "r") as g: + addr = g["addr"][:Nmax] + I = g["I"][:Nmax,:Ymax,:Xmax] + f = g["f"][:Nmax,:Ymax,:Xmax] + a = g["a"][:Nmax,:Ymax,:Xmax] + b = g["b"][:Nmax,:Ymax,:Xmax] + fic = g["fic"][:Nmax] + with h5py.File(self.datadir %name + "make_model_%04d.h5" %iter, "r") as h: + aux = h["aux"][:Nmax,:Ymax,:Xmax] + + # Copy data to device + aux_dev = gpuarray.to_gpu(aux) + addr_dev = gpuarray.to_gpu(addr) + I_dev = gpuarray.to_gpu(I) + f_dev = gpuarray.to_gpu(f) + a_dev = gpuarray.to_gpu(a) + b_dev = gpuarray.to_gpu(b) + fic_dev = gpuarray.to_gpu(fic) + + # CPU Kernel + BGDK = BaseGradientDescentKernel(aux, addr.shape[1]) + BGDK.allocate() + BGDK.make_a012(f, a, b, addr, I, fic) + + # GPU kernel + GDK = GradientDescentKernel(aux_dev, addr.shape[1], queue=self.stream) + GDK.allocate() + GDK.gpu.Imodel.fill(np.nan) + GDK.gpu.LLerr.fill(np.nan) + GDK.gpu.LLden.fill(np.nan) + GDK.make_a012(f_dev, a_dev, b_dev, addr_dev, I_dev, fic_dev) + + ## Assert + np.testing.assert_allclose(GDK.gpu.Imodel.get(), BGDK.npy.Imodel, atol=self.atol, rtol=self.rtol, + err_msg="Imodel error has not been updated as expected") + np.testing.assert_allclose(GDK.gpu.LLerr.get(), BGDK.npy.LLerr, atol=self.atol, rtol=self.rtol, + err_msg="LLerr error has not been updated as expected") + np.testing.assert_allclose(GDK.gpu.LLden.get(), BGDK.npy.LLden, atol=self.atol, rtol=self.rtol, + err_msg="LLden error has not been updated as expected") + + @parameterized.expand([ + ["base", 10], + ["regul", 50], + ["floating", 0], + ]) + def test_fill_b_UNITY(self, name, iter): + + Nmax = 10 + Ymax = 128 + Xmax = 128 + + # Load data + with h5py.File(self.datadir %name + "fill_b_%04d.h5" %iter, "r") as f: + w = f["w"][:Nmax, :Ymax, :Xmax] + addr = f["addr"][:] + B = f["B"][:] + Brenorm = f["Brenorm"][...] + A0 = f["A0"][:Nmax, :Ymax, :Xmax] + A1 = f["A1"][:Nmax, :Ymax, :Xmax] + A2 = f["A2"][:Nmax, :Ymax, :Xmax] + with h5py.File(self.datadir %name + "make_model_%04d.h5" %iter, "r") as f: + aux = f["aux"][:Nmax, :Ymax, :Xmax] + + # Copy data to device + aux_dev = gpuarray.to_gpu(aux) + w_dev = gpuarray.to_gpu(w) + addr_dev = gpuarray.to_gpu(addr) + B_dev = gpuarray.to_gpu(B.astype(np.float32)) + A0_dev = gpuarray.to_gpu(A0) + A1_dev = gpuarray.to_gpu(A1) + A2_dev = gpuarray.to_gpu(A2) + + # CPU Kernel + BGDK = BaseGradientDescentKernel(aux, addr.shape[1]) + BGDK.allocate() + BGDK.npy.Imodel = A0 + BGDK.npy.LLerr = A1 + BGDK.npy.LLden = A2 + BGDK.fill_b(addr, Brenorm, w, B) + + # GPU kernel + GDK = GradientDescentKernel(aux_dev, addr.shape[1]) + GDK.allocate() + GDK.gpu.Imodel = A0_dev + GDK.gpu.LLerr = A1_dev + GDK.gpu.LLden = A2_dev + GDK.fill_b(addr_dev, Brenorm, w_dev, B_dev) + + ## Assert + np.testing.assert_allclose(B, B_dev.get(), rtol=self.rtol, atol=self.atol, + err_msg="`B` has not been updated as expected") + diff --git a/test/archive_tests/dls_tests/dls_po_update_kernel_test.py b/test/archive_tests/dls_tests/dls_po_update_kernel_test.py new file mode 100644 index 000000000..3b8ee0474 --- /dev/null +++ b/test/archive_tests/dls_tests/dls_po_update_kernel_test.py @@ -0,0 +1,106 @@ +''' +Testing on real data +''' + +import h5py +import unittest +import numpy as np +from parameterized import parameterized +from .. import PyCudaTest, have_pycuda + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.kernels import PoUpdateKernel +from ptypy.accelerate.base.kernels import PoUpdateKernel as BasePoUpdateKernel + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +class DlsPoUpdateKernelTest(PyCudaTest): + + datadir = "/dls/science/users/iat69393/gpu-hackathon/test-data-%s/" + rtol = 1e-6 + atol = 1e-6 + + @parameterized.expand([ + ["base", 10, False], + ["regul", 50, False], + ["floating", 0, False], + ["base", 10, True], + ["regul", 50, True], + ["floating", 0, True], + ]) + def test_op_update_ml_UNITY(self, name, iter, atomics): + + # Load data + with h5py.File(self.datadir %name + "op_update_ml_%04d.h5" %iter, "r") as f: + aux = f["aux"][:] + addr = f["addr"][:] + obg = f["obg"][:] + pr = f["pr"][:] + + # Copy data to device + aux_dev = gpuarray.to_gpu(aux) + obg_dev = gpuarray.to_gpu(obg) + pr_dev = gpuarray.to_gpu(pr) + + # If not using atomics we need to change the addresses + if not atomics: + addr2 = np.ascontiguousarray(np.transpose(addr, (2, 3, 0, 1))) + addr_dev = gpuarray.to_gpu(addr2) + else: + addr_dev = gpuarray.to_gpu(addr) + + # CPU Kernel + BPOK = BasePoUpdateKernel() + BPOK.ob_update_ML(addr, obg, pr, aux) + + # GPU Kernel + POK = PoUpdateKernel() + POK.ob_update_ML(addr_dev, obg_dev, pr_dev, aux_dev, atomics=atomics) + + ## Assert + np.testing.assert_allclose(obg_dev.get(), obg, atol=self.atol, rtol=self.rtol, verbose=False, + err_msg="The object array has not been updated as expected") + + @parameterized.expand([ + ["base", 10, False], + ["regul", 50, False], + ["floating", 0, False], + ["base", 10, True], + ["regul", 50, True], + ["floating", 0, True], + ]) + def test_pr_update_ml_UNITY(self, name, iter, atomics): + + # Load data + with h5py.File(self.datadir %name + "pr_update_ml_%04d.h5" %iter, "r") as f: + aux = f["aux"][:] + addr = f["addr"][:] + ob = f["ob"][:] + prg = f["prg"][:] + + # Copy data to device + aux_dev = gpuarray.to_gpu(aux) + ob_dev = gpuarray.to_gpu(ob) + prg_dev = gpuarray.to_gpu(prg) + + # If not using atomics we need to change the addresses + if not atomics: + addr2 = np.ascontiguousarray(np.transpose(addr, (2, 3, 0, 1))) + addr_dev = gpuarray.to_gpu(addr2) + else: + addr_dev = gpuarray.to_gpu(addr) + + # CPU Kernel + BPOK = BasePoUpdateKernel() + BPOK.pr_update_ML(addr, prg, ob, aux) + + # GPU Kernel + POK = PoUpdateKernel() + POK.pr_update_ML(addr_dev, prg_dev, ob_dev, aux_dev, atomics=atomics) + + ## Assert + np.testing.assert_allclose(prg, prg_dev.get(), atol=self.atol, rtol=self.rtol, verbose=False, + err_msg="The probe array has not been updated as expected") \ No newline at end of file diff --git a/test/archive_tests/dls_tests/dls_propagation_kernel_test.py b/test/archive_tests/dls_tests/dls_propagation_kernel_test.py new file mode 100644 index 000000000..ac9fa0402 --- /dev/null +++ b/test/archive_tests/dls_tests/dls_propagation_kernel_test.py @@ -0,0 +1,102 @@ +''' +testing on real data +''' + +import h5py +import unittest +import numpy as np +from parameterized import parameterized +from .. import PyCudaTest, have_pycuda + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.kernels import PropagationKernel + +import ptypy.utils as u +from ptypy.core import geometry +from ptypy.core import Base as theBase + +# subclass for dictionary access +Base = type('Base',(theBase,),{}) + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +class DLsPropagationKernelTest(PyCudaTest): + + datadir = "/dls/science/users/iat69393/gpu-hackathon/test-data-%s/" + rtol = 1e-6 + atol = 1e-6 + + def set_up_farfield(self,shape): + P = Base() + P.CType = COMPLEX_TYPE + P.Ftype = FLOAT_TYPE + g = u.Param() + g.energy = None # u.keV2m(1.0)/6.32e-7 + g.lam = 5.32e-7 + g.distance = 15e-2 + g.psize = 24e-6 + g.shape = shape + g.propagation = "farfield" + G = geometry.Geo(owner=P, pars=g) + return G + + @parameterized.expand([ + ["base", 10], + ["regul", 50], + ["floating", 0], + ]) + def test_forward_UNITY(self, name, iter): + + # Load data + with h5py.File(self.datadir % name + "forward_%04d.h5" %iter, "r") as f: + aux = f["aux"][0] + + # Copy data to device + aux_dev = gpuarray.to_gpu(aux) + + # Geometry + geo = self.set_up_farfield(aux.shape) + + # CPU kernel + aux = geo.propagator.fw(aux) + + # GPU kernel + PropK = PropagationKernel(aux_dev, geo.propagator, queue_thread=self.stream) + PropK.allocate() + PropK.fw(aux_dev, aux_dev) + + ## Assert + np.testing.assert_allclose(aux, aux_dev.get(), atol=self.atol, rtol=self.rtol, + err_msg="Forward propagation was not as expected") + + @parameterized.expand([ + ["base", 10], + ["regul", 50], + ["floating", 0], + ]) + def test_backward_UNITY(self, name, iter): + + # Load data + with h5py.File(self.datadir % name + "backward_%04d.h5" %iter, "r") as f: + aux = f["aux"][0] + + # Copy data to device + aux_dev = gpuarray.to_gpu(aux) + + # Geometry + geo = self.set_up_farfield(aux.shape) + + # CPU kernel + aux = geo.propagator.bw(aux) + + # GPU kernel + PropK = PropagationKernel(aux_dev, geo.propagator, queue_thread=self.stream) + PropK.allocate() + PropK.bw(aux_dev, aux_dev) + + ## Assert + np.testing.assert_allclose(aux, aux_dev.get(), atol=self.atol, rtol=self.rtol, + err_msg="Backward propagation was not as expected") \ No newline at end of file diff --git a/test/archive_tests/dls_tests/dls_regularizer_kernel_test.py b/test/archive_tests/dls_tests/dls_regularizer_kernel_test.py new file mode 100644 index 000000000..972648552 --- /dev/null +++ b/test/archive_tests/dls_tests/dls_regularizer_kernel_test.py @@ -0,0 +1,77 @@ +''' +Testing on real data +''' + +import h5py +import unittest +import numpy as np +from parameterized import parameterized +from .. import PyCudaTest, have_pycuda + +if have_pycuda(): + from pycuda import gpuarray + from ptypy.accelerate.cuda_pycuda.engines.ML_pycuda import Regul_del2_pycuda + import pycuda.driver as cuda +from ptypy.engines.ML import Regul_del2 + +COMPLEX_TYPE = np.complex64 +FLOAT_TYPE = np.float32 +INT_TYPE = np.int32 + +class DlsRegularizerTest(PyCudaTest): + + datadir = "/dls/science/users/iat69393/gpu-hackathon/test-data-%s/" + rtol = 1e-6 + atol = 1e-6 + + @parameterized.expand([ + ["regul", 50] + ]) + def test_regularizer_grad_UNITY(self, name, iter): + + # Load data + with h5py.File(self.datadir %name + "regul_grad_%04d.h5" %iter, "r") as f: + ob = f["ob"][:] + + # Copy data to device + ob_dev = gpuarray.to_gpu(ob) + + # CPU Kernel + regul = Regul_del2(0.1) + obr = regul.grad(ob) + + # GPU Kernel + regul_pycuda = Regul_del2_pycuda(0.1, queue=self.stream, allocator=cuda.mem_alloc) + obr_dev = regul_pycuda.grad(ob_dev) + + ## Assert + np.testing.assert_allclose(obr, obr_dev.get(), atol=self.atol, rtol=self.rtol, + err_msg="The object array has not been updated as expected") + np.testing.assert_allclose(regul.LL, regul_pycuda.LL, atol=self.atol, rtol=self.rtol, + err_msg="The LL array has not been updated as expected") + + @parameterized.expand([ + ["regul", 50], + ]) + def test_regularizer_poly_line_ceoffs_UNITY(self, name, iter): + + # Load data + with h5py.File(self.datadir % name + "regul_poly_line_coeffs_%04d.h5" %iter, "r") as f: + ob = f["ob"][:] + obh = f["obh"][:] + + # Copy data to device + ob_dev = gpuarray.to_gpu(ob) + obh_dev = gpuarray.to_gpu(obh) + + # CPU Kernel + regul = Regul_del2(0.1) + res = regul.poly_line_coeffs(obh, ob) + + # GPU Kernel + regul_pycuda = Regul_del2_pycuda(0.1, queue=self.stream, allocator=cuda.mem_alloc) + res_pycuda = regul_pycuda.poly_line_coeffs(obh_dev, ob_dev) + + ## Assert + np.testing.assert_allclose(res, res_pycuda, atol=self.atol, rtol=self.rtol, + err_msg="The B array has not been updated as expected") diff --git a/test/core_tests/classes_test.py b/test/core_tests/classes_test.py index 7aae2856f..250ee7e2e 100644 --- a/test/core_tests/classes_test.py +++ b/test/core_tests/classes_test.py @@ -1308,7 +1308,7 @@ def test_init(self): self.assertTrue( np.array_equal( self.basic_view_dpt.psize, - np.ones(2, dtype=np.float) + np.ones(2, dtype=float) ), 'Assigning of instance attribute psize failed.' ) @@ -1316,7 +1316,7 @@ def test_init(self): self.assertTrue( np.array_equal( self.basic_view_dpt.shape, - np.ones(2, dtype=np.int) + np.ones(2, dtype=int) ), 'Assigning of instance attribute psize failed.' ) diff --git a/test/core_tests/import_ptypy_test.py b/test/core_tests/import_ptypy_test.py index 7bd592c7d..78080f194 100644 --- a/test/core_tests/import_ptypy_test.py +++ b/test/core_tests/import_ptypy_test.py @@ -2,12 +2,18 @@ So much stuff in the init files now, we better test the import. """ - import unittest class ImportPtypyTest(unittest.TestCase): def test_import(self): import ptypy -if __name__ == '__main__': - unittest.main() \ No newline at end of file +class PtypyLoaderTest(unittest.TestCase): + + def test_load_ptyscan_module(self): + import ptypy + ptypy.load_ptyscan_module("hdf5_loader") + + def test_load_all_ptyscan_modules(self): + import ptypy + ptypy.load_all_ptyscan_modules() diff --git a/test/engine_tests/DMOPR_test.py b/test/engine_tests/DMOPR_test.py index 4b7bbcae2..66c2fe3ab 100644 --- a/test/engine_tests/DMOPR_test.py +++ b/test/engine_tests/DMOPR_test.py @@ -10,17 +10,26 @@ from test import utils as tu from ptypy import utils as u from ptypy.core import Ptycho +import tempfile +import shutil +from ptypy.custom import DMOPR class DMOPRTest(unittest.TestCase): + def setUp(self): + self.outpath = tempfile.mkdtemp(suffix="DMOPR_test") + + def tearDown(self): + shutil.rmtree(self.outpath) + def test_DMOPR(self): p = u.Param() p.verbose_level = 3 p.io = u.Param() p.io.interaction = u.Param() p.io.interaction.active = False - p.io.home = './' - p.io.rfile = "./DMOPRTest.ptyr" + p.io.home = self.outpath + p.io.rfile = "DMOPRTest.ptyr" p.io.autosave = u.Param(active=False) p.io.autoplot = u.Param(active=False) p.ipython_kernel = False @@ -42,7 +51,7 @@ def test_DMOPR(self): p.scans.MF.data.experimentID = None p.scans.MF.data.label = None p.scans.MF.data.version = 0.1 - p.scans.MF.data.dfile = "./DMOPRTest.ptyd" + p.scans.MF.data.dfile = "DMOPRTest.ptyd" p.scans.MF.data.psize = 0.000172 p.scans.MF.data.load_parallel = None p.scans.MF.data.distance = 7.0 diff --git a/test/engine_tests/DM_simple_test.py b/test/engine_tests/DM_simple_test.py deleted file mode 100644 index 70e5082a2..000000000 --- a/test/engine_tests/DM_simple_test.py +++ /dev/null @@ -1,23 +0,0 @@ -""" -Test for the DM_simple engine. - -This file is part of the PTYPY package. - :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. - :license: GPLv2, see LICENSE for details. -""" - -import unittest -from test import utils as tu -from ptypy import utils as u - - - -class DMSimpleTest(unittest.TestCase): - @unittest.skip('Skipping because of a NotImplementedError in engine_prepare') - def test_DM_simple(self): - engine_params = u.Param() - engine_params.name = 'DM_simple' - engine_params.alpha = 1.0 - tu.EngineTestRunner(engine_params) -if __name__ == "__main__": - unittest.main() diff --git a/test/engine_tests/DM_test.py b/test/engine_tests/DM_test.py index 2a436577c..db10f8154 100644 --- a/test/engine_tests/DM_test.py +++ b/test/engine_tests/DM_test.py @@ -9,9 +9,17 @@ import unittest from test import utils as tu from ptypy import utils as u +import tempfile +import shutil class DMTest(unittest.TestCase): + def setUp(self): + self.outpath = tempfile.mkdtemp(suffix="DMOPR_test") + + def tearDown(self): + shutil.rmtree(self.outpath) + def test_DM_position_refinement(self): engine_params = u.Param() engine_params.name = 'DM' @@ -25,7 +33,7 @@ def test_DM_position_refinement(self): engine_params.fourier_relax_factor = 0.01 engine_params.obj_smooth_std = 20 engine_params.position_refinement = True - tu.EngineTestRunner(engine_params) + tu.EngineTestRunner(engine_params, output_path=self.outpath) def test_DM(self): engine_params = u.Param() @@ -39,7 +47,7 @@ def test_DM(self): engine_params.object_inertia = 0.1 engine_params.fourier_relax_factor = 0.01 engine_params.obj_smooth_std = 20 - tu.EngineTestRunner(engine_params) + tu.EngineTestRunner(engine_params, output_path=self.outpath) if __name__ == "__main__": unittest.main() diff --git a/test/engine_tests/MLOPR_test.py b/test/engine_tests/MLOPR_test.py index 7b4b64e49..1c0ff79af 100644 --- a/test/engine_tests/MLOPR_test.py +++ b/test/engine_tests/MLOPR_test.py @@ -10,8 +10,17 @@ from test import utils as tu from ptypy import utils as u from ptypy.core import Ptycho +import tempfile +import shutil + +from ptypy.custom import MLOPR class MLOPRTest(unittest.TestCase): + def setUp(self): + self.outpath = tempfile.mkdtemp(suffix="MLOPR_test") + + def tearDown(self): + shutil.rmtree(self.outpath) def test_MLOPR(self): @@ -20,8 +29,8 @@ def test_MLOPR(self): p.io = u.Param() p.io.interaction = u.Param() p.io.interaction.active = False - p.io.home = './' - p.io.rfile = "./MLOPRTest.ptyr" + p.io.home = self.outpath + p.io.rfile = "MLOPRTest.ptyr" p.io.autosave = u.Param(active=False) p.io.autoplot = u.Param(active=False) p.ipython_kernel = False @@ -43,7 +52,7 @@ def test_MLOPR(self): p.scans.MF.data.experimentID = None p.scans.MF.data.label = None p.scans.MF.data.version = 0.1 - p.scans.MF.data.dfile = "./MLOPRTest.ptyd" + p.scans.MF.data.dfile = "MLOPRTest.ptyd" p.scans.MF.data.psize = 0.000172 p.scans.MF.data.load_parallel = None p.scans.MF.data.distance = 7.0 diff --git a/test/engine_tests/ML_test.py b/test/engine_tests/ML_test.py index b7ae3525e..d06571d7d 100644 --- a/test/engine_tests/ML_test.py +++ b/test/engine_tests/ML_test.py @@ -9,23 +9,16 @@ import unittest from test import utils as tu from ptypy import utils as u +import tempfile +import shutil class MLTest(unittest.TestCase): - def test_ML_farfield_position_refinement(self): - engine_params = u.Param() - engine_params.name = 'ML' - engine_params.numiter = 5 - engine_params.probe_update_start = 2 - engine_params.floating_intensities = False - engine_params.intensity_renormalization = 1.0 - engine_params.reg_del2 =True - engine_params.reg_del2_amplitude = 0.01 - engine_params.smooth_gradient = 0.0 - engine_params.scale_precond =False - engine_params.probe_update_start = 0 - engine_params.position_refinement = True - tu.EngineTestRunner(engine_params) + def setUp(self): + self.outpath = tempfile.mkdtemp(suffix="DMOPR_test") + + def tearDown(self): + shutil.rmtree(self.outpath) def test_ML_farfield_floating_intensities(self): engine_params = u.Param() @@ -39,7 +32,7 @@ def test_ML_farfield_floating_intensities(self): engine_params.smooth_gradient = 0.0 engine_params.scale_precond =False engine_params.probe_update_start = 0 - tu.EngineTestRunner(engine_params) + tu.EngineTestRunner(engine_params, output_path=self.outpath) def test_ML_farfield(self): engine_params = u.Param() @@ -53,7 +46,7 @@ def test_ML_farfield(self): engine_params.smooth_gradient = 0.0 engine_params.scale_precond =False engine_params.probe_update_start = 0 - tu.EngineTestRunner(engine_params) + tu.EngineTestRunner(engine_params, output_path=self.outpath) def test_ML_nearfield(self): @@ -69,7 +62,7 @@ def test_ML_nearfield(self): engine_params.scale_precond =False engine_params.probe_update_start = 0 - tu.EngineTestRunner(engine_params, propagator='nearfield') + tu.EngineTestRunner(engine_params, propagator='nearfield', output_path=self.outpath) if __name__ == "__main__": unittest.main() diff --git a/test/engine_tests/engine_utils_test.py b/test/engine_tests/engine_utils_test.py new file mode 100644 index 000000000..4e8f977ce --- /dev/null +++ b/test/engine_tests/engine_utils_test.py @@ -0,0 +1,89 @@ +""" +Test for the DM engine. + +This file is part of the PTYPY package. + :copyright: Copyright 2014 by the PTYPY team, see AUTHORS. + :license: GPLv2, see LICENSE for details. +""" + +import unittest +from test import utils as tu +import numpy as np +from ptypy import utils as u +from ptypy.core import Ptycho +from ptypy.engines import utils as eu + +np.random.seed(1234) + +def get_ptycho(model='Full', base_dir='./'): + p = u.Param() + p.verbose_level = 3 + p.io = u.Param() + p.io.interaction = u.Param() + p.io.interaction.active = False + p.io.home = base_dir + p.io.rfile = base_dir + model + "_test.ptyr" + p.io.autosave = u.Param(active=False) + p.io.autoplot = u.Param(active=False) + p.ipython_kernel = False + p.scans = u.Param() + p.scans.MF = u.Param() + p.scans.MF.name = model + p.scans.MF.propagation = 'farfield' + p.scans.MF.data = u.Param() + p.scans.MF.data.name = 'MoonFlowerScan' + p.scans.MF.data.positions_theory = None + p.scans.MF.data.auto_center = None + p.scans.MF.data.min_frames = 1 + p.scans.MF.data.orientation = None + p.scans.MF.data.num_frames = 100 + p.scans.MF.data.energy = 6.2 + p.scans.MF.data.shape = 64 + p.scans.MF.data.chunk_format = '.chunk%02d' + p.scans.MF.data.rebin = None + p.scans.MF.data.experimentID = None + p.scans.MF.data.label = None + p.scans.MF.data.version = 0.1 + p.scans.MF.data.dfile = base_dir + model + "_test.ptyd" + p.scans.MF.data.psize = 0.000172 + p.scans.MF.data.load_parallel = None + p.scans.MF.data.distance = 7.0 + p.scans.MF.data.save = None + p.scans.MF.data.center = 'fftshift' + p.scans.MF.data.photons = 100000000.0 + p.scans.MF.data.psf = 0.0 + p.scans.MF.data.density = 0.2 + p.scans.MF.coherence = u.Param() + p.scans.MF.coherence.num_probe_modes = 1 # currently breaks when this is =2 + + # init data is level 2 + P = Ptycho(p, level=2) + + return P + +class FourierUpdateTest(unittest.TestCase): + def test_legacy_general_UNITY(self): + P = get_ptycho(model='Full', base_dir='./') + pod = list(P.pods.values())[0] + diff = pod.di_view + e = {} + pods = list(diff.pods.values()) + for p in pods: + print(pod.exit) + e[p.ex_view.ID] = pod.exit.copy() + error_LEGACY = eu.basic_fourier_update_LEGACY(diff, None, alpha=1.0, LL_error=False) + res = {} + for p in pods: + print(pod.exit) + res[p.ex_view.ID] = pod.exit.copy() + pod.exit = e[p.ex_view.ID] + + error = eu.basic_fourier_update(diff, None, alpha=1.0, LL_error=False) + for p in pods: + print(pod.exit) + #np.testing.assert_array_equal(res[p.ex_view.ID], pod.exit, + # "Exit wave data diverges after fourier update") + np.testing.assert_array_equal(error_LEGACY, error, "Error metrics diverge") + +if __name__ == "__main__": + unittest.main() diff --git a/test/ptyscan_tests/diamond_nexus_test.py b/test/ptyscan_tests/diamond_nexus_test.py index ed4a9c919..24634bcb6 100644 --- a/test/ptyscan_tests/diamond_nexus_test.py +++ b/test/ptyscan_tests/diamond_nexus_test.py @@ -34,29 +34,29 @@ def setUp(self): self.intensity_file = os.path.join(self.outdir, 'intensity.h5') self.intensity_key = 'entry_1/data/data' - create_file_and_dataset(path=self.intensity_file, key=self.intensity_key, data_type=np.float) + create_file_and_dataset(path=self.intensity_file, key=self.intensity_key, data_type=float) self.positions_file = os.path.join(self.outdir, 'positions.h5') self.positions_slow_key = 'entry_1/data/y' self.positions_fast_key = 'entry_1/data/x' create_file_and_dataset(path=self.positions_file, key=[self.positions_slow_key, self.positions_fast_key], - data_type=np.float) + data_type=float) self.mask_file = os.path.join(self.outdir, 'mask.h5') self.mask_key = 'entry/mask' - create_file_and_dataset(path=self.mask_file, key=self.mask_key, data_type=np.int) + create_file_and_dataset(path=self.mask_file, key=self.mask_key, data_type=int) self.dark_file = os.path.join(self.outdir, 'dark.h5') self.dark_key = 'entry_1/instrument_1/detector_1/darkfield' - create_file_and_dataset(path=self.dark_file, key=self.dark_key, data_type=np.float) + create_file_and_dataset(path=self.dark_file, key=self.dark_key, data_type=float) self.flat_file = os.path.join(self.outdir, 'flat.h5') self.flat_key = 'entry_1/instrument_1/detector_1/flatfield' - create_file_and_dataset(path=self.flat_file, key=self.flat_key, data_type=np.float) + create_file_and_dataset(path=self.flat_file, key=self.flat_key, data_type=float) self.normalisation_file = os.path.join(self.outdir, 'normalisation.h5') self.normalisation_key = 'entry_1/instrument_1/monitor/data' - create_file_and_dataset(path=self.normalisation_file, key=self.normalisation_key, data_type=np.float) + create_file_and_dataset(path=self.normalisation_file, key=self.normalisation_key, data_type=float) self.top_file = os.path.join(self.outdir, 'top_file.h5') self.recorded_energy_key = 'entry_1/instrument_1/beam_1/energy' @@ -251,7 +251,7 @@ def test_crop_load_works_case1(self): data = np.arange(k*frame_size_m*frame_size_n).reshape((k, frame_size_m, frame_size_n)) h5.File(self.intensity_file, 'w')[self.intensity_key] = data - mask = np.ones(data.shape[-2:], dtype=np.float) + mask = np.ones(data.shape[-2:], dtype=float) mask[::2] = 0 mask[:, ::2] = 0 h5.File(self.mask_file, 'w')[self.mask_key] = mask @@ -761,7 +761,7 @@ def test_mask_loaded(self): data = np.arange(k*frame_size_m*frame_size_n).reshape((k, frame_size_m, frame_size_n)) h5.File(self.intensity_file, 'w')[self.intensity_key] = data - mask = np.ones(data.shape[-2:], dtype=np.float) + mask = np.ones(data.shape[-2:], dtype=float) mask[::2] = 0 mask[:, ::2] = 0 h5.File(self.mask_file, 'w')[self.mask_key] = mask diff --git a/test/ptyscan_tests/hdf5_loader_test.py b/test/ptyscan_tests/hdf5_loader_test.py index b6188e071..9627fd316 100644 --- a/test/ptyscan_tests/hdf5_loader_test.py +++ b/test/ptyscan_tests/hdf5_loader_test.py @@ -34,33 +34,33 @@ def setUp(self): self.intensity_file = os.path.join(self.outdir, 'intensity.h5') self.intensity_key = 'entry/intensity' - create_file_and_dataset(path=self.intensity_file, key=self.intensity_key, data_type=np.float) + create_file_and_dataset(path=self.intensity_file, key=self.intensity_key, data_type=float) self.positions_file = os.path.join(self.outdir, 'positions.h5') self.positions_slow_key = 'entry/positions_slow' self.positions_fast_key = 'entry/positions_fast' create_file_and_dataset(path=self.positions_file, key=[self.positions_slow_key, self.positions_fast_key], - data_type=np.float) + data_type=float) self.mask_file = os.path.join(self.outdir, 'mask.h5') self.mask_key = 'entry/mask' - create_file_and_dataset(path=self.mask_file, key=self.mask_key, data_type=np.int) + create_file_and_dataset(path=self.mask_file, key=self.mask_key, data_type=int) self.dark_file = os.path.join(self.outdir, 'dark.h5') self.dark_key = 'entry/dark' - create_file_and_dataset(path=self.dark_file, key=self.dark_key, data_type=np.float) + create_file_and_dataset(path=self.dark_file, key=self.dark_key, data_type=float) self.flat_file = os.path.join(self.outdir, 'flat.h5') self.flat_key = 'entry/flat' - create_file_and_dataset(path=self.flat_file, key=self.flat_key, data_type=np.float) + create_file_and_dataset(path=self.flat_file, key=self.flat_key, data_type=float) self.normalisation_file = os.path.join(self.outdir, 'normalisation.h5') self.normalisation_key = 'entry/normalisation' - create_file_and_dataset(path=self.normalisation_file, key=self.normalisation_key, data_type=np.float) + create_file_and_dataset(path=self.normalisation_file, key=self.normalisation_key, data_type=float) self.framefilter_file = os.path.join(self.outdir, 'framefilter.h5') self.framefilter_key = 'entry/framefilter' - create_file_and_dataset(path=self.framefilter_file, key=self.framefilter_key, data_type=np.bool) + create_file_and_dataset(path=self.framefilter_file, key=self.framefilter_key, data_type=bool) self.top_file = os.path.join(self.outdir, 'top_file.h5') self.recorded_energy_key = 'entry/energy' @@ -370,7 +370,7 @@ def test_crop_load_works_case1(self): data = np.arange(k*frame_size_m*frame_size_n).reshape((k, frame_size_m, frame_size_n)) h5.File(self.intensity_file, 'w')[self.intensity_key] = data - mask = np.ones(data.shape[-2:], dtype=np.float) + mask = np.ones(data.shape[-2:], dtype=float) mask[::2] = 0 mask[:, ::2] = 0 h5.File(self.mask_file, 'w')[self.mask_key] = mask @@ -1267,7 +1267,7 @@ def test_mask_loaded(self): data = np.arange(k*frame_size_m*frame_size_n).reshape((k, frame_size_m, frame_size_n)) h5.File(self.intensity_file, 'w')[self.intensity_key] = data - mask = np.ones(data.shape[-2:], dtype=np.float) + mask = np.ones(data.shape[-2:], dtype=float) mask[::2] = 0 mask[:, ::2] = 0 h5.File(self.mask_file, 'w')[self.mask_key] = mask diff --git a/test/util_tests/derivatives_test.py b/test/util_tests/derivatives_test.py new file mode 100644 index 000000000..c2237d561 --- /dev/null +++ b/test/util_tests/derivatives_test.py @@ -0,0 +1,89 @@ +import unittest +import numpy as np +from ptypy.utils.math_utils import delxf, delxb + +class DerivativesTest(unittest.TestCase): + + def test_delxf_1dim(self): + inp = np.array([0, 1, 2, 4, 8, 0, 6], dtype=np.float32) + + outp = delxf(inp) + + exp = np.array([1, 1, 2, 4, -8, 6, 0], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + def test_delxf_1dim_inplace(self): + inp = np.array([0, 1, 2, 4, 8, 0, 6], dtype=np.float32) + outp = np.zeros_like(inp) + + delxf(inp, out=outp) + + exp = np.array([1, 1, 2, 4, -8, 6, 0], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + def test_delxf_2dim1(self): + inp = np.array([ + [0, 2, 6], + [1, -4, 5] + ], dtype=np.float32) + + outp = delxf(inp, axis=0) + + exp = np.array([ + [1, -6, -1], + [0, 0, 0] + ], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + def test_delxf_2dim2(self): + inp = np.array([ + [0, 2, 6], + [1, -4, 5] + ], dtype=np.float32) + + outp = delxf(inp, axis=1) + + exp = np.array([ + [2, 4, 0], + [-5, 9, 0] + ], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + + def test_delxb_1dim(self): + inp = np.array([0, 1, 2, 4, 8, 0, 6], dtype=np.float32) + + outp = delxb(inp) + + exp = np.array([0, 1, 1, 2, 4, -8, 6], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + def test_delxb_2dim1(self): + inp = np.array([ + [0, 2, 6], + [1, -4, 5] + ], dtype=np.float32) + + outp = delxb(inp, axis=0) + + exp = np.array([ + [0, 0, 0], + [1, -6, -1], + ], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + def test_delxb_2dim2(self): + inp = np.array([ + [0, 2, 6], + [1, -4, 5] + ], dtype=np.float32) + + outp = delxb(inp, axis=1) + + exp = np.array([ + [0, 2, 4], + [0, -5, 9] + ], dtype=np.float32) + np.testing.assert_array_equal(outp, exp) + + \ No newline at end of file diff --git a/test/utils.py b/test/utils.py index fa7e847c8..14ae745b3 100644 --- a/test/utils.py +++ b/test/utils.py @@ -13,6 +13,7 @@ import shutil import os import tempfile +import numpy as np from ptypy import utils as u from ptypy.core import Ptycho @@ -42,51 +43,125 @@ def PtyscanTestRunner(ptyscan_instance, data_params, save_type='append', auto_fr return out_dict -def EngineTestRunner(engine_params,propagator='farfield',output_path='./', output_file=None): - +def EngineTestRunner(engine_params,propagator='farfield',output_path='./', output_file=None, + autosave=True, scanmodel="Full", verbose_level="info", init_correct_probe=False): p = u.Param() - p.verbose_level = 3 + p.verbose_level = verbose_level p.io = u.Param() - p.io.interaction = u.Param() - p.io.interaction.active = False p.io.home = output_path p.io.rfile = "%s.ptyr" % output_file - p.io.autosave = u.Param(active=True) + p.io.interaction = u.Param() + p.io.interaction.active = False + p.io.autosave = u.Param(active=autosave) p.io.autoplot = u.Param(active=False) - p.ipython_kernel = False p.scans = u.Param() p.scans.MF = u.Param() - p.scans.MF.name = 'Full' + p.scans.MF.name = scanmodel p.scans.MF.propagation = propagator p.scans.MF.data = u.Param() p.scans.MF.data.name = 'MoonFlowerScan' - p.scans.MF.data.positions_theory = None - p.scans.MF.data.auto_center = None - p.scans.MF.data.min_frames = 1 - p.scans.MF.data.orientation = None - p.scans.MF.data.num_frames = 100 - p.scans.MF.data.energy = 6.2 + p.scans.MF.data.num_frames = 200 p.scans.MF.data.shape = 64 - p.scans.MF.data.chunk_format = '.chunk%02d' - p.scans.MF.data.rebin = None - p.scans.MF.data.experimentID = None - p.scans.MF.data.label = None - p.scans.MF.data.version = 0.1 - p.scans.MF.data.dfile = "%s.ptyd" % output_file - p.scans.MF.data.psize = 0.000172 - p.scans.MF.data.load_parallel = None - p.scans.MF.data.distance = 7.0 p.scans.MF.data.save = None - p.scans.MF.data.center = 'fftshift' - p.scans.MF.data.photons = 100000000.0 + p.scans.MF.data.photons = 1e8 p.scans.MF.data.psf = 0.0 p.scans.MF.data.density = 0.2 p.scans.MF.data.add_poisson_noise = False p.scans.MF.coherence = u.Param() - p.scans.MF.coherence.num_probe_modes = 1 # currently breaks when this is =2 + p.scans.MF.coherence.num_probe_modes = 1 p.engines = u.Param() p.engines.engine00 = engine_params - P = Ptycho(p, level=5) + P = Ptycho(p, level=4) + if init_correct_probe: + P.probe.S['SMFG00'].data[0] = P.model.scans['MF'].ptyscan.pr + P.run() return P + +def EngineTestRunner2(engine_params,propagator='farfield',output_path='./', output_file=None, + autosave=True, scanmodel="Full", verbose_level="info", init_correct_probe=False): + + p = u.Param() + p.verbose_level = verbose_level + p.io = u.Param() + p.io.home = output_path + p.io.rfile = "%s.ptyr" % output_file + p.io.interaction = u.Param() + p.io.interaction.active = False + p.io.autosave = u.Param(active=autosave) + p.io.autoplot = u.Param(active=False) + + # Simulation parameters + sim = u.Param() + sim.energy = 17.0 + sim.distance = 2.886 + sim.psize = 51e-6 + sim.shape = 128 + sim.xy = u.Param() + sim.xy.model = "round" + sim.xy.spacing = 250e-9 + sim.xy.steps = 30 + sim.xy.extent = 4e-6 + + sim.illumination = u.Param() + sim.illumination.model = None + sim.illumination.photons = 3e8 + sim.illumination.aperture = u.Param() + sim.illumination.aperture.diffuser = None + sim.illumination.aperture.form = "rect" + sim.illumination.aperture.size = 35e-6 + sim.illumination.aperture.central_stop = None + sim.illumination.propagation = u.Param() + sim.illumination.propagation.focussed = 0.08 + sim.illumination.propagation.parallel = 0.0014 + sim.illumination.propagation.spot_size = None + + sim.sample = u.Param() + sim.sample.model = u.xradia_star((1000,1000),minfeature=3,contrast=0.0) + sim.sample.process = u.Param() + sim.sample.process.offset = (100,100) + sim.sample.process.zoom = 1.0 + sim.sample.process.formula = "Au" + sim.sample.process.density = 19.3 + sim.sample.process.thickness = 2000e-9 + sim.sample.process.ref_index = None + sim.sample.process.smoothing = None + sim.sample.fill = 1.0+0.j + + sim.detector = 'GenericCCD32bit' + sim.verbose_level = 1 + sim.psf = 1. # emulates partial coherence + sim.plot = False + + # Scan model and initial value parameters + p.scans = u.Param() + p.scans.scan00 = u.Param() + p.scans.scan00.name = scanmodel + p.scans.scan00.coherence = u.Param() + p.scans.scan00.coherence.num_probe_modes = 1 + p.scans.scan00.coherence.num_object_modes = 1 + p.scans.scan00.sample = u.Param() + p.scans.scan00.sample.model = 'stxm' + p.scans.scan00.sample.process = None + p.scans.scan00.propagation = propagator + + # (copy the simulation illumination and change specific things) + p.scans.scan00.illumination = sim.illumination.copy(99) + if not init_correct_probe: + p.scans.scan00.illumination.aperture.form = 'circ' + p.scans.scan00.illumination.propagation.focussed = 0.06 + p.scans.scan00.illumination.diversity = u.Param() + p.scans.scan00.illumination.diversity.power = 0.1 + p.scans.scan00.illumination.diversity.noise = (np.pi,3.0) + + # Scan data (simulation) parameters + p.scans.scan00.data = u.Param() + p.scans.scan00.data.name = 'SimScan' + p.scans.scan00.data.update(sim) + p.scans.scan00.data.save = None + p.engines = u.Param() + p.engines.engine00 = engine_params + P = Ptycho(p, level=4) + P.run() + return P diff --git a/tutorial/minimal_script.py b/tutorial/minimal_script.py index 34492b115..32320083b 100644 --- a/tutorial/minimal_script.py +++ b/tutorial/minimal_script.py @@ -1,5 +1,5 @@ # This tutorial explains the minimal settings to get a reconstruction -# runnig in |ptypy|. A |ptypy| script consists of two parts: +# runnig in |ptypy|_. A |ptypy| script consists of two parts: # * Creation of a parameter tree with parameters # as listed in :ref:`parameters` and @@ -25,7 +25,7 @@ # We set the verbosity to a high level, in order to have information on the # reconstruction process printed to the terminal. # See :py:data:`~ptycho.verbose_level`. -p.verbose_level = 3 +p.verbose_level = "info" # We limit this reconstruction to single precision. The other choice is to # use double precision. diff --git a/tutorial/simupod.py b/tutorial/simupod.py index c1bab0ccc..a1026bc68 100644 --- a/tutorial/simupod.py +++ b/tutorial/simupod.py @@ -173,6 +173,7 @@ class Base2(Base): storage.fill(flower_obj(storage.shape[-2:])) fig = u.plot_storage(storage, 5) fig.savefig('%s_%d.png' % (scriptname, fig.number), dpi=300) +# Complex transmission function of the object. # Creating additional Views and the PODs # -------------------------------------- @@ -240,7 +241,7 @@ class Base2(Base): exit_storage = list(P.exit.storages.values())[0] fig = u.plot_storage(exit_storage, 6) fig.savefig('%s_%d.png' % (scriptname, fig.number), dpi=300) -# Simulated exit wave using a pod +# Simulated exit wave using a pod. # The diffraction plane is also conveniently accessible with pod.diff = np.abs(pod.fw(pod.exit))**2 @@ -249,7 +250,7 @@ class Base2(Base): diff_storage = list(P.diff.storages.values())[0] fig = u.plot_storage(diff_storage, 7, modulus='log') fig.savefig('%s_%d.png' % (scriptname, fig.number), dpi=300) - +# First simulated diffraction image (without noise) # Creating the rest of the pods is now straight-forward # since the data accesses are similar.

      )K#u3`r}Q}v0xse6NG@9*5i1XW|JdXV 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%0DOkSsCS!F5}HT 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

      _p%G=8_8h&di73a%Qf2jGR{Qz4a6(TeUX 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 z

    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