#ifdef MAXCOMPILER_VERSION_INFO #define MAXCOMPILER_VERSION_INFO_PRESENT 1 #define MAXFILE_MAXCOMPILER_VERSION_YEAR 2018 #define MAXFILE_MAXCOMPILER_VERSION_NUM 2 #define MAXFILE_MAXCOMPILER_VERSION_POINT 1 #define MAXFILE_MAXCOMPILER_VERSION_PATCH "" #define MAXFILE_MAXCOMPILER_VERSION_REV "8488566" #define MAXFILE_MAXCOMPILER_VERSION_RELEASE_DATE "2018-07-18" #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/./StreamFMA_MAX5C_DFE_SIM" #define MAXFILE_BUILD_DATE 20190705 #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, true) 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)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") MANAGER_NODE_STACK_TRACE(a, "com.maxeler.platform.max5.manager.Max5ManagerBase.addStreamFromCPU(Unknown Source)\ntests.StreamFMAManager.(StreamFMAManager.maxj:14)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") MANAGER_NODE_STACK_TRACE(b, "com.maxeler.platform.max5.manager.Max5ManagerBase.addStreamFromCPU(Unknown Source)\ntests.StreamFMAManager.(StreamFMAManager.maxj:15)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") MANAGER_NODE_STACK_TRACE(output, "com.maxeler.platform.max5.manager.Max5ManagerBase.addStreamToCPU(Unknown Source)\ntests.StreamFMAManager.(StreamFMAManager.maxj:16)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") MANAGER_NODE_STACK_TRACE(Stream_1, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_4, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_8, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_21, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_11, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_15, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_13, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_17, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:21)\n") MANAGER_NODE_STACK_TRACE(Stream_19, "com.maxeler.platform.max5.manager.Max5ManagerBase.build(Unknown Source)\ntests.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(a, PCIePushSourceSync16, "a") MANAGER_NODE_CPP_SIM_MODEL_CTOR(b, PCIePushSourceSync16, "b") MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_11, FifoPushToPullSync, "Stream_11", false, 512, 128) MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_15, FifoPushToPullSync, "Stream_15", 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_13, FifoPushToPullSync, "Stream_13", false, 512, 32) MANAGER_NODE_CPP_SIM_MODEL_CTOR(Stream_17, FifoPushToPullSync, "Stream_17", 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", "ac5fbbbe6e4b46179c07a7a26c8647de7f8ceee21ed281c31027872a8e6038d8") #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(a, STREAM_FROM_HOST, 0) PCIE_STREAM(b, 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("ac5fbbbe6e4b46179c07a7a26c8647de7f8ceee21ed281c31027872a8e6038d8") #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)\ntests.StreamFMAKernel.(StreamFMAKernel.maxj:21)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 9, NodeNot, "~", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.output(IO.java:836)\ntests.StreamFMAKernel.(StreamFMAKernel.maxj:21)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAKernel.(StreamFMAKernel.maxj:15)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 1, NodeNot, "~", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\ntests.StreamFMAKernel.(StreamFMAKernel.maxj:15)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAKernel.(StreamFMAKernel.maxj:15)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAKernel.(StreamFMAKernel.maxj:16)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 4, NodeNot, "~", "com.maxeler.maxcompiler.v2.kernelcompiler.stdlib.core.IO.input(IO.java:630)\ntests.StreamFMAKernel.(StreamFMAKernel.maxj:16)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAKernel.(StreamFMAKernel.maxj:16)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 6, NodeAdd, "+", "com.maxeler.maxcompiler.v2.kernelcompiler.types.base.DFEVar.add(DFEVar.java:1010)\ntests.StreamFMAKernel.(StreamFMAKernel.maxj:19)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAKernel.(StreamFMAKernel.maxj:21)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 15, NodeStreamOffset, "stream offset: 1", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 24, NodeEqInlined, "==", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.StreamFMAManager.main(StreamFMAManager.maxj:20)\n") PHOTON_NODE_DATA(StreamFMAKernel, 21, NodeFlush, "flush on trigger", "com.maxeler.platform.max5.manager.Max5ManagerBase.addKernel(Unknown Source)\ntests.StreamFMAManager.(StreamFMAManager.maxj:13)\ntests.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("302c021403bb77cd00b6cbb7e95b17f03f1a583509e1176802144b3bd7c15b0c30281360483daae602853543039c") #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/4hJqFu64Ja65lM4Mu6UOyCCIywioZNowwCCDMDPODIi20W62kW1m ZWS5pC2kaWYb2qKZFWmLWRZpi5gZaYtZ5v/e886D8x7vwTCg1a8/fq5vvt+579x77j333PW9udY0 MT6gRQtB+mspjBE4Mu4UOSPywZmtauIYhSjhHPZ/H6E3xG0taP8Zx7SSXQUhBP7n97VhITBO5APj BsquO/qIsQ/1EWT3BeB9OyaK9+2YOFB2hQjkGoiwFYYdqKryinfXXKXcmr/xZsF9G1qK8RVXb0dB dpXum8ruayP4/heE12RMT6tcTrQXZFep5njsLgKvP0EYP3ma4M6P+GR/l4hBn9qS7K+ZJgza9urK RTxeW1YuzwhivZ7LQsDUzg8HCAGxJbo1i4KE4K1lgcZxrtiWi0qEVm0T+wn9ojp3s+qEmzrGuspb JBvNLYV2QhtjUGXQW607tAiKueWlIUONA/tPfCNoYFyb6nat01sJLd7oFNcqsF1AqdCi1CjE3ia0 jul0boQQWFpcbAyIN5YHCue2MgZtbnlvm2VrTbaQ+Ljy0v6tY94UAh+7IuhIC2FwhxBjgLDGHNKy VdtOiwLTz8sQul47roUQOMwlGIOEgOLSdoKxh7kk5ivXwBtaBV6/VAhYtYalWlxsEFzGVsbigS26 Btx7R0rskPKyQ8O/n9BHSLtO+F5o30LI6tGflXJEi0BhSO+WFy0TigWhnxDbacRQ79pW773RTxCG sBze1Ko4cHCRMSAt4Jz1gjEwqnhQ7O2CrnU7Y4uOxT3axUQZsyoC3ogoWVrRKljQCUGtunS/rs2o klmCeXiLNoHCjawachJDjC2n6AKNxsXdV9wbVBLQPSyAVU5ASVDp9a1DR02P6RgjpAutWgrBQkkQ M0+jsOjc4lbjzJ2SS+df1KpjyDqhdafF3TqWfRsYGDjg7jbCY0K7qEUJIYuLzUHFxvJxrQJ33HDu iH5dE2JLH0wccJuQkH6p/utOA4KCK4NaBAwKGS8EXG/sckgQ7hTeeup547m7hgQF3FgcEni90Kq8 RYhQYo219aq4uSSzYIl5UekzhwLKuC08y0IZC8+hLa1nYZPCPl9g4UUWtrDwMguvsPAqfrcVr68r 7nmDfN7Owtss7GThXRbeZ2EPCx/h9x+z8AkLn7Kwj4XPyb1f4PVLFirx81csHMDPX7PwDQvfssBU F6pY+IGFoyxUY5xjLPzKwgkW/lDk8xQLpwnm7jCAhVYstK51jUIb9pkZknBeC6HO3/mMC0K+E7t2 VsTpxnB3wgWzzz1Z6MVCH+QvwGt/dh3IwmCVdIYQbjj7fBELF7MwkgUdC3r83oDXULyGsWsEfo5i 12j8fAleL2XX0SyMRWxk1xgWYlmIYyGehfEsJCnyNJnhKSwkszCNhekszGAhjYXLMO7leJ3FrrNZ uIIFCwtWFjJZsOH3c/BqZ9e5LOSz4GDBifw8dvWw4CV5mI+fF7LrlSxcw8K1LFyH/PXsehMLN7Nw CwuLWLiVhcUs3I5x7mDXO/HzXexagp/vZtclLNzLwn0s3I/8AyT9peTzQ+zzIywsZ6EU+cfYdQV+ foJdV7KwCvGT7LoOPz/Frk+z8CwLz7GwHvnn2XUjfn6RXbew8BJJ82X8/Aq7vsrCayxsZeENFt5k 4S38fnuL2r5O+sMuXniHXStY2M3CHhY+ZOFjFvbi95+y62csfEHurySfD+Dng+z6HQuHWfieBebO hR8UaR5luFrFrn9i3HEWfmHhV/L9b/j5BLv+zsIf5Ls/2efTBLdgfVsACy1ZaM3COSy0C6j9/lz2 uQML57MQxEJHFjqx0JmFLix0YyEY4/fAay927Y2f++D1Anbty0IIC/2QG8Cug1gYjPhCvA5h16Es DEM8nF0vZkHHgoGFcOQj2DWS5JX+jWL8JSxcit+PZtcxLIxFPI5dTSzEs5DAwgQWJuJ3kxQypzBs ZmEqC8n43TR2TWNhJguXIzeLXa8g96azz5kEZ7HPOSzYWchlwYnfzWNXN372sGsBC/NZWMjCVeT+ a9jnawm+jn2+nuAb2OcbEd/CrotZuJ2FO1i4k4W7WLiHhXtZuJ+FB1hYhvHZgEZ4hIXlLDyK3Aoi +3H2eTXBa/Hz03h9hl2fxc9l7Pocibuefd7AwkbkNrPriyxsYeEl5F5m11dYKGdhKwvbWHidhTeJ nB34+W123Ymf32PX9/HzB+y6Bz9/zK6fsrCP3P85+/wFC5XIHWDXgyx8x8IhFr5n4QgLP7DwIwvV LBxj4WcWfsV7fmPX34nMk+zzHyycYiGgZS3fIivk5ZuMi0p77T++enZOy9nnWioDlx6as27p97cb NzqntHrxR13isuDP3px3+Xdzrq18vzxeN3TqqcMXtXzzluyW4aGBpk3dMi4rZ3HOn/zTZZVdB094 paD0jmfL+r747cpNXXtWv7J/0gfBr+uGbp4RszZ5+vvvR724YsnxKxzX6YNfvOOn82ZWPXrHuonz Zw7b8ovb8PIvN3+bNjqy9QsPFMWxuBdO0E17NDF0XCL73Olw4cZbemzq+s2Ez2ZWbx0+9peWrl+W f7Fl6iunWqSt3nyDeYFx+nUpLF6Ha3a20jnaZUb3jflu0KkhgxbYnty0bMCIZz547vST+1vnfb7t r3EbUo3BlwXfvHrPc+1eTL7FE5zw7av3XT2y9W+5ISUvvbt9vqkycGpWwr6nxj838Lo5Ia8PHbk2 9duTB67rO/r6z++PX/m546PilSeCtm3+PO7zRz9bNWDtK95DBdZd7uw9J+4ddPfPfw13v3ZT+SfX v3JlTveRG63Do05tvfDCOz9KcA2O3xFw4P7jVzyx6+CrP3Z8be6Hto5tJlx7cSdrr/WnPx3mOdVi /NYdITdNfviSpWW7W1SlRc7qH+bZdseLr3Te2XJmyvi7PrZae+jKXph7/4CLhs1bHfT6D+dePyv2 7aJ+wVWbuk0t/bVw57FTk1b3nrB44dOnJ+0K3Pr9gu3TBs3x3rptzfsTjRuLTmzoNnxS7MNffLlq gLdXYMLr/R558bG7duWeen7310UMz7nv57+sd94WN7XwyMKrGb7NOj30htnzZy0cc+nAKXceC9n1 S6v+0+7t88eTo395/+FVV5luYXGseftH9vnsgyWTDx5/fNrGXUc+u++ukm9eap/0drDpnGNpV558 d1ZZ5QVb07o6337y7Q39W3/y1nV/xqavWLxm5+brV0zaNeD7+0e1XH7NMxl7j3d1TL919cJVE607 3/q4p+MZ+21/JXR7sMT5zO83DOj8wPs9nts5v2Sc6aMjP34945GRux98JrV31X1b3Z1GfHfJ3X9s 7BuYcMcoT07BnfnPFEfum/Lc4MgxK67pMe/1B76L33n7F8JL7PuEiYsX9En4uvRl9vm2cX+8deSV u9NaJw16veKCJ4IfevhoxX3rPkkoyGj/7IgXdvf6ptsf29dX/Xx7H0flq5bM1VdPPlqdfFX7y7tt Z/d+fnrVPZvf+u6By9e+NvWGQzdc3GnEqh5dKl86oB9x6rbt15gqbuyx/7U975/e/voVjqLPOxzc M/Gh9lvH/3C6d9Uj9xYN/e2+j157vWXOV6N2XTB+9I1HQw79Ftpiy2MLrp5iefrWV7fsuOzW8j/H /rz6xC+XfqC39r7gl6MHNhwcu/jDso+uftbw0itHb5w2Z+qWN0N6fLNU+PGVHc8/+OXsiV+X7g2b kfrYRHflgncHJRm27oi9xzL/m75rjM90HXH08xsjo38oMNyp67PlvXVfbpmU0rN44skVV5/K2Pjm 8NlZd11mt2VfsaBHzKCkXmntIt96eMvBtvuvyqr+MX7bc31nvtNrnf6aL7KXD+j3eJs+jycc2HPe jdt2ZyyYOiz3j/s+emnJKwOe2579+NbrVgTc/eaSgaEL7nv6s84J2ZMm51867IkTj+wv7Klf3KXy YNC6w5XHJ9/89nev55X+kv37+LEXvZ7cKzz28K/zDq1becuRGY+avy5tlbhic/k72XfuK/699ben n20zYFD1ponVnjbPfn+ic4/3ntnYsqNpepsIg+PWlysnBfX81PEVi9drmnvaAXbNz3OfNyzjj9c3 vb165IBHTC9Mv3bKiXXuiw/2DtYZ37SMmr76l75Pbwk+/fARFnfnB/M/mPvnfuuuJe8kDex81zN9 5p2/fnafzUOdPW3v2N8OarHn1bs2Hu28YvS4Abc9mf+R+YOjI7a8+MqNh7ZNv+64u0/E8z8NirYZ u0dWP/dbxB/6loPcoW+w74Y+OfPyh+7++tOrXjr/xImKS2bbPV0nLH9+TUSfm35v3TVn/jeWJ/4K DWGf88eUj/+rX+QFG0ad+rR30FVX3vzjJfNGGwbe/2HwosWD2Pe3lFi3L9tz18+D3gs3vP7qAzH7 n1x3vufXh0P7Zo19b8HkzWPaeHIuGcniGa2hgd2Tz93V/cY5D3w8MvbCsWOf73Nl/yc/ikl7ecHd R5d/Fdnv6tyDfR/Ofm5k4dHFw85PbnnLvEd2p4yaPiXpjqX7D975vqfHlvIFH5Q6OpafWznJePzU +9ebpi6d1z22X/+HTpxo8dXE21c9cfmgdmGrsyfdel/LfXc/MnDVTztnXbn8qYce3n3bD2/nPFWV fmxSyMHrlq3Yf+e0bw588ej4Ozz60M3GNmOHpae/f9PzU387/vDKvZ2H7To07Jojs5LTDc9O3rd9 y+lX37z8+Tf29EkelbZ4yuiZlzwx8bagoC+7/d7ttR4/p32T2LrFJ3mzW4WvvODahc/bvnojfM9X b33z06y4Q8dDC4+W/Zl3au2383dHX+r46OOPVx3plDZqeocTYycZL/tuRseHgtcM/eTXBX0CW7y9 6+Xo218rDLHennh95sEjty8876N7nxlW1P2VZ+9aZ5l/9Y/fHFm4+uvsE+fds/za5U+9kPp4n3Ou 2ffOk/vm7nzv8UO36IoyQobYjk1adX1peMzm0cv3HV173jdf3TntgW2TPrx8+3VTin6cc2Xb67pe VfbIpMtaP2vq9+0PFcbFrksH3f3lz+1fLfm190P24mNL3h8UF3rDu3Ef7Dmtn9nq2bhHGfc4C9dO H7T+hqq2Pz2x4MLTJ64zGKbkn3q19M8xv3zRLcw0qMt7rtzn9371ytbcIfZOP814msUPjSo8uiV/ 2thn9rZNukLXt/dvm+YcvOyKXp+mzho1/cX8Dtdu6FK2K3fXG79s2rii9cgjO8yXfnFHQo/97V89 p9egj1ZWXdsy+s8X375xeLnw8vY2G08NnB3h9Oaf88UNy5+6/ffU/SNueb33SvMTY4PGDfuq5/pd S3v0vHXqzrc3tPv18/Xv3Drr9q4X9vz8gd8+/nDIk7nvHP7y6DWjPssvPtby1083329e/85LB5dc dWPYcOvOwtPhXzH+p2/3PHaQXT/pMPyHPz7tsf2+LvFPzvx624ylERve+aZL9g+Xdb9/cOipA+lb k2Z//NSqxy6dl7nQuLlN69VH2D2ng1euu+em/jeEL3fMqrRMf3v97XeHBWRZb7n45InZ/YZHvzvi vrSJVX2G33zn+51tN71w4A/jqLiXxgydHWE5kHOtcUbGtFk/LNyw4XDJjvDOl37qPbC1/NSPq7bH x3cqe9A6Y17/Ha/c36fVl0VFF0Uu6VVZ+vLBlpEzppe19R757pZ2GXkD+3910pF9emXy9FX7rt5U /eVjmz6dl9Z7+/13fTay64fbDt975Ovv9/x4XutVydMNX17TbbuxuuThqE/3P7Rj9T3HRpRtOIfx LTZE/Hle/vdZrw2c1eH7Hxfl2D50dO8U+sS3Ld/LCC25TXjq5NHbVkzY3WHWlgsTfnv74We7dWT3 CBp/p9nYq5MK//kBdf7ajur8F+eq8yeeZPMeFf7Wj9Xjz6tQ563PqvNtflHnH/xAPd0BP6nHj9Sr 887f1HnhoDp/6Cf1dC/5XD3+6S/V+cl71PlPWqjzfFoaosJbNfgxGvV1vYY9xPysrtfic9Tjd9Cw n21a9rZXnW/XQZ13fKjOv6WRnzVt1Pmdn6jz3TXKeWilOn+vRr1fqGGfF3yqzu/VyOcSjfJxa9jz VI18/vWROh+lYc9jdOr8AxrlnKqRnwiN9liuoW9vQd1u569Uj/9LnDpfXKnOZ3+hzgdp1Fd/DX7P M+r8Sg2/ESWo6/VCSw29ftbwwxr2uVyjfpNZ6K/C52nEL9Lwhx00/LlhtTr/0mfqcs7X8OcpLdTl 3Kwh5xIN/uRXGv2RRjlXlaqn216j3S3UsP9DGuleuE+d/0ijfp/XsJ/l7dX5FzT6kREa8S3fa/Qj nTT6I436elPDjx3S6Mcf0NBrikY5L9fw8xccV6+vIUHq8W/V8PPnHVOXc19X9fifapTz1xr1GKVh J09q9I+hGu3rlIb8jzTK+SGN+J9o+MkHNPSa9JQ630Wjv7hewx/+qtGPnKjWsH+N/L+mMf4crJGf czX6o+MafuOUhj08X6kef7pGey/RsPNxGnY4S6PeX9Yon7c1yudrjfoN0bCTWzX80hdr1PPzlIZe eRr9+7Yu6vHTNPLzsUb7DdRoRyM02tEmjfiXaNiDoFEvAzTG4R+3VNf3Lo1ye0NjvqPT4H/QqJf2 GvZmGKnOp2v0y79q1MvxUo3+8Rz18cMTGuW8U8MOP9SIf6WGPXTTGJ/crSHHpOEH3hPU+S2rNOpL Iz/vafRHj2jY4X6NdF/QiP+uBn9UK75G+fTWyOejGu03U0O+TaN/H7id20N7IX22uKEzS+J/5fHb C5V3iHwK7ve034Px24sbPR/iPuqIx0TebBAjDkA5Xd9APkPkz0U+P1PkiweKfC/kr7pV5F2dRb4r 8qN6iHx5osi3Q/6a7iJfhhu6VuTTXZjPKHl++q8T+Yr2Ij8a+b1vYboz5fk03oHxz5fnZ8QvWD5P iXw0HuBa8oUYvzJfLJ9NyA+2YD4vEuP3RTlr7kf5A0T+WeRXoV7VE0Q+FvkvL8FyGC3yXZCfeZfI w4Yv+1uEfM8LsRxi5OW2/07MT4TIm5EP6438UHn838eKfNBQeX3NNWK6ejnvvQzzj3wa8hvLUF+0 t8uQj56OdtJVLucGrK/ydvJyu/9NkTdaRF46P8fPw3US2gp7V8kPC2wYjPk3yvVaO1/kdZjPPOQf vBTr8RJ5ft7rhPlpIfIvIB+F9ViqsOd2N4h8Cda75KN+xnIw4mZ5B+Tj92M53Cvaj3QW5sOeIh+C BwQGY/zQ5zD/Cjn7j/Fjal2FzUkDa8qF/x3rhXauqN/qt9FOzHL7n7sb61EQ82PA/d13jnP5HYQg PM94IcbvsATLJ0Fuh+n9UP4IebpBXTD/bUT+buRf/0nMfwnmfwjynkAs579ayMo5pjP6kwB5vVzy MpZ/oci/g/nfno35DBX5CIz/+w7MJ/qB85C/uCvKbylvj+PQHipbifxy5NuPwXTRfqQ+d1sxyuku 9ycB92E7ilWU22+inwl5R+RHoKF3wHwWK/yVqS2WDx7k6If81CtRr14iPxf5L2/E+HjQZIZUDjDe 6CCErBMLTDrfWrUF7fMaMf6XyCddhfnvJZfzw+VYDhfI7f/4CJTTVm4Pf2B/UWyR67VkANptR3m9 HEB/ZQ6Ty6nMwHTHyNtjHNpzSRtRrzTs11a8i+WQKvcn7tew3G7A/GB77BGLdhslr9/1T2P8c0Re stvXpqBeeBhnIfJjpP5ioZif5ZifR7Gf1T0q8lZMtwL50lKRz0c5H2I+XS55Pj85H8snUOSlY9Gj +mJ99ZT7k88wPyWnRX4mypmUj367q7y9bIJxMrPieNFCpH7kdBzmZ5QYP1UqH/TnpQp/PvYKbI+D 5fzd7TCfmP+hyO83IB8pb0frXkA/f6vIb8L2Pgb9v9kol//hatGPudaKEaX28slOrC/0h4exHPpk YT7PFfl7MH7Os8jPltuh9wLsT/vI080civx4uX2unIPpYvwRyC/diHaSIpf/zgeifyjDQz83I/9t K9T3IzHjtyJ/5VKs3yh5fq5EP1A2XF6eP+C4oiRCns/XHsT+aJBcznnXYv0q/NuVs9GeQ+Xxf/se 9Vollr90Lm/E7djvKMZdw3FcVIH+bS3yQ9/HdKfJ/cMy7NeKZ4n8B8jHo18t2Y9+DB9GmOfAfrmj vPx3ovzyGXI5e9JRfpi8fHo/gHIGyMdXh9E/6BT+4U3sx82XycdFu9BOKsbL/ec5M1DfwfJ0K3Dc 5dLJ+dbrMf+Xyf3qr+hPQorF8rchf/l1KKeb3J9XPCm2dzM+V7AG68uE8ssU8j/D9mKOl/uNvZ9j /T4kpnspttNPMN0KHC/FYfy0GCzPEXK9tuC8QBcj92MtsH5L14i8AR36tncwvlnu540rkVeMb29C vSpQL+m5kGXfYvwVYsavxHIYieOi8vVyf3LXanE8U54oH48lXYT200OerhXH58ZI+bzg9wVYbr3l 9pAq9V/YoT2E/O0r0B/2lc+DXpPGdYFiPh3Y76R8ie3xPJE3oyGux/FkCT4vE4xyHvwK5d8mxt+A Bbof22/I+fLxxmU4bxKOi/x8jN9nHPqZeEU78mL5hMjt54qRGD9J5C9C/mGct5a/iP0Oyj+K9qPr JJe/UYf9NY7reiAfeQ/as2L80HEI2vOFcj+8Ffuv4mC5f3vOivnE/kKH/PLrsfzR3+YgfwPOQ4ut Il+BfJ4N0x0rL4c/f+O21EOosEojNPHvr3OwHjvI878f/bCgk+dzC86XQ8bL/d7gizH/F8vlLMRy Lt6G/g3L+c316n4srhD9Cfa/BuQrcH4qHYCWynO9G/mxcruND0H5PeXxs6PQv2G9DEL+VYwfNELu HxJw/mi2yNt16w3qfvJxHF+VZsvHV3nnop0Eyv25aYO6P1z5ItbvPJH/E/1er3i0wwj5eDKiHOMX yNM9X+q/Hhf5Nth/PdUH61EvL5/uEejHYuTl8yX6hwqDvH4dC7G99Jb3v/y8O9TLB2JG0tFv3Pyk 6B8SJoh2KM33F+M4yjxF7m+LcJ5bcZdYAB78IhvnyxWKcUg/7O+KMZ/xyLfG+U65Yj7oegLLf6xc r6Po94p/w3ECVnwhziOEMLmdpKI/1z0l9+fBR9EeVop8ONaLW/JvR0U5v6JePyLvwgPg8chfge2r 7GK5P2+H48bSfvL8tMb+vUIvj//Zo1jOQ+V8h0HIj5e3d2NLtLc9YsaxOoWt/ZHvpmiPRky3n7w8 q5/Ccmsnt/8IHMeW6OT+avR7WF/TFO1iGLbTGEW/VoR+EsfD0vrMSuwXyhX+Tb9KHJ+UJYh2eAj5 KlzHC4qSx1/bAfsLfEBkEZbDfbguVNFX7q/2pqK+/UXeifxIbEcu9DPSesj6Xcgny8eN9lEoP1Gu b8LVWP7d5flsh/7WdVDkb8L2Xo7zuJAe8vr9qhL1fUy0T+lZ27HY75QMl8svkNYV40ReWldcgv7N FSivx/sewnaUqJCDfsmMDyRMRTt/YyDqNUpuV8exXRv7ytv1sfbIh8vtqhz73+poebp7u2F/N0k+ L1iP60VlyEvtN3wC1mOc3N8unId8vLzfmY7rt64u8nIOldaNcf3tfeS743xKGC4f/wy+Ccu/i3x8 ex2ufwaFyvXaqkc7GSX321diebqi5eX5/Uocn+N8vAjtORbXT4ROcn+ytRTLp6/cDhdGYz4HyP1w EPrtsptFu0rH/us13EcowfUoab58x3LMf7xc/kEcDxgVdvv7cOT7yeN/j/68dJBifIjz2ZABcj4E 51kVbeX20x/toRgnmpI9tEjE/g7XLaX1inS0q/IkuV1tlNYbW4v8GuRX4fzXqJj/bsZxfmkPuV5l 6DfSL5D7jYoCzL/CztdhP1uK/Wwl8g9vRTm4z9IN+dU4vy6zixX1GfLjcf6uGysv/xKsl/TBcr9n wPWc8oHy9lL1KtrhlSK/TRqf/Ij1gv6nHfLrcJ2wNFhu/0vTsJ9C+4+Ryg39T/p5Ii8dgPXgPM5o lo/fDqCdmzsp2gWun1SnyMell0rjE+Sl9ZPW5Vhuc+XjrouxX3BdLC+3jjg+FBaJvPRqhNUtRH+Y vkskHkZ/+B6uxwYpxlepJZiuSV7vTwVj/sfL2+/yx1GOwk6Gb8J84npmT+RvlObR3eTx52J8M8bv jvwNh7EenxTrUVpXfwnXb0s7yu05DvMpPXQolf9vRrS3nvJ0pwWhnBZyfh+OE4qnyceNubhfUIH7 BdJ8rSOukwSNkufHtUpsLxWJ8nnrCCy30pGK9oXlUJIqt6ufkrH8+8vt/xacF5sV8+Jw5F0K/ulb UL5if3MN+r0QxfgqMBzzGSePn4bjgZBX0V9hAU3BfauyAfJ+vGsp5t8gLx8DjveCusrt+U9p3NVL np/d21A++pnzkS/C+W+QYp1zMfrPEPS3lyO/9RH0J4r1lrtx3awa53HSPsh+1Nf4qcibUF8rjq/S cX7xDsZ/9BWUnyfyuI0hrMV9E91MeXk+h/ksVey3HsbyLFWMcx7H/aygbvL22Hc8jkNw3CKt8/+K 8wiXYr/MfjOWJ9qDtA7w+GIshyC5n/x+k7ofC0Y/WY7zlwLkr8R61PWRyxn+grp/cON+TXqIXN9B 6G9div3B/j+gP/GKeknvOBiI45OyaLk9dMH9heKr5fsdF6C+6ei3pfXGWNyvlB6ElvzJ3BfU/dVs aV6g8DNdsX1VKtZLZ81Cvc6V53M/zgvgAXJBPNfL/3rkYT4vko8PV3yH+j4hRpTmHUOL0V91k48D j+A4MwTXQ6T1lra4Tlit8FfDcR+kUjHPjcB5U7VRrtcPuO9ZnSG3/x3lWP7In4PxF6B9GtE+pXHm TefheP6UmK4b+Ugcn5Qq5l/P4TihWmE/x3G9zoXr9tJ6XacE5LG9SPOp13F+VK2YH83C/SyXYr7Z Ef2AGe1TWv+PkfbvFsr75Qrczw1qJZfTFtc/dTliOSzA+P1+FsunGtd1e2P8lnguoiRW3i90Rj9v 7iLP/024LlQyWW7PhbGor2J+eh/2X0E43ouS0sV9ELPCX02NxHoZLfdvb+D8pSJIbuexHbF8FPX4 LM4jKsbLx5nzcb3U2FIuPwPX+csw/9I88Rnczy2xyOcFhg6YT8X4/Gsc/1Rifyete2fifLAc902k s0z34vpDkEKOEdfBKnRy//wV7j8GnSMvhwvXYrpoV5OR7/8M5h/jX4x8x2VY/tHy+u33MNbjWDm/ 2YntLlre3jMnoT3HyOcdh3H9raKXvJzno32W5Ip2GIftet8iLJ9Ocj+zFdtv6XGx4C3Ybz4yGf3q aLnddsxFOT3k9ZiPfq+yizz/G9F/Vij2VSfjeRV4yYRQa+f91uD+yFq5n3kb1/1cinW/45Lfw/KX 2t3+qWi3FyrKDdfbqyPl9qw7H8cP+HKSxXhQ5itcLypV+Nuc29BOguT9ciLuJ1bjuq4R+ZvQL+nQ fqKRvx/XG3Wt5OcNUg9iPRaK/K8Y/0vcZw/pIu9fnkB/W6xopwKOWypaytO9G/1S6RB5/dokOwyS yx8wF9O9WF6/e7AcyoLk9lyC+zsliv3ZElyfCeonr/err8H6CpbLeUDaX1Cc+3LjfqjxMrmcCWjP FdgfSePPPzdjPueI8aV19Q9DUT7O6yV76431UtFBjNhSWv9Ee9MFyu3tQ+m84hB5PmeiH0tvK28v 3XAcVY7rgdJ6+G04rymZJp9frMT1Yd39In8M2+kBaV9MsY59Wjq3huMiaV10G/rDSsV+RMxHaA9u Ud8HUd9rcf5lbCvvN3PXiP1OseL8WHeUX91G3t6Xod/QBcvtavFL2K7xpSyLsV4uxnUhncJ/bsBz ULrRiv4Iz2lUK85pTE3CehknH28v+wbt4XF5+3oc14HLz5OPM0fZUa9guf3Pmoj2PE4+PtmL/Xjp ZPk43Iv7s+becr+xtBzt7XaRD8DyT8b2Uh4i76cm4zmrchynSeUf/Dy20ynycXsa8sIU+Xi4Ffq9 im/EBJ9Gv/faNMynIC/nG3FeX9xRzu/CdUtzZznfFv1S0DA5n4H9fjqui9a83xDXi0pQL2l+mp6D 8fvJ29HvH6B9Yju9Bfly7K91eI53nFT+eK6vYohczlIsH+MUebt7Bv12EI6jpPWuH1LQbvvL7Woy 9rM6xfz9cpxXmmfK5btxXbTyMnk5xErtVzHv1qE/d2G9DEU7icT5b8VbIi/tt+7F/a8QjC+1C8/X mJ8CsdxGo5xNuL5XoZinu7ZhPrFe2iLfTvL/58vrdwL246Vr5ePhgUbUS3EephP2O+Ud5fVyHe7/ GhXnvlrjflaFYhw1XDoP+Zy8HMy43ms8V+73JuE6Q+UguZzr0W8LinXFo7i+HYSO6k/ki+7G8sRx qXSep7U0flac37gC13/KFOs/d+C4sVxxrrgF7qdUK9bJh3kwP4Plfmk/7uuFJCj62UOo7wK53xuB 47SyC+T90Qhcdy1V7DvcgvO4YsV6+5HWWM4fiwYlndfa+7y6P3wcz/mU4PmiPvhy06sw/0Hj5fk/ /wT3dT2FasV5hsKfxfIMxPI0Ij8A961CIuX+JHijup/8Gvf90y3y/i5to7r/3InlXz1Q3q99gfuz 1YpxTh7qW3Yf7gujvsX4fEQp7ttK6z/P4DghCP2/tO5dYUb+Unm/M7cU7Wek3E5mpKN8Rbt7D+eJ ulHy/mUFrqsUD5Xzd0r711XycciaWGyPJvl4cin6H8kQpHRboh82DpK39zn3YjsaLW9Hc3Hcld5T bj8/4rmmChwvSfPH9ni+sRLPN87G+ItxP9GM5SPtJ36O+6rl3eX98vIjKGdNS1k+r8b14ZK+8vL8 C/s713h5f3Elnvc2J8rLJxDzX6bY734Tx9sVFyv8IfqxIIUfexfPI1ViuUnz4nex3yzvLbfPyzIw /4p9hOO4DpCusJMx0vjzIfQzWO83oB8uV/jPl3CeWx4rl7NtNOZTsa67eiba5wi5nP3YLkJGyvP/ Le4flcwX66UD1vsfWC9linNiK3D9qlSxfvUa6pX+qFyvBXieswzXD6V14xQp/wq9UnB+ocOXD/aX zm/guqL04kZJrxfxPLDyOZe5ryOfIfcbXfBclksxHmiJ/lB5vmtOObavq9GusHw+wv1QXbxczhu4 v1yp2O/g+4SdmFUGryUv7mN/JzD/yudT9mJ5GktE/ls8WPA7jifLFOuQc3D+UjFG3i464jyuGNcl pPFDBxx/lnWVl2ckPi+jfM5lOvo3I+7PxiJ/Kz6XYcT1vXuRPx/X7c2K/btRaJ8hOrkf3ozPs+ji 5Hotx+dTKpLk63JXVaGdF8nHXdNwXaJSsS7txXFscXu5v1qD66XFeG5BWi99TdoH+VDkpfNFO9Gu XIrnJgqx3MxXyMelgsUyJ9/psHi8VrfXYhEsdofdK1iy2UWwJKZOsmTZ3LY5do/X5k6dNC7P6bCl WjPybOJ36t9YMousXIA1z76QwQmFlmSMNy7P6vHYPEKePcPtHeFxjtALI50u78gUZ7Z3vtVtG5lv LbLl2dz8munMd9nZ54sNOn3UCMMI/Uh2lxTB6bnYY88Hhl09C5jwfCZPsExzzLc7sliCnoJ8lvbM yfowIovF1YfFLXBY8+2Z063uaYkOr17vtbiczjzLfLfVFZbtttlMueb8Rt8Zbs3Lc2aazCk6iy/3 RnjgVpMvceP0pkLVeOEpXrfNmh8/KSbJ5nbY8qJsRbbMAq9Npx7fYBCjTbI6rHNs7liW37kpCxyZ ev2UAq+rwDvdmldgG6eRmPbN8912r02UkDg5xaLXJ8yYkp3tsXnj7UWJE3NDDaaJdp1pIvsqKsU+ xzHJmWUz6U38rzA3OSlVtbg0UzPMsXknWV0uWxYzKVNyUoont1H3h4KZx+cVeHLsjjmNVDViXoGt wJZss7LE2UeP15Sb0SgBkR6SeyhutRILi1IpMZ1YYlxjqdBSPGHMzl16nYU3Uo/X7VzAS8SamGki Xxt0lhSLLd/lXcBaq4s1c6ebZQpjsNo2J2XSm7xRluQMC7MrW2JuijfMZbW7E5Ny/bMlkynFy3KX whpsplfv8SamhFsYFZZn83gSc00sUU6Y9GFMgUxmyV6bxcF0TZzAMuQ16F12W6Ztvt1js2Q6HUy9 gkyvxZviDfcWuPJ4pBQ9uzllvCVxApSNmSUWKmVeFMTFx7mmYHH9DaoZDEw1Vvh51kybhVmc11Lg sDPT8VNFlmZkjYas1bmtrDYxaUOt7iBL/v3fWwrRrBRYw2Vdi8fGOhlSEMwLehrMPC8GzLvd6bFk WD22sETWS0m+Ssmjw2R5q9GVNRBmYfk2h9cso7mZwI3K+HaHD/GZYrXxQTUr63vctgxrntWRacvQ uJf1EckpFpAQzfTMZz2l18ZznJVn5hfH/HzsRBlfxHtjABmsE3VYMq3ezBxkbCw1it02b47bOZ93 6UVFFherSCfvhFnTL9Qx0sW+Zc7LMte2ANubareii7NlFMyZw/vyOING16NwWXp1jzXOYOJUodUN NQ4RTep9ns8CfcqPVqdTN0Mspm85qkekT1nS8up1s8Ri+palekT6lqVon7MU7WuWtEWqZ8kAxiYO ZDya5magbkivc9tYgvDZp/gGPqS1W/NSvMzkfbojnHmrFHu+2eq25ttYE4WRRnKKx5dbIXM1vbzH t/Q8KumlGNSHkrJbDQZpDF6TJCCQwAcXisGkSXXEIpcZpzGAVMTSrCxzQV5eit0B/UW0i4FEB+sx TKojNXls7ZRlsbQGxPJYWvlTlAjrRVhZ+TZsZ3HVtQgzsxFlirPAnWmrVw9lPC1NlPG0dFFOAfQ6 l9tmEqcBvt6iL3BlsYZRX+uoc08EWPk4FqWA3WZ3Ony9MYq1LBh+T7QV2niLdHt9vTXaXeAgKY5b kJnna34NdfIbk80aCWTERxGimah7gDpxDb7H1TSVOhF9nQZqGktE3RkNuCog42we5q9NZu4zImUc j6nu/OsIrE/xOpG18mnQi67MlAcDsCkZbGRVaHMbdPmUHpdjdcxhKDmJ5zhUdotqbjXEaubClwFw 42/2spEo6/D4ykmjb66d/E6y5fsz+ZW6CtEfcwHexkkIkySIZSCKaNwUmOogTiJAkcblI3KOciLt R3HUFaI2G9cYibK/VIuWrTcxyXoWAPxJ06Ne4mLDUQ4PmrieIQ6Umiy5yW1dQ644OGtcs4vi3Y52 X6N1WzSfakFDa+SqWKqlUWaMLjcvL8/OBoz2xtyq1fVoxm/k2qCWg1NMCJkG5qR8VaXrxlRdma0b rcF0+bzPx4QxaoMi+bzNR5EYtWGR0b4pjfFAXjSb/TsKLJlFRfpQh22+BRamYS0FFn9Y/+O12tlA 0ZJg9eTgOpm0DsSmDMpkIhOnwKq9yTQxAwxUr8uyoUybyZwSZck/G6nGNYt2fLnKk2N127IsLi+7 pe64WzGL0tI6pjm09j83Z6c0DLqYDI/Xbc2s7T+c7gV/b5k0lKczUjIpzjNq/dqpNayNWZZAeG0C sNJYJ7+hDeW3IXkNe5mGJDSsU0M2EAXTfBiP8k/jnA6HLRMmoXX0DW9I36ak1SyasGk+SvfknGlN NNPySRPl5opkwPYUb0QhE8VjGSyJzJ49NUv/dfWI9kEPP1OKxF2wRNYsTaZCs7jjcSZSalJ5+b3Z 0njvc2ZyUVvOkU0t5ybkoml1wOrTryZWv8DakglrcsmAwCYq2VBnqjVNEhcI/Onjz3B2ags4uukF 3PTsNK16cpvZBHOb2QJzfdTQl2E8yVi4jxnzSWzD4xEfBTVKUT9G7n54zSYl16iC8SeBZi0wzWH9 mSw27USbtfC0k2lKEfJZQlMalZq4pqgNAnxXCEZUSu9naNj70btVUouwsNj2OQ6WqYyC7Gybz80/ wjKJq9F8AiOZQGtWViMl+tMQ/cq6Xx7sjKik3TzOiGL1eJrmUA+aQXNkXGzffmSJTl30ZOoSZvGz TOsX6E8W/R/1+5F9/xPzSzXumPzJJb/PvwSbPIz1K7tNTtUvZXP9y22uMrmkBk7VhGXYsp1uOOur 8IMatyt2u8I89oU2H+NGe53sE/swDQ/IyQ5fpaXyZuaHJDjZ1jyi4ERaI0TJD6/oI+wezoiNK87p sImHaOrcqL1xLTs0opGs9rFtu0c68B2T6bUXatVLfQKalv8Ih82W5Ul1Jktbgo0U0KA5wjFcvtDq 5ac2uYv2aZCCXlyxRl1znNfEeNu8AmuexetM5E7fG5bD0uAfJ6dEWPRRlknOLIub781a+Bf8RD3/ wqCzxNmyrQV5XvHLLPhW+srstufbLG4b5ywuZ549c4EoLrJWAzYdtdq9nkS+DD4xQycthxv0rBEX eGwei4elxaJlFGTOtXlNZjMIqLPW/F8qG5ageELYB5PwY/DHiyPCz+KI0iqOKO3iiNIujqimmkqU P6byHyiz5jQhzWH2v61Qzroh/c+UXBPMiU9+/m0OuNk7p/+BMlExAYPF0ig3OpGO8Q2WiWxIJGWC DXBdXp8la7Qrn+U3+RALn4E4bEWNkOjvAZHmT6n+YxdNTq/myINcEjP35j095KPAph/MaaaEfD3t 4l9yKgdNmKCGT4DAgUa/60J8RpXNH5slPf+r6uzmo6GaPKO5IRXd2HSIYTTHURnfxDR4TkUU48vh DR1ZsAyVH96oX0gznExoIAHZBn9DcZtvr7qBlHKVUX3chq3HAYVaNIyvkVuz8jv82xStJ5vhPmSz KRuljZNU3+bkGVai4Q3LeuXhVmITDaK+7UUSU74TCO8xqHksnAPpzHqKM89jMscnpzhTMDVPzVf/ jQUimJ/Ubrfi9MSjOT/J//+y+U/ZR3hmns3q/k+pXOM2/tvrfvV5BrUlrgY9w3+4zP7fnnz3JP+B omgOD/M/syB81v3M/3zJ/b9tNbfP+Z8pED88z79xh6HZZzX/w2XyX7AHP/3Av1FV2sIbN4zy9U4t Z+jz/Q2sSvoqp56V5UaI0FpV1hDBTIJ8Y2CVCEftLdaCokReC6Zoi/TazURzU9bGTYWpFubTmy0h zdXzRiZEF9jg1vDaW6fD8jq41KbsC0jHiGsl2vNdebJib+6UQmW+0WRmbP4ZS0x68WWqq/YhhjOn W1PKTctomr+GGkypOWuowcSat4YaSq6eciOtjcfWN6bM1e6tU4p6zVJUu71R5aIiQJbb5jzx4btg vw58NEJ8/Z1bcyWj3e6bMQUNu/UzhRSnzzf6t4XLjbPQmlfzFMAZ2cZtTCK8i2xU/CZv5zYmtVz1 6AUOp5u/3D/Lkm91Jda3sE+GuspBsHzPjrd8WfUq02j8WNXntEObmrbWaPeM5YCNMP0u2bCaFpfp LHB4E31ucWEup93BSlaaVMgPgDThrVA1cp2m5JRIS1OS8/9QjyIb0Wc0Gw2/H+nMZUb2SiIfi77h dwXJBBkkQRGWFJdoZvzZKt7l129t8IsEbjZv5lIlu4uoGUZI+Wm2033yx4iT2RTHzEohv6kJN+Fo mSJDMZaa996cyQw1eMbsrGSLHjZrfMU0ZKNKkaGWmsfGtUQ2aW6uSC7cQqcj/ianPUP3KzlfBlF1 H9yFdppikb1egaUSbXPAmpM9OzHN4+YPVTqyLMwOYiz8CUuMbcmx5blsbn5yJ8y7wMXrJbwQxk2F SHB3Z04xWc5Y1mXlxNOKOmPlpHgFBSSX6q9mTThXqKiwiPorLLqxFcZbZ9zfo1ZjvcQZykikrGwL ISv+VzSsmynqLLT+OotobJ1xBxHT5Bw2o89BmZEyjQtBahNKsumnXxX1EFV/PcQ2th54Vxr/N+vX 2L79TOdI8To+yJP/NpD7T29Muc3flnL9bUo+HatWlGbY31CavuVT8U6zxpWAH6P4Rna0UY0tmUhW MuPOaP7rdGSRzVhi2sfD/03lVo8WzVl6cG79n9TSVPPnfwvD7UGF3zNYyH5DKF/8omNs5X6BwWKq +dU4O+4g8FF5mHzNC+T4O7xLkf0qXW0/Z1BLA04KqEb3qMVuYl+plZaq+rkasWWP7fjkV1Vi++Fr /JCi2fIalsWttU4saloWuVXVjez39KCuJJaOCtnUgZNSJOhTS9Y2ombcLm6EUN93ODWbu3x7sPbn KO2+7f7wTNKfnIywKJwHd9p6fgSKFSiMqFR/GjTCUucHT5s1A7Xp8c3bROagYVHsjCseXvtrsH+b 8nAAje8eT+YLd3X2j89MopGsi82zZXtN2r/YecbSVrzn4EwmY3PzddC/oVKjWPm67XNy/pYCVms2 Z+33iRv0JeF1S/6sZU7pZ6K1/cxZy5NPPuhvLDSf/dPZylBjfdfZylc9fu1sZkHb5/2NRtRof3i2 MtZA04ejBnIxBqUYg09uz1Bv4fucjtKDRfjkwXwW75Mzah5V/PErvspugovwNQnfWntjpGk33OYp 8Ka0QV/TaMgOmzrhU2YiUpmJSJ8aY2T9BXp2cqlsyrG+NeWzkzmfHME/oRj9ciNnJWdNcUJnJYM+ urCzlhdtB/hPMLQmuc+zksMGPEfu2RnK+JqMfyMZX6U3w0DGx6T8cUA+im6CB/ExBd9cQCOE+TuI 8TkJ/xuhj0lQA5SO1kWQ5wuhhsXjfk15sZ8e3t6oYTJnMt0o+fOu2Dikg7BnNu3ouml7zlbi9T38 rP3s8xnNUnOYmh/bUGfUBJuSH3XTjG6ydTQlTxom+7dm6mybchOyejZMvOGj3H+HoTecq7/L3BvO 2d9m9A1m7Z9m+g1m+Aw0ANlDA2fBtGXpnanhQ31pnrFhQz2J/s2GRrOiYkIsd7UZgCNO8seLGzgl WPcJx8ZI9ueU3ZlNUft8WrOmC+e/GpYoVrotwymdR5to15maOliESwSb/rCpJnk+7uylrW2FfqTp /4hCUQ6xzVcOTczTWS2fhrqdv6+UfMrZmSwr4jnPXJtpIE3Uj8XSW+CH9GwejzO7mZ7gNKdaksU3 0/gj338rh3RjzlS6DdlNs6ZO6ku7NBt6uhLuDFW7swnnDUWp4X5K1XxWsj6p9GwyxDOI8cIynQVe 8ZPNkZWXmMlvzWQZkE42Z5pYo/LqQ1lx2DMtTlZ7Nmt+YqolVWcxpUSIQqKkFyc17bVP/I1KzSqR n78UhSazls5z7IdwzeL2O7uaJ0Z9yC6tRx43VCUD9HSp3oLRNEQ2qb7EE/GNFKddnmriZPpKEaLP pLdtpPDmcbXNnGhj/GzTktZwstH+edg8T6Jv/iczlXmfcIs5KZPdlzqubqmHp0DE+Ekx4qabSWfh Pb0BzNnugI03U6Pu1dq+81lKlJgFxW/Bwu0qZiP79V3NSHXUUTNA3xKsk1+NeBGqBaBig3rR9kx5 tnybwzslw2NzFzL714hdX+nW45bg+xRfik8tUp3iU4mkWi4q8dTLpW5EedZTfcmVSiS1SlWJppr5 uvHqLf3pk5kv4O81sWbYC/X6SPaZO08Lf9bKYndkO1ViGdhnj92XiGycUpivGbPhalWLVKcAVSKp lkzdePWWTI7DEBVl8f3oYiSbotQ4ZPEAYzJzqbm5TRPGuhYizC9ZHvWMJSeBx5L/ELZ/qntUc1tf AtxfNlhtcTqYhPkcXV9fdK3c15+I5l2ytJr649qphTqLwxCmoqPM3KWs+hhb30BshZtpULoyfkPy tarT9xsaSKGhKm30fSS9UIPv9xl0+bQ3HJcDLz42ifYfKuspTZL8SEMjzKaBX0QHgY2x3nA2fLN5 a++NjvD93ih3gWPcgsw8eNcVc/VWi6vAbbMU2t3eAmuekG/LZ6L5Mk2d6tUnzJiSnc2+jbcXJU7M 1Zv4Ks1EVkZRKfY5jkl8H0Jn4r9nxalCq9vu8FoKIKLJ1DSBWU273d602/OadnthU243NE13Q9N0 N/ime6hB5X69mimwmL7ZQj0ifSqQeu73qUTqub+pReKTPWje76NB1HN/0/T30STConz1DiymbyZR j0ifiqSe+30qknrub2qR+GQSmvf7aBL13N80/X01iWifTSLaV5PQFulbkWjf71uRaN/f1CLxzSS0 7vfVJLTvb5r+WiYR7nC686159oU2S3ae0+plMpij4YG/0J/bQWTCjHj4Ji3VYkrji6ImU4bMPvgX JmoynsQ0Vx6LOdEeype6MjIy4ISAMq/qWVW3M5V8RppEr/iPzyhrptBW/x0Zjf6nZTQi0+rxWrLt RbYsA/yv7fo4jk52FjiyJKKmRaToLaiVPDM1qqWlwjuS+Rwj1MLoUE6F8f/4Q5E+ZA0LUc/Gbrnh oSbNLrve4hWnOIoc6vnXBv4fPPHOSjTMUluKqFl9GeSp1JSd+thSUXTcCdRokuFzyVGdpAKEDIc2 IcNa5fjPzbFv5vmPyrF6x/HPyHGUbZ6loaKt+UKrodcYPkbgGTNYVPMLtNTeMLeq+apxeqxEwkwm d4p6L62Ye0exHFky7F6PyW7Pbyg+n6A17obwRt7Ax/uNuyG6kTeEN1bp8MYqzUu/cTf4EJ9vy1ka 74SkmMzO9HWg741GrROq4SM4Fcn/i6JNSd9gU5Lp5Fujr9OLKuHfr5OjVieNlRNf8sfSw9+oqpPC HK+twVJrcKhxBjxQtMPpbSbVufg666c+rkvp9S7esmI843KkH89roqgUr5v/AF5yirNJwgxzbN5Y uyStaRkLZbJSF7hszSMMC6xZhIWxnMEuUYwn1unMaz5pE51Nzpv4g4rxfK7h9TZd1YjazMU5CzLy bE2UFwn1wM023u3Mj+W9AbM52GNsWKjWmpw/zaEBWY1sD5rS/GkQmsL8ahHa0vxpEprS/GsTvohr RKPQFOdnq9CU52+z0BTYpHahtTDpT7toQFYj24WmNH/ahaYwv9qFtjR/2oWmNP/ahS/iGtEuNMX5 2S405fnbLjQFNq1daKzO+tUu6pfV2HahJc2vdqElzL92oSnNr3ahJc3PduGDuMa0Cy1x/rYLLXl+ twstgfW2ixSvPlw8keqBusooyFY7Op9i5edXQz01j5E5+YNldofH5vYm5vOTrU58qbgzzyOutDAh 0bVnXZlo6cSrlvRxehO8iCPR6bFMcdkc+UwBUVAEf6oxz4ZHVvgxXDuLw0/d1j66EmGRztRK2Wrs EwBmPtXiWzGpqY3OO5y5k5Uli65RliqRGyp4dochlFW/Jd9jt8xnX1kkVd3zzGAY8E0Om23n2WrX uQip14t3xGQ43V6yYUajhIpvrY83c3vJhmNtqvHCs/MKPDkzrN7MHPHhVnVxEaI4Ek9TYmSW3aOI qy4zys0P1NszvQqpdlWlxxnq+VJ6qqtuuxqXY8uc6ynIn2TLZzbJJeAP5tV/Bk0fkSk+BcBJ8VVI cDJwsnhWmkWsPeWqKTDFnm8qyrS5+KMEen2WM9aaOTfVbc20aWRWdgOeBWsoltaGqeLMmz6yRh/p EF+tQgaIKx1N1VInMq7AmhfjcTEhkwqKeFQs0HzVVT0aP9k2x4f4eGArzuZhHg9ObFmzssQztZBN 1bPMvsjR3NWuG1XTkKLi7dlOXk6pTumoNKqToaFPlHlcoo2WrD4C71CLbtDVRK+ttHpv0PN8pEKe YrKsLq/NTTKleofm2U5WznG2jII5NYfzeHFHmRwF+TLaYxI7mjqCQ2XlmFzALA0yo9d5vE5Xag5z Vlnq5ap9K/NxVrfXv3vDWbfLWonZ6rbm27g+mkWiLcKjIkKjaWhLibByF137QJGnsZpE1Jynls5h NrIGIpgecQX5rji7G97svcCPsojw1MlEYw0hgnd0bFyVyH+31F3g8prMSYXmeLv0bi7fJUVChwV2 KZ66bXSZRrttWVAaIIQ75QJX40vFoM+3Zdaea4WHmeysB8s1GwziqVpLPnKWLKvXavGouglt+QaZ fNIGzXz4AAm4JdL/FGa47V5bHRWSmkmHUHkKVImk5tIiorY6s60FeV5iGn7Uan3SVDsRTVHkrLLv N0V5cgq8Wc75jkbex90+d9p1e7TGNS+t8URYRnY+G5fb+MsqrF4bm7p5vPH53sSYcEsm/yWipFRV z6h1Gzw4Wf9NkdJN4gjW58RU7ms4NQMbqbNxInNQ4jTNbGNdsEOj8uCOcJiIgejJ8t+Icng9bja5 yoqweywuZxb/SSjpt6Ds+FtQZnOmOSkzs2aGxDKZnWed48nLy6zZI1JNNdJtc+XxAWQ+GwlrxnLn Y1Elp+gs9erNYnIN6osXOc7qYu3WgwMLu/SnGneStSjezmcfONqUmiGMMmVPSWF3mhKmnmiNINb/ QR+MPw+l2pprYodDb1mbCrxHIZQPrGrHjOKznRp+QZIkTTbqi6M1VIxMiY/BAlP9Pjox3jy+/hgw IQIfAp1dQ7Fwcqbp7WpjSnOzhiRGS1MzC5l01V21kFWpXsdKX3qGWcpKA/fwx8UmswGW1rKIbK4T Nj/H6tWKWdfxGSJZRvjaiazriREfATblauawnqGH171gvM0L027WM3ucDo3coE/JhnWkFDYDsmfb be6JNsccb44pPzkzuU7LT85jLSFFL+4Op3jCsu2OLDZEyhTnFoyJ5OKtbptJfLqYL/aEZ3JnkpjJ X2g7yTLfnmVzWOwOu1RE9G0jOgvzhvk21tXm8Aedxd+Ah9ftOmxFXkvGXK8p38ebwuAm6LY5bcoX s5jiDOVzykzxM7XbFI/ewO7Js1nnstm6O0tiwzzzrWzcJdZCiieCVxMqLWekmpIz+TWxoJZl94lM 7X1kUlQD8qWf+9TVvoklEX5RTnqo3Kwy95b5MOmnHBRPqNe85tXEeNs8Ngu2eJ2J8B77MF5k/OPk lEgLf6GZk5Ujf+jKwr/gC478C1byOPoQv8yCb6WvVCpFFBdJXimDa078IXh+bgQfhgdDwTutBUWs F2H9JevGbHPcLJPMZ7M5F+vUMiD6f6944MVr4oKjpcBhn1eAL5nLzzeDBNnLB8LFl0Y3WEy1P3Pn VzmEaZVDmHY5hGmXQ9hZN5N/of712kGYwg4M/7t2IO6GSOv02qrZ/3WaNauF//vUPyMG/u8rBnGU lYzDLv5Wd7qJ4/8Wl/hLuir9o2IqIr0B3i77jVi7+JOo9iLTFNx7U/2tvobF1/czVPbaH1mLxh8R QHvIgaO7olG4nLyWDLXv04eWYbGzcbQVfiWQCagtvjOaTZ9/XwwNj2lldeFbNRs/aomwwBK4r8ar ZbvapqttuT4YLvzP7QOHtP8trfEtcb6oXfv7lf8CvXyvTfu/USvcg7c7Par76DjWYN8YwKOy4LV6 0aFG22r2O8nrLaGPyljgtXnMSYUwnROPDnhz3M75rNiyLPwBHIweSXl4K7L4BX8nkPiFs8BrcWaL ZSBOstm3YdK3dkehNc/ObnXPKeBbIFKMsEyb2y1ovgiL7KtqRaJLHFqRFC5TI5ZyY1ojWsREp9Pl yzu6MGLDOkTVSGww8agamQ1FrXkrn8b3tatVYgRqJoLmq7UUyqhFqlMhau/VUi1D7YgNJ6tVhtpR 65Sh6mu9SBmmNnaII2i8ykpRQvAylZrXlZNKgC+yeTetJKFRsc9Z4juWoKUyyNqSw2kBQWLcIu4F BKsHVtuzhQxr5lz+BkFb7SeLZ0F+hjPPI/B0hHzIhiCdDsHfYarF4vKnZX7NiZPar5jqjtp81n6B S/tZfCPIkgG7hcrvsjF7ClolFVgXU/uCj8AyrS5rhj3P7l0go3GbzCbuvcq+YrVhcUlb1DXf8EVA OzxyXEPl2zItfCfdotjW04xQsyknizGf7+XVK0MWo64QaXcNi9MJJ1Hq/5Z1ZpbsLBKHv6aHIHGd WqVIPdpl59EsOzyLBfv2NaTilJYlM4O/Ligz38Uv+c5CVs5zWc4FFiXP5uAXR6ZrAb96nXlCnj3D 483KHD58hMc5IoLD/JpPczJZW+RIz5HLC8cdONZxnCnGs9j4xihrDRkejwWORTDKkSWMHzfOEspi jp+YGDvOYhhhGBEufk5LY3zYCH2UwD7GxCZa9CNCFd9Fk6/kN+kpFPhfgCD9BQgt2b8AYFoSXiAx AoRWNah1TRx+pygpoEamKCkA7xKAaQn/S/EF/L91nTRq72qNcQREgtAGGZq/cyB2a0izNcmDAJj/ H1gTtyXmvDXJVwDI5fHaKu6X5+ycmjvF/LUjWgcQeW3Z/y3+/9////v/f///7x//T/RVH/4mCEHs cwgL5sEL2gvMu3U5IXo+/v0B8n1BT3tb7nV7k++P1fm+Jfm+jfASfs//ck48wFxlW2HICZEr+OBZ ll6gEIn41muHBnCPHId4z7NzW3OvnYzYCve3EmYj9g5dEsg9cB6mFxg3ULxiesadLeAapODLkA9W 8OXIhyj4auTLrAo5iNMxPo81mXQg1Rp8sEmdX6rB5xA5UwnvInwI4YsIHysQPl6dLybxb6J8vDq/ iMS/n/Lx6nwJie+ifLw6v5TE/42WT7w6X0rif0vklMar82tI/JdaED5enS8j8b8gcsri1fnNJH4l kbM5Xp0vJ/F7Er12EP444Sto/RJ+L+HTCX+C8Pkknyfi1XmB2GEgyWcg4XeS6CGEjybpDiH8bYTX Ef4vwkcRfjORX0r4D0n8NYR/jPBlhB9F+OLx6vxmEj+c8IvGq/OuBHU+LVEj/gR13pikzpeT/Ewg fMl4db4oQZ1PT9SIP0GdT0hS53eQ/LQj9rB0vDpfnKDO5yRqxJ+gzpuT1PkKkp8s6gfGq/OLEtR5 V6JG/AnqfFqSOr+X5MdZSwtrxqvzlbS9EL5svDp/iMQPoP5kvDpfmqDOL0pU511J6nw1STee5Kd8 vDovEH+iY/8FI21U8GZMI0HBr8H46VNEvg3y0l8gif8Uka9T8CF4T5SCl+QHEX5kQK2cYAW/CPkQ wt9O0h2i4Euk/BP+PlI81Rp8znh1vixRIz6RM53aM+EHUH9C+DQiZ4cGX6HB79Xglyao82s0+OJE db5Eg186QZ3PSVLnizR4gZSzi5RPIOGjaHkSfgixwyLC/0nEVxJ+GJFjTlDnyyao8yFJ6nz6RHW+ iLQXyh8i+VlG/cYEdb6axM+m45MJ6nwa0SuP9vtJ6nw6iR9BxwNJ6nwOie+g5ZmozudMUOejktT5 EiL/eC0tFCWq8yUT1Pn0JHW+nMh/jPBRiep8+UR1/hCpX8rvIPIvJnwF4bNpP0X4UDoOIfl5gdRv AuFvpv0L4ecItfO7Cg2+WoM3T1TnXRp8iQZfpsGvIen+WJt9YTPhlxK+kpQz5ctJ/HFE/uYkdX4H if8QLX/CFxC+kvBxJN0ThE+gC5PEDg/Q8ZIGv5ToRfkgEv8qkv+SJHW+QoMPJnLOI/KHEH404aMI 34XOU5LU+WCSf8qnETktqJ8h/KMk3WIiv5z044sUvNTvLyX8QiJnDeGvqKWFHVZ1vpzEH0TtgfCX EvmHCP8JkTOE2PmXhC8l5UP5cqt6fB2RM4KkG0LkUD6KxBcIbyT8A7RfIPxnJN0iwveg8zLCW0n8 EpIfyi8l8U9Rv0T4P4j8ICKH8ptJ/K/ofGdybXy6S1FB+Hkk3b2Eb0fiVxK+Da1fwp9P4lcTfjVt F4TvQuILRK+uhA4kfDDhhxB+IOF1dLxN+CjC6wlvJLyB8AmEv4TwZsI7afslvJHEzyH8eMK7CD+R 8MWE/46U8yLCb6TrBoT/lsQvI/x8In8z4a8nfDnhbyT8DsLfSfgKwt9F+L2Ef4Dw1YQ30fEbadcP kfjBZpE/h4WfaLsm/JXUPxOe0IKO8LTbiSL8+3T8QPhn6HoC4fvTforwLWtpIY3wrQifTvin6XiP 8IvpuJ3wd9FxMuHvof6H8NUk3UWEX0HyX0L4a2g/S/gddF2C8I9TOyR8G5JuGeE/Ivxmwm+g8zvC X0L9GOFvIfmsIPw5RP5ewp+i4xPCv0fnF4T/ga57Ez6ZpHuC8BupwU2t5QMJHUj4A4QPIryNyAkm /BXU/gn/LLV/wh8k8nWEb0v4KMIfpf0g4WdR+yd8eyLHTPh51B8S/lUSP53w5xI+h/AvUfsn/AV0 3kr4DtT+Cf8KXQcjfG86byL8dpKfpVQ+4UsJf4TaP+HvpX6Y8Mm0vyb8eUR+OeGDCL+D8Huo/ROe 7pvsJfwYav+EX0f7ccJPo/ZP+ItpP07rl9p/ci3/K12XIHxHEj2I8GvpOJnwb1D7J3wnImcI4TsT XkflED6K8C8Q3kh4Oj5JIPw3hDcT3krtn/BPkvynE74bkZND+FgS30X490n8IsJ3J3wx4Q/S8QPh U6j9E74HkbOU8M9S/0/4niT+GsLfSNeFCD+f2j/hF9P1GcL3IvJ3EL434SsI34fwewk/jto/4XdT +yf8BURONeGXUv9P+AvpwCKllh9B7Z/wfUn0IMJfT/0/4UNI/BDCv0X9P+H7kfg6wn9M50GEp+ur RsL3J3ISCP88Hf8Q/mVq/1Q+kZNO+DLC5xD+J+r/CT+IxC8ifDfq/wk/mvp/wl9Hxz+EH0zkLyV8 Ep2XEf4VOo8m/Akip4yWJ7V/wj9I7Z/wuXT8Q/gLifwKwg8h/F6aT8JXEn4o4Q8RPpH6f8IPpPZP +G3U/lNrebqvHUj4YSR6EOHpvnYw4e+l68mEX0ntn/C/Ejk6wr9N11EJr6P2T/jhRE4C4Z+m9k/4 9nTdgPAXETnphG9B4ucQPo3aP+HfoeN/wo8g8osJ35f6f8KPJPFLCL+F8EsJ3476f8KfS8c/hF9C xz+Er6L2T/gP6Piflj+Rs4PwV9DzA4QPIfH3Et5K+ErC76Ljf8L3IfGrCT+Qjn8I/zId/0wj4yJq /4SfTddzCP879f+EDyXiQwg/nO5TEP4LIkdHeBO1f8KX0fE/4el+SgLhH6D7F4TfRe2f8NF0/EP4 c6n9E95Cxz+ED6ulhSLCV9J1UcKHk/iLCH8NHf8Q/n46/yV8BJFTSvjfCL+G8JGELyP8McJvJvwf 1P8TPorE30H41+j4n8qn9k/jEzmVhKf7rYcI34naP+FHETknCP819f/Ta/mx1P4Jv4Wu2xP+UiIm mPCnqf8nfAC1f8KfpPZP+D+I/CjC/079P+FHk/gJhB9DeDPhe9HxD+GNdD2f8PnU/glfSu2f8Cl0 /kv4m+j4h/Cf0/EPrReS/xLCP0Ptn/CZ1P8T3knHP4RvSf0/4R+m/p+WD8lPOeFfo+MfwseQ+BWE P07tn/BHSfxKws+n43/Cp9LxD+FnUP9P+CoiX5hRy++h9k/4rtT/E/5yOv8l/HdEfAjh76f2T/h4 av+E/4L6f8KfIvKNhO9E138I34r6f8L3ov6f8JdQ/0/4G+j6J+HHU/snfHdq/4R/ndo/4ddT+yf8 bDr+J3wEtX/Cn0Ptn/BTqP0T/sNaWigj/AbCbyZ8ER3/EH45Hf8Q/iI6/iH8Qrr+Q3gvHf8Q3kTy c4jwcdT+abp0/E/4ZdT/p5FxC4kfSPgZ1P8T/mNq/4R/k67/ED6BJDuE8DZ6HoPwiSR+FOEnEN5I +CTCJxB+Lx3/U57ETyP8YGr/hD+H+n/Ct6L2T/hJRH4R4WdS+yf8z3T8T/jO1P4JH0TkLCX8ZJJu KeG/ofZP+Fup/yd8JPX/hJ9C5JcTPob6f8KbSfwKwk8l/F7Cb6XrP4QPpOMfwicTOdWETyH8CcKn El64jPg3av+Eb0P9P+EH0fE/4Z+g9k/4h+j8l/DTSHZ0hB9J138IP53ENxL+Mzr+J/yj1P8TfiuR k0b4NXT8Q/iHqf3T/FP7J/xq6v8JX0DH/4T/gdo/4fV0/E/4GST/SwlPzx2VEv5nOv8l/Ed0/ZPw qXTfk/AVJN1ywj9O/T/hS6j/J/xzRM5ewu+j/p/wYXT8Q/i51P8TfhORf4Lwy6n/n1nLr6PjH8Jf RqIHEb43tX/C/0nH/4SfSeQMIfzzhNcRPojaP+EvJ/GNhG9L7Z/w9LkVM+E30fE/4W+j/p/wnen4 h/CzSH5chJ9N+CLCu6n/J7yZ2j/hLUROCeEPEX4prS+6/kn4D6n/J/yb1P4Jn07kbyb8WDr/JXwG ib+D8O8SvoLwn9PxP80PiV9J+EzCHyK8kc5/Cf8WiX+C8EOp/V9O7IT6f8JnkehBhKfP6QQT3kbi hxD+GB3/E74LHf8T/j0iJ4rw3en8l/DZJH4C4d+i9k94Dx3/E76I2j/h/yLycwhfSXgX4a+n65+E D6b+n/CPUfsn/DfU/xPeQcf/hKfn8UoJn0PyuYbwf9LxD+HtJP5mwr9O+HLCH6L+n/Anqf8nfAm1 f8LnEvmVhB9H/T/h55L41YTPI/wJwg+m9j+rlj9N6EDCf074IMJ/Scf/hL+V+n/Ce6j9E34/Hf8T 3kHSjSL8RGr/hE+j/p/wXmr/hJ9H5KcR3k34dMJvp+Mfwm8j8V2Ev53aPy0HEr+Y5pPwi6h8Ov4n fAGJv5Twk6n/J/xX1P8T3kDtn/CFRP5mwl9L/T/hq6j9E74HXf8kfCWd/xK+NR3/EP4JOv4n/Hl0 /EP4DnT+S/gjRC9hNvF7hA4k/ALCBxH+I+r/Cb+ejv8Jv5DIGUL4q6j9E/5KEj+K8B2p/RN+P7V/ wl9G7Z/wG4n8NMIX0vE/4e+m9k/4q4kcF80P4YsIv4b6f8LT5wIWEf4Oav+0Xuj8l/DXkHRLCX8t 4dcQfge1f8LPpON/whcTOeWEv47wOwh/gvp/wvel9k/4lXT+S/ibqP8n/Nsk3WrC30Ptn/BJ1P9f Uct/QOhAwt9A+CDCH6b2T/gw6v8Jb6fzX8IvoOMfwt9M0o0i/C2ENxK+gto/4d+n6z+EL6bjH5ou tX/Cx9PxP+EX1dKCi/C3Er6I8IsJX0z4Qjr+IfxtJH4J4X8h/FLC3074UsK/TPg1hL+D8GWEz6fr P4S/i/p/wo+h/p/aFfX/hC+ppYW9hL+b8JWEf4TaP+E/of6f8EuInBOEP033fy2kvRA6kPCX0vUf wudS+yf8Umr/hL+XyB9C+N2E1xF+A53/Ev5O6v8J/xRd/yf8j9T+CR9O7Z/wL9LxP+H7UPsn/IMk /y7C76PjH8K3pfNfwn9L/T/h06n/J3wGHf8T/jc6/iH8Krr+Q/gfSP7LCC97rwLhz6fr/4RfRuLv IPwkav+En0L9P+EvoP6f8A8T+YcIf5Lw1YTfRP0/4ROp/aeT9kXoQMJvofZP+Dup/RP+dTr+IfwE 6v8Jv4+kqyP8V4SPIvxywhsJ/yjhEwh/IbV/wlfQ9R/ClxI56YT/jNo/4bfT8z+Ev5raP+HHU/sn /AqS7iLC76XzX8KvpfZP+Bxq/4R/nMhfQ/gnCF9G+JWE30z4VYQvJ/xPhN9B+Dxq/4RfTeLvJfzb dPxP+DI6/if8mlpaqCb893T/l/B/Ufu31vJP0vVPwsfR/S8an4gJJvyN1P4Jv5PaP+Hpc806wruo /yd8BvX/hC8n+Ukg/Bw6/if8Eer/Cb+WyEkn/DrC5xD+XWr/hN9M1/8J/xSRU0z4nnT8Q/gV1P4J /zSRs5Twj9D1H8IPo/NfWm6037zhSGDCba27rukvJNxU7m19yNOKGduYQey/qoAA9vUbgbD8czo8 4Mn+wulBrdj/5/c1sk8cwwpTVeVp9jfoJBMBLbGqAvAxjnlKVeWAD3PMH0GqKgN8gONWHJcC3scx fwSwqgTwbo75ozpVxYB3csyzX+UCvI1j/ghLVTrgLRzzR0iqzIDXc8wfEawyAl7LMX80pEoHeAXH /BGPqhDAyzjmj1JUBQFewjF/9KFKALyYY/4IYVX1Xxxfz3EQ6A94IccdQX/Abo47gf6AcznuDPoD zuC4C+gPeCbHXUF/wMkcdwP9AU/guDvoDziW42DQH/AojnuA/oANHPcE/QEP47gX6A+4P8e9QX/A PTnuA/oD7sTxBaA/4HYc9wX9T3EcwHEI6A/45GqG+4H+gI9x3B/0B3yY4wGgP+ADHA8E/QHv43gQ 6A94N8eDQX/AOzm+EPQHvI3jIaA/4C0cDwX9Aa/neBjoD3gtx8NBf8ArOL4I9Ae8jOOLQX/ASzge AfoDXszxSND/T6h/jnWgP+CFHOtBf8Bujg2gP+BcjkNBf8AZHIeB/oBnchwO+gNO5jgC9Ac8geNI 0B9wLMdRoD/gURxHg/6ADRyPAv0BD+P4EtAfcH+OLwX9AffkeDToD7gTx2NAf8DtOB4L+v8B9c+x EfQHfHIVwzGgP+BjHMeC/oAPczwO9Ad8gOM40B/wPo5NoD/g3RzHg/6Ad3I8HvQHvI3jBNAf8BaO E0F/wOs5ngD6A17LcRLoD3gFxxNBf8DLOJ4E+gNewvFk0B/wYo6ngP4nof45NoP+gBdyPBX0B+zm OBn0B5zLcQroDziD41TQH/BMjqeB/oCTOZ4O+gOewPEM0B9wLMdpoD/gURxfBvoDNnA8E/QHPIzj y0F/wP05ngX6A+7J8WzQH3Anjq8A/QG349gC+v8O9c9xOugP+ORKhq2gP+BjHGeA/oAPc5wJ+gM+ wHEW6A94H8c20B/wbo6zQX/AOzmeA/oD3sZxDugPeAvHdtAf8HqOc0F/wGs5ngv6A17BcR7oD3gZ x/mgP+AlHDtAf8CLOXaC/ieg/jl2gf6AF3I8D/QH7ObYDfoDzuXYA/oDzuDYC/oDnslxAegPOJnj QtAf8ASO54P+gGM5LgL9AY/ieAHoD9jA8ULQH/Awjq8E/QH35/gq0B9wT46vBv0Bd+L4GtAfcDuO rwX9f4P657gY9Ad88gmGrwP9AR/j+HrQH/Bhjm8A/QEf4PhG0B/wPo5vAv0B7+b4ZtAf8E6ObwH9 AW/jeBHoD3gLx7eC/oDXc7wY9Ae8luPbQH/AKzi+HfQHvIzjO0B/wEs4vhP0B7yY47tA/1+h/jku Af0BL+T4btAfsJvjJaA/4FyO7wH9AWdwfC/oD3gmx/eB/oCTOb4f9Ac8geMHQH/AsRwvBf0Bj+L4 QdAfsIHjZaA/4GEcPwT6A+7P8cOgP+CeHD8C+gPuxPFy0B9wO44fBf1/gfrnuBT0B3zycYYfA/0B H+N4BegP+DDHj4P+gA9w/AToD3gfxytBf8C7OV4F+gPeyfFq0B/wNo7XgP6At3D8JOgPeD3Ha0F/ wGs5Xgf6A17B8VOgP+BlHD8N+gNewvEzoD/gxRw/C/r/DPXPcRnoD3ghx8+B/oDdHK8H/QHncrwB 9AecwfHzoD/gmRxvBP0BJ3O8CfQHPIHjF0B/wLEcbwb9AY/i+EXQH7CB4y2gP+BhHL8E+gPuz/HL oD/gnhy/AvoD7sTxq6A/4HYcvwb6H4f657gc9Ad8cgXDW0F/wMc43gb6Az7M8eugP+ADHL8B+gPe x/GboD/g3Ry/BfoD3snxdtAf8DaOd4D+gLdw/DboD3g9xztBf8BrOX4H9Ae8guNdoD/gZRy/C/oD XsLxe6A/4MUcvw/6H4P657gC9Ae8kOMPQH/Abo53g/6AczneA/oDzuD4Q9Af8EyOPwL9ASdz/DHo D3gCx5+A/oBjOd4L+gMexfGnoD9gA8f7QH/Awzj+DPQH3J/jz0F/wD053g/6A+7E8RegP+B2HH8J +v8E9c9xJegP+ORjDH8F+gM+xvEB0B/wYY4Pgv6AD3D8NegPeB/H34D+gHdz/C3oD3gnx9+B/oC3 cXwI9Ae8heMq0B/weo4Pg/6A13L8PegPeAXHR0B/wMs4/gH0B7yE46OgP+DFHP8I+ldD/XNcDfoD XsjxT6A/YDfHx0B/wLkcHwf9AWdw/DPoD3gmx7+A/oCTOf4V9Ac8gePfQH/AsRyfAP0Bj+L4d9Af sIHjk6A/4GEc/wH6A+7P8Z+gP+CeHJ8C/QF34vgv0B9wO45Pg/4/Qv1zzN9lUlUJ+GQpw/yRwaoK wMc45q+4rCoHfJhj/uhFVRngAxzzo8RVpYD3ccy3wqtKAO/mmL/Kp6oY8E6O+ZHkKhfgbRzzV+ZW pQPewjE/EldlBryeY/4q0yoj4LUc80cgq3SAV3DMH/GqCgG8jGO+hV4VBHgJx/wVW1UC4MUcn89x 9VGof46DQH/ACznuCPoDdnPcCfQHnMtxZ9AfcAbHXUB/wDM57gr6A07muBvoD3gCx91Bf8CxHAeD /oBHcdwD9Ads4Lgn6A94GMe9QH/A/TnuDfoD7slxH9AfcCeOLwD9AbfjuC/o/wPUP8choD/gk48y 3A/0B3yM4/6gP+DDHA8A/QEf4Hgg6A94H8eDQH/AuzkeDPoD3snxhaA/4G0cDwH9AW/heCjoD3g9 x8NAf8BrOR4O+gNewfFFoD/gZRxfDPoDXsLxCNAf8GKOR4L+R6D+OdaB/oAXcqwH/QG7OTaA/oBz OQ4F/QFncBwG+gOeyXE46A84meMI0B/wBI4jQX/AsRxHgf6AR3EcDfoDNnA8CvQHPIzjS0B/wP05 vhT0B9yT49GgP+BOHI8B/QG343gs6P891D/HRtAf8MnlDMeA/oCPcRwL+gM+zPE40B/wAY7jQH/A +/6PvS+Bi6p6+58R0HEdXEpKTTAqNCtwKdFMJiHvJPyk1LTUNDMz0zId0lwSHVCu4yRqptmiZaVp lksa7gMiiyugImop7mccF1wS1GT+53nOvXPvnR2z3v/v/f9/n/dNnnu25znnPN/n+5y7DMhxaD/K RSC/gPajvBPkbmg/ylkgc2g/yhtB1qP9KK8B+UW0H+XlIHdH+1H+FuR4tB/lhSAnoP0ozwH5P2g/ yjNA7oH2n8f1BzkR7Ud5PMgvof0ojwb5ZbQf5eEg90T7UR4Mci+0H+XXQO6N9qP8MsivoP0ovwhy H7Qf5edB7ov2o9wR5FfRfpTbgPwa2o9yK5D7of0otwC5P9qP8oMgD0D7UW4A8utoP8q1QB6I9ltx /UEehPajfOsrKr+B9qN8FeTBaD/K50F+E+1H+STIQ9B+lI+A/Bbaj3IRyEPRfpR3gvw22o9yFsjD 0H6UN4L8DtqP8hqQh6P9KC8H+V20H+VvQR6B9qO8EOSRaD/Kc0B+D+1HeQbI76P9BNcf5FFoP8rj Qf4A7Ud5NMij0X6Uh4M8Bu1HeTDIBrQf5ddATkL7UX4Z5A/RfpRfBHks2o/y8yCPQ/tR7gjyR2g/ ym1AHo/2o9wK5AloP8otQJ6I9qP8IMiT0H6UG4D8MdqPci2QJ6P953D9QU5G+1G+9SWVp6D9KF8F eSraj/J5kI1oP8onQU5B+1E+AnIq2o9yEcjT0H6Ud4I8He1HOQvkNLQf5Y0g82g/ymtAnoH2o7wc ZBPaj/K3IM9E+1FeCLIZ7Ud5DsifoP0ozwB5Ftp/Ftcf5HS0H+XxIM9G+1EeDfIctB/l4SDPRftR Hgzyp2g/yq+BPA/tR/llkD9D+1F+EeT5aD/Kz4O8AO1HuSPIn6P9KLcBeSHaj3IrkL9A+1FuAfKX aD/KD4L8FdqPcgOQv0b7Ua4F8iK0/wyuP8iL0X6Ub31B5W/QfpSvgvwt2o/yeZCXoP0onwT5O7Qf 5SMgf4/2o1wE8g9oP8o7QV6K9qOcBfIytB/ljSD/iPajvAbk5Wg/ystBXoH2o/wtyD+h/SgvBHkl 2o/yHJB/RvtRngHyL2j/aVx/kFeh/SiPB3k12o/yaJDXoP0oDwd5LdqP8mCQf0X7UX4N5HVoP8ov g7we7Uf5RZB/Q/tRfh7kDLQf5Y4gb0D7UW4D8ka0H+VWIG9C+1FuAfJmtB/lB0Hegvaj3ADkrWg/ yrVA3ob2n8L1B9mC9qN8ayGVM9F+lK+CnIX2o3we5O1oP8onQc5G+1E+AvIOtB/lIpBz0H6Ud4Kc i/ajnAVyHtqP8kaQ89F+lNeAvBPtR3k5yLvQfpS/BXk32o/yQpD3oP0ozwF5L9qP8gyQ96H9J3H9 QS5A+1EeD3Ih2o/yaJCL0H6Uh4O8H+1HeTDIB9B+lF8D+SDaj/LLIBej/Si/CPIhtB/l50EuQftR 7gjyYbQf5TYgH0H7UW4F8lG0H+UWIP+O9qP8IMh/oP0oNwD5GNqPci2Qj6P9J3D9QS5F+1G+9TmV T6D9KF8F+STaj/J5kE+h/SifBPk02o/yEZDPoP0oF4F8Fu1HeSfI59B+lLNAJmg/yhtBtqL9KK8B +Tzaj/JykG1oP8rfgnwB7Ud5IcgX0X6U54B8Ce1HeQbIl9H+Ulx/kMvQfpTHg3wF7Ud5NMhX0X6U h4N8De1HeTDI19F+lF8D+U+0H+WXQb6B9qP8IsjlaD/Kz4Ncgfaj3BHkm2g/ym1AvoX2o9wK5Nto P8otQP4L7Uf5QZDvoP0oNwC5Eu1HuRbIdrT/OK4/yPDNUmspyrcWUBleRbEWoHwVZPgEhtWC8nmQ A0BehfJJkOFVfetilI+AHARyOspFIMOrqNZklHeCDK+6W0ehnAUyvCJrHYTyRpDhUTtrIsprQIZP A1ljUF4Ocm2QI1H+FmT4RJA1FOWFIMOnGq3BKM8BGR61t6pQngEyPApnLTuG6w9yMNqP8niQ66P9 KI8GuQHaj/JwkBui/SgPBrkR2o/yayDfh/aj/DLI96P9KL8IcmO0H+XnQQ5B+1HuCPIDaD/KbUB+ EO1HuRXITdB+lFuA3BTtR/lBkJuh/Sg3APkhtB/lWiA3R/v/wPUHORTtR/nWfCqHof0oXwW5BdqP 8nmQH0b7UT4Jcjjaj/IRkB9B+1EuAvlRtB/lnSA/hvajnAVyBNqP8kaQW6L9KK8BuRXaj/JykB9H +1H+FuTWaD/KC0F+Au1HeQ7IT6L9KM8A+Sm0/3dcf5Aj0X6Ux4MchfajPBrkNmg/lXty5mYL6BWO P04gHnCmzidSqGi+72W8eqyf9R1KM4Zqm8MtMZWqN8ef4YwXgjlz57doBTKTtVmJbdpjG/N9jaGk DW3Gx/3FGbODB2xXtCe/UT0GbNc2j1WpYPxQYfwY1tcbbPyiz4Txradl40P965+x+sGsfhSr/61Y f4O8PtXzRygwB8E/vbmWFWhARb0P7+NMQZVG9nhRzQH20qGoD1UV/vekrP072L79YNa+EtpnVgZw fBmXSbpw6hyusNIQQjvbIHRWh3XG2jv3l9z5AdqPKmk0Z+w8nzbACdH16mmoQy05Po/O23ia1cSb H+k3DkZt1h/+MQVdpCXxLU9xmbcDOKNNzUWXjAlFfTmjRc3xQXtouc7eKJtWzaJ/0vLRZwg8H9RP 139ATtD39Jr6Gp1xsKc+dGnsokqqbX3IjlMF/ZiCVk9l+ltBJXvBAHy+SNdH94quN1WQLnokx9+O N60oDYBhN0GIDdTOhDt9prll7BqEvQDtIkvyJghAKu28zNBM7fpMzlimLi/iwrI4fm5woEo1NNcY Ak9YqUxrD0BDupZDjtC1FDqd2M00NzLQ3w4TWYd9hQ5LhA4b0g71m+34P7VKv439BYYagZxwZk7N ZVq7cOZ4jVq/tZIVa+PDrnDlhzlzrEZtMsXQLgNM8BlqLrM0kONnBozCsVICxuFgtCvQl+6mWhPf 50wmgsLNWjPmgrITq6cUJQ2OKtIZ/1TTqzW1izJTirTzskJ3atfvNF5Rx6ZaDV1FbfhMpkwdNWjQ Mg8HNH+KA5rW/i7Y1OM2bHhx0ADtzHmohakUVOR3xofdovNhYfORx1QMMFmCVKr4sBNRN7hOplX0 ovazLO36Ik7b9Sp+T4rTvlDMmdYuhi7CrtL2Bax9CWufesPQlkstMjzEmXGYoaa5GbTDofxLGs40 d1UQDFzfFszxrDTXSLDdUJMJFBjKx4eHUgUtqGB8eAhVm+6ZVDZ5MF8zTGWCNZNrpOTT9bVVT8lP GhWVTxc/PRCXHNUFcxdZQvO06y3lBakFhv9Qj7xGWR9nnhhOwahXuIa8RB2HMxuYGALztc0K8xUL V8YRrlPn+cktVNpUOJsUZzHVok2byrSJpLbow3Lj+U3BQWyLBrEZNLIZLI0q4joZ4ccAtJ/RPZhP Z7BwgzCDO+lclOEMFtKZCGXtI1h7OnnPcqn5hsc4M45Bp4bNIEdn0MRmUGN7IN6E48JUsmq5xg6s A5OJbVgddfQsLvM87Nn6dEudqKQbJaoIdYjvtCmG1jYERuVTNYXdmojDfBrQN8jhsKqPn/K65Yyb sZXKoIH5sx8Fp8yOpCCiG6B7XTdwO4WbCopcb02myGWovQF8pkybqbHVMGnML9n54NR87Sx4bBDW IYIMpABtnQ0ivx36O36D/SlbkkDak+FJodt6nrudXIt1WQcwn3b1Ke0KnvfsLQcoTs8f0PN23hDe LsH8C5yB6k2z+uI65xs6xPOE43cNVeJx9JjQMbU5U78QLvVo0lVbPc7UPZjW5viSpCIbnYTttoB4 3qY3/wInuvHRNt1WUM4QRNt92JLiRHg7jo8Nj4H4UwK7MT48Jp5e7cDxl2kwIs1OC8a3DtebWofn xobjjynSf+uEwrLxsF1Nnb+eBGBvoJt4Jkw57ZEGFLqndXxhHFX9wyi7PqzY8B++2Hg2IMqewJfp W5YZOg7ltO/tGKodZYmlkxnMF/OFxhMBXMu9cvuuaSd3K6P/qcEZc0M5Y85fSRfj+Vx9dKUhjC+G aGYOrFDEOz6CLoaGs+9Num4aE2GkgY7qPZqq07MDVfTPiTRC5f0JbsXUo/sxNJbvHsHWlO8ayfds rTPerDb2Ps7cNYZe6HBN+35seChVoWuMrSZUC4GrHJ0C/F0K+EPDIu1Eav+XlNPrTfPZohXRJTM8 aYoPbxfPX+L4Ahq/ojlcrxi6Xha2Xol0vYo4PifpmA2Ccnw0MdSEJp1ozUdhQdoB8sAKqQ65rFAO mUA3VE5MIvWnbM6xzwfQFcsl4DCwvWBrUVP2Q8jnb4GekRsica6KqUcSfQkN2CZDeKTeVD3eNC6S MzWRrzPWzHCEHz4WV/ynCeKKLzwsrDhVWgMbtS+/ly5zXJQl+oqhrZ7Po2sNK71dWOlRwfxO40lq 6j6u5aF0Oq8vwPpWp2tL1zcX1rdlpqHRi+ZAC/gHx4ew9cxPuo7jxfPlOvshNtlPHYeF7E/nIvWo oT9n7q6hTshPQCfMEJxQTZ1QbU608/WNFeqkZzgTHfm4nU66uXsdWruft9o1xdpUh+yYfoggej7H Vpf+h2mw8pgbDWpUSYPD4/3SgNpNBl6ldMex1ZH3JJLhZXY72XES4CSWrTcFk0Q9f13PV+IK74zn M0mvI+jI8eYJobSneP5sPH+LNL9GNyufDRDfSm/+jyYh9fQqdVI9LrrQUFNnqtHp+VDtHIt2fQUg wZvnaF37CxG2xlQfulARZPUfDMqii+n+4U9RyIGn2mEPwjxpmyeDknT3UV2Kt8EDlWTgFVSC7jOT iu8aypknRJDHD8I1oenruG8XXGYdl9IisqsY25AlF9nFfthHLgkAutNchp90mIN6/gbFzwTz25qE 6OsGnc40UqUzvRAavWPMS3rTwJD46GvalAuIW+Xk6iG7PXpYqNZ4CoMURz0yX6+Ny4nXxl6hA1rh CFtvnByhMvShbUNNXUN1neJUY16Mi7phhdsTUUejidY4FEF6YCh2/ZfQ9aELdnsn6BoeY9Cb/gNd x2vjyjhtbGY8f43uHuuT2K4HYDW9YnhcZ4pTsf2+y9STzgxFcfOYkOgCTvv8Fc5Uj1ZLOh1doOeP jWlKFdB3GhiiTTmvYrQq4hAsYw50EZWvi34hlIb2w/G0oRUe46FtrBaVYzRDO0X80PO7dRTTQvUU V4L1QDyid9AxCzlTLRizNHpHAn92TEMYM/p3w7h4/hzZUIzDRVl00e+Fxmu7ltKhyugGsA2gtWx9 HVadMjwyNB3s6SrY01PZ9+noHWBPI8EeStGoLf3lnVM7SqBziGGn4gG9johbTIC5dMznplyIRIY5 ie7UJFqrN+FMSfTvcs5EJ92cUMLxW1QYxvdxfGrFHfhrXRn+Yyb4zzx41p7sgz1mbj/7MODspFLO NA9KSQZ1ciujMqwxABJ/gjP3LuUoj8zV4QeG2FcdtsKbEfwV/ASwji+LuqHj6fptYYPl0B5xoKGn xB7pMCSjBIadVEIWnQE02YJjmGpwJjNTWs2Z+sTQmEHDfyP6dzeO43WJNOEJ/ZBicFAB7oIp8MQA NyUTkxt+H+l1WtIZewnCFIc6TkeXEswQaAnc31SWBAsl1V3ahAolTV3aRAolRaecS2KEEmJ1LkkU Sr52aTNIKPnVpc2oQEYCjZmhdBlLcIJTC3Dq2D98Lr2QB9M9VtY4jy0gjWGsTXSe0Eybut2OjVn3 6cLAtV1UWiyUXDnpXLJKKGl8xLnEIpRMcmlTIJQscSkpFUryD7sspVDyvksbVRArmefSJlgouX3C ZSmFkjCX3iKFkm4uvcUIJStdeksMki+LhS1LBluWDMeywKsqZJWs8SppWSyOZclwXZZRtPuofH4v 9RcLrbEM+ulQ7OgnyUL9By++edFZs2RB53fOOZekBwkvK2O/GbRfeHUG44/YbwbtFy/Wdul3cRD6 8SpO+L0bCh586gKoe/wPqYNVtAO82KrEZdtINi2jTeE1HfKdrOky2hQvXj7ksq8Umi+mrdMQX2St F9PWeHG1c2sTTeD0hFPnUYhMZtiYzEBxHNTPxHy0fWAhomEaxS68vNyxGcxb+tKlwV+BIb/ulRAt nSJjGmc2QymlgZxpHXRLCo/IqpAlh6B37IG8fRABMI38vB//SCbzShEJmZo1EPvUuZw5tQPsBX7L KMdGGgY9N2aaNigATbfE4H6ZhyV3SiRlgx3K1pCU3cJBbfM8bGQ2BztUhiHIQ0eUFcnFYtQaqpHV B/BvaEn+LMK/QT1y+LikuzlVxTQe5NC4L3T81jnU+NBe1FjDNMaS7pLG6+A6TZCDcM2wC8wv+NRe d5RLaTLDFT4NT6NYf2QwUwnGJy8cl1zIRPOgyXQ6K2hhKcaXLRzzUnifi+w6i5qdZ5oRbDGPU+4f 85aMSnEuN+2WrpahyfOwkdkMddhcYsdFJcqK5BtcdeyKvIULj8ORHwvxb9CNmI/J53IZU7eDYy7h jTPyANP4VD5qvIppjCX2Ymku4ToeGInTCb2QhOMwna1dprM1TmcJm05oShoyrUAFUv6HNJ3mLQuY VqFsEkOg22lnUKWXmUqLmUpQgYyQqQTXo4qoKtjmagmo0shFlUaoyu9MFWhC0goc45IRkipDTekL 8MQkfQHEB1NGOgJeRjoee4llyxRli1nZMlaWwcoWszKMZvLdMo4ZqmGGwtt75KvTaGjLPWhoMjMU KhDjQWm54cXJrZBHEvNO6Woa2y3JbLdAHR2+6Us3DPb9TbGyLhnFNgnUJO3YckBjMm4f/g3qkf6/ OzbMUNN0ZvP0CrRkFrN5VhnaPJ3ZPF0ThGXM5lkYP01ahov7qFqRzOaKvwT2aIaXFMkPpxjg7Eaz OzCzsWTmAUlpjcPsz/KlqzHM7A7MbI3DSWAIsvKgsiKZyLwYqpEYtu7QkqTsxb9BPTIMzlymZAMH HrCdL+T4uAI+Ybe1gcAvHVdIj70C0XyatrA+TzmqVLuxQoL3NyXpPgntpc7W7BNA++YeAbRLAS3h Tr7U8il3/QQr+hm+T4LRn/dIMDoHepuidtNeo2g/fo+Ec69DmwTfGgDmSD2QvRL4tN4jgU8w9GZ3 136Von3FbgkafofouMtdm8WKNtm7JR9eBm3mq3xqnajooc1eyQM+3C15wGvQm953bxpFb6f3SHsr Yre0t+oclkUOM8t+MjWIvntJj3y4OqmA5JwQ78MI+VioPB8zwb/0/27S/KQA/QwHZ4wDeiZnIRSY etNcLa4U+57HkrTUMuR3pehtt3YhESHganA5rFD0Fb6UMhiaHXGa3BiWi6kYhAZNGgb3iiyajZiW FW5kaVlBVBEc/ZkENSAtq8D8T/K+SYSE7cJ9XUo0kJ+ZOq+GvqgdRkuILDWjF4IS8Tx6CrONystQ KZqjTcll2dkGp+xsfbETFXNkZ1+6lIjZ2ZrfPWVnw1zaiNnZxy5txOysnUsbMTt70aWNmJ2pXNqI 2dn9Lm2U2RlLslNLWRpQ6ojfkIGRw0elxiVSGkAcaUCp5+xs5EHngcXsrKdLiZidfbTbuUTMzo4f cC4Rs7Mgl97E7Oxxl97E7KzQpTcxOyvf5Sk7G+DSRszOjC4lYnb2o0tvYnamdWmjzM5YmsxSYiEz xmWBDIw0kDW2SMtS4FiWPK/ZmZi/kYV5Ui6SR30OL+447ik72+WSayqzM4uYPT4v6xeyPrw40qVf ITvLUGRnmCHqCpTpHV6cudNl20g2rRIzw+qypqvEzPAll6bK7GyZmBbm7VPmdnixoXNreXaWxrAy nWVnmM09fBRBceh2NUu5TPPwch0ZHR/kSHjuz5SAbQHNzmiGZh7kSHUwt2y7R1aFBO3EEAB1SH4u 4mA6Cc4RIn55kd1tdhbDcp1kx0bChPGjI6ipIUvtyLeEVHLgLknZEIey71hkzJFlZyxJM4coE8rk 3cqKLB6xrkhD1JplbX12SBSjk0x3c6rGbT6Zexg1js5Ui3RFzCdXSvx1XbAiO8N8sbIIOPwQFw4/ RJ6dYfKYnc14Hfy9rNDuNjsjjHv2ZV4KX98gTzDN4plmZYx49lXuH/MWiyM7a7ZNulrBiCdL0swW B/HEjtvtUlYkAXmoIFQjuWz+MGurnS2RpcsF8rlcJU8mc8V8cgIebraP26wWiRfVGEvekEjxugzn 7Awzzl8KYTqfdZnOZ+XZGeaPSdtRK8zUXi2wy7KzxUyrSDaJEdAtwaOH9r9uQpWWyRLGvXmSSsvE 7Azb9NoFqoS7qBIuz86QAZ7PcoxL9u6z/2vZWTIzNIQZGizmv9RQ0za1I98yzcNk80yu7BDHkaZc 3ixdTWe7hSVp5r7y7Az7DshX1iVFbJNATfIZWw7M2o5kSjx16177Pc3OOsgzUsjOMHHUMLMNW9WO fMs0D0su5ciOgxxmV2ySnfIws1mSZg52OAnmtNo8ZUVyjDkDVCPfsnXHrO2sRWLTO4FZT8kOlbKz Ej7hgJidEccVstoi8M0Fe+TZGdZurJAc2RlK90loL3XWKEsA7X4WAbSf3yPPzrDlU+76CVH0sztT gtFgiwSj13fLszN5+2BF+9+3SThn2S3PzjxrYKmU9/BipgQ+n2yTwGf0bnl2Jm+foWj/2jYJGp7b Lc/O5G2WKdo8uk3y4Vq75dmZZ637Knr41CJ5QMlWyQM275JnZ557C1b09oJF2lsztkp76z1IUUxB 8/uxLMeRluyDJwNWb5IxswKBXm3eAhcnlZCGB9j9U/F5SEjWIFEz1bAnDmMPPeLzKSyfi1GL+ZyQ x2EmY+4Nd9YGYQw9RL2vr51FKvwHg7ZwftF+20bHLTW8/NZ2hycllcLZJlyMycF2jEXgUa+ItezY N46mfmZWmlA2FNJF0zoYcij/CjWdJob8c+g/w7bY2TFHj504A6gPy7BMZsYoKO/iy+EAEXszR+A/ 6+CDZWQnniy137FBzU71TfPw8tosSWOgfNCEfLIDNQ5hGgfLNA5mGlNeaWalCRaqMSBJpKRxBtN4 FVm/GTVeRr7Kd2hMgX8cA/4QBMi0UbiEacEsKKSxsghWxthzGuZ9LMdzWJrGLGVMx8yOo9dhiC/F 86T29gwHhcTL+RJZTEoHtAZLv8tGS5E88KnggKKljKXELaAjstKExdTSxYCZkqULmKXpZPcmAY7W 5rmxtK/C0kSFpcMUlg5iZexJtHTCytjDaGmlirIOQfIyTJpYgiTO0LphOCcwSew83FyC/6yD782R TXg81f4xnKQtoxgXxJJvJJ66jl3fAg3JOwU4VXlsqiyVUsxgtfASkGMmsXpxyfRPdsXMtFDTWUyG 5xTJgo3o8cPQn3IxmoA/ej/re3Oj4AQvQqg3qeQnQELtVVLt9huFDdgUag9wVztdql1jo7CIGE/d ni6NUpzRFW+QLNiYY2eHRrPpzKb/XXxpiqdg7QeuV+JL0DY3+FKaeW/wRbNBmNrLO+4CX4bjSVv7 t9Yp8aXnVjf48mTmvcGXVzKE5e0s19hfnMjA88D2h35V4sQ3W9zgxETLvcGJ734TtpgpW6ZxFfw2 gCn9/q8ufmvd7N5vV+++x35bul7a9dnb/fTbFeuFzTVnux9+O2m9sLBDtvvhtz3WC5P69Hb//PYh mQXVtgt+e3iX6/sUMQ7+wFeYfmMPxU8qAMKxaaXdHq7Wrodj4AI+aTd5bS3tx1hRU/tlZvIJWnCF M8VBTT4pj1TSMdqx6qbeeTWvmpJ2hxUbK1XalI64iWhFU0KBafUB4bT0yV8Ev+XBWcF/EwrgWRgI ALGmuLKhsfwUFiGhJQuPfJqKxYcIfMA7XYPl0GuJ0KtGUhm628cnZZPv1jCtddovLbrkUrUOiwXF LSROUjzWlGDR1bxiSsqODdvrRndxlNE/o+4U4XpThKL/Mt0HCbqXgu7DJN3ZUWtaDNN9GNOdw7cM smOAqynWI1RcjxvTC+l4aiqWaVOimSJlOclwEbXYjWG485mX8B2RZT+pVeQjWCBT+44vt8Aa47NF bJxURhLYiX8ZOQ3aG7NDnd8PgfEhUUU0F5/PYvqU8UkXCHwY01hBJ6UR6jKpzEQvwtcn+bi/rFrZ tZ7smgnfwAkdID5PyPrrPLF7C3i03gIzbqE6KMaHofmk62A+n1RWps18ho5sirtA66U7lZtoER0O /w54hn+GTo68t6HpzvyYdMeNwOhxrMqFP/ss/2Kt9/JdK1zLHTdSkqBOGcXI3Dj86DK9WmqcdEGt NcIHZKmJfCZnotspNxA+0AUXjBY1H3fBeggRKq4UThWNJ+h20Cj6h4flJkH/ws2a53Je0KhyXqip kk/GPddHeKhYDe5Xyj1MtVJ7GK+K+inWw+JuvmNo1qT/j/T4nJNBJi3H1+NMPSI40/2c6WWKL3Xo vz0iOf4/iRw/De/m8GVcUGI1FR6nT8lMZgSGwAwwr6beDJ5rtBA8DYvLI2UrcBHyIP/ioisAZLWp jpUJqlAzl/xxlXhlmXBl+o/ilXHClbg14hVOuNJ1o3hlseDas9cJV4yWRKQvxtwQqqIF1DFRzPrm B3FPJNGyHLipR8y5OFsxTv4mm89+m93N5yiH7TCQOa6AvVnCw5E5Ha03/QcoUTH9k/4Tt5gcQJMm LSabYH1MwXSWI2hVexFQBIEyTFpALq5A8EkXrsSlw0TSEFYGCW6ydIhFw9LLCFtxdPF6V1AFRw3Y Dpcxlln4hM2kDZZPspAHdrjGL1f9I73r30jU//Y2b/pvyfKif8EWuf5z1njXf/QaQf9Xs531d+Tu 0wnyC8kn0uXlM6bDu0oCZCrXNxLs55NOg/lEs0yMTLlkBIuwBaLOz36n0DJS6YAx0n4xtT/cvYVK ogU0ZoTi/qduNiWHBcFy8sRKaTe53W/YcOzPQtTZu1Sqrli/QZg4AEz0LuMTLjBH7l0WbwYrJlni 0QMz4vm4VeS1pdjZKgKvwjit3DJx5Sxwa4Zc/lZaoBJyhfllBlVgEC5OiUSUDq4SyNHmLPkj+o74 4aRfLMZTpqMp4UI8PqIMau5jaiasIm9+K6j52haHmuCo7jWNU2jaZ5lnTTstEzRtAJqmy/Y/QiDf +wKFrlJROTxK6k3ziKRV5AM8FENGxG57wfWEZXwm+e0b7HMZ+XmzqGskjeH0EsVCeCqRulAc/ac3 pfdZ8aa4BTp7gbTxf2SLKt/weXxCNpnNFiqPDMuEoyrFeie6POyNcQjAjSaKSRkkG0/JIH88xG7v JdAicOOdVN8+3wtz+5ykLydOrjSNql9QsUTnKSQ/C1O4z+LyPoZzfMyZhvzL8/425q4i8x0x34Vv YPljP3gup/vK1IUL6AbKk/+s8OAfHurv/d5rfTEkwoP0T3MBH8O2KCMPLJcaKe2la+EOD6IsaZny Okj7M2Xni87+3ng183c8jIzxjg9QJcLpvNKFn2yFFyEkfRk+Fb7ghE/pFgGfjDmJAE7py0RDnfil s77zlwn49OSSqs3/68uqVr9ym9v6gr1yfouvrMv5kKn9G872Lv5aae/ipX7a22eVYO9z31ZN/4dW Va3+1t881je1/ybWyR7VJkd8Ycfd5WTPD3Y/4ss50Z73vvGpH/jjb6u8++vSRc7lke7wn0bQKVlw aEBDQCxmr+AfwB+LkTXTEEx+X4JQXiLEWll/TnidUAGnZtBZ7wsCUQbwLUG0Tighc1ejTk4BW+Ve P6Vu7vQKV+rlvF9Clfjs6E3QjC4uaHcIuiPRG8VU0t39CMV+eO6XKu63r/1YTw155ksv69lFxZLn OozBUfU7kGk/iw2U9mJ3W+3sbK6M2MvgExIXMKJA7lOh1qZ2d3QDz3cEQ8gpRNloqSO0zCU52JAI DQk2rCtrSBu9FMICFU4cxKZcPuE0uZirjEiu/P1xGeS4y5c2+ShvkuG9/F03+asiH/vGXbm0Xxwp WA2Or86ZutFZeg5vcvOBz0HOZbSEYj6VREgiS3AIex8rlwz6yXEm4Xk/VqH/sl+V/af/7LH/SMfh 9STBPzC5AiGH5P3gOAWlrOLIUtERkVEwd6PXs5YKINQyxzU/UeoPvmicVKbSpjwvbgqq3urF0pC9 fxBoOjzvtlg8wGGoQDS/CXbR0a1r7ZL3yfkLxtbJdN0qXPMJ+XrieaWb8wrWPsRte9/9RyrtLcf1 WCzMENW7lBgXsiRFnFjgJiVkwCLp0SoEGvLur/LpzoW7qXnZLnxSxndAL8pyHnZAh6s/SVjj8/wB Xlsn3b5wxpdQ+Xgk9weGjOxZsZ2waNczREPkDn6B1Ml2m1+47m/MZ8uB1ZIFaxz7Vpp/OV9QnD8t 9byenu11xXs3QJ/8lR/+ydrTfw+R0s891pf07bTIrb5O/MfFP68vlZyl5Hu5f3b8xr1/tvhG8E8+ 6+78U7dMGvKt7yX/fHWFk39mrLuH/ln7u3/NP1Wfy/yz6xfu/HPLYmf/3LXSxT8jXPM9V/8M+Ore +ec5H/752AIX/zywwr1/jrBU3T+5T538U2lvGVk6xxvf1JC3V3osJ0cXeo3HjP/M9dx+gpf98zfx IPHLquFBwTw/8GCTm/N3P/AgdqEsXn8tx4MZc93jwei5Ah58tPXu8ED9vSxefy3hgXWJEx6krbmH eGD78V/Dg2A5Hlz7zh0eTJrtjAdNlrvgQcgWP/Bg7Y/3Dg9yXc5jlHjwjCsenP7KPR7031x1PCAL fOBBjZ+840Gu53Jy+3Pv/Nz06T/m7zELqxj/Z/vh7yvc3y9zOf+Q5YdGyzhI6WDZOs8X/M5oGQXy E5Icg+/rz3PImAL8YfZxnkBMK33M7xJ35S54lD1fAgfNCgU/We4ej1osF/DIuuHu8OjEJ9KQ85bL 8ocFTng07vt7iEdf/PCv4VHMYhkezZ3hDo9GLnTGowmfueBRWoYfeNRz8b3Do2eWeMejtxe54NGv 37jHo92/VR2PNPN84FG3pd7x6O1P3JyHCWc1Ws40ViO/a0paforLVEDHLoXvU/0407Em7J7UMN6N B7CiBF5wgtPrhe+rucUXYY2eMjsMc3s/zSfeMf37BHMtd3KZtwI5fi/urRpzJIctJfxn4ihyhy0l H3wm6NphvR/7qe18z/tJUT+ugusUV6ZNacHGryCff8oOlU5MR7etwBe5+LgK/D1hX+e9ZMVd8T8n vNWIeLtntmBz9mx35nhaL7jXSPEKHpURnxzB+9ZwGxIP+g7+4Boq3OPvBN77+ZO3+OU5HrmNX6Em P+JXv7QqxS/SaeY/Fp8tX1fNvpgZfti3a7o/9oVKNlDPWJoqRCJjFxqjnhAdqWye4FZW+Pllue+X wh74gO5U9tCbcGHQd6J+uOUK14jPm8rj7U142BPCG5k9DSNCqei5gIWlZNd3wqBRN9gTZhrOlKjh MvELdqTZNCEU5sYIXwOMCRZQV4oYv5NX1ijej1bcv3qGAoiGZC/y6g+y89PZ3vevMIdCfH/MEd+F B7jq/IBGluHtTpjU2tQC615HEPcrvjrKuzgVO+JDopM+eXAzJnGOSCQm5ZFTsNng4VwMzhYgHSox o3qboQRe3PWthKV5ZOXX2EWGGKMJvpPEZ9HCDDJoiXQTvJSsYRuP3b0tld6lWIgwSAlT/SXSfpD5 V4p3/tbpe8/lEt8g7VL8WE85vl9L9Y3vYjyd7+jcNX578e+CqX74a/fPvNtfe3HV8cePcrd44Ok8 09d5yW8u8+MpHv0h8oV2Jj/9b4Wb/Mh5fc5N8Zx/2b6u+vx5wF9Liof19Daf8v0Bz0rQfaGhk7BM rU2FVy+t+B93IbZNuutoyvNkx1oZcyK56HLtp66PZ7rig4OPgU34/AYJmcWAGCCAbIKkUXiQg8+B h1FI2kyku6WoGTj+2Pnyp1+iP5U5vuyxjTCBV5KQRR74FubHbuKxG//O/sTrfvHPH2f64Y9Npnr3 xxVu8Orv+Jtsfw3yhBfe+EntGd71bTKtanznXbf9ecsfDjvlD9HznfKHiq895g9/fC3gwXfLFfmD 6/0Do5QsV3wiz8/PT3GfnxdNEbrWL7/L+wfzpCFTP5Hyc73JKT8flnYP8/Ojbs6L/qH8PFR+Xjhm qrv8fI/JOT/v94lLfk6W+ZFPXfvUnQPfXX4+dp73/Lybm/PC6e7z89bLqp6fR/jKz8td9HM6//cc L0m/8f9YvqFa4BH/3J//T/IDL9+d6w++uD8P+GXaP3Me8HaK/Dwgf7r784DV0wWAiPjBj/375hTP +9f7ecCGhew84I2Jd3MecHvc3zoPIO/O8s2flo7z7E/+nQfcN87f8wB3+bS/97OnV23/Bk/w5zxg vj/71+v52Rxl/PtonFP8SxvnMf6NHCfGvyV+nJ9tS/tn/GXsZ3J/iU5y7y9hSYKuFd/64y/T79Zf oqczf3nJdFfnZ3/TX0yTfPvL2KS/6y/fJ/nrL6bkuz8/m1U1fykd64e/2NzHJ498sskcr/NJdk32 UT7FfbkpSP0gfoVBlmrWwK/BpavwTRLkanfm2MX7SX3xfZupDjkU7zcZHXIIyF9NlHhemJuUw01+ C/lvmuAZX38oKetmvh3nbWluz9uSzV7P2yCfUpy3BTvychz8jUXez9umfOTuvK1TmrfztpWj/Tpv O/u1r/O2cLfh002+b3Obf/l93vZlitN5W7/Uf+28rWy67LzNOMPlvM0yQdgm3aZJ522bxsjP2xJm eDlvi5wqP2+rlur+vO18inDe9s0st+dtSd79rdMov/LxXqOreN72ZpK7Bu7xtcaEuzpvK3MDqi72 fWHybv/tVNfyf/m8bdhEH/mFK1+T5Y9j7+o84G7Ow1Z9cG/Ow4aZ/TkPy/r43zoP00yUn4dNczkP y/vI6TxMyjfgPKzlFPfnYfWnCOdhmpne+BPzrwMT/MXL972vtzv+4Gl9xPj02Edu41PiKK/xqb7R KT6pjIr4lLnAe3wqdBuf+r3rLT7VHeFXfHphga/4ZBjp53z3c3s+5nd8+t3kFJ++mPivxadQgyw+ NRznEp9Uk4X4dC5Nik8TFPHpj7Fe4lPiBHl8uvq++/h05H0hPql5d/Hpto/49Lgb/HLjPymT/FhP eXwyTvQ/Pk1/767iU/KHfsSn2m75viy/+eh/PD6NS/YRn6a75Eee7gc1GylsufAP/PS/o97P53F9 Dr3tOT4+7iY+3m38G35v4p9mtD/xr8GYfy3+Jcnin22MS/xLm+gc/yYp4t94D/FvvBj/Uv2IfwY/ 98NtH/HvqPv7NV7j39sfu41/oWO9x78JzvHPcf7E4t9s7/Hvjcnu4t/Rj73Gv7f8i3+zfcY/f/Oz owZ38+13/Nv9jlP8m/Dxvxb/Vk2Wx7+xLvEveKwARuVDpPh3VBn/PvQS/wrGy+PfYDkNlMW/F6eI 8W+qu/h31M35ioK/G/2Kf0MGVzH+XatCfrb0A2d89S/+jfcj/nVyu7+k8u53cX/kHse/jLd8xL/G yc7z4yn+1X1PjH/D/eWfbuLfXcavsjfvTfyqSPYnfo12w37+mfjFvSeLX4+7xi/ubaf4tfRDefx6 Z4z7+PXSGCF+cR/7jl+N3vNzPb94x8f5p3u+olgfBx7W8L7/PZW72+/Uz+V7/sAQ19VTfP+B9p8b dx0nkTYzTrru+CjVdfwoFZE+SnUdP0p1HT9K9f/7E9bbHIdnySzujw02Ncb373Gnwi0QtgFY/Qzh W0+4YDx+fqCiU9wFKpVojfDaOgtKcQes1VXsq2BxB0xxB2jky407zVQ63SmOaI0R7G/Ul45aZycI WXDjn+PrFFMBFT9t3U0VpySDupRxUqnDzlJsVyLZWYrVS0U7lfvZrX2X3nRnH1fF74/975mP50b9 PzQf6ez3d58ZmttNo1IJ89OTgdFtLjcAAwSn/dgCX3zbyL5dp1VxYVlcJunCZVrbTTlhr6FSpcWG a+AXuylk9goPwZ+JjrpBhmAMCBjK99QAbPUT3x+S/bJ2GA0YNaTB2SRyb+ZwG6QqmRyvVejH5daA ao77OxRTFfGsJ5L7TSipyibD/VbxB8tzA8NZjJkYHhJ1Y+PP9O+4KEtcVD451w+WvVd4KJdalNSI M8WHR8AP9raaEU9rWqKO2npyU27Bp9eTGnDGieER8CVGGhgN7aLybe1Y9cwTQVxGqWOO8qApTRLa iT/DourAqYu5sGs2DSspbcvVLOE2CoXJXM2slHxOG1sAvxyeBdlDPxZvnO3DlGiexWE/mxz8VZI+ GrqmOd00alGC9c3pVlMhw6+jT7kwDH6Nma/kzE3DtwbjZj1OqgE/MLff9JpatbGucO09YEXmZ8PZ 7wYkwz0Hnkbl9t9BpWpCJT2tRJMj+teiPmIFo7xCBPbSfjRc0wjXGrFrb8M1tXBNhdfYb56Th4Hj moL+uhOmwpwrJoTu+XD8KQQ+sA4tmQElePsRNqApNjyRM48jXKfOb1SGqZLa0BqJlfIadNljyAA0 cmJ4X7J2BPyKdxk3JRsmA3+K22ihjt85mrZSGWrjJizTZmpsNUwa80t2Pjg1f/Jyzvxr+CBan7R7 w263fQHGmoL6etTx7F8edNxCmxiihBFz73gesa5jxKxBOCET7rgYlZYkGnXsXViA4+TRJDHfTDTe jNFtjKEzHKv9T6GOL9CVl9Atn1qUoNVnbkDY0u803nxq8gS+ILOieViBTp0Vl1r08Yh4U3OdObDW Rlj5ljuNFZGx2h5FfF4mqa4zP1sr83J12ovxRBfEBZ02rjCBP6zfb1Xfis76sCH1Ii2O2XJnWqF+ /6mEmod1xlsxhvoIfLFphdz+Us6epw/LjE3L1O8/odOuzzRaThgrBq4KHRsQm5ZHMaUGZ6b/EfZG OWSCJ2gw7uuMt+z31unuu70R0BI/Y0hy+9vtG0NBjGBbK56/QdbARUjSN4RKF7+Ci+ABG0Kki2lw ETbqhmDp4pj++Os3GscVjv2Cu/W1/vIn2P4pPD3wgXc8VfvGU/U/i6e/SHj62Jh7gKeBXEbZfzOe rhmFCPdubxmePvSWgKdRsE0jR4pw2au3DC5vDhHxtMfLYoW28golQ7DnFr1leJrNrjXuLcPTVUNk eLr/XYSPnyo8YVXHCg9YVf+mgKeqmy7QU/cDEXrefNsDnlor/MHT0/0kPNV41PGzcg86jqyQ4elY LyNKeDoag37Q4xUuRnUYJRr1yVCGp8XvVxFPIz3iaZSAp1H/43g6e7B3PAUo3dABNmo3GnokeBUA sc0gNyDbbJAbkNUMcgOy1wa6AdljAz2A7I6BkPLH/nP42quHe3zlZaAK/u4s+8JPqh48Mw5OH1WE 55kJsO1Ah8zSdlzt2PDg5GfDVYa63AYJu/IAtSxUjxDqDjWoNZmloVxmRRf8t2ae/Dzmn8Ovq+8i oqxIlOHX64ME/ILVJaOGifD0aaIMnqIHifg1K0GsMEZeIQR7aT8SrtUTrgWya30SZfhVNlCGXw0x FQ+6cM0TNoy/5gEbXrou4FfMdRdXTxghuvqSwR7wq+V1f/ArvI+EX5xHHYuvetBx5TUZfv12zR/8 WvMKTsi711yMGveuaNTeNxh+3f9uFfGruUf8ChXwK/R/HL8KB3jHLwcMkXK9GwA6qXcDQHv0HgDo Vz17Pvifwp9fB7jHH+NZtTSktrmL7At/wL+NFyL0Wx0MTuByGhVwOTVds2ruGF0wZXQw1wKjOwNM xARMi/K4+2DnUm5nSYqYQfEr6mhc1A3b85zxZgDlc0IR5V4lhlZRFlsrdgUIWth2qE6pXTuRqJV2 4dQ79WHFtkAoia95TY6Ch1Ogl12AhZl0TiLAJ9P/Pf52dSjDv+5y/Osn4B/+2OSoNx34112Of/0c +Mc58E9eIQR7aT+4u4y/BbJrfbrL8e81Of4NZvh3ySP+XfKEf5dF/Lvsin9vO/BvgCf8u+wX/r0s wz+POhZf9IR/l+T4d8kv/HuJ4d8lV/wb6sC//gL+Da0S/tFxPMGfWoA/9f84/BX1BfgTwMp6uo+A T6Z6XIBWnhXmRRXJPMZUPaAGXJDwQhtVxA4sO9UzBNLsrEjpX9RXOlXXzoX8jBaly87vHoaOTDXK C4ylatYl5lfVWYH4vSBdH90rut66XgBDHfRSa9P7Gm7KHQDEpEejKNeZHKzSpqbC70uYugUDtjya 3EVlCKD4E89brCOgIPViUl2xasprYtWtrMsuKhE7glVczcxY7Xotx+/kyo9wYVcTUiEXLATAjQCw AxZLka2It03Zvuc2DQNs3fcbb0Uiw+WLtT2umFMD/rLbjRWR2h6ZLQt0Wi7LbK4GV24+NbG1ed5+ 2s54S61dlEUvaNfv1Gtj8yk4GupH5cel5Mdr4zJB71/pzKZatClL8VcrKKzy/cObbngikO4FK40B IbqtbenfupaXOH5EeOgWFe5L7s8488cxuvJjOn4H3dV1dPx1nqKALYLiPe4j2NyRsfxZjj9MVsTS DWfcYdEZs2N0xlz6/zmWWP6mMZP+t4zT6ndgC6r+IS23x3iz/eSRqUUYArSfwAKZ29Xa9jRszX3G yqe1PQ7x++heNreulXmxOt3OGDU2YSCLvcaZ+tPp229TX4qu/PDx1BuobVL4VtzZezkTTeRj0q5w +89xNW/b6grrT5P9plEXYbcHI2jCZj/L2ffS1D0tk9t/Sme8o9MaH7UzjwWjYvnzYNf+rnR+J4aH qD4eDEARPEOVYjH0MY0IrxMwIlyzCY+lbMbbutFPxlOIjBR3LJuf3EzQmcImf4nMgI62W4w7Yoy3 Y8Yex2GECvwl/ggZzgZqqoL4FjrufhgtknJ1Y3aHfrr+ugG613UDB2zPgHVqmbfhGRg3Ew43Irgt 4mY2jIgqgql9KzV/XCidNsMDrML+k+LZC92dYTttcUPTbZVQddfEjmYuH+caqtfnTAaofomW2dWG h2x18A+8agiW97GX46+aOboH238YGJVvq8Maapfs1c7JNFbARYt0MUc7x8KlFmnnZWmyQgvRLu36 fONNtTa1KUy43cKFEcDNSGsdu5Bf9aYBUc/vpAu2CWZS+58jqTc+qqO+Vn6Mrq1+//moG6lHtZ/8 Acyk8intrAOwhQIfQq9peQWd5TB/NfN89VhzYNs4PkeXeam68WyXDNwjZdEl2m7bjRUxSbV0/JWo i/F8gS1ax2/fghuD7oYznH0PLcFddIYrP2is6DL2Pi7XAtbHph0GmCwviA8rsAXQpnwx93Dr8ti0 fLhcEyJMuS66+MM2cak3kp7QGSm1EBtmQg1TY8rEYltuT6O4fJ51w9UsoMmcLQAwzumeA41/wv0f OX6FxPJ74vhsjs/T08DBX9Hzd2D6gvVTKuA0S5vyOwWlGb3CE/UC/auh0gt0K5DCl8UQEZ9aok35 lcopRYY+ghbQgy75ujom+U+1brXaOg/AKeW0NuV1SiljUi4mDU4pSnpdb6yI0k7tTi/pplgK0KXX W+LSEihvidPoc+PwsSPrM6yJ4X6nvmm/UUW252i3hnB5EVyOumh7BFAxGJYBQ4GtHlde4lQnLuo0 jTrxYcc2tYHAIPqbfZfxdhsakcbW3YareBj8Pyw39ei4IC7Vbig1Tyg03n7SkGS8HalNnYXR69nw WAp9dWI0B3Vpubrkc2qukMBgqTdwPMPjyD+3tnHy5gQa856kjEia2wS+TJd2KTbtTCz13DqymTY9 G46/esupLXSWduvNo+1cWA5Xk3qPgRqUdjnqoi6t2LoMdvHtqCQD6qPTXIhLO6vTFMek7YhJPqMG 5Qouo36ZpJpcwbZgA1MyykXJbMK/CsTk2XC5oqVOKtqeMtorJ4dvhN+ka3lEm9KVTp7xVlvtzI3Y Fx0Fl1NFL1NN49LOxaXYDQMRCPlM4wl1rObPpCAIN92pF+vDsuJpaAvmtBtLI8dE6wvP022GVwyP uZ/LeH5HHL+XHKcUIg62MTFuL+KP0/V6WvtJBsQgdW6Mdn1ufLTlwzpcZ9zbqXi/jO63DBDxgEKn rR+nsWZTEULdJ/Tf1KJxwXwhQFoN6nO2ZwHvjLf2TK7tMMkWyReWH+b3Ai7QahpuPyJQsLFSnVTX UYuiWIC4/+wUjNqMfcR4sgtdy2xGlnJzKqkV8HcO9zBdUq5mDi4t92ZurBqoCtV8TAvwuGaCZ08G wkKTLofH8AnBtjogafswQ+J5AicuMsxn/u8/HraR8LCtgIdt/8vxsIZXPHTwOfX/rXwuakOUM5+L cuFzkcDnimR8LrKKfO7Je8jnJuj+d/K5JTFe+VyU33zutRjvfK5jzN/kc+r/V/lcpIRfUQJ+Rf2X 45f63vI5rYPPae4Bn2vj4HP7/if5XFtnPtfWK58rMN5+CvhcVBX5XFs3fO7SSxKf03rgc5oq8rk2 f4fPuZLObKJ/ScnntC58TuPgc5EKPtfu7/O5KLd8znkuBT63KFHic4X/HJ/b/bf5XNu/zefs/wKf ayvhYTsBD9v9l+Oh1jufk7O4+kjMDC1g/yRbt7sQttUCYbPVFRieNuUEvaR38Df9ZpG/6WtmA/mr C4wpRF/+e0LYdVsQCg72FmXR8Zd1U3KBviHv02n1+4w3Q/F+E79X2+Oq+Svkb7dDtT2OtNyl5UrM qUjfKkIn1Uw9mjTI2oSOnnrU0NGcehq4XMXTOv7PrcCFtD1y4vkh4REtc8B7IsiC9nTW+EvgfRGw px6JDyuLjy4zNAM2OxlvcyRHUwv30XVj1u+gf/HtKM5NDK8DXYVmNAP6QODMWbeNUb7LQPmCRcp3 J848llK+4zr+D0oRAynls7WE+Xbhe48/Led7OcD5KNO7gnyvQs73iu8F3wv1yvdC7yHf69keaZhG tiFi6RB1Pn4T5j0E6V9fSv8CA1qHbwp1sL/IePOQ8EjpBFqJcuco/7vVzjv/O0LL41LtYF0yM5ku aLCfPJA/YniTcb/+lPs9ApBGd+0Ryvziw67aOMA/3CSwndfi3rD9xAhgazkBpKnKMQf9a2Crxegf f8xQPT7shpLy1aDEbpeM7YG83TPR6yQQvSk7cK+KfC+8anyvCPGtuXZWvoBvoQK+hf6X4htvoX8h qDk/jw341jOR42/rtzlot+lxLoNhUyjFQ0I9Z6KWAkG8NrYinu9kfQWSvBvalGb033FRfDldVOqQ dFk78rdo/rn/Ise33q9DZqVrWREHyHcGgubDnazncGJ3amfhT2aze8LWg/Q/+Ck8RxvGGVve1PE3 deWHoy7eyAwwPIZVWt40ngiIuujgY+ZGT3GmRvs5vpGNs++ItiZd0hlvBoyeoWMd0i5aWjlzvC2E o25nzAqINTfqGGvu/1S1WLPhKbWaMiPl79U7+utlJTpzoydFoYwKj4tCBRVaCcNaOeOOQB0deIe1 Aew9ZlNcFPXGTgCerbcg/PxpvNN+bOjQdLm/cvxx6q87u1N/pc565+nRJzm+RLihDr7Hl5cfp5kt 5Fd0imHL8K1vx4d1si2V9LVVOr2vUYX43V6K308L+/vp/9L9Lc8ZFfGbPZ/J34b7fpT1RpRnAigZ QjHS4WM68hUhT3DsPn6Ep3v+r6sc9/x1XdiTSiFwenMfZtPsKU5K4tICKM2y9eKMFZOTGsEznKEq w9M5ASptRNDw1mqVrSOrPuUEolTmifuCLHTfPALEguZTwWkNOb6rhuO7B9sase4yoAhZqLY+lJSw ZzbT/cvXqBralD00/sditobxMRCsohu0LeZox8AumqQNpFPLJhOem+DC8lzStV9VQrqWKqRrH9J2 SR/QMcK0Uz+AfM1oGUTXbzKQzQR5sjZISNbCPI5B+4+jeVsvyNuecl8La9AULtIphQuhKZzn6lI2 B59xk/k75HMtvORzseYxJ4y3HzIMAmKVOgXIC91Gmlh5MqccVsyaHmapSAuXIB0YTnLi6B+mwPCY tPM0nbN+qnLkbuzBGOzLTRYXm1Zk+8h4O0ybCviJmtA0LjbtZKymyG0a5161x9IaCflcmMo1n2tJ lZvRKFxI4jTSboGcbLiUk9GEluVkr0DAlQ2UyR7fodlZ6JiOXKGVbjC8ImZnrlOC2dnqWCk7O6nj j1EgMLTTfnIVRlbn6IxnJydE53xYS2+snKxNtamE7GyySpGd/UVFmjljOqwzVlZObrYR3vaBnPNH AL1bD0+8X0rORtIJpcmmtQXVguZyjVguVxtyuRh2vx7yuT/k+VxHP/O5uq6bETK7Fn5mdglv3pCM HtMsgc5FCKPfD8eyrC6BT6JZXZzPrO7u40MLKT48LMSHh/+r44Nje3rO7wbS/O425nctHKf078tO 6Vto19fgjGVqK57H07xKSvg47yf00FA8oGcPgLkc0Fv4P6bskB3QHzTeUjMewxfGanvkm9diilep 1va40rKY5jxl/OEpmZDljXsI2O+irNR87fqdtOs88Mta7eD1ZOsqga4tcZzJjwhvmlFJwbhlCd2W IVEXxVP5YxzNxUIVB/J/0s1YJ47fjVhjezTdJT/b9Nz/zvP4U529nscjF/XrPH5hZ+/52PjOd3ke b/iQZWLv00ysFYDRw+5P4XvI+e3/Refx+GAUS8/q2h3f//A7P6NbetZOAZ7UAjyp/0vhCSfCc34m 53dI7ookZncrQJuyEJldfHgi8LnHlgVrU9ZguM439IJJbi7wqzLkcDHr1da5WEzzsvYCh+tGKyc9 j71NDUMOl1VNZzwZoEtLooGmt8ThggUO96hTx+spz8q3PedEyh6lgxgaSVVZNcre7isvcb4G8Jdl PBm8CaiGI7+jPEBnft1uvB3I8Yc8kLSjFHMqU48anjberpaUCIAVq9kj0TMYKLUIx2JH8ro0Spl2 0E1ax3rCwbzyjKUPcTUF1ghcKy5ttzUL4uDtAG0qT/+AjnUaEpeWHafZ7ZZtyUYS6V+ACyY0CieH ngX61ygcVLC9wSoGujCxA7FAFVc8C3+fpDqbWrMGkchrwtmjlpTXdMOz9CDtzLUq+Vl6oBoY0u64 tFzgba/Kz9LPMN4WR3kbXGmO7GxZoKEd/yela8uCGVsL86RYMbkflbpKF4e/JNC0TKRpxZSxBCRQ PwCaRudtI053kiojQEnT8pGmFVsXqvAQvQkjXg2AeHUbqsQr463brufpInJJ/MvufJ4u7i9gXYEi 67IIrCtXZF253MMTgXXlYmRE1iXaMKYJsC7E42DqoMwVRM4Fkj+cyz882498K1ACtCAB0IL+awGt uTtAE/kWolmojt/L79fzf2WA+Qmpp+mGhKf9OTN1kV4t7fZtwRTXSMdoOCnZgQ96c/xl/kgsf4W8 9ZTdrudbh7M3hdgz0nxmmCpJC3QsOxTWAldCeGQ6JdPzI9N7oOtgMjXcbrdl6vliPZ9ray38W4/9 S8clg5uJLyax4R6kXWpTI9VwN4gyoMqApL7k0tNMV1Oz/pYwFbwI3kyt2ohfm+GPk5jW+PUE+vdl e2Iw1Eu9qE35Cksvk6yHobTzw9CQvwQfag+m9a1wEEc+Y/3SUaol6Wnvlduw9xfkvZ983LV3w1Do eRjrOX+bo+f1tC4FHlPndayjQ01pR4/ASF9CSTeO306eb0dHx29Vm+iKxhDO/GyAyRAQatyrJtXb 0FphUKsprWUb6abKqSi6QsLhCbnR1m7P6E9X0zqwEr7TgmtSts3jmmhnLatkz/aHkPM0ObN+Xolv CpCVbdkD6289Y8dvsNeluaoCL2T7axRdO/4a3V9bhP2lTXmGrtYWOG7UGzeHa+B9A23qw/Bug2lz uAo228hICmwmVqbnU/DfBBpiwvU0h2Dr3mIbrDvkmXTdSXwTaqaJVYR7PKmQMW0BzORLaNDSTs9G vlw3+0G1inszcAqnzrOX6uDOio6vbv0e4JEKfUFYgDXbT2uiRoI9iDP3Cu9LulNuqmeiIXwQmUlF Whk24iBbf1p9iFA9EapzpKm8eiIZIFVPtD1Bqz8rVI+B6h3IxUdk1WPIk1L1GMHctlupV3FRFxHj Rjn7VeutXtbwd2ENh5FHw+ga7pGW/s8tnt3xU9bkWijdWGnM/UQHSyJmWH8T/PSu/aVgjE9ghwae 929BTdkGR3ZE096BGMGw/zs0gzX6UljUn4S1OmpoCtuWWZmwBRZ1mZq50tgHmKsHW+FYjIS0hRSH ut5IxdChMHQIDL00XBza3M4xdCgMvaWpz6GLNsPQLwhD/xXChg61DaWr1fMBtlqRMFQE6eIY5xFp nEgYp7fvcYbjOOUCWnwqjBMplMZvBvAkCXT/o4NY60ir1W0zrNYoabVGWIfQUvRl62uVgMQIkrgn QyQh0VZbEsT9dGoTVSOlldS7lV6gVwrpoI4RrBAHZTtpiF3cSb8/RMfsbXe0XgGtDZ0l3aKFgjlY 8LxU8JxQ8BEWdJMKusoGqrwjDjQGBrpMRVlpP8eG7g2l8ZWK0u8dpc9A6WfK0g6Onh+A0pZ3ENCs Z3A9tttqw6tBdCH/ul/YesJ0/boRpmsb1GLqb9yI07VAMV2zWS/WtU69/Sz0Fir0NhR7M0u9jYDe DMOlyRgK3aQ5dfP2/crN0py2oqFFeP8Ju+gqddFF8uVazOLHqAOSq09Qh37apaw2lBVD2YMuZZfp riYbn2CQPzqKQf6DXeTfk2D3ryjac3p47ee2biuAPd362hSwQrf1IBq7CcE+aRxn2oQ4n9oKLFqB bsIbmbdcNIRi/GQ2dtpAHeIVsP6d+6CuUMmS1A4csgM4ZGQ8X0lWhLJ17YDfg4lkE9VB6ORGBu2k VVzUDTgLMWZz/RTgeTkDZi5cmrlQoaAYC1pKBY/INtI7gi/EkIIm4H922TZj4BlD1jcB8LRR2w4C i2nK/pVr1j8D0GAtYy/GOwFJo0nUk07YikwM8C23uYg7K59SkDHyR2PIZDaxeVwhRsumUrS8/huM 04aNQx5qJHAo62HobRtdWuOdaknvKoYNgbkNhnF7OMZtL40bAuO+5WvciTjuBSFK/9BQuFVjG0JR 9U5DhqoRMFAosT4kjrLvSccoETCK/X4fo9yPoywSRokRRokQSivW09WvRW7SvWa9fccBWXDZU/Ar Yut3gwYgW45QPw/rvyLVf1ko+AUL+kkFfYSCz7BgkFTQXyiYhAVvSQVvuEG3GIx/zuh28I5Y+iqU 5iiRcb6jbScoTVO2Pe4obQalBZXusU/VQMmwM9Y5Yd/WdX5gXwgIWYIQJ3T9fX3xXh3regB2nSx1 /SZ0bRggzcyrQst36ysX9eF1Mux7Yp0P7Ishj9NAS25EuMG+GKKFsiMRbrAvhlyjO5xsjWDY92Fr hn0PdWR0V5lfUvSLodC3RUA+Q/8tCtBLEEEv/RHYzmtloAcJbnO9qbpgW7df6YZtCW/TJgUrMK9W 1EX8flU9ux15YAxmdsIkRPzqeT+vRWgkj1JjbEspClEjAGzGkOyWHoncq01Ef+zyuJLIvd9QZsAK 0YCmkgHT1oI/PoNoU05WaUUah2jzUkt3aCOxuBMPiuPmtlKyuPIGPsath+OWqNi4HbQihwO0maVV cLgJjlHekEZBDjfb1yjL1sAoJmGUonrKoDxjDTI406Mig3tZ4lipa3ykvx2I8T5If4X6vdd4YFXP rvHAqh5e44VVvS/4fwfSjI5iHaREh3xHqZ2GB+tGZWl9u1h6Akqr2d1jR3ZdJW+auNoJO6aurgJv +rCukjc9udqJN7Vb7Q9veqquconOrZJhx5VVPrCjA7ncEPhPuBvs6ED2Q9nX4W6wowP5DcrgPAOc tmMEw46TNCsaml4VvBgU5gMvGq8S8SKujju8GOgWLyp+8YkXNxo448Wnj3jEi5aNRY/SPqbEiy5a Hx71yi9yvEiurcCLsEe848Xq+8Vx5z+qxIvcej7GPfazHC80teV4MbC2Ai+6O0aJelSJF2/4GmXc z3K8+LaWcjO+9jPiRb8WbvCi988+8aJnfRlePPKzB7yo87MHvLi20i+8uBjsDS/2BXvDi9XBXvDi 05pKvIhf6YQXL6+sAl68UFOJF5U/OeFF4Ep/8MKuUS7Rbz/J8CLzJ594sY3udzIj1C1eLIGy90Ld 4sV0KHs5lOFFrXCGF2uiGF7I7j9xOn6fjj+g5/9UZlqfuGZaH4sg0qSZr0yrcAXdiIPQ/hoKFOko z7QuEV1DKdOK5U/G8jfJew8q861p0NWT8nzLcSQvzOKEFR5yrsErvORcAx05V3/qdNZERc6Vzkqe pyW2FG85F1nuknNtCfWUc/VsIPp9dAtlzvVOLR9ZSfJyec61vLoi5+oe6j3nOlpfHDczTJlzXanp Y1zNcnnO1aa6POfiqytyriTHKP2kUTDnMvka5dsf5TnX7iAlPU/5EXOuVLrrrOVSzgWXfeRcU+vI cq5eP3rIuTr96CHnavGjh5yr5o9+5VwBdbzlXGdqe8u5cmt7y7l+rO0l55oZqMy5Ypc54eCLy+42 54oKVOZc1qVOOdflpR5yrvIA5aL+slSGgxuW+sy5fqsF/KeJ25zrCygb2sRtzjUZyl5swnCwWnOG g8tbK8+bXPnTICV/ekmEvtAQH/zp0A90sz4BwTkoQIF89YQuoi6S2m451K8/eN7PvzBQX0MdybZE zqESm3rkUGfqiv64q5mSQ90O8sEyGvwg51DPVlNwqD+aeOdQIx3j9pTGRQ5l9DXuwu/lHCpbLedQ TaopOFQNxygXmyo5VDNfo7T7Xs6hXlcrA/T93yOHavyAGw5V/3ufHEqrkXGoE9954FB533ngUL98 5xeH+rGGNw5lquGNQ42s4YVDJaqUHErznRN21PuuChyqmkrJoTYuceJQliX+cKhN9krFEo1ZIsOO SUt8cqgJNGyRFxq75VADoaxVY7ccqiuU1WvMsCPnQYYd70W4ntcI59Ud5BTK8LYTfeojYsjvDX3R pznf0j3YHky3VFbKQaQhaBKvYhp9R8scvKiD8hz67W8979Sl6CrkrSD2+TIRTEaTgBBPzOXzmqK3 TX5AyVx+UfuI7TnfyJlL2Z1KOXOZ3dg7cwlzjFtDGheZyzO+xv0Pjrtf4BTjhHEZc9l3RyVnLps0 4ijfhCiZS6HKxyhkMYwyTRilgTCKGOR2LkbmsgtOOXpLMAKXvTKXSJIXIGMuCxd7gJEpiz3AyLDF XmDEIABFJBlMR7G+pQSKvY7SWCjdpiy93y6WPgqlNTzASM2/KhUUJHORE4zkLrpbCvLz7UoFBRm6 yImCjFjkgYIYbitXp/UiGYw8vcgHjESSdhQ0ib2BGxiJJCFQdqqBGxiJJH/RrUpyGzCnnXw/g5HH wuHttWQHfjieV9bxe3X8IR1/XU5HhivpSD8RSmbjacgKBR2hUKKXoKTb13QLPhtPzU+6pYCSxg4+ gg/I3oJHcKrVEohJB9cs676vPW/axczQhtRQ26dyRFnd0BOidAsSfe6J+5SIMoA6kdf4bfhKzk6+ vqlAlC4NvSPKvkBx3HWNlIhy5i8f4/71pZydPHpTjiiTbioQ5R3HKD0aKRFlsq9RPvtSzk4sFco9 O+5LZCcfBYvsJEGClTFf+mAnkeQDGkkd7KTrlx5gpdWXHmCl/pd+sJNIUpuO4omdRJKLNGx5YieR ZB+UemIna8qVsDL8CydYGfVFFdjJkHIlkjT9womdtPjCH3bSrFy5RAcXymDl+EKfsPIH3e9kWT23 sJIJZTPruYWV76FsVD0GKxENGKwU0AxH9rxUjF6EEomXvOPES14VwSS2ti9ecutzuvuiweiIGwow uU/og0IJ6UznQ8fXcDCTGOcHjHZ97nmfLmHMK596iW2+PNF5W+sx0flLJTrbyWBlotPgZqX38N3y czk56flnpTzRuV7Pe6KT4hh3uDQuJjoLK3yMu3qBnJwcvV4pS3Ta/KmSJzoPOUYJlEbBRKedr1G6 L5CTk6TrShb9xAIkJ0/CIYUsx4HLXslJB/I4DaQOcnJnvgcUOT3fA4rsmu8HOelAdtB45YmcdCBL odQDOelAeCj1RE5GXKtU5Djh851QpNX8KqDIQ0JvYo5T/JkTivz+mT8ocuiqcnVmfSZDkc8/85nj zKdbnQyu5TbHmQBlL9Rym+MMhLJWtRiKnKzLUGRGE5fncaTvn/F79S785D0lPxkoQsqV6r74ydJ5 dBfGAD85eEUBKU3g7SM5R4nnb8VTjlJP45mjfDDP8979kqHm+9RpbOlyjlK3tieOsoSiEHM9vo6S o2y47iOKF3wq5yi3yhQcBc6rvHGUxx3j1q+j5Cg6X+P2/VTOUaaWyTnK4TIFR9lxWxxlRW0lRzl6 zccoV+fKOUrTMmUAPDAXOcrBGm44yr65PjnKnhsyjrJorgd0mTbXA7qMnOsXR3n7hjeOor/hjaM8 fsMLR6l3WclRcuY4ocvuOVVAF8slJUcZN8cJXT6e4w+6fHRJuURRc2To0mmOT44STSMjCazulqM0 gzIS5JajqKEMz/MpuqTUZOjSujGeoNwLfJldzWf+M1vEl6SLfuHLc9T5POFL/dk+8UV73RlfVlb3 hC9dK0QPbKlR4surZT48cFS6HF8WXlDgS6fq3vFlV7k47uoaSnw5cdnHuBWz5PjS4oIcXz66oMCX txyjdK+hxJcJvkaZM0uOL5ttys1rmIX4khTgBl/en+UTX0ZeleFLl1ke8OXRWR7wpe4sv/ClxlVv +GK94g1fdl3xgi8/n1fiy9BPnPBlxCdVwJdB55X4EvKJE7489Ik/+PLAeeUSFZpl+HLU7BNfDtP9 Tr5Tu8WXLVCWpnaLL99A2Qg1w5fwIIYvuxtUGV88na9EVVb6wJdzM8Xzlfusns9XBGwZ/KdnbFk3 0+f5ylrqN8rzlZeqecKWc9dE79sToMSWOzYf3tdophxbniMKbDmu9o4t7zvG7R2gxJZUX+N+aZJj S845ObY0IwpsqekY5XI1JbY09zXK0yY5tgw6p9y4ISbElgfsla7Y0tDkE1vqX5Jhy6kZHrBl5wwP 2LJ6hl/YsuKiN2wxX/SGLe9f9IItL59VYkutGU7YEjyjCtgSeFaJLZt5J2zJ4v3Bli1nlEuUxMuw ZTLvE1sm0SBFuDuV7rDlDShrDWWu2BIHZcFwok+xJU/FsAXOW/4Gnpy46QtP5qeJeLLjtE88+baa 51zorTSfePKmzRlP1Hi7yR2ezL8setwkuBsnw5OV53x4XPZ0OZ5cOqXAk1l0gr3hSXPHuEHSuIgn 7X2NGz9djicfnpLjyZ5TCjzZcEkcZVFlpQJP9p31McrZaXI8CT6l3Kx50xBP8m+5wZPt03ziSaZV hidzp3nAk/HTPODJG9P8wpN+Vm940tnqDU+aW73gSbWTSjzZmOqEJ5bUKuDJryeUeDIi1QlPRqf6 gycjTyiX6JFUGZ48leoTT56gAZFUVLjFk/pQ9nuFWzz5k+5Xdp5P8WQc3CCjeBJaC/DE/+d3F/9Z 6f35kz4p4vO7qaUK/BCe323+e6WbZ086pPh8fvdpqr7y+d0DN53AQjqSfccm+lOP25WKI9nJp3zd /zDK0cJyXHEk+8ZNd2ghHcleOS+Oe+hWpeJItoavcR8yytGCOy4/kl10XHEka3KM8oE0Ch7JfnPS xygZU+VocfKY8tBv4VREiy9uVLo+ezJvqs9nT+aekaHFW1M9oEX8VA9o0XaqX8+ePHHGM1p0INoz ntGiA7ly2gtaHPhDeS47c4oTWsyZUgW0mPaH8lz2uSlOaBE7xR+06PKHconKk2VooZ7i81zWTvcd 2XndDVp0IKeg7OfrbtCiA8mFsjnXGVq8WMHQ4mqQ9PyueH9nn54/oLi/Y3C6vzNExI4heMDq7f7O g9S4pFgwm/tdAR6hQh/xSD3IcrpvbxTEateX6TLPNtdlVjb3cKundLLnTbuAGXqMuoxtphxXJv7p EVfqnxM9r/yGElceO+7jZshzk+W3eoYdVeBKzT+948rnZ8VxJ99Q4sovx3yMm/Ox/FZP2RE5rnQ7 qsCVto5RHrihxBW9r1EGfSy/1TPjiHLTPv8x3urpCmcSMkiByz5u9cSckN3qafCxB0i5OckDpJRO 8utWz5FSb7d6Npd6u9XzdamXWz1TDishJXqSE6R0mVQFSGl7WAkptolOkHJloj+QcqFEuTrfTZRB ys8TfULKT3Srk7FlbiElHcr6lbmFFAOUdSljkFJ+jUHKIrXwOJt0XsJ+T7aSMzVbMwE/JXKSRsWN sWjFcfIfzJjZt0FMXwaUCajTPXlCB5UhaEbXrrb7odpjaGTA1lqsmT0xUru1jDN1Hki7JA9eZ4M/ T8ljVFFUPo2F4o/Ovk/jB+l4sNK/98FnqlzeUpgowl3SBV9w9zjVJek1PG89pIC7Dsr3wb9AGou9 spk8L5zxi28BnBzv7Z3wo+M9vJ+QNd7L+wlv2cWHvTfTEGR9xe7mnfBvaYn3d8K58S7vJzQr85Tj rT0h4s/nV5Q5Xv5hH/hT+pEcXWsVK3K8FZe953idHOOGSeNijveSr3GHfSR/P2HOQXmOBx+hluV4 B0vFUTaVKXM8W4mPUap9JH8/ofVBZQJxehyi6xm63+TvhMNlH+8nnDwqQ9dfx3l4P+GLcR7eT5g6 zsP7Ce+M8+v9hDfp8J7fT4iDUo/vJzwGpR7fT6gJpZ7eT7iwX5kVfjfWCZSXj73bhwNn71emiPqx Tg8H9hjr4eHAPvuVi6odKwPlB8b6fD+hMQ255OR5N6AcQ27TXUxyzrsB5RhyHMqWn2egPPgSw8Va f7nFvw46/JVvR5I4Upkkvi4i34Rzsv1sFPdzc2k/t/mQHTLZyaAi5U0x/D2ouNQb4+rLjptukI/+ kA6u5dCm+tDnIVNlifMh05c2TwDU5g/RRUMuKgGIO+gjsRqYJE8b+UIFALWyeQegjb+L4y6+oASg ggM+xj1nkKeN9QvlADSsUAFAvRyjdLygBKDhvkaZYpCnjSsKlHv1TQOmjUOImDa+JHG81w0+D5n6 H5KljU8aPHC8+wweON5fY/w6ZLpR7O2QqaTY2yHTxmIvaeNX+5Rw0nuME5z0G1MFjtdjnxJBaoxx 4nh1x/jD8TT7lEtkGS2Dk52jfR4y5dH9TuaedXvI9BOUjT3r9pApHcr6nWVw0vA8g5NN5RRO3H5P bRB+zKlc8UE1+GEu5w+qwdd9HR9Ua0pTU+nDVCmOD1OFSx+mKvwA9uunAmW8vadS/kG1pFEUjhBo DENhn78hfesM2NYTwLIdnzOLp+jT5DC0Z6ODmVg3hpwWThfFz1D1/wDpnEn6ifUX4cobwofOBjkn p10/8Oga2lmxwubrSzpT57S2tzs8qs4HHujctVF+0Lm+5OJ+ZzqnnfWqo3QflL5oFz/AZXvWdkP4 q6nrh7eGj4Jpfh2mRWZ1L7yaqZa+YphEIs56zKm3HBJhack5ZU69f1+lry+QkfdhrGfVbKEb7Baz avzI2lrK5b1+ZO15x9AR0tCYVvf1PfRIHPqasMfm7xITa/jI2qVdisT6SLE4juWsMrEu2+tznCAc 5zthnKd2KZO3c+8h9pKTIvamSwzw5Hs+sLcvKS2UYe+a9zwwwM/f88AAk7HgI6kgSXz/Bws+lgrG y3bbS5XibnuDDm99Xgm7uXfE0q5QmiHZ0+A9L0g/1tFpHWg2TNlppqP0Eg1e1jXK0uccQxZA6VMe PqS2Nl+Zzb870gnpPxh5t8Sxb74ytQ8e6UQc7x/pgTg+lK/cEMUjZEhfOsIH0vclx+hOJz+WukH6 viQLysylbpC+L/kByj4oZUjf8jRD+kKaPynf7+/L7k/q+et6/o4A8he1KUUSyG8RMH4bYvwWhPjo P8AtvmJekSo6xcOSU5S9C07xleAUD+ZB9VQR38fROMLw/T0gnu8AyA+RQ/pZwu2HFusYok8M5xii nzyuRPQZdJSk0fDtcRoZ7PH8VbL4WKW9a07sc3ZEPE6oNxjqvSngfF/Xe6GvvusF6TsJ2JtIelIw sLaWkL7Fux6Qvua7XpA+wdFfAPT3nBLp+zhKz9CoaOWQ1NCsPYcSO3b8OanUI1Q3KBJxrOKEEqoj dsoWbKUbFOsyHBZsnADU7+T8H+7eBS6q4v0fXxR11RIsL9vVTbEwy0BFF6+goGdtUbwlloaIKJQX kiUpNTVE2VbSyorykp+0ojK1skTzmhewrNRK8ZZaWofQbpZiKef/fmZm98xwUfv8v6/frdfL3uw8 z7yfZ86ZeeZyzpxRlj8bnLjy8uer+3x2Z55U4/Sa3VexW5RGdm8Sdn/fKS9/aruUKN3Rb+Xmk2qU 7nc1K0nMyh5RHb071SbZG9LMeD3mmC9Gf4MAU5pT4bv0cpVrTkyzJ5kD6NvSWEz5QYkpR83AcDm1 5iA/j9/pf9BnlM0U+l+k1jDAXptawwB7UeoVwm67Cl99ehFWSluogTXXL51C0idU6V6/dDhJt6nS Ry/7pF1JOoIH5bJH5Ih8xw41Ih8ah+Cn+d5/GUd+tzb9pq8Ll34gIm9n+rFN/BhVKbzF60Wf0fMP WkZ4neuw/T/b1Sj9CJkbI8y5mblo01x3kWvadrU6dKRc/USuHizXXWauVlVc6Uau1DtSTRSO1+0k KzvMo/Dy73gUvv9M1fH2v/+e5UcHr7Z++ehY3/csX/lUmcZX+p7lkS8qzO9ZPvWZunZ559grrV22 GFtDCKw79goh0PyepQUtt/rvWf5YfLW1y3kpVdYuk47UtHRwYY8veBw7qi4dXL/zKqt7ISny2mX/ bcrSwa+Hr7x0MMNvN8W0y5YOXtxxFbsrx8hrlwe2yksH925Tlg5u8lsxjqhLB/ddzUqfMfLaZfpW dV4aOoatXbYpUdcuKfkqa5d3Fklrl+XJNYxcjyfXMHLdlVzD2uV7yde0dvnWriutXXp2XWnt8tFd V1q7jNt1hbXLsC3qYoM+utIQ9JfR/+0Q9NvN6spD3uhKQ9AXRtcwBF20Wb2pg0dLQ9CRo6+6dvkQ Woh+54Fq1y57kozW86tZu2xFsl++5cHvzUM8+NHzoRq+j/Dvnt98tP+q8S/J9/zmlU1Xen5zpLjS 85tHtqgxsGXSlWLgLUk1xMBaSdf0/ObS9pqe33y//WoxMHdUlRg48kBNMfBckS9KHDqoxsD6W68S Jeyj5BjYb6MSA8u+vXIMnOq3m3RQjYHPbbmK3YJEOQbu/0SOgW02KjGwqd/KPwfUGNj2alZ6Jcox cPwnanMJSWQxsPXXagyk5KvEwJafSjHwz4driIFHHq4hBn76cA0x8O2HrykGLt92pRiYs+1KMXDc tivFQOe2K8TAezaoMfDUyEox8OeR/20M3LdejYGekZVi4PyRNcTAl9erN3XASCkGDh951Rg4DC1E b7mv2hjYlWR191UbA1uQ7Oe9PAa+/g2Pgf2+r/L8Rnpf+Bu24lqxnk/GzwfN3spm3qtEiAua/R8q L4U5b5auP4Wr7fTspPeEH9e8Iy3ZU8txyQ5ntWHfbyODSPTl9g61ZD9Zbsm6jr1PxYRDLVrtQbrW 5rC7ocvzq+b5Tt9YRLOpOTyDhR7kR++KqUOH99wToqZr2eVGpt1ZRIfsWXwnf6yPxv/Kgnw/w7c6 PfXCd3uKK7+G7Pmanvj8QyHrnX01hayo7b5GfefXash64BPycimf862qbv3vId8TH7b+t04JWQ5Y pKOjagpZxZ/67K7ar4as7zZcxe5fD/qe+LD3KdfJIevxdUrIGu23ou1XQ1bW1azMf9D3xIesrP9Y rd2PPchWHSd/WWGsZzPa6eaEdfyDV33i88gmadWx24M1TEhbPVjDhLTBg9f0xCdw05We+Py48UpP fIo3XuGJz7sfqQEoeXilAJQ2/F888Rn5kRpzmg6v9MTnluHX8sSn2UfqLfoyQQpAJQlXfeJzAPVd /8+eap/4bCBZzp5qn/gsJVnaHh6A7tjLA9DuYxXG2Griz6wzOo24PAc0zznNc9mVN90aNGxrUONY Gx16pRXFhlpYJzndhn+YZceG0XlbVldeigMKGv45oJTAlVI0/IvX8qaP4kdQfqbXonael8MGWp7A EEYtfo2n6xtxbC21j40hrPXkLQzZS22jG43G8iK2STLdtoU+IrFT884WuuyaPjmMGkXdQIslFuEw nfYcfsQzrRGEBWy8QuPhvLU80QvX9MhC1vyKZoessPD/SL5CyK26s4jkoWRujWmuIcxpXnjunlz6 fm1Kjqgv7BULexS69anCXrHPHsuk71jHIjeMbpSMbmT15lf9AKYZLm6y2DSZ/wCVMKa2ecne+ZBb zBcW6fgmvT6zGPGsJNNPb/JfsnyTsC8jvLE2v2QPI9PSNTxGpVOMStU3b+KLA+n8SgWt41cqJmRM gIWPl8fwa9R6l7hGMZSVkf881HeBxpfuZaPriKg13KVc4S713fqDm/gFylUv0PKP+QWKCZnmszWN fe9tp//S5JolmT6USpIm1aZlH/CSJFBJ4vU/N7KL8oQvVf96o7giMaTCSByMJKYWvxz9of7camUR cvVGfjnCmJ8u5uc/H/muiTg33B0Swq9J453+axJW1g9svVcrC9pJgk2T2N7zs3XzsfH9Pjv8XL51 7WeGkLcfB9DwYIJW1pifp8meVxQzElfkabfdG4dJ0fRQOhLXGxUczY5pRD8f4/nD2Fu2v6wr8trK mprjEcpv8+W/7J6g5o8N3+rP/K2LrrRYIbVp3gL/ECW0lhiicEdPDqaY2bCWP2b+NJhF4JMBcgQ+ jF9bllGFiPycmXfmfaQLh5qzlcRAXFcbXQR0hsEU0OyreGArXA2ctYO0qy7vP8mNrVLC/VtmAH+Q y1cr8gJT3oXL1yjyt035zVz+viJ/x5T/PYjJP1Dk75ryw1z+oSJfaVGOQ2r7j8GayAm6PJ+hipTe 9I/SN56RFd4mhcOqwq2XJIVcUmhwSVHYKSuMI4UPVYVSWaEPKRxUFR6/LCm0JoUx8vxixvV+oZVV 8l91yypf51o0k83vWQQo4H3CdprQs8cXkSu5+r73RC0oEpoUklyM65jmzYzire7+d0grk38P/h2K FRf0u+gRAVVUHsHZKZSi4qaX5pk/wkrZbMJTht9lb+N/pfbLhi8ndTVlyZTY0EykYFrWnxLPXxKJ iCdl3UqPX6KzP0UDgStN4Hzp/kv+jBTWy5qKHxTIyqwit699vxNPzea1S/6x25r4KzyomiLfnrc+ pFemubHSkQKHCowTGCuwu8CIS/79AzQXCaVRwKwiOu9Q/4kmdTlb3Y0QAjCSDxVLIFuCWX3czC9u XsRMEVytfIA7C72F73jYqI8CuARTjLfZesz1zwxA/5C9LdTpaeSCqeztEB6n4fcTq/ld2wbi8LOa NyKLNL1Nf+9/B3vD6dA2MlhUuojduKKygfS/aLY24hsgT0QOdztx3Sh7TWNeNk6y6Y9/wE3+ApPk qjR+bCVT3Xt1qragogNzrcS3ajPxGvqbuyr85x1L461CVtvo4+qosRbWx7ADb/U+IMH0KihnLf0q xigu21ErKOdNVu2nWzYbdFeSEKZztgbNpk7f5Y04HMfex26BSLThTgt/GWwzm/iC2vuAzvxZzy4d 7ZkmtQALX/Sg+bGTRXg9zru2Hr22zeae09ASo2c+5bC460Y/06d3WTPieOQdUq7LXt7Gb/7yNrEk 7eLjSw8toaDqo0t7l0Vw77vsRXBqDeFHYsPPx4afKmsovm/ozN5pdUai03iFdWTTLXTA78/i6Fnc +z9d7N7noHB6PBsSFNH6TbEz8jt3/ThPD2f2LmvZhrg2P7o8Y0Lszm0VtV2e39j50FpQzLb+ebTI d1LbVtrdd6q10cIVFHvSFfCbK6jXSXoWTV64W2mFPrEzckfQXAOJ/fK60eTCohewzndnf8+0vyz0 vNmuRX7HIzrm2lqbP7TsT8s9e7fptY2tBfU0j655fnd6fnPf5Tmw7Zfaxq7sH+tpF75DusuzbYHm jdQ8DtR7K6qUVTN2ZZ7Vsv92TB4krofmbax5MAQaiNYQbwUikMXTb/R88ehlB9qB6JIHon3Go1se iEF4PMYjAx1A4o0Cb5QWeSjzIzSpclcb9IM/lLvy3G1RIbeX1XZ6fqFLRn0otTd9WkGF0S9vxGm0 pDNs4EU3pPQRTL30gVsRRS7gr7IH4yL/JGGwO8Tl+UFZv9W8XTXPL3rrt3CJ0IRxWzLP0NGusPaT 3qKAdcyFlTpmz3ZoQO5uXhZMgT57Wojd4m5A8duul73FO/UMTP71/m/IayXmebJivSSUzS1c3i28 mq1WqtlZqmaBzuwiOPWrr371pOpVZlavF/ux6nXn/ahev3/IAhm9kLDbGXnM3SDOk8nqJ9Wv06J+ XUb90uX6FVpD/dKvvX5pn4r65T77f239Gu+vX2fpkvnr161vVqlfRaJ+/b7JV7+S4yLPuJtR1YL/ XfUsf2U6lvkrf4LsLWTL/j3ARrULuj/xjshXq0o/fIMyyUnbSYnGEUa1Fe3pN3hFa4DupOybatfj /v/XrwiN1a9dAP259/831S99y/+79Wvj8hrr13Of1FC/QtfWVL++W15j/Rq8/F/Wr5bLef16Z3PN 9cvjCmniYauO7hBrDfXsFKpa2XW+/FepbztjWX17oA/q2x2r5fp2lOpbxxBn9g5W387Q4BT17RLq 2wmpvt1jd3lKq9S3UlfACdS30rics9XUt53++naW1besTb76dvr/2vo2xl/fztAl89c3139YfTuL +na2Un27Y72vvj0aF3k6BgVvEuNbz7C6cV3LglqI/lJ8UvnX5b6KeDTzR1rEb0ar8Gq9O7KsSr1j HehZqFZb795Zxutd+43oOxf4hvPBbJDJH56GvotRaV4GrlYGm0fbltAoNQPTsN40oseoLsOOv/ly X15GmCtvqgO6UTT6O7OYdKdqkEdx3anx+Juv+vHHbDQ+s5nP177vfYclM4UGiMHkWVG2b6rn4u6Q ejCJBy7lg+XS15iaxTcjzJs6Sk+hLkG4kLaY/c1cH7mYXZ1gNiPxTfnn9r7CRCmDLSN3DNGffpMm SQab/Eie9zE9D+0tDf3b10zKh/5WPexNXoDQ165YzrQlXC2gmnJOf5PWhKaGUVn1mYvMgroX8RnK dcXyiEjcX6enwundzM8PeBURLO8ph9P7sFbWnOLdVFq8MdAGwNKDHhV4trsi/0F9y3vKCi1b2R3q eE7WbyTp+yw8s4rG/+xvdtVL6fmDfz3Zt31g1hm2zkjnsVdo3g7sLUU+t3nkDTG3oSUT/cwqMbdZ zgeTfGoz5xM+tXmWXb7uRhSb2jy6AnOWEDFn+YFWBUDMZjaG/s1K38ym9wppZrNppTSzWSFmNqfc w6JnTgvBtKZe9DMxIb3LmtNg9fklpBoYIiY2P5kTm9z1fGKzxiw5zWMD3maj23wxuqUKqC95VR2w qvM9a11aXz/o9Fze4qBiDigUD34ivlzKV0bL6/CV0d+AelQBXxllibTfiM3eJlhoyYAr8v0/UbQQ eAAXhrNeXOdj3fsqZ9UF6wli/fktzqoL1ic5q5VYdZO1LWNdRqy0aKgv97MOXSLW4gXrXmJdKFgp MXz/erpG0YUzLdzE3BXMRDBbRjFNFPckEyP9JqL8Ji4tFivpwsRWMhEuTBRXZyKEm7CxtRXTRAoz cTOZ2Eomjn3sM7FcmCgUJtaQiS/f5CYocYMd1OsDBX/gYsZvJ/5Ck78O4z/cysc/3c/vEvwFgn8Z 8U8U/AVV+FcsYvxsXbvA5H+jB/G/2sp3iW7z8/+1SCzvC/4FxN9I8OfLl8guTAQsZybC2LqVaaIX MzHMb2LDRz4Ti4WJXGFiJpl49w2xXF+diaWvMxMOtqhlmjjenUw0IRPL0AT0YX4TvYWJLGEinUxo wkSWqKH57zLWKGLNMlk9jPW7lj7HA/ysl0W9TxWso4j1jxWcNbU6x0//h5nQyESqaeJOZmKR38TS tT4TK4SJBGEinkzMFyYSqtzebwsYfzzxJ5j8u7oR/0PEX0D8Pfz8cYJfE/xRxH+f4NfEhWnBK2UC sWomazpjbU2sbPlO/9DHuu0lzuoQrGHEemg5Z3UI1uHLGOsoYnWYrDcz1l/RC25hT+ae97O++wpn DRWsdmLNXs5W/+wUr4E2C8dggVaGgeKZyVqWF3eF+kL+kCI2fDfbD7yEOZNKzoSazuR1JWee9jtT hzmznfqsJ1kkGJnOBWc+8AsGvsMEWVzw9Qc+9//O5+7bhPvB5P6O19nzorNCZhUyC8kKXucXzJfB Ki7cKDbgfo+FJNrRZrr7XRe2HcnOBTZTsJMJ/oYgLu+jXNbxXIjxVOg7aa6Yt8mGKxE0bGt0UOMc K/6MLsqhFItlZk9nUY49gA8cWIelZ7CHIdudW/zjcs8SC73/kP1PQNBsqujoxYPmNuyKpG0/1KYL svd9dgnCz2v07sdhPf4F5n85TTPyNsWbtqO47XjTdoJi+8J73LZnicNvcSS3+HgzvT48Kwtyedg7 xrTIHhFg+uCq5MOe55kPVG/hQ67pQxb3Idf0YYFafr8P6X4ffmvBSz3nGWoGs2gJfiZ7i83nijNv CZXN5W1Fo4IxLm9Ex8g7MObdGGJBnCprL8Z+nSJrHvu1pJcIO6EhltlofcrlOe3yptDjL7aA7Iq8 kLmBrf+/yGaWmced3k2scN4X2bXa9n3t8PP6gecqDPZAvLYQ07SusTMvZxT9HVnurqN/vZAGdpus LO999HCE3M1xkLsruLsdfONfxxXd/VGfu4i7y54Xlmnetpq3t+zucT1lIa34n808AX9YffC+aDHd vYu7i9tST8jhb9DslTfTTcsJ5T67vHSVMfcJC5q9GBK9MThLn7/ZvPfxq9V7v3cBK2JqANvJwYCt XdfVaqez5etfqYF5Yy3hR+hpRAN6fad2tE7NOy9i3otiBBUoRlBAvWIpMb5RLoIMyWioN4VNkdhY gavz7790prb4Qwtm1iqZzeJmrdWZnfCcGGIJsyfI7NylYogl7NUz7emmvd2dyN4L3F6wZM/K7QVX Z6/kBTH4Evb2kr3mwl6JsPfya357Jaa94cxeb27PJtnLZ+PaWFt19iYLe8XC3lay99YSMRIT9u4y 7RWb9kojWNC7ndmzS/ZCuT17dfauE/YKhb01ZK+zsFco7K1b6rdXaNp7gtlbzu2FSvYK32P2Qquz 98bzYpgm7C0je0WLxTBN2Otr2isw7dVn9gZze2GSPY3bC6vOXg9hL1/YW0D2hgl7+cLewSV+e/mm vVc6kr3a3J5DslfCJjmxjmrri6ifucLeTLL30yIxhhP2xpn2ck17bZi9D29j9qIke6ncXlS19UXY yxL20sneFGEvS9i7sNhvL8u0t74D2Uvm9jTJXvm7zJ5Wnb0bhL1UYW8U2asn7KUKe3NNe6mmPSez dyO3Fy/Zy+X24quzt3KBGPcJe/Fk7+VXxbhP2Gtu2ksw7R1qT/a238rsJUj2bNxeQnX2YoU9TdiL Int3CXuasPfWIr89zbSXxuxlcHujJHsF7Ale7Kjq7L02T4wQhb0wsrfuFTFCFPY6m/Ycpr2L4WSv FbeXSoZ6MkMjU8E7d74YIwpeO/EmCt5QwXv8VT9vqMn7H8ZbdgvjTSfen95mvPSOV57gtQneYHb/ Ba/Nd/9NXpt0/xnvh5w3i3jnc94s8HYVvFbBayHe1fmc1yp47zN5rSbv72HEO5XxfjSTj+n0jox6 CRsb4mo8Kzqr2qKzAuoDBTslEvu+V8xeqraf/QXG3p2xT4/aTAPmDfS/8N161BtkA4m1pcS2vsQA KbGZLzFQSgzwJTakxLo88cwKkdhA0jzoS6xjEWstSPzUl0hD+w2BPPE9X2J9KTHfl3idlD3bl1hP 0pzoS7xe0hzuS6wracb4EoMkzft8iY2kxJtFYvh5X4p1BRtsF/J7E5sHXXJXX8a61YgeeaKLFzfr BN2sFS9RHjZOZT19bT4FuBdZfK+nzBY52G072o5u25s3MRPLvKITF4x7iXHQS6ITF1TfL5GpSkyq 5xjVVE41QlAVC6qtRFVPUBULqpcVqmKTqg+jiudUl58RXa+gWkNUG18UXa+gcjGqEEFVaFL9cy+b dHKqliKKFAiqZUT1mKAqEFQBjCpAUBWYVGsY1d82RnVaFDBfUC0gqjsFVb6g+nixTJVvUqUwqq84 VYGgyhVUM4nqyELRFwqqRxfL1yrXpLqZUa3gVJMFVZagSieqBYIqS1DZGVWwoMoyqb66h6ie4FSd BFWqoBpFVLGCKlVQfbtI9irVpJrNqPrbxKzG6Z3AX72rnaqDe4q4pQmCO564S19gUQ4jztoubzqp bRdqmlCLIrVPoeYKOEe/KbsrbzaTs30Cv2ieQ3oSjWq9s0Uu5s35tuTNiebczQRTcIwJfmrOXla0 Sh7eO0f0N8J0GJnuyz20mR7eITwMFWp2UrObHjqEh6GKh1te4x6Gmo4MYY48JTx0mIKuTJDDPYyS PMzLET2MMB1Mpt94nnmomR7O8IgOQ6hZSO2p5/0e2oSHVsXD24SHVtORD+4mR24VHtpMwStM0Ip7 aJc8LJstepNaojehZfra3MMw08NjuSKOCbUT7HnBc34PKTt5SHLTw6lLuYc8F//+BXNkQzPuYbkp uNCGfVymGfMwVPLQKTwsEabpfWA96TnmocP0sKvwsFiobSW1LqaHJcLDYsXDQ0u4h8WmIxOZIwnC wxJTMJQJErmH8ZKHb2WL4CdMryHTWxYwDxNMD1+ZKwKbUFtGavkL/B4WCg8LFA87Cw8LTEf2hJIj 55uKOGoKPmSCy02ZhwmSh3WEh/nC9AIyfRv3cJTp4XdPiyAn1GaS2vn5fg/zhYe5iocvLuYe5pqO 3M0cWSg8zDcFjZlgEfcwWPIwWZjOEqbTyfTU+cxDu+nhUNHkU4XaKFIbYnqYJTxMVTw8t4h7mGo6 knsX25coPMwyBZOYIJJ7aJM83DZLxENhOp5MH3qWeRhqevihaPKaUIsitQ+eNeOh8FBTPBwoPNRM R368kxzZ20TEQ1PwBRMcbMI8DJM8bCE8dAjTYWS6M/cwyvRwqWhQoULNTmrBpocO4WGo4uHqV0U8 NB2JYY5MFB46TEFbJsjkHjokD6fPFPFQmA4m0y/mVfZwiFCzCjX27HBinhkPhYdWxcPrhYdW05HX W5Mj1wkPbabAwwQ3cg81ycMjM0Q8DBDxkFb/zs1jHsabHn4hGpQu1E6Q2p55ZjwMEPEwQPbw0VdE PAzwO2JpTS9djAhxBOW8caMIiqb0+xByc+WNrLNPFDZLhM29ZDNhHnX2C1kiLYYd13cJIyUmzSJG k8NpugmaYkHDnj01FjSUuJm/539cnyaYik2mgYzpIc7UzBf3BNMaYiryciZKZDMM9j6BYCo0meox pnDO9Jdo/QWCaRl7HiaYKJFNS4hJzxfh0GTa1IqY6nGmzwVTvmCihV69g2CiRDabIKalginfZMpg TMduYExv+4KhYKLVX730Gc5EiWy6QExDBFOuydSGMX3ImXJ8sU0w0SKz/ppgosTNwYKpgWDKMpmO tyQmD2caLphSBRMt8epDBRMlbm4smLa+LEKeyfQiY0rkTO0EU4JgovV5vaFgosTNNwimxwVTgsl0 P2OK4Ey1BJMmmGhRXN/m4UyUuPlGwXSPYNJMpgDG1JAzHffFL8HEHkBNEUyUuLmJYPr+Jc7kMJnW 3UFMJxszpo8FU6hgoscd+r2CiRI3NxVM+YIp1GSawJjWcSaPYLIJJnojXf8hlzNR4uZmgqm/YLKZ TK0YUx5nelgwWQUTTTn0VwQTJW5uLpgCBZPVZDpkZ+tbnKmjYOJL04hRNOEcIJgocbNNMG14kTNx Tb7/kzFFcqYGgkkXTCfY8zDBRImbbxJM6YJJN5liGVMQZ/pRhGxlA94nc0VwIqabBdOdgknafvdP C2I6HcyY1gsmZSfcY4KJEjffIpiOLhTxyWR6nzF9wpmeFUyFgon2b+h3CSZK3HyrYHpeMBWaTOMY 03OcabRgKhBMy4jp2BwRn4jpNsGkCaYCk+k2xjSOM3USTMquuxcEEyVuvl0wVbwg4pPJ9PXtbP2G M10vmJQNcU7BRImbWwimtYJJ2vPmYUw3cqZvWJ83LSSL3rRJ1+swjiEhWZvtgiCDEcSQAm//LPdf QSz3JpE7lfKM0otyKtjOtFR6++XvPLYK8jpUNlgZWZE+J4+TpQqyituIrJiTzRJkYufdk4Isgcje 42RjZ4g1FiKLFGS+bXjvM7JFnKyPIBN75u4VZBr7PjEnu4fIbhRkZ+ZxMt8umjGMbCKRzdpB79/I 72/6n1DRCt0HbDqyia3Q5RjuuuwtKKuzKGemhf/n9E7PUiSxWSI5XU1OF8mpanKqSB6lJo8SyQlq coJIjleT40WypiZrIjlKTY4SyQ412SGSw9TkMJEcqiaHimS7mmwXyTY12SaSg9XkYJFsVZOtIlm9 5LF8pYPOY6JaK86/u+UO2ijXoZa8Ue4ec1fhc1zeUZHfa8of4/IIRd7OlA/k8k6K/D5THs7lnRV5 mClvzOUORR5uyn+/mckjFXl7U76Py7so8g6m/H0u76rIO0rl5/JuijxCKj+Xd1fknaTyc3kPRd5Z Kj+X91TkDqn8XB6lyCOl8t/E5NGKvItUfi7vpciptM6896hnR0sMFU/8Sx84btDq6yiePMqXvJ0n 5/PkfF9ywUllo+KBEr5Vjp6Z69OmVRilO0oUhYaHJIWHSOGiqhAnK3Qhha6HFIX5ssJNpDBdVfhS ViifCoWNqsL1hyWFg6Twj6owQFb4mBS6H1YUnpMVXiSFGarCLlnBTQprVQXrEUlhMCmcVxX6ygrt SSHiiKIwTVZoTAqPqArvywq/PQmF11SF245KCl+RQsOjisK7ssIqUnhFVVguK+SRwnNH/XsqRzRn lW5ifbnSjavvr5TduHySIk815bdyeboiTzPll5ox+WOK/BFTfpTLJyvyR035Ri7PUOTjTfliLncr 8gmmfBqXZyryiaZ8BJc/rsgnSeXn8imKPF0qP5dnKfLHpPI3ZfInFPlkqfxc/qQiz5DKz+VTFblb Kj+XT1PkmVL5uXy6In9cKj+XP6XIp0jl5/IZijxLKj+Xz1TkT0jlb8LksxT5k1L5ufxpRT5VKj+X ZyvyaVL5uXy2Ip8ulZ/LcxT5U1L5uXyOIp8hlZ/L5yrymVL5uTxXkc+Syn8jk3sU+dNS+bn8GUWe LZWfy72KfLZUfi6fp8hzpPJzeZ4inyOVn8ufVeRzpfJz+XxFniuVn8sXKHKPVP4bmPw5Rf6MVH4u f16Re6Xyc/kLinyeVH4uX6jI86Tyc/mLivxZqfxc/pIiny+Vn8tfVuQLpPJzeb4if04qf2Mmf0WR Py+Vn8tfVeQvSOXn8kWKfKFUfi5frMhflMrP5UsU+UtS+bl8qSJ/WSo/l7+myPOl8nP5MkX+ilT+ YCb/jyJ/VSo/l7+uyBdJ5efy5Yp8sVR+Ll+hyJdI5efyNxT5Uqn8XP6mIn9NKj+Xv6XIl0nl5/IC Rf4fqfxBTP62In9dKj+Xv6PIl0vl5/J3FfkKqfxcvlKRvyGVn8vfU+RvSuXn8lWK/C2p/Fy+WpEX SOXn8jWK/G2p/I2Y/H1F/o5Ufi7/QJG/K5Wfyz9U5Cul8nP5WkX+nlR+Lv9Ika+Sys/lHyvy1VL5 uXydIl8jlZ/LCxX5+1L5r2fy9YqcSisN0J49IA3QzqRjgDbtgDKCOyYrfE4Kn6sK9xyUFN4hhZsP KgpTZQUPKaSpCp/JCqmkUKgq3CRPGvqSQj11TpAqK9xJCg+oCutkhTqk8IaqUFeeE5yaBIU/VYWh ssJ2UuitzglWyAqvk8LzqsI5WWEWKZxUFXrJc4JRpBCmDvmfkBV6ksI4VWGNrHA7KSxVFX6SFS5P hMK3qkKIPCc4Sgo3qHOCDfKI/hNSKFCH/KdkhVdJYb+q0OiYpPAEKVxSFRyyQgIp3HlMURgtK3Qm hXhVYZ6s0IwUnlQVPpYV/poAhRWqwglZ4RtS+FJVaPCdpPAhKZSrClNkhedJIeU7RWGSrPAYKYxU FQ7KCvGksFNV+EpWuI8UNqkKnY9LCo1IofVxReE+WeHseCjcpiq8LCvsIYUcVWG+rPAuKUxXFS7I Cs+QwmlV4VdZIY0UjqkKw05IChopxJ5Qp+Oywl2k0F1VWCcr1CWFN1SF1bLC6UehsERVaH5SUthB CnXUhY0gWWE5KVxWGabICk+TQorKMElWSCKFkarCQVkhihR2qgpfyQotSGGTqtD5e0mh4hGqD9+r 9UFWOEYKt6kKi2WFjaTwjKqwUFZYRApPqwobZIUnSaFAVfhBVhhOCvtUhet+kBQcpPC3qhAhKzQn hVY/KAoPywrn0+hjvarCXFnhW1LIVBXWyAprSWGpqnBIVniBFIpUhVqnJIXJpPCbqtBWVhhICjed UhSGyAphpNBLVZguKwSRwqOqwpuywi+pUFioKnwlK3xBCptUhXJZYSUp/Kgq3HFaUvCSQtBpRaGf rPAIKThUhQxZwUkKSarCYlkhlBSeURV2ygr1SOFDVeEXWeHHcVA4qio0/1FS2EkKdX5UFDrKCitI oaWqMEpWyCaF/qrCPFlhNCk8qSoUygrRpPDmj/SdM//WrgfpCb5ne+kpjpV2Kh+sTZ80K77RPzw8 VptPv25Upl8s787S0z/xL7xuN7mk/clexvWWyfUc55qucD0uuJ4WXK+ZXNJG5J6MK9vkiuVcwxWu QYKrheCaanJJO47P1SKuRJPrYi3+3EHhaie4Nv7IuYaZXNLu4rcYV1eT6z3O1VjhaiC4hguuDiaX tJP4IcbV3ORK4lxnb5C5fryBc50/zbmCTC5py3AQ4zp3g5+rKefarXB9KrheEFxlN/i5pL3B2wOI 6yuTa3cAn7IqXEsFV5jgKjK5pB3BUxjXuybXdM41S+F6UnB9cYpzLTe5pK2/bRnXXJMrnHONVLge EFyPCK4ZJpe0zfe4hbiSTa7TFv4sSOFqL7jqCa6HTC5pc+8LjKunyfUK52qqcDUSXCt+4FydTS5p S29fxnWLyRXHuX5vLHP93JhzRQuuG00uaUfuP4YdOS809nMFcK4vFK5dgus76mA9O+nB9N8P0ciW /y5dbaZ/T+mvifSZ33PbdbjtUvZmB/dB2mY7hfmwyPRhOhJo+V3x4RHhQxA49fEZsFK2g1v5iwYv FMfYs+3SmY1IUfxMKH1M/qmVjsbP0oB/5PBXaUOhXkHu9G3kd+eXCubOSqX50itjpev/rswjbRRc xniM6/08b3KeLIXnMeJ5rAqPtAEwgfGsM3ke5jwxCk934mlThUfa2BfMeCaZPM04T7DCU594Tl6s zCNt2Cu+TDx3mTxfXmY8R5Wq/C1+lb5ShUfaiDeT8Ry/zs8zh/MUKDz/IZ6BVXikDXYOxvOyydOD 87gVngnEU78Kj7Rx7rdLxDPA5Dl/ifFEKTzU+Eu3lVfmkTbEFTCeeibPKs5zncJDTaL0iSo80ka3 UYxnS0M/z1jOU6I0i334VRpehUfawGZjPFNMnts5zwqFZwnxlF6ozCNtTNv7D/HcZ/Ic+IfxpCs8 acTznyo80oazXMbzUwM/z7Ocp5vCE0E8w6vwSBvMohjPayZPH85jVXgCiKdxFR5pQ1n538QzzOSp +JvxfBMs83yBX6W7z1fmkTaQrWE8QSbPx5xnmcLzCvHMqsIjbRVLZTxF5mrcRM4zXuFJIZ7IKjzS 3iU745GeCt3JeRwKTzjx/P5Xlfhj8pRcJJ7OJs93FxlPoMJzOQg8b1fhkXYtLWA8v1r9PC9xni+C lK6GeJKq8EhbljTG85bJ05/zvKTwzCeem6rwSPuVLIwn0eSpy3kSFZ4E4tn3Z5X4Y/IUlhNPc5Nn cznjCVV47iAeTxUeaadSOuP5qp6f53HO83sjpVun/iu6Co+0TSmU8cw1edpxng0Kz4fEc/Fclfhj 8py4QDw9TZ4fLzCebIVnmq97LW1aT/xVdrsZPqT9b0SX05Cah7rJKIvZOVjXb+cpbsfSQLZzsb7P znt1q9qRtgq1YXYO1rdU3ioUzOxMMu0043b2KKvcO/12YquxI2342Xae7CwXdqQNPwXnWfw37aw6 b6/haRuzc6xOVTvStp3hzM4kYUfathPF7LxWx4x/3M4Yxc5Iv53MauxIm29+/4vsdBV2pM03JX+x 9m/a+e4vZidMsdPGb+f6auxIW2g8zE49YUfaQpPO7HwVaNZ/bueSVbbzl9Vn543AqnakjTB3MDtf Wy2VN8JYmZ1xpp1G3E6xYmeb3073auxI21nW/0l2XhN2pO0sy/5k47/a5vjvT2ZnoWInz2/n29rV tB+TbiCz86iwI21KcTA7L5t2enA7oxQ7w/12JlRjR9paUnqO7HQWdqStJXvPsf7ftHPgHLNzj2Kn td9OnWrsSBtEZjE7tYUdaYNIKrNTZL5iNpHbKa8n2/ndF21Kl9Sqpv2Y72/fxOywsCp2eJQ+7MtR muT7y7dto7SXXxYry2gjRumdflkbWUZbK0ob+GXXyzLaLFH6S4BP9nuAJKM33Ur3+2XfyjLa0FD6 sV+2XpbRFoXSV/2yJbKMNh2UPuWXzZJltI2gdLRfliLLaGNAaR+/zCnL6FX/0rv9sntlGb3bV9rI L2ssy+h1/NI/LD7ZXxZJRi/Ylx7wyw7JMnplvnSDX7ZJltFL8KVL/bL/yDJ6rb30ab8sR5axD/en 8WoyybxzlDqYpw437xmlduepvc27Ral38dR7zftEqY15anP/NNP3tvaS3+yWzPb00vMto9lrymxP CH10J3IdvfPIXnbUIsuDZrfBb/1NF2a1Ldb5X3PLRHaL2+6v9HSaIBlaxeEtDsvMzwS9aL7/OLjC KJtT6RgHvv43uIKdyxDpqmBHMODPzeMqKp/4wJ9/CdVGXLW0wTdVTobg67+DuN6P93O9z7+uXm+X 0Nss9ObVoLdU6L0k9OJq0Htc6E0Ueo1q0Osv9PoIva/2V693p9C7XegtqEGvYiDXO9+P6w2sQe+A 0PtS6N1Qg94qofem0Pt6X/V6c4TeU0JvYQ16Dwu9B4Te0Br0Ogm9dkKvWQ16jQaK/TXS+t9Zu8Ud LurpF2ftNX65ymQpjufWtjq5teS9/oo+7yyL8P0C5QjfO1B53+DjS4ZR2szstRN4ns5KnjA1z9OU 53uzxwrheUKUPLepefpTnlVmnt/OsDyNlTwN1Dw3U54nzTwbeZ6K2nKeC7WVPD/+gzx9zDy5PE+Z kueUmucDynODmWcIz1Oi5Nmn5nmK8nxn9qZ2nmenkmezmqcf5XnHzHOmjOX5QMnzrpqnGeV53MxT yPO8puTJV/N8/zfy9DLzzOZ55il5ctQ8qyhPIzNPPM/zhJJnsprnScpDRxVJaWMpbZeaNojSPlDT elDaUjXtbkp7Rk1rRmmPq2m1KG20mvbLRaT1V9MOU1oXNW0Xpd2ppn1AaTeoaUsprcKipD1DaT+r aY9T2gE1bTSlfaqm9ae0VWpaF0p7VU27k9LmqGk3IK0sU0oIoIQxUsJv5UgYLCUcp4ReUsKXlBAu JWyiBLuUsJISgqSEReXy82/qRD3lygOwZ36Xn3+TQtbvisI+WaEFKWxRFWx/yM+/0T+U1v1DUUiU FY6RQpyq8KassJEUFqoKZ2WFRaRwRFXoeE5+/k0KLc+p70vJCsNJIU1V+FRWcJDCGlWh/p/y829S uKAqxMsK1P+V9vhTfe1DVviWFHKQUvl8Ihri6Qd7ULfCNjndrXkjon6y00fwPT8C+Jfx9abUZeRs dTescnxRwwd8xxe97bRY/McX2fRP+1d/fNHPQ8jY9Z8Te3XHF23ow7/UXesBcXzR+h+ZO+0BlH7z 8KseX7Qaqv4Pj1P2K3543K6vc3KT9z1Q5fiiMTLVxKtTjXdKxxf9OpR/qfynkRWG+N6++T3reH5S bVzeWKvT2z9Yy9nt8vzgDov21nN5vtc8n/PzjiJ726c31LwP2bScI5l/lDXSvPeTquY5nHmkrLbm +doV+YPbikxdoThuC21B0x0j2dF/0d77oj0T7P4daHlD7S46I/w7fW7PCvZR15z97jvBuyYgs6Ez 8ht33a6P2IMWbw36uNzl+cXlOamvxjDMafQJLaPTbfXnoon2mMtThruF6lOCumCVtgNWPp8p+4zN 6cHYeguNtfXlVE+8W8S4mz7OOVeMud119E7R9J3Jt2jbdJx3NYOcs+5kzXvvqVO46/R1+LIIcRNK T9V8E0JcnvN6aV86y1Ncb3jrMr/PqUX+mllID8d2RtHnRNn3Obfwz4m+LH1OdG533/c5A0OEgs9n 84OiT0cxn63cZ6vwORE+hwmfg8t847KIK/hsJ58jyOdmQS2q8Xcj+dtU8pd/T/Rl6XuiB7sp/ooP ijJ/Q/3+7u9JX9zaQvMkvW4CuxkzhaJ/4+DcmXzLF/hnqHs1+4q9mjPUvZp9xV7NGepezb5ir+YM da9m31EiWd2r2Vfs1Zyh7tXsK/ZqzlD3avYVezVnqHs1+0aJZHWvZl+xV3OGulezr9irOUPdq9lX 7NWcoe7V7GsXyepezb5ir+YMda9mX7FXc4a6V7Ov2KvZU0llpz+jIdmkhiSfT6C0Jy0OUc7zOTvl +jzaMn2L9kjvCoM98KXv6H7Zmx3KGRN5NiiHDjjJvhzAj2ZHrXzkJAujH570R3UWDX7RI/uxcAHZ lhN+GQvGv+i3Mdmu8CN0CsotCMaLTzCWTLCE76YY9w+bRGwP30q13waNQdzO4BNc41f9EGnkHOFn QGrewfEIHwkQwHvNc4id5ZgDf2+pxdzczg2sPVHZzeedPjdnVnHzcWclN0dyljknfG4OqezmYK7R ze9me+4m5lLeqcxFRMqyHuj0MkO4sy7PHy7PRdwrTTpe5LoHeccYpKZvZ3enwuX5mY4fUrOkda0w eN/5Vf8K9rwcbT1iQzTvPe3Ue4bps/uy3pPt2FwTAJ1Adr4edcNMCR3lf+IodxFVgpfwZ85ZV17r omj65krETgLPeWdQzJ+0qXuKVuF7K2Aln/tR/iRf/gr9AfwZm3M2jutTQIrRWC/d+jjvpTXvEOq9 G9DB42ZXHUT9CDs1cijv7ANZbfZG1D3OLu6M7+ziDOCUgfR+Lu+xqXu1i+61znH2CNLin0Q0PM4m EVst8iRiPX7xK7YkjvdceRE/RfHrFUzXy6EP6cMcYJ/31rx1JpDl7K3opWrT0gqdeEQBmWa9D9Jg h86TJypvxEPMx6bfHLOzbf4b4/k5GOR16RfcYTYwp1HGBCbxH8yqIat7uHB80HcU4juZIb59pbFB lB6PXg5lD5y91T2VGSibBMLws9KY2qfaOpo7SeUVI5JgYXX/MWlEcvTYVUYkUfrhKDEiYee9xPER ydChrJiVxk1TZOpZV6eeEeW7/39hpM6raeltFYZ0hAcGm/HseJWHR1HjGqHl3W+l+T8nLxTkASAP yIs3PI2zywMyO5NHnuNGPIp8/3X0/P/oFbTr+7RtMBIvG9lypWxVjDx3zUaiZCMP/isj91yrkT5h 4p78cMRuyWzl9D7F+p46ekMHdd09+I+KzrS9n0ZhD/sO7/nsSM23bT07uGc3GkDZqirjURqv0Tla /KSjHpp3ir6hXlpQkf7K/VRXdmhejEMfRS0aEWIN3+/ynNAu/EXjT2+3Q3Q0T3KctzOrpi5vKMaz Nt/4K/Jk5s1O71Dd6X3cqnV9QM+8joJtiosOqHHf4fR20hCy79SQI3y/5ikm0sjDcTQ0Pu/+tOx6 orbSCTSIw322UD+sD6fFQd/HHOnwLy/CkmZFtFp3mEUrGwWqoqhgrsGnHWxMvU3v3o19DyG4Uo9L QfKPRN95T77LEez0fMn62gt0SfKm2l3eRxEJ6eCnwTZ25pceh8lMQYC7OQuIB/SHO2HOwq9NhtXp ORjnGYu+pmE/b+BF3kl4EUfq0k+XJ6zsHi0vA973hp26Lk9GsNNbl7Qaa94ouhigcHk67qP8no4X NaO3zeX5jR/WJBxnfr8zgJr0o6H6SRgvm4XoqK+L49Fj/gCqK318c5n8Q2jenUQ9ef0Q1ZMbzXoS RGRnH5YXoMW5TPnd+PRoQUSFoU/txCKwPljYaMiWLov0Dx+mOY7v/CIxuXFmGwFBs4vZOLxcw+UP ytmDH/3zQi7zwflPujeed8zn2RDme71he/L5qWBnUR9+A1EBxjrzHg8O3+/07NU8F8dWOj8zUvNG 43I5L1zQvIFf0wXEAACxPID99NAgDLkyD5TZ6XwB+owzRJ5GmqcjurJIizuwn+c6OoQucxmalTMP DY8Nl5d3xIjb8xTu4u2+eQ5dcWfew2FwjQ0fS4fQ1PgRl3xk0TW0J6f2P9+emjr/i/YUy9tT/QE1 tadxB/3tqfrm9GyvGpvT8hFmfbj29nQ5XmlPT7n+17enB12iPT3XwdeexvXjdb2nS2lP2gGpPQ06 UF17WvJQNe1Ji+TtKQpVXW/bgben2sLGJ3xUpic/9N+1p65xanv6pN3/Ge1pcPg1tqebnXJ74stV s87QN+xQhZ0eNv4NZl/30gf0EMPhXbND5kChNa130R/sy9S6BcOTaO8UK13OIfdWGNCa69Oa69Mi 4cGe/KtIoWyRSi/vQ8Ma3Cm0Ip2qn6Gf7sbHndLKUL9v6HE2+1pW9j+G+3qo0cD5/i6oNQ3Fj1UR xHRb4tc0xqytee+PouF+MB2npnlcgVRZNUqxY8ja4Gs2ZA2m36HsaHVh6CQEmeOhsVfRgKuj2Pom 1XhQ2ypR+w4NYl+10pv0ojpXrs3aQVdSOe4v/2uquSFmzbULwQwmuMcUhErLi/UMvrxIz8f1x9Ep lP5Voaw/3i8rDCWFSEMc335b//3XcEEu7qvhguzdLz3yOry/5vHO9X7737IbUefZ/VWu4KJ+13gF 90fxVntzP95APx1mng9ZQ/1c3fWK9XNUd7N+rr37CvWzc3elfibEVKmfsV2q1M939lVfP++T6udS B6ufW/Zew+14ZG8NtyN6n6ifYfuqXN3uzmu8uu6eNdbP8r011M/je6+1fh7ocJX6+VEHpX6u+uoa Lsjwr2q4IGF7pfrZZe+11M+IDqx+/vJVlSv4T99rvILte/D6+WRfXj9bDqX6aZ5d6vOXzYl964td u2cjNbMR9TzhPSv4WaC+Cz/jq5pd/5J3ZdPRhZV9aobrBeb5lfSGHmsRl3xfEOWN4lWqc+LrpKjx FbVEjac/eLvQulC7oPqNYiy6izUMw6dm1JIaxu1d6CTWjexbqcTJT6eqYOvJmnct++1rJD/p9s6i kczmAn4Bnv6S2gn7UizaSdDs4ACxsMDdLess2jANrbwP6Po7kUpj/JzmwHndQsjsFjYfDgzxajo7 sJMdcPydXt6DJ/u+/8wMvsVcM5vrP19Q6vtIjTYo1Xtbmy+uoRJ+s6eGSvgu42OvHXnrvPRFlXq1 PPYa69XhrixGLNojeSO+88pyzAvkf5NP4kuy3jrd/W7N5jdHfRWsEXNuNl+ruVhZV3zfV7coLlZj s2h2iO8QM8rEvlPcltydtYNqn2+MIarzmj1saelZZWlprrn0tIDL5yvyXFOezuULFLnHlMdz+XOK /BlTHsblzytyr0V5bvvEZfHQjn2f/z76PMBlJWrtqZAUDIztSjeoYa1AZviOFF5SGZbICptIwVvJ hKywmJm4zAJjaQLr5HaVviia3xa2WLarLJZFTX8FD/tcjn+fXyX+MTMR7fhnJ32t4exnEsWFz66F 4o97WT09t/saWs3S3TW0mkzZ7oxrsvsks1unw2dVmlhUr2tsYlN4N+zY/W+a2OHiKzaxd3dLJflo 97WUZM09rCRpu2toj+nR/0V7XNSZd0s/RFWZD47iAybMRsOPaNlZOhrHO8iizEeys8otWTRc0UdH s6OIgz6+zpZ9sXUmgjGirLFbi/w8425X3qMBpqaDa/aCaiip3qRlb69VZuXn9Rnbta4J+uS3SnsG sIM042thWrQrJqQn6jz+r3moGg8JGabluULiXUjSXPgrig2YftE34Wa7kk/EBZyhOxdG/UoFfdX8 WzZ8Oam1OUTpoSz1sL6FelQ6xNM3tw6NQV2Ld3ldIRrVuqigza6QYUGb3SE96eX/YA/r88gBd4id SrKUDVtH0Hr/cX3f3bwnCkOfonk+1aNb8NVXuz7sbnFKs6a72pwkHRt7+PC93r2nLw8obfpTUbyZ 2UQlmVOEzr8vycLI3PzOfHX44L1cLVSoJZJaJKX4ViXjKCUKo4VR0uSZ1zVnEdW17mZdi/TFPybo ZQp6CEFzJuhrCnrLr3OwYZo7JEFvfDd9JcRQvxrjl55rA+lwVTpCSEP1b0kaxx4YbZdLlrMLrcR3 7uP8XTW3kiBuJQ889Nh9u3wxonZJy+b9rkDSgJNobfhUf293/6Ddd0P+2knPQx40/C/k/bOzRrqg +e39pf8rlL6QYIj3O3jzskd7vtI836KRYfznyhvDl5l+Yqs3v+ututO9/omenqVifOJMPugK+INF HzSrNvv8r2uUteDDHfb4YGKEGqb7wLvM61EN7KKvHemrBb1r9nvGV7wyRsPnsu2VZi1/7pCuZcWO q1zLYP3SXfxazqZH4C2iLNU8L3WF2Jyer52ev5yev+O8tZwoYPRGNMiZrsjSx9M0L/9stJYXMcZO o8ez0UGbu4Xm9T2UXV7/cXu2YXd3zTZaZfZmt2mmFlC3rK28XpIcOEcL+M044RNby67bVStM2Bm7 QDN2apFfTH63rDaYw/fj74zo8PPS+sYzgaGBe4M+3gprU1pE5f4WEvBhgLt2VO652Vu1oJhvef6o 3O8mf1tGqee3B2Re5yyi2Y1Rupyt+bhooHnE5RlPS437tDalIgQdcHmahOhdMR5yecejDWwLY711 dFFdHqDdIY4N/Kz2X/UUhH5X5PgQR9Bs6gr65V1nd+YtDIGRGVrkPqfnSNDcixh4R2f3aBk0+1d6 Upvv9NSTW1LX7XYL2Ql2eZuEUISzBuU0q0XvRtSKDvo4MDS7vF1QzlHTYWjGeY6heHSdUESn59eM UPxvrLoe1fuZQIf/+lidRpEz8qvJP9NzWF5OhMkDcZ4DmudnfWAXESz1g/ex552+7yBTeGMlpYoy tS1kkSPoVNWfA0RJZ+2ggroiT8Z5yoLmnqIH59MtKCi9qKjla1QYtv5lPreM+9RuifP8wQoclNOU vQNSq6yBsyjAYJPIX3sHbb7OkX0xY8Y9edH5VJPqZV90ZfYs66LlXR9yO6s3s7SAYuNE76CPYxwB 2eWpmS3KmmdfdLvRuz2Z2ayssU8wPrOuM7uoVlltFJ6uRnRubae3Vi/OP+apxtkXJ86wZ19Mcd+X fXFsZnxZg+yLse5W2Rf7ZLYhz20z6weWdcm+OCnzDuqBbN4G2Sc/yt4dVRbCpc6AgLJbsi8muOuV Ncm+mJUZJGtZPQ1gKNCRvfWT7PIbp9y4vp7Faglavi2jvq+6R7HDpmPa6NEBRTGYv6tPwUU77rSt hhn8bUwQYQrk1w3fqeDRLYrV7m/1xiFUf39GZSydr4558y8LzTjPV3EU3r7WT7Ui5cNxnnNxnoul U5hC950t6fskLejTH4y7+1pKeNuOhKYV/r7BXnY3RK+QqAfp/nqJ6eZSwnTStVyu0o903yqFrb5b rxK2ovTYVjxsfdFZXuzE+EiKX7PO5LPp7Bcxnu3Rnj2aBzNKeu/Du5Ede8K6eT5H7UsdSvZlw92I 9yVsTDY+MDTmmZVs5ObMNmSZyzMt0O7/5RkRGIYWurO7ASr3BJMhb3ygbebGwIvkmbu+NmvnCfxR hoHLkt/YOvIRDNcQK2ZOdVjcdZ7pPbzsJiqR9xZqhehGosJ838439ubmUN5dOSfx/wAt7z36FZM7 gY1ZT7CyjKBxeBhNsImkz9280wljE3F9XHiFgai8I7s8+amMPG1x9sXAoKc/BEee9lz2xfpBc16m kWJ5WtBstiHF270RTNOJXXBgA525oP+FKxSTuyJkPhuydv9lE8nXsp98zeGbNuxb+NR5bwgW05ut SNPftVUY2eXDZgTlaZ9kX6w9uWd2ebS7S9mr2eUJ7g7Z5UnudvAq08se1QRtDg7fSq+r0OKFPgsx texOLa/OCDqzOfm6XC1gm3GSP2LJi+gBS0xZHw49Xpt8j/h/3cSWJFhZ7m1JvtJLB944NqOx+WYR dDCTJmYwdfZsNKcfys6X5YxrJZ9qP7tJ1qIDC/RFrEuPxaA+zlaJ3j9ypZUVukhfIXZ6SjC7zg9Q DgJg0z/T/TAyOVua+XbaRA1ijNkgRvna/yY2JQ4JULYBBPgzXt7I5K0V+e0B4kGVdK2bwrPSdRVV dk2wo29K2ED53kOfXPlCos7Wyfmkhss4YqM0nRq78SrTKWY2iZmtc/PGKtf8ro7Xfs0fupvPn5Z3 qJBD3g9iks4sXbidvrClzuIbiegZrB8iqQGp3rMpfSbrEl/lpCZXelp5WYPmZ/zlYPbKRiealj2l W9zJ0nzsKT7LuqDv70CTjk7o22/PLmfzsT6YjxVrkdsz7ja1Vvq0Ym4PILVH2FzsurH+8RPNxx7G fEyZEtvCt+q92vBVbpv/LR+rPrEljwvBRD2rAx+M+qrd+g0YjN5AMyKbHnsbW8sMlV6MeH9DzTft M/7y7mrkKttMoZ3Oa2rvH537LAzbIEX5pCvwiZeBE2/jUf6ncP/7v3J4D1ZWSBf4V0izWvEV0mV8 hbRubbH0SX/waHVna2mF9Ikb2AppPZ9avdrSCumlEL5CWiAm8rlihbTJPXyFNFdZIa24w79CKh3k NGo9hZCf/SukdrX32d2STIynIecF/Z5bqbr+6qJJx6f6UyFKHH+tLZ+NWsmD59uKuYRYLQ0Wq6Wf tVHnGN8XsgAmlkt9t2IPS/1YWi79e52y8CO37t7+MPnGuhra9zTGN4cvrYwrrNJk3WHqWs6VmmzB nWw5J012iK+M+FZLFkjLOXztpk5Dv2fiYC/cg9/Me3B0HfOPh/GiyrqwzE5f+/I+dYWmis0ivnzk c5c24eoXW7MV0+DaUkz3NZpp6+xXXDMdweU1rpl24/Ia10xv5fIa10wvfWy/6prpOBEKaclXP3MT QtxQNRR+ViEpfE4Kher4cbnM8A4pPHe5mgGmUPCQwhxVoUhWSCWFj8Sa6QixZvqSaJDernzNtI/o NP3r/x9JHUydj6/SwTA7lpvUAFgoU3z60bVQbLKxqrp57TW0nbS1NbSdKNluv2uyG8vs1qlYW6Wh Nbz32htaz1bMe8vaf9PQXv/wig0tY61UmOlrr6UwWc1ZYcLX1tAqHff8F60yuSXv999tK88QlPfT 4quun86pef205T3Xun5a3vZa1k9v4eunUWL99D62fnqfb/20r8ZWTZHkoPXTMLF+Ot0mr5/a/eun L94tr5/axPrpjLv5+ql49cg3FqBx3x96yzv4dD+YetiPmvpfjGZro60b8LXRYL1r08pro1axNnrH 3b487FHm6LZqv/PIB761UbYUm9GSr41+YlOXUHt/4Fsb9a0NhH8g1kbjq4TTez+wV7822oQJqlkb /ed9+9XXRjX9ryY1r41q+sEmNa+N2vT1TdS1UV/J0t6X1kYz3q+5JQRxK481kdZGfRcj5H1pyNTu CiQNOMk9TfiQaW1olRcaDq2ptDZ6fE2NdObaqKYfulGsjVZZH8zSPN1CXOxZL18IM/Qz9Wkyhr8w Etl7g3hRr87Da1jTZgHJGn4254jb6Uo+58rrTl9ZpLGP1dfe2MCLDYAq9GX1qOrdeobK0+RGNi4S 1XMOJJqx0xX51+Qvadz10g1UqW4NYe/W50UMBOuG6/nkWX+wnrQAuylUraQ7V6Ou0d6DrKqrLltX 13y1vyDGdH0z7JZtq3SdH1st3bKpVyBpwElo/Em+BdwFsg/l2QTihfT+waFV9mreP6hNJWhG+d+/ nfO0aVjpPYQLq2r2YRdvvH81hu0NmL9o3r5WaQPNgmt4H3P97f/z72PmtPgv3sfsxd/HfKJ1Te9j HnzP7n+/2aMFV3oZc9aNNb6M2QxTJb6f8F++jznhLuV9zC/r/69/H/OzluJ9zIAGvvcxD9p5TVnd kr2P6R//rETF9W0T/HSlvZr3Ma9vL7+PWZ+9D78+SHmrc/JKqfpPW3mV6m/VnwziHfVka4Whj6zP 3+aMEB6ebcVfxnmRzQB91//fvM/5aCv1fc6ywP8z3ufMrneN73P2a1Hz+9GY+sYheqJm0MOLnLNB s1+hYnsjzr5DWyhpi8zD4k788Y69+jXkQ0wgf5vFvEUdKQwfuh715m4z8R6+LPIpJWO8UKax/Zas ErkiL2TO9wUn+rGInY9bF7cg52zm105vtxAn2wnF910m1vbtu4ytvIfvX7wPHnnz/3z8qXPLfxF/ evD4c9HONtr5jpF05k230tgrWLejcvuOopRij8tTqp9uUGPsebUdbwK1WrAeUO9XB+0koi71FdRS Goo1ku12rvZoO2W8q+yX/pYPeOPyxlnjIv90R0d7J1iivX3skTunD3R6E22uyHNBs8+whnNBH4QK GplqD8r7gbmr2bSc3c6g2F2uoJjf6RO489jC+IxQi3sY8tq9ve3RXWMt0/vFhp8vpdOpw49E6kF5 Y0kLYkZ9SVB3vrXC6ErUtBBON4M2bwfF/qYFxWxzec7RdK8dyzeAb+s+524b7Y21sPbl+dw7GIOj +1HfMmyRe7Ug1++atxHUMk9F7nV6vpt+Kxxwdk20Bc3+WYwAcuvyB3egCN8dHdnHrgXFHXIhYylF DuQp3WrxW3N3VNq/07MnmoZjTgzCg520MT9yJ2zuo04FNk9E7ozz/Dj9RrIZedSdRRHnJm4ufGt0 5ES7KyjuBEz95vL8UDYSWmUJ/lL94G49dgGVp7coz2CV+1TkTipPE1Ee9+1sf10diRzlKCFyejj6 AwV/z+FKe8rF+7V0TSto15Ud3ZONbsEK47Lh8k5lg//yWrQ5GpXrn8wT/M3R6uJNPO/naAOuv+lt bsY/XuBt6PIms1b3m/PCn6ho/bz3lKLJux/WvCMtcZTlfhuL367I36m9DdNZPynam6G/2Jy3N83b gdrbXf72BjpX5M/s807n0N4aEWl9tgqNBlcrfGul8lILSGvLOmvhv+Y5PVjLu63bq9T1n7HSPJP9 WW64b6DxTnaZ1dhLs1+kZP7O6EZutzBdff4dbCRl3W4x/xttmZTpTs90Wwa7J6ckTegTF31/yuSJ KeO72OOS0tNTxthjx6dMSJnozrD3Tk2aOC5lTBf7oJTxk5LGpIyh7P3DO05IykqeNCE9bXzK5Iy0 CeHt4zPHjx+cNvHRwU9MTI61VPqvir6DqftVq/J1ikuamDQuZXKv8ZOSq3JWY1/Wv7r98IhKBVez GPXkX1bLVG3YgLFjM1LcfdKyuljusVuG9h/s7Ns/NsYy3TJk2IDBvQfExbti42L7D6lsmf8Xe7rC GIR/ifj3LP5twr8zxw3jovTvW4Fy+gn8O33SMG74HvOW7zlWiN/yP5K9dxoo/Tv3I0c5nf6u4foN TpsQm5Wcku5OmzQx1gJp4oSMtMS0iWnutKTxaU+mdLFnTnx04qQpE+0pPrVqtSy9tWhn/0RXbP++ QzRLdHx8ojPGMij2AYJhSZMnpk0c18XeK82dwa6/PTMjJcM+JiV9ckpykhv1zkc5JSnNnch1EtMm P2YfmzkxmWzeYRk8ZFBsdFxin0ED4hK1AYOH+BKGDBA/eabwcP9fEf6/fH909Kd08P/VuXJb8Esi fX85fH+0D7f0TkpPGp02Ps39xKCUcZbeqSnJj2ZkTohLmTBp8hOWpOSIsaNHj07plNJxdMdO4Z0j k8M6J3VOat8p2dGpY+cxKZ3HOpJTUlLah6eMae8IT+4QHta+s6Nz+yRHSqewDo4xDkva2PRxSZaM sUmmU5aY4f2j45y9E3u7BvS+f3BibP/oXi7UQOfgxMHOuKGu6CHOAf0tcbG9EwcPjY8fMGgIZPG9 nbGJg13RD+D/7Co5+/flidEu1F9WYfsPjUt09onvG53ocva/f7AlbWI1caFd2qTEpMSxkyYnpySO SctIGj0egaAandHXoMMjz9UUJ2dOTEx+Inl8SmLypMyJVR1Kzpw8GQEq8Wp6Y0aPS0x2jx+TmDR+ wqQMd2LKhHT3EzVrjZk0MaVm6VUyI7lqQRRpYnpaOgo9etyV1B7LTMmoviDkHV2/aoVj08aPTxyf 8ri/5lYSj8/MSL2qPMOdNLkGelN+NRa08eqFmVf0EAUj/vE1Sx9HkKn+CrN8iY+nJLsnTeatpx37 P67pZPCljZuYNL7PpMlTkiaPgXfRY5LS3SmT2w3uE53YZ8CgYdGDYtCeLC5nXDRClQ+j+R/RcZaY mEEdEzs6+vZiKdRYLFnJDwyNjE/s4+rbq314WMfE9omxlgGsZtvvah3eul3r9q3vsqdl2JPHJ2Vk 2Ft3aG2fkpqWnEpJEye57RR7k9xpqPr2KWnuVOTpiDwRyDNprC9Pp9btLPFDXS78b7BmGSrCr3MA l7ezZLgnpVlaZ1hiBw0aMKiLHWE8fnLaRPdYO5rWhCTyw3IXM5aRmZ4+aTLCawNLA3uvpORH3ZOT kilW+zhHU69pn5g0AYlw3hKfNBmxmcrBCcaiaY2xp020t0N8tqOipbSz9EkCjLG7J9mTcTvcKEeS Ozl14qQxKfYxaZPZjXjCfldVtbHp3ElZqdrxREbqvxpPQP0K4wmHa9KkdDbomJSJuFOJtZrxh1+/ Oh9q5IcT/4q/UhkDbqnd1d3YYrm3lsXiOHfZWIC/szA6PXODxVIAtN5InwGtMHb0sFjKgVv7Wiyh GHSOwLgj31Zh0FkEDkyl6GyDfMy0YoC5GP6NB9paVhgLgVnAQsKQCiMEfNb2yN/EYinsWWHkA0uA a4GOmAqjSVPY6VthdATmOiuMFUBrP9gF2oDxN1ssqcDxwFxgLrAAuAJYAqQzMcqBo4C2+yuMaUD6 zlk+MAG4FlgI3EvlAp6hdBfKCfu5wBBgATCK/IpDfmA58Bvyt3+F8ScwawD8gD/5wPHAQmAu+Rlf YRwFasByYBawSTP4MRDlARYChwBTB1UYbqB1MK4PMBS4BqgB95AcqAPzgYHNLZZioB1YDuwGtA2p MBKADqAbmApcAMwFrgQWAIuBOvAU6Q+tMCw28ANvBWYBHcBc4BBgPjAdWAKcB7Q+UGEUAB3AHcBU 4AlgAfAS6QFtN8EfYEegbRiuBzAVOB5YCMwFWhNwX4AacCswC3gUWAAsBxYDm+C+lQPDgPnDoQcs BB6l+wksJzmwyS2w8yD0gA6gC5gPTAWWA2cDEx6CPWAxcOst9A4LeIDWEeABhgKb3Ap/gGHAQmA8 UAeOB1pHwm9gKHAFMAu4A1gAPEH6wEvAEqDtNtgFdgQ6HgYPMBU4HpgLzAXmA1eQHnAHyRPBQ3Lg JWAB0HY7/AV2BOrAeGDCKNwPYC5wHrAAWEB6wB1AWxLuK73LCbS0AC/wVmAu0AEsAA4BFgPTW9Ab QeABWkeDB6gBdwCzgCeA+cBLlA9os0MvGTzALOAQYD4wHVgInAcsARYAy4H0pnTqGPhDekA6PKgQ eCuwBOgAhqagvgITgG5gFnABMB+4kvSBxaQPPAUsB1pa4rqOBQ8wFegA5gKHAPOB6cBy4DygbRz8 IX3gDpIDTwGtqeBpBfvAW4Ea0AFMBQ4B5gLTgeXABaSXBn9ID1hMesBTwEJgYAiuI9AOtD6CdggM BSYA84FZwGLgQtIDrgFqjyLOALOAZ0gOtLaGHBgCtI5HnAHSuZQjgPnALGAhcCGwHLgGGDoBcYH0 gDowARh4J3iBdmA+sBuwBJgAtE7EdQaGAhcAHcCVwALgHkqfBH+ACUDrXeABhgCLgVFAHTgCaE2H P8BCYD6wBLgWWA7cCwx9DDzABKA1FDzAEGAhMApYAhwBLAdmAW2TUS6gA7gGqAH3UD6gDswHBrZB PqAdWA7sBrRloFxAB9ANTAAuAOYCVwLzgcWkDzwFDHXjvt8NP4B2YAmwG9CaCR6gBnQDU4ELgLnA lcACYDHlA54C6kBLW/ACbwXaHkf9ATqAQ4AaMB2YCpwHLAGuJPkUlAtYMIW+s4DrCgy8B3xAO9Ca BX+AocAEYD4wC1gMXEh6wDWk9wR4gAnAM8BcoPVe8AJDgMXAqHvpyQ2uM9D6JHiAGnAhMAu4BpgP 3EP5gDqwBBjYDuUC2oEJU8EDzAWOAJYAs0gOXAi0TQMP0AHcQ/pAHVgADLwPfgDtQOt0lAvoACYA E4BuYCpwAbAEuIb0ngIPMBSoA3OB1jBcd2AI0DoD/gBDgSOAGjALmApcCMwFrgGWAPcAy4E60DET /oRDD2gH5gK7AfOBCcBCoBtYAlwALAeuBGbNwn0HFgBPAW1Pg6c98gFDgMXAKKAOHAF0ZMMfYAJw ITALuAYYOhvtAqgBzwBTgdYO4AGGAIuBUUAdOAIYmgOeDvQoBTzAVOAaYC5wD7AAqAMLgYEdkQ9o B1rnoFzAUGACUAO6ganABcB84EpgAbCY9OeiXEAH0BIBP4B2YDmwG9CWCx6gA+gGasAFwELgGkr3 oFzAVOAZYC7Q2gnXERgCLAdGAW3PoFzAYuA0oA7MB1q9iBtAB3AvMBV4BpgLtHaGPjAEqAOjgNZ5 4AGGArOAGnAhMAG4BpgL3AMsAOqUDxjoQL48lAsYCuzmoHdaUC5gKtANzAcuABYAV5L+s7g+QAfw FLAYGBiJ8gDtQNt88AAdwASgBnQDC4ELKX0BygVMBe4F5gLPAEuA1i7gAYYAbc+hXMBi4CigDpwG tD6P6wN0ANcCU4F7gbnAM6QPtHaFPjAEaH0BPMBQ4AigBswCJgAXAnOBa4AFwD2UD6hTvoUoVzfk A9qBCcBuwFRgArAY6AaWAxcAc18ED7AQuAdYAtRJDgzsDr6XwAMMBXYDasAEYC7QDSwBLiD5y7jO wCxgMbAYeApYDrRgPlGQj7gKLAE6gNZXEFeBhcB0oA6cB7S9iv4dWAw8QfrAP4GORRVGcE+UBxgC zAI6gLlAFzAfOAqYuhjXm+TABSQHriA5sBBYANwDLASeoN9LUc4o6L2G8RDQtgy8wFCgi9KBqcAC 4DRgMXABsAS4AqgDC4GF/8G8geRAneTASyQHBkfjOgBDgNbXwU+/l+O+AktWoPzArDfAC8wFrgDq wK2kB/yG8r0JXqANeAkYCgzuhfICQ4C5QAcwH+gCFgBHAQuBbmAxMJd+F+A+kd7b4AeWA08Are/g OhMfMLg3/AGGAHOBDmA+0AUsAI4i+bsVxkySAxeSHFhAcuBGYCFwL7AYeIp+v4f6HQP9VagHwHxg GLAQGAMsBibE0PEIGFcDy4EzgdbV4AfagAXAUOBGYMkHFcZvpP8h/MXsVl8HHmB5YYUxBliwEe0N WLgJ94dwG9oZsPhTzF/7wP4utC9gQRHKA8zajesDzP0MdoCpn2N8SXpfYT5BentRPzAfdnyD6wDU voWfQOuhCmMZ0HYY82Ng1lH4oSH/97iPhD+h3E7wlKEeAYt/RfsAlvyJ69oP+S7CPjDhMuICsCDA MM4Ay+sYhv1+pDcwjARgYSPDWAC03mgYxZTe3DAsLvh7i2FoLvqOuWFMA2bZDWMxYWvoAYvbGMaf wIL7DCM0Dv5HGMYowi6GUUjY0zBOAQt7G8Z18Lf4fsPIAobGGcZe8j/eMMLI70GwDwwdCrvwL3+Y YcwDZg0HL/itD+I3eGwPGcat/ZFvrWEM6U9fPTGMmcDijw1jLdC2wTB0YMlmlG8A8m81jChg7jbY HUD3xzBWEm43jG+AJTvgVzzy7YIeYZFhpAILd8MfYMIelANYDPwGqO83jMCBuD8HDMNBeNAwxgOt Rw1jBTD3hGEcBeonUY5BKI9uGB2BqWXgBZacMYxlQO2sYWwEJgD3kvwXw7AORr5fDaMb4W+GMQZY 8rth5ANt56BH+BfsD0E+YIh4XtNErNMEPDnIEpAVHHDLdfWs9E4mpgkWTDEty05eNqIw97A0Cu7T yNYvqOEU60xLz5u73t0hpKVF6PD88S7GUG9R68V2yy0+HnoRgrgK61YYiwMtlsD5aMi9GgX3amTr 1cjeq1FodKOwmEajsuvOq5MX+Gzt+bWgiyGChT6JHNIQ9Q8JgS8jT7SUp1ejsOhGjphGMwOy682r m1fn2cD5tefUYnboTWvX9RXGPtgOfMFvK7qRnaxwC6RH34huElRh0LvYpj/RzJ/sOvOYIqaSlhP4 Nw16I4GBMzhfNOPLrv1sLV6+GNgqhI5BrwxV9TO6UZTiJi2BWOjopNm1K4y7LDxPdi1+HUm2ELJ8 yDoL2Zxava+vK641PZl3Na4wnrke/tzfS5FTXtoZN69zhXFLpbwkOwPZghpkdB7WwhpkIZDl1yCL gmwxZA9VIxsB2QnI7qhGRseT/QlZUjWyhbS/1lF9vjWQjXBU78seyEZB1iag6nWjc99W3FZhvEfX LbHqdaMXmYdE1lB+yGxt0TdUcz9ot/CtkCVS3U7uXUVuJzl411H92VJVHgX5Rp/886ryUZT/PsiB gQd7V/FtK+Vvj/4hoKrfRyGzd6kwmlZTJjrmMwSym6qRNUFZQiHrVY2MzrU52qHCmFyNzAVZVMcK I6gaGR0nS/Yiq5HNprN0IAut5vqOgmwEZAvp+gyuen1mkj+Q08bHwMSq8mWUv+v/197VgEdRnevZ bLL8GH4UBISgW8AVFCEKLFEBA4SFaIAgcY2CEgQW0AgIIQbBNiqNtFIbrzT1hypVG7GmmipNodKa akxj5V7Syo200hpLumKLXqy4YsXM/d4574TdnTM29vbX6z5P8u477/n7vnPOzJkz58zKdRP69U69 XvTDomMHRupNTv/60wyjeILeTxNEWyXaGRoNv95d4qKViFY2wWkvtErRNrtoNaJtE+1cjYZfkN8h 2ikarU20nROc7dfabiZfdos2QqNlyJdml3hZ8mWfaIM1WoF82S9aUKOtki/HXezbLF96T9Rr2+XL MBetQb5kidZTo7XKl5Gidddox+WLf6K+nAO6yHndJb+xohW6aPmiFbtoxaKVT9T3gU2iPeoS71HR dk7Ut6V60Xa7aAdEqxdtlkbDbxgeFW2qRuvbVfr/pHYzpNEyRZsv2kSNlida+SS9DctE2+KibRRt +yS9DdtEqxEtM0lDm9wgWr1o98j31DcvdtoPXc6duTr7RTsqWj+d/d1EF+10nf2iHRdtmM5+0Zon 6a8hy0Tb56JtFG2/i7ZNtAMu2m7RWl20/aK1iRbWaEdFG36xU4NPm0UrFu0K+PSVSU77pSPViH69 zn50smz99WaZaKnZLvaL1tUl3jbR0jWaVf+i9RYNP7aRerGzrAdELxJ9qK7+RSsR7WRd/Z8k5+ds Z3tEnkck3gbRcpDnwYnO/i9xa0QfpUm3WLT6bP15apNoO1z886hoO13KWi/a7mz9OeyAaK2iBXT2 i3bUJb++6aJnO8+Zlv0S73A228dHE5z2S9yRk/Xto1i08sn6et4k2sbJLvaLtsklXr1omzUayro1 HRvG2D6WOst6XPTWyfr2MUDGiUcn630+VrRjk/Xto7doxyezfZzkzHOV6COn6NvHZtHwzjTdeXC7 aDkuWoNoM6bofdcqWp5LvOOi5bvEGyCNtGCKi/2iFU7Rt7l80TZM0be5YtEqXfLbJNqWKfo2t1i0 TVPY5vZe6LRf9KYp+jbXKlrGVH3bOS6af6qL/TKIHeYSb6xowzWaVf+ijZzKNneRs6yrRN8wVd/m NotWOVXv8+2ibZmqb3MbRbt3Ktvc6xc4x3+iN03Vtzmjt5wnNOla4z/RWl20LNHaXHxXINohF22V aIddbNws2pGp+na1XbS+Ofp21SDa8ByX9i/ayByX8Z9oftGu1NW/FHCxS5pjRVum0az6F604h231 +iyn/aLX5Ojb6mY4ZZq+zW0XLXWavjwNonV1idcqWrpGQ1l3i9Z7Gtvqq+Od9S83E0XT9G01S7SS afp6LMAam2n6tpop2oZpbKvrnXlWil4zTd9Wa0Sr16Rr3f+I1uCS56OiNYlWjDzPcOaZijU6oRNz MQn3f6KNDDntRLrHJd1M0Qqtfhd0xJ0vcVeF9P4rE21jSD/G3oK1QSF9XdeKtltTHmh7RKsX7XyN dki0NtEma7TUvoLT9fn5RcuYru+TE0TLnq7vk4WiFbikWSJa4XR9n6wULc8lXo1o+dP1tjcxP105 27BWyqWchnSMzS75ZYhWqSkn6v6YpInfqFoJ/3001qEPkLj7RL8Z+ntjnfUv+tgZ7eYQXf1j7dYM l/oXLU+0fF39i1Y+Q38eOCQHN4rWV2NLA9a4ifYUyrrSWdZhWDuW6zL/J1qGizZfNH+u3sYy0cbm 6vsG1qLNyNX3c6xPy8vV1zPWrK1yKQvWsZW4aFjbVparb1dY77bBRcMauPJcfTvGujjkpzuPYa3c Jhf7sH5uc66+D2NNXa2LDVhnt8MlTay92+kSD/92u9iHNXr4jWxdv8G6vX0utmMtX5NoBRoN6/vS L2k3z9S0wzzR/FhLiTrpc77TfvlXeYmL/fJvyyX6ttY2QK3N1LUZ4zRpNy5pZojW7KJlibbvEpfr 32lqDajON6uYn86nm0VrdYm3nflpr//MTzv+Ee2AS5rHXexDXexnftY185lM5/lP9GGXcpzzRKaz /Q+U8dOl+nFOyUC19lV3nqoUDb9JrD3/i1bvEq9JtAaNZl3/B+LZIcc5/Z1lTcWazjz9ucgv2sg8 l/4vWmaefswxQLSxeRznPDvaef4TfXGe/vywRbQyTbrW+U+0DS7ankF4qavL+U8ObnSxIzVDrTnW 9Q+/aDV5+vY6QbR6l/wKRWvI07e7EqxhzdOPtypF26MpJ3yKtbHNeRxvfWmU037Re8/U1+Mh0YbN 1I+3UgdLeWe6jH9Emz/Tpf5FK3KJVyja4pku8/9YgztTPxarFG2rS5o1om2bqa+nJtEaZurrqW2w WkOuPf+fLueHmfoxzgGJ1zyT54CzznXaL3H9s/T1WCja2Fn6esQa46xZrMc3Rzrbv+hls/T1WCva 5ln6etwjWv0sl/YvWoOmPFb9Y42ySzy/aHtm6etxghxsnqWvx0LRUme7jH+xBnq2vh4rRRs5W1+P NaJlu6TZJFrObH1/axMtyyWe4Rc7XLQMv3t+WJeN/NZqNKzV3j5b/zwvU7Tdszlu9p7j0PNFT8/n uPmjs531L3pxvv46j9+XKM93qX/RNubrx82pWPudr7+u+EXDb6Lqxs3HJc36fI6bb3KWdb7EzZ+j L0+ZaAUu2hasUZ+jt7FWtOI5+r6xR7TyOfq2eki0jXP0bS5VMtruUha/aDUu2gTRaufo+1ShaDtc tJIhag+K9v6P+Wnv/0Wrd7GvSbQGl3JiDX6Ti4Z1+Xtcyom1+s1zXMa/orW52IA1/fvnuIx/Rcu4 zGX8K1rmZRz/zh3utF/0bZfp2wX2Cey4zMV+7B1w0bAYZvdlLud/iVd7Gfvq/5zlbP9ohHPZV988 y9n+Je2iuS73f6KVzHVp/9irMFffV7GfoWauvq/uEa12rr6vbhdtx1z21UXOsmI/RE6By/oP7Hlw 0bBvIq9AbyP2UhQVuMz/iFZSoG/L2HNRVqDvq9iHsdWlLNibsc1Fw36NRwtcrn8BtVdLe/8rWk2B vp1jrwfy0/VV7P/Y4WIf9oTsLNDf42KfyAEXG2pEa3VJs0m0Npd4bQG1B01nnyFN4XCBvo9nYGBz ud72LNGOFuj7eIFoWZfr+3imaHmXs493OdNpv+i7L9e3pxrRmi93uf6Lts9FaztL7anT9fF60fZc zj7+yDCH3ip6Rph9/IFhzvYvp6kNYZf2L1pl2OX6J9qWsL6PY29OU1jfx7FfZ09Y38c3i9YcZh/v 7yzrYdGLrnBZ/zZCxusu2rARak+hzsZs0TZcoe/j80WrvELfXstE23KFvo9vGaH2Lmrn/0Tb7aLt Ea3+Cn07PyRag4uWKkOXpiv07Rz7lpCfro9jL1Ozi33Y37TvCn0fx56nYy42YB/UcZdyYm+UUajv q9gv1bfQZfx7ttoDquur2FeVV6jvqwckXlEh++p7X3DaL3GbC/XtolC0tkKX8b9oh1y0StEOu9iB PV2thS7z38xPp7UxP11dGHL7lX6lfq1fhmjZLlqWaCUuWoFo2120VaIdEG2kRtssB4+I9l2Ntl20 jVfp4zWMVHtwdetFW0WruUqf5nHYN0+f5gC53S2Yp09zrGjL5unTzBctY//H5klJGl4aVixa6zzW LcOXy7ED8048g8zpmWktBUb4raL557eb/Rkex7CPbqQcGxh3rEGOZcmxrnHH9suxsXIsNS6vw3Is U4693JFXdkdeXaWDt8WFx7EMOdaalG6mHDswn2tYeCwHe/XkWHrcsUI5ti/umB9NTY41yzG8ST11 7+n2WurpPcu91mJqxKuUMFuvaTd/wTJa83ej1J7lChxLWn9t2Y/8FyT6dT/yX6D361HsJSxK9GvX 0XKeL0r0a4YcyyxKsl+OjSxK9GsO9hAW6f1aJNqBokS/Yi/i/qR0N8mxfUWJft0qx5qLEv2KfYt7 ihL9unG02pNt+fWRwVq/Yn/jlmsT/XpcjhUtajcfcPFrRqbU/6JEv2bKsQOL9H7NE82/OLG8RXIs I+lYiRwbsDjJfjnWd3Gin7bKsd5yLBsHcnr6Lfvl2ITFHBswXAP2Zialt1+O5SxO9OdhOZadVBbj PJVevD/3YQ/nYvrzSxlaf2ZJvNRIoj/z5FizHJvv4s9i0XsvTer/cix9qUv/Fy1ftB7x9S/H8pKO NcixGUuT7JdjOUtP+BPlOyzHsuXY3hPlQ1PtKF+6XCCOLE2sA78cO5yU9ljsQV2a6NsZcqxtaaJv sUe1dWmibzPl2IGl9O3sQVrfYi/r9uXtZjN9gmPb5dji6xLT3y3Hiq7jGk4ew77XYjnWJe5YG/bA XscxI48dk2Ml13GtOo+lj5HrkxzrHW//GJVe97hjY8eo9LrxGNamzhijyveEV5XZsVdlVeIeEGv9 osRpvUFsOrFvBO0l9S4JgTS3it68ot087pZmvjPNZomzdbV7mkdE37zm05VzGPbu3uSeZo7ox276 dOUskzgN693TvFf0HRvknPopyrlH4uSXt5seTZpYr3tY9Oxb283nE/bp2Ht+VEpIp+84tcdaVzbr +i/6/tvbzdfZPu3zPcqdL9rWjTImTO28LzZKnHs3ufviUe51/uqn8MV+idO2We8LpHlM9H1fazfr PkWdjZSblaK7280UTZroW3miZ+79OGFPk7X/K6j2Fs/FXq4nBiTmZ+3/ysf+Lzsrtf9L4jz6kZxj 5MSTesdpujJO77ktJaGQyKtS4o3c0m5G07DXbKAmr22e+MwwR90gcWZ4TfMqnJPuGJTYNlA4hkbY IxJ2933t5p+w3+dZR9hVdljYkDFe2kOqaZ6PvTt3ZOhtOOLcw1aAPeYPyj0X8vhmRpyvuYdNwiH9 DRIus4tpFsKvlw7W12NRYj0i/R3Y0/4w05832DX9A0i/G9PvdXqn0ke8vllqb7APdXCGS7ykvXuI lyfx/CeZ5grk93rn8oM9G7PUHuDzYc/B07X2oO6w1772yXbzAsuvZyTXXZFdd0hzv4RN7WGa+9Am pvsT9hFmch8hymxcIP396XYzH2mO93eqf6KdZkm8HXXtZgjxXvNr2ukqR58oljjNP5L7WMS5/Qud ygvxHsW7BH7CeGcN6XS8AxLP/wJte7nz8friXQI/Y7yVQzsVDz7Pk3j5L7Nd9hmmrUech/COghlS N/gdnhP1oioFvt2C/Pe2m3OQzmPD/qJvkSbeb7D4Ff09BtrOIUlzn+gxpDn6TNd+j7B98e6D/e3m NIT9yBG2o52hrHiPwp4Dci1BX3kioClrZcL5Cv4tkThlv2s3v4w468/S+7cysX9Z7V/iNb/Jc9dF wz/RhgETJJ900/R6jMT9sdN71nvsDbKG8g3e6VB2mL55zT1dlD1Twua9227eZNXNiE63qWUS76iU J/9KnOvO1p9L69MdNm+TeOkR01xn9eNxrud21EX6RLm+LTXN1wztNdGxj9eqP4mTvsw0czp5HYUt Y/FOiutNs85q5+M6dX5EG8U7LGpXmuZ9HmcbRbqbRc+80TR7wtYFLunmO21owLs0VpvmRGtMPk6z Pzs7YX82+irek9F3jWnGDMN1/zTK5JdwhyVcD6S9pvNlKpR4DSUs06LOlWmPxGle+8llsq5/eOdH qWk+iOvMHePiziHTe9Z6b+8Id0DC+dcx3BP6cNb9P97hsd40l3SMB/3WeBDzSn7RDos22Id1VOOS +1KtL64vWeNHCX/gVtPEvt/UD3R2q/OBbTjibJQ4Xb9smng9e2r/YKfGV3jfyD6J8wzaYK9gp6/R RyTe/K+a5hqr7WrjTe/Z7E2I58d5IluuQ3eZ5pWoz6FBx/0n7MA7TVq/bprj4KuLgg7bpYP7km0v lziHv2GaE+Cv9c44lhFxcWDDDolz7F7TXIiyPOBie22i7ajnkZMlz/tN84akerbuf0XbKFqaoT7W +E+Olcux7shnpUs+mrZfMBnvkjHN9VY/1tnkbPtNEufRrZ/c9q37Pwm34VumeUh/jtOer9okTtaD Ui/W+aHzdsyfIufHh8xOvxcB57hKiZP+bVM9F0m6tqMsq0QfKbq1X/4cbVkc6eLe5JDEa3j+Y8f7 FswH6srLDa81lLuPx6wvmFTA4Mx4Sgh2VWM0YfxUyGv8qTKJ+5REtVIsto/hC+YoMGb24CUPhygY Hkd+l9sSvmDifg7C4AdQMHscBnlV/v5sBzMfaEFcazuv3z6IL2k8eXjwFGOQrWRTsd6vOoMEWXlm stEmlKspxftiyhz5imnRk1GCMlSB/J0B0lfCDRIXXAyyIE0FmwmyPk2Vfh7I3WnWkjJjOUg36ciY UP0GyHCfCvYIyCSfarbfB3mWwQ6C/JrkXZDLuyjSHy4t6aISOBPkq11UAmNAunRVwZaABIRgV/oa kPup3Aeyq6u13N94DOT2bkr5T5CHu6mkXwPZ2c16Kmy8BXJzdxVsECbc7uuugo0Aeaq7KsF4kFeE /NBuPuYD/30bKuqX1oFC29GF9K3lzhJ4T/7OBRlC31ruvIG+tdz5FfrWcudD9O1NIP3pJ8udQfrW cmceffscyEvx7jxEYj2dWETfWu68jb613HkvfTsZ5FR60HLnWPr2VpDtVCx3/oy+/QHI3fSt5c5a +tZyZyN9+wHIJvrWcudj9K3lzh/Tt9NA3uiuXu1B334gnl2bQ19+C8OuIkM1Z2tOK0bFmjg6xaOU X4HgtwihfAhynEoX9Oo0ryrIWSB420cfwXEg44UMP9HfR6jenmdXKb6gK28FKUd4468Km2DT+ylx NnnjbRoab9N5INtp0xyQBioLQK5OUTZ9CWRDirLpayC4ZjhtCtmlwRecQ9aB4PUsYxw25dtH8hn2 dpDrtWGL7CP4grdofM1g4qMdYa+2j+ALzlalINcmht0tZ0/Ygtln3K158IhupK2jT/WwlasM6/5c fezz3KneHrjQoAFOwOG442hyeJg9L+k4mjwmiscnHf+spoPKQEOapQmP9CdqwmMy/ML44w/jFDgQ V06sjcCYySPDWaPj3eB2ONZ9rn08lwXCG1+sfuJsJwntrxtTN65MDPsJdvyt/PRJ/vis+O/zcnWy XAx7un0EX/C70LOQ8ffkb6LjnPuvEHaUHRZfcOV5GgSjyfdO2PZ/GbP+NWPkT1O2v+eYeHOK9wMP nIiLzTYEx4UG1xe8TyoN1xY0uFqQS+Xf/XYCv2emezxM7kSVeFQcS8n0qOuy9ZnqUXEugqXXeNTl 2/qUMY6l4HfbcDdajQQe9ygTLoUrXySxkt4brxwisRJ4W8gcO+lJKXHBpqYk+CDlFu8tRXl+Y3Ge n/549jbDuzNlqXzH89U++IfFUTifDgJ51OBABeRXVH4L8r78Yf3RW1gMk+tRSgzKEiHoqDeC4Aft cT3PBHmVg5sskHTek0VBhgjBG6s+RGrX8daxHQru99ApvwjyixTl0Wkgh3knOBNkkFel9g4IRlJo YT6Q5VR8eOKNwRNq/E4o73hVO2jHIApz1GjxF2GU+LVU1SiuQLBvp+J3s+TuF+RxIUu89Kj5QPVt 0lbvTplkKKdbdfScoTKMSLC0X8sXPGpeC/IOletBunmUchvIYI9SVoFkUfk6yBQh37Wr8DDbTQ0K 2e5RhdwBclKKIrtABgiZbcdZytvdP0NZx2ApaXQtSBeQl1kdk0HeoJIL8g7JLJCPhDzYcVudpi59 vxX0tKQ52trRXL9xLNdua1d7rXcKdozfLqA3HgPByM66CQPZYKi62AGChwJw/y6QuxnHCoaIz9ip mQ/86Vapi994gqyLDNTFGkMZj06a9mXmEQD5D/nSaEcu9Khz307U7HL6FW/iM0pJXgS53RM3/N/L uvDBr28wWE+Qd0j8IOfRr31AptOVuDc0CkiuAlkoJMf263dSlV//IOj5XarDr1tn+I1tM2y/viBm T8bXZ+zzMb7AZb1R6O/yhLADqb+SohTrLuQ1IVec8N9+j/cFzzmGumGogRdvRCntAC/SlUeRzqt0 5XGQNhIPEn3XiPPRRPpoCpTZdMslIPNJZoM8xNb/FZAfULkb5HmSKq/tcdtHb3iVjwLw0elOH5VN 9xsbpif46BVDGX8B0vg5z6B4HmgcJBkJ5WOSMEiK/At/Vn1UEPIbhaG/tY/YD7MNXrMR9BY65nwQ DGBwkbwQ5GHkY0cuZj/cA1NuoV37QL5KYt34fzO+Hx6k/waiG73PYNZqjRR2sLEg09gPrSmBeVRG gywjWQGyNr4f7mI/bIf/Yk7/9Z3mNwZMs/2nxlQH6cA5SOTXdFMbHOhNUZcbK/mTU+LujuPa1SUG Rx/Yh9fRrl6i+44hKp5mWavF4IpDJJjxsK7JHX6ZTL+EoMylX2ZZ0yskc0EeYbuyZhJ2UfkGSCPJ /SCvxLer37NdnQ2/DHH65fhU8UmO7RfLttFsDT8GYuD5sB2lxVB1biL1N2lOF+R5lCQdxBNf5zNp 20woC1jOy0GKSZaCPEXbrgJ5kcq1IL8k+TbI6yC2bYdp23mwbYTTNr/YNmyqbZvcu/ShZUM9cfcu ls0XsgqxPC/tLkNd5KzPIdrcD9l/SDNPB/GxYNbMUJ94mxfQ5sVQbmSwYpAvktwI8lPabM2dvUrl GZA2Eusi9258fXrZzmfA5mynzSOn+I3MKQn1iRssFA0tMw2zRQvsKL8zVDnT46uwr12FIKeB9Iy3 7SradlV8FVoVtS6+PnfTtm/HV+HjHVUo+CTI4fj6/JD1OQm2BZ225U/2GwWTE2xDvWFuF+dCa5zQ UW+HWW8Dkc3HtG0ISHcW4CyQ/vG2LaJty6CsZTCM84zbSNbazdMa2VhXZio/tLo4yW6ri8fXWxfW G97T68lx2laS7TfKsj+btt17sd/YerHDts9Ef9s9yW/UT/ps2tY60W+0TUyw7TMznkoVu7om2obz JG7F9sE2zGEvtaO8Tdv6IxuT5pwBks4C4MGFcVp8vS2hbdYd6E0MdgPIRpLVID+jbTUgv6GyA+QP JLtAPog/T6ay3nJh22SnbcMn+I2RE2zbku61/J64ey08/ErbbKh72LNBqoy4e635HONZXf4GlqcB 5GaSl0DuiLf7FdrdHUO03zPYKSB/sn0FMo5jvP4gl3JYdwZIIck1IEvix3iP0+53YHfUaXfmRX5j 7EUJdYpZKNw3NcB63J52DH5/YyjbToIF77BO+4B8RDIApGu8bQW07UooEZqzEGQNCSYSrIkU2LYN ZA+V7SC/IvkeSDS+vR5je50I28Zpxv8Xyvj/Qts281bD+wfPxaxSzEal3c0qfRLkEZJaEIzjMIO+ EwSzheM8dtKcb8BNrNGHfv8eiJ/kaZBz4+coNjDOe1DuYrCPQB4g6YEytbJ+rQLGqHQFwf0syHQQ 3PbeZvvgPzhH8SrmKPY65yjyL5Dr/wW2D9iupzCPWrv1onABSTbtKdp9DshPDDWOsT577DEMiv1b 1gl+RcD4I8likGPxdZ9Du++HEqZBD4MsInkFpJp2Pwaym8pTIC+RdENpW4S8ZxfnpVR1Qr0Fdq91 2l2Y5TfmZyXZ/f9g7qRovN9YPN7F7s/weWxZ0G8UB227rfMYzmGYTMfT6DTMud1jR+lF2yZ66RTk OQ3k3PgL6oXxtlXQtjuh3Mtg94B8h+Ree8QH234JYk9h/hrEnsJ8HQRTmB3nsbNp20rYttRp2+Zx fqNynG3bU1WGt8Y6TQyzg+ELZpTfwwPCbEMlgJddWw9+kOl4pH8zg10MUsVg00FeYLDbQZoZ7E4Q DJvxGPAea2BAe/aCjPGoYK+CYCCCYK+DfIXBBmHeuIrBhoI87VFPCc4Becu+9wGJMdhKkFO4FuAm kFz67RmQMOfOnwVZnaIyfQGkhsFMkF0M1gWn+/9msF4gvXgmvRQkw6uCzQXJ8iqHzANZwmDfBFnN YA+B3OVVqT0G0sRgB618GOyPIO96lQnvgQznfPto1A0uVAg2HmQOa/tikC8y2HqQOxnsdpDHGOxO kH0M9jOQNxhsL8jHQqajSkAWpvH6PFn+rUhT0zaDQG6mcg7IHVTGgNxDZSrItjSV9KUgu0nmguxP U4905oFk+tRs9jdBFvlUA3wc5BGfemRtfV73qQdY3fCY4awucQoW9uChxRYoX++i2o/1GdBNJW0p Q4UE7Di53VSp25BKpBsf3CDTr3RTrjoIUh8f7DcMFsDl70MGOwcEPxLQEWxmdxVsBZTl3VWwNSDb 4oP9mMHqoPyKwZ4F6X1SXDCsl7Ie9kDJPYmLZKbKv/L4YN9isBCUXQx2KciR+GA90lWwu6CMSFfB 7gEpSo8LdguDtUC5j8FeA2mOD/Y2g52eg3rpoYINBcnuERfs6h4qWATKOga7HqQ2Pth/MtiTUN5i sGdA/D3jgk3syWdpUK7syXMVSGV8sO8x2CQ8+XyJwaaCfBgfLK2XClYB5Qu92EtA5vSKN4HB/gvK OgZ7BeTx+GA/YLB+uF37BYMNAkntHResT28V7Booo3urYItAFsg3rNK1gtWfrIJVQzl4Mtd8gZxy ilLeARl1ilLeA7maShDdeB2Vi0C2U/kiSAOV20Heo9II0quPUl4GmdRHKT3R8a6i0gfkK1TCIN+h Mg9kH5UHQY5QeQTkjL5KiYJc1FcpfwRZT2UU1iY8TJIF8tO+6lHyxSCDT1VKFUgOyTaQRaeqYI+B PEelHSRK0hUzx2n9VLBeIAv7sVmCbCJZBfIYg90E4u3Pqgc5m2Q/SG5/Fex1kO9QCeKx+B6SbJA/ Mth0kOkD6B2QFSTbQb42QAV7CuQtKj4MH3qfxletg4w+TQXrD3InlRUgT5OUgfyCwb4Ecu5AdmeQ ApJWkDUDVbA3QfZSmTRT/sVIZoCcOkgFmw1y4yA2S5B7SWpBfshgPwRJz1DK70CGZ6jBz2GQuVTa QVZmqHWUXbGi4VtUBoLsojIM5E0qQRDvYKVkg5w3WCmXgcykMh9kPZUVIN+kUgbyIpWvgrxBZQsI dv1ZxoGcc7pSakGupPI8yFoqe0AeofJbkOeo4HcVjbep/Bmk2xlKScVt3fgzeKYAmUsFv8Fo3Erl fJBvUZkA8jKVWSBvUikEOdWvlOtAzvMrpQRkAZUKkPVUKkEep/IwyItU8GuPxntUfgLS6wtKaQKZ +AUO2UCupPJbkDuovA3yCJWjIL+g4sVaorepdLcWUg5Rymkg44fQByBLhqhB8GiQ9UNU2wmCPELl XpBdQ9Tiie/jUn2EykNQfEOVgl9tNSYOVUo1lLlU9kIpGaoq2fo8NFnd5FhDD/zsa439voyOZ/MJ S5uRpHW3g7WdGPT8FwjeLYEhByaQjWpDnfX3g9QyjhUMEeOezT90q+Hdao1aovbYJcobgRJrilmG oPgFumYM+atSVBbzcJPz7RR1A4bfjTOeSVHjKisYVixcameB2U+kditSy+Wo05rbC3tVGTEuNa5h MOseAzlPsYtjrzcbTGMxeerB+4na7Cw8DHeL13pHZsdq3/H0yJMIg1FMma38yFAe/ymUBhLMBHnw 2KTj0bt11yl4JnIYToL5FA/uthxrmBLLmWaX8+C/Wjlz1aqEhDVfuJLgFy2NW1l81LUH61sG2Mrz 8nfA83dM64jhxYujjaCdGL5gytl6tlzFxN4S4kEr7mUrbxhqvdEb1rMKQy15e9eez4P5MevOFY5J S8qzmSva3rDzxBdEeTGFUdD/ykEw64c8rcUb+OXQU20Fa8N+eKK9ck3duXaS+IJ1V98HudaIW7wW v97Pekxuf0EjmoADIZJl1txTatwKybj1JT+2j+HLfPmLIDRWueFC9wMUEb8Q27G0f36qaiJWsPgy dMwz3EP/WptSH6bnrRk1zLN1LHs6UWdZ9iF8QZ29bc02MObHqLMmpmkp6Lyw630Q+/ljGsrTj3Vm TcXgvr1Xp+sMpyRjkEet/sdvolp398gTS9KsX3Q91Va+nFhnJ3xQZKeKL+i/fW0f4OyNBzTWpMOD J3yQ2O9T7H7faof4W/f7b9jBrmFXx9M+a4YaBM3Uc72u3x+UYs6zi9lusJhb7WDoUzihWydYTKV0 bFTox6SxGK7jZINTi+dMXT6nensMYC5oLR7by59/Pv98/vn88/nn3/mT/XN1Pq8l1hOPEE1+7PDJ 3P40pyUf+ed+ylmeWpfyJn9a2zsXzv5k/jkxvM2Tj/+l+J823r/q59+9/v/d6/Mf7f9/tJ3l/6T2 VU77yv/N++df80lx+Y6P99Df1x/5fznI3/Rjnyc6e774R3zi77S8+z99uf6Z9feP+tg+WpvEy5P4 sx8k8p8n8X1J/HdJ/E/k9ntU91crpQf5gO96LTyNvGuOWhVh76D0E99XPxlgHGHC9mmtnrsUfORl fFGv/f7UsmMKT7LzI3qJRr7Kz67nprEK7Xe32u917Xh382pPwvHeVytuv6/WYP72u1rt/GSYZJU/ e37H+NDi9nTXEfKssNI/JP8XGx78v/805Q3THu/3mKq3ADFIDBHDxAixlFhBrCJWE+uIjcQWYpQY I/q2K+xHDBCDxBAxTIwQS4kVxCpiNbGO2EhsIUaJMaLvceZPDBCDxBAxTIwQS4kVxCpiNbGO2Ehs IUaJMaLvu8yfGCAGiSFimBghlhIriFXEamIdsZHYQowSY0TfE8yfGCAGiSFimBghlhIriFXEamId sZHYQowSY0RfDfMnBohBYogYJkaIpcQKYhWxmlhHbCS2EKPEGNH3PeZPDBCDxBAxTIwQS4kVxCpi NbGO2EhsIUaJMaLvSeZPDBCDxBAxTIwQS4kVxCpiNbGO2EhsIUaJMaLvKeZPDBCDxBAxTIwQS4kV xCpiNbGO2EhsIUaJMaKvlvkTA8QgMUQMEyPEUmIFsYpYTawjNhJbiFFijOj7PvMnBohBYogYJkaI pcQKYhWxmlhHbCS2EKPEGNH3NPMnBohBYogYJkaIpcQKYhWxmlhHbCS2EKPEGNHHXc39iAFikBgi hokRYimxglhFrCbWERuJLcQoMUb07WD+xAAxSAwRw8QIsZRYQawiVhPriI3EFmKUGCP6fsD8iQFi kBgihokRYimxglhFrCbWERuJLcQoMUb01TF/YoAYJIaIYWKEWEqsIFYRq4l1xEZiCzFKjBF9fHrW jxggBokhYpgYIZYSK4hVxGpiHbGR2EKMEmNE307mTwwQg8QQMUyMEEuJFcQqYjWxjthIbCFGiTGi bxfzJwaIQWKIGCZGiKXECmIVsZpYR2wkthCjxBjR9yPmTwwQg8QQMUyMEEuJFcQqYjWxjthIbCFG iTGi71nmTwwQg8QQMUyMEEuJFcQqYjWxjthIbCFGiTGibzfzJwaIQWKIGCZGiKXECmIVsZpYR2wk thCjxBjR92PmTwwQg8QQMUyMEEuJFcQqYjWxjthIbCFGiTGi7yfMnxggBokhYpgYIZYSK4hVxGpi HbGR2EKMEmNE33PMnxggBokhYpgYIZYSK4hVxGpiHbGR2EKMEmNEXz3zJwaIQWKIGCZGiKXECmIV sZpYR2wkthCjxBjR91PmTwwQg8QQMUyMEEuJFcQqYjWxjthIbCFGiTGi73nmTwwQg8QQMUyMEEuJ FcQqYjWxjthIbCFGiTGi7wXmTwwQg8QQMUyMEEuJFcQqYjWxjthIbCFGiTGir4H5EwPEIDFEDBMj xFJiBbGKWE2sIzYSW4hRYozoe5H5EwPEIDFEDBMjxFJiBbGKWE2sIzYSW4hRYozoa2T+xAAxSAwR w8QIsZRYQawiVhPriI3EFmKUGCP6fsb8iQFikBgihokRYimxglhFrCbWERuJLcQoMUb0NTF/YoAY JIaIYWKEWEqsIFYRq4l1xEZiCzFKjBF9LzF/YoAYJIaIYWKEWEqsIFYRq4l1xEZiCzFKjBF9fN7a jxggBu3nswv18zX2Z/rUqRf6h0+fdfkI/9hRF4w631hUvHDFUn/pktVrlq9c4R8zavyoTP/wa1cv XLFo2ZI1o1cvKV6ycM2SBWPG+88fd15wzAUjDGPUmmVrSlaXLLzWGLViZcmSUUtXrB117drlxYvP Xb7YsNiyhWuWGaMWr1uxZt0NCktWK4X5JJAFokk+CxGQ31YVlxijlq9YLv9LlpTJ/4gQ0VYuXliy 0Bi1ZNmCyOqFNyxZsGzx6hNMEl20aMGSskVLVpUskOIVL1FpLFi4evXCdcaoRSUrV6+R4ii4bpFE RXLIUVK2yrnwhuWLJJmVJdY/VQyV5bVrJM6ilTfcsGRFySc6uJMfzM9iTrVjHtaTiMm1mJrEsYo4 Zpor7fj2PLGNm/jaO3vet6uR+BnOMtjx7XlkG2fMOJGvJy6+Pb+bybTt+Pa8tI32PLT98STljwWD Zlz57XlgG32+xPKnJCH2wrTHxbfnmW1sNk6UP9Vw2l/A43Z8e17bRnteO9l/tv3XMP4UOz7nyW20 59W9jJMcH8snEdKex7efE9j4l+p/UVJ8g/OjNmYPTQzfOwlXJMW313fY2PJ6Yo31NhI/JUnx7eca NvZMCp9c/psZ3/Z/JuPZ+I1uieGT878tKX7TM94ELDn5k/OvTIqf/aI3AY2pieGT28/9yfG7pibg ieXM+vyxFxw+6mhffA7UNUeF9CeF75qEO5m/HX844w9n/GR/JZf/uaT4WYyf1cn4jUnxZzD+DMZP Dp/MX06Kn8/4+YxflhQhuTzY4uCLi28/p2jKo6dZMbbf439fEZ83kvJvmsX4s1SMzKQTVrL/o0nx 7edqRr6KX5vU/pLj/09SfPu6Xbvwk+vf/rzPY3b8ZsZv7mT8PzP/zKTjdvwpScc9GvQazs8p16r4 3iT/JZ///xeNIIf4WGoEAA== #endif #ifdef PARAM PARAM(BITSTREAM_SIZE, 289368) #endif