#ifdef MAXCOMPILER_VERSION_INFO #define MAXCOMPILER_VERSION_INFO_PRESENT 1 #define MAXFILE_MAXCOMPILER_VERSION_YEAR 2018 #define MAXFILE_MAXCOMPILER_VERSION_NUM 3 #define MAXFILE_MAXCOMPILER_VERSION_POINT 1 #define MAXFILE_MAXCOMPILER_VERSION_PATCH "" #define MAXFILE_MAXCOMPILER_VERSION_REV "b189b8e" #define MAXFILE_MAXCOMPILER_VERSION_RELEASE_DATE "2019-01-09" #define MAXFILE_MAXCOMPILER_VERSION_RELEASE_MODE true #endif #ifdef MAXFILE_BUILD_INFO #define MAXFILE_BUILD_INFO_PRESENT 1 #define MAXFILE_BUILD_NAME "StreamFMA" #define MAXFILE_BUILD_DIR "/mnt/beegfs/home/jusers/makni1/jumax/makni3/starpu.git/tests/./StreamFMA_MAX5C_DFE_SIM" #define MAXFILE_BUILD_DATE 20191029 #define MAXFILE_BUILD_REV 1 #endif #ifdef PARAM #define PARAM_PRESENT 1 PARAM(DYNAMIC_CLOCKS_ENABLED, 0) PARAM(APP_ID, 0) PARAM(REV_ID, 0) PARAM(CHAIN_LENGTH, 36) PARAM(IS_SIMULATION, 1) PARAM(MEC_SUPPORTED, 1) PARAM(PCIE_SLAVE_STREAMING, 0) PARAM(PCIE_ALIGNMENT, 16) PARAM(NUM_IFPGA_LINKS, 0) #endif #ifdef STRING_PARAM #define STRING_PARAM_PRESENT 1 STRING_PARAM(BOARD_MODEL, "MAX5_LIMA") #endif #ifdef INCLUDE_GENERATED_CPP_HEADERS #include "StreamFMAKernel.h" #endif #ifdef ENGINE_PARAMETERS #define ENGINE_PARAMETERS_PRESENT 1 ENGINE_PARAMETERS(DFEModel, DFEMODEL, MAIA) ENGINE_PARAMETERS(maxFileName, STRING, "StreamFMA") ENGINE_PARAMETERS(target, ENUM, DFE_SIM) ENGINE_PARAMETERS(enableMPCX, BOOL, false) ENGINE_PARAMETERS(MPPRStartCT, INT, 1) ENGINE_PARAMETERS(MPPREndCT, INT, 1) ENGINE_PARAMETERS(MPPRThreads, INT, 1) ENGINE_PARAMETERS(MPPRRetryThreshold, INT, 0) #endif #ifdef MANAGER_NODE #define MANAGER_NODE_PRESENT 1 MANAGER_NODE(StreamFMAKernel, Kernel) MANAGER_NODE(a, PCIe_From_Host) MANAGER_NODE(b, PCIe_From_Host) MANAGER_NODE(output, PCIe_To_Host) MANAGER_NODE(Stream_1, DualAspectMux) MANAGER_NODE(Stream_4, DualAspectMux) MANAGER_NODE(Stream_8, DualAspectReg) MANAGER_NODE(Stream_21, StreamPullPushAdapter) MANAGER_NODE(Stream_11, Fifo) MANAGER_NODE(Stream_15, Fifo) MANAGER_NODE(Stream_13, Fifo) MANAGER_NODE(Stream_17, Fifo) MANAGER_NODE(Stream_19, Fifo) #endif #ifdef MANAGER_NODE_IO #define MANAGER_NODE_IO_PRESENT 1 MANAGER_NODE_IO(StreamFMAKernel, a, IN, STREAM, 32, PULL) MANAGER_NODE_IO(StreamFMAKernel, b, IN, STREAM, 32, PULL) MANAGER_NODE_IO(StreamFMAKernel, output, OUT, STREAM, 32, PUSH) MANAGER_NODE_IO(a, a, OUT, PCIE, 128, PUSH) MANAGER_NODE_IO(b, b, OUT, PCIE, 128, PUSH) MANAGER_NODE_IO(output, output, IN, PCIE, 128, PUSH) MANAGER_NODE_IO(Stream_1, input, IN, PCIE, 128, PULL) MANAGER_NODE_IO(Stream_1, output, OUT, PCIE, 32, PUSH) MANAGER_NODE_IO(Stream_4, input, IN, PCIE, 128, PULL) MANAGER_NODE_IO(Stream_4, output, OUT, PCIE, 32, PUSH) MANAGER_NODE_IO(Stream_8, input, IN, PCIE, 32, PULL) MANAGER_NODE_IO(Stream_8, output, OUT, PCIE, 128, PULL) MANAGER_NODE_IO(Stream_21, input, IN, PCIE, 128, PULL) MANAGER_NODE_IO(Stream_21, output, OUT, PCIE, 128, PUSH) MANAGER_NODE_IO(Stream_11, input, IN, PCIE, 128, PUSH) MANAGER_NODE_IO(Stream_11, output, OUT, PCIE, 128, PULL) MANAGER_NODE_IO(Stream_15, input, IN, PCIE, 128, PUSH) MANAGER_NODE_IO(Stream_15, output, OUT, PCIE, 128, PULL) MANAGER_NODE_IO(Stream_13, input, IN, PCIE, 32, PUSH) MANAGER_NODE_IO(Stream_13, output, OUT, STREAM, 32, PULL) MANAGER_NODE_IO(Stream_17, input, IN, PCIE, 32, PUSH) MANAGER_NODE_IO(Stream_17, output, OUT, STREAM, 32, PULL) MANAGER_NODE_IO(Stream_19, input, IN, STREAM, 32, PUSH) MANAGER_NODE_IO(Stream_19, output, OUT, PCIE, 32, PULL) #endif #ifdef MANAGER_STREAM #define MANAGER_STREAM_PRESENT 1 MANAGER_STREAM(a, a, Stream_11, input, 128) MANAGER_STREAM(b, b, Stream_15, input, 128) MANAGER_STREAM(StreamFMAKernel, output, Stream_19, input, 32) MANAGER_STREAM(Stream_1, output, Stream_13, input, 32) MANAGER_STREAM(Stream_4, output, Stream_17, input, 32) MANAGER_STREAM(Stream_8, output, Stream_21, input, 128) MANAGER_STREAM(Stream_21, output, output, output, 128) MANAGER_STREAM(Stream_11, output, Stream_1, input, 128) MANAGER_STREAM(Stream_15, output, Stream_4, input, 128) MANAGER_STREAM(Stream_13, output, StreamFMAKernel, a, 32) MANAGER_STREAM(Stream_17, output, StreamFMAKernel, b, 32) MANAGER_STREAM(Stream_19, output, Stream_8, input, 32) #endif #ifdef MANAGER_NODE_STACK_TRACE #define MANAGER_NODE_STACK_TRACE_PRESENT 1 MANAGER_NODE_STACK_TRACE(StreamFMAKernel, "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") MANAGER_NODE_STACK_TRACE(a, "com.maxeler.platform.max5.manager.Max5ManagerBase.addStreamFromCPU(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:14)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") MANAGER_NODE_STACK_TRACE(b, "com.maxeler.platform.max5.manager.Max5ManagerBase.addStreamFromCPU(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:15)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") MANAGER_NODE_STACK_TRACE(output, "com.maxeler.platform.max5.manager.Max5ManagerBase.addStreamToCPU(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:16)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") MANAGER_NODE_STACK_TRACE(Stream_1, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_4, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_8, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_21, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_11, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_15, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_13, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_17, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_19, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") #endif #ifdef MANAGER_NODE_PROPERTY #define MANAGER_NODE_PROPERTY_PRESENT 1 MANAGER_NODE_PROPERTY(StreamFMAKernel, control_pipelining_depth, 2) #endif #ifdef KERNEL_CORE #define KERNEL_CORE_PRESENT 1 KERNEL_CORE(StreamFMAKernel) #endif #ifdef KERNEL_HOST_CONTROLLED #define KERNEL_HOST_CONTROLLED_PRESENT 1 KERNEL_HOST_CONTROLLED(StreamFMAKernel, StreamFMAKernel) #endif #ifdef DEBUG_INPUT_BITS #define DEBUG_INPUT_BITS_PRESENT 1 DEBUG_INPUT_BITS(StreamFMAKernel, a, 0) DEBUG_INPUT_BITS(StreamFMAKernel, b, 1) #endif #ifdef DEBUG_OUTPUT_BITS #define DEBUG_OUTPUT_BITS_PRESENT 1 DEBUG_OUTPUT_BITS(StreamFMAKernel, output, 0) #endif #ifdef MANAGER_NODE_CPP_SIM_MODEL_CTOR #define MANAGER_NODE_CPP_SIM_MODEL_CTOR_PRESENT 1 MANAGER_NODE_CPP_SIM_MODEL_CTOR(b, PCIePushSourceSync16, "b") MANAGER_NODE_CPP_SIM_MODEL_CTOR(a, PCIePushSourceSync16, "a") MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_15, FifoPushToPullSync, "Stream_15", false, 512, 128) MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_11, FifoPushToPullSync, "Stream_11", false, 512, 128) MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_1, DualAspectMuxSync, "Stream_1", 32, 4) MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_4, DualAspectMuxSync, "Stream_4", 32, 4) MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_17, FifoPushToPullSync, "Stream_17", false, 512, 32) MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_13, FifoPushToPullSync, "Stream_13", false, 512, 32) MANAGER_NODE_CPP_SIM_MODEL_CTOR(StreamFMAKernel, StreamFMAKernel, "StreamFMAKernel") MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_19, FifoPushToPullSync, "Stream_19", false, 512, 32) MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_8, DualAspectRegSync, "Stream_8", 32, 4) MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_21, PullToPushAdapterSync, "Stream_21") MANAGER_NODE_CPP_SIM_MODEL_CTOR(output, PCIePushSinkSync16, "output") MANAGER_NODE_CPP_SIM_MODEL_CTOR(CapabilityReg, CapRegs, "CapabilityReg", 0, 2, 1, 0, 0, 0, 0, 0, 36) MANAGER_NODE_CPP_SIM_MODEL_CTOR(ifpga, IFPGARegs) MANAGER_NODE_CPP_SIM_MODEL_CTOR(sfa, SFARegs) MANAGER_NODE_CPP_SIM_MODEL_CTOR(ChecksumMemory, ChecksumMem, "ChecksumMemory", "ac5fbbbe6e4b46179c07a7a26c8647de7cec6bb27a42f5ac58fd3d986dbdfa72") #endif #ifdef MANAGER_NODE_CPP_SIM_MODEL_SETUP #define MANAGER_NODE_CPP_SIM_MODEL_SETUP_PRESENT 1 MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_ctld_almost_empty, 2, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_ctld_done, 2, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_ctld_empty, 2, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_ctld_read, 2, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_ctld_read_pipe_dbg, 6, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_ctld_request, 2, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_done_out, 1, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_fill_level, 4, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_flush_level, 4, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_flush_start, 1, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_flush_start_level, 4, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_flushing, 1, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_full_level, 4, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_out_stall, 1, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_out_valid, 1, 0) MANAGER_NODE_CPP_SIM_MODEL_SETUP(StreamFMAKernel, addDebugRegister, reg_dbg_stall_vector, 1, 0) #endif #ifdef PCIE_STREAM #define PCIE_STREAM_PRESENT 1 PCIE_STREAM(b, STREAM_FROM_HOST, 0) PCIE_STREAM(a, STREAM_FROM_HOST, 1) PCIE_STREAM(output, STREAM_TO_HOST, 0) #endif #ifdef REG #define REG_PRESENT 1 REG(StreamFMAKernel.io_a_force_disabled, 0x0, 1, hwOffsetFix(1, 0, UNSIGNED)) REG(StreamFMAKernel.io_b_force_disabled, 0x1, 1, hwOffsetFix(1, 0, UNSIGNED)) REG(StreamFMAKernel.io_output_force_disabled, 0x2, 1, hwOffsetFix(1, 0, UNSIGNED)) REG(StreamFMAKernel.run_cycle_count, 0x3, 6, hwOffsetFix(48, 0, UNSIGNED)) REG(StreamFMAKernel.current_run_cycle_count, 0x9, 6, hwOffsetFix(48, 0, UNSIGNED)) REG(StreamFMAKernel.dbg_ctld_almost_empty, 0xf, 1, hwBits(2)) REG(StreamFMAKernel.dbg_ctld_done, 0x10, 1, hwBits(2)) REG(StreamFMAKernel.dbg_ctld_empty, 0x11, 1, hwBits(2)) REG(StreamFMAKernel.dbg_ctld_read, 0x12, 1, hwBits(2)) REG(StreamFMAKernel.dbg_ctld_read_pipe_dbg, 0x13, 1, hwBits(6)) REG(StreamFMAKernel.dbg_ctld_request, 0x14, 1, hwBits(2)) REG(StreamFMAKernel.dbg_done_out, 0x15, 1, hwBits(1)) REG(StreamFMAKernel.dbg_fill_level, 0x16, 1, hwBits(4)) REG(StreamFMAKernel.dbg_flush_level, 0x17, 1, hwBits(4)) REG(StreamFMAKernel.dbg_flush_start, 0x18, 1, hwBits(1)) REG(StreamFMAKernel.dbg_flush_start_level, 0x19, 1, hwBits(4)) REG(StreamFMAKernel.dbg_flushing, 0x1a, 1, hwBits(1)) REG(StreamFMAKernel.dbg_full_level, 0x1b, 1, hwBits(4)) REG(StreamFMAKernel.dbg_out_stall, 0x1c, 1, hwBits(1)) REG(StreamFMAKernel.dbg_out_valid, 0x1d, 1, hwBits(1)) REG(StreamFMAKernel.dbg_stall_vector, 0x1e, 1, hwBits(1)) REG(ifpga.ifpga_ctrl, 0x1f, 1, hwBits(8)) REG(SignalForwardingAdapter.SFA_FORWARD_EN, 0x20, 4, hwBits(32)) #endif #ifdef REG_V2 #define REG_V2_PRESENT 1 REG_V2(StreamFMAKernel.io_a_force_disabled, 0x0, 1, hwOffsetFix(1, 0, UNSIGNED), HOST_WRITE_ONLY, true) REG_V2(StreamFMAKernel.io_b_force_disabled, 0x1, 1, hwOffsetFix(1, 0, UNSIGNED), HOST_WRITE_ONLY, true) REG_V2(StreamFMAKernel.io_output_force_disabled, 0x2, 1, hwOffsetFix(1, 0, UNSIGNED), HOST_WRITE_ONLY, true) REG_V2(StreamFMAKernel.run_cycle_count, 0x3, 6, hwOffsetFix(48, 0, UNSIGNED), HOST_WRITE_ONLY, false) REG_V2(StreamFMAKernel.current_run_cycle_count, 0x9, 6, hwOffsetFix(48, 0, UNSIGNED), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_ctld_almost_empty, 0xf, 1, hwBits(2), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_ctld_done, 0x10, 1, hwBits(2), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_ctld_empty, 0x11, 1, hwBits(2), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_ctld_read, 0x12, 1, hwBits(2), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_ctld_read_pipe_dbg, 0x13, 1, hwBits(6), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_ctld_request, 0x14, 1, hwBits(2), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_done_out, 0x15, 1, hwBits(1), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_fill_level, 0x16, 1, hwBits(4), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_flush_level, 0x17, 1, hwBits(4), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_flush_start, 0x18, 1, hwBits(1), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_flush_start_level, 0x19, 1, hwBits(4), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_flushing, 0x1a, 1, hwBits(1), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_full_level, 0x1b, 1, hwBits(4), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_out_stall, 0x1c, 1, hwBits(1), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_out_valid, 0x1d, 1, hwBits(1), HOST_READ_ONLY, false) REG_V2(StreamFMAKernel.dbg_stall_vector, 0x1e, 1, hwBits(1), HOST_READ_ONLY, false) REG_V2(ifpga.ifpga_ctrl, 0x1f, 1, hwBits(8), HOST_READ_WRITE, false) REG_V2(SignalForwardingAdapter.SFA_FORWARD_EN, 0x20, 4, hwBits(32), HOST_READ_WRITE, false) #endif #ifdef CHECKSUM #define CHECKSUM_PRESENT 1 CHECKSUM("ac5fbbbe6e4b46179c07a7a26c8647de7cec6bb27a42f5ac58fd3d986dbdfa72") #endif #ifdef CAPABILITY #define CAPABILITY_PRESENT 1 CAPABILITY(LIMAREV, LIMAREVA) CAPABILITY(LIMARAM, DDR4_48GB) CAPABILITY(LIMAFPGA, xcVU9P_FLGB2104_2_E) #endif #ifdef DEFINE_DESIGN_NAME #define DESIGN_NAME StreamFMA #endif /* DEFINE_DESIGN_NAME */ #ifndef SLIC_NO_DECLARATIONS /**\file */ #ifndef SLIC_DECLARATIONS_StreamFMA_H #define SLIC_DECLARATIONS_StreamFMA_H #include "MaxSLiCInterface.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ #define StreamFMA_DYNAMIC_CLOCKS_ENABLED (0) #define StreamFMA_PCIE_ALIGNMENT (16) /*----------------------------------------------------------------------------*/ /*---------------------------- Interface default -----------------------------*/ /*----------------------------------------------------------------------------*/ /** * \brief Basic static function for the interface 'default'. * * \param [in] ticks_StreamFMAKernel The number of ticks for which kernel "StreamFMAKernel" will run. * \param [in] instream_a Stream "a". * \param [in] instream_size_a The size of the stream instream_a in bytes. * \param [in] instream_b Stream "b". * \param [in] instream_size_b The size of the stream instream_b in bytes. * \param [out] outstream_output Stream "output". * \param [in] outstream_size_output The size of the stream outstream_output in bytes. */ void StreamFMA( uint64_t ticks_StreamFMAKernel, const void *instream_a, size_t instream_size_a, const void *instream_b, size_t instream_size_b, void *outstream_output, size_t outstream_size_output); /** * \brief Basic static non-blocking function for the interface 'default'. * * Schedule to run on an engine and return immediately. * The status of the run can be checked either by ::max_wait or ::max_nowait; * note that one of these *must* be called, so that associated memory can be released. * * * \param [in] ticks_StreamFMAKernel The number of ticks for which kernel "StreamFMAKernel" will run. * \param [in] instream_a Stream "a". * \param [in] instream_size_a The size of the stream instream_a in bytes. * \param [in] instream_b Stream "b". * \param [in] instream_size_b The size of the stream instream_b in bytes. * \param [out] outstream_output Stream "output". * \param [in] outstream_size_output The size of the stream outstream_output in bytes. * \return A handle on the execution status, or NULL in case of error. */ max_run_t *StreamFMA_nonblock( uint64_t ticks_StreamFMAKernel, const void *instream_a, size_t instream_size_a, const void *instream_b, size_t instream_size_b, void *outstream_output, size_t outstream_size_output); /** * \brief Advanced static interface, structure for the engine interface 'default' * */ typedef struct { uint64_t ticks_StreamFMAKernel; /**< [in] The number of ticks for which kernel "StreamFMAKernel" will run. */ const void *instream_a; /**< [in] Stream "a". */ size_t instream_size_a; /**< [in] The size of the stream instream_a in bytes. */ const void *instream_b; /**< [in] Stream "b". */ size_t instream_size_b; /**< [in] The size of the stream instream_b in bytes. */ void *outstream_output; /**< [out] Stream "output". */ size_t outstream_size_output; /**< [in] The size of the stream outstream_output in bytes. */ } StreamFMA_actions_t; /** * \brief Advanced static function for the interface 'default'. * * \param [in] engine The engine on which the actions will be executed. * \param [in,out] interface_actions Actions to be executed. */ void StreamFMA_run( max_engine_t *engine, StreamFMA_actions_t *interface_actions); /** * \brief Advanced static non-blocking function for the interface 'default'. * * Schedule the actions to run on the engine and return immediately. * The status of the run can be checked either by ::max_wait or ::max_nowait; * note that one of these *must* be called, so that associated memory can be released. * * * \param [in] engine The engine on which the actions will be executed. * \param [in] interface_actions Actions to be executed. * \return A handle on the execution status of the actions, or NULL in case of error. */ max_run_t *StreamFMA_run_nonblock( max_engine_t *engine, StreamFMA_actions_t *interface_actions); /** * \brief Group run advanced static function for the interface 'default'. * * \param [in] group Group to use. * \param [in,out] interface_actions Actions to run. * * Run the actions on the first device available in the group. */ void StreamFMA_run_group(max_group_t *group, StreamFMA_actions_t *interface_actions); /** * \brief Group run advanced static non-blocking function for the interface 'default'. * * * Schedule the actions to run on the first device available in the group and return immediately. * The status of the run must be checked with ::max_wait. * Note that use of ::max_nowait is prohibited with non-blocking running on groups: * see the ::max_run_group_nonblock documentation for more explanation. * * \param [in] group Group to use. * \param [in] interface_actions Actions to run. * \return A handle on the execution status of the actions, or NULL in case of error. */ max_run_t *StreamFMA_run_group_nonblock(max_group_t *group, StreamFMA_actions_t *interface_actions); /** * \brief Array run advanced static function for the interface 'default'. * * \param [in] engarray The array of devices to use. * \param [in,out] interface_actions The array of actions to run. * * Run the array of actions on the array of engines. The length of interface_actions * must match the size of engarray. */ void StreamFMA_run_array(max_engarray_t *engarray, StreamFMA_actions_t *interface_actions[]); /** * \brief Array run advanced static non-blocking function for the interface 'default'. * * * Schedule to run the array of actions on the array of engines, and return immediately. * The length of interface_actions must match the size of engarray. * The status of the run can be checked either by ::max_wait or ::max_nowait; * note that one of these *must* be called, so that associated memory can be released. * * \param [in] engarray The array of devices to use. * \param [in] interface_actions The array of actions to run. * \return A handle on the execution status of the actions, or NULL in case of error. */ max_run_t *StreamFMA_run_array_nonblock(max_engarray_t *engarray, StreamFMA_actions_t *interface_actions[]); /** * \brief Converts a static-interface action struct into a dynamic-interface max_actions_t struct. * * Note that this is an internal utility function used by other functions in the static interface. * * \param [in] maxfile The maxfile to use. * \param [in] interface_actions The interface-specific actions to run. * \return The dynamic-interface actions to run, or NULL in case of error. */ max_actions_t* StreamFMA_convert(max_file_t *maxfile, StreamFMA_actions_t *interface_actions); /** * \brief Initialise a maxfile. */ max_file_t* StreamFMA_init(void); /* Error handling functions */ int StreamFMA_has_errors(void); const char* StreamFMA_get_errors(void); void StreamFMA_clear_errors(void); /* Free statically allocated maxfile data */ void StreamFMA_free(void); /* returns: -1 = error running command; 0 = no error reported */ int StreamFMA_simulator_start(void); /* returns: -1 = error running command; 0 = no error reported */ int StreamFMA_simulator_stop(void); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* SLIC_DECLARATIONS_StreamFMA_H */ #endif /* SLIC_NO_DECLARATIONS */ #ifdef PHOTON_NODE_DATA #define PHOTON_NODE_DATA_PRESENT 1 PHOTON_NODE_DATA(StreamFMAKernel, 8, NodeInputMappedReg, "Scalar input (io_output_force_disabled)", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.output(IO.java:836)\nperfmodels.StreamFMAKernel.(StreamFMAKernel.maxj:21)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 9, NodeNot, "~", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.output(IO.java:836)\nperfmodels.StreamFMAKernel.(StreamFMAKernel.maxj:21)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 0, NodeInputMappedReg, "Scalar input (io_a_force_disabled)", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\nperfmodels.StreamFMAKernel.(StreamFMAKernel.maxj:15)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 1, NodeNot, "~", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\nperfmodels.StreamFMAKernel.(StreamFMAKernel.maxj:15)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 2, NodeInput, "Input(a)", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\nperfmodels.StreamFMAKernel.(StreamFMAKernel.maxj:15)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 3, NodeInputMappedReg, "Scalar input (io_b_force_disabled)", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\nperfmodels.StreamFMAKernel.(StreamFMAKernel.maxj:16)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 4, NodeNot, "~", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\nperfmodels.StreamFMAKernel.(StreamFMAKernel.maxj:16)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 5, NodeInput, "Input(b)", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\nperfmodels.StreamFMAKernel.(StreamFMAKernel.maxj:16)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 6, NodeAdd, "+", "com.maxeler.maxcompiler.v2.kernelcompiler.types.base.DFEVar.add(DFEVar.java:1010)\nperfmodels.StreamFMAKernel.(StreamFMAKernel.maxj:19)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 11, NodeOutput, "Output(output)", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.output(IO.java:836)\nperfmodels.StreamFMAKernel.(StreamFMAKernel.maxj:21)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 16, NodeConstantRawBits, "{HWOffsetFix:1, 0, UNSIGNED}\n0x1; 1.0", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 26, NodeConstantRawBits, "{HWOffsetFix:1, 0, UNSIGNED}\n0x1; 1.0", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 13, NodeConstantRawBits, "{HWOffsetFix:49, 0, UNSIGNED}\n0x1000000000000; 2.81474976710656E14", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 14, NodeCounter, "Counter(NUMERIC_INCREMENTING)\nInc: 1\nReset: 0\nInit: 0", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 15, NodeStreamOffset, "stream offset: 1", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 17, NodeOutputMappedReg, "Scalar output (current_run_cycle_count)", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 25, NodeConstantRawBits, "{HWOffsetFix:1, 0, UNSIGNED}\n0x1; 1.0", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 19, NodeConstantRawBits, "{HWOffsetFix:49, 0, UNSIGNED}\n0x1000000000000; 2.81474976710656E14", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 20, NodeCounter, "Counter(NUMERIC_INCREMENTING)\nInc: 1\nReset: 0\nInit: 0", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 22, NodeInputMappedReg, "Scalar input (run_cycle_count)", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 24, NodeEqInlined, "==", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 21, NodeFlush, "flush on trigger", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\nperfmodels.StreamFMAManager.(StreamFMAManager.maxj:13)\nperfmodels.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") #endif #ifdef SLIC_USE_DEFINITIONS #include #include #include #include #include #include static max_file_t *stored_maxfile = NULL; static max_engine_t *stored_engine = NULL; static char *stored_error = NULL; static int stored_has_error = 0; static pthread_once_t slic_bs_is_initialised = PTHREAD_ONCE_INIT; static void set_error(const char *error_str) { stored_has_error = 1; if(stored_error == NULL) { stored_error = strdup(error_str); } else { char *nerr = malloc(strlen(stored_error) + strlen(error_str) + 2); sprintf(nerr, "%s\n%s", stored_error, error_str); free(stored_error); stored_error = nerr; } } static void set_error_and_free(char *error_str){ set_error(error_str); free(error_str); } int StreamFMA_has_errors(void) { return stored_has_error; } const char* StreamFMA_get_errors(void) { return stored_error; } void StreamFMA_clear_errors(void) { free(stored_error); stored_error = NULL; stored_has_error = 0; } static char StreamFMA_use_simulation[16]; static void StreamFMA_def_use_simulation(void) { long pid = ((long) getpid()) % 100000; snprintf(StreamFMA_use_simulation, 16, "StreamFM_%05ld_", pid); } static const char *StreamFMA_check_use_simulation(void) { StreamFMA_def_use_simulation(); const char *use_sim = max_config_get_string(MAX_CONFIG_USE_SIMULATION); if (use_sim == NULL) { use_sim = StreamFMA_use_simulation; max_config_set_string(MAX_CONFIG_USE_SIMULATION, use_sim); } return use_sim; } static int StreamFMA_simulation_launch = 0; int StreamFMA_simulator_start(void) { int retval = 0; const char *use_sim = StreamFMA_check_use_simulation(); char buff[1024]; snprintf(buff, 1024, "PATH=simutils:$PATH maxcompilersim -d 1 -n %s -c MAX5C -S simutils restart", use_sim); FILE *pipe_fp = popen(buff, "r"); if (pipe_fp == NULL) { strncat(buff, " : failed to execute.", (1024 - strlen(buff))); set_error(buff); return -1; } while (fgets(buff, 1024, pipe_fp) != NULL) { /* Uncomment this to get simulator command output */ /* fprintf(stderr, buff); */ if (strstr(buff, "Error")) { set_error(buff); retval = -1; } } pclose(pipe_fp); return retval; } int StreamFMA_simulator_stop(void) { const char *use_sim = StreamFMA_check_use_simulation(); char buff[1024]; snprintf(buff, 1024, "PATH=simutils:$PATH maxcompilersim -d 1 -n %s -c MAX5C -S simutils stop", use_sim); FILE *pipe_fp = popen(buff, "r"); if (pipe_fp == NULL) { strncat(buff, " : failed to execute.", (1024 - strlen(buff))); set_error(buff); return -1; } while (fgets(buff, 1024, pipe_fp) != NULL) { /* Uncomment this to get simulator command output */ /* fprintf(stderr, buff); */ ; } pclose(pipe_fp); return 0; } static void StreamFMA_static_init(void) { stored_maxfile = StreamFMA_init(); if (stored_maxfile == NULL || !max_ok(stored_maxfile->errors)) { stored_maxfile = NULL; if(max_config_get_bool(MAX_CONFIG_STATIC_INTERFACE_ABORT_ON_ERROR)) abort(); else { set_error("Unable to load maxfile"); return; } } if(!max_ok(max_global_errors())) { set_error_and_free(max_errors_trace(max_global_errors())); return; } if(!max_config_get_bool(MAX_CONFIG_STATIC_INTERFACE_ABORT_ON_ERROR)) max_errors_mode(stored_maxfile->errors, 0); time_t timeout_previous = max_load_timeout(stored_maxfile, 30); const char *use_sim = StreamFMA_check_use_simulation(); if (max_ping_daemon(stored_maxfile, use_sim) == 0) { int sim_stat = StreamFMA_simulator_start(); if ((sim_stat == 0) && (max_ping_daemon(stored_maxfile, use_sim) == 1)) { StreamFMA_simulation_launch = 1; } else { set_error("Error: An error occurred while trying to start the simulation infrastructure automatically."); set_error("Error: Check that 'use_simulation=' is set correctly in your SLiC configuration"); set_error("Error: and that the associated simulated system daemon is running."); max_file_free(stored_maxfile); stored_maxfile = NULL; return; } } stored_engine = max_load(stored_maxfile, "*"); if (!max_ok(stored_maxfile->errors)) { if(max_config_get_bool(MAX_CONFIG_STATIC_INTERFACE_ABORT_ON_ERROR)) { fprintf(stderr, "\nUnable to load engine: aborting now.\n\n"); fflush(stderr); abort(); } else { set_error_and_free(max_errors_trace(stored_maxfile->errors)); max_file_free(stored_maxfile); stored_maxfile = NULL; return; } } max_load_timeout(stored_maxfile, timeout_previous); } void StreamFMA_free(void) { if (stored_engine != NULL) { max_unload(stored_engine); stored_engine = NULL; } if (stored_maxfile != NULL) { max_file_free(stored_maxfile); stored_maxfile = NULL; } if (stored_error != NULL) { free(stored_error); stored_error = NULL; } if (StreamFMA_simulation_launch == 1) { int sim_stat = StreamFMA_simulator_stop(); if (sim_stat != 0 ) { fprintf(stderr, "Error stopping simulator."); } StreamFMA_simulation_launch = 0; } } static int StreamFMA_get_pcie_alignment(void) { #ifdef StreamFMA_PCIE_ALIGNMENT return ((StreamFMA_PCIE_ALIGNMENT < 1) ? 16 : StreamFMA_PCIE_ALIGNMENT); #else return 16; #endif } static int StreamFMA_check_aligned(const void *data) { uintptr_t pointer = (uintptr_t) data; int alignment = StreamFMA_get_pcie_alignment(); return (pointer % alignment) ? 1 : 0; } static void *StreamFMA_malloc_aligned(const size_t size) { void *ptr; int alignment = StreamFMA_get_pcie_alignment(); posix_memalign(&ptr, alignment, size); return ptr; } /*----------------------------------------------------------------------------*/ /*---------------------------- Interface default -----------------------------*/ /*----------------------------------------------------------------------------*/ #define CHECK_ERRORS_ST(ST, RET) if(!max_ok(ST->errors)) { if(max_config_get_bool(MAX_CONFIG_STATIC_INTERFACE_ABORT_ON_ERROR)) { fprintf(stderr, "%s\n", max_errors_trace(ST->errors)); abort(); } set_error_and_free(max_errors_trace(ST->errors)); return RET; } #define CHECK_NULL(VALUE, MESSAGE, RET) if(VALUE == NULL) { if (max_config_get_bool(MAX_CONFIG_STATIC_INTERFACE_ABORT_ON_ERROR)) { fprintf(stderr, "%s\n%s\n", (stored_error == NULL) ? "" : stored_error, MESSAGE); abort(); } set_error(MESSAGE); return RET; } typedef struct StreamFMA_callback_stream { uint8_t *user_ptr; uint8_t *aligned_ptr; size_t size; int is_output; } StreamFMA_callback_stream_t; typedef struct StreamFMA_callback_data { StreamFMA_callback_stream_t stream[3]; int count; int max_count; } StreamFMA_callback_data_t; static void StreamFMA_callback_internal(void *cb_data) { StreamFMA_callback_data_t *data = (StreamFMA_callback_data_t*) cb_data; for (int i = 0 ; i < data->count ; i++ ) { StreamFMA_callback_stream_t *s = &data->stream[i]; if (s->is_output && (s->size > 0)) { memcpy(s->user_ptr, s->aligned_ptr, s->size); } free(s->aligned_ptr); } free(data); } static max_actions_t* StreamFMA_convert_internal( max_file_t *maxfile, StreamFMA_actions_t *interface_actions, int is_internal_call, void (**callback_func)(void*), void **callback_data) { max_actions_t *actions = max_actions_init(maxfile, NULL); if(actions == NULL) return NULL; #define CHECK_ERRORS if(!max_ok(actions->errors)) { set_error_and_free(max_errors_trace(actions->errors)); return NULL; } StreamFMA_callback_data_t *cb_data = NULL; int use_callback = (callback_func != NULL) && (callback_data != NULL); if (use_callback) { cb_data = malloc(sizeof(StreamFMA_callback_data_t)); if (cb_data == NULL) { fprintf(stderr, "Unable to allocate memory for stream callback data in function StreamFMA_convert_internal\n"); return NULL; } cb_data->max_count = 3; cb_data->count = 0; *callback_data = cb_data; *callback_func = &StreamFMA_callback_internal; } /* code for scalar StreamFMAKernel.run_cycle_count */ uint64_t ticks_StreamFMAKernel = interface_actions->ticks_StreamFMAKernel; max_set_ticks(actions, "StreamFMAKernel", ticks_StreamFMAKernel); CHECK_ERRORS; /* end of code for scalar StreamFMAKernel.run_cycle_count*/ /* code for stream a */ size_t instream_size_a = interface_actions->instream_size_a; if (instream_size_a > 0) { const void *stream_ptr = interface_actions->instream_a; if (use_callback && (1 == StreamFMA_check_aligned(interface_actions->instream_a))) { void *aligned_instream_a = malloc(instream_size_a); if (aligned_instream_a == NULL) { max_report_error_slic(actions->errors, __FILE__, __LINE__, 526, "Failed to allocate aligned memory for stream 'a'"); CHECK_ERRORS; } (&cb_data->stream[cb_data->count])->user_ptr = (uint8_t*) interface_actions->instream_a; (&cb_data->stream[cb_data->count])->aligned_ptr = (uint8_t*) aligned_instream_a; (&cb_data->stream[cb_data->count])->size = instream_size_a; (&cb_data->stream[cb_data->count])->is_output = 0; cb_data->count += 1; memcpy(aligned_instream_a, interface_actions->instream_a, instream_size_a); stream_ptr = aligned_instream_a; } max_queue_input(actions, "a", stream_ptr, instream_size_a); CHECK_ERRORS; } /* end of code for stream a */ /* code for stream b */ size_t instream_size_b = interface_actions->instream_size_b; if (instream_size_b > 0) { const void *stream_ptr = interface_actions->instream_b; if (use_callback && (1 == StreamFMA_check_aligned(interface_actions->instream_b))) { void *aligned_instream_b = malloc(instream_size_b); if (aligned_instream_b == NULL) { max_report_error_slic(actions->errors, __FILE__, __LINE__, 526, "Failed to allocate aligned memory for stream 'b'"); CHECK_ERRORS; } (&cb_data->stream[cb_data->count])->user_ptr = (uint8_t*) interface_actions->instream_b; (&cb_data->stream[cb_data->count])->aligned_ptr = (uint8_t*) aligned_instream_b; (&cb_data->stream[cb_data->count])->size = instream_size_b; (&cb_data->stream[cb_data->count])->is_output = 0; cb_data->count += 1; memcpy(aligned_instream_b, interface_actions->instream_b, instream_size_b); stream_ptr = aligned_instream_b; } max_queue_input(actions, "b", stream_ptr, instream_size_b); CHECK_ERRORS; } /* end of code for stream b */ /* code for stream output */ size_t outstream_size_output = interface_actions->outstream_size_output; if (outstream_size_output > 0) { void *stream_ptr = interface_actions->outstream_output; if (use_callback && (1 == StreamFMA_check_aligned(interface_actions->outstream_output))) { void *aligned_outstream_output = malloc(outstream_size_output); if (aligned_outstream_output == NULL) { max_report_error_slic(actions->errors, __FILE__, __LINE__, 526, "Failed to allocate aligned memory for stream 'output'"); CHECK_ERRORS; } (&cb_data->stream[cb_data->count])->user_ptr = (uint8_t*) interface_actions->outstream_output; (&cb_data->stream[cb_data->count])->aligned_ptr = (uint8_t*) aligned_outstream_output; (&cb_data->stream[cb_data->count])->size = outstream_size_output; (&cb_data->stream[cb_data->count])->is_output = 1; cb_data->count += 1; stream_ptr = aligned_outstream_output; } max_queue_output(actions, "output", stream_ptr, outstream_size_output); CHECK_ERRORS; } /* end of code for stream output */ if (use_callback && cb_data->count == 0) { *callback_data = NULL; *callback_func = NULL; free(cb_data); } return actions; #undef CHECK_ERRORS } void StreamFMA( uint64_t ticks_StreamFMAKernel, const void *instream_a, size_t instream_size_a, const void *instream_b, size_t instream_size_b, void *outstream_output, size_t outstream_size_output) { (void) pthread_once(&slic_bs_is_initialised, StreamFMA_static_init); CHECK_NULL(stored_maxfile, "Maxfile was not loaded", ); max_run_t *run = StreamFMA_nonblock(ticks_StreamFMAKernel, instream_a, instream_size_a, instream_b, instream_size_b, outstream_output, outstream_size_output); CHECK_NULL(run, "Unable to run actions", ); max_wait(run); } max_run_t *StreamFMA_nonblock( uint64_t ticks_StreamFMAKernel, const void *instream_a, size_t instream_size_a, const void *instream_b, size_t instream_size_b, void *outstream_output, size_t outstream_size_output) { StreamFMA_actions_t interface_actions; interface_actions.ticks_StreamFMAKernel = ticks_StreamFMAKernel; interface_actions.instream_a = instream_a; interface_actions.instream_size_a = instream_size_a; interface_actions.instream_b = instream_b; interface_actions.instream_size_b = instream_size_b; interface_actions.outstream_output = outstream_output; interface_actions.outstream_size_output = outstream_size_output; (void) pthread_once(&slic_bs_is_initialised, StreamFMA_static_init); CHECK_NULL(stored_maxfile, "Maxfile was not loaded", NULL); void (*cb_func)(void*) = NULL; void *cb_data = NULL; max_actions_t *actions = StreamFMA_convert_internal(stored_maxfile, &interface_actions, 1, &cb_func, &cb_data); CHECK_NULL(actions, "Unable to build actions", NULL); max_validate(actions); CHECK_ERRORS_ST(actions, NULL); CHECK_ERRORS_ST(stored_engine, NULL); max_run_t *run; if (cb_func == NULL) { run = max_run_nonblock(stored_engine, actions); } else { run = max_run_nonblock_with_cb(stored_engine, actions, cb_func, cb_data); } CHECK_NULL(run, "Unable to run actions", NULL); CHECK_ERRORS_ST(actions, NULL); max_actions_free(actions); return run; } void StreamFMA_run( max_engine_t *engine, StreamFMA_actions_t *interface_actions) { max_run_t *run = StreamFMA_run_nonblock(engine, interface_actions); CHECK_NULL(run, "Unable to run actions", ); max_wait(run); } max_run_t *StreamFMA_run_nonblock( max_engine_t *engine, StreamFMA_actions_t *interface_actions) { max_file_t *maxfile = max_engine_get_max_file(engine); void (*cb_func)(void*) = NULL; void *cb_data = NULL; max_actions_t *actions = StreamFMA_convert_internal(maxfile, interface_actions, 1, &cb_func, &cb_data); CHECK_NULL(actions, "Unable to build actions", NULL); max_validate(actions); CHECK_ERRORS_ST(actions, NULL); max_run_t *run; if (cb_func == NULL) { run = max_run_nonblock(engine, actions); } else { run = max_run_nonblock_with_cb(engine, actions, cb_func, cb_data); } CHECK_NULL(run, "Unable to run actions", NULL); max_actions_free(actions); return run; } /** * \brief Group run advanced static function for the interface 'default'. * * \param [in] group Group to use. * \param [in,out] interface_actions Actions to run. * * Run the actions on the first device available in the group. */ void StreamFMA_run_group(max_group_t *group, StreamFMA_actions_t *interface_actions) { max_run_t *run = StreamFMA_run_group_nonblock(group, interface_actions); CHECK_NULL(run, "Unable to run actions", ); max_wait(run); } /** * \brief Group run advanced static non-blocking function for the interface 'default'. * * * Schedule the actions to run on the first device available in the group and return immediately. * The status of the run must be checked with ::max_wait. * Note that use of ::max_nowait is prohibited with non-blocking running on groups: * see the ::max_run_group_nonblock documentation for more explanation. * * \param [in] group Group to use. * \param [in] interface_actions Actions to run. * \return A handle on the execution status of the actions, or NULL in case of error. */ max_run_t *StreamFMA_run_group_nonblock(max_group_t *group, StreamFMA_actions_t *interface_actions) { max_file_t *maxfile = max_group_get_max_file(group); max_actions_t *actions = StreamFMA_convert_internal(maxfile, interface_actions, 1, NULL, NULL); if(actions == NULL) return NULL; if(!max_ok(actions->errors)) return NULL; max_validate(actions); max_run_t *run = max_run_group_nonblock(group, actions); max_actions_free(actions); return run; } /** * \brief Array run advanced static function for the interface 'default'. * * \param [in] engarray The array of devices to use. * \param [in,out] interface_actions The array of actions to run. * * Run the array of actions on the array of engines. The length of interface_actions * must match the size of engarray. */ void StreamFMA_run_array(max_engarray_t *engarray, StreamFMA_actions_t *interface_actions[]) { max_run_t *run = StreamFMA_run_array_nonblock(engarray, interface_actions); CHECK_NULL(run, "Unable to run actions", ); max_wait(run); } /** * \brief Array run advanced static non-blocking function for the interface 'default'. * * * Schedule to run the array of actions on the array of engines, and return immediately. * The length of interface_actions must match the size of engarray. * The status of the run can be checked either by ::max_wait or ::max_nowait; * note that one of these *must* be called, so that associated memory can be released. * * \param [in] engarray The array of devices to use. * \param [in] interface_actions The array of actions to run. * \return A handle on the execution status of the actions, or NULL in case of error. */ max_run_t *StreamFMA_run_array_nonblock(max_engarray_t *engarray, StreamFMA_actions_t *interface_actions[]) { max_file_t *maxfile = max_engarray_get_max_file(engarray, 0); int i; max_actarray_t *actarray = max_actarray_init(maxfile, engarray->size); if (actarray == NULL) return NULL; max_actions_t **arr_actions = malloc(engarray->size * sizeof(max_actions_t*)); for ( i = 0 ; i < actarray->size; i++ ) { max_actions_t *actions = StreamFMA_convert_internal(maxfile, interface_actions[i], 1, NULL, NULL); if (actions == NULL) return NULL; arr_actions[i] = actions; max_set_action(actarray, i, actions); } max_run_t *run = max_run_array_nonblock(engarray, actarray); for ( i = 0 ; i < actarray->size ; i++ ) { max_actions_free(arr_actions[i]); } max_actarray_free(actarray); free(arr_actions); return run; } /** * \brief Converts a static-interface action struct into a dynamic-interface max_actions_t struct. * * Note that this is an internal utility function used by other functions in the static interface. * * \param [in] maxfile The maxfile to use. * \param [in] interface_actions The interface-specific actions to run. * \return The dynamic-interface actions to run, or NULL in case of error. */ max_actions_t* StreamFMA_convert(max_file_t *maxfile, StreamFMA_actions_t *interface_actions) { return StreamFMA_convert_internal(maxfile, interface_actions, 0, NULL, NULL); } #undef CHECK_ERRORS_ST #undef CHECK_NULL #endif /* SLIC_USE_DEFINITIONS */ #ifdef SLIC_DYNAMIC_CODE SLIC_MODE_START(default) SLIC_MODE_END(default) #endif /* SLIC_DYNAMIC_CODE */ #ifdef SKIN_META_DATA PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9Im5vIj8+PG1h eGZpbGUgZm9ybWF0LXZlcnNpb249IjIwMTIwMjAwIiBoZWFkZXI9IlN0cmVhbUZNQS5oIiBuYW1l PSJTdHJlYW1GTUEiPjxjb25zdGFudCBuYW1lPSJEWU5BTUlDX0NMT0NLU19FTkFCTEVEIiB0eXBl PSJsb25nIiB2YWx1ZT0iMCIvPjxjb25zdGFudCBuYW1lPSJQQ0lFX0FMSUdOTUVOVCIgdHlwZT0i bG9uZyIgdmFsdWU9IjE2Ii8+PGVuZ2luZW1vZGUgbmFtZT0iZGVmYXVsdCI+PGZ1bmN0aW9uIG5h bWU9IlN0cmVhbUZNQSIgcmV0dXJuLXZhbHVlPSJ2b2lkIj48c2NhbGFyIGRlc2M9IlRoZSBudW1i ZXIgb2YgdGlja3MgZm9yIHdoaWNoIGtlcm5lbCAmcXVvdDtTdHJlYW1GTUFLZXJuZWwmcXVvdDsg d2lsbCBydW4uIiBkaXJlY3Rpb249IklucHV0IiBuYW1lPSJ0aWNrc19TdHJlYW1GTUFLZXJuZWwi IHR5cGU9InVpbnQ2NF90Ii8+PGFycmF5IGRlc2M9IlN0cmVhbSAmcXVvdDthJnF1b3Q7LiIgZGly ZWN0aW9uPSJJbnB1dCIgbmFtZT0iaW5zdHJlYW1fYSIgc2l6ZT0iaW5zdHJlYW1fc2l6ZV9hIiB0 cmFuc3Bvc2U9ImZhbHNlIiB0eXBlPSJ2b2lkIi8+PHNjYWxhciBkZXNjPSJUaGUgc2l6ZSBvZiB0 aGUgc3RyZWFtIGluc3RyZWFtX2EgaW4gYnl0ZXMuIiBkaXJlY3Rpb249IklucHV0IiBuYW1lPSJp bnN0cmVhbV9zaXplX2EiIHR5cGU9InVpbnQ2NF90Ii8+PGFycmF5IGRlc2M9IlN0cmVhbSAmcXVv dDtiJnF1b3Q7LiIgZGlyZWN0aW9uPSJJbnB1dCIgbmFtZT0iaW5zdHJlYW1fYiIgc2l6ZT0iaW5z dHJlYW1fc2l6ZV9iIiB0cmFuc3Bvc2U9ImZhbHNlIiB0eXBlPSJ2b2lkIi8+PHNjYWxhciBkZXNj PSJUaGUgc2l6ZSBvZiB0aGUgc3RyZWFtIGluc3RyZWFtX2IgaW4gYnl0ZXMuIiBkaXJlY3Rpb249 IklucHV0IiBuYW1lPSJpbnN0cmVhbV9zaXplX2IiIHR5cGU9InVpbnQ2NF90Ii8+PGFycmF5IGRl c2M9IlN0cmVhbSAmcXVvdDtvdXRwdXQmcXVvdDsuIiBkaXJlY3Rpb249Ik91dHB1dCIgbmFtZT0i b3V0c3RyZWFtX291dHB1dCIgc2l6ZT0ib3V0c3RyZWFtX3NpemVfb3V0cHV0IiB0cmFuc3Bvc2U9 ImZhbHNlIiB0eXBlPSJ2b2lkIi8+PHNjYWxhciBkZXNjPSJUaGUgc2l6ZSBvZiB0aGUgc3RyZWFt IG91dHN0cmVhbV9vdXRwdXQgaW4gYnl0ZXMuIiBkaXJlY3Rpb249IklucHV0IiBuYW1lPSJvdXRz dHJlYW1fc2l6ZV9vdXRwdXQiIHR5cGU9InVpbnQ2NF90Ii8+PC9mdW5jdGlvbj48L2VuZ2luZW1v ZGU+PC9tYXhmaWxlPg== #endif /* SKIN_META_DATA */ #ifdef SLIC_B64_DEFINITIONS I2luY2x1ZGUgPHN0ZGlvLmg+CiNpbmNsdWRlIDxtYXRoLmg+CiNpbmNsdWRlIDxwdGhyZWFkLmg+ CiNpbmNsdWRlIDxzdHJpbmcuaD4KI2luY2x1ZGUgPHVuaXN0ZC5oPgojaW5jbHVkZSA8c3RkbGli Lmg+CnN0YXRpYyBtYXhfZmlsZV90ICpzdG9yZWRfbWF4ZmlsZSA9IE5VTEw7CnN0YXRpYyBtYXhf ZW5naW5lX3QgKnN0b3JlZF9lbmdpbmUgPSBOVUxMOwpzdGF0aWMgY2hhciAqc3RvcmVkX2Vycm9y ID0gTlVMTDsKc3RhdGljIGludCBzdG9yZWRfaGFzX2Vycm9yID0gMDsKc3RhdGljIHB0aHJlYWRf b25jZV90IHNsaWNfYnNfaXNfaW5pdGlhbGlzZWQgPSBQVEhSRUFEX09OQ0VfSU5JVDsKCnN0YXRp YyB2b2lkIHNldF9lcnJvcihjb25zdCBjaGFyICplcnJvcl9zdHIpCnsKCXN0b3JlZF9oYXNfZXJy b3IgPSAxOyAKCWlmKHN0b3JlZF9lcnJvciA9PSBOVUxMKSB7CgkJc3RvcmVkX2Vycm9yID0gc3Ry ZHVwKGVycm9yX3N0cik7Cgl9IGVsc2UgewoJCWNoYXIgKm5lcnIgPSBtYWxsb2Moc3RybGVuKHN0 b3JlZF9lcnJvcikgKyBzdHJsZW4oZXJyb3Jfc3RyKSArIDIpOwoJCXNwcmludGYobmVyciwgIiVz XG4lcyIsIHN0b3JlZF9lcnJvciwgZXJyb3Jfc3RyKTsKCQlmcmVlKHN0b3JlZF9lcnJvcik7CgkJ c3RvcmVkX2Vycm9yID0gbmVycjsKCX0KfQpzdGF0aWMgdm9pZCBzZXRfZXJyb3JfYW5kX2ZyZWUo Y2hhciAqZXJyb3Jfc3RyKXsKCXNldF9lcnJvcihlcnJvcl9zdHIpOwoJZnJlZShlcnJvcl9zdHIp Owp9CmludCBTdHJlYW1GTUFfaGFzX2Vycm9ycyh2b2lkKQp7CXJldHVybiBzdG9yZWRfaGFzX2Vy cm9yOyB9CmNvbnN0IGNoYXIqIFN0cmVhbUZNQV9nZXRfZXJyb3JzKHZvaWQpCnsJcmV0dXJuIHN0 b3JlZF9lcnJvcjsgfQp2b2lkIFN0cmVhbUZNQV9jbGVhcl9lcnJvcnModm9pZCkKewoJZnJlZShz dG9yZWRfZXJyb3IpOwoJc3RvcmVkX2Vycm9yID0gTlVMTDsKCXN0b3JlZF9oYXNfZXJyb3IgPSAw Owp9CgpzdGF0aWMgY2hhciBTdHJlYW1GTUFfdXNlX3NpbXVsYXRpb25bMTZdOwpzdGF0aWMgdm9p ZCBTdHJlYW1GTUFfZGVmX3VzZV9zaW11bGF0aW9uKHZvaWQpCnsKCWxvbmcgcGlkID0gKChsb25n KSBnZXRwaWQoKSkgJSAxMDAwMDA7CglzbnByaW50ZihTdHJlYW1GTUFfdXNlX3NpbXVsYXRpb24s IDE2LCAiU3RyZWFtRk1fJTA1bGRfIiwgcGlkKTsKfQpzdGF0aWMgY29uc3QgY2hhciAqU3RyZWFt Rk1BX2NoZWNrX3VzZV9zaW11bGF0aW9uKHZvaWQpCnsKCVN0cmVhbUZNQV9kZWZfdXNlX3NpbXVs YXRpb24oKTsKCWNvbnN0IGNoYXIgKnVzZV9zaW0gPSBtYXhfY29uZmlnX2dldF9zdHJpbmcoTUFY X0NPTkZJR19VU0VfU0lNVUxBVElPTik7CglpZiAodXNlX3NpbSA9PSBOVUxMKSB7CgkJdXNlX3Np bSA9IFN0cmVhbUZNQV91c2Vfc2ltdWxhdGlvbjsKCQltYXhfY29uZmlnX3NldF9zdHJpbmcoTUFY X0NPTkZJR19VU0VfU0lNVUxBVElPTiwgdXNlX3NpbSk7Cgl9CglyZXR1cm4gdXNlX3NpbTsKfQoK c3RhdGljIGludCBTdHJlYW1GTUFfc2ltdWxhdGlvbl9sYXVuY2ggPSAwOwppbnQgU3RyZWFtRk1B X3NpbXVsYXRvcl9zdGFydCh2b2lkKQp7CglpbnQgcmV0dmFsID0gMDsKCWNvbnN0IGNoYXIgKnVz ZV9zaW0gPSBTdHJlYW1GTUFfY2hlY2tfdXNlX3NpbXVsYXRpb24oKTsKCWNoYXIgYnVmZlsxMDI0 XTsKCXNucHJpbnRmKGJ1ZmYsIDEwMjQsICJQQVRIPXNpbXV0aWxzOiRQQVRIIG1heGNvbXBpbGVy c2ltIC1kIDEgLW4gJXMgLWMgTUFYNUMgLVMgc2ltdXRpbHMgcmVzdGFydCIsIHVzZV9zaW0pOwoJ RklMRSAqcGlwZV9mcCA9IHBvcGVuKGJ1ZmYsICJyIik7CglpZiAocGlwZV9mcCA9PSBOVUxMKSB7 CgkJc3RybmNhdChidWZmLCAiIDogZmFpbGVkIHRvIGV4ZWN1dGUuIiwgKDEwMjQgLSBzdHJsZW4o YnVmZikpKTsKCQlzZXRfZXJyb3IoYnVmZik7CgkJcmV0dXJuIC0xOwoJfQoJd2hpbGUgKGZnZXRz KGJ1ZmYsIDEwMjQsIHBpcGVfZnApICE9IE5VTEwpIHsKCQkvKiBVbmNvbW1lbnQgdGhpcyB0byBn ZXQgc2ltdWxhdG9yIGNvbW1hbmQgb3V0cHV0ICovCgkJLyogZnByaW50ZihzdGRlcnIsIGJ1ZmYp OyAqLwoJCWlmIChzdHJzdHIoYnVmZiwgIkVycm9yIikpIHsKCQkJc2V0X2Vycm9yKGJ1ZmYpOwoJ CQlyZXR2YWwgPSAtMTsKCQl9Cgl9CglwY2xvc2UocGlwZV9mcCk7CglyZXR1cm4gcmV0dmFsOwp9 CgppbnQgU3RyZWFtRk1BX3NpbXVsYXRvcl9zdG9wKHZvaWQpCnsKCWNvbnN0IGNoYXIgKnVzZV9z aW0gPSBTdHJlYW1GTUFfY2hlY2tfdXNlX3NpbXVsYXRpb24oKTsKCWNoYXIgYnVmZlsxMDI0XTsK CXNucHJpbnRmKGJ1ZmYsIDEwMjQsICJQQVRIPXNpbXV0aWxzOiRQQVRIIG1heGNvbXBpbGVyc2lt IC1kIDEgLW4gJXMgLWMgTUFYNUMgLVMgc2ltdXRpbHMgc3RvcCIsIHVzZV9zaW0pOwoJRklMRSAq cGlwZV9mcCA9IHBvcGVuKGJ1ZmYsICJyIik7CglpZiAocGlwZV9mcCA9PSBOVUxMKSB7CgkJc3Ry bmNhdChidWZmLCAiIDogZmFpbGVkIHRvIGV4ZWN1dGUuIiwgKDEwMjQgLSBzdHJsZW4oYnVmZikp KTsKCQlzZXRfZXJyb3IoYnVmZik7CgkJcmV0dXJuIC0xOwoJfQoJd2hpbGUgKGZnZXRzKGJ1ZmYs IDEwMjQsIHBpcGVfZnApICE9IE5VTEwpIHsKCQkvKiBVbmNvbW1lbnQgdGhpcyB0byBnZXQgc2lt dWxhdG9yIGNvbW1hbmQgb3V0cHV0ICovCgkJLyogZnByaW50ZihzdGRlcnIsIGJ1ZmYpOyAqLwoJ CTsKCX0KCXBjbG9zZShwaXBlX2ZwKTsKCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCBTdHJlYW1G TUFfc3RhdGljX2luaXQodm9pZCkgCnsKCXN0b3JlZF9tYXhmaWxlID0gU3RyZWFtRk1BX2luaXQo KTsKCWlmIChzdG9yZWRfbWF4ZmlsZSA9PSBOVUxMIHx8ICFtYXhfb2soc3RvcmVkX21heGZpbGUt PmVycm9ycykpIHsKCQlzdG9yZWRfbWF4ZmlsZSA9IE5VTEw7CgkJaWYobWF4X2NvbmZpZ19nZXRf Ym9vbChNQVhfQ09ORklHX1NUQVRJQ19JTlRFUkZBQ0VfQUJPUlRfT05fRVJST1IpKSBhYm9ydCgp OwoJCWVsc2UgeyBzZXRfZXJyb3IoIlVuYWJsZSB0byBsb2FkIG1heGZpbGUiKTsgcmV0dXJuOyB9 Cgl9CglpZighbWF4X29rKG1heF9nbG9iYWxfZXJyb3JzKCkpKSB7CgkJc2V0X2Vycm9yX2FuZF9m cmVlKG1heF9lcnJvcnNfdHJhY2UobWF4X2dsb2JhbF9lcnJvcnMoKSkpOwoJCXJldHVybjsKCX0K CWlmKCFtYXhfY29uZmlnX2dldF9ib29sKE1BWF9DT05GSUdfU1RBVElDX0lOVEVSRkFDRV9BQk9S VF9PTl9FUlJPUikpCgkJbWF4X2Vycm9yc19tb2RlKHN0b3JlZF9tYXhmaWxlLT5lcnJvcnMsIDAp OwoJdGltZV90IHRpbWVvdXRfcHJldmlvdXMgPSBtYXhfbG9hZF90aW1lb3V0KHN0b3JlZF9tYXhm aWxlLCAzMCk7Cgljb25zdCBjaGFyICp1c2Vfc2ltID0gU3RyZWFtRk1BX2NoZWNrX3VzZV9zaW11 bGF0aW9uKCk7CglpZiAobWF4X3BpbmdfZGFlbW9uKHN0b3JlZF9tYXhmaWxlLCB1c2Vfc2ltKSA9 PSAwKSB7CgkJaW50IHNpbV9zdGF0ID0gU3RyZWFtRk1BX3NpbXVsYXRvcl9zdGFydCgpOwoJCWlm ICgoc2ltX3N0YXQgPT0gMCkgJiYgKG1heF9waW5nX2RhZW1vbihzdG9yZWRfbWF4ZmlsZSwgdXNl X3NpbSkgPT0gMSkpIHsKCQkJU3RyZWFtRk1BX3NpbXVsYXRpb25fbGF1bmNoID0gMTsKCQl9IGVs c2UgewoJCQlzZXRfZXJyb3IoIkVycm9yOiBBbiBlcnJvciBvY2N1cnJlZCB3aGlsZSB0cnlpbmcg dG8gc3RhcnQgdGhlIHNpbXVsYXRpb24gaW5mcmFzdHJ1Y3R1cmUgYXV0b21hdGljYWxseS4iKTsK CQkJc2V0X2Vycm9yKCJFcnJvcjogQ2hlY2sgdGhhdCAndXNlX3NpbXVsYXRpb249PHNpbXVsYXRv cl9uYW1lPicgaXMgc2V0IGNvcnJlY3RseSBpbiB5b3VyIFNMaUMgY29uZmlndXJhdGlvbiIpOwoJ CQlzZXRfZXJyb3IoIkVycm9yOiBhbmQgdGhhdCB0aGUgYXNzb2NpYXRlZCBzaW11bGF0ZWQgc3lz dGVtIGRhZW1vbiBpcyBydW5uaW5nLiIpOwoJCQltYXhfZmlsZV9mcmVlKHN0b3JlZF9tYXhmaWxl KTsKCQkJc3RvcmVkX21heGZpbGUgPSBOVUxMOwoJCQlyZXR1cm47CgkJfQoJfQoJc3RvcmVkX2Vu Z2luZSA9IG1heF9sb2FkKHN0b3JlZF9tYXhmaWxlLCAiKiIpOwoJaWYgKCFtYXhfb2soc3RvcmVk X21heGZpbGUtPmVycm9ycykpIHsKCQlpZihtYXhfY29uZmlnX2dldF9ib29sKE1BWF9DT05GSUdf U1RBVElDX0lOVEVSRkFDRV9BQk9SVF9PTl9FUlJPUikpIHsKCQkJZnByaW50ZihzdGRlcnIsICJc blVuYWJsZSB0byBsb2FkIGVuZ2luZTogYWJvcnRpbmcgbm93LlxuXG4iKTsKCQkJZmZsdXNoKHN0 ZGVycik7CgkJCWFib3J0KCk7CgkJfSBlbHNlIHsKCQkJc2V0X2Vycm9yX2FuZF9mcmVlKG1heF9l cnJvcnNfdHJhY2Uoc3RvcmVkX21heGZpbGUtPmVycm9ycykpOwoJCQltYXhfZmlsZV9mcmVlKHN0 b3JlZF9tYXhmaWxlKTsKCQkJc3RvcmVkX21heGZpbGUgPSBOVUxMOwoJCQlyZXR1cm47CgkJfSAK CX0gCgltYXhfbG9hZF90aW1lb3V0KHN0b3JlZF9tYXhmaWxlLCB0aW1lb3V0X3ByZXZpb3VzKTsK fQp2b2lkIFN0cmVhbUZNQV9mcmVlKHZvaWQpCnsKCWlmIChzdG9yZWRfZW5naW5lICE9IE5VTEwp IHsKCQltYXhfdW5sb2FkKHN0b3JlZF9lbmdpbmUpOwoJCXN0b3JlZF9lbmdpbmUgPSBOVUxMOwoJ fQoJaWYgKHN0b3JlZF9tYXhmaWxlICE9IE5VTEwpIHsKCQltYXhfZmlsZV9mcmVlKHN0b3JlZF9t YXhmaWxlKTsKCQlzdG9yZWRfbWF4ZmlsZSA9IE5VTEw7Cgl9CglpZiAoc3RvcmVkX2Vycm9yICE9 IE5VTEwpIHsKCQlmcmVlKHN0b3JlZF9lcnJvcik7CgkJc3RvcmVkX2Vycm9yID0gTlVMTDsKCX0K CWlmIChTdHJlYW1GTUFfc2ltdWxhdGlvbl9sYXVuY2ggPT0gMSkgewoJCWludCBzaW1fc3RhdCA9 IFN0cmVhbUZNQV9zaW11bGF0b3Jfc3RvcCgpOwoJCWlmIChzaW1fc3RhdCAhPSAwICkgewoJCQlm cHJpbnRmKHN0ZGVyciwgIkVycm9yIHN0b3BwaW5nIHNpbXVsYXRvci4iKTsKCQl9CgkJU3RyZWFt Rk1BX3NpbXVsYXRpb25fbGF1bmNoID0gMDsKCX0KfQoKc3RhdGljIGludCBTdHJlYW1GTUFfZ2V0 X3BjaWVfYWxpZ25tZW50KHZvaWQpCnsKI2lmZGVmIFN0cmVhbUZNQV9QQ0lFX0FMSUdOTUVOVAoJ cmV0dXJuICgoU3RyZWFtRk1BX1BDSUVfQUxJR05NRU5UIDwgMSkgPyAxNiA6IFN0cmVhbUZNQV9Q Q0lFX0FMSUdOTUVOVCk7CiNlbHNlCglyZXR1cm4gMTY7CiNlbmRpZgp9CgpzdGF0aWMgaW50IFN0 cmVhbUZNQV9jaGVja19hbGlnbmVkKGNvbnN0IHZvaWQgKmRhdGEpCnsKCXVpbnRwdHJfdCBwb2lu dGVyID0gKHVpbnRwdHJfdCkgZGF0YTsKCWludCBhbGlnbm1lbnQgPSBTdHJlYW1GTUFfZ2V0X3Bj aWVfYWxpZ25tZW50KCk7CglyZXR1cm4gKHBvaW50ZXIgJSBhbGlnbm1lbnQpID8gMSA6IDA7Cn0K CnN0YXRpYyB2b2lkICpTdHJlYW1GTUFfbWFsbG9jX2FsaWduZWQoY29uc3Qgc2l6ZV90IHNpemUp CnsKCXZvaWQgKnB0cjsKCWludCBhbGlnbm1lbnQgPSBTdHJlYW1GTUFfZ2V0X3BjaWVfYWxpZ25t ZW50KCk7Cglwb3NpeF9tZW1hbGlnbigmcHRyLCBhbGlnbm1lbnQsIHNpemUpOwoJcmV0dXJuIHB0 cjsKfQoKCgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0gSW50ZXJmYWNlIGRlZmF1bHQgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwov Ki0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0qLwoKCgojZGVmaW5lIENIRUNLX0VSUk9SU19TVChTVCwgUkVU KSBpZighbWF4X29rKFNULT5lcnJvcnMpKSB7IGlmKG1heF9jb25maWdfZ2V0X2Jvb2woTUFYX0NP TkZJR19TVEFUSUNfSU5URVJGQUNFX0FCT1JUX09OX0VSUk9SKSkgeyBmcHJpbnRmKHN0ZGVyciwg IiVzXG4iLCBtYXhfZXJyb3JzX3RyYWNlKFNULT5lcnJvcnMpKTsgYWJvcnQoKTsgfSBzZXRfZXJy b3JfYW5kX2ZyZWUobWF4X2Vycm9yc190cmFjZShTVC0+ZXJyb3JzKSk7IHJldHVybiBSRVQ7IH0g CiNkZWZpbmUgQ0hFQ0tfTlVMTChWQUxVRSwgTUVTU0FHRSwgUkVUKSBpZihWQUxVRSA9PSBOVUxM KSB7IGlmIChtYXhfY29uZmlnX2dldF9ib29sKE1BWF9DT05GSUdfU1RBVElDX0lOVEVSRkFDRV9B Qk9SVF9PTl9FUlJPUikpIHsgZnByaW50ZihzdGRlcnIsICIlc1xuJXNcbiIsIChzdG9yZWRfZXJy b3IgPT0gTlVMTCkgPyAiIiA6IHN0b3JlZF9lcnJvciwgTUVTU0FHRSk7IGFib3J0KCk7IH0gc2V0 X2Vycm9yKE1FU1NBR0UpOyByZXR1cm4gUkVUOyB9CgogCnR5cGVkZWYgc3RydWN0IFN0cmVhbUZN QV9jYWxsYmFja19zdHJlYW0gewoJdWludDhfdCAqdXNlcl9wdHI7Cgl1aW50OF90ICphbGlnbmVk X3B0cjsKCXNpemVfdCAgIHNpemU7CglpbnQgICAgICBpc19vdXRwdXQ7Cn0gU3RyZWFtRk1BX2Nh bGxiYWNrX3N0cmVhbV90OwoKdHlwZWRlZiBzdHJ1Y3QgU3RyZWFtRk1BX2NhbGxiYWNrX2RhdGEg ewoJU3RyZWFtRk1BX2NhbGxiYWNrX3N0cmVhbV90IHN0cmVhbVszXTsgCglpbnQgY291bnQ7Cglp bnQgbWF4X2NvdW50Owp9IFN0cmVhbUZNQV9jYWxsYmFja19kYXRhX3Q7CgpzdGF0aWMgdm9pZCBT dHJlYW1GTUFfY2FsbGJhY2tfaW50ZXJuYWwodm9pZCAqY2JfZGF0YSkKewoJU3RyZWFtRk1BX2Nh bGxiYWNrX2RhdGFfdCAqZGF0YSA9IChTdHJlYW1GTUFfY2FsbGJhY2tfZGF0YV90KikgY2JfZGF0 YTsKCWZvciAoaW50IGkgPSAwIDsgaSA8IGRhdGEtPmNvdW50IDsgaSsrICkgewoJCVN0cmVhbUZN QV9jYWxsYmFja19zdHJlYW1fdCAqcyA9ICZkYXRhLT5zdHJlYW1baV07CgkJaWYgKHMtPmlzX291 dHB1dCAmJiAocy0+c2l6ZSA+IDApKSB7CgkJCW1lbWNweShzLT51c2VyX3B0ciwgcy0+YWxpZ25l ZF9wdHIsIHMtPnNpemUpOwoJCX0KCQlmcmVlKHMtPmFsaWduZWRfcHRyKTsKCX0KCWZyZWUoZGF0 YSk7Cn0KCnN0YXRpYyBtYXhfYWN0aW9uc190KiBTdHJlYW1GTUFfY29udmVydF9pbnRlcm5hbCgK CW1heF9maWxlX3QgKm1heGZpbGUsCglTdHJlYW1GTUFfYWN0aW9uc190ICppbnRlcmZhY2VfYWN0 aW9ucywKCWludCAgaXNfaW50ZXJuYWxfY2FsbCwKCXZvaWQgKCoqY2FsbGJhY2tfZnVuYykodm9p ZCopLAoJdm9pZCAqKmNhbGxiYWNrX2RhdGEpCnsKCW1heF9hY3Rpb25zX3QgKmFjdGlvbnMgPSBt YXhfYWN0aW9uc19pbml0KG1heGZpbGUsIE5VTEwpOwoJaWYoYWN0aW9ucyA9PSBOVUxMKSByZXR1 cm4gTlVMTDsKCiNkZWZpbmUgQ0hFQ0tfRVJST1JTIGlmKCFtYXhfb2soYWN0aW9ucy0+ZXJyb3Jz KSkgeyBzZXRfZXJyb3JfYW5kX2ZyZWUobWF4X2Vycm9yc190cmFjZShhY3Rpb25zLT5lcnJvcnMp KTsgcmV0dXJuIE5VTEw7IH0gCgoJU3RyZWFtRk1BX2NhbGxiYWNrX2RhdGFfdCAqY2JfZGF0YSA9 IE5VTEw7CglpbnQgdXNlX2NhbGxiYWNrID0gKGNhbGxiYWNrX2Z1bmMgIT0gTlVMTCkgJiYgKGNh bGxiYWNrX2RhdGEgIT0gTlVMTCk7CglpZiAodXNlX2NhbGxiYWNrKSB7CgkJY2JfZGF0YSA9IG1h bGxvYyhzaXplb2YoU3RyZWFtRk1BX2NhbGxiYWNrX2RhdGFfdCkpOwoJCWlmIChjYl9kYXRhID09 IE5VTEwpIHsKCQkJZnByaW50ZihzdGRlcnIsICJVbmFibGUgdG8gYWxsb2NhdGUgbWVtb3J5IGZv ciBzdHJlYW0gY2FsbGJhY2sgZGF0YSBpbiBmdW5jdGlvbiBTdHJlYW1GTUFfY29udmVydF9pbnRl cm5hbFxuIik7CgkJCXJldHVybiBOVUxMOwoJCX0KCQljYl9kYXRhLT5tYXhfY291bnQgPSAzOwoJ CWNiX2RhdGEtPmNvdW50ICAgICA9IDA7CgkJKmNhbGxiYWNrX2RhdGEgICAgID0gY2JfZGF0YTsK CQkqY2FsbGJhY2tfZnVuYyAgICAgPSAmU3RyZWFtRk1BX2NhbGxiYWNrX2ludGVybmFsOwoJfQoK CS8qIGNvZGUgZm9yIHNjYWxhciBTdHJlYW1GTUFLZXJuZWwucnVuX2N5Y2xlX2NvdW50ICovCgl1 aW50NjRfdCB0aWNrc19TdHJlYW1GTUFLZXJuZWwgPSBpbnRlcmZhY2VfYWN0aW9ucy0+dGlja3Nf U3RyZWFtRk1BS2VybmVsOwoJbWF4X3NldF90aWNrcyhhY3Rpb25zLCAiU3RyZWFtRk1BS2VybmVs IiwgdGlja3NfU3RyZWFtRk1BS2VybmVsKTsKCUNIRUNLX0VSUk9SUzsKCS8qIGVuZCBvZiBjb2Rl IGZvciBzY2FsYXIgU3RyZWFtRk1BS2VybmVsLnJ1bl9jeWNsZV9jb3VudCovCgkKCS8qIGNvZGUg Zm9yIHN0cmVhbSBhICovCglzaXplX3QgaW5zdHJlYW1fc2l6ZV9hID0gaW50ZXJmYWNlX2FjdGlv bnMtPmluc3RyZWFtX3NpemVfYTsKCWlmIChpbnN0cmVhbV9zaXplX2EgPiAwKSB7CgkJY29uc3Qg dm9pZCAqc3RyZWFtX3B0ciA9IGludGVyZmFjZV9hY3Rpb25zLT5pbnN0cmVhbV9hOwoJCWlmICh1 c2VfY2FsbGJhY2sgJiYgKDEgPT0gU3RyZWFtRk1BX2NoZWNrX2FsaWduZWQoaW50ZXJmYWNlX2Fj dGlvbnMtPmluc3RyZWFtX2EpKSkgewoJCQl2b2lkICphbGlnbmVkX2luc3RyZWFtX2EgPSBtYWxs b2MoaW5zdHJlYW1fc2l6ZV9hKTsKCQkJaWYgKGFsaWduZWRfaW5zdHJlYW1fYSA9PSBOVUxMKSB7 CgkJCQltYXhfcmVwb3J0X2Vycm9yX3NsaWMoYWN0aW9ucy0+ZXJyb3JzLCBfX0ZJTEVfXywgX19M SU5FX18sIDUyNiwgIkZhaWxlZCB0byBhbGxvY2F0ZSBhbGlnbmVkIG1lbW9yeSBmb3Igc3RyZWFt ICdhJyIpOwoJCQkJQ0hFQ0tfRVJST1JTOwoJCQl9CgkJCSgmY2JfZGF0YS0+c3RyZWFtW2NiX2Rh dGEtPmNvdW50XSktPnVzZXJfcHRyICAgID0gKHVpbnQ4X3QqKSBpbnRlcmZhY2VfYWN0aW9ucy0+ aW5zdHJlYW1fYTsKCQkJKCZjYl9kYXRhLT5zdHJlYW1bY2JfZGF0YS0+Y291bnRdKS0+YWxpZ25l ZF9wdHIgPSAodWludDhfdCopIGFsaWduZWRfaW5zdHJlYW1fYTsKCQkJKCZjYl9kYXRhLT5zdHJl YW1bY2JfZGF0YS0+Y291bnRdKS0+c2l6ZSAgICAgICAgPSBpbnN0cmVhbV9zaXplX2E7CgkJCSgm Y2JfZGF0YS0+c3RyZWFtW2NiX2RhdGEtPmNvdW50XSktPmlzX291dHB1dCAgID0gMDsKCQkJY2Jf ZGF0YS0+Y291bnQgKz0gMTsKCQkJbWVtY3B5KGFsaWduZWRfaW5zdHJlYW1fYSwgaW50ZXJmYWNl X2FjdGlvbnMtPmluc3RyZWFtX2EsIGluc3RyZWFtX3NpemVfYSk7CgkJCXN0cmVhbV9wdHIgPSBh bGlnbmVkX2luc3RyZWFtX2E7CgkJfQoJCW1heF9xdWV1ZV9pbnB1dChhY3Rpb25zLCAiYSIsIHN0 cmVhbV9wdHIsIGluc3RyZWFtX3NpemVfYSk7CgkJQ0hFQ0tfRVJST1JTOwoJfQoJLyogZW5kIG9m IGNvZGUgZm9yIHN0cmVhbSBhICovCgkKCS8qIGNvZGUgZm9yIHN0cmVhbSBiICovCglzaXplX3Qg aW5zdHJlYW1fc2l6ZV9iID0gaW50ZXJmYWNlX2FjdGlvbnMtPmluc3RyZWFtX3NpemVfYjsKCWlm IChpbnN0cmVhbV9zaXplX2IgPiAwKSB7CgkJY29uc3Qgdm9pZCAqc3RyZWFtX3B0ciA9IGludGVy ZmFjZV9hY3Rpb25zLT5pbnN0cmVhbV9iOwoJCWlmICh1c2VfY2FsbGJhY2sgJiYgKDEgPT0gU3Ry ZWFtRk1BX2NoZWNrX2FsaWduZWQoaW50ZXJmYWNlX2FjdGlvbnMtPmluc3RyZWFtX2IpKSkgewoJ CQl2b2lkICphbGlnbmVkX2luc3RyZWFtX2IgPSBtYWxsb2MoaW5zdHJlYW1fc2l6ZV9iKTsKCQkJ aWYgKGFsaWduZWRfaW5zdHJlYW1fYiA9PSBOVUxMKSB7CgkJCQltYXhfcmVwb3J0X2Vycm9yX3Ns aWMoYWN0aW9ucy0+ZXJyb3JzLCBfX0ZJTEVfXywgX19MSU5FX18sIDUyNiwgIkZhaWxlZCB0byBh bGxvY2F0ZSBhbGlnbmVkIG1lbW9yeSBmb3Igc3RyZWFtICdiJyIpOwoJCQkJQ0hFQ0tfRVJST1JT OwoJCQl9CgkJCSgmY2JfZGF0YS0+c3RyZWFtW2NiX2RhdGEtPmNvdW50XSktPnVzZXJfcHRyICAg ID0gKHVpbnQ4X3QqKSBpbnRlcmZhY2VfYWN0aW9ucy0+aW5zdHJlYW1fYjsKCQkJKCZjYl9kYXRh LT5zdHJlYW1bY2JfZGF0YS0+Y291bnRdKS0+YWxpZ25lZF9wdHIgPSAodWludDhfdCopIGFsaWdu ZWRfaW5zdHJlYW1fYjsKCQkJKCZjYl9kYXRhLT5zdHJlYW1bY2JfZGF0YS0+Y291bnRdKS0+c2l6 ZSAgICAgICAgPSBpbnN0cmVhbV9zaXplX2I7CgkJCSgmY2JfZGF0YS0+c3RyZWFtW2NiX2RhdGEt PmNvdW50XSktPmlzX291dHB1dCAgID0gMDsKCQkJY2JfZGF0YS0+Y291bnQgKz0gMTsKCQkJbWVt Y3B5KGFsaWduZWRfaW5zdHJlYW1fYiwgaW50ZXJmYWNlX2FjdGlvbnMtPmluc3RyZWFtX2IsIGlu c3RyZWFtX3NpemVfYik7CgkJCXN0cmVhbV9wdHIgPSBhbGlnbmVkX2luc3RyZWFtX2I7CgkJfQoJ CW1heF9xdWV1ZV9pbnB1dChhY3Rpb25zLCAiYiIsIHN0cmVhbV9wdHIsIGluc3RyZWFtX3NpemVf Yik7CgkJQ0hFQ0tfRVJST1JTOwoJfQoJLyogZW5kIG9mIGNvZGUgZm9yIHN0cmVhbSBiICovCgkK CS8qIGNvZGUgZm9yIHN0cmVhbSBvdXRwdXQgKi8KCXNpemVfdCBvdXRzdHJlYW1fc2l6ZV9vdXRw dXQgPSBpbnRlcmZhY2VfYWN0aW9ucy0+b3V0c3RyZWFtX3NpemVfb3V0cHV0OwoJaWYgKG91dHN0 cmVhbV9zaXplX291dHB1dCA+IDApIHsKCQl2b2lkICpzdHJlYW1fcHRyID0gaW50ZXJmYWNlX2Fj dGlvbnMtPm91dHN0cmVhbV9vdXRwdXQ7CgkJaWYgKHVzZV9jYWxsYmFjayAmJiAoMSA9PSBTdHJl YW1GTUFfY2hlY2tfYWxpZ25lZChpbnRlcmZhY2VfYWN0aW9ucy0+b3V0c3RyZWFtX291dHB1dCkp KSB7CgkJCXZvaWQgKmFsaWduZWRfb3V0c3RyZWFtX291dHB1dCA9IG1hbGxvYyhvdXRzdHJlYW1f c2l6ZV9vdXRwdXQpOwoJCQlpZiAoYWxpZ25lZF9vdXRzdHJlYW1fb3V0cHV0ID09IE5VTEwpIHsK CQkJCW1heF9yZXBvcnRfZXJyb3Jfc2xpYyhhY3Rpb25zLT5lcnJvcnMsIF9fRklMRV9fLCBfX0xJ TkVfXywgNTI2LCAiRmFpbGVkIHRvIGFsbG9jYXRlIGFsaWduZWQgbWVtb3J5IGZvciBzdHJlYW0g J291dHB1dCciKTsKCQkJCUNIRUNLX0VSUk9SUzsKCQkJfQoJCQkoJmNiX2RhdGEtPnN0cmVhbVtj Yl9kYXRhLT5jb3VudF0pLT51c2VyX3B0ciAgICA9ICh1aW50OF90KikgaW50ZXJmYWNlX2FjdGlv bnMtPm91dHN0cmVhbV9vdXRwdXQ7CgkJCSgmY2JfZGF0YS0+c3RyZWFtW2NiX2RhdGEtPmNvdW50 XSktPmFsaWduZWRfcHRyID0gKHVpbnQ4X3QqKSBhbGlnbmVkX291dHN0cmVhbV9vdXRwdXQ7CgkJ CSgmY2JfZGF0YS0+c3RyZWFtW2NiX2RhdGEtPmNvdW50XSktPnNpemUgICAgICAgID0gb3V0c3Ry ZWFtX3NpemVfb3V0cHV0OwoJCQkoJmNiX2RhdGEtPnN0cmVhbVtjYl9kYXRhLT5jb3VudF0pLT5p c19vdXRwdXQgICA9IDE7CgkJCWNiX2RhdGEtPmNvdW50ICs9IDE7CgkJCXN0cmVhbV9wdHIgPSBh bGlnbmVkX291dHN0cmVhbV9vdXRwdXQ7CgkJfQoJCW1heF9xdWV1ZV9vdXRwdXQoYWN0aW9ucywg Im91dHB1dCIsIHN0cmVhbV9wdHIsIG91dHN0cmVhbV9zaXplX291dHB1dCk7CgkJQ0hFQ0tfRVJS T1JTOwoJfQoJLyogZW5kIG9mIGNvZGUgZm9yIHN0cmVhbSBvdXRwdXQgKi8KCQoJaWYgKHVzZV9j YWxsYmFjayAmJiBjYl9kYXRhLT5jb3VudCA9PSAwKSB7CgkJKmNhbGxiYWNrX2RhdGEgPSBOVUxM OwoJCSpjYWxsYmFja19mdW5jID0gTlVMTDsKCQlmcmVlKGNiX2RhdGEpOwoJfQoJcmV0dXJuIGFj dGlvbnM7CiN1bmRlZiBDSEVDS19FUlJPUlMKfQoKdm9pZCBTdHJlYW1GTUEoCgl1aW50NjRfdCB0 aWNrc19TdHJlYW1GTUFLZXJuZWwsCgljb25zdCB2b2lkICppbnN0cmVhbV9hLAoJc2l6ZV90IGlu c3RyZWFtX3NpemVfYSwKCWNvbnN0IHZvaWQgKmluc3RyZWFtX2IsCglzaXplX3QgaW5zdHJlYW1f c2l6ZV9iLAoJdm9pZCAqb3V0c3RyZWFtX291dHB1dCwKCXNpemVfdCBvdXRzdHJlYW1fc2l6ZV9v dXRwdXQpCnsKCSh2b2lkKSBwdGhyZWFkX29uY2UoJnNsaWNfYnNfaXNfaW5pdGlhbGlzZWQsIFN0 cmVhbUZNQV9zdGF0aWNfaW5pdCk7CglDSEVDS19OVUxMKHN0b3JlZF9tYXhmaWxlLCAiTWF4Zmls ZSB3YXMgbm90IGxvYWRlZCIsICk7CgltYXhfcnVuX3QgKnJ1biA9IFN0cmVhbUZNQV9ub25ibG9j ayh0aWNrc19TdHJlYW1GTUFLZXJuZWwsIGluc3RyZWFtX2EsIGluc3RyZWFtX3NpemVfYSwgaW5z dHJlYW1fYiwgaW5zdHJlYW1fc2l6ZV9iLCBvdXRzdHJlYW1fb3V0cHV0LCBvdXRzdHJlYW1fc2l6 ZV9vdXRwdXQpOwoJQ0hFQ0tfTlVMTChydW4sICJVbmFibGUgdG8gcnVuIGFjdGlvbnMiLCApOwoJ bWF4X3dhaXQocnVuKTsKfQoKbWF4X3J1bl90ICpTdHJlYW1GTUFfbm9uYmxvY2soCgl1aW50NjRf dCB0aWNrc19TdHJlYW1GTUFLZXJuZWwsCgljb25zdCB2b2lkICppbnN0cmVhbV9hLAoJc2l6ZV90 IGluc3RyZWFtX3NpemVfYSwKCWNvbnN0IHZvaWQgKmluc3RyZWFtX2IsCglzaXplX3QgaW5zdHJl YW1fc2l6ZV9iLAoJdm9pZCAqb3V0c3RyZWFtX291dHB1dCwKCXNpemVfdCBvdXRzdHJlYW1fc2l6 ZV9vdXRwdXQpCnsKCVN0cmVhbUZNQV9hY3Rpb25zX3QgaW50ZXJmYWNlX2FjdGlvbnM7CglpbnRl cmZhY2VfYWN0aW9ucy50aWNrc19TdHJlYW1GTUFLZXJuZWwgPSB0aWNrc19TdHJlYW1GTUFLZXJu ZWw7CglpbnRlcmZhY2VfYWN0aW9ucy5pbnN0cmVhbV9hID0gaW5zdHJlYW1fYTsKCWludGVyZmFj ZV9hY3Rpb25zLmluc3RyZWFtX3NpemVfYSA9IGluc3RyZWFtX3NpemVfYTsKCWludGVyZmFjZV9h Y3Rpb25zLmluc3RyZWFtX2IgPSBpbnN0cmVhbV9iOwoJaW50ZXJmYWNlX2FjdGlvbnMuaW5zdHJl YW1fc2l6ZV9iID0gaW5zdHJlYW1fc2l6ZV9iOwoJaW50ZXJmYWNlX2FjdGlvbnMub3V0c3RyZWFt X291dHB1dCA9IG91dHN0cmVhbV9vdXRwdXQ7CglpbnRlcmZhY2VfYWN0aW9ucy5vdXRzdHJlYW1f c2l6ZV9vdXRwdXQgPSBvdXRzdHJlYW1fc2l6ZV9vdXRwdXQ7Cgkodm9pZCkgcHRocmVhZF9vbmNl KCZzbGljX2JzX2lzX2luaXRpYWxpc2VkLCBTdHJlYW1GTUFfc3RhdGljX2luaXQpOwoJQ0hFQ0tf TlVMTChzdG9yZWRfbWF4ZmlsZSwgIk1heGZpbGUgd2FzIG5vdCBsb2FkZWQiLCBOVUxMKTsKCXZv aWQgKCpjYl9mdW5jKSh2b2lkKikgPSBOVUxMOwoJdm9pZCAgKmNiX2RhdGEgICAgICAgICA9IE5V TEw7CgltYXhfYWN0aW9uc190ICphY3Rpb25zID0gU3RyZWFtRk1BX2NvbnZlcnRfaW50ZXJuYWwo c3RvcmVkX21heGZpbGUsICZpbnRlcmZhY2VfYWN0aW9ucywgMSwgJmNiX2Z1bmMsICZjYl9kYXRh KTsKCUNIRUNLX05VTEwoYWN0aW9ucywgIlVuYWJsZSB0byBidWlsZCBhY3Rpb25zIiwgTlVMTCk7 CgltYXhfdmFsaWRhdGUoYWN0aW9ucyk7CglDSEVDS19FUlJPUlNfU1QoYWN0aW9ucywgTlVMTCk7 CglDSEVDS19FUlJPUlNfU1Qoc3RvcmVkX2VuZ2luZSwgTlVMTCk7CgltYXhfcnVuX3QgKnJ1bjsK CWlmIChjYl9mdW5jID09IE5VTEwpIHsKCQlydW4gPSBtYXhfcnVuX25vbmJsb2NrKHN0b3JlZF9l bmdpbmUsIGFjdGlvbnMpOwoJfSBlbHNlIHsKCQlydW4gPSBtYXhfcnVuX25vbmJsb2NrX3dpdGhf Y2Ioc3RvcmVkX2VuZ2luZSwgYWN0aW9ucywgY2JfZnVuYywgY2JfZGF0YSk7Cgl9CglDSEVDS19O VUxMKHJ1biwgIlVuYWJsZSB0byBydW4gYWN0aW9ucyIsIE5VTEwpOwoJQ0hFQ0tfRVJST1JTX1NU KGFjdGlvbnMsIE5VTEwpOwoJbWF4X2FjdGlvbnNfZnJlZShhY3Rpb25zKTsKCXJldHVybiBydW47 Cn0KCnZvaWQgU3RyZWFtRk1BX3J1bigKCW1heF9lbmdpbmVfdCAqZW5naW5lLAoJU3RyZWFtRk1B X2FjdGlvbnNfdCAqaW50ZXJmYWNlX2FjdGlvbnMpCnsKCW1heF9ydW5fdCAqcnVuID0gU3RyZWFt Rk1BX3J1bl9ub25ibG9jayhlbmdpbmUsIGludGVyZmFjZV9hY3Rpb25zKTsKCUNIRUNLX05VTEwo cnVuLCAiVW5hYmxlIHRvIHJ1biBhY3Rpb25zIiwgKTsKCW1heF93YWl0KHJ1bik7Cn0KCm1heF9y dW5fdCAqU3RyZWFtRk1BX3J1bl9ub25ibG9jaygKCW1heF9lbmdpbmVfdCAqZW5naW5lLAoJU3Ry ZWFtRk1BX2FjdGlvbnNfdCAqaW50ZXJmYWNlX2FjdGlvbnMpCnsKCW1heF9maWxlX3QgKm1heGZp bGUgPSBtYXhfZW5naW5lX2dldF9tYXhfZmlsZShlbmdpbmUpOyAKCXZvaWQgKCpjYl9mdW5jKSh2 b2lkKikgPSBOVUxMOwoJdm9pZCAgKmNiX2RhdGEgICAgICAgICA9IE5VTEw7CgltYXhfYWN0aW9u c190ICphY3Rpb25zID0gU3RyZWFtRk1BX2NvbnZlcnRfaW50ZXJuYWwobWF4ZmlsZSwgaW50ZXJm YWNlX2FjdGlvbnMsIDEsICZjYl9mdW5jLCAmY2JfZGF0YSk7CglDSEVDS19OVUxMKGFjdGlvbnMs ICJVbmFibGUgdG8gYnVpbGQgYWN0aW9ucyIsIE5VTEwpOwoJbWF4X3ZhbGlkYXRlKGFjdGlvbnMp OwoJQ0hFQ0tfRVJST1JTX1NUKGFjdGlvbnMsIE5VTEwpOwoJbWF4X3J1bl90ICpydW47CglpZiAo Y2JfZnVuYyA9PSBOVUxMKSB7CgkJcnVuID0gbWF4X3J1bl9ub25ibG9jayhlbmdpbmUsIGFjdGlv bnMpOwoJfSBlbHNlIHsKCQlydW4gPSBtYXhfcnVuX25vbmJsb2NrX3dpdGhfY2IoZW5naW5lLCBh Y3Rpb25zLCBjYl9mdW5jLCBjYl9kYXRhKTsKCX0KCUNIRUNLX05VTEwocnVuLCAiVW5hYmxlIHRv IHJ1biBhY3Rpb25zIiwgTlVMTCk7CgltYXhfYWN0aW9uc19mcmVlKGFjdGlvbnMpOwoJcmV0dXJu IHJ1bjsKfQoKCi8qKgogKiBcYnJpZWYgR3JvdXAgcnVuIGFkdmFuY2VkIHN0YXRpYyBmdW5jdGlv biBmb3IgdGhlIGludGVyZmFjZSAnZGVmYXVsdCcuCiAqIAogKiBccGFyYW0gW2luXSBncm91cCBH cm91cCB0byB1c2UuCiAqIFxwYXJhbSBbaW4sb3V0XSBpbnRlcmZhY2VfYWN0aW9ucyBBY3Rpb25z IHRvIHJ1bi4KICoKICogUnVuIHRoZSBhY3Rpb25zIG9uIHRoZSBmaXJzdCBkZXZpY2UgYXZhaWxh YmxlIGluIHRoZSBncm91cC4KICovCnZvaWQgU3RyZWFtRk1BX3J1bl9ncm91cChtYXhfZ3JvdXBf dCAqZ3JvdXAsIFN0cmVhbUZNQV9hY3Rpb25zX3QgKmludGVyZmFjZV9hY3Rpb25zKQp7CgltYXhf cnVuX3QgKnJ1biA9IFN0cmVhbUZNQV9ydW5fZ3JvdXBfbm9uYmxvY2soZ3JvdXAsIGludGVyZmFj ZV9hY3Rpb25zKTsKCUNIRUNLX05VTEwocnVuLCAiVW5hYmxlIHRvIHJ1biBhY3Rpb25zIiwgKTsK CW1heF93YWl0KHJ1bik7Cn0KCgovKioKICogXGJyaWVmIEdyb3VwIHJ1biBhZHZhbmNlZCBzdGF0 aWMgbm9uLWJsb2NraW5nIGZ1bmN0aW9uIGZvciB0aGUgaW50ZXJmYWNlICdkZWZhdWx0Jy4KICog CiAqCiAqIFNjaGVkdWxlIHRoZSBhY3Rpb25zIHRvIHJ1biBvbiB0aGUgZmlyc3QgZGV2aWNlIGF2 YWlsYWJsZSBpbiB0aGUgZ3JvdXAgYW5kIHJldHVybiBpbW1lZGlhdGVseS4KICogVGhlIHN0YXR1 cyBvZiB0aGUgcnVuIG11c3QgYmUgY2hlY2tlZCB3aXRoIDo6bWF4X3dhaXQuIAogKiBOb3RlIHRo YXQgdXNlIG9mIDo6bWF4X25vd2FpdCBpcyBwcm9oaWJpdGVkIHdpdGggbm9uLWJsb2NraW5nIHJ1 bm5pbmcgb24gZ3JvdXBzOgogKiBzZWUgdGhlIDo6bWF4X3J1bl9ncm91cF9ub25ibG9jayBkb2N1 bWVudGF0aW9uIGZvciBtb3JlIGV4cGxhbmF0aW9uLgogKgogKiBccGFyYW0gW2luXSBncm91cCBH cm91cCB0byB1c2UuCiAqIFxwYXJhbSBbaW5dIGludGVyZmFjZV9hY3Rpb25zIEFjdGlvbnMgdG8g cnVuLgogKiBccmV0dXJuIEEgaGFuZGxlIG9uIHRoZSBleGVjdXRpb24gc3RhdHVzIG9mIHRoZSBh Y3Rpb25zLCBvciBOVUxMIGluIGNhc2Ugb2YgZXJyb3IuCiAqLwptYXhfcnVuX3QgKlN0cmVhbUZN QV9ydW5fZ3JvdXBfbm9uYmxvY2sobWF4X2dyb3VwX3QgKmdyb3VwLCBTdHJlYW1GTUFfYWN0aW9u c190ICppbnRlcmZhY2VfYWN0aW9ucykKewoJbWF4X2ZpbGVfdCAqbWF4ZmlsZSA9IG1heF9ncm91 cF9nZXRfbWF4X2ZpbGUoZ3JvdXApOwoJbWF4X2FjdGlvbnNfdCAqYWN0aW9ucyA9IFN0cmVhbUZN QV9jb252ZXJ0X2ludGVybmFsKG1heGZpbGUsIGludGVyZmFjZV9hY3Rpb25zLCAxLCBOVUxMLCBO VUxMKTsKCWlmKGFjdGlvbnMgPT0gTlVMTCkgcmV0dXJuIE5VTEw7CglpZighbWF4X29rKGFjdGlv bnMtPmVycm9ycykpIHJldHVybiBOVUxMOwoJbWF4X3ZhbGlkYXRlKGFjdGlvbnMpOwoJbWF4X3J1 bl90ICpydW4gPSBtYXhfcnVuX2dyb3VwX25vbmJsb2NrKGdyb3VwLCBhY3Rpb25zKTsKCW1heF9h Y3Rpb25zX2ZyZWUoYWN0aW9ucyk7CglyZXR1cm4gcnVuOwp9CgoKLyoqCiAqIFxicmllZiBBcnJh eSBydW4gYWR2YW5jZWQgc3RhdGljIGZ1bmN0aW9uIGZvciB0aGUgaW50ZXJmYWNlICdkZWZhdWx0 Jy4KICogCiAqIFxwYXJhbSBbaW5dIGVuZ2FycmF5IFRoZSBhcnJheSBvZiBkZXZpY2VzIHRvIHVz ZS4KICogXHBhcmFtIFtpbixvdXRdIGludGVyZmFjZV9hY3Rpb25zIFRoZSBhcnJheSBvZiBhY3Rp b25zIHRvIHJ1bi4KICoKICogUnVuIHRoZSBhcnJheSBvZiBhY3Rpb25zIG9uIHRoZSBhcnJheSBv ZiBlbmdpbmVzLiAgVGhlIGxlbmd0aCBvZiBpbnRlcmZhY2VfYWN0aW9ucwogKiBtdXN0IG1hdGNo IHRoZSBzaXplIG9mIGVuZ2FycmF5LgogKi8Kdm9pZCBTdHJlYW1GTUFfcnVuX2FycmF5KG1heF9l bmdhcnJheV90ICplbmdhcnJheSwgU3RyZWFtRk1BX2FjdGlvbnNfdCAqaW50ZXJmYWNlX2FjdGlv bnNbXSkKewoJbWF4X3J1bl90ICpydW4gPSBTdHJlYW1GTUFfcnVuX2FycmF5X25vbmJsb2NrKGVu Z2FycmF5LCBpbnRlcmZhY2VfYWN0aW9ucyk7CglDSEVDS19OVUxMKHJ1biwgIlVuYWJsZSB0byBy dW4gYWN0aW9ucyIsICk7CgltYXhfd2FpdChydW4pOwp9CgoKLyoqCiAqIFxicmllZiBBcnJheSBy dW4gYWR2YW5jZWQgc3RhdGljIG5vbi1ibG9ja2luZyBmdW5jdGlvbiBmb3IgdGhlIGludGVyZmFj ZSAnZGVmYXVsdCcuCiAqIAogKgogKiBTY2hlZHVsZSB0byBydW4gdGhlIGFycmF5IG9mIGFjdGlv bnMgb24gdGhlIGFycmF5IG9mIGVuZ2luZXMsIGFuZCByZXR1cm4gaW1tZWRpYXRlbHkuCiAqIFRo ZSBsZW5ndGggb2YgaW50ZXJmYWNlX2FjdGlvbnMgbXVzdCBtYXRjaCB0aGUgc2l6ZSBvZiBlbmdh cnJheS4KICogVGhlIHN0YXR1cyBvZiB0aGUgcnVuIGNhbiBiZSBjaGVja2VkIGVpdGhlciBieSA6 Om1heF93YWl0IG9yIDo6bWF4X25vd2FpdDsKICogbm90ZSB0aGF0IG9uZSBvZiB0aGVzZSAqbXVz dCogYmUgY2FsbGVkLCBzbyB0aGF0IGFzc29jaWF0ZWQgbWVtb3J5IGNhbiBiZSByZWxlYXNlZC4K ICoKICogXHBhcmFtIFtpbl0gZW5nYXJyYXkgVGhlIGFycmF5IG9mIGRldmljZXMgdG8gdXNlLgog KiBccGFyYW0gW2luXSBpbnRlcmZhY2VfYWN0aW9ucyBUaGUgYXJyYXkgb2YgYWN0aW9ucyB0byBy dW4uCiAqIFxyZXR1cm4gQSBoYW5kbGUgb24gdGhlIGV4ZWN1dGlvbiBzdGF0dXMgb2YgdGhlIGFj dGlvbnMsIG9yIE5VTEwgaW4gY2FzZSBvZiBlcnJvci4KICovCm1heF9ydW5fdCAqU3RyZWFtRk1B X3J1bl9hcnJheV9ub25ibG9jayhtYXhfZW5nYXJyYXlfdCAqZW5nYXJyYXksIFN0cmVhbUZNQV9h Y3Rpb25zX3QgKmludGVyZmFjZV9hY3Rpb25zW10pCnsKCW1heF9maWxlX3QgKm1heGZpbGUgPSBt YXhfZW5nYXJyYXlfZ2V0X21heF9maWxlKGVuZ2FycmF5LCAwKTsKCWludCBpOwoJbWF4X2FjdGFy cmF5X3QgKmFjdGFycmF5ID0gbWF4X2FjdGFycmF5X2luaXQobWF4ZmlsZSwgZW5nYXJyYXktPnNp emUpOwoJaWYgKGFjdGFycmF5ID09IE5VTEwpIHJldHVybiBOVUxMOwoJbWF4X2FjdGlvbnNfdCAq KmFycl9hY3Rpb25zID0gbWFsbG9jKGVuZ2FycmF5LT5zaXplICogc2l6ZW9mKG1heF9hY3Rpb25z X3QqKSk7Cglmb3IgKCBpID0gMCA7IGkgPCBhY3RhcnJheS0+c2l6ZTsgaSsrICkgewoJCW1heF9h Y3Rpb25zX3QgKmFjdGlvbnMgPSBTdHJlYW1GTUFfY29udmVydF9pbnRlcm5hbChtYXhmaWxlLCBp bnRlcmZhY2VfYWN0aW9uc1tpXSwgMSwgTlVMTCwgTlVMTCk7CgkJaWYgKGFjdGlvbnMgPT0gTlVM TCkgcmV0dXJuIE5VTEw7CgkJYXJyX2FjdGlvbnNbaV0gPSBhY3Rpb25zOwoJCW1heF9zZXRfYWN0 aW9uKGFjdGFycmF5LCBpLCBhY3Rpb25zKTsKCX0KCW1heF9ydW5fdCAqcnVuID0gbWF4X3J1bl9h cnJheV9ub25ibG9jayhlbmdhcnJheSwgYWN0YXJyYXkpOwoJZm9yICggaSA9IDAgOyBpIDwgYWN0 YXJyYXktPnNpemUgOyBpKysgKSB7IG1heF9hY3Rpb25zX2ZyZWUoYXJyX2FjdGlvbnNbaV0pOyB9 CgltYXhfYWN0YXJyYXlfZnJlZShhY3RhcnJheSk7CglmcmVlKGFycl9hY3Rpb25zKTsKCXJldHVy biBydW47Cn0KCgovKioKICogXGJyaWVmIENvbnZlcnRzIGEgc3RhdGljLWludGVyZmFjZSBhY3Rp b24gc3RydWN0IGludG8gYSBkeW5hbWljLWludGVyZmFjZSBtYXhfYWN0aW9uc190IHN0cnVjdC4K ICoKICogTm90ZSB0aGF0IHRoaXMgaXMgYW4gaW50ZXJuYWwgdXRpbGl0eSBmdW5jdGlvbiB1c2Vk IGJ5IG90aGVyIGZ1bmN0aW9ucyBpbiB0aGUgc3RhdGljIGludGVyZmFjZS4KICoKICogXHBhcmFt IFtpbl0gbWF4ZmlsZSBUaGUgbWF4ZmlsZSB0byB1c2UuCiAqIFxwYXJhbSBbaW5dIGludGVyZmFj ZV9hY3Rpb25zIFRoZSBpbnRlcmZhY2Utc3BlY2lmaWMgYWN0aW9ucyB0byBydW4uCiAqIFxyZXR1 cm4gVGhlIGR5bmFtaWMtaW50ZXJmYWNlIGFjdGlvbnMgdG8gcnVuLCBvciBOVUxMIGluIGNhc2Ug b2YgZXJyb3IuCiAqLwptYXhfYWN0aW9uc190KiBTdHJlYW1GTUFfY29udmVydChtYXhfZmlsZV90 ICptYXhmaWxlLCBTdHJlYW1GTUFfYWN0aW9uc190ICppbnRlcmZhY2VfYWN0aW9ucykKewoJcmV0 dXJuIFN0cmVhbUZNQV9jb252ZXJ0X2ludGVybmFsKG1heGZpbGUsIGludGVyZmFjZV9hY3Rpb25z LCAwLCBOVUxMLCBOVUxMKTsKfQoKI3VuZGVmIENIRUNLX0VSUk9SU19TVAojdW5kZWYgQ0hFQ0tf TlVMTAoKCg== #endif /* SLIC_B64_DEFINITIONS */ #ifdef SLIC_EXTRA_FILES PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9Im5vIj8+PHVz ZXJmaWxlcyBmb3JtYXQtdmVyc2lvbj0iMjAxMjAyMDAiLz4= #endif /* SLIC_EXTRA_FILES */ #ifdef PHOTON_NODE_ADD_DATA #define PHOTON_NODE_ADD_DATA_PRESENT 1 PHOTON_NODE_ADD_DATA(StreamFMAKernel, 8, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 9, "SquashFactor", 1.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 0, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 1, "SquashFactor", 1.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 2, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 3, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 4, "SquashFactor", 1.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 5, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 6, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 11, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 16, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 26, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 13, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 14, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 15, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 17, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 25, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 19, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 20, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 22, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 24, "SquashFactor", 0.0) PHOTON_NODE_ADD_DATA(StreamFMAKernel, 21, "SquashFactor", 0.0) #endif #ifdef MAXFILE_SIGNATURE #define MAXFILE_SIGNATURE_PRESENT 1 MAXFILE_SIGNATURE("302c02143578f5aee3b838f55f88f02510321eee5917f7ab021400efececa243f79c7dc512190b3fd86bf70d0c0f") #endif #ifdef PARAM #define PARAM_PRESENT 1 PARAM(TIMING_SCORE, 0) #endif #ifdef BITSTREAM #error You are using too old sliccompile to compile this maxfile. #endif #ifdef BITSTREAM_NEW #define BITSTREAM_COMPRESSED 1 H4sIAAAAAAAAAOxdCVxU1fd/ohhqGpoLbolbuZTODLulDssoCOoIqKTWMMAggzAzzgyItpFlmW3k r8XMjCz3FtI0sw210mwjbTHLJNvETEnLzDL/9553Hpw3vAfDgFa/3x8/1zff79x37j33nnvu+t7c Ykga49eihSD9tRRGCRwVvy1yeuSDMlvVxNELkcJF7P/eQi+I6y+o/1VHtpJdBSEY/uf3tWZhTZzI r4kbILsO6i3Gju8tyO7zw/sOJ4n3HU4aILtCBHINQNgKwy5U1fOKd9dcpdwav3Nn8c83PtcSsOfV 3VGQXaX7JrH7Wgve/wXiNRnTUyuXtHaC7CrVHI/dWeD1JwhjJ0wW9mU9NC7bvf/guBaj1v7ywbhX dlT2Os7jtWHl8pwg1uvFLPh1vHSZn+AXU6JZszBQCNpWFqCPdcS0XFgitGqT0FcQIi/tatYICzrG OMpbJOuNLYW2Qmt9YGXg2/7tWwRG3/nKoMH6Af2S3gwcENe6uq1/eiuhxZud4loFtPUrFlqU6gX9 3UKr6E4XhwsBpcXFer8x+vIA4eJW+sAtfg+2XrrOYAgeE1de2s8/+i0h4MnrA4+2EC5vH6z3E9YY g1u2atNpYUB6hwyhyy2xLYSAIQ5BHyj4FZe2FfTdjSXRXzsG3NYqYP4SwW/VGpZqcbFOcOhb6YsH tOji9+C9KTGDyssOD/1xXG8h7VbhR6FdCyGrez9WyuEtAoRBvVpeuVQoFoS+QkynYYPd61p98CZT dRDL4YJWxQGXF+n90vwu2iDoAyKLB8bcI2j82+pbdCxu07ZFpD6rwu/N8JIlFa2CBI0Q2Kpzt1tb jyiZIRiHtmgdINzOqiEnIVjfcqImQK9f1G3Fg4Elft1C/Vjl+JUEls73DxkxJbpjtJAutGopBAkl gcw89cLCi4tbxRo7JQfPGdCqY/B6wb/Toq4dy74PCAjo/0Br4UmhbeTC+OBFxcbAYn15bKuAXbdd PKxvl/iY0kcT+t8txKdfo/22U//AoMrAFn4Dg8cKfvP1nQ8Lwn3C28+8qL/4vUGBfrcXBwfMF1qV twgWSswxlp4Vd5RkFiw2BpSuO+xXxm3heRbKWHgBbWkDC5s97PMlFl5mYSsLr7LwGguv43fb8LrD 4543yeedLLzDwm4W3mfhQxb2svAJfv8pC5+x8DkL+1n4gtx7AK9fsXAQP1ey8DV+/oaFb1n4joUf WGDqC0dZ+ImF4xjnZxZ+ZeE3Fs545PNPFv6iBGtU3CW2ZKFVrWsU/Nnntiy0byHU+evAuEuQ78iu nTzidGG4K+G6sc/dWejBQi/ke+O1L7v2Z2GgQjpXEG4I+zyUhStZGMbCcBY0+L0Wrzq8hrBrGH6O YNdI/DwCr1ez6zUsjEI8ml31LESzwJqfEMeCgYUEjzwlMTyeBSMLKSyksjCZhSksTMW41+J1GrtO Z2EGC9exYGLBzEImfm/B60x2tbIwi4U8FvKRt7PrbBacJA8F+LmIXeeycCMLN7FwC/LF7HobC7ez sICFO1i4k4WFLCzCOHez6z34+V52vQ8/38+uJSwsZuE/LDyI/EMk/YfJ50fZ58dYWMbCcuSfYNdS /LyCXZ9i4WnEq9l1LX5ex67rWXiWhedZKEN+A7tuxM8vsesWFl4maW7Fz6+w66ssvMbCGyxsZ2EH C2/i92+x69sedSf1fe+w6wcsVLDwEQt7WPiYhU/x+8/Y9XMWviT3f0U+V+Lnr9n1Wxa+Z+EHFg6z UOWR5hGGjyrY9U+MO87CzyycIN+fxM+/sOuvLPxGvjvNPp8h+E/2+SwLf3GO9XN+LPj71X5/Efsc wEJbFtqxcDEL7VnowMIlLHRk4VKM3xmvXdi1K37uhtcgdu3OQg8WeiLXm137sBCMuC9e+7FrfxYG IB7IrlewMISFK1kYjryGXbUkr/QvlPFhLITj9xHsGslCFOKR7DqaBdZxCjEsxLEwBr8b6yEzgeFx LCSykITfTWTXZBZSWZiM3BR2TSP3TmOfryP4evY5g4VMFrJYsOJ3s9g1Dz/ns6udhdksuFkoJPcX sc9zCb6Bfb6R4JvY55sR38qut7NwBwt3srCQhbtYuJeF+1goYeEBFh7E+A+z6yMsLGHhUeSWEdmP s89PEvwUfl6F19XsugY/r2XXdSTuevb5GT6GQu4Fdt3AwkYWXkRuE7tuZuFlFray8AoLr7LwOpGz DT9vZ9cd+Hknu+7Cz7vZ9T38/CG77mFhL7n/E/b5MxY+R24/u37BwkEWKln4hoVvWfiOhR9YOMzC ERaOsnAM7znOrj8TmSfY55Ms/MrCGcK3yAp+dYF+YWnPAydXX5fT8rqLTZUBSw7PXL/kx3v0m+wT W718XJOwNOiLt2ZP/2HmLZUflo/RDJ509siVLd+6M7tlWEiAYXPXjGvLWZxLJvx8bWWXy8e9VlB6 7/NlfV7+fuXmLj2qXzsw/qOgHZrBW6ZGr0ue8uGHkS+vWHzyetut2qCX7/25w7SqJ+5dnzRn2pCt vzp1r/56x/dpIyP8X3qkKI7FvWKcZvITCSGxCexzpyOFm+7svrnLd+O+mPbztqGjl3+1ddJrZ1uk rd5ym3GufsqtKSxO+5t3t9LY2mZG9Yn+YeDZQQPnWtZuXtp/2HMfvXBu7QH/vC+3/xW7MVUfdG3Q Hav3vtD25eQ7XUHx37/+0E3D/X/LDS555f2dcwyVAZOy4vc/M/aFAbfODN4xePi61O/PHLq1z8j5 Xz48ZuWXtk+KV54O3L7ly7gvn/hiVf91r7kPF5jfc2bvPf3gwAd++Wuo840F5Z/Nf+2GnG7DN5mH Rp7ddsUV930S77h8zC6/Qw+fvP7p9755/XjHN2Z9bOnYetwtV3Uy99xw7vMhrrMtxm7bFbxgwrKr l5TtaVGVFjGjX6hr+70vv3bp7pbTUsbe/6nZ3F1T9tKsh/tfOWT26sAdP108f0bMO0V9g6o2d51U eqpw94mz41f3Grdo3rPnxr8XsO3HuTsnD5zpvmv7mg+T9JuKTm/sOnR8zLKvDq7q7+4ZEL+j7+Mv P3n/e7lnX9zzbRHDMx/65S/zfXfHTSo8Ou8mhu82Twm57bo5M+aNumbAxPtOBL/3a6t+kx/s/cfa kb9+uGzVjYY7WRxz3oHhvb/4aPGEb04+NXnTe0e/eOj+ku9eaZf4TpDhohNpN5x5f0ZZZZ9taV02 9vP/7O1b/4xJX7Foze4t81eMf6//jw+PaLn85ucy9p3sYpty1+p5q5LMu9/+tIftOevdf8V3fbTE /tzvt/W/9JEPu7+we05JrOGTo8e/nfr48D2PPpfaq+qhbc5Ow364+oE/NvUJiL93hCun4L7854oj 9k984fKIUStu7j57xyM/jNl9z1fCK+z7+KRFc3vHf1v6Kvt8d+wfbx997YE0/8SBOyouezrosWXH Kh5a/1l8QUa754e9tKfnd13/2Lmh6pd7etsqXzdlrr5pwrHq5BvbTe+6k9375blV/9ny9g+PTF/3 xqTbDt92Vadhq7p3rnzlkHbY2bt33myouL37gTf2fnhu547rbUVftv9mb9Jj7baN/elcr6rHHywa /NtDn7yxo2XO1yPeu2zsyNuPBR/+LaTF1ifn3jTR9Oxdr2/dde1d5X+O/mX16V+v+Uhr7nXZr8cO bfxm9KKPyz656XndK68du33yzElb3wru/t0S4fhru1589OB1Sd+W7gudmvpkkrNy7vsDE3XbdsX8 xzTnuz5r9M91GXbsy9sjon4q0N2n6b31g/UHt45P6VGcdGbFTWczNr019Lqs+6+1WrKvn9s9emBi z7S2EW8v2/pNmwM3ZlUfH7P9hT7T3u25XnvzV9nL+/d9qnXvp+IP7e1w+/Y9GXMnDcn946FPXln8 Wv8XdmY/te3WFX4PvLV4QMjch5794tL47PET8q8Z8vTpxw8U9tAu6lz5TeD6I5UnJ9zxzg878kp/ zf597OgrdyT3DIs5cmr24fUr7zw69Qnjt6WtElZsKX83+779xb/7f3/u+db9B1ZvTqp2tX7+x9OX dv/guU0tOxqmtA7X2e56tXJ8YI/PbV+zeD0nOycfYtf8PGeHIRl/7Nj8zurh/R83vDTllomn1zuv +qZXkEb/lmnElNW/9nl2a9C5ZUdZ3Hc/mvPRgEvvf6737Es2XNd7y2B7D8u71ncCW+x9/f5Nxy5d MTK2/91r8z8xfnRs2NaXX7v98PYpt5509g5/8eeBURZ9t4jqF34L/0PbcqAz5E323eC106Y/9sC3 n9/4yiWnra4u45a/uCa894Lf/bvkzPnO9PRfIcHsc/6o8rF/9Y24bOOIs5/3CrzxhjuOXz17pG7A wx8HLVw0kH1/Z4l559K99/8y8IMw3Y7XH4k+sHb9Ja5Ty0L6ZI3+YO6ELaNau3KuHs7i6c0hAd2S L36v2+0zHxk9+sXeN/Rb+0l02qtzHzi2/OuIvjflftNnWfYLwwuPLRpySXLLO2c/vidlxJSJifcu OfDNfR+6um8tn/tRqa1j+cWV4/Unz3443zBpyexuMX37PXb6dIuvk+5Z9fT0gW1DV2ePv+uhlvsf eHzAqp93z7hh+TOPLdtz90/v5DxTlX5ifPA3ty5dceC+yd8d+uqJsfe6tCFb9K1HD0lP/3DBi5N+ O7ls5b5Lh7x3eMjNR2ckp+uen7B/59Zzr781/cU39/ZOHpG2aOLIaVc/nXR3YODBrr93faP7L2nf Jfi3+CzvulZhKy+7Zd6Llq/fDNv79dvf/Twj7vDJkMJjZX/mnV33/Zw9UdfYPvn001VHO6WNmNL+ 9Ojx+mt/mNrxsaA1gz87Nbd3QIt33ns16p43CoPN9yTMz/zm6D3zOnzy4HNDirq99vz9601zbjr+ 3dF5q7/NPt3hP8tvWf7MS6lP9b7o5v3vrt0/a/cHTx2+U1OUETzIcmL8qvmlYdFbRi7ff2xdh+++ vm/yI9vHfzx9560Ti47PvKHNrV1uLHt8/LX+zxv6fv9ThX6R45qBDxz8pd3rJad6PWYtPrH4w4Fx Ibe9H/fR3nPaaa2ej3uCcU+xcMuUgRtuq2rz89Nzrzh3+ladbmL+2ddL/xz161ddQw0DO3/gyH1x 39evbcsdZO3089RnWfyQyMJjW/Mnj35uX5vE6zV9ev22eeY3117f8/PUGSOmvJzf/paNncvey33v zV83b1rhP/zoLuM1X90b3/1Au9cv6jnwk5VVt7SM+vPld24fWi68urP1prMDrgu3u/Mv+uq25c/c 83vqgWF37ui10vj06B4b3lvSvcddk3a/s7HtqS83vHvXjHu6XNHjy0d++/TjQWtz3z1y8NjNI77I Lz7R8tTnWx42bnj3lW8W33h76FDz7sJzYV8z/ufv9z75Dbt+1n7oT3983n3nQ53HrJ327fapS8I3 vvtd5+yfru328OUhZw+lb0u87tNnVj15zezMefotrf1XH2X3nAtauf4/C/rdFrbcNqPSNOWdDfc8 EOqXZb7zqjOnr+s7NOr9YQ+lJVX1HnrHfR9ealnw0qE/9CPiXhk1+Lpw06GcW/RTMybP+Gnexo1H SnaFXXrN5+5D28rPHl+1c8yYTmWPmqfO7rfrtYd7tzpYNPfKiMXftIyYOqWsjfvoD3e2zcgb0O/r M7bscyuTp6zaf9Pm6oNPbv58dlqvnQ/f/8XwLh9vP/Lg0W9/3Hu8g/+q5Cm6gzd33amvLlkW+fmB x3at/s+JYWUbL2J8i43hf3bI/zHrjQEz2v94fGGO5WNbt04hT3/f8oOMkJK7hWfOHLt7xbg97Wds vSL+t3eWPd+1I7tHUPk7x8ZVnRT4Lw8p87d0VOa/uliZP72WzWMU+Ls+VY4/u0KZNz+vzG8+qcw/ +pFyuv1/Vo4foVXm+5xS5vkijxJ/+GfldK/+Ujn+uYPK/IS9yjyf+yrxfIoZrMCbVfhRKvU1X8Ue fj6hrNeii5Tjt1exn+1q9rZPmW/bXpm3fazMv62SnzWtlfndnynz3VTKeXClMv+gSr1/pmKfl32u zO9TyedilfJxqtjzJJV8/vWJMh+pYs+jNMr8IyrlnKqSn3CV9liuom8vQdlu56xUjv9rnDJfXKnM Z3+lzJer1NceFX7vc8r8ZBW/ESko6/VSS+X4K1XSvUXFPper1G8yC/0U+DyV+EUq/rC9ij/XrVbm X/lCWc4lKv6cr9kqyblDRc7VKvyZr1X6I5VyripVTredSrubp2L/h1XSvWK/Mr9ApX6zVOxneTtl /iWVfmSYSnzTjyr9SCeV/kilvt5S8WOHVfrxsSp6TVQp5+Uqfr5QpT8aFKgc/y4VP99BRc5DXZTj f65Szg+q1GOkip2sVekfQ1Ta17Mq8j9RKedElfifqfjJR1T0Gv+MMt9Zpb+Yr+IPT6n0I6erVexf Jf9vqIw/L1fJz8Uq/dFJFb8xWcUeXqxUjj9Fpb3rVew8VsUOZ6jU+6sq5TNXpXy+VanfYBU7uUvF L321Rjk/M1T0ylPp37d3Vo6fppKfT1Xab4BKOxqm0o42q8S/WsUeBJV66a8yDv+0pbK+96uU25sq 8x2NCv+TSr20U7E33XBlPl2lXz6lUi8nS1X6x4uUxw9Pq5TzbhU7/Fgl/g0q9tBVZXzygIocg4of +EBQ5reuUqkvlfx8oNIfPa5ihwdU0n1JJf77Kvwxtfgq5dNLJZ8TVdpvpop8i0r/PmAnt4d2Qum1 4sbMDOQ//oXHbycELxL5FNy3abcX418knlP6GPdJhz0p8iXDxIj9UU6XN5G/XuQvRj4/U+TLcWOz J/I33iXyZZeIfBfkR3QXeWkDsi3yN3cT+eo/xIyYkU93YD5D5fnpt17kAwNEfiTy+97GdKfI86m/ F+NfLM/PVyexfNaKfBQe0Fr8lRg/OFcsn0PiRbjchPkcJMbvg3LWPIzysRyeR34V6qXBjdYY5A9e jeUwQuQ7Iz/tfpHXR4j8QuR7XIHlMFJebgfuw/zoRN6IfGgv5AfK4/8+WuSNA+X1NUuP6V4l593X Yv7RHtKQ31SG+k4T+WuRj5qCdtJRLuc2rC/YZCfl9vBbIl88XeSl83H8vFsnoY0Q9JT8MMDGyzH/ 18j1WjdH5B2Y/zzkH70G6zFSnp8POmF+/hLlv4R8JNZjpYc9t71N5Cuw3iUf9QuWQzGWQ3vkxxzA dnG/aDjSGZePe4h8en8x/uUYP+QFzL+HnLAT/BhaFyENzy9K5wBP9EQ796jf6nfQTpLk9j9rD9bj WZHXoT23X4zlYJDbW3pflDNELj+wM+bTT+QfQH7Hz2I+NZjPQci7ArA88SCGVJ7Rl2L5eJT/1a9i OTtF+e9iPndmYz41Ih+O8X/fhfnE9t4B+au6oPxzonyp3cVivQe3EOMvR77dKEwX253Ut24vRjmX yv2G30PYXkbJyy3wlOhP0neK/DA06PaYz3IPv2Rog+UTL/J9kZ90A+qFh0pmIX/wdox/uchPlcoB xhXthZJVYoFJ51SrtmJ7nCfGl87HJd6I+e8ml/PTdCyHHnI7PzkM5fjL7eEP7BfKp8v1Wtwf7bO9 vF4OoV8q0cjlVGZguiPk7S4O7bbCT9RLOnOy4n0sB6PcbzjfwHK7BfOD7a57DNptqLx+NzyL8VuK vGS3b0xEvdBvzEN+FPYLxkIxP8sxP09I/elSkTdjuhXIBy4T+XyU8zHmsyxPns/PLsHyaSXy0vHm EX2wvrrK/cYXmJ+KP0R+GsoZn4/pdpK3l80wHu4ilI4RLUTqL87FYX7wEFGqVD7otytby/326Oux PfaX8w+0xXxi/gcjf0CHfIi8Ha1/CctzgchvxvY+Cv18yTVy+R+v5m2kvVC5UowotZfPdmN9od87 guXQOwvz2Ubk/4Pxc55HfprcDt2XYb/ZXZ5u5mDkY+X2uXImpovxhyG/ZBP6GaNc/rsfif6h+kOR vwP571uhvh+JGb8L+RuWYP2GyvNzA/qB6ivk5fkTjh8qdPJ8vvEo9jt95XI63IL16+HfbrgO28tw efzffsT6WiGW/zlp3HgP9i8e46uhOP4JTBD5dcgP/hDTnST3D0ux/yrHhv4R8qd+FcutAg80HcSH CmbbsP9tLy//3SgfDq0ROXvTUb5GXj69HkE5feTjqCPoHxwe/uEt7K9LJsvHP++hnQTGyf3nRVNR 337ydCtwfFV2pZz334D59+gvTqE/KblBLH8L8tNvRTmd5P68Yq3Y3qul5wSwvgwov3qyXP4X2F5K YuR+Y9+XaD+PiOleg+30M0w3cLAYPw7jp0VjeQ6R67UVx/+OkXI/9gLWb+XTOD5Bh779XYyfJPfz +pXIe4xjF6BegVhu0vMdS79H//y4mPEbsBzuPCH6E81zcn9y/2pxPJM+Tj7uSrwS7aeLPF0zjsOL Q+Tj/9/nYrvoLreHVKn/Qvt8DPl7VmD76imf77whjd/8xXzasN9JOYh+pp3IG9EQH/0a83OHyG/E gjuA7TS9nXxc0QbnifrjIj8H4/eORX8S49Fe3FgOveR2cv1wjI/znSuRT8L6hYOPXH+UfwztxNFB Ln+TBusLHUx35CP+g3brMU7oOAjttr/c327Dfqq8s9yPvWDGfOL8UYP88vlYzjjOz0H+NpxXluMh 1wrk8yyY7tXycnjmFLeZ7kKFWRqJiX9/XYT11Vae/wPob/VXyvO5Fee/6bFy/3b5VZj/wXI5Q7Cc y/EwqRHL+a0Nyv4qrhD9BvazOuQrcL6p7ycvzw1O5K+W2+eYYJTfVR4/OxL9GB5wHoj86xjfOETu B+JxPlgyXd5+/Tcq+8OncBxVmSEfR+VdjHbSSu63DRuV/d7Kl7F+80X+T/RvPcegHerk48bwcow/ W57uG1I/9YTIt8Z+6pneWI9XycunWzj6q1Hy8jmIfiBwuLx+bfOwvQTJ+1lu3lAv74sZSUf/cMda 0Y8dRj8mzd8X4XipJFHuV4tw3qq/WywAF36RjfPfwEHydPtiv1aO6wNjkPfHeY3wh3ze53gay/9q uV7H0L+Vn8TxAFZ8Ic4X9Bq5nTyDfrt0tdxvBx3DfD4p8tIzLf0k/3ZElHMK9XoC+bIXMP/IX4/t q3qw3G+3xfFhZW95fvyxHw8cJo//xRNYzgPlfPuByMfK27u+Jdrbh2LGcTgobOuHfCeP9qjHdC+T l2f1M1hureX2H47j1Yor5f5q5AdYX8ke7WIIttORHv1XEfpJnCdK6y0rsV8QPPybdpU4DjEm4POY yFfhupwxVB5/XXvsL06LBbBQerYG13kCe8n91b5U1BfLwY78cGxHZehnrpDK7T3kJ8jHh9YRKH+M XN/4m7D8L/UYz0j2c1DkF2B7L8f5WnoXef1+XYn9Ms4HpWdjR2O/U3GFXH6BtE4YLfLSOuFi9G9l reT1+NBj2I4McjkDcV2i5F2Rn4R2/uYA1CtcblcnsV0X95S36xPtkNfK7aoc+19NuDzdfV2xvxsn H/9vwHWhapwXSO03bBzWo17ub+fNRj5G3u9MwfXYskB5OYdI68A4v/sQ+W44b9JfIR//XL4Ayz9Q Po69FdczjR5+eJsW7SRC7rdvwPIsC5OX548rcRyO8+4itOcYXCfRd5D7k22lWD495XY4Lwrz2Ufu hwPRbwfPF+0qHfuvN3BfoAL7TWlefO9yzH+sXP43OB4o9rDb34ci31se/0f055V9PcaHOG9N7yPn g3E+Fejhl/qhPZRjfyHZQ4sE7O9wPiWtS6SjXQnxcrvaJK0rthD5Ncivwnluscc8dwuO5yu7yPUq Q79R2kPuNyoKMP8edr4e+1l9oli/lcgv24ZycN+kK/KrcR5dbRErSnqedSzO0x1Xy8u/BOultJ/c 7+lw3UZ6oExqL1Wvox3OEfntWO+XHMd+B/1PW+TX43pgZWe5/S9Jw/ho/9FSuaH/KUU/Lx1odeF8 rThJPn47hHZe0sGjXeA6icYoH5deI41PJoq8tE7iX47lNlM+7roK+4WywfJy64jjQ/3tIi+9ymB1 C9EfluJDjsvQH36A665Gj/FVagmmGy2v92eCMP9x8va7/CmUEyaPP3Qz5hP17YH87dJ8uZM8/iyM X4LxuyF/2xHknxbrUVo/fwXXaSvby+05DvOpj5SX/296tLeu8nQnB6Kcs/Lx234cJ5RPko8bc3Ff IBDXSaT5WkdcDzGGy/PjWCW2FweOS4OQH4blVjnUo31hOVQY5Xb1czKWfx+5/T97J8b32H9cg34s vbdcfkAYpquXxw/A8Xz6VvQ/qPBE3Feq7iPvl7uUYn6Gy/XV4fjN2FFun39K46ggeX72bEf56Dcu Qb4I57NGj/XJRegP09F/Tkd+2+PoHy6Xy38A17s0OC+T9i/uRX2LPxF5A+prxvFSKc4X3sX4T7yG 8vEBz/XY76zD/Q7HFHl5voD5rMTxVQzyR7A8Kz3GLU/hPpSxk7x99RmL/R3Oy6T1eesdWG5Y79L8 /alFqG97uX/7cbOy/wlC/yY9dFuA/A1YX47ucjlDX1Ju107cTynt5TEeQz9Z5rFP1+8n5O1iQXZA fzUAxxXVYfJ674zr/9VF8v2Iy1DfUvS30npgDO4b6i+X+4FZLyn7meuk8Xw3ef67YDsK7i/nZ8zA /AfI83kAx/P6X3C/D+2kex7mc5B8XLfiB5RfKkaU5guDi9HPXCofvx3F8WE6rmNI6yRtcB2vxMPP DMV9imCP+Wk4znc0I+V6/YT7khqT3M53laM/xHZ6EcZf0AHH27+L8p3IR+D4obKNXP4L2I9rPPzS SVxPK8NxjrSe1ikeebRPab6zA+cvGo/5ywzcVyrzGHd1xHZdgnYorcNHS/tohfJ+swL3VY2CXE4b XId0ZIkFMxfjf4Tz9HRcX+2F8VviOYSKUXK/fSn67ZJAef4X4LpNxTi53RbGoL4e/exD2L+UYb1H SunifkSJh/+ZFIH1EiX3V2/i/CKwvdyeYzpi+XjU4/M4znfEy8eBc3A9sxjXMyX5GbjeXo3zX2ke 9xzuq1ZMl4/bde0xn/7y8v8WxyfBOD6R1p8zcb4m4DxROjv0IK4PGD3k6HGdKvAqub/9GvcBjS3l 5XDFOkwXz3VMQL7fc5h/jH8V8h2XYvmHyeu37zKsx2vk/BY7tq8webvOHI/2PFI+LziC62OBHuO3 OWifFdmiHcZh+92/EMvnErk/2Ybtt/K4WPAm7Acfn4D+M0putx1zUU5XeT3mo38L7ijP/yb0k4Ej 5eU5Ac+H6EfL7bzvGtynwP19ab75Dq7LlXnsA56U/BvWu9TuDkxCu+3vUW64Hq7xWIfRXILjATwg tggPpnyN6zl6D7+aczfaycXy/jcB9/U0OB7QI78A/ZID/VIU8g/jeqBDkO/7p36D5ewU+VMY/yDu d6cHyvuRp9Hflnu0UwHHIYGCPN0H0C9VDpDXr0Wyw4vl8vvPwnQHy+t3L5ZD9cVyey7B/ZeKdvL6 KsH1E2Nveb3fdDPWV2e5nEek9X+Pc1ZO3JcsniyXMw7tORDP4UjjyT+3YD4zxfjSuvfHISgf5zWS vfXCeglsK0ZsKa1Por05POztY+l84AB5PqehHyv1l7eXrjheEnD8L61X343zjopJ8vH/ZFx/cywW +RPYTg9J+1Ye68znpHNiOP6R1i23oz8M9vCH0Z+gvjZR30dR31twflTsL+83c9eI/U6wx3mtbihf 4+E/l6LfcHSW29WiV7BdF4v8IqyXq3DdxuHhPzfieSRHlEd/hOcl0lfJ18knJWK9jJaPn5d+h+Xw hLx9PYXrtEI7+XhyhBX16iK3/xlJaM+j5eOTfdiPV46Tj7fduE9aEiT3G0vKsfzvEnk/LP9kbC+C xzr8BDzvJOA4TSr/oBexnSbKx+dpyOsT5ePeVuj3Ag+JCT6Lfu+NyZjPP+Xjxttx3l3eXl7+7+G6 Ysklcr4N+iWjx7wsA/v9Uly3rHlfIK7nVOA4U5pvpudg/N7ydvT7R2ifbcR6vBP5cuyvHdhfx0rl j+frAgfK5SzB8ilOlLe759BvG3EcJa1H/ZSCdnuZ3K4mYD/r8JiPT8d5YonHfr0T1y2Dp8jLIUZq vx7zaA368zKsl8FoJz+gfwjEl+hI+6H7cH8q/U/5eqPrW6xHh1huI1HOZlx/C+whT9exHfOJ9tYG +baS/28nr99x2I8HrpKPhwfoUS+PcymdsN8ROsjr5Vbcny3uJ8+PP+43BXqMo76Q1jGelZeDEddj iwPkfm88rhsE95PLmY9+W++x7ncM15+LF4h6/Yl80QNYv7iuIp2r8ZfGzx7nKO7F8aHgcV63Be5r aDzWq4e40A77yf3PAdxfS4/z6E8PY/wCuX8bhuOx6h7yfmcYrn9Weqz/34nztfK+cv6oP5bDHtFw pPNR+15U9ntP4bka4UYxP73xpaA3Yv6NsfL8vwHnCnoI1R7nCi4/KfY7a7Df0SPfH/eP0kPkfiNo k7I//Bb330uny/u1tE3KfnI3lr+mr7z/+gr3STWXyfOfh/oGP4D7s6hvMT53UInzDmm9/TkcDxhx /URaf64wIh8p719mlWJ5Xim3k6npKN+jfX2A80FHuLwfWYHrJOUD5fwoaR/5O/l4Y00MtrsY+bhx CfoZvcc6Q0v0t8V95e165oPYXqLk7WUWjq9Ku8rt5zieIwrEfVtpntgOzxMGox1eh/EX4b5eCY6v pH29L3F/U3qxndT/Lj+K5YzrzFI+b8J12oqe8vL8C/u1slh5v3ADnq8uMcjLJwDzX43jOmkd7C0c VwcO8fB76K+MHv7qfTwXFIzngqT57/vYPwrd5fZ5bQbmP1qe/5M43y/1sJNj+JyI4xH0M1jvt6G/ FTz85Cs4nxVGy+VsH4n59Oj3V09D+xwil3MA20X6UHn+v8d9HMEl1ov0ztE/sF6qPc5r2dFuSx+T 538unpOsxnU/aV03RcqnR/5TcL7guAHrUTovgeuB+v7y/L+M52w9nxOZtQN5k9w/dMZzUGUe/ftG 9Hue56lmlmM7wpcFSvtBn+D+oyNGLudN3M8N9jhvyfflOjHrW4jniqW/05h/z+c7FmJ5Ft8j8t/j Rv7vOD6svkYufybORwKvltt/R5yXleM6gzQeaI/jyeqO8vKMwOdNPJ8TmYJ+rNjjOaO78HmHYpzn Poj8JbiuXuKxXzYC7TD9Srm/3YLPiTj0cr2W43MfjiT5OtuNVaivWz6OmozrDMEe68luHJeWXyT3 S2tw/bMczwlI6592aZ+iQuSl8zy70a7KPJ5HKMRyK5kmH2cKJtPMfLvN5HKbnW6TSTBZbVa3YMpm F8GUkDrelGVxWmZaXW6LM3V8bJ7dZkk1Z+RZxO+UvzFlFpm5AHOedR6D4wpNyRgvNs/scllcQp41 w+ke5rIP0wrD7Q738BR7tnuO2WkZnm8usuRZnPyaac93WNnnq3QabeSwkGHa4ewuKYLddZXLmg8M u7rmMuH5TJ5gmmybY7VlsQRdBfks7WkTtKFEFourDY2bazPnWzOnmJ2TE2xurdZtctjteaY5TrMj NNtpsRhyjfmNvjPMnJdnzzQYUzQmb+4Nd8GtBm/ixmkNhYrxwlLcTos5f8z46ESL02bJi7QUWTIL 3BaNcnydTow23mwzz7Q4Y1h+Z6XMtWVqtRML3I4C9xRzXoElViUx9ZvnOK1uiyghYUKKSauNnzox O9tlcY+xFiUk5YboDElWjSGJfRWZYp1pG2/Pshi0Bv5XmJucmKpYXKqp6WZa3OPNDocli5mUITkx xZXbqPtDwMzH5BW4cqy2mY1UNXx2gaXAkmwxs8TZR5fbkJvRKAERLpJ7KG6lEguNVCgxjVhiXGOp 0FJcoczOHVqNiTdSl9tpn8tLxJyQaSBf6zSmFJMl3+Gey1qrgzVzu5NlCmOw2jYmZtKb3JGm5AwT sytLQm6KO9RhtjoTEnN9syWDIcXNcpfCGmymW+tyJ6SEmRgVmmdxuRJyDSxRThi0oUyBTGbJbovJ xnRNGMcy5NZpHVZLpmWO1WUxZdptTL2CTLfJneIOcxc48nikFC27OWWsKWEclI2RJRYiZV4UxMXH OSZicf0Nqul0TDVW+HnmTIuJWZzbVGCzMtPxUUWWZkSNhqzVOc2sNjFpXa3uIEv+/d9bClGsFFjD ZV2Ly8I6GVIQzAu6Gsw8LwbMu9XuMmWYXZbQBNZLSb7Kk0eHyfJWoytrIMzC8i02t1FGczOBGz3j W21exGeK1cYH1cys73FaMsx5ZlumJUPlXtZHJKeYQEIU0zOf9ZRuC89xVp6RX2xz8rETZXwR740B ZLBO1GbKNLszc5CxsNQodlrcOU77HN6lFxWZHKwi7bwTZk2/UMNIB/uWOS/TLMtcbG+K3YomzpJR MHMm78vjdCpdj4fL0ip7rFidgVOFZifUOEQ0KPd5Xgv0Kj9qnU7dDLGY3uWoHpFeZUnNq9fNEovp XZbqEeldlqK8zlKUt1lSF6mcJR0YmziQcamam466Ia3GaWEJwmev4uv4kNZqzktxM5P36o4w5q1S rPlGs9Ocb2FNFEYaySkub26FzNX08i7v0nMppJeiUx5Kym7V6aQxeE2SgEACH1x4DCYNiiMWucw4 lQGkRyzVyjIW5OWlWG3QX0Q5GEiwsR7DoDhSk8dWT1kWS21ALI+llj+PEmG9CCsr74btLK6yFqFG NqJMsRc4My316uEZT00Tz3hqunhOAbQah9NiEKcB3t6iLXBksYZRX+uoc084WHksi1LAbrPabd7e GMlaFgy/kyyFFt4inW5vb41yFthIirFzM/O8za+uTn6js1kjgYx4KUI0E2UPUCeuzvu4qqZSJ6K3 00BVYwmvO6MBVwVknMXF/LXByH1GhIzjMZWdfx2B9SleJ7JaPnVa0ZUZ8mAANjGDjawKLU6dJp/S sTlm20yGkhN5jkNktyjmVkWsai68GQA3/mY3G4myDo+vnDT65trJ73hLvi+TX6mrEP0xF+BunIRQ SYJYBqKIxk2BqQ7iJAIUaVw+ImZ6TqR9KI66QpRm4yojUfaXalKz9SYmWc8CgC9pupRLXGw4nsOD Jq5niAOlJktucltXkSsOzhrX7CJ5t6Pe16jdFsWnWtDQGrkqlmpqlBmjy83Ly7OyAaO1MbeqdT2q 8Ru5Nqjm4DwmhEwDY2K+otJ1YyquzNaN1mC6fN7nZcIYtUGRfN7mpUiM2rDIKO+UxnggL4rN/m0F psyiIm2IzTLHBAvTsJYCiz+s/3GbrWygaIo3u3JwnUxaB2JTBs9kIhImwqq9wZCUAQaq1WRZUKbF YEyJNOVfiFTjmkU7vlzlyjE7LVkmh5vdUnfc7TGLUtM6ujm09j03F6Y0dJroDJfbac6s7T/szrl/ b5k0lKfzUjIp9vNq/eqpNayNUZZAWG0CsNJYJ78hDeW3IXkNe5mGJDSsU0M2EAnTfBiP8k+xdpvN kgmT0Dr6hjWkb1PSahZN2DQfpbtyzrcmqml5pYnn5opkwNYUd3ghE8Vj6UwJzJ5dNUv/dfWI8kIP H1OKwF2wBNYsDYZCo7jjcT5SalJ5+bzZ0njvc35yUVvOEU0t5ybkoml1wOrTpyZWv8DakgltcsmA wCYq2VBnqjZNEhcIfOnjz3N2ags4qukF3PTsNK16cpvZBHOb2QJzvdTQm2E8yViYlxnzSmzD4xEv BTVKUR9G7j54zSYl16iC8SWBZi0w1WH9+Sw29USbtfDUk2lKEfJZQlMalZK4pqgNArxXCEZUnt5P 17D3o3crpBZuYrGtM20sUxkF2dkWr5t/uGk8V6P5BEYwgeasrEZK9KUh+pR1nzzYeVFJvXmcF8Xq 8TTNoR40g+bIuNi+fcgSnbpoydQl1ORjmdYv0Jcs+j7q9yH7vifmk2rcMfmSS36fbwk2eRjrU3ab nKpPyub6lttcz+QSGzhVE5phybY74ayvhx9Uud1jtyvUZZ1n8TJulNvOPrEPk/GAnOzwVVoqb2Y+ SIKTbc0jCk6kNUKU/PCKNtzq4ozYuOLsNot4iKbOjeob17JDIyrJqh/btrqkA9/RmW5roVq91Ceg afkPt1ksWa5Ue7K0JdhIAQ2aIxzD5Qutbn5qk7torwYp6MU91qhrjvMaGG+ZXWDOM7ntCdzpu0Nz WBr844SUcJM20jTenmVy8r1ZE/+Cn6jnX+g0pjhLtrkgzy1+mQXfSl8ZndZ8i8lp4ZzJYc+zZs4V xUXUasCmo2ar25XAl8GTMjTScrhOyxpxgcviMrlYWixaRkHmLIvbYDSCgDprzf9LZcMSFE8Ie2ES Pgz+eHGE+1gckWrFEaleHJHqxRHZVFOJ9MVU/gfKrDlNSHWY/W8rlAtuSP81JdcEc+KTn3+bA272 zum/oEwUTEBnMjXKjSbRMb7OlMSGRFIm2ADX4fZaskq78lp+kw+x8BmIzVLUCIm+HhBp/pTqP3bR 5PRqjjzIJTFzb97TQ14KbPrBnGZKyNvTLr4lp3DQhAlq+AQIHGj0uS7EZ1TZ/LFZ0vO9qi5sPhqq yfOaG1LRjU2HGEZzHJXxTkyD51REMd4c3tCQBcsQ+eGN+oU0w8mEBhKQbfA3FLf59qobSCnXM6qX 27D1OKAQk4rxNXJrVn6Hb5ui9WQzzItsNmWjtHGS6tucPM9KNLxhWa883EpsokHUt71IYsp3AuE9 BjWPhXMgnVlPsee5DMYxySn2FEzNVfPV/8YCEcxPardbcXriUp2f5P9/2fxP2UdYZp7F7PyfUrnG bfxvr/vV5xmUlrga9Az/w2X2//bkvSf5HyiK5vAw/zULwhfcz/zXl9z/21Zz+5z/mgLxwfP8G3cY mn1W819cJv8L9uCjH/g3qkpbeOOGUd7eqeYMvb6/gVVJb+XUs7LcCBFqq8oqIphJkG90rBLhqL3J XFCUwGvBEGWSXruZYGzK2rihMNXEfHqzJaS6et7IhOgCG9waVnvrFFheB5falH0B6RhxrURrviNP VuzNnVKIzDcajIzNP2+JSS++THXUPsRw/nRrSrmpGU3z11CDKTVnDTWYWPPWUEPJ1VNupLXx2NrG lLnSvXVKUataikq3N6pcFATIctucJz68F+zTgY9GiK+/c2uuZNTbfTOmoGK3PqaQYvf6Rt+2cLlx Fprzap4COC/buI1JhHeRjYrf5O3cxqSWqxy9wGZ38pf7Z5nyzY6E+hb2yVDXcxAs37PjLV9WvZ5p NH6s6nXaIU1NW220e95ywEaYPpdsaE2Ly7QX2NwJXre4UIfdamMlK00q5AdAmvBWqBq5dkNySoSp Kcn5fqjHIxtR5zUbDb8f6fxlRvZKIi+LvuF3BckE6SRB4aYUh2hm/Nkq3uXXb23wiwRONm/mUiW7 C68ZRkj5abbTffLHiJPZFMfISiG/qQk34WiZR4aiTTXvvTmfGWrwjNkFyRY9bNb4imnIRj1Fhphq HhtXE9mkublHcmEmOh3xNTn1GbpPyXkziKr74C600xST7PUKLJUoiw3WnKzZCWkuJ3+o0pZlYnYQ beJPWGJsU44lz2Fx8pM7oe65Dl4vYYUwbipEgrs7Y4rBdN6yLisnnlbkeSsnj1dQQHKpvmrWhHOF HhUWXn+FRTW2wnjrjPt71GqslzhPGYmQlW0hZMX3ioZ1M486C6m/zsIbW2fcQUQ3OYfN6HNQZoRM 40KQ2oSSbPrpV496iKy/HmIaWw+8Kx3zN+vX2L79fOfI43V8kCffbSD3n96Ycpu/LeX62pS8Olbt UZqhf0NpepdPj3eaNa4EfBjFN7KjjWxsyUSwkok9r/mv05FFNGOJqR8P/zeVWz1aNGfpwbn1f1JL U8yf7y0Mtwc9/J7ORPYbQvjiFx1je+4X6EyGml+Ns+IOAh+Vh8rXvECOr8O7FNmv0tX2czqlNOCk gGJ0l1LsJvaVamkpqp+rElv22I5XflUhtg++xgcpqi2vYVncWuvEoqZlkltV3cg+Tw/qSmLpKJBN HTh5igR9asnaRtSM28WNEOr9Dqdqc5dvD9b+HKXVu90fnkn6k5PhJg/nwZ22lh+BYgUKIyrFnwYN N9X5wdNmzUBtenzzNoE5aFgUO++Kh9X+GuzfpjwcQOO7xxP4wl2d/ePzk2gE62LzLNlug/ovdp63 tD3ec3A+k7E4+Tro31Cpkax8ndaZOX9LASs1mwv2+8QN+pKwuiV/wTLn6Wei1P3MBcuTVz7obyw0 r/3ThcpQY33XhcpXPX7tQmZB3ef9jUbUaH94oTLWQNOHowZyMTpPMTqv3J6u3sL3Oh1PDxbulQfz WrxXzqh5VPHFr3gruwkuwtskvGvtjZGm3nCbp8Cb0ga9TaMhO2zqhM8zExGemYjwqjFG1F+gFyaX nk05xrumfGEy55Uj+CcUo09u5ILkrClO6IJk0EsXdsHyou4A/wmG1iT3eUFy2IDnyL0wQxlvk/Ft JOOt9GYYyHiZlC8OyEvRTfAgXqbgnQtohDBfBzFeJ+F7I/QyCWqA0tG6cPJ8IdSweNyvKS/208Lb G1VM5nymGyl/3hUbh3QQ9vymHVU3bdeFSry+h5/Vn30+r1lqDlPzYRvqvJpgU/KjbJpRTbaOpuRJ xWT/1kxdaFNuQlYvhIk3fJT77zD0hnP1d5l7wzn724y+waz900y/wQyfhwYge2jgApi2LL3zNXyo L83zNmyoJ9G/2dBoVhRMiOWuNgNwxEn+eHEDpwTrPuHYGMm+nLI7vymqn09r1nTh/FfDEsVKt2TY pfNoSVaNoamDRbiEs+kPm2qS5+MuXNrqVuhDmr6PKDzKIab5yqGJebqg5dNQt/P3lZJXOTufZUU8 5/lrMw2kifqxWFoT/JCexeWyZzfTE5zGVFOy+GYaX+T7buWQbvT5Srchu2nW1El9qZdmQ09Xwp0h Snc24byhKDXMR6mqz0rWJ5WeTYZ4OjFeaKa9wC1+stiy8hIy+a2ZLAPSyeZMA2tUbm0IKw5rpsnO as9izk9INaVqTIaUcFFIpPTipKa99om/UalZJfLzl6LQZNbSeY59EK5a3D5nV/XEqBfZpfXI44Yo ZICeLtWaMJqKyCbVl3givpHi1MtTSZxMXylC1Pn0to0U3jyutpkTbYyfbVrSKk42yjcPm+dK8M7/ ZKYy7xNmMiZmsvtSY+uWelgKRBwzPlrcdDNoTLyn14E5W22w8WZo1L1q23deS4kUs+DxW7Bwu4LZ yH59VzVSHXWUDNC7BOvkVyVeuGIBKNigVrQ9Q54l32JzT8xwWZyFzP5VYtdXuvW4Jfg+xZviU4pU p/gUIimWi0I85XKpG1Ge9VRvcqUQSalSFaIpZr5uvHpLf8oE5gv4e03MGdZCrTaCfebO08SftTJZ bdl2hVg69tll9SYiG6cU5qvGbLhalSLVKUCFSIolUzdevSWTY9NFRpq8P7oYwaYoNQ5ZPMCYzFxq bm7ThLGuhQjzSZZLOWPJieCx5D+E7ZvqLsXc1pcA95cNVlucBiZhXkfX1hddLff1J6J6lyytpv64 dmqhxmTThSroKDN3KatextY2ENvDzTQo3TN+Q/LVqtP7GxpIoaEqbfR9JL0Qnff36TT5tDeMzYEX HxtE+w+R9ZQGSX6ErhFm08AvooPAxlhvGBu+Wdy190aFe39vpLPAFjs3Mw/edcVcvdnkKHBaTIVW p7vAnCfkW/KZaL5MU6d6tfFTJ2Zns2/HWIsSknK1Br5Kk8TKKDLFOtM2nu9DaAz896w4VWh2Wm1u UwFENBiaJjCrabdbm3Z7XtNuL2zK7bqm6a5rmu4673QP0Sncr1UyBRbTO1uoR6RXBVLP/V6VSD33 N7VIvLIH1fu9NIh67m+a/l6aRGikt96BxfTOJOoR6VWR1HO/V0VSz/1NLRKvTEL1fi9Nop77m6a/ tyYR5bVJRHlrEuoivSsS9fu9KxL1+5taJN6ZhNr93pqE+v1N01/NJMJsdme+Oc86z2LKzrOb3UwG czQ88Bf6czuIiJ86Br5JSzUZ0viiqMGQIbMP/oWBmowrIc2Rx2ImWUP4UldGRgacEPDMq3JWle1M IZ8RBtEr/uMzypoptNV/R0aj/mkZDc80u9ymbGuRJUsH/6u7Po6jku0FtiyJqGkRKVoTaiXPTI1q aanwjmQ+xwgxMTqEU6H8P/5QpBdZw0LUsrFbbliIQbXLrrd4xSmORw61/Gsd/w+eeGclGmqqLUXU rL4M8lRqyk55bOlRdNwJ1GiS4XXJUZ2kAoQMhzQhw2rl+M/NsXfm+Y/KsXLH8c/IcaRltqmhoq35 Qq2h1xg+RuAZ05kU8wu01N4wt4r5qnF6rERCDQZninIv7TH3jmQ5MmVY3S6D1ZrfUHw+QWvcDWGN vIGP9xt3Q1QjbwhrrNJhjVWal37jbvAiPt+WMzXeCUkxmZ1p60DvG41SJ1TDh3Mqgv8XSZuStsGm JNPJu0Zfpxf1hH+/TrZanVRWTrzJH0sPf6OqTgoz3ZYGS63BocZ58EBRNru7mVTn4uusn3q5LqXV OnjLinbF5kg/ntdEUSluJ/8BvOQUe5OE6WZa3DFWSVrTMhbCZKXOdViaRxgWWLMIC2U5g12iaFeM 3Z7XfNKS7E3Om/iDimP4XMPtbrqq4bWZi7MXZORZmigvAuqBm+0Ypz0/hvcGzOZgj7FhoWprcr40 hwZkNbI9qErzpUGoCvOpRahL86VJqErzrU14I64RjUJVnI+tQlWer81CVWCT2oXawqQv7aIBWY1s F6rSfGkXqsJ8ahfq0nxpF6rSfGsX3ohrRLtQFedju1CV52u7UBXYtHahsjrrU7uoX1Zj24WaNJ/a hZow39qFqjSf2oWaNB/bhRfiGtMu1MT52i7U5PncLtQE1tsuUtzaMPFEqgvqKqMgW+nofIqZn18N cdU8RmbnD5ZZbS6L052Qz0+22vGl4vY8l7jSwoRE1Z51ZaKlE69q0mO1BngRR4LdZZrosNjymQKi oHD+VGOeBY+s8GO4VhaHn7qtfXQl3CSdqZWy1dgnAIx8qsW3YlJTG513OHMnK0sWXaUsFSI3VPDs Dl0Iq35TvstqmsO+MkmqOmcbwTDgmxw2286z1K5zEVKrFe+IzrA73WTDjEYJEd9aP8bI7SUbjrUp xgvLzitw5Uw1uzNzxIdblcWFi+JIPFWJEVlWl0dcZZmRTn6g3prp9pBqVVQ6VlfPl9JTXXXbVWyO JXOWqyB/vCWf2SSXgD+YV/8ZNG14pvgUACfFVyHBycAJ4llpFrH2lKuqwBRrvqEo0+LgjxJotVn2 GHPmrFSnOdOiklnZDXgWrKFYahumHmfetBE1+kiH+GoV0kFc6WiqmjoRcQXmvGiXgwkZX1DEo2KB 5iuu6tH4yZaZXsTHA1txFhfzeHBiy5yVJZ6phWwqnmX2Ro7qrnbdqKqGFDnGmm3n5ZRql45KozoZ KvpEGmMTLLRkteF4h1J0naYmem2l1XuDlucjFfIUnWV2uC1OkinFO1TPdrJyjrNkFMysOZzHizvS YCvIl9Eug9jR1BEcIivH5AJmaZAZrcbltjtSc5izylIuV/VbmY8zO92+3RvGul3WSoxmpznfwvVR LRJ1ES4FESpNQ11KuJm76NoHilyN1SS85jy1dA6zkTUQzvSIK8h3xFmd8GbvuT6URbirTiYaawjh vKNj46oE/rulzgKH22BMLDSOsUrv5vJeUgR0WGCX4qnbRpdplNOSBaUBQrhTLnA0vlR02nxLZu25 VniYycp6sFyjTieeqjXlI2fKMrvNJpeim1CXr5PJJ23QyIcPkIBTIn1PYarT6rbUUSGxmXQIkadA lUhsLi3Ca6sz21yQ5yam4UOt1idNsRNRFUXOKnt/U6Qrp8CdZZ9ja+R93O1zp123R2tc81IbT4Rm ZOezcbmFv6zC7LawqZvLPSbfnRAdZsrkv0SUmKroGdVugwcn678pQrpJHMF6nZjCfQ2npmMjdTZO ZA5KnKYZLawLtqlUHtwRBhMxED1B/htRNrfLySZXWeFWl8lhz+I/CSX9FpQVfwvKaMw0JmZm1syQ WCaz88wzXXl5mTV7RIqpRjgtjjw+gMxnI2HVWM58LKrkFI2pXr1ZTK5BffEiYs0O1m5dOLCwSn+K ccebi8ZY+ewDR5tSM4RRpuwpKexOU0KVE60RxPo/6IPx56EUW3NN7DDoLWtTgfcohPCBVe2YUXy2 U8UvSJKkyUZ9cdSGihEpY6KxwBS/j0oYYxxbfwyYEIEPgc6uoVg4OVP1drUxpblZQxKjpKmZiUy6 6q5ayKpUq2GlLz3DLGWlgXv442IT2ABLbVlENtcJnZNjdqvFrOv4dBEsI3ztRNb1RIuPABtyVXNY z9DD7Zw71uKGaTfrmV12m0pu0KdkwzpSCpsBWbOtFmeSxTbTnWPIT85MrtPyk/NYS0jRirvDKa7Q bKstiw2RMsW5BWMiuHiz02IQny7miz1hmdyZJGTyF9qON82xZllsJqvNKhURfduIxsS8Yb6FdbU5 /EFn8Tfg4XW7NkuR25Qxy23I9/KmULgJum1OG/LFLKbYQ/icMlP8TO02xaXVsXvyLOZZbLbuzJLY UNccMxt3ibWQ4grn1YRKyxmppuRMfk0sqGXZfSJTex+ZFNWAfOnnPjW1b2JJgF+Ukx4qNyrMvWU+ TPopB48n1Gte82pgvGU2mwWb3PYEeI99KC8y/nFCSoSJv9DMzsqRP3Rl4l/wBUf+BSt5HH2IX2bB t9JXCpUiiosgr5TBNSf+EDw/N4IPw4Oh4J3mgiLWi7D+knVjlplOlknms9mci3VqGRD9f6944MVr 4oKjqcBmnV2AL5nLzzeCBNnLB8LEl0Y3WEy1P3PnUzmEqpVDqHo5hKqXQ+gFN5N/of712kGohx3o /nvtQNwNkdbp1VWz/us0a1YL//epf14M/N9XDOIoKxmHXfyt7nQTx/ctLvGXdBX6R4+piPQGeKvs N2Kt4k+iWosME3HvTfG3+hoWX9/PUFlrf2QtCn9EAO0hB47uikbhsPNa0tW+Tx9ahsnKxtFm+JVA JqC2+M5rNr3+fTE0PKaV2YFv1Wz8qCXcBEvg3hqvmu2qm6665XphuPA/tw8c0v5vaY1vifNG7drf r/wX6OV9bVr/jVrhHrzV7lLcR8exBvtGBx6VBbfZjQ41ylKz30lebwl9VMZct8VlTCyE6Zx4dMCd 47TPYcWWZeIP4GD0CMrDW5HFL/g7gcQv7AVukz1bLANxks2+DZW+tdoKzXlWdqtzZgHfApFihGZa nE5B9UVYZF9VLRJd4lCL5OEyVWJ5bkwrR6t5253K97WrQGIEWvyC6iurPBRVilRHUcXXUJG8pTa2 SxZUXr3kkTK8/KPm9dpEOfgim3crniQYAfucJb4TCCyLQVb3NrsJBIlxi7jVCmYXrA5nCxnmzFn8 jXeW2k8m19z8DHueS+DpCPmQDUE6zYC/G1SLxeU605yaExK1XzHVbbX5rP0Cl6Kz+MaFKQN2tzy/ y8bsedAKqcA6jtIXfMSQaXaYM6x5VvdcGY3bOhZxr1D2FasNk0PaUq35hi9aWeER2Roq35Jp4ju/ Jo9tKNUINZtIshhz+N5TvTJkMeoKkXaDsDjtcHKi/m+Z8zVlZ5E4/LUyBInrqgpF6lIvO5dq2eHZ IdhnriE9ThWZMjP4620y8x38km8vZOU8i+VcYFHyLDZ+sWU65vKr254n5FkzXO6szKFDh7nsw8I5 zK/5NDOTtUWOtBw53LA9z7GG40wxnsnCN/JYa8hwuUywjc8oW5YwNjbWFMJijk1KiIk16YbphoWJ n9PSGB86TBspsI/RMQkm7bAQj++iyFfym7QUCvzPT5D+/ISW7J8fMC0JL5AYfkKrGuRfE4ffKUry q5EpSvLDuwRgWsL/UnwB//evk0btXf4YR0AkCK2Rofm7CGL7Q5r+JA8CYP5/QE3clphzf5IvP5DL 47XxuF+es4tq7hTz15Zo7UfktWH/t/j/f///7////f+/f9w/0TfdfkoQAtnnYBaMl89tJzBv9uYp 0dPx7xeT7wt6WNtwL/se+X5Fne9bku9bC7Pwe/6Xc/oR5hrbCPuQK/joeZZegPAD4rtuGezHPfAv iPc+P8sfvPRvIjbD/a2E9ojdgxcHcI/b6zdR/pq4AXCVvHzx2y3gWubBVyO/xYMXdop8uQevQb7M LOclLBgGoL6CEE86jBIVfosKHzlGmQ8g8RMJH0j4HoQPInyMQPixynwwib+A8mOV+UEk/sOUH6vM a0h8B+XHKvORJP5xWj5jlXk9if8dkaMfq8zHk/gvtyD8WGXeSOIfIHKMY5X5NBL/KyInbawyn07i dyZ65RD+R8I7CH8N4YsIP43wSwifT/K5ZKwyX0riX0TyuYbwu0n8csKHkHR3UbsifAXhTxF+H+G3 EPl60i7eJ/HjCf8Y4Y2EDyV8cLwyn0biDyf8oHhlPjBBmT+twgcmKvOVKnw6yU8c4TXxynxQgjIv jFOJn6jMH1bhc0h+2hB7iIxX5oMTlPmAcSrxE5X5ahXeQfJzPfUD8cr8oARlPnCcSvxEZf60Cl9E 8mOvpYX4eGW+mMSPIrwxXplfSOK3oP4kXpnXJyjzg8Yp84FJynwJSXcMyU96vDJfStsR+y8I+UoP 3ohpHPbg12D8ooki3xp56W8Nib+OyK/w4IPxnn0evCS/jPB8xCHJ2eLBL0S+nPCLSLq7PPgSKaPE rz5EyqdEhQ+IV+aN41TiEzlGas+E7039CeHTiJwcFd6hwhep8JEJyny8Ch88TpnXqPCRicp8QJIy H6TCl5L855LyWUN4HS1PUi9XEDsMIvwfRH4x4QcQOdUqvDFRmS9X4UtIu6D8QiJ/CfUPicp8CYmf Rcchicr8aRI/m/bvicq8QOpdQ/v9RGU+gMTPoeWmwgckKvP7VHgNkXOCZDNonDKvSVTmhSRlPp3I f5Lw+1T4alKPlM8h8a8ivIPw6bTfofHpuILwm0g9Hib87bS/IOUwU6idrzlU+BIVPp7wx0j+0wi/ hPCHSTlQPp3EjyXy05KU+RzqJ2n5EN5O+GI6LiLpLiF8DIlfSvhKOj5R4dcQvShfRuLfSPKvSVLm HSr8FiKnPZG/i/DXEH4f4S+h84IkZV5D8k/500TOn0S+QNrL44QPJvJfJ/3mIA9e6mcjCV9E5MQT /nqS7C6zMp9O4veh9kD4q4n8hYT/jMon/FeELyPlQ/lys3L8CiLnKpJuJJFD+X0k/jkip5LwD9F2 PaFWDl1Frya8nfpzwrcl8QWSH38SP4DaA4keSPjOhA8ifBfCBxM+iPCDCH+Sjudpf0fixxNeQ3gj 4bWETyO8jvDphL+a8DmEt9J5N+H1JH4x4ccSfiHhkwi/hPDPUT9DeDOJv4XwcwhfTvj5hN9F+NsJ X0H4+wi/j/D3E76S8I/Q/BA7f4zwQUaRv4iFn6gfIPxcwg8iPHUnGsLTYUUk4XdROyH8aro+QPi+ JAEj4VvW0kIa4VsRPp3wq+i8mPC3Uzsh/F3U/xD+XtofEf44SXch4Uvp+I3wNxJ+CeG3Ubsi/ON0 3Ev41iTdMsJ/QvgthH+GjlcJH0bHh4RfQPJZQfiLiPx9hP+VjmcIv5OuVxD+OzpuJLyR+j3Cb6QG N6mWDyB0AOG/Jnwg4TPpvIDwM6j9E/5Zav+EP0TkawjfhvCRhD9Cx2+En0Ltn/DtiBwj4WfRdTDC v07ipxP+YsLnEP5Fav+E703yWUTLmdo/4TfTeQ3hu9J5EOF3kvwsIXx7wpcS/ltq/4RfTMdphE+i 6/aE70DklxM+kPC7CP8RtX/C03X7fYSPpPZP+LW03yf8RGr/hL+Cjt8I/yq1/+Ra/hidZxG+I4ke SPin6Loi4bdT+yd8JyJnEOEvJbyG8G8SPpLwLxFeT3g6Dokn/LeENxJ+OrV/wq+m82LCdyVycggf TeI7CP8hiV9E+G6ELyb813RcSvjx1P4J353IWUL4NdT/E74Hib+G8DeT+GWEn03tn/ALST7LCd+T yN9F+F6EryB8b8LvI/xIav+Er6D2T/jLiJxqwj9M/T/h+9KBRUotP4jaP+H7kOiBhC+m/p/wwSR+ MOHfpP6f8H1JfA3hP6bzBcLT9T094fsROfGE30DHP4TfRO2f8P2JnHTClxE+h/BV1P8TfiCJX0T4 jtT/Ez6C+n/C30LHP4S/nMhfQvgEEr+U8K/QeTrhfyNyygjfi9o/4R+h9k/4LDr+IfwVRH4FtTfC 7yP8a4SvJPxgwh8mfCz1/7Qeqf3TcqD2n0rGn9T+CT+ERA8kPN1XDSL8fXTfjfBPUfsn/K9Ejobw 2+n+L80PtX/CDyVy4gm/nto/4dvS9VLCX0nkpBOeTlRyCJ9M7Z/wb9LxP+GHEfnFhL+M+n/CDyfx Swi/lfBLCO9P/T/hL6LjH8KX0PEP4b+m9k/43XT8T+uFrkcRPo2uAxO+D133ILyJ8JWEf4uO/wnf i67L0fKk4x9abnT8M5mMK6j9E34q3Rcg/K/U/xM+hIgPJvxAus9I+C+JHA3hR1P7J/xzdPxPeLrO H0/4B+i+A+F3U/snfCQd/xC+HbV/wl9Hxz+ED62lhSLC0/MPxYQPI/EXEr6Ijn8I/yCd/xI+nMgp Jfwpwq8hfAThywj/M+G3EP436v9puZH4uwj/Gh3/E/4YtX/Cv0HkVBKe7vcdJnxHav+EH0HknKb2 Rv3/lFo+ito/4bcQ+YGEv4aICSL8b9T/E/4s9f+EP0Xtn/BniPxIwv9M/T/hR5L48YQfRXgj4bvQ 8Q/hR9D9U8LPovZP+OXU/gk/ic5/CX8LHf8Q/hM6/iH8aJL/EsI/Q+2f8NdR/0/4fDr+Ibwf9f+E f5j6f8LrSX7KqZ3Q8Q/ho0n8CsIfp/ZP+J9I/ErCF9DxP+En0PEPLX/q/wl/mMgXptby71H7J3wg 9f+En0znv4T/nogPJnwJ9f+Ej6P2T/jPqP8n/J9Evp7w7en6D+HP0fEP4XtQ/0/4EdT/E/4muv5J eAO1f8J3pfZP+Fep/RN+PbV/wk+n43/Ch1H7J7wftX/Cj6f2T/iPa2mhjPAbCb+F8E46/iH8Mjr+ IfzldPxDeDdd/6Hy6fiHljPJz2HCj6L2T/ihdPxP+Aep/0+r5XV034fwk6n/J/yH1P4Jv4Ou/xA+ niQ7iPAmuv9I+AQSP5Lw4wivJ3wi4eMJ/ym1f8LvI/HTCD+Q2j/hW1P/T/iW1P4JP57ILyJ8KrV/ wlfT8T/hO1H7J3w7up9L+Akk3VLCf0Ptn/B3Uv9PeC31/4SfSOSXE/5q6v8JbyTxKwg/ifD7CL+V rv/QcqbjH8InEznVhE8h/Gla/oQXrq3lb6X2T/gW1P8TfgAd/xN+BbV/wj9Kxz+En0yyoyH8MLr+ Q/gpJL6e8J/T8T9Nl47/Cb+NyEkj/JN0/EP4pdT+CZ9C7Z/wK6n/J7yLjv8JX0Xtn/BD6fif8FNJ /pcQnp6TKSX8UTr/JfwHdP2T8MkkP1sIX0HSLaflRv0/4RdR/0/4F4icfYTfR/0/4UPo+IfwFur/ Cb+ZyD9N+CXU/0+r5Z+m4x/CX0uiBxK+J7V/wv9Cx/+En0bkDCL8i4TXEP4Sav+En07i6wkfQO2f 8PS5CSPhn6fjf8LfRf0/4TvQ8Q/hZ5D8OAh/HeGLCJ9H/T/hJ1D7J7yJyCkh/A+EX0L4qXT9k/B7 qP8n/OvU/gmfTuRvIfwoOv8lfAaJv4vw7xO+gvD76fif8G+R+JWEzyT8YcKPpvNfwr9N4p8mfH9q /9NJv0b9P+GzSPRAwtPnRIIIbyHxgwl/hI7/CX8pHf8T/gMiJ5Lwnej8l/DZJH484d+g9k/42XT8 T/hCav+EP0vk5xD+IOEdhL+Rrn8Svhv1/4R/gto/4Q9Q/0/4PDr+Jzw9n1ZK+BySzzWEP03HP4S3 kvhbCL+D8OWE/5b6f8KfoP6f8PdR+yd8LpFfSfgY6v8JP4vEr6blQ/jThA+m9j+jlv+L0AGE/4Lw gYTfR8f/hL+N+n/C51P7J/yndPxPeBtJN5LwY6j9E34K9f9UDrV/ws8m8tMI7yR8OuHfouMfwm8n 8R2Ev4PaP+FdJH4x4d2EX0j4cjr+J3wBib+E8EnU/gl/kPp/wmup/RO+kMjfQvibqP8n/HfU/gkf RNc/Cf85nf8SvhUd/xB+OR3/E74NHf8Q/mI6/yX8j0Qv4bpavojQAYSfS/hAwu+l/p/wZXT8T/h5 RM4gwhdS+yf8DSR+JOEvpvZP+C+o/RM+hdo/4TcR+WmEd9DxP+Hvp/ZP+JuIHAfhvyR8EeFXUf9P eHqOfSHh76b2T3gXnf8S/maSbinhbyH8GsK/Te2f8Gl0/E/4YiKnnPC3En4X4aup/yd8d2r/hH+C zn8Jfxv1/4R/h6RbTfgHqP0T3kD9//W1/EeEDiD8bYQPJPz31P4JP4z6f8LPpPNfws+h4x/C30HS jST8nYTXE/4Dav+Ef5+u/xD+Zjr+IXwxtX/C6+n4n/ALa2nBQfi7CF9E+EWELya8m45/CH83iV9C +F8Iv4Tw9xC+lPCvEn4N4e8lfBmtL7r+Q+NT/0/4kdT/E/5D6v8JX1JLC/sI/wDhKwn/GLV/wldQ /0/4xUTOacKfofu/plr+P4QOIHw4Xf8hfA61f8IvpvZP+AeJ/EGE30N4DeFfoPNfwi+k/p/wK+n6 P+F/pPZP+FBq/4R/iY7/Cd+N2j/hHyX5dxB+Lx3/EL4Vnf8S/ivq/wl/PfX/hE+n43/Cn6TjH8KX 0vUfwh8l+S8jPH2ufwvh29L1f8IvJfF3ET6R2j/hE6j/J3wQ9f+EX0bkHyb874SvJvyL1P8Tfiy1 //Ra/nFCBxB+I7V/wt9D7Z/w2+j4h/Dx1P8Tfj9JV0P4SsJHEn454fWEf4Lw8YS/nNo/4d+h6z+E LyVy0gn/MbV/wpfT8z+En0Ptn/DR1P4Jv4Kku5DwH9H5L+HXUPsnfDa1f8I/ReSvIfzThC8j/ErC byH8KsKXE76a8LsIn0vtn/CrSfx9hN9Jx/+EX0vH/7QciJxqwn9D938J/zu1fzMpf7r+SfhYuv9F +LVETBDh51P7J/wuav+Ep8/baghvo/6f8DOo/yd8OclPPOHNdPxP+MPU/xN+HZGTTvj1hM8h/NvU /gm/ma7/E/4ZIqeY8N3p+Ifwy6j9E/5ZImcJ4R+h6/+EH0znv4R/mfabtx0NiL/b/6f1/YT4BeVu /8OuVqygRg1k/3X382NfvxkAyz/nwrY/0084N/BN9v8lffTsE8ewwlRVeY79DdzKMU+xqgLwBo55 SlXlgNdxzB9BqioDvILjVhyXAl7KMX+kr6oE8GKO+aM6VcWAF3HMs1/lADyfY/4IS1U64Hkc80dI qoyAnRzzR/6q9IBzOeaPhlRpAGdwzB/xqAoGPI1j/ihFVSDgZI75ow9VAuBxHPNHAquq/+I4huNA 0B/wCI47gv6AdRx3Av0BD+H4UtAfcD+OO4P+gHtw3AX0B9yJ466gP+C2HHcD/QH7cRwE+gM+w6ow pzvoD/gExz1Af8BHOO4J+gM+xHEv0B/wfo57g/6A93B8GegPeDfHfUD/sxxv5zgY9Ae8leO+oD/g DRz3A/0Br+O4P+gPeAXHA0B/wEs5Hgj6A17M8eWgP+BFHF8B+gOez/Eg0B/wPI4Hg/6AnRwPAf0B 53I8FPQHnMHxlaA/4GkcXwX6A07meBjoD3gcx8NB/z+h/jnWgP6AR3CsBf0B6zjWgf6Ah3AcAvoD 7sdxKOgPuAfHYaA/4E4ch4P+gNtyHAH6A/bjOBL0B3xmHcNRoD/gExyPAP0BH+H4atAf8CGOrwH9 Ae/neCToD3gPx6NAf8C7OR4N+v8B9c+xHvQHvJXjaNAf8AaOY0B/wOs4jgX9Aa/gOA70B7yUYwPo D3gxx2NAf8CLOB4L+gOez3E86A94HscJoD9gJ8fjQH/AuRwngv6AMzhOAv0BT+N4POgPOJnjCaA/ 4HEcTwT9z0D9c2wE/QGP4HgS6A9Yx3Ey6A94CMcpoD/gfhyngv6Ae3A8GfQH3InjKaA/4LYcTwX9 AftxnAb6Az6zluFrQX/AJzieBvoDPsLxdNAf8CGOZ4D+gPdzfB3oD3gPx9eD/oB3c2wC/X+H+uc4 HfQHvJVjM+gPeAPHGaA/4HUcZ4L+gFdwnAX6A17KsQX0B7yY42zQH/AijmeC/oDnc5wD+gOex7EV 9Afs5DgX9Aecy/Es0B9wBsd5oD/gaRzng/6Akzm2gf6Ax3FsB/1PQ/1z7AD9AY/geDboD1jHsRP0 BzyEYxfoD7gfx27QH3APjgtAf8CdOC4E/QG35XgO6A/Yj+Mi0B/wmTUMzwX9AZ/geB7oD/gIxzeA /oAPcXwj6A94P8c3gf6A93B8M+gPeDfHt4D+v0H9c1wM+gPeyvGtoD/gDRzPB/0Br+P4NtAf8AqO bwf9AS/leAHoD3gxx3eA/oAXcXwn6A94PscLQX/A8zi+C/QH7OR4EegPOJfju0F/wBkc3wP6A57G 8b2gP+Bkju8D/QGP4/h+0P8U1D/HJaA/4BEcPwD6A9ZxvBj0BzyE4/+A/oD7cfwg6A+4B8cPgf6A O3H8MOgPuC3Hj4D+gP04XgL6Az6zmuFHQX/AJzheCvoDPsLxY6A/4EMcLwP9Ae/n+HHQH/AejpeD /oB3c/wE6P8r1D/HpaA/4K0cPwn6A97A8QrQH/A6jp8C/QGv4Php0B/wUo5Xgv6AF3O8CvQHvIjj 1aA/4PkcrwH9Ac/jeC3oD9jJ8TrQH3Aux+tBf8AZHD8D+gOexvGzoD/gZI6fA/0Bj+P4edD/F6h/ jstAf8AjOH4B9Aes43gD6A94CMcbQX/A/Th+EfQH3IPjTaA/4E4cbwb9Abfl+CXQH7Afx1tAf8Bn VjH8MugP+ATHW0F/wEc4fgX0B3yI41dBf8D7OX4N9Ae8h+PXQX/Auzl+A/Q/CfXPcTnoD3grx9tA f8AbON4O+gNex/EO0B/wCo7fBP0BL+X4LdAf8GKO3wb9AS/ieCfoD3g+x7tAf8DzOH4H9Afs5Hg3 6A84l+N3QX/AGRy/B/oDnsbx+6A/4GSOPwD9AY/j+EPQ/wTUP8cVoD/gERx/BPoD1nG8B/QHPITj vaA/4H4cfwz6A+7B8SegP+BOHH8K+gNuy/FnoD9gP473gf6Az6xk+HPQH/AJjveD/oCPcPwF6A/4 EMdfgv6A93N8APQHvIfjr0B/wLs5Pgj6/wz1z3El6A94K8dfg/6AN3B8CPQHvI7jb0B/wCs4/hb0 B7yU4+9Af8CLOf4e9Ae8iOMfQH/A8zk+DPoDnsdxFegP2MnxEdAfcC7HP4L+gDM4Pgr6A57G8U+g P+Bkjo+B/oDHcXwc9K+G+ue4GvQHPILjn0F/wDqOT4D+gIdwfBL0B9yP419Af8A9OP4V9AfcieNT oD/gthz/BvoD9uP4NOgP+MzTDP8O+gM+wfEZ0B/wEY7/AP0BH+L4T9Af8H6Oz4L+gPdw/BfoD3g3 x+dA/+NQ/xzzRwSrKgFv5Zi/UrGqAvAGjvmjFlXlgNdxzI8OV5UBXsEx3/quKgW8lGP+Kp6qEsCL OeZHkKuKAS/imL+itcoBeD7H/AhcVTrgeRzzV2dWGQE7OeaPPFbpAedyzB/pqtIAzuCYb5lXBQOe xjF/xVRVIOBkjjtwLAAexzE/oldVfQzqn+NA0B/wCI47gv6AdRx3Av0BD+H4UtAfcD+OO4P+gHtw 3AX0B9yJ466gP+C2HHcD/QH7cRwE+gM+8xTD3UF/wCc47gH6Az7CcU/QH/AhjnuB/oD3c9wb9Ae8 h+PLQH/AuznuA/r/BPXPcTDoD3grx31Bf8AbOO4H+gNex3F/0B/wCo4HgP6Al3I8EPQHvJjjy0F/ wIs4vgL0Bzyf40GgP+B5HA8G/QE7OR4C+gPO5Xgo6A84g+MrQX/A0zi+CvQHnMzxMNAf8DiOh4P+ R6H+OdaA/oBHcKwF/QHrONaB/oCHcBwC+gPux3Eo6A+4B8dhoD/gThyHg/6A23IcAfoD9uM4EvQH fGYFw1GgP+ATHI8A/QEf4fhq0B/wIY6vAf0B7+d4JOgPeA/Ho0B/wLs5Hg36/wj1z7Ee9Ae8leNo 0B/wBo5jQH/A6ziOBf0Br+A4DvQHvJRjA+gPeDHHY0B/wIs4Hgv6A57PcTzoD3gexwmgP2Anx+NA f8C5HCeC/oAzOE4C/QFP43g86A84meMJoD/gcRxPBP2PQP1zbAT9AY/geBLoD1jHcTLoD3gIxymg P+B+HKeC/oB7cDwZ9AfcieMpoD/gthxPBf0B+3GcBvoDPvMkw9eC/oBPcDwN9Ad8hOPpoD/gQxzP AP0B7+f4OtAf8B6Orwf9Ae/m2AT6V0H9c5wO+gPeyrEZ9Ae8geMM0B/wOo4zQX/AKzjOAv3/j70v gW+i6vpOKKVhM2VRq4K0WLVF1JZFWxBppJUJtlIVHhFEEBVRURESQAFpSSMdQqBsgqiAolJBlEWx 7CmULqylQCl7QZYJYSmLtFBpvnvOncnMJJOliL7f837f83tf6Zm7nXPvPf/zP3eWoDwX5LfQfpSn gzwY7Ud5Eshvo/0oTwB5CNqP8icgv4P2ozwc5HfRfpTfBfk9tB/lQSAPRftR7gvy+2g/yi+C/AHa j3IPkD9E+zlcf5CHof0odwL5I7Qf5XYgD0f7UW4D8gi0H+XWIBvQfpTvBdmI9qPcFOSRaD/KDUAe hfajXAfk0Wg/yjcWEPljtB/lyyB/gvajfBbkMWg/yidAHov2o3wQ5HFoP8olIH+K9qO8FeTxaP8Z XH+Q09B+lNeAnI72o7wC5AloP8qLQTah/Sh/C3IG2o/yXJDNaD/K00H+DO1HeRLIE9F+lCeAnIn2 o/wJyCzaj/JwkCeh/Si/C7IF7Ud5EMiT0X6U+4JsRftRfhHkKWg/yj1Anor2n8b1BzkL7Ue5E8jT 0H6U24E8He1HuQ3IM9B+lFuDPBPtR/lekGeh/Sg3BflztB/lBiDPRvtRrgPyHLQf5RvzifwF2o/y ZZDnov0onwX5S7Qf5RMgf4X2o3wQ5K/RfpRLQJ6H9qO8FeT5aP8pXH+QF6D9KK8B+Ru0H+UVIH+L 9qO8GOSFaD/K34L8HdqP8lyQv0f7UZ4O8g9oP8qTQF6E9qM8AeRstB/lT0D+Ee1HeTjIi9F+lN8F eQnaj/IgkH9C+1HuC/JStB/lF0H+Ge1HuQfIv6D9J3H9QV6G9qPcCeTlaD/K7UBegfaj3AbklWg/ yq1B/hXtR/lekH9D+1FuCvIqtB/lBiD/jvajXAfkHLQf5RvziLwa7Uf5Mshr0H6Uz4K8Fu1H+QTI 69B+lA+CvB7tR7kE5A1oP8pbQd6I9v+B6w+yDe1HeQ3IuWg/yitA3oT2o7wY5M1oP8rfgpyH9qM8 F+QtaD/K00HOR/tRngRyAdqP8gSQC9F+lD8BuQjtR3k4yFvRfpTfBXkb2o/yIJC3o/0o9wV5B9qP 8osg70T7Ue4B8i60/wSuP8jFaD/KnUDejfaj3A7kErQf5TYg70H7UW4N8l60H+V7Qd6H9qPcFORS tB/lBiDvR/tRrgNyGdqP8o2viXwA7Uf5MsgH0X6Uz4J8CO1H+QTIh9F+lA+CfATtR7kE5KNoP8pb QT6G9h/H9Qe5HO1HeQ3Ix9F+lFeAfALtR3kxyH+g/Sh/C/JJtB/luSCfQvtRng7yabQf5Ukgn0H7 UZ4AMof2o/wJyHa0H+XhIJ9F+1F+F2QH2o/yIJDPof0o9wX5PNqP8osgX0D7Ue4B8kW0vxzXH+QK tB/lTiBfQvtRbgfyZbQf5TYgX0H7UW4N8lW0H+V7Qf4T7Ue5KcjX0H6UG4BcifajXAfkKrQf5Rtf Efk62o/yZZBvoP0onwW5Gu1H+QTIf6H9KB8E+Sbaj3IJyDVoP8pbQXai/cdw/UGGb5bay1FeAzK8 OmovRnkFyPBqut2G8mKQ4ZVW+zKUvwUZHo2zL0B5LsjwKR97FsrTQa4HchrKk0CGT/rYh6E8AWT4 tKJ9IMqfgAyPxttTUR4OMjy6Zk9A+V2Q4RViewzKg0CGR8vt4Sj3BRk+KWAPRflFkOEVOLsK5R4g wyei7RVHcf1BDkX7Ue4EchO0H+V2IDdF+1FuA3IztB/l1iA3R/tRvhfkO9F+lJuCfBfaj3IDkO9G +1GuA3IY2o/yjS+JfA/aj/JlkO9F+1E+C/J9aD/KJ0BugfajfBDklmg/yiUg34/2o7wV5FZo/xFc f5DD0X6U14AcgfajvALk1mg/yotBfgDtR/lbkCPRfpTngvwg2o/ydJAfQvtRngTyw2g/yhNAjkL7 Uf4E5Gi0H+XhILdB+1F+F+RH0H6UB4HcFu1HuS/Ij6L9KL8I8mNoP8o9QH4c7T+M6w9yDNqPcieQ Y9F+lNuB3A7tJ/JLjLVlH3KFYY9xEA8YS5fVmUS03tkUrx7tZ3+H0IzB2lZwS0yl6s2wpxjTuVDG 2uVBUoGbTNuYsU1HbGO9c/9cUtKONGOT/mJMeaH9N8vac78TPfpv1rZKVKlg/PK5dPwE2lc8HX/6 XH58+0nJ+FD/V75+KK1fn9YfJNRfLa1P9HwHCqzB8E9vJroKDai6Y+SdjCW4dCJ9vKh+f2f5YNSH qAr/e0zSPhrbd2xN29dA+9yaIIatYHK5row6n9ldYwgjnU3jO2tEO6Pt3ftL63Lgi9YqlXE4Y+ry IWmAE6Lr9ZKhEbFkPiniPiFZTbL1wbVjYdSW6+AfS/BSUpIc/QeTWx3EmBxqJr5sRDjqy5hsaoYN tpJynbN5Hqk6gfxJyoef4uD5oH66V/vnB79FrqmvkBkHez6CLk1dVcaG9vudOFXQjyWY/YzqbweV nMX98fki3cu6/+h6EwXJoscwbHWyZUl5EAy7FkJsXe1kuNNnmVFBr0HYC9LOt6WtxW8oaGflhudq V+Uypgp1ZQkTsYlhZ4TWVakGF5jC4AkrlWXlXmhI1vLNg2Qt+U7HdrfMiKkbaIeptMM+fIdlfIfN SIf6dU78n1ql30j/AkNNQE4YK6Nmcu1dGWuyRq3fUEOLtckRl5jKA4w1UaO2WBJIl0EW+Aw1k1te l2EnBw3DsTKCRuNgpCvQl+ymBmM/ZCwWDoXrDSbNAGXH1ssoMQ6KLdGZ/lSTq/W183MzSrSzNoVv 1a7aarqkTjTbDd0EbdhcqkwjNWgQXYgDWmfigJaVh3mbelbDhhcGDdJOnoVaWMpBRXZrcsQNMh82 Oh+FVMUgiy1YpUqOOB57jelsWUYuaj/fpF1Vwmi7XcbvrzHaZ0sZy8oF0EXEZdK+mLYvo+3N1wzt GXOJ4X7GisMMtszIIR0OZl/QMJYZy4Jh4CaOUIalpQUmDtsNtlhAgcFscmQ4UdCGCiZHhhG1yZ4x 08mD+ZpkqeCtGR+SUUTW11Evo8g4LLaILH5WXVxyVBfMnW8LL9SuslUWm4sNzxOPfICwPsY6NpKA Ua9IDfcCcRzGaqBiGMzXRjvMVyJcGc0xnbsMyGit0prhbFKYRbNNmzmBahNDbNFHFCSza0OD6RYN pjNoojNYHlvCdDbBx/21n5M9WERmcPdqfga3krmowBncTWYinLaPou3J5D3FmIsMDzNWHINMDZ1B hsyghc6gxnFPsgXHhamk1QpMcbQDi4VuWB1x9E1M7lnYs03IljpeQzZKbAnqkNx5bQKpbagbW0TU 5HdrKg4zM6hPsMthVZ8+7nPLmdZhK5VBA/PnPAROmRdDQETXX/eabsBmAjdVBLkeNRHkMjRcDT5T oc3VOEIsGusLTjbUXKSdCo8NwjpEcQMIQNungchuhv6OXaN/SpZk+4TWKsNjfLelE7x2O74B7bIR YD7paibpCp737C0FKEbP7tWzTtYQ2SHF+gucgeotU/vgOhcZ4pJZjmG3DZbjcfyI8BENGUu/MMZ8 yHjZcQdjeS6U1GbYMmOJg0zCZkdQMuvQW3+BE93keIduAyhnCCbtRkYTnIjswLCJkQkk/pTsh92Y HJmQTK7GMexFEoy4lid549tG6i1tIwsSI/HjCOTfRuGwbCxsV0uXkekA9gayiSfDlJMeSUAhe1rH 7k4iqo+MdeojSg3Ps6Wm00GxzhS2Qh9dYeg0mNF+sGWwdpgtkUxmKFvK7jYdD2Kid0rtu6Id372C /CeEMRWEM6b8v4znk9kCfXyNIYIthWhmrVsli3dsFFkMDePcabxqGRFlIoGO6D2cqPNSHFF0RxqJ UIV/gltR9ch+DE9kn4uia8p2i2FfaqszXa8z6k7G2i2BXIi7ov0wMTKcqNAtwVEfqoXBVYZMAf7+ BPyhoZF2LLH/K8Lp9ZbZdNFKyJIZHrMkR3ZIZi8wbDGJX/EMrlcCWS8bXa9Usl4lDJtvPOqAoJwc zxnqQ5POpOZDsCAdAHlghWJKPVYonxtDNlR+QirxpzzGtc/7kxUr4MBhYHvB1iKm7IGQz94APWNW x+BclRKP5PRlJGBbDJExeku9ZMvoGMZyn3SdsWaOK/ywibjiGeOFFZ97gF9xorQGNmofdidZ5qRY W/wlQ3s9W0jWGlZ6M7/Sw0LZraYTxNRdTPT+LDKvz8L61iNrS9a3ANY3OtfQvIe1rg38g2HD6HoW Ga/ieMlspc65n07248dgIV8lc2E+ZHiVsT6nIU74wnh0whzeCdXECdXWVCfbxFSlNj7JWMjIx5xk 0q3PNSK1H/BVu75Qm+iQl9APEUTP5jsak/9QDZYeVdBg16e10eAbX7VFDYjd3IDLhO64tjrynlTu 3Qqnk9tyAuAkka43AZNUPXtVz9bgCm9NZnO5XgfRkZOtY8JJT8ns6WT2BtfqCtmsbB5AfBu99XlN ivnkMrXxDiZ+t6G+zhLS+Zlw7XSbdlUVIMEbZ0hd57NRjruJPmShorjlRyiUxZeS/cP+QSAHnmqH PQjzpG2VBkqS3Ud0Kd0ID1RyAy6hEmSfWVRst3DGOiaKe2QfXOObvob7ds5F2nE5KeK2lWIbbuF5 erEf9lHABQHdaSXBTzLMPj17jeBnivVtTUr8VYNOZ3lfpbM8Gx6/ZcQLesuAsOT4K9qMc4hbldzl /U5n/JBwrekPDFIM8cgivTYpP1mbeIkMaIcjbL1pfJTK8DJpG27pFq7rnKQa0SMp9podbk/EHorn tKbBCNIDwrHrv/iu959zOjtD1/AYg97yPHSdrE2qYLSJucnsFbJ77I9hu56A1eSK4RGdJUlF9/s2 y0tkZgiKW0eExRcz2mcuMZY7SDXjyfhiPXt0RAuigL7zgDBtxlkVpVVR+2EZ86GL2CJd/LPhJLQf SCYN7fAYD2ljt6lcoxk6yOKHnt2uI5gWrie4EqoH4hG/hYy5m7E0gDHL47eksKdHNIMx4w8bRiez Z7jVpThcrE0X/0F4srZbORmqgmwAR39Sy9HHZdUfhgcHZ4E93Xh7XpL3fTJ+C9jTnLeHUDRiy6vS zokdZdA5xLA/kgG9DgpbjIe5LMzn0s/FIMMcR3aqkdTqzTEWI/m7krGQSbemlDHsehWG8V0Ma666 CX/9VoH/WDn8ZxY8a8/tgj1m7ZhbBjg7rpyxzIJSLoc4uZ1SGdoYAIk9zlh7lzOERxboQhEr4T+q DfBmBHsJP4WjYytir+lYsn7r6WD5pEccaPAfQo9kGC6nDIYdV8bNPwVosh7HsIQwFitVWs1YXk4g MYOE/+bk7+4Mw+pSScJT9THB4OBi3AXp8MQAk56LyQ27i+t1UtQZewnGFIc4TiePEswQSAnc35SX hPIl9TzahPMlLTzaxPAlJX+4lyTwJZzdvSSVL5nn0WYgX/KrR5thdSkJNOWGk2Uswwk2F+PU0X/Y AnKhEKZ7lKRxIV1AEsNom/hCvpnWvNmJjWn3WfzADT1UWsCXXDrhXrKML7n7oHuJjS8Z59GmmC9Z 6FFSzpcUHfBYSr7kQ482qmBaMsujTShfUn3cYyn5kgiP3mL4ku4evSXwJUs9eksNli6LjS5LDl2W HNeywKsq3DJJ42Xisthcy5LjuSzDSPexRexO4i82UiMb+okrdfVjtBH/wYtvnHfXLI3X+Z0z7iVZ wfxHmLDfHNIvvDqD8UfoN4f0ixcbevS7IBj9eBnD/94NAQ/WPAfqHjsidrCMdIAX25R5bBvRpmzS FF7T4b6TNM0mTfHixf0e+0qm+QLSOhPxRdJ6AWmNF5e7t7aQBE7PMepCApFpFBvTKCiOhvq5mI92 7FCMaJhJsAsvL3ZtBuv6PmRp4FaWivt1p4hoWQQZMxmrFUoJDWQsv0G33O6Dkircwv3QO/bAvb0P ATCT+3kP/pHGzSpHJKRqhiD2qQsYqzkO9gK7fphrIw2Bnu+mmj6zCzRdn4D7ZRaW3CwTlQ11KRsi KruegdrWWdjIag11qQxDcPcflFfkzpei1lCNW74X/4aW3J8l+Deoxx04JupuNauoxgNdGveBjt86 gxqH7ESNNVRjLHlO1Pg3uE4S5GBcM+wC8wvW3OumfCktVrjCZuJpFO2PG0RVgvG5Z4+JLmQhedB4 Mp1VpLAc48t6hnopvM/FbTuNmt1LNeOwxSxGvn+s63NqhLlcu128WoEmz8JGVivUoXOJHZeUySty 3+CqY1fcW7jwOBz34278G3TjrEelc5lN1Y1zzSW8ccbdQzVuVoQaL6MaY4mzVJxLuI4HRsJ0Qi9c yjGYzrYe09kWp7OMTic05ZpRrUAFrvKIOJ3W9XOoVuF0EsOg289OoUoTClGlBVQlqMANlagE12NL iCrY5nIZqNLcQ5XmqMphqgo04TKLXeNyQ0VVBluy5uCJSdYciA+WnCwEvJwsPPYSyrJlZQtoWTYt y6FlC2gZRjPpbhlNDdVQQ+HtPe7rk2joK9vR0DRqKFTgTPvE5YYXJzdAHslZt4pXM+luSaO7Bero 8AvxZMNg39+Uyutyw+gmgZpcB7oc0JgbvQv/BvW4Vw+7Nsxgy0Rq88QqtGQqtXlqBdo8kdo8UROM ZdTmqRg/LVqKi7uIWjHU5qq/ePZohZcUuR/+oICzDc2Oo2ZjyeS9otIal9mfF4lXE6jZcdRsjctJ YAhu6T55RW4s9WKoxiXQdYeWXMZO/BvU44bAmUt6HnDg/pvZ3QybVMymbLc35fml6wrXcydPNJ8g Lezw87Ri7btlEry/KUp3imgvdrZiFw/a13fwoF0OaAl38sWWjyv1Eyrr591dIoz+vEOE0enQW7pa ob1G1v6THSLOvQZtUvxrAJgj9sDtFMGn7Q4RfEKhN6dS+2Wy9lXbRWg4DNFxm1KbBbI2edtFH86G NrNVfrVOlfXQbqfoASO3ix7QF3rT++9NI+vt5A5xb0VtF/dWowOSyGGl2U+uBtF3J9ezCK6OK+by jwv3Yfh8LFyaj1ngX/J/10l+Uox+hoNTxgE9c6chFFh6k1wtqRz7nkWTNHMF8rty9LY26G3jOHA1 uByxW/AVtpwwGJIdMZqCBJqLqSiEBvcfCveKbJo1mJbtXkPTsuLYEjj6s/BqQFpWhfmf6H3jOC5i G+7rck4D+ZmlCwt9ETtMtjBJakYuBKfieXQ6tY3I2agUydHSC2h2ttotO1tV6kbFXNnZVx4lQna2 4rC37GyIRxshO/vUo42QnXXwaCNkZz082gjZmcqjjZCd3eXRRp6d0STbXE7TgHJX/IYMjDtwSGxc JqYBnCsNKPeenb2/z31gITt7yaNEyM4+3u5eImRnx/a6lwjZWbBHb0J29ohHb0J2ttujNyE7q9zm LTvr79FGyM5MHiVCdvajR29Cdqb1aCPPzmiaTFNiPjPGZYEMjGsqaWwTl6XYtSyFPrMzIX/j5haK uUgh8Tm8uOWYt+xsm0euKc/ObEL2+IykX8j68OL7Hv3y2VmOLDvDDFFXLE/v8OLkrR7bRrRpmZAZ 1pM0XSZkhi94NJVnZ9lCWli4S57b4cVm7q2l2Vkmxcosmp1hNvfAIQTFzzepacplmYWXG0no+EBX wnNXrghsc0h2RjI060BXqoO5Zfsdkipc8FYMAVCHKypAHMziQvP5iF9Z4lTMzhJorpPm2kiYMH58 EDX9Llftyrf4VHLANlHZMJey79gkzJFmZzRJs4bJE8q07fKKNB7RrrhmqDXN2l7eIlKMzhLdrWaN Yj5ZcAA1fsemFuiKkE8uFfnrb6Gy7AzzxZoS4PBvenD4N6XZGSaPeXmU18Hf2buditkZR7lnH+ql 8PUN7lGq2ViqWQUlnn3k+8e63ubKzlpuFK9WUeJJkzSrzUU8seMO2+QVuaBCVBCqcQV0/jBra5gn kqWLxdK5XCZNJguEfHIMHm52NK5VC8SLaIwlr4uk+Lcc9+wMM85fdsN0PuUxnU9JszPMH42bUSvM 1F4pdkqyswVUqxg6iVHQLYdHDx1PrkGVsiUJ485CUaVsITvDNr22gSqRHqpESrMzZIBnN7nG5Xbu cv5r2VkaNTSMGhoq5L/E0LUb1K58yzILk81TBZJDHFeacnGdeDWL7haapFn7SLMz7DuoSF6XK6Gb BGpyn9PlwKztYK7IUzfsdN7W7CxOmpFCdoaJo4aa/d16tSvfsszCkgv5kuMgl9lVayWnPNRsmqRZ Q11OgjmttlBekTtKnQGqcd/Sdces7bRNZNNbgVmn54WL2VkZm7JXyM441xVuuY3nm3N2SLMzrH23 THJlZyjdKaK92FnzTTxo97PxoP3MDml2hi0fV+onTNbP9lwRRkNtIoxe3S7NzqTtQ2XtD28Ucc62 XZqdedfAViPtoUeuCD5TNorgM3y7NDuTts+Rte+7UYSGp7dLszNpm2xZm4c2ij7cYLs0O/OudR9Z DzNtogeUbRA9YN02aXbmvbdQWW/P2sS9NWmDuLc+gBTFEjxqAM1yXGnJLngyYPlaCTMr5unVuvVw cVwZ12wvvX8qPA8JyRokapYQZ+oQ+tAjPp9C87kEtZDP8XkcZjLW3nBnbSDG0P3E+/o4aaTCfzBo 8+cXHS+udt1Sw8tvbXZ5krEczjbhYkI+tqMsAo96Baylx75JJPWz0tKUisGQLlp+gyEHs/8hppPE kH0a/WfIeic95ui5FWcA9aEZlsVKGQXhXWwlHCBib9Yo/Oc3+GAZtxVPljr+maOmp/qWWXh55SZR Y6B80ISbsgU1DqMah0o0DqUaE15ppaUpNqIxIEmMqHEO1XgZt2odapzNfV3k0pgA/2gK/GEIkJnD cAkzQ2lQyKRlUbSMsudMzPtojueyNJNaSpmOlR5H/4YhvhzPkzo+nuOikHi5SCSLxixAa7D0uzy0 FMkDawYHFCylLCVpDhmRlqYsIJYuAMwULZ1DLc3itq/l4WhloYKlfWSWpsosHSKzdCAto0+iZXG0 jD6MllkuK4sLlpZh0kQTJGGGfhuCcwKTRM/DrWX4z2/wvTluLR5PdXz5dwwmwygXxJJvRJ76G72+ Hhpy7xTjVBXSqbLViDGD1sJLQI6pROslpZE/6RUr1UJNZjENnlPk5qxBjx+C/lSA0QT80fdZ3xtr eCfoAaHeopKeAPG1l4m1O67hN2ALqN1fqXaWWDtkDb+IGE8VT5eGyc7oSleLFqzJd9JDo2lkZrP+ Lr60wFOwjlN/k+NL8EYFfCnPvT34olnNT+3FLbeAL+/iSVvHWb/K8eWlDQr48lju7cGX/+Twy9tF qnGgOJGD54EdQ36V48Q36xVwYqzt9uDEd7/zW8ySJ9G4Fn4bRJWev9LDb+3rlP12+fbb7Lflq8Rd n7c5QL9dsorfXNM3B+C341bxC/vm5gD8tucqflKf2ByY394vsaDOZt5vD2zzfJ8iwcUf2CrL7/Sh +HHFQDjWLnU6I9XaVXAMXMwat3N9V5J+TFX1tV/lph0nBZcYSxLUZI2FXA0ZowOtbuldWP+yxbg9 otRUo9JmdMJNRCpaUooty/fyp6WP/cL7LQvOCv6bUgzPwkAASLQkVQxOZNNphISWNDyymSoaH6Lw Ae8sDZZDr2V8rxpRZehuF2vM475bQbXWab+y6dLK1Tos5hW3cUmi4omWFJuu/iWLMS8xYqeC7sIo w39G3QnC9SYIRf6lug/kdS8H3YeIutOj1swEqvsQqjuDbxnkJQBXk61HuLAe1ybuJuOpiVihzYin ilTkp8FF1GI7huEu63vjOyJlS9Qq7mNYIEvHOv9pjTU+yROwcVwFl0JP/Cu4k6C9KS/c/f0QGB8S VURz4fksqk8FazzHwYcxTVVkUpqjLuMqLOQifH2STfrLrpVce4les+AbOOH9hecJaX9dDvdsDY/W 22DGbUQH2fgwNGu8CuazxooKbe6TZGRL0jlSL8ut3EKKyHD4d9CT7JNkcqS9Dc5y58fcc7gRKD1O VHnwZ7/lX670Xb5tiWe560aKEepUEIwsSDqHyThrLDeNO6fWmuADssRENpexkO1UUBc+0AUXTDY1 m3TOvh8RKqkcThVNx8l20Mj6h4flxkH//M2ap/Of1ajyn62vkk7GbdeHf6hYDe5XzjxAtFJ7Ga+W +snWw6Y03wkka4p+UXx8zs0gi5Zh72AsPaMYy12M5UWCL43Ivz1jGPb5VIb9DO/msBVMMPySOhyn p+emUQLDwQxQrybeDJ5rsnF4GpZUyFUswUUohPyLia8CkNWaXSsTXKWmLvnjMuFKNn9l4o/CldH8 laQVwhWGv9JtjXBlAe/a037jr5hsqUhfTAVhREUbqGMhmPXND8KeMJKyfLipx1kLcLYS3PxNMp/9 1inN5zCX7TCQNamYvlnCwpE5Ga03+QcoUSn5k/yTtIDbiyaNW8CthfWxhJJZjiJVnSVAEXjKMG4O d34Jgk8WfyUpCyaShLAKSHDTxEMsEpZeRNhKIovXu4ooOKz/ZriMsczGpqzj2mH5OBt3zxbP+OWp f4xv/ZsL+ldv9KX/+k0+9C9eL9V/+grf+g9fwev/Sp67/q7cfSKH/EL0iSxp+aSJ8K4SD5ny9Y0B +1njSTCf02QLkamAG0ojbLGg81PfybSMkTtggrhfLB2/6dlaJdICEjPCcf8TN0vPp0Gwknt0qbib FPcbNhz1Mx91di4Sq8vWbyAmDgATvSvYlHPUkXtXJFvBinG2ZPTAnGQ2aRnXdxF2toyDV2HcVi5b WDkb3JrhLn4rLlAZd4n6ZQ5RYCAuTplIlPYt48nRuk3SR/Rd8cNNv0SMp1RHS8q5ZHxEGdTcRdVM Wca98S2vZt/1LjXBUZU1TZJp+nK2d007Z/OaNgVNsyT7HyGQ7X2OQFe5oBweJfUmeYRxGfcRHooh I6K3veB6Sjaby/3+DfaZzf28TtA1hsRwcolgITyVSFwoifzTm9D7TcmWpDk6Z7G48X+kiyrd8IVs Sh43jS5UITckF46qZOud6vGwN8YhADeSKBpzuDw8JYP8cT+9vZdCisCNtxJ9X/6en9unRX0ZYXLF aVT9goqluk8h9zM/hbtsHu9juMfH/M+Qf3nf36aCZdxsV8z34BtY/vAP3svJvrJ0ZYK6g/Lc80u8 +IeX+ju/91lfCInwIP0TTNCnsC0quHsWi43k9pK1UMKDWFtmrrQO0v5cyfmiu7/fvZz6Ox5GJvjG B6gS5XZe6cFPNsCLEKK+FJ9+7OGGT1k2Hp9M+akATlnZgqFu/NJd39nZPD49trB28/9adu3q12xU rM/bK+W3+Mq6lA9ZOka727tgntzeBYsCtPflZby9T39bO/3vX1a7+ht+91rf0jGdcbNHtdYVX+hx dyW34wdnAPHljGDPB9/41Q/88fdlvv110Xz38hgl/CcRNH0THBqQEJCI2Sv4B/DHUmTNJARzhxci lJfxsVbSnxtep1TBqRl01vscT5QBfMsQrVPKuBnLUSe3gK1S1k+um5JekXK93PdLuByfXb3xmpHF Be32Q3dc/BohlVS6HyHbD0//Usv9Ni+A9dRwT37lYz27qmjy3IgyOKJ+HPfZz0IDub3Y3QYnPZur 4JwV8AmJcxhRIPepUmvNz7m6gec7QiHk7EbZZGvEtyzg8rEhxzfksGFjSUPS6IUwGqhw4iA2FbAp J7nzBfKI5MnfH5FAjlK+tNZP+X05vsvfU8hfZfnYN0rl4n5xpWAhDFuPsXQns/Q03uRm6z4NOZfJ Fo75lJHjUmmCw9H3sQq4gT+5ziS878da9F/xq7z/rJ+99h/jOrwex/sHJlcg5HOFP7hOQQmrOLhI cERkFNTdyPVNi3gQis73zE/k+oMvmsZVqLQZzwibgqi3fIE4ZO8feJoOz7stEA5wKCpwmt95u8jo 9pVO0fuk/AVj63iyblWe+YR0PfG8UuG8grYPU2zvv/8Yub2VuB4L+Bkiepdzprk0SREmFrhJGdd/ vvhoFQIN996v0ukugLuphXkefFLCd0AvwnIecEGHpz+JWOP3/AFeW+e6f+mOL+HS8biCHygy0mfF tsKiXc0RDJE6+DmuUZ5ifuG5vzGfrQRWy81Z4dq34vxL+YLs/GmR9/X0bq8n3isAfdrXAfgnbU/+ 3c+Vf+G1vqhv5/mK+rrxHw//vLpIdJay76X+2ekbZf9s/Q3vn+ymW/NPXbY45Fvfi/75yhI3/8z5 7Tb6Z8Pv/jX/VH0h8c9uXyr55/oF7v65bamHf0Z55nue/hn09e3zzzN+/PPhOR7+uXeJsn8OtdXe P5mZbv4pt7eCWzTdF9/UcG8v9VrOHZrrMx5T/jPDe/sxPvbP38SD1K9qhwfFswLAg7UK5+8B4EHi XEm8nifFg0kzlPFg+AweDz7ecGt4oP5eEq/niXhgX+iGB5krbiMeOH781/AgVIoHV75TwoNx09zx 4L7FHngQtj4APFj54+3DgwKP8xg5HjzpiQcnv1bGg1fX1R4PuDl+8CDkJ994UOC9nKv+wjc/t8z8 x/w9YW4t4/+0APx9ifL9Mo/zD0l+aLKNhpQOlq3LbN7vTLZhID8qygn4vv4sl4wpwBGrn/MEzrLU z/wuVCr3wKO82SI4aJbI+MliZTxqvZjHI/vqW8Oj41PEIWctluQPc9zwaPT3txGPvvzhX8OjhAUS PJoxSQmP3p/rjkdjPvfAo8ycAPDopQW3D4+eXOgbj96e74FHv36jjEfbf689Hmlm+cGj7ot849Hb UxTOw/izGi1jGaWR3jXlomfiMhWTscvh+1Q/TnatCb0nNYRV8ABalMLyTnByFf99NUV84dfocavL MMX7aX7xjur/cigTvZXJvVGXYXfi3gqZLjpsOcd+Lowiddhy7qPPeV3jVgWwn9rP9r6fZPWTqpjO SRXajNZ0/Crui5n0UOn4RHTbKnyRi02qwt8T9nfeyy25Jf7nhrcaAW93TONtzpumZI639YJ7jQSv 4FEZ4ckRvG8NtyHxoG/fD56hQhl/x7C+z598xS/v8UgxfoVbAohf/TJrFb+4zpP/sfhsm1c7+xIm BWDftomB2Bcu2kA8Y5GZj0SmriRGPSo4UsUs3q3s8PPLUt8vhz3wEdmp9KE3/sLA7wT9cMvtXiE8 byqNt9fhYU8Ib9y0zzAilAueC1hYzm37jh809hp9wkzDWFI1TC5+wY5r+RkfCgsS+K8BJoTyqCtG jMPcf1bI3o+W3b96kgCIhsub79MfJOen03zvX34O+fj+sCu+8w9wNfoBjazA250wqQ2JBfadriAe UHx1lXd1K3bFh1Q3fQrhZkzqdIFIjCvk/oDNBg/nYnC2AelQCRnV2xQl8OK2b0UsLeSWzsMucoQY zeE7SewmUpjDDVwo3gQv51bQjUfv3paL71LMRRgkhKnJQnE/SPwrwzd/6/y993KRb3AdMgJYTym+ XzH7x3chns52de4Zv334d/GEAPz1uc99299wQe3xJ4ByRTzwdp7p77zkd4/58RaPjgh8oYMlQP9b opAfua/PmXTv+ZdjXu3nzwv+2jK8rKev+ZTuD3hWguwLDZmEbLXWDK9e2vE/SiG2XZbnaPLzZNda mfJjmPhK7UzPxzM98cHFx8AmfH6DC5tKgRgggFsLSSP/IAebDw+jcJmTke6Wo2bg+KNmS59+iZ8p cXzJYxsRPK/kwuZ74VuYHyvEYwX/zpvic78E5o+TA/DH+yb49sclCnj1d/xNsr8GesMLX/yk4STf +t73We34znuK/fnKHw645Q/xs93yh6p5XvOHI/N4PPhusSx/8Lx/YBKT5aop0vz8bLpyfl6Sznet X3yL9w9miUOap4j5ud7ilp8PybyN+fkhhfOifyg/D5eeF46YoJSf77C45+f9pnjk51x2APnUlZlK Dnxr+fmoWb7z8+4K54UTlfPzttm1z8+j/OXnlR76uZ3/e4+XXL9P/rF8QzXHK/4pn/+PCwAv35sR CL4onwf88tk/cx7wdob0PKBoovJ5wPKJPEBE/RDA/n0j3fv+9X0esHouPQ94feytnAdUj/5b5wHc e1P986dFo737U2DnAXeODvQ8QCmfDvR+9sTa7d/QMYGcB8wOZP/6PD+bLo9/H492i3+Zo73Gv/dH C/FvYQDnZxsz/xl/GfW51F/ijcr+EmHkda36NhB/mXir/hI/kfrLC5ZbOj/7m/5iGeffX0YZ/66/ fG8M1F8sabd+fja1dv5SPioAf3EoxyevfPK+6T7nk9s23k95unK5Jfh4S/wKgyTVDMGvwWWp8E0S 5Go3pzuF+0l98H2bCS45HO83mVxyGMhfjxV5XoRCyqGQ30L+m8l7xryRorIK8+06b8tUPG9Ls/o8 b4N8SnbeFurKy3Hw1+f7Pm9L/1jpvK1zpq/ztqXDAzpvOz3P33lbpGL4VMj3HYr5V8DnbV9luJ23 9TP/a+dtFRMl522mSR7nbbYx/Dbp/pl43rZ2hPS8LWWSj/O2mAnS87Y6ZuXztrMZ/HnbN1MVz9uM vv2t87CA8vFew2t53vaGUamBMr6GjLml87YKBVD1sO9Li2/7q82e5f/yeduQsX7yC0++JskfR93S ecCtnIct++j2nIcNsQZyHrbp03/rPEwzVnoe9pnHeVjhx27nYWK+Aedh0enK52FN0vnzMM1kX/yJ +tfeMYHi5Ye+11uJP3hbHyE+PfyxYnxKHeYzPjUxucUnlUkWn3Ln+I5PuxXjU7/3fMWnxkMDik/P zvEXnwzvBzjf/RTPxwKOT4ctbvHpy7H/WnwKN0jiU7PRHvFJNZ6PT2cyxfg0RhafjozyEZ9Sx0jj 0+UPlePTwQ/5+KRmleJTtZ/49IgCfin4T8a4ANZTGp9MYwOPTxM/uKX4lDYygPjUUJHvS/Kbj//H 49PoND/xaaJHfuTtflDL9/ktF/lRgP53yPf5PK7P/re9x8dHFOLjrca/d29P/NMMDyT+NR3xr8U/ oyT+OUZ4xL/Mse7xb5ws/n3iJf59IsQ/cwDxzxDgfqj2E/8OKd+v8Rn/3v5UMf6Fj/Id/8a4xz/X +RONf9N8x7/XxyvFv0Of+ox/bwUW/6b5jX+B5meHDErzHXD82/6OW/wb8+m/Fv+WjZfGv1Ee8S90 FA9GlW+K8e+QPP6N9BH/ij+Rxr9BUhooiX890oX4N0Ep/h1SOF+R8XdTQPHvzUG1jH9XapGfLfrI HV8Di3+fBBD/OivuL7H8uVu4P3Kb41/OW37i391p7vPjLf41/kCIf+8Gyj8V4t8txq+KN25P/KpK CyR+DVdgP/9M/GI+kMSvRzzjF/O2W/xaNFIav94ZoRy/XhjBxy/mU//xq/kHAa7nl+/4Of9U5iuy 9XHhYYjv/e+tXGm/Ez+X7vm9b3qunuz7D6T/gqSrOImkmWncVddHqa7iR6k48aNUV/GjVFfxo1T/ vz9+va1JeJZM4/6oUMvd+P497lS4BUI3AK2fw3/rCReMxc8PVHVOOkekMq0JXlunQSlpr72ein4V LGmvJWkviXwFSSepSic7J3FaUxT9G/UlozbaCsImuPHPsI1KiYCKn7RvJ4oTkkFcyjSu3GVnObYr E+0sx+rlgp3y/axo34U3lOxjavn9sf898/H0sP+H5iOL/v7uk4MLumtUKn5+XqJgVM0UBGGAYLSf 2uCLb2vot+u0KiZiE5PLdWVy7R3SjztDVKrMxEgN/GI3gcxekWH4M9Gx17g3MQYEDWZf0gBs9RPe H5L8snYECRgh4uB0Epk38pnVYpVchtXK9GMKQqCa6/4OwVRZPHsJyf1alFQV4+F+q/CD5QV1I2mM GRsZFnttzc/k76RYW1JsEXemHyx7r8hwxlxibM5YkiOj4Ad720xKJjVtsYccLzHpN+DT68amjGls ZBR8iZEERkOH2CJHB1o993gwk1PumqNCaEqShA7Cz7Co4hh1KRNxxaGhJeXtmfplzBq+MI2pvymj iNEmFsMvh2+C7KEfjTfu9mFKNMvmsp9ODv4qycsasqb53TVqQYL1ze9eXybDr6OnnxsCv8bM1jDW FpEbQnGzHuPqAD+wdnS8olatacxf+wBYkfWpSPq7AWlwz4ElUbnjXqhUh6+kJ5VIckT+mv+yUGGl tEIU9tLxW7im4a81p9dmwzU1f02F1+hvnnMPAMe1BO9Vt1ZhzpUQRvZ8JP4UAlu3ESl5Vy3cfoQN aEmMTGWsozmmc5foOq1VxnakRlgdaQ2y7AlcfzRybGQfbuVQ+BXvCiY9DyYDf4rbZCOO30VdB3+f HDdhhTZX4wixaKwvONlQc9H4xYz118iBpD7X4XWn0/ElGGsJjvGqY77Ki45m0sQQy484Ve19xMau ETcNxAnppvYwKtMoGHX0PViAY9xDRiHfTDVdT9CtSSAznKh9freOLdZVlpEtby5J0epzVyNs6bea rj8+fgxbnFvVKqJYp96UZC75dGiypZXOWrfBGlj56K2mqphEbc8StjCXq6ezPtUg92I90ovpeFfE BZ02aXcKe0C/x66+Eb9pZDPiRVocM3pr5m79nj9S6h/QmW4kGJog8CVm7mb2lDPOQn1EbmJmrn7P cZ12Va7JdtxUNWBZ+KigxMxCgikhjJX8h98blZAJHifBuI873tLfWye7r3oNoCV+xpAreNXpXBMO YhTdWsnsNW4FXIQkfXW4ePFruAgesDpMvJgJF2Gjrg4VL454FX/9RuO6wtBfcLf3fVX6BNs/had7 P/KNp2r/eKr+Z/H0FxFPHx5xG/C0LpNT8d+MpyuGIcJ92UuCp/e/xeNpLGzTmPcFuMzoJYHL628K eNrzRaHCG9IKZW9izy/2kuBpHr3WvZcET5e9KcHTPe8hfGT8FeEFq+6FEiWsOkAKEE8LZTUQehp/ JEDPG297wdPlpJV/PD3ZT8TT8mpvOo6s9qJjRzKIC0+7+hhRxNPhGPSDr1R7GBU3TDBqymCKp6Uf 1hJPY7ziaSyPp7H/43g6bZBvPAUoXR0HG7U7CT0ivPKA2G6gAsi2HKgAspqBCiB7ZYACyB4d4AVk twyAlD/xn8PXXj2V8ZWVgCr4u7vsDz+JevDMODh9bAmeZ6bAtgMdcss7MA0TI0PTnopUGRozq0Xs KgTUshE9wog7hBBrcsvDmdyqrvhv/ULpecw/h1+X30NEOdRTgl+vDeTxC1aXGzZEgKe8nhJ4ih8o 4NfUFKHCQmmFMOyl49dw7Q7+Wl16bWJPCX5VDJDgVzNMxYPzKr1hQ99KL9hwTxWPX5oqD1dPGSq4 +sJBXvDrUmUg+BX5sohf4V51XHXNi47GSgl+jfcxoohfK/6DE9K+0sOo0e8JRu18neLXXe/VEr9a ecWvcB6/wv/H8Wt3f9/45YIhrlKvAEAn9AoAtEPvBYB+1dPng/8p/Pm1vzL+mE6rxSG1rTxkf/gD /m06F6Xf4GJwPJfTqIDLqcma1VFidKGE0cFc84zuFDARCzAtwuPuhJ1LuJ3NGDWJ4FfsoaTYa45n GNP1IMLn+CLCvcoMbWJtjjb0ChC0iM1QnVC7DgJRK+/KqLfqI0oddaEkuf4VKQoeyIBetgEW5pI5 iQKfzPr3+NvlwRT/ekjxrx+Pf/hjk8PecOFfDyn+9XPhH+PCP2mFMOyl4/QeEv5Wl16b2EOKf32l +DeI4t9lr/h32Rv+XRHw74on/r3twr/+3vDvckD496IE/7zquOqSN/y7LMU/HyNK8O8Fin+XPfFv sAv/XuXxb3Ct8I+M4w3+1Dz8qf/H4a+kD8AfD1b2ky/z+GS5gwnSSrPCwtgSicdY6gWFwAURL7Sx JfTAsvMdhrokOyuR+xfxlc71tDMgPyNFWZLzuwegI0tIZbGpXE27xPyqHi0Qvheke1n3H11vXS+A oTi92NryoYZJvwmAaHwolnCd8aEqrdkMvy9h6R4K2PJQWleVIYjgTzJrsw+FAvN5Y2OhakZfoeoG 2mVXlYAdoSqmfm6idpWWYbcylQeZiMspZsgFdwPgRgHYAYslyFbCOtI376gmYYCu+x7TjRhkuGyp tuclqznoL6fTVBWj7ZkbXazTMpus1jpw5frjY9taZ+0h7Uw31Nr5m8gF7aqtem1iEQFHQ5PYoqSM omRtUi7o/SuZWbNNm7EIf7WCwCr7amSL1Y/WJXvBTmJAmG5De/K3LvoCww6NDF+vwn3J/Jlk/TRB V3lUx24hu7qRjr3KEhRwRBG8x30EmzsmkT3NsAe4JYlkw5m22HSmvASdqYD8f74tkb1uyiX/rWC0 +i3Ygqi/X8vsMF3vOP59cwmGAO0UWCBrhwYbn4CtuctU84S25352F9nL1rYNcs/XI9sZo8ZaDGSJ VxjLq2T69jjUF+JrRj5ivobaGiM34M7eyVhIIp+QeYnZc4apX+1ozK8/SfZbxJ6H3R6KoAmb/TTj 3ElS98xcZs8fOtNNndb0kJN6LBiVyJ4Fu/Z0I/M7NjJM9ekgAIrQSaoMm+Fly9DIRkFDIzVr8VjK YarWDX8smUBkjLBj6fwU5ILOBDbZC9wk6GizzbQlwVSdMOoYDsNXYC+wB7l36UAtVBDfwkffBaPF EK5uyovrp3tV11/3mm5A/805sE7RhaufhHFz4XAjilkvbGbD0NgSmNq3zEWjw8m0Ge6hFfacEM5e yO6M2OpIGpzlqIGq28Z2sjJFONdQvQljMUD1C6TMqTbc72iEf+BVQ6i0j50Me9nKkD3YcWTd2CJH I9pQu3CndnquqQou2sSL+drpNsZcop21SbMpfDfapV1VZLqu1ppbwIQ7bUwEB7gZY2/k5POr3iQg 6tmtZMHWwkxqnz9ovvZxI/WVyqNkbfV7zsZeMx/STjkCzKTmce3UvbCF6t6PXhN9CZ3lAHs592y9 RGvd9klsvi73Qj3T6a45uEcq4su03TebqhKMDXTspdjzyWyxI17Hbl6PG4PshlOMcwcpwV10iqnc Z6rqOupOpsAG1idmHgCYrCxOjih2BJGmbCnzQNvKxMwiuFwfIkylLr50ZLsk8zXjozoToRZCw1yo YbmbMLHE6M2ZBJfP0m6Y+sUkmXMEAca53XMg8Y+//yPFr7BEdkcSm8ewhXoSONhLevYmTF+oPr0K TrO0GYcJKE3qFZmq5+lfiErP0626BL5shqhkc5k241ciZ5QYXua1gB50aVfVCWl/qnXL1fZZAE4Z J7UZrxFKmZBx3jgoo8T4mt5UFaud8By5pEu3FaNLr7IlZaYQ3pKk0Rck4WNH9idpE8Ndbn2TfmNL HE+Tbg2R0iK4HHve8SCgYigsA4YCxx1MZZlbnaTYkyTqJEccXdsOAoPgb85tpup2JCKNarwRV/EA +H9EgfnQ6GDG7DSUW8fsNlU/ZjCaqmO05qkYvZ6KTCTQ1yhBs0+XWaBLO6NmdnMwmPkajmd4BPnn hnZu3pxCYt5jhBGJc5vCVugyLyRmnkoknttIMtOWpyLxV28ZtY3M0na9dbiTichn6hPvMRCDMi/G ntdlltqzYRdXxxoNqI9Ocy4p87ROU5qQuSUh7ZQalCu+iPrlcnWkCrYHG6iSsR5K5nHsK0BMnoqU KlrupqLjcZOzZnzkGvhNuuiD2oxuZPJMN9prJ6/BvsgouJwqcplompR5JinDaRiAQMjmmo6rEzV/ GoMh3DxHvFgfsSmZhLZQRrumPGZEvH73WbLN8IrhYeW5TGa3JLE7uWOEQiTBNuZMm0vYY2S9ntBO yYEYpC5I0K4qSI63jWzEdMG9bcb7ZWS/5YCIBxQ6bZMkjT2PiBDqppB/zSWjQ9ndAGkhxOccTwHe mW7sGN/QZZIjht1deYDdCbhAqmmYPYhAoaYatbGxqxZBsSBh/zkJGLUb9aDpRFeylnmULBXk1xAr 4O985gGypEz9fFxa5o2CRDVQFaL5iNbgcS15zx4PhIUkXS6PYVNCHY1A0r5MDUlmOThxkWA+9f/A 8bCdiIfteTxs/1+OhyE+8dDF59T/t/K52NWx7nwu1oPPxQCfK5HwuZha8rnHbiOfG6P738nnFib4 5HOxAfO5vgm++VynhL/J59T/r/K5GBG/Ynn8iv0vxy/17eVzWhef09wGPtfOxed2/U/yufbufK69 Tz5XbKp+HPhcbC35XHsFPnfhBZHPab3wOU0t+Vy7v8PnPElnHqd/Qc7ntB58TuPiczEyPtfh7/O5 WEU+5z6XPJ+bnyryud3/HJ/b/rf5XPu/zeec/wKfay/iYQceDzv8l+Oh1jefk7K4JkjMDK1h/6TZ N3sQtuU8YXM05hmeNuM4uaR38Tf9OoG/6evnAflrDIwpTF95OCXiqiMYBRd7i7Xp2Iu69AKgb8j7 dFr9LtP1cLzfxO7U9rxs/Rr5W3W4tufB6G1apsxqRvpWFT6uvvmQcaD9PjK6+ZChk9V8Erhc1RM6 9s8NwIW0PfOT2Tcjo6LzwXuiuDkdyayxF8D7omBPPZgcUZEcX2FoCWx2PN7mSIsnFu4i60at30L+ YjsQnBsb2Qi6Cs9pCfSBgzNn3UZK+S4C5QsVKN/NJOsoQvmO6dgjhCLWJZTPEQ3z7cH3HnlCyvfy gfMRpncJ+V6VlO+V3g6+F+6T74XfRr73UkekYRrJhkgkQzT69A2Y9zCkf30I/asb1DZybbiL/cUk W9+MjBFPoOUod4bwvxsdfPO/g6Q8yewE69KoyWRBQwPkgexBwxuU+71KuN+DAGlk1x4kzC854rKD AfzDTQLbeSXuDcdPlAC2lRJAkqocddG/po4GlP6xRw31kiOuySlfCCF22yRsD+TN3oleZ57opW/B vSrwvcja8b0SxLdW2qlFPL6F8/gW/l+Kb6yN/IWg5v48NuDbS6kMW63f6KLdlkeYHIpN4QQPOeI5 Y7UECJK1iVXJbGf7fyDJu6bNaEn+HR3LVpJFJQ5JlrUTe4Pkn3vOM2zbPTpkVrroqiRAvlMQNB/o bD+DE7tVOxV/MpveE7bvI//BT+G52lDOGH1dx17XVR6IPX8tN8jwMFaJvm46HhR73sXHrM0fZyzN 9zBscwfj3BJvN17Qma4HDZ+kox2SLqLtjDXZEcYQtzNtCkq0Nu+UaH318TqJVsPjajVhRvLfq3f1 18vO6azNHxOECiI8IghVRGjDD2tnTFvq6sjAW+xNYe9Rm5JiiTd2BvBsux7h50/TzY6jwgdnSf2V YY8Rf936HPFX4qw3nxh+gmHL+Bvq4HtsZeUxktlCfkWmGLYM27Y6OaKzY5Gor6PG7X2NWsTvjmL8 foLf30/8l+5vac4oi9/0+Uy2Gu77EdYbVZkLoGQIx0iHj+lIV4R7lKH38aO83fN/TeW656/rSp9U CoPTmzsxm6ZPcRISlxlEaJajF2OqGm9sDs9whqsMT+QHqbRRwXMfUascnWj19OOIUrnH7wy2kX3z IBALkk+FZjZj2G4ahn0u1NGcdpcDRchCtU2gpIw+s5kVWL5G1NBm7CDxPxGzNYyPdcEqskHbY452 FOwiSdoAMrV0MuG5CSai0CNd+1XFp2tmPl0bSdoZPyJjRGgnfAT5msk2kKzfeCCbKdJkbSCfrEV4 HYP0n0Tytl6Qtz2uXAtrkBQuxi2FCyMpnPfqYjYHn3GT+Dvkc6195HOJ1hHHTdX3GwYCsTKnA3kh 20iTKE3m5MMKWdMDNBVp7RGk60Zy+UnkD0vdyITMsySds89UuXI3+mAM9qWQxSVmljg+NlVHaM2A n6gJSeMSM08kakoU0zhl1R7ObM7ncxEqz3wumig3qXkkn8RpxN0COdm7Yk5GElqak/0HAq5koFz6 +A7JzsJHdGJ228kGwytCduY5JZidLU8Us7MTOvYoAQJDB+2UyzCyOl9nOj0+JT5/ZAO9qWa81uxQ 8dnZeJUsO/uLiCRzxnRYZ6qpGd9yDbztAznnjwB6Nx4Ye5eYnL1PJpQkm/bWRAuSyzWnuVxDyOUS 6P16yOeOSPO5TgHmc409NyNkdq0DzOxS3rgmGj2iZQqZizBKvx9IpFldCmskWV2S36zu1uNDazE+ PMDHhwf+q+ODa3t6z+8GkPyuGvO71q5T+g8lp/SttatCGFOF2o7n8SSvEhM+xvcJPTQUDujpA2Ae B/Q29kj6FskB/T7TDTXlMezuRG3PIutKTPFq1Nqel6JLSc5TwR5Iz4Usb/T9wH7nbzIXaVdtJV0X gl826ACvJ9uX8XRtoetMfmhki5waAsbRZWRbhsWeF07ljzIkFwuXHcj/STZjoyR2O2KN46Esj/xs 7dP/O8/j/+ji8zweuWhA5/Fzu/jOxz7pcovn8YaRNBP7kGRibQCMHlA+he8p5bf/F53H44NRND1r 7HR9/yPg/Ixs6albeXhS8/Ck/i+FJ5wI7/mZlN8huSsRmd2NIG3GXGR2yZGpwOcezg7VZqzAcF1k 6AWT3IrnVxXI4RJWqe0zsJjkZR15DtedVDY+g71NiEAOt6mOznQiSJdpJIGmt8jhQnkO95Bbx6sI zypyPO1Gyh4igxiai1VpNcLe7qwsc78G8LfJdCJ0LVANV35HeIDO+prTVF2XYfd7IWmHCObUmA8Z njBV1zGmAmAlanaI9AwGMpfgWPRIXpdJKNMWskkb2Y+7mFehqfx+pj7PGoFrJWVut2+COFgdpDWz 5A/oWKfhkjLzkjTbFdmWZCSB/gV5YELzSG7/U0D/mkeCCo7XacW6HkxsbyJQxSVPwd8niM6WtrRB DPKaSPqoJeE13fEsPVg7eaVKepZeVw0MaXtSZgHwtlekZ+mnKG9LIrwNrrRCdpZd19CB/ZPQtexQ ytYivClWyt2FSl0mi8Ne4GlaLtK0UsJYglKIHwBNI/O2BqfbqMoJktO0IqRppfa5KjxEv48Sr6ZA vLoPluOV6Ua153m6gFwi/3K6n6cL+wtYV12Bddl41lUgsK4C5oGxwLoKMDIi6xJsGHEfsC7E41Di oNQVBM4FUiCcKzA824N8q64IaME8oAX/1wJaKyVAE/gWolm4jt3J7tGzf+WA+Snmk2RDwtP+jJW4 SK9op3NjKME1rlM8nJRswQe9GfYiezCRvcS99bjTqWfbRtI3hegz0i9siVAZtUDH8sJhLXAl+Eem k7d4f2R6B3Qdyk2IdDoduXq2VM8WONry/95B/yXjcoNaCi8m0eFO5EUQbhijhrtBhAHVBBn7cBee oLpaWnYgpfAieAu1ag1+bYY9xiW0xa8nkL8vOlNDoZ75vDbjayy9yG16AEq7VG8mDdkL8KH2UFLf Dgdx3Oe0XzJKHaOe9F66GXsfKe39xCOevRsGQ89DaM/fiD2vInUJ8Fi6WGlHIdDRgzDSV1DSnWE3 c890IKPjt6otZEUTOMb6VJDFEBRu2qnm6rUjtSKgVgtSy/G+QpU/YskK8Ycn3LX2TmfOq2Q17QNq 4DstuCY5m72uiXZqdg19tj+MO0uSM/sXNfimALe0PX1g/a0nnfgN9sYkV5XhhWR/DSNrx14h+2s9 v7+0GU+S1VoPx41607pIDbxvoDU/AO82WNZFqmCzvR9DgM1Cy/RsBv6bQkJMpJ7kEHTdz26CdYc8 k6w7l3wfMdNCK8I9HjNkTOsBM9kyErS0E/OQLze+eo9axbxRN51RFzrLdXBnRcfWs38P8EiEPiDM wZodV92rRoI9kLH2iuzDPUe4qZ6KhsiB3GQiksqwEQc6XiXVZ/LVU6E6w7WQVk/l+ovVUx2PkupD +eoJUD2OO/+gpHoC95hYPYE3tzqXeBUTex4xbpi7X13N9bGGh/k1HMI9FEHWcIe49Ou9Nxs/kza5 Ek42ViZ1P8HBjJwV1t8CP73rfCEU4xPYoYHn/VsTUzbCkR2n6ehCjFDY/3EtYY2+4hf1J36tDhla wLalVt6ZC4uaraauNOoe6uqhdjgW48LaQ4pDXO992dDhMHQYDL0oUhja2sE1dDgMvb6F36Hn2mDo Z/mh/wqjQ4c7BpPVMoXR1YqBoaK4rq5xHhTHiYFxevsfpx2OU8mjxUx+nBi+tLkNwJNLIfsfHcTe SFwtrQ1Wa5i4WkPtb5JS9GV73xpAYgRJ3JNhopDqaCgKwn5aspGokdFG7H05uUCu7CaDukawQxyU 7KQ3ncJOOnw/GbO309V6BLQ2dBF1i+cL+mLBM2LB03yBDgu6iwXdJAPV3BQGGgEDXSSipLSfa0P3 htLkGlnp967SJ6H0c3lpnKvne6A0+iYCmv0UrsdmR0N4NYgs5F938VuPn66xG2C6NkItqv6EDThd c2TTNY32Yl/p1tvPfG/hfG+PYW9WsbcO0JvhXXEyBkM3mW7dvH2XfLOcWR+hIqGFf/9pPXTRTeyi q+jLDajFDxMH5C4/Shz6CY+yhlBWCmX3epRdJLuaW/MohfzhsRTy7+0q/Z4EvX9F0J7Rw2s/1boN APZk62szwArdhn1o7FoEe+NoxrIWcd7cBixagm7Cmqi3nDeEY/ykNgYRs4z/AevfuRPq8pVsxg7g kHHgkDHJbA23JJyuaxx+DyaGTlQc38mGdaSTNkmx1+AsxJTH9JOB5+/rYOYixZkL5wvmYUG0WPCg ZCO9w/tCAld8H/ifU7LNKHgmcKvuA/B0ENv2AYtpQf+Vaha5DtBgJWUvpptBxuFc7GNu2IpMDPCt oJWAO0sfl5Ex7sjdkMmspfO4RIiWLcRouW4tjNOOjsPd35znUPYD0NtGsrSmm3WM78mGDYO5DYVx e7rG7SiOGwbjvuVv3EQc9xwfpX9oxt+qcbxJUPXRZhRVo2CgcM5+vzDKrsdco0TBKM67/IxydA2M Mp8fJYEfJYovtZFSYwPuOtlr9uqbLsiCy96CXwldv2skADny+fpZWP8/Yv0X+YJRWNBPLHiZL3gN CwaKBa/yBUlY8JZY8LoCuiVg/HNHt303hdJXoDRfjoyzXW07Q2mmvO0xV2lLKC2uUcY+VVM5w05b 7YZ9n60OAPvCQNjEC0l81983Ee7V0a4fxK7TxK4fga4N/cWZeYVv+V4T+aI6ciTY92eOH+xL4B4h gZa7FqWAfQmcFsoORilgXwJ3hexwbkMUxb6RbSn23d+J0l15fknQL4FA33oe+QyvrpeBXooAelkP wnZeKQE9SHBb6S31eNu0xBxjNLxNawyVYV6D2PP4/ao7nE7kgQmY2fGTUPG79/28EqGRe4gY41hE UIgYAWAzgsuL9krkXrlP8Meuj8iJ3IfNJAYsEQxoIRrw/O/gj08i2lRyy7QCjUO0eSFaCW1EFnf8 XmHcgjZyFlfZ1M+4patg3DIVHTdOK3A4QJuNd8g43BjXKK+LoyCHm+ZvlGE4ioUfpeQOeVB+cRUy OMtDAoN7UeRYKav8pL9xnOlOSH/5+i1XeWFVdVd5YVWO33ywqg95/4/jWpJR7APl6FDkKnWS8GBf Iy9t4hRKj0NpHacyduQ1lvOmxN/csKPHb7XgTSMby3nTtV/deNNfvwbCmx5vLF+iX36VYMfqX/1g Rxx3sRnwn0gF7Ijj9kDZvEgF7IjjfocyOM8Ap+0URbHjBMmKBmfVBi8GRvjBi2MrBbxIaqSEFwMU 8cK20i9eXGvqjhczH/SKF9F3Cx6lfViOF121fjzq/pVSvEhrKMOLiAd948Xyu4RxZz8kx4uCO/yM +8MKKV5oGkrxYmoDGV485xol9iE5Xrzub5SEFVK8+LaBfDO2XoF40a+1Al60XOEXL15qIsGL88u9 4MXe5V7wYu3ygPDifKgvvNgV6gsvlof6wIuZ9eV40Xy5G17cu7wWePFsfTle5C9zw4vtywLBC6dG vkTjl0nwgl3mFy82kv3OTQpXxIuFUPZBuCJeTISyF8MpXjSIpHixIpbiheT+E6Njd+nYvXr2T3mm NcUz0/pUAJH7WvrLtL74hWzEgWh/iAxFOkkzrQucrpmYaSWyJxLZ69wH98rzreehq8ek+ZbrSJ6f xW6/eMm52vziI+ca4Mq5XiVOZ0+V5VxZtOQZUuLI8JVzLfvZI+daH+4t53qpqeD38a3lOdc7Dfxk JczP0pxrcT1ZzvVcuO+c61ATYdzcCHnOdam+n3GLl0pzrnb1pDnX6mBZzmV0jdJPHAVzLou/Ud5d Ks25tgfL6XnyUsy5zGTX2SvFnAsu+8m5JjSS5FwtlnrJuYKWesm5zv7kJefa/VNAOVdQI18516mG vnKugoa+cq4fG/rIuSbXledcjX5yw8GmP91qzhVbV55zLV/ilnP9vsRLzlUZJF/UUUskOJi+xG/O 9XsD4D/3KeZcX0LZ4PsUc67xUNbjPoqDdVpRHFzcVn7e5MmfBsr50wsC9IWH+eFP8xeTzfooBOfg IBny3cF3EXuea6jIocYu9r6ff6GgvoI4kmOhlEOltvDKoU41FvxxW0s5h6oO9sMyDv4o5VBP1ZFx qCP3+eZQ77vGfUkcFzmUyd+4g36Ucqg8tZRDPaeWcagQ1yjnW8g5VEt/o/yVLeVQr6nlAfpoNnKo u+9R4FAHsv1yKK1GwqF+zPbCobKyvXCoUdkBcagfQ3xxKEuILw71fogPDpWqknOo4kVu2FG6qBYc qo5KzqEmLHLjUJmLAuFQa501siXqvEiCHUmL/HKoMSRscc/ercihBkBZm7sVOVQ3KLvjbood+fdS 7PggyvO8hj+vjpNSKMPbbvTpZQFDDjfzR5/6/kD2YEcw3VZTIwWRZqBJsopq9B0pc/GiOPk59OM/ eN+pi9BVuLeC6efLBDAZzgWFeWMuX9QXvG38PXLm8ovaT2yf8r2UuVTcrJEyl2l3+2YuEa5xQ8Rx kbk86W/cu3DcPTynGM2PS5mL8y+VlLms1QijfBMmZy67VX5GWfYdjPIZP0pTfhQhyE3/DpnLNjjl 6C3CCFz2yVxiuMIgCXMZ9J0XGNF/5wVGYr7zASMGHihiuEFkFPtbcqDY6SpNhNKN8tK7nELpQ1Aa 4gVG6v9VI6Mg7EI3GJm68FYpyM/VNTIK8thCNwrSYaEXCmKolq/O1W8lMFLzrR8YieE6ENDknE0V YCSGC4OyP5oqwEgM9xfZqlxBU+q04++iMPJwJLy9lubCD9fzyjp2p47dr2OvSunIu3I60k+Akml4 GrJERkcIlOhFKNESu4xPJRPzjTdkUHK3i4/gA7I34BGcOg14YhLnmWUd+cb7pl1ADW1GDHXMlCLK 8mbeEKV7sOBzj94pR5T+xIl8xu+nvpGyk3nXZYjStZlvRNlVVxj3t+ZyRDn1l59x8xZI2clD16WI srRKhijvuEbp2VyOKOP9jfLaAik7sVXJ92zCAmQnH4cK7CRFhJXOC/ywkxjuIxJJXeyk4QIvsHJ5 vhdYOTA/AHYSwzUko3hjJzHceRK2vLGTGG4XlHpjJysq5bDSbr4brMTNrwU7ebNSjiQn57mxk7Pz AmEnLSvlS/T1PAmsLJrnF1aOkP3OZd+hCCu5UDb5DkVY+R7Kht1BYSWqKYWVYpLhSJ6XStALUCLy knfceMkrApgkNvTHSzZ9TXZfPBgddU0GJnfyfRAo4bqQ+dCxIS5mkuD+gNGMr73v04WUeRURL3HM liY6b2u9Jjp/qQRnOxEqT3SaXq/xHb4vfSUlJy/9WSNNdK7e4TvRyXCN+644LiY6c6v8jPvxV1Jy cuhqjSTRGXRVJU107neNUlccBROdDv5GafaVlJwYr8pZ9J9fIjl5DA4pJDkOXPZJTuK4R0ggdZGT LV96QZGfvvSCIjO+DICcxHFbSLzyRk7iuEVQ6oWcxHEslHojJ0Ov1MhynHNz3VDk8txaoMj9fG9C jjNvrhuKfDc3EBTZf1m+Oi/PlaDI63P95jizyVbnBjVQzHHGQNmzDRRznAFQ1qYBRZETjSmKTLrP 43kc8ftn7E69Bz/5QM5PBgiQcqmeP37y4RdkFyYAP9l3SQYp98HbR1KOkszeSCYc5Q6Nd44S/4X3 vfsVRc0PidM4sqQcpXFDbxxlIUEh6npsIzlHWX3VTxSfM0fKUW5UyDgKnFf54iiPuMZt0kjOUXT+ xg2fI+UoEyqkHKV+hYyjbKkWRlnSUM5RDl3xM8qa2VKO0qJCHgC/mo0cZV+IAkeZPdsvR9lxTcJR 3p7tBV2en+0FXTrODoijvH3NF0fRX/PFUR655oOj3HFRzlGmfO6GLjM/rwW62C7IOUrC527o8uzn gaDLxxfkS3R9lgRdgj73y1HiSWTk6tZT5CgtoYwLVuQoaijD83yCLhn1Kbq0vRtPUG4Hvkyr4zf/ mSXgi/F8QPjyNHE+b/hyYKZffNFedceXpfW84Uu3KsEDozVyfHmlwo8Hxs2U4svcczJ86VzPN75s qxTGXR4ix5fjF/2Ma5shxZfW56T48qNDhi9vuUZ5LkSOL2P8jdJ3hhRf1jnkm/epGYgvxiAFfHly hl98ef+yBF9CZnjBlwvTveDLvukB4UvIZV/4Yr/kC1+2XfKBLz+flePLY9Pd8KXD9Frgy8Czcnwp n+aGL6enBYIv95yVL9EX0yT4snCaX3w5QPY7951aEV/WQ1mmWhFfvoGyoWqKL5HBFF+2N601vng7 X4mtqfGDL79kCecrd9q9n6/w2DLoT+/YMi7L7/nKSuI38vOVF+p4w5YzVwTv2xEkx5abDj/ed3iq FFue5mTYckztG1s+dI3bO0iOLWZ/4745VYot+Wek2JJyRoYt9V2jXKwjx5ZW/kapmSLFloFn5Bu3 fApiyz3OGk9sOTTFL7Y0uSDBliVTvGDL9ClesOXjKQFhy5LzvrDFet4Xtnx43ge2vHhaji0lVjds KbPWAlvqnpZjS4bVDVsmWQPBlvWn5EvUxSrBlu5Wv9gyjgQpjrlZo4Qtr0NZWyjzxJYkKAuFE32C LYUqii1w3vI38OT4dX94MmCygCdbTvrFk2/reM+FHp3sF0/ecLjjiRpvNynhyeyLgseNg7txEjxZ esaPx022SPHkwh8yPJlKJtgXnrRyjRssjot40tHfuM0tUjwZ+YcUT26ekOHJ6gvCKPNramR4suu0 n1F+niTFk9A/5Js1axLiSdENBTyxTPKLJ7l2CZ70m+QFT56Z5AVPoicFhCf97L7wpIvdF560svvA kzon5HgygXXDk0y2Fnjy63E5nnRg3fCkExsInrx/XL5E5zMleFKZ6RdPHiUBkauqUsSTJlB2uEoR T/4k+5We5xM8GQ03yAiehDcAPAn8+d0Ff9b4fv6kVabw/K65XIYf/PO7rQ7XKDx7osr0+/zuE0R9 +fO7e6+7gYV4JPuOQ/CnntU1siPZ8X/4u/8xUYoWtmOyI9nXryuhhXgke+msMO7+GzWyI9kQf+Oe /kyKFswx6ZHsrqOyI1mLa5SPxFHwSPabE35GSftMihYnjsoP/QZ9hmjx5bUaz2dP+n/m99mTGack aPHoZ17QovlnXtCi2hzQsyePnvKOFnGc9pR3tIjjLp30gRZ7j8jPZXuZ3dCir7kWaPHZEfm5bD2z G1o0MgeCFl2PyJdoY4YELYoy/J7LOsm+47ZeVUCLOO4PKPv5qgJaxHEFUDb9KkWLHlUULS4Hi8/v Cvd3dunZvbL7Owa3+ztvCtjxJh6w+rq/c8JE9l8imM0cloFHON9HMlIPbjHZt9eKE7WrKnS5p1vp cmtaebnVk23yvmnnUEOPEpdxTJbiytg/veJKkzOC51Vek+PKw8f83AypZ5Le6hlySIYr9f/0jStf nBbGHX9Njiu/HPUz7pQJ0ls9FQeluDLqoAxX2rtGueeaHFf0/kaJmiC91TPpoHzTNpiAt3q6wZmE BFLgsp9bPQnHJbd6DqZ7gZTcdC+Qkp0e0K2eg+W+bvWsK/d1q2deuY9bPekH5JCiTneDlJD0WkBK +wNySFmZ5gYpq9MCgZRzZfLVGZomgZSRaX4h5Sey1blRFYqQkgVl/SoUIcUAZV0rKKRUXqGQMl/N P84mnpfQ35OtYSwtJ43HT4k0JVFxTSJacYx7HjNm+m0Qy1dBFTzqPJc2Jk5lCJ7UrZvjLqj2MBoZ tKEBbeZMjdFuqGAsXZ4kXXL3XqWDP0PIY2xJbBGJhcKPzn5I4gfXaV9NYO+DT1Z5vKUwVoA74zl/ cHflU+IWffG8db8M7uLk74N/iTQWe6UzeZY/4xfeAlj8qa93whd+6uX9hEmf+ng/4S2n8LD3OhKC 7P9xKrwT/i0p8f1OeOinHu8ntKzwluOtPC7gzxeX5Dle0QE/+JM9ToquDUplOd6Si75zvM6ucSPE cTHHe8HfuDHjpO8nTN8nzfHu2SfL8faVC6OsrZDneI4yP6NsHSt9P6HtPnkC8dNYRNdTZL9J3wmH y37eTzhxSIKuY8d6eT/hjbFe3k/oMdbL+wmxYwN6P+ENMrz39xOSoNTr+wkPQ6nX9xPqQ6m39xPO 7ZFnhUPHuIHy8DG3+nDgtD3yFLHJGLeHA+8e4+XhwJf3yBd1/ycSUD7+id/3E+4mIZc7cVYBlBO4 arKLufyzCqCcwB2DssVnKSgPukBxscFfivgXp8Nf+XYlie/Lk8TXBOQbc0ayn03Cfm4l7ucbH9ND Jic3sER+Uwx/DyrJfG10E8lx0zXu4yPiwbUU2go/9nvIVFPmfsj0lcMbALU7Irho2Hk5ADH7/CRW D38sTRvZ3TIAauPwDUBrDgvjLjgnB6DivX7G/WW0NG1sslsKQHOKZQDUyzVKp3NyAHrX3yj60dK0 cUmxfK8+MhrTxjc5IW18QeR4D432e8j06n5J2nhtlBeOd2SUF46XNyqgQ6Zrpb4OmcpKfR0yrSn1 kTZ+vUsOJy1HucHJA6NqwfF67pIjyK6Rbhxv38hAOJ5ml3yJMkdK4GT6SL+HTIVkv3MzTiseMv0E ZaNOKx4yZUFZv9MUTpqdpXCytpLAieL31Abix5wqZR9Ugx/mcv+gGnzd1/VBtRYkNRU/TJXh+jBV pPhhqi+MsF9n8pSxekeN9INqxmEEjhBoDINhn78ufusM2NajwLJdnzNLJuhz3wFoT0cHM7FuAneS P10UPkMVaUQ6ZxF/Yr0pXHmd/9DZQPfktKHRq2topybym68P14U4p72j0+VRew1e6NxaQwB0rg93 fo87ndNOfcVVugtKeziFD3A5nnJc4/9q4fnhrXYGmObXYFokVrfAq7lq8SuGRi7qtNecev1+AZYW npHn1Ht21fj7AtmyETDWU2q60E23C1k1fmRtJeHyPj+y9oxr6ChxaEyr+/gfuiMOfYXfY7O3CYk1 fGTt/m2yxPpgqTCO7bQ8sa7Y6XecHcNhnO/4cR7fJk/efhmO2MudELA3S2SAi4f7wd4+XPluCfZ+ MtwLA3x9uBcGyGDBx2KBUXj/Bws+FQs+key2F2qE3fY6Gd7+jBx2C24Kpd2gNEe05+BHPpB+lKvT RtBsiLzTXFfpBRK87CvkpU+7hiyG0se9fEhtZZE8m2//kRvSx390q8SxT5E8tS8b5kYcjw7zQhzv L5JviHnDJEifPcwP0vfhjpKdzv1YroD0fbhNUGYtV0D6PtwPUPZROUX66JMU6XeT/En+fn8fen9S z17Vszd5kD+vzSgRQX49j/EbEePXI8THHwG3+Jp6hVlwigdEp8j5EJzia94p7i2E6mYB30eTOELx /QMgnu8AyL8phfTTHLMHWvxGEX1sJEMR/cQxOaK/SEYxDodvj5PI4ExmL3MLjtY4u+UnPu1ExGP4 em2g3hs8zvfxvBca8aEPpO/MY28q9xIBA3tbEenPfuAF6Xd/4APpU1z9BUF/T8uR/mVX6SkSFe0M khqStecTYkePP8eVe4XqpiUCjlUdl0N11FbJgi1VQLGQD2DBRvNA/U6+7PizQbnv48+5u4Vx047L cXpZkZ9xp74P497Dj3tpi/T4c/QWGUp3cI1y73E5SvfwN0o0jrKd346WLXKXbEhKjalc4hEBo/cS gLGba4Spl265Y0PB8T8UCfSpoYgpf8gw5bAIDFuGegf5yXSlq0nMcKTx9WcN9UKwxw71QrDfGOoD dh+rEfbTLDKKvZUcWDNdpaOg9GN5abGr9BUozZWXvndTKO0Mpa9SUHa8K0XkiDw5In/zHgE/Rnj+ 5T3Q+0FRb/i6sH0Fj7xPgpDLCwPd4C2VK9gK9z/gGOFbWgff/9n8f7h7F7ioivd/fFFU8gYWKpXm mmthWYKhgldQ0F1bFJXSPmmIgkKikixKeQ9I15W0orLMsqSkMrMiU/OCiYplpeWt7OIF6xBaWqZY xvm/n5nZPTOwq/b5f1+/W6+XvZd5nnk/z8yZ+5k5o7bSXclcijDXm5mLMcz1EbFm7VCLw+WHEWuw iNWQxbrdiNWhjiu9yZVGR720wgmamWRV3/JWeNUPvBW+93Td8fa//57lh4evtn55z8Pu71m+8Iky ja/1Pcujn9cY37Oc86m6dvlr+pXWLn9O99EEfpF+hSbQ+J6lCTXX+/csfyq/2tplYnqdtcvko76W Di7udTce33+nLh0023mV1b3TafLa5ZDtytLBb99eeelgrsduqmGXLR08W3YVu440ee3yUKm8dDCm VFk6uNFjRT+qLh10uZqV5mny2mVmqTovPTuRrV12OqKuXVLwVdYub9strV2WTvQxcl090cfI9cmJ PtYusyde09rl6l1XWrt07rrS2uWkXVdau4zfdYW1y7Bt6mLDugm1hqDrJ/y3Q9CDW9WVh/sm1BqC PjjBxxB0+Vb1od48QRqCdpxw1bXLB1FDtNsOeV277EcyWs/3snbZgWS/HuSN3xvf8MaP3g/5+D7C v3t/8+FXV23/Ut3vb17YcqX3N0fLa72/eXib2gb+knKlNvBkio828NOUa3p/c3mHr/c3J3ZcrQ1M SKnTBo455KsN/GO3u5X45rDaBl5XepVWQhsvt4GDNyttYNXBK7eBMz12kw+rbeBT265iN3O83AZ+ 9bHcBj7wsdIGtvRY+fuQ2gbeeTUrjcfLbWDGx2p1OT2OtYEdv1bbQAq+Sht46ydSG7h5nI82cNU4 H23gonE+2sBHxl1TG7hq+5XawPztV2oDJ26/Uhto236FNrDzJrUNXJNcqw18P/m/bQP3b1TbwGHJ tdrAkck+2sDnN6oPtXWy1Aa2T75qGzgSNUS7db/XNrAXyRru99oGtiPZL/t4G/jaAd4GDj5R5/2N tF/4AFtxrdnIJ+MXAvNK2cx7rWjiAvNepfRSM+fK0bQ5yG2bcyftE55udY0x5c6sRpZ9m9OJfb+N DCLQHdt1nyn3sWpTTlO2n4oJ7zNZ6w/XrJ2+dTSxO3+zOn/QNu+m2dQTPIKJXuTH7IptQJf3dLao 4dbcaj3bbNtNl+yZ3Dd/bIzB/6oC3X+Gl9qcjcL3OMtrb0N2fk1vfP6mJuut/b6arOgd7kp929dq k3X/x+Tly3zOt9bb+l+S+40PW//7SGmyImGRro7y1WSVf+K2u/Yrtcn6YdNV7G55yP3Gh+2n/Ehu st5YrzRZ4zxWrF+pTVbO1ayMfMj9xoesbFyvlu6oh9iq47QvavSNbEY725iwRjx01Tc+D2+RVh39 H/IxIa0a42NC+tWYa3rj47/lSm98ftp8pTc+5Zuv8Mbn7Q/VBujOMbUaoPAx/+KNz5gP1Tbn+9G1 3vicHH0tb3xafag+oudGSw3QytFXfeNzCOVde3Wv1zc+m0iWv9frG5+XSZa+lzdA7ffxBmjP9zX6 BC/tz/zTGo24nIeszj+szn/sBbMDAkeWBraIC6FLr6y740JNrJOcHYJ/mGXHhdF9WwH2gtRIKFjx LxJKo7hSqhX/EqwFs8fyKyg/1epRPS/IZwMtp7+FUYu/Mih/uzUrofqx2cJqT0GhZR/Vjd40Givo du4DQ6aFbKOPSOy0uvKELsvT/g9SpWjobzLFoTnMRCS/93ikdYKwmI1XaDxcUMIDXXBNi9rAqt/u PEuRif9H8iIhD9Bsu0keSubWGea+/k97yOG5Y1rle/UpuNtT67i9cmGPmm5tprBX7rbHImllH7GW G0Y3S0Y3s3Lzm3YI0ww7N1lumBz7H0phbH0jy759n1tcJizS9U3adcxit62STDu1xZNlywzCQEZ4 Q32eZQ/RDVMf8DYqk9qoNG3rFr44kMlzKvAjnlOxlhQ/Ex8vp/A86rhL5FEsRWXk7z/gzqCMyn1s dN0tRDzFhcJd6ru1/2zhGbRQzaBV63kGxVpmuW3NYt972+nJmoVGSuIeoJSkS6Vp33s8JaMoJQna +c0sU950h2pfbxY5EksqjMTESGLr8ewYAvXta5VFyHc38+wIY37amZ9/f+jOE3FvuMNi4XnSYqcn T8KqBoMta62yoJ0s2KwS2zsett5uNn7ep8zD5V7XHj6KvF3vR8ODydaqFvw+Tfa+opyR2KNOOcyu eEyKZofSlbiu6KAYdk0j+vlY5+/6vqqvqnohbkhVS2M8QvFD3PH/cUxW48eFl3oiH7RTTosV0hCr q9gzRAmtJ4Yo3NE3R1Kb2aSep818dyRrgY/7yS3wt/hr20oqEFGfMfO2gg814VBrtpLoj3wNoUxA ZxhEDZp5LW/YNrwLnF9G2nWX9/tzY2uV5n610YDfyuXvKvJiQ16Py9cp8jcN+Yn7mfw9Rf6WIf+E y99X5G8b8te4/ANFvsakXId05986qyLHKHs+RRGpvPFvpW88LSu8SQrfqgptLksKC0mh8WVFYaes MJEUPlAVKmWFgaRwWFWY/o+k0JEUUuT5xdxmHmEAK+S/aaa17s519zw2v2ctQDHvE3bQhJ69voha w9X3vyNKwW6hSU2SnXF9b3VlR/Nad+9bpJXNvwf/FrUVF7Xb6RUBFVTegrNbKEXBzawsMP4Iq2Sz CWcV/q56E/+rNP+ju2NSV1M1ngKbGIHUmFYNocALl0Ug2pOq3pU/Xqa7P0UFgSvBcL7yq8ueiNSs V7UUf1BDVhUgYrvr97REqjavXPaM3XISr/Ciaob8eFZ/QFumubHKMQLvExgvME5gH4HdLnvOD9Bc JJRGAfN3032H2s80qcsvdTRHE4CRfKhYAtkWxMrjVp65Bd3WicY1gA9w56O3cF8PG/2hH5dgivEm W49p9p8R6B9yt4fanM3tMJW7A8Ifafj96Lv8qW0HcfgZq6ublTRdLfcMb892OH2znQzurlzOHtzu qmH0vxi2NuIeIHdHDMfdIt+iR/ge87JxUog2/X1u8leYJFel8WPVcInqz+FXpboTVHRhbgDxrd1K vLr2xq4az33H0nhrAytt9HF1lFgT62PYhbfaQJBgehWYX0J/lWMUlxtZLzD/DVbsZ5u26vRUktFM 55cG5lGnb3d1e38Y2489FCV8020mvhlsK5v4gtp1v8b82ciyjs5Mk5qfiS960PzYxlp4Ld5V0oi2 bbO55yzUxJh5cyJNjoYxiwYOqGpFHA+/RcoN2eZt/M03bxNL8i4+vnTSEgqKPrq0t1kL7nqbbQSn 2hB+NC78Qlx4RVUT8X1DW+7OAFsUOo0XWEc220QX/P4irp7Fs9+bwJ59PBKnJbAhwW5avym3Rf3g uC7e2deWuyugalN8p5/szhSL2ba9pr7deZbdD20NjN0+pIAW+Y5bt1f2cd9qrbezB8Ydt/udtQf2 P07voskLRwfrBrfYFlUWuEBH4OCC3jS5MGnFrPPdOcQ5608TvW82W6N+4C065trWTr9bcz+pdu7b rtXXS4sbWZ2a1XnO5jzruN15aPuv9fVduT81sl78AeF25/alVleU1RmJch+AIhVg1Xdln7Hm/hU5 bbjID6urhdWJIdAw1IaEACAasgT6Gz1fAnrZYWYguuRhqJ8J6JaHYRCegPHIsEgg8UaDN9oa9U32 h6hS1fZO6AdPVtsLHHeiQO6oqm9z/kpZRn0o1TdtVnGNPrhg9CnUpNNs4EUPpPJhTL20YaVoRS7i V9V/4qPOkzDIYbE7Tyrrt1ZXL6vzV63jamQRqjAeS/ZputoV1n7W2hWzjnlDrY7ZuQMakDtaVwVR Q587y2I2ORpT+23WqlbzTj0Lk39tyOvyWolxn6xYLwllcwu7axsvZu8qxewMFTN/W+5uOPWbu3z1 o+JVZRSvyUNY8foVoJ37gDVktCFhjy3qe0fjeGc2K59Uvk6J8vUPypcml69QH+VLu/byZf1ElC/H mf9ry1eGp3ydoSzzlK82b9QpX7tF+Tq3xV2+xsdHnXa0oqIF/3tpOZ7C9H32b/wNsmsDW/bvCzYq XdD9mXdE7lJV+cHrFEkO2kFKNI7QvRa0x1/nBa0xupOqA17X4/7/l69mdla+ngRoT733v6l8adv+ 3y1fm1f5LF9PfeyjfIWW+CpfP6zyWb5GrPqX5evWVbx8vbXVd/ly2i3BTrbq6LAE+ChnFShqVU3d 8a9S3lbYWHm7ZTDKW/t35fL2HZW3CIstt4yVt9M0OEV5u4zydkwqb53NdmdlnfJWafc7hvJWGZ9/ xkt52+kpb2dYecvZ4i5vp/6vLW8pnvJ2mrLMU97sr7Lydgbl7Uyt8tZ+o7u8TYqPOhWLhAfHutcz AhzI16rAdqK/FJ9U/m2VuyB+l/0TLeK3olV4tdwdXVmn3LEO9AxUvZa7t1byctd1M/rOpe7hfBAb ZPKXp6FvY1RakIXcymLz6JAVNErNwjRsAI3oMarLMuM3X+4ryAqzF8yMhG40jf5Ov0S6M62QR3Pd mQn4zVf9+Gs2Gp+FGO/X3hrU3pSdSgPEIPJsd657qmfn7pB6EImHvcwHy5WvMDWTe0ZYMHOslkpd gnAh/SX2m7k+5iWWO0FsRuKe8g8ddIWJUhZbRo6waI+/QZMknU1+JM8HGp6fHSgN/f8aeJWhf4AW 9gZPQOgrV0xn+gqu5uclnbPfoDWhmWGUVm3eciOhjuV8htK0XB4Riedrc9bYXFv5/QEvogUrmBNp cz1krWpN7d1MWrzRUQfA0pdeFTh32KP+RnkrmBMArZCq9up4TtZvLum7LSxaS+N/9pvleiW9f/Cs J7uPD8w/zdYZ6T72GqvrHrZLkc9tHn5dzG1oyUQ7vVbMbVbxwSSf2jzxMZ/aPMmyr8/hWDa1WQ6d TRYxZzlJqwIgZjMbXTuwxj2zyVolzWy2rJFmNkViZlPhGBkzb5YF05pGMYtiLQOqWtNg9ekVpOpv ERObn42JzcKNfGKzzkg5zWP93mSj22VidEsFUFvxojpgVed7AQ1pff2wzfnPtkhK5tAN4sVPt/tf 5Cuj1Q34yuhZoBZdzFdGWSCdN2Kzt8kmWjLgivz8TywtBB5CxnDWSx+5WYtXcFZNsB4j1l9Wc1ZN sD7GWQOIVTNY/xhArCuJlRYNtVUe1vyXxFq8YN1HrIWClQLDv9pIeRSzYZ6Jm1hQxEwEsWUUw8RS ZmKMx0S0x0RnYaJcmCglE+HCRLk3ExZuIoStrRgm7mImbiITpWTi+/VuE18v5yY2CBPryMQXb3AT FLjJDOqN/oLf/yXGbyb+DQb/5/2J/9sObv7ZHv5Zgr9Y8K8k/imCv7gOf9Fyxs/WtYsN/smM/8UO 7ixq6+HvKPiXCf6lxN9c8C+Ts8gsTPitYibC2LqVYaIxMzHSY2LTh24Te0WhXChMzCMTb78uluu9 mXj5NWYiki1qGSZWx5CJYDKxElVAG+kxkSVM5AgTmWTCKkzkiBK67G3GGk2sOQbrMMb6w61ux/08 rHcJ1jTBOpZYfy/irGneHD/1KjNhJRNpholfo8nEco+Jl0vcJg68wE2MEiYSyMQSYWJUncd7sJjx JxD/KIP/Scb/IPEXE39fD/9swW8V/NHE30XwW0XGtOOFchSxWg3WSMbakVjZ8p32gZv13LOcNVKw hhHrN6s4a6RgfWAlYx1LrJEG64l+xPobesFt7M3c0x7Wo8s4a6hgNRNr7iq2+mem9hoYYuIYJDCA ob94Z1LC4uKpUF/IX1LEhe9h54FXMGfSyJlQw5n7mDOPe5xpwJzZQX3WY6wlGJPJBaff9wiGvcUE OVzw9ftu9+8Q7ocI94PI/bLX2PuitkIWIGQmkhW/xjPMHSFAZNxYNuB+hzVJdKLNcPeNvuw4kpkL QgxBARP8BUF8wYcLWcdzMdZZo+2kuWLBlhDkRODI0pjAFvkB+BmzO59CTKZ5/Wy7881+fODAOiwt i70M2WHb5hmXO1eYaP9D7t9+gXlU0NGLBy5o0gtB20/WpwzZ9x7LgvALVtr78a2W8Azzv5qmGQVb Egzb0dx2gmF7lGL74jvctnNFpMfiGG5xeivtOnhWFWh3sj3GtMjezc/wwV7Lh71PMx+o3MKHhYYP OdyHhYYPS9X0e3zI9Phwth1P9ROLqBrMpyX4eWwXm9sVW8EKSpvd1YFGBSl2V7fLvdtjzLvZYkI7 VdVVjP1qevse+91Kmwi7oyJWhdD6lN15yu5KpddfbAHZHnUxexNb/3+WzSyzf7S5trDEuZ5lebX9 RP3wC9qhp2p09kK8vhDTtK6FrSB/LP2OqnY00L4upIHdlgAWtwu9HCF345m7Rdzde9zj3yu7+5O2 YDl3l70vrLK67rS6Bsju/qilFtKK/5nsY/CHlQfXsybD3du5u3gsjYQc/gbmrbmJHlp+KPfZ7qJc xtwnLDDvJUi0FuCsfPom49knvKs++31LWRLT/NhJDgZs7bqhtX4mW77+jSqYK84UfpTeRjSm7Tv1 YzSq3gXdgp8SIyh/MYICajUvE+Pr1aKRIRkN9WawKRIbK3B1/v2XXlQXT7ZjZgMkszncbIA3s3GF YoglzB4jswteFkMsYa+RYU8z7D3Vk+w9w+0FSfYCuL0gb/YCnhGDL2FvH9lrLewdEfaef8Vj74hh rz2zN4DbC5HsLWPj2rgQb/Zee1qMxIS9UrK3eoUYiQl7txv2yg1770WxRu8WZs8s2Qvl9sze7PUW 9jYIe+vIXg9hb4Ow99HLHnsbDHsxzN4qbi9UsrfhHWYv1Ju9g6LYFAt7K8ne7pfEME3YG2TYKzbs 7Y8keyO4vTDJnpXbC/Nmb4qwt0zYW0r2Rgp7y4S9wys89pYZ9pKZvfrcXqRk7wib5MRFei0vwt5C YW8e2ft5uRjDCXsTDXsLDXvnerDtxW2ZvWjJXhq3F+21vCwVAzphL5PszRD2coS9iy957OUY9uYz e+O5Patkr/ptZs/qzV5/YS9N2BtL9hoJe2nC3gLDXpphrwWzdwO3lyDZW8jtJXiz990SMe4T9hLI 3vMvinGfsNfasDfKsPdqd7K3ow2zN0qyF8LtjfJmL1vYswp70WTvdmHPKuytXu6xZzXshTN7Wdze WMleMXuDFzfWm70vXWKEKOyFkb2PXhAjRGGvh2Ev0rC3vRvZ68DtpZGhfszQmDTwfvSkGCMKXjPx JgneUMH744se3lCDN53xVt3MeDOJ9+c3GS/t8doieEMEbxB7/oI3xP38Dd4Q6fkz3g84bw7xLuG8 OeCdJHgDBK+JeN9dxnkDBG8XgzfA4N0YQbwzGe+H8/iYTotg1CvY2BC5USA6q/qiswJqwwQ7BRL7 /heMXqq+h/1Bxt6Hsc+O3koD5k30v/A9WvTrZAOB9aXAO92BflJgK3egvxTo5w5sQoENeeDpIhHY WNI87A5sYBJrLQj8xB1IQ/tN/jzwHXfgdVLgMndgUyl6rjuwkaQ5xR3YTNJ8wB3YUNKMdQcGSppd 3IHNpcCbRGD4BXdIQBEbbG/gzyZ7MXTJXW0l61a7TVksunjxsI7Rwyp6juKwcSrr6evzKcBdiOLe npInYrDHVtSVHtsbNzIT+xaJTlww7iPG4c+JTlxQnVghUx0xqB5gVDM51WJBVS6oSomqkaAqF1TP K1TlBlVzRpXAqe4SVBsE1Tqi2vys6HoFlZ1RWQTVBoNqRzibdHKq4aIVKRZUK4nqEUFVLKj8GJWf oCo2qHIY1V8hjKqloFomqJYS1W2CapmgWv+STLXMoLqLUX3JqY6IBC4UVPOI6mih6AsF1aSX5Lxa aFCdCGOfeuBUrwmqHEGVSVRLBVWOoDIzqiBBlWNQPc+oHuVUEwRVmqAaS1RxgipNUB1cLnuVZlDZ GdWQEDGrsbloIS/OZK2fpoF7tVP0VoI7gbgrn2GtHBqW+nZXJqn9IdSsQi2a1D6Bmt3vD/qbotsL 8picnRP41er8RkumUa0rT8Ri3mztQt4ca83dHGUIXmeCn1uzzYomycMx+aK/EabDyPQg7mGQ4eEw 4WGoUDOTmtnwMFJ4GKp4uO0V7mGo4Ugb5sgc4WGkIajPBPncw2jJwy15oocRpoPI9OtPMw+thofv LhQdhlAzkdqcpz0ehggPAxQP2woPAwxHHrubHGkjPAwxBMlM0IF7aJY8vFl4WF1P9Ca0TF+fexhp eNhMeKgJtWPsfcFTHg8pOnlIcsPDmS9zD3ks/v2Lu8iRTa24h9WGYBsTbG/FPAyVPHw0VzR4wjTt B9aSn2IehhkeTlogGjOhVkpqPQ0PjwgPyxUPv1nBPSw3HOnOHBklPDxiCNoyQRL3MEHy8PDjovET pteR6W1LmYejDA/3PCEaNqG2ktSWLfV4uEF4WKx42EN4WGw4UtiZHLnQUrSjhmAmE/zTknk4SvKw m/BwmTC9lEy35R6ONTxsLtQWCrV5pHZhicfDZcLDhYqHz77EPVxoOPL7newzTcLDZYbgGyZYzj0M kTx8Zr5oFIXpTDI9cwnz0Gx4mC+qfJpQG0tqiYaHOcLDNMXDP5ZzD9MMRxKYI12FhzmGoAcTRHEP gyQPz80T7aEwnUCmv3mSeRhqeHhSVCirUIsmtfefNNpD4aFV8XCY8NBqOLL2DnJkX7BoDw3Bs0xw OJh5GCl5OFR4GClMh5HpHtzDaMPDL0SFChVqZlILMjyMFB6GKh6++6JoDw1HmjJHpggPIw3BH51I kM09DJM8fGeuaA+F6SAy/WxBbQ/zhFqAUGPvDqcUGO2h8DBA8bCZ8DDAcORh5khT4WGIIRjGBDdw D62Sh02E6Wo/0R7S6t8fi5mHCYaH/4iaogm1Y6S2d7HRHvqJ9tBP9nDSC6I99PM4Uh5Kmy5GWyID 81+/QTSKhvStUHJzzQ2ss18ibB4RNveRzVGLqbMvZIG0GPajtksYOWLQjGc0+ZwmQ9CUCxr27qmF oKHArXyf/4/aLMFUbjDdyJge5EwD3e2eYFpHTLtdnIkC2QyD7ScQTBsMpi9vJ6ZwztRRMBULppXs fZhgokA2LSEmbZloDg2mfMbUiDP9LdqRZYKJFnq1ewQTBbLZBDG9LJiWGUy9GNP31zOmbwTTQsFE q79a5SLORIFsukBMiYJpocF07jY2P+RMH7rbNsFEi8zaK4KJArcGCabGginHYFrNmJycySmY0gQT LfFq9wkmCtzaQjCVPi+aPINpDGNK4kwPCaZRgonW57UmgokCt14vmKYLplEG0w2MqRtn6iqYrIKJ FsW17U7ORIFbbxBMnQWT1WDa05GYmnCmQMEUKZjYC6gZgokCtwYLphPPcaZIg2kuYzregjH9JFrC UMFErzu0uwQTBW5tKZiWCaZQg6kbY/qIM20UTCGCiXakaycXciYK3NpKMA0RTCEGU5WFmAo405OC KUAw0ZRDe0EwUeDW1oLJXzAFGEyvMqbxnClFMPGlabRRNOEcKpgocGuIYNr0LGfimvz8J2OK4kw9 BZMmmI6x92GCiQK33iiYMgWTZjA1Y0yBnKmVYFIO4H28QDROxHSTYLpNMEnH73Z0IKZTQYypUrTA ykm4RwQTBW69WTB9VyjaJ4PpUcb0MWfaKpg2CCY6v6HdLpgocGsbwfS0YNpgMHVhTE9xpqcFU7Fg WklM3z8h2idiaiuYrIKp2GA6dSsxTeRMEwSTcuruGcFEgVtvEUw1z4j2yWBazpj6cKY+gkk5EGcT TBS4tZ1gKhFM0pm3YYzpBs7kz5hmWXJop02m1oBxJFpytpoFQRYjiCUFXv9Z7D8DWewzc3jsNIoz VtudX8NOpqXR7pe/CtgqyFdQ2RTAyHZrTxRwsjRBtqs9kZVzsvcEmTh595ggG0Vk73Cy5+aINRYi ixJk7mN4jzKy5ZxsuiATZ+buEmRW9n1iTjaayG4QZKcXczL3KZrOjGwKkc0vo/038v5NzxsqWqF7 n01HtrAVunzd0ZDtggqw7c6fZ+L/2VyzcxRJXI4IzlSDM0VwmhqcJoLHqsFjRfAoNXiUCE5QgxNE sFUNtorgaDU4WgRHqsGRIjhMDQ4TwaFqcKgINqvBZhEcogaHiOAgNThIBAeowQEiWM3yOL7SQfcx UakV99+1a08H5e6pJx+U62ycKnyAyyMU+V2GPIrLuynyuw35jVzeXZF3MeSXbmHyHoo8zJB/w+WR ijzckG/k8ihF3tWQv8DlPRX5PYb8US7vpcgjpPRzeW9F3k1KP5f3UeTdpfRzeV9F3kNKf1sm76fI I6X0c3m0Io+S0s/lMYq8p5R+Lu+vyCm1toJ3qGdHTQwVb/wr7/9Rp9XXsTx4rDt4Bw9exoOXuYOL jysHFQ8d4Ufl6J25NmtWjV5ZdkRRaPKNpPAgKVxSFeJlhZ6k0OsbRWGJrHAjKcxWFb6QFapnQmGz qtDsW0nhMCn8rSoMlRXWk0KfbxWFp2SFZ0lhrqqwS1ZwkEKJqhBwVFIYQQoXVIVBskJXUuh2VFGY JSu0IIWHVYX3ZIWzj0HhFVWh7XeSwpek0OQ7ReFtWWEtKbygKqySFQpI4anvPGcqLTezQjflOrnQ TbzOUyj9uXyqIk8z5BU3MXmmIk835GVc/ogif9iQF3H5NEU+yZDncXmWIs8w5Clc7lDkkw15LJdn K/IphtzC5dMV+VQp/Vw+Q5FnSum/kclzFPkjUvq5/FFFPk1KP5c/psizpPRz+UxF7pDSz+WzFHm2 lH4un63Ip0vp5/I5inyGlH4un6vIc6T0hzD5PEX+qJR+Lp+vyB+T0s/ljyvymVL6uTxXkc+S0s/l eYp8tpR+Ls9X5HOk9HP5E4p8rpR+Ll+gyOdJ6W/N5AsV+Xwp/VzuVOSPS+nn8kWKPFdKP5e7FHme lH4uX6zI86X0c3mBIn9CSj+XP6nIF0jp5/IlinyhlP5WTL5UkTul9HP5U4p8kZR+Ln9akbuk9HP5 M4p8sZR+Li9U5AVS+rn8WUX+pJR+Ln9OkS+R0s/lzyvypVL6WzL5MkX+lJR+Ln9BkT8tpZ/LX1Tk z0jp5/LlirxQSj+Xv6TIn5XSz+UrFPlzUvq5/GVF/ryUfi5/RZEvk9IfzOQrFfkLUvq5/FVF/qKU fi5/TZEvl9LP5asU+UtS+rm8SJGvkNLP5a8r8pel9HP5G4r8FSn9XL5aka+U0n8Dkxcr8lel9HP5 m4r8NSn9XP6WIl8lpZ/L31bkRVL6uXyNIn9dSj+Xv6PI35DSz+VrFflqKf1c/q4iL5bSfz2Tr1Pk b0rp5/L3FPlbUvq5/H1F/raUfi7/QJGvkdLP5SWK/B0p/Vz+oSJfK6Wfy9cr8nel9HP5R4p8nZT+ Fky+QZG/J6WfyzcqckqtNEB78pA0QDudiQHarEPKCO57WeEzUvhMVeh8WFJ4ixRuOqwozJQVnKSQ rip8KiukkcIGVeFGedIwiBQaqXOCNFnhNlK4X1X4SFZoQAqvqwoN5TlBxVQonFcV7pMVdpDCAHVO UCQrvEYKT6sKf8gK80nhuKrQX54TjCWFMHXI/6is0I8UJqoK62SFW0jhZVXhZ1nhnylQOKgqWOQ5 wXekcL06J9gkj+g/JoVidchfISu8SApfqQrNv5cUHiWFy6pCpKwwihRu+15RGCcr9CCFBFVhsazQ ihQeUxXWywp/ToZCkapwTFY4QApfqAqNf5AUPiCFalVhhqzwNCmk/qAoTJUVHiGFMarCYVkhgRR2 qgpfygpdSGGLqtDjR0mhOSl0/FFR6CIrnMmAQltV4XlZYS8p5KsKS2SFt0lhtqpwUVZYRAqnVIXf ZIV0UvheVRh5TFKwkkLcMXU6LivcTgp9VIWPZIWGpPC6qvCurHBqEhRWqAqtj0sKZaTQQF3YCJQV VpHCPyrDDFnhcVJIVRmmygrJpDBGVTgsK0STwk5V4UtZoR0pbFEVepyQFGoepvJwQi0PssL3pNBW VXhJVthMCotUhUJZYTkpPK4qbJIVHiOFYlXhpKzwACnsVxWanpQUIknhL1Whm6zQmhQ6nFQUHpIV LqTTx3pVhQWywkFSyFYV1skKJaTwsqrwjazwDCnsVhXqVUgK00jhrKpwp6wwjBRurFAUEmWFMFLo ryrMlhUCSWGSqvCGrPBrGhQKVYUvZYXPSWGLqlAtK6whhZ9UhfanJAUXKQSeUhQGywoPk0KkqpAl K9hIIVlVeElWCCWFRarCTlmhESl8oCr8Kiv8NBEK36kKrX+SFHaSQoOfFIUIWaGIFG5VFcbKCrmk MERVWCwrjCOFx1SFDbJCDCm88RN958xztOs/9AbfuaOygmOtk8qvNKJPmpXf4Bkevt6IT79uUKZf LO7OylM/8y+87jC4pPPJIxjXaoPrAc41W+GaLrgeF1yvGFzSQeRGjCvX4GrGuR5QuIYLrnaCa6bB JZ04/rghcSUZXNsb8vcOCtfdgmvzT5xrpMElnS6eyrh6GVzZnKuFwtVYcD0guO4xuKSTxB0YV2uD qxPnOnO9zPXT9ZzrwinOFWhwSUeGDzcgrj+u93B934Bx7VG4PhFczwiuqus9XNLZYBfj+tLgeopz va5wvSy4wgTXboNLOhHcj3G9bXDFca75CtdjguvzCs61yuCSjv7+4U9cCwyuS/6Ma4zCdb/gelhw zTW4pGO+qxnXeIPrHc4VpXB1FVyNBNeDBpd0uPdBxtXP4ErmXC0VruaCq+gk5+phcElHegMZ180G V0vOda6FzPVLC84VI7huMLikE7k76hPXxRYerj31GdfnCtcuwfUDdbDOnfRi+q8HaWTL/6581wg/ QeGviPB5J7jtBtx2JdvZwX2Qjtn2Yz4sN3yI4z48ovjwsPAhEJxaRhasVJVxK3/S4IXaMfZuu3Je c1IUf46qfET+01o5Dn9W+v0tN3+1DhSuq0fuDGrucWd9Pb5aoVRf2jJWufGv2jzSQcE0xqM38/BM 4Tw5Cs8jxPNIHR7pAKCZ8Xxk8NzGeWIVnj7E06kOj3Sw74gf8Uw1eH7wYzxBCs91xHP8Um0e6cDe UsZzu8HzHOf5TinKB/FX5Qt1eKSDeFbG82NTD88QzlOs8LxKPMPq8EgH7EyM53mDpyHncSg8k4nn ujo80sG5DSbiGWrwbDXxV6MKD1X+yu3VtXmkA3GZjKeRwTOd8zRVeKhKVD5ah0c66BbKeLY18fDc zXmOKNViP/6qDK/DIx1gO6ab6V2QwfMTAmj1UeFZQTyVF2vzSAfTljGeLgbPy5wnU+FJJ55X6/BI B84SGM/PjT0893Oe3gpPN+J5oA6PdMAsgPG8YvA05zwBCo8f8bSowyMdKCutIZ6RBs+uGsZzIEjm +Rx/Ve65UJtHOkCWw3gCDZ45nGelwvMC8cyvwyMdFQtjPLuN1bjunCdD4Uklnqg6PNLZJe0fs3gH Jnh+/YfxRCo84cRz7s867Y/Bs5Lx9DB43uA8/grPP4HgebMOj3RqaRTj+S3Aw/MQ5/k8UOlqiCe5 Do90ZCmI8aw2eFpxnucUniXEc2MdHum8Uvll4kkyeL64zHiSFJ5RxLP/fJ32x+CZx3haGzxPcJ5Q hac98Tjr8EgnlSIZz5eNPDx9Oc+55kq3Tv1XTB0e6ZjS2b+JZ4HBc+FvxrNJ4fmAeC79Uaf9MXiK GU8/g2ct58lVeGa5u9fKlo3Er6pbjOZDOv9GdPlNqHqoh4yimZ3DDT12BnI7psaynUvXue2807Cu Hemo0Lm/yM7h60y1jwodIUHeVMPOD38xO3uVVe6dHjtxXuxIB36czM4qYUc68JPJ7DQy7Ezndry8 bWN2vm9Q1450bKc9szNV2JGO7QQwO680MNo/bidFsTPGYyfbix3p8M3GS2Snl7AjHb5ZeYnVf8PO G5eYnTDFTiePnWZe7EhHaIYxO42EHekITSSz86W/Uf65ncsBsp0/A9x2Xveva0c6CFNZTXa+DjDV PgizjwR5Ew07h6qZnXLFznaPnT5e7EjHWeYzO68IO9JxljRmR69vjP+4nULFToHHzsH6XuqPQXcj szNJ2JEOpZiYnecNOw25nbGKnQc8diZ7sSMdLXnvItnpIexIR0uWXWT9v2Hn5YvMTmfFTkePnQZe 7EgHRGzMTn1hRzogEsbs7Da2mHXndqobyXbOuVubyhX1vNQfY//28QtkhzWr4oRH5UPuGJXJ7l/u YxuV/T2yOFlGBzEqb/PIOskyOlpR2dgjaybL6LBE5a9+btk5P0lGO90qv/LIDsoyOtBQud4j2yjL 6IhC5Yse2QpZRocOKud4ZPNlGR0jqBznkaXKMjoYUDnQI7PJMtrqX3mHR3aXLKO9fZXNPbIWsoy2 41f+bnLL/jRJMtpgX3nII/tGltGW+cpNHtkWWUab4Ctf9shelWW0rb3ycY8sX5axD/en82Iy1Xhy FDqChz5gPDMK7cNDBxhPi0Jv56F3Gc+JQlvw0NaeaaZ7t3bqebMpuytter55HNumzM6E0Ed3oj6i PY9ss6M1qjowrxP+1t6wY1bb7iPPNrc+iG5ymD2Fnm4TJENrOazmsNL4TNCzxv7HETV61RO1rnHg 638jati9DFH2GnYFA35unVhT+8YH/v5LqDbnqpWND9S5GYKv/w7nej/dy/U++9q73i6ht1XoLfah 97LQe07oxfvQmy70pgi95j70hgi9gULvy6+8690m9G4Rekt96NUM43oXBnO9YT70Dgm9L4Te9T70 1gq9N4Te1/u96z0h9OYIvUIfeg8JvfuF3n0+9LoLvbuFXisfes2HifM10vrfObPJES7K6bPnzD6/ XGWwlCdwa6U2bm38Pk9BTzzHWvjB/nILP8Bf2W+w/rKuV7Yyem0zj9NDiROmxnmc4pwweqzTZ1kc ixKnrRpnCMVZa8TZwOO0UOI0VuPcRHEeM+Lk8Tg19eU4F+srcX76G3EGGnESeJwqJU6FGud9inO9 EacNj3NEibNfjTOH4vxg9KbabyzOTiXOVjXOYIrzlhGnhMd5X4nzthqnFcWZbsSZx+O8osRZpsY5 8Rfi9Dfi2HmcxUqcfDXOWorT3IgTwuM8qsSZpsZ5jOLQVUVS2AQK26WGDaew99WwvhT2shp2B4Ut UsNaUdh0NawehY1Tw369hLAhati3FNZTDdtFYbepYe9T2PVq2MsUVmNSwhZR2C9q2HQKO6SGjaOw T9SwIRS2Vg3rSWEvqmG3UdgTatj1CKvKlgL8KCBFCjhbjYARUsCPFNBfCviCAsKlgC0UYJYC1lBA oBSwvFp+/02dqLNaeQG26Jz8/psUcs4pCvtlhXaksE1VCPldfv+N/qGy4e+KQpKs8D0pxKsKb8gK m0mhUFU4IyssJ4WjqkLEH/L7b1K49Q91v5Ss8AAppKsKn8gKkaSwTlW47rz8/psULqoKCbIC9X+V fc+r2z5khYOkkI+Q2vcT0RBPO9yXuhV2yOkOq6tbUJWZPoKf/guAfxlfa0ldRn6po0md64ua3O++ vugbq8nkub4oRPtkiPfri35JJGPNlhO7t+uLNg3kX+qud7+4vsj5C3OnMYDCb3rgqtcXzYCq58Pj 83/x3SeyD4+btY9s3GSX++tcX9RZpup+daoMm3R90W/38S+V/zymRhff2ze+Z53Ab6qNL5gQYHMN CbLm77E7TzrCYlyN7M4TVudn/L6jqAHm2U2srgdDrPlHs3+vam513UuqVue32Uer6ludX9ujTjoC EKkXFCduoyNoWuQYdvVfjKtLjHOy2XMCreA+s53uCP9BW9Cvhn3UNf8rx23gXeeX3cQWdcDRsNfD 5sCXSgPXV9udv9qdx7V3MQyz6QNDq+h2W+2pGKL93u6swtNC8TmCshAgHQesfT9T7ukQmxNj6200 1tZWUTlxbRPjbvo45wIx5nY00LrH0HcmV9Ox6XjXuwzyzzjGW113rdHw1Onr8FXdxEN4T/P9ECx2 5wWtchDd5SnyG97aje9zWqN+y95AL8d2RtPnRNn3Obfxz4k+L31OdEEf9/c5/S1Cwe2z8UHRx6OZ zwHc5wDhcxJ8rv6Z+xxU5R6X/fOzb5/N5HM38rlVYDsv/m4mf1tK/vLviT4vfU/0cG/FX/FBUeZv qMffr/rRF7e20TxJaziKPYx5QtFzcHDBPH7kC/xz1bOag8RZzbnqWc1B4qzmXPWs5iBxVnOuelZz 0FgRrJ7VHCTOas5Vz2oOEmc156pnNQeJs5pz1bOag6JFsHpWc5A4qzlXPas5SJzVnKue1RwkzmrO Vc9qDjKLYPWs5iBxVnOuelZzkDirOVc9qzlInNXsp4Sy259RkUKkiiTfT6DUJ2u8c7fNudfmPMhu PfsN1VQ7OoDu4dxld/5MH9L9HH85d8RE/RCYvxPxY3Jr/LIftLra9jnF2tA5pzxNupXfV92bzTh2 QvZihUfGLmb5QTMzGVmxOj+xOy/BTat0s0aLB2v0uPwLgfkFfuwCtW8qmI1NCg8V7iM23ty4Wq6t kO2TbDOT/QjfmY3KWjb6oGTzfmbV0Br2bjmADrXH8J7GTD1NmDbKynoadrpxnR90/Gl28wnNlZgS OpXsIRR7N2XYw0OY2/aCuz6NoQ+UdCsncF6wBcb+ye4XZx7tpC8IzuXTMiKIcBPUaJ3wM/9oPFen NITYWI+25yTv0ayuROrpGtMl3Ua3dpLaXHbDYqehzF1/9uRd3d46ybLtTgYkjxpOe1l570Zdkdn9 /YOT7HWdyTPgXn2SDbhLTfKAeyP+4jn2yBCe7QXdqqJ5fgVRfkVqoYOYA+xT2FZXgxbM71K06PVp GYJuB6LGi81HWUfxozadqFzd9BPM1XkECF06jN8ZQV5Xfs4dZoNY6pEnM4nnEtMKxHE84H7/dYKa w+5Gc9i1Vj8arVn61+hIu39eqWMmM1A1FYThZ6Txp1v1Ugx3ktIreu8gYXXKCan3zjlxld47Wlsb I3pv4gsfwnvvTmyEU3uMcYNM3fbq1CNi3M9/T3yNzotpZdsavdb9bBicJbDrSB4aS3fmjLYW3BsA A5uPMwMbhAE/GPArSNCdLXKr/bJ7kFfOH/UEJPveptB+8kra17m1Q2AkQTYy8l8Z6XTNRqJlI78f +zdGyq6kLRsZGOb+/hdiZHewueawtrqBdjSSurq+/I8vIuk4PI1aHnJfdjPumO9Ht5FddPMCKkHV 2jrjNxrf0L1T/GagvlbXDG1To/TA3Vq6ncpLmdWFcdsklKTRloDwr+zOY9aLf9J4zdX7G7rKZny8 qwcrqnZXKMZ/Ie7xStTx7Jtsrvs0m2t6gLXX/Vp2Uxp7dYunC10c7W2u7tb8Cxi1IUb4V1ZnOZFG fRtPQ8kLjk+qmhF1AN3Ykl+aPXAb9VtaJ1o8dH/8kC7LcqFpsgagxRr6I2uxQqix2h0dxDX4MJ2N Qbdrzfqw7wcE1eqhqJ38ZKz7fiR3dgTZnF/YnAdsNMj821ow02x3TUJrSBcljQhhd2RpbTEiLvZz tGaN4iHt7h4Y4/O8yQqwOQ/HOyeEIN8Gu/wv0Wwj0OpCW9KQ/rQ7w6o6Wwuy4P0A2Glod2YF2VwN SauF1RVNmQEKuzNiP8V3Rlyy6gNC7M6z/HIj4Tjz+7EEqtaTQrX3YLxqPlpIbcEQ3oIkJVBZGege +4f9gCreXZSTnj9QObnBKCeBRLYlSV6wFfcYpfXh04mx3Wt07d4erBXWOggbR1mfslvLTaI5gfu+ HzEZsOXqfoF55WzcWm3drvUJzN+LP4YUWP7hg9mftQdZ/B3sO1d4SNrRruTznCDb7oH8AaIATLAV TA8K/8rm3Gd1XppQ677JKKsrBtllu3jR6vL/mjLwZmSz1enH/nTSoAWxsg9Vmak9os8eQ+RsbnVG oDuLMjn8Bzub0qVt2StRrWwFqHhseJnVDSNU5xw8xVvc8wLKcVvBQ2FwjQ23KhNpKtkzXr7i5xrq 0422//n6dMr2X9SnOF6fvhnqqz7pRz31yXt1emiAz+qUNcYoD9denz4fptSnIfH/6+vTHfGiPiVH uOtTj3t5WQ+MV+rTsW+l+vTLt97q0+TRXupTSE9en4LuQX36+x5en74ezG24+MBMu2f0f1efmgxR 65Ory/8Z9alD12usT7/Y5PrEl3fmn6ZvvqEIYwLOBn7sa1hau35iSLwrz/IEFDrS+hD9YF9y1vZh khnjmhFA2Wm5u0aH1gK31gK3FglXR/OvCIWyRR2tfBANbfCkUIs0Kn669mEfMeQ3VlJOHKHXv+zr Url/645mUKPB8829UGqaiD/mdCemto2O0DizvtV1bzQN+YPo+jGr0+5PhdVKIWYMWzcdZsPWIPo7 lF1F7v7+EWJnZ0Aj7YisAVfHau/QCzSUeFCH1KJ2X7LDvgKlVfSnMldtnV9GOalcjxd2hEquxSi5 ZiFozQSdDUGotBzXSOfLcfQ+WRuITqHyzxplve5eWaEjKUTp4rrzthcOXUOGvHnIR4akHZZeEU07 7Hu808xj/3X2IBrcdrhODk669xpz8LUYXmt/Gcwr6NOjjPsUfZTPub2vWD7D+hrlM+/OK5TPRn2V 8hkaV6d8tuxVp3z2P+S9fIZJ5XNKFCufEw9ew+O46aCPx/HNQVE+yw/Wyd1mg68xd2OjfZbPpQd9 lM8ZB6+1fL4RcZXymR+hlM/7D1xDhlx3wEeGlB+QyudXB66lfDaIYOXziQN1cvAz6zXmYL1+vHwO tvLy+ft9VD6Nuz4bXPramBe71+N69bkZJrObU8/jF13D7850Z3zrK7j+Be/K4tF7VX1iNNdLjfse aUcbqxGX3V/c5JXiYSpz4mueKPE19USJpx+8XoT0onpB5RvJmBTKKobuVtPrSRXjV+pJwbWS7crZ bOG3OdVoDftTppWwv92V5GftbA9RSfK4gGfATV9TPWFfVkU9CcwL8hOLC9zdjyNFHaahlet+TXus p1IZl9M8uKC3hcwuYXNif4vLqrELLsW6U3k/HiwMvvkVGVzNXDOq6zMs9D2ExugU6mq7f/81FMK8 /T4K4QDGx7bpuBrc/VWdcpU18BrL1Vu9WRsxQPZGfBeVxVjsz3+TT+LLq64GZ/a5Debxh6NunXpj PzmXx9drntpfS1d8D1fbFye76MXm7jyL+9IvisS+6/s3tYTzy6j0uccYojhb97PlpSeV5aUFxvJT KJcvUeQLDXkAly9V5E5Dru1j8qcU+SJDXs7lTytyl0l5z/noP+IlF30t/mwXOk7/j9Jq7a2RFL4k hU1qs1YsM6wlhedUhhWyQgEpuGqZkBUymIl/WMNYOYp1crsqnxXVbwlbMNtVFcdaTU8BL/9Sbv++ vEr7x8w06MI/0+iuDfkyxZJrovjkblZOl39xDbVmyBc+ak0z2W7ra7I7mNlt8NkXdapY0IBrrGKD eDd87PN/U8UWfX7FKjbgCykl8V9cS0rm3cVS4veFj/oY3f+/qI+TInm39EFMnfngWD5gwmw0/Kg1 N0dD5XgLUZT5SG5OtSmHhita1/7s6t7A9U1Dci91zEZjjFZW32ON+izrDnvBJD9DM4Br9odqKKne aM3dUa8qgN9vp++w9hqlTVtd2c+PXTyZUA/Tol2xln4o8/i/1UnFONEy0lpgtyTYEWS141c0GzD9 qhXgYdvHH4v3O01PLoz6lRr6CvjrbPhy3NrpGwoPZaHfakuoR6VLL91z69BYlLUEu8tusVKpiw7c areMDNzqsPSjzfJBTtbnkQMOi5lSMoUNW0fTmv+P2qt38p4oDH2K1fmJ1sLMV2DN2u13iluNrZq9 03HSwdS2hmZ/zaLdcUAZog2J4dUsRBSSW/ai8x9EsjAylxTJV4hX383VQoXaxc+gFkUh7lXJUxQS jdHCWGnyzMva8c+orPUxylqUu/1jgv6GoK8QvMsEgwzBAHn7AxumOSyjtON30Fc1dPUrKx7pDpI+ oEpHC2mo9jpJ49lrmh1yytrCtMN9T+Ltn/muJYHcyhjw0GvqHXJmHPlUWjo/8alvksacJOQOPtVf 2dczaHc/kIJP6Z3If3TPBrZnfNMFLunqSf3OTvRFAV3sh+DVyxzj/NLqPIhKhvGfvSCFLzP9zFZv zml/sEU9/PWrFklvUscftvv9zlofVKtO+z3bGz428+EOe4XQt7vaTP+wB8WgGYqBWfS1Y9yl4Oge 39nwJS+MLeBz1Y5as5bFe6S8fO4KJCwvg7S9oTwvE+kVd7toU533i2hvLSE259c2558251/xrno2 JDBmMyrkPHtU5fR0q4t/Zpm+wW2m0eOZmMCtvUMLBn2TW33ddHOubnb0ytU7ZA9gj2me1a9h1Z3y esl4/yesfmf1Y25xQFXTXfXChJ0JS636TmvU59PerqoP5vCv8DsrJvyCtL6xyD/Uf1/g+lJYm9Eu euFZi98Hfo760Qv/yCu1BsYe5PGjF/4w7WAVhV7Y4Zfd1LabZjd65Sq25mOngeZRuzODlhr3WztV iibokN0ZbNGaYPhmd2WgDjwVznrrmN0NeQPtsERu4neb/6Z1Q9Nvj8qwRAbmUVcwuKCp2VZQaIGR udao/Tbn0cAFl+rR+9e+twbm/UZ75JbZnI3kmvT1brOJ7ATZXcEWauECAvNb1aO9BPViAtf7h+ZW 3x2Y/53hMDTjnd8jeZRPSKLN+VtWKP43QV2PGrDIP9KTPwE2fbct6stpv9DLW55ONJOH4p2HrM5f tPa9RGOprQ5jrzzd3w2m5o2llArKvZ0hixpNt5D+4idSOr+MEmqPOh7vrApcUIHg3NkmJJQ29lmX WSkxbP3LeHd5apfZFO/8nSU4ML8l2zNRr6qxbbefziaRvw0I3No0MvdS1tzOBTHLqCQ1yr1kz+5X 1dNa0MxyCys3861+5fqxAYHrYyP9cqvTsttVtc695HCgd3ssu1VVC7cgI7uhLXd3var6SDzlRszC +jZXvf6cP2VOi9xLU+aacy+lOrrkXpqQnVDVOPdSnKND7qWB2Z3I85B51/lX9cy9NDW7PfVAIa7G ucc/zN0TXWXhUpufX9XNuZdGORpVBedeyskOlLUCnI1hyD8yt/Tj3OobZtywsZEpwBS4anvWde7i Hs0uZ47tpMX47Y7F/F153e1uDL7Y6WMG/yETdDME8va8t2p46xbNSvdB7biFyu8vKIyVS9Qx77J/ hGa888t4at6+1kqY8rfxzj/inZcqZzCFPjtvxYCkp5k+lcG4+5RQwKPtEdCyxtM3mKvugOgFEjUn 3d8uM92FFBBPuqZ/6vQjB8ukZuvHsqs0W9FaSwtvtlZE1igvTOX2a/7pZWw6+3msc0eMc6/ViRkl GnO7azO7JoR183yO2po6lNx/dEdz3pewMVmGf2jsojVs5GbL1WWZ3TnL3+z5yznaPww1dGcfHVSO yQZDQYZ/yLzN/pfIM8d11vk7j+FHFQYuK86ydeSjGK6hrZg3M9LkaLBowANVN1KKHmxDtRDdSHSY +1vz+r6F+RR3V/5x/N/PWvAO/RW7cDIbsx5jaRlN4/AwmmATSas7eacTxibiWo+uNTpa5bLc6vFz sgqsL+Ve8g98/ANwFFifyr10XeATz9NIsTo9MI8d4HD1Wf+JmRr07+HAJrqjQNuJHIpdWGRZwoas fZ5j8hL2J19zKLqDfTt+F8UIEtObpQjTZt5Yo+dWj5wbWGD9OPdS/Wn9cqtjHD2rXsytHuW4J7c6 2XE3vMp2sVc1gVuDwktpTxotXmjD0KZW3WYtaDCa7jge33Sh1W+7fpy/Yino1heWmLLW6S7a4yK/ 5l/wCVuSYGm569PtZn5BmiuezWhC3LMIumrJKmYwDWZtN6YfykmRXoxrDZ9q3/aJrEUf+NcmsS49 DoP6+JBa9J6RK62sUCa9grbTeQSz62V+yofz2fTPcL98Ow1ipJnvF9upQqQYFWKsu/5vZ1Nii5+y bd7PE/FZLu+oyG/xEy+qpLw+hQJT+VFNnVMG7KqYYjZQvmt+6ZUzEmW2QbdSH9l4vlSaTtWUXmU6 xcyGM7MN3i+tk+cXI649z++8k8+fsiJq5CbvpJikM0u729EXqdRZfHPRegZpb5JUh1QLbEWflbrM VzmpylWeqrVhwyQ207ItG91pWjZHMznGS/OxOXyWdVF7LYImHd3Rt9+SW83mYwMxHyu3Ru3IusPQ muXWir3Fj9QeZnOxphM84yeajz2E+ZgyJQ4JL9Wuv4Ovcod4dvoEaH078HYhiKiHRfDBqLvYDduG wej1NCMK0VrewtYyQ6WNEbZtvh/ap3yz61zEqtpKTTvaoHr3eEbnbgu/bZVa+Utbr9LKm7Uut/BW /qOunv2ycvMepKyQLvWskFotfIV0JV8hbVhfLH3SD95aXegorZDabmArpI3cao3qSyukezvyFdJi MZFfKFZIKzrzFdKFygrpF7d6Vkili4+qt1AT8otnhdSs9j4vdCATGTTkvKhdbkPFlbbC0RR1SEel HZ/amc9GA8iDcZ3FXEKslgaJ1dIX71DnGI8x62vEcqn7UaSw0PXSculrm5WFH7l2D/A0k/dt9lG/ gxnfE3xpRd9cp8rGhqtrOVeqsjm3s+WcFrJDfGXEvVqyVFrO4Ws3DT7+2Fh1KRbLOWeNZ+DYzPzj zXjS5lq6sMxuK3s5TF2hqWNzN18+crtLh1a1PbexFdOg+lKb7q40wZvNV1wzPf+x+Yprpge43Oea aQmX+1wzLeTyK66ZThRNYQC7n/YmNHH3qU3hpzWSwnJS2KCOH1fJDI+RwlP/eBlgCoUHSOEJVWG3 rBBJCh+KNdPRYs30OVEhH+zN10wHik7Ts/6/SepgVmy6SgfD7Oy7UW0AE2SK/1wTRQGjaDth4zXU nRs3+qg7RzZKdk9svBa7LZndBs9trFPRjt517RUt0MK8L97wbyra8A1XrGhN5MS0vKbEWENYYvbU JnbXyoC7/otaeU8H3u/P7CzPEJT9aQl110+f8L1++nvna10/Le98LeunN/P102ixftqFrZ92ca+f DrKyVVMERdL6aZhYP42/UV4/NXvWT1PvlNdPQ8T66dA7+fqp2HrkHgvQuO937ff2fLofRD1sfivP 5mi2NvpnY742GqQ1aVV7bTRArI2eu8Mdh73K7NpZ7XfqfeReG2VLsQM68LVR143qEurR9e61Uffa wJ71Ym00oU5zunO92fva6Bom8LI2+gwTXGVt1KrtbOl7bdSqrW7pe200RHO2VNdG3SnzWy+tjTZZ 77smBHIrMS2ltVF3Zmz+UBoy7frwKkMmq3Y5mA+Z8jrV2dDwyIe11kZn+KYz1kat2pvBYm20zvpg jtXZ22Jn73r5QpiubW5MkzH8wkhk5Q1io16DCyWsarMGKSD8TP5Rh80+/g97QR/6KiGNfQLc9Y0N vNgAqEbLDKCi1+Y0pafiBjYuEsXzfkis+k571J/TvqBx14QbqFC1sbD99QXdhoF1UzM+edbuCJAW YAs6qYV0DBzLDkRZy6m76jKqxHduf06MmdqTsFu1vVY+X1ciPbIbrkDSmJPQ+JN8249hT9UH8mwC 7YW0/+DRD8xe9h8sR2h2K4o/vx3nudSk1j6EJR/49mEXr7w7r4ftTZi/WF2DAqQDJ0uvYT+ms93/ /H7M+8z/xX7M/nw/pu02X/sxp75v9uxvdlqDam3GHBbsczPmT5jL8PN3/3I/Zp9QZT/my43/1+/H fLGD2I+5v7F7P+bq9rykzO3A9mN6xj/voeC6j9X95z2zl/2Y33eV92Nex/bDO4OUXZ2N35OKf/B7 Vyn+AdrgIN5R97+uRtfuasx3czYQHm6x8M04qWwG6M7/f7Ofs5dF3c/5cYP/M/Zzjgi4xv2cN5l9 74/G1DcerSdKBr28yD8TmPeCiZ29yn+XjhzSMZmHxJNY9K7Z+xryI0wgf8vEeEQR1Ay/2Rzl5g4j sDNfFnmagjFeqLKy84msENmjLmYvcTdO9MdyeohpjfAI8s9kf21z9bbY2Gkofk6xi7/7nGJc7TNv /2I/+HU3/8+3Pwdv/i/an768/dnTnh23dV+7aCuYHUBjryDtLEq4++pGqe2xOyu1D5v4bHse7sKr wFftWA+o3dQQ9aRBI+orqKYcbctryjPtuVqvLsp4VzlffJAPeOMLJgbER513xMS4JptiXAPNUTtn D7O5kkLsUX8E5p1mFeeidisKaFSaObDgJHPXGmLN32MLjNtlD4w9R5+MXcwWxueGmhwjEdfsGmCO 6RVnmj04LvxCJd3mHH40SgssmEBaEDPqy4K6EXzuRdS0EE4Pgw47B8adtQbGbrc7/6Dp3t0s3lB+ DPoPx50xrjh2Hsrq/Mw1AoOje1HeskKi9lkD7eesruZQy66I2mdz/jC7DRyw9UoKCcz7RYwARjXi L+5AEb4nJmqg2RoY/40dESup5UCcylKTx5ojQqn/NufeGBqO2TAID7LRQfaonbC5nzoV2DwWtTPe +dPsG8hm1HeOHGpxKhsyc+GlMVFTzPbA+GMwddbuPFk1BlpVozypOunoOGEppWeASM8Ilbsiaiel J1ikx3ELpWWxTI50HCFyejl6khp/57e1zmCL/bWUpzV06sqM7imEHoHDRK81Z7LBf3l9OkyMwvV3 9jG+c9Rbe5PA+zk6sOqpek+25of9XU3srvGs1p21XTyPgjbY1bkSVd7xkNU1xhRPUe4NYe23Peoc 1beRGusnRX3TtdQQXt+srnuovt3uqW+gs0f9wj6H9AfqW3MivY6tQqPC1QsvrZVedv9tZ9ZZC/+t zlMjrAVtM16hrv80amKDZPazWndcT+Od3KoAfR/NfhGSfY7RjdlhYrpa0q1sJBWww2T8N840NduR me0wjXBMS02ePDA+5t7UaVNSM3qa45MzM1NTzHEZqZNTpziyzAPSkqdMTE3paR6emjE1OSU1haIP CY+YnJwzfurkzPSM1GlZ6ZPDuyZkZ2SMSJ8yacSjU8bHmWr9V0c/kql7VOvydY9PnpI8MXVa/4yp 4+tyerEv61/dfni3WglXo+iN5L8CTDOtI4dOmJCV6hiYntPT1Nlsum/ICNugIXGxptmmxJFDRwwY Gp9gj4uPG5JY2zL/r+VPNfqt+NcF/x7CvwL8O/2jrl+S/h0UKIcfw79Tx3X9+hOYt5zgWCP+lv+R 7J1TQOnfHz9xlMPpt4/8G5E+OS5nfGqmI33qlDgTpEmTs9KT0qekO9KTM9IfS+1pzp4yacrUGVPM qW41r1qmAdYY25Ake9yQQYlWU0xCQpIt1jQ87n6CkcnTpqRPmdjT3D/dkcXy35ydlZplTknNnJY6 PtmBcuemnJGc7kjiOknp0x4xT8ieMp5stjeNSBweFxOfNHD40Pgk69ARie6AxKHiTx4pvJvnV7jn l/tHhCekh+fXPbXrgkcS5f4V6f7RNdw0IDkzeVx6Rrrj0eGpE00D0lLHT8rKnhyfOnnqtEdNyeO7 TRg3blxq99SIcRHdw3tEjQ/rkdwjuWv38ZHdI3qkpPYYnzq++7hxXXskR3Sd0A3akRNS7kmJiuye Mi5lQnKPrqb0CZkTk01ZE5INp0yxDwyJibcNSBpgHzrg3hFJcUNi+ttRAm0jkkbY4u+zxyTahg4x xccNSBpxX0LC0OGJkCUMsMUljbDH3I//s1yyDRnEA2PsKL+swA65Lz7JNjBhUEyS3Tbk3hGm9Cle 2oW706cmJSdNmDptfGpSSnpW8rgMNARedMZdgw5vea6mOC17StL4R8dnpCaNn5o9pa5D47OnTUMD lXQ1vZRxE5PGOzJSkpIzJk/NciSlTs50POpbK2XqlFTf0qtERnDdhCjSpMz0TCR63MQrqT2SnZrl PSHkHeWfV+GE9IyMpIzU6Z6SW0uckZ2VdlV5liN5mg96Q341FtRx78LsK3qIhBF/hm/pdDQy3nOY xUuanjreMXUarz13s/8jT6eBL33ilOSMgVOnzUielgLvYlKSMx2p0+4eMTAmaeDQ4SNjhseiPpns tvgYNFVujOE/YuJNsbHDI5IiIgf1ZyFUWUw54++/LyohaaB9UP+u4WERSV2T4kxDWck2394xvOPd Hbt2vN2cnmUen5GclWXueE9H84y09PFpFDRlqsNMbW+yIx1F3zwj3ZGGOBGI0w1xpk5wx+ne8W5T wn12O/43wmq6TzS/tqFcfrcpyzE13dQxyxQ3fPjQ4T3NaMYTpqVPcUwwo2pNTiY/TLczY1nZmZlT p6F5bWxqbO6fPH6SY1ryeGqr3ZzjqNc0T0mejEA4b0pInoa2mdLBCSagaqWY06eY70b7bEZBS73b NDAZkGJ2TDWPx+NwIB3JjvFpU6ampJpT0qexB/Go+fa6ahMyuZOyktfxRFbavxpPQJ2p+t1cvxd9 M54ueS87/4++GL/9MTDTrjeZIoD+N2CiCCztazLlATcPMplKgKPQd1tuqtEPQL/slho9APoWTEfo +/zBHWr0NGARcCnQH9PxEsLbanQz+ArvQfxgkyk2pkYvBKYA1wHL4mr0oJawY6vRw4DB99boK4GF wM3AIqD9JpPpPDANGGyv0fOAEcCVwBRgNPjzgKOBRUC636EMWAisAK4DxsbX6HspXUCNwoH+sB88 BP4B6TsfvcmvoYgPzAPuI38TavSzQP9h8AP+WIBpwFhgHvkJPAI8ADwP9B+O9LSCH8AwYOyIGj0B eB6YCSxMRP4AS4BrgAeA5SQHVgAt99XoptYmUyKwDTAPGAksAiYCy4CZwPPAxcDg+2v0YmAEsAzo AB4jfeBl4AFgSAj8GlmjRwCDgQlACzADmAJcCCwEFgHLgKXA88DvgBGjavRq0gMG3wh/gGHAIqAd eB6YBox9APkBLASuBB4Abgb6/wf5A4wAngcmAoPw3PKAnYGWB6EHjAUeoecJPE9yYNDNsAPsDCwD WoGW0TV6CjAPOA9YAVwJTBwDHqADeARYCDwPLAEGtYE/wM7A2IfgN9ABTAMWAvOAJcCVQP8kpB8Y AfyO9IHVwBRgcFvYBYYBy4B24HlgGjB4LHiAFuBK0gOWkhz4HcmTwQOMAAbfAn+BYUAH0A6sAGYA g8fheQAjgEWkBywFFgGPAQ8ALwPPA0PaQX88niswApgATARmAB3AhcBCYBHwALAU6J8Cf4AWYDXF AwaboQeMAPqnggdoAWYAY4ELgSnAImAekHb1nAceI70J8If0gHTndQowAlgCTARWADOB/hNRXoEW YDEwFlhG+sBjwDzgZWAZMORW8AMjgMFp8AdoAWYA84C0w7AIWAQsA5aSPB08wELgZSDd6xbSAekG RgDPAxOAwQ+DB5gHXAwsARaTHrCM9IDHgLGTUA8tyEdgG2AhMBJYAkwEWjJqdAcwEbiU9IBrgAeA e4H+k9HOkBzo35E2DKKdARYCewPpXspRQMsU8ABjgUuBecA1wBJgOekBK4AVQNNt4J0Kf4AWYCQw BZgILARmAkuAi4FlwGJgRCZ4KByoASuA/reD5xH4A0wE9gY6gKOAhUAHMHYa2k9gCnAdMA+4F1gC 1IAVQP9Q8GSBBxgL7A1MAY4C5gEdwCLgUmAZcA3wALCc4jmQLqAFaOqEeMA2wDxgJLAImAgsA2YC K4CLgcHZSBfQAiwjfeAxYAnwMjB2OnjuAB8wElgITAQeAGYCzwMXA4NngAcYASwDxgKPAR3Ay8A8 YMid8AMYASwDJgAPADOA54ELgSk54CE5sBwY8SjSBUwEmjqDD9gGWAiMBJYAE4GWx5A/wETgUtID riE9YDmwAqgBg2cin+8CL9AMTAT2BjqAo4CFQAfwAHAp0H8WeIAWYDnFA1YAU4Cmu5EuYBtgBbA3 MHg2eIApQAfJgUuBRcA1wDJgOekDK4ARc8DTBX4A2wALgZHAMmAisAKYCTwPXAxMmQse0gOWA0uA FcDgeUhXGPIdaAYWAnsDS4CjgAeADuB54FJg8HzwAFOA5cA8YAWwDGgKhx6wDTD4cfgDtAATgbHA TGAKcDEwD1gM9M/FcwdGAI8Bi4CmroiXB3+AicDeQAdwFLAM6ABWAJcC/fPhD7AEuBd4AKgBzwP9 7wHPE+ABJgJ7Ax3AUcASoAN4ALgUeB64Bhi8AOkCRgArgLFAUwTiAdsAC4GRwBJgIvAAMBN4HrgY aFmIdAEjgGWkDzwGLANeBiY6wdMN6QdGAouAicAyYCbwAHAxMHYR/KFw4F7geaAGDHYhXd2Rj0Az MA/YG1gEHAVMXIxxE9ABLAQWAtcBy4B7geeBGjC4ADw9oA80Ax3A3sBC4ChgCdABPABcCqwArgEG P4n8AUYAKyge0BSJeMA2wBJgJPAAMBF4HpgJtCxBuoARwGLSB5YBy4DHgIlLwROF9ADbAIuAkcAy YCLwADATGPsU/KFw4DrgeeBeYPDTSBcwBejfEzxAM7AI2BuY+AzGpUAHMAdYCCwElgHXAc8D9wKD C8FD+kD/XtAHmoGFwN7AEuAo4AGgA1gBXAoMfhb5A4wAllM8YAXFA5p6Ix6wDbACGAk8D0wEJj6H dAHzgIuBwc+DBxgLLAemACtIDjT1AR+wDbAEGAk8AEwEBi8DDzAFuJjkwGKg/wvIZ2Ai8BgwD3gZ GPEi2lXMK1KAEcBCYAIwdjnaVaADuBBYBCwCJr6E8QrpA88Cy4BN+yE9QDPQfwV4gMFAK9ACHA08 D8wh+cvwi+TAlSQHlgAjgOXAWOB39PdKpDMaeq9iPAQsAkYAS4BWCn8N405gBDAHmAhcDEwBrgQ6 gCXA2FWYN5AcWEFyYDXJgU1jkA9AM7AQGEF/v47nCkx5A+kH+q8GLzAYuBLoAG4mPeA+igesABYB q4ElwKb9kV6gGRhcDF6gBWgFRgBHA2OBmcBEYB79/RaeE+m9DX5gHvA7YCHwLPEBmw6AP2vACwwG RgAtQCswAjia5O/U6LNIDlxKcmARyYEbgLHAvcBE4DH6+12U71jor0M5AFqAnYGxwGhgIjAR6ACm AfOAs4CFwKXAImARsAS4AZhSUqOfJv0P4S9mwY6N4AHmbarRxwIjtqK+AWO34fkQ7kA9AyaWYf46 EPbLUb+AEXuQHqD/Z8gfYPBe2AGeB5aS3n7MJ0jvK5QPzIfLDiIfgAcOwU9g4bc1+kvAoqOYHwP9 f4AfVsQ/iedIqCHdNvCcQTkCJp5D/QCmXEC+Dka8v2AfWFGDdgEYUV/XNWBeI11vcy/Cm+h6IjA2 SNcXAwuDdb2MwkN0/TIwuK2ux9qR/va6ngP0v1XXlxHeDj1g4p26fhYYEa7rlnj4313XRxP20vUS wmhdPwaMjdP1APibGK/rDmDJEF3fS/4P0/XO5Hci7ANL7oddSs8Dur4Qfvo/CF7wFwIXgqdotK6H DEG8D3U9Aej4SNdnARM36Po6YNHHul4BLNyG9A2FX9t1vTcw9hPYBebt0PViwjJd3wcs3Am/EpDf u6BHuFvXU4COT+EPMPhzpAOYB9wHLPpa103D4NdhXY8gPKLracCy73R9JTD2uK4fARadQDqAFZqu hw1Hek6DF1h4RtdfAvr/qusbgMHAvST/Tdf9RyDeWV2PJDyn62OB9CnxQuCBP6BH+CfsJyLeBV03 E4p1Gb/Hhpv8coL8bm7aKID2NGKKYML00hR28h89GvMOU/Oggc1DBgc2mREwz9Tvpl533GO51SR0 ePwEO2NotDz7VbPpZjcPbSQgLmsAyqE//F6CSty/eVD/5iH9m5v7Nw+NaR4W23xsbsPFDQr8n6y/ pB50MSww0Sd4S5qiriDA/3nEiZHi9G8eFtM8Mrb5PL/cRosbFjR40n9J/SfqMTu0U/m75jX6ftj2 f8ZjK6a5maxwC6RH3yQuCqrRaS+z4U8M8ye3wWKmiOmj6Rj+NW1Ro48B+s/lfDGML7f+k/V4+mJp Dyh0dNpyU9fPmObRipsm2nVPV/UEN6jRbzfxOLn1eD6SrBCyUMh6CNkT9QY0ayjymt5sf3d9jb6o Gfy5t78ip7h0sqxNVI1+c624JDsNmdmHjO5fsviQWSAL9SGLhqwzZA96kY2GLBOy9l5kdB1WHmTJ XmSFkB3xEW8dZKd9+LIXsrOQdfKrm290z1hEuxr9Hcq3pLr5RhuBK3r6SD9kxZ0xzvDyPOi07RrI kqhsjx9QR24mOXg/ovKzra48GnJ7LyH/rK58LMUPg7w+tRkD6vhWSvEjMDbxq+v3d5CtA3dLL2mi ayVLILvRiywYadkAWX8vMrpHJaNbjT7Ni8wO2T7IAr3I6PpSshflRZYH2RHIQr3k71jITkNWSPkz om7+zCN/etfodHDQP6mufCXFh5yubvKfVFdeCvmsPjU6nWDwn1E3f80NTKbLfbznU2/ITH1r9HZe ZHRbtL8PmQOygL5100uypZC18SFbAxl9c+wuLzK6sTwWsuu9yCrodp6+dcsvO66FH3bIOnmRtcGP sT7iReJHCmRtvcgS8SMNsu5eZJn4sdhH+hbjx0ofsmL8KPEhK8OPcsiae5Edw4/NkDX2IruMH+t8 +BnSCH2lD3sRkGk+ZAmQXfYhy4AsqJ/3OrAQsoh+3uMV0RV1/byXpVLI7D5k30GWANkQLzK6My8P sgFeZMEBqP+QDfQiC4PsNGR9vMjskAVFe09DGmQWH7I8yCKjvadhJWS9IQurJaMyOQuyBMiewW// n/vVTT/J6aMJ3tL//7X3NfBRVOf6s9lkCRg+FIQoUVfAFRUhCiyoAQOEDUiAIGENGCUBEkOJECFE UGwRaaRK21jp+oWVCoZYo6aVplBppS2m8UqvabUxrVSx0Bhb9KZVV6yY+b/PnGfCfpyxsf+2t/Wy v1/y7HOe8/W+55yZM2fOzIq2UbSBOvt7SnuIdrbOftE2izZMZ79ohZn6c0ipaEsctI2ilTpo20Qr c9D2ilbuoLWKViFaUKO9L9pujQafNot2XLRr4NOXJ8bbLwMpY1KnuUxnfy884KI/35SKtmWSg/2i 3e+QbptoWzWa1f6ibRMNP+6QeGV8XQ+K3iH6UF37i5Y4udM8Vdf+p8jxeXJ8f0SZHZIuRbQslHl4 Qvz4l7QZoo/U5FsmWu5k/XFqk2hZk/X+2YFf1nao6z7Rcibrj2EHRSsXzaezX7SNDuUNSJH6TI4/ Zlr2S7p1k9k/Ps6It1/S7p2s7x9louGdWrp23iTagCkO9ouW6pBun2hpGg113Sqadwr7xw3xdT0u evkUff9IlXnixil6n48RbdMUff/oJ9rmKewfp8SXWS763in6/rFZtGZNvtb5T7RXHLT9orU6+O6Q aAcd0h0X7ZBDulTppEec7BetfYq+z+WKlpKl73Nlonmz9OVtEm1Ylr7PLREtNYt97qXL4+0XPT9L 3+cOiVaXpe87x0Wrd6hPqkxidzmkGyPabo1mtb9oe7PY566Ir2u56ClT9X1us2jeqXqf14o2bKq+ z20UDe+UtfrcG5fFz/9Ez5+q73NGP2kXTb7W/E+0cgcNvxVfMVXvuzzR1jho5aKtc7Bxs2jrp+r7 Va1oO6bq+9V+0XY7lHdItL1THeZ/otWLNl/X/lLB9x3yHCPaMY1mtb9ox6eyry4bH2+/6BkBfV/F fpfqgL7P1Yq2JaCvz37R7ndId0i0rRoNdd0r2rYA++qr4+LbXy4mOgL6vjoee2iy9e2YJ1pytr6v pouWks2+emt8mdijk5Gt76t1ouVq8rWuf0TLcyhzh2j5opWhzHPiy8S+otrsE2sxUdd/ou3V2Il8 j0u++0TLt8adPy4t9v0Y0/T+w16gAdP0c2zsD5o2Td/W2DOUM03vd+wjyhXtUo2GvUUVok3SaNhv VOtQHvYg1U3Tj0nsS2qeph+T2FN1xCHPigF46Fo/JqtFO+iQrk60Qw62N7E8XT2PiJY8XV9PQwZG 2nR9eWmieafrz0nHsEdLtBXw38dj4vRUSbtE9Fugvzcmvv1F3y/6EF37i9bqUKd60Q6Klqtrf9H6 XaU/DrRjD5toAzS27BctVbSnUdcV8XUdJhdJtVc5rP+JVuegFYhWf5XexjWi7b9KPza2iNZ6lX6c 14t28Cp9Ox/AxdwMfV3aB2K9VK8lDpL+MUPfr7yipThoGaL1m6Hvx/mDVHm641iFaKkz9PZVi5Y2 Qz+G60TLdLChSbQshzyPiDbNIR3+5TjYlyb/cmfox814+bfEwfY8+ZcvWp5GK5d/W0U7T9MPc0Sr Fw3vH0nsf2m8/fLPm+Ngv/wblqPva0fk3/gcfZ8xzpB+6pBnmmiFDtr4M9QeT+35T7TSHL1vylme zqebRSt3SFfL8rTnf5annf+IVuaQ53EH+9AWrSzPOmc+kx5//BN9Vw7nOU+kx/d/7I3N0c9zKvA+ tZn641S1aDkzHY7/ouU6pGs6E/cG9fOcHaLlz+Q8Z1B8XROlsNqZ+mORV7S9Mx3Gv2j7ZurnHKnY GzqT85xnR8Uf/0R/f6b++LBFtORZDsc/0VIctAOi9ZvlcPwbrPYU6+xIlAqnztKPD69oGbP0/TVD tFyH8vJFy5ul73cVok2bpZ9vVYtWoKknfFom/wpncb71pZHx9ou+bZa+Hduxl3aWfr6VeJboDnZ4 RTvq4LcM0Tqc7MceW4d2qhDt2Cz9XKxatBGzHfq/aOmz9e3UJFrebH07HRGt1CFP42zx62z9HAf7 gwtn8xhw/sXx9kva+tn6dswXbf9sfTuOEa1pNtvxrRHx/V/05Fx9O9aLlparb8cDouXmOvR/7FnO dej/0kj5Dum8ohXk6tsxQwILc/XtmI89zg55Voh2f66+HatF25urb8c60Zod8mzCXupc/Xg7IlqT QzrDK35z0NK8zuWN96ryVmu0PNHGz9Hfz0sXLWcO583ui+J07PHeOofz5o8vjG9/0Y/P0Z/nD4jW 72qH9hdtwNX6eXPiuXI8ulp/XvGKlnO1ft6M/eW5V3PefHN8XQsk7SGH+qzBHnQHbYto7VfrbawX 7fjV+rFxQLR+c/V9tV20AXP1fS5RCho/16H/i5bhoGWIljlXP6byh6hnTHRahWjT5jpc/7E87fW/ aLkO9jWJludQzyOi5TtohjiywKGeaaIVznWY/4pW4WBDnmilcx3mv6LVzXWY/4q2by7nv3OHx9sv enqevl804dmAPAf7RZvmoGEzTE6ew/Ff0mXmcaz+z/nx/V/06jyO1bfOj+//kneHQ33X4FmEeQ79 X7TkefqxWi9axjz9WMXzDZnz9GO1VrSseRyri+PrmoxnGhzqM0y0VgctU7SD8/Q2FojWMc9h/Ue0 xKC+L28RLTmoH6v1oo0IOux/ES3dQWs/Tz2LpT3/SQcf76B5RcsI6vt5hk+Vpxur+aJlOdhXIdq0 oP4at1q0Mgcb6kQrd8gTz5JUOKQ7ItoaB/sM6QrrgvoxniZatYPt4/HsSVA/xvNEawrqx3i6aAeD HOM9zou3X/Sca/T9qU60wmsczv/nq2fmtPaLVnqNfozvE63gGo7x7cPi9EOi113DMf7QsPj+L4ep lHyH/i+aN9/h/IdnbPL1Y3yLaPn5+jFeL1pBvn6MbxatMJ9jfFB8XY+K3uFQn+QL1DOD2vEv2jEH GzNFS5mvH+MFonnn6/vrGjwrNF8/xreINm2+w/qfaDkO2gHRcufr+3m7aHkOWqJMXfLn6/u590JV nm6MZ4hW6GBfPp51mq8f4xWibXKwoVq0zQ71rBOter5+rDaJtsPBhiOi3T9fP1YNmYIenK8fqwcl Xcd8jtX3zo23X9IWLtD3i3zRKhY4zP9FW+OgVYu2boHejjrRyhc4rH+zPJ12hOXp2gLPgm1doN/r h+fDmh00PDOWeK1ew3Nk4x20ctHK8OysRtssgetF+45Gq8UzZwX6dPslcHiBfr/oIdEyCvR5Hod9 DnmmXqye4dXlOUa0Yw555opW95tPzFNiNLx0q0y08uvYtoy/XsLKrjtxDzKrT7q1FRjxt4pWL9og xkdYvYTtlbAzI8L2S1iThCVHhLVK2H4JS4wo66iE7ZOwF7vKyuwqK3mkevY4MSIPPI9Xfn10vukS VnY997AwLEvCSiUsJSLMenYvIsyLriZhhRKGN5EnvnS2vZc6u896t7WZGunwjN+Iwk7zl6yjtX4n YcckrAphMfuvLftRflG0X1tRfpHer++LVlsU7ddkPANYFO1XPEe4ryjGfgnbWxTt1ywJ212k92uh aGWLov1aIWGli6Lz3YRnEhdF+3WrhBUuivZrvYQVLIr260YJy19Ev24/S+vX9lHq2epIvx6XsA4J e8jBr2np0v7F0X5Nl7CyYr1fc0SrL46ub6GE1cWE4fnJ2uIY+yVsR3G0n7ZK2DYJy0RAVh+vZb+E HSjm3IDx9ktYa0x+rXhWszjan0clrDmmLnhG80BxtD9fkXhNxfTnl9K0/sSznFtuiPZnjoQVlnaa BQ7+LBN9W2nM+JewraUO41+0Q6L1jmx/CTsYE4bnRVtLY+yXsFdKT/gT9TsqYc0S9tKJ+qGrdtUv RU4Q65dGtwGeOV23NDrvMRK2Zmm0b6fhmdSl0b4tkLDypdG+TZewsqX07ezBWt9ukTjjl3WazfQJ wmrxDOuy6Pz3SljHMu7hZFizhB2XsB4RYUck7NgyzhkZdgzPypZxrzrDUkajkTrNfpH2j1b59YoI GzNa5deTYdibOm20qt8TblXnuGdVyqOfAbH2L0qa8hVi04nnRtBfEr8mMZDnVtELyzvN40555sbn 2SxpRlQ459khetrqz1bPYWNk/rTGOc8s0Tet/Wz1XINnf29zzvN+0bO+KMfUz1DPA5Lm0O2dpkuT J/brHhW9eUOn+dOo53TsZ35UTshnwFip30Z93azzv+ilX+4032D/tI/3qHeuaCOqZE6Y2H1fbJQ0 w+9y9sUO0VPv7jTv+gy+aB2rnkXW+QJ5HhN9ydc7zYbP0GYj5GKl4xudZoImT4ytHNH3NX8S9UyT 9fyXhDfd22nOxbNcT6RGl2c9/5WL57/sotTzX5JmzCdyjJEDT+KdZ+jqmN1nW0JUJVFWtaTb+81O sw3PX3z9TE1Z21yRhWGNer+kaU00zQU4Jt05OLpvoHKMjbgdEjfnoU7zL3je59m4uOV2XNiQNk76 Y5JpXopnd+5M09vQEf8MW944/FaTXHOhjPvSInzNZ9gkHvJfJ/H2JZtmPvw64yx9OxZGtyPy3yXp dm9n/tee5Zj/QeTfi/n3Pbtb+SPdgPFyPNjZaXrQBuc4pIt5dg/pciRdfYppLkd5b3SvPNizUdIN r5PrG9hz+GytPWi7OomXWd9pXmb59ZzYtiu02w55tkrcLX1M8xX0iWxv1HOE6XyOEHXGM/ojdnWa uchznLdb4xP9FM/yZ+3uNANI95pX00/L48ZEmaQp3CvXsUhzx7ndKgvpdki6TfuY7vwh3U53UNLV 76dtL3Y/3YDLZbw3Md2Kod1KB5/nSLpDB9gv+w/TtiOOQ7skXqu0DX7H5kS7qEaBb/Eeg6bmTnMO 8tk57G/6FnkmXyHn71f01xjoO3gHwpJfd5ph5DnqPMdxj7gDJK/xv+00pyLux3Fxu/oZ6popcQte l3MJxsoTPk1dq6OOV/Av3rOQfKTT/DLS3Hq+3r/V0ePL6v+SrvBtHruuGP6pNqRmSBzxsdtlRD8f m91nn8t+QNZQvkmUuMnv0jevOeeLuqdL3IN/6TRvttrmgm73qVK880Hqkzsfx7oL9cfSfSlxNm+T dFtvMM211jge63hsR1ukTJDje6lpvmZoz4lxz/Fa7Sdpti41zaxunkdhyxhJs7vMNH+P80L/sd06 PqKP1km68nLTfMAV30eRL95z0XGTafaBrQsd8s2NtwHvw2haaZoTrDn5WM3z2ZlRz2djrI6fiHcm mWbYMByfn0advBKvrsI0eyPvVd2vUz7e8beadVrcvTodkDTVlZ9eJ+v8J/FKbzbNb+E8c+fYiGNI dp969x1d8fB+j0NrGe8JfTzr+v9Kqe860yzumg96rfkg1pXwLpA60c7yYB/V2NixVO+JGEvW/FHi b91gmnjuN/FDnd3qeGAbjjQbJU3Tl00TrzdPHOTv1vxqt6TZUmWaz2Ac9vV3+xzdIenS7jbNVdYx Wpsuu0+zOyqdF8eJTMw3TXM+2nOoP+76E3bkSJxt1aY5Fr66wh9nuwxwT6zt6yVNXcg0M+CvW+PT WEZEpIENeB/K7gdMswh1ecjB9vpo29HOIyaJ/Q+a5o0x7Wxd/07Cu2JME48EG/RxmoRlSlgvlLPC oRxN38+TdKlbTfNWaxzrbIrv+014V8vDn973res/iZfxLdNs1x/jtMcrvNflmKQZax0fum8H3u9i bDO7/V4EHOOqJc2Bb5vqvkjMuR11wbtijopuPS9/kbYucfni2qQd75jZ/0nc+xbMhxrWrzfc1lTu AYZZX7CogMmZ8bQQPFWN2YTxEyGv8ae+JO3TktTKscwOwxesUWDO7MJLHtopGK648ubZEr5g4X4O 4uAHRLB6HAR5Vf7+akczH2pBWutxXq8diC9JPHi4cBdjsK1kUrHewTqNBEW5ZrLTRtWrKcH9fMIc +Ypl0VNRgzVoAvk7B2SAxBssLrgSZGGSijYT5NYkVftrQe5JsraUGUtBespAxoLqN0GGe1S07SAT ParbfhfkWUY7DPJbkj+DzOuhyCC4tKKHyuA8kLt6qAxGg/RIVtGKQXxC8FT6KpAHqTwAsifZ2u5v 7AS5o6dSfgHyaE+V9Wsgu3tad4WNt0Fu6aWiDcaC2wO9VLQLQJ7upWowDuRlIT+wu4/50K83oKF+ ZQXk247Op28td1bAe/J3McgQ+tZy5430reXOr9C3ljsfoW9vBhlEP1nu9NO3ljtz6NvnQF6IdGc7 iXV3YjF9a7lzA31rufN++nYSyOn0oOXOMfTt7SC1VCx3/py+/T7IPfSt5c56+tZyZyN9+yHIJvrW cudO+tZy54/o26kgb/ZSr/agbz8Uz67Ooi8fxrSr0FDd2VrTClOxFo5OcynlNyD4LT8oH4Ecp9ID ozrJrSpyPgje9oEHd8aCjBMy/MR4v0CN9hy7SfEFQ3kryHrEN/6uuFE2fZAQYZM70qahkTZdAlJL m+aA7KeyEOS6BGXTl0DWJSibvgqCc0a8TQG7NviCY8haELyeZXScTbl2SC7j3gGyTBu30A7BF7xF 46sGMx8VF/c6OwRfcLSqBFkUHXevHD1hC1afcbXmwi26EbaOMdXbVhYY1vW5+tjHudPdvXGiQQfM QHBEOLocbmZfGxOOLo+F4nEx4Z/XfNAY6EizNPGR/wRNfCyGXx4Z/igOgWfizIm9EZgzuWQ6a3S9 EdyOx7afbodPZ4XwxhdrnMT3k6j+15O5G/Oj436KHf8oP32aPz4v/jtZr27Wi3HPtkPwBb+rPAsF Pyl/E+KOuf8OcUfacfEFZ57vgWA2+d4J2/5/5qx/zxz5s9Ttnzkn3pzg/tAFJ+Jksw3RcaLB+QXv k0rCuQUdrh5khvx70M7gDyz0gIvZnWgSl0pjKekudV62PlNcKs0VsPR6lzp9W581TGMp+N0zXI3W IIPHXcqEGXDl8yRW1i9FKu0kVgbvCJljZz0xISLalIQoHyTc5r6tfo7X2DXHS388u8Fw7064Qb7j /mp//MPmKBxPB4PsMDhRAfkNlddBPpA/7D96G5thpruUEoZSLAQD9SYQ/CA8zufpIK9ycjMeJIXX ZG0gQ4TgjVUfIbcv8NKxEwqu9zAovwjyywTl0akgR3klOBNksFvl9i4IZlLoYR6QpVQ8uOONyRNa /G4o77pVP+jEJApr1OjxV2CW+NVE1SmuQbRvJ+J3p+TqF+RxIcVuetR8qGaD9NV7EiYayulWGz1n qAJLJFrSb+ULbjWvBnmXyjKQni6lbAA5y6WUcpDxVL4OMlnId+wmPMp+U4dKdrpUJXeBnJKgyB6Q VCGz7TQ38HL3r1DWMlpCEl0L0gPkRTbHJJA3qUwHeZdkFsjHQr7VdVmdpE59rwu6WpLi+lrWbK8x bbbd165zW+8U7Jq/XUZv7ATBzM66CANZZ6i22AWCmwJw/x6Qe5jGioaEz9i5mQ/95XZpi9+5/GyL NLTFKkMZj0Ga9GWW4QPBL9g32onzXerYtxstu5R+xZv4jEqS50HucEVM/19iW3jg1zcZrQ/IuyRe kEvo1/4g2XQlrg2NPJIFIEVCsmy/Ppao/PpHQdfvE+P8enSm1+iYafv1Z2L2JHx9xj4e4wtc1g+V /g4PCLuQ+8sJSrGuQl4Tcs0J/7W63D9zXWSoC4Y6ePEm1NKO8Dxd+T7yeZWuPA5yhMSFTP9sRPho An00GcpsuuUqkAKS2SCPsPd/BeT7VO4B+SlJyG173PbRm27lIx98dHa8j5pyvMaBnCgfvWwo4y9D Hv/FIyjuBxqHSUZA+YQkCJIg/4KfVx/tmOE1amf8o33EcZhp8JyNqLfRMZeCYAKDk+TlII+iHDtx GcfhAZhyG+16BeQuEuvC/77IcXiY/jsTw+gDRrN2ayRwgI0BmcpxaC0JXEtlFEgpyXKQ1ZHjcA/H YSf8F47335KrvEbpVbb/1JzqMB04B5n8lm46Age6E9Tpxsr+1ISIq+OIfnWVwdkHnsPr6lcv0H3H kBR3s6zdYnBFOwlWPKxzcpdfJtEvAShz6ZdZ1vIKyVyQ7exX1krCHirfBGkkeRDk5ch+9Qf2qwvh lyHxfsmZ7jVyp9t+sWwbxd7wIyAmno/aSVoM1eYmcn+L5vRAme+TpIC4Itt8Jm2bCWUh6zkPpIzk BpCnadsCkOepLAL5Fcm3Qd4AsW07StsugW0XxNtWPs1rVEyzbZNrl/60bKgr4trFsvlyNiG25yV9 zVAnOevTTpsHoviPaObZIB5WzFoZ6h9p80LavATKTYxWBvJFkptAfkKbrbWzV6k8A3KExDrJ/Tmy Pd3s59Ngc2a8zeuyvcb67Kj2xAUWqoaemYTVooV2kt8bqp4pkU04wG5CkDNA+kTatoC2LYhsQquh 1ka2517a9u3IJny8qwkFnwI5GtmeH7E9J8I2f7xt2wJeY0cgyja0G9Z2cSy05gld7XaU7XYmivmE tg0B6cUKnA8yKNK2xbStFMpqRsM8z9hAstruntbMxjozU/mBNcRJ9lpDPLLderDd8J5eV1a8bfun eo2mqZ9P29qzvMbRrDjbPhfjLUXs6vc5tS19itcYMyXKts/NfCpvstfInxxlG46TuBR7BbZhDfsG O8k7tG0QijFpzjkgKawAblwYZ0S2WzFts65Ab2a0G0E2kqwE+TltqwP5HZVdIH8k2QPyYeRxMpHt Nh22TYq3bc0kr7Fukm1bzLWW1xVxrYWbX0mbDXUNeyFIyIi41irgHM8a8jeyPvtBbiF5AeTOSLtf pt29MEX7A6OdBvIX21cgYznHGwQyg9O6c0DySa4HKY6c4z1Ou9+F3W3xdq/P9BobM6PaFKtQuG7a D+txedo1+f2doWw7BRa8yzbtD/IxSSpIcqRtebRtPpQSmlMEsooECwnWQgps2wZygEotyG9IngRp i+yvx9hfJ8C2sZr5/5Uy/7/Sts283XD/0XUlmxSrUUn3sEmfAtlOUg+CeRxW0HeDYLVwrMvOmusN uIg1+tPvT4J4Sb4HcnHkGsU6pnkPytcY7WOQh0h6o06H2L5WBcNUkkFwPQuSDYLL3g22D77BNYpX sUbxUvwaxbaJcv6faPuA/Xoyy6i3ey8q55Nsk56m3ReB/NhQ8xjrc8Cew6Dar7NN8CsCxp9IloAc i2z7LNr9IJQgDXoUZDHJyyA1tHsnyF4qT4O8QNITtW0R8p5dnRcS1QH1Nti9Ot7u2gleo25CjN3/ B9ZO6jO8xq4MB7s/x8ex3Vd4jb1X2HZbxzEcw7CYjrvRSVhzu9dO0pe2TXDTKShzKsjFkSfUyyNt q6Jtd0O5n9HuBXmM5H57xgfbfgViL2H+FsRewnwDBEuYXcexC2nbCth2Q7xtBy/3Gocut217OmS4 66zDxDA7Gr5gRfk93CDMNFQGeNm1deMHhY5D/rcw2pUgIUbLBvkZo90B0sxod4Ng2ozbgPdaEwPa 8xLIaJeK9ioIJiKI9gbIVxhtMNaNQ4w2FOR7LnWX4CKQt+1rH5Awo60AOY17AW4GmU6/PQMS5Nr5 syArE1ShPwOpYzQTZA+j9cDh/teM1hekL4+kM0DS3CraXJDxbuWQa0GKGe0+kJWM9gjI19wqt50g TYx22CqH0f4E8me3MuE9kOFcbx+FtsGJCtHGgcxha18J8kVGuxXkbka7A2Qno90N8gqj/RzkTUZ7 CeQTIdloEpCiJJ6fJ8m/5Ulq2WYwyC1ULgK5k8pokHupTAHZlqSyngGyl2QuSGuSuqVzLUi6R61m 3wey2KM64OMg2z3qlrX1ecOjbmD1xG2G83tEKNjYg5sWW6B8vYfqP9YntafK2lKGCvHZaab3VLXG T+sZJT154waFfqWnctVhkH2R0X7HaD6c/j5itItA8CMBXdFm9lLRlkNZ2ktFWwWyLTLajxitAcpv GO1ZkH6nRETDfinrZg+U6adwk8wU+bc+MtrDjBaAsofRZoB0REbrnaKifQ3KBSkq2r0ghSkR0W5j tBYoDzDaayDNkdHeYbSzs9AuvVW0oSCZvSOiXddbRSuBspbRloHUR0b7BaM9BeVtRnsGxNsnItqE PryXBmV+Hx6rQKojoz3JaBNx5/MFRpsC8lFktKS+KloVlHP7cpSAzOkbaQKj/TeUtYz2MsjjkdG+ z2gDcbn2S0YbDJLYLyJa/34q2vVQRvVT0RaDLJRv2KVrRdt3qopWA+XwqdzzBXLaaUp5F2TkaUp5 D+Q6Kn4M47VUrgCppfJFkP1U7gB5j0ojSN/+SnkRZGJ/pfTBwFtApT/IV6gEQR6jci3IK1S+BdJB ZTvIOQOU0gZyxQCl/AnkViojsTfhUZLxID8ZoG4lXwly1ulKCYFkkWwDWXy6irYT5DkqnSBtJMlY OU4aqKL1BSkayG4JsomkHGQno90M4h7Epge5kKQVZPogFe0NkMeo+HFb/ABJJsifGC0bJDuV3gFZ TlIL8tVUFe1pkLepeDB96HcGX7UOMuoMFW0QyN1UloN8jwS/Omj8ktG+BHLxmRzOIHkkh0BWnami vQXyEpWJM+VfmGQayOmDVbTZIDcNZrcEuZ+kHuQHjPYDkJQ0pfweZHiamvwcBZlLpRNkRZraR5mM HQ0PUzkTZA+VYSBvUfGDuM9SSibIJWcp5WqQmVQKQG6lshzkPiprQJ6nchfIm1S2gOCpP8s4kIvO Vgp+J9GYT+WnIKupHADZTuV1kOeotIO8Q+WvID3PUUoiLuvGncMjBchcKl6Q26lcCvIwFfwio/Ei lVkgb1HJBzndq5QvgFziVQp+vdFYSKUK5FYq1SCPU3kU5HkqdSDvUfkxSN9zldIEMuFcTtlA5lN5 HeROKu+AbKfyPsgvqbixl+gdKr2sjZRDlHIGyLgh9AFI8RA1CR4FcusQ1Xf8INup3A+yZ4jaPPFd nKo7qDwCxTNUKfugTBiqlBooc6m8BKViqGpk6/PIJHWRY009dkxSr5+2Pl335qO2NiNL62oHezsx 6flvELxbAlMOLCAbNYY66reC1DONFQ0JI+7NP3K74d5qzVpOs+cup9kLGpjl+4XgF+iwi9dagEMR d+JC4BcudQG22V7mT7WjYflqhl3EZF4yPYncVnOq+32QDbzl/UOQuxjNWqBByZPt6tj7zc6isVg8 dV1oqJVG6+NivNvc1jsyu3b7jqNHnkIczGLW2MoPDeXxn0DZT4KVIBdum3TdereuOgXPQwnDSbCe 4sLVVtwepuh6Jtn1PPzvVs/paldC1J4vnEnwi5bG7ax+SNrAhf0tqbbyU/k76Pon5tVhuPHiaMNv Z4YvWHK27i2HmNnbQlzoxX1t5U1D7Td607pXYagtb3+21/Ngfti6coVjkmLKbOaOtjftMvEFSZ5P YBKMv/UgWPVDmdbmDfxy6Om2gr1hPzjRX7mn7mI7S3zBvqvvgiwyIjavRe73s26T21/QiTIQECAp tdaeEiN2SEbsL/mRHYYvBfJXgtjY5YYTnTXY8AuxXVv7CxJVF7GiRdaha53hXvrXeij1UXreWlHD OlvXtqcTbTbeDsIXtNk71moDU36CNmtinpaCwQu7PgCx7z8moT4D2WbWUgyu2/t2u82+DQMHu9Tu f/wmqnV1jzKxJc36RdfTbeXL0W12wgeFdq74gvE7wPYBjt64QWMtOnzrhA+ix32CPe4P2TH+0eP+ m3a06znUcbfPWqEGQTd1LdON+8NSzWvtanYarOZWOxrGFA7o1gEWSyldDyoMZNbYDNd1sMGhxXWe rpzT3b1TWQp6i8v28snPyc/Jz8nPyc/Jz8nPyc/Jz8nPyc+/+2d9o5q/dxCtTUzySSea/NjxY7n9 aU6KDfnf/axnfeod6hv7OdTZvXj2J/2v0fFtHhv+t9J/1nT/rp//9Pb/T2/Pf7X//9V2rv9f6l/r ad/6//Dx+fd8Ehy+4+Nu/+f6I/dvR/mHfuzjRHePF/+KT+TKmrv1s9frX9F+dh1Xx/D1MXxZOJrf EsM3xvBvxPBHye33VqduV0pv8k2PuS08g7w2S+1Cs59Y9xI/UD/RYnQwY/uwcqhAoYc8ny9Gt99X PfxDhafY5RPdRCNXlWf7uWmMQvtd2fZ7tO17f7nLXVHhzQsUt98Pvp6Ps9vvxrbLk2mKVX9jQdf8 zOL27YUO8uQ8pX9E/m92ev7cf9pzhmnDg+y3JcRKYhUxRKwhNhAbiS3ENmKY6NmhcCDRR/QTA8Qg sYRYSawihog1xAZiI7GF2EYMEz2PsXyij+gnBohBYgmxklhFDBFriA3ERmILsY0YJnpqWD7RR/QT A8QgsYRYSawihog1xAZiI7GF2EYMEz07WT7RR/QTA8QgsYRYSawihog1xAZiI7GF2EYMEz21LJ/o I/qJAWKQWEKsJFYRQ8QaYgOxkdhCbCOGiZ7HWT7RR/QTA8QgsYRYSawihog1xAZiI7GF2EYMEz3f YflEH9FPDBCDxBJiJbGKGCLWEBuIjcQWYhsxTPQ8wfKJPqKfGCAGiSXESmIVMUSsITYQG4ktxDZi mOipY/lEH9FPDBCDxBJiJbGKGCLWEBuIjcQWYhsxTPQ8yfKJPqKfGCAGiSXESmIVMUSsITYQG4kt xDZimOh5iuUTfUQ/MUAMEkuIlcQqYohYQ2wgNhJbiG3EMNHzNMsn+oh+YoAYJJYQK4lVxBCxhthA bCS2ENuIYaKnnuUTfUQ/MUAMEkuIlcQqYohYQ2wgNhJbiG3EMNHzXZZP9BH9xAAxSCwhVhKriCFi DbGB2EhsIbYRw0TP91g+0Uf0EwPEILGEWEmsIoaINcQGYiOxhdhGDBM9fAvIQKKP6CcGiEFiCbGS WEUMEWuIDcRGYguxjRgmenaxfKKP6CcGiEFiCbGSWEUMEWuIDcRGYguxjRgmer7P8ok+op8YIAaJ JcRKYhUxRKwhNhAbiS3ENmKY6Glg+UQf0U8MEIPEEmIlsYoYItYQG4iNxBZiGzFM9HC3yUCij+gn BohBYgmxklhFDBFriA3ERmILsY0YJnp2s3yij+gnBohBYgmxklhFDBFriA3ERmILsY0YJnr2sHyi j+gnBohBYgmxklhFDBFriA3ERmILsY0YJnp+yPKJPqKfGCAGiSXESmIVMUSsITYQG4ktxDZimOh5 luUTfUQ/MUAMEkuIlcQqYohYQ2wgNhJbiG3EMNGzl+UTfUQ/MUAMEkuIlcQqYohYQ2wgNhJbiG3E MNHzI5ZP9BH9xAAxSCwhVhKriCFiDbGB2EhsIbYRw0TPj1k+0Uf0EwPEILGEWEmsIoaINcQGYiOx hdhGDBM9z7F8oo/oJwaIQWIJsZJYRQwRa4gNxEZiC7GNGCZ69rF8oo/oJwaIQWIJsZJYRQwRa4gN xEZiC7GNGCZ6fsLyiT6inxggBoklxEpiFTFErCE2EBuJLcQ2Ypjo+SnLJ/qIfmKAGCSWECuJVcQQ sYbYQGwkthDbiGGi52csn+gj+okBYpBYQqwkVhFDxBpiA7GR2EJsI4aJnv0sn+gj+okBYpBYQqwk VhFDxBpiA7GR2EJsI4aJnudZPtFH9BMDxCCxhFhJrCKGiDXEBmIjsYXYRgwTPbx/OZDoI/qJAWKQ WEKsJNYX6ddr7E/2lCmXe4dnz5p3gXfMyMtGXmosLitafoO3snjlqqUrlntHjxw3Mt07fNHKouWL S4tXjVpZXFZctKp44ehx3kvHXuIffdkFhjFyVemqipUVRYuMkctXVBSPvGH56pGLVi8tW3Lx0iWG xUqLVpUaI5esXb5q7Y0KK1YqheVEkYWiSTlFiMhv5WUVxsily5fK/4riNfK/RIhoK5YUVRQZI4tL F5asLLqxeGHpkpUnmGS6ePHC4jWLi8srFkr1yopVHguLVq4sWmuMXFyxYuUqqY6CLyyWpMgOJUrO Vj2Lbly6WLJZUWH9U9VQRS5aJWkWr7jxxuLlFZ/q4G5+sP6KNdOudVZXNMa2YmIMx1MZYdNcYae3 14FtLOW6q72um2xEf4azDnZ6e53Yxk3ZJ8p1RaS312/Tmbed3l53ttFeZ7Y/rpjysQHbjKi/vc5r Yzgpuv4JMYhnCzsj0tvryDY2Gyfqn2jE25/HcDu9vW5t43oH/9n2X8/0k8ntdXAb7XVzN9PEpsd2 dMS01+nt+wA2/q32XxyTPpPpunBodPx+Mbg8Jr29f8JGzxvRLdbPiP5UxKS371vY2Ccmfmz9b2F6 2//bmM7GgzENFlv+hpj0655yR2HFqZ9efnVM+o7n3FFoTImOH9t/HoxNn5AYhSceD9GXj3drwEd2 /7Lv89RmqZjemPjJMbib5dvpm5i+ielj/RVb/+di0rcyfWs30zfGpG9n+namj40fy1+MSd/B9B1M f6xHdPzY+uCRMU9k+bxP0Z5DT7NhbL9H/l4tPm/G1n8W08+i/TEHrFj/t8Wkt++bGbkqfX1M/4tN /z8x6e3zdn3Rp7e//fmAYXb6ZqZv7mb6v7L89JhwO/3kmHCXBt1G/Oe0RSq9O8Z/scf//wefNWQ6 WGoEAA== #endif #ifdef PARAM PARAM(BITSTREAM_SIZE, 289368) #endif