From dda35386634dc070a28ffe9bafae929afa649c8b Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 27 Apr 2026 10:55:16 +0100 Subject: [PATCH 01/32] Add SNN work and ignore local notebook/test artifacts --- .gitignore | 5 + docs/advanced/snn.rst | 68 +++++ docs/frontend/pytorch.rst | 3 + docs/index.rst | 1 + .../backends/vivado/passes/snn_templates.py | 107 ++++++++ hls4ml/converters/pytorch/snn.py | 80 ++++++ hls4ml/model/layers.py | 51 ++++ hls4ml/templates/vivado/build_prj.tcl | 5 +- .../vivado/nnet_utils/nnet_if_neuron.h | 76 ++++++ .../vivado/nnet_utils/nnet_lif_neuron.h | 77 ++++++ .../vivado/nnet_utils/nnet_snn_common.h | 11 + .../vivado/nnet_utils/nnet_snn_readout.h | 248 ++++++++++++++++++ hls4ml/utils/torch.py | 1 + requirements-snn-dev.txt | 12 + test/pytest/test_extensions_pytorch_snn.py | 76 ++++++ test/pytest/test_snn_pytorch.py | 150 +++++++++++ 16 files changed, 970 insertions(+), 1 deletion(-) create mode 100644 docs/advanced/snn.rst create mode 100644 hls4ml/backends/vivado/passes/snn_templates.py create mode 100644 hls4ml/converters/pytorch/snn.py create mode 100644 hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h create mode 100644 hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h create mode 100644 hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h create mode 100644 hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h create mode 100644 requirements-snn-dev.txt create mode 100644 test/pytest/test_extensions_pytorch_snn.py create mode 100644 test/pytest/test_snn_pytorch.py diff --git a/.gitignore b/.gitignore index 8fb87927ce..83ed4bb462 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,8 @@ hls4mlprj_* *~ *.ipynb_checkpoints/ *.bak +.ipynb_checkpoints/ +.pytest_cache/ +*.ipynb +snn_test_lif/ +FPGAs_AdaptiveSoCs_Unified_2024.1_0522_2023_Lin64.bin diff --git a/docs/advanced/snn.rst b/docs/advanced/snn.rst new file mode 100644 index 0000000000..df9109c5e1 --- /dev/null +++ b/docs/advanced/snn.rst @@ -0,0 +1,68 @@ +======================================== +Spiking Neural Networks (PyTorch/SNN) +======================================== + +This page describes the initial SNN support in the PyTorch frontend. + +Execution model +=============== + +Current hls4ml SNN implementations are synchronous (clock-driven). Neuron state +updates and layer computations run in standard HLS pipelines/streams each cycle +according to interface handshakes. The generated design is not a native +asynchronous/event-routed neuromorphic architecture (yet!). + +Supported PyTorch modules +========================= + +The frontend currently supports direct parsing of: + +* ``Leaky`` -> ``LIFNeuron`` (or ``IFNeuron`` when ``beta`` is effectively 1) +* ``SNNReadout`` -> ``SNNReadout`` + +`snntorch` tracing +================== + +``snntorch`` modules are treated as leaf modules by the hls4ml PyTorch FX tracer. +This allows conversion models to use ``snntorch.Leaky`` directly without defining +conversion-only wrapper classes. + +For ``Leaky``, the supported reset mechanisms are: + +* ``subtract`` +* ``zero`` + +Only scalar ``threshold`` and scalar ``beta`` are currently supported. + +Readout and Decision Rules +========================== + +``SNNReadout`` implements programmable per-model decision policies: + +* ``argmax_spike_count`` +* ``first_to_threshold`` +* ``threshold_then_argmax`` +* ``binary_logit`` (for binary classifiers with ``n_classes == 2``) + +The layer accumulates class spikes over a window. For most decision rules it emits +a class ID. For ``binary_logit``, it emits a score equal to +``count(class_1) - count(class_0)``. + +Window Boundary Semantics +========================= + +The current implementation uses ``window_size`` timesteps as the sequence boundary. +At each boundary: + +* the class decision is emitted +* internal readout counters are reset for the next sequence + +This behavior is compatible with fixed-length time windows. + +``TLAST`` note +============== + +True AXI sideband ``TLAST`` boundary handling requires top-level writer/interface support for packetized AXI stream types. +The current implementation does not yet expose ``TLAST`` to layer kernels directly. + +For variable-length windows, a practical workaround is to keep the hls4ml core unchanged and perform ``TLAST`` to boundary conversion in a thin wrapper IP around the generated project. diff --git a/docs/frontend/pytorch.rst b/docs/frontend/pytorch.rst index 6e91d0c44e..3d1681bab3 100644 --- a/docs/frontend/pytorch.rst +++ b/docs/frontend/pytorch.rst @@ -18,3 +18,6 @@ of the model. If the ``io_parallel`` I/O type (see :ref:`Concepts`) is used, a t Outputs are not transposed back by default, but in ``io_parallel`` case, a transpose node can be added. If not needed, these adjustments can also be switched off. See :py:class:`~hls4ml.utils.config.config_from_pytorch_model` for details. The equivalent of Keras extension API is not yet available for PyTorch parser, and will be provided in the future. + +.. note:: + Experimental spiking layer support is available for selected modules. See :doc:`../advanced/snn` for details. diff --git a/docs/index.rst b/docs/index.rst index f170ca6858..35e79f75bb 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -51,6 +51,7 @@ advanced/precision advanced/fifo_depth advanced/extension + advanced/snn advanced/model_optimization advanced/bramfactor advanced/plugins diff --git a/hls4ml/backends/vivado/passes/snn_templates.py b/hls4ml/backends/vivado/passes/snn_templates.py new file mode 100644 index 0000000000..300d148bcf --- /dev/null +++ b/hls4ml/backends/vivado/passes/snn_templates.py @@ -0,0 +1,107 @@ +from hls4ml.backends.template import FunctionCallTemplate, LayerConfigTemplate +from hls4ml.model.layers import IFNeuron, LIFNeuron, SNNReadout + +if_config_template = """struct config{index} : nnet::if_neuron_config {{ + static const unsigned n_in = {n_in}; + static const unsigned n_out = {n_out}; + static const unsigned io_type = nnet::{iotype}; + static constexpr float threshold = {threshold}; + static const nnet::snn_reset_mode reset_mode = nnet::snn_reset_mode::{reset_mechanism}; +}};\n""" + +if_function_template = 'nnet::if_neuron<{input_t}, {output_t}, {config}>({input}, {output});' +if_include_list = ['nnet_utils/nnet_if_neuron.h'] + + +class IFNeuronConfigTemplate(LayerConfigTemplate): + def __init__(self): + super().__init__(IFNeuron) + self.template = if_config_template + + def format(self, node): + params = self._default_config_params(node) + return self.template.format(**params) + + +class IFNeuronFunctionTemplate(FunctionCallTemplate): + def __init__(self): + super().__init__(IFNeuron, include_header=if_include_list) + self.template = if_function_template + + def format(self, node): + params = self._default_function_params(node) + return self.template.format(**params) + + +lif_config_template = """struct config{index} : nnet::lif_neuron_config {{ + static const unsigned n_in = {n_in}; + static const unsigned n_out = {n_out}; + static const unsigned io_type = nnet::{iotype}; + static constexpr float threshold = {threshold}; + static constexpr float beta = {beta}; + static const nnet::snn_reset_mode reset_mode = nnet::snn_reset_mode::{reset_mechanism}; +}};\n""" + +lif_function_template = 'nnet::lif_neuron<{input_t}, {output_t}, {config}>({input}, {output});' +lif_include_list = ['nnet_utils/nnet_lif_neuron.h'] + + +class LIFNeuronConfigTemplate(LayerConfigTemplate): + def __init__(self): + super().__init__(LIFNeuron) + self.template = lif_config_template + + def format(self, node): + params = self._default_config_params(node) + return self.template.format(**params) + + +class LIFNeuronFunctionTemplate(FunctionCallTemplate): + def __init__(self): + super().__init__(LIFNeuron, include_header=lif_include_list) + self.template = lif_function_template + + def format(self, node): + params = self._default_function_params(node) + return self.template.format(**params) + + +readout_config_template = """struct config{index} : nnet::snn_readout_config {{ + static const unsigned n_classes = {n_classes}; + static const unsigned io_type = nnet::{iotype}; + static const unsigned window_size = {window_size}; + static const unsigned class_threshold = {class_threshold}; + static const nnet::snn_decision_rule decision_rule = nnet::snn_decision_rule::{decision_rule}; +}};\n""" + +readout_function_template = 'nnet::snn_readout<{input_t}, {output_t}, {config}>({input}, {output});' +readout_include_list = ['nnet_utils/nnet_snn_readout.h'] + + +class SNNReadoutConfigTemplate(LayerConfigTemplate): + def __init__(self): + super().__init__(SNNReadout) + self.template = readout_config_template + + def format(self, node): + params = self._default_config_params(node) + return self.template.format(**params) + + +class SNNReadoutFunctionTemplate(FunctionCallTemplate): + def __init__(self): + super().__init__(SNNReadout, include_header=readout_include_list) + self.template = readout_function_template + + def format(self, node): + params = self._default_function_params(node) + return self.template.format(**params) + + +def register_snn_templates(backend): + backend.register_template(IFNeuronConfigTemplate) + backend.register_template(IFNeuronFunctionTemplate) + backend.register_template(LIFNeuronConfigTemplate) + backend.register_template(LIFNeuronFunctionTemplate) + backend.register_template(SNNReadoutConfigTemplate) + backend.register_template(SNNReadoutFunctionTemplate) diff --git a/hls4ml/converters/pytorch/snn.py b/hls4ml/converters/pytorch/snn.py new file mode 100644 index 0000000000..b26293768b --- /dev/null +++ b/hls4ml/converters/pytorch/snn.py @@ -0,0 +1,80 @@ +import numpy as np + +from hls4ml.converters.pytorch_to_hls import pytorch_handler + +BETA_TO_IF_TOL = 1e-6 + + +def _to_scalar(value, name): + if value is None: + raise Exception(f'Missing SNN parameter: {name}') + + if hasattr(value, 'detach'): + value = value.detach().cpu().numpy() + + if isinstance(value, np.ndarray): + if value.size != 1: + raise Exception(f'Only scalar "{name}" is supported for SNN conversion, got shape {value.shape}') + return float(value.reshape(-1)[0]) + + try: + return float(value) + except (TypeError, ValueError) as err: + raise Exception(f'Could not parse "{name}" as scalar: {value}') from err + + +def _parse_reset_mechanism(class_object): + reset = getattr(class_object, 'reset_mechanism', 'subtract') + reset = str(reset).lower() + if reset not in ['subtract', 'zero']: + raise Exception(f'Unsupported reset mechanism "{reset}". Supported: "subtract", "zero".') + return reset + + +@pytorch_handler('Leaky') +def parse_lif_layer(operation, layer_name, input_names, input_shapes, node, class_object, data_reader, config): + assert operation == 'Leaky' + + beta = _to_scalar(getattr(class_object, 'beta', None), 'beta') + + layer = {} + layer['class_name'] = 'IFNeuron' if np.isclose(beta, 1.0, rtol=0.0, atol=BETA_TO_IF_TOL) else 'LIFNeuron' + layer['name'] = layer_name + layer['inputs'] = input_names + layer['n_in'] = input_shapes[0][-1] + layer['n_out'] = input_shapes[0][-1] + layer['threshold'] = _to_scalar(getattr(class_object, 'threshold', None), 'threshold') + if layer['class_name'] == 'LIFNeuron': + layer['beta'] = beta + layer['reset_mechanism'] = _parse_reset_mechanism(class_object) + + return layer, [shape for shape in input_shapes[0]] + + +@pytorch_handler('SNNReadout') +def parse_snn_readout_layer(operation, layer_name, input_names, input_shapes, node, class_object, data_reader, config): + assert operation == 'SNNReadout' + + layer = {} + layer['class_name'] = 'SNNReadout' + layer['name'] = layer_name + layer['inputs'] = input_names + + n_classes = getattr(class_object, 'n_classes', None) + if n_classes is None: + n_classes = input_shapes[0][-1] + layer['n_classes'] = int(n_classes) + layer['window_size'] = int(getattr(class_object, 'window_size', 1)) + layer['class_threshold'] = int(getattr(class_object, 'class_threshold', 1)) + layer['decision_rule'] = str(getattr(class_object, 'decision_rule', 'argmax_spike_count')) + if layer['decision_rule'] not in ['argmax_spike_count', 'first_to_threshold', 'threshold_then_argmax', 'binary_logit']: + raise Exception( + f'Unsupported SNN decision rule "{layer["decision_rule"]}". ' + 'Supported: argmax_spike_count, first_to_threshold, threshold_then_argmax, binary_logit.' + ) + if layer['decision_rule'] == 'binary_logit' and layer['n_classes'] != 2: + raise Exception('binary_logit decision rule requires n_classes == 2') + + output_shape = input_shapes[0][:] + output_shape[-1] = 1 + return layer, output_shape diff --git a/hls4ml/model/layers.py b/hls4ml/model/layers.py index 8bd8cd8a11..9d8509de7f 100644 --- a/hls4ml/model/layers.py +++ b/hls4ml/model/layers.py @@ -1037,6 +1037,54 @@ def initialize(self): super().initialize() +class IFNeuron(Layer): + _expected_attributes = [ + Attribute('n_in'), + Attribute('n_out'), + Attribute('threshold', value_type=float), + ChoiceAttribute('reset_mechanism', choices=['subtract', 'zero'], default='subtract', configurable=False), + ] + + def initialize(self): + shape = list(self.get_input_variable().shape) + shape[-1] = self.attributes['n_out'] + self.add_output_variable(shape) + + +class LIFNeuron(Layer): + _expected_attributes = [ + Attribute('n_in'), + Attribute('n_out'), + Attribute('threshold', value_type=float), + Attribute('beta', value_type=float), + ChoiceAttribute('reset_mechanism', choices=['subtract', 'zero'], default='subtract', configurable=False), + ] + + def initialize(self): + shape = list(self.get_input_variable().shape) + shape[-1] = self.attributes['n_out'] + self.add_output_variable(shape) + + +class SNNReadout(Layer): + _expected_attributes = [ + Attribute('n_classes', configurable=False), + Attribute('window_size', value_type=int, default=1, configurable=False), + Attribute('class_threshold', value_type=int, default=1, configurable=False), + ChoiceAttribute( + 'decision_rule', + choices=['argmax_spike_count', 'first_to_threshold', 'threshold_then_argmax', 'binary_logit'], + default='argmax_spike_count', + configurable=False, + ), + ] + + def initialize(self): + shape = list(self.get_input_variable().shape) + shape[-1] = 1 + self.add_output_variable(shape) + + class BatchNormOnnx(Layer): """ A transient layer formed from ONNX BatchNormalization that gets converted to @@ -1793,6 +1841,9 @@ def initialize(self): 'ELU': ParametrizedActivation, 'PReLU': PReLU, 'Softmax': Softmax, + 'IFNeuron': IFNeuron, + 'LIFNeuron': LIFNeuron, + 'SNNReadout': SNNReadout, 'TernaryTanh': TernaryTanh, 'HardActivation': HardActivation, 'Reshape': Reshape, diff --git a/hls4ml/templates/vivado/build_prj.tcl b/hls4ml/templates/vivado/build_prj.tcl index 888c5f4c95..5b27df0422 100644 --- a/hls4ml/templates/vivado/build_prj.tcl +++ b/hls4ml/templates/vivado/build_prj.tcl @@ -161,7 +161,10 @@ if {$opt(reset)} { } else { open_solution "solution1" } -catch {config_array_partition -maximum_size $maximum_size} +if {[catch {config_array_partition -maximum_size $maximum_size}]} { + # Vitis HLS 2024.1 removed -maximum_size; use complete threshold when available. + catch {config_array_partition -complete_threshold $maximum_size} +} config_compile -name_max_length 80 set_part $part config_schedule -enable_dsp_full_reg=false diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h b/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h new file mode 100644 index 0000000000..435592b5d3 --- /dev/null +++ b/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h @@ -0,0 +1,76 @@ +#ifndef NNET_IF_NEURON_H_ +#define NNET_IF_NEURON_H_ + +#include "hls_stream.h" +#include "nnet_common.h" +#include "nnet_snn_common.h" + +namespace nnet { + +struct if_neuron_config { + static const unsigned n_in = 1; + static const unsigned n_out = 1; + static const unsigned io_type = io_parallel; + static constexpr float threshold = 1.0; + static const snn_reset_mode reset_mode = snn_reset_mode::subtract; +}; + +template +void if_neuron(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out]) { + #pragma HLS PIPELINE II=1 + + static data_T mem[CONFIG_T::n_out]; + #pragma HLS ARRAY_PARTITION variable=mem complete + + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + data_T v = mem[i] + data[i]; + bool spike = (v >= (data_T)CONFIG_T::threshold); + if (spike) { + if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { + v = v - (data_T)CONFIG_T::threshold; + } else { + v = 0; + } + res[i] = 1; + } else { + res[i] = 0; + } + mem[i] = v; + } +} + +template +void if_neuron(hls::stream &data_stream, hls::stream &res_stream) { + #pragma HLS PIPELINE II=1 + + static typename data_T::value_type mem[CONFIG_T::n_out]; + #pragma HLS ARRAY_PARTITION variable=mem complete + + data_T in_pack = data_stream.read(); + res_T out_pack; + PRAGMA_DATA_PACK(out_pack) + + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + typename data_T::value_type v = mem[i] + in_pack[i]; + bool spike = (v >= (typename data_T::value_type)CONFIG_T::threshold); + if (spike) { + if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { + v = v - (typename data_T::value_type)CONFIG_T::threshold; + } else { + v = 0; + } + out_pack[i] = 1; + } else { + out_pack[i] = 0; + } + mem[i] = v; + } + + res_stream.write(out_pack); +} + +} // namespace nnet + +#endif diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h b/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h new file mode 100644 index 0000000000..26a44bed59 --- /dev/null +++ b/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h @@ -0,0 +1,77 @@ +#ifndef NNET_LIF_NEURON_H_ +#define NNET_LIF_NEURON_H_ + +#include "hls_stream.h" +#include "nnet_common.h" +#include "nnet_snn_common.h" + +namespace nnet { + +struct lif_neuron_config { + static const unsigned n_in = 1; + static const unsigned n_out = 1; + static const unsigned io_type = io_parallel; + static constexpr float threshold = 1.0; + static constexpr float beta = 0.9; + static const snn_reset_mode reset_mode = snn_reset_mode::subtract; +}; + +template +void lif_neuron(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out]) { + #pragma HLS PIPELINE II=1 + + static data_T mem[CONFIG_T::n_out]; + #pragma HLS ARRAY_PARTITION variable=mem complete + + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + data_T v = (data_T)CONFIG_T::beta * mem[i] + data[i]; + bool spike = (v >= (data_T)CONFIG_T::threshold); + if (spike) { + if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { + v = v - (data_T)CONFIG_T::threshold; + } else { + v = 0; + } + res[i] = 1; + } else { + res[i] = 0; + } + mem[i] = v; + } +} + +template +void lif_neuron(hls::stream &data_stream, hls::stream &res_stream) { + #pragma HLS PIPELINE II=1 + + static typename data_T::value_type mem[CONFIG_T::n_out]; + #pragma HLS ARRAY_PARTITION variable=mem complete + + data_T in_pack = data_stream.read(); + res_T out_pack; + PRAGMA_DATA_PACK(out_pack) + + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + typename data_T::value_type v = (typename data_T::value_type)CONFIG_T::beta * mem[i] + in_pack[i]; + bool spike = (v >= (typename data_T::value_type)CONFIG_T::threshold); + if (spike) { + if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { + v = v - (typename data_T::value_type)CONFIG_T::threshold; + } else { + v = 0; + } + out_pack[i] = 1; + } else { + out_pack[i] = 0; + } + mem[i] = v; + } + + res_stream.write(out_pack); +} + +} // namespace nnet + +#endif diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h b/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h new file mode 100644 index 0000000000..e453a522d1 --- /dev/null +++ b/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h @@ -0,0 +1,11 @@ +#ifndef NNET_SNN_COMMON_H_ +#define NNET_SNN_COMMON_H_ + +namespace nnet { + +enum class snn_reset_mode { subtract, zero }; +enum class snn_decision_rule { argmax_spike_count, first_to_threshold, threshold_then_argmax, binary_logit }; + +} // namespace nnet + +#endif diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h b/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h new file mode 100644 index 0000000000..90df5db29a --- /dev/null +++ b/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h @@ -0,0 +1,248 @@ +#ifndef NNET_SNN_READOUT_H_ +#define NNET_SNN_READOUT_H_ + +#include "hls_stream.h" +#include "nnet_common.h" +#include "nnet_snn_common.h" + +namespace nnet { + +struct snn_readout_config { + static const unsigned n_classes = 2; + static const unsigned io_type = io_parallel; + static const unsigned window_size = 1; + static const unsigned class_threshold = 1; + static const snn_decision_rule decision_rule = snn_decision_rule::argmax_spike_count; +}; + +template +void snn_readout(data_T data[CONFIG_T::n_classes], res_T res[1]) { + #pragma HLS PIPELINE II=1 + + static unsigned counts[CONFIG_T::n_classes]; + #pragma HLS ARRAY_PARTITION variable=counts complete + static unsigned ts = 0; + + if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + counts[i] += (data[i] != 0) ? 1 : 0; + } + // Fast BCE-like score path for binary classifiers: logit = count_1 - count_0. + res[0] = (typename res_T::value_type)((int)counts[1] - (int)counts[0]); + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + counts[i] = 0; + } + } + return; + } + + // Fast argmax path: update counters and argmax in one pass. + if (CONFIG_T::decision_rule == snn_decision_rule::argmax_spike_count) { + unsigned best = 0; + unsigned best_count = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + unsigned c = counts[i] + ((data[i] != 0) ? 1 : 0); + counts[i] = c; + if (i == 0 || c > best_count) { + best = i; + best_count = c; + } + } + res[0] = (typename res_T::value_type)best; + + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + counts[i] = 0; + } + } + return; + } + + // Generic path for threshold-based decision rules. + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + counts[i] += (data[i] != 0) ? 1 : 0; + } + + unsigned best = 0; + for (unsigned i = 1; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + if (counts[i] > counts[best]) { + best = i; + } + } + + if (CONFIG_T::decision_rule == snn_decision_rule::first_to_threshold) { + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + if (counts[i] >= CONFIG_T::class_threshold) { + best = i; + break; + } + } + } else if (CONFIG_T::decision_rule == snn_decision_rule::threshold_then_argmax) { + bool any_reached = false; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + any_reached |= (counts[i] >= CONFIG_T::class_threshold); + } + if (any_reached) { + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + if (counts[i] >= CONFIG_T::class_threshold) { + best = i; + break; + } + } + } + } + + res[0] = best; + + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + counts[i] = 0; + } + } +} + +template +void snn_readout(hls::stream &data_stream, hls::stream &res_stream) { + #pragma HLS PIPELINE II=1 + + static unsigned counts[CONFIG_T::n_classes]; + #pragma HLS ARRAY_PARTITION variable=counts complete + static unsigned ts = 0; + + data_T in_pack = data_stream.read(); + + if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + counts[i] += (in_pack[i] != 0) ? 1 : 0; + } + res_T out_pack; + PRAGMA_DATA_PACK(out_pack) + for (unsigned i = 0; i < res_T::size; i++) { + #pragma HLS UNROLL + out_pack[i] = 0; + } + out_pack[0] = (typename res_T::value_type)((int)counts[1] - (int)counts[0]); + res_stream.write(out_pack); + + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + counts[i] = 0; + } + } + return; + } + + if (CONFIG_T::decision_rule == snn_decision_rule::argmax_spike_count) { + unsigned best = 0; + unsigned best_count = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + unsigned c = counts[i] + ((in_pack[i] != 0) ? 1 : 0); + counts[i] = c; + if (i == 0 || c > best_count) { + best = i; + best_count = c; + } + } + + res_T out_pack; + PRAGMA_DATA_PACK(out_pack) + for (unsigned i = 0; i < res_T::size; i++) { + #pragma HLS UNROLL + out_pack[i] = 0; + } + out_pack[0] = (typename res_T::value_type)best; + res_stream.write(out_pack); + + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + counts[i] = 0; + } + } + return; + } + + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + counts[i] += (in_pack[i] != 0) ? 1 : 0; + } + + unsigned best = 0; + for (unsigned i = 1; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + if (counts[i] > counts[best]) { + best = i; + } + } + + if (CONFIG_T::decision_rule == snn_decision_rule::first_to_threshold) { + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + if (counts[i] >= CONFIG_T::class_threshold) { + best = i; + break; + } + } + } else if (CONFIG_T::decision_rule == snn_decision_rule::threshold_then_argmax) { + bool any_reached = false; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + any_reached |= (counts[i] >= CONFIG_T::class_threshold); + } + if (any_reached) { + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + if (counts[i] >= CONFIG_T::class_threshold) { + best = i; + break; + } + } + } + } + + res_T out_pack; + PRAGMA_DATA_PACK(out_pack) + for (unsigned i = 0; i < res_T::size; i++) { + #pragma HLS UNROLL + out_pack[i] = 0; + } + out_pack[0] = (typename res_T::value_type)best; + res_stream.write(out_pack); + + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + counts[i] = 0; + } + } +} + +} // namespace nnet + +#endif diff --git a/hls4ml/utils/torch.py b/hls4ml/utils/torch.py index 25d2754b1f..21b0306ca8 100644 --- a/hls4ml/utils/torch.py +++ b/hls4ml/utils/torch.py @@ -22,4 +22,5 @@ def is_leaf_module(self, m, module_qualified_name: str) -> bool: or m.__module__.startswith('torch.nn') or m.__module__.startswith('torch.ao.nn') or m.__module__.startswith('brevitas.nn') + or m.__module__.startswith('snntorch') ) and not isinstance(m, torch.nn.Sequential) diff --git a/requirements-snn-dev.txt b/requirements-snn-dev.txt new file mode 100644 index 0000000000..c034b61503 --- /dev/null +++ b/requirements-snn-dev.txt @@ -0,0 +1,12 @@ +# hls4ml SNN development environment +# Usage: +# python -m venv .venv +# source .venv/bin/activate +# python -m pip install --upgrade pip +# python -m pip install -r requirements-snn-dev.txt + +# Install local hls4ml in editable mode with test extras +-e .[testing] + +# SNN training package used upstream in this workflow +snntorch diff --git a/test/pytest/test_extensions_pytorch_snn.py b/test/pytest/test_extensions_pytorch_snn.py new file mode 100644 index 0000000000..afefe6ab56 --- /dev/null +++ b/test/pytest/test_extensions_pytorch_snn.py @@ -0,0 +1,76 @@ +from pathlib import Path + +import pytest +import torch + +import hls4ml +import hls4ml.utils.torch + +test_root_path = Path(__file__).parent + + +class TSNNWindowReadout(hls4ml.utils.torch.HLS4MLModule): + """Example custom PyTorch module mapped to builtin SNNReadout.""" + + def __init__(self, n_classes=4, window_size=8, decision_rule='argmax_spike_count', class_threshold=2): + super().__init__() + self.n_classes = n_classes + self.window_size = window_size + self.decision_rule = decision_rule + self.class_threshold = class_threshold + + def forward(self, x): + return x + + +def parse_custom_snn_readout(operation, layer_name, input_names, input_shapes, node, class_object, data_reader, config): + assert operation == 'TSNNWindowReadout' + + layer = {} + layer['class_name'] = 'SNNReadout' + layer['name'] = layer_name + layer['inputs'] = input_names + layer['n_classes'] = int(class_object.n_classes) + layer['window_size'] = int(class_object.window_size) + layer['class_threshold'] = int(class_object.class_threshold) + layer['decision_rule'] = str(class_object.decision_rule) + + output_shape = input_shapes[0][:] + output_shape[-1] = 1 + return layer, output_shape + + +@pytest.fixture(scope='session', autouse=True) +def register_custom_snn_extension(): + hls4ml.converters.register_pytorch_layer_handler('TSNNWindowReadout', parse_custom_snn_readout) + + +def test_extensions_pytorch_snn_readout_parser(test_case_id): + class PyTorchModel(torch.nn.Module): + def __init__(self): + super().__init__() + self.fc = torch.nn.Linear(4, 4) + self.readout = TSNNWindowReadout( + n_classes=4, window_size=10, decision_rule='threshold_then_argmax', class_threshold=3 + ) + + def forward(self, x): + x = self.fc(x) + return self.readout(x) + + pmodel = PyTorchModel() + config = hls4ml.utils.config_from_pytorch_model( + pmodel, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + ) + hmodel = hls4ml.converters.convert_from_pytorch_model( + pmodel, + output_dir=str(test_root_path / test_case_id), + backend='Vivado', + io_type='io_parallel', + hls_config=config, + ) + + readouts = [layer for layer in hmodel.get_layers() if layer.class_name == 'SNNReadout'] + assert len(readouts) == 1 + assert readouts[0].get_attr('decision_rule') == 'threshold_then_argmax' + assert readouts[0].get_attr('window_size') == 10 diff --git a/test/pytest/test_snn_pytorch.py b/test/pytest/test_snn_pytorch.py new file mode 100644 index 0000000000..c29ddea9c0 --- /dev/null +++ b/test/pytest/test_snn_pytorch.py @@ -0,0 +1,150 @@ +from pathlib import Path + +import pytest +import torch + +import hls4ml +import hls4ml.utils.torch + +test_root_path = Path(__file__).parent + + +class Leaky(hls4ml.utils.torch.HLS4MLModule): + def __init__(self, beta=0.9, threshold=1.0, reset_mechanism='subtract'): + super().__init__() + self.beta = torch.tensor(beta) + self.threshold = torch.tensor(threshold) + self.reset_mechanism = reset_mechanism + + def forward(self, x): + return x + + +class LIFNet(torch.nn.Module): + def __init__(self): + super().__init__() + self.fc = torch.nn.Linear(4, 4) + self.neuron = Leaky(beta=0.95, threshold=1.2, reset_mechanism='subtract') + + def forward(self, x): + x = self.fc(x) + return self.neuron(x) + + +class SNNReadout(hls4ml.utils.torch.HLS4MLModule): + def __init__(self, n_classes=4, window_size=16, decision_rule='argmax_spike_count', class_threshold=2): + super().__init__() + self.n_classes = n_classes + self.window_size = window_size + self.decision_rule = decision_rule + self.class_threshold = class_threshold + + def forward(self, x): + return x + + +class IFNet(torch.nn.Module): + def __init__(self): + super().__init__() + self.fc = torch.nn.Linear(4, 4) + self.neuron = Leaky(beta=1.0, threshold=0.8, reset_mechanism='zero') + + def forward(self, x): + x = self.fc(x) + return self.neuron(x) + + +class SNNClassifier(torch.nn.Module): + def __init__(self): + super().__init__() + self.fc = torch.nn.Linear(4, 4) + self.neuron = Leaky(beta=0.95, threshold=1.2, reset_mechanism='subtract') + self.readout = SNNReadout( + n_classes=4, window_size=12, decision_rule='threshold_then_argmax', class_threshold=3 + ) + + def forward(self, x): + x = self.fc(x) + x = self.neuron(x) + return self.readout(x) + + +class IFNetTol(torch.nn.Module): + def __init__(self): + super().__init__() + self.fc = torch.nn.Linear(4, 4) + self.neuron = Leaky(beta=1.0 - 5e-7, threshold=0.8, reset_mechanism='subtract') + + def forward(self, x): + x = self.fc(x) + return self.neuron(x) + + +@pytest.mark.parametrize( + 'model_class,expected_layer', + [ + (LIFNet, 'LIFNeuron'), + (IFNet, 'IFNeuron'), + (IFNetTol, 'IFNeuron'), + (SNNClassifier, 'SNNReadout'), + ], +) +def test_pytorch_snn_layers_are_parsed(test_case_id, model_class, expected_layer): + model = model_class() + config = hls4ml.utils.config_from_pytorch_model( + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + ) + + hmodel = hls4ml.converters.convert_from_pytorch_model( + model, + output_dir=str(test_root_path / test_case_id), + backend='Vivado', + io_type='io_parallel', + hls_config=config, + ) + + layer_names = [layer.class_name for layer in hmodel.get_layers()] + assert expected_layer in layer_names + + if expected_layer == 'SNNReadout': + readout = [layer for layer in hmodel.get_layers() if layer.class_name == 'SNNReadout'][0] + assert readout.get_attr('decision_rule') == 'threshold_then_argmax' + assert readout.get_attr('window_size') == 12 + assert readout.get_attr('class_threshold') == 3 + + +@pytest.mark.parametrize( + 'beta,expected_layer', + [ + (1.0, 'IFNeuron'), + (1.0 - 5e-7, 'IFNeuron'), + (0.999, 'LIFNeuron'), + (0.95, 'LIFNeuron'), + ], +) +def test_leaky_beta_maps_to_if_or_lif(test_case_id, beta, expected_layer): + class BetaNet(torch.nn.Module): + def __init__(self): + super().__init__() + self.fc = torch.nn.Linear(4, 4) + self.neuron = Leaky(beta=beta, threshold=1.0, reset_mechanism='subtract') + + def forward(self, x): + x = self.fc(x) + return self.neuron(x) + + model = BetaNet() + config = hls4ml.utils.config_from_pytorch_model( + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + ) + + hmodel = hls4ml.converters.convert_from_pytorch_model( + model, + output_dir=str(test_root_path / test_case_id), + backend='Vivado', + io_type='io_parallel', + hls_config=config, + ) + + layer_names = [layer.class_name for layer in hmodel.get_layers()] + assert expected_layer in layer_names From 65c817a3317e7e0d6b3cc9cec53ad6d16742e4fe Mon Sep 17 00:00:00 2001 From: Barry Dillon <77981701+bmdillon@users.noreply.github.com> Date: Mon, 27 Apr 2026 11:15:13 +0100 Subject: [PATCH 02/32] jupyter notebook demo of snn functionality --- hls4snn-demo.ipynb | 1927 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1927 insertions(+) create mode 100644 hls4snn-demo.ipynb diff --git a/hls4snn-demo.ipynb b/hls4snn-demo.ipynb new file mode 100644 index 0000000000..8f8722175e --- /dev/null +++ b/hls4snn-demo.ipynb @@ -0,0 +1,1927 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "67fc7845-3298-47c6-a893-6babb5205883", + "metadata": {}, + "source": [ + "# hls4snn" + ] + }, + { + "cell_type": "markdown", + "id": "5ccb39c0-9fcf-45d1-b418-7e19cd2c7bdc", + "metadata": {}, + "source": [ + "This is a simple notebook that shows how to use hls4ml for SNNs, with neurobench also." + ] + }, + { + "cell_type": "markdown", + "id": "c071f16c-6f7d-409e-85fa-d09d726944a6", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## imports" + ] + }, + { + "cell_type": "markdown", + "id": "0ff83cc4-4b69-4250-99d9-7e37ba5fdca3", + "metadata": {}, + "source": [ + "Make sure to run:\n", + "\n", + "`\n", + "source /tools/Xilinx/Vitis/2024.1/settings64.sh\n", + "`\n", + "\n", + "`\n", + "source /tools/Xilinx/Vivado/2024.1/settings64.sh\n", + "`\n", + "\n", + "in the terminal before launching the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "19b95931-bd8c-4bf2-b82f-4d0dc135bf50", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/b/Physics/hls4ml/hls4ml/__init__.py\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import argparse\n", + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.utils.data import TensorDataset, DataLoader\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import hls4ml\n", + "import hls4ml.utils.torch\n", + "print(hls4ml.__file__)\n", + "import snntorch as snn\n", + "\n", + "import neurobench\n", + "from neurobench.models import TorchModel, SNNTorchModel\n", + "from neurobench.benchmarks import Benchmark\n", + "from neurobench.metrics.static import (\n", + " Footprint,\n", + " ConnectionSparsity,\n", + ")\n", + "from neurobench.metrics.workload import (\n", + " ClassificationAccuracy,\n", + " ActivationSparsity,\n", + " SynapticOperations,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "a22085b8-462e-4313-9247-2285164117a8", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## data" + ] + }, + { + "cell_type": "markdown", + "id": "cbb35d2e-1633-4f1d-a9c9-ba4b5c93312e", + "metadata": {}, + "source": [ + "creating a simple 2D dataset for testing the SNN" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c418a2b2-698d-454d-88a3-c67e09586932", + "metadata": {}, + "outputs": [], + "source": [ + "def make_synthetic_stream_data(n_samples: int, timesteps: int, seed: int = 1234):\n", + " rng = np.random.default_rng(seed)\n", + " x = rng.normal(loc=0.0, scale=1.0, size=(n_samples, timesteps, 2)).astype(np.float32)\n", + " score = np.sum(0.9 * x[:, :, 0] - 0.6 * x[:, :, 1], axis=1)\n", + " y = (score > 0.0).astype(np.int64)\n", + " return torch.from_numpy(x), torch.from_numpy(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8cdf7458-42a8-48cd-9104-8744d5cafc60", + "metadata": {}, + "outputs": [], + "source": [ + "def make_simple_gaussian_streams_2d(\n", + " n_samples: int,\n", + " timesteps: int,\n", + " seed: int = 1234,\n", + " mean_shift: float = 1.0,\n", + " std: float = 1.0,\n", + "):\n", + " rng = np.random.default_rng(seed)\n", + " y = rng.integers(0, 2, size=n_samples)\n", + " x = rng.normal(loc=0.0, scale=std, size=(n_samples, timesteps, 2)).astype(np.float32)\n", + "\n", + " # Shift only the first channel by class\n", + " x[y == 0, :, 0] -= mean_shift\n", + " x[y == 1, :, 0] += mean_shift\n", + " return torch.from_numpy(x), torch.from_numpy(y.astype(np.int64))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "090e098b-62ac-47de-b5f4-1bb04f12f301", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_2d_streams(x, y, max_per_class=50):\n", + " \"\"\"\n", + " x: torch.Tensor or np.ndarray of shape (n_samples, timesteps, 2)\n", + " y: torch.Tensor or np.ndarray of shape (n_samples,)\n", + " \"\"\"\n", + " if hasattr(x, \"detach\"):\n", + " x = x.detach().cpu().numpy()\n", + " if hasattr(y, \"detach\"):\n", + " y = y.detach().cpu().numpy()\n", + "\n", + " x0 = x[y == 0]\n", + " x1 = x[y == 1]\n", + "\n", + " # Optionally limit how many raw streams to draw\n", + " x0_plot = x0[:max_per_class]\n", + " x1_plot = x1[:max_per_class]\n", + "\n", + " t = np.arange(x.shape[1])\n", + "\n", + " # LaTeX-like font styling\n", + " plt.rcParams.update({\n", + " \"font.family\": \"serif\",\n", + " \"font.serif\": [\"Computer Modern Roman\", \"CMU Serif\", \"DejaVu Serif\"],\n", + " \"mathtext.fontset\": \"cm\",\n", + " \"axes.unicode_minus\": False,\n", + " \"font.size\": 12,\n", + " })\n", + "\n", + " fig, axes = plt.subplots(2, 1, figsize=(10, 7), sharex=True)\n", + "\n", + " for d, ax in enumerate(axes):\n", + " # Raw streams\n", + " for seq in x0_plot:\n", + " ax.plot(t, seq[:, d], alpha=0.10, linewidth=1.0)\n", + " for seq in x1_plot:\n", + " ax.plot(t, seq[:, d], alpha=0.10, linewidth=1.0)\n", + "\n", + " # One visible line per class for legend\n", + " ax.plot(t, x0_plot[0, :, d], alpha=0.5, linewidth=1.2, label=\"Class 0 streams\", color='green')\n", + " ax.plot(t, x1_plot[0, :, d], alpha=0.5, linewidth=1.2, label=\"Class 1 streams\", color='red')\n", + "\n", + " # Class means\n", + " ax.plot(t, x0[:, :, d].mean(axis=0), linewidth=3.0, label=\"Class 0 mean\", color='green')\n", + " ax.plot(t, x1[:, :, d].mean(axis=0), linewidth=3.0, label=\"Class 1 mean\", color='red')\n", + "\n", + " ax.set_title(rf\"Dimension ${d}$\")\n", + " ax.set_ylabel(r\"Value\")\n", + " ax.grid(True, alpha=0.25)\n", + " ax.legend(frameon=False, ncol=2)\n", + "\n", + " axes[-1].set_xlabel(r\"Timestep $t$\")\n", + " fig.suptitle(r\"2D stream data by input dimension\", fontsize=16)\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "93c1e030-8b52-469f-a33b-0d3b48453624", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x, y = make_simple_gaussian_streams_2d(n_samples=200, timesteps=10, mean_shift=0.4)\n", + "plot_2d_streams(x, y)" + ] + }, + { + "cell_type": "markdown", + "id": "09d83842-24b9-412e-b5b5-b7af9e2275a1", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## neural nets" + ] + }, + { + "cell_type": "markdown", + "id": "0e90daa3-5b2b-4139-bde7-3c5b28b7e297", + "metadata": {}, + "source": [ + "defining the SNN here where the forward pass loops through all timesteps in the data" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "277f1a94-1c6d-42bd-b8d0-5a65c487f4fd", + "metadata": {}, + "outputs": [], + "source": [ + "class SNN_LIF(nn.Module):\n", + " \"\"\"\n", + " SNN model using snnTorch Leaky neuron in IF-equivalent mode (beta=1).\n", + " This is the one we use to optimise the weights\n", + " \"\"\"\n", + "\n", + " def __init__(self, hidden: int = 16, threshold: float = 1.0, beta: float = 1.0):\n", + " super().__init__()\n", + " self.fc1 = nn.Linear(2, hidden)\n", + " self.if1 = snn.Leaky(beta=beta, threshold=threshold, reset_mechanism='subtract')\n", + " self.fc2 = nn.Linear(hidden, 2)\n", + "\n", + " def forward(self, x_seq: torch.Tensor) -> torch.Tensor:\n", + " # x_seq: [B, T, 2]\n", + " bsz, _, _ = x_seq.shape\n", + " mem = torch.zeros(bsz, self.fc1.out_features, device=x_seq.device, dtype=x_seq.dtype)\n", + " out = torch.zeros(bsz, 2, device=x_seq.device, dtype=x_seq.dtype)\n", + "\n", + " for t in range(x_seq.shape[1]):\n", + " cur1 = self.fc1(x_seq[:, t, :])\n", + " spk1, mem = self.if1(cur1, mem)\n", + " out = out + self.fc2(spk1)\n", + " return out" + ] + }, + { + "cell_type": "markdown", + "id": "ed20e49f-cdbd-4eb2-9682-823e19838a97", + "metadata": {}, + "source": [ + "making a single-step SNN here, because this is the version that will be used with hls4ml" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "bf527b56-c244-47c5-8c4f-84684c0aa6c0", + "metadata": {}, + "outputs": [], + "source": [ + "class SNN_LIF_step(nn.Module):\n", + " \"\"\"\n", + " Single-timestep model for hls4ml conversion: 2 -> Dense(16) -> IF -> Dense(2).\n", + " This is the one we use to put through HLS in stream mode\n", + " \"\"\"\n", + "\n", + " def __init__(self, hidden: int = 16, threshold: float = 1.0, beta: float = 1.0):\n", + " super().__init__()\n", + " self.fc1 = nn.Linear(2, hidden)\n", + " self.if1 = snn.Leaky(beta=beta, threshold=threshold, reset_mechanism='subtract')\n", + " self.fc2 = nn.Linear(hidden, 2)\n", + "\n", + " def forward(self, x: torch.Tensor) -> torch.Tensor:\n", + " x = self.fc1(x)\n", + " x, _ = self.if1(x)\n", + " x = self.fc2(x)\n", + " # neurobench requires 2D output from the single step NN\n", + " return x, None" + ] + }, + { + "cell_type": "markdown", + "id": "170c299c-ace5-40fd-82ca-bf10ac18ebfd", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## train function" + ] + }, + { + "cell_type": "markdown", + "id": "63af4cf3-3a4f-47c1-a606-9c9540aa2067", + "metadata": {}, + "source": [ + "very simple train function for testing purposes" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "edc0c97f-375a-4424-87ec-0b78e52c4bc6", + "metadata": {}, + "outputs": [], + "source": [ + "def train_snn(\n", + " model,\n", + " x_train: torch.Tensor,\n", + " y_train: torch.Tensor,\n", + " epochs: int = 5,\n", + " batch_size: int = 64,\n", + " lr: float = 5e-3,\n", + "):\n", + " criterion = nn.CrossEntropyLoss()\n", + " optim = torch.optim.Adam(model.parameters(), lr=lr)\n", + "\n", + " n_samples = x_train.shape[0]\n", + " for epoch in range(epochs):\n", + " perm = torch.randperm(n_samples)\n", + " epoch_loss = 0.0\n", + " correct = 0\n", + "\n", + " for start in range(0, n_samples, batch_size):\n", + " idx = perm[start : start + batch_size]\n", + " xb = x_train[idx]\n", + " yb = y_train[idx]\n", + "\n", + " logits = model.forward(xb)\n", + " loss = criterion(logits, yb)\n", + "\n", + " optim.zero_grad()\n", + " loss.backward()\n", + " optim.step()\n", + "\n", + " epoch_loss += float(loss.item()) * xb.shape[0]\n", + " correct += int((logits.argmax(dim=1) == yb).sum().item())\n", + "\n", + " print(\n", + " f'Epoch {epoch + 1:02d}/{epochs}: '\n", + " f'loss={epoch_loss / n_samples:.4f}, acc={correct / n_samples:.4f}'\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "70b37555-6f4d-4cca-a35d-e79c5da91540", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## train the net" + ] + }, + { + "cell_type": "markdown", + "id": "6ff987f8-0978-48e7-b083-d1580b250636", + "metadata": {}, + "source": [ + "train the SNN model" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "974f3a5b-a98a-496f-a389-91d4c9c2caf9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 01/40: loss=1.6508, acc=0.4950\n", + "Epoch 02/40: loss=1.4839, acc=0.4950\n", + "Epoch 03/40: loss=1.3144, acc=0.4950\n", + "Epoch 04/40: loss=1.1773, acc=0.4950\n", + "Epoch 05/40: loss=1.0510, acc=0.4950\n", + "Epoch 06/40: loss=0.9358, acc=0.4950\n", + "Epoch 07/40: loss=0.8379, acc=0.4950\n", + "Epoch 08/40: loss=0.7687, acc=0.5000\n", + "Epoch 09/40: loss=0.7271, acc=0.5000\n", + "Epoch 10/40: loss=0.6972, acc=0.5400\n", + "Epoch 11/40: loss=0.6772, acc=0.5500\n", + "Epoch 12/40: loss=0.6613, acc=0.6100\n", + "Epoch 13/40: loss=0.6407, acc=0.6300\n", + "Epoch 14/40: loss=0.6061, acc=0.6700\n", + "Epoch 15/40: loss=0.5802, acc=0.6800\n", + "Epoch 16/40: loss=0.5514, acc=0.7400\n", + "Epoch 17/40: loss=0.5107, acc=0.8000\n", + "Epoch 18/40: loss=0.4786, acc=0.8450\n", + "Epoch 19/40: loss=0.4461, acc=0.8750\n", + "Epoch 20/40: loss=0.4129, acc=0.9050\n", + "Epoch 21/40: loss=0.3928, acc=0.9100\n", + "Epoch 22/40: loss=0.3692, acc=0.9200\n", + "Epoch 23/40: loss=0.3514, acc=0.9200\n", + "Epoch 24/40: loss=0.3359, acc=0.9150\n", + "Epoch 25/40: loss=0.3234, acc=0.9200\n", + "Epoch 26/40: loss=0.3129, acc=0.9200\n", + "Epoch 27/40: loss=0.3003, acc=0.9250\n", + "Epoch 28/40: loss=0.2982, acc=0.9200\n", + "Epoch 29/40: loss=0.2919, acc=0.9100\n", + "Epoch 30/40: loss=0.2877, acc=0.9050\n", + "Epoch 31/40: loss=0.2803, acc=0.9000\n", + "Epoch 32/40: loss=0.2721, acc=0.9100\n", + "Epoch 33/40: loss=0.2632, acc=0.9250\n", + "Epoch 34/40: loss=0.2554, acc=0.9250\n", + "Epoch 35/40: loss=0.2484, acc=0.9250\n", + "Epoch 36/40: loss=0.2438, acc=0.9300\n", + "Epoch 37/40: loss=0.2414, acc=0.9300\n", + "Epoch 38/40: loss=0.2358, acc=0.9350\n", + "Epoch 39/40: loss=0.2314, acc=0.9350\n", + "Epoch 40/40: loss=0.2287, acc=0.9350\n" + ] + } + ], + "source": [ + "train_model = SNN_LIF(hidden=16, beta=0.9)\n", + "train_snn(\n", + " train_model,\n", + " x,\n", + " y,\n", + " epochs=40,\n", + " batch_size=256,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "6e57d564-f005-4877-9e74-7caedf255e69", + "metadata": {}, + "source": [ + "copy the weights to the single-step network for hls conversion" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "90386d04-0058-4516-8939-770126305fb6", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "SNN_LIF_step(\n", + " (fc1): Linear(in_features=2, out_features=16, bias=True)\n", + " (if1): Leaky()\n", + " (fc2): Linear(in_features=16, out_features=2, bias=True)\n", + ")" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "single_step_model = SNN_LIF_step(hidden=16, beta=0.9, threshold=1.0)\n", + "single_step_model.fc1.load_state_dict(train_model.fc1.state_dict())\n", + "single_step_model.fc2.load_state_dict(train_model.fc2.state_dict())\n", + "single_step_model.eval()" + ] + }, + { + "cell_type": "markdown", + "id": "8b9b5257-eb80-471c-b52b-fe48c6893c5c", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## run hls4ml" + ] + }, + { + "cell_type": "markdown", + "id": "18c67f8c-8f92-4bfd-bc08-6d9b19f1b0ba", + "metadata": {}, + "source": [ + "now we run the hls4ml package" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "87bdabc7-6423-4bb1-bc31-956d6479c46a", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Interpreting Model ...\n", + "Topology:\n", + "Layer name: fc1, layer type: Dense, input shape: [[None, 2]]\n", + "Layer name: if1, layer type: LIFNeuron, input shape: [[None, 16]]\n", + "Layer name: fc2, layer type: Dense, input shape: [[None, 16]]\n", + "Generated HLS project at: snn_test_lif\n", + "Generated top file: snn_test_lif/firmware/snn_test_lif.cpp\n", + "\n", + "****** vitis-run v2024.1 (64-bit)\n", + " **** SW Build 5074859 on 2024-05-20-23:21:20\n", + " **** Start of session at: Mon Apr 27 10:37:51 2026\n", + " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", + " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", + "\n", + "INFO: [vitis-run 82-31] Launching vitis_hls: vitis_hls -nolog -run tcl -f /home/b/Physics/hls4ml/snn_test_lif/build_prj.tcl -work_dir /home/b/Physics/hls4ml/snn_test_lif\n", + "\n", + "****** Vitis HLS - High-Level Synthesis from C, C++ and OpenCL v2024.1 (64-bit)\n", + " **** SW Build 5069499 on May 21 2024\n", + " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", + " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", + " **** Start of session at: Mon Apr 27 10:37:52 2026\n", + " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", + " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", + "\n", + "source /tools/Xilinx/Vitis_HLS/2024.1/scripts/vitis_hls/hls.tcl -notrace\n", + "INFO: [HLS 200-10] For user 'b' on host 'b-comp' (Linux_x86_64 version 6.12.64-1-MANJARO) on Mon Apr 27 10:37:53 IST 2026\n", + "INFO: [HLS 200-10] On os \"Manjaro Linux\"\n", + "INFO: [HLS 200-10] In directory '/home/b/Physics/hls4ml/snn_test_lif'\n", + "Sourcing Tcl script '/home/b/Physics/hls4ml/snn_test_lif/build_prj.tcl'\n", + "INFO: [HLS 200-1510] Running: open_project -reset snn_test_lif_prj \n", + "INFO: [HLS 200-10] Opening and resetting project '/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj'.\n", + "INFO: [HLS 200-1510] Running: set_top snn_test_lif \n", + "INFO: [HLS 200-1510] Running: add_files firmware/snn_test_lif.cpp -cflags -std=c++0x \n", + "INFO: [HLS 200-10] Adding design file 'firmware/snn_test_lif.cpp' to the project\n", + "INFO: [HLS 200-1510] Running: add_files -tb snn_test_lif_test.cpp -cflags -std=c++0x \n", + "INFO: [HLS 200-10] Adding test bench file 'snn_test_lif_test.cpp' to the project\n", + "INFO: [HLS 200-1510] Running: add_files -tb firmware/weights \n", + "INFO: [HLS 200-10] Adding test bench file 'firmware/weights' to the project\n", + "INFO: [HLS 200-1510] Running: add_files -tb tb_data \n", + "INFO: [HLS 200-10] Adding test bench file 'tb_data' to the project\n", + "INFO: [HLS 200-1510] Running: open_solution -reset solution1 \n", + "INFO: [HLS 200-10] Creating and opening solution '/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1'.\n", + "INFO: [HLS 200-10] Cleaning up the solution database.\n", + "INFO: [HLS 200-1505] Using default flow_target 'vivado'\n", + "Resolution: For help on HLS 200-1505 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=200-1505.html\n", + "INFO: [HLS 200-1510] Running: config_array_partition -maximum_size 4096 \n", + "ERROR: [HLS 200-101] config_array_partition: Unknown option '-maximum_size'.\n", + "ERROR: [HLS 200-101] config_array_partition: Unknown option '4096'.\n", + "SYNTAX \n", + " config_array_partition [OPTIONS]\n", + " -auto_partition_threshold *** DEPRECATED***\n", + " -auto_promotion_threshold *** DEPRECATED***\n", + " -complete_threshold \n", + " -throughput_driven \n", + "\n", + "SEE ALSO\n", + " INI: syn.array_partition.complete_threshold syn.array_partition.throughput_driven\n", + " docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1399-vitis-hls&resourceid=vyw1583260160301.html\n", + "\n", + "INFO: [HLS 200-1510] Running: config_compile -name_max_length 80 \n", + "INFO: [XFORM 203-1161] The maximum of name length is set to 80.\n", + "INFO: [HLS 200-1510] Running: set_part xczu7ev-ffvc1156-2-e \n", + "INFO: [HLS 200-1611] Setting target device to 'xczu7ev-ffvc1156-2-e'\n", + "INFO: [XFORM 203-1161] The maximum of name length is set to 80.\n", + "INFO: [HLS 200-1510] Running: config_schedule -enable_dsp_full_reg=false \n", + "INFO: [HLS 200-1510] Running: create_clock -period 5 -name default \n", + "INFO: [SYN 201-201] Setting up clock 'default' with a period of 5ns.\n", + "INFO: [HLS 200-1510] Running: set_clock_uncertainty 27% default \n", + "INFO: [SYN 201-201] Setting up clock 'default' with an uncertainty of 1.35ns.\n", + "***** C SIMULATION *****\n", + "INFO: [HLS 200-1510] Running: csim_design \n", + "INFO: [SIM 211-2] *************** CSIM start ***************\n", + "INFO: [SIM 211-4] CSIM will launch CLANG as the compiler.\n", + "INFO: [HLS 200-2036] Building debug C Simulation binaries\n", + " Compiling ../../../../snn_test_lif_test.cpp in debug mode\n", + " Compiling ../../../../firmware/snn_test_lif.cpp in debug mode\n", + " Generating csim.exe\n", + "INFO: Unable to open input/predictions file, using default input.\n", + "-0.25 -0.25 \n", + "-0.25 -0.25 \n", + "-0.25 -1 \n", + "-0.25 -0.75 \n", + "-0.25 -0.25 \n", + "INFO: Saved inference results to file: tb_data/csim_results.log\n", + "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", + "INFO: [SIM 211-1] CSim done with 0 errors.\n", + "INFO: [SIM 211-3] *************** CSIM finish ***************\n", + "INFO: [HLS 200-2161] Finished Command csim_design Elapsed time: 00:00:04; Allocated memory: 0.016 MB.\n", + "***** C SIMULATION COMPLETED IN 0h0m4s *****\n", + "***** C/RTL SYNTHESIS *****\n", + "INFO: [HLS 200-1510] Running: csynth_design \n", + "INFO: [HLS 200-111] Finished File checks and directory preparation: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 326.793 MB.\n", + "INFO: [HLS 200-10] Analyzing design file 'firmware/snn_test_lif.cpp' ... \n", + "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:33:9)\n", + "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:107:9)\n", + "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:189:9)\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_test_lif.cpp:38:57)\n", + "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_test_lif.cpp:38:61)\n", + "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_test_lif.cpp:42:70)\n", + "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_test_lif.cpp:42:74)\n", + "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", + "WARNING: [HLS 200-471] Dataflow form checks found 4 issue(s) in file firmware/snn_test_lif.cpp\n", + "Resolution: For help on HLS 200-471 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=200-471.html\n", + "WARNING: [HLS 207-5292] unused parameter 'keep' (firmware/nnet_utils/nnet_helpers.h:285:99)\n", + "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:14:36)\n", + "WARNING: [HLS 207-5292] unused parameter 'buffer' (firmware/nnet_utils/nnet_function_stubs.h:15:36)\n", + "WARNING: [HLS 207-5292] unused parameter 'partition' (firmware/nnet_utils/nnet_function_stubs.h:16:44)\n", + "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:24:24)\n", + "WARNING: [HLS 207-5292] unused parameter 'buffer' (firmware/nnet_utils/nnet_function_stubs.h:25:24)\n", + "WARNING: [HLS 207-5292] unused parameter 'partition' (firmware/nnet_utils/nnet_function_stubs.h:26:32)\n", + "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:33:30)\n", + "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_function_stubs.h:33:58)\n", + "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_function_stubs.h:34:51)\n", + "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_function_stubs.h:35:49)\n", + "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:42:30)\n", + "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_function_stubs.h:42:58)\n", + "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_function_stubs.h:43:51)\n", + "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_function_stubs.h:44:49)\n", + "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:51:29)\n", + "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_function_stubs.h:51:80)\n", + "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_function_stubs.h:52:50)\n", + "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_function_stubs.h:53:48)\n", + "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_code_gen.h:16:39)\n", + "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_code_gen.h:17:38)\n", + "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_code_gen.h:18:60)\n", + "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_code_gen.h:19:58)\n", + "INFO: [HLS 200-111] Finished Source Code Analysis and Preprocessing: CPU user time: 4 seconds. CPU system time: 0.83 seconds. Elapsed time: 4.89 seconds; current allocated memory: 331.387 MB.\n", + "INFO: [HLS 200-777] Using interface defaults for 'Vivado' flow target.\n", + "INFO: [HLS 200-1995] There were 3,460 instructions in the design after the 'Compile/Link' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 5,728 instructions in the design after the 'Unroll/Inline (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,900 instructions in the design after the 'Unroll/Inline (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,696 instructions in the design after the 'Unroll/Inline (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,554 instructions in the design after the 'Unroll/Inline (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 857 instructions in the design after the 'Array/Struct (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 857 instructions in the design after the 'Array/Struct (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 861 instructions in the design after the 'Array/Struct (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,275 instructions in the design after the 'Array/Struct (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,264 instructions in the design after the 'Array/Struct (step 5)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,219 instructions in the design after the 'Performance (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,215 instructions in the design after the 'Performance (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,215 instructions in the design after the 'Performance (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,215 instructions in the design after the 'Performance (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,154 instructions in the design after the 'HW Transforms (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,246 instructions in the design after the 'HW Transforms (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 214-415] Performing recursive inline in function 'nnet::dense, 2u>, nnet::array, 16u>, config2>' (firmware/nnet_utils/nnet_dense_stream.h:85:9)\n", + "WARNING: [HLS 214-273] In function 'void nnet::dense_latency_wrapper, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)', Pragma conflict happens on 'INLINE' and 'PIPELINE' pragmas: same function (firmware/nnet_utils/nnet_dense_stream.h:15:0)\n", + "INFO: [HLS 214-415] Performing recursive inline in function 'nnet::dense, 16u>, nnet::array, 2u>, config4>' (firmware/nnet_utils/nnet_dense_stream.h:85:9)\n", + "WARNING: [HLS 214-273] In function 'void nnet::dense_latency_wrapper, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)', Pragma conflict happens on 'INLINE' and 'PIPELINE' pragmas: same function (firmware/nnet_utils/nnet_dense_stream.h:15:0)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::array, 2u>::operator[](unsigned long) (.3)' into 'void nnet::data_prepare, 2u>, config2>(hls::stream, 2u>, 0>&, nnet::array, 2u>::value_type*) (.10)' (firmware/nnet_utils/nnet_dense_stream.h:47:17)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::product::mult, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0> >::product(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>)' into 'void nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:42:27)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::array, 16u>::operator[](unsigned long) (.5)' into 'void nnet::res_write, 16u>, config2>(nnet::array, 16u>::value_type*, hls::stream, 16u>, 0>&) (.8)' (firmware/nnet_utils/nnet_dense_stream.h:75:2)\n", + "INFO: [HLS 214-131] Inlining function 'void nnet::data_prepare, 2u>, config2>(hls::stream, 2u>, 0>&, nnet::array, 2u>::value_type*) (.10)' into 'void nnet::dense, 2u>, nnet::array, 16u>, config2>(hls::stream, 2u>, 0>&, hls::stream, 16u>, 0>&, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:93:2)\n", + "INFO: [HLS 214-131] Inlining function 'void nnet::res_write, 16u>, config2>(nnet::array, 16u>::value_type*, hls::stream, 16u>, 0>&) (.8)' into 'void nnet::dense, 2u>, nnet::array, 16u>, config2>(hls::stream, 2u>, 0>&, hls::stream, 16u>, 0>&, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:100:5)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::array, 16u>::operator[](unsigned long) (.5)' into 'void nnet::data_prepare, 16u>, config4>(hls::stream, 16u>, 0>&, nnet::array, 16u>::value_type*) (.4)' (firmware/nnet_utils/nnet_dense_stream.h:47:17)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::product::mult, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0> >::product(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>)' into 'void nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:42:27)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::array, 2u>::operator[](unsigned long) (.3)' into 'void nnet::res_write, 2u>, config4>(nnet::array, 2u>::value_type*, hls::stream, 2u>, 0>&) (.1)' (firmware/nnet_utils/nnet_dense_stream.h:75:2)\n", + "INFO: [HLS 214-131] Inlining function 'void nnet::data_prepare, 16u>, config4>(hls::stream, 16u>, 0>&, nnet::array, 16u>::value_type*) (.4)' into 'void nnet::dense, 16u>, nnet::array, 2u>, config4>(hls::stream, 16u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:93:2)\n", + "INFO: [HLS 214-131] Inlining function 'void nnet::res_write, 2u>, config4>(nnet::array, 2u>::value_type*, hls::stream, 2u>, 0>&) (.1)' into 'void nnet::dense, 16u>, nnet::array, 2u>, config4>(hls::stream, 16u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:100:5)\n", + "INFO: [HLS 214-291] Loop 'Result' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:64:5)\n", + "INFO: [HLS 214-291] Loop 'Accum1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:54:5)\n", + "INFO: [HLS 214-291] Loop 'Accum2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:56:9)\n", + "INFO: [HLS 214-291] Loop 'ResetAccum' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:48:5)\n", + "INFO: [HLS 214-291] Loop 'Product1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:37:5)\n", + "INFO: [HLS 214-291] Loop 'Product2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:40:9)\n", + "INFO: [HLS 214-291] Loop 'VITIS_LOOP_55_1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_lif_neuron.h:55:22)\n", + "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 16u>, nnet::array, 2u>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 16u>, nnet::array, 2u>, config4>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Accum1' (firmware/nnet_utils/nnet_dense_latency.h:54:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Accum2' (firmware/nnet_utils/nnet_dense_latency.h:56:9) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'ResetAccum' (firmware/nnet_utils/nnet_dense_latency.h:48:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_55_1' (firmware/nnet_utils/nnet_lif_neuron.h:55:22) in function 'nnet::lif_neuron, 16u>, nnet::array, 16u>, config3>' completely with a factor of 16 (firmware/nnet_utils/nnet_lif_neuron.h:45:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 2u>, nnet::array, 16u>, config2>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 2u>, nnet::array, 16u>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Accum1' (firmware/nnet_utils/nnet_dense_latency.h:54:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Accum2' (firmware/nnet_utils/nnet_dense_latency.h:56:9) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'ResetAccum' (firmware/nnet_utils/nnet_dense_latency.h:48:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(config2::accum_t)' into 'void nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-178] Inlining function 'nnet::array, 16u>::operator[](unsigned long)' into 'void nnet::lif_neuron, 16u>, nnet::array, 16u>, config3>(hls::stream, 16u>, 0>&, hls::stream, 16u>, 0>&)' (firmware/nnet_utils/nnet_lif_neuron.h:45:0)\n", + "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(config4::accum_t)' into 'void nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-248] Applying array_partition to 'b2': Complete partitioning on dimension 1. (firmware/weights/b2.h:12:0)\n", + "INFO: [HLS 214-248] Applying array_partition to 'b4': Complete partitioning on dimension 1. (firmware/weights/b4.h:12:0)\n", + "INFO: [HLS 214-248] Applying array_partition to '_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0EELj16EEES6_7config3EEvRN3hls6streamIT_Li0EEERNS9_IT0_Li0EEEE3mem': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_lif_neuron.h:48:0)\n", + "INFO: [HLS 214-248] Applying array_partition to 'data': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_dense_stream.h:87:30)\n", + "INFO: [HLS 214-248] Applying array_partition to 'res': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_dense_stream.h:90:29)\n", + "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer3_out' with compact=bit mode in 64-bits (firmware/snn_test_lif.cpp:35:24)\n", + "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer2_out' with compact=bit mode in 64-bits (firmware/snn_test_lif.cpp:32:24)\n", + "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", + "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", + "INFO: [HLS 200-111] Finished Compiling Optimization and Transform: CPU user time: 2.46 seconds. CPU system time: 0.52 seconds. Elapsed time: 7.31 seconds; current allocated memory: 341.434 MB.\n", + "INFO: [HLS 200-111] Finished Checking Pragmas: CPU user time: 0 seconds. CPU system time: 0 seconds. Elapsed time: 0 seconds; current allocated memory: 341.434 MB.\n", + "INFO: [HLS 200-10] Starting code transformations ...\n", + "INFO: [HLS 200-111] Finished Standard Transforms: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 342.793 MB.\n", + "INFO: [HLS 200-10] Checking synthesizability ...\n", + "INFO: [HLS 200-111] Finished Checking Synthesizability: CPU user time: 0.07 seconds. CPU system time: 0 seconds. Elapsed time: 0.07 seconds; current allocated memory: 345.227 MB.\n", + "INFO: [XFORM 203-712] Applying dataflow to function 'snn_test_lif' (firmware/snn_test_lif.cpp:8), detected/extracted 3 process function(s): \n", + "\t 'nnet::dense, 2u>, nnet::array, 16u>, config2>'\n", + "\t 'nnet::lif_neuron, 16u>, nnet::array, 16u>, config3>'\n", + "\t 'nnet::dense, 16u>, nnet::array, 2u>, config4>'.\n", + "INFO: [XFORM 203-11] Balancing expressions in function 'nnet::dense_latency_wrapper, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' (firmware/nnet_utils/nnet_dense_stream.h:18:1)...16 expression(s) balanced.\n", + "INFO: [HLS 200-111] Finished Loop, function and other optimizations: CPU user time: 0.13 seconds. CPU system time: 0 seconds. Elapsed time: 0.14 seconds; current allocated memory: 369.496 MB.\n", + "INFO: [HLS 200-111] Finished Architecture Synthesis: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.07 seconds; current allocated memory: 411.000 MB.\n", + "INFO: [HLS 200-10] Starting hardware synthesis ...\n", + "INFO: [HLS 200-10] Synthesizing 'snn_test_lif' ...\n", + "WARNING: [SYN 201-103] Legalizing function name 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config2>' to 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s'.\n", + "WARNING: [SYN 201-103] Legalizing function name 'dense,array,16u>,config2>' to 'dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s'.\n", + "WARNING: [SYN 201-103] Legalizing function name 'lif_neuron,array,16u>,config3>' to 'lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s'.\n", + "WARNING: [SYN 201-103] Legalizing function name 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config4>' to 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s'.\n", + "WARNING: [SYN 201-103] Legalizing function name 'dense,array,2u>,config4>' to 'dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s'.\n", + "WARNING: [SYN 201-223] Checking resource limit in 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config2>': cannot find any operation of 'mul'.\n", + "WARNING: [SYN 201-223] Checking resource limit in 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config4>': cannot find any operation of 'mul'.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-42] -- Implementing module 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [SCHED 204-11] Starting scheduling ...\n", + "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config2>'.\n", + "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config2>'\n", + "INFO: [SCHED 204-11] Finished scheduling.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.05 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.08 seconds; current allocated memory: 411.000 MB.\n", + "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", + "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", + "INFO: [BIND 205-101] Exploring resource sharing.\n", + "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Finished micro-architecture generation.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 411.000 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [SCHED 204-11] Starting scheduling ...\n", + "INFO: [SCHED 204-11] Finished scheduling.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 411.000 MB.\n", + "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", + "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", + "INFO: [BIND 205-101] Exploring resource sharing.\n", + "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Finished micro-architecture generation.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 411.000 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-42] -- Implementing module 'lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [SCHED 204-11] Starting scheduling ...\n", + "INFO: [SCHED 204-61] Pipelining function 'lif_neuron,array,16u>,config3>'.\n", + "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 2, function 'lif_neuron,array,16u>,config3>'\n", + "INFO: [SCHED 204-11] Finished scheduling.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.06 seconds. CPU system time: 0 seconds. Elapsed time: 0.06 seconds; current allocated memory: 412.020 MB.\n", + "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", + "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", + "INFO: [BIND 205-101] Exploring resource sharing.\n", + "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Finished micro-architecture generation.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 412.020 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-42] -- Implementing module 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [SCHED 204-11] Starting scheduling ...\n", + "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config4>'.\n", + "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config4>'\n", + "INFO: [SCHED 204-11] Finished scheduling.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.04 seconds; current allocated memory: 412.629 MB.\n", + "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", + "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", + "INFO: [BIND 205-101] Exploring resource sharing.\n", + "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Finished micro-architecture generation.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 412.801 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [SCHED 204-11] Starting scheduling ...\n", + "INFO: [SCHED 204-11] Finished scheduling.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.03 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.02 seconds; current allocated memory: 413.031 MB.\n", + "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", + "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", + "INFO: [BIND 205-101] Exploring resource sharing.\n", + "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Finished micro-architecture generation.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 413.160 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-42] -- Implementing module 'snn_test_lif' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [SCHED 204-11] Starting scheduling ...\n", + "INFO: [SCHED 204-11] Finished scheduling.\n", + "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer2_out (from dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_U0 to lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0) to 2 to improve performance and/or avoid deadlocks.\n", + "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer3_out (from lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0 to dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0) to 2 to improve performance and/or avoid deadlocks.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 413.457 MB.\n", + "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", + "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", + "INFO: [BIND 205-101] Exploring resource sharing.\n", + "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Finished micro-architecture generation.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 413.465 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 414.539 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0 seconds. Elapsed time: 0.06 seconds; current allocated memory: 416.477 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-10] -- Generating RTL for module 'lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_9' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_8' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_7' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_6' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_5' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_4' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_3' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_2' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_1' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'p_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0E_5' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'p_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0E_4' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'p_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0E_3' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'p_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0E_2' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'p_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0E_1' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'p_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0E' is power-on initialization.\n", + "INFO: [HLS 200-1030] Apply Unified Pipeline Control on module 'lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s' pipeline 'lif_neuron,array,16u>,config3>' pipeline type 'function pipeline'\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.08 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.08 seconds; current allocated memory: 418.840 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.07 seconds. CPU system time: 0 seconds. Elapsed time: 0.09 seconds; current allocated memory: 423.156 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.05 seconds; current allocated memory: 425.211 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-10] -- Generating RTL for module 'snn_test_lif' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "WARNING: [RTGEN 206-101] Design contains AXI ports. Reset is fixed to synchronous and active low.\n", + "INFO: [RTGEN 206-500] Setting interface mode on port 'snn_test_lif/x' to 'axis' (register, both mode).\n", + "INFO: [RTGEN 206-500] Setting interface mode on port 'snn_test_lif/layer4_out' to 'axis' (register, both mode).\n", + "INFO: [RTGEN 206-500] Setting interface mode on function 'snn_test_lif' to 'ap_ctrl_hs'.\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'snn_test_lif'.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'layer2_out_U(snn_test_lif_fifo_w64_d1_S)' using Shift Registers.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'layer3_out_U(snn_test_lif_fifo_w64_d1_S)' using Shift Registers.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0_U(snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0)' using Shift Registers.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0_U(snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0)' using Shift Registers.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.07 seconds; current allocated memory: 426.281 MB.\n", + "INFO: [HLS 200-111] Finished Generating all RTL models: CPU user time: 0.14 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.15 seconds; current allocated memory: 428.766 MB.\n", + "INFO: [HLS 200-111] Finished Updating report files: CPU user time: 0.22 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.24 seconds; current allocated memory: 433.898 MB.\n", + "INFO: [VHDL 208-304] Generating VHDL RTL for snn_test_lif.\n", + "INFO: [VLOG 209-307] Generating Verilog RTL for snn_test_lif.\n", + "INFO: [HLS 200-789] **** Estimated Fmax: 283.77 MHz\n", + "INFO: [HLS 200-2161] Finished Command csynth_design Elapsed time: 00:00:13; Allocated memory: 107.934 MB.\n", + "***** C/RTL SYNTHESIS COMPLETED IN 0h0m13s *****\n", + "***** C/RTL SIMULATION *****\n", + "INFO: [HLS 200-1510] Running: add_files -tb snn_test_lif_test.cpp -cflags -std=c++0x -DRTL_SIM \n", + "INFO: [HLS 200-10] Adding test bench file 'snn_test_lif_test.cpp' to the project\n", + "INFO: [HLS 200-1510] Running: cosim_design -trace_level all -setup \n", + "INFO: [COSIM 212-47] Using XSIM for RTL simulation.\n", + "INFO: [COSIM 212-14] Instrumenting C test bench ...\n", + " Build using \"/tools/Xilinx/Vitis_HLS/2024.1/vcxx/libexec/clang++\"\n", + " Compiling apatb_snn_test_lif.cpp\n", + " Compiling apatb_snn_test_lif_util.cpp\n", + " Compiling snn_test_lif.cpp_pre.cpp.tb.cpp\n", + " Compiling snn_test_lif_test.cpp_pre.cpp.tb.cpp\n", + " Compiling apatb_snn_test_lif_ir.ll\n", + " Generating cosim.tv.exe\n", + "INFO: [COSIM 212-302] Starting C TB testing ... \n", + "INFO: Unable to open input/predictions file, using default input.\n", + "-0.25 -0.25 \n", + "-0.25 -0.25 \n", + "-0.25 -1 \n", + "-0.25 -0.75 \n", + "-0.25 -0.25 \n", + "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", + "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", + "INFO: [COSIM 212-333] Generating C post check test bench ...\n", + "INFO: [COSIM 212-12] Generating RTL test bench ...\n", + "INFO: [COSIM 212-1] *** C/RTL co-simulation file generation completed. ***\n", + "INFO: [HLS 200-2161] Finished Command cosim_design Elapsed time: 00:00:11; Allocated memory: 11.672 MB.\n", + "INFO: [HLS 200-1510] Running: source /home/b/Physics/hls4ml/snn_test_lif/project.tcl\n", + "INFO: [HLS 200-1510] Running: source run_sim.tcl\n", + "INFO: [HLS 200-1510] Running: source check_sim.tcl\n", + "INFO: [HLS 200-1510] Running: source dataflow_monitor_API.tcl\n", + "INFO: [COSIM 212-302] Starting C TB testing ... \n", + "INFO: Unable to open input/predictions file, using default input.\n", + "-0.25 -0.25 \n", + "-0.25 -0.25 \n", + "-0.25 -1 \n", + "-0.25 -0.75 \n", + "-0.25 -0.25 \n", + "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", + "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", + "INFO: [COSIM 212-323] Starting verilog simulation...\n", + "INFO: [COSIM 212-15] Starting XSIM ...\n", + "Vivado Simulator v2024.1\n", + "Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", + "Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", + "Running: /tools/Xilinx/Vivado/2024.1/bin/unwrapped/lnx64.o/xelab xil_defaultlib.apatb_snn_test_lif_top glbl -Oenable_linking_all_libraries -prj snn_test_lif.prj -L smartconnect_v1_0 -L axi_protocol_checker_v1_1_12 -L axi_protocol_checker_v1_1_13 -L axis_protocol_checker_v1_1_11 -L axis_protocol_checker_v1_1_12 -L xil_defaultlib -L unisims_ver -L xpm -L floating_point_v7_0_23 -L floating_point_v7_1_18 --lib ieee_proposed=./ieee_proposed -s snn_test_lif -debug all \n", + "Multi-threading is on. Using 14 slave threads.\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/glbl.v\" into library work\n", + "INFO: [VRFC 10-311] analyzing module glbl\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif.autotb.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module apatb_snn_test_lif_top\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_fifo.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module fifo\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_axi_s_x.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_axi_s_x\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_axi_s_layer4_out.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_axi_s_layer4_out\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_deadlock_detection_unit.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_deadlock_detect_unit\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_deadlock_report_unit.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_deadlock_report_unit\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_deadlock_detector.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_deadlock_detector\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_deadlock_kernel_monitor_top.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_deadlock_kernel_monitor_top\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_deadlock_idx0_monitor.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_deadlock_idx0_monitor\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_test_lif\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_regslice_both.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_test_lif_regslice_both\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_fifo_w64_d1_S.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_test_lif_fifo_w64_d1_S\n", + "INFO: [VRFC 10-311] analyzing module snn_test_lif_fifo_w64_d1_S_ShiftReg\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0\n", + "INFO: [VRFC 10-311] analyzing module snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0_ShiftReg\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0\n", + "INFO: [VRFC 10-311] analyzing module snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0_ShiftReg\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/dataflow_monitor.sv\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module dataflow_monitor\n", + "Starting static elaboration\n", + "Pass Through NonSizing Optimizer\n", + "Completed static elaboration\n", + "Starting simulation data flow analysis\n", + "Completed simulation data flow analysis\n", + "Time Resolution for simulation is 1ps\n", + "Compiling package xil_defaultlib.$unit_dataflow_monitor_sv\n", + "Compiling module xil_defaultlib.snn_test_lif_dense_latency_wrapp...\n", + "Compiling module xil_defaultlib.snn_test_lif_regslice_both(DataW...\n", + "Compiling module xil_defaultlib.snn_test_lif_dense_array_ap_fixe...\n", + "Compiling module xil_defaultlib.snn_test_lif_lif_neuron_array_ap...\n", + "Compiling module xil_defaultlib.snn_test_lif_dense_latency_wrapp...\n", + "Compiling module xil_defaultlib.snn_test_lif_dense_array_ap_fixe...\n", + "Compiling module xil_defaultlib.snn_test_lif_fifo_w64_d1_S_Shift...\n", + "Compiling module xil_defaultlib.snn_test_lif_fifo_w64_d1_S_defau...\n", + "Compiling module xil_defaultlib.snn_test_lif_start_for_lif_neuro...\n", + "Compiling module xil_defaultlib.snn_test_lif_start_for_lif_neuro...\n", + "Compiling module xil_defaultlib.snn_test_lif_start_for_dense_arr...\n", + "Compiling module xil_defaultlib.snn_test_lif_start_for_dense_arr...\n", + "Compiling module xil_defaultlib.snn_test_lif\n", + "Compiling module xil_defaultlib.fifo(DEPTH=2,WIDTH=16)\n", + "Compiling module xil_defaultlib.AESL_axi_s_x\n", + "Compiling module xil_defaultlib.AESL_axi_s_layer4_out\n", + "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(PROC_N...\n", + "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(PROC_N...\n", + "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(PROC_N...\n", + "Compiling module xil_defaultlib.AESL_deadlock_report_unit(PROC_N...\n", + "Compiling module xil_defaultlib.AESL_deadlock_detector_2\n", + "Compiling module xil_defaultlib.AESL_deadlock_idx0_monitor\n", + "Compiling module xil_defaultlib.AESL_deadlock_kernel_monitor_top...\n", + "Compiling module xil_defaultlib.df_fifo_intf_default\n", + "Compiling module xil_defaultlib.df_process_intf_default\n", + "Compiling module xil_defaultlib.nodf_module_intf_default\n", + "Compiling module xil_defaultlib.dataflow_monitor_1\n", + "Compiling module xil_defaultlib.apatb_snn_test_lif_top\n", + "Compiling module work.glbl\n", + "Built simulation snapshot snn_test_lif\n", + "\n", + "****** xsim v2024.1 (64-bit)\n", + " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", + " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", + " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", + " **** Start of session at: Mon Apr 27 10:38:29 2026\n", + " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", + " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", + "\n", + "source xsim.dir/snn_test_lif/xsim_script.tcl\n", + "# xsim {snn_test_lif} -view {{snn_test_lif_dataflow_ana.wcfg}} -tclbatch {snn_test_lif.tcl} -protoinst {snn_test_lif.protoinst}\n", + "INFO: [Wavedata 42-565] Reading protoinst file snn_test_lif.protoinst\n", + "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_test_lif_top/AESL_inst_snn_test_lif//AESL_inst_snn_test_lif_activity\n", + "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0/dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0_activity\n", + "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_U0/dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_U0_activity\n", + "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0/lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0_activity\n", + "Time resolution is 1 ps\n", + "open_wave_config snn_test_lif_dataflow_ana.wcfg\n", + "source snn_test_lif.tcl\n", + "## set designtopgroup [add_wave_group \"Design Top Signals\"]\n", + "## set coutputgroup [add_wave_group \"C Outputs\" -into $designtopgroup]\n", + "## set return_group [add_wave_group return(axis) -into $coutputgroup]\n", + "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/layer4_out_TREADY -into $return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/layer4_out_TVALID -into $return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/layer4_out_TDATA -into $return_group -radix hex\n", + "## set cinputgroup [add_wave_group \"C Inputs\" -into $designtopgroup]\n", + "## set return_group [add_wave_group return(axis) -into $cinputgroup]\n", + "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/x_TREADY -into $return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/x_TVALID -into $return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/x_TDATA -into $return_group -radix hex\n", + "## set blocksiggroup [add_wave_group \"Block-level IO Handshake\" -into $designtopgroup]\n", + "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/ap_start -into $blocksiggroup\n", + "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/ap_done -into $blocksiggroup\n", + "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/ap_ready -into $blocksiggroup\n", + "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/ap_idle -into $blocksiggroup\n", + "## set resetgroup [add_wave_group \"Reset\" -into $designtopgroup]\n", + "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/ap_rst_n -into $resetgroup\n", + "## set clockgroup [add_wave_group \"Clock\" -into $designtopgroup]\n", + "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/ap_clk -into $clockgroup\n", + "## set testbenchgroup [add_wave_group \"Test Bench Signals\"]\n", + "## set tbinternalsiggroup [add_wave_group \"Internal Signals\" -into $testbenchgroup]\n", + "## set tb_simstatus_group [add_wave_group \"Simulation Status\" -into $tbinternalsiggroup]\n", + "## set tb_portdepth_group [add_wave_group \"Port Depth\" -into $tbinternalsiggroup]\n", + "## add_wave /apatb_snn_test_lif_top/AUTOTB_TRANSACTION_NUM -into $tb_simstatus_group -radix hex\n", + "## add_wave /apatb_snn_test_lif_top/ready_cnt -into $tb_simstatus_group -radix hex\n", + "## add_wave /apatb_snn_test_lif_top/done_cnt -into $tb_simstatus_group -radix hex\n", + "## add_wave /apatb_snn_test_lif_top/LENGTH_layer4_out -into $tb_portdepth_group -radix hex\n", + "## add_wave /apatb_snn_test_lif_top/LENGTH_x -into $tb_portdepth_group -radix hex\n", + "## set tbcoutputgroup [add_wave_group \"C Outputs\" -into $testbenchgroup]\n", + "## set tb_return_group [add_wave_group return(axis) -into $tbcoutputgroup]\n", + "## add_wave /apatb_snn_test_lif_top/layer4_out_TREADY -into $tb_return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_test_lif_top/layer4_out_TVALID -into $tb_return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_test_lif_top/layer4_out_TDATA -into $tb_return_group -radix hex\n", + "## set tbcinputgroup [add_wave_group \"C Inputs\" -into $testbenchgroup]\n", + "## set tb_return_group [add_wave_group return(axis) -into $tbcinputgroup]\n", + "## add_wave /apatb_snn_test_lif_top/x_TREADY -into $tb_return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_test_lif_top/x_TVALID -into $tb_return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_test_lif_top/x_TDATA -into $tb_return_group -radix hex\n", + "## save_wave_config snn_test_lif.wcfg\n", + "## run all\n", + "////////////////////////////////////////////////////////////////////////////////////\n", + "// Inter-Transaction Progress: Completed Transaction / Total Transaction\n", + "// Intra-Transaction Progress: Measured Latency / Latency Estimation * 100%\n", + "//\n", + "// RTL Simulation : \"Inter-Transaction Progress\" [\"Intra-Transaction Progress\"] @ \"Simulation Time\"\n", + "////////////////////////////////////////////////////////////////////////////////////\n", + "// RTL Simulation : 0 / 5 [0.00%] @ \"113000\"\n", + "// RTL Simulation : 1 / 5 [83.33%] @ \"163000\"\n", + "// RTL Simulation : 2 / 5 [100.00%] @ \"178000\"\n", + "// RTL Simulation : 3 / 5 [116.67%] @ \"193000\"\n", + "// RTL Simulation : 4 / 5 [100.00%] @ \"208000\"\n", + "// RTL Simulation : 5 / 5 [100.00%] @ \"223000\"\n", + "////////////////////////////////////////////////////////////////////////////////////\n", + "$finish called at time : 252500 ps : File \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif.autotb.v\" Line 249\n", + "## quit\n", + "INFO: [Common 17-206] Exiting xsim at Mon Apr 27 10:38:31 2026...\n", + "WARNING: [HLS 200-2011] Cannot find the 'zip' utility on this system. This is required for cosimulation.\n", + "INFO: [COSIM 212-316] Starting C post checking ...\n", + "INFO: Unable to open input/predictions file, using default input.\n", + "-0.25 -0.25 \n", + "-0.25 -0.25 \n", + "-0.25 -1 \n", + "-0.25 -0.75 \n", + "-0.25 -0.25 \n", + "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", + "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", + "INFO:\n", + "Report time : Mon Apr 27 10:38:24 AM IST 2026.\n", + "Solution : solution1.\n", + "Simulation tool : xsim.\n", + "\n", + "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", + "| | | Latency(Clock Cycles) | Interval(Clock Cycles) | Total Execution Time |\n", + "+ RTL + Status +-----------------------------------------------+-----------------------------------------------+ (Clock Cycles) +\n", + "| | | min | avg | max | min | avg | max | |\n", + "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", + "| VHDL| NA| NA| NA| NA| NA| NA| NA| NA|\n", + "| Verilog| Pass| NA| NA| NA| NA| NA| NA| NA|\n", + "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", + "\n", + "***** C/RTL SIMULATION COMPLETED IN 0h0m19s *****\n", + "***** C/RTL VALIDATION *****\n", + "INFO: Test PASSED\n", + "***** EXPORT IP *****\n", + "INFO: [HLS 200-1510] Running: export_design -format ip_catalog -version 1.0.0 \n", + "INFO: [IMPL 213-8] Exporting RTL as a Vivado IP.\n", + "\n", + "****** Vivado v2024.1 (64-bit)\n", + " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", + " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", + " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", + " **** Start of session at: Mon Apr 27 10:38:33 2026\n", + " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", + " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", + "\n", + "source run_ippack.tcl -notrace\n", + "INFO: calling package_hls_ip ip_types=vitis sysgen json_file=/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/solution1_data.json outdir=/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip srcdir=/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1 sort_interfaces_ports=false\n", + "INFO: Copied 1 ipmisc file(s) to /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip/misc\n", + "INFO: Copied 15 verilog file(s) to /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip/hdl/verilog\n", + "INFO: Copied 10 vhdl file(s) to /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip/hdl/vhdl\n", + "INFO: Import ports from HDL: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip/hdl/vhdl/snn_test_lif.vhd (snn_test_lif)\n", + "INFO: Add axi4stream interface x\n", + "INFO: Add axi4stream interface layer4_out\n", + "INFO: [IP_Flow 19-234] Refreshing IP repositories\n", + "INFO: [IP_Flow 19-1704] No user IP repositories specified\n", + "INFO: [IP_Flow 19-2313] Loaded Vivado IP repository '/tools/Xilinx/Vivado/2024.1/data/ip'.\n", + "INFO: Add clock interface ap_clk\n", + "INFO: Add reset interface ap_rst_n\n", + "INFO: Add ap_ctrl interface ap_ctrl\n", + "INFO: Calling post_process_vitis to specialize IP\n", + "INFO: Calling post_process_sysgen to specialize IP\n", + "Generating sysgen info xml from json file\n", + "INFO: Created IP /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip/component.xml\n", + "INFO: Created IP archive /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip/xilinx_com_hls_snn_test_lif_1_0.zip\n", + "INFO: [Common 17-206] Exiting Vivado at Mon Apr 27 10:38:39 2026...\n", + "INFO: [HLS 200-802] Generated output file snn_test_lif_prj/solution1/impl/export.zip\n", + "INFO: [HLS 200-2161] Finished Command export_design Elapsed time: 00:00:17; Allocated memory: 0.000 MB.\n", + "***** EXPORT IP COMPLETED IN 0h0m17s *****\n", + "***** VIVADO SYNTHESIS *****\n", + "\n", + "****** Vivado v2024.1 (64-bit)\n", + " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", + " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", + " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", + " **** Start of session at: Mon Apr 27 10:38:50 2026\n", + " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", + " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", + "\n", + "source vivado_synth.tcl\n", + "# set tcldir [file dirname [info script]]\n", + "# source [file join $tcldir project.tcl]\n", + "## variable project_name\n", + "## set project_name \"snn_test_lif\"\n", + "## variable backend\n", + "## set backend \"vitis\"\n", + "## variable part\n", + "## set part \"xczu7ev-ffvc1156-2-e\"\n", + "## variable clock_period\n", + "## set clock_period 5\n", + "## variable clock_uncertainty\n", + "## set clock_uncertainty 27%\n", + "## variable version\n", + "## set version \"1.0.0\"\n", + "## variable maximum_size\n", + "## set maximum_size 4096\n", + "# add_files ${project_name}_prj/solution1/syn/verilog\n", + "# synth_design -top ${project_name} -part $part\n", + "Command: synth_design -top snn_test_lif -part xczu7ev-ffvc1156-2-e\n", + "Starting synth_design\n", + "Attempting to get a license for feature 'Synthesis' and/or device 'xczu7ev'\n", + "INFO: [Common 17-349] Got license for feature 'Synthesis' and/or device 'xczu7ev'\n", + "INFO: [Synth 8-7079] Multithreading enabled for synth_design using a maximum of 4 processes.\n", + "INFO: [Synth 8-7078] Launching helper process for spawning children vivado processes\n", + "INFO: [Synth 8-7075] Helper process launched with PID 13247\n", + "---------------------------------------------------------------------------------\n", + "Starting Synthesize : Time (s): cpu = 00:00:02 ; elapsed = 00:00:03 . Memory (MB): peak = 1875.809 ; gain = 425.641 ; free physical = 1408 ; free virtual = 25077\n", + "---------------------------------------------------------------------------------\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s.v:9]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_regslice_both' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_regslice_both.v:9]\n", + "\tParameter DataWidth bound to: 16 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_regslice_both' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_regslice_both.v:9]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s.v:9]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s.v:9]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s.v:9]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_fifo_w64_d1_S' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_fifo_w64_d1_S.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_fifo_w64_d1_S_ShiftReg' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_fifo_w64_d1_S.v:129]\n", + "\tParameter DATA_WIDTH bound to: 64 - type: integer \n", + "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", + "\tParameter DEPTH bound to: 1 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_fifo_w64_d1_S_ShiftReg' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_fifo_w64_d1_S.v:129]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_fifo_w64_d1_S' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_fifo_w64_d1_S.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0_ShiftReg' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0.v:125]\n", + "\tParameter DATA_WIDTH bound to: 1 - type: integer \n", + "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", + "\tParameter DEPTH bound to: 2 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0.v:125]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0_ShiftReg' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0.v:125]\n", + "\tParameter DATA_WIDTH bound to: 1 - type: integer \n", + "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", + "\tParameter DEPTH bound to: 2 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0.v:125]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0.v:11]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif.v:9]\n", + "WARNING: [Synth 8-7129] Port addr[0] in module snn_test_lif_fifo_w64_d1_S_ShiftReg is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port data_3_val3[1] in module snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port data_3_val3[0] in module snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port ap_rst in module snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_dout[59] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_dout[58] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_dout[57] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_dout[56] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_dout[47] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_dout[46] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_dout[45] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_dout[44] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_dout[3] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_dout[2] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_dout[1] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_dout[0] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port ap_rst in module snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s is either unconnected or has no load\n", + "---------------------------------------------------------------------------------\n", + "Finished Synthesize : Time (s): cpu = 00:00:03 ; elapsed = 00:00:04 . Memory (MB): peak = 1956.777 ; gain = 506.609 ; free physical = 1309 ; free virtual = 24981\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Constraint Validation : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1971.621 ; gain = 521.453 ; free physical = 1300 ; free virtual = 24973\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Loading Part and Timing Information\n", + "---------------------------------------------------------------------------------\n", + "Loading part: xczu7ev-ffvc1156-2-e\n", + "INFO: [Synth 8-6742] Reading net delay rules and data\n", + "INFO: [Device 21-403] Loading part xczu7ev-ffvc1156-2-e\n", + "---------------------------------------------------------------------------------\n", + "Finished Loading Part and Timing Information : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1988.531 ; gain = 538.363 ; free physical = 1296 ; free virtual = 24969\n", + "---------------------------------------------------------------------------------\n", + "INFO: [Synth 8-802] inferred FSM for state register 'state_reg' in module 'snn_test_lif_regslice_both'\n", + "INFO: [Synth 8-4490] FSM extraction disabled for register 'ap_CS_fsm_reg' through user attribute\n", + "INFO: [Synth 8-4490] FSM extraction disabled for register 'ap_CS_fsm_reg' through user attribute\n", + "---------------------------------------------------------------------------------------------------\n", + " State | New Encoding | Previous Encoding \n", + "---------------------------------------------------------------------------------------------------\n", + " ZERO | 00 | 10\n", + " ONE | 10 | 11\n", + " TWO | 01 | 01\n", + "---------------------------------------------------------------------------------------------------\n", + "INFO: [Synth 8-3354] encoded FSM with state register 'state_reg' using encoding 'sequential' in module 'snn_test_lif_regslice_both'\n", + "---------------------------------------------------------------------------------\n", + "Finished RTL Optimization Phase 2 : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1988.531 ; gain = 538.363 ; free physical = 1288 ; free virtual = 24962\n", + "---------------------------------------------------------------------------------\n", + "No constraint files found.\n", + "---------------------------------------------------------------------------------\n", + "Start RTL Component Statistics \n", + "---------------------------------------------------------------------------------\n", + "Detailed RTL Component Info : \n", + "+---Adders : \n", + "\t 3 Input 6 Bit Adders := 2 \n", + "\t 4 Input 6 Bit Adders := 16 \n", + "\t 3 Input 4 Bit Adders := 8 \n", + "\t 2 Input 4 Bit Adders := 22 \n", + "\t 7 Input 4 Bit Adders := 1 \n", + "\t 10 Input 4 Bit Adders := 1 \n", + "\t 2 Input 3 Bit Adders := 4 \n", + "\t 2 Input 2 Bit Adders := 4 \n", + "\t 2 Input 1 Bit Adders := 4 \n", + "+---Registers : \n", + "\t 64 Bit Registers := 2 \n", + "\t 16 Bit Registers := 4 \n", + "\t 4 Bit Registers := 60 \n", + "\t 3 Bit Registers := 1 \n", + "\t 2 Bit Registers := 7 \n", + "\t 1 Bit Registers := 25 \n", + "+---Muxes : \n", + "\t 2 Input 16 Bit Muxes := 2 \n", + "\t 5 Input 3 Bit Muxes := 1 \n", + "\t 2 Input 3 Bit Muxes := 1 \n", + "\t 2 Input 2 Bit Muxes := 30 \n", + "\t 3 Input 2 Bit Muxes := 6 \n", + "\t 4 Input 2 Bit Muxes := 3 \n", + "\t 2 Input 1 Bit Muxes := 48 \n", + "---------------------------------------------------------------------------------\n", + "Finished RTL Component Statistics \n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Part Resource Summary\n", + "---------------------------------------------------------------------------------\n", + "Part Resources:\n", + "DSPs: 1728 (col length:144)\n", + "BRAMs: 624 (col length: RAMB18 144 RAMB36 72)\n", + "---------------------------------------------------------------------------------\n", + "Finished Part Resource Summary\n", + "---------------------------------------------------------------------------------\n", + "No constraint files found.\n", + "---------------------------------------------------------------------------------\n", + "Start Cross Boundary and Area Optimization\n", + "---------------------------------------------------------------------------------\n", + "WARNING: [Synth 8-7080] Parallel synthesis criteria is not met\n", + "WARNING: [Synth 8-3936] Found unconnected internal register 'dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_U0/regslice_both_x_U/data_p1_reg' and it is trimmed from '16' to '12' bits. [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_regslice_both.v:42]\n", + "WARNING: [Synth 8-3936] Found unconnected internal register 'dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_U0/regslice_both_x_U/data_p2_reg' and it is trimmed from '16' to '12' bits. [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_regslice_both.v:64]\n", + "WARNING: [Synth 8-7129] Port x_TDATA[15] in module snn_test_lif is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port x_TDATA[14] in module snn_test_lif is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port x_TDATA[13] in module snn_test_lif is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port x_TDATA[12] in module snn_test_lif is either unconnected or has no load\n", + "---------------------------------------------------------------------------------\n", + "Finished Cross Boundary and Area Optimization : Time (s): cpu = 00:00:09 ; elapsed = 00:00:09 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 393 ; free virtual = 24049\n", + "---------------------------------------------------------------------------------\n", + "No constraint files found.\n", + "---------------------------------------------------------------------------------\n", + "Start Timing Optimization\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Timing Optimization : Time (s): cpu = 00:00:09 ; elapsed = 00:00:10 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 393 ; free virtual = 24048\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Technology Mapping\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Technology Mapping : Time (s): cpu = 00:00:09 ; elapsed = 00:00:10 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 393 ; free virtual = 24046\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start IO Insertion\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Flattening Before IO Insertion\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Flattening Before IO Insertion\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Final Netlist Cleanup\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Final Netlist Cleanup\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished IO Insertion : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 396 ; free virtual = 24058\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Renaming Generated Instances\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Renaming Generated Instances : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 396 ; free virtual = 24059\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Rebuilding User Hierarchy\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Rebuilding User Hierarchy : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 396 ; free virtual = 24060\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Renaming Generated Ports\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Renaming Generated Ports : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 398 ; free virtual = 24062\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Handling Custom Attributes\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Handling Custom Attributes : Time (s): cpu = 00:00:12 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 398 ; free virtual = 24062\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Renaming Generated Nets\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Renaming Generated Nets : Time (s): cpu = 00:00:12 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 398 ; free virtual = 24062\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Writing Synthesis Report\n", + "---------------------------------------------------------------------------------\n", + "\n", + "Report BlackBoxes: \n", + "+-+--------------+----------+\n", + "| |BlackBox name |Instances |\n", + "+-+--------------+----------+\n", + "+-+--------------+----------+\n", + "\n", + "Report Cell Usage: \n", + "+------+------+------+\n", + "| |Cell |Count |\n", + "+------+------+------+\n", + "|1 |BUFG | 1|\n", + "|2 |LUT1 | 6|\n", + "|3 |LUT2 | 12|\n", + "|4 |LUT3 | 20|\n", + "|5 |LUT4 | 64|\n", + "|6 |LUT5 | 60|\n", + "|7 |LUT6 | 130|\n", + "|8 |MUXF7 | 4|\n", + "|9 |MUXF8 | 1|\n", + "|10 |FDRE | 274|\n", + "|11 |FDSE | 8|\n", + "|12 |IBUF | 13|\n", + "|13 |OBUF | 21|\n", + "+------+------+------+\n", + "\n", + "Report Instance Areas: \n", + "+------+------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------+------+\n", + "| |Instance |Module |Cells |\n", + "+------+------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------+------+\n", + "|1 |top | | 614|\n", + "|2 | dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0 |snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s | 98|\n", + "|3 | regslice_both_layer4_out_U |snn_test_lif_regslice_both_2 | 82|\n", + "|4 | dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_U0 |snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s | 179|\n", + "|5 | regslice_both_x_U |snn_test_lif_regslice_both | 127|\n", + "|6 | layer2_out_U |snn_test_lif_fifo_w64_d1_S | 54|\n", + "|7 | U_snn_test_lif_fifo_w64_d1_S_ShiftReg |snn_test_lif_fifo_w64_d1_S_ShiftReg_1 | 46|\n", + "|8 | layer3_out_U |snn_test_lif_fifo_w64_d1_S_0 | 21|\n", + "|9 | U_snn_test_lif_fifo_w64_d1_S_ShiftReg |snn_test_lif_fifo_w64_d1_S_ShiftReg | 13|\n", + "|10 | lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0 |snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s | 206|\n", + "|11 | start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0_U |snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0 | 11|\n", + "|12 | start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0_U |snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0 | 10|\n", + "+------+------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------+------+\n", + "---------------------------------------------------------------------------------\n", + "Finished Writing Synthesis Report : Time (s): cpu = 00:00:12 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 398 ; free virtual = 24062\n", + "---------------------------------------------------------------------------------\n", + "Synthesis finished with 0 errors, 0 critical warnings and 40 warnings.\n", + "Synthesis Optimization Runtime : Time (s): cpu = 00:00:12 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 397 ; free virtual = 24061\n", + "Synthesis Optimization Complete : Time (s): cpu = 00:00:12 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.570 ; gain = 1404.395 ; free physical = 397 ; free virtual = 24061\n", + "INFO: [Project 1-571] Translating synthesized netlist\n", + "Netlist sorting complete. Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 2854.570 ; gain = 0.000 ; free physical = 621 ; free virtual = 24280\n", + "INFO: [Netlist 29-17] Analyzing 19 Unisim elements for replacement\n", + "INFO: [Netlist 29-28] Unisim Transformation completed in 0 CPU seconds\n", + "INFO: [Project 1-570] Preparing netlist for logic optimization\n", + "INFO: [Opt 31-138] Pushed 0 inverter(s) to 0 load pin(s).\n", + "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 2910.590 ; gain = 0.000 ; free physical = 599 ; free virtual = 24238\n", + "INFO: [Project 1-111] Unisim Transformation Summary:\n", + " A total of 14 instances were transformed.\n", + " BUFG => BUFGCE: 1 instance \n", + " IBUF => IBUF (IBUFCTRL, INBUF): 13 instances\n", + "\n", + "Synth Design complete | Checksum: c630c992\n", + "INFO: [Common 17-83] Releasing license: Synthesis\n", + "43 Infos, 40 Warnings, 0 Critical Warnings and 0 Errors encountered.\n", + "synth_design completed successfully\n", + "synth_design: Time (s): cpu = 00:00:15 ; elapsed = 00:00:14 . Memory (MB): peak = 2910.590 ; gain = 1464.402 ; free physical = 599 ; free virtual = 24238\n", + "INFO: [Common 17-2834] synth_design peak Physical Memory [PSS] (MB): overall = 2666.062; main = 2397.660; forked = 449.381\n", + "INFO: [Common 17-2834] synth_design peak Virtual Memory [VSS] (MB): overall = 3881.023; main = 2910.594; forked = 1026.457\n", + "# opt_design -retarget -propconst -sweep -bram_power_opt -shift_register_opt\n", + "Command: opt_design -retarget -propconst -sweep -bram_power_opt -shift_register_opt\n", + "Attempting to get a license for feature 'Implementation' and/or device 'xczu7ev'\n", + "INFO: [Common 17-349] Got license for feature 'Implementation' and/or device 'xczu7ev'\n", + "Running DRC as a precondition to command opt_design\n", + "\n", + "Starting DRC Task\n", + "INFO: [DRC 23-27] Running DRC with 8 threads\n", + "INFO: [Project 1-461] DRC finished with 0 Errors\n", + "INFO: [Project 1-462] Please refer to the DRC report (report_drc) for more information.\n", + "\n", + "Time (s): cpu = 00:00:01 ; elapsed = 00:00:00.78 . Memory (MB): peak = 2974.621 ; gain = 64.031 ; free physical = 608 ; free virtual = 24261\n", + "\n", + "Starting Cache Timing Information Task\n", + "INFO: [Timing 38-35] Done setting XDC timing constraints.\n", + "Ending Cache Timing Information Task | Checksum: 21c8b40a4\n", + "\n", + "Time (s): cpu = 00:00:06 ; elapsed = 00:00:06 . Memory (MB): peak = 3521.754 ; gain = 547.133 ; free physical = 242 ; free virtual = 23904\n", + "\n", + "Starting Logic Optimization Task\n", + "\n", + "Phase 1 Initialization\n", + "\n", + "Phase 1.1 Core Generation And Design Setup\n", + "Phase 1.1 Core Generation And Design Setup | Checksum: 21c8b40a4\n", + "\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "\n", + "Phase 1.2 Setup Constraints And Sort Netlist\n", + "Phase 1.2 Setup Constraints And Sort Netlist | Checksum: 21c8b40a4\n", + "\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "Phase 1 Initialization | Checksum: 21c8b40a4\n", + "\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "\n", + "Phase 2 Timer Update And Timing Data Collection\n", + "\n", + "Phase 2.1 Timer Update\n", + "Phase 2.1 Timer Update | Checksum: 21c8b40a4\n", + "\n", + "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "\n", + "Phase 2.2 Timing Data Collection\n", + "Phase 2.2 Timing Data Collection | Checksum: 21c8b40a4\n", + "\n", + "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "Phase 2 Timer Update And Timing Data Collection | Checksum: 21c8b40a4\n", + "\n", + "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "\n", + "Phase 3 Retarget\n", + "INFO: [Opt 31-1834] Total Chains To Be Transformed Were: 0 AND Number of Transformed insts Created are: 0\n", + "INFO: [Opt 31-138] Pushed 1 inverter(s) to 34 load pin(s).\n", + "INFO: [Opt 31-49] Retargeted 0 cell(s).\n", + "Phase 3 Retarget | Checksum: 23dbf599f\n", + "\n", + "Time (s): cpu = 00:00:00.06 ; elapsed = 00:00:00.03 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "Retarget | Checksum: 23dbf599f\n", + "INFO: [Opt 31-389] Phase Retarget created 0 cells and removed 1 cells\n", + "\n", + "Phase 4 Constant propagation\n", + "INFO: [Opt 31-138] Pushed 0 inverter(s) to 0 load pin(s).\n", + "Phase 4 Constant propagation | Checksum: 23dbf599f\n", + "\n", + "Time (s): cpu = 00:00:00.07 ; elapsed = 00:00:00.03 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "Constant propagation | Checksum: 23dbf599f\n", + "INFO: [Opt 31-389] Phase Constant propagation created 0 cells and removed 0 cells\n", + "\n", + "Phase 5 Sweep\n", + "Phase 5 Sweep | Checksum: 23dbf599f\n", + "\n", + "Time (s): cpu = 00:00:00.07 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "Sweep | Checksum: 23dbf599f\n", + "INFO: [Opt 31-389] Phase Sweep created 0 cells and removed 0 cells\n", + "\n", + "Phase 6 Shift Register Optimization\n", + "INFO: [Opt 31-1064] SRL Remap converted 0 SRLs to 0 registers and converted 0 registers of register chains to 0 SRLs\n", + "Phase 6 Shift Register Optimization | Checksum: 23dbf599f\n", + "\n", + "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "Shift Register Optimization | Checksum: 23dbf599f\n", + "INFO: [Opt 31-389] Phase Shift Register Optimization created 0 cells and removed 0 cells\n", + "\n", + "Phase 7 Post Processing Netlist\n", + "Phase 7 Post Processing Netlist | Checksum: 23dbf599f\n", + "\n", + "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23672\n", + "Post Processing Netlist | Checksum: 23dbf599f\n", + "INFO: [Opt 31-389] Phase Post Processing Netlist created 0 cells and removed 0 cells\n", + "\n", + "Phase 8 Finalization\n", + "\n", + "Phase 8.1 Finalizing Design Cores and Updating Shapes\n", + "Phase 8.1 Finalizing Design Cores and Updating Shapes | Checksum: 23dbf599f\n", + "\n", + "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23672\n", + "\n", + "Phase 8.2 Verifying Netlist Connectivity\n", + "Phase 8.2 Verifying Netlist Connectivity | Checksum: 23dbf599f\n", + "\n", + "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23672\n", + "Phase 8 Finalization | Checksum: 23dbf599f\n", + "\n", + "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23672\n", + "Opt_design Change Summary\n", + "=========================\n", + "\n", + "\n", + "-------------------------------------------------------------------------------------------------------------------------\n", + "| Phase | #Cells created | #Cells Removed | #Constrained objects preventing optimizations |\n", + "-------------------------------------------------------------------------------------------------------------------------\n", + "| Retarget | 0 | 1 | 0 |\n", + "| Constant propagation | 0 | 0 | 0 |\n", + "| Sweep | 0 | 0 | 0 |\n", + "| Shift Register Optimization | 0 | 0 | 0 |\n", + "| Post Processing Netlist | 0 | 0 | 0 |\n", + "-------------------------------------------------------------------------------------------------------------------------\n", + "\n", + "\n", + "Ending Logic Optimization Task | Checksum: 23dbf599f\n", + "\n", + "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23672\n", + "\n", + "Starting Power Optimization Task\n", + "INFO: [Pwropt 34-132] Skipping clock gating for clocks with a period < 2.00 ns.\n", + "Ending Power Optimization Task | Checksum: 23dbf599f\n", + "\n", + "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 166 ; free virtual = 23670\n", + "\n", + "Starting Final Cleanup Task\n", + "Ending Final Cleanup Task | Checksum: 23dbf599f\n", + "\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 166 ; free virtual = 23670\n", + "\n", + "Starting Netlist Obfuscation Task\n", + "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 166 ; free virtual = 23670\n", + "Ending Netlist Obfuscation Task | Checksum: 23dbf599f\n", + "\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 166 ; free virtual = 23670\n", + "INFO: [Common 17-83] Releasing license: Implementation\n", + "17 Infos, 0 Warnings, 0 Critical Warnings and 0 Errors encountered.\n", + "opt_design completed successfully\n", + "opt_design: Time (s): cpu = 00:00:09 ; elapsed = 00:00:09 . Memory (MB): peak = 3790.660 ; gain = 880.070 ; free physical = 166 ; free virtual = 23670\n", + "# report_utilization -file vivado_synth.rpt\n", + "INFO: [Common 17-206] Exiting Vivado at Mon Apr 27 10:39:19 2026...\n", + "***** VIVADO SYNTHESIS COMPLETED IN 0h0m40s *****\n", + "INFO: [HLS 200-112] Total CPU user time: 72.55 seconds. Total CPU system time: 6.7 seconds. Total elapsed time: 98.26 seconds; peak allocated memory: 445.930 MB.\n", + "INFO: [vitis-run 60-791] Total elapsed time: 0h 1m 39s\n", + "INFO: [vitis-run 60-1662] Stopping dispatch session having empty uuid.\n", + "Implementation report not found.\n", + "Timing report not found.\n" + ] + }, + { + "data": { + "text/plain": [ + "{'CSimResults': [['-0.25', '-0.25'],\n", + " ['-0.25', '-0.25'],\n", + " ['-0.25', '-1'],\n", + " ['-0.25', '-0.75'],\n", + " ['-0.25', '-0.25']],\n", + " 'CosimResults': [['-0.25', '-0.25'],\n", + " ['-0.25', '-0.25'],\n", + " ['-0.25', '-1'],\n", + " ['-0.25', '-0.75'],\n", + " ['-0.25', '-0.25']],\n", + " 'CSynthesisReport': {'TargetClockPeriod': '5.00',\n", + " 'EstimatedClockPeriod': '3.524',\n", + " 'BestLatency': '6',\n", + " 'WorstLatency': '6',\n", + " 'IntervalMin': '3',\n", + " 'IntervalMax': '3',\n", + " 'FF': '450',\n", + " 'LUT': '1744',\n", + " 'BRAM_18K': '0',\n", + " 'DSP': '0',\n", + " 'URAM': '0',\n", + " 'AvailableBRAM_18K': '624',\n", + " 'AvailableDSP': '1728',\n", + " 'AvailableFF': '460800',\n", + " 'AvailableLUT': '230400',\n", + " 'AvailableURAM': '96'},\n", + " 'VivadoSynthReport': {'LUT': '238',\n", + " 'FF': '282',\n", + " 'BRAM_18K': '0',\n", + " 'URAM': '0',\n", + " 'DSP48E': '0'},\n", + " 'CosimReport': {'RTL': 'Verilog',\n", + " 'Status': 'Pass',\n", + " 'LatencyMin': 8,\n", + " 'LatencyMax': 10,\n", + " 'IntervalMin': 2,\n", + " 'IntervalMax': 4,\n", + " 'LatencyAvg': 8.8,\n", + " 'IntervalAvg': 2.75}}" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rname = 'snn_test_lif'\n", + "output_dir = Path(rname)\n", + "backend = 'Vitis'\n", + "\n", + "# optional load model weights instead\n", + "#torch.save(single_step_model.state_dict(), output_dir / \"model_weights.pt\")\n", + "#state_dict = torch.load(output_dir / \"model_weights.pt\")\n", + "#single_step_model.load_state_dict(state_dict)\n", + "#single_step_model.eval()\n", + "\n", + "# create savedir\n", + "output_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + "# set variable for precision\n", + "q4 = 'ap_fixed<4,2>'\n", + "\n", + "# build the initial per-layer config\n", + "hls_config = hls4ml.utils.config_from_pytorch_model(\n", + " single_step_model, # model we are converting\n", + " input_shape=(2,), # one timestep input shape\n", + " granularity='name', # create entries per layer name\n", + " backend=backend, # use specified backend, vitis/vivado\n", + " default_precision=q4, # default weight precision\n", + ")\n", + "\n", + "# set reuse factor\n", + "hls_config['Model']['ReuseFactor'] = 1\n", + "\n", + "# quantizing all model variables\n", + "hls_config['Model']['Precision']['default'] = q4\n", + "for _, layer_cfg in hls_config.get('LayerName', {}).items():\n", + " prec = layer_cfg.setdefault('Precision', {})\n", + " prec['result'] = q4\n", + " prec['accum'] = q4\n", + " prec['weight'] = q4\n", + " prec['bias'] = q4\n", + "\n", + "# convert to hls4ml Model Graph\n", + "hls_model = hls4ml.converters.convert_from_pytorch_model(\n", + " single_step_model, # model we are converting\n", + " output_dir=str(output_dir), # where we save the model\n", + " project_name=rname, # project name\n", + " backend=backend, # vitis/vivado\n", + " io_type='io_stream', # io_stream or io_parallel\n", + " #io_type='io_parallel', \n", + " hls_config=hls_config, # the config from above\n", + " part=\"xczu7ev-ffvc1156-2-e\", # set your FPGA part\n", + " clock_period=5, # clock period in nanoseconds\n", + " clock_uncertainty=\"27%\", # clock uncertainty\n", + ")\n", + "# writes c++/headers/tcl/project files to disk\n", + "hls_model.write()\n", + "\n", + "# check it all exists\n", + "hls_cpp = output_dir / 'firmware' / Path( rname + '.cpp' )\n", + "if not hls_cpp.exists():\n", + " raise RuntimeError(f'Expected generated HLS source missing: {hls_cpp}')\n", + "\n", + "# print result\n", + "print(f'Generated HLS project at: {output_dir}')\n", + "print(f'Generated top file: {hls_cpp}')\n", + "\n", + "# build and get vitis report\n", + "rep = hls_model.build(\n", + " reset=True,\n", + " csim=True,\n", + " synth=True,\n", + " cosim=True,\n", + " validation=True,\n", + " export=True,\n", + " vsynth=True,\n", + ")\n", + "rep" + ] + }, + { + "cell_type": "markdown", + "id": "399e5116-a303-4824-858a-c822d579865e", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## run neurobench" + ] + }, + { + "cell_type": "markdown", + "id": "a6843c36-d9de-4129-ba31-412077693113", + "metadata": {}, + "source": [ + "set up the model for neurobench" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "bbe8aea9-4506-4ddc-b7d0-decb42302345", + "metadata": {}, + "outputs": [], + "source": [ + "test_loader = DataLoader(\n", + " TensorDataset(x.float(), y.long()),\n", + " batch_size=64,\n", + " shuffle=False,\n", + ")\n", + "\n", + "single_step_model.eval()\n", + "\n", + "nb_model = SNNTorchModel(single_step_model)" + ] + }, + { + "cell_type": "markdown", + "id": "065b22e1-6f3c-4fe6-aa60-0b464d8735c4", + "metadata": {}, + "source": [ + "define preprocessing, postprocessing, and metrics for neurobench to track" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "df860349-1bae-4238-984e-ed06a69f8111", + "metadata": {}, + "outputs": [], + "source": [ + "class ArgmaxLogits:\n", + " def __call__(self, preds):\n", + " return preds.sum(dim=1).argmax(dim=1)\n", + "\n", + "preprocessors = []\n", + "postprocessors = [ArgmaxLogits()]\n", + "\n", + "static_metrics = [\n", + " Footprint,\n", + " ConnectionSparsity,\n", + "]\n", + "\n", + "workload_metrics = [\n", + " ClassificationAccuracy,\n", + " ActivationSparsity,\n", + " SynapticOperations,\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "9c6323c4-9a5a-465e-b6bf-a6936a861cfa", + "metadata": {}, + "source": [ + "run the benchmark" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "654390ad-9ab8-44db-bada-3be720edfe5b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running benchmark\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 105.50it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Footprint': 860, 'ConnectionSparsity': 0.0, 'ClassificationAccuracy': 0.93, 'ActivationSparsity': 0.84065625, 'SynapticOperations': {'Effective_MACs': 320.0, 'Effective_ACs': 50.99, 'Dense': 640.0}}\n", + "Results saved to snn_test_lif/neurobench_results.json\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "rname = 'snn_test_lif'\n", + "output_dir = Path(rname)\n", + "\n", + "benchmark = Benchmark(\n", + " nb_model,\n", + " test_loader,\n", + " preprocessors,\n", + " postprocessors,\n", + " [static_metrics, workload_metrics],\n", + ")\n", + "\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "results = benchmark.run(device=device)\n", + "print(results)\n", + "\n", + "benchmark.save_benchmark_results(output_dir / \"neurobench_results\", file_format=\"json\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "080b4a2c-d6ff-433a-8d8e-f8e7fdc575db", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From f77951546d5ca312f9d0e09047995f8e79fcbb6b Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 27 Apr 2026 11:16:40 +0100 Subject: [PATCH 03/32] updates to readme --- README.md | 189 +++------------------------------------ requirements-snn-dev.txt | 6 ++ 2 files changed, 19 insertions(+), 176 deletions(-) diff --git a/README.md b/README.md index f49fe76d36..031f7c1bed 100644 --- a/README.md +++ b/README.md @@ -1,188 +1,25 @@ -

- hls4ml -

+# hls4snn -[![DOI](https://zenodo.org/badge/108329371.svg)](https://zenodo.org/badge/latestdoi/108329371) -[![License](https://img.shields.io/badge/License-Apache_2.0-red.svg)](https://opensource.org/licenses/Apache-2.0) -[![Documentation Status](https://github.com/fastmachinelearning/hls4ml/actions/workflows/build-sphinx.yml/badge.svg)](https://fastmachinelearning.org/hls4ml) -[![PyPI version](https://badge.fury.io/py/hls4ml.svg)](https://badge.fury.io/py/hls4ml) -[![Downloads](https://static.pepy.tech/personalized-badge/hls4ml?period=total&units=international_system&left_color=grey&right_color=orange&left_text=Downloads)](https://pepy.tech/project/hls4ml) -conda-forge +`hls4snn` is a fork of `hls4ml` focused on spiking neural network (SNN) functionality in the PyTorch frontend, while keeping the upstream `hls4ml` workflow and documentation structure. -A package for machine learning inference in FPGAs. We create firmware implementations of machine learning algorithms using high level synthesis language (HLS). We translate traditional open-source machine learning package models into HLS that can be configured for your use-case! +## What's Different In This Fork -hls4ml is designed for ultra-low-latency inference on FPGAs. While it has strong roots in high-energy physics applications (e.g., L1 trigger systems at the CERN Large Hadron Collider), it has also been adopted across diverse scientific and industrial domains. Example use cases include control systems for quantum computing, feedback loops in nuclear fusion, low-power environmental monitoring on satellites, and biomedical signal processing (e.g., arrhythmia classification). +- Added initial SNN conversion support for PyTorch models using `snntorch` modules. +- Added SNN neuron/readout templates and related conversion backend plumbing. +- Added SNN-focused tests and documentation. +## SNN Quick Start -If you have any questions, comments, or ideas regarding hls4ml or just want to show us how you use hls4ml, don't hesitate to reach us through the [discussions](https://github.com/fastmachinelearning/hls4ml/discussions) tab. - -# Documentation & Tutorial - -For more information visit the webpage: [https://fastmachinelearning.org/hls4ml/](https://fastmachinelearning.org/hls4ml/). - -For introductory material on FPGAs, HLS and ML inferences using hls4ml, check out the [video](https://www.youtube.com/watch?v=2y3GNY4tf7A&ab_channel=SystemsGroupatETHZ%C3%BCrich). - -Detailed tutorials on how to use `hls4ml`'s various functionalities can be found [here](https://github.com/hls-fpga-machine-learning/hls4ml-tutorial). - -# Installation -```bash -pip install hls4ml -``` - -To install the extra dependencies for profiling: +Install SNN development dependencies from this repository: ```bash -pip install hls4ml[profiling] -``` - -# Getting Started -### Creating an HLS project -```Python -import hls4ml - -# Fetch a keras model from our example repository -# This will download our example model to your working directory and return an example configuration file -config = hls4ml.utils.fetch_example_model('KERAS_3layer.json') - -# You can print the configuration to see some default parameters -print(config) - -# Convert it to a hls project -hls_model = hls4ml.converters.keras_v2_to_hls(config) - -# Print full list of example models if you want to explore more -hls4ml.utils.fetch_example_list() +pip install -r requirements-snn-dev.txt ``` -### Building a project. -We will build the project using Xilinx Vivado HLS, which can be downloaded and installed from [here](https://www.xilinx.com/products/design-tools/vivado/integration/esl-design.html). Alongside Vivado HLS, hls4ml also supports Vitis HLS, Intel HLS, Catapult HLS and has some experimental support dor Intel oneAPI. The target back-end can be changed using the argument backend when building the model. - -```Python -# Use Vivado HLS to synthesize the model -# This might take several minutes -hls_model.build() - -# Print out the report if you want -hls4ml.report.read_vivado_report('my-hls-test') -``` - -# FAQ - -List of frequently asked questions and common HLS synthesis can be found [here](https://fastmachinelearning.org/hls4ml/intro/faq.html) - -# Citation -If you use this software in a publication, please cite the software -```bibtex -@software{fastml_hls4ml, - author = {{FastML Team}}, - title = {fastmachinelearning/hls4ml}, - year = 2025, - publisher = {Zenodo}, - version = {v1.3.0}, - doi = {10.5281/zenodo.1201549}, - url = {https://github.com/fastmachinelearning/hls4ml} -} -``` -the first publication: -```bibtex -@article{Duarte:2018ite, - author = "Duarte, Javier and others", - title = "{Fast inference of deep neural networks in FPGAs for particle physics}", - eprint = "1804.06913", - archivePrefix = "arXiv", - primaryClass = "physics.ins-det", - reportNumber = "FERMILAB-PUB-18-089-E", - doi = "10.1088/1748-0221/13/07/P07027", - journal = "JINST", - volume = "13", - number = "07", - pages = "P07027", - year = "2018" -} -``` -and the latest overview paper: -```bibtex -@article{Schulte:2025mai, - author = "Schulte, Jan-Frederik and others", - title = "{hls4ml: A Flexible, Open-Source Platform for Deep Learning Acceleration on Reconfigurable Hardware}", - eprint = "2512.01463", - archivePrefix = "arXiv", - primaryClass = "cs.AR", - reportNumber = "FERMILAB-PUB-25-0890-CSAID-ETD-PPD", - month = "12", - year = "2025" -} -``` - -Additionally, if you use specific features developed in later papers, please cite those as well. For example, CNNs: -```bibtex -@article{Aarrestad:2021zos, - author = "Aarrestad, Thea and others", - title = "{Fast convolutional neural networks on FPGAs with hls4ml}", - eprint = "2101.05108", - archivePrefix = "arXiv", - primaryClass = "cs.LG", - reportNumber = "FERMILAB-PUB-21-130-SCD", - doi = "10.1088/2632-2153/ac0ea1", - journal = "Mach. Learn. Sci. Tech.", - volume = "2", - number = "4", - pages = "045015", - year = "2021" -} -@article{Ghielmetti:2022ndm, - author = "Ghielmetti, Nicol\`{o} and others", - title = "{Real-time semantic segmentation on FPGAs for autonomous vehicles with hls4ml}", - eprint = "2205.07690", - archivePrefix = "arXiv", - primaryClass = "cs.CV", - reportNumber = "FERMILAB-PUB-22-435-PPD", - doi = "10.1088/2632-2153/ac9cb5", - journal ="Mach. Learn. Sci. Tech.", - year = "2022" -} -``` -Distributed arithmetic: -```bibtex -@misc{Sun:2025, - title={da4ml: Distributed Arithmetic for Real-time Neural Networks on FPGAs}, - author={Chang Sun and others}, - year={2025}, - eprint={2507.04535}, - archivePrefix={arXiv}, - primaryClass={cs.AR}, - url={https://arxiv.org/abs/2507.04535}, -} -``` -binary/ternary networks: -```bibtex -@article{Loncar:2020hqp, - author = "Ngadiuba, Jennifer and others", - title = "{Compressing deep neural networks on FPGAs to binary and ternary precision with HLS4ML}", - eprint = "2003.06308", - archivePrefix = "arXiv", - primaryClass = "cs.LG", - reportNumber = "FERMILAB-PUB-20-167-PPD-SCD", - doi = "10.1088/2632-2153/aba042", - journal = "Mach. Learn. Sci. Tech.", - volume = "2", - pages = "015001", - year = "2021" -} -``` +SNN feature details, supported modules, and behavior notes are documented in: -# Acknowledgments -If you benefited from participating in our community, we ask that you please acknowledge the Fast Machine Learning collaboration, and particular individuals who helped you, in any publications. -Please use the following text for this acknowledgment: - > We acknowledge the Fast Machine Learning collective as an open community of multi-domain experts and collaborators. This community and \, in particular, were important for the development of this project. +- [docs/advanced/snn.rst](docs/advanced/snn.rst) -# Funding -We gratefully acknowledge previous and current support from the U.S. National Science Foundation (NSF) Harnessing the Data Revolution (HDR) Institute for Accelerating AI Algorithms for Data Driven Discovery (A3D3) under Cooperative Agreement No. PHY-2117997, U.S. Department of Energy (DOE) Office of Science, Office of Advanced Scientific Computing Research under the Real‐time Data Reduction Codesign at the Extreme Edge for Science (XDR) Project (DE-FOA-0002501), DOE Office of Science, Office of High Energy Physics Early Career Research Program (DE-SC0021187, DE-0000247070), the European Research Council (ERC) under the European Union's Horizon 2020 research and innovation program (Grant No. 772369 and 966696), and the Eric & Wendy Schmidt Fund for Strategic Innovation through the CERN Next Generation Triggers project under grant agreement number SIF-2023-004. +A demo of the SNN functionality + neurobench is in: -

-A3D3 -NSF -DOE -ERC -NGT -

+- [hls4snn-demo.ipynb](hls4snn-demo.ipynb) diff --git a/requirements-snn-dev.txt b/requirements-snn-dev.txt index c034b61503..0645bd959f 100644 --- a/requirements-snn-dev.txt +++ b/requirements-snn-dev.txt @@ -10,3 +10,9 @@ # SNN training package used upstream in this workflow snntorch + +# SNN benchmarking package +neurobench + +# Used by the SNN example notebooks/plots +matplotlib From 4c6b30add38f67cddbb22580a5cc5de11086c40f Mon Sep 17 00:00:00 2001 From: Barry Dillon <77981701+bmdillon@users.noreply.github.com> Date: Mon, 27 Apr 2026 11:33:18 +0100 Subject: [PATCH 04/32] Update README.md --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 031f7c1bed..5a402af514 100644 --- a/README.md +++ b/README.md @@ -23,3 +23,5 @@ SNN feature details, supported modules, and behavior notes are documented in: A demo of the SNN functionality + neurobench is in: - [hls4snn-demo.ipynb](hls4snn-demo.ipynb) + +This takes you from building and training a simple SNN in snntorch, to running it through hls4ml and getting Vitis reports, and lastly running the model through neurobench to get SNN-specific metrics. From 415123101428515f15dd678db40e45736c8f158b Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 4 May 2026 18:44:43 +0100 Subject: [PATCH 05/32] add learnable beta and threhold functionality --- .gitignore | 3 + docs/advanced/snn.rst | 11 +- .../backends/vivado/passes/snn_templates.py | 22 +- hls4ml/converters/pytorch/snn.py | 70 +- hls4ml/model/layers.py | 55 + .../vivado/nnet_utils/nnet_if_neuron.h | 35 +- .../vivado/nnet_utils/nnet_lif_neuron.h | 43 +- hls4snn-demo.ipynb | 1958 +++++++++-------- test/pytest/test_snn_pytorch.py | 158 ++ 9 files changed, 1416 insertions(+), 939 deletions(-) diff --git a/.gitignore b/.gitignore index 83ed4bb462..1a771cac6c 100644 --- a/.gitignore +++ b/.gitignore @@ -19,4 +19,7 @@ hls4mlprj_* .pytest_cache/ *.ipynb snn_test_lif/ +snn_smoke* +examples/snn_* FPGAs_AdaptiveSoCs_Unified_2024.1_0522_2023_Lin64.bin +_ignore_* diff --git a/docs/advanced/snn.rst b/docs/advanced/snn.rst index df9109c5e1..7fc56bf551 100644 --- a/docs/advanced/snn.rst +++ b/docs/advanced/snn.rst @@ -32,7 +32,16 @@ For ``Leaky``, the supported reset mechanisms are: * ``subtract`` * ``zero`` -Only scalar ``threshold`` and scalar ``beta`` are currently supported. +``threshold`` supports scalar or per-neuron vectors (length ``n_out``) for both ``IFNeuron`` and ``LIFNeuron``. +``beta`` supports scalar or per-neuron vectors for ``LIFNeuron``. + +Conversion selects the most memory-efficient representation automatically: + +* scalar values are emitted as compile-time constants +* per-neuron values are emitted as parameter vectors + +For trainable snntorch parameters, conversion uses the current parameter values from the model +at conversion time. Readout and Decision Rules ========================== diff --git a/hls4ml/backends/vivado/passes/snn_templates.py b/hls4ml/backends/vivado/passes/snn_templates.py index 300d148bcf..b9269d1a0b 100644 --- a/hls4ml/backends/vivado/passes/snn_templates.py +++ b/hls4ml/backends/vivado/passes/snn_templates.py @@ -5,11 +5,14 @@ static const unsigned n_in = {n_in}; static const unsigned n_out = {n_out}; static const unsigned io_type = nnet::{iotype}; + static const bool threshold_is_vector = {threshold_is_vector}; static constexpr float threshold = {threshold}; static const nnet::snn_reset_mode reset_mode = nnet::snn_reset_mode::{reset_mechanism}; + typedef {threshold_t.name} threshold_t; + typedef {membrane_t.name} membrane_t; }};\n""" -if_function_template = 'nnet::if_neuron<{input_t}, {output_t}, {config}>({input}, {output});' +if_function_template = 'nnet::if_neuron<{input_t}, {output_t}, {config}>({input}, {output}, {threshold});' if_include_list = ['nnet_utils/nnet_if_neuron.h'] @@ -20,6 +23,7 @@ def __init__(self): def format(self, node): params = self._default_config_params(node) + params['threshold_is_vector'] = 'true' if node.get_attr('threshold_mode', 'scalar') == 'vector' else 'false' return self.template.format(**params) @@ -30,6 +34,9 @@ def __init__(self): def format(self, node): params = self._default_function_params(node) + params['threshold'] = ( + node.get_weights('threshold_vec').name if node.get_attr('threshold_mode', 'scalar') == 'vector' else 'nullptr' + ) return self.template.format(**params) @@ -37,12 +44,17 @@ def format(self, node): static const unsigned n_in = {n_in}; static const unsigned n_out = {n_out}; static const unsigned io_type = nnet::{iotype}; + static const bool beta_is_vector = {beta_is_vector}; + static const bool threshold_is_vector = {threshold_is_vector}; static constexpr float threshold = {threshold}; static constexpr float beta = {beta}; static const nnet::snn_reset_mode reset_mode = nnet::snn_reset_mode::{reset_mechanism}; + typedef {beta_t.name} beta_t; + typedef {threshold_t.name} threshold_t; + typedef {membrane_t.name} membrane_t; }};\n""" -lif_function_template = 'nnet::lif_neuron<{input_t}, {output_t}, {config}>({input}, {output});' +lif_function_template = 'nnet::lif_neuron<{input_t}, {output_t}, {config}>({input}, {output}, {beta}, {threshold});' lif_include_list = ['nnet_utils/nnet_lif_neuron.h'] @@ -53,6 +65,8 @@ def __init__(self): def format(self, node): params = self._default_config_params(node) + params['beta_is_vector'] = 'true' if node.get_attr('beta_mode', 'scalar') == 'vector' else 'false' + params['threshold_is_vector'] = 'true' if node.get_attr('threshold_mode', 'scalar') == 'vector' else 'false' return self.template.format(**params) @@ -63,6 +77,10 @@ def __init__(self): def format(self, node): params = self._default_function_params(node) + params['beta'] = node.get_weights('beta_vec').name if node.get_attr('beta_mode', 'scalar') == 'vector' else 'nullptr' + params['threshold'] = ( + node.get_weights('threshold_vec').name if node.get_attr('threshold_mode', 'scalar') == 'vector' else 'nullptr' + ) return self.template.format(**params) diff --git a/hls4ml/converters/pytorch/snn.py b/hls4ml/converters/pytorch/snn.py index b26293768b..522222ae48 100644 --- a/hls4ml/converters/pytorch/snn.py +++ b/hls4ml/converters/pytorch/snn.py @@ -5,22 +5,34 @@ BETA_TO_IF_TOL = 1e-6 -def _to_scalar(value, name): +def _to_numpy(value, name): if value is None: raise Exception(f'Missing SNN parameter: {name}') if hasattr(value, 'detach'): value = value.detach().cpu().numpy() - if isinstance(value, np.ndarray): - if value.size != 1: - raise Exception(f'Only scalar "{name}" is supported for SNN conversion, got shape {value.shape}') - return float(value.reshape(-1)[0]) - try: - return float(value) + return np.asarray(value, dtype=np.float32) except (TypeError, ValueError) as err: - raise Exception(f'Could not parse "{name}" as scalar: {value}') from err + raise Exception(f'Could not parse "{name}" as numpy array: {value}') from err + + +def _parse_scalar_or_vector(value, name, n_out): + arr = _to_numpy(value, name) + flat = arr.reshape(-1) + + if flat.size == 1: + scalar = float(flat[0]) + return {'mode': 'scalar', 'scalar': scalar, 'vector': None} + + if flat.size == n_out: + if np.allclose(flat, flat[0], rtol=0.0, atol=BETA_TO_IF_TOL): + scalar = float(flat[0]) + return {'mode': 'scalar', 'scalar': scalar, 'vector': None} + return {'mode': 'vector', 'scalar': None, 'vector': flat.astype(np.float32)} + + raise Exception(f'Only scalar or length-{n_out} "{name}" is supported for SNN conversion, got shape {arr.shape}') def _parse_reset_mechanism(class_object): @@ -31,21 +43,45 @@ def _parse_reset_mechanism(class_object): return reset +def _parse_state_reset_policy(class_object): + policy = getattr(class_object, 'state_reset_policy', None) + if policy is None: + policy = getattr(class_object, 'reset_policy', 'fixed_window') + policy = str(policy).lower() + if policy not in ['fixed_window', 'tlast', 'host_pulse', 'never']: + raise Exception(f'Unsupported state reset policy "{policy}". Supported: "fixed_window", "tlast", "host_pulse", "never".') + return policy + + @pytorch_handler('Leaky') def parse_lif_layer(operation, layer_name, input_names, input_shapes, node, class_object, data_reader, config): assert operation == 'Leaky' - beta = _to_scalar(getattr(class_object, 'beta', None), 'beta') + n_out = input_shapes[0][-1] + beta = _parse_scalar_or_vector(getattr(class_object, 'beta', None), 'beta', n_out) + threshold = _parse_scalar_or_vector(getattr(class_object, 'threshold', None), 'threshold', n_out) layer = {} - layer['class_name'] = 'IFNeuron' if np.isclose(beta, 1.0, rtol=0.0, atol=BETA_TO_IF_TOL) else 'LIFNeuron' + use_if = beta['mode'] == 'scalar' and np.isclose(beta['scalar'], 1.0, rtol=0.0, atol=BETA_TO_IF_TOL) + layer['class_name'] = 'IFNeuron' if use_if else 'LIFNeuron' layer['name'] = layer_name layer['inputs'] = input_names - layer['n_in'] = input_shapes[0][-1] - layer['n_out'] = input_shapes[0][-1] - layer['threshold'] = _to_scalar(getattr(class_object, 'threshold', None), 'threshold') + layer['n_in'] = n_out + layer['n_out'] = n_out + layer['threshold_mode'] = threshold['mode'] + if threshold['mode'] == 'scalar': + layer['threshold'] = threshold['scalar'] + else: + layer['threshold'] = 0.0 + layer['threshold_data'] = threshold['vector'] + if layer['class_name'] == 'LIFNeuron': - layer['beta'] = beta + layer['beta_mode'] = beta['mode'] + if beta['mode'] == 'scalar': + layer['beta'] = beta['scalar'] + else: + layer['beta'] = 0.0 + layer['beta_data'] = beta['vector'] layer['reset_mechanism'] = _parse_reset_mechanism(class_object) return layer, [shape for shape in input_shapes[0]] @@ -64,9 +100,13 @@ def parse_snn_readout_layer(operation, layer_name, input_names, input_shapes, no if n_classes is None: n_classes = input_shapes[0][-1] layer['n_classes'] = int(n_classes) - layer['window_size'] = int(getattr(class_object, 'window_size', 1)) + if hasattr(class_object, 'stream_length'): + layer['window_size'] = int(getattr(class_object, 'stream_length')) + else: + layer['window_size'] = int(getattr(class_object, 'window_size', 1)) layer['class_threshold'] = int(getattr(class_object, 'class_threshold', 1)) layer['decision_rule'] = str(getattr(class_object, 'decision_rule', 'argmax_spike_count')) + layer['state_reset_policy'] = _parse_state_reset_policy(class_object) if layer['decision_rule'] not in ['argmax_spike_count', 'first_to_threshold', 'threshold_then_argmax', 'binary_logit']: raise Exception( f'Unsupported SNN decision rule "{layer["decision_rule"]}". ' diff --git a/hls4ml/model/layers.py b/hls4ml/model/layers.py index 9d8509de7f..f83f7e9c1b 100644 --- a/hls4ml/model/layers.py +++ b/hls4ml/model/layers.py @@ -1042,13 +1042,30 @@ class IFNeuron(Layer): Attribute('n_in'), Attribute('n_out'), Attribute('threshold', value_type=float), + Attribute('threshold_mode', value_type=str, default='scalar'), ChoiceAttribute('reset_mechanism', choices=['subtract', 'zero'], default='subtract', configurable=False), + TypeAttribute('threshold'), + TypeAttribute('membrane'), ] def initialize(self): shape = list(self.get_input_variable().shape) shape[-1] = self.attributes['n_out'] self.add_output_variable(shape) + self._set_type_t('threshold') + self._set_type_t('membrane') + if self.get_attr('threshold_mode', 'scalar') == 'vector': + threshold = self.get_attr('threshold_data') + if threshold is None or len(threshold) != self.attributes['n_out']: + raise Exception('IFNeuron threshold vector must be present and have length n_out') + threshold_t = self.get_attr('threshold_t') + self.add_weights_variable( + name='threshold_vec', + var_name='th{index}', + type_name=threshold_t.name, + precision=threshold_t.precision, + data=threshold, + ) class LIFNeuron(Layer): @@ -1056,14 +1073,46 @@ class LIFNeuron(Layer): Attribute('n_in'), Attribute('n_out'), Attribute('threshold', value_type=float), + Attribute('threshold_mode', value_type=str, default='scalar'), Attribute('beta', value_type=float), + Attribute('beta_mode', value_type=str, default='scalar'), ChoiceAttribute('reset_mechanism', choices=['subtract', 'zero'], default='subtract', configurable=False), + TypeAttribute('beta'), + TypeAttribute('threshold'), + TypeAttribute('membrane'), ] def initialize(self): shape = list(self.get_input_variable().shape) shape[-1] = self.attributes['n_out'] self.add_output_variable(shape) + self._set_type_t('beta') + self._set_type_t('threshold') + self._set_type_t('membrane') + if self.get_attr('threshold_mode', 'scalar') == 'vector': + threshold = self.get_attr('threshold_data') + if threshold is None or len(threshold) != self.attributes['n_out']: + raise Exception('LIFNeuron threshold vector must be present and have length n_out') + threshold_t = self.get_attr('threshold_t') + self.add_weights_variable( + name='threshold_vec', + var_name='th{index}', + type_name=threshold_t.name, + precision=threshold_t.precision, + data=threshold, + ) + if self.get_attr('beta_mode', 'scalar') == 'vector': + beta = self.get_attr('beta_data') + if beta is None or len(beta) != self.attributes['n_out']: + raise Exception('LIFNeuron beta vector must be present and have length n_out') + beta_t = self.get_attr('beta_t') + self.add_weights_variable( + name='beta_vec', + var_name='be{index}', + type_name=beta_t.name, + precision=beta_t.precision, + data=beta, + ) class SNNReadout(Layer): @@ -1071,6 +1120,12 @@ class SNNReadout(Layer): Attribute('n_classes', configurable=False), Attribute('window_size', value_type=int, default=1, configurable=False), Attribute('class_threshold', value_type=int, default=1, configurable=False), + ChoiceAttribute( + 'state_reset_policy', + choices=['fixed_window', 'tlast', 'host_pulse', 'never'], + default='fixed_window', + configurable=True, + ), ChoiceAttribute( 'decision_rule', choices=['argmax_spike_count', 'first_to_threshold', 'threshold_then_argmax', 'binary_logit'], diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h b/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h index 435592b5d3..9593211c06 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h @@ -11,24 +11,32 @@ struct if_neuron_config { static const unsigned n_in = 1; static const unsigned n_out = 1; static const unsigned io_type = io_parallel; + static const bool threshold_is_vector = false; static constexpr float threshold = 1.0; static const snn_reset_mode reset_mode = snn_reset_mode::subtract; + typedef float threshold_t; + typedef float membrane_t; }; template -void if_neuron(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out]) { +void if_neuron( + data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out], const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out] +) { #pragma HLS PIPELINE II=1 - static data_T mem[CONFIG_T::n_out]; + static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; #pragma HLS ARRAY_PARTITION variable=mem complete for (unsigned i = 0; i < CONFIG_T::n_out; i++) { #pragma HLS UNROLL - data_T v = mem[i] + data[i]; - bool spike = (v >= (data_T)CONFIG_T::threshold); + typename CONFIG_T::threshold_t threshold = CONFIG_T::threshold_is_vector + ? threshold_vec[i] + : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + typename CONFIG_T::membrane_t v = mem[i] + (typename CONFIG_T::membrane_t)data[i]; + bool spike = (v >= threshold); if (spike) { if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { - v = v - (data_T)CONFIG_T::threshold; + v = v - threshold; } else { v = 0; } @@ -41,10 +49,14 @@ void if_neuron(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out]) { } template -void if_neuron(hls::stream &data_stream, hls::stream &res_stream) { +void if_neuron( + hls::stream &data_stream, + hls::stream &res_stream, + const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out] +) { #pragma HLS PIPELINE II=1 - static typename data_T::value_type mem[CONFIG_T::n_out]; + static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; #pragma HLS ARRAY_PARTITION variable=mem complete data_T in_pack = data_stream.read(); @@ -53,11 +65,14 @@ void if_neuron(hls::stream &data_stream, hls::stream &res_stream) for (unsigned i = 0; i < CONFIG_T::n_out; i++) { #pragma HLS UNROLL - typename data_T::value_type v = mem[i] + in_pack[i]; - bool spike = (v >= (typename data_T::value_type)CONFIG_T::threshold); + typename CONFIG_T::threshold_t threshold = CONFIG_T::threshold_is_vector + ? threshold_vec[i] + : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + typename CONFIG_T::membrane_t v = mem[i] + (typename CONFIG_T::membrane_t)in_pack[i]; + bool spike = (v >= threshold); if (spike) { if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { - v = v - (typename data_T::value_type)CONFIG_T::threshold; + v = v - threshold; } else { v = 0; } diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h b/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h index 26a44bed59..25649cfcc7 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h @@ -11,25 +11,39 @@ struct lif_neuron_config { static const unsigned n_in = 1; static const unsigned n_out = 1; static const unsigned io_type = io_parallel; + static const bool beta_is_vector = false; + static const bool threshold_is_vector = false; static constexpr float threshold = 1.0; static constexpr float beta = 0.9; static const snn_reset_mode reset_mode = snn_reset_mode::subtract; + typedef float beta_t; + typedef float threshold_t; + typedef float membrane_t; }; template -void lif_neuron(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out]) { +void lif_neuron( + data_T data[CONFIG_T::n_in], + res_T res[CONFIG_T::n_out], + const typename CONFIG_T::beta_t beta_vec[CONFIG_T::n_out], + const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out] +) { #pragma HLS PIPELINE II=1 - static data_T mem[CONFIG_T::n_out]; + static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; #pragma HLS ARRAY_PARTITION variable=mem complete for (unsigned i = 0; i < CONFIG_T::n_out; i++) { #pragma HLS UNROLL - data_T v = (data_T)CONFIG_T::beta * mem[i] + data[i]; - bool spike = (v >= (data_T)CONFIG_T::threshold); + typename CONFIG_T::beta_t beta = CONFIG_T::beta_is_vector ? beta_vec[i] : (typename CONFIG_T::beta_t)CONFIG_T::beta; + typename CONFIG_T::threshold_t threshold = CONFIG_T::threshold_is_vector + ? threshold_vec[i] + : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + typename CONFIG_T::membrane_t v = (typename CONFIG_T::membrane_t)(beta * mem[i]) + (typename CONFIG_T::membrane_t)data[i]; + bool spike = (v >= threshold); if (spike) { if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { - v = v - (data_T)CONFIG_T::threshold; + v = v - threshold; } else { v = 0; } @@ -42,10 +56,15 @@ void lif_neuron(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out]) { } template -void lif_neuron(hls::stream &data_stream, hls::stream &res_stream) { +void lif_neuron( + hls::stream &data_stream, + hls::stream &res_stream, + const typename CONFIG_T::beta_t beta_vec[CONFIG_T::n_out], + const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out] +) { #pragma HLS PIPELINE II=1 - static typename data_T::value_type mem[CONFIG_T::n_out]; + static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; #pragma HLS ARRAY_PARTITION variable=mem complete data_T in_pack = data_stream.read(); @@ -54,11 +73,15 @@ void lif_neuron(hls::stream &data_stream, hls::stream &res_stream for (unsigned i = 0; i < CONFIG_T::n_out; i++) { #pragma HLS UNROLL - typename data_T::value_type v = (typename data_T::value_type)CONFIG_T::beta * mem[i] + in_pack[i]; - bool spike = (v >= (typename data_T::value_type)CONFIG_T::threshold); + typename CONFIG_T::beta_t beta = CONFIG_T::beta_is_vector ? beta_vec[i] : (typename CONFIG_T::beta_t)CONFIG_T::beta; + typename CONFIG_T::threshold_t threshold = CONFIG_T::threshold_is_vector + ? threshold_vec[i] + : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + typename CONFIG_T::membrane_t v = (typename CONFIG_T::membrane_t)(beta * mem[i]) + (typename CONFIG_T::membrane_t)in_pack[i]; + bool spike = (v >= threshold); if (spike) { if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { - v = v - (typename data_T::value_type)CONFIG_T::threshold; + v = v - threshold; } else { v = 0; } diff --git a/hls4snn-demo.ipynb b/hls4snn-demo.ipynb index 8f8722175e..9b1805ef4a 100644 --- a/hls4snn-demo.ipynb +++ b/hls4snn-demo.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "67fc7845-3298-47c6-a893-6babb5205883", + "id": "69096b40-4b90-4aa5-96d0-69e0e2a75ebf", "metadata": {}, "source": [ "# hls4snn" @@ -10,7 +10,7 @@ }, { "cell_type": "markdown", - "id": "5ccb39c0-9fcf-45d1-b418-7e19cd2c7bdc", + "id": "bdaf653d-4f87-4320-bdc3-44399b928b2f", "metadata": {}, "source": [ "This is a simple notebook that shows how to use hls4ml for SNNs, with neurobench also." @@ -18,7 +18,7 @@ }, { "cell_type": "markdown", - "id": "c071f16c-6f7d-409e-85fa-d09d726944a6", + "id": "87c72b0e-8b82-4241-9d9e-787d23f6ff5e", "metadata": { "jp-MarkdownHeadingCollapsed": true }, @@ -28,7 +28,7 @@ }, { "cell_type": "markdown", - "id": "0ff83cc4-4b69-4250-99d9-7e37ba5fdca3", + "id": "86ec6acb-427e-479f-bcd4-3c913c7dc124", "metadata": {}, "source": [ "Make sure to run:\n", @@ -46,8 +46,8 @@ }, { "cell_type": "code", - "execution_count": 20, - "id": "19b95931-bd8c-4bf2-b82f-4d0dc135bf50", + "execution_count": 1, + "id": "eeefd791-53eb-48ff-b858-b61412814c34", "metadata": {}, "outputs": [ { @@ -61,12 +61,14 @@ "source": [ "import os\n", "import sys\n", - "import argparse\n", + "import json\n", + "import time\n", "from pathlib import Path\n", "\n", "import numpy as np\n", "import torch\n", "import torch.nn as nn\n", + "import torch.nn.functional as F\n", "from torch.utils.data import TensorDataset, DataLoader\n", "import matplotlib.pyplot as plt\n", "\n", @@ -86,12 +88,16 @@ " ClassificationAccuracy,\n", " ActivationSparsity,\n", " SynapticOperations,\n", - ")" + ")\n", + "\n", + "def set_seed(seed: int) -> None:\n", + " np.random.seed(seed)\n", + " torch.manual_seed(seed)" ] }, { "cell_type": "markdown", - "id": "a22085b8-462e-4313-9247-2285164117a8", + "id": "653288d0-17e1-42b3-861e-ecf89b47d9d0", "metadata": { "jp-MarkdownHeadingCollapsed": true }, @@ -101,55 +107,58 @@ }, { "cell_type": "markdown", - "id": "cbb35d2e-1633-4f1d-a9c9-ba4b5c93312e", + "id": "d9788ae5-ff34-4cda-b0e3-0a17f4543071", "metadata": {}, "source": [ - "creating a simple 2D dataset for testing the SNN" + "creating a simple 2D dataset for the SNN" ] }, { "cell_type": "code", "execution_count": 2, - "id": "c418a2b2-698d-454d-88a3-c67e09586932", + "id": "80d75f42-79ed-441f-ae0f-9a78774963b7", "metadata": {}, "outputs": [], "source": [ - "def make_synthetic_stream_data(n_samples: int, timesteps: int, seed: int = 1234):\n", - " rng = np.random.default_rng(seed)\n", - " x = rng.normal(loc=0.0, scale=1.0, size=(n_samples, timesteps, 2)).astype(np.float32)\n", - " score = np.sum(0.9 * x[:, :, 0] - 0.6 * x[:, :, 1], axis=1)\n", - " y = (score > 0.0).astype(np.int64)\n", - " return torch.from_numpy(x), torch.from_numpy(y)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "8cdf7458-42a8-48cd-9104-8744d5cafc60", - "metadata": {}, - "outputs": [], - "source": [ - "def make_simple_gaussian_streams_2d(\n", + "def make_toy_dataset(\n", " n_samples: int,\n", - " timesteps: int,\n", - " seed: int = 1234,\n", - " mean_shift: float = 1.0,\n", - " std: float = 1.0,\n", - "):\n", - " rng = np.random.default_rng(seed)\n", - " y = rng.integers(0, 2, size=n_samples)\n", - " x = rng.normal(loc=0.0, scale=std, size=(n_samples, timesteps, 2)).astype(np.float32)\n", - "\n", - " # Shift only the first channel by class\n", - " x[y == 0, :, 0] -= mean_shift\n", - " x[y == 1, :, 0] += mean_shift\n", - " return torch.from_numpy(x), torch.from_numpy(y.astype(np.int64))" + " timesteps: int = 20,\n", + " noise_std: float = 0.60,\n", + " amp_jitter: float = 0.55,\n", + ") -> tuple[np.ndarray, np.ndarray]:\n", + " \"\"\"Binary sequence dataset with class-specific temporal signatures.\n", + "\n", + " Class 0: positive early bump on ch0 + mild negative late bump on ch1.\n", + " Class 1: mirrored pattern.\n", + " \"\"\"\n", + " t = np.linspace(0.0, 1.0, timesteps, endpoint=False, dtype=np.float32)\n", + " x = np.zeros((n_samples, timesteps, 2), dtype=np.float32)\n", + " y = np.random.randint(0, 2, size=(n_samples,), dtype=np.int64)\n", + "\n", + " early = np.exp(-0.5 * ((t - 0.33) / 0.16) ** 2).astype(np.float32)\n", + " late = np.exp(-0.5 * ((t - 0.67) / 0.16) ** 2).astype(np.float32)\n", + "\n", + " for i, label in enumerate(y):\n", + " amp = 1.0 + np.random.uniform(-amp_jitter, amp_jitter)\n", + " wave = 0.35 * np.sin(2 * np.pi * t).astype(np.float32)\n", + " mix = np.random.uniform(-0.25, 0.25)\n", + " if label == 0:\n", + " s0 = amp * ((0.95 + mix) * early - 0.7 * late + wave)\n", + " s1 = amp * (-0.35 * early + (0.8 - mix) * late - wave)\n", + " else:\n", + " s0 = amp * (-0.35 * early + (0.8 - mix) * late - wave)\n", + " s1 = amp * ((0.95 + mix) * early - 0.7 * late + wave)\n", + "\n", + " x[i, :, 0] = s0 + np.random.normal(0.0, noise_std, size=timesteps)\n", + " x[i, :, 1] = s1 + np.random.normal(0.0, noise_std, size=timesteps)\n", + "\n", + " return x, y" ] }, { "cell_type": "code", - "execution_count": 4, - "id": "090e098b-62ac-47de-b5f4-1bb04f12f301", + "execution_count": 3, + "id": "bfd3f387-6e8f-4a4b-afb7-99299ae4b996", "metadata": {}, "outputs": [], "source": [ @@ -211,13 +220,13 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "93c1e030-8b52-469f-a33b-0d3b48453624", + "execution_count": 4, + "id": "c2e4c80c-ed6f-4d8b-920d-53efe2ddbb45", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9gAAAKvCAYAAACReme8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XmYZFV9+P/3OXetrbdZ2VEGwR0XVMQFjMYFFDXRqPkquKBiMBrlZ/RJ8giPojF+Xb4at0TEBeNCNIpRcQsoGHFHBNmZYZEZmJnurvVuZ/n9catquqe7Z3pmeqZnnPN6nn5g6lbVPXXr3lv3c8/nfI6w1locx3Ecx3Ecx3Ecx9kjcrkb4DiO4ziO4ziO4zh/ClyA7TiO4ziO4ziO4zhLwAXYjuM4juM4juM4jrMEXIDtOI7jOI7jOI7jOEvABdiO4ziO4ziO4ziOswRcgO04juM4juM4juM4S8AF2I7jOI7jOI7jOI6zBFyA7TiO4ziO4ziO4zhLwAXYjuM4juM4juM4jrMEXIDtOI7j7Lde8pKXIIQY/l155ZXL3aTdcsIJJ8z6HBs2bFjuJjkL+OQnPznruzr//POXu0mO4zjOAcQF2I7j7Jfuuusu3vWud3HyySczPj5OEASsWbOG5zznOfznf/7nvK95/vOfP+vCeObfyMgIRx99NM973vP48Ic/zNTU1D75HBs2bOD888/ns5/97D5Z35+aT33qU2zcuJGTTjppSd/3yiuv5Pzzz99nAfuPfvQjNm7cyOGHH75P1rcj1lqe85znsG7dOjZt2rTczdkj559//pIHwGeeeSYbN27krW9964LP+dznPsfo6CiXXHLJkq77QPS6172OQw45hBtuuGG5m+I4jrNfcAG24zj7nR//+Mccc8wxXHjhhTztaU/jBz/4ATfeeCMf+9jHuO2223jRi17Ey172Mowxs1732c9+lo0bN/LiF78YgBe/+MVs3LiRe++9l5///Od85CMfYe3atbz97W/n8MMP5wMf+ADW2r36WTZs2MAFF1zgAuzdNDo6ytq1awnDcEnf98orr+SCCy7YZwH2ihUrWLt2LZ7n7ZP17ciWLVv47ne/y+23387VV1+93M3ZIxdccAEXXHDBkr5npVJh7dq11Ov1BZ/z1a9+lVarxZe//OUlXfeB6JJLLmHTpk1897vfXe6mOI7j7Bf85W6A4zjO9qamplBK8cEPfpA3vvGNw8fXrVvHE5/4RI4//ni+9KUvceqpp3L22WcPl4+NjQHlBfLgv2vXrgXgkEMO4cEPfjDPe97z+P/+v/+P5z73uZx33nnccMMNfOYzn9l3H85xltmqVas499xzufXWW3n605++3M05IJ177rls3ryZv/mbv1nupiy7f/zHf+S73/0uf/mXf7ncTXEcx9kvuB5sx3H2S57nceaZZ855/NBDD+W5z30uUPYi7Y5jjz2W73znO4yMjHDxxRfz8Y9/fI/a6jgHmo9+9KNcfvnlw5tSzq559rOfzS9+8Que/exnL3dTlt073vEOfvKTn3D00Ucvd1Mcx3H2Cy7Adhxnv3PaaacxOTnJyMjIvMsH41gnJyd3ex0PfOADecMb3gCU4zjTNF30a2+++WbOOuss1q1bRxzHrFixgj/7sz/jX//1X2eNaRVCcOqppwJl2vt8hZPWrVs363FrLR/5yEd4+MMfTqVSGT4+04YNG3jta1/LUUcdRRiGrFq1iuc85zl873vfm7e9v/nNb3jb297GYx7zGFasWEEcxzzoQQ/iLW95C1u2bJnz/O3bZIzhfe97Hw984AOpVqs86lGPmjUO/l//9V950IMeRBzHHH/88budDt/pdHjHO97BAx7wAKIo4sgjj+Rv//ZvaTabC77GGMN3vvMdXvnKV/LQhz6Uer1OvV7nsY99LB/60IdQSs16/pVXXokQYphWfMEFFyxYRG1Xt9uuuvjii3n0ox9NrVZjYmKCF7zgBVx//fXD5Rs2bJi3nsDMNh599NG7VJDr/PPPn/X8md/Vu9/97jnLrr76ak499VQajQYjIyOcfvrp3HzzzbPe87Of/eycNlx11VU861nPYmJigkqlwgknnMC///u/zxqScf3118963VlnnTXrfWd+tu2Dt1NOOWXWcTHzfU455ZQdboOZrLX8+7//OyeccAKVSoWVK1fyF3/xF9x4443zPn/772Tmuu655545y6ampjj77LNZtWoVo6Oj/Pmf/znXXnstAN1ulze96U0ccsghVCoVnvSkJ3HNNdcs2NbNmzfz1re+lWOPPZYoihgfH+fUU0/lS1/60pzn+r4/a9ulacrb3/52jjzySKIoYt26dbz//e+fdz1KKT796U/zhCc8gZUrVxLHMccddxznnHMOV1xxxXBoznzf+3xuvPFGzjrrLI444giiKGLVqlU873nP44orrpjz3PnOPf/yL/8y/MxHHHEEb3/72ymKYsHt5DiOs+ys4zjOAeblL3+5BeyZZ5457/Izzzxzh8sHrr32WgtYwF5++eWLWvdvf/tbW61W7Yknnmh/8IMf2A0bNthf/epX9rWvfe2cdW7cuNF+7Wtfs4A96aST7MaNG4d/7XbbWmvt5s2b7caNG4ftOOecc+zf/M3f2Ouuu87efPPN9gUveIGdeaq+6qqr7OjoqF21apW95JJL7C233GJ/8IMf2Cc84QkWsP/8z/88p83HHXecnZiYsBdffLG95ZZb7I033mg/+9nP2sMPP9weddRR9r777pv1/O3b9IY3vMF+4AMfsLfffru94oor7HHHHWeFEPab3/ymfc973jNc9j//8z/2QQ96kAXsN7/5zUVtz4FOp2Mf+9jHWsC+/vWvt9ddd5297bbb7P/7f//PPu5xj7MnnniiBewVV1wx63WDdp5wwgn2O9/5jl2/fr299tpr7YUXXmjDMLSnnXaa1VoPn59lmd24caN961vfagH71re+ddb3kmXZbm+3xTjqqKMsYF/1qlfZv/qrv7K/+tWv7Pr16+2///u/20ajYWu1mv3pT39qrbVWKWU3btxo/+qv/mq4XbZv4/33328/97nP2SiK7C233DLcrxbSbrftxo0b7Ytf/GIL2IsvvnjWdzBz2Stf+Ur7zGc+0/785z+3N998s33f+95npZT2sMMOm7WeXq83a5s+6UlPsuvWrbNf//rX7YYNG+zVV19tn/KUpwz374GiKOzGjRvthz/84XmP1/vvv9/+4he/sIA96qijZi3bunXrrH105ne4devWRX8fr3/96y1gn/KUp9irrrrKbtiwwX7961+3D3vYw4bb4Z3vfOfw+YPvZHBcP/WpTx0u01rPWvb4xz/ePvOZz7Rf//rX7e23324vueQS22g07NjYmN2wYYP967/+6+GyL3zhC7Zer9t6vW7vueeeOe288cYb7WGHHWZrtZr92Mc+Zm+66Sb7k5/8xD73uc8d7hszbdq0abjtjjzySPv85z/ffvzjH7d33HGH/clPfmIf9ahHWcB+6EMfmrOul770pVZKad/73vfaG264wd522232y1/+8nDfXb9+vbV27vc+czsN/Nd//ZeN49gee+yx9rLLLrMbNmywV111lT311FMtYN/97nfPev72557Xv/719t3vfre99dZb7c9//nP7jGc8wwL2TW9602K/YsdxnH3OBdiO4xxQiqKwa9eutYD9xS9+Me9zFhtgK6VsGIYWsBdccMGi1j9471/+8pdzlj396U+fs84rrrhizoX4fAYXlH/xF38x6/Hf//73ds2aNdZaa6empuyaNWssYH/2s5/Nel6SJPaQQw6xUso52+VpT3ua/drXvjZnnVdffbUF7N/8zd/ssE3nnnvurMd/8IMfWMA+6EEPsm95y1tmLfve975nAfuMZzxjh593e295y1ssYF/wghfMWfahD31o2JbtA+z777/fPuABD5g3KHn3u99tAXvppZfOWfbOd75zwaBgYHe3244MgpTHPvax1hgza9kXv/hFC9gHPOABs4LowT60du1aWxTFnPd84QtfaF/2spftUjsG+/HMAHv7ZePj47bT6cxaNrjh84UvfGHO6wbbFLDXXXfdrGWdTscefvjhFrDf+ta3Zi27+OKLFzxe169fP2+APTBY3+647LLLLGAPP/zwOZ/zN7/5zfC959tHdnRcD5YB9j//8z9nLfuHf/gHC9iHP/zhc5a94x3vsIC98MILZz2ulLIPfehDLWC//OUvz1pmjLGPfvSj513XYNvN956/+93vLGCPOeaYeV9z2mmnzflcg/1+EGAPLHQs3XHHHbZWq9k4jue8ptfr2XXr1lnA/vd///ecdQ3affbZZ896fOvWrdbzPFutVm2apnNe5ziOsz9wKeKO4xxQPvOZz7Bp0ybOOeccTjzxxD16L8/zGB8fB+C+++5b1Gs2b94MlNOIbe+CCy7g5S9/+R61aWZRN4CHPexhw7Tziy66iPvuu4+TTjqJJzzhCbOeF8cxZ511FsaYOWPKf/SjH/HCF75wzroG7/Htb397h23a/jMNtvstt9zCX/3VX81a9rjHPQ4o06sXK0kS/u3f/g1gmLY/02te8xriOJ73tatWreKOO+7gsMMOm7NssZ9vIXu63XbkDW94w5zU/5e85CWsWLGC9evXc9lllw0fP+WUUzj22GPZtGkT3/rWt2a95r777uNb3/rWrGJ/S+XFL34xtVpt1mOPf/zjAYZpzvN5ylOewsMf/vBZj9VqNV75ylcC8OEPf3hJ27m7Bu0488wz53zORz3qUTzpSU/ao/cfGRnhjDPOmPXY4Ni588475yxb6Nj5xje+wQ033MBhhx02nCFhQAjB6173OqAcqrGQV73qVbP+/YhHPIJKpcLtt99Ou90ePj44v/3xj3+cM0vD4x//eD760Y+yYsWKBdcz04c+9CG63S7Pe97z5qT4VyoVXv/61wPwrne9a9HtnpiY4Nhjj6XX63Hrrbcuqh2O4zj7mguwHcc5YNx2222cd955nHTSSXzwgx9ckve0/TGh2wc7C/mzP/szoAw63/72t3PTTTcNlz3xiU8cLt9dD37wgxdc9v3vfx+Axz72sfMuf+ADHwjAT3/601mPZ1nGBz/4QZ70pCexdu1aGo0G9Xqd0dFRoLyY3pFjjjlm1r9njo3fftngPXdlnvFf//rXdDodAB7zmMfMWV6v1zniiCMWfP3GjRs577zzeOQjH8nKlSuH47BPP/10YOefbyF7ut12ZL7vWUrJox/9aKAcsz/Tq1/9agA+/elPz3r8c5/7HEcdddQujTterHXr1s15bGJiAtjx97vQPjzYb3/605/OGRu/rymlhsfJfPsc7PhYXIwjjzwS3589Wcvg2Jlv2ULHzuC4f/SjHz3veWpw3F9zzTVorecsr9Vqw9kUZhrcXJyenh4+9tCHPpQ1a9Zw7bXXcvLJJ/PVr36VJEmAclz3ueeeS6PRWPhDz9PuwY2D7Q0e/8UvfrHg/rS7+6DjOM5ycgG24zgHhI0bN/Lnf/7nrFu3ju9+97sL9mjuCq318CJt9erVi3rN3/7t33LeeeehlOJ973sfD37wgznuuOP4x3/8x3l7tXfVqlWrFlw2eP9PfepTwyBy5t+g93tm4Nfr9Xjyk5/MW9/6VkZHR/n85z/Pr371K6699tphL+TOCgYNLmgHZl7kL7Rs+96vHbnnnnuA2RkF25svQAC46aabeMQjHsGHPvQhnv70p/Nf//Vfw882CEbzPF90WwaWYrvtyEL72+D7H2yTgbPOOgvf9/ne9743a9lFF13Ea17zmt1ux47M11MZBAHAvIHcwM4+W5qmbN26dQlauPu2bNlClmXAwsfcQvvcYm1/bMC242NHy7bftoPj/rvf/e68x/3znvc8oNyu8xV+XKjHeb7vslqt8u1vf5uHPOQhXHPNNfzVX/0VK1as4IwzzuAb3/jGDr/37d15553AwvvDmjVrgPIm59133z3vc3Z3H3Qcx1lObh5sx3H2e/feey9Pf/rTWb16Nd/97neHPT176ne/+90wSDrppJMW9Rrf93n/+9/P2972Nr70pS/x1a9+lf/93//lwgsv5IMf/CAXXXQRL33pS3e7TYvpSf+bv/mbeVOp53uPj3/84/zyl7/koQ99KJdddhme5y1pmxbb87+3nHfeeWzZsoXXve51fOADH5i1bPsgdVcsxXbbHXZGle2Z1qxZw+mnn843vvENLr74Yv7pn/6Jn/zkJ6xfv35O9e2lstTf7UKfbalfs7+sY6mPmxe84AW85z3v2eFz5rtBtavresxjHsP111/PlVdeyZe//GW+/vWvc9lll3HZZZfxlKc8hW9961sLzvCw1Jb7/OI4jrM7XA+24zj7tTvvvJOnPOUprF69mh/+8IcL9nDujsH0NqtXr+bJT37yLr121apV/O3f/i1XX30169ev5+UvfzlJknD22WfPSrlcSkcddRRQBgTr1q1b8G9m2vYg1fhpT3vaPgsSd9Vg2jWt9YJTr82c/mymwef78z//8yVt097ebguN+R+MgR1sk5kGPdWf+cxnhtNLPfe5zx32BO4vdvbZBlPbDQy273w9koPXLLWVK1cSRdEO17HQPrevDY77oih2eNyvW7duTtr57hpMMfipT32KjRs38tWvfpW1a9fyk5/8hPe973271O6F9ofB40KIHQ4BcRzHOdC4ANtxnP3WrbfeypOf/GSOOeaYYXrkwHXXXceznvWs3X7vW265hU9+8pNAOTfwYlPO//mf/5kf/vCHsx476qij+NznPse6devodrvccsstw2VSzj3NJknCpk2bdimNGrYFkb/4xS/mXW6t5RnPeAbnnXfe8LEdrWNPxhAvpcc85jHD7/bXv/71nOWdTmfBFNLd/XzzfS/NZnM4v/Xe3m7zzbNsjOG3v/0tAE996lPnLH/Ws57F4YcfzoYNG7j00kv52te+tleKm+2pheaQ/tWvfgXAySefPCsQ3NG4/dtvv32H69q+h1NrzaZNm3Y6r73v+5x88snA/PscLPw59rXBcf/LX/5ywd72l7/85bzsZS/b43XddNNNnHvuubMe832fF73oRcN5swf76M4M2v3zn/983uWD89jjHve4Jb1x6jiOs9xcgO04zn7phhtu4ClPeQqPfvSjueyyy6hUKrOWT05O8r3vfW+33vvmm2/mtNNOo9Pp8MpXvpJzzjln0a+9/PLLufjii+ddppSa0xszNjYGQLfbHT72yU9+kkMOOWSnQcD2Xv3qV7N27Vp+9rOf8b//+79zln/xi1/khz/84ayCV4NCQj/4wQ/mFJa69NJLd2n9e0ulUhkGip/4xCfmLP/0pz+94LYafL7vfOc7c5bt6PPN97284hWv4DnPec6s991b2+0Tn/jEnGDpy1/+Mlu3buXoo48ejqudyfO8YSXu1772taxatWrJe+6XwlVXXcXvf//7WY91u10++9nPAvCmN71p1rITTjgBKAO37W9sfOYzn9nhurb/Hq+77joOOeQQ/ud//men7Ry04/Of//ys/WDQlquvvnqn77EvnHHGGTzsYQ/jj3/8I1/5ylfmLL/qqqu45JJLeOITn7jH69q0aRMf+9jH5q3QPRhOc+SRRy7qvf7u7/6OWq3Gt771rTk3StI0Hd7g/Kd/+qc9bLXjOM7+xQXYjuPsd66//npOOeUUNm3axIYNGzj55JN57GMfO+tvMDXNTNPT02zatGlY9XbQU7xx40ZuuukmLrvsMs4++2we8YhHcO+99/L+97+fiy66aJfb9x//8R/83d/9Hb/85S+56667uOaaa/jrv/5rNmzYwJvf/GYOOeSQ4XMf/OAHs3r1aq6//np+/OMf8/vf/56LL76Yxz3ucVSrVSYnJ2elom7atGnWZ5hpdHSUr3/964yOjnLGGWdw0UUXcccdd3D99dfznve8h7PPPps3vvGNw+rZAOeeey5HHHEEN910E3/xF3/BNddcw80338yHPvQhLrjgglnrHaRnz9emPV22M+9617t47GMfy3/9139xzjnncP3113PHHXfwkY98hI985CMcd9xxs9YxSCd+17veRRAEXHzxxfzDP/wD119/Pddeey3nnHMOl19+OVAWOdu0adOwUjls6yG+/PLL+cMf/sAPf/hDfvSjH3Hqqafu9nbbka1bt85qd61W46UvfSm/+c1v2LBhAxdddBHnnHMOtVqNL37xi4RhOO/7vOpVr0IIQbPZ5NWvfvW8PfE70ul0Zu1fzWaTTZs2kef58HjZfpnWetgz3Gw2AeY8d6YXvehFvOxlL+Mb3/gGd911F//7v//Laaedxj333MM555zDc5/73FnPP/LIIznttNO49957Ofvss/nd737HTTfdxJve9KZhFenB+rff1oPv8dOf/jS33347H/jAB6jX6wtW2p/pec97Hq9//eu55557OO200/jpT3/KXXfdxTe+8Q1e9KIXDafpmrnNtm/HYN8abJf5lg32u91d5nkeX/va1zjiiCN49atfzQc/+EFuueUWbrrpJj7+8Y/z/Oc/n+c///mzbhRu3rx5mPq+/Xc383vd/rkDz33uc7n00ku59dZbueWWW/j85z/P3//937Ny5Ure9ra3Adv2gUE7t9+3HvCAB3DJJZcA8MxnPpPLLruMu+66i6uvvprnPOc53HbbbbzrXe/itNNOG653R+eQwfsPihZu/1zHcZz9xjLNv+04jrOgD33oQxZY1N9MZ5xxxoLPq9Vq9sgjj7Snn366/eAHP2i3bt26W22788477fvf/3775Cc/2U5MTFjf9+1hhx1mn/GMZ9hvfOMb877mxz/+sT3xxBNtFEV2fHzcPvvZz7a33HKLtdbapz71qfO29+KLL16wDXfddZd9wxveYI8++mgbhqFdu3atPeWUU+yll15qjTFznv/HP/7RnnXWWXbNmjXW9327evVq+8IXvtD+5je/mbXOpz71qQu2aU+XLUa73bZ///d/b4866igbBIFdu3at/T//5//Y9evXz3nvG2+8cfi6n/3sZ/ZZz3qWHRkZsUEQ2KOPPtq+4Q1vsF/5yldmvead73znrPV94hOfsMccc4z1fd8ecsgh9nWve51tt9u7vd125JGPfOSs19xyyy32ve99r33wgx9s4zi2Y2Nj9owzzrC///3vd/pez3jGM6yU0t59992L3rYD73znO+fd36644gp78cUXz7ts/fr1dv369TvdTwfv/c53vtNed9119nnPe56dmJiwURTZRzziEfZTn/rUvPuntdY2m0179tln29WrV9swDO1DH/pQe9FFF81Z78knnzzrdXfffbc9/fTTbaPRsNVq1T7mMY+xl19++aK3hzHGfupTn7KPeMQjbBRFdmxszD7jGc+wV1555Zxt9YlPfGLB7XDmmWdaa+28ywb73e4uG9iyZYv9+7//e3vcccfZKIrsypUr7UknnWQ//elP2zzPZz33qKOOWrCNZ5555pxlRx11lLXW2qIo7He+8x171lln2WOOOcZGUWQbjYZ9yEMeYs877zx77733Dtex0P6y/bnrD3/4gz3zzDPtYYcdZoMgsCtWrLCnn366/dGPfjTn+9jROWShfddxHGd/I6zdByU6HcdxHMdZEq95zWvYuHEj3/72t5e7KbOcf/75XHDBBbzzne/k/PPPX+7mOI7jOM6ycNN0OY7jOM4Botfrcemll/K5z31uuZviOI7jOM483Bhsx3Ecx9lP/f73v59V+O1LX/oSjUZj1jh7x3Ecx3H2H64H23Ecx3H2UzfffDNve9vbeOQjH0kQBJx//vm8/e1vX7L5jpdCkiQ0m805xa7q9fqsqfUcx3Ec52DgxmA7juM4zn7q6quv5swzz+See+5hbGyMV77ylbz3ve+dM//zcvrsZz87nD5sJjcW23EcxzkYuQDbcRzHcRzHcRzHcZaAG4PtOI7jOI7jOI7jOEvABdiO4ziO4ziO4ziOswRcgO04juM4juM4juM4S8AF2I7jOI7jOI7jOI6zBFyA7TiO4ziO4ziO4zhLwAXYjuM4juM4juM4jrMEXIDtOI7jOI7jOI7jOEvABdiO4ziO4ziO4ziOswRcgO04juM4juM4juM4S8AF2I7jOI7jOI7jOI6zBFyA7TiO4ziO4ziO4zhLwAXYjuM4juM4juM4jrMEXIDtOI7jOI7jOI7jOEvABdiO4ziO4ziO4ziOswRcgO04juM4juM4juM4S8AF2I7jOI7jOI7jOI6zBFyA7TiO4ziO4ziO4zhLwAXYjuM4juM4juM4jrMEXIDtOI7jOI7jOI7jOEvABdiO4ziO4ziO4ziOswRcgO04juM4juM4juM4S8AF2I7jOI4zj6OPPhohxJy/Wq3GUUcdxQtf+EI+85nPkGXZgu/xnOc8h6OPPprNmzfvw5Yvn4Pt8zqO4zjO9lyA7TiO4zjz2LBhA9ba4b+ttVhruffee/nP//xP1q1bxxvf+EaOPfZYfvrTn877HuvXr+f++++n2+3uq2Yvq/31895888288IUv5O/+7u94y1vewite8Qruu+++5W6W4ziO8ydI2JlXD47jOI7jzCKEAGC+n8vrrruOpz/96bRaLX70ox9x8sknz1qeJAlJkjAxMbFP2rrc9sfP22q1eOhDH8p73/te/s//+T8AvOc97+FLX/oSv/71rwnDcJlb6DiO4/wpcQG24ziO4+zAjgJsgG9+85s8//nP58gjj+TWW291Adt+5h//8R/5t3/7N+6991583wdgcnKSNWvW8NGPfpTXv/71y9xCx3Ec50+JSxF3HMdxnD1wxhlncPzxx3PXXXfxpS99CYArr7xy1rjtK6+8EoBrrrlm1uNXXHEF//f//l+OPPJI6vU6T3va07juuuuG73HiiSdSqVRYt24dl1xyyYJt+PznP88TnvAE6vU6jUaDk08+ma985SuznjPfuj/wgQ/wwAc+kCiKOP7444ft396XvvQlTjrpJCYmJhgfH+fEE0/kn/7pn7j11lt3+Hln+tznPjdsY71e56STTuLzn//8krVxIV/96ld5/OMfPwyuASYmJjj++OO59NJLd+m9HMdxHGdnXIDtOI7jOHvo6U9/OgCXX345AKeccgrWWt75znfOet4TnvCEWY//y7/8C0EQ8Lvf/Y6rr76a9evX84xnPINrrrmGr3zlK/zXf/0Xt912G8cccwyveMUr+NWvfjVn3eeeey5nnnkmf/Znf8bdd9/Nhg0bOPXUU3nJS17Cu9/97gXX/c///M/kec4vfvELbrrpJg455BD++q//ml/+8pez3v+jH/0oL3vZy3jBC17Abbfdxl133cXb3vY2PvzhD3PhhRfu8PMOnHPOOZx11lk897nP5e677+buu+/mtNNO48wzz+SNb3zjHrdxIe12m1tvvZUjjzxyzrJDDz2UX//614t6H8dxHMdZLBdgO47jOM4eOuaYYwC47bbbdul1tVqNN73pTYyPj3PCCSfwxje+kfvvv59XvepVfPSjH+Xwww/nsMMO48ILL8Rayxe/+MVZr//Wt77Fxz72MZ785Cdz4YUXMj4+zooVK3j3u9/Nk5/8ZM4//3xuuummedcdRRHveMc7WLlyJQ94wAN43/veN+86Lr74YlasWMHb3vY2JiYmaDQavOhFL+LNb37zoj7jN7/5TT75yU/y0pe+lH/4h39gfHyc8fFx/vEf/5GXvOQl/Ou//iv//d//vUdtXMidd94JwMjIyJxltVqNZrNJnueLei/HcRzHWQwXYDuO4zjOHqrX6wA0m81det1pp50269/HHnssACeeeOKslOYHPehBANxyyy2znv+JT3wCgNe85jVz3vslL3kJWmu+8IUvzLvuM844Y9a/H/zgBwMM074HhBBMTk7ygx/8YNbjb3vb2/iXf/mX+T/YDJ/85CcBeOlLXzpn2eCxj3/843vUxoW0Wi2AecfF12o1AKanpxf1Xo7jOI6zGC7AdhzHcZw91G63ARgdHd2l1x1yyCGz/t1oNOZ9fNAD2+v1Zj3+i1/8AoATTjhhznsfccQRAPOmlUOZIj3T4CbB9ut405veBMAzn/lMTjnlFD75yU9y33330Wg0WL169fwfbIZBOvfxxx8/Z9ngsYVSvhfbxoV4ngdsK1Q3U1EUACilFvVejuM4jrMYLsB2HMdxnD006Fke9DQvVhzHu/T49pXMBz3mj3zkI2cVBxNC8LznPQ9gwfmeK5XKrH8vVC39Fa94BVdeeSXPfvazufrqqznnnHM4/PDDeclLXsKmTZt28gm3tXHQYzzTznqRF9vGhaxatWrBZYO5ugdBu+M4juMsBRdgO47jOM4esNbywx/+ECh7efelsbExoEyZttbO+3fttdfu8Xqe8pSn8O1vf5tNmzbx8Y9/nAc96EF85Stf4dRTTx32BO+sjYOAdqbBY+Pj43vcxvmsWbMGIQRTU1PzrntsbGze8dmO4ziOs7tcgO04juM4e+DSSy/ltttu48gjj+QlL3nJPl334x//eAA2bNgw7/JrrrlmOO3X7vr+979Pp9MBYOXKlZxzzjn89re/5SEPeQg33XQTN9xwww5f/7jHPQ6AG2+8cc6ywWOD5yy1Wq3Gox71KO6+++45y2677bZ5U+sdx3EcZ0+4ANtxHMdxdtNvfvMbzjnnHKIo4ktf+tK8xbT2pje84Q0AfPazn52z7I9//COnnHLKHvdgv/a1r+Wqq66a9VgYhqxbtw6Ym8a9vXPOOQdg3vmrv/zlL896zt5w2mmn8fOf/3xWWvntt9/O3XffzV/+5V/utfU6juM4BycXYDuO4zjOLmi1Wvzyl7/kvPPO40lPehK1Wo0f/vCHPPGJT9znbXnOc57Dm9/8Zv7jP/6Dv//7v+eOO+6g1+vx4x//mGc/+9k89alPnbd6965685vfzJVXXkmn02F6eprPfvazXH755TzrWc/iuOOO2+FrTz/9dM4991y+/OUvc+GFFzI1NcX09DQXXnghX/7ylzn33HPnVFNfSueccw7dbpdLLrlk+NhHP/pRHvKQh3D22WfvtfU6juM4BynrOI7jOM4cRx11lAXm/FUqFXvEEUfYM844w37605+2aZrOee0VV1wx72vXr18/57GjjjrKWmvtU5/61Hmff+aZZ855/OKLL561vv/4j/+wJ598sq3VarbRaNhHPOIR9v3vf7/t9XrD5+xo3Ttax9VXX21f97rX2Yc85CG20WjYkZER+8hHPnLW+y/0eWf6/Oc/b5/whCfYarVqq9WqffzjH28/97nPzXrO7rZxZ37729/a5zznOfbNb36zffWrX21f8IIX2LvuumtRr3Ucx3GcXSGsXWQpTsdxHMdxHMdxHMdxFuRSxB3HcRzHcRzHcRxnCbgA23Ecx3Ecx3Ecx3GWgAuwHcdxHMdxHMdxHGcJuADbcRzHcRzHcRzHcZaAC7Adx3Ecx3Ecx3EcZwn4y92AfcUYw7333kuj0UAIsdzNcRzHcRzHcRzHcQ4A1lra7TaHHnooUu64j/qgCbDvvfdejjjiiOVuhuM4juM4juM4jnMAuvvuuzn88MN3+JyDJsBuNBpAuVFGRkaWuTXzM8YwNTXF+Pj4Tu+MOM5ycfupcyBw+6lzIHD7qXMgcPups7/bF/toq9XiiCOOGMaUO3LQBNiDtPCRkZH9OsBWSjEyMuJOYM5+y+2nzoHA7afOgcDtp86BwO2nzv5uX+6jixlq7I4Sx3Ecx3Ecx3Ecx1kCLsB2HMdxHMdxHMdxnCXgAmzHcRzHcRzHcRzHWQIuwHYcx3Ecx3Ecx3GcJeACbMdxHMdxHMdxHMdZAi7AdhzHcRzHcRzHcZwl4AJsx3Ecx3Ecx3Ecx1kCLsB2HMdxHMdxHMdxnCXgAmzHcQ5a7bxNt+gudzMcx3Ecx3GcPxEuwHYc56CV6YxEJcvdDMdxHMdxHOdPhAuwHcc5KGmjMdZgrKEwxXI3x3Ecx3Ecx/kT4AJsx3EOSsoqAASCXOfL3BrHcRzHcRznT4ELsB3HOSgpo5BCEnohmc6WuzmO4ziO4zjOnwAXYDuOc1BSRuELn8iLUEZhrFnuJjmO4ziO4zgHOBdgO45zUCpMgS99Qi8EcL3YjuM4juM4zh5zAbbjOAedQXEzD4lAEMjAjcMGtNYY43ryHcdxHMdxdpcLsB3HOegoUxY4K3oJWa9L5EXkOsdau8wtWz5aa3q9HlnmevIdx3Ecx3F2lwuwHcc56CijsEojDeiiIPRCLPagna7LGEOSJFhrXQ+24zjLwhqLbuVY5c5BjuMc2FyA7TgHEWss1hy8vbQDhSlAl9vBmjJVXAq5bOOwU5VS6OUJ7q21JEkCQBRFaK0P6p58x3GWRxlYW2zhAmzHcQ5sLsB2nIOITRU2VcvdjGWnjIJC44VlgTOtFJEXLUuAba2lnbfpFt19vm6ANE0xxlCpVPB9HyjTxR3Hcfapfs/1cvdgW2NQW7Zgi4Mzo8lxnD3nAmzHOYhYbbH64O6dtNaS5ykSQRhXEFJidBlgG2v2eZp4prNhevq+7jnOsoyiKIjjGM/zkFIihHBp4o7j7FPWWqyyCF+CtcsaZFulsNpg0nTZ2gD936pEuawzxzkAuQDbcQ4S1liw5d/B/IOtrELlOaEf4fk+0vfRShHIAIHY59XEU5UihcRih8XX9oWiKMiyjCiKCIIAACEEUkrXg+04zr6lLGARkQ9CLG8vtirPw3aZCz4abSkyjXIp845zwHEBtuMcLGYG1QdxgF2oHF0UxJUaAJ7nYbRGCEHohfs0wNZGk5ucql9FIPZZ77nWmjRNCYKAKIpmLfM8zwXYjuPsU7bQIAXCEwhfLm8PttYgwGqzrGnipv87rV2A7TgHHBdgO85Bouy1FjP+/+CUZQkekiCKMNqA8LDGYLQm9EIKU2DsvrmgyXSGQBD78T6bi3tQMVxKSRzHc5ZLKTHGuDRxx3H2GastIigvSYUvYRkLclqlkGGIkAKzjL3Yg+FcWhtXeNJxDjAuwHacg4W25REvxUHdg52mPcIwRkqPtKvIkzKY1P1x2MA+K3aW6pTQC5FCDoP7vWlmxfBKpYIQYs5zPM8DcAG24zj7hFUGbH/8NYAvgGVME1cK/AARRcuaJm6MRUgBFvQyF34rXME3x9klLsB2nIOE1QbhSYQUB22hM2M0eZ5SqdQx2pAXORpDnlp0XiCF3Gc9yYUpUEYR+2UvciCDstjZXpyua2bFcCnnP/17nocQwqWJO85BRCm1bL2kVhkQAuH1e7CFAE8sy3Rd1hissYjALwNspbFqeWbeMNriB+Vv9nKmiRdFQZqmqGXaDo5zIHIBtuMcLAxYWf4drD3YadLDCoiiClpZ2kUbHeZI6dFrp1hribyIXOd7/WIzU1nZcy3LqcJ86e/VcdjbVwzfkUGauOM4f/q01vR6vWXrpbSFGaaHD4hAgjb7PE18EEwLz0OEYTkWexl6sW2/GKnwBH4gl7XQ2SCwdjddHWfxXIDtOAeBssfa0lZtpvIplC4OynHYadrDD0MCLyBNM/AsWigqjRiVK9JuQeAFw2mzdsZai+4WmGTX7+ynOiXyomGathCCQAZ7JcCer2L4jrhCZ45z8BgE1svRQ2n1tvRwozWdqUlUUWxLF9f7OLBUCgQI3y9nVQjDZRmHPShwJqXA82WZJr6vt0WfC7AdZ9e5ANtxDgamLJKS2wIjYDqfpij27XRUy02rgkJlBGGEQNDLE3zfw2KxoSWMJUVWYHOBFHJR47BtpstelkJj8sVffOQ6x1gzTA8fCLylT0/fUcXwhXied0AXOrPaYjK1vFP9OM4BwFpLURTDYSH7Ok28PEbLlPAs6YG1GFWUY4/lvk8Tt1ojfH/4bxHH2EKVlcX3aTu2BdjSFyCWp5r4YOhAEAQH9G+C4+xrLsB2nIOANZbCKpRW1PwavgiYSqdIVbrcTdtnVJ5jsMRRFa0Muc6pxVWkkCgMfuDh+ZYi1Ujt7zTAtspgc02TnK4tsKle9Nj2RCV4wiOQs3uTQxkuuvd8MXZWMXwhg/HZB9LFlDUWk2t0J8d0c2xmINWYzPW6OM5CBgFUHMdlRs6+DiQLg/AFWil0niOkHLZBBBKr7T4N+q1SiBlDaERYDuHZ12nigwJnQgqEKHuxlyvAllIOb866XmzHWRwXYDvOwUBbcgpUoTDK0AgbRCKilbfoFb3lbt1eZ61F5Tk2kPjSJ0kzrLBUopjIiyhMgfR9PB/8UCIyjyJXCwa61lhMoiiArmjT8TogwKQ7LxRkrSXXORW/MmfZcBz2EhQ6W0zF8O0ZU17MHiiFzqy12MJgegWmU2BThZACWQmQjQACic0Uple4aW4cZx55nuP7PkEQIITYp2ni1tiyHogvyHtdvCAop08cjIP2JVhbzoCxrygF3owebCkRYbDP08SNtki57ZztBxKj7TB1fF9RSuH30+Xd0CHHWTwXYDvOQcBqS2YyPMo784UqaHh1akGNTtGhnbcX/V5ap2iT7K2m7hWqyFGqQAY+vvTpZQlBWPYgh16IthqkwChFWPGJw4g81WT5/BdVNi0vAHt+jrAGbRQqUGW6+E5SxVOdYrHDKcG0NvRaOXmilnQc9mIqhs+kC0PSLtsBuz8Oe18EslYZTKownQKTlPUEROwh6yGyGiACiRACEXnIio9VFtM9OOsOOPsxY6C7GYrlOZ9qrdFaD+sy+L6/TwOoQXp4oXOM1oSVKgiLNQZjdFlVXOy76boGFcTxPZRqY0x5/pdRhM0L7C5k9BhjafYK9G6ec4wuC5wNeP0x6ftyui6tNcYY/H7KvJTSVRJ3nEVyAbbjHCCMUZjdCLysseX0VDon9EKiKEJZjcoLakGNRtggUQnNrLmo3teiaKFVm6KYwtoD4262ynOsJ5CeB1qQq5xqWPYgD6p4F2hM/+IyrgdEfkir3Z0TlNlCl+nhkSQxCbUgRgqf1CaIyMNmeocXhJnKCGWIJz3yVJG2y97VIi/HPwbengfYu1IxHMrgOu2V69RqMPZv1yuJW2uZSu6nnTV3vdE7e29jMVk/BbxXDCsPy1qIVw+RoVeO29yOCDxkzQdLGWS7cdnO/iJrglGIvA37YGrA7Q3GXg8CqMFNtX01NMQWBistRZoSxDEIjbZNtE4wakaa+L4KsPvBo5UarXsUxTR5PokNyvPKrqSJtzNFqjRpsXu/kdbO7sEW/bHY+zJNXCk17LmGcv9YjmEEjnMgcgG24xwglGpRqJ0HwXMYS25ytLXECEKh8YOALEsx2lDxK4xFY+Q6ZyqbwtiFf8CLvEPSaqJzD2s1eT6JXkQxsOVkjUHnOfiyHG9daAyGSn9M8qDX2Mhyu+r+RUWjUaMwil4nG27zMjVcI3xJT2isyakHNeKgRqJSCABPYhI1b2+pNprc5AQyJO0UFKnGDyVRPwDUypRtsWaXg2xlFKlK6aQd2r020pfgles01iy43wyCa8+TRBW/f0PG7lahs0K16aqCdt7GmD3v6bC2P666W2A6OTbT5YVmNcBrhMjYn9XLsxDhSWQtKLMUesUuFaRznL1CZVCkEI+C9CGZArMPe4/7xc0GqeHAMNDeFwGUNRa0oSjS8hwcRSjVQkoPKwr0cLosCcYuur7FHulXEDfkoCS+P1o+bFoo2UUlrUW9TdYPrIWAfDduDhhtwDIrwIayF1urhc/lS60oimF6ODAMtF2A7Tg75+/8KY7jLDdrNdb2exh1D9+vLf61xpKp8rWRakO7S1w/jHY3pchyompM6IWMxWM0syaT6SRj0Ri+nH16UEVBt3k/4IOBIJjAmA5KTWNMBd9vLGqc776m8hyEAF/gC0E36xH4PqEXDp8TeRFd08VHYrSCIKASxIRVjzTP8HoecS0op+MSQOTRTdtUfB9BgDTQyxVdMU3g1dG9HFFkiIq/LTi3ll7Ro510sEYihCSMPbQSoEAX4OWSqBoMx2FvXwRtIdpoptIplFYkSYLv+xgMvXTu+HqBGH5PRlnyROP7HnEUILTAaEmofDx/28XUYlLMjVGkRQ/p1dAmoVt0aUSji2r/9qw22Nz0Kwhb8CQi9oep37tDSIFXC8px8qkqUzBjb7/cZ50/cdZC2gQ/gqCKjccAA8k0VCfK89VeNrM69ICUEs/zUEotajq/PaINWimUKYjrdbTpAJS/I7KDVilQBV8AZZq4WEQ2zp4wqjwvmFaC51URfkAYTWBMRh4U5N0t2MzD9xt43vwzMlhraSWKwJPEgaSdKoyxc4LlHbajf3N2+5uHfiApUo1RFi/Yu/vIIJNh5swTbhy24yyeC7Ad5wBgTJk+KGWM1j08r4IQi0xA0ZZUJ4RBiEg2oYWH11hDEISkSUoQh0gpCWTAeDTOdDbNdDbNaDhK4JUXWUWekbSnEBIq1RV0O5vBQhCMoXWCUm2KIsf3R5GLDAr3lSLP8IKAlIzQhqRZj9GROtCfCkWU02PZwmIkw54TKSRxEGGELnt5pzMCCbIa0LUGZVJqIqTX6yEBrTzapsVIJYYATKaQXpmiLEQZ1HbTFF9HxLWYuBIMK8RqrenlKUWmiCrlOPFd6cHuFB2stVSpUq/WqVQqWGHBUk5DRlm8bPBfgLwoyDJFFHiEFa+cBgZNV3cIMo96WEUIsegebK075BYCv4Ywgk7RpR42Fr+f9lljMd3+XLSRLLffLlyc7oyMfawnMInGGous+Ev6/o6zU1kbrIFopPy3kFAZgXS6DLwrY3u9CYPeye2HkAwC7L3NFoY8T/GqATKwKJXh+2NIGeJ5AUXRBSbKc6ffH4cd7Z0A22qLLTS6mWJsAVWJF1SxucaGEikjovpaRAK2UCim0drH8+pzAu1OVt64GInLzIA2ilwbYrn4tpv+79L2Qbn0JEIKlDJ4wd5NQB2kh/v+7DBhX+0fjnOgcwG24xwAjMkQIsD36+T51n4vdn1Rry1UQWE0DTyKLMMgqOZdoriOThOyLKNSKccje9JjPB6nmTWZzqZphA2ksuS9HtIzhJURfK8GbEYrhef7/WA/QKkmRTGF59V2qYd9bzJal4XLajWMTii0wmKpROXnNUkBQhDUAqSQaKGHFWwBQi+kZ3r4viCfyhCjEZEv6fTa2DSBqEoURURRRB5F2GILlYrE8+rlOGFlkXGAtZZuJwEEKycmqFVnVxD3fZ8iLyiSHFWEhF5IohZX+CjTGZnO8I2PJzyq1epOe5xVrrG5R1yRRNVtKYDWWopQM9mbolKLFt1boXWGMRnaq1P1PAK/zuZel6ToUA1HFvU5BmyuIdmKrIUIfwT2QvArAg8pBaanMN2iDLJ9N2LK2Qd0AXkXokZZrXpwA8sLy4A7bYIXQLj3zqFaa5RSw/P+TL7vk+c5WutF1W/YHdZa8l6CxRBWBqnhlWGw6od1inQLxmik9MCXkJbDbpbyZthgqkWrDAiBkAZbMQTVOtILypkJco2IfITv40VVhPYQ1Riluig1O9AutKGXa+qRj++V5xNPCjJliIPFb0trLHKBoS9e0J+ua+5Xt6SUUsPZJGat3/MoimKv7h+O86fAXVE4zn7OWosxOVJGCOHheRW07mF3MFZ6pqLI0VYTaoU2FuvF5J0ppIQwCCmKYtYdaSkkY9EYoReyZXoTzdZW/CgiqPj4XhUpyx9do2e8RvoEwUS/bZ19UgBt6r6tNO/fusPnFFmGkBLbv1jJ83LMYegHZe91fxyg7Y99VsIMK9hCGWAbazA6x6/4FNow3U1ptaeIZUi1Wh+m0FU8n4KQoijHH9vIYmxOOtWm22rTyaYIK5ooVP0e/xZFMU1RTFEUk0gvR1tFkavhOGy1k3HM1lraeRsfH9/6RFG0qOA66ym8QBLXyl6Wch8rx1uPV8bACqaSKeSMOWl31Aat2xgCrIgIpSD2fAKvSqfo7tJ4QWssNskQnkKgobulTJvdC2NTZ4/LVm5ctrNvpM1yzPV8AXRYLf+yNqi9V/Rs++JmMw2Cqr3ZS2kLQ5Gk+NUYY3sgJL7fGC4PgioWQ5GXQ1wGN7+WqtiZLUxZ16E3mIHAR1Q98Mo5uaWslNlFocRmZlhPQ4QRNs8RIiQMJwiCcYSQKDVNlm1hqtvBl4JatG27Rr4kU7t2btl+iq6ZfF9ijUXrvVfszBgzq7r8TPti/3CcPwUuwHac/VyZHm6RsgzkPK8GCLTu7vS1VltSleB7PkIlCC8grI+VPRR5h0CWKYLZPNVRo8Ij0JI8sKSy2193edtceP6w4vZAecHWIAjGMEbt1QJoaZrT7SR02gmq3VnweSrP8MP+NFwWikJT6/deW6Up8/AEJtNEXoSRlAF1/4IokAEyLyt/x+MxBs2mzVvwUYyPrMT3fZRqk2WbodiM0j062f1k2b0U+STdYopecys6m0YHLSLPok2GMTnWDi5QJEIEeJ7CMk2vM41ny56BfCeVhQep4RHRvBfMg8BZKUVRFPQ6Ce3pbjktjijodru0223a7TadTodut4vSBaPRKHmh6OjO8D0WUt7s0WhZQwBhv8ejEdbJjCEvdr6fDtuba9AJIgygtgrikbIYVHdzP612aYv7lAXT/PJCOlWLmsfccXZb3i17sOPRhcdZRyMgg71W9Gy+4mYz7YtxtlmnixXgxRZrCwJ/ZFZbPD9GygCVl+d2IQV4EhYZYGudzjmOhwUTO3mZuQTISjCcgQCt0SZD+D6yP7OECMvz8GDqRRmF5U3Aov96GRIE4wTBOL0C0qxJ7DXROh2uN/I9rIViFwJis4OeeumLcjjPXqwmvn318JkO+HHYRkPaWvLfEsfZnksRd5z9XJke7iH7RceEkMNebM+rIsQO0rSMJSlSwiiCzla82hhRFKOKnCxpUanXicKIXtIjz3PCMMQaQ9JpY7RmxfhacqGY6t6FDupMhAKwSM8bjlXenpQRYbgCpVooNY21VTyvPvtibhAsxbuWPgzlhVKz2SXwBTqM6TXb1MMAGc0eC6eKct5SPwxJdY+iX9SnEpXVw21R9laIoKz6HeCX83yi0UrhhyG2MATGJ/cUSZaQiwLrG2oiQsoIY/Lh9+D7HhEGtI81Hrpo4PtQWeWhiozAixiprliwcJnv14mrgtbkFL1emT26o3HYhS5IVELNr2EygxCCNC0vLAdB8cyLTFUYikQRRB5hXF5Aep43rBI76K3OsgxPBtRFg55tkxc5FT3/XNrWarTu4nlVutYjlAy/56rn05IxHdUhDGo7LSZmjS3TMUWOCGtlABLWwK9A3imDkyKBsF728i0RIQQi9jFSYFON1dvGZas8R3peOb2b4+wJo8vzXlgFP1z4eUJAZRx6W/ZK0bP5iptZa9C6h5QxUvr4vk+WlbMnLHURQKM1RTchqIdYm+J51WFAO5Mf1lH9G4jlOGxZToG4kzYZo1Cq2S9EVu0HxGUqONYi/H7BxO2HhCiFISMKV5Z1MazFQjlFV6YRoYcIAoQny+m6wm1tNtanMHVGa1VCP0OpJlp38Lw6oR8jBGTKEHiLKRZZ1s5YKEVcCDGsJr63DNLDF8qG8jyPPM/3yv6xVxkDvUkwqhyGEezlPHvnoOZ6sB1nP2dMNuy9Hhj0Yiu1497BvMhQWhMBRhf48QhIn6hSL3uZky4ekiAIyLIMpQqSdgtrDJVGAz8MiaRHI6yhrcd0No2xBul5WFOmU89HCEkQjOH7DbROKIqt26Zt0gqbtrFZp7zg3EXdXKOzjLGRGpWRBpn0Ma3WcA7TAZVlSM/D8wOUUeSFIvACwjAoU/6MLatSB145/i63ZXExNEaX4/1MWr6mVyRkRYYJI0ZHJNWgTt5TKNXBWt3vga5S8WNSXSPrFggJ1ZEqUSMmFwqZC/wd3NMUQlKvrySMx8h6BZguvWzrvKn21lraRRtf+oRiW5r/oKfZ8zzCMCSOYyqVCmEQE8qYsYlRJlaNU6vVqFarxHFMFEWEYYjvb0sxV6bAsz4j0QiZyehk82cJKNUBBFLWKIwlnDlvqxDUwzqJUig9t5r5nM+UKtAZIgCCGQG0lOWNmNqq8qIobZap42ppsyNk6CGrPhiL6RaYQpF2O+TJ4sbC70150lvwhpZzgEibZTGzaBE3FaWEeAxMUb5uCRVFged5M6ZcSvt1PboUxRTGqL0633Ha6YAFEar+zeL5a4kEYQ2tFcaUvcFlQGxB7bjncZAZpIoeJlXlOOqsnFpR1kJkNZi33oIuEvAEUkYk2rA5V2wpFFuwbCkUm9op92UFmz2f+zs9tuSKrblislDc3U7paA1BSCpGyOUoiRF0smmKokXkeWSLnA97MB3ZjqqOe4HEKDvvVJB7apDxNN/wgQHf9w+8+bCNgWSyLC4ovSX//XCc7bkA23H2Y2V6uJkTYJfpwDWMSXY433CWp1gsvtUIBH6lDl7ZQxFWKmS9JlppoijCKEVr69ayl7cxgucH/Tb0iP0q49WVaFtOB2X7v/07+4H1vCpBMAFAUUyW6cRpk3aS0dUeZB3Idx58DWhj6XZTYixBtUIl9NDVGoUF3WrNmhJLFTl+FJX/bxSq0Nt6r5UBRFk8BxCRV47DtuV82FopTFKmVSssUkhE6KMoqPoe1UYdpTJ67Q5alz0maboZ1WmRZR4i8gkruiykZQ1FoIllVAaROyClpFqrY3SVkDG0yeil9/cD+W0XU4lKUEbRCBtkWUZRFIRhOG/gjJHozBLEPlF15xXeyzHlFlUoIhlTC2s00ybZdun+xmQYk+L7DfKy04Vou4rhNT9EejGdvDMnZXMmq205DY8sEDIoA+k5G8cre/aqKwBR9kT0JkEvXeBZXoSX47Lz6QSTK1SRL3gjaV/QqiBPEoos3fmTnf1TkZQX9NHI4nuj/X7RsyIpszeWwKC4WRiGWKspimmUavZTnVcghKAophDCljfalvimjioKdC/Di0H4Bt8fndUDaoyh2+2SJAnGSrAeqj/ERHjlcB67k1Rra8uhHrqToPMcEUpkPSizUhboFQZQeQfphRT4tJSmIgUTgcdE5DNaDWgYQU0KGnFMZC2BKvAFpHlZJbwaBeTWkhpDYjwS22BrJ+C+Zgtheyhjh9Nv7Ygx/QriO+jt9vu/W3ujF3vwne8owB6Mwz5gAmxrtw25qK4AP3YBtrPXuQDbcfZjxmQgvHlT6KSsgPDQeuExyL20R+AFiKyDF1VRpkehO1hTENZGESiyXg+jNTrPKPoVtwcpscYojMnLQLk/jRdA23SwglmFzhZSFkBbgedVUNkkk5P3cF+iuT/RFKLfI7nIH7tOqiDPacQeXXIy00GhyKt1rFKYVgsox15jLX4YoowiLTKkkVS3Tw/vX9yJQIIQhNoHKUh7Cb12m1wowihkpD5CS2dgEqp+jOcH+FGGLgpM4SHsCFnXIlWXIGxifYaF6FKVgoRqvVZWrd1JT0alGpdTbKmonGtc+GjdIy+2onWKMopu0aXqV5FW0ul0hr3V2ysyTZ4o/MgjqixuRFAQBPiBR65ydGEYjUcJREAraw1T1q21KNXu99zH5NbiCfC3n1ZGCCp+jUQXs8Ylbs9mCrAIke88bc8PobainMrIqHJ8dtrcVo15Dw3GZWsKTGJQaRlkL5c8LbebLhY/bZuzHzGmHPPpRxDMc4x2epiFvtslLno2KG4mREGeT2JMge+PEQSjw0KVQkiKYgop7ZIG2GXl8C5Yiww1nlebNaWjtZYkSYY9o0VRkKSWVmuKLEswxpRp4jsZe2yKHJSHiAKoaGS882n4rLWYoof2q0wXmkAKRnyPUEoiKanEARVfUtVQr8SMBB51o6l7Hr6GtdWItdWQVWHAqjBgdRSw0vMY9aqkRcTW6WmSTofeTm6wAouaM1tIgfQEajHjsI2B7tZFj+ffWXr4wLJM16Vy6Ny/azdVh8F1UQ638PzyWLSmrIfgOHuJC7AdZz9mTIbX770ejK0dEELge7V+T+Lciy9jDGmeEQqJ1TkyCDAojDBo3UV6IXEckkxvoTs9RVypUB0ZJc+LGe+RABIpywtDT3qMRWNgoWeSRaetDgqgZV3F5m6GH7Yp9BSbM1n+2CVTO/2xy5QmVZqaVWQBJDqhMAW57bAxmSSJJUXSw/R6qDzHCwKk9ChMQZpnRF68LT1cm2Hv9aB9IvTwtMQqaE83yXVBpV6lUqkQeCGtvEtIgedVy3HxUhFWA4yOKFJJFI8zOnEI1ahGZjVFMUmW3UequoQyxAvL1MTB/MsL8TyPuBKSJBm+9DEiJAgmkMJHqSZTvXvAampBjXa7Xc65OjKC6PcCD+SpIu+PuV5scD1QBuuWPCvTSet+HSw0s2ZZBM4kWKuHlX8zY4gWuCCrBzFGRHSL+W8E2X4Vd+kXCFj8uLigUqaNR42yl6+7ucyIWIriNdaihcGIAJNainmKAO4LWil0nuOH0azq9s4BJG8Dtixsth2VF/Q2TVFsnkJNTWHm28+WqOhZWdwsA7po3R7Wypg5j3M5tKesjG1MB63zHRY43BVFlqLyAukpZBDOmWYyTVOMMVQqFer1OvVGg2p1FKs1vV6zLMKY9kiTlCJb+GaDKQqkF+DHVYxd3HGrVQ+lNW1ZwROCcX/29FRlRXEPm5cVxUUUYbOMdlresGhEc8+vqjBEHhyychxRqdHJ2kxPtknaeTlN4gLnKaPNoqYi84JyHPbOijLaIsF0uth850NdBjc3dtR7PeD7Plov/DmWnDHlPPFGg1pkNs8guNY5VCa2ZUZ5YZlJstj32QussWSJK6r5p8wF2I6znzJG9cf3lr3XZdGw2ePxyjmovXkriudFhtaKQBoEpuyllT5+OI7WSdnDKn1Up40yhrjeoFKpDHsPyh/bFM+LZ1d4lR71oI5C00lbi/48SbfLlumU+shaJhoxoxVLuzdFh1o5bc0OLiCttbRThacVkoKeLLh58238ftONjAQxgQhpoZjyUjZvvptOaxKvX8QnNzlFXlCNYoQUwyB0+3F4IpAUqsBMFWhpqIxUhoWANAHWpPjC4nkRSnWxtiCMYir1EaKqT1wLkJ5PJRzB+qvw/HGSbJJeeh++LW+CiNgHASbZ8Y2Jai0uA8+8LHRW9i6NoUVMrlJiUZAkkyRJj3q9jlAWk5Rp7dZY8lRRpLosaLbI4NpaS7fbpdfrIaUkiHySXtrv8RLU+2Mlp9JJiqLdL04UoIxF223Vw7cXSEEc1OipfN6q8ibVIAWCorzZInehoJgQENWhtrrsHczaZaBd7NmFk8pzikxjpESr8t/LEdwWaYqQkqhajkl3vdgHGJWXQ2Cixrz7dd4qgx5bKY8tPd1Ebd2K6fW2XXgPip4JURY9m6c6drfbpdjJvpFlLbJsEj8o62MEwQiiP6TDWovasgWTZcMgOwiC/lSCiz+WCmPnDRisMeRJghQFwhP4291sGAxzieN4ODZcSkmlUiWO6lSrHpVKBS/0UVrRa5WzHyRJQlEUw5sAxhhMUZDjg4jA6nlvPs9pd9amaUI8P2QimDv3M4AIJQjK8dxRRJIWpGlOI/bn9DhbW96czIoUm6WsqI8SjFRp0saYnKyn6LVy8v7c3jMZvfAc2DN5gQQLZmdj0tOkHIKziFoS8xXAW3D9wzH8ixxbbgx68j7s7g7pyZplr7MXLj69O53uB9fjswsLCtF/n+XLTFKFQWUalS/f8CNn79qvA+w77riDt7/97Tz84Q/nYQ97GMcffzzPfvazueqqq5a7aY6z1xmTURaQCofBrlZzpx/xvAbG5P3nb5NkCRKBZzVSeljP4ntVPL+O9Gr0mveSKUW9GhP4AUVR4PvbKshqnVCO/57boxh6IfV4hG7WIVvEBViSF2y6/36iKGLVijqBX6NRHSEODJtb0xThWPnE3uS8qb69XKONpWIzWqZLiubbN3+Pb9/yPf7vz/4fP7zjB2xutxgbW4vB0pq+j6l8mlbeYjqZRliPWtyfnqsw4MlZvQTWWrI8I0tSIhsQjleGAZW1lkQbKtJg8GZkDAikjAmjED/cdvEcS1leuAYrMLKCFCGB9Mr5rtUUNtKgDSZb+EIjCAP80EclejgftrGGni6ox4cQyBHa7UmgRWBV/6KvbEM6mZQ91/Hig2ugnLpNa7TWdLtdwjAoK/7mCiklAsFoNEpRtOgUnX6hPcisQQBRf3sWuUZtlwbfCGK0CEiL2UXtrDKgDTIQ5UWTPzeFdlGkLHsIa6u23azpbS1TyHdDnqQYLSCwFMZQJBq1j3uxjdaoPCOMKwgpkb6PLlyhswOGteXQBS+cd85rrQwqyfDiEOsHeGNj+ONjCN9HtzvoLVvQnQ5W63L/rozPW/SsKApUUZCm6bzBzmDKxCSZJgyrxNGqOTU9KAp0t0D3pzwUQhKGE/h+QJJsWVyQaixbC0Vznjmfs6SHtQVSGIKojjejxkJRFGRZRhiGcwI76XtgfcDgeZZqtUpjtEEljAmCAGMMSZLQ6XTo9Xpk3S7tXkYzs0z2DIUWOxyaMtg+k2kPvJCJOEL2g+vt564eZDnZQmOETzvXhFoRB3NvnBhlUVmGX0whsha222LUq5BJj7ZoEdUEfuhRZJpeOyftFmjdn2/b7rjA2YDX/w3b4Thsa7FJD4TAZnOvHba32PTwcv3eLo3Tt50pzPT92K1371LdFaDMUCrS8hwfVMqgeWeZFcl0/zVj5Y3b7fnx4t5nLxl8byrfg6wUY8u53F0v+H5pvw6w3/CGN/D973+f733ve1x//fX8/ve/5+ijj+apT30q3/zmN5e7ec4OWGUwe3DicAbVw0OEEFibk/W6dJvTtCfvo9ecJmm3SLsddK7RypKl07N62Xppgi88hCkQngYZImWlP342pEgzZN0jrtUJKYYBVhzHWGtJ07L4zWB6sO014hECGTKdTKF30LuXFpr7t0zh24I1q1YCBUHQwPcjJuo1dDHN1m6GjcfLO9TJ1KxeGm0s3UwR+YJubxIZxdy0+TaU1Tz16Cdy5OiR3LTlev7915/hoz//N65v30mjMkKcGbIiY1P7PjKVkomsvBjQ/d784XY29Ho98l5GGIc0xkaR+ORFOU1NYizapIz4EQpJUbSxViNlWTl8e54Q+EKQW0lhIfJDomglvj9Wfh7bohDTqF4Hs4Px2NVaBVuAKhSFKej0U6xrQY2ikPj+OLGsY/IOhdcizZokRUqRaHwgjBcfXGutyfOcKIqo1Wrl+DpdoI2m102GU3h5WKp+gMKnW5QXSZmxBLLs5dbKkHULsq4im/HDH0lJ4NfoqGzWjSCTDXqvs7JXIahQmIJmNreo2qJ4fjnOrjoBRiN2oziUMZq0myF8j6Di4QUeWS/f52nieZogpMTvTz/n+QFauR7sA0beKW/wLDAVYZ4qhFbEIxWw5QW3CEO80VH8lSsQlQo2SVBbtqKbzbK69DxFz3qdNnm3gyry4RhmGNRJ6FIUkxijkLJOHI/P6Z01RlF0m6isi2p3MXkZTAshieMVGCMoiumdBtk9pRG9SdI8pTsjONVKUaQJQuZIQvx4280GrTVpmuL7/rCGxMxZEzzfR4qgHC7bD5RFIPGEJArLc1W9Xh++ttlsMdnuknVSbK5pZZJO2t1hALI161EUmhVRfVhDotCG6V5Bst01TNmLLei0c2QYUpfzn7+1MqisTRR61CKf2HSpZVPEuWJzV9EupghjQbUREkQeRlvSdkG3lZU3Jxd5Ze75Ox6HbbO0nC2jPloGkjs4h5X7y46rh89Z/y7Mh206TZBBeeMybS54M33uC/vzVgdxGVwPbsLuKL07bZXHSTw6b90DYFvQvTu/M0tAK4P0BUbb3S5WZ3Pdv0ntAuz90X4/D/Y//dM/ceihhwJl8Z0PfvCDfPrTn+YDH/gAZ5xxxjK3zpmPtXZbCmzo5o/dHdZqrC3wvDKVTuuMZifHSp+VVQ/PDzFGl8XJigKtLEpPU/R0OT8z0J7cSsVAEWpElBNQwWhdTvmjDY3GSkwcoZIegREoa8myjGq1iu9Dr9cjjOaOGxyQnkcjatDVKa28xVg0NufiLS009093kUWbNRMjEEjQot/rvpU4bjBSSegm07TC1YxWxsupNNLpsseGfmEzAbZoobRionEYv7zhK4xGDU570LOQQrKpdR+X3/a/3HDftfz31u/zP1GVE0bWceIRj8W3ASNRg8ykJN0uQeZRievENh72/IAgliFeVFaaDad8UpVitKJrwLcZ9WiEZp6SqZzQ84Zzxs4nloJmnuHJkFDafqG4CM/rz50texSdDrrdw2+MILUPSgGi7FkXglAKpLEk7ZSu10ZjaEQjZGkZ+HtKEHmjhI2AdjrJ/RvvxiNm9arVWGNJuwFymO44+F7K/9/2PZX/7fXK9MFyeh5DGdNprMhoTrcQXg2wWDI8IJYhzd4fUUWVjg2pS0g1pJ2inL660kAVMVoVRFUfz5c0ggqTqkNWdKlEUZlJoA2yWha6y4Wk1w+sm90mnudx6Oih5fj1XUkbB5QImMw8sqTL+C7e3c+TDK0tUdUvC76NB0zdm5J0e8T1+rC6/t5kTNljHlarw+/K832KNMFovWzzcreUJpaCcBE9XAc1rcogOKzNWxFfFwadZPi+wItDhOyilYX+Nb/wPLx6HVurYZMEkySoqWlEGCCFh0xbIAN6SUba6SDDGKMMxi97dOM4QKkW1io8r4pSAVIW+L5E6xRri7LatikAi+o1sb5BmRymNxKvOgIhZD+jaRRjMopimiAYm7fgprGWVKXUUVjVpe2FeEIQe5Ks18WKlMAL8UUD+tWxB73PQggqlUr/MUVRbEWIoCy85pXnV2t8jEmxdtvrrTKIsOxFDcMQIT20gSiskCiIs4z6eJV2bwtWdBir1uf0DLeUJlEJYzIgDrd9T3k/4MmUpjLjGkYIQeFBmhbUaxVE1sNqjdjueEx7KdL28CtroDZOGKX4eZeV2SRbWxlblESMaUbrawljnzAGVWjSdlEWpQw9TGQJQg+LXXg+6kCicoXRZt6q4zZNQHrI+gi618IkKd48xTCB4Xjq+QJsay2JSubJnvOGKfo76vW2WmHTLrKxAmN8rB8jdFLO9R6Pzt/DPJBM94cC9a9FpOynd6dlAcDtZe3y2ItH5l8+IL3y2FTZPp8PWysDtrwJnvUUKtd480wdtyPW2mHBP6vNvFPPOctrvw6wv/Wtb8052CuVChMTE0xNTS1Tq/706cJgbHly3x0218MeSKvcgQ+Q9lO7K4s8kQ96CwYXM0XWQWkPP67R1obV9cqsi4VyzFdQjrn2anSzDkbbMp4teuQAGaiiiZCSyug4XtHF+HWyIEXnPaJaOWdxOU+qQUofVUC43fWh1bpMWwR8P6COR2oUnaJDI2xs+8yFZms7QRZdVlQ8wvo4uekgZVQGpsJDCKhVxlF6K90sIfCrVOOxshdbtMj9OqnShL4i6UzTqI5y2/QGptImzzzmacj+GMK1I2t44UNO5ylrn8BdzRv53fTN/HLyD1z1x2uoVcY5/bgzOGrNEeQqJfNSWkWLye4kXrdJPapRqawBIZH9lOrQj0mTLkleUAhLQ2riYJRmOkVuIfJHhinS8wmlINEpNRkR+QKte8PvsswKCJGNGkWrieo2MUkbX9bwZIyx/TmvgLBI6Uw22dzZyOrqahQ5Smmkgl6qUKMNpnuCVnML3U6GVzGsjgI862GzfiE3ISjf0GKtGe4vZcAMeZaT5xnVaozWgxRugecJ6g2frUmH6ekposgiPY84WkkoQwyS6SLBehHVoILNLUKEfO2OSzls5BCese40skSRdgqC2CMOJb6s0lVtoiDHZoAnyU2PJNlKFtbAWHShEVrQUz22JlsJvRBPeEReROiFBDKYd4zkgNKGyV6OwqOXKfIsIa7OP9fufJJ2Ut6Y8AW+7+MFHpVKjazXIu31qI0sfNNpqQzGXgf9qvepSreNeVTFsgTYhbH0tMFYF2DvVNoE4ZVjr+eRZwqMxg8lIgyRvpy3F0sIgahWkdUqJsswvR46tZiiTTE5Rc+v48UVCr9Kt9PC0xJoUU0N9WqM59X61bm3IqWl6GedIDyk8PuVvPtzv8fl9FC6M0VWvRc/Hsfzqv0aDA2kTPpB9uicFPOeNui8HG8cBgGRl9AUVazKUXkHLxZ4tobwt1X0TtPyN7E64ybSoKimxZDnkwTBCNLzEAhAlUU/vRi8fjXx/jWKtZZmJ0cKgxdWiG1MmmaMWxitVGjnXSZ7IaOVgKAfiHaVplOkjHiWKkGZ/dKX9b+LvF9EbNA+ay0tZQh9j0oYYvIeNssQ1W2BnNGGotciCHy8uP/9BzEyiBnx6+ipSXTeYvN9d6N6TSbGj0KGVfzAI6xYkOAHkqST0SxyhLSMjNfLKRe34/nluHBVGMLtAmxrLTZNEJUKCIGMY0yaYrWdd7qyoiiQUg7PM8PHdcFUOkW328VkhhWsGC4bXJ9rrXccYHemAZATq7FT0xgFXn3ltp7ssDr/FHZZp0zjrq4oA+vhiqMyQ8Ta2a/JOuVf1Jh3WMYcXlj2dO9jWpn+VGwCP5QUmSY0dlHF7YaUKT+/FNgZN+ec/cd+HWDPV2hhcnKSzZs385KXvGSHr82yjGxGOkyrP32PMWbJqmIuNWPKk/lyty9LizJ9xQt3eCE7H2vK3msRlj+ANlcL9vIdTC761efpFF3Oe+LfLmqbKpVgrYe1YExBlvYwIqBeqdJJm2ztpEzUZn8/nt/A2EnwNAWWKIqJfYMfVYiiBt7IBNYYhJQIazB5G4xABHWKpE1UtPH8cXq9LkGQEEUNiqJMHZ95o6uYnMRMTaHHxxHSg1xRiSp08g4eHrEfk+SaZpJjVc6YlxNWqihA6xzfr5b7uJVonRNFo0Rpi7SYotXz8WohQViHrEWzm2O8iEy1iZSgMjLK1X+4HIngxEMfPetYCSVQWB51yGN4ynGncPf0PVx23df43R9v4Os3fZ3v3/l9HjP+SE48/FFUihomz7BkZLklKiRyYk0/5IQgCjFNw2S3TVjxCPwyFc5HkKmURhQAcsFj1bOWXCVUwypChCjVQsoaQszoDZEeQW0U1e5hsjZq3ODVGnj9MfdYS6WWU+iEnpdDdYROT2FtQCdN8KLywpy8TazaTIxNsLU3xZbJHocfcijCakgtshYs+MNdng+7VKtj807zJaXBjo/QSafp9e4nilbh1yYQQjAa12mbKRJdgA1RuWFztoXrt9zBHzbfxCPXPprVjUPI0zJdvMgEcRjSVpB2pzFZSBIVmPY0olD4fhVf+rRp06g0CLOQSEbU/Bq5yUmKhE7eQSCGgXbkRbN6t5U2TPXKXvTYpEzmGc3mNEFUWdRxV+QFWS+lMlrrTyukCWJBUAlJ2x7tZpOoWlvUGMXdZYwmSxLC/lCNQhdMp9PlDQbpUWQ5XjD3YntvS5Quex0NNKTY5d+Gg0bRK3vXKhPlBfB2vX6q0Khc41OA7/d7/0AXGlWohec/DgLk6Cgmz0k2ZxRTd6G9NmLiSPAsjdjQ6d1DLgWtnqGajlCJMzwsKEOjMdrPugmGxc2gX3wqS9EjmiCewEtHsYmm8Foo1QM8lBIEwQjGTJNlU7OCbGstrTzH9loYPyDRgjiZopABG1tNxvyU0B+D1McG5TlnUNSsUimPy8G1T553oJURjq1Bix5ZNok2YItKf1qoLkKEWA9sqkFLhBC0koIiLQg8TScLqDV8eh1F0suo1DxGwoKeUmxtaxpxAJ6gqTSxzYmsBethPdk/H1ravR7apHhehST3huOsW2nZW1tvBJhcYYWHShL8GefOPMlRSYt4xSiqrZDVbQU1A99HxKOMjowjOg22tO5B9f7AxNgh+JURisxHa4VROdYz+KIMvtrNLmMTCxRfE+U4Xj+cvd+YtPz9ldFYuX2DANNNsFmBnGf4UFEUw3Htg++1p3p0iy6mMPjWZ3NvM720RzXedkOhnDu9mBOYz6Q70xBVsUJCFKF7PahWEfFY2ductbeNlx5kfOh+vYGwXwR15m+tF5ap40W6rfe76G17flBdXPq5F/bXnc2babK3qFwjZLmNPV+QJYY8K2f8WCyTKawo54e32bZj4WC2L2KoXXnvAy7y+eQnP8nKlSt5xzvescPnvfe97+WCCy6Y8/jU1NS+n7tvkYwxw2l39uYF3M4k7aKchinzdj1tJdXleJCqB5kpx/9UD7jdbEklKuGm+27BWMvv77qewxuH7fD55ViorUhZxfNAm4Tmlq0kYoJat4dQHTZ3DM3piNGKP+ukWgbmLTa3U0Q7xwsSoqokL6pgmmWVVyAUILvTmJ7G2hjVNYhkPaJm6GU9pMyoVg8hTbs0m83hhZDNc/T0NJ1uF3vnnVCrkfe6VNQoqU5p6iahqJMWAlROVeak5KQE6N5GjMkIgoA8n8KYBM9TBIElTSFNN6M8TatZYbzqk3VTut370BWfwAgahc9t5i6u/+MNPGTl8aieYrI3OfzsusjptppoaylUQWwjHrP2CTwmehSbi038un0r37vlh3z39h9wzPgDeMLqh3BMbQ1bCoWSW/F1Uo4DFwKjDK1Ol14vY+2KkKZfw9hpsqJHV3fxinF8b+ETbaYzumkTAkEQqH6AneF5c3tSTbOHnsqxvkD07sT3x4cXwEmRc3+3QytNSDv3UZdVIj/ARJb6SISQim57MyasETRWEqVNtm64GWUko5UQkRpoCURl/h/uwZjNSqVCrzd/4ZmkU5DrFknSQ+sO3e4fieMYKSW9oiAt2ty+ZZqGN8L/3ncNvV6KsClfvfZrvOyhLys/o7bkLY3Sms22xeZ8K5VgFC8MibpN8Kt4JsF4hp7uMRqMknUz2kmbldWV+NIve7FMWRW+YzrDObk94RHIAGkDujn4UlKVmlbrHkzeYvO9d5Noj3q88wuozlSHIk0pAoNWBs+G5Zyz1pL1FGnSIi0U9ZH5x9UuhTxJUHlGpTGCSFI6RYe0P/60ZmIoFJV831e/3ap02Y9owXqScFd6Ww4W1iB6W8GPsEUXmFsDIO0qsJYgbSJrNaxSdHptsp4iyYM5gdKst+/PJa2LAkZWY5r3k/7xDrRMqI5AUUB1ZC2eCEg7GUXmk/SLKdbTlNDPCX05a756k2ao5iTW9xF5gZdG2G6KVA2M6JLnCUUBjcaq4YwV1k7jeSNIGdJTms3dHivyKXr1cYwMaTW3oO6fYlJaklrMyixHFjlUfbQpx12HYTir8rkxKUVrE15RQeabkdUqWudk6TQ601RGVmBtD99XYCX0FKQeWX+GibqyTOZTFLZOJQ7o9FLILe2uJggSfF+TFAH3TWoyCRORh6BJriSiq5GAEYLN7Rb3N3uMxz6pFahknNFKUI7LThT10KOlPGxXYYsMqxKk1oj+NVt3cpqiOw1hDckUdOWwACVAJynoAKNxAPEh3NPZyPQ9dxCLiCIFGcfEo6P4YVlRPS8KulNd0rxHFM3tplS5oUg1cTp7vm/bbCGLDjaqg0hA54juNCYFGrNvOGqtSZKkrNTueWij6ajyHFvxKpCXVd2zNOP2u29nzeia4U33siCqplqdPx3bFjncvxHG1yImJ7FaY6amkHle9q4DGInIphF6CyasQ1BFJFvL4mxxCN3yd14bTbNoMhqO4idt6OTYqAEqRaZNbFDFRtHw+TtlLaLXhG6BDRef5bQnrLWknTKY7mXlPpMnCtOEuL7IGT+MLff/yAMpIFGQ+fNmJhxM9kUM1W63d/6kvgMq8vnNb37D+9//fr7+9a+zdu3aHT73He94B295y1uG/261WhxxxBGMj48zshcvjvaEMQYhBOPj48sWYBttiGT5o7crU/wAWG0xfjkVkRxU20wUsh7uWurLfqajNMpaxoLdO1yuv+8PhP0fxvXJXTziqIfv8Plal8W4gmAFUvqkyRaKdJRqtIpVYzWU9Rg3AZ08QniS8WowI8VuhF52H+0ip0qVetWjUhshiFZAPMo9rfLks2akgYjLKS+s30BX6mi1HhEq4loNpWqMjJRjoHu98oc9DEP09DTZ6CimWmUsDJHVKmkYEDdGmPBX8Mf2FjqpYkW1RixrVEwXPwixlXHyfAueN44xEVmWYYxPGBbE8SgwzvS0B9KQ00D6PkFYpxJpYpnTsKP4YY2fbfopURzzjOOfxsTExKztlnbaeF5IEVYZrUdkOqHaq3HIimM4IT+WJ3Ufz11mit92buCmLTdz2R3fYSQc59jVD+HRRz6UY+M6eNumxGmpDNvcyuqxEfxgFK3bGFMjyKvUq6NUg4XHdzWzJofVQvBGGA190CFaJ4Th3CJDyvPRwsOrj6H8FkqAEQ2ywtDVBY2xlYhJj4k45oFrD0N5Bm01tVqVzvQ92NoolcoR1Mcq5OMVwtuvRxUpwYoVjIwFmKRARB5yu7laBz0WlUplh4VtekGvHJtfq+L7NeI4xhiDH0WMWsEhepTp1laCmscd6+9kzcgq1lRGubV5O9OixQPHjy57Q4oezW6HYDoEUWOsUaUa1PEjj3DsUGQQsTXdyogcYSQaoV6tM51NE9djRsK552xrLbnJyXVOL0+Z7OV4FcF4I8R0O/hjI0RxSKAkhZQ0RseG6aHzHneFwXQV0cRomVqvJVL4YCEIPVIvQYkq2tPU6/OnbO4pawxdAcH4OFG1ijYanWpWBCtIVEJgPLzMUB0d3adp4spa8lwxFni0lSaSkhHf1deYI5mGaKysZi/m7msq10RSEQYG0RV4ExNYWfY8VYI60pPEtflvBJUX5m0iWSeu1cmVQo2NMD15KzE+jdph2MqKsjhZo0G3Wwb3SmlkEGGELFOeASMFkS+JfA8pOmSNKv6accBAvYJoJniVCt7IoRRFj1ZrM3GsiKIqUh6F1q1+XYkqnU7OCmFZacfQ4QhBXIVaxNS9N7O2MYIdO4JA+zSEhIqk1+sxMjIyJ2MmTzaj8zpBYxwRlFXVYYIin6Az9UeimkTIGkFQnod0Jy+zooxhbVUQFim9ZsKa8bWMjVQxXo/IQiW2KNOkUokZ8yegl5HlmrqnqYeGyFQxfkqvUqHV64AfcvSh46xuVLlr82Z04DE2NsZkr2BVVTBRK49729DoboFNmni1GrJSKQOf5jRy1RrqtZW0tKEaeMSNbeeKKFN0M8VEI2JEKTZVItrtzWgtiPyQiVGfatUHz8P6FZT0iaSPjHzGxkfmKVJnSVo5UdUfzmZhtcGoHBnVEaMrMNYirIXQYooI0RhFzhgCmKbpcP7xRJWZQiNihJFwBKMMeZ5TrVaRgSSXOcITNOoNgiBAKUWSJNRq82f2mOnNmNExvMOOQvTT8HUQYI3Bn/kbbleVc8bnXSha0KhBY03Ze93XK3rYwlILalRr/em64iokGYwcOu9c8ztVlWVx1erEzp+7BHRhSL2CSiMYZqvowpB2C+JaUE6/thMmVdjIIOvlucK0C0TszfpOD0b7IobalSKAB0yAfeONN/L85z+fL3zhC5x66qk7fX4URfPe7ZNSLmvv8M4IIZa1jUaVd368QGLNrt0FMmmB9MsLeSEENhCQGYShTGU9QGVoNAIFuzX28I7pO5FCUAkqXH//H3j+g0/fYSqP1gWeF+D7/em5igRkTIyPyAzSDwl9xUQYM93LaaWasX6QLWWIyTxs3iW0MX4UEcgI6UcUFgqtwZbjz0b8EIzB+h54Hp5cTZ7fgxc3kOFK8jynVqsRRVEZjHkeNsvRApQq0JUYmWYgLVhDoiweNSK/SaHbjPm1cm7kyigahZQgRP+9gpAiL8cExrHB8wKq1Ql6vfuoxRn3dy256TFRH2FMK8RUE12v89uNv+OQxhrWrXjgrG1ojcEoxUijxnQhyHRZlMUjwPcC8kjitXIePHE0jzz6ETQn7+VX9/yMn03dxs82/ZKr7/85Dxg5nBPGjubRh53A6NjRiGoVf+oeUD4E6fC4rMoJClsseGwYayhswWhYo2MlBVAN6libAhlSzg7MJRY1UqGjBGknQIkWQVUi/ZBaDCtlgy3dsiCSXw/Jk/KGR5FPoYqMKFxDXIvxfI+KP0p19RryVpfeVItg9QTVSlBO4xVsS1U0prxoCsNwW6BobTmuzQtnFZ2RXoInQiqVKkmSUK1WKYqCZppSWIFHyIrGCm5q/YHN3c087cin8qjVD+a233yC/775O7zmsWeR6hRjDdVKxKE9n42ZJcsKxgJNpTEGcZVu0UUIQSNqIKUsb+oUIZnKIGI43n6milfBlxFZEbGyaqhFlkJnNJNJRGCxAUzEFaayNu1khBWNeMFjL0kzpIQwDimURgifqBKgcoOQAj/wkDaikCl5VmZi7CgtcnfkWbmfxdUqQkq6qovnedTDOkIIEpXgC4HVGrmIuWqXrF1K40tJxfNQCLKdFDU6KKmsrEhcGZs1nnfWU3JFEPr4NsX6Pl4YolSBEIIg9FCFHc47P5M1hrTbwRpDbXQUhMTkOantYgOPidpqRGIwvUkKIcArqErJdLMNAsarE/3fZMiUJdOWLDWkCMyWaYRNqOuVRFGINgVeFGPTDNGwRFGdsqMxxdoUbXI8r4YQgqn2/WQ6ZoUwWCMIKzWKosAaiGIPicCYcppFvyKQWYbv+8OMqAFjFKbbwg/r+LU6utsdbocwqhOGK5BCY2wHpSYJwwbG92g3U8KRiBFgS1LgeZJGHJc9umGAShVRGGHzjDTrkdOgEYccVhVsbW9lugeVPKPXa2OEplqtEFdjKlFAPQ5YkYxwb7vF5l75WzJWDbft95GEwqJTH1EUyFqNIulidEE1XkGGII888lyxwgRE/RtSceDR7KVMtxWBhImoShAcSlq08XseRVQjtZrIKOzmu5HKEqmQVFUo6pU5NyakBD/wMJph20ymkVYhqw16xtLWZbaVwAeTQVLgS4EQZcHyJC/wfI9u2qQwORU/YiRoIBGkRYcoivA8j8gvK7d3sy5pliJEWadikOY/X/BhkjZetTF7WEu9jp6aRmiNmHkeq4yVN6Z6k2XPrFGz5q9WtpwyUlmFDKtltfDe1jItvDq+4KG5Q0Fl29R3++CcpozB8z38GR02MpIUmUErSxDtuA3WWoQGGfnbbrIG/etsd07e6zHUrrzvAfFtXHvttTz72c/moosu4vTTT1/u5vxJ09r2LyYlRluMWVwFXqsMVhlktG2ckJCirPi5m1MQ7A+Mteiy9gvt3fwct0/eQSOq84TDT6SZtVk/deeO12myGePbclSRg4jxRH97ZhKTFwQejFXD4ZQigwqfmRLl1A12ijBqlL1wXkA3z6EoCK1hutfrj2tSw6rVIhgpxwirLlHkDaduGgRgabOJUjm5H2DDGO37ZEWGbXdotnp0M8VIFDLqR2gUWrfKQM0LMKYcU55l5Q8kWmKVT7dZ0Gm10coQRRU8r44qOmS6Q6pSKkEdzxtBSI9r//gLekXCSUc8bm4vcD9lNogiosCjm+a0um10pvGkoBLXqFQa2FaCbieMViKedvypvPnE1/Gah72MR619BFuzFpff8wv++acf4UNXfYjrNv+GwnZJO71+VXcQIiAOahSmwNj594e0P31IJagQSEFmLEKUVce1np2Gba0lTTJaWmBij/pIgxXRKHXdw9omkZH4SjA2MobyoN1t94vuZKTdJlKMEEY1gsgrj0FjiesTBDWfChmtLVMUXrnfmESVPSwwrE8xvAlpdHmhknVmTQGkdYqQCs9rUImq/enb0jJFPIxQvbxftTjk1q3rKXTOkaMPZKSyhoeseBA3b72Jn9/zKwIRULVVvJ4kDjxWH7oWUalQdKfJinJf6xU9Kn5lOKba931iP0b3K/3Op9CGqV6OLyWr6hXqUY2arDAWVGnUVpHoFK9Wo+Epup0O3QWmDlSFJk8ywjjAijIokELihx5+KFGFwat4oD1838NoNWtKpKVgraXIMoIoQkiJsaY8BvwyGKn4FSyWXCj0Ph7mlBhD1B93HUmBtmXRs93RLbrD9P4/GYM5r/1owYrERa6xxhJUPGyeI6IIlef0pqcpsgwZSLDlTe6ZjNEk7RbWGCqNETw/6NfG2EJadKiNHoOtr0VWa0hlEFqTpwm+AInCFikq7UDeQ+RdYtNjlB6r/ZRx0SVMtqB1m9bW+0iaLQwZNg5AWUxSHndl4BT3A10fpZp0u13aucaoFoHpUak3qFQqSCFoNzcRjq2mUR0lTDvIPOP+JCEzdk5wDaDTFjZX+I0VZcBlKfPdKS+YvSBEijpBMIFSbbLsfppF+ZvX8CS6sHSzgtgPUIXBZAWBFChsGfhHDbYmGUXRYSLw8CVUbUGSaNbffz+JMKxdsZLx+hgISdS/EblyfBRpPe7cvKUs0rhdBoyMPIQXoJNyZoe0PY31PAK/QuL3Zx5EMJmWY8DTNCVNeqgiR0M5r3e9ztrGGJHXoCsUQWQxfkS7a8hMhBmpE4YKOX0f3Xv/OO+x780oklcWN0vBgxYBbW2oeZJR36MeRdQDSwR4xiIob7q3i4wteYvpIgdZQ4saU8qwqZewpVBMWsH9eUFPG2pBedM9Fzlpmg7HX883XZctMmyWIGqze5ZlGCI8Ody/ZuzsZdGxkUPLGgYzpvOy1tJVGS0Fm7OUqbygm0zRVYpeOEpmDIWxZZHQXbGb03XZ3Tz/aWXw/Lk3eYPIQ/d/w3eoX9xMzJh/XXiinMbP2a/s9z3YP//5z3nxi1/MJZdcwpOf/OTh44997GP51a9+tYwt+9NklEF6Yjj2WiuzqLQTkyrw5KyDHkD4ApvNrsR5IMn7J7uG79FSmlQb4h2kmW6vV/TY1LmPR659OI9a+wiuWP8TfrvxOh44cfS8zy+rh5thgK2KBKMtkpDAF3i1AIRFddtoLyGs1Birhkz3cqZ7BaMVn6woCLRAhBmeXwOVg/Tp5glBr8dYHHGfhY4S1K0pgyspsNYg/IjAgrUJvh+T9Xscoiiis2ULRkDPD8hCS6UxQiYEW7dMUnRzDj/uWFA5sR8T+ppOdzN+dRWBNWidkuceUkIcx6RtRaUWU+gKvU4XjzpCCoSpsrm5FRM0Ga8eSl4E6LSFHF3DNXd8g9hqHnvICXO2W5FneGGIkJLYt2yabNLudhj1q9S8CvQUNq7g1zysaiF8Q0EVT0oeOHY0h00chvJha3eK39zzK37zx99y1/R6vlekHFM7iiesezyPOPQ4GuEYXv+0mevys24v1SmRFyGFJJKWTr8SredVKIoUrTM8r/x+izSjmSjiFXXGqwFSSqwO2LKlSb65RdVbRTxaJxqp0drapdVrMV6vk6cdMCF+MIIXSATQ29xDBh7BaIPU30pUleiWYmpLkxUrRpFpOWTDhAwLDEkpy563wVQoQVzuL/RrAegOflDBqgisIAxDsiyjUqlQIKmFVSLf0Om2uWHTHxgPVxMGI2zsNTl+/JHcsOVWrl7/Mx418QikJ4lkQDASEsUeW9otjMooTEBzehobWqqVbb37UkoCP8DLPRKVUPWrs84huTJMJ2VwPVYJhlX1i6yLF/g0Kiu5X2ykS85orUrSS2i2QuKJxpwL5SLVGJMT1ysorRFG4sUSocpescKC8D2gQNp+hk7/ZsNgiqE9VWRlVeWg30M1uKlQ8cv392RZSb1Hm3gfzoetTHmTMepvs0hKJJrMGIJdnD5NG10WTbKGYPvpCfaxwbltSbIQsnaZZrpAiqq1liLVeIEsM1aUxsaSrNsBIVBZiudJELq8AA8GmSaatD+msNIoK2pba+l270ebaaS/lmp1BVNYGmN1ItlE5hnaC8n9On4jIJSS1FpktTr7s1qLXxTElR7BaJ2pXkRvqknUzci8HJn4iPw+QsAKKPIcHUf4/ihZZumlbRJtGI8kIR2EP14WGMpbSF+AP47nC+JWhzQ3aCRZbQy7fe+8tRSdrXhRDa9SKW9aCbBFgejf3JWeh9Gaam0CYxJavSa5yRmLRhC5ppsrjM6JAJFMIUyBp0OErJKkBboe4PlVwqxD7o3QS9o0e00q1VGqugLROL1c4MuyzsCgIrfnSypRjWZzK9p0gdnDQkTgISoxZrKH6ZbzkQfRCAWQAlJZYq3Jujl/TC2jvsdIHDE2ElLobemmUggmojp5VtA0CSuMAaVp+5LUaPxqgEnAbL4bsjYjRzwQWakNe+u8oCyGppVBWospElqeh8Jj1PeoDM53YRVUgjYWYUBEHpNpk9D2WFUZZSQaQQqJoUw9b2eaRhwThgG51kway5SyRF6VzHaQSLKsP23kPMeR7UyXN+9rc48LEVcwvS6y0dh2Xk+ny/9Wxvtd83EZZHc3MyVD7kkVcVAnUE1UsQXjVTAyQmsD28X3sr9dpQBvxv9bbcjThNFarWzzcLqudNHTdZlMYTONrIW7NO7ZGlvO7jJPMTM/kORpeSMunKcI3XDduSmvtWesV3iynBN7gQrxzvLYrwPsn/zkJ5x++umcddZZ3Hnnndx557aev1//+tfL2LI/TWX1PUsYemVhH1+gC7PT6bpsocFY5DzFzIQv+xUOLcxz125/l1uLJ6DqSRJt6OxigH3r1juwwDETD2BtYw2ra6u4/v4beMFDTp835dWYrJxCpT+lU551MDZA4OH3x9B61RBZBKheivRiwtBjtBrQ7BVs7nTJs5xQGfzREaxJQYZoa0nabUZ9j9j3iZRiOhPUPIswCuF5FFkPgipBIVEWpJehdTleOgJ0njMV/v/s/VmzZWl634f93mmNezpDjjX0DDQa7EYDJBEECUCkBJGSwhZtRUhX9oW/AT+Eb3zlCzp8YyvC4ZBCirAdDpHiAIMCSAhBTGSj0Wj0gB5ryso80x7W/I6+WOecyqzKrMoCCaBF9nNXlWfYZ++13vU8z3/KqPIcP1lQipAviIsN6uox9skj1OZoztEee2K+4BB6lnisdcA1vS3O14HJJKvNkra7QmYJLTVdY7k6ODYLz8lC0nYju9EyVAfeGff8wt2fInf9PAjevGchEL2nWFy7no8jduyJo2B5XCOFIGmJqgwirwjv7nD7AbsoyBcVKSb84PEq8pmTT/GJ48/xS5/+2zx+9zf53Uff5NsXb/LoGxf8w+/9M37q7pf48oMv8XB1jylM84Ad4zycCoGPHh89dT5HhBRS0hCZYqJQGUIYYuxRKp8drw/93LwKSTMF1qXE4pi0RnqJlCPaaERuMMrQdg2LPKCiRJkNUmhMoQijJ/iItx5VSYQssHFiudxwcXHgIkWO1zWpc/SHAV1mEAK2382otcpI+Ro/XGLCRFadENIAKaLNkqAiMSSKomAYBg7DwDTASaZZrjL+8J2v82S/5Rce/iKvbo6QQpB7wU8tvsQfbP+I33/yB/zKJ34ZUkIWmlwKsgguy8kqx9iMlFOF1xFTiFkvKATGmJkmHibGMN4Om9ZHdr1Fv8+DIMWInTqyskCrnFIv6cPIUX7CBs+TYWTXZZyu3mukvA0469BGgFQE61AiQ2nwux2yLFFmdvSWWpKCAuXJjGGyFqXUv7Eeex7ARnSWIaW6zZ0tdPHMOVHpil61TG6i/HPKwx5jRAD5Uz4amRSMMfFxbYFukOspTCx5foTVn0d57z90MHjZCm2HNBJhuzka6AULB29nZMrUmmQnYgi4aURqTV7X7LZbvLVoo26RyBhm5FoIQblaIa9/9jBsmaYn5NU9kMfXVNrEEBPVYkG8cvhpoouRrKyoqoqu6251srfDjBAkG4h4PJp8uUarI8rwGO8bqB4SOovd7xFFztT3RDsRYmQcJyaVkWWSjbb4viXYc0QIeN9ydPIQHwxjFEjn0RJOyzXtNHEpFXfy9+5ZPxyI1pLdeeX6ZQmEMaSnDNCU0vjrzyuKBb0LLMsMGRtsM9CMCdlekK2XFIsVPpTE9oCRkQtXURnBSbGhuXybd7tHiHygWhUcVSeIcMAvKpoYuWgdq/K919ZNnrLMOHErdm1PkRW3Z9DtayszglC4ywucTyxWFYNiXtSNE4fJc5Qb8qrES0UwijIxJyuEeOsLISLcKTfs/RUXu3dYLU9IeUYdNSIJ2pWicYl+95imv6Q6fkBx9GDOuZaSYXC4qCBA2x0Qi5oNEZMEIVxf58rMA6/yWAste7qxY1WuOCrfo1grZqmaBuoiRylJIWDQEiFgSIYpKoQcWeVL+r7HWntrknZTsdsjq+WtAdzTJcuC2HWkYZhjzmw3L3tvhmsAU5Ck5uxwwVuHd8iynIfVEbvuQFEuWK5eg3FP0oIoFSElYmJeEKREBEJK+DRLt2KajT2D96Amjuvrhe7HiOtKLsw9Ldf50x/j/Li5t58nmbxhjnobyZ4fVT6j1CHexone1vVQ/XFfz4/rz7Z+pAfsv/f3/h5N0/D3//7f/4t+Kf9eVAxz/q68HoSVnreiH1YpJeIYEFo+N+9aqDmH93+pedg2JkSYs4eXOuPKBYYQ39sIf0R97+oHCOBzx7Nm+Mv3v8ivfu/X+d7VD/jcyWc+8PUxTqhbenjA2xFBjUBgnjKp0nWJ63vS6IlAninWFbx1uWN7OPC6TJSrVwi+Q2U5nXWkYSQ72uCMYeU7zn2iC45F4UhCEXyPKVfIOGKSwQqPUiPOgRhHgpJ4k1MLwT4lzjqLRvDwtYcc0khz9oSlMahMQAysFg+5cgcu2nco0oLlcjbTsoO/zoCUaAq0VvgwkeUZe9mxOllyrBXR95hBcegDv/7u7xKT4K998m++h7iWGwDcNIEQTM7hR0fygUoqeqHJFgWy0MSY5muUeUExdT2p6xDrfH6wSc3kRgY94GTNosj5mVf/Cp9bvsrju1c8iY5vjY/55sW3+ePzbyGJfHr9Cr/04Of4/Po1lNJgyhkpEpLsekGihEAJmOK8mFGqwvuZar8bE/1oyZRECslgPVUm2Tc7UhtZnzzEFA7vGkxaoSLYcGAaFHVxghDZjIgJQbfrGe0APmDf6ZFlYhy2pLWmzOHqyRPctKaQCddPLFLN1G/BT4h8Aaoi2hbvR6b2gkW+IeVc5+AqlAHbe1SmUEpxaEYQGfWRIcTE7z36OkJIfuG1L5JdL1BOFxW//PrP8b3+DX71e7/Jz65+htOjzSxJiIGFSFyZDWG6oKzXrMQCZwPBBfK0RWYFulijpcYnz+AHSl2+cLi+uRZinMjyuVms9ArHljZMLLOMNZpd01DmmjqfEVQ7Boh+1sQJQfSQZQrpLDFBsha9qpg6j8wkfkiQgUgRYwzTNKGU+jca1Pw0kWIku0bDBz/Tzyv9rF7fKEOWFUxjQ3B/PnnYT9PDbyqXktEHQkqzdOUl62bAjinio0f/BUU43kgknHPPjad7mYrTNA8IvkFv1i/M3Z2p/zN6rZTEjyOTm9B1OZuVuS1CzQuWvFrircdZh+1bhBAUy+XtcO19R9O8QZ6vkeY+GRCuowV9SgRjUHUFV5eMk6VezqZYNykB72dcxNFiXYs291lUC3oXyZefQBy+h/AtYnWEUBF5dIzIcrq2xflAlmd4k7NUcn4GuYKpa0nxkqK+T1EeEULgsNvjxsRqIcgWFWpyXPU9kpLTIp9ZMs0FKq/Q+VPRTyYjDe/JaeQ10uuco53m2Kx1URPaSy7P3qHzsFhkVA9eQeZLpAvgBHa4pG0GVpziC7DG4cPI0lScLl5BBEEAitxghGTbOQbr6ccREwY6l7GuM1QSDOOBfX8gW2TPRAMKI5G5oXn7HNb30CZjS8T2PYVUqLIgN4ZlntOmROMjtZyTva1/b8COIaFl4mSQvKsz3kxbXlH3OFreAeBkfUJT3qEZ7+PaJ4TunN5u0ScPycsTstzQjY7Rjxg8C6UJ08RuHLHWcnrnzmy2qjIG29BNCpJkmS1ZFh9cdllrP+AzYYTg2GjGBNtUcj7uEYVjWVVcXV3Rdd2tiXCyI8lOyKN7z70vhFLIPCOOIzK/jsvKqmeW550PPJ48vV5RVh333Ijavo1SmnNVstQFsEeECaXqjzyLQgh0Egaj2U0TZVHMvZwu5gE/uA+N60ohEoe5302Jma79MYzFgp/9POQLTH91pvDWEVx8rtlZcmFe5r+vlxZSzIu2H9PEf6TqR3rA/spXvvIX/RL+vap4LTa+ufmVlrjxmrL2guE42Ws9SP7iQ0loOWuCP2bdbCPNX5ADeUqJ0XXEsWFMgrub++RS0IZA8ZI5sN+7+j7rYsVJdQLAlx98kf/f936dP3j3ax8YsGP0pBQQYh7Ogr/etDLnHT/9GQiRIfN+3mg+NWQb5QlDj800WfkA13wPnybafcQAtqoZhGA9juTesU+eKjiSEjO6KEswINyIqTbADjc2NJcH+sWS1aJGjCND71CZ55PrikwJmrKilBLZdXTuQHl0itIZlc/ZDi26Wt2ifCG8dz1JqcmzDGsDb2/PcNHzyTv38eOEUh16aullwVf/5Ot8evMqa3WfwY+oqUUnhayWDG2Ls55sgtxkuFJghEbFjKj1fO0JMS943EAiEeoVyidcs0XVJSavUP3EbuoxWc5GODA5xeKE8nDJF5ef4D/49K/QxS1fffcP+cq7X+Pr736NPzn/Dstiw6vL+xTMEVKLfMXR4j55vqTUBV5ohMx4pVxQ6BxiRz8FbFhQec9yVSOj4KqzvNMdiNOBo/qYxfERKU04tcfbATE2CBuwVlAVEoFEG8FwuWdoOvS6pKxKpqsRUyvkNRpcnjwkL/dcbFvssuT0zhJje2RZIRav3GrQrL0kSydMruNw9V3Kk9fJFnNzd/N5pSSQQtKNE8ta41Pish345vk3+Mzxq/zkK59lvz9gjGazOUJry3/2mb/B/+ubv8Y//P6v87/9mb/LKki07ymkJMkF+/GSV4tj8tygs8i0bxmHiawM6HyF1hrtNC462mmkn3jucA1gxxZtFOoaZdIqR+mKLk4skmJZLxlsy9WupbizId5o3pRHmRznPSIJlBakrkdoRfIBJeazUWgJySOiwk0T1XpD13WM40hVVS91Jry/UkqzZjbLb9Hr3vfk+tmM75uqTEXHjskOt3Tyl/o9PoIUHyvR4YYevnzfQrGQggMzul1/jCHfBkuucmyY3d//IgZs7z0hBLIsw1qL9/5jOcPeVOw6RBhIY0+S91/42d+g11mtZ2bCbgtZTrFcktJESg6pE8E7IBK8o9sNZEVGuXgP/QthouvfBDR1/QkONrIoNF1KGBdxEiYVqeoasduR2oYUPDAbVN2wT55mXEyHLUEmlvURaE3nLEHmyPoBsTlDWkP0EjmOTNbSdB2np6foqoYEdzKN7CGlJaUuGYY3yav1rUFZtIGkMnSpUK5jVR8R2pZt16OFYOFHghspTl975j0TmSF2ieQ9Qs9mTgm4akaUEiwZiE0LvmawG3Q5Upy8N4gLKTg4wSEskG7L0Dwi1ktWqw3YlhQzYpQo767va413gXUhyWPP4bJl7wOLoubO+v7151jhp55DduCoeNZQS5WJaQjopeEQPL2zGCHI60DyhikkjE8sc4UEmhBxJLSP1Pk1UBEiojsgNWTrDZ1rGYPHjhMmz+ZlS5FB2pCqGkXAbR8xnb/DWG85mCVtV3KcJaplxZhXjF2P94HJOXTTcGI0jevxdkdRvIJ2mqA/6Izs3Jz3/SL5S6UkhSwR0fFkbEnlETqfr6+bZIrY7EBKRPlipoooS+J2R2rOEVpDPg/nU4wcXODSeSRwF0+fJIM8IowT2hQcYuQQPCudz0v3Fyy4nq5pmpBSclIU+EPD1ThxWubk18g+fnzhgJ1iIvZ+RosLRT84Sv/xjKyCTx/qEq60RCqBs+EDX5dSIrmIMM/Pu/7T9tk/rj+7+pEesH9cH79mGkz8UzUu4Vp/fXPzKi1B8MIBO8VEsgGRqQ/VfQgtSC6RYvpYzd3BB1xM3Mn0n6px/Tet3jWE0CKsIdmBC79nuVwwSujVRzeWrW0568758oOfuX39d+o7PFw+4I/PvkGI//kzDXSMEyCeood3EDVgMIUmXZtqCSFvv0bkESEz0ujxKeJcz1pGyJY0NlGLuZntDx3rekkgIlKiyXOWXctVEAxDh14EpMyQSYGpwPbImFBqgXTvcDn26ONT7uQlZ4+uiIeJ8q4iU4JhGJBaU63uYpot42FPXx2TmwE7tizyFWSa0c/a5OgT2XUusxAKIRQOy1mz47WTe9R5yRBhajt0snx7/D5CJ372tb+KLhQpVLjOM51fMYwX2KlneXTCYlkjy4xuukJOijLXhChvH0oAuAFrI6pakklB/9a3iIuK7O5rFCrncb9lITXKRFKKKF2hlSQ1j0mULI43/NInf5Ff+uyv8N39m3zz8rt85+J7/LB9wuBGJt+SI1HMlPEkDVEYhhTnBQTQTSODnaiyig2SPFuSZRU/sf48r/Aq99YrimoBCJQqidrR2yeYMqL6gtTDVCRkbhkbR+wdelmxOFrNZmdDIk4JnS1IsSOlker0mLzr6K4uCXcXGJUT5ZxjK5jNzFLyGHOEWG5w2+/jR3BmJCtK5M1glmAcZ+fXED1X7cQP998jxokvP/wSqe/p+5FMCiohyfOan9p8kk8vH/KN3R/yC+1fx8dTat9SlQUpjERZI1O4putKytwxOYMdPcp1aF2gnGLwjsd9w0m5vnXNf7piDDjXk1clUhpinO+XRbbiatoyBEedHMebJe9e7LlqOmqRgZgzcIVSuHFCywyVHCkm9HqJ3+7AOUxmcDbMZ11UpGiJwd+ig9M0/anQUG+fRa9vHdf182PgClVgTEY/dixWL+ecOzeHbj6rP0Tf9/56Hj0cZhrvjYFf/ZLzdUzX8XKqnlHdvyCjM2vt7NReFHjv/1QDdhxHUrdD14bAkjBadPnBBn9ennh0JpFK0m+vCM6zuHcfKRXWziit1CCkZOpb7DihjZlz0G/jFz3D8CbeR8ryVZJUJDxKSmw3UByuECIxlIo6U8TYkU177JMfkp3emT8vIQjeMu32yLJApMR48RZ6o9HBchi3hLjGBUOeLYj1OOugrWX3uKc3OWVZUtc1uzRfEwogOkS2IMqCnrtM/QjC4+1Ipgz5OmdMHulGVDZxtFgQ2o7zpsUPV1RVicqfHcJunKWTtQitEUA3jvjpkpOjGqkyHJFtUxOrjHXlUPJA310hqRlDwX7wlJmg3+QE27D0nqq+S5taYtAzmh/jPNilhB0a9HjgqM7YmQ1XnSMXIyI4cq3Qhcb4imHoyVRHbeqbD5kYBqzMEe1Ac5RTmgxURMqJqAKjk9Q+Qq6o9WwEe2YDl5NjXcx/X2wOKB1oCkmuNZ+pXufx7pJHzQVVvkIVOSgYQsKHRJSC4u5nSbsth8MZfdoi+wO+9FxGg5oCdVGzXB9zvttzdtghqoRQktV1nFo79iiyDy4qrf1IfwIpBA/KFSJZGtuiTT7Ljq6p/brbIcvn08Nvf0aeE2NPHDzq7ifxCRrv6UOkcY48eNYCfJiIKHSxQWeRYezJtGXrJkphML7j2oX0hb8rhID3nqIo0FqzzuZlyM5pjo3G6Hz2H/lg+NC8AOnnv0uWmjElWmDygZOX1D3HMC/anmdw9nTpTM252DE9i3Q/x9zs6RJKkOzH77N/XH929eMB+9+h8tGzm3YAnJanH/v7Y0jo923NlJYEF+E5fWOyc+ST+CiKzDX6kXz86K99qlycNTT9x0RJ/k0rpYT3e0Y/kKhJU6LKAykMdDsNWtBliqI0SK1eSH2/0V9/7vjTz/z/L93/S/yT7/wa3774Dl+4+/nb/z+7h2e3Bkpu6tCiYESQ54qh25KSo6iOUCq/1vNaTFHN71PTYtuWI6NYH53STJZkDVFOBNeQr16hH/esZWInZz2YcYl913BUKZRazCYZxlxrknpUscF1jjFPnDhP7D3RZNQqoVygGUdkjNSLBXiPqTOIm9nZ/OKCSMPxnVcYgcY2s2QAnnnIROC837HIaxbSkFIiyzLGMeKV4Xcf/Q6n9YqfuvMFhhjZ1Bkx27BrOob9AWOgrjwqXOHaQBgbxKioM0EaJ6yIFEUFwRNtj0eRFyVCephG4uAZu28TN6+Dj6T+HYISaCQIRVYcYTWgM1IqENdGRneX9ziqjvlf/8R/CsBu2tFOLYtswTgeGIc9w7hjDI5H3pOkYteOXPYNRu7JgLHp6bWkcQd+7Yf/mF9+9T/mc8f/ITHA0Fi0kQhlsLZDak1WFkQn6Z9sYVOwqBfoeolX8nbjna0zhvMBtCYmSQgj3mnqSpCNjv1+Qr1yHxMgjR5RGUJor689QxKKPC8RmcH2PSkm8qpCaYEdAqOPOK0wIVHi+c7VH0OK/Ozy0/Rth6wrfILQtUgl0DbyKw//Bv/PN/6//M6jf85/9fn/gqGd2EZFNIE6P2UMLVkcUCJHBItZrxh3Hb5r0UcLXEh0EyTtWBTPZ4+4aSIli8mfzTPVqqBQij4ESj+QL9Zs6onziwaxWFJXiZjkrN3zkaw2MDWIzCCyDGH0TBNf5Ljpmh7oE8II3DRR1AvyPGccR5RSmI8Zn+XGEZVlt3TvznXkKn/hklQIQZUv2A3neOfQL/P7rmN6Pi7C8Tx6+E3lUtD4SEwJ+RILUBuunf6lIapI57o/d/PLp5tsmJG7j00T95Z4/hYiBUR1iqxzwm5PnCbk+6JBbyRWptBMfYdrO/J6NvMKYSKlgFI1sAMRabc7inqDyt7TSqcUGYa3iNGj1X2yrGT0ES0FjohrD2ykYDQLRikYJVBvqFXB1OxxIZEV8+vKC0UYBsZxgm4gJU+5OsaFEWv3+JhwsaSUOULnhIWh3fd07SVHr30WUS/onSMow0rLmVKbEmPS7AdHbkom2/Pu5QUGw5EpKZc5vR3miL/xgFzc5c5ywfT4jMfdntc3r3/gGph12LNeHRUZuoYwHqiMQVUn+CjZnT9id9VSVSVu9KjlmuhzWr+nDwdEIciMAlFRFxt0HGA4RyRPUWQ4B33XUecaugt835MVNdTHqJg4ziKxvyBNB7LqBG0kUhhMzGmnlkxlGGnAdgz9hNM5KTjyrKDShtbu579DOqI0WBsoqhksqJTkTmn4gfWcTY6jcSRMFr8yoBWbfANesGLFPttz8AdMW2NMhgKMMKDmRBB7csq6KHnlsMc2l4S2ReZLYgGyhCE26Cywu9yzsUseru4hu3Nimggp3kp6bi/va4ZHVT1/wff+z+m4WLEbdwiRcZCSA4Jsv6XqWqrjBx9xL00IGfFe0UbBED0ueKbJUqTARhvKPGM7eYLPWRSG0ijecRY/DsTMsVMVpzEi/PQMvfz9dYNe37A3jDEspokJ2DrPicpQ7jB7qrxvKZAGDxFkrRFSMNkALjCGwGFyrKuP9uAI1+kAL2KD3pTOZrMz/z6zs+eZmz1TNyyjkGa6+I/rL7x+PGD/iNWfNvbl6eE6pogNlky9vPFOivPmS77v5lVGYnv/ga3YjF5HRC4/clv2TFzXSw7YPiZCiGgEvYhU8vm0mH/blVLEuR0peaJcYXtP9AGzqliYnoimGyODDZQIKnVNP1azLkbo996PG/31Z48/9czv+Nn7X+SffufX+Orjr98O2HMMlEOpeXiLcSJ4hxZrkhRoAeM4AAJltqS0QMqMEGZjDllo+kNP6FrKfEm5WCKDZz/CbueRuUAwIlKgKJasx46d8OgIvT1QDgXr4hRuIiKusyFj23KYNMtyTRl6rsaMpDWZhGHfIVLGndUCkSJTt4UqQx/fw15tIVmUSfjRs1is2UXPtt+xFCvkzdIlJS6GjhADnzy5T7CzXiwzBhUT3+qesB12/Mqn/0OOqoL94Oi6CTV6RF2zqnOUypnQRBKT6EjJIJJnqQT0e6YIRZaDH7DNAfIjYrC023N6L6mO7mDcE/o3vkHhHe7IMt55yHLxkCQFpTnlqt3jqwW6O5ByjShqcpUz+hEfPUooXHAclUczslFsYMPs0O56PtHueWc38Kl1xv1Pb1gvJOPlOaHNye6c8o3zH/Jff+3/xm+f/TZf/uSX+anj13BTwA6WabrE+xWSkSybaIbASlVoFCYanJmH65ttty40ulDYKSKyDNs3hP6SsqhZfOJTXF60bC+3nN45QdqA61uSCmi9JoQWlCHPTonaQbbADQOQkDJn6Cy7a6rxybrGu46vP/ojXjOnHJsFu3qBMYaQIIgS3bSoZuRBVvOFk5/km+ff4smD7/J6dYddCCSryNH0ylD5DhkdQkhGVRAK8P0VcRxoXaKUhrwSjGHEPIfGZ8cWZRRKPUtrlDKn0iV7PzHYjjpYlusl26uBfd+TGU1eFEzWIdHX0UYedbQBQGQZaRhQSiK1IEZJnBwSQ7iOCsqyDH8dw6OUeiYrM8b43GxjmN3vYwiU9WwXNvpr9Np8eHNbF0u24pxubFib4w/9WoB0E/0U00s7zb6IHn5TTxv4lS/x81x0KKFQUmEwJJfw0T/3s/yzqhv0WmvNuXUUUs1RiC+DYscItiE2O1KI6HuvQ1EhgZgZYtc9M2CnOGuvZ13liBtHssyQ5XMWewgdQhiUqvHO4kSHNhmmyEhR3DLKhuFtYhzQ5gHezQucQ+eoc83QjWhnKe6dILyhs54mJqpySbE5xfvE2HnMekbDBVAWa3ZXl9hxpFgfoY9fZQgR2pHkAz7MlOiUMvb9uziZs1ltqOwOt6i4colMG3IpwVkGHzkAhVasq4Km2V0nEVQ01jNZRZUVuLhkHLZUpoFswWkasXXJ2Zgw2UT59HIiBkQaCdst1q3ZDhJhTggx0rUJO1i6vUBKR1UskWOkSIq9NzwZwMYrToykTEfUxYJpkgS1xod30d4itKXIlnTNOS7kpOwElx9T1RVIiQseLQQ+WzK6PaUfyZXGpUAlShrrOKgDx/kRcWzYNZa8rIlaUEwBKwRCenJVMzERVGJygcInMPO9UmvFiVE0TU/oe0SeZtO4bI2IknFw1GXGcXV/9u1wE9ErYpp9TESp2cWJSimOqxLbdiShUKngaHkXbXJshEkrRA7rfEF0atbzqww/9ghToJDP9He3nhJyzlpP1oF381n3nCiuXOUUusCGkROd4ZRi9BPWB2JSrF60RIuRNOwYipp9l6DtQMnZpFUp7tb1LB/zke0wsikXLIv5rFgvKt65aMjdQDRLDkmx9uMLB+z3L9aAW/+MJZFGSK6i4oSEDNO8mbh5maOfI2hLcwsQWOcp0pzs0LqACZHqI3x5go9I/d5zIKTE3gcKKSmfWmIKIa7PjPfMzl5obvZU3cStpvAUY+/H9RdaP/4UfoSq8YFd+PgaipvhWiA4yo9QQr0wN/ZFFcLz3Q31U3FdT1caZ6Oql0Wkb1Cfl10g2JTwfUc1doQ0o9h/1pVSwLkrUpqHDRs17X5iWWdUeUkzJarcs17mRCM5l0CpEdlseJFGT2wtobXE0fP9y++zKdbPuHMCHFfHvLZ6lW+cfxMf50zLOZ6LW+q3mzqSAyFzMJIUHLbriJ2AVBJCRwj9vAi4plp2cUcmBVkqiRgKFVgIQTtEUl4zDedIVRLNkrI+pso1PnTI8cDgIKT4XpaiKUEIDk/ewUbFaX0XkSsudhdoIjIzdPuGoZkbUylmfXOUOSEv8FKSC8tieQRJMjYNtazwLtCl93KW99OedowcFwuqXN/qIkPXkWWG3z3/Y4Qw/JUHnydTiSIJ9ruR3k3IQmIyzeJkiakLXMw4jIA5IlUbsvVDsvouY75mVAsO3cRln9jbxG6/o337hwg/MAwdu/qY4c4Rq8UaLgYO25YYBEhDVR4hEYyZAVOSmh24YTYyS7A/XNJ0OxKJQr3vAS8Vk6o48yt2VNxfZZzIHroD0+UVQkf200i33/N3Xvs7SBH5b7/233GYekwuMVWHyiR+yhh2EEaLCwPLe3eQOsM5hx88759v8lWGTBLXTQxXFyRGsvV9ZLXi6O4JeM92uyNpgR/2JC/wvsFPLVIt0XoFcV6Q5HWNG0cOuz3b3jIJwXGh2SxKvvXkG/SHHV++99OkzRFBG5ZKoQRYIVHlkuzoDiIN/K3Vl5Ax8T9++59glWBVKh6u1mRIrgbDVT8Sxi2jymhiYswyRi+4vNxS5RnLXFKo4nYIfbpiCHjXY7ICeY38hs6RWkdsPHQJMwm6psNdbnFXlpUwuObA5aMrYu8ZrwbkGElXB+IQSGMiHCZSUvNC0Xt0puaYISHmLPcY55x65vg5IWbJxHtnSqLrultTrfeXGwaUMajr4a73PZm8RsY+pLTSlFlFNzYf+nW3r+OWPTQ3YC9TL6KH35QSAi0E00uezTbY22HaSIMUEnt97v15VIwR5xxZltGHiHUH+uAQQuA/KlfcjdBfzGecl4j1XcRTkXKqrknOE8fxvW+5zlwXwmP7HlMUaCERWUaMdl6oyorhN/9n/JMdOlcsjo9J0ZNIeBeYpieE0JLnD0gxmxH3OMdEZ0rQ7/eURUZSGVmhkSFyaEeMMQityTfHhL7FPWUYluIc5ZSiJ8iETAJ7+Qbin/4W8u3v4YYOay1ta3HeszqqqE8/RUqS2JzTjx3ljct239M4QXmdZOGcw3vJopTcqQpWdUYE9qNnTGZ2n+52xGYPwvHg9A55XvGkmw3YUozY88cMTx7RH0baXnPWl0S5YFlUyBgJ7YSOkVznLPJECJ699Pxx2/IndguV5s7qdXL1EIVBxAYbL5ncHqsU2mxg/xZi9wOMSExmSa+W82Lxut/xMVFIgTEFo5wNuHI9G6LJTFFS45xn1zyhPezxzlCeHiNXBXKyTONArjULs0AgkDowhUj0zw6oCwll19CKyIUWVGaBEpqxc0glyCuNEBKtN2hTovOerHY4BWcHh20tbK/wbYM2OetP3CPfnOJsQfAKkxJLN3EsNHcXR3R9jw1xHrDtgC4MQsjZGdt7XNvi9ntU2+LPLwjbHWno574txjlf+zm1MPOC0DGxEHDiR9TmlEtruWjaW7nO0zUOOy5c4GBWKAFxt2VynmVV8upmRZHn+Jg47zqUEpzW791vqzKnymuadqAQgUEaBvv81wbvoddPs4tuFm3Be460JgnFLkiSe+/nJBdmGWSub4fWkGaKfiYElRCUcZYzftQ5+H6pZXMtgTz4wIXzdD7c9sc6m5ce3oXb1/E8c7P314/zsH+06scD9o9QZVLgEi/dsMCzw/Um36Ckut4m2o+Fhkf/rMHZTQkpkErg3XuvKYU4N2y5emlUWWgBpJd2ObQ+oHyLSB050If4p0b3X6ZidFh7BYAxR9ikOd8OZEJyelSwLjO0Lth2LYtcc6/O6K3n3XHWNaraIBfZvOXUkkO/52x3xqeK14m9x/UTfnpPc/il+3+J0U988/zb179/Qoj5YQfgphaZcpJWSC1xY49rW2w74K8sSi5JCZzbE0KP9SP90FDlBXq5ABeJoyO5kaIqUGScdx3OSobWEWTGankHXWXE7oDth/kBla6XIELgxsjVxZ4ir1Amx4s1poAsG9CFYLHMcWOguRxJ0zw0OwzjOGKO1rPucOI2v9W1HcYrPI5uaGmHhu3Ys8g2rMuClNwtfWtoGg4MfP/wQz63+UmWZsWwfYwZeybb8bjZE51DGYOUiqzQqApCjLg99M4yjInBRi6c4Ky1NA7E5gHre6+yObnHSmvKo7uU5QKX3aUpj4mv3KM8OsbtWrrHb8J+RFiHEhrrRsRyQ0oZqd8i/AjOMwwt3XDASPMBU6p28jzejxDh/skRxfFdUnmMnTSMI2P/No/e/Q5GeD579/P8yif+JpeHx/w/fu+/xU5XECPRC3B7qrqkzO8glafbb0nBY5WDaBHdbPpzgzDITGHEiN3ucSEn39whivnfdJFzcvcI149c7s9w8YAfelKMKL9E+gKhc1TShDCgswyRlZxte8Ywsi4zai3wTcPX3vwKCMHPffavM15rzHMpKKRk9PM5YY6OKe/fYV2s+Kv1Z3jz4gf89uOvUeiCOs+5t8pZFwVX/azDvwgZSsz05C05wk2cVHpuiNI8iI7+2WZqzpC2mGstZ/JxpkVnElFoVFlRVjlUNUM64IWgOlmxXuX00dEmT1KSYmkQMqKOlohC0+Nxfk5XSPaasi/nRifahFQKb2+WY7OuN4RwO1B773HB4Z6TW+2tJYZwq72ewjRHvJmPNusBWBQrnLe31OsXVbrR7mk5G/S8JE38w+jhN1Vc67A/6my+0V/fuOvDPGRP4fmLh4+q9KdYuFprZ3RIa5r2Ceb//l/jvvq7WCFfPGDHAP0VDFuQmqiWJJmj6mc/I5FlsyNyN9Peb9BrKSJ26NF5jlH6WlI1M4+CTwz/+g+x/8M/oPi1/xmTa3SWk2IkRc/Yn+PcFVl2F6VWhBBm1M1HlBS4riN4R7FYMlxnymcSpincxoWZ9QptcsaLi/l9S4mpazFZRqEVPk4M+3Pib/1rzDffQf/Gb9Nevc12fyDGxHp9h3yhQGsoTxi9QE0HMtvRDJZ+GKiqimU+a5rP2w50idGa6EaK0nC6yFmXBqkUvaw523Y0T96EQpFnC+4vaqQxnPcDh699jeH/+H8ifOUbmOV9plSQ+cjdRUZhFNFdZ6nnkn2m2ZWCN+UV75gOrQU/fXzMl04eUNcLgs4JtqLITjFmwRQ6xuYxMfSEMOHtHlOs0dWSphtQYkYPw3W8kxaCQgkmsyBGT56GWSutBJkx0EsO20f0LlFkNXGRkVcFabJ4O1Ka2aQwUxlSepISTON711kKAdUeiCIidJoXZkHRNvN1WjzlMyGEwJgVSi1oY8eQ9Zg0UQ0j427AW0VWLMhKgT46haomegiTog2eJ+98jUr2ED3bYSAKhe97ZN8S+gP20Rnu4pLh8goRI6YsUasl+uQYfecO+uiIVEjiMDz33lNSUZsalxxjc4kJjnsndzlZLGic4+1Dw3j9bLIxctk3XHUtnozCObzWOCSnZcHdukJKSYiJXe8IyXFUmWeYLlIKTtdLJpewQ09hSg7e490Hz5Mb9DrLPqg1N8YQQkCkyJHReJWxn+ZlVPLXjuFGIZ/KrZ6uWUCZEJAECwEG2LuAj88/B4Oft2I3A7aLiTEmllpxajSZEDQhcm49rQ+3Mbl+ih9pbvZMaQnh5YGsf1uVUsLZP91Z/u9y/XjA/hGqXEq0gO4lEYbnDdcwU3YS6WM1LzGkF2pDlJHPINhxDCAF8kPQ62Z0bLv3Gr+n47pepsZhQMkEKVElR0gwvODw+rAKYcT77kO/JsYJ57YIITHmGCEUF53FT56TZUYuHdI2rMsF1geaoWOZG+4tcvaT56qblxlCijmyo9B8f3wbMsln734aSHS7luZiT2gssXd8+fQLQOKrj//oOn/cIp+K57LjiFEFQYJMMO63aKXRixI3TKSrFi0WSJkz2TOa/l2C96yyBWpRI4wk7Bq61lKtF9zJNM2YM7kGqQRj64hCsT4+wSxPcLtzhrHBOTcf0C5ycTYw2sCyzmd9b1Fy9/QUkXpidDx4cIJeKqZuZNodsKmkadprnZNALVeIIEldR7lcoUyBsBHtE/vDjt1+hwg5R/UKJRXBT6QYkCHQ7Xb88zd+l+AsX1p8ju68p99vmVJHlUOWF4wYdF4QY2J0ge040IXIfvLsDp5x59BScLzKyUPPujDcOT1mURji4ZJpmjD3XgNt0ClwWmkau8Wffoq0XDNEC0MkHBpMNzDur2bPuWJNShnucIbsR6KC0Y3kTw0PISa2neWqmwgx8WBTclJnTDFhvSLKGr24y+PJM9ktD8qcpZz4q/e+wF89/RTfeOu3+Qe/+99wePNN2re/Sx47jheKtdas64jb/xB/uKK5OCe6PVI02P0Z9uwRyY7QX6HMQNIVQh4jpSGE9+4DU5Us14rD9vt01pLpI5RbIdAQIilpFHq+dseGi0OgWi5YLTSpb5H7Pc32jO8Nb/OZez9FJnPG6/g6IQS5FITJYxOoPMPkFfqo5pde/3kMil//5j9DjzcIn+BenbHKc/ZJsO0HsIF+8ohFzcoo4tRdow2BXOf0vn+mibBjhzYGpcoZNR49VyEwaYnMFCovUZmgXGzo7UjCki0Ny1VFvaw4u9yjMoOSHplr1KomKMEbYcej6UD014ZLQtwO2SlEEJpg7W3TqbUmz+fseO893dixszuuhqsPDNl2nM0BlZ4bx971GGmeS5lO8YMLxqIoUciPRLHn1yluoxRfhkl0Qw8vPsSgCOZ/T8yMow+rG0Ozp5H5TGX46D/ARvioSjHS7Xe4F6Bpz6un0evOtYSvf5380Tnlb/wLhuQIMX5wyLYddOezzrg8guqYOIy32vz3l6xrkg+kccRNgeA93vUorcmrer5+lCQkT7c/x/We+K++gs5y9JNL/Fe/DiKgjMHaM8bpEq02ZNkJzs1Iu1KKyQdyJegOe3RVIKXk0gUOw0huElppuutBTghBfucOYRyxTYMdBmKMFEWN8QcynWgenyH+4JtolcGjK4ZvfhU/WRaLBXV9BCoRhQNdMIiKUmYctk/omyvqTJIbQ9d1XPYDXmlGU7KfwIXx1p+kMIqTRc6dzZKUDOeHK3bW42OGkYLTPGdoJ/b/w/9I6Ef4zd9i6hpCrlktNbFS7IBtpthVcOYngrZMyZJEx2vLBV9Y3eckq7EJohCEXM291JTIhEFOI9oZZLaB408yCYub3sKIntF60vWiyl33GUYKSikRUjOoEmE7MgWjCwThEJMlR9E6IFOETFGVBUPy4CZM0LfXeRIBaQSjDTMbJiXCfo8Qib6UGJHzWr3EDoEr51Gl+oD0LqVEm3LayaDtjoo965M1q3snuMEz9iN2sMgsJ+kcdXTEzh64/OF3aZ6cM7zxR5Rdw+GdR3SPLwhth5q6+XwsS0S9hKMN5d27qNUKWZazARyzg33QlpBa0vB8dmRlKjKT0RyeEIVEVUvWecYrqxUiJd49NJxPjvN+YNidkyWoTY4zBr1ac6cuqcMNoy+x7efPo8wjhX6PGZbS/NxYljl1WfFkv2eZZUgh2Y39B862G1nI87wxtJ418c45jBSsigobAvthNl5DCUTxbJ/rYsQkUEaBBhFgIwRCwNZ74nPOwuAjiPcG7CYElJjd2LUUrI3mTqYplKS7HrR7CdYFog0fam72dM3Sn5cHsv5t1dT39IdzvHv5M/nfh/rxgP0jVpWU2JhuD/kX1YuGawAt9cdGB0KIH9Bf35TScr5nfSS5GRmS+Yfr1QYXsCHinloWvGyMgA8RO/VkmZljHrwll4LuOfqfj/5ZLSG0t4fy+yuEEed2SJldD9eSw+AZXKCWkqqUMB3AdpS+ZZEZmrHDhchJYViXhp2bh+z41Gf23avvI4TgJ+5/jmDAionRtfRjR/SRZar5ZPka33z0TfpuN0cBXdOLne3AR0xe46QgTI5paqnrJdlmQVwsCUKTdi3KVaQY2e3fRCdHrjNEXiIzSG5k8JIiOqITLBf3ESYypAkhoD90iOQ5evg5kIam2zIdzrHtyP7dPeeHjtXJmtUCRK5AwHpxRFkuMdlsDFTUGZYOIyVTUPSHESUMMY6orEav1sRhJA4D2hQUiwWlMMRuYOocekrIsWVoWrrdBcPhgG8O+Gj5/bOvcX91n88f/SRaLVnde4iuoagrXrl3Su8Cb182nDUj+8HR2IFKF6w3mgd3KjY6I5eSTa4I/YGgK0yWz1mYj95G1Qt8veLSFNi2Y21gU1jKqiYUK65EScxzhIDClISmY7x4TLQjzueMk6eSnizTCAQ6zffg5AOX3UTvPELAcZ2xLg25FAyjnw15guWqs/SFZlnWLM2C3IM1Ff/lz/2X3Nvc59ff/QZfO38TR0515zV8fgz1MZuTzyGXK/SdGvINo1gwmROucsN+vCK+9SekacAWK4qjDSoo/KSu5QQTIYxYd4kqJ5bLJa5f4YQGGwmTJwEpzH+TtYLz7R5F4uG9FfmyJtsdGLZbvta8gZeCv/L6X6b3Hus95fVAZiLIkLDZjIBKmaOVJzeGn//sL9JFy29951/gt1uS9+QpIhOkes3dKnDZWkRIlJWBosZ17YyKxUgmMmKKt+db8B7ve2SW00XB2eTYj44xBVo3N2zyerDLdY7zEhcO1xFGcOfOCVPvaMcB7IQo57iti/6A6DuG2NGQiP38+3SmEOY6B9Vd5xPb95aJeT7HIrVty7bfUheza/Zlf0mI8znknSN6T3ZNM3bB4aJ7rvY6hjAPlNOzzYtUmkKX9FN3KzV5XiUXbzXXL8sk+ih6+E1peZPz/uE/zwaLFPKZ59QNmv1RCPz7y00z0+aGmv8yZW9ZBpHGHsi/9UN0EujtHvndP6aP6b0BOzjoLmE8zFKZ+g6YYnYO9+EWvU4pEdqWdP19whhkkeObOWYu+gFlNMViOSOjw8DkLO3uCQhBaQXq7XfQP/E5RF2Tfu1fkIYDKI+zZ5AKtJrNSp1zGGNwMZESyL7BxUS53tBME0kIdsNA8I7VsqC5diEGyOoaXVX0Tx5j+46sKOBwSXQN1fF9wm/8Fsl64v/qPwNdU3zlDzGhpSxnN34hDElNjEIRpSR4Q+sNC7eDcc8weUZAlBV1BistiVGzDSNtCM8MPHkK3Ktr6oVhujjn8tEZF288wr1zRv2tb6LeeBN/fMx02NH8439EXGTsguVJ5+h8JK8l07RDjg2VhlJveHVZc6+anaGTj7cMQGM01kTaizPMdIkXAVm9jixeoShfQ2Z3SEXJ2D9BhSdEt2ccW3xKSGYJhBSCTApGXQMC4zoObYcPgbqAjBVhErS5nyUTSmOlI1ORzM+xbLmaF+cqCzgfCTYQDwe8m2hLKE2OSSXRJdYIqsqwi/EZJmNIibNhZL/bUYfEyeIu9fGKkAbKzGAKEMYSXMI6Sd+OnA9bfAoYB0IdcXW1ZbF7k+BHmiwju3uf7HiDPj5CLhdM1r9wEI1xICUFBmx79sIF3SZfE/sdvXmvP8yN5uFqSS4Eb+/3sD9joySLzV3GLEdow3GmqaqKeL0A2g2OmBLLYj6vbvyEvG+x9uJWUndvvWIKnkPbs87L+T19qucMIdwu1m5NA50j7PekEK6ZAbO0IaVEkRUstGbYtXQhIMsPJthMIWIECKMQan4OiMhMM0+w8x/sNZ+mh08xYmNi+T7jXiUEK624k2lqJfESLrznYj/ipXgp34xZI/7nSxNPMWKHHd63jMMZ1l7gfUv8kGfSvy/14wH7R6yK64blw4bJDxuugdtDfQrTS6EDMVzTV15g0vB0XFec/Oxk+CEmCtbH+dBhHrRvSmg5m+x8RDM2Tp4UR8qyRmUFwY0slJpR7I+hUY9xgnEPw0yjfn953+H9HilLjNkghKCdPKMP6JjIpSQXAykKUraB6Fkliww9226mix3lmiLXuJi46i3h+m/7/vYHHJdHrIs14zggUyIrS0bXM8WeoCNfeviXsMHxx+98jTQmYhuIvWNqDiSvUHlOjIlpOKAJFKvj66VDgmo5I9VjIDYD7WApRSIxkJQijj0+WWxVovYjQ8w4Pllyslgw2D1tCvjQMfVQV2vWyxVdyNhtG5ofvsnV4Yp8abj/yVdQOLrBkimJUZKiWKPk/P4u84wxDYxekuWGqsqxw8jQjBAzZFkiy4LQNPjRkpU5ZbWkVEuk05QpIpUmy2tMlVOu1lRFyZtqj8Xz83f+MlW1QNQaYRZY51DKkhtFLhpE3GJSyzL3bCrFUVaS54KyNBSlBiXx+x3eekIx0yzb3Y4wdVR3HrAPga3JmIJnaK/ITMUq99w7PsGJirejx0qNkQqhDU4Lou3oHz0iuZyiPiKbBnIUKQTaybPrHQLQQlJn8xIGQEewQ8AJ2F1tObieVRBkk6OsKnIU4+TYDz3/1U/+F2TlKf/o/Hfwy4IoDM2uJYqIoUQtNvgUKRaJbGUY/Uiz39E4yyhgbCxhdCyPZ9Oxce/nXPfxEd7vESiUyjm+92nqxYLd5ZbBT1x2l1y5LTZEmt7T9AkVE0fLgIie1LUs6hqxXPN773wFJRR/5bUvMyHBzYwBgDgFciWx102BlDkqWqbY8jMP/gr3j1/jNy+/Sjvs8VdXhN05HhBmQ05gYToW2uJCIlbLeUh009zshHk4u/GZ6IaBvZvYUjKESBFhTSQTgd5aYkoIIRHC4EZLnq8I6YCdRqRSSKVZ1QVj1zFMFrSiv7ricP6YhY9U08il6xl7S5ym66xSCUoSbEQa8wF6XFmW7IYd0zRxUp9wXB3jw3xuhxiwQ4/U+tYBvHMdSqjbZvymUkqMXUuKkeCeRcBnN/EaQnyh50aKCWK6Pa9flkn0MvTwmyqk/EhZk4vuA6abSiqUUB9Lhz3HXo1M9pxp3L8UVfwGvVYKBrcnWch/8DbydI1CkP3+v2JMlnGy81DdXUCKUJ1Asb51FI5dd4tep5Sw20sut48Y9pe3v0vWNbafmC4u0EZSLBazC/hhT7fbEgToUrFY3yN+5askwPzN/4D0t/4mdCPDr/4jQrxCZzVarIhh1oenlG7p4SJ4GHtiVWGkpJssq7rG+0DnHOu6IAJD/971kh8dMRz2xL4jiwOxP0CxwP3wDPPmO8S/9EXaT30S8cWfJntyhXrr+3O2MKBURVKe1lt81PjRoaTBeQ9hQkuPNzmZ8ITYQ5w4lRVFJjnYfkYs25aw3zO99RbhcMGiXLBCkIcWJzOuJo/56h9g6hXt/+5/z9nrnyT84R9gfvB9RDOSO8uiGNF6YOwtmarJszV3qjWbXJFSmJdeNmCnjmq4pBwvkXFHGxwpZoTqmGRqvI9IqdCiQpV3oHiNXGhKWrruCU3/hOT2DO2e4D2FlDgEVuXE4YoUHEpr6kLgfYYOOUOREMniYsKrxCIzM518CkghZ88BGUlK0F0eCONAmyekMZwUG8bJY0dPnitOlES5wNVhpGsmht3Au1dbxubAxmiONhuq5RGL1R2EgKnZXqdyjBTrGvLIRXdJ++YZuk+oOw85/qmfw7/+BawSlOMVBz8hyxqCneOtNPhp9kh4/z2fUsTZAdcJhF4Sxi1u9/bM8JhamJr5vhn36MMZpbc0riF05/OiqrtADVfksWMznpPLQHZ8nwOzxPDYaDIpkWUBCXa7Fh8imzIj4hEIMpnhfXfNwhLXkaawLEqqMue8bZDKsBTzPXBzHr0fvY7jiN9uCcM4D9nX99WcHDMPhEU01MnSZYrhfYuEkBLBX9PD1cxYJCWiC9dItMJe66qfPrOeZog2PmKEoHhBvy2FYKEVd3PDJjf0veMyBbbOY19GGqPEbWrES1UMMOzm6+BPUXYciMmhVIFggRCGEHqcu8TaS7zvXghw/btePx6wfwSrVooxJsJzLviPGq5b27KdtreUmvdrFZ9X4XrbJT8kn09pies9xIQsPpyqMvmAEFBmitE9tcG+brY/qrmbxh6lBZmpULqYH2hpbvjaj4FihzAivEUlSXDtbY40gPdzxrVSNcasgJn61U2e7JpGmSlH5iZiKIlOkcoTlC5Zpw4/7WgmT3U9dGbXGp3LbuK8veKyv+Izx5/GWoubJrI8Z7nZkNU1Qins2PP59SdBwR8evoGuZ1p3DIlp16KnDDcFpsNI6hqqokSX1UxpkglnPZQV5uiEYdoTW8tCrEhK4cMWv7uglxoIFEWGNBU6JBblEUeVIcQ9XZxwKWMcYFFUsI9sp4xORpw9484qx1RrbIj4qae6/hvnOKeMEDoWTASZ2IV5qVNUGaaYqZB2kIydg3oBSuF2h5klEQWhXLK+d4fNckNe1eTVCm00hPka+73zPyLH8MWjn8IsC5TRdF2PkjVKBYZhR2ESJ6sVIg7002O83UKYSNKho0QpRXmUEYY9UtY0XaRtW9LhQJ5r0uaECxtIxjDIyJPmAJwQQsOyXvLKyTHj1HHIKjpToV1kHFp8bpB1gfHgGo9uFflgudx3dJOnMLOZlFKCTTk3LCkmwhBQIrI/f8zV+WOKLFHqBfXpKaw9MTVM73yXzno+88oX+c8/93fp7cg/ePc3EFmBMhlpnPCHHoxkGCXTuGc8vMN+9320GAmUXC1OsAhU3yCjp1xm2H7L2LXEOM3Z5tIghMKYBUf3TjCZ4e0nb3O13bF/csWbl2dctCN5iGyqBcI39FdbhNHU9+4Sypzvb3/ApxavooRBGEPGPMjc6J/LcnYTdzEhpcG7Aa8TC7Pib3/6P2JMnl/ffQ1ZljRXF5huZCUNV2OPn95AhEuG7gm98IiswLYHjDGzG6wu2LuJd4eB83ZP0oqjvOZOpildIESHlhHnHf01ii0w2HFitTpGEGnaC3SWMfYTq9WCwo2cPbnEb3c0k4NFwcmDVzlZbAi+5TCMhHYeZHUmERqiC0gM0XviU2fTGEZcciyyBTFEcpOzUAsSiYvuHGcnsmLWXrvosNE+V3s99R0xBNzkmboPDtHaGHRSjH58Lqp0e9Y+1cx9FJPow+jhyccPLEhzKQiJFzZ/McXZLfw5xm25yj8Wgm3HjrF7E8kOOz5hGrcfSXef0amIlAN9kuTfeRfpJ9Rf/Vn0T3yG7HtvkV28QXN4QhgbyBdQn4J+byHwNHqdUiLsduy7K0Km2HdbwjWaHoVkmBzCDRSLBW6c6Pd7fNeRFxXF8WKOWgqa8JU/QN65g7/3CumLX0K8+hD3279FenzGYvn6zCCZ3DOZxKMLqLHBJYGql/TOIoBVbiiNZvBzo5/lim70t+alERBljmjO5uWrMAilsf/k1xBlgfgPfhn/6B3Ez3wZnVe4f/n7pPYc0pweMEbB5dQifCJXEWlHTF6SH79CP3WY8QBpmI2ympbUj1TTxGr3BLY7trsD26YlJhB3N+R3HrJ8/SeQOlEoyfHhDPXDNwif/Qn68gj+1t+mrgvMr/4q05O38NM5Sku0OiKmmtIYFkqyLK8R9hggdLj9GWH7LsVwyaI/IytKpvqEIUZk0CQp8NfmcypqUIlR5FTrhyyzNdpGtrsD0/6MoX9Ms30LMTV477icQCrDJov4sQOpiFFDVpCrnBA6mnFAF5o8aaLzhKuRMDgymeGCRQVHd7HnEC0pKpa+goMl7CzYgPIRpsAmzrnlZ0PPDy8uSb3l3nrFerO5lZRIqSmKY8IEKhsItmHnRgYalsKzlCt6D0mULMslq/uv0i2OkW0D528zIeahKjhs9Ag5Zyg8e/NG4nBB2F8ipx45OYwQuO2bhO4MbAu2n5cxwRGbLctiRdIZjetnLwBl8CqjjxD7S3bjyNXkUEJwYvTtUlYoRRMFQzuwrgyZlrMxojTEOFxHSeaEMODcPBxrqTlalrgY2PaBWiuyaNm7gPP+GfQ6tB1hf0BIg9Q1obfEw2F2TFcK59zsGJ40i1JQG/EB87LZbyKSyVkmNKfGAG4+F3MpWWpJH+ItSBavPTyUFowh4lNi8RFmZTAvUFdKcKIUC6XwKXHlApfWf+hCU+iPiWBPDbhhZu58zIox4KYJlSlMXiGSxJg1WXYHrTcIoQmhw9oLrL26Nub992fY/vGA/SNYpRRIPqjF/qjhGsBGe6tru0GxP6qij/Nh8SFohdSC0DuQ4jaq4EU1ukhhFKVRpDT/N7wvrusFlXzEuoG8KJDSIK9jF6IbqZV8aRQ7pUh0LY2baIMHPxLCbEDj3I4QerReofW1+2WIHAZHoRWZFFgbKMNACgZRlLPJkQdRn5KVKyp/wdDsmHyk1hILrAqDEoI/ePQn+Jj49NEnZ2OdlMjyApNlSKmQJqNcrVkWK14r7/LNd7/JGAOy0FB4kgpk6yVBC8b9gLYTWSxIXiACSCVm4w4bSDrgihqEop4Syi+J3uP6M/ZuQgdPdfeYWM+Z1/6qRTvN0nRkxmNFztmlo3tiOS0yQq15nCQiwKpSYBv6oFBxItfvXW9SVqQwEsct0lS4XKGNIdlIDAP1ckVeaYKPjK3DqZLkA7QNXe9ISrBcZECaDfPETCmLQ8tbzbu8vX+Hv/zw5yhXC6y3GGMYhoEsW6BUzjA8QuucqjpB6w1TyMioZ1Q+nJOmligsYWzJtGd955S26TkcHKrvUKsVXdIc2om7FhZy4Moa3uj97fL3eHXMIgeZBmK1oMvX7C+vGC7OKO6eYE5O8BSMLmN32eEO5ywzib/+AUdVdmsaOPaO2PfId9/h/PwSuTDUd07Il8dUy5KuucSqnlJNmFSRjOGT+T3++qu/yJP+nP/3N/4B1WpBlpeITNPvLrl69BZ2t8XIjphpju9/hvXmLlfbLUNZkS9r/PYdoj9HJIcfKrQ5IUZLCD1KlQgxR0qZTUa7b/HbiaHVjPuecHnO8PhNdNMRdleM0pIdHZHlhj86+zoozc/e/yLbwwElErUxTP2IbSd88CgRScHR24lgR4axA6VY5DU/sfo0n1i/yu+8/fs8mi4ZlkvqvMJcvsX5kzdJYaI0AhF6du0TbB6I00gMnsZ5thaGKBmnhoVw3F8uWZiMFCLjMDAKi9eOmCbaa3qwdwpExJQGQ8Y07olCMO0asmbHsYiQZTxOgmlds6gKpJAUm1NWdUHvDhwudqSQ0JlCZpoYIHqBkBJ3Y2wWPbthR5VVHC2Pbg3PJJKlWs6O7KFFXN9Pvevn36OfdaB304ifJkxeMMZplpe8b8GojKGQOd6756PY/jo79Smqt9DiQ5lEL6KHp5iIvZu1iU9Vdm1uZ1/w827017eU8OG9wS9T2e0A/sKKAWyPbx/RPfk6wl5SqhwTA9N4wLnLW8ro+yulxDRNCNHjUiKpFdm3vokQiewLX8D8/M+h3ET1e7+DTZberCBfzo69T7+Ep9DreDiway9Jy5rjk1cRUrA/nAPQXu0J2pCVhv7sCW4ayYqCsqwwi5qERcoC/9U/Ig0D8Wd+jn6cGIee9Ld/YTaZ/NXfJS+XaKOw/YBzHmMM1seZQWEtLFYkKbDWscgMMSZWRUGmFDs7UZeaSSTcEPDW4vuG1bogJomz80KIr3ydsL0k/uIvglRoUSDyJXzus6Qfvo39wffBdqQEj5rI6A4sRGK13rCQQPDs9IpUrincFn/+NmLXMG13JO/Q+QJdG07vnrC+dxerDVfLmjFXqGyBLDYQJe7wNup3f4e8KCl/+ZdZ5YLj1+7S/uQXGM+eUL79QzY2obrExZQopeDYQCYkSiSknxD9FbF7G2cblDBkm1co1g8pRCJKT0dCB4NP87DjJwfJEKTG+YEsL7HkhMkSBk9R3GN1/BoqU+wu36S7+AETE+XmLiUW2++Z7CybCsuCZahICc76S4qqQHtJ7EeSDbjHHfLK4/c9YbelmUamqFjpJUIonE3kqwxWBllnyGWGWmYsVCDEiSHLWC+WFEX5getbK4VSS1JQtOGCi8MZWTNxUq/xdUFea1abI2zvWeqCdHJKLzJk2zAcLol+IvrZLyIrc3DX/gzBzahmd0YYL4mpQFQn+OwYfffzyOI+ThtCdQTLe7C4A9UJKUmye5+mXj6klwabVaR8xZUvGJoOkuXMRqaLS1bTgHzqPmsnz6RzljKSpdlzwkWHIuJ9g1IVIYCboGsv6Zor7OAx3qAEbPcjbTczjuzkeWfXEnwiBcF4cYXdHQgyI1AQtUZmFX7fE7tupokPM+tL1DVCSVZ4cinYuXAr2bQxzvIn9RQjSKs5BvF6qK2VolKS5lquEK77a6kkTQhkUswRdx9RKSVEBF0aTIQ7mWFz/czYusCF9c/thYWaUfWXGrJjmIdrgD8FpdsOAyk5TG4wWUkMgXQdS6lU/tSwvUYIeUvxf2/Y/rNPB/qLrB8P2D+CJYSgUpIhxFvDhJcZrlNKt43KFCZyleOiu9X9vahm+sqHUwFlnB9M8SM2b+76NedaopUkU/IDNPEPM9kJk8OmiSKftYhSKYQyBD+SSUkmxUuZwMU40g1bvNA4oVBR4H2HtXMzpvXmNi83XrtVKilYlZqum6BrKAGxOkJWBpFLkp2p77J+SFkvMH5Hszuf8xAFdClyXGe8dXgD6wMPqlcI3qOlnJ2YhSDL5mglISXlcsWXX/kiPgb+4I0/ZOxahv6ASIp8s6IPnpAFyoVALZZzVqWNqGnWg7rG4saWwQrKqsAslxAE4mLEjpF+OrCoI7GoEJnGyETYdcTtRJwcJkZy72aKqYDqqCLLFfvzS8xig1wc48eOaRypVQBvSSHg2+1spOUm+n7HolyiqhIv5q/xdkLKAp0pqmWGzhTTmHCywO5b+kNLlUWMCPP14CJSzvol3xz4nXe/BkLwi5/76xRFcR394lHXmiUhMrwfblGdJBPORzJxhM6PUXqJCpJAQ3/1PbxwJJNYrQvS5BkOA7FccDkl0qXF7FqqfuRuKLlsBv7kSrHvWoiCPKtx9sBxnVEWFduo6YRGdB1+HGgmGOsVQq9YxJFuf0VIiaPKoKSYG/yrA/bsEnd1xpQg3jui3FSYrEaIiJaSFDTV6oSjhw9IU8vlxTmZTPzNz/0dPr36LF9596v8i+/+c8Zmj0gti0xT1jll9YBgFtjQI6JkUdcgoB322DwRy4RyjlqvCT0kX+DclpQCSs2IqQ2WbmhYFRXVeoEsC47vPmSxvINvdxy2j0hBMYwH1GEPU88fPvoaRmf8zGs/ywSktkPaxLjtuXznnMO+YWwOxLZjdziwP3+Ltu0QVmLbPc3VJb949JcZ2ob/5vf/e/a7Lc1wzvn2Dfrznv5JxDY9iyzQ9nuuwoGLcMXj7WPGGDAx8GpZo12HwmKyeVHWNS3baU8sZnTDqERnLc55olfoTJNwaAroG67eeYPY9WRaUD58wOknXuNisIz9AQi0rqXxDeXmGLUytFdX9NsGKeesUmQijLMxlbcTKSUO9kD0kXWxpqpmR1xrLTFGgvMsRYUpCrbTlslPTGGi0s9qr4P3TP3sPo2USKUI1uHfRxOXSqOUxqQPRjOmlEg+3RpN3dZNBv0LFp1jTM+lhycb5ob1xnjnqcqlYHgBquKCu9VfhxCv893n55SRZkZqn0axY5ybvmEH7TmpfYxr32TqL0gyozj+JGrxKlrOKQUgcW6L980Hnivz2dGgtWCSS4z1qO9+D/n6K/hCIO6tkZsa/a230CZjO33wWfk0eh0OB/bNJX6Rc7S8Q65zlstTxm7P5eUZ7XaPzgQYgwqRarmadfbOkVSEFFCyxP/u7xGlwf7k5/n+xTtcbN8mPTjG/PxfgzffwX/tj8iqgnHoCC6itWZyntDuZx+JssTGSLKW4hp9K8qSVW4YxokEyFwzjI7u8hwVOsr1Mfr0Faa2w7/zJv73/jXh9AS++DMoHyk3x6SsJH7hp4kRpn/5+7huxxtnlzRT5N4iY7nS5NUSoxL7bsChqIWmaQfyaaLMJaIuMKdHmM0dZFmSVKR0lhMSVW1oY+LCSprWUlQr8sdvYr/xLcKnP0X/YEkqBg6xhb/xS+SrI6o//CZTUlwcetTVlgdaEl0A1yGnx4h+h/KRmDxTuUCbFZAgW7DSEjOeYYk4pQnTzK5z42waF0TB1O9x3QGfJPr4Iev1EuMOxKBQ5hSdn1ArjRu3dH6PjC2MW5oh4ZSg3OSUQmJ8zeBaGB1YSbIOtcmRuUYGkN2Aq0fCSYEpakxdMPlIMoJ6YxhDwEePnSYOV5cMfUee5SwWBW14L7Lp6RIhInPYDQ3IgmqYWXtxvcLZger6TFdGoryhrhaE9YokMlzT0/UHXDOnp+R1AW4g7S9mmUSwRFPgzQpR3CWrChKSZHJMvgEb8X5/GxMah4YUI3p5RGlKVFRs+x3NfuIwjKj0mLTIWR9pTK6xuy395Q5vA4Od2YPLZUmVa+I4XveuIzINpJBhB01/OBCHCpFKpvGMaWxQSVFoSQqJs4PD9yPF5Gm6iXaKTGeX2F2PkyVuUlgXsAlSXSBMgbs4wGhhingRkUUGyoAf2WiFFoKt8/iYcClhEs/ooWWuSCE9E3+4ugZq9i4wuYDSgj5EQuI97XXwczrBi9Do6/QHUxuCi1jnkHhq6cmZ6F3LW80TfvD42/RPR5TdMEVfhiZuWxByZhp8zAE7hoCfptmTRCh0Vl3/Wc/+nHnYLjBmQ5adovXqOhqxwdpznNsSwvDv5LD94wH7R7RuQuv7EF9quIb3kAItNaMfyVWOQDCGF9PEb/Qh78+/fuZrYkK4hCrVM0Zez6vJR4SAwTU8aZ9QZgoX4i2qNzd7zzfZSTExTD0YQaHe29YqUxCuD5CFkviUGD/i8BjsntEO5NmCpIvZJdZeEEKHMRuUunHsTuyG+X3bVBnJR/qrHpNGiqM1sswIbUe0I4g561pKjSiOqJc1wk802ycsro1+XEo86d7ibn2KHSWjDSitUdcaoPfrfX7m4efIiwXfOHyP4BzN43eZhXqSw2Egk5Ys15j1GrXIkIsMsygQRmD7AXsYcI1gETRRFMiyxjU9zc5hyKg3NcNNtncYkaXBWcvwdk/oNCa1PLhfUz1Ys5sm+t5S9z22rOmjotdrREqYwxP8ox/izi+wh8e47ZtMF5cEnbGoDDrLsTLhmYiDQIjrYVgK8lJjSoVZlmx7sPsDcn+O3T1BqDS7VodE6hxNc+BrzZ/wiTuf5JX1w9vYrrZtqesa7z3Wtii1QIhADJ6kE0SILpFURKWcMj9ByHpe2AhBCDuWtYXpErLIKCoePW5YxMSi7smrilNt+GSu8Sx48zDweLdDx5rDvuPq7IIseNZ5zrRec5UMjx5dMV5tWa9yTu9s2LZguy2bDJQUxK7DPj5juGyIyeOyAv3wPiabEfvoQRtPdImyvE+9fI1q9RAtR64evY3SCkHil49/mSNT8mt/8g95Mv2Q5XrFcvMaxb37lHfuglwigqe7fIf+sGWdBUZ7QdNOmM2nyI/vkSuHbDvGfSBcy0aEkIQY2I87psuOzeqI1z77Cq8tJLaZUE5xsjpGvnqPw+kGXxgME7v9Y966+C4/aR7gmgEZBNUUGfcN/dDjTSRfLlFZzWq1QhQlXezI6rtkxYogI8Jk3K3u89mTz/G9/XfYxscUdU595zXuf+bL5KtXsVcO2OBlxg8PB7yymP4NluER0l5RqYJgB5zySJnTDR0X+3N0pTmpTlhkCwojCSmwO8zDZ6YV9uoMt22pkqSZesxmhalr1GqFrku0MVxePWGcBsy+J3UDLjny0w1Ukt3jJ4RuRGcSlSm8DQg0KUb2/RbnHZWsbqmJs1mUxDlHu99jTMad5T0A3u3eJaVEqd8771KMTF2LVIq8qnHOQgzEFHDDs2e5EAKlNVnShBSeHVR9Aj44YH8Yk8jHhE/pA/TwFBNxCkw+4EIiTeEZBDyXM7voebImG+0tPTzYiPWe4CLBzUiHEQo7zRpO2nNon8zDdXBECVYlYnVEyh6gqg1ZfQeVr1D1imRbVMxQanFNHb28bfhTSgzDDqU8Qq/wGIpvf5vkLPJzrxHGS1wG4hf+GmJKLL79bSbX0tlnlxg36HW0lq7ZYivNanFCpjJCSpSLDXGwvP29b5GI1Ecr6gcPyMqSNI4k52bnaD1fp+ntd3FvvUP8wk9zZbcI29IeWtK4oPhP/zeIMsf+43+KEXMkVfQeIQR916JCxKzWdN7TNS1pHPDXrIYsy6iLEukdUwhoLei6S/xhR744QlTHZOs1wTri//Q/EX1g/Fu/hJYKlRT5ekl194jw4DXGBw8Zv/Zt3v3Wn9D3Bx4eHXFvfYzIPCImfGZoh4lsv8Nuz6EoWb76BYzOEP2OOD5BtGfIoSG07xK3j9EGajlyrAp8H9l6z942+H/1h7gwcvlzn58Nwigp04L7n34d85/8J/S7hvGf/yZyteJEK8z+Cfbxn6C7t0nNOzB1KJHj8VgRMGOLffc7pPNvk/me3F4ido9J4Qq7fYzfv4s/fxu3fZvmySPS4RHGXlGJEZkmCi3Jxh0X3/lXHC4eo0zJor6LmzKePL7i0F7Rd1e8++h77MJA9JYURy7Ot4itpT8/0GDpQ0/jWzo10u4u6Zqe87HDIGh3AxdnW7q+w4WRFC3D0HN5ecX2/Ixxmog6w8bESkTGaWQ7PMvSmNl+E52ZUdi127BZvYLNJVfNEzLpMddDjynUnAoRBGa5IFU5IRq61jNdvomxO+RwgfANyaXZNX9xl6gVISiUztHXRqfBxdlbxeWQBM7tiNGT2h0iy2eTVSmRzjC1ngvbIMQFKTiMfIUjkXC1JNsskLZhf77l7KLDAIvCIK7vm27a44aGMGQEWxHDgIuR7RDJilOKusCUE1UdqVaGo3slVAUii9S552RhUHHEFJLFq3eoVxXlOqO+W6G0JCaBOV2DUIRHO6QEL28kNRn4OTXiyCiEgHPnsD5ieHbAvqGJx/ct5zZaIVLiavIgZ1+lQgqMvKbmjztwI2lq5sVKsAx+oHc9jW3Ytzt2bs8ubbmaLjk/XLCbdhzsgRBHFipyEkdSGHm8e8TWeUJK82JUio92Er9ZZGYVSP2xB+xp6BFSIo2Y2aZSIaT8wID9dAkhUarEmKNrZHuO1fT+gLUXOLf7d4pC/uMB+0e0pBCUSnLwlu24/cjhGuYBWwpJbWpCCnPuqMo+VIcd/bX++kMcCpMNIGaqytN52M+ryQVypfjvvv7/4f/82/9XfrD97uxYfb19FXPY5HPRk+QjNgzorJgzQ2/eC51DjAQ/kUmJEeIZp8gPvA9+ZD9ckquCdXWXKCWD3SHCjH4K8Z4W8DB4fIhzTmcCux2Z+ob6uEIuVsS+Zzg/pzt7TFIznTn5OKPfRrE4uoPzntScoaLl7faS7bjjJ48/SWEk3egY03v5hTeGGzOi5Sl1zudOf4If7N8kZnNTiNTsLs9p2546jyidI/N5ISCkwJQZslb4bKAjErWkNBl+DAyXHZPNGF3EuIy4y2gPA8P5W3RXe0anmEjIUVI0Cq2AfOB0XaMqSZwmCi+xY+Ds8or92RYTNClKxHSJyB3y+IhAZOr3ZLIgY8RojSPhlAOvnnnYpJQQaY678FmJ8JHLr/wRl9/8Ae7sB4S2xV+1xMbxlfabeJX466/9/O33CyGIcUZxUnL0fUeW3SUNgcP5WzTdGSpC3/XYMJHGQCDR7y7xXmHqV6mqu2Qk/OGcqRjoY8fhsqNOgaR66vUdlPFsZMkn6gU6y+jNiKtLVF1zdfUuKUKd1aRh5Mk+8CRmkCLp0Rl9SkyxJvcOtXtMOD/DNS02GlgUYDR2tUJWgmXyBHJiHNEyIERFvbqDlDlS1qQI+252VM+mA0UI/B9+8u+S5TX//dv/nEYZhChQRiEMeGU4vf8ZlE5Ye0Gd5eiUs9017N7dMnhJXJYI3zC8/QaunzXiMQYO9sCw3ZOHguXdI4rVkkxG5PkZk1aUp/c41iuEqRi0wFeBr45vQ1HwpXs/y2E/oPY9mfOM+z1+d4FRniAczb5jOnQ03ZbOOurqlKJYkJeKo5MTdCn5pdd/jkWV8ztX36Rcrsnqu7x27z7lYknXey6e7Hm4/iSL7HWq+h6VLki2Z5oesd3+EbhLXBrpppYn23cxWnNv84BMZRhpZpQzwW7bIvsGDj22bxDLJYv7r88NIwNCK1KW0YXIZq3oXU+4nFjIinXI0ChGHHJTkCRsH50hgkMWmhgSyQscgXY4kIsco8ytsY6PkOcFSkqawx6URknFyqyYwoQN9hkzyrHv5iileoEQYo7z6nroe4ar7QfOO2UMMgmUmF/37X0X4rWk54Nn+4uYRC+kh7tIDAkvJUFco+NPZfrmUiDgA4vPG/r3jcHZOHqeHBoudxdM+yvoLsiGHa6/ILlpRo7KDWlxF18UOBWRWY1SR3g3YPIMrWuEMKh6A0rjDxdoWWLMMSBw7grvW6apw7kDRbFhZM5WV9/4BgKP+tQJ5AvE4h7iS59GGEn2lW+gGdg+Ff91g16DYDjs6AtYLI6pTEVMiceHA2+eneH7iIiC7M6ScrFEaYOsamLfz87IyZIUKFUy/Oa/JDiL/elP0NiGcpHjs4pxK0AtEP/RLxEPO8Z/9huYIiNNATs5ht0OIRWNt1y2HcJZVkVOvVxisvn5ILWmFuCtYzqc4+weXZ8SzAaEwOQF8YffI/3wTbrPfBLuPyAXEik1ZlFQLitUXXDx5Z+lbUbUv/xXbJaaIwNaVyQVmIKl70eywSIOW6basDi+T5KGacyYTE2s15AtkGaJb/dE25NEi2ufMJ4/xrTfR+2/Qfsnf8T03TcQn34Vc/eYKpQs1ZKq1IQwMv7s5/Gv3MP8y9+i/OPfYeHfRYVz0sVb0F0RZYZYPUAdf5qpvEOsa1JSTKmmTyUuTCzXR5j8CBT01QLrc7rOMURDKk5Ynz5AL2tEscCqApMviOUJYRqp3JYq9ZQqcOfoBJFVqLRAyyN8OEA+UasBIz3DtmPpS+rNinGV8H7EHfa4ZstoD8RcU8mSo3xBshKkYX20oKpq1osanRIhRNZHx9y5/4B8uaQ+NCz+/v+F5T//DbaXWw5PpRV0fcPOH8iiY+0AtaR+8BperpiaK+pyxCVFSgmlJMpI0gRmUVPXC6wf6KbAcHWOaR/N58L6LuRrkpjv1xAnUsxQCsZ9gxDXi7GyREiBcvkcc2W3xG6PqDYEH/FjIkyRqq44yCu65hJhDZvJYHYee/WYdnKgFLa/pJgOZDbQHya8zBi6gd27byF9gcnW5AtF0AP7NswpII1H6wopC1IcEXHA6EheFlx2lml3yXro0UrRrFZEL2YddJUhlURnc/RsJCFXS0Ag+57gPCEE0MVsdOgt8tqIzYbEznoM3Bof3pylaDkvHZ86T6UQLMUcY3gW54zsxQ16PTU4N3AxXHLevMVVf85u2tHYht73WGdJPmGKnNrUrOsVtVhylB9xp7zDaXnKsVlyogvur+6Sx5Zhariwns5fMwM/CsG27fwZi5zDviX6l/fCCN4RrMWUJeCR1/IfpQ3Bv5yWex62q+th+xQla5ILpPTRxpr/S6kfD9g/wpX//9n7z6BL0/O+E/vd4cnPiW/qMD3TE5AGOZAIJEGAFMnlUrS1EhVWq1DWKlRt2S7Vlmu/bJVd5U+u/bCyy2tpLdkSRS1FUKTEJUhRpASSAAEKBEDkMBhgQs/0dL/9phOffCd/OO/0zCAwrGQbZPGq6up++z19+pzzPuG+7uv///2FZ9Vv6DzM0tnv2VzDTooXyYhY7jIBe9eT6QwX3P3p9jeWc5f5fC/zVXvvdxcZ2E0WB4eI1U4SGbjvn/vGss5jfUBKx3PL57HO8lOf/xnuVbdfATv7dpAd3w8MGNJviKpRcQpC4M3Oy1jq3RT724EeVt0ZInhmyZygJPgaqyIyNUNKifeX9OFLYvg4i4gAVw/0dYVJHePpHG8Mdr3ByZ0cptsuCewmOVKmgEBrRzI9ojaQtUuevPcVrPfcKK8zTmNGiaIPkturC5aXQJ4oii7Jtjsi5luvvBUXPJ++/WlilTA+vEJTG/zQQ3Wxi4oB7ODoKsPQOLq6o6sbLs47fG9QOqW1hrpusNrhM00yuopfD5hTS7xqCDQIbYgLSbF3iAoO2cfYzZZN16KGLdfo0HlB/dwpFxcb1s4xOtxH33wjarpHGE4JbY2QGfHeVUTf4TZLVBgIyiGVxKsI1/b3J1zeBszgWCxbYqXIMkOcQmtjtssWe3GMOT7DrZZ86vSz5CLiTUevvzw+d8dNURSXWbA9w+BxA5g+phsC3XKF77fU7R1Wm7sMTcu23rA+O8boHCEVw+Dp1xYZYtYy5flVhXAbdHTKtjF4G6OVIktSJnHKyCS4tsfTEnTCQgzEswydpTTBUCTwyLUZYW/K8b0NJ8/eJfMWe7LGbNc4WzNEBYNgR4wVCp8o/LAhGQLbtsXYiqFxBKHp+p6qqmibGtdDkSukX5EPhnQ0YTp6FT/x5r9IZVr+6ec+QHCgI4WVA9Za8mhGNr/B9OhRDq69litHjyDLCCcDfe/xcUaYJvTVXZoXtlQnK07Pb7E+OcZtDElRkqQRvmkY1i1FrmA8YYhiRG+J9ZhpukdtKj7+/MfIo4xHp48zFAXl9QP8eEJU5IwmGe26YlgsyIsULWLi0JOOpkxmh+T5GK0csKKhZ6JK3vfQ+7i9eYFP3n0CJQuyYCkJHMxmjC/OKdYXzLMRa79PMj5Cu4QouoIbFFq0bIcTbp1+Hmkq5kWGkLvNK4FADQ6xXNFt1ztp+HQfygJVZNgQk3qP9Q2kCZV1DLZj8GsORxNU5enZbfBMfEKmMzZsicYJrVA0JxdEKoCErulpQ4dyoLy6n68aQmBV9zTWk2iN1Jpu2P3MBj8wTaZkOmPZL3d08a7FDQNpUSIvF2PDZkMSp+hxSbe6wCwW96OhAJTWEAKJiO4zOOAynuvbKJO+XVzXt5KHh7C7BwwhsPKelfd4Ke5vNnL5GcVS0H2Dwunl+dfOeNZNB/0L9M0F1WqJ84oo3yfke5h8CtkUryKMXV9yAkqiaIbpOkLoSbIJQiiEkCAUqpzs6OrdatckRnOUKrB2zWbzFFGUoqIxnQ/kZsB/7euoqzP8aIzMD4iiGaKcwesfhJMLxscn9P2G5kU4WF2DNQxdQx07snJKeWlHaJot23vP0m4WdJNDZrPrON/c557IPNtJIdfry+l1hFmsGT77SXjwiM1egY5irs8OiOczNqHH1B5e+zjhyj79Rz+K2uymnM89/XXWiw1WKdb9QO89hbd4oK4rbr/wPCd3n6fdLhiqDf3xLS7OT6mjnD5OWC021FVNu9kSfuM36CLF8o2vQXuBNx4nBEGJHUk9SNqb1+kfeRXxk19H3DshNxVSxAQHy+Vt5KZiun9EhUVojew9fV2jRLSzN7iw28BI9xi8pBqVnKvA2aCpdUFUjpiHhKMv3CKPU4bv+W6G9YJudUZonwd7wWJ1j8jWzH/se3eqm3/zISIixP5DiCuvJkwewYoxIZ4hkhGDKjFtRTANcT5DjI6oe4OyA1kywjpB061Y9QYREuTogHiyTz4+xOuIEJfYqEBEORsX0e3fJMQZSZqTCMck1IxES5SNkWrKEMakKqX0kmG1QsQbRgcp49EY01TUrkLWNcIODGNFluUkXtJVG0Szs4lFUQTBY7qGWIHOS7KyREpJFyD6rY8Q6ob0859l/M9+ivOvPUM7GNbtmm1bkQXFqDGkoxLGc/rBEUTCSEfIJMWYNfYy4SBOFdJK/NCRxx7VXtAEGNIDghxB8AhpdwMQ43GmxdY9oRG4bYPZNNBaXOd2Vrksg65H6ym+WWOGNUbmdJVBKUVaRFgM21WLObvLXJcko5wo3ScRsKoWLCtHFAQzt0CuXqB94R6Lrz3H4s4t3GLFJBmRSEvfLDk9WxGTMipSmtYR3O46pfUULQLdcMGsTGm2HZuTeyRFwexgHz8Etr3dRW4pQde2HC9OqdZLtncvsMOAuDpGBUG42DB0ww5wKCRcnsvq0raJD6x9+KbOSabqEu75yuufcIFJpNhcws20FDsg3FBT+QEhJCM0UxTzdH6/eZ6pCeN0zCgfk0c5ZV7sztXWEroOV1W487vYbUU0xKQ6Je1OyaRg6zwX3u3SfL6d4tR7MA1EOXXbUXWWtu3+wCTxoW2RSt23lgrxYoOtdz7sPySRXAiFDCnSFOy2av941J802N+hZb1lO6xJpSSOxkjx+/+ojN812EKI+5PrWF022/Zbw868C98Uz9U0G7bb893Cqt9dcEUsd5TxS4nQt6re7qYfx9UL1Lbm0b2HUFLxgS/9DLfXL9C/uBh7Ma7rZRejYD3ONNhIkahXwjyE3OXovihtTV6cYn+LJn3bb+ltxUwXSJ1iXUOkUkj3kUhkkFjX0A6WqrcUiSYO4BtDsI42NKiiINURfr3GEhBpTppPdjmmtiUYC5dTbOd7yiRC5nv0PuaF8yfo+4ZHZjeRBMospsw1m77lvG6pTIXWencD7SqkjHnjlcfRUvH5Fz6LihN8pAg6ZTTJUBKMDdTLNe22JxCQShDFBp1pjLCMi5g0H+1unPOEYs+RHI7Zf/U1ykeOkDFkgyQmx/YVKopJHzxC7ZeEtscuB85vPY995jZj6Xj48YdJ8oJNJ9koRS8FQkf4bEIQAtcZVJQyOnoMNRljuy1ifYL1A1FSYrB45wndLou13vQs1x0qBArZEsmW6WteTT4Z0XYxNorwKvDscMZFt+bt48fgYolbrWjXayRQliXedzg/YK2kXlcQAiJPmM0eYhY9wGy8D74njSx9c5s8Dxxcu8ZoNKIoCjJjmMzHiNGcuh9xOIo4upaT5HOsaDEmxW57sjLiYDwm6hWbi3MSB8lowpOLFcvBkyIYlZK9w5xx4VCpI16e01ycs2wclcqp+4HN2V3a7YLaObpEMfQrQtsTGxhcRW8sQuSoKN55rTCoekEZBQ5mVzDFiMY6yiRl8PDmB97M9z30Hp69uMWvPPOrpElMGxqkEtS9oEay9QLrA+PRhDwtMKkjTgt0XFI8cEh+ZZ9UZ/Sblu3qFLvqQMQoDNuLcxa3bmOzjNED+yR2YGsl3g7Y3jJPprS144XFszw8fYghUQQldlFxAuJJRrj2MPrwCk3dkfgeKwdoa5Se4LzF2hZjttR2QKuSiUp570PvIotS/t0zH0epQGhbiixl/tijjOd7NM8/z6heYrygj6+gZYxra/rW4eM5NhQQAvvZBBlferu6U9qTryM2G/Ce+GBGV5bIJNtd8yLoBkEpFArPRnpWQ4t1W5SUPJhMScuck6bDCghNw1F2SBTnrPtT9F7J1oLfrtEqsNquEDIiESmm7+9Pr7vBEZoLumpNcJbJdEoIgbqpqfqKMi6ZpTMEgvP6jLbaEqUZ+tIa0bcNZlthVEQ0meLzDNcNu2izagdtVDraTSe9QgpJa9vd9CK8Uh4evH9pk/NbxHV9W3m42T3XNniiSOCEYH0JT/Otvf+ciZSYEO5zQ+Al/7WWOz9w064pI0s6H1PpMVujidIxUkUMbsC5DmMWBDxRNEfrAu8dfbckSrP73ABf14Sqx7cNxgjM8gK3OCE0DaILDNsG13RI07PanEPfo77wJUK9goev46IM4XeNepRdRX/XW8DWRJ/5Mso3bIYe17b4qsJ6RxVZonLEOB5fvrGO07PbnF6ckIiGtBjhy5Kh82z6DT54hJSILMNultjQY0xH/bEPI5zDvukNrGxLoXKEyElUxIWpWW7XtK2nevtb6bY19l//Cn1fszhZUYwnTOZjeh1RRnr3azRGuW4HFJUa5TtKe06yfp5cBmQSEeSADDsSvf3Ix2C9ZP32N9HHMbEJNKsKqwJd1+1gTmnJLM/hR34AIzR86LfxmzVuecpmUeFdxXg6Jt4/ojEN4WKDtxatEnTiUZlmsTpl2Sw4W7zA1vW0ssH3jlFyhauHDzB2CdEGuH2CesObkI98N3p8hEkCL9Q1yyARKKZaIW88jHvb29D3zhievItLj1AH1xHzPYIGv64x6zV1PaD7CqEDvVMQRchihCPHXtxj2GxQwtEmjixO6M1O+pvGOeAxrseFQNM2rK1FZSMqJwlCQnlIHKeo4LA2oBgwQeBPzmETYaMJep4S+iWnt76MqNZ42xGGli4O6CxjNBqjRExVb4kwNCcXrE5OqdcrpJaMZ9MdcftyUGFPTpFf/gruwRvI97+XYrsh+cf/mFu/+kG21ZrSKHIvkJEkOTpASMFi3ZNJS5mXEB8ghKStF1SrBbZaELs1qusJWUZaTAlCYfauUxuBHTyhWhL6HexyWNW4BlSUELRHZBrk7r5uVj0iTncNXG8QbaBzgt7VRKmimKQEYbh3ekq27chVILpyhWRvih7tkYwOWESBMC8ZPfgwbnINLxRR4Un3QM8KxJDgFy3t+YLj556GZceBNxShx66WVHdXmMUpYduS9Bm2WtPf/SqyanYbPLFCdgOF8bSRoBO7SKnlegm2RgqJ7T0Wg3UDQyYY1itWTz9Hu9liXMB19UvNooADJRkEr4jhgh3vAAJ+eKU82tlA0IJCKaQQ1MbusuODxxAYxyWZTom9Q1kHxuCaBruq8G2NW62w5+f483PCds1wusRttoSmIgwtIh0jQiDzBd4b4mHFXqRBShbWsuntK67HL12Y693vcUnbtiAVVT/8gUji1hicMcRZTggDCIWUO8WpvNzs9e4PD0zznSV0f3zk4fAnDfZ3ZL3cc309nxOQvy8523hDINz3uiUquT+5TlTybX3Y3oVvkoe37Zq6WdJsNwTrkekur3Dn99tJa75V9dYTa8mzy1u0Q8WrZg/zl97450AEPvDlf84zF3d2D9QCEK+QsATj6X2PjFLib0EpVzrZeZ0upZSF2i3mXhGh4HqqYUWhUhISwqWkOI3GeKnwQqC8xFjDut6SaEkedr5qESukr2kCpNmIsN2AlLg4RoUInRQkcUIIjr5vcK1FiASCIwTDJI+x0YhnNydMdUEWPK7vUVGECQ17eUZExmm1pXc9UaQwpgV2u4+vnj/G0xfP0KndNMwLRaYt5WRGOtmjqTqGdguhww5rvK0Zhp66XqHbluqip18v8WrDYnGGcQq7WbOsNrSux6aCi/MtZycbzs9qTLVFBIuwNZ0Q+CQhshU62yMrx+xf2yf3HtV6vn622gF2JHg0IZmjR4dImRDlc+RkDN0Fw+oMmYx2MWRhoK8MzbKjbgwiU4yUwzdr0jInObhKWY6RzhGKHNtv+fjFk6i84N2v/V7U5cR6WK2R2wq/WkG7pl41u1gSdhmUXb+7UQgZk6gxDCO6XiK9oZiWBNlh7QLXrXBdgx5LalNjmi1XDqcU5QE6DqjMk833MJWhvahJ84SD8Qi3XrHpHFqOCL7DB0vbe7ZDzerslO70lIODMddf9RCzw0O8zGkXA56UlJZRnqMPDxiPU8ZlwmE5R6pAXiQk2ZTZ/j5lUZCHBtVv8SEQz64xmj1ASPZpRU9UrQmRoLOeP/2a/4Sb44f45L1P8aXTr1KbmkFqNvWWbPs01M9z1l3g8UzzKYPrcWrA9APODqSzK0STMX0wyEVFrErK2SE6JNhNS3BAFoGW5MphrWDjHKFq0Y3hieNnSXTKmx56DWeuoq+ayxt4z9ZLvFSEyZg6L1gvLhiqO0xkxGBg054TgkFFcxoSJlKQxjvv1/tu/gCrbsunnv8YYTDIokBqzfjRR4mKEn96QrK54KJzRPkeDIFFdUzdV+ylN5mmV7EigAJJiqgCICDLiKYl2TintY6+bZEyxjmL9ZJUCfI05267oBrWFEpTWEUSJPNrV+jbjrPVlna9pj4+ZqYntG1F196jT2OqwdG0Z/RtSxF2UkNvDVrvFhxNvaVqey7OL+hcICvKHegwGLq2IyJCScUkGmPqhq2vUcmlPNM5Vsf3sM4TT8YIqXBK4NIMmef4usYtlwRjUFGEd45MZ3S2w5mdrPk+8CYEms0a070EQvtGJdG3lYcPjoFA5wPjNGKaaarB0sqd7DJc2kFe/Hcvn2K/6L8OIbCqBmRoKLOYUZkgYk1dtfTt7jFNf4G1a6RMiKM95OW9rG9qvO9JsilCyF0meFXD4JDeEhzY3hHW5/jtmn5zj35TkXKI6mG7PEGtXsB9/MPQN/Dgg7h6wK9qXFUjpCZ+4HWIh68RnnySvNrSdmu2Z+e4fqDKQBY5k3iym+zbgc3FXe5eXOCY0TQK7beMJinCRyzanvWw3amUgqPuTqlW91if17hPfgGXZBxfnyJDziSZoZxkqnPIFVVb47TGXdtHvuktFCfn7N+7S6wzjq4eEWc5JorZizVJmpJKi7eWdLxHNprTWoUsZujxNY72joi0xNMx0h363vOIj3wIMcvp3/waDvb2KXVC4gLTo310kmGIyIuCo3HB5oF97KtfRfLVJ6meeI7N88/i0gmTvTEy19RthbMe1TmSuMD2G1bb2zRmwWZYU68WxJ1nb/YgmdekImU63UO1LaHqcJ/9IkIJhne8i0hqrl+9ykS2YDrk5pRR6HHG0FhP+iM/hCgn9P/+E4TKEQmJcxY1HqHKMcuzM7rFCm0HBm1RcUq3XFNtaoaQInWM8p5xkeB9T+22tJ1DhV3clRCa3jY0XceqaSmTmP3JmF4lmGa9m+wFT1QcUYkJbUgYJWOiTUVz8VVO189jzjbIWhDZmElaUOxltMVAPCm5cvggUVogdYKIAzoPtOuK1d0l3u6Aa9o78J7eejrvCR/9KBiD+r7vIbzruxH/m7+GHGWkv/5hwj/8AJyfo4oclSegU3oCpjeUdCTlBB9ARyPajWV15wmObz+HFTHp+BpdVCLzKRkWMwRaJzDrgK39LrbJ1wQ9ENIUme6uqyrWkAj0OMZZT+g9wQma0yX9RYUurhNlHqEarB1Yntxlu6g5LFP2r1+ni3f0eqEEbRPjjcd0a0zrIB2THO6TlDXFRJHfvMno+hGiKDg2ll5nHF65Sby3RzEbk4xLmk7gg8e7jsgr9MJQnx9TlhYFnD/9LObegrjZkGyXnN66xea55zCbNbLpESqQzsck4ynFdEZ+cED50FUYBtqTBV1t6NYL6sU5m9WSpqpJesNIBhrrqF7eZCuxsxm9rEH0zuOcpxOwF2vGWrFtlrTWUmtNYh2ycdh1jTm5hz1+Drtc4ZYbQtuACrtNujRFjUckh3PEeILY20OPUvRsjpofIkcjohChRUbdnKKD4yCNGGtNY+w308ZD2EWrRRm9czhjKeIdQb/7A8jEh7ZBao2OY7zvkeKlOEOlNQjxe/qwv1UFv+N6oF+ZePFHvf6kwf4OqhA81vWs+zUCwSydkSj1ByJnG/cS4Ay4LxMf3ECqUnzw35Q36i+jWl6ef22tpdvWuNqwOLlH3Tb0ztyXjCst8fabI16cDxjnSbTiK2dfRbjAgZpSJBl/+Y1/Hh8M/+Rz/5S765PdIkXtZEiwO7lc32O0R8qU6FKeGHy4D1WTcQou4C4lO6mSaPHS5+K8YztsiYSnUClSKBy7RXaid1MPIxVYw7YThNAwCrvFo0g1AoPrGuo4Jx968J6Q54TeEcUxIt5BHGIV4RV02w0YuYNV+RatJEPYsGgrbsxeTWs6aBYYDC449ooxV8ZjvNPcXS8IwlySFHef3xumjxCC50vrpzGDR8eayLfItMQZST6eUs5HCCHx9MRxSu8CSnikT/GDoJiNUZHDRinj6T5xtvM7S51gZlcJsz3iJGJ1ccatkzuYLCFcucKQ55TlmPigRJYevx3wtWBSJlyNBF1jeOp8ReMcnhgR7G7qCmhdkmRzZO7B1phth0SyXm0xziPtbqc2Vh5/cUakFSrKMYuGeJQT5RGmczS65murJ3k4f5gyHiGLApfnxAf7pHtzPBbX1PSLGpZrtOlomhUqTXb0T2kIScBUO7r6pJiTjx9B6ymg6S6eozW32YYz+q1Fy5LZeEIIFilruq4imsak4wSannbTYRpHEsUY32EGTSEixHqF73rO2g2ri3NG5YjpgzfIHrzG7HBCUU5Z3l6wOa2IoxwjLTqWSN8Qy5jQWXpfkwmFiEfoKIZuRfCOQRaEfEaUFWgVkYQEke+8fpFraAYHHv7ia36CaTblF5/4Zb66vIMTjlF/h5SImYjwXcXJ6g7KNujBslrdI/QXDBdbXOO4uDjBnrf0Jw39+R3U7XP8akkytOR5jjYDvXOAIXGei8oh6x7h4AurJ5mM5rx27zGCE1hTsR0uWHUWkaSESBAphRiNucDhq3NyGoTrqDtNHO/RiBHC9eS+RiYSiHjzwTvZy+d87NkPU9MjLye4Kk0ZX7sGcUI6dJjzc5ZNR9XtKL+ZnDBKBLGIcVGJEjHD8hjna8RoupOJx54kFhigbWp0VND1HWHoiNISr2A5bMmlIJYRoumJ8hLwTKcTbJyR7B+gQ6CIR5RRSbdZMgwX3Ou2XNTniHVFf1FhrEUEv2sCfWC9XaOloGsaln2gMoF2sFhpyeOcvttF5Ji2ZRyPSYqSVb+iaiqq9RrTVBT7e5RlSRIlO8l/16LKEj2f7a7ZiyWi67DGkMiEQKDrW4R+SeptzUDw/n6UGHxzXNe3lIcbf18WqYWgTDTjLCJVktVgcJEkDI7gPErssntf3PR8MdUiVjFNYxiMJ1cNcTolixRZLjFCsVou8cOGwdUIWRBFk/uvIXhP3yx2U/3L6/iL8vhovofenxHtz+HgGvrwCmQ9YZQR7d1g9MCDuKObJEc3KdOAv3ML8dpXIR+8RrR/FVWU+KbexcrEI5J3vgfhDOpzX0As7rJZXFCNNOQZk2SCkopgBtqz2xxvNwyi5HD+AMrlSDfQ2i0q9PhNx9fPT7l9/hybxbP0asA1KfrpY3S1xr/9dUT7R1wf36BMUmw/oLqBJM9opSUOBdkkp/wzP4xKU8Kv/SbKa5SwLK1FISicR2ERpmEjc9rg0XaNCbBiTDK7QpKNKUYHrJJ9mB7gP/oJXN1TfdfrSbKEcSQY1ieI5gxpa6pqQyJhVsSU5YRmGBje9nZiHObLT7I2isK2pEJRmQ31Zs1keohWCc3imFVzF+cMpYWZTym3Fu0kQs+xQ0eSaVQIuIsloWlxX/8q5oGHsEdXGY813i2J+5oHkoTYBYahobEBE08obzyGfu8P4qoN5nc+ghIKu9397Fpj2ShFJBVp25PGEpVKgqnQvUaTkM6ukCYz7GDxfcfKbnBDi7xsiJTK2A41i6YhE3CQ55RxgkgKqsFAuyTYgdjE9K1hFWLK0RhGYzbrM86/9iWy7Tn7s5KDG48SzV/F9Oh1JOMxad8gAoQQMT84Itsf0ZkagSOomESlBBcYuhZbbdgsV2yPj5Gf+hRcPyC6uU/nGs5nmuhv/5eM3/B21K3naH/6f6J74ku7tY2IGEIglwO4gErHu+gpazAbg0hyyGM6M9BvPeuzNUMXGImcpOmoULg8IugYOSoQaoVrNiiZ4b2531AFZ9GpJiQKHwl6G9HfvUAOluLoCkkyxbRLlk9/gWVryfYOmU4Ek9EDuM5xeuecxUlNt5ZMZU7ne3Q2kJYKn1hEOkX7GNsuyEYldbPGipb92SHCRfRB46ymHM8wPsb5DBfA1xYdz3DTmxSHN0hmJXVlsDJGpAWJk4QusBIZwkuiZsANFVEeYYed2kRHEcXBIcW1fZR3pPGEJC1IEo1XGucstC2ia5DbNednx9zbbOguIYQi2bFnXpx4Oxuog0cpQaEkozCQuIG7QTJ0Pel2IMgEUYxRZYHKE/R0hJzM0YcHRHtz1GSCKktklhEXKTKOcJ25hJMVIAQySZBpQubznWKwOgagiBV78pJmbh2LSxI6Q82LlP227ZACitEIHaDuvz2vCcAOA97ay+m1IwR333/9Yimt/9ANNs7v0mQy/fs/9o9Q/fF6N3/Eqzdrlt0L7JePMEtn92XhhZIszS7w/tvl5xlv0FLfX5i8XCZeZAVKKDrX3YfNwC7/Gl7pv+66Fj8YJtmUpm8gFrtJ4jDsyJBS4VzAWb/zZL/42i9385T0PHXxFNeLqxzGe1Rm4Gh0wH/xpp/gH3/mZ/kHv/tP+K/f83eY6PF9KESwHh86rJbEKr3vXWyr3aZBPo6ROrokL/dwSdwtlWRlHb1z1GYNwVPoGOUkSIEXHilitIp2mw1C0VQtyISRCLihIypLhBb48zU1Gm89pQY1mdG2HSKAVwHbdTtCqrPk0zH1+XIHh9pL8b4iBMfz61uA5+b81XRyhBYrRH1MWhwQyYhIwtXxlBfWF9zbnjKPcqzdfQaPZleJdMwXz77GOw7eTXAWgcORgw+kZYRSyc5bamq0nhPWz5NHKbHOSGVCNJZ0YY0opozHE6RQrNoel49IdUJ2mLBtHNGQcdo1PNcsEXlOMGtGF0uy+SFqGhgIsIFSpKim5VqRc3ez5k5QjF3GPLG7x1yWUmNknKLzntW2pWwHTLD4g8BmZWlWDZld76BIeUZ/vsBme6RZINufsH7uDh93TyEjyffsv5ah7vCmxeEoivzSt3oB0zmFEthNTTNsGZqOWXRIRL4DtpiBSKtd9FhIId4BULxpoPEkxRU2SuCtoygbNv3zeFGi4hkxnqY5Jy4Cugl0vaAyHsecfLhAlxmnrUQ2nqupoWl6+mxGe3QFJRVplqKzGp0qhAbWW5bTGRJD2Z1h4pQiKlhvX8AFTxFPsXlO365IXE8foh0BVMe7hVHniQl4PcJNLNGwoO4SGiko45K//Ja/xH//iX/Arz75K7z5LQWJSFjVJaVbE4uWW67ia90Zfb/i+e05HkPbB86aNRfbuwzOshYdw/mS2vRs+optaNiYir14zjv338579t7Oe2fvpE0PGeeeO/VdTttT3v3gu6gazzzZnau3F2eMJ3tM4zHCBUJr6VrDtlrzGB0kY8YyYetT1rXB6oixHzCuRuXXiGXKejvwow//AP/y8z/Nr9/7JH/u6Mb94yudz+mblmAHjB144XxF0Swp4pRYH5LpAsc5jb0gW0+J1BRGmmrbgBiII48MFiElddOyv7/PsFkS+R6TFZz3F+xnYwod0a4uKHRCSBNcVTGbjjg+W9OqiDJJkUqxf/AAVbNCjyc8c3aHWE2YOsH69jHJ9ZKgYXVyj8Y5tpst1/f30KN25wEUkpO6InSGm/PrSG9ZLxcooJzOiL3jdHtKHWpmLkLHEelkgpSSJE4QUtF19S7ZIYpQsxmhafCbzc4vnGUkIqEdavKsuP8Z2r5HyMvprzU7WfnL4rrcJdfiPoTnxXvE4OiBIcA4Vvdz3WdZxFkzsEo9c7HzBqoyJpU7AOWLGbYAWmhOqx4texJp8TJDEpFpwxBLumaNUBEqn+DEK///vqvwoafIr7/UdA9mZxuKMhgqlJbYwWKLGNfVeJcSFTOkUjSDZSQF6skXsCImvPZBDDVxdAWZFoSuw9c1ajQieu3rMdMP4z7zZcTVCdvxEbY44oFksvOQDz39+W1aZ9nEKbFwBBfoBYTGIRNFKy1ZW+GSiHMvOEKQTh9CmRj5az+H0BHmPe9CiRLR9Fz0LUEBLnA02mPJBX3XEUcRel7A+96N/xe/wvRLX6B6eI/NODDCIZsl1jcc65Sz1pHZM9rxIdaPwUM2Kei6jrKMuWcc955+htHXnmJ74wbn124yOXoMEzKWp3fJk4jNnRNqoXhwr0bIEmkcvqroj/YRj9wk3L5FFL8fju/SpZ5tAXFeMkn3WZzcwpk1RTFlPLlBr1qqZYNYt3TtAAjiSYyUEnt2Dh7sF76AMw77jrdR6JrI1LRDBeNHyDNNv1xQO4u1OdNRTqQkvO2t9E98mfCZTyDe9Tb6YKiaGpnsIccT5rEkXxk2izWdeJJiWjLbu4oICc22xbj48lipWdYN01GFqnOCzTAi5qRqibxjLy2IsxQpBEWWUa0qpqsTXCiwvWGzWVD1nqvjmEpGDOmE2fWMg6sPEiJJomp83xNImcp92rPnWG2eIMoP0bFAdj2iEJSUnFcdTlj6doPKFNp51u2A/MiHKBbHmPe/ncWzTyD3ZmR6j2wQqPf+AO7Vr8F/6N/S//TP4N7yRoYf/wtESUIRG4yPiYQkSRJW9xZcrO5RyglRoSljhekb6rMWl0uSSUEqLVXoWcSS6yrCdQM+krBs8GyQWUSUlrshfggIFRg6izUSPcnIFgPCK0Iv8HVPfXrK0jeEK49yGCzCO9BjxFnDvfMKJXoOxiPSbMxSr+jcFjH0O5tLfhXT1/j1ks4IVk3N9KBgbzbH157BerqtJS0iRJrQVDUyWhPHB8jZlDDUpKNDlPX09W1WumU/TghesX/9kOe8IO5XFKlg09cIFQhDwA7u/no22dujMfdwbY3WEco5yEeMdUKZBEglabekrVvW64473ZgsSRmriNgHwuARyS4OrCewrxUyeOg2FHHEcdvDpiYIgZ9MiSMFzWKnhjQNwpfI7FvzlnQsMZs1cSYQL2MVydEINQwkLqfrVqTZHKlTVGeZaEXqA1vnuBgMRbelSDIQkrpuUF7SDZJEKZq2xYzCjnT+LWpoG1QUoaMI53ZqKCljvPOYwROnCqX1KzZy/yDlO7tLC4t/b87UH7X6kwb7O6h674DANBm9wnOdSIkWntr93g12opKdL88M6NmMVKV0dpcnmOp055eKwv2FincBIcUrJBlNs8U4QW8LItGDGhiNDrHW7iYtxtD2A9YP5KOUKIpQStEbT6wkTy+foekrXjd9M0lrsEmMDZaHZg/w51//Z/i5L/0C/+On/jH/1dv/JiUp2B1Ax4seL9P7MkPTuV3WJTvPt4okUiU400I6BXZTbOUcp92GVDhKHSPDgPSBoCNCGBA+wvsNkdxJ9zILM+UhSQjpgIgkod0SBkPlI2LTk105JGiFrbvdxcJ2BLPbqVPOoXwgn09p7i0Y1gI1Audavn72FImWvGb/MbqmxxYlEypKs4NaEBeUScxROeGFxSmRTBmpgDEGuoFXzR/jK6vnqV0DZmCHIUpJM41SEtN3mGGDjCUQUzcNpRBosYupUpGmbgNCSZxXnJ8v6ILkYFIw85KN2aDMlv18TpnPea7eEpRkpiVDX9PKlK7bspEBNZ4wzws29wbyuqWUHQ27CA7RrDBs0FmCUCnWtFRVzmprqWkIJHTrJT1n9F2M2G6JZIOejgi+Qo1K9N4B7cUFozIj2IFP3v0se3tXeXx6A6saqjpBSQmZoK5XNF2Fiif0oWEoA8Yq8uQIRUy/XjG4nq3vyZKMPJV0fQubU1QWIQZBJErcZMb5as1ASjzqOak3fO78KSrbEYuS2HtmyjFcbGgZk4/3GOcFQ7sksRVSzdnKCnnWMr4y4+DKHlIpnm17EimY1RZnGsqjPRLjWFUbynhMY84Yza9gQ0vXrpHxiNF4TOV6mnaNkwlDWCF1jBAJUihEgExIOsBNj0jWd6iXz/D1C8/SnHCrO2bRHvP5u5/gI099ECEi7tUnrIcV7j8w5uKkOeErqyf4J0/9TwA8Uj7Ke669i4P0iMa1PD59A0YkjArH+cqTioKQa9bbBUXISeKASC6ovKUVM8byiKxzbFTDqU2YjxJi22CkpYjG2CBwvuNNxQ0+PX2QT558nu/dfh9Ho0MAhNZksynr41t4vZNI+60mb2rU4AgmoUwOaZZPUImWveuvxbkYwY5VI30PwaCIGQgYs8uu1rLjLCqRLuHhdMp5t2aoVuxdew1D1yG1Jstz8qxl2w6MyhzfNGRFSb1dYINlPh0ztDE+L9HdGalXpOMS6zwX6wVZpEmTBOUzjHfMi5hNF7AupjEBZxymbsmSmKbdLVhm2YzWVNTVAh8nxJcJAnEck2QZzcUWP1hUuuNtiKIgThL6vmM4PSPOcmpvGYQhReGd20lt4xQ99ETDgNLRK+K6Osk3ycOD8+A8lQJtA1n8UvpClCjGnaI2gY0WTMwO/phEkq3z9D5g3bDb2DQwDJ6RbvAGnEixnUWpFVLFuLiEkOBNRx/19yPLQgi76XWcEkXlS6+r63c2ERt2/j8Nvh3ohwaV7BE2NTFmJ4t0htxuGL72LCIqSV//OI3wWFsjZYzMc1xdI/MckZaot7wB9a9/nfDMLdz3TEAkKBlhupb+/AU8ngudUC82pI1gTI0d50TKkauUfGZZ2wtmIqaORpxcHDMppuz3C+TTtxne/hZWSYJYdQy9J5sW5POSk2fvELUWGWs2ywVzNEJuGG5eJVzbo/zyx9m+6gr+5lVkprioFoiyZOs80jVkQbJcblgLj4smLFc9+6GnCC0Yz/YXf5kIwcUbH6eXMSoZYRuBcxL5wBXWp2f0vuWWCYzFBoKlVAYvB5r3vR/5gQ8w/vpXaR66Qjg+RTx2nTTTrJcXdFHD2CgmYooez/HmHK8r3HyG6iX9+phIJHghcK1CaMXw6U8TjvaJHxyTZglWO5w/IM7noD3lwZzN6S2qZsPh3nQXOZck6B/6EcK/+OdUv/xBVu/9LiKtmU2nhCIlH9a4pMCYnu3FHcIwRmQSISQCiagdaQuygvONB7XgwA3ITLEqc7yXHGiDjmOUjvDGkamIVe1Yr48J0ZSu19jBEhUlxcEIbwPLJuIo75juX6cfHJ3pUFGgv3MbXS/xjcH093CTYxQjkiSiTyHyCtV55H5BmsZYY1HxQL06YfLkV9APPsj21a9htXmevYWjmB0wNBVpus/su97O8vFX4/75T+I++0WGW6fM/4s/R3w0prE5pjLY3lAtT/DeEdldZKU9SDwR0G8AAQAASURBVElGlpGPaAewQSNdT2waVusN02s3drDOdsCKMaq6QOgROprjncP7QLtpcUaiI0VWSEwaCMTY7ZJ2sSSonGZ2SBk7Rt0G6zVuDdUmkMwKtDY4OkSXoxPN0h4TFwdk2QMIoegEdCHHd5ZCNYzFCGElUkOmJb32iEiSpJL+rCG7ohAHJaq1RPGOAp6OrjIVW47Xz6OFZW//KiGOyZoObEDM9+Hu85i2QuoS87IGO45j+slkd11wFmpPjyGNdt+XoUfhiKYHjIaayjlWZuBe05BsA5NUME5K1r1FR2oHR2sWIATrrqdYXGCd4CTPmDcNYjQiUvEusqvtQCe7G9e3KB0JrGmx6fi+0hPYxWWNRqQrzxAa6u0x48nDuzGIC6RakkhB1W6pnaMNKWHb0a1a9mZThJQkOqUbOmrnmMpvbg1N3+1sSMXuWuz9gBCaEARdvYsilFIgdURoW7xz90Gdv1eFEPC9B60Il/ehPy71Jw32d1CNkz2a6JzgDZC+4nuFkqytw/hv3l1y3uGD33ndhoZgLMFaohcnt24gUQm1qeldT6p3z+2cf4X/2jlH37QYq+mCIIkL+rrC5nO01mitSdMURUfX9vcn20JIqs4xLVO+cO9LBBd4fPoYsY5pOkNSTPB4Xnf4CD/62I/xoWd/hX/42Z/kb7/ur1LKEm97rAq4ECG8o2sN9aJFIwgOhkiSRQlKJzjT7CRLl/48HQxr0zLJp0gaJBoRepwMBGcwq69jXKCfvJGq6ThQORENlBOs3+JtC/UGFxTbpmM03clx+qreRQZodZlhHTG0PWkc8H2PHo1I51O6xQonHC6v+PrFU1yfXOcgzbmzbVhZy3R6FUmAbrMDSKQTxoliLy9Z9A4RDfi+x5ie1x+9kSfWd/nCxVd4PLpCSHKiNEJqWK1WbPqO1qyIooLenLDsPFmm2QaPcI7MRZw5vQNMbBu0MyTz8S530w783BMf4J986SfxBP7Ugz/E2278MI+4R4gC7F+5CUphxMDSOqRc0EqoDwTdyQWFg2rh6EcGX3iqpkUXS3AC09XIkHCYHXA6XJCMpuSuZFlvUTphP+4oZER2OEZFHXK8D0lOGHo2ixVf88fUXc0PHr0NGU8I7TFxXIAuuHtyj3o4IZ9k6MEgkexN5vR1Szmd411gvT0j8mCW5xg60qtjjJwStg7tSoZqhUVyMQx89vhrfHn5u3zhix/lU3c+QfMi7ON/QQnELo5JxsQqJZMpY5VTRCOKtCQnZRRl5HHOQT4l0TG6D8xmN7iy3cf3A0k05YG9ByhTuFgvOWk2nNRLbq9uc3f7PLebY+42x9zb3mHTb/4Xv9b/kHqmeppnvvb0/a9/886HeNeD38c7D97I6+O3cmXvUQqb03RL1tGaK1HCgYyRBwdseonSirlSDOsGpyzR0GBUj5xMEEIzOEcmBa5t+NNv+HH+/md/kn/91V/ib7z1r4KO8cFTxw4RKeZOc+E9VZ6zl0zxiyVN58hHGeP0Ctu0pe1XuC4hSUsiWyDosb4DAyFO2G5qnO2osw6nUvaLjMQbRN1iFASt8X1DOtoBrSZFxvH5mm5ckAqBcB4fAttmyc2DV7GQG05Xa9I0oTASbSwXTYtSmgcfeog0yzCVYFF1bIeWJFLM4pw8lSybDoti0Tp0v+Fof8aoKEgWhlMCtegZecPPf/5nefzgtTwyfojt2YKubijSyf2fidCaaH8f3zTo1qCGijZPSKMUO/R0IXCxrUiFIJGCOMt3zbkWhMF/a3l472hDwElJjkTpnbdOKoVSkjjawSrbSNDKQNY7VCRRAnrv8d6ghWZdGZJIoENFT4ZUMAw1w9AyKaZsRYm0HmxP3dVMLzdQTb/F2o7x+MHd67n06blth08TfOcQiSZg8FQIm0A0RiYC7VqWgybrN6gQ8Lfuoh56AIqcJBshVY61m128jm8R1QaV5sjHHsbj0U+fM35/jLRLzlaCeHWPgMcWU9bVmrRyFKTM5yPqYLCiwjQDsd7jcPZq1psLQntGaO5g9/aoP3aLGMXFw1dotgNHJmc2H5MdjKBfk4kWtb6L0o7OLqEeY1nTsU/48R9H/vOfof/UZ7i4/p/hvEFHGcV0n3SQpC4hEZ7rZsN+mVNHsKh7qiAphefhr3yO1XpB9463MTrIKfb3uZKV+KEhmaZYZSHUXEk0Pqxpw4xVPEXJiJOLO+TzK8yLBPOxj1C++W+xEhXD6Zbt1BPLEeN0QrrZSUKlihBNwDYtQ7nP9GCGqjqG05ZwcQc9yfCf+ALCdMj3v4doegVSje02CJ+iP/LruI9+DC0CE+9JdEAcXkOM5wilkAF8kRF++7fJ8sDke7//MrHCYYYFIR7hixLjcuT4kCw9wpkdwFTZGuEdkzBwtxPU5wNPDU8zvnMLDq6jixhLQz+N8Z3hYtGTNjXD8jZL2bCfTdHjMYlSyFQxxAmjcUFvBuIkRrmWrNyjaxX9ckW/7WmyOXassFuNGgmi6YgkOaLrK3yrGDY959sBnwS87zF9R/+ZL2K7wPpN7+QidIh0n/bsGJ8eo6cPYipLLCWTScHZf/4TmE89QfGbH6b7+38fvu+9yHf/CHVds3UrRGLZO7yKImU0HmNjR9UPTKYJ1B1m8KTpmMx3bNoLbp2PeWQCbgveaIKISDDQrbEhx3QBZx3FJNvZ95oNwYEPMKwX+HlCl0wQJuLI1AzNObU9BNOiy4hHb+zhrOVsuWAxrNC+oQ/g00suTwhsqg2NjZhMSiZDhawqgupBa9CSqIhoz9bEpsMkJV4r+r5CyYLYaAbbk01z0n5CZLdUtmJPWRqnGQmP0pI6ziFJGLYrRlcm9LXFOY9Su0jVKEmwISC6GjvU+LZAm4SgHaKvCFFGSAqkihh1G8okoXEFF9WSk7MlZ7ajMZKb5RjfrHH1hk1jWK/PmZQHRHGgUiV1FxC+Qk9ysD1hsAjZIMRLG4ovL2lqpBZYUqJv/F6aotKOrClpzIrBrNBiRHC7NAkBjHxHpHaql4ttRaKg3CsY2kCIUrL2gsY6nFaob0iSGNoWFcc7nzW7BlvKhL7eKZWUlpjekY12r8xZ8wdqsLE7FavIA8YuiKMZQvzxmGT/SYP9HVRCCJTcQThg9IrvZUpSOfctd5deLsULZnej812PKouXZOJRgZb6foMdQsC7QJS8NBFv23aH6q8DUTJg8wLb1rTtitFo//7jkjQmOEGS7ciJVdtjraFpB75854skQXElOcQ4j7aOtm+YZjNWw4pXzW/Sm+/no8//Bv/Pz/4kf+3hP49OLH0SaIUhN5ZhZZA2IMYxVdsRnztCJBEiwpmAcx1SRlhvsa4m1wkmQIJDhR0d1wVPu32Bvt1gTEfwF6RCoaYpkgERwIkIU91FdRH9ILFxzGg+2V1Mtg0ueAw9SgsiqREN9IMlEx2hLImKhDCUdM2G59bPUPUb3nHjbahg0alHBM3gIkKesA0Sug1jb/Fasl9O8K3goqroty3KGx4/ejPZsx/hS/e+wGMHM/b29rFh4PSixgBJppjnY2yXcnryPDo0ZBQ4qQHPvU5wUnvmpUDanj5LqJXm9t0v89/+1t/l43c+dv9n+MmTz8Kn/juuF9f5wb3v5T9/x1/h/eXb6bc18/k1StHgUSSzCSftBarrkX7FeeVRYsaol4xciR86jGhJU4VOcvpe4eI12dU57pnnkc8fE83G6KOHEGWx22zQu4ncZD6mPznh48svE8UZr4seoFcZy+WWELcwus4gOvI4ZcQRcgA91gjp0KUGZ3B9IJ+UpHnKdjghbqBfG4aDKZugWL3wFP/+6V/lE9tP81sn/56z9uQ/2vkaCAxuYHADtalYAnf/oz37d249vfo6T6++zk9ffn2zvMm7r7+bdz30Ht738Ltp6wjpAwd24NinGNvxnIU6gqLd0GwWyCQh9orQL6hdRG56rPdcGz/AGw8f5wvP/w5fP3ojN6+/hfWw21g4vPIQ2zvHnNYLdBbj51fR5yuae6ckYUz24A260FA1lkx1CO1Rckwk1rT9AunmyHjEenkCtiXORuQ6ZRRp3NkLKGuIxzPW2wWjZIS+JIGnWUoSbdm2PWmWYestTngiB1JIrkz22VQNC7aMokO0dWzv3aM4OiDNMmrriKIE4StW7ZZRkiGNpFmvUN6wNymxQtEMjrNNQ9cZ8qEnL+bUzYp/9Pl/yt3NPb58+gT/u+/+O4hYUm025PPxKxpirSM6rRGjEXnrqZfn9F5jfOD8EsrT4ZlpgTO7SZ1QEuMtxgTK9KUlW/ABbxyNguhyU1dKQbNZEyUpSZ6jY4VvLZkQbLVA9Z64taSJpLEO4Q3Cp5jBMcsD/aoBPUfKlizL6ToNwZKmmq4eSGTGtl9RdzVFWtBWF+goI4rznY2otQTr6ERPkziKXl6SyxconRFcipOOdDSnbZeE5fPk5Qzz1DHBWtTrXoXHI1VOFI1pBiAYRALd4jlklOFizfDaG6S3zvGnsJo8z0V3zLV8TjY+ZFstyIZAZxTjK/voPYk8PacnkBU5zo9QmSRbVWxWJ8hY4Vc14rOf5WJ/zPneAVdFwUFZkOyNkK7B2xZVFhRRybJr6HIwLqHtA91ojr46Z/G2d8AnPkX69c+hHjyinF2lDAXGBaAhjROSqORwPKGPM3K55N664eLeOQe/+WHMaMT5ax7jiqqIiwmuA1d36CLh7ukLJMWMg+mMgTVLoZhHY0yf8NSmYrw1jN/yFqJf+xDdRz7E+rtfg1zFaFeRXI2RwxRSD1GM73vctsf7gEg1Orb4JEe4gS60mEVF/NnPwyMPIx57nDjLcZ/7bfRP/SvSn/uXyOOXrqB733DdSS5/3a+f/7n7f5wCIUkIRUGUxkxTjcoL4myMiGOIY1IVgdbMJIyDQsYxg/fIoSWOFHY8JYkCOhtjiYkUiCv7zK7OqQ4eYhhHnKkO4xRjnTNkCc73OG8R8RzjaoTZohwI07OJFX0+Ji5j4ixDSwPa0ptThNT0WUp8MKaWHS0DOpeYs8D8819HZjPaR/fw1QptppxuBfL0DvNrM4SLUNstxUjhDbTf9T0cPvwIw8/8M7rf/Bjhmdss3/9+1DRhbzRHR3vUvUF4RWlSutATUk0sDMNyQ+zmhGjKdb3kWTdwb9tSygzXNyTCE9ScbrnBih6dauJUEGeadtPT37sNNmDzAmM3xON9tqJgL5ckdcPFItAMHbOZ4fDKhDhSiFiz7+bcvXcLFw84mVFte2K1YQiaVdNRpnPGhSMqH4Db57jFPdT+dUQkEc1OUq7yEToTdN0aw4ZxVhL7iCGy9F2DD4qrB0ecGMVic4ZLp0yEJNOKC6mo0xFhvWQaHEIKbO9Q+W49HEURxhhCOaE/XeGjFt1LfLPATAReKDA9UTRDJiWiryjSCenVfbZnW55pWrabhrg9Y2RbUjT1MDAuj5jNjhDdEp2PWTvotlt0lBB7CQiEsrsoL/2Ko/1+tFZUjOiswNmd9aldnZLtXbs/xY6HgX6oqaoTJkkOVkACvmvotz0+nrOXRAyDQEYx58YTKsNIJqTB05qeOtpB2V4s2/cE70my/PKlGMBjOkW4tDASoKvM7nVd+rCjb3gL36r84HbkcdUj4I9Ncw1/0mB/x5WUCSEYQvC7rM+XVa4kW7uLcNAvm2Jbb5FCIp3HASLShKEHilfKxFVKbWp88AQPhN2u04vVdR3tdiC3kEuDiUZsmoTNakWez1CXu1EvxnV5G4hTDcozHml6d8Hd9R0eiI/oB0OfSNg2tJFA+4hEJGzdmlfPXosSlt989iP89Fd/nr/2jj+NzuaMyEgbv5PVXMnY+J2EcnXeYpVCj2P6FgRb0jRiMyxRUpDHI87rDUEHRuw+i9Xq63T9liw9Yr25w8gdk1x9BJdJhEnBtCitGeotvhnRZDkqK0mlYLNdsV6fYyNPokoSEWNExyhLMb1jaBrSYdg1CaMM7xxPPvcs3vU8OrtJOzRkmSYRY7a940IbrEwQyZSRq/D1CSo74vp4zmAMLzx7i8NZwUzlvO7gdXzi2Y+zmr6Zguv024okiTnIImIqhBjTW0WWSA6lpmgb2uAhGoNV3CgSHkx3VoKTVPL3Pvp/5B995v/+bXPQ79R3+Kn6Z/mp53+W/WyfP3X4Pfxnj/9ZfvS1P4YaWkphaSZzgl1yNA1Mw5hVG2gWF7jkmPKgIE32yLJDED2lKjipT6iO76C3jixPEZMpapQi+oEQC4TaLeSFlKzdBc9VL/D44ZtoVitsogkiJxOO1AXS+QytYmydsWlWRBHEypNPxjTnt+g2G+L5HpvK0WVT9MEhH3n2k3z0Ex/gt89+hyeWT/xHPT//qFUeZZTxiEzljFTONN9nmk2ZqIg85IxtjkrmTPdm3Dx4gKmAL549wYePf5ePPf8xtsP29/0/blW3uPXkLX7myZ8B4JHJw7xh/7VkMsbKEYVOidDIKCNGMB9aZtl1spOMSCXEfsw+gqgYEW9v8XAY8dH1BT/9u/+CvxmPyCdHTJIJArGLkbIdenKdod/RpEWWwmwOVQN9zxBJ5pM5zm5wrkLrMa56BiEKrCxZ1guORjk63yOXHik0TVNBqhhFJVW9ZjY5uP/+hJSMi5RFPdDnE+phSxo0GZrGNEyTKVfyKU3puLtesReVqEiSDpaqH6gQKDSBga6zXB3PuVicMrQN04NDirJEa70jbW9q1vdO6JSmSyS/cfvf88z6WR6cPcC9zRk//5Vf5MdvvJ9mU+EGi05eaoql1uA8XnqKo6t0G6jWF2wbyzot2MtTVsbSWEs6DLsGW0v6AHj/Snn44Gh9wCeKwrKTYfvdQsiZAcjRkWToIPPglGSjAjPriDUsvQHrkVbsrDxiwzBYslmK1oo43kOIhro+Iy0MnZIIHyOlomoqsAPW9pTTB3bxLYMDJalERSNa4uSAru8RzUBIDEl6le1iu1OURBGbBpIwoJWi/fITIAT61TcxareJ3ZiG6jL2MYoKZLvA2YY1NerNN0mfukPz4U+hf+gNlKknJDFDvcIGgVAFMnWUU4OIYorRPsN6ACmR0rFdbeiHJdkA8exVLD79CfrmHN7/n6BHh9A65DhGaqDeWYfIEmRUkHvBxncsqgUpE7ZFTxE8ww9+P/nnPsH0Nz+E/Jt/nb39a3RtoLlYcFB6oighzUuwLUky5sbkCBGWVL/wCwzVgvWP/jgbKUmTmEfGY4Z1j6m2mInBu5j5eI/0yj6Rm3GyeAFh16RJwTyXO0Xbu96P+PwX6D/7aaLHX8c8V9TDhu2dgSxouDIlURqzWDHUgXRUICOLre7BSY12A3b/Cuqj/x5R5ITHHiX5e38P8Qv/ivjLX/mPcq0TfY/o+29uxC/r5cv2wz/A802+4Wsfx2RXjnA3HoJX3aR56EHqo33Ko0M2r3k94koBZ0/gVMlGKNqxpih69scF43iGX22QowIX1mTtgtX6mHLRMtpsKdYd8cWK7jOfRn36s4giR/7vP4w+XaCqlvqhB1m+7Y10P9Libj5O8/yGdQKQkI971qOcw//t32Lx4d/GfPS3SP/Js8Tf/07U295KFtckZcCEhGrRMJqOEJlgYKCPKopQ4eSEqA3sxQ1bBKUcYSODXdXYFzYU18ekqiWr2x0fxlvcxTl2uUZdu7nzc3cJS6MRMUyU4HR9AdmMkpiUBmEN1WKLiiOk7JjmOZ2ZYMua02aLPPc0PsVrxX6ZEsktOpriRgp/ckzoFzgb7Zg0R3OkEfSDpasF2vXIyBCnCZt2TSSgmO4R9SvqVnLe9pRqixYOocfsRZq+HLFYXTDebEjKKaZ3xH5nm3wxStUphclLxPYEKxUIj7QH6CwlMOBci0wmEDyuvqB3CabqSbxhpiJks2HdDJxJQzrLOTy6RsAQpCYpM5Rx9C4l2TZIGSGl2UUo9ttvbrAv1XYqHyMqi20aurNbtBcrbG8YXXsIoRSqLMlWhsqc0Ylz0uiQobWYxQoRJaTjjFZ4srVjfzxiaTwb55BBkwhBZnpal1EqibzkIQ1di06S+xNp7weGziG8Ii31fY6T1ALTux3ozPz+kV8hhN31XXmCNGj1jWfdH+36kwb7O6x2ge0O73vUN+RB51JS42m8Zyxful28mH99H/6S57j15hUy8d725FFOZSp616PdzuPxokTcWktdd/hVx/hoTpxqlLP4csxycUJRr5mO55evUbxEEw+BwXqkNDx190mc97z+8NXsXb1K7RzBGgQCmUj28j2KsuDZ5Tnf/dC7kQJ+86u/zgee/CB/9q1/i6z3OBNIZiki0TTnKyaZxOwlKOMYJRGmKBlERUuFkIEymoAPdH3HmUnwtmbZnVN3J4xHjzJsIoYwQcctSg27RlOn0K2QtsdtLVYPnEclnduyGVq6xRpnDeP9A6bTA5RUXHQXGOmI85J+cYKutsRJgogUTsDdboEIjkNKalMzKvYo4xG31g3PbHv2M4UJgXFSIt0S2TcIEXNF57zge86HnAMbeN38tfzGE7/BZzZf48i/gcPxiCJRGLMEEkwbMZgOmQvGIWUwnrpqiVSGNB1FEkFX83Pnv8T/4aP/J463d/7Ax955e84HnvtFPvDcL1J8qOCHH/oBfuxV7+P7b34fTkbsy5K9gytkVc+569Flho16GhFhXE2qUnJ9QH92D3dxl4nIiW6+hqAjvG9xmw6mExTQmIa2XvNbF7+L1PDWK29FDSVi1ZKOJ8RRoNSe4BpUPAPhiEqNN462t0Tpmi40bKTm2ZOv8KGnP8rH732Ez5x9lt794QAbR/nRTg3hzW6a58233ZD4TqhJVHKU7XFz9hg38qsczq6jVMxX732Fq6Or/Jfv+Js8oBOMkDRRiugdSR+4FwKDMbz5gUcRduDkqSepjgfiB/aYzCWT+T5JVPCjzQX/jdRso5IPP/+7fOyLv8TPPvnPOR5OGMLvH+PxzPpZnlk/+x/8PlOV8uTm6/xf3vffUexlmMEgVMxIKMzWIdqKrnak+wn9EIEUyEWF1A2DSomjEtoFIQOMo5GnbHtQUiGzGRJFJgxuu2WQEpVEJF7TxTF9GIh4yQeXpgm67jipVxRJzKgXuADN0NIQoyLFY4dX+PTZ8wxnx1w/moMJLE9OGB0d0SPZhoFgFNvVFtO1pOWI8eQlYrYQgmkWo9OIJo74N1//t3z69Es8vP8IP/zoD/LJFz7Ol0+f5NP5Pm+Sr6arO8qXNdhKa3DgcUityEcz7nYdS6kZNVv2VaBWMRvrGJthBywSgl4EYsfLyN0B1ztqJci1gt6iYnXZWHPpxXRIqS6hUZ7pKOIiBDatY9p7nDBUvWeOpIgF1qzxPiLJIswgECEQxwVdt8L2W9JkRlMbkijDYVgvjkmjDG3iXTRjoqioaZuKUTKizPc5cc/R9A2jqEQqjfOeVEDfbfG2J5/eIDQb3Fe/gnzwJi4OhBBjTaDqt6R6B7Kq1/foE8l2uyJGUzzwatzBF8mf/gp8/2sIacpye0KUj1DTh2hv3SFJBKPxDK1GxFPYVCe0VU2cd2w3HtM7IpMQm5grT99lm0naNz/CIWNUU3MhLfOmJRUS4hHUS5wIpB6yJOEFJLEVTIcBQoVOBsJ73kb6b3+b6NNPol77di6qjsgPJAOocYxMdg02pkEkJUeLNeqp21RXj9APHhENDfeCZF8l6G5B31xgyn3Gk33SRDB0DUbFJOmMzcVzaNfw4HyGsYJBGNZveRXjf32bg+OO9PsfJNkEtndXmMXzhETQJAmyteg0J09q6vWzmC5B9BFhfsCks/gP/hLJM88R/V//HuJlEZt/FEoOA8Xzt+H52/DbH+MyEZ2HL38PWUq4dhVz8ybFtQfQD99EPnITs76gv3eKfuEYcXaBPj9lfO8uk5NzhHklbfmVxsCXanx8l/Hv/A78/X+Efd1rqN75Xhbf9Q7U972HIixY1wueloHk7TehTMh+9UOEX/l3cHeJ/Mt/Dp1FSNtTSwh1oBiPIIVNVrNcVhymEVbFlPUp5/qARW+YxBnZjQlhscK2Pd0oA3+OO3se0x0hXUsjC9IiJhlJerXPtmrJJymLVYV0PfuzI4ZUIsueen0PLUb01QofBrSeoQfNntnnVqi4254R3Ji98QGxaEFoBDHIFKdywskpMopQhzdQl2wfMQSMFcQ2YnAtKii8schJTJRkYBv2crizgtQA8hyrNJo5V7KCKss4Xy05KEcIwAxuNzQClBJ03Yom9qTdCYSU6KE3IOUI3wZOh4G+X6AZCL1B1luEv2BVpQwqZ3wgkH2EGiUsxYAgYXu6YCQGRkmMkobBe0Ke0DmLaB1pLAgeRLgkhUeXPcDLorWQEi06qjvP0WwWu6iyk6chFWTjPWSiUYlC1xHb4RQbEnQeE0eBaD5FaElXdUQEdJxQtJ4mUXS1wxKTmYaWKY3zlFphupYQAnH2Uj8ydC3eKPJRhI4UIQScc0SJoq8tMpZ453YJDd+GGwWAC2A9PhqQSiPltzsD/mjWnzTY30FljcH2A2KUfssGW4gd7r9y/hW7S8YbyqgkmJ1PRSQJCAh9jyx2MvHe9ZRxSSx3kvHca6R6yXPXdR3b0zWREEweOkJ5j6sNo8mYts44PV1Q5hP0pWxEacnQWjrjsM4xdAu+fv4MURTxxsPXQlHgB0OUFwjb4YLDBksWZezlEy6aNe+99m7qzTmfuPdZfvYzP8tfeewvkI5S4jxiW3fYriUqYogD3WDw9UCaJPT9BVLA9fEBqU5xrkHriHpQuGGB4oRr+zcQ4QrN5oJseo1F/zSzdglRSUhHDN2KdrmgMRl92bG1HfvjklIkiKFCT/YYTw9QaneKpCqloSJVKaos6ZZL9HRGAJwM3OsWXBtfo9lcQF7sJKZSksWK59YNzrd4AUlIuZrvIUMK/RZztuJonHKuY544OSWVO3jFvf6YB/fmCCkYzAJnBVXjQNYEYRj6nr53xOMJB9kIH+fcWa05fvaL/LUn/nt+6+RT3/IYuza6zvsf+TE++uyv8fzmuW97LNam5hee+iV+4alfIpKad177Hv7XN36EP5/8WabFFdwkRYuA7WPG032UgGZ9QX2xYFUN6KKgNx1meJbVakkdtlTLO2wcXMSGxbCka7Z84ewJsiij/vL/QG0srq2I0hiVSIT0BGdB7mjrTnicM4Rgcd7ROsuXLr7MRXf+hzrPrpRX+VOP/CA/+uAP8q7x2xnrEZEzJHkBAe4dP0e3PCHd20emB9jBsDBbmmSDYUvfCy7WK3IVUUWKUbGP6HuqpN+RuBfHvHD2AiIBFzrOtydsbE/TbbChpw0DlR/YmorKbKkvd6YFgsP8kOvlEQ9MbvDA9Caj5JAy3udw9CA34iu8fS/BVCtOVyseHT9Mef0Rugjq9oKv3/kC//NT/45/+9Rv8Hfe+GdJzYrtIDGNZ29ySOag2txj1ayIQkTTK/LZFUaJwoWazeoFZvOH0EkJzQLXD7x1+iauvrZgtTrm1ekjmOkNbl98jieqL/K7y8+wHf6/5wvvXMcHnvsgH/zpD/HXH/vL/O3X/i2ulXuMZlPW5xtEPibZn9OHHtV1qPGY8qEriPqEpj4jnlxBxeMdAruGtb9H5GPicoYpSsrg8F2N6CPseIQeaoSwTEZzWtuSR/l92KSOYpRybJqW8WyfiB5ZVUgr2bgNk2SC0Zr9vORiuWCrFC5OyPqBstpis5i1GdA1NDRM5nOEjvDe31cGAbi6JhuV/Pbpp/nk3d/mgflN/tIb/jwSwTuvvYs723v8xvO/xd61knl1SDrO7mduA0gk/kXIXdCcDQ5dZBz5mHhbUUrFNsvo+p7EDAgdY5VgfBm9KOQuPrH2HlJFxu7jU1rStwbnJOBwg0GmiihRdJUhuMBUay7iQNU5XN/RekkSS6S2NJuKKNlFn/khwTiH6RwyZLTtmqQokFphe4lXNaLpCdmEIIBMsrEbnHdMRE6SpZjtmqi3dE5hNwLTrxFGEFYVNQMqKVG+ZPjyFxHbCnnjBq7p8FlJ3S9RKFKrMaslCQmrzNPcWyN0jtg/IP/ud+D+53/D8PnnkD/4FnrRUKuIaPk0poYHHnsQpSZs1yvSLCNOFOcnZ+RdjND7BOuAkmx5DlVF87a30BIxMh3zQmK6LSsfKIopxeV9fOMMjR1wHrJyjttuaTcNshRc04rue38A+cXbqM9+nuU7v4e2mHFQBJAp2kf4wSNUgjANRDn2l3+ZKI6pvut7OczGGHeGkRln9Ra29xAqZvzEKdee/Deoj/4G8itPoMdjxg8/QvHwdeSjD1G96jW8cDij0BPyx19N/Nufp//U72C+941Mp48ghlt0I8Ww2CAmkOUlUR7ovGTTW/o6I//8F0h+7VeR//LnEd3vHQMEUD/+ON2DN4i7Dt13hM0G0TTowaC6DtG2iKb9fZ/n/9cl2g7x9LMkTz/7ign6f+yWQT/xJNMnnmT6k/8If3iA+YHvZXjvd3H83vdT5ockr71Kf3hA/8u/BV/+Kvz9f0T0Z36McHVOOh6hbES/HsjKgoPRPsebu2y7hlEKYbEgsmMuOpjcnDB/4AiTp5j1mqEd6CpHogcINd40uFihsoDQE87VQNNsyX1DHnUkowh8QT7T9EgcS6KsJxE5ws9xnaPrWqq1ISkzWusIYYnoY7rzmLicY1yHXTa4ukVkKfpwQhg2BJMRp5qwqgkOZJSx7RaMVERRTvAvXlJ1jOsq8jTD9x2kGV6AMQuiaMZ8MmZYrNjWDVGcQ2eResD7DujpbUdAUhRT9DBCOIEcRVycbDm9twW3RmlDnJWo8gARaga7IbKK0DSItECNUx6KI0bRiKbvaVZragtj15HKmI2FQWti1RGyAl9XiCRCyuqlBts0EDxeJ/j6Ht35bZaLNUZLdJLgmzXVvWdxwZCWBSHyuN7StRd43TBNZ4Qswfgtrhd01YZSeDrb4H2gKCO2bWCwEdEwkClJ4zy5ANP3REmCvBzqmcHStx1pNiZKdn83DAPdZkM5361Zndv1Fc5adPytgW2wk4d75yAb0Gr6CsvTH4f6kwb7O6i8s5i+A0q8f2nC8PLKLhvs2nlGWmH9ZSaoisDWiEt4jUwS/GWD/XKZeKITtsMWYyzRJRXWe0+9regWFUf7BbrIcNsKLRzOBQ73Zzx/9w4nyyXX9vcuJ9i7RcFq1VCbLUpZTrtT8ijjofEDVELRCbsDgXQdph/o4o4ojphnJVXdsWyW/PCNd9P1lt9ZPMkHn/sl/vp3/yUIge1mS5omZOMxbDc0vqdpWnISmr4lz7KXwdpaIiFp23vo/pS90Yx0/CjbexXlKEdOCs7Pjrm7OkcasJMOuTgm1JBffQyVW8peciWf4i9WOGMZXT+8D3MAyHRGo2oG05NO59TrNd1yAXnBhVnQhI43jF7PIDpGYobrBkwiEVqRKce66bk2SrlXnzOJrpCkJd4rtttbiEwgQsLJ8pQrOuXNB49xK5xx3l4w0Yq+tRBKBrEhSMH5YotqW0ZpQTEr6NqE292a/+Fr/zd+6qv/GPstKNKRjPi73/13+Vtv+K+YRgXVe/7P3HriN/nw8lN88OQ3+Ny9z33b49J4y8de+Agfe+Ej/Dcf/295x9V38PjkcQa7ZDk0rG3Htl+x6des+jVbsyW8LMbrD1KfuPeJP9Tj/zCVq5y3zt/C+w7exnc/9EO87uhNPDyd49qWlQcjYDw7IpIKu1oxP7hGl4/oU41VmjxXzIcSkT/Cve1zPLe54IDAA9kekdcEMWMoS+x0xPV5Rnt+m2N1m2L/QW4+lFMdn2AutpAluKMb2LMzcgT5wQMQJSzcOVkWk9sxqVfo1FDJmlNX4kREZnqU8fT9krEe2E5uoNaBvt9SqLBTr/Rb3vHA27EEfunp3+R//PxP8xcefg8TL5DFVY5FRKYEh7MpX11dcL2PKeOM0bRAxymGgsEc05x+mTQbIb1ke75GCcHn734YqS3vyg4w0UO8Y36Dv/Gqv8L0xiH36qf59Sd/jd+683E+dfF5Nub3l5T/YauxDf/gq/8v/t9f+yl+4uaP8V+/8W9wvXiAtVQcPHCFi+PnWKyXpOOS0bRAjq+zXN5l6LaIvscWE0wcQ9WTN2va5AAVJJEP2GqLSyf4JEU2DVEGUVzStT2NaSjdTvHiVYxRw27iKFJkrnHrNVGn2aiGPB7TOc+1PUF1XrDoFXJimOmUoe9pFneJohjvO1SkGU1nVFWFc+5+g+2HgTAYvtTd5he/9suMkzF/9fV/kQdGU9phQdsH/lev+gH+2Rf+Fb/8wr/jMDtC1BF7k51bNbiAUhoTDL1zLDuDkJqCnkRlkEpGvWfVdlQSir7HS41QkuSSGB6ExPaWTkAZKYINIEDIQF/3+OAhCKwZiNIUpSVC7mSBaRExjjUr41hvO0SaoSUgGobOUEwzrHFonZKPY5zxiL5g6Cra1RYX5XRNwFQXzMoxusipaXcpC8AsnRGqBUM9UJ08RzKdYssxTVWhGkealwybe/SjOfPpDCEl7tnnCbEmfvU+QyaptcFZKLxiuzgFH+hTRVQ7ribXGLSjqTeYmSQtMvzTx2z+0x/CuxPOe4e9d0IqD+gSwZ3tGmMctrmHMx2LtefIe0ZXLbqOiCd7yI/9KoPpiN/5XiaMiKWjyxXZ9hihj6hlQjdYzgaLRjCRA9EgaTPNyjlUrchWW7Kr1+niEeIHfwh+/gNUH/xl4r/4E8TKE8+mSB3hB4dwMcI2mE9/BHd8D7777aTXjnBOUkhNdvuM7Gc+yPRjn2TyuS8RLS5eca5pIPn0p+9/PQNuAPbqVexD11HzCUPd0f+DjNX7fwB9EJM9OMdr6JYV5UQjixnyM88x+of/D8b/5iOoe/d+33PcXLnC+Y/+KE+/+330r3s1h7MpV8spPghWqwWt33L44MNoBFHX0+uOMPRUP/PL5F/8HOmf/jGqozHNvbsc1ILU7tInTqu7HOUHjNMRtu9ZnCxwbcfhOKVZVwzDQOwd203FVAV01TBszgi2J+oD4vSc+OQE8QeQu/7/o+TpGckHfoHrH/gFruY51fe9D/nD70e//73wl/4K5qtfRv3738L95E8zfM/bGf/A+4hHE0xrd0AqUTIajenOW9q2ZYJjGrV0MqYyiqYzZJOSMFiCaQhS42dHdKYjVHeIpodIkXPaBc77wAjNDEuaNHRVQpLHRKWmPl8RZRPWbJhl18ji3fzfREvWz5/St2AzxX6icXrJtisYVyWiqvFDg5qWiFhjKWgWz5BJSXx0FWUsUmhssPjWoOaSPM6oTb1bP+uUxm3YzzV1H1jVnoPpAcZtd0221hArkqFhFXk2TcuhlCRZRhzPULpBNhek2YxQlATnCNWWs75FRp5HHz5CJgod7+E9nHQFk8EQP/cccXZIP53ShY6xyHBBkkiFSnO2MuPupsG5CpVmmCCRkSCKJGnQhMHjnUVE9Q662Z7i8QyrJd1ySdtI1OQqGEinOcgpsd1i1gbbBpJyQlwmTFTE0J9CP6Bm10FqGjMQho64SBm6GqkCEZIQx5ghxrZLMudoEGyaFh0Ccbpr9J3zdHWL1JDkL8WE9asVrm4YkoQoLRia3Qrw92uwQ+fwokVEGkkM3Xqn6Pm9pt5/hOpPGuzvoIouc2Vt74jSsIuZEq/0YUghyJWkvZxiG7+TYGsvsD7gxQ5IoJOE8C1k4kVUsPVbOtOTZrsD3xjD4oULtNJMHpjRbBe4odtxCs2AyFP2yozFesW6GDPNYwKBtm/Ztj2qhDhIjttTHi6vI5MM6z2pVKz0romPG0uf95ShJFKSscjZ1iuabOCHH/1xls9IvrL8Cr/w1Q/ynz74pxis43A+QWlNVo7om4HtdktLhfYphXiRZGhozJbWSYr2HBNl6OIa1VYRnKEPgvZii3UeREdbX1AZxRFj4ukYPZ1y3LdIsUHYnnqxJJmUu2kmu82Har0ieE+cxbR9Sy7+P+z9d7Qu2XneB/52qFz1pZNv7BzQQAONBhq5kUgQIMEISkwSackSpRlRtteM5ZFGHnlJXh6P7KHWGs9oZIlDz5AiqcBMkSCRidzobnQCOt+++Z574hcrV+29548DUaIAUJQsjzlcfP4+X511zrd3Vb37fd7fkxGMRpSzGQjB1eIGQkt2gi085TEZT6irklXT0QYha6FDGJ++kyyrJS+5lPXQo50X7Lfgo5GLKRO/Z9n3TLJ7eP74kI+/+DnetPYgWmf0fkWLpakb6mbFLVqSpD5C+PzS5d/iv/j83+Cg/MYAr/eefzf/w7v+b+xMbuXatVfQdk4bJpwZ383//tyb+Gun/i5P7b3Exy79Jr/94q/w+N6j37RAdjgeu/kYj938xh3yPwqSQvLQ9ht4z9ZbeNvmW4jNOTRztm89S2l8hqua4uAysyTBpTHS8+iqDtGuEL5HPBrR7WuioqfLNEUzx4UKf1WjSDm3k1C3PXO3IooiMinwnYc5OOQghyqCbH2bsq+4WUDmPERTEqYZOslYCkU920dUC9JwC92Ba2I8odBacqRDDqolgSy4Jd1EaMd0eQ0lWjpvi75YMByephMNzewG4XATCXR+zMN3vJemy/n1y5/mHz/zYX7inh8gHoyYly2NciiRIut9ilXF+vYZlIZgGMBC0LcendB4owHT5ZylNkQ25+nZFbbX7mE0uZ96XmOHCa0O6MuGezdezesm9/Cj1z+A1iFXuimPHj3JzBSsMKy6krZbcVTMkbahNTWLrqVzDUVTUFULStvQuI7a1L93YPiN1NqWX7j4q/zTS7/O957/ID96+s8yOrVOHA1YHO+fRLOR4SsfLx3Qtj3dYkmxd5lotEPf5JTeASq5nchJ3PGKvu+xmcV2Du0n+BqEkMReTNksUUWHF3asAg/P89mwirbraWMf6fmIRYGbBEzrinEQI2MLcYoufdJtzWIxI3ctxhRsyTWOpaQSEiklSin6vsf/2guILQou5tf42Zf+OYH0+Mv3/3lOTU5RlnO0dqTRBrIVvPf8G/nN5z/GF/cf5d1ZilWWUTxCGYnSPqVpWdUNdVuz5ieIZkrTl0RZTOA5wkqQzxaMgoDOCwm1RBhwnQUHeWeQsSZRkqbpTyIC24627vEzQ1/1NIUlTFKElCfZrI3BWUesJDNpKJxh3EsaZxHNEoTGCwP6DqCCXqH9AO1HKD+lWLU0eUuf5yxmDek4xvqSaXFMGiVsZBu41lDmHW2+oLEW1XrEccJxuyBoWiZByL7vIeMRYeidZFxfuADnbqVrlixvHFJ6O0RiwKHrsFJhspBC1fjHDTgfXffIckm7eQv5Qw9gP/cY+VOPkTxwD0HtYZzP2hgisaJclsxWLdK1aJXhwhGlW6LbisBLaXG0zz2HPbeBHp9l2LZoryUMoMk7ZFswVDBtG6TpmZgWR01vfTwV4cdjIjPFa2vmtUIEBnH+DPm9r8U99TjumS+Tv/5+aqVBOJwnEE4ij1bIf/HbtH5EOxyw9S9+A/HJT7Dz5cfxZ/N/r3uqvnkTffMmAB6QfPrz8Lf/K5zv0587w/COO2m3ztIMUuSnP0X4zNP/1s6tiSIOv/VbOf7u74R3vwtrIkZWc2rsU9ct9aKgW+YEoaIrOsgPaYkpjo8JtyLkxg7m+74LuXeN6uWL3HzL+xlsbqMmp1Fb28S2p7j2ONd6ODu4lSoZMr1xTNhb2lMD8mVBZaFtS47mFVujjKhdgpNYs8dAaQ7sOlkQ0c6OWD37IpuHh6wdX4PdPapLV/Bu7P4HKcDtcEivNHZ7g+auW/F3bqXbOUt4dhvPGdxHP4H46EcQ0+k3vYYsSwYf+TB85MM4IUgefCP1+95P+653UT/6GPITn6PyNfLd70d7AVJBnQtsqVHWx/kdhQzImgXjLMAGHgfHFdvjCBcHVE2NGI0oakPQ1iSpRkQBNw8XzMOMxCm2x0PCdkGTr5BymyD16G2HA2rp8PwJpWkJnaVrO5SviNc36IsGaxr6uiEIPEgiFt2K4KgiHg3xz03opnsnh1+yw+7t0ssQrQRKORoHw2hI19fE0QDXnTg7pfBokQzp8CPN8cwwNBLfG5+M3dkFpSiImoJBMGbmxcy6kNNZinQO+gOcE9hgDWVrGAxY7B8xPVxwZiNFhylSlnjS0AhNoCVp3+GHinCcsEwMQ5WS+RnGOmxVYSOfQTKh6S0H8wXzRU4TxHSpT1XWJKGP38+RjUEdTtGDFFMu6KzCVWD7dbLNEVbA/tVdtE2QWQI5iKajLBf0bcPkzA5xoJhdO6ASFbE/QEhF25QkaoAOx7hOEmYeRXOE1CWdF9IuDUnT4AU+i6pgJ8sQUmKtoyl6EB1hFCC/Blvu25a+LE/clqsVYZbRCrBWYfpvvi9cb7Fdj9UtgTdGdAV0NQSDb/qZ/3/TnxTYf4RkrMNIH9tZjOdQ6gSD/28q/pp9ozSW/vfmr1u6rqVtfUTZnkQN1B1iVSLjGN0pqqYgDkNUKynLglGUYK0j3z+mOCoYTxKUgCqfIaSkaQ2BF2L7gHQ4pj7YY7Fc4UyExmCFwwKxduwfHdDZnjvSczSeT1uVrAmH8zSLIMRVFb41NKbBNx5BZaiUhxp4HB0WfO/tH+Tj+x/mS1cfo15WvPeO76CrWmariuF4wGB9wuHiAq40nIu3sWWLCVuWzRFFVzE0Gs+D/XCdWR3hNQaUpW0bgjhB1WMSL8SaI/rpMcvh7Qw9EK6icR6Bp2iP9jCmZ7yxhrWWtm3p2pbF8QJnHdladkInbyui4YjVdIYtCi7NL+NwbGVbZNpHaaj9gOVyRWA6stAxmUxYVBVNH9Bi2O8aWM3JZEssN4k2A7SXc+XoGv5wB+/I57mbz/Des+8iTFPm7ZREJcy6kt7kpJ7m+eoaf/Xjf4XfvfaZb7ietuMt/us3/3X+1G0/SFPXvHT9Zeq2Pcl9Xub0UYwoc+R0wSQ5y19+6D/jJ970n3DxxU/wW9c/zedvfJ7PHTxOa//tc7f/a+tcdob33/Iw33bLe3j3Xd9J1mpsVTFvDC8c72KqGicVqTfELA85rGqUlWyMUjocy6M548kAP0pxncOUgna2IvFHeHpE4XKOZYefjjgzVrSl49q0h9BnVuWshxGTgc8iXzJJM7y1lKtXL3NlryN2hpEX4cmAURQxGQ4pkpDZ/jXmsz1MKOisIHGGfWUpe8l6OGZN5mg66m6BK5fEk03mjUO1HZOtc+RNT5tfQx5dxBts0jkLXsSbTr+ag+VNHr35Mj9/9WN8aHweX8e0StK1LTtGMg8dKwEjLGjwdYdFULoBxcrRkaGGGS9de5KuK7lrfCt1kpL0YAfbSKXIpCbvTmisKzFiYxTx5q2HeLB5H3XbM+sMmQehXrFb9Kiu57btHXZnK6arGUG+ZBRZtN9RtxO64TZ1tUtZ18zaOT/17E/xiy//0tfleltn+eXLv8EvX/4NHn75Yf7GQ3+dW0fbHB8dsLYxJox9Ih2x6BcsAktSSbLao25SVsGScTjHehmSnk5H1Isl2qXoYQa2AdOdfP74JkXdQlXQr42YJOu0Nse4nqLTjAYZ/dEhNg4xcUMmJNcbyNYG6HmLKgJMUZLXS9Jhim5L1pTkoGspWoPWmrY9cSq5ruPq0SV+6uV/jhCCH3nVD3JqdIYoiui6Y7pOkMqY4ybi/rXX80TyFI8fPMJrN+9D+hqDwW81oZew7AWyqpG9IfJ92vmCVguSZAvP5KRexqxtWRweIsKENE0QHrjW0veGRgqG/smrgektni8pVzVCWaLUo0ZSLRfE3Qg/iPB8RVcb+s7iBSez2mHs4RpJ3RbQ5vh+hnUGaz2WrqQrDaPhCWpKuoCQBuVL8rDADVIWXYUtNJ4NIFcsuxLZ9PRFDaLGbWzS1xI9bbBK0DczmiqhFgnZYk5b1vRPPo2dLTCvfYBF0zNVhjDO6IMM3/dRrqc43ieoG7K+JxzEqNZi2yFpeJruNZb805/B+9KXObjjPur5kraJcN6IfNVwcFTRigDX+myGmtvOr2H2S5KyRCQTuq9+hcL25Le/GlH2TKKIrm+hnTNYO89quWQ5v0mrHE15ROFAyiGDwQirfI6bHOs5rB6wv6pwRYESPv3b3sXohWfQH/84+qE3k2hN2eUE0iO48gr8vb+H+txn0YfHqP/27/wvet8VbYt34SJcuMg371P9KzkpWb7tjRx+17uo3vM9eMGQ87ecReqAw6OKQeozHobMVwX7q4Z0tEYySulnIVU1xRcWU1fYRUtDjGc6xOsfoPvSY4jf+QzpO96Hv75+ArVzgkmywcFsj2v715hwTHA4RyUDqpkh8gOcUKykIlifUDiL3twgiyb0RUakOsalorQN87WU6K1vZBkGjMYR5XSfK4uGyWiLOozIDg7g5YtkVy7hXbyI3L+B2L0OR8eI8QSxvQOnTiFOn8ZkGf3aBsfZmP20Jzx7lslHf5fipReo/vyHGN9+H6nepFg22NRnGPu4D/0ZhC84+p2PUP/SP2Hjc58juHLtm38vzuE9/ije448C0Jw/T7OxRX/pItO8RLzlfQircYFCCjDKEjpFZTJm9YrRcI6Jcmgyrh1NiXSPcIaiqRnIiLa4Tri5zTQ4TT49IsaRJhPG45TyynW6qiY7NQRP0OU1MtQ0tmXir5F3Ocf5MYELsE5hnWXND7FdihUF0jforqWbGaqwpZ/4ZOUxwgdRWrzJGu2VG3SXruKd3SGKJJUJ8DxDW69IEvd78bRWKqT2CW1LGGqWQcjRPGdronGuBxqcrHD+BqlNCAZDDpYth1XHml2BEHjxhK5zKAVCC242J13scCOm6xxBoOj7klUfoo720LZDn7uHqp/j8inZ+h0oKVBSgLQQRxB6JNZhbIpd1vRNQ7ye4JUFXWMwoqL3POwSmB7hBZLAixFeQpD5yCggPzo6iUzsPZq+oSosG5lm6/SQvDIs9m4ShwGhiijalnJ1gJdtYZqWRCuMVUgNlSmpnEFIS69bnNK0qxxfplgnMNrHOfd7cVx+aH9fXVIvFigpCcZjyqNjbNPgBZquBtP139CJCycFtukrZKZQIoD2CIIM/hjZxP+kwP4jpKozVE6CkNi2x+gG/W/EdQEoIQiloLQWTEvsxdSrgsYYaAXWKTxhqJsOc7wg0iGB9ajaklY26F7T9wW9aaFxzK8fIJXPcBzQ1CswEIQRTVnR50tkmIGIiKOA2fKYYzNmfRDhxTFtnqM6yeXVNaSQ3DG+hUYqdN+DlsQSbBSxKiv6oiEwJaqNCHyQoUCbEZYlyIYffs3381OP/DRf3HuCMB3xrvW34JyjWrW0siEYxthlS9k0hKInX+3TUTAUAWE7wwYDAn/I4RSGXo+iJ+qWTPyAcmOLw6NryPmCNNCE8YiVyWG+pAvWyHRAPr1BMNim7XtM0yClxHUGT/pYLahmNb1tWTlBsL6J8n2ktbx88DKTcEgSxQyCCXlZUvlj/CjGVUcoFTERHnk/o/fHSARRfkxfzEjSiFGyyWR7iF3tM53u0vcrbku3eXF1ERM0eF5IhGTsp8xn++TFIX/r2q/wf3/xn39d8QHgK58/d+8P8+Ov/lHuPPsA02s3OShXXMoPeXz2RRIp+Y/XvwWxsQX1Cjc9ZjAeMYklyIr7T51lO/0QP3brj6Dqnk93T/E71z/Ob738m6za/N9pTSuhGPgZAy9mGE4YRmOG0ZCj1ZSiyXnt+quIlI/vx/hKI4ylND3dcoanJcFwA6MDaGsCLGE2oWxqFB5J4LOhxtw7fIAsDrn7/GsZmBzXNvStxTqYtiVSOtwgpTrIsX2DGIxJX32eiTG4VY5G0PoJi1Yx8QzOgUoj+nlDbQrS4RraT2lMh64qiqIiiUIynWCcYJB5DDyBSyxK+yTWQzYzkvkhjYyRp7YwwZAujjguKiIhCZMhmxst8+OrrOqIOoKbWLTvcz70GGhN1/U0zQ1s3uB7Cb6fMV0cMUxSkjii7CsaI6GY0/kD2t7gO8eyq/jWtQfJolN88voX+X898TP88Jv+EttBQDldMJcJyZqgKkuE7+O3FYGoCMIBeVlRzXva9QnWOi7Op2idcH54BmQFUc1awtfsvYZhZChXczoZM+stia1I44SldoStIOiX9LUjbSQHpeNgvsTVU2bzGaeUZHzqTozsCKY57f4RjeiId86woe7iv0/v4T994D/j//C5v87nb3wWw9dDkT5z8Bk+85uf4e07b+YHT/8Qw/GEc7eeIlQhuciRSIYbZ3DzBpsbxNYWqXJUxxdw6Vms55PPjtgKJygRY8saQYHxU7wWOh9MXRNV4Gc+1vPx25a6txQqoKoMwbxDeYrDvSOWJmYzDehmPeXBlE44dOUR6AC15hO3DceLY46Ga5xJA5qmoe1abu6+yE+/+ItYLfmPXvsjbOkJnu9h7UlHx/cTQJPVCcuu4Lvv/BD/4LF/wK9f+A3+o/iH6B2sypaFmuEjiTtL6wcE3RxZNZTJAP3yS3ihRzZMmK2ts7p5jfDokCBLEEpiu45Vb1CpR6wkpj/paFvr6JuWMFUnlvNsQrnKKVdH+MFZhBQoT9K3hl5A1XWcTiNWTnFYLDlle8LMx/bQCYeUkrprqesCnwDR6JNrZC266JGxz8JWnEq2iGXK/GjFfLkixqKqOW2mUOk6StfU+weIfkVrjjkqBjgd0tOzHGnMhQsQh5g33U/ONbLwNEnvsJ6hqJZc2DskLis2K0s7TumExSYpvQCzt0tjC8Kzt5BeOuTg8pzer1CqAr2GKTtcX7A1nlA2PivXklmHkRpdrkjGkvypL+PWx/Tn7kN3DVEa0TpYdD1FHBBFE+bzPa6YGjs/Ig5vxfM3qQPN8f6MRhlIhpQGdGdxdYMMNZO1Ee6B+0l+9ZdJ/q8/CZFm+NWv4n/ui8ij46+/Cf9b1O3sUL7lzbh3vwNRrFDPv0x8bRdx4QLi6tV/5+t9I7WTCdPv/g6qn/gL+GfHrPkh2m7SlS2m7chbia8kWezRNTWqrYijgNZ4REIRjkfMpzPSU0O84ZB6uUcfRMRdSf+611I//gjjLzxBf9v9dF54EveTpvitpTECnfp4OqJa1FgpwI8YnNqiPF4hsThPYRcF0h/ReJLEH2BchcqGVLZGLhckzlHbhmLVsZztntyTRwFzA9t3nMXcco5i+UbGaQihR7H7LLn1SAY7JDr4PcaBtY7FjRmtUGyfDqmPdulevMDizBA7DBjHJ5Z/vzFUeYtTJ9GjtZS0D7+X43Mjrv5vf4jbK4+1T34cPvFp1GNP/IHQuODKFYIrJ8wV99GP0t56G/3D70W87z3ot72RvaClWtT0bQyyoekV+cFFCEZ0jU9DT1ceU3U98SRitZzTTO7CpAFeuIayJRO5gl7S9w3K+HiBR9tUCCnplUPWgn5VIqVgns+xaoC1IYmn8H3wraJqIzwNbrVE9OBnIbUosE4wlGtQ9vhO0AYR+dEua/WI8fYO7bSlNR5SLqnrJb5/wh0yLiDyI0S7gK5ibTDg6mxKuPIZDcYM/TWq9hKdqQn6llA41nzNcjXnUNR00YgBiq5piALFajFj0UvWhjGq66jyHN+PKeoVzWLFuClgfQsZZRSLkgEOVS8hnpyAykwL3gkpu2x7TF+T+C1HxYJ6kRJnMXGr8HVC31Q0noXFMU7eSuMPKejBWlRZY/oeFUSYGgLPpwlaqsoQL2tG43XyoqQ8vomSHraGYraLHwyRbYPv+7TGIQJL2ZcIofC8iKYuEAE0swUy0ERRROlAlD3WOsJE0RuDlF9zXXUd7SpHDAfMvACtJM1ySbS+gdSarm2xpkfpfzO1G0zdYURF4A8RbYFx0FpFYC3yTyzif6L/0Iq6BpZLunGG17eYrsHqDim/fnEmSrFqaowxhFj6PMeLEope4EJJPIhQoaA5OkK4mmiQ4jU1vXL4MsaXNX3oMIcrql4wODUmGluqviEeb6M9gTOOdm9FEKxogwgrNLpf4mtJ6zR5W6CkRbWay8V1AhRnxueZ9x2xFEilMNaQRCFWSxbTGoaS0PeRiSUwHvMVDMcTon7FbH7ID977If7RV36ZT1/4NN204t13vBOrepblikiliBjK6pjFYkksIgZZSGA6rAIZrWGWBtf7NHbFYH6AwKDykiwLWdRzpjIkSAPSvqMLIm7Olyy7JaL9WsRHeHLaFkURUipms5IwjfESn7ZsqOeW5cEC5zShH7FoDlhWC25Pz5BFQ2SYMp/mtKJiLYlpjEYuew69JdAzVCF5XaKWM1RgqfUEkQToQLLaM1hvRKhqHtza5oXVRT575Unee8dDBOrkAf1rz/0iP/nU3+OomX/DNfS+W76F/+aNfxtMg++FHB/v0UnNS2LJZ3Y/SqgFR67nxeoSb4juZhWtYQ5mpFpSFvs42+Fbj3HimKoBzWLB951+Hz/60J+j7kt+7aVf55Ov/C7L/ICdyTkGzieUMYFcZ0MlDLbPMhhsYOuQunaM3TFn1ieMcRQEWBeQ0/D3n/gpzqY7fP8d341nOjI/IgxG9LNDFu2MvUVLNd1n+763ko1jVF0S01BpwWHeszXepK1rXAPCzTiwLQeNRUYDosU1qBpWzmNWlvSmZj30aXNHF/gka2M2xilCCEyWgHVMpGRad+QKAiOAHis6hLEE2YAFgnUhiKOE2eyAWTUl8H3yvseFISIY0vc5YWxZ5UswU8xyySSQpIN1bN8zGA5wdUUXRdTWIcIxJj4irlY4UxOkGeuBxnOOrm1om5JqcR1XxDh/g/LmLoWs8MOAcj5H1hVl0yFlhpkdUKcZN/N9AisYD87wbTt3cq3peObmI3z0hX/Gj93zpwnqlvWdDQ5cSV+uaGXAbH7AVpYgXUhvDlk2lvKaZRRKXlq+zPrGnQwHt2KKGeOBJrE5dRKRz1f4eYxQsBGFlMIwr5eU1scJwSjokL5DMcLrrnO9XnB9d87OYIhmCApEmKFcjY06hJ2i+5pJkFAKSaM87lu/m59/99/nb33m/8yzy6d5Nr9E0Zdft+4/d/MRPnfzEf7+S/8jf/Ph/5Ifev0PMg7HVG6B0gG1bHGDAZko0DmIvqXySnqjMLYjXotRQYgjpM8LGitILORBjC81QW2pZzUYcMsGlGC/qHAuZlC22EJwOS9IB2vEccAsXdAdTWlDi68zRK2J9DouWZKtrrHc36eKztC7nuOjPX7h2V+mEoYfuO9Pc/vkVor5At/z6U2OEArhxWghOLO2zqWZZSsb8t7b38MXrj/OI/tP8d6zb8Fp/8RuXq+4eLxPlsaYusGzKc3xEfVsRhJKRv4a6XCTg2xAuFpg5nO8yYS6MTTCsvY1MrnpLdZaXANKgw4EAo0X+ETxhDo/oh+t0DpD+5I678j7Hq0ssYjwYzgqSxaNIBwKOisxomcUppRNy/JoxiTbQIY+SviUq12MhtD3KEpJvbCEmWO0ntGZhurKDYwtqbpNupcuEGsfb3GAcpblZMLKc2yN1ylFSxoGeHu7qDvvoIlr4s5DyIx5cUQ3X7AQCVXeMvBTsomPvxYRDEOIRrhuTjVb0ooJk/d8C6v/z69w9oVXqN75FkRQYaOWa9OaSTxgI1ME2yOuT0v29vZJ4xBTFTTPPU07O8Z727vw14aEdUXaNXiBIElOMbcdQZLSH2ts0WGMxvM2SOMAQUvQF5wLEjYOb2Kefgr9wkX8C1cJd6+hX3kFvf9vn2v+Zmq2tmkffhfmve+he/ObCE6dohceC2ZsZGvIxlJbRyBjVqt9Zi99GfPEZ9m4UeJdOcR/5QLywgVkUfyBv6fbWGP/PW/BsxH9HXfg/diPspk4lEyxnIy3ReOM/ekc6QyTNAVnaYoCzwvYHGtuzBuO5znrE4HnD3HCEiYhy4Wgayo2woAbR0c0b3od6x//MvbJp+nuuINAKYzn0wx2iGJJ5ilWncZtjtFWotseO53iygajFKKv0ToA6VNYx1qaYlcV6IplKTgz3EQ3HeVin7nTVMMdlB9ivYiRNOB6/K4hXxwhwhGubXGhwascjbCkaxNUbzBNSzPLqaYzvEAydGfh84/Tdw31Gx/GCM2q3EMnZwgzn7LpqasOP/KY1w0NK7IswHMp9Sil+d/8p7j/3X9Bceklss9+jvATn0F86tOI8uvvkf9SAgguXSS4dBF+5qeIhGBw/70UD7yB2V1vRL39NYTjTRazy1TGMPFD8qYi0A1ttWDv0EBv6NoZYS5pGgjiEOsMs6sX6ao5vl6nWM7oFbjgpEst6p6izHG9JYwCpm3FJItZG8bM5yv8pqTve6aHJaNYE45H+OunSK1lWS85rndRX/o8gy88jhgOCW7fgNEAb/M0oa+oq45RFNE0OZG/yawv0dqwFoRQT3FdhZd6RKEib3wmMkZKSRRt0pa7GLtCrDRhmCDakmmWsUQzlgLjLHnbM81LlEwYjDMCJOVqRaEVy3JJ4gx6sI6LxlQ2R6uQKBqBXUE1A/01YJkOsLajqI4wdU0ch2S+zyw3RMkA1+c0rWWgDLGdI7IBfTxk2bQIJfDihL5vmRmDsz6NJ1mb+MQ6It87Zlk0DMMFaTCgVAGt9VBdSX7tkLa7wKY/ofdjHJbS5Wg82rpD+x6V9LH+imbe4JUZw9GEw6JFGsEg80GcuBn/ZYHdzOdYKWjCiLY5cYt2ZUlkevwooM5z+q77ugLb9RbTlAgl0Do8gaqqkK7rCMM/PiTxPymw/whJKkkkHa1TeCqkrab4QfMNC2wtBQrDcdUw9AJ8remEDwK0rygaw2QwQJYlbV1TCHHSOaAmMh6RH1Lkc7qDFV0QsjkIaPs9BCFBNADR4086bNlTTA+xwRCdhCRpjDYVjUvYz3M2hKA3PdfzXc7F2zg/xnQtUila7SGrEmMFsQix1YrZ2BHZhpHqUV1AL8APJIkJ2V8usL7kQ7f+KX7hmZ/hIzc+Q6k83nP7axmPB6QMODyYs+p7qFuyskc6i019tDdkuWrppx0BPYgKtCNc20R5Ed3N64zrguXaDitXse6tUPE2HBj6xR7z2jLaGJNkPlEUghPk8xKwJKMEhMAYw3hnnfLSZebTQ3Ymp3hh7xJd13HW38L3QpYSSuEzbGuUJwkIicOAm+0Cv8/ZEh7LTlDLkJA5UZBQeoLZ0ZK+afAyyTA7w4Z/luGVL/DktUe4c3ILXzl4jH/45X/IF3e/+A3Xzun0NH/3zf9Hvv+BH+XKxed4pZhxLvERfsZnbjzCF29+nlPpkB948Af5+cf+MZ9bPMv95ZtpslOgJImqcHGMcDH1/AamqYn0hKWzTGdL4vGQaDDgu+/+Ht569mHIc7ZG52gXR6zKmshLSMMEGcWUSnDt+JhdUWHMmKLvSNJNBpFPscr5nec+imka3nf3O9FKUgmBDDsablKII/rOI0tO4S1quHwDrc4Cln4woZhdJe0NUXSW2WyJNoqiL/HTCa41TKVgZH10O2XveMZSRUwiyUSPuTrKWMsSIteeQJr8ABWe7C3FSXbn4XHJMl/iu5Lh+gYCwco6nBAMPYUSmo3hDseLlpwFvfWwteDAHND1Hdv+Fk4f01cQbMbYlUUe3sRf26KOYkZ9h9c1uCSlsZZVOqJxYNsVrpW0ywojBMaUmG6KbBWNODnVbYUlGY3Q8ZAgigllixNrBIMNvOV1uu6Yslwx9s/QrZ9i72iX997yXia64fH95/nZ+c/yI6/6EMNxBivJNZ1jXE5V5szSMVG1pEVQDyLErOPlmxeomhVvG7yVlZHcMhiyaeZ0bYTWQ5qhZnlznyhT6HBAUAqysaVzDaHUCJvjUNT5ddr6kI31dRZijA4jksUBnRLM9+ZEfojpDP3EEBQB/c0ZZhTjtMAvazazDT543weJLnn81Y0/x1dWl/mp53+O2Tc4ZHp++Tx/5jd/hP/6C3+Hv/aW/5x3Dd6K6wVFU+NvnyJyM7q9y8TD05S0tOUCLXycMCcE7TimL3KU1+Jpj6gZ4ZqSJl9SVCFB4tEZ6N2JjXB9Y4JfTFl1OV3kszbWeF5H5M1pbE883ERsjrHzgnpRo7fWCIZTzPyI67s9KhL8+jO/zHGf822v+gBvOvsG5sUMLTycAGsapIyZdoZQClKlCGTAzaLgvvXX8cLhdb6w+xyxdztnBttsRopCKZRo8JTCE5LNNIA+5lA5mtWM7upV9N0DumSA7Tva5RIhNaVxeIEm/Fqmad8Z+taiPIfyBEI4qATW9cSDAXWeUxVz4tRDeyFV31D3LVEikEYRqJpUd5S1T1mfHEQFAkIClFNMbUWlO7IgoK1aDhf7xMmtbMsRF2fHTKlYXxsSxB4qd6yWxzhl6HtLJyy7omd9e4CHj40TnM2ZBBJPeuiXX8SYnvyuHRbLa5g+QOqW0J8QeQ1Hy5YkibF+jO81xAqslJj+CCegchrPaMy5s5STIeqpJ+jueS2bt2Xs7h5yNDcMtodM2ykbEZzLJrw06zhofELrM3jkowgkvO4hwo2M6GpDMz3AO7dGlqzT1VN6UyEE3HGwS3v5BoPPPc947zLts1/l7gsX8a9dRfTfnEnwh1V/apv89a9Bvvm9LO56A9c2d1i/8zRn12OO5zM24hBtQFc+fWsRRlEfLGhiy0IZxG13MhuFyGwHUQiC1jIeBPR//6eReYF6zX2457+KuvIi9mhKeWpC+X3fhfjg99L8xq/iP36R4N3fQTwZ4/oVsvNoZgs6N6UbnsH3Q7ymwfQNbSMojSH0PIQAS8u0KEnXJuh0RD47xAUruqKiW+1SBgHz8pjsgQfRRwZ55Ro2L+jOnGFVlIRRxEYYYa1hWRTIrmW8dQte4GOaHJYL5lhOD1PUIKPvDI2UKB2iR+tMi0P6vsXXm4QYehy7piGPhpwLNWPfo9VDamsZiQYRO6oowRcLunBM0C/oZpdYBYrB8BRtDb0f4J/ZJsSg8wr7xBPUk5St7dsxdki+XNF1F8jS0xRSscobItmT90vWIo90tMWsP6StVswTQVKFBOfPUk8epvneH0ASYh//Eu43/wWjj/428muz899Mwjn8p5/Df/o5xvwsTkra19xH8rYH2H/wbo7fdA9BOkYH27i8IBSCeGeHUkZo20GmyERFQ0BPjSd6pCcppwe48ZiGGmkc5azE+BHjyENGA4RdocMO6KjtEXZ+ldSfUEYThAvQYYAXKCInCaxifnmX5gufYeUF+OWc7MkD7FNPUdz1GPEDb6I8czsuCHB9je06KusY0qNkCFLRt1MsGVuTTW4elRwvSzZGKb4fU1cZwje0+R6hSxB+SiBjEiVY9Y6+6wisoe4cgW0J8EmGQ9obVzi6fBV/MyRNJVYP6UVHKzrSMME5jYtGiHoO7Qp0RG9rmnZFZwyhGGKUx1YKh8d77B0cc25zTFQv0G2OqA1mcJ5Vc4z1UobJBF94rNoViRVEYUKZBizqhp1xSDTJMMuCpmtI/BnpzjpV79GqFdVRzer6dUZRDSagCw3CQqhS2qY/yaH2M+r+GCGW0O8gW4trLV2sUZ6k61qE0AghcX1Pkxe0SYoxlsBZaqUJnMUUBf5geFIHlC1BFP++Ned6i2kL9DA+ST2QCqNClLB/rEjif1Jg/xGSUxLf9QhrMH4AnaRrCrROv+HP27qg6y0EEqk9qg7S1CeIfGZlS9NbvDhGdh1Ga5q6Ie8LlAyI4pD5jcvUtSQajwn8jqZriJIdlPZwTmGMxUSaPi/wA0foAqxKaaolvVphbI9zPjfqPdq24fbJeWolUHXPUvvQWkbmxNqmopDMlJjGcqhWCOURixjpW5q8o1jkJDpjt+/p6PmuOz7EP7nyz/jUzY9zfnSKtw92aP0aGzdkdg1nNMujZxCjLTK5SVsVrJYNTg8ZbE1ozYJmkTMejHFND6IhTkZMnM+NsmBf7BKpiDYOmTQr/GiADibMlx3IJdLEdE1DkPh4/skMipQStCIdDJiWx8gIXsovIXrH+eh2pquSPFWkcUycH1N1NVk0wYSapshRbYPnO4YiYGUbWmCgLF7vWNY1OsgJgogkGrOyJcfdnI9c/EX+3hP/Ld03gT/50ucv3vMX+Fvv/Rv4Vcnu7nPsLm4Sp2dQScw/e/HXeWV2mdvTU/z4Az+IDiIeXL+Pzx4+yWM3n+JWMUAHBpMvCMd3IYQGG0MlKQkYpDF5lbN7+Qpbt91KnKYEquHYVIyqgkbFqGZBmmbo9SGmaKlWczJhuGMwprExorjCnulRdcLB8Su8cPAVXjW5l414jMLH4NhdHFF3UwYKtqMdPONR3rLB4vqco/0jtrbWKFtBU3msCUt7dIRpLJuJBF8gooyicRzuHlF0OapYcdyUhFHMKEhpkwlZkDAJFJ6SNHmOyCTa+1eHV9L09Ms5RbHk1OlNRqMhh9dvUOYF2+MR6ms3fhV6jLtt3KKhF4bCVAQuIPMzGrFA64q6CMjO3k++e5M2n5PFUBY+Mx0wKUr8KCJWEu1rxPgUTbFipQRFEBMIQ2QKEp1goh1csSQUliodkvkaL0zoTEMsIRpMqCzEwx3iwxVRsEkTDpgXDU6GnPMNd77qu6mXBU8dvciv7X+CHzn9QwylTxlFHOe7RCJgNcvJZU/rRWQ65GhU8MzxVbQfsK5PE5cla8kamBwlClyTMMy22AtbVN/ih4LVcko9LxmuO1xvaPsa2/q4vCAanGEwPks1KzhYLFkfx/TDFHe8pO0VRjTMyoLI36E6mqPyFa2SFJ5HlI55+9nX88ziOZ6bX+Ov3Plj/KXX/GX+yaVf4v/51D9iN9/9un3x4vRF/sJv/UW2oy2+8/wHefvWu3j/2e8kbDKWcUDiB8wXSyqbsx5NqOslQTChaU7smKFf0rkQnIcXZ3hhTeMseJIw8lkezwhiTTwMKOuaLm9IJxHN8hp5W4JT9H6M1zvq2QsUDGm6BO+gwKRrLOVV6nnB488/ySuzq7zhznfwwLmHOW57pmVF7HyEKbF9j9AeN1cV1sJISzrrcVT2BL3jnWffyT955df55PVP8Fde9xdI44RFdZNJBokNMKZiWt+k0oKFPUJFLWZxQHDtKuqW25FRTKsE/WxFazVr6RBnT8jhTdGfdBg8gzUgehCLEmc8/GGEFyR0VUcfLnFO0jqLsD1Y0EJTm4L1QLPXwfHCMHANY9fTL6+jk4DUrynn15BtwnF+BVd2JL4j8GFjIJiWU9o8hdaj2J/SdUvm3pjarZjsDCn3D0mHZxn5EbYoCLTC9BVKKRZffhTXrzjaSPHzkjDeZJBNCOOA68sVTX6BU1HEvJpzzXmczjpYztFZSumAOCOuHHlh6R68H/2bHyF65SXEqbdi5g23bGxx6vQObXmJw6OrbCYd504PeOlqx5WDJXe+conw9W+nXRuTBRoVQTsvaMwZwqpi+MkvsPi1X+GOj3+C6PLvt2F/PXXl303m1CnMux+meMMdlA+8muXWacZeRt8MYZUTpilV1eHmBUHnqKRGuBXOOfJVwYgBQkpylmivYRwl1N0m/igjaI9oOw8bhHjveQft5x+hu+tuvB/+EWq1y7I4IDQ+o/E9JF7A/ouv0O+s4b/qbjpXEoQThIhP5vObQ8RiyjhJqOuWVVUwo6PxQiaNAOloiyVKC/b3ZqS+pVxV1MOahafQreCi7ZmvTQjSLRbf+i1EP/vz9L/12zT/8Z8jco6J6Vl5EXmb01QtgbJ4gcahcFGEHcbYoxlZ0WFFyfx4QdSVLIsVWd/R33k7Hi3dbJc4HrB25gxfuXqJqul5w2RI2FdIP6E00FUlfhJT2BYdZViVEgxvQV1/ifLmC6wqB/4QpQ3xZILf15Sf+hhWCxbvehO3DDYROjrJDu+Pub7/VXI3QIdDDuaOW9cy1rwA6Rx1GGPbgqJscX7HThpR+CGz2TFycivBt72f4Ls+yIExjJ9+Cu9jH0N++nfh85+Hf0tUmrCW4OmvEDz9FVLgNiUp77ubxf1vINUdWV/QuZANG6CdQfUtXllDVSCqBaLpEE0LZQXGQtMiqhrqBmF6ultuob33PoZvfA3FvedYvu61dLrD632Gm3fgmp5ybxeploj5DOtNcHjoT30ZG405/sAHSG47zdor12if+CT984+iX7lISEh11z0Eb7qN4s4AF3hoTt6bOlPQ9SVChDgBQWBYVTV+EJAEPkJq8FJUf0hbt8jRFlVtWY8C6qpi5iyrXtNXPZFtiNbPIKQjRFM1DWGjEMMBnTVU1AR+SODCk78fH8IR7uhFem+J9TbpbIAyMR6WZVfjeR6nt9e4OV3RVUucqWgK8IIhS9tibc9oFONnGd2ypDrKoZWE44h0LeTybkPRGqLw5LCsLZdQ75OcuYc4GwAC+pZovqAROU2zwErDRriFvXaA+ORH6bbHeHffT64lQ6/H9g35rGE09Kn01yDKrkV9bf66nc+pncMmCX5bU1Q1Moqp/YCoKImyDD/0acqabO33r7GuKnHCnnSvuxWEQ0zdI3pw0ckoxR8H/UmB/UdIbdfRFgUjLI2TBCqkKVeE8QZC/P6ZhKqq6PuaUZTQWehqgw4VSeIhtSTQklXdM/F9RN0Qeh5KDVgcLVl0CyISmryh0BlbUQBuihABQXRSzJ/MfxpEAKPxGONLrDQom4BZcHTzBluba8hG8ez8KqJ3nE5PMctLXLGitgE0BjzwFcSjMTQew6KlzHr2FpbNSIAR1MsFg1BjvQRMg+pz/FDygXu/jZ976md4ZP8Jbh+fIYxhPBghtKLpphxNc1YHIXoR0sUefTIi3DzFKI2Y79486do7D5vPUZFHl23h7e6iS8PKL9BthVQ+oa8YjRP80ZDFYsH+tTlx6IhCQxCf/D+EEHieR1mWBGFMJnvmxRGXqyucjdcZTTbYzTtck7M5GrBaLWhtTxYMWFUFQRKwsbZDPs3xpgWdbNAqpjGGSQxlW/LM6ipfuPwMn7r0MT534/MnkTh/gN53/t38zdt/gjO3PQhdztHsJqu6IF07y1RE/E9P/VPqasWDG6/nOzffQFOXLI7n3Ju9ii8cP8cnrz/BD4Rn2djZoas0UWswugOp0F6Mcoqts2fIVyuObl5HXrrM8MwpQqeoV4Z5IPB7SH2JlwYYYZmzpKtahn6GiEIWdUuComhzZo3mt64/SSkl923cx345JxqMiNKATXOKvvGxfU0xnRPXNW6cooKexd51wtPrWG0JI00cD1hOZ0gTITjJr84iD7+vKeZzZq5l1jisHHCqNXi+ZjBZxwNU1yC0h3KOOl8RZRlSadqqIp+u8IVFro/pg5ReKlqpUE2N/69R1YUQeElKUmaoroLwxB1ydrRDvrrMrMgpPI8gHKDTCr2q0cMJUX3EHMWx9dhYeajhCaleeikqcKx1Ja3wmHUFdV0zCkfQxah2BUOwwuE5hS+gqlbEUUgcxJR5Q6sDBpM7WCLo+p5+WTAeDohVTl0Zvnf9bRD4PH30PN5Xf5XvP/dBNrSkDT0WuSbMl8yHCaMoQkUZ7WrB5eICW+l50tEWt6Qxwln63oNiCfIAnCMcDuk7GBhHHArauqBYHaCkRtgBWgaEmUYPt0FJYhw3FjlnbtmisBI8hZIl5eqAanlMGm/jJzHtqqFXjtpTiMNDlFzxgdMP80+f/lU+dvGzfP9DP8B//va/zF9984/z//7Kr/KTn/+7XMu/fl50r9rnp174aX7qhZ9m7UsTPnD2vbzr1rfx7aN1ysPy5NQ+0ixn1+gKD+FCQmFY7e3SeDt4mUBIhTAtwi1pWkNrW+azOeP1NeZti7YturNE8xVtNEcMTqPXtki6FU40THyo6ylBoPD7lnrVMIkyvlQ8yyuHT3J7dhvfe/cHiZSiNR0Yg/R9mr7C4bGsDVfzI5IgIIsmZJHPRCTMZiVKpbzt3Lv5/OWP8Ynrn+Bb43dSm5hRlNLtXiOWDatYUzQNCxMQyQYx6On3LiADaCYbVE0HOsAXLbquIPFoe0vfGrK1CNM1COVw85Lmf/xZ1AMP4H/7dxCmIdUSnFXMmynKy3DG4hqB8VqsaUmMJmgbqsbSHuX4kcPEKdiTWe75fJfL82O8omcoNwhkR+i3rAVwuDflYtGxMUixq5toryJ2HpkUTFRKqyXaG9OEAlUuiGTP9dUeA6cJX3iRZmeHVI/xfY94fYM4Tphbwd6yYaIk26ohHSQc6wFlHLCtMqySdKpk4k+Qi4bF0YrogfvoP/IpkpeepXrn2xlNRkzGPqZxDPWI467iqLnI1tpd3DZSvPyRpylahbvrbjxfErU97urLyI9/AvW5R3CPfAFV10z+Z7wrADghsGfOYJXGDQb0GxsUf/bPkHzfd6H8Drda0R5ep25ndHIIvaCXlvXNIQsHh0XBJIqYrSqM7tgYDSlWSzxfQBYxn++xEa8R2ohQFjQzy0CGdANLQc/6W++n+eKjuC9+keA97yDvUlLXEAVb2B7qT38GWoN554OEmaVvNUbFOAuNCOj9mEEUgYrIc8Px/nXypmTz/C2wf43YkwyjlGAt4aCwJOOQMEow3h6pKxm1hhuRYs0fM3IQnTqFfvgd9J/6NPqpp/Bf82ry42O6QUje1DSrFRPhKF/+CsG0wR3fpJ8fcmpviV83qHJJVfWEUUgfeqyEQH3+i2Qf/ABdolHjMSsZYJRkKDXGKoyt8E2D7CxNb/ATybLr6V2MoMX3EuTWfcxffhpz9BLxYAM9Po9zAbYr6B79Av36BHf/q4jCMTKM2C9jtBkwUAfE3YJFcUishwz8IdKcxCAmSUrR1qhqRScUTS2ReofCXCfojtmKRvhaYTpYPPB61t/0EPyf/ktoGnj0Ufj4R3G//dvwxFMI8/Ucl39dwliSZ54neeb5/5kr9kT+xYv4Fy/Cb/0LvmaaJh0P6e69F3ffq4nvuJPi3GmKe26nCwN830d8+ksnsXNvfgeTB95E77X0W2dJ3vwgxYXPYi/N8J8/oH3yCeyzX6Ieh3Dfq1k9eC9ma5Ou3kNZh64XCD9G+Bbb1eRlgBAhUvuY8oggmtB1DU17TFt6GBMi84Kxc7x4XMDiiNszgdeu07UV3WiN2OaIvKZd36Lo5ugwJAsy6A2273GdxXqGXnRgJJ7VLCof3beIUBASoMOQ85miWR0zO5gTDtfwTEPhBLIrGW+ewlcWhKXXhqapCdwAP9AEviaNPJZlRzqO6AOFVwqwHmW+IgoygsGAflmSTCOavgQ/Z5isgespPvzL9BcuIJ6X6M98Hl9o1Lkh3c4+4tUPkw62qY1lRUPMyfy16zrqvKAMI4K+Y350zGK5JNrYJMtS+tUSW5YEcUCdl7RNix+c2MqdsfRNjvIDpGtAapwOMc2CQPl/bIpr+JMC+4+UVNdj8hyvr+n8CKMzqBa09ZIgGgGcQL+qirZr8XyPYZQyPVyhDGyEmqIv6euOLB5xXLTUUuMLcE2DnyQMohHz8pjZjRWdC7AhREGH6Su0P0L7AVVV0lQ1np+gdYNykq639PQ4z6eLfZrjA9bnA0QmuDC7SFu2JN46xXJBJAWBUUgLlZRo3bJczNEtMC0QxiF9n2IAPS1WWpZ+iN9bxn5AFAquV1M2VMKr0lM8s/9lnhvfx0PjW5F1Tj87pj2+SBwPsOGAYmUojwXynE8ceATCoJocL4pZLgt802K9EBDEgzHD0Kfpjjg+uon2N/GCED8URIMIoQTtzT2K1Zy+sERa0lUznNCodEzTNATSZ5xOePzoy+RtyUPDe2kDjROCeLpgOZ+zNDVZGKDVSfxFVih02WLLFpfXSOborVNcNtf5mc/8P/idC7/Nk7M/3APs/OAsf/vdf4cPZG/iaHbEorsJqxmxhjKIeXp5g0eufZbIVrxn663cnd1FW0xRYoO1dBOdhbyxewO/9fyHeXb3Cd4+/l7mnSGYLrBDidYpxiwRwuCFPhN/DRsoVtdvoo+X1L1FlB3zyjDuW5L1Tbq+ZFFbpKdIgyG6dThrafI5omjJhiOm9U3qfsZrth9kulxRLleckducGd1HqDUm9uhcyJw9quUeyoBIQuThMdd3D4gSny3fQTqgnB2jRU5eOmaFREQrfAlnJwk3ipLdRUfer5GuOc6GEq0lPgIfj67rSJKUarWkznOEEHRNh3WCdBATDgcsOse1vCGNI/y2oW1boij6ve9AKIGfjaj3l5wZnqFQHcv8BmHbEYt1/J0BZdtQ24a4KZHRBlniI6Z7HC+POajmZGKDxgmcMjhiaCvS7iqbStN4I+YypZ7NGEUpNrLQLPBEhlcvKJyl9zO0FEgp2C0a/EAghSRVIU41+K6nFxHd8S5BHPFnb/0efuaVj/L49SdQZcOH7nyYSbxOtTrg2AqavmM8iCkkrFZ71LScSc8wQJONRwghsL7EupbucEa1d0R2z/2UfkTbVYTCoxMTFA6JR5AMCGgQzgN98nANygLbdlTzCklJLwzd/Jh5OWdte4uNrS2En9Asa9plQ973eKInGox4Hbfy2egJnp59lbdfv4/z7h601/AX7vog33XH9/Php36Bf/DsP+DZ+UvfcN8c11N+7uVf5Ode/kViHfGmzYf4lu238afVe06KleaAyeZ5ZO/RG0GyMaRMIrRURIFA9DVKDFkelwyGI0ZrY/qmResIRUumO/qNU6jBKVSnGGymLI4WaH9MRM+8WqK9jrj0uFFf47HrX+b8+CwfPP9u/MUxaZZR4+ilYhJorHZoPWS1bNkJFGkkCGXFqWjCRI95PF/StDkf2Ho9xfIVnj/+Mrfc3OC1Ww+S9j3TxRPIbY/BYJ3Jsc8N41Fbj51Mc70WxMc3WaiOqnEMRzucWRthZwX9UlEZjdISP5KUjT0Zxbl8HVsViOeehW/9NgLPp6KkqSNK05D6BY3oUKVH5y+RXYcqG1y3wos8wrxlEZ3DjTTkBS5f0ThJWcJ6dAvBZERuCpZtgvCH6E1YLAwbOiMLD7FyDRslJBubVFbAEJbtilIJQtsQUBPqBPPkK7iiw91xB2ngkH5GkgxxWnPxxiFBs2LNl3ihJJlkNCbCmphl6OPyKV4UEkYhK+FohEMtO5rb7yC9cAFx7SKb999FEhmmqxnNbMEgyJizYFkfEfSazcsXsMN15k8+xW3/7BeQn/gY4srVf++XrXY8wdx+Fnf7nbSnbyE/vYV68HVEd78WGQfUH/4d/E99inZrA/G2B1FeS9s6lLdOEi/pliuKyiLJkR5MQo1pOxZY1gcxoljQVWCsQFhJ6xsak6NMhyoD6Gt8GTErFwQ7ZxC6YjldMV+1iFfdi3rmK5TPPoW49zbi7Cy+N6TaO6D9whdx6xvYe06hfUMQjmkrwWxR03mCLB5gXM1RI5hVBhPFbI+G+GVLKSGKEqLTO0SDmNFxRWkdKnDkyw5dLEAP8EYRYzfELUuSNU3w3ndTPv00/he+iOp6+qtXccs5weE+m4eHRElKrySmA4dBeR5Juo7Z2cbfuI+uE4g0wT+3TXmwj/rNDzP89d/B/sU/xwLLvDlk5CkGUUIjNKp1xPWKoPMocQy8Hmki8q4j9n1s72g6R7x+B/nqBWx1iB+GFHKL7olHoWuoHnz4JKcbg6k7itYwigJ2Nu6g62ZEswWqVuTHM+LMIJ3Bi0LEaoKWczyz4GgVY9BE49MkwZKuPMYfbDLSiqO2Z9Ebxp6GIIB3vAPe8Q7EX/tPaJ79KtVP/g+oKzegWpG88Aryf4XMbz1boL/wCHzhEf6lmdiFAebee+CO2+gXJeK227FvfivhcMiyXDFvFnR+DLfcTZ5eRbzpQVaXjwi/ehFz6VniRx9DPvoFOHuK5M7bCe6+C6UKiCWtaCnqgrqsoBjTV0eI+gB/fAusBG29wJie1VSTqJQ08NBI+ljTRorOU1jnKG3D2nBElVcsbh7RjxSb3hglFVZZnIC2nkOfo/wMHW1RLxa4ukMnIX4cMBCauu1RdslmonlhMeD6fMFODNL5TFKNH0XQlrhmRbHMcUiicYbWAlv2rA1Cruy15K0lEoDq8OJt+q6iWkxx2YjADwnTMVdnK8LqkLVz99A++wLNiy9S3Hkn5nV3k908wl64ir1wA+/Fi4gvPkq9cyveXXdQ3nIK/5YN9EDRLWccdx19FBGXBV1REGlFfnyyvkvPJyxLvLU1pBI0RfN7BbZpa1zXotIBwjQQjeiNwfYGGaj/n6+9/yX1JwX2HyFVbU1Z5bSHhyR3rbOqHb4OqYsFfnhCHqyqCmMMOtBoq0mkx25ZEcgIoQ1VMQPABiGh51G0Bt/zsU2DTBI8fLTraazBqRhDjusl1koCL8IBq+kUJSVhMABarCfwrMT5iroomDY9VlnK5QwpEg4XV5mINYyfMpAOKWOiXqPHgpurGuMcfV5TNxZbLJBRwOS0T2EN1xcFm35IGAaEvcEYwHko7ePKQ9556iFeOr7Ek7tf4tV2iNc3wJLOgzg9Q+c6imZJVUmiGxqBZGULmB8TZ+sczZdsrGckg2004GJJMk4oDnLaG3uYUKLObOJJhylzTF6zlhpyt0/TDji42REKRxA6TN3T1S06VkjncyXfRQjBSI+5cfMm64MxQ09TeDWD8Q5pBavpIbmr2Ykn5J2l2S+5uHiSX7r5m3z2iS/zSnH5D7U2tNC8YetBvv3Mu/hTr/txjHNcvHSZXvps9xmbfclhV/LRy5/jK8UlTsUjvv3st+GlQ5SyJNltxIMJYXoy2/bOW97AZ699hqfL53lz+w68cIfVYoYUAX6Y0K0aVKhxkUBYx+bWBu2yYP/6AWuLQ7yyReDjTo1ZBB7d6oDAC0n0iNzldHWBWEm0sIh0TJhM+Pjzv0ysPL576zVcuPw0nh9Tz2cs/F1UlqDijMjEeIOzLHzNfO9lauGIt7ep2x4CSTzOqMqcZQ1Z39AqQZCMiNIBdlViTMl0/xiTh2xtDEl3FEXfMTvYZzjaxA99yrKk6zqiNKPKT6yRQkYIURKkEUEY4NFR1h0DqfFFS9d1J9E+6l89APx4gNQepsjxM02R38CYCS4asLG2xWqZM12W1GbG4eKAzcFZko1zVDLlxtVLHBcXGeysM8pS4iBi2guW84p132e4MUQtazpjaQYZC7NCYfFcj6orTDBgv+0xribvKmZlzQaK1JPsl4YokNTNkmbpE5mWYJIhhePHXvOn+Onm53n0+iN4geJ9p97JKIk4aEts1xD6Aa5teXH6Mp5Q3Ll2jjSMaKueIPaQcYZc20DIEFVeIjjap03GFFYTepomr4k2t9BhgNYal6+wIsCtVpiypLu5z8Bo5k3HZBKyxCPRMYE/Ih2fwkoHncUJRRx65POKVd+RbG1gm5gP3vu9/NRL/4iPHn+JHzt1L4EcYuopYZ/z/lPfyveP3srHjj/LTz7/j3lq8fQ33U9lX/Gp3U/zqd1P8189+d/xlvUHeP+t7+UHJj/EVj8hTFP6WGGURwnEQYIwNY3rcVgCL2RRVoyqOfPW0fiOyXiIUGssm4KYmCDpEceOziQ4v6BvBKFe54Z9hQ+/8Btk8Tp/8cEfp/RgOt0nmoY0cYRCgewASWsURdcyDD1GQcZhs2LRLJAqJYwz6uII2xV8160Pc+nFK/z2K5/h/o1Xsbj6FSpy1rbfRuZ8ni+vol3JUVsyFyHJ8BRZcRI3tlzMEeI6zZbGDwzVzT3aeEK2kWG67iRGrG3pX36JtsnRxy3+7nXEmXNoXzFbNoSDDO3m2HKFWo3owympV1PamjYIiJTPeDJmGiZYWqxwHO9exo9iMJJpb/FbjXAQR4Y4yQiSda7VM5aLQ/y+pQsGiMk62dppbhwdcOxa4m5OrMesj3YwB7v4yYCjF5+hsw36tvNIkRMmE2DJ80cl9WzKWbvClw5v53a8aETbe8iy57jO0RLO2Yim6FhWBrRPtWgRD7wacfElwqe+zOCtDyK9Hm+2Sx3EpMqSiQ3sM89hfvoXOfvJLxMcHCDMH35+2gYB/flzrM7fgbvnVYxf/2rqW+/k2mCL1SBgZ2jpqhmrg5IwHbAxOY3nxwSBpH7Nq6n6CnvH3QxUQzs/xoaniOKIcimJrQcyo5YFue0YNiti4VH6/okDI7L4fspB3pMmHovyGOolmVrD1AYiiEXItFri0oRIxZSrBcsbcwavuw958RWqT32S+DX3EQUnqSfu0S/Tr3J4/3fgRA1IPD+i7zpWjUFLRY1Pr2qaLseako3JhJ3xGquixPoKqg5jWiAmiT3aVUtjDcVsxSjQLKKeTEUMVMZRO8cKB76Pev+76X/hF3Cf/iSiB60VNk7R923A+TP46xvsVRVqMob1M0RxRi4lLg6QraGtOpxnKAYjRu/IkV96nOaXfxXx538Y0c8ZeJZMSpznAzHFaoo2Hp0v6YXG0wnLdsYgiKnLDq0VMlZUzRZNZgiLgnr2LP6jn6eejLF338OaTNkvKjKp2cgCBAIpFVqPUZHBiYLm+IhFbRmvDellRBB60C8J6oK9lYcYGO45uwEmoMoPTxoHwYCBVsx7w2HbkSn1e4yFTvvMz/p0P/H96J/7XeRozPSnvx39/AXM736KwZNfYfDV55H/ATgA/z4SdYN+8ml48mk0EALuH/4DzO23krzqPtw9d1K85k6it74ZGWcoHOkdd9KOTsHbHyTMZ3QvPEtwaQ/9+aexjzyNvX0b8do3wNqE1FcsTY9VEud68mjEZDRExhmubtCixS1LvCCiTDNS7SOmS6w2zAVo57BdwTDbRPotVy++RBaGBF8bJbOypzdTkA7fBeggw4qUuq/BLdFS4Hkpylrq4pBGK0I9JA0XHBcziihhLQiQQQhdBX5Mv5qSz1d4KiDZynAelLOccBiTBoq8NoS6xnkK40WE0qPucmZLhW9bjO8Tr23jVfusji4jPvoxOi+gf/u7yL0Wd/Y08u3fjp8fMLr5Ev31G7grM9SjX0B9sab2PNzZO1hlGcUt51mPMtzxFFnVrGcpXV2wmM/Racqg7ZGrCq0l7aqh8wOUkrSz2QmcVrUYCaDo6hq36pG++z3a/h8H/UmB/UdIWnkgNNXxjMR0SCHpVYJsprRVRe8c1lqiKKK2NdJJ2qYn6EFmikU9QzqNsY66mJMOtmk6QyUUUdtiuw5ZdfR1g/VioiTDmhmrYknshWRBTD6f0/c1yTijb1uMqVFKQiPopWBRHnM8W5BKTe8actchpeG26DyrRpxkKgJtd4AuK/ocpkazFkPsh5QBNHnB3u4xXT1jEseMkpS+LsirnrQXFGGP7ioy4zFcP83rJ/fylfklLkUNr4nHCKXQcoNAnaVevkKd9gTbI4ZkOKEo6hrtBFFTYaWjVwnKgu0NQp0QRV/GIws9VL5LNTUIFVHnNTLKUFGEbiOCQUbeBlRG4lHhTIWvfdoyZ1nuce3mZVxviQdnkMuc9ckW8Zk1ytU1Ui8gigT7Fy6zV1m+Uj/J71z+KB89/CTX66+fGf1GinTIw2ffhnGahzYe4Ifv+ACbKmTarlhdu87RwYLx9p3oVnA1L/mFg8e42R5zbutefvR138HyqMaaBYkJ0IFDhw0AXZdjreIDd32QD7/4G3xp93O89VXfS9/2jDwf4Xs0TqE7Q1P0JzPsncELMuhv4H7rt4kFqHvvpZGCG3XFaS8mdZJisaTJS+LUxw9CBl5D3jq+sv8y12dXeePWvZjVlDNbtzBcP8vewXUuLy9QVBEb0S1EssVfG7GR3oqZLzjcfQ6xPsI/MoS+xUVnUULgJwOUGmPjhvFoQuKFVMUes+6QtnIE0Rpba0MmfknbD6iqGm0OkaN1hAPRnERVeGFK1xjaekkYeycUTOtoBWzEPqYGh0D0/dd3scVJF7tdTAnaDtMKZsawsRaDdWhPMUlHrJKSbl5yJTkEPBI/Ye3MbRQ3nietLWHW4GzHUHeU4ToL6xgtj3FLwebaCVzwSr6iJqTKb2I6SaVC6rZkJ9CsBz4DkRFoHykg1g2DSLA4aqgPLjMY+hha/M7gKY8fu/0D/HQx47NXH0N3kgdufxiRL1gTHl2xYlbnXFpc4q7hbYyH63hRfwK70gbta/re4IKA8NY7EHlBGlhmi5q+d7i6pp8v8CZj+tkBrphDvI7QljqvQUdsn93iRt9RaYWnPYyDwBtQzw19lBMGAUKe5NgK12GVoFoIqFtuO3Weh9q38NjFz/DC9Hled8fbiSZrmOKAOijIq4K3+q/mLff9JF8qDvit3d/i6f5Jnp099033We96Pnv4GJ89fIy/+ej/hTdu3M933/FtvNt9D/edfYjGOpZO4bWWzlYMUs1iLlA3bpANFEfj5IQSnm3hOkPXN9SqJYx9gihkUdQMRj4b2Zgb8xX/5NrvEsqA70kexIsCJuGAm23HMj+kXwnCeIeeGiECDouSxuSkviXREyqbsVetUMpy23DE84eOw9U1bt28jXfd+kF+5amf5xcf/5/4Dn2O0ZnXMFJjrswPmTcRO8OQVbVgv845LUukCRFVSCAmhMWCed7ge5K+zZFtiZvs0DUamha7WtJduQxJTF9WtF99mvDMeRyCelUz0AHO83D1DGdKhDIEScJeIfCQpJ6Hv72DXuZceflJ0mhErDP65RylfVRYESeaNBhgXYuvJUHlkaSwnB2zKhu82wLSbMysqqibCt9paiFZqxy9a3Ciplo8S3jjAvX2BN81+J7DC4ccdIrZoue0FxAZQ7q+RSMjEunjaUGnLKpuEEnCourhsKZOJNkg5CaCaDDE3X4r4eVL6LzAxQHB7BD95GWCj3yS8ac/j7z5hyd7O6VoX3s//dvfgf3293Dp3JA83iBbhAyVph2PEL5G1w1JvUKHI2bTi8zbmjuG50l0RNNbbOUYDhOmb3k90ShGGI9u2RCqFViP1lpUExDFHcofoiLHsjhGKp90sM2iLomsIPED9mSNl0PZ3mQUjxmunaVeHGBsT+A0MoyprGEcZKjOx4keN/Ro7r8HHvkS/kuX4TWvgbLEPvY4Zjwkuv9e2vYKTkiccxwsa0yqCGMP21q6pqJatgyHCafPbKOUZhT5FFUHwkPQ0lYV2g+JFeSzOXnvyEZjanfImgzxPI32POqyxvMd3HsO/y/9efAEenKa+cGcosrZiDRyfYgnQ+qrL5H6I7LxFoPYY1HUlJ3BE5beOY5awVCHeO95H7nTuC9/ieiXfo3yOx4mDiWhy2n6iGEyoF0c0a4O4dQmvYiRqqetLLJTWEB6hq7pGKYTcq/hSPv4Lz2Omu6y+pb34euEctnjfMfIV8jAY1531F1P2VqMyDBeT6dn3Nyd0zqNyMZ4YYguYdobgqZHKAeeRxSu0TUV5WofpQNCFTARkBvLvDdoYxG2pGmOwCwJb72T/oNrBJ/6FM2/+G12v/f9qAduY+9gwWZ4G+nVC6jPfgL9/AsY2yE21qiFhxOSIImQwwBP+7SNQY3X0FFEG3l0gKdT6uGQcHudrquRbc3w8mV48mm6Z5/Hf/ElZP4H0+j/dQnn0Bcuoi9cJPmNf20/nd6hu+c22te9maO7Xo0+s4Y7HWDf/Q66D/r4z72IfeE64qVXMM9cxYQ+6vu+nei28yhRIMdDpo0mt5Y0y1gdz4n8iNj3qUXBvAdXlYQC1tIM52uqKidSGuIY0Tt630PVjr6aI4SjtwVSeyiRItslFoXte9owQ+kO3edoE0NbYjvHvNGEieDUuqLsQo5ayfokpHcav28RXkJZN/TzJdnWbfiJR1EWOOmolyWj1Gd/VpP3DYMww0qLUwk+LbbJaZYFbWfYuuU2zL5m9cmPw4ULNK97C2JtDXm8y+HhEdtnTmHXxwSn34R4fYUNB7BbIK88RXXhGrz8PG1RMnnEJ/Z9luM19N13491xO5sN7C5rjmvLME1Q8xVeGNA1DV3Z4wKHaRq0DpGyQ6QT8BS2cejERw5OQM1/XPQnBfYfIQVhikpSurqm2btJduY88zLCIZhP94kGa8RxjNaaru7QeOR5xVAKllQUTc+ayWidoRI5aV8QBxFF7QgAtyro8wKpIgoMg8CxoWLKZU3d15RFQ1ksiVKJ0AbjLHVhqatjVOMR2AGVMgjryIIR4aDj2ekLSK3YWb+d5WFOiyQbtXjVnFZIAt9RNQVNbqhNRCtAd4Kobujalq0sQpQ5N4sevzakQlLZHt3MyHyfwHW89/a38OJXL/G5mx9h6/ZvJXM5ymwyzw9oiyNs1JIMBkQhtPMpfXcTLVYsG4G3vkWZQr+YMigrorUEb97QL5fYxCfRPappOTwOyTZjwo0d6jKns3OgZXNjk8ZplrsdfpeTro04mB2yKpccLvZIvAkuWWOTkkuHL/DiwXWePXqWS4ev8NLxs7y0vMSi/8NnR4+CAd9527fx0M6DvHH8am5LT/HfPfYPmc1vEK6WzOs5eW8ZqAjvllsYnjnPwexFfub6R1j1jtfuPMiDZx7C12OSSCGnHv5QEw1CnKvoupKmc0iV8S23v5On95/kmaMXuWv+CkZljDsHiSEYRCSewIY+9ZEhn1e01rBRlHR1C6aD7gjPJbg6YIlC5Yd0ep0oSUg2MugqgpllZno+/NyvIZzhwY1XofIQO4nxB2MGTcdhdZ1du6TL9wiZMbAL0niEr4fEasxCWpxaElQedQd1VaKVhx94VLQoFKbI2ZtdY3bUMBxus3XqFOlIMAw8FjZlhUdqcsxiQSUCjvuGSQMBinJeEMSOaHDiEln0BiUEa7HPHEG+nJOF0Pc99l/LaOz7E/hIvryJDDN8dYpVvziJmlmUWGNxTU8hIlhY0okHA1BeQRIGqHZIXgriXCJUj5KC0WiN40ZxfPMVQhXhJ1sUXUXR5ZjOUFdHNGLEFjAKM7ajmER71J5hUXVYYDMdoKxDaWiyEtIEoXvKegn1AlrF9931nfzcc7/CJ/YeZemF3LF+Fi83LOYzLs1fRJuWu9fvY3OwBtQY19NUIJWg7QwSR7h5ir67hoch3BjQLjrQDfXhFB+LUg1ytIYYrOOMozrI0aOMIBHoBZStJOx7VouS09kO1vYIKsIUBJq2qhFdQx9qbCMRxuCU5Nvveh/P3HyKj13/DHdt3UfmbeHpEU7U2I2IwHbYquPewX1M5Bp/e/TjmK2AD0+/wK+/8Gt89trn/kC+wWOHz/DY4TPwxf+ee9fv5T23fSunh3dyW7DNq7IdUu8MkRB4wlBGmsCLgYgWfQL9qUq6gUPIbUxgoAyI9Rrz+gr/9OIv0/eOH73zQwwrj9X0mOFWi1WSm04hplcJyzmRN8aKIQe1pRcF0gUU3ZJVZ2msYqIaNJbMc8yXNaULuDXc5LbBBs9feZrXnj/Dm7fOc2l+nemsYd153DqecOSvsXQH9HoOwTpFYxgMBvhFR3CjxKxtUHsG0RWUs11sZ5BVi3U1FDni/gcxL79A95Wn8d/7fuqZwetbdFfQuBm+lri4xnlrFKueeVmxfWoTHSd02qdbXcXvDdsyIPI6+k7SCEvlr9gvbuD5W3jOYLoaz2gCuSQyDVOjyHTMWIdcObiC7zpULdjtK05PUpT26YcJ1Se+wIgI8cY346wHNqJRG9yYr5j0gpED6/sUqaReHWGswY8nHFGSofE7j8OiwTeWIAkwZU4jNWkQ4L/mLvwvPoL9iZ9AXXyF4ZNP/YHZw/+m7M4O7bvfzfKht+He/jZW+ZSNM6fJdjbwpzOWZsVo3WPcSa5O58SDAcr2xEbQdYKiLcAXDOM1lJC4aYUJwIst4/EIJ0Pa1scfWHxTszy+iikrfDkCKlAxp7d2OLp+iVY7Vv2cznYk7YimqPAdHNkFfmDxswk69FErR7vMCbIEL8mo+4Y291DERBtrOEpW951n8PiTmN/9LLz61bSf+zy2aXAPvwtJh9IDettyY15xWLdsbcSMA49FtyAvQTUd4/UE7Z9YSJWSeGWPCzx8X9OWJVIpRLHCx0AcMusFAy8iMCdzrnE2pCyP0EFKHE9Qt2/RdTPKqqRVisg4lHSEQcLe8TVSPzkBuWpHEvp0BubGsJEEtKZir6gRw4hl6Wje/V4SWuzTTyD6mvEP/wiiPqBsjmmimDhIWKxuIjpDG3p4lCihqWpDFCjasjzpJsch+aymaGqil67SRAnLs2O2+oZYhieOma4lIEBJwVHe4ivJOA7x1DZFP+WotMxnFT4F3jDkMBd0lWYkO3TfMW9b/DAgGWyznF2lXO2TDk/jS8VESqq+42ZxyLKdk0jBenIec9TjP/AAIk3of+XnSX/x18k+9EE6kSGjCP87vo3y3W/hlVcusDbMSG89z3PLFeL6Mef8hPBsiJ5dpVxW6PQuRmcnrGZH+Ec1ZRjRNRUyjimUx8hrqR94A8Gf+fP0acbLe8+T3rzB2cs5zeOPoL7yVfyvPo+8eeMPva8AxI2b+Ddu4n/i8/xLJLAdDWjuuYPuVbcSPvQQ4m3vxLzuXvKnn0W9cAV+5cOo73kX/dYW3qkNMIajvKRqFaaHQSTxhyP2DvaYLq8zVIrh2jp+JEmaQ6pohDMenekoupJsuI50JeXRJaKt8/jBGsJ4uL7HFC1CJnSBxDpL4A1RbkGbX6XvAro+oVeCySAimM9ZTxP2CDluHTvS0QqB1xascoPs3P+Xvf8Mui67rzux39775HNufPKbO2egG4GNSCISJEAKzAKtzJFszViSXaUqu1yyyzWq8pRVNXSYqfGUFUamKUYJBDNBAiQBkCAa6G40OqPTm9/3iTeefM4O/vBA9HBEUSDFKdMcrqrz5Z6qW/eesPf+7/Vfa5EOY3rdnxJuo5R6XoK2xK6kMYouSAitobc9mpjQziiaJUaNGEQp8syd3PrSf03etXRveSvWGISJUFJTN8eEwRQkKJMgPE05DWmTB1jd9RDLR0+wxyds37pJc+06Zv8G8cFNus9/BvHBD5FduMg8CThGM4xCvEjiSQ/rCSwVyvfxfYnKAkhPfWisNajYQ1tH8Bcu4n+B/zHQ+x4uiHDO0c3WJHs9UihKDUFf4yt52nbpHNpqrA2xbUdEj2yhdyki9Qh7SWEimmpNOoyppKBC4R2d0JsAL4qxfY2TBVk4olMaL5IU+RptSxI1out82naFCDyk8bFdS7U6QUwGDLMJtjOspM/Lh69BD3vD83ha0QcOVeSEzmdwx1laPyCfL7l57Sa+WrJ5ccqoVNg4oMsihqMdPGM5FjlHpieKfazXMoyHBKMEgpjz2Yg33b6L5+avcLk55oHRGSZqm6P9BYKEdDthlG7hR0N0tUSuSqJBQDs6T+8i+mWH63NOVoekLkZ4MWm8Ref3hJMN4j6iWBqSYoHpNijmM5SXEISnMTme0+Rlidc1EB7xanWVp06+yhfnT9NZy6dv/hLXiyvU5o925/z3YSfa5Ft33sG3bb2HH7zvgwihWZicni1eX1acGdzJ11evM9eOrekFpnWNSRIKFfDM8dP87uu/jBU933Pvx7iw92Z041jnPuWqZ9QKvEFCGE5OWz1dR9FbQl8R+T4fvusD/Mzqp/n6zae478LjDNuQUZ3jBxHSNTgc2mhkYNmYZvBbN6iymLbo8a5fJz53J3FryK2kjHwyFeAHHkIJaNb47YKn9l/kRnnMdz7wnezIKTeYEcdbbCab+IOWOBAcm54qXxNnIScy53A1ozxc0rUVUT4hTBRVtcDNrjIzQyZ+ANKAAGcct26+zMmqIPJ2CUebZKOIKOppDEyymDrwwHhM+xKjEo5yxeFhjrSCwHaMtqcozyfXBuMcU99DCMEo9jn2Q6q6RylYVyuE6OnbNVY36KrHuoiciMAIBtmEddAhK7AOPGNJxinmuGRU9mTjbRrdULY5ThlMEDG3lvR4jheFJJf2yIolN8houppo/jor3wfXc0n5RBtnWbsAo2IqETDvLbFyhJ5ECPCkJJCCuuzxbEO8tUsrwVen/6Vb36J1MViPH3roe/jnr/4Cn37j13hr9xgPRvezFUbcWr4CxvLg2TcxDTOa3tJ5NXE/oFzWYCEOFSKKEMMJNl8zCCvmUYyTk9PIK98iwxgx3MAhaQ5PyKuacJBgW8FEBZy0FuetULHPeHsDozXr5XV0XxFGE4Sw+KKnbhLESJIMfHRnCcKYD9z9IX7txZ/n9679Do/bb8NPUkbpNlWc0h6vyZdzwp2QbJRibc+e2uQfPPy3+U/f9He4NrvKv778KT7/xm/zO7e/SGu7f++7+fLJy7x88ge9EWIVc8/kLu5IdjmTXuT+c2/j7uQSVlzk7HiTYNWgxZB5u8CFHqHXce3oGv/6ys+y6mZ8/NJ3k/gJhepoFzkyA8+1LK3BjyeM+jVhGdKl5xnHCiciduIUi49pV2jXoUzPcXdA5qccm5LL+XUC0/M92+/gX958nV9bPcP24Vmq1mNUhUxGW8hkwLAZcBzmKBkw0yXOaVQ8QKYbtMczRqkjjjeovYhqtk93eES0M0Qvb+L1PWJ3h1ZrxBNPIV55FTa3GAcFDkPZg4rP43sLxHLNyaJBjUdsjYbUTpEvDqnaNVvbZ5lunkc3t3DBgJGGqe25UR5y29RMAkfmerxgDPmcOAlYiYSq6lksb1D1NReTPRaRY9iuCSZjqqJnXvZkV4+JvZDhB97HzTeeY7UKWQ1axLpg27W0rsEMImIcoQyp+5rY1HRGI2yKXfcMYo9VAl7V0T35Vc588Qm2n/oi0RO/90fmC/8P4TwP+5ZHMe//MNff+wHyex9gc5ziH+6jyn1EHCAHu3QuxImGWGjwNSsZ4hcGrQzSacZ43No/QDeSwSDFGIPzJaK3dGKF9AuEOkvXeXieIs5iXBFT3LwJdYUfbNCbgsBzSCBQIYkf0zQlZVVhg5i1CZhMJPurFVO19fuMsyehaTqCjYBYQFEVpJ0hyFLCKGV28jI2BPnoWzDPPIv+2rO0v/tF2NggeOxenAb8EdfXJVXjs50l7MUBh6sVjTOcmU5Y1xXWnsbCef5pekkANFKgwhDZddQH+3giwASSFMWyMWxFG9AUGBETRD19qTEm5t/6sEs5oOtXmBASJ0Fret2RNznnkwssSk2lS5QY4ClB01iEtnhIhmGASCO6umYsJe7j30NdLghfepXgNz6H+si34q0PyMtT+UI8zlAO5nWNUg2eVhRNQyAEUknCND31tXEK//VXaE+OmT3+bvzpHWwHHao5ZFVP6T0ftMU5x6ruuWMjJfAkGE0ifMabE46XPgMaurJmlKV0BirTMqo75kdr6lHGdhzgRVv05T5NcEwUb9OahlW1T0zHOJ3QOcGq1TT9gmnacPLIXbjVB0h/7ReIPvkZsh/8IXJf0C8WhF3BRAla5zFSKQNZswoEjWiZ1iPKRkOkaPs1y9JHNhBubVOPBqTLBcXtY7w4gMjHhiFqOiV2PX4oWZ69kzMPXMT77u9mVs2RfcBoMaf5L/5PBAe38NMQ++KrhNev/QcN2f77kMs18RNfJX7iq/DffRIAkcQMH7wf7rwTfXhEcLTP6m9+ApttIUzPYt1T+IJsMiaUmq5YsSgtQiUMBpp04OHqmqavKP1z9MZQLWZ0vWWoAjpVYhtNnPd4aYpVPbaocZ1DhhE1Dqs7nNJ0SmDrkKax+FEFQYauFpi+Z7KxRa8Vq7pg2HWIwKOrlzTrmjRN8MOOupX4vk8QhdhEUxUlEQ29GrPuDJuhwhhD7QJMVRGiCYcbVFWF/9WnMS2sHnwA1S3pcofTiunOBpUpWa0cKy/D6yRVmbNaH+EaH+GlHKcp57a3SN/+FiqlKG7eYvTKc8jf/T283/sdovEQL404WFVsqQkjKVBKYkyLbisi5yOlgWAMcBrRWXVYJzCzJerCHir8d6OJ//8Rf1Fg/xmCBYx36j6ptaY+PkYNRhhC/ERh+x5nLdoZemNwRpI0NW1dEY42EUFKnTm8okP2AZXrSbqcLBywWvSoZY6Z7OChwCuRsicQ2whO6K0hUg4/CalrCAJBEIxwrkBmAS5KObl1zPyoJJIBVnnYvmfW7nPW2yALU2xQkQ4U7QraMGaMh9MGKVIKM2Ukb5N6Bu0KbB3hTQd4ypGEKdNCU0nD1bpi2C+IBopF26J0jGrWvGfyGC+v3uCrh1/l0vQxAhNhrEC6gEESkqZjug6MrYiVo61SxMShrMHYkDS8QLc95uT46zR9Rbh5kbnrQcV4QLI9YHl0wOqZp7BxynDvLLeW13nm6Dd4ev9lnjt+iSvry1wrr/57I7P+OLhjdJGP3vuX+Mjmh/jAuce43dfsrypurg5wpiITI1Kv43a55tLkAS7n13mtOeSRe95NMzvm9XrNrx/9DldXzzL2I777zu/izecfp40H+J3h4KhkqhwuDpl3jn5dEgcBnvTQtmcUn2qJ33b2MX778ud46eQVHjr3OId9jVvus3v2XkxVUa9LetMTZT5x31Ndu0p/3yXcM8/jv3YT8Q7HcGtM1AmWqyOcLdkaxIimRJfHLALHF4+fI/EmfPTCB5jdfoU2NJxLNlFCEfiSkR0wSTa5Lg+RgeVOP2AVGV4rDK3Q9CdXSAZjpBdwsP8cJ8EubbSLlwywynDj6msUxzcYTO5FmQQbRiSZT+Z1LCqPVavZDH3AZy0MUwrObKTcWp+cehqECUKGtNZSGstASXwp0FbTmQ4ZaU72D8AERLZhmCZEQYo/mCL8gFl1i5yagpbMbLA4XuL7HWdHU2IV49KUY2dp2o7Uc8QiwWsdhSoR2rE4OKCWgriGg1e/ThsIqjih7SIy23NW9GTRmBECl0wR9TF9XxB5mxz1Br/tGfiKaRIgHLSVRnQ1vi/xRkOc7umqCtXX+EbgWke0MWIwHvOXvb/JP332v+XLV7+Cv2cYbj/MlfUV7hzezSAZEkqBF2QsmgU6aOnXLb4X43kGrEalCbrqEAZiVVL3Pn3sQ7/EWAmJpDpecnL7iCaM2YgTkiQkFFAVNUVdMIkH9FISRhF+kFDnC2qb0vQNSipcq+iNJR6FaAddpXl861v4UvJFPnfrCe4bP8BucgdZkrAuYaVS0CVqdQvlxnjnztEnMX1R0NYVG6MJP3j/J/ib9/51pKj5xTee4DOXf4XP3Pw0ef8f7japTc1zJy/wHC+cfvDyv/j9c5Nwwt3DC1wcXWJvuM3Dk4eZiiFf2X+OWbPk2+94N/fHe4RJQKzX5EuPtPCZbE7Q+S1aIBxm2Lahb9+AjT2wJZ2RtEjOpRPyLof+BK0NRZ+zcMcsFo632JCNvubDZx/n38yf4BduP813bX83QSAJN3eoQx9PDBEcIBNFr4f47piqXRLHE7Qf4VyFkoqR8NDZhKI0LNol9sV9NnpFvLWNi33aLz9B89Uvkn3HtxPGA1o/oipqhr4j0oK26pk5w9YkI7CGvmvJ64ouUEzDlMo1eGqA8jThZAvb9pwTJQdAUa1pqyskSuDlOcQRgeqpm4bb85Z0uE0QZKQxiJOKLs+5uZox6R3jRY46e4Y4TAkyuLEy9LcWnHcVLSUm9BgPJvjWY+kaqqamMw7fpniRjzw8ZPjV32Xwhd8k+exnCfa/OTnPv4UZjWm+//so33U/ty5us7d7F6PRWYZaUDm4ce0m98RQW0t24RxW+pzMG8pSM0ojIuWxsobpxGe1zjGhhFFIf3tN7G2TKEtVLFDBCOcX6GaFGE5Yt5ZQCeI4RkpJGwlqLUlsjNWnkThR4GjXBcp5mKolCT3EZJvOdRwv51RFjxE+pdigs5pO13htjQpitJLEQjFbrOnTEelkA4ejlREZJfLxN2OeeZbmk59C1zXqI++HyCdvPOYWiqrlbCDYHQTsL1f0xrA3HtEtSrJRTBAL2lJjw9O0hlAKtC9prCU0Ft332FFKs6yJAknoAjozpKkPcfQkky0Su4mUPk3TkKYpTdMS+CMqWxCFFt12rPI5kQzxlEcYxzSuotY1QnpoY+nKnjjxGGtJ3ls2Ep9QSBZNz+JjH2GrMbgnvwJpRPqWR1isj1m2awaTM4RtT10dU3YlG0yoUGyOMsI0Q2tNp3s8ZVFfeobCQvm2N/PA2fsITY49fINgdo1yco5GJPRSEHoS+W+1qH2NND1+eBZv1HCQL9koNGd2z7OwgkQ4UhuQ6Y65s5zUHbH0qc2AYrZEJTVOVkRexCi5iKdCuu6EvFQUKuSVbkXojzn3pgfpV8e4L72I+oVfJPiu70Y7MK5FTnYoG82yKNlTQ7xxzcl6zu56jWssYmOK1prq9hXODi/RjzKUkniDMTouGI4TgjhGK4WQEtOVZHGE7ULmZcXO9oS0jli2M6pf+iXY2CD/T/8u3vkdjvMlntDsXjkgeuFlxPPPo65cgWefRdT1N/1+iqpGPfUMPPUMitOtmOynPonNUqYXLrI+u4297yHsQ49S7W7Rbp/HjnbIvJAo6FFmhbY9C+3j6VOZ2eF8cZrzrUI67dN2E4pbR6RVcBppNZ8jfIG3WrEyFt82ELQE1sPq5NRvJbQcLo5ZzG6RDncYDhN0ZelswnFT4ruOZllB3ZDdcQndVeApwm8wwGEW068WFL0lSgNWvaOQGt9a5l1NUHSkKiYNLd1ixfpXf41mMME8/FbqxT4yjSiFz7C3KBWwWs25XSwYywghFYNJiEgjSrdBqCyTwCcYj1kcHmJMTfSux1BZjP613yJ7/kXE5hZvCMn1+ZyLSYJKIlygsKVB+gK8CGs9XNHRrBvqVU828QgTgQz+/JSlf37+yZ8D+NriezHarNDCsTpeMAhDBtkYa1YY09E1DcaHqjMMjMUu55h0QDIY4/uSY7Nk4Bm8JqRzMW1XEUUha92xahWZ7uk8RRI6nBAIA8Jq6t6RDCyj0SZVBUL5CD9Am4i6PaTRM2zkM+xDBqEiyyJePrpF19ZsDbdA1AjVItYZwzijncQUvaQ1LVsIggtj8tmMw9uGvY0Rpq0I2iWVbxBuFycUk1HG4aKmqBuMcmwGIeOhRyMdfTDg0uAunp+/zNf3X+Ocfw/TkUAVIa7xUSNw7Zp2dcg0UjTap6o6DpDgLDpUDNOIqNpgfWtG013jJKiYNIZomFC1x3z+5Ks8c/tpXtW3eCF/lVvlH29x9UchUiH3T+7nA3vv5jsvvYd33ftBmkZwfDhjOT+gbRypMiz7miBNuGPvQcpqyajP2Q43eFaNeTm/Al3LKg74mZc+zY3VK1za2uV77vog9yT3kyZTtHO0dY90lr2BRPhTalXhSU3dK5wzKCmI/NMCWwrJh+56D/9q9gavHrzE/bvvpGgLVs2KsOzoRUWQRsRBRP+1J+n7lu7he+BgQXh0QhDHSE+RBR71saNa3KZLN9FaUkjHV4rrGAXv3ngnzXxGK33SeIASlt5UeL7CNj6hdZyf7nCrW3MsJEmxZOzFbJ4/g/VeQ2mFSLaQN18jcPs0GxH7jcYVFcWt15kMp1jfo6gK/EGIkxWVXiFVzElVcVbFjAOfOSG3T/bJmit4OmKyMcCgTh3FZYpDo7Gc9D3W9KBrPNMzoaXVKWkyJssmhEmK05ZyuaDCUZWCfigYjTw2yoTe1AR9h1ASFUfEk5TmIKevauLNMcqXZPGU4TDFvPwcS+NYqxhxUrC5O2Q3nhBsJhRtQVNeY9MsYHQW4YUE4ZC2PWIkDMb3To0JtWWtl6hO4tuIlB6ZJAjPI/A8TLWma3t84+OaEpEGHNQagoT/2YPfx6+89PO8tHyFWXOCdoa7dx5GtR0iivCER+qnLMsZvlIIf4juV3imRyQJIiqwRpHEivVyRZ1HdANJv7B0qyOMbjChx/alXcbjBCEEIRCUS3SvkaMRrXWEEuJsyuzkCrduv4ZnHBt+QuIiqs6AJ/GFABzrRc237b6fn8t/mieOn+Dj07NUXcd6vsKVPVt7F+mLy4iywgsvYExFAwhdU5/MCUSCGPuMwoSPXvowH7/je8hkwc+99OP86tEzfO7G5zmqj/7Y7/miXfDk8YInj/+gwZovfN61+VbC4i24YE20dRGhO4oyp6wUfm7wrQA0hbAIP8QWC7p5izfIeLkISFXHXXFM4GqEFzFycFkfU5oVcjHDyW3WacR9Fx/jwQSeO77Mq7zM2+OH6EyHqHrCcECc+xw3NbvJOVrtqKoZC6GYCEcnDN7xCdL38LenCBlgmp7J/gn+eEATKbJJTJFJ6uu3aQnx4wFtscY0LfQF3sinGkzp9CEDUeDqFuyASko0EPgBfVOhbUqWxChP44zCayWDIKCKpkh1jcXNV0FJ+n5O6l2k6yxFZUgS6APJIFC00jHbv0kwHjK4vQYnEQ/dh1kdY5OEdeEYHx3RBDXJ7ojpeJvIi5kXJ1gkx/v73HH5a+x+5Tm83/wswbNfA/h9J+P/EFwQ0Lz17TR3XKS3gvyHf5j40YfYyiRHN6+x3x5iCsXQy9ixkkYG3HYBifAY+6dMa6ktVltkq2glTAdDhKxpVyuY9yy2IlLfp0/HjAYd1eIYv2wIRwGqDFg2glLkBKPg9+UrRVUhAovvNuibBqUMXr6k8SAZT5lVJ/hxQBSPmZc1YbDEGMdmuMlxJ7guLa6dsd00hBtn6fsezzi6pkXsBCjPo+gKgnhM2ICfOdpHHsY98zXcdIJ+5C5qEVJrDc4wlIosMByUBVjLmfEYT0DZdsSjCUFsTh3MG41rNP4gxJeCapUT9D3R7h7rfE7ZLImHG+yMEnTpc7LMmQYJUbRF3eV4vkfXa6qqwhiDChI8I/CjOfkqp15ptkfn6IWGICYmouxLpBhga40beMSZT513JJXGCxXJMODoaM2qMpz9ob+M+8mfoP2Nz2DKnO7CFjrpCI0mRJD5hsLFBCIkTFNUmoCApq5xAtbXLqNun9C9/QHirQmp70E4RZwJCK48S37yBvNYkGyfJUwC6s6cztXNit5ItJfhRzE0KzzfYdY1Uil8LwIpSWqLJwxdHDJUksSbcutoSbU84szGOTayPYSQaF1iraNtDG2oGAceg2ZOZT3aN78PUzrC557D/9Vfpv/Ej+DHCZ6EW/UKNS+4c3NKsrXFc6s5N/Jb7KQRxiV0XQ21pttscUIwFJJ13xFGPqEQ2CiBvqXvazpdoVTElhezqEviA03YGYKnnqS7fpXk295H/ehbaRcHyLhn7G9Q35Oi3vkeODgkOH8OIwz1E18lfON56me/gv/s10lffA2Zf/O6bgBZlMQvvUT80kvwmc/9gXPTnT3MHXci7r6Euvci5dmzLMcbDO4N6FKBZ1YkDJiMN05ZYb/AthpZzJHhFs5zmCSlqBwlhpCKXsNalyzkDR6yd3PGO4PfzuhcRDAe4ewSTygGvsfahZysl+iTgqGSBFlE13UEXocxhqqqcEajdUXXSbRYIlTMrOnwlWVRzdlpBGKUYvs1/ee+TL3OWXzr+9DeFrLOmWYduIR8tSKLFIGWrNs1u3sTBuMN3MSyPDymXqwZhjF6PKJfr1nPDgkGAaPz9yDP38fi+RcRL77A8L572Xn4EVZ1Td62BE2J8yxeldCEPulgDJ3FOkdd98iBjzeAk8ay60D9OekS/4sC+88QWk9S+D7TJqBsS1I/QrUNw9GYWb5GS4tsGwpjsTUE1Qm1MfhbO3i+wo8dxe0V2ljiVuDLKdUQhrN9Qhlz7Md4VQUDj9RXWBGxXs3wlEAohwgkUqbUegVAID1CLyINz3G8OiZINXbps7Vzhs41XD+5iq0Mk/MbdN0CL9hE5Y5sOybKHJKKKBe0vWVrJ0S6IbPrS9LJJp7yCU3Aois4LG7QNQGECWFXENMzHG0xiVKiYsZ0MiQIJR9I3sfLqyt87soXeNfeFi6s2IoVbRnSLI6RdY2r16dtj2cvUK0bquMFm9GApXGYtkGYjjoyvHD8Al9cvsgtt8+V8jI3/pSK6aGXcf/WvdwzupvzyQXuSs9yR7DLuekFssEu64PLDEZjmnVPPZ/RGkOYKHyp2N0ecmi3WeZzZs0cGyjGZ84z6jzuH9zJ7yy/xm/c+gpfOHmOo/wqj4wv8o47380Zf4txukklBe2yxSpJpkDaHn8wQreG2DMEYUhnLOp/oHF5aPNOzk4u8tzRi9wxfTMDYsrlglzXjNIpSbaB7B3tV5+hwRA98CDcXOOeegq1f0B3ZpssgFS0dNZwvTMMQkcofJ7af5GtwQYPZXdxslwQbYzwQ82ib/CNZivI0KZBS8MoGWOE4agrud1K4iBmhCYe+Zh+ip7ssVjX+LMbpM0JXhvQ1kv2BlOmWw+T5xVBmBCPQnwMrekwMqDqC24eL6ipsF1JYx2lg8EgQowy1vmaWwdXCfSYrWGM7h2hNYSAr2LEcIJ2GWsZU0qJry2BcxSrkpN1gRqMGPgl2WQAfoefxbRGsl4umMQTJJIoC+hCn/KkINoYYW2PlD5K+kwGIwaeAiKESlGRhy0qklFCKz2WuUQ3LeGpRJzAH6DUgq5dkcRb9M4xVoobh8e0WpLGU2ocURASakOAI1SaUoToWiMiy3FVkkvFULRkXsI/eMff5Z8+++Ncn19F+B7ndy7h9S1Ga5TnEXsx81bTh44sDGhziexbZJAgsxR9sobBhGzYUl47ohAJwkQIuyYaxohwi9EgQnzj2XPO4dmCUIT0IqAxhlhYKtuz3+QcFyWmhumFS2TSY9kZqrojDBRt1+CFkod3HuZrs/t5dvYyjyyuEKy38Bdr4iBidPdd5K9X+OaIzrSExqduG+JhSjcvGNqCfrWi8TJ8gMxCW/Bt08f4wPa70O/6z/ndwxf4wgv/hsvNPtf7I27m12j+hDKQ3vV8/vgJPn/8BA+k9/DXj/4Of/sdP8xoGFA1CX7nofqWJNqgjUf0WjBMK8rZLW7PS+R0j7Bf8kJ5ixCPEEFneqbxLncan/2TL/OK9NgJt5mKiG8/9xGu3v6nfOHKZ7nv3BaTekJgBGMJQzlmlt/gwXM9TXye+eXL9KpmEhiq28cMNu7Ei31mt+fMh5ZxljEpOji3RV3PaWRGe/+DxC+8ip/nrJXPepWjyho5CVHZkKJeMYgHeOsFVTDCDS9i+wOs8wniANMHtOsWxrtAg/J7jI5JV0vaJEDXOZGCbnuT2bEk8DbR0rHIe0brY1TS49WC1eIq1vTcG+/Sfv236LqO6P5z5MdXaAIPVy5xqxx/uss471HP/g7NKy+TvvEGwauvcuHJZ1Bt+8e7l+fO0m1s0v/VH6H5ju9gtliy+XM/A9mA5WOPMVjeQqgtNkYPcOP4hEX+HHHyGL0Zc/elc1y9cZ0DmTDOe+TYEg59vAKslbR1z2gY0XqSPjqhW87w5kMmyZiFCPEC0GqB9gakMqVpSpYHOcm5IZ3rcM5hjaMoVoR+CI3EtB7pZBOjT/A8UMMzmN6RGIVEcFwvOJeNmURDrA3p5yWzwiGL2xg/ZpwNYbGkXs2IkpjeP9WR1rpmlG0grQK9xH/vY3TXrlO9/x04IUn8IVqsSKyhE47jak6cbLM3HhH4PuVyiRCKJB1iWaACQ2glbQ1KQlDXLKoaMRnipyldvk/nalIXMApDyj5n1cXgEhDmVKftHEEQ0HUdnudhkHgyQHoRrWxQlWW0PWYmcrq+Y0slaFswz1fEXogIFUIIjLbUeY3XgZIeVTWjXrX0yYD4Ez+I+7F/hfe5z5O9802YD3+EKAvwdEtcrhl6W6A9tOmoWx/PaWpt6WyD/PKTp5tX73o3SnoY152+zWGG2n2A8o0nCfR1huOYbrBJ3lqMNsh6QW0SciOIIo8z6YCi75BNgS9iCBKs69BCkJY1fRxTWUfkawbDlKhK0V2CseApsLahaAw36pzhZMgF2+GO99HRHcyE5Ohd7yIcDUmffBL3cz8LP/QJ4snp2nAsJIKWcTxl10u4Wl9nuHEHUin6vGCanGPtNINuhg026fqe8XhAnVd0eY1UDqVqur5H5o6B7ql0w0mvOWsN6XNfp9jbRn/oW9GtZm00Y98ncJaFdJws90mbFdGNnOjsNuaOsxSXplQf/zB4IZXOqZ9/leGVBdHTT6Nefh71yht4J7M/0dgdHO7D4T488UUAdr5xuCCgeexhmve+n+YdHyD76IOoXhA0PnXrCMuaLNTIJEYMpxzmLbo+AFNTqYA66PBJeGV+mb4uidsab3QOz99Eip7E5pTNGiklR01HVJ16FWhTIsIB0lY0xRoVxnjWEAwivDhj0eZkUcCsERyrnKkUDOIh2cYZgvVV6qe+TL+1B3e/laTrSfemoI6YFg1V2VF0mjid4lKBdTndokTagCav8bqGodtE55ZlvqSTNWe3LhEIH6SH/0PfR/d//2fIz3yWjQsXWCdDWuEhloenRXPnUQmLEgaBwWqBkI54FHFS7LPq1uzaPZDBn+he/VnDXxTYf4YgZI8OOjoboPSKKM2wTU/UNoR+RKc7AgHz/TnDIKbvS8RgTOQFBJHHojqmKjq0N0Z5JXa5YtY5ZHWCDndQviKvc0ZeRBYOWZc1eT4j3fSJPYnwI6qmpeoKtpKYJNBIGdE58MMpbb0AtyIMLtBrn4VdYXGkzseYjqAI8KiRmSD0DWEQsp4tEE4iMXhJRDxIub3u6DzLHUpikjFt2zKRPWV3QLi8yjiISZ2iLFaYpsQNYtIgJfYC3rv7Tj579Uk67ybCn3CiLdGqYl0d47mAgZLUYoM69mgXPaEMea14iS9ce5rX2ld5dfUir68v43D/UfcqkhF3phd519l38siFRxm5kHuTizwyuYg3HaMIuHywT+TF+EqwqG9wOL9MQEsUT1CexzDJIIvQ3oqw8PBlxijUaBlwuLxB0kvO796B7zredtfjfP75l/nFG59D2o6PXHg3bzn7KIftAZ4WuCCgyDu0gDjyiVYWIxxxGiH7hr5rCCNB6P3BnEFjWgSW77j/o/yL3/sXfO3WE7x770OMe+gCRSsqMumwR4eUl1/HvPlBNqdnOL7rbuwTT8Arz8HkLXQuxcQT3LCi71pMm/H00SuUuuF77/0Ydt2iZURASONH4EBbQ2d8lDJYcaqtmkRD8qbkSrNiOjyHCyShvonua0RZMxpewHMBnrfCD2rGMmF78xyzRiD0KTuzOxqTqI7GtDQmZdOtUXVDFPkMts7ReSm35zWVW5PoNVr5VL1lezFjKKcgBE4FNH5EK2KEETgnUW2FCxP25wXLoqWb50SDkOl0xHrWMQozFv2aUpdsDjeZ53M65VBVDxqCcUg3q+mKBgKNlCG6LFBJQuT5COXRZwnluiPwW1y+Qvgt4zCkdCmyKoiVjwhSomhCVR0Txx2N82nbirA3xPSkroXhFC0EhbG4egFGoF3AynSEiY9Yz9jeyOiagjBK2Rrv8p99y9/mv/nyP2Wc7tKLjnk3x+WOyXgL3bZkKqEJLNbvEZ5PVzREKcg4RgYFrqwJQ4VoF5Srnq17zuDnC8q6Q06SP/DsNabBFw3TKGPZN5Smp/chkBItYjaFRx7XHOsV57wBaMnspGQ89vA8j2SY4Bx87K6P8X994lU+9cqv8pcvfC+jpkWeO4+LAjYu3ENuLGVbEYY7CD9g7ULCnUuMkxG3rl1GGEW2HbD0UlamJ9k7T9N05LXmzeO38y3vvJ9Kr+lNT6g8yu4mLx+8wL7tea084XZ1gyury1zLr6HdNycdebl8jf/dU/8b/vNn/o98/Px38PFLn+ADO29HlA1KOLzhWTpPIeMB83zFyfKQt6xeYSdxHJuSeR+xr2M2bUzkpcRH15j20ClHU1mWOHzb8/6z7+NXlj/HL+VP8iODt2FET1JWjOSQg7VhXR1yfvciB/6A5XJFOZI4WxOEHVoOWMxukk1TNm/PsF2L3J5A4LGoHeF9D6Nefono8DpyMODq7dsM0xR/vMWiEmjdsOEZbBPSpSme16KbBZ6/w6opiMSAaDCgb1tUOsBzKwQNrumR+jWK4ojhYJM4uUDjImamJsgiQrvDKPGg0yybAhVHbEVDol4gr12j2NljcXyCffLLJK/d4LHXrpHeuEl6+wi1mP+Jxnq9s0v1+Dvx3v8B+re8jSrfx/ulX0cFHm4YkL52APM1/bvfQxApbODTrGqEaBhnd0C54kZzm41kQmRadjPHlXDIjVnHRlwTjjOMBF8ootjQa43u1amhYqagqulUgu8buqonCGJMlNDbjjJpkUXKyAyomoraq+lXlr4qSDW0vUSNAsLNMX1jiMWaankd3w8JrMdxMUObjmm6zSg85e0dIBYG29aUyZhi2aDnJUnfEm+NaXRH1Z9q0QfxkLq11EWOzhT1//Jv4YuOaTSk6wWe72O7ilndsTvw2BulBL6P7jp02+PHMcr3cdrH6BplU+LMxzUNflchk5guivGsZW0LwjiAukTGPmkQUIVj8soy0gVSxRitibIYW1VEccy8tfjOUhtHkI4Rsxzd1njDiK6r8ESG7XzybsXuKMZYR9t01HmONT3W+Gjn8JKQoR0SRUPiSYz4z/4u6//ynxB//ku097wF/aYHsGKG1isSM8UbZnh9x2JV4HsKlCCaHyCvXqe6706C7Yv4SpB3OUEUIISg8FNEdgFlFrA+IpKaQoxpihxRtczVNknsMVUlLsuoV4J1cMJGYKHpaX2DDT100zNoOw6VI7cl24NNZOg4mK05PrFsThJWXcv1ZU6I40xdYpZHeCojjROS7SlidUjx3vcgTU//pacJfuEXKT7xw0htSOLTjdJmlbMpJTeU4UrbclF0JElKHwQ4ImRfsWoPUS7CeAktDaas0K7HL1an0gydoDZTdryMW/sz8l/8FAmS5C9/glnd0IiODoNXe6zVijZJqPMarSva4x5nfbTtyE2ISrfYG2TUeoW9p2Nx9jzDNz2EiRWLQca07Nm+foD70hPw/NcQV67CG28gmj/ZpqnoOuIvf5X4y18FfhS7vYP94LcTvvd9NG9/K912iHENXXVq9na4uoWpF4y2dtmYTNmmg3XN1arl1vpldtNNvOAsnXGkYUQSR2S6oFgd0+saQU8teuKqIN4Y0pSnGxVxOEaYNYwmeH1Iu+xPM9Wlpuh6LroE50uC1GfxyS9RlQXVBz/KeDBCdHPkZIveJJy4jnG0c5qtHm6RO48iEYhlQ7Vf4mTCkJ5AlFSdx0m3IAkDpmGEWR9SzBb4002ad70N8dkvkXz2c6Tv/zBlliE9Q1A5pjspdThksWroTYmTks6cGrct8hPSwQjkn5+y9M/PP/lzANfVtP0cO9wgOJxjpME4j74oSYcJ86ZiWTW0RYG3LegdxPEIP/DohObK8QmxTZEqohEOXzYkNZR+hmvWCO2Rd0uSQmL9DIqGTvSkvkcWT+jxWCyPSeOQcbaDtS1al6yaGcJCbzzSALr1Ma0LONTH7GzsEJBQrRrC5hC1NaKzDYNgTN/GmKCj0QtW+7dp03MEO1vYRY52ElEWpKGgyBtMGFEuTkiVJpr6bChD3x6wqnK8pUe8cQd1lfOWjXfyewcvcG35Fd7z0PfhCot3tKJxmnnvI7Thslry20/8t/zu/pd46uTLdPaPx1D895GqhDdNH+T+yT3cG19kEtzHvJpzs3mev/nWv8u54AxRaMh1gRxF6KomKGsq1UMyJhGSTnboPqYoj5mOUgbjHZQD5wRNVLOuNaNkC2MtvhaMwoC5H9PqClE0NHlJMhhyYbjLfr7Pd5/9CPdM7ifYHFDeXLLKlww7h8YhY4/IQYDFhqcTtx+EtE2FtR26MwgEfhQBYG2FED4P7TzMmeF5Xjn4Og9tP07ahVwYjWlEw6Jb4n7vd7BGM3znu9C1wQ1TUKBfu4L/4Y8waxrqpmI4HrDpxewXa37j+pNsDba4J9nlpF6gwgGm12iRkXoBSgjK2jGJQ1pdY3SP8nycVkTCIaRBez59ukMQehQ3DtHGZzTYIJYp2XCA7B3Km9AuZxjtiLIA33QU62NsX9HbjrEH2fYWJTF+luFry9lBTKMyAl2w5YE3GTPoS6IwQo52cIhvmMKdHiYMcV2OJwSLSrM6OmA7DsgGI4zRhFEEzhGrmNzmGN0SeRF11BOFEtlKlBV4SlIdL4j2JJ6n6MslXpLiZwOQEoWkWLS4KMEGmu7oDcaDDfrxLnm5QhQLooEkCFLqeonr1iAnnMyXhFKh+gZByyA71Wa5tqRHs9CwtIo6G9GYitgsEfkhjbScTbdxzjEOR/y9h/8TlghUZE5bh8sTWtEje0saDchCj0pXDJMAPa/oqo4gCRCRT3n9CjZNiCZnabuGeJBgyjWNMQzEH9zQKpsVVrcYL6bt1tgwwiNDlw2iizm7PaaTjllZcuSOwGSsyoCtjSlxEv3+94xGG9w7fpgXD7/C7flLPBDeSzxMabsWhSQdbjLPcxbaMh6dpWordifbGOsTTLZQtkLWLSULfCXYGG5RBBUlDa7oSdNtPG8bN7+FtGvOqimXtt/BIpyACtkY+LRtQVEZbqwLnjl5ks+efJHD+hp1W1HokqNu8YeOLY2p+Zmrn+Jnrn6Ku7O7+IHtj/BDF7+TrXibUepza15y1MHFwYTt9SHUGZNsD+FyhNY01qOs9klFS7T1AF1bchRPuehv46O5MLzI/aN7eKa9xpcXT/HwmbcStYZJGDOIMm4tZ2zHBRd9j3zecZKO2I7O0RzdIpy0+JlklBfoJ59BCEfx+CPsmzWH830u7T6Gr0JWX3sKtX0e6Tp0vMGyFtRtQcKSOIwx7BKlQ5b5FUzREE4TTlYrUuCOO+6ib1uaqiSMUqxe0omc7uAKfbzBfrLBoOwZMCIZd4RqSKkdS92TzwrSgytcurFP+OorhE8/T/zcc4zXK+T/4d9vWvfNwMYx+Vvezvxb3sPeD38/s+GY/Kgg2dpk6vlERxXN3hT99eex3bcyvnqFTiryO+9hU1e0vsLO5/hJQrZzCScE6/XzVHKf5MTgjQUXxIRZ33FtlnMuCOmAC9OUptNYoZkVJZSG3dFZCg45XB+yG3pYf8JwqCh1zWJVoQOfwXTMWoNpHW6xAKHwlcVzEa1vySYJLlJgRjjl0dVzBuk2RV9QdDWb8cYfYIyyyGNLN5SJz3CcEBm4bS0nUtIVhsC0SGFJoyFrbSm8gNYlJFozjgyxiuhMSKsNQRiwf6skDCUboxQpT13Xu6bGoQiCACkFUob01QrpYsBiVmu8jQFRlNBaC31B3dekaYpfGWzroYKA0RDqxpBXDVnoY3sLXYdtKjpj0UGK0wXa9kzTixTF69TVbfzJvQhVUpUVyguIkhAhW9racnJSkcQ+k71tdOuo+xrPCxlPhlgp6SqNl4bIH/gY6id+nuBn/zXt4G8RXtzCWkVkZlh/yjBKOVmVKN8nCyvkU1+jtA793ncRqJiplOQuP80wtwGtcWxv7ZDPNa2XkXQ5oWmo+p66kkRnBmzG8tTVn4zIsxQuww0laq1h3WITiXYBslhgUgUqxlcxfirYFB7H8yXXj/dZVCeI3LIXjJDmBH9zjyDbgrJADiPGOqMu18Qf+lbavEC/+gbmU59i9Pi3oKRDBBHdyYq+mXFhtM3LTc1+73jowr1cnRWMOzAqoWzmJEFLYyJMEGOLnKo8RmWKIJ0Qxxt4owzVGsZf+mWa/X3sd30Xg7vuZv/yVZZ6jnI+OSAzj56ALJYoQDGn8xqiwVn03MesLBU1WkiqRqKPbxNFCdaN8IWiP7OBeehR5Ic+gt4/wDlNY3PcMsd77uvYn/hJODmG0Cc9PEbevIlw3zwRI48OkT/143g/9eNEUtI+9gj1e9+O+ZZ3MH/gEdq+ZiPd4tzenXSuo1rMSAwMVy21qOimDWV3g35dcGGyS+BFZFGEOkmIaGBiWOkCb3UbFXp48QaxLRDzN8BqEAppWmLbsWhW1H1N0nv0lSEdJSxffI7q6a9RntljtDcl8Rpa1SDCmNqNcWZNq0M29RgbKrp2gxNb4Sgpj0vGW2Oy7btwsaKe56zCMdPz9+GPxhxevcFqPydb9HDvg/DVF/G++jSju+/g+oN3E2QDioN9ulEN6TamswwmHtQ1Zl1g5wu8/ITheAf5Fy7if4H/MdCXBlt1cFYhZwFduSaansV0HV7R4bWWg7bGDxvaJiI0CSoOqD3H7dkRVJZ7pgNK31F3GYv5nLqDycXzTKsTalMRBTHduqV0M7pFTh+VtJ1kY2ObN+bXafqSS7t7CKFQKqFzAqlaPAu6OyIIYurljMOwpqhPuH/7MbLhHXTz2+huQWsMrh0z82CxXjKKBqBrVNGxMWqR4QAx76ExVH1NXmv6UFDHPlGUMNm6GxkG2PkBQXWII6NfLJHqNkXhI+Ip77vj3Xz56q/x6v6T3JPcA+GAmxzz6zd/lt+89XmeLd74E13/UAY8tPkAD03v4Z7JQ5yVd3JneIld5+HLhma6xSoM+PSzP43yFBfThOXNW8wCzfjsRaSuqPoWFi3z0TZROsIpze3ZClUPUcqQbg9xgQd5jVEtyhU4McIFMZ1ZYRpNkHgkLqDzBat8RmQ8etPyiUe+j7g3lKuSRngEznEm2eX66gaDco6ZTFFCEFU90pN0QYAxhiCMaeoFTZlTL0uQgo2z57FWY22H540w2vDeM+/j+vFVnj16gsn59+MJx9gfcNS0lM99hXg8IrnrAeqjA4R0uDvvob9xja4tyKuGlJjNyTa0Jzx78ARl2/GBux7DNg3bm3uc5CWdJ9AtZOkAzzhmpkVnEaJsT3PXpaJpOsbRhCQEz1XkKiFNU7qjDnOyIox8osRHlhBEKTkK2zSnhZwu0aVC9EsSL0D7KWGYkcUpXdmxbnpiA1HgEcchy9LhOcvW1pAub3GmwcOCH/2BZ6OXiuW6QiK5sD1hXpUMNqeMxuPT856iqSpkEDKMh5TVktQLqDyPWjTEo4S+a1Ceol2tEYMEL+7BGPxsgPhGRI3VFj8LcL2l7TtkqPBMRGg7XDoiL+bIYkEw2MD3h/T9EmELGl0xVBJpIrT4BpNqDbZdU2hB18PuYECKx60cRH6CzQ8w2+cpnX+6sK9LtLEIITiTbLBQki4vsWVNJx1OePgmoNENyoMslPRVg3Adbb1AYwhsxvbFKfs3L7O8fosoS3CpT9DVOBdjnWXVrjgubjEUimE6wlWSZeOYtT3K1EwnG0yGmqqTdEVAIQ7oWRGLLXojiDltMZ/lOeuq5uMPfwc381f57JUv8OBb3oyyHbYvKIxA+Cmp17BqG/Jmhcg8XANGWLJBSoWgbCKqoyv4NuG6GLLWsMgdSb/EyYRMSo6NYJgNkaHPRFmqdYOXjhmpnnWTM5/PeXX9BteWV7g72uFHLn6AR5NHUFJxc2fMb7z8c/zkiz/OreYPz0p+vXiD/3Px/+BHr/xTvuPF9/E3HvsRqum3kAQJD23fjTApRd8iBqdFcFTPef7giJGrGU8v0C/WNH5A5SUcr+e4zT2GoeKdd3yIl6/+BL/w6i9wLtth258S5QV70yn7szmH86vcc/YSM+l4qahojeCcVejiCoPhkLIv4PKrNKHkZbPPepUzAvpuH3HpXuwzX2H+zhkuywhVx3HZUR7eYjrQiGEKMqBcelw7vIkU0KuGZZXTYtmoKyaDEevlIUfHRzjhoZXCaMlIeFSeJHzuCtuXb+CfXCZ544j4ymV45etEh4d/ojH+D4MTgv7RN6M/+GGuPP44o8ffwusvHzMNIkaxj394wHY6ocSjjEPsRsDivh3GR3NGn38Kd/U67k1vQnoa//A6dTKlTcecHQ1Zryq6cIdptqLpVyybNX5yB0kaEV/MeOnqAbMrNwkjn81xzElekdclebcm8wISF6Mjj5Oyxy5aVOKjggFV/Tq60WxM7kCqCGcc1gWsihXhUOIHkl4rpNIkaYQWjmCU0RQduAAfyKtDMBnbm6ceCP/Wxdu3hrCv0dGAde8Y6Jo790Z0QvHGyZpXVmv224aLw4ytqGcchhCnBLpACUVPRtUZLJbluiBTAckkRsoQ5zp052O1RvkRyjtdTEsR4jqL9WtE1SGUh0gyIhyFsRTF0amBqT9gvH2Rdm5py5poEKF0T55bfK9GWp/Z/DY9GlvWmKbH80tCEeJbn2TzErq6ja3XBHgUTcV4EjMIB9jmhOWJYZIOGW1NkJ5CSsusrHFOkQ48pFLoxtBVh/ib26gf+dvYf/lj6H/1k1R/7fvxR+eJ3TFFdwjZWXanQ6Qrscs17fOv0J89g3fnvQRKERhJFEbM6xzlBgyigDQbU+VHNM4nSfYIyyPydY5M99gaR8h2iRMK50KCoCbxhvTOEU4bZFVgizWNP0LnJZNgiokzVtqw4SviyKdTHscnB0T5nAGbeHGFt7FNML4ItUaENUKXJIMB+WpBbzTTj3+U5tNfwL38CmcOb9J/+NvRj7wZ1zd0/Zoo2mXcl6yspvFDwoE9JW+qkL4L6DyLaBck8QRjY6RKKYRkgkfwDTa8+/qrBM89S3fuLOu3vxVT1LRti5Aa0zS0G5soP8BvS6bJmEUwJgCsaOgDyLYSUjziUGF1T9/F3NQROl8RrA1RkFGHNXVVk4gQubVFMd+n3V8ikyHiL/0g7X2PUv3E/xtCy/KvfYLDboi68gx7t66grp7g7R8SXX6N8OoV1Gr1R44pwlqip58levpZ4J8zGg0p3vUuwu/8bkQ8oBgJvKKAeJuNdItlBZ4dIH3Fqj7mQJWMoiHShNiuIrQSbzzF6oy8OiTKDxgPYkxdovoWkWyA8hAKlCdpqhaUZLuUVGVJkPrYX/4VtGuwb/8Im56hrq6hQ41zAmXBjwIWdc6GyxBdwSSYctjkXDvYZ6dVqNAn2Nilafcx1SEyuQPPD6mblsXtBVpmLEKHjGL0h9/D+Kd+CfVrv0orv4355nmytmW1P2dnsEkoPWLnsMbSCcHR/hs03RIZHLGzeY4wjP/Uxvf/X+IvCuw/Q2jqHJ0XaKtxWYDOC9ymQJcO0be40NGxQPgeupZ42lEmIbqucOsVe+mEwcAhdYvuFWeGMddOGg7XDX0LyuScOXuG4qhGa0uSpuT2CN2PWC0WFPM5SRzhKYUxDVKGlH1J7A9oGkvq7xCGjqJb8sbJ19A658zoHHE6Rh0vkekCqwbMT0rqxpEpD0yD364ZeRPMuqVLDNprSf0RWRZzfFJTK4UQmoknGGYR9AK7bgiy8yTjHbqDm7TXr1N5G0ymu3zn9DG+9tq/4adf+llUvMFnrv42t8ubf6xrrYTigY37eXD3zTyy8ybeFt3FI8ku25MdOgX7NdyYrYh9iV9VGG9CMTrHlrQc13POJpdQixXQ0QhBXx3jdEFb1vR6TJcGeL3jpCyI5BDbz7GBQAVjijYnqda4FCI/Q+gBlakJRI/QlmZWkiEQ8QadnjHemlLmC8IyIPYk3WCTTleYRhOWPsEgYW0W6DZlN4nx2xYRBZgwRGtNFEUI4ZHPT5AE2N7Qty1CdYAE55MvK+4YXeTOrTu4Mn+VR8+9g1nlMfVrxPVjgqbDve1tLOa3CV2LCSLsXXdTvf4y0dVrjHbvQ1kHYcR6Nefpk2c4OzjHntkElTIYTjhcrFhHPomThK1BWAh9ReEcwyBAdx2lk/RNzzidkoYGUR/hki3WpqcIU4R3ukBMEkU7P6bWU+Z9ialrZBqTyZZESXrpIZNdjMjwvtGaPIw8jlcNprdsbiQoKZmkQySCXltmnaDTmqBeItQWSIVzjrIzVK0BqRh5YHpNl8SsnWPswFMS5QfofoXvBwyjIX2+oHE9qT+l1CVRFCETH08F6Ftz+jk0iYcXBMjg/8semd7ipx5CW1azY+LxFG+wickLslCzises6jmTYkYQDFkWEikLXLdCq4zBeIvaLOm7ir6tKLuevvWYpjFxmLCqe6I4QdUx2EM2fUkaBNRdR951oBSRMwgg8zMWQYPNa6bTLYI4o9ENQggO6xN6HH5RUi4gGSYkmxdwqw4nQIQB81u3iS9cRGUpdbliqXN05FH2JaEWjNNtbB8iqwZhLIdByV7gM4xipLS4psYZwe7mOU6KY/J8xbKMiUPJrMyp+56NwYBRmvCBM4/zy/Nf4on1C7y//zZMvqLLpuAUWA9fBhhR0OURh+WK4abEWseiauiJCZyP7Qz1rMSXHRMVMLEew6ADz9H6CSMLrZKskm3U6gqm7Wlsx74T/OTRF6lMzgUZ8p7xJfzkTpooIA032LYB/+DBv85/8sjf4guvfJpPvv7z/ObJF9Hu342c6Z3ml44+yy/9+mfZTi/yl+78Ae598IeI9G2Un7Lj3UHnoFj1DFcnnA1TpEq4wYpmNOZSNqTqHLUpGbQ9MtnjPRc/xi+/8dP8/Ms/xV+596+xqSS2alke3uLZvmQ2chzYQ55d7JNXcwbdMW23xA4tsq/54PWr3Dy/yUtf/3WMShhh2FaOcxfO0H49xju4zN5b30pU5ki9Jg0NZZ/R9x7pJKKsCow1bGzvcLS6ynzpk4wSXtl/nbNmF3lygnv6FeIrV0muvIT/+uvIazeQNw4Qff8fMaP+u3Ceh750CXn3XaiH7mN18QL7b3876T2X6GufVa/oThpgwHgwxOkF0Sggmoa4asbtpkNGEJ45T5Dexr30Crbr0I/cw5bXUjYRoo1xwwENDmEaSqs4k+yxXloqeZ31LGG6cSdV4HFH5rFYzRl8oz3bDz2OmwWu7hmEHp6/RtUZG8MzFNUxyWqGSzPoK1AhgT/A+B5oQxKnzG2BNmumjaTpLal3uoEA4KcR614R5ZJZ1yL8lKTuieqahfXxlGSQBoiyIAwUTg0pqp5jZdiO99AO4jBnpHum8ZBASvJGY7U9zXHuVmS9IHeO2hqsrokdjHa3qOwS7QTW9uimQioP5zykJ7/x4AModDnH90fIJAPriHzJvF5zWB4QBh5huMVouM2imlEczgizmDTx6XvDom5w1TGqd4z3znF7uaRd77MTBQQyxVM+Mo1YmxXV7Bg/3cQGlsZ2eI1GVw7nOfxhivzGnOGkpXUa0UcknsIpgQwa2llJMNwguHuK/sQP0v/0v6b7sZ8k++v/c5KdXbp+TtHN2Y5H9H2N+/LzdH0D73gnUgXEkQe1ITAhRVOQBQ3ZN56BeDihOp5j5BZEu8SZz3B3G4UB3eJEhjEG68HEjyg1aCT+Zkd5+4B6fYsgnTAwPk4IZr1mUVW0dYWr1ng0DCfniasO63qIJrjWIDyFjAbQFURJivAE9bphPMngB74P+cSXqT/7W3g//dNUX3uR+D1vRvkhi7LkwmSTm6bjpeUBj4zPsmhaqrzCN44mSJkMLSEFxhP4LmS17Eg8hxf62HWO/tSnEFlK8r0f5/ZyyUnvSAYRXt5w4tbMZcQZkbITFiTJqaSrzAPOhBsctx2dVzANh6eaftGSnDuDGfkcvf40YSjQRUNrBLfnB4zTASIU1I0jyjYJ2gKvLHEP3sf6u7+T4Bc/RftTP4v96Pez9/jb6f23cv32Ef1kj0mQcm48xF+c0H3+C3i/+duEn/9t/Jt/9PrTX62Z/Nqn4dc+jftfCTYeug/97ncgvuv72by0A+kORetIhU8nM6yQFF1HuTzBMwJla3oyVJpg3RaurVC9xtBhpMHPtpHeqWlio6GvBowGY8TJMSUpy1srov0jyoffxPTSo6ihYLZ6BZFu4iVnCVYrQr3gljYc+jXblYW+wV8eUnYOvbkNgxF1OaepC2Q8JJUW5wSHVw5YrkpENqCdrZFBjx1t4z/6ZoZPP83Zr73M0d0xWitsMafObmHTMeXCI+9qjsoZXVWxuXkXobeH/HOiv4Y/hQL7xo0bnJyc8Nhjj51qhr7hYvkX+OMjS8eoXjM/XjDIIsztOW1R41uJ8SWmafDdgkadJ2gcjdezFQjkyZoIn8FkQGtOMM5ii5owGrI59pnrkv2mZxgoNjS4rqE3IdFAMUqm+PEmZVuTehFSW072XyfwQ1w0ojU1cTSmnK8ZhgP8AdhuwdGtAisDJn6E6I9JAiByNMKxrh0DV7LtS+b5CdrVbG/dj+hj8kRQ4Ijqhq6NsGVONt1inedksiWWMc46VlbQDy4x2NrlVr6ivVWxdLd44vnf5Lf2f4dfuf55KvPNtX4LBPeP7+OB0Zu4lNzFhegC7z5/P/ecu8RxEFF0Na5qaT3Yrypk26K1z2Syi3FQtfuY1LIZanQ/Q4WSuwd3EUVjBiPwnWIy6GlXhjqAPOxoWOCrlvFQsK0yFqrCdRrnYtryCNOXjKMLOBxWO07aOSOlSYMEW1t2plskfsS1uuAGBTuTKd31A2ZC0g4zYhkS1Al9l5NNR9zuK+KyIA0CbNvibQ3xPA+tT9lMpy1NVTHeHNNVFXW+JBwIBBFtZej7HhXAt9/7Ef67J/8Zzx4+xeaZdxFWa8xLL5GGGfKBR1nmM2YJLDvN1oVtIieIrhxgdt+E9lq0NfzGtdO2/I9e+hY2+oBGZDTGooRjgWU7jbCzOUJIBnubLKylkx6drk5ZRgtpGrPpd8xbD6lAdYaVgEQphAzx0g206SlXa1iXxLojHAhCI3D+GOQY4w9AO4JvLDA9JQkRFMZhAMWp5hdAehLPVzQ2JTYlXrOiD8es6x5tHUmgiEcJbZ5jnMfumS0Om5aTvGZnlJwyG1oT4BBCkBKxUjUOhxKKoiuIfB8wqHGMKVuqomR0fhNnHeIbcSy6t/iBwoma1mpSO0T4IWqsMKsVA8+yCscsmwVJO8c0HlIc4tVz9NZZoo0dquOCo8UtfBWitMdm4OOPRrR5R9MbQmlRk21WsxMG5QJ/dIG+a5iEAfFgSLlcnGoZgwhlJSUdI+sIZEAYhmR+huckx7MXiDoQ8XmUyhgoRVc09KsVSehT6IayKMlSQ02FWPfEagu/F4SNR65B+DVBALZaUzU9a+0xVS1N3+F1hmyYkiUJvq8oi1vcnu/TNgO8NGJrPCELA0xR8LbsPp7afJYvHX+JR7cfhKqid5ZyUSFbaKWkr1qUMXRBR1eVTCYj1r4iVo5zfsIbxHgmolmWDFVHoIYQaqSDJJ7iZjOCxnFieuJoRBBWfOrml3ny8hdRneE7L72ft22foSmWnJgYXxQYAoLjDhv67F44w3fc/16+ZeNBDg9v8emTz/HJw9/ienXrDx23jspr/PPnf5R/+cL/jfduvZVP3PkRPqRD4vElgnXLdrpFP/QY1yuS8Zgm9LFegO0ESe3QXYU3yLg7usijJ/fyWvEa//XT/xciIuq8ZKlPoPeIqjdIrKDIS5ZdTSwM52LFTrrLuQPLmYEmfexR7t97G4e25ys3fpPP3H6C7Xs+ziDMcK++TvT+t9CvNaxmjMIBpvZQQYw3iBH1PlkcM42mFE99iYc+/wbjG7dJr7xKduM2/jr/j5g1/3CYLKW97wHE3Xdh7jjP0d6U1bkzTB9+G2e2t2hKjQiG9Ic3kLokP1rTuBTlZ6x0z9aZjPFWSnV7QbJzkcoX9MGKYdXR9B7KBohL2/DKDcwwQZwbE4QDumyMmJfQG1ZxgB8HyLxETFIyGdKpLcr2mJP1VWywTdJV7IWOolii12tqr6Y2HZHoEFh8meBFCdskzAPJYr6PvL1mM/NoIw8ktNYhhSARgmgYMF9UDJrB6QbsRoh2liBMaWwLkUfbCroiJ4juojW3sItD/NEWWsZ0eUVgNFHss15bat2xygJiIUk9SeY7NqXHuSzhzCBj1WmWrWZmJLbzyE4WtJmHR08mJEk6JEw92lWONobeGWxvCNMpuj1l25x1uM4iO41xLWo8xLWAcQhPs86v0FiYhGPScAJAmIRI5dO3HUEYEeUdh22NKNZcGJxlkE7RRUUb9Ihli8sS/EmEixQmHlHN52xEJZVyHM0OOTuZkkSbaH9NaSusjZFS0JoWfEloA5R2dGhiKhQKTUQoPdQdl7Df9zHMT/4b5E/9FN7f/9ukXsZxW5DbjshC++Qz2M0N1P0PY5Ug9hROWVarlixO8P2W3vb40idOR+RHR6wP5oRbU0bnL+H5Cqr5aT45IVp0SClJ45C+6ql1RBYNyKPryLYnrC1dnuN1LZHyKZxDhh7J2IGc4BaOaBCS7eyhK0OtV0SbY1SQQlci+hIVBNTWIa3C88G+9z2Iu+5E/vpn6Z95GvP1J5HveSvNhYts+wk72QavrA5ohgXWhMz6A7bCKamBLBiDzkH0RKQcm4ZOSKyxtJ/8ecw6h+//S7jJhGixZGl7wtjDHbeocIPGdUz8mIQU6wmmyqeNp6y6Hj9ICXEU/Rov75BpRrw7Yaor1oMRySjE1w1+MkZ0gqqpEC0MpxOycYa3uoptlxSrnvKu+xGPvxv5m59m4zd/meh//fc5KnNaZdn1DXEypmwEo81tVt/2bprHH8f+7/+3ZFcvM/7SFwm/8Hv4Tzz5R+q6hXNEL3wdXvg6/D//XwCc4XTzzw4H7AwGmNEQMZkwjGJMmtCEEd1kjLczRQ6G9Fia7RHJ7hZ6PEQ3rxGMztJ40NKgvAy3NvgOgsjDfua3qaVFvvXtTHYG3Jrfou9hEiRYHeEpn6EuCLqG1zuH63qym4esKTn38H3Y1pG3JU3bEAiFTDdJbU9+MOPw8m1SCRsDj9BuI+KOJRr37e8lOrnN1hvXaM49gr33fjbNil7AvC6p1yWInthv2N0es7FzjjjMkOI/zh/pzxL+xAX2z/7sz/KP/tE/4vLly+zu7nLr1i3+6l/9q5w/f55/8k/+yZ/mb/yfDLyAU5ZptWYtPQatpmuXRINd1m2Lawusb6htiO86tmNBsFiy7ltMpGjdCmNqdGvwLJRsMBz61LdvU4macGuP2WqB1QaamjJWjOINjruayMXspGco2wN0J1C9papP8KKE1XJOuygRe1PW5T51t+Tm7IhxfIFEbOGqBcmwZwkcLm4wlg9wJvYJU8FUjNF+ivUaRNsglz5EIXTHFCuD8D3GoaJeLTB+T91NGbYtXjrg2A3YP3iFT736M3zu+m/x3PoFjLPf1LXM/AHvO/thvvf+j/HtFz9MOA84rgui1HDixUTVIXY9Z2v3LGEHvS+ZTDao5zPWByucVzLc2kX3igOpCEzDnd2czx29jOc0d40vsY4GCH9N3FjaVUGc3cnmZsbXT27R5WvO+g3TcEJR7OP7gkyEVH3BsG/pVUDTa7pO09UNlas4O9wikArXOQYqQ9Q5QRKyNDUIR9VWrFDEQUlEhLCWJItx+CzyG9hySbHuCRBEVmE7aJse168xxoGV4ARhOqAuTvDiIU77OGewssdTPvefvZ8Hrj/AC/svcjO5hzhoGb/2GsHueUQ2IAsq1oGmFSVy806CyRb666+h3vERgiRkf3mbJ4+eZyfd4IH4LMPJBgsZc7IsaZ2hNR6ZEDircUIQYgmkoLGCypxeR88PGSYBsi0YJZvMnaFtSkIkLkvobI/uQI0uYOwMb1XCKGU4mmAd9FWOUAbdSSQengtB+Vg8QinRkce66dlIg993tZZSEIceRWfoxSnjWpUOL86YpgG+kmjj0a4Kwskm0TBjqgSLsmUdBCQ+CCmRgDMGz0mydESlKzI/o+gLJKBwyEhh8xbnhVjnY4oO4QG+wlmHUoKuXeJlKVKl2Nqcst/jMWa1YmhrFmrAYnFMWB9j/A4/CWA8ojSWUkSY1WXGw0sEwsMbjQBBUWuMrhlmPsQjRLuJyNf06xOsFkSDITiBEBLT9yjPI3Qe0XBIbRrCpiaIE9A9ad3SipRgGBGOd1gdrylDAX5FWDcEvqJKBHU556y4k2xzC7XKyauW3sLAHxFubOJFCo1mcVIx6GOMipgOYljlICygaYuW6XjIUAS8sjjBSMtD21OyMMBZS7dc4gUxH3/o+/mxl/4ln73xG3xo9Fba45q6KtncuACmxLmAnWnAaCOl66BzLTL0yVyHlgkSSSUCvNGEaHadUIZIHSA6j0R06EFEZhP6quLQ3OR3X/oUb5QFZ6Iz/J23fQ8pK/xA05Z7KOVTB6fP8dgc0uoWYTt2NvYYJSOSZIe/MbyX/8Xdf58nFr/Bj9/8NF84+jK9/XcZW+MMnzv6Cp87+grb0X/DJ+76Xn5g9zt48K63cTw/ZmYNXhKzKwwiSWi6lr4yHNQWFx2yHTh+6Px7+bXFgPz4CiN/wGj4MCeqxFQz4sFDvHm6h6tg3wjM4phLkWWa7pBdf5F4y+B96OOsGPJo7aHXt/nS+lk+O/sq3741Irx2FTe/zVoMUVVB72m2JwOyyZBaGI5vXObsb3+Oyac/w5lnX/zTmSw5ZWa7c+co4wTiEPlX/grL3T16tcZ/6K2IzbvpY4s+uUm3XiGTED8IEG2LEhnF1dnpd5iKyvNwQ0nqe1SlYDxJENWSrjcsXIcXegyjPbyk5eD2bZqNAd2bJOJkQfnwo0TxGC1ThlFKE0HVt8wjgReEBLKlWebEQtO2GbHXcHTwKummZDcdwGBIefkNjm5dxu1NEF2JEo7xxlmaZY3RHuO9FK8L+Pp6jp0vmdqOeHtCLzu6XjLwJF6gmOKx0o5jp9lxEmlCEBIvDFi3C3TbUNuYVHu065rBdAdfFoy8mrWx1KuOOvXQvWbeWaJvbBL4WAZK0SQeWZnQdT3OGaahz9D3KIzPzA5Zz4+Ii0Mmo02iYAgC/PC0c6fqazrX4fsZAoWQFikFttaYskBKD9IBTmqECtB9Te/W9F0N4YRAQexlpzdfWLLhmM405HZFrxsyOaTVK1ohWNY1fW8ZZlss9i8zchXBGYHUgnWjqEWEKQtqetZdwK4NcIFHGibcWB6TepbElzSuRwifNPVxnaV3BabviLMxfRDS1hovCDDnz1B9x0cZfOaz5P/sx+CHvos+8FgFPe6pF+mrHPWhD9IIj0idzhMLa3HOsRNlrJ2h7ErG0RglA7QMaYoVg7MbeHoNLvp99tpZR48h8AIckISKo7xh3XdIL0OFS6rDY/R6TbS7ib+7RxD4YNdIDdNeMtcldniRKN1Au5beNLRVjjEhoRdBWxIpjyYKaaoGP0qojcGMRgz+8g8zm/4m8qnfht/5Mjuj19AfTYjf9Bhn2wGX53Nc6YPz8SeSTRFj8wahAnzRoxqL8iUGyfpLX4GvPYd78H6CR99EHIQcL2dYu6ZqhhhihtGIaSLJuxWbo120sqQqY3PccH3/kNgaLtiAuiwpXH3atdZ3eKZjY+MinSpp+yVudQLJhHgQM9neJoxirLV04ZCundGJhrHvU7/93bSvvcr42mtUv/JzmHd+mLvO3o/q14iwJl8pDldHeKpBGJ+JFyPveYTuzY9S/I0foG0b0q9dI/qVXyb8vS8RXLn2TY1nQmvUfIGaL06TLTjN6f4P4b9vWxt949j2fZwfQBCghcT1HSbLUL/7BVwWcd4piGLkIMKoCDUZYT70PvTb7uflZcVJsabUAhmF1CohVj2r5XWS0Rk0KW2lGUiPK2+8QtML7rpni8mZAf1SQCPY9hQ3upLVt72b5Cd+kckzT3H53B56kOC6EjGAcTBA6op5c8jBasGV6oSl1/E9wx9g6I2/yVngzzb+RAX2Jz/5SX74h3+Y97///XzsYx/jV3/1VwH4x//4H/P3/t7f40d/9Ef5h//wH/6p/tD/KUDFQ4bTCflhQT5rSHxJ2x/TB3vo4wV56rE0MSPTMQx8Ajpm8wPyVJJ6A2JP0uiUky5nEguarmVjOuKga+llxzgeYtqCxhlW+2uSYkIaO3TX4fsxHTlS+pgwpXcaiWPibTCrFwy2N0g2Q+ZrQ+4MqzrnYnYnei2Im4bc11TCp8hLfHGTfRcSeAN2z0yZjHZotWXtz1jcnrFf5VydXeVgsU9BxfrpE2btPlVoyZ9zrKoDZrZhv5px0nzzWrs9f5MPnn8/P/C2v8WF4FHOpRmNNSyPVsjiBCKP4XhEFwwIfEOV30ItllgpCcMI04KHx3B7TLzYx1+e4LItBpshJRFdVfDK9acIvYD77nyY/eWcoeiQ62N0vE0/2MZKRTyaErc3GbgBRqc0bcPmZIJX51wvFsQmwAaSeXFMFu7h1JIsTPDDlLZcMRqOkV3PulyTbqVsmSGHt14nTANabfGbFRs720TKoLyQMNnCtyt8bajnK1SWITwPYS19q2lWOWEc0Wuoip50kNHWBWIRkQ0Vna1wzjIYDFBK8e33fpjnb3yNrx5/lV2zwUZR4r33Xtq+x58kjLwMlwh64XCX7kR/7RlUviTe3uVnnv5Zat3xwTPvZOgU/jBjA0W5XrLoBC60yKahDSTCWvy6JssybvWGxli6qmR6ZkokHViDn4wYOMOt6gbKBmTZNs265NatGduJpbcdWg3wz19isD2iqSqabk4aBnQ2xLc96Aa6Et0Y6B2TQciyhsKFZEEEno9QktCXzJxlf+1Iw5BM1aTx8DQzBmj77tQNPAoQUpDEEW2vKZuWsjL0VtGVLY2WmKpFhClr3bNijUQy02uCRuLo0cuaYDKgag1Bb2hPbqHCmMnuHsoUdKYnGU8RWqGtw6s1MvVRkwl2vsBfLGkbi3AWbEuajultRWEChp5AO4erW+TmBiIIqKv+VH+WQJhmlLYi2ziL279Kees1wvMP4/k+Ju8QWmClpqtrPOUzHmyyyufUVQG6oS0WCBWwuXsfZXVALBRhOmWlKxqvQboGbQXReBuVd8R9iKwFdeOxPtknTTzizRHSOlzZk7crUi0pKkkbaurFnAQFg01C2VGt1hQHCwJdkno+XiApmjVZHCLyEt11qGzEA4Pz3D97mOcuf4HHsguMvEuokWS6lXD96gnCi0iyAUr1BGHCSdsjhcWYJUW0he86Wl0yiDK8ZEjqB/TLDs9z+L4kT8dop/jyi7/IV46/SOhZ3nvpW3n3fd/FVgLlyStYF9DWN/GMoIkeZrBxjq1LDzE/OaCzHb6IiDKPHVtxo7MUjeWt4we4hy2Wj/4X/Fb5Bf7Nsz/GtfVrf+gYd9TM+a9e/Bf8Vy/+Cx5/4a18ZO8jfPSe72FLaowEKwXng4Dj40MWnSYwPSIcMR6f5fvNCJ08RhcaRsNtnt/fZ6WfxPMNIt1iKAwD23G7N7xRdcS+Znr7Mt5wiNx+CFmtiZKa702+m/3nVjxx+ML/h70/j9Vmue/7wE9VdfXez3q2d3/fu3ITTVISV5ESRUq0KcqjWLEnso0INgYzNuJgPLCDAP5jAgEDO3IMYyZIjHggZMaxIssaSaa1WpJJraRJihS3y0vey7u961mfrfetquaPQ1GxKVsWrcSI5C9wgIN+ntPdaJz+Vf2qvgvXk+u8ZqjIv/AI8+R1oqhAez3TiY/8tY8Q/uP/kbf9/M+h+q+f6j1mGc3jT9A/eQf/1a8lePI1lPtXaZ66yqA1+d/8b+n35sg/82cJ7j1Dwhw1neOpkd3Y0lhH0lj29w4xtqLaCbSf4MSIHXs8YVCZT+8JtLncGdRiYLM7p01iMqVYJnsoqajLLdEg8JcHrMQO8Sffi0STCA8VxsjKkiwyXC/pVjuaKGAmFeXqAid7ZBIynT2F61e47iFtcpPJwW1Yn1JX50SrgbapWExvkEYh9aYD6WFwELYs95ec5QPnF2uuH0KnBtzgE/s+KgDROqbO59xZ9n0wnsDrBUVZU5RbRquI4z0Sv4R6IAtSDA5PSUS5Jq8dvp8RDwP7aYxIMlzYU409kg7P95mFM4qmoDc9nvTwpGAmPYJswvm6YuoNJKKjq3OCr3hUBEHEZnWBH2iiRGFGi/IEzjhMUcHY4S0mGL/H2g4wjP2WamwI9IRGhSgl8JS+jCIbR/w0pMpbimbHUsbEY8RWhzyqK8qThyA85jLl1Ph044BZbzE6YlcbGjEwLWFMfOq2ZLU9YbaIwRjaruT+pmc/ybhoV6TeDZKFpqsa+rrGWoUXh8jQoy46rOjZbXeMjz9BjcP70IeQP/lzzP6PH2DQM4aPfYwuDIhe+3pa60gkrJqe2liSSNP2BoKIdZfTDgW2V/RpRtuu8Dbn4BmEOcPqBOcEg+hpMcS+QPUjtu843Z5RVzVXkzm162GvR9Wa3lhMU9IJhbQd87zFdhXp3gFGTxnqAaU94tmcoWvp6hqDQzQlgfDxpzF12bM0l3ONtqzR0uA9cZ3jx9/P3kuPSD/5HM2P/Cjyyy9y49u/jV/dtPR9zaunB0xDULJmOClwvSE+nNB0KyIa3IOc6id+kjhJSf709+KnKavdhpKGufbZ5QOD9rgZp/ja8KgqKIRmoi+p9NNY4DxN7xz9Zk2kAsLrN7ioKh6dPmChLJPlFZquoKpyqt09lApYLJeMxkDX0fc94BFECdpPUOWKk5NjTt7xLbzRDuhf/wxpcsjhf/Snqc4GHm0fkhuPs5MtkzThijdFJTGtGri3OqZrambNiPyGp2nf+DTFOKW+9xzXP/lJFh/5BN5v/Cqyrr/uWvhvCzEMl/KauuKrhOuygJPjf/0f/fAP86rHbuF97wd49r3fyvYg4gkTIhuQesSzll6GbHeGpqhYG0PT7Fhem14a/OaPCOMJedGhx4Hx7JyXrebO7TuIl16k+fyv8sXrEWHUU1WO86rktDjBeS2xDvB0ythXvOWpdzKJZ/+rP6P/LfB1Ndh/62/9LT74wQ/y3d/93QD82q/9GgBPPPEEP/qjP8p73/ve/9Bgfx1QricLNLM44LwaSWRIUu44bx/QWUflIuZu4Ggo2aI4aQbQI4oJi8kRfb+CukVgyEWKVh11XYOUhCKkKDccRgvC5i49lmoUFGclsyilcQ06DZjOj6hcT1eOyNFimo7RGCZRjKBHhnPOm5exSI70DXw7MOiQfpKRtz3H9phPbX6Tew9e4lxsaVVDaQfW7ZpVvaLo/2DpgFeTq1zRR/znV/4M33DwRuKjK9jJNbSRhInPcy8eU+1Kbh1NUU1LOxi0PxJECV4fU223tL5mplOqviHyFP4sRpkFXr1lsAPToxnO+WwfPOBR8ZAn77wRL1GMFx1dtSYUkjo6xBjDwtfEStLFkoUfU1mDcJrRXE4KRNlTBRFXZnPK8YxGGHrRsx8dUrQNsVOkcUpTntK6gUymRM1IZTs2kynNaiQVEIgOz1NIX1MJwSJbMB12yF1D541EriVOU9raYD2PJI2xNkV6DoelKUakHJF7jnbzFXdWrbHWsPTnfMP+a/jk+lmaL19ghgZ3+zpWO1ABqpcsnUdDR3v7Nv4nPom7+zLn1z0+c/Jp7qTXeE32JEoJhO+jnGMaSsZaMuY1tUrQcYQbR2zb4iUJxlnq0SCMYxJqGBoQEoNGDZK2sJhuy2J5hXSesn75Lls5Becjo4B0EqOEQGtN0wyg5ww2IFXyt4M/GccKTxu0dsRjS11s0Faiwwix2KMbLY2xaOPIkgmxKKDZQrL3leixgTBNEfKSwuR5HnGgafqR1oyEYYTpOxg6PK3xQp+FnbDrdoTKQyqN7QtC22GChCwNcJHG1Dt63bNdlYjJBO0qes8nDWNkpxiNxRNg6wERefTOQ1Yl80hRZNcpzz/LgV0QyAHf5gRKsJERAz1JEuOcY1fUCNOTTi4j4vqmJwlSTLJP//CLpLbHjRacQwlJ2zRIbyBMMzwdUPslm5P7DMonWRwQTvYvzWnaFUWxYja5ii40UXBESAM6QBlBzn3WZcVCacQyIFAhk2FATVOE1tT95YRuEc3Ydg1WjOR9SzzZR0Yh0no0pqYkJj3IeOx8TdnUdIycm4pJp7GBT6hDhJa89/a7+fyXP8yHT3+Tv/jNb6dzFZ6+1Lm7usS0ltEXtLJFqIilrzg5q/HkSKg0Qja43uAHIfFiys61mHKNv+55uD7jp178eU7yuxxm+7z7xrt5zf4TjFqzao9J9ILdRc3oBcTZFBl6mO05rY0ItM/QOWxjCCczdOpza3aXV846zkSEcVOabcl3H76X9337u/jc/Y/yC/d/il+7+CSd/d1dsT9++ik+fvop/vbn/y7vv/kevufWe3jt0VtZiJiT7V18L2Ff7YETPLz3IsH9LW5/n5Vp2Qwv4/U1wXTO3iSkHwzdLidKQ6L9q+gHa4r8PmwusLffSjsoknBJGHR0rPm+W+/hv1495IPuWW4b4O6Kyeti/OaE7B99mPSf/TLi4aN/6zpuPY/h5jX6OzcxN5+gf+wxNleXRPsLVmlEcevVaB2yJwOCXrHOV6StJrl3wtyTPHrNq7h48R5Xmx3mzpNYa6mHLRJBGk+xqkPmFTpRVAiiokKkGjHExNWW1TCiPMNQlyhGVucX+EpyeO0aHhEYgekHhrrGZQFSdsh0hlmdYLwOvJjAaUzfI/cFQnnIpqbebOkP9wmjCCkks5mGeEksA7zNF8njFaKfU0cDU+UzlgNDZQkPAmxdY1XAZBZTtCUDPTcOlnQXFdVmQXm2YjwIUHgoGdG7HtN2RC4gshWtlUjpkQ6K7dkpXTAwm+9xmE4ococ2W3xfUa1a7OCRGkvkg+wtSEc2yWhViBSOZqy5MHAjyhCZZXuxpR87Yn1ZX1xv0a1jP56ifM3oBoSp8IYNqClBEDG2HS4IEcIxjgYv8LFlg61K1DxBJgnOSMYxx7kOKzRmqNA6xhcDUk0BMOOItYbOG3FakjLHa3qGfIsIMrb1BR2SJ/dusewN0WzOeJQhy5zQGqZhix+M7OFTmJFCDYRByeHsCCE0QTDjosmJogDVafq+YtclCFsylCMNChlabFczmJGma7GjYG+aIL/tWwm0h/nQhwn+yc/SP/0q6rKk/bZv46zs6KVBtoqqG0kDj15Ium5AaU3fSaquYJHMyGYZebWjPzlGLhIiV6EJcYGkVYbIScJxgKqkbDYcyBE72yNNM7zZlKa6z6ArTHWOf1EQ37xF0xtWuw2TdMFscYV6FFTNyGzvt/X/IUprurqmvOjRqiNe7NFUNaZukNkEW4/UY4cXjhS15eDd70O+/X2Yn/gJos98hu6ZL5E9/SrKNz1JqLbErU+nDCpJGYVklDPqsMVrevyf/glUtUN87/8BfxJRtiUP1o+I4gxZO3S7Zrpc4oKQdMiJoimrviTRAUoqeiGZJhHDZkNhBhZBShgkTEfL2W5LlfXEegnjBH9McN4po11j3HWK1YowywijGD9JGIuBbmjouorGdeg0xf6pP0P3D38E9Qu/yPNHC5rDI/q6oZGKdmxwjaIJNkz7gSzRHB4cITcLGnMPbzxjEs9wKsTdvIN+y2vZ/cW/RNs9Iv3nv0zy8WfxPvoR5HPP/TvNf/+g4b90l9f8N/89N3/kx3nmz383xXs+QLTbMJ1H3EpvUAjHqAwr59jmBQeBRYYeD84KDhLDrjvnUbFjtX3Apn6F43xNd9jxli98DvWRz/L5d95CJTFZlBLKkCsi5UZ6g9fdfIrIT9DBgseXj/37fgx/YPi6GuyyLL/aXP+rmM1mGPO15i3/Ab83hrZAqoaDGyGbVzasK81Q9uzCl5nPniLZjoRRSDk8pGoVyfUnkaKjt5peGOJqSzh2DFqxlh4wsF2f4IRiMWi6XUMzUbjOMvcDWlGx9ScsZxO6+i6+f4M0mDKYLdb3UY2htCVkCjlWDOeK0fq8fHqfi6HmxfwFPr79EHfrR7zUvMKX11+kN/9uESm/F0IV8M4rb+H9r/4e3rv3Nj753Ef5pbu/Thd5NNMlldCU24JrccbppmR3eoqVHhfS44k0gjDG4rDGMTiFHntO6pEkHHChRegQzICI5sjhEePuEWYY0MLnxe1dBhSPLW6RN4/wx1PKwUfOr+A7ywSHtQZwLNIlbV0zWo/5ZAKqIYrmLLShjQN0EBCIiOfWD8n8jIkOuV9dsBfPcKanHAv8eIbYCUR3ThrNOB9jElWSRindUOIHAUYElMYyCyLCZoeKNMFsQrHZ0NU1zlqUHzAOHfF0ytA1GNeio4xxMGxXK5T2SJIEZy1tUSCE4Ntf816e+eXPUXzps9S3nkZ4Bi/yMS5ENRWis6S+o7x9HWkd9sFL/NPnvoxj5H1X34UQATLUYC3GGEYlmWcR5b0ND/2OO9MJeB62aWjLCu1p+m7E9zXKWtq8xqDBDDR9T6xSxqBHhB0LqcAXVKPBVQPyYEnqX5YypS5dsOvO4TTo39Y2G4eTPl6mQUmSCJq8YXvxiKjPadGIIOQgiy5p9QZIZ1BfYOsN/SBQQqMnPoy/sxvnf8WpPYh94jimyS2q6/CzGBVqQBNqRzmULIOUdbtG5iXh8hqh1njewEW9w09i4rLH5cecE2DjhKUKIBKYwmKURA6G5v4FZmiJbx0hBdhiywURbS/ZG1rsuGYcInx/RueNWGNoRkebV8yzED+K6EyHw6GFhwlS/GRCv35A4GUgBNLXdJsLglmCFwTYcUBXJaNtGYOUINtDfEW7nriMtc3ZmpwwjpBOI/2IxjnGrifRIWVb43lzatUST2K8bYkbLTa4jFVJohRJQBQbfFNS+CFzP0J2NV3X0giJn0zYnyVETKiKc3AF3clD1tKRTa7jCYuTkLYtb7v6jXzs4nmeXX2Ox2evpRtb5ldnVOeKuijoTEyfjmRa4hNifJ+xHbFaETHStxXJImFoGzqhMUPPh08+wa+sPkUn4Nuf/Bbeev0tFJuWoRtJ2jPWzmFLRdusSZZzZHyDNFlQX2zZnp2S+JfPy/aSttvhRwnaCeb2mLtrR+H2MB7U2xOWQc87D27w1sX3s33hA3ykfZafbT7O57a/+652a1p+8uWf5Sdf/lmOoj3+4+vfwdvMO7l29XVc0QsmMuLldscD1eOKLY3Ycbg/57Gjq9ytFDENQ/mAfMgYxoDlPCE5cuSf/BiVsaT7VxiKitnh/NI0TkJoVnxg7xv4sf6E3/IuePfP/jx7//ifEH7iE79nDR/296ne+36aW3eQt/eoHpvRzhdof0EZpaRBQtls2L78kEWypOwv2D14gH9wB9+viIQgmIY0Y0L83JfwhMBcvcGsuSDan2JFxkVeYPyRa5NrBMPIRkYURc7Vq4+TX9T0xQa9mBDOJrh6Q7PJOUoiTnfnZFZhtMfB1VtksxlN2dMWPVr2tK6hDyNi3+e2vs7WCToNXdviGYGxPaocaAwsD/fRZ1u6rsOPp5dSjnZNEwu09ZiIPRoFu/IeUsNs9iSnz93DR2C7irLSuPQAFVo6ORANMX0xsJyA824xjsfsHp0QH3iYYULD5eLQaBSpgbbtQfr4SU9PSegfMFMRtC1N2RM1OXYwyM7SVYbscIGTNfl2g57GZNOMvhrBeTi7pifEiYA4Aik8yqpgoia4zoBzIAU6CzHNSF97BJMliArqFc55KAQoD2Mc1g4IqxnXW0Tko6aXzbOUAUJ4eEFEVeWYfsAmKZkbcOIy2aHtanZDThRPWSRzhn5grB+yXRWoG3eYRidsnMPzHP2qIIwDet/jvL5LbB3e/gFpGCJlxnjcsD+ZIIMCiyTUERN8dn2LwZEFe/i2o6vuUXWQby5djx872ifUmiRR9GcjvorJfEkrJeZb34VuGoZf/zX8F19AhD57b/9GHuYdXVfhqLmWxMy0QyAw3Ui/6wmkovIb5lFPpCKMGqBYk058pI4IRocz54xOEgiJ9jW1HBGTiMNsH2MUm7rFCEtpQHgWL9WkgyZcVXjmjDHUNOHhpaZeQCEdg3P4/LZUSqGDEC+bo7otpixohaEuGsZ2g8k70rnPaqxwNsD3ErppjPpz38fwzBco/slP89hHfhnufp7m/X+cNnsKL46onSXbT2i7js6zTJ99Gbur6d/8DuT1a5S7BzzYrXA2INYTxnHLfhriBT6Da6h6y97+AQ/rDWfrFYeL/UsGwDDCOFDu7VEVLSqvkMqyTBcYu6UyDZtNy8KfsLe8xnGzYrc9Y5EuLscw7VOakUdNwWp3ivKWjJNbkG94fiyJ3/stXPnpnyH6n/8xyf/lL5HGhzyq14hYcDifsrIbjHB44gqhTFHzChlOcFWAHQbq4gQlI7CGut8xNgXBn/gA7h3fjvl//Fc0eoE/1ui6wG62bB6dsXnwiPHsEVnbEq5WiGJNOLT4dYMtKlxeIHZbVF4g8wJh/+1kk78fpA9PeesP/hDV//eDfPl7vpf++/8i0WLCSZtz3uRM0yMiVZFGcxABn734PP/g5U9dbtrYiK4uUapBK8t8eZ3+W/Z542de5s7mCeqn38w3TK9y1uWcdA2HmWY/DdkRouIjLgUUfzjwdTXYbdvSti1hGH7NZ1VVsV6v/51v7I8iZJBhA59sGrBcCF6uWqqdI0wHvMOSfhjQLsbvDVf8hCLNON31HAaarF4TVhvOZcRuuyKehoyN43yzJVZzJknE+VDzqDhhKTLCrGU+njI7uInTA42LKNBM657AeHh9xOB67q+OuetOuN/f5/Pnz/OFi8/xmfPfojIVHP/o/ybPZT9Y8l1PvI93Xn8P75QL0sNbRNPb5N2WN6kD7gcJz20+z9tvvI2d2qOte07Hmn6zotMCHfs8ON+wnE+ZKJ9pFuBFI8e7c1xZI6IpebUjEyFGaUTRYQdH3+bgGvpRACMPXYnpO651Kbt7X2DUAUP2FFLH7NuWdhw4MyWR53OQzjjJv4Q/pARpjAwSlJswypJWOoqhQSHJu5Lr2RHjWCOdROqQXX6Kkh5aTWhXWwKT4y2uMVUDofQZ2oG1U6TNikrfwGBZ6JBxdNhIoecxatuQr1ekiz36occJwSSbY0yLs4a9q/ucvHLKuCk4uHEFKSVNkeOcw08SUm/JtzaHdNVnePnKlBv9miv7V8krgxIC/BB/GCiVT7M4oP3ip3jmSPKNB6/mZnSF0Y8IPQdjizXQOJiEgiTQnPaWTWOY+hKrNUVe4LwQUw8Y6dPlX9lpnkxQoaYrB7T2SFzIuH5E5UniSYRb17TG4EWH+KMDBc6NaO3TjObSEfYrGuuxs0hPoNTvFO+JlpwpR9F1BMUjFotXY53jYjS0gyG0GhVM6FaPcMSE0RzhC2yR48YR4Xlorem6DqUUSqlLs7OmIZhMv3qdWMd05tLExhOOvC65fn2KbTuG1RmjZwnjAyK/RpkCE8xoR0nRGiahRmnJ0I2IMmfYFIRXlwTLGc45vG5DhiTvNWNRkogW34I/P2Jo1tT1lk0JgYRkliHEpXGPJz1M2yOVR3TtSbrTF+hXZwT7RwjnsN2AFIqxKWl352ipmV95nLquaOvLXHbbGxQBkfa4aAvSaYovNW01sKt6okAxPVgwXpyRDw3QM9UKNZlh6oaCFuEJEp2wqQemuqduDWujOWkuSCWMk5h0luBbUALSRJP2c4begjW42FKPJUmn6c8eYYoL3v/0+/lcccwvvvgLfP9Td0j2JGESErqIMq8ohhFdCVS847TKMUis7HFOUO4ujYRm4z755pz8fMuvP/wV7lITHdzi3Xtv5i3TPQKjcd5AMZzi7WJ89qjoUZGHjJcgfKaRxkQxRWHIpinFasuAjzSgrYef3KYLjzFBy1TMKNIeE/mkgWVXXODqmpvZq3j1k+/hr0Z/jU9vPsEPPfhVPnz/51gP29+1Vp40F/x3X/5H/Hf8I96wfiN/qvs+3n/tu1CdpLCaWFluT66hAo0KJ3DxgE1xHzc+Rnb0BLQdpqhZHGhEXlANkmY6Z17XyCGhPl4jowBpBW+813H7Z455/EOfJuz+zYvqzlPk73gb9s//aTbveg++N2O16YhTiY1LdvdeRIwNo8rYipGTqmI6+mxGjzFacFA9IihCzOGMiU4QasbJqkK/8GWaG9eQ3cgkBBuFeInEEyNe7dP3gr6pWM5DdlXL6WnNOPQ0pmRf7xNkGQ+jKWr1ItvVyLCrOFjcop/PUNml3tdTgqbqqfWaYqyZT4+Yx0tcPTJJj+iGlnV+itSGdDbFegFe5JFEjkh43L/7Ivl8ib83xVtvEU2Jb0AFM1IrEM0a5Rb4kwMa/ZB5r6GpKW1Mn/Z4ticJY0I/Yn16QeppqkmKNQfo3SPK81M2+wnN0GLWNQiPtIduoogyyXF1F8967Lcgq3NqT+CQBNkcTznk/gH2YouxGiEkzuyQwQFSKgJtKbvLhYNUp1TWMVOSUMWU6zW9WuAHASLQuG7EWYHpDW60KCeweo5QNcPqmECMmL7D+SHW9djVpRGUtzf/qheGEBLfXzKYgWEsEc7HIlnogFEo8r5hW16gtc88mGMlDK1h1116FUx9qJAcKIupH1FVOdlsD7NzhOkc6wy+m6B9n2bwcB4so4CCkaI7xfdCfKUIRMg2XyFMRBLGKLkhCVKC/tKJPe8EmSeJEBg5EgUx42DxcTQO0g+8n2p1TveJjxC+/S2EYYQsWwIJ2gz4QwX9iHPQ1z2mGkmWPlL01PlDPBFDeYrwLYFxtIOgHRtQNSLKCI5u0ChDN9ZM/AyAzhQUQ40SgjSco/UU+hoXDXTbM3pzzt7V19N7KVU/YrWH5yuKdmCZ/o7ad+w6gighmia02wvOreF8fUboakwvMNoxOtifHXJ8fsGBN8cWZ5zv79P9uT/LjWc/i/e5z6N/9KepX/86sve/j0FJZATO98jOdwQf/xTD4RHVO9/LNlKc9xv6UZOECZzeZRGEuCjFOctARy4D9oxA9QG7sYTdBpwksSM6y7DZ5NLR/tFDkptHJFlAt4voSkvZl4yzjCNxlbEvef7iJW6oiEgIEIZ2aKjrCr91SCVIxku/mn7cceVmyPI//X7Ej/xj3I/8ON2f/T6kabm+fw0pAg7cBDdCXHXITNEEPfjXaKsHjN4EHXekdqC6GCi6M4IG9KEGsXf5LJuKcX+GvnKABGbG8OjFUzZ5zt12w5GnuX3rgNFsKcsckV1jiPYZxxWdaDm+WGMenfPEIuNodpNdsaK/uE/5So356CeY3H+B4c1/jPTG7UtD2Lah6nq8Imc6GmS5I8QQfew38Z5/6WvqdnJ6wRv+/t+n+6f/lO1/+ucp3/5WxumMMN5yI1J4+09wfPcVvrB5BhtI3r54E8vJLXRXcUUFZOZS5uf+2FXs8DOE9+9xctxxUR1jkoD4IGOsC3KuMMxu4yfxVxfv/zDg62qw3/Wud/H+97+fv/N3/g5vetObvnr83r17/JW/8ld473vf+wd2g3+UYKygGSN8q7HzOcHps/RjhSjnbLcbwgCSKsVTM8ZJSFHt8EXAtTTCPXyG3EpyHaBaTWWPCUTCpmsxvuPqck54UbMeW1yYMaYp2XZNqGq2xmfiL6gD+PzuPr/4xX/CJ88+xefXn+WF3QuY3yVO5t8VAkHiJUy8hKlOuOIvOQqnhGGIp6/weDLjseUR18SUO/IOk9e9hWIcyL/869hhYF1sKM+PmSRX+ROv/xP88HM/wxcefpTHbn0Pqu3wyobRlexd2cM0DVU9cGxStquaq74i8yRWJIwori1T7l1s6VYbktRjoSbIuYcjRZSOLoipi4JjWaPjFFe35AFMgpDpOCAriwgsTX1BoTxuL64SKI8Wh9/mODXB8+bQ9ASej68deVcyuo7Mn2AY6LqRqU5ZtzvUtiSU+4zOEqkd6AgxybgiamIZsa0uyBXcq9c4FSLTawRITOdQ85h2aAikII5jlJJUVYmRkpnSCO1/ZZc9IJxE9M1AXw80osAaQ5RNKE2FlJJvKaZ8XMCvTiv+NC2DdYxNQzSJLncVTYferiivXePBxz/EdPs0H3jd2/G8GBOGGDmixpaqlxgpCNuWcJKSW8XZRUunBTYQuKLDmopEeQTzFGMrgiREJDGu76lOL1CnO2JZ4GeaNp4zmV0nDHY0u5yYAduOCE/i3EAQROSVQ40jIvSxxmJGix//K+XOtqSRjze9hdzdx1Qn+NkVfF8xViNDb3Daw1iBtj1CCWQUYAtwfY/wLs8Xx/FXJ4jKQT+ar37228j8jE27wQ0N1gkG3yEKQ7s7QV1f4lHihQP14Bhdz346pR8tq6onU47+fIU1lujGIb5/GSklfYUJPSaLBSd5yXkuqJRmlsSIsaUbLdsH9zFuzkGSsekMrm9ZtyWB0ORtix8meF7MMAT022N8P2E0I72TVI/O8BOJH8aEkwM8KRhkz1m+Yl/5yA6UrxE1hKFP4xoiHeG0xAsV81mIFj5xseasWXMgYnwhEJMF3XZDn5csjm5jHTR1R9DUCBsgPEvRbLHhlGkUsZSSbT3QG4vWHhEO2wtcEGCFQscTVrSIqiDyJLF0vOfKN/FTz/0s/+9P/x2YZUgcKrHDAAEAAElEQVQMthcUTcWAJPQE1vV0bQkyRAYBSgbYtmKkJ/EzzNijBksYT/nOW+/m9tXXcW8YyLOUa4PCa07od/fI95/iMJ1SVw/pPY/An5BYgTcOJJGj7kN2XYDyE/quJZ0kSE/gTTTH2yk2qEllT6QcWs45dlucrYnagGxyyDSc01Qr7iSv5a+/7g38hTv/GZ/88k/xofyf8ZHdM//a+vyZ7af5zG9+mr/1qf+K90y/he99+vt4/NY3Mm97VmVFnzhc3XO+KzmcwOHSo1k5LjYV3sKx3DXk6Zy7KN7W17T3j+kfPSL7hZ8k/LEP4r30Eld/jzpfPX6L6rv+FPe/9SlmTz2NDQ6YpXvI3RrhwYmImXcWF05pmDDTAbtmy3BcY6xC7cWEwYRrQUObn/Gy2TI5eoJo7jF/8DJN1dIdHpGEIdlBwPnQ0ww5N5MZkZDsNi3rvIQkphk8NtsLbt0+AtEjPMm6aVkFgkQZyvsrpm5KPAshDTHKwxkLvaESNUW9ZhJOWKR7l/IILP32kn2TTZeXi5PzjM2uAyxaKfxZxPxUcdK3nLaam5M9vLy4XKCZZHhNQywi8mZDuT3BZhnzHNQuZ7iyT1WviPyMbL5H27ZEoUONPpkMOK18kuUeervjfPsAXIzMWyapT9jnGBfhti9SNB3L6W0m8yluFNStRWlFOPOhOkcqi4o13ekFwh8JfIdUPtY6Qk9xXjYo4ZMqiTOWsjX4MqSxlk72hPHlQoS1DpTAWIEXecjAw7UjAxIbzMg8yS4/Y3QKNxqcjdFHe0jva6eh5XBJ1a+cT6AcmR9yMvQ0fUmEYpnuo6TCSkPRGwYDhwcT+r6gbizXlzNEB00n8ZqAcDFjb2/Gabths1qztw0oVEA4Twm7BqNmtOMFXb9CihluGInVHB35LJKRcVxCb/EiA5M5YrRU7cDWDJTtyNFyzpBXqLaj9zUv704o3/UGxluH7D31GloryV3ElUXEXubTdS2FsQjjoSaKIHWoUJH6grP8mE3VkE72abNL1pg0EhsIRJoRMNLTUg4dSiiqocI6i5aaK+mMppdEvsFUG7Q/p2eLWdSI3QRVCeKgJ01DCl9iEbjB0PSGyFc4axmHHj+KEH5AlLbMnOHBwxOOnMCbZGzLh2glONjPePbeKUoODKOP8UOO9q8Q3rmOeOvb6H/h5+Gzz9I9/zzBd76H5m1vRFuB/zO/iPIU9k9+DztboZzPrhKk0RGpgsjrSWYZbVlg2xLfBlT6JhfrljQOGHzJanOCNobZwXVM26KspQw065OK/XbA9x2busO5iGzvGhvbsKJnEc5Z5S/zaPUC/i4k1hFHoY9vFYNMqU2F9CMm+3Ns5zNzDdmTt+m+67uofvYnGf7pjxG+4zvZm08Rkwm+s5yfHlNwhq8jDuOrjF7CeXDOy3nPdLbgIIb29CFjeUJUp6zuHpP6C+zFhq5p6U/20X/sMVQc0TYdgTPsTTIelSvWwznXh4zF/g3E1FJtzujO72N8RzdJuJJeobw+pbeWSo00t55mm+5x/vCjPD7k9O/8JvjeP4eZZ0SRz+ai57go8Xc7zGiYTRw29ildDR/+DYK/9/8heu6Fr3kfg5MTDv/232E+W/DK938f+fe8Gf/qE0xSOJYdd9sNe/omT85fz94UEhfCVuFFC4bhhPmRx9m3fyvm//fjJB/7F5y/+S1gOrJpQTq9Qs8BVTdwbaa+Opf6w4Cvq8H+wR/8Qd7xjnfwzd/8zURRxDiOLJdLttstjz/+OD/0Qz/0B32ffySwrjvu5SN7nsY5S6o71uEW1yXY4ogwzCm7M7zsEBULojonyg4Y8wuGi4I8WaDjhOxwyiuPPsuua9AEeKnHEMEkgrzQnMiSO8lVYpug2jVbpvzsSz/Hz7z4k3zi+BM4/t1s8q/EBzwR3OKx4IB4nLAfTLi6NyeRMXtqnz2VIMM5ee0YqrsgGqbTQ+ZlxcPZFczo88cmkigYUNER5aDodmuSNOJcx9jNFrkI0eUl7fm11+5w7fwZPpl/kejktazXDhE67HLJMlFYN3K9F/jap29G7KZjJ6HpO3qlcNsc6WuECjjdXRBd2cOPwbWKoRc8ah+xa3vunb7E4fSIlam5fe11HMZTxrphe16zqTsKzhHZIcHE0tLi6whXr5FWI6Vm7Ev8KCKl5cV2iyXganKd0a6xncBTAZuLNUddiD5ImMQdyhso5FXqumJ/oklEgIgmpHHIyThDtAWIR4Q2REmFjGOGtsU5wXx/n76q8QQYLqUdee/RDw5fGeIswdmcvixxQ8D0YM4oDJ3pyDqBeXhC9sRreOR2vFRdMC3O6LuEsXbUZYHLFuSrki9HW7qm4A27KaKLaZOMfnT0oyWmZdMrrHLIYcTLZkTrhnZsKZqBdpIyiRXtqiA62sf4HvdPNvRtiC4sthk5O10TaoHJIvSN64xezI4Bbz5BzrLLBrvMEd4M6w0oleCUQZjLiLKxtyDA0//yyqgZGqIwIZgs6bsaU1wwhgmhjtnJkb4dGLsWGS3wugbpSoQIEb7G9T3El9q1/2U0oRQCh8UI8S8VV096xCqiqApUGJA3DwjajpKKpTwi9AwuUXS1ZlcVXJvdQAYem3XOZrvDdoJgOiGcxzBYXDticZi+ZUgjMuVhK0vvGbzpIYKWli1VueJguUeShEhf0duewBeEnUOHAdEkQQiwiyO64SGu26BkCF7PsC0I9m6hp0tG57AjKC9jlZ/S1+ekyZRBGcZyxFcTTseaqhWEXkwUabSnAEWShHTVMc4EOOdhhUcTCoJeIaqe7WgY8pxpOCKyiKLcYkSLUjFzKS+9BsRIN1p8rQjHjkL6RFrTDQ3SebRDQS9guriG9ULeNH+Kl6fPc1zdwxs7omR+yQ5SGT6KyA9xQchQnOKsj0on+N6cTEHvajCXkYVzKXjT0+9mMQTcHwv2www/mHJcnyECw148o6odlc7xxY6WGf0gWQaKcbdCCcPVoKMYSognaE8i6bEDvHKW83DoOAxjEjoiz6dzjnydYwpB5M+Z37yFKk5Z9zsat2Ta96wtfMfV9/O+2ds5Fp/nV/vn+KlHn+Cl3e+u52tsw89sfomf+dgvcfMLN/k/Pfl9fPf83WyO7+JlS2R+BKJic/EI1SVoPVCdV8yKHnVwhfm/+Bfww59H/9anSZ7/EsL8mymJ4yTj7Du+g+PvfjPjtevIdkIVjMTRFcoiRSAJ2469LED6I2o7EMmMUCcsVcYoO26nCToQvGw79KpiGcaYeUu46Tjb7LgaZITPf5GmbRn2jtD7C9rxLkQxk3BGMCZ4OseKgkh1iC5BmSmGLZu6Y5rNMHrg7vkOXwuOogNefuUFkhuaLoI48GlHh9+35GOBix06l0TRpQ4V4+iKHM/3CNMJXt2zqdZs65J+lERIZAq2aji4fsBuU/HwbMfenessXIG2I6OvMbscL5uBO2d7dh8ZxMTTgPL4mO3QkE0TQqup85wRiDSoOMaMHuPWo1SKx46ucLY+oc5PsNbg7SLa1hLsT3jkCuaLp5hES2pPkXmK4aLGN5fvs/QCGGo8IRk8i+hakumU3nSMvUH60NuO2EtxzYgve2okXhrhi4y2r5iywDkH1jECeALfk4hA4QR0F1u8wCda3mDblLTrDf5YIK6+Ghl/LQuyNz3D0BAon0Y49hGUfcXoEpTVTPwArX0GY9m0A8qOzIKAIPMpxxLTj+g+xRQt/QBJ7DM7XF7GWrkp67ClXu0Y4pFkPsd3A0PrGPyMbbkhkD1JNMcID08anGvx/SWm2TGoAj+BYFBE2uO0q+hH6KXHKBXV+pxT2aCsZT49JH7zqxBVzf11QddbkihEaw9cyG5dYN3AZJ7i4eEGi/PcpeeIq5lN9+msxNiQyAspu5zBOggsF+svI6I5aThDS03sxWh16T1tbU9vBFLAYEqctRilSI6egNKDPMcPYZlN2RrDtnfYpuOaFzH2l9Gn2g9AStARgdninIeee5TdfazdsZe9ht7LYOI4q3qyyCfxBJNIk/gxvadRf+ZP03zhRbwPfwj/5/8Z7nOfpQ00/nqL98c/wDoJULR0A3SjxzKQhF1NcnAV4ghhFJEYaLuesLtgZ30OZ3PsKNmVDhFLED2JlND3KK0YogizK5CJYY5ExSmTRcqmjbHWw1SnxB5IVZKKCNU25MAjNcG1A97QMfUXHEQJF+NArQUTZRne/CTjxZvQH/k4/NqvYRbXkaPEpAmz/QVdsWPbVkwaSUjFUinOxg6vaTgzis2ju+jz+8TTVzGWI1VY4gUpYpoynm6pPv0MwY0j1lVP6GkMlj3X0USCnYzAxExiDZ7H6sufYbOqCYbHiMI5dw5m1KPjYndG8fA+L94veeJznyaJJf173kY9dLg2YBannLU54d2HjH1DN/FJsmuEzuL8PfLv+8us3/MBkp/5cZJ/+COkX3jxa95Nf7vmqf/Xf4/5Bz9M/Zf/Au2f/x5eGl5AhR53spsU/UOuu4S99CZF42FMgBMBg90xP5ixevM3Y3/qnyBeeAbzDY8x206Y37jDFwuL7Ua0GeGrHur/+8fX1WBfuXKFT3/60/zdv/t3+aVf+iUuLi7Y29vjfe97H3/1r/5VptPp732S/4CvwSANW1cxVjtMfkrvp0wzQVKObOstp0NI5rccuIbQpdixZlnsqHYbrPDp0gS/D6j6kWnos+5KdJqymAryboN1Dr/32UWWxm756Ycf5ie/+Av88uknv65d6kAF3Emf5NX7r+W6usLr917Ft9x8ktRdpSxAyJz8JMe5hBs3Z2yiFnFxgllb3PI2qb9lNey4vf8UfuazO7nPtvc5SHu2nsXEc0Lt4ZmAoa7whnNMmFDXa46KLYOQdLFgaHLedvut/MPP/xQfffRR3i5eS5gtiZI5oRezbY4JlcL1OaK0bC42pAzMk8tJzrZv8fYPkXpC0bTcr3a0wjCcr8hHh3Y9F55k3Vc85kICZVkISZxdYwi3tOOW1W4kcDHhaDAXKwpKkrbDSCirll73jE1HHKfQ7mjGnEDfhMHhBkHVdYRJRdArwvmU6TJEbR9AkFIHMW63QhbQ7jqMGImGFhXMCfwAb9hiqh2dsnTNinj0EUmICgKoG4QxJNMJdW9o2pE00Djls81bpLP49Hh+xtBBZXJ85SM/8ymMNTz2zu8iLn+Rj589zxPhbcpRcXXcEgw1cTYl73s+ZZ/hTcBrHlpE3WFnBtsZ8qGnHHIujEfgKXonKawg35aE+3PCWBNaS2oFYVsxqUO07TntW5wfE8iQMrDYWY3njTCZUKoAIRN23QbT58yDCXoyw6w2jNsVNrOoxENqhew7hmFg6C2e/y+vjBrT4cYRlV7WKm9yCBcdY3WOF+8jtabIS+IAsiQD6SPIoSsR2sc1v7sTqLAWqX2sGUFfDhTO2Utn3OoCbIOMfGy+o3QKlR6R1hY5FQxZirIGaRq6piGSksnYsJY+/TREKkXfGcJYY62j3e3YtBvi+Q32kkPGuKPzOqIQYm9BudsxTUbmYUsW+6hIXxqIDZBoj2gyQX1l92j0M7xJzHZ3wih9ppMJNjgiiScEyVd9SHHOJ7A13aoiS2Z0RqCnMTry8KVPNdQoEZEEvxMe4nxNKBxt30EWU1Y5zvPw5JTydEvlCwLvAp1lSO2hqxjla6Ya7GjBUwRa0g2WFENoDSryseNIEqSUu3OC2MOGmto1hGKCEwHf9eSfYTeuWMQ9s3SPMz2hzAdmEjadQwQesegwduTBrmaqp1xdzBC+4+GuRO86ll7PZLbk9P4JRvtcm6eMuzVDdQHTBfrwcdTdE/L8mFhv0f6cZr3Bix19s0NFAV0Mka3o6o7WemjPsWtbnjt/gcAX7IdHiGbDZOfzXH9OJgUde9SepE1z8BL6QaLWWwo9Je5LWgmkEQv1Jv6j6DH+1FN/lrPNjh998cf5xdNfJB/z3/X/815xj//7b/0gf9f7e3z33nv4C2/8yxxObyHSNdr2mPMTlp//PNGvfIK9T/4W19drhPu9F1ydgPO9hF/6zjtc+/7/gv3pPspsibuMStXsxwfEo4/yAiZ9Q5gtQde0q1P6UpEuDql9ycP2jKZx3JrsMztKaesKJ7e80myJ6Zj4e9yrcsLVlr1nnqGbzRD7R4yqZFsW7Mc3mekFOzXi9QO235FGEZoJs0lAImqOT1d0jz1OqgZEGHPbj2lfPkfbgGji0W9z0uiA9WpHN1YEoc9EarYjOBMgBAyM4AvkJEZGPlpA5GLOVltim+KFYH0QridZzNmXkrsvPeLRquGqViitMZucUQo8z8e0gqEZCSbgRwM7kVPc/xJ39t5O4EVs12uEgDRVqDAmlT7RNiAvt9hFzGJ5BdNvIWkwZYdKMmqhyW3EY1FKoBXFaC8zp31JqCSuM1jpI22BMgLpeXgOlM5QbmBsOwY3EhqH3wfIsMULHIEOKLsB5Ud0Y3Hp4q88rHUMg8ULPaRzlz4LjAhfoL0Q1zqcjGjrkmgaIFUJ7Q6CCfx2bXaOqjpFm5FOSaxwDGOJ8hyH8YxN3uCUpLeOXT2gpGAvsFQmZnAGp0biIKZf1zBcRnnpZfjVRVCLJFMTbNRSDhtmwx4qiSHfMDYW60nSAISyPNh07GcdQiikCHFjRRBPKSix3oSxFwjTc3WR4ml4aDacPHzIdLLH/NoN4iRGS0GBh2hD9hND6yq6XUtgItIsBWXo+w7naWRv6JuWREfgNK0S+CpgaEYS36MfLOv8DCMVkfQ4EJrQn6K836nP1o5EXsd5UyBtjzfWhMEM2YfodMqgQS+CS5+Z3ZZlliEizUnR4jUd07HD0/5XabpOJbhdTxBo7CygfGnF8uo1kqtPc3djaHpF6GlmUUBTbPDkjDBJcNbg9x08dpvixl/C/8Jv4P/GR8AY5FOvpv7GV8F5jQoiVmXPQgV4TYOfBOjJhL5tkBhksqDrDHrsSGxFdX+HVIJFFDGZLEAM+J4h2LZMsoztlSuU918h7g17R0/S6whGCD2NdUvKYAbuReZ7c56YXCG/OOYisNA1JEoydhHCSWwoGYzPVjn8wdF0HdFb38n4whnyhS/RfugX8L71Oxkx6D3HNJ6RD5bz7X32Wkd+ckGSN+xNU7pAIWyFmx9RXDsiPHgCITxsObINLJNsgdtu2Tw4pepHDvZDms0OaSxRehURKfqh57hpka7BBQY7+LBtcfsjnp8QS8MqmvK5F77E4fMvceXRMfU33MJ6ApE/IvBC8n6F1+SXcad7h3RRh8wWeJGhkxMGIVjM9zH/yZ/nhW95LfLjz3Dlf/ox9j/7/NfUe7Xdkf2t/yf27/2PzD/wjey///W84+m3sl69xG69Yi94jCCbUq1aRLiPaVcIp+BKRnv9iPDuPfpX3cCTEW5XY8eECEvf9/i+j1Lqa675v0d83TnY0+mUH/iBH+AHfuAH/iDv5480YiqObEvgAi78PYxwDEHJZrVms+tQs0P253NUvaE47Ug9iex3dGNPfziH3seYDj8Bk/dE2Rw/mNL3x3hmxknb8bGTD/PhF36Fj5786u/LkOx6ep0nZ09Q1TmTYJ//4pv+r1xZPE7QS1xX0haG6wuNx0BpfNRMMQxw5XrI8TamOG/x5o5RJ2zmPklVYs5fZnQCFy+Z2B0Xk2vsnZdkvsKLZ5TqkG4omDSOqrR0/gljOqWyjt3qEWa6T+06Ahvx2vlTLMOneHH1Rf7krddBGqB9iV6vCQQk0nKx3hKqCD3xcU7Qy4ggCIiLR5fZxW3O9WnGqrvg4mTDrqkogzk3tiseiTNUGPKayRGuHzk7OyFZPoHnTZFhTrvdoZMDpgE0StJ3Bt8papuweXCfhfFwxlBJQV6VOAttB7mqWfgRNhlQpifyEtQ8RQ1bMB12co1d1+ANHbL3EQhQgs16hdAhHSF+L9hrDf3+EXebewjtkM6xalakKiCIIszQM+qE0JMkgUcUR7ySrynaET0N8SOPZmzo2pHZPGP81CexQUTyhjfwjpfW/PLJp/nEyUs8FiuSacAwn2J8wQtxxSYxLK89SXq6wp9mJL7ESUs1DBR1xawfSZXAJhntxYrJUCHkjKqoiaqGygkmSuI7x3QaM3BAaSLSJKbva6bbmmW8RzybInWP9gOmcsrdk4eYtqcPQ4JpRnd+ginAhQqlLumNTdWh0Gj/a3evhZD08jLKJAp9VDRHdFtsUIGVtN1IGmQIKxBxCNZAVyD1lNE63DCA57HttgBMgymMIyoMGYcepcHaFvsVF+i+3pEmh7T+hG57QhsOLAhxxoFegKoxxRmZi8hPH6KTOdaPyJYhk0CyLXrOty2HX6Fgr1enmMayuLKH9jRlb1DS0Y4tY20wNmZv/zZ9fs6QLpBuQTd2yMHhRQHK04zDwFA3DGWD+4q5SBBEqGiGFR1j0+KnEcL7yvNzMFMzzqOGXXHBbLZPEqYI54jiKevWIEVL4EWXX3eORsBeFFJWFbvJjGpbE4UJLnTQ77BNSbKco5NrBCog5pSd52Nkx9DX+OEUX0nqdqCvS3QSEoyWTkrmTrLqW8ok5EoypR1zVtuHuG2DCKeUneHwyi3aJseNF2R6ioegBdhcMD+6AdpC2aB9y9i1hKOiZWTieTg9sC5P2Q4jCQF+15D3W5ZTn3R2hbyWSDVSDA8wXkgsRmrj2BaSoDOMU582nOLsSGotfedz3zjORIOUPvNOg1LMwwlV+TKuqRB7r2U61Ii25LkHr0B8yHKSUhYVXVsz8Sr6LCSUCSreozA5pvwiV5nw11791/gvX/N/4/PDM/zjL/0Y//zklzF87Y7zdiz4hycf5KM/9nP856vX8d1nPteffYj/yv3fz5BFd+UK2w/8CdwbbpP/2ke5P9/yyYvf4C/Nv4feSdxSMa4K4ugWbeUzXShEWaHmB3Rlhd0U1OxxPZuShiOfe/iAMU8wKZy3isPJEVcOlnzpbKR5tMIPCoIxYfitT9Gs1wyPPcXoK3YXL7LwMibeBM+HUPqUgyCeWEJvj7ZQ+LFmaiPsekuT51StxzKJSZqBs6YlWeyhSrBVS9WfUAYewSJlMVnQ1Bf48widZlgtGfsO4Sua7hw31ETeAn82oe9rQjXgBo9xUxGFDkSEjhtm84xqk1OmkuVBgjkt6HwPoz2sUlihiRt76RQdLQlWOfb+c/SzPagH6HuqrSHc85DaI6Kj7QY2d4/ZW14jEDWTOKBYPU9/OCGXgnRIGOue2SxlkI6LdiBwEMT6cse0BdM5XFOQ7B0iihFrFcqXNJsNte+YBSmdrxGRoxM9Ey+l6gWjDJCmpK5LtEjodz29hEnigRHY3tCPDTqO8cIAU3ZwUTFaUHs3cbG8TIsYOwhn4PkU1RlDvWUmfV4SmoEWZRSzdEmgAlZjTilCVD2glWSiLFYKgklKXRYU7Y792S047YimEVEqqLxL34lABbTtSCR8/MMDHh1v6HdnmMM7dEOLdh7iKENoTbHbMNaCXlm89Ao0LQjws328do21BW0b0jUDfqrYditCr+dWtg/enEflyDU1sh9qLkZLohXXogxnHLsmZ/AHZv6EyItQSlFXFe12SxhGpJlGioxcKjwBq2FNM/ZUY0VDx4IlN/ZfhWzX0OU4Oce6DmManBsv5XdBSE2EdD6UPYHyGC6KS7f7wyk4g8lzzGbDYjLBxD4nZUNrO64tLplZzjj6vMU4zWxvQi0Vo/bIZlfJ8bjoauZhjDfWjM4S+x5D39F1HUGSMPYDrHOE79G97V2Ix68TvvSA5rVP4Q3j5YaG2ZBZx0SC7nv6OCAqS/r1CsoLajXBExqEI4smrB209GShZNblCB1S2J51tWJvkhFJSy4VfTtgtEeQaLp6RPuSYhipZEYgBaerc+RQk6kJcjjg0HlIXWDThqtzULOAKojYth3WbplkR2hV0/6Jb8X/sRXqUx9BPX2H1sypTw1BEBOPFZVr2aiRNp6S7h8SxDFd84CUmGn2egaxRfRb1kxoPY1vLUMaoT1J+cKWSeTwzGV0mI5j6nygNA9RWY7zU867HbNgj9niCo/O1oy2od8J2mrLcw832Fzw9PNfQEch27e/hVFAlESMXUWpFkyuHLKufILEYmOPk6Lkih9SJwG6KAhVRyEdlVzQv/nbKN76Fo4/+ptc+4c/xvJzX/qa+i93Od/+P/8y7/jgx3D/WcjL1xfIzSu0/rNEckFcthhpcf0FYqzIyp6sHuBLz8ELLxI9dQcrA+6IAN9YPGWQUQjf+73wh0Bq/HU32P8m/I2/8Tf4m3/zb/6vceo/tPieH/0enjv7EvtiwrX4FpP548yja1ztBXF/QbRqiLM5TVGT1zuwD7l+eADdBKlaaruPP3iEoWNod9SdTzbPyNIJP/XCT/NLz3+YXzn/GK1tf897yXTCd9z4Dt54/Vt4681v5NXzQzZNQ/Fwxd//wg/zqoM38PTVb6YdCjTnjOXIlaMj4vaUeuMxjDuiwwQX+0y0YIhD6gcFatMj59fx5iNqe0IvDJ7VnN9/SC23tOERN8OQelD0BMRRyKq9YKAif7hmXHaEgyEMDujzimtxhh9N6A10teLV4Ru46z3Pb/GAd4WHjKrHNy1HaUptLYKA2f4RsyygHmumIiC/yPHllt4qvDDgtYc3+MK6pHi+YRkvOczmLO1Id/FpZn7IrZuvImk12/MHPFw8z3J5ExsEJEFM3vWkYcDD+hwlNYvFVeZRQH3/y6SrY7xwwhlnbMsaEU7YuIYwSJChI2NKv97hpYJRS9idQTilFJpy94hrYUJAgnSSaO5RPKpYJhHn1rFrLElZ4rwLplFGEKc4T3JenVH1mmm2oM1bynrH4XKKlJK+bUilI5xmGC/gbJejJ4rQhQwvvIQ7PsG+9hvwJgnveeI7+Oi93+KjF5/nG67vM+pDRiVpyxW/WXyedLbPY48vUZ99lqoZyR6bI4UgyDKOx46JzJFxjPAyvGrHchritECFAduiIoszgr0JnjDYumPiZ+SDpZID9eYM7Wm8ZInnK6zrwBl8KwilxihDU+zwFnuQ+rhNQZfXyCwk9H22RUGaaOT/wtzMOfuVBjskdw43GmohSKIMf9fhBovodlhPY80EYy9zkCED08NYXp6n72noGeyAFJJVeUbYVRAouqZA+VOk9PG8DIxAjiviNCPISx71a5gusf4cI2PU6BilwzKStZJCOGrkpelO5KF9hfYkp+c1pxc1fjbQiYZZfIDXC4QWeJ5H3/e0fU1XSCbZlFmasi4Kum6D7R1dUxM7HwdU2w3OWhjAjyOMt0cShST7txiHnr7tqPItUmvCRYqQEteOaE8TTDPWZyfMp0uEF0BXILjUmm+7Lc3YEHmXjuVWCOZhxG615t7FmqXv4QtHkIQ0Y4pXtMTxIVIFWGNIfUFuPRosemiBKYEncXVNaw3pfIK+2FA7Qd9sCKMpNZJhrIjVlOOTT2P6gKNpjN3uGHmaNgpJmvs4V5CPIVp4jHWF5ykam5AGPsiaKLtCv2txZYOtHHovYbupaAqYByNqUSPVgIdP2DaIxhAGPReD4VF0kycPH+Ngt2J19xWmzcCQpkSJj0GxGXJMteXlVYmRmhvx3lcM8kKGWNColjS7woXMmIuC6fwmu2ZEhw5/L2QvuMH4/KeRKPQ0Ixw9ugGczNDdkgd+x41hxZ4JeN/BW/med3+Al4+f5cc3P8VP3P1Znt+8xONreNfdy59vvQt3tj3wW7+vscqGEet3vovTd38TwbWnGQ9SjMiJP/eQt5Yh/4Can3z4y7zv8W+jFQU2rLF9ifAvWRzb8pT8bINzBuMNhLMRb66p84LAeKSex5B3PIwGbiaWThieOHqCfAj5/IPnQA1cf/HzqLGlvnOHi4t7RFVLdO0OItDEiSb1InYnFYV1ZMkMGQkMhmFToq1l0jfU2ZJgXVLvKrrA5+hoyui21M7Rd6fMl08ReSlYx9DVxJNLk8B6VyGVw6lL1ldfl/jTiMb6JC7EBgPGQSQ7VBhgO4upRyZRhthtOa4hqRu8MEABdT/S+QHOnxCJli4ZiKavI5gXeKOhFxK1CAmNY6gknRvxdEyYCmbjhKG8YL3eIpscuo6gqtnqa3RDxZVkRt3VVLuYJNGcjRaUxAHSVzghGGsPV9bIpYMgYiwF0kqaZgX+jOliyqoacBacrBDOkGrFthIwCnarnEnsgRJEscYZEFoy7EqsuPT1QArcUCOdxngOhMJ6Hnjzy13sekXpDE27JZOaqis4k5qb4eKy+VIhzhrsaFkLx/VQMYk8zHaL8DVBEHF2ds5QD8wXCeLmPp5oUcLRS0E91Ejr0bWGZeLjhwHxZI/N+pj0JESnCUFnMMJjWxi6RpLGA/3gM7QS1XXIIEAqRainNP2GpjvlrCrpkpiJSLgeX8HFA+t2JO8EbdNT5QVWeQTaYygGfC/gaL5PJ1rKoaQZG1IvQViD0ArnBKYqCNMZDYa8zzGRY9fsEE5wZXGN2PpY53B+hK0eYYcVRHOk9FEqQcoArWGko9nuoK6Ir92mPM3RYQUuQWiNWiyweY7Z5SzDgHIYKZxjh2A6WFQ70rUtZDNmvuR8/QrTJKM2IXfPS5aRz53DiGdf6hmKipvLhNAP6LoOay1+nBB5AcNuhVUL3JOvwTz9FPJiw3DRUqsWb7ViiocnSqLAp+0G4rbDdhXWi/HnRyTzmK6tGQeLaBXWF0hPsi4rorIlpKYadqwuXma2vMneZEGZn1MPLVMVIyQ0TcWjrqCodyyia3hjw7rQzOcz2rpG+zPGaMZCaTJ2DINgP9LUoyPtDVkck4eSna9Jvvv9ZD/1TxE/9xNEyz1GF2Fm+7hJTDSPKXRDn1oeW+xjm3NM+ZDJ7DYymiN3I2leYLSljqeMQnO8yVn2HZ4eCXXAtgkYsWjl8MIEL9JYUSHHDYdjh3JTmkoSxBPaqOeckRfqjpPe5xtthWxrTt/4DeTXryFbw9g6HtUFsefj11NKXxIpQ5YueHC+xkUek3gk6UsGfySvDL3TCDdnP+7Yvfmb+K3XPYl55kXe9GM/zsFvPvM1Y0JQNfC3f5BX/yvHo99rMPnXpU489tgf3Qb7t3Ov/3X48R//8f/QYP8+8czZM7y4eZEvAax/Ex78y59rPK7khxwFR8x0yr6KeDK/wp30CfaiGaIJmcV7xGHFYGo+VrzIrzz8H/jnD3+Fbbf7Pa8fqoB3HbyL77z1HXz3nXcTehNstODq3oTT6mWs2XBenDNajxvz2xgvgO6CsSkJmWCrE8rtOZU4wp/PWcyXrKWjrR6SDI8oJhEmj6A2zOYxypWIG3ukw4L8+S/yoDekUY04WBAbw8NxQBRfoj6+h5EpUbOhvmu4svTZmDO2pwX+8AouzKgqQ1MU3DIe31otOHv2t6irhKT/MqOnCF/zesxsRihGtOdQbQ++YIg9Uplij1Pu3b+gPNhnur9FmwbhTTHelKNiw+LGTXbbhqv+DNkrrtx+NaYeqO69QqsFg1SobJ+Lkw0qLBnbFcvgOkfpFBVozuIZ+aNTQn8G61MWYsCbXGVTXnA2CII25Jq3RKsakwqG8gxjBkS0z/n6DF8K9veOcJUBAa0QOOeYJhMaEdI2HTZyYCpCMaGpShbRHnWrGEzHqBxbOspixzz1kC6irUrCKCIMI7p+4NFuTbkT3JknmM9+lnEQuNc8RRRPMKS8KXySf9Y+z0vlKxxeOaS0A18+fpbClHzb9bfjjzXqM1+ke/458qefYqa9y2xbJ9HO0ulL1oC/NyXNYmQQkR5ozncFo7IMVhO2LdbrCW/eJq1qLlanjG1HNt3H8zXK87DDpVN431TEXoSZBPT1QF3s8GIPPSbU2y2ev4eKA5wBywj8jkuqtR0YQ6cuj808RWUsWynQMiDcbAiCgCCGuiwI4yX+b1MYwxmivkDYjq4VVMIRKY3GsO0uWLdbsuQ6aohRco6nL+l7/e4cNxZ4TY/nJMN0Tpju49DUo0XUDU1f4eqKQCYMswm7ouZwMkP7l3Qp7SkOFhF3T8/Z7FpSI0nnc7DgmpEwDBnHgXsnK8JowWKWIsaRwJ9gDFTbY6rNlii7jR0HPN/H831oHEZYeuMI/Q5pWvwoJVtA6Vb0Vc3oLpkDnvOQsU/YRQRRRNFsicPDSxqxGRBSU1mPuim4lYZUQ4XoFW014NyGdhyYHt0icAmeS7GMBHEGzYCLHWYYCDxFgs9F09J0OwaV4UvHUDUwSQndiO/AHyo6AUE2ZWIdTX2XvFzh9x5yb4l1OcHQstrsWFy9TiZbtvUFeTMQOdCBT1m2DGHA/uyAi4svY22Li2OinabYPoRQMQyCiRHo7TmD61CRhMWUoY9xnkcQnXEgZ+xkxsnmnNdkPm4244HcslwXxNEe4XzGvbHmwTCQaA9panbKJ06nDOuK++efRycTqjqhv3gJk87x969ztC2ZpT5t1+CNLS72kXJBNmiKUCLakmnnqKKbGM7otyeMXgQuRpuUW0PGf3n8FH/j159F/co50ar4fY9NxvepX/00qyeeZvuN38zwhm+k8wvS/oL5IOnGUx4Giv7qksderHh9l/Hx4fMkr4S8bnaHLA0p+1NsXlPVHXYWkbgtQTmgF/v0keT44iVq16F1RBA29MrD9z36quJR2XMYztDqKtN0Q1Wc0L/0HMPhFU5FjRpb5vsHBLPrSKApukt37F1O4ydY5Qi8gfJkR28F0WPXSTxF4F/SlE9NiZrOCBY+1UkFsxlRGJJq6DxJX7eYqiXyp5cGfEVFukzphxxJiLOWcihoTMo0SKhdQesqpsqiphM6J+gGQTb4aCepreClV87Yu3qVQfmcP3yZ3SAJ0iVC5tiNxiwiTGLINy1uZ4mvHiDlCr0Q9Kah6g0i3mMaxNSBwVpNmKaY8x1mto9SKddNi247dv0FZT9imhk+EjHx2Y6GhfYQWiICHxC4sgAnEV7AYAds6ggFCCEItaQZFFJI6r4hMiFDYxlQJAFIMeKEh9uuGScTdBDRdy1eciltMXmOsyNqOsd2Jaa2eOGA1RaZLKmqM+rNXVI8jI541GyIZre5lu4zVOfgFLuqYRwdQeaTRh4Yg217ZBgje0PnBpyTRGmISiLGTYtQHrEO2LZbNlWNVIok1tSjIZUZhV5RdjsOFzdp2wq3HtmYlnkywzM7epXQVy2qbgmPlgB4UrLpR87KeyipWQ432M9mqFjTDoq+23E9i2iqBh9D2HV0jQdxTOArdOChSQm8gKLNOVk9IFABy6uHtGdryl1FnC5J/YiL5oKJnrDrdoyMZHGKKXdUeU6YpohgcukPYn1EMPvqOysExGNPPYCJQwYzIicTdNAzbjZ4sxnCv4xHE36DyXOycodM5/S94aLrSXAYafDTjExbbB2wFj7PbyxZZnlqP8Pi8COfdrVDWHHpl6F92vYyPSRQHqqroYtxhc+ueERMRrfdIRMIrU88CfF1gJjP0HFCNVwmOgTTfaK9DKkkvohp2w1DNzJRAQfziNLzWJ2CsgOBP2Ns1nR9QGIkfRpSNg2mWGOEpekGhkFA7zHZe4xFt+XY+Nx1hkEMxO2KeHKdK9MJojhl16ypPUuoEqJ2ZBo4RL7DeBnJ07dxf9an/elfIHEK3RSMux0jAju2BF2LF/i0SQDtjrCvSRe3MUGI7UdqIfCyhCtxSBHPOZvHFOk+jx0dUg8Wu87xlglxFhOOik01Us4dYaA5Uj6j1YxFToij6mHrD2z7hNsp3PyVn8FLQh68/a2EFznXsoxhL8GYiIOuZvvwLoswZhqG7KdLjjdrzLYmtStGVbJ2IXXTMtcRVs8YYkHQ3cfkJfkb3sKXX/s6hpP7zP6nHyX5lY//vseSf/tB5w9H1PPX1WB/27d92x8qp7d/37DOcj//N1PzBkbudQ+51z38nYNnv/OrQrEfHXA12educZ9Vt/k9r+tJj3defTvfe/39fNv0zdy6co37bUd7cRc/A084Tjc7GtEQjPCoO8cCN2ZP0LU75C5HDj7G7uD4AjW/wuTKE6T7UzwLYd1htSLUlo4QUwvGZuDw/n28xMeLBTMD2zSGQnMUBNhU0+Rr6o3m6MO/zPLRI5zr8coG3Xt08330UBH3llI6HBozStTYM/cz3qVGni2fY/upRyz96+A7ho9+HPeXvx8dzpGup20FWRSx6XoOs4jILji/OONusSM+a0i7kCYA40eIvuDF9pTW83nj8hqe8eh2ObPbT/LKsx9jvH9McuMOjRgudW3tiqXqiQePrrfQ98jexzYjQyTwZzFy7VDbiqlr6D2FT0ZnRrw4w0hLv71HlRwim45y7NifHyCdxAqDjDTt2ONLgXPguxEzWso44ep8gvLg3BpQAt9IrHFQWTyjkXbgbP2Q2E+J/YR0NgdnqbuSNJW4TlEXa9RzX8bEEe7KdYSMyZsNbzl4PR+//zIfL77EW7vXMMqAj51+mixLeOfBNzGIF5BJjP+FZ2ne/11EylIPI4G1GCcYxgFPapLpFO370BUM0icLfYamZwwtTkmEZ0H7TFlz2jSMKmI/vHRDl1KBUDg30NX1ZXMSKQZTX+Z72450do2x3eJfbOn3l2hfYzE4575as4xpEM6nVYpACkJ1qUlsjGXjB2xXPbMoJBYhpd0yjAGh8y//XnkQTBDlMUVxgoqvot2AlIq5d0AVxQw6ou87wnHEUx50OePqIVIacAHddMrUxggkzrPkvYG1pTI7ksMJiAw5euB1GNsCv6Oxa6gIAkcwenRGUdkAP1LQjbiix3UdxiqkZ3DWYNoeayRNm1MMLYHvEU19wviSyeBGi3UDvRtRnsYPptAVID2U7+MnMZ673Fnu84peCZzVCKXY37/CxeqYqm1JhaDqW0oliLyY82bN/fUFtiuIhWOQJfHcYzRTBjEnDULGPKfvByaH13B1ha0qRhxCKXxTYmTLzmwZC4voLNVg6KqRpOxQecNIz6AzJvUOf+ywdUnebplMDpkoR5+v0H1Df/dZfFcjJzFdV9E3HfvdFh1OOT42RMs9ZpnPqss5v/tJrDokLBp6USJlThzPyBYStYooKnBeSjssCYTGVx3bvkWNEXdkR1mNnLqQTW+pVMBRmPLwNMeuzmhnPm42Z5K06HLDzk/wxzmd/4hxDBm7mK5pUf2A0CFiaIknCjEo1K5laEqElxEe7ON2Fc22Q9iSmzLkItxnVpbQGJryIUe/+CGmv/ob6M89g/h9TlYKHz5yA565k5G+/f08+U3/CTdTyfZ4xZlMqW3NjB2z2VXG2Q3KL32UoNth50vkcJ9351d4Zm/Nbxx/mkU04R2P/XHWdY2pvojofZLoDm19wdj2pHsecXBAefGASM8IXYINak79nljmONsSuIQHL55SGkenYfehD5Kff4EHj3tcCxR7XoCVgkGGxBmYwVIcP8KtR4K5YFvnHE1jZOAjZguCgwzXt0S2x81i2m2BlpZtubuUn0Qp3myGq2pcENF4PSrVeGHEULXIztJva4weyOI9Wq8jHztsl6O8CfEY0XvndNbDWo98rFgbR4akUxKnffKtI96WRDcO2Z9O6O6dMPo1LpX4zBGDQWYBuTci8gqxymlDH+I5Rrasd+eQ75hme7TATA/INqcVinHvJvEi5TC8gRod/fYum+aMsRtwtSJtQ5okpEgj0uhS+qIWC3AOEUZ4YUZx8QDthYSjw3QDofYomwHTQTNWLOOQvTRgbQOcZ2gvGnw/IAglfdfRNwIHaBVg6xrbtODH+F6DyyJcLxmrHilbRj1S2ZE0XKLlpeTG6pgrwQT5Fb+jsjYUVcNeGjEGmnYw+LsS1xpIfGToMWYGf0iwXYdKEtwwIH2fQAXYTlAPDel0hnCOvK6JpEcwP8R0DVW9YhwCTNMgFgpP94QypRst1vS40X3F/bzjpDzhJF8TBTNuxzP83oD2EFrRWIWSgmUoeLRpqcMQMUhoa8JZgLS/42fgCY9w9LAqxoSS3ZAT6xZpYtq2R1mLRNINNb4zZIFi1zwk0Sl0PpIJOo5AlZc1W/ngX9K7bdvidw3RfELTt/hNhZ/t4S8yzHbLuN2iptPLXfkoYjSGoCxwbYPtHP4iYzVUeEZykAUIp9Ha5+56hFTzxNRHe5J11ZOlCtGFVPVAmAxkSYqUkouXHuC2OzKhKM7O6ULBVmqGKCBTYNqGbP+IwNVEk4Q2utSsX5yviEfHfG/+VeaZpzWtU4x9A2FAMxhmiUcjO4rWQXoFv58z9B1mPMHTERdFTm1jFosjAn+G2W3xsUTThNE49k3PF9eObdVxSMPRoUF7IS2CdhhJgjkaResVdJtj2rIhniyYLQ9wScz6/3yLbrLPfhoxPnhImzdUF48ozi9Iw5iqPae5eEhkfMTsKrofGM8uKB89JBpa3KMGWTXsDyNtuqR825uJX/UqxDLDji0qPSSLIu6+9CKzlSUKB5o4Qkd7TBhJ1cDLpzlVXrM3yXjd+hWCzYrubX+MRFnCYUKcTCkyn9ngCKNDeJAzG9f46irtbsdBFPDwpOTMlgxRiFWWGEcyP+A0DxhcRZcsUOcN8bhBkTG+5g7b//a/4YsvfIHhv/5B3vqbd/+tfDp+XxjHP9jz/XvC19Vg/25O4UVR8MUvfpEPfvCD/PW//tf/QG7ujwpOypPflx76d4PBcNIcc9Ic/xu/J5G8Ze9NvPf6d/L2V//H3AwC/NOGiXCMxQXd/YecO0He5VxVPWpwOGGIRMTL+V0SP0OPmuHRfeY6gVBgy1N8FZDefBU2TNFagXUE3Y4SRbC4grfx6OOasW6pHm5Irvdk/gHO6xkWU9I4Qpga6+1I9xfcPD1H39sg7zzN+bJnUhR43uO42RLb7Ri0YNXVOBeicJQuRMZLjmLN+WqfLzUv8B2Hr2ehp8x+/aMMv/zzNO96G4opwxCz8Kf0keasdyRtjUt3CB/KTYDofdp65PCah4iv89njDzH0Fd9w/Q2IMeP+es18/xAzXeB3BTcaST5PWQcFp6stYRrTDVtUv0cchGS+j5nEMBrGxCNY7lOclYhdQZb6zPZS9oeSNkzZtSecNBWdksxki0xi5mGCbUdQkl7B2A2k2qMdHXZoifuOej7HTeZ43QZ/bDA+zCZ7/P/J+6+Y65b8vBP7VdXKYec3ffGc7yR2zpGpm90cUmaLJgcyYFvpwgYMWDAkC7AF3QiSYEA3BnzhG49gWJZmhKFoCqKsYWgxdjO1Op4+p/ucPuk754tv3mHlUMEXb7OpQZMjdov0aGaem41Ve+1atfdau6qeqv//eSrVU3eWRIVE2YKm27Hr1ixu7eP7PtYY6qEiijMS3WIfP6bdFrTvfBtpkHF63uB1LfPFio9tnuXzwzf5+sUrDCag7Nd85vZ7Saymzebop5/Af+Mh48U5m709+rohBYYwp6/XJIsJcZZDX9FWG1ojORA9Zw5apZnFinEIkJtjIk9grMeIQCkf6V2RYyk8xr5BDwPpfIHvS8pYI93I2PW04YhYzlFna/rHl8TXl4z2SuwsCAKs1Vg9MLoIKwWRFVjrkFIQScFEaGSS048WIyVDmNCOFWEXEMZXfqMECW3gobdbcnMN4Ts8L8e6mmm6pA98LqqK9fYBB+kE1zVY6SOiGU5l9LHH1MzQw8DoCzZ1DdaCSvCThL7Q+MJnupjSdBVJkiI9RTEU9KZnMZnRXV7iBzEon/UwkiuFvn/CrmmYzCdgas6OHxIT4gUxzhVgPPaPnkZ5Gq23+P4MN1pGrbGevfIgVeoq17zbouIFQkqEBF97+MmEwdOUuw1hFBGFE+Io5bw8p40yjOlIsxRRjWx2A28MDzjKYg7jCaWMyYI9ok5Sth2zJKTvSpwIiZIEB5iqQitBLwR61OypGUMimLuRMI5xBxMelx2u6vECS2ciLsxIf1ER+Rpbd3Smpx6O0ZVBzvcp91MOnWKoOqogpx0TAtfgxxOUH1NVPdZ1nGsD3pKqKogyxV6yop1nNEpgXcAQgll4dL5ETJY8LmqGNCL1Kk6VwxmPMFJ46YKHm0saNzJGGV9pFXGsaUZBXPk8ZSRl/5CtChDDiN68xBgbDg7ewcnjY5TyWEwn5LlPpCQi8DFjT1tb+k2NvzeBekc7WPptT+IP7HzH/m/9Eqvf/A3yL/0u0fnp9zR2rGP4nVvwudvw+dvw/CEYBVAC/4L9lz7PX7v9v+SvPfGzqMLDJCOetITRDWw2I5sfEvcLhqd8ohdfJX35LX78Z36MfzP8Mp+7/AJP6Z/ABFMmLiJJPdIooLzv8KcHRC7i7OwB26pj5iZMFgmB2qe1LZ7VyFagTM+FeYvPFy+wu/8NfvTrL1LkKb+3v+GnxJs86b+LbWPZXBT4YcREVnSn9wlkRJx4lLHHhYxRugYVoEeBDH2Ehc4p2jhA1Du8wnLtiSdpxhKlfGxkEVVJScciDxFhgO4a4r2ccn2Bbz1E7DHIgaEPyKSl0yXCpGg78nB05LuWtWuwKObSkBxMadqe8M41mu0WuS2YTQ6Rk5p51DNDsulLIt0RpDO8ecIkjhB9CSJE5BnGprQyxVUXjPWWZmyxbiTqWpyaIlJF5vlEfgw+XAue4lH1iG1jSFOPwPmYsmVT1RAp/KpGzSdI2SOSGOMpemXJZYLyoS8KVDpFNxohPVSsUYlj4fvsqoDSNqhRE8gRGSe4TtNVDWEawTCimwaVpQydxPMDXOagA+cUdbWm9wIyaUiiKZUf00qHIGIqBQ5D0V+FhqeeII8jyl5TjwavblGzDJUHV/OnwBGHOX3V4E2n4ADPQw8G3waMXoNzI00zMBjDMs0wTtB4PsVZgddbjJJMkNTVDl9OMMZhhCOaxJxuzijY4gceU2ZMAskintGqgrYv8MMZA4JJEEJTkweKyguYhArjK7Qd8DY78OfIQF3ZUBnDfL4PUlC1FzS2RAZLQiRls8aNJVJKsjBhNtmnHHsGILSSsevxwxjCDKyGvgDp4SyYokDFEdMko7uE3lb43oZhULgYrC4ZLtaoPEdGEU23w0wCVNGzXa9JbIzxJBsT0ZQXLGzJWZ/Qupp3H+SEGLpR0/YDWaDwVnOGzZbqsiCQElfXqIstIvcJDq9TnG4ou4p4miO6ggrIbETuWbrGEWQJI9CUPbarcJME5f+RmvSgLfghUdAxtj1VoKBpkXZgmWfEe3OKeydUjaNWHr6C0PMJBosqC870QKR7PF/RjIa5WtKoc5TrqXtHISGwW7rBY20a/MGxCq5ReJZ1c8nu8i0Gf0WWJjjrsF5KFFZU5Q4zzVHXjgiiHZemRScps+szOnGL0/UKP3qKPr9GOstR3cDmjdcZE8FFFOE9vI96/i2CV1/F/8K/Q33pS3izCd21IzZmpH/bLey1Fc0YsDInFPWOlIp4NiOMcvZkxE6fsS97kt//HDb0uHhij7mfkh89yYXuUH3DVA1s2i0kOdM8IkoUl5eX2L7HsyUXrSR2IaupxIqYIJ4Q2opCj7RiRpCOhPUJLnGM3YBRDV+8FvKlv/0zdO79PP0vfo69l19FItFKMdoRjSBIQnyp0MYwiBA8gVAGZISIQnQ7EpxfMOQ5bn+faLEknWbID3zgexrD/lPF90Ww/8bf+Bv86I/+6HeVf+Yzn+Gv/JW/wt/5O3+Hn/3Zn/2Pbtz/VLCIF/zWX/8tfvf5z/Hq/W/R+WsetRc80mc87k8Z7fgffY23T57hLxx+jM/c/mmOZtfxCsXDc8vd4ZgFV/ZC7fkpceixWB6x3e5ozZSV6theXDBowYPiAbcP3k84NsQmIphNYTxmlI50to8LMpQnEVJAtyEQFhvsUbmCwGkKGzBxJVo31DvHdG9C6bUEfoMJDLVWZPXIdBWRvfYWbZJS/vgnGPRraNOQ7n+SobEEfUUahTy4PCXTgv2Jop8+R+IEaerxoc01vvLa/5uvJiU//uRPIB43RK++gv3QSKxahNbYNmBvnnDWt5z2NbPEY092bCvN2dkpj9ya37v7Jc7qc9ZiR4rHJHkO7Qxdf4qrzjhKcnQUUtVr+kYTCk2kUwa7pI/PCZtjlH8bIyyzWzdpN1u6ooLZAYUSZMGKiVSM22N0mDCLA5J1wVbGXGKohMUXIUID1iFTj9pYPKdJwpC11oy7HZkf4E1yKieIohlhX7DdHbNIr5NFMet+wyoNCbJ9VBNRnT5i6FsAWtshlCJxAk9Y+pfvEgjN8N53sybAFhUHwmDDmI+u3sY3zu7yW+ffwI0eebLiB9PreGaNVgLz5G3MG4+IXv0W51lOXxTsE1AFoJsOX0m0sXTbDdXagAqYZzGd3TDqgt4mYCXedou88STCFghhGZDk317JFsKjqy8QUuJHEUJKalXjgh6pfZquxUQSfz6lu3eO6jtc7P97BLvFDpZtK3F2xHjQ9YI48xmHDpxludrHbNdUrqWIp6z7ElVv8QIPpWJGO9KEIamfIsszWO4hhH+1Y5JlJA6WAi6qNes4IDQ++CBcxxAHVxOmYEKnS/SocdriMo9AJQxbja8ckW8Jk5TLrqFpalwk6HTHJJgQeRGVfYQnQ5ZpwLbqOTu7pDpZ0xnLvjH0ex42EgjjE88XbE6PEVjieAoYxnHHMKwRfcJgR3w//CPlzngOzRraDVIEGK0R1kMqBZ4inS8IlGRoW7SRnDUt2sHtLGOsR87v3SNWDi9ymGhBYwYIErJkhXVbikbTlBt6IfG9BOEcIk3QdUW/3lGkPiIUpNKjbyKGdsv8xiFePqEsLrA4ZvMV/VaC3zOfH5L0l9RdyyjmNHXFmGa06pDz3QP2Jj69jGmChGFc4g/32PYNZvo0JnJQl8Ah17ybPAov8bMI2UvaJOTxdsM0NURG0dUFtJIo+vauf9NgNseoyOFPjpjGCcaLeXhacDhJgQl3uzWT3Gca7NMUAw/7S9A+20oyaR4wUSNRcojwp8j9jPnZq9jRYFxEGlmsSmj6htAf0ZHP8vod6s0J3csvcONrL7D40hdIv/ol1PinHyPM3h7dBz5I++F3I97xA5zczPmtx7/Bf/mtf876j1EfP+uO+b++8n/jv7j7/+Rn7/yv+NT0ZyhdxDAYcl0RhYrduGQ8WjA8fQf/a7/H9WLg44t38Jvrr/BPn//n/B/u/CUOJvvIfIaragLfoaYZ0eSQuN+QNz2DqamnmrpztBI823DRFHz14ms81qeMduCnXh/Yz5/i9Kd+nNn47/jd8z/guogIkudYFzWv1wW2fgwdHN5+ArkKUdLnZFtB2xOlIZfHDV40EqQB52VBNxr2vQTR9ZDkmG0B9YCchIi2oy22eMtbV8rGShFmPrtKY6MFp85yv+npi5GDLEaKisyeE/kBYxoSupEghJyAOYYxjWnKmvzggMIVVENBqHOaCJ4+vMY0XNJtG8TlA9Z3T4lnK+aTI2gGhA7wrMb6AVkSMs1vQlvjbS/YbR+hh4hJEhL6kPrpd+5foAIyf0JDg58F9L4gsQvGWnNZV6yERCExgwebikqsUdJD9YIRQV+XxH5KlgcMOJSn6W1P4KVMvYCLqiASEJsBVIbtC7RIyBcR5tEFMosQQYwpW8IsRIsBPEk3tLSiIh8WxAjcPKezNR0K34uJrWFdt2gkmbMI7ZADhEKwcwYiicoThBAUY0EQekzzJW1dkvRXdlNOKvpGk0YJJ31FWW+J4xlRkhL5Hv3oo5sGL5pyWZygtj57nqOUPcMERN2xcx1F0lLajlhk7KsVvb4kSD2CPEdYRbnZUJQQpxPSOKTdXDKZLzBhRO4EawRkAne+Q5+tMZMAay1xnn/HyWEqfPpkyVZruvoBnd/hy5BpuE8cT/D9kLnnrjQuVE/Qa/y+ww8jiKbQWlx9gekEIoiQkwmREGRZSrlzRDLA6KuISRMG6KFAn9XYYKQbRnypUH6EmUmOT0/JA0kyXTCMlnt9g/FTrk8d+5HH0GvKusMZTRRKPGDdNei2ozYazxmCwwPyJw5o25ag7Dk7f4Mn0pR1XSGjjGw6Iah3DFHOYByeg7KpyWKBjSeMxuJ/e9yvek0Y+OhIoutTmssZ9VByeLRCqoyx61Bei287cm9GRwqxxPaWNzuLrwv2XcGud5g6I5tc7WK3Y8E0BGTIptoyhA1oj6XKkYEj0BZfzBhFQz/0ZLZhHDxUGjBYh2laiqJiMZ8gwwKtWzIpGVtNpxpWs33CfMLY1YxdxKYYyNMVjy/epEor7jz5DMPhDS4+/AG6RxdMNydkr7/E5FsvYV78GuFqRfqRH+TBrafZrWa0MmRdXXAUwODlyNxnenuPxa/8Cpwc0/zQ+9DzGdn0iMki56L0oHXIsafcHhMGGcHkkCQWdO5NatsTK4FzIRPl42lJKyReLMil49Gxhx/4CAnzeJ+LqKfpBIntef7hl7gxfzvPPvE/Y/22D/GKvyUN9jkrCsZxg+dP2ZskTM1jmi7krJ6hwgH6uwSFwE0XmPkt9v7FvyB+8w3ufuzHmL7vnXzk/W9Dev/jsOr6vgj23/pbf+tPfO/o6IgXX3zx+23Pd6HrOv7+3//7/Kt/9a8Iw5AgCPh7f+/v8dM//dN/Ztf47xuRF/GJJz7Bc8m7eWt8noNwxM8lQb7icpJzfPES67NXeOGtl3hLHNNFHWvX82bxiOP+jM72f2y9P5A/w48kb+cn9j/M226/g2qMUX3LyfkDZBNQXzjK1CM58qk2Z0wnS46eeoqiHkm7Fje2XOCBnfHKgy8yDC3PLPaZCokUMVb3pMqDfIrIc0w3EGQhDDXoHpnPULWjaA1eUaDrkdkEuuWcfuNz/viUMujI4hSd+ISNwXUKW9fIF15Dve1ZgsUhi+0F2gtptg/phgmzIGKoOloDS9GCypBRSGw07dgwXx7xvvK9fO3sCzzaPmLxoU9g7t8j+YMXaT/9aeLBxx8c2VBTlzWnpudEd7x8/DwvXm5pu45kOsPUDQfpPs+s3sV7ls+wGB1RmnIviynKNUfegmIzUExBtxd4QcNTiycZXYAKLOfbe1jlMw1SwtUe22GLWbc07gxThhwsb5IuHZcPj2mMIHj8GuMw8sThc7w+7mhMzyyccFkP+EoQFy29g1lgkEFEc7GDuiU8ukkcB2yMpRUeQTRnXH8Llx1gTYJEMJqGLF3SNyO9Cmi7iq6raWxDHudQbPCSjOall7GTnPTp5xjHK4Xkuh4wniKdBPxY9wP81xcvYvuav/bED6GcRAUST4fIa3Ogx969i33yGaptyXSypKWgGX3Wm5pJpxHaImVKFIbIyRJfjwTdBWMTI/0FwkSIziCtIIsUjbOsvs39pPQZ2ho/XKDUVfcVqIBW7UjinLax0HXoIMVfTXHbAuXP6KylqTqGvmBsFYN17MUBUeDRNSNt2WNtix/FqCDAbWNmokQGlmOdsh1qTH3JLJ5Tmx7PC0hnNxmK1wjGGTDC2CF6DVoQxRNmIqG3mnV1SSYlYRYx+JLEi1Gej7XgjwFZHNG7gTyO0OsafwXSCZSFOEk4350SkzFNZkRehLUayYjUOcO6JRxazrcFJZL45hFWWVRXoUKFsIKyLBgRJGmE7nuCOMH354zdmqY5RcQzwjDEOUdfbHBK4sc5qt0i+4K+9fGnC0at0VaTTjKEUpTKQzeSqQowmwvqbmC33SBUix9MWekZ/bbmkd9ye3kLL8hgqIlcz27X4ed7pMrHdgaV+jRCcLI5Rwc+e7NrSDHiXRiq3rEXSKw2uGZL70bMcLUjNMmneBjc2WOyyLE5t8ziGcP1A0SSs2cOudRntLuapijY218xXc7pj3uiruNassIVBa7ZolYJZp5Su4FxrBnbjDDwOFjNiP2rSWQc5ZjRcBhKguqYoj7GmWvEXkjSlmz8hlUeg0iJreVObnHSZzqfUonH3D1vIdzH79ZU7Y69IOWm9ThrRlw4J/cDLtYP6KIjCB26vuT84SlxJDm4f4/Jv/yXzH71l7nz1pt/6vHFBiH2Yx+h+eRH8H/ix/HvvIt69HnQjMzbN9n3d/xv87/MJw4/wRde+Jf8woN/yxvh9rvqKceSf/bKP+afvfKPuZ4+wQ+uPshPXPwAH0/fgW+neEFK/65nES/+O/z7D7n23hnvat7Ot05f43f0f8Nff+9fR6RQ7d5gup9S6pbN5oIwvcFsKKmHC5L6Hus+4cX6Fb518jyD6Uitx9sXz/KJOiepfp3uYx/k1g9+nPCtJb9w/K/4/c0X+HR4A1U78ukUL7SM0YRgmmKEIJCWqbOYvZTD/QW7k5rN5ZZOl2zXNYf5kiSLKM8vuDwrMWHAsC0RLkdoQzWMXJ6XBIEjyTOarkT5iu2gqHSPGiW5EghfEWVzZPMWEJNMphS7Da30WKEQvkeAI4hDaj2STFO6TcNJeYnnJPMgYQgyknnKZJrT33sZLUc27QX+9oxYC1DnDHv7gCBUEpHlTCwU9YDpO0IfvCAi8v7b/tKSEGTLfjKnNQ0tFWkWsKsEFyrl+nTBUO9AQFNuCQePbrdF+ArfF/i2IZzMWdcDQvgMZiD2UyLhIQZHIwwzLHbYYoYWGWXYogRPwbcjsJwQhFFAayWdG2i6hmwSMjEGxoChdzS2RjtJHqRsmwpNT65CRNlBqlBpSOIJtuclg+8Rfpuc1kNN7MUkk4TdZstYVVc+0P1V6KoVGqclwjPg+9jRooeRejfSDj2LbImNMsRQEYyW6dRH5Yry0TkXesvNw6d4cu82agjYPS5xbkRlU4QnCcgwfkdbF6ySGGktVmtU4LMfBZhOE3qCwQvIDhaUdx9ga0N28wbq20TC6QHb7xCBzyT0qbqQzTgwy2d4Xoz/7d1cIQTTcMqWLU1fImvFJAgRQuDCCebyHAC12vtOStQ09jEuZeRqXJFC4HsQLjNcXdOdXxLagMnRAV7m44zmoQyIR0emJE4M3I0ylAqYYvHQ1A7Kyw2psniDh5IeXpLhpMMJQU9CurdASkmSJGTLHPPIsbm8RGhBlIT0NPh6hNBRXJRMJjm+q678xz2fou6ZZwGDtgzakIUebSAJB8vu9D4mWKKjkH4sGNZX88gjKwlmE4o+52zccbe6oBYR71ruYbYFUoPcljjlUfcCNwQsM0vie9zbbTiUkqN0jp9n0BX4g8CbzKnKNdgI5YUIr6Ye1wg/RIQtTbllNs0ZhEPYlvlkj2qEslhz++n3IZKUzXDOOFYEaUIdCKrHltQKpvsJ4d6UURzT93P00zd462MfIL485uitt8hfeBXx2X+Lcp/F3Tggf++HKJ+7gfbA7nZcdoZk0ARf+RIuj6jefpuD1RN40mczDEwjH8+bc3k5MhYFyQSiNGdsW/yoJdSGIH6SWR5jlM/28pR0GuHHA7gMZ2rM2OK5kVU4pZhEbGzNw8tXGeuC55Y3CTzJcnlI1UG/uWRaKpguCbwOud0ikxQJpHpEppJA7WHrh9jtlmB2C/MTP0nyX/0znvj6l9kuY+w77sD/lAn2fxd+9Vd/le12+2dW31/9q3+Vb3zjG/ze7/0eq9WKf/Nv/g0/+7M/yy/+4i/ymc985s/sOv8pYJ5mPDjYp6/PiBKHtB5+XbI3PeDJfsHe/pOMQUc6t+TLI+pHPYtlzOlQ8MLx8+zcGcc0eGHIDx/8EHf6a1yevcFiFnItPOLEjyCqadsNF80GE/sc7SWIoWTt+awm1+h6COqSZTLh8vguxeSIo5t3eOX+72ECj2eLjkivEfu3CccK4hh/7jAyhHFACQtdyeBCxlHh9z3HtUG2pwR+hplOmOwrWt/nzXuvIPsdT/zADVjMuLR3KdqW+IVTAqHI3v0efCeo0iVu7zbjK29Qnjbw1NtpL09JhcLbW9J3BTEtoXUYXzBKySf2PsLzF1/hS7sv8uGn/vc0T76D+PUvs3vmdZprT/BmcZ+T83ucFW+xtR2YBtVs8bybvPfoA/zwu36Y6c6QTpbMl9dx1hHQM+xqutZQdQ41i8iCmKovUXsCvw4JuwFhA5LlHXw6drvXMPMnydqEUWm6IGDYDoR9wDQO8TyHl4ZXO9MP3yI+epLpdIm73KKN5poMAU3TlpRaIwVEAowf0+y2LIKMIE1QniJ0jsoYpipBqpCx3zG4hIkfMowlpTYEnk+U5HQ41tszvDQmlz6ts+j7Z9iqoP/IR1HCZy9yyFhRaI9z4wiGgfdmz/KLu0c0GG4s3kMbdiTDBhVlsHcDE3kMd1+ne/YpzNZyohKU6InCjETvWKSHyPQ6zaaCUCJQBNEeYigQw44hnCDklOrkksCX5F7A4Aytc6RcRS+Pw0Ay+aO85EhFlLbHi5c4PaCGkbavyFcz9JlGP1jTZhFD0BHGDhvEZFHI5Nv+zlHiszm9xPMF6Sy+UhEPAhARE9ExxDm2n9KPFffNMUoG3MgOIW6xpYcYR1x7ehWiNzuCaIKUHkpvSDqDGQVN2NB6PpEQxN+2sBoHB1jmec6mrUAqvDAEO+CExQ0DwpfUtiXTEyIRYjtNX+2Qo8MPQqpdQZcIRK64EU5Y7i3Qqcfp6SNO12sOkkPGzY7Rk0zTiKFrCOIEKT2EyRjNFk8WlKNjGEfM9hKEQCwXCCyu2aKLjnHmoTtNEIa0ztL0Fiklh9MJKk9589WXuPvNN4knIYdPP0XhBlb+nOPjewxS0swSUueufJC54H4vSVOP1SRANx3bdcHF7pIhMezLCfNgRtFsyEPLqc6omxp/bDHdJS6aYYVPmEoC11JuT5DDwOBl6LFk9sR1vP1r9H3BbOpTDylrXSBKw8Qo5mrJ40TQWcPSyKuJlmnYFKdUq4y4FtiiZbaUmBEePzxnQCO9KalQCG2wqqGLYmx2ndHM6KuCtrygNgOke5zIhjSEJBT4A4jmnMxp5tbRXmxQ9gwv9NDRispM0Q+PScVjmr7EOQ1vvE71hUfk3/w6T73wEvnrryObP957/Y9Dt1xw8fGPUH3qh5n9+M8wPbqFNFusDBFeznIiOd89og7m+MLQVGtklPOT/VP8r+/+z/mtjyz4p+o3+drm639s/Y/qt/j5+i1+/t7V8bPxHT5+9jGenTzBj4Qe4b0HpB875MfnP8rYlnzt9AVu3v8Sn3r6I7TzPcZgQX9+TFfc5eDoGVjc4tHlyDfe+A3+YPM6VRgzCTPec/Be3uWeY0QR/fq/ZIxjks98Bi163rZ6io9dXOP58k1e0a9xkL6Hs+2aZycB4TxluowY7EA/9tBo9Cxni4VoYFAj0kjSIWSZhMz3IvLgANXXBGnC2m3BCVo6olnGel0ymfiYKKGqCsreY9P1rCKfm1mEHCVpFpBMAjqdUmqDdYaHeqTpW45Cjy7xCYaByXzKvfKC67OUMenRtWNCwDgq+kDgK4FVPovZAb0/EqcZzVjQDR3J+gxdVsi9fcQkQwQB00nOpp6ju3OMckyS6XfdL2F9Qk8xuoFZNKMZG8qhxPcKOjnneF2TOUOpa0SQE0/mqGkD2w1aj3SPH5E6h9ACF/nYwGKFxoyWzPkMomXwPPyhR7oeugYtQsLVAtsYDCB8hfQEtrdUriENEuJxYJQdbrrH+W7LWVuRTQ4wY4BpLHnQEWQTurYjyjOEL2Ec8UfN8O3vaayhMx178R6RF7JTiq7uCaIIPWic1DTtSCQTvLHhfFvgu5DWCMIwYJLHaOE4PDykC04oLo6ZJPtsxh2akoAJe8ERqR8zND3ajlficOKKBBjnsPGEZNAM7ZZQK1QUYR0EUjBaR+QrOufozQh5QjBaqGuM5+GUxtQn4Dqkf43Qu0q3mdU+kRddRR44n/DbQp1SSGbhDKM1u2JD0EZEcYopSggmqNAi+gKSBQCekuzn0Xc9EwDWy3HrDdI5Ajng+RFtV5PlCevWo6OmudgQ+TEyjBmGAbO5pKsV425HeLRHOJ8joogwbqlevyQJAkiW6MHhrENIgRcLFrMVAkeIT6QddXuOCjP6yzW18Em8DjmUrIeAvaylaGpE71P1BgE0raSrzwmHFlSFTfd5dLHh2iQlCqdEeYja3AcLkzTANBMexS2u2HBWCRJnSPIDXJNSK8XJ+pSpsyyUZJQnhEbRlRlNPjJVPXpT4e3dwg8i6s6RehAlU1SsKaoHhMoiIku/rSm2Bf32lGg6ZTJbsTt+FTOCkDmTMGfnFRxfnLC/v0/DyGoxZ6Zr/O6CKJ1ymC84SSXKlkjdUtw8IH3HBwh/ShJ97WsEX/0CzcMTotNfZ/k5h7lzi/SdH2BYHsCv/TrKWbaf+ijSD9kXE+rQo2g7Dic5gSd45EI6HTE3I2N/BlYRTg7Q3RZcSzo5YlM0jLIj8BXWBDgRkkUll5uBVeChlGXlz3lzkvL7936NuHc87SdUsUGlkrzfkPqS/WzFRrQEwYh1AZG3h9INUbDG2RxPLBnyEn/d4k5PiaZz5Ac+wuo3fo383gNU8Mc/q/9DxPdFsO/cufNdZc451us1VVXxD//hP/yPbhjA5z73OX7hF36Bn/u5n2O1WgHwF//iX+TTn/40f/Nv/k1+6qd+6n9UYmumGwlDweBP8XKNNzjG+29iDuZ4+RK53jDHY2tGto/PWIQBlYpIzMAP3vwow/QWXrMjN4+410esgwkyz+mDnDq5hmsuCUzJraEhmt2hnhtyf2TbKLpZwjZ0zLRC/8Zvo/qK+Id/BD2OFJdrXmseMIsXHE7u4IdzvItXEF5MF18niXIG7eOPI7QbRis4W2twOyaeoWsrEIrlJKOUHdY42swRxBErFyN6hyoqPAmNdJgvP4+6fRv/6acRnqbvMzRLlP8ALVvOi4J46JhP53jxjLJv8S8e4U2PCFcriscb5sS88/oHePn8Bb5UfYX+Tkr+xbs8/pcv8vlPP41HRCBjbq+u8e7ZdSZ9w7ViwMSHzA/fxt78NsgLNgKq3RbdasI0YzAafxzJ0zk2GpndWPDo1cfowHB48B7Mq2vcMNC5jNn0Cdi+iLM9ZXFJ2WwZRp80OgBl8dsaD5BGM+gK9vYIsj268zMCJwHFWGxJjSOKPOxijisLzO6MKgZnIIqz73gU50pxMWqKtiPK9ymHgtBsyZOc06Fj2zdM8wmhm1BUGyI7ErceMjCIKKf76u/inKN77p3MhCUxI9pqpvOUwhiGYmA9zPjZmz/FRd/Sm54y36fYdnQuom8E8eoIXnkDc7xlGSmsPUPOM6b+nLg+gTgCPFQcoBKfUVuC2qB7QzhfQZLSlRW7i4J4mRH6IVIYam1JpGTsBwRXSqx/CF+CFIoOhwxizG6kG3ukLAjyHNlp4rFHpw4vTDBGMfn3fLGtGZDKIWWM0RYxGGTigc6QZkvgOkYVkciUc7fD2IHNOBAzIryUptaIYbhSAU6vlGYFoKSkKQpyP6XPPE5Mg/y21sLQapT0kE6Thgknpqc1NXkCdbXFRAmy7BizmEU4x+56tOuRgULbFhd6EFkKDXgh+bgmjObYwZHNfML9Q+7VJdvmksETOBthOsfo1+hhgpWw3m3ohcKnRXQdiZsSRDOkE2AiTOAxxoqmv0ezecjoTdkOhmHXEQeKiadorQ+dw7YhLQWLvWsY36O9PMefevhhhxozqvMC0cesPEsqR4ya0QwdNVB2BX05ECiP9PotFqNH0Iy4qiZMM2I55ezRKYluiKYJvr/C9DWRaBh2mn6w+EGELgYmq33k7BqIkFhKjFBc33uG3rxFp1sYe0yUQSgZNydIt6Wbx3RO0muLPD1B1ZBKRSQHFi+8jP/kEW0+QeqWYX2Jkg7rOy4yD+lleMEeUjRsenC7AWkNN5SmKgqCsWZPebgy5mEX4NmSG66ikVsW82cZ0iX3Rk128ohrX/o9/OefJ3/tDcLL9fc0djgp6Z97BvcTP8zr7/swDxZPMLmWczBVVGOLt7skSy1D0eCmAXoQTAPLSbTg9Z1FV1uEGjDnGwKp+fidn+I/v/nX+I2T3+f/9cY/53fXf4DjTxayebW9y6t3714d3IRn+oz3fOOUj+79EH/xiQ/zi2df4LMnv8Y8DLhx+6OE1mOIVxR9gT55xNfa3+cL25exxSMCafjJp3+QT9/5JNW9U3bSR37zdfr1jvqTP0LqpXiX58Rxwrsnz/K4XfON4g3E4ohwjLlfBtzYN3jWMThHU+ywKkTlMS+enWHGlogIXWiyKLwiihaiaUa3Hgi1JPItdmwwYiDLp3TWchgpCHpG6bj0UvZnPnueR4DACIv0Hb5p8ZIJgfExtuHEB9v0dIFm7EeEdQyxoBw1m06RBYo03UOfnzAYj7IayROJsYZ8tc94cZ9w1KTXn6UoahrTU2xLZlvQRiM8hQgjroc+94XGefF3FvC+079Zx2gdeRjTmY7UpST+lTXgRmwI8pG6sfTNgKHhaL4gzWMgRksQ2uCqEqtHQiNo1zXSa2miAddGeE4ghKb3AyIn8KzGDT1uuUSEPm47YjyBC6A2AxddxeAgVjlnxT38yRSs4ZHbEssYVXtEyjLLQ5yokWkA5YCUV32+bVsiT9H5Ps456rHGOUfu53ieR5BGNEVLNypMX6F8ifVDAiXJAsfjtiGVMUnmEyU+Y9uzbTpuzfbY9TM21SWyPMfzpzyx/wTntUdVdOTCx3QWbybJZMTYOobIUDuHUoLZZEG7OwW9xZ8coMcB5xzWOKJAUrYtle6ZLmaIEUx3yXB+F5mEeMKikuvIYHY1PsiSRCVMvRmFLSmHkiAKvjPflUKySJac9T3nuxMOujlSG7z5EiHdVYpPt7sKHf+T+gzrGHY1IoqJZxm6rin7nsJZCGOaWlMby94kZ1b0FMWW87ai9sCEc4L5hGA+RyZXwmpR11IKxSglWR4gJHT1SJT5dGPHcm+fiT+7cqQwDcPUp/ciUjuCtYSRJIoX9H1AmE8R2tBqi4pgmvjUTYMKBD0B0ouZRCPGzqAKiCcBBgFW4zTUwlB3hif3r0EkefX8Pls0tz0fH8XJGFBHU+bCEAYNfntBImpKodlWUzKnmfg+QRygdw2d9tjPFdJ39NYQBiumfohxJ6zVmt1xBWPP5PpT4HlgS/LkGuW6IIxClJoxjsc8rE+YBXvMpnP8oiRIBWbomGnB1re02jKPY+I4p5ANZy5m/s53IKYxu05B17F8/Brtt75B/epbOKOgH9jd3GN9Y8lBsE+721B6M5w10Hc00icRPU04oekbuu4t0uw5ApPRpx7GWobyAiMF0WQEFVFWPiqwxMpi2oFgFdHpgVzOGc0DXu8ueX/yDLEytN0DUj8j8RT+IscbHfHGYEMfGUXUQUpvI/xggxYV7bBHMp0RCoEpC5Iw5+yZW+y9uCB443XM48d4t299T+Pff6r4vgj2brf7rhBtpRQHBwf82I/9GJ/61Kf+TBr38z//8wDfVd+nPvUpPvvZz/LlL3+ZD33oQ38m1/pPAc4b8fwGEc5pKfDNhiGJEdpHtxvC0OGLhM3uBKdGDvdiXFmgjOGp597BQ+FRqQjXZXTtfXpZkPkhmbFEriM/OGC91piuJfYUUwV1pZkun2SZCR7c/Sbh577CbFfhGYN4uMG7NeXll77I+bDjP7v+AcLD6wyDJHYJIvCpT+7jiyNcIlB2h64DzvspYnuJoacKQprRI8wWRFScuIZAH4DRXEsiptMjVBIzXr6CjCTha6cMbYF9//twgYdkSxxMubxoGMUcG7X0u3P2FzPCYEK3K9h6KYfFmuTwgNF6KK1pIscP3vkED4pX+LXT30D2luvXfJ5+c+Rjuyk33/5Jnlm8h70bCzy9ozh9xCNRkbmGPBjpLx4y8TzCSUy/aZBO0RQb5L7iIN+n2nYUbY8/6SANEWWFF9dEy32q7Tn92Tn90YxQ5TAqRt9QNZqpWJJFKWYeovqO5tEDZNDhhRp7+A5UtqS8eERQ92SDYGcKksMbqMUCT0qcjWnPW9raESUZyvO+Q7A9KQix7PqBRZZzqQdiU9O3Ai1jGteSS0sSx5ysH3E4OyLoWzrnI/2M8cXnGa4/gX90jdgOmKZDAC5JmDVnkITckxI9+kwQFGjsxSmT0SCkwIVzmjvP4b/yOuFuTXb7Dsb1FL0hMg2eJ+m7kThyxLMJTkJf7AjlDhckjGpFHE3pjKAoH5KHDm+6xMfSA42xV/lyQYRUf/S/MWbAsyGbogWb440S3wfPd/iRJbi9z3B8TL+5pBBXk8/Yv+r6hm6gLSuSSQKEdLuBUAm8PMD2EttFRFz9RkVbMZssSD1FOW45GzroYZbGeFJhnCTVGu/bYYvogXFbkNy4BbFg4mI86XFeXBCZlDCPGLc7mqYh1g6CgEmWsqtLLjaX2LEj3btOFuXUsqJ1HZN8Tl+WOA2tknjTHLnZInqHThWu7Yh1RBDFTLIJ7fkpfjrBTvc4362xmxOmw4AXx+ihZ7q3IE0SMDXj5gLPnyO9ENt1KCLCbI5UjmL9mCCLCcSEA+UIEw+tNbru2Z4VdMMG/1CxUwNRrIgnU/q+YpXkVC5gGHZcXvT0rmSiB1qzoRsKsnhFpFLSIKHkkihOiJIMU5QEwmOIFEFjOduc4OURB8s7lBclRVshQsU4SJLIwzMeTlqC/QM6JWm6hsSDC6OxxuMgmuAOoH58Dqyw+QS5Z+hFS9cbxg76MCI2lrh8yNT3ab66Jv7c5wleWhL/b/53CKtxkUPZHtP1bLsto4qZ+IYk8LkcDL3WxFOP2XRKWXtUZQjVBePgUwY9N4MdyYNXmb50n/krv0H80otEb7yOsPZ7Hi/G2YLdhz+C+eEf4eypp4mXGa2tqFzEtSfvIL2Bmo5V6LE7fwPpbiG0pNid0vQjFy7h3AioJdGQMnJKcHGK9iKqdMq6HfmAf5tnnvu/UPiaf/z6/53Pnvware3+g217Lax47fg3+IXj3wDg6ewmqRfzRvmI/7PKeff0DnU+8vL9N/nK46/RRoYkynl28WE+duNdPOcPmAf3MCpiDCVHX/8yxWRC9qEP485O0WVNHUN68w4f1oJfuvgyz+vP8aH4x9k4WPkwNT2Rk4xthxcq9HDJjWDEThYQwEV1jp34XDQac9EzSQVdLwmUZOxG+mHH4Du02WH9I5rR0N1/wKlLiTOPJ/II3RikgCANsW7E9jUyyvFtTNcMSDlwZByJHchFwJBnnLuaXhjO2pE70zmMHUmoEGmG3o50piefhERpitr59Jtzwls/wHSaEpYF1TKm7yu2qicVEX5do/uGkZE82PuuTYfBXD1bsyhlN2zoTU/kRXjGsYgXtHFI2Z7RpYqciFD8UecqkwRXlFevCtK9fdptjTQ+VblBNgNeXeL7O0gCahkztVt0LOnwrlKSrKHrHVYYuqYCGRIhCHSPQuL5ik5vmPuSJFgQE7LIAnAWXVrsYBCeRAmFsxbbdcRJQgt01lGNFYEKCLyriCQ/Dtk8PCZAMJknZHlKKSCSgsh4DLsSkQ1E6VX+dj8KhDCEnsRHoiZzyuIBB5Vmcn1B52mK84oxiDA+OOVYRBnbGta7Dht7zEOf0BcMFz7aCPzQ4BqB7gdw4PSI6ztcHCBDwzgWuEDghVNEWSN9iZxOrsYza9BCk4UJttcEQcJgttRjTRZk37k3Sir2poc8uv8tzncVB7eeuYq8Aogm0F2JnhH8UT7+H8JZh21GurZDJyG7MGJwjvb0lMBTTLMZo3J0w8A08HFpxDQquLARj1zKRAiyNEZ8e9HNlCW+1firPepdQS4tcR7TVSNV2TKOPbPJCl9FiNbg2p4w26PRDeyFhI/XjK1POFsyCTwGK8jiiHvrhnnqk8YRp8UpXbMmDDIOV7cxbc/QQz1qYhHizIgWirEdqaXBSUHuK+Z717g4f4WLyMfgrqJaNho/VljhCGzGfP4Bdt5d2vEt2AzsxARvrvDqR1QXITKMmc0jhr6l80ayIMP3E2bCoyo3bB+9iR+s2M8m1LuHeHHKPFlQ6JFHZ2taaZhlEzZjD6Il8SRjEHBSbpjPbjALArR9QFXX3Ln+DrJkj62pOVMtO9GSzFK6hw67nLD8kQ+SDiWP/uALDF98iUmx4eSH3kMeTZgtb1A3Je12S56lbHc7WqPotqekjPTxhJ3tibsTxjbGz2a4KEJXG4Q5YTKbMegpQ9uTKw9MTygECo/OaVaj5GH9kF4p5sFtgnifZLygPLvP3uJZvNHS2Q1RtqBoesJZyK7XpH5AKyaIfo0RNYlIafyBaLwkHCrs2LP9yR/m4Pmv0Mvx3zNV/R82vi+C/cwzz/BP/sk/+bNuy3fh+eefZzKZfGf3+g/x1FNPAfD1r3/9TyTYfd/T93+Um1wUV+It1lrs9zGZ+XPHW29BXxC5FqUydusS268J57fpo4zHr3wZz/SUs33CC0U+DwhNREsLkaLsB9J0QpCVnO8aUt2Ru4p47w7h2DFYiEdHF88xSUVUrPH8gE4CvmEvTol/7fcZHx6z+/gPEn3rdcTvf57z1ac5Lu+TCcmTq3cipce4e4A9fJJwtcR/7Zv0lxWyOMOKlrPdHoOrCSlo8dFbhZYKqzsG74Rpfg2rc1zzkEWeEM5XdHWD8CV+r/Cff5UhCtkdTYm299HjCX72Noay41R7hJ6Pbk7wZh8lyafUD15ms3Vci2JUtWHnUsLcZz1UrNQRP/PUZ3j58iFPB0dER5/B/7mf5wdeE+h37jM0I2XZEjePMUFOMI3wy2PsdAnb/kpcqO0YTcvq2nM8ODlGbC2Lw1skWvHgrKQ2OwZlCeyC0+2GySJG76/YHJ9w+uqaNA3pdx3FUGCcz2EywVqLJwVd114J1rgd5ajpZExtNG3soQqf7GLLMIM6dEhrqPodri2ROMauI5qurgRLnEF++5EOxgHrHIX1sfh0buRyVxDO95kHPqFpqZ1ldI6x7giygNYGjF/7In3VYT75HlazjH59AV2PmkwZPIUpzrBJzHSWY89CiqZlFu0h6gcQOPbTARmuuPfsc4hf+SXc2Tm76UcITcP24pjl3h5JHNKevcW4kgTJCj0aXLvBV5Zhbx87KEzZQJDQRRGuaXHlGjXP8czIZnAEbYsfJhirGUeN7g1dUyNtyGA0UvYs93KkuPrvj12HTD3IQtzxwNaU7O2nCAFDP7I73+KcJZtHIARDoWlHSCc+eAIrI3zX0g7njEYxt1NCP2TsS7r2gtFf0RhHJBWhUtR1/R2tCF3scBZs6tHqlmlynVCmnBYXDGrLTEzQu4pGgcwzXNVT24CIkHoUzIIFSZwxxpLOaR5Vj9gNG7rtKd7sCYIwZmot603JYCD1HXXRkjQJgQzACLpEoYaCqJWYTLFuNfVlxSryWaVTJvEEIQTWpTCeM4QNQRBjNgPCNIhFxuVoqVXKoTBMvA5cihgUagBda1yv2TuckM4+wsnJ6+iuxIsCzFgznx0SxxM21QZXaC6qhhOnsW1D0GRUfU20p+hMQ90WTBZ7uNiHMMCTKRfbDVHvIUNAGfptRdf07HqNChRplmG7Cyo74sIIpUIq21PXl4TTmNpCWa55Lp0gi566LBnjmDLeozUtMLAMFWe9QgUhS6HocVTegPrN30E5ib3Ywi/8PN5P/gXC5QFyrGmFxdUaz5uzimPasUEqn71ZzmyV0caK/cmMqi2ZfvkFwm+8xNveeJHstTdR7X+YoP5JqJ95jvHjH6f62A9y/t73kWPwRsOwNhQ+yPWG2TRCyhGVZJy2A4FucQLeWK8Z1BQzbBnrGq1y/KCDvibNc3YPHyEuCupbE2aJIvRCYuFTo9lP9/gHH/qH/I2zv87rl/d4oXuNL28+z4v1Xbo/BeF+vbqyofz69lV++fGvci0+YhrOOIxvcjt+kh9Z/jgfOXqSzfaC2Hls1ztIFM3+Pt4v/RJtU9D/5F9kcnxBXJ7hH2WM5WPC2Yxx/zn+s6bhs83X+Ob4O3zy2k/T9QYVavzGp2lqOm+ABhbpgsIL8FPBraevsRMjRdfTygBhBzxpcVGI33oU/TmezGBURNOYeqi5POvQfsKtgwCFoDcW7RzTWURbFmih8VSEAxoT4EbDRGm6tib0A0SQ4pqKm3mG6T1iGTIwMAifUAikZ3FaY8cIYwxeHDHszjC9QSQppqyI/Yyp8KjLkpOoRQwNsmuwo8ZT8XfNb5p+ROKuRKxQ1ENNIIMrSyo/IFMpKxlxLgxOpbRtgxeFSKlwQYATgBMMXU8yNkjfw/kTRjMSRSGuvQqblutLmnCPWniE0jIMA/EIQSBRVYcLe/aDmNxP2baX5KKnDhKqdoP2U8wQE8Y+KugwUoEBi8O21VVk0mgQtsdZi4pClHE0o6bsSybB5DvfW/gSoTryfcdkniClQg8jqnfUnSH0A/AHrLW0owGriH1B2ze0QwnKIz96kv7xKcPQk/sRW12ybXr8WIJvibwAL7Rs6oGsAT/wsMOIJyw2XKH1gLYdXesx9gJBTehbegbG0UeGKaLzUbGPGzpMp7HbLXI6pdUtWlt6FLtti4s9rPIxtsSXPr789/JTh5EZCWtVszYVSxMihQQvBm+AdgtI8P6IsozG0pYD7TBSo4n8hMRZMt8nSSICaylOLlGex9zTrHewmvlEWc6krjltRzzTk+0fXDlhlCWurgmnOV6tqc83jENDImKCSHG+3jLWI/E0QfcW3w2U2hEYSZ6kDKJF0NEUGpVb0sRnO1jqfsRZi7OOs+0FFxf3EZ7P6E1QnUUMGtEX2GxO1Y0EpqXtHf2gkbnD8wWJhR5NKkCJGUSWJDL0pWUcOpySLMMZcZwxDEdI9wiZSsbsiHV3yrh7BX2ZkB8d4pSlbjfYMMQLfNp6IFCWXESceAm5c4zdGbvdPbK9O0Q2odpuuH++YRlPSJd7zMsNtt1xqQxhklPWpyTFmrMkhDTELzS2LVBZxtyl+IQcmw27UOCvItpdy71XH3LrmRucPfUc49EdspsThpO3yNMj/DDEZgHz7ZaJElyg6OotNOdE8YpkNqEaek62D0iKFs97F6McQbVXYdzqJpVWCDnQbmvGuiaLBLr3GKXCKcur1atE0YqYjCjIkLLE7F4jnj6LHDoa6fBTi72UdK2lHlqieGQQHk3nEYlzKp1StD1Zf0x595LTgxm/Xv0en0t+mwc/9//g/v/xAZ783umptfYqauTPkeN9L3V/XwT7C1/4wn/n+/fv3+fWrf/4Lf7z83Mmk8l3lf9h2fn5+Z/42X/0j/4R/+Af/IPvKt9sNuj/BD3Wpn/5L5N94QvESYw52mcyX1Jc2ye4eY366Cmsr8nm+zwYeiZaIIeO9YMaMZ0RpCl3H75IljzJIrR4tif3M/qhYsyg6Qz9m69jbt/hYizx6i2mbXEuwZeK/qJn+3O/z/S45vzJZzm58w7iVhN96fPoP/giJ6ue1BmyMWP95gOSeGBtBfLhmwjlaNsRtm/xcCiphop0FiOmGdVuR1FtqbIpk3FgjAe8wePB5QnX6nPGwyewgaY9ecRoFO5bj/DWGzbvfTv60avkgSW0YKbHPFh3nNU9T/gWZTsu6pIwkhRG45yibCRnxyeUeYlYXWfXtSRnWxbeTd4RJfSXx6gohw9+HPvbv4X75tdZP/kcxdoxSUfavTlTPTB2LQ+256yakI0IicXI2eaM076jlhNkp7jo7uFFAef1mvOzgolyrJzmQjuSfo2K9hjsQP3GQ5rFjDHXeGPIcnmTs7ph7AxptSEvCsJZSICjG326e29wGYbIroIhxptOaUXLm6+/iJ9OCJOcfnOMN1pcGxGaDTaJGC5A+Vcr122xY0Ry0micKXmrHpgpj2V1jIlyXu3X9NZhx5GT02MicR0pB+rf/V1Er/GfukXd1NTHxyhjiaKIzcMT2vUpYrKPEJbl1CLEiPQcia8oraTbPAK/47yGwyQievAGRgaUrmOoB16NFQdO4F2sCfuetFnQDz3aCkwUUUuNdQaKgW1jcFJxqRXm9IJguETUS9bOQxRbFvOcbnOJ6TVCKJxY4wcprekZy4Y8nSGVYWiaq5313Q4VDDQyoHx8RuIc1kwpLwrMqPGjGHexRgqBbUd646h0TRB7uFoz6pptc4z0DtjoLZutZhh2KAWJrOl2DWf4eFIS9z1us0HaER49ZvQCqvVjRtkSmJGyWSMsDKrhweMHuPXIMJ2z9GMoax4VG7zYEijDODj6okExIbUZjzdvUnSPqYMBL6xYmPvsio76coOfZFyerem3LedtjUwd9fqSTVoQW8WNRpBM5sRpzuNyx0lt6QxszUASKITucI3FqQHqR8hSMriS7ZDRti0TYTGtodSnmDbAEdNj2W13CH9D4M1o2wa6ivPj1wjyJXFpuBQVbpBc1Gfo8gJhFxRuxirqYAjYlQ1xCOflI0arcXclNgSHRRtD2e2IXEVRVWwHn7Otw/SGIpD0YU5enWIv3mQdTFBygdycUtQ9amjpmgkn7cg87DnfVeSbAuMsd+WOTJfQa07LgtaFtBaSCALnU4wGc/8t0l3J+Yc+SlhuiF99k/4DO8b5DNE7TmipdYicHlD4I+d1hQ9kEciXv4j69c9x7Xe/SP7CN5Dfow/1H2KMIra3nsCLIvTBAbVQVB94P91738dFEBGUFcY3lNuWs8uR7Rhy0MJW9TSvv4r0c0wsOO63BMGU0BZof43rDL7LmQYl43jCVkniZEJ2dheM4+FhwGH3OmW0INAnbLRF64Z5cpPRT3h28QTP8hQ/Hd5hmz/N67vXeKP/Ci9sX+Cl5s0/UXTz38fj9pjH7TEvb18G4Bcf/Dzvnb6T57yn+djqnXzi9jsR48DjF7/F7Ksvcm9/jh9L7MOH6MOMeG8fe+8hzb17kN1iFa94z/Acn6++yZfPP89HvU9yPziBesAOO6hCfDul1SWeq+itpJyleG2N73tYPXBe9tAWOA+kUnT1BdIOCLnEDBUXxSVOCKa2hmbDTvgMrcE5x3Da4LpTGuXhuwRrLcfbAtu2jBiaZkeJZhjWV2k3/oq+HdnpAetaisFRn19g9UjmK7YbQ7ETaLelG3v0w0e46ZRdVdNUNSaLEZtzhGfoshDTlgy7nrP1lu+stnKVundZjySBYj2oq7SesWRUPWJXIPMc2zb0dccyn7AZDA/LkmXXE8RX0T6u6zBVzWgszdjQRQvKcsBR05qCtihQU40fZMS+jx4l3vYCMYQI6TFkgu32kogIREhJya54RC8U5SgYx4LeG/A9Qc+GTVVRqphQGGg6xvYEL9+ntT22LxG+j/R2NMayGTrq/pIoi1j3a5xzlLsd9WqCNCPDxVtIOeW0s8SDw3kCGVi2u5KxHql7SagkIxXl+SVN05CEC/IoZ5NEFPffZDY9ohUdjx+fEc8lKnP4g89FP9JaR6zhpCrxbYPQmiHIcRcay46h2aJ7SzwFFWXsuhDlBQRK49oe1i1KtRiVY8/O0OcXnEnD6CST0BKNFm9UlMLSmJI6rpmFs6v7Mo7Y3Q78ACEizo+PKdOrxQYpvu260bWwfZMxmtOj6KzFNgbhwImBwBnC0McOHWVdYa1FqIDT4wumYY/WAxs3RcY90VhT1SWjgkILgosdbmiJpUVNpkjPoyk7iqYlvjxD4xBSsinPGMqey3BLIDT9uqDRjrBck8iMsj7HmB3jNqBVp0z292kHy2k5kIeCe0VBW1/Q6IHpNCEaDWNbY/uOiop+HJFeTNrU9FXDJBqwviBUIVVXsxnPaK1hUSsu7EgXNWg5Uuw0czmlmva0pz39eo3TKUXYkI1binGPk+NXiWVNMCasLwbqrkKm+7AFqzW+Leiko7Aeyjkev/EGndggk5bOWh7uzrGNoRk8GiCvL6hsiZ4GpAYsEY83O4LOoZxBA8dFh/BOcAbc6DG3I2+ZiMGvcX7L5ckFm+KUx4MlTUvu3TP4jeFSBxS2ZPQkczNyvilZj5ameoSnHeHkEE81eHQUbUvXnZPu3qIfMno9kvkB9fEpQ+BQdmTz4ATd9ASRz3bwyXLH105e5GR7wfXwvQjncXr+Gv4kwvNnXDx8HS19dp7D1I/p3Zz69ByjI8oZKC/grGy5KTcM45q752/yxfPP83vlK7zw4n9btPOXv/HL/NCNH/qex0xrLWVZ4pxDSvkf/sD3gbIs/9Tn/pmLnAH8zM/8DF/96lf/PKr+U+Pv/t2/y9/+23/7O8dFUXDz5k3m8/kfS9r/+4Z49AgA1bSoN+6x4B6LP+a855IUe3hAu8jorl3DPXmb8aknOJ0LxE0fO30biyTEth66PSfKJOvWp2FEJ4ZFs6ZNQxI/IogPidID9H/1XzK88hbje97F5KMfwSYB7cc/Tvvq15i99BLbH7vJ4fIaz1Q1jbNMjw7wooF1tUZEGdLzqKI72EFzu6sJkZDMeb2t2GWOZZRwPUiJlwYvnrA9echekrF34wjESDer6dsZ9pWX0L5g8v53sBtO8byYabBkyGdE7Qkr65HlGda3aN8wtjsIIm7nR2TG4vwtQXeKVAvmq31UITFDiy80wXzJfrzC/6Ejzr7+PPHLr8Kd2/ShxSzukMUzjqIE61U89ASTaUocTRnsSEML42NCX5PG1/GcAbthkTqKTnJrknIoLbshRaSQdhLpTSkPBU0M0bRntbdHOrtOuWt4eLwDCdH+AQt/h5/fQqYrNmcnFOs1WTwhvHaNNA95NBaoQhNrmDaOVkbYmU+TRixdiog9wnxCmCQYPRJwlWu3rjVtr0loed+N26h+w1aELGIfZy0eDtH1BLNDwvYMc7zGPfd2Zgd7JFFElGYYJUn3VmzeekCyXDA9fBbbNaykQ/gWNUvZzw+YiAzbX3JWDeBb1JNPEL3yMlPlKFKfxZ1nsP6SPkrxXUArBsIgINQt09mSKMmJ/RnjOOLyge1bpzy1t8K4ANm1ZLnElx3OCdrplNXePsOwY/QUSRaCmON5M9q6pxM75qsZYRjQVSV6HHFOo/UOd/0JpL4gwyJHRxIEzPZCtItRcYYPuNjhQkVfa4JIIVNY7wyH8R7WJAjrE8cRi4XC92/h7ICWpzgvpplOMEgSIRnfeoMxiMmfuMVWn7CYXCNVM0ZlCHwLtaQOJY8XHTL2OTxcMO4nlKcP8LIVRxjG0hJ6IdFsSleW2L0jzss1h2nO0f5N+rrg5Lwkmnu0nsILPfKFj9UaD1iu9hFRRuxlTESOa1pGGZCnFtcERLMM4/s01hH1HbPlijGNMeU5ei/BtT2Zkjxx8zquawnCGG+YYNyOTlvaviGe7JgdTImTPZSKmHqKu48f4PcDkyRFRwpix8KFjN6M+fQOd49b6toyXyp6q2h8gzOKVbZPLBP8xEN5CtH11FVLpRWRe5o+grmaolvHcpoyXU7J7r2ImF0jSFd46RE6DEkpWQUJFw1E3SOeDpZYM1CnBdn+LRJjmamObLHHuW3IZUAQBmRjRzYo2iwh+ObrhLeewf/0j9BvO/x/8ytEf/D7JO+6SekyhGlZRTcgTen6kmvfvMvB736e5Dd/E/Hqa99z/2+lon7qSZr3v4v4Iz9IfW3Ko2pD+NuvIqOA+i/95+Q//1+TXJ5xnK0o2pFVkGPmK+rqLYL9gaWIyfyI/aOcatyhdxUrL8DkK2on8M2IZwaMl5Dlh/gpDPUZc1/g53t4pcUGMx7deQrjDDkbpk8+wbzUPB4CpkFGejNmrM/h+C6TvWtc+vtoPJ5oE/4X2Q8iU5+78QlvvPItvvbg9/l38TmN+w8T7u244bcvfoff5nf4L04gejnk3dNn+eBZwLujCfN3vIcnvBaeWKIPrizb1P4dtD0mjXousgkfCT7I40TzsH2Lx9Wr5NW7UG4gWMzI968ReHtEesSrRxpfUQvwPI80yeidIPYDzruaTa85nM2I4gRcjxfNqIcWqzzyvQMOpUcwGHQQkywS/NBjrHoECWRTstmCxlhCMzK1Ocs8oy7OOY1HdOB4cvIk03DKadEhdE8Q79NsC2I/IvFgPsmwxtGUHd1OME4WeCZAAcNqxUQZlr5FPXkTN4CcLRh3DyiGM8rIYzKd4X3b3qgfDdofWaYBnpI45/A7H3+wpGKGWq0YuvbqfzObM7OWkzBCmJH5fH6lTj2fYy4u6EeLlAOzWco4+EhPoqtzVBowObyNms1YJXs0uwz94A1UFKOjkCZomM7nHK1WeGkIusfZmMYLmRNTrgNkOPLUwXVG2xMYDyUUuQIbCLRqiQ/2sbselEPtLZBBQG4du+KELJxxfXkdKSR6NFS6ZxZP8PwUaQvEYImDlGuLkMYTeFLgTEzRDsyiCassZN1Jjs/vc/3oOqla4keK3Co28gKCjlW8pFp3RKlkNs/Jwpx125MjuBH6tEWP22riwxVECV01IlRGwWNkFrG8doiUMf6oSaQk8xROW+zFGSJOGJI5Vd1i1mvCseDG0U0W+QS0xbaaBXDZJtSmJAh9Ei/E7LaIvT3UbIYeBqpqyxg4lK+YhbOrVAE3Z6zOOR80QTol7yGIIEx82mpHEEUEcYLRmhaHF6dsGsvezZj57i796BHfXjGaDWG+hyxGbnkBdpqQBwnjyUCQ58xv3ryav8oOOxri2JFnKTLwqYZLltGEWPiI0eBPV+Spj1KOZDIl91rWSUBhahIUq9WKsB3ZmII4uVqE3/oZ84XiuckSlR/QbzZM9Y4+hnrIOB0UlR3xVIhWkiiKuDadw6Ap62MOj24z75fkvqKYhBS7DWkY8ORsBtZhHl+iRMj0be/nfDylqc6ZR3uc+oe4dMvy2gF6NEyrRygbksgOf+IzDlPwQq45fSVOWpyxd/2dZLM55+0FycGM/XPD2pdMhIMIYjXnxo0nOTl/gF1fucXs+dfxAoXntRhpCecJnrNQnNMXHbfThGYy5SIVBJnh4uGGRAYkYYoaDXOZ0Mg9WhVyPYuYhj6VuiR69BaeypD5TZYHTxDliqgs6UZDnaxQvmSeL9iaAasMocs4TDzqMaKyx+RhQLA/Q6opobfjd998Hqk83n/wfp6Ukq78JpH0ePLpT2K2Bc4OzPrHlMkUk97m7NElSxOzSQyL5T4X5Vf5pbc+y68+/hzfKO/+iePBv330b/npd3/vTlHWWoQQzOfzPzeC/Z0UwD/NuX+ak37sx37se2rA66+//j2d/ydhtVrxzW9+87vK/zDce29v70/8bBiGhOF3R/JLKf/cfvjvG8MADx/+qU71mxru3iW8C/DCd8r/MF7AzKaY208yvO8DlG97BvP+W8TzOduh5/7JKUdxwE5n4Pt4WiH+v/8N/v2HmOfeQfWJ97GIPYJJxn054L/r/chf/SzTV7/B7NM/QbV+wDCb81j3zIAxTBFMiAOJ5Igw1yTFmzhjaPyONJ8gi5bUFkgDQy0wzWPm9Sne3jWUMIztKUGaIU+vQlL44McZ4xxnBoLDp9DtwGYzECufaKUQJmH/8AZrZyjbBtOFTPMAE0l2uwpHTL1+gMwTwrXGJC2pHVnu3SIK5/SXW/jhDzH8618h+sqXGD7xYbok4VoWw3bEV3OC3ZYiy5gkIfdPtkjZsEhDMtvTqwt8ExLLq7C7KJNEYYLcVWTdhma2RIYd/sMNs4OUyhtxo2ZYn4AdcSZnEfvETqBlz6W2TLMjYq25tB0uTehtitcXtHmEkorVwbP05QW7tx6Q2hEX7LGNPKwVBGbE6hEpJcM4YpXiTAsUAqElR9MY40sqm+MPJU+nU5zVmLrkvpXsugb1B18k8SKCj32IrioIhoEgCOiTmMuze3S25vryGUSQI9sSPfQIPSJ0i/Mj4iijampk15KHgurGIdEbL2Ne+jr6/W8n3b9GMjjWRUe2PGDUFV2YUbqQ/aFAZjM8z7si2H7AaAcm+R6696nGnsEkOOGIux2jFzEqDz2AVBWIESlDrAyQ1hH5AVqNxDIiznKaYoe2LRqF1pbZckVz9hhR3Gd2bU4UJAzDwDA4fAUq9pGBAisYe8PodzgJE7Xkot7gBT6+CvF9D99PEWKCCyuc0ExlRWUsRTtgq1PC2YJiWNP1W/amR4ydwbMDomhxThGmK+J8YLSXHD9+BS+A/TCkN4oh8vD9Ht0OtOsNMvCJlkf01RlLPCZexPFmzSKeolTOufNIAh8vkuj1QCZjFtdWxO4cT3rsxUvG3Y7i8gyrBCKPcBikk2gkl23PsfMZ1hbjNLNZS2oEqenx/ZCx7RmLHcQ+Nh3Y3TtFI5jfWZLlN8D4mGGk7yHsIzbrR5yJDpUeMF8sCXVH48H2/D5mCAiEZegNaTqh6SsWsyW3l09DpXHDSGFrZNeThDGN8ZguDugDgaw70jRBJTNcURPaAfIFocoZo5hRDcS9ApkyFhWzDVTBwBjGdApWyrGv5uyKC/SwZZ7MmMiGnZ9itxu2l+cE33gJ2hH/L/0FsqeeZfd4jfvEJ7G/9Su0v/qbFD/6SVTdsP/7X0X80i8z+/zn8Ha776nL19dv0r/3g4gPf4C3bt6gXh3hPXGdwZes0hy7uWT6L/4pwvRs3/cB6rFDvO/DxF/7KpO7L8HRHQ5URKAEvmfJ95Yw+rTO48Y8wcsOefONL2OHErW/JCagvdyhR0kQCzpTEMgJSTJnwLF+9JCjB48Rszn+1KeTLRM3J14+wcwf2bz1gLFuuPP00zQl1JffZHJwm7L3SGrLrrEMaYgYd7wjeJp3Pvke/k9fmaGv7fHFT1/j85ff5Pndt/jS4y9c5V3+B9CZni+uX+SLHrAPvPFbPHF8nQ/uvYt37z7IO6cf4NlkznJxi2A8JhAjha75yeuf4v9z/ll+b/054l5ye/E2vL0pg+zZTz1Sk9KZCt+3uL5n9K8WV+pB04YSL0p5XBaUrieJc2R7iS0HbNjiogjlBSR5TvPoAmFqVNShxxija4ZmxElDmI60CJTtSVAoEeJPVlT1KyThklk8QwpJHPi0RiOtYdCGynRMJxF9319NFOWAdBLnIsLphKAu6Y0hz0LUCN78OrZtsds1XiuZhCFF11DXHfPZVa7uYA2+pwj8P5rqJX5CU54hghnK864WXIOAsbcEoWKRJZxvtrR9T/ZtASvSDG9XMmjJcLlGDz5JHCKtQ048gniGFoLjXckinmDwGNoNTZwjtWQ5XaKcRCCgL+mcZZSSUMwxoiIPRkKlaI0m8iJ602OcBhHheSO+dAx6BOnhRVcqw6GEwbQkfor3bcvGrh8YheEoSVEq5qwwlO2WLGmJ05xy0KRK4Uiox4ZpDkhH21cIHIvpHkNl0adrPGdZLQ/Y1md09ZpR+VjhoUafyneEShEIceXg4RlaIdEiIvIVfuiwJiOf3cLzI/xvR5hF1jG4q3moZaA3A00d4pQhCCP8wznhbmTWj4hYI4IAPRpCIdkTCeO24/R8wzV8PKWQcQqtwZceofPxRkcvNDu3u3rOlKIO5xT1Yw7LK0tOLw3QY48UgiCOkVLSDz1SKVp3lec+jwV26+NPYiJTcmYHijHDeIJcGhAeQ70lmaUMMqSrR3zP4Y2aSAmGsmZwZ1hfoDdbsvwQ4Qa09ImXU1Qg6KryyrZR+WTRAevoTcZe4/qechxANFRlhwgmdMPIs77HMp/RWUGrMkQkiewFLnCEVU+iDJPpjPvnLaJsWU9njH1NPwysJvt4KiUzDboXDGJGmPvkswi93lJayyhCUj/jMI157XJLq06YTxMam9Lohs4ZVsEUYZaIzCNOPPpGUK93rOIJm/6C2nTkIqVDIYIDVtlI25widmdo5zP6Exb5jFB4REbTe47As+jqHOEJ8jDhvKjZBRVZluPRY1VEbjRTm2GymxRioD65R1ivmbU+02xFQMIujtl0mkwP7OyOXXWBHHtcbRmlpV6fE5uYfrtBlSXj3m3KrmSxWSNSxWVrmc9mVM2a3ckOYzqYJaggIY5SqnrLCxevcDN/hiflgkUMJ+fQ1jWRzZDLJXQFVnZ4qudyaAiiiPvbN/lXL/wyv338W7xy+d187o/Dr939NYQQ35eItRDiz5XnfS/1/qkI9pe+9CU++MEPft8N+n7x3ve+lz/4gz/g8vKS5XL5nfK731Yrfc973vP/9zb9ueDxYxAC3J+s0vqnhdruUNvnCb7+PH8oh9HfuMb0bc9x+Z4PYH/ko4RP7uEmGdG//kXM629hnrmD/eSn0ZOQM++S6vjL1EKz2J9znvr8wOsPaT9Usls+S7Za0Q0pl41mFS+xtaNpJfPVFKk3NFZg8zlCSZZJgKhq6Df0+RTsiqS8zyydwLXn6IMIMYb4+ROMr/xrVBBi3vs+ZDzg1wvabcmubK/y2A4WuKClqQvi7DrxbsPgfLxAEM8ytqHH44tjUq2wTnB4/AihQ3QWEOmYVPr4UYALcyZv/yCXn/1N8pdfRnz4vTRjQ6oWBFmAEwuye8dsXEOdNGy6c/JEc2fvQ0S6oel7Hp+VFM5jEyxIh5rGTtifrYg3D5BWIYMMFSgGIZmEc6JZxvBb/5au/irxj36EwM3Ja4fydzTJhM2uRmpL50tEOuG8NES2ZVYr/HyFkB5SC3q/J2oq9EaQ3vwBejRqcLiiwE6m7NruSsXTWebCEoYh2jecdx2LKGMmNWKoAHhyMuPRdsfd3RlPPf8tojxn8rGPcvbwPuXFmunREdoXXD56SDTNmSQr1kgS3V0RYWPQzZZhcUSiPFrj07UN+9mU6sl34j7362xfe4H2ve9kGUaEgUe87Wi0ZhooBtthfY9q9FF9QxReqZ3WvUZJh4oUYRAiSKjLjjGEwE/IQ0WxuSAyHV5kMKZHyojROJx2TJOY3vRkLkNIiR/H9NszRj9HNCNSW4axJ7EtoVxgwwnKbHFNj4kDlH/VeQaxRz8ObIqCxPMxo0eaXuV+W9vjrPyOqm20vHUl9SIcc2dQF2+wlhHdaknfnOH6kvXpQ2IXEgEuSlFJTq0HwsgnPDG0j9+AfMbRk0+zXV9QGZ/UGoadJQw95GxOP/YsAg9hNecPz9DjwGySst7VXLu2IhUhxXZLqVuchlEaQq5y8pwweHlGUFVEzQgTiZcGOOXh6ga5N+HUT1lXA76cYoYNg1SIdqB7fI+xbzFWk3l7dEVI24ZkUYdpA1o3oJRGeR6DFNR+hz/P8E2MH0xJtCYKc+JsxcOzHcsoZ38ScH56QlE0bMoLZqs9+r7C2Qa92bIBbGSYxQsiBuLZBHvZsq0Lbt/ax/SO9aMzJpFAmAAx+Oz8AeXVhF3MaV2TO6gXE7aZYDKM3MhyHnY1ox3JXEzfrNH+nCKwzD1NOUScvfQiBy+8hL59m+ap/x95/xl1TXaeZ2LXDpWrTnzzF/rr3EAjdANoJCIDzAGkSJHUaCTb4shja43Hy/qhkSyNRtbSD65ZM2NbVrBsS6REiVmkSAoECRIEQKQGQKCBBjr3119+48mV097+8UIgKQEiiKFmKOr+c2pVnbVrn6o6u/a9n+e57ysExiEZD+GxhzEfeT/6//Pj7Pzdv4f3hS8hvs7Ub+s6FI+9AvWmt9Lc/3LWDz5MufsAvTYIYzg6PcUtcqQyeM6Qo3VO9PknOTicUd17mckrH2Z/MMS7527qF55h9Nx1gkceo6rPqNMFSRLg4pwveCX7LIqGqFliYoeshsFiySC4gK/GtElCWmUMgp6tnTF92rFpJc36JmK1hIcuE7cG6xQoLnHj+hF3TScMA8tZukZb8LF0vmFlLV7osDca0GUxpWcxWc+wFehJSDMe4d24w6vax7hwz2P8jfFFjLR8fvYkn7j5aR6fPc6nTx9n2Sy/rut4vbjD9Rt3+PkbvwbArr/Ft198N9938dt4WRhCsaZdu7zzynv4hed/no+dfYyR3mIk72bqbCjqBbIfEU2HGGHQ5bllnXZd9o3hpO6ohMQpcrK6ox+N2EiD17UY2VLIIUM/YtMqxGSCX5xALXE8D+lDy4BV3lDOl6RSYPINZeNiyprTqMHVY3zhclrMGfhTegkVEtG1rJdrCAPUOEIphed5KBdQI+q8oC5W0NX0dYJ3cBmxWmOKApEkNHdu0DY1vh/hNw35bEmEQruaqmgJfIW19iuTVV/5ZHVNE1r0lz2bhfYx3fnzPAhccs9jlheEQYAUAnyPZj4jL1roO8bTbaxyoLfUAVgnpm3XmGxBJfZx3JBZcYIyIbEa4voOdAZbpKT1EutGdK2LCjRR5KFtQ91nWCyJm9AUJU3foG2I63rYpsS2zVcUqwHavkXQ4qjR+f/MWFZ1iecoYsenKXsG1iELEgqRs65XIGJcIdi0Ek85GEpWdYHsIQlGGHrMcoWpevJYMuoNo9EB2eoWm26GZ8a0naCsOsa+Q2EMTd8j64pgEtMaS5W36EBTbxqMdfDU707IXSnJ6pZVb2g3S6yUOI5P7Coc32FRZXjTbWQF/WqN8T1qIeiUIkgCDsItXrr2IsfU3LV7Bak1mHM7LMfx6dOUyATktmCVz0m8hE3X4rWatq9YDhJGwtI1Ncp1kVJh+p6+aailS28ssaPo50ukcojuv5vu6GncpiYHJAqtW9TRMYWv6bYH6M2a6nZJiUIqQSA7MmuxSlLQIqMEMR4jtEZ2PVZbxJcXRPpijQxjIm+A47vkbc3JyTFLVzKQhrkJMI5iX/bEXYTpPJzeIl1JGwzR2Yq8mBO7Y2TT0IU+k6EiWa3xTcdxndH0Lsveow0c9Aa8KqcPQ0axg80yRN/h7yS0s4wm7ZC+S+LuMy+u4zslu+4Oy9KQmg3D3mUQAa6H8SKoU4zp8axC9xVr32FSblDxhMjx0W1LPuhwz56h7BT+3qtx+5rF7HkC2zIdH3AsV1SrnijaIRqPyY83dF2P1xqaNKVD4yqDXi6YqoxrS2hVQBwPGQYaX7Q0qiYYOXgCZJshlht86+MOt5F9iu8FqDAiiQa0aUbnDQm29lmmMdXZMTLfILRPLHJE22HmR7gCWiupV2tMoPjc6fO0bc2rvQcIpKTzeqLBgEoXpKpg4gWYrEFN7uLF08/yz578J3zgxkd4YfO1I9W/FwMn5nseei8/8PI/zbfc+y1/Ihyivi6Cfd999/GhD33o62700Ucf/YY79Hvxgz/4g/zDf/gP+eAHP8gP/uAPfmX/Bz/4Qe65557/VUj/fxBcuQJVxec//T5WTz7Bm9otuHOL6uln6K9fJTw5xZstEN8gAfduH3Jw+5CD3/gQ/A/QTiZUl69AHNK84lXkb3gjKhmgPUvepZi+xM2WzL2AJ197NwcffokHnskY/tlXcmUcUCzW3FyvOMaizAAdBli/oz/LKbUDfceWTTiNfIZuRmdPyfwIr0twVynju6+QBxF5fspQerAs4MWrqEcepvYhcAeo/ZCT559Btw2BBD+6jJABjdmQNRW6l6zqBkJJ2rb4A59o/4B4dQdRWSZasAlB1iD9iHpdQZPhao1z2lC/7jH8j3wY9+NP0X3/LqfLO1wa7eHGCdGRYK5bDtdniHqJF+zQm5jGuJjZTQbGYa1jKjdlZ3dCu+nInZCt6T7B4ow8MLRxh0y2mVaazRNP43zkk9i2wWxq2ne9GYuH6Axh1eNxxixQnDVrmjQjDHfZ2TrAq3vMes1GSdyqRdHTuZIi35DkS/zJlEJ1qNmGbLmk7A2O50Nt0ViGccBxXxGYhrGjQY8hnwEQxBOi2Rnp2TEczzFveSMyCPCloiwLSgl5NUMowcCb0Cof2xmoSpQf47iStthQDA5QRYe1AoRByY5kmODsX6a8dcyqXHJBXAariJOIps2ZlTltkaEF6OGUVHrYfIGQIes0PyeyTYebKEbRiOrFI7J5RjRymO4ccLbJEH2K2/QY93zCVTQ9WkASRix/j1Ku0ha0pu4lsWlJT2/hBQHO4BJtZVl94bPoUBIkD9DjfWVQt9ZSyZy+7RCEeJ5H4PgsN2fUxQrH+93sGaEU/+ZVYMoWJ+vY2b2LdZCQC5Drju64ww4D1PYYPfBpm4Y0T3H6FubXUVWGERGV8UhGW6xPb7PuckbSoyo1NCMiW+H6IfONJc9m7N91QLrcIH2HrUGMQJBuemwHVdGjqpIwCWlNS9VVyFbijsaIvqOrNlg3xAtC8rMZfRgSew77Axdsxa3jAtfpmBBi6grG22RFRTnrWM9X6MhSCweWNc2OQDsBRZOdkzAcHti/QtM2FGlD7CucaIussBgk7lgx3NolCiQvzBZUGwcrYzxqjGxpJgNsWeCHIRUDQlWdi1YerzGyp7cGP9tAU1J4Hg4BynHIdUWgHFLPw9aGcNvF9oapUiAWCHdMrzwmsmTiTDmdN6R9i4wj3CYlli68+BRCGtJ3vJuoqdh88F8x/fDH0O97H+ra9a97zLXbU+y3fzv5O1/DnTc9hIoOUGKPslzTHGUwWzG8MsJozbQK8BOXtG+4EARs1ivExz6KSFy897yRtdxm33fJIk368JsIPvVJoqZhOXFQswXR5CKtB2XdULJhs16z0y8JBzvYoaJcHONs5mztX6aPY4rDW9RNQb44RpuQurG4x9ewwwmjN76Ze/yM56tb6MSDwnDsLIhpMK3h1o3rTJ0VtXXYHG/Qjo+iYhoNOBYZoTfEdgHDaBv90EPo5Qxz6xTrD5jV13GCAQ85D/PglQf5/kvfR7pZ4I7hM7Pf4cMv/hafT5/m+fzru84n1Ywff/Fn+PEXf4ZL8QHvHj3M24LX8Oj2N/Omvdfxm4v386XiE9yz2cFIDylr1jR0XsXAH+InwVe8jLWUTF3NaeDgSYtT9/RCUvtDpqZiVTVseQqvFwhhcSJJVcM6q/DNGcqPMOMtoOC0bundBt30rHpDms7JMOzKPdqu5Sg7ocVHSo/cQllZit5yYTj8/eVr5Qy6gshpaa1D7u9jTQ1NQ+0pyuWMLl/Rq5rSNkyTmMRA1nVUfY1qBH3dnftqpy0ogVAC0XdoFJXocbsW05+Tb6UEXdPj+oqtKOT2YslZVjDQkrZtwfNwSzBKM4oss1WJYwwiCOiQNFUDtqVer6g8ga57POvStQblKjCG9eqQJlBIOcbagsCxtJ5G1y5lneK6I5RUOFJSVSWxjc+vbbZGaB/huF/xVs6aDFeAr0MaY6jrnqpv2I086sLQt4ZB7J6XobSKk3JD4Fg6OaTtDdtRzEl1h0THDGRMISvyo2PczqUZhJyxweYNY2+PcTLm1uyERSFR4T6ilAxcRdr19HmF7nrkwKfrLFXRoNoesJRpw1DDrq9oekNVdyzLBqMsU9URjKbYzoXOnquHm46BO0CNfEhTstmMHhd3OiDPc9ymYT+MOBKGs75hN3CR8vztoyKHXvVYYxkGE9bVmrnJqHuX2PeYui1rAbOyRtU10+EIgKYsKTtL72kSR9GkOTbbEF7YR4mOyrPo1kWtl+g8x7gdKjVE0Ta17YniEKld8lwgtEJFIXVvWXc963pJEoywUiIA7ZxnqjVNQ1dkGFuih3tgDHEQcSPbkJ6eMoqG2GhALxR6mXIAWCKq1uD7GlcKcgOCCZrrTKKWVWs4yVsuTc89wYvZjFg1jIRLoAMaAzOjycoMPwxwmgpTVchBgliXhFsBthdUWUPsjEntkrw75sK0o24Vt3OX3G/Z8UpqG1KWJU1v8TyBLTPqroThNtZa2qojki1pk9JVt0i2x6zXJao9wgb7ZGcV+9M94t0r+Mvr5M4GIQP8eMxg4pKWGTIWKFx87SJ0QbvOqW8fo45LnLGDu7tDHAxxu5LGjdm2Pq7NSYsaIYYMRoJ+vaJ3J+hNg2jOMGVFtJpTAUG2JLI9x3VGvakYBQMa7VF0BtF7jIIOgoC8rzlJj3hi9VmMKRnKmIYFayAZjnGtx3OL27TVM/za87/AL976AM/Nn/u6xvChk/DO7Tfyp658O999+a2I4ZRk564/flnG3yC+LoL9Mz/zM3+oRv+w3/9aeMc73sEP/MAP8Lf+1t/iXe96F1tbW7zvfe/jN37jN/jFX/zFPxErHF+B4/Cb/W2eGS/48NDlrd/+HVzI/gzr+RGLzQZHOVya32bv7A7FpkFeOyY4O8OcnuAfn+Kffm3Bt3/nVIsFzuLcZzX52MewP/5P6B99hPSRl3H22vvwHn4ZlTelcAqOLsBOEnLppRREy8aNGQSS6dGKW3WPs7XP7s6A1ekh9eKU1hWEszl63JJbn7uOj1lmV+EwI64cvLNrBFlD/8ItzGaOckPaT38B9eJV5MBh/CtXoVR0skffuYXjKLJ77kFduR8ZgpUJ685iTUVpK+4abhGYFN94REFAWSgGc4HeTojdjr1kH3d7i+LmIXmTIqWl6yuSR+8jf+kl4mdvEt3KWQ4LEiEY6X3aVpLJBYmnIPLomgEv3Vqz6ykCTzAYS2obMsHj4mjIreYWd7IlbhwR4NHOTygniv34buz1l9C/8C9R21P8e66Qf/YL6NNfJn/rK/CH9+Bc2sOOPer+kImJWDQWoQRpnREogZulFKdH9LYiiR263iGNDXL2InECJki4bWuSkyO2dg/IOpDCYrA4WjPVPqbP6Ex3rsoYnmeCZE1PLDqiF6+B0iweejlJ26KqGpUknKRneLJkNNhH9FBZga0ypJT4gU9pJNpmzDcVrqdo+5okGiD7EvoOdd8r0Z/4TcLZnOJCQV0WDIcj3NMVZ3duMRmOcJXFrBf4o4SMCtMtqMuG6XSIaS3YDjeOGIxd1ouGYg3jHvxgRNmnJP0SWWdYb5uq7Ig8jaMdnM6h6ip87dP3JdZPsPOM/uQU4fj4wyGmbMjTDW2V0c5z1IUEJwwxxiKlYFWuyIqMSTLCwQcEWkiEI+mLHNMefCUqVJctCHA9Tb+cYYTEG49xbcZgXbFaN/ThDs7+Lr2rkGg2mxZsyNgI8l5DMqWXguXtqyQHd+OLmDR0qHyPOs0Zp3NUv6QsO0TjIzxD3QuaumZ3Z5/ewiIt6KwlGccUac9qnhH6Ma4jyKqMRCb4ysWOp5CXNOsFjuPgey7HjcHYFcsuw+kNkTukrnJaneCqFtN1NOuUNuvY3vEZ72/h6QlmtaKXJWs6qqZACZeR75FbDxmFyNU1yjzBGY+wXcUgbOnqDeuVS6AVic6ZBAGz5ZqLo22C6UU2bU2cWgZyxFFaEAQhdXGGVZbR1i5lvSIJYLSrKTsHqwM2dLTCYGzAINIMu45AK3SvUAScNTWZcDmYHhCVN1nXaxIdk/YF66phv8hRtw6J0xW8+lXsv/AFRv+n/4LgD1FP3b/6VRTf+g7kO9+GfvnL2eiMzFQ4asBkcC99Z8jbJcIRbLuWaRQxq3O8xCMahpAt0BqiD7wPmoazd78TPYroSpeVk5C2kupljxI9/QT6M7/Nhb/4Z0hTS1GsEBjkdMg4dNAmQJYKk0mWZyl+4CKHLm2/weQN28GURdVz8/iQJPapMslkneNEQ6LH3sXk5qfRq6vUcsOlCy9jWWf0AxiIFYtihRJH9GKC4zooB1CWi7t7HB0+h6eG2MqhLGqql91F9IXPEhUNzvaExVmO09QE7hp0y6bPmV4+4IELd3N58Qq+a/Jt9Ge3Ob72DE9+9lf4zFbBF++WPHnyOcr+369Ufis75MezQ36c3+C+2z/Lt13+DnZHBzxXH/PS4gUe0PcSSoEba/JmTtunDNwEpTy0Pq9X9ZUklIIzWqzycFvB3tBjXZ1QVx676zVeOCVJNH4zpw5CGuPgLq8TXLoPEfgMgf4sRVU1o8BDhw7SGPZHQ8Z9Qtu2LPsUm91inNxF1xrWRYexEhW4GHvuGEG1huwEggk6GFIHLVlpaJYb5MkGvT2BzuI2Oe5wghlpatmTdBaFBdlT0KITFz90sb2F3mBbQ5/meJ1LUXWUVUZbGPyhwos0VdrSdwalFCGWs+UcMxgyCXx0ELDenCKsQbYVqqjOU7aDiKIpMVWF5yrS9RwnDNmNRmRtS93WQERen1HWBSK6By0cBkFDR4V2PXTTk1UbdsLd8zmKVKyblsg5Fwfr5yfnREhKMBakIO9yYsfHUw5Vb1iXLZ7ucYxH3xm8SCO1RDSGvSDidtGzqTNsYxh6CVa052N4Z5HG4hY1TduR7O1zuknZWEleZWSLNSqOUXnC0aaiSZbsqSHrStErS12U+KGPoxWhhkhJ2qIDa9FKssxaNl1PohSukowDl8hkRNoFN8SqL1tmVSWCc3EuAOP79I6PzGp00dArS56mhFtTdlTPrEjRwmEaeV8h2V4YUm42SGAUj7mRLVjKGscRNKZhKjvmdcfGCjSSQdedE0Xhknga1UE9m5EEDnoyJZ9fp25anK278RZrmsJHDTTEX86EkLCQDn5VgeODsJia8xIrqZDAZDgljn/XXsxaS9s05F1FXnWwzGmbiiYraVtJntbEokFMPA4ch9XZKd4gxBmOKBAEnsLtDEd5ydSJGA4myOIM642gqRCEOAOf9eoMP1a41sUz0LYdnn+eLaG6kmUKw0FM7Hj0XYoIXKglgbbUvUdASNXHLG2BaDIm7mXWMqWoz9BRQt+79NbiOz2L1R06HXBpdIHFasZkc4O0Tljkd5g4hsldr8XeWmKrDKsEpiwp8wq9WaEai1EGoy2m7klCj02Rk2drXHcLfzhEdh2NTZmFFkYFE79ix7UcVjm+9nH6Bn+5RNmWvnVphGHbZjQYoonG1CDrDdVZhm03qO1tDBWqbxgGIXeKFqdPyYXLvG3p3Qh/5DAdTincIfNbNzgqzhjpiI+dfoxsfsK1/pB5esRZccLt8ugPHKP/DcbOiLfvvo1v23s733Tvu8kXM/xgw8nsGnJxjWi8i/TCP7ih/wjwdRHsBx544A/V6F/4C3+Bj33sY99Qh/5t/MRP/AR/62/9Lb7pm74Jz/NwHIdf+IVf4Lu/+7v/SNr/44T/48u/k1/OLJ8tb/Jzn/854hreGD7MoEvwLlwm272AyW7QBCGF2ibq4bm2YnphlwNb0j/7ScTVm7jPHTN49hrOZ59AZNkfeF5RVehPPs74k48zBqyUdBcu0PQtDzcb/MbiN88gf+FfYpWEtmW/7Tjo+6/4t+5+lXZf8+855+j3bLv/ZuNXfong9+zf+T3b5m/8t1T334f/yCM0r30Nm4Mhg62Y7XiLvpqz3KzQyqEyDnvhFmVX4kWaSFsEAjWcUM2OKaSl8npE6LF6x5sZ/NT70R/5DN73v4cFDTI95aRMca1mIAtKJ6KVER5QOzUECYGy1NmKQO8ydBNEtMu1bs6s6/BVSVNn9Buf8vmnCT7wYRzfo/iW72D46CtJlYfz4Q8gfvmDrN8tMa6DFRNE7HBvcAHpbsANOBEO1hbINkPanqbKmSR7SG+fNPaoTq5zZ36EMylxvJRudkoZxhTOGNe1KKXYCnywlpeyjKytGHkxxkJWtqR1RqIl9pmX8CdD1pcuc3i2YGwMmS+xfUHsRFTaxRpJWhQETYkXRgipENYSuCEndc2iaei6kr3dPZrDpzAM4J6HsZ/4IIPbpwweidm0c05n1+jakiAcIIOE0Thh1dZ0bYZvNcezU4qsJrnrgHJd0/cNEOEmPlHissla1ncKBpdiGiek6iFslrRVSW8DfO/cv9XXPmmT0nY1fVdRFi1uvqYpegbbA1TfU9mWRoOzfwlz4ybl2VWUO6BqMlplmNdLhoMtxqMRXWOo85a27nG1Qy4ENCVt7ZKVNSenKY6W7IYSlWXIZEzdN3THC4Kixdme0AzHVGGALHO6sxnrWrA9HqHLM9AKf3IJKwWbO9cRXGO4dzfLcs2x9rkchygTss4P6UuYuIK1bZnducH2IEEGESebnMXyGKxlP0hwqahMB7XANIKiKokHMdIIRBhhvCnyaE526zpmOCBViqrZkGUFNA4PBduoTrM0a6YqxmxKTCcIxiHTCwmuP0DrkKqxZOl1NIqhjomDkPFHPokxhnxvhybpqQiw3gJnZ8zuYI/OLMmqjKqy1Msj7vVHXOtjXsoc7h9K6i4jSWIcXGI6GtejSlucxCV0fcrmlC6MiXtLKmPSTcmRrCEa07guU6kYBxIrBGdpQxArRn7A0hOErmbAlE1xRG0sqg0oqzW5VxB94kP46zX+j/9TvGef+QPHTet61G/5JtZvfSfuD/0Q3V0jqNb4fci6uIptCpR/kdjfYhRGbPINZdURhxGj0KPJcrqyIolcZOgS9iHmdz6BfvZLRG94I/Zt38bp4XO0zYK6CFGmR2wNEa99Bc7nP4W4eUjlSLKqZtpododDbNOhI5+lTBj0OaM+xLgCEVloNd08xRsKksDh+lFJURl244jBeo2dbFEnAxz/Aq4ckZolO9UZoQgZ7F/hjBfJyhxhO/YuvJrCtJyeHqK1oI8s40DhuNsM0ZjNmrnroLZ3cK/exr5W0VnNwYVdhpHm+vwE2/uMwpimq2i0wYsDqkXC4HNXectqh0e/84d46HVvoFwteLp+ik8ff5qPnTzFp89+h5Ny9jXvy4vlNf7ec38fgP3oIi8Vt/ibzn/FfePLRO42HpaSjqzriABrlzjOCCEkTn1uaWkizUQ7aAvLrsbzxqyXNZM8ZSN6rGnRyTZ0G5qqIihL5FhgtEb7kv4ko6BFTSSRStjytwi8gD5vcJTDLL3BfHZE18VI0xNLTQXU+RK/r+i6kkY5NF5I2hWkTYrQU+LRCHdVEKcuOtnHrm7RGInnBxR9ztDTyKZC2Y68sgwSjdASoQHOx0dTWQJvSCUbNvM1vo1xjIGiw5QtaVYgHIvTQdJB2wlML+gqg1Qa2zZUqxonnVGHQwKdcLpZEXcCJ4rpdIvvxTjW4tqekp7Feo5pl1g1QRqHUeyTtgV5m5+nhKsG2zTUTc4//8LP8PZLr8HpLJ1nz9WUjUV7EmMEtjcYaSm6gpE7wpOCZd3RdR1j19DVEj9U5/7aX/YA96Rg6Easup5VnSFUSyg0e9Eey5NDgsZBa596JJCRw8lJCZ5GolFVRrwdsbu1RX9rw1ZTMBmHBMYl6FsMlskgQegv+4drRWNhfpzRdimO61NZl36oGUUuXttRZBVEAxACoQUoSVUUuMnvZlHVdY3yQ7QKaOYz/FCjR0MaIBAuA78hbwtEIRiHLkoKlHbQrkdTlniDIUpFFMVNaumSWXDrDM84bEcBJZY7m4ym6piOB8SuYnG0RPclznRItVnTFHNkNMVKl6431HVLFUxRbYrOSyLfJw1jDB1REDDciqmLjqKoSZsCD8W/ye+yxmLrHtsbVFUSCRecgLapmKczrDUofCqvpRxoLniSYSjIZhW9s8XQdzlepPR1gdAeWPB9hSP3ydeHWNWxEzpkWY72DFr0mMawzl1yStyhz9Y4QEU99fKIOpqSez5lUSGqFsfz8WOHPm/xPIHvu4yqCWfrDKedc/fu3RyaXebFi4zdM4TYpmkrbHqV2kkZJ7u4PRy6kiSrmGct49Blb+9BGpUQ7EbIk1usDhco3+HZ0+dosxe4Lz7AOh2NW2O7DldrND2bTclkopC1ASFZVQ6NlxBfbFBI9kcOLxSWwjbsuAW6bPGCEWGg6PsCizkXsRuEKB3gEiOv36SWAdaZUs5rBv6YbKTwki1Y3ObG7c9wa32NY6/hxjrj6MkbHJdHvLS6yqb5w+mM/F5MvQnvHr2Gdw5fxSMH7yb2QyoV0hkXzw2o17dRjmJn8nKUG/zBDf5Hgm9YRfzw8JCf/Mmf5OrVq7/Pbxrg2Wef/Z/dsX8D3/f50R/9UX70R3/0j6zNP65oS8Ojap9XTab81uHn+EJ9k3+dfoytYMjbRUI0eIDTLCZqJcEwYDOfIYqKeHmHeO+A9pVvpLrnXuZvaTGjIZ2+C558hq0XvoT94G8hP/YRnOwPFpgRxuDcuoUDRP/2sf8gv/wPhuw6wmeeJXzmWfipn2YPuDcKaF/9KN0jr6C6/2541WuQ04s4WzFtfYeRdLF9C8tTTC/Q8jzFPtkKWXQQXA7gkZdhP/UF7LMvo3jbK7haL4lHMWOxJOOYKHmUvHNA9qiopyPmsNlgTMNQSJqyI3QDpiqiCTRFcUxBj04bzK/+CkZHmO/7QezWBU7vLOGeuzDrh1BPvYj+8MfIX5dCfoVotEMfu/hui1MvqK3LOi8RJfTeNkJqnC6htoIodcj8PfLNgomtmGjLrJ3z0p0vMdi/Fy1DtsMJwZdrvwLlsmgqYhWwXixYFT2eU+Pc2NCfrejf9RpcA5vDM0oPWhouRCGOPyZLV8hgRJGu2fYNTjDC9M25EqyKiFzBYp2SuC6hNhjt0kuPxh9jlItz8zZmtiKxkhNRUyUOW9NdmuMTyiZiuHWZZbXE6zX2zEduDlkd3yYId8D0dE2DAYajkKJN2aQ5g1zixw6VHhL1NWWaIfwRgftlgq18MjKK8oQuX1KvDHGhsP4AGSr87S3a23fIZcP26BKuiFhvnqcxKXXlUPRzIqUZNYJ+sUC6LkoI6tognRbchCJfM8tbyg7C0KPrGjaHp4i+JdSC6s4dRO+gdofEw5Am6ynyDVlvaZwAmh6nTSnTGXq4RR9PMJslejBGOYJVkyOaDs+tkCom3azY5JLp1gGOL+k3S+z8NsaDw9Pr1E1B4oaUyme2XqGEwXNClCPp646+gsZpCR0XIwW1gXXU0hweUxtDfOkuyCr6dc2mbZgHJffsH7CsVuStgzib42iFn1gcz0friLIrSWWGcEZEpuFsdUT4yx+hvnmEdCTx5xtU0yCER31whfLee9h77NXEl/ZYmIY6PUNbhSMdtuOY46zk1tkZOuzP0w83KQPX4bQsaI1HFEicsqH2LGWfMvI9KuNxPVtQhpoLToTUEtVaUk9wvKlYVx2v2jLEOmGNwJgSK33CzuW46eiVZWo1/Mz7GP7Mz+Oezf+941A1GbN47SM4naZ86GGav/i/wZnssrYden2G13QUqsJtM5SMsTIk9hOKomBTFLhRzFYU07Q5fZ0ijMKxDq3p8NIF/Or7IRkivu/7ubCzTZke83S1JtosGXkBbuIgv+kBuic/hfnQR/Hf9a24WhHFE/qiptkcoQaX0DqgLxu2tzTpeIjtZgTjCGl66mqJG7pMwhGztKEyS9RyRvvYy1ktM5IgYn96iRvljDI0eH1JpCQ2GXNyNqd0IqLRPk2xpK6W+P6YWbFg4vgQ7+DLFruas8wibgwucO/tpwhO75BMHKr8jJUacxz7TJxd3ChilZdsbt0mzjPU2RynLljcfx/u/gGc3sYVmtcfvJFHB3fzf3hwROkHfPHoM7zv9m/xC9d+iZubW1/zfh3ltznKb/OR4w/x1t3H+M9e/gN8z5VvJURSqY4qHBCGirZdImXCcrkkDmLESGH7gLLL6FvF1FpWvmK+uEMnBuzsH2CsRHYVlXLIZgviUUHjuOi+oW03dCJAaJ+BF+HhnhNdKQmI8MQ2nVqyPRmzSD26fEWzvM0NF6ZhcC5AqB0c5TDWY0Aj9IDdoU9Tz6hPV6i7dkFb2rIlGARkRYbVGhB0XQP40DVY6/9u6UvfgzHIQYJnFIt+wWBrG524FNkptZG0NQyDEC+OcTcb1k3LSirCyuAEAbataRYVutxQRjuYStCsVkh/hGtCBtOQos5ppIOsGlTgMTu7xSAZILwJiVL4jiJrBXVfs6W2KJVAGMHjtz7Fc7MXmaW3+TN3fzed7DFliQgiBAahBLazlKKiMx2RG6GkYFG2jGgQLWjPRXsCa889yiVggN5CoiKULlg2c1znAoMaWK7ooh2SyRaV3DCvM0rTcbc3pO6BeonscpwwYjhUDLMNctKT9hvEqoXER/xbysIWKKs1Whl2dUUnBWnrMm9aoq7CWGiU/5XggnWgyzpCcx7pbdsW0xuUdHBjQTnracue6CBCS0lVVbhGYXRN27ssC75Cst0goFjXZEVBbXoG2idQLqt6RbdOGfgXCYMhXm84TUtax2PLkVR5S7feEAYdjRGYdo2RCu2OsHWNLwT+cEiQbKGli7ZrlLTgK1aZIhH9eSZI5BAPPO7cPmE78OjNuZWdbXpsaxCuBFXjTAY0ZUGramIVU2SGRhU4fkxjW5x0TdX1RK6mxSfPcxSGrDHormI6jOmFQCmPTIdoWiah4s6yYilqQgurTYVTJ0wmku2tEGNKel3jjMc42tKLikXRkhUNW1MHHWravIW+xQsdPH/MatlQ4yP6M8bRvbT1lHWZ43pLNsUxQX1KMr7CZHyZRamJHZ+bzfNs5TXD7ftZ9BVPHb7IqjrjaPESL774WWplsVJStw2PjB/mbfe+ljyZk9UKp3XxmiWLZcEgKrADl7qTnG1ydCxIkouI2gHZkrgp86YCq7HuFl0QIpTC6SVZOWAyDs6dfhyNcMA7mdNlS2gatHb4Qn2D/8fv/H1+5+yT3E5v0dtvzFLyq2E/3OMtF9/C2y69nrdvv57BoSUnR4YhY6OpdEhaljiOQ2P2CaIev6mwbYtw3T/4BP8R4Bsi2J/97Gd517veRRiGLJdL9vf3ATg9PaUsSy5evPhH2sn/VNC4EU28RVJlPGTu4a7kLl7cvMDz5ohffuFn2Zk8xNvk3dzbbdNWOUI0TGMo05Jy28VNdqiqgk7VLCqDJWX3Na+iecdjrB1BObKIZEC0vUvwpRdwvvQc4UvX/uCO/TGFykvUJz4Bn/gE9315X7O7R/26R+le+TKcl7+M9uEHEVsHyDqjk4YmKxFbW+gi4GJs6L/l7agvPo1+/ONcu/cyjpNz1/QiZbag7VKUVmxFklmZY3qHOPC4lff0jYMvN6zWigCB77qc1Wt8PWTb6eD9v0Y1X5N/68Psvup+QhtwePOQrsqZfMcbKd7yVsJf+gBbT1xl5Ti00x3WXYoXCIQHbh8h/AHJdsBptWDd71FuXaSoG7LTkslwym7o0GRLslVDWg9YdSWhvko42kG2G8qNj9QhA2O4Uyy52Z4C4McwiBKql+5QORLzsofo0wKz2nA8CUmQ9JUGP6Dv1qRpjZIWN/SwTojZrKhWJd7+Djo/pbWWONTU+Qad7KLomaUN/XSX5KWb1MszxMUdomCfLedchKzyBLZqGCiX0AnJTEE/HDEw+9T5BlpJFLoUXYt0XZw4YrhpWVtDmuUMdUzldmzkgKZc4gQlUpzXLwrAaSvy0+coCg9HbuHFQ7zxAON2tJsNOnTphUdbzfFijawki+IQYQzhwZStwS6qM9i2xTYNqusgSynyJbU35KTIcW3PzuUDxMglvXOKxFBmHUV3ihw6TPcv4AQpwgrqsiDwPMLBmGtnBV4gaZsZWVaidvexKHoREk8cyr6FtmSkHfJ8xRkCtd4gPYXjOZTSRUaS3F1TdQ3DesOOEkxin1kbkOqOrJ3jSMlys2AwiBnKmOVqRaEKNBrtWALlIqIJfe/SLZdYUzG1HoPJLnUsKbUl8RJuHt/CNYpp2CMchRAhaZNSdiW+HxAKj+Wd6+if/nnkcYZ5w1voH3sV9ug2zukCefN5qhvXaK5eJfvoR4iGPmx7tHtTpldeSbCV4AQ+i/SMW4sztvpdOqfFGgPW4PcdjRvTdgtaQnwh2VQbCmfKS1nNbc+yFSfIzjJ0BJuuI3AcBq7CGTp0tuLM+kSOh7UV61JhK0EcRrhPfoKL//3fJf7M73zNcaZ/4F6y7/1ubr75m3hx6nPgB1x+8hDvIx9FfexTuN/xbazyFZ6zoXd8XDocOWFTVzh+T9t050q9CIZBxEhFzLOabpWitIejFNX8GP1rv0Vd1gT/+Z/DRhFnWU4YbjP2V2Tlkk1XsdWWmPGI6JHH4PEn0I9s6KYJnTbQGGQwxmtrGuOSeQ47bkfnaho9pOxres8j9gPcYcwmbYhd4PglqrqlHSR0Zcr2IGBQ34V54Qb5BUEsJqzv3CAMA/Ydy0Yk3FzkyPUC2eTYRlLkaw6Su1FujAwqeiWpMkuxv4/9wu/QPvc05s2v4bbocDzLgIjYS6gFLIuK9XKJ7Q3+pz5JE4fU73gLcdWTScVgP8A2M2zn4PsC0wnujl7Gf/3aV/J/ffNf5XOLZ/iJT/8Tfv3OB5g1X32BxGD5yMmn+cjJp/k/q/+Wb7/8br7n4J287cJr8O9+BEnP6fF1iqphd3eHXqyYNx1NLSCNKeya/Uv75HcOaUqPRZETpAuk7dHTizSrBenNa5QXrmCrNVWbMtrepbMugY7P07ONpbOWetMySMZktqM3K+rqFNNXYPdYuUP2giFRtcLxB+AlAMzrAmE7dGcQSYyta+r5DLRGGI2HQAtNJSTadSmqhsB30VJQ1zX+l5W37ZeDIcJxsMsai0WGULUrqi7HjUO8cIwTuihP4amYJM9Ya0HqSvbHAcbrqFczVBzgDFw67aI8Q+0YvN6gnPMIXNkZbJlhY0lXWeowYnfo439ZlKu3PcYalFDgKFwV8PiNx+naluN6zZPz53lsOKWva5xoAH1znu7WWDIyHOkQ6ICsM/S9QdoWoTVuqGjbOWDJW4NFUPSStGhxTUfkdcT4lJtjDjctjg5pYwcZKGSruJ6t8B3NxPVYtCBMytnqBG96hZ2dkO52SVgYetewqZbo0SU6Y9FfTtM2xrI4W+IFMNnaxVQ1Ks8I64aqH2JlTitdGuRXCHYjWoSSON35lLxpGrAC2RtEW+BtT2nqnn61Rk/GhGEIBRRVgeOXWOuwyBsmkYtSCsf3macZpWoI1ADHBkhPcjb7Ip118RizTnNCqRhNBpSdYX44w6sWhInGuBFdvkR6EYETki1P8QcDAtdBotHeEOOtkWVOENbMpaYyLcmXy6b8WCNFDyKmzXtat0IZCZ5CyhYjOzZK0coet3coq4ZFZxnv7eC0PUpUbKoFdnGGDXfp6gbPCRmOEpargsB2aGtojCCrK4yOSbRBmwqpaubLkrbt0VnN/sUhKnCpig3KqVEqRHsJXZdjuxRnk+F7Pq2vOM0aokBjsxLRCazvMIh9hL7AbDEnUCuSKCbLLStjGLU9nreHM76XtYDn1y/ywslzXJ09RVivKc9CjKtpOoPvSERTEBi4y91lun2F55ZXeWL5PDtnV3jlaJdMg5/V9MuMRjqkeo3Tw9GdjNLkTGMPR/ioQFMLl8C67NGADKkSD1l0CN2SKM0cTaclGolUEluXgMVpFZ88/Cz/r8N/wa9e/9VvZOr9NXEhvsBrd97K2y98J2/YfTVx0hGzZrYoGWgP7SQ0TkDbNAT5MZn0yZwxwVAhTU4VC2L9J6P+Gr5Bgv3X//pf5x/9o3/ED//wD/Poo4/yxBNPAOceZH/n7/wd3D8hqw//SyMOIvqtfdZFizKCYF3w9njAe/fh19ZP8pmTJ/jnzed5UF3idf0bGUzv5XKiyWe3SE+PcK0ilyMymZFuFuyqDd3A0P7z9+M+/STt3Xus3vAK2u1XYP7siOcjSTub86rHP038+FN4T11FffFJRNf+kf82K87T59Aa4ToIR2OtxLQtJBFiOEJ4Lg1gXRejHQwK5+gQ79rVr1vgzT05xn3f++F97//Kee2Vy/Dgg3QHe8Q7CcUrXsnoFd+Ef7DPctojH30E8TuPE710Hf+uyyyKnL7oME6ItIqRU+ELh8ae16NOI5dcxXT1ilU6J3ViMlVwazZjpAIe+MznUUXN0VvfSXUQ4G6eIVEXoDhjaUui5C727ruPbu8eqv/vjxF9/AmkbTh7xxsIqxhyiXVq+mRMNI7Zns+R3hYr7VAJxSiW7E4iWjmg3sSsj11OTcn0wMMrZ+f2J+M9bNfQ9jmmWpDOTinFhIvjCaI8oikq9NNPoXcnyHt3MbfnrPyWySBk4sCyU0RVQS988qpn2Fes2wovdbB5RZdViK4jX61RyYRpqMhKg3RChk7H4a3b9JMp8uiQcn4Lff8+Q2+Ar32CPmDlZ8zyjN3eEDsxiyxlU625snsR2fe0pqLAwPERQTKgd1zCKMKYgtQagsYS0bE0ipV12OlWWLsDfYddHqFXRyzXGQwuMB5dwBUOXuLStSVlmtGOAkLl01QlfbiDFCG9OqWp7jBofEy/BuUgtIOMYvra0JucfGUoshohILErmjxAti7dOqcuG4bjgDNPYnqXusoxfYqS8blasePSVzBGEvglZ8c5BR5jz2cSB9TKZ56dYbXLttQMAoc675ivZwSdJUliNpWhdlrKMsN4Fk9ZtuMDkskI1Zf4VcraSiI3xvcjbp3dISEkikMalRN6AX4fESiftstZK4ei71HZggDJ7mCf2oFjfE7LjHjT4QoLExcpC2wrWRYr0JLYiQmdkGZ+SvsTP4FaZZjH3oD3nrdRZgXlXQ8xfvMW1iwpTjLcmwvqF56lOz2Cmyc4Lx3SfeL5c5Gjy1fYG8fcGo2o7x5xo5gTupY49JBS4/UdZ0hy3eBXLYdNTytcclMThT4PjIdMWouu4AxBpDXjHZ/1vMAXPTetJsAhywrazYa9m7cZ/L3/keD9v/41x5Lq8kWyv/S/I/izf46XpGBZr4lWS9w+RH/zu1A3buE8/zz9G15PbWY4fcVkZ5shPpkb4ck1O8MJwgtpektj1+y7AaY1uKFPkypEtkRsudgvPA9PXcM88BD6da+lkJp1mjMWkpePAp6hYzRx2E9ifDFGvu71VB/5FM0nPo7+/vcibIkbRgguU65u4TgrPG9KXVvcuqYfBog6IJnGRG5HengHjGZ3Zx/nuU9RVR3tKMFWp2TJZcLBAYHVLNeHjIZj6gpct+XiwSVWIuZEOmR9yzCJyKslfVoALkG1YNO0OL6DX3YYR7BOIpxbd0gH7yFvT7jLjhmF2yT0uFnBOt0wDHy8F67TlTlnr38NjCesThYYYgLPh6rCGwRo2aHKDePRlK5uycqe+yaP8H97/d/gf2z+L/z20af56Zv/kt84+RRp/9Wztaq+5hev/Sq/eO1XGeiI773yLfz51/9X7BYhSRKRhJCnJU2ZUW5qwtbgOiuSApykI6sq7ty+ychzmSRDLA5qKsmWG9Y3XqIpT9HSRQx8XOGcWwrajn7d03cWKS2+59DbIYuzJ1FmzmBwwDC5zJknaHrLEAHqd21GDQrZNtjeQ4Uu0cGE4uZ1stbDDwNEWeJIh9L0xFqzyGp2/RbPHVLX5ymlWin6rMJaSZd1tMuKWPrk6yWyKRDWRXsGqzu6RuF4Cu15qKrEy2tK36OyFt/RyK6g8xNCbTndnBGbirrOsX5IX7bIriZbndAUGY5X4OsdPO2gtYUGbGfobY8UkrqvkVLx/PyQ080pb7/n3Tx59Bk+fvhZXr77snMV8mgL8jOEbTBWkVUZoRdiEed6IkZQmxZvMABbY6s1TngBqzo8AUXbUHUdnnOuzeHXFlWdcVKX+PEujlqT1j2btmORnnLZ2QaTooQDQchsM+PeLcnA95nFCV1eMmwdmtBlVqVsNSED//x+rZYZTZWyszchSCJsHNIGHnY2x54cUgeCcrqLaHviL6eVV32FG3iI3tKWDX3fI1qLzTPkMEQnA/qspStTxGqFmkyIogiDYVEuGIYOvQ1Y5A3j0AHXY90ck3cd8XCEozQhE3pvSmk23F6dkC5LLm7tMnI15nTFYj6j8cDxEkLbomVHEB9QL5dIx8GfTsnPTs9V50UAQYjJ1sg0JfS2KGxN17Y4rkuPwXcsbhxgBGyO1wwmMaJc0+ZnpKbEhiOGKuD0dMa8bFDTfbbiAFVWaDEk7U5Jsw2D5F5cR5FXDa2W7AwD6rJkWZT0rkdtKhIdoH3NPM1Jq4xAhoj6lJF08cYexuSUeUM0GKG/vGildUSVG5rilPG+g6MsZ60hDRR9V+O2gjboGSUxo2TMtcMNq/UZrRtwsjrhapFiN1/ihILVzd8mbRu6vqJNCxrbcWEw5sH4EsPkMvvJiIeGEza379BOLX3n0vsxr5vewz9+/pf4yNmn2B5dYLq7he8IGhnixUPyqqdPOxZljxyBK12E7fGcgmXVo6Qh6AxdFFNIaNueLVUgpYOrBKVQ+BYQlub2ER+49VH+p5s/xW+fPP51zae/GkZ6xOX4Mg9t38v++H629AEvc3d5zcOvIzAjXrr9PKu64IXijJdHe9ylRxyVz9J4IY7xaduQNNxC5xV+l9GkGxojqSqJEt4fhZnSHxt8QwT7+PiYH/7hHwb4fUJjUkr+5t/8m7zrXe/ir/7Vv/pH08P/hND5PnRwPc/otOaerQGDXBP3Dn/m4jfx6OA+fnl2yrXNdW7OfpXd/Arv3Xs9cehTLQ+ZLTOaOMZKCIMDfLFC/dIvo567iXj5Kyne9FqC9ZyqbLmuF8Q2ARGzecu70W/8drpwQJumrH7r43TrOZ8wX2TkbPOGg8fQUlAdvcjgk5/BXLqAfc/bIbIcLV9EhluM3D3ScEw7uUzsu1jW3E5zYmfIIMvQouaOV2HEiAeG22zpE9If/zXWyw3lf/nnGe9dIF/OWJUS3xlSFy2elqjeElQL1Md/ncHRjPD6DfrHH8c9Pv66rqmwFnHtBly7QQiEwPjLx2wY4l++QLW7Q5iWDI6OqP7Un6Z5+R4r0+B2Hl2WY9wBnhPQ9pKqzRh4EVMnQHQdi/kRuduit+EeVxO//1fxXryK3d1lqBTh49fRH/goTWZIXJfgFY+iH9ijSi16FLL8oXcy/JkPoj9/lUHW4n7XeylbS745JlQua1mjhWQnGlALgdtbBoFzbssR+pyethx3LnvacinwKcWAoj5lWXqMgwGdsaSthx9MsGFP7a9xjEvz9FVG2RIefg3ljWvksyVie4dJ4DMNNH2rWJYrdBwyHngkt6/Srjr84S5isoUrFW26pk0rkrhCuFtI41Ov15S2wZEt9f33w7Mv0Ny6Svj6N+Apj6LpyOse1xmwKees8g3bgxHKeGBbetei2phx6JM2JetM4/Q9fZoS+D5xn9O4IauuZssVDIqaXDmUbcHx8W2iYoMvBZ326KYXcLwxvuufk0QMsqpQg5hNt2QY+bTGpawsYbxP2RtMDW7mIiYuYKjrNU1T03UdhVkj98eEC59GSWqR4xcZg41DmWesO0swHBC5AlEK0uUZUpfsXT5AWUm52JBqRag7aEqayhDu7RKOB9B35F3FsoZtbXC9iKpY43sOkexI8xVOqFlR0jsN00CzGw+plEIojXJ9sB6+KqjaU4ySOHggLH1noLP42mMwSgh0SLEuOLu5IlUGPZ6ii5oga9HDBqsMSe1wsq6p2pwL4xGVXLPONSJLcQOX7egARzmY0zPSf/QPMfMZ6pu/E/fRN6CocBwfGcb0xiClR21O2X5oD/fBC5wUHanq0IfH9Ed3CBcrzI3rBC9V7Dbgu59kEw04e/jVLF/7WkTT49UtdpwwTw+JO3Bjj8jpcURHl0zYiVyY12R5hbvtE/oKiYUyw7qCRBlEmlI++yzT//uPMvj1D3zNRbtmf5fT//JHyL/rvQR7I7rao2jukJuMi8mU/WCHru3o3vkO/F/5V+Qf+Fc03/JG/GSXQTI6F9ArMxIhEcsFjFxWTY+jBYFwaLqaIAkoXQmLDdVcIT76OFa58K3fzrzuCGOPHe3RFRVKuDxwYUIYJ8ThFNMbVkVFPhzgPv8ciakhCTEmxEhLGwzxdUkiO9abijDtsIOAVnTnNbqhx2aTo2tLdCnAOU0pd/cpJz6UK05nAYmK8L2E9fKUYnQP2vGxwZhgHELZUi02HPcN7niP9SpHRPuUfcK470m6ORtf4WPpy5LFdIudl56nv32DYBLidkBWoGVPUdcYYxkJifril9jsTBm++x2Mqo7DxZxZlcNLV1HRFsOdMTY9w0mP8GxPmgvKKmeUaCLXIQxi3pq9llc/dDd/5ZUbnq5n/OLVX+YDdz5CbZqveq83Xc4/e/EX+Wcv/iL3xlf48y/7Hr7/rrfidh6+HIBN8LYC3Lal6izd1mX6oxJT1NjtHWZK4+Qpwhhyz6E8O6VdH+NMdkjrku0wpigLVssa5Sr8iYcShnzdYShYrc9wvQhPFNDNidxtyqYkRxDr3w1UmA5UXSNGI6SnsRqU0yO7HuFF1GmKqyyZ21L1DkVuUG6NVgVNJyiKjDAI6LMKGQXURQvCMBgMOC1v4HaagRxQz3P0RGDN+XMmlTxXWm9yhqOQtDfIuj63Mew0QbOkX8zxkglp72EGYzzHpd2ELBZzZN0wLWrCscTt1rTrHKkirHGwskcLzSpfIa3kifkzCCF4IL5CuGX44Onn+OhLH+O9D3/3ua2TcsA2NEbRtg3b8TabtqMpa7wiJ3cqmsanTg8RZYaQY3CH+FpxJ9sghGIS7xHXAtNWJMG92HZGk8SUjsuib+mEh0QzDBOs7dFOy1o4IDROk+H5ESqMqFcFzmrD7l0XWWQpJ5s5kbtL3Rg28wXDQUAwGJ3PQYTAjaNzLZYbL2BXFYUccJYIhloSKM7Vw70B1PK85En2mHWJm4So0bkIn+NZWhuj+5x+tUKNxwziAa1t2eQrJpGmtppl0dLJjmXboVvBduCghWK93jCJ90j7BWfrDa5StKrk9LigO10xcCwmCajcCPqMoetj8p7WGLytLVJj6aQGcZ5FIsIhxlnTrddMLm9z2kg2VcXE0VR9ji/BihblKKrVis1sg1QFjSxR8Q5Db8RqnbFarmilxxjDoMio04xqU9P1p5jesCUEjiu5uS5J65K9yCdxNF1dclJWNH3FvVqwaSCvK0Jl2AsMN9uWVoWU3RLfkfjukL52KURJYXNCG9NXFj8aogOXrlgy0TGdFrxUV2gjaKoVRZcyP/0Cd9KrfOn0JdZ1xxBDh8DpN8RbV9iOLnHZi9h1Yg7aIYPwAiIxXCg3ZP2AydaAYpNStZrpwRXWmzViseBSMuC949fzs/NP8WvPvY+R/+cIBj6e5zPxQ86yNW1T0wcdQ+1DFdJ2lqC3rNYFvi3x3Yombai7Layy0DZYHZPolsxK0rriNz//k/wPT/xdvrD5g8t3AxVyV3IX94/u5lKwx1PrGxx4E74nfBMD/xKt7tgK97l4+QE6J6ByJBfWKTSaRdty34X7OTx8llk1Y1ZNCLI1bpmy1hWx80qq3KWpWxLtEPUhQbGgzOf0wkePH8C0BqW+run9H3t8QwT790ao+76nbVscx/nKvhs3bvzP79l/ggj7Dm+1pstnFK5BhBF723us7TZVfo1pW/Atlx/D6VZ8cvN5npm/yI9d/1e8audl7Jst4nSD3DgML93Hjieo3vc49TNPET/8CN073o7f9xTmiMXsGpIDLoiYPvFguEO9XmGyM85qSfXY6yninidulLzrwrswFx/mrFgiNvtEwmJuztGX7qEYCZxlQB5K5t6IthlQ+RY7Ddi0FZXbspUKxgNB5QckBNw6yblZHWPTOzA/on7kIXoCqrRkWQf40ZRB7OHuWJp0RWEknruFCL+ZeVqzvHwPx13J+PQ5th5/gfZjH0XfeInkuRdw8j+4vvz3QhQF3rMv4D37e5SCf+M8otUmEfWlA+R996Ifehn9YICzTHE2a9y0wl2tkLM5o8UZpBt0liHL8ve1v/U1zmvi/4b69a8jf+Nr8R99Nd23fD/iic+grz6F97M/Ce/9FjajgFZkHN+ZcxCGOMEQYypkVuHIANEr8spwZzVDmo4HIomcz4kmQ8p8zcnx51l7A3S/T+Bt408cDuslWiYkVrK5+hkaz+C84fUcHT6P00smXoLZLCjEDlPXcpKntJ3DXR4MYpe0CxCxi+9FZK0hy9aEwwCn3JBvakRZ4hpL4fjocYR0hpRS4N45pW86zrIaa8F3FDaOaYTD4WrBVjKkKlumwZDWdNi+ZivZgeV5nfTM+EyGY7zIo7t5m7DOqIaCvN9FOpJBMSOenWCdDZudKywdD8wSR07QXY/jCkQHpshBCOwowc6OUF1Esr1PuVlT2xq/dXCnI6pVi7/qIA7oe3W+0m0y0A2JF9JUFau6BV8yyguaWuPFDos+5KxqSErLIAoJnJCykazupPhaUZqe3FaodkNVN+wlIZODA9bSoZQKHQomZUeZr5hVM1QviZTL9rBlMat45mxBMJHcfbDLvgLQOOOQqqpxi4JO92R9RdbP8ewIUcOVrStIowgcxUl9ynF5xI6aYsqCTmhMHGKbjL5cE463MU2Gjl2aoxv0+PRDl8at8UTHzBE4uWHau+fk+vYd8n/8Y5TzM/rv/S6S+9+MkQrre0Qj91wcqatIsxV0OVKOCHcvo49vMqglXLyb9cUDnHjIqDtE5ZL2qTuI6zcIb90g/vhvUUQOgyv3kUxilBYcZTlWDbliPY6Wa/I+ZMf3yaqWwBgGkUsnFUVncNMVZjUj9RLU2VW2/uHfxfm5n/6a/tXtdMr8L/4wR//5tzCaPIxclqTWQauefD3DCNi/d5tpss365Jh6b4fVqx/EfvKD7D+9jX3Ty9BSs4g9dCIY6AiyOflyTV2WRNsBtjFYAW5XoLsCtXdA+UvvQ2w2lO/8NhjvoTrDSAqk47KUlr7XjMMAJxzT95a6brC9wLz6UfSHfp32Y7+N823fR2fBeA2BE2MqjRcKVNBQzWeYMCRzBFuBpS0K8k4SxQGcnCAWKybf9DYYhCxWDfnsDi0unreHXb9A3W+IxvdipUKGY1xdYY8OmYiMNg+5vfLZVhGezdAO2ChkuX03O31HvJrxXHZG8nTFhReu0zz6CKur1wku3I31HRZ1jZEgP/5JmjJj8Z5vZafriZqa7fGYZb6hWa2JSkmtfSrl4umQbvEibdbi2xhrQoLLF7DWwdUpQSOoHMs7g22+877/htO7fohfOXyCf3n223wu/RKWr76wcjW7zn/3mb/L3/6dv8+b917DDz3453j37ntR4xCzzmjrhmKZ09ISBkP8uj6PTvoxfZ1RioKxr+nahDL0cXtJHMbUtgdf4jmSZBhj2x5btuTdnGgwplcH1OmCrj2FSqElZI6LZyyOFDR1j2gEUoP4spCj6GuMd66g7TmSqlHQ5DCE2j1PCRWuRqqGMNkiLwoaGtxIY0If21pcpelEQV1luME+nh9TLzrq5QoVunTNGDeQWDRSCUJh6CwsV8eM/R6RVVS1QigHHV5CNRsqGmLXI1M1dZvg9BuiZEywe4m2KDAU1NUGa1pQBXXTYoUmCAbcKA+57O+T9JaLcpcL0T5fOHuK11VvYmwPsFJhyoxVZejKktatWdUVdtniiQonsNRWEogG6YQU6Ro7GZDWFcs65UriExUG07TIKKLflETDHYaJZd50XK0sgTVETkQYJ/hG09RzZtma/WRKV6Qw3MZ1XVpjMUritj27gwnz9YKT9Yxu0+Ipy2h7G/4tlxshLNH2EBUPkKucomu501kGgcXR5+rhnWppNxmesEg/xNuefCWI5XiKru6xQYIoNvTrNWo0YpJMaGlJ6zUDb0TawhcWZww8n93Ax2sqtC3plzMYJpCXqHrJwe7dVPMN8/kC1XWE0Zi9cQTDIfPFMYvGJ6DBHQ7pHJeibVj1DSiNKdf4kaLSPV06J2xiPOkyS2scFVGUZ7iqwXYpDRFuaEhnCwpTMb4QM51usywEue8jJlsoJ2S6v4PTNVR9j+haojaij7eoqw1+HeIK6MqGoMrQW1sMg4DjdU5b1JxoF88HbIbHAKo1UrQsyzli5UK8h6eh7ApWqxVuqCm6hqHycT2XSji8ePIss/aMO5s5145vMiOlt4bI9ZGmQ0lF5ESMRju8wh2TlA6j4Zj7X/5mVn1HaDpUVhDUPcpzuVNXzOlxjCUtFZv1Ct93CV1LG0V0ZUe+KXnQ7vC2+OX85vKz/Paz/5pw701M/C3s6Ya+qVmRMQwVe9JjXazQNPR1T77sUUpDqCiym8ybBeMJLPrwPCvBq/jp53+Jf/Tk3+d68bU52dAd8J/d/ad5s7qfkXc/u3sPcO89+yTDAZ+58Vl+4omf4t07b+He6AHq9Dab/BAKTbm4izSQuCOfsmuoz1Lc3T2G2nCEx71qSvviNW5kBYlb0muLGAh0WaBiFyfxCFSEv5CUraX1W0YXfRz3Twi75g9BsD/3uc/xmtec60JLKXniiSd49NFHeeihh/jLf/kv87f/9t9GCMGP/uiPEgR/clTg/pdEfueQ1Z0TolHO7uQCVsfcmeywEw45ffGYpR0TGMvIG/K9B+/hDXuP8RtP/zofvf0UZdPw1v1X8R3Te/GY4/364/RPPMv6wj7ydQ9DmVKOx6xzSVS7hO4UEzcE3nmaz7KDspO47pDx7oQXVp+l6Qz3DC5hHYV1OwZqTPbWx/D+xfvoP/ybLL/1PcjkCgOOWciQJprgdYKshMTXOI4gy26gdY4JPKLxJeKiJD2raD76JZSRqG/6VqrKMF+uCfcucnkvIYxcmrpiUVhcR9N1FdNLl2iff56z4yN6x6JCSfX2N5K++hU80/Qw9HmjLFGffZzwsy8in3gG76kvIdpvLN3dSXOcp1+Ap1+AX/41AP6onmqZZQS/9WGC3/owW4AZDMhe+Qjm/rux8yPs7Ijkh7+d5uJlNpUlExJ3cUKZLeitJtraolBjjvMe7Q3ZihX+KCA7ukOkNGrnXpYnAXdqyW7kkUwNtYiZRjFKb9GfHDG8fkh9cYdjnZHWOfc8+DriQUS66ijLnuboFt7JIfaumDp0cfb2CGpFejaDpKY+PqIPNMPdXczqjPz4iFA5RPfew7qszl/mGMr9C4R3brA6O2Hr8haxpymtxfSGyWDI7fWCg1FK27TsJEMaZViVazq7hXASpnHJ7cMz0v2EydYQ3e0gDm8QmorqbIOjWhQLvEjj+kNq6bHsa1YqoO9jpl5N29eIqgfbosYjivqIOE5QfcSsqGmRNHXOlvXQ2uNYl9iTEwZ6Dx3GZK3BypJxsI3oB7TTjjgtoGroVkv68gQ19SmrkFWueNWVi4TbI7A5QRWQnynWm4JbXcWAkvHQx+8EySjG0R5TKcilRGqNIxyuHleU3ZKAmLLvyeojTqs1Jog4GEZElaHuc7zdLXAVs+yUYl2RDIZI5TNNtmEjcI1mMh6yPNugKpetYMKd9CZz1SNqi5kMicOC6tZ1rB3jDC/gGig2KaowhLEBt+ekOiF0AraGA+o6Jl+mBFlJ9RP/gjLbkH/Pt3LhLe+ku1VjjUGHMV7kYFcb+iKj6wV4Q3opqLrq/MVqod2U7GwnbLoNtrY04ZTIO4EnP8/eE7+DOj2h/eVfoL/rXtpXv5J4EPDKWNFP9kn2htwQLmZ8P7o0bOqOkdb4I4e8s+RnaxLV0K5zon/6Txj+i3+GaL56FNOEIfP/7X/BtR/8HtSgZxCBUJbSGLqiYaVWbEzLUEtcJVBK0/Qtlayo3vAA8VOPE3z+ebKXrZh1Ac2Ww9ZoG+VEtFSUrYcyFc4mp+osfmxp8wrrJYSrnPXzz7Pe30M++gr2RhGiqGmLCtVYXN8DMaArW3p9rpSstUb2Bv/eK/gvXcB+6Srt2xtyxyArh52Di6QLQbnJ0eEW89sLwuMT6oMtWttQHM9phMt0OMF8/gmEAOfuK0x1wMpsKIVkMvIwywJRQbHasHOvQ5u19FVF17YUdYnTVNjeIIsekQgaD9baoLf2mMQJcVMwtxH95T3UdIq6ccz0Ow7Ij67TVBtWtWStPaKbtxDPPU96/92o++9jIjRdGDDZntKcXkN2Qw4mE4qzI8LAZbh7gaoaIbiDVS51Iagyg4o9lJJ4xkH3EVUxwwm32Lv8Gv70xVfw/Zsf5l/f+nV+/uTDzNo5Ly6f/apku7c9Hz36DB89+gxj77/jT937vXzHvd/JfWaKLgV24CFlCJuObc+ylj5Pl2doU3FJSRbDiEE0wLUu65MlfhwxORhQzQu6oseLXbr1GXm3YRBfYbNOWVQW5XSI5hax56P8u1l3PVMpqYrzAIbrdXSmO1/cakp618d1PWSR400S8mWN7CrKyBIMQowjEdKiRIcf+hSLBcKANRJsTZHNackZJXtoL0E7Lnp7i/S0pTKnSOkhdQRWEMQebbpgYBrOijnZ+AK+dkiLDNf16ZuWQRCStRW67jFC4usIpT2UsShtaZ0Iz08odM5ycYwixqgNvoJnTz6PKda8anwfgaloessb4lfzc4tr/Mpz72ff3cG3IMqUVVWcp94rHy17fN8h3vIpNGAljlVghlTliqbMWDYlnhLstALbt8jBAFNbjO3xh0O0o3G6OaFtmFcViQoQ9PhhzEnn0bYnbE8vUq8WZMUaV4ZUncGOh9i+J+g6omDE6dkdZJNz38V7ENr5dweaJgOp8Xd3EN6G0XJBV604qwWh5zHSPeVyjuw6CAboUfIV+y0AKQXalXSdxR8M6NdrzGaDGg4Zh2OW5ZKsyjktaqxpGLrbuI7k8zc+weeOn+T1u29B9GMc65J0c7LFHUTtMeo7rGsR9pi6GeAu1wyXx+TuJZZex8B29OUGl4zQprQi4KwoGTsDhBNg1eK8bGPrHoo6Y9VqlIgZJFOa1gUZ0nQ1ZVuRjHbQ3YST9YK8rEjCCY10iYVFdw29EMTjMUW/pKhGjHfvoS3PKKXF3d3Gni3pKlCrNetoiLWSXVdyeW+LVBjW6xjkAGTDNDKs3QGmdRHSR1hBowt6ep689gLXi5fYlHOyLqeW5yWuUrWUWUrijHj5/r3suBfYjg4IZMieP2Xbb3m2XdFsVgzSipkacrjOmHoGvyqxeY0fDQinE9IcXloYDpoUc9pBtWYwGWGtjxdExFsxVTkjCRK+TVzm6rNrnp09y72byzw0eBBsh0ksqT3lynSCm8QIFxLXo281uwPLwNNshZLm6AaLk5yuy7hdlvz/nv1xfuzaT3JSfW373p1ghz9/6Qf4ntE7GXgRRV9Q7l7G6y227Wjbls8snkEozf3qIuFoi961jLyCPu+pFoe4yYBaDjira/y2x5nPOduc0tYFV3xFna048xWbYMypLDFhwwN7l2mUIFMtgfJxfcN49wIzm1N0hlD+J0iwf+RHfuQrtdbvfe97ede73sWnPvUp/spf+Su89a1v5R/8g3/wle/+03/6T//oe/qfAPKf/1WGn/0M4a7LwdYeyvVYjveZeRK7XhO6MXK0JrUa23bs7435ru5lXHN2+Uxyi6eqlzian/HNX1xz8OwZ8YOPYL/t27lZnaH0Gt1YxjIgSQxNfUa9EFTJiHa8RbydUN48oi0bOtflufk1bCfpxIhVWSIaRRX45OYK4tI+3rPPU77sVYweewzTwrjuEUFN07uI6twXN2gjwmBIr0JCb8w0uZ88rrnz7FO0d67TP3of2nWx6QorJfvuCs8JsVZh2g6lFJG2VJ2h9TRWl5g2R1QaREA3GhMebCPvnAAVm8v3Mnz5/dR/tmLdJCgbMn3yCczTX6R7/knkjWPCG4eoq1cR/1a0+X9NyM2Gwcd/Gz7+2wCYIKT9lQ+xfs+bsN/9/ZhXvorZcsbsBHwn4lRXbDjCFJCMJiSjhKZZ0AeWsm7ozICpfx9BueKMNcVmzcVgF4tDVRR0z91gq22xr34V9ewOaI0ZukTSUk+2KVY1TVljopipqwnKlLNWk0TnwifLakG2OcOXE/wupo9GlJFCtgJRlGhjOO0a6sywfflB5OFt4sNbhPc8QIsm7w2JltwzGnO4nvPkyRl7KMLAxzWa1MlYZHNi6+LG28RiDiZjXkcEkcJJRsh4RCEzFkVGMNyiSiR91qLSFaOBT9lptOtSu4Y7mxUHrSSYDmhES9tnTKOLNKXk8GxJo1si43JyuiSsDCaJqESLv8qoeoWrFbFo6QqXVNa4ocPF1ufoOGOdKQbBACRoO6NxQoRo6SpouhKn9/G2Y+axoru1xq8LzCDCFR2OG2GKDhCEEoSrKNuGxA9ZpDXuwGPTGG4epoSOYey4lG3L2fomGsP2wRBfeIzjKaLqmYghK7lkMNhhnZ5imgrHdZBCsJrNiXdCRsEY7bgczW9QhJpJusEfJMTBfTQZ9JFH2awIhYNVIUuRYWWMIyWKgnA8IPvIM2Sf+iS4Dun3fjvxyx9E9Q6VqXE8gauAcoljSlrhYMMBkU0pyxmN5+F5AcHQZVVUOOuS6ac/QPC+j+B+4MM4p6e/77+hAG7dhI996N/537zzy5/G9zGTKUy3YWsbZ2sL5QR0tmX/F38OWX11f07juuSvfpjF//T/5NQG51Et/wzanLbISK0hqgydUzPdvYukWzE7u8O6ysnMBscaVJ8Rft8P4fzsr+P+5i9x+s3fxTie4jsRPYJ1LRBscEYCs+yws5sod0qhIxCG9l//DFUcsXnstVySmiTxqY2hWGZIYfGmEa4OKZdH2K4lDCOkkGzWKQ4tzpveTPdrH8I89yXko4/Q5wXr0xnKianyDrRAjrZpN6eIbMNpsWZ+PcMNdxCuizw6pcsalkLBvCQSE5ZizaJy2J3uEi5ukB7OONE3CP0dtFnR9T1VuSIsKwqbM56M6b0hhdJoWoZ+wshW3GwLAql4cPsy+r7L9F+6RnG64sLeAbWpMPEWHoLJpz9DF4Zsvu093BMNcE2P9GKUB4EyVE2PVT0qGUAPm6zH6gj/wsuIVMvJ0Yw0bXHXK9y2w9ED3NEWXeNSOhbfH5OEkpnI+FPOuynoeanP+a9f/7d59s5H+JVrv8jN/M5XfUaW9ZJ//PSP8Y+f/jHuG9zDD176Ht5z73ezH4wxQUDTHSNcH2UEcmOZ2QxxcZe4j+hqgYw1wtYYK3BChyZv0aoib2cY5eN1HhNX0OoOLxiRLu5Qtwu24pjeCtzOpZGWwPehr2lNiyMUbVUgHB8nGNAfznBCgzsesrm1IZcF02BA1zcgPWhy3GhK1XVsKoOnStp6Rd2lRKMJw/EllosZjdcSjCOidhuzvE2+PME02wS+xVUVZbnGtC2jwZRVsIdyW5rFGX4wpO5KAm/Mqs2oOgm1y3aiaMWYfF0QmRpEQFO3tH1L1tTsxwe0nkJJl8efeT++GvLyi49CNSM2DSLzeGDrFXxx+UWeXj3Pmy+/id5p0LIgUNsY7eG2NX6kcLycgIBldoq3tjRNQGVXzGa3IRxyQbgoY5HDIbYVdE2JDB0c16Oxlk4m7Ps5myzF6pjTpkQKn9oKBq4P0hC6AXm+JhAG4bj0jovwfWRWUKLxSov0XAq3xzM96vcSBdNDW4F/LsTpDhNiI1ltZgzY0HU73Lp+hNeWTPZ36QqJ/CqJFo6n6JqWXmjUYEC/3oDK8eMIrMu8LShsxeUoYFXM+YVrv87x4Rfoe8m8VXzv6EG2ZIjnTlmagMgJ2B5NwYugOaXyXdLTZ/BbTTRwkHRk9Ya6zThwDMK4DKJdFrakNA69comHGbJo8ZyQkQ+HdcoIB0f59FXLWZ6iNwuGic9we8ytpcTMYWs75rjY0NcpQzdBSUEQRti2Iu8LajFm4kS0quZ0NmcgPTzbU/kh682GVZdyKdT0SmCUwq8KAjWmUgWnaUrixWxPttgsOxCCqq3QkeKLZ1/gQ9c+ipU9dC2Xxnfz8OQeLm9dZMfdwqw3hCOBNxgzdS8yX5SctRW9MmgvYLsuebbuSQYO68YSL1e4jqF3XSJ/C393D+FonGJNWQqKZskgPUL6IfHwLtaNzwv5U/zrG/+KLx5/nokXcSneI3SnHDdH/NTtn+NH4imTcp+5U+LtecTONlJvI0WDMorGtQw8aDcVy9Kg4gledcr/+8mf5mev/hRpu/ma8817h3fzF1/+v+e7Hvw+OD7j9IWrFHqOM9jFCxP8tme5OOOkW/Hs2XPcm1whGu/idAXGQJxMadySqgiYVEvU8og2CpFWENljDnVFOBkwahzsQw8iXcP6dEljfI5JuRI3dGtD2wnqsGK6FREIRXbccpL2TIz9fQtL/zHj6ybYTz75JK997Wv5kR/5Ef7SX/pL/LW/9te+cuxTn/oUP/3TP03TNHzXd30Xb3/72/+DdPZPOtyHLrI6fp5Yg2sNclMyTa+x2CyweU/gulTWoi2EeUYgDNum57KwfOtowPV2xe3mBfIy4+OJ4nMXX2J4+2fphCC5lfGY2uGh/VdhA///z96fB1tznee92G+t1XP3nvc+w3e+CfMMkAQEEAAncBBnUZQly7LlmKIU2de+cW4qdm6lKpWKnTipchI7ruub+DqRB9nStUVqokSKkziTIEiA4AgQwIdvPvOee57Wyh+HlqhrioIpqXxt66naVV179+mzunt1r/Wu93mfh7a0WDinkL0eg8EAvzS0NdTSsGEL1tke5wZnCNyGkbJIvB6H9ZKrmaa65+Xc+/wFhk98GX3HbZjODq4dI6sCYcOymaGXDhO7T6cXcCVrmFVbiNQwCrcoXvgdjBGMXv0YZVszc3rIjgt1Tnl0Ednrkuc10rZQTYq0JGldQzBE7B4x8RXKn5CYBoyP4ymEZZFnCZPoPJa1wm9WrIxH9dAr0ffdw37+Slz3FBv9EUWTYT93heaFy/gXL2IuX8S6eAnnxReQV6//nrf3Hwfa9xHdLqbTQY8n1JGPunwN58ILf+TfyjzDfeECGy9cYOP/86+oJpskr7gf74GH2L37YXTvRmSbY2b75PERTtGlqCryxiWMRgSZxlI2rpCElUuFZCVrhMkwRYH17AuUwpCd2qA7PSY8dZ4sPWJlXGBIVVY0/R6i08ePIkb1Mcd5zuwwx9GS9OCIPJ0SDHq40QTtgZkdYoYj4qLm4PCQsmwYOh7dW2/Efeqz1Bevkr1iSek7uAKqtIFGcdb2+cZygRsMkEohW8nA77HKZlhOB4sAb7hBICuW8XWWIsexFHq+R3ejTxr2cPxt4vgqVZ7ScxVVnqP0gHORRWb57K4OOQ67dB2HJt/Fkj6OipiWcygPccuSyN4gN5rldIF0PHbzkuHqiM2mxOn7rOMlqenghgYvr6jjAms9ZVnmeMMu2vLYOrdJLDSZmNMpVrSpJhYbtE2FRnC+a6GXNus4Y9C1UKMeUtiYVkMyI1/WVI1Nx/E5FiteXB9iWkGLzamzXeThlGUscHo97KTCrFtc2yaMQubNlKxIqXSN7bq4nQE6TSiWC0yZU1YlA3+IS87i+AChAiauSx4nqI5P0JWYWU1ba+x+H20r6tXz2MGE/uYdeLKgqA4In3sS9yO/Q+KGyL/4M5jNLr2gT7GoUI7E69iY9RR8geoMaIRA5xWT0Zi9/X3q1SHn3Q3Er/9bxh/8IOoTn0Bk/2GlHf/e81IUyL1d2Pv9IGn0ffY3vk/2lrex6nnwuofx+n3cAqZKEfkDkjgmX+zRRAOWZYzy+5wdnaIrJ8znU/LDQ6xBQFEd0a4LJre+BvXgHuqzX0C88Ayy/zqydUmhBBpD0ByyyARu1SAiQd0UpIs15otfIV+tKN74WjY2d7DqiqqqsCOP9nBB27ZE2yOUpQiCAOGevOeyZUwzn9EZBTh33E399Depv/AlvPsfJZeKxdESP2xxfYcqr/DCgKoM6Tld4njKqlhxbsvDDxyq412qyEd6Gjv0MK1ip7PJQZUiu10GpyY0B3PqYk7cuLCWiLZAFlPcXpcjSsJwyJaOcNMjjtwO0yJhIltCr0eQ1Uw2NpjdcTPyG89TfOtZrNc/RmlJCl3QefZFrIMph698Bd5oQhdJIzVKF5TzXXwlyeyA64uC4XhCYAymqpCeT9DtURwf0JWaJF3SmBDleNihhyVs3A5kxS5ZfERvdBbX71GbnJ+86TX80+c+zMXp0/zM3e/lr9/2v+Bb1TXe9+1f4rcvfoi8/d4LMhfWF/m/fuv/xd9/5h/zmtOv4903/3nevn0fVTljHE6QBy37VkaEzZYzQFRLgsjG9lzKLEMYgdSGfDZnLUssMcTUFVHUJYhXhFYHzx9xXAqKOqdeXyax+jidLpsyojaKxjTQ5NRNg9UJkdJGex6myglHQ6YHAcVsibpxQFVyQlNuK0yVQ6XJ8wLhSowpcHyfTnfrxCpP2Cz1mkBE2MOQsB1SH10nW67wdvrIwRgRWVR7lwi3TxNKxULntEpB7eFFBlqNJz1oXbxmTafnUfXPsPj2MyTHM2p/RF232JEi6IXougEbLsxeYLqe8siZVxN0NllnS7qdEE8UvH3rVTxXXOVDlz/Fwzc8QiUUra7QtodIalwj8DsCMLhSUC7XrPMI15JMk5ZKpQxNgN/zUYMBpjKgDa3VYrsnomTrpsWzHDARgTimYxUUteR6saIlZ+yPaYzG9SRilVGKBqszosGgLUUtJOXRPmMvIOidom0rFuWCgTv4/SC7OilPwg6Ak7rsTs9nWoXINGarOWavErTRCL+xMHWN25qTwLxYgdsFZSGVRNmSumixux60LW2SEtctRnhouUC7NV/d/zqfvPw4TZlzX+cO6gqemV7k4qUvE43OEvldOlhYokZ2xuhK40VDHAQYj3p8hqmyCYMOlvRpS8kKhzpbYKczfCOQeU2hApKojzy+Ti9dEjghVZxSqBCDIsmXlG1Oz4POcMhRndAYi8D4xJVPFqdMAoEXaIQ5cVtoq5hWCYSIUMZg+UMKtSSc7dIZbBG7EZiWCZqJqZjVBUerFWMp6EU9rOqIpinRw1sxqqaZzTic7WE7kiat+fyVL3Kqt8VPnP8RTJxQuxadYEQnijCtJA8U+AahDcfpDEuF3OKFLNqMWVqSL3N8r4u2YgLlEraK2u1g1QGy54EUpGkKbU1UpmRVQ0TJ80XJf//Fv89vXPlNrqy/v3vP+/Z/E0c6jOwJW50dbuie5nTvPCN3m9vG5/GcCWecCYGJuBBf419e+B/41Rd/haIt/9Bj3jO6g//dg/9b3nTurRxKSVOUVHaANbSJbJ+FZdGrcra9LqvZkk8ePUmSLrl99BrcjQk6OyLMSpTjUzYxWi3QuHT9LrVrMZYJtXQo+xETZdHEU9S4i6hdhjZktcO00VxYzhjUEs/t0OqWNuxR6wplaxbzQ5r6PI77PRgg/wniJQfY9957L//0n/5TfuEXfoE77riD17/+9fzsz/4sjz32GPfccw/33HPPn2Y7/4tA+dhDXOmn3GRvstzYQno2S2GY7e2jYpte4JEXc64fpmyvllS1wLMUcnYNRcMpucV2eyfrwKW9wePmdo/DZsXBepdrScGutY9qrmJsw1bnFFvFzQyZsCpzxkzY7PtoYXN5eoFcN9w+3EG1DVkwoFQpRWvhmDmnT23Ru/cu7Gefob58GR58lKTRWMbHyQ5ZVmu6bZeyXVMrCMIu0ouwdEEnySkP95mfPU3HBCjHY3vzLE2taRqQ6ZKmXCE9QTAaI/IWSw1ZVDZN60Os6Y8cdL/DKpmT1BrfFmhhQIMSNlr3ca0ckR+R2OewVEOtFYFqKHRB6HTIbr6DKujTe/1jJEIwPT5iIGt2L3wL/5+/D9HbpL89on3hm7i7+8haIwdjirCP6Pjojo+2ffwXLmCUQr/qldTnzlEMt4l7A+JoQL8q2LQlhC7TtMRy+sjFMeHnPwWf+Bjh00/hXP+j9Qqc40OGH/kQw498iNOAth3KM+eozpymvfEU9Q2nyPtbsHMTzo0dHK9Hwxo7sLjF2qbueqzahKLMSae7RJe+xeLGHeQ6pR+OaAKHajGnCh0Kt6Tt2OgiIJc2FAdoq2YYbbCUsJ4fInVJG/bwt7ZoabBVSJ6X1KoEoahDwZbw2VAOcasg7CKvHXKwnjP0xrSlJl7XCAF+Y6GSnAU+u8uKvrDwAp91aUhVgVdJ7H6PLJ9SzZ+l7mwhwtN0llfwqxDbd7HI6bghhVOjS8NxnNPpbZOULfY8YVg1iFMeRbVmmqzZcLpMk8us8hjLg5CIQeSxM7yN1bWLJJaN1/WpqhojPVZpSel26Q42GLk2omqp45rQtym7PdytDUqZMpx0CI3H0WJFWB2QNFOcwCJwJaIo8I1FbHmoxlDWisUio9sPcUxOoQtaU6K1y/WjGXOTk5ocu2nxbAvXH9DvVYzwMP1twq6gbFtW8xmO74OULIsVGnDdgO5gwOHxMe7xHn60Qd0WZNkcFSjmCQzsiDGCeHAG5RvW5ZwyKeh2h8igQxloosamk9qgJdLu4X31KZrf/gRq0GX6yKtovZqRraEUNHlN6EkcO0WnGq1GCOXSyhJpQF14kf6//R9xP/RxnKe/+SeyiPUfCmPbVH/5Pczf+7Oo3/hVpGhIH3mQXlKw3e2zt56yLG3itcApj7nr/I1kmUdpPAKhaZEUjiKyLXpGMLNChLNJ3RQ0D99J+vSTBE89ibrrfnb3zYkHbm+BqTNU0eCaPv5om1IXrB//Kp2nn0TfdSucHxKGHRytyZYzgt4ILduTOtrKYGyBdAKoEoy0yfanqDzD2riRXLjEt96D+vCHkU98Bf+Rh7FcgbIkSkmMqQFBGXq4lWBaRMixSz1QHF39Ft3pId7t91As9qhMS7R9jo3hGL2es87X2L0N/PSYoAfKVzRTQ20SRM9ivbGFnS05pUJ2GljZhlhq0iKnH/Q5Y/msTIXluES334MOfxf7wrMkb3g9srGJ04TRxz5JETjMHn2Y28qS2qwpTQOWIa9a/MF5rLgij9eEnktnMESvVuiyQi+WtEWFPT6D5yZQFzj41FVLvVwT3DHAWNkJ26Yc04uGHGcB4+EpfvTcq/iVK5/kc3uf4c+feYxHxi/j7nOP8VPf/BhPLj/N7x58mScOvvw9+1FjGj5x7eN84trH+T+6I9549s28YfIyHih3qC0LN1fkOyG+LKmXS/wzZ5Adi2K9Rif7xCKl9F28wkE6Ai/q43szqHM8x8MuOthlyNhXXCPnoGjwRYWgwZIWQSvQwsJzXUzeonoddLaCokANO/gHMflyhRVFtK1BSkVxuEeyLAjGfYQjKJKEXncH1w3QWY2Uit1iSda2bFgOjsiw2ppKetQihFahTEVT17TWiZXjos7IO338QtN1bZIyxQ9H+PJEfFAFQwLXZSolx3sHDG4c4Ls+jVXQ7w3Ipwm61Hz50hO0SO7feQU6z3G9DdqyxOqFjIqMN2zezweufZqPvPhp7p/chEZgWoFVtzihg7QbtJbUyxUiq6mDLsIqWR5ptmWFCjRur4dpTtTLtTLQGCzHJW412sDAkhzmhoG/jStXZNUS1ABHN7iWhcFB2EvcKicXEtPdpG01aZpTS4PT1DiRgx96tNqhNCnzbEbYgBN0sOr8JLj+rrpsVymMVdPULg2GcaSpOrCqNYEUFEmFqWMcpzqpw/ZP5FltV1EkNU3dooKAdVxQzZdE4wGPL1/goy9+CtEYBv4GP3b+fk7ZZ9mLU7793EUe3/8s945/DttYhG1KFtisRUvUFiBsqvl1wu4mpn8OUcasTUVZLNlyFbYz4qhWlI5Dm69IV4eoYIjsDpnPdskOruOcvgW3rsgTj7lT0NgFwybFCiZUgUcdJ4y6LfM1JEcxo07IqcEYQ0FVzLDtGpoVjdVBaRvTGgotiPwu7ewicrLNoOvR0iHKMxQtzromyY4Z72xirBRRKjzlMeiPyNuU1lzjytERO50dvpB+GWNL3nHnWwmqiEoKGqlZ5jPS1ZqqyWlljcsAx+qgiOm4OXkWoOqSarpL2qSI3gjlbLMlfYq6ph/2sFY1ZaVpVgmuKEgPd9nPvs2Hdj/JJ/Y+zPXipQnz/jtUumK/3GW/3OXp6Ze+5z6ucml08339q1+z/RD/1f1/jfuHd2Jpj+dXM0rpME4KguqArRvOYPzT5GmM8CWip4gym+dfeAavatlyJ8zzPWyZ44UNeZKT1d9x13E38Kw+0s0w0uWoshG6olfUyHBAHWzglgW9qCadxWTVgr20xen1adIZB62h6d/IwLJwOhYT1cGIFvgvLMD+h//wH3L//fdz//338w/+wT/g/e9/P3/37/5dfv7nf573vOc9vOc972FnZ+dPs63/2aMua4auy5nxDaSJpGo1mZ0xDiPoB5StpmhdZkFIXG4xcLvce3pMNZsTrOfgNND12MhaoibnZnmOJi2RXs1Bb8XFrkthLTmIdzlY7nG1OqLYl7RS0vM73DE5yylvzJX5MSvRshOMQfnkRtNVUJYNFRWnvRHuG99Ae+EF/Me/AA89RNDx8TtwPLc4727iKJ8mn9GL+qhgG9/xWU7nzD77eRxps7j3brp5Qdfy6IUORa3BGGx/RHy9wtI10quwrQjldzmYHlLkIMOQKJDkRqOFJPFKBkLRZi5tIbBtRdtK2naIK66zzvcwdQPSwVIVHadDZWwap6VrNMIY/DBkUcdkCNRtd5K84iE6u/tceehR7Nc/CP0aLzyF599IJRVVPaNzeJXgN36H6qZz2H/ux/BvuQ1dpsi0Zmu8hTmaESsHtzHI6wuUHyFdSW71WT74enqvfwt1FNLuXqL50uOEn/kM4RNfxD3c+yP7iawr/Isv4F98AT598t3md35rBgOqG2+gOreDuvk27Dvuxr3nbrj9HFSC7Nld8nzN+uwDDJOSYGNAlixoLEG4cQ5dZGTFnGM0jhaoMsGYCGWDXyVU/R51dCNmHuN5PmmRkueaujHYpkaqkn6vgxcOCdCU1/cpRxO48hzV7i56VqKvLhjNpzSTIYtbbqHnWXRCwyxvMbagn2tMJlhmOXl5yNbWFiiDox123DGpNqStSxy3uEJSMCfqTggpWVUJgyhioy8pq5ZseSLUZo6vEbklfemwKhtmtUFFAzalT8f3oIoxbUmNjVvE3HPuVo7iJXnSMlvMcTdP0TfyxGZnmUEZY3dCuuGQOtD4rkXHjfCKlhdTg7EGbExc+rbFMrlOWLd4bodSCxypcLojslVLsdjHt3IqzyaXOfvLqxRVyLg/JswUmZnSd4b4BPTP7qAv7TFfLNHnztDDwZiSskwRTUvelBht6HkR6ALjuNRlQtRZ43QcmsqmtULqcpeO31JYFp7Xp+d5HB1eIl6V5PlVupOI3sAnPHsP8ZUZxdEU/fyz2J/+FEWvT/nuNxHVHY7iDDG2iBdH2MLCQqPbhqqJ0QfHiGcuYX/wo/Q/9jGsF19k+BLfg82NZ1m+9hHaM+fwk5IgnSN2r9M+exm9XCF0i5WkqJeor2CUovlLP8Hqr/816s3T6E9+FpnGtG99I6UXsJheRVsNFhV26eL2bkCWhqrKmWzcwHyxJEuOCLpbBNJCRBZ1XeDVLt3hOVSRkjkRvOMtOO//bfIP/Rr5m9+ErRoWtk8Q7NCqCtfapFYti8MF4ZefJgy7ZA/ej2oEXjdEVQVFcsSiWmK0QfX71FWJLQTS74FeUB3sE794Gal8VnVIfbzG3Hk3wVe+hHrmK4TvfIyqhLapccMQIQ3LozlNo1klBqE1Z4YentsjnT9Lbgeoc9vkRUWvrgidFpnPmViKQ8tBqwAjHZoiptMvaW+9keTqVfrWgLWtGLpdxnZEs3+NtafQfsg4t4k0pHUFjkOhW/xOn+yOW/Ge/hbV8T7y9CkGj3+B5viYvUcfRsRLlCPIHBcr7NPKjDDs0h9vU5oprYamaWmbBtXrQZrSti3SVkgnwnO6NIfPYwUtyu4hZynZMqbbH5PnS+LFNSY7G1iuR1Jp7rzh5dx09E2+cfANbumd5hXeDeRFy3DY5THvER7beAvzG4/5Qvok73vu19grDr9n31qUM973wi/zvhd+GYngtuhm3hq/nlfpd3Pv1gNEeUGwWmEPBgS+JLUNcZVjVR5FVtDbHLGuYoTrY+scrVtcMSBOEzbGp9jQHbI0RpmWmpZlOqctG2x3RKQFxhhkYCNESBMnGKkYDLuUWUymAgpTIYD8+BAn2GJwaouD/ecoK0PUmWCMoa41B6bEaWGdXqe2A4Twqb0urq6xqpo6ibFXx+B5NC0IU+KaljzqUrQ5fW0hKQhUg99mFMKmkYq2LHAGA9rVMQ6GRkBeFvTDHpmTkO8f8tzsEreO7yLMalpj6EQ98mJKoTyqMuYN3g5ftEM+dOHjbIUDbDzsssLGwwssjMmpc018vIuRsHBKgqbBaiCIItrARZQVRjgI16KpM6Rl0UhJVrd0LEmjK8pW0/PHCClYrC8RuALH6aAM1K1Auh1Eew3pBFSyRGufPF4SWjWdwRgtJLZsMa3C1yGr5DKLtqZfL9GyxfLP890Ov1WRodZLvKhLI3ws2TJWNXvZgqozwKsM5SKh6bj4Oke6XZDqZPHMkhRZQ6mgDUKK4ohffuKX+Hqyj618Xn3udTx29gEmecpsCR3f8MD4dp5cf5Nvl9d5Tec2rOWUsHuK4+UKW1co4yJkg+qfI28aukGfVhtsnVHqBt2sCUTLOOxC2OUg1lg6x2odssAlWxxzdTUhdoRCTwABAABJREFUnrdYOqE6rTiV1PjKIY0CKgSuPyBtYlRoCLSHrxsc10eoiGw9o80W1PWcVm3hWpKmNWRVy8go0m6Xdb5ERj1s3ydoa0hXSM9FzecUmUO/u4OofYyJqasVlrYIQ8GwhOfTKU8fPst95+7k5tFN5PMVWAF+PyQlxrdcsvmMvTinXBec6kf0Oz2QBaKN8VZLShrGkwml30NYHiJbsKsDxkmF4wikavjm5ad43wvv57euf4yr2fWXOOr9YCi/T8b6TWffyl+/6a/y9rteReYqLk+vk7YltWgZ5S12uosXWPiDGyi1ZBB2UVVO1jQc+SuOi0Puju4ktATp6hp5UzDsDyidTcx8F9tz6EaQz45odZd8+zzV0R7u7iGZqPFuvhUn2qDM98mykF6vT6MTLtZzprXDRttgCc0ym3JqvI0fRdjjEMd2/9Bz+k8NLznAft3rXvd7257n8dM//dP89E//NC+++CL/7J/9Mx5++GHuuecefu7nfo53vvOdWNYPJFD+XzQiaRG4Exq/jxuvaTScDyJc4yH8kGlSsDaam8cOq0VJVudcyGI2ejZtq9BxSp0sqewQE/m4dYvtOMgzATdE9xLohqBZMrrlTayTjNUy5drxLlebY+Yq5kq8z3PHl6jKnMB2uLOzgxr0sfIEO89oa03k+ZR1gru1iXzN62k++ynUU4/TffQhFnUMbsBm4OO6AcfLNZVw6HgBStQwnSG/+k04dYbwrnNcP4a76ppAAUjioiHwwO0F2JZDWcTUSiF0hr3KmHoRw0lO22i0zsANycyMs30fKT2WhWZ1vGSys4WUkqZJWa6PSGvNxnCLnuegjSDXhi4Gy/cwbYttOwhTktY2wncwr30D/PL/iP3U1+ENd+DFJRNfEK/3qH2bNq+wP/YkdqXh7W+hOnMOLRUqCAlMiqwzxk5LPOpRzmPaw5jOaETHVaixzXQOHdulNBbJ5nnWbx3R/+E30sguzGdYX/wkzud/F+/xL2P9T2pS/yhYiwXWUwuCp74C/Nbvfd9XiqjXZ9LrUEYRQVHihAHWudOEvRAziKiv5wwGA5Rackk6yMCmPKyouy3tSGNHA854klmmmK1bDo9zgl6ATOaM1mvKi88QztaER0vk4QH2fMH4wgWaS1exjo/Y+e/+0b/X3s5ojPOWt1D+1Z+mOLtF6WjmMiUnA+lguwolnJMsr9igPMrw2pgkGLFMYjwkwSiitkGmFnGTsdE/Q6dZEuQNdViQWzZH2Yr9wqXxfVrbphsGVMIhx9CzPKaVoFMviQKJakusKsMyFoesmPRtBraiNYblUYxeLZC6wY2G2KFiUcTsdHuUect6VeA7NsarGUYj2lrSpFOc+ZxqsYufpthtjT/cwVrnpNeucDybYhZT6v4Q+fAjnNvexFEdqriELCbxAgY9KF0faYN1eJX41CYGgw04fgB5hmo1VVFTuxl+aOF3XYq4QmpNtz9hf3/FdD4jLDRZ20Bp08NhNk0pFzXbjkO7fw33SNOJbJT26c7WyM9+CXnxAnrQI7z/ZTgf/RT1bMX5wmCZEKcpcKsFpk7QdY1ZlniPP4mazV5SnzVSkt13H+uHXoF8y6sxj76BTn8Te7FmtZ7RtjO83iZHuST+J/9vrGXC6sFXMnrwFYTZGjWdYecNcu8A7/ILqMUcmaS065js9Hncv/FfU99yhmp6TLx3AeeLn6AcdBEvv5meCFgYm7YumQy2yXOLnVGEqhqOsiPm0Sm0KmjLhsBYNG1NaSsKIwm1jytrkuWU3G/YvO1G4jvvga8+w/Z0QXnfGeIYitImCnvkdMiVQX3q/ditwfvRt7AwDc6qwh4aZGcTO58TH82QgQtNzrotsWMboSyawiLbXZAfTxndex9ez8ZBEEZ99OtfTf2Rj9F+7es4L7+PbFViWk1nPEFrTXLtkNRIjG2YDCK6oyHLwyWZkewPOsjuiFF/G6NdcG2CqqAroJSaWreQFXTzI4SyCdo13cFtHNQ5kRWgmpy1yTkWm9zY7eM4LdW6oa4TZL/PoijZ7EXIe+/D/sa38Z7/Bksl6X/5S+Qdh2tnN7m7thDDCX7kY3mCIsvp9Dep65rIdylbyKsGL88Iuj1UFFGnCVJrtBYnyrPhiNoUeF5N1O1SJCU6anCsLmU2JV0c0u0NmO2vcMOAN93yaq59/Vf53OFXuXNyH72mZGcyJDsOODq+yubOy7in88P8zJn/im8ePclvHv86H7j60T90UqsxPJu8wLPPvMA/eOZ/wLd87t98kNdvP8I7b38zrxjfTNt1sNMIu4SsLhFZiuWf+LmfthXxMsYPt8haSZIvUf4mAw9qCnrKw4iMss5pAsMsPsaVHoFQqCCgXifIIicaDEFnLKYzrFDQi07Gx6DvUDcxuq0JgyF1XdO0cFCkaJlzmxeSej54A4rcItYFWX5EWq7pGA9rdh05GGMtpzgStLTYCELWQhJnOXZk0eYraq3JjI/bVLiuy2jzFHExp8qXlDY01gl7RbQNX9n7JnFRcrt/nrLWuEEHLS26O2codc1qoSmLhLd3buOf7X+a37jwaX7y3DvwabAsQSNq4tUx6SxHmTUqOoPCRZctvUEf5bbIRtOsM9yhi7AFbVrh+AGrpsUWglApVmWC0QrftWnrkKYW1FaMb070J7KyoJU2lhviKE3ZliwyiMo1lvBwuyPQ+XfuZ5dstSCyfDI3osiW2L2Aul0jTYlSEZQ1+fwIx7GhN0DVNdJ4VBqGck5h1uRSE/oWWD3qeolbJeD1vjPQC2arEmM3fPn483z2yhdYrRbcNLyPd9z9TkobkmyBMh1ilWE8xcNnXsG3nvs2n7r2ER4aDrEijeW3qFXKOp5jD4bYUYfGuEgpqaRC6pINL0RYHZKqYFWtCKuQQIZ4wQDbbolCm7BZkx98jergImnlUweSzBiWSUnRH7BuKtLCYSNwcLwuvtNS1hYmz2kbgefaKCOhFmgrQlcNSiQkrY1JGjwMZvMc14+v4a3mnB5vIFyXai+h6EiiSUCxLim9jHyxQqPQpkR7DsHWOW7hkF/72q/R1DU/tPMaSqmwpaJ1LURrMegMKEiIMXQ2Jmx3JrgYTKORdU07vYwpNFVvm8ALGIqcRinSaIA4Tvns3pf5WvIpPnDlQ1xYfn/697/DTYObeNdt76LVLRd2n2UvucpBveAwO0bzgzG8LKH4kXNv5udf9r/nVu9WkuWC3UbgyhLVQq0ChlrSqa8gg4LeqXtwwi5lXuIHAaErSNczPrv7FYQpuGd0I8YfMgwHyHWGrhYcL2ZYpqbJW6xwjRIWeWEh0CiTE5CR2z513tIcHLE82CNvArbP9HGbs5AsKIqSxjpNzwsx1MybGrtOIJkRRIMTdfT/DPDHPoubbrqJv/f3/h5/5+/8Hf723/7b/PiP/ziTyYSDl+hT/Gf4Lrg+/d6YScdjMV/gyJZ20VIZjd0b0Om6dCuHRDScHXbpliWXGp/ElnihodNAerzCivo4jkNntMU8z8hWu5zb2iCqV1zcLdmdVowizf233c15/xRHi2OOI8GpnVvRVcaV42cJKwu/P2HQ98nTI67PE6T26VktSbug7/q073g31leeRv7uJ1necZrKtwm8CZ4x6HpN4PRZ1pIQw3o6pf76VwiB9tGHkL1TzOdHiDSGpsCzQ2IakjTH73ooDKYRZGlOux/jdztUysPNVhRxRuPUyF6IzmqM8NnodalkxnQxQ7geTkdRWy660vjCYsuZYMhZ1jmRfSLkoP0Tylabz3Bsi6O8xq0V/taE6rbbCJ59hsXBKdJTWwS5oQkNrTJ0PvI5mK6w3/Y2rAfuQsxXJIVEuR5Rv0+1u4fth7jGkBmBkJJsWWKcgLXIqFybJvIJWnAKGAjF5mSCWVfoU5sc/8SPcfDDr8FuPTYPXmD8za/hfOSzOF98HPUD1quKtsWez7DnM0KAb3zzD/wefNd2BPwIJ4GPDnxMp4Po9ZH9PiLy6YVd7ohT3IN9nNkUcXz8h1J+1Xc+fxjs2ZQzv/Sv4Zf+NfEP3c/0L/wUi7e+AeFEbLohTjCgcgtkXdIpQ0yiUWHEQEniaYYxHsFwRFpm5EmONBVBu0LPZ6B87N5phFfTGW4xm88RhSA0LoHvUeY5buBxkFa0Gkb9Dbo2tIeXSNfHZM0ATUF31COqJaYuqZuCzC5JyoAMQ/vit1CXdomLGpnkeNTc0JYs54ekWmOqGt9oZKXRtKgmxQgovQi9f43OhSuMXryCs1r93jUxlkUzHDLqDSkjj2a8gdg6hdkcYfwejtBU85TkltvwuiOcroeyPYKqxHJaGp2hTR+3dVlfOqC8vIubPY2+cMDo6iUmOqVcHuMvU9zFEnF8hJxNv6fwnwN/MPP8y7/0/brZyT39I/cA7bkUDz2E+uG3snrTa1n3h9gWHMUrztaGQFpoN6IXrDjcXTJlQD3oIN7zE1j/8gOMPvt51LALDz9KfvNpGm+COLhGkz1E6A1Q/S5tL2S+f4htu1TLY5qiQHzmaWQrsd7+NoKwTzVdY1mC1E4Z+T512SB1y3h8DrU3IykX2J6ga4/IVwfY0ic2KywUvfEG5toL5LMD9OYE5U3I3vpu/OtH+J/6FP37/hqTU9vMViuy3KasSoIL30I/c4H23peR3/wK0v0LREKQ7s/gaEnZGprjArk5pNI2SoFrKUhKhIiRbsZgM2B0xiGXNa7jnlhkvvIhmk99hvqzn8W+/+VYrktV5ASuS9QfMM5zDlc13Y5PdzSmqVLEiy/SGQwQO+eYOgGXm5IzScow3Mbt9rDyDM8LmM8usjieM1gr3CrHVz6516Vaxki7oSpS6tEZIiI2W4M7cLmWNlRJwdbY4rAomNaa7o03IMKI7pWr1AfHiKJi/pbXMpwM2B5v0UibstCUZYwbBCjLp0hTXNelYyySJKapKuqywHY92rpGG4kElK6RQUDWRNRNgtszFGsLBxvf7ZCnh6TrfTr+gMYyzBdLbjh9L286usZvTZ/md65+iXdunIG8YTTYoa1iisUBduXR2dzk4Z1382j+w/y3xfN85PL7eN/lz/PVo69/3z6eNzmf2/00n9v9NH/3yf8bQ6/Pw6cf5LWbj/Lw+EEGnR2SVUyPDlkTk0mFAkqrwnM6ZMWS1kyZRFvkrUPWxJhyie/06AUbVElOqSqKYo4jHWLZUhVr1nFOTkGar4EeQjdI2aLbKev5IUVriLoWV1YHlI2i0ikjKyWTXSonosrX9M2IjUmfbGUxz+aIuqF1BqTBiHo6Q5gCq7/NMIixIovpumRQWizyKV3VxQpCPMenQtAKm6R1UOspa8eirhuy9R7ZwS6fO/w6Lg6TdkBdtjh2S2kEpRvg+RFB06Jdj3vc+9g5epJnrjzJpfABht0hum2pVw3FPMVCo5w+QmxiVSnCsdjs9alWC+ysQHehpkJWLQhBrqwTarit0EZTNCUKG2FayqykE00wVoyrQElB2zSs5ynDwQ6kR1TpijQTbDgWjfHxfEUmIkyypl3tYRqD8iZ03YbV+hhjT7Ash6ZNqJfXEIWmsgTd7phl0YBjEToeq2mOZQ8ZOymr5R5rMcKqKqSwCPIUIwPS1rDISr56/FWe2PsUSZsROj3efO+7uCM8zY7lsKdzrCrDFX36dkEZ9WnMiIc3HuMzh5/ky0fP8vpbXk5TTPHKGUlYsLIOGFSnKFYrHD8iwyJQBVJaOFaILX0yKyNvctKqwLVdhIRGerTBDST2FZhe4IbhTdiRR1amJF6Iq1pMI6kbSTcMCJVgsTqm26mpaklZGJwApClp2hITjPFEAO2cuJziZZrVeERr+yfBV75AFB1M1ZKaNbW2GI9uY393yvzSJSxb0z17I8arqUxJpzfhSy98hbiZ8oroZWzJDnld06Q1oR1hhMSxHQ6Wc+blnDt2buNUf0KVJ5TrKc1qii0jypFFvTqkyg3SD/lac5HfvvJJPvDcr3I1ufwSRj04F53mz9364/yFl/8lHti5HwxkccX66iXq1TWs3hm+UR6yu77GNLnOx/Y/hZKS7e4OV5I9luUhu9k+0+wAbX5/zuUrj5++9af5W6/+m/hJxkJsMIsLpDZUWtLNl3i6RJg+oljhORJvcBt+t4eUBY6S1O0K34FEar52+CIbwWluGt3CPF0TRhHRYEBVefSiEqVy5qtDolYy6AzRzYq96zHi+Bmibhdx5hzFukXHGVZpsdEdM3T61J7GCwYcXn2GVK1YmpBeFdK2grotMbqk1fWfBdj/Dru7u/yLf/Ev+Of//J9z6dIljDEMBoM/ibb9F4euH1FFQ+Isp2xifM+hTgwi8gk8D43CmwMyxkQ2fV1wWlkclpo0qQiDHr2zAUYYmn4fa7iNc+UCtmtRlXOM7DHcDKmXS8pkTiyOEEEf2aS0RnN8fMCNk1P80I2vRmYZkW9jNQXL4pgid3FtRWALTBCwQjDqdvB/+K2sf/PfUH7xCeQjP4TltuRSUZcaTI/K1MymR7jxHO+F53H6feTt9+AYFx2tma1ThkWK5UZYaNI8JRhYGECVDmY1o9A1zugU9rrFtm3SpEWMBMtmDTInaVxivaIWmlqmOOsFgY5wcTk7uhFhVYgmZVq2WJ6h6/dpkwrpexijqVfXcbyQajqDVU33TJ/mVY9invsG7he/QfXe20ndPut2wZlPfgFx6QrF3ffCG96ESZZI5jiU4HQpyxKjW4QUmEVKayqiXoAUmlK1yKrm7OaQfhTRMYIXXzzArDX2wKfwbaZZQp7PkcuSIPKJ7riV/JH7Wfz8/4bk8jXGF1+gePEyav+A4fwY5+olxIsXUbvX/1B/3x8UQmtUkkKSwv7vL5i53/n8SaPz5afofPkpzv6fOix/5N1kf/4nCF/3Kpp2fiKGIsc0Aw9ncxMrOWYyUlgY2sMDKnJSs0/UdzFNTmv3UGGHxlaUIidpDIU03DjZYNsNmcY53d09epdfJLcd2gdegeltI3ubVIspq/kC5UsmgaJA0vU8mucvI46u4R4fI64eU6/2MS3oUtAasDwb3Y0g8Gm7HRa+T9CJ8Pw+oFDdCPH8l+CLXyL47Iex9r83O0E0DfbREfbR0cliyPfA5Lu2db+PnoyJxiNoWsR0hpzN6axXfHfRzk3ffa3/WHfqB0MzHpO+9jVcf/k5qkcfJhzdTOg6TLWLb3WxIx8nb6j2jyllH2lbJEWK7u5QipoyPmbUH2L+4l9G/OIvYj74UWw3onnkVor1NWS2JDMebZ1jpIMpa0qRYxkHVTrY13cxL15G3XY7nXteCcLCkwanU1HU1zHFIZHXoapabH8Lz+9j1Wu8aBPhSMpEQVnQNDN8Z4gtChLXpvF62HLAopB0hgPad7wB/W/eR/OhzxD8zF+GuoOV1nTqDPGRD5H5Adab30KWpiBtgs3TWJaLXs4Qyzmd0OAFKZXnUGMxGG9iKZty/TyL2Qpnc5sSeTJRir5zhz0P64ceoP7c52me/TbO7beSleXvBaNuGLBtlbi+T5lnNLNd5CpB3nEn4+6ASX+by4tD9rKY+OAa29tn8WyXQtrs7NzNbP0Ei7zDxAWvs8leuaSocxxjIwmwRmc417a06xUygigwxDkUacHEtTioaxrLo3/zjQTffoFIrVjfdgeLrXPcGIZUocYzgrYxZGmOG4zI0pMFH8dxiKQmyXNqrVF5jlQKozUYB2VJyEqE5eBKReVIlEgQq2MoO0ThkDwcUaYr1geXaTsNVA5tqbhveB9fWl7h6b3H+aGOxe2dCdJSeP1biZ//KoGzYOfUHRRVy1xKrGbIa4fv4G2bP8HjxR7fOniCp65+jqfW36Q2379kYV4s+eCFj/LBCx8FYKezw6tGD/NQ535eNrqXsBsy7Ixo02Ny06OxBFW5IjSC0B+xwifLU1RgYxmw3ZAotCh1SVEXZEJiSU15eITc7BNONO3SolwXdEc+jU6QraTjbSD8Dk1WosqUkW+YOF1kMEYimK2W5FRshWPsUNHJFFZ+HWt4mirc4mhVcrgo6fcCtGNjK01ray5OD1iSEUmbgV2SrA2uENitxlE+1WIPGdXIlUeRT7nMIa3V8MbtBxkMfLa3N4n6A5CStGrJyoZS+Rga/HDA3ZsP8Mzqg3zq0m8RnnozfdXgrm3cIKQbZkh6uL5Fv1LkURevlRQrC6k10lU0VQUYtHLIDXQsiSUFeVNQNhrRCso8RSnFqf4pFuU+gX2iQSGqkrzIMVsT6rKHWF6nqxoysUNHSixhEFJROoJ2HuP1NjHKwWkKbNtnXRaM/Q4qKTGlpPE0lSyIdIloT4TqlH0iYKa1oWkE/bBPW7VMF0eUMsTJU0Rh2MsTPnvt4xyur6Fahzfd8Ebu2bmNKBgykAqxXDJJ10jLp8yn+JFCCIeFlDy8/Uqenn6JTx19g9ff92bE0QUcGdDb3CTJ9sgchRAlWdvSrGYYldMGQwpSSiNxlUfP7TLLVuRWRl03VDOB4wek/Yh2eZVB6OPpmCrVXI76HOcVVs9lwwsY2g5Z1eDaPq6OkZGPbjTFOscyDSUGbVw81ycuBsTlMXWVokTAWIVMRptMD3KOrr1I4BgyJ0cVY1Te4k82aJocpyqxlMuyXuE5HUwLHzt4kn7Q4VWbL8ckBa7vsM41dk/ghRaLdYWsIAoUttIQHyCzOfv7F3h+fpUXmykvZAdcXF3l+uoSl5NrxHX6ksa9M9EZ3nTrn+MNN76dR70Nhm4fe7CNMYZkVpJlFQqoVYe8XaGtmpvCM7wsOs+58Vk+f/Q17hrczX9z5lWEqqYSCssxrPNDFvML1KLlrvEbCO0RrdcSt3uItqHNEraHfdZJwl52iOOM8amwzAK3d4pgeAOe51FXa7LllF5viONEXIwvktcVr91+JcIOQScUqwRpTWmsDXYmPXSmUX7AOtXU8QF1UaOAjoHuxl04/iYyMKyOr3M8N/g9D900eJZHma7pR1u4VsYi3ed67JFpj5vGm0STANvyfsAZxv/88AP5YDdNwwc+8AF+4Rd+gY9+9KMnaqdRxHve8x7e+9738uijj/6pNfg/Z1jSoig0en2E7zU4so9xCqQTYimHw7rBlRY7octlI5gZwcRqyVcZbaVpOgH0JlRlwXCyhZtlYAxzN2CVxGxv7DD2POaRw/UX11ze38cZ2hjbY6Is4qrEiIpOYRCRS1kWZMspWd2g1JgmXxBu+RThkKJO6Ktt8lc/RPvJj6Ie/waHt50nUi5BeArX3SJNMuJKsawOOPXCNwnKEvsNryUlYuJZzDb67F5MOHd0jOqMMeWcslkhxAaqlrRVDW4EnZq9+S5COayqhCJLsCYBqzqjowyBH2AXHiNLk3geozDANhGm0th9FzeUTPMl7TojytY0VgeqGtntoCkwZUWrLXLA1pqu3yH2jpndczfh157BfvFFju9/kOATX8N++tuoG24mfvtbWaYZg7qlcru4VotjNcSrksqL0KsC0TQYS9MOh4y1Zi1LpGUxDEMybah1g+pKlNflelIhW0PQGExSYCGJAkNubMq0BRY0PZ/05Xdj7ns5nY0Ji6qlilMkJcrUdI6n8I1nMd98huBgD+fyRXj+OcR88R+7a/8BaM9FD/pY+9+7rlHFMaNf+kVGv/SL1HfdSfenfpTZmx+lvvEMtupRFgVtq3H8BvQMvTAobMrhAKsJyMsU1R8hlGEVX6Ppd5DrilNfusD42x/D/do32Hr8i1gH+3/g/9Y33YR+6CHyG27Bu+tGBrfU5M9dp15VpLtHqItXEKqlskLayMO983bCm2+HrdPIyQTTCai0oagKqsV1rq1LNqMBp594kuAjv4PzO7+FdfC9z/mPA7lcIpdLeOHCn/ix/7jQt91G+tgr4Q2P0tz3KEm1Ri2+xnho4/ctDnLBoYaBZSiahm5/wnLvIhweohwLS1WMT93IMlvDYoFcL7DCLeyf+Sus/n//jPS3fg3VPsDqhtPopourNGEUElkdbNdFeQpbuMSHR9Qf+yhSaLy3vAXb9XEth4I1KQG96CZsFSPRNHVBGl/HDjsUxxeoPQvfGeOZhmV8gLJs7PGI1nKJowBbhFSpwE5iBgOPw9vPYe6+B/PNZ4m/8nXqMzfTQyA+/mF0mqJ/4idwBiF1PMUfePQ3eziWQ91RoCscutiewu0GLJczytUeXrdDVjnQeugIasujo1pEvoBgBFLivOoRmse/SPWZzxHceQeW61IXJwG2F0SUSUIlBL5low6PMAbEziZud4ywbXaCPrkbsJgfcungKt3xNgaLTjBmPBixSAzbzmkKx+MguYZvBUSthQx6dPyIsSVZpglFXCKVod/x0HmGdvr0m5rY91ndcBPy2y9iLJf5g69A1oKt/ibrJkFIha0qOsMulhUQr2K8wMMY8GyFYzuUusZuGookoW00ylYo0WK0QQgLx3dojaARPYSXYYoVwhN0vQkrWbFeLjFzgYw8irSkkh1eM3iQXzn+dT56+GXu7LyTeJUi6dIZbdOKmDxfI7QHqyUdrWk8l2o1Z1M63HL2bfz86PXU3R5fXX+bry2/waeufoZvzp/5nh7b343deJd/G7+ff8v7sYXNu254C3/zlf8N93TOkeVQ4aJkSBnPsFuDqQ3LWIIoCJorOP4IxwpQQlDHLTJtGA420Dg44Yh5WLBMEoKyQbUaKQP6OKROF2l3OBMGLNKUQEgib8DC6hIYwaZrSOUabTSZqCnqFLOY0Tt9hlDCprQorJCgrRCmi7B8wp7i4v4xlmcjqTHpkjhtiL9zFUy+Yh3PaJo1br1F47h8sTxEdSLuPvswiaVZSouyaZHS4FuSnrC4Xgl244SkWJNkPncM7mVWXWeeX2cQjgl1QSdysNsS4fVw2wLj2pSuB6sS23ZPSsC0oakamiqnGW78HjUcoGxKqqJF6QbLVji+R+AFlCYjrZcM/QGebllrWOU5FR49rbE8yaJuGPYjRFPRCk1VZgSdEVJAY0rS5Ro3GrMuCtbTPQJt4/Q3aFSLKqe0ZY5FTmUUTa2wbYUSDdU6R4wmRG4L+QGibTiuNJ+6+kG+vnoeIQT3brycRzdeQxBBEEYgHXzHIvMs1KzElT7T5hjFJqoUuL6HpxNetflKPjr7Ar/77U/z6raPM+4hHZ+23SDFZ9LdYo0hrJeYqmGZacr0ECTU2qGvJT2nR6NKZuspbXVM4Hdo3Q6RHeBVMXJ4DpMfMTQJx41CKk1lDHuLDFdAL+pQxgucwIBW1OsVxtYYaZNUBtyW47Yh0JJJ7xSBNIhmwfVszeXlVZZHL1IVx/SGpznTH0E5h+6YtW2wjU28PERFNoFn8dvPfJxE5/zImdexNZwQL1fYlsI2kn0dM1vssXt8gW/vP8lueZm9z1znWnrAlfjgRLX/B8DpcId3n38Tb9p5FXeffRXrxkPZgqo+Zp1cwxM167mgjVe44RDh22D3uHx8ASFtNje2sFTBQ+p2rifX+MrhE2yGPW6c3MbQj/CTFqfaYOPUmG53izy3WLUaneb0wwGTOmNXGVK7JFsvKJct/R2HQbuH7Awogy0GjoMQgjQXyDbAyzXGETy1/3Ucy+Fl536IfJ3jO4I2g0SVeJ0Vfb/HSgyReUk9UFhBH7G7j5sV9Ce3Y9sjbARu12O6J2iNwNgldjfE1hI1v4awIzwdM5ItRas5jD0mkz5ngt4PdL3/54qXHGD/3M/9HL/0S7/EL/zCL/Cv/tW/YjqdYozhkUce4b3vfS8/+ZM/SRj+YfmWP8NLwWoVs1qumKiCaDQgXwgcWxBNhizTmtQYzkUOgTQMZcnCsohnR0z8AXveiLatGLse9miAbWA2W7DSLZ1BhKtcbJHjqi5gk7p9CpHQy2b0ghEdDcJ1aYxBeS5YEE+POD54ASfYwTQFrsmpu9sEfsR6tcuV9YyMhuCxN6J+6zcIv/p1nFe7jAc3IxvvxJXCa1nonOapr1A4PuVDj5IVMPEltw0mPOVPuX68z5nNCFFlOK1NNW+wPJu135A4CsvySA6P2AwqVGWhvD62G+DbhnOORycaEVgKpguk5VJVGY7wcQc+xXxFPG+pxwMmQw8dXyKfXcVuHOSgjzY1rbFYxStsP8SuJfVqybptsV7zOuxrB8jPfxnP9uk88XWa0YTOT7yLTmCxXie4TY6MQtxeBzPbIxAtdTSmnu5iigXeqQFqc0h9OKMu1gSdDWwj0EZzEK/JlKI/DpFZg5e1ZIcJxjhsbHRxrYI5NseLHFes6PZ2yPOUjtAMQp94OeU4XXJ2u89QjlE750hvvZ34Na8mwyYajLFdm+LKFczXv4j61ldwrh1hxQlNEiPXK3SSQZripAkizVD5Hy6a8UfBWBbNZIw5fYpm+wz5ZBP/zBnsSZ/VNMF6/gXatz/G/r1ddKFxXjhi8sFP0v/gR1CL770IYH/rGez/wzP4/2eH7B1vIvupHyO7925QFn4wOqGnei1ar+lYXexqRZm2qMtfxXzxCwRf/xreM5dQzz2PML8/4f1eLz77xRfhu8S4jFIEkxH1aEJ17hz80Csobr6JbPsG+g/eS6/z7zN1HMA3Le4Tn2Xw659k9LGP40yPf+Br+h8LRilwHIznYRwbbVto18U4NrVS2E5Aa4MIHSzhod2I3I8QgYsVeKSTTeIHX0vn5TdBpBhJi2zvIsSH9Ea34vQGdCanmc0zvCQmcnIGXoPQgnQgOV7P6a4aNrZ6HNclwrIIo4jD40M67YtEownNX3g3za/8IoMPfY7+ax8mvfNhwu6YoNvHFxKhLIQQVGVB8sQXsPb3cV/zEKPb7kA5Lm1WschTCktw88ZN5KvnKbXCCraoqwo/CpFK0K4SdNjDSDBRn8gZILCYrac00kIEAzyrxatXlMt97CDCvOvdmAv/mPx9v4nzv/qvCa5epnnhWzR33Yr18APYZYZQBt8NcB33RGyqqbEHY2xh0Ks50jF4w9Nk8RK3FZSFRKkQE3ZRdgVuH8oU8sWJhWGvh3rZfbRPfYX28hWcs6fJvkOpdsMQZVnYrkfQ7RFfuoiua/xbb0a6J6UylmURSkl/6yxHR9dZr48pvC6tFdKNOmR1yaLKKZ2KtnEZegFR09L0JzhKYlsWQa/PcnoIVoPT7SGXGXVbQQNRqMhuvYniqTH1bXeRCpvTUUhu+dhVQVqviGxBv3OGqmrxIxclbIq4xnIkgeeyTmuMlBitMfpE8Ek2Ba0GKS2Eq3CNS1On6HBAWzXY9QpHRNRliz/uYi0F6zJmXnsYKTk7Ostj7r185voX+di1C9wf3IXd9elunmH/yre4+PUn6A63qaoZrh8wmkworYBOVbObTjlwHG7ub/L6YJMfvfVd/LcvT7h67et8Y/ENHl98lU8dPc3l5Nr3fd5qU/P+i7/F+y/+Fq/deZS/cud7uWX7nZzpbxO1HkLU9IVm2R1iXB9hFDULTF5TlbBKcrSQRIMNSiHQSYrl2+BLaGqyfI0dniU3Na2p2bAUTZFh2wJXC5Y4VNqcuAE4IdLRWNJi6A1JnAVLEbKuMnK1z7JY4vg9Oo4gaip0CdOqQGmwckk7cOlNJji2Q6WhaEtyLaiaFbqKMZHmxbjg+ekF7ty+g2lS0PiGenGMv/bxHI91VZ7UiitB5Pgcr9f4JuLHdh7hfbsf56vHX+Nl/nlMOEbqijzWiDwGS+NvTOi3hsKACmw8fHSd0wqXdd3gC0HPOgmutdHEWUxdS7qhi1IG27YRQjDwxhzXMet4j44bECuXw0XKwG7ouhEtitasKFUHWVXotkDLEGdzjF4uaOeHPHHwDI0VQZIgPdjaOk+HlNxk+JaHxiNwbZImY5WneCrEVQ2l51DWFo2pkB3Jl194ig9feZzGKjg9vJE33vA2zva2KMo1aZIhVIDnVDTakOcZreyRzWIa0bK0awJPEnUEVdzwyvOP8Pj8a3ziwqd54PZ303U16BpXDkjRLHWBkAG1lNT+Jo4VMmqhSg7ZSxISf4SqTlTYR70Ju6sLTBcpjnFxfZ82n0F7E4kUhN0tElUh8xVdUXHcenRdj4mlyDMJYYGlQtq2pFAW07plVeVM48tc2nua/dm3uVwe8NzsOZ5fPEdcxS9p/LKljascHGVTtQ2OdPjI1Q/g2T6ykbTasFfuM62mf9yh8vew7Z3ix277Ed5w7i3c378VVguKUKKFwBE1bSpoRIdM5zBPqFuPft+iXLxIVUPqh+RNxpnRkHCgobYo84p3nn87/+SZX+GzB1/Gc8+w2dp4joO2JbmMmC5rlGzpeQ5trukFQ9KjhLArOdIlYrVENRHz9JDbBiG6e47CstEI1nVDWhT0fQfVtuxfeZHnFxe4dXQr/WDIYXmAypboRiHskMDyaT3NajGjaSpk0OPU1k3gbxNPp3R2zuNGPpQt5TInXeaEowFKGep8gW5irKDCjSJkdQpHFYzXOU225tJ0TShtzg+DP/pi/yeC/yAf7LvvvhtjDFtbW/ytv/W3eO9738ttt932p9m+/7IgSlxrje20lLqPFJoo6GJ5FserDEcqOj0HnWu8NiasC8q6Qe106OSQJxVFmqM8j8ViTVHUdAfQ73UwZkySz1mYOfNEgeMSdiV9AV0nxEpXdIDVMuH0TUM816M4eJGqsTCtT5sfkNqKLG3Z8KDSkqPkgDODHQavf4z1Fz5B8LVLNA/cRTw9wPd2kLbBaxJOX71OvUzQr3klS+GhbU3QtkS2ojdUHF2ZE1y8TORvEvkdStdHR1CkhqE/xLgBvdSj3x6QVzlWr88yS7A9wcTpUrU1KopwV2t0VtP40LgFKm1AtcRpjXu4wDs9Rne2qcpD2jInX+3SSEPWCLTWdDs9mBZMj4/xNnoMOyHrx16H/vX3MfnIJzGTbebveAuupehaFeuiYpHHbEzGCGnTGIfaVHhlQeP2SOtjfJFhKcnSE1jrCq+uaPKKWFccFBVbgwEbgUtZGHIKTFTjlB6qklhWhO0GBMsFs2KF73apWo32HdLlirSa43ZcfK+P1UqEFnS6XeospcxzsmSFlUc0wQbuI2+guOksrSmxNyfURU26LKn9MXHPwhcZnbZksdplKUdsr2LCdEmj+jBdwe41PGOw6hxrvaY1Enn+NEknRA434dRp2qjPojiiiCLsznm2Q5cgcMgXMcXzVwiW/5J6dg2j7sDtd8nv2GB9+40s/ubPIj74eU596pN4n/nMHwiEf//RqAh/9YOEv/pB6jOnKX7qp3D/2l9n6U5oLz6JfPpxNr7+HPY3vob97ReRZfXHfxzbFvvgCPvgiOBb34IPfYhmY4POPffhPPZaePWr4f77aVwQdY361OPw/vcjf+PX6cwXL4mG3Zw/T/2ut5O9840sz96Idf0q1uEewTxBfv0JnK++gCg0qh9imhZzPMeeLxDz+Uu2ujJS0vQHqPGQqt8l7/VwTp2mPTXBn0yQnR51v0d1dA1zMEPmUL3s5dSPvBzHNbhVQ3O45LgQHFkVOq8ZrDOGUUE9FOhlQBSdY6/TQzuS04OAthE4QnFcThnWDXWVYByB8jxcbwehBEVRkcoO3U5Az4ah75xkr9SEBc/jrmv2G4ers10GXoioM5TTo8lSwsrQn0Qc/qU/T/0rHyb8yGfRzoj0NWfpGENoDLrVpGlKtnuI89QTyG6H0Y+8A+WcFDg0acFRltLb2mIQ+ei0S1UsEcEmupVI2WV46n6yOCPOC4xU2J0xHa/PanqVpUlxO+cI7ZB+R1GtE/LjI9wzI6rQRz72RvRv/Drhx3+H9sIljGvTvPMdKNOi2wYtDIF3MployvKEQueHWB2PxhY0h0d4lk1ueySNQqclxrOJBtvYTkujU3B9VJmdBNn+AOc1ryb7ytNUn/4M/l/5y9jflcUenj6DEBJjGprnX0T2ezg7Z3/POsiyLPI8xwtDtnqbhNmS3TZlr6mJVIhlGxzlMG80yvKZNAW2N6LyIqLvZAMd3wdlI6UGUSIcB19XKMtjlpY4YYh+70+zXGZ4B3PO97rM1xnSsjGU1JaLMQ5Nk+OHPpZl0VSaqmgwTUvbCBoLhNEIaaMcecIWEjbCkgglsZDYjo0RJa03QDKjlDGiafC0JNgYUy+PqUxL0O/SrTUPVWd5snqSj119grNnNphYAH38sEvTHGCkYnzqRqTYRHs1++0+W0WNsiWHnZBjUbBjRajGwndGbPdvZksp3nX2VeSi5SvJVZ7cf56n9r/CU/HXmZV/uADgp3c/z6d3P89OdAM/9/K/wf/6wffSlhVVNmWzf4rDskaFYxyvpagS8srgRD08V1FWFVanw3q+QmmB8k7mBUpAqU9omqeCBtto4iKj6yqEsZlXGouCtoRB30eqkLiKadoS3zTojVswjcS0Gdg+XuhTNClNqYnnBYv5IWdDiKwOU6fBBB6OkHSrEoFETiaMyWjXmixUPJ8fcSrq8tbNH+JcMGSlM1wkdZpCU9N3HHAifNtFuS3HyYKB6iNzw136Nr7cPMUzyTd4hX8fWSsI7B1UozHGkM0TymZJ4TlIJEZCkyes24rEEgRpDJakETCPF+RFSeCM8WyFMO3vCfRa0qLvT5juPQv2No3dQxZLVJ1SOF3cShAFhmV1gKrUiXjZsI9UEh1EfOFrv82HZ19CGxtdaipHo6YONjZFUyCNxFIKx3HIjcYxhsiCQBocf4IyEU2REJNxnBwR4fH6yet44KYH6Qy2gIa8AkuHrBYVwmmZ65wkX+E5Q3AW9JXL3DRUgcGKM7Rj4UqLV49/iA9d+zCfWTzDOycvh7IB28e3FZfyhL6tCaVm4AaE1smCQ0kHaz7jYD9mox/guRalqOkWXZq8IWmOqPyAfL1EzK+ghkP8YIRFRZVkRL5FLTKEb5FJm1VTcGHvWZ4/fo5vHF/k2+sLXIovs5te+wP1xT8Ial1T6xq+q2pjXs7/WMf8Xjgd7PCunbfz5vNv5+zZR9joBFhS0WsyjrTBiQIsf8zIVhRFxXqVU8YZ+fGMwLHJ/Yg8zRFOxiyfMewP2I4GlHh4/QmNPkJoxTvOvoMPXHs/H/n2r3HzHT9Ob2NCJLqUezVNFtMf+4g8p4hjytClWBVUVgxViCNdamtFVbgQ3Yxv22jb5npZ4WPoGUMYRTR1zZe+/Ql03fDK0/dT0tKqlk7VEjcrpHeGUnVpqgpbKKzQohDQtC3drU3cwQDLOxlbjSXJrqeUaUyv38ENPdospk0q3M0dtNvFeD1qc4lgGHBmVnF9f8a38paJf4rQd/7E79V/DLzkAFsIwTve8Q5+9md/lre97W0o9f2ki/4MPwiisIsvDXVd4imQboxwLaaLFTgWI2VRNwarFahVguVYBP0emWkx0sbYDqYsyfIKpy6wugJcUFafWLvs1TZttqBnDbmx12VRKjrSRrc1IuoSZXPmacNuPEXFiuO8pumeRmuDDG3C8TZDaROUJVGVsapWdLqnSdoF+nUP4v/W5+Gpy2T3d0H1aXWNr+fYX/kWwu2yevABOgo6oUeWrkhXMQrBunaZXp/jP3AbwXDC9fUMN6+JrIgoiE58QEMfNXUR7Qo2LI4PFpweb9D1RyyrNTUNwvepj485tgJyM8c0EZ1TIzo98Kcr8sMFVt9BCoUaDonzXepM0+gW4YQ4pWStc0zlcu7UKXSR0b3/Ppaf/zwiWTD482/nQNocFRnnIxeRTGm9iNZAvV5TaRftRIjpgiByoDukTmKq2SFpYHOmd4Z6WTDfPaD0DHbUZct1oGgxxlA2CU7kEHYCbNEQp5J6NedM0JCXsD7epRf2aYKAa9PL+J0+p7qbVA1oS5x4dbuKIIqQUrFeJDSyQeYtGTWdM7fjNRmmqbHdmrw/wO9EONLmOC5w8pIqGCJsSa+/iTd4GUvL5XA1Y3btLKdPneemUxukVcrFg4v0+336TYBoNEVZY9WSGYpmseb2sWAcOBht0FhYHYu8byOvXmPgvxajPPIyxOlMaHXClUdvZf6a87iHP8b2p79C/wMfxv5DKOT2tevYf///jvl//D+Z9PqIxQ8+cGrHQWiNaF4aFcw6OsL63Y/B734MOMn0yjtvQ1y9Dqs1AOL7HQAobr6JxWNvxP2pv4h68JVkdc21wxdpk4TNrbP4dz6A1ILm7W/Cy0rKX/5VWM0xGyHrN7+NSk0Y02KtW8yl58ibBFU0BKsE6TnUvSFt2CeLIvYci0MZcONGSNeCZXGNJjb44/OYoMSaHuM/fQXxu59A1C34EvHQvRS3baHWCeHGBBUFyMbDunqZtqoZekOa7R5tvotbaKp+h7Vd4w27lJZF69goqyViSbOaURY+syiiOz6FYw+xWoUuU47rlkRZ3D7oEOmGsmwJfI+uM6Q2DlXgsMYwjmw27Q5lA1I5ZNIiKwuGjsbrjajf/kbUr32A4NOfJguHrO9/gJ4QpKuY5XxJ90tfRuoWXv067N5J9boxhqPFgkbA9nCA1hrb6eK3CUmzppEhTVnidEe4BKzm36JWhv5wm47tM61yZmXO+WFA33eQVYUahqiiwMwW5KFEv+w+eOYbqK9/E91qrHe8mWw4QlYVBtASPDfAGENV5ChpI5UFSmCPx5i6Ri/mBGF0Uk+dZLjjAZ7vI6WkrqHROTgeqiogXyA3Jqjbb0M/+2304RH2ZET9nVpsx/NP+t/BLsym2Pc/gHB+n3VmWScZ/6ZpcHo9Ok3DWd1yWbXUUpGLkqqWrOI1mzT0dUsy2sLOUqRjo5WCtkUKhWt3qMoF0okwWU3Y9Smrlpl2CJqKJM84P4qwxwO8xZrFssDrSozlEmcxrvUd8TZOfH8tW6KKhlVWkyQVvdDDdh2UaWirFhmECPf3pzOu66JUQtlKAqtDZmKC0DtReXZ3iHyb1PbxLYnJ1uhFzZu338S/vvwRPrr8Ev/LMz+C03eJBmcpy4hsfR3LChFGUVU1dVbgWIZz5++kp2y+vbhC7kCnqVFCoHBp6wAZniLPrxK1De/YvJcfGb2VUWeTy9aULxx/iS8efIZPXvr491Qm300u8Xc++7f4R1/+v/BX7vxL/NjWq7nN3aYsWi7KnC0iknVDmc6IggjPHdO2DcaAtjycpkHoFQtL0PeGWHWKg4djDFk6R+iawLVYWh3qLCNdrdFOxLYd4kufrM5IVweExuBublKslpTZGs/ZYefMJsl8n6PZnEU8o6qnqNEpLDtkkB2i59dJ3BGFYzOIuph0iWoaSukyrzMuJS+y5Q25RZ0jdDpYRtIdDlDKpm5rwiBEKcWqbnjueEXhG87vTKj2U86vTvNC9yqfy5/nPvssqrVI3G02hxH2aESa5ZClZG1FzzgYS1IXBYsyx+31EfGKxGiqumaVL8Fy0U1OVq6xbBvZnowFQp6IXwW4THVBbVzOBBJBxDKDyMDQ77G/eo7C9LGtEbotMEVOfHzI546/wND2ePftP0qhIhZxTOqmCFuQFimmAiOg0Zp5npIWBQExDTl5lZLXM+bxGiF97tu4n1f1HqWTNPhxDF6X2FS4toMzCJGVZnvk0yQFpYgQZY4OQIsQck2+ntE2AvwQkSy5d+flPHH8JI9Pv8Grz9xAoDxS12GFBWS4esGGN8D9LsskoXysWlC1ObnlgzkZ7/r2kHl8lYHtoQc3MD/6HK64yuTmuyiKBqsyvLB6gQ8fP8ez+0/wzPRZnpu/yLJcvqQx9z82Ok6Hs90buHlwEzd0z3LaGXBzeIYzxQ7nvLOovoUadbheN0xna84NAkhS7NCjUR5VVeG5IX6vQ+t4yKZlOdsnkimt7hN0zzF3GkR+xI1dF0toqqpBRALPPynjOK07PDp4BR/ee5zfOvgUPzl6J2UhSfMS6QY0VkhkV9RBS7peM1+vqd0CP6upTExjtYRM2JuXnN0OqJGkbcNYt3hKgG1TZilfy64QYHHv4CauFxmyygiclt28wbKgpw2dZkg4GbNcXCQrE7J8TjcKfz+4NoamyVis9zFOhu8NCehjhE/lnajGW1ZBQhdlbKygxap7nEoKVjLBcv6oGdR/OnjJAfbdd9/Nb/zGb/wpNuXPUFU1TdUwntyEkBHCaUmEYJnOCPs+oe1TJSltXOJaLunAJ1hraBu0YzPLLDZkRb8taG1Nqlq0CrhWWVS0+HaIU5SMogpLecRehDQCR2qS1jAMB4RixaXDOZ6lcETAVq9HtrdLOAw5f+4MdabJTUrYH2BWMFvvUVVLwlvvpom+Rfu5ZzG3blN5uygnxN27jNldYj3wKgo/RBHjGoVq1gSJoVEjnhvkzGdHmLZlWK4omwJHePhdH6kUSVUSConQBtfrM5cN63aFX+8QWyFxuiRN1/QIMEYTrxOGI4Xb8+jYDoFrYWyL4nBOOavQRYEapgiviy8li4PL5LUL6RTjQuB62EaeUGKLAvU3/gZJmtEPbDarlIP4kL3rK5xsien3MXXNarrCCQdYWtF4EXYnpmP5LMuWeH6VRpxjbTuoYYBaXaebFLSWR5lWKGmdUPKcFpVKLLnCsQ2No3CSjNruszHaJGWJygqSdI0WDWeDDmHgMU0qUm3oGAONRlkWAgtPKsrlFOP62IM+wu1gwi62WVFWFbYbEkQu+brAqSMW1XXWyqdrW9j2iXrvKWdIPI+Jgy55kzMvFlhCoaRCaEiblNCKMElJgsO8lZxyBIMmxpiQqmhoTUEVrKk3+/QWK7wFrEcepl1RFJIw7OIPTpEv9/DPbrL4qz9K/t53Y335OTof/F2ij38S8T08j4XW8B8QXBvbprrzdua330rkBDTKpbjnPtqfeDfZU8/R+9pTqGeepv/Vp7Cef/4lHVO0LeIbz/yR+7W330r5jjew//Z3IW5/OX5dEgyHuIFNsVgQStCeQ2paIiFpdQbCxrnlDur39Gg/8juYJx8n+MV/RfPwY6y3ttm88RbazVdjm4R1GDJ1eliWjVICVbUss5ijRUxHWqx1ReYIpDOm23VpD5a4n/si4tnnUNrGdALUww9T3ns7qVCMhYUlPVQUYvkRajSiWu0T7qV0BiFiK6SaSvRsie3VLPIpYikZ7dxKPZti6YzUzwnsCFuNyMKWZVURen2UCqjnVznID4k2u4zdIaLRZNmcPDkicGy6apMj38PTijOuR2bWhHZNW7sEdkXueBzhI6dXMG2C+qvvpf037yP80IdYlDXhK15OXWao6QzvmWeptid0H3mYuhEoF9K8ZpmsGXQiAt+laRpQNv1gQJrHFDIgbBrapqYsVkhL0gqFpSVlvqaQFsrycYTGcSyKbIaybcLt86wu79Lmc4rtMb13vwv5T/+/cOY04u67qKXArxpa0yJtC9tyaMoSozWOFSIsgfhORtkej6lbjVVX2HVLw0m5kJQnbrq23aVpBE2bge2gqhLyBc7rXkvx7LepPvNZvJ/4c7+fxXZcDIbsmWdQQuDccguo39d8F0KglKJpGlzXRXa7+MsVm5bN0u9Rr6+yVjWdKGKnmtPSpw079Nr2xM1BG8qqQqQpsrZRbU3WHBA2PnXTMg4CMuEwTUt8YTPpR7SWwQkVnjHQesjMYW1W7Gyc/oPPmRR4gc1AeyyXLWVRYtmKOsnRlcYZ2BhhEN9Z3lJK4Qcui3mKbZVIO6Q/HLA4uoCpVjjaxbEMoWOxiFMaoTg3OMddyU1crPe5zJpXOGeJS/DDPk2TEc+v0ekHlNMYSyjo+riWIlKKvjegETapyOgJTeg3LJTDcj5j6Qucsk9odemc6eFUFTdmXW449+d4zwN/jSLb4xee+O/4F8//Csf5v09ZXRZL/tFX/nv+sfgnvPnsm/lLd/0Mt3sPUeQGX8NgOMH1DHU5Q1cuZWVjLAdbadKrh8TdHU73Nwhmu5ThJnllyPIpkRvSKJvUKIp8TZ4UmKDhOPM5HQ0JrYDV+iKu1cft+lSrFcmsQG2t0MamdaFcFUysLv5N57CUy7VFQlGVhIvrnL3pFNoOWDYt6XKBUxpKFXB9/jy6Srhv8ArCcYSwXFTl0kpN4DnUyZIkabBtj7oCTzREgSLNbRzZoz9OeJN6iF++8n5++8qX+PHzP0LbxMTCZqBOMtZ+v4+d5fhYdMKAdbIi9AxbGzuYOqZqa+wgwA8MQgfI1uBoTeBKpDkRKm2ygqKSILsYy+CVU7Ts0e1sEifH5PWCIG5xMk1tHeNJSZP1ybH43LUvULg2b7v1bdy1cysEY8pVy6xastQr+uMOfb//e2WVs2XBIknYsXJwh9S65WB6gXWW46kJUc+n11GIlcJKD5H6CBn16Do9Vo0kyhooi5P3gtfD0Ydgd2icLtY6wy0LasdhtV6QKwvPVtzXvYPfnX+E37z0FD985k3IvoWjFLdGPbJiRY38PTHTttWUqQZlM+jCqlrT2IrT3gCtExodI9sOrtMjDzp8afU1nv7cV/ni7ld5evoV4vqlUbtfClzlIjgpPfiTwsSfcK5/EzeHZ7kpOsft5+7hzOAsE3/CyNpEV9CrKuLpAYoazx5Dx6K2SuxegOu6WGnCap0j25S8iGlDha0sLFOSJ2ukZZGXBXWWEkY1WVaTzWMIJVPhsLl1G5Fc0Syv01YZedDFdQOqeB+Tws2DBzhbHvClvW+xYZ3nkTMPsH16gO2HzGY5ZVbR60fM9q5hhxGR6GKFe1xPCojOMbYCrhzs8XxbcWpzSM+2yLKUIAhoyoJr60MOyjkPbtxNHWck8S5dt+ZIamxvwCiICBobbcDuOdjeELuBVbZmWM2wrA7GVLRtTrqqyNICr9dltHMTMqtp8gx/OCY3MW26JGkFXjtAckQTgOt0GVUN1Ob7W8/8J4SXHGD/WXD9pw+lGlypsNw+uq4QXo9GdnHbnEiBEhVlckzZCtxOF0xBY7l0BAgbjv//7P15zG3rfd+HfZ5pzWtP73TGe86dL2deUiRFUgNFDZTk2bFjq27SpI5dJICbGKhdpED/CFr0nxZBC6QwqrhNBDhoXNexKVqUrHmgSEkUR0kcLu9w7rlneoc9r3k9Q/94LylSlCLJthBZ1Rd4gRfYe017P2uv5/f8voNRnLUj82SkouWR9QwyZaIVN+MIGSR1VOJDzdAPHMyuU5/eYX6Y0p0NLAeIJinjznNo4fpBSteOOAV5uUArRU3Ddr9nXpY403HWvkZpZkTxIc2734v+8D9Df/LLyO+dEssS94nfIMiU9u3PI4eWoT6nIiOLFsgs4yhJuLAdfneBu7jHy/oquTeEILliIurR0YyOzEM7DNhiyr1hS68cY9Mxyog8yvDNjkIVpLHg7uAw2ZQ8ATEEiEHGMcnRjHDvIRfrCqLA4cljBGHxyYx615K2Ow4PpyAk474jPswY2pbjMqXNM7brnvlsyixJuPfCbzE1mmxc4x7tGTqF1AmEFHM4xaSetnqEiyVJ5Ym6gcZvOEgTTJlS2wxRt3T9kvywxNsdmaoY2gGlLTt5mbE8mR1y0UVMA0Q4OuOIxz2yWDCONcJPKQzsupEUge4C3jv603PS1BDSlC6NSFOJjgJu8Ax1C3lGqlOMUAQ9UkrNy6NmEyquLw5QRjL6mn4/ECO5cnwV2Y0onyH1yCyacRjPWY9LVrZit6kwRxmzSUrhwHUN/X5DP3hascSbiOjWE6gvPUDdW1NnU/IkpshLknjBYZTwmks5ePKEuvsC3fkjJh94F6+++21c/T/9H5j9y5+HH/kR1Bd//2L2qxhuPUbzjreg3vUO0ne8g/H5d3N2/x71P/oR/L5l98Y3YL//A8Sj4+Q734N//3t4pel4OVU8t30Z/S9+FvHlLyBfeAHzqd9E7ra//0G/Du755+k+9Bd4+B3vQzyRMGTH5NkxpZLo2OCdpa5rtptzZmlO8Dm179ASqvNTlBe08hQhE/jWb0XdPIJf+QSTT36G5voFzckRRTmHvWWoN3QObh1dIY4U9X7DJjhuHx2Q7Ssuti068txY74g/9XnaL3wBEWnGp59APXOb6PZN5JXHUSpjcAGTZ4hdjR96CCt29ZbRd8ymR/ixZVZ7dke3UXpJX53Thgazeo3IVtiQ0+uYqh2ZTWZkOlCOA1tnqLRGJRGn4oDOrniiexWx9QipSCNDjaaqB2Q646LecDQ5xIgJ+AEdetz+Hsl0zuT6Lc42NfXGEaJAFI20f+FD8P/5lyQf/THWY0/51rdRfPxXsd4ivvcDFEdHDJ2n6y3LXYXwA/PpCUpJ+t6ilCJO5hR9xcq3OJnR1RVDtSbECUUxRbQNDzZnEJdcn2UM3Y4xiwnBosQUpzQiLRFDQ1dtOTk+Iv67f/fyfogMbhgwwEhARxFKKLquRukIiQAtvzZ+hDGoskC0Le3YEpU5SVl8wxjT+lKIYF1DiCL00KGOJ4jbt7Gf+zzh+74HUxZf62I7a+HOHZRS6Kef+aYxa4yhbVu898g4JqQJadMw5sf4OEOGgNCKMij66S2yxYLMXE4jQgh0mw1ZGkPfk0UT2rMXsYyExiL7gZOJZ9Qxk6lBJ5fdnUBgOtc0PqWrQTJQ7/dMyxni6z4PgDTRdGWKCSOOkeFiDTrC2g6qy0WCr/4FEdi2OxADh8SMmcGkBzTtAxJ9hW6z4Xx7FyFH8mvHjI3gL7/1b/DDX/p/8ZFXfoE3zp8gjC3EGYcnb+Hstc+xe+0L9PKYydVDBj2Sjx1WwFEc4+SEMWh2m7tM84joaMYrL34SZxZcLa7jRUw2xMSlJB73VKendL4ixPA33vQf87e+5T/nX7z0z/ivf/OH+eLFb37Td+OC46OvfpSPvvpR3n78PP/hW/9j/uqzf4H54hAhAmO8p9pe0O6XCB3xSI6MTpKalMn8ELu8T+IrdjInrGr0QnPWRmzcksEKTt2O0s15sD5npiNyKZHdQDVzaLehtg9pR82h8ow+ptqM5GmKLjRlvEClBUc6o5sZtqtXqNYPiWY3cecbzrcV1mkGBV9q7uDDwPM3nyc/KBmHgG8FfdOTRYEkUXjvGXrH6abFyh2LoEnaQEhT+sUxj9UVbyyO+cLZl/nSZMcbbzyBE4Hzi/sU2Rwigx4t9CNN29MozcQPyLGlrhuEbxC6IwodYfQob4mMINEKpAYZI4Nn8/Au7eENDmVFLwY23Z4Mycy07LpHNI8G8sVTDNmGxlmsmNCPAx9f/SbH88d41+PfDq5G9FtMMmWqch6tTqlGw2FpvnbfmBCIVAdFSlrkjM0Wq2KSaEKmHPNIk+QSa1KcnVKfv4KJYogPCcJRJga7XdMKSbA9IVji7ADijHm5QFXniN4SlwVbGRO7livFCXlzzCfOvsRbDt7MiTtBipxIjjiZ0NiR1DiUVIydQ0iQ2jDGO1I5Rw4Z49jzqPoKH73/S3zm7Et8ZvlpfmP1RWz41080uVZc48nJ49xOb/HGozdxs7jNkcyYecNRXnDz6tPYck7ve+6dvcj5+Vdotz3N8QGv7l7jY3d+gbecvJG3HL2BdveI4CXW7RmExwnJzeOneerKG9FWEpqRo+KYdnSkyYRECWLt2e4vON3c4zCaM4weVcTk8+uYeELTVMTZlLScIIQgljEuanFiwJWGkERIWTCXAjvsWV+c0jUjPYJpkuC8pwyWtRtRIiJPNVt5iGw2DOv77O5UpPGTbCykeU5dNfy5a9/OcnfOxx/+DO95/GkW82uXv3UTy6t3O7bDGlV35NEBWdbhVE2qZmRXn0G5nkQZ6tHBviFJDevVBh0CsYv51OrLKOBdj38LD5ev0jaPuHr4LJUdOZ4UzEWCEx6rHar3KKWJdIpFXi5QswEkhATbX2q85/NDojjCVntUGSN1RGIL9vtz2m5FenCFWJUsux0TL7lVJBj5/4cd7Fu3bv1RnsefAtAixegJLkhwA7VPkZEkSZNLJ9BgKWdXaILENjVS7Gn8npiUFMFhFHG/EmTtlgvt0VHO9TjiJM/wo6f3gmKSs9tWCNmixQGtNzzcLon1IWfVlgZBEUnmacIoA+N6zWQ6YXSe89U5zdggrIJREimHAIrZVQq9IPvO78K/8EXsC3cYv7VCbHa4F88Ybj/ByleUq5FeBKpME8UphMC4WWO6gZ2WmNNXOcimNFayF4ZXhWMXoLaGgpFEOdQ0h/2Gq9kJua2Z2hqdzrHLM7y8IMkSikTSDpoi7fBuZOwlUaIhjrHCo9SAEhFhTKmq+2w7kNJwcu2EVMDaV1S7FckiRxmDH0emSYHTI7vRU6YTYgz15AjnIN3syBcLut0KkUQU0YJ6rKiEIY480mlKNeLiKfVmjTEpq2YkFR7ciu7V11Cpw5QFTgT2o8SzY6Y0ox9Juo5ZrhCbPZEH6QPNekXjenI7kKQZbTfSWE8xWobtDtXV6PkJcuhJbUUewO23iKBoO0c2zTFKY3cD+ayg7TbYU4NLJK6/wBS3GD2sN+fkSUlSFlTjlnEUzNMp3nikh0k8Z7fZsRWWkhXX5yV+K+j6Dt/ep08CsoiZljPG288g5CdxL7+Cf+IZFvMFShmGzUikJDo1jDojCwlVeUJy5Qrm4ZLlqBn/3IfwH/o+3Oe+xOQnPkr5o/8U+XWZ4O7ggPCub6F9+nHqN76ZR0/cYKUiDg4kJ0e3ET7gX3oR9f/9CMUoufie72N427s5SD2x3SFFxmQ257Hg+c12z0tDzPHb3o7+7jdS3HoH9T7D/8bnUV/8OPFvfJ7005+D3/riN0Wjje96ntUPfID0z/27ZG98nmHZ0Z1+ktWouJEdM4sMSgoirdhcXFB1Fd4NKJHh2o4yhqE6JxIjKj1kMAaRx9iuo3jLWxne/jjyxz5B/PlXaH7kn5L+zf8FtcnQw5apXTIsR4YxYe0calJyZVbizs84/fgvsnh0D61jgtbINz+Dfee30F5J6c5PmaRHRFFJZgxCSBofmGQ51mZE8cDFq18i1Yp56mjw2GGKGQf6vMBLRd7fQ65qLppTDm7dBtEwlQtm6YzOXhAaifYDLtXc3W95WG+ZWUU07PHdEjW9hUxnxMslW9fy0AokkgMke+tJhhHdg5MpPk/phwvM6SkBTTV9jMT2FKlg95d/EPuPP4r88Z9AP3qIf+EFhrc8y9Hb3oqOI7quZ7PrsX1FpiPyYkIIAeccURSBNszjgmVV05iYpLvMXhbzBbPygPW9V1lWWx679QyTyYyzi9fYbR5SxIf4XmDxZAcT9nuP7TpMVxFMAl1g0AbZtshI48YebWL8MBK8x8QxjOGbCkqR5diqJTIJMo4R5ptTxi+LbIFzNWiNHhqi976T7s4dhl/6ZeI/+4OYOGZoW0Jw6Pv3kItDxOHV32VflzTxcRwvu9hFQdL3VE1Pnh8zVjXZ2IHI8eWMXP32+TrnLo0By5Juv8OkKYW4TrNcEssJQWuyvOBmUWKaGjuOOG+ROhClEcKmNH3PJJ/T25Z+32KiCJkoxOvHiZRESoExKRmO0cSoowNEFhFC+IY/dI8TnhBS3BAY9w1BZ3S0BLuFdiTOYHL7OfrtBlcPHM2v8Gef/bP8k9/8J/zoyz/DDxy/BRHNiOKcTE9YVXcZpgdMTc4oKry3jPtHTFTMICxNu0a1PWfjnn3zKjruODEBug4Rx6RhwG0tMoFpMzBsEuqZ4Hx0uEzxg0/8Ff6X7/yb/PNX/iU/8un/ip+787O/61zhs2ef4T/96b/N//nX/o/8p+/5O/ytd/wtJvGUOI6YHSy5c/4Sm92am8UBA5Zm7DHZhNBu8Eaj2oHlds1yUTIGz736Pj97/yc5yq/wrTe+l5cv7nJL2Eupkunp+x3BxujsiDiG84enqEExuX7IztVEOqJuHdO05FpZ8FK9heUZZQetFcxzw05HnLoVL/UXPJU9Rk/EeefIEoVTmmr7gElxjAoxiI7GxcR5zFgPyCYQ+0BcCtL5nJVteFf5HC+dfplffvhLPP3k8wQp6PanaCXQ0pMLixj3PLxoiCNLZlu6VYdSGcZI6nZHnE+wPkFoR5SnECcQAhAIFtquQa9foZgF0mjKvnUs64qjRUKub7BrG1RUkuQLhvpVmt0Fn774dSyWD938AGFXEbIYQYsINcFDliRgA10zIoVCCFC2I9XQ6xIxjmz2G4LVTCcHlGaHrUdcZBB6T5PE2FoyOTunpkRJTeIHmnrP3ucoe4EIjqAtQxiJRc96/RCEJL96m34v6KuOrMj4oP4AP/HyP+fT6y/zoWtvRCvNtluCiGnHHaMfmZk5rgdUYGd71rtX+NL6Z/nFl36VX334ce5Ur/6B5re/GyJpeGL2OE8tHuPW9BkW6gmei67w7MHjTMo5ygeclIypZ3fvnFRBuTjAL+9TNxvK6QIbFGWccPjYO0j28MXlQ37q/CWemD3Jv/fkv8/J/Bgl7iN3FWxH1OFVZHkFWRhssLxy/ysUoyDvOlwU01YbGEFkBi0LhIFeCaQWZNMFcX7A0LSoRJEUBUIInA8oBHlw7McBMzE4nZEoCaLFOYvIJ4TQMjKSTW4zzTPc9pywczwmJizGhDYy7PU19mPN+vxl9rMWWz4GYiTpd9yc3uTfe/6v88Mf/wf84xc+zN+78RSRioi0I5iKetVTDilSD2i9pfUTysUBQQYe9Z6bxye046WMdGohLwuGvEBL+I2LLzLROaXtuEvL8fFtSp+xEiOZSZD9iDrMQEn6tsN7RSQDnZd4ytfNAQ3tfqBtN0g9MpnM8G1LsA69mOOCpN0HXC8pjWTZNcyTlCJeoVbnREdPI6Nvfsb924o/GWnef1JgHSJovHO0ziFNjIkUfugwux1iVqAWMwoXqPuI2ClqvUeOnsHtWWjBuXFcaMFBVHKSRUglaXtLtRvwAvCeVeWIYkUyVMgkx3d75FxTypyka0hiQRAdzXlNIQN6sUALqMaKsiwpyyl9t0Glmtwd4h2MwZIVMeEHPkT33/w3yM+8gokMo5J0b3mWWTHh8OAEn8Rshg3CpGQ6Bbcmsz3V8SHi7JQDH5gcLNhbQWoU2/2eWT9wmAeiKGIdS+LecWPxNP35a1Trh+TZVXRnGZM95ZUnyc9XVDJmGBti0zN2Gmcdo+8JSlGczAmhxw01Z+cV22XHlcOY+VNPYzYVzeYh9eaCssqQcUrf1GhhmGaGnRScn56zKOfstGR7NiJUymJygNUWkY00/ZaqvYdiRqoTxjTCV1sSY+jrc4RUlPWePApUwRFcoNy1jNsNyjv2dcx0lmDEITUQJTmqKDk6uIZr9uz2HbIfqUPEuoXDqCAxsKm22HWLKeYkJycMXkFxqedWZoLSgmbTwCiwFyNKWlwQ9ENPLAaiYkJEYKjuUM0fxw0DEklRxAyyozaScehpxksDirbrqZwkuIhrV27g3BndsCHOplTLe4yjR2vDXE3I4jltmWGPj3F37qLrM+KoB5nTdA6hJLNJxv7iDidxjsmus686jEoZ9YJeCET1kOhNjzG+++9z7+//b/Cf+AXs5hHqDe8hfePzqKJBBYXfgdudE0UtIwOZ8OiX7zP86EdwMmP49/9DdicHPLU44ChK6fsL+npJbwyzIuNkc8rDqsJHgpvkaJHjtSS8+a3Ydz7LudtwMD0kWt6l/oWfQ758Tnl4SPjuD/Lw6jX87i5ZcYQfLPX+VTbWEpU3iLXCdi3SGHb7HevTR/RyYDqdsatadJ5x9WjORXcGKuOguI5IE3rbU1uPcAaTxsgf+l6yx+6x+x8+zPIf/NeI7/0Qi7e8AWk62nrH2YN7bLIp03ZL8/NfwP3sxyjaDf7adfT3fA/6TY8zdjXV2SnDxUPieEF5cgOdJoQQUEA3WAYBahxZ7R7Ri4KTg2P07py0GxiNo5AtF2c1TgWmWpFEOV2c0cQxMnQczVLwA4mIESJDdjuUHLnY7gmupyehkhlaxiT1FvY1VW0585b9gxXXdcx6+ZBaQFHdpwsx3uSIzOIfnMHZAyYHx7hR4GxErh1xvOfuD3yQ6h//M7Jf+RWcFvC9H6AsZwghaL2n63rU0JLoFJ0YrLWXXSRjQEpMnFNWe7bDBap3OJNc6pcHx6pvKMspuTRE0qAST9eMREGAs0SzmCjNoW+RKIa+JzYeEUla74heX50PWhDLiKFr0XGMDIKgBEIKgg9Y63GDx1mPxyDoiIr0a/Tx3wmtC0DgqCAI9K0T5MEM+8lfJ/7u7yJKUsa+R9QVYr1Cvut9IOU37ed30sSFlOjplOj8AisiFlGFaBrG7AYmioi/bh/jOCKlRGuNMgY7DBTTE+pqQ7+viZIc23VMDg4YtxsaNxK0QUceKRMkgkmWgDSoLFC5hpnX+NojjELECiEFsZLsdjWirRAhYNIIpb9xKmO9JTjLfD5nqiJiNaJFjcsDRmv6sSefJMTZDEfEGCRRUSKd41tvvpdP3vskn3j4Sd5a3OC6WODCmklxhe3RwLB9iLFHuETTiYB3ChPlJAFGqaiLKevVBhfNmB0mFCGlTW+jRkWjI2JhkQqG4x71cMOimRKnA+k0sKk927Hn/be/h/dfeQcv3fscP/yp/5Yff/TjtK77pu/r3u4uf++n/h7/xS/8F7z9+O2MzmJxtEON7VukFPTegRQEAqPtcd7h8YzeYQmE4OldRwiBzGRcLX6Ypw+e5Tkz5R3Hz3MrfyfSaUafEhcpu80e161ZPHaLUKSY3SXLzSLIBo92ksPpddbVi+zXr2IPDsiKA6SDr7z0q0yU4u2Hb2BQjra3yEgwJp7lusE+7HFtTxa32MKTRim18xxNFwhrGP1AYWP6VCBMylPR07wwnnKnf5lb0dNYM6OqVqT1BVmSMTpLv1+yWBT4MCJtIClndENP3+wRPmJwIzoSWGWxXYUPAdd3DPuG+OgqafeAIKeoxXXMRUTnH1H7kVl5E46WLPdbkuwaiAmn21f49Yef4OnpTZ5MH2MDTNqeaJIj+j113VKaDDOP6VyNbjTeOuRYk5QZ+wDtfsNY92hZUGaSuLdUbUXXluhJTVsPJGKB36ypxztMZ8f4cY/vRup6w0RvQU24X53yG7uX+crFZ3l5d4dOCsbfElgHtmmZZIpu8DzqHvJzj36Jn7r3c0yzGc73BKEZvaW3PTiBFJJtv+XTjz7FdvjDMbm+ihvFdd59/T286eAN3Eyu8dz0KnMzows9WV6yGmNoBCc6xduBqIvJipyV2yA2DTeKQ6YH1ykOc86UZdV3cP6Q/dASp5JE58TX5vzGCz9Ds1/zPU//ICq0aH+B0Qq7mCOkxu4qkiPAWfbbM9xrD0hNCdmUSWRYq4imBRMMQyQp44i2fYhKBLPsBG8ddugvnbDlJZe5HR1GCKaMrIJnhkf4jkg4WuvZNQErNEeLYw7sni5IUplzZixDLhEmY79rEAimQXCUH1Mow9K2pHbNPnFE2ZSL7Zp5mvL+29/Jrz/6BP/kN/8Zf+3N/w7nu1MSA7M443zXsw2PKBYzXDZHpYrtUGNUzDSNmEYR91XN+aNzpvMCm6T81vIrnO8e8f7pUzg7Mj28za2Tm6zuvkJiAybVCDci8MRphhtbhv2IFooQoBt6yjzHjo5m39PbhiQxpFmG39eIOGK0gqEbGaVDlAXaCegh1oLEBs5FQ6cVf3I8xP+0wP5jhWAtPkjqrkNoySRLWdc1UdcishSZXq6WKS2Iy4hhFeHThKAi8rigG1tupB0ueJSP2XQDSsWEoSf4QDmJcUPDwSRHB0kajRjpED5iq1qmBweYNexsTSAwC4L06jXIMnrRoztNoQqkbPH1yCgzShkxto5x0qNNBm9+E+OtW/C5zzEqyTA9Rr3pWzg6OUa/Ho2RktG5jpSETgzICGb5Vdy+YdivufrY44QR9oND65zCNgzVEhGXnI178ijierbg4UXF/nSHnlr0pKQ3PRhJogUtAk+C9RWRTtltG1RwZAbE9Ajf1SyXr1FtN2gXkedTjAGKQNwqtm3F/uFrmCPN0DtCX1EsbpJ7x7ZrsdmceLcncgO7+Yxit2V6dEKXjJxu1xg1p0yukmpwwP61O/TtGuMDQ5yQHy5IRkUnHCIRWD8wnNe0zY6gZsjDJ2izEhdJppEmuEDIDdZL9OgoZxlyhP3oqcNA0gfYjzQ+4yif452lWu5JJimRSegbSzqZkZUxcRboly2jklhnGasWxMg0mRDWO0YpWG9WeBs4muQYM0f6PUoNDL1hs28YqwqkgSjGGMW1gzltZVkPKzq946LbMDU5hYvQI6goR0WC/vgK9stfJL1/jjy5hYoUdvsIJSwz0fDa/S27g9uYMsLKgUm8oO879nvI8qvMb0zx4x6aDevvfg8SwbXj56i3O7AZ5eKIztZMbU8+EQx+Sv2Rj+J+82Wa2YyLv/yXOXjiOY6HLam6zD1V+gi8pa1OiZJj1PaMRAqK4xP6ZuD8YsuiXIAxaB0xDB3ras1sPqP94PvJvxVCMaeZ32DcnTGP5mgd8/DuF3i0OmcyOSIKktVyySKOUFJinUcYSVZOSFRBn3vikxP6yBD1S/bS46XCCEFqDC7P6OMEYS3D5pI+7/OC5iM/xuKnfhL58kvEf/ZDeHPApH7A9GO/THL3LsF72jRl/50f5P6b3k1zfEDWb4mlxhqBbCLMwYIQK3zwrLs1WmoSmdMFS9quOV/uScqSRATk7AZ6sAw6gOnQ1SO2dcfisdvoqyWLDhppSA+uYMaBwZ+iwwy7vYCxo8oPycpDnj5I2G9qds05Ro8MVcfm/JQ2zfBJzkmckkwy9ssNvloy2JheHzA5KikPZ5ed39tvhCsT/LLi3DeU86tMybk193zyr/0lzM/9DO7ajGs3jwlC0PQWJwVajthmJCmmKC3pugGl1Ne0zU5CJls2tcOnx8jMEMmEB49OUQpuX7+N6wPN7oJIKWx86doa60CUZAwB4jQjuIohionGER8Zxn4gjwwET9ASxsv8ZhMn+MrhJIzViLOXDrpKS6JUo8o5fr1CJvHv8eS4hNb5pUkZewgB85630X/kp+k/8SvEH/wusumU7kufw4eAfvq5/5H9aLquu6SJS4mMItI8p1ruQHRop3HlIdOv615fGtvYSxYAoKOIvqrQsqCYLKjrR5iQX5qt7fcMfYcTApMKdKRx7rJrsSgz1q3F+xhUTa8tKQmhd4TRI2IJfUvbNMjlFlVm9Os1Ql7GjBmjkUqxcxVKKqZZjhot3oBvBWEcSJKU0Qd8liGTY5rNGdKkJFGOGC7TB/7is9/P//VXX+DDd3+Zv3WUEh/HmOOrZMbQNp9nf3Gf+PohtRSQTDDxHFFfYF3gAlhMc1pVIroltquQxrI4PsT3YJsB2j0mNrTCMp7fh8mC7KpEqJoH65pKF0wN3Dp4gv/92/4u//nz/zt+fPkT/PBv/T+4t7v3Td9ZNVR87N7H/kDzjP8x7IYdu9UX+PLqC/wLgC/8t/DzIBBcSa9yq7jN7fQmzxzc5Dme49rhUzw7eZqq7xGFIZUGoQS5zmizjKapqboz0tkxgZEvnn+RG9kh33ryDH0Y8dYSnGAWW7qiYP+gQamIiyoQsWOiOxyQFiXKRzjRo7RCtCtSHN82ewcvLX+KD7/wL/nP3nWbq6lg02SsAowkbBlofMXDRlHmB4h2oAkZlRM0foJuE2QUIU2C1ynBWmgahBeo+YJZDm4Do7OIuka4hiw22EHT5Z7Z1RP6V+9yfnbOfDbjV85/jaHf8l0nf42tMYi8oN6s0VYQtGFo75NHj1Hmczb95vK5v2yItceYnNW+JW+34GPS1JDbnsEk6KOA3RVUYsCVASOvUQ0pvq3Zjvf5tc3LfOrsFT716DO8tnuJF6qXWf8hTcS+sPxmWcK/KpRQvGH6JO+/+g7ef+uDPH/wTiZmQnY4w/cDom8oYknIDjhfvYQdFFQDEzESyRlNNeIyy3m1Br9jkU5YXL3FOEpc13E4OeS1YeBuveSwk0QeyAoejhd8rnmJ6/qI56MTpNqzsorj2S2E3yKPEkLXMp6dE7Rkd36XaIT09k30/BAczJxnJR3bwROUIJWSYMArgQuSsalRxlxS9F9HNzqi4JBS8EB1yK5hmkzog6apQeuYicpJYwHjwCNSLjY9p9uOWVYQJxoTZ8jzM3xV0weLNAWtiLmWewiXruO26pAq8Lbb7+K17Sv88p2PM0umPKmvcWimRGlPbbY0NnBmZ+hS4oKg0D1ZPKMFpgIWWcq5VgzNSL9f84sv/wKi3fPtb3gb0cFt8te/wy6KmTYeHQIulsi+J+Q5xTRjX3c0+xad5zT9pR5+aB193yOkJY8z1OgYeotTGQwOKyw1HpmVlLoj9TPs2SmqE9gk8GB7j8V88buOqX8b8acF9h8jqLKkjfZo23M4mzC2DWNVM58W6DgjdJbgAkIJojwiqRJWXU0ne+ZigjUZZZ5R7XviRJGlFi1igtDEuUEpaAZHUU7oqh6nFXKoaI3GhRETOYpyimkd9W7P1iW0Mqbd7VCJoNQTNvs1eQbBRIztQOwiVCzw2uKDR9qB6NvfSXvnKxAU43d+P7PDo68V1wCFKVjaJef7U1pfMyvnDNZwalK6scc1NVenc17qanAwX0xxDx6yY6BKeg7SklmZsYsiNncqFocl0dGUfn/B6GoiYxBDj5rMccMZo9iTFhF+11Ptz8kmV+m14mz7Km7bkB9dJcqh2e+II0GaGHZZRJBTzBATwp62viAqC5w1TGPDppX4TjCbaB45w0aMFHpLFyRu6EmjOenk4LKbUxwiW4kfOiZXrvHIjggvGUdBkWd0piEXEtu/hpCa3MXsL9YMuWNyWKLKmFCPhNEzyhidFmgGSh1oO8vq7D5H5RHxYsY4BsbB4a1lqBrm8ymRiWj7PWPdECUpKhFIo+iDw+56jFR4nWPGmKtDxWY74ezOimmZQVTgNw1SZ5i+YrNZYaMF26riaD4lhEBuDLmRNCGQdD2DN9ReMQl7bDfBbxwjFUoo7NEc5y3TzpFcuUK97RmGFhF2lDgYYvq+53hWs2EDsgAZoycNNh4QWUJqZkTuCnG1RpsYHWsSIxm3GctlR+gDhU7Y9Wcc/eTHcV/+MtujQ85+4M8wP5yTek+RFQy+vRyzQpKVV3D+Ho/u/DreeY5mN0inc6TdMuwbtnFJOU0RNjDND3iw/AoPx57F7HGKaGBsOtZVQ6hWkE5Ynm64++ABk0zw2MkJa2tAaNR0AnZES4GZpOhhpPGObD5nkcRsrcPbQGRyKlczd4bgBuI0RqUTdJQynp1ysXyF8eZ13A/9EMOvfZL4hRdof/j/SaMj9HaP1oH4LW9kd3CAOyi5cnKC6Peo8xWLeY4tjtm7q9Tb+zQ4bNtAsAgckXdEwhO6nmXb0jnJkRZ4Z4gXc3ANyeqUKmhccRU7bpHdnnSSIKWg2AwkU4MNe2S3QUvHoFKaMKetIspUwtAxw7LaWy6wSGHITq4ziVukS8iKKwyuQk3hMEkJ4QqyFahiQndRgdOkj90gmhR4saPZPeC02xBNctyw4+pVxaO/+udQbuTpzFC35+x6QRaljHJANmCuJgBfKwy9t1i7IzCS6JzcCcZIE0eGphrohy3HRwviZIo3lu3qHGE11seoWIEbCNbRSnHpYj10NMB0OqEeLaEfMFLi/SVjwzUDSqUMlWPc98jMoGNJlGm0loiv06KJg4Pfs3v9Dc8Q9XrsF3vkW59B/uzHsB/7GPG3fxvSGPxLLyCk/l3111/FV2OKvr5gTiclpt7j9zEhLjHZ6/TH1/FVFsDXIo5MRC8EdhxIszldvsLVLaiIbrNmaFvEZIKOIQSFtRDHEVorJilsmoAgprENcRKjtCEMjm5TI/qOLEi8SQnzA0Yp8M7hW3dpttjvGf3ANJnQ9T3aCbJCImpHFAZUaRAo2kFggiVg0dGMKC4I+wrb7jkpZnzXre/lZ774E3xcfJYP3XwcL9UlW+naLer7ryI3MWpeoKUmNGs2mzNGaZiWBRJHsR8Y1JStyjkSlnFYkmQHFJND9ktDf36K7AWjUTTnjy41rocJaqiYpBnz+RUerC19dMZ1rvIfvfl/zf/2g3+f//7z/z3/5a/+l3zu7HN/sInFvwEEAg/bBzxsH/ArAHeBz/z261fzazy5eIo3HD3LcXZM4TTCOYp4ytiOzIcLRjewrJd8x633M51MqNoe5Rq6AWqhWA6aNAyUcc6+8eR1RZNsEMUBW6+JlUALSd2vOd/f5Xx3jo1ytOv52Ms/yVeWn+fm5IDd2LDqKiKTU6qSo1BwMr3GY9zg0BkORoFJcg7TI+rWMkkNJ/MS2bZ4NyAmCTLLoKsQvkcdP45dnlJd3EfGE7S/RpnF1KpFacN8MuH0wZo7y1e5s73LdTMnL4+IJxOUEHRJgm8a6lTilSB3AwZDrGLaoSJRPTLKWW8GhnZDohVeGRauZT9IxkghRODUPeBTL32Wh/YVvrK6yxfWL/Di+kss/wjip/6wyFTKuxZv5/23v50PPPvdvOX4nYwX95n3a9ThbVZ7R2xiDtIFzbhF65E4neCM4Xh+lbvLjrG9y3SmMTEIrdgMG2IPsY9gXuLk5Rytsxsmk5QkzVjul7g8RigYNw3/7MWPEMaG73v8zzAtp0TxhIswsmw2zFNDUA41u2Qz1dIy9IFyfp2oPAAHwkji3DAPgVc3DeO+I01a5vmUQUZcbB9RiIx0MvnatQ/W43wg7jcEuaMLFbbPKGJJ30smcUmsIgJgZA3q8rfn1XbkuJzy1NEMNY7Y7Z4xSrEHU9iekdg9sj+jlTdw4hqiWkHjMfkJkxDxvY/9AP/Di/9vfuyLH2Whp8xCDP0OISO8WLD98lc4mMZcLWcU2pFlRzifcmhSksFTKUttcvr793j53ud4ZvIYTzz5Ll7crDjMS6quRjlFuThEy5ama/DeMw4DRVkyX5Q8WJ8ytAONVvTtSFO3CBVQCkwU0a0rrDAYrRmEZ7XriCLD4STFu55dvWKnepI0ZWzO2HV36a4+QxIn/9MN5n+D+NMC+48Rht6xbweuLySJ9yzbmjjPiMvyUlfWC8LoEEojlCApIuJ1RNXtWTiHjiIIFjKFCAExeoKQaKMwkaKrK4SUKAxxKujtgLMRG1VxReYIBlxUkPicSHUUJ0f0KTTtQGEOECGwbWs6V9L4gXHtKaOILBF0o2PrLph6i372OfSb30Hz8Izone8gi77RElAKSSQjXtq8zEl5hcPpgrsPV6TpDOvOGHdbonLCNAhsZEiMx6U5Z6/HYZXFMaEfKIVnLSW9PqRUApSg77ek0RzTNYxeUqY5zvXEcaDfn0E8UlWeVd8j3IhWExbljMOjq4yjIngwcUQqHmGTiCg6QIsS242sVy8TyyPkEFEGTzMv6MJAUdUMhyV39ueUOuGgnKH1hGEYLjWNUjG9/RQhcKmx3Ne4/RadZGgCbbDsa8fQ1hw//hSpnnJx5yHteg3GUcUgx4AcJD4KpOUhvlkiV/eZ1IIHNnDKyPF0isihbS1SWKKjlOgoQyuNWQ8M6xqjI4TSmKmherQHpYhSQ61HEj0hVTuq5Bqrs/tczyWtkShbE4WEtEtw9QXCV2T1SK1aYiOYTyNsVWOHNU0zABHH82NKPTKKjO3QMvc7ksjQXb+CzEr03ddozlu2pw1iHImyhmhxyCwz1HFEdJQg1gNdvyP2gcwIahHYbB6wmB2g9IRyekwIjmFYYuKcME9pzypKCf58RfaRD8N+oPmWtzG+702YbY04fwB+YL6YsW5X9F1FmswgmTFahW0qsjy6nGBR0NJxKGtGBZVziMEzj2OiSHG6rbgyNfRRxHrVsF3dYTEJ9EJwtl1zMLvCYzczzDRmu5YkWlO3HYwdSaTRNmBbx3iYcpxnpErSjgPnduR4dkhvR5q+IfEWlcVYQMiEdH6Ten0HrWaY1PDogx9kuPUE2S/8DKHrCe9+D7zvnVTCs7t/hzx2zFRJMDvGviNTE6RoiWlZEuF9oO1XoBJyM6F3jqq5jxwVF6NjKgbkMMVMZqjIQVuTYHm4T6hcyfxGhp+k6GGNZYt0Df0Ln0YsEuLDJ/Ftz7Zf0vlAtG6Q85gwTckPJiwd2H6NTj3DZMpMzClqR5Za1q1lTEoSBE3lSMqETDmsbQnlhNEb7G5AhJij9Bqn9iGP1g+JQ8Ni8QTddqQNDmFOaLoWIztCWBKGDdJr0BLnHN57oGMce4SQaDFFS0OuVwzaYMeIenfOJNNMyyOEEPjQkOQF9RLG0DM9OkCsOprtjm5SMjEKl+dcbHe4MqerOiJj8NYyBqjWFfmYYKaG4DxRZojnyTcU1V+PP0hx/VVcFtkCm4B479vw//KXGH71VzDvez/+5ZeRhyeI2ez33P6rNO+vL7CllOTzA7b9BpEvKH4HJXscR5RSX4vvFEKgTYQdBpKiJCqnuHaFc5Kxa7HOkuUJyjiG8ZI98NVjxVqRRp62j/BioBoqZskMi8WpkbjMSfY1HJeYwxIfwIeAD4HO9tBYEjHHiAhPS7fpMK2gaQfYbBDziljP2XePqHLH0SRCqgiTpti2Yawv0MWE7zl8D5/LP8PP7r7EO6v7TJMpEHE0v4Hdbag3j8jSG2gEm+0FTRQxW1xFipG79Y45AS2m7MyA0BrhPV23Jp5qpidz9uNAu29QkYG2Ru5bkqMFpAaaFWmek48jS5Ww9ZbSWboR/tLTf4nvf/L7+ZX7v8w//PQP82Mv/+S/dm7wvy4e1g94WD/gY6/94u/73n/48o+Q6ZRJNGFqcibJnDxZoImYUjBJF2z6ir67YO3PaLDsuopNv2bbb37vaz3/w51zolPm0YKjZMbV/ITD7JCj4oSj9IAjWXCkEt585W088dT7CHHOcDFgRI3XEVlZ4B3UY40JilmU8KP3P4roB545/gDEgono8SqjTVLGYWC3XpJMjzBjIDQ7yqKkWp7RSwfFFbrTDWboWOmUojnjZ7af5+Pbz/Dpi8/wxeUXOGv+kBf4R4hr+RXed/M9vOPqu3l7dpvHmmvMHnsjZSpIpgVbqYmLBjGuGatzRJghpcSOA2FoUEpAVODcHikjdts9OPBBgG8xC01+ETg5uMaoUzo7sFst6ZoeOTTsxy1icci1+Cr7/gH4mBfPX+Kl1Zd5/uQNvOnx5xm8YBZHLNqKVb1HyJRCC4yO8a2l3S7RXpMdHiBTA1+X4JAi0JFku2npRM9sfoLxin2/Yijir1HDAeq+w/VL6LfUsaAdJFFIKH1OEqXoWGI7T5JpxqbhrIez1pNlKc+dzDFdx7irgYRoUVCkBn2tZPfal5ieB2TjmR9dRZEyS0Z82OFtwsH8Kv+zJ/8qv7D+BHW1oW7OaVxDS0JtaqrGcq/yfDlJSKOAEILBRUAg7gYGGah0wLQNkZe855kPUDlLADKTsFyfkhFhpinGxAyPevq6QmYZNk2ZTHLWZUG1qaiUYLerGboRlRhE1xMawSgd0fGcTsJm36B1YFIIGl/RVkuGfQfFEdPpAZNNyXb7AEn4n2RM/1HgTwvsP0bYNQOSkUkA2yfYLGNaXsY4CCEQkST0nhAFhBTISJEnCct+R7tvSK8WjONIlCqUCOxXFqMD6YnCe3eZ62pSRAhEWUy/6mhljpJ7ChoGCloakkGBmRHNMvb9ksOi4LBIGccNhV6w7xyuH8nzHKUE4zgwuJ6m39DnV5Bpjvp3/l2sdcyK5Jsmh6MfabqKCE0UpTjvkBomxQG7cce2WuHPJ+RJjs4Vvl0xCMWQCDKbY/YtTVOTL6aUQ8dmuWN+cosoruiqU3JdEHlLP46obE6SeIIPqLAkXZyw9xPEvmbcCsziiMP5AaJqSGYzxhGGIUZaTd/XhMkhJs3IzWOc3vsctnmNTN+kmOWYLGe5aQiqZd+vSVBkjGTTCcbMaNuWrutIkgT1ege/tg7vLHkUoSOFH1pUECxP7zFLc4rZMcEBiwPSqCIdHbJucEnK+bpGGUXsNKwHqCxpapjKGRddg58KpmnKw9Mdw3aknCeAQ0YxJk2wY09vNiitGLYdwgi0LmnaPXaSosMABIoio64TgkwgS6hpsG6PnudciW+y73a4doAxI/IDqgxYWVHHFh/nFMKhD66yCJ4QxZyfPuLi0cscHh3Rp0ckVx9jfOVV6FqIPWVeExUZqrhG0S/Z+cCyCkTRNYbcMW5r4iTiMElZ7lY07lWSJEXLHGt3IARCTmmbNaUMqFdeYvjRf4ocWuy3fRvZO99OJxvEBPqtp1idw3yBSS4z5GPbsVm+xHDecTg/BjNQqRbZj3gRMfgtBzm0kWHZdzxabvFxQIuEi0f3OFpcxU4mFGONjCWrekuhC65OC7KiYN93KGEZxsvFnjE2RMKinaA2CWlkyF4vLjLXIaVg1CUJLdV+iwoakWb0FjbNwE4uGOQpM9kSkgJnPa/dvMFjf/NvE1C4TCMZ8J0nXRywuHlC/GiL3V5wIUs25ohJ5JCuo8gyqmZFWJ5x49rzFHFCU6849xH3u5HdcEbODBcKTNQihhHijJAa1veWhEnGrZM5OxTDfI5ev4afNrjdlvCwgc1DujSjGgNFOqIPZoisZDCajTZoU7PYeMQCGuno3Zy0BCFrbJQRacXYdPhxRCUSsXdERYo5XhCUYRwc/WAZq5EkctQ+pfeSw0wQ2YS6crywbCiVYp5NWfY9rtaXMWjVOXKQjLYn8yVapUiREVoHGFolsI3AqJFEVpSTI7TO8L7H+w5CiYkDse1pxz0HkznLzRYbtaTxhJAkrKqazXZP3Q5EKqYbBlyq8MNIMT8kn6b4ekQY+XsW1/8qUCoFBPZbvwX7i59g/LmfQT1+BVYb5Hvf8ftu/ztp4gBpEtMcPY6ODOnXnav3/rdN4r5+H1FEV13S1eN4Spvs0KOhrypMOUEnAucuNcxZFn/Dc6KMNYP1WJcyiIZ9vYVdjZIKFVp8BHr6umRKgELgvGMMDfO8YBpPL885S9majuMyonFTmvsW9IYoM2irWI1Lxn3CrcPjy4UTbfHrGlyKMRF/5R0/xD/4lX/AP3vpp/nr8QmmuIbWmtnRbc5f+wLD5gwVAjaOmR0+RqokzbAnCgFrNCYULFRDL0YgR/mRYawwoieLwTzzJM3pEsNIJifIh1uyGycE6WmrM/KuYS4zln2Nqzc0wnF9kpCnOe+9/W1818338tLyRX7t4gtU3RI3WowqMf2AjBJUkjMiuHN6n2MdcUunrLRDjT04y08tf5mT4gp/6dm/gdIJp+MDXnj4WX7qxZ/jy/u79K5m0/+raW7/x9DYlsa2PAL4N7/7PxA62/LQ3udhc5/Pr37r93zfjeIa77n6Lt41eQvvPXiGx7OrjKGgNCV9O7LzNWfuNe6sXuKN+ZOczJ/EOof3DVpeSoK2UtA3FYvDq4jBEuotMo6IrWAVPCyX3Nl8ih+/98v88r2P8ZubT/+umvs/LFKdcmv+BG88fAOLdAZDT7dfo3SGF4YuzvGjI5Zw1rzE6f6UZw7fwLXJdXASJSVSKEYGtJbcHg/5rtvfyXPPfgt9f87Fdkm07kjnh7TTnKbucHWHKwom+QS3yxjaPXE+geAZuw76GjVfEKTE9R0XFy3Vds/JyS3GUBGGh+RmQcgmyGxKWcTUrz5AlTHHV6+wPn2NTdsSndbEIqPdr7h31vDju1/BTOZ8z7N/FjMEqmpPPZ0SRwX5Zk3re8ZkIB9i2FoG6TCHC+JFgTDf6EfROY/2jknc02IYbUToaybplEFDMzYkKsa5mqbdIPuKCthJxSJZQF+CNUQTxdh7pBbsh4rtrmKvplwvMqLU0KzWmLqDKMPMS6JUI6XAjZoh1RRHV1lXI8npBXISkRw/Qaju01ePEDPBweQK/8H0r+Crh/j2jKG4RpUc0k5TwqNTQtfQFzFJJiCs6H3MRd2j1udUsmele+QwMInnvO/J9/Kw2pDoiL4f8O1Imi5QqUYaRXpwwLDf0a/XxJMJxhimiyl11fPaecNUbiiSHGsdthkweQqTlAvb0fQN+IYySxmCwKDJR8O0SGln11FCML36GJP5waUB8p8Q/GmB/ccIi2nMeH+PcCX9vESZiPTrTGSEUZcF9ugvDV+0JIsS1omhrhsSd0nR896jlcMYjTKSvrEgehACyeV2hEAnDYHAxEzo+zMy7+iqLV2jSCcH1DQEH5jEBeO4RUpDlk252N5DWbh2dcLYOmxTEauRzSQnyjIipbFOEqcxsf7G7rX1lm2/JVjLtckNBuHZNTvyImXsIN1nbPYVkdpzsJgipKfbDlRYXBRTRlOS9UBvHeb6MXNGTl9bUVWOLDumaZcMbkmkcrq+Y/QZSZQwdmusd7TkJMrSu4qlTyizCD09BNvit1ui+RylMrplwm61opl1lFGBlBptjxiq+4SDh4T4WbQyTLOYV/qBettx8/YzSE7Ztw3HqSZJErqu+4buzL7rUCEwn83oupZubBj2LW3Xcev2swil6O0IUlIezQlVj7QD9a5GK4O0gdXDMyaThPTJZ/Db+5ReMEQxy+0FWXIdvKV3gaMkwVlLGB0SiSo0fb/FhJLgA2kZM9QVy+oMkx1gRKDpLVliuXLlgKaCZN+zVyODWnHt4GniLGb7oKY2PTcLje5G6v0FLjO0HczTiFwnOD1hGHfMpUIWBef1hoe76rILfHKL9rW7dHdfopoUHCws8fQmzmqMFIRmZNsonrh6xLpfUeOZ5HN0nqFExKrbUbZn+PoFIp1QFjfYjhZvciZf/k3WH/5RGhWR/M9/iNmbn8BWktXqjCGTHN2cEe/O2Z9doK8/Rh8aVt4SzpbkQWIWKTq9RVvv2LXnzKMFTa+YjhV5OUVOE164c492V3ElP2F0NbUAryQqFpxePGCS3+QwPyBOR4LJCaNAhRV9sySNS6zS1PvL/0ccR+byHgkhUPc1idbsHEhi2vaCjW+Zzg8YhWfZjxR5xHxyhOkrMttxcnSF++s9wyjBaAoNeZSxH/dkZUQqAsiR+PgWptd0Z/eIXUbMBHM1pduDGk9R9QXCOTLgJD6h3n2ZPT3nPiEZN2QiJ02mBJGwak8JwnE4TZEqIrIDrTIsDq4zrF9Dxwl6kdFv9mzqmrScYhJNokde8x2Jy8irlklwPIhAe8U1E7N3gkprXLQgRDDpttS9JEiP6Sp8XGCyEplcUsiUkSjd03c12sdob8AVbCvNlVTR7TdUneRwNsUFD0GSuil2MiEAbXNKFBsElwuZvh0RSGQWYVzKMDSXspfEUBSHhBAY7R43KoKNyOca2VmW9QVjMcGpGDn0eGvRxhDFCdvzDRZFngaSMqGVHVmIyaYFBCCEr7lk/5uEUgnkJ9j3vRv307/I8JGPgFSYp5/9fbf93WjisZREcUym5DcUw99gEvf1xzcGhLg0BIpL2ihCAsniADMtEcJhrXpdO/2N2wohKI1kvRnp2y1NtWaRHRBNZ4g4xkQR4ncU9LthB0AZlb99DlKABGcDeVngZ8cMVUU8iXls9hzp+Yu8ultymh1w3QQ8A6JyYDzqeM5z8oDnr72TT7/2q3z24ad59xNTICbPJ1STK7j+jJAmTA9vk0c5w7Ckd4EDPFszYcBwRRU045JOAIMgo8S3S4IYODMNP7/9JZ5wc2aP30Rc1NjTc2aLA2y1IfIdN+Jr3FM7dLflbBwZXMmNecYYRibZglvTm9ycXKdtapSaMUkLZNOwzwu2o0XS87C4RzqMHFhHdViSVxv+xau/yNXoMf6Tt/5Vbh4+xTBEpOnbMEfv4j975j/i//LSh7l//0t8R/E+spMpL1Uv80p/j/PqIXc3L3O3epXT+vQPOhz/rcW96gH3vvJh/ikfBmAWTXn/zffznbc/wDsP382Tiyf453d/EjUMfP+bP8iQzVnuG07iAR+WROkBj4Il1oZkDIh8iq0rvvSlX+DH7v4aP332CX797FdZ9+t/5XOMZcTt4hZvmz3F0ydv5Yp5iu949ltReUplR56aHOGCQ64e0KwrrJXE05vcyyfENmCHmmvTjv/bx//vaBXxN5//X6H6iFgbBBKTSjYXr9BuGp5+6p1oYdjUDeO4pVQzssUBUZmwHC31riZPUuI4pVYZwe5IZE9vY3zfIEVAJBOaZsPq/IyzNUznMw6nOZtmxFWaVHdwdJW+6/BhwESKIBI6W3PhKtLJgmltGesLclXyi81XeGRXfOjoe0mSA5z3DE6wvXfK9Pp1tMmQyz3jBC66FcanDCYlHiTBKobOopREvm40uR8G/LDn+tSwGSY8PF+ziAfSaYkb95xdfIUcg5WGrReUNhAXUyItODFTNu1AJ6EM0DpHJwLd+oIIQ6kycg/9wxUb7zmeT0lnBer1It97i/V7rMxJ0gw7nqNUSiQCw25NVl4HAd3ulCYeSHyErB/h8gUbUaLjhFkUk+URnUyIpwucUUixYJpqdnvNTp5SFDF5BFVcUuZTBI5mtBwmU6rtnjRSqCRBvv5sMpOSZLFge/8+/XZ7mTKBJNICjabqeibRhHrYMdo958QMtiJCEitHkU2Z5lOMMtj1GqdyQqFIhKD1gd57apUwDwH5h2Bs/XHGnxbYf4wQqj3R2CEXj9NHMZHgGwaakAJhJGFw8HqBHSlFFMfYdk+360hnKYFAtVkSZQn5JKXdd9TrmixPEQowkqYecYlmJgSDTbBB4y9eI4mOaKaaLnJYP1JGBYL6kvKnp3T9iPOBLElQWhBCy9DWMJuQlQWj78mjAiG+eWg579j0G4IPlzqWYsJFs6Iea64Wcy7cgLIFjhqocbYnBI/zIw0B6RxR3ZNnM/w0ZexbIqOIjGe3qbmSTTHpFYb6IcJvUDamt54iBPp6ReUiUm2I+1P2tSWbzpkuYlxQoHNUv4ftFjWbMb12yGa1ZLvcEgdF01QkokAlE6zY0fgVkY3pxJ5iMsE6w65peOygoOotm7ZmnhV47+n7HiklIQSarmeepRhjsLbGDjXNak1SThHFHIDWBrQU5FlEOwbWg0DokblwaCmo0oJ9mmOVQjNB2yXXDq7y2m7Po/UaFQJpkdD3gBjxOFCgjEMOMSLEFLNDdBShw5qRCjlEeHeB9z0pAyIzrIdLY65kMSNEA61dY3xOaj1NH5DxkvhwRtVb6rYmCpaDk2MEEdU4MAoDu1OyfMHh9Tdw7/4rbDfndNdOmCpH9slfxT//BO7qUzRqyna7pt039H6gC3DkGnb1hrXdEFpNqUqCCrSA8Anp5Ca1iSGUDG1P8os/zf6Tn6WfFegf+iHK+XWUaGCa4KuIvu8x6UB2cJ3+4h727IJxYtC9pdCHSPUQHQSmvMLEp6x3d8HvECpmW9UcTh1+rMBdkKsFUXnCrltS7VcUKmGvRvKgOaYgKIdJI1obsDYQmZJYXiCUxbV72iARUU4iLnORl4NlDIFt1xDFGZGUtC6QhYggKkoVaIRiYTTHJkLIGU44ZNujxobDeclqd9llKGOFUzGhf0Cegho6XJSg80NSa6nWjuG8Qo8t3Y05UX5IREqPIItyRqvpuzWpGHhSTNmwoU2OWMkpxirEbsu5dcznBXMNnRdkBGrn6KKU9OgGQhiEjNnOGrj7KqZpaZiwNz1uGDhOJEnnqLyFNCayCfSemQYSTeU8sRTEzrELCmcb4uARZYTQl8X1pbHWHk9LmufEImKQZ6Qiou0swU2IXUuRKOKoQ/iWuUkRDKgDj4sirL3O7GCOlPbSuE816KJEm4hST1ktz3CuopxcQ8oYa/fYwRLGCVFyKb3RZs6227DcLyFaUChxSaUrJ2inCCYmm8SkbiDJEzabJXlSIqXC9w4QoP9oJhRKxaTf8T1UH/sk4wsvIlSMfvLx33e7340mDnAYffPv+jiOaK2/1un+Kr6eJp6lGSafY/tTivkVZCbox4oQcuL4t82Cwjji+4Ew9MjRErU9VWVRWYG/Mkdnv7sBTj3WjH5kHs+R4rfPQ0uJUJemggZBPJnQ7yK6/QXp8U2SfMJ1K6n2K+60jzgguZxsJgni9ev588/8AL/16Av8xL1f5flrT0E5RSrFZHKVXe2YLI7I4gnW7hlcj7cjpYypyHFaglMkg8GowFnwbPctuh/46MOf5/OrLxGC5Av7kVvXbxPNryF2K6JuR+9H8rgkyECaF9BecDV4WmE47yz9WOP6y9zZ3f4hWqacHC+wQ08tFCKKKLylb/fcODji9O5dHtBwVCv2yvPKcMFz02e5xhV00PhI0O3OkXYkKY/5wRsf4h+++iU+UX+Wv3P8n/Cum2+jy2HXB7pdyxOzE2Qs+ewrn2C5v8Od3T1e3L7ELvTsfcdpc8GmXVEPe9bd+t84jd1IwzSacJAdMtcFiUx50JwzyQ5465W34ceGjp5lu+Rsf8p5e8F5c87ox3+t426GLT/20kf5sZc+CkCsEhbRnHeUz/ES5zyX3WR5f8uZ23BQxATrqceeXjn+u8/+d/z8xa/x86/+PHf2f/h4KyMNT82f5lb2NG+eXeNN02d4+9HbSCUIf5WTJGbrK6zKidKU1+wFV7MrHKQH7OpzzrslMpphsAwhUGhFEQnu7BpcOeF7n/pufuKFn+KL5y/ylsM3MmBJTYTcVSRtTFtqtv2eaZ/Th5bYe5SO0GVJrBVdmfDyviLfN9h4gtOaKCoRoQYXY9sWE8fs6ob9+sFloZ/nBC0Zux0n2tAdvpFaXJB1p/RNipCHzA6mPHpwn9XDNSQRdJ56dymBbHXMb/pXyLIJb7j2PD6JaZ2ln09pxg736B7R0SFjrFF7h4wVw8QTW0ksEoSQjL1j8CMhWCyWs2pLIrYQlUzUnnv1BVJk6N4jugFcoDOC9a7DeMFiMmPMc8auY+4Ug1GsekvfWbrRov3A3I00ZoZsexIG4tSwLXPaJEJLUEAIHms3WC+Q5hDXnmGCJylTSFNs1eL2LXG6IO5GBttcSuRkzDJeoHRKkado4TDCEfKCLDKMHpqQsG4qZD9QSccBkIYIl0yorMeNFQoFg4DQk+clQgjk17GVsmvXaFcrqocPkVFOsIo0MyxUwmAHKlGx7E5x48hxWnB9tkD7AB7yPEdKiasqwjCiZwdY9kRYzi103lP8jobcv+340wL7jxFkJJFlgUsnWB8o1DcPNhFJwugutdhGISNFMmaM8RY/DIx9/HrUiyVOc6QUKO1QRuBbyaACanTsnCNNI0plWC439FtHrnuyxQQH+OBIXQq2BmKMmRM8bHZ70jRhkhb0uwsSHDKeMwRNqlP6vqd3PYn+RpMCHzyb110tc2KCciAkiUgIcaAbG+woUGlKHgy1sOTVHhnH1HZg9COqcpR6gT6ao1LD2HU01Y5IOrq2oqmyyyiYaIZRp8h2iXWHtEPNZlNhihNmsuHBvmH0MYtZQjmJiXPJ2MGoMmRTIcQWPZlQTBKWuzMiL1BSk09irMipQkzXbdn5Pbo45okrNzmPt9x5eJ/D6QGzdMa23bHTMWUc45yjbVuGEJBaU7zefZOhpe8acCN5eUznPQYYnKdMDfjADk/oAycnczSXmcuLJKHuLctVi5IzTrIG3W85yie8fH7OJJqxOJxTbRqkt7jMInKLQJBPTxBCXer1AS8CUVFgG400OfM8JU4MPtIovcUKR2RrrA1cbL5CyQmTIqHfSIa+RpucoGL86YrMTIjVBIxAr9e0rmJkwMQT4tSwvzMhqXuSqzHDNEN96bMkL36K6Cfn+MUxIs3wWYI4ztjKZ3k1y4m9IcomBBRTM0UrzcSuaDzM5lfZDDsena8o/sXP0L/yIly/ivnBb2NxdcrYDHTrHj/TiHJO1GxwuiXoKWlxRF/tSEIJ9QipROYFUuf4eoWiYFIe0+5PKUxKtWpR8SNqt6Mocw6zW+yNxNkJ43BB61oK4bh29QbdqSeetDh5QF1fLk6pIJmWh2x3S6xrcLMb1D4wTTMuuo48duQEhLTM8pI4idiMlioIVJRw2u0oohkHiQEXUDrBmwyfemS1Jr82x40WKQVRmrNaLjFuTRxdB6kRRYlUCTqsEGXJaFNW7RlJ27CQkjoYetsyjpaxHem7M2Q3skiuYCYxW6tIrWNoRh42HUujeC5NiMNA4wPWBxIcjVNkUYESgvVocUqQz6Zc7AfiSKBMyfGwRb/0Iu08YTg4Zt7G2NbRCsv0YCTVObGUKMFlBq6zOCNQOkKIgJAG7yzWbS9znfUEkRiapsMYQ5pn5EXHth7RMuLQzFnva0TomPgdbtgyyW4i5RRrLUanMHqEjAiZxYuecVwhhCKIliiJiZMF3g+MQ40bEqLYEKWXj08hBNPJAfeWpyR1TX48Zxxa9sstWqfkhxOwPSpIrB1x3pHll13WYD3i67R/fxSQxRzz7m9l/PgvIQ6vIKbTP9B2Wmv6vv8GmvjvxFfp4Unyu5vSXNLEe7xzJMmUvTzFj3uCj7FWYbRBOodrGsIwEJy/XEiOIkSSYLQkiRNCrOjDyOhGjPrGbvfgBuqxpjDFN72mpEAogbMBnCfOMnQyY9zfY5xfMgtmx0+Qbk85u3+f7WSBOFxQjAPBWoTWTLIZ33njA/zYqz/Nz736cf58dogur2Niw4THSOOIEBzOtXTOEzmLM3NSYchiRdNZ4lqTMZIYxY/+5kf4yv6LiDThuaM3cqs85MOf/XF+4rWf5M889x8ghhlDfYavz9A3nkIdTEnHLecyMBsa0s7TDIqdgHboOU5KppNrKJNxPgSaVUUWRxwhWfc1w9BzXJS85GtULElCwY89/DhRpPmLb/uLhLpn2KzxUYTr9rRDiZU90zbwfbe/n48++jk+/MKH+Tvv+9vsVE01nGHShGXjSIaRt6dPkWcnZG/8M6AipICdlzwIPTIMfPrOr/GJe5/mL7zhB3lSHfDCw1/nES06ymn6hvvnDxmCZe9b1mJ9mRNsMpQ0lP6AEzXl5DDnMDkhq2rmynJy9V2kUc5GwJXD68T7Hb4d+cgrP8eHX/lZ3lK+k7defTtvuP0G5lGMWu7xdcV2WPHw/GX2LnDXdkQHirN6xfn+NS6q+2xCy3m/5dH2EXf3r/6BnLh71/GwfciPtQ/5sX/+c2iheXbyLM8v3sy7rr2Tz59+ll+8+HW+snnhD3TffT3eNH+O9568k/eWb+Btjz3Hm574Tmo9pX60J6/v0gSBGzz7sGZmJKOMqEdJlu5o2pEknnCUXhpypa5D+4ROBVQRU3cjpRtRiSaPBKd7+PYnPsDHXv5lPvHqL/OO+fO4YaReP0J5R7I4JmtabNdzobdYI0mGCArztZi81GhkHlF3HeXOIJOCOAQGv4P+jKZXmMUV/H5Dkhhcr2mbnknQzExCUk7JipKHG8tq92UKvyUaFJt75zzarJDRIU9OTrA2ZlcEnLzgF1/+aVCOP//cnyeKQUjLNC9QScI6MoiLC8a6wTlHs2nQaYsVgrZfcf1khhOXcjm8BK/Ztx3jsOUgifBjQd90JC5nu5Jor5lPZ1yd3WBvG3o3kK/XdK3lIuwZGgORRWjB3YuaKxquzmImkWLsE4yFRewx5RSZ52TA1jo21hF7Txp2iBBATkD2DKNllqUo7ZAioisCPkpRWBISqgGcjNgpRZyVTKOcXgnisQUliJP8Up7oPEVIuOg3NLtHTJIDXAB0SSEEQ3DcqRpynzD6lixXSJl+0+++lJL0ylV2X3yR/YMzjp68weg0kyih6hUhSQgPHDenJ1y/dhPvL+e+aXq5L9/3+LpBFTkyzrB9TWU7Wh8zV5KF+ZNVkv7Jupp/yyEEkGZ0ASQQ/y6aPKEkKIkfPMpcdrFjEdNKhZY9bswJwWESgTaG4D12GMizDKxmcJ6LZY+eRMwiTWgaonag1jFMC3A1ZXyIF5K+2iJkwJgpBEldtYxh4HA6I+pb2m6Hnx5jVEK725I7iFVMPdbfUGCHEC5p4QSmZkK/rzDxpVt0bGKU0Gy2e5QuUMcTyvsbVqFjbCuiKKKu96gQcPGU8uAIlV5OokySkElBGz2iaTY0w4JUaXxUotMesT/FNmvW3YhAs8gNY1uz7gNxFJFm2eVnKEfSIqNvBWMIjKs1otqjowi5WaKmEWUxQ65PsSqFSFPX9xDJwFF5gziOuXa04PTiNe6d7XjrE1eZ2CW7Zo0sDsjSlKZpGJwnS1OMFHjbUW0viHSEmpQgInrnkaNHCoHUsNr3RFlEZAWh98jpb3+mJkBpNL2ClTtm0rxKkhm0s1Su52oMrVbUm5o075EMKFWg9TfqW7qhJy9THtzdMU0tZZHSyQwc5HlAJlcI9YpMRJxvX8Al9ziePUmc5XgjqZo1k2zGkJUoU1wWKl4QDVv2ITBkc5wdWDoYveF4OidLPdWf+4vw6GWKsUNXAn//jMW9OyxkQIwtrf4sPsuJrh7TXTuimhasnnakhzOi0BOSCbveM5xV8CP/CF/tSd77bYTv/HaQHUlSoEPDarmibTfI+Q1uTOd07oxG75jMD4iDRbQOqyS9rui9Is+uwX4Hds28mLJ0PUP1kHHTsCoiogVMzVU2PWgET89LzqRF92uOkwLMFfBnCD9cehU4R6IVxhjKKGZzcYaLPYO1OB1TGoPqO2YCnG0xUmKiSyfoSfCX5iCiwDnHjJ4kyi4lH7FBSkPIJvj9ElOvyPM5Uil67wirO2STDBVPwVswE0TvEPQYGdP6Fj8tmBTXiYeRYX9Bbyuq/j4G6Ks1sTnCHF7j+jSlOT/n9PSc40mBTiIOpAKl2A8jXd/jRODA+0szOOtQQtD7gLSWUy8xBwdcCT3VMJJOZoy7PfVmRRpr8tltVtsNboCwaAlheikV6HrGfYcSYNMYLxQiljjX4+oKmZjLCDlpCNoxDiNJkmLxTKIIrQSJSpjPEi6Wa9wQsDuDtxlCRoxuixARQzVghECmETJKgRLnerxvmM6mKH3JyOn7C/pGEMcZcfaNj85Ep/g0RQ49tm6RSULfbCgWEYPS0I6oKKLpa3QUEeuE4C+LPpI/+sdw8h0fwH3q8+jn3vQH3uarOmzn3O9ZYI/jiBDimyjeX4UyBiElduiJ4gQZF/T1EhFyQmfQETghEVohksvIJPH6vtr9DqkUR4cF29bRj3t2csciWXxtQcIHz27YEcmIzPzuCapKy0upjAtII8gWV1jefYV6+4ggYxQQecvBwRP0RtEOW2znmDQx6WSBUoq3HLyVL+y+wscvXuRtF1/g8WSKNhlj57CDB1kxeIsfBzKVsBUJsVFkRnPhA51K+Mydj/ELy89y79E9To5u89ff8Vd5y/GzDMOOlx68zJdXL3J1/au8/+iD9PWOofJszraki2OqVtFqjfIjB2ZEmYSZKrB4EhMR6xQbKSZ4FrFCT3I6aznb79BDILSvUofAgTnixe6Mu5vX+LZbz3NlfoQzPf3qNdxmzWi3bNoRrOEgMzyh38a36JovPPoUP/PKL/K9b/5u7u3vUcaaeNPxaLVDZ4rCaEYCyfQqox3Zbs9Ixy3j0PG5R79BnpW87/H30W1OeWr9LI9PMvJZwGwky+mUbBwoDue4Q0VqUjrXsek2UE1JekGS7vCuo15/hvnRNUw2pwoRcewZw3jpOty0fNv1b+Wn7vwSX774HM8fv5nt5gxvDXKzI0cQSsPJ9WdIq47j5ApPPn4FV+8ZdhuC8kSzE1QUsbn/EhE1X9xU/NLDX+NTu0/x8Xsf4+7+myPSfidssPzW9rf4re1v8Y9e+ce//432dbg5ucm3nryHd115Lz/w9Ae5mZXgY0QlGPev0l2c0qaeeebxTU4kPMvxEZ2MGe2eJgIbx0yynO1+x34YEemM/bAl9OfEck4ae5ZRjB96oqphTA2Hk4xXV4J9p3jvwbv5yFd+hl9+8eP8wK13ISYFwyRhVw1sqx1qPmFjT3G15yQYyH67EdSHwHGR0YwbltuK41mOikfEbkfoloz+kFgnpKmk6jqWbU3US47ymCSLUVHALl8jq/fss4Swu6C6qHjVTpCzWzxxdJM8Sgm9Jct7fuPRhs+tvsAzx0/wfc99B6t2RdNtWOQZRZkgY01uIAmBIBVrf5/ebmi3A8u9YxulGJWg4wipBF44Wj8yn8YsptewnaTfVUzLFBqobEzmDDQCP8To2hKpjDYElqdryuIYOzFEOCLtKCYxR0cT7Pohu6qlLBOigzny9QaHAhZG0zrPut+ydx2LZM44QNd1iChhajRj6DAomuAYZUAUM7JIYV65Q43CTEpOioL9IFFKIOoWFaeoxOBsIMkM1b6FocNbi5GCMUrppSYZPakeMR76Dta654k8JvQK+TuYVePgCCrDlAXB1tBUaKVIpCIvjtjuaxbSc3LlGCEur+GrEqDgHH63Q8YRMs+xPrByAu97jqP8T5C12W/jTwvsP06IS3wy0HpPpvXv2dWQkcK3I8F5UIJIKQIRzjfEyRHjMKJjhRCaoe0u41OEQRaaphsZQiC3gXG1QdiRYnHEtpP0wWKcJ4QWTUxtG4riCCkjunqkGVuSTJOOPcIPqHxBHzRJZmh3gqHryfKMdb+mdz2xir9WXFtvmSUzwmAhBByXhbdREb691L+oxBJ0QZHnbPY9LRZbrenrBjM7ICrnJPk3ZsGaKKY4PKa58ypNuydVJS4KiPIIc77E9UuCilikOVoMPKwtoxcskoQsidAmJoQBRIYynp6R1gbEviU/mJLme7waiJSl3taMswWd2yMoOFxkEDYMQ4IxU64eZtw77bi/bbg5mVA2a/Zdg0xzsiyjHkbi1yeq7f4hdW8p4xwfG/ogaJuBXgimkWHXWwRwkEf0NjDWI9EkQgiBs56xc+SFYRopdp1i107h7JSFmlFHgVXbkStJYwON3VKK4msRPl9FsAODdwiZgehJkbhgLnXYRUaIArEu2PY1fj8ySR5nMHua0dNZRXqQoMeOcd8T54ekcUrPQFJXaCdAZVygSLqGZu+YKcXJras0Z+egMtI3v5X5tVsEn0Hw+HqFXz6ge/EriIsOd3pOenZB/ughpt0j5c/jhac6PGa8cpNdNkF/5teZ+J7wgx9EvO87aPd7snSCyKaYdIbcdawfnpHEO46PMi72iu32nPRoQnIwQbYjQkv+f+z9WbCmW3rXif3W+I7fvPfO8UxVpRJSCQkJIbUKSQgJTQiEGzA0QzQQgfuiHe0mwvjKN76zI9y+aBO+cASB3dHQbbrbDA2ikUACDZQAqdBQpalKNZ0hT2bu6ZvecU2+eHfmOVknT9UpAW6Vup6bjNzDt7/hfdda/+f5D0McGPWCbgiMo6FSHer6IcickM/Jsj3Xh4fo6hRtMgwD836iNNU5RFPgTIU7SvRcM/rJUbqY1WilyPKcuDsgy5woSw5jA9qQ6znWaFLw+LFF6Qwpb5Zl55BSMWjLXEOIHekJPToohFBgJCHP0GNPVnmiELSPX0dLT7Z6HyI4yOcIqQntlA0sRs/BDdzanCJyiypnqB76XYMuLkkmx9sV89VLmCpHC8mJKPjssINwJGQbXs4yailobcWw3fNIGFLXM88Ldm0PUiKVmjKmheKFeYFSFfHhI8TVOe3JjEyfUIeetH2D6IBkcfsRa1u0rQjHI75p0Ksl4AjGEqUjjo9QdobRq6durvImqqnUJR0NLkmUcAgEo99izY5oa/RRo2dzgp/THa+Q6cix65mfrTDmregVpTKUytB6Dki8P9I3I1ovySvzjrU5Co1Shry29E2HCJDPSmIYKaMipDTR/4IjryqkkCQ/MVKE/nevv/78Eus11f/+ryCq6j3/jpQSpRTOuXcF0N77KSnhXfYqIQTKGPw4YosSW58wNDvYteTVKWY2Q2QZ4m2u5Ckl+uOBGALFbI7SmjIKxm7SYLa+pTLT69gPk+56ns2f+/cBtBQEIUg3+eJZXZPknKvLS7L6Frp5gM1zNvdeYd/09IdzUnjM7vwz+NyQy5IkBP/hB/4wf/1X/iv+3mc+wn+6uE+++mp0puibFmEaBiImemJ+SoqSyiq0FJwfXuXv/Po/4PLyN1kWJf/hK3+ID77yYeaLO4wxolTFD37V9/LgFx7yP33in/By/buolCCoGf3Bkd58yHxRYza3sc0b5Fxh52u6mFNbTylztseBLCXmOoJR6FmJ8EdWuSD6hv14JM/vMZLzjx7+A2KQfHj9zcSxQ84WqMeS3BY0V485xgOzcT7Fn0nL933VD9D25/zE536S+yf3WWdz2u05aRhZVhWhVJxTs/IB7Qf2SRPyklIGXn38KS6bN/nu29+DG1qOCGazUyqpeNwfOO7epL51i+G8R/gBq5cMYaBzHToZqqxgzED5SPP4k5C2JPtVBFMT+4EqqxjDSDQ1XXNkzHO+/X3fw0ce/Aw/9ekf449tvxW7uoUvl1xIiZsL7hYrLj/5CUrh8IctVvQ4W03Ro0PP6I7Q71BZzdcUJ3z9h78ZhyfPMl578Gv8o1/7MX7swUf4ld0v8ZnjZ9/z/fS8WmVLft/yQ3zXve/g+7/pT1IOik0qcKvbzAtN7fZQnRCX0D5o2QWHOzRIvyWkmqEdiDqCn9HGx+y7wK3yFD2U7NtHZM6RVreJsaE9HJF2TlVmHG2NipccLy6R1YxZtUaHnk984pLfpb+enzX/in+z+1l+sP4Q5eIOebBY2zEUAxqPFSWH9oKHDKz8ltA+xqiCvYd1lhNF4igip2QQR+Q4EoSlXM6o65pufIPH5w+wR8NcF9RlgdSBbr8lRFisb2F9ySeOR9oQWFRL1rMz5rMMJRRSJBrn+Rdv/gxozbff+QOEceR0dsob/g3O9+fcXd/FCIErSvLDASEsxa0a0Z2gdwlZecI45/BYMCsEJpM0fiT4hmpR0B2vOVxeorOcejNnflZwfgj0WlBlCu8DlfXMZ3P2YaDvO5ZZRDNgusAm14g8h+OO3eNL7OKU+vbZU+nJ28syspIDvZpxjJqL7TU2BebzDbN44Gq4RskRFRRD7IlhRr5as/Ge3eUVy5MTpLKMwjFLcYr2rE/AKPzoSCQ62aB6yR2rGVWkSQUyRKyDg2+onJ5kS3niyhvKEMmUfromj53HjxFbWDZ3z7i6OKc7HlEyoI2iyBT94z1ZYdDzFcNNNnae56SUCLvd5AM1n9OHyM5PU/m5atFacu0jY4zYd2nmfjnWVwD2b7MaE4jEM+Zmn1/CSOgFaQjI0pBpiVQ5g7um0iA1hCAhCdzQo4VFSMkgoPOBk2WG2h9oe0dxuiSbVxSppWmuWGQ5PkVGt0epEmsrxt7jRk/SjlkKiBChWJFJQ9M0xBRuqIA95XyGkYbWtWQqYz/ucdGxyBbT14cGoTTeB5TQjH1Aa8W6WrC7+Vkxq6iPBw4xorsdVmeockZel5jnHEbz1ZLZ5SW7oaERkhhgnGlsuUS6KW/ROkc/Wo4eijwnHyMyz9E6o2svETFBStjcULx4m3HX43cHTDJ019f0TaQNiaNoybVlcWeDUAkpW8bxghgdVTVnPdM0+y2X2S1ObU4Yj+yVJRlNEpJMSmK3Y7ffkdsZmQBRbxBd4nLXQFlQyClaba4kMkFWG9rW41qPKTRD65FaYG8mX8vScu1Oubx4iNUDm0XB9dBhnEaZwO7QsdrceccheHA9YwQfA1UWUVFwHAXKKMq8xHmHERGM5rjfcWvzEk1QHHeXDHhOiwqt73O43kNxTV1s8LsLnJSI5R3aiyu6EHlfHpEHKBcZ9WaBaxxc7JEhJwwZWiWEDERl0ffvoes17bajK+bExZLZeOT4iY+RHrxGfuiJ1w3hV34FEyIyy5n9mf+Y8X332e4uiT6ytmcAhBiR8xn9dmQlZwiTs64C4/ljto9+jVsnvwtlEwmHNBV1tmBoIi46Dsc98niJmWWU6zu0u8TFxSeobcYLWUMlYegSwecorUmmJvie2Hm0gZ3TiK7DzGtsUUDb0acRuajYXieEjZxaD6lHW0twDu86svItoHDse1xmuGUsEYVPnqM/Uuia6KdGmxCSlFv8CGpsaQdHcAOz+QlaShASbEWKgRB6lC4YujfQKmM2OyUx4lVEVTPC/oQhGxmUxBZzTJ6htcQde3TyzJYrHruWQh+o5eSMP7cVedeSxsi2C6S847qbAPadWY0bPeu8pLKanfMIJeiKyUymMjPk/JTQX2LZEZLHXylGLpHrDHd+gcgsMddkLjEWkSH0ZCFHywU44Kbf5sP02FoYjDS4FFEkvN/SjobaLohscPGK1a2KWFnysED0ka5t2B925LHD5jXGVE/vFSEUMXrawwFBQTErnuv2PTVFc0TsSUETXE+5WBDGBF2LVJIYAhiF1dOTTi6CFP9O3cO/UH2haK53K6014ziSUnrH+hFCeK57+Dsew9iJ5eA9eV7hl3eQOqecL587GR/ahuAc+Q24BqgzzegzDoOjkQ2ZyhjDyBhHltnyGd3155cUU8SebhOeSc7gilPay9/Eux2+LMlmp+TtpCWnOEUkjdm9Tnf5KvtiAwLuz8/4zpd+P//s0z/Bz77+83xHviAr7+LGjq71uNSxKWoOKSPTkt1wzT/4jX/Mxx/9KgOCb7z1rfzR5Qcobr3Cdd/Ttz2vSUWZEp2b8Qde+X7+5sf/Nn/v1/87/vJLf4LZ3TO64BjbnlwIzN0zpIHj49/kxJ2T5JLeeWY2skiCdAx0oUUISNuOy+ECcTxwPFxi7C3eX97hJ85/it245TtufRv7q8jod5hKQW9gONA3lrOv2iDIOb+8Rqw0msSf/Zo/wX/5sb/O3/z5/5r/3Yf+HAtheE1veTE/YX16i8dty6PdBa18jJjdxgrPGCIf2z/AZDVfM3+R/eXnmM3uMLu95Pipz0zyonlFFK8zhBkxOiySIQXGOJLHirqwHEn48wRXD5GnBaJ6kbZpMFmOQtH5lkO3RwpJLz3f/IEPI5pLfubhL/L33MhffOXPce/sHo+3VzgCF0OkV4ZF2OGOEXt6gskLxs7hQ0d39Vn0CNvRUZcNeXEL3zr222sMG7578318S/lN/Mrx4/zc4WO8VG94NF7xMxe/xC88+gVCCu96LRY655vX38S3b76N737f93AvLqnqGfdvz4ki5439A/xCk9clQ7el1haUQSqwiwV+f85sVqGbEbcLDNePuZaeLj4gXxfMkyLXgn3fEfMFm1oiXYcUR7oWlnliMCWLbEZmDZ95/Ev0D/akkxUnCF4/OvxZxR/+qm/jv3/tx/iJR7/MD81fIvYOnSSFiJijZSFqVjrjaBMxONzQ0qjEIQSU3zOEA15KHg9wdjwSpUXaFbNa0rWv8fj8U+htxro+Q56s0Kdrum4g2pw8M+jQcj46HqYCnRu+4WyNbxu6gyITAt8Hfv7Rv+az15/hm8++nrurF3jjwWNun21YZXMe7h7x+PohRbWmFYJaa9z2HHNaImYv08THbIRA5jU7FxmMZBxHzndbBB45QjdssVnOfH6CEBHEkUo6Lg6BZrSULpHJkWuR89ntkdXJKbetpr26hmS4s1lydbnl0u2QVcXq3r3nrvUxOrzfo1XJyszYtz3DMNLXBZUpUL5HJoihI9cztuOewY1kSVOtN5iiJCtLrnbDFMM7dmgpUTYHPaVTXDVblBUsUgJRkNUlMcLV4JHe07kRQk61ECwKRRMt2xCQKTHzgaENpJTISo22Ci3mmN2WHpiFAP4I1RKGZooVFhLnpgQdKSVhvyd5j16tOMZEc+OxMtcF3ndoPEpIhpiwv3Pw9VcA9m+niiHQOsdSCMwXOXQJq0hDIMWEtBqrS8bhkjC2YCJSatzQk2LCKEOygn3vsDFS9i0il4T5Gh8lqXFUeUXb7nDOY4oFHokxOTEkXB8IakS7PbmsoViBnqh1xhjGcSSrMg4XPX70lKZkN+zY9lvGOLLIFlg1md3EEIhKEb1ACom2kqzUCGEYwsBxbBiLirnJ2YaBKGBW1rSZpXoX+36d5WRFTikMXgHHjoPwrKsV8uoRZnBgBNtW4FWilDnKt8QQ6A4dzvVkxYyiWiJvdO8ms3QS1P7A4WLLpRzo5hmV0pzNz1CVodvvEalGShjHR2g1Y7bYoLZX7I8NZl6xVI7gDxzkAgFkcWS3Oycoy0luGUfIrKUykvbxHhfhXp2xKi3x6EgxojKNziTjcSQydRPz8q1D7cQEEMxXd/DNFWPXYQQcpMSanr4X9E5QPjv8ZxgH+iCx0pHLkZgqrC6R+uYxpaHrjlTGcqgrfD9QlSeM6Uiej1RmQUwzqpXmuv00onmDTFfsRYHTkqwqibsj3a4npcBsfYIQAruYMVvfwkiNCgljYOhGCAEJ2HJGON9h15bRSNL6lKr4Gq7fv2Rz/3djshL6nubBQ+Jqga7mmJC43J0z9gOp8UQrGP3I3kns3FIp6H1OsZixkIaLRx/juH2NShX4NIJVJCcZrztMGrEiweYWIjZcbi841KeUu3NK7whqhl4sGHYDXitUoYluTxwEybV0aoByRt42KOdRoyN6z7HQdA48gXv5itM8sB/35Loi+JGUPPqG5tr5wLEbqOYzZsKwFZFeVPThgKRHe4s0BoRDZCVxOBBkRpM0Su0xmUXEAOVyWltiCyLR+QHpI8tqOZnc5BmHfYMQmsVmQRO3CCWY5zXaSEI70nc9ts6oHAyPI3cXkV23ZbXYIJVCFwUnvuU6JPQwsDQGRSIfR5oYmdVTBFO32zG6I9WtUxaihO2RsG9x+YrsRBDHI94ZhusrRC8IfYs4uQXDkVRETF4R3QrlBISRNEqSnRytvffYzJDiJFM5uiO51FNsmSyY5QuGQ+LCj4hySQyBTEiKTYWZl3jnCOPIsd+h9IEsr7B5hZSK9nBNDILZYoF6jtt3TIkhJpY2Z3c4okxOWWe4vicrS4a2JaWIEBJhFVpqUkqkkBC/zU8TxhiGYZi06p83xX5CD9f6Cx8j3qKJj9iiQGczrLXPBddj1+KHgayu0Z/39+a5xvmCdtyh1R4fPaUusepZgJ9SYgwRFxKjjxx6x34IaBnJo6bMDYvbt+jSFpVVqNVtkAUuRDoXSAJ2siaFJaujY9c/JkbBbBR83we+m1969DF+/I2P83UnH2Clc0yeOIyJdBhw+S0a1/NvXv0I/+rBv8IFz4dOP8R3vvwHaS56Lt78HLO149AcycaeVJZcHa4RLvLy5iW+4+xDfPTRL/Cz2U/xQy/9MURo6XZbpJozPrqmuL1hzFcc96+RrSoeHwbKvKOqSoQSxJ1HreZcpy1KtgQBg8y5bc4QWeIXLj7KIq/5oQ99P93jc0RzJDg4eoFrNVqVED1BdKRywdliweg8chD84dNv5W/+2n/P3/30P+R/8/v+Aq83l+zFwGmCF5Zz3gieq/05hX8TrSNte+BTh1e5NXuRrDyhymqWGtx4oG1abK04eeEDnF99kl5JhmQpxwEUpJiwZGirKH3P40efI7M5abVmSA4BiDjFhbquQZqCcrWi37/J7XrDH/+aHyaul/zk6x/lv/n1f8h/svhLyOS5bUu2nUcr8P7AhV+hUk6eT07SQ3tF9/gSETawVvThCnluIFuy7QaaAW699AL6Uxd89PyXefHOB/mrX/NHUaVFbN7Hmw/f4J9/6qf5F7uf52df/xne2L/Gndkd/sgH/wjfkP1u7soNL5/eAl/Rtm+CsJzeewXikfHxG1TVgjCviO6IdwOxWPPkLgnlHH/9kLy9Qi9uEYbHdPrA5ZsHqixHru6xLDPOTk941A1w0WGLOd1wjhA9IhUkERhkxsxF0qioRE27v+A4u+LW5gzbjBzwfMPJy3zk+g7/4vVf5MNnH2Zhl0TtEKUnyBq/PzArFuR5QS8OuGOLyZbclhrRtUhZUwxbDv0DXksC2XZkeUZwLS4J0r5gtX4ZeXqCyTO6dookKwwof+T1tuH1QfPi5iWk39MVBabv2L/xOdYn9+i848ff+CkyZfnB9303m1nJo/NrXn/9Tc5Ol1TCcnH9iGU7MNgK1Q/E3UMyc4quLaIoqDYnmBhJ13uOnSOlkUEH5qamRyNtQTVboAYFAyAAL0kHRzO0GN1zlRL7/UCmGu4aRQoCKQPCdehH17QDKAsvnZxMiQafVylFnN8hhEbrGSlGxuOBlTWkqsIjuEgaZIbzLfXsjG27oxs76lCgtCKvJzPdo4tkFvAj1prpDwM9LW3fcUuVKDUwFrfxIbApA/sh8qnjjhNVIK0ltx6jDcuQIbXnOHr2fWBlNVVtnjqKyzyfmKbDgKgr4uOHHLlGCkc2X9P3PUoprLXEriN2PWJWc42YPIaUpLoxNPNBkdJIJkv6GJnxO8fo7CsA+7dRDX3H4XhgZg1DLNHWovTzqXnCyAlgu4Cwitxm7I+aOBxBWyQGNwxoYRBKsk0Rf2xZpxFR5ajFYupyjYGh8yQvUTqnHVqWMQEFAqZpqUqE8RG5kMjyBPRbB5osyyYjJzNNYrpjx2w9QwnFGEdmdkamJmTnhh4fI8FLtFSYSpMVb12Cta25Hs85RM/dmaXaJ2JMqEKjipzsOaZvT0qXFdmxQa5OSCqxu7qi3GyQMZLGls6c0kePtBpxfcSHDhNrimqBKRNK6afgGiZqY3m6gH7k+tcfs9cti5PbnBanmCJDKElWlAxtgy4qYrxESocykJc5ITQ0rkCqkmU8ch1GpDKMx2sOPjAvS0QCTIk2lotmJCaJCR6lb3LPlSD5BBmY2uKve/wYyCvzjLOjc47gA0V9SlZA0xzpmyPdLCBzhe4Fu2NPYd+itqYY2XU9UhTocUtIkWK2Ji9L2nYyBJFA2+y5tbxHyizt9TVLUTCvNwiXE12N0pKsLMkOkeFwSTq9Reskaui5u6r4zW3D/ugwpacwGu8iUkjW77895bEXZtq4UjfFZFiFyQp0LsEkglX0bqAycJ3PaOLIkhJnMw737gHQpohRCfKMPNMcU8MizBkOPX3jmRc5pYj43jMoyXxxm8N45OL4GF+sSYBwkjAEUsqZbc4wIkPVlu048PDBJ1HDNferM7wPXJ4/oDQWlSTjbkD5iKdn7CLJ7xm1JjeabL1GNR3e7TjOSy6jR0XFrbqkVJqZqWhC4OCPZH5EpISxJePNZ2MFLIqcOMICSdSKZrQoOkRUqKgRskdlM8Z4xW5IxBioZZhAjylA28mJP3T0IhJbR21qyDPGlBBJEUfQWaTOavpji1EGowzCTQYlotSUVcmb1y2ZVCxtRWwP7N2epV0hy5Ki67loO5xI3Lt7m2EYuLzao5Smyiz9sWHXbKnmOYtihVWWaDKG184ZjnvqF05w+xFpFS7VJDpSXRLTiB+vKM5eRBcndN0w3bvu5uTiI1G9DWC7RCYz4EgQBV50ZEJR6ILY7tFa0giJOPbkJkOWhiIohkaS1RUxBIbuSHs80DUHtLG4caCabdD2+etPF+PUPHM3tH0byYuKYWwYu46sqhiaBmk1CI+WGsLEmPn/Bz3836ae0MSfB7CffO2LGbS9RRMfyMqSuq6f+ztu6Bm7DluWGJu94/taSWaFYWxK2rGlshmVqd4BqH2I0z0tIFOKRWHQUrAUEptNxqApFXD7LlIZjFk8GzsWIrPM8HhccLU74nJNche8+uZn2AjJ97//B/hvfulv8SOf+Zf82fqMYGdI0aNtxT/8jX/Nzz78KaIYuFWe8v3v/4O8NL+L6AdCf0mrI3e6S/JZDt6Tmci2Ljk2BxyS73rh9/P6xa/xM2/+HB88+SZu6w2xa4hVSYiGi998jfliyWHYAp+hHQr6vGZTGnxwEBOjbHBhS21qXmfPzC5Zzub89OEjBOH5rvf/QWbrktye0b92RA6Pmd19ERFrwui5eONTtO4aTr+aQlXoOJBcywfsmt978lV8fPcq/+jVX+D3fuDbaXePuTxeca+4zQubNZd4muObHBrPL+8/QTOMfOut96OUYLF+keA9x6sHSOWZWY/uE2VakecNl+7AasjxmUQEhZEGLRxx9xDne8z6hNLeoRkPVNUt4tCzffSIbFUjCsO2jyjvqdseaSz/0df/SVrgZz/7Ef7GR/8r/tTX/AlmXiLbS+7WGZna8GCAN/YtZ6ZGhB2HBw9pr8HOA8u6xrsOkRqG7C7CWRZ6oPI9P9Z8ikDiO5dfi6hn033cbTlZnfFdd7+Db/na7+HPur/MSZ9wXc+Ly/dxvW15fP4qjWuw0UHXsbj7AsYHgoeY5RS5AltxOD7Ep4xBZjwZK/RIiCPu4poxVDzavc5QZazPNmzyHCFG8mQYrvccraGoLCI0tE4h4xybRXatQ+cRITwiDJxtlmiV8bq/4rLNWGaCMTTs9Zzve+k7+Ru/+iP8k9d+kj/5gT9GFC0qy5E3Ej81L7FlRWkXPNp/mgu/5Y5aoo1hVljccKS2J1yKAtu+QTFI/B7S4Q20XjN78S77IaC643SGVQERHK8OI2/0ik0x56XNkv2l42p/SaGKSaLUHvmX219kHxv+0Mvfw/37r2CynHK+4M1H5xy84NbJfWSZ07RHlFZ47alPNiiRo2zGMi+weT4ZVBYFu8+8ypuP3qQuNbfmC0YSSRtCWTIqhYiJph3xPrJQmtmYiDJDZSWN31NbhRUFCChkg7KJ3jl632NkROoNw/AIhEIgEULdsKNGgKdrUNcccSGh65pMK9ZacaDg0BvceKQKHUWW0xwb1n6Jutk/Wh+JJEwKaBHRNgch6H3PIHoqXaH210hrKc9OOey3uO7ILFfseolTOWUxxaNJWeGGiPERjaQxksYKNDy9FoUQFIsF+wcPaIUgKzNaN2Ayg08SmRJFUZCcIxwOhCzjoA0pJlZGPZVKAkhhiHEk0xV9gJAS6ndITNdv7939f2GV8hJTVMzyDD+OdPs9zfZ6osz5Z6MlJqdVSRonXZk1kiRzxqGBFPAuEH1ES0OroL3cU/c9dlGjlsunOhBtFUVtUEJD0Aw+MTRHgg/4AQSJ6B+TgqOY3X8GXMN0ADPG4JzDVpaxHYgxMc/mLLIFxY2pVgwBNwz0Q4SkKOrsGXANoKVmYSsa3+CrnIVSzJQh1Bor7XNN356Uqkp08MgYKOZrbGbZbw84VeAwHAZw/ohreqQfsLM5s5PTyVVWF8Q4PPdx81trNi/dY/HKXW5VZ2hrJoo+k8ma1BrXB5Qqpqxs0RO1JJcR4Tp6LE00rMORhdux7Ud0nlNLgUcjjaEZA+eHkdsnMza54dB2Ny9KQpysH1Sm0EZhjHzmoJ9SYhgGBAppDGaxZm4sS+OQ7pKtqhBK0u6PdO4t6lo3dOzHQCYSrr2mmi3IqjnaSASCvh0I3YDQCpVbZuUMtKLdH8jLU7ScXOVtLontBUW15lqvuWiuWJc5S2toDwMmKbpCkdmIGsA3DqUleWnIKou40c6mGBEqIsREl54vl8RhQMpEd9wiTUGer2hdS4yTfkcLwZnV1EpyGLspO7rcsFeevWxoVcLnlnVeQPCozuH2A+NhZDO/T+cTu+4KYQzjqGh6EFVBjAIfI9eD5zB6ynzBHV1Sk1P1lv7ymjc++ylk8hATMUb8sWe43jPGESktWZaRLxbEcWDvHOcikEdBoQwnswojBb2PzO0ChyK2DzGuIRzP2R6uUM2OhUwIrRFKICIstMLqkjYlutSRwo0+SiiOQdIersjCEU1CmQJudKkhNHS+YxSK0iuKvMYaQYqJ7X6grAuUESAji2xFZWfomBj6HgpFWZUMMTEkuF1n9J1gZuY44dmPe4QxSGuQbmTwEaUUUmmObUuZa3COq+tznBVsZpunE0dpLaxWiASiOSLzFYKAJhLzRLSJsX2MLmqy+g5a2yneTmtSiuAdcQh476d7Nb+hXt+YLfahp/c9uc4RSRC7kbrQHFpH9BE7zxFSoI1CSIEfIjazzJZrFutbZHmFd468qMmK57NnALqQkD4SxsisqvDaQ4gU9eQUPjQNAOIm4koLPemBhfj3kn/977qexHWl9JYNjfeeGOMXnV4/fQybkWIkeP9ccO2dY2gaTJ5j83d/r0urqW2OSCWKKTf3/DCwbR3t6JEC6lyzrixns5xFaZjnBq0kUTA1LJmo/9rUaL14x/PRSlLlmhdvr6lzjdY5L99+hY0t6PYPqGTNi8sP8tHz1/j5V3+Dh48f8Yuf+nn+2i/8DX70k38HPQ78sft/gL/ye/4sv/vsJTZ1ybrIeenklPr+y/Sqotq8SLALhlFyenKPfHZCkIpoc3747ofJreF/vPhnhNIwP72DiY7ZrQUUBnd1oDvP2J1PSQEX129wvL7C9Q0+HTn0V2RmyX7wpBRYmzMO7PlXD36Oe7N7fM3p1zGGkWI2w3vB/uIC6QeKLGNx/w55kSOswKpE++AB/acf0LoOVgV/6vf9eW7PX+JHP/kTvPnw09QmZ9fv2TY7pJScnNxC5BKtRz52/klMgG9cfxUSw9X2iu11xygy6vsvYuqCsLtA7hpuL08Z5Mj57hybIiZl5CpBf43bDRRzhasqxI0BYhgbkvdAQkuDi5GrrqHaNYRHD0khEq+2/PmXv4+vO/16PvbwV/kffu3v4naXBO+oVneYz9bcLRVqGLk8v+Qzr/8mj686hMmZb1asTm+RL++zJXI8bFlaw4kIPHz0gF9oPsW9W+/nA3ZOfzhCdQZhxIiRIBLDYcumPKPenJBXNQ8ePCS1WxbLJd0+0XWPsMsVtYCw3SOynLS6jVaC0jt0cIwyMaaE63ua3Zbrq2uyFPBKsN0/IGSJeXWX2/ffRz6/hzA5VQ1peMxwvMAyIKQmlye4MCMCw6ioRkeeKVTtMeuas1v3mQ0lj84footL8jLnwJK76h7vX77ARx//Em8eXgMdkbIiDEeMrfA+oYzB6IwiP0HqwMFdk/SAVR1ms0DP5+S1RZ6dUNZzyqNmbAL5CyeEEBmaA4VOFHIEAp8dI290cFoteXmzItMKlSz6ekuMCrU6YxeP/MxrP85GFXznnW9E3eiEtVbcOlkjY+Rie6DO19g8pzs8xqVEeeslbJZPcX1lOTGfxpHD9RVGjdjbG8zpK8QYUW3HTGusEBx6z4N9RwfMTlacvO8u85M1s3yG1ppGOJZ2TmnnqH0iEyX16SvoW1/LulgQqBhdjtYzlMwASRg63P4Cv71EyxohFG7oCeOIyApQEiMFRknWRcVJljPGxMP2gM5qfHB0ff90zTqOARkCWoJVApSZpG7jgdIWlCT84YCYnyG1oqznHPoG6TteWW0wmWKWJaSEhKXZD1OcbmW4O88plGTnAzv31j4g85wyyxnaHlkW6MqgjcInOTGUhCDs9/RCss0LBIKN1c+AawApLSl5rBCcZeZ3DLiGrwDs33ZVZZaiqqmWK4r5HG3tO8C2dxPYFkZBSiQXyYxCqoKhH6Z82MGjxRTstN1ek3UD9ekSNZu940AhlaSoDbnNGKOhPewZuhFJIhc7+tBiZrdR5vlRLE80eEJCDJ6x9xhpnk6uAca+43gYEEkzW5RP9cOfX8usRiG4So5FqSgLgbeWQmdf8MYzZQUCjB8YQmR+uiEpQS8yLkdJ3x7AKup8xnxWk8/nTxdmKS0Qic/JxxRKsLl1n3tn70MJify8552VFcF3kCYTJ3vjRCl1woYGBTSionOBfTcQTM7CRIQwBGHpo+SyGcmN5O5JxSwvafrJmVkoMX2+ISGUxJb6HdKBcZw6oBKNNpIkStAF+Qxe0CNZSlwLgzu0bJueeAPYL44NwQeq2KIl1Os7SCVIKWFzzeFyj0Jjy5IxjORaYU3FSI9zDjcEtBWocUc7DuzzE+ziLrM4osYrrMkYjgNaQ2cktpBIFfBHhwjxmcN68I6YAkJC8tN0vVouUd4R2ytSSji7pLQlIQQuhhafEgutkEJQaUXFyC0zLfhJlHxqv+X1vsfOcspljVzpaaArBMN2YLjomOszohsIvaM0G1b1mlJZjhcNr13t2V7t4bDnRIKcn1Kd3WFRBE7WC3buwOPmDWKWCCrRdi2x6UEKbJaT1zVhf2Bfz2isxjR7SqGRxjK3esoMdYFKgnGRWC3Rq/tcYxEpshh2yNDA8RFiuIJ+h3E9CykQsqRjoB9HegeXxwPB1JT0ZO6IsQVkM5CSlCL9uKcPiUJl2GRQdgIwofO4ECln2UTlSgGtNNpNB4+UScqqRCnF486hheD+IicMAScVi3zBEAYO4wGvNaUUSB9oB0fnIkIkrBR01xdcMbJarJ9xek4xEZUiP1uTvIB+IMocZQpc0+LHFklGuX7x6Zplb1ymvYDke4gJ1483oH7SdkcfyVSGj55IpNAFbggk76mtxo8jLtfIt2VuaisJPj69P5TWlLMly5M7lLPlu647LiZGH1BjRBlJXZagoHc9QkqK2dTkMFlGJCGFREl1E8/15bH9aq1vMsf90685555mZb+nx3gbTfzzK3hPfzygrCUrv7gJ27wwGGnpx4gQUGVvAeplaSmtxrytcSGlQAjwQkBIT9cerWdI+XyGGICyhrLIUeOI1wXL1V1eXpxypjq+/6Xfg81y/tFrH+F/+NW/zY+8/lPsCfzg1/0A/6fv/T/yba98D/n8DvniDFkuSUFh5ms2m1P2IeK7nhgjzjuk0mhbsJhtyIRmoWd8+OzruGzO+dE3/xnz0zsonU9O2y/dx55sqNUSK5csFyVJOxrXcrx8lVb1xJBj5YzrwyMWck2RV/z4mz+Jj54//MHvRwvLEAZc1yFIqCiJhy16taRrW6StKBdz1qWjkA1i2HHtBw6hprB3+HPf/BfJsop/+Ov/I3HoCV3H5e6C1rWMfiAkw6vhmsfuTb7l3tfx8vIV8pBz3He0+y1ROLzN6VXNkC8RvWMZBk7KOdfHLa7ZTtOzsMd3npAU1UoQspoxWjJygjsgTMZsvmS8vObyzQe0x3OqqFGzCnP7Fmoxx0jFn3n5B3khv8vHX/05/ttf/TvIYonNS9AZpUqk62uGz/0K6dggl0vUrRdhvmH0jkaVNC4nb88p+w7dR36y+WWiSnz3B78fUSrcoWfsBshmpOHIKFvE6JnbBUu7Qcs5vRkhNeigcLuID4J6XRIP1yQEyeYkoVDFAtFdMUeDVlx3B4a2YUBgjGC2mNHlhthsKWNBlq+oVgtUVWBEyaBnuKLAhM8xVx1FNcPmBbWUGGOZL1fYLCEqgbARbSu0MdQ+IxsHvIVBC+KYaFH8ofd9OylEfvRz/xSpLKHvScmT1TV+jE89EpzImCeFCo5+eMwgQM/OGIaBioSdzTkaRxMOiM09LJr99gGF9JQ6EJTis2PiYeO5Xa54ab1AS2ivttBAbSvyGvyy4kcvf5Fewg++8gfJGZDdJQwHiFOD9GQ1AzewawZKUyH9gb0POGWQZUlsG8I40h0PdIc9zo3IUnNydouqqLkWBnvrNj7C9nwLh4bNzRoT/UjbtqRMkrTm0h1QUnLL5LjzLUJAfmtDry0ueF4+naHrNdttw3B5IO0dYjuiGomJNYYFdG5iTrUtQhtQGqR4a6AkBFVWcmY1Mva4JGiV5HK/nwYsMTK6iCFglEKLRJSa3bBDScVclahxh4sZopjW16giUQuUj8ysZV5YCuPxXtLvAyIJqsUk0RBCsDCahVb0MXHhPC4mhDGUsxrhAzF4DI4UAzYvsdYSdjsOo+NYVhRKsjHquWd4IaY1+Mk0/3dSfXns8P8LqVJJ5m87GChtyMrqbWB7mmz3hxuw3TeEFIiDRxmFsTkuSMamJXmBDHB92KJ6z2qzRM3f/fAipKCeFehZRhgTsW8p5IExDoR8QfkFXFqlnDpWSU7xUkMzdb+eVIyR7cWeEGC+qt4VXANIIVlmNUcg6oRXnqTyd3S93vF7SiHzAj10CABhyFclIitB51Rni8ktMysQKaLfNpESwgLiuVNsoeRkJOUjwqoJ9L6tlNYoIwijQMoKpSSZ0gxSoOhIriGzmj01nZxR2ohNkSgM+z4wJIkSglVpyYxiVlpkUuy6jvgkuCBOLAVhp4N5CvHp+zqOI0poBAJlJGlMRKtBC8ryhJfElrzOaFzk4mrPvhtoB8fFbs/cakxo0eUMk1VILae82DiSYkCqAqszXHQkH6lMiZwbuu4AKWHCjsPYc6ErCltyp54xq05oj1va3YFCW1SmGQVEBDGNiEKhgNi4p9dIcA4hJ43qBNwzbFWT4/DNDlUu6HzCaktMksuxpb7p8AK44PDeMbcl69xyv6hQTnAZWtoUaKNgNJpkI3Zm8UWi85718g5ZPidgEcmQFRqvNENdUZ/U1DU406N1xGmFO30BVRbcygInq7tcb/c0zUN219cM4wjJIYKlmi1wx5aL0SGWK4pCYdsOHwRFlpFJSWYkPgRCc0mlJGH2Ckd7QrI1q9kGka8Ry9sTUFYGwgDtNVV/yXzcMwwHXr94g91+xIjA2fqUTErE2KPqFdxEfTl/5OAOWDOjZKLjK2UYxoASCZErUpqkHkrLm4O/J+ZQVAVa60kPPnhOCk2eayyCo4tYaZnZGc3YsPcd1bwmT4F929P1A/OqYDzsuBx2mNmSk/zZ/GU3ToyKbJEjZ3N0VhKbFmSOshtUrDH5HPW2e/UJY8YbM1HfxwHXjU/py+rmGs5UhkBgpUVLTRg8jA6pDJlWeGueafKYG1aIH581KPpi9OcuBFwXps+01GipMdow+Mn/QipFtViSlRU+Tk3PFBLE3/708CellEJK+RRgPwHb7xVcP6mpWfzsGhtjoD8ekEqRV/V7ez5ScFpnnM0nQF1lzwLq5/5tOU2wIU30/PdYIcs4ySbDxIMDsiXrxQu8UCz4g/e+nq3b8lp/we975Tv5T7/1r/DDH/qjzJZLdDaZUfoxkNp2uhbKkkVZYjLL9niENKVg+GHAJVAIlrZmM7/P187ucMvU/OLlr/Ar+99AlXPGwxF/eSDO55y8tMZ6i78eMTqn8x0xBtqoMOQ8un6EcomlPeVKXPLLjz/GBzcf4HedfhUCQ9+3HF7/HDZGFu97Pz4FRjfSXF+j8gI1ePLuMes7K+b37pCMJiSBHwcMC37ofX+UxvX8yKs/SVlWtPsjjy/e4Gr7mOMAv3j+m2Ta8wc++GFUVSKjBTdSW8NiscIUBX4c2QfJYJd0xwMrk6OC4nj+OWx/jbQZQ6cQNmALg5IFx7GHQZGlhB6OxJt848M4kllFubmDriZ5m8xz9GpFva754x/4Hl4yp/zLN3+ZH/3kP0J4R3cYuX79Dfz4GB8c8/mGV166xWqxoVeGx23P0LSooyRdXdE//DSvhkf86v4TfNXq/dzRa3xWQJnRPXxASJqGgFEjs5QTup7ddqB3iaxwzG9v0K6ldx6jb5P2e1I97euuv/EzKBcTUCQy0zm7bs9IIuYFKexpBaAEanDkPsNUS6RW2NoyyyqO+54rMWCNZVaeUqqBuh4wpYdFyerWGqEFbjyAUEiZ0TYDeQqcLksQc3ADR3cgFjkrseJrVx/kV69/ndcPF4zNHmEz8mJKuwg3zs8hGbTr2AhPkc/ZSUnXH3FNS9rvqQ4N7e6SXT4S0KhjJPprCt3hTM5nOsfjw8Cdes399QzpAu3DK3wzUJ1uyE/WlGrk4+cf5aMXv8gHNu/jQ/e/FTm/DSaHsYHmMXRbssywmhUwdLT7A5VZMmjB5eGAKKYh1MWnXqc/9CRlkBZkkZObiqX0JKF4c5Dss4pss2Y9L6iDI+97ypumYiKQtKMTI7eEJh0akjLkd0+JSnNoR7LxSD4OFFFxbBzjbkffHBFlid6s0ScnqKoitC39fo+UEpGVDCmhpSR/+5lX5+Qqo2DkRAaKquJh23DVDjQhkpzDSrB6GpLs/MSCXNgFYtijUoRsTkQRU+QwHpjN1pR5TuwbVoVmbBtCPzWqs0q/QxI1geTprHnlPE0I6LIkk3IyLY4jUWjKssQ3DVdNx1DVLPKMhfkCqUhSg5h02L/T6stjh/9K3YDt8gZsL9A2IzjHMDa022v6wwGlBM5rXDMgx8T+eCBIyXq5Qs+fnxH69rLKYsqMYlkwLyPaaFpbYHWB+QKdfpgmS0ppkIngR9wwHVRTTBwvj/RNz+J0TlE9fwr+9lrYCoRhrx1jDkrl78m631Qlse+wWhCCQllJPi+ZrzeQC2Sy2OBISqHMW1R3IQRS2nftoAktJjpn9k4NZowjJrcomeOHiFIlmYEgCkwmCN05SiTyvMBmikIOCAwXPYwRytxgtKS8eWybKXJj6X1kGAeQYjqQc+MeLwWxn97bp9NrMVFcZUwTDbNQSDNDFmtKKbhtDmT1lB352UdbXnt0hYyeW7MKEQcoVmgBSgvGtiUGT7ms8T4io8LFiYprjcLOlyQ1YsSOrR/ZmpraWk5shhSCst6QXEZ7+ZCyMsjcTpnISTE2R3RhULWBNIHs6MJEG1WBMGW3YfIcIRK1dISoSNoyhkhCMAQNyWN4a5rWhx4ZJNZMjInoPTNZclZmFLIjJdh7yTkj101HEoGszJHasrr1Mj7LacxAW2uOKbGYZdyalcgMVrMltVXopNn2A709wfUttytJUawYXUtMR6R3kEM5X9MfBi6PLWY2Y5EpYiYBSxoG6pupaa4lsr+mHx1ltQE5RTmtjEY6B4ip22wrRL2C6oxUnEGxItcFwVsO/R7ZXzHzF6iww0SBzmpEtb65NgPb7hFS5iyyJcKNCGPx/dTMqCuNlILeh8l8ThqkSFBAUZVPQetl79ECltmk/a+kwKdEG6bpsI2WzndQZ+QEfD8QvaOWsG+3DDZnni/eIfHwY0SbSXcvtELmFXaxIBz3GJGjTIYsy6dTkif1ZIrtSPihhRBRNy7SUk/U95RgmS2fanTdvkPGBLmhKjRSa9qbRhVMDUZt1TTpTu8NgKWU2B5HMgFF/ZYWObcl401Tanrs6bm56CbDyRABAfoLg/ffTmWMeUoTf/Lvu0V3vVspY29o4hNTKMVIfzhMer76ncyqL1Rfys/CBMr9pMx+up5+sXIhEo2lyAwLGYkIrg89yVZUixf43hd/P3/0le/gP/+W/4Qf/l1/ilWxIrtpmmSlQVtJ3zjG3RFZ5AilUEqxnFUcmx3jOHmH+HGgdw7h/TRRuv0Ky+oW33/yQYwQ/H8++Q84xJ6+E6jmiLCJ6u6G5e27k3nTvsG3ml2ouQ6Si92ew8VjlmmONjk/9vCfI4TgB9//vWgpwAWa1x/grq8o7tyj+sDvwtqMw2ufIxwOSB/IrEaZRCzmmNMN1XKOUSU+9Yyh5dvufQO/9+yb+I2Hv8m/efxximKBEJqLw4Fjcnzu8Jt8YP1+bpUb+s6TVQUp96jckAmLJcNKTS4U5Z07hKRIIaHMLcJBo8Wevt0Txg5Vwxgl4tjhjnvoPcZpbKXI1ivcco0wFrs9EqsKhJoakgAxEt01m80Jf+yb/zK3i3v83Gv/kr/143+dy8+8QZA9qxNLphcELVjMN6zrnJOsYJmXrJIlcwYRBdHu+ccPf5oUA9//wneQmj27fY8vDO3xyPknf43H2x02CNzhmovPvcGrj8/JRE9pFVbnOJPQqwx7DMShwFc5IR7x+8PkhO+HqTlqSlYpEMaB6zBweXyIiB21vY0eB4KCLJvi4wKQl4bZsqBtGg7dQJltsNkcihVSJlwZsfOaMs+m+MR2O51ZRk+/vaKa55zeuU9oHDNVMdrAoAKu93z72TcjpOAf/8Y/ZRhasnoBKaIzgxsCXYjEsSPvG0QcKXyBvL7kwRsfpx8eEsMl5AO6CGAVuVWErkGFgpArPn3Ycnl03JltuDcr4TjQnl+TJJRna7J5yUDkb33s7/Pjv/kPqHTO93/wBxBJTE7Z+WKi6NsawohoL8nlSCX2yL5F2hOyrOBRd81+e03be2SM0DkObz6mv7yg3YPc7mmOLdpmDDcRist5iV2v0Js1whhS02KORwoh8AJ017JICm8qdF0ix4GrN8+JV9eUx0uSMMznFX65pHjxZdR8zuAd4WaPEWWJHwfcfkdWVbiYiIBR4tlpr87JTE5MCeEbXp4vyBWcHw4MIaKcw1iDJnDwHZ7Ewi5Qvp/eE5Wh6gLvJnANsMjXFFVNSj3d/kjwkaKuMXYC2c9zPNdSsDGKQkkOPrJVGmsz0hhxbiQrZ3jnuLzekcqCdV1SvgcZ1KTDfieD9Mu9vgKwvwxLaf0UbJerFSYvCN0ArqfrIjQS1/QMZca8WmAy856mJVpqpJDIqqKo57h8jic9Q+t8txJC3EyxJTE63BiIIdIdHcf9nnyeU8/e24Qik4LK1HQqZzQVVmXY9xBlo6saYiLzI9NEWmFqSb7QdC6Q6ym3WRjzjkO7lBkpuUnb+fmvLdfI8vlmPjEOCKHI6wVhHEnBkmmDwBPtCVYNNLuHVJlilnkYew4+ox8j6/kUlaClILsBXtooSq1JGEbv8TG8dVAXAplpCJEw+qf5tMEnlBakIRJUi1ASXZ5NYtRyzSocqfTIqs5JKXJ+PHIyKyhTjxMCXSwRQpBiYOw7lM0pZyWJBE4SfCA4j8wUs6wmaskheEK+ZG4NpZKTcRPghoA1G7QSHPoLhFTM65ImKlzbYlRAKImsDEIJ/KEj9ANSQRgnTZdSCroteTVDqZwQRoSAKzdR6+dS0YdJf5RSYggDucimRgiwa3u0NmzqDaVM5GLgNCvQ0nPZd2x9Is4yOh9Q3qKoeBw7tu2BpZLMC0MXOlJKlFqT5znrxQZsRixK2lExDj3zTDD6HPxA7I/YWUVY1ux2BwqTcVJXDKEj+ICYrbApYccBUoLumkJFOj0HBLPjnkXXYqQgOYfQCvF2Uz8piCGxc4p9Ktms77C5/X72qmY0BZGEns0xm3sTxQzY9+e46FgVdxA+kEIkYPB9IJ9lCJmwStK7SIoJFQS2zCjq8qnsowuR/eBYZRp94wlgjZym2H7SP2s082pOqwPCgB478jDStNfoWYU2s2m6/nYjKTclIOibxpLMFMSEruZQFigZkblG3RjRPHuvTowZby3ODYiUEO6G2n2zmQcfMcqghCKMkbAfULki5gotJaVWU+f/mSm2hATevXMNeF4dOjeZ3lT2qbsqQG5yEtC59unXQgzEFCcHcRdBiS8ZJP7PWU9o4iEEnHOoG7D4JT3G22jiKSW642FKRKhnz82G/XdZWorJzkIJCO/t8x19REpJVuRoN7KoMwbn2XcelCFf3OcHvvqP8MrZ19P7QJWpZz7TrDSoODA0I1G/JZfKbIlOjlHKidkjJc3xQGgadIyQ5ejZS9yrN/yvX/4WmuaK/9dv/H2czshsIjYNSQiyzZrF5i7051g3IKRAyZrXL6/Yv9bQH3J+5eITfPLRZ/jQ/HdT+TnD5YHjp1/HX3t8vSDUS8YhomcnhO0VuWtJhWZ27yUoVoRxZBADm9kMk81oTI6SoGPHH//QD3B3dpuffvUjfObqVfrGIs2c1/YfRwrBt730h+hbRwgHCiMRSqCWBbKySKMYO4c6eorZinJzRuZHsmzJUHwQzIrx0Wt4d854eJXdG5eYdmQ2n5PONtjNPWSeYypDkwLGBayyNMmTkKSxhxhIzQWj65kVZxg953tufR+nes2/2v4qP9V9FCMi8mKHLRJJWES06FyjpMB2Ahs0daWwt+7zwDZ87vAZ/oNXPsxXvfDVnJ2skLMzVGGoXniRNvUUXlAv73FAcP7mI/Zjj/ENqvdcbC8YjOWF2xtY1yRV4w6CgY7heIWKYprE6gzqM6QbmYfIEU8cG25VZ6jB0zUH8s0tTF7hu3Yy1rICVbYkY/EHg80KcB0oS5evcfmaOp8YjMpOsqzkJc2bjxFaUJxsmKsai8LLwDJf0HmPSwOl1nzjnW/kU+ef4p88/lk8kRQjJod+f8XVg08TX/slUrujH3YM4ZIss9iqQt5a4as5gRwrVpzlK+6eLBBVTTsUvHa552p/4G694I7NSM1A3xyRlaY6W6Ezwy8+/Bh/7d/8dX798rN8450P8Z9923/MrLxFStN5AQApIauhPoNiCQSU21L2DYV01FQcDi1vnD+Aomb5wm1UpdD5QJSG43XPw0+9ye78SNEceTG1xMtLrh48xl9fE9sWlEaWBUkI0n7P7vGbZD6gk5kaJN2R4+6AR7BaF5j1An16l/VqgTCGNkExm08NjsOese+IweOlRCOQaVpzouTZ6TWAEGhTIaTA+Z4M2MwKzNBjnEPFSF5ktOOBnkBta4yQMBxIGJKw2DKn6Vp61zOzsynFR1fYApANxazAZJYQIlK9+94khGCuFUut8AmOWUZKCSkl0RZcXm3RmeV0tXzPmdaTDtu95+b2l0t9BWB/mZfSmmxRU5Rz5qsVpiyJydDNKsr5nEqK6fD6HstIw6g0lGva0KOEekcMyruVtRaTZYQ4ErynOzqGoQflWawXz41leV5JISi0RZoaaWYYKd+T8YHOc4TW0HdYJYlB46JjiAM+CEopCMGji+I5h/bpNT5vii2keAc1/EnFOCBlhrEZylrGrsWYBUYmxhCYzc9IwyXbwyW+33HoBR2GRSbJsmkyW2XPgv0qVxAlXggGP5LephsURoKS9Pv25r3SkEAliGkkqRGtK4Stp0B0nSGzGfNwhY+BFzZLytJgtYJhj8sWGK2JMTB2DSazGDNlF2orkFHhjx6PRxiFUZK8PkFWGzZ5iWJyBRdCEEJk7D1WaWYnt2lcw9BeczKrCSrn2LbI1D99T2VpiDJNOr7Wk7zA5AUMe0gBMTuhkpLOOYSArQtUSlKpjCEMhBimf70nkxahJhrrsXPozJIbyzqraX1LImG947QUnJicCDRa8Kgd6YVmVc3JfU9IPVEmWtdS6AKBQ8qMUhu0MdjlmqKsUCojM5qE53AMCJERNrdpj0fmdcaiqAijpx1aVDRQVtRlSToeSe0VhJF8dkKMku78EhsjahiIbUsaBsTnZQuPKXG5Hxh8YJ4bbtU5t+cznMy59oGYlcjN/WnazQTumvGKWXaC1Rmp74kRfACdKYoyI8aIVQIXIr6bGAHFonom1/hqcChgmU9fSyGhjaK4oWJftx1KKdbVmlzndJlA9XvG4zkp05yc3CckiYrPgho/RKQWTwGx0NN1LaNAZhnM56SieEdU05MyxiC0pg8elfwknYhpuq5udNhwE9m0H8AHzCon3BhzVUoRgfZtz0sqOdHkh3fPsX1SwUUOrafINMXn3b9KKqwx9MNbJjQ+Te+vQkGIT40Sv1zqCU3cOUcI4Uumhz+pJ54ifXMkhkBez55Jb/j3VUoKEhAl73mCPfiI1RJZFCQfyKWgtoLOeXadm2zKbUXjE0JAYZ59HSklTHKYWck4viU/SDFQFznWwL7ziLwEIRG7K9zYMyDQ1ZyyvMMHF/f5ts2HeLD/BB85fJQuasIw0DcNykjy1X2KuqJPj5id5MxOLWenOSub4WPkRx78BEJp/tD7v4vQ7hnOH2CMxM5qYg6pPxKP1yQSVWnQp0uYn0xU63xBt7/AC8+ynpEbxbZPzOYL8qpCJvjTX/1DWK34pw/+Ka/vztFu4Jfe+GVyFrzffjUilUg94IcjRVHhCdNemitSYdFKQAgEUeN2HTPhycuC7eOI34HqLtjvribQ98pdlnfPcDZD6Ay8og0tMpNkw0ixOKEXI8MYYOygvaRzLQMZbt8Rjz15tuJ/9eL3cf/Oy/zr/cf4Z5e/irYSq8D2cHh4TgwOkxL4iJQD5TxDLjb86Gu/gI6O733ft4PvKPOcvDqhGwOjHYmLOWkQPH64hdmGLNeczjRJKNIgeeP6EdkwcLLeYF95ATmvYVR0R8847uG4nybYZtKHewx19GQucqJztF1yuHoTRM7s9ISQlfimx4iISDuSlpjFLcQocf3kv4FrOMaItW+xAIXyaJXTPHyI6xyzO2cQJWkMnN1aM968/jxWeCE4+gu+bfUt3M7mfPTiF/i//bP/Mz/z6/8Av32Vdvc6zeXrFHlB9cLXk529Qra6jSzvsFl+FZv5S3QJHj96iCkXLFZrdL1mXG+4dD37S8kmWTa0xHFkCB2qtpTLJUMY+Vu/9N/xt37pbyOk4j/62j/Bn/zqH2JlEuPQ0oYRRHwHKEs6x1uDLm9jZyeo7pzZ/nUy53nsIqP0BKsJFsqTFePmHqnKmd27xdkL98jrOdiKWV3TJ8lxjKQQSH1HaFq8c2yD4+h75lnF6AV2USNWC4bZktnJijwT0zWqLVZJCqPYDeGpL4fJC8a2pTscJsfwusYdjgwhoqV8rqGvMCVWWsYwInxPXZbE4BH9iFYadOLYX1M+MRfudyAkUUypN6LQHP0Rk+xTfyQpDdrk2EJhbgZpMaQvCLCfVK4kG6vRZUUrM46yoGkGSinYbNbIL4mRZG7WzN9ZNPEvr13+K/XcEkaCEFghyU82jOsNalkxC9PB9UvR+hlp8NFPwDQM72l6/fYqq4pEIqYJFDnfYouc4j2Y17y9Mimwuia7mX6911JViW+OFFaRULgQOI4dRmRkKRC9f0bT+aSm2AT9rm7iz6sYJ5dWKafFKivLG4M5R5mvGFwHZs68mtEfHrHdHUiqYpZZrNH0USKFeEorfFI20xgJnmnK2w/dM7rBZMANDis00SWkABEiQXdIZVCqvMmoqacNuz5lZgWyndw0K5Pww0TjDdkCBfTHIwDFfEbwUzdSSNBaEtvEqN+iZM9txsJMLpE+ToZ2KSWGxiNCxFhFvliSdI1rL8kUmKzEaUOzvXzmtSaVUJUk9B45SlR0MLaQzRF5SWENwTn244BCkAmBFRYpJJ3v6H2PZtK+ogS7picBWW4wQlDbCist5/tLfEyUtaEymg2Ss8pSFJpVablX1MxFSScGHnePJ9qq0pAmh3gtBUrAoDU6K7ApMDu9z63TDRhNWK1JLrKSgvmtDTLTtMcjYzeSpEUbQ7mYk/o9cXcF+QIlFHK/ow8RtV4jqxK/2xH7twB2Sold59gNDiVgXVqKG23UIrcsshlXXeQ4bJ++py5O2b1WWWb5yTR5bDvGqJBaYHP9dPqoxXSQHDqHzNUztLA2RI6DZ2E09sk1GhPSSIxWiGHkOLqngHxu5xTzJfvxSB8GVqf3QWcTOHtbCkIMcZowf57GS2YKgUAi8W6ElJDvElMopZx0wVojmTRo6QbAPNFhA9AHQhdQOSQ7TWG11mgpyKV4hiYOYDJFDIng333KGWOibUaChHn1/OeX2ZLRj8QbRoyPfjI4m4TAXzb667eX1hrn3G+JHv70MewNTXwcyav6HUyif1+lb67rIHhqHPmFKsaEC5FMK4Sd0g5wjkwraiPpXeDQO2JM9GOgtO/UGKa+J4VIcbJAW8nQeoa2J4VAMVsyUx7nE9tuQGvNLM+JSnHYbZFCILMT+r3jB77me3hxdYefe/TPebB/lV2A/XaHUoBQLJYvEbNEyiRdt+U0welmzmvHj7JrXuXDZ1+LuHjE1Wc+jlQdi7WmMI6sjCjTUZSSclVRv/Qifv0CtpyhpEBVS7p+D34kUxl5oWl9QrmEzQuqxZL7Jy/yh1/8brbHa378jb/Pw/GTXPuW37P5RlRUSFnQXI20xy1a5PTD8JZhnlSYXBMLjQsalRdUY0txfc7Vgz2NmRN0gmzJ6u770blCpS0xNLQEJCXHbiAfd8zKamIJZJohJfrDkaHt2A6BNCTiCJkuyM5OWJ/c4Ydf+g7u2A0fufg4/7z9NbKTE+YntxgOHd3rj0mHPdY6rEmY9ZqPX/8Gb7R7vu3O11PLCK5DZQV5XtCMkTcvXgMKdlFhgFVRMJsvKV2LT4qhnJFGh8kMTgqsBrGoKTcrQrD0bU/3+FOEEMAUk668j8gEeXDIINg+fkTXbKlX99DGMBpDwCHbR9NerBaomWFW5IQjeJHo+oYQE/VNIzPGkZQCJsLxco+az6d7eaLSsVrMsMbQNA3GS7SpMfSMV4/443e/nR+682F0kPzjN3+e/+cnfoTPxD2musf83jeQzU7JshXeD3jvybIpRk91gWOzR8wr1PIuR+DTFxd4VfJCfsJalXTNNZ1/jClyitmcX7/8JP/Fv/i/8wsPf5mvOf1q/g/f8Z/zu0+/muB6Ml2ho6eJDc5dMY6PGYZzxvEK5/YMwzluPCJEjVqeMlAgkNyfzSiTY9u8wfFwyeA7rl3GvhnY5Ir79zbMNjlqZvAWehFxMvH6MPBGGtlWsJ0L9jVcFILi7IRqdRu9XJCvZxyCQEpBbW+o/uatc+bMaBofCDf7TVaWZHU9eU/UM2RVMXQD/TCQafn8ya/OMMrikie5niorEUbSDyM60xz6K6ww1PlqYkL4AfIFaRjA2glca03Os2d6pSpAImVGDHEa2LzHdAslBCdVwaKs8ENiKQXz9epZ9t17qCc67N9pRmdffrv8V+odJcRbkV2Z1YjKMpcKmXiubvgLlVGGRGI/7JFCkqsvrpl+5veNwWQZ3ncIE4huoJ7NvqTHgAlgRyZcab6ETpgpK+LoMAQyZRk89C5OLuR+BKXQ5vkTeSmzL+kGn8C4eDr9llJhiwLXd2TKImVOO+4pZrcplEKhWC03yOhBaQYXKK16zjRdUFnNMAZ0nuF9wI1vAZTRu0m36gXehSmXMnWgAlq/7b02xY1BlkMt7rAMB/zukplOqLHnQE4yBbFtn06TtFXTJFDIKYYH0MrQu+frY3zyU+Z556foI6mQucKTUNmKwhr8/iFaGbLlima/xw+TAUdKaQJSOkJmMZkhXl0SkwFbIrQmUwoXIm1wLLVijNPzehLDNMaRPNlJq54S+3ZgVmRE8ZYLp012cqw2AoR/eq9YBGd1xrK04BOFKTHWct1fI5FP6f9PPt9CSsaYIK9JfYeMnuXqFpu7d6hmc1YhkC8X0+Zi5TRd6RJJWSqtUKFDWUGMhtB7/HZLUVhcvSAJiaprBBD2e5CS0UcujiODC8xKy6q0fP7dfKsusKniYb/DhwnQbftrRBpZ5mfT59gP9I1D5DlZeRP7laapZPAe4yMDN6kEN5VSYjc6REwsi7fAVArTlFgZAf2IUIrxRv8shGBdn1Is1yxP71FmNUOMlNkU0fTEJMuNcTJb+7wp7pNmoIiS4D0I8QUBmBACnedEKYiuJ42R6OMULdh7/HEkjpEkElolopLPOF9XShHSRIN/UspM2jP3LlPsqZHkGBKYQlO8S/OvsDmkRDdO1/pTgzOfQIrn6tt+u9cTUK21fs9spM8vpc3kFl5VaPvemFH/Lko9Adg3/09fhCY+3nzf6omdI4oCcRNRk2mY5Zp2DFy3035Rmnfus7FtkZmd1rEbTfbh6kCMgmK+xshIrgJ9M6JdINMas94gtaY/tPS9xOqKXHv+9O/5kyhb8BOv/yNUv+XKObbbLSiBNivm5ZK2vSbfX1E4jykVH9n/EjOR8T2LryFPCbm6zXjyMvsx45jfJs1uMxRzqDZQrgmzO4wY8pvXIm2JI2DC9BqFEmS5YhwmoCCkJK9q/oMP/H6+dvVBHu4/w9/91R9DeMW33vsm5qcWkwd0VpJVFdF1dM3Iftty3HakqBl9YDwO6EVNcWeBEANLDWa9ZDu27EOB0hWLrMDazURplSOH/oom9vjeY7orVptbWJPjfICyYAyGUZUEIdAhIyIw85KzkyXSFohDz5963/dxf32Hn3jwy/zLB79IOZ9j7AKXWUShkMmjZ5Mk6ic++5NYXfI9L3/XRDsfDnReMPYtB+cZXARVsDxZky0r6HuW+QxjCg4pY3c4sF6dUr54b5JjHY8cXYexOcXJCapccHx8zvHRBW3XcTgc8N4xO7vPy+s1RbFkd/46Y4BicYpIcHQdqfBkfkSrBUOUKBWoVwVizGk6z8E5stA/BWwhdNAfCYMgZXNsJmEMyNIgtUQKyXq5YAwjvu9IIrFwBTIcOGrLV73w3fzl3/dX+M73fy+PmnP+37/2d/i7r/4THh6mxrmUOcPQI+XEcmm211g065M7tKHlsr3kk28+ptvCy+sT7t5bY/MC7wXj2OBkz//3V/8+f+Pf/NcMYeRPf+iP85e+8c9T24ooWlIQ5PmLzM0KU5zh5QKtFyhVIIQihA7nLomDo+8uORw/h64FqTSQJKuTU6SCN89/g6t2yzE48NcIO3Dltlz1VxzintH0iDJQlNOk9rCL9HtBFgsys2RenXJ/dhsRNTbXNC7gY2JRGITvJxnY2wD2wmpiShzeFpVqbEY5X9wY9OY4IRm7luLdwK0QWDsjJRjDQCYSmbVII+lFh4ieeTab4nyGA9iSlCQpRDoVcNGxrBakwNO0jOkzs2TZ6c37dxPB9SX6g6xWS16YzagX8yl+87dQvxN12F8B2L9D6snhuFaKZWGxbnKp/VJzVo00SCEJKVDq8rekE6zqGj+OHPd7bJaRFV/aFBwmUP3kL3+h/OvPL11Nk3J/bCbwmiwpGqrc4rsWmWXvemh/K67rvYHsiR5un3mPTJYjlcL1LbldMHjwYmA1P+F0eYLUlhgCY5o+l9I+vwFS5pPpixcSbQ19M+U/e+/x3pPPS4KLpM4jiUQ9oFT5FAw+rRvjD1ksUEXBbNyydD25EexSgRsdwo9kVTU5ot9cLykCMZF8oJoXDIN7JqYHIKY4Tei8mAyrBEgjEHaKoILIYnmbFDxxuMIuT5BKctxeEG8ycWMcJ9q+KTCZQxhFoiL202E2WEtMYBEUMhESOB/IZEZMEYEgI0NoyaEbCDFSlNk0xZaScRzxznMyOwFpacY9SU2bSHqb1ja5gNBiOlDYBS6ONOP1xAa4qVxKIjAW9WSkNTQgBJtixjJKTF1N9GYm47VBeqQukF5Q+BaGI3J5SpIW9+AB0lrKkw1SyqcZ5SLPwRp251dcNQNKCtaVpSoMzzNoslZxlq9xHh42F+yHPTF2zMwMrSeDr/66AaUoZvm0HtwY5yml8N0Uwea0ILxt021j5DgE5lo/ZVikdOPArCWJqbEzs/kzWmYhBLfvvsLq5M5Ez46JyhrkzWeRYsKPAZO9s7EEU0NQK0PyEame/zNwMwUfPbnOcEnimx6/bQnbHjEE0hAm7bWevAWkkXh4htpsbqJQjuFZMG0yRXDxmUPIkxo7T4yJmMvJqO7dnFGVwkpDfwOwXXST/vrLKJ7r80sphdb6tzy9flJFPcNkX1rj9t+2hBAoORlCIcUXdRIfXJxYKzd7j8wySCC8J/ppYl1lGh8TuVXIz9ujYt+TfEBWbzG3lAEhIikZhNAkZVmYADGRtwNCC4LQZNnkPSGtQGiDbxpuVwu+94Pfy7kc+Tdv/DRVGujahl3fMAZNKk4Z9YKZvQ2Le/zs/lM0OvFdm29laCPZrXucvvQS68IyyyzO5OxbeHQ40rvJ2K93AQFP7/du7JF5jfaTDGeMiWWhGYGxfSsPt/Ejf+Trvo+XVq/QjiMvlPc4K2v6w57940ckP6CkRcWGEK5ouiva/Y5m27G7ONBc7fBupD86kozEumZWWUwxMmYF0p4yHD2x2aF1zaI+A2G59A0crsD15LOCIi9QSdHhyGYnRKHxQyQCdllRVCULDcM4kMmClDr+zNf/SW7NX+QnPvtT/MynfhpbZDArCFWJPtkgq4qffe1fsx33fPv9b0OqJf1+z/5wjU8QRKBLGSfzW1Q2UJUZhwR5llMbyLKacWgZtSI7ewkMlPMFi7ompMDVcYdwkeW9M5w2PHr9ddrzx2gEVVWRV3NSucE3B4QIFMtTIor9seHgLqhnc4psjW97XEpIAtVyRlHUXG8DQ3LUT/1KIrE7J7QJR021mBPaDrREljcUXR9ZFAW5KeiaPW77GC9nnNYF8+UJRk6Gb99+9k382a/5C7yw+no+vf8s/5ef+Wv8Vx/9e3zuasflMXAYes4vrrne7lHVjPniFvSSB2/uOe4l907W3L1TE7QHF1is7/NwPPB//ef/BR/53M/ygc37+Ksf/s/4ffe/CQDntiitkKIiuBEtoLAZXdIolaN1jdZzpNQYvUEMCxAF1fwWs+XZdDbyPdrC6uQW+axmpRL0e+Y2ZzHbMLdzltmSdb7mtDjltDrl1vKMD9y7zb3NmpAscdDsjhE1ghimZnNSgnYMb6UZuH7S0cu3znaZlmRasR+fPUM9s+ZkBTIGjH93kKltjRSSMTqE78izjDGOIBILlSNVNknshJxcw4cBj6cTjspUFHkG4p1pGU/XrZsG+pd67hdFgV4tn1nvvtT6najD/vLc6b9S7yghBUILtI/kN27MIvut0e+MNAgEuf6tHYJsnqO0JjpH+SW6wz6pydVYoIX4krQcUilUWeDahsIoSl0yszNyCX4YUPk76eFPf1daQL4ngJ1SJCX3lB7+9uedVdVERY+OKGaEEAjWIsoN3o0kYERSPGd6/aSs1VglOXaBvMyJITEMwxTLpRQ2s0QEcgj41CC0ROvnmMiZHJRFhB61uIUlknkok6IPkuZwxOQFxk6v44mGlcgEUlKkmE+a9abtn3noECejqjgIpEgYJZD5RJUc/DT9zrIKm21Q8UDvO8p6jm+PdF1HcCMh9JAUVoGMDrncIApLGiOhceyToEiJTOtpoqAm8C6SmGiLMp8aMZIp9zIzk0u8ABEDwzBgraXKK+b5ii709OGAMJPmzHuPHxzERCcHQgqcVWdkUnJ0LcPbQNYTmvioJ217PO4IhwN+u0VY88zmcugPaDTMKzLXI/c7sCXRy4mOpzTC2inWTT9pSMA4jOyLOUM/Uo0d68pO5mLwXIMmpSVlZlnpGdfjge3YkQmFNTVCKIbWEbqOYl1PZmDyRjISEwpJHD2mmADCk+eQUuIwBkRMzPK3UV9jYkIZ4Lwjyy1FmrStb6daK22QUjHE9LTRYa3Fe884eEi8IwLk6f2jJCozyDgxTVJMJB+JYyD2ntA4wmHE7Tpi5yikRWqLlwnSOF2/tUUtLOSKmEAFT9KQhHiHdrhSkpCgf9vz11ZOh5DPm2K7MeDHiMgUUYp3nV7DdB9lJsf5cXLhTxEV5bQuf5kCbICyLP+tAfb/XKWlIITp/f9iE+whhLdkEYAwBmE0eE+M03VRZ5pFYajtO/fZ2DQIaxBve6/GrqWY5eRVjusjSWQoRk6NoPKRfoS+9cikqJY1i9MNuljS73qG5sC33/8G3n/21fzc/hO8evUZ5qkla7c0PnH0lpmX5DbjGHr+xav/glM74/fe/ib0fIWyFlIiHI+s5gWny4pFXkFKXDQt58eBZvRk+q1mQTe2lLMzlJB0zZYIrKxBFArnI24ItEPLMO65vb7FX/qWv8T7Tt/PD3/DD1Gv1ygzxYzOT08pqiV5uSLTgiE2ECLWKLKFRome7rBn++YV+/2BAcm8kFSLkkEp6pMFqljTXx/or64nzw9b0zPHpISVFYN7iBCOIivo48DoHfvjDmEV5aLG5uXky9BvKUykqGckqRn6yF/60F/gdnbC//SZf8xHu19GSTN5DaTE4Af+6af+GTNT83tPv4Fj79Eo8tzgxcDOdxSmZrNYUxeCaxeQETIlyJcVaRyoTCRb3cGZDB89IQayomAxX9BbSbPd0V9dUdx9EakKxuuHuN0WKRQIQd8c6Q5X6Kxgc+semdHs2j390LEo18iqpj82pBBQyWONpVhldL0hDqDTCK4jtOeEtsWlBcJkFHkOUhKEnxg1UoCPZEoxywr6bovrO0ZdoYzlpfUdFgpOdMutRcFm8wJ/6Zv+NH/1O/63vLS4x8+/8S/5f/yr/5KPXf46fbvn2DSMSTKqgoseHjwciK7k7GzFnZOSoT0SokfNCn7sM/+cv/nJH6ENI9979/fyFz/0p1kWSwC8P5CSJ89PEEIxdh1CSmaZxaf0dO0OoSWEEbdPxBAp1xuKao1IJdaesNjcxcYSnZ3w/nvfRFneoRoH7i2WVLYi1zlWTbGOn38uW84s81nGXkSCggJJDAmbK/a9wyhJnWkIHsI46eg/rxZWcXSBGN+59oSY6OV0rjNN8+4Lk86w6gZUh5HKTHGUi3KOTgmif0oNRwhi33MQI0YaKlNNjUYtCe9i5Bm/iMHZu9VkwJt98R/8AiWlRaka+ArA/kr9NiyRqUlfNvjnZja/16pMxSJbTLERv4WSUlHVNWVRYIvf+qRioRWr51DvvljpsiS0LTBNFzItEW4k+YAu3x1gAzdxXV9ch/3kZz4fYMMEMHSWIf0ISRKoiGky0PLjiEMCgvI5B7O3V51r+iGQlCAzBjdOU2RrLcFHYowI4UlxQOsa8W6fVzabaOI6I5UFsixAWkLrCT1o++xnJLUkuIRIgqQFRhtsrumH4ZmF2UWHayMSiUE8pfi6EPEhomUCJFm+ZlbPaI8XRFtiRMSPA+3xSPQDKgkMI9hqMmWzCllNmqXRCTZiarS4lLAKhgDeexbZgvpmwtyGyOgcyypniBEDdF03uQDfLPylKf9/7L15uGxXWef/WdOeajjDnRIShhBDQsYbVGjGEBJoEBCkIcpPQVRaFKQZRGm0lakhNCAgIEor0u1jOzYBFWjABEQUHgxiEJA5yJjhTudUnarawxp+f6yquufcM9xzbqabpD7Pc5J76lTt2rVr77XXu973/X7JdJvl6jBOB7xzDHorDJb6DMohAzck0xlGGnIlKcwcK82A0h5dWMilpHIe76G54QbCcIgsWqj5+elNubQlZVWiTYGUgbYaEUhoBgG3MkDNL2D27cWtrBCci57YPrDUG7I8qFBFweK+XWTeRvXSMUJtbDGkjKQrO7S1xgF9LzhoDTf2Kw4f6WM1uDyLE8yxYJ+3HlEHUJKgYilsNe47HjrPYCwot1q4afLelY0LUHkrJ7hAJsU6RW6AynuUiIGNMVGFf7gyQhm5LuO3GpFq8lYb1Sj8So0fNoQyqukLASKROB3Q7Qwzn8eJbDsjaEf0f4tCbK7xhCZmdfw4G36s8nUiJUbE/Z++vxCYRNHURy27nPPUI4tOJE4LJMevrMmSHGxgUMcJk/ZxwnxnDrDvzCgpcCHE+6IPhA0qFCAq+YbA1NlhgkxThHW4+ugCbColYrwINPlxgxG+apBZPn2sGZa4qsaYjCRRKAmuSagGDS0DKveMGpAjSIzEpAqpFO29p5LmLerlFaqVJa4457HkrS5/891PcATFnB+yWB6kcJqW9cg056P/9iEaW/HoMy7FLMwxt7APpTRVb5mmrNDtNlpJMp2w0Eppp4HcRP2DLInnZu1qrLW083lU1qK/soQWgraSKCVxRlAOhxzuHSRPClrZPKctnMbzHvifuWf7dPq9PsOVFXSeo0yKyTLy9h7a7XmG1Qpp0mbhtN3sutc9mF+cZ2GuzeKpu5m/56l0FnOKLJBlCdpkDGrIF+dI5+fxoxWGB49Epf9Bn2By5hbOQjhJCEfADdDGsyJGuAI6rdhj3DiwoyWUCOzJE6yCpLuPwZGSVGT854v/P/YU83zw2x/hX27+HN5BVVV85CvXsDRY5pLTH0Kn1SFRkLXmsD7hO0duoJVoTu12kTKjkQKPJR+3V5lOi9CS7NmziznTopGG0kfXixACyjkGziNbhiRAMTdPZ/5Uyn6Pwzd+jf5NN7Ny80Gq5SWcrUjaC5hMg18B0yZL27i6opaCkQ/IQQ9EbPNzhUFlOboUlLaBsocdHqBhDi8KDIIkTzBz+dSbPi48BbCBTtMgk0AlFLYe0WQdpLOEwUGkSRiqNrUPLLZy7rf3DF78kF/kqWc9iUwb/u5bH+P//Nsfc7j+JnsXOuR5Rmo0e1LDvXZndDONLwcE7zngl/mdL76bT3zvU9yrfTq/cslLeei9H8Sg932q0RDnhng/QusOSmdIrQneI7UmXTV2e2+pyyWqlQZhJcXiPCaL6tbVyKK0pDXXIdWK4coQH6BnFWmrS+qGMSjdAiEE84WhGhe/tDsJeTdh6GOlUzcbz+WaYcwe6/XzwrnE4I4pE5/QOE8dAp25DjiPH4022xGSpI3zHuctuYZT5vdQmARsXEjB5KBTgrX0yx4hMXST7nQTOomLA/6YRcYQAt4F1B10fxJCRYHeE4w7TkbuOp9kRiz/VDF4E5tkiLaDlnrbyuGbYdKUJC+Q8sT3QwqxLfXwde89tutyoxHdzDBfJDSjYey/Ps4qW7TriuJlWxH7c82mg0GaF0gpCHVJ4xOUKqjrJarRzYxcQ6bVtPxwM1qZRhAYNJ7EJCghpyWaTWXBekS7QgSDZIvPpZMoNkVNMG1CklBJi+lmtJKc/pFRLMkeTziVFvgy9sCG8ddX5BleOKrR0dLA0aiCIEnNuE9xfJMpG4d3lkRJgotZ1oX5UxESVuwQpSTSlgwGy9R1SYJHqDQuBIxxQjBKFe0sIWsCalTjhESGqMQ5GvekBxezpMvDkswoTJJgfcCXZRQqO0Yxfi5dRARPz/ZioNh4Up2y4oeMhiOMN+OsumM+30OmM3p1j9KW0ZpkNMIdOkQdFEJrZCdDtVtr3qNX9lBBgdSk1RImz/Be4ZbGwXi7hWzF1/iVFTKjEAKqYUmRGnbNt0haBbLIcf0VQn20B5KwPjDQOi5x7EsK7pFIFtM2RVCEyhJ8Q5UmLHm4qWw44CxHvGdlpaJ0AfKYWc6Mmi6MrFiHcIFWqtcGwj7gCTRNFDYziYIAWdRFWScYVvkwtRsRQqCEpq6bmCHeAqHiuSRSicxNtPXpGFQ7iXZ5icKJEO0Hx/aAMsuifUxTEmoX/bBDLHlUeLyO185GFSNtLWlCoFqVWdBp/Gy2jurk1cAipcBkipHzZEpuuK3VSK1IRELlqmh/6Dd3I5hx26OlxPlAmJzTm5SJ1y4u5CTHTDRFliEQuJUBbhgrKfwgLgCt/rEHl8BCaMT0sfJID1GDbMAPGwyQSE3VF5TLPYa1gyyns7eN8gE3aAguik22dt1j7Ioh0dWIJ5/9IwzDkKu++XfQ3UNe91kYHCRBcMNN13PdoS9wn9335exTzyNfnI9OI2mBqCpG1QiMQStB4z2JSnA0dDLDnk46XVQY2RE6SIxJkcUcVTMibWrkuLLMak+/XKIuBXOtRSC2ELRaLfI8xzc1CIELMBgM6Pf7DAdDRj1DXZfIdITONUJrfFXhhwPM3AJZd44895S2j1Qpi/NzDCpPWTfoTpd8sYMPA9xoSDi8RCVy0lYXwyLGFChhUKHGmR5ZqtFopFT0lnsY01CkCqMCUqUIP0/iE4a+T2duN//5nB9jd3sXf/2N9/OvN32R5dEyf/+tf+TU7j4e/gMPpd1uo0LNgTrhSOPJleW0ToLRksorhl4wXygyqbEiUA0OsGshoZXOsZAYEqNYtoKVcoXBYICvyrEloydJc1wtsKmg6nvKQR8r+vjSIrwFqcnbHZxfIdRQ6UX2dDukqaK0lr73+MEyOI8WmpEIzC0WaJtSloGm6VP7BC8WEDa26MjCkOY53jlsXceFvxCwh3okvqE4dZHaa5wbUJsFXBMF+lR7D8t1Q6I1rXGFhsk053Tvx3POeSaX3uthLNsRf/j5P+V//utfcOPKAXYZw+7FNgFL2V9B4vn7m67l9/753Rwuj/DYsx7DL1zwM+xt7aU9dxomTVhZ/jaD5ZuQMkepmBjRUx2I+P+WimP3cv9GysEQIztRPHHsetFUscrO5AohJXOdDs5aDh9ZwoZAd/G06Fs2OgJu6/7fkQ+0M0NHK44Ma2rnGdWOdqaPVpk1o1g1uMG9IdOSREl6G+h7lNbhCBR5iszSaMW3Sal0ksVgufYO4SqSPOrsUPViYJ/Nxf0d9Ch9Sae1gFo1D1d6XKFVr71fex8gcEIZ7BkbMwuw72LITCMLfYeL6Jg0Iy123nt9a6CyDKEVdrAyfcyNRqgsPW7Av5Vd14QQAt7XG2avJwgpSfIcHSxlWSFlGxna1A58GKLFUgzktvocSpIlikHlQAjyNCPP8ygONrAIVSFaEp108OVxrIXSTlx7wVMOetTCkM/PMb+7oAJs6fArDb6yiAA0Hmn0tJzJSINIow+uraMKdDWKqrrSB8QqBerKepSIQml4gU4kWifMdfdSugrrPKIe4e0IXw5jefq4pGnCknUoJZjrpMhOhh5VuAZkCGgJgzL2MgXrqUKgqhu6RUodAk1Zognkeb5OjEmplG7SpqxWWHZ9Up2AAtlSdPMutrH0eodxLiBlQjfpksiE5aUbGd58A3I0RBU5dt8pyE4XyuGa7deuZjgakuoUUS+Ta4OrJEiHXuwCZmwnJZHtNr6s8HXNQp6CHgoAAQAASURBVJEwb6DdProgINttRGJwy8sE56LXJ4xLtY8itUDIWNUghSCTBar2zKeavalkX7fNLq2YU5KW0eADVWnpyUAPuHFU0fOOnnXcNKopG08mxTrhpuACVVNNfailkkglCDaQK7kmi1372Pu4JsvrozK9P87iFRCrGFKNGPvnrvHQtnaqBg5Mg2xnDK6pCOMyTQDpHUEEwipxs2NJpUQfk8WWUqCMpKkc1bjfNG0Z6gAetiwPnyCUIFUJuBDtuXy409lz3ZWYLGh6iIuHm5SJV40jXVXpEKzHVxZfeoRXuOUhrm4QJvauytbkJwETKyzUnoW4MNRKcEmAVJLtmUO2k+lPa1+bdE+HkbdYIWkvtknaaeyHDQE/aPC1Q7fmUcqQJwVSae5X7OOC3efwpYNf4lMHvo7adSqiGqGF4IPf/jhOKR575qPJOx10YuI5N4rl0xjDsLeMkVFzwYgEFxzWH+0Ndd5R1iW5yhBK0JgWGIUeLQGQisCgPEytBK1kPgr3jZFSgncYpZjfvYdOp0NRFCihGa7UUatDFgyGRxhWK9TeY3t98B7ZivZUwTtqV2NMi/l2jtEZh3qxCkTk89RZRtseJFMNVhSs1BYRMoQV0Y5KLaKUxtV9bD1kNLCE0KdbpKjgsEbQdjlNGSh278HSsFLVzCVtfuEBP8Wu9iLv/erf8BdfeS9BCZ5wzuPQSmNtw8qoou8lOpOcmneQeGSoOFg1GJWT+YrUKIIZMRr2wGV4Z8gTSddbDh3p850bv0/Z7yGaGmMrGlch8oK86LDrXvdi8R73JKEN0lPyfcrREjLNUGmDCIrSdwg6o50qkkQh0gzValGVA1xvwMA5rPN0coGQmsFSxaGlklGVQA3aKJK5NIpVaoPUmqYqQQncqMQu9VEdTTfViDTDaknjElaswqdzeKEYWUs3z6bjsrUNTT3EeMNjz3kcP3vez/ED8z/At/rX8+5/+T0+9I3/h80CZW05XB3kf33lz7nm3/+eU9r7eMGDfpHLzn4kUkpCZZFSk7V2I1RJXY2wJYTxPESZJIpfjgPtVArq/s0s9ZbJW3vI0hYyiUKewQeayqFTNdWWSUxCXhSsWEdaFORGQ74A0sDwcCzx3oSBc+Rasqed4sfuHomSRysRmzKK12zhvDOXaPqNXRc8rzQuVpVIiWy1CM4ThsMNtyFNjlEJtW9i5t27aMkVHBSLcWHLO3qDQ2R5Z50TkBACbWSsAlmFnwiczQLsW43Z3f4uhlCzEkSIYmfNuJclhIAdjVDbEFsTQiKE2bJMPAbfYcsAG+IiQ55Gb+zKOrwDKxco8t0kWmPtMnV9cMtAu5VpaudpggcXEEJgK4evakRaok0LXWTg/BrRrnUog0gKpB0SnEN2FtA69hDKTDM0YyX6yuOXK0TwhLEyt/c+it8pATrQlJamdHjpyKQGKZDjionGeZwP0f7JizVq0a20g8y6OFlTD/tI28NojdVtUEeDn4F12BCY0+Oy3lZOogXOx8y6ASrrqOrYO91vLEZCkaX0qwrhHXmerysHhnGfj1AoJ3DaY7VnwBCjDfOteYoiR4iGuhYMBgNsv0+732BKx4qo8fMdim6XRmlE2iKMVqJi6JjesIf0IF2JCAFdK3AWPT+Pmos92n4YhTxkniMSg+/3o0Ccs2v8r4UQqLm48BCVxWEjobNJSbO3BikyqmEYaxjEyYLIMrSPQWErUcwFwWJmOKVI2J0ltJQkEQKtJCvj3uvCqKOr8mNsFfsS0zSdTqyUkTjrKeTaXuzKByRM1Wu98wQPWZFS19sTEdwMay1SyjXfb5IkyDzH4gh1SbAencSKBysCGLPh+TChpaJCfLNq8cKkUVHfWU9WGKQUjLxHC4HZzgKmFKQyi7YnftJHPxub7ygmVl3Wh03bLZwPNNZjQsBPstTDhlDFrLZenEMawPioNzEWEo0/glAOkVmCytN4L1YCW5XoNEGP7b5W/7QXF9CpwHRy8nE7ldAS2YqBcSgt1KDSFr7s057bh8kVP3rfR9FSCe/98t9wEEe673S+GZb56tK/c8Hucznz9LNR4yyfSCR+MMSYlGx+gaaqcGMnB4FGIKjd0WuydCUiEB1EpKD0kryYI1QDfFOj3DLDyiGTeeY6GXVpp4KAwXvq0QidpOhxW0jwgmAl7VaL7kKLvXOngtE0vk9ZlgxWVhhYy2g0ovKS4WiASNN4z5Ga3XNdqrqhP6oYOU9jOpimptO1zHVyysZT1wI7EAgqjMiQqoOmTTUcsDL6DlmmKRA0rgaXkYoWwgjk3BxF1uJIbwlHYCHJee6Dfo5u1uFbR77HvefvxXl778+odiwt9zAmQaWBNOvSVm2kh4EfUDWOBVPgmhGNO0jWylHJAqNBRe/QQY4cuAF/5BDtIOirhKSdk+QFC+2MdG6eZM8+kiwn0SnZ7l10d+3CDnrUzTJeeZK2xiQFOsyx4gJZosl1ivcNNdDNEkgN1YHDfPfb38YuHSZUQ2TiESHFe41bsVT9HjLza2b+JstwTYMrS9xyH6E1oaUoak8xl1NLQ6gd/UYTlKFf1aA0uVJR8NF7eocPoXUgmIKbl4bkco6f/aEreP6DnslpxSl88oZredM//y4f/PZH+eOv/ik3DG7i8vtewn/5D7/Aqd1TYg9vFkUgfWMJYUTWWiDvdGnqIaN+D+8cSmta8wtIpQjeM1w+gqn7yNYulOnERczxXKQeL8InxzjpdIqCrDtHZ1LdJsQ4yFYwOhwD1mMYOh9Lw1WsPFwoElIt6a5y2KAZRiVDtblGxVyicSGsETvzPjCynkIrlBCxMi7P8MPhdGHhWJK0Q+NjlQj1SlwcSDvT0vReuQTW0W3v2vD1E7eY1XaU3sb+6xPRTJqxMbO7/Yy7JLrVJtTN9MaBD+gN/K83IvZh15uW6By1bzq+iFzR6aBEoN9fYVRWoDTtPMeYBYxZQAi1ZaDdTjVSCAaVn04Im35DkENUnqBUKy6oKImv1q+MriHpYJIUU7QgbaFFHExbqaJyHmckotBRiElKwiAG7c45tNSxJ9/Em4/1DiVBoZD50eNQWY/3LgYgXqL00VJaIwVJvogoOjTNEUyoaC+cQh1U9P8kTn5XnI9B36S8OEnIUoU0ELRBlw2hcawMKsrGUVlLOzP4EBiMSlpZuqUQk7WQCEG31WWgR7gk0EmiGF8IFVmWkYsUe+gQvQMHqYC5ffcim1+kZ1eQweKBJm/hq4rQxO+tcQ0rwx6Zb6K6cBP3QS0sTL10ZaGjgNwo3mBVp0OwDre8HPXDjrG4EFKi5uYITYPv9zcUOoMY6Go5h60yQghkbUOo62gTJMeiTkJA48fl/AY85MaQS0FB4NQiYV4rUiGmXtsTggtUdYlO1qpI63GZOMdksUvv12SvJ9ZcRSvDe0+zie3b8Zh46B77/U6y2FYbXDMiNBajJSp4nBLHtZbKlUQJ1iiKKy1RRpLkGmUkfqyKnm9zhV+M+63nVZc8ZKDkHV5ZdHdGSoEQMYhGS3CBEMY/1uNLy2i5xA8ajI2tASIZZ6k7BlkYdLeF1CqqLx9DqGtC3SBXVW41VYl3jmSTxV2dJJi5PSSt7pqJrRACmWtkbmKpOF1cWREaT5K12LVrniec+SMMyj5/ct2fE7od3vfVDyG94IkXPnFaSht3zBOcRSY5OknQWQ5Nja1GWA+JSiibMgoKhsDIjkhFHDccYEOgVczhqal636OyFqm6mDQlHYsg1sM4nlWjYaz2GB+DurTUQxuziGn8XO2sRdLqkiSK1PZoLcyTZnFxobaO2iSknUWkCAgSWnlKnhqO9Ib0GoepK1ySk83toiuGYMB0EoLLqZYbbDUi9wVUBWmaERKLcivUZQ9nNUp38IWkpWR0V2jtxjWWnq3AViwWizznB3+W8xbP5Uln/ghL/Zojg4rEjUhbBqUlmeqAMjgLTQhkjLBuhKuHCA3t9qkU7Tmq0tI4SzHXZfcpp3Lefe6D7sxzkGhz1hLxe6lEbOurV0qsH5AttGhlC6TmFJJ2i6Izj1Jz2Nqx4hpy4bCVZXnpAIOlI9iVZUKiMXkLYR2ZNsg0Y+7U3bQX9tDJT6HV3k0238KHhuHyEnU5ipVAY9vS6sDNUQSz08KP+qQyoT2X4ZMoPNU0DQcHlu/2SkYNLA8bDqxUfPO7N/G9gz0OupzvjxwHD/aQ2jB0GZlt8+NnPoP/eNaTqKzgszd/jj2tRZ73wJ/nsWc9ek3psjCSIAXNyhG89+T56SRpG5MHvLeM+j2cbRBC4Kxl2FumaZaZm5snby0yKOs4xmqJcx5be5JsfTVnJiVGq7VVSFJCvgiIGKyuCrJDCAycI5VHF1aNkswXydE2P+/H4mZbzzFzozBK0lul4l1P+q9XVYzJVnQA8RuMMwBJ0on3UW+j53VwUMRgetgMqYZ9Oqa9qaiv0vFetDqL7V2YZa9vZU5MZnrGjJMcXRRR7XiwgnAelNxBgJ3i3IAQaoRYn6X2vkJt0x9cjvvSlnt9tJSk3da0z03KZBrMOzfA2mWcW0Gp9nT7QgjyTDFcaZjzElc5muEQ2fEY05n2gMtM4wc1ofGb998rjenuBmA5BNLxDSY3imHtWCktcyr2vZqOwC/V+LLBigrdVRhpsMHSbuWoAUgbMK1kjRVc2Tg0USxDEzOrExIhopBF51TUKKrBFgunMxiNKMsyHifrkALaq7YptEZJifINtNtoZ9HDmpVeiU1SlPJkScrycIRSirktvmfnHNaCMZJW0mWpXkIJRaISQgg0gyMwrFFS0Op2cUlC7RzDsiRPc4IMDJseXrSokxwtFGHURyQ5veEylH2UadNUgizXMbhelTkVSiJzhR9ZfOWQqUa2CvxgGLNgG5QxC2NQnQ6u10ckAsxGwnqxr8r7QNYyCO/iZH8u9mvFxZlAqF10F7AenEcIFf2wnSPLDIJYSnuswFM1KvHeUxwjWiilQOp4o24VmpHz9KzDBUgnlm9hbM2VRJsnpRR1XZ+QGrVzbk15+GqSJKEucprlZWRVIsgJtsbrfNPy8NW0lKJno5/pJNuZtY7u48h7AtsrD58glEA3Oi6epLP17DsaLaOgoEgkgYAf2nEvdgAhqH1sBdCddMPFECEEstXCDVZgz541f3ODAcLoqZpuCIF6NEIlyRbWkJJWp0uzSbm6MBKpDEa1aZYV9cGDpKfegxCOcNF9zuXryz/MF2/8F972sbfxvSPf4aGnPYh9u06LC2qB2FO73I/WfF7BqIn3QgxhqcegCrQLxageUZUCnyq88OSiBSJWbEigMDl947CDQ5TqfsxnaSwpDh6pLMOlEdUwoLQgLVpj9esG13hMpkgyzXA4jA4YQSKMxpWW0AwxC7tRTqCLIgb4eoASKW5lBXw8brs6La6/+QiD3oDT3IBhZmh39pFUKwxXlnDpHlqLLYa9ipWmj6sNQjqytqIc7CFrDjEa9jCtjLRdUC71KLShlJIayVwxT290M916ROIspyzs5cfPfRpLw5rlsqKtHdQVh60kkW1GVQ2JpD/qobOUenAjy65DHubwCprKYkxGmnfpLhha3XhPSoDdacoN5Yh50dBWkjRpMfKeXAeq6gC4hmxuL7meZ1gvEaTE25Ry1GPp8IBR8CwmydiNBJIsJU8EOIloZeweDGi1ChrncPUIkUhEI5C5pFjIEDKel/VwSFOWmDRDlBXNsMIsLuJDjVsZkc2fRlsN6eUdfO1pa0GVCHQ7Y7HIaGtFOVhhqRyQtrq051qkzlIe0XTbbZQRNPUQ3RY8bO8P8cP3uoBvHL6eC085G7NJljeYEjeqScLCWPRqjhAsUnpcpRn1+5g0pakqAhVpOyNNF/FW0K897UygiHaKUglMun4upKVgT7LB+0sZS6yHh2JPdr4IUjLy0R50Xm/RXmhHsZJNH3+O2TWKpVUZ7EET/52vdi1QClkU+OEAWeSIY+45Jo2itrW3GGS0Y9UZ1lsGzYDUK7K8vWU2WhtJUzuSLH4u78Km7h4zTozZHX/GXRKpFCrPsYMBzWiITNJtl75IadjMris+5o9bHr6aTqc1tsMQtLP1r5My2TKj3coMVkJVe6rlEidWSIqjwh8wbg0wijAW9diUtI1PWrgQvcZhnFVINVUTRcxEojCpjpnpTEW/62GDKgVN08RVznGZrs6OZlyn5eEyQJBIJafl4ZP3MULgZUpr31kUp5yNUIosy3DOcWQUvTwnpeGrEUlC4hxWQDpXkOaSum6onCXTcb9sCBRFvqUwXlmWKJVhjAIaFrNF5tI5fFnSHLwR31tGZ130rkX0/DxpUdBqtdBaU5Yl2mpkkFS2xwCPSDLCsB/785a+TysI6kaTZzl6cXFNcD39LEYhkrEImfVR8EzJddnrNedIHtXfw2hAqOp137EQgiTXpIVGaYkvKxAgJpN96/F1XGiSqZr2qEH0hrbWIoSgmxs62drJh/eeuqwwSYI26wMFpWOZuAwxEzzyIfrpTkpy6zjZ1+PJTpIk0brOHb8X+1iapllXHr7mGKQpzhh8PSI0DdZbpDHbCrDzsQ3bYJP9GrlAKndmGzgRpoM7tz3XXQUlYu/xxA8e4sKHbBlk22CNJM3NlpUGumjhmmYqPggQmmZd9tpWFcF70uO0Jm1VWQFj68TCYBYXsYMVfN8iQ0amLZec9ShOXTiNby9/lxY5l592CWHYxP7tYYNbqXHLI2SWRwGjJi5SJUVB2s4ZVSU6MTgzovRH6PVuRCFQIY4RpY+Cft7H0vdhrXHDmi4NVb/H4cOHsNUIIQM+aLJ2B52kMbi2nrTQJFnU8rA2WlxJIdFK0YwqdGsOrxu8dwTn4gKzlHFBQgqki9dtkhhMaqgPH4k6EEVBanJksUiqYNg7hEwVed6llRmELsnbFo9GVRbjUnRrEdkyVPVBAg6jNC0pqK0nTbvopMXS4AjYEusDIxUXW07d12K+5alTS6vbZffiIiZV9ITCS0fb9tBSUFUCFeZwHsrhCs3IkSYpWbH2nn+vvEXjLDcMllFJRmYSajugrI/ghRvbUaU4bRGU+KqmqZYJjaNUhvbCHPO7dtOa30NIs1i9JQJOGlyW09IaYy1FUSClpAk1lXToPN4bpFRkrTbF3DxKG8qbbsSu9PHaYLG4chmFQRSGTCryvE2tEkyaoNKUVp6xkBlcOeTQ4SVEknHqvkXuMZdRaEe7nZMqQyENWZKS5p48UcznBT942vmbBtfODfGMMEUXYXWsIBECredBCHQe0ElCU5ZIJTG5xJg2UibkNsbHIyVoaoe3gSQ/gfyhVDGw9g5GRwjeM3COTB6nLagZjb2vjz/Gz6cG5wO9sVDrSuNIV1XsTXelKKIQ6ia2XUnaiX3Y+TyYjCAUvbqHCNDyCSLbOgmkEgmB6Egz6b/Wswz2rcnsjj/jLovJo12XG40wx7HnOhYp0w37sONjciqGth20krS6XbJWh2wLkaPNAu1U1GijGFWWphqgcolZZbswQYyVj0O9deDSjMvIzapAITMKbT3D2sYV77EftpCSMFZzNkIThpZ6ZYRtLCpbOxGNNk8BGXwUN9vgsyYyZol0Mo8a+3ZrrZHGcHg4Ihesu9FAzOIaa7E+ILUha6WIJGqT4F0sx00z8i36bOu6xjlHnrcQUuN9ja9r7KFDuOUeXjToxV2Yhd1rMslSSvI8pxjf8IwzqMZzeHSEUZoTypLe4W/jByvI0IK8RXvX4rpV59VM+jf9yIIHtbiI7HQ2fT5E0TOSBNfrEZr1YiwmUehxmVmoymgrJGKvaahd/E4ndiJybFUUAkopQogCdplR69ST67rGO0+6weIQHC0TdzaW9gvi9zxZJGkqt8aayxiDlHLHvdiT8vCtguUkSVBFQR0sbjjABofOsuMGMRAD9EJNMhZrFzAaH7Ah7Ch7DRydcMmZgvjJgFICOxFMaieololiekpSu1ihkB5nIUTlUSXYrRIh8oMBQivkeFIbQqAuYy+y3GJM2glmfheiAFf2EFWKdoJUOZ549hPZu3gqj733o+nsWojK+8VYdE016K5B7+liFjN0HlX4SSWd3XOI3NAf3IyUDXWaYF2DGo0I3lKLmLnTbiV6ItcFy8MKlg8QbHTC8FmL1vwC8/t2kWQ5thaMVhq8i5U0k4xY08TSXi0USIEpLU2wJN1TEFrjbA9bDXBuiNZtQvBIk4wV6aJoYpolFLbkQFOT6rHAltIU87vxrqEaHEYmmlS2yVuQpAl2xSNGJbKTks2fQprupq4rXOiBaEgRmBAog2Rufg/Dumapd5ClYY2Wkt2dlFRLRs0SpBkLrXmSVCPzlFFYodsWdHLJrsV7IzWkXUl7vkPW9hRzCcVcss72KNcpC6HhcDWi1CnSLYFdofIGlcwhjMfWR0BJstbeWCreTvAygSKnXaSkUlIHCEJhsNSupvGKQkmSThs/KpEh0Gq1KDo5PjgaV61pzZFKkQhBlmbo+UW8g97hmyj7h1HZPCHUJDphLkuxStEEgdOaRAqWl/vcfLgH2nDK7kXmihRX1wTvac13sLXDjhpUVhCoCWFr33nvK6zto1SBzuO8IIzVtqXUaN0lhBqdRjsznXmkVCjVjgvF1tPKDUPrKIcNysgTt5tSOmayfcNocBjnA+2trmHXxJ8txM1WUxiFlpJ+7fA+MLCezgaWrULKcRZ7RLAb3O/TLo2tCM0IpGFghzjv6IR4399qwR6iiK6QAluPA2zBlvaZM3bOLMCecZdFt6NdFz6gdqhoHu263Dq7Lu+rHWWvJ8y3MhY72bay6McG2s71MGqZgR9hw5Cs3R1n2dcipECkklD7DQV8JthxhlGvGkyDDxRK0kgx9UNWWoKPnp5oQdotEJmitjVWOky6dgBfXR6upIorpMeQSIEf78NqRlKhpUA3GwddIklIpICmoSYKbRUmkMqYeVVpXD3ezJvYe09VVSRJEgN6kWBHPdyRJZASNd9FdFJ0tn7hYoLWmlarRZZlzJs2vqz5fjOktjXLN3+PQrVoOgu0FhdQ2wnoMh3LukdN9Ec+zrkhhEAvzgMCe2R503770DQE6xDjUvnQ2BhgZ2oa5E0XRnwMsIUQG2aUJ/3SiTLIDbLXsLZMXAnBnFZ0xhMS18ReVnNM6ZkxBmvtVKV+O0zKw7cqLRdCkGYZ3hiCsngjMceZaKymkBIJaxTFAcpxqezxvK/X7Y8SM+/rkwgto32b36DKpx6r8JvjCNFJGZWb3bjfODQNvqrX9V4H70m22Za0HaTUmPYcIawgUo30BamztHXBC/f/PA845QJ0J4vK+1qCCISyRORxYRAtozhUHatHEqWQxmNdjaxzgtAkxQJJoxiVB1geDKh6N1Mu3YArA8MmJ5ubo9vS5EWLuU43LvgRBdvSXE9Fk/K2WRPgNE0TF8ZcgODQjYcixxEw6QKehmrwPaRMUarA+xqls6kt4YrzJE3DfG4oBVh3dCwySYppLTAclYgQg7REpOgmpV5eQbZAtztoXQAKIbqkeQtr+zRVjzxAIwJpqwumxfdu+j5GwsJY2LApe4yaEa18F1pqrHesuB7aD0jTXRg9Rw4Ep2nCACGOWn1uNKYLIdjlLVLUfKdawQVHkS4yrBzWLyNSh1QFmjlUNoe0irBSsVKtgJZk4wqv0nmUMhAqhs6hlKGtFSLPEUpOM595nrFr33xcpB+NGA6HOOfwVYVbGaA6XfK5Rdq7duOqHmU9YjSyVOUKUqa0tEIlBisNDZLlIz2Weyvkecqe+TbtIju6oJSmJHkCTeyB1lkLCHi/uZCr95am6SFlgtad8TxGERo3VfpXKkWpNs4NcL5PCA1aR92CUI9dVjJNUzkG3p9Y9no1yhCyeUbNiLxeXjNXWscW3tebMZcoerVjaB0uBFqbJF5EUaz5LleTJm2QktqW1ASGdkjLtFCNQyRmywX+CTqJ1WfO+rFGxSzAvjWZ3fVn3GWRaYrQccVcb0NBfM1rxwHs6iy29/GmeSIBtlHyuBO39ftwNNAu0oRGDyE3Ux/EjRCJAgGh2txuogkBfcxAGupoTZPkmpXxa6UWCCYT0nijS7MMV4BLA0ocDZpWl4d7G61A1AafNxm/b7VqRXtgHQ7B7iLHObehAJYYi1TppqH2gSyLixXWWlqtFl6qNarVx1KW8QafTIItC255GZFo9MICXjlAIOXxe+uTJKHdarOvs5uRhxvKEu8TzK7TodOh2GaWU0iBzM0a0bPjv0aiFuagqvErKxs+x1dVnKQYEzPTAxsn19mqScc40A5jZXopJXaDVfKqqsBDYsyWGVhtFG4sDJUpOZ2QNOPMuTpmAjEJkncidraRevhGGGNQRUHVNAitt1UePmGaxXYeP17ACCFs2/t6I2TLxOqSGXc4E1GiYxf4IFbgHFu9sRFSKUSa4K0lVBV+ONZPWJW9bsoSnd562esJuljAuYoQSkynTZa0sKMV6v4Qmeg1vd4TgSQ5rt4SQqAyAy7grMO5Hko2JJ19ZKZNtbKCEop6AKNDfY6sfJck9Mnbi5juKZhWhz17T0ElgTAckkqBIC4+QaxkSVuavG2Qq8b+yUKaFiraj5UDkqxA5wW1r1EqJSiBLXtIWeB9A3jkWGuiqR2VdeR1hermZImmrAJ21SJYURQ0uo2tSiQlJszh+gMaY0m7bbTuTvcFBHm+G510cc0A1SyhVOBQ2SDyfQTfIJvDY9HLQG94AJMUFGkH7xsOjQ4ghGcx340PKegMXQ9QssCKyaK8xPuNBaqcbdDNMnNJQ+kFg9DCUDIqDyN0Rtbei8k7BAdCGlSroFm2lKMVlImL1FFIMlColNIOGLlARydRhVqImPksq2nmU0pJURTRo9x7Br0eowMHEGmCarcItUMbRZ4b0sXdKO2p+n3KlRJjGzKjWHKBI/0hqq7Ys9illafRvUFKmrFgWpLn0cFBCrySxGq/dFOnlBA81i6NS8Hnpo8LE1s4VtuPat2aVhYqVSBlMl7g8nFRKYBxgUZH95JbylAamnSeVmhgbFG3wQeI9lwm39D7ejO6icZ6z4FRgxSC1ib93RPNB19WhGPulUoqlGlRuoqeq0hkQq6y2KpynPLwCdPqs8YjZ4vAtzqzIzrjLosQgmRujqS9tdjDxq+VUwGyCTHYFjsqD781kDKhky6Sd/YgWotslfOLdheKYD3BbvzMJoSYDR4TfCDUHpFKOnnsDxrVDqUkUo5XOMfZTSPN1NLFrMqiVzba2AjnEMh1AdXq/TNCTO2QVquGt9J02uu8UWYz9mFb6nHWNc9z8jwnyzJKv/Yzrfm8TYO1lmxcKhzqGnojhNHQiZNP50dImU1F446HlJKFVovd86egdu1l7h73xLW7pFJsvdp97GdSUS042NjnvlXlwfS9swTRauGHI/xoAzXjskSMFyBC7QiNRxV6nUoxQkw9tbXW6zLY1lqapiEd2+2wxedSJvZz2dW2Hz5EkaMNgkspJcYY6npztf5jmWbBjoMQgjTPodVCjvsQd0IxDg4GqyzHtut9veH+zDIDJw2Ta9MdE2A7H3A+HLc8HJhWzASp8MMhvqym/ZLAmmDj1kYlLUSSYAdLCCVpz+1CFYbKDdCren1DCITRMFoBrjpvhZEoqShXDuJ9SZbOgcxpd+dp6RaZTEmKApXvxuSBVqFJskVWak+mFUVaILIEOxrA2ClgtGqs1kat61+fLowJiS9L8B7Vak3vJc6NosI5OU2zRFUdoLEr+NDgaOiXFXI4IJMCVxh2tTu4pqZXHl0QzIxCJjlDWSAYIeplalERCkORdxHiaKn6xFFAJwVazhO8xzeHOdhfplW02btrD72lG/DOsVIu4V1Jp9iDcyOWy4M0QbCr2EOetWMm2BRIazHC40WO90OE0LgNW8xqRv1voURgvnsKRgpuHh3BugZJAdlidChJ43EMpUUWbRoKXD0Cv4IRgtKHKLioUvpNhRKC9qog7dgs9gRjDEWWoUYjGu8ZKUU9quLCR7WCbqXoVhehJXmxgJSaarBCUg2pRiNaoeGU3fPTcThJkmjNVpaYNEVKhS8tOlcII2kqh5QZITR4v34B19rlsWjl/Jp778S2K9qPrg6y59C6g1LjMvLGR9eTRFGXjpZSmEQx2kQ0cLuEEBg6T5bk6GIh9liXy+ufaKvjel9vRDvRaClYaSytDTRnViPzHKFVFP07hiTtUuFBGTpJh1DFc26ivXI8JtVnMPO/vi2YBdgz7tKki7vI9p1yQq8VYq1dVywPT+6QybIQgk6eUyvNgdpyc9VwuLGsWEfp/JqeUWHUePV3/Q3Nh3Ff3arPMOnZFmMLiUyrmMUWsUw8uKMZ7NVB9WqLjbJxaBEDLCXVlmqUkz5sYJ1qeDZeea2q9ZMTYQzG2bFdkmd+fp75+XlciP2x6QYBUAiBqqrQOtpLhabBLi0hkgQ1vzi+8VcQ3LaV4Y9+DkmiDbv23of2wqm4EP2Ud4owEpFpggv4wdh3d6sJghTIJENkKa7fXyO25Oua4DwyTeP2ShcF8NINerxWeQGv7sOeUFUVSim01LHMeYsAe3KjdvXR/baVAxHL0DbCjDPs28liW2s3VQ/fbNsqyzDbnGisRo6z2MNxFntH3tczTmqEiCJ19pgFvMq6KMy3zSyOUIqQGEJjY/Z60o7hPU1VTYONWxshBKa1gKtWCHXskc26u6kLh0gtzpWx0mo0Iviwpmwd4mJP0EOacoBSXbIkxzqPVIpdu0+lNTePaSWUakRLLpCYOZYGBwne0c50dL7IWwRR40cjMilxYeOKAGB6fWut8bUjVCNkniGSZBxglzRND511UbJFNbwB63oIorBa7ZdZGRxAr9zASPZobI9WIslUw2DUZ1gdHTuKRFGJjJC0EYllpBwmaaF1C2AqrDipnhFKILyith1cSMjVEC9WWJg/heAaDi3fxKg6QqELgvCU9TKjkNJJd5Gpo8KJjQsEEhJV48kBEbPYwa1ZoLd2haY5gq9GpPketAq0WCHIjH6TkeuUZnzOCC2RmcJXHjuoqLOCpD2H6x1EuYpyPCZpqenbmpaWa8Q9N8piT74P3++TJgntU05BKcWoN2C4vIytV0jmumid0zQrKJmTd7rk3S4treiYwN5OC5NmsW1onL2uJ9VhWY6vXWw7yjUmVdjaIUjYKKNvbR/va4zpbmh5KnRsdfClm87BhBAodXQxK1QuPsfFxdw81xRaTe0iT5ShP+p7jckh60I9hKq/9olT7+udl6R3xy1X7W0od8tWi1A3+GN0S5KkgGKRdtpFSUWoqm2Xh0+Y6LbMAuxbn1mAPeMujZByR4PNamIpeCCEetyP3WyrhPi2oqsVexLNvI5iJgIYOs+SdWuC7r511CZ6Qa5e/YX1AmfT7HVy1KO3lSp8CAxrF/vogpgG2FpqBAIpZPTF5mh5uJHxJpekZkuxjEkf9nJj16mGSylJ03SadV6NSBKMkMhxmfiEavzvjfpjq6qKvtBZRrAWt7QUba/m51EqjZYkbjT2Nd95ZUKmJKX3DJzHCLFpifrxkIlCtk0MtH3ADxrcoNmwCmFiiyaLNsKYKHo2/n5CWU4VyeMCS1jz3a5BHc1gT/qwJ8e8aRqcc6TjQH07Al2ry8RDCDRja67NFqSUirZd2w2wpZTbDrCFELRaraMtATtkdRa79oF8FlzfZdBSrMtgV43H7KAFQClFULEdZ032uipj9noT/9lbA513QQbssAdAZtrRflG6qTDmaPnbWDXE+igc5n1FCJ6m6SEShxItsBotJYEYJAJ476jqZWyiaIkFBHMMak8iV5Bi0g+b4RPwwyGJiJPIchMthenCmNL4/iBW7LRj9jFVKc72qX1NUOB9iaaL0fNk2T7SdC+N2UVSawrVwmYZSkqMFiS6xNdHONS7kdHoZur6MEYMcW7ECgprDJVIKbKjZccTobWphoOU9IcNw9LS7ezi1O5eKldSU9HOcwYrhxHlEKMFPlQMaWFMh+7UZjOOR82oBlNglMc1DVq3AUcIccEjBEddH8a5AdKLKAZmBJnOSVWL+aRNv6rxSuGFpB4fS5kbhIJ62BCUJNuzDyMVzZEbY8m8FCw3NUEYuhuoP2+Uxfa9HqFpUHNz6CQhz3ISnWDrIQNX4kSCTiUuNAgbF12VNszPz3PP3Yu0imIqTpkkCd47mqokyaLw3yTgFUpOdTds41EqW5PRd240FrTrbNlyJ1K9qXDrJHtNIqlGFqUlOlEUUuKJQfKJMM1er65GS1qQtqFaib7TEL2vbXVc7+vNmEs1Sog1/tebIbMMYfS6ioRUpSxmi2Q69sH7up7aBG4XncjoPnICyYEZWzM7ojNmbIKUGoSKatPjm8PtXR5+LEoIMiVpa8WC0exNzbqgu/SeZQKHfODmXsmhuqFvHSPnqY4ROJsE4Ku9s7WSZEYxqC3ImNGzY9VqIQRGGbQ4GuhMysMZl4dvVBK8mkkf9mgsrHZsUJokCUopyrJcswottEZIgbbNNKgGqHwMbo+1T3LOUdc1SZIgvMcdOQJKoebmxn3HyTjLEHu6ToRUClyICxcnkr1ejRACmShUO4kWaSFMrXZWL5TEYFdE9fFuF0LALcdSu1BViCzDVy76XJtxgLtBgCyknIoIxcyAmgqJTbL+U2GibXy2iWq8tR7bjK25NsleT5hYdm3U/72a46mHb8QtqTRRQpArGTMhRPuxGXcNopL40fEjhEDjttd/PWFiv6cWF6dZ4qOlstkJL+puBykTVN6iGS1FGzClQHUxZhdJsgftchQ5qt0lhGacOV1iMLiesvxe7AuXnmqlhxIxc299zPg11WFKbzHtXeRas9K35Ok8eSJpmiNjDZIcmSZ4V0FVrSsTX03TNCilkI2Lytbd9vTYBF+Cr6hsCXh0ukCqFsdBV4YLgVEI5I2PvecypZ3tI012026fRjdfAHKG1oxLwBuMHNEbHKH0FqkKMhPv15NM+mqBxH5jGZaWItF0ckM7KUiTRQYoikyTuAFy1AeTUokuTmbrLCSNMbja4pQhSRNCPcCTIoTBe4f3JXV9aCx4ltAMDxIkZMU+WtlelNJkwoG1OG3wwVOOz83YPmQYDpq4UKkVxeIpDJshzfIRjIDlpqTQ6fSeuppj+3fdygBfVqhuFzE+DsF6dGPJC0PSyWkawagaEKTE1s3YIz6SKH1U9DKJlXz1aBTnBFkeVb/DWLyTWC2hx2XiQhy913pfTxXDj3ffFUpEz/rKr7Om9LUDJbE23sNMHq9JLQWZFAxPMIu9Jnu9mrQTA+2yF7PZzTC2WW3D+3oj2onm7IUW6Vb+2quQ7XbMYh9T3afH2f9QVfH47zDAFkLM/K9vI2azhhkztkDJFOerVeXhJ98lc2zQvScZB92thFxIRO1j0G0dQ+enpa4bZa8ntMcrx5UPSKmw1k+z2N2kS9u0p88tG0eiJHXZoLTatP96wqQPWwnobBK4ZFk2DfTWvDZJMC5mvn2ImdLaB7INMozR81phlMItLY3VwuenEzwhEqIayvbEzTYiHatOKxGz2bcWwowD7cKAEPiRxa3UscwyhPiGziPGCwahbnBLSzFYNmnMJEyyx5v1AK9SEgemAfakL3qSvYbtZbCFFNETu/bYiTXXcY6J1hql1JaWXVORpB0G2LeUiVjdTr2vZ5zcaCnWqIhXdnv2XKtR45LQ2AkbOVoqe9tXOaliIS78DgfTyp0l6yg9hFGDyedIskWSZBdpuhchDFImJMlujMkgcTT1EZrRQYI7yHB0iKY5jHcWK7sUSUqjBE1l6RhDmizGTHdzJAZuJsNrH8vEVSwTb44NgLyflmTb5T7CKGQrBlTO1VTVzWgRcEiSZBGdtcE5tG4hRFzckuWIzGgaJQgEUhWDB601WVaQK0PjM7xokyS7mG+fgjYLjFwHY1rTRZNJJn0SYC+PGka1o50qWquCi45OcWqeYOaYS6PbhJO7GAZFe4PFYK01+IANDpO1wFbjkvgOUiqcGzFR3ApuCBZ0fjpJEnvQpZDIZhSzrkpTexjZo4updSpolCQJYF2gSDo07TmUXWF4ZIna1cwlLcCvczwBohaHVrheDz8YIFutNQJYvmzw9QiRa7JWi05nEbB4mbKy0sdWa8fluq6jtk2S4J3DVhUmy8ZZ5qjjsnouYcbWod7psSPKkKZZRkoz7aM+HiIdC7euankL1sf7n44BvE7Xiqq2lMIFposV22XD7PVqsm7MWJfLMZO9Te/rzVA7qIySSYJIzKbipqGqEEZPF/9m3PGcfNHCjBknEUdXXusTUg+/o1BCkCeKdmGY84LdWrM30SwYRXc8AIdmvOK8weqlkvH1o8YhdRQ6mwTYm5WH28aTZdvrUZ83ikWjN32uUookSabe1ROEMaTjLGvtA3WIU9xj+68nr0uNwS9HcZLVwTUwzWIrld+ihZOuVsxtcxV6pwgto1dvy0xFb/xKLB334z5tkSSoTlzdFkYTolButDpxflpSvm7b40z4sX3YVVXFHmalYhkcbClwtho1tv3wbr0112ZMLLs2sgmDODmOKrO3b4Ct5VrLsRl3DZQUBJiqUNcu2nPpHSyQTcYRPw6GVpfK3pbZ6wnatJBpgh0uoYSgqxU+wJHhkJvKhl6SUo4zeNZGW6M03UOa7sGYBbJiH9LsQoUuSdLBBYkQkkAHJw2pFPS9J000xoEQisQsrAqyDWQKX9eYptmwTHwS1Crn8KMaNd9BCIH3llH5HUKoKLJ7IHUHF0J0PWjia2KLUkPe1Ohui9JWaKmn2TqI1S+JFkjv6JeTUnRJqg0BTbLq+5xm0qVkaVhTNo5upikSzeoQLB87IJRmgaK9j6S1j0ODAVqIDSuUgvUYrbHBgSnQStGMVsYBZGe8cOsRQmFCDqJAZ0dFVxOVMKoGtBODURoBrHhP5T219fQrR7aYxUBsZFGAMx2SdkJvOEQOe+TjHvOovr6WSRY7WIfMUlS7tWbf/coQoQVkUe1bCEdRZMzN78EFz/KhI9M2q0ml0ZrstZSYNIvBr1g/l5AqCp42Zax88L6eKoZvt8JIiLFt1yrh1lA7kIJmfA0nx1TNGSlIpWBlk3vKZmyavV5NPg8mOyFxs1uKarcJ1q0TNw0h4Ktqx+XhM25bZgH2jBlbEEvCJ/3Bd77Ba2rbVTukEKRSjr1gN89eT2gl0ae5jtalGwZAk/Lw0FgEgiTd3KN4NUqINaIsG7G6VPzo50mQCJRtqEOg8gEl1np6TzyvjdbQ70MIqIWFDVd2jZlH68629nkzsg0yG7c2QklkYZCtBKFlnBz1a9yomYoZqXYLkhycjyXmELPTW2Wfx5lwONqHPclQQLTxOp7A2Wr0OGO0kTXXZpixSvlmvdjW2i29r29LJhPuGXcd9PhanZSJV40n3ea5OkEIgVQK7+OY2JTltFT29kAIiS7msM0QX1UUSrI70Sw2NZ0swWnDknV8f7TE4WoFK9trqnSUiiXHMmgyWYDsoNQ8pdNoJWlsbPHodNOo5Gz9miDb+xHCSIK0hLIklWJdgD0VN1vuI5MEVWQ4VzIafYcQGrLsnrTSXQDUrkZMFtCaJrZmDIexNaOVU7ualLX3X6UUxhgS6XHOMxj36RbjYGuSvfbeT8eQpWFDbT1zuYm2e1IgJGvKj1tKUckEl8xRFfM0dUMHv2FAGKzHmASUoLEWkxU01RBCQOs2SqVoPUdiFhC2wslkjZVaIhOapiJPNIkUaAGl8xwpG5aGNUZJFjoprjCoEKgGNUpkeJ1gC8iqClU6hFCEsPH4KbMMNT+H7K619/SjGl+WyG4Owk8tsECS5R26iwvQWMqyZDAYUFXV1P3BWYutq6iU70I8P9KN9TZMqmK1nE+QMl2nGL4dZHJUuDWM389Lga09SaY3vD+1xpUV5TYVxUMIDKwn344TSDYPxeKOvK9vDYQxyCzFDwZryt9DXZ9QefiM25aTNsAOIfChD32Ipz71qZx99tlccMEFnHvuubzwhS/k5ptvvqN3b8bdhEmWUwg9tfq4MyGkQCQq2jW51QOy3zR7PUFKQSvRlD6qKTu7PsAuG0eqFXXVYIzedlC1rX0XgjRNcc5NS8UnfdiJtVTjlf5js9dlWcYJzmgULWHm5+8yZVMTWy/VTRBGEUqHX2nwpUWkOcKr2Het5bR/bqvybqHEdHI5CawndmbAtgXOptuTApMpknz7x3vyvk3TrLNnc87dIeXhM+66qLF/s/PRS9mH7dlzHYtUGu9czF6XJWZsjXd7odIuGIEdRLGzUNeoxtLptNmdaObliIySINv0fcKB2rLcxHEzirSBJ6CmmXxH5Txawqh2tFKNThUoOXWkmATZiFj+HIzHVxWpYE2Z+ESxW9U13npEq6DxPer6ICE4svT0cSm4wEhD45vYFyzA1fU0e62KFrWM2emE9YtsSZIgBRgZGFYW6zypVnQzQ26OWnOFAP069trPFYbMqHg/lGP7wVUBdi5j+9KSzKl1SifR+GoTH2frUYmeijWarI1zHl8NEEJizHx0p2iGOGcJOl8zlikvwQe8igGhFALt4freCCUF80VcfKxFIGklVC5gSkdNhtYNpl2gRhWhWqtYfiwyTdecm8EHXG8lWnqmitgmlY5b4WKQlrZbGKNJZQycnXOrstdDpFKYdKz3IaN+yIbnqZZILbB1wJj5DRXDt4PMYjm+HzUgYvZaKrGp5ksiJUaIqd3i8Rg6jycusBwXIW734HqCbLUI4wWoCaEsEVodXaSacVJw0gbYN910E4973OM455xz+Ld/+zc+//nP88EPfpD3v//9POhBD6LX693RuzjjboLWHYyZv6N344QRiRwrfMZJUsxeu2gPdZyV2iJRGK0Y2UBdrxWimpaHi0BTWdLs1heA01pPS8UnwZdIEoy1uBAndavVwyfq47qqEJPg+i5405FGIVONyDUilYQm+mhPSsNhnH1ma//qyeRyshqepunabLHfnsDZapJMT60/tsvkPY/NYk+Uf2cB9oxbEyWj0FllPQLWlBNvF6kk3rk1pbK3J0qlyCzHlf3okDAYxKx0mmJtH+FHzKfz7Ms77DaaQknqEDjSOA5aR995RsKjPAgP/cqNs73x+BTjgEmmKo4RE0HMcZAtZEqtVqLVUlmtKRNvmgbhPaKsQGus6E+FQpNkEbNKwyNRCbWLwaEwhlFV48fZa9kqqH20I1N+/Tg2yWIbHEIw9cbOV7kXVFXNoAm4EJgvkqOiUj7Ee6CQaxafxdimz4ZAIgVz7TauaXB27dgUXIjb0OOsrnPRPcNkNOUxfbL1EItG6nHrzRhvGxKd4oSPzgUh0NQWB3gdq4km1ppKSZpM40NAlQYdLDpPkEVOWKlw5XDbol5+WOLLGjXXIYQYVEenFDcNsHVqUCbBlTWtVouiKNBaY5sG1zQkeRHPCedj8LsFJlV4G3AbuGJsl4ltFz5giVV1Sb71+7aUpBnbem5FCIGB22b2+g5GaI0scvxwSBiLE4a6RtzO48+M43PSBtgACwsLvOpVr5oOSPe5z3146Utfyr//+7/zf//v/72D927G3QUh1J0yez1BCBFXqsc9TBN7C3Ecte/Jazu5wSEYjdZOMKbl4TY2/ab5bVPGm45X3yel4hOhsxCiIvpEQTWEQFmWiMEAHUIMru+g0uLbBSUQPiBTPbX4ksWqcjnn43O2yKpNn7uBGExwIZ4nt4M/5tTy5pgA+0TUw2fMOB5aStw4wE709u25ViOVJniPrSqSLL9ds9cTdD5HoMb2eoS6QbZaWNufWiApFUvWtRS0tWJPYthlNC2taYAjwXGzdQzrhuWywTtPENDJjupjTP2Iq9V+xIos3YeQkkb28aOVNWXi1lpEWeIpsXJEUBIvNA6NVx1GzjN0noF11F7Rs5YD5YhlBIOyImtqTKuFD57a12RpviYIXk06LotNpadxntEqS6eqbjg8rBBas1Aka5Tigx3rU6xqk5lQSElbSea0wiQpUinqY/terQcE6LgAKIQgeIdIWjSNhWac9bYVeIuT6ZrgGsDWNVnWovENzgfq2iGlZG8r4YhzWB+mlpSeABJcrimUgFIhXINst1BZgev38NVaG6fNcMsryEwj8oQQLFJm4wUQscYpJSkybFnjbDPd92Y0QmqNMgZfuqOB7xZooxBS0FQ764k+FpFp0JLGeZSR0UZ0CzIl0UKwcpws9iR73b6NtFRubWRRxL7r4ZDQjNvE0jvW4WbGek7amcspp5zCjTfeOC1VnHD66acDcOTIkS1fX1XVGgXiScbbe7+uDPFkwY9Xo+7o/bvkkkv42te+xk033bSp8NCMOxlK4AUxyxniqnsgrLO+2IhUC5JE0RuM2GOPZsFHVUNqNOWgQo372W6rczdJEkajUbSPUir2VTc1KkniCu44uG6Wlii0Rna7BKWm/tB3NLfFNRVEwFsPfjwp0FG8afKZXROrFLb6ToKI401o3LpEd7Bu/NqAuB2Oo9aauq6nImuTMtPot7rz9z9ZxtMZJx9CBJrG4UOgk+kTO0dEHO+ElEhjTvg8uyXnqRAZITXYso/SOY2o8E0MroXINtymAlpSIBND5TzCCFZGjmHwyCBot1PMMWN5MAI/sIRqdSmwQqtdNPpmquFhVJnT6JTvrwxZWV5CVcuIPEfbFBEMvuxH4a/aAxPBTBAIrAsMbUlLKnTw5EITsoxRMyL4QKJTfOmgcRsu+CmlYp+1TOiNaoxM8CFw05EVQoBdrRQlmH6mEOLYKbQAEfDNqnF0TCFFtEoMAZ1mlCt9dFqhdFy0dbWN/dvjRYfJ+CWVoW4UvuqDSqBaISCwKDJ5dDx21uKsJWsVHG563FD1yaTB5BobPD3rOVLXJFIigqdygmZsSWlyAZVBjQK16aG7C1Adojp8M+nuZMuqLTcc4UYVet8i1g7Hivoaa3sIYab3UyAGbQHKwZC01cLWNU3wFN05XGkJziGz7Y3PKhHUQ4u1sdpAEPvfEbFlQ4z/I8TYYlFs8BjREjOEgE63vrdNyAUsW0clxNRBZTUhBPrWkkqJGH/fJz1CQJbFqpW6JkhxUs137ihuj3v+TrZ90gbYwFRoZzVf+cpXALj00ku3fO2VV17JK1/5ynWPHzly5Lieq3cU3nv6/T4hhHULC7cG119/Pe94xzv4zGc+A8DKygrtdpuHPOQhPPaxj+XBD34wxhje+9738vrXv543vOENHD58+Fbfj1tCWZa8/vWv54Mf/OC0nPUlL3kJj33sY2+V7f/e7/0e97rXvfiRH/mRW2V7JxPBBRiNz/1CI0bbz7iEpuHQ4SVS4ylyw5HlHlZVdFPNcGmFop1z+PBtuxhTliVLS0sURUHo9fBlCa0Wh8f9YcMDBzHB43btQmxiZXFrc0deU6HxUDmo1quxhxBgYCFViOHWY8no0ApveOtv8cEP/78119R/vPTRYAPC3n63idFoRK/XI89z6rqmaZqpNcxOua3H0xl3XsrG0x+3zMjCUJ5gWeio18NkOZXfesF/K27pedpUFr98CFV0CS4gVRslS2DjvuEJk+urKAqKsmY0slRaUqeWwxvcG0LpYDlAcbT8Onoae/xKHzkYUM2dxnC0gl36PkXewqguwjt8uBElNNpkCKLq+OprOmkq7GhEUG38Sp9+USCOHGGpWoquFUbG8WykEBvofIQQGA6HKK1ZsYJ+Lwbt1WjIrm5Ob3lp7fMn98I89vVSOag3d7UAKPt9eisDsnZ77fhaHhVTGw6HOGliJc7gMD6rkeUSjcoZuZJWq3U0UCxHNFVF6gPfW15CiwGndeewVWDZeiof+O5K9HSWAmof8AHmteRgKCnrEdIZBv3vozu7cF4SekvoFYs4xjFjNe6mQ+AFqspoBocRaJQ6iLWHx8rnR+/jwQeasqQZLZPOzXH4wM10ul0aRPz8RiLs9rK+IQRcE2JAH44uTIQQ/xP/f5yNiPgcnUoqt/1sc69xjKRgboNWkKHzDHxgUUsO34nsGIP3hKWlWMmX5zMrSW6fe36/39/2c0/qAPtYmqbh93//9/mpn/opHvCAB2z53Je97GW8+MUvnv7e6/W45z3vycLCAt1j1BRPFryPSpULCwu3+slx1VVX8TM/8zO88pWv5Hd/93enZVVf+MIXePazn83v//7v8573vIcnP/nJAOR5LC1bXFy8VffjlnLFFVfwxS9+kU9+8pPs3r2bv/mbv+E//af/xFVXXcUTnvCEW7z9P/iDP+CSSy7hp37qp26FvT35mIjVHK9n6lgWFgKjMiCSnMXFDsPG0y06dJRAO8nuUxZQt3F5VQiBwWAQLbx0LM/UCwsA9G68kaRV0N63D3U7+NDCHX9NBefxgwZZmHUlesF6vGmi6vhxSryv+M/P4Yv/tv6aes+f/iWPf9yPRC/u2wlrLaPRiKIopj7m2Ql+n7fleDrjzk3jPGpQo6Rgd/sWiBXdCtfyLT1Pnctp5tsIKcdl4duzDppca61WC184ODKi3U7odDe+3oIP+JUakerYl00ck+taQ8vh+kvIwtKvS5KF3XROPZNQgqUPyQJJsmtT9ejc5vTrPgv5LsTcHCJJsN5iS8tcOkeqUlzWIKQ46pBwDO12m7qumU9y+pUlOEs+V9DptNcdV187QuqQHQMe/KDecBxdc7zabcqVPnm3g/CSYCyynazRMRkOh9TWU6Fps4wWAfIFSj1H4T2t1lGbrGFvGTpdhiJhj5RkqWdPaxchBNLG0rcONXb+kEDfOdpKsicx9OplOnTo6DbV8k1IoZDdPbi5FnqgQcronHFM0OUGA2zWQu9ZRBR6rPQ+Dzis9STJnnXfkU3ajEY9hFFURcHeU09FOUVI/NQ+8tYkTIPt+P8QJgE54/+A3kSxfDMy5+lZRzfR6NVibyFgG0tXSrp3kvLw1fg8xw8GsR1ug4Tk3Y3b456/k5a1O1WA/eu//utkWcY73vGO4z43TdPphHc1UsqTerIVVatv3X38whe+wDOe8Qx++Zd/ec2iA8CFF17I+9//fu5zn/used/J4HUyHauPf/zjvOc97+HP/uzP2Lt3LwBPetKTuPzyy3nRi17EE5/4xFulD27yHdwVkcWJD8LznZxe1dC4QG0D84nGlhVJajDJ9oIwHzyHhodOeB8a31AOS1IhEKMROnWUy0uUyz3ae3ZjwwBG2+tDW82uYtfU23s7nAzXVBACpEew/nz1wSOVQh1HbOzjH/8473nfVfzJu/943TX14l/9ZZ7wxCfcrtfCRNCurmtCCBhjbtH73xbj6Yw7P8n4vMgTdVKcG7fkPBWiIIQRShXbDq6Bo33DIWCyhD3tgGmZzX28JYjMEBqPSI9a9xlT4GSJrhcpB31Uo2nvOQ2lUxrfQyQWkyyi1ObTzUxnDOwAhyMdL6g1rkErTabH6uxGERq/6TFK0zRqNgjPQivFVgEp9cYT4uAJWsa+YgVIhQhb3/eTLMPWFU1ZkumCYPS6ReUkSbBuBAG8aSHdAJICb9eOZd47vHWMpEIYwb5umxXbw+EwytBBMPABhSBXipF3CCHpGIOSEhccLdNCG0PodrErK4gqQSYCNd/BL/UJvR5yfn563wkhQH+IynJ0O8f5AVIqtM6wdgmtsw2/I50aTJNiQ4NOErQyUDtkbpB3kqC0JQRDHxj5wNyqe+LATo6rvlNmgGWng09T5Cy4nnJb3/N3st2TIsD+zGc+w7Of/ezp7/e4xz344Ac/uOY5b3zjG/nIRz7CNddcQ6dzy3xr7268+tWvpqoqnv/852/497179/Lyl7982t++GX/3d3/HW97yFr71rW9NH/u5n/s5nvvc56456T784Q/zqle9itFohHOO3bt385M/+ZP87M/+LBDLaF/2spfxd3/3d9En03se9rCH8cu//Mvc97733fT9/+Iv/gKAyy67bM3jl112GR/+8If5zGc+ww//8A9v+vprr72Wl73sZRw6FAO8oih40pOexK/+6q/yla98hR//8R/n+9//Pn/913/N/v37AXjxi19MmqZceeWVfO5zn+M3fuM3kFLykY98hC9+8YsIIVhaWgLg05/+NL/+67/ON77xDQDOPvtsXve61023td1j+Cu/8iu8973v5Rvf+Abvec97uOqqq7juuusYDAb85m/+Jj/zMz/DG9/4Rt7znvfwne98h6c+9am88Y1vXDOR+O3f/m3e/e53I6XEWss555zD8573PC655JJNj8/xaOUJK6OaXmlxIWAEDCpLsYMM0KHhIfa+ce8J78Ntxc0vuZk9rT3bfv7Jck399BU/BS6sv6as46EPfigv+a+/sq1r6lGXPJLgw3TS/KhHPYoPf/jD/PO/fJYHPvhBG772zW9+M7//+7/Pl770JX73d3+XL3zhC/zjP/4jN998M7/0S7/Ey172Mv7oj/6Id73rXXz961/nUY96FL/7u79Lu31UQTiEwFve8hbe+c53ArFs9YlPfCIve9nLaLVa03P6yiuv5H3vex/OOZqmYd++fbz2ta/lh37oh4BYWv7gBz+Yb3/723S7Xf7gD/6AK6+8kq9//evs3r2bd7zjHTzoQRt/jhl3P4QQdDOzRvTqzkq0udu949dNJqHOuajE3U2Pm42Mlo8+ulCMq6CkTHFuCGmGH9YkSYbudHBljXUDtGmh1Nb3CCUVSigqV5GOnzuyIxKVrBFbm9hNblSVI6WcLtDlWlN7R5pu7EsenF+brZ4KnW0dMCZZzqjfo2lqTHt9pt8Yg6oqQu2o04xMOpzK8XW55v5sq3gfNZ2ChSJBS8HACmpXY6Qhl1HJfLlxzAnFwAUKKWgpifWWQMCouKitTRuXj6JV18gR2tE9wy0t4ft91Lhi0w+G+MahFueiXootx97oAe9rtN54Xi20wJjY026ynFC5aP95K1py3tYIEY/divO0Q0CNF5YGzpMriboTBtcTZsH1yctJEWD/0A/9ENddd92mf3/ta1/LX/3VX/Gxj32MhXFJ6O3Jn37+Tzk8uu17kUMIDIYDWkVrw0zsYr7I0y94+o626b3n//2//8cZZ5zBvn37Nn3eS1/60uNu68/+7M8466yzuOqqq5BS8t3vfpdHPvKROOd4wQteAMSe1B/90R/lwx/+MI985COBOBF/1ateNQ2wX/SiF/Gtb32Lz372sxhjuPHGG3nEIx7BD//wD28ZDFx33XV0u1127147mTjzzDMB+NznPrdpgN3v9/mP//E/8qY3vYlnPetZQCzx/U//6T/xq7/6q5x99tlcd9113Oc+9+GRj3wk/+t//a81r//xH/9xhBC8613v4p3vfCeveMUr+OY3v8kP/uAPAvBP//RPXHLJJTz/+c/n6quvBuAlL3kJj3jEI/jsZz/LD/zAD2z7GL7hDW/g8Y9/PJdeeim//du/zV/+5V+yd+9efud3foef+7mf4ytf+QpPfvKTeclLXsK//uu/sn//fvbv3z/9XP/n//wfXvva1/L5z3+evXv3UlUVz3jGM3j3u999iwJsk2gyJWgaG8VHnCcET5rfvQb4k+maetb/90yC9euuqe99/dtc+rjLeeBDHrS9a2rX7tiLOJ5gn3mf+JrPff5fNw2wX/SiF/FjP/ZjnHHGGbzjHe/gPe95D29/+9v5wAc+wBOe8AQOHDjAwx/+cD7+8Y/z/e9/n3POOYczzzyTV7ziFdNtvPjFL+Z//s//ycc+9jEe+MAHctNNN3HppZfypS99ib/6q7+ajoOve93ruOaaa6YB9Z/+6Z/yqEc9in/7t3/j9NNPJ89zrrvuOp71rGfx3ve+lw9/+MN85CMf4dChQ/ziL/4iT3/60/na1762TsV3xt2XfBPf3rsTSqmp6OJ2Sn2FFNEWsPKEJC7ISZmAUFSiwgdPMb8LIQS2Wh5bWG2vJS9RCZWLwrSNa/DBk6lVQew4qA7OIza5jo0x1HXNaDTa1N4vhLBmrAMQSkRNi+OgkwSJoimHJPPrqwUm7xnKEutTaC1gqwohxHTsCSFwqDckSMVCK8OM+4IndmUtE+d/c1pzpHEsNY7GB+bTsSe2r5FCYqQZv6dEmwIrhjBS2MGItJujul3ccg+kQuYZbmUFkeSozOB9QwgOpdKpf/bEnmsdSiKlIk/bjKoj0fu7ld4q1YK3J4WSDMbq9R2tGDhPIFp5zZhxW3DSn1m//uu/zoc+9CGuvvrqaXD9/ve/f0MBsxnrOXjwIP1+f8tAYLv82q/9Gq985SunmbXTTz+dpz71qdPsE8BnP/tZ6rrmrLPOmj723Oc+dxpcA3zqU5/i3ve+99T79pRTTuENb3gD55577pbvf+DAgQ375yePHThwYNPXfuUrX+HIkSNr9uspT3kKv/Zrv7blex7L+eefP+31PuOMM7j22muBmHVutVq8+tWvnj73Va96FSEErrzyyulj2zmGq3nyk588Ld39iZ/4CUIIfOlLX+I//If/AMRy5HPPPXca1EM8vvPz89OFiDRNefnLX85jHvOYHX3WY9GJwiiJEZAbRVU2aCPvdjZKJ9U1NfaxXn1NBR84Ze8+Xv+6/7GDa0qsscHptGM24+Chg9v6HJdeeul0/x7/+MfTbre55ppr+LEf+zEgViU94hGPWHOefuMb3+Ctb30rz3rWs3jgAx8IwL59+3jZy17G3/7t3/JP//RP0+d++tOfngbXAE9/+tMpioI/+ZM/Wbcv/X6fl770pdNSsac97Wl885vf5Prrr9/WZ5kx4+6ClNtTYl6NMAoEhLEdlveeqvRU9YD8lFNIOx2aZgVvG0w2t+1ALFEJPnist5SuRApJoo4u3gohQEnYwkt5ksWetJds+N7jcW51FlyoqBi+HVcNoxOcdzi/sViuMQYloKybKOzlHEqpaTn+kUFNVdUsdltrKigSldD4uLAAkCsZs9jOkY0z2hAXHybB9QSlYlAuMk+QFj+0CJ2g2i38YIBbWgIbkEUOWo4tuSRSJnhfIYTe1IpUSAFSEGyAKmb+70zZ6wlCCHIlGTqPC4HhXSB7PePk5qSeGb/whS/kj/7oj3jd617HX/3VX00f/8QnPrHGguu2ZqdZ4xPFe8/hw4dZXFy81foHbs1Vxm63y2te8xquvvrqqNipFDfeeOMay7QHPehBtNttHvzgB/O85z2PpzzlKZx11ln85m/+5vQ5l112GW9729tYXl7mmc98JpdddhlPetKTbrX93IhzzjmH0047jSc96Un84i/+Ik972tO48MILec1rXrOj7Zx//vlrfj/zzDMZDof8wz/8A5dffvkaQaaiKDjzzDP56Ec/On1sO8dwNfe73/2m/56IY61+DGDXrl3ccMMN098vu+wyfud3foeHPOQhPOc5z+GJT3wi5513Huedd96OPuuxKKUQWpAKQApsY8lbyZ1uJfuWcjJdU2G8Cv+oSx/F23/n7SwvL/OM/++nuPTBj+BJP/bk7QvQHFMiuZ2J5mqOPScXFxc3PE+/9KUvTX+/+uqrp+0hq7nggguAWD4/qbgYDAZcccUVfPnLX56OjYcPH562Yxz7Prt3754GDpOFphtvvHHNIsWMGXd3lFJrgsDtIKSIpeKVpRGBsi4RIiHLUowReN/gqj5K5iizfYHCRCYIYpl05aq12evJe28j0zyx9dvIhQYmY5tYk8FmMt86JrO9EUoadJ5Qj4ZoM7fu71prUqPoVQ219VOrQYDlUUNZlnRyRV6szRinKqVPn8pV5DqWtu82mqHz7EqO9ss3vqFlWmteK4REqRznqlhh4AJ+aJFFjvQeNxgikhyZxu14X04z1t5Xx+3dF1riy7HFZ3rnrfxojQPsw42dZa9n3OactAH2v/7rv/Lbv/3bADznOc9Z9/ef/umfvr136U7Jrl276HQ63HTTTbdoOyEEfvRHf5QbbriBD33oQ9Oy7Fe84hVrqgnuec978pnPfIbXv/71vPa1r+W//tf/ysUXX8xrXvMaHve4xwGxvPW8887jne98J0984hNpt9s84xnP4HWve92WCu+7d+/mi1/84rrHJx7ne/Zs3kPbbrf5p3/6J17/+tfzzne+k//+3/87Z511Fr/xG7/BM57xjG0fh436/48cOYL3nmuvvXZNvzXEIGC1yMh2juFqVquOTraz+rHJ46u9lX/sx36Mv/3bv+VNb3oTP//zP08Igcc+9rG86U1vWhf07AQhBEZrbO2wtUcpT5LtTGF6V7GLm19y8wnvw23FrmLX9p97El1T0Z5O8KY3/BbnX3A+73znO/nRH3vSjq8poQRhVWaov3z8a2o1G52TxztPDx6M2fHf+I3f4H/8j/8xfdw5x759+xgMoljd5z//eR72sIfxMz/zM1x77bVT8cr73Oc+Gy60Hvu+k4D81vIfnzHjrsIkqN5JgA0gEkm10lCPakwnI8taWOvwfkQIFrxC6dZxHQzWbFMIjDQM7RAfPKleX7J8vD7syXYmjg0bYj0osWahVKhouhxcQGwxKw7WQwgk7RbVcAXbNGiz/h6YpwlHBiuUdY0IAa01y8OGynoKDYlMkXLt8Z6UfdeungbYLa24b5GSjPf12P7r1ShVIGUf50pEHhCVjEF23gJpwAmEUdPycK1TQqiBMO7F3pzpsdYScScOSuWqLHYxy17PuI05aa+UCy+8cGp4v9HPsT2yMzZGSsnjHvc4vvnNb3LjjTdu+ryPfexjfPnLX97071//+tf5xCc+wXOe85xpILAZZ599Nu9617u46aab+PM//3PKsuRHf/RHpx7mUkp+/ud/nn/+53/my1/+Ms9+9rN55zvfyfOe97wtt7t//356vd5UpGzCpPTzoosu2vL197jHPXjLW97C97//fT7wgQ+we/dunvnMZ3LNNdds+brjMbEEuOSSS7juuuvW/Hz729+eCljt5BjeUi6//HI++MEPcsMNN/CGN7yBT37ykzzmMY/ZcTngsZhEY52jqS1Kb9zjthVSSPa09px0PztRED+ZrqmvfvWrIEEGMb2mvvjZz/NzP/2zO7umjhwGPx5ffeD6b27vmrolTDLLv/Vbv7Xmmvn85z/PjTfeyOtf/3og9qmXZcmrXvWqDZ0hZsyYcWJM2ih2cl/w3jMajaixUZArzcaCaRneV4TgUXSQJ9DjPikTV0KtK4MG1vRhnyjBbxKcy0kVzxavtR6EwGQpUmvq0XDD5yVJgpKClWGJEIKV2lNaRzfTGPyGQTkc7cOeeEQDpFJOFwOO7b9ejRAKrTt4X+F9g8g1Qgv8qIEgQUmEitlrkAiRxIy3UEh5nPu4lrE1ID1pQ4Zt01KSTArad+KFghl3DmZn2N2AV77yleR5ztvf/vYN//6pT32KRz3qUVtm5CaZomNL11eXJgNcc801/MEf/AEAWZZxxRVX8Md//MdYa6fZ55/7uZ9jOIw3prPPPps3v/nNPP7xj+dzn/vclp/jiiuumL7Hse953/ved02P5rF8/vOfn5aDa635kR/5Ed7//vcDrHlfY8z05nbgwIE1PaObURQFD3/4w/nc5z63bqLyvve9byrqtN1jeEt5y1vewqc//WkgBjEvetGL+G//7b/xrW99a6p4fqKYNKq+O2sxibrbikadTNeUUJJnP+c/H72mzrwfb/qtN+3omvro343bGHwAF/joxz923GvqlvLoRz8aKSX/8i//su5v/+W//Bf+/u//Htj4ODnnuPnmk68SYsaMOxurhc6Oh7WWwWCA957WXJs0T/GlG28nAyRKtJCcWKZzkpmdZHCPZTt92FuxkcDZdNtqrQ7Fhq9v/LT/OMkLvLXYul73PCkleWqoG8fIQtk4upnBiEDwHmU2Ll9PVEIgloFvxEb916tRqkAIhbW9uHgy8fb2YbrfzldImY5LxavNxc1WIUT0H78rtIMpIZi/k9pyzbhzMQuw7wacc845/OVf/iVve9vbePOb30y96obw93//9zz1qU/lJS95yZYK0+eccw5nnXUWf/AHfzCd2H7hC1/gz/7sz9Y87zvf+Q5XXnkl3/ve96aPfexjH6PT6Uxtcq655hre9ra3rQlkv/jFL3L55Zdv+Tke+chH8tSnPpVXvOIV0/LSD3zgA/zt3/4tb3nLW7Yc/A8dOsRv/dZv8W//9m9r9ktrPVVmhihc9t3vfheIKuOvfe1rt9ynCW94wxu44YYbpsJmEIXVXvjCF/KABzwA2P4xvKVcd911vO51r5sGXHVd84//+I9cfPHF0z7uE0VKiVTggidJ717q4as5qa4pJfjoxz/KW9/6Vrz1QODg4YM7uqZe+epXcfDQQYILvP8D7+fqj11z3GvqlnLf+96XF73oRbztbW/jn//5n4E4Af693/s9/uZv/mZ63UxEBV/3utdNr63XvOY1jEaj22zfZsy4u6CUwnu/Jmu6EVVVTXUiiqJAa41MdXSTsB4hFEmyG8m43FjvfOww0tA2bTK9ecnydgLhTZkKnK2f+h5P6Cy4WB4+sffSxsQsdrnxOJSnCS4EKhfoZJo8UbimRkiJ2qTyy0iDFJLarQ/aJ/3XWwXYkyy2tb3p9ykLE3+SWB7OGvVwv60Ae8aMGSdAuJuwvLwcgLC8vHxH78qmOOfCgQMHgnPuNtn+1772tfDsZz87nHvuueGiiy4KF154Ybj88svDVVddteZ5D3vYw8K+ffsCEC666KLwl3/5lyGEEL785S+Hxz72sWHfvn3hoQ99aPiJn/iJ8MxnPnP6vL/9278N119/fXjuc58bzjvvvHDRRReF888/Pzz60Y8On/zkJ6fbf/e73x0uvfTScP7554f9+/eH8847L/y3//bfQlVVx/0Mo9EovPSlLw33u9/9wgUXXBAe8IAHhL/6q7867usOHDgQfuVXfiVceOGFYf/+/eHCCy8MD3nIQ8IHPvCBNc/75Cc/Gc4999xw3nnnhYsvvjh8+tOfDh/60IfCRRddFICwb9++cNFFF4V/+Zd/Wfce1157bXjMYx4TTjvttPCABzwgPOxhDwvve9/71jxnO8fwv//3/x7OPPPMAIQzzzwzvP71rw8f/ehH1+zDFVdcEXq9XrjoootCq9UKrVYrXHTRReHgwYPh4x//eHja054Wzj333LB///5w7rnnhmc+85nhu9/97nGP0/FwzoXDhw6H66//5ra+r7s6J8M15a0L73rH/wyXPvLScP5554f9F1x0YtfUD5wVLjj//PCA/ReH9/7Fe477uj/8wz8M97///QMQ7nnPe4YXvvCF4ctf/nK46KKLgjEmLCwshIc97GHTz7+wsBCMMeGiiy4K//qv/xr33fvw1re+Ndz//vcP97vf/cL+/fvDT/7kT4Z///d/X/Ne//t//+9w//vfP9znPvcJl1xySXjNa14TTjvttLCwsBAe/OAHhxBCeOADH7jmPb761a+G17zmNWuupSuvvPK4n2vGjNuT2/q+fzyapgnLy8vBWrvh351zYTAYhOXl5VCW5bq/25U62P7RccYN6mBX6ttsf33jgl0ug7d+x691pQ12eeMx0Vsft9ts/D24sgl2uQreH33fpq5D/9DB0Gwwzlrnw3cP9kJ/dPRYrBw5HMrBypb7uFwth4PDg+ser20dbhrcFGq39bG1dhiWlz8fqurIur81TS+U5c3r/r0d7ujzdMaM43F7nKM7iSVFCMdZtryL0Ov1mJubY3l5eUvRnzuS20JFfMaMW5ter8fhw4e55z3vebctET+ZCCHg+w0iU7GP2npUe+fVBX7YEAKxnDCRMTt1J2Y2ns64M3BHn6chBPr9PlmWrVPettZOPaWzLNvYV9p6/LBB5ga0iGNRqpC3kdp0HO9qRKZ33Oc9GeNUa+MssOvXm459bqWOvt/F2tcOe8sAFN31iuJrXm8to94yWae7aQ82QOUqlqtlFrNF9Kre6EEzYGRH7M53b/k+IQQGg28gZUKe33NNFVJVH0TJFK071PVBhEi27VN+R5+nM2Ycj9vjHN1JLDm7SmbMmLEjpJRTX88ZdzxCiDiSuxBVcLdrzXUsSsQSyhAQswnUjBl3CzYTOtuoJHzD1+sooOUrOy7BDogTKA/fyf6eaB/2VurjwFjobH3OKfiwpo95NWmxeS/2alxTgxCblodPWG1Xtprj9V9PEEKgdZcQarw/Wr7ufQ3Bjb2vLSG4WXn4jBm3IbNZ1IwZM3ZElmUzNeeTDKFk7BF0AfSJDesxqB5PLndgrzNjxow7N6uFzrz3DIdDqqoiTVOKojhuNkiOq2f8yIIQt7mV04n0YQc/XjzcYmzbbLvRwnAc2B+D0gZlzKa92BOipVdy3IXpiV3Z6gA7bKP/ejVa54DCuuG0F9v7CpBImY7/LZDy7qujMmPGbc0swJ4xY8aOiJYss6HjpEKJqI7LLchgT14nxIlvY8aMGXc6JkJnTdNMVcKLotj2QqpQMmayV4mA3ZZM3mtHQfZEvGyLe9dmQmehGXtnbzIuJnm+ZRbbe4e3FpVsL0BOVELjm2lwvJX/9YafQxikTAi+mWaxna/GSu+M1cOPH+zPmDHjxJnNkmfMmDHjTs6aid8JZp9jZkdsaGEzY8aMuy5SSkIIjEaj45aEb4ZINSBulwD7RPywg/Pj7PoW49skQ70qwA4+gPMblodPXzbJYm/ii+3qaLul9fYC5FSlBAK1jwH7Vv7XGyGlQUodLbvccFV5eEoIjhAapNxcqX3GjBm3nFmAPWPGjBl3diaTRiluUVZCJHLLieSMGTPueiilUEptuyR8I4QSyI65XcaPE+rDdhv7X6/ZrhQgxNrAffzv4y0cJHmOd46mrtb9zTY1yphta1soqVBCUbm4re32X08QQoFQCJFAcDS2B0KN+6/jNmfl4TNm3LbMZlIzZsyYcSdnMuG8pdkjeQLKvDNmzLhzI4Sg1WrdYm2N27PkeKd92McVOJtwjNBZaHxcuDxOcD7JYjejtb3YIQSctWizs4A2VSm1q3fcfz1BCk30uc6i9/VY0Oxoefhs+j9jxm3J7AqbMWPGjLsAstCI28gaZ8aMGTNOJnbSh31U4Oz4U97VgXsIgWA3Vg/fiI2y2LapIYRt919Pt6USfPCM7GhH/dcThDCEYJEyJwqaZYTg8b6ZqYfPmHE7MAuwZ8yYMeMugBC3rDx8xowZM+40jDUjttWH7bbvjrBG6GxqO7a9hUulDSpJ1mSxXd0gtUbKnS1+GmmQQjK0wx31X0+Q0gABIQRpuhcpTezFJswC7BkzbgdmAfaMGTNmzJgxY8aMOw2xLUZsqw87eL99d4RJltuFo+XhOxCOTLKjWexYHt6gzc6CYzhq1+WD33FwHV9vAEEIzfQx7yuEiOJnM2bMuG2ZBdgzZsyYMWPGjBkz7lQIvc0+7G0InE23ORE6855g/Y51LZTW0yy2s5bgPWqH/dcTUhUzzScWYAuE0HgfA+wQwrj/epa9njHj9mAWYM+YMWPGjBkzZsy4UyHU9vqwgwsIvYP2GSkItT9hX+9JFrseDhBSonZoeTbdjkpIZDINtHeKlAYfJgH2rDx8xozbk1mAPWMdD3/4wznllFNO2n7OpaUlfvInfxIhBP/+7/9+R+/OjBnHZXZNzZgxY8atzDb6sKcCZzuwHpv0YSNOzNd7ksX2zqGTE7fDkkIyn82jdti/PWFi0xWCi/3XQo17s2fMmHFbMwuw70Z8/etf5xd+4Re46KKL2L9/P/e9733Zv38/L3jBC7jmmmtomrjS+YlPfIJf+IVfuIP3dmM+8pGP8IAHPIDPfe5zt8n23/KWt/C+973vNtn2jLses2tqxowZM+4YttWHvQOBs+l2x33Yt8T2MMlyEOKEy8NvDaSMmXPvG5yvplZdM2bMuO2ZBdh3E6666iouvvhizj77bP7pn/6J6667juuvv54//uM/5lOf+hSXX345H/jAB+7o3Twur371q3nPe97DU5/61Ntk+7MAe8Z2mV1TM2bMmHHHcrw+7OB2IHA2YZwZ364914ab0JrW/MIJCZzdWgihQCicG0Jws/LwGTNuR2YB9t2AL3zhC/zkT/4kL3jBC3jRi15Emh4dZM8//3ze//73k+f5HbiH2+djH/sYF1988R29GzPu5syuqRkzZsy44zleH3ZwYUcq4BCFzmTb3KIMNnBStARJYcZK4hIp77hs+owZdzdmAfbdgFe/+tVUVcXzn//8Df++d+9eXv7yl3P66advuZ2/+7u/48lPfjIXX3zx9Oftb3873q8tz/rwhz/MQx/6UB7wgAdw0UUXcdlll/GHf/iH07+vrKzw/Oc/nwsuuICLL76Yiy66iOc973lcf/31x/0s+gTFQgCuvfZaLr/88um+P/ShD+X1r389AF/5ylfYv38/3//+9/nrv/5r9u/fz/79+/mjP/oj/vzP/5z9+/cjhOA3f/M3ecUrXsFDHvIQ5ubmmJ+fn27/05/+NJdffjlnnHEGZ5xxBo997GO57rrrdnwMf+VXfoUf+IEfQAjBVVddxU/91E9x/vnnc8YZZ/Dud78bgDe+8Y08+MEP5vTTT+eFL3wh1to17/Pbv/3b7N+/nwc84AFceOGFXHHFFXz84x8/4WN3q+E9HDhw8v34bXiprmJ2TcGb3/xmzj33XIQQ/N7v/R6/9Eu/xMUXX8xpp53GlVdeCcAf/dEfcckll3DaaafxjGc8g5WVlTXbCCHw5je/mXPOOYdzzjmH+973vrz4xS9mOByued6VV17Jgx70IH7oh36Iiy66iMc85jF85jOfmf59NBqxf/9+FhcXuc997sPVV1/Nox/9aH7wB3+QH/7hH+bTn/70CX3GGTNmnOQcrw/bhx2Vh0/YUcb7JGbScz3LXs+YcTsT7iYsLy8HICwvL9/Ru7Ipzrlw4MCB4Jy7VbfZ6XTCfe973x297uUvf3k49vR4znOeE17ykpdM9+873/lOOPPMM8Nb3vKW6XO+8Y1vhCRJwsc+9rHpY29605vCve997+nvz372s8OjH/3oUNd1CCGEG264IZx11lnh3e9+947375vf/Oa2nt/r9cLCwsKa93jPe96z7jPe+973Dj/90z+94TaAcI973CP8zd/8TQghhOuvvz4sLCyEEEL49Kc/HdI0DS95yUumz//lX/7l0Ol0wte+9rXpY9s5hiGE8LGPfSwA4RGPeES46aabQgghvP3tbw9CiPDSl740fOpTnwohhPC5z30uCCHWfK4//uM/Dnv37p2+rizL8LSnPW3Tz7VTbtF5evPNIUrOnGQ/N9+8o88/u6Yi3/zmNwMQLrjggvDVr341hBDC+9///gCEF73oReGqq64KIYTwve99L3Q6nfDyl798zetf+MIXhqIowqc//ekQQgg33nhjuP/97x8e97jHrXlet9sN11577fT3P/mTPwmdTid85zvfWfO8n/7pnw7dbje85CUvCdbacNNNN4WnPOUp4YwzzgjW2m1/rhkzbi9ui/v+3Q27Ugc3qNc97q0PdrkMvrn7Hlvn6lCWNwZry1u4ndl5OuPk5vY4R3cSS554OvDuxJ/+KRw+fNu/TwhkgwG0WrBRadHiIjz96Tva5MGDB+n3+5x//vm3ePd+7dd+jd27dyPHapynn346T33qU3nnO9/JC17wAgA++9nPUtc1Z5111vR1z33uc+n3+9PfP/WpT/HgBz8YM+5NOuWUU3jDG97Aqaeeeov3cTO+8pWvcOTIkTX79ZSnPIVf+7Vf29F2zj//fJ7whCcAcMYZZ3DttdcCMevcarV49atfPX3uq171Kt75zndy5ZVX8q53vQvY3jFczZOf/GT27t0LwE/8xE/wS7/0S3zpS1/ida97HQAXXngh5557LldffTXPetazgHh85+fn2b17NwBpmvLyl798JmJ1KzG7ptZz6aWXTvfv8Y9/PO12m2uuuYY3velNANzjHvfgEY94BFdffTWveMUrAPjGN77BW9/6Vn7hF36BBz7wgQDs27ePl73sZTzzmc/kE5/4BA9/+MOBWB1yzjnnTN/v6U9/Oi960Yv4kz/5E371V391zb70+31e+tKXIoRASsnTnvY0rrrqKq6//vo1x3DGjBl3DYQe22ody6QS6C6SjT4RpDQYszhTD58x43ZmFmDfxbk1e4C63S6vec1ruPrqqxkOhyiluPHGGzly5Mj0OQ960INot9s8+MEP5nnPex5PecpTOOuss/jN3/zN6XMuu+wy3va2t7G8vMwzn/lMLrvsMp70pCfdavu5Eeeccw6nnXYaT3rSk/jFX/xFnva0p3HhhRfymte8ZkfbOTaoOvPMMxkOh/zDP/wDl19+OVmWTf9WFAVnnnkmH/3oR6ePbecYruZ+97vf9N+Li4vrHgPYtWsXN9xww/T3yy67jN/5nd/hIQ95CM95znN44hOfyHnnncd55523o886Y2Nm19R6jj0nFxcXNzxPv/SlL01/v/rqq/He87CHPWzN8y644AIAPvrRj04D7MFgwBVXXMGXv/zl6WLE4cOH+cY3vrFuX3bt2sXu3bunZfaThaYbb7xxFmDPmHEXRChJCI7g/FQBHGL/9Y4Fzu6CzILrGTNuf2YB9nbYYdb4hPH+/2fvz4MsS8/Czv/7Lme7S25V3S211EJYCK1WS5jVSJbwSIDAZpkwhDwOhGeGgBADY3mCYUwMhI2DNiAGTIywR8SAWcwYEUzY5geakFkssRgDEkhogQYJbS11d2253OVs7/b742RmZVZmVmUtXYv0fCIqujPz3pvn3jz33POc53mfh3Zzk9HGBlzHzMarOXPmDNPplHPnzt3U46SU+Jqv+RqeeOIJ3v72t/Oc5zwHgH/2z/4Z3//9379/u4ceeoh3v/vdvOlNb+Jf/It/wT/5J/+El73sZTzyyCO89rWvBYa1my960Yv4yZ/8Sf7u3/27TCYTvumbvokf+qEfYmVl5aa28ySTyYQ/+qM/4k1vehM/+ZM/yQ/8wA/w3Oc+l+/7vu/jm77pm079ONPp9Mj3tra2iDHyrne9i5e+9KWHfra5ubkfkJ32NTxoPB7v///e4xz83t73Qwj7X3/91389v/Ebv8GP/diP8a3f+q2klPjKr/xKfuzHfuxI0COun7ynjjpun7zWfnrx4kUAvu/7vo8f/uEf3v9+CIEHHniA5XIJwPvf/35e/vKX89//9/8973rXu/Ybyj372c+m67prbsteQH7wdwshPo3sr8NOqAMjo2+kwZkQQtwK0uTs05zWmte+9rV89KMf5cknnzzxdu94xzt49NFHT/z5hz/8YX73d3+Xb/u2b9sPBE7yvOc9j5/+6Z/m3Llz/NIv/RJt2/I1X/M1/MVf/MX+Nn3rt34rf/zHf8yjjz7Kt3zLt/CTP/mT/E//0/90Y0/ylB588EF+/Md/nMcff5y3ve1tnD17lte//vX81m/91k097vr6OlprXvnKV/Le97730L9PfOITfPzjHweu7zW8Wa9+9av5//6//48nnniCH/mRH+H3f//3+fIv//IjzbNuuzNn4Pz5u+/fmTOnfgrynro19jLLP/qjP3roPfP+97+fJ598cr8B4Vvf+lbatuWf//N/fqhbuxBCwFXmYYcERk5zhRC3nxx5PgN8//d/P1VV8RM/8RPH/vy//tf/yt/+23/7qhm5vUyRviKzfrA0GeC3fuu3+Kmf+ikAyrLkG7/xG/mFX/gFvPd88IMfBOB//B//x/0uwc973vP4l//yX/LVX/3VT+ka4fe///375eDWWr7qq76KX/u1XwM49HuzLCOlYdzHhQsX+M3f/M1rPvZoNOIVr3gFf/qnf3okgP2P//E/7q85Pe1reLN+/Md/fL9r8tmzZ/nH//gf873f+718/OMfZ3t7+5b+ruumNdx339337zorRuQ9dfNe85rXoLXmPe95z5Gf/c//8//M7/zO7wDHv04hBM6fP397NlQIcde7ch728P+SwRZC3BkSYH8GeP7zn88v//Iv8+Y3v5l/+S//JX3f7//sd37nd/h7f+/v8V3f9V288pWvvOpjPPe5z+Wnfuqn9k9sP/CBD/DWt7710O0ee+wxfvAHf5BPfepT+997xzvewXQ65Yu+6IuAIWB485vffCiQ/eAHP8irX/3qW/acr3Tp0iV+9Ed/lD/7sz87tF3WWl71qlftf++zP/uz+eQnPwnAv//3/55/8S/+xake/0d+5Ed44okn+Of//J/vP6+/+Iu/4I1vfCOf93mfB5z+NbxZ733ve/mhH/qh/YCr73v+y3/5L7zsZS/bX8ctbo68p27eX/trf41//I//MW9+85v54z/+Y2Aom3/LW97Cr/7qr+6/b/aaCv7QD/3Q/vN75JFHaJrmzmy4EOKuc3ke9u5FbmlwJoS4k56yXuZ3mc/UMV0HfehDH0rf8i3fkl74whemhx9+OL3kJS9Jr371q/dH6ex5+ctfnh544IEEpIcffjj98i//ckoppUcffTR95Vd+ZXrggQfSl37pl6bXve516fWvf/3+7X7jN34jfeQjH0nf/u3fnl70ohelhx9+OL34xS9Or3nNa9Lv//7v7z/+z/zMz6Qv+7IvSy9+8YvTS1/60vSiF70ofe/3fm/quu6az+H7v//708MPP7y/fS94wQvSww8/nN7znvdc9X4XLlxI/+v/+r+ml7zkJemlL31peslLXpL+5t/8m+ltb3vbodv9/u//fnrhC1+YXvSiF6WXvexl6Q//8A/T29/+9vTwww8nID3wwAMn/r53vetd6cu//MvTM57xjPR5n/d56eUvf3n6j//xPx66zWlewx/4gR9Iz3nOcxKQnvOc56Q3velN6T//5/98aBu+8Ru/Mc1ms/Twww+n8XicxuNxevjhh9PFixfTb//2b6dv+IZvSC984QvTS1/60vTCF74wvf71r0+f/OQnr/n6noaM67jsM/k99W/+zb9JL3jBCxKQHnroofTGN74xPfroo+nhhx9OWZal9fX19PKXv3z/+a+vr6csy9LDDz+c3ve+96WUUooxpv/z//w/0wte8IL0uZ/7uemlL31p+gf/4B+kj33sY4d+18/93M+lF7zgBenZz352euUrX5keeeSR9IxnPCOtr6+nL/mSL0kppfSFX/iFh37HX/7lX6ZHHnnk0HvpB3/wB6/5eghxO8nx9NaIMSa/06XQDeP4QuOSn1/7+CdOR/ZTcbe728Z0qZRSOi7w/nQzm81YXV1lZ2fntjT9uRExRjY3N9nY2DhSNirE3UL2U3EvkP1U3AtkP711wtKhFOhRduj/xc2T/VTc7W7HPno9saS8S4QQQgghxD1tbx12SmlocGblFFcIcWfI0UcIIYQQQtzT9tdhuwikz/j510KIO0cCbCGEEEIIcW/bm4fdhwNfCyHE7ScBthBCCCGEuKftz8OOCbQavhZCiDtAAmwhhBBCCHHPU3YIqpWR01shxJ0jRyAhhBBCCHHP2w+spTxcCHEHSYAthBBCCCHufUahcoOSDuJCiDvI3ukNEEIIIYQQ4mYppVClnNoKIe4sucQnhBBCCCGEEELcAhJgCyGEEEIIIYQQt4AE2EIIIYQQQgghxC0gAbYQQgghhBBCCHELSIAthBBCCCGEEELcAhJgCyGEEEIIIYQQt4AE2EIIIYQQQgghxC0gAbYQQgghhBBCCHEL2Du9AbdLSgmA2Wx2h7fkZDFG5vM51lq0lmsf4u4k+6m4F8h+Ku4Fsp+Ke4Hsp+Judzv20b0Yci+mvJrPmAB7Pp8D8NBDD93hLRFCCCGEEEIIca+Zz+esrq5e9TYqnSYM/zQQY+Txxx9nOp2ilLrTm3Os2WzGQw89xGOPPcbKysqd3hwhjiX7qbgXyH4q7gWyn4p7geyn4m53O/bRlBLz+ZwHH3zwmlnyz5gMttaaZz7zmXd6M05lZWVFDmDirif7qbgXyH4q7gWyn4p7geyn4m73VO+j18pc75GFFEIIIYQQQgghxC0gAbYQQgghhBBCCHELSIB9FymKgn/6T/8pRVHc6U0R4kSyn4p7geyn4l4g+6m4F8h+Ku52d9s++hnT5EwIIYQQQgghhHgqSQZbCCGEEEIIIYS4BSTAFkIIIYQQQgghbgEJsIUQQgghhBBCiFtAAmwhhBBCCCGEEOIWkABbCCGEEEIIIYS4BSTAFkIIIYQQQgghbgEJsIUQQgghhBBCiFtAAmwhhBBCCCGEEOIWkABbCCGEEEIIIYS4BSTAFkIIIYQQQgghbgEJsIUQQgghhBBCiFtAAmwhhBBCCCGEEOIWkABbCCGEEEIIIYS4BSTAFkIIIYQQQgghbgEJsIUQQgghhBBCiFtAAmwhhBBCCCGEEOIWkABbCCGEEEIIIYS4BSTAFkIIIY7x7Gc/G6XUkX/j8ZjP+qzP4r/9b/9b/s2/+Td0XXfiY3zVV30Vz372s7lw4cJt3PI75zPt+QohhBBXkgBbCCGEOMbHPvYxUkr7X6eUSCnx+OOP8//+v/8vn/M5n8N3fud38tznPpf/8l/+y7GP8dGPfpTz58+zXC5v12bfUXf7863rmpe85CV3ejOEEEJ8GlPp4NmDEEIIIQ5RSgFw3Mfl+973Pl796lczm834rd/6Lb70S7/00M+bpqFpGjY2Nm7Ltt5pd/Pzfde73sW3f/u38+53v/vYv6UQQghxK0iALYQQQlzF1QJsgF/5lV/h677u63jWs57Fhz70IfI8v52bJ67hz//8z/mu7/ou7rvvPh599FH+8A//UAJsIYQQTxkpERdCCCFuwtd+7dfy/Oc/n0984hP84i/+IgDvfOc7D63bfuc73wnAH/zBHxz6/jve8Q7+j//j/+BZz3oWk8mEv/23/zbve9/79h/jC77gC6iqis/5nM/hF37hF07chp//+Z/ni7/4i5lMJkynU770S7+UX/qlXzp0m+N+94/+6I/y1/7aX6MoCp7//Ofvb/+VfvEXf5Ev+ZIvYWNjg/X1db7gC76A7/u+7+NDH/rQVZ/vQT/3cz+3v42TyYQv+ZIv4ed//udv2Tae5AUveAFve9vb+Nmf/Vme//znX9d9hRBCiOslAbYQQghxk1796lcD8Pa3vx2AV73qVaSU+Kf/9J8eut0Xf/EXH/r+m970JrIs40//9E/5vd/7PT760Y/ymte8hj/4gz/gl37pl/gP/+E/8OEPf5jnPOc5vP71r+fd7373kd/9Hd/xHXzzN38z/81/89/w2GOP8bGPfYwv+7Iv43Wvex0/8AM/cOLv/qEf+iH6vueP/uiPePTRR3n605/OP/gH/4B3vetdhx7/zW9+M//df/ff8fVf//V8+MMf5hOf+ATf/d3fzY//+I/zyCOPXPX57nnDG97AP/yH/5C/+3f/Lo899hiPPfYYX/3VX803f/M3853f+Z03vY1CCCHE3UICbCGEEOImPec5zwHgwx/+8HXdbzwe84/+0T9ifX2dl770pXznd34n58+f53/4H/4H3vzmN/PMZz6TZzzjGTzyyCOklPh//p//59D9f/VXf5V/9a/+Fa94xSt45JFHWF9f58yZM/zAD/wAr3jFK/hn/+yf8eijjx77u4ui4Hu+53s4e/Ysn/3Zn80P//APH/s7fuZnfoYzZ87w3d/93WxsbDCdTvmGb/gG3vjGN57qOf7Kr/wKb3nLW/j7f//v87//7/876+vrrK+v873f+7287nWv4yd+4if4tV/7tZvaRiGEEOJuIQG2EEIIcZMmkwkAOzs713W/r/7qrz709XOf+1wAvuALvgBr7f73P/dzPxeAv/zLvzx0+//r//q/APiWb/mWI4/9ute9jhAC//bf/ttjf/fXfu3XHvr6BS94AcB+2fcepRSbm5v8xm/8xqHvf/d3fzdvetObjn9iB7zlLW8B4O///b9/5Gd73/vX//pf39Q2CiGEEHcLCbCFEEKImzSfzwFYXV29rvs9/elPP/T1dDo99vsrKyvAMGbqoD/6oz8C4KUvfemRx37ooYcAji0rB3jwwQcPfb13keDK3/GP/tE/AuArvuIreNWrXsVb3vIWzp07x3Q65f777z/+iR2wV8593Prnve+dVPJ92m0UQggh7hYSYAshhBA3aS+zvJdpPq2yLK/r+1d2v97LmD/88MOHmoMppfiar/kaAM6dO3fsY1VVdejrk7qlv/71r+ed73wnr33ta/m93/s93vCGN/DMZz6T173udTz55JPXeIaXt3E8Hh/52d73tre3b2obhRBCiLuFBNhCCCHETUgp8Zu/+ZvAkOW9ndbW1oChZDqldOy/9773vTf9e/7W3/pbvO1tb+PJJ5/kX//rf83nfu7n8ku/9Et82Zd9Gc65U23jcrk88rO9762vr9/0NgohhBB3AwmwhRBCiJvwy7/8y3z4wx/mWc96Fq973etu6+/+oi/6IgA+9rGPHfvzP/iDP9gf+3Wjfv3Xf53FYgHA2bNnecMb3sB73vMeXvjCF/Loo4/ywQ9+8Kr3/8Iv/EJgmEd9pb3v7d1GCCGEuNdJgC2EEELcoD/5kz/hDW94A0VR8Iu/+IvkeX5bf/+3f/u3A/CzP/uzR372qU99ile96lU3ncH+1m/9Vn73d3/30PfyPOdzPudzgKNl3Fd6wxveAHDs/Oq3vvWth24jhBBC3OskwBZCCCGuw2w2413vehff9V3fxctf/nLG4zG/+Zu/yd/8m3/ztm/LV33VV/HGN76Rf/fv/h3/2//2v/GRj3yEuq757d/+bV772tfyyle+8tju3dfrjW98I+985ztZLBZsb2/zsz/7s7z97W/nK7/yK3ne85531fv+nb/zd/iO7/gO3vrWt/LII4+wtbXF9vY2jzzyCG9961v5ju/4jiPd1J8qbdsC0iRNCCHEUygJIYQQ4ojP+qzPSsCRf1VVpYceeih97dd+bfqpn/qp1Lbtkfu+4x3vOPa+H/3oR49877M+67NSSim98pWvPPb23/zN33zk+z/zMz9z6Pf9u3/379KXfumXpvF4nKbTaXrJS16SfuRHfiTVdb1/m6v97qv9jt/7vd9L3/Zt35Ze+MIXpul0mlZWVtLDDz986PFPer4H/fzP/3z64i/+4jQajdJoNEpf9EVflH7u537u0G1udBuv5ty5c+nLv/zL04te9KL9+509eza96lWvSr/wC79wzfsLIYQQ10OlJK04hRBCCCGEEEKImyUl4kIIIYQQQgghxC0gAbYQQgghhBBCCHELSIAthBBCCCGEEELcAhJgCyGEEEIIIYQQt4AE2EIIIYQQQgghxC0gAbYQQgghhBBCCHEL2Du9AbdLjJHHH3+c6XSKUupOb44QQgghhBBCiHtASon5fM6DDz6I1lfPUX/GBNiPP/44Dz300J3eDCGEEEIIIYQQ96DHHnuMZz7zmVe9zWdMgD2dToHhRVlZWbnDW3O8GCNbW1usr69f88qIEHeK7KfiXiD7qbgXyH4q7gWyn4q73e3YR2ezGQ899NB+THk1nzEB9l5Z+MrKyl0dYHvvWVlZkQOYuGvJfiruBbKfinuB7KfiXiD7qbjb3c599DRLjeVdIoQQQgghhBBC3AISYAshhBBCCCGEELeABNhCCCGEEEIIIcQtIAG2EEIIIYQQQghxC0iALYQQQgghhBBC3AISYAshhBBCCCGEELeABNhCCCGEEEIIIcQtIAG2EEIIIYQQt0hKia6uSTHe6U0RQtwBEmALIYQQQghxiwTncG2Dd/2d3hQhxB0gAbYQQgghhBC3iO+HwDo4f4e3RAhxJ0iALYQQnwbq3tO6cKc3QwghPqOllIbMtVIE7+705ggh7gAJsIUQ4g7z3hPCzQXHi85T9xJgCyHEnRScg5TIq4oUIzHKcVmIzzQSYAshxB3Wti1t297w/X2IpAQuREJMt3DLhBBCXA/verQxZHkB7AbcQojPKBJgCyHEHRRjJMZICOGGs9h+N6hWQOclWyKEEHdCSongHCbLUVqjrSV4WYctxGcaCbCFEOIO2guqlVK4G8x09CFitCIzms7JWBghhLgTgvekGLF5DoCxligBthCfcSTAFkKIOyiEgNaaLMtwzpHS9Zd4Ox/JtKbMDH2IRCkTF0KI2873HUprjLUAaGuJIcg6bCE+w0iALYQQd1AIAWMMeZ6TUrruLHZKiRATmVUUdjikd16y2EIIcbsF57C7a68BrM2G799gFrvv+xu66CqEuLMkwBZCiDskpbQfYGutsdZed4DtQiIBmdHovTJxWYcthBC3lXdutzw82/+e0hptzA2Vifd9T9u2eCkxF+KeIwG2EELcIXvrr40xAGRZdt3NznyMKMBqBUCZaXovZeJCCHE7Bdfvlodnh76vrb3uTuIxRrqu2/9/IcS9RQJsIYS4Q0IIKKX2A2xr7XU3O3M+YY1GqSHALqwhMTQ+E0LcvVJK+IsXSX1/pzdF3AK+7/ebmx1ksowYAuk6AuW94NoYIwG2EPcgCbCFEOIO2SsP36OUuu5mZ32IWKP2vzZaYbWSbuJC3OWScxAjqe3u9KaImxS8O9Q9/KC9hmenXYftvcc5R1mWGGNueHyjEOLOkQBbCCHukCsDbBjKxFNKp1p3F2MipkRuDh/Ky8zQ+SDNcYS4i+1nrp1ksG+l2HW3/djne3dseTiA1gal9akC7JQSbdtirSXLMrTWxBjlWC7EPUYCbCGEuANCGALgKwNsYwzWWvpTlI3ulYFnVwTYhdUkpJu4EHez1PdgDCklKRO/BVJKhJ0dwvYOcbG4rb/b992x2es9xmYEf+2lP3tdw4ti6ESu9XBslzJxIe4tEmALIcQdcGWDs4NO2+zMx4RSQ1n4QdZojFYSYAtxl0oxkpxHj8copYgSYN+UlBJxZ4fYdeiyINbNbXtNg/ekGDHZVQLszBJ3b3fi44RA3/fkeb7/ubD3Xwmwhbi3SIAthBB3wF55+F5zsoNO2+zM+XikPHyPlIkLcffay1irPIc8J3WyDvtGpZQI29vEvsesrWFWV1F5RpzNbsvxz/dD93CbHS0P37NXOn61i6Zd16GUIj+QCVdKobWWddhC3GMkwBZCiDvg4Prr2AWSu3wCddpmZy5G7G6AHULEu0DaHc9VWE1K0k1ciLtR6ntUZlFaD0F2CCQJoq5bipGwvU1yDru2ht4NTs3KCinG21IqHlyPuUpwDaDN7jrsEy6aOufw3lOW5ZGLrnvrsIUQ9w4JsIUQ4jaLMRJjxOytv+wCsTt8cn2tZmc+RFKCzCiCj7QLR7f01LOeetYT+0j0kaaXk3Yh7jap64bAGiDPQSnJYl+nveAa77Hr65dfT0AZg5lMnvJS8eA9MQRsXlzztietw44x7jc2s7sdxw+SAFuIe48E2EIIcZsdWn8dEpAgpv3s897PjDEnlom7MNzWoGiXjuACeWnIRxZjFcFFtIvsbLbUs5526XBdIEhGW4g7KjlHimk/IFRKobKMKAH2qaUQCFtbECNmfR11TAZZj0ZPeal4cP1u9/CjgfGVjLXDPOwrtmWvoWVZlsffb3cW9o0G2bJMSIjbTwJsIYS4zUIIaK3RWpN8hN2SwHRFU7Isy/DeH3ti5WJEK+hrT9+G3TXbgSw3FKOM0UrO2npFVlmiGk6y+tbTzh3LnY524ehbT3AyAkaI2yn1PSgOBYUqz4fAW96L15S8H4LrlIbg+irBrZlOn9JScd8P5eHH9dI4si1ZBikdGtd1sLHZXsfwK91MJ3EfIhfmHZ2XSiYhbicJsIUQt13Y2SHMZnd6M+6Yg+uvk480MTJ3gbZxhANZ7Gz3xO24kV3OR1IX6WqHtYq5hll/ODtS5Aaba1KmqCY5o5WccpKRFcPvdl2gXTrqnZ5m0dM3nhjlBF+Ip1Lse9QVQZnKc0jIuK5rSM4NwbVSQ3B9zBSGg5S1+6Xit/q1jSEM5eFX6R5+0N467HigTLxtW4wx+2O5jr3fTQTYrY8kYNlJgC3E7XTtmhYhhLjFhhLJiJ5OT3Xl/9NJSokY47DGOiaijyxjBBLtsgcSRmtyo8msAj2UiRdFsf9apZRoaofuAmWVk08yCJF+2RN9wmSXX9MyM7QuMi2HUlRjFcZevrYaQiT6RPAR1wdiTJTjqzfsEULcmJQSyTnMeHzo+8palDXDOuyrBFufyVLfE3Z2wBjM2hrqhIzvlfRoROw6wnyO2di4ZZ85vu+GQP8aDc4ObYu1+xnsvu8JITAaja56n71O4jcSYHcuoJXChUjnA4W9+gUJIcStIRlsIcRtlWIkhThka64xhurqj3N4zfK9IuyuwTPGkHyk85FkFGdXK86MclYzQ5lpQkosWs+8T5yfd1yY1Sw6T+cDde1oZo7cGqqVnGQ12igiQ5n4QYXVxJRwJ6y9NkaTFWYIqq2md5LpEOKpkpyDxKGGXHtUUUijsxPEvsdvb4O11xVc7zHTKSmEW1oq7p3DZvl1BexmN8AOIdB1HVmWHdvY7Mj9jLnuUV0hJnxMTEuL1eqez2In7/EXL0q3fXFPkABbCHFbpb31Z4qbOpmMjSfW996axRCG9dLGGPCRLiXKzGCsRltNgWJaZmyMc+6bFpydVkyrYS123Xsu7XT81Sd2mNU9qjIEBW2IKEBbdaRreG40SkHnr579iCmxQ2ThozRCE+IpkvoepdXxTbnyfLhweBMXHj8dxa4jbG+jsuxUwfVxnwnKWsx4fMtKxWMIRO+xx1wouRpjh3XYTb0EuGppeEqJvqmHaq8byGB3PqAYLrKOC4sLkf4anwN3s9g0pBDl/SHuCRJgCyFuL+9Bga6qm8vWhN3O2/fYVfm99dcpJVwXcGoo4wZQmSaFyyeHSilyq1kbV0wyxUZpyfpAqTWrZ0ui0ew0jidnLYu6J5DofTyU2VdKURhDe43MdB0iyih6EsHduydhQtzNUt+jTgiqVJ6jtCJ21xcAfjpn9GLbErZ30Hk+BNfXyBa3LnBh3h17vNPjMSrPCPP5TV+Y9a6/7vJw2M1gh0DXtBRFcWJjM4DgHH3T4Pt+aIi5u7zotFoXya1GKUWZmd0s9vFjH+92KUZi0wz/LwG2uAdIgC2EuK2S9yhr0UVxw1ej095oK6NJfTjSfftutt/gLCRaF1CZpthdE62shpSO7SZOgq3zC5SHyXrJAxsj7psWnBnnVKWltBofEn2MhCvuX2R6KBc8ITOdUqIOkVxrlFbXDMaFENcvxUhy/tjy8D0qz0n96S88phjxly4RFstbsYl3ldg0hJ0ZuixOFVwvO89O40DB4oRAcr9UfHlzr5fv++suD4fhWOtCgBTJr5H93puZ7b3bb4p52jLxGIdlQQfXXI8LS3+PZrFT2+4urcguV8EJcReTAFsIcVvtBdiXszU3kMXezdDqyoLRxMbfE6XiV66/bkOkKuz+SZoyGpQ69oJBuwg0i47xeoEpDZnZ7SyroMgMq5nBqMTSR/yVAbbVKE4uE6/D0Gl2LTMYq2jc0VmtQoibs1eafNUAuyhIzp86K70XeMR6+WmVyY7LJWE2R48qzOrqNW8/bx2LzjMuLGtVTojp2AuF+6Xiy/qGS8VjHMrDTX79zSD7vkdpQ3aN7ucwBPEoRXBumJWu1Kkz2HvH+uJAQ8syM5h7NIsdmwZdFsMyCslgi3uABNhCiNsqeb8/WuVGm/qkOMyOVloNQXaC1N79J5d72QetNW3jSEZRZYdPtFSmjwTYy52e2CvKFUswQ+C7F2D3MeG7jti35MnTxUjbHz6B2is1Py7ATimxDJHKaIwatqcLiRgkwBbiVkp9j8rsVdcQ7wXfpw3+Yteh8mwY/zSf35LtvNPCYklYLNHjEWY6veptU0rs1I66D0xLy6Sw5HaoClp0x194vdlS8b3A97TjufbEGOn7nnJUobU+NA/7yG1DIMVIXlXD7GznrmsdducDmdFofTjDPrkHs9ix70k+oKsKdqu5JIst7nYSYAshbpvkPSSGD0l2A2wfrv/DMiTYPXFQWqFKQ3KBdJevHd4rD1dJ0fYBm1/ORO9RRg9ry3cD3HrW08w6pmcqxislTdejFBitSCkxq2uSd2RZxiQzRCI7tTsyz7rMDC7EQ3O24XL2ery7HVVu8aQj3ciFEDcn9f1Vs9cASuuhDPYUFx5TjKTeoYsCPZkQu/7GKoLuImGxIC6XmMkYM5lc9bYxJrZrR+cDq1XGKL/cjXtc2N0s9gnTE65VKh4jnBB8+77HXDHH/DTatkUpRTUaD5lpf3ImNjgHSpEVJdoYvOtPHWCnNPTiKLOjp/h7Wey6v3cC1FTXw4WpPEftdly/0QA7xUhX11KhJZ5yEmALIW6bvRLGvQ9Jlec31E08hYQyl09udG6GUvHW39Wju/YC7OACLkSq6pjxLFYBQ5l4u3Ast1uqac54pSDLMtqux6ohG1LXNa1zTKuKqqrIrKGykVkf8O6YbuIMmY09V2avAUo9zMlu7mCA7Zy77pE0QtzNkvekEK8ZYMPQTTz2/TWDgL3jpipLdFmi8ox4Cxp43Smp74nLGjMZo6+YE36lEBNbdY+LkbVRvt8ock9mNKU1J2axr1oqHhwszsH8SVich3oT2hn0NbFviH1/3d3DnXN47/cbm5kD87CP412PscPyIZPlBDesw44xXvPv2/nhoulJM68nhaXz8cTRjXeTFAKx64fsNbsXoIy+4QDb9R2ubXBdeys3U4gjJMAWQtw2yfkh47xbIqmU2j+ZPPVjxATpcIANu+uxgdTenVfmY4zEGDHG0LYOtKbKjgbYSimUVXTzjvlWQzHOmKyXAFhr8SERvaOua/oQKaoRo2I42cvznGlmcDEwrw9nR7RWZEbTHcjo1CESuZy9BtBKUWSGxl37RO6pEEKgaRr6WzBKR4i7Reo6UBw7nutKqiiGMthrrDWNbbtfHg67WdkYicv6lmzz7RbbFmX0NYNrHyKby56YYGOUk9vjT2XHhSGmdOLFQj0eozJ7tFS8m4M2UK6CLXd/aQftDmHnHNQXsc0mLC9Bsw3dAlwL4fjPnpQSXddhrR0aVjJ0E48nBIkpJYL3+yXoNs+GaoXd4PpaWezORaxWGH18hv1eWosdm2a3Sq3c/56y9obXYbu2BaVwbXvPXogS9wYJsIUQt493YC30yyEjEONQJt67YV31aexlqK9Yx6i0QpdD87B0F5Y3H15/7clLs78+LqV06MPe+cjiYovNDNONyycWMQFK0SyHtZa2KrHGkO1mn7Mso8otxgRmy+PLxPsQiTFdzl5rtZ+93jPKNH1MRH/7T0D2Amsva+zEp5HY96hTlhUra4cs3VUqe4aO5EN5+MH76dHonmx4llIaAuyyuurteh/ZrIdlMhvjHGtOPo21u1nsZXdy00azsnK4VDy4IZjOJ5CPoFyB0QZM7oPp03B2BTM9iyonw2dQ9NAvoNmC5YXdrPeF4etuAbvBdUqJ8kCQqO0QNMdj/k7BOUhpfwSYNsO6/bQbwF8twE4p0flwJKN/pXshi51SIjUNqqoOvW9Ult1QgO37nhQjxXg8dN+/jm79QlwvCbCFELfNXgdxuvkQZC8voPRwgnHaMvGhBFwde/RSmUFZTWzDXVcqHkJAKUVwCR8TZTmcPHnvWSwWtO1QstZ3nvmsQ1vFdK04dGLRdI4QPJkxFEWBR2F3u8vumRQFRa5pXM/iimz+XkfZzkfqOGSvJ8eUEZaZIZJobvM6Pe89zg3ryVNKUiYuPi2klIZg+DrKiq/VADJ13TC26IqZ2no8vu6GZykl6rreDwRv1M0s0dnrhq6r8sTbtC6wXfdYrdkY5SdmaA/ay2LX/fHHkuGixG6puHOXs9fZ0UA/pURMCTuaQjGFah3GZ2H6NJjcPwTixRRsPqzf7uaEdk7f9+R5fmjmtbF2v0P4lYJ3aGPQe81AlcLYjBjCNddhXy4Pv/rp/b2QxU5tS4oJXV6xT9xgozPXtWhryfICk+dDNluIp4gE2EKI2yKlNKxBTP1w8jE6AzZHdXOUn5HqU54QhgSaEzNBqhzKrmNzd5047K2/blqH0oqqtPR9T9M0KKVwztE1PYvNFm0NK/eN0AdOVruuY75cUpYF4/EI5xwuJvIrTjLzPKcqLClFFnV/KIu9VybeOk99QvYaINcaewfWYff90MinLMvhYoQE2OLTQHJud4bvdQbYIZ4YRKS97uFXjHtSSqGn0+tqeBZCwHtP13Usl8sbqh5JPpL6G280uV/ufsL4qqYP7DSO3GrWR9mR7tgnsUZTZoZlf/IoRz0eDaXiW5dIvh2y18ccF/1udc2x3cO1AVtAPh5Ky0cbYAvaxTZa6yMzr5VSaGOOXYe910TtIJNn+yXlVzsudj5itLpqZn/POD9dFjulRFgsTl9ldovEphn2CXt4KdWNNDqLIRCcI9sN1vOyJIaw/zcV4laTAFuIzyCx8YSluzNrj3av1KvkhhMRmw8ZgNGZYR327Byp3oJ49aAqhTh02j7BUCpuIUTiCVmLfb4bSgKfYnvr5vbKw8vS0LYtbduSZRlj44n1nM0Lc0CxslFiSkvyQyl327Z0XYfSlul4TFEUdM4T0tEAG2BSlhiT8L2nviJILjPNTh9wITG+yizWqrC0Pt62SoCDTYCUUmitb6pMfNt52rusikF8Zkp9P6wjPcX66z0qy05sAJlSIvb9iRlxXRTX1fBsr7pmPB6jlKKua5qmOfVIKGB/tOCVIwZPd18/dEOvji8PX3SeWeuocsPaKL/u7t2TYhjleGIWW6lh/Xo7Jzb9sdlr2G08lmVXHbN2UI8lupYyM8dus7HZkU7ie+O5zBVBvLXDvpOCv0YGO1wze72nzDRaKeru5M/JFBPt9pLlk9uE+Qkd158Cqe9JzqNHoyM/u5FGZ65rUVrvXxwxNkNbS982t2ybhThIAmwh7hXdYihfuwnJRwjxjsyMTt4PwayKkB340LQ5av1ByFZIzXxYx9bNTxyRQgTM1U+wVKZRmSFdrVS8WwzdYetLQ6D9FAphWAPoAwQfSDicc5RlSZlnhHqJnzX45YzRSobNh1L3lCLNvB5mp5YlOsvJjMJai0sJ7xz5MSduozxHZ4boHHXnD2Wxc6OpY8QA9ipZoCozuJRw/vbsK13XYYzZbwJkrb3hDLaLiTYmmtuccRHiOKcZz3WlqzWA3C8Pv7J09oDraXjmvccYgzGG8XhMWZZ471kul6duNjhkrtVQYXSdYtsOFyCuKHcH2Gkcy84zKSwr5ekvUBxktKLMhyz2lX0p9igNOtdEp44N3FKMBOdOPfs6xkgXFDYvsen419BkR9dhezfM2DZXZm21Rls7rBc/oZN45wMpcc311/uPqRSTwtL6gD8mi+36QD3v8fVQSh2XzQ03F7tesWmGhnfH7BNwfY3OUkq4riMrDi+5ysuK6P1Vx6UJcaMkwBbiXpDSsGa5X54ceF7rIcLwQZ6MIrlw7ezuLZZCQNGjlMFHhT/w4aisRVUTkl0dgu/d9dm45orHSEBCaUW7dLTLkz8YVWlAnVAq3u4MQXw+BpMPDWmewiA7xohSiqZx+L5DG0VVVeR5TmgW1MuAyiaMCkfyCwCSStRdg+t6RqMR6OGEKzMarTVJD1fwj8uMFEZTVAWkgO89ywNrqTsSSoG9RuxZWT1s83WUfMY+EOY98SoZkeP0fU+MkeLAyZQx5obXYe8F1i5BlE6x4g4ampH5Y4PHazmpAWRq22Eu8FUqUA41PLtKpm/vPWYPBHR5njMej4exgG17zbLx5IcO107tEGNPus7GWalpULvLQg5u13bd07rASpkxLo4ZaXgdxvluFvukZS/9Aj2eoKrJ0a7i7Aa+cKrxXHsjFJVSFOOVocP4McehvSD6YIAXnDtxxrbNc9gNro87LnY+otWwDOi09rLYywPH7BAizaKnrz0205Q56FFJRBEWi1M/9o1KMRK77sSKBgBsBqfMYPuug5SwV7wHbZ6jjcG10uxM3HoSYAtxL/AtpDh8SLsbK2lKIdF2HW3qUbkhtf6GyvluVHIOhYesom8b+vpwudlwMtnvdm09OwSUzfaQZd4r49490YxAcJHgIv0JY7mUUsPorhAvB3wpDY/X18M6uXJlKFPfC7LdU9P0JISA857ZzpKyyphMJsPILReYnZ/RN55yWjLZWMMtN3HtkrquwSiqrBwy1iGiYP/kKWUZlnTsia9WimpUELVCBU/Th/3O4XWIrBYZIVx9DJdRiiLTVy0f3JN8JCz6/RFp17NfpZTo+54syw6d5BszlFVeb5l4Sol2d7Y3IGXi4o7am7F8vRnsg/c5OKd5vzz8FAH7fsOzqwRFe4GauSJY3+uFMN4dmXW1svHkIxEHWcCHJek6pg/ErjvSyCrGxFbt6H1kbZRR5afLyF6N0YoqN0cqeoBhvJZrUcV06Cru/JHMv+97tLXXLA/fC64BRqMROp8Mn93+6GeLUgptLcHtHjf3xnPZ4zP1NhvK44N3x/4dOhcpsus7rVdKMS4MrQ84F+gaTzt3pAjlJCMvNDH0RDsnFjk4R3yKm4PFejjHUVcJsFWekWI6Vbd817WYPEfro/tRVpT4vju2m7sQN0MCbCHuBa4Bkw1rl4/5oD6N2HsCwyzmaAGjic2Nd329bt1yWDdlhuYiMYRDV+51ng8fmH0Pxg5NYkYbw5rs5UVod4bxW0oRfKQPAWUVrg34E7ISyurhYkIXSM4P5eChHx433y1TV+opD7Lruma+bLHKsL4+JUVoFj07j28TOkcZtsnbi+QrZ4k6Y/vJT6CiZzydYLQm+YgPab9xTUgJtCE3BndCmVyhNarIMbuB9LL3NDEREmwUlsSQ8biaKjN0u2O9jpNCItaOWDtQCj3KULm5PErtFPay1webAHU+ENNw0n+9Gew2pv3Z3pmCTsrExR2U+n7INh8XmMUwTFLojw+AlTGozB5ah31S9/Bj73+Khmfee7TWRwLsPacpG08ukvRQnYQOhP70x9DUNMPrs7s0JMTEZt3jY2RtlFMcM+XgRo3z4QLe8srpCP3lzuEqy9DjMXG5JNb10JwzRoL3ZPnVX/MYI03TkFLCFpbtfhun0vDZcsKF8YPrsPfHc+XHB9jaGMyBMvFDT8FHYkqUN/B6VZkh+siFSw2+D+SVpZpmGKtJfU+MLbrKSQZSlhMXi6e0j0tqG3RZXvVixn6js2uUiXvniCGQFccvp7BFgdIa10lHcXFrSYAtxN0uxqF8OavAlsP/X6MR2HFc71BmaB7V9/2Q3QVi/dQ3PUshkLol5CMCu6VvSh3q4KnyHGX04TWHthjGoBRTcA1hdoFlM+fcVsPCRRYpkjR0tSeeUJaoCgPJETefJMWw2738ihMlpYagOyt3g+xb0/gkxshisdhtUJYzLgqci7QLR7v0WDpW1hJtbqnbGrdcEOyYqBRFajBWgVIkH+lDJNtde97vBrCTIsf745veZFpjy4KYIpZA3XnmzlNqRWmHES3XCrBH+TCuq7tiOUGKidh64rInhYSuLGacDRc0jIKUdsv5r/367I2wMcYMM26XPdu1Y9a4/QD7evbPJkZyrfBdhwmBPqanfP8W4iQnrr9OaTjWpIjql7v/f3Q/VflQ2bO3D6euGwJSe7qS6Ws1PNubbnAtJ5WND+XhgaQd1o7RWY7vT9crJIVA7Pr97LUPgY9unmfeL1gpNfkpm3Wdlt7NYu9V9AD72euDncP1eISuSsJ8Qbh0CTebDY3HTgh8Ycg+72X4i7Jg4Rf46KldPXx2n/C5bawdSqJjwLt+GM91TKZ1//ZZfmyA3fmAUlz3axZCpF06rAdHIhtZsuJyU7bYdSTjMdaQkodqdOq1/Tcidh0pxKuXh3P6Rmeua9HGYE9oMKiUIisKXNfd9i7p4tObBNhC3O38brBnq+GDWqnrDgBTGBpi2Twb5id7T0wRPcogQnqKR1qlvoXoUNWU6B1K693SrP7QSd+xs1+VojMV23qNzQaa+TZZs8mZyVAKXac0ZGPr48ewqNCj0w4kRbJrQyXAHtcczlhX67tB9vZQRn4KfYy4YzK2IQTqemhQljD4RqH9bpdzq8gzxXiSiM7R2pydmFhefJLReMxo/UGc81BvojSEPhBT2i8PdylhFOS7Jw3HZbFzpTCZIWmL9oEmRua93+8cXmZmtynOycFnbjRGK+oDJYyxC8SlI/URVVj0JEMdbKqz1zjtFCcre5kwYzO2656tetgfRnbYtoC6rnXYPib6mNBuaCKngh/2DSkTF3dA8n6YenBcgN3uQPRQbRCrtaGyZnlxCPgO0MVuZY9zu++/DnVFJjVsb181k3dSw7MY46kDbDi+bLyeL/GxQ1mFIsdkY1IM+FMcP1PbgrrcrO1SvcAFz6iIzNw22+02Xbi162OPZLEPZK/3KKUwKyvYMxuoPKfb3ITZDNrj54RfGVzP/XCBYZyN6UJHMPnu5/bR1+TyOmy/u/766ksJ9tZnuys+Jzsfryvbn2I6VA6+vlYwGuc0V1x0Dd0cMou1FShHSnqYG14vT1Wefb1iXQ+juU7Rcf9ajc5iDIS+PzF7vWfv55LFFreSBNhC3O1cO2RctR4+pG1x3QF29IEQAlmZY63dz2IrM6xTTj5ed2Oq69LMUdqgijHB++GKcp7vd2bdo4qC5APJD+vklp3nwrxju3b4COPpOtO1B5hWBaM4Z910KK1oiIQQ6eorS/+WQ5Cal6i1+0mOyw14YtxtdjY7nDmq1oeTrXbnmkF2CJFLdc/Ftmd54GTDOcdyscT1geQ0XavIlWJ6piQvLL4PqFQTfMfmoqUzBW1WYX1HYQx5UeDshBg8yu/Q90M39L0Au4+JfHeUlbUW59z+Gus9ViusUejdTrU+BpJP+wf9wuqhd95VGhIptZvxcXFojLdwpM6jMo2eZOji6PgZpXez7tfIYMcYabueNig2a4cLidUqY6PKGPlE5hONS9c1D7uJkRQC2nXodgvdLTBImbi4M1LXDQHklcFCvxyO4eXqcMHPFENlDRyZaqCybMjU9f2wfCaBLi8H2Knvd0vAT+72PTQ8Gx9peLb3vrKnzIbvOVQ23jqW7TZ9H6kvnaNZLOiajuXWedw11rbGth0y7FrTOs8nd3ZQKWNq11nJV0gkdrodLjYXWbolMd38+1hrxaiwNP0wF/nK7PVBylr0dArTCXY8GTLaFy/ul47D5eA6hEBZlizDkkRirVhjZEdopalDM1SfHfO5rbRGG0PfNLvjuQ7vK+GKgNdYizEG5/r9LLYPkRDTqcdz+b3u4H0gKw3VdJhcMS4MrbvcUTx5T/AtuhhjTIkyCe/7YW641sT5zU01udK1xrUdcY1GZ77rQKkjzc2uNFzw381iS7WTuEUkwBbibhb8kNk4OJczGw2ZD3+68SkAvu3BDMGYUoosy/ZLi1WmUYUhdX531MotlhKpnUM5BqWIIQwnCdaijTlcJp5ldCGytbXg4qJj2Xlyq1kf5ZypcspMk5QlWztLMAWpX7I2ykhK0ZDwfcDtXShoZ8O/fASjDVRhQath3XlKsLfuMYaj69qrteF+7c5wMnzo6aQh2KwdO9stW1sNftEz95Ft56nrhtnWgq72qGhwweFVILOBpm+4eH6Ltm/wbk49X7IMgdF4SrV+BpVb4mJOnucoY+nMGJTHtzuoEDFaEVPCp0S2uz4tyzJc55lfmNHOD2c1Mq1ImaYLCqKn0mo/c5OZoXvswTJxP18QmsMngaVS9POefr57QWaco0s7BNInUObqAXZKic15zXbdE7VhUljOTnIKq3e7vidGWuNjwqfTNzprQoC+w7jl0BjJt9jg6eWkSdwBse+HAPlg8Ob73QkGo8PHdW2HINtkQyPG7vK6bJXnpK4buodbc6g8PPaOlDzJXf3zYC8oCgeCohACWg9TCW5Epi1VWWAKaHYWNNvnyHQkKyb4tqWeXaTe2Wa5vUUzn9E39VC1FONwwcAH+qxgu+75i/MX6VzgzHjKvPM4b1gv11kv18lNTu1qLjWX2Ol2cOHmxiqNsmHCxHKxfSR7fSXvepQxFGfPDBntorgcaC+Xh4LrOtb46FnNV7F6+KwtTUnrW6Itdz9rjmbkTZYN2dMrxnOF3eVEB3uMKKXI8oLgLjc6a/3QAPNaAXbc7Q7e1R5jNdU0Jy/t/v5ZZQalYLm7JCh2DZEek02Iy7TbdHLYz/RkMlzYOeUYt9OITXPiuLbjqMye2OjspNFcJ8nKcrgQfUKvAiGu183NPRBCPLV8s5u1PlDiZIvhpMA3YE/XmbbvepQ1PL7TYrTigWlB3/c45yiKAl1YYkjExqN1NqyjvWXPoRs6iK+dHcaExYje7ZJqi4K+aYZ1YD7SuEAfNabtmK5OKK1B6721YGGonjQKk2s+smVIbccDRce4ylg2nsYnVO3Q3RYGN3QJz4dyxqGreDaUNzcOFZrLFyv65dGTrHJ1+G87AyDpamjm4yKQcCnxeO/IrUI1PcpEHpsv8U3HRpkzGY/ABpplC1GTlxrvoSgLxpVCd4ZFmzGaFpzJpmxFj68qUrMkjSfkeT6UlxerRH+OvNPAeH/9da6G8mnfJ7pLM2y7QE1WKMYPoncz3blS1FrhUOQKRgbaPjDO7TAbNtM0u2NwUkqESzugNPoZxZCF7jyFH55vazXF6JRzaI2GYyoiUko0LrBTd7R1w+pkxNqkvPw3rt2wZAFPlhS50jQuYRgatV3tRKkNkaZpmfqaygLlGkZdwPQLXLaBi4nsKhcFhLiVhgtxDrNbTg3sVs1sg86gWDl6J62HXhDtbAjCo4dydQjq6gblHHoyPXSX2C3p/RY29VjWT9yevYZnYXtnGIG0u1ToerPXh56jjyTlqEYjVLfEG0NwLdXqg9hMwyhi9JQU/DBJoetIsSHGRD1b0HUeozKS1vjY8tz7NrhvUrHsPIvOE+JQ1bKSrxCzSOtbGt+w1W1htaWyFaUpTxVAHaS1YmxgOW8YV2cwV7n/XvdwrQ1oMCsr+03Qlpc28TEwWlujiQ1d6FgtVskOLEOqbEXjG1oiI22HMvEreoBoa3FtS15Wh57L3sVi30fsgWU4eVWSZts412OtpXOBwh6tJtr/O6WEa4eLz0orynGGOabbuFKKcW5Z7M4d9+0MleWoVuEvbKJiIgVHDAlTlsSmIc7nqI2N6/4bHLeNsWnQo/GpH2u/0Zn3R0bWeTdcyLlWefgerQ02L+jbhuwq8+WFOC3JYAtxN3PtEFxf+YFjyxNna14p+sh82fGpuWOncVxa9MxaT5ZlQwC3+xiqsqAhNu6WdhZP/ZKUNCovL3dL7Tv6tiFow6x2nNuas+w8mdZsrE3YyBWVUfuB13CnSIgRbRRNiLReob1iUS+Zx0S0ipZAs7xEt2hJxdp+cL1HGTVk65fLoVQ8Hw//gjs2s5CyKTEVhEuXCFub+N7hlGeRHH+1nNH1DasmMN9ecOmxi4xCZLK+gjmzSrk2ZjSq0HnF2nhKkVUURcnK2ghLT1w45gtPYUcYpciCwqkCpQNxudzvqt0nTV9MyPqa1C5waSjz1kCz09Cfu8DIz7BZR6q36evLGYVMK3oFDs3UZmQEEmk/i11YM5SJ+0hsOgiRFDzuwhx/qSG6SDbKyVYK2uvIAg8XaA43Omtd4OKiZ956dAycmVasT0eXg+s+kHxElZrULolNzdholDY0LlyzTHzedaS+YaoDupxCPsbkI3S3RKUkZeLitkrODd2+99Zf7zc1S0OFzO4x3bXt0eZK5cpwG98OS1ysIbme1HXo4vJF1SHjtkCXBSG218wm6qJAFzlxPifsNso67frr45/j0D2cZDC+Z7K6Tgo9fVdj9AhiRBtPXo2oJlOyySouHzNPlrZ15FXBWAXq+UXyrqEKka5eUmWK1Srbb3oYYkIrzSgbcaY6w1qxhlGGeT/nUnuJeT/Hx+vrIzKiBm1YxKs3LgvOHZl9rYzB5TlpZUo1ndIud1ic/xQjp8n14dsabShsQe1r0n6T0sN/b6010XsOfsqHEAl++LwL/vBIRWsztNK4riPEhI/pxPFcMSaaucMdKAc/Lrjef13yIYs9bx2+m2OLCXE+VHHpxpMYAmwAM5kMS7qa0y1ZO2naBwzd5Emgq9MHt8qYYfnEMeuwXdtisgx9Hfv3Xhbb9ZLFFjdPAmwh7la+HzIYx5WvZaPd2ZpX/yBwIXJuc8a5eYstMp5zdsy0tJybtSRthivbux9OexleEvvzjI99zK47VNZ9VTFAtwRboYwhhoBSisWy4dylHWZtJGpNQeDspGB1lFGMhg/YK5udRR8JIWEyzWbdk3eRNZVTzJdMtcboSOw32QodO2pC68yx66l0riE2RGeJARLZUJa5WwqeQiK0jm67pt1aUveGGkPdbdK0m8yalnObS+omcl9WEn1El5qiLHnWMx/gOQ9sMKpK5kmx03t8TORBEWMiLwz0gbC9oFk6UmmYrq1gJjlFaem9IQKpd6Td7tpN2xGKEbocw3JnOHkNieWFGf7iJQoWjJ+2ilpbh9Tj5vV+h9xMKZqU0BoKm5NSotBDFjvERG41Su2OxVo0pKhR2hLdMHYLNewXo2wIck/tQKOzzgcuLTp2GkdmFKuFprJQlZdL91KIpDYMzdLCEJhAxEQYFRmNC1ctE/chMKtrpqkhK6qh6zygywkpeoyrZR62uK1S3w/lrntrarvZsNynWh8qkBgaW3X1En/cCX1WDSXjKaCaTfD9EIQdWKMbu5YQW+x4nZQC4YrlLMfRk8kQmO+Wit9ogJ18JAYPZrd/R4rkq/eTFxV9NyPEhIoFfb9g2TkuLjq26p6AYiU3PH1jhac99CD5dIorMh44exZrM+pmQb2zQ6YS6+OcmGBz2eMO9IrITc5qscqZ8gylKelCx2a7ud8UzXXHXLQ4KHiU7xiPp7Q+7q85PnKz3bFZ9orGY13X0fc95WgEq2PalZzxaI2ijful4wc/eypbEVOk02a4wOIPB6Qxxt0M+YHsdTtkm/ORhXR4LbbSGpvnuK6ndeGq5eH9bl+SK8vBT7KXxW6Wc0LwaCpi61DjAuUTyXf43aaXKsvQo2p4vte4gBlcpFt6wgnL0GLToMviSCb6Wo5rdBa8J3p/6uz1HmPtUK5/ijnfslZbXIsE2ELcrXwznIhdOVIKhjnRJju2KykMB/95O5zUXNppmExKnn3flDK3PH21Qim4sOhR2hyaaXqo6dkJQXbf1Lj2lE3WXD1kim0JWUbwnqb3zFqHBqY5PLAxpdAJGD54ldbDWJmDs1/TsL4aowgkFjsda5Vlsr4yNAy7sMmZ+Rb3VznZ2v2cV4pPzVtmy2PW6rkaXUCyI9q/fIzusSfog6XZ3mFx7hKz81vMN2c0XUubPN4oQrFC1Cv0y4Z23qKKigfOrLA2tTR6TrmRGE2n9F1EK8VGZhkbzfmmZd4G6D1GK3QfSHUNsactLOXqiKIasuxllaGqij4oSJez2D6CD458vEakoNu+hH/yPGq+zajsyM+sYFYeIF85Q8o0fr6N3y0tbGMaTr5yA1FhrcUShvWHu1nsMhvG1vSzJYvQsqNblmaHfiXiVcAtOwo/NJFrTxlkK63wKbE1GxrUKaVYH+WsjXKCH8ZvZbuBwlAa6EGDKg1x/+QmkkJknBm0tsyaky/qbC1rTDdnrSoOZQdNXqJsge2W+JSG+eG32fWOGRO3RwgNMd669aNXOjSeyzVDw8Ry5dCynr3AOpx08chkMDpDQqPabVQ8PHXBtzsoa8jKdUxe4bvZNbdrr+FZP5uhU7rh9dfJR2LqUFYTuxabF6isJB+tkKvIsm1Y1JqLy57t5ZxMa9ZGGWcnBVX0mCIHrblQLyiLjPtWz7Idl/zwH/8r3nP+AzTzGSoGzoxzjFZsLfsjxx+jDZN8wpnyDNN8SiJxYesJnrj0GFtbF4gnjbPc7Rw+Gk/QSrE8ocHnfnn4gaCv6zq6rqMoCjAw7+eU+YjVM0/Hnj0zlPMvlrgL59naehwXHZnOyHVOHdtjm5QG57C73eJhyDoHF8kKgzEapdWRwDQrCnzf0bqwe6H0aODsukDfdvhuPlwMOaVRbkj9jDZoaCPKKrL71lEqQ7U94UD/F727BCIujp/lvv8cdy9iXNm0DYZeBcmH0zc3O+iYRmeua/cvQlyvrKyI3uOv0p08hMBisTh1803xmemuDrA/8pGP8E/+yT/hr//1v86LX/xinv/85/Pa176W3/3d373TmybEUyuly+XhJ9mfrXn4A2uvFHfRenoXKFXiaevj/fmYudXcNymp+8DCD1fPD455UlajCkvqA+mKE5rgHdEHYgj75d5X5RqSylDZsFaq6TpmdcuoLFkbF5gYh+zAFTOxdVEMY2n2nltMeBcxRjGbdygFa+sV5cqYvIrUy/OkaMjTGs8qS542znEKzs9bnli0LPeCnJSgX5Lykq7vmD3+JFsf/SQ7j+3Q7PT4ZgnWoooCk1Xk2YjMFJR5iZ6u40erTMY9k1HHOEtcmj1JdA5rFaaEetnvnyRNjEbNHWnmWLiILjS6sujCEUg4qxkX1X42yyhFNirx1qJSIrZuyOIbO8wRNzBbGvqLO1TLJxhNHXZ9DTW5D2xOOZpgxyNCN6dbNqSUWIbI2GqM0UMX8iwfRskcyGIXVtMuF2xtXSSMLcXGCikEls02M7NgS+2w7LaY72xzfnuLxje4ePLs9K5u2JrVbLWeEOLQGXyck1uNc44QwnByuis1HiK71RNp6CI7qsAokvPomJhUOcum2z9JO/T7uo5lvcNKDuZAdnCPraZY36KCo73NZeIppWGU0YGuw+LOSyng/QzntvB+TroF3akPPX6MJOeHZk3BDc0Ss/LQkpW9JkxK66E3xUn7hzakbArVBJVa0vzS/v1DO8OWK4QUMcUK0Z3uooEej4gpoU5Z2nvsc3SRZHpStKSuwY5Xhh4LKafxiZ22YT5vmZQj1ivPSmWGJSl7naJHIxZdz9I13DeeopTiDz75bnyKvH/nLzFZRjufEVzH+iijsIadxrHojgaKSikqWzFOBWMqRuMV5v2Mcxc/hbuy+dv+3OsxSuuhc7YPR7LYKSW86w/NT+77nq7ryPMckxlm/YxMD2vEYShZNisr2LNnaEykmW2zvXOemCKjbISPnl7bYZ840KgtOEdWjoje75b9DxdBtR0mUhir8O5wmXhRVvgYqev62PFcMSa6use7Bm2gWy6u4xiUyGNLH3PcosWsDK+Vno5RbY937X6VlNJ6WJPetFcfmeWH2x93DE91PTTvu4GA+MpGZylGfN/f8Dpqm2W7a+JPfm94PzRKPW3zTfGZ6a4OsL/927+dX//1X+c//af/xAc+8AHe//738+xnP5tXvvKV/Mqv/Mqd3jwhnjq+G0rAs9HJt7G7V3t3y81iTOzUwzprSGilyFRirbSMRoc/bFaqjJXC0rjEso+HstjAMH7JamITLo+1Anzv6LuE67h2mbhrIQYSGcoY2q5nZ94O66xXx9g8x/fDCabJssPdxItiKFXf/V7oI8FFYojMXGC8UlBkBro508wTM0W3soEqLamLnEma+8sMi8IvPTtd4ELvmS1nLOslyx7q8xdQpiWzHtoObSZYElmeUVYF5TinnGaMphm98uw0DcZm9Bjqi0+y+ORf0nY1G6NVQtdD5ggp0S57YutZXliStjseqEqysxU7uaYnkLqaZcwwuabKD/9dcqVw4xHKJFJQhNkCpQ1GKWYXtmgvbWLLkul6hjYRyrX9gFIpxWjjDMZGmp0d5o3Dp8SaNWCHjtykIYttkgcFi87Th5qti+dZeAXr92GrNdbGZzijp5wpz7A2WWe8tsKosMxmNbOdbTabTS40F/a7+i77JbO24cntGY995BNsP/kk49KwXmSUu815Ukp0XTdk0Xeb0+ytu9aVGTqP787F1ePx0KU8BfCRlWoIyHeaw6W03nsWyzk2dYzHq0MQc+XbpJwQ0dh+cdvnYe+diMUYaU9Rdihujxg7QGHMhBAaerdJuIXzlveOWyqz0GwPkVK5dug23vWQEsYO6z5PzGLvPp6enEGvnCUtNqHepF1cZNHtsINjs92kJkIA765dJh5jhNEIHcKhSqFTPz8ficGBSaTeo0iQj7mw6Ji5Ya79AysZ61VGnnKMhhCGaqu9TtFkGReWc0a5ZaUYE1PkfefeD8DHtj9OKgxZWdItl/RNw+ooY1xYlp1npz56gc91LX3TMB5PObv6APeffQY+eZ64+AkW7YFxUvtzr4fP1iozx2ax98vDd2eOO+do25Y8z8nyjO1uG600q8Xqkexx0oq+spTlBN/WzPs5uckxytCoBErvV5+F3aA6H1XEGGmWNfPZgs41LPe6lOMhXQ5SYQgEfRqWbB1XHt7Vjr6pyUtDtTJc/OhPeUElhIZCBbSzNM6jp7uNQicVWmeExZx44LxAj0YoawgnZLFTSoQQUVoRw+FxkikEYtffWPaaw43OgP3101l+uk7kx8nKkuDcie/Jvcy1ZLDF1dzVATbA933f9/Hggw8CwziaH/uxH8MYw4/+6I/e4S0T4inkm935qFfp8Kr1frlZ0wcuLju6EIbyLsAYxdRAbjN0dvgKt9GK1dFQetejmTf9kQ+L/aZntd/PyvZNi9YWpS1dfY2AwdXDc0iKoC2b8xqCZ31lhM1zTJbvn1hmeUH0fn9mqjJmuDK9e/Ln6mH+cm/AZZr1MtudYb0gm9xHUU1Z9h2qMMN8ZqtZQTFWkPpAvmzx9ZJLm+e54BRNFyl9olobU6yPKceGPNdkJpCFBUo5vKtp5ztcOH+Rixe3sbFnlCu6fEo+WsVkjqdvrLG+8QCjrKJdboHzLM/XhM6zvewwleXsAxPOTgsyrdhq5syXNa3RjHOLuqJCIdeaYEooFabK8IuOZmuB2l7gtrch95TTCnXm2cMJe7t9udHd8hK6mzEyDWw/wflzj5O1O0xCjfY1IXXEtiM3Q8YsRsdfbV/kY/MdVGNIk1VUZqlDRBXlMKNWaQpTMCkm3H/2DNVojTWzxqqbMGaExjJrOz6xvcVHLz7BExcew/kleexI3ZIYw36jM7c7VmYve31w3bXa3T9j26LzfFgmkGXAMLvbGM2ozIYsdrw8f7ata3w7oyxHFNXasbuhMQaVjzD9kt574m3MJDs3lMOXZYlzjk5GwNwVYuzQOsPaMXl+Bq0s3m/j3DYp3fxJc+p7VGZR3Wy4UFquHWlU6bsOpQ3Ba6JXQ0B30uO1LaoscdWYWUhcXJ5j88IHcCFRFCuopaP2DX2E0C+v+RxCCKg8Iysz4uZ5UrMzNGA7ZRnx5fJwQ2w7bF6wjMNn1ZlxzurKKqM8kecZvnOEYAmhHo4HbYuqKnbanta3nB0N2esPXforZt2Cp0/vJ6bEB879OcVoTD4a4dqGdrFgnBtWq4zOB7Zqt59F9c7RLZfYoiArK7quwyTLA+vPoMhKLm09yaXFRbxr97PXe38PpRSTwtL6cGidt3c92hi0MTjnaJqGLMvIi5ztbhuA1fxocA1Qu6FiZTraYBwL2m5J7WpG2YgudHiTgWuJIdDWS9q+p+sdTdsy254RY6Ial1RVRVEUeO8IMeAPlFdrrQlkqOgONwNlKA1vFzXGRsrJFGMz8qrCtc2pKs98N0ergjJp+jwn7S4j0FlGNh4Tm/mRknU9nZJ6d2CJz2UxJEiQlWa4UHCg+WVsmqHXx40G2Mag9FDtBENzM5sNnyE3au/+x63FHi4WDOPt9i6gCnGcu3pM16/+6q8eGSFRVRUbGxtsbW1d9b5762T2zGbD2qQY4/7swLtNjHE/2yE+g6UIfQPF5Ej595W8ylnsXKQrcqqiIDeaWeuGALq0LJaOzBoS6Uhn8NIqqkzTusSy7SjmS1ZXJod/QWmGsVZ1T8ygq3tMUWHzjLZ2uL7D2GO6sMYwlIdnE7yv2VGB4BzjTA+BdUoorUkMmYesrEhA3zbk1W7WPssIdU0ajWm3WrRV7BgoEhSpJ/aLYdRNNqJyHXW3ZNnljHILpSHpSNEHZssl9ZbnzHrO+iinqzaYPbHNMvTkuWWSBaDBu0CaLTHzGWrjQUyVUwdFp3M2zhSsjAp2nCf4JVmRQX6G8twlut97H8X9z2RnxWLKJUGNqXvHwntWJrszcDWsoph3S871Cl8lziqIerf82w1X9zOjiMrQJk1RJOo20n7q46w/tI5ZicywjLIpsVgZSgzrS7C8BCYntEtUPsWutKhuwXK+ZKM0oDy26/FdYL5U6LHhwnzG3NV0qmQ1VKzEjq5UhM3z1LZkPB5hYyQ0DXq31K7MFEkr2kyhe0277XBKYcsxG7ZAaYdRGbWvaYMjXy7xeWKUKbIqp23b/TnsIQTi0gEKnavh2Oc9se/RKyvDumVjiF2zuy9pJkXGhVnLrOlZrTKapsHV20SjGY3Wh8D5wMnO3vE0pYTOx8RuQeoWNNZSmaf+2vJeA8GiKDDGkOf5fhY7y0457kzcckNpZ4e1k93PWoUxK0BHCHO8v4AxY6wdX+uhThTaFqU90SWoNoaM5YFjedwdWaV0OZyToHF9RxEPVyyllOi7mrrZxmc9MUWIkdJOGDOMqcIllBrW79Y+QLvAFAusnQ7vh+gP/AsQPb5eYFJE5Tmh3ibhMKMSUMePD7vy+XWeoDpUyAndEibr1J1jWlq0gmgKSDtYHQjJ0PcBmzlSdxEdEtiMi7MdRpllZIfX4F2feg+kxDe84Ov4iT/6v3nfkx/g8x982W4GWdEuFwTvKScTVkrLTuO4MA+s5ApXLzDWkpUVy+Xy0MXiwowJbWDz4jmW9gnWqzHj8f2H/h65AUVi3vSsjfL9v09WDOMsm6bBWkue52y324QYWCvWUKgj52sxRRb1nCoUJG3IvSV4xbybM82m+N5zMXpG7ZLUQds6jDXDhbhqRLd0TKYjimI4Rhhj8N7TNLvHjmI4dsWYiMaQeY/r+/352TFEljs1wbdUG1O0Mbud0Av6tqVZLKimKyc2O4vR4ZsFqkkUWtFNR8zbnkk+NA3Vkylsnqed75CVG5fvaC1kFj+bYa6Y/e57T0wRbYbXx/Uepe0QrC6XqLLcP1Zfy9AQ7vDxOxlD6jtCawjek49GN30ebfOCrl5iy2JoQLdrr/t+VVXDZ5BzNzXqTtw6tyOGup7Hvqv3iuNOQjY3N7lw4QKve93rrnrfH/zBH+T7v//7j3x/a2vrrl03EWNkPp8PB7GbuPr26WJ/fNRNzle857gG3c2IIwP6+DLslBK1izSdJ2tnjMaBZT/lydZjzRBcX6oD7daSajKi3Tz+qrX3kWXrcb1jtrPNA21DfsV6rhQSNJ7ed9TLjtF6pAsd7cLjkqOaHnMi2i9Rbkkwkc2LM9LUk3VzXAqoqmK5G2h09ZK0s0M5XaGvl4TtbaqVYf508p6wuQXbLd0sEc7mXLhUs65hvpyD0qSqADpU19LVDdu1ZzUfAri9q8xZAW0fufiJ8/i1DJV57PaC3tecq1u2K8ua24Gzz0ShMF2Lns9YtCNaYJIbXOM4N9vhyUVDvrVJ+NAHGX/oYyzPXYDYw3QF/63fxKX6SbQ7w4VL4IrAmIJtIsqbYeTO5pM0saKPjo/7gkl3EdtFiAmUQo0tcx9o2ppq53FmO4pQbxPrSG1yLnqNjQ199MMorJBQzZPQzWje81ekyTrl857FZlR45zm32TNTGdshZ+F6xl1ChRrnW2wfedBY2gtzmrhga3tJ1W5Tmww3W2XStWTLJWZ1+Hu4ELlwseXi5jCbNkuJwkPa6YkWinFJd3FBMJaaQPfkOarJOrN6ji6Gk6mqqob1yO1Q+s3Iovq9Gdg1cbkEWlJqUU6h6oQqAmppCCbRLmrqtmWZK3wzQ6WWutxAz+Z0VxwnDh5PQwj0ixZX19RtYPWYNYu3mveetm0plcIUBcpauq5je3ubsiyvq3tz0wcyo7C34cLAp7sYO0KYYS0odThDlZIixpYYt1DKovUErU++GKK6GclWQ6XO3mN4T7x0DpsnGK+R3BI4XLbt2oa+bVF6OHYuFw3aODofQClcdHSxwwVHWMwxLlBkOYUp0K2mDltQZ/hC033iL4nZiKQ0fbPNbGuH6WyT0q6jD6wtT0oPpdHasmw6bF7S6JxoV0k7Dab3KD0nVVc/P0ohEZctIZsTnUEtt2lCRTIR2xoaGI5l7YLkZySzRmc8ISyx3Q6ZXmPeBy40WzxzZYWtrS360PPHH/8T7hutkXUtD+QbfODxP+OJh56gMEPFS/CefnsbtjYpRmNQmp2658n5nGllGU+nXNqZkVKiLMth9FWMw2dB0sS5Z2v+Sc6Nx5RbS6b5lCIr0Fqjtab3iYtNz0J5CG5oklWN6PseYwxFUXB+dp4+9KzkK8yaow3lUkgslzNc36NGa3TG4bZn+Asd8zXDk/FJcp3Tp54zSmEbRxctxXhMXde0y4Z6a0HKNaa9/F5PKbFYLvHtNk0/wVhN6yLzZUPp5lw8r8nKIQPczHvaxZxqmkNtSTsz4s4OyhhSntP2HflisX/7K4WwwG9dQm9b9FTTu4ad8wtWCkdTe+JkQtN0LD/5GL1Oh87PUgjErS1U0+w3PwPo6mGaxhMzKCJYoyhGQ4VanM/Ra2uoq1Rw7Nk7plZVdej4Gesamoa+KCBFem7+nDGlRDvbYdG05Aey633f45zDOUdd1ywWi0M9RcSdcztiqPl8fu0b7bqrA+zjvOUtb+Hs2bN8z/d8z1Vv9z3f8z38L//L/7L/9Ww246GHHmJ9fZ2VlWtfob0TYoxDt931dQmwgaZpiDEyHt94JuGeVF+CaQWjjWN/3PvIrHXkWWJ93TKOI7quZkdPuH+iWa2Gq8dN3VBGy/TM6n4J7nHKuqf3gaZeEk3O2tr0SMlZ7AM7n7xAvjpm7WlrbO9so50mRs/GxjHbufAkM2VzAZMpnHnm/cyf9BSjMdMzZ/dv5icT2sWc0eoqaWVKM5tRrQwlbSkmXBvpvKa4v2S5lrPhAg9mjgoF47PD2kYgdAW5ucB5r8HmbKyWZFm2f2W5a2suPuYJfsRK6zDTdcouURYT0v0PsLH1BNn9D4DS+AufYtEHcpVzZlpSlZa4tc2lP/kTzvz5B6nOfQo0lNN1zCtfAaEn/sm7eMb2JucefDrMLQtlObOmOTuakE0KdG5Iy0vUzYSNyVnWTMdSTfA+Y7KiqcqM1Pqh0Zf3zOcN4wTm6Suk+zKmWPKNZ9L7llVyypUKXeyuPdtR1H/xMfR//h1QFvfJl5C+8GVs2JwF0EY4s7bKKATy5RybZ6xOHiS1ibhwzPoFUU84c/8ZijzjTNihTYaRHxGWNTor8cpATKyt5mAUn3PfBEWiXtbE1lPanBQiTeEYP/MsG8Zz6WOfYEJJNhmzjA2TyYTpdDqsu7YeXdlD+2UXGmKVoyclSk2IvsVkGlWtoJRFjS1luWDhILmW+6YFTXGWSbXCenb0o+zg8RRgWRaEfhtXZayPjy/tvJWapmGkNfmiR0VDtrExNIHaPa6NRqNTHedjTLhFR5EN5bHi5jg3I6WcPD9zwi3ODFk8PyMljzEZxkyO7i/Rw7IbuoJX65e/Pd8hjgzmvqehTjiGL7e3SNUUpQrysSH4QF5GVJkIOqHRTNSE0pZoOyGvxpjpMHrOW0M7f4Js4+no1bPkOxcoc+iaBqUnLL3CjxWT0Qp5sTocI7UdsugMGThb11RVhbW7WcRLl1DJYUpgvHqkUeChp916nAHGOX67IWRn0NP7WNWa7GCVlLakeptICVVGXecEX1Osj9gOimeubvD01bNorfjjJ/4EdM8XPetFrK6u8HkPvYDHP3yR8+EiD9/31y//7nCGdjGcQBejESNbM8sMqRiRCKytVSe+r9L6iGZnxDLltFkk6jQk7G0xnJDHnjo6grU87Wln0ZmmaXqm0ylVVbF0S4IPPK142n7Qv//YMZG6MJTDj3s2HjhLlY+o65pMrRM2Z6xMVqkLR5mX+OQZAUVT0zJitL6B1oalbiiUZXV99VBzNYC1tTUuPblFWVRMV8fsNA5TVJi2oKpKxqtr9I0j1dusPO0Mk/U1lNaEnR2SMcM4q76nBwIwWlnZz3rvP4+U6DpHWE4wKxXZM5+GGhU8sbOFT47JJOfMmTNDldK5HVamK2T54e2MoxGxrjErK/vro2vTsYyR3CjwkYkxjFcL/NYWqqowa2sn7m8Ht225XFKVBVleUB5oYhbHY/zmJp01lCurZLco4O1HFX3bMl5d2y85r+t6aKpXVYzHY5xzTCaTazySuB1uRwx1PdUK91SA/Sd/8if8yI/8CP/+3/97nva0p131tkVRHHtVae9q5d1KKXXXb+PtEGMk+ABpuGqZ30B3ybtJ6BsSYPNrrDPaLeGjWhvWWB/8UUzMO0/rApkxbIwt1mjqxrNsdxhNI6uTocQwpUR0w+umMzs0lWFofBJ8wliFthpjNaujgkuLjlFVUbcd886zPr7ivZMlfITKZmjU0FBrdcT8wg6ucxTVgdv7DkjsxAIfGtZXRpgUSCFQTSbDvh2G8uCsKOibmhg8eVnRW0v0HmtzUutReUHqG1Jh6YCJgYoWXU5JJtu/khxCQgNrhcZlFVVVHbpIUNFz9v4VnniiZ94PtwvLlvH0Prp8ikvnMZub6I0Hmfcj3Ow8q2OLfvT99B/5C/qPf3TY/nFJ/PwXMXnZFzB+wYvBWtLODssPfBD9nveT33c/Xd7TdZGVrsCuGExuUURiPafRFUVmGXUdVVGyUyoWmUZZTZVZ3Kwh7swJKKqNDBcd+fr9mD7h255RlhOJJJfQ1fA6Nu2C8OefRGnonvY0lu/7M7LNC4xe85WMsoJ4aYe8r1nYiA+W9eoM02JK19bMuiWkDp8XnJlOqF2kyqYsFtu4fIXl5ox0aYvx2hrr04ppkXF+0eFjxHct2mjGZ1dRAeaf2MQmRfCa0o4Y379C//gCvSzJVob3b992ZN6gi2z/AkGMPa7dJrgZ2fp9ZMUGSil6dRFUi2bIkmhlhgZtXU3XzkhrK/hyhTVrTzxeHjye2rxAxQrvW7xao3gKj7ExRnzbYpoeZSypdaQuYKqM0Wg48W7b9lRBdueHSgwXhtfhM66i51ZTHmvKq77uWhdYex/eLwlhiQ8Oa6aYg4GVdyQUKvRAGoLSlIiLS+i8wIw2jhzDh7s5FKB0TjKJJtYsmFN4jfaalekGhSmwegiIvGqwVbV/gp/yBJ3DFAUxJex4jXwygaqhXS5ZC5HNYsEODffnDx7ZX5xzQ2XPgTJetbpK2NqCvkNXbhh9dILoE2QBlTLwLV02pUqKPIFHoXKDsRpDRtI1oQuoYkzpOxYq52JbE1XGxuQMqk/4OOfdH/t9TIS/sf4F2K7iheufzdv4bT544VFe9uDDB/4umvHqGs18xuzCebKy5L6z61ya1zQ+UY6K40+Ag4fYM7nvQaxLjNqWkCs6HMtuRuY0Bs10PGIRFIuuRrUzrM2pqgfoYkcbW1aKFars8md4SonUR+gCSkGfO0yZMyrGNPWwZrt82hSvNHhFubLGnCVKKToUNkSs8VibEVxEa0tR5aQQ0Lvnr94FjB3+XqPpmKZuGU8rXEiMiowQc2IY+pfUsyU2U0zWVzHWDlM4nMOOx+jxmOQcerlkefEi7ac+yei+B9Cjy/tWCC3KO8wSmI7oqpwuBpapY9lFVkPLfVpTrK/Tnr9EmrXo+w+fK6jJBLoO6hq9tkYIkZAgoBjnGcvocCERe4fyAbO2eqrz3a7rUNGT9TuEDpTeQGUjMBkqz+m8x1hDXpa37BhZVCN83xO8Iy+r/TL2PM/330PODQ33bnSevLi1nuoY6noe954JsP/8z/+cr/u6r+Pf/tt/y5d92Zfd6c35tBYWS/DuVFcVnyrOOWLrMUrT2/7QycD18H1PSpGsuLGRDbdC7AP9fIuUImp6H+ZqV1ddMzRfuaL5VUqJrbonxMS0tMM6Y4Yu0EunGRc5E3tg7EcIRB8p8nI/uE4x4fuIsZoYEn53DrLSChOh8VAZxbLpyKxhUlw+PLR1C7mmmJbEZmh6VlQFtdU08/pwgO1q5i7RZoapSZRFTr2s0WZYI0e/JDU7KG1Q47P7HcTzssLmBa5tMcGiUDCu8JsLWt8Teo11M9pMETXEbijVsdZSVRVZts7IOy4mzaL3rJS7J4m+B99RmILV3LETc7abGmuhKCekPtHqinw5Y2amhE9+nPG7fxc+9alh/jWK+nM+B/U3XoZ63jMoiorxgY7AanUV/fwX4N7/QUYvb+lGHUZVhFqBGmaY0tW4pqHP72O1bUFnmEnBGatZ+MDcBy5dmsGFbYr1EjO1NM4SvSFfPYupF7idJVVRkvqWvu2wk5x+60lC59B/8Rjt2fvh274J3v57rL/7v5L/yv8P/fV/j5377meruwRBMyGHizNc3+HbSLtcYJWjWLsfH0EBC58z78HEBWfPDGWmMRvKWjObEbxja9azWhW7FzI0vfMkE7BFiZ/3hD4wmpxhu9phOd9mMnmAPMtoZzXeWkaT6e6opMVQktu25Nka+fj+/ddV6xKnF0PHcwqSH8o9VbPNuMi4pMZUSlGesmzaWks0BSYs6PqGonzqKmN81xFmM6pqii7HhNk2cV6j7RSd6f1S+b1yx6sd2zofMFoRYqLzcb8ru7h+MTpIAa1zuroemi1eJSNh7RhjSryf4/02MRZYO0UpQ3BzfJxhVIHtl1CukJptUt9izj50bHANQ5+JJji66DFVwkbDpBgzMhUTnTHOLu+Xse9RWu2PL0opkkxE+2E9rO+7oVzaWLJqTNd2+LZmfXKGzXCO7fYi69V9h35/CGFo/Hdgn9NFQSwK4nKBDh1w/PSKFCIx9Kg8EfswzKW2FSOlcBGiVuAivh96ShiVo2jReoXcJuzaWTbrJzizNmG0WuL8nFmzw0eaJ3n+01/C6tr9xM6zygrPnN7Poxf/Eh89Vl/+Gymth88OpfHOsZjNWBmNWDE5iz6wtRx6NByqwjrQObzMFaBwO1tDCb0JuDxRjqdsFCtcmLf0/SVWqwnWWJbdeZa+Y1Lcz+jAVI/kIrH1kBIqN0QLXe+obEXXdiil9kvV7coItzkj68eUWcEy1XgSynsmZrc5VxfQRmFssd+ILLhIt/RkpSEvLeNxRdf0bO3MibZkVOTUzhK6ltmFHYL3rN63ut8XJe12Dd9rIKayDLu2xqgsqS+co9vaJKsLdFWhRyNcqKnnLX0bSQ9U6Jgwsea+SuPjhIvzJ1hd1EzLEj0q6La3Ke9fPbSPKKXQkwlhZ4bqe2IyLPuAHVlWskiIhsWsp5w15EbvX0i4mhACfd+Tq4AtCpZdwDdzsr4e/q62IHRLstHoll6A3Jul7dqWrCiH3iAHgum995H3XgJsccQ9EWC/973v5eu+7uv46Z/+aV7zmtfc6c35tJdcP1zpTOmOZUv6tkdFMNbgXcA5d0NZ7L5tiCHcdFfJGxVbT2gbyBIqavrFJoW+/0hX732uGTqDX/G67zSOEBMb43x/HeasdTR9YFJYxsUK9Iuhqc3uAZ+YsAfKt1w/zNYsRkNGO8VhdEbwibJPLPpE7xKZ6dgOGqYF43K4bbtoyaucfFrg5x10w9q+cjKintUEPwTuxEhdL2lSxbS0ZG0a1p7ubJGVBardAdfgtSP5GVmtsNkK3XLoOK2NpdupiRXYSUnT9cz7hmaesB607aG4f5hVqTX2UPayQruWkYW6D4xzi9EK+gVJaULjmVYlVJpzH36S8chy9v51VOvYeuyTzH7vnagLc0ZlgVYJ/eyHCC95GeEFDxNsSTlSRNsxyQ+Xg6WUSC9+mPS+P6f65HkuPf9pjO2cuNC0rSNbLQjzLeatQeWWEQ165Qxqd7TKxBrc+S1ivUCvVFAmmph4zJ7Bujm4Hp0VLNOcUnmUNri6o992+HqO+sQFYr0kfMVXYouK6dd9BfZpa4T/9Ft0P/fT+K/4CsZ/4wvwWUYyOarx9MuWbrkgb5cQHYVvaXYChc0xRcZ9G2fJ+h3GKhE6hS5LOudYLBe0i5psOmG0ezITY6Kve6yOpHKE1RmEROw00RSENCc3T8fPIoUp6E1gsbhEnkeU0li7QgoadcUoOWMqnNXEfomdTobyy3aJJTBafYDzDYyvY+yWtZZOW0zK6Ns5PEUBdoqR9uJFbJ6jxytoo2BaEpue2Hi0zjDG7AfZXdcdKnc89Fgp0fvIuLC0LtA5CbBvxjCeS5OSwbULYvBU06svGVPKkGVrhNDhw5y+vwRo6C6BHREI6H6OVprUzCFfQZVHA9SYIk1fc2lxnpgsRTbmzHgVqyyphIwC33fDcXC3RHuve/ieEOphtJcp8X0HZYHd/VxUWpMVJd1sRpkyVooNZm4ba0qm+VBevteP4LjPUj0eExZbxOUcfaDk/aDk9rqHW9zOAucMk2lJMsNF26KymEwTfSL4iPcFqZ3TtDto5ZgXGUppMr9N05Tk+YQ/2/oU6Iy/8czPQ2UalQzaVTx/49n85sffxYcu/RUvuO95+9vQ1TXB9VRra9TLJbHvMKOKssywVrPTODbrnvXdKRn7c6/LlaGpZtsQXI9SCpM0ZyYbxEKzdEv69hK50bQpocwaJjNDJlopclpCsGhKYhsgRDAaXWYoo1j2c5RS2GjpQ09VjUi7a4FVVaHz4Vg78iXOOHa6HXyKrBlN6BqC18O65GjxTb87h3to1ua6QJYbtB2C9s3lAlN0ZKsVxlraHU9fL9h48P5D64XjbpPKK899srKk2DiDa1uUzemWNc3ODp1eoM8vKItVxqtjCpsIvsNkK2AyHlteIISW7WZMn5cU2wsmbYcpDwfJuiyJTUOcz2mzMS5F1mxENTvD+vUUWewsOfvgScs0Duu64YJFrgMqG2OsxQFZYcG3+OUO9HNsa6DNhxGm9tZUPeZlRd11w3tzt3pvL5je+3/vvazDFkfc9QH2H/7hH/KN3/iN/MIv/AKveMUr9r//+Z//+bz73e++g1v2acwPMxfxHm6w2613jhTDDWWOvffEfhh/4ILDaEPfX38WO6U0jH1KCde1l7tT3wYpJVLjST6S8oC2Bdas0M0u4Obb5KvrqCszb8EN5eHl4RO+eevofGSlsBilSCkxazytD5ez2bGCbj4E6PkI1zsybVH2YCfPiM30fkZbaYXVBptBUVl0abi4DSZ0RO+5dCniRxlGJepZy9oDq0OKM9dEN2Sxy0lJPVvQLFomayOaesGyC4w2plQafAIfI6HrmBQKvCIVE5Zuk6QMdv4EuvDUdaQPER3NMEopdhgKVFKoakyWHGu55sz6/UP5/HF2L0yMtaNWGYtuaHiG74jeEPuIGU+ZxoYt5WhixfI//BrqT/8UX7eoepvJC55H+fJXkb34hbQ7T9JubuGKDG0tcbFNOR6jMo33gZTAh8hm71APfTbT9RX8ez9AevjFFP3jGDVnZ3uH8VTjLu7Q2FVWJgZDDgeWCnR1j1423H92jFGO5DTFyjrnO8/YNRSpY25GLLOcvK3Rk1XqzQVm6yLTp62TvecDOJvB5/8NQl6y5ueEz38Jm1NF9mu/zeTX/zNms6Z97atZ+J7CKZwyFE+7n3JeUS9nqNqj2pZkFNXqFF1VLEJB1A1EBV2HMgatNaMio3ZDRqEoCvrGgxsybcnm5GOLagOtD2g9Jeqa2M7QegVvPDZvaduWlComkw1UCMSYMFcEmVrn6LzENws0kWY2I7MtabyCtyXW+mFUzCmnu+xlG7QpiP0C73psdmuXnqSUcFtbhBAYnTmL8gl2ttBVQdSRlAKxAT0a+gOUZUnbtmitjw16Oh9JsD/ndtl5UrJSJn6DhvFcOdH7YcROjITKXzWLvceYAq1z+v48Xfs41re4tIHNI6rdJHcdiQqV290RcwMfPY1vaH1L37VYZRnnZ6nGJbmxBOdRGqyxuLYlOIcuDMk5Uoj7Gb4hOG7QwUBR0nUdRZaBUtSzHYy12DyjMwbX1FTjVXxoqd0cowyjbHQkA3eQznNiOSbWW2jfHxugxD6QtINQsthaYIs1qpGl9wmba2y+m9nLFCbT5OWUkOa0F2YsTMVW2GJsIqlL1KqnPLvKe5/4IKUtePH9LwBAWY3WFS8687n8xsd+n/ef+7P9ANu1La5tSMbgY2KyuoZR0C2XNClRjidsjHI2d2pmSrE+zqGfk5TGB01fb5NiJCtLqpUVQu+GTtGqYKPaYNbtsHTnWIaS2aWa1YmjshMm2YTeLahnl0jeoLPxcOFDQ+ocLgQ22zkZOXM3J8sLGjzgKTPDSmnRRU4MDpNVTPoRC7fDPLZ4s0JaLFDZKjY3BD9MQ/DO4V3CFgbfB/rWU4wystwQFoZCJfq+JyWoFzVFpqmmly/+xq4b9p+ywLnt/coLgD5G+qxge1mT8BRr69hmE7vdkW3WFA+eoVQRH2tQBmNGFClgs5KVwqNtxsVRxezcEv3EFqsP3U9+xSxuM5ngN7dYzOdk4xGVGrLyNrSMFSwaz5lTnB865/DeU2Ua5RLYCrv73KPOhufXg1kHlfywRK2vh54DWTlUA5r8SNLitLQxmN0sdrLZkfeOtZa2bY/tbi4+s93VAfbv/M7v8Hf+zt/hH/7Df8jHP/5xPv7xj+//7I//+I/v4JZ9+koh7I9zSs4dOlG4Hn1TDx9kNxBg930/jC3KNCjQUeND3D+hP6294FpbO4zcKK9einmSFBMJjjT+utrtY+0gDrOkU3RoVaB1Rj5do59v4RcFdjIeOkHvcbsfCvbyc2xdoN7NUuMiy8ZTx0jUirVxfjmbtVsmhW/xOif5iLUZ7AbxwUVSTNj85Ld8VVgmk5JFHVgrDW3KaFwkqztSgBQ0i+2WpqlZLJYUWzPycQEmsZwtSJmhWexQVCMmZb4/D7Nvl2g3J8vGUG2w7BZ8cvMCyUy4D0VRP4FWG6jOUo3GFE8bypAzk9NlCjMdoTYfpzSrVx8hoxTYAhU6JkXFvPWMY40JkdhrdFaiC4vb7JiONf5P/5Tln7wf/dAz8X/rYdSz7kfh8c/8XJra03Q5xIzZhRlqkpED5UxTdy06N/QxMg9DXbWucszf+Dya//xOqk+eI9y/RrXqqbeeZB4Ww/5zdp2xdZCy/SZCMUT6WU2me6wdTgiSnVCgIClGRckqAYymWF9lMtsm4Eh6SdME3HZP/Ku/YvbCF2GnU1asJaXdjNGD91O8/vVkv/4O/HveQ3b+POGrv4JtlzGdTsmdJrhEOV0njApGD5TUy4YQO3JdQCjp2p6sXbDoA3pjnel0Sjma/v/Z+/NYW9c8rw/7PNM7rmkP55w71K2qrq4e6Hl0N9Bt2g0YYgwkEATYJCHDHyFREpxIiRQrVhQpcsgfljC2rMSCxCHIJkwKgwERuqGbbmi6unqihq7xVt17z7SHNb3TM+ePd599zrn3Vt17y4Yu0/cnbeno7L3WXmuv932e5/v7fQe+dHHgMIxUk4eo0Dngs6KsNLrQRJ9JdpyjTPoVh0cPOfmIJKRAsgXL5Ys4N2fLliEgtHrbtUYXS6Z8zTgeyNOB5nTBVCw4eM+6KsAnRhepi3c31dVaE6NASIWdjmjz7iYo77bS4TBLHFYrtDKk117H/vn/B+pbvhn9u34nQkbIijQGVGsoioKUEtM0IYR4S3KG9QklZ/dwIQSdDV87TTyG+br7DQrOc043pmUtznps11E29fx5vUuTohhnN/BKn5LcDp96RFyg3YGoM1mvETdrrIuOMYzYaJFC0piG2imyUQipURli55hGTx4j6kTiJkn0AVPOAElIgbxpvKQ0wU0iQSgKsrNoIQl2bojmlPDWknLGdj3FnbvUpoUY6HyHkgriPHX7SkY9cn1CPF6ShgNydf7c92Z6uEUUMO4syWeWL6/xN89Z1G/znELM03z/kLF0lKXj3uJFZDAcj4/57Jc+y6sXX+YHXv4+ZFJkmYkpIozkLi9xt9nwyYtPkfLvJ/mAHXoiIIR8zmdHSMXUHRmPB8qqop2OHH1FLxNFt8dhyGpAlyVFXd8yBGSl4Aagk2FRanJsuUyC/bTHJsOLywW70YFTpNSQ1AQc0N5jWKCkxKYBI6HOkrI11HUDObObPIMNs7SrrOBwAJ3R2bA41hzFgSs/sp4SRbMBQGk9ZzCPFnKBKSRSCtwY0GUiSoFEUxeSaZroro9zY3mzIIXw9HoZBkRhiMKSkmX0giAX2DRroiXQtgsYe5YikVtN6CpyE5HrFnf1mKAGiuULiEJghEDICp8TC+W5e7LictvhDwPXx5GqNLSlxtycOYQxBFMwPrjm7GyBiI4sJCI6FjHRFSVHG9h8lUSH2XTNorXG4G7OOQVGJqy1MzVbClIIFOtTcj+Q6zNEjnNqR5iegm1dgq7IKNIwIJfLd81qLKqKYb8nxET7prXiyb30JLXk3VbOiZT8874O79e/VPV1DbD/5J/8kxyPR/7Mn/kzv94v5TdM5fBUl5u/xjiznBLp5rEpRuR70KaklPCjgxuzFCEFeUxo9KzBKYp3DZJTCCAEVbtg2O8Izn5NgH8aPClmmmVxO/39SpVjIg3ze5etJuEhJfykCcJTL1pSYwnDAdFr1KJ8+px+gmcMVFxIHEZPZRSVkoxD4Bgi1kXWlUHGTNbP0Ph1BdOegJ1phM+Ym3n3RN/11TeAZaUZrGGwnpN1zTZ7DpPl/E5Dsy7pjsON0VJJ9nMjRhWa/cWB7TixNANts2AcRxhHhBtw0w5dVuT2nN56Lo+P8KqkajfsiLwYj+jDFZFzzOIctGDY7Zj6iQkJOaKzo9DVV9Q13pauYNxRV9DnRNf1LIQE5DxxEBHXd8jPf47Vp36V7gMv4//IH2OzrNlPA9PFlzHHLU4W1IslrsyorkO7npMXXqGSNbhEMAKnNa0QnBjFlQ/Y7/ke0t//SZpf/QTdv/ZbKRZrfP+A4eFnER/5Zuq2Rk8DFE+ZFHYMYCeKYjYCot4gxoDxERcSqaghDrgYKI2haBqGi0ds6kiz2aB+9p+QhKT+4R9mKT0xdhyFoC5aTigYyhLx+38f5pc+gf3Jf0jzn/xZ7G//3fAt30ZWAVkrzPmaMQSMEdi2pTsENrZHL9eMaoE7bInDwGp1ipYKpQRNVZGVYBosOU2YYUC1S4pyvtejSEQfaE8a8l5x3R8x05azu9+AGyRhgrqpGaeRbrejPXl7t2VlWmIGv3+dRXmCKDagZofuF5sGlyOdDVRGvqt1QWs9mzyZGut62rT5qo7J76Vi15MmS65rdFUhXMD9jb8OMRI/9WnMj/wWslKodUMaZo8JWc1T7CcgW0r53ITExnjrt6CkQEvxtdHEc4bhcl5fqvU7//y/hDXTw2dmhBv37I5HVkqjC0uK9TvuUyEciXFAqQU6ebzRiGAJ/QV1eYLPDjH2hM0KO13faoeXxZJKVaQYGNxA8gqt5qaZF7BLET8FViEDCu8cFTf08GcayjH2SFkigifJeaomU8IGD8pTNmuiT3it6C8vKQ5nmEVNzQDZcLAHilhg1FdumsuiIJU16bB7K8C+oYcnL+iu9hTLCmUqQsjUi7dnl+WcCK6j89f0QXB+5yVOFrNBrdATP/NrP0kWme86/06m3hNi4GgP1KqkloZvO/8m/sGXP8bnL7/AC+oEHyK6qqiq6jnGhzaGerli6o4Ml5doQI8dl90FK52oT88omuZtP2NTVgghGY5b0nTE61NeaCvW1YQKmlMUQmXUpkCWC6SSxDgQQg8cEbLG5kCVCypd3KaeXPaOrQ9USs4sdWCZM9I5RFVjUJzJUy77HQWZRlpg/myk1tjeUbYlUkmkmmnibgwENTf7K1Ny2O0Yuo71nc3sZeIduijIIZCdx7cVg+uwSZDoKYuaSilKKWaTx9Iw5ojt9+jCwyGgTs8w985xw0PkZOAw4XtHX5QIJEEoYhxRqqU6qTFXGRk9Y9Jc945Sy1ug3Yv5zNTYHpc6bC4p84RKgWZ1j24ILCrzFeMH5wl9piwKGI+356Mn8jDvPSlnpFKYuib0AzmE+b7RBbCamYFhAj+RbIffXRBzRucPYNZ33tW+obQhC4GbRlbr59fPJ2t2COFto4XfXDknYuyJcQQyQmyQ8tcRZKcI9gDV5jds8/WfV31d8xk+/vGP37r2vd3X+/Vff2UfZlOVsvyaAXYIz5hthXfONny2vPdkn5BGoo2mKAoiCX1zqTr39rnQb1cxBKRSz1F83mvFkIiTIzs/g6GvUtknUh/miWZrEErOU4esyFHd6tJMsUZUmpCOpN7PjIFgIafbDSSmzG50aCVZVRpvIwcXUZXixTstbWPwNjIcHN7OtD9MPeuvpw6FvNX4ppSJPt3S975aaSVZNSVjmBkDjRRM1uG1xnmH1LA5X1ItC0RQ6KxpV2soSsocOV20SDMDBru74Lh9wGGY6HLF9W7POPUMaWS1uMM3LM9RKB64BVMuCOkBLvZIqRBSMQwTSYBxR8xigXpTHm1O+ZZt8fQNVPPUJEws5cQ4WKyXiLJBaEWOgemzn8f89M8gT8+5+yf+OC+9suH0tGZ5via3GqZrFuuaZrMgNC3FIlLXBbUN6NrgC8l+8BifODUKKQSNkuyXa8KHPoz6xCepdgGrIosPvMjoM4ehpwnD/BnfdKzdFIiTo5AeWZW3n70oFDEmVMqkoiSSSX7CCEEQkPotpTIUbUv65V8iLpcUHz7BugdYe8miXLNcvISSgkJn/OSJ3/mduB//PaiYaH/iv8R/7B/jskOWCnVzWPXes641abFgNwbkYc8xBfT5KYtawjjO1+sYKAWMNlOXNZWR9L0l6llnCmCjAyyxu6JaShYn95i2iZQVVTtHA7kxUgmJRDCl2WfhLfdUzgSfEO6A2ZyRs8QJgUiZgkxbKlLODC6+47UNM8CedXM1AUiu++oPSDML5p0qTdOc4V3XJK3RWuP+wU+RHz/EfNNHZ8rnL/4yOUTIEVFpsoukm9f9xCzuSYQXzOZmOT+lhwNURt38/3vc/6Kb34cf39X7+ZexUrIIYSDDNAzEDNZOsy7XfuW9IeeM93tiHNB6hdYtRE8UEuEnou+JzT16O3DRf54ujyih2JQbTqtTKlmRXcRedcQhIoWiWBbIhWGUiSD2DGJAkFFR4q0njCM5plv9dUqWnCMyamKIJJEpFkt81xGCRahATAeEnljcPUMVhv7yMbZ3hOBplUEKyW7avW2TOKfEfn8175nrU7IdyW/aL5MLJO8Yj5koLIvNhuAzRa2RbwOQYpxw/hpnBya9oBElm2e03XV9yieuP8WyrPhNH/go1dIwxYHB9eynnsNu4EN8BG8nfu4z/4RpsKhiNlZ8OzmF0pp6tSI5y8PrN/DdBSaM+OaUcrH4qg0UXRSYWtANgbHzrOuCu6rBeFBaUqwqdGNu36dSDUVxhpQlh+kRQ3eJRlJXNSlltkfH5dFC75mmSDaSfUy85gXb3ZEQPaJWnLbnqKFgm2/kXTclpcJN/rmGeFlrUsiMY6SuFdNgiZOnXrZkIRBKE73Hp8y+67lMias84rNkWZ2y0YIznVhp9VyCQtk0xDhi90eEF6jTNZkJUSjKsw+gTzZMQtJdXROmiUhNzvNarQpFKiRmnDhrC1aVwcfMde+47hzHMdCeLLHbx4z7I9Mo6HcjUmaWbQEp09m3P1ellG6lgYr43PkIwBgzZ6PbCV2WCHUzkPFvej5lyMUCX9ZMU0cQASEjbvcqdnpMCB35mbz4r1TKFBBvXsebrx+tZ9+br1I5J0I44tzlTYOiJmdugPbXVjlm0hTeeg56L+WHebgT7Nf+HO/X29bXNcB+v34dKgbQs4Ys+/A1NTKi80itkUoR3yNId6NFIchqXkCNMWQjSCGhxazFfnIAfee34m/dNIuqIsVIeJtD/Fd/PZ58PKJsRxjdrenImyu5SBo9QosZXMtZK52SJUUDYmYFeBtn05xiBWUkpok0eLId5qxSZcg5sxscAsGmNuQM1gaShGVpKAtFUWvqZYE2EjcGxqPH+0QUhmx7tFBwQz8PN+ZmupAcJs/uxkDlK9Wi1JiiYN9NxNGyambNbTfOZkxKKYqFwVSaYe+4OnjK2rDSDqEX1FVFKyyNcIhqRTQLdFlQFAVj3DN6j/EGfOCDek2d4bA6ZxSafvvqbOSDofcW6XaInKlP75GdJ4UZlMTeY68m7PVEPLp5Iuhu5A2qAD9SpgkZM31WCKWRhcJ++XXU3/5bqLKk/h/894h1JMbZjbzIiaMokHakLAxdjFgBJZH1ckOOke56y0EJqlqzipl8A5AaKbEu4L/tu2ByVF/8PGkhUXGLPXkZHxRq9xokD7ogxYS3EZ0DSkZEWcyvGxBKEIWg8BmkxIkCgkUGjx+OFIsaqSrkZz9BHHcM3/ERxBRIVKyKBYZIFhUpVuhDR4iS49Ul5ju/DfE//Z/BSy9Q/KN/yPgX/+Lc7X+GmpyHHSfaY7Vmf3lNthN6cwdzskT665lSmTOFS3TXA0hQPrNYLTC1oe97um6Lc5doHRCToT55gbMXXoaYuX78eM4QXRhSykzbnrpt0WXJOI5vaaCNfYfKmbKsyIWAnHExUyo55/kqSV0oehdIbz5kpPAWMPnElEbnRDYtkx2+MuCMgXx4SB6uvioozc4RDwdkVZLKmWEjH1wQfuqnkC++gP5j/zbi3j3Cr/wqwjuStchCIYwiT5Ec0m2uKszT+Zxnx3ApxC3lEmaAnZm12e+pgp1pkjnPB6rfYDWvxQ4pS2IIjMNIChpnAylnvLVzpNHbPG52D7dovUGp+jZKMfqJ5Hf0IvJouMCmEiMDJ+WSVbHCJE3sPalzpCkSUkA2NWpRYFpDyJnBDjSFIGCxymKUIvaJMPRzo/vmvoxxQAgNQRC8Q5YlZrnEjyOECW0KjNkAgpSOlGuDIAIS3zuG4wV1rsg508XuLev/4XjNtrvk0O+QzZxfHA/XT/8OMRGGYY6CcoG6VkCFLiTmTY3blALebwlhjwgZaxtsu2GpMkV+2iR9vXvMMYx8+9k34qwjpciUezbVyKLcURRH7okltU/8yv2PE6JERIMfM3bweBdJ8fnPTCBIwkEriLJnXVdQLDlMX/0cEqPFpwjNXVojiccjKiRSqbBqNnIMLs5T5ClgB48dItOo2W4Tscv4YU+333J50XOxncg+cZolVe8pXeaFZYlpG17rHJ99cMUgBMEYTqoTQoLtcHETXwk5z+uslE/fnzKSCNjRUxnJ8fEObTRn985xIbB3nkvreDyM9P1AUWo2OnFWLslpwidPZ6+w0RLS07+HEAJdSNxVT0KimoIQeqSskXKOwJq0JtkJv9vhIuQsyNmhlCFViugiaZyoC8X5Ygba+9FzfZywMWLdiMyaomoYh0xEoLE0WmFDwoa3nqueyGbKspzXrJvz0ZPSWhPcTBM3RfnkP+GZoc4Majucu8TvHyKyoXrh26nufQtFKhCjJ8YB5y4J4UjOX6VRe+Mo7t5mUKPUjav/25x33w5YF8U5QihSGt/5936FyjmTRk92kfwO1/dXLT/dDHne+wDq/frq9T7A/jqqkAIuvvsJ7T+PyiEgtEY80Wi9R0A6T5wc2hiUMbdU8XdTIQSSDQgpkUbdOkTrwhBSoBA32rZ3McVOKZJTmrMgc0bp2ajKT+++W5hiwu8O8yGi0mAH7PDWbmGawk1ms0I2T6lyMyUxk2Mx51hWiugTKSaUqlC6JhUTOQbS8Ug287TiiWP4STNHjQQbGXykKBWVeXrLSikoG0O9NEglcEPg0GXi6NAi3Zqo+THMVMKDoz86xs6z303z4c/ORmzPlhCC00XN6AL7fUfbamRO2CSeo9Oa1jD4gJ8iK5kxKhKSIh4v8WNP5zQTmsViyfmduyxWC4IOLFcvspAl3UWH8HDn5IS6UoTmDvt+Ytc9wvqBKCLiuCcVLWXRkIZAvO5mUJIzQeTZRC3Pk+w8BVLviZMiXl8Trvc0RYMXBfaGJTD9hf8c4SzlH/nvwgun5OxJaSIER3YWFiezgc5wZIgRgaNsTilEZmxbdqOlmkY2ixJZGbKNpCngp4DuA/Gbv5nU1Khf+xQFmeGwQ927gy7PmY49yfbgx1s2hMoOoSXiTc7xXglqATFkRmlQfsJ3B1S2lOd3sbbD/fxPk8uS8D0/SJaGcqoxocUf9sRhIjfneBxqGdBKU5iMfvEu/t/+48hv/w7kZz5N/2f/HPHR45nmliPd5QPc4YIq7dAqk/oR6z1yfZccPdnuZ4BQakgwdh571VG1DYvFgrIsGfoLhNCU+gxTLpFKoZuSzWbN1B04HgaEFJSNIlqHz+Z2KjVNE9bOnXQ7TcT+mna9QRanxNhjUyaFTGsMMc6HkrbQkKF3z6w1MUB/ibCHt9zXWmtSjCjT4GJ4e8CZM0w74v5AOuxg3L7tGpFjJO73CGOQqxUhBLSUuL/614g5Mf2bv5fLKTJ93w/ANBE++amn0TnV3AR7Ensn5Rzf9YQuPtlIIW6ad1Mgx3RLE5++QqPvK1awswbRVLMm8TdY5TxnVUtZ4J3DWUfdNJA19qZp++aDc84J77ek5DFm/VQrGR1Ehxt3dMKTy5oiC87KF1iVZ8TDxdz0G+e9U1SaVCaEmQGzLuZ1ebARsCyrhtLUdL5DtiAiuKsDoixvXPo9KTmUaknOEsmzc7hW8ySUOXZMypKiOMWYDaZtiWGHUBPV4oQcA/32MVXQpJw4uKf3hZ+mGVgrNTecpEQu1uSxI9/stbHzRDsxaE1KI5UuEbp8Tnf9JHbP+2tSjmi9IfuSQ0iYTUurK7J7uv/+wv1fQqmSH3z5O3Cu5/H1Y1LoWRQLyuaU2Ga0CHxT9SLHcMEQXqUWe5TfEfsD7nBk3A30u4mp94z9kWF3n9FvqdcLZGHp3JFFqRldmLXQMRF9eg4sT4PnsL/iapdQqaQyLf1Fz+FqT5gCh71l6j12CLgpEFwixXyz5vQIqTg//SDLkzOimrBii1kFztcl5yc1i0LTbyfkEPnQsuGD65rQdTyeEg8HR1wuUGbNtusYhqubv+VsEpfS8/d5NgIyuEOHDxEWC3qp6aRiZy0KaMeeO0qyqBNKKA5hxCdPEobe7dmNV1xP11wMF1xP12zHx1jXkVxmFIGg53tF61lr7Jxn6npWywXCWsZ+IMmKGMfZJLIAtCYe53VFCEGhJaXMLPOET4GpWtA7RRp6VFHSB4mII6UUKCE4vgkghhsTwrIsZx/2YOe16833dYzz9F4+1X3nEN4EagfEFNGhpTx5GVU2iHKJateorseYM5RqZsaFu8T7/Rzn99xakEkpUTUN8SYXewbG89npCTPqWYA93w9PXsN0w3o4R+slIG6aGCUxTV/TFDuPYfb5KdVspvte9wSA6OfBxSTI7+Fs/H69u3ofYH8d1RQmOv8OlMV/jpVzJoc4g2utQcxGZ++lYgg3+t9idl6O8W0nA29XzjpEFmDEczmdxhiiSCSfMNrMupt3eM4Y5um7nRJTP78HU1VE79/1VN0eRrJ1FKcr1GqFkYk8DLfgKOdM7OcOoqg0snre0iClkZQVOcnZYfXGwdvbeSHUejnTyOU1ZEjOcBjd7Bhez7qknDLTFIhC0JZv7x4slaRqDdXSkIQmesG4PRJGj92OpM6jhKCXGdVqluuSUQv6GMk2kQZPPDwzBY6ZutBoobk6dEQyJ8uKuqrYDZ6UZonGPkSUkdxZFcgQCAHC8YLjrmNMBSFL6qahaVuU0XRuj02RdXmCdhCnSFCJpm5ZFg11U1LqJf1+4I3DFjVdEnYeQ4OKIEqDEBG5MCQlEUZhWk1IkAuFXBZzg6OqwHbE3lPqBjMmus4y/D//Aun+Q9SP/SjFd30XIfQIoUkJuv4aLSXrkxOsqugP19gwUEvBornLMXjG5FkvF7TTNE8hS4UoZ6rv0DmaSqM3Fe43fRtcX1F87ot0KVCfnLCsS6ZYYpPG7S5JY0+h0zylKOTt9Pr2+hVQFZrsI102pLFH2D26iHjlibtL5JcfkL71u8mLJV5GmlDCYJBGk8oJX2pc2VJHz2K5ItojlYYQJPkP/LcRP/bbydsdhz/9H9L//M8T9hf4kOispqoW3Lm7Qg1brr/0edAKUS3Jh2uiu8l4XRZ0waG0RCtNPDpwjvF6R7j0yKKYTf5cRChJszylLgTHfsvUe4R3lJUia4Ptw61pkbWWR7tH7LdvUBqJ3ryAkg0pWAYcOkJlnlLylBTUhWJ0kZjyLTieu/LjPHF8pp6Y0mjAyYrs+re7+cl2JOklmYocJpj2z/1Izpm434MQqPWalOacbvfTP8vwxS8z/eAPk198ibZQxG//DlxZET/+i+QQ53xjIZA3ACV2870nQqbMmu6qY7juMC7NDSWX5mgg5im2C+nds4tuJq4zwG7nf/8GowOm5EAopDTYcSBGKKuKoqxwkwcpCc7e/k2fgOucI8a8SSPpBpI90iWLqtec1nfQTuKPA1LegaEnyRHZGlRrkIUiOEdGIaXCFIoQE4MbaUxG64a2XBGSIaiOXGbcYSTFG4PKOM6vXRSEfgCtMWVFsA5pCgQeKZ+uH1KW1IsXKPUJrj8ilMU0GrTDCImZMsdux3E6EINnf7xGlIa6WOCmnjCOiKqG4IjHjjg4wnEkGMcYBTpYVLGgWhggEUKPc9e3YEapmsKcIWXBfndkUI66LEhGMxwv6VzH9XTNz7/x86zrDW2z4mK8z6vbVxndji57VLlm8IJ9hu//6O9E1wt+cfsFotIUlaKpI40ZqMQeaV/D7z6Dvf4S4+PHjJOksC2lPufQHTk8fp00Rh5fDPR79xQsj+EGZB/ZDw6tF2xaQ2E07WaNXmqMdIhCUq8KmnVBuy5pVgX1skDVzBP3xYr1ZokqFnhxgiorjBopww6KzOlZjSkEow9MvadAc08kTpQmTRFTGfRyw8FrXr94xHYcCD5RVMVbzio2JUK03L88YJctQwQp4O6i5UwrGiEQ3RFMwmdHFyJSSE6rU87qFzhr7rIpGjblhta0GGnwoWfqeoIQHETP/evPs/eWgzvSuY7L7WMykcVmTV2WjMeO4CWQETKBSOSyJA/29rx4GEam/YGTuuSVeytO1i1Wtxwni9qsCanEDz1ES6MlMWUG9/RcNU3TbGxmzI18bnYPf7aCdyipUKa4bbaiBN4dsNPj22mxzkvEJFGLFfJJUoUQyM09cnBw2KL14hb8puzx/vqmuWZv7sG5qV81LUJKpmF7o8N/el6fDTTjM8D66hlgfYbWC4R4ck93zE2MFQJBCMf3tp65mfkka4UsNUJL0hTfO1Xcj+QkoFjOjV77G2tf+Odd7wPsr6MqVUki/fpNsZ8YnN104550A99LRe8RUqK0vo0+eTeAdjY3syiliDI/ZxahtQYjZyqQfHdT7BTizBRKghQyKWVMUc7unO9Ci51CxG33lMsKVdeIokAvW1SyhNHh7TwtJWVkMx+inq3ZIdKRQzHTs426pWKFG0dvISRGL8mxJ1UwuUx/sLSFujUx8i4y+oguJPU7GBvllNAqU5kFjCPTdqI/OKgUaWnwhaIIE9pPLGvDUCpsq2dQWkpyhjxFUu/wu4nKRry1jC5SFiULo/AucLEd2XaemDPrtqSUiUqP2L7n0A1YWrQsKLTEVNUsFciJo91jZE01KUTImKbCp0BKiYVZUKiSpDRmB+yP+DCxS56iVcilQa8bcr6Jb3NzLmjZGJSR2DGQQp4jXpQni4hel8h1y2Jdkn/6J7G/9Cukb/gmih/+LfjOE4cBfImdEilOVFVFoxRTs+Rw2CJiT6MbDkkwiJJlmlitl8iyIO735BCQpULWGqcl7aqkyhn3Xd89SwJ+7mOMxQJjEk0DSVRYVowj6Nwhhy1CZJAC6/Y4e0XON9P5lKlrgwyJXT9Adqj0kKRAUKE+9QZZlYTv/HZUCkgrUI1B1RpdrxldxzQdKZZnGCTlUiNFJg4dKmZ8DPD930/+w38Y7x32//Xn0T/3c5y++Aqrs1NQJbJcc/rKh5mGkavXv4DQgjQOuOsrpBK0RmEHS3VSIhcl2UX6Nx5Dn/HHQMgRWWpyyGQBUhmWiw0i9ox2Ytz26KakXlXEmLB9mF21dWLornH+QLE4Q+gCZUqST0yMVII5c/gm0xduptjiZoptj+ToSWkB9q2U6CemNColUtHMJlH+mTXBT0Tbs3eaiwmOQZFlPU9+7dMDVbq5BtRmA0JwGCa2r77B9Pd+EnF+h/Xv+Z2ctgaZr2jqiP+e78NebYmf/Rzx0JOmMB9qYiJ1lridyC6hlEaUJUlFVC2RSzMD8ZjINw7i74km/gRMqxvjH2Xg7ZoK/w2qGIf3RKuMyaJkSc6ZcZjp1nVbU1QlyUcighgC3k7kHPH+mkzGmJPnwCspQvcYh2LSkpYWaRN0mZAG9OkZelGROZBFvHlIvDHc1Cg9N1l7FyFPNEWBlAWlFhRmhUsS8pEoIylBHCwpTShZk53DO4uuG8RNQ0AvSvABwfP+FMIYimqJTC2CBjCEtMO0mbZpKKPm6uoBjx++zpgmilQhLy328Y7+0X3CvidZi3v1S9gvPSDsLzjudqQ3HqC3lzDtGB9+lv7+p5kefYl4dU3cThwvj+zGgavpitevvsyXDo+wZiDlRCcDw7BlCgOffvwZhjDxvS9+F01xgsqwLArOaPFT4tGj18ljhEXBN939Fk4Wd/jM4fM4UTJQkZpzUrsh1gLZaKrVktXJOVomSpOpxp5m9UGWJ3cZhjdYLgJ1a7Cap2B5U9KsNF5ZinbBvfMldVugpaBalCw3KwqdCW4k5vyW5vbV4QqB4GR5QsqwGzxaaUy9oTYnFGRC3CKKxMJoEoKiVgQhyD7T2EBbKUiZ87Ll9PSc5ByvP7zPhQv0WtFNsyv8FBMXk+PBceA4DBRVxdmy4URK1krRGjNTqVNk6Dp6OXAMlkLXnJQnSDGbQCpZQXYYaWhMQ6srVllzKu9wurzDydmaMpWUYp5eD8drLrotvkpsc0/ZFJAi3aGf/QxISCVIhQAhiN2AnSb213uqQtOs1xgZqYuC0/MT2vWC0LaMak4rwfWoDJVWdHbe25/IAG8TY8I4r1nq+QGGnyaKqkRpjXMT3h/w+TBH8aWCojhH5Yp0OCKrErVon79Hyga5WJP2F+QUb+RDDWVxjtbrmybbDucucTdeHUopTFXhbEdKeR6i3IBwpQTW7pimixtg3d6A9qfAGubJ9gz+G7RukaolhP72ed6pcpibruJGZgQzSwYgvYNP0FsqTGRZQFmClKSuf9/f6r/Geh9gfx2VuTEisfHXp4t0C6ZvgLHQ+msA2A5lDKO1DJNFSPmuAPZsbnYDkN7kpCulxBhDIIJPt4ZMX22KbUdLijMte35d88+aqiI4+xbq1Vsefz1Pq4rTp46Rsm0xlSH3R6bLiRxncC3expk7pYmcIQXznEbtyb+fTLElGpUVVkaOwlMJSXPztnLOeBvxZNpKv21MWM75VpPsdiPZJUzVUp8ZihNBVpKU4eroiOOIDoHgHK2SNEpyCLPOWBg1A/FSEqRg6D3D9kidFcfHjuODHr+11AGm0TP0gVU1TxPC1X3ssEVuNlAs0brGDxakRCmN0obe97joqEODCRlRa4q2JNjEdJjNs5ahRmbDdQycFoFmuWEoYBcuiTnNzqAZfD8Rc2ZU0IVIUSuUkkyDJ/pIOl6TZYOoK4RPqM9/Cv0LP8d4dgq/71+n3FQkE8hZ0e8n4iAotQYclRSM5YLODbRuxIoSmzLrZkUjZpMouV4jlJpBds5M2RGwlCpThoR48SXCvTP8p36Not5AtrRFgqJmmgROFKi6Jh2vIRyZDo+wux1ud4VzV4w34EdXCj919IfHlIVHITHNK8ghwyc/Tbpzl/7FU8osqFJJMgIhJG6IN1YKHi0aKBpklagKSRoGoj1yuLrEJ4/6hm+k/V/9L5Ev3SP+7Mfrz06sAAEAAElEQVSIf/n/Sy0VZdviraUoCpqXPsRulAwhEUMgXr5GEa/RCaJzuKzJNoIRTMVAeb5BLQv6qx082atjBjJlu6YSChf3+N7i8ww6qsYQY6LvRqbpijIEIiW9k7MZHIrJa7LwlCIhs0AIcQuwpRS0hWYcBsJ0JIsGVEEWJXns36Kh1lpDiihd4IS+BeExBI77S64nweglIUeOLpCCgHIxZ827gdh1JOsQqzVDhIvOsjsO1H/371IpWP7BP0DZVhzGhzzePaA/PqL83h/Au8z0j3+BdOhJPiIEyHpmPohSIQqFag2iLmkXDS44Ypxji5CC7OJ7p4lHC6rA5UBMEUwzg+74X0G39+tYKQUuu2u6t6H/f6WfJ0eEKHDWzjnT0qCUoKpLcgQpBAmBGzucm7XHhTlBymcO9TnDcAU5cNQFKmQasUZXGlFCbjSUoIs1IjpCmF+ft5aUQEqDKRUxZUbnqHRA6/ZWolMXisgSkxNBB7JOhGkgjRGlauI4ksiYtpmn7SmhFxVCKLJ9nmkmpMTUFSIlkhcUxb15WiZGUCOrdY3OgvvXX2K/3ZEut6gyIlYbehT6/C765A6irBCFwS0ktlQI3aFONeqkRi9XlOsXqdcfRC7u0GlBJKJ9otY1qZ//vq9sXuJee487mw9xVp5wJls+c/V5al3zox/8LVRyASju1BoZMmEUbC8fIYVidbJhjAPfdvLtXE7XdGlLCBO73WuM0xahG0z7Aczyg4jiFF8tadpzTLWkkJI7L3yUpmg4jq+xrCMJGH28Bcv9eKB3iXWzotCSHBPERBKJn/vSx1BSEp2l759v0vVjz+hGThYnSCnZDXPDvygUCcFKlhh9ijQlIR1pWk20AZsyRS0wixa7n2ilxACjB2la1suW5TiiUo80hmOIPBwmdiHS24Dsel5cVHzoA+fUYma4RT/nL0spKRAcw4HrcUddnLAu5/PL3JDKs4cAMzCc742JPE6IZBAmU68XLJu7mChZ6QWVLzhbvcjLmxfmpmYBlTbsJwtTZuYoZ5KIiKpmutpydbVFFYb1cjUbqwZLkjOj8eSFM06WFcWqYWsVx8OeaC2Lapb5HEZ3mxaj1KxDn+Utz9PDnzStdKkRYmAYHs4+CcWKojhD5RLSzDASWiNXbx/vKTf3Zpr54fK5/1eqoijOMOYEITTWbsl5Twj9jezQk4OeEwn8Duf2xLglZwuUN8C6fVvG4Tz1FijV3qwzayDg/TtPsXPKM4hWAlE+PVcKKW6bsOldGn4S3NwwFMXsHbRowFny9DVQzd+vt633AfbXWZWy/HUF2EI/pWbPE+x3T/FOMZJiRJuC/fHA9rAHId+Vk7gbZoOXpOYuoZTyObd4rTVJZlKI7zjFjiEydY6yLiiq+QB/C7DL2WXaT1/5bxynCXcYKTZLpHl6wJopnS3aedI04pV4Psf62eeIIzlpBBJVPL3NhBSYQuHdjROwH0E0HIJGyIHVuiSHRBoD0ScGG5FG3kb1wA2V38/U7nT0twYXyYBZlKhFjWxqhJtmt++FZrQeth3OZsZhott1qMETe8f9657dzjIdPW6M+JA4jhO5zrz00XuYdYFVmbLRrGpNbRQmJNJ2pH/wOt2jR8R4wmb9EsuiJA+Ow2t7shPEweNHx7DdI7dQu9ncSmaQU0RO4EdLFqDbkuXmjCEO0CpKGl5YnuHDxKPhkp5EkILLXc+OhM2ZPiauQiRWEqkE025H2O+RmxcQaOKrn8X/zb+OWbYcf/xfJ7UNojRkE4i6YCf2jNrTdSPH3WNcSFiV8EoRxoBPmROjqIpypti6fu50r9fkGLHXl1xc3sdP16Rwhe0fUeqB6RtfwPnA4gtfRuZESiNCV3inKGvNNARSVtirz9EdHtJpzWBBZI21e4K/IrgrJv8YDVTFBlO/gHCW+MlPkaeJ8Qe+H6ECzQBCaR7s91z2R9xgadvzOWc3OWRbIpQh+AF3dU2yB7z1lJsTimpBe++c8r//h4jf872EX/ss01/4zzFFSbVYEr2nKTWqbTlOmp04RZiacPkAffU6euqxQs5TfGGJOFZ37rF84ZTJjbh+jiJ5soYIXdBUS1K3I5WeiMaNAWUkRSnYXn2J6aJnVb+IXpwwhWmmcTrY7SIMkXHscEdHCuAmf0uLa4xAuQN9UGRqohyJxpAmR/bP68uemNKYnJlUTXQTh37g+uoRU0hUq1NOTKZtCryUTMNENi2YmrR9SNhvGYqSa5fpbcBIWH38Y9SXjyl++LeiPvwK2/ERh+GKNEr68UB7vkB/z3fiHryB214gzQ37pZxZJLLWZBsINhJSZrV43llcFDdau5TfG008OKJU7OyOrd3ipJoNz/x/M6fYRzvgutkfwsV33pvmyZBAyoJpGJj6nuQt0U0IEUn5Jl5RJMbxkuA9xpwixJsYQ+MW/IgvGgbvaKgwzRJRaBQzhTXEAVG06FyQwzTTSJ0FZqdtpSW9C+Q0URuFiAVp8OAzTaFJIZJpEVXJMF2SjEWmkjwlXHdEVhXazIkYqihAJmTRcNxu52jEZ0oYgxIS7yzejTeTNEVKgaG/j4iPQE+47pJgL8ilp1ooBuexfSRJjViDC4/ZhytyTpRlxfoDH6Vaf5By9SJmcUqoDQflkE1DqVfUTiCDJtjAZrNgU21QUiGMBlUwdJd8+vIzfOTkw6zKFcfhiDINhZuQWmJMwfndl9CtxriMj45vXH2YTOIX3/gZytKjdUmMNSGUs/kb4KcR13coClK9mBtgwGb5MtllxvCYSjs6G3Ah4YNlN/S01ZK2nFkK2SUQgn/8+j/lr332b/JP7v8CVVnRH7rbc0wIgV2/oyxLltXy1jNlVWuGnGmURMeMUBJTbOYPQ/fURtEdpzmzebmibiSFhjIJipDJ0bBNBpUzJljaHDkvNC2Zc6NRfUeDYH22oWwMUss5mcSnGYymhLVHfOEQrmBVbG40/NNtxJwQatb9xtlI0Y978AakIqkJXbY0y1NSCIyPHzMhqNcrKlVQ6xpnBG2psIDtHISEUpkYLF5EpsNA9InNZg1ZIMXsuh2ZmXxSSUqtuLtpaM9OudpN7Lc7BNCUml03ElN+Zno9zSD7xj08e0/Ybpm6HTEdSfmIUiDlAik3M6g1huzdLN8B1Hr9FqAbb/YMUZTI5Slpd3lrMPdsSVmg9RqlNhhTzz4g7iFCBYLzxJRw9pIQrjFmRVneJefyK0Z/zX4K0829KG5+R42UDSHs35GV82RCLeu3ygWFlvMeMc0yv3esMJKzAFUgpESUNaJI5Mm9e5D+fn3Veh9gf51VqUpS/q9AE58tp7+2h94YnD2pJ/9+t1Ps4N1s1CQkzvub9zGD7q92EPTeE11AFYZEuqWHH6bAdpgXPa010ihCjBAyRVG8raN4zpnxOCFEplrOi7Qykhie0LLFrF97Rm/33ONTwl0fwBjKzeK57yUbyUFgNktMMUcsvZ2reEqBnAMpFnP29JsiTHSpIENwiexHDkGh9QmrUpDVOEf4+Mi0n7Ap0ZYGJcV8CBwDqfOze2TKiFIhFwVUkiTz3HwQAsqaMA4oDZOCWlpMIfAJ+uPE7npHP/QUfiKHiSvXYfNEVp5h6nBhoFlo2mXDcl1yTBZfCFIlOWjLFTv2l6+RQkdzdkazeRFTl5i2xDQZ7ybGadZpjdHiR4dWJfWinQ1ctEBWCt2WiFYTVEJoiQ9xnkSaliFnzkrBebEiO8uXjhd8xkb6ceK0KbhTaM4LjRGCY0z0Gtz+ktFp8mJNuu7xf+kvIqRC/f7fg1rWeOmYwpZhuGbfPWIaHmHooNYcxy1ffvRluu6SsVyRJsepTBRPIk2K9iZT04JSDGXD/Uf3GbYHlnoJeYGkoS0E9oPn2Lqg/IV/TJ4e0Q2PEDqSlUfqAvfwIYfDI/YyENoVTV0RRCROmZAVKVzQ7b6IrpesdItnCeWSdNgSfvmXicaw/85vhlzRjYHeZ479wKPDHqkNRpTIWBEYmYKj70ZCElQqslkvUFrhVHnTET9Qbc7Qf+APkr7rO4hf+CLhE59EFwX1conOCQpN9oHjMTKlNTZuMHmiNRM2HyEcGbsrdFFQVgvqxQJZa8a+mzf7kOYhcswUixXFGHDaY5o5gs51PdPwGohApe+BaVi0DaJKtOsSvalRlWZZ1QjtiDYSfaI/TgwHR7+32KsrTILjVNL3R6IYSWUAMbNOnrsHb2QwhMAhah4MEbt7SKsS5+f3WCgBKWGqco48srM+zVGx34/sxgNWSJpSc74oqa4vkT/908g7d5A/+iNs4zWT29LkNevqRaJRTLpn8zt+G0orhp//RfybpmJPtHRTZ+EGRNd1jRCCYRhAzzTM7OK7p4kHBzkxiYxAoIVm5/YMQszNvXfZPP16qZQz3bGjCgNqGrnujsR3aDLMBmcKOwzsLx4RbEQXJc16gRLzFM6PI4ielCWE6jlKJwDT4cZoqeGYIthEVS6RlUFEkCIhdEtOgSglUpWoBNN4TfQO0E+n1zZQKg+5wHUTk7UkF+ZYvRRwQlAt72KnA4EDul0QB4vbD5jFghjC3MguNNl7oteEw4jtR4bhSIwzoAq5J4cdzl1w3L+OEIGcJ2J0xKnFxzXr5oyzVUU+WfB49PTTgWHacfXwVUYGcuEZrSOMikZsWK02mOr09nA/+IG93aOFpowlUhuGcWJ3uSVJy3Kxvs3dFkJA2fLL9/8ZIXq+78XvwTlH5zqKJFBJIgpJ0y45vfMysSiwQuKspZwiePilh79G72uiOmVMBY/2A196tOXBtuf1195gf3AMqmWnKg5R4PcHTN2yFGumkJB5j8gju8FxebhGSsVJu5yvk5SJNjBFx098/qeIOfHJy1+jKSqikIzHIyF4uqEjisjJ4oTOhlvPlClnBLBQkhxnNp4QEmNWZDxV7XH9xDBEpKmoWkMhA9XCUBnFCoObCq5zpjTQdwdySsgYcONAtxtZb1ZUzQzgilqBADt5BIK+37JzF5zeeZFGb24bLnMqx/NT7JwDIRxJ44DSzRxhV2uUWszyPmA4HHBVTXPDJqx1jRKKspQI4CgkeQhkAlO3w6VAbpaoCNXN/aOyAyFJmOfOQUoKXry3pl0tuHx4ydWuw5BIIRDEM+DRj7M/iVTkEG7A9QOGyy+iCoUxa6rqLsa0t54cwhjidjvLd27YZs/WYfI83o/4m+acXJ+TsyTtH7/t+jGzpBRleUJRnCGERBlJiAeCHSjLuzcguZj9gr7KeTeEI0KoGyYBt/eFMSekZG+y1d++0hQgphlcP2EzpjSvTTe/T5QKJPP58J2ar8GCLIn9gL++IEXmdAvh3j1If7++ar0PsL/OSkuNEuprm2KPI+N/9J8w/Ok/M+f1vdcK4Tmdi7gxOnu3TuLRe5QxWOfJImMKxeg95Ez6KnREbz0yC9DiNkZnNrrwuGnuDj+hjUeRyH4G4UKIW8fhJ2WHQHBh1ubeNAjUjfN2DE9o4iU5JcLbNCJS1+GnQHG6uqVkp5SIgyfbgCgV6nxN0ZYw9tjev9VVPE3kBDmY2+zpqetwx1nHI+XsEOqHiUM/EmTJyaLBmMW8GepI0pKhc0CiKdUMrvvZ8VsUEtkWqEUxG23J2b1SCIFEzjFPlIDA55HueETYibKtadeCsxdqNicNp+drNqcrPnC2plk0jFrhU2QcLNowu7fHSKkE3g48utyyG3p2/QU+XnPQFrVYUd07nw+aWlIsK2IaaU40uTAchpGYIrmWVHdW6LZA1hqzKucsWK3QcjauC94zHPdsTu6QU8WEJBWSbuyJqaHVChM7lAjIOL9fJQQbozk1imwP7H3Hvq45PnrM+Bf/C1J3Ab//x+iNo64D5CPX/R7vJdY6imqDzBWrsqJqNbtwie86UlY4e8QPl083Kl2C1Iz9gcvO0acJXcBdU6GDxw8BY1qqKJCrl7Df/cPoB1vqxwP96JAmIM2e/Zc/xaH/DBdcwuqc0/OPspYGJUa2u89jvUOlDYW5i9aeQh2YckUWmvjwdfyXXuP6lQ9wFRVluaFeFiyzpawdsQgcXcJed3OcjetxbqAoFO2dD1LWBU2ymMow2ZFoB5L3iHI5g7kf+20EKZj+1t+GGFHasFlvyBGm0VGnwPVuJFQNxbKgXm8IsmQ4XBEOb1BriWKWdbSrFTZbkpwNunJIMwVTa2pRIlLGiRFDT3/1kF1vqZqXWJ6t2e4vGbcDMUd8mmPDSiNZlg1FayiawHJZU7UaXQmMmJ2ddbUmDpHLw4FpEEy9ZcwGtx8Jw3R7r8aUGQJsjyPOJ0yhORcHmnaJ0CXJzR4D0hjqynCMmcePr7l6cImrzlicnXNH9Sw0SDL2L/8VZM6I3/tvsE89IXeszYYiLjFVSaFaunGL/MDLVN/4DcjPfIbd/cfEN8XTiFrjYsa4BJlbZ/GcM8MwEMRseCYBo+Q708SjJQvBmCOVrthUG2pd0xHp3HHWN/4Lrp0L2BBIKd6ynmIIszOv9wTnCDd6Y28n/DThphE3jVxdH3C7a+LUU7gdYXfJZT995QOtdwzHLdNhZBp6EJJqtaJZLanbBUVdk5k4Hh5TFDWmOsf7gHfP7A2un7+qFTZ5vIcSgW5vplAhozTIoiYlSUwDmBqVFMF5fBgQSpKJXB97hmFPcj3jwTPZiaASdpolR2X0JFOiqpYcxNycVpYYRlJIKFniuh5cIg+WNEZi0qR0II+XdLsHHI+PiMkijEbpikIvSKGkrl+kKl9i3Du8r5DtGXeqF7mzfIUvxy1/6hf+NP/w8z/BZPfsQuZ6WrE9tmytJg+CMlvKurk1ZDy6I53vqGSFDnPiR71aMYTI/uox1aKgLd6se635xUefwADfee/bOI5HYvJUMaHNipA1HZnRSo6T43K6hMKQcsE98yFeP1yzGy6QQlBXJZvlgqZQMBxhf8Hm7jmndza0ShKqhm0/MU2OWtdUqWZIiUZPbLsLduPEul4RgmccR7rtgX7o+cdf+jm24xYlBF/cfZHd9SNA0Q8jl/ff4DDsMErhx8yhn6hkhhzpnKMmz3nhIZLlzNyRskSpBmEsCsfx6JBaYZYtaZqQSlAvC5qF4cw0hAT7weKyYNcdub/b88bDa3RZcXL69O+pjaKsNH6MXHc7+v6Sqqw437xCXZa4aWIcj+Qc0HoFzEwqKUsQCjdcgMsgK1Lq0NUaKQ05RpQP+KoiB091cw4SQlCqklhKGik5CglOYK93c0Z8XRHbBVXKxMnOE+vsQBfEm3vq4cU1x/0BO/RE7zi/d0aZHPtHV9y/PlCWmojEhTSDxzg/Pk8d8eGXCP2XscPnEP1EXd5Bqfo2ZjLcGNumyZLGCblc3sbcAbfxp4e9xXWB3XYkxoQoCsTylHTcv23CwpOz1SxblEhpqOsPUDd3Ic46aykNIRxuz67xbc7fMVpy9jcu4s+X1i1Slnj/FdIqfJrNQm+asE9f3DSvTTcDOSHEbLabnkaIvm0FR46BcLSkcUQaQzwcZh8bE989SH+/vmq9D7C/DqtUXwNN3FqGP/efEe/fJ213xM9/4T09PMfZgVCY540kZrrNOwPsnBLRe7Q2DNMIOWOUJqRI8Okr6rCfmJuZYtZYP6GH25CIUyBNkcnPjzXGEOXN4hVmGpH3/nYx826eaqkCdDF3QXNIiJiRWhBuaOJSKnRR4t4US5Ccwx0GRNNSNE+NbXaD59HoOGpBLmYKvVouMQbSM67iTyqmiZxmSpST8HiyXPzH/zcu/8P/CHcD6k2l6Psjo42sFguMkjeaHYMPB0JKTEpQIZAukoaAw+Gq2TjqzdT0EMLsvJ4ALQkekjZcbS9J3ZG2bWkXDcYElI7EOMwZu8ZQFgX32hqpNNc20NQtm/WC9WbDcrnk5OSEeydriBPDcE2F5XR1B3Nyh6v+mkk+1YfqosSPA0WpMJWk2/U4nxB1wbJsiCHP+a43ueBCCtQN5X93dUHKsD6/gw8Gi+A1mREKWnvkJXPKC01LWRx4fLzkYtwzui3WXpD9Jc32cyzKQF4p9n/przA8ukL92I+gPvJRCCWL9T3KsqK3LdHXONOg168wyQUiL+nFhk4MvHhS86FFg3ea48UbXI2XHN2R3lmuvOHQDeg80cqB9fqU9vQOYpwYHz1GSIjHa0S7Qf3QDxFQyI9/GuQZOmnqqLk8XuIWK5YnL1EnQdbQxwtkvmZyB/rrkVIvqNYvYbKirgx7t+f6as/+538V6wNX3/FtvFiUfOB0xebFE+ywRyVBazKX2/tcPLgEBc3qHuVmNffNskRtTmF3yWKzwHpHOG6JGNCz5q29dw/1oz+Kf/yIw0/+A9xgyWOkShWxrKnXGpUsnbNYChoDMWsOuSZXNZU2pO0D0vYhjXRId2TsHyLERNoeSENP6g6YuqTJkmH3GtAzlhLnVlS6QZrAJDp2+y3eBkY/YXOmMRpiRpmKyITMAqkk5EAheqr1gnrRsllF5EJjmg3KKHKlcB7Gx1sOu4mHj3tef9wxTYkSuFdLlPBzVJpUpDTnIk8JbMzYkNnazPHRFctKceflO7TrOzOFeNwy/dRPkV9/nfTD38/xfIWSkXXZYuKSSKZsK9pyg/UTLvQUP/JbKI0k/9Ivs9sdnzvE5AyukBQ38V0w09nbtp3XxegZxoFoPaWW70wTDxYLpJyobnSMy2LJolwzCtgf75Pyv7gpdkiZ6/2Wi+trht2OYT9/jYc94+HAdDwwdUem7ojtOmzfY4ceN44M/cBxt0W5Pcf9kd56zOEB/f1HvPH48fw83RE7DIzHI932mn77iBQC9WJ2dy7rCpEVujJsdwdijhS1xw4OJdaUVUVM6akRZrDzhKho5ul1v0UGhSo1RXkzhfIJWRiEgJxLUnI4JNaOTPuRY98x2B3jNNEPllJ7SlXTFgtWZxuaZUtKCdsNFGRUWeLwIDQyrwm2Y9w/RhcFaWdxlx3alGTtUU1FahNmU1HJmrY4J08LUmgpmjsovUCJGtCInOn3HjcmaCKVydTCkFf3+LuvfhKXNB+7+jTbcIFcZopas906Di6QpeZw2LINht3oeXC85mB7alkjvLhtBFkkQxTY7mqeXsvnzdd24cCr3QO+bf0hZJIchz0mCiolQVUksyQly9IcebGFTat56e4LfOs3/ia+9+63IFLgC5e/wqKEdW3YtCXnq5aq35FFothscGPgsneQQBYtu23H0SVqq0i54LIfGQ73cUPHMHqmaSLGiEoSVSh+5rWfoTEVv/sbfhzIfPLRP6O/3tGPlm6/o9tfwZS42u4RdkC5gYvdjtB10B0YtzvG457huKffbXHTiFILpNRoeSQ4CCkhq9lT5Ilzs5SCk/WSF184IYWRcYDXB8vjy9d52A2sNjPz6NkyjaILHfvLa1opaJoTTLHAFAVSCsZxPzeM7EjOmnAzxZaiwPcXSFGR8ghaoOsNAPFwQEhJPj1D53gjcZir0hVZCsoCxmHgGCNYKGtF7zyiKaiNwh96pEz4safvHf1+z/a4Z7s/8nDX0Q9z4wyRKSvN9OA1xu2W/tCxu7rm8cMHDI++wHT5GtP1faYvfwZvB0KjCeUKoyJsH91Obo0xs0Fa15GtRbXNc5PrlDLbwTP0nlpJmoXBhsx09NjBIxcbsihIx8u3sHpijLfJE0/i/pSqKZsV5Iy3E1qvyDkAE1LKt+Rhz6D7eBun9+aamQ4nhNAT3pRHneOsuxZaIss3yVbSDQh+hvEqtJyju2x8SwTr7XPajnjoSD4j1zWh8QijiIMjD938e9JNFNj79TXX+wD767BK/R5p4t4z/md/nvT665jv+9556PzPPvGefucTGvizFHHgXTuJhxt9ktCayVmkAIUki8T0VaKxnHNkn9GlIaV0u5BNU0D4gEiB6eYm13rWsUXmbp4xBiklzjliTLgxoEuFFAml54097C1hN8067GcOo6aqyCndTipySqTDgYBCL+pbOlPMmWF0GCVwSnDhAjsf8Ephlgt0dIRhuqWKp+SIKXCYJLuUOKZE+MxnMA/eID++oPv8FxiGARsi1g4UuqZ6Rl9tzJoUAl2/QzaGpimI2wnvHEc1cPRH/Ju0Qk/igbRQQCaTsZPjOkSm45azRc365JScR7wLkAtSGrDT4dknoQqOFASDEAgxR60RHIxblvSYNHIRBM36jOXyLsuyplAl19NEz0gOeZ64xIREEINFNIqgBHnKmKTxh47cH7j65V9i+5lPIRWkmDEisd/uiHXLNmmOGda6Zl0W6BKUvaK7fA0pM8sqUk9fYnA7Ll3gImiuj47BKtT5R9n8o1+l/dLrTN/xfVz90G+n3x0RokQWArIlBcVDb6FZ0eiCqBS7YeR1Jzmtz3l5ecrJyYJy2SA7S94feXTY8er2MftkqapEHR9DiBT1hvL8nOL8HN/1xAdfYhgnzOqE9Yc/iD87IX7sl6hGx3V/n6HtUFXDsv1WXj79Rkxxj+gEstywXHyAaEeOuy9QVI5puMB6QTIvs7OR/dUj9Gc/jTipKb/hA7x8tUP+w78P/+n/ner/9O/x4h/9H/Lyv/PvsvhHP4XThmQaynKN1A3O9mRvEetTcko0MiK1Z+oOuPyUruazp/yxH0GfnJH+f/+A4f4FXT+gjKB86YzYrKhLUFeP2PmC3NTkwzWHcUS3G/TyFbJYkINGZE3dNNjuAGaCdCReXZGu7yPFkfrwOur6Po+7h0R7ZCUCeTywv3iNOh+RYmLYD1xPPRmoy4Ls/UyvU4nkb1IH+msQilyuCONIUUXaxRqbBWVdUTaR+oUNNgzsRssYI4WUVFIxDZ7da/d59Hji9XHJgwdXPLjuudj1bAP0LqOV4kwFKi2o2hY5i/6gOSVdXmD/5l/Hrhrcj/8wVdY0pUYzTyCFkcQYKVRNzoLB7zHf/m3o0xOaX/skfn9gPz69n11MCClmeUtMMy2QeZLdNA1N24AWdLsjRE/K+SvTxFOC6JnIGGkYk8TdHB4b07BevEiMjm33cDY/+xdQo58ZP6mqKRZLquWKerWiXq1p1huazfzVbk5oT05ZnJ7NXyenpKKlbkvqUqDqDaI6pzlvOdUWkmJA4KeJ49UFh4tHjMcDzg+AwltPt93O03EfEMB1/4jt/iGL9QtARbc9UJYzzXkaR8I0zLprXUK1Zhj3xDFSVjXCKJQq8bsdftvhc8a5ka6b6PqJbtjPOdc+0lRrmgYwBVVdsmk0pVigqwJZKLxUBGMYrndkMlVbM0xHCJp40MRBMO2v0OuaVIEoNLquwGSyVAQ/UOoTZNSUxlAXFXY/MHYDwhiSn92t94+2uD5QbZYkfUSNkW2S/Nwbn+P+1at8951vR9Ub/v7FP6XvHjOFHUe7pzEj7UqxEAGlNVfjlt0wEmzFxbVlPwW80PQ+8aC3HLOn0BmT9Vs+/48//lWy1HzP6Tez318Q3MSmbmezJVMTzZKL7jjTrpuXKIoNU/KUdcMPfPAHkKrkVx5+kn7/6DYCNO33CJEoXrhLnAQPrvdIA6PMZK1IzvH4wQVvPLxm2jsuj0fqpuBs1TAlS9MuKIQme8fHXv8Y22nHj370R/nhj/5m6sWS+2ZHVda4KKlfOKNulkRa1qcn3Lt3hlytUIsVd05PaNYbqmZBvZ6vaVPVuGHA2wlBQ86ZogqMk5/TWgpDuqFyB5dQWrI5OWexVpRlZMDQTYmjt0T9VjlcF46IOiGPgbIoEXo508BNAdES447j4Zr+8IjpsGc67rDjluQDyQWyVCTfoaslUs+vJTuPXyyQRcmyqnHjSIpxbuILRalK0JHYHemlYbm+A27iOB6oG0PWmuHymvH6EXYYiNmgiopctmzWS+qq5BAlsWxpT045/YYPI8mcCM95k6nige54je12JFXix4wXLa49YTceeLjb4Vcr0nAk7x9Cmk3eVEpM2y1quUC27S3zMqbMdnBMk6cWkuWiYLkoMI1G3qS6jBZCsSINIzxjnvhkGv3EdDdGC0LNXgYxossSP00IoW+ytAek5C0AO6WRnCNKvXV6/aSMWSOlxPvr535/Gj3Ip07hz10Dzs3MRvf8QE4UCqQgTeEtDdjsHPHxQ5AGtVyRyjA3BxcGWS+JxyPZHpH17Pnxvh77a6/3AfbXYRk5u4lP8Z3jpAiB8f/9F4hffBXzm3+Y8r/zexHnZ6RPfvI96euyD/NEUc0TnBifmBJpckzkd6CcR++RWhNcwgdPWRQYZRASXIoE+/ZTcDdYjJ7NzYQQaK3JOdMfJ0SwyOxw47xIPPl+EBFShjRrsb3zDAeLlAJdzGBZ6RvDmCmSXUQKID+liSutkVrfTipS1xFcQNQt5pku4eAjqfMsx8SdQrPUEp8z1z6yNSWxKWAasL3Hhsi17bmcIlNULGrDKkfqn/8YT6Cv+8Qn2B067j94QGkSZdneGrABsyNsaulth1GeUghEoTnGDpkERs7TzGenTrcUJiHJQNeP9NPAkDKnTcumLUnJ411HtJC8QlBgx+sb043EOI4oBKdFSRSBg5tQdje75saAbjdU6xcYskTkkloIYrRs1vcoqBnSyM5usd2ADrNUeRIDZTXTu8rDQPfqA8L+SOgPHLevs33tUxyOrzMNj7nev8EDNzIxMYxbzqRlFbasdcBpRxcn/PGauqqpV9/IQp1zRynOypqTcknVHRHNCe6TX8D+5D8kvvIK4o/8Qa694PP3L3g9Ca66Rww24suGTinulC3GWQ4+8KmrK7Lt+MjyLkpCU51Rnr9MFxXT7kDVR+4Wik0j6XPH4/3rjDahbsxxZFGh1xuiP9IFKEbLQoB95RX84UB841WO1YiSmpc2H0bIBTkEinaNGw9EJ8G8TCHvkEOi7y0Prh8w7h5T/eI/4uW/8de596f+A9q/9jfY/Lk/x7d/07dRf/e3IX7Pv4H6X/9vWP3Fv0Tzsz9L+5f/Ct/4J/4EH/hDvwv/n/5ZposDYioJfcQfr0lHT5JL1PWeJgyEZOguesLR4YaJ3fGa6+MO8aM/ig4R86sfJ8wLBG6aCEVJ+6GX0P0ODlv2NGQ7YMOAMSUyaihaxGJDpqU++QC5PmVSLerFV0gsSb1A1Avk2YcQ1Qtcu4iWLSfnS0iWbrelHTpO0g4/brneDYjk0cbM65QokLogxh7pBqKbyOWK5CPBH1FVzbpZEFLmqpd84bLn01vLxejJU09Va2SlELXGmEChHGp1QiqXFGTK/kjpE7VQnBjNJnkWOpPXG+xz5oiC4W/9BON0JP+3foR1eUpBQBqD8CUhJ3wO2IsL3H5PQctg9yRA/fAPIa2l+cyvMU2O4zSvj5OPM5ulULMXg4vPHXC01rTrJaUpCJMl2JFu+Ar7RLSEHHBSUKiKISaGZ0zBimLBqjlH+IGt3b6lcfd29U7pDe9Uo/NoMkVR4pVCG4PSs5xHqjknWko1m+48Y+Iz+YidIiUHvAvo5YYkNUG0VE2iGfccjiMWaE9OOXvlg5y+9AGa1YKyXhJzwruJ6AJ2HDh2W4bdQ2zwaHlCvWzpt3tySpR1TYwBt30AUkN9Mu9J+ysKVSJKiVQFhMDx4UOG/ZFptyMPB0RKtM2GupaUVUOlCxbNBm0kve0otUf4OataVAofAsfumlFlLnZHHu4m0jiSJksW7ew5khXFcoFcQ1SWct2QnSVZj/cTOSacWZF0Sdx1mNZQ1TX2MDJOHj+MxKAZDgfqZckkBcdHB8ZjIIuSf/TqT7CsS/5HP/BH+R3f/Du5ihO/cvEJ/DWslw3LZcEwHhnkxOPjq0g9cG9R06jEsi5om5nWfNFbRutxeMrlhvAm6n7OmV988Mu05YoPVy9zuL5PW7dUSsxSiXrN4AKL+pT9pBBC0+gGGyyJxKY94ZtPv5kvjo/p7DX9/hp78ZgcI5MEo5ZganRraHJA4elUpDo74aRpUD6xu3RkJKvNhvPNHaLveePBl5mu9wSR+CePPsZiuebHv/nHWFRLXll9gC/sv4iuBc4n+mAJuSZ5y8JIpFT0CSqjaczNdSwUqirQxlA2DUU9g+zp2ENuWZ5KvB+ZRo+sKrLzpBCIIaGMpNY1smgJeuADd2pWmzPQiav9bMAHMyNlZ3f45Dlvl6gwkeQSKQtCmEh0WHcfrUCklhDN7HYvSsbjJccHr5KcwoYdkNH1bNqZug5ZlUzaYISgbWdK+mE3m+iFENBeEO1IUWm8VIjNHYYxM+4ekoYDNgaSjVTJ0mzOKBcrgjIgMqum5N7pilrB1eUl15ePkOFIWwVyd8XClNx78UXU+kUeiw3oE6rFKcsPfZh6IbDjJZUxDMFidUnsDjBczs3jYSAJgVgsQM/+BCEmrnuHc5EWSdMaikpT6llHnpSgWRZoIwmqZhg0/rCfBwtwy458ArDTTdzfcDxyff+KHMWt3FCpJ3Fcw+3QY77u56z4Waf9VpD8pISYvXh82M/JB9xMkBPI2jzVXT9T2c5pLdlNzyVlzIa8Zp5C26f7R5omwtVjUBJ59iJJBhABIcysw99skFVDvL4gp/DUNO0dvD5SytjB46YwM0lvPI9+o9dX/rTfr1/XqlT1zgA7Jab/4v9D/MznMD/w/ZS/+7fDeI3+pldwP/tx4hdfRX3jR97dL5xzfQBwYyDFTLMqbjUsOYS3mEU893Dv0UXJ4CYigbqoMdpgnGIUDjd5Uozz9OemvPckF6jbFhfDLT18nDz20HG6KYHE0XqmKVDXBmPMPLFOCeETRVVw3A3kbGnXa+LNwqi0Jh7nzh8ZxA01OfqEvskOLKqaqTvihx7GiVQ0SKNvvw/QDY7SJoROxN7TNIa2UEwx0cfEoawY+oG43VPGlqIcaURFXWgKDeOjS/j0rxHunsHlFeKTn8b+1n8V/EDSiW6yCFPQmJk2lFPGOQ2qpPRHsi5xy0TsEpu4RJcF27Dj6I63ERzee5RS+Mlj7cQUM0EJKllyUteI6PA+4YZpjrAwBmcnvD9ipytSbmejThQqDgh7QSc1+1ixbk5Bl/NmFAbM0SM6h546UlOQ1guaWJFkSZcuObzxgKUX9OFIcIl69QLeOdYvvIy3BjtF3PFV0kIjtpb7rz9ErWsm36ONoYkP8LGcqcc2IvOCZXHKZZERbsREh1jcQRhLdiOZa7CZIgfEJJn+xt+A9Qbzx/8YadlQR8+D3rEVHX26IC5eRpWS7CQPHmw5+6c/g5KG/lte4SPFmuwNEwemsGfMBUNxwgcaSbVaEqMjjT1ZJrJXeDOx83uKWKDGWQ/ulIC7L1GOA/b+I9yLJ+TGUHz6E2y+//dRhYZ2tcBPMAyB5l5BnhL9P/sc/NoXMZ/9HB/67K+yeO0+519+Hf3o7Y1X3qmqX/s01f/uf0H8D/7P8Cf+55g/8HtJm56UlujzO4juISYk5NkHmS4mpn7CmgmVJbrQDN/7UepffpH0T3+e8rt/gPaFM7rrjl441usas1wihz39fseYCsJ0DeIOyQV621O0NaUuwGeqqmE4HmlOS4TfkUKE8i65rRhe+xwmLlBnK9TyFOccwjn483+belVQ/p4fYZsD/riEzfrJwoEqGlz3CB0FuWiJQhGGPUKDKVeAIOZM5wTrUnGyUKyX59AP6MJgao2IHucTtt7QrGbH3VMf8bs9kyiRVYmYLK6fKBZLAophsjTeI4yh++l/QP+FzxF+8Ae5+9Fvgf6SKDRaLcHD4EeIHiMl2VqEMAQ1MPg9i3/lBwl//ydRv/hxFj/0g/ROIwW4kGjLeR2WhSLFTJ4ifX+gaBtMUSK1pGwqdIgE6Tn0A7WGqqqeizckTEwpImVNFgbI+DfHlZUrNilwyLCzOxbFglrXvF09acQVRUFVVW/7M1+tcs4M4xG5f4gsJaM8of3KW8pzdezd7L1gd0TZEIsa4R3WeWzoaXNiYcEtX0A2NVpKUnLoQmPMhnH0NIslyUOSllgEdD+RncPakaJsGKcD/fbA8nSNDT1jcJRnH0AJwdAdSdayODmjTxNGN7jDgZQzqw+8DGUkDgNuGEBrkrHYCEpXGOkYck0Ie7SIyLxCNQYRPdPhAo4jZ/1ATgYrMts8MDQlY1ywGHs47qgX56QscW5PfbYh+Yk8JPbDQBA1sVWIkwXVY0e83FO8cIZQgt2DC/pHe6qzOTLx6jjSJ8sylizulvza+CoP7UN+/CO/hbPlGb//m38Hv/TgF/jJBx/jpfEj/MB3fSuNKtk/3jKaDU3QlLni0B8QUtA0DVJlKlVgsaTxAaro0c0r+HHEOXfrCH3/8IDH/QU/9ML3cTgOSGU53dzDXbyGqhdMKJy1SJmYguO67zldtPS+ZwwjbdHw/Xe+m0/vP8Onuy/zA6nFdoFUVYy9oz5vmIRgKSp0ipxVmt7MRmAnjYHXHtF1B4rQcP9BYGouWRnN1vbYouDL0+tc2T2/41t+/FZO8S3n38TnLj/PVbqkbDd0vWXT1DQq4oYOKxbELNjcULdzTJBnB3GYp4WmqskZrt54gNINq3XN9fWew77k/O4SxBG768hoZJHJoyNYxf7hl1mKkpVfkkpDF3seXl3wwtkd9uFAJrOpNuT9NUUjiKnG2euZiq5LpCjR4hRRzAks1g8URYuUE+k4kcWK8bgligVyEcm72c07Lxa4kFjpudEljWE8HCjqhuF4oNGKpl3ii4jdd1wqGIJGjg8RKVOerBEjmHiNKGrsFJhSpNQZky3GTdwxE3vbc731IA3rl7+JsL+inySrzYoP0vHFy54HTvDCCxV62tLtvkTIimVdAxYrM3mS1NME11eYYkloV/Ok3RhsN9ApR46ZVkiKck7wgBmAFnqWIralpmxmv5xhXDJsr6nUluL07nP665RmT5xgE9NxZBxGhFQ0ywo3jeiyROsVKV2T0kSM83ocYw9ktF7wTmXMKd5f4v0OI07I4cbU7G3SanJwZJ+gXJL98Uav/pR+LpRAVIo8BbKWpGkk9TN1X56ckqUmxitU3aD1Eu+vyNkhT8/h8iFxt0euV6AUaQzI9u1BPoCfAsGnWZb5LLAWINXsrSSVQMo5eUdK8RWd1v9lqvcn2F+n9Y408ZyZ/tJfmd1+v/u7KH/P74BpB6pAf/u3IoJ7TzTxZx3En3SfUkwINZtoZf+VaeIx+NnMQ2v6cUQrSVVWFEVBqcqZrmXt7DL+TPnJIZHIUj+nc9ldHZAy0540qCKhSM/TxKUkMJud2dGjpEYZZtOcEGYQH+fIjSfOvNlG1DM6bABdzPEE9uKCrDRZl7e52QA2JfzRUQqJLBS4SBo8OWaMFBRSkJUmNC1TcoxDhwgRnQqUkUzTRP74LxLsiPiWjyA/9BL2i5+nefVVXi4ShalxfuTRo0ccDsdZj+7mvMuKJYWWOH1kiAPNYoExBcJmlsUSGy1jmON7vPd475mGEYRC6QJLYl3X6GpBnAaGy4cIV+KSYQqKsmhIVnI8HLH9I6o8ko5XiNRRmIrTs5cYyzUdT7RHGSdhIQPaezrrUGTGbovcfYn05S9S39/D9YGBI4fCoxdrxL0TmrMzVL3GLGvG/RXbywfEsyXptMXtrjhed6h8zkdf+lbK4iOUxSucLD5MUZ1CkhRCY5Sg1wP7wxdx3auEdEXaXyCGDn/xWYI9Yv/iX4EsKP/oH6U421ArSR0dS6PY+GtaIWnaU+ovfo5v+r/8X/nWf+V7eenf+rf49j/yh/jdP/Lb+ci/879F/uW/xtX9HQ8vH1ESWW4WSJEpm5JyeQYBRFdQ6ZazItMIScyBXb9FpZFJaYSbKWvbbElL8B99BfPqA07GBj9OqLqkVAH/s79A/t//u6z/1d/LCz/647zwP/kf89Kf+ve5+1f/Js3Pf/xrBtfPlnr0EPV//D9Q/tBvpvj3/n3SZ34BfbZC1AXKKIrNbDi37feEKrM6OWGzPqMoSsbf/psJkyX/g59ACMWmaSiXDX6ayJtTklSoywcgoXOZ6dgz9h3j42u6BxdElRBaUKuGPHYMu9che+T6HsiK3WGHT4p7akXWieOwZ5r2rH7yJxEh4x8f0X/1J+D6AXb/Ot1xwseAG0dikIRxjwuOIEuOu2um4UjWFdPkebjtiN5zb2n48Pma0zZRL1dUpUBNN+7Z0w5d1ORigUoRlzKpaBFhQplEUSlK6dHLlsA8kXIp4/qBw4NXGf7O30FuTln/m38Q3a6I/TUKwAkGO+JTQEjFvqiITQvdSI6SwW2hrlHf972ky0vMF79AXSiuesfoI+UzJjaiUng/0T245HjxNKtVFAqJYF03lFXN5CN93zNN0+2EOQeLFZlKVfg8+1XOhu7PHIB0hRSatdCUupyNq1z3tteS909jir6Wcn5iuH5IoSRqPOJTwr+LKUc/eYJPFHREbwnFiiEE9l0HlAil0WennLYF1dCxs4GQ8k08lyRnhXfu5rCbkVqT0sRmeUKBZPK7Oa9darz1+N1D6qYi6iV2ssQQGPqOujSosiSliMQwdR3GGMxigV6u0OebmcXiHOGyw108RgiDxGK9oZKRNB1QVYNIE4zXjB6Kck0hLaenFWfrBQsxcXexBC25tJYHu46haphCgdSGmI94YblKjv7oaERLVSmcEui7mznd4vGB7GejzeH6SNf1+OWKXdyzUYF7L9zDtJL/8jN/l8aU/K6P/msAGGX4Y9/xh3EZ/t7V3wPhGZwlmiP1yT2W+YxyyJw357yweYFa14Rouey+xOXwOtn3nNclqopMyWP7/vZ6/NiDXyID37r8Rnof2aw2iH5HThG9OGG0lpgCi7qiVopH2y3eB2pdM8WJrOC77n07pSj45Tc+AalHrE+4vDxy3I+MSSFzZllp6rYiB8H6BuheyILJCE7FnjtKUWfNo52lTzWb+g5DtPzdz/0dSlPw2z7yI7fX3keWH4IMr/av0uEoc8udZYMpS8Zp4mq7oxJgboBHDhkQoMQ8LdzuiPs9Skmyy2Tbk4+eOnnGiy8zvvGY1HW4116H45502NNfXjDueqK1+DjRtgs2U6DOgtfHS954/BopJjblBpUFtnuIWUpSHPE2IuUSrRtM2eLGQFEWrE/OKcsa7y3j7sDkHbpZULSLOTZ0HOiuLrECjtMEKVFLQYxzZGBV12TvsMOA1IZCFDjbE93E7jjS3vkwJ6uWbI8IaTCNuTF7y3SjR8pMHQ6I3QU5BGS9YfPCN9Bu7mJlw5YKqoowbLGDRx+vuWsSwkSOQ8dVP7CLgVytuBYVk0jUrSIqxeH1K1IS6DKj83wWsllw6CdETDRZUBhF2Tw/Tyy1wsfE/5+9/wy2LT3vO7HfG1ZeO510Y+fcyIECSIARJEESzJmSKI/CaKTRuGZqasr2lO0v43K5ZiyPyhrKGlGyLA0lUSREgiABAgSRiUSERmyg0d3odPNJO6y83uQP+6LRTQRC41EZ0uD/6Vbds9daZ5/1rvU+z/MP/uYzSGlJcWZGlObYuqE9XdG347P7Uu8HzGCwg6UbLYNrGYcOayXOOOww3Iz1Kgihx5iBEBzOdVuTuz+TTOCspd2s8c+R5ygVofWUsTsm9A4RK0T0dbqQ40gIDn8zQ/zP0sRh26QNUmAOT3F1jSxyVJ4gohRnWoII6GiCCBIp422UW5QhJyVSg99sQN6cxPdfx0fJeezoiVNNPo3JZzHpJCLJt8kJUoptJNzgGFpLXxna9Ui7Genq8dnJtzUO/03ELv77hG8X2N+i+IY08RAY3vRm7Kc+jX7wAdKf+EEYa4gLbDLHnLsdsZjiP/vZ59FGvh5CCATrEFpvqeE3P+LsTev/m7mCXw92NFtTDCfox440SZ4thNM4RSqJCY6x+8oxvPeYdmtu5vDP0r/HvqOtWqaLCciBQIfShqG3zy6+rdmZxxmHqS15kRLFejvZtttNrR8sQmxjrES8deFWUmxp4s8pspWxuGHARikI0NFXlkQ9WmRtSGJ5s+EQGAfHct1x2I60zjOJFHfvzLl/UTAZ16wqz/EAR0PLMI74jz8EsaJ8wYOE1/4gNkmIHn2IyPaUKmE/VkTDyMnl6xwdHnJ6smFsB8osIpnsUpkV3vdM4snWeCIEkhCT6pR6rNnUG7qmg8GTyAjpFatVRWwCkxDhe0G/WeM3NWk+Z5SS1nogIVQD3dPX0c0S0y4hLhHFHiKbU2YFEyWpnacZDcMwMLQ1k6EhWS0ZD9c0G01rNEIl4DQujOzsFajEM8YDvfB4RqZFgRkdy+WGo/VluiLQ+inF4lbuzySZiajahCJOcCJCIYhESpItEOQIP2envIty5xaqECO6CmkaXADT1uiuxf7uW3CbY/RP/BTq9lu2LvRdx/HVqxwby8iGg498nhf81b/Ky1/7Os7/w/+R6PQrWifdNKS//weUf/2vccdLvoM7/+bfZuc3/zni5JTTTUvfrDBhgypTlFyQJreiXYQ2FVkw9PUJq/WTmACuPeUoGNgt2D8zJ3/5K3GjQPzxnxC/412E/+zvMHvpi9j5pZ9D/92/j/riY3/uGv168JOC4cX30/zMj2H/q/+CcMcdX/PnRNeh/9lvk/7ATyB/8eeRD30GrWc401BMY1b1hjBYErWNgJklM8KF22nvuhX/hc8xPvYEZaaJkxglFcXOYkvFG0aSYYlykktXNoyHz5DoiNAPNKsNIQ4oX5M4Q131UMwROqGVPZt1zSRekMQKmpGrh8/Qv+fdiMs3CN/5Kuzrvh9xWLH4N+9lfXiJ+uhpqqqmaxqGzRHOQ2c9wzBQLY+wAnorub5qGEZDoQMqOLTOgYAXHpFnYFvC6gRCQBY7SCmJbj4n+6AIHrzrUc4hEOSLkijS+N5gI8310+v0v/MmYidIfvpniYqc0Y2IZI6ylqE6pXU9g1R0LqDTFD+dEQlB2FgG0zC6geQ134nQGvunH2Uit+fvRsdzn9hCCJp+DUIwbhr6Zlv8Ci1BSYT1pEmMjJJnTR+bpmHsW3rb4VREohJGH0hDuzXgeu47QQiIc4TtmeqSMipp7TZ66c9q94wxSCmfR3/8pmFHVsdXCQGS6VncMNJ3Dd2fcxzvPXUzEmsI/TFCZ/ReIhGIvCCdLshne/SmQ0xnTMOA3KxYWot12w2vMWbrjCy3PhweTzA9ZTahzKcE36Okx1qL63tsu0EkE3Re0NYV1WpNCIYiy3Ai4H0gtAN2tSIuCmSaIkQEeHSREaZTRLkAoWFsaA5P8asjEgcISbAn0K8ZiDFyq0EPPqC0I9YB4WGiEg7yhHQ0ZM7jlWI1Oupkj8tdx6XqKp3rmaYFiyQldQE7epxXiDimu76iuVHTKY89SPCpRArD1PRMRUw03eMjlx/msLnG993+Gsqo4ORkxWgMO+I837H/Cm746/zR4x+g6mqmWc7efI8hwLjqSZOEWMWkMlCqQBHPmYRddvUeO4u7mGYZVvVU9dE2TjN4Pn39Myz0hInIiKdTMj3BrA+J84KeiH4YEDIwyTTn9naQCC4fnyCdxHlH73qKvOTu7DaeuP4UV9YVbe8RKhAtJlgxMEsCJhJspMcKsK0jc47rJys2oSFRihzBg/fexq0XD1i2LfUm8PkbT/PMyTVeeeGFz06vx3FkP91jkc/55PXPIZRmkubkMqIoS8Y4pW0aVPuVhlSwHpSAEHDLJW55iLl8hfrRJ2AYySPJsFwSE6GSQNV3iNkCqzN8qhkjTZVmhJ19xMEFujwj310wmU9JKkfbnnK9PSQfYzAj7fIxjN+QLvZJiwUyLHBW4XyH1hm2H1FxhFKKPF+QZYoEh4pihrHB+4wRj/SOdD5HpinrusHXFV1dUW822wlukbDsTjF+ZOw7EhkzKUui3Qm9EyRFSTrbZ6iPsN2AygKohHbTM9pAHmpUuwaRY3uBN2BcIE8T7ji3h5JwOsSMY0Nz+SnG608xnSaU8xmi2GU5tBz3I1ZKUBGn1mNMTZrHhNHQyQynMiLf0mxOWPbb2LvUOHQkSYqvzo3+ciPzuR4WMkmIJwVJLFGupW8GxtbjrMcMNaZ3eASj6ZCRxcsegsMaSd98OQatREeaYVhjTAVCotTz3fRDCAxNjbfbhvFzodUC3w9YX21jt74GQgiY9hQTapxqtgOn4asTIYJzhL7CDyMyLVGJhuAJOsWMNUpnCCfwjUGElBAMXoBQGpnHyDjGV9siO1iPH776eT32DiEFOt5+n9uJ/1bmFKdbdkBWxhSzhHwak5bb4lvHWxmQdzeL78bSVV+dyvPvM75NEf8Wxpdp4l/WHwPb4vqtb8N87OOou+8i/akfAjdAOoW4YF0POK+ZvuBB7Ac+jH/6GeTtt33jEz3H4Mwa/yytw1m/1SPrCLqvji/4MpzdxnP1w4gNhkm29+z1xnFM3EdUqmNoR8rF9jPjMBIcxLOU/qZZUfCe9WmFimLKaY73S2Skoa9xLmcYHFkut4X4MNK2I3EcEWcaYRK6m9q1PC22jQUtMX7rMh4FgXThZqTVVuvkxxHpPaIsGbqBYj559rpdCLTVQGoccjdniBVtM+IiibKewgWKafKsq6ecTpk111CNo0t6BiUxn/882fIEXvYCzOwMnJmQ7J/BP/k07nWvJi4jlMjYUwn1yZr+6ITVqSGaFoSFpjYCFxRTKQjB3TTWCPjNQBrFrNdLTpqWnWxBFiV446iGFqfh7M4MGUc419FHjiydEs1y/DCgx45NV6FTi7Mxzi4YVx4d1SgJIpLYAIlz9KPl1Ack4IYl074hVBWZG9DzPVY6Yh7FRLGjb1YkOiBXV1hEgmV7jXCyIV/cx+nGcOPxJ8iimlvuvMDYz2irYyQdQgH0PHrjKlKrrT7LduhM09UVQuQkRYKOM5ar64ShZZLOMbJADMek738IcbTCf9cr6W+ZY4aaMAjWp6ccP/kMZ9/9x5z7/d9FP3Ptm1p3YhyJ3vEeone8h4tSMrz0pdgfei3jz7yBcMt9KBWRlFOoDGI9QhGRnGw4HJeInSljWJMaz35iiFcV2WcfJ7zjj0j+4f8L8Q3i6r4egpT42Yx+Z4f+ta8jv+9eogdvYf2i+wm7B4yrU3Rq6EVA/5d/i+IdH0H+43+M/OAHv/p3CwHe9g7U295B+aIX4f/W38D8xA8jpEY0Aju5qXX2gSKUtD/2g3S/9usk73gb5Qv/t0TW0Q8D0zQlnc/QSuOGY5LastysmZ8tOTgoUX3HsFwxuDXZpCTZvcjqqafZTBpioblxdUMkY5SQjINF9AP9lS+x96cfR5+/B/uGHwOl0FFg8YfvpPq9dxP+0l8miQVJvyHbm+GmdzHUa4wz9FFMNjugcZLpJGWex5hxoN6sAXlTY9ah4gJZX8J3ilCcQ0iF1hpjDDrZbvKjqCCEDjn2CB0j44h8Kqjbmk1fE3/848yfukb0Xd+Fve1WhNga/Kn0gKFd0nenVNkMLTTzSJJNCo6NQ+3soK9fo296mmzFYv8M8oH7cZ/5DO76ddL5ASFsUwt2ihglBd1mgx0GpmcPaI9PqZenREm61XrGCt8ZYi1obSDOE6IoYhgG+npF3W1IFhdwKHwY0aFDhZjRJ+TPyaQlKrZRL6YlT0qUVGyGDcthySyeoaTCWos3hugjf4q7/XbcXXc+n47+jWBHbHVINTiibIchKjGsqZYrGqs4lyVoJYmVRCuBfg59sOksIUDMiLMNRsxpx5GdfBcXepph5Mzugnp5ld44sumU6WrDcrNmlRr20uImzROCFxA8RnikHQjphFjEdNUhOteIGxX9sie/9QzGQprlLFcVXd+x2Cu296q3CAvD9WuoNCXd30dovY2ZBJQKdE0PXhHvX0Cnjs2xRC0PEY1E5+A4Rs3voO1jlPYkkaQSMcSB4BqSqMQYQ8S2mZGiKGVAR4pax/R9grUNosvIs3MMuUJ3jmAsrVbIJKfKOowa6Yae/Z0dppOcw75CbwwhVTgheOeTH6aIIl5z7uVcfeYKy+Oakzgh2tnjp+/5IR5bf4I/eub9vGhygVvnt9J2G7K9CeGkojk6Jl4AeKTKGDtPWrVkRQZBkkcz+mJgs7pB1VzneNOy7tZ85+7LsTqwU+zgmhrpWqLidlajYxy6rZmi7Ahh5Mws5sZmpOkHnPec9ivmfsqdnOPz9hEea495+XxBPAG9cw4hI47bFjkOpLFmEJpx3bIZRorIEO0UqMkuarWl+5+bL5DOUG8GPnz4cULIuC9/AfXmGKlybDMQxzF3TG7nvZc+TKIcUaJxZjuMkEXJLoF6swEE5WwGbtvU93WNX11HJQoxnVDd6EgmBZM7b2XsOkzfUWQp6/WaddtjvUH1LX2yw3HQaD+iZYZWLdKviac5h92KRSixpuH65nEOzC62r8iKW8mKM+BGxqGhrWriRECIbnoZbNe6lAm+q0E40nyCilK0SWmqip6aeDLDIZBZzlRJ+qai61pc7Bn6DukFLlLEZUleTtgZFTeGUzQBb3uy2QHLzWOM6yXJQkExpVq2yHQk8htsSOiK2XY/U1W0xpDs7pJlKbec0VwaBtZXrxPVDfEtt5Lu30WJ4vD4GCW2sXPNoDiYTqhtzeH6hPOxZHLxIqMZ6QyMLqKtTylKQewVwjnSPPqadGQpBZGSDNaRxV95lsk830bOyoFEeZQqqZcVXbMkn+zRWwtYsiLFDAYhLXGWbWn0eU+SZaTJgq59hr4fKYpzX3V+03d4a4kiiRkGfJo9K5+UJkGIBKPWJGL3q67buQ5jKnxXofMpUhcYXeO6BjkP26YpEIzBrdcIID6zS7AQuhohNTYM4Dw6n+BHh/MD2mY4rXCuQ+pk64E024f1Gt9UiLSEAYISz0aFOedxxhPnX93A+FrYpsZ87Z8Lftu8/Ho09H8f8e0C+1sYiU5obYvxhvhm9uT4zndhPvgh5G23kv3cj4DwkC4gShmse5b+5174Mnj/Bxg/+QnSP6fAftYlXGv8YHEBBueJA0CEiDS+CQTnvkqH/WVatooTqvUGrSV5mj/7/1prUp2yURVt3zIzFh1pxq4n0hq0wI2ONE0ZmppxDGRlgY48xgTSdMHYXmawNUOryfJouyHuHUFAGcstZTuK6NqGYRzIoxIiCcExWrM1gRkcqQSZJTjjCWnAbzbIOEaS029atP7Kwm6tJSx7skjTFhF98OhMMc1jYruNTXDLAQqPLCOCMKiywJ8YpO+YFgU89Ams8By/8KUcj5b9pGPvBS9AfuT9jHVAliNRFEh2ZpgoIxyuidKKRBmao+s0oSMtJvjSMbJE2ykiBPqmw0aBPMkZwoieRkilGb1hYwzznQlFqgnO0pxcQRpIfM9w+fPgJJmAo84QyZyiTDF9j+ksIq9xRpHN9vHCIZKI+SQDKbg6WhKxJB0FfhLTVp6pr6n6OUd25GwpkYOmCQajCnSxw6CPGFyN7JbYa8eky6vc+sJd0nhOPXY4P3LoBYSRgzJwagLSjqRxoPeOyWyOWTmUMug4Q4+eGYI2Kol1guiWjO//EOaxS/DgfcQvfAlqXCGdJHzqcYr/56/x8re9DTl+Yzf+IMS28PwaEN6TPvQQPPQQ/Ld/H3PvvQw/9EN0P/7jyHvvRXUb7LpHjI7x4ALxZM78U08ye9e/Jn/3e1Gf/Pw3PPfz1tJ0irv7TvQDD7C85XbahSa7926KyS1Ub/o9lq96Le6HX8/dsaYbL+HimMxHkO6QZgl9/QxD2KBe9wPEP/7jjJ/9LPHf/zWiP3gz4mvQeuVnP8v87/zn2P/LAdGv/kcMf/Gv0RUJ5WKHsXNIJVlcuJujl70C88mP03/qkyQPvIClC2TeoicTCJCGFYu2YkxLTrzCL485P4nxJ8csfU6nCnSyNUvcbGpkJhAqcPa2A2KpoE2przzJ9O3vwUhF9Qs/jxEjlVXsvOa17KYx4+++GfPG38H99C/TnV5HF5pocha6GlcdYuQOq8FTpJpZtt1QBbV9vRljiKIMazcEmSL8AKrEW40MYduwG0ei4GnHkUInBDci2g1i/+L2GIz0UUt22pJ+4CHYmyNe9/3ACDgUBdZ4Kp/Q5RPUWLOrUvJyByUlifSYckqab7BVxyY7Zp4ekLz2NXSfe5j2Tz6I//Gf5swkpRosy3Zknijq1SlxXpBOJwTjqetTus2aYr5ARBIGQeKhYTuJSSNFlmUwnGIQxBaqrgM5opUgcuardNhIudXumRaSkkQlLNIFq2H1bJFtjSW8/08Y/+QD+Hvuwd52K3Ec8+fCjvjmmGawuLgkQqO1Yn9/l2R1ylKCF2CdfzbTWwBKCqSAzXogSwS+P0FFmqoJeJEyy1LGaqQ2lrMiIc4zTNtgih2ismCyPuUkaFYKYu+3HhIBRuOofEOKpNIZSmeMm0OKMJAnjnrjGX1BJtx2iuQcg+85L2YEKTHtGnu6QSIoL1x4VlYlxDYjVwiPHUfwiiIpGcQaV0wp3SmSnogFpjf0x0d0codyUW6NinQKiUKMNak6YBAe09TEWtIajdtUqNmCUin2Uuh8waYVkBhWwWNGg7Oew2oklQKdpYSTI3IUeTSjXa1BGlRcUDWG9336PZzUa15/8UU0JzdoG02Ux1y/csRuaMlnAz9w20t4yyMf4Q+eehd7xU+RzRzpbJc+PaY5XhP7XYpyyjisaZcryiSGPNmyoTrIpKUVsG6O+ZPL72fsltw5uUBcJmgkzniyOGawgaHvcc6Qlxqlkm3WsK5RoeZ0bZnqnHW3RNqKBxb38vbVR7gWjmncLmsTk6uEvTgmjSPU6hpj1bIREULO8DLm3EIS4hldyFGbBnV0RHTxFuaq5FHzCU7Ga7zillfTmJIr10+YRBVFvEBkmnl0gPaC0/UVdmd79L3D1COyUOzlU2oH9ekKbxx5lCO9xx1eRuBQi7P44PCRIZWB0HUkeb7NfF9VDG3DMNTk5S6rwbFqe5SUTPSImBREVtEMh7hogdCBLIoJwlE3x0SjYcGEeO8AAB1LoljRtBVjP0F4QVIUOGvxIWz11f2IE4ZU3UxDaDvyZIJYFKgs46Tr8dYymEBlO0Qh8V1P3GyjpIJ3DHakCIFMZVgXyDOJ6wd8XiLilLE9ReQFJj/AXLtKwYiNFX0+RWYZGwG5d9B1qKrCi602+0A2bJKUk37kqs24dQhEscUNGzbCUkQSn01RasLEH3HSrJjHJbv7+4jTJavBURmI4gKaFmEhiZJvWLAlWtIM9nlDLJGmiKbZvhPESJ7D8niD95K+V9TthixLSHPNxm6w1lDOSsY+pjmtic+lRFGGEI5xNEwmz4/l8s4x9j1RGKFzIBRD15KVk21qhPMkkwMGe/UmvXzrieH9gLU1IViki9CyQBW7CF3i0gbbXEcNHTLdDlLceo3QGjWbbc2LW4Nfd4hZiTMNSqYIqTDjGhdaxCiRKsGHjqAmiLFFeIuczbZFdr9lyfpOPKvHNl+eXkf/v5Ohv1Hx/e8rvl1gfwsh+EBwX9n8RDJCCUXvemIVM7zv/Zh3vxd57iz5L/woaAXZAtTWiKwdHFoKtJR0Zy6Q7+7hP/sZ+Mmfgm8wbdjqr78cQ+BpncMRaAZPlGniLxudGfNVBbYbb8ZzBUU3thTTHCmfv9jyNCfuNEM/MjQjoQj4wZFNMpx3CCG2NG1jQSUURYT3I77uUCJCqRwpG/qxIFiPMR6BQuVhm79s3FaHpxR+cPg8oLTYUtITQZGV9OuWYRwQ3iJUjFl3CO9R8zmiMuhYYu1IfNPgp1qPRK1Hn8nZiJ5cwkQnSKUQ6U3deD3gqgE/WHzeYkVKiBzSNIRLFdmlp+juuJ1uusugDKcuUN51Bv1RCU/doD9/BzIYZHuCbLd06/L2cywmmpPlNeRgKXyEOe5pmqskUYac7uINRCIi0YrRQ7c5RA8bTpcNFBHTTmLrJX11zFhdZzLdx+OxImKpEkYhKKb72CzHDS3aKZg4RNIhlCOezZEh3tLdfCAdPaGpaZfXccZRnL2VtWgZDo+Z7wRO9YKTqiVNI66dLolEjOkt5XTCbpgy2p4rmyPmu1PSYo+qOmHsWvanBxx2EVM7sigmCJEjs4ipH7FtS+wTpvEOOpLMZARI0p3bqIOgp0Z+4ePkn/4i7o77aH/iR7HNmp3ffzfJP/st4k9/48I2FCX2Z38W97/5K6gzZ/DveS/h999M8r73Ib5B7nv06KNEjz4K/+Af4G67jeF130P73a9mbGse+M0vUL79nUSXLn/Dcz8X4z33UP/gj6B+/qdp790n0Zrp/n3044h/7GGWNx4nfPRDAMjv/k4oI7yHprakQRCigE5S3GiIs32su44ZDVQVvPjF9P/Dr9P+1/9H9G/8Y/J/9i+QVfVV16CvHzL/v/93hF/7Napf+jlO/8qvkt73SpL9KWPnmL/+DXSPfYH6bW8hv/UWvLf0QTMtJzRH17CrNZNijjh7G70YaFdH3CAjizNktAAXiAnsnT/g+ukpQ9dz/sx58ixDKMHGGpbveS8cLql/9HWoXUE5dnTWYZMpfMcriKxheMtbEG/+bcz3fj+bY8s0uk6wPW3v6AvFTAQmscAMPa63mLqD3mKMIUmKrTykPdxG0hDhnSeMHp1su+/Se9xo6LUGF20N/7RiPawZ3MAsn6De93Z6H6hf830UwSFFj2CCHeC4brBlQp7ukJy2JGOFjM9sn4FKsvQBPV+QHtVsVkuqYsX07ruQ588xPPQpxPf9IOlsH60EJ83AtRunJN5T7uzi1ksioYijHDuO9G1DVk62WuzeooWgN440UuA91jXk0zmTdMK1pkHYDY1uIMqxcor1Gv3czUxcQnMMpocoRUvNTrrDeliz7JeILz5N9Ccf3KZJPP001pjnM6u+FpzZ5oQbx5guCG2Pkooy0ShRMI03tH5A6ZSdJN7SHl3Aeo9xgZNlSzdYvDXUXYVAcNgGkjIjTRXlkHDYrBitI4pLgm8xfYcqJ+huyaztWKqOREjiENj0jmM7Yn3PfpEyi0asjKl1yvWjZ9jbPc9IR3V8QlrsM9ZrXOSIiBjqNXGcYdZrcAK1s0NSPt+0SEqNdyPBeTyaKE1YVQLdr5CiJpnsIffuga5mc/USJjikMDTe4ZTGRwplFNJ54iiiHnqUFlx1gd3Wcuu5jEIpGrNG2ZxZWpDEFjM0HImYY+uIYsn5nYy4a+lqDVIhZynt40+SZTnxmV2uXLvMWz/3JtJIcV9yC+3mlKAOyEsBU8lmdR0lFS8/+zIuX7vMw+urfPT0Mj+0mOLHjigtyVVMqCf4aLqNeSrPsji7jxGSODgYDX4YmWG4OrR85uoXOZOVTPIeRc3YdkjfY5Wjao4Ye8mpOeSPH/sAV9Y3OJOf5yfv+EmmasaN8ZTZRDHpOjadY7G4hVtOzvP46hJ3lrchlOfuNGGuBLLfEIoMk0/p6g2jMMxiSTCeaTEFH2jnC+TxEWLTEMmID1/5GBLH6+58Jb1J6KymEAPOtlxr4faztzO9UfBY+yQvvPAd22SRwTJ1AlygTCcwWKprJ5ikp6CG9QnqzG2Q79MfXUVHlnSxx3C6xDc1QSmE0hifcVgvOYhrEqnJhOdgltDbDZEUWF+x6Z4hDyv2y12W64Hp/q2IqGR59WHSyT3kbhunpCKJVCCEo9s4sjyQ5AXLrgedUJgOrEWpDKUSQrDY6oTkwp2E1COkR6YZpes5Pb2GMSNxK5CdI9LbWFO3adl0G2bljN5BoVNEapCdZxgsQucEtcH3iloOqGCgN1QqIZnNmWvFyTBgAuyeOUCuj3BXD3FxjLea2YX7yGZPcnnT89SlI/Zmijgdqevts21/uosac2wLXZqykY5s3DCgGIee3d05/ema1hiK3CLqI5hPn90j/1kkWlIPX2lOwk0H7jxnrBuiTNOfXEVpwexgh5OjHpwHG5GmM+pmjbEGZ0cmOxNW10+oVw3ZVBHHOcYYrK2Iotmz5+ybGml7CB5rJcEbrBqwKkYYEIkmjheY5pBxPCVJzuBcvXX5FhFRtIDRElSN0DF+HImKPYbTG5j2hMgFXN0g0wQ5nX6lcaC2jQQzGoIOaFXg3Yg1NSFR+GDQLserFi88SgiwPSKZPFtku6FGRCV0AlL1bzW9/l8jvl1gfwshjA7652scEpXQu57hQx/Cvv0dyP09sl96AyQp5Dsgtw+F0XpG55llEVII+tbhX/hSeP+78E9+EXn3g1//vDcNzrwNWOdphxWJGvFhwdFmYGeWECv5NfOw7Zfp4f2ICSNl/tWUliiKyOKcUw4ZugHwSCHRWUR7kyrjgieIBKECSapxroamIyhJJBRaBgZX01YJCElWJhg34IRHGEFItrFdEREWR+Q8o7OkcY7SiixLcQS6pqVt1jg7MD2/j3MChCS9OcmNknRrbrbsmKcKU2r6cUmuJUEkBOcRkUREEr3I8KnBrFr6oxVVrwhpzERp+MO3M3YD1x94MT5X3FtmLElZn12gIkX6xUcJr3k1rZNkg8Cvjhj6QOF2EBa07ihkAmZAVxW+WtG4p4lPd5hcuA/lAsNoKJOSUYwcnhzR65gzOwmpHvHSMcaW7La7SHfvBG/oDq8ydiOxipnGMZqYxoxEnWWymNCseoT2mHRDFC9QiSZ4GKoVxeYafTVQF+dI9Yw0hiTWeGUZ6xtcdTEiT1DWMYsyrPDsZAnjqmI8XTFJctJze9xwkl6nZEVKnRa4VYQ013B2JPaKyV6BqQUqsSxPVkQyIgo1vo2Q6QSVpnB4A/+B96M+9CGYLVAvu4+9/+bvkb7xd9DrzVfdf8+7Xx98AP7636D74Z8g7OzRDw1eSfSv/Arrv/43mCxPyd7yB+Tv+GPkH70d0TRf91jq6afJ/+lvkP/T3+DgG571OWtNCOyrXsrqB/4C6gd+AnPr7VxdB85fyLHdMVm+Q+8HhBUs4gXXNob+i58ledV3k5zZJwBrXyNliux6ZCKwxqAF5OU+/VARIrCDJ5ycIvIF6Z33svmv//ds/qNfpPy9t1H+xm8hn3r6q65NdC3Tf/Yb8M9+Y3ut+/skF25B3n4rsdb0x0eY0xP0d/8A9r77sFFEvzwiDprJffdjqxabzDi4kDJKCRZc7/HEmM0alaT0iSQygcRJ2m6kixXrLzxMePhjyP0dZt/1GowX+KCITUecBzYDlK9+Dcv2iOx9HyN793sYfvpXOLx8SN+ucTImiVf4jaVuU3xrEAE8EFYdJu9wSYo0A941ML0L0Z4iGPC9wKsAEvpuwzDUDGgS0zP6FtFfJ8QF03iKf+gh+qeeJH7NqzjaP4c/vs7exT2cjbm2WeHjiLPzEjEOhKhEqhZhNqAkiYpQAkySkBQ7xPWG5foGk3SOfu1rcP/Tv0J/8hNw4UfQSpILy7KqkLMZynucsYAn0glWjrhxq4WMkpQwCGLv6UK46afRMdqRvDyLimLizEN9ncPWEakV6XSHMSRonrMpUhGoeDvFjrYaVCkk82TOyY1nGP7NG0F40vvuxT7yRez1a9g8J4q+9sYVZ6A93bKqoikhirDrhnSa39zIKuIkIe0G6mFkHm/fW7EWxEiGwZJFmkUuCP3IMPZUNqX1mjyKqawnjjTOwaYf2CtTdDxgvaBvatQ0Iz4VhJNDrhYLCjzSBGLhmErHzmSKlhCHljOJ4BKwJEKUoDrP5vIaCoNKBJmPqQ+vUi72tkkbcUwymXxVI1kIzdgvEUIjhMJ4D3VPag9hMkemi+0knZx1sUMbOqLREYaRjbXELmGelDC2GJHROM/gLVJJ0gCl1lhb40wPbkGcTfDG0tkabwKzPCbJFNr3CNGRnsnw1ZrOPo1Sp2RxAqHm45tPsvEbfu6WH+Pc/G7qvkbOFngdM7kg8dcEyRhwQ8Zr91/OleEDvPvqh3gwn3PbhRejkh2Ssz2m6TH9QIMg218wCkFlHbEU7OQ5IckoRs8zX3iYZtTcd/HVRMU+kRUIpUmjjCM78K8+9z/xB0+9i4/c+Cg2fGX/8797z3/F9932fbzhjp/k+4bv4iwSN/VUacuZ/Da+eOMZjjanvOj8RVK3Qg4ehEAUeyihMVbh22OKpMJxhrH3zHKNXSyoTo4JV67zeLLh6vIaLz77Isoy57Z8l0urgWpZM8iWqm44v7/g7t27eWL1JDIKrCzsTRIyJDLfTvImxf7W9+PwEp2piKdniGZ7jE1NXQ3QHNLG28mlOzWYPMcoRXAbEr8iNofoLEZ1kiBTRrMh1lO8HdgTMQTFbO8CvTmhOb1MMtPoJObYnpBvTknDAlVEwDan2Q4ek2k6GdG5lolzLKsTUmHI9Q5BC8RyIChQkxJja1bVMSdDIDSnRFJxkM3wvUXMYpSM6UWPPITN8RF1uWAkZT8vOXXrrYqwG5GkyHhN70bG06uk0xn90TF2ptmPY6LOoseBdqxAKvQkx6mI8WiF0pqgFLP5HJEpnjhcc7n1yIOeHIULkjhExMbQqoxyNqUdNzxzdI357A6mdkR2hnw6B+Vp7YC0Lao+QuQ7zz7XngutJEqK5xXYAKQpPnhM69BqJEkj2sERpZI8TwgmxvYaJTUeix0Gkjwnm2V0m5YgHXFSEkLA2hYpU5TaZmb7oSVTjsFlhDxGNiv6ukOOgmw23XrtAFrP6frLCAFCJmg9Q6l0m409tggtsaOlXq2Z7O6g8gXj0VXCNBBNdlHl83XfwveIXOPsgPQ5IlaM/SnGgpAaqQzaCoRKcL5D6WQbV5bcbDp8ucjuarwvMP3WgC2K1VZT/me/w2/j2wX2txKEkhDCVuR/892d6IT2Yx9h+P13oXcXZL/844jJDNL5ltp3E+1409Th5g2upcDc/wDRB96P+fSnSe64F9TX+XNbC1mOs1uannM1cSRJojWeHareok1gIkeeu3xCCNt4riSlWtdEsSKP8686vBCCMik5iQ6p+wpvM8pJQRBgxpFgRpKiYGwEUSLQStCvTpFDg5rneANJF2ijnvXJmsXZHbIixtUGJwJ6a42LawayIsOqQF3VCC1QkcIEiwJ0rMl9ht1UDCHQhYBveuIkJk5z2vUKOw7UlUUMnmw/59h2NO2AUoIoG0nt8+k+MosQStI/MzKcauYHBaUYqT/7KU6zGd3ZWzg/T1kQCO0SY0ea286SPPp5ZsfP0IWE2gRaIQjU2OOWoz4QqxzVj/TLBuM9+uAiWX4BTq+iU5D5gjBsSDKBqlqeGSvEYoed6QShEtpmg5rtki9uITiFbSwnqxPiNGN3/zyD65lGgqqLqF3PIpJEUUwIEabuCckpsZwihoqha4hcT6ELXD7jZNPihCHkE4YkoWlukPkVyuSUMmF7+zpC29HXDaExnDtzB2FH8NjJNegTzp69mxvOEJUa3SjaoUYhmWnBSgiszghDg3AtXbskyc+hdc7w5JPw//4nzJ58HO8h+cTDZP+3v/d1Kd4AIYoYfuL1bP7izzN99fegdEE+KVktO26sBqb7c0I3MNrAcjqn/tmfRf/Sr6Bch3j7bzN/+4eI3/J29Gr1Tazir3H+6ZTw/d/P+KpXsbl6FfndD1J9xyvZ3bmFtHfowxvYay3Mt1mh7WqJGjOSLCE9WmKdRT9wJ1HwjDhaDHOZg2mROOw4ks/mKClRssSGimz3PPVTV7B+TVwmFBvJehLR/6d/g+4//lvMPvhh5N//74k//Imve93i6Ah1dASfeggNlADvfR/z//5/ePZ7PX9mH85fQN5zL/OdA9g5IHvJ/WR33Ia9cCttX7NqHbqqsFnNZDrDS8Nh2xFOPF5XyDf9JrLQFL/wy8RtxlU3cEOPTGSMbddEMmFVLQl338UNM3Lx/Y8g3vgbnLzuhwiqYJ5BtF5DnhPlEXpWInONsSOnzYqh7thc6dCiYkwDctggfI8za1yYghU4HejqDcZahqQgtZaoXCBtR1rsE1UdzTveiZjPyX/iRzm+fIW2bmm7hGVTI4Piwu6EREmqYSAOIHfOw3ACzeMwOUeeTFlJSVyWTNyC0/URzfQi6UteQih/H/2xjxJ+9IfwweP7lmmeEOKMelWRK4F3DqUivJfbqL22RSqNjCVJF2iCZ7AeP2zwUpFGBb334AeiyBOrKX1zwlAtyaP8+TpsgDiHbrWNbLz5rhBA9OY/IrQjzeu/h2M1svv5HvvYw0Tnd5FyipTR8x1ynYX2FOsDg8xJ0pTTdoTgmeZf2eTKOGdq1lw1htY6yugriQVVY5AqEAWLp0NIh0l3mIvA3ednGBPotSRFsml7DqYTQBBlmmrd0JqOkC+gucG0WeLzORmeDkOmJcTx9l3bnVDEU3b3zjN2PbWMcZHCrjuILYtyRjg+ZKhbxjMKN2gQgrjcbp4344Zc50QqAiLM2CGYoxRUh1fJvUfMCkyygx+hOz5hNCmtKpgkgWmakOg9hutP0FvJSuWoccWq3hqApnrEFwLjFNYYjF2BVYSQ4oIEVTBoS+E74sxyPPSs+pq9siB4icwzhuuXSGRJSLe08oeOH+f8/BZefetrwOfUrofxFKVLLkwmdL1gXJ/SPn1EouFHzr+EN934LG+5+mn+k1teTjJJCS4iVGtsZ+knC5IgqK0nloLRBxrrKLTCZ4pHq0eIlOJsciuZWbAeDnnbpTfx5kf+kPde+ygufG2ju0DgPU+/h/c8/R4iGfG9F3+QH3vwJ/i+yWt52blbee/TGy6dPslrb7uP0+PHYHInZAucgWXfkagUO8kxZkmhHePocJFkriWX04Ibl67zzvY9xFHMT77oxxFa0LqWZfcEb3vibTyy/iyJDNwyu5MujDx28hR/8OjvcW76Yg7O3Q5WEnqLuFlk5wp8aHE6wc7n9KKmOnyaZnVKJhvG4yWtnGLbAbk+pdyfMysEsyRlWa+x48g5vU/QM/LkPDrK8N6xI1LWp1/EmpGzZ+/h6pUv0Z1coZicxSYDV+rPct7eSex2kGLEG8WgAq0TzIRgL4nQY8c4rmmjjELv4P0at1ri5znV8gYuCJ7eXCaQca7YZXe6hx16dBGjfcTSVlw77mmFwF0/wcinuXD+HnbLlLprMbHFVxY7QuYGGhlQfkrw0AjBJIpIRs9YnZANG1SRsVEZO1FOEBv0/j7OB8bDG7j9CbEaOFPCdWO4elhxV6Gpx4hRtEwmE4qdfRrbMISC0C9Z7NyKijJM1VBcLNHpDtXpCf0wIvqRRCzBTyD56qisREs644CvNAudc1hAjxa9VzJ0R/QuZjqf4IYOXUzYjOBJEHj8zSzsrMwZ2xV9a4iiCyhl8b7FugqQDE1F5HtIt9ICJ1vKVCKPRno7EO8ERAh4v02I8W7Ae0OWnP/KlNh68AaRxtT9QOs8YbWmdAIxWHwSkMWfaSaEAHbARQEhFaKOMLJhqDpkvINQYEJFHDzSxzg54IVGunGbuCHlV4ps1gzritElFGcmAHTGUfWW0Xmm6ddpuv6vEN8usL+VoL4c9eC39G+Azz2CfPPbsZOCyS//JGKxB+nsWSMDAOO2G6tZFjFaj/OBLFZUZ88TLXZxjzwO/RqKr54uB+cIPiAjjTOeznREMpAkc7p2TSRXZMk+m05xvO7Ymbhni3hnzHbhBkVvOop5jpJfu4OVJilJlNKs1kRRTHxm6+46ti1FWaBVwmA7JpMMbxrC6hAT7+KEJC0zZF3j+55Ow4HcAXg2EztIjW0GwuiI9yYEb9k0G3bO7LGqKowxHMTbnNvQ96RaE02nuHFrSCOjQCxyVBzTNy3t0lPkETaS3OhqpoNHM7CSBTuRJv0zRgxtu6ITkO1NKCY57fs+wNAZ2vvvoYwluekYl4eYpoJsl/b+l5N+/gmGj36G9BWvpXWOjRfMziyo11eQ1YZZnGxplBf3YFFirMX7kb45ZP3Up0j27sQGhdAT+s4jJ7eS7SYMcYYcPM61ZNkMWoExA9XY0OURt04nzMsFy35J7WuKNOfUaGrfk8xzojRlbGs8Fc6v8MmcoBJEM5LNpmQHc46rNXUfiCPNHI+YzjnuTij7U7TNue4z5vEpY5MgTIQWiniSsWRJkc0IjaLqa9S1U8rjE7JnLtFcu8bcAGPPblXRHx4Tjm6QVqewXCGWK+R6Tekcf36a5M11cbDL5ld+nPGXf5Dq3B3sin3U0KDmB5BlNMcrkiQh9xEqwHxV05vANFaMdYPKPe71P8rxD76B6//5f4H62Ie48MEPsnjPh0iufmPDNHfhHO0Pv47kZ38J9apXEYB0mrP5b/7P2I8+RPEd34Eblyg9pzi7C61F9IKog7U7JhcTrIpIvvQM9swFTs7M2F8fYooMERRSQZSU9PUKqUviPMMtV0ihCNoiEsgmU6pqSVWvmXVrynxGn2XIMHL8gz9MeP0rmH/8YdSv/XOyt74V8W/pDC2MQV++Cpevwkc/Rg48t70WdneZvOxlTO59AZdvu4sbL7+PMy96OTZt8P2SyZCS/N5bEJsN8c+8gfzuBzm8dI3e5zhZM4rAjX7FNE4R9ZJORJzecTuRn5L/8XuZvO2thJ/9y/gipW6uYM1TDNPbSW927p1y1EkLMQzVhny+wDmBrhqiKCPzFtIY6VNUGtHUASLFsVCUWlHMFtTLR6iHxxC/+25ks8H/0i9SjS1BDVSdoDlaU1rFucWEONlquUPfo6MIofxXntPNEVmUU0lFLyTT2Rn09WNWy+tM5hfhlX8B+Sfvxnz6M9i77sAZw3wxx8mI+sYKP5sTjS1BWIx1EAUQina9IZtMkYD20BuHH9bEyQQlFb21KF9hkJTZHpkYuV7VHFcVs8X8+VNYnW4ZUWMN2RyA/v1/gn/0MeSLX0J1/x1cOn6EyHZMrl6nrU6J460DrxDqZiSVQHRrAjGdyNA6QkQRm25DGUVkyXM2Xzoj1TWxMWz6njLaruyusxjnySJHcJ7QLxFRQdNLsjwi14rh9IieiCSKaJqBwTlMiGhtT6cltrYUGSx2z8DJDZZdzXEH1m2dnBEGOYptMyNJyaIcP1xnYQKds6ynEtdbyuOGzA6M0xlVt0F2kmy6RxRFNEPDalVjM8/udEFwATc6IhXou2Pq2iL39qiCJfSeXGbEfYUuS2QRsaNjcBWBjizylMWMw17QVT3paNjfP2BMY8YgqOpA21QIUcGYYqwnyxVdKoibkjIRRJHmqB7p1A5xtkvoe+ruCN94VDwloHjv8lM46fmpu34Y3zmeNBVDNHAQLPt6l9xmGHPKxhsiuUEmEXfN7+MlEj5z/WE+8swn+L7ZDyOcwzuHSCS6SKkbQ1JELPKY2nkq58EaqnbFU8NVzhc7vPX62/g/fOQdfPTo6xfVXw/GG975zNt45zNvYxJP+OHb34DpRrR7hGb5nQzK0mjDTDg2zuOBIrY4F+iz88zDiGlPWQ85OpNMkpzPySVPnDzJ+TMX+eef/ee856n38JFLH2Y1rL/udfzuo//m2X9P4yn72R77xR776Q4LnzKPdpikB8yW50gtTFzBItnl3M55FmkgyVMWty6ImwrXWbycs7M74VA2yOEUESRjKIjzGYM3lGmJlClFf0q1eob8zB75tETUJQP77E8LjvVTHDWX2Tk5ppea0yYmmpccxDETJxBxTHv9Momo8eEix/VAvDlEjTVxdp7Ob+hUikhyzmU7HMzOMTYNSm+ZGKthycZYiiBhvkN/6nn8yS8RUOTn7kBZzcb1ZEOgqWukq/Dzs0zLKceXjtCLOQsD4/KI9el10ukui90LHPUjq+WKWRyhFwu0HTHLY/ra4l1LnkQQauaNoF5W9PkCm06RiwVJBdW1FbqcMi1quvUhMj3LNFUI0xNnGel0RhhGBqMIGhI2iOAgmT5v/5xoRTs6RuuJb5p3dXWN15I8nhCwtN1InFiSWND0GqcULvI0TUzkVuTJDDMM6GQbUYdJ8EZuhw1xDqGjXd9ADgPxpGTjNa2rKOOU3ljyBFpvqVenFAtNCI4oKgnh4s24QQ83x1vBeMDidUqzajFdi1kOxPOSeHqARWLMmjje+cqNa3u8N3it0PEEXzu64xVBx5TzEuctbb3BxwZlE4gVTvjtnM/22+YrX5lkh8ZC20AfEzJNbzxSCLrRoYSgSP7nlZZ/ruzo3zN8u8D+FoKQAuRW1wNgv/AIw2+9EZ2l2F/4YTg4v3UL/zNoB4cUgkRLTpsRYz0H04RaCux99xN99MP4K5eQdxRfRZN5lvYtFX1vGF3DLFdkWYF3ir5dkdk1O9OCVb/NPMzzhEmisWZEKsUwGLx0FNlXKCn1WOOCY5ZstSdKKcqs5PK1E+bRPh5Bs14jBGTlhG4zEqQg0+DXVwlB0ubnEK4hlR6fTtDrY9zUMnRrdL7/rGOulx67GQgCdBYzVmabvakEfT3gg2fAkgoPdiAqcoKO8C5QlAqEp2kapBBsTlrcqMkPUq52DQjP2TRF+MDat6y7BJ1FROl26XRdzWazIlJzFmd3Mf2a4aFPMGYT4vvvRG1WdL0gpAYZPNYa9AMvRKbvJHriEvYHY2Qbo4aeNLKYKGHCOfI4QuQpal4icKRh3NKZiwXN8pj6+hXiM/di68BpI1BlzkQKrp9cJekcqZZ4GTGokQFDow3JdJfyoU/Trz9B8cADnJ7bIbiWSZlyUlec31mQpBm0K4a6weaaPpG4Zo3GkZ05RxwL9gqFWgUWKsK0FUkcIWdzsjZirI/pxkOU1UzCgkj0JJOCpd/QP/Ukd773EfQfvIP0Ix9CDl/JbZz/mXu64H8+uu/5XtY//1M03/kg2blznJ48Qnf6DLNphMgWyFix6nrsYDl7MCdKEqyJiQrFsN6g4pIwrOmGkTFI1qtn0C5FvOTVuO/9fvr/9hzN5z6L+sPfJ3vbW4kfewIA97KXoX7mZ+D1P4C/+yLrsSMePYv6GJUl+K5F3nMe++HPUWw8w/4cy5TpgcJUI6quUF7gdIOvrrJ5ZoM2Fvma78LqmL65gWNGFO8itEAkJf21L5FeWGBai6lGdCyR0wQzLElm+5TSsjq5QdtWTA9eiEskpt9QD5Y4naBf82pO73mQo//Tf8bin/5ryje9Bfm/QP42gDg5QbzznZTvfCf3A/cD/cWLtC95Ef0995AcXIAvPo55wR2EV3wnN4zDZinJMDCNEoY4YnCCoT/hfJwT5zsc1xFfuifhXvU97H7g0/BHb8b81C9SHNxGbQ5RdUucTYmLDDT0ScVUG9Rkl6y8iCgsfuyJ5A5UAXqHVwrRBbCWoAW+HxmEIAwdjUvIH/4C4rHPI17yMuS5KZvjx6m9Zj3CmaYiDyWtG3ENtG1L2GwgU0R+s42+i3eI+xP0WJHFc1ZCQJQzne6y3hyxVHOmr3k1fOQDtO9+D/KWC+goJkpTknabrb7uYCo0ygwgYtp1Rz6dMLQjY7ci1hmudyw3HanrmS3O0DUjjTGoYYnRU2RnyZVmVjhOzMiyqpmXxVfcwIWAKNs6inuPv3qN4e1/hJ3POf3uVzKElmz3HG2ZUN44ApchxQyp2Ma72A7bbrO6O5Hhw0CSzlj3HjP07O7Mnn+D6BipImYejkbD6BwaQd2NaB1QzhDsgMDgonN0ref8NMe3LUoIor4DHdFWHU9tOqZZhAot81SimNJUNXpnFxOn5Ksl19sKS0c6KZC9RKZ7iOwAhyOJCuokQm56Ii1JY4H3MSftwCyLSTPNcnWIGDMWt8zwwbOstnKUpu0oVIlzI30/4uQJxxU4NSVPoNAzYgVJUKhRsYkNkUyIVUbTVzT1VZadIcwjpoWknJcM1w5ZHa+IZhk7symbesnx6SG7E8/Qx4hMM2Zq69vSbtiEFUnnKEPEab5gWW8w9RpbnTDZv4C0sKpO+cThJzm/e4E7yxdyfHSNbgJnZiW7mSBFMLYbvFohCsEkmxOIGYPm+/dfzjOby7ztqXdx59kXcotKUbMpnbEEPyCihGT0+DhQakk3jHz26uP8xsO/zpuf/D2utVfwfH2W0ZeR6pRXnns1n77xENX4teU+1VjxO4/+awAKldPFDb947xu4K08wsmSelky1pBuOWfuYIxcTPBT2lGV9g09deoKPH/0pb/zi7/B09TTuiX/LyLmb2IwbNuOGL62f+KY/k6qEMi6ZJFNKmTHRE8pijpYFhYuYhUCeFsx3LzIr5pwpzjBjwisvvJRULmlOPkeq9wnxLj6J6G3ETnobJ+oI2zRQO0S7oZhKimhF3wgiaxi7Q3wCE5mwcSODyin3JXai8FaDlcyiHSaxZmy3iTE+klSbFVJq0sFBKtAq4tz+C1h+4VM07SHLPkMmU0bjSQmE1RFrrUinU06WDZ2FgyAxjaNfX8WqHGdj7KojNw0bBPl0ihYC3ICez2h6T9TDZv00g2+5Jb7ApsiRyYLDZoCTikgKMqmIooTE79CsDoknB4i0wLctOstQSuHTlCiJsVLhzUgaKqR3z2OAxloihWCwjlhLzNDTNzVZMUFHMSfXH8HpKTupxPYblJwxCMgThY1TTteBzFkiKRj7FVGSIEOMVB7fw+DcllFVPUVZ7GGSktVyxSQrmMmSpTcMhSMeeqq1I0r2yKd7N5lBmrZ96qaOe75d78YjlGczOPrN5mbaRUStE/aVhDHgTYN1Hq1yCB7aE5xZAzlqjOjaG7h1RzHfRQ+HqACdF9hgUCFG+gQvW4JUiOcU2ADeBkJekkYCt9nggFYKlJRkkaIens+m/WYxWs+6+0qCxn8I+HaB/S0E4wOD2E6w7WOPM/zL30SoQParP896fwcTpfxZ31brPL11TFKN84G6GvEuMOQRaaTo770f/bGPYh55guT8+a1b7HM6RMFYhBR4BO1oQPSkcYz3G5R2eKcZR4tIa6YJGMWz3T49DKRJSrNpUIkkvVm8hxDo7Fdn8uVxSXAOpwzNpmHsO6a7uwgE/eiIY4kaloxdjUt38XGMsJ662iDjCcW8oDGGtlqRliUq2T5ER2PAWFSuCYA1lizPaLsO5x1Roui7EdH0RNMEqQtCbzHGMTvIUVpuc543HetVTzlJaTzUtuXMJCY2GicCE9HSiMBpPbAXK7yznJ7eQMmIMt+hZ2R47GHCukI++BLigxR3fEyvZojzU2SZ44Mkt5burvuYPPko3XrNSQuZDKyrkel0TjJkhNigwylieQTJDJHNyOYHJDvniLKS5WOPI9qKoBb4pGR3klEC6+UhvatI5hdp3IgZW4QSVK5Bt47hre8CIZGf+BQxgu6286QvfAA336WZTSmbY5JY4idnMd5R1yeI9XVkWhJPDqA92TZplAMEZhxwYiDOpmRZwjo+JenXRG6P4+sVtx0/injv+5i954/Jv/jkv7O14ycTxr/4c8j/7L+kPTiLPbpCQNAaS9trcmaszZoxMRRNSm1yChTZtEApgduMqCQBHTg6epzBr1DJjHyywxl1jvnOWZrlSAgVSi8Rr7qf4SW3cPVv/xXsqSeOM3bPzdiZl8jmBpHtmErByeaYNJ4zOXcLg6tRL30x6lOXsZ99HHnvnWzajjPlnHShUPMEU29QJwoTevjUB0mTBPPyVyHMhrWsSI9XrJWk2Nmjq3pMY8hMwLQ9Qz9irSSd5vT9MUl+lnSxIDu6xBA8g4GJmnBVXEKEllSdpzVrnDihmk+Z/Xd/j+7/+mvI+oT+0U8yPvUZysOefFnB5au4x7+EuHwVeXiI8P7P/6N8DaSXL5Nevgy8Ddhq0oc772D4xBeYv+o7aB94gPHceS6cv5NBaTZDSb9q8HnJni5YCM0Vu0Td8yD54l78O/8Q/Ye/h/iZXyQ6fw7fj0TVmtCPSK1ITYsSEaFY0HcjkVPYyOIZEVGOr1c4meA2hqEaGScQupZ1meP9ChpQ73uY/OAiyc/8CIOKWLcRscq4WFh27EieGjwD2gZ0XxOHjiSbQzYjRDl26Oi9phxbcpWxlorWWsrFOar6EZrTE2YXL8ALHiD86UcJNw6JbrmIlgrTD2RZwYhEJBnZ4EEldKMnySXpZE672SCVp1Sak1VDpBVxXNBZj+k22NHhZE6CZYgidrKeWipOrCNqGvI8R990w342sqte0v3mbzFax+mPvA4rHbNMs0gusr54AfPYZXy9op9MmMwX4COwHSHeo5cJYejJMk3AcFitkHaDlnJrUCk0SuVbWrlOmPiWYx+x7nrSoLE+UIgRa0Z06CFK6GyCSgxlHOE2FaOOGMVI1feMzjF0hr3pDOdP8GODCBPUuGY8rhBSIIUiairkRFDnUxblATI7SwgeZ07QIqBVhmOg6k7IQ8m8OGDY0SyvX6JLAl3VoGREWhSs6g3OenamM47bNTeWa7rjG6jQYIopOj1gdwaLPBBFc7wbMVWFTFJG06N0ynHXUtWG65euMfawKFYsdnfo44xyVrA52dDOJkiVEkWe0+UJE7GDExqZKtb1hrA+Yb2+zmPdo3gTeNHBRUy9w2VrKU1FGk3RO3OUCbzr8XfQ9h2vvfs1jNGIK+GMzrlYnmHwFQMtrTkkKTRzO0X7KUELTFNTGPj+W76Xt3zx93jrp9/Er7zg59g5f47u5BTTNOyeKciM4KmjZ3jzY2/i33zhjXzkxkcI30xRrRK+9+J38ZN3/zg/dPfPkOZnaOqa93z+d3nLpd/nnZffxei/dhJE41p+45E38huPvJHbZ7fy+jt+hL/5wl/lwdltJDG0dcXbn/gTPnb9T3n4xkf5wvHnv6lr+neF3g303cBxd/Jv9TklFD96x+v42Yuv4PUXfoxochci0Qzeo6OcrlEcKsNt+ZQzQ8CtNEw9vlrSuR49i0jyiyR+QjLWXCPiBj27tmWRnOWZ9ohFNiHYNcYHQp4z9g2pSlFoet+Qljn14QY/09x15jY2wyFuGJBRh4ktTX0NFRnqZMI0DlSbjnx3juwdo+2pqpb0losYJzh94gqznZJ0b4eN9cQqoGzPOA6YypJOd1i1TzD3njSP6LKY/ckZjjeWJy4vufUg49ZFztPtQKkXpNkS6VZssrPMuw7fNOgkoZcSGbZsrr6u6AykoUV5B/nu84rs3ngyZeiqCqE1WVni/EDbd0x3z2wtKpoNIdnDCUGpFMWkpNpEHA89kRJEbU05P8voLCGMpHnG+mRFqGtipbCJYt1VREIzTUroHWksWLuWCY6MBX2lyEoJkpuGdBnjuETrKcEG8AYvoWkHwukRqoyIYgib67SJIPMSdIpjhYxmSBHh+yVeObTMGdqO0RqS+R46mxB0ArZGy4AxHWk6QZgYku6mBHPcMlVv1g3jYFFaksx3cGrF+nhJHSVMJzmj2DqBrzuDEFt2wDeLqjVb4+H/QIpr+HaB/S2F1jpW1rH31NPYN/4rBIbsV38Zefv9KFM96yb+XDSj206BI8W6HgkuoKWgqkd2ZindLbfg8gL56FPwfd+53Tw9V4fiLNzMv26GmiQOaL117k4SQ6NO6FpFnGZ4KhJS0iLntO5ZNiO5VwxuIJsmRHJL/+td/+xLzHqLljf1fBbSOKP3DawEcZGQZjm+d4zOMY37re6EBBNNbhpQ5GxOT9ldeNTuHFv1DJtTxuKIdO8WtNZ06xqpA1repGjawGQ65XizJuDQaXQzEiOQXtgDK/AbS0Cg1FZbkqiYwRuIIuq+oVl60h2YypihN4isRAwbpqVjM0iOqw7fbUAYinRBA+hhg/jYZ5BSMb7kImPfUpY7hLyg845Cz1gNoI9PaM+do3v4M8gPP0x4wV242YgikLQdUgSsyogXt21dff1NlkGUIYVAT/aR5WXsyVVMvCCJI3biGNM07Jcz2lTi44SEhDKeMDAgW8vsY5/CORDf80pcUuIffYbkS09ivvgF5n2Pv/cu6pe+lOLlf4F0saBfntKfrIi7E/T+eYIzNGNFHWWsRIOprmLGniAlE73Dcn0D0xnu+MwTZG/7/1B84MNEq+W/k7Xiowi3WGBvu4PhZ38a/at/Cb2bYEZH1A0Qw2xxCyerxyiUZPfgLpyUbKqneGLzCKnb5ZbygOAMwzDSNjXN2FHpnoGGs/GMvDyHjiJknhDkiigONP2I1hE6n9AFwWRnSrnjqOuaw6MjIrautRQHTJIpm83AGsi1ZKjW6N3ziPvuZ3z4C4jXfz9D2K7XSEusEWxEjFkNDHXP5InL2Be+jHVaIJoTTKrZlYpmrHFyF5UGsvmCModh7LE6MAwD6TgF53GyJo4yEuGwxZRh6AlrgVAZET2RqKgHi9M5oR/IVIR1Ej/dp/zu17N85X0cbdacndxKWC3ZfOlR4r1d5Ac/hvv4p+m/40XEiSY7XJI+dQX/xDOI69eQzzyN3Hx9muVzIUIg/dITpF96An7rN1kAIUngxS8m/v7vw/zyT+POn+WwG5n2Fbdri/GKG9WKvXvvIV/8GLzxTbh/8U/wP/0DiFt2SBPJWC/pT2tcW9Mf3I7QELDQa/wYEHlPlEzQriGKA1ZohI+wKqCc5cSM7B49xfyhR7D9QPuLfwmTZJy0x4w+4cJ8n3I3Z/3YNebnp4RE0m4q5PEzZGVEFO3cZPSNuCSiaSOMtUSmJtMz2m5kluWIbII73cCwg33ZS+GjH8d/+CNE9/xlfNfhHJAnTBNJZz2FFIBDiwgz9hTzBfmkZGgbVASShriYkZYxg7HEYYPMS6TIiHuHNRpnHTuxpxUprbfQtmRZtjUskxJUQv/G36E7PGT1Pd9FmCcsshQTGxbpgvb2e3CPPYU/vMq6KCnKAtmvAIGLp5h+IM/nJEmydRB3sJtLomQCOJxr8X4kihYInSHHlmkkWNUduYhJYvBDjxSS4Adan3LsPKOSbOqWMBiGkBLrmB2/RDGiqhPGrEe7Fd5tECInm+8w1h1BJth5Sjg9ZVcZBiVoRUQqthnBUsbYoSYh5Uh1mMNTslv3CMWUMh7xZcH1asVJY3F6JL56xHJoSNMc00NnLcWwJLYDSXGATxSTokCrCucgjmPM4Gmc51B5TtdritETJQXDuifLziFcxXD1GjeOjtB5Ri41sW0opwWjlIjIszxpmJAip5pu2XB58zD/+gv/kt954g9on9PQjmTEfnbArfEudy1u5e5Ld1LEu7z30p9y7/wu7ioPiErNbn6Boh/RDpAFTbtByphico64bhi9RE3mdM4gmp770ou8TyS865k/4lpYkjwR8+jp0xwun+RkOOJKfZUbzY1vat3nOuMHbn89P7x4Dd97+/chox0WrsELSV0fsddJ/toLf5a/9QN/k9N2yW995rf5zYf/BR+8+uGvWyA/tX6Gf/SpX+cfferXecnOA5wOay41V7+p6/mzOJuf5eVnv5MQ4LQ/4qQ/4qg9YjMs//9SoLvgeMsT7+AtT7yD/eR/5Bfv+2V+8UV/lYPiIjdsxDzOoVlSiZqd8xeov3id0RiSizt0YiDKFHFYMHZLGj2QCEcozuCFZNNZhNQk9Iyjw0Q1EQlTUSB0RFudEOUJk/keV24cE3cVF88e8MyVGhMCsx7mwdANhtNYYrzj+HTJLCuZThPK0dGeHBGnBfNpiu0NlQ2sraRsLJvesZQ15eoathdE2YLVNEaKPS5Uhk1XIVxCWkQcpIqaAdtaIiVgsJgkpsgWuOGIYHepkpRp16PTlKAUdhiIpCSfzuibmm7oiExDIsS2yBaCNJK03UAz9AgpibMcpRQnqxNUVlAIjdMQnMS5HohJpECkCftpyvE4cmoCJY6JSIizmL7akKYQbLONVrz9Aiu/xg6OuTzL0Gyo7THT6YyCswzthplWbGpHvWyZ7pYIKYjjHfr+GtY2SJOCcDTWYY7WSAbEZEKIZ0QI6mCJtUClFwhRjRWCKGQ4u0bkOzixQ7e6QlQekE/3tqarTU/oGqJUYazGSYtE3tRi9yjrEXaAKMUZj7eBtNhGYaqdOWM1YK6vSZXGIbCRACFYt4ZFsc0a/7MILoD3BLdNThoGy9AZ5llE+A8oC/vbBfa3ECIbcFeu0v3+m4kYSf/qryDvfBCUJg0pne2ep1FwPjAYR3EzZmZTj+SpIrpZbO/OII404z33oT/zScKqQSxu0gBvaqWDtVuNTmdxoSOLFVJo8BlxPGEy1SxPDrexLKLHd9fIJwWzKOBjxaoaGZxlFk+eva7OdkQywnjzbIHtvcf2I7PZgqPqKjpNKeMpAkHXGrAVqdQ4sY0hMlFO5Ax9PWKkBjkidUFcFrTWY05OUUWJEluTBaMskUgYmp5YaaTW+BAYhpp4OaKdQaZ7jEMgigR40FpgrUdrie8tg3GkswnjAMOwJA1zqEec0AgVI9GIsWYS7fDUyRLByPm9gnWXEKmW6OSE8UuXCOcWrLRhNttjMTvH6ZUvktQ987iktYFBtdSLmLrviD//OWaveABjWxKmmKggzGZEMsXpCJVMwHRbDX1zDMmEYBVMF4juiPraMQdnEoIzeO1Jiwg7llR9QzYtSNKEuqtJgkb/6ccI5Rxe9EpkKrEv/QvE0lJ/9D3IL3yB7NIN2uvvI/zxn6BuuRV/+3niyOB2Moz2HFdPQxCUyQyyBcLD2hv0M5fIf+u3Sd/6bu742Cf/3Nzp5yIIgZvPCIs5Ic/pywW2nCLLFHl8AmnK5kUvoXnpy4h2E+zBeSb5gmgxZXX9BsLDzi1nKQ7O4FxHt7kMowEiRmtxmzUXz9xHuj+FINHR3dhrjzA0V7kSRxxdqZkUCXEqESJmkUjM5A7mg2dz+DRyUjA/c56AJ8oVg5lgQ6BZnzCMlv0kJ8tSysmcUS65tqmI90uybA5uK5E4MmuOV8+Qjo40n8KrXoV58o0MDz1MeOn9OD9g2+16HOqWEEnSL10ilinhVS+EvGMatjEmIkvY94GmOqbQMcViQb9aYogpZlPqZUN70qKmGTZsiEeHzidEIkdmCavNKRSCQgZGc4M0uYVjZxCixwwtUk0QEqIkZibP0w41p+tD9I2aMNknue1umO/jH30MdXgN9Xf+EzrpaYxHLyXJwXlW/THi2pcQH3kIPvRB5p//EukXH0f0/Td1T4hhgI99DD72MRZ/9/9B9IYfpfvLP4u5+wJ7qeZWnXFVn3JkTrnjgftJfvkXGH7zd/BvejftL72e/IX3EKeW2lwiCM9konGsCMUOWRoThhyve5JigdAlmG7rBtzC0Wc/g/3iF9g/usHMb/Nix1e8gisXbsW0a/LOshMJiiwmIUHoiF5FTOdT2vUp1iewfw/kObgRbI/yDu0HBqPQsaP0PRsEoxOoYoeovc5wegT7e6S3XITPfBY1GmzbYkVMnChUomjtiNEx0Tig4oJxaHHWEKUpzlrWmxMSNyB8jveBdmyRfsBHZ4mdJ0oGvFWYEeK4w6s5RCnGjtBtTXWSJGH47KM0n/os7d334u+/dZs4kCeEABM7Utx2B95DenjE+twB9ZFlOpnj0zl9P6CUIkm2ZpDLfiuNWRQlcbyVN3k/YswS52q0nhCEJAuOJzpLKx1z7xlHS5JFiHGkEzNaESilpLAjHk9pNmjhCXKgHTqM0lQuYZEv8CYiMKEsZ7hwQl911F1FSCPKdEuB72xgNRgiBKNRjKsl3SC53G2QRNB5VDwiN2tEHNGPI72NaZOIjz39Jc6cPcdeOSHCE3xHJDvSvQuMo6Rul+Q7grrvgZxIGEzvtvFutqWIIi5mGkbDVWu4ePEcp/UMFWnc0RVU29I0Lc5YdLUkLlsis6JZVXxu9Dy5+jhvfupf8oHLf/I114/xhqvNFa42V/jI8jPwHAbzHx7Brz/5T7h1cpFbZ7dx5/RW7pjdzT2Le5iKGaNcc/X6h7m6/BKXuhOeaW9wdfM01zZXOR5Onz3O7139w2/6Gf9lFDrnDfe8gR86/9289MLryUOOqq6xYZdcFeTOcHhi6fpL+GKKnr4APOzkO/yn3/W3+Wsv+kt85JGP8DtP/z7vuPx2Hl1/6eue69OnX/imr0sguH9xPy/ffyWv3H8lL5y9hN2zd5BPYi4UO7RNS+Vbchx/9wP/iP3pDn9h7zupqifZmDXH1QmHq+ucxg3H5gaHzRGH7YrD/oRV/798g/loWPIPPvMP+Qef+Ye85Mwr+al7fp7/+GU/RRaf5crhkxx5Qb6YYIRFNUvi6QIxzthURwy6JU1mTEWGXBzw9PoKzbhmPy3o2uvYOCWOBDMKCJJxbLdDimIHLWFUOTI4ymnEfDmndg1EDWa5IbBDMTdUq566WpJFKf2wZFqW9NccSTIjUo64VCTlOWpn6foa2VhO2hWdb1ncdhdDMmE9XmIWZ8z2dlk3a+IWhqMTjMg5t19yelSxHAempcJoT5ocUA9PosZTxuwMXd+R1zVaa8x6Tdw0SK2JEHSrms3pivmZgXxfQr6DFoGxrdFJRJnlOOcYhoG+r1jsX0B0Fj+MiGiOsS0xJYKtrDMrcvJ2TSDQioJN27OYlEitaVenRL6CPOd0kJDEpCYwuCP6eANJAnrCXOecOGi7JUU5p2lbuiYmK+ObMbURZlwR2318GKnXNVRLbDSQJZbBGfJ8ge07akZmxqLzBcacYrprBAFClHT1GqkgT2agJDKWmMMNOIvAEKIIYwcSVYCNIR7wwqHsNr5x7C1SC9TN3GsfoM1zsmQkrmviSUptYVCBMQRWrWGRRijCs8X0VgJ7s0klBEIJ6hBIyoi0iP+DKa7h2wX2txT0yRGT3/4tDI7yr/xF1H0v+QqFRcU0pmH0I4nabl6a0YKAPFbUzYizgelOglKSVTVSN4Ys06wfeAD3qYcYv/g0yatfCEMF2fxmpIuDVNH2A0qOJHHG2Eu8dAglyYoJXe2xZmvwMFSXaZqnCKZkkpaM3UCrA1UXyLVDKY/1lmk8xY7bAhtg7AbwUGQpN5YWqzwEiR8dfbMkij2q2MEsb2BUBDrGd9tprohiNnXNfJ4SCdA7O9jDnuHGFZL57QglcMHjBTA44iLFuYCMJKG12NXAKDzlToLtHc4HpJZILXGjR1mPM46NcYhIskhSThvFRGdsbiyxSUyiFJksMMOatlNMJJgs4XI1UkrPVHZUn3gYVa9Zv/JO4izlzM6U3hwhcpj1c+xpRdqvSKMBJpL1LedIL98gVrBb3EWwnkFZRNsTvEf4jGwag04ReUToTgnNEfXhkthYmjRGXD9GzTSD2dnqz81IpufoxDEw4HpL29SIhx5HVBXie34IJ2eYrqIsN+hY0b3whSxf+CBOZmTLjuHRx8gefQz/+U9R9DXVwYL2wXspHryV3fteg1Qp9jOPEv/R21m8+/3EX3jkm77H/WIBP/qjtG/4cVbf9WqeVIIiyUj8mtnTT3J8khN/+lPsX/oi8ctfSfYXf5nk4kXqa1c53Jxy23yfvTTBqBgT56g8Qiu1neDpaEv5HFfgz9CcXiYtCqZn7iAoST0sGbKUi/GCMJ7SJx2rEHB6xmKSYeSKoV/j8immSFEiRnaKJNnHhw4raiJpuLbckPtj9vduJytnEJdoIbjlfMzTjx5z5SRwYWKIjSFNMrJoYHl6hfOT80RZCS8+T/QHb6X9xCeJX/Eiqq6hFFOSVBBsh54nTK5eRS/22Jy7Bet7sgRk7RnzQFlMqI+PGJ3dTuqGgTSOiKclzin664dQJohxhR0dYrpH5KAfWnwEcmiJkYQkwcsRqTKsntLWh5RnZ8ibjbIkKplGOxx+6VPotWTvxS8nme7QyATxqteiPvZhzBeusvuKBzkar7NcP01pnmIILRSa7jV3Mn/tC7D5Pm0/Ej/5FOZDDyHe/BbU8THRcvXnUs2F90z+4K3c9wdvpfmOl2D+xl9h/mO/QB2n1F5xXWWcfelfIEmmhH/6L9C//YfU+Q7q/G1cTXfZmJRQ7uPXh4j6lI0zpMkU01TEoiLa1PhP/inms49irp/AakUWKaL772B84H6KB1/BkM8QzQohDUHtMZ1a7LCEoEhnOW2zYZINSD+g52cZ9QypI9RNppDvGuJkpF1dxyQJqeiIRMqmH5AyR+Rg1i1ZWjC+/CUkb7nK8N7341/6ckSZomOFGBzKBUYZETEgJQgvMP2AKqNtCsP6EpELeK+pjcW4FUooBCkRBh05fCSxY4ofaiLtSKRi0DGRtAzDwHj9Bv3v/yF+MoXveTFR8BSzAxpxTB4iBDC7cIFVmiIuPUPxsgc5Xh+R7FzAjdts7Dzf6vVG66mNo9DieXFeR/2G0Vq0WCO1RISIsa5ofMJoG3LrmcwXFGJkEIokzzH9yDnXkQ09o56gswJHTFLOSPorDCqh8RETEeH8NnJGKYXSETJyrG9cIo4E0XyK8j2hbbjcx2il8a3Dr2sG6RgmOZNkAX1Hmghi58kmCVkTk9ozCCW5Wh9ykJxnph0TU3NNaZ4aU87HMaMOdFpxWi8RYvv9qrpDecckK1Gu5iDJyZqaK8cDejZnMSsZzYiXEWpnl0jK/y97/xltXXafdaK/Oddcee149glvfiuqgqpUkkqSpVJ2kK2Ag8CW3Sabi2nMvTQeNHBpmm6aO2guBhoa220GFwwY7JazZUtCtmQrWFmqUuX45nDCznvlNcP9cAqDkWRsw7jD1+1njPPpnLH32mfONfd65vz/fw96vSINAsyNFzhKQ26uGj5Sf5j3XvgFDprrv+319iup1BVPL57j6cVz/0Wv89uRL33ecvrr+bY7vo1vP/cWsmxAW+U8MjfMl9eZBB6+lOz6Fk+3oFeMox5VYCmrNYl+kTnT5JTNmjtP3sOfDk7zHSe+nam6wXtf+Dl+8eL72ejNb/ualFRsRzu87dRbecu5r+UN4wfpR1tcWx3SSkVva5utrT7YDdqUGM/H0wFZ0HI2O8GF6WXuOD0iGJ1iK4jRqwJnJAwdUuZYMUR7MXmc4ZzFmpJFveKoXlO1OVW7pp5dY2kKculwumBVLpnOb3KznNM5S9uuyE1ObiquVjcpzZe33AF86eDzfOng8/y9T//PfOvZb+Ld59+JlyQ0acUkzI7bY9aao+pZdG0YnjlDakM8r8NaQ0LI1K2Z5msGvqEXJyQywNUVWkdgNuQKGj3n4v4CKzK8MMU1Of3xiPLKAS6I8OIxRwdHxJFPPwgxTYrUPlYsOCg21HFE5ikwFjkZIzYNaVVTuZZwGNJJwaYeEDc+s/WSRi44N+rTeQlCLwjDE5hFhy2XhEGKqzRl1ZD5HaUxtHVC0Dn0+hIqteS1QdQVXi+jXi7RnkImEVVRQKVx1rG6vsBTPoGQNJ0g8DwIY6y1xwdW6zlB4JNkIzp7hC1rbLRLo+fYcsUBIwIpUHGCcxVRF6J6GYu6OuZnBCH5tefxk4Q6TjC2JV4PKIormDRnmN1CVTuqtibxU/rxiGW7xnclQZQdZ8VLSZT6KNWnKad4LiXfzHH5Ct0e4g8GROmYajGnMRlZELEpCuqmIrEpSiZU9bOIcA9bWRAVcZSB8xBK4socYzeU2pLOK7w0pW5z/CzEvchU0KZDNCVax5jKEGX+MWhNQNUa6lKzuzPAK3Mwmr7nsy47Sge5biBUDGP/eK2XAkIP4R3zpoQUlK3G+ZJMOcxshphsIbzfWf/271X9gcH+vSLnaP/Nv0Ytjii/+0+Qnbv7OH7KHpNolVB44rgcO/RCrHXUrSF5kda3yTvC0CN8MZMujhV50dLPAuT58+gwQj35JLzptcenoX4C7vhBWjtB3myIAwFIBCFCCppCE/d8ojikbixeNiZWDm0qyvISyC2cSNgdxwQyZFV1GCp8JfBcBWZN6yzOT2mLGoHD9xVJ2qN2BZ706BYzOl3T29rFITFNQad6uKbFastoMiDSmsXhBj9fI1R83Cu7dQK3f4nW3kCMt7GtpcPiW3mcSGAsjo6wXOM7j1Uas1wd4cd9bB4wGEaIzh2TSAOPTaspteXkVoLfNAjlE2tJLSRe7NOaGmslbrOmk5Le3glWckNTSgZiw6YokJ/8OCLsaM7vsjOcgIQ2HNA7nRGtGqTzsf0zVMYxKuYcnN/HPn+BxSc/T+8b3s7k5IS83VDkOaq2sBH4kmPSryfoENRVh24Dov4WupsxGtzATC/QhiV64OGphLSfgvQ5WE+5WczpxztEjz6GilLUq19DYySmy4/7cmxANtwliiJuHF7BTwPM+fOoQGA/eR11dMj2o08S/tQHkeUG0WpEUTJ8EYTy21Fx7gzrN72e4i1vov8Nb0du7WIQpMBgccie6hBdS9satj/4C4i8wrv1FNn3/Em8vT2stXieRmsPXTRoL0BXNaOzp4j6KV1T05QlxWp5nBFZNjTNCjewjMZ7CBXigEr08d0SCdhoTOIEUQyl6LBdh/RKArWFkyNaY0h2zmHWK9rplGB7AuTU5Yx8M2d7EhP3diBI2LQbPOGR+DEnxyk3c8f+fMO2bYiyhKgFoRUNLU76CKWIXv4yVh/5BPL6IdXOiP4Q2rygbAoG6xl+a5BvfhN5XSOMoTfao7KXkE5RWY30A7q6wQ8TfBUgdYsMAlRgUdLHWUVXrFBAkJwj8n0Orz+DiDwG8QhhNHFjOBAb0jClcrscLa7QFAv8eEhPQNy2xJVCa7CRxk+Pd/Zda/Df+CA8+xTNRz9Bed+dOCvYSE1tK/rZaYTXQ6ojesJD9lNMkVDdcRf1o8/TvvFNNN/wejoP4uevEF68Qv/qdaKnnkK+8NX79NPPfQk+9/3YO36Y3e/9k0zf9BBlvWbh+YzvuYvwv/lOuh/7Uap/8S+p/vB3oc6dwxcFqR+hswlWl7hyibx+DfnUM9jnLtBsSrq2orWG9s57KeI+8v678M6OaWWfzo9wbU1SLtE2Qfd8qqhPsDogd0f4QUwzn7JWI7ouJN0eY6yjXDVEmY8wmtVsTRil+GFKu57jD0b0hOBG49HzFKnwcRl4XUN35524/ifRH/s47v4HCQMFtaaqDdIYGl+SehJhOzzPp3sxf7V1HUHoEaQxRdOwLABRINSAY5i5PjacvkHpHrpbYWxDII/vjRpFIAz5v/0JvKYi/K4/RKFLkv4JVCiwlSYRMVMtqY3GnjyNufgM/fDdzFTI9el1Rtk2vfQ/5EMXjcY4y0CC92KP97ypOWpbFBJj1sS6ZhxuQ2s4HQnyVUOaROz0M+qjKyhfUukSUeWEWEy6hUi2CAcRVd6hJfSzhGJV0CQlG88QygRPGqzR4ByeimjqgjDxkAMP2U2QhWMQrOiFE6xusGnIJq7Yjk5Dqwn2V/RdiVMeouvQUjLe22W13LAVKNKjm4hQsgxStFQUbcWhaxkMMs6kGaKp6CqPZl2g0oRk3EP7PqrSKGHZTOc0WrG7PUZKSagkXVPQ6Q6pczZdRTs5xYXrn+NfPPkL/PTNf0eui696b3jCI5AB1VcxYv+/VOqnvPHUmzFa8M7z38S77/pm2rBPuVjh5Ue0ykfPFtj1AdktZ4kCyALFQvWQbc3ucI+SmrWbEYY9/DqntCVN3GMQ9OjWS/LKMYlu5/vP/hnOyz0Wqkb4gvc+815m1fw3Xc8oHPLakw/yst1XcvfgTj5/+AT3j+7nm297F8vZFNu1zIIlcc+nXBhcFDAJQzor2S/n1J0hbQVFZblzfJKLs6e4Wl/nfHwfum0BiRgobDdFeBkmCHFBRN52JNYQ4DFhgC8TOtXhgK5/GwM2jHsDsriHQHB19gJ6UxLGpwhrcMWKqSr56OqzrNp9fvbqR/jC8tGv+D+vdMW/vfAz/NsLP8P5wTm+4fRbeM9tf4yH7n2Iwxe+hD06YGs8IfY07XSF8SOM9bCegmZJqyJMPOLC7DmePbrE0/tPcWF1hUv5RS5srnOQ38Th2Iq2ec+9382fvfvbuGt4hkwJysZhoh7GX2LmBVG/R4kC6xjHKdO8Q/X7lFqj24JsJZAdeCokG47Y5EsSX+OfOMei86iKJaoosXKXVc9DWEvop1SxQ/olrj4k8TWu1thVh+hJCpEwjMZoN0XKEn/7NMVywSgM8CYTusBHhCHOCkxicbsh6+cuYy5fJ1mvCMbbDEY7rGpNazVGdxhTMxwOkNKHUOI2IauyZBknbJuCzLY0ImRjDaUHbS04t+WD7ljUNXE5RwhHEyV0QjPweqxmUwrRsdMbEYkELVs2xYZhNCTwAuJ4QrW5TqISNBrdaFopUEFG3R1Rri/Tlmtk19J5gq3T9yJcDyHXVKtD+jtnCUtBXhWE3QghOqwVdLWHH24IwxBZxQhP4JzGrmfUqUKriPaoIPANlWyxgTguE3chVtaYrqVdlUh1zEWy+nhjfLWqkXlHMvZBSMy8QEyGZJ6HNIZ16LHCIpVg/GJZ+X8s5xx5o4mUhzI1zpO/b8w1/IHB/r0jIfD/0Dvptvew515CWRoCv/tN5RJBJ6ltiY4i8s5gtSVSHtWqoa5aJpOEqigxztJLIg4rTVNrkjggv+NOgicexa1LROxDs8HJ45OGogVrStLYAy3xg5gwUVR5R1sb/NCnbTsaY4hkgO96KOUoqjVGFIQMGScT6k5weVkSeZIg6oCIRi+oSp+21ijlCJIeWTJgUa0wL9KqGY+IkhRTrNHW0Hkx1B1x4Ahkh5/G1IMxtlpimppOg/FTonQHow9w6ymGAC0MsXfcJ+KkxZb7xIspg+HouGSz7qjXK1qrkEGfCI8u75DDmINNQxQphrFkWnVESZ96tgJfMt7eoqoqrl8+wGs6BgNN5SwRLWdMy+H8gPCpZ5gUS1aveRB/+wyj0TYL5+F5gqg9JNg+gYi3CK17kVYZUT1wN3u//nHUCxdZzo9o24peGhNHPoXX0lUQiJA49HD6uGS0WK/wBxP0ZBt/7hPstLjZnLLuCHo+O6M9bNvRrhbQLLF6hb/YEFy7jLz1TuTHPoj/5DMk00P8Yom9cY1gOsebLxkeHv6Oo5q+kpxS5K95gPnXvw335jcSnr6DSmiu3XgBc3CJvcAxSTM6E9DH4ZoF5tIR7r3vJ1luaN/wNro3voYOkM6xrnKk53E6i8hnG4QI2NodEPWPWeN+GCGlR7maY6sF1VFNux0wGE6Iwh4IwabTIBQjYjZGYFVNLz1DEDiaymDCkCTew6qMpmwpTM14OEArRbte480F626FsVMG6RDR3wPTYmxIpSsEgsBZgihionyWdcvhcs04sljrGMW7dN2G3HX0APmKV+L/6iewn38M3vkmWldRTeeYxCf75DPgedjXvJq2OmBUL2DTEvYnuHrOXNdYNSQNDYMspjvaHG/EmeOoDBWGKNdStJJaVAS+Txs6OpvT132SaBuEplhcwWqDHCVkacSz04A4nzFIh6w2BWVZ4tUNSbYLQU3dzNBOgNG4XoR746vRP/c+1h96H+r1b+bU6Qepqiu4ZIiM+my1A8IwwEYc95796qeI92e4V38N7s67SJOU9c5LOHhlxZ0nzuJP+tDUNJ97BPtL7yf+iX+FLL7cVMjnnmfy/X+d4WSLzff8carv+4vMt/cY3v0SvO/4b9A/9k9RP/5vif/s94IAUZX0Ll6gfeJJ3HPP4ZU5PpouDClf8krsLWeIBiFeNCLIK2QcIoqOthcSOYvTc2yaYDcJTWHRgaBpM1J9iMeGzimmhx2pD4YQHDSlps47mmZDaS2y0gxHW/j5Pl3bkomapk4RwuNE0iP3WtqjhijMsPffh/vQR5AXL+KNh3TGsfEcyglcrWkDha8bVNBHNy26bamoCYSjt7VHPW05nB4ynhgMMQEOzzMIEeIpi/IUWnvYekMX9Bgqj6t1w+YDH6I/m+O9/tUseikitwx6CYXZoCw0naQ2IVbXtJMt5LMtwWJOb/dW5usD8nDDwDsmhTfaUGqDLyFwAqEU806z6Cp6wnGmt0ele6yqG8xW10FDbEsqFUCS0i4O0OtD/H6PI21IvBARpth4jIp8cBYVSLrGkI2GeLMFpi1YCZ/dNMHzWrqmBCFoOo2UgijwsLaDcIKuPQb1Ef7sebwkod7pExrDIExZugIdKvTquA0pX6+xXoSVgmgYMlQj8ul1zHibdLAN1ZrbZMg6cMjQw8Oh3QZP7UDbIgchYRxRdJrYT9HzqywbSzKM6EU+ts1xmwNCLIWJuL5o+VxzkR/7zA/wq1d/+bfs+R34Q77t1vfw5+77E6Rii8vrK9zYXGQedjy3ucCl5bM8cfNhOluxaBa/UVH2X6JUJUziHTpn2Q63eMMtb+WO8Tl6c8NY7XHL+G4+Pv00D6++xCtH9xJbn7Cu2dQb6s0By3QH32sYnhiid07hyQQb+2zall5d4x8dMhgMaWXHcvUUo2iXIhsTBxGqLdHthiRSsLtFP5pwS303xewx/vLr/lt+4I1/hw++8PM8Pn+eLBnxilP3cnswITUeRu3yr5//AKL1eMOJ15P1e4SBx3T6HHlRUsbnSLyCnu7YGEtkJE2haLqcrWSAdBH3jbf5FWV5drXPKf922kDge4Cfo2REVypsU1A3mrZu2IkCUl9hhaAXKqaeIDeaMklp/YBUaZokpUVzSJ/TO+eQG0MXC3zreLx9iqeqK5yJ9/ixB36I5+sbvH/9EX7ywnuZ1vOvOD6XVpf5p6sf5Z898a943Wdfy7tveTtvH38DTTKkLme8sHycp9dXeTa/ypOrS1wvr3G9vMFRefSfHftZfcQPfuEf8oNf+Ie8Ye/lvOf29/DQ5C3k5U38NKZn1DEPpOvouiOs28ETiu3hHs435DdvsowL0tEWsY5BgOxKjAoIwojCMzCqGcsMqRLWqwU0AToy6C4nyKA3Ok/oOvZv7EO3QaUetZS0yYA0UVR1SRpJNqMxxWaNcJZ8NsdX8hjalYbspBOWzmP23HMU168zEoYkjTEmIG9qPAxR5BGGGdbWOCnYeClHeclgvM0ODs8UpL5P4TW0WY/pwnGzaOn7CrmZsqpL/NE2xtZEJmFd79OGmq3kDDEBTbMiVAMqU7EqVox6I7JoSFsvqfSSUE5AarpG4oxELNYU9QEyGVEUDfHWCSJ/gjUOL95mvbpKvJgyDEOWRc6maomZYs0WhA7hr1Hy7HGZdihwqxnaNXTZLp4f0ZZrEl3jhT6ajriXICqJCzpMvkJIQ7gV4ymJsw6tLZulJcsCwmGECQ12USIThQwUvbLD7wwzY5kXLZ4QDNMvZ0jhIIsUbt5A8PvLkv7++jT/fy53+iTdS04TuoY66mEjD99XL2ZNQxgklFVDI1rqjmMMvrasFw3SOVTT0TQ1SIHXV6hAsik6xqOI/O676R77Eu3jTxC+/rVQznC1RihFWdcozyAJcc7HD9UxXCFStJVGBRJf+VjX0VkLdYWntvBEhI1meK6j6+YY6+jFFlrLlblE+TFZrCnWC9qiItzbw49iwiDGLw9p8yMatoijFCmgLdbUUtFWjtSzpH4DtUZ4PnHSo20LEs9n03YU6w2hCgl7W9TzyzjRQ/b6SE/SFCU2yDGrGUlToGSPyLbH5evBkEB5uK5Da0tbN9w4rCm05Y6tMU25oraQpn3W6wPiUUxXFrRFge5K8sbilvtseS1JoFkvKpSE6NnL1H5G88r72en3KWSAEz6D9hDnJ4hkAkAgwBrLprA4FRDeexvZ9QVFGOB7knVZI3ODoKZsWqzWnDl7CitatGwh8qAf0WhL3ApsGOLGEf4qR7lt8lwfl0UO9vBNxqkvHeH9bz9M+tmH8Q8OfksD/V/S+WKDkOrkHot77qL4+odo7nsZk/MvIR2nyHZAz8BmYpmuF/jrHBUGHKyOyHRH89kvEH/6UZAB4h1fT/Dg66lEQFPX2HXOuj3e6TfLKWVTU3sC0t8c5GWNQYXQTBsanWBjSWAbpApprKWyjr7yEEsNaoTyjxB+ixfvooprtK2kn+6AJxHzFcYTuCDEF4J2M+XoxlVspMi2hlAPaIyH644jlAQCIQRFNWcQxPgqYKxzlnHAtekR46THqJ9S5DWl7QhNi97ZQeydJHzqCfQ730x+5QrroiEZpngXryLvvYdpIAllj0x61PN9eifupJgv6FghJgO8oE/sOzbSQ7c1epMjbYAIA/x2gR+MKTb7hLZgVS3JRhPCIsR25vg0OpAkLVBr1n5BmI4x+QEyvkZcOebOo7GW3f4WXU9SmRw9LfB9hdAronvO4X9yFx65SPq6b0GOYwKbUXqKWPlErYN4wAaBObxM+PnPYrIe8tX3QqgwLiaYZIh2RScAJMYP8F//GuwbXw9/+3/C/MgPIX7oh5CHX/7wp6YzRv/rP2D4v/8I1Z/4kyz/3J+nO38b+lv+EOpnfhbxo/+MuBdRzpY4wHQdbm8Pfc8DmNtvoehpIheTuATDGrobxFsjiCuEVohgTacbktint3OSclnhr2piK1lEBlsroq2YXiY5ev6InRNnSUfxceZ5z+foxoJSa7ZPbtNOV+S5xfMyND4jWyAXV2nSXdK9CdX6CnWsGAUx69tuw/KrRJ/6FOIVL6f0BMJJjHRIa2lagS9AYI4Jv3VBqxp6MkDFPeL+murKnDod0lMePgbPEyiVYe0KzxN4NqFpVpTtNgDeU8+iPvs55C1nEW94BeWVIwbJGM811NWauPLZoEgDSVI36J0dOhFz8OwzJFvn6YV9nDWsmhXDcEjRGAzgC4cnBAvjcA5iOpSsMCYnDfoE9gyXV9eo7Qy7mhNv30rXLCmXM1QvpEt36EpBvy0QYYyTEs+zrJ//POHoHAQTRJiQJCGr9Zx6tEtnfBIFbVEgSKjqmihQJIMeTVlhEkHgWbpph4hC1CiiK2fEyhHQopSiTiO66RTP86iLEplO0CZnkkEQ79J0gunBTQZVAZ3AD3t4XoeyLQf5hoGCnf4WyuZ01lLkLY2CrDFs1iV1r8duFsFmH2Mty8rQeoqfvf6L/OjD/4QX8t86+uklvTv4rlv+KO9+3fcwyDtklNIVS7aMZPuO17I1GHBQWn7yyZ/hXHwn/8vr/yKTyQ6PPfMIl4trTJtrXFpe4lKzz4XFBV6YX+CwPCBRCWeSHc6OznF6dCsnw22GYovBcId7d25nUGuCZBfP+nx+9iQfv/KrvGr0Kl5z5iGa8gJ+LunmBY9d+jQj3+dWG5PYChnH1L2Q61WCi1LGYcVkNOGKE4TSsShL0Ev6zqfVDrleMQxb5qLjeuiIDSSrJUf5ksZ5nL7lLJUfYCK469xLeXzxLF+8+TRfd9cW77jv7XxT1YEDEzmqzrLZLzg4eJYnbj7O/dv3cOvZ86jAo/agqcb4taOfz0i39+jqmukyJ3CKKEgYZh5Otvh5QV9tMRnu8cL0Sd6QvIrGeIigwFtV4G3RrnOCKGIeCuLRkCQJ8YIQJQQB4HeGi5SMfEE/kohqSY+Ga6ZESR8/m1C7goNrB9AWfG72NDYMeL6ec2E457U7d/PawW38zdN/jJ+ffYgfv/4hPn7wma+YK26xfGL/1/nE/q/zt8IfAGDR/NfrCf/4/sN8fP9hUpXyxp238h13vJt33fGNTFczVt0LiLJj3Z4hUAY/BpUMCWVC5WpqWmrdoNaWUDrEcMJBVeHZAusaomQLMUlRxRFy2qddHWKVR14EzMQN7ti7g2yksAcvIJoaFxyyyQdEgxDfa6mqQ7L0DNPpFLla0dqaSA/oZwN6vQFCCNKwh949BU2NXm4ouMgyyKhqy6lxjzgOkTIgbzZsrML4PhEN251GBCmmmGHKSyhl2EszKHJc3dJ6HuvpAQzGrJUi2ihsvU/jOXZGtzIcjag2LVW5oD9oSJOUuqmpqookSeineywWL9CRE0iJh6G+coCpDd2oj2sKjIHd7XNY4/BDj61oRNUU5MucyKYEbcNmdUhr1iSDMwRJg8NhuwacD00J1ZI86yP9gFgUbJIe7XyD19XopoYkRUiJNAFlqwn9Du/FnHAhBaU26NYw2krxEh+hErqiwlUtRAqZ+kQlTDrBkXYcbGoQMEyOTba1jrLRx9wna2i7ChsKPNdDiN8fp9h/YLB/D2m5nrMqZkyCXSqVUEc+QeTz761P4Ico57PRHTKO6WUhujF0kaSXhRg0vooQraWrGuIopC40prNEL7mD1g8wjz8Jb34T+BFudUgXbVPUa5JAgBWoIKIQjrbTbIc+prPo1iIQx5Rua3F1hc2GqKCHiC2h7wOSqlvh6TVx0OOoGLDINfPKslNreqGHCjV1vcLH0nOaGkMbRKQOXNtidE2hFb4HsWrwJWAayA9J0j1qL0SIlsyP6Lrj0l6hfWp8ZLdBFBVGtNiqwHgWt5wTJinCT1HhgHq9JmqWZL2UTWHR2scEEV1esTWJCXzLYrGkMgF2dURdbQgyj65rcV1Jlhh0a7H5nKLdsCSBIGFXWLqjGfNbTqOyHioZkwufgSkhCJDR6DfGWEmBLjtmiyVZNsB7xSsIb3yI9voNvHvvZidNKYyhKgpcN2O5fwVR5ySpBRUSxH0qDF7Z0RUbZBQjew16vqA9WGIO1gy+9CW8X/sw4w//Ct70dxYH8jtRd9s53Dd+HfnrXsty2dFcfBKrW9TzVzhxbYXqPgKTMZy7g0V/h+DMhFu3trHWUk03yHyB++WPoK5cx+6cQrz9W9BhSSwqWtmnMQ3Lg+uEkx5Z57FuNeEgIu5FbGqNJyXBiwt+U26w+RxsSHB6jAsrKFbUSctGGgIpiJ1lk5c4X5GNziLcitbVKE/TdAIhPIzuUMKiZEjdVGTdhk2rIe7T81uUF+ICycZKGqup6iVW+oReSNds6LIMpQK6PKff9yk3ksKlpG1D4CU0xrFu10ibYV76AOEHfwHz8c/RnhjQDnvsPXUBB4gHX8G6y9kOU5QL6aI1q4PLICJ2k4gDu6IOd6FriANFJxPq+RR/sIfwLSbXJL1t8s01DjfPE2S7bG/fStXt0xYbhO9jfMUoCJnriKpYM+738doBq3mFHwsCU9MIwcZPUUHIbHUTpvsMBynjvVvI+rdSfut7yH/0X9N85MPEf+TrCJIBiY6QRJSiokQi24bh+z9K7ces3/BKYjvF2BGd9BmPhohGkk/n9OQ24XhwTM/OC5wA9//4Xuyf+naCn/oQ4kf+Kd4zXw4vEkVB8oP/hPiHf4jlO96B/c53svy2N7D9/k8TXFujb78T94r78U6doB4N2ThI0pg9WeIXR7TXlnhhSCAqvCzCKE1ZOdy6Qkc+O/1tPE8hQkEQh7jljHGgOfAzNuEOgTnEdAtaeY4Oh3VQdB1LV6PihMZAMsqQBwsaXzDrOlaqD/k1pPCp6h1sYTHKUdWarpLoW+7Cu3iRzcUr5Nt7BB50EqLEp8s7bGsRqsHzI9blFBFpIpUcxzCmx/2E5UIzTEAqjfR8Vk2L70Aqg28zsIcclDk7G+i97xdwWczqXW9FbxrSpE82mTCbP4+xLTo5gxemZLZAJjHZnXfSypjuwkWWr9gw7m8RmJa6LpkasCbG9yVl0bL2PFIEPQWztiY3Er+rGPl96lYQ+CnB4jKebNCy5Kj26JxjZzCmIkA1G0IpsSrG8yX14hJ1scZ0F4nOjHHGI+nHFDdnVE1Hk4AUAV27wA96lMWKKAgJez6bokXvz8iSkC6LEOMRdapwDWTOYvMDYpVR0oIH7WZGq0F4FUFSkmXnkcGYsUu4+MSnceuWQKQUk4YGj7P9jDIJaI2k7jqSYUzTacrW0BQtab2i8DKynk/oSmxleaTU/OCX/hE/f/lnWDbLr7reSiH5xnNv4907f5jbxe2koz4n8YhDRykVbbVCiRIrQIV9itkLXD26xENnXslwvIuxsDc4x53DMyQ7E/RshoxjvF6Py1euo+oZrfXYHgRkSYolPH6ojxOu1gXjRFGslxRNSSocX3/2a7i4epbP3fwUaRGz24w4myVcCG5Qy5ZX9O9HhH2MlJR1B3mO6CzN8ga7k5B0uEOyLqm7jlV+ky3VYFwP2yygMnihxEaSWX6Bk/FJimTIKpAMRiMmOzssNxvmreH07nniOOHZ+TXeWEmkVyNEhez6eLJPgocXFfz85gOgC15+9pUIBXmbs9IVfn+CzWG03qeXSVal4PBoSTkecWqYMPAClosLNBhUtM15tctn8s8wn15AqIRwyxFsnURHQ7zI0HkpjXBMAo8qX+GHCXF2DGNFH/euKl8y9EMq12NTTXFmxfn+aSZRQCUctaf4QvE0TZXztfe/k8+98DE+efgZXvvKB5A3p7gGvnn39bzx9tdxaan51es/z/95+YNc3lz+inPnv6ax/k9V6IIP3HgfH7jxPu567B7+6F3fyau8W6GyzKZrbjtzAitrhOzjJT5JCSEhCzNluZky7PvIOEPUGr+aIq2kCvuYuuLZxQs8dfA0D9/8PA9Pn+Lx5dNopznXP8f/8qa/y5vSVxJ0LS5y6K5mtpixlQ2pigW28dCeoRQdcevoieQ3zHXX1FhjiHt9/O1d9HwByynh4oi5F1JPBKvOY+FiurYi9Qa4Djo8vGWO29rCJRN0UeE1Cq/rSNyaZiPIOoP2FLkCV3XcbNcEUnNK7RH6CUp5BJEHc4/2aA7DFIui6zR1XRNFMWk8Ji8O8ZoaT2voJEV6DqOu4o6ukkRnkfHoOBcbQ6Qi+qM+pXVoIVDLkmaxotvaYpDK47QG0aedrfBshsyP6MKQLsroscEXEi9JaVYRSVvSBWuMHuMFHmatsCg8WYI1vwFIXmwaQilJXjyVFr6PCCSubXFdhAw8ZOITlh27QrHvOm6uaqQQ9GOfvD2upkkDddzz70r8cPv3jbmGPzDYv6ck+xPqNELIFSYfsFAhge8RhB7yRdR96IUcblac7KUI544J3N5xmZLVliAMsE5DrfGUwXmCutbEWUB1+x10Tz+BWywQgz7omxRljtHVMXYfjyBKWNjjorTaWIJEUW1adGeP+wE9jzLPUdEAGYLyMyI/ptUrWtOR+hmt9glEzql+yqWbBUeVJbrlLK0TmPIIqTdEwZDDzkMpg7Jgy5KibnDeiEQ1hHp9nMkqJBRHKF3jG4+u2eCZjjQe0sURdpNTaUU/lXRHFxH+EC8dY9ZXEZsV/m33IVyLbFqqYEyqfHw2ZN2G/VJS1BkqjJkMe0RRx9xIqCxNviHuHecosryJDUKyk+dIR4LNzadoj65TGJ/x6YDuo5/E1mvM/W/CkHHUGAZeQ5T0aKWHeP4FzL/9ScS163DqHCoeEu5usfvKl9Hdfi9Sfojk+acpX/4AXVUyTDOy7R02gyH7/k2uXrvI9qZhMDxHLiWtqpCzHNm1pF6M+/Tn6X34EySf+gL+M7994NhXkxMCMx5hTuzRbk+IdiY044xykmC2T6Inp9iMR5x82e2EUY+chPmnP0Z+8k78l9zLON4j3l/RPP046mhB+8RjyE3D2BnCcQ9z9iybwYD+o48RtRX5/feyetMbOJ2doqxvQJvjedsstI8rb7DVy+jKDTJWZEkPz7ZIT7KsWrbSENe1NNPrWGMhHOMNEga9Ad5Kc7CeI2Kfk4Mepqyoi5Jgb0LQ6+FKQ9d1hOGItjreVDJVSZQGdFXDZrGiUyGyt0skNgRBhmjAigpPd6yVw3Y5hQ1oKUiFYONaBjbCOk1bl+xs7dGIPqv5NSKlCLRHh+Zw/yr9vV0CIdBPPk35sncReh7qkceQoxHLMzvIrmEgfKqugXSLOr/GMN4mDhMW3ZRKFWxsQEpLPJlQHS1oqw1dOcNaiVzPCeKAlc5JxR0EKsAMBtSHR5hiDYGPlAFe2mer6FjXK3rDIREDlkVJ1xiSULNpbmI3im6zZBAlBFGEn+wiVEhy912sz59HP/Iw7g13E5y8FbMsWC6WtFmPTAr8D3yQ5ugQvu7riPdGlJsDzMAnCCxRp4kn2xSrFavDQ3YGt+DihLWWePWKeDPHC4eYb/t2+JY/wvrRLxD/g79H9LFPfNm8FdYyet/7GL3vfQxf80rkn//jLF7xIOHgDG5nF1PXNE1Nzw8YBQFR2GPTGUwkSIWkWs3RwwrhD/CjkECFbJSithKalkprfFtQSI20KfiSG1WLyCV1qLhezNhuh2gnmC2WRL6iP+qxWuXMXUfiasyqpBE1l7TE81PidsWlq88Sq44mbKnXFV5V4738buTlx6h+7f2sv/Ft6M0GQ8TWyW2iMEa7EFFUiGFM17UkaMRwhHUtrWnJRgOWRx3deo2cKFrtc3B4ERUIRkmKY0BpOe5N/oUP4lUV3nvehZcmTA8LTg0H9MOMq12LbUraXshICqxrcf5x5n27t0N8/QaRrQmkokNgmoaiKegpjfYymq5jGMeMfY9KVzSmQ8mQSnek6znlskIUhyjPZzA5jUj2KLqSMlgxbdaUhPSaGrIBCImQDdXRVVSY0bUF3vIANTiBFwUIKVFVRz0QtJXAOUPTVnRNRZb5GF2hK0EiHNr32Eiftm2QuqMXb6FUTFtexe86ZLembhewrkHGaF/S75/AT3eOv6t9TRL26UrYiAC7MUTehiq/QiB92tqxr+aM+31s11B7BjtbMO86ykzx2NUP8Zn9L/LR61/gswcPY91Xh/31/IzvuvUdfO8rvo9zgzt54ZkrrIOMwVaMWq/I1wVVP2bmckJ/xET2ETLkl5/7MLH0ePX5N7IxFqUdfhAQmAaEwEvT440spfBsTaQ8ZFOhw22cVJijG8jBLkk/IzIds7rG9zMiW2MaTawM777zm/n7H/1HfHLxYb71xHdgzu/x6LVP4o8yXvvA19JFI67VjsAXbPVCqlZTTK/h+mfpFiv8zpAvD1kXC/b2ziKUR9z3sELQbSr0fElEwYEICIKQsK0ZRgOk79NLEor1mtJ4nJ+c4/mjF+g8QegGdB2IRuI7h58I1qrgsjvkpaPbGXoJF9bX6IwhCrYYhSFdnODKEaqp6QkFwlFKTdVp5PKIqLVsjKNr9rlNb/FpY7girpAl98Bwgrd7jiYvUFHEYScIao1HiXUb6jIH54h7fTa1IQk8ksCnspYsiLm0runamv5WD2MMXVmztTXi8Reeo+8k35jdx/Zezc9e+DC/fOljfPPd7yRsWqrDZxD71wlUyrtv/dN89+1/lk/tf4kPXf9pPnjzIxT6t89J+Y91It7hXO8k59MzbEfnuffk/Ty4ex5Mwz97+F/yk1d+hdlXoaM/PX+Sv/7Jv4EvfR7aehXvLN7O6Z0/Suh5WNse9/BGCvKaxIb4cUJlWpbNhrzc54sXP8iTR8/xhfkLPHr4RfIu/4rvc3l9mT/2vvfwpr3X8zfu+gtsd+dIwpRFlWPyJV2+YuWeo791Kx4+ZlWwmR8gQ4GQEpzDjyKi9DjiMDl5gmXXYqYvsB1t4VWKZefo7CE9WrwwZm0k0biHryuulJf58ad+ktefeSWvO/FmaDW+t6ZcXGftechJRrxeEschahCRdxOubjpC2xF1GrNZ4nca1/l09YI6i/BVRL1paSKNMh5muWbRrgh1n3BwgsJTmNkav9CovQxnJNZpbGtpuxZf+NjAw4gQFUEyPyQ3J5jmBZPeFs6LaJslZnURFSlmyTauWuH5GbntiCJHkw2JFytkl9PWNXEWo1vwVAZyCbqGIKXtDHnespsGyODYEAsh8KIQU2lcY3D+MdRMpj5+qTkB3Gg6ri1KTrqYVlvSUCGloK3WoI6rrH4/6Q8M9u8h+Z5HZwOsV5KENdol5GVH3Fo8X+KHHtYex0/5ytLWhtY6gtAD0+H7Plo3dK4jUAFd0+J5AbU2hFrh3/dS9BOP0z7+BMHrXotTEflmja8cwoV4KqD1JFVTAJZCZESBIoyPS8XbWqN8n7ZpEa3G7yuk9An8HkVXYvWCIDhB5+2h5BKaNX61JMx2SHvHpXr1siSJFQJJS4eSLRhNuV5TGIEfCvxqHz+JINuGIIUwhXpNHCdsVlNEUyC9BkjQTUWgOyyGQm9wuWXsG5Y3nkV4HtNhglvP6edrhHK4/gmsP8b0Zkh9E2YH2LaHrWNW5YyqgUCGpKM+UaSoTc1muUAkY8Yv9uOsnKZrO7a2tknCGPHE47izuyR3v5S8kcwOD0mHGZvD5wn+3v8b9a9/BqH/Q+/byRd//r1sv4dLU9Jf+gDmzBnsqVP4t9/O9m23IUZjNoMhN8QGJ8FXBvXME6Qf+SzjL36B4DOfQm5++wRVFwS4l70Me+IkmzRFnzmBO30WsXsKN0jQq2eZbu3g7n0FlV0gZEa/XdIPLGGyRxKcRLcauSlIM49VecTBrGStLf3YY+QL1NaEbrSLvP00bX8XnReEjz+DfeoF3PIG6tnnGFkB0iN857fgXnoPR5vLbMySMBvSHi3RIqez0EPRTQukD8H2FmEUsZ7PGHmWWWm4UeaozRG2qwiSEc5J/NQn9UO6bBdtHZkpaTaObrrAepKk18NZhasEygtQfsamOSCfHxF6gth31K7jeu1zcjJgHHSUqxlefBKloFpsUGbN3AsJ2jUymGB0ifB9OiGpyhVWdWhtmPQmWNMxiyLKRtDe2EcFHvksZ7i1h//qVxM8/AXSdYtYzBGbDbzta1l2NYMgo9rkdNoct1tMtgilj1mX9L2QqYoo2orQs4SuIx6lGGFxWpEXBd7BIfVOD08ZRNvQNA1hr0e9XJKvj4gm22xMxyAWxOM9msPLHHUrTgcplg21p7GbgkmS4UUDbtQJRVbjyzn54hJyEuFkSPfWr6d79n+HD34E/tRdtM0ClxeMt7fxn36a8rOfhdtuIXjlA1SHFynbhEG4y6AXoY+WmMbQ356wurJPuVhRxwkIQakcaTbBKz1MW+Ko4dUPcPN9P4X6+M/T++F/w+CDn0CYLzcn2We+AJ/5Av4t56je/o0cfut7iF79IAMhiDyJ0RrrxzRFjYwDKhdTao+4uEFvuIUZD+jyFls0zORx37ks5oCHHY6xpSBWBq/UbOqGbPs8fpvjtwusjjgJTCYjOgU61ayMxAsSgkUHZU7UQXJiD13PmFcrbol9sBXV3OJvjfFDRbO7hXnsEer778BkKVW5orqyRmUx8yxgstGgCyrRInVB3hvSlQXLtsJGYAOfPF8QpiEbbdHNnMBmzGVN20kiFbH78Y9hL1xAPPQg5vazBIUlFALtYqomx+v5WBJM2SJVSWu7Y1CN9WlP7hIe3KBY7hNGewwHGQebjryzzPwC1Wlu9z1GcYQQgta0tLrhE5c+xp29XaR/loaIwAsYnn45nlhQzw4ZeQPa8QnqtmGTT1G6JWBIIKFcXoLGEW3fQtveoFvdQMRjwKDiGN9YurYhlz6BVKyKDbQVgRVsFhui/q2MxtscXb9J60UUbcl21idWMUIIZDAEv0XVDU19BbeZIZMBnZrQy/YA6NoKXW4Y9k/Q9Cxt0iPwA+JwTaNvEAc+o8CnDGDVdWyWh3zy2id5+Oan+eTR53lq/dRXLOn9T3Xr4Bb+xEv/DH/s3m8lyhuM7iiqDa3nk0QRahBxdLTEyJbOVGyfOEmYh6hS8+jFRzjIb/KK869hGI85zBsyT7KTxbBqcF2HTFNs09AcXMVTAaE2KNnQaIuxFhGlSF+DbhmEIVcWG86kGbJTEEK7WbIVnuDe9C6+VHyeF/Rz9PzTPHL0FLeMb2N39xY2mwrnWVRXU3sBTWwZbQ0wWycplI9b36BaXiN2CbZ0yKbEZRlCQkNHtHcLkbdh2lXodkqY12gvo9qs8XyfvvIoteXs5FaePXiOZ+bP8rrzX0NVdLhAEwkPHPzq9V8HJ3jHPe8g8EJuLNeoNCWhwTWaKAqgP2STa4LIMug5hrqmPjigahrKdIyMAnR3yMm9O/GnGRfNC7wieICGEVFrcNbSqADtDInRoCvCrQxrNHVxgDaGXAf0s4BRoJh2mnlXIpXENwlVXaJEgDBwtb7MSjW8fuflrA6mPKBu4Yt7t/KZzZM82L6e7ajPJklobgYoYWjDlN2w4w3jPV45+fP87bf8v/jAU7/Ij1/8WT43/fxvmldSSM70znAqPsOdo9u45/R93Ll1Oydsn1PekJ2dHY48uHa4wq8rznoeIl/h/B5/4yX/N/7GQ3+Fn7v+GX7ymZ/jo5d/5SsyAjrb8WtHn+TXjj7J37/0T/ju+76DP/Pgn+aO7fsQvmSaH/LI/iM8Mv8snzj4El+cHs/X36k+uv8JPn34Ob7n3j/BX3jgzxG4PrP1FbLII/RKQrUm601YrA1lOycTKcrzAIkX+EjpAQJdNWgV06gU2hx3tWH7/D2EWYPxMirTMqsqxn5AZRt+9ZkPcFQc8vPPfoSr+Yo/fO8349cRnRSsTURSduhqRi8cc75/N4tS8ly+4MZygS1ybNcSpz0GSUK7nqHNEd4wIWhiTHmIF/r04l2m1T61On6Gb7yGOO/oihDtPMpVQWc7jK7JtgZ0QF61LPKKLSlJVIurltxcpZS1wSfHTVukXtD1tqlMw3bUw/cyVusVwlaQDWlWB6h6gYlK2iYAJYj8DCtW2DZHBimLsgVtGQyi3zQeIgiganDWHldr+N7xupoo/ApOC8HVsuWZ/Q07/ZDtXohzjq5Z4eKUmRaM/eO2ot8P+gOD/XtIerPGNIIju2DHHe8ctT1F6seYF/sd1o0mFB51WxG0MUZCwPGXted5lOubOF0h09uRNeA6rArRrSG+605y36d77HH8V7+K1oup9IJYGqToE0QJG2txtsYXjtpENFYSBh5hrChWLV7kQPqYukELj8zLcM7RmookHNMZRd0skCbC5ktiWrzM4Yyh71a4IMGEu+SbfUq9IWRNlyvqZYkbQtzso3yBGN/CBk1TTsFZnK4womEpYoS3IhAtZevoFpcZ2AZpRrSiJV9cxtQB+XJD3HiIf/VvsKaheMM3EJ7q4TZHNNEWebZD3+/RVBdobt5g/vh10ltPg7dDFEpU2yCDhMR1LDyfkR9SHu4TxRFSVLREREqhHv4iVjeUr3ktcdhDxh12A+of/iOyH/lnyOI/v4ss1xtYb/B+7ue+7HfbwFYvo97boz51kvjKVeILX520/JXUnjhJ+bZ3Yt/xVuYPPYjDZznfp6wd4+0d+qOUutPUixn104c0MuAO4bEvQ0JdogAvPEMancIhkb4Fr8V5MdfWN5gdXWM7ren1bqHPkNo2LPMFKt4lcDAa9mlffi/1mdvxYoVoNwTTFWpvguuP8JcNEzkir9eIdAsN6PKIWPYI4y3K6U3i8Yj+aHwMLFssaKqSVEaUixVFuaCJQqJcYHzHOAjxjGEpE3qhoC813aZjcWOfeHsX2YITBhElCNFBEhCsA1ZXLhHvjnFb2+i4h9AdgQQpG/wgw2qQvR5+O6K9eYHKDemcYRIJnBI02qE0rDeHeJ4jVGO07vDrDf22QruUSgts6RDREDfx8V//avTDn6d57FHU7Bhak997O054+LWmqiqywRB0RzTYQYgaXRmCRU7cTylbwaifoV2JsqBMjVIdkbIgJbX0yCyY9TWWeUXWH9IpTVWusdU2aQw9OvBj9oYTnrr5JEf1EQMZsheFaDegSHeOzWeQMfMXFFbRq2pm+08Sp9usM4m48yzhs5fwH3+c8NQplKoIZlOK9/4ULorx3/kO6nyBS2Nc2CeuDcO9CZv8OGItHvpsYsfNa/skZ8/Qj1uatqZyA2JfY+IGpws4uorLI8oH7qP5x/8D15+dsvPef8fWe3/qKwLR/IuX8X/wR+j/4I9gT57EfOPbMO94B91Dr2deVbRVh/IdyjjCE+eIvTl+VyPskko7enmL1RW+akmFj7+1hxUela0RSUB1dETQWczuHqsjj+liSSYco8FJCHzy68+TPf4UyZnbaW+7nbS0iPWakQzptT7GxlxpajbxmP7hVYyx9M/t0LeSmw88iHzfLzJ6+jLq7Q8xX5RorVDGY72skLKkmU0JogShWly9ofM6Cm1xDoQvKboSs16yKJb0VcihDshqifRy/ItXCT71KerJadKvfQ3G+LSbDdsqRsQhB3qGkIo4GRAjKMoFIFCRxjYWceY04WNPUB8dUe9syNoU2YGvHTaNKcsVpR9jhEQ4R93mfPbyp/nS9Ye5Hu8yuP0Weg7i4RZxr09TKExznTi2dNEOmIisWRxHRbqGdv0C3nSf1J+wcWuEMChb0BxdRKcxQoWkUcK6Llm7kHEYkk8v41UlehRBmjHa3iVQAZWxXFqu8LyGve2t36Dbel6M7Soi1zHblPjpkHRrhKhrRLHAih750QzRSMZndlnka5pWo5zDWYntAvJO8+vLj/Hpw0f52NXP8+jBI7/lCfV/qm849xa+52XfwZ29byDrDdlJSpaFR90eMOsO0MonlSWl9ggbQ9jbon8iI/MytN8glht++YsfJJMBb77zzRgBVdmhfY+zgxgjBa7rIAzxQkFbV8jYJ8timm5JPp+jRxPCnTOIdg3VAlQfAXjW0RKR+DXVuma9vM5bT76aG/kVvlh8CXHDwzrDPSdexUELGsGgHyLrihvzkqYpOaX6mFpz3eWEoiM9c45dOcasDTWaLPTpVEQV+jilCKOI8+qQa20BkSLoH0d3tWWJ7Vr8smYSnsQKy+P7T/D6215HlCZ03QpXGeb5lEemj3Nb/zxn927lwmofs/G5zd/Ck5pVsSKxAdEgprrR4iV9ojCnvX6VKPBJds5Q9UYUZUVTRFiv4my2xwub57BnJK0Xky9zvCyiRRxDBTF4wqFkghcm4A64ObuJ8cYMJrsIIeh7kqOyxEif3azHcr3AD/tMvJSP3/wMSRBy751vodw0xL0h7z7zbfxvn/un/PjjP887t9+MsJp06za2xYa5XOOFPsID0fkMSsEfvf3dfPtL/zgXVld4ePk54lbxEnmKu+95LYxGiKbFTBc45dEbjOhmc4Q6wItTMgur7pglIHyDyk5jrKIphgyArx+/jHtf9VbKBwt+7eEf4if2P8CV8isb5JvVPn/vs/+IH/jsP+ahMw8xK6c8PXvmt4T3/U7U2IYffOxH+MVLH+SvPvDXuH/nLpLRLqd9wbqsCPo9BrZmMc3pZEIv7WO7Fl0VOL3G1pp83bC2HmZ7G2VzvPKQKL+M9RLC3gBjDIFnCETFzG344uHjDAdnOTU8y8P7j3J9fpF3n341bU/SFg4fSTo8Sd+NEWVNtGk4W86YlYLu5Bms9KmtYtHBqWhIUhe0s8v0elt0UYZWMaFTTMY1cyOY6wXDSBHEPqt2TOkcdX1EXRZ0VUfVbAj7A6z2WeUzwtQRJSn9bkWQ3IafBaSLGrOaIfdSlonlVC9hK5nQlB0miliXJb1E0qRjgtVFunZJ5dLjmDDr6EyEaZdIu81yWdOLffzoN1tIEbyYY20NtpF4/n843SZWeGj2Ask0tyyKlkkWElHjrKaQMc1qidgaw++TMvH/YoN99epVptMpL3/5y7HW/kZExx/od65eOGSS7LBxhtKrCExOsUmIpcEXgrJ11JUlVILZjRXDvsIFEuEMvh8ew2FW+3TWoeQNoug0XlHSKYW2gtBXcMeddE89iZvNKBuLUwrfHUeHWD+maitC6VBC0LiWwihCKYkyn3xZkc9LgijFCY02msALKLsN2hQMk9NsGonTM3S5JtIecbaL8wra9Q0cgsHkBMoGdMkIvWqPCdHzNT4WvxEEYYgYn2VuSrr1klAEBKMxQni41QIZZTTKEasIrzNs1JDt3TP4QhBvnmKZpcjHniP67OMEvkKNYlzbsvy5n2X2J78LpU4gqzUeNV2rsMMdduOM+uAy65vX6bwOsTPGV4o0CZguF3jxiCwMMZ6kmL0A2uH1JrTrGyRffIR6a4K84wxHhxc486GPMvoHP4z4ClCm363kJifZPE/y3PO/rb83cUT9+tfSRDH5aIuL3/eX6E+GjEYB14slvsnx6grPRJSloAscSgbI9ZJ1/1ZmIsY9fxU9MMenozKlDFKMMPjS4pxjVnUcOY8bBxu2ZUWsNMnkFD09xmjJfqPZiQv6MsUXCbWzxFmIaSzaKYLz5/DGGW2lkYnPlhsym2tMabhZacb5nP5uD+GnmFaD9I5Lu4A4SSk2OYltCUyD7QmSaEQzb1khSGrFjWaNiwfshRmmmdEul0itUH5I0xZEwz5SpFDOwZZ4ssTaFm0T1nmAFyt2+x6bakUWeETpFm1R4qzFH+9hZlewR1dox9v0lcK4kIUHQdFRFTOiwYTUi6hv3EB6mjBJ2Iq32HcBR4dzBpMEIwzF7gC1tYV6/EvQNNQvvYd1qFCdxNQFaa+H8iTWeUTJkK6bYYcGtfaIp0tmgYeMJ1iz4PLygFgYev0xqrLkckXqJ2RJim7XdE1NObtOoTesq4rBjefZ2U5xeoWNEvxqydhpxGaF8UdswgytLVprZodzrBMkaU4hLFb0cOWSzKzwy4bVq2/De/55/Pe/j+h7/yxsb5P/8x+F9Zroj//R4zxMOsrBkL7ICBcbdF4Q93tUCx+cxhuE3HzhOifmLXY3IFIhRV0RYpGDCESAUCGD2YZcZ9BLODod0f6Vv4T3V/8K6t/8K9L/45/jHR5+5fvoxg3kP/8X+P/8XxBkGdWb3kT6dV+L/abXY4MYM0yQncTp+Dhe5cYLLNYapTuGZ07hnTiFiEJE2eEnPh0OrRsCqQiFz01rCX/tYc5fehz51DO4zz3M1n+0Gbb+lm9l/n3/LTqJjhl9xoAJOZn10MKnCSZ4oxxPluThiIO9MVtxQvL4U8g3vZpRELHQAVvxmE5DbDeU4ipBp5CtJa82iGyAk4JYpGQ9j6aU1M0UL2/o7Z6k6Aqc9dkzK6pf+DBadBTvehNeBZExiFaT7WzhZYL96RJrIkbhDgNZsMwr6hKqyhFFfdI7XoIQHyK6uaS6v2CmW5adx8i1xCpm6dfktuZmXRJiOZhf4DPXPo9HyrXNgsuLy7xidJ7eePIildYjDBKQOdY05I0is4bA6xPIkM3RBepSU0Q5WWNx2mH8CrG4SF720SpB9jVepZnOG5yUrOY3GEQxy8iSBRFOWlbFgutVxbpbYwrLOu/YGrw4R4RCNAVqdUjrPMxgQDY6Q7RyWONRHV7BzNZkW2cJ+iFRPGa2uMGvXv0Iv3bpV/jk/qd4ZvXC79g8pCrh28+/mz9/73dx+/mTbJoeQkwwsuLGakqRdzSeQJqaYZCR+BGBTVGqw0QSa46fvaTv87mjp5i3U77+rm9kj5Sr1qCtQzrHpjOkvn9ssHWLMDU2GyOKNS7gODe5XGJOnEYoBXJIm0+pqyUn4oCN1ngmwLYVQjna9ZSeynj7bd/Me6/9DJ+8+kliP+HBEy+nH4X4g4jVeklrDWtPY2XJVA/xru+z7IWoXsQd4y3SlaCyOdXWgPTkLut5RY0g7WpG4QhHQbK6DnKbJoRh1MdZi+5ajJmyKmpG4RbP7j/NcjF9sddWYmzNRy59HGMtbzr7EDe6FTJOOSEzZFURupCRP8RZw4YaLWqCNiCUAWo0QkR9bOeI5jNUWeL7KQd6w1Z/m6eWF7jQ3uROeStd3VGlKaGAqq5IIoHCh/Y4b9gPtulsRWimNGufOBnStDmh1eTGR4iEoC1oupxn2iOuLK/y6lOvJAlHNF3JUgT4C8Xt8V08fPhpLvZ2eHDwCoajLQK7pt1/isMFnDx7J0nb0dy8iRifQCm4e3IX9528h/roBqZzSJXRGsckTZC+YrY/5fD5m/RSRzaIybua/bml15RkSUPZ2+LU9q00VUduZ6Q7Yw4ODbNr+9zdSr7//J/iLz/4F/hc/ig/+Mi/5kP7H6Oz7ZfNcYfjE1e/vLXnP6fd9BSvOPkqvubUgzw0vpNnlgf8zU/+Lab1b37Gury5zJ/7+Pfyjbd8E//T6/6fjDlP5DRdmDLe6VHPH2M2v0GqPHwdIkmwXkXjbbjeXaOxlr3tk0ROsJyn1PUhAQNkeAJtBINkyMl+xmfWX6AVIXcNX8LXvOTruP3gC/zK07/IP37sp3j56A7uGdxP3D/Nid0zVKs11cbSzWoGYYAzJXW9pG18wrhPkdcciI5dCW1p6HoKLwkoD1e0QUQwOMXRlUvs24qo9tAVkI0wVYEVKwIvYTDZxheO0NX4LicYVESEhKM+YimIl4fUwwxZHuJnHcvBLl0HXmPQfofuLGkUsSkVXVkh+xP08hp2tY9Jt+mPQ0RrEbqHtRvyzZq20ezu9n5jY1JrjdaaIAgQngShwSpcZxH+i2A0IRCJT1V3nE0CKgFX5xXbHOHjUVSGVCj+y3C7v7f0uzbY733ve/nrf/2vc+HCBfb29rh+/Trf/d3fzZkzZ/i7f/fv/te8xv/LSMQeaRAjzAQnNli/QhoNWZ8Qy0qXJLFDaceyyDloHJ6UeP0QEQWU88tcq5a0noTZM+ztegQioSg0ujdAdZbgvntpn3ic5rEn2Jy/DSElvh8SCE1pLNa2RMrHEx6dbmhtTGcdvifxQ1jOG9IwRvo1bdfh4VE0UwIZI2WGcR3YjLa5SohikJ1mo6/ivCVzdohReM6R9GLOMCIvNcXqIjpSZNWIqJ9RCIOuNV4boj3FUEYQJdiNJkgsizaF1T6IGJVsE4Q+XH4O+/lLZM8/QXPzKp0TFPffRe9tr0V+4UkGH/4E8l/9S5592zdwcvulnHA1eefR25owGYzYN4KDwymxOCBKauJsTFs7KiPY2dklCiNsNWPZrkAmpErjLl6mPjrEvvWVJL/ya5z6B/+U4OKlrzi2LgzJv+mbcHlOdnAIVy4jV6v/anOnu+de6jc9xNFr7ic/czvjMEX++M+wf+42aq/PiTCjbCWhGTHxPVwUEliJUAMCFeDrBdq0yHMvYWg066MFbpnj90LEVoIJA9aeYyf0kTicktyYHSLbjji0GC+iNxzAUrJebuj8MaO4h7Q5dV3inCLsRdR1TdsIdK8jsI6uNQSxwnMpYb+ktALfZTTVc9j2FLYSBMMdnCdpi4IgTYnSlNXBEZWusaFFO8F23GeuDtidjIl9wUHuiDzBfNYgtaE6ukl26jyDczu0ZUmVrwmTBF9IXLU+Xvwnp5ljSRAMEeSi4bCrcWabII7oqvo3cof1eIg4vArlGE9IlBfie4rq0jXMeoML+sjMYnwfF0pEMsK3kiyM2I9DvCAgFh6rYo284xThr18DAUd37DJfTRnLFOXHxGlCkxeEaYoQAqV6GLcm2BnRu3bENGrYCNBii5W3IVcBW8NbKBbX6XpbjOJd/EGCrq6TjvcoKkO+meJHEE7X5POGcn0AYYTnxZjWo3Qhk16foBNkWQZhSH+QoHoRufGIjMSGAbJL2biGdNSnf2IP97UW97GP0jz1RTojcZcv47/0pdTbY1yxoBlmiLDHqWRC02jaxZz4xCk8JWkqi/YCwsRhiquY9hZ62ZjqaEXlQz9M8bwYmZ4h6ue0l6+yv5+jREHoJ3TZmO57/jTXvvu7OPvhT5P8o3+IfPrLgWj/XjLPSX/pl+CXfgn3lxXdax7EfPM3ob75m9FoWu2x6jxM1lDOWuprFdmeIwGwjiCWmEcex//lf0f6wrOoLz3Kq594DNF1X/U9+z/3s2T/7oMUf+7Po//0d8IgYH5gSMMhVZuj0hi7nfHc5oC6vEziJ3gvuQ/x6OcpHn8cHnwFlbZcrdYk4ZBDrfBNj7HwsFqxnhaU2qPyDD3PMJSK3KwRmwWZyKAdcloJlqage/+HCTc5q294KatUIJYdyhOoNCKdDCjqQ0TXABNklKKbGW45o7V9mq5CDCQyTZBRiLx0k1m+YJ+Ivf6ELRNyNFsySSJkFlLqNctixfsufIzKKd66/Vo+fOmjPDt7igfP34uUHk3R4uqayI9oupJuvaGee4ysT71u8dycWAS0WYYONK1zOJdShCUimFIVOXLUQwqLNTnrgyPaNMOYkkoJKK8yinYolpe5cjjlYJ1zKnWsW8GT1y4zGCcMgwhZrRCtoaksLk3oIokf9vDjjulyw/OzZ7icX+bSzZ/kqU9c4JGjp3l28TvnXiipeNn2y3n1ziv5utNfwx32HHvjHcKkYqUVjU7IspLVZp/lfIHyt+hHY06GUFSCsjHoVQGeRCYKUxka2yCt4EM3Pkk/ivmme9+CaD3ctIZA4HuSG0XD7crDlSXUHXgBJk3w51cwZYzzx0TREt0WQB8nBKtggG/m7IqWx3JDYiMGvqIVNUHXIMSAW/bu4B5xD5+//EXu23sp21lG8mLkThhKbiwqorYgDVIC36crcxqVMistY+dwvodxLULEHHWGDY6BCtnyLF5dUcdb+EaRKE1rGoquIPVT/DBitLOLnvvctns3v76+waNXHuUVZ16GUJZVOefh+WOc7Z0kzEY0CE6nI0hgdjRFLJdkwx3wPDAtzXbH+vAmbZwyOXcWFcVIY+gOD6GqCIs1e6rivu3b+OUrX+SRxUVO9O/G+n3oLJHXYI0h6XtIFyC1whYdq7ojYouRv6ac7qPjmsoTZE7irGXVtGwFPcKq4Gcv/SraWt546rUUGmqtKJuOXQzv2nkl19Zf5HPTL/JA/0FsY3HiON6oFgk0kqRxVIM+QSBojEHYCm0UkZS4ccZGd3i1wI8DiEL6wxH1zRfI2w1NOKZ2Myw9Tg0DBj2fpZ8ybyuGYQhA1Tl0ssd2ViP2jyANsN6I1yTnuOPl/yufP7rKM94j/MxzP8Oj08d+R/dF3894+eRe7hrcw52797Ab3c/Jnbt4+ekTDAOfanadV25rXpa8jh+99CP88yf+2ZdVh3zw4gf42NWP8pcf+Et830u/A2sLumCL7fEZrhU509WaSRLgJT6ltswJEeGEYVczjmMQhrzZoWzWZNJDbjZUJiMbBggh+OL+Y/hRxhsnL6U+usadwUkGZ9/Jjz37s3x0/9OsMLx7+x5sZ6HcULfg7+4SDXsEN65RHqzJw47OdFSlpXQQTIY0saKbGeCQzoljBtFa0+AYR8BmQYxgqxdQC8mq6AjiiP72hHK6xnkp8dCjWB3STK+jdvcIJlvUiwZ95WkWNw8Z3HICbzhhR8RQzVlPp0CP3iSmlySsqw1RPKBOxoija3hpibO94/jBLkEbj+nsCF+O6GcBWmuapkFrjWhbuig6Jp8bDb7EtgbP/w+Hro02aCUZ9CPGxnFls2F/MScIUvyeIwqPU1l+v+h3ZbB/+qd/mu/8zu/kLW95C+94xzt4//vfD8Df+lt/i+/7vu/j7//9v8/3f//3/1e90P8rKIxC0l5Eu+pQxqACn3Jzg3nRI8yGqChh9CJFduAZVnWH3zlMozm68Cw3py9wGCuS/pC5NvQ2N0miLVwtWKsSL0gQZ3dxEjYPP0J9evcYrNRLwRPUzQZPdsSqjyc8GtOgnaYwgqFUWFqckAgvBJGjiNkUUzpTMUrOUGmLcNAVa0Reg6+JyoKNban62whRsSlq/DBCS0nsOoJyQzlKueEk882G/TRiJxrSbz0qT7LUhn5Z4nsRhD2UvkHYrMm7FuknhKt9ql9/P3zxBZzx8bciDl99H9UDt3FifJolIeWrvpHdtSH+zOcZf/BDlN9qqMN7cSqib6a4WlALRaNTzt4yRuoFJr/JulV4wYRB5GObDcvZTbwoImosNrbw9At4V68x/oFH8B//yg/zTgiqP/Ie8r/637HfGzKZnKA/zFh0GrdckV27zPLZJ8g+/nG8T38B0UtwixXezQPUVzmJA45hVa97JbzxTZivfxu85H60MNj8AtszR/zBX0YrSffyV3Ey9jg77rFwMJQBQ+fQW0OCRmOkw0lJlN+kHYzotnrsNnPWagtyD4o1pUnxbIEnfBpj8QW03YasLdndSilX15DJnTRWsPIqzDJnvDdE+QOU0JTlFG1yUBHKEwgh0Z2mrY/NiAo9XNmhnaJuKs6f2uFAZ0xnlxkEZ0kmp3BUVIsFfpKgfB9RtRQGjKvpjcY4rekETNIeVV0z8SSpCqmNZbHpWGuJ7Cl6QhH3BzRlQVMUaCEBHx1FtIDfrpkMBQ6Jl+dIoygLQRiDCgJ020Dg0aoQL0uIpE+52tAbDBCLFdX0CnE2gd6QdpQRbGra5RIvVBgpiHohY5uiO41UfZpiyubMmFuCCJdm6J1TZH4f33bUqqNe3iSUIaHff3HkfUBBpvCjgLiruTk9wIXb9PrnKYwjbw2l2RAkA3wjEBzDzKzNKZyi0Y49GROqAtHkECq8ZJfCUySZIxLQTwP8TUU0nlAVHUG/RzJWhB1EJuOgmCOCAcv8gLw+4NTgbuo3fT08/CTdr3wK2xSo3SH2za+l3r9JsN1j7QVsBwmhrxCjMfn1q8jNFKRlndeIMOPE3nmq2WW6ssMTC5SVaNUjCMa/MfdVv488cxp31ZEtZhhzQJcMceuSbpjQ/LH34P+R76L93CcQ7/sF4n/3AbwXvnpbhdCa4Nc/Db/+afjv/ybm7pdg3/JW/Le8DfGy86RRS/X0AcsfewR58XnCL30R8fAXSJdL0q/6ql9Zsqro/YMfwL73x6n/6l8m/tpvoXOSNjeEkwAnG65XOXruccpJNvfdy+i5LxE//ijNg/eyFcQsraEfdhA4tugTlRtkmhLXjuUaxj1J4gRSTcmL53BzSXrmAeKmRbY+2ZNPo5+7jL7jPOqWO1CNJadCuYbdndM4Z9gUR3gEjIMBhXBU0znVfE21fYJQdURJhBWK9swZ5BNP0axrrJox6A9ofKgOVwQzzejkDq094IXDJ3lmdoHbe/fxQHIHnxef4OL8AmVZ01LRlQZf1DgRgowQVYd1DaR7dOsNJl3CMCXofLbTmEomdBtHbCR5r8IrHVInRI0k66XU44AlEQMvIBoEZEPBoH+ayljqWrLt9zgvNhSm5OkbFS/ImtMDRaQi9pcrHr/0KR7RV3nhwiGH9ZLnNxe5Vtz4XZe1+tLn/q37ed25N/OW82/mzedfT2siArfEbkqOrj1Dow9YaEVdpwz8jkDFDBysvS2k3+NE3MeThmGvpm4szWqFmyQIa6HVHC0OeXT+FAud8y3nXk9koYs80sBDO0ssBMtOcyA8duolLshwcYpbXyXsRVh/gpf1CQOfejOFrR1yC1ZIhtkWzXQfV24QvRTjoC5KBoEgVwGrzRFfc+4t0Pl8w61v+A1z7ZzDVmsWqyU4y972aZJIcO2gI/UdJ1WCtIrGedSNwdeGVmv6sc+2BU8l2HxzTIIOTxAGFbLNKcRxqknohXjKpx/H3Du5m1+79Ks8m1/mVcGraFc1H73662g67hrdS+N5nI1HZEphrEWHAU3bkixXdOmANIsZ9E+xPFywaVqOyhXbvkIZh5Ae3mQLs75OJDxuc7ucDSe8cPQsh1sPkWwPOGkdm0VB0IvwZHe8IRgGdNZSdpreMGIwHFLkh0wXl/H9Pn4yptc5KuvTxDG0Cy4Vz3LuxP0EyRZl1XFyJ6VVmkwUhHWfbzRv5aef/xU+Nf8k3+RezUw0KLXDrpYsNg0nO0Mdxpi2RjiPaDig2zTEWY86jmk6y9A6TGcR0lEucuLYYPCZzi0MJEO/pJeMCFNFT9fkXYUUPsIX7G8alOdxUnlsooxkb4CQNXmpaaqCiehz19438dde/d/zy5ffz088+7P8wvO/yLpdf9k9cd/OfTyw+wAvZcxDW3dxz+0PsXQ9pq4iDXzqmaCl4fJqH9XfwgqfyNPsJj2+947/O996x9v5Hz72P/Lw7NHf9NqlLvmfP/+3+T9feC9/53V/jYfufjv9Xsaw6ljnkma8hcaj0A2R8BkNM3RZorwM4Xlkfc1i5uiHAbI5oG06wmSX1WLOU9PneMnOXZw5eSuL/ae4ejhjU1Z8+7mv43P5Ezw7v8D/5wv/B++55Zs5NdmhkYJs0kfFPl7aZ3mwZqs/YFa0HJYbagKqqWF7NyFYHTBSEf6ZEdYZbsw2jPs9TpqSg/IQQx/VO4HVC2TXYIRi3YI1Eq8rGU5SjHeSa5ucVR2ylzVESmKvPM1cKq55L2FkAgZpgAu2WM+O6NqKplD00oSi2tBVFTbexddX8fURut1GZT5CKXSVsFpPmexsUzc1Wms8zyMGMIa2bamtxasbkrSPay1OW8SLaS95rfE9SZwG2MawW1dcLmqumz47fgP5dZLRffj4v6t19veaflcG++/8nb/Dz/3cz/Gud70LgI997GMA3H777fzET/wEX/d1X/cHBvt3IW0sohfTax3L1ZLRZAdPL1gublJpw4lkANoBgjDpYZopO3s7pJHi2gvPssAjNkOCtWQVaI5yOC0FGZJl7SGzENN02FtO0zz8KN3sHuKdHTzfJyeiLQ5JswGRdwylkULiuZbaKjpjjsshgwgvUJS1ZSAVy2IfP0qJVMa0aBG6opheQyw8ROZhQ0sYJxTrFeNkTVmssL1TYDV2s6RxiptJwqqaM+pvM44HkOesKku2vY2m5vqq4GzqIWUJzuL7Ae31Q6IvfAD/ygFdlCInZ3H334e7Z5vZhSfxY8tKVOxfKandktW993PKBGw//xzth5/iyjsmBP0JEz/CLA5pZh1D0SMd7KFKQV7ts8kbtnfBFVMWqxltfYTTFeHgHMkzL+D/m58gvrn/Vcez+do3kf+V/5HDu2+nXqxJanFcJtQeQ3RyoH/mLGayS33/A0j+Cd0tp+Hb3kY3vJW6yBkfXCa8vqB+5jm6514g7WXIV72K6swIdW6HbOcOZLMBWbGSkn4yIK0r9LPPU+6epDt9hiRxXF+tyFVM38Kiq+n7CtULYVXTLZe0qxXVmdtwtiCN+6yKJaNhH5WMKLqaWQnGeJh0ROK15PMZg3hIL1qhioBkfJapSansDfp1TqIFtXWkQYiUA3y1QbcrrHAoP6ZtGozJCaIA3ViqZUVdtihVQaDopaeYLZ6niCeESiNrRXe0QCifIJA401J17XG+LyM2y0Ok8mkrgS4rJmGE3w/xTYtZaoLxLviWWZ7jq5DYjwg8n6bYsJwvaGSMiuPjjPRmg00igjQgEzHVpiVVEpWGdHVNXq2p2440m5AECbWISSoHxRqb+QzuvI9aa8qyQNUG4xwmlOgWnBT0+xlUOYebOVIossE2xbvfhfEVYdgnDvqMPIEIFJt8gQ0Ei3qBJzw85+FEhOdpbCjIVI8n5wt2ooa97RE3Oo+ba0uEI0m3cbrCFQ1CO1b5deatz7Y/IKSlG0BU9+ilQ+T2FpVtGLgA53Ec+eMMnSvRrSMepFhboFTEJE5womFR1igbsixnhOUKZA/50EME738/vorhXW+jDBqkKlk3AWo4YhIdMxtE4LBeTTW/geyfRqgRiYRg0GLLU6AjXB0ROse6aFgwIwwUnlJUCLQfsHvyJKVZ0a1v0CyO6HKHGvQxrkKoHublr2J510sY/s2/AY9+CvmJT+D/0keJvvBFhPvqRsl76hnip57h9h/6YdoTJxAC/Bu/cwDPbyV57TrJ9/1Fwjf8NDf+u79KNdplv57iuoowj/BtQvD/Ze/Pg27LzrNO8LfWnqczf+Md8+asTCkHzZYt2Vi2bGEwcxOUCwwU3dB2UzRFtCNoqroMBFXQNAVBddFUmGqiisFgGyg84FmSZQkplZJSykzleOd7v+mM++x5WGv1H5+wEcbGlt1RhF3PXyf2ObHP2sN613rWet/nSULCvYjg4V30q9exnv80ydVH0XpEZSt8y2Vvb4A+SakDC4cJpt7gtBGO7mjK2zgF1N4BVuCRlnOCexuCn/kMauJTf/Dd1FnPaKLZWDZZsWXXEfR9ybraEIp9hgjurBdki4JBMMQb+IjaRUqBkhb55QcZvvY6u1vB9pLATwJa4ZFMeqzlGVaa4+Lw03c+i+gNH07ehduVvGf/CT4yf56Xzj5HcsEnjMZ4jsHYCbKqsLY5ieuRlwWxvaX2ewKZMHQ0Rro4foIUPc1yi2cNzj3LFydU0ymjy4eMlODkxhGBFEjZ0EtDabnUnaTtAgJybqqU1811PnP2IveOzjhSp1zP75L9MsrFvxb4ls87J4/z9PQdvOvyt/Ds3uPnu1BuRNG5LFclkDMIFVuzpFRrnHaIHl1l19pjNoioqjVby8H1PQJpIy0HbRxcp8W3DUb15H1FtxUMfIe8yfjY0b9mGA15++7TbBcLmnhIEkiE7SEazbZT3G+2JGVJHAR0ZgNa4UyuIPoAYzs4sU2ZvU61nVMEU2Ip6BuDskeE0RrLpGyL/nxhxnScaYXrOFz0J/yJd/8haBRGG1Tf0WRr8s0GO/AYeRFCV7j+jG1oUMtjrlyc0g9juqIi9jya2jBRMB64UPQIee7/rlZrkmCMPZgiqzm6c9myZeyPz4l2EHKpHrGXHPDS4lWQFnnT8NzxC0ThLnuDq1z0hsTO+cRd9T2+lOjBiOZohZQF7ixElyVRnOB6IdtOsshWzHoLLEnfbZCBRZBcRjHkqZ0n+LEbP8HJ/E2uxgPaYMSq7jlMBKCR0kdIQaY0GBhEDkIKnGiErDeYtiRXxwy8Q/bjmE2r+cnTF3EEfM3orRznDWFgsxMZ5nVBL13igc3T6q08d/8lPrd5nicOHiQS++wlAwbZkpvLjHp3n0BIms0psjlCywC7d1EIzCRA6BJHaLLVlr6p6DcbBrsxZnhAdbyiS++z8SXj2VUsu8PTDUZXbKuW1FSo1mGnqwgIWAUVXTJmqDYUTYzYZowGA9ptyen8Ls/uPsNbZo/xX33NX+Jnbv4kr+evMvV2eXr3aZ7df5JJMGF++jJydZvIfZTav8hZviYKXcbCwUQR9gDulBteP7vPLAjpWou+OGaxbnj4kSf519/5Ef7Oz/+PfO8Lf43Nv2NH9ur6dX73j/5Rfs8bv5O//M6/wEV7TNs1lMpgGU2keyzbQkqJhaFvcoLBgEGoaTqHHk3drjDdMVbd8YnTO6hG8e69t2G6Da4fk5pb6NjmYO8Z/nD1EB+pfoqPLl/h777+D/g97u/jkeAqQijKwlBqCzex8GhoiprEdnEF5NkSv+zZmfTEgxmWclnKLU2z4NANsOscx/HJTYDTabTiXLBUS5oyJRmNMfUxdWkRWZLh7gWabkgpekxxE1GUjC5e5n5fQFNRCoNt20gZ4IVb2q5AiB2SwGXbVBSEDJIhVnWKah9GaxvpWaQnHm1RIknRekoQBNi2TT+f09Lja4suDKmyHMoM34nQjcKyJXV3XqoyDr9Mnp0e3RcEeIS0nL5xh5ENFy62EP0WJth5nv8Cuf53MRqNUOo/rJD5v+OXYlvWLIuKoe/RziXpfMUgHuOUWxYmY+goZJ0QhD59ZZBCY3mSKrtJqjaIyZSL4R6m0RzXc1KrJ25aBsbQzwvW0iJxQ+S1t9B9+vOIN4/xrl5Fug5Vb6PUAtk0tJ6DJT18y6fqK7QJ2FQVWilcL0JGElMZaGp6ofB0SF139FVOf3KD9m7KyIHIWJSFj/B2UJ5C2D6iPubm/efwGBA7EZ0uqJs1UxlweXYV40f01Qna7ai2J1R5Q92ACOZMYwvuHNN95KdwX38T3ffoJ56m+NpvwhvOkCrl3sk9ii7HLwS6K8HMCMsFnefRft3bcXeGDD7xBfSPvcDZ/+Frud2XiN6jc232XYk6vYMlChrZ0KsWXZ+x1gV1scUyLdbGZ/J9fwvrH/4vv/wk/Z3vpPivv4f54w+i7ZhA2MjaIpQ11t1b9MMRFgZjBCoMcD0fNR0jH3gM+/Qe9iCka+/T2DHm8bfgPT3h/oOvoxf3SS7ugp/gCQ2qpi1yZDSkzs9YtAVufEj3+U8hlOD0yjV80RJPdtkWGX5TMQkSFm3PQHuIKERscszJDZrQogo8YneAERqjc1wzItq7hp0usMoNCymZZ5L7VYpqYLLvoKuGyBmj44hxEBFrh8ySiE1GP0oYOxZaGzxvguw6tL1Gigwai74D2zXk6571aY4bSRq5ZrXusLWL3zf0zZy1ltjCxa4zqhvHuI5D3Z7bMQ7HF+jSmnS1Ibl0mUbCMBS4UYRGU6YppuoYTKfYnqLp1vRqyCLrwRhso2nsgDiJCSxYpoL14hgrtPGiQ1xPkveGrlJYUqB7w6ZeojEMR4fIOqVIBjSOA+ltvOkh0nMJO5t1XtBYDd4gpMy+rF3ggC1s8BSmzLFMxGRwSLmvsRFYGdhViT2ZoPuOYTgmSAa0qqVWNds8pWsq+rrEtHNSM8QoTVKt+FvP/VMG3g7vPHw/nvSRZU1fpVh5BrHF0mjsxGV/PKVpMrpcoIWDrmvKaokdjhj4Y7TRLDYrOsdH5Vs0LrY/pO8VlnXueTkKYpRp2JYNnoo5OZ1jDQ3uO97OYLk4t3m78BB2taIetZTVlt16jElquv7cpSCc7lGdrCkKQzKwEWKL0D4m0JzN5+weXGCyP0NVLa3RBFJSNi2rtiOUgkgK6mBEs7qLalZIPcCdr9Ee1J6LZ7v4vk8yHNM/8Q42T1zjzh/7T9mvXPx/8cM4P/ZjuJ/6FKL9pfWC/wbu8a+NWBshqK5cpn7r0+TPPIV6+knUxSl7f/v7iP/B9/+SmGF9/ONc/MQnUL/zt3P2XX+CYTxgZAKCacTuhQNMM2f96D7+Cy9hfvzjCOdTTDqfTPbI6ZR6vIPj98jxATo4wJI57nAXwoLeAs+9giKhOi3YdCX8zE9ga8P22bcRSZcqiOi7NZ6Y4CQDNtWGdZlSVgqvk5zKDLcrCZQF0YCgLFn3Ln27QnlDuskOUoF74xj/ICJdnGEnhwRaY0uFCGxe2NwiVQXvvPQednbHJJ7NB8IP8ZnP3ODF+U0eHz1OFPb0XYtxxtSthSk64nDCojkmnuV03j6TFhzPopQetYYw8ChMi04bYm9M2qRUXUfV1ARxRNvULF3DrmmRVkLfGv75Z76fn7zzk3x28xzzevFrera/EkLL570Xv4b3XPw6Hooe4Z3JVYQlyeIpIzNjagukUyG8hkZuuV0rIiFwGxsPj1F0iOcYYm+fsePTNAVb1dAKmx3HwRsMSTPNQEq05+OSol3JWjWs05aJvctzqy+SmZJvf+jDjKY7VKs1RVETBw5l1xPYNrt9x43VkvttyYODiM4ZYfChEhhbIbSFZRyUjFmujnD3hkhlYQAxCIisKe3JfbbrDlk36Mhl7LlcvnwJ3VZoFChNs9qgpcbSHbU0+EHExLIQX9YRSHXKvutjWQLH9PRCI6YhkbLQ2ZZWd7i2wJSGxuog22L7Q2x3StumhE1KhiE1hok/wZKSOPB5YvQwP51+jFeOXuXm+habvuFd48e4Mp4SmXPhJGMMTdMw8FzWhaIKY0ZWj8ozTF1jTSbItmNoByyWZ6yMZjgIMX2BFyUIf4TsXZ668k7+1cnPc7s/4y3pEr8uwR6x3G6xLY+pY9MqTdkoEimxXQtjDHmbMxjsUW9TNuvbjHeGuPYYKy95/vSLHIQXeTKcceT0ZLrgKNvgOCO0TNBmDdLwOw/fw/9w65/xoyf/mj/5lv8M01i4wiaRirUvuba7Tx26qDuv0yxv44cX6fFoDNhtQ9OXmP68n43GHs5kh1VnMR45aB1wVJWkecp0PEEIiejPqPqYdVOxJ1tk1uIkI7zAJmu2jCb7tOUSTcEs0TT9HqUqGakBdZ7iJyFfu/d1fPuTv4NFUeE0FZNOsC3v03VnDHYvUIjLbOY5fqjP52KVwUiDi8O+E3Ijzbm5WdMqQdJLZsKFAggFf/TR38fX7H0T/90Lf41/cucHfkmmyT97/V/yUzd+lr/wxJ/ljzz4B3GWG+xRTG8MzpcXXZwwos439I2P7UIQTLAti6pxceMlQq351J2P4aJ4XPgcz1/h7noLruDq7mUsIyn9hPc98gGulM/yQ6//K/7J5/4xT+89wbfKb8XIEUFgM/Udzu6dooY7PHlpj0oZ7p+esjpOUaGFiDqCe3fZlEsmkYXVN6RiQOQIit7n5Ow208kOddsg+xR39SZq/zEcX9BmOY5vGI+uMN9k6GqJlg29fxnlXWAsO8L2FNue0tQ2ZaUQ1oK+aul9gx+PIEvR0kdNDuHsBVQ5p/MPUPQs0xbPskn8/rx8DNBFQVac0QcC2gjf8xBJTFPXVMLCNTbCk2R1j2dL3C/vZjdNSlNW4HRE6Zq6AC5dQrrub1hc/t8aXxXBruv6y4bo/i/5rigKVqvVr7thvxWR+A6uLemMheVFbNdzLC+mKxscq6Lc2uTdCXEfscnO1W+Xi+s025ssWxfP8xhYFs4woKCn1lsa30FGEyZqQZ5nyL2Ieu8Cveqw3riJ9cH3ktc+LTaeNSYwNm3b0JqUwNtB9x22rFiuMsKywbM8+jzH7nKKe2usJMSyt2xMSVuvqF69g11pkp2IaHpAl645u3mdzPexownDIES3NaUjGJglNCUTv8PxJ1TtGqfMmViafiA5vX8Tk/WIVtDeWlG88jrB2RlohfW2R0mvXWb8zt9GrkLUZo6ROVXZMhgNiIa79NInSDzazYTYr3GLDcWTT9CkPdGXvsTFH/44N7/xIbrGY2eygy0FOi0odEaZDJjuH9A3DdWmIChqov/lnxP8/e9H1PW//wE+9BDqL/8ltr/9mynTIxIvwbLGVJsS15Qk09l5ZkAUEkQR27ZH2RaeViy2W8aPP4Y1nyNu5YhDB1eckakQu6qhbVFOx91mS1jmyJ0HUAL0eoHTWRSOA0YxaAr0F16hHCVYDz7KhT5lN7iAkjFmvsGySoQU9JaNEDa6OUPnR9QHb0eTENg+RXUXVzpIAoQXEswuwkKjyxXzbsN2q3FdF9fKsO2YHIUnYOJouiDC29mn2WxZrRNEr4iMwvckUrt4yR5dvUGZCisQ2E7LdlvgxprRgU3WCIoShtMRdbFD68f4o0PqvsUJhtiLJUYGRN4Uy+2JvIjjk7sUdYtRkNRbRJ+RK0nTrGjTLbQKJTSikwjVEDg1URTQ9NAozWQwYByfZ23U0kXlGwJhATbUFa3uSRuNwqVtS7abFYPpDoPdQ5qzEtkXzPMWo8FODsnSnIk9IPADimaJZQ1oy4ZoEFP1ms6UCNsw8yNoJI2xiN3zVMfF5ozIlkgh6JUijBPoz8XcXNUj244eUJ3hngWrtiEOx9zRZ9xZzaE/4dn+EubC43SOwYmHCKHIhwNaluw5FcYURNEUYzoKlVGXmmaREl89V7eVSHxjU0uB1Wgsv0XrCgApzwc/oQW6aejqnMPdSxRVzqKtuFfVeN/8TYR9ey6AIh06f4brLhHFXSqnwRscYlkhnmezOinot2v8oaFzJZttR6FKtNKsVqcMdycMooBt3SF8h87xGEUwkqB7xUhKyrO7zOf3CS/uYVcN5a0j2njNMDxA0VBVJdUmoxUK26tZRx6j3/d7KD74jbRnc5zPfIL4c88TfexTiM2vTReh39tDvfVttG99muBbPsjqyQfI8pZ+A37iUUQ+whec/c3/Fv1d/znOn/4zhM996ivOIbTm6r/4YS595Oe4+Z1/kv73fBuj2QSpFiSe5OTSFbbf8F6cVmH3DU7lUC1zgr6ivvEG0rQIeQfTSYKyJDAVlq9xBwnam+LGU4peMi43mLMzVl/7LOX4InK9Znb5GU7vL2nETa5cfg9NnvPqyW2sImI8loz3B+ijE7Rtoac7uKrCtJKiVEzoqIMxJRL73h0c+QTzesHYHxCLLcHelNJ2+YnXPkbsJ3zT7AP0TcrWjrk82ufx3cd4/vYLrNueC63A2JK6XbBdbUEpLKPQXkHr20ycCRQpfTQk7QTLNMNvG/TpAiV6ZlcvY7kn3Dxes1hI7GRAJxrO6jn/+sZn+cSnn+eTxy/Q6V++Rv5Xi4PoAg/vPM5bZ4/ySHzIk9aEp5PHGD32XkRfcnT9TVRvqCc7KN2wdTs63dNuUgYDD8+BgSsYxDsMwyGhUVzffB7HdAyVpKMiw6AciVv2JHFIMoi5t02pWoVwPVxhSLcLOssjcQb0reSF9EvMkhFP7bwFZdv0WMSOzSQK0EVJVWwZ5MfsbFfcKW2oNkxmPaZs0ASIoEf6Emn7NM6EZrNkzzpGTC7iRQ6rXiFxWbeabHVG5EccJjNmiSGMAioUTVmgqx6JwJ8O6LOURmsSFG4UYw0OuHV8ghGKq7MZlm3R9j1OWVD7PokyyHpDk1UY28LF0JkUrysw2RwR29jCo2/nJE1B6vhsqzVDd4BrFO9N9vnJNuejN36Km8UJ02iHd40exLcNKI1RmrY/fwd8x4WyQCU+Xijojo8Rvo+ZDMmO7lLnS6TWFMqg5ytGwwjbH4EbYZqW3WBCHE5J5ZYcxdAV7HsOpphT9gnaBFiuh60MoXvu91t2JcooEjchFSlxtI/pOqryhOdufYG+b3nq0vshEHjdMZXlklkhAwRlPT8Xsqor9vYu87byWb6weoU3qus8zjXKQjAe2NAG3wABAABJREFUj7iXF2SDgmgyZmseQt58iU7do7b3qV3DwBVYnosQLp0qsZOQVLnIdsvQ1az3rjJNTyGbsxYejtOgjcFIn17ZhH2D42hq1gztkrJVlOYiHR4impLYFZ5qqKSNdm0if0DWrSjLjmjhYJqSanWXk+kupVtgFHRmiigzrDzDNYJaa0wfYTuCMgWjW+JG8GYjmCQu7s7j7CxPyfqCUodEkcuB3OMvPvOX+KOPfiff84U/zwtnL3xFv836nO/5wl/kH9z9Z/w/3/oXeMe192MlAa7r0jQNliOwXYe+rbH9mMANqJVCeAG+2OFMnHBcnPD04DLzxZc42RzRxBOuTJ5AVw05R8jBPq3jMYli/vjoP+OfffGHef7si1w/u8V3PPb7uTAek29K1sJjGHskuqEvey4OQ2wvoWgyWtlTWBVFqfCcIVW3ocoXuOslxjugCCvcJsIOIybUmMhlffw5oukBCAdlxYSTEayOKZd3mY4vkjsXSJuaSXxI16zpuwK3t6jbNXXb0LY9XXMbDLgGjFSU4S6B5SMXN6hljLYE2nY5SPawdY3WPUJYZMs7tGpDpzykanFzG8uPCI2h8xyqtCJb9ujAI/bOFzP6vqJK51SLUyqjUSSMp0PCQYz+jRGX/48CXxXBfv/738+HP/xh/vpf/+s8++yzv3D8zp07fPd3fzcf/OAHf8Ma+FsJjuOwM4qxrJCu6SjPCvquJ/RmX/b0i4mHktN8Q49ilgSsFq/Q9hojxyROQGTZaN0wi0NO1i3LcsUonBFMd6hOT0A3iCRGX7xMMF/gSkEmfHSbgvHo6o705AZaKerkDGSMJQu6ZU4rPaJYU7QlfiSptMCLdrFcj2W+wt5kdMYhvDqEy3vMgxn95JDy3mtY2QY/XyNExMCZ0eslKq3RxlAJj863GGGIsozCbmi7nnhdEH7pNt2LXyLULdZoSPautxM88wheZGjuHLHI3iSrQqw6xxMVodAQuCBatlowHjhEGGzXou82uIueoycfZix7Zi9/nos/WnH9mz9I41qIZILentBqhXNSMVxBefcE74Xnif/e9yF/mcm3mkzY/qk/SfWn/jhyGGKVNbEb4vhjVAFukbJar2lGQ3YHMbIskWGILQStUlAWaK1x3/F2+o99nO7F14kf+Sbc7h65arg7v4Go1xwPAzqpudjAoG+Rto2UPc5miSdrRruHBC9+kXy1Qb3rnXijGNc0lJszRDhjEIRoVeNJ6F0HVeT0xW2Em4B/AL2FpXM61RI5A7Sx0UYjLQtvsEcwnyM2d0iGVxCmQxqbRgxRVsHEtbBMTasskslFQnUTpTZUrU3b9WA6YilxXQ9XTpHkCA+2aQsiYboTYHk1bj2m8yxcK8KZPUJaLAjEmHhkcXZ2Rtf32I6NPYxIYuj6jlYUmOEAy3UIuhbpesggotclvh8hI59kbxdpSbouQOsG102IxC91PHBkRe3GhK6LCH38OKGuaqRs6fuejII6yxiYiMbforWNny/p8hRpD1GtxaIv6IcBrpBUuaEyDWPho1RL2lTYVscsGmNMgy42WPGYZrNFWwbZNXi2T5evsaVGlh3nnksCIx2MGxEGCUVWYIsJezrF9IKPnN2iMDUYzbrJOQwTSj8mDiR5npKWOQktvnSRMsCyQpJEU9c1a9kTZBX+lwc20zQEtk9leuoexoFH2y6w7SFaG5qmpO97HG1w3YB4HDObDPGX97mRnnF9G3J1OiLoSgpdo1xD7AwJPIkuG3TQYtsJedMjBiOc8iZZ2tOOE5peMfRm2BfGnK7vM18ccbBzGQEcly2RbzN2bKQQWLbDxPNoLl5j+eYGY7fsXbxEsd2iTEl2dg9te+gkRls2g2iPaKBY1RvMtqFPN9jDIeUf+B2Ef+a7aS2D/MTz1N//v+L++I/h/Tu71yYMMG97mv6pt7F8+DHWj78N/+pVLAuEHZCPLJxAMlQtx5s5rkiwtcdZD77eUl64iPsDP8r0x/4pyff+13gnp19xfitNeehv/VXaH/kB6r/4Z6k++PXMjYVwLaaPvwVpCRbVlrkl6fVlRtOQqj7icnABse7IVyc4R7ep8zWOAC9v0EVHtF5ir9ZEWrOc7ZM99CDGi8i3W8ZHd7H6mJ4t8/V9iqKnyhuuTfdJLvlYqiItlsQXr5Hs75PfO8KzDU4QMR4FpMahuHSFvbO72OGQVXobsbxB4CZ0gyE/+uq/ZJUv+fAj38JAenSdYLXR4BzzYHSVz8oX+NL2Za7472K8u4tZn9HUAhNAX7yON5LI4DJ+mdFXGevU46yo8K3zXREvGVA0DSdFzkgkqPIuP/nac3yqfonn5p/mdnnrqxqLfdvnkfE1Lto7zBjx7NVnuHb4NLpKKOoSe2yYp7e4fXqLSm5Im4oHXy25tnMNy3Y4US3GtAhVMAlDAj8hM0DnUAuP0K2JrYa8TamMQ9e3xIMZfb6iGo5Qvo9VLLFxCZME0yl8BEVWnxM26ZK2c4R9hWtXHuAHv/hD6F7xocvvo81XqE1Guc4Zew6GCbHqYXsfTxdcOrhIuhXcXGxI5zmX93YQ+1NkXWK6Dh1GVJ4DOsHLlrjTfZSxWJc1q/mWoi6ZJAFRMMI3Lo7bYvoWP4yo8gxn6GH1FpZSzLcrhOqI/Bgr2YUONqZl6Do4YYzse6wool8ssTyfqiuIvBAdDKkbaDV0Xc9gchUcH+MOsRwX7QWYYk4iQraWTWG7RE7E4V7AxcEFXkxvg9T8voNvYNdXtNu7SPcQ24ppdYvjOPSFIpSCNrCppaZRDU1dYjYGCwtfO9S0tPYCUzXEZo/GRDi9Qvc9W6V4eOcxXj/9AmXfshSKg7HDMB7RbWz0OqMRKb4/wApdtNGUfYlv+zRNgzaa/d1L6Kphc3rMx298lJ045m0XLnHWt4hOMpEC7Y1xLIs2f5PjfMPM28UkEd/2+Ldy59P3+dHXfpxHHv0OhBfgeAFRtWW13nL5MGIThGSTA+LNGWU9x632mF24RLrJ6coMz4dNH2IoGFsd+AP6xibauYDc3iXb3qDwYwor5qQ5pSokrTdhuHeB8uwOSeiQio6jzS3oLJwgxB7uoLYnRMaQ5ymBF6BMQxwmqNwwNAo5nHLm1WzbnEN/l9noAoiOzOqIIg/R1DjDMbZvk52mSGkYzhK8omSSSBSKKhrhtjlNX2KbjtAklCOPp8bP8vMPf5zve+P/w3/5sb9I1mZf0bdfXL3Et3zsD3Ll+ct4jof9ZVFfx7KwhERog+v42JZPq0EaiS9gXi1J6yWvr/f457d/BEfDW8aP8I6u5tELTzEaHYIQ5K3LsigJjc8Hr36YTy+e57P3P8bfffV/5FtnX8PEfujcam87R9tD7MLA3owrI3jtjfucnaTMpjPGe7uI6pSNTOhMg8orQqdl6k7YbNdcjkf4ukXsHLKhpytWuMaikxayWBHUZ5TKZRbs0Nkxg0rjYdG4AzZdgdf32BYEuAS+S9aXbJZ3sKwZge9SNJK5NWE3u4OlW2oV4CcuSRSg6ut09ZxmuyDf3KAaTNj2Gp8MnVfE/R62GxPYNibyWZymxBJk7J5ncZzdoD++xSavaYaHRPaQ4d4IogTL+s1h0QVfJcH+q3/1r/K+972Pd77znQRBQN/3TKdTNpsNDz74IN/3fd/3G93O3xI4qzKOiw1vuzCmjEPyTcBmkzEaDoloqJsNB7tXWRcNdtKSFdfpqejdy/i4XBjvMHAtirLGVhmT4ZSj5R02xZq9yQFWMCRbLamqiv7yNZx0TfXmfax3XyP2WgZ2RJGeYi0qgmCCGlgUviLTLXIQ0wdTrIGHSrdIZ4QjG1wvpuhL1MkxnK0RuweIUcgqGCAlDLuKA68n70H7+9zuWoYjxZ4YM1/BRmoSP2ToSczJDRYv38S9cY/pJz9F9OpryLqmC3ya2QT30UdwFinqhS+ixyPGuqXzHPzRZYpJQjRNqB2LXtRU0gZ7h93YQ8uCMq2QcQzbnvD+XQJjIYqa8Q9/lHf9+McRkYszn+PcPcZaLRHqXJnyV0pW0VFE/if+KJs/8J3UkaLbrpk1gtB16U1NtVqRaUW+uIeObdo6RbkOY60IpcQejCiKgkR1OJ5PbVnoyRjxyqtQfx0YH1FtuH3nPkauqIOYsQqwh5cIQoc4nNC3grxoMesOdbom+/hnaNoO9dADCE9he0PK9QrbivBth6ZOCY2g8HKqxXUsJNbuW2jbFtsyNG0NxiFyXHrt09cNVt+jqxox3cfTNbpN6bqeRl5BKc3Y9/AtQ6Nq0B5O6OAMZoTpgt5kDPyEvlGsLE3UWkS2haWgThWt8BkOLVzPUFYFrjVAO5omLxjsXKQoVxTZGfujBxlKh6XnkWcZk2lDON2jKFOkH+NH+1w4mGBtligl0I3CcRwUPXYSI61zMm3bMW3b0Pc5zi8Ih51DqRpbdGBPULLFbgtkODl/nkMbWTTUCJK9HRJngO40fa7oNvcIpcVgcoBtdZzJAtH0uL3CNJqz7Awd+8zvHlHYkgfGU4K2om1LqmzJcBRyfHbKvaLhotWgSwcmM4LxDFwfLA9sF9X3GFXSIM9Vad0B49ClSQuOFkdE0YC6LbgjV7zTUqzKmtPeQasKYdYMoiGeE2A4f7ellIRRyDw1+MZFr5fIgwTTNAjLwekktVNgOwOqck7XSaR0kFLieQ6WcFF6Sq0ronBKbEeM9RFt4HKcZwy6U9zQIXAiBuEekZvQro7pNnPavqPQMcHAJltVFPOaMBxxMJlBbyFsQ6wrsiIjdpZUdkTRw2HoIcUvqowKIYgdDyuc0NIh6fDjGO0N0HGFdVrRpzlBkhB6HsbxWBzdYbNZEgVT3J0xrXMuSNTTsX34Kss//V+QfM+f4uDWi9gv3qXzx5RXL9E8eJlg9yrZcklXVUxHU/qzFVvXZcEWURoOd2aYTtNpw7Zr8KIIP98ADbatCUKH/Ld/gNMP/DDBX/vbXP1H349sv3JX1b1+A/c/+W6sb/kgN/5vfwz/gX2G1gzbFPhtw83tTUrjUG1jGndBN91n3/XQhw7BtWfY9oamreibMe50D3xBd/MmttRYWOi6JYyhCF1OFzdorF36nTHLegnmjEujAy4fXiPVGcu7twhdj+nBZbptCSimoSbtApq2xkgbc3gReXaX4fwUL5AYW+OPdlnrjOfnX2TmjnjEv0ZTrek7hzgY0m/hKhcJpMMX55/nmfgq3X0LU6ypjY/dtLTlfaLkAlbWUs/vYIzF3T7E9SIuHUxYWwo50JBV/NjdH+On7nyMj979CFv1q6+h3hdDHr30NHvWLgfuPg/be1zZucwTj72HJq94+frHudUsSbueH3/9Z8m6GtG0RKcBge0ytIbMmzmni8/xkaPn6W2fYTwj8nY4aJ/g7bsHXE5mOE5ILQOKvGJTa/BCWqFp+oy6WGEpiUVIpQta18PVNaqssO1dZA1d3eBLSe1YZKLjTnGPz+k36U7P+MTmM7x09BKX4n2+ZvYUqcrYdj1WFOK6EitwCbuCJrJg/ATJYJe3NS1f+MJrnK4LxnjEbYPpeyhKttrG0QJ3dx+3v0ezPOHMmXJcrPBNya5l2Ll0lW0m6doaKRW6TZHhDh4C6Xloo2m3c4pigx/sIYMpUtmctTkq9jjwYmqt8XuF1TSEvo9Fw7arqIJDRoFPTc0mzTDbDns6Rno2qmqw/RDLm9KhsZuKAEGmWoQd4IYDntl7inu3foZrw6u878EPoq019eaELj+mKzxMHCCtCU2jCENJTsWd+SmD2MbVAf7W4O8eYOoSd7tC1Zo6tsk8w7CHrmqpy5LGFzy9/zivH3+ewiqxuxHD4j6z0QVsd0gxP8Nan9KZNYTXKDi3uPSFz6pa4Xv+uWp+I/ji8Q3yZs37H3qYQbfkxEwp+y0X2xWh9Fn3iqRtOTMuvd2yLyW7410+/PCH+CcvfD8/dedjfPtb/wD1umLglBwXOav1AoyFikZEewdk8yVOWWFWJ5gCaFLk7i551bIT1DjDIbUMMHQErkcT20QGVOfxapFR9zntJuX+gYe0Quq2Iox2qCyLTbVipAWe3dMYh344IK5q6nLLsjrD8ccM4hF26BG3hoXrU7cNI18RhT7oGu0phKyRTk+Xlzitg+oFdZkTz0IyaXF1MsQ2LVmRsuwdptpBBxH67D6gEOMJvQTdGv7PT/4pvvHyb+O/+sh/yz+/8QO/pO/fLu78quPEv41b+d1f+Pwji+fhjX8EnIu2XZtc47HJI1xMrnLoP84j0UP8tp338ky0ww/d/BH+6fwTXBlteO/s7RTpkjMyPDchTxXjwBB5mldWGu3YvHUa4FkhoXEp+obN/hWyYYzlhBSbjPrkJnW7pNcS1w3PyzWJ6MqC+vqn8SyXfHjIqqjRiWBkx3i9xhtPuXeyJF2t2J0c4o0CfKtDpymrekPbHmFEix3uUyb7iPaUfnOfLTtEEws8icpr2vmLVEWPimeY4JBR06McxVZuMNm9c7cd30K5CZ4f4GlNWRTo9T2a+XVOCtg4Uw6iMYNkhLs3RUmwrd88Vs9fFcE+ODjg85//PH/jb/wNfuqnforFYsFsNuNDH/oQf+bP/BmGw+FvdDt/S0B2mqyo6LViZxKzXsaclCVemZ/bd7klJ+kaWzpETkNabKm0y6qpuTQaMIoSZF/hDHawlhnDQJCHY842Z4zjCc4gIZ131Os38R64jPva58lfehPvne/GFRJlFGpRMRjsY1yDECG2Udxcn+AQEEYTClNiTIthgmVpXJ2yvn+MmefUwRh3MqJ1ABSTfoHIznC7jl51lNUdajNmxgDqOabd4t+/xc4qw7uzwP34Jzi4eQ9/vvyK+2JlW/yzM/jSq+dqhV/G9N9zD40QqCSmn0xhMsHd2cF0Fer2bezTBTIvft3PyUhJ+cFvov47/z0bmdGuW8JWEpUabW3Jop41UNs2TmAIQ5/J5YtkRcHp9ozOixkc3ac8O6VEnKfzaMOiqhg8eA3n+BO011+nf/Bh8vV1hCOoJxe5GCVEVYkW5wP1pi2xLBcVNszGjyJfeZP81j36x9+GDEJ0uaARmqzpGd27SRdM8cYJUhVkqzs0ixMGo6vonT3MaoXl1jSti8ScB+xK0JydEkQxMompeoj0g4g7L3O0SQn3DFMlCcIY1WUoaSGlf27LkCSEacmyKJEDm1E4oXYsyk5RlyV+nVK2mmC2Q4hN3S5QnSYejBH5hlJoRBITREM2+Zo63RJLh2Z0iXl6m7I+o26GZPmGxnIZBOG5oJFvyHOo8prQdwGBk/ziWyOExLYj+j5D6wApz1OWjNH0fYbvBtTao5UWdp+B6vCkRaPNebpx0XA42SeUHq4fEFo1Vb2LDKdYl64gHUncJtR9ybBpsYcDvK5ibTa0bYfFBGWHnHYKqQytUujtAtHnaO2hkildtibyE2Sy8xXvnVKK3kDdtHSdYjTyGYQ+b87vc5af8IHHvpZXj77Im80RuC2uEdwrcsZmiydgsHMFo1K0qlGqwbI8tK3x4xDRWtSLNdpNUJs1XjBAaBCuYJUvsXqBZfX4vsT3Y/o+o9OCyBtRy5x1OsexbEbRjCVbjjdLes/lwXgXbIfQOa/XckZ7sBScLVf04ZZelec2QZuegXGJk4i26ulaxXgw5XjTcNJkWD0EwqVT+hdquP4NbGEThwNKz7Dtt4wYUjXQ+5qtU7NfBARAu93S2xaeiciTHFdaYGmMgaJosPuaumqIAsEw1FTv/FqKp22kN8Ys1qSLU469JV6vsVtFnaZYSYJnBKY4Rjhj6rRhZxoQdBElDo1Xk2xaqk5zyz9mpzpj7CWE0Yj5f/5nsb71Q+z+3e8j+NmP/pI4E/34T/PEz36M8v/0n7D60/9XxrsXcZKA8e0Uv0rZLjRBoUm3r2BEj/Q19ugx0BmO6TG+S29sgmbD6GBCt5Mw6wSrN48RYUzv2tzZfJEkPWHoDGgvXabedHjCou5bBo5PVmzYTobIzSmyEVgjD12k2Comy3LsQY978TLd8x/Dunkd59ln6doNxoIfe/Onka7FN176epzGYHc9arCH6tf0lc8oTPia6K387J2f5si5gedrtl1G4Qa4esEwCNmbPEKGi/YDUl9SbDMOpnvcN2f8g8/+Q376xk/z/PFnUOZXp/tiCZuv23+Gb5lPeX96mYfNBOsdf5jrVs4X7j3PnaNXuC+X/NjPfwZddgi7pZUGKWOu7jzGldEeFyvJDMD2qYhxrRbLWnBrecKdPOeOrLie3eHl9V2+cCTYT/Z4cPoolwYXmTk7RO6UmWOjtaD2HTZ5zbJzODUWrheQ1BWi3NA1ksbpeCV9ndvLI46yU06KE47SY6p6ieVoQh3g+REPTC/zbW/9Hfg7u/RtzGqzZmz7tMs51qbE8wTW8CK1PyECAiE5cCEbRmxsl5my8V3J6cmavFlzuDOmMj7LeoQpNqzqHqeq2PPd8xrkJMHtXLrmDNFVqHqFIEJXNUgLYbtsTm5gLIcomGAZF4XhTNSMXJ9ZPKSpSuqiwM/OHVMcu0UHEcuqRboWviWpKOi3GUvhEu0PMZsUyxhwHJSCvu1wuo4ew4lTMXJHPL37Vj57//N8aO8DaMfCDma4tqROO+plRuwI8vI+TVsjBj5CWQjtMBru4mobXabQVchhgEhLdqwx2SBkKSpsucVtPE63OUk44vH4ElIITrs5E+ctZMUNSm+ArTWqzbEHY/R2SXrrS9SRy3A8o8lPUd2G2AuoT+7RNDWfm3+U2JU8Gz+KozVSbamFwNgJdlkiihMqpRHOkPDLQpF5m/P2i0/xr1/7KM+dvci71Tewm8xQKw/KnMV8w8VLh/TSonY8gt19zOmWzUrh9GuMSUnbhNBoJCHGS2jqHinA6C3S8rBGexSZBdmcSy04Tk8dtxSbVwhMgbQHeKrmpCxQKmQ2kpyWc7pI4FPQq5bT1TGHE0E7HOLIkrN6RVoH+P2Gi36PsmxW2/tIX+JaLqYG2xtgdyG9JfCHAdqP0X3P1UGAlHBsnXFvnrLINeQRoTfErk4QbUAT+Qjfpm8M1+JD/l/v+xv8oYf+CP/l8/8Fr65e+1XFia8Gne54bfEary2+8j8sYXFtcJUH4qvkreJ6dY+721f5Y9d+J94woVmeknchmT1CzEICA21n0dct/nSGnm9xVkt2dx4idSuOt2vs0Yx5foY13cH2fagVZruktWrs6QHW2RplCeTMcLZecjjcxU+GmCxFqoLETyhMTZoumO1dwRvtYq1zhIlRzpymOSJyfdrAY+lI7OUNmshjP9rF8TyE8cg3x3TePs7kCqbyscoNeA5OchmXNfrsiNXqLkW0yzDw8I1Fce9NNqdvUAcRqT1mN4mZTiZ40YDcGCJ9rpEgxG8Oq66v2gd7OBzyvd/7vXzv937vb2R7fksjcg1a52yyLTvxCNcPiUKPtqmpihB/7HA6P2I2nKHrYybRDqtOse1WOO4BNhosBzeIcP0RdbfiwmyPV2+nzNMVO6MdNr3BVDDeceDSAeL6bfpsTThMKE9PcSqohh399oQo9YkSh0GW0osWY93grMyY4aJ68Mtj+qLBnPT02sIJwaS3YRIxTDeEfsR8dEiX1RTdPdpWE9SK9vUXEDdeYe/kCPvVlxjcuo1/uvgVlX1/tRDGYG8z7G0Gt279wvHfqKST6qm3kj7+BPX//XvQfYbQHWPbRXY+nVNwFmlW5QJbeFzaGTEqS0Qk0ZREgWBW2sx1Q6sbwlIgJ7v0jo8tBDKQjL/ufRSf/nna11+Dqw9hkTCdNJwFAyajS8Qy5353gitH2LrmWCmqvmISefRfeg0jbKJnnqUc7jM0PqZeo0WAunuX8rBH+yOErfHrEl0qxKUDasdG64xAR5Sdg6PXmNZFNoYOgRyPqXVLs+2IXJdFEtNVGVaa0qkQazRD9xnYO0jLQkqB8TzcwEWmDZVbMfQa4nBI2EFen9tFWY5moHPa3qVpMrx4hu04uL2hDDxa3RIOd8my18kXp4x3dvGMTTLYAbXheH2fqmgI/IRJ4KDbHql7sAR+FFDNMyzXwXG/MsxZVohSJX2fIawEBKBKgHPrlK6nwSWUNrQ5nj9CG81abbC0ReKNkKZD5XPc0KfauYTjeoTe+f/4bkTZF2RNjx1MGA1DlqsNrh1xGE+ZJVNaY6jMFjXUnBYpmojxeIgKBqSlZqAbKFfgj0CeE8peKTJjoG4JLJtB6GJJyfXsCETP48MHscuaj528wM1yhY9A2hGuHWHlPSqXGNtGWNV5TbWwaXXLOB6jVU1+7xbtretY0mK7bailwQoludkwiQf4jkdbLkBplErpOxfbNli1YlumzAYX8LVNMT/3EtbhgA5J8mVXAgAhJYWXkC1WuOoIE9gkySWsUYMpSozWOJ5F1yoc6eJ7A067gkPXYHUtmzQn2h39wrM0bUuNZBgNcajYupJhrzCbE7RQ1F2KnBzQHi2o16f4jz7MzsE1+rmhrM/QZYPxZ6g8J7AdpGvhyIrCiynNhHp1hjFHDFAUxRZ5smA23EN7hrDJiQ4HrFTDBW1hyoyyaViLEKcp2ZYNeW5w24JVVbGWNcNxhL97Ea0cLsY22yfezf3vOSD89t/P7P/9N3Bfv/4V76psO+K//fdR/+AHeOm7/yBXvuOPk+y+A/veZ8iDFC96CLebs9guGWyGLLyCODS4yqaXPbI4wa47GIRkeYFwh/hRzLrQeE5CEQa4jkEWW5qT6/hWhHBals193FUPSLxgglI9g8EEfxix7rbYfcOqgUlTER1O6JVBna7w/RGqmPPc8We4sbrJE7tvYd8/RJymGM+Hdou69zolAfqJt/OeS2/jE0c/x5vtKY8mVxHdHlafEc8SwuQqnaM5XdzhufkX+ezqVV5bfYFXf/ZNVvVXqgX/Shg4Q7528nW8c/IOvmb2DO8xPeXLH+flqeYzr36GO//zK7zydQ+zWZ5SNyl73h5X/YvMdg+5cuEBfMuh6T2uXHiIi6MxuuxIX/4UWd0gI+i8PQ69PR52L1MSIgczPqcybp3cQHLG/fI+zx99js/c/yxFVTPwRzy59zBX3H0eSC4wzg3rUnG9WrDeHFFv73LWnrLoC7S0QEj6RiEQTJMJV6J9Av8CTz/2LAfzEms4Y+/ht1Dr5lyUVLkE0sFhjRA19abCvnINL5qRKk3fK0TVEziaHS/CilyOqo7DwEUFETu+pDc983WFKwUDMowqmCZ7xHmHdhOKzhBFHpk9olEaLz+mbyOE9DBdS1+fUNYFzvgRbGVhDzw2dkvTag78GNe2kEFAnudU6zXxzgDLchjMdqnmW9K0QkiD2xk8aVPnLdZW4WNBXuNMAhx7dC6O5rTsKsnGAuUoLu8/wJ966rto85JltiUhxJIS49kUtiDLO+zIJvYdIimxs4y5CWnqDn/gY0UT2tUpqjrFosWN9tiJ90GtWNVLTCPB9wh7g65qrg4vcnP9Bs9M34vOWo7zl7gYzRjHYzpt4e7FLOe36ReGvOyxhwmW66H7kFb03Ghus6Tl65/4HQx2nqLua2qZEvk2jbVLtl1jOSM2ZUXXaa7FDi6a0uTURc23P/qt/A9f+kf88xd/mP/js99Jj0UoHTJt0E2Db7lUvWIYBqioI72/YSdxqP1d9PaE6SiiIaGre5pOYYstxoDv7dG2G+5RMvECHrRGbMMB1vCQ7f0KezCiQzK1BmypiR2Hq8keeV/T+oKiPcbSW6QjWLZ36baKlYCxPzoXWa01lr1L6D6ALRsWnGEpH7VuCIYD7CimzUt81+WobAkih9ixEEKwk8woes0ynVOstqSzmKmM8OqMVFUwG6FqgdXYuDrj8uApfuCb/yU/9PJ/z1975fso++rXNvH7dUAZxRvpdd5IfzG2/xzw917/OxxG+zycXGU3OCSOd7kw2cfuR4z6AKMvc6E7xNcNsjWIrsUe7jFtW/a8mrKDKoyR0RDtCyplUcyv4xwf44YHaMcjXaVsijVJfg8xjKDv0MsVtRrgjw+o6wV5saaRgrariL0WE48oizt09TGuOGApDxnWd4hCQyBj7C5na0vq2sJObDxnCJsKXwi2bYHX+XTuhCQwtGcrgis7IDbcv3GDrsxpRgEba4co1+xORrh+TCdBlS1se8ylAcL+LU6wfyX8+T//5/krf+Wv/P/j1L+p4VoevqVZFqcM3BDLcUi8AC0UVd3Rp5DVGwZ+ydDvwZpAVzFzbFzZsV6+wcAf4whJFE3JFkuGUc9kMmaZrhj5A9qmAOVjxQHdQ1eRNz5F9/KrVE8+gj7dIgJFTkHlJxgMgfGwPAvpjAidAWdNjgh84npLqGCbR1SejY59nNBh0y/w/RFVm7FJF5itQb9yh9nd+7Qnt/AbwfTmm8S3b+Ldv3fu4fkfKYxloff20Hs7qAceYPs7vonq5z5F/dADuAODY2z8MKQqFizKDNUpmtphYLscTqaEWmC3AqIppQwRgeYgGBFtSm4LSdOf1xspKWmKglxozhIHe5bgvHoH9wM2qT9B2WcMhUJVJZ7j4OFyWqQ8NJgStiXC8lkv5/DCi1gPPoR/5QppWTLc26M2FUm1Jh7vQCjZqhJTCZwsoxnv07Yd22JN4Lm4ymVdLXCaHDOd4M6G6LpCa02aZVhAXs/RjssksXCUpMpLqq4moMHgYvvnZFAIAYFHsMjRykPJEkt5yCYj8Wx8e4BAQ7+hWp8gBglhPEYXBZZl44Y+Td/gRUPcpqc0SwYXrmDKlmg6xe0lZ8WWfNuzNxih+prtukbUCzpnhB/0VEWOlEPM2Ro3+EVfVgCtoenmZP0Zlm0Reoahf4AQ5yqXRdNjvADRZFiuQumGtC04iMdIY2ObgrYuKZMpnX8uPDYwBvllf1bZasq6IRpCJzr24j2O6i19V0AT4EsD6Rl2V6Pmd3AHAzx/jBYd9XBKph3GqoNyCcEYLJtV2yGEhawawjjCsy3auuf69gjfdTiwhljja3xy+RIvrW/w7M41wrKnimIu2y7S9LStTa8NUKFsgRCCQTAg7yW1lKhtQbR3kVxKpFAMBgNK3SJcD8ce0rQLyuI+GEGTG1SXoVVPRc+8mWPbFrZSTKWgsTRnVcdO9ItimGldclKn2HGPn/uE4R5e5KMmima+pSlL/Dg+V4uuNMoJiEyHMQ1JNGaxKdhsBMPhACEEum1ppWA4GONWPSddT1qf4W/XeM6QoG5ZHL/IxL+CM97FkxYyL7B1QqnPMGbJUO/hCU2ta3B8UjL61sZqFIN+QI2idiTxBOTyDeQUXNvFdh3Wq2MqDwa2Rbo5wpc2be2hIpdNdoYSmpacJjPE4ZRClJSqYEftgu7Zegmdf4f20ctkP/GjOP/4nxD99b+JtfpKAjlcF7z3L/09zF/+n+gefwvdO67hPzLk3mNDqsMxWdAzOOuZUDEcTlnUAVvX5lLioxYKVZSstwVl3DN0HfqqRDSaob+Hs6dZ31+wvX/EaO8B9nYk6+VN6pXg0v41poePsS23VKLGVhZBPGBZrumtELOd4+1OKXYv0h2v8LSiwuUnbvwIXjDknTvPIM4qTJ6yynuku8FxA4TuaZVif7jH1cMHuVEcs7ALMgy3zr7A3fV9vlTd4LPzz3Fje/vXHLsfdq/yzRc/wBMHj/HYhW8kaQakd66zG3g0P/889/IzfuSZIW9fxDwyV0zjJ7HcxxkOJ0SNJpYxowceZd46uHbGot5i6RpXGCo1p9KCliluvEOh4H66YuQb+sChrRVGxrz10lvZFS5B1NOLkFvzN/nczZc5K+/ywu3n+LzS6LrF/jI5dIsIS6hzizzP58LwQR7ZeYBdb5exnnBp5wKtLFnfu0tVaXbiC5DfoBKawA5AC7ZNgWgc9mRPZTRd7OHUHWUrCROB6QxV3RKqGjcKCHuHJHFJi45T3RLEPqasELHHINEUVUmhLUReMXQbLN/GTqakm5ww7gljn0zt4BbH6PoOzoWn0KtTyuYOnT9iqAIsz0WGDst8Q2D5DOzzwivbtnGDgPzuHfyBxBpewnIc9vbGLJqOpiuJrYCBM6DSDnXT0TkuYdtj1wrhOkiT0KsUesGw7lk3JSdoLCfCiSXbqmFV13R6S9NvSZwJTqaYjCbEYYyhRmWCyHOodE7SZGip0HYPWYnnBQjfwWQps9CirRtuLE/ZnwwR1QahXB72L/D64jr31q/zZDABvaTyIJldwUbSCY1wJMO8pSwgyzpaV7I30Lixzydffw3bTfjAtffjuzHpsqGqNA+OfPK2YmN72FZBIkb07pRtr9jtW+yqIGsyvP193nnxHfz8zU/yyZuf4msuvovAhjbbst4WDAcWrZQEUtAFPrKrWZQaJ4mIXYmOhjhdTTnPaW1FMAxwnBkCh3kp2W4XPDm8SBAMKHNJ0KbUIiQZXyDtStKywiiJcXwcJyR2PLre0MoOP6oZ+BGnxW1GqgY/QbgJWZcTCs0iA9escGMbXfVkeUpWpezuxHSywtga3fZs6o6HRt4vLNQObIfdaMyaFXVb0YczuirEUx3VdkkeDQjlmM2mIqtTXAcSZ8Cffeb/wnc98Z/yyfY+jejo0pRad4gA6rKkNprODdGqpchXiF6z7Hs+u/g0kePyjsO3Um5O6BtF4Qlurt/k9fUNzuqvTtj5qDjhqPjlrV4d4bDnzTj0puyfXWJvcIUHJxc5nMN+MGRY9exGDp4MCGKJEBewThc44QATh2xvN/iVoD07pp3u0Fsr+o2htyLcSUAqR/zcvZ/i9S++yO955PfyUBDjeSPApim3xEiOG49We1xr72NlI7Kgp/QihHHxXRdhBFbbEw4SsrJENQWEIdVgSnG0Ir77BrYnaY1DOUooYg+dCVzZ0Tk2su6peokoOoyQmN8c3Br4Kgn2v/G9/uXwgz/4g/87wf5qUPcM+4C8LVluTnCtgE7bOGFLW9Ws5g29OAVR4uxcIc1zdL3hYBgwlhZgWNERVGtiJ8J1Ysoy5fJ4wotlzr1liqlThOOiHI/+8afxf+JjVJ/9DFkcE5seMXLx3KtIHZCvblE3Ct8bUIsCAsnUnlHlG6pszZYJmxbUIGAQj1DlnNwbEgqPj/7j/wfj1+/wZPAIRoWEZ0fs3rnJ+PoNZPcfVnLt45j0Gz6IetdbUWWNtS2w1imybvDqDLk4Q6w2mM0WJ91i/SrO+ZXnj1AHF+DiRZyDC3STkPzmXfq6o3z8Sfrf+2HUQxHSksj5BgRUH/84gaVxv+Hd+HFMWdd0BorSwbLPbccSRyHHMBjs0y9WtGWPMx1RCh/btnC6FKtruJpMWaqWk/kxURKSuB5tb8i2HeMHHkR+5DOkr95itTNBB0PGskKbnDkBgTtlnt7nCBfHarkw2mH985+kaVvcd7yTOgwREvQ2oy1sIiNg7NF3GzwnQfaGru/pDy6QmpZ2k5JEY/p1CtUZcrKHtbuHkBLZtWzzLWWZEQaQlYZxOKbuzhB1ixskdF2PqUvsuMeKfzE6GsfB1YpOny8idNkdHBlixBTLsUBblHmLrrck+5cA0FWFDCN8R5K1Gcry8aRHaXq2RYktXbyBTZfHOC2MnZbRKEbaFu1qA8IiGo6hrAnjAH9/SNsoTC/xQvvfSj3yKbZr2mqLKxyUE7LtKyrd40ofg6CVPp4ooM0p24yuF8x2JpiqBtMgvJhV0+PWNUprcgzJaIhAI/OKottA7RDbHgPpsFQl2eKEqN1gOw5qm2JHCXEcEIwm9KpGWx6zUcImb3CtIZHOoFySWjF1r4iFwBjBIAkx2pAVBXfzezy49yjK9Fwb7aOl4vbmlN/58Ic4ql4lzxVidAlHKuw4pNiWlNuSSlaMh7vngj+qR3o+VlaiW0EwjpjNEkDRFy6VhrHvkQQXyLY3UJ1LV58LjSWTEaFsKPsUoxquDASqDrmhWoo+oOsFlmPYNFuOtzmObhkGAZ4zJsDBEgP6gUW7WlIu7uEED2E5kjTXWEZyIRqQ9zmtbgnikKyocSX4cUxbVSjHJcbgFg3zbkUW2gSHV3HXPV5T0MscdSgY6EOU6imPj5Bdi5hOkMUSmd3FisfMSwvlBRTZnEjVDGxN4jmcNh3rheQgCqgKm5NbR8x2r9DPJmzW90n8HbzpEJ8YR7psl2doqVB+zPEq5XC8wyjqyesao32y7ISgUtjWmGFQsUoGOK5A4JL9oT/M+rd9A/Xf/Ks89AM/hqW+MqtHGIP7pZdxv/QyEXDofD/ztzxO8szb4JnHcFyBt3Bw2pbJ0MKZPsA2qdhuDdQuQ8tGmho/PSETHtbuiHV7n8JKcS1w7Rlj5wA7zzgr7qPCB5CWxcBJKPWKcnMbx/LoZYtlGUx93pe4dJXmhc/gr874/Pxl0mLNt07eTnt7i6lqbNenVjbTQDE+eAxu32Rz6zpnuy1zveZnbv0kP/T6D3JUHv+q073/bXjS5d2zp3nH7P28w3kbT3r72I6gGXS4Scz9aovuO6ZKY+7d4+Vph7+zx7f+oT+C+qc/xNnrFdnDBwTMqPR9GkdT9YJeG7QVEdopptnQti6UGaU9ptMOA63YF4K1cLEcQ+LB7VoTNT2xp6nKhj4r8b2efbPHe3cGhMEHcAc+b86vc3dxi5NizswPePriQ8ysmB06rGCICq/iBwEqa/E6g7EVWZkRuT6+UqiypxmNcKocmorADzjLjvAVhJMdXJGw3t5FDwaIXlOVJU4naQ3ETo9yAwZIhDGMfcGt7QpbBiSWxLUaWr+lNxGoCZ4zRy3PqMcHhEGAKEuE0CTSZZ6VtHqAa5WIfktfLthWHY5/CUeAHfms+4pWK0beAFf+YomH7/vUpqZqYxzLRwKWJYldm9tdy56Q2IOAgR/jbEsK1VHkDbbocOIIaRxoe3Tf4vQug6bgZlMy8iymezHrbMm2yOnaFtVJWuUjLMF6voU9G6fMsYMR4cgj7zO2fU6sDZ6UCBuEa2EcMFWHaG2UToj9Ft8P2SrNcDrlqvU2qtuf5N72Hu/eeZAgONcf8FXFMJiSVUukP8FSJaGuKNZzZCPRg5j76ZZbm7s8e/FZhv55aWXjW3iNjauHhKbintpiKcMD0z1SJyTtFJYt8I8bLCdgvVrxiHuJ54TLz976GO+4/CzRaMS4rTnJKgJLMB4MkZ1BtBV+LFlWPTtdgz/boxWSKJlQ37tBt13junv0TUHdutzNagIl0KpnWZT0tcaxVwgZUwuPWeQzr9cIlZGrglV5Smx5VNWGwmkZTHcYt5K8s+mEw8iKqKVgakn86S7peoTVC1TX4mobx3XZxFtO8jPcNmAQDzgtCtqip20UZ9hIIQnsgJl0WCQj7q0XDE2FCGMiT0O24db115klhzQmYLIzxsGnFSHGOERFzod334+IE5o2p9msCHZ9DAbR+iAjMrXl5mJB2yre6Oa0QvF73/ItPLV7mfb+TSx/BsGIVmUkWUXR9byU3+BLZ1/kenqbV9I7vFHd4qSe/5pj2b+NznTcq4+5Vx9D+hLc/6W/caXDleQCDw+uci1+kIedHR7xax7ZeR/j3RmhKZDZCf7RTUQYUdUaGWwxaD5+51/x+vo1rK7nY3c/xrW3/kG2TYeILtK1r2O6LU5vszFgFcdk+YwmOsB056WkvghYFxmRVjjxkCjcpVlv8Jqao6ZBdjXyOEPsTvBmIyzVEpshiVMS+SFpltN1BfZ4yMzykP55///Ngq+KYH/913/9b5oc+f+YUAuB0RqrbFhv7rHjhthtg2/39GhU0eIHilIpShmxbDyswZS9C1eom5RA2BSOzbqvuagsIkuwKmsmkWQy8Ll1Z8WwVgjfJVcCJ5nSXtjB/sKL6CfewvCtD1L5CYG/h28ki+2MLL2DP95BcEyZ3WBg79DbNg4XWW9yFnXG3jRm5NXcVwIpxpz+f/87Jl98najUxIsXOXztBlb9H07JUWFI9sH3s/rmD7N45HF2xgNc0dJ4E1rHZeJ7HJ3N8X1Fo87IO5+BdZH781vUJy+zF4Yko312dMjwbAlnRzTHtzC9QF6+wtloQjXYYu9cIIt3sHavcOAkjC3NtllRLCrkz/wc9mtvIJ97Hevx30Wpjln1KRWw+8o9nINL+E8+Q/FlaxOvDZkNRthxg64DHNZI+zzF1bMdestik23RfoBubeabiqFt8FqI/Zg30vvcXy9529VrzNwZWmXog4v0/acpXv0S/cX3EYcRI1fjaUVug3AHUC24vTrlWrJDs8jRn3yOcDCExx5noTSd7+KlObawcb0ZrVzRZytEusVFw+wqQRJzlp3idgrnaEUreywPnOEu2pyn1QtpMT++jT90aRgQWA6jULBoIlTaYEcjLD/AZB51tsEfBuCcJ+QrJL5j0aPpS4lDTyc1lhZYkU1X1VR5gRuNcU2HLs7r42Xg40tJTk6drXAHI6xsTZZtmQ12sX3JsvMg3zL1AuJBjMHQntS4w4QoSShWOcFoSDSMUJ2mLjt0K/AiBykFaZ7Rdi6zZExbdURmD99zKbuSos/YthopI3bciLZaUZZrAifGdV1MvqDHoQkC2k3KxHS0rqBezglzD+1H6HxBa2cM9JjYGrMpWwI7prFq1o3mcHqA50zQrsATBrwB5Gus0Mb3XcKyJusMlj/CdCnb7QLPOBjhE3kSy3PpasXrqzcw0vDU4TMo20K5DofDaxylp7i2RxAOqLMtq77kABfbGhLEPk1eoBsDlUXelJiqB+kSjMZ44zHK0njGxriGQTDgbNtx7/5dRlZI31e02QqpI3Z2J7hehzGCvu7JRcfO4CJ53uGXa1SvOcpzEr8lLTucXjB0egJvRDydodMUvc1xRmOCwT55fkSe3qcJ9xCWYKBsLBSRH1HWJb6wUV5A23Xo1YoqL8D1cLqWXnXEiUPqz1DOALspCMyMYLZLtrlJpjeIxkH0NUlf0a5buhY65x6LPuGk9glb8LqQOB4Rjnc5LhfkOkP0GcfzEtnVFGWOf3gBo3JkGCOLlrJPkYlNXa0RKLKiQ5tzr/XUmyDVhqAucLNdelWwzO+yu1fjmggx3MeTISpds24bfiZ9kc9/+x7X3vEtfNc/foPpZ9/8ZWOm7Hr2vvAie194Ef4+qCSmePophm9/L9bb30a3bfFVT+dBpWM2pyneWNNGgiJLsTYKy3OY2AEicrFsw+J2hqsSJns7VPUpm7M3GUiPJHaxginr9Jg+OyMMxrRqRJ+XqMNL6M88R/X5F/iM+gxTb8BMj2lNx3Di4XpjBk3B7foG/9OrP83P3/w5Xlh+kfzLpRlfDQ6iXT545Rt5x+77+Ja9dyGURdFLunV5Xh7QLBmJhKEYcrM6onE8zHOf5V5+zJtP7fC1j349w6vvoPzIR4lfeZni0QcwTY0dJVTSZ3v/HqODQ4yM8Y2irI6pi5isFPRWxCgSxJZBYLN2nC/vRqeItuEiDs66PVfFlTbRMKYwPv4EXNGDVjy98wjv2HkrVuBR1xmDIEB1LZZMqbKUyHepDRwXHcIx9MWGke1jiRJfSDrPJhUBQWfoywxb1dB2ECUIf4hTLIiDEZnsCduOvmzRPfSRg9Yt2kuIdEWnFLls2Y88XAnokrKsGQ536IqGTAYchDGO3oAHZVai0TReyzgcsLx7RCE93H0bYxqqtqKpbAazIbY0CC1Z1imB7eNaDq78txZhyy3hIKQWLlVdE4YhQghsejCKrhfIxEO4NkHgYwuHtO1Yn6yYhAFO4OP4Q9p2ifE8tNZEXY6MegpdECcDIiek2RZoXWMsCyNctvdXNDfv4YUebihw2xKETe3tMQ4iRDEHLBhdRkgL4fUUVUerO3ZHeyhqfD8krQvC2GcUR5xm12n7DzMKdwmre2zyY4yw6HWP0zvUygIqvJFh6h8gOoufvf4x+r7na6+8F4Be9eR9yzBJ2DZbtmmD7UssOcEPYlwhWXU9m6JiEiWYcJdhscVvt/y2y8/ww29+jH/5wo/yux7/XQR2gGMaVtuSsq8xyR52taURitj3ECagqhRG97RlTtFbqOaAciWReskRiszk7IeSmg117yDSLYFnsDyHyiiGlodnw8QJ2HYrjtYr9kYHNA4EwS5+vItTLpk4Bcd5ihuMUNWWsWshvX2SyEMXJb0tSQb7iLZlZzRindZ0lsK1AmTkc8Eo4s7BiVwUiqIuKCvF3k7IIgu4v9rgBIZ9bJJoypvFPewi42CcMBqO0V1Onxtax8d0FrLYYAcRSkuk1PTlFjsZ44QRbFLcvkb4LmVVcmt7E43Fw5NrZPkJgRFMZ5exwgHz/Ahj2/hbj7cNr/He4bOYszsYR7IdaFba5fpmzYurN3kze5OT4jVubK9zrzn994W0rwqt7ngjvcUb6S3go7/4xU/DxJ9wLb7CoTPgifwaj7oPcWAOCSYuP/rmp2kczbv3n0WaES8uPsnL88/ynughahVQRzvMTze0ZYuMO84Km2BxhIgHjI3DcH+XIl2hqi2eHSICD69VpHaK2hYUx7fZTzxkP0WFA/JshStDbMcn1orZdI8tgqM+Y1ss0EWBYxdcGb0L1w1/w+7P/5b4qgj2v08pPMsyXnnlFf7Fv/gX/Lk/9+d+Qxr3Ww2r7JRlscINYzpANhrPcSiVYGsrvEAwGe1yT5e0a0WnGmY7YxCCTTVHu0P2o0uclWcsjGbiOGB6ymLF1I55XZ2ipU/oWmTChvUx8mDKxc+/ilyeooO3oOwRA99HG8PGDjHKpe46AheWfQ64WN0MaVkUwsWSFladkjoSvWp4+G/+N/D8R5mtCry2/w9es/Zctu/+Gk6/4Rspvv3DVNOe/uyUmQrxZxewZE+3aQilReOCFfas7p8hpUM/20HrhouJxVEdUhxcIk0uE0/2CJoOXaaIwEO0Dtt2RdaAyr5E4PuEUcBW18jeZ9tuaXowto/3nd9J+M9+kPxTn6X9nxXth59hrmrMK3fZqWrMh56ibAV1ZRFIl0Fo48YO+XGBdCWmV3i4tFVF2zS4gyHrqqTblDhWQ6tCMr8kz89QnccDewcsswqlFPgVVlUwevABqsuX4M1XEB96H6FoiGWMbXs4bk4la+zxmOV8ieuHNC+8BGmK/MB7UEVP11akXU7pu4zjBOfoNo2+D7ZLoHqUMMjxLrYpadsOH4/WMTS6xVEGoS36RiEDyMsVXV/gebuoRhOJHFNq3ErSNRUkNTDEcqZYUtCWBUYr3CCkr1vcJMFTNU0B0WyPtqrAybDklKpeIwF/dAVjCnR6ihzuIr5s0+BoQVlmTHcOcDc5RZnRDEZUWHiBA5aFsi2kLWirEqMbLG8fXdWoThHsnAdpy5H4sUNT9NR5h0azKbcMwgHjJCTf1lRFSxSFjP0xrWppupRllSKFR1nMEXXFdHKRrtoQ+hZln1Bpg9uUSNEQzS5S+zFVUVKvCmrXJh4/SG9cik5StpLRaA81Scg2K9qqJpAWqq/w4gHajpCqwgiDFoLYtcBollUPToxrdzTpFseqiYZjjIGuVbyxfRMhBE/vP0GNQ43gyb0nONrc56XTV7g2uoDfO6yaNT4JO10HwqGXPYMkxBaG9CRDGAvtuPRljSkz/JFPn6ZU1QJsw0j4pM2amjmoBmn7BLGDk4zAchHSRjo2utlgJTNUf8qgdVmqint5z24X4GiLyMoIg4Q4Phdwk8MhZrVCZ1ucaELQtMzXK9K+ZyfcwcOlUwrf9en9HrqOvrVQrg3zIzablMHFSzDyMSJmR/tUrSD3NcFU4GuPwE3YyAWr7Jgd6wAvnqFFhVWd0jJjY7XczTSBG2G7IKIZ9Sgmr7fUfcPB4AC8CavFEcKFPm1ZdUt8LjBOxuRnJ+jiBCYhxTzHWBHbsmNdZPh2i+hWGD9g7F3h7Dil0jUXDgytp2gMRHFPmtbky1t8/8knOZYl10YX+cBbfz/Ld2+xPvlZ/J/4BPITz+E2v3KmjpXlDD7+CQYf/wQA/f4+zdueRLznWTZf+34yZ8hkqzBaEwQD3MllVH2bWNvUwkFlSyqtkB5EyUXwLPLFdazBiEF4CdcdnJeYqI4+VBSORB6nNMbFrVte/OLPIJ+M+KaL30hpShJHYFk2P3T7X/FPbv5DPrd+6asaGz3L48np07x79x289/CdPB48yI4rkbZFPbqI74yo7ryBrSvCOOGs2uBaGsu20UVGV1uUgWT14iu85KxpLz/LU4fvJDOG/omHca6/yfjmMdsnLhDsPoDoJfnpHYp8zb7XkjaKplecmgzT2EyHAyzXoNMFsm9whUAbl0Vd4vkw3dunKTKa2MHSIY0W9JbFwLUo1ymWlIzCIZaxILCoC0VXV3hRSNdZSBwcelQrGSNYW1tqBZ1xKbdb9sYXEaGL0yuUbdMVFS2CILmA5bU0+SmetAmjQxq5okhPiYWPcR3qJie3Bdgejtfj6p4z3TB2fPJ2SW1q9s0ER3qUzRaDxMPBihNcP4DOELgBrS4ougLf6alURNK2aNdQtgbXGeD6Atf12bQFndTsejFCgPVvNmeMweQrrMEEX4S0TUNjWfi+T6tbYq3pjEXnOHiWAEviIJkczljcuMvyzinTBy7guDaWdS5cWQifia9wMdj+BFvaFKpAOYa27AmjniCYYp+mlNsj5HiM44YoEtAOy6KHtmTQtXjRFEeej0XGkayXJV6jSAY+8ypHOIqdeIe023AYJdxu5mSWIakMvpjSdvco2w30Fn2en6fTjmeEnUfoxyyzjNdPXuLB6YMM7QHrbM2qz0jbklE4wvYCIgFRX5ElARWCxJIMtOYk3eLG51aQyWyfsTzkA+MpL26+xHOnP8c7dh/n4uBBom3Ore0KuVU0x1vsTmEPE5JoiOltVNnRiwJL9FgyxotsaldTRXBWLEj6DNX3/K+3P83NzQlPRQ/xzftfS1cW9H5GKnO6fkMsPTx1QBv05L6hrmpGWLSAiEbE/gaznZOXNXa/pApC7MbCk4LCNXR9R6xslCgRrk/kRAjP4n5ZUmm4PB3j1Bqvc5BBgFfZFHZJJUtclbFcSu5PbRK/I9q7ygBDWPWYbk027wlnNn6gqeseS4Y0WYocJahaIj0bXWWIYIhFRut2nPTg4TPxJZvtdfbjC8ybEitPmdoz3GBMW2nsPuas3BKWDUml8UY7tM4evpfiqfvoUvNYcIEnHnkbnm1Rzudo12L/4i4vn77Ey8svcVyc8Pr6Oi+uvkTW5fSmZdOlaPPrL59c1StWX05f/5fHH/uF4wLBwI55fPog6XbOhfhBsD0+cvoyb3noMpPtPcLhDo0uAck2GPKaMOyv5+w4E5Krj2IPx7SbDCvfwNij6Tp022PyBVWlmQ6mGKnpGkj7Eul5+Lmg3pyRTGeIQYTTQty5TKyIzeI2nbtEiHf/uq/7PxZ8VQT7u77ru/jABz7wS45/27d9G9/xHd/B93zP9/C7f/fv/nU37rcaxv6MN5hT2gmuLeiNj1ek3E1PMaEgdn2GUUTZ7/Dq0Rt4Y4cL/gwBjOyQwBsROiGzYMaiWlC6HtILKcoN0gxJ3J66LbDdgLStcbM542iMHyUUpxuyvCYYW/iORdf1gMbHod4eM7l0QNOv6BvFnhIc1QVNnfH4qy8QffZ57Oee48E7d/9DlwiAti0273kPq/d/Pc43fAvhIxfR6xQTDri3vM0w26BmEVs1R9bm/0fen8fclp3nfeBvrbXnvc/8jXesqlsjq4rFoTiTEgeJomRqjKxIht1O5MRxN5Juo5FGG0jgdoxG0N1u2EEjht3oRixblhXZVjQwkigOFimJIlmcilXFmm/dW3f45jPuee819B8fI8mJJNO0grasB9g4wD4H66wz7L3W+77P+zyYGoYupPEsRgesrMKzIZecj+iOsUHLznDIQno0VQlBQetxrkDZJ4RpRmMabH8ItUR7DcY6XFXSSk3peqpFS5QOGUqL+9EfRpQN6qtfpV29xtGHH+fa12/Rioj6wYeRdY2vO6JU0ISW9VrTmg1hqOm7nHKRIwjRxgKWVZji6Yoo9gjTmNooxp6HXyiy3R3ioUav1zR5TlMeMZzdT/XQg4jbNxmvCpTvoV2CPxrheY6gPSXSEiNDXtwsuPzFLxF4Dvuma/R9iatK4sinQ9Bs1hA5om6KikZk+xPacgH1kqatUMEWw3u2CcqG5Y3nSK1GFGu6KETrgqKrEemYrunIbI4f+AQmQglD3x2i6yWwS689hiMPmaS0dUXXtJjWEA8TorNTNmqE6dJzeqmXk68P0bYgGkxRzsOKENedotQ5JdY5R1D1VL6kj2NUEKO6huOuZFcmDAPIwxChQPcdfZkTxjFCxfRFhQh8/Pj3TNaUkoSpx+a0ZlEsiSce0+H43OZp6NM1K/JNxXiaEaiA7WSKdDWOjrvNEtV2RLagth7ZeIeuNHStZtSW6CQgSib4vuGsl/TtXZK6Jol3KGSLiMaoLCSLQwJ/QFUXzBdH7M72cLrDG45R2RQ8TdX0GGdRAjLPcdpbXAsjEUPoSJs5Qvv0dYp1lldXr3JpeJFxOOLuukZKwdt2H+ZTL3+SZ46f57Hd+1GDAaa5w0k5JykSXOojhCQUPm2xIEpi/Djm4JUlqgO5XKB0gg1CLB1hMCYeT3AkrBe3SLyLODdAexUtHZE/xDqLQJB5GZtuQ6csKE3QazorWXWwExUMhwlJsvO7v4sQAjUaYZZLXF/ThQM2eUucgHM5Wo6hEzhzvqmv+4KwrticNUw9gdjaBt/QuR7ZRyR+wNBbUwlB3pYYGSNNzPaVJ1mevUB9Z4FvfVpR0EYZN9qEdlGigjWz3Sl9BdPhgMiH9dkJV7cuMQ5nmL5C5h2rYMLucMmmu8OOuEDYO0o/JPQn+GYEQUYX9aiqI/V2GLLheH7G+NIFdgcXKW+/QJmvyC9uUax8rNTc6zV89fQZ/sXhZ2gJec/2O3jv5AqdDullCt/zUc6+60P8+t3PU37lS/z4QcjkSy/iPfPiv1LDwjs6wjs6Iv3Ep7gk/hblww9TvOVdtO99H+sHLpObGoPCJXvMMsHJ3QNqVxBlVzBth2odYZBSxFOadYtZHrOpYlK3i14es7Aat9aoJKMJNP3JXR4f/yB7asZvLT7P5xaf49cOPsOyX3/L66BA8PDsYd44fZSH3H08eeGNvOcN78ON93GdwR0fcfDKV9gkit177yGWQ+4sS4LOUdc1YrpPZUoKrYg6SyEKpD/m6ktPc1Ye8+rjCd9773uYhhGnTYm9epFIRQxfeAb9tivMydgeDSmaOaI9YSTvwQ72ObzzCnp9m+3RNZJEUedrnB/hkoBRllA3lqqUbMUtUewBA+riDDEaURYVBCHunFOPF0UoFCI47zns6op0MsELFE3n8MIB0rQ0JbSyIhCai+Md1oe3KVHk0ylNtWSSDMnrmg0hUg0YZyFtc0jVloST+0BKhuGYE3tCowtG25fJD89YBSlRIggCn7otUAEsuoaBCpGJBw3URYET4HcGFUR4cYjRAtU3TKZb5Mph1jl+dL4m560kdht66RGGCT4WFYfMyxVZGCGkJPx99HDXbHC6R21fRhQVDui6DqUUrWkZW0XtKwonCAEZKGzd40U+W5d2WLx+zOJwzmR3ih8mbOqC3jVsDaeodgX1Gu2l6F7jBwlh5NG2B5RHtwhkgZhlaD9BaY/RMEJ5PqLuaMo1nnGUvc+oN0S+orCW3rQkTUflaaajbbpAI0RPZhwPz+7jtc1tXilf4MJ4h0Ak+NWIdl0gtSJLBoymO6z1hjBMkKbnt0++jHaWd2w9QtktqZzmqM4ZJFvsJVs4I6jSBZ6uUT5UxhIJCNZLamOp45RJmv4umzQZ7PLn3vqT/N9/8//B//Daz/N/eOI/IM00ibUY4bHenDBhRhZH4EmUFAR+R97mrDtFH7bMpo6qtdQuYKUbXjr4Oqfr2whbMfEivnD6FYZBwOPjNyCblJUJGdsJgYrpAoGNeywrJuGEtitZNJJhOoE4JRMSJy2qsxRNTRRsUJMBtVfSbGqCUkFa0DYpPiGqCmm1wFcNZTfHmATVgOh6TN/jewKhA3bGCeWq5dALkN2ah13LhSAG3yMOHf1yQ7UwBCOFkym210hb0c5vgIuQgwzTa1jOaYYTNp4HSURSetzcfB1MyxNb99M0c3aJ6aIxZ0VPLATWRTRVQ2LAY0jT+1gkJt2n33RUyyW5kST9IbuBoG198jTjZLHk2uR+Hh3fzygdcbapODm+yS/f+FWORMUTl5/g0d1HuPnyK5yVtzgcKRabA+blAafdIQfFAQf16bfVTgPgcKx1zheOn+YLx0//7vlL6SVuL67ztx/9j/BuvUzSaly8hQ0Ut4SgK0K6kzkH2y2TgaX1PIJGU+qKqKkI2zVhZ1iolHuvXePk9FXObh0RN4rhZEY1GzMpC7yuQleGTdWjMp+BNjhZkWYjfPVHmeP+ycK3FWD/1b/6V//Q5/b393n22We/3fn8qYaQ4PeOXltEHNJmMVVX0G0qEqNh0pGbIUo4Fn3FlotJxJCZn1H7AzZYmuYE6TSBsFjbY5MBi7YhmJ8xcy0HomIdbkHjSNZLsniIvv8q6u4Zqzpha1RQNIq8NXimRLga60ecaY1vd/Gf/RLpFz/Otc99lfGzzyD1v7pKDd+0tnricW5/7/cw/+iPsL8lcHNDq8Yo7RhOxrQaRrnPQOwyGWWU9Yra9ARxT1NPoEvZFDVLK7l44TJRMUfSsfI1yvORVUcYOfo4QE0SuLOgrzR12LDswLkeT05oi7s04owkGlMHPbWIMJ1mdHVKEoe0rqX/iY9iyxXDl77KI5/0mCwty0cfBS9hixQ/GJx7g/caT1niqcK1NUE2RsxL4iRk4znm6wWlHzKMFVXYsRtOqcyQXp8QBx2B1mSjFNO3VCdnFGHEmYT5hRHbnmJ4/WXii28lCsf0WNAJRbvAMwVX44hbL77KzuEx6ZvfgIoEfmOQWzF9okiEQJYRa/bYlIpgdRchNM7E+PoQN7yKl44RYUjgeXhJiHAZzeLw3HZrOMR4IcLrkNUZUTZDOI9KV5SeIMgGONFiVxucGGN0TxhFSE+xPjqlyWsGaUzk+6xESJW3JJn8ppjVnCgbE6RjEGBKjUyGCFuDSXFth+8UfppRNA3+YEi7OKIzLZly2Kql8UuEkKilw6fHzzJ647B5iTcaIn4fFdHa8wqGVh0qgURkmN7iBercD3oYk68qmqonzgJCT+JLD2PPM/vbYY8pjzmNdwl0Q6N8orZBGUunQpqmQdcFhyeH7EYhY394njgIBI2yCBvgK4kvJdPpDgcn32C1WjBKFV6UniuFewFKdlit8TyPZdcziFNMozla1lwaxfjy/PvS6zMOyKl0w7smD1DnHWOpwDk8b4tBmPLq4lViP6b3HNvJDm1bcbQ6JPSmZESYwtDrjsF4hugMUeTDYBcnINqe4gcG3Xp4bowuHKY9t4jLtncxuUI7RVmusVbivBCHYxbPOCwPqW1NGqYMvJDnznK0v+bSMCKOtxDiX+6xEp6HHI04uX3As4vXeS1/hdNbR1zbv5/33/MdpAzoqoa4cVTlmsCPKKOYU6OJt4YEzZJudV5lk2nK2NU0Vc5q1SONYCf2kF2AH1/meP0aq/WCdmfKwlygG4yZTqZs1beIlnfo/QFbgy1OT+8SKBgPt3CNwVUlWShYkLKJFP6qxOlTnFmSREM8vUNxumLDGqckZichazRqLrlkIqp8zUkxZ+YZolFEvzFEeoEdbfOzz/8LXpw/R6BSvn/7vTwQX0B0G/zO0UfbNLMQLy+5nF7mnz34Mtvf+Wa+87/6v5D5F7n9Sz9N9OsfZ/+L3yC5deePXl+cI3vhBbIXXoCf+e/QkymrJ9/M/C1vZvmB72R0/zZJU9J3Gn32MnL7QbpGUiuJ1AW5FyNkyHiWMREhdrmglD1L3yetNM8Hc8aHLfOu5D/62v+RpxZf+pbWhm1/wmOjB3F+xM5oj//ze/4LtsM92jt3CDQ438PLG4Sfc2d+TPvqV87XFLXNsj2lsT0nfYZvelxjcdqSCUePJe07rLNc8j2yF77Ol2VBfs99XAt3iARUmyV94xE+8hDq+S8TnJYkY5/DNmeQxihq8qZHBCOmMsTYHBXHCDRtvqLzB0xHCVkYc9bUIGN8OmjWhMMLiOIMW1d0Gly7QUwistGYvulxWITnsdycok1PlGYYU2IMRPGQtswpy442qpiGYxILRbHhws4uXQBVYQmFj4vOGRCjBGJpUMay9gN6IfCsg8YyHO2QNyd03YZh6HGrdQSBRsYB1aZAeApkRhTsYtSG5eoEv9d4QuF6jRumyEDQl/25urdo8SxIZ8gu7NMuN+S1QboWNdrG6xXCOTa2Q3swkQmVdQzUN+/J1uCKJXgJIowR2uK3LVYpNidL+syQGvDimI1zNMYS+RIagessfpYx2anZbBqW8w3DcUpvEyJvc76rVTNo1rTLA3QfEA1m+LGkq3q6zQLfGzC58ACd0zR9Q1WW+EHAyPcplGacDahQ5I1GSFiWJa6uMVqTxRPGs23KZkW5uYOWKW+6/DZ+487XeGX5Mm/cfROjyRaZnZJvLHGSMt3eRqMxvSHyU077kt96/bcYZxOu7NxL2Dn8IKROAiYqo6kbMApfWpLRGKsg73uO52sirdnentF7Po11xOr31rlL48t8+MHv4xOvfJJPHX6ZNw6uMBMGLwm53fQEFxKmOxcpliWnh7ew/RobxWykxzBNmQ1nPHN0m489/0vcKV5mHCa87fI7+Y5Lb2O1OuWnvv4P+cSdp5hMrvCG8D7unmjSwGeYhfiJ4qSo8D2YDWY0dcuJ7jipFgS+Io1iEqnQ8YxKx2T7CclgSlF0OOsjtAArEMIniGOWiwqN5XIU03cl8yKn1+e+0CoN8KOYJBwRhxlVfcBKexzaNRfWr+N5E1rlQ5hBatHdApsfUOsBZXPGIBTo1sdrjlBVg3QhZaDpBhOkFxOrmK7vuJm/DMaxG6XEwuNeFVFHA9ad5gyHrEoyX2HHkqAb4pxG7I2I04DWbaP8NUnU07YF686j9gXe5oTad2TaQ8Yj2sBDxQn7nePHxZv5WPA6Lx49y8HyNb7DPMwbh+9g67FHMVYTnW7wQ0ealpjOsmxzXqjv8MLqgJvtkheX13lx9Sp389fR7lvbm/9+3Cnv8LMv/xy/eP0X+YHpe/jo/od5OK0Jm4DLQUhYWlJ9iF0tOOw66qYhK2r82JH6BuUCdHYRITV9VVG2ksYP2MXSty3B3oBhGsNmRbk8o3Up40hQnR0QeRWj2cPngdC/I/hjVxH/+Mc/zmq1+uMe9k8F/DAkDBJs3VMqSxXG+NOQ4cmI09XrJH5OKWKkGLA7mDFUlnJzxKKNCCmpdIGpPJJggK8Era1JVMCdtsH0FXu6IrZr6tCSLtaoBuJLl2jKDd5vPY17/QSzf5X1/BWKpsX1GrWumD7zNOo3f4PsC1/FX3zr9igA1x/c4/n3PsGDf/4/RTlJM9zCqR3q6nW2phkbl9I2PWvR0pglVyJL3iVYO2Mrm7BslzjdIN2MYnVCY84IGaCcY1N2jGNNMs9pR2NqK9mbjsFqlnnOMEiJw4SF1ETDkNSfIFOPYt0RiprRBuqdXWptGCYhInZszAYlFYMwZvGRD7PuV0wPC2bDAeMPv5NF3yLbgtHeNg55LuAUBXQO2mqDlgJTgRIVnQdLDanM2BulNK5CCkHsYKlSxEihqxzlBeBJBtRU0WXmheMsVUxnI9Tzz5K9/zsIhxkEEmsthT1ly59irUK/+OsgOzYPP058dpcgnmHjHZwXEEUpiiVxnHKsehqzx6Zd4lmHiAeIbETqQFtLZXKCNCIN96iWr1HePaGtO8zliMyGeDakthbbbfBbTVNtEAkk4yl6A8LkGM/Dao1UHr4fY9SatuhRXoJarMl1jtsYvDTADPcoO0uqFDiNq1vkhT3oN7hqia0dMo7wPcemLDHDIeL0hInr6fqKpt7QWoPpa9p+zaXZDBXENKsa2zviwe/18BhjaYoe4ww26pgOh4QmpK001jqCyCMMA9qwpalb/EDhBQpfSW6uToi9iEv+ECfg9WjAQV3gcEybBb300SKgPj2k7BvSJGGSKrLJDqZzBOszFtWceLCP/82N0CgasQxDFusTBtkF8MLziaoAJc/tuDZI2r5ne+yxbHuMc1htwQvR4RC6BS8efQnb99yfXkMpSZJ4WONoqp5LyQW+cvIM83LNxBthTcLecJvrh69RryCLJ3SmPU8w6I6utwSDiHCU4gyo0EeEGuXHCBNQny0QdUMSjiiWBak3YTSa0vaSul5SWYkfxTSmwTnHNJqSehGHJ2dE0uKFFqu2abQk+WaC2jnH3c0BL569wrOnr/Dq8SvosibwIFAeX7g5Zy/Z5lF1EWpBOB2QTLZoPRhu4JWjIy4Uhq1kAnFEvZ7TlAVBkuKtbqK9GVVkuSMrklKga9AbR+1KfLXPvoy56sc0sc/E7VMuXsUPjzg7TDGdYzae4rTGth2uzBHDAZ7p2fQtwySlrUrEcJutdIYtG477Q/qupjYh7SBlHIIJM3bDMbdfe42VfZH7dydIuc+pdhRyyede/zlerxdc23uEt+98J2Fl2OgDYr9AVhaXhJxIDxWPmO29BXf6L3hteZsna+hHKa9/6L2IJx/iznyNfeFFtl6as/P8c4y/+jThcvVH3pu95YKtT36arU9+Gvv//DuUTzxO/I7HOHvve2gmghvzitBuo/ucoG/wt0YUrkKNHcF4m2DyEA91G75YaD7xpV/ls4Pn+MYbb3Hy4lf+yPfdi7b5oQsf4lpwH9fkHvtbI0wRcEst+ELzPK/ceg4Z9kwWC/ytLVSg6MuCui04mh8g04yLVx+nPG0o6hphe8Z2ycYeM/ZgnDZIr6foBM6FzIueycEN1ifXuXHfNk/uvpt6fsrZaAt5tqKzCvnkw7hXniH4+vNMH3uCedkRRDOSZMKd4wO2/YArXsyrqqSVjlDa84BYDek7Cbqj8WCUDFFC05UrgmRGOJywOTui0ZbED/CjFOUr2k2DTRx5u2RdLjDKIZWia2qE8PGijOXxgrxdMp5sMQpT6sUJBB7JeIoTPReSFOUkJgmZb2omRmPLnDDIUBKqviLTMQiIZxP0cUGxOmA0mOJsTNm11IHPul0j/RkxPp3n6KzPvKmYKEEUDuiVxAYRTvlYc4aKIjxb41UNvbAEgyETazEYOp2jwgBfOKRzzNuCYZQijQRtCcNvBoNtjtMakY4RUiLCEFvVhEaw6hvcWuOFGV4U0ghBbgyRkucV/9biQoeXZQy0oRKCw5M1MgrYm2ZoXSCDGToY0ZgaqTfQLdE6IxRjRGRR2ZTWdue9o77E2vO2CZsv6duGIp0xCnxO1hU3FxWuLhg4RzLOSOMBru9JuoZGRRxbzZVgwkNbD/Dy/DUa03JaL5gNR0TJRYLQP7d5rJdsug3OOT538DTaST586R3sTffoWs3x/DZxPGY8ypC6J18XhP2GIB7SFxuUgqrt2J5NIU4pjSHXhlAK5O/TRPqeBz7E14+f5TOnX+Xi6Ap7YYaoNNvjS9Sx41Z+i9BZSDsitonI6IuG0zu3+eTNT/Di+jXqruaJ3Uf580/8MNvpFmdFx2Qy5Qcv/Qj/9OYv8suvfYotkRH6l6ksjHGI2ODWlsgN6VxH5IWMXIh1LYUuEGlw3lIVj/HiMXiG1pZ4QYAKQ5xfo2xIGg0JhykHlWDiSXa3M6y1nJwtaXSFcY5B4oNnKfuCua7pXc0VG3MoEl7aLBnHSyobod0lkkDQ1BC3C7x2wcoTtF2HNC3olrp4HUGAkwOSvsfNrtC4EpPn3Fy8wL4/IpzPGcYTOmOR0uB0TtM0TGJFuH2Jk/IAbIfXdsRk5E3BomhpYo3XnBI7Q5PtMx5eITMW05xRtiusHzDPa+JQksQGb5zwfck7ecG8ymfv/g7/fP0C37v3AbaPtogjD6vAWc2q85ns3sPeZs0gyHh09+1sX3qcVV7w+qokbApOuhd55dY3+OryGb64fp55M6fSNWu9+Vfu22vT8nOn/4KfO/0XXMku8iMXvpsfvvo9BJMZ/aJl0p7i+QFmsYC2pS97DusV4dW3Ij0f//QGd1YFfjRge6+lLwosGaPFAjEZY7JtypMl/gRELbCbQ8LBAJlegX+H9L2+rQD7vvvu+1+cc86xWCwoioK/+Tf/5r/xxP40okWgAsmWkbzWLnjp6JjH4gzGHU1tGfch9cmCNq7Z397C83y6JmfTtQTKYSxo6dEbjRcpKmqEEXR1y9IcMyZm4of0Jy8iyoRw637ULKZt7wPzRdJXvsbppQD51FfY+e3fIvr8U8QvXf9XT/z3oRgm6O98H/2730P57nfzq9VX+cLtr/CXVMO97NItCtJpghWSPpR4QNFK5meHjMOO/eElVBuwzCXTq3tcGO5y584N1n1HKxxbo5SZSZkvb6GaFRYY2oBwchldnKCcIbQGsSkokiuowKeuO5LAMkx2caZi003w2yNavWG9GtI0S7L9LVrdMgpGjKMxVX7EHSqWH/wIT758l2wY4e65Rn24oBcarEaUju0shtBS94ZWL8GA8AOc81Ftj4u28WTEmTVY6xDVhkxljLIxjdkQqhVytaA2LeOtMRMreXmRM/Am8Ib70Z/9TczxErF/L0IKOtshpE8oPOrcY+v1M8zekFqsKDrDeHuPPp4Rej5KLzEa+lKSCMV0b49N61HpnqZx6KJiMtmi6DuKviCIJcJ2hNuXKYobzFe3mWRX8QYplSvw2pqxjInQ5NUcM4JWQTQY4GmNLQqaozPCrRmm3BD7FmECqjynmy9pJlMmgynJxW3KpkMfzdG6w6MHoRDSg2iEPXkdnIfc2kIWNWtnyXzJxA/wes08P8W2PWk0oW031KambnNG2QRdLBGej/dN72vdG9pKI5WglQ2e8BgEA4QQ51nWxmC0RXmSIPRpqp621khP4uhZFhseTEO8dArOMhKKhTdi5Cpst2IuYjw0nWkZJBN2s4yuXWJVgMp8YuHo7twkYAHDCyAEUhuG8Yg8n1O1Lck3BeVQAZ5SrJuOSvoM7Xk1TmvD7iCka3rKwMM3Am8447lnX2NgPa4MpoSZD4CSAhXDfeMrfO3wGzx7/CLvv/oudKcJ0zFSW7zKsvIaQtMxDkY4r6NvBL300FWLNlD0kjgp8ZUPfYka+aTjEbQRZ8sVDkEUTImjMbUtmC9vEeoZOhwShVN851HpDu3g6lhyqiWtlRys5pw2t7m+vM6ri+sUXUVvHUiPe3ce5hrbvGV0kdD3+dvP/BS/9sz/yIVH/32m8RYmG5ANUtp6Tt8tAINpJW6cEGUJYKhuHUIXIHRBurWP632cMrjVknhxRBj6VFsZs72YqZVUwtIai40GqOEU3d2hfP06F2aPEogI09a4vAClqENQ/YqxCGnFDml5iGkFZjCilA1NXOPZOdbFBPEuYlVgO0Vt/fPEqTujVwNGuzM+d+dpnnr9M/iq4/se+CCP3/sd6Nwg/IZ2reirlFaGnCwP8cWUa4HP1dDy6OwBDha3CYpT6lMF6w3beUdXHdHvXaR5x4/AoOeTt69jXr7B40+9zOzFbzB45hlk/YcLTUpjGHz1aQZffZq9v/eP6S5cYP22J8nf910MvvfDbG7exL52g8nFHXKb4volQ2H50u3f4f/69Z/ls0e/gwvdHzo+wAf2381fvPxDvDt9knZ9iBYBsi5YFCWeiHnMv8LnNs/y9NkLPLh/D8nWDHlhH5eEnN55gbNFCXFGur3P/sV76Nwdjg5r0sk2unLMmxJoUNzEuDNUnNBHezR3j/Ge/wrH7THV4+/nweFbsKszmtcP8QuDihVltkV0/714N67Tr5bcO77AsnOIJMGXc8TqGB0ronRAX5yxtmNUMmQ4HNAUPetVjRh5qMAnUBO6YoNXLgjSGZuqQdme8c5VTA++J5BOsOk2rNslxo/pXU2na3rdo9QAY2BeV3heyyQcQp7TmQ6VZIggQOucYZzhd5IkirAjn7Y8oxU+yc42sWnZbFbEXoCfnStnZ8kIPT+lyAy+7yMxHJWnbOqWkXXIqCXsfUIpOfFCDosVu16MH/hY6WGcj/B8lBI4B16d006nGGvwwxBfdhglkUoj/XM3lD6MuJwOqEqDp905ndn00Nc4AkR4buEngwADtHnFmXRkpcEFDnyfgYN5r6mMJfYVrjU4bRFRhPJLMgnL3sdULV2cEESOrltSlT2d60gHGZ42qF6i2w7rK+K9GV3Z0RQ54ShD45ACAmGopceirAidpewa5mXDFQ/iICCaDpA43PIUmQaE4QXs5gbaWR7aepCX59dZVSu20iGbbkNoHZXz6Z1m1a5IgoRBMOC5o+fZSvZ4+9V3QLuhUR52MCSoBUGR443GdLJESEdlfZSzTLoKF4bUcUIkBZ0VOOfItWHk/95WPlAB333tA/zDp/8Jz62uc/nCB2ibkiANqKsVDWu8SLG/dw1JytH6gE/d+jQvnj1HDzy68yhvuvctPDF5gGkwJm81zjkSJUhsxo/d92f5uVs/z0+9/PP85Jv/EqIZ0FpDX7UM4wilQ4zrcdKheocTAbN4RqU8lpu7jKMhw3iENiu6bgE2JfRj8mqOClMCFVCsG1oFF30JDpRSjOIhrEH7PUVVQaIojUN5HvujhNwoEDEbL2Q0AK8+ptYtk8GY0IR4m5LUbwi3t9nIAJbHqCQgH1zBI2PYGGxTclod0YmA68tXyal598V3MCDGW/UUYUzfOirXszeKUIMBgZJsCZ+NX2JrqDeHLLUHjcZTGpfsMkSzaVuEq0kG2/S9oU0jyjilFB1ytSH0t0juucJAwxvDq2TiEh8z/5RP2Zc5nQ/5s1feTRf52OoYW/msTnsGoUQSYkJL059SO59RFOF1BaPhFZ5TrwMBP3Tpu/j+K99Hd5oTzibM3TEvLg54cfE8t6o7fH7xZVbtH1w8u1Xc5b95+af4f738j3jf9pP84M538V2bIf70Amk6IFEttlxSehG3X7tDlIwpuwobKh7bn9FsCuZ1z3D/AtHBAd3dA9rd+6n9IWO/xMzvEvgr/OGDVI1HGrl/iX34JxnfVoC9Xq/5gR/4gX/pnFKK3d1dPvjBD/KhD33oj2Vyf9qgTE4iS0IvRDYbbp2dct/uFbw04tLuPczkFrdPTyi7ggtAEuyRV3fxzOvU0T5BltIISyQHmK4Dabi9efW8RzsLaTYgbEdy9jo63UO5MeLTLzP82vMkv/Fpov/+Z/Dy/F9rzlYINtfu57ffNOPzj+/w3T/4F3h87zHCYItOVlx58YAvHvgcb8544OIbyFc3GZ1cJ5pNyK2gbQ9YaMV0EDMyE7pKsrMz5PWm4vgoZ+h7oIaU7gZxYEjaEaEQlFWF3Bui+4reH9DlLVnR07JkWRt2lEFENafOYZRmLCRxNqXpBS4NoOg47EvKLmffQSYUs3CEs4pqk/P6YkGhJDvDGds/+ja8LKJdL4h80L5iVTY411J6isAFeNIjDQP83JFcuEq9WFPmJ6iLU7LYUrQVtZTM24poGDELA07bAUXYoI6PMHGI3LsAxzWmWhFt7aLvf5DwNz9P8dLz8NhDZEFGpStCP6XtDfap3yHrNcv7HiSOY9rQZ+kKiq7lftnTriukHOOkYzBJiMMQfzWlbzSt7DDliiDp8ASc5odcGoxwpUS3GjOLMTnos5wyz0l3LhI4RdJb8H1k05Duz2g8R1HlbE12UF5Hc3KKPjqmNyXR3jZqvIN2ObIscb7EZRl1b85pwVJSlCWjUCKzFNsaZCiwRqF8h+vPq1Ai8AgxRNkQWy1Y6obYzwBDL3xG6Yi8OsMb7GB7jT8470vrmvMAWvkS7bdorZkEk9/tWQsiDykFurP0rcFoge4MVddgrWXjFlAXjMZbkGxBl9NXBSaYsKV7TDBC+0N66VAmYhAOGPiGeSepnCQDgnSAGEwwTYVZLlHjMU5rIhmSJAmV66nrmjRNEcpHIymcIRI+iRCsihpPOgZxRNd3rFtH5huKZsFpU/Hui28klBU0wP9k8+IaHr30EB97+dM8e+cFPnD1nTjrqPKaOMjwnUS0ila16FCiXcfRsidIYibFKVIqcj1iYxus6fG8iCCWKOmRjcbnlj+bgjJf05Y9uakIpc9uNMDzRhzXPQWayHnEmeUkv8PTy2NeeOEGTV/gqXN1+YuDC7xx7y3sj+/lvskVnPBIK03YFNhixY/c/xF+5tWP8csnT/Hnrv0ZqHLSNCHoLEfLI5L0EvFgi85qRN2gnE8YJZSiBd2j2oaxTfGd5mxzA90agtk+l7c6xCSgWWvoGhIkJvIQqU8bxihhUKpEyARjc1y1wm1lLNtjsmTIKLzIq7dP6ciI2oa8WnKS36aNFHF4iXZeEx69xqbUjP0ZKkzZfuAezjaSu2XF0y/8M768uU7ihfzYm/49Hr70BjabEiEVSVzg1iV+n2EmF4mLgm6dsxophPC56D3IK/KUry1O6W7eJbACNxzQZQkmvZd1XfD6KGIcpZxcuY9bD76VLoxZRgHtN75O9Bu/xeSzv8nw9Zt/5H09ODhg+5d+me1f+mXsfxmRPvkO5k88gffOh8nbY/4/B5/iZw5+nevlH+Ab8/swVBk/uPc+/tO3/Wc8vvdmyqrmuFhytjxmFiWEmYfyZ0SjPbZEyO5ql5fmL7MeHTO68BiV6+nnJ/i6ZhpIVDIhSLfRZQ/DCRwtoMhxSmBJSQf3EJQ3aAGjBLU5wp7c5Oz1r3J4ecgH3/7DxGyjj0q8RmOFI0581s6QvONB7I3bJF99GfPhe5g3LZ4VTMNd2volOt0SiwzBkkU7ZJJ6pKOQzoFd1niNQyuLF8a0QUa5Ogbj0UcpCQ2eq7EmpS97OtNyqzgiHE4ZD3Y4OrtJ2a0Q2hBFISeLOR2SC+kQr9rghE8fKBIb0NAjhSQMY2zX4znJLFIc5zWbKsDvLaHzEcbRRB2BigEQypHhs7CKTpeoKGS+nmNLx55vCaOAvKgYRIp7RttcX5yx7EqSdAu/h8BzCD9GyQrbCgLfp5KWznb4ShB4mi7aR9kc4QmW63MV79jz2XiGqHM44xDNBufAyQjp+7+3l0BxvLyDmoa0vaPTjkAIfAGRFBTaEAcewpO4ziADhUxT1mcr0mxIRERd1vR9jxV3aEqfLNklDjJk6CFEDTdv4SU96JxktEPVLWnXOcEkQ9c5yrVsTfdpG828blChz6jt0U2Hn6SEaQz5HGfABRO0rUi8GO0sD87uQwA3Vtd5bPcNxKKgrg6R4ZAoHjEKR0yiCc8cfYNNteF7r34XajDD1HOa4pgguYAXhciqpJ8v8ExPPJ5iogzlGuymYLC1RelgxHnV2pdQW0ds7e/an2mruXdylYe2HuD55cu858LbmaQeYTAg9ACvQ/oxt8pjfvvVp/jG6QtY43jDlTfzxOQJRvGISAhEpTm7vaBPAqbjGNU3tJXmvssP8+89/MP84+d/mn/6/M/x5x7431MlDs/ByEvZ1AbTQed1CKuoe832eEgaJnRtRSthnASYMqZsFkQiREqBw+CHATL2WJzUBIEkUx6ut4hQoXuDL0K2JmMWeYdGsRMrRp6iaTzkWU4YhCjZIIIthsLhOoG2Ak8sWOuWXnjM4gDtAtauRsseL7vANLyPVPf0y0OQHuM44hvLr6Gk5truPsIKyvmCYztETh3TQUo2iOmE5mSxptUNnTRspWOGvSQRKWGUU8s96qal7S1FvUZWC1IZYJA4mdJ1IT2OVlpsNKORMFKCwghG/YC/dO0H+GT3Il8/e5alnvMX3/ljmGxArPbRpWTlKqLhNqbvODw6pHcKr2k4dpaPv/6b3J3fYi+7jx9++P3M1B4H65dZnB0yGl3gzdtv5B3772MsUvROxmde+Tl+7uVf4fOHn/sDBdYsls+ePsVnT59iJFO+5/r7+U/u+X7eILYwViLSKXJzTJ0fU/sxvpUc371D5EGrAnS9wqUp5fWbFO0t9CihPCsQi5so1bARMTI/4croEt55yeFPPL6tAPuBBx7gH/yDf/DHPZc/9bC1ZlmcEe1sM7Ej6qZj0XRcmVwgDTLmp2fIeICPxisbivmLzJs5Ns7J4inLTUZtHCa1RPTUrcB0M0K5ZHDc4H3uabJXXmP4ymskNw8I5/96wfT/hHJ3h34yY729x6t/8S/z2qWSzx79Bo9deRNXJ7sEdXdeiWk37A62mSUTnl9e572P/BDTyy3BnZfQ65ZVvyFPPcJ4l4u719CvHdP34CuP8VByeGPBRgaMtgWZX4FJqI+XBNOMS8OY4+EYkUvseJ9aatLc0d86ZB6tkdt7XBoWeNGA1tb4KiKIIs6MT0FNYGtqFFPbcu/2w9Sxo17dxcmUg/kJbWgZpg1Tm7BZn9AtGqx0rPSCovQQcsruLME2Ftc7/FihW+g3Nc3Ykm9yFouK5KKmNw2mqfC9kEp5dMJibM/A81mtBUoatGjRhKxETuIM48DRjqb4w13UjdtUfUlrWowzJEQsFjfJvvibeFFM8OZ3Uo+GpK3F6FvUqxsc+ym7NmM4ixGuIwh8hJKEUcygbbglYZIE2Lai79aUTQ6zC3Rlx6bqOYwlk2zIwEREusEtNvRKYaWH2N7GmIo0uIcwiDis7rBxPWNrkdKnrSpE6qHGO3S9QSiPrXuuYjcbVkVOZFKCcYIMIorVGVk4IhiluFpjVgUiGeF8w+nxIYXMmMaCanWGcoL1yR1UltAPQpR/HsA6UxP0Pov5KYEMkGFIU/WYzuKHChE6Nk1F4iXnFdnfB++bdHDnHFY7rNB0laZctxwvb5OYgFZOSKzEqgRnN0S6pC/PPbpHownKBdRNjQoE0vQEfkRtLamTGOsIowwRca4Uv1iAEFhnmQ3GrHDUbYnneQRhyMopQmVIpaDoLVZo4thDWksiJQWKRd7y0uZFVKB4/OpbIRpCswFrMEFGa1pmyYxr21e5cXaTclNjSkMpa7am+5zeOmQYK9Roh8Nyg+0kwgl2o5BQO2Tso+eHKA3D/ftRYULVnmGJyJuOdW84dRuWTcvMH33TzmxMZDSdbWnaki8fP8/B5mWW9S361oJUdAQ8OHuEx3Yf4a0XHyEKMzbakEhB6xwSQRp6WG+AUI4nZ2/lle6Y37nzFb44fp53jO6nWChkvUb7IenWEE+FWN1RFyVJmiBSH9V1hMGE1XJBHDisaSmimMD27CQRQTZiISJORMlOkJK6jtz6rPM1UZoxnA3RSuF0i14dgyfJ/QipU3aG94C1hLqn0AmROuP47hepdM9gcoEmGmMWd7AHJwTZiPvuHRBvb0GtWde3+IXqKeblIQ+lF3hL+k522oSD0xwpJDtJS7m+RV4aOhswdvDkww9y8/guLuoZhVMenm/4VNnwDf0yV+RVxklILypkvEXuDWnygqrI2BI7bJlbrBNL4CLWr91knc24+B//Z3zjP/zLjI5f5/Knfp3Rl77G4Bsv/JFaGrJpSH77syS//Vn4u3D7kuAz3+W4fs8fvkY8OnmQn9j7KN81+ghb98Dw4qO0nWTpWXpPs79/mX4+57jvadyMSRjRjaY8MH2CFxcv8IX5s5jhHsOyYzf2SQd72HCN9YfkpSCvW4xzjPe3aY9vc9ptGMS7hLsp8qjFTy4Qqy0WlSZ95UWO6wM2j7yZNyUj1lFIUY9Z37qBPxuifI9A9OQPPMZo9xXE018j/473MfICtmpDFyc0/YBlsWKraZGZpvMtvRL0xqEVROMA01gEUJQ9cTSmOLuDkCuS0YzIrqApEfGY+bLitj5Dex73jneRQiJFRNGsSURC2/ds8pzRYMxANdAU6O193GJJEA3Z6JbEP7ezEp7ANQ0Dqam2dqhzx+pgznCYkSQDGtFinUUKiVAO6SdENsDaktcXR3iN43I2I/UVXuhzslgTeAOGnsc0zNCuJo4DjssekUiGfozUObbr8cfb+N2C3rR4EnwvJJQR2tRsvJLeOS7KgN46rJIEUuCqEuE6nIyBDuH74By6ydms7tD0ObsiY+VyFr0jdedV74GnOOs0pbGkgcJVPU5bCMPzPuSuYbQ7I/AVy+Ua6zx8OST1h+ffb+qjFzkineFNNLY+A+sRjwfUi5y+qhG6orOWWComiU9pQjCaQPQURiD8ANkuzxPFaoTrLY1rGEcjPCEx0rCVzLixuk6nDRN1rlgOUFiHkgpPePzmzc8RSp93XXkbQkpK5SOVj+tq4ixDTSZ0R6fY9Rw5uYz0fUzdnydI4oi6N3TfFML0hMQJx1obtnyBEIK8y5FS8uOP/ih/5wt/l4/d+DX+yht/FKFqQie4WxZ89ebX+PLhV9Cd4drwEb7z6vvZn1yg70vuVmdcne2TEHDz1pqw63DS0RQbQhFgUp+3pG/isDrg09c/wS+++k/4M+/4Ma6lU0SrWK5Lulwip+a8xcaAUx5KSrYG91CKDbWtsVLQ94JE9mhVEYYBQvjUzlJ7gpmQ52yB3tDDeSU7VKysoxGOTDvG6XkI4yUhQbfExjGp6uiMI/DGYNb4Tc4o9KmyhOWqxBsKPHrKWBFjuJReBN+jKB2VGuLynMqtOOpy3nbhzexKRaDh9coxl7BdN6jUMa9avM4yDkKqaIfNZoMYpdh5TyaWmFHEZHgBeeN5UCl6fJHYzrHVAW1wlb7RyH7Dtm8RwyEL6xH2mkHXk+c9fuhzYbbL9/uXeU59g986+Tr/7VN/jx966MNcufQIg8hwd7liE4zxU8eiXDHoDc+fPsXHD76MdYJ3bb2NJ3ffTdsXnOTHKF/TasuiA7ycLREQJRavynn/wz/Kux7+93nx7imfePbv8Ut3fp7NH0InX9uSf3r8K/zT41/h8eRefuzC9/FB/3uJA8htyywS9LZlc7KhTC9QGgftGWGQ0o0G5OWC1p2xbuegN/iRIqluE8YZB2vLOJ0xDIffUjzybzO+rQD7C1/4wh/5/K1bt7hy5cq3NaE/zfh/f+2nefnO1/jfbv3vuEBMGI95enWH7XBCpAecLZZoAZ4wiGFEpk6phaZwQ1zrk01miL6hu32TnesvsvWlr3Pp6a8Tv/g8/vrbC6YBdBxz8sZHqN7xLvIL9+I//yxO+dTf/z3Ejz7M7zz19/FVylu2LtMLwZk0JO2cuN0Qy10en9zH145f4JX5TXY9RTD20L1CMcbR4NqCumxJOg1eigwU9fGGVmrSdICdv0RqDHXhWMiGYTBBiRqRL2kt6HBE5xruuXI/vblOX69ZdDO22oq0PkOiMH7AWX3CSjcMZcfKKhI/IHZzjCqI4y0ON8c0qzOKYoG3t4sQDusn3F5ukLLFBQ2218zCASQZkTcgSxVN01DXOfQGP4oJ4wAnBDbMmPoCnYZ4VkPT4ELHsuiI+oqpTCmLkmagUPWKxdEhq6ZmO/Zx9ZxtArr77yN44UVGR0vyrRTf9nStj/fCq6i8wPvQR0l2L1M2OTYKyJcjMrUk8CVVkOK5hkB6eN75pS5jj6iSsDGY0MfYU2gLRA/rqgOnOLOWNBhyXxBTbHrSS/tUd2+S375FtLWLt7eL7mooOvw+JLagpaX0BGNf0PtbiCykPD7GdYL0ygX8NGKkDSvnyFdrJtIRKcmqqsh1xki3tOsNZr1C7owpOsditWE20KTphMJCmYAMYqbBmPV4TDgYMAsTzk5ywmCEXVTUkYCmBQTxMMDzJYtmcc4w8NM/9D8uhED5gmyYUHnVeV9kt2F/6yHqXhKXPWutofcIqzPy1hBkU+I4RDiF8EKs7XF0pOGI2kFjHc5YQhUivY7ei1GVpj08xAnDaGdC2/U0fYXMAxatwZMeM6+lNJZSWwaBQaCQxlKXmiiMkYHkuVsvE/ohD8yugfTOj3pFvb6FdJo4Vjw6ucIrJ6/w6tErzPw9XGAJgow4itmYhqQdgZOYvmQceYS9h4gzbBJjTm9BPSASEuFprLVoCZ0piX3DpekMp0D0AWXZ4YmI2jUsy2P+v8/8Y0pTE4Xw2M5DXBvex7XRFVS2zbJs2B9MqbQ4v749heBchG7iK3AGYSQMx9jNih+5/H5eW9zg06/9JpfuGUO7YhBPySYXCT2DLRsM5z30peswfY8tG5LRZeZnL/Pi9a8w2LnEhSsPwMFNlqzYEpeQXULVrFEzxzAYcHDrOk1esTO4nzSJaCixUiOsxGxtUfeO1Etpm5ZiviCxhjU5h8WcollhowlOeZzmZ2BLKuVzcXcXu7dN0a55+rWn+MSdp1hLwRv338OP3/M2Nr1ifbIgbc4Idi6hK0sxP2MlQjpp2NUNKMEwycito+4MAwNTF3O3O+At197IXrpLKg5Yas0mbJn6Y+K24fJsSCIn3A1yFmfHGAFx57MpG0QWsN6O+fpHHuTonSH65H52Xj3gwVcOeOszR+yu/2grsLffcXz2p+CfPAb/pw/DwTf3QYHw+e7mAf7Sa7tc+6GP4NRVpNngh1c5Wb9OaEdoFzJWEdvjhKVdsSo8jJXczQXaVVwZ38PIT7hVvMq767eyO8jwGNI6h28dka+oNoal68mUZDAZUbjbFKcLLl6+iBQNOvAhHqCriO7oFHX9JeY7Y976+AeQ1RxncmRT0HcLbKWZ+WOkH1HIlNG73kn/C79I9uzXEW94G7YzTGaQiwnNpkOXZ+CneIOaIPBZVh1CQDCOUMuWRgqqUqPLHhWO6NucKNtGxDFtXpMvFhzmOeHU557BjKBr6bsOYSHvGoQXoNs10glGUYToO1ToUbgOzwp6z+FwROqcWi08cOsFpBGDbIJWLeZgTVEUZOmQxrY0uiFRIcJ0yHSEq3uKpuRsecTDs3u5uneJ6uiYvqkxXYu1GbbTRMMZpj5l6Du0UNTWYBy41pAKg0gnBDqnKo4JszHKH1EtW1AhuSxIopDIGFprkUIQ+OA2G9wgxGmB8BSir9DthvVqTh2GpPGYoVPIYMOZ1ZRVS5ZGKCFIlKQ0liTwQApcZ6iUQMQJkWlxWhMmkOqAfBEQhQrlSWTi4/oOW/fIwQA1jOlrgTUNqtNEYUjb6fOEmkpoioJ4MKQR4HUt2mriIKLtCrI0QKQzpAFdtnR0TJIJiReyaBZcGV/iS3ef5nTzOuM0IxpuQ72iaxYEyYxXF69xsDnkPTtvI45TjDU0tiNI9tB1SdCuENkWIo6QpUTnNbIHJzy8NEHYntTzyLUlEILWWiaex1l/nnyQrqW3PZNwgh/7fOfV9/Cp65/g88df5f7xFp+59RxfPn4ZTyge23mUt+6+BdGMGI7GZEJyJDSxUgRO0UrJYHtE7CxWaYxpySYZvdN0WvG91z7C6eIuX54/Q/baDve96cdJBophrdksa6RvMK5DyZgeiKUgG8YoDXmXn4tw6Rgte5Rck6Ypzvmc5RVe5J/T3juL6TVdazChZF1rQm3YzgJcbX+3vUsqhQRCT5A6gbY9ToVop2iqNaGS7M/uZV4vKNoGlQyZjqeItqTrBLNxiue13Kha3GrF9cMvEDjBg1uP0dsBzUmO7xxbY8uVYcwgHrLoewbCxw98Ei/ENg0HZc20WLObhJjkIoHpz21DBwPSeMCkd5SsQS9J3YhOtdimIVYjNpHHShiW85rlacHOtsIORjR1w5PbbyHNrvDxW/+cf/jCr/C2Ft6y/xZ6Ca6COPOJA8nzJ1/gc/NvMMxmfM/kSd68fRWcpFwEnJ7eQqm7eNE2LpJcDAMu+AMcJe26ZjLbw4iGY5XwA2/8K3zvpY/wj1/7GU66u3xj+Q1q0/yB68Gz1Q2effXv8l9d//uEMsBxXu02zmCd+7aUzv/Wd/8t/vN3/8m3e/5jFzkD+KEf+iG++tWv/q8x9L+7+Gt/jR987WluHbzA+Gevs+uN2O5bdpqKgfOIGs2byhJpNb4xKNujtOFq1UDXI3WP6PW/0rblW4ENAtprD9G97X2s3/4YL+wOkBGMjwrSz3wJMRzw2kfex6VHr/FbNz7Botvwzr03MshmKCLSJGSIj84Naxfz2NZVvrp5nmdPPs/+7AkKAgJvSpwN2L64S1nVHB4ds7UsiHYkdlXS1ZK+X3JwfIe0XpONMuqupfXhrL7NcDhG1RvM1kWqwNHVFZ1KYHfA8LRlrgsOEASncxrfI1FT0AHGSnqtWJuEoW3JabnrdTSFYFHFVN0RYRBhlzlhbEinKZXQ7OztE1Q1zl+SjRxBHFCbED/ySdOUzfKA1ghkOsDVFVYI4tkM37ZYFFtpRBf4uC5n5WDR1ERNxTCMOQsirPE4PLuD8EOmg4BV0TE2LfKJ+ym//nXKL3+V2UfeT+081laSPP0ShBHBu95LK8G1gjowlF7ARdlzJZywlIrj6pRJPCJ16Tf7jgV2EBBvCkxdUbFBqA3WDbh7ZNnZGRIkjivBGInBo8ZJn2hnh+7uAWVdUrzyFYpmg1AJIpswjCx4PvXyNmXZYYcP0hnHIB7gK4NoSlzkEycRi04jZEB/smZR1vRFwdkyxvd8RFOggog+TGl72Nr22U06bBAjIp8+6BkPtrCmQ0ofIToGwYhKGFaNI6jBDWLytiAdRPiBougKrLOMw/HvUsP/KHiehxKC+eo1snTEcLxD70lcKLCdInUxzdldFq3PNPKI9HlgHiUh5bpAo/GziMA4KmPxtDtXD/cjWtORjCaYO3ehKxF6wGi4zfHigJOmRJcdl0YBvlKURYuQgsBpNAHNqqbpBcOdkCjS3Mlv88jWwyjxTSqVF+KSLRrXEYnz3/rR9AK/1LW8vPwabx+9BbcKWM+AKERrjbSay4OUw7qhdmvqssYbXEF3EI5T6AfUqyV1U6BDn8APiWVMGKZEiceqXdDqgr04JDaKRof85upVKrvkuy+9m7ff/wG2k20ia6k2a1wLi86yzHP6MGFLSeJAMu81AyXxpMBJSV+3HN1Y4iKPJFZ83/YH+fvP/ww/+9LH+AsPfC+bvqAfjjFnDVr3EGRMwpCmqCjONiTVBmckdeURxjMuX7wHUa1pu5oyMLTlnE3fYBQs3DFG9qy6EwJhoXGYUNI7w6bNUeMBS9vT1A3RIGK5PqPJ53gDcGbNcSsRbYnvRRTlBtV0eMkUL7nAhdGETI35+Zuf5gs3PsMgnfCjl7+H6WCflRewGygOiEhpmeqag76GeMq+qjlzLQQeXVEwiCKavGS1XrGXhDxy+Qk+efoFtK1AWtxgxHwloCiZDCe4tiNs13jaMjOCF9sb/HzxJZ5ZPsXdGwfk+g+wzLryzeOD8MZj+OjL8GdehnfegT9M0/XPPQff/zL8nQ+ltH/+L/He0duxL73Ofa88hb2xodk5Q+QbKtHRihw5vpcw2qamp8588uGQqreE9OS9wawrjFnz6PBevnb2JebNXR667/vxhMbZir6M6A8XuMixkR5BHFM2hkWnEG1P2p17NtdBRioFZRQhn3uKZXVA84638Pj4SUQNadnglKXZ8klUSFz1lBMfLXyaN7+F5OMfh995ivCht1FGCl/UpH5MpiYs/ZyB7RB2RRzA3c2aneEAozwGaYBtGjZ9yY708YeXKY5fQDUbCi9gIyzd8pg0lGz5F9BlzdI1SN9HtBVaKU7rFYkeMw6HhKZDZiOQNX05J1YRrTxP2Klv+jOji3M/aX9EJCWyBzEaIujoigrhGUpKYqPP73/ZiLu3XqBzHbuDMf44wQsj4jgm14Y49NB1Q5cEqCQhsQOausCXAwbCQ9FTWp829hh2JV48xixewEQpSg2BNZWFqlbsJD6u62msxZcCaWqstSBTXHmEUJa+8VnrDoIpfjoh6Ft00zLMBuR9xzyvSZMQIQSpktTGUhhL9k3LrqqHeJDglRpblphYE/gBofUQskMmPgiwRYGQCpVESOkh/BjreyinkDonbDZoX2GChLaukEoxS1KWZY7n+UyFpnCOxhsRSYWQ0NgGekc0iFBSkgUZ90yu8NSdr3D95Bvcc997ibyQ3g+w1QlRustnbv4WEsH7Lr8LPEHZF0ghUV6CjD0CvYF6ie17/K2t87WybvEHYwQl6IYkHFIJi3YWi8ABqZJs+g5hCgbB7zG1PnTt/Tx1+7f59eu/wceRWOe4Nr2X99/znbx5/wnypuXpO8cEpsRJQdN17CRjemNZlxXbowzV9qi+wR8PKZVDY2m0YOArfuDqD3JiTnnm8Mt8enSJH3zg/YynEWXT0246OtWSZAmNNgwE2LIkyjIa0bDoFwQ2oXc9nqgJghFVK8+LDNOYMPYxrqc4qygTDy+NcHVJU5ww274Pozz6xiBTAT2oJMCTYIRHZXrwIgJdUHkC5XwyKRkPtqlY4nkhfpiio4ymbFmvW6JxBAMPvTQ8ffAaQSLZ6qDSFtEEBBfuIw0lpl5zlp/QWo03u4dpEFKvHWnkE86XtMqwIGJHQrdYgfIQcYTfd1gvwo8ymrO7VEajRkNEE7IoLVI0RKHPTdPg6w7pUmrrk4QSF8Jj0R4j/RE+Ub/El2/9BjeWL/PR+7+HSzLi6bNjPn7zH9E3C+6fPsj3Xv1uvCYmvjg8VzDfVCy0QPaCVq8odMSVQlAOFXbqsdCW6OAWmwSsaxgNdtgdX+WH9DHPnj7Lf3Hfj3MrbPjp53+BL8//4NhOO4M2f7jOx78OjP327Mf+bcO3FGB/8IMf/Nca9NVXX/22JvOnGn/7b/Ng3/MgALd+9/Tg970k4Y8ffZKgH30M+9BDbAgQZwuO/uxPUO09SKpzvKxhkvWEX7xF+NufpZ2OmP/Ej5P7pzy/ucXXT77OXjLm/tE19oPLzEjx2xxranIVk9qcKBmQhAk3Nq/C6Alqo3DTbSIqtkzGztaYG4tDGj/ANXOOnz/COkUzuEvXNwTDy+AprGiZRQMaDqksqL4Hb4AxGlv05H5LKH38dJtw09JsHBu/ZyYisnCLtVWYfM7aZAi/QeiCrgtYtRXjccglFbHoBkSze1DFMVHXk9UNhYtY9IppK8nSMb6/AXOGwmdTC7aygMD2iCSjUxGLwyM6GTLYn1HnxwTKoLItgnhMWg/QtmKTF5wpwaW9S0TtnKXMOFrc4JqI8cYTfAmyWRPfcz967/O0r95l481ouprg9nXU6QL35jfSSoGpFYEKqEINDlIT48qG2WwL2ztq13FanTKLRigV0riaOCroy5KzyiBExXT0MItNQK4t20lEagI62RClEV1R4rqaaHubhe0Ry1cIspDc8xjIgDBNsGWOR8JZvcGGpwyjPcJkhL/jY6sCs1zhSUHftESjCUErQWuidJ+F9GlbiGVEHaSUpSP0FJPxCOFyqs0xzmo8JxBphj47JhI+Hoa+rxkFPutVzbKFi2FK6/Wsuw2+llS6IvMzfOn/IRdADUKB93vei117QtXU3HvpYUKlqFvDSgmiyGPiwTqClXOEwxRroO01QgqE1WjAl4rEWVba0PaaQegRqZhGN+i2xkUhQQK26fB8zaYW1Cy4PNyhLTqWosS6gEEQoJue2nSIvCeaDoiHAV+6+xy+Etw3eZBl1TKKfRyOZbukE5Jxso1tHXuThxkPdnl+fYd37b+HTePOq7SpZChqmr6lX2riztDpgqOyJJV7xFmEyIbUm4a+75Bdzmh4ldQf0VearuqRniQwPqfmjNFwTBJEuM2a1158llko+Mg9b0KHM+pQkvoBgdDopmMQR9xa5FzJPISGeWdQgSL2vknT7wzLkzVl3RJjcdmIa8MrfPf2Y/za6Vf47YMX+cDVtzFWHcN4SKEqjJUESuL5HtY5RLXGZDH79z4IXcMsmyKtTxVtyJKEk0WN7nseeOReCnvCzZOX0aLFG084OrlFUGbosMQLJcZ1GOMzTLfxA0m7PiVOJV6csm0iTk9fQpiUq6HPpnGodBc13mFiLKrv+O8//1M8t3qNh7ce4cntNxD6Q7an2xycFCy1I44VXRixli2yXYL2GdBh7Jyz1mPca8aXL+OHPhsvIxxe4PKJw538NteLu1yIMk68Gf7oGrvd68TlCWVuOOtzPpP/Dj97/Fl+++zL3/qCIOCZvfPjv/4OmJXwkVfhz7xy/jj5nxUxBh389V8raZ77H3j5P7nCa1d3QVrksmX5aEbvO6ZhyCTwaZqCcllAFFMlM7Q3IBl5yDJn2OVUwlDqBW9IH+Dp+bO8VB7whs2ave0EaUbIMGHTrlhJjdKGonSUYci8MURhwqLa4LUDWi9EtYZl3WCe+wzl0OfNj38Yt9LoEKJ0hlE7DC8+TFjPWR7M6X1IpzsEYYR64xP0n/kcwcld6vuvkDcNopVcShKuu13q9i5tvub15QFt5ziWmu3JDr7rCWyLjAM8GaGFoGCA2Cxp5QS/2GDpEV3EYtEgQx8vCQiER19X9J6k7w0DJYmtxgtD5GhMndeIskCGEUYYMqFAd9AViGaDCBNcc95CFUtJO5IEnYdA45mKdb6hChRpNOIgX3C62TDbHrJ9cZ+1sSz7nFEQEBpD6ns0dcsmTRh6kCUT6qqk92t66zPRHXY0pJSaVV3hxRmdsNi2QXqKYBCxdAVpN0XZDt2X9G3KIPIRfQ7CYBbHuLbATrdYK1A2xo8Set8jkILlsiRKR0xVwXFZsKkTRkmI/GaQnRtL7CmqzmKFIxuECJfQrc/OLfLKEM/3caoDYXFVg+00MsoQ/nm6SMoIYypcsI1QISzn+DZA+o5KC8rVuZq4aVuyJMATii4dU2iIvvnfb70e2Sm8b2r7xV7Mg7P7EU7z2uoV3is/zADopI9QPmeLW7wyv87j00eYDmZYZ2l0Q+Zn1A4CLwB/gt2c0m42dFt7aC9Be4qhH5A6DbpFRIJUKda9xjhHay2ZkhxVOQLY+31MLU/AR+9/H//kG7/Cta038KF73s6lwTaFhda0bDrHOB0xdA03+1OkE0y8lNO6I/QVss3xdIO2AS4cYjkj9hWNdvSuxwmfn3zzn+O/e/bn+dWXfpUL6YS37r2ReBhQzxuwkrZuwavpbYewDuF5hH5IrzXSaHw/RHkNxvQ0VmCdI1PnrLLCOVbOEvYGz9TAklXXM2xOGAR79LVAVxrpHN4woS9ropFPUDX0psPpGhVvsbIjRmWDVD7K+aBbLJokvIhu1syPzjg59Vi7gkTCxlQ8Ih9inTdMpET2hmB/j4GvmJ8dE6uSYV9T5kdEUYq1gmK+YFd5rGZDNoUjPT7B1muy7T2WVUPi++gwwHQSL56ysYcMOsOl8T5NGdJRYbRhbQzD5LyI1m56LoxCzDgibdcE9R5/ce8tfHb5W3zx4Iv8s+eWfPe9H+LXX/klzoo5j26/g+974AdwxYZKeByVHmXhc2fRIXaHBEi2i1MCr8HK4lxTx2S0YcJ6vuLOYomXTtkOIlqr+MBDP8yrh8/z2TtP8x/e91380Lv/Gz7/4kt8LP8Unzz7JCd68a2vLf8a+Hb9vf9tw7cUYH/pS1/iySef/F97Ln8gmqbhb/yNv8Ev/MIvEIYhQRDw1//6X/9fiKz9iUcYQv9HU/P+TdEPUtonHkG++W24J97EjVnL61cv4AcP8obBFuKlG4Q//Y8YHt9FXLsP1fdUnUD8zrMkX36e9XDE5ic+wsrrSZItPv36ryCc5MO7byXuY+xphTd0eMMRnS+p8lPi8hgbBNyT3ccziy9zu7tDun0PTjkSEyGOVgRlwKhYchJ4SDy8YcJZewq9YpbsodsUXwcMvZ6htRRyTJPXjO0IKwcE2sMFI3opGBiPdKAwQcG60cRSYXuNyBeIYIBoGrJ0xuVOUG0WlDpk5PlcGSZsTI7auozxJUEkkOGMg9MlVeVoNjlMUiZbA5yzKOUIycnbhnUxwG8q4vEOnlWcvXyTfuyTZgGbRU1cGKogQFhNHMaUZ3MSo8kHA9btmkx5FL2jliGpmSP6MWmQYFSHrWqCNzyE+9wXKF+9js0GZM9/AxtE9I+8ib5rUX7GZJSyrI4JAo+QXdpVTtAsmWRTROgzb9YcVXNSBet6jaBCxBG6zZBVx4XpkHwqqKoV8WiGrnucD9FoSHPniK7VmGwI3QGzYUwTTjDlgrU3YHfLZ1MtkHqE5ydUosUqhzYQhj4ynGDLkn6zQWw26DBCOkE4iAh2xpj5kr6rsIMBlfAQ6x5POXpf0cmA5TpnEIb0eHSxQIuApO/pCDjMT9iyFrXSiEFyvqHPxpyuFtzZ3GEST0j8PyA15Rw0a9blCcoLycZXz883G1blGV4yYRAPCTyPtuhohWU75HyDQ4wfGbxYkYQB1liaUqPLDhsqIndOf6fXFNowTc6r0lJI8nKJdIZwMqKVCfNNg9caYn+N9gRla1icLkmyhDZIaVc1MozwrSONFV3d88W7X6K3DffOdjkszlh3Cik7ij4nkhFUFudAeIpr4/v47O3Pc4hhPJ6yMxmcW7Tkc9pAsTh+HdksSLqWwnO0bk7fKfpGkBiP2GjiaEawcVhR4WSITHxUFuIZjecUzubIruFOfcRxv+TdW0+S+UO0ECw6S+NBlKXUfYcXRfimQYqeWnq0leEeEWH7DtsY6qZlXVQMJymR1si8wd9S/MDbvo+bn1/y9N0vciW6zAcv75FmCqcj6ran3PT4qxVJAJtA4Ccp+7vbrJYrjNaYzYZwkuENd2hef51KLxDdBdAe7aZjL05I9x/CsSKYz/GTXTZZS+cbtuSI1EsRRY3nJ8gkw3YGbUsCWxNl27TFGpF80yowL8iE45/f+RQvnr7EfclDfOShH2N1+hyxyVFlR9wZ7rY1k2HM4vSY4GzBJIB+OKPtI6blnNf1knmSME1TRlmGV55xqiRDlWCt5VZ3hOV+mnLGPZlkKEd88uZT/OKdT/Arh5+mtP/m1YR5Cv/8LRGfe+eUvyvH/MRXNT/5y68Tl+2/9Lro9h3e+F/+50zf8XbWl8b4dw/Ysm+jCkKON2f02xdZBgrrHLthiLdpCbKYIJTMywBZHxO6ksC1XJrtsF8/xivLW5xWB0zLK+jSsup9ujBge5oyzjKObi84XawRpmWWpkRhQHu0It9KKRtD/sXPole32bz7jdx/8Q3gjfDNmn59Xs0UF+5nI0qKQDOoayZOUAL9I29EfOZzmOe+RvzgPvOyIdAJk+GI3SzhldtL1OqQQt3gwvYDnKw3DP2IvjekQYAepKznNctNR51MCec3yM8KWrVhMthhL5zh+wEqHeAFhnyZU5zdBR2T+kPQd/CSCUpNEcUxbXVCkJ/S9T1SDQgtYHuol+BFCOXh6hq0IRuPaa3F+A6v90mzMdVizWJxyiKwHJYl460tpjFMoyH0hlVX4FmwTU8soJTnleLdJETgk9Qdteipqw0MfIJBRoijyU9YtgsKfwvZ9Iy9Ap1IjFZcGsxwxZpNdYRRCUFfQZuf22eVgjbIqHyJj89Axqw8gS8lIPDSBBtFNJ0hNhtWRUMaBXjynCZeWUtuDD2OyIEU4KIIu65hHeBcgJfG9Kam72tkVSOC8LzfW/3+ALvE2hZlesRoinMJnmhJQ0uuNfV6TaQMvkpw8ZhBFrEoO6pOE3nQS0vkx9jWoLzzcSfRhPuyXV5avE5hNOPO0JgWP57wyW/8Ms5ovvPiuxC+pNDn1etQRaw7TSwEayspS9BFTjTZJkokgRdTtAY/CAhsBeZ8X1NKQWssjXUIVxFLi5NDanuu+A1gbcdDs6v8jQ/8NbJoF3B0/QL0hrwrWfUBW4OQqPW4Uy+YeD553WGsZTdw2GqDDhNEPMb2FusMaeRT5S3zfEMaxuxM7uF/8/gP8t9+7ef5mWd/nq14zEDtUHmCYTCgaArqO0c0WyOSOMC2Lb2SpAxoRIPwfJzz6XRPoTvSyIe+Y+5gU/dkWykyX9FuOqwncCbl7lnJ5eyMvkqpGohGAdYKynVP5Cvk/JQ2UJRhwLT30drnqDNsRy1N09DpkigOsYFC6AArNtwtWi5tjzhojggmCfdP7iU0KaIxyPKYiZ3hq5SDfkM23mM7kbj5AYvVBE9r0IIwyvCihMBrKW8c0QU+O/tD3PI2cjCj78E0LSaOsFpxtjhC2DGDJAKRsilyEk8y8TWNK1jWGevQI7A9qeyY7V+hXxnePn03O0nKJ29+kX/yzM8RScmP3fdjxGKfW8uCVEpiT7KpG/q6ZjSM2b08hLZCrGqGq4ZO5jTDlNI4hAsoak3WRCSjAeu8JBI5qu15Z/YEv3rwa/zKq7/Fjzxwlft2nuA/3n6Ev3zhJ3j69PP8j/UX+cz8c/Tujy9++YNE1v4k4lsKsO+//35+4zd+41se9M1vfvO3PaH/Of7CX/gLPPfcc3zuc59ja2uLj33sY/zwD/8wv/iLv8hHP/rRP7b3+f87whCK4o9tuG4yIX/4PvqHH2B99SHWF3ZYPJKxe/kaD8yeYN1ohsVtLqxvcj0/47YRXLu0j7ywRfjqC5RPXCIYb5N//DcYvPQK3ZWrbP7MjxLECVv567xsCu7Mb/H4+BL7gwnVYkFrPJjeg4kVbWfx1YjR8F4WJudq6/OMKXlm8yrvHu8zMGtSuU1dVAjdMoxjTn04bgJ2opo0FeyYa8RJwkGxJC86hqpC+DCWIxbVAXp4icQD48MgDSicpdkEZJHEiy02L5ioAGSGrT2CrsR5Iy4kWxRFj7UD4qAnEj3r/Ca2jxnOLlLUB5y1NTE7LE3N3jCkaDXFZs2ZqUlVQTJOSIcpkbSs5zcY0hMlA+ymAyRBFtC3K3rT0GxChD9H+h7ZaETY2vMbexhzWC+4mkzpdU8WjqhNibcsSVNonEKezLHJEFfV2C9/DfvOd6FfeBm7exFv7zIi1ijfQwSGpujJ/CHGGqSnKPMl48GEwAsIki3OmhW3Ny/RO8tefIFQDwgHR9wuDOuiJNsZntuv4FFWBckwQkYJpszJe0E89UjbnGB2lS4eEW4aqmpBXnropsMhGO/sIMselGFjS6I+QvkSmaZoqfCWa7rXXqeKY4ILM2SSkBwecmgcbRIzCXxkf0679iLJaZHTuwFpa6jrii4IECoh2WzwJ1ssyzOadY5SAbPdEZW1JPZc1KfpW1z8B1gHWQv1EmMaauPw+pxsaMD0dM2SldVsTy5grcULJMaHvtL4UYvuNUYlpLGk6wrSMDrXRYgEVkHZCKKuJwwDfAeddahvWk7EXswiP2aApBKSMkhQsc8sP+NsXVAHE1yYkcQVYVXSND6hU6TOIxgmZMNzS5y7mwOuTa9x7+TieUBeljhPM1U+rtZUlCR+QlX3zJKLdDhOyjs8cunqec+4FOSLBe2iY2NSxv6SJNnFy6Y0xqKaNaP4HpxIMO11/GwH5WW4psE6gZfECGFpyxOm1tC2G9psn6dWN1FBxDvufR/CSQLPEHSKstN4oUcuFYHuuXc84ni1ZqAi/MAHX0Jn0e78s/hewDTO6Lucxi0RbkCUXeA/ePQn+OuH/zd+5fbHefcTjxHbmtApinzO/E7PYJSSTFIGekQcR/S9xnFeCckXJ8hwQF8I/GTITttxujmE3jKNZoRTxziQrMdTgqY4p+N2Ej/qUbpGtw5lIzQ+lA1WGZr5HUYOvFZSGEkU97jekA0ifunup3iuvMMDszfxIfFWFi/dwh8Nwd1ic3SdZHCRwlrSOCMdNLiTA5rQZ7q/T5eMaY8OGecrynbF+vaLDAY7BO2K3GhuFXO2ogss6hO0ArE+4adv/yN+9vY/56XVK9/yGhHIgL1om+10jy05ZFoa9oMpo/hegmTIMNzn6oXL7E8vYIueOF+w+76AF38yp/iv/xrv/cyLCPcvX1+XvvgU+19RrB96CPWTf4Vqd5uV+QYHUtF2BTPPcXky4+QgJ48M2mjQ5/RUFnNkOKRWMW/af5K7r7zK14+eo1kOCJxgeOESl7bGbIUOBhmrQYtYzvGaFW58gWBbEZzNkWeSu3WL9/mP0YUe93/nD9Dv7NC0AaLv0fMV2ID+JKcPPLKRzxifqKqoWiiTMdnD92NffhHv7M2UtYfvCXTgM1AKP5jS1EfI5pA0eohm3XN2dpfR7CqNURwUDZXWmHXDKHREuqMo1wSTjPsv7TNK9+gXK1pnqZdrRLui7CuSdYi/leCcxk4HiHiIdoY+nhD7DY2vyAZ74KdQLSDbg3QLELSHZwQ0+J4k1I7Oc/hGYHrBLB3w3MENCqvZ272EF0YE9ZLQSIZByNz2rPWSpIdIeRhfYHpNFI1p+57/H3l/GmzNdpd3gr+1Vs7Dns/4TneepHt1NUsMQrpgNQarPEDJeCLK6Eu1qzvcTXQ7TLvtxg5HmYiK6O7ojrLLjnJ1YxssZAwYDGXAwsII0Hile690h/dO73jGPeecuXKt/nCEkIwpJBWqoqqfLztO7syVK0/snXs9+X/+zxMoD69vyMo5zfgyBk1vejpb4LQrlLvDrc2chWkJvBmJm5B6Ln0ckZ0UdHdfRh0OYHgA4ZQ6PyFvayJnTKJDtLR0SjBSkqxpiUYpseewyiy93dBs16yHETPfRQhBohRHRYOnYCwVaIuVNdZxYQkm6YkGE7r1mnZ5TqAShB/Cl1qkgAuZuHAwfYXqOkQYYXWMdWMcCgZYSlsQJjFWDhG+h/ul9IO80Sjb0llI4whac+F07Upk3/HE7CGeX9/i+TvPMT54Eu129K7kc+cvcn98mcvDyxhpqZoKV0TMy45F0zJxHDwl8ZUiHk8Y+hpUj3V8emPZtIapBalrhJ8QK0WhDVnXoCkYeQm98Mh1T/ClbOy+rxBCEHrDL7VICVxnQNCV3MjmSLHLLAg5qgpiIiZRxOI8Z6QabO0QjnYotUAITW8sQoLrOBi9pm4t++MUx/G5Mjzgz7/xT/Pjz/40/93n/hl/6dG/gHJiIi9A52dk2pLLPTwhkW1FJQ2e9lGhwLgtfS/prENjckbhhHlVIa1h5HnIsKHoerwGWuuQGEEuHDph8bwc3SU4sYvj+uhNjkfDIKypvQEmHmEcl0PlM19ausBFigxRNkg1JBmFoFzmwZLRRrGrUn7h6HOEKuRqGJEUPW0J0WSKcToyu0RNdlHRGHdnSJrPWS9eRIeHTKIZhWmRjYdjNygajBNxfpLRWcizJX3tUHYV0oJrWmplWC5vY4OIDo9FrtmdTag3mmpxihA1W3cHvTzFCw07O1NCWzNfn/C2wcPsP3KF37j7af7Uw9/NnjPl6O5NhGOonJh53bBpSi4L2N/x8EyAGQ6JHYFTvsC2PiOzMfNFS+h2uJ5PolISW7G0AcNQ4me3ubQ35QoP8fLJC7y0eZp7Hn0P/d0CPPjee97E+8R7WIx/lOuL51me3+HSOGR0eC+lvw9ao4qOHenjNktWRUNpOw5kwW40w4gEJxmhBpc5Pb1F0fe88bHHGcXDb4j3/FHD10Swf+qnfurrGvTr3f/3w6//+q/z0z/903z4wx9mNpsB8IEPfIDv+q7v4q/+1b/K937v935NfZX/i8Bf+AtUZ3c5rwo2geFGfoeD4WWuqAFz6bGKY+IgYirG4Hsk0x0ysSEe7+CNJhwBbQ8Tv6Gpzllduoe1E9F3DkOjmUQ9lViT5RUbPyerNQNvh0k3ZyEcTtcVly859A9dxbz+IurGHTj+POOXX8I7fICzp/4kpQlpTza4suHzR/8Wl5aH9x7E2p6BUOCntO4+tpXUjSGsV4g+oDxasp97DNyE69XLfKt8G8H0EoNoj/VZSXl+hqImnRjm1ZZj1bI7nJDIMessJxwdkJsFk6bCjUY02waxrslSS7zKkLMYPMvMuBw5Preagp3IQ6639KMdJtbheLWl6WpG+5fp8grtBgyDFOFuWVcF8eoMJ3kYhKKuDK0jkfRMQ5fD6ZgmCllqQdvW2LJDn54hKkMY75KdnZIFEGYLivMWo1wGnk+1XdI0Fr2tiQOD9gbI8g5+EFAFATGaou94fnGOyCW7dcGycQiqU5wgpBrv4fsJXL6KHI8Rx8c0n/sCZd0xeNc7cAcRZbfBkZra1FjhM/JCbFXTBS62qJFtDlGCIwUTR3DeaUb+hFkypltrSg1tMqIQLdM6x/oJreyQEnQrqbcVOQaBwe9y+rqjdj10B0EQE2+O2IoYKQcksYd0BIHpCeOYja5ZZCt2J1OsteRlgaNbsuWSejqi61L8psFYS6McAiGIDDSuxHclmSlwA0U620W2S4LtlsxIVBDRrhZ0w4KRCVjrApNIfLclEAFnxQZJz46/S297sjYj9b7UbNFrqJZgLZUMsNbQVUu6YolLz3lTYFTAwfCAru3YVDVh4iHqnHxTIgVIpRiMp+TlhqZrWBuJo2smiUdd+RTrGmfqoOxFLnVjLS4QqICmLGn9kNhKQqkQsmMz9vC6BFZrMnePkDFBvwRajO0RlcPgcITvhFyfv4I2hif23nhhnuZ3rCqN7hQREa2sWFc5RSUxnuShw2tErzncym7hB++jLmocV4MHctXjRFNMc0KPRXoT4vktBB2Bt6b1oGot1XzN4OoIjIs+X+OYnLbT2K5ilF5ia3vOjObZ02c5THa4d+d+7OII6EiUy0nVUWGJwoCgLJCOzy0pUXXN5cBlu6mZpC5LU2Fjl8kkRpgMki2qMDgmoZ43jIMJ3/3G/4Sf/uLP8pO//WH+83f9OWhzuk1DGXr40wmT+gh/NMYNQ6qipspKHEcgfOh6hbYu08MpSeZwKnO00CROSNfU1P0ZtvExe7sgFSwKlBEIV6F1Q1nUuI5DEEgWJ7doVxuSZIYTOpT+ISfNivFwwL+69Su8tHyFa+G9vDd4F6YpwfOZ3HON7dqyKbfInZQdnSLrkjiZsM5SQrtBtCWJP6UOE8Iogabm+M51OmdONw6oiiVnm56DcsoLq4/xfzz9NJ/ZvPAHSuqGzoA/ffmP897J4/RdwCC+l4PpvVy+fJk09Dm//RrO+V2aSmMlnDWKSkXMmoDhes3WVZwPFNX2mF86/RhHf+nNDH7wf8tj/6//Dvdzn/+qcyndM/ni87R/8YNk/9f/kv23PULhCs6cNY1T0I1S9FnG6fqM3eEOh8MIPZ/TxlMSN6GpLQ9NLvHRMOHVxctcmbyZxvVJbY4UQ7bZmq6R4PkENsdVPX46o6jOsd2GJmvIbt5BLe+g3/kWHj94jHEYUVpoKhcTKrbWo50vGU0ChoMY2fmYssarKjaRj/2Wd2B/+qfpfuuT9E++l1w7oCAOPa6MYl6vhhhxlxdOXqbqxpx2ChnVSOPi+wLlWzxZE9Yt/u4OftSxMRF5VRCmFu1ZqtUx6/USOxDYYIBvppjWw6T7tEkCfkrTFcCFPBenIfAG0GYgBETTC3f+rKRre0Rf47QFsRuxNBbjQ5+3bJdzCqkYTGIGTsBZkzH1Y2gafM/DVzG1XVNToZyEvC7pTce88tG6o++WtFXF1pbc0QmTpgcLvb2IMZt6Pp03IMDgGcHU8RDlEqdvUWlMnx9T9teIwhl1X5F3K3wvJZUJttfUrkAJgTAXypvQVSgpmKQRuh5SnizYbEqiaUqkJIEUdJ1BuRKlFH3ToVWGkilaFYi+xXE9lHBpt2vCS7vQC0Tw1W4CUgb09QJrHEQ4QUiwncEmI5QbkQYF1okxNYgvVb4T36HpepZViXA8As+FXmMajXI9aHKe2Hucf/nyb/DS+Rd4o7tPMIz41OYL9NLl23aeoNE1i21H0XaMfIfS9qS+y07o4UpBmfWo8Q64Fuo1IpwwDF0WRcO2lYycBvzkS/8LuFlsOAxcYjfGAk2r2eqeoSPp+wJhHVgvscNdhOMipYdQQ8p2wdQvUXJARkUqA0QfEskl6JKCGb4bETiWqqoQrsVxFV3fIUyHK8MvjeeipMdjk8t8z8Pfyy+/9K/5yS/8c37gsR+EosfpXeSOQ+8qtFH0dUWrexybMBnOWLcnZEVNI1IaVaCFRmqIhQGvpulbRumYdXdOs94wlJbOCyjbhJgGGxdAjOs7+BFQrglSRUCM8KbUdovrQAisOstssEMUBUg5xA0kyyIjq1uuSMXy9rMcnx3ztoMnmUxHNFsXXzUM9i4jJoJiMSc0lros6OyQIBzSZ7dR8QHJeMBmdQSrJXl2hoMmqTLW2lJ6km5bkfoh0tdYD6w7YOZKsqNbmM2IMLrE2Fj24gTrTdD5lkJrMp2hbcMXVx4HsaZC0DmKuy30teK77/vj7I0O8bKGIHKw0me9NTTlljgJMUJgQ0le90xdn2GyhwqX1I4ga2vqOsfpt/h6gootJlsTpCVxF+C5Dt7kCu/xU25v7/Ivj36Lv7z7KFcdn1zv0A7BbNaoXPKe3W/nprqNVmcMnQe4dzBjag1ZuGEkB9jqgNeqY66NMhLpsTN+I7oyiNrSnCwpS8XO4TV20hlS/n7OH//LwtdEsB966KGva9Af+qEf4uMf//g3NKGvxEc+8hGA35Or/Z3f+Z388i//Mp/5zGd4+9vf/j/6PH8U8H/+Xo+zPKAvOzx/wCvLHrfveCp5lIGMcYKYhw4fQYoJTVGxGw8pREE9nOG4A1oJ/dkc3ayweLS5IYgy8ipgGbj4SrE/epBFueLo7ARHx9ACbUDQ5uQq4tZ2QzKLmLqK9DPPURVL2vsOiZ56L77XM1It81LzjJ6zKTLeffkBdsMpqzrmnvAQ2XjcOquYGEvQFvjFlo2n6KwkPbjKfe3jfHr1NEtRsEeOrpdEgWWVz8mrDXgJFOesjc9uJGAocVuFKQV5bTgXFU54GdE3qEWC7gRFvcAJSmyQsuMkuJHHYlOyYzo81dH1MeFkTH50hK4tw7yj1R17szGmTMlFxbZZoI2LE1v2eoOnNKMgYbnd8MDeHr4bIbVh6gV0jkcd+zS1JNcW0dT4TkgufE5u3KU63WKNwJ7exfqaKAhpdU/ZdQjbUuQ143tcnKwgP93iCcFz65ZDkTByOo69Q4gKAlkjDvaI0hjWa7ZXr8LzL5FutthRSvHgQwykizGA2FJoy8Cf4liNJ30yxxAlMW2+QUVDjFKU2zmpdZmpMcZUNPmSVW0YzXYw5RzbFUzdCVm5YZb6iN7h6NYJ2nFJ+nOqU0sYBqhkSl+UlHpL1JWkdkSVjGicDluB5yqUkkzCEWfLBSfHBUGtyYuKKE4YXLsXbxhiy4L89JSNHzIQEml6itYSxi5lndPWNXEwRCiJ9SOiKEH1BeHeBNnluG3OLHLQ7gA9iGltg7QtWVnj+0P2RYpwe/IuRwlFhIR6feG4HY0pV+cEXkjdKJrFHdTskKXWTIIJgR+AhUVZMkxSXKdjWxl805POxigvRpdb5vkWLx6hdYNWLvEootjW1EVHYwwD36HszYVBT9uSaUEYGSa+j25h3a3RQuNeuY/i7hGDLkfFM3Rf0rUt1XKNCDKSfoxnB3zh7AUE8Pjuo2ij2bQbJlFAvekuMrNdh23XkI47hrEPtce19BqvrW9Q5iv6yuBOYpKdGTQrjGnImgjX7Uk3W2gr5DDB8SMMW8J0RLssKW+8jusp+sUanRmayQAGQ5SKiWzHbx59krIteMcD70O4EuuE0NaodEC1rJESLg8j6q6lrmuiMKZfbhD4GN/l9maLsDBOB7gSuuXrEIHQO4iqgyCibHLedu3tvJzf5guv/Ba/8czHeOsD76TxFO7AxdZrpLGEox1M1RMGIY1w8fISohjrj+nQRIEiz0ri1oHxkE6vSeSUzfEJKohpJ/fhWo0ch8hFS9e2dO0RfjBmmM5Yl0tWFqIrDzKMIVMxgRxz8+aSZ1/8WV7d3ub+9AG+M3gnujN4lw4IzUU2cRJf4fXuJfrNHd5z6XFu3VxQ15putAtI6s0xVk9J0wRNQy0G1O6KlVlT5DlPr8/4ubsf5dPnH2Xz+0So/A4EgndN38wPpO/hzzz5g+zv7rFuznglX5GfVhdE2lqC1QrlQHjtEZz1kqKYY+dbRNAh0wFSdUxiRdyUfFKfcb054+2HT1JO3sj1//ffZfzz/5q9f/gTqP8gqcI7OeHy/+6HmL7n2/ncf/5D7D92DetlHJ/e5cwt0VkF0lDZLQ0tzuQSm03BdrtkGGkemz3J03c/gZbnPHTP2/FcwXnR4xuBbTKiyCJ1iR+MCKsMrTNyITkNYrJnfo2hgMfe8QF03tNtW3zh0OcdoYoJQ5/qfEO6qjFpio0cunmHawTC1rT3P0CYRlSffY72kfdhI8HVQYArLbdNwXgwY16WnM9P2NvfxyqfzpZcViFS97xaFKBq4iRk4RpCIXDdnNOtpZcxfuRhmhWmaYEBkUhIQ4XjOMhwTFnUlE5F1Vd4VtJIge+HqGp9IQ8PR1gL/WpFvaxAStqsw3XO8A7uxRWCutfkizPOl2v27rnCMB1QFhbqFpyAvq7w0hSMwfFioGTtGZp1ThJPyMuOoe9hnJjQaNTsCiiXaTAF26Adi+sajHEp3ZRx5BCicZo1KA8TjLBDnyib02NZrTa0siDwApJogim7C2MtedFb3bQGJQXul2Xcgr3ZDnq7ZTlfMI88LscBZdsTK4F0Fa0EUeT0psP3p3SxRtQ19D2qM7R0WOUgeotwvnrRrlRA3xUYZ4hSDgKLbfuLarTnXxhHtj2g4UuSayUFgQtH25bEvXhwbX11cS1VCbohVTtcTg65ld0g7wtUafnNG59g4M3Y9e9jXSyofI9pNGAc+ix1T6gkrpLYpsRqgwoi8N0LpUK1QgVDRqHHqnXJy5wkHIOUOLT0RiPlRYVaAImj2OoeT9cY0+I0Dma9xDYdavcyRikqERGpBGGXzJsYHIHXObSbJZcnQ4p2xLorUOWG6WCKMYa6rnFdl025JlAKxw+p+54BoFSIbzVP7j/Kplzxydf/PT/z3E/ylx/6fqLxHpt+RUXNTjBkM++o24rZwZQwCOmsx92uYNVVXJ4EDPsKLQLyfkNofEbhCNNptvWWQGtqofCajLqNKWREkNY09QrXG6NsQdnlJOGUkUk4MReV/HVZ4fQdvfIxQUrchXTbnPPNK2SmJTIJA1/z69V1hOfy8NU3UfojvKBlKkt62dEWIf7oIcb9muOTBWe3K7q8xDoB/eI2p16ApcKxJWEfsHEkiYDRbIqHZnN8h8KxyIHgzGQcOBO8BmpfscxuEpcewygmMWBciTuIiOWAO01JKGuWwueL8w2B77DrWLIerBMysC63Ts4YljVtFLCkJ6Rnz3cv/ElEQStCtkoxEiHCdvieQPmXWC1vM/IHeK5ASsFgd0qxrJiYmmILbXSZfX9Cuncv32YNv/D0j/Nb13+Jye47yeR92M6hrxY0m5ybTkCcjpBVTt21VLmHCFzisKNaX6yxhaoJ10vkZMBZl5NEO7hhyvylp+k1+NkppjtA+gH/a8A37CJ+dHTET/7kT/Lqq6/SNF/dj/Xiiy/+j54YwOc//3kGg8GXq9e/g/vvvx+AZ5555vcl2E3TfNW8ttuLxYgx5sLJ8o8YPvL8R7i1ufV7tv/a+VdI878ISiiG7oCxN2TkDwnDCRNvwlQkBJ3HmJCRN8XRPvdGE3aGV2ikZdMH+P4urhVs5nPuEQnKURCPcJdbVH+HZR0TX9pFznYxqy2bh+7FvP878fxdCAJGWc7crnlp/Wk84LHoYSLfZWUUt6XLTlPB9g5uMqL3YJVDYyVOEiGGMx4plnxu9TQ38wUPqcuUzQ36rqIs5mQk1Lc2+KlFJRFm7xA7GHN13LB+/Yy2y2g8h1I3yA6a2SFG+7R+zWZ5xMi9wpEICYcw8RxeXR2z67pky4rXWo/C8RFKY+ZbktQh8idsHIdlK8jzHh0LHggssarJREvXePg0CM8iHIsnLbXtiIRDX1jyLkRTQb5FSImVMatOoUYdcSBwzZbaWAZuQu8J5jfOcZ0FWqVIFYDfUnQrWn+EihOU7+AHI8ZqhutlyNXr9F1O2fhI61FcvQ/77HN4UqDe9S20CM7bDqfvsf2WWuyRuj6iXmGNgzYSETp0pUCsT7BOSFVvcYMBvhrRNzXbumBt4MHY56QR1EIzNZpVoemGPtpUVNsVrlchsMhW41+6gvZDqpNT+nZFOj0gCgYIqZm3NX4h2Jn4tFWJbFvUcssqXxNOh3iHlxl4IXK+ohaapm1ZbXPGDz/MsMyZFzW59PAiS0FFbEJEJ9G6BdtjwiGqaFAiR7sefn6EqS1xm1J7CdY6bMpjurbEFx4bUbAbRAS4bLMjQBL4QwhG1FWNblsGoyG6EjSbLVUzo+4aro6uYYyhlRLdW5w6RzgtZz2opkcGIRLLVnj4bcFuMmSlKwovJlIKxxfoXlPkHaORT9X3nNaGcpsRKZfE6ek7KJotVb9B+TFNH1O5YwZiw940oGOHm7dW1HVNYguWy2Oycs2zt59m5A4YkLJczhEWQhUiy4zWOvRSMp1YcDuypsKUmgfjK/z65iZ3iiPuSR/A9UO07pHKkpgthUmZ5xlJdReZCqRy0EKA0xPv7lEplz47RzNE7F4C0VGtT4mth+6WSGt5+pVPQFPw5uQ++qLASklfN2yChth1sG1P1V1UeVbbFWMnZOtItrZANR5nWc29BxMcK+jNXTZFQ2hnQE9dz4lnl1nPKzpX8Rfv/U7+3tlr/KvjTxAFV5le3mEvNGzO57TxAOtF9Is5Mo4RvqQ7W6E9gXUH0NcU9RZjGkZyinIHzM0KHxfjpFQBdPk5VatxAw8/UPTW4sQT4nFEbSSnVuJN90lVh4xSOj1gvTrlt2/9JpvsRR4YvYH3JN9KT4hzMGDvypTt3XPO1xli6LGTzCjrOafLW0RacKRz1CCica7grV9Hz19jlD6JZ3rO1yvuuIZPHv86P3vj3/BS/gdLwK+Gh7z//u/mfVf+PI85u0yPXyTcvkY5tPS+y76/y3K+oGpqjs9uoXyPwySiJaU3JV44xpsq+u0dluc9bueQBiGj8TVePPosw/QSb9p/N2eyZ1sp5Pv/M8r3fx/BP/qvuPTTv4owXy0bD//9b/DO3/4Ed//s99F+6C9xS1YXCRK1j9hsGaQexWCfbdFTtArrVbjNkjfs3M9v3vo4zxTPcFnfiyN8qqoFA55uSU/vwvmWILmKktAKD8eJKc9v4999heLee7iyfy+dlXR9T5S64EI/mOI3c2qbky8y/PF9CM/BOCUqjAi7jjrf0l+7gj56jskrL+O+91uw1rDarDHCMEwGnOQTPHVGUb2CKwI2G43rxISuz8ZonCSkFAVSCzwZ46tz1kIj6w1eH2CEIQ0dNsUCvwN3GBHGLgwC+rrldH6OFzp4GjolSVSAyU+x6QG21hf9sZ2F+KI1ojyTNOsjrHOEE4+5cb7A1EvSQcKl9DIVBet2xTidIFGUyxVhEGBNR6sz9sMh684y8cdM4illLUmHEfU8x1EOarjLWbWiaAtcWyGlD55Dt1qihIP2XKQIMNIFx6fue+gqwmhMYVeUjSDUitCJv2RG1tGOPIwx+EqwaDti3/nq9ZkQTKYj+jtnLJcF0lhcK0g9hZaw6TuifINyI2yqMK7C7V261QplJIQhbVHiutEFgf7Kz2Z/kaWtvYvqOQKsBFPrC3cwwHT9RZvJVxzry4auh7YFExqQF8d1q+WFDD1yefTgUW6tbnK3OOMLizXrouA7Dp8iTEdocYbjKiZhjLYWbQyOEhdRiFWJEQrUheM3wRCqNZQLHOkSuR7FVqPKDBkEaF0wcmO2Gvb7HiEEgYASy6rOSIzGKTVWCmxbYuYLtnFMKxUjb0bX3+bO5gYDZ4qpNoTKQcYTEg+6tWFdrHBdl8RPEEKwyld0bcuuO6NSDq0xdLpHCu8ialE5PDJ+lGZ1xjOnz/Ev7vwaH3ryz+Otc/I6Q6cDir6j37QE93l0vaboLFvj05ucXecQXW+pbEnvGCIxxrGK2+s7YCt6N6bCJS/nhN6KKkzxS5+uXrNdn+P5PZoAzIBQ9bg9VG1PUawZuENS38dWFevthrLNyUyNHF60XazbFV/Mr3OY7jKxCdvKctkB2i3e+Cr5MkACyd4lRlqwnZ9RVA6jwQFNec78/IjBJCQMJW4wYn12yqk1JNsNnmjxxIq5COl6hScD3G3I+XZOawR9u+W0vk7gv5Hj3AA5XhAjHQePjpSIwIe6z0n6EE+0OFphwzGzYcqNoxNeXmUkfUAoa8ZeQhiOef3OCZlTMxtE7A8Sytpwul2ThjGV7imbjMPZLp0YYvSWsM4oVILTWWgMhewpY4mMAh6dPMlze5/i5Zuf4aVixM79Y85WHoHtCQNwHIHqMuoyoNILWrOD7wyJOofsrKQNJ4SOgygMjY4pt3cg2qKdAY0oKEXLJ06f588/9jjRN8jRjDEXZqnfRI739Yz9DRHsz372szz11FNEUcRqteLg4ACAs7Mzqqri8uXL38iwvwfn5+cMBr83bPx3tp2fn/++x/69v/f3+Nt/+2//nu2r1Qqt9R/K/P4wsSgXX9N+ve1ZtiuW7Qq+hpZtX3ocBDvsR5e5Z+cRhs4Oce/xNv8hHth9EN8bUlGg6g15K9haQ/XEG3G6lrPHDhiWmptNhr8uKMstn1p8ki67w7ftPYLIfF7KzuitovdbxLZgsBPwxU4zbDqMURSrHBEK3FAy6AWHrcsLr/wGT44SKjlE4rMloBmC2db4bgx+z6Zo6WyGiyWrS4LqnNpLyM9PGCwD1OEhjjYYY9kUWzbLktMg5sDWdPWG45NjOndA0y24sVrTAddmEe3dJdvaozIVR3lFWRQo4UCXofIlx9s5d7drVB0QK8nZ+RGtO0RZxboz9MIhlj5VXrNt11RVy/RwgpKQbRZoW+MpuFuf0IQpc+kyFx2uM6TXFxm0u8JhEo4w6pjXszMG4RX66oyjzicICkpdU2pJe/NV1nFN6Lic7++xqyusaZFX7sHJMza6p+EcWXf07pBYtoiyYtPXWGmYd3NSPcbevQtJQBY0RC2s9G26LOO0y9GupTj+IkZrCi1BlFSNz+ubJd42wzVrLB5lp5D1muV2l6y4SbY+xg8Vqqpo+xYZtTSrE84LB9N76LK/MDJLRqh4wrG0ROUSsQ2xfcvy7mvopkRYSbIYszZQbhuyNGHbFETKQ7WCuiowqsEKQ+M4tHjo+RFtZhgXd+mCCBEliKbgrC6oy5xEGPLsOmsxQm9iElGhqyXHjksS76PkOVmeo4XF0y1VnVPVmvWNV+hDn7ZsmZcLltogupbVcglSsd72CCPoz9e0gSJvO2ybs+1u0bQVK9cy9jVVVWGEIi8tpimYK4txJdP1nKitKYqWrDin1hnKqcmWiqY4IYodslDiHN/EdRyU1iipKIoIswpY1De4c/QKb509ySsvP4f0fUbJlI1eo/UaLxkipME2FceLjO1mxa63y7XkMq2BZ89fZCL2KduSvjP0xQqzPkbYEaU2nJgtiYjprUYvb+GoAs9d0zJCSZe27DCdwZs4lIGLbDStajltt7y+ucuDyQH5ck1jM/quZ6tr6AyjMGGba+6UOcqV5PM1E69EpD63Fmc4BTjDAYv5hlqWGHOH9Rb8UuONPES5pXzhaRbbDjXYJ5oNeN+VP85PvfRT/Mubv8BfiT5Il1U07Zbj/ipGr5D5FmuW5OstYjnHXr5Gty2wfcEiu81E+nSxJj+bg6M53xzjBQOs57DarsjPT5ioAePJHqaviIRkuc45yze0vmCUFWzRFGXAreXr/MqtX+WsPeUe5xLv8h7HJYBEMYouzJKWVcVGF4QqJsEStrC88yKm36EQBX4Liz6ibCRfvP0xXrnx8zxTvsBn5p9j0a7+wPt8KAO+e/ad/Ll7/hT7jNkkmkQnbOcrBmFMY3vyzZLOtXQmIZAOzUojrOC1PsetoBMGypq6PcXdS6iNpj5dkVmPRrc8c56zKje89eDt5KsCVwha6/J8VxPuTOB//5+xet93ce2//v8y+MLzXzU/1XVc/WcfpvnVX+X8v/g+bj3xBnrhkzcwtxF90WM3Jb7n4jo+821Nt1nhm5RXqhvcOb3LbpIiu54+37IoM27mFQPHx0sTxNinWS25uy5YfuLnGTkW501PcXt+jBru0yzmVCvo6pZtVRH0KzZ9T1VnhK8cEXpDOFDYYk1ZG87XS+p0zDXlMvrCp9h+y+PcvL2k7pbo3nBcZZSNZM8bIddnrGwO4YBECexGkMZDjJKYpmFkBljfYrMc2+UU5PTrik7HCKemXuV4eBRG0Ocl+CuUgs32FLX2KJoOE0r8rqbKlugVWKEuyKNxUbaiyzoaa7DGQd54hWUfcOq6JH7BxNtndbahcUqOVyekY5/GD6nqgsVLn6eMPXqVsnLgPDvF9VO2iwV57yG6LWzW+J7FrJZUXcON6pyJ5+O7M7AtzWJL61qyzqU0AW4QIpUirzLarqTuoCqOiHd8uq3irDd4kUF0PUtcfCU5NZas6RGRS1N8ddufNSBMgzM/5vk8JZWS+yYhRsAiWxFWJYnn0ven6KYhcD3sYgGuoqKh3B4RjWaIVn3VuKJe0+uOXq9xSoUQEqsN1D2UCuFIbHFBtr/y2LZb0DSSrl5z2pa4SmLqGnl6hoknCJWx587omoZXVjd4ffMyqePwhHuNsqvY1mtCWbLqQkpjKYzFdSQFoFendIQ0m/V/sPATiHaD6Fuq7Zr1ZosZRLhSEquUm+2GoChIv1Sl19ayLI/J+4rRqkUNdxCyp1wvyM7nqCDCuj6F1Zxkr6FESeSNkQScz9coR2AbaOuGG9UNRtEIV7gcL44ZyJjCr+hkTdlY+rYg9hRal3R6BecljwUPsB2XfP7kOT7yhZ/jW2fvZF7OcXRPUW6JasvpyZw6gLxa45gEZQtu3b6NIzqcoCNyDlhWC877lkV9iitd8k1HnAr0tuUsrqnDlMoEpEVOXdxBjkaIdYLuVgRRT0vDSbVhIHqcNKDYtARlTiNaskCQa4d2U6Jtw2rzEpt6y7X0Ac4XW0Sa0Bd3iWyLOC+otSGqK/Imx7guhTslUIo0MHROQ3F0TsiAJpLUxuAow1ldMH/+ddJYks0ETSPJmhi/kjT9HTrH5Uy4DPuGujrDO7rOyJsw8Cqi3R1oVkw6TaUcMuniixK5XXFWbKnkFDf2qVYZ9Tqnjn16rak2czy/ZWQNppyzRVC7Ho/6MWJ5TrmZs0p67hbntN2A+fmCUNbI+pST9Tnb/ccpjm/holh2Hue9ZC90scbwnp138i9efZp/Vz3Hn68ewBs/wrZp0f0Z0+aIwFcUVYtzdoJpDberazhFRXZ6RBmU3C+XKOnS5z1ZnVEMNuTdls+dv8wL1RotEx567bO8cf+xP5jc/EdgjCHLMqy13zSZeZZlf/BOX8I3RLD/xt/4G/zDf/gP+YEf+AHe/OY387nPfQ64uLi/+3f/Lp7n/QEjfPPxIz/yI/zwD//wl//ebrdcuXKF8Xj8HyXt/3Oi6zuKrvimjN2YlhvlXW6Ud/nE/JO/5/3YiTmMDrgS7TMRYy6Hh9yz/yCD6ZiB2yOCmNZ1CVrBmd5wZF5mFsx4y/3fjecPWd+5hehK7h0YTr0h3c6Y1HUYzHZpW0v22i1ED4P6lKFxeDK5n1+pn+M4sTw23ScoE5SSbEzJYK/HsQWbrkH3JdNkQlVpukQh5QQ/SqmWcwQufjjmYKLoijVV5dP0MDmYsBuHnKwM4TrlqEs5iDqMctgf7DJWln7c0tmQfrNitBcwsENabwRehS8Uc5NjK81AeUzSKda00HYMvBg3gI2E3VHM+DBkcaSp2xoTR6TdhPHMZb09p6VmSwwyRLia+w52GE9Tlm3NUmdoz6EPHFz3Mqpdsh9U+MSs/YRkOGSvs2zc+6kXp/SiYbazhxnHyD/2TvJNRWoW+ERcSh0qf8JRb/GckB0/IvRDTupzRsmYsj0h6iMwCa0oGMYBSReD8KgQJOOUfS8CkbEXgi4FOtsiozFq0zGSDeFOTCRCmlWGES511zAbxcT79yHHAXpxgnE0YTJltJnTiQrbOuxNJtgoJd4/oGksfZHj+Q2qcxgGAd3SYLyUOFS4eoE/PsTpLO1A4PtjriYzdKlxFiV4DiLwyIVk7LusT87QQYZkSO/4BIczvGGCUwpEEDBJhnTFltOy4lS2DNKUye4VctPQG03Y+7imZZwktHgQX2Pj3CZbzLl/8hDpeEzdG4bGMqWjWlZoN2HclUxHQzo3wniC+0YOTe2T2poBAefejMh1iOOGTdkiUw8BTOselGEQRQxHMRvRcHtdXsjZqohSKw5TxTDy6LwdXCfHW2uSvmN8eUybt5h0ynPqNu5gykNX78cfGoZ+hCcUlhY/iYhH+5i+I9vcwcOQpgMuHV7jPj/hXx1/lDvNCdPZhL4zFw1pbNnOBXEUk1w6IM9fx7bywl1VH2PVDiRThBigpY9TLemMvMgcHxwijMTqjqc3r+CFCd/yyFOY6ZTIG7HdbIjOT9hxJf5sxiDtODovwQquHR4iZUvih8zzAlfBQ4cHzLdb/NCn3CYMpiMi16HpBY5IcRpNcnnAYDJGNhEP7r+BN+ffwqvbz/B0+SLfNX2C0KlYyR43TpBiTaMLdL5hkoDaHdHJiLJqmLRDZn5KHAe4psbVAW2cUAYg6xyp1zhhz9gaEpPjjoe4w8vMN3cQ4oQhCXpT0EWXKcWA31r9CivOePfVJ/i25G04m4r9/V3CvYCsrimtz+TQJ85zTDxkYiUCwVzX3BV3+EL5Ok/ffY7nzp/n1dULaPu1PwDeDQ/43oP38X979/+F2exeirs3eeH8OcbGEGmJjfdJ73WImiV4hsJq7LIiOryKU1h8bdh6F60VUuUsRx1x5XN5b8ZKCY70bTwbMnKn/Pz5xzCy5933fRu3zzbY5YYkTFm6JZt+zbRtEffcw93/zz/l7L/+B9z74X+Gqr8618s/XfDuv/WPeMMj97B5/HEWDz9C+4ZHaMYOjbCIkUcXTTnPWsb1Hd59+Cifyj5Py4KdOsX1A8qox5U9R22JTFPaHYXrN3jejNXZXeLrLxFde4D73v4eRHYO6YDOCxi3HbEnaYXCDO4n7nJ62dGVCcqGeNZQeBbqnj1fcjTdI3rzmwmvv4C7XnB3NCTwI1a1jy6X3J+OSFXAJLnM1m04rQ09NVIM2duZUIc9l4gJC4naiegWPsyfR3gCTw3p1RhtV+wHDsaxtN4UV2iCxEMHESIoUY1ALgpC6ZJYgQjHiCRFTvfRvaCtNEHi0HcNaeySC0FhW9xecMXVuIMp+3v30BY9G60YDcdMJyNSzyF0JhTHDY5MMMEOTugR6YrpMMK2EYEfo7Zb0r1d/ORiTWfFiEo3hNGQcbSD7noaI3BUyUIYfO0RxzF+4NPbChUlOEIwChyCYYpUgrb3sMbFJII0VOwkAXndESQwif/ja8dKCdL5nCaI6JWDG0UkjkXoHD24xFjFNLpCDQb4cYLJc2QUUebHNKua4XSE8r4iqtFoKBqsv0trCxwnRqkQuOhbF1IgfAfjXGRp/4683JiOvGnZTRPoHIwEz1N0TUs/ntKnE2zssqfuxw9inqmu44iW77n6bUzSEVWiGQ0uMzUWEYaARwyMXQe6irobQDwlSMP/+Be+bxmkx9w9v03VCy5Pr+EFA+qixkjBJPS/PE/hzqk2gmQQEVy9H9ts0Lpn1/j0mxzHc+jxieqYNIm5tHcPfS2wWMLEwySaOIvYiAIRCKyxxGHEYXSIF8agBJ0jaLRhkvoYk7A+fpVLccRmuMufCR6k/vzP8vTyGa5OLjFK9miEYTCaEicO2jiMEw/fhYE3IdQpd05fY288Y2/gI4nYLnNyJRikQxyGuL1ltjtmhMOpPEfFllY4OGFEsr2M9HxU4ONYHzfSTDuXwgxwTMswTmiEwGsaorHHQTpiWQnOtxWzNOFj2SmJH/Cm2QMcRGN2xh75qYsOr6FVxHg6YoCkbnsaR4L1GUvJaBTSyJod0zPAZehZbJwwEgonrzitfRpiwuEUJRVt5WNkQ4NiNz1EugmqvMm9wxFBVqHXxwyGIyb7h/TlGYNtzZE/IvFcRkHPQOS4C8l8GVF1UEpwkpTvuG+HrCpZxxeGfHnZ0LmCxA0ZpVOccEjk5phByDatGNgBajrh7OwVnrg2w3N2ufXFl3GPXkM34A59nOGYip4oCWlbw731hG/bfQe/Wb/Ep/R13iLvpx4+wsyGeI4mD3Zo0gVBsSDWc6QWmKaGpGbAgp1YoeJDGO6x3br80vmnuLW4jlSCnfE9PDV9F9/6wDtQ3yCHNMYghGA8Hn/TCLbjfO20+Rsi2CcnJ/zAD/wAwFeZjEkp+Vt/62/x1FNP8df/+l//Rob+KsxmM774xS/+nu2/I/fe2dn5fY/1fR/f93/PdinlH7kGetMb/uZ7/iZn2TGvLu5S6YKiWbNqtpyWJzSm5j/ihfyHgkIXvLx9hZe3X5Fd/toffNz/87//JzjCwRUOrnRxX3RRKFwcXMfDdwJGIuXh4GHeu/t2RtFDsHsv79h/jH/38Ru80r/OY/6baQuodUXoh0wv7WHaBf2dI+bnN2ibNYiQpN4ghjsEnsvZ3ROaAJrOMMRnpTp6b4JTNpTthjPVU9SawWgPKUNaary+ZXcUsb29Zl347KSCsKyJM8mmFnhegBWW+fldzpsS3yomgyED18HxAzJPo/yYWWPo64aua/B7SwDksctJD+ddSRAJ4qKl6sFVBwQtRH3NVJcESYhvUsSyp+sLyn7LUe2AmtJ2R8TeHoFT0+uW07XG8SP6wRS3WyHaDU5b4r/pDeiNR56d0955gXQcEE2vktierc4phUeCg3IcsJbQxJRmznB3SnnnLrJ3UaP7WReWNtDEA4cgiKnbIYNIMc9f47Q3uOmMUSxwFydYEeIECTbRtMGApgyI1GVM2jMehCyWK7L1GZXusLpn6rYQeLS7O4TSw/QaAp+gDkitQ2FyivKU4cDF80cob0K9mdMUNZWd42sPL7qKtppWasomw9KhVU0mJaOuoJEObQS0IfgxKrJkXUYgDSKMOW9qJg4MdMGZMLzQe1yWBteN2FYbTspzHN+jdH26dU5selZnN+jyki7IOOoMGQ4D16HSG5qqpTIZoTZUvaGTDV4uGCiYC5+uLYiimMB1aCykrsuiKfAcl70kIPQNr53Oma+2kApOVj3r8pRBFGHCMffvDhgLQ1ZuwEloBwl0FaraEAYBfpqiApfXjl5FugGz8RtJw4DAM1BVtJRIG9J8KYWgs+AGHuNkF+0YUkfxwORBnp8/Q663OE1EEEq0rtGZIZn4pLMxZX/EpmuZdj2j2S6O2kcGIVb0FFrRywFSXpBkTwTY2KcvMj5985OEQcz+8DHuFBvOm5w0SLg8mqBWc0w8xpUBjbE4SjCcDSjWK9ZnC5IoJfR6qnKDQ03eCLpaMhIZYd3Sty6FPwYVE40OCVzN3eUKRzp859Vvo7x1zsdPPsP96RUeFEPm9RmvSZf9Nse2kqzIiQ6GmLzGmiPK1TkDMcLkHWd3X0WolthNEemIpsroHIvj+XhhgCdjpJpSi5jFfM1JucCoCtlYbLBLMr3Ev3n1X7CoXuUN44f5U4/9aVRuuJPfYSMzNAnrsmeYWK7sTXi13PDc6ad47fwTfOLmx/n06llO6rOv+569F+7w/Q9+Hx+47y/wc1/4GaZxyP4swmXDbZ3jT3cJZUS/9Ih6S5dpWqdGdoa26ElxiAeKyA3YvPYagd9SznY5iGLWTUuLoCzWOKIlvhzTHI24s7rLnfyIB2ZvYb6Gqo1RTUWzLdm5FPNq9gzbtiQOZwyiKXc+8P3Y7Zb06C67n/pt5H8gqxu8eIPBize4wi8A0AcB+dUr1G96nPpNb2N5+RHEeMD9ccIzZ5/hxfmz3Lu7T9T3yNkMr4uRZ3fYFltuz++SRJpcGo6e+UX2tWbwtncgpoJ1WRNld9l6CXlZkkQpQsVUBYwGhoHn0ssQNZ6yXi/ZmHOGVY2UHpU3pHjwQeLrz6N/4zfJ/9h3UrYOvWnYDRz2lIf1InA8hs4Z27ym90K2TkWbHTFKriFtgHQNSkic3QP8+XNszu/SRGPSHUPohgizx2p1B1d0qCAisB1L0yJUADJDdCv8PqWJJvjjCV4osa5LX3c4rqSrS/quo9c561Jj3Jh40hHV0DaSptN4gUM2rxg4CY0+I1QJXjJGhwbHSCoJJZogneD0FXXfEKiQvGqYHRzgSEtfFDiexZcRWjj09BgNKkwJhKZfnlNqcGSNK9oLxUYyZhwOUZ1H1+RYFEE0oOsF864n6EAJgTYwCNzfd20WjCasz1dMuwo72WXd9DTbDUngUURDqkZD3REMYpRSqOGFC7GrQjpZYTFfPXZbXXhx+CmO7oEWKb+UHx242FrTa0MHIKE3lt5a2q5i1YFWDgNPsdg2tHlFZDXObIzbKxwk1vQ8lF7j6fl1hHJ59+RxrCfo2pZ4NEL1LbYt0K5H6qqLuZkWK1xc3/+qufZ9j1JfqqDLgD7dw62WYAKaPCMwHVMVcNIrOsCXkr5vCaXFdIbSiwmkIlcBqlkzGs6Yd6DXt2mbNUlyGTcOERS4/pC2ujCxU4GL1xqSxpDpklW3QmmJ53qgJI6n8DxJU7S0vUVVHaaoSaYz5GCXolnx/Y99gH/yzEf4Nzd/hacO389QzwiCGH8UEW9KdNXRCodICUSticIIx3NwnJg6m9NZl0pVeCog7CKiqMVBkMxmlOsKt9tSm4K7js/B7lW8rcayomk1xA7JyGO/TThazpHCoCrNerthoCKklRSNxtGWqK945fxldp1LTJyYnWlLVHYkwYDV7Aqr0wX7jiUZxPRFS6MNIyStNZy2NT0el3ambM7OKJbnuKxwx4dou0c/cRE4UKfcbXMuDQL2Rg5i4TOeTRmUAbfsCd5YEQuXQpfkZYZ3ck6UGNCWPgwY+iG6u0PnVMSz+9C2QZ3OcUOHaDhAb7ZM4wCSEb2tEFXNehDS9g593dMsV+jsjMJrkX3EngrYuiHn0uekC/GTESfBMcNsjnFm5J1lZBtqR/H6estuPATr8e6Hvp3rZ/Bb8xcYui+xOx2jkkOoT6iOVuyoDpt4UGe0fobJSzrfZ4eSWbjPWpf82hf/BZ9tblFWBQ8ufN4ZvYn9mx3p/JfgFz+O/Ms/BI99Y1VsIcQ3led9PeN+QwT7KyvUfd/TdR2u+7tPB2/evPmNDPt78OSTT/Lbv/3bLBYLptPpl7e/9toFA3zTm970h3Ke/7kRuiF/531/h+z0lGeefw3XUeylCVtpeOHWJ/nFo1/hoXiPe70DFialKM9Z5zfAkeB4nJklWVCzaAqW5YJFM+e0Ofu6KiHfCLTVaKupTA1feaqvaMn/JJ/hn5z8BPuv7PPe+57ij13+HvaSfV5ZXmd5WBGWHcJ32Uv3qDZLQs/BV0PifkspDInY4rVbXBPhqIimCaj2FKlvcYoO3W24MtjByRpunM153dkwVQ6zwYhx03OrGtDqlvOzDaE0XB5OOOeEPvJxqxDXbRhLSxZFnJ9cB6O4NNsnCRTxOMUdjZB9daEw8GNsb9lUJSrPaenAN8jW0tsOt82IY8urRIz9KVORE8iUPrO05hQvGRH6Ad1mi3a3CDHlwPdp84ilDJF1yWpVIt2EJyYxCRG37yxZze8QDWKkChjN9qgmu2QnL2CanFpXBDiIJsNse04ROJ6hNSXDZExe3aZrFage3SQUraKmwvHBQ9HUBbrSWDmkdVLigSFoF1gV0I9jnLWHznKstJjZmHSlaJYltezofYkfpHibOV4n2A6n9PSoLqfuW6wbEzUNjXIJPIUsIfYV+fKEKJ2gghTRQKdCtvM1ZgBh27Otjqlri9c5dKbF62MMitRqZm4E032i4jVUnuNJB6fLCZyIvWCGlD63Fgs8YxmFY2bBDsuopzE9Az9k4CbccG5gfBevdRh0IKMAApepmxC7DesGOldgKs2qySlMQJNluLhs3IDD2MVtoWxKpCcpeoOPJgwki07TGkumO/b6Elu3bNqWbjtns6xh5WJdwSD18Eb7DEb7TFWLkoLUH7HcLNkKn8CVDEKFqktMGFLpNcfFTe6bPMA03aHvBXnZEJoKN7E4voMjHZQTsTALAuGyk85YtxvqvubR3Yd47uzzvLh8mUe9N0KTUZ2ucbwEbzbCoUdpzVYlDHuPrBOkStN3EjxLWW1pnAGCDO30eEFA1Rpeqo/JqHj/9M3shh5pmFI2LbEQONMdaEv02ZLcC4lGyYV/QtVRVg1F3XDl6g4bk7E5PWEc7nK02WKLDROvQEuHxEvoxJibuWG27qj8CMe1yGqN13R8+/Db+fntMf/y+i/xFw+/h1oKVrdfIg72CfsGWy04qSNMViL6Glk6BAMJgcP2uLmIQZrtghzi79+PETV5dYIWAa+tc/zsDCccUnQLTAQHaoDBMtq7xEdu/jwvHz/Dw6NHeM9j3wfWYVGWOHsTsiIjiUfczD/Lrz3/b3l68XmePv4sTV//nvvo14JpOONth+/kg/e8n//00T/G+SZGzzMeig55Sb/CojxlMHiIrZRM/BGFSYkmHak/oS9yqrJE6AxBSPDQW+n0BlkcoygIOo+tmJDJiKtjhyr0WN38DZwoxEQh1Sjmt197DdMUvHH0KGrbcdnAZH/C2dEL+Kpg5gr8ssVhybp6nWLs0ngB7eNv4+W//Od4w9//+0yeef73vT5V1wyvv8zw+svwL36Ga4BViu7aFf6LqylfuBYxeP9j7D3xDgYH97A4P6UcXEUNRuS9oM8E8/Vdhl94gXC0T/zAo8ykQE8OkVnDuFojgxg7mbEqeoLW4mpFKQ2ZU+KKivF0xmixQooNa3F4EWGlwUmn9M98kcUb30yXTLg06pmogFC6RHHEqhBUG0sSGDIxpOznpDKkLnNyxyWJQmzXo12QyqUr5kTDCMfRBFGIkgnnZw5ClqhkgLEaXedYK+lPz6DeMHjoIXS4cxGHmK+RtqTvBELUCCnQXctytUXGU4TVhLJmNB6RtR7lcoVNHLq+IsIFDL0I8VSCNStC4eDORryyus3BYBex7rHtFplJrONiAx8hLDbbInWF54xwpCVrMnx94d5suovUikY4uBtL3pV0XsLVcETg+GjPR2QZ2pY4kcJJXGzWIEtNvm0QSuA7EmstfVMgvRApf1eWLaWkCxK8akuqDHPTUrY1MpoSSElmOiJjUMK5GKMvUCpEWAfpSXTb4gVfqgobA10FXgxCIGWA1lusNQghEa5E13BeNBdEsrdIYVFCIGkJnADfcRgjCIXA9A07Ix85GGBqjak7yjzjgfhenl2+xIPpwzRZB2mBAALjgR/QtGfQlfjeEKylb2pQ/pcztQG01pRlied5BEGAtZZtXxGGAybejI128Pqagc44by1LEg7SIX1fYBtNWFaskph2ucQGIVPHoSszhK3IY4HuUvZFjCMUum9xnRKEj24NXuigQpe22FA1OdG2YruqUNMr9BaUEjhK4khBtc1xiw1OOsFNAyIpaZ0E11q+/7Hv46df+Od89Nav8r4rf5x796+yE7p0bcPtbU4dRYhyTSIdHty/j9PtCYvFisiFNujIy5JLwYRwnSGswWLxZwPCOqJY3WA68rHB/WROTBcZAt1Qbu+gghHp2EF6IceZQ+0bol5z4nYkjWFenuMnCVHk8cLxM5RVyUPh4ww8cEyNyD2kSXHai0jD4mSD7wRIBG5vGShBrSSvrtdM44Cg27Ct7lKLDtfMWHW7nORnlMOYgUooFx1jNLu0DEvB4PgO6pO/TfvmdxN4+zhuQd7fYTqKyWTK2WbNZULqfIOvJgTDlEZXrEuNF3l4ieWSTRF1S90UFBoC1yGqW27kx7h5ze54jBMO2DSC5dktyvwWYnKNuBrgF0tCR3NlZ0Ken6KbnKmfotoW79IOjtEctism/g6vb1tCUbMjevzpPh/c/R7+Hx9/nU+uPsn/YecRymaCGh+gQ8E9+0O8tmT5zCcxt0/Ijo8Yni5wTo+4u1mhzs54//maP7tpSLb1l6Ief/KrfxDe9OQ3TLD/KOFrJthPP/00b3nLW4CLm93nPvc53vzmN/PII4/wwz/8w/ydv/N3EELwYz/2Y4Th7yNv+TrxwQ9+kH/wD/4BH/3oR/ngBz/45e0f/ehHue+++3jb2972h3KePyrojIvUAsdX1EFMVc45dPZ4KLzGDbvhkdElHsTnmrvLib7KXLpc2bkXZQrm9Tlissfl/QGbyHAqPOLj17h+5xVqN+PIqbhd3uFW/jJ3yxNO6/n/pGHuJ+UJH/7CT/LhL/wkSihm/oR5kfNn4vfzrtlb8WgodAeTHcJ4SndzTeP5mO6cLo2QgU9/Z43uFRupEO2GZa0o25rEDwgCn+roNsvU8uC9VzhIRhTdhkHq0aiIqNvSa4scJQTHBjlMWVYBk6alX57QeEOysmbqegRejBh4eJPJxeRtwLavOW8zvDShRzDNM7R0cNsVpQ6plcf87IgyHjPcnaFcgWcSPBUSjEaYLqfenpHEM9brnrOzDn9muKYc7i5STnXPcJCCuI3wFYWuSbRGRhOK8phge4LlAEQLqWKwd5m+7lmXJXHsomKfce1ztsmQLbg6pzUVXpWxkQUm3KU6F9jqJrO9CIRis1nhuZLInZCjcOIpe86E+uxZ1kGIG11DeB3NdkM/AFt7RKnH5s4K4hCntySuRylABB7Tw8toO2J75yX06hWq/Sfo2u4itiwIaDYNjqyJVUjnhawoEHXLViu21Zy90S6pM8CLpjSmw28yglAjrKZuWgbJAOIdZFfhqwBmDp50mM9vMxkeEsgA2gWTasVaeLjKw8nnHLgJy75mnc/xO0g8wzZvsOfHjKIhcykZDvY5DBNm3g6699mLFEG7oO4cjPWQ9MyFoowkeezSpQ6mtOAqpArwqgKdL7nd9dB1qKpAGAcbpsjKMm48RDigbDpE3JDszqijAZGrkRaCJCEcSJq2YXW6oklhmLi4nURXDZ9ff4Fe9Lxl53FmfkQrLOtzzVILYidgGEYgazZVTm8Us2SAEobQCSl1ycOz+wHJi/OXeWj3UcrlEVlpCCYztq2mP1lQrg31wOPMc5FtRNKXuGKFNxijbUdfZMhdj0nXkPoW6/v8wovPEDkB77/ydoZFThKHnIuCqs0oGBILH+M7VMIyaUoaP+Z0efFdHAxTUjpK05Eph6xq6fJjVLOmsSnB1St06xPc5V26LubWjQ1X7/e5NEppPImwC7a54c37385v3Ph5fm7+cf7sW38Q/+hzmOqY1BnRjqZs9q4QBwFjO8K/HDMaTy7i645v0BpN4vSEoY8/HFLh0YoNedGxbg1DTzPddVk0IU7T0dcNfQg/99ov8MzdZ7gyeohvf8sP4mJYHWUUZsHz5Sf5+S/8DJ9YfIpCf/2tP1JI7k3v4Q3hPXzH/rt5x+4bObz2Dqo+YybANpr27BSpe95++TFevnvEZ7MFj/oFoQ8uMbILcWNDMFZkyoF8j3abE4VcZOO6A4KhYNhAvdDYsmUVhTzkS9DQGR/fmXJcrlmbOdfdBdeGV7i3b5BNBrah1SCk4ubJEU7Q46f7SE8ydnv8vStU995LevMW8pF38IV/9jj3/PyvcPB//29wF1+b34joe7zXbvDYa/AYwI9ftDiZq1eJ77+P+++7H/mf/GlOH97naFNy+syvca0yDL79vZRty2J5m3h4P828wlmUzN72IM1gSk+NYzV9nqHSQ6KmR7s1dd/QtR3K+rTCZa9pmIcO27c+Tnz0CoevXOfOk2+ibaFxI4znIrQhlJY+mCGdJSfZEiUVM3920cutVvheh5cprN0QDq8Q1Rt8N6etXVwvwIslnh8RBD1FUaGEweanGC9GNiXebAc73iFQHtpV1OcbyuMFMvSIBgE4DsW2QvgRbtBijU9sAqRuSXavUSzmnC5fQWiXIL2Krzxqo5FFjXA9HCWAljCOEbJHekPE9ow+63GmV2l7gx+4GFHjGkMjQiJHsiqW0DuESUJZgs5KZFCy3nSY2Q7TyR6Bc6EilJ6HaCzWUVjZUEmXKHWJjOB8WZPuhAhhaMolpqpRboeXjr6cW120PU6a4usKb7nCcQViFCFVQFNruq6jVs7Fgwy2WNvRdzUYFxV69F2DMf0Fae/Kiw+YG13MTf6OrLpGqQghBI0DooOd0MX13S+939L2Bi18UgOuNgxjyarvqGRKDAhP0c1XtFnNo9NH+G614TB8kHlWM8oF451DaC3Wk7QqQLUlDgPQLUYbUD5S/a4qtG1bhBC/+ypajDUMwwmO6WjDhKx1GYeC1G7IshVRsaDtTiDXBMIjneyQa4OvO0LPZTu/Te8PWKqE4e6AmbRst3NaJCqqUI6ia8ENFLVoqEWFPV2j9Yo6K8nPj3D9Af7uEKsiAqPZrDbY0CGa7iDEFl+0uMrH0uG7PR98wwf5iWd/gk8c/zuGA4HvPYyLodQlVWEYxQN2dicXLvIdFH2JN9hhOb+OX/ZETYFpesJL+yglQGtiZcltR2MG7LqKTEi06jkVAZ4fItqKPsvxkoSB5zPPc+4xPa7jUAQJrucxogMszy6+QKV73rB/P+Ndi+MlqG2GVgk9cOnSlPz4lNVyy2Q6QhgN2ZrK6/GpsE5AfTJnIEPuju9hWcPi5m2qKOBwcIU+3+KHBZNY0c23uB/7FPruLWzg4RYN4z/5AWxnqYym9xpmh1e4dVJxUlmidMikLtie1chYU5qI7WLJQeoz3Uupjk9w3Bgx2aW3lrEKuL2+wcJaJlHC0HGRbU7R3AYnIM89Xrt7m3tpmF0dkagYYXv6bQtSUElFIjcE8RjjeBzMdrlVLCju3mI/FHSzHZLY5V3Tt3P29L9m/uI/5MFbgmi14P7FOdH5Ker4mFHXfd2/fV/G0dE3fuwfIXzNBPtDH/rQl3ut/+Sf/JM89dRTfPKTn+Sv/bW/xrd/+7fz9//+3//yvj/+4z/+hzK59773vXz/938/P/qjP8pTTz3FbDbjF3/xF/nVX/1VfvZnf/Z/PRnYX0KVLxHthiCZss2XyD5jMhnzv4m+lf/26L/n6fYu3xnt4UY9M3mVqtmwTFZs/AnNsuOgPqPONjT9hKYyTNsxj3gPc2kyRgcxvrvCOj1N47HOGu6YBa1ccba+xfXiFnfMijvlXc6qE7a6oPsmVcB723Nan/Nzd3+Rn+MXObi1x1Pz9/Ed976fb5l8D7uDGD+Z4NQleWspVMfYCelbTTeKcaUHbY5HTeR5TCKXrGzZcUK82NI0GUHq4A0jXF9R4pGvCuJes9IbEj9hU7Y4oaDuE5qjloq7KGFJQg81muH4AmsNBkGuDVN/QKszrK3QSuBOZ/iypjyeI+sl235O1UjEzpCDkcRqnz4TWNlRhzW/fPTvcYqa79h/nM4pyFYhcVWzsT1dE+EkLQ/vjSnLjOvZmpsrxaXRAdFoyqvz13E3Z6jpfbR0NMsV6XSPcDSgrdbo6pxmc5dU1owne/SjIavtMfr8RQad4bXqDN3tMLJTRu6GcFuzTFJq0zH0d1HhkCzP2BklyCpDSJ/ajdnoirCr2dQL1HDEoHZwpgmTQ8nyaEVLhTNKcS8f0FUa2WsG6Q5qXNBvzinaFbc7idu2TKb7tLJBZ1s85aG0i7Yd0o1wi46DvStMnAhXeKS4nKuQrrdEgY8uz9GdQXgpuc6gL3GNTxMG2HSEs2oRMsYIB+lGpHtjqhZKwN2UjJyUYTgk22bkzpyFbpjONX7fUgaW7eoWo4P7CYKLa/ZVwqjVKOUh5IAARZYoEBblRUSOxHMtuWkpCs3KFZwXW/rlEj8d4RnFUKYMjMLRAZ2pCZKAwCs5div2o4DEv0LTZ2At/mgH5Vws4kbTA7JlxUl+zsbRDKaH9JXl2bufI4gc3nr1SfrW4EvYTSOWvWZbttjCIQp65tkdRvFlQt+j7SocmbJsCkwvGAf7PHv3Ot9m76DKklaERKMhtqux2xVpOiPZSRFWousY10pGZoPM1lgvpTA5SoRM4hFOl5O7Idezl7l/eA+ONyWvt9iiwI1cNsWSI51zzQsoVU8w3iGuCvr1nNNNx/5kzGToUFfneMKhlw5n50c46xxpQ8rgEiM/Re31FPUpnuxJixbRtmwai+v6VE5IY1Ycugc8tnMvd+pzjs8+w8OTfW4sFlR9jxzsIP0IYSvicIoThAgpyOcbbJiSTsZ4uPhmi7uyVJ5gaBPoMrJQ4DkRm2KORDBLx6zdml9+7Rd4ZnmT4eAR3v3on+HG6nP85hf/Nb9+65e5nn39CRpDf8ATk4d4YvgE91/+Fhz1GLNOs++tmSVX2NUddnOX3hR4fsq2NMhgyGAyY+w+SHDyG3z+7GV2gitc9Vzyxid0XBzXo2nO2HYltoXA2UEpgTAKN53RCZc4rmnWOWJzip1FdKZGVDW53EVoyyV/wucWn6aShgfveTvDRlA4GcKBrOiQ0xHl7Vvs1B1Xrz3BZl1hipyrlxZcv7QHr99E373F4eXHEf/pn+HGW95G9PlXSK6/QPD8C6iXXsRZ/8Embl8JeesWya1bJP/uY/CP/zGzyYjxW95AsLmLnR5w8O7vpDQ5m/WCPr9Jv83YCUasswbX77jqKTK1oWhWpMMhO9KjtA6rxZImb6kHA+TIIs9z2rKneegK49mM5PnnyN9yP5Nwl1k6oDFQ1g1SufhxRF5mFPWGq7N7abuOkYrYdjXn+Ya00UxCFzW8hpsdobiDch+mLgWSC0l6PBK0ZxvWqxZhKpgqnCAlHF+m1BVD5eF4Cul5NKdH+O4uVe+SZxnS8wgi6LqCcXyI2ZRYp8N2G4xXUHsecT/CbwyO9qjIybdb4kGK1DVNlTMNHbqmAW+IYyRNUxIlPo02xEZjHEOgXVohEDhI41DZkkEfsJ2vLmLE3CX5tgBzD6H6XVWj8DxsrVFJSCdrqj5k4Dg4qcBuK2xZUdoVUluUF9Drkr6IULEHAspWk0Y+okqoV3OSPY/KPyB0HKqqpaoaet+nqpY4UuF6A9pyjTA9TuTRlf3vVrG7Ehz/IuseEEIipUffXxBsgEZJPKVw3N+tohvT0KGglTjWIEIHry8IfY/CuoTGIqWgrba0jcANDd91+VGWBdytc5xVz+5hAJ3F1prGifC7CtocbE9vFdJ3v7yu7fserfWXK9d5ldOIhlE0wkFCtSJ1oe0s55saKRRVr1i3BZHdEraKcLpLPBii6gaZLdD9hZx7ZSyddTicDgk8h3bRUW+3BFZgwxxrUsq6YtutkcYQNg2N46EmPVvPErc17sagNmtUVaOtonZjRp5P3/tYUxNIn4YIT9V4asife/z7+eef/wg/9/wv8HMv/Gv8XjJSCQ/vvJv7kz2UFNR5RuyEWN3x6p3b0K+5HB9geg9vFOBPx9i2pT+5hRQ5Khoj3BlO1+A5GbqXxK5Dk+ywNEuceoFnUqZRyOl8wUI27CYJOhkwGUSUbYdeHfHS0QscegfspZYwnuBoH63OKdMETwjixMM7nLBcrNmYjlGwpdrepVhfRMn1WclZHeLv7pHbhmV9jluHzIYjdohYRA3Chej2Cd4v/AbOpqV/4k1kZYX3ysvsrjecBpbYHbN1FgxNze7hHreu30J6M3YGAXm7oVpblnlGYFuEP6ETAidReEpgsORWsK4zAiAcDglnB0SiI8tfw3EdHrn6Fu6cV6xPz1k4gmy5ZBLtMkt2OSsKEqGJRilNV+GMK7YtqNMFB+fnuJ/7TdxXX8e5e8x9r7zIX71958J9/5uB/38j2M8++yxvfetb+dCHPsRf+St/hR/5kR/58nuf/OQn+fCHP0zbtvyJP/En+I7v+I4/tAn+03/6T/nRH/1RvvVbvxXf93Fdl5/5mZ/hAx/4wB/aOf6oIIgdlNfSBZomUoxEyo4zYrOOuFeNeG1xnZP+CpMwZiIK5nVHvYZLe5az0YytMcwcybQOcMuarGvx2pr56Sl9ajnYGzKNLlMUNWerG8xUy0xOCaMB0eS9rETHWZcRygm9sWxVwnxzzsfvfoTIgfff890MxvfROz2r7BQjI0TsoLIF5/WGdujjrjt0m1GPNc+un+Pf3/40t7M7/4PXfVyf8hPXP8xPXP8wjnR4++Hbed/hd/De5E1cCw9w4oKhkNQO9JcvY0VHXK7Qx3dQYkquSjbKYeh5RL1kUWoys2KWjmmrCk9qrJW0nsRvSwZOwEnf4qmOg/0pd24mdMev4N8T4kcptmuQSUrfF5RECGDoOuCOWJRzNvmcaHKIJ3xkNKJbv44uLaPwXkQomBc19w0nFKuaT519gs8+/xytbqC3PJjsUtqGVu9TnnYop2d4MGMUaNarE3alYjcYoEOH0yZjsWrYFJZWjEjDltyR1KcN0cDDepZhOoY4ZvlqxaK4yUDWTOUO1eaYm8YwnDxAtzb4bcK12SE2v02bbZG7Q0J/iCWkqGoC05MEDuVmiRNNmSqfl0vNanWDTq+ZDu5nkMzACjZeSa06huMxRkgING2+QJYlcriDihJEUXGIJPd9TjZb7h6/TCxK+vkCkwxJEg/RlizyBZ4cMZ7s0K+3OLaFtsVRknVdk8gaggGhMyVEsOm29OWCtoJMKRopOBzu0s5vktcl0e4VlJ+S2oIMQeZq/MYy8EMaX7FsW8R5jlAC7943UJqWZn6De5VLpQKqest+ahBZTudIes+h7w1aueykCVobHBUwi3x2QksmS9xVjgimBG0J1uOGFkgEHgYvUriRQueK1aLAHbbM9q5RtwqZacTMw/UuKijWWnpt2b10ieJ2wVl9l2GzJgtTbhfHPDR8nDSKaUtNs6wJRj7TSBCHE063hpe3a3rdksYu81zQ6RzP88H41H3BPck9nJ6+TN7eZMe7zCRwmFzbJXv5Bay1OJNdwnFApDzKjWVdKgrdEeqKdm2oZEdSGpzdfUxxzq9f/xhd1/C2g8fptEZ5Kb6qiCuD5494vV/zkq6ZWo9DBTZJKE7nKN0j6oY6zymyFa2OaHRAttVM65LRcB8bCzarEuX0HLUO7jAkJWd994RlNWI6FjhBzdXdGW0huPrAd/GRlz/CL776S+w/9oO4O/ezyU7YasEAQyQDtGMRbUO12aDrkuBwj2GwR69i2q5AYSnmR9hSMUljqshl0Un8bsNOOmUtLD/78q/whewma7a8ev7v+Cc/9V+ybTZf133+3vAentx7M9+6/0YeGb+Jx+59jGw5Z73YoA4u8+nbG0bS4eEr97MuSmrrIbd3cHSDGTjU/gHhcIfRaICu4Up4mWeX12l2KwQxWndE2tAUDRtu0Mkpk91LDKTFZY1uC+r1EmVafBnTjQeo9R3U6mWO9AyvlCQ7h8jiBkqmXM9eZS+a8cDhGygwdAbS3keoJdo1zIYTRvmGZtMT9IquKMkWFefJkCu6YnrjNYInn6DRAmsM2QP3kD/wMMkHP0Tjz9m89Ar+yZa9s2PcF14hePk63t3/4d+Mr4Rarrnyb3+TKwDcoHv2B2jf9XbWj9xD8c5v5Yaueb1vCV+peVRvULs+aaLxvRjXBnT1BtVUuO2ayDdUSUpmc46jBrtYUZ53dG9/J94v/TzJs88Tfdf9TCcjirLEHcZo4XA237JuQIoQ1xjarmGddwTjlMDziFiQNTXC6QjGl+k2n2Pov4Gyccm2JaatUbnElyXZMMRtYprVChWPCZIxVV/Tm56+bcnzFj9x0Z5isyzw0AwPIsq+JTIhvu1ojaHuG2Q9x5URMr6M8kPCrsQst2ino7Udk3QHSku7WRKnl1hkG7TIcdyYWvf4oqE0IXW7RfohslPIXtN0klBEbFlyenKLvoPdvV16LRB2wKrYQNWA97tLTNNaHDcilxZjSkI1otAGL+hRNqNZS6JkgpsE2Poc01aIUlAqAZYL4uSHlKJmgINQPqUxpC6UAjZ9xqIXXIr3USpA2Y5ebS9ithx1QbCVANNDOP6qz9DvysR7LBINDFIfob5Srl2hK4XUBm8YIJWBpiFJBtQt5K0m6Fu6rgWl8PQSLxiSbEqIDF3VUK9LwmGEaXu0I0iDGNoCrMGI8Kvk4V3XIYT4cvtlVVYXKQ6xh5USrTv0eo5rXfK6Qzgug+EIYyUUFZ5TIh0Q5Zyx8ii7gsIJqb2UZbllb3qN5EvV+XiySy06uqpHdTW1bCjW4EpLKgPy0EVJn0goCA1uOkbT0i2XuK6H6nvaxRoTuBeRd6IhkD01kiRIOd8sude7wt981/+Jl5ev8fnTL/DpO5/mTn6LG8U5v37333BPuM8jo6s8sfMwWjts7Jar4wmD4QHrOzl+lABQdw22XYHrEoa7GMelayymmmO9GeNRQqsNmzxmqQri8pw03UUWGUvHcM/gkG4Yo4RAuC7PFbdogCeSPYK6xDH3IOucFokJIBUuptK4ScywKNjMb3Iqc6yxCOXRdYrurMEmO5SDCO/8BqpsKN2UqVYEypJGLuaXP4P/sU/juQHie76b7t3vZfXyy0xvvE7ysY/Tvu1xpvv7FEHNWX3KbHKVeBSxWuUE/gICn3ntUGy2HI4FrrHYXpPuXoK+o8oyXB1xuplTtIq9vQRJx3m9oC+2OOEl+nAHbV7lDdNdmoHkPDuicROqzke5BQfbFZPVluwTH0fdfBHv+utEt4658k1OXjKuQ70zRRweEly7D/Hkk9/U8/1Pha+ZYD/xxBP8o3/0j/jH//gf8+ijj/LUU0/xoQ99iPe97308/vjjPP7449+UCQZBwI/92I/xYz/2Y9+U8f8owY1GDA/u4f/H3p8G35adZ53gb609T2f8n/9455s3B+WglJSSUpMtJHmQbBkDBkyFKdzG5Wg+NEFVwKfq6GiIoKs/QXQHXVRVIxsDrqIo28ijLNmaZY2pVCpHZea9eef/dOaz52Gt1R+uEWALWTK4ywU8ESfi7H3O2Weftd+993rP+z7PI4dDsmqNHcb4g20yS/He4q0cHX6Cl7jJePC9+J6Fld/ENTaR6tiqDU1/QOlvE0qH/d2ca4XGOeoolgt2zj+Au3VA4fYp1QrXc1H6GKdNwe0hd+6nOb5OsmloxYiqkRSi5k72IsIzPHH5T3Hu4pOMjUvXVcjts5TtgFoVWMy4PPKIRiFhr8LpHMTFfYyaY7czvnrnG3zk6qf40vIZnlq9QGv+3a0jne74wp0v8IU7X+D/AWwHEx4eXOYNo8e4LC5yZvc9nOttMUh2WVUrVjdzsvQWycVdeolPU7c0/R3m2YrI9bGMQaoGhaERkDSGxfSUC6MhudYcFmvE3gT7eE5XVbR1ja4rBJKiyFh1FqEQtAq80KGvPVIBM1PRL1tyoyCEHTkmsAy313NCOeG5o2t88uXfYpXd5mA04P0X3smvXv04Hzv8PJfDJxBdgW8F+J5EDCVb2uX23Tl26KP62xRFRVitIDsh9AVzb4Rd3CUeDZFhj01T4QlDr+4o6Rg4fTJrQ7FcU5QLTC8kGFyhqAVRkNAbjOgmIaa3S37nFmm2IBpeoKpd/CrHcxyadIpl2XT+kG56C7vWnCrFue0BgR8g+g7lLOW/+93/ibZR/Ezv/0IQ+qAtiqwjJsfrj7Bdn8526OqSsaixaEhnp7R+jZCSODlDHm0zrwuaPON8f4CLpA4DVJYjshxpK0S7ocGn8sdY2ma60cyFJGoCAtulH3Q0bYHSGZbX0eiWbnNKkBQY0+G0HdiK4/UMTw4wbcp8fsoZXHr7IxqrIq8zvGhEqA1LpTGWIFQZ2tJUtU3nCvKmIXZcYtdjWWZUTU0DSC1wC8NWa+N4Dv7Ioc5K7uLQRg6VC4oat+04PS0Q9ppz2yMaL0G1JcMwou6g6Vpc26GtFUYb3MhhNxlya7XhxuY2qeVh/IAr/h56s8FxIzpXUjU1jqVopEMXdPhKoOw+RnT0gwG6q/BccOwB80pxnzvmKdNxXR8z1mdx45CW7p7FjO1iohDfjbFtSRy32AIWRZ8STb2pqUyBYyly95TOSL50+0tEts9bL7wRz/aos5ZmI5A6J5aS/fEezx/dheqUyHIpW5dSxmwPJZvFdXTeYScTTGnRth6WSPH7FXbokfYkd+YFq9Mc4xgeOTvEjx24eURZ1Kw7h3N7+/THIQs5pygTPnjwJL/wym/yz1/7bf70w3+eZTIiW6X0VUVrOdw6vcHYThjaLtawh5QuIpf4g4iqhsUyZWNCJv0At0rpZx037Ro8h88efp2ffe5/5qXVS0yrKXwXspOPb7+RH7j4Hi6YfS6693MxOmDdM3huRZMbpsuMUbRNndZU61Ne51p0doAb7hC1V1nND3FK8LwJuRG0rSE2ErQFQjOydmk3z3B082W86Aq90MVybbIuR7s+k94uEh/VphjpI9oFednhth22iDFJD2MSsuUpTpMyGCYMRmNeTW/z6uJVMC2PTx5m4k4IkgA6w7CVdGGPF2evEiUeveAKRVmwd3FM4DzIF1eSk3MJ9wUuvc0M0wq64TbzdEGUndLrbWGu7KGUR5tlyMfeytzx8ewWbVn0hY/82rOoV2/gv/Qc8tmv4l67hqX/8HF3Dg9xfvlXuCdZ9f/i/IVzHD38INPH7ueO/TBN/Di7+w9ja/9etTCIUYe3yE1CoVrKcESQGUaeZjaMSGdTFrsDpM4Yf/Ur2O/7QbqmQhqF0RZhIAmiDn8TMA72uHZ8yDlvRBI6DKKAqkoJ/YjC+KR1jh1IOqGh3hDFY8obU0yVY00OCCKLbp0RCIWda4yJ6ZSHtBpW6RydalItsMIQiw2OJ+iajvVsgx+PcXDJVrcxSqNJ8JXECIEvPSppEW5vUdw6RR+t0fsuWmiUI2i7mirPEBq6ZoUX9HBsEFWKdgQlFf1wiClSbNVRVpJQGaxOsco3TJI9vNAgnIvknoLDW7A8RYVnsBwHlVfgOOBIahxcUyEw5FWK45V4nYdxYzphY3UCywnRosa0AXlW4ycuouqwbAVJiKokPV0xEz7rqqQfNkhpM8994lwx8gwWHsaNaPUMIUN026GrBmm58G9U1+FftYkLlKpoxD2Koyv+dayprsKUHZ3ycCIH6VpQbkBaSC8kEoq0bFDZkq41GFOgNRSrmCpbMvQtWhvyozsIfZ4WgzIau+ejswWmzVF2jO0otLj3Z2udl7iui2k1mcnxPA9bWKxmMxzbwmpapKUIB0O8nsWq7CgEmC6nrDqGyTZidB5UBW2J0xuxyTWHbYllFOei6Ju/z5Y2btSjdRpkDunsGrXoMd67hMhSnNglCLbQeYpSDcq757ncJD1qz8UUJRKHKi/xSoEyG+xQYLkDJA5+Y7M0KQfbu1yJrhDHWzw8ej3t8QlLPeOF+Su8snyJ11av8ZvHn8e4MWfCgMh/I1tNBaa8R4XIMzarU1rhEqgIS/jUpqXuLIRS9JKO2hL35iXrHKlCUsdQtwv8piJvLbTn03Nslm2HBXzhxlP4vs2jl1+PER6iaNGnp1R+D0mJH/UxZYfpDLbd4NYnTEVIpbx7Lii2TWC5JP2YqVLUG8GmtrD6FmcnPYrVEclHfx119VWYbCG/73uQD74RApfw/BnEW96AfuppwuGAdPAg/XDIUTOnufscu/EBx03O8XLFrh6y7hJ2zl1gaz8kKTTl4ojSSQi2t/G7GeXJCekqQ4ZDosDB0XMWVYpFgte6LH/384xvv0w/rShuX+PcyRHOukLevUP02qvI+p6Akv8d392+PYyArj9Ab2/TnTnDauzCeJt2fIW5H2JfniDPbrMY+BBA5EW8fu/1OL/v/Pw/Kr7jBPvv//2/z5ve9Cbe9KY38ff+3t/jF3/xF/k7f+fv8DM/8zP85E/+JD/5kz/JwcHBH+e+/kePIIpwhyN0HBLWS4pNRiYNse1gxQ/yuuFtnlm9wHPrQ9z9R7nP8rh7epPTYs54bHNptI0aDDECirRF1itWUpMMdri0cz9F0VAtFjgYkv6QWV6SyxzpRswXK0ymkWubQp6S+2Oa7C4vl88xjHpcPvt6rpw5T5mm3L0zo+dtU2Ub8jpnd3uLfhLTZEukY9N5AeVijdCSgRvz+OR1PLD/Tk6LmvnRHZ5ZfoGvbp7mY4efYNN9ezPv03LKaTnlk0dfvLfieei5PdNo66IAAQAASURBVB4c38+l4D72OcMbzBneMLcJ9kf4EjoZsykbFovb9IWLZdkYDF0FbaPRdcNESoZJxDOLNV4voE172NJldVzRlFOcYJsCwLaJwj5do5F2h6watvrbvLBOScspfbWBeIzfn2BLQzO9wxdu/S7X8ltEQcC7dt/M2y6+ha3t+/jS6Q2+dudLnN1+lHOxgyg1uQqZ3blJkwSsRctyVTH2R6gqxVaSKHGILIfY6mMKj3RR0rc9jhZT+n5CXGraxMUb9BCDHaSW1MUCt1VslRXTZoP0+rSOYNbM2I4niHDO6eIm+6MLDF1wsg6slnI+x4nH6LZDGZtxN+Wm7xJv34cRDkU941/e+CTLcoNEcX39Ao+M3krZSDZSkKYty6tHRGGHnc2x3BjlebhNQUeAdmKk73Ot7pAnJwjt4bkjFm2KyAKspI+qG8xmRV61tJ7NjSYg8ARjS9Kalli2TIKIKBnj2pLV4pTKSPr9HVw6VO3QVgYviDGmYsuV3DqdsZim5H7JSDh4w22C/ghZZWRak8QhRd1iTIErDWpxSusOaUpD0da4TUk8GCAbg6cNeVlT2fdaAi3fIgwjiqxB2S7GKtmSmnAUEqKYLxbcXNS02YILOy3DaJ/X0pKJa7O/NeZoccpmnTMc9Ghrhe1KNB2uaxOHfRZqwyvTlzDAA8PLqKKEvMMb9VhsTnltusROhgxdj8t7Z0ibmrLL8R0bLX2MqREiIqgMQ+0ReiGvrm/zZP8JCF3q9RrHcVG2hbAsnN/j/wnPxus0I6vHapaR6Q1F3WJbPsVyxtyHeZfzrjNPEHj3RJxcITC+TSYDmuWatWlwxYiqzHjutVch2mZvZ0JjLSiHErXp4cwE86yiMisce0MRblFICZ2LDgxDq8D44JqK3PGoQ0WPDNNuUSw08TmbJGzoVgtG8RXeePZdfObO5/nq4ed4/ehdBF3AuE4Ai6LNqFVK6Q/JzQrXSGgkvqkRvs90fgvLc3HHY+aZ4qn0af7F7V/id08+z7JZfcfX8Z7X53svvI8PXP4+3uxfYehfJtCadd6QBTBv57jGwXZ9Ql2x2uQo5aHdBJkdcd6TXLUjXj065oIHibTQyQSnF9BZDlYNYbemTqHoOrbcEXatOF3fZTJ8lF4QUDk5bm1hybNYnabscmxHYIsJZZlR12vqdc1at2yiDTLwkOwSdymRzMnbkErEPDN9loHjcWFwjlh6SOFh63uqy1oqirxg1Bqi/gjRnFAbTRZMKNIVW8MAa/8MTr7CdGsG+Kz626xo6VyPpp4TthJ3uI0XuSiToEQGZUY1HCLf+Fa6J95OPRygTl/m55/5X3BvX+W/VA8zee0ufOp3sW794YKq3o1bXLhxiwu/8TGMZVE88hDrd70d+X3fz+D73o9RLU0HtWUzjwc4wmPH3af2l+CU3GfvMO1SFvdfYO/5a5Rf+yyrJ95Cz7HJs5a0dumwSRyXMAqpqiXTvCToxagqRTUlmT/EET4jJyCzcjJswtNrDFRMEDnoIMEejqiqE6x6gXEHxLEB12aaFVAvmOcLLDMgSEIGocDNNyjtkvR8ROdAW1AbqDYrvOgMTTOmru/SyAbbith0DWthIZ0IbdboecGpfUjjQFHl6NkSQ0dfKJzeDq4n0LrAlFOaIMG2A5TX4NQty0JhiZYwCFhJB+PW91TPwy3QOU7UQ3Ut7WqOHG+j8worCam1AmICWbHJ79J1hoHXw25sZN9DWZKm6HB8D2RFJmqMFvi5QrsS4be4po9KFaLKCQOXw/IUJww46O3RiZrjTY1jSSJL4nh9VJ3SmRSh7jknuMO9PxAj/6pNXOuKWngIOhZVikAgkZg8QyhFGSYMHQGqg/Zed5U24ADFKmN5siCqS+yhg3QHVFnJRksirSnDPmW5ImCbXLm4EtCAtOiaDmOBkALTaZqmwbQGy7E4Wqyo9ZKeG2ILgcKggGi4hd0W4Lg4UhIbwTrLoClwa0MdB9huAATgG2xgPb/DrKx4sB/jUwP/WrA4sAMWXUkqW9A2vbZGFyWqyLCGCZYzQK9LqARlfYfe6CLRzhnyNMXrOmptkVkOfuJjFS3teoZLR9YKEtdj5ZSs2hVN19FVGr/W7McjHmTA91x+OzUu31jf5On1q7y8eJrX0ptcX9xForni73Exvcgk2mEU+4wml1CLlnzdMFMbzuzsERoX0eSowKcJfISQBI3Aj0OO1YrGa6HwWNTgK0WjDbdObnO4fo03nXkdg2QHISW4LlVRoURI0JZoUSFdD71ZoswKo8E1hiIOOYh9zOmScmTTJTbBVLBegHYidhJJdXwD53/7RUiXyLe9A/Put6AWJ9Sqo+oqJomLeO+7Kb74eXovPM3JQzsEtkfjjinbYzxnlwuXD7j5qsXVW1cRk/vZ3ZqA22C5Fl7dp7h+gn3zLtbyGOtrX2D/+pKwrnFXh7inU4aHp8iTKbJp/q2Y/7d7OP7o6M7s8+qWx62dkPlWQrW9x879T3Bw4QpWU+MIHzdOWHmaTM/QdUKcvJ5q+gpqkFDagl4rCXwfVzhI/mS5PP374DtOsN/97nd/87nv+/zET/wEP/ETP8G1a9f42Z/9Wd72trfx6KOP8tM//dN88IMf/K68wv4z7sFoTakUjq5IbIt1UZIvYGd8FsYFjxeXeOr4a9xIX+Ad8RN43oh2ukJmC/ydCt3lhGaN73gcp3cpNh3Sn9ALQrpsBY2kPT6hcD3cUNBLN8wriYw0efYyZ+o+TPaxvAoLm+dPv4pQDW/ef4JeEJKvU06nh6R5xs7wPKVd0sqE0f4Z3HSB1oZN6CAWLb2BQzXoU6eappjiDc/iez3sccc7rPfyI8n7eff++/jI9COcD/o8dfoqX5s++22r2/8Km2bDl4+e4ss89c11zg2bB/oXeTy8j4f6j7A3eoTXjXYh7GFZ4JQdwiRsFimDKEa7IWvj07NLqCsyJcHvIVyNW5Ss11PE9g6jUOH7DnXeUa9yHKWorRhTrUEdQudD/yxOt+K3pk/ztZMXqFYV+/YZvvfcB9hKznM3X7GenXAhusCX+BKvNi/wyOAN3Dyesw7HjGRM58LloMeyyugtKvBsjFVyIALS2sOmxNUwXxsGkxKNQyFtuDRkOS9QeYETaLYGIdb4AumsJU3ndPoOgXWR1oG81eyGDmUYIJc+TlNiWdB0FV06w7Idwt0+jpQUdY69eJUkiin8MRMr4MXZc3z+zhc50z9HrVY8s/gi73/T91CVAXEBdpmz0S1FBk1ls04b1CAhLBakZUOZK5zBWbYTsNuCwA6IRgcUxRH17BSpLIwGeXxMo23c++6j8j1i3+Ug8TlclNhZgxUNsD2PZnFK4AY0VkJpOkI7x0361HmJqhWW9LEbRdxwzyvcd7kwHGHGu2yUIUCy11lQb5i2Ja6ROLqi6WoaOSAPHexK0XdsrEGEsC0CP8Gap9RdRxR7VJZgvihRWtPHxkQhQZ5jdS2tEKSLFJNrdsIZ+D0O14pl09H3erRdi+NKVpslpjbYtk2QxGRZSdFuGA9HyNzwwvrX2Yp28JRL20FbLai9glPWaOGzLXtMohghBJZnUXQZaVuQ2D5dt74nTpZ3BEmP/WiX66ubZIOUSG/hNwY79KmljaU7qqr6psVF3dV0ZYsWDpatGIYRlumhpOHzV38DZSRv330EvVlj8DG2oHYaTuYb2kBjyor9qEdlxqznSzp/hTY5vWBEf/AQC79DvHyKm20YB3cJ9gOMd5mVybAdjx7AQYTUhs38Ner4AtLZQdUbtrYc8rTg9HZJoo8IHcPVVPPA8C3cKmc8M/0G97sHjO1dgl6E50WIqkHpBk8OUN0JjhvRqJJsPWW56VjoDTeOX+Zjz32cjx7+Nsv6O+cGP7z1CN97/n284+x7efuZJxk47j37ofKU05MlRefS29pmbxixWBWsFyskI6LQI8tb7pwscFxBUhYoKejHzr2W43jE6MCl0z2sAI5WHXHgIkUL3ZzKCTl/5SIHd/a5Ux/yaKJpgpbtoYunJqwqCy9MMU1FEG7TCxIce4J1UrH0JTkbfKMx+Ta68MhKwbElyWfHrIop82LOk2cexbVb0BK/M1hGIC3D8XyJbkvGnovT1gzOXOS1sqK0N0xcF1tLismI4dUNej7HGXk8eHbCdU9Qp8cEsk9keRT9Pcq2ZFOlICRJ0COqlwSDCaYTTF99mTCUvO7CW/htueJL58/x5F/7GYos4uiLv0jxj/8/PPbSjPGmwdqk3/Y4CaWIvv480defh3/wP6EGfcyf+/Os3//DVJf28eOEKKuw7ZBjZdFzPULb5nSeYb39Bwhu/SI8/RInDz7CYtij6DrMcoWlQ2xryCCMeOTgHC/euUmal3S6Rbgx6woS3dIPPJLOoTBDNvkxdjLFndxPOpvTqY4sm6NVxrQN2NINSmyY5gVqXdIai91RwKXdCa7lUK3m2HaHG/bphEIXUzw3weu2kMmATjtsaou+FJSOTdgJmrYjsAV6klCvG1aHr0EQ4NljwsaikopbomKnyzkIfLSqscsVbTeiUxrpuqjFimLT0pskmFIRKYcuP6FqR9iVhbJdAj9AG4OqW7rFDF132KOEVV7gqhZpNWzKFbZ9hkBEGF8hAOFJ5lVDXApC3yJvcqJggCw7lCzB04TJiLzKaYoNUm2wgc7dQgiLg37AzbpjltWIyCOxJK67hVI3MN2UjhDX+db1OSl92nZFTYdSJb608KVPk5aUbUHre6Q6xapyimqDaA00LpbokBrspqQuc0Ts0Du7R3VySJnPsPsjTKmxuooKG8OM1tnBNw5gEIGD0DG2VeEk/XtUIRq8IGChFUfZKbaRDOKEMAyIpKQoCqpOExqDVDXIgNizCYua6SYjMQ6FH/PNGrUQdJ3iuK5wBOwNtu4pqXvJN3+/LWyW6RSrFZy7+Hra5Snrqy9i92K80QEIF9WCWFQ0I5uVLkmynK4z9MZb1I1isVqTS40f9hC2wc0E0mi0KvA2LXVXQSUxqwrHVgTDBMtAdLBPKCTnwphgfIY/feVhylzz4uwWXzv8Cs+dPs/T02cxlsO54YR3XXwPT249QXeaITrBuunw/D6mqXCtlMp1Mb5DnZYMEkGkDFXgM5OG15YbZNewtiXP3Pwc0tI8ef5tuLaDcVzaMqeM+3ijXbx2TXN6Fyfeoivv0LYt0oposekN+2wOb9yjQhw8gG1F3Fkc4bou5yMf/zOfpnvlOtL3aD7w/ey8673kXUa+PqHYLBHKQroWduDRXryAd+0G/fkduvNvZugkdPM18+KQ7d6AZDDhxvUbJE2BnWU4n/g44rd/h/DjnyX6N1ybBr/3+ONAPZ6QXrjE+r4LWA9eQV86R/DGN5H5Ebenhzy3fJbH5Zhdd5dF6JNVK7bjIb3AYmk50C3piy2OlitQ36BPwTKtqeKYfn8HR0nI5L9tS/d/cPx7Z8GXL1/m7/7dv8vf/tt/m7/1t/4WP/ZjP8ZkMuH4+Pg/xP79J4WyacjSNV65wVY2SbIP2qYzJZndoiuHxwYP8Jw55e7yGl7/MZTl0rf7SN1RVw3y5CqpahArTa/ewQiLzsDh1bv4gwGFkZwWOUnnEto+o90Yg6AfDJDeGJmcI9AZs+WLzM1tXte7yH2Thygrwbye0uqa8XBAu1hSNorecExXVnh1Q+241LFHfDglbIfgejRS4wx8slrT1gU7kU9nQtrDGff7l/gEfS6NH+NvvPW/ZTY75enlN/ji7Mt8+vbH/1Du9r+J1nQ8v3qV51evwuFHvrn+THyG88l5Im3fa5trNYPhFvoVB2OgF8WUdY6V1sjUBi9kokF/WSFGE4ZhQi/oMQn3eL18kFF8gJCasZtR1ooTM+Rk/iqfe+XDnOiC84MH+NHHf5CBGZNnM8r2kNYTtGnGWS055+xxfXGDvHuEsNG0QcMVN4Bc4RnFqN9jvlnheCMyvyHpLPZGuxzXLQ4FRilyJLJnkxvDTTTSlETthlG/hxYdxgTEgwnGVUxPHTabE7bdHjhnuVttWIiWs9EO47LjpDvEdClx4RIeXCJI+lRlRlmsCTrNQRSxcnxiZfj1Vz+N0Q7vv+97ubl6iS+cPs3vfP3DPL7zIB0pVuAQhRFdrcl1x3qZ4rjQKIEUFbESeEmME/i4pUujG4a+Q94mrJs1/vEdrEFCY0k8JeknPp3jY1mCThs6q8FVGlu6tGlJWzQQJcShTVqDZcCyGoKkR5luaFZL1KoijjxutTmy7Yh3xkjX4c4mJc8qok1DKR06G7YSQbWZUboJuW1wBhGD+RpLuAjHQgiBLW2cVpPre22Li2VFWy/Bkawaj7ZRyKbGnc85VJJ8XTCyCnpOh6f75E1DzwtYKoVd1QTSww5ruqoBYWjbhnU2R6DpD7eYl2vyquCxC2fJ6oxsdQc/iWlWGXEvYLK9h6gt6qLDjxxsadNzPNK2JLLH6LqhzUq03WMQGc56Z3lFXeXV6gY79gPYZYkVuih8ZFmwaWq6riXpJ0hH4mqXUFhUzZrdYUC+sVm18NTiNXb8MaOuT7dZ0PaHFLQUtSYO4nuq8+UKf3nIsqjYin2GW31WqiJvBCMhkUaSBQ5JkROoNbHzCFNpkdkug7bErStu1Su2fRsxXdLXPbSdkG5sTp2GwNvQTlOONnNUEoHrI9o+f+bCD/Oh5c/x67c+zY8/+Gdg4LNIF2RqRRVZFOkriCZH6oTseM5T65f45PozfGn+BVbfYVIdWiFPjt/Ou/bfyQ+//i8y8LYIfI/AAt+28H2fpmlQKqEXp3hWn94gQYYWttjCZC1H8yNyY6jKhlbDvujjhVs0vYShLyi6mmltc3F3H12sWWclqg0ZbY8JgoCqWtNujtgK+tzXO8+n7n6KsjjmzGiCdHx8v4/bVBRljee2NMrFGE2uJWne0bou586cZxL53Ly9pJBLmtqwlh5hBy9Pn4em43x3EbPoOKnWnEkSrMghzwqmsyVDpyRJdqmbkFU8Rncr7DTF9mwuJT1unD0gfekq0ckC577LuA4ksYtvuYRVRbnWxP0d4sgh7E6p7YTe9jY6myGrNeuspWobsIfsTS7T3jF8evoK2/tvpS2P+aR1jddFMcc/9CTzD36A6OaU8NZVvC99megrzyDz4tseR2u1xvrQP+LgQ/+I0RvfwPq/+hn0u9/HKTmeH7LlKQ6PbhFbEm+4g/3EW4i/8hTL105oXhcRug6Rv0tRNDhuy6LIcayA/lYfd75ENRYm3uZ4UyOsGrecYjua0fAiqe+hyUibBctqiVxWlOUc7XnopsWzE9aFwfM8Bmd2sYuaTtTIVqDSIzAK6bk0lgZp4/gTZHlPvK8xhk7UKBEQeoK6qxg5IVVTUdoZsq/pxztYmSBTFf04ZpQXiFbSdg5Hy1tItUuoC0JbUK2W5ELgtBXl3UNsfOh5VKuUfuRRYyhci8CyMHlO4LjopsJ4CdVshis1nT+iKTK8aopMYjr6RK0CG2Ts0lUty7rFCWzqQtFubDqT47sdsufSNRus2sf2PKRXUG4KRFcwjs9RWi650sS2xSjxmS8K0q4jUBrL8rFlSKOPaISLrxTyW0zgpfSojaDsUmyhyFWEV1tEjo/nDyhNH1N3+G2LyjTKCzGypZPNPY/v7oTCZOTeDmp2leLkDjghk8jB7u+QTg/ZFB0nx3PkgY9ljanTEt9tUc4QqUroGjojqLua3GgWZU7fdxgEO1TCRhroC0EYhuR5TtkoQqdEOPfa2gdOxaxqqd3ePY660oS/xyOf5iWF0JyNe9jCAdVAV4Pt0amO4+VdrE6SJH38KMZ0HVX9Cl6bETUNQd8iEAor9hCTbVpqsvQUrWNs4WHbFraXUOsWkZZ0RYkTBYTbuxRVjb3MkJuWVlp0kSD2Jf5gG6esoWlIHZfK0fjlPQpjtDPhIWFxv5NQC83V4pB5esit4ohf+fq/5BPyd3g8eYjXbz+GW1S0JBSZjVivsXuGzvIxq5bcm2MsxRkxQjkL7jYLbszHyHrOi0dfYxCNuJRcwLQ1YdBnffwKneUxnAyxdUx1epXq8BkwAq17iPEudZkyLAoW6yl2HDKy+yyOCvIyY7tnMfrIR6gOb5Ad7NL9yPdy5uBBrLrFbPJ7nVhtzkAPcGwPqTS9tz2JXi4JvvR1jh5+G5eGIXU7ImtWHN64gXjplMd+59OMv/x54pdeQPwxcqL1eIvmvivUFy6SXXwQ9bqYV3f3kNZ5tmyL6syEqs3R2SlVc8pecIEH9vc5PzlHuy7olUdsTm+S1lCenTDq37PemwTbrJWFv2XTqRxbJ9ibBRPlQF3g9Eb40v5j86/+3wP/3gn23bt3+cf/+B/zcz/3c1y/fh1jDMPhf6jmg/+0YBwbIzLarsM1QxJjkXqCO8WKLqsZeSHvH7yF105+m88dfp6hdwE78PBNhduOadIZMiioPRc/vEAUhaw6xW1j4XU5l1qJ6vXp2xVnE4lnh7ywXrHOYSc5QzxW2DrFpPDVVz+F0IpHRw/hlgXBcAfjSgbDCQNnyNErd7HdgIFnkd6+Te4Kas8jrAqM3aA6AWlOa3VY9piyXtMf+QS6j110HAUBkiGJDnl+eovvu1JyYTDgUvQBvv+Bv0TaGbLmBl89/irP3/kKz5w+zbXiKuvvUlDoTnaHO9nvS9S/003c+IOrLvfu55377+Rt4ytsi32eKn6H26sXcKn5/ge+j/ff9+No1dFaDUe3WtqTFcmmJWeGSSRvjB/kU+lneaG9wZPn30VQZOgmvWcRpA2uHeCEFa1WmLxBAz27YVYZiu6eJ+ftLMXrQ4SL2SwYdDlur4+VJOTzWzjekGTiUVgCN9+mqzVO5+AVp5zKGFdKxm5EezQjnjh0sYfRMQaXrlWsiyV2V2N7IX3fJ7fh165+gpPNjMdGTzCODaEe8OzK5rN3v8JD24/jjS6ilivKyqVpFUE0YnvXInFDfKdPTwVYlaZLeqR2gJCKtFiSdQ17g5DaDahffQ63aMmiPp0uma82NJOAWmsWZUFdVXidS7HoMDrFdixUaUgicC1J0do4bYn0IhwE1aakVi3d9hbR9SP8cEDm+nRpQV62zOcFggwsQT+DOo4QuuW42xC622w5FpYNwnIxjQLbwpQdcehzss5o5yWh1RFEHdKxqZRH2jUM/ARVpFQG4iigJ+fEbgLRiHGyxVbgMWs77lH8BJuqQmUresIn7VaoOmcvHOL5EVfL24BF7PoUTU1ijWj8AU6dM6hqwr6NDu4l2E3V4fo2sR2QtyvWVUGUNShLghviNRn3DR/gozc/wo3mkHcrC9PViKFP1wS0y1NwYyzLRjcSP/KRUrMpllhJD2kEvVjwzM1nKLXgkeRhVkWDkAsspyQcnEFLh8YWhLbAlw2HRzdo6wYVhwRSEvYuczTfcLc4xCot8npBbyfA1xPMumVmzZCDAav6FY7TDJmMiHsDZB1S5zeJeldIdjxaV9GKki5ZkVdrytLi/E6IDgW+E/BD930vv3rzo/yPr/wTgtvb6KLAWBIZ+GT5kk294vrqFi+vXmLTfWcXhEuDSzxx8A5+YPJDPO6++Z514KhgO+xh14aRkehGUxcVnnDwbBc7GmGJGkpBB3RpSlMLYivCV3e5kx8S2ztMhjtsiRB3MKQKfNbLV7CbjmM8tjqPJAxRlWBrZ4e410MZw1x6WF6A2KScdQKEtFivj4gvPkJNSN+x8F2bdKMIXIk2iuNVzmbT4OkN/cE2k+EBtnHYGgUc61dJnQarOsHvedxy5jywc5EoFEQ+1CanKny6tmO1WNAUt9gdSspqyLEIKBYFe27C7eMU7BlpVeFt7dNUHdw+RkxbOiFAWQy9C2xmV5ltVpzfv8BgPAC1INNgtR2endAsDgmyKe7BWdLNionT8frJJZ5dHFJWktNyjn71GgNG1A+8gzbZonu9T/vOCyz+8p8jTx2SV15j+0ufYfzU0/hPP438NhPT4OmvEfy1v4YaDJF/+oN4P/UzqIvnaNuMJN4FaVM9/jjixW8QXn0NfzJhfP4Mpjdg47UMrZJsuiKrbUQcshIzYjwwLVbTsWkKaqtib/8s4TCgtGqCqsLuanzLxm4r+tEegeXQ3JmxrhROHDAc9dG2R+w45G3J5vQGsmlwh0O0LJEGbGeEkC1sjnHiIY2CqktxpEuHRZEucN2SjaWxMZyNt3Clz0tNRaU0vabG7lpwPc4UAie/SzZ/nrRtGQ120eWK5XJDfxAiw4TIjyikgz8cEm/5+J3DxvXJlYOQDaHRrLsObTRaOyixIq9XYJX4CowcIfQSV1QIf4CwJatcQyOJI5vU0+QZuNqAX2I8g5Q2Vhfd43PbBa20cZqAEIW0JLnS+FISWRZLI0hbjVe2jCIXqQyeF1MoaOoUPxz8geMvhKDFoaxnJFYfU2nmNATWvapvJQy+7ZDQYg8H6GRMZxRFmdGVG5q8RCHIsynN+hApQ6KtCVW1YTzYQu7uohdLDmcpvWiD7rWUpURXEjGKcGVLWy2ZNopCNXQyZMsKGA9CPDugqDqyTtMZGNgWYRhSNBlllhL4AxBg6g1D16X1AzptkStFIAWN0hxuUgLfYa83pO00jmVDW6CExfHiDrrrODe+SEZBVuaURwvc/g7uVotsStrbtzFFgTseIjtFZRl0m+FZDVbnYGqDlbfkZYMtBJ3RVOURbtbQ+SFlo5jnFZbtEwUl/bBHkPTQek1alGShoNMLlFmQV0MGdkPU1ATBPuvE5wHVZ89cAWvE506f46XjZ/nK+mm+vHiK8zsP8YGHfpjdyQHzWUu5WdHYQ6SWqMUpxAHGDRlH21DmbMoNR5u7ZHXFO7ffQHm6wHYCLM9QrAucrR6uJUG64NYomUExxAiborUQroXONsThiCLwOD6a081L+ndeZfLcs3Rdh/PetzE7t4c2kktOTJmvsfOGYG+HYn6Inh5S2ztUdw5xkgDnzQ8jPv4puhdewWkPCD71GYaf+Bz+p7+Cs/zu5r3fDvVwiN4ao7d2UNsj3J0trIsPoB6+yOzBR7FH5wlNy+0btzFVi78H89kRZ7Qg0ZosTUmjHrt7Y4bLq4jlMcuehsqjMRZWkuAeHxGscubRgsoqGLoxaQXVZonrKRqlOA0FoTOgl4xwhIcuG6zA/o+oQfyP6IPddR2/+qu/yoc+9CE+9rGPoZQijmN+8id/kp/6qZ/iHe94xx/bDv/HDLvLaHVLEJxlOxqBq7g2PYbOcFG6OImH0gGPDh7gt+4+xe3bT/GEe5Y0q4kIsMb3syxPqfMOo2v6dolbdPhFjaoyOrXGPjvGlZr58QkECQLNtgVBZZjPBa57wqtHz7PeHPLY+DH2LzxGv1SoesFhWTCJRoQqwRne87jtey5L4SJHA0Z0FKd3KO2GrMxwhzaVdNCFheNnhE5I2Dm0FGxvB3TC50rxJr548gW+fvXr/NCVt6PLEpG52H7IpZ0HOBhc5Ht5FHnf/4m8zdhkN7jbTHmpuc5Ty5e5ub7Fzc0fzsP7D4Vrm1e4tnmFnwckkt1oj8cGV3j/xSd54+5FlqtbeI5H4Phc2BtxIlKy166hrQJhX+TRrR1uF1d5YfMCT0zewKjSdOUCP5+i7IA8FkTjHidlRlfbeMOY1rNIlEPqBvhxTL0+Yn9zjCtP2MgdGifBuD3qrsbIANeyUFXOtJgSh9sEIx9XKXR1im9W+NLHHezSzI+JnRjX3WbhapbrFawUZZXSExYmCHG8IavlNT5z97P0VI/He5cZ1DGJf573PPAD/NpLn+ILN1/kzReeoK0NkWcRTbY4LRckcs4YiyhxsfIBGk2QzxnuniUlwzUSYwsCRzMIKrLdsxzPl6RFysAN0KscN2zItOCoy4nrCp+YQEEYarzRkDST5MuKZBJStz5ZucAqTqERBONtZmXK6uQ2Qmpa6fP16RLZdoyERY+KZeLTITloTmiXFUt/n5P6Lg+HM9y8j5YCGQfoUoFQIKFxbcq8JYglYVxTVxa+b+H4knlps24NrnYJyiVBorDKCqO2UUGPwHXxLYu+gU15T+050RbfKFJOTEWQGRIb4sQiLRZ8dfp1BuGA+71ztJ2mdTz6YYRNhikNar3GHo2wPcE6S/GNS+wHRBg2s1PcMARHY4oNoukYeQO27AE322PavMRzNcqLKPIaq1H0BxFWYCMEtI1CdYp0VTDYSjA2mCbj6dOvExmLh3evsCLHs3uMi45OVhS2hSUVrsqosxRvfIkLvZbl/FWOp5qBtc9eb5f58ha3D69Thz72bh+7EPzSS5/lt6af5curr3FU3OuA8iyP872z3Jec47yMuTx6hAd3HuFSGzPcO0C3S/R4gqr2mM0NE8uhlgGPjd4OYcArh08xtEeIXsja6vjC0Rf4xM2PcjO79R2d72/deTM/cPFH+P7z7yb0E8pNQ2RGeE5CGUkiRxCKGjvp40QBulM0m46uarEtDdpgsphGLWmtGYYSyzF4A8Ww8bleJygR4XctJgARTQisCi8akMuU47bmxnTFuYFEy5BBdK9StWk78jbFMzalUVwcbJMcutzKruMrSWd5bDpFFBjESmKwwdR0rSDRS0zgEkV9fMenTBs8z0Ik2/RCA0fX+NyNz6N1wxNXfhAnWxOIitYt0M4EqTvK8ja+VeMHlzkpfdpBj32jUVoh/JhgMyfr7uKNH6AbjmlPT5gvN3h+zGCwhefY9NwFCzendlIKJQiTAaqqSOdLyjaDekPQC5DthrA3ZJuW9519kpfTD3Nr9gJ30+s89NqGyeAC6sqQkW8Rbx0QFmus3EGomsH7/xSnb3mEzApp8xXB08+x8/RXcT7xCYKXXvyWx9xaLdn9+X8CP/9PqN70BJM/9/2o9/8w9CMObY/9nR2Gh3epLAd9fESlJXYY4YRDkljiZGuicsHVwEWVML91iNcbMd5LqFLNbKMYBBpsl9YWJKoh7RraTqKCiKyoIC2xY48zBzt0bcei1uDUJLJlSYolPSQenuXjGAeEBNWCEyJQCMuhrko8y+UwKymzjIOJxyTsk7cK3w0olaYV9/iPxmmQvk/nBnhuwiQIyaoTmqyGwRmq+Qn5IiUSPVxbQrFhtt6QTAaIrMINYmSjWaUzhtEEuyugLOlkge155MqiLE7puX2s1ifNajztY8cKLSrSLkA5gqECu95w2t7TTfFNQEONqzpst4dwLZrNFBtJa/XoyhxpOmIUlRBslMJvFT2/Y905zIsGz5Z4qgOvj6MsqmKG68dI+Qenv2mpMFlOW1qIrkCEDmnQstVL6FA4oqYoZnSOj66XGGNol8e4qoUqYjfWmFHMcmazPdrDDIYs5i/Tre7QC3YYbo+ZFiWy8rAGNooT1us+qjzG3xWodEVNiBNvM3BDfJVi2w7CtQgajWMEGwyLtqNnWwTxgHJ+lyrf4AQOuszpOQFpb4BuNMuuxXga3So2bcbeYEA/CqnSlM6yEXXByXqJRrMzPsB1fLJVxen0kHiTMRjGlNUpyq8RysY4Pq7roMsGZTeoDiLHIMwGx00YdIZp3kHoEXp9irSm2WzIFzm3FwWqqtBBiPtgQtwfIoQglYbjdE5jVhi9YhIPCesEJ22QwYiydRF09KMhOj/GcyyeOP9W3vfQ93P35GU+/eJHeO7kGa6Vt7h/8jreefAEOzIm60oOZc3Rcsl9cUAwGeANQpidIFTJ18wRrW/z2MHjCMAIi9XxCW2tCYVLuypR5S1EmWHECEbbeO6Qk+kplltjCQtneJmu3FCd3EJ+6jMMplPE1jbFj/4o0UjjTl+mtoacLBbsORFeHFMon7peU5U1hj40G4wfoNM7DL7yFNu//OsEs9l3PTdt4xi9vYu4eAazPcYMesyCMfVgTHLpfrqLYw47uNt1THyX3fGI0WCbbp1iTwYYBaZNqUTNMIowwkU1U6bFHn0ZUYqSu8LGlBWDwZBRb8DYuY90NeWwO8QNXKJQkDeKdrDHtl+xZM46g+FwhxqNVjWWBlF1bGQJpmOsJ/hRiDbQoTH/Edkvf8cJ9k//9E/zC7/wC3zoQx/in/7Tf8psNsMYw9vf/nZ+6qd+ir/4F/8i0b+hSvif8d1jpaDufLacGB0IpnXFcLhF0Nok7QbVeZyerHmgHvLpWvGVo8/z/sf+CwwDNsLDjfqsNykOHZPxFlGWAjVnRwPmQY+jLiPyQyaqxI8HaDdi2Itp2FCJLdxG8ZXbH+P506dJ/D7vfeAHOHv+QfSiZDO9jvI6TqpTHN8QjA5opiXTMsNOeoRRwkB02GkPOZawVNiOTbZpcX2LyHUxTYWqfGxL4O71OOtI3iXfwZcWX+WZ09d41H+QmABhNWzLAfVRjtvl6PWcVTfBCXpcPHcfr7ffxpusjD9veQyD+2jKY546/QLfuP0CN7LXeGH6LC+nr9H9Mfl4/ytoNIf5XQ7zu/zW3U8x+so/5F277+QHr/wA33/fe9h2HYJAUyb7bLkK6fXZivf5nva9/NPmwzwbzvmR82/h+OgObX4N0Ta43haWcjGWAjvGkn3uLOYs24pbYoltW+RWyHbR4dRTUqlJdvqkZYFRHf2tMZbUnK7u0mwU+4MtCBWbeo1UDrKFxI/QTgOuwlpX+GfPMkkibueHXL97k0ks8YWhC2NmtebDz/4Luqrm7fE72Ioi1vjkG8OF8UV864t88ejzvP3sG0gmCW1jIcIAu4G+VDhth1QlUdLDBAnZjZewbhf4wy1aFNNU426mDBwfKznAP61YVjmzriSwXA50g+j3eH69RNdQxSGu0IDADiNix7A+LcjXNVIaTk835IGNF+xRWpLM+DTH9yYTfmoIqUj6PQ42K8pI4PdGVNqhrpaE2SFt71Fs1VDlSzbVNeKt+xCejVqXaAFpIKnLjnESoNiQbVpWKsFqa3rRGkWI7ULd2nizgs4r0bWH7kWYICK2JUppRNFR1x2R7xC6FgGaxitpUos8r7nTs1HG4Shb8cbdx3HpcdPJkPmMy9EFKlyUcCnSDaYtaPoBjVFUaUmrS9y0wLEMRTTAzeaYcoFDiK0LLvYv83X1KteXV3n0zB7rqqNuGnbjGBeBG91rbw4ih01WgyOwapvOtrl7+jLXNze5b/gAk60RvtGUyqWpS1anx9S9LXZ6CtEZiq5PfxATyg1qvUU+L6nHa9Bz3LSmRPGJ1Uf5717+HF86fIpclX/gHKtVzSvLq7yyvHpvxY1f/eZrkR1yKdrn8vASZwdX6KkD9qbnuW/yEM7Fy7x1510MC8VHb36Mf3nns3x5+tQf2P63wmNbj/JDZ9/HD+9+D2fOvh2qFhzJN2ZTnJUi6KcMJ1vEoU9sQqrVXbomJ44SbN+5V82xJcJxqNc12JIgCWjNMVpXBNH95NWKdSU4n5ylbVo26znRcExk2zRZihdus+Mn5Js5dVeRlkOiMMB3bWqtmVUbqnpJqPv0g4hNWHKpt8+d4jZ1VRCGUFgGW5T4vk9V2Wz1a3ReoesCe3CWXhDQZAW1saipGQQBTStJk12evXWHkeeTdCGtaagqg90do7f3ceoFjVkS7ozIZIwZRDxwMKYnDd84mjHajoiUg6M73IOA7rEHab/2dY5VztBtGezGNIuUPBdMRvt4umKRN/i2hWoqjlcLLBTbwy38uEcsNEZ2aCvhgj1kL+jztcVX2Tqcc7HtIR6/jNqyKDoYyjH0e5jNim0/wO+mOKFkvSnwg4Tq7W9D/MU/T1OtWT/9Ndx/9gv0f+0jWMvVt4wF/6tPcfDVp1D/z3/A6sd+jOYv/xXsxx7F+fgnqO/epd6LaI40vYcexrQK6YXYpkYsBOM6x5QG2/I5Cmxy38F3RlRLxWbToj1BY1xiXdBWG2b2Nn5R43WKcS+iTUIcP6BKF9hdQUtH6FrUVse4t4XvbtNWJbQZrt+/x6kNR2jVsK5P2VQbhqGLLhyG4YhB6JMKSW1LVq0i6yr6qsZrHKrYZbh7AZW2eLYAKWjtiMiZ3BNN7Me0js/MS4giB2dxgmpapCMxRYZqLeRyTlPOqLYyBruXcHDJp6f0tkNy4SKlR8+yaYuaKofeqIcT9NjUa2rLYRC4OOsUuowuF7huQtTrk1c3wLJxnAmdWiMDF6uNKLslChspPUST0fMHzMuWriqIwhZRC6a1w/Fqyb4tsHwX3x2SrW7R1As8f/JNz2nTaoqsIp3NCbOSygvoTXo43YajzZy8HiCiCM/WCCkJwjGO5aLTJW1r0GVEo2dEB9u0jQHt0ETbhF6E5++yWN9llR4S97fofJ+qWlOWB0hLkAcl2bJmEAYECLDBdwISNK0xWI6DkALhSuxGM/JsNlqz6hSx5eJ4AVmR0hY1el1g+X1SZYPuSGtFHdgEokFaFjthD9txkbZNWTekmyM622V76zKyVmQnM0S+pl3exfYS3GFIV+8i4xDhOEirIziY0OQpVp2iHIHf30KrFNPauHZEGPURrkUcufhdRNuU5KcdddqSWAqtC2DAYVXh1AUr1WBpRag0iZcwFAIrcFhvbLBs8mqJZ3lsR2NW9YJWdkSuQ9FOuXLmfi76I16+8VW+XF3j2uwl/uniFXpWxOPxeXpmTNo2NI0klw5ODdQO+8M+RzducCbZYTjcJV+l7ER9ltVtZM9F+4Isu0bQLJD2BN1ILGHTOCGtaxPNT2lsD7Fjk9yeIX7lF6nqAvmmN7D64b+A4zgslt/A9wQH/QkFUJQ1oRdQnt4hvnmbeJkTfexZBp/+FM7TTyOKP3j/+3fOPW2b5SMPoX7wvYgffBvX4g53foAfBIwe3icWDsX8GDNdky1amuEYMdRYVUtcbGgcHwYTYq9H4dcUTYroRvRsj7VdcpwJosDlKJMcLXP2Bn2WmxPw4bH+Fpk0lOuM0vUQQ4d+MaYfxjRpRlFXlEKh+xHjQUi4bpku51iOheWGxJ5NJQVaGcLeiH4cM9w/oMgLVNdhzHfu0PEnHd+VD/YjjzyCMYbd3V3+5t/8m/zUT/0UDzzwwB/n/v0nBUsZAiC3a5qqYeBFbLsR07JFWDmyCrHcFv/kmNfJfZ7Wr/Ksvs2l4CFO0oIgctkejHG0g2/bSJ2ztbvFWvq42YY7mWZ7lfPQbow/3uakrjFBRKUVyjL81rXf4Ob0Nc6FZ/mzr3sfk0sXiESIiixWR4JIuLTBEH+YUHc5aXGC1zmMh31U1dDoGtsP8EKbMluzSksUDVrayMbHsjo8Y7Bil9TSuG7A/nify4M9Tso538iXXFQVW2VGWY/wkwFV3nGaSYTnMt520FgcVgVzq2Vv0Adg4gT8hSs/yHr8VjzhYyvN0dGr/L3DD/PK6jpjb0xbb0i7nA0VynTcu68qmrYEo3EFyE5gXBfH9Ym0g9EdrdE0TcbL+Q026tvz+Rb1ml+5+Rv8ys3fgN+B143u5z1738M7Bu/igd5jhEFEEoy5sifx1gM+cfgJRr2Al1evcbp+iY2aMj/acFqvOKlWLJoNq2ZJretvHS/CIrETttwhI3/MdrLHufEBoWMjhWRktri4OWJ7tE0UxVzob+Mp0B2sF68ihKQ8XsE4x3UdLEdTLlI2eYOQJSoa84mj32WWTnl98EZ8f4s8HpFYApWXiLLmnduP8lu3P8dTixd489nHsKkIjaL2LdzMRXUZogmxAhfbbjDDiDov8YyPbpbM1jWHtsCb+ESeJOpFTHyPXK9pdE2TpviRhdPU9C2fnWFMXcxZ1TZF1WE5ksyX1Is1UrUoOyATEEuoHBiua0wUIKSPXeZs+yOEVsyKDfZoyEHSRyvN8SriVhcSNxsubY3Qa8iP71KEY3rGx3Ekq6qhyyWxZ5MEHq/cSCmlS7TlUhaGF27NOLO1RxxGLPIMS2a0K43xY6ogITBAralqhWUJerFLawmevfESH7n1K4Sxz0PeY9xnzrOtB7y0fJnAsrk0uB9tfHwBRTrn5dlthuE9EZeiynCWCwZyl/5glzwt6Ban1LrC6vtUXUddKaKywEQRgpbHdh/n67de4RvpCzyo91mmFSs9519c/SU+fvuTGEdwuX+ZR3Ye4VxyjkvRFQ7iMWVR8NmTr1OrjjcO3kBcOXjjhKhacWoiFlQE5RLLlqR6gB/HBFZBUwui7Uvo7BXu3HmGXzv8LL95/RM8u34O813YXf1+5F3Bc+urPLe+Cnzs33ot+eyA/Wifq+uXUag/dFvnwjP8hYsf5L98609z395DzA9fo60chIQ4cfnaKmO1srkcbHHGWeG0C7Q4IAl9TBPQNTVl2uD6NpZl0bYtdBadqLF75b0qVDdBqYymKzlaLxBOxMVewnR5Su7ETHVBrzxFdIJG+Gz1hsyrnKXOqO0+e/G96vVxkbIoT9giZOSPkW1Gg+Khg4e5fXPKa7NnecybYMUB664iiWIWK026WdFm9zyO4/E+QmX3eJxhQNi2xG6P27MZzy+uUguXN4/fjiMN2AolbaTb0rZz1pspqWcTOAPq0ub8Vg9PSpZtx7IVOJslwgoIu5BiWdCMRzidoJ2vOfaPsHYmNKs1Wa3YPhjTlUfU2qLwXGqzJnYUroqwvQRHuti+jVSbezZTQY83jR/gN+9+nosv3mYnuMTyzW9kOD6DziBbr2gDnzCO8P2YyrT49oLKFJT5AG3bbPKMcajhyn2kf/2vMP8rH6R96gZ7v/QvGX75K9/6WrvZMP7Zn2X8sz9L/ea3YA4O8BxB/Rc+gF6f4nT3Y5QFukTmC2odkwxCjtUxB66FYUlZDTgY7jBrcjZFiedJ1kpj1Q6rTiF0h68qtsIBru0zsxR1U6GzFZ7TUTkxUgsid4zxY4LIo7El7TxFzeY4Tk3lBRRdSVZOGQbb9E3ISti4kYVSKRhw/R7HVU2cntKXAn9nn8XyiNU//B+w3vQOnDe8DlsphPCg1bjaQvQDcEraxRox2WeloQ4CdOJjC9jkHU0Y0ovPQjFjPr+On/RoZ9ep0wFm+wq+HSKckiq9C/QIkwk1hlyv6Vklge2jTUWad3hVi5X0sGKBbH5PWdyeY1k2jj8CTyCXAIK2dfGsCk+3yEaxblLCJiMMEib+mJNlyUlgsxeD5VjYTp+uKbHsDbZM0JVCZznLdI5WNTrukfmKcc/B0hF7oc0y9yDr2HJarOEOwo1R5Yb66CZGhBRdjbUVYLsD6vUpUX9Mjs3EsxkdXGDmdGxWKVk2R/ZHqOyQ4+V1jG3RAkESYuo+p2YDIieYn1A4Lo7jfJMvru1746CyBulatK3iRlPhNpKgq8iyY/zaMBxHJEGAbwlGjWbRNSy7ksQLGXj3VMOFEBwdXccSFbu+i56uaVqNdB28JCBoI8TeHlYvxKsC0D6qXaFNgWXtIG0bUo3luzTa4NQObbPGS7aIpcu6bO+J4kmftltRdYrJ/phB3+H46kvo6TFFHFAYj4k3IAo78npBYgksd4iMxlCtSTcZRgoiL8EDQm9E5QcEdkBTr2mVwooT9oYXeZ+zx48GHl8+fp7PHT7PR65fx1Q59wf3cVAHuNU25awlS+dM2zusujXv338rQdMwc3wO6xa1qhnvbNF0M9azV2iHl8AZYgUSJVNm+Q00KaXnYdceg49/lOaLXwJL4/3ZP8Pi9Q+wWi05e3KIc/cFzp4eER1/lvLGLawbN3COTrlyeIRQf/g96fejuXBA/afeRfvQE2wefZhbIw9lDhnHEU0mcQc9pFAwzck9gd3YxKsFheNTRR6brmIQGbwNuMkW2B4n7YbOKmnnK6Rc0YtjHEtzd7FGSM3K7SOXKV4YsO+5dL0IAugZSVPU5JaPcTVx0MNqNbLRyAoCq+MITW90gf5oQPXiJ8kWKcSX6WOoRUMoQ3ZH51CmRkhBfzikuXoNe2fnux6bP6n4jhNsIQQ//MM/zF/9q3+VD3zgA//RqLz9SULsWKzqJXbT5/LkgKHjoxYpXlOwzBc4yZD9Bx/kGMMTxzbPL6/yL1/6LD9zcIUgKxCxjxiNcbTAVhnKMTBIyOcbXN2yJWAiFY3tsxQS0x+g0xXX82v8zq0voPKOt8WP8eTFx9na2yUJ+9iWh2obUimwlzWj3SG5H6EWDcPxGL9rEdUpbeWy6Ay9rRGmbsjamqZO8YYeqrXoDUe4VYYxJY1joW0PY1xyteKKf5blekYqjmmGF6k1BOs1mbvD0TqnjhP6MZxMj+n5IciWnlSc8X1a3UGncAmJeprl0Sl2POAXrn8UV2v+m0f/FveHV5jolBNhsQlihqHNLJ0xy+4wrQ6pRc3J7FVW82PW5Ni+jd8GVLXCj/uc7QdcX9zmVpWhpOK0OuL5xUso8+0vki8uXuHFxSv8A/4RvuVzNj7Hqlkyr+ZoowH4x1//h3/keFFGsWpXrNoV5Ndhzrfkjf8rSCEZ+UMiJ7wnkINEdAbxkgtCYrRG1R3GdAjLgOWwbnNsBLH9aWz7v8d5xcKSEs847PoTRv6Y282MWy/ewZV/iUt+H+3d86GUdo8qu4soEkScgklwdy6hFqfYFAzse5OSa3KLqVhg6QwRhURWTRfu4c6OsJuUWzcyWmnh7G8Tu9DroLRiilaDBXFX4OsWL4kQnsdyfcK0LiBV+F1DMBkSKZdOFKgsxzcrat9DeX1C18Y0OdpzSZ0Rgxp8W9xry/cCsmrNtJXU7oCghb4t8AOLIp/RNBordNiNQjzb53C9YpOvCR2LoFtQhi1hOaToNE0LYd7Q2TZuYJPpDf/rC/8rP/e1n+erh1/818cIyVsnb+FPFz9OZUparbmvdz/bsmTXxNxOZ6TL25SmR+Tv4gx20FbJepHSiSUyVyReQjeekDbH5Pkp3abBaVtsBwLXYd8+R8/p8dzqeY5enPFLt3+Lr5x88d+KlS/c+QK88K+XAzvgSu8ynYCJO+F69g0Gdxzu0w8RRh5lkxH3YgZ6SqGHWF5EKAuyNOdLxy/y0Vsf4ddf+jA3y7t/5Hj/bpB2K15er77te3aiHX7k8p/m+4MnePvWo4zvfwiv12eWn1IhSOIRCMNracXxrODSqM8DeyPs2mVVz2DtYfQWwnj4kcGSHW0jUMpQlg2uW+OFLY4TYdsxxswQcsLd1WsU5Yaz4328PMVrO7zBeXJRcJzdYhLfBw0QW0z6e2zqa3TdEikSjsqM03LBQPpsyW380GVxmGJUzevPP87vHH6Vq9khr68XuNqmDFxq4VLkG8qmITASN/IIHJvZWrCuc2Jj8IxAAQ6a59IXCcOER86+AenUqKjHfH6Duq6o9YzVsmQeuGzlgl0nwnVdiqbjOK9QbUtPCnqDBKdU+FXF4ZkJvm04h6IQgm5xSpmmrJ2aOq+Is5bQs7DHI0oKRJ2zzMGqSvr9BLoMK95Gd/fUld988Ba+9sKneDiL4M1vIdg7i2e5WMMAs8mp5xnxQR9b2HiNSzP0CepXaaYLisxlHd2z/euPR6hqxmIzZfk9b2P5rrcxunOdi599Gud//l+w5vNvGTfeV74MXwH3I79J8dIzFH/uh9Bn78PYMdRTLNfF2dnDtiy6UlNRsWtOuJo3dIOzXNxyObp7SlsprECycCeY9QletcKOdkmCBEOJazLWp7fxHIUMLKTlU5aCYTIiFxVVV+EHPiQB12YzPNmS7PjgxvT9IQOnR5VqtNRg+7TGQrclyo0RyyXG1AQ7+4Rej/yXf5Hq5ZcJDmeY+ydIXyAai6orGScT3KTHkTolV6dMyg2dlChbMJ3fJXdshBzQO9jHbSpaK2BdnFAzBVeTrxq88wG+ljQqpjYOvl7SmX1SLQidGF+U6K5Ei46SiF5Q0FkNZdvihRHZZkpVFAxGFxBColSLHbkYYVFnCse1MfkaX7mUuqIwPlG+IfYdOmk41SFWXnHgdDhuSNtoujxFNTWiUhihOZEl2vVoQ5+h3zH2ElRnsPwRKnTYLE4p6oogryG9TT29g3Z8TK+HKg5xwwGqBY2F3RtgOxadNkSeR5IMsaVDNl3SVFNsv6ancrb3X09eBHR6Q1llZCZg8nsdRItVgXQc4sbgeAFIiVYdVAZHQM+2iBxJ5mhkXdIrazwvIApDrMCh6BRxoLg7X1Erw9kgxuQ5ZZZyujikrTKG/R2EkWjLwdsaIC1NOZ/RS8Y0jqBTNa6f0BYOWkUgliiVoxHYwsISDkWaMbQHWKGmI8O1hggBZavwLZhvGsq6pD/s0fqQjELsVcuAPrZngzDM2hWjfInsHSDjM3RdC7Kh6jqiaIhruzTlhiTcokGBFeC6oKRHEI9Jko4yO8XrXeDd7hnesfN2vnT9a3zi+qd4YXWVF8tT3mxmvHPvzbjC5anTF6nynMtbD5OmNZYVMWsK6rrFytZ4nNA4u+R1hEyPiSIP7JZZneG6PXRVMPof/kesa9/AVzXRIMH9v/3fMbfv4J4cI35fFfaP4urc+T7le97D8m2vh/e8m2A/Ia0bxBQ8JNvDCasa8kLhFhF5UNHvDVhdv8NgO8bHoR3tE41t8i5HbQqKTqDoIfyOtlxSejYDZ4DnOAi7pW1yVnnF3fUpjdRM2h5nmyVm7THeTSh9l3m75qzSBCQs6iVCGPb6QyhL8mWOXShKucQLzzHLfKwthdsboFcF7nrKjczC2fbZ397F8XpQTllffYHw01/F3LqF/V/9VaxLF/8II/YnD99xgv3II4/w4Q9/+I9xV/4z5pslVley7VrEVUt5d4FBYDxYyoChN4RaUpqIwOvxYP9hnpm/wGvpC1wye+i6xvagLGsa1RH6IVZbsdOUHGnNaDyily+YZgXpdsCOUHz02q/y3OIGrvD48XM/wrmDh0hdg/RsQjsEYK0KGg8GVo9+oXiJHDcvuXLhIlJDMT2BZk3lWeBp9LplUxe4Vsqo3qPz3XtqiW1LZ23IOxClZNouKYuUB7au8OL8WfL2BMe7xPVkn3A6JUjn5FJy7vx5zu5HHN4qyTYZQSJo8pJ8vUHamqI0hEoj7JCsrvgXr/4sa6fl/eN38T2799NUhjTtkMOA+/dHlEYihEOsbR4ZXGDg2qyCB6l6gqP1KyzjE4Q14GhTsO5y1uTsJnt8sH+Fg/vfg2Vr5nnJU/NnePrkU3z++He5lX57TmelKl5dv/L/jzD6d0IbzaycMyt/38TxW3Um/T63tFnzrSeb/yZ+49ovfvP5JJyw64/ZFj5nwgMunnmEc5P7OeidYWRidjuP3bBH4vns2j2m9YrD8pSB3MO1WvywhwozSDNUV9FLdiixWRcpQ2nhBxFmWaDzAtcy1MMBbuyTr2qWmWa+WfBgEuONQzwJohJEWzsUt1+laFK8y4+hbJsiqzHFEiUdRlEPm462DWjbGZ20CLWiDA2iXaFEj0oJ9GpJ2RbYUUxru3SNIgk89gYDVmVGXWyo09sEw21sO+bweIoXdkyimt8+/G3+2XP/jF975ddoVPMHxlCj+cL0i3xh+kWksLjSe4g3Du/nxx78HizLoUVj0iXD7Qln4hFSutRhRyoli+kpFh7+cJ8kjLCkplzcZp3m6FBzyVHUneJ3V1/kk4e/zVdnT/+hfxJ9M0S6kmcXz39z+dNHnwTucaQvD65wJrzIY+P7eHxyhnP9R3h2/hv89o2P8sm7n2HTbL6j7xAIHhs/yvt2/xQfePhHGTh9Xr3zAjeza7xavcyt7JC72TFXV9epv8XYfSeI7Zj37X0/P3bfX+aN4zeQL09xuw04AzrlUixSDtdzfBwabNrWcLouGbsB958ZEtgWYnhAt27x6hWqdKAVWNgIJ8cPt9gsO/L1GjEwxO4Ex+mhVIExmnULeWUz9CN8L8csKkLh0SQew86Q+7CiwK/AyW1G/THzfMUmPeG5045MS0Jb4ogxjQuyqZktZ/iRQ793gUmyzyvrYxrPIT+5TUnAKgSra2nWmkiUCCE4vnbMvKwYOgWDZoWVjKCcc1peZVnNefP+k3RGElaawWhC3ZQs1seU5SG5KYl7u1y2+5zf2cXrB1Rdy+Gy5CCy2ZrsYhdTZG+XfDrFTYbYvkWwnmI/+jDldI6RHbu7I3TpUakhHWu26pJz/nlWg7tM6wVpnbJdhxgpMJaP44VU5YJhb8hf695EPbxB+uSTeK6Fqg2drfBjj63WQnUW+RCsWU1QR7T9PaJmRpZnzG4tOBNcRDgWTrJFXlo0+YZd30Nt9bn5V/4M4V//P8NnPsPw5/858Wc+8y1jSdY18S//BvEv/wbtk29F/43/GudPvQUxOoOnJemiIg56bLTFWXfAKFuyWd4l3DrD9nDAfJnheIqNySmMZMs1RNEA2g6hChydc1qmnNk/C0rS1RaFBD+IaRtN0RXY0uaEhtZu8OjTtwZsxBonHGPnDVpbGFdiGSg7i6KucaopPUeQ+gm+H2Nu3sJ/5Sp5v0edzlG/8kvYH/xRPOmhYtAYXOEwdsfMvTWHy5uMxJBYzzjOFWpwgSgZ0ApQxqDbgpCQSmoqtyDdpJzNU5xoSLGqaXsT/OKQzfIIu7/H0I1pu4a2nJJ2FiKO6Ac+62JObmDg2YRxn7ayaGuN60u6pkHaFvFOj+zOkrZwUSYFmRErwxqLVlr0Nnfp+9u0dsC8KvCKgqHxUWuFoMaIJQR9jkTNslHc39vGimJ8UrTKAIOUHhaKoWvIo21kmiMOX6PuFPbZMVWWYjTYfg+lNKWwGSYJYeCzySpapSk7l0W6ZK4UQScx6p5eSL9ssP0RutOsihNiabHlj7DVEkcKCIe0TY1wLEI/wvZsZKWQtkT697Qyeq7FaXabrG1xo10qJVBtxaLJ6VmGc77P4rRkKCrqKmNZb6AXsbtzFpVpjNMSxBYysCnWK0TXkfRGLKySqisZeBOUpdHax3Fiui6jUzau5yNyTWkpuljjuSOadkHXbfDtmKxqaGg4zUuEKBjEW1huD/dAcz0/Znoy54H7zjJf36BSLY3wwRkhLIsmXVO0BV4YkAQRKE1Xl7jRENG1FG2Bb/nUqr6nI5P00Se3WC4XbI/3Cf0+j3pLHjjzZ3j59CW+KOd8ffYC3zh+jr1oh2M15Uq8x5lYYxwfowLCakHXy0AqYhEz6m1TlmvCSQ+8mJlSJC98nQs//0vEH/4Isv3DLWW/GxghaB5+APXOJ9lkHWlvwvpv/A0sv2B/NCA2Gn33JRZyRpMHyGKLMDyH6NY0OsVtLdbFhsBodNqhej7W3llcd056/DVcucfpHOK+hSsMY6ePCUOyomX7YEDdKJbLktpUGN+QVjN2/Rov8Mkqg3ENO77PneWGTXGHyBuz1hWiFpRC0HN6tGEfz7pL5wxxgx530hRX1xSiw5ns4i8Klus52/0LjEKXJlsTf/J3Uc89Qx1EBG97J9be7n/Qcf3fE99xgv2fk+s/fgysIQdNiLl9lzSU2H4Ew5iy2uD5IZ7rsMxyWi+gN4r4Af9JXmtv8/n8KR6d/AXaukEsUpzIZeR5uOUGspYuCOgC6FsOmViwlgq3nvNzz/xz8mLJg/5l3nzwJJfuex3j/gg7r1GdYp43tE3NraND3CggTs6xOD4m9gVVZGNFHq6wqaceXhmgx0OwwfIVcWLT88f0GFBpRXbnGC+ryZrb5KGDJxMOq5KwU2zHPfbiHV6anfDEPky2E25LlyhfsDcYc9/eEDdo0KM9XjbHOK5D2zRsZhuisKGoY9bVBq9v8+vHH2PanPDB+97PO4aPoEyL40GZGyI3pmfZuKpko9aUas6228NyNLI3pCs7tu3L+P1dYm/Ek35K07rU2zvEWsPRLXSeU/ZdzGjAu0c/xA/uvhX7nUOa7pTfuv6/8anbX+B3j75G2mT/wePDt3ykkBTdt29V/5OAaTFlWkzvLcyfgdu/8QfeEzkR+8E229E+A2/E0A/ZCa9wEGxzvjzHrhywaiocV7PvKHJLcrjMsAcJdlOzmM5BSJxRD4NgMSswaEQUMl6swYpoLYNr7rWZqrrFRlM4HlbTMOjHbDYpumro2xEq9nDqnDrXqFSycRMstSYxIwahRydK0rXFYrZAexZWmNC1YGuFa0ksO2QrqNjMr+Nakn58ltXimGeal/ncs/9fPv6x32JRLb7jMdRG8fL6eX7643+Vv/7pgB+8+F7ev/deXu9dJJJ90jZl5I+IHQexvUNpYL7JscqaC8MIqX28XDG2DU+pE/7fn/zv+fWbv81p9d0LqPy7UKuaF+fP8+L8eT52+7v/fGD7vH3/rbzn4L28/cEPsO/3WN04JNEDRs6I8fajvP38A+D8WRrLZ2w0plhwpzri+ul1XlouuOtlvLa5xquzV3htdf0PaC/4ls/3bL+H7zv4Ed4wOc9WdAaje2SrmiktQjrYRqI7xaxZU3T1vUTHslBZRq3hdZMhfdtBuBItJSKY4FmnqGaD5Ya4QZ+mWFAVa2gbwqhDm5C29JFCo3TJpqlZlJLI9hhHPazmhFp12LaPtEvK2qWfDNFCsCrXqGVHHIds9Q+gK6gVtNLGVDWpKTCOxXpRkhYbvNFF1pVi4p3h1buv8MVr32DHHeIpQSdWKGyUbWOCkHZrh0VliAYJo/aYtq2o7IB6NeOLp8+jWsVl5zJHyxXjDpp0SmVq6hwKBa1Q7DU5iW1wAg+tFdPFCqUMo2GMh8IJAkp8Krmk17Zwdo/m1nW8wQcRsw4rcAn8EZ1dcOK6tLlPcbTEOzMg9Mec2/G4fvcOp4ub7O6/DqkUrgeZ06f+ymcQL19Hn7+M2R7iOSVFKWhbzSSUOOMe2gopTEMZ1OjVhni7xzxaEwYt+cpwmHYcsKCxQ3ToE1PheCGhcDmZ3WbuCSY/9H3Yf+kvM3/2BeSHPkTvl3/531nVdr74JfjxH4d3vgP+2/8r8n3fh+o0o6jH3c2C0tuiJwPy4phm7WCFQwIn4mR2HeUOqcOYIBA4dYkpZmi3A+mDa7D8HtQa1iuc4YRKG0In5CQ/oWxLSuEwGuxjtE+eVyhXkcgBmBmWq6CVGNMy39REqmYQ26yHQ2gblAb9q7+O7XlEf/m/oP6d36T+ytPkly4Tv/HN0HW/ZzensIzNONxhNr1OEVa/V8Hc4qA3gNBilq0xuiboSpzGZnTwKKp+nlN5m2Jxk6SFSvmY0KNkiKhLhl2KdEdYwme6uoP09xj0XCzLwipu0lYV+BcJox65mVIVKZbTp2sabNfFcR3svke9VnSqAznFMgOiYUjaGqr1CbEcEjtQthZHxytcN4JiTRf51LFDLdesN5KdcIfJcMRaGVzlUBQZtu2BLaDJ6WtFmhZsqpRwa4LlWqi2o7p9ihP7eJ7PyWyFG/gM4xDKEjudk7uGznWQYUBQt2x7A2S54ihfc3d6m2QYUEUBjR0QtyXzZY4wGkFB3N/FKE2e12jLQwiBbhQmU8joHjcboFqtqAvF3dinXqdYyzmdG2JLl7gq6QU1IghIFZgg+v+x92dR1yV3eSf4i2HPe5/5Hb85v5yUmUolSs0zEhgBQkKAmWxwuVyNq1xerpvqXtXT6otePazVF+Xl6tVuu9u4MZjJCCQGARKSQBISQqkhpVTO0ze+05n3PEX0xYdBNgWCtl1Fa/HcvPuNsy/i7BMRO55//P/Pw9CZoDuHWm/RgYcSDU2RY5oaV7uoOMbrasq2RQiF9gRd26OcCGMEXbshYETXG3SsqWyNLwIcPaRtVzgiZ53mZF1KbxUXR2OmQYRSLqnV6MkYu9jQnHVYkXMw3qXZbFmXhpHbUhQLWuswicf4oUuTbWkaQ5b3GOWQtTm7kYuxhqqt6AUo4dJkKWKs2WwLaiImOzGvpOWyPeCmt8NTp0/zfPMyreh5ZPZqqtUJ/uAydQd68QJTdYs+uUjq7d8R4iPGjXbRv/Ir7P3f/wmXv/Clv/xL7s+A8T3M4SHVq1+N/LZvo3ntZZrhDq2MSZ96keTXf4Psdz+O+e530PY9dd/ieQ6zqU/mjjC1wPQZbpMTSg3RiD4pGQ32qJ88Y9tp1Mxw2pywbQp2Mcg+ZDY4YCAkVrlEPdRKkiqwvkRJSbsuUNLl/PAKOyLD1Cmycpg7LtbpcYLLLPpjRk6D9Eb4wmOVr2kDh6pao7ThcO9VlNOQxctPcetWgS8tUaDYjDwmYkKYVVQf+Sj+k3eUysXhAc0Pvpfo8n2g3P9oz/h/bvyFCfalS5f+U/bjrwEEnsNodoh0c2TsEE2nrKUlkD0DJ+JG1ZFuC/ZmASOGVFnDw7NH+eL1T/OV1VM8NP4WxqHPcBhT3XiZ1rYE00NqZSE3lE0BkeGrL3+al4rncazhWy+9h/uHD+EGNcoTSCmZRj5V29P2PUdnC9qmIpyeZ+EO6K9fQ21aNhf2eXqx5GI8pu0trRFgfMrOxSjFOOgJAw9UTN8YlvMVSd+z7gS0huXxgq48Y388olOa+yf3cVyuWHYZ90w0DwQzTm82lLJn27e0qy3brKMVMUssA39GUZ7iuZrJbI96W/GLT/08t/Jj3jB6JQ8O70EYSx94nK5XhL5gx++oz45Q2hLKjlM3pA4PUP2K2hGMDoa4GFLZUcgt49kO81VJfuuEaHRIdO4yTfoijZgwiWcMG4frZYtSBRdjh7/3yN/hv379f4mpBL9/43E+8vJv8umTx/ji6Zf+OCX8T/3mOiR2Qu4f38dATZn6CQM3YtfdIdBTkC4PDy7ywLn70cmIqqioNxUv5guuZbcQwYaTs1scFbcwoWWdrrm5vUbWbtm2Gct6zbZN/yceyX8x5G3Oc+1LPLd96c+9L9Ex58JdDpMDhuEeM/8cO3rGlfE57tt7BePiAn3l0mxqnEnI2LcEA4/jukKtJXftjtFaMz9+BqVcxPgQaXq8sqAqt0gtiaVLoyRt2+KnBTfWNdHl8+z1K0S+QLvnEEhC75S+hpPCpdUOQ0fgKMHxOsNzNLGpeWlzm0Uy5ece/x/4xad+lpfzb6xYPfJHtF1D/mcET4qu5Jef+3V++blfZ+DEvOfGe/j+h/8mb7/0dnxvRNobxru79HrNYpkShZrVes7PfO0n+eDpx/jq6ulv2IehN+YH7v9ezjkznk2v8eT8WV7avkja/sVOoP+i2HWmfOeFt/PtV9/Nq/YuMQ3OM9Ez5kmC6XOyZMOt7ZJlvWWWRIzH59HBlLpYcuvkebyyIZrdzyP+Lg8OfPTogGhvhqoa1vPb3Kpv83x+neubF5A24dHodewlIcYL0driWUXdLkj2p2z6AWVesJKWa6stN4slkZGkQhC5FZsiJ/F9Lg4CECA8RW0MSvq4wZCqXuGZGq0ttetSVGe4jk8iR9SNxDQdeVuTtXOWtcJ3PBLHwTMdUg4pVI9jKhwcqmBK01pm4xEYOL59hjf3GOxM6cd3YesN03qN5+zgRRGdbjg6vYaragLtQpbz4PAuvuB8irW9zhvveQSTOtRn18j8HjMOwNPc6hWOFsSxT7nRCNenk4qFrHi5O+OB848w2L1ATk4kBkR9hSMFwpeoRhDIATsCsDXb9RFtJ9j0ivEgwZEWTY8ThMwzCX7IsGtJZwdw7Sb5Zs7ADxGOR2UraqdkfzRGHGk2m2MW6ZogGTIdOKTzJZt8g98XJI0izgvEBz9MdeMaRAnmbW9E2BYtNFnXMfANgVAwibGdw6BWyFizKc5I1hZPW1K9IAovcZR7DAJF5UQ4bkrSRbjaIxU9fbJLaWFke/w2pbowo/jf/K8o/ut/gPt7H2b4Cx/A/cwX/8cH96d/H77zO7GXr+D/zb9N/773EfgZGzll/+ASaf8S1lZsFrfQtSUQHq1tENq5IyK1fJFKaNToAq4dEYmCuq1xrEJYS+A4FH2PL2rKvkQKj8TfIdGKtO1J0xW6t2hPIuIxFEtk3bJentEVHePzO7ieQfQlkY7IPvM5vONj3Le8gWDqY97xGvTLtwg++Rj9K19JTcUyX2GkwekFanMbYzu27oa46JCipWgNfgl+U1BJjQ1iNIK62KKcA8YTaKst6+4l6vgibRcj3YCJcJCmxRQrFlVL2pSE0YZNKzBVQd+cYUxAQ0ioXPwgosxLio0HpkdFLkIInMhju95imgZZlvgjn0liCNc5m9ChNj356RzRt5hmw+2kJ4o1uD1JMKPcnKAlHI4m1MbSVBUBBmN6ug6y9ZpmfgO0x8hTnAQBCzp2k5B6aTHqjHA4YnnrGNv1THZmUBQ0+ZZO14QdJJMd6ijmTB6RVJbhKMTt9tn0OXV5A3d4F6+6eIiuM8pVStVqPKEZ6RYzTii3G1wHtOtgA43JWoSSCF/TdR09Bb7uyZya3h3itD5h1WBthQ0Et0vDan3EYDgmYIhjPdxYo72IrqnRXUPTrtFGoTwX6bq4RlEKRd3XeI6H4ytULzC9h9N54JQI38VFU5uGznRo6WDwONm8RNpYKhNzZTBhOlQYW9P3kk1n2J1NyI6PODpaEV+9m5Hv01tJVlqONyc0VUMS7xB5DirUFOuGVW5RXsveJKLsHE6zgkBbunJFKEOceMzm6BbrwYoyWyBFh/GGOIf3IZ77HLvVinPnvpUfvneHF7fXueockh4/T5O/hBAt8for6NlFoslVaAXrk5cJfubn0B/4JeRqTfCXfM/ZJKa7cJ5+fwe7s8P28l20F88T33uV9uK9lHtTLCWO9Ynnt+mbjCCcYFTE7E1voPjcHxB+/g9IX/sAa0KklUzjS3h9jdE9280p/mAfdyeGNkZ6DY4pQVhEYFh0S5xGMC9yInEFkcLFaUwkfaqmgqbBl4rdxKMS4HSWjWtYmBSnl9wT793RFYk8Zu6UtNds8zM8q1k5grxdMVER0d55tlvJoqmgPcEP95DBBC0Lpm7ASVsymU3xywU3+5IrSPZ+9zP0x9epd8fI9/0I7pVLdGOPTb1mGsyQ4pvDrOs/2Af7r/EfDypwceIYV/k0/ZIVO4je4BlL0Sq2aU7gKvaGkiaPKLc1j8QP8szgSR7Ln+AVxWXaekC7bui6nGD/IjWCRWfxHcVm/RK/d/wJjjcnHI7P8bfufy9ecIU+8rHdhjRdMQ4mKCkIXcXpOsNtUnYPpgSTGVHbow4nHJ2sOXQ0RV6RtRu0FjRBSLNKSdsIKTRBG5IWDZ5fgtUYL0bGEHYNRnUUZcbV6Q5jOSQrtzw8usTv3/4cX735DFeGh9w1ShiNDlmvzsiPr9G5DrgRB+NdrqW32du7SHaUcro5Y+Re5Bee/xDH+RGvv/I23hA9wFmd3bEe0oqqqtndm+LHHnUTsc0bHMdhEMJpmhPUa4LxAbvDGZt1jkpPcYOSfnY/fpQyXvYkoxHDvQlHX32OLD1m5/BhEptxVm/ZqJ71dJ9Rso+szrBdzZtnr+TBwT38AxSm73myfYb59hTR+xyMznMgY8bRDo8vvswnX/4433/PD3ElvMzc5HiVxHUb0sbycpdxfhihq57E75hM9qhkg3YGDEZj7t6LeWmZUty8xcHBHkI2rJYdw3HI7lDgdi7VuuTa6pTrzYpbZgFtgzEWGblY2aC3a0TRYpwIR1V89tZjnJiGd1z9NgbuDqu2wPdaHCxNK+iFy1l+wqY4YtUtOalOubm+zs3sNu1/AuX2tMt4epvx9PbFP/OevXCPy/FVzoWXeCC6zN07V/HlgAuDVyL2HGybYouCNtxHap8kECzTUz71zG8xObjCWy6+g6jTnKQtlDVCSWph8fQuvZ3T56eYYIiRHb0r0UJzEPk0xnCWNxRNC+2Cn/nq/4tfu/lRHk+/MaF1pMNb99/Ijzz0Y/yNh3+Y5vgWv/rSr/DhG7/FJ2586s8MymzbjJ99+uf52ad/np1wl++67/382Kt+jHdefBPdwOeDT36AX/v0L/CZo09+wxRwieR1B2/le+77AX744e8hcUPUcYoRUMc+XalZ+hm/9NQv8MmXPs40mLDMbvPk8ikW/36pwZ+DR8YP8e27b+YN09dyr7tHcnAJkd7AlCkxFTpKCRrLcdngRgP8skKIkvHO3TjhDCsEvtQUfYM7GqH8hKrPqHyBWR6TNw26qjFuzyi5wFt3HqCtGk7mR2ybmlW9YqBr+tSjrl3iCx6MO3YyhT/cJU8LmqDjbldywRmgw4RFuWXjwEGYsM4aRKBRuSXtDUJApTxyIxCui10vqZoK6VeEw32UiOlWW7Sw5NWaZZ7j+ufx24K+bqip73jPmwQh1vRtgQ4tRQntsOVgfEBZ1NyeHxFEPtILqGyNWzkkpsOhZ521ZCc5yvFIm5Ioltx/9SrjmyOupy8RCAGyRQ0OkDS02mD8kH08dgceruyAEGsNVVvwqfwpPNfhu+57O8YA1sGPQga1Q2MNyB7RaaypmDhTwmhEXi7JWkVtI4ZVgUHjOIbCOAjfIzERqsmxsx20FdQ3rmFf+wZ6erJqxTAcMTKadhCRNzGBKQiGl8gW1/DCCFqPOt3QP/EFmj/4EsI4bF/1apJ3vwPRblFtTl5FKKVIbImxHk4QgFR0C0vSasxkl/zsNtIcoTwXm9fYsmNldhG9wtcNrgiogNwRBHgMI5+iF5QyQDk9Mr9N364wr3sLJ298FdVxzuQ3PsX4Z/8VMv3TASj18kvE/7f/I/0//yfsP/Iq1vfdj714idCDOnJQwwPaIGByECOGM862C2od03YZjn+A0ntoq4gdSVGuSKSPG4bYtmZOTSItM3/GsqmAjkg5bNuWRrUEuU/vGJwkpCtT2vQ2RdWxs3MJPZjS1MeYpmBgHcrf/gjS85APXmazfIneKQje/Vbshz+K89u/xuA73kjWHXF2fA1pYZv3NPGY8wGoImNroRUBPh5RuEOIYmtSpGopipS0U0yic/SZR+1VnK2fJRzfy0SHdF3B2jqs5zcp65LBIMZ3FJ7UlPUK642wleIkvYVhikaA09FsNiAUsb6zfVVKUzYZ1tTEUqCokL2DLwW1gLZeE9Uem7qhDQ3H2jDQPpeQ6NqjI8APLXQbVqXGEwLXjzBGo60mP7sBVUUz9JBKIrsC4wasCg9WZ8Q7E/rdQ+pbp4x0jTg9o3NrqqGP8seMSwl5TRpFxHEE5ZrawGi8w+pYUdQ5UXobPbibMNiBtqc6O8XoAc1mS7QXYzwXugYvvEPzTCiwdYeUkr6d09oCP/Q5jAc40T7L1Z01p9QOXV2R3l5yqkoebiRB7OOGFlk7CGtpipK03iKtwfFGiNjDWoMSFk9FlF2Jr31cX9Ove/qmIQiniKDAVAWikwgtyJoMIQSbfIPFJXAMtnJJvADtSbKnH6f87BdwRhHjq1fpBw7zrGPYKvB7vHCELJdst0tSNSKRDlbCtuxobEMYJnfGQN8w8wKePbnOSWUIFJwLHYQTIWVH3SyQfcsgGhDGMWIwILt2hBYriFucMuf1wwPq/AiqlPnyOp6Xo50EObiX5tc/hv+T/x8u/N6n/lQt9dfDak17373YixeYT3YRuyPKcxHBQ/ex9+rvRE53WK2PWd38GkE4o5MeYTJlUa3Zn+yAkSyyFk3HpjzFUxMWZzly7BP6Pidv/hbcn/1Fok9+mvRd7yItS6yXoQ1ga1AumWkRZYhrW/YHLcWi5DS9jYgssgGvaxn657CVIK3mHO4aHNtz1lnKVcHwMMB1FNoYlustx0VO5yvu8scM6oZlLtHRAEcYxl2Cqxukpxi5M26tzwjqE9rtgNB3ycoTxsbFH1wgb7b0qxV163K4M8NxW/JFx/2f/TLO7QWtUsjXvI7s/j2KvQE7bYkoDEJXYCd3bAe/CfDXBPuvEPrVCnP9Nupgj40o0JtjYj2gaCw61HhliXIk5SLHGhcXyzl6Hpk+wFeyz/DE8ss87LmEV/ZwpzsUvWTdtAhXszr5NL/4/IcRYcLb73oHDwRXUXqf6ShBRS5nFSwWW8bZmkEyvuOzenqK8SU2HjBUmjDP4fCAoOkZ2I5t4FOsl1weT2ESUsxX1F2L8l0GXoijEuIkQueGpVdTl9eQXUntxOjIEke7SCdguL9DVa45t7qPa0fP4mwKlsWLRO0+54Zjau+YtMwZDydMJ2O29RGeEcxmU+YnKR/92r/m1uIlXjd7JT946Y3YzYYNLqUQJDJgFElIpvTuAOVYRN1RZgVjZTirC45weWQ0QWtNJyUjFJX0WPQ5gTKM93ZwtEuebtkqh64sCNM1R8fPEjgtg+FduN4OuRE0uUEWWzwjGYzOsU43OOOI907fS77ZcH21IVGSg/192q7jW+r7+HT3u3zs5if5zx7YIc/A6R2U9nD7DftRwsaWjIMhZVpAD248wawLekpWBfi+Sx/uQFGQhltCOUO1mvWmYRJbGDhcdC9yn7z7TsS8rfGiCXndEQ19Rtohe/ILlE3Lc92LPOnNeNvlb+d7D76LE9sz3IvxKFhXC26s1hz457EOFGXBTCsODw9J51/jCy88xk/f/gPu8hMuq7vIgp7T6jo3yptcX51yUi04Kk9YVH9xYvYXxUlxwklxAnyGX/66di0cLsaXuS+5wD2DK+wNH2Q6mJLXC64tX6DKN8j0ee45eJD9fpeqNljTcWlvh2vbnPnAYyIHlGbJfPk4Z73HoukQ4hrFImBpW26sT/jN5z7I7978bVrzjeuyXr/3Ot5/5Xt43d7rOD86z+HOJU5Nz7at+Y773sMb7nqUn/r8z2OoeS57mU/d+uyfSbbPilN+6kv/jJ/60j/j8ugyq3LFpt58wz48MLqXB/dfTdVq3nflR3ndpXs4TPZwSkkXK1bFMYE7xRjDNLkjhPPqC+/kH73xv+GC1RhjeSK9xRPPfIzb5Yu8lD7H8/kxTy2f56Q4wVce77ryrXzPfe/jzcFrmTQB7v6MxXZJ2Jeswz2i9jaeHSLUkLWbUFpBWdfsasn52YS1bZBaM3YdrDF4xQYRxkRRSCw66mDE1laU8wX92QI13GF4cAiOYjAcUhc9sqk58FvKdoE5usGou4hKEgInZnX2EqFU6HDGjWpJoFpeOYgZxBNqrXGUYOpN2MFHOBLrKTpj6DqLLyRVo8gbS2M7bFYi2aBVSJtXeE5AieG0vokxFVoPOYgj6n6L1xlQPu1KILGo6JCymNOJM5pizHKe4o0Dzk/PUWc1N09us3uwh2pr+n5E2tdw+ybrMiPWAZfuuUi4c46iK6j7msPhDk/e+AJnRzfYm17B1T5UPSbu0b1m6Dm4noZiC05IX1dUxZwvzZ/mXHLA/TtXePr0CNc61BJ618WWEmkbEJJYBXg6wloPLxyRYQhrjTI9bV6SUpI5Y5JRjO9NaecFzqUDRNvh3T4h1R22ygh1wNC62K7DBA7+eEaXL9D5AiMknRuyPjnG+8BH8fM1xXiAeP/7EFcfIogD8nmOKTa0fsQk0Ki8wQ58hHNHUkgOHPpVTaw98BXFVqHkgLJLUX1B3xloKlTfU7WS0lomO0PM/JSR3KF2HU4Xt3HrCoWkVwld2yMICa5OWP7D/4bN3/mvmP7rf070b34WfXr2p+aZ2mwY/t4nib7wJfI3vgHnnnto24zQv0ZnXZp6RaQ6Jo/cQ/Ft7yFghmwVupe4gUKIkOXymCiU6CBmnZ9BGOPoISPP46Q5xfQlTaPo+gJjIHR8Ggu669lsG9q2Igo8PE+Qr1MaW9LkS7zf/yykG+rvfgfILcZvCUSIftWU/smL8IVnSB5+lFk4JU9b+ugARxqiUUSfHREOBriFxzLtCaY+w2AIpaEIHNpuQbc+BT1F1RajPLpoQlU+j1x9mdP+IkMlafUQqxPOUxMlh5Qiw7QnBE5EEFymqTLm2QpjJQ0dTV9Stls0O+g8Iw5DqryhJcezG/zRCMeLaI6WCKvx5JCmv8E2jtCRz7gzhG7EVkZcS1Oi6ox44KOMoC5X9HpE4IQ0dY3NMmxv0KpnuD/BcwNWZUbfdXjCYb7dEtMSD6Zs8opkOMTrG2SvMEpQZSsSEyHjXbrNhq6oiIKY3ltQbxricxcozgpE2zDtaoo2pafHj4Z42QrpScqsBb3CHcU0eU7XtiilsVrQlh3ZZku2fBEpHIbRPsq4tGdL/KxC24Cvns1heYMLKqCKJ3SeixtphBDYtgVj6POcarNhoA3GMfTaoUtXdDbFVQlbMyfweiSKdpkRzKZ4wwCEj7E9xWZFKwIWZkGiEnx8lD+i6E/Roua0Lhn82mewn/4dZJfhI6n/8CtI2zH2Bph7X6J/4yO4Vx+iabaIyrKzP6HuDC9kNWNPMAwVwhlyepbSdBUAYacQUmGEwISKg8kUYZcst6dMvX1CP0T7PlVREQRjemvoVMN2uyAyDtAhkpg+ndJvC/qPP4b40P8F5+afn3HWHhxS/dgP0/ydH4fJAWfL2zRNSmosroR7dndRgaSpCvxOEfoJt23NOSckoGNrNNt8SeTvcD6aUG5v4A4ndM4UN21IPB9hcuw9B6i7Dom+dg3/VQ2nA8GqK9gZXQC5JRElq65iWykiv+dWukb2ApB0fc1kcpH58ZJgJ6GqO4hdHMelL89oSo+ztCCMFdqJaZuObduxsT2jwOPSzoT85BaBUVg9wfprzHqNT0Id5XhCsTe4H785ocvntP4hO56DX+2xsD30W9oW4mhMJFb4v/tluk9/kqEC+Zo3s3jdgwSOj3P7JbKjl1mNIoI2YBTfB3xzkGv4a4L9VwoiHIDjUVhDkVrEyTM4/pg4iFkdleiqwRsLGmnwtctwZ0qdr3hl8iqe3z7HF+cv86DzJlrXJy86yjzDug2fvPm7PLX8Ik4y5n33/yiPhCNObxyBH+HHLkpKdoOItRdyI11xwYvYns4xXUu7E7HvRYRFDkIg4gRnNsM5PWZcuRyLhlRohkJhrEJUFdKB4TghjiJM1dHXGapec7KZM5lcoNGSpKsIPYcwGbFpW3Ikr7nwKLc313im2vBQdJ7R1Ec3LVXR4bUWr16TrVpiU1BvbjJwej5x+3M8uznmVbOHedfuO1D4ONMIr+9ZdCVuVpIkY5ogoCz/rZpXTV1tSPwZo9iyqCSNUWzSDCU69if73DALNsUKrT0m0qVtYVUsqD0ft7bcfurjZLXk8MKrkI5HPl/fqfPKc6o+J3EChp1hFAxpI8uyWFBlFY6jSXyfvjf4uMy8mDecfx2fnD/G15bP4WWX8BIXp3MJlYsKNSdVTWpTxsGUvi/p8jPW5RqjajobczEc8WIC66MzbLXFS/YYRSO2dsu6CfBkhY4MnZSERcQwmtBGLiarGHkTkkFAIySr/CU+sf0SYbzLOy++g3RdUSjBpcBB2oh5WdOZBbZfMXBGyDgmTVdsjp7FDyxXLz7K5fSERXGN948e4tz4HPHFCbY6Y5sK6loyvnAZ3J7T+oRri+u8cOtZjpZPMhcVzy+OOW5us6znnBWn5G3+HzynOtvyYvocL6bP8Zu3/93PAuVzITpHPe/52L/+KKEbUTcVZZ1Ri5aiy6n6msb8/yao9fW4a3SV77j4PXxb8HquDC+TdxahwFchEkFbLPCt4dLkEr/17ONE/pC/9+jfYmgEVdfxGzc+xc9+7Wf5w7M/IzUVeHn98p/bh11/h2+/9Df4m4fv4tV3vZ4XG8M//cI/Y13cxhX3UOXFHRFFp8VicWqL9RyePn2Got7y2gtvxZGKuTFURcZQKN5y/vWM5SOgBoRuQq2hERvGw4tI5ZKeLihO1gzP7TA3Ddr3UFbj1ksyRyPtjHnREu6PGGAxnaQRAuVoBnSsizW+DhB5RlemeNEe6+0JwvSo0XmCSCGCFEd5yMMRHS5dU7HZbAjDECM6dga7FJuWaxVMB4qd+/eoKkG+dVGBos4XRKbBXS6x6hKV6lmbLaaVhLj4ofrjesfGGBIpmDoa0zY43ZC2PUONQyL3IqbJqNoNFT3L8pi67hgPzzEbzSDPsNUdjQx0hDUrgp0If3YRfaZx9JamrSkKSRlUuNJjEs04mp9xfPMYOsHQHeGNh4ikxz8uGQY1wTDCUQ5DNaTrOx6YXuarL36eL559lbfMLhEog5M4JNZBKIEbaOg76GoIRvRZzhfmj1N2LY+e+xY29YaWnLpzaIuORkkGfU/ZVsRoEu3fUVeONTo8oE3XBE5BoDUeIZtViREGWWVYzwft4MUu5XhEcO0Wq1bg95pAaNq6o5SCuuqQUcKmqMiuv8xo/wKTp5/A/Z2PU6YF/RseQX7bu/B2IgqbkTWSwirariWWhkgrrBUYz//j8S49jY0srFaIuiKaPEBxdA3RbTFeilUNRrQ0maKravZ2E+LYpW5z5LbA7V2y7W2yquPc/gM0Q0na3eQg3kd6FaZcsdI+5m/9PY5+6D9n54P/jMG/+SDOjdt/au7pLGX40Y+S/MFnOf3B76V65yPoZIf1tZfRT3+Z6WPPk70ip4gDmixjNNoQDGbQ9VgjyWyBMhJpJbvOgEYo8q4nUD5tuSZ3BE2VQu8iI0GZpWxur5jXLbHjE9iarkyRTkzjauK0QT3xVfx7LlI8dB58CL0pkZwiug5+8O9S/Pf/PfZXfpP+h7+XhWrZVwmH4wDhOqw3Kf2kR/YV68Uc3AaMRWYSOfKo/RlVfYNAbyhFzzJfcdaX7OxfZbK9TrE9JnN3iTyPcezjNSVtdYxw7/hlO84EpVyCYEhYZThWMAhnlNIBpwAN63TLKl9SrjfoYIPqJNLbwQSC5uwGFqijkCYe0Etwlcc4N4imIZYx1+qG223KwPUYez616GjrDTQtTg8GqOUdRw3H9ek0OEoRDM+Rbyu8rmfd9VRlR+IYImOw0uCdv0JpW8TpCmfdYNG0foxNM4JwQOtKGiU5ySu8IISyxes6wrYllw15vSHwR7iepaLkbLFBFILeVDi5wQlCqr6gKDNk3SOzjDAYsUxdmusvk4uAznfIlKVvl1ghYLTPbjhh5TccxgLtjgGw1t4J8nkuqtqgkwFyPKJrNqje4ugxRX5GUWf4habbrtGzGNu1SNdF6IS0v02bbVHBkL4VaC/gWlmBGuGtX8T5uZ/HzUrUwQj5ne9COjPqF6/RPP8y0bPHiN/9JNWXHqdPQsrRALVzgfjNU1JngIwUqBbTGnprcFxN3xk8z+NgJ6aWBbU1lH3HpuzQ8YDyxjPoZIaMFXXXYWtLNBnSLhZYKpZywG120c1t8seeZe/nfpnJJz7+DUXL0gdewfwf/rc43/5eonEHlNRtSUPMaOix2dxCWomrd6izLXV9hnQHOCKk67fkXYWdpxgxYNMUhMqjMz2eq/H0gE3REc1ctCqosg6/8tFvehPOv/4YfOlLXPw772OeneCO9hBtRJ09R9C0eEPBTgiqCummIZnjcla2nA0UZquwixapXfbOT4iiHWS9ReaStPY4PSnZiSOaXlA5Hu12xcXJAElDV1bsTkekymcrRsT9bYxwsdbQkjELLlAqQ7S+idquGKqI46andrckrqCthoxOn4OP/hbyKKWIx6y+483svPUtDIyPKed0Zog6vkG9sVCCjNZE0QTkN0cd9l8T7L9K6BrWpqeeb1DhCEmFm57R4VHbnoPLU7qopW4dxvEY3/NRR4JBnfGqC6/n8+lHeHz5Fd56sEt1c0EZlvybs0+xqk+5d+8e3nn1h2hLB9MWjMIEKzpyYxlI8KTk/HDKsye3eP7WEWFVYpOAYRAwNgLbtKjxiBaQyRCvWNGeLIjPT1i5PbGEzmp0uUWECpSDbWvMak5fN6yailwlDBwPbM3B+ADtwabrqaxgoBXnZlf5TeHy9PZFHj28l87LUJ6l2TTE1iXcztlWK5QUtLR86OZXeTJfctf0Cj/y6N+l2LbkZY8fWJy2J4kTNtuMwPSEccxms2GzmCO1JRjGDIIpq8Vt9nyP1TbHqbecH0bIXuPaik2xxDgBvaiQ7phetnjjKcLLqV+4xdg/x+6FuyjbjsXtFZkxzAYB2day6nPyes5sNCLIJIvT66yLhgtXHyCOYop1inR9wsTh7fe8hd9fPMZnjr7Me6d307ouTdcz0DFtk+J7PkVTEtsa5Wiyk+tkpmQYzvAbHzcUzIYJTy8Vw9LBmSqytqbrKmohGO7sEXo91pbooY+VAVWTMhkO73iMrlcIY/nY6gkq0fG3H34/AR636hQchTKGTEqMEVxKdqnqlMXmlEHsIZyW4yzlMDpATSLeeeFV/PzXrvO51WP8wOiQIu2RtQHHo696BBVROCIO7+LK6ArfkjxCfvQ8vZSkd+9TJiUHIxdFz+3r19l0Dev5Nb52+xnOAktenzGvjzlq55wUp9zIb/2Zp7vfCGVf8ez2hf+4c/jrMHKGfP9d38P3ve7v88bzr6ctNqxefI5tLckEeHlF43Ycuyf4Tc8wHBP4Cc/NrzEIQu7ef4BVvmCYpfwX976fn7jru3hq8TL/4qmP8dHbv8Zz2TdWpQ90yDt338r37byVdzz8fmydI6QhivaIpGQn3GFVHqEQ3D55kakV9C6YxqGsVsTndvn87S/SG8trz72aQweuFRvWbYnXSwbRBVx7A2MVddXTsSY5OKQuaqrtnHqR4g8SGk+QHW3wkiGdbSmXL7F0FINkzKDMibMtlePgW0PVQ69cIuuS5YZrt59kWNck0ymBSmj0BttsCcMJ9XpO52rwRsSJpraG2gb0pqFpGgSg8xKZWuLxObowotkcs2gtResReDP2nBbjKupM0VRQdSvqtsSYADcS2MGfiAk1xiIBRwq2VUPblDiuIIwDgmCfJr1NvnmCtvfZHV7CsQlJPEBKyabKcE2H7RNsUWBNi06mCM/HCQfYrmU8cbm9Sum8mlGQIJ0Yaw15XREEAbsHY4QsyUofIacEcYduSlA5uBF0FQ/5h/yqN+RGsaBvGrZ+h9QKUTk4rqI2PV25xDQFLYqqXPF7R19Aa4+7p5dJmxTPkTiEtAZ04DNUilBZ6mYNvUAHAWEy4KztUATEjqTvlhS9QYUJ0+kOtm1p6wpjJaLc0p07xH7lCbxVQdq1WAdEoLBCEA0SgsAnsjH1rQX+Rz+JXK1xDifk3/I9tIdjhBBQOEhfsiyXpMWWmfaJZIuqW/BDjPMnhjhCCJTX05sN9A7Z2iMenOOQknmZcrK8hU4SVFYz0w6hcmiyGr8Eu5lj6oAomJJpSIWhUxbHEzAYYToYzrZ4uNQ6gU3P5gd+gvqNryF8ec7g534e+cU/HQyTacb+v/gZzM/8ItUPv5f67//nbF7xCsa/8BEmv/kRlt/9nRjtkm3PMK5E9B2dMGR9zXl/B0V0R3jM1SzaFr8XFHXLMj2hSAu8aEZm1/TrlEVlUMMhs1gT2gyDotUuwnY4n/oC9AXut76KzHGolUPkzpBqCM0R6Ab1lteSfezT8PkX8O6/guorgmiKyDPqICYczlDVC8izlKwoeX71AgM9xLUhJ7ZDVIJDVcK+S5WCk3Xce/cOwc4hJ89+leunt5GqZuJHdF6AROJah15HKGfwRw9M4XoxVZVh/QRlHAInJhoNybaCxWKOUimep6lTxVm6Qq1rgkDRj4b0SuO3Cg0IFdL7Ne3iFibr8N0G0QJGYo3lrFJ4TU3vtTiDQ0QYUVz/Kr0S4ErqqkGKBGPA8UL2YssN25NjGadbCtvhHgyw2qXa3iZKEhzr068X1NMIrRRik6GVpo0d0rxgqAVdElKLjnCzYXww4qhLyT1wRYSIwNoM6pS+l9QU4NcYBd4wRh1vKcuWtelp6iWQo3ZjxCDBGMtev6AaXGTjxjhFQZc7CDfjXOTiaR9TVxghcZSmReOFd7QAEBItxygdE2lBul3jDGNEl6OVolkuyKlpXIkIppjtmrxoyD0Pv+1QwOFjX0R94hM0psC+5RG8t3wLItpFeWO2+/vwxjfhllu2f/gVzNkW1iv6F27hPPky3WNfZjAY4jxwN7k2rD2XWPnsrNZ0J2doR6M8h8xUBMJilEaqhLKvGN58ARU8R783AyfA8zS2LhDbFXJ9SFC8RP/UU4w/8EHOfe3Pf4faICC//35ufu+7aX78xynrAXHbItY16JbKhrjCcpbl9FbiVhmro+so4eI4FTov2DQQBi5lUVE1BbuTmEIOqfoNgRsQ6BGbzRpEhSsHiFZRZga/E6i7HkDcfwP1wvOEZ0vygcNKwMXROdpqhZcdM1QzorpBeBoCh6Cc4I48nkufB60pTkvifQcdhFQW4nBCIra84p4hT90oOdt2eLHLqt4SKzgcj8jnC6S1RPEA13U5KxV17yJVRpP1xLFCtqd4jQTRUm5PqJ0DclsRxSHdUU/y67+MN38G6wScvua1jN7weryRy7bc4IYaKcAbD6jMFFkMcIuGerPFXBB8s5hA/zXB/iuEMyRH0YR9pdkNXZo9D6e4RYePV0Joc9arEhPuo10PIQUqjBlWOVeH9/Hc4It88faXec31+3kqf55PNc9TC8G7L72O15x7E0qNuL7aIEOH5GCPqq4o2o5QSrQU+NrDcR3M8RJnMMQfRYRSQV4iwwDpunR1hxSCcJCwPT4lsQcsZMtC97SiJ+wkdB3VZk4oe7oWViKm6FbEjsuGnoPRiCQccFausKpi5IaUvUNVdDwweQWPL79C1dfIxYY29HEGB8SjfShyZHZEJAW/ffuz/OHR09wzvofvu/eNKFujXP9OzYwylOs1vueiBwM2tKTbE/L1hrIpQSuSYETjWYzsGVqXzXpFMHSp/QnRao3ERZYGJRSF2NIXlqpKaWiZRjsY/xxBb+hNg9KaQRLj4TBIQLLFFQarBnS+z/LsFNNKet9FpmuoDFJLGiocBZN4xrfsPcjHnvsSR8lt7okfJbR3aovKpoYup9U9G5MSqT3m9RKhHHYGO9StouwFiQOtgkYMGEjNuq8YhTE6CumVi+t5CCKads0qfxlHBoRhQlMX1GcnPNGf8Wy15KHJFR6++BDpicSGDbG03DpeoWcRsQTfG1IqyLa3MaLFHUWcNoJsuWU6dXnw3CUuXbvCl0+/xrsuvo1hPqKsDe5OTzwJqIqMcDBASHlnA6wMvUqoNme4Oz0EAQ6WrFggvYSHpUe7u8uDXCC48ApaJDpfIm2JM4uQwYivrm9yvHyKl7OXeHL+DE/Pn+H57EU2f0F7qP+YcJXLe+79Hr7r7vfyLnXIdPoQcmdKVm6QfYmd7CFPU5yoICCmrltiPKZOgOM4zNenzMstr75wP4qOwE+ohKYtSkSz4qK/xz967T/kR6//IItozsfnH+E3nv8wz6+f++M+CARvGD/K977yR/iOe96Pd5IjuhNU2xIJTeV2nCAxwL2Dqzx3+jhOaenyNWeRINIBI29GdVqyXB/z1PHXOBhdYaQsWbPCEZKDZMpq01LLlq0N2dEuy7zANjnpjTOE59FsCqRU6EHA8dkpWV1RBQmeaanzOePkPGqbIROfdH5GYQzC8XCtw0bd2TDEOiTvbtE7GhXv47kRiTOg2M6pj85AuTjRlKaoaXOFK3I6E2KMRYcWZ5nTVi5WavaTEbUz4Oa2ZFOcooZDJp6LbxVF0DOOFe04QHgeiRxSFOBpS10XKM9BSEltLK4UtG1Luj7F9SXJ8AJ9v2GbXyM3BbgjBtYy9CfkraDr7ugS2GaNNxzQNWCXW8RgiIpGACg/hNWCaBjjq5bl5oSJP8ALXKKRT9CEhLGP0pa2LahrB2173Ok+wh1AtcU2JW26JvKGXN6/nxsnLxC5Lk48pOgKKq/CSEHbCmSTobwEp4UXyhNya/jWc6/lIDpgWS0ZB2Oq2mFdNEjh0HsK3w7obYlEEo6nVBbK1uBLiaNcWjOkKW4QJx6OVgjHwQ0COkdBk9PtzWi7Fr72FYKrVxlPR+BqgijEDUJoKurPfJL+Y5+m6zq8d347yTsexVsUNGlJoho60yIYs24sbZ/Re5K6r3DyArl7lbbv6YzFYO+IVOUrNralMQFl05Ps7iCdEnvjOsK2mKrA3aaQxFx/+jbhKGQyiun9CncyRakhfVcwd1pmeY7tFHnTMBtNsMLiB4IMj1bXtHKCnocs7tul+8C/QP3h7xP9D/8K99N/+KfWCVk3hD/1S1z46V9m9p7vYnv1PuLHv4R+/jn617yWQWip0aTZhsDx8BwHbxAi8enaBlc5FHmBS49rDEVR3fHefv1rsO4IsbeD3zpQ1fihT+SGFItj0nYDTzyHuXET+fAl9GyI748oTM+y8xj2BUFbUHYd27d9O+LZmySf/wL5OKa77OOgaJuC1tWs0zsK/CNXEnaHSL+hCErW7YrF1jAVPqE3oHUHRCOBf7aiSDcIPaOfXWaWbulOn2IZHDI7fAOOG9Mcvczmg79F8uZ34F+9CoDvJ5RVRt0UmLbH9QaU5ZbegGNzgmDM2JuRxxs2xwsIXfoLB/h+xMyJsaalzI7pG4dtpsmrFG0qXHvHFqqta8K+xRWSIJ5Rug2NahlkZ3RtTueP6KzEth5IicRBKcEqzxmHAa1pMG6ETu5YPi3PXqZoVoTTq+AMkFVFszgi2LuAXR7RakHleXhZj7KWMAxopaTJTlDLU4Y6pvEVaVtT1YJgGDNBsF5uWG5SYr3PIB5RpTWb1cuYakukI2YXLuIGgt4fciYi4vl1po6P2T1ElQ3zytBkPYUraJwtAkValGjPw5g7ntJ13+OUW6zo8JwI2Rt0Lej7nkwVOHFMmXisipqm6NCNg6NcukoS+i1aFphFyeFvfxznpeuovR3Md7yBfFgRR7t40SF5eoQ9SZmtW8Stp+CZFxE3bmKyHPd0Q3x8jDOfI1YrRJ4R/3t10F9PvuJ/b14N/5x3s/dHf6Nv+BaH7oEHKe5/gHI85uRbXkHz7W/CKToi2+LGLsvSEMsY7bsouWG9hTg5ZDYsKdYZo2hKMrlCc/Yi0hNEno8fhjj+DJcGqUOaZkPiDsnSNU1+SiJdlNyl1y5m6BB5GrPV9G97M/pnf5Hywx9h9+9+P7f6mnXb0w0vkiwX+PkpmagJBxdQfYRyeuKRy04/YLHMUL0htDXaBJzYmq11cR0HbIUJBUdFwzS6E4Q4HMT0xtCVOV4SIXtJ5GuKzlCHQ2x6g7ZYM3V3aT2Xxg2x3v0UJ8+hmi2O6gh/72nMpx5H9Q36tQ9SvuFtZKcZB7szhp7D7fw2hT7BAvvBJcRAsnIahOuTdAL559S9//8b/ppg/xWCpxxmgcdd52bIfEtjLRulaaqC4eEl2n6J37jIqiZbLhkOEpwoIUk3OG3Jay69mY+efYCfuvUBqkQxTi7y7otv4UAqfHeEq3w0S1rHZzgeYY+OqKuSTCsGQpF2lrBuGIwD/OGAVvU4RYtQLjK+s5R15k5KEdLFnyY0WU4UjTgutwR+z7nA0m4XFJ2PN94nNZKiXhOJhmqwT+orZv6AVa9pUYxlg0tIWlg60/G6u17NVxZf5Ln1U7xqeJWmC5iMzqOHCTYZ0ouax57+MF86+iznJw/y3ZffB/2Cvs+Q0qFqJKMooapKqu2GcDyiygrqRUovLfF0zNH6FlYLTpsC66Rsioq8MMSTfVa2papK2ra+Y08R+dR1SlqsqdotfnJI7O+z9ReYckW3OSac3sUo1qR1Q7rYQhQSyh7Z1bTrktTROAf3Mu1rumxD15Z4yqUqCipXovyaN+y/mY8/9zh/uHqMV195FCk0MvHY7zy222P6viIj5+b2JlvpMkrGJE5DZX2arsOPaqLAJe8dyizH+IJN1zOhZVtB1gqGgcZYgZQxsRvQ5UfQpqyyDb9x8jkiN+a7pm+iqzOy1sH1fCZTj9NljlpucKzBoMisRypD9qeX0SpDxi5Pzddkpy/iTmPefv71/Mzxk/zmC7/Lj7767xM5MZ0sQYBpOpqqxAsj+q6lqVukN0Q6W3pREckBdZ3Rlg1tB23v0AnFKB4RBBKzt8PZs1va0wIVCVzT8UA4463T95A7msePn+DjL/0et1c3sLbArWtG3oiN7/D0+iVuZi/w4vqFP2Xl9JeFK10CJyBQLr70uJCc5/1X38uPPPy3CYYH5NmKwcmTWF8i1nNip2frDtjohk5sCEWJdCMcFeC1AVWdosceX739FGjJK/cfpu9LIj2m7muawGHTxMRNwQVREM8idBnw4/f9l/y3r/nvOC6u86EXfhVVC74reRevuHyF3BmQFiV+ZNmYARRbBq6PcR0aAdrCXYO7eP7kSzx57TFef/crSQchVXmKVR1hkvCH68cx0nB3sk+9XZLphEE4xErFQSRpmoINIYqOvDjG5oLBqCYaT3Fal2B/QiY7lplGTA7ZmQ1xmjnjrUswmJF1EeHBHuVqgbh9RhSM8YZDzkRL7/u4Zcpsd0Djx3S+pNE9fuiQLzoaJyeaHSCbiC49osHixw7+dk2ZQ14Y2t4iZ3f8zRURXaDJ0pC8cbgyTJglPYtNhuwcPNdhbbY4VhDrGW7QMwgdynRLlWd4cUJrLS6wXZ+A7EgGB1ha1sUpre1JortI4nvo82v0+TFaz+g6MNUWJTpkOIb0ZVAa9AB6QIHwfaRwoSsYR7vcKm6QVackwS6O49DLHtfXNM0CYxVtIfFUhwwHiGCEFZru6CWMzXD3XsErRvfy8smzvLB5kVeOX8dQDUncBADZluB22GCHulnxxeUzOE7E2w5eRWdaetvjKQ/hSjZlR98aalcR6hDPCdF+iHQ1RddjjcWTYI2h7gShM8TznTtWPc4IIRRONMCxe2T3tnQfUTi3rhO/6kGk76BdFzcIMbePqH/upzFHx+hzF+ne9nrshcv0XswobjitQrq6IPAKpB6RRDFuF1H2PVm+JizX+M4r6JuOom6QQtClS8o8pdMhOvLxHImtJMFwh3h+zLgVqMzgqZAwHnGtKzGuixl64I5pRE0mG9ZliSxWrJsCyZCu2xCpEN1pqHMit6dThluBQe5eIDx7gc3N2+irj6I/9GM4zz1N/3/+v6J+7YN/SjRJGEP4q79OyK8Df0QYfukX/vh6+j+y9mjAB8Zf1zb5uutuZwfz0CtJ7n8F2/NXkI8+Aq9/FO15tCe3CD7xUYwDwdvegpGKUGuWtcSWW5TpqNwxLSWetATf+73k//j/QfSx36P8se9ju5gjqXCCKXkPg2hGlDS0RcGlCweIqcOyzMk31xGBR6okZt2g3QF+mLKeX2fZVCSxZvfKRfLHU2wG2/wYfxtR/vQH4Pgm+VMv4PzET6CuXMbRDtIJKPM1jgjopUNZHSNQhEmIFh718QrHlThxRDI7JEkmf5x1glQ4fkTdVkiZIL2crMhw12uE3xLWA+TeIW0QcmUQQZeTbl4kKwvOPBdX+HhbgzKGcDDAWpfNco4xllFfIR2HIhrR+AUzLVlWFV4wpS0F7XaLCiaY/CZutsFqwaZSeJ7C2BK0hy+hDwOabow9O0VPYTK6xLpdcrQ5Y7CtaAKJkANEDsvVLYpphR8rhJsTkhBMzsHeJdpqQ1Y3+EoyLjf4o13SokKYHuvBUdrRlA65WxBULbtuguM61I5D4TqYriXPVxRKIuuavsiRvSGXPfU2o2gaRp4h8RNm8R6+MbSrJZ5VqLLj9AufIfzs4/ilQO7uEwwc3J/+afwXr6Ov38Jev0k0X/w7JNfnrwas41B853fS/r0fhaMV8umXaO+/m83feD17nk+d+gzDmNks4KzwUY5P7MJym+L0AaHwSLwQ02lMGGLSBYtc0AU9SWsYTWcEwQ7z+eO0fYaxY/JtSXN6RKRcwuk+cjKjMgJVrgidgC5ySS8f4N5zN/2TjyNurRlc3GHe5Gjpszc9hNVtvGBE74zpzjLswMXQM3CnnDY10aAlND1e1bPRHb3skUGELhsGYcmm1FTrHLdsCQYj8k2BKTvEcEBfd7BNCZuKJqzo0g5MTF1rwtk50nxLnUuCZIz5g88zePx5KAzN7oTkve/CPdxjfZoRuAEqChG6YpDVGDsid13O6orD5ICqvEk9CfBai3C+eWjpN883+SbAOPGgC3Aj787m62jBtlZIely7opaKwfkL1G1PlmZE6zVSa7SQRMJwfnyFveE+p6ubvP7c23ntXe/CbK7hDqaEXkyXVwwDQaF8XM+jcl2coqAKI+qmw262zLQHoxjPC2jWc9zeR40Gd9LzgK43qKbGAt6FS5gbN/G2BXl2ShiE+OMhTh2Sdh2LrEX1PY5TE3hjck+jpSY3Eotlx0swzZqyLHG0g9UdB84+A6X5yvoF3njx2+jWJZ66E3sUUvIH22f4vfXTnPOm/NiFt6C8hE2xQVdbPD8m6yRVbQgmU+TZ/E6ts+fjCo9YK3Ts0PctVsV0dUqEQvo+cRhR54Z42HBSZTRtiUgg1QVdUdDbmiCcMnAPmC9Xd6x4kvPoJkcWGX44YN1kZGXNcDSiX7xMVVUEswuc3ztHUxuwDvnIUjqSYefinM4p0wphWhyG3L/zEC+nz3G0fJHz47sohGUaeozqCQ2CwhyTpgvccEQwmdH1KdKxpI0mb07Q1mAdxVYJ9lyXpekpq55BDGkt6TpF5Hl43ginq7DWo9Oaj80/wqZZ8wMXXsfAHVAuN6wbhZUT5r2hQ9KlHTZS9FWNH/ic6Ih5XzH1NfvhDnnjcTZ/gZXQjETAvj/j8e1TvNXc4P54h9b25KKl6yVVluJ4Ptkqp+8gGLt0zRCDJbaC5XZOmRbYcEomfGZlijsb0ZiaWIKcDblZLVnWsCd6uuo2Hzr6Az5/8iRZf8em4jXnHuEdB49wvp/SDyzbJqRpGtI+Y7W6RVmuKCLFs9lzFE1Jaw2fv/EYQxXwnvu/E2EFrRghm5zzToInFVk05d6Du7nigZIum7yj7Uu0EGipoXPw1IBlWuFvSmgEqjzFdjF6NMURLlldULg1k75kXwa4gymy7ehqS5a3PDF/EtfxuHf2AJgt2ApX+dwq12h/iK9DdN0wpqENFfNKcNusuSu+wv/ylf+IYtXjdhnOIIJFQ2AteBLbhVjulIRUHYxEx61ecdE/h+pKnsuv8W1734sSNa0TUMxP0bbhD29+migIeOD8oxhvgicFoqxIy45haPFNjW1DzjYbqjpnPLpEEMTUN07oRkMaBTfWK9pec9csYdcVLIoNUTjAN4radcg7S9dJXDfEVwIRCWhqbm43JFXFON6h91yMMHRVRXd8G9cfUfuWsGlRBrQw1KfXaLmAFi2hZ8lEDGOJjC1VZlF6gC9TtGiQgzHjLkQRILwVbmHJa4moCpSfkDcNgXaRSuFFMVW6JSsLeiRtsaLv7syD2qwp2grhThhKRewmKKUh3KPPj1BtSmMd+nqFHw2wdYlsWuzOIcINsVV3R9Hf12g/omnWDOMdzoohm6rD1xukjGhbQ11vgY6mvZOq6XsW5UVYY+jzmt4LUa5EpBkPDC/xm67m6dOneejSaxFC/In1SVOA42Naw3F+mxe2N3hk/xGGXkJebxAIHOmgHPC0pOp7ys6SuArXjJHao8VS9wbZW7SGtGzxhGEYReDNaLs1TbvC0SOk1KBdBucPWU9n+FmBMxqhtMb3A5qP/g7tx34H+gbn274d/1vfSV6kkG+pK0OkNcJt2ZSabZ7jqS2DwZBcgutO6KsW5dVYuwIbElkfXRT0ZUUceuB4KBnjGk21rhG9i9kZU97eIm3M9P67MFOHnXmOLBS6nBC4M/rmiMw6TPw9guw2TRJjXZ9mtWG+1cR+jC16Ah2yG40p2oKjoeFgdYYna4IkwGxLtne/gvJf/HOKz/8DBj/5T5l+6NcQ36De8z8E+uwMPvFx3E98nPDr2y+cZ3cYYHUA73gH9sYccfUi2nQI42C7mqU3RiiPc74gNBXZaErx0MPoz34C9bkvYL7jXcSDIWE8IT9Z0TSaME7Y1immtwTSRVvDJX/Abd1x1DUcmB53sAOez2Jxk1DV+IO7CUYzzGRBV0vEYs3qX/8kOm0I3/RGmsceo/iXP0X4d/8O6splAj9hM1/T9iUqcvA8n7aw+J5GzAvavEYOZwTDAaYTLDc5/iAgEIKmacjSljzNCIcTbJTSrQThvKFbrOmjLeVY4zkD0vWSUZ8z7DuKMCZwZjTbjqNsxXT/4I+8lkvKPGPU1aggJJzu4lhYdDnrTkEQM/H3EaWlbio2tcEkQ1R6ysYLwIsY1g2npiKOhihpkUVJmwzojq4T5i/T4wIOoYoptxXt2Rl+2KH3x+hig9Qd3aqCtsObXcAf7uIrSe0F0JW42yNqC7ZX+I6i9WMump6yWnI7rTgVIOSG6dhDbBo0Ft9xqdOMQG1x3QQp7yhlM3ARraQpO9yuZyZ8Blbhz88wzzyDfPZZ4mefpf34x7l64wZOliLrP9Et8fiT0+O/ijCHBzR/+29jfvwnaAcJ/a/9EuLZZ+DBV3P2trcTmApNRFZ39G5B0yhmgYfr+6yzBZ21OJ5HUAnqRrI7G7MwIScnz1EWOc7kAknQIaslHYKglfTZmkp61Lj4wZThKEQMd7GOQ5XWOKKDNsQPA3JbId7+BuQTj1P99ieJ/6sfZV6U4Hqo0UUkDuH0HNvFlrIsETOFsorVusPREfkow9kq2rMVej9mP5bMohjjO6z6m1y3NabvmEUOWInJc0zTIvqOerOFDehhTKkiCn/ErI/ZnJ1i9QKkpHnmOXY+/0XEzeuo4YT5O15H8vZXk3ia5XxJndeMRiGt2YLjMfAnWBshg4BFfcKi70iikLpx0IkDvQH9zSF09tcE+68Q/i2JBZB/tKHstz1yL6TO5/jDC7iuh3IsuXZoTY9fV4heEG9Ltl3PDz3w/XTrOdP9u7l59BIjWxEHHvXJAm0LBo7lqO5oqgYdRcjtlk1VUZcVF+lR0122tiAv1rh1jxrFf6zKCtB1PUFdIocJylP4bs3i1kv4QYDcG1F4O0RpS2QKmq4nCh0K6dH10CuBFAGVgUNfY1pBWRocXREnA1bZmr4peXjnlXz66Cus6y3nhvvY3mDKjs+dfZHffPYjHAxm/C8e+XHsak6Qn1L1mrppcJyMrvPZpiXhweDO6YjnQ+BTpAWyhTLLcN2AWvqI1TFI2D84h+vH3D7N8UuLURGZo5BRR+C4+OPL9H3LujU025qurziYTAnGY6rrz9NnS3Tk0+QZnudSXV+CrHH3RgSzCaIBzwhk7OEozbpaU3mCaDqkPKvIjuas7ZC3nn8z8+s3+ezxH/ADg3M0rabxNJHvURcRO94OgybGBucYDwcM2oy4rZgLh/TUci7ep3eHVH3D0FHoriHvc4auR+jEFE2PK12cNoWmQPhDXrz9HF9aPc+V+AqvGD5K2vSsry9ZjASu0+KbQw4Th3LtMNuZ0HQVeZ4TipZOtVR9RC0E3lhzQe5xesOgC3jnxbfz09d+hY++/FEGd7+bRIAzjugbS5ZlGOPQ1h1e5GKlxMYJQZ/hdB3N2REbNWHqzpBmiycEznBEu9lQL+Z4ynBweYf1zSN+/fnP8UL+Io0SjKMh33717Ty8/womxseetDiTEWXQUOmWcOSxPEuZuhFJMySOz/HOg7dQZT3rPuch7x4e23yFC/FFdrspt9qS0dRjV/h0RU20s4cz3qO1HfnNF2iMYHBwCS/waMoSYwyN76G6nnCZgiMxskeEQ5ocOlER1BUvNUsmMmG3camFIC9LXOGxzXKeW7zEg7sP0OWCrlM0/YZMxJRZxV4U0nWSzIIjFFG1RcSa58+2PLlqeGjvjlKzM1A0RqOFIJA9Z12PpwIEJQsrmKoQla8xTUybppwL97hm1vRIht4Q6yacrlY8vfwyJ/kpr7n6N9D+FItgbzBgWzSEuobmmHyb0uUFql0yGR6ghxG3Vg1WKgIN5vgmfVZwODpgP/JI2w2qKwmSA1gU+OMJm9MNuq+ZXNynL9ZsT68TJENMtcZV0PjnqDBsqw2zdYmsakwypjk5pXA14WhMEE1p4pLGVSS7d5NkZzTrBqkdll2BNZqdKGJRrEFUXN49pCoN/WpJEIQMBoqbeYUqDSIqWXdLRtNDALTj4PgB8+2asq/wtQHHUpgcx0QE7i4Db0Dfbej7FKU8lArp/SE0Dd3qCKF6lLdDd/Iiwh9g/BA38BFCY+s7JFv4MXY5h7Bm6Pms24Y9NJBhjCDLCqJoSFVaHFujAgcpXfr1Gtv3MAqRZoIoWg5CwdSLeWbxAn1Tor0/olpdDabDegO6rOBzZ19GCIe3Xn4LKJemXuOGszvlGwJiT1NlPW135xQ7dgKkq8h6Q98bPCVpmpoewdCzSMcHqXGdMW27+uOTbKl9fFkiLl3EPvssylrc9YbyJ38Kc3yMmg7wvu/7kFfvv/PM+56+KWjqnNxqaheK1mNUt0TtmqRzwfZ3/L+xRAf30CnBcVVxdnKDkRBEw5hOG4wJCKIA2Qu6oqerBA4RRVTh6Rki8cjrYwZJhA5ipEzYrkrWJ4beX3Lh4JAgmpJZRaktdA6y0wQqQMmIPM1ZpHOCbYvvKPKdGYPsFHec0Lcl2XJJ70V4Vx9m/X/6f5L+7/87pv/vf0Xyk/8Skf+HCzn+RSFv3CS48Uf/fPkr8I//CVYIzOULXHjFK2jvvx+zf57ecbBKUtmalgDdWoIsJ/y1DyN0jb7rQVrvOiwLRJIwGrsUi1Mq7SDEIZWQRKHPdBCTpinb45fxnRLrabSeERmHqtyi6hJvf0b74oLug7+Bk26x734L/ZvfRn/PJbpf+g2qf/lT+P/Zj+NdvkRa5Lhmy+70HiS7NMunoC1xdEw3HdH0glg5LJdr8tMaPQqRcYxnLDa3aNHgmhX15pQ9oRH7E5q1jyhXzOcLzvclteexjHaY7tyP6FuCqiOob9GHIX6UcLZu2GxTBtkGFfm4Ozso5eF2CxJTM5dDQhWgaoHtLb7rsclybBKSijOqdMv0wiHN6QmiynHjCttKxOkZzWQH4d6xL2uLlGW8Tx90eMEuLgNsXeC5EcpP0NsldnkdGUv2xjOkF1KWPZXr4h/dpv7al3GXLcm6RJ0dUd+4hWMsD0vBuaKhsh2hB47jYKxChSGh7+MbgxAlyg2ReoDwHIyEyBgudD39Sy/iXruGeOEFxPbfLcH6T00m7HQCu7uY2Q5d36GWS9huMb2hdwS9p3GNQHYWay3CWoQBjEF0LXQttC0CgdWa/vVvovvRH6J++G68q6/EUwHmF38R++wLyIfuo/3+d9GkDaNaY1IHX2lsX3N6PGdnZ4ZyFVmTgZVQ1wyjIUqGdO0KZQpWrUaFAcMsQ0ufdn0N4yzwB3fhDiKsslQE7EmFcHzQPlV7p+wwtBYpHKSv8VqP7nyI86qHqZ54ju6Jl1B37xGpnlR6TPeuoKTA1D0b1dHWLTSCs1XFXhzDRDF0JOY4R48cPMcihUC6PuPhhCq/geN7CCfBdyvYniJiQxArWjUEPNRujF8tafoBvvUxmyGbp54g+tIzTK5fo5UO8VvexemrXwW+ZncwoW0XpFmF05Qkk5gWjdJjVKIZbTN6O6QKJyy3p8y0haonGl1A6m8eWvrN802+2dBVbIzA8xNsU9AFglAKsBYlBJ4UlEITjUb4UURU58hiifEHHB7czbGv8WLNzuR++iZCqRanbZAigDRlKxpiR7A+m9NlOVoqmE3wlItoctosIwnGyOhPYuBdb7BFgTI10iooe/pwQGEqRsEejqPJtcEBRlGMcBRpneK2cIzFCoeh6xErgWkNTdHjuhFSlciixKzXtM6QR3Zfy6dvPc6Xzp7g0oOXscby5euP82+e+gBDL+K/ePWPsDO4xMIJUFlKNF+wWTfoeIRWHYvVmuksQroOtm0xrouV4CUBy9MF1guRukM0BSoe4vohWkuSwGFzliGBkRuyFj11UzAZTVgUOXQbtFFErkMQRDjBgMYb0zYrzJlB5DUWiWkV0YUL6IGhzwuU9pGhRmiJgyRyIrJyhTYNcjih7hvy5Yb7Rrs8NLyLx28/zbKcMwgc0koRhS5O7eF0CVpHVGGAKxXCH+K0Fen2GmVtOdzfwfo+NxYL1lIxRpN3glWxZH80ou0t2/WSsdPQOTFZZfiZx3+F1gi+4/zbaE2CE8aYszP8aMzUrZipFVIq/EDQVQ3JKMEYQ7AqUTIhjIYs84KiLpm5e8jqZSp6rl55iFemT/Ds4mVWFzPoJdIxWNehSjvqCgbDCOFK+sZCFBFst7SLU2yvyXG44oYEbkpVaTSgHIdmPkccJDyR3uBD13+LvK3YHxzwrVfeyqOXHmJZneIqg86g6TRt7HGaL9GyIfAP2dvdATegkx3CU9ja0G9LAk/w6PRunqxf5EPP/A4/OHkX+wcDunjI1kiG1menqiibhpvbiqAxzEYeYehjpaLvOrTvk2EJRYNqFsjxLt1kjFSKNruz8XP9DYF1EfocGEHUVjRNR+t63GxvIh3JPdO7cHwJJmFdFEgKDpMQIwReGNBschovxFYtKs04UD03qpyXzyoOnQLjRygjCSNNvljjhZLCCgwOjm8IxgeU85fxzhYU1ufK4cPcuP1Znj97hvsPLtN1BY6T8Gx2TGstdyX3IZUm6Du6tqOqanxKhDAke+fIjs8QK0USz2jPrtO2Cm/vPI4LJ6cbTG4I7ZJtv2VrMwKTUro+dpli7ZplXhIOPIImZdts0VlF1Ht4rketDEFb4deGo9u3OK4zJsMdtD/AFCtyr2N4sAeAb1vadEtv91DBCFPcpigMcQszZ0ArerKmJ/HgXBCx0XB6Ouf8pqUZDwlmM5ysJ8saKnsTY0fAnbRq5WpW2SmyK2F/l6xs8PwB43DnjzNsUBFtu6LvK5TyUSqg0Q1eEtHbkja9hW079OzgzjruOEilsFJgyg6kRgqHrs0Y+EOWWUlpAiKt8LyCulZsM0uRFYxkA1pjtgWi7xGDALoM0buIYYIUDfdPLvOZa5/lZHmDcwf33eljk98RoLSaol7xxfnTXBhe5NLoAn2d0jcFQfwnAdXAVSgp6PuOqlcMQgcDVI1FmDvpzkXdMAw9PFGD/qNsI6FwnAltu75DsnWCFgJ16Tw8+zziw79N9dzzIATOW1+P95bXwWAfgNZYKqlYyQBH5cheMzaGxNfI3Mc2JU29RqCgqUCAHO2jsg1xkVOamm7ssLBrdB0xTgK01hhhQAmqTUdvPEI/QNCwSo/opWE8uEDXlQjPUmiJtR5BX2ObOXKwR+yGtOmcUlkCpSizlPFsB4+Ws5MjHBNwYbrLxqRsV8dkN48Y7M9IkhjfuJS+Q7NuyaI92v/D/5b2f/2/w/+n/xjvt38Hs1zRW4t0XERZQbpBeC4kMdLxQEg6a5H09FbSdwYpBEIpNBa6FnntGrKu/1LbDGEt6qXrBC9dJ/jwb/+pz4N/v+FXPwSAA1z5uua7vu764PwF6ne8A/e9343/xkdZaM12XhDs7zHbC/A6BX3PZnMT34aYD/863WJB/L7vJnzzI2zqNc1egvyh78X9wIcp/+VPYX7gu+m9Bu16eNYjOzlB1SUiCrFaItoCuTXUhcOyKWgWS8JFR+MqWjckchRTJ6cyNdZxGO1eIHN2cAYN7mJFli8QnUQ5HWldUKdb8q5HbDaMgwBnMELUHaKsiPI5UkoWgxEj7UOZo8SK0E8Q1qEuBDUdnq+xCsg1jpWsrCRqc+TJEdWmxMkbem+Ov3MZN4nJeosd7aHrinI7pxAN4ewQJXxcOUa0S5y8RL5whH3pRdTyGur4Nt3xB5BnK5wbN9m5cR21Xv2p3/HrMxn2/1Ij5E7N87+te3b+vBv/krBSYqZTzO4e9XBIP5rg7OzAuUPEeIJ74RB1OIaLd2P2d+llhzF3xvemM1QGptsU+9FPsvrC75NnG+SVVzJ923vpHtij2SyZOjOWRU1XnhD5ArHOERfvpR/NiIygufUMUhj8OKb+5Q/CE19D3nsv+v3vZ06K9HKGwQ7FQrEz8xC4LJcryrzhdDNHulA2Lb5wiEcjsm1JsSxwuxRR1aTRgAN6KJfYOMYJ9nDDEGTCTp2yNQ1FsWEQjRFSUrYNyrZII1HxHZ0lT7q0fUXwnr9B/fRLVL/5cfyf+BEit6EXHquuoykbsjyjG3lEyuf0ZMXMKvanLtILaHVHnba08yXlfszAvZOVqtwQ35Q0WYEXgVIuTWcI9y9g9Qhpe4QUtKYm8ECPx5hbx3i//yncxz+P6/nYRx/l9E2voRztUOYVV2cjtIRVvaHLlgw8l+HogHXj0vQQugFKZyRNR+/H1G5J2tVISvL1hjBO/iOOsv958dcE+68SmhxRrcGOaIotRacIp1PqzbMwmCCFgCYDLyGQknXX0xqL4ziE+wcMTlsqKamUpmo27A+GSD1FaEmgC0Q/wYl38d0tBZY41mSblHgxR+3vkzYd7mqNanOMBX84+ZNTdWtpiy1idRNvEiOUplcx69rDG9eM6cgbQasrcs/DqQxGQiNa8rpjrjX3BjGJ1qRFi24sWgoc6dOkc7p2i3ICumTAxWDAzmiHr66e5H3qPTyzep6ff+FXCFXAj9z9nUy8HaTUuG5EO9CMXIf0pRepVxsmyYjtVnB0NGdvFKDqhkbXf+Rx3dE7gJFUpyeEYcB4vEtZlgSuT4BlFfR0RjEqeoSw3Oo2DIOMTkIcJJjO4BtQroepOpzhhM3JGe2tpwmDCd30IoP9Gb1q6Io7xE4kAvF1KS+hE9KUK+b5As/dpfRjnBEk4yFvb1/NV17+Mn9w8jnet/P9bLMc3x3ghB42NwgNytF3hJa6jrLX9M0WHY7u2D44ith1KTAMfJc4dcjKgirOGboOq03GggQrXD7y5K+yqOa889LruWd6AHZE1voUYslIxByMplTpGusI/FDQFnNK9w6xinyFJzy2VY2UJWHvsF3fUW7vpWWtJW+5+gZe+OKv8NiNx/mBS2+nKnsaz9IpS0NK27a464rOutRNT1ymbDcbUjHBVWC6FZ4jST0Pp6kQdU1ZrvjQc5/mq+sbJPGYH7zybnb8MZGvsTLC2A7VdpjUUoch82yJlD4HUUDVVyRSIHyfYy3pAp/A9QjqDtqCqu654lzm9/vHeInnee/w3dxSAS+uT9jdOUd7sgB7htHQTqd4kYOt1jQiwPY9jdSIOiWsVhipkaPzKG3p+5K8h221QsYtD+ycpytC1o5m1uaMB5ptMuCJp5/F81we2r+fvK1oHA8/TAjNHK0TcqsQUpMQkOctVvU4TsLVvRBncYPrqxsI4bLTjxkrDaKiazr8Ycy6aRHWsu8Jyq6gbjZ4+RlZtMvedB97q+KJ4y9zz+4+Ah+jXF7M55xLztH2lkgYfCynp2eAxI07dDgC46N8iJJDbG/ROuBiIpCB5DRbkZmWcTzCerDMzpDlGmVbhDdCmp7KpkSJiwwktc0YJDFJNIF0jWwMSI8sPybpNefHu8xVQBuOMcEuTV2x7dbExZZBOMAfzKi3K6p0SRuP6cMRw+waYQ0m2mVVFviOxPMUrtQEqkKGIdlyjkpTBoMDXNFRdgZdvsB8/SSHk1dhbctyeQ2jDEr6pGWP746YxTNc9Sd2IlLesRi6owdx5xTb1McI10G1LV12fEeQzPURbYtUd7atwpFIoe/UvVmPvsgIRrsEhWRdFowmU4TQeJ7LfFFiu5LWpujCxwk61HhM02+hlSjPRXoa0Lzi3Gv4zI0/5Knrn+dwehGh3Tsn2P6Qvqr5/NnjdBbefPENCCGopUQg8L6uTtjTksBRpE1H1Rlqx9JYi+kNyliKpkVKwSiQUAPqT5JBhZA4zpiuW9N2KVoYvAsH9FphnnkWee4c/nvfjRz5GH9EaQxlb+msRUlJ5HmEXU9Iz6bxSU2LdV1M2dD6NaCgzBF+QNNoDAEhR/jRAJ1MOF7folU9qkkJaoMwd7zM3UAj+ggjc3q1xQQTBuoA0ym2i4YNHckoZnJ+RDmvwNRUrUUrl8gZkmdbWqfBlzHZeoXruiSDHfrA0OuS/y97/xlr23qdZ4LPF2dccacTb76XV4yiKIbLIImkElvJsmVbluR2l6uMLnS5gf7TQKN/NNAFNND9p/52VxdcBizbVCrZEiWZkkgxJ4kSxXxJ3subTtxh5Zm/0D/W4WVSsq1q0IIGsIGDfdaaa8255xzf947xjvftQoBM01cNoVJkkxmEljTUlErSeUu77VjmU47+L/9XVv+n/yMXX3qaWaqI8yt024747/8901vPIn7wNZg3vxGdX+Js4wm+YtUKxioh6xsqBU0MHFy+hOla/Be/TPzCF9Bf/grZ5z/P6LkvI77yNML7/5U2Ld8e+sYL6H/9i/Cvf5GxtUxe81r8E2+h/7EfoX74mDgMzEJJKnM2v/ir+LNz1Nt/Av2KVyNDwiSu6Dc32KhI+ZPfh3vnr+H+xf/I5KfegbjvftqvfAEHFAcZbr1gu7oN+RhdjrlwkWq3YpxLUjkhawPCRyhTVlhqteBgdETtInV0ZKJj63eYtkX6S6jRCdO45aunT7KoBhKvOXjkJUgpuXN7jWm2HFiFTHL8uCT0PYtmjSg0UqaUTSD2hk0Kx7mmdz2+b/BVi40Oi6TaXODVhPGV++n9gl4oSKeEp58iKoHYnRJvPMvxYkkyKMzZBcnNG4hnn0E+/zxytf7/29/yPyei0cQHHyA+9AjV1eucXbmOfehBkmvXqKct6cllQpxxtmmZpJK8GNNtOxICIbOI2CBHFjG9uu+4AjF6Qug50JKFEzTTkvynfhDxkkvod70H/eWncXf/Lf4H30z3kkv0ZzsK7dkVJdX4MikL+m3NeC7pq5pQbynue4D+Xb+N+5NPIR99mOQf/ix1aFi3nkQMhChAREapwWvBhAKdKvrzjrD0tKHnYHJEdXZG6AaME7jVFjOZM5lN6UtFPlQkrkZoDWGA6LFCMYmCbRxY+obSOQYf9l7qyiLsfn1IEFQRhqMZ+g2vo/roR5k8+SzDSx9gNC1oUZiqJZUDB7ND8IYX1jeZZyNEIhmpkqWvSO6bEZ4fWD1/m/njh9gYEO2KbHpC2zjSyRSCQFiPLuf4VY+0CpEoquoCqyPZRz7K+vd+H+0c+sHHMD/2A4Qr17CtYNt0HJUlk2LErr7BanOKDobx5ArWjjB+2IP3LEFYTeoHCm8o8gnVuoak42yz4sBd+hvTxf6bcRZ/U0Jq8ANU56zPL/AyJcsFqTqgbyN9LrF9BTojVRrlPbX3TKTGFCWlyWh1oMoVSTWQimNCFKSF2lfFTQ5CMMoTznYdiTQUWUpWFuRXrrDShkHAJIxAin0yiBGGGvqK4eICoQzq8BpRJ3uRrgCzk0tk63OGNhB0x2Atde2hbemE51bvmOVjLmHYLTqaqmNUJPuNTuwxKuBTgc2O8dEjteK7L72S3//q+/m9p9/LB575CJnJ+NlX/zRzLxGtJuqAVZat7xiPL1EcXlDveka+Yy4t201NO06grhFSkM5mbNsNvZKYoSG2PZP5lLKc0FQd1cUWk1pqdiAE3kfGXrIzKTsGlDJor+gSj60kEYUIkUEJtncW6Lri6IGHWZdzSA1i63FBoGeRKAa+tfabRc2ydzTK4dGczMYMWnPtykt47IXH+PzdT/PD15/AZIesNzvUKEdnKQiBkgLX93Rdh7QSaZN9RxuH9Yo0SfBNxbZIGeuMqtqyys85URnjssCnU25vb/CZu5/ggekJb7v2ahISgi04W3qaxPKwa8izE6rVGmUlo+lV6osNQ9th8khRTJiVM55aLtg2a15ijwkjRSsTWjljt+7JRsc8cnIfT26e4qJ9BWWYI7eOo8M5dppSu566q1kuLkgAl1jqoSdOr3BlHtks75KHKb7MOa8W1Hfv8ss3fotT1fOSS6/k7zzyY1hhKYoc57fcWj9PmWTYnWU53GaYeVw348rhIUGcMQw1U1UikwxtI7furrh6NMKMFf6ZLXJywMuuTnh2eJpPrb/IW5ZvwByO8F6w8Q2ZNPSnLzC9ekyvSm5VHbN2ResVXlpc6JgYEGhIxpDmKBGp2g13qgXWgg+Ka/kBF01kIxW665maQJpIvnLxFPfPrjEZH3JnvcW4wKVxQVPfRgC5ztkNO4wU+L7Gy0Ca57gwYjo6oBpuIkSKcIIVNbvVXZzvoHEY35PqlhAFpnmWOztHUs44OjqglylFesBX16dYc8jQez5z9nEGKfiuK0+Quo7u/AXQJbsmcu3KEdbsCM7Q1UtimhA3grhpOXzoEbTsGIaKIey4MhpxOc2IiSM2Fh0MvhHEzRIRKvzZgvGV62x8i/IF89QihCT4lGgKyrTELe9Q45kdXma29fRakAN2dMCtuuLp1RnXo2Ke56h0xMX6Ap2UlMlon9PamlZuyJIEmWVIGQmhp/ctJ9ZwmhkSpzj0kijAZAWH9iVsqy9zJj6PiYZNFwnFnKk1yCZgosHob+/nKFUwDAtCaBHCIBAIH5BDwIuCmCUM/RZtvln/VmiJLAyyHzFcLAhFzdRk3O1b2sGTmgLvA34QTIoUd7qllQYzzxAi4usGrceI9OtL+qPHL8HkU55cP8vbdueIJAMhiSLBDUs+cfppxsmY7778CgD64NC2QLhub/nFfmypSDXbzuGcpw6BIURUhN0Q0MEzK1JkGEAZkN88OyeEQOspzm1w7FBHBf2rXoW5conkzW+iq85phKaLmugCiRSUSpEqySCgqQOCmiRVNJsWlySE3tDtGjJrcW1NLMYYBGkaibmlJlJXa0pxgJQldV3TyAVlVjDJR1gt2Z57osrx2mFtzjgtaSu3Hw3yjpnV9L1CDS3RlYgkIGREyoyUMZvVOcmVEQwKoTPKXFGZDWf1C7QicOXaY6Sn56ys5LzfclTMkEj02YJCGOJBpGkrOj8m7jxmMIxP5pyvL4hRIP/+P0D+4i+SfPxL1Feu0NwX8UPO7W1gOoZ5NmG16iD2hCRDuZ5pWVC9/Lu4c+0+Lt76QxzIjivTjFIa6v/7/wO+8iT2+mXU8zeQn/8S6satbxNd++sO0fdMP/YR+NhH4H/4f+KuXaN6yxN0r34letui60D3tjfiX3qZTdtBe0YYp5Qn38Xq7pe5lbXM/97bkb/2fvJ3fZj6J0ZsxgXJKKEfSqrNBUNRMrr6GLYscYsNRS+ZH84ZqhotGiY6ooqCi3lB02qCmdIwQN8xES11meCbMW5bs/Z3EDOLFBkjLSjLhLN2xVBF+rMt1w5zlC1Aa8aJQa7XdIVlm1pOdy1pbZmWii4VLJYL5FeeIty6S3n3DtNqAXVD9+wz2LsrkmpHcX4buVojlysO/iPZB98JEY3BP/AAw8OPYB9+gP7SEaujy7Qvu4Z46CHG5ZhN1NRyzNh7xGJHG+9QIFF9zllVYeod1hu0VjRDxLQ9ItM0zRabH3zT6KQQCqUyCIGpW7FqdpyGDnPpQdK/+3M0T32Z8svPID/0QeR7KlYPvYTiza9nfvUBQlJwVtUsF2um1x3N8pxcK8KH/wj3R59EPfwg6c//AmGAqq+pmpbr44Ku6kjGGZpI1/YkScK6W5H0Pac3bqOLKTofUElBOZ/TtT13VnchtxxPJK0XDKPrpPUSX53BpITgwTWYdsPITlgrw+3dBXpIKKNHl/mL5y18jzEpvYzEt30f8pOfRH7kI/D4A/TbHeN8wqreoQvFKB3z3I0LUixJoXD9gMwMo3RMa3Zwac7mxvNc3Pkql8eTvcje/IBp25JmKfXt25gsIwaILiAnCb2vcR/7GMknP0NoGzg4YHjb27CP3I9EoFPJAZCpEcfzgr5fsKpu4ZuEqZmQTSbgA4mWVJ0jAsIkiOgoQ2Qwlp0eI0QLqWEgfkfP7P/HxN8C7O+k0Akxm9E3OzbLM9LjB9HGk5ZXWZ+ds9tVzEY5ottAPieXkp0PjGJEak2Zjznf3abuFZNokWpEkmtUaPdA+d6mqbSKLw+O0XLNUZrQTqeoriVNEqoYydIUAdDt9pTCGIjSMsQMdTBFmJS2bam7AW0sRTlCDVuyuqHrMrA9OylomprKtYjB84DK6TYDMkI2TaBMUGKAZoso5gTlUTi64Ikx8j1XXsV7vvp+3vP0B0h1wn/zmn+yp/7GASVTQjNg7P727YVgOr9E253SiIFynFLfbnFVjTYaMQwopaj7Gjf00EE2n5Irja89sXFUbY2LWxIj0OWYwgzkEjbdjqbdkakShMVasDtN6CLtsGJ7dps0KcgOJliboJsNrZ4zyhP8kOF9Swg9Sn2dpBVjZNhVGFNw4RxadBzNLhOco+8G3v6yH+FLf/QCH3j+E/zUoz/M6apGEjCjEUIIXNfREbDWMgw1yoxI0xFD2GEHTWb2G08XPMMop6gt9fqMXTljPH0AL+Dffe7XIUZ+4uG3kQhF8JJdFGx0ZDqZknc7YteByCF0eNGQFBmhMsio0NoggtxbkNSemCuskuTK4qbHDLfusFxVvOzg5TxVv5/fv/0Jfvbhv4trKuK23StwpgWJ81TBMyktp9UFXdGTzgyTPKHrNgzCcjQ65EPP/wm/+9y7GBS85eT7eOujP0g5GqO1ZhgGRIh09R18uITbbrHTY9IiwS0cOg5UPqCjI7Y1rUuQbU9TNzhZMJ3OuXtjQXSSq1dn/KB6gl//7O/yrq+8h9du3s44sdy9OCUtDPJiSbk7IJsY1sqw7Wvy0BK0xu1WxMkhbuiQSYaQEh88d3YVfqg4nM5Z1Y4ijnC2Zo2n05ZdDNy5/UXatuK+7D7W24pCgB066mUDIhB8hbUj3K7mYnPB2GSoRFO3WwYXyMdHXL8suagdrVtQ5hYbK7qs4GIzcCWRJMmYxnvK6PH9mDCDa0eXuLluuVxc46mzJ1nslhRqxJ+c/ikRxZXpS7myvouot2znBSZPMbLD9Y6hDQyxJ3QpmXEYWSDzEtSIW4uOLjvhJD1EZ5Yda3JR7OmhJzOGOrCpt9SnLyDqHlVMcX5GzA8QWiNHEJ3Dr1aMkhGbNLLpl4x1Qic1XbtlkuVoUfJC23JzecHZekvvNX654lKSEfMp67rBJDNGrqFQLa0akaqCetgQoiTzHWmWoeSMtmkJbYcYJRwdHiCXj7LZPY9WApcfMMsKLuUT1v6CvuuIISDUNzt2SmmQMsX5CiksCg39ljgopJ2gyhnNdoOx376FEFJgZ1P69S36zYosnaN8w7ppSU1B2w5AJO0WeK3RJ1cZgObiFCMielx8XTkZMMrw8MGjfOnWZ6k9lH4AWxB6zxcWn2fVV/zwI29CS02IgT70jNIxDN1+Ayj355YZhVWCbgi0LqCkoO0cIQRSI0gTC10FNv+2c4I9yDZmgosB0TzP8OM/QJsdsKnWeBdQxZhSSTIl9yytr31/Y+iUpveWLAvUtaDzA0oqjD4gdgM+CPLRiCwZEF2HK65Q3f4KPYbRwaMUWcbElvSxoxoqlt2SLMkwVuO6Cc52JL2ndY51DIwOSkrXkBUK50DrCHHE9qKjnO7IignjMKe9sePi9JSD+Qn1ZkMvWrJRwswWdFFTZyWTxTkz17JJDUvXcXA4JheC9rlz9DYyTBztBvS2xw4BaUeUs5S2q9GThOonfwr1zn+N+u0P0fzD62xVT6MGDpRgFzpsHJglltmlY3zb4pwjTxMSsWKzucOlK8cYPaX6wIdp6Oj/6U8wvO6NpMUxql7h7twm3K249NwziM99AfnMc4S+R7mAaHv6XY0YOkxw0A+EroO2Rbbtfr7V/cc7MegbN5i881fhnb9KlJL2Va/kcD5hNZ2wveqp3IDvE/JLJwzWsqy3HN33GPFHBOLf/Q7yV36D1dufYP6KB5HyADE6IZkZ0qJg20v6bUMWFdxtMMZjj3JkPsE3FazOeXA2pyey2O2IwTAeHTGZFZTZBd1iixcN1aohGx1w9dBhUrh1ccH61gWJgYs4Zd5l5OkM2SwIQqPLAtMumDWSTCjk+95N8q5/T/Z7v485O/02Jfi/Tpr1XxTx0iXiAw/gr10jXLtGCILoHcEaQj0QdxW9FbRKMIo9o2gIQ433Ht90xL5FIsBFolIYP9BeLAlJAY8/Tvpf/e/oX/Y4qyiYGE8WOsJgCMtTpgdjzt3AzTrSuRVHueNScUI7Gui8AHMdFybkeSQfcqyUuL5nqDZsNwNTM9DuLqg6T6YKhFL7XKs1Ig6IocIAMis4X9RcqSKjbEr98BWGN76M2VN36X79Xbg/+RT9rTvYn5ZM3vQE1aTk9M45p7fOMPWW8rOfw33pWeT995P9b/8x+yp4T+sCmoDqC1ofmeQdXiXEyhMKQbe4IO5ahsKQTQ5JD04YzfZF03q7oY4eE3ZMikukoaTuA7aYEEOHa3t0okEYGGoMgokecV6v0e054yxBJd+gre46jC2pfU+YTDBveAL/sQ+TPPU03WOPUJ9tadoN5dExzglWqy2HZYkpFb6PNKannBQI6WkOoLir2D3/LN13vYpkPEcDI2Pom5rY99jDI0LtQAnCFz9H9R/ehTldEqeHxJ94O+UrXs521xC0Zmg7ijBCFhVpjIS4ZvAt7aBI3YiiTFFlQRwCSaLYddD7QKITpN8ShWTsI5M8Z7nJeGQ2JvkzCtf/pcbfAuzvsIhCsagivTQc6IYkerQ+Ip8Jtme3GIYcGzsYGjKdsvWBJgQKpchHY7LNKUNVUaQnmNyijYLdXjX2axumRoAeekTfk147xlUVfVVRTiZcBKibLYVvgAg6BVsSqhqHIStzhmGg6Rq6CMpEnBjo84ShukNfj6jDCqELAiDagcPxCKsSooYs0wQR6YcG3A5MishmyGGFcA2gcNFxVBxx3/Q+bm9v809f/Y+5Or7M7fVTFOkEle7p2fQe7SWd7CiyEdm4p20r8rIjnU6oVhVH0xzpHM3pHTb9GucUiSrJMkfjPeJ0jUoMk5MZF/UFpckwFHTdlrGNZGFErDYU4xHeCBKv8UNHc3pG69YkWUZ5dMwQarptjVWCOm+wB3OGbUbX1RjbonV8sSI51C39sENkY2wPIbYkiSEIRb3Zct/0Og8ePcifnj/Fj5gfJNeKzcWK9TCg8pxEQJpnGKNYbjakSUk2PmZoFlhXY1WONAly6GjKEZkxmOWWZjwnJfDBZz7CrdVNfuDaaznOpmg0fbSc9xGTaK6N5/Q3a/z5OTafoJXF+wplxhgl6btA33jqWJPqyMnkgPMwcNg6srElLzP0tUs882yDGwyX0qt8cfksd9u7XL92ne3Zju1yjSbSB01upqRJhvM7xsVVmgTaZoOTO1Zdzns/9Wt84oWPkFrBL9z/U9w/f4w8yxiN7s3HKsWt7Ya2q7C7DamZceXSgyyaniJbsljdIBhH3nc0QeLDZSaTEj/K2fYD7vY5OxGYyIhanHItv8p9s4f41LOf4770pTx8+QG2RUZjBqbHc8aJRcgEHxo2ZkSRWaRQjGcnKB9obj2HHh8gvOO8XdH0gqM8o6VmXk4JbSCXmk3fYGKg6Xv+9PmPEoaOQ3GMqStGWuF9oKovgAGZCqr+eUTX04cOFSV9E+i2FWI0YHSCVhnaeS4Sy6LyjPNjRuUYc/OMYxtxsWfRp9xarZFCkE5Lagbm5YgH5o/wuVuf4XO3v8C14irPrZ7jgcOXUpqU46MT4nbNc0GCqKnrCh00gx/wKMwgGB+OaIeUftvSZY5VN3CYzbHSMMQeVw2MY0DkEl1Ocd0aMZsgWTMqDrDJhOVixWmzYzQqsGVJrOt9DhmNyAgsVy/Qe4dMjrjYXhAnAh0NE9ESDKz6QI0kSyd0Q0umYdn0HBvNaFQQxBbZrEhHJ1x051g1pnM18+KEYKfs4pp4eo5JM5SSHMwPGIRHa42xBROT3JtbSzDe01Y7stH4mzos+/uxwHdnDO0dLCnYOb7viWlA6ylS9gQavG/23ZhvCCEFejbFrzaYIMk97PqGmcvYVQO6b6DZog7m5OMpQ9OzGRqGJGPwDqvkN32flx5/F1+8/RmeXD7Hax5+AyDxzY6P3v1jtEp44vrrAOj8vnuWJBNw5+DaFwuyRkkKq2nrns55CqXYtY5ZIsiMQosIMXwTPfzPCm1npHbNql+xjYHSeybFDJvaP/c9xhg670mUJ8sUXeXplMY0LYpAMtKkucXtVgwhwauEdujI84TZvESofUddk5OohMpVVK4iZNDtWmhSJJJt5rGpZaYV3bolBo+ODcnBBD0aoQJsl2v8oEmyhPFszqbZcHZ2htIJo1mO9QIlUgo75tbQss4SZtst8uSAdVWx2Blm05Kij9TnZwynd9kmM67NJkRfImVCJhWkJd5VVAcZyRNvRL7nDxj+w3tY/51/gFKexK0o4k2sShlQyNWKddfiiCgj8f05bbXjtDtm6m7Tv+936FJJ8sbXMS4fQPscNS45r9e48Qn+iTfghCIXPY21dELiVpbNzXPakwJjBvLdBpWO8SEgf++3GH3lGUY/+3P4+x/l4nRFaQS3b97Grs648vGPIj/8QczHP/oXgnARAtmn/hQ+9accAbMrJ6ze9Hr617+W/mDEJAbkYsH56r3M1i1JXVF++vOUH30/5vo1RFBkdY0aWkRVM9tVHGy3qKaGrifc/wDh+96Mf+KNDK95NXo8Itv0JHpFFxx9NuNC5TgfuXo448ZmgUehuh66LbOr1+jqAbvdUeYHiKyib29xFiPz4gTBDJXM8be/SPiV3+bgfR8n/fBHEVX9Fz4Hf13hjub0V6+jHn4EdXiIv3REde0yzB5EPnQEpUaePIS1FmMMFzduEYdAce0Sm3VF89wpydUTlrnhqc2Cl9jAbJKQpAesbjxHdeNL9L5go0eciI7iV3+VdrPCvult+B/9KU5VpKkHsmT/LIdkzNBVpEVCiDmDGehl4CCZkQ5nLM7WxD4Q8ZQnB9TekumeJB1RTKYAeHuXlVgxhAFb5vRCk4SAjJFQrfeFvDCgpgfI6SXc+g5Z2xMGhdYVZZqzFp7Rd70M/vGc4XN/TP7Zp2h/9dcY/uiThLd8HzPRE3YV8WOfYPeFz2Fe8lLyX/h5ojEIoNeRXVczzQqGLcg0J7OB3u2ISlKfnxKrji61JHnJwWyGFoa+dQjhqFZnxLFgZBNEHDNKNYPv2XooUkvwCTG4fW7KZqBT/G7FaFB4BrYykEaHEWZf6AyOJJvQtBukGrj0tu9j/cefJLz/o7jHH2C1PUMCeTrl1mJDaAemJ1O8dpigGbxDqEipS7rdKcnEsr3o2dYOkTXYNCPGSL/boZRGmAT/+S/jPvp+3NltgoX0R3+U8NJXkhyMSfOMtm7oIyQqEoaIMjlBNUiZ0fY9QyOZYsjGBTJRxH5fmJVC0LlAYhKIG6R16E5xbBIWWO4sNkyyI4T4WxXxv43/FaJvW9abLZOjK2QjiXQtst2SJWOqIqdpGnSRIrvtPWVWQe33AFulKdN0Qu8GstEEm2oYWggO0gkAW+cZhoHDoaO3FpIUA3TbLWldkTGwHRpUkhDMXljJd1u61RlLbei7Cy52LT5CFw1jo9kNEqkNJJqs6el7SzZVpJnlTrtlaidEAWluUEZi24qmXuPzHJXt3TyVylG+xbseFxxGGv7rV/8CLjjG6ZjONUQGrNpXCWWqiUpgt4Z6V5OPSvLMsA5H1N1dRnnDapjQM5AJwfK5r3CxOaM4eAiZS6Jw+w3fZIQyiiBBW40OGq0CjVR41zEZFZwvFghAGEFcNrTrzd5z975jyiRBGUMcMtrTiuQQpKgZ4oQ0z+naFUPXYm2PUgneB7pqRxsHpJ1Qhg6vBJt+w0SM0VrR+Z63P/T9/E/n/4oP3fkUP/qSH6E5XTLstri+5+DKpX33ut/S9C3j0SHWJHS+YDQ0WK9RaETscM7hMo1dW9wgeXrxVX7vqT/gJJnylvtfS+wqQLEKmkYLDlLNZJpTLXPqsyWjR+fEkBLDFi93KFtC6wk+4qlQxnL//Ijnz9es6x2jw73gVJ5n3H/lCu7Jmzyu7ufL+gV+/9YH+GfX/2uyqWP7/BKMxqsC78DFinGmIT9iQsSKjJvtXX792d/k5sUzXM8m/OADb+ZIHJImCYSAdwNKG7qwYhWXGKYc1gHuO+CsaenrnkwoTjdbylKTKAdyhJElOomMqppbiy2ur5kfTsjNvmuKmvPE9bfwxdOv8hXzVd4wfwWL8+fo8jnicES92yDOzzCJYTQdUysJQjBLLNIPCK3ppeTW+fPUQVLqMdpcMISaa5P7YQWy94jVEicloTD8afUco2LOpauPMT8YvQiSQiVoGkfjBqTumZ88zCZs2Sxuk84mzCYTWilhWmK8RFY78maD6wcuJjNU8MyiJ/M70vkBohmz9A19ItEi4aKqUVheduUV/OYXf4NP3/g0z6iv0jrHq699L5cmIxI9Yr1ZkLc7fDFw884NZsU1kjwitwKpekKpcJuG5YWjKxWpzpiYFNpA2++wyqLVjiByXDtQhZZWCqbTIw7MFHF0TCwmNNsNfd/TnZ4hlERNJjAMSCkppWWLJ42RIi+IKZRqjqoDL0jNYTkmd4EdUDUXnNcrtFKk3oMx+GSK7St8s8K5HVJGpNSM8jkg6MuSU2W5ul4RLx+hpOLy/IQhRJYuYKUghECMkXw8YWhq+qYmyYtvyuEyBKiX+GGBnL4KomXgDioriD5izBhjFc5tAIFS3+wEa/IxvloRlafoNFVVszYF/WrD1HpiqjGjKdEFYtuQjTJkMqfr9s97mqaoe531lx69hF9Xmi+eP8lrHnyC6AO3ts/zzOYmr7n2BsbpeL/u+B4jzd5SS9n9umG/fl5Fqlk2PTZEmr5HChgnCikFMvQgJOg/Hyi/eG7pnJN2SXBLpNJo+xdLLllr6fueXiQYYxnZhiFKkJosCfQRutUaqQxqPKbvz0lmB+TSInwD6uvnoKRibMdkKmPLli6T5KGkSyLS9MxMjpGCQWuGtgLXokZzRHBMjo5QdqCrK4JPkGgm+ZxYrZCdoHCWqHaEKNBCknvFeZaSLG8yqq4jC8G6bbm7GUh8RzQKu00h6RGpRBmJCwNaGLI0Y7Fq6ao1N+9/kNGl+ym/8HlOHvwYzX0vxVqBa24wCI0TmqQ8wtoxu2HDLm7YDJGNF2xP7zL9+MfJ6zXnb307E3+FGA1+6HCuZh01Rb3irDhGlwlRSuqm4tRHwp1ImQqO5yWbxYqxbxhNr7BYrjE//mP4//F/onvXb8Mv/DNcWtJPLLJIiLtj2je8jtU//z/jliuufO4TZO/9PcJ/eDfq5o2/8G+tb93l8Fd/E371N//S+4jPfeEvfYl6+iuop7+C+Zf/khQI168Rv+fV+Ne8lPC2N3P4PfezE5IuRO64ijodSBoIJkU5Q73wNLuWojjhcFaw2G3ods9SJhv0zVPcu3+H9L0fIvv4HzL6a5xxD9biDw5hNkYeHSGPDxH3XYf77ydcOmJXWC6OB/rRI6TldS4XOaHtqLd3GdYd6fgyXeiQ9Rn59oLk5Bp9t7cVFKkmdB3p0NDkGXUXOTHQqZxn4gVmGEhJkAzE5BDhFAfzKcmv/CKuaQg/85OMXv29BAk+BjauwzjHZjxD9QMhDsjRERfrFcFGVNxxkE1RtqBq1/S9IM8OGQYDElI82ljEvdGS8WjK0EG7vksRHS7R9H6gLAxoTSznhGE/SdlsVtSbcy61jsG17LKSyfQ+zndfYllfkM2Pad7yRtIfegd86GM0n/4szf/8LzGzEaMr19Cf/mPEoy/B//zPsw4SsetIjWI1NAwMHDKiRpDKiFQZdXWHumlZ3zklySaoMmOWHJImGp1IhtbTNHfZtUuK+WVmOqOvWrQpmGSGi6qjFoaxFnhfQHcObYQsY1fVqPWGUdbSyjGL4QaTdIIJDtE3RDWmbz25rjHlBPGGJ+jf/17ERz9LfOz63l1i41hfbJkYg0oFzkORjcAG2qYhFx0FEndyhOglzXJNkmYvXvvQdZjViua3fx++9BSUCe4N34N8yxsQyRTdBBJpEUIwzjIWfY/TisF1GD9BpwU+Rrb1C5iQkkqFKnOElsTOg49YJWgbRykt9BCHhhAykj5wEjMuqkDbO7LkL19L/kuIvwXY30ERY2S5WqMEzGf7B0OlB9DVyGZJVoxphgV5B0I4RLchsyPawdOHgJWS6fwQ33XY4t6mbaj3GyZtqX1gNziKaospU851Ruf2VONOBoaz5ymOjrgjBLsQSIcGJQRqV+GRmKxEh0CqS7xKKJEcj/IX/VWjMPiLC2zMaQZJ5WvEYChsSloalJIwNCTdGkxCm0z42vZnLxBkkdS4sK96599AOeyGHQKJ0V//nTCKpMyoVhWudhijyFJN5w9R7TnaG4ZsjFJwqhytzLkaFaUMJM2A6RvkSBEHRbWtUQmUoxnDMBCloOk96SjFZDnRCLrlEvncAoqc9OCEshwhugZ0gqwdsixQFhSRrtkwKuckaUbX7HBZi5SWvna0/YqgE3JpaUTP8eiQLlRU/Y4sz2jpeXB0P1fHl/jDG5/kRx5/K8V0zDpLyLqapGkgSajqNVEYxnlJlILalDgCqqlIQkktNFmzprcGV4z4/Ff/hA/sPkfX7vjpl/4kQglElKwHSY/ASskks1ijaMY5w+ldlBvw2iIYARuibklsgm4dvR9Iy0NSrRhFyUZLdt4z8R6lFDYtmBQnPNxuecnBY/zp6ef47K2neSzPyazGpwUXQ2A6ykj6c5Qy9LokGZY8Xz3Nv/ryu9m4jjcevZ43HT+MK8ZUzQ7dXCD1gFORmARW9W2KbM68zRg4JTQX3G5ycqUoxopyfsI8yQm7p6j6JaksQWakmeV4OiEnozye0W83DM0xtgpkZsTLLr+MW6unuBlvkwuJc4YQ9D2mg2QyfogczVrtr50SgtjVKGsYRhl+6BjWEWsaau1JpCQNEtfsaNcVSedYHJb83o3foTORn7z6JsrNmkZDNhkRo9+DwCDoekFaWIQJyMZQ4xnlGkPGMPQ0oWdUjImmRJ1uiU1DfniE6Fq2/YYiU0g1wXrH4XxKLTqORiWybnl+XQM5J+P7+fzFU/v8M55yuZzQdwsWveA8AJs7DK3kdDPQqRUHocBtM5KDMZs2YT0oQqOY2oz5vCRuBxwDPoVJOSJs7kIyZ3F2TqUchZ1zmI2IqyXCRSZliheSNNVoP4BSKK2RUkIIEDKMHLGpetI8ZxCOVgiqYBDRUaSeSTZCE1HbFb7eMUeTpSk9HhcDo9Flmt1dQrvFhTXTw5e/mL9yoYjjMd1uiV+vUdMpUkiG6JGAlZLhnn+xsRYJdHWF0gZt7X4Mp9sS2y3ReRBjhqpChR4MSJPjWofUGmNGDEPEuTV7kP317q+yOcJokA1plmGrjurOOWZwJAcjhnqDNDmhcXjRorMca3OM8TRNQ13XWGtJkoRZNuPS+ApfWX8V13aIKPjo3T9ECs333ffEi+tO73sKcy8bmwya1TfRxFO999Pt+kA7eI5HCSH0WJvC0PyVwDUAOsFKSxAKl2iGYYHW428rMryY44XAGMMwQGpTVFuT59BuFIPzBN9ix2Ps7ITOdbi2ZjS5TGxqYrdF6Ozb5sKNMszzOdlJRlUFnK8ZiQFzj16vjaG5OEMqhRrNiKs1cRgoxjPgnOBbkjLBu4Gr0/sJztHVO4LvSZIxcejJBsfSJ9weWvoXvsr85S8jjStWlaEd2Psf2xErcZf1+W1YVRgrSIoJ/WrFsqq5sxUot+HwHW/C/tsbTH7ndxF/b8bmYMql0SH2+BI+ejrfYJMedi1iK5CUjK/P6b7yVcZf+gr+JVc5fM2rMT6BbYPRkfXugr6NlG3N9vyMwlymyVIyHSgv7tI1gZMr11BeoxLNgKXta4y1pGXO5offTvfLv41697sZ/ezfpfI1NtaI5oIm0xSjgkbMcD/844Sf+XtsNxv8f//fk37iY6jthuRLX/5Popj/54R84Qa8cIPsN97Fff+3/xfh6BD7lu+jf+K1rF/3OPHhh9k4A74kzQT1riGqhPHBBBlqjr/wGdpfeifTT3wC+5Wn/sqfG9OUeDAnHh4Tjo9woxnuYIw8GaOPr9Aoy4oa/eh30933EE4IXKg5TBVFeUgxKqHbELIZ1QvP0S6+SpdvKUYZ0zSlXS5JpiP6rSIWU7zsyWSCzQ5pdhVt/TTKpCTzAwwWFwdC35GUGYttTy3goeMRX9qcc2t1B5sJakZUAUZ5xcnmLu3ZguE1ryNcubzX1xg8TmpOCsEombP2sD6/i1OGxO7oQkXiLeM0JYqELLnEIM6w044QSpanFZODFERAJ/vcF0NECUkxzWl9jmwHVHXOtl2g77ufdHqM0AkK8Kd3WDzzWbTVFGrGcJCx0Sld36MdrH3HfD6iM4I2KCZv/wGal70U+bE/wn72T2lv3qa8esL4//DfIsuSwe/zWt05nl6dE7qWrDI4o4lhw92VZbs5Z3H2HEV6mfH8GD2Z4DEYse8QD8OS5ektnB5zfHCd1G1ouo6+S0kyzSjRXJz37FxF6QqQCWo6wktL3wiykUCpjqmHrW9ZDwPlMGCloQ4bTNuiRIfrwTzyMLv3/gHpH7yf5Lv+CcXRIaenLW5TcXgwweMRQaEzTZop6sVtGt+TzS5hQwPTBn8x4HpHV1WwXhP+w+8yfOlphNCo734V8sffxi4H6y1SStJxtmcgJHHPoKwb+kRh3ED0AZxi5zZ0VccojkmkBmmI/d5mN3QeLQVNOzAg0MIiQo8sx8TWc6JG5GQkWv3FD9R/QfG3APs7KOrths12x8PXDlBGgDBIOwKVQbMk62vqRNH1DtlLlKhJTI4SUPs9wDZ5jsnvgVDv9qqx2ZQ+BLbOk1Y7cilRh2PkuqPtezLVYpTDddAJSWoMUo/Qcm9z1Q2OIZ+wHSLSKvIko+oDk9TQB1AiogTIpESmG4rWU7eeRdVwKZ1QjBPkPXBNs0LaDKtHdCFSfMOzpFSOZEHvGrDfLNXf+wqj8m+jYxprkYWh7yK2BSs8QZe0tsN0Db6VDNqxTVKuP/oY8+D3nc8yxZSHCAGh7+naDbbSqH6FFwGqgappSQqFNhmb5YJk1aGTFO67QpaUUFVEJYk9SK1IL58wrG+hTaTvdpCW2Cyja3d0TYOIBUPvaF1FXswBh1KKcZpTD7DbrrGjhNSkNE3D99//Jv7tp/8XPvTVj/GWh97KcvCY0RjR1rjtiqrdYW2BNXbv+wh0dkThFyTVjiZahvaCj1bP8bGbf0yzvEsxmfPWK69nMhrhu5Y2aoJTqNSitaRI9ilB5AadZQzna/SVkuglxpYMYYOIkjhUDGXBOCvwLlC4njAZUQuFbRqsThjawMHV+4n18/xo/jBPL77Ib3zlPfyz6z/C/L4rnDaaZrHlqhYgekRyhGsjH3zm/bz/1seQyYy/f/ImDsw1sknJrJiysxeIqkLFyLI6xwbQ3mJaCbsWPZ3R9w1pNsLMxuzYMh5NaO+u8LUhpI7AmmRygNQpsvNYLel8y9BJdDoBs8VsPW9/5E38m09+iXc/9V5+9qF/xHYYGBpNCJJ6WDOmQ4SUmQOZ729k32xZ+w6sptRjQl+RULPcbJiGQN/eRlGixxly1/FrT/17Nm7BTz3+o/zAA29hcbGhXe+wrmdQnnbYYc0BaTFlV52zWt0lzy/BaEY/NFhyijSj6Qf6zOFlxI0nsK0o1kus29EYz7makq4H5kVO0iZEuaAXjqujAkfPboBHppd59vzLIDVPHL+WzuegDLsBXJYgzpfEoef65ZfRDnfxvaacHCFmI3ohOEwiUjusBF17YoBh5EiTDBVaQvSsqo7KVRSjI2b5DJlYvFwSuwYzKvdCKL3nsPwWgyDfA5CpCb3aMEiHj/BCu2MmFVe0oA09kchoPKZfVbT1GTJI8klJLQaGbkBkks6moBJke0bO3voQIQg+MisyBnp2dcNIa9Ron6e+Br6cc0gp9z9pytC1NMsFaWKR1ZI4dHip8VKipMWLCpkdIVSCEAbvGmy2PzdjJi+CbCEmSPl1iyuV5ISmwpYz8sazbXbMLl8F5fbziM4QwoBIIupel1YpRVEUdF33Yjc7yzIeP/wu3rd8jucXzzBPp3z6/Enumz7E9em1fW69d91eVETXezFFhgaSe4whKRinhturFqslud7bymqloO3BTP5qi5yyIBXSjDC22IufuTUxDihVflt+h693sYMpEXJNKQf6gyl1tSUahSimRB/Ybs5QyhBNSdNFhq5GihUkY77xqF/7txMGZz2zPkX5Hd539zzMBaGviOUBOklwShK7DmVHpEVJW9X4LiUSyAqDkAlCtwztiLQ8QqpIOgwMlWVRzLnz/FdYRBhPMmaTY5q+pFkPYDU2n7Orb5AZg8jHrMqUVefZugSRJ0xGBZPcs/upHyX9pX/Hwcc/zOKn/x7q5BIUkbYX1NuGUmmOL38XQz5w6+YdksGhPvYBnG8Yfvjv8OClR5HR0FUOZEdPShkcicxpq3OKVqNRKFtitoomLHDhMlYKDrPAXUYsm5qDYs6wc4T7Hsbfd4X0S3+M/Mp9LK7cR1kUiINDUuOJ0iNKg5GS5u4S8c5fpFWW7T//b5l+//fhnEC9/w/gt38H86EPoe+e/tXun7/GkGfnpL/+66S//uuMgTiZsPue72X7ujfSvf4NhJd/F0d/9HHs7/426nd+C3nnDuO/yoGFIL7hCbq3vQP5d38C/cCMpvFsNx1+XjL0kVInTHOFlgO+gcXnP042Kii0pvQNi67BTa6AMvReIJ2jPb1J8IL+6BDrNdPYoDZ3aHtFvV7StgPza1f3Y1y3z9ktF8gyIYgUti3KrkBZZN+RphZ0wvpiy3kHU6e4HFruRsvnto4jn1OWCWUScb/xG8isYPzTP023uEm129HVF/hsQjo9RJie1J2ywNHpHNcppJoxkpIiTeliT9d4lChIp1O2Pei2gU1DZyP55N4m0O8F97IEun4JSlMWJWsvWTWRcdKR5grRbmjaC3o8s2EC45Ikt2SdY1u1ZOmcRbMgFppMFmwuzrBk9CZl8vM/R3HrDdx593tZveX1CCtQ/RYfPC46dtQ0LCmVYrfdW+JleUG33tFcVIyTGQ889AheHrLYdmjpGaeSanNG1y2JIUXoGXmSIGWC8T191SG6CjP0pN1AFRzF0RhDClrQEZGJIDuwyGSMDZp5X7MJPVXXIUdzOj1mHGZ4t6QLKeooQ/zA2+HDv0/+1A3aK49Su45UQiYtzW5HHjXm4g5hfQe721HXnl33JHboyRY3iLeX+F4gjCQul4iuRz76OPbtP4x64DprtcPVNWVSkmUZAkHoA3EICGsplKSLgg7P4B2+Dmw3F6hKkwkFWkGA6APCKmKMZKVlp8BlmkSVUC/ACoIyiNZxkBcvjvX8TYi/BdjfQdEGSKxmOsqIwqPVPZCpNBSH6HZFsjulFwNJGCP6Aak25MmUnQ+EGL9JJIZ+B1LhVcJq8Ki2ofAOOZ1itcGIima1ZDq26OkJF90d2K05ObpOqlNCjPT1Dmc1a2MxXU2e5DQB+hhxAlbu69QogUTanNhu8DEjF5ajo8k3gWtMCtmMxHl2fk+3/NqmSqkULRMatwWOXzxuCG7vA2iP/szrlpqUVrSkvUHUjsREGlMS7BbhAnddD8mY60fH9MsVsmkgRFSRI6RkcC0yPaJwOaJ1WBnJzZqLsx3NaY/KI3EYKLM5IRdk4xE2CNpNi55NQAhkrtB5ytAWyKGjMxbfrlDpGJNphqZFhJbaVUgZGZdz7mzrfeISglxmdKJmG3Yc6AOMMbxk/igH+ZwPP/8xfuDht5BIQVQKVRY0F7dphx2Hl6/sr70QWCnooqDMJ3TbZ3nflz/Bnyw/hTOGJJ/y/fd/P2+7/FqSNGMhl+w2Wwo1J4+atdHkiSLR97p0UjK6fEB/ukJ1HcFYEpmhdMdgdvTGoZMxqZQMbY/wnvlozEoZqrqm3vSMxiVFOaE9uELcnPH6yQN84vwpvhCWvKI+YKdSLh1Mkf6Mvm2pisC/e/JXuHXzk1zKDviHr/5v8LefY6cD2eQyVjlMq2hdy8gXmFQTOsfWQ77z5JMZyf2XOLv9AmnfIAfBamgwDvzygmI+Z3JY0m9OcdVdpNOERtCkEBpJUk5JtOa2SxjXKVY5Xn3wGB8//TJfHW5yEqY0Q8/9Vx/j4uIF7pw+w6Wrj2Fdhq8G0ILV6pRoLWM74WzVkilBcD2mD6QypXYtZXEEbsev3PgP3N7e4M33v4nXH7yKttqRTEqaNsW5mur280ibkF5NCUoTo2UYKsZjj1Vz1sMNOtehbYGNimEY6AEHnFw6Zri4RX92l8MHHuC0gUqxp0rXA4dlSesaUpsz1zVVt+FlVx7io89/gsRavv/RN5GZnKPEcLZtEW0Fuaa0Aj21LO4a1sKwTgZGAjIl0FLRZoGh9eyGAZEEjAxMTU6o7rDuOjb9jnFakmVTrN2DLWEMsW1gVJJbzbLu7ylnf0P1zXcgFdHDOBtzIbYsuhYhINWSAkkLNK6htCXjwynx5oDTNWlZUvdLdK9ZVSs6OozOKcdXCb5F1gtiOqXznmmR0Q8tldGYqt7f39oyUpLoPa5pkDHihgGcQzvPsLxD63uy+QFidhlUj1ECmx7Q9xdE4RBRQZR7/+tvEHHRerK3sRrWGDNFyj3IVdmYvrpN7CpM6xlfypicTGlPnydGjQiCkAwIqb+p+y2EIE1TtNa0bUtVVTw2f5j3KcUXL55Ea4Uj8uYHnnjxPZ3vUEKhpf7aQfZ+1q59EWDD3hN7VhisVsQwoLXe08PhRf/rvzSEgPL43nqxLzJ4b3BuRwgDxkwQ4luF4+S+i+09MhtBfcGBqal9jR9fxZiU3W6FwlEWl1BK0UuFFymqrwmmIN7rxH+raPY0M1gp6dsab2uUSpC+JSC+XvCwltj39/5eJTbr6HE0K09bd6RFgrYeIQqG1mNzTZLnTIWgv/ww8eKMpt3SzUpEdYEZHHUd2HmD3O3wSlKNNG0UtKstQ+M4VApZWJo8UhcZ6tGc5K1vgA98AvuhD3P7Z36IXFQU6SHz/BKZLbAmx6U7suNLyA++H3PzWZavfhSfnxD8gJA9Qncsl+f0oeYghVqMMWFLalJ0MWJz65Su65GpxPkFiU4QA6SqoKlOqdo7yD5QTC3DD72B+M5z/Hs+Sv9PXo5MxxxODTQLLrYXFPNLJH3H7t/8Iu72HXY/8GaS736UQqe0qcb/8FtYvPkVCP0/kH/mK4jf+hXKP/pDzJe/vPdIzlMoSmJZ4rIMMS4Io5IBSY3EWk363AsMSYp7zXeTPX6N9PAYdXDf3uv9Ix+k+/3fw/7Rp5Drv9zaSqzXjN73Xkbve+9f7V7+hohZRv/WN1K/4wcI7/gxTPEQQmjKiUcMDb00bC+ewa4GyuklZqMpDIHgF6zjQDK/hOx2NLs1aXvB7PgatbAEIRjaBgZQfYO3KY1VHOtrmCiplzfZdYb6rGNychUZA95HzPEBUgpUv8TbhF1ioZJktkNsl5hpgeo8J3nPM6sFLwD3HRjOOeRssyTXDccnU8QnP4K/fQvzjp9GTMZQLwi7JY27QNWO2IwY5MCqT7H5jKNZSTV4GDzNdg3aM8ie2GwpbcrOD9QBDg4z+oslqJRmN2AShXYtNBuM7rCJordXMDIw7jsabWh3FWFzihSRVmqKk0dILhpivSGoAt0GgtGIdERKzybsKMhomwo/mSATAUNFfWWOfMvjbG1ktzrnsCjItSGVKQt65umIB/URg1VoKZEpfOGLT9LFhkdf/mqWMWJkTdSG3nl8V1Nvz/G9JjEFTiaETY+TAblbEPqOTmvS+YhRXrBdn3FeO6baE9eOZdMzKi1Yj1QpJCOETpnsztgMFWfdBh8N1/Ixy16z63rm0xnTt76J3ec+RfeRj9N84avY8zsUdYP0Edv3qCKlEz0IiDpDIvbrlhBkDDS+JYQCjg7QDz+CfvkrMa/4bpCSAce22lKaPbiW91hAwkhi7xFWkmUpSdtRS8FATwiRpmnI84w0GsykRE/usROGQGgGhJJYo+hdoLB2vx64FpmU+CEQWocszJ9ZaP0vMf4WYH8HRVmUHE2yfZdCpN+0cUIIyGZkMbDe3sb7HSIkCNWQmZQdlsYHiq/RK0IA1xJNwcJ5GHrGbYMqSqS1yG5L7tY0QdElByADtXKMe0lyb5MnnEP1A2Y8YrltmSWGwyzjouo5LFLKRBNixEfwMeKJhKRgSGryPjIZFyRZ+m3gGiCRkq0PdCGSqq8/TKkZUQ03GXyHuXf+3jf4GLH6W7pa9yJRCY1riLlB4xiqQJok7NjipGXhHCejAuUCRElyaQJtjV8uUdMpjWuw0pKMS4J1xN5TnuTUXrGp15TjMcZH4g5UoUmSBHd3sbfgSS1CCoRVCCkxxYx+cZNoJJ0byFyPtRmu3dG5Fuc3TJMMj2IIkXm6p0ZGFyiTko2q2PZbRskI5xxvvPo63vXUu/n4C3/Ia6+9kapzbI2lCy2idmTi649wIiXPbO7y3psf50+e/SDNestkdB9ve+TNvPyhJ1hvLoirFmMUqcq561ekvsXpgiAlo3Sf2IZ7quvZwQx3vqbfbtHTOcFFtB7jdE+vNbnOUAKaXYPSgizPqVvH1mtKORDEQIyG0eFl2sVdXpte5zPmWT6x/TSPHj9A4gKH4wzXwnnb8osf+3/TDGvedOWl/OTVN1NfrKncimKc0bRLslJjLFShZbs5Yzp5FCc1abNjZA325IAQIdoxtrnJ6vSCxE7YSst8XmJsjth0iN2wpy7ZiJgWBDxFOcKajO26pXeBo8M5w/p5XjF5nM8vbvOBZ9/Pz73k7xK9pJM5ly9d4/bpGXfvPsPR8YNYkbBZLnHbhvHhgzTrnv58QWYH1rJienSV4+llqvNbbDen/Nsnf4Vnmzu8dvpKXnvyBCIvEF0LTUXfRyoR0AdjUlnSnp0zAKPpFJdJqnrFpDjGSksdK6axQClFUJpOCFJfMzaOTWbpZMKwXpLIE8ajvU/sKnhOshyGDVsHCVtKZdHZo1yfXeOx+X0YnaElXNQtN0/PMKEhOzpks9sSbz/DUhxSmRFGOFIaDswEJQSj1BKlp/GBM5bokJA7GLZ3WbnIVKdkdrSn337NBzrNiJst0QWslhglqftvBdgDEQMh4lKF9wVGDqRioAWKGMlEQutbilhg8gybp3TSE0RESMEoG3F3fZcoBiY6wyQJwZbIrqPfnhFjQZoXpFoStGWrPH6zxSmFIjKEyFDXZHmGSFNI9nPlxdGU1gvC+BCTZdCfo1TxoqWM9zVCaILzCClR3+Dx+XUbqxXDsMKYGVIalElBgTu/S5KOGFLF4Hp8vUPaKVhFFD1K/tnK3VpriqKgbVtOkiOssHx+9SRt7JmkM1518vIXX9v7nuxbc6ves6bwbl/gBRKtsFqRaoHrPGmagqv39pLyP53Wp1SOEIbBren7BcaMXwS3X4s9TXxAmJIothT9BoxFTY4QweNCRVaOydN9QcAkFikSMr+F0EAy/XM/PyYC2aX4tiGqYW9TlpQvonGRJISmJXqPUAqtS8g29HWk3ba4oSVEh7UTfIhsznYI2SNVRJmM5L5Hme2WNAeH+xGCrWOUa/rdjvNNhZsFwrDExARNxmw+5+SwoKk8N6odizZyWMwxb3kN1Rc/g/38n9I99iDZ6x6j1AYhC4auIYjAMFSoocF88gP4kWL36sexiwV3k4LLxzO01fjEYDcZxXRGj0DIkthGdJnTr1PaoWZ2fUYvFrizNcgEXEoyROrgmI7H5ONDVqok/vg7cL/5bvIPvQ/xEz+JVJJaj4CaZH2X9p3/HhZn1G9/G+YVL0UZ8FEgqgWbUEE2ZqQT1kdHuHf8NOa/++eYV7yMSOTu3edY3XqB8eSYKnYcHswJvWL15JOYfMpqkjLcfZrkl3+LkYsUr3sL7r4JUo0JUdJ/12U2//RnSKoDkheeRvzhhxAf+xj6wx9G3bnzn3y/fi38bM7mB9+M/Zmfpvjxf4DNUly/ZL24w3L9FKOjI9JOU0XHum8ojy6R1oHYNPhRjlKGdZPS1UsuX7qPxZ0vE3a36b1hqnN6Y2gGxyixmOKI0NVs/Y6UAeMKloueepC4ekuoK6y5jyAk0pj9fmw0oV9V1Ju7NCrSuIKqchjlMInGqECqtsybNTddxDuLlpIj7+jUhl2cMv7QRwlJin7jq+i6M9rqLgkD2fE1yljgdvs5bMeMSZnhgGmimZQpK+HY1h2bIbJ1O+xUc1rv9vU7LSB2TPIRip5hsWFoW2y5t0HLDhPa2uIlqHpHSoqjBSHZOIszgZFK0XONO7vDcLcilEdMJjm1SdBxzMX2lCy7gsws525HEAHWW0ySMJld4aA8ZNtDyFJSkyNjoHYLxjJFRYPLFUUI7G7ewNqOycE1WjUi9A0jt6OwE/qkYSM8bm1QQoG2jESge/4OQ/QYMUApqV2GrwU6kZRKs+l7+jRHFZL+wuFFoFct+p4SOSaFpGTsZix7x+BOqSKIQRNUh00VWqZs3/aD9O/6d4jmJoIBOzukyyyYBHOUo2YTxPwEUZTIPCckllYI0jLnwp8SFwHlLPnxjFg5RKLBBZb1Ciklk2Ly4joNIKwkDh5cQKQpeV2zUoHTekGaZQglKYsMWUlk+Q1jP1oAYm/FaCS79p5dl7IvstNkqgiNY/8f/9mP53dE/C3A/g6KRAYK7QhCvCjm9W2vyQ+QvqNrK3Rd4b1G6x1pMqMOgYJ7D8OwV7JciQTvPNOqQlqLyhKoLyA4bD5hN1hqFwhyR15OSXaO2LaIPMfvdgit6IHBeSbTEa0LAOT3Nr9SCKQA87UnIivBN7iwt20Rof82cA2gpUAJ6EIg/QZKiNUjQNAN2xcBdu92SGEx6s+W7zdy7zc7hECSKXxQWC9pYsKy2yE1XEpzhqpFpQaZBVR2BNuednFOnwam+XzfTbdqLx5UD0zzEc12i28UmU1AbsjHc8K2JdQ9+mgMQyAmCmn252CzjCEpEX1Dq0fkQ40yGpNJFvUKHRYk+THrtkFpTXZvsx1dQBtNaUo2/QarLGma8t2XX8EfPPtBPvjsR3nLg29ECcOq2nE6RCb5CLmriDbhxvY2733mg/zRnc9hiTw8uswT13+Qy9nLKSY5SQjUaUpVRIw1rHaOYz3FtII7sSKnJNVyL4p2j1oqlCKZFnTbHUNaYlJNYjTaTHHCk0pBcJHQ9dgiIQSwfUBphc4tYej3onwyIRMaYTNee/w4H18/z9PVszyUJPhuw8dufpT33vk0rYefvPoaXjt/hNbXeFdTzA6RckTVpvR5zmx+iO80uzvPIYLBW4ndeUw+gUSxXG9ouw6tBhIfyUJK7Lf42NIOKSpJ0PM5ejpBKYsYNghhsXZEjJFN15IoSAsQdUnaN7x2+hjvX3+az+6e4g3HT7CpWkYjycmla5ye32G1O90LtrmaiZDgYP3CHWwM+Nzibca4mKNNhpCGX/nyO/ny4qt8z32v5R33/QgbDJ1UTIqS9uwu7bpCz0fMxhO8L/GiJXUO3bT7DawfuKi3aJGw8huatiaaFOk8mRRMujUiHyOTMaLc0dQddizREvIQ6a1mFxNEBNefEoUkVSmpTvlnb/rv6EPgbHCMh8jF+YrQt8wPU4rC0qw3DHXD+NKEQzKODgp290BMZktCAk0fEPTME0WWjFjsTrmzWTAfP0gRc5xSpPbrM7siyYANsesQOqNIFKt6oHN+P48Vwh5gR0MnItsYsUpzfzFn3a2oXEXiPKUtqaOjcQ25ySlO5vRLQetbpJBILenpSfqBzM73llUEKA7plmfIfoUpDc4YJniWecE2gg4Bk6V4ATpLSUYjpGug24K1yPQIOzj6piHKAQQvqoMrVeB9g5SWodvPX39rfA1kD8PyHsieAobY94QQsJP7kH7LbnOBagfMtADTg4vfpkL+rcfNsgytNQ/PHuUzd/4EqRTveOzHEffyde97Qgxfp4e/mKCTe92FBtTXx3XmxZ6u7YVAaw19v6eU/2eGlAZr5ji3ZhhWKFXsgezXvo7W+yJSCERb4tB4pZEx0nU7tBGk6ddp6kopnHN7oNxu9oJtf876IZRAZRluV+HFORqJsCPiPctIYfbvi12HyPN7RZMGk7VEn4IcUKREHxm6inZXE4KgmI7JrWabHqHvXKDOOlpjQPRomzIRkZW09J0gaDhzkfuKguPDESbZ2xHpU8+tUFMUGXiJ+TtvI33ne1Dv+RDmoftplSDPLF13Tr/riVIT3/0HmHaL+6l3IA4fZiZz3GKgTQXJWIM1THNNO1i0BSHHdNUSf+uMpu7JbeAoz1k2SzabF/DuCDF5hMMrh6y7C3ZdIB8ERicM3/NS/GefpPjUpwgvfyXDyx6j9QKNof+X/zPhfE3zwz9C9uY3crg64zSWbOsLYregLyeMvKW6uItJI8nsCKcKvI9oo5iVhwxmSVNVDKZhda6YbfeMFXF9Sja+TEgTmh/vSN/zYVb/6p0kP/cT+Iem+Mazs5pyfIRNLL16HPnKxzj9+Z9mkD3JjVvoD32Y4098Fv3RTyKefeavdJ+6Bx+ifcP3U3//W2n+N2/kImy4Pn+IIs8RQK5mICyiXODCktN6TTATUjVmVoxo3QBqwFUrtiqncYLSCXLtWViDlht0dkJ7foG6r2TRDoQgSIbAermjdncw3nMz9iidkUyP8f42STFBqYgeNkgzQSY5wib0bckgQU9HeyXnpyvEYDDBEf2WGKEYH6EWd3mm2nJZeVIdCUXP4rc+irl9A/nG1yAunsJnx4hBwdGjlBoKKbizXNM3CYkYqJOGMiuZmH2OK4uc0HQIlbDyLU9enKPThMeOD2iqBZ2s2V48g84lOikJw5ggCmK3RBcFJkA3CHIRkRc34fCYC5+zEwE2NeMcouv3gmvCQN+TlxlmUGx7WHZrEpviM8VmseakPGG62WCSHHP9AYQx2OWSxXbHQgiccLS+5VBMiCiEiLSrU1arc/Ljy4xmV0il53ByRNUuGNyWQ2s4q1K29YLMdRAaRoeHMM7pvAKRYK0iQRFbj7Uam+YI2dD7gPCR8UlOmgz060AzOJJxhyktIjj64pjEC9LtOauzF8imB5hUMYQBYw35y1/K7uFHcb6i3myYTA+p6yXzXJHYAjE5QKZfX3MUwDDQNA1ZyGjHNdmZpzpdk44mRBHZ7rbUouFkfLLP8d8QUULHQF9V+CTSDUsGL9i6gcNKkipDKgzCCKT55kKy0PcAdqbZ4uhcINXJfh2NcS9qWv7NEDf7WvwtwP5OCt/hYofQ6Z8r+gJ7Of5KSArliMsFYTOQzSyNKulCIBEChpotljbCpKnQSqIyDfU5CAX5AdYJ5KbhrF5xUGgOxkc0zSmurjFaE/uBkGe0XY+xFqMV286RmL167J8bNkdlPVj9Z4Lrr0UqJW0I3/Q7JRVa5fSuIsYDYnS40CNVghZ/9u0qhMAqS+87EgU6FfgBtCsR2w2XbYLtFJ132MQQGrenaVpLc3aTuOyRRxOC6l88ZvQRUUdKlbDb9GRzRZomCC8JVY0qDXJc4M9rSBQuREIMhAC9KWi2G9axByMZqi1OK5SSTITEMbCt7pKWM4ieGBWEiEgUqTb0oWfX75ilM/I04/Un38sf3Pogf3jjj3njfa+nbwdcDAzFCZ85e5qPf/6dfLW9ixCCxw4e4/svv4pXTa8Q7ZizG3fwdYtPNNM8505dc7dqGFYtM2fpBkNtInK3ZqsVuIj3Huk9vQw4mdFXG7qwwQ1QTFMa5+nrCK2n6npc1RJGU6p1hzaKaa6oI3txqd0Ov6uw5QShA69tBX+yeoFP3PgEj913iV/6wm/x5OppZpP7+ccv/Xu8XO/Bv9ssyJQmv/44rm0IS029cIxtyuTgErs7N7i48yxqfkA+SNxU0qzW7GpHnkhcSJg0PVLvkLJhmB7Q2Dmmi+RlSowdUo6xdt+1F0JQOU8fHHMV9yrpySG53vJ4cokvju/yyduf4nuufjepn7DcbTmaGuaTE9bNkqgTykWHX27Z6jVtmnB8NKemxvQGufNslqf88ud+kycXX+K1D76Bf/S9v0C92bI+33Kx1CSZRilNmmVsmoogLVJ7TDFiUArXtriqYugcTX1OanO0ULTtkrE9RA01o65CKgHFAe7sOVQMMD7EzkqGxYrOZBxPc1ItOW1bBt9j7TFCNMgQmCSWiy4w8o5sGCiHnqPjOXnh2FU9gxCko0NyFegiWGUoZclu2CGFJDc5QsEQO3KTYfCI6jYzW1AkB9zZbMnynPIb/aOVvac02kCxFznR0lF39wC274kx0njNxkIiBTOtEEIzYkTrW1Z+R+4a0qSgdjWZzpBqzyrpfU9qUtbdGmM1Ey/pgiKVCcFviULQmSmJ2ECzRESJDIqp1SxFSa4kSiuGtkV6h2yW+6q7zSEZgxBYbXF9T729oBgfvGgzIoTE2gNiFHi3enH++s/KYcZ8HWTLWiJUihgFJIFS5iwXL2BCRzkucW6FlMm30an/rDDG8Orrr+ZzZ59GCcMrD17GbrdDSkkbWgIBxbcc52s08aGF5Jv1ML7GcJHR74XQ/qr08L8khJAYM8O5Hd5XxDig9eTFa2mtpWkags4ZnCfqhL7vibEhS4tv6norpfZz26pAynq/icvnf+5ny8Qga43bnCHn11AmEvuIdw5tDMLuCx7c0zfReoRUO9ywxtiU6BV+qEkyyejgmOD2qsImlQzJDLEuyHdb7PF11uo2Yn1KUR5xoHqGVUMjRsi5YSNrbqxTrNFEN3DWbDnd1RzIlsIWJNfegP8hT/+//D7DL/02/T/8IZqyIjETXG8JN0+Rn/gk/YPX6R58NW6zY5iMsNpx6+lb5ONAbyUmm7CsPEPrEB10C0ei10gaJgcpQaSk+QNcbCTGaGbpCmOnTGXJzeqUXd2Sz3KWfkv88R+l/P/8C7rf/E3q+/85fd2Q/9KvEc5XNG95PfJNTzCPLXKUUnZwuqxI+0iGw4kWtMYYyMsp3gvaTUM22QNWbcaY7ZbMKW73dxmi4PrDj9FNc57enWOc4L7HX0rywGNs/9W/Zfcvf5nl3/kxslc8gXOCXOWIAurVirhqWMsWqw2jx18Ljz5O+1+tyO2jbD7zJOED7yP//B+iPv6H2Ce/DEAUAvc9r6b/gbdSv/VHqK89gpIae5iybW6QG0FVOWSsmZUpoR4IUXAwv4pyCbXMGESOkpEgKpyrsUVCFVuq3YI0JChl6bcXgCLkE8hyNrcu6G/cZlOU9Lsd7a6iq3fM7IbEFozGJxTHl+h2G+RkSTG7jtEluWVfFHMB0glrAjoG8ukRm805dl7gd5BkiuTgPmIyxi9bSt8RvERJDUmktILsj36ZbVFSP/YQ89t3SUtFb8Yko2OyYcFFuwHlONSXWYmIDgNpvcPLEqUNUmmCgyKR7JymY8M0nSKGnryumOQ5wSs6Y2mNwCUtMnYMVYUVBUli2e1WBBGI1cBmlLLqGhIboczY1C3J4pQgNGpygHYd/XbNrmpxsmfIUhrhuJxforn7AqPOo/MSkSQvFs3UdMosLllutnyVvahvZlJq7/DrNaHe0JUZSXnCbDzB1BViGCjNlK5f4i4i3Y3nCSFQRcH46IDiyglKS1wf8JUg0R3JuKBZ93gl0MpQyHpvERoE02mGNgMmGxFbQ7fpGbYdVnXsxikBwyS5RKrO6dwFdSVJVIJNLEVhUMDtZUOmEoauQlFTzK+DGhF7T1QC8Q1sMGMMIQTSIWUrtoRRits4OuXZLZYsNkvUWBOHyLpf46J78cdHDy4i+khKTpaMuewj52nA1R2jMkN0EZmkoL4FI2gJrUMCSu7tulK7t+vCdXuc8Dcs/hZgfwdFIBKVROniL3xdqlOqoaIvRyQe/OIORgb09AFqL0gYqJ2jsiVlW2OcQ6Ug+t03bQpNDPSxpnUDmZphjaXLMoamQQpBVJIeEEphpcaHPWuusH/Jps7kCLXb0wf/HHANYKWg8jB8g4gQQKJHDMOCEBpi9LgQMPrPFsB58T0qofMdPkSUgsGBH6UUm4ykDWAECIGKgRABFEILhnFK2mpis0PMJvvEK0AUBkRNqXL66OiFJFQ9QnuGtkOOi30nu9l3rCRfH+6LUhNVRl9XDLM5aRwIosckKZk7ohclXmxJbGQYLmBQCG8Rcs8DGJkRgx/Y9lvGdszrr38vH775UT7wzId5/bXvpW3X3O6e491P/gE3Vrex3vHaK6/k7S/7UUZmRF0vIRnvxeTGI9xiTahb0jQlzxVD75iZuBdT0zAfTxgXkVbsiA5m4yk2MXsbdFEgd8levMlHpBa4CEYLtBDUm5rgPdtdRCm3t+2poA+BcxEoN/VelC8dYaNjYgZePX2EP7x4kv/vZ3+JXTjjlfd9L+94xc+RB0+3OcOODhC7JS562k2PSAJ2FFidDlzc9UxGlrQ44OLOV7G7gXRyQsAzdJ7Me6g2+Bby6RFZIfaiILZkEIL1ZiAJGVK1hNC+2AEMMbJsWqyOWDkwdBlD0zG6cgVxq+X7y1fxazffx3uf+QB///GfZXdW0+425PNrMDjEINBAf3TCanqA6WrqdsPGb8lEQlSedz37u3xh9VVeNn2En3nkJzDRMJ7M2TU958s1p4yw5YhO9dx44Q7zeMDlk2RPSxWQ5RkxNVAF+tXzuPU5CEetFdqBalqGvkYcPUToHe16RWFTxMEhjAtCvaY/X2LnFhN2HBjLWlqqqOldwMqaUarom4okBpq6JslTTC453e0I6x35fErpMoa6RqSRpktIsxTrLctuyeAHdKpRw/5ZXTUrdN9zfXoZEyOnSuC05nzw5CpSKIkUApFkxKbdF7aUoEg062bYfy/fUfeRlYDMqHvgen/8TGfM0hm32zXL+pxZNqN1LZ3vsNIyhAERBUTY9BtmKmdWSCqR0veBvUZXS0CSjg/B7RDtgtA67HzO3Cj0vc/yzQ7lKsiyPVj7FmBpckPbelwXsN803aMIfvi2+etvja8BzG51g76q0bNDfLMiDC1JOib1UOeSXb8hEe6bOrx/Wbz0+CWU2QHffemVXJpfwnuPc466rTHCvAi41T3qvlIKpTMYlntPnHvd3xAC3nuyLNtvioTYC5f9NYbWJVIahmFDPywweoyUey/fruvw3tObMcMwoENLkiiM+eYiwNdojT4EZDLa091d9+cWA/YsAkHvHIOXCBmRWuGHAW0M0lp8VSHvaYZIaTB2RFffpdlGjEmwaYpJ95oa3BOVd30gSzTd4QnJsy9QGoVizFo9iyumXJ6PySZTfFVx6eqcRbfEywphE3ZthZtptMjYtYL2aAJFgXrVq3E37qA++Vnshz5C99bXYe1VsiIQPvhvcIkm/el/RJMYRlqzXl9w//yAszZysbjgqrG00wKEwQqFMAJxUBJxKJmjZ4dUdYdmIJqC9OCEVLe43XOIdE4eI+t6x/h4SteCmJVkP/KDuN/4barf/C30rVvI5RntD/8o4XtfwXxYI0UEaUjFml5HzFLTdz3F/YfEzQbhHOnVSwy3L/DdQFsN+KolNpE41Ex0Sp0EnJZUCYgoGOqaYejITk6wMRD/8f+e9l/9C9S7fptGC/LH38jQtgjToEvP2TmELGNqUkJUlGZE7C5woqF96AH6o5+i/Ym3kmmwi1vYO3dZzCf0kxmTOqccHWCzMXVmqXLHMAguFVOEtKx3Fe22JvcSkVm0aJExkhXXid1AnucQBDrZ4GKgT3MKuaI9u01X9bS+p5GgkgyraoqxwdQrwihDjHK0D4xKjfUbstaQTOYYk1G5u6STA0ym8K3HmSnaZNBuqJbP4/BMbIEdIix2SBvRk4y20uhLE2oX6XRgnFtskyMmBjVJse97P6kQDD/2fbhHXkGoqv3ztw3M+o4lkRBaDooxZxcNyWzK8TxlqCuazQaTpoRgUNaybWqCC0xGcBh3VIuWwhjs7AoxaGy3B4Fd0uD0js71rPoVfl3Tr1asRUnY9tTxBZLjKamWpAbW9TmbtsdkFrfbEoUjPHWLJCs4efgBZD9iUZ9Rbi/2RYqsIJkc4zdbtF4hk2QvVjkaofu77FbnjJMZdfDUbUVWrVlnChcsV50irzuadU1984I0y/cgumsoyoTRySVeWK64dDgmyfa5UhtF6zO67Y606LGFYWg9Ik2QRjPB0g2SNNvr3hg7RmUpLjd0Fyt2q55F1TMqBGaaUiT309VnNKtnuVg+zfjoVchEI1xP1/VMRELXrMiuHCCLfTExREdLtXQuAADDvElEQVRo3H6N1V9niiZJQulLVusVTQnHxRxVFrSnF4gc8jKnjjVDGO4J6AqstGQiQ9v/H3t/9mxbup71gb+vH+1sVrObbE4nHTUgCUl0FkYCAS6wCYqm6DEmKLmiKqIqKqLu6qr+hbpzXRq7ShHGJRuDJQssDELCSAIVICMEQug0qTy5u9XNZvRfUxdjrrX32nvtnZkHHcFJnyciLzJzzrnmHM03vvd9nvd5NKQAkyBpRWq2KBcZFOTWQpcQZfbKfl3oeZecfMRpSTcFyLN5xMj33yiwv4GvLaKEZGukfL3sD0AKidOONnTkJ2+TfCJs3icTX2a/+Cxd2LPDkIVI1mxRJiJkDvntTeEUO0IaqUyJD3LeZBQF036P9YHR6HkzoSzCR3ofcFqiP8zlTwjIFvPGLHu976YVYo66iRHzwgyfUY5h0vgwy9yj0Fj55kv1WuLoASMj+yBIBN555yGERDQCHRTSBUTK0NbSTi2iNFSrU9juiPstar1GKI0AZGnRo6FoRvrtQJQSlSaUkegyR3YBsXRIIdGZQWuJFPNmrdeJp+ePcSqwLJeM3WMSASks7QQmX7HIlog04oc9Ie1IfkClDClzFnbB5XBJH3uOVit+673v5WfOfo6/+gt/lX/2wS+wCQOrYs0PftP381uOvpvlKFmHDJl27LVj0g4LZIsVm6Yj7rf4Muc4y5j8BiEMSMtIZFllPFjmXLWXXE1XTGakMPNGMdkcua4Q24ZmGhmCI1jFotCYTKHwqDLHreYoChDElFhNnrPzLT4J7GpNc3nG1LUoV/Lbqs/zj578Mtv+gh/81O/kD3z7n+BZO+I3T3FSYMYrkpEoe0K/2zC1Ey7zuKJmO06UXlMt7tE9+oC0G4jLgOpH/BAQTtEFx+rBKUXtEBdfIDeO5ArKfuAKz/kYOLGGELqbAnvnA+PYc2RH4qDo9iOuslTHK9TQ8amd4nOLd/nFJ7/ED37qEXV1ym77FfTYkC+PSH4iTSWTrJHGsMgXbLpnTPuW3Cr+5uO/w//v/J/xzUef4c9/+x9Cl5IYE8InjvIFY78nFw4nJFp4HlQ5CyFYxR5tFDFOpOiBBIUEfYzaXDFddcjLlmnaYM2CpDOiEbTPvgT9QHb/LVivGKaJIS9Ju464/TWSXGLtMYV/Rj9d8qjZ8d7ZEz6zXNEByxjYDRNuteDq6ilqv6e2ilQdcXXV0Q97jG3Z7SZKFgghGPzAZthQmxqjDL3vkYMnNwZXHjGcNdTOURY5XZqTD9oQKZWkcA72DWnyCGXIjGI/eNrR4/3AZhIUlWLtXi1QK1OxLu5zfvmvKPotVltaP0dVDWGgFOUNw36k5vs1s9XMhsbImDqEKLFagl4gQoLde7B7hq1PIUVSe0XorjDVEsqTeY17CSkNZOWCOCamvsdkzzcM4WAuo+6QiN/6jHFCjhZKiMqDNaRmABFxVqCX92jGC6IyOPfRmePCFPzfv///Rm7yGxd0FGQpY2mXyCQJIRBCuIkiE0Kg+hHNFlWuUGo20hPX8vBuNxfXXwNDGikd1h4xTbNkXOsKpYr5nB6K7HmURWBMcWMO9/z98/MshDCfh9HOLPbr2PYY0SIyuYKxaSGfZ/SDPxwLa2HfwDTBYbzBuiVabzBuQVYukS/NoWeloW8mZB/w2ZpJvI86f0RxdEw8fYezi8css5y3373H5WXEOE0+GJ5tn6Kj5WHxkPVxzoV/n6aP5MahjCTUK7o/8P30H/wai1/4BcLnPkv7HQ+pfukXSY+/jPn+H6D89m+ha8/5dH3MF7/ylNYHdKnp24hInnFziZItywf3SVlOt9fE0COMxo+aft+Q6S3lcklyEl18mtQ8wQ9XZLFj2++5HE+JUSFDh/wdvx3/cz/P8DM/i7Aa/4f/INMP/AArBWb7Pgw7Rl2y312xdDXhSJD2PVMfkNOALGtkbpG5geDpNy3d0y2SPWad42XJogefZeT5kg/aDWromLTgPEiO+gnzYE3xf/2/0P6//p9k/+1fhz/p6L79N1EsKlJe0KmJKuRkJudqGLm3qOhHw7a7ZBstqzqxICNdPmWQgvC9vxvVd8Qv/TIhO0YffRNaWqrK8EEc8EqwT5a3FxXOOC6ebbgaR2qXaK62mGxO2FBKobVm7D1tUrSDRCuDEg8YU4uQ5/iw4kgLshJUHlEIpq+cU3aCVq1YOsXytMCf5SRv2I0TV0/PSWnkpP4UQnZ4MTANPbqq8VLRNltKkbByIJ49wbZbpqOCVX1Ce5k4e9yQFhYrekRmYC9I2rAQkuEf/gzDeon5zm+lKmqugkKljqQS3eYSWUZOTM425gTRcSIFWijMYsnU97TbHV0bCJkj+ESlE15GkCM9JVlZg7b4ODF1PdNuIFpBmhqSMphpz9Rdsmtg6DtckXNsAm8/fIBAMXzwJfbbHedCIJeJ9QQKh073cVJj28RpkXN+3vN4HKnWRwSrENYgtSL1PUFrpn72VnjSN6irK0TT8mW3wbV7Qq1okmYdM/TQMnQeXVpSEdCVwdY1+8vIIl+TlMEaTRchHGJKAVyd0zWSftuSHa3xY2Tq5zQeJT0LVxNCf1iz5nVFO4VeCbbeEpuEThPRKKISuPIeJ0Lx/tm/4Nn5v+Rk9Vk27Q7TtUgniFVBvXpuECwyRYqJ2HpkqW85dBd5QdmXNGPDthgZt3vacYeoFdZYrLYs5AIrLeqltS2aQBoCotR477EWzpWn7aGWCmleJeGEFKAk+Ii1s8/KFCJG27n5+QnENwrsf4egVIlSi4/koJfrnN73jHHEnj7Eh0C2fUTL+2x0hjYl5eWjOUe3OoFsdSsPdAwjjW+oXYlKOYMPpKTnSBTn6GMg6Ywiy2jGRIyQRGKRvZ6BuQWTz/+8AdfO131MvMjFaKlBOmKckEISkRj55r8rxfyaKbTgJ7zMKVLElfMn73a7WRqTetRBStiHHqcc2ljSek24uroxPhPGIJUgVhlVHKhSQh0vSX2HrBdIM8ufRKFJbUCkdEs2b/McawvarmFVVGhVwdASpaaPkSwr0FICGQhJyhOokRB6QmiR0pIrTTM1WGf5gc/8Ln7u6T/iZ9/7h0gBf+hb/zf8gc/9XgpT4EPk4nLH2aOvsF5myOO3GWLCSnBGwWJFvBgIlxcU775D8nuidLRANIbSGWbSxbLO10xxYjNsWLjFPLtaVZimQcWJp1cjq1M3O+/uB4b9QPXwiLyazd5gnvOR3Z7BQDhacVTmuFyw/colZVmiCslf/k1/jKlr+Mzx5/BC4ceWtYZiccS0eYI+fUBmS1IY6SJM45ajheNsbwm5o17V6P5bCcETSscWSVjUxNjgbMliWc77fiEgBfIsIw2BQnua0XM5aVaqJaVARLLtelza47KM5umEdJr6eIWUiuzoBNdt+IGT7+aXL7/Aj/3rH+eHvvv/xL4t6LeXlA/XKJ0YvWcjIU07BgdJCo7feptfePRL/MyTf8w72X3+5P0fBJkRxITOAlJmWA2rcSBst0yNR9ueozLS+552/5gsLTBulsBKqRHCYsyaSZdk6RFx39FsG+SyJrMF3T5w/uVfxQETD5B+omk2fPDsiiE2yO1E2myQ9ZaoJgSRt7KSXx08k6k4lgLRT+g6o8wEbrOhyBfo9QkuO6EfWvLWURSRdoo4VWGt5Sg7YjNsGMM4N52CRsYGl2eIZBnHK9xigVaKGiiVZB8iTYi0UVOISNa1yMMsbWk1j/cddmgodM2quJspFUJwXJ7QNI94tPs13jn5TeymHUMY5nxnSq6GK07dCTp6yEqMMYQQ6LqWZmpZ1C80AosFFGvS0CHUOaRI8AGyJao8urOgjNGT0oTLV3gZGLoWqfVNQR28R5k3r2Fpmub87SzHLE4Zp0smuUFgCMMOoRJlsSb6c7oYsVNLYe42ObsL9UtS7+vzZJW9yZuGORf7uoANo2VotySeO7sqpeYJ7jC+Ih//9YQQCmPWhLDH+x0xTmhd3zDZWkeMMTcxZS/jemYbmL9new5jO6u4XsbUAgm9PKE7v8KaHJUZ/DCQYkQYg5CCOI6oQ4EthGR58pk3/gZXzOd/d5bo8wr95D30vXtU1QP2V5cMYUtPTZc6kkiISnLcHDHuRho34SbJQ6v4VeVIAZYekrPYPHLxx/8o+od/hPJv/k12yzXt3/wxBleT/Z7/iMvLLZMPLPKMoq6Y/Ei+Lnko1gifo2SGHDum/RkilSQM7a4lX1ZoO2FUz+WzSzJVENOOiyHOIxWNJmx7VHvB+x8opF1QqonHTWT8gd+LfPrfcPVbvovtd34n98YBkzsQivHqKVdBolefZlWdcJYNlEbRPHqKKTJcXeGnEVXnxGdbmFra5orF2xW6Lpl2PZUwbCRMMWKjY6EcFynwa7un1PWKUg+wysj/4z9F/M//S8Jf+29QR2+zMxXRjthVTblTeC8QKc6mdTLj0flXKM2Co3KBPloShGT/wSPi00u0cOj6bXypEX4LtiCoGhtH3s5LugBP+4HSJ0rjuCIi6JBKMghHnDzSWK7akctNz5X3VAgWUiJTT55JxpPPEK9aqiFiJ8mYQagKsiLggqImYCsJsUUHSfHw00x+4tnUMxjHzltyFZG6xw8dMS/YTQ1CLyiKEtk/IXzwFbJqzX59RFCOyY70zURpJUJ2aCnJC8UkHepv/wSZb3j2+/8YWp1QT3smW/J0P5Dokf6MZaPpq1P60bMuDY6ONNg53tM6kg40cYueenIG+qljWVq8kOxDg+9hMHNRFQnE3YirHHaMZEkiRUlYPuRorfjCxQXCB3T7iKuz97Glo718AlrzYFkxVUfYXnDveIlNhrHrGTcb7DZxrCreKwIn6yUyTFilUes1YbeHZiZwfJjYtTtsylgrxVfOnrHJHFVeU6Mw1YpQlEgp0ascORVMfcfYtQigWi55dn7J23VNIwVX/cBxWRzWCEG2qOi2DWO3wOWavplAKISZRxJjHBBCPx/3SYlu3zAoy+mnaoooGHcj05MWW1nyes3i6LN0zRnnF19g/7Qni4opK7DH7tZeWQiBLDSxmQ5FtrnZpwkhWJQLJj9HWGoUZV6wXp5SZ29e14WRpGE2O1N5jhtHjvKSy6stxljsa0g4oQVpiJhsdgEZfMTobF6XXzDU/KTgk/Vrvs4hhER+SCF5DSMNRhq6qcNlK9TRPUIYyfsdXaFYbJ4iUkSefgrc7Q1IiGE20pKWPCvZD7Oj3+AjmdHouibGiHMOrTVTPzCGQGn1zPL8OsJJSe8DISXUYQOnpUZKTUiRCAhpnkfIvOmzlGM7NXRhwpkS5+dNIsybRq0VIYTZsTZM+OipDjE0QkrUajUX2VdXqOUSlEJqQzpIfjhs1mSRE7sASiK1IppEGiO8QI5IqciLiotNy9jvscUJXHyBfrxgUmsWbt6kpYPuXhmD0A6lKmLsCaHDMtH5HRexY7W8x5/47B/hrPsy3/np7+HTp990c0y0kpwuHVc7xcUuEl0HdUGt51l55xyxXpEuHjNtd8R9SxQF7eSxdU5mZ3OzGCOLckEkshk3XPaXrNwK6RxYx9QO+N6Qe0cbE83FHmUkxXF1s2gDhP2e2A+s1isuhGIfIot6SZflDENPsVzwblaAPyJ3R5xNnlIljsol0zSRrCJbPkRFD91IWa9p2pE0Nqgo2Wwiq7cs7jNvA4kkJZdnG9rtJdYG7t17a252TP3NZlpMDc44Yhnx3cTYOzYuolXLPmWM3RVrHek3EZRmsVrdMFLCGKrqmBNv+K7lN/FPL3+FL139Mg/Kdxl2H6C2VxgxcrbpafWOk+OaVEmsVPyTr/wv/NR7/4BPH32G//03/WnkrkG6gqHbMPZfwWUrpElQ7JjShBEWbQQ6LEmiRIREaAXWFegX5MUiSuTQkuTA8uG7DH1gcIpqtWK73eK9RVYdj/sPCGcdfTfw7OoRRlrS8m2cD5jtgF0tkGaa5a7dQN90rPOCrS5ZlDknwxOEUOjVEpMdoZRhVI4sdxgpyeQOxhGTzWvMUXbEftqTQoIESvQot8B3AwhuzSBLIVhoNRfaXrCXmqbdU1UlhVZ4keimHtt7FsflLYnby5BC8qB+ly+d/RIX3QW5zdmNOyKR/bhHScWxzmBqZodsIMsy+sHRdluOFxMwH18hBMIVpLmKBG0JOptTFdTd4zExdiDUzLzmc0E9NHvyxdwsCN6/dv4aIMVI2GwQWiMXc5PVmjXeb5nkFjGKuUGqJAU5iuyGlc++SpOx3vc3xfWLuGaotdagj0jNOcEZAjPLbe2BcUgJ1K/P/PXrMH+XGiEM3m9JacKYDOccSjVImb32mXk9hw2AtrMEcdzPjd8Xf3NKMDZgcpQtSeqCNA4oOV/T3k8Y627FdX2c72+0oNSKC+lwQ082jUyDZlGdMomB/bilDz1H5ogiLwhtT9PtebRvMNOWxWpJ0Ucukmc5BuLUUJRrhuMl6o//KfQP/xXWf+U/ZxoDF3/4TxOsY0hbjsqCvDTct2u+8vQD4r7loau4jI7kJA8/983IvsfvdigVUEcLdKaxmUaFSJOVpEFiK8skAnWeg34LEx1SB0Y8faFIYaRB8PA7vx37Pf8PfvWqgcmj/Uh7viG+/y/Zjw16fUqxPGJKgrwqieMA3QZ5ckqcZo+DvCiRRUO43GOPC2S5JIaEIKGzjFzBk6srzKRYqhVlZnnKBY/iFXLbsyiO0J/7DvIf+j/T/Gf/GeMP/xfs/9Jfon7301SFI/OeTTtR1Iq23XPVnOHbS45OTwnumHHsGK2iyY/wbT+Pu7gV50YwjgnXXrIfLujU7AYdR8m2b7gMAh/SnGKy2eKqOQs5xIAKAiETQ0ycLjIeKIXUMO4u8C6jM0cU6wI7doSzc5qmI3vbsXj704RHj9BkeDPgLx+Ru1Mo78P5e2Rmz2r1GULw7NpImAbUsGHs9owisJhKYt6RUobIcrLTt2l15Kzbo4RldZQxXO2Z4o68WGDvLWnee4r/uZ8i+/RbVL/1B9iGeYxtKTp2xYKx35GrQNcl+u4phS6oTo4RYSSNnuQ0TTdx1QXqkzULkzj/tT3j9ilZ9TYbo8ktJJ2Rk2GTQqREiANq9Og0EvMlg1ohtCNZwT2bMHtPRsQ/2RPKPVouyEqFrtcIndEUlp00HCHJFgbRBHw/UVQrUnPOdpxwMjKOPUW9nB0npERIydWwZ9dqTpcPifsB2SaOHqxQx44TXXG8qFFS4XcDvp/jOAfvSd5TLZb4lJgmz+nRCh0jm2GgyjPcgdCSNiNzLf04zYaKRjINEiEHUorEON7yXBr2DftuQq/WLAuLFAJdaKbdyLgfZ0WfzYjulP1mS+gDNruPLxWL6xGVl9YgWZjZH6CdkMXzIttpR17k1KpmHHq80Dd74jeua/KQnz3GWdHT9RQehgQ7bXAicddTafZaCYgIVktGf3j/Ia6L15g7f73ik5Po/b9C5DpnjCM+emRRIOpTcjKOhwERQT34LOKl4jql2bhAIFi4BeYwAwlzgQ2zmYwxswQxpcQwBVKE0v3692Pc4UYf4vMZZi31HIGlSsRhk/NRCmyrLG2U9HFiZQRSPnfFno2sDgWyNHShu2FvriGkRK3XoDX+6gr8NDM1Us6xAdOIzHOIQIhIe12Azfm2yd82bKuKAmRO03cHtmdBFyU6NOS+eeE94sYQQgiBUjnWHmHMEcvshOBb9uNX+PZ77/BtR59Hy2yeK71GSohhy/r+KavjNWGz4+yqZThklGdGMWUlqqgYnz0mjpFJWcaYyA+mUuM43jj1GmVYHWJtLodLvBJ45xjjRE3At55hPxG6nuq0nnPOD4hddzCBKzFZRqUkbYhMMVFUK0TweA86yzBVyTAGJh9YmwRC47srTH2CUuZm8y5jwGYlrspYlJp2t+Pico80GmkMg0/gNVJ6rNWkmEgpzWYvOps9B8YGESJFWVLkFtMNTEFxNjRsux0q7GHSxKCpTpYoJUmHa1IYg9aWoljy79//HnRM/Pi//lvYzBFMQRgamvMzWp+oVjX5egFK8guP/jn/06/+JPfKU37oe/4imReYwmCXGSbXhHRJ3z2j3+5Q5CzqU7RZELFky6M5H1oa0hDYP3rGtO/n62XqoD1DyZxUrJGZZlUsiXnGr10+5tnTDxhlQq8fUixPWC0dD49XvPPWN/HNn/0e3n34Lbz9+d/M0b0HFGi0NAiZuF8U6DgxakfpHA9TjxgaVF0hbY5SjnC4XnVdkIJAu4LQXt4whUIISl0ivEAR0DIg7YJhv0cdHK1fhhKCpdEc1xUmTmx6z7PR08TEqYkoLwnmw+//LFtyPz9h0z5lChMxRaYw0fqW0/wU4ftZIvyCkkfZEhBMw+7WZwmt55Sm6hTy9dwAfE1xnVKcxw1kdmOYl5UVMUaGtiEGf5i/vvs3pJQIm838muXyZoMkhMKaU5JReL9HuYIYO6TMWLglmc7YjluG8PHldT7OhjXuwwpk7RBSodOEc46iKOZzeMgl/41iHJTKMObapGw2LlRKvpa9nt+jbth4AGw9m7KNze0XTi2kCLZCCEUyGsQEY0SqeQ4b5riuNHnSS8acb0JKCcZIlSdMltGVa7pH7xO9J1+cUuicSmjWbk1pSugjMlOoZY2NiTB0eBQrI9lPAzv2MCnCdEQcArv778Lv/L3zJvwz38LJ7/o+Hi4MmZN4ZXk2BYKckwfCVYNVhuxoSZMi0+TRiwX29JQscywcVEZig0cEz8k7DynrHBNzfFJELdDGYdb3sat7lNOIi5qLSTOkS/rUcRUS9xclx3WFx2DO36cNPeGtz2OyNdsPvoRvG3LSrCqzimKZI5Sm3XREgKpkdI7ytEAITZgkGkksCoTJ2T49Y2pairLkndMj3lq8gwqeD/ozzqcGLzX289+G/xN/DL89p/6R/45pOxFTImaSXTcwXmx47/G/4oPzFqGO2YuCTe/p2h1dUJj1gvLhPaq6ZJEX1CcLcJbs+BQle05Sw9IqjuuK4xR5q7AsCkNdjOR1jnQFRglO6pzjypKUoLSa+6VDGknaXxK8Z8yPGSfPKq/ITu4x5oaw26OaPXJZzvGNQTJtLhnPHpEmhX96QX/xBHV5TjYEyqFhHQfcpGiaHe89/oDUS7Q2iCJD1ivU6dtIHZm8Yjt1lFaRl4oUe6b9iDQZxVGF/vt/k9T1yD/4x7hXFDhj6OyKTAaOdGBdamL9LtvqHqmZSE/eI3bnCBXBNzTbnrOrnjw3nFQOZzNMZcmspu8jdSp5kJ9SDY7USHRUc2RjJZHxnCASgz5G2ow+kyQpuF+XWCdRy5Lc95gpR0tNAmxVURU196ocfORst2XcN7iH9yk/9ZAsBe4XOX6ceLaf2FxtiT7M+2Xn6KbIF588Je4TYjew9ROn3/5ZPn2sOI4wSkWys89IUZcUOqOqKo5OTiiriqKuadsOJcHlGcvMYYCLbiAcYv5QDqUl1vh5jE0JEJppiITQAvHGoHFoJ6amxWeaRZkjhSDGRIoJmWlEbRjHSPt4YvflBtFkVNlDdJWjqjkN5C4IORfZJIidn9cluJF/RxUZp4HcFR85g1rYed8rpJ7VPU3Lwhgyq9n4iH9hT3/zHiVBHNzEtWIKB0+kF+K6Pkn4BoP9dQx3mCfsfEdta9RyQRg7oh9RDx4g3Ks323bcEmJgna0PBeZ8EyghbsnEr+Fjoh0DpdO3c2l/nSCFwAjBECPFC4Walhqf4sxmC4kUH94LEkIxzoEpKPw843NgsLXWpDQy25HN86KleXVzJoS4YbL9boPQJcI6UteSBKiimKUxhw4ezF05pCCN4RbLprQmL0ua/ch6bPAh0mXH84zN1EL0pFgiXjBtunVspMHZFWvh2PRPQQVcWZGbnLZtbyJ4GLbzBjFbUuYSReILmx0fGM3DOsfpeR4xLk/hcUNC0SNQRlNmZpaCXhsXvXD819mazTAz2YMCZxUZnpjS3B3OBLZ+LreM40jY7pBFjiznY1soSRsjWx9YZBXWqFlyGx1JKiYhcFKQK8HY70Ep9MGgAynngsgPSGNJcmR5fMx+SJw9uyI3kNclF5cdPvYs1wVLt5hjhLwnDx0yW4ApSEMLwx5ZHlEvS6YhIIfAaEaG9opFFEhVYssCVztSO0GIIGcnamE0pbIcrx7wPetv459sfoV/9uyf8G3lNyEYSEIj8wWr1YKJif/lyT/nx//V3+JB+YD/w/f+eVwKDN0j5CqHYLBuhdIKpWpEckwHKWoMVwz7BikriJGtjxw5xXjVMry3J1MgmRBZjqhW+LBHtGfIeMrC5DgJJteorOTorXcI+ZKue492aMnLY4zWDMNEXleo03vEzQbRXULmWa9OGdQFTmsWEuL+DJFZZJahDp1lP0WEFJiiwJ/3KF0i0p6pucLVc9Rd388zZVZORCFIOPx0RXn0ehdnAGMLlnZLlTyt1FgpcSlwrh1dTHyolZZUrPJj9t1TtuOWXOU0vuFYHbNUOYyXr3hCTBGW1RLvW4ZhuJlrFloT+/5mI3LD3N6BGHvgdmSWVApXFAxNQwzhMH99N9MadzvSNKFXK8RLRbzWBTZf46fdnBeeAlrP8r2FXRyi5bYs3fLVqK03YAzjjXHNh8JkM7vAC8fOj79u7uEfFVJqjDlGiB3O7dG6RL6h8SoPjZSbmUilZ0XLuAdTzOvLDXudgVTEENA6R5pxlvcK/bzAPpz/NAyIN6gRXkQaA8l70tixOllyqQPNv/4ViuMHmPURDBUp7iEp4uARIaFqS3exYxUV8sERbeyxfSC2DU9Szad0CUPA2pwYBuo/+UeZ3rlP9843IUMiMbIymnVW0PjAdt9z0Y0YIehchlOJoijZtD1aK5xziONjYjOPV41X54R9S25XiKll2m1JInG+7TjN1sjCss9POL/cIK7OCIu3adUVzXjFwo7UyjJ0DZunz2jHC/SnP8/9o88xtC1q/wwjBsaLiabdI4zFbC+oH77DtkvsLxq0lcTYk5VrfC8QQUMHsdRs+0TadqgHNfW6RIlEMW5w9hifLbnYP2ba/BpjcLSf/xz2d/8g1U//DJv/4v8N/8l/Qqcm+uGC/W6PWSwoTcm9pad0niJuEUVOFzSuLCEIwuNz1KokKyyb6ZLJRXJ7n3raoGIHFDRaIiS8ZSJJSHZ2ReMl2zFglKSXEENkqRVaSxiu8H1PdDVNmkmGzDn6vsccvUU5tPirp0z1MbooGX/+Z0lvGWRmSbYEa/GpoLRLdJ2BLdBKzaZkl57+/IqoFly5nMpmFFYhnGF3+RjIKZ1Gi8TQDCjtccaSgsN/+V9gfvVf0H/mW+nf/Ty1kjywmi9HS29r8nHHlRcIt+S4MiAr/KN/zfDoS4TVMUNQbPxDzKrk3npuNg59D1PD8b23GIcMMSRMbXASegF1ZUj7FuQW3w9M7hjjLIMVTDGx0opMSUarGC93GC3Y9XtU8Cze/RTFcklqAylGltsdVzKyqRccFQUaEJuWY98zVoZn/cCm7SguZ/POvuvZNnt2ccROCSUn1g8fslxbpFCUlwO7vmPnF0gpya0iTYE0RYx1mKOZgGqHgcq5G+XPyhqu/MTGG46MvtnHGDxRF/ghYKyhbUCPDVJJpLT0zcjUB3wcCCpDdYEmHnKhAQRopbD3C7K1pfnyDtVHFqsVUx0xRr/xGTAX2ZrYeFLnIZ89low0tFOLTILcffSRI6FmRVWa0tx87HqEtqyd5kLApfccG31D4N28z0jSFHHl/DwcwyGuq9/O6/HXwNPj3xa+wWB/HUMIcTOLHVNEKIU6OkEd30dmrxbX7dQyhIHa1jeMsJQCJQXieq8Rbnfnhyky+Mgi+9r1YjIpGK9ZxwO01Pjo8dG/Np7rZWx8INMWJyClmZGNMRJjPBTYHiln8yXgtdLK6yJbOkvYbuciSytkfpiX9hHxkpO6MIrk0w3reY0yLxhlxjiO+BCZpKKsjqA4nk2rdmeQ3sxA5SYntytSUVAu16yq2XCo6zrGbj/Pr7h6/p5CkB2tOS00ab/jqh3ZDR4jBd4Y5PIeoVwxjBMuc+RmNi6SUt7MYF5DCsnKrZgwbESPNqCix+BReIxVqGzeZKdpIlxdIZ1F1c/nd4QQLLViSonBzEyFFQElLVrnqKpATz0iRsLQYhcnt82CrgtsDCkFIHLv/hE6L9hc7nn8/jMuz84J0zliGEj9QJpGmvNHXD57yn7f0zV7+j7Sb88Zmi1+HLBGQh9RbYftB/L8GG1LXGGR1w0T//xcCmMQk6danvLbHn43eRT8nS/+XZIS9AHa3mOy2YToF5/8c/76v/gb1Nbxn373HydXEd9uEViy+gHOnWLtEmOW83VqHcViSblaU5/UVOv7GFuzPj7CljVmsWT11j1cMYEZ0etTVHE8s8RhMUeKjVsskqPyCCsVrrREpfB+g5ILkjhBmZHMecZhxE9hlo4tl+isJmw3KD9hhYRph9qfk0xCljlCGNSB6QxTRBmJ0HqOLpoCKqvx7RUxBNq2JYRAlmUw7RBmzp8XUmA+rCjRFqE1ahxZakUhgHGiWJT0IRLu6Ii/DGEy7pnZOyCkmbk8yo6Qvp8Z1xeKwhATU4jUZYW1mmHonht8aT1vbA7Np/QGBnv2TMheicwyLkNbR/T+tex1bFti16Pq+qaAu/V7hEKpDLd+C+nmWK4X46gWdoGRhs2wYQrThx6fawxhuFMefid0PjO//sAwBA/Rf83l4XdhnhVfkGXHGPN6A03gxswtvsg428PaNB4UC1M3/7bDf48xImWGcoYoRoQXxBCIIdw02j6qTDzFRBoicWiRRlOuV+jTYwaV8GeXxJhQtkQGjZ82xH5EOMUowfctmdBU9SlBRs66x9g+0bcGWWqKdUZdLJAkuv0V6ru+E7+o0ELQ993cfI+Jso/kfuCoBFHVnEfFk6YlLwsCiqbrD2NTAlWVqOWSkGvsW+/gTk/J791HVzll4dg3De9/8IwPLi5479kllztYNDs+2zxmOSnKqKlCwl88Q7ZP8ekpz6xAZY5m94gQ9+RHS4wcUOM59aqGe6f43Y5+v0WIif3VJburDTZTpKDQRpNniiQMZzvPvh84rnIkPSIFaM9xQuCLE5blQ7KUc/nkfZ5cXmIwZL//P4Lf9t2U7/0rjv7Gf41NW5ZHgsXRQ+6V77DIc3Kt0aEjhZYxGaRSaG0J+4GYEiJ36EkihORyuMRoiyiWCLNCdi0i7Bj7DiM7cldykhcc5YYgBV/e9QxTZCEUWknE1EAcCDpjjIreB2o3Z8t77ymrmsXbnwcp6HfvMfz0TxP/p59E/tjfJivfhtIxugFVr3DrtxBpmtdiIeh8hzQ596uaggGXGfaD59l+4HKALllWaqJyhv3Q4PcDSYxkxwuE7+j++o+jnMH8vv+AoYsMPlAbzYnRXKSMYCsaURLHkSKBLSpW3/od6PIezaR4drHDn32RxXRFPJgD9t0WFSey7AQlNLrOMcuccuFIUjD0LXF3xjSBNwXSZIzCs+067NDht1dcPX5E9/RXefrkAx5ddEzjgC4rqnv3EUIS+5FwcYEkcXr/GJNlXE6B3RRgsaTOS7Kuo7KKJo/4ODL0PZGAryVNP1BOgfXDe5SLkihGClshqpojrXD7HZtxoiXeSJyv96qtD8TRU+TP95LWGAoSQ4jsDyrCa4bWOolSEj9FpDQMnWfsBJdPGnbnA9FPNMOEFgYlBcYpXKnJF5Zy6cgqg801UifKhUWdWvTCEXL/kRqsQklkoUk+kvr5u1llISRylSP1xyPRpFUQIsJYSCCMRWrFkZkVYJdTuLWvhwMhlRIiJbQUDFOclYbwiTM7+0aB/XWOTGUk0k3RKKydZcwvYQwj+2lPoYtXCkujJKSZTR5ekjnv+gktxddEHn4NJ2f7/vGlAjukwBSnjyQP70NkjIkjk4NUTGGYs1oPbrJzsT0hhKHzHVbZN7Lit4rsyw0pRGRRkMaZjbpmr29ebyTwqky8tAblHLto6KJGGjfL4rUFezwXFdN2zgtPry8gFnZxY+RmtZ3Za6UYNk8ZQgL7nI0XSlEcrcllohxbhinQToF28uSnR8SqIoRAUeYIEtM0vZad8wmUrjgtlowm0IUG3/akfkRX83WWQng+P7pcvvIZVkoyKWiRJF0QfU+ZGYqiwJNw08jQbhDaYqrj228+XKvysEmOccBqyWJdEkzJlBz5yrFY16yqE0yWkRcFdeGQNqefpnm+XDoSEPsNYRoReEQEvGWxmAtapSXGHWT/Wt46l8JaUojk0rE8fsBvu/dd7PdX/OyTnyckGKeJ3EX++ZOf5//7i/8VmRT80G/5s5xUDzHmCDOV2HyFemFkQ6kCiAcGdDbKgkBeV6QoUEmijcaPHTa11Otj1OIeoijIThbkR0uK5THOrdAIXDSoJIhpRDrFFNvZ10GsEHKJcwvyPBLClrbp5t8lBHp1jMpK0vYMEy2q3RHiM7wdiHE6fE8IIZJimlkYQGYZaZzQ+RI/TezOHhFjJM9zjIQYOoSpGdoWVxQ3jOKbIFx+yHFNcy52ShTVbFjXjP5D349yOKk50tWcf60yalMdYkBur4vPRygyrLVIGej7fi7IDgVxOjhrz6Mbr24+YhxIKdxir1+EKwqk1ug77q84joTdHlkWd67Z15DSkdJIjMMrCRNCCJZuiZaazbhhih9eZMcUmeL00RlvbefmhJ+vGa4l6b/BDPaLmDPAP7w5oJR6LhGf3wi2em6qMzbz7zhI3UMIh7iyjGTG+ZxP6QUW2330AnsIhLYFAqquUVKio4DTY3S/o7tsiSKhxAL6yJR2YCS7XUMaJ5LI6C4abIgUy5rqRKMsbNoRlECQENuB9sljCIFxtydOHXHwmFERm4lEorUT7xSGdVayUAopBF0M7JXirPc0bXuzCZ66PTEEXLUmKM3gMpp6wVVeMh4f0a9LvF2QXMWnT094+/Qep3jyZsvF+Tk0EasXyHpJtqxYrj9P15dImVOWC4S2TOPE1D4lzyfC0tCZid14ResCV3HDk/aK3miiT5i8mJumJmfbTcjUc3z/PtZ7mmdfBAQ2WzF0PdvNjio7QRnHKs+473LWhSb+Bz+I/tx9+IV/TPPTP89qfY/F4oi28Sxdjp88jB1jivgQMS5nuOjpNx0jgr6HbjMyDbDZNIybkXYz0u4sbSzp957x6Rfpr3Z0PmNsPG5MnEiJ9hF5bQaVRhh2iKwmSEM7BrQUZFIyjiNZlmGMwS5WuOpTpMeP8D//00SjEc82pP/6p0hxpO0e44rlHD8XRvAjIQb2457CLincipQaSidmmfZBilsvjsiNxHlP0+zwXYvMwS0t6td+GfHFD5Df8V1kn/4cqfd043zf3HeGXBmepZI8K1hpRbNrSSRMVTItT+gHKJbvcO+0QLQbug9+lebZV9ifvY+OGcgcs8gJaWIaetLYk/bnXLz/JS7POza7niE0XDUb3vvie4xPHzOdP6PdbgjdFVoJ7NEp+cl97r/zKdxyRRCCuG8Imy1IjT49RjvHkVFYKXjaTQQpKNbHJJ8wV1c07ZYnzSVCR2yd8aX9Ofpyz7v3TsmPThhig1UagwGlcCcnLEi4Zs92CrSaebRvmvcGbdvhhEC/QGgZYzBC4GJgHyJjPBSQKSHihCv0vC9FEX1i7CQpQXXkUEXC1Jrj4yVZabCZRht1y0A3TJ5h01FVFerIIFcCJK+Vh78MoSUy16QpEAePU44MR2byWb7+MSCMPDDOGnV0PCuwlEAJwcoofEpsfbj9JiWAg0zcKIYQ5ufLdVzXJwjfKLC/zqGkwilHd735uQM++htTs8q+aiJglcTHhFWCfnp+M6SU2A+eKtMfeS7jq4GWAiVencOGeTP4YQV2SoldCDgpqI1DScsQRlIa58XOXLOfCZ8iIQUK/eFSGCEEar1EWocsclCKNEWEka8aScg5ZzCNtxcTKQRZntOjGZTFOIs9FBopAsUKUazmhaU5m6PNXvNdjrIjlm558++5ClijGURG13W3OoWZdbBYIPzEIk1YJblqJy47T9cNGAF5OTPrLzoIv3xcNz6gheBetmBZHjPKgd3+ghgCpsyfz4/CrfnRl7E4dEZbW83mNmHCJwixR8ae2Afs8t6rb5QKlEWEASEMMc6b20VhwSjIFdlCUpcrsqLEZjnWZeTOsHrwDuVyRVIaoRzFyUOK3FJUJYvTY+qjY45P3qFenM4jmPnz60yow1x9eD6HDcA0sS6O+ZZ3fhNHuuBnvvT32PlnSHa8P36Z/88v/rc4XfIXv+cv8dmT7zhkFStCNyDy2w/AazYyHOLo5hEGgTEZ2krGbsQNG8ZmMxswLe7jFkv8ODB2HcJIZGGwR8cINxF9TwwjSfQkOSJMgTFrYoAgIHc11q7RLrHfPSUEf3Mt2dU9sIKFD6zdErM6QkhBSiPeb/F+x9TPRmXqejQiy0BAGib6ZPH9jiKbjRHjuAOR8NGSxglbfDTp2TzWEuYCo+9BaaSzlFbTj+HDWWxtQUhqaahtzcIu0HHOoOYlx+1hilg1MwpSGqyd56e7rpubaEqSDgy2UnePcYTQIYR+JSbq5vdISbFYYl4a10nez/J8a1DVm41d5s+eN3R3FfLXRbYUks2wwcc3NyKuZ7Y/dP76RehsNg2E53nSXwdSvusC+xaLYst5XekuZib+BSf0mcGeC2xkBBMRUTAdimppzcxMf0iRnUIkNj34HlVVCGuJIWCDRz54l2QCaXfF2AdSSChREUVge3XG9oPzA0sqUWrPYr3g7dPPoZwi2Z6rcWJ6eoG/usLYHC8zqHJEkTNNV8RnO2SbEFbRu0iKPWuVgSsZup63ypJq8qwRdJPk1y47njzbMOwGNmfntElzkQRnk2cfIjbPqITgYdJUZaKLnkw61mWJWJxg7t3nwb37+FyxdYJkJ/a+Ic+PWZbH7CdJpxb0smIzWC7CivPiXUZdMaoFW7dm7ANZvqAyGUe5Y9gLrsZIe9kythNpVaJyiZwiKjPUJrC9uqCNhr5p5hzsPGdx/BZZfoKWHfv9B8TtE3qh6P/kn6R/cEL5Uz/D8he/QLKSIARZUqhxYPQwBgky4PeBsQ9YFylParJM4QqNXWrqqgA3YrTGGoesC0y9JssiMQxI385+LYATkvvO0u8nNmd7xs0Zo9d4cqYw0vl4U1xba2+a3EIIzPEp8id/EeF71F/+Y/A7fivigwuG//JHSF2LccVhrEHDuGc37hBCUJkKKxdIA0O/QUnBMjfcW2TkmZ2v/a4l9ANjbJAmImVE/OzPo60mfd/vAWuxEdp2woeIEIIHUhI6z9BHQlIMrWeaBq7agc6tyKylEon8ZEl+fB+bHzHsHxMfPyKMiTH1qMyQYqTf7+kvH8P2KZfnE82k0LonaU2bZyyrJW/fe8DJu5/i9OE96kWJO36b03ffJVsdIaTFVBXts2dMlztEnqFXS6TVN54LmZ8Y2paLds+2n6AoscJQxIFJBnqt+aDdsfu1x3yqXnP0qXfYDi1KBmpbP2+0OYdarahjINvv2MVEKxJpDPiYGIaePDOIF5rHUkq01rgUMUKw8YEo1aFJOau5slKjdIbUBpfnLI4z8mqOlbQmm0mvO9eVxHDVgRLU6xVSyBuzy48zIiSMQjg9G455qFQ1K/e+Cgg774vTFOfG3+G5YKWk1oouJpoXimwhxOwm7hNWzc2F0cf5mfIJm8P+RoH9CUChC0IKjHdcnCkltuP2xtTsLlw7gwshnl/sQDcFxhCpP2o0178BnJQML0j5XpSFf1iBvTsYJSwOs8xO54zBE+NszJNlGSnNhesQIkrMRl4fBUIJZFmh6npeQFJ6RR5+81qjIKbZGfwFlNYSpWKSivwFqWjys+QIW0BxyNZtz1814Tng1ix6mGDY46o1eVnjvadt2xs5pJYCnTmmokD1HccmUVnNeTMwDSMutzgtmaYJY8ydxUMTIj4llofjWlQrVvUp3nd0tKjMEa6uSN7PxfVrJLTzdxeUWjKajCEm4tgwxIjwPaLbI3SBLl5lv+cfMy+8UlhiHEkp4bQkyw1JT2RG3Y4r8ocCSefkeU6WZYz9QJcEUcg5DxcwThGmyNh7tJWoFx8wej4e1+fyWh4axo5MQmbhd77zbQztFT/55Z9hR+KHf+UnUDLnL37PX+RTq0/fZEemtp8dtctXO8xS5qTkifGaoTQHB+kI7RlyHPBuyWRqEAJjHbaYY0KmYS54lKmRzhDFDj/tiGmHyiqMWUMSRJ9IQmDUXDjU9T1imNjvHx9Yc2ZZ7KLGVBq9dAitsPaIPP8UShWEONB3F8S0IYS5mSOEIBpDc3WJKRZY55AH6W0ct6ByfO/RWqE+4swqyiGUIA3dHJN1eF9uFAhoPwqLrR06hufGUVN3MDd7fn3GmBhDxB2aBTNL7MmybDYnG4bZ6GyabuWavoiUAjEONwz/R8W1YzhSzmkFHwIhLCAOrO3dj+zrcQ6B4Gq4IsRw5+sABj9g5ZsVPK/A5HNHcOrnTdDH2Mz928T1ebvFYgsxs9gxHNjr58+C6wJbyjleKuoJbQx+/1whNsd1vVkpEDpPaBtkYZGHyJ6x67BKUSyPmaoS3ZyBEvR9YAiKGEqa3TnKDqzvl+iiQ8scrRYYbVjbJdmw5WL7hD0BVS/Ij09JZDRnVyAtJI2eIv7yijgF9ts9btvhpgzdw9hMaC9xHoph5C1rMEKxGyfebxrOu55AjmkDiylyKgRH1rJwGfSBfUhMzvNwnZGSou0gCUVmM5au4Kw958vdjg05m5hz7iOyyDgfA7vBk/YNWiRWq1PuFSWfEiPHqxMWLawGw+niPqtqxSpzhNHw9NEFg1QMeOrS4oRgPHuCcgVdG2m3G1xVsV6twTj2U8DlJ5xmJVFMPJ46zhX0WUb8C38KV9cMP/LXGH71C2SVgb7DRkHvJZOfz9u0HzCixWQKXeaIyJwUoiOnixOm1EIEWxukluR2pHr4LixPsKonEzuyXJFVhvVRTlEqYtihjGGSNftty8VmYOojsptQSs8jNS9Afuk9eP8p4lu+BXG6wv3+H0T/nt8NX/wi9sf+AX6zIQ6BZAq6YcPoW2pbIwJIobHVgqm7ummi3lyXKic0Aed7vNqiJPCLX4JnZ5h/73vRR/dI4kC6NBP7fqLbj8gh8enMYYTgbO/ZjoLHlx0ffHAFo0BnNcZGYhsgdUhdQ8jI62OKpSF1Z4y7q7nR2W9IXYfQK3R9Qn68oj5eEk4ecvTgPg+P1hiVoUhM+wv6qLDlkuVqiS4cw5SQw4Tve4K1RG0ZxpF27Njv97RtS9MN1EpxWhZMxpEtjqnv3Wdpc0R7SdcPXLz3BSqheOezn2FMiXZqWLgCq2bvnmtDTmEMerWiioG82bMT0I6BphsRk6e4YxzzOgayPoxebny4GXcDkEqSlQ5r1uSlQxvFGAIhDOT27mdliolp3zP6EbfIUUphlSWm+PGapdfXmFNzcdz72W/mqy2wr9WcISL07X1koSSlkuxCpH9xX6wlhIiRAiEOajLt5oP1hmfX1xu+UWB/AmDUHGN1F4t9bWp2zXDcBSUFUswXuhSC/tBt2nUeqyTu1zma6y44KQgJpmvnZiFu3MTfVGBPMdGGSKXkTcyXU44I+BfcdWOcSEiGOJDrj7jZZ2amSenAWswmZi9GUt2CFrND4nS7wHZSoqsaXdY30Q1zjFF6boqmNBTHM8vWb6G9uIkFuxP9Zu5e2wpjDHmeE2O8mYEFyKTE5zkyz4i7HSe5JDMKHSbyIsf72U3yLnm4j4kmREolMde5iUqR5RXr9RFp5dhfPiWN001u+IehVAqXleywhH5LPw6o8QohJbo4fv0bD/IqGROQSGlm3atMYK2n0MXta3vq5wLgcKyNNuRZTiDSBkUYW/AD2sobtsG+5DEghAAlwUdinGYGlx39/hF9f4VLBevFZ/hU+Vn+2Qf/kh/+4v/AlDx/8bf8WR7W92898GLbIew8s/wylJo38iG0xDjOG/thh+gucIVDuGMi9tbohs1yTJYxNA1+nIsd7RYk3zE0zzAuwxYPEEIQfMTH+cGnD/Ivlxfk+SldN9APZ8Q4HiICHeSSqMPzWVSVo3WFUUdIUaOtwvst43hG257TxQklBHWek2yFHxoYG6JvSKog9D0uz9/YfLkFKWcWe2ohxhujRikFhdV0YyB+KIudQfQYIVApzQXhS/Lwa68Jd1BWzEVsQoiAc45xHJnSLON+3fz1rDyQSPnxYrLidgsxzk2pjyKbFwJjlgc1xOtxXWQDXA1XxPTq+pFS+njy8GsoM683w27eBP1blId/HFyPCMWX11JbzGzeC03na7+O63OtZEZKA6p0MEV8Pz9PhLWk6fVMS5oicbtH6IQ6RK7FGGbvhyynNIZpdULod7g0YBYOk2vyIgehcbUncDk7UZuaOEyE/R69bzlKFl0bHjuFOipxpUG4gua8w3/wCDm2FOsMMexo33uPoXlGKSKiyNCZIpUGUWjykxpRacpasVqV1IVjoUYeLC1v3TthWVgcgtQH4m4idrBpJ1QSaOOpS0NeOaZxop8ccey4t7iPtg7pFqyFxknLvSLjm1YlD51B7xsWKVDmGcuqwhVrimlEjSNDTISpxa2r2bFfZxyXmvVSc+Usj842yN0ePW1otx1kD6iOj0lhRBuLkwIJXA0el+VUy7e5/+A300nDefsMH3rS6adwf+6PM8VI/K/+KnV7SZwaJCXTmOh3Cb9pMKnBFAZ9dDQ35UJkkANKKBZmgRgCQwxEIYhdg9URUx2TTMmk67n53Ty7KaZyvyeQsCf3KFcZWkc6nRAiIvpEGiXtdmTsPGGKc1Pvb/0EFBXqD/xe5JSQRQ3/4Q+Svuvb0O+f43/0R/HNlqkVNG2LmyaccvNYkxBk9TGIxNBe3bo2+7bH43B2JKgdhIzwd/8B0irc7/9+bJGjIiQp8LuRi2ctKSayylDXlvu15bg0+FzSVxnSCoZdS5AZSRu60bB/fM7+/cd02x5z+hncydsU9YJMTZi4RyIR1UMWD97m3v010Sr2CaTJWRuFygxMnvHiMf0UsdURWTabpmUqMQ09zW6gC5Ynz7ZsLrcMB0WJc46yLDFZSVkWPKhLVs7ihaWRkuLoBGKPfvoVhrHj5MHbLJZLLrs9WkHtqpt90YuJF8Ja1GpFGTzF2LEXiWbbkglxp9+RMWb2f/CehVYMMdEIPRePh6aHNopiYW8UYc3YoUhkdxTYKSZiOzEOI6q0uIP3zfU6/tUU2MDsTH5NsL2GNf8wXEd2ve4zaq1wcmbyb/b3h7957SY+XDPY9f1bjfCvd3yjwP6EINc5QxhuyQPvMjV7HaySTCHhjGSYIv0UGEKgsAr9uoLy1xFWzMHz4wsboeus7zdh6wNKcMuB3CoLQtP750xwSiNDCAjEx8uNPfz2NAaIr2ev4SB9OTgkvihJNHKeSZEHx2zglXiuwwfMLsf5+pWH9C0M+/n/Z8sbmabWmrIsEULQti3ee+yhaRHKau7C7ne46DECijK/iea6azZ24wNSQPXSgimzjDLLyYVmtz8nVTnyNfPbd2FpNclVbNqGadii2i2qWqFd8YpB3A2UBqmRMcys0kEmPsaZEbrVMAn+1YIqzBnoZV0hTE43BKb9xax2yDXZC7mQ14hxJNDQNo9pmic0zRWdTwydJkwlVXaPoljxB77zD2KMYRCe/91v/qN88/HngOcGeilGYj8i8+y18nklc2IcIAZkv5/Pr6vQq3toZxE+0b3E3LqiRFlL3+wJCbSrEMwPYleeIg6/30+RwFygGvlcqVIUFYoVfopM0xUh9EiZzWx6aJFS3yro/BRR2pHlRxhzzDQJ2naHNAMm86R+i7QFU5LE7oJExJMhQkB/VPb6AOHmAllogTDPNw7FIcXgQ2exr+XLvp+juYR8bqJyQD/NDr/qcN6l1Aih5hn/Q0zhEAPDMM7F8EsF9ixF7FHq9ef1LoT9njiMyOVyNlL7iJjZ6w/feCipWLkViXRnkT2EgUT66jZkZj4vCHmL9f13GULMcY23GOxrZItbMWPXRfj1ejjL8RPSJYRR+P3sKj/nYU93xnWllPDbljQO6NXi5hxPfT83Ep0jkwK9PGHUinj5jKw0mEwxtHuitLhMEw7eB8n3+CfnxLbFVBX58T3ePjrlyvdcdA0y0xQnNWm1QBwZ1KmlOK6xby9o0xau3iNPHcQ9pnuCjXuG7SNUf4ULLX5/Th72EEdcmqiqBcIopFOoyiIri9eCzX4itxlFL1Cdx/ctJnPYQhGw9G1C+4m3V2/xjnbYEKnLBcuiQEvJwgj8vuUqCBKCNEmGTWAccqxv6bVkf35Fvw9IVZJXJbmOLKscZSANF1w2F5CvyKsHhB6q1X36oWPabedxLqCZPJlRJGXZhw7pct5x93C65GLYEd89pf9Dvw/6HvHDfwXpW7rJEXeRtJsQsUEuFWq9PihYIiFFekZynZOmkSw5JgN93yPDHpXP5lxaa6YkoTyd74/2AppzbJiQxZL2cAm2fcskE8fHNet1TVYalBZMY6BvJnZ/6+/hn57Bv//9xKO3kU4iqxV9d4n7U38c8x3fBf/iVxj/zo/RiIZERtFG4r4n9h5hJEpZbLZg6J9HKI7jyLQfQEZMIbAi4f/hL5EuLtC/+3cglidzwRXTnBbRRwgJMnWj7goh0u49K2f49HFBXpfsLPhFhqss+TJDyYJp80ViEKRY0LaCNizwckWiAHdCtlyQFYZCSXa+owuwdnMsldCCqTmjbQZsfYrLMmLTEM7OMNNEtsqx91aURzVOW2RSGJvDpOeR9CHSDtMNMVRpxcpaxqQYdYFeLTnzW2K15OHRPXwMbMeGVV7N5rqHWNeXIyWltajlknKayH1P7HuyKOb18A4YY5imCScFpZLsk2FK3Dln7GNiHAdy43g5+jClROw8fvIEC9kLe4lMZSzs4uM3TF+AyDWyNB97/vrWZ1g1F82v+YyVVighuPJzCo2QzwkMpyUhpo9kYvr1hm8U2J8QZCpDCnljdvYmU7O7YLTAh4hTkpgS235mpoyS6K+ys/VxIITASkH/wk1Wmepm5vguNCEwvSBhvoYUkswUDKEnxrkbmVJgiB6n3ceTRr5YYCt5K4brzt9h1Mzw+NuLRaEkhXo+u5387XmVWzAZlCfPH9LX8QVwMObZzwyMvr2oSikpigKlFG3bwjTneI+HfF2lFarZo9Xsih5jvJO9ft1xheu5W0ExSXRRsVfTKy6Rb4KVkiJfsBsGpuYpBoVZHWavwxsYe5PNbuLCEuNwq3l06zse5OEvFlQpxkNMkpqPT7mib3f0u0u0VSgj54dYHBjHDfv9V9jtHrHrLhi6iB8tSq0p6vuUxYIqy1jXa1bFivXihD/zvX+Wv/A9f47vuv8dhBRuyW/TMJB8QuavL2iUysGPiG6LSMxKhsNcqM3V7I3QefxLxycrK6RS9PsdUWpstsa4EpWVs5IiJYKPJHlQqbzQRFBGYpQjxoIYZ7fxWS4uCHE6RCA9vzbCFG82WX0/EqNlsXiLsjxFuoyxPSfFSwYi3rcENGGIGKk+VgMGAJ0hC40obsu6pRTkVn04iy3ErGDww7yZ0dmteeGUEuPhwf4ipHRzowPIsmyWdHqPPMjhX8RsTBdfMR17E2Lf32TEf+xj8jGgpWblVsQU2QybW/fnEAa01DfjCx/vgw+/9euEvb7GK0Znr8HLBfbskWDnjPPK4YeJNMbncV13zGHHwRO3W1SdIQ++AylGpmHAHKJ8hBAUNmNYrJmuns0qiWGgaTaoAqr8ITrmDE+/QOgahLGo5RqzWIAQrLSjdgWP9ht63+MyjV4vCIscV99HVCeIo4cMx/cpzYIolozRYfIVbnnCIC0+grUGJRJi2GOmPT5GlLutkggpsRk9KtecvLMm5IY8SLqmgTYg+ohWCUxGf7VDT5J+uyUph1aWsfP0zUT/bIOKgmeXA9uzkeFqYJoisarJywXKweh7jPSUqxyXK6Zmx0XXMzx7j7f1xPrBQ9RnPsd0XDN0HaLRCAy7s6fzGh8iCYFUYs6H9wNlccxJVuNkSS0zRum4ePeY6ff+duL5Gf6v/Si7Z1eozUSuExytSOWcsTzESBw9Pf28p1AZvuvIXIHQlmb3FGPljQrCWksIAR8jFEfgKggj0VZUdUE/Bvqu52y7I8szjlf1nOKiJK4wlEuHSx38zN+H9RHit38ffaeZ9Lt0XSL4EVefkP+FP4f65m9l+rmfY/jJH6e+9xYqd8T9lthMxDGQfCQrj0gxMnSXpJQYdh1+aEluwK4ekCVD+Ls/iVoU2N/52wnC0fceHxNlrimPMkQfafq5oRli4nwzElLiZJWzVJojFKerml0IPOoiU9eR31tDsafQkiLXuEKjjSTpjOhWuGUxK8ZCokkJKTxamBsiZ9w9Y4w9OjvCTIFwdkbYNwjncPdOWT58yHK9ZLWsWS1KTKVxC4s9xE61vWfYe0Lj6fazMiCLgmOb08VAyFe06xVlvuC4LjnvtkhgnR2iKF+Qh78M6RxquaCMnlMD1rjZTHB6dX2ZvX8S3vtZYSklmyRJd5AmTQjI0M8F9gtIKZE6T/KRUXq00bf8coT4mITRHRAHv5F/o89Qc87265rNQgjWRt1yFp+NZNONQnJ42QztE4BvFNifEMzymYw+9ExxeqOp2V0wanbyFgepeEpgtbpheH4j4KRkSomYnsvEX3fDxpRofCSX4sY07NZnqRIf5znsmb0eiUjy17j9vg5i1s0DIO1HkHMqccgGvL1YVFpRH+SoKSUI6c3FulSHh3Q9z2S3F3NxPWznjulr5ulndrLAWsswDKSD/E4c5j2XuWFZ50zThFLqlQdJSIm9nzPJ7zquQghkMbser1YP8NHT+vZDj8uLWFVLZEzI/RZb3UeX5RyLFd5QNOkMUkSmeSO2H7fkOn+ViZv6Vw2YQro5h0II8mqJLRZM+wv2u0u67pzt9n2urr7CbnfBNAmkXFJWb1FWJyzKNVVVkeU5xlmYJqSQOO1QUvGZe5/j3ZNPY6VlitOtB15ou9ld/Q55+M0xHVv0NKHsap7Ff6FxIpWkLAxhjDTDbeZ2/i1zId63A8lIpFFzgQ1EnyBBkLximqLNHMsmUMSYoVRJjA0pRZSc//0aMSZiSEjFzQjC9TWmVIatH2DNGhs1UQR6oQiqgjDnfd4VP/VGKINQGnFHIVfY+Xpt79jQ3P6BGYQREcOr5mY+kuDOAnt2dZ/mY1uWc6e9afAXF4Srq5mBblum9hIR5UdilWEuxsJ2i8yzm4z4ryW01CzdEh/9TZGdUmIM41ctJ5xzpMtbiQVfD1BK3ci/34Tr+etbzVqZk9KENookI7GfGXyh1SsFdkqJcHaF0BK1ft4YHg+58C8a3eVKIo7uMYaJcHHOsD2nEwOlKRA7j2wEaIU40shFBYGD+ZpCp8RJWROS5lmzQRAIySNlunES3k8jUnWU1RGiOGLYtsiocMWSkC2YdAHFEdnRW6TiGFPfY8pPuRzlDZPkQ+SyncBH1qUlOI2qcurcMrnIaANJCKamQyTD2Axcfvl9uu0I1ExdmBU0XQ/TRFFkFCIR84z8tKB+UFIuHeXJKavTFZGe2O2IYaJ5+oRht2PXX7Fwkvr0XU6P73OcGXRdsltodsKj7YK2aRkeneM7T2Ek5/2eIQxkZoEzOWWWMYZAJS2Ginr9gPjNx1x9z7fRffHLmL/+I7g8x56u6E3Jk6blcd9w0U9c9J6WcV7Tx0iKE7rIsKPCjxtEUd00Aa/VYNdRf7iaWNwDXVAdfGwePz2ji4l7R8coq7l2U76G/x9/Ahk95Z/4IyzuLbG5Ajn7XEyTwfea0YP9C3+e6eFD9E//LPzPP4ssa6SakLmaPQLaCTrQqqJvL+jbjnHfkOSWrFyi3RLzT76IaDbEf+976FNBv59AQH6ckVWWeuEwMbG/7Gj6iYtmJPjE8cJhtWTsPFpL7i1y3rIZadKcTy1n6ZJhdQ8TPaltUUpgc01eWYqFRR+USLtxoouBe5lAKMfoI9P+kn6/QZsCO474yx3COfTJ8TxuoZ8b7qaQ5mahk/gwYZwiKw0y1xQLS1nNMYTXygDXKVwfiZMheMVpVZNEYtO3rLMFSs6NuOtY19dBZrNfiXIatS4RShA7T2ynWyq8a7OzayPZlVYE5dge0jFu1p2U6P1EKdKN8uxmTekDySeCSSTBK7P6X0940Vl848Nh/5tmL0klb7yfPkn4RoH9CUKuc2KKXPVXbzQ1uwtGSQQwhTjP6UqBFPyGsNfXyK47WR9BKnJt/V+/JrfP6QyQDKEhRk/vB6zOPrK52YsQUhyiuT7aZlqYOeLptZLnMM8SfxgbDsxd8OIYUoD2bGblXpCGvw5Zls1zS2Fi27aEGBFaY06OkfU8Z3SXc/i1NLx+w3mXZYmsKowylKakmZqPFA90DZ3lrG3GQtkb9np2bH7DAqvMwYXTs5t2SCKVeal5FKZZwvpSQZVCekX+pMsapVqG9iu07Y6EIctOWSzeYbl8QF2vyLIMm1l40R/JWtJhA2WkuRm90FKTSAjETQGTYiT1IzJzd0unDoYvDDtUdoKqHtzMjb8Im2mcUex3rzJmQkryekGSmqFtEVIi7SFWy8fDjLnAvPT3pZq9BLQ0B5dlh9YLhJBoXdxir/0YCDEwTLNEtiiK2/NpUqKyEhUsmbsHekWSNTpGpPsqi7ni+Hlm8QtQUpBZRTv6NysnDsV5UvoVOfPgI0qKV9Y2IQwgb1hspRSLBw/IV6tZLpoSaRjwu0vC1SXpqsc/fYZ/9mwuwDebmwI8jiPpMMuXQiBstwhjkPWrv+lrBSMNS7e8abiOcSSR/o3khLOs+utDHn6NO43O7sBdZnZz00WA9GAlwU+k3iPcq3FdYdMQhwl1srqZrZ/Z6x7jslvz9koIsqJmKivGZ1+m6S6RwpE3s9rGHB2THX+KJBNRdiQ/+4Bcs/G10eSuZvKSnd9SOE9uNEbOrFnjOzIxYfIV0ZSkzCHHEbPfEYScowsPow/WWoieOtP4mDjfD2y7uaASApZGkkRi1/coBITEsG05a88ZVaRJPaOKqDIjU5FFUZEbg5NgZULt91ihECly+mBBdlTQvNjsEIK8PiU6w9X7X6DfbmEciS5htKBe3SfZuaHnpORe7lhkjr0MDFmJzy3b/Ya4HymHiavthoyMKDT6MCMrpECHiX03cuIy1uURzTd9C1cPjolP3mP/Cz/PlZ8I0RKnSMnICkGfes6jRyZLGgNJR5LQmKHH5I72peewMebm2MJzUZa2EsLAo4sNeV1TO/OCm/LhtV/6MuGf/gLqWz6P/rZvRWqFKzKgx+YTq5MThBRMQ+DZvmH8E38GffoW4//wo4z/5JdmpZQeZ2l/YUAIdKzoLzr2Zx/gp0tMmZOX94hXF4h/+iuwWtDcPyaIDFvMRbA2CpkprJUUtaW7HHjvWUsKkdoqskwzDYEYEiZXxHbCJcmD0zWlkzSXT9mUDxjqitBeEjavmrZ2IbIbA7X0LKxBmpzd5pLmyfvIPmCkQS4K1HKNzKs7PTzSNO9VXDETBt7PDejBB3KnbgrucunI69kzoLaOGsVSlzxYLLnsNwgUy3xuGr5OHv4yZJ6jT0+R1iCLuahPPs1s9gv7mGuzsxDmSLZFVjLESDs+90tqw2z2mil1yzwy9n4mapxgDLMZ7V1eIF9PsFKy0Io+Jto0r3UpzGqy0cePpYb8esA3CuxPEK4ju4A3mpq9DkZJphBZZIaj0hJiemVj/rWEFAIjxC038bswxEgfE5WeMz3vgpYarXL6aY8PPT6lj2Vu9iJEpucH1kd9vZbAq2Zn17g2IvnIMy/aznNdOpvZo48o0bTWsioKQghc7htijAilZtOrO6K52kOW+OIOafjrUOgCLTXbYfuRF0chBMX6M+Srz9wUYEKL2YH9Tc0V7Wj6C4SwVPqOHNypO8yHPn9IpXgwkzsc6xB6xvEMH/forGLpatard1gtH1AU9Y05yfO/KSGkm98mjCH5QArhplCpTMXCLuhDj1X2eYe970kxITL3qjFejNBdznm82XIuXN5wvBYLyzhG+u7V+WOpFNlyPcvgbXbDqPgpEueI+ztjP7SRCOYu+zAMKJVjzBFa3x7LGPqJcRpujSC88h3znOQDVgjAQgSNQHy1BbZUdzYbAEqrSWl2cn3j+01BMq+yrYMPdxo3zvO69qbABlBZhqoq1GKBXq/Rx8eIoxp1coI9vo9aLhB5MRfgMZL6nrDbEy6v8OcXcwF+fj5/1hti7L5WsMqycAuGMLAbd0ghP9TX4pOG1xqdvYRrBvtFzNdERhITUimSTvP6LTUpxJtmWxwn/MUWtchRL8TxTeN8LZnsDjWG1gyLiq59xuAVlanQqyV6vUZYi5QWrWui7AmhIfl4w8Y7ILcKJXMmnxjjeLP29DExjXsqqVCLJX70SJPhjtboaYSuZQzhpiBxzs2fO40sLKQw8oXHFzw+vyJ2DV3T0E49u65HE9HOUUg3L7WZosgyFkdLFg8fsnhQk90/Rld2tkF4tiXuJ6K2xOAxwlBF6JuJthlvVEtGCLyr6ZoddmiwsaOLEZuvkVl1a12WQnBclRwZAUZzpQuehA4tRzAjIkhkp+m2A6aZ6HYT1us5v/pyS/f4CdtzRdprwu/6Qfy3fQvyn/4jxE/9FMc+soiOtNtifCIzgUJn7JpAEyaEhdiOKALF8h59GG75HFw/U69Z7OgjUom56B56vBC4vHyuDju4KacQGP/7HyMpRfZH/vBzbxVjCaFFW0dWLOZ57SKRbKBa3UP+2b/MlBe0//WPMPzzfw2pI4bAGCZ6RiYDSTtC36BzQ7l4GwgMP/H3iEOA7/s+ogzklcS84C8jzDxTq53CT5F2O5Ah0Hret0xDQFuJGOJhBMpgc8sis9g0UgaBr1ZcZrA52+Db5wXlGCObyZMnQaUiSShku+XqS/8KERL56dvo42P0eomwmjjc7bkRD2N7Np+v32EYGHwgJcheIkOkmn9fXZfUS823PXiAUIn9OFLZ6uZ54L1/bSTjmyCMQlYGDuqB2D83ShNC3FwPuTFk2rDvW3yc9xVtiOTJI19Q3sUhzKa6mWZK4eY+/SQgV5Lq4Cw+qNkU0ulZQTu+aUzw6xDfKLA/YahtzTpbf6ip2V0wWt5c4CEmEvyGSsRhdhMfYnptsZYOwfVGiFvGZnch0wW972imHUKaG/ncx4WQH6MYvn69eVUmfo2beK6P9SUE5Ks3FmJ3wVnLoijmrunB/GyaJqy1tx4iISV2PpBLceN0/tG+lmBhF8QUaaa748Xugl4foY9ecA6/PpdvWGDbFBmnjoWpEYRXrxHfz7PaLz4cD9dSSD3DeIb3G4TQGLPGVp9Cq0O01Guut3k26flM/c385TRhDyzvfKfMefMvysPjMCCUQZqX7sUY5ji2MM1jAPbDY56KTKOtZLsf7pw/VtpQHD/ALU8Of2JWUKSDUfpdRoVKS1JMaG2IMTKO48Hs6/n5H/qBZtdgnaYoijsN8WA2gBFaIQ5yOHUtt/0azBorKciMovkwFjtbvmJuNnfJn7uHv4zruK6UXnPvpkiMPdrM2cYyy1BV+bwAPznB3L+HPjlGr1ezlLAsZ6f9j3Ff/XrCKXdzj361a+DXOz5sDjvGmT256/pWKoMUECoRmTf1KQgSz/Ow/fkGoSTq+HlzKqXE1PcY55B3zLyrNKAqy3jyAL06pjo5fsWRWKkcbUqCaAhDf9PcEjGQG0WSCk2FkeZm/GnvO5xvcKZEuBwvAipKpMvI12tUiEy7PVP/3GxpjrJM9P3AMHqWheGoyhkmgZcGUeZUdc1JXbNcranrJSYKgk5IIYghgFSI+gFoRxwjafQI6XGfPoKlRpUWW+VkRuGA3VXPuO3pnm1onlxS2gVxcUzYXNBOI2O2oi7rO5MutLFkWnFqE7UteDIKzrtLAj31ekXjJMkqstzQSJCF5WmM7C4ec/nsAq8d1ekD7p2e8OBP/xnqdz6F+vs/zcU//p+JQ2LsRtpxQ9KRByrHJdiqke0QiE2DLkqKfA3MZrLXuJYFXxdUwScikaZpCGEir0qU1M8btod9wPSzP0/44APM7/o+xMnJ4foJCBVIeLJyNTeJUmTv95R5zmpVU3/qLbIf+ktEp+n+2o9y+XP/lPNHj2ib7hCtWXD88F3yoyOKxQOUMrRf+BLh538B+e67VN/7W1FFydidv3J9jlrQxsii1CyAdvAoIxlbP8dOhggxzX4ZRsLYkLRCL46px4HaOqplTiM9Tx5f0A4jPiaupoBJUItEbDZ0Z5ek8/cxZYV6+/Oour5hrKU7RJ++tJeaU13i3AiQAuccIQSafpyJmtfsDa+fzx4/71eioXbZTQMuhPCh7PXrIKRAlWbOlx4jsZkgphtVwzXqrECGgSsfaEMkpkSBvyFO4hhIg0c4RVLc7Nde9+z9ekSlFZkUbElMMaKYG2fDJ0wm/sk5Y98AMBt8fTXFNYBRcw62DxF/2MSb3+Cb2slDJ+s1G+cmRMIh8/rDkOmSRKT3Lbmuf0PZI2Hk/GB4acFIMc1u5L8B0WfXKIxGHub/2nbeDLzMXm99QPB6yf2boKWmNCWtb+/MYr8LQqlbsi8hxRvnsKcwsU8TuSnJkuI6rusGfjzk2j5XKaQ0MzmTvyCkPVIYjDnCmNUsgZZqLsL8MDu2T6+6ewolbmRM8/c8zF9O85yukYYpTgxhQAr5vOgOgTiMCG1vy8P9CM0ZkGYZ9EdUIwghqErD6CPjHSw2gCxWCHeQuk2zPDyKWQp917UvtZir7zirGcZDJNU1hmFgv28x1lIvqg+9f2SWkcaRIs9xQiCs+ZoVlaWdDVO6D5vFfgm9D0ghsK+5/66l8ddO9S8jhJmJUR/i5SCUmgvwPEeW5cdyDP9aINMZ6+yQC/6/QnxYgX39/+5SZ0hp51l75edC0oJIIIQmjiN+sye2I/p4eWsT7IeBFOOt2evnf6/H+y11tkadfJZcTZj+8ibC50VoXaNszjRekmK4+S25lEgtCBFKvcQowxQT/dhS4JFuOY9/mFnymsaAsJb86IioFOPFBeFQZCulKIoSrxxZUfDuyYp3TpesXEaQiseNJ4V4oxizeYHDME4jU/TE4OcoocMsKimRUo+qLKLICX7CVgXSzWqw1UmBqDRnXYMPIybPOF6ukdkJu16yCSW5zeBQsL58XoQQGOeIfuKkriiM4nxo2O0nMmXYCegknBO4lIleKkTbsOy3LE5POTpdsnp4QvnufaKOrP6PP0Rx7yH2b/9t/NMv06iRy3iOkhobNMvcUNtEu2/ZxoCsFkghyXVO57tXWGzvA10zEHxgnIa5eBOSZZ3jpLopJIQUMPRM/+NPIOsK84Pfj/cN43jBOJ4R4p5qdYQ9mL3upz0pJSpTzQZawcPxfcKf+t9CpZA//hPY976EERlpUsQJlHa44ggpM7r9xPgTP4FSivI//AFsvUK6Y8ZheyuxpJ8Cm97jKsvpMqfQknGKbHvPxaanbQe2nWdD4mrwXOwHzi+v+EoX2IkF45B4uu/Y7iPKwFXr+eUvPeGXz3eMo6dqWsLFM6ZmyxgHypMjlu9+M118SUGiZ2PZOLxUYE+zqZ3Ins+/a63ZNR1Wv/45df2M3k97Bh/IdEF22PNcF8FfbYF98zecQpbzZ8TGo6IkxnjTdBE6Y6UEwY/sQiRLIwpAuTmBpvcHJ/9ZWSaEuNOM9usdS61QSnIVIn4KNwlGnyR8o8D+Bm5gD12/KSR8nDvT8jeYwZ4jrWC8g6UL6dVs5jfBmQKBIpEoPqLZ268XhJZzwfjSgnFTcP8GSu+dlHNETJ5jjHlFBt2FyHCQhr9Ocv9hKEyBkYbt+NGl4i/jdXPYMUU24wYjDUW+RsZ4K64LmHOTpQJtSSni/X7eoIxbhHYYc4wxS+TL8liTz/J7qWfJdnf5Sv747Hb5/L/NMT3z37ZqNjbrfPeKPJwEwtnn6oeph+5i/lvFyStxHB+GzM5MwTgE/IcUlsHPrt8+ppv865chhEBpSfAR59xsgnUosruuYxgGtDSUZf767PcXPy/L5t88jnMDwnwNnbKVJNOKZrhDyfAGDFPEmdc/9oSQCGFuycRfRIgdUma3WP6vFxj5epfXTzqUUodotbvvm3gYm3mtQkPmSBFnBUOKc1xj0sR+JFxukVWBqm4398a+m3OhXyoO5+J6g5Q5lV2g8xWuOIIUZ5+N4VVFjc5WCKGY2oub2LFMSqxWeAHtIbqu8R45bclVBqZgOjQCVWaYes8wzlGVQzXHRp198ITN1Z5NN3HZTYSUWBcWrSQpJAojWdYZCBiGwKadCDGhjSHPStI0MaQR34/z/GlIiEwjVIAQkHWNP2SGG/u8mRiDx/iOMQRCWZIfLbALR3F/SbM+IhhH6SWhm15bXGjnICXaYaQuNbmUFF7Tth19jAchk2AlwD05YzE2HL/1AKRhHEay4xq3OiJJiReR/C//xxiTkf13f4vsoqcb9gyXV2y2Z+zGPePmErnZ0qJ5f7vnarsjDpG2aTnfnLPf79lcbdle7tmc7zl7esHoe6Sar79JCJZFTm4U+xdkz8NP/m3C7gp+3+9kkntCaA5eGAusPcWYNUJIxjDS+55c5UzjxH6/p+s60gTZW58l+0//DKauMD/6N3AXv4axiuATQ+sJk8b7hHz8PvqLv4L5jm9DvXUfkVc4u6CPkdhfAfO1tOkmMq1YLRxuYckRGAFjGxBjQGmFKDRKSaQQKN+iZQJjWeRrisyxygXa5uQm8s5RyVtKkLUN4ekZw6YhavAaXFWTHz0kd46Y0itu0uLAYscXRoLiGGZrhBdl7Wqed1bpzUWaOzS1JQ4j9U2z9Voe/uvBFAsl5+grK5E+IYbEOBz2K8qipaQWHgGUaZpHTpIkdh6hJTKf48K89zh3xzjcJwBCCI6sRijBZTdhpCCmT1Zc19ffLuEb+JpBCIGWgtFHfIi/IfnXd8FJSX/HvNzrspnfhNyUGJVhv1rn3H8D3JWJjY9z3Ndv4LE1UiCBKUGe57ecKONBGp5JQfZvaGi3sAtSSuym3Vf1/tfNYW+H7c3nC51D9Mj03Ixqll0MJGXxfjcX1qFFqQyjjrFuiXyTquPasT1fHRjmZ/Ns9Gu+180cdoxYaYmHTfeL8ts4DAht5oJNyTnburucGevi6LXzxW+C0xJtFZ7E2L2+sEwxEf2cNRliummc3QVl5PxanrPY16MEmcvQ0qDeUJC+CKEU0lnCfg8JpPvadt0Lp2YH1o/Y9Z4Ocry75q9fxBzXNb5yfEMYIIUPZa+/gX/3cL1pft0c9l3z1y9CqUOTSQbCNM25r9aQ+gBCoY9um9f58cBevyT5frG4NmaBEIJjq7Emm5tutpxTI5qzW4yilAqTr4nek9J+/r4kjJhjngYfuWxGHu92TLsdV1PGs8bzwcWeyz5xNnrO25GLy5Zu8DRjZF/WNFHQXW4Yd3u0FKwLeyOvTT4AglHDurDcKy1DCJw3A+3oZxY7Gbr9nmHbghRzUaEFcb9HZg5hDFPfo629UbOMfUe33eKM5vhkxZCeOwjXeQa5o1rls/dJFIgu3ulnIqUiqP9/e38eJ0V174//r1Nr77OyCCibsgzIDAR3EBUwokaNV4n3oxJ/iTd6NUZQvGoSZYviFQ1GvEZ/MRKj1+uS4IaaKIiKQhAXEEXcAFeWgdl6r+W8v39UdzPN7DAb8H4+HvOAqa6uOt1zqrvO9n5riMVrECnwIRwOwoSCSCqJHpqCfj4Dqm0B26uQjNWhtG8pAqV9YUVjED4VmmF4a3PDxXCSKag9i6Fc8CMIy0b42eXo5UQQUg1ofgdCqYUT/RamLlFSYEBRXNRKG1LR4Nf9iKeSsOIO3DRBCAWhSACGX4E/ZHpTxqULEgpCpgG/rsKy04glapDc+hHstW9D9OkJrXw0NK0w06gu9OqcyOafdrErugt20oZMy1yQ0mAwiIDhgz9UDK3/EdAvPh8kBaxH/gKtrgqBiAFfyMuz7g/pkK+9AigKzFNO9L6LdN1rcGphpK044tFaRFMO/IaKgkzaJTVowAwaCCRcFDgSpaV+FPUIoChkoiCgo8CnokBNwwiaCAZ0FPuDCAUjKAoIFBeEoakafGoKJYWFOMKvIxwJo1o1EXPi0FQBf2EPQPfB0BRoikByr9gaIpMelep1plLazU0Pz11zlEmN5TafOtSn+hDUglDIhC/z3ZbtfNvf0eu8cgsBJRO/R1c12HUpOCk7l0YyIG30NDTo0gYJHTLpeKlb/V4ZvLgoaqPBaA8WqhAo8ulwpERSSvQMm52+LLUjcQOb5cmuw7bdpke+OpohBFxCbpo64I2yWpIQbmMAikJ/L5QG+nVEMVvkRR2n3M0BEYEc8hpsncxURKOdFtlo7K2Zct8SVVERMkJIOSmk3cZHAFs4gPdvvXXYCTsBS1qIGF4ajWwKLkV6uc2JXJCdgGPXwaKEl7NW9cMwSqGqIQhScim6WpQdzdYML7p3osqbdp674cxM68t84ZFlQVM0CAhv6lkm6Bk5Dsh2vDRTCoBkjTcqZYYAf1GLEeCboigChqqAdJFZ39n4aJybKafM/Emb6yjTcr33e3KiSynh9/uhZFJQtbaBDXjBzkCZm6IOvjHQVQWmpiBuNT5lfm9pxxvVaq7DAchGjt5rCQIAKRMQQm84C4J1e4qi5EZ+G5ONqN0UIRQoigmhOF4DWxFQgiaUQABqcQGUvYIq2akUVMOAWu+G3XXTmca1D7reSCwNIby0jIFSr9MvUZWZUZOZvm4Y0JUIhGvDdWPeKLYqANXLEhBzXUi7DmFNhREogK4QAoaK0ogfhQEDxYV+FJsaevgN9I74UFIQRGnPQpSUhFFINsJ2EprrgFyvIUO2hNAE0kTwqQr8hobSoAlTUxFNOahJujBkAJR0EKe4txZXEZDxuLeePRSCY1u5afIkJZKxKKxEArrPD384grDPgKYI1KW8RpHfMFFkaIgEApAq4Cv0UjjKpN0gDRIA2KQiZccQ1v0oChcirUkoKYlSx4aMxlC3rRqu4yJU7EeooBjkeFN4XWVPZ4se8IP0ANxYDOaIARBTpkDW1MBY8ipCvhKEi/rBp/hgChPBkn4I+DWUGjY0N4nKul1IJ1KQTgpkphEp9qGwJISikgIEggEIIeC6LmwiKMKGLpKA3A0h6xBNxOC8/DoAHdoZ50M6JhzHa1ilUikkk0kkEgnEYjHsrNkJy7JQ6C9EIBDw0kb6fFCEl0tYMVRoahgYcBj0/3chkEwi9dCfQdXVUDUFhk+D/PRTyK1boFSMgFpcAhjesh9FVWGoAeyyJBKxWgQNBRFfvVzLioBZ7AMUAU1TIAj5AwdWDACQVjQYigFVCsAXhCCCqUgYoSKk3RQcSkMJFiAcCUBYSaTjNRDBIu97MSNgaEg7ssEopjA1b9mBnYktYjkQvvzGcMqWCAe9zk+rkRz1ey4zAVX4AIhcMDTH2ROUrL0JTYFe4IOiK7CiKa8eK6aXRtK1QY4DaWveiHwml7dlWXBd96AJbNYcXVdRoKpI2RJxDnLGDmaGqkBmclE3FSiio5mKgABy0cSJCDHXhbkPo6yKYkDtgtFrILO+SlX29L63JT1XOzMVpUGnRcr1orGH92Nq+N6yuamjVjRvXVpr7L0O23ZtxOwYAlpgT2qhTO+vkt3HroGV/A6ukFCNCAyjFJoW9nr+M/u0JUAdFMVrBAeKvZRf8UoIO+410rMNbFXNW4ft1/wIaHsClclUOvNaFAi71gu+5ivwbp73k09X4ZDX6LXTLtxGvpAc24tc65L3djWXak8owlvHactclPBgMAhN07zjaG1bJqKYpte47qQbg6CpwZWEVCvWYqdtF2YrOugURWuwBEFKB1JaUNWWA9Kx7qmpddhE1OIINuBNExcqIF0L0nWhGCrUwjDUYH5ddyzvcaPe6HV+47pg70PvVVCtkRk1cW/aqWZCRQBEKaTTMfgzEdJNnwbDEOipp1AYLkQkFIKpEEI+HUGfAZ+uwhfQoWkqhC3hVxVIxZsO6xoG1IIIZDoNp7oGzq7dsLfvhFO5C4m6Gli1tdDjcbixOJBOIawSCiDhRlNIuApgBpB04rDtNMi2IRNJqMEghKp6HQ26DoCQqKuFdBz4QmGYAa/xKYRAgV+HlIRo2oFQFBQVl0BmAs7ppg41k9uYXPIikmdGMqUk1DoJ+AwdPtIR9AchTMBWNaSqYqja6eWdN8MCwUAA0jHgkotQaTFkJtgn4H0GGpEiSEcDUnXQjx0NjBsHue07pB/9C1BTCztaC9Uogi/YE9KOwLWKEBEFKDALIANBUFBHCtVw3GpYViVspwpSxlBbux3R6HbsrP4WbqoG0WgUiQRBhR+p9VuQ/mwraFQ5rB7FSMWTsCwLjuNkUid6319SSJBO6FHYA8FAMK8R6HX6evcUqmpCUQzQsAEwzj8HVLMbyYcWg+rqAClh/fMVQFNgjBvrpdrTjNzrT6cV1MGATyeEkMTetICO0OFh6L38UHQVlHK8JQFpG7ATcDUfLHJgaqa3TEDXvM5wOwFfMAzDH0TaqkUqnkRsRw2K3FqEgwHUKkV5n90+XYGot+QhS6giN4otLdebIVVvenh2dpLf0HIzsZrLGpC2vVSN2Xtcx3FyeeY7gqqq0EM+L5+1S5DpTCrXVC1kSgKKl+5LKF7neTqdhq7rHdLg726EIuDTNYQBxOrFfzoYHPx/PdYm9Ud3umqqhhAChuL1nAcBRF0JSUCklXmouxPF8NbVkEteoCwhMpGpO1eu04IkNHhTa6OZTgt/O5cnbIRRlapC1IqiwGzhZnIv2XXY9dddh/ZeP6/7IZI1UOBNz1ZJg+rvAaHl75cb7diXeqyZ3mh2ug5IRyEcBaSEgEy6NqHruXXYe5eP0ilAVSES1RA+AfiLWx3MrCXZ6c1SFRCKgJV04A/VS0tGBNeR0E0VKUe2KkihqnmNdSLK3WDUP05bqUVF+zQFfl/oqgJDVRBPOw1Ss9TnSi+uRNBsXblUxYQr0/C+9gEpkwCUzOg2OxCpqpobqarfydJcBPH6FMWAqhmwUym4tpe2S2nk+rBSSSiaBlXTM8fPNq4NaFobskDofkA1vc+gVB1gpyDUIFTbD10LwrJqEAgEYSoKYo6E7cQRJgeKWegFwHKcBuuXFZ8GmbChuwISAFQv4rUZCkErLQVcb+mLTNmQcJDSJTRJ0F0HZKXhuhKUloBDiKhAQgUSaRc7qnfCL/zoFSn2sgkEAnAdB9JxoGgaknV1UDQNvlCoQUR1TVUQ8mmIphwYqgJd8Ro89ZcyCV2Fkp0mnHZAtkAt0ki5afQr7AFpO/D7A9A1DTIo4CYNuBENpu5ASUj4tDBsOwXFpyIYLoSzcycSsWhuhFAzVdiBIjjxaphmDHTqRAi/AXrzDcQX3oPkycdCGfYDpJOO1yD3adAME2FFIOlKVFsB1KWrERYBBDUDRDaIUrCsBFRfCKot0KOgBH5/0OtYcBzQypWgQAjhc84GGX4IS0IJGvnTnqWDRDoBv+pH0GgYoJDs/CVnqhqGtHdDVIyEkUrC+sebSD78F+hjxkDu2AlxUjnUYMhbigDvc77GcuBYCiJhE0KFtzxKDzaIEaIa3pRsxa9BECBTLmRtNUAOUmEVAgKmMEFke/c4WtCbheFY8IVLQPb3sJCEZidggqD6iiFtBdXVSRSGTfj93pR0n64iabsImVredSpMDRS3QAnHe831ZlalbHfP7CTVhG3bSKfT8PsbLueR0lvnHTS13HvQ2LXS3nRdh23bkKaAYmuQSQVIpQDNyPu7p9Pe7L9DYfQ6S2gKAmmCqaldtjS1I/AINsujKALnnjERRx81AEY7TBveV4YiYEny0ku5EiFVgXogBnrQFC8Kte16U+66aNq9F/HaS4EGAFHH9TotOuBvrAgFYSOMtJtG0mnYG95sOTPrnWuTtQC8ddcNZGYk6MIHUwlBU/wQjaW6cglQxL4HCBHCG3kOlEAoAOJVoHitl1fbMHLrsOsj2walk0B2HXqoFNBMjB8/Hr17997vYCVKptc97UiYAQ3SIdj1IqxKh7wUKroCW0rorZgtoepesmzp7Ok5dh0JEKAZba8fYh/yiO6PoKnBaWEUO2V7UfJbWn+dpSgGQC6kdDLr85JQVd9BGWzmUKEoSm60ur7s7y01sIUQ0DQ/hOLAthufgurYNqTjrU/2jp2GbWcb1/uQB11RvJHsQAlAEsKqAtIx6AiDSIFl1cAUXqJA3a6Fofog9GCuI2Hv9ZtCUwBVgWq5ABFkJvib43ijx0LXM7NQDKgFQbihMEJFhdCKi6EWlUAJFEItKITRuxjGYSUoLClE3z69ENKD+HbXLtSmHCghb+qxlUwgnUhAOg50nx+BSEGj6coAb2qwqSmoS9lIpdLe6PXeZc+uaQ3qkCDs3lWNMOkIBwsAIeDaNvxGAFLYMEoj0EI6KBWHT/HWMjvCgeH3Q9V0+EMhWMnknlFsIWCEA3CVMNxEFVQdoBNPBs77MayaOtDflsL4dBN8IR2BiAHDp+Vm9vhVBT1MH3TVwLZUEq4wIKUJRYmgd++joAdLURAoQEGkEKZpwjAM0KrVMBMxuBNOAQVDUI1MYzYzI0mSRMyKoTpVDcDrtN4bSfIiaddraCqKBlUNwFUktLGjoU0cB7ljJ6yX/wEEfNCPHQmh+QDd7zWuEzZsIhQFNBQYfqQUxVuekIl70hShKlB9AopuA3oAiXgMuqV4gV4AL4irZnoBPe04oBnwB8MI6g4CARVqcRhKQRiFERM+IVBdlUS8KgmZsOFHthG8V7BRVUDoKsiVEEZ+HJu0I2Fqam5WhGl6jey9Z6ykbBe74xYg9uTKzs4W6OjRYk3ToCgKHNfx0nkFvJSiSjiYuy/MRhs/2NJytcSb1UnQD64Z4tzAPpR88cUXuPLKK1FeXo6KigoMGjQIFRUVuPbaa7F8+fLcl80/l7+Oy35+eZeW1Zf5cKmxXagCuZzXqVQKN910E4YOHYpRo0Zh7NixeP7559vtvPfccw+effbZdjueECIX7AySvAZ3FzEV4aVxcSWSmanhHdVpYaomfJoPMSsGV7YhlZKqeOuu7fSeddd7UxTvy9tJA3YSUDMpt/ZCrmyf2QKaAUR6AGYQlPICEAnFu5H4fNOmvGtq8FFHYuykSbju1t9h+dr1yE50W7lyJa688sr9Lwu8aXS2KyEUAc1QYKWcXG5s1/G2E7zYb3orOnRs28Ktc36L4SOG566pZ595Dora+VkE9oWhKdBVBQmr6XqWdiQMrfF0ZY0RwgAgIGU6M3pNPD38AKdmOn72vul2XTe3RrsliuKDoqlwrHijgZTszOi1puv1Gtf6vjWu69MMIFgK4YtAUAJaYjc0eLl/VbcWirQQcBNQzEJAUWDbdpMRkRWfNwJpuAQbIjeyn0Wul0oy5fW7wacqkGkv/ZZQFagRH5SgD4rprUH3FRag/8BBMAIa6kwFUanAsdKIVu2GqmnwhSMwAy1fOwFNIJVMojqWhGEYTb5fQlUQVZOwdaBIC4ESDjRFh51Ow+cLQkqJhJuCnYxCSRNMMwIbFhRNzaVM8we9WUfJeHzPW6yrUANFsCwHBnnbxYB+EJdMhX5YD4hXX4Xz/PNAI8sMdEWgXyACkIvvYnWoTnivQdF0JNM2gvVSFlJ1New3VsI4rDeUY49B3HL3LI+yJZJOElWpKiSdJAJ6ACW+kkZTr+Zigux1T6GqIQACjkowjx8D4+STvO2nHA9oChSzAFISquIWbFeiMOStq/fBgATB0n3ed6vTQhwVKwqh65AFIUgDMGHCjabzon3DCHjZM6QLmCHvfkPzQ9F1CNMPxaehqEcQwQITda6LZNqBYknoSRfxWu9Y9dfdi8yMkfrTwx3XW7Ndv/M0myklOxosJaE2aaM2aUNTBEqCe4JpdfT08PqyObGJCEowBDXkvQ9ZB3NaruYINVP/OQ925yAi/OMf/8AFF1yAoUOH4uijj0ZZWRmmT5+OnTt3dnXxDjhLlizB6NGjMXToULzzzjtYt24dNm/ejMceewyrV6/GpEmT8OKLLwIAIj4N/i6ejq0KAU14DYUCbc+I2KWXXornnnsOb7/9Nj788EPMmjUL559/PpYuXdou523vBjaQyYmduRnrivXXWabwcozXOi4MReQ6LTpKSPdGMqJW66OK22QjIZMIKvXWXTcm28B20oDeMM8sEQES7ZYOTSgK4A+DjCJAKBCpGjz7/N/xg+OO23NNrXkLn73+Ev76wH1Y/e46/PDcM3PXVHsyNdXLFe9KGJlAL9nc2I4toWqiTXnsL730Urz48lIs++cKfPjhh7j11ltx0f+bin+8+nK7l72jBE0VtisbpHgBvJsr2/VGOFrLS9lkQMo0XDfhBbgSB94SFbZHNg3X3g3s1qy/zvIayz5INwm5V85q1/ECoOk+H6S06jWuC9tn5oMQgBmCKOwNIXRo6SiQtABpo0BWwRQKFCMCKfdEmW70MJmRQMMmWK6EqnkpgbIj+d5NrkBKAXQASDhe1GZT9UbeGul0C4QjiBgmnHQdauui2L19BxRFQbi0FFozwQ5d10UqlUIsFkMqlUTIUAFNR03ai4oeTdlI2S6cerEmLNdCdSqBUCCCUHHQW38sNbgxC2Q7MHQTVioKJ5GAqYWg+QSkdGBk1n0DgKKq8AeCSMZjeTMafEEfXC0EOxVD0EhAUywoR/SH75rLoQ45Evbad5H408OgaMPvNFM10MPwIZWoQYKAtKohKSXIdRCs12BKv/gy4Dgwf3QWgn4Tadv1PqOEg+q4t7TKUA0U+4oR1INN1h0vCF3DjCTeTIswpCIgyYEx4XgE/ut6qKOPgqIYcFU/qhKWl5ItaMDUVS+AmdCgChUpAe/7NVXXIF3cnj+c7TWcjRBSbhqqocNXEPQCgkpk1so7IM3v1Vs7AWgmyN/D6wxXvVgqWQUhE4GQiZgqkDZUBMIGbEfCiluQMQtu3Ft7D8p0ENWfHu7IBrOTsqPYjuMgnkxjd9xC2nYR8ekoChp5yx8dx+m0tc66rnsBSm3bWwcf7pUbHHAycQGa61w6mO2dDvVg0G0b2Dt27MCUKVMwbNgwbNy4ERs2bMBLL72EpUuX4rjjjkNdXfNTWNgeH330ES6++GJce+21mDFjRt7ajpEjR2Lp0qV5a1Wy02y6WlBVEFYVGJmbnzfeeAN/+9vfMHv2bJSWlgIAfvSjH2HSpEm49tpr9zn/ckcTaiaStSI6NT3X3rRMjnHA67ToaIpQEDEisKSFhJ1ocX9JEnVWHQzNhF80bDTn0eo9rjWSNklmAsq14/stNAUgFRQoxkdffoNpv5qBa/5/l2DGL/8TpkyCYlUg1Y+jjx2P559a0uj6r/aQDc6Ssr2RD9OvwbUlrJQDkgRV9zIBqErLI9DZa+rWW25FSVEJpCtx5pSzcOopp2HmDdd122tqb9m1W/F0wwZ2dqpha6eHZymKmVlLyam5DhaNBTprSwMbAAwzDIIDx8of4bNSSSiqClUTsO2a9m1c1yMMHQgUQxhFgCuhpS0gHYWqhwDNyI1GN9doEKYKQwjAcuEqe6aJA14DW6qAZUmYCReQBCWgQzGbPp6mGwgHCiDcFKLxXYhZEqHiktw69PqyDYxEIoF4PA7btqFpGoLBIIoLI+hZEELA0CCEFxm6Nmljd9zCzroUdsfS+L62CokUEDL8ucjLWtiEqmmwquIw4YNtO4Clwx8JwXbTUDQtLw83AAQjEZDrIhmL1XsdJjSfD5argKwkHKlD8anQwoXwX/ZT6CedCPrqKyT/549wv/2uwWtTXRV+BQj7VSQloS6dhgmClmlgu198CffjjVBHjoB65GD4dRWudLEtWoVaGQVIoFAtaHr2VvY9bGR6eF45VB+EYsBRJMhJAeEgyIpCamFUJWwQAcX1UrKJzOihT/Mh7aRBRsgL8tnU93Y66uVu1nxIu+lcikpFU6CEDQhDAaUlZNyBJNNb100ESAFIO5NhI7/sBX4dPl1F1HIA3evMSZlqJrK2l5pLxi1viVa9wYG07eamh+e/BxritsTO2rg3ah0y4d9ryZPrupBSdloDW1EUL21bZrZofdm0XIfa6HWW0BRAoEGmgANZt21gA0BRURHmzp2bm7oxYMAA3Hjjjdi6dSv+9re/dXHpDhzz5s1DOp3GNddc0+jjPXv2xKxZs9CvX/PprF5//XWcd955GD16dO7nvvvua7Cm7Z///CdOOukkjBkzBuXl5Zg4cSIefvjh3OOxWAzXXHMNjj76aIwePRrl5eW4+uqrsXnz5rzj+FUFwXoNwaeeegoAMHHixLz9Jk6ciM2bN+Pdd99ttvxr167FpEmTcmU/6aSTcOeddwIAPv30U1RUVOD777/H888/j4qKClRUVOCvf/0rnnzySVRUVEAIgVtvvRWzZ8/GiSeeiIKCAhQWFuaOv2bNGkyaNAkDBw7EwIEDccYZZ2DdunUAAMWvQ/HrrXoPb7jhBhx55JEQQmDJkiW45JJLMHLkSAwcOBCLFy8GANx111044YQT0K9fP0yfPj1vih8A/OEPf0BFRQXGjBmDUaNGYerUqXjjjTcQ0VQUdODU8L0ZqgG/5kfcjsORDiRJVMYrG/3ZXL0ZuxK7kBZpVMZ2Ymd0Z5P7ViarUJmuQ6UVRWVyd4PHd0Z3ojJRicrUrqaPUe+nNRHPvfRqBLiEeXfcjXTawlXTLgUldgNOClL4IPwRCE1Hzx49cestt3bYNXX+2WfgL4sXe2vHDBXJVAK/+tWvcOxJP8Axx47Ficf8ADdfP73BNbW37DU1+fRJgPBGwF1b4pQJp7Z4TS1cuBBlZWUQQuCBBx7AL3/5S4wePRp9+/bF/PnzAQB//etfMWHCBPTt2xeXXnopYvVuZgHvZnvhwoUYNmwYhg0bhkGDBuG6665DIpF/Yzd//nwcd9xxGDt2LMrLy3H66afnlS2ZTOK0k47D4H69MWDAACxbtgyTJ0/GD37wA5x0wnFY//67bZ7uriiZKLtC5eBmBwlVVSGl3DNam1mT3Zbpod40cQ1Wes8opnRduJYF1VBg2zUQQuuQxnWW0BUoih+urxjCiEBXw1B9XqdztsHaXKeBUAQ0nwrVkbClt/7UcbwOOnJcJNMuRNKB31Qzua1bCACnqggEwijwFSAY1BGjBOJ7faTWH61OJr3YHH6/P5dyKvs3MDQFIVNDYcBAj7CJHiEThQEdQVND0o0jmrYhHRNJy0VlNI3dsTTqbBdO0A8LLlRHQFg++AJhaKaEdJxGp6irmgbTH0AiFs11JAqhwPDpkJofKduA1ELQDPI+CxQF5tlnwrjg30DxBFIP/gn2++tyx0un0xAkEAwEocJGka5CcR0ENNXraHBdpF9YCmgazDPPABEh4cSRoiiiVhoRXwSF/kJoaLkueplJRLNLzjQtDNIMSJmCTGyH7RJqZBBCAMVBIz+7hOaNPJuKCQIhDekF2UvHgL2jcbuWN3PMDMEiG5Kkl0s706mt6Iq3Vj6kQ6gCJA248TQomQA5LoSwcxHM95ZtZNelvAao5UiQqngdPGHvHkqYam5mmpOJOm3u1dGQXWtNio6ALhDUGw/a6ziOl7arE6aHZ+m6Dtd18zr6DqW0XE0RmgI1ZHTpIFS7o24snU432PbSSy8RALrrrrvadKza2loCQLW1te1VvHbnui5VVlaS67rtesxwOEyDBg1q0/NmzZpFe1ePK664gmbOnJkr3zfffEODBw+me+65J7fPl19+SYZh0IoVK3Lbfv/731P//v1zv19++eU0efJksiyLiIi2bdtGRx11FC1evLjZMp144okUiUQabP/73/9OAOhPf/pTk8+tq6ujoqKivHNkn1df//796ac//WmjxwBAffr0oRdeeIGIiDZv3kxFRUVERLRmzRoyTZNmzpyZ2//666+ncDhMn3/+eW5ba95DIqIVK1YQADr55JNpx44dRER03333kRCCbrzxRlq9ejUREa1fv56EEHmv67HHHqOePXvmnpdKpejCCy9s8nW1VVvrqZSSdiV20e7kbtoR3UGYjW73szO2s1WvxalLkx1P564pa/sOcmM1JO0U2Tt3khONkpuyyalr+NnVntfUXXffTf2OOIKSlkNERD//+c/ptFMnUl11nKSUtOGzLXTkkW27ppIxixLRNMVqUvTk40+1eE0REW3ZsoUA0NFHH02fffYZEREtXbqUANCMGTNoyZIlRET03XffUTgcplmzZuU9f/r06RQIBGjNmjVERLR9+3YaPnw4TZkyJW+/SCRCa9euzf3++OOPUzgcpm+++SZvv5/8v0soHInQzJkzyXEc2r59O511znk0YMBAchyn2dfSGMuqJcdJtvl5rHtyHIdqa2vJtm0iIrJtm2pra9tcN+LR7VS1/TOSUhIRUTIWpbqqnZRM7qB0endue2vsy/e+dCTZNUmq3V3tfY9mnpt9fdnv1maPISVVVydoR02C0uk01dbWUrI6TolvamjbzjqqiqVaXR4iokRdLSWidVRXvZs+//ZL+njHN1SdiFI6naZYLEa1tbVUV1dHyWRy365Fx6Id8R30bU017YqmKG27FE/bVJOwaFc0Rdtrk7T56+209btK2rYzRjWxFMWqqygRrWvymOlUirZ9tZWS8die81g1FK3ZSbHqFMXrYpRKbScp88vrfP0Nxef/N8Vu+g2llr5Edub9S6VSlHbStCO+g9JOmuK1NZSMRr1zrXyLojf9htKvLqOEnaDKRCXtjO+k2lSUttckKJayyY1b5EQbfnfszYmmyY23/De2rFpK1X5JsZ0b6fvvN9KuaIpct2HdlLZLTm2KpONSVbKKqpPVXp2q20aUrCGievU0WkkUqyQioppUDe1O7vYeTzvk1KYb1H3puORUbidn+3fkVNWR3P0NkdN82WuTFn1XnaCtu2IUT9tN7hdL2bSjNpk7p+tKqklYtL02SVWxNDmupEQiQdFotNFrMhaLUSKRaLYs7U1KmbsOsr9Ho9FOL8fBqCPaUHtrS1uyW6fpamyqxKeffgoAOPXUU5t9bjqdzgU4AJCbUl6/97q1/u+j/0N1srpNz9kXkiQSiQQCgQAU0bBnsshfhH8f+e9tOubOnTsRjUYxcuTINr1uyuZgrPecm266KTc1W0qJPn364N/+7d/w4IMP5kbH3333XViWhcGDB+eee+WVV6Kuri73++rVq3H88cfnRhN69uyJ//7v/8Zhhx3WbBkrKysRiUQa7BMKhXKvtannf/LJJ6iurs4r13nnnYebb765wXOokUizWSNGjMCZZ54JKSX69++PNWvWQEqJG264AcFgEHPmzMk9d/bs2XjwwQdx++2346GHHmr1e1j/fT/33HNRWloKKSWmTp2KX/7yl9i4cSNuv/12SCkxcuRIlJWV4dVXX8W0adMAAKtWrUJhYSGKi4shpYSu67jllluwfv36Ntf9xmTT2rTlWCE9hOpUNZJ226KKd5bWfi6QAuzYtiN3TZEAXAcQioR0Xai6Dmm7gECj9Sp7rqx9vaau+s//xM7d1UhaDgxV4F//+heOO/Y4+IMGLMdFSY+euH3+HTi8X59WX1NCAeyk16seKfKitzd3TdV/LaecckqufFOmTEEoFMLy5ctx1113QUqJ3r17Y/z48Vi2bBluvfVWAMCXX36Je++9F1dccQXGjh0LKSV69OiBG2+8EZdddhneeOMNjB8/HoD3mTFs2LDc+X7yk59gxowZ+N///V/ccMMNufJoikAsGsX0664HEcFygbPP/TFefP5ZfPHFFzjqqKOa/fvuzQsY1PBvyQ5M2RFl27a9iL6ZgENA2/7Gmh5CQu5GOhmDZviQSkSh6BaAIFQ1AiJq9fKKffk8hQBIEaCUzAU0g5SwLCuXcqw1xzMMBfGYBVdXQJaLWHUMrqKgTldRZDmISiu3dr2xf/NG6IUCO50CiNCnoCe+qa3Gl9u+Rc9gEEXBIvh8vrypuG29H6lJ1QCkQCEDPk2BpgCaosALQ+FNc0+IAOKxBHx+FTpsOI4DMxhq8lyarkPVDcRqa6GbXpYAIgWK5gASUDQbRCLzs+cYom8fmP95BdL/+39Iv7kSztatMKZeAD1zL6JAQXV0N/yOl5rMrauDtew1uJEQ6o4pg5OqhU/1IWgEoSoqpGMjlrJhGirIcQHHbXIkj1yCdFwofr3F91BRAoiTjliyFkaoNwr9GgDKBcXMHVN49Y9sF4ZiIGpFYWtBqHrAmw6u+SGhgJwUpE1AsATSdZCyUwjqXmA5absgQRB7130BiEgYFN0NcuOQmuLFs2im7CHDuzfcUWdjVzSFfkWNB8lLpL2gZUSElOWgLuVdz2GfnpkOTrm82KlUKm+EOBurwOfzdfrnu6qqsCwrVzbXdbukHAebffos3YdztFa3bmDvzbZt/OlPf8Ill1yCMWPGNLvv/PnzMWfOnAbbq6urG0ynbUk8Fkc8HW95x/1EREilUgDQ6NQywzVQVVXVpmPW1NQA8KbCtOW52Slc9Z/jui5uueUWvPnmm0gmk1AUBTt37kRtbW1uv6FDhyIYDOKEE07Az372M5x11lkYPHgwrr766tw+J554Ih566CFUVlbiJz/5CcaPH5+7kW6ujNn1MnvvE80EHEkkEk0+v2fPnjjssMNw3nnn4bLLLsM555yDESNG4Lrrrst7jpQS6XS6yeMceeSReY8VFRXh22+/xVtvvYWTTz4ZiUQib3pr//79sXz58txzWvMe1n9NvXv3blCWI444Im9bJBLBN998k9t27LHH4v7778fxxx+PadOm4Yc//CEOO+wwHHbYYW2uP42RUiIajbYqd2x9lmNhW3Tbfp+/I1TXVENNt25qXl2Nl0LMcRzUxONAba2XM9T1cr5SzAYMFSKV/9609zV11dW/xI7K3XCCeu6a2rV7F847/wKMPu5EnDJhPIQQrb6mpCSkYw6EAsTj3lTu5q4pYM/nS9++ffP2KywsRP/+/fO2hUIhbNy4Mbft+eefh5QSFRUVefsdccQRAICXXnoJI0aMAABs27YNN998M7744ovcZ2NVVVXe8QDAsS0UFhUh5XiP766phT+TT/ezzz5DSUlJk6+FHRqSyaSXb9fnQzqdhuu6ja6JbEk0lkAy/Q0UxQ8rVQlfuBBp2w8hatp0nH39PCVbIh1NwE1GEQx5eY0TiQRUVW3V6yEikCMRrbbgVgI+v5cCKWZI2JYLRzqIZm5Wsx0Ge99cZhvZQgiQ68JKJCBJwgiGYBAAS0El1SLlpBDWw41Gw26NhJNA0klCRxiWY0EL6kg2co9EUsJKRCEdC1ErDdUwYKH5Kadpx0asusZLa2h6AepctxaaJuC6UQAqtCamYtOPz4X9wlKI9Rvg3P8Akhf+G6ikBLF4DWqTNSgOliBAgFz6IpzdO5A493SIWBxBPQhHcVCLzHeJJFQnbNiGAtMiIKk2ub6aLBewJGBrLS5BiKUdxNMWdEWDbruorm56oIjiDhATIFOgNl0LW7PhV30QyShQl4BrFiC+ezsQCkG4fiSd3Yg7cQhTICVS3vM1AdHE96hIxCGkC9J8IKd19yEibeHr3TacRBQRf/56flcSqhI2goaK2hpCypHQVYGwqSHpCNTvyrcsCzU1NQjUC3Rn2zYsy8rb1lmklLkYBNmG9r58BrF8+/pZ2hbRRgIcNuWAamD/5je/gc/nw/3339/ivjfffDOuu+663O91dXU4/PDDUVRUhEikkdy6zbj8+M5JWSWlRHV1NYqKitqtchQWFiIcDmP37t0oLi5u9fOyAZqyzyEinH/++di2bRteeuklDB48GAAwZ84czJ07N7dfcXEx1q5diwULFuAPf/gD5s2bh9GjR2PevHmYMmUKAOD+++/HmDFj8Kc//QkXX3wxQqEQLrnkEsyfP7/Zv02vXr3w8ccfN3gd2d7SI444osnXWFxcjHfeeQcLFizAo48+it///vc46qij8Jvf/AaXXnppbj9FUWCaZpPH6dGjR4PHkskkpJRYv349Jk2alPdYXV0dhBAoLi5u9XsIAOGwl/eyd+/eDc5XUlKSty070yO77dJLL8Vhhx2GhQsX4vrrr8d1112HH/7wh7j77rsxZMiQRl9XW0gpIYRocz0toiIktJaDnXWFosIiFAdbvj5IEiJmcM811bMnZDTq5bMMBCB8AUjNghJouG6xva+p2XPm4pjxpyHk1/OuqZ9dNg3BUAiX7sM1lfRZUFWlVdcUsGdm0N7XhaqqKCoqytvm8/lARHvOlelwuPPOO/M+013XRa9evSClRHFxMTZs2ICzzz4bl112GZ544oncKMSgQYPy3k8AME0T4VAYgXAEYb8GM2GjpKgQALwgSm34DGQHp3Q6Ddu2EQqFkEgkIITYp4CEhmbBTkcBshCJ9EYg3AeikZlnLdnXz1MiQlr3Iy0tRIoKc7OV/H5/s0GbyJUg2/uBToDqALZEUdj0RkdNgVJNRbiJQJj1R4nq/+s4NhKKgD8UQiAUhqZpKEk7qEumoOkpCEHwG374GwtK2Qxb2nBSDor0IiRSGoo1pUFjq76Uz+cFoAv4ESwozKXHaoqUhditqjA0DQXFxSCSsCwBTQvBcQiaFm4yRV86nYY19ULow4fDffmfkI89DjprCnqWDUegJALDMKF9X4nUxg+hDzsSfcafBr/e+LGMhAVHEgqhQKgCir/xv6EbsyBUpcnHvddEqE3ZMDWJkuJi+DQnkwmh6Yak9Dsgl6CGdBhpAw45KPYVA04QSFZDqirUoA8FvQ6HYvhRnapGUARRaBaCJHnfe34NoqkMNCHDGw33FQBNvAd7Ky4GtF1x2JLgC/kQMPa85njaQUpJw9RVEAE9c6PWDRER4vE4NE2DL9Phmh0ICbQihVxHSCQScF0XwWAQwWDT0eJZ6+3rZ2lbtCUgXrdoYL/77ru4/PI9jdg+ffrgpZdeytvnrrvuwiuvvILly5fnGh/NMU2z0YABrc132VWy06/aq4yKomDKlCl4+umnsXPnTvTu3bvR/VasWIHDDjsMw4YNy5Uj+3wA+Pzzz7Fy5UosWLAgb5rl3vsBwPDhw/Hwww/j/vvvx/PPP4/Zs2fjvPPOw0cffYShQ4dCURRceeWVuPLKK/Hpp5/igQcewL333otYLIZHH320yddSUVGB1atXo7q6Om8kauvWrQCA0aNHN/u+9evXD3/4wx9w991345VXXsHvfvc7XHbZZejXr19e4LTs36AxjT1WUlICRVEwYcIEPPPMM02evy3vYfb/jdWFpspXf9vpp5+O008/Hbt27cKjjz6KefPm4YwzzsDmzZvbpW7taz0dVDQIG6/eCF8mCnjSSaLQKISu5t8wkSTIuJVJydG2ACRku5ApB0qw9QEzSgIljS7LaEABYOg44/Qz8Lclf0NldTVKda+DQ/X7QTLzN9NVvP766x16Tf3b+T/GyjXvIzB8GPymlrum/vX+Bjy6+CE8cP99bb6mghHv79Laa6ot9XTv19WjRw8AwN13341zzz23yXM89dRTSKVSmDdvXoOGUGPnEALQVBXRtAtAwMjUn+7+2c86R/0ovkSUy5nbVj5/AZx0HYSiIRjuA0Xd99upff08NfwmrDoLUkovJ3YTUYhJUqZR7UUFF0JAMb10R0EYiNalIQiwNQVCVRDQtCaDAjZXxlAwBLXeDWjYp8NyCSADpmEj7sThkIOIEWl1gyJuxaGrOnTFDwgHAbP5v5cZ8EM6Ngy/P68sTVEUBYFQGMloHVzHhm6YUFUdRKlMfmRfo+ezbRu2bcMfCEA94XgkCyKgJ56C8szz0BMpFJ5yIuqsOjgvLoWuGYicfxFUM9RkOUI+A9UJC7YiYMrG32dyJRRk/nZNvAe2K1GTdEAAijM5roFWRKbWVZDreh1Ohh+16Vq4cKEbAcBJAXYSUE0ohh8SEi5cRPQIFEUBuRJQFCi61vR3rhECSHqN6zbU896FfmyrSaEu5eWrDxial8c7YSPtEiJ+DRG/3mgQs/pM00Q6nQaRV/+llPD5Gv/bdgbDMJBKpfIC/LH9195tqL215bjd4m5j7NixWLduXe5n78b17bffjqeffhorVqzgKX77YM6cOfD7/bjvvvsafXz16tU47bTTsGPHjiaPkV3Pvnfl2rYtf8rv8uXLc+uNfT4fpk6disceewyO4+Djjz8GAPz85z/P9R4OHToUCxcuxFlnnYX169c3+zqmTp2aO8fe5xw0aBDGjh3b5HM3bNiA2267DYB3g3XmmWfmcmfXP282TyHgrU9dtmxZs2UCvB7Q8ePHN7rG+dlnn8Xs2bMBtP493F/33HMP1qxZAwAoLS3FjBkz8Nvf/hZfffVVbkpvVzFUA/0L+iNoBBE0ghhQMAB9In3QI9gj76dnuCd6hHqi1Ffa4LGWfrzn9PSO0crntKpxnSE0BbNu/i38fj/+54EHIFQFQtcgNA1wCVC8NdGdcU19+fkmpB0XP/vZz5BIJCAlYeCRR+Guu3/f4dfU/po8eTIURcEHH3zQ4LFf/epXePPNNwE0/j65roudO3c2eeygqcKVBEUIaAdTVFK237I3s9n11/t6I6brfmhqAfzB3vvVuN4fqqlBEQJO2s5FD88iIpDtejmEY5aXy1oRUAI61LDhdV6qCkyhgEwNFhFSCqAJAX0fr5m9G7RCCBT4de9jkfxe2kbXQlWqCrZseUpswk7AkV6DPG0TVEXAaCGiuarp8EciMPytH5n0+f2AqiIdj2fKrYPIBaBAaWRaezYiuqZpIMdBsq4WyoD+CM24FvoRR8B+bQXwxBIEPtgE//e74T9hHNTDGh/cyDI0BbqqICklkJm+vzeypZdXWm3875OyXVTHLSgCKAlmG9et4zWMCZAEQzGgCAVpJxPHyIx4abkMr4Mg7aYhIGCq3iAWuV65mu3QVhTAX9imxjUA+DQVYZ+XqiuaclCXslEZTSOWdlAa9DXIa90UwzCgKEpuWQjQttHI9padbXKopuU6FHSLBnZzfvOb3+Af//gHli1bhqKiIgDA0qVLG11fzRo3bNgwPP3001i0aBEWLlwIy7Jyj7355pu44IILMHPmTEyYMKHZYxx11FF46KGHcje2H330EZ544om8/b755hvMnz8f3323J0fkihUrEA6HcdxxxwHwbt4XLVqU15D9+OOPG0yv3tspp5yCCy64ALNnz8auXbsAAC+++CJeffVV3HPPPc32iO/evRt33303Nm7cmFcuTdNwyimn5LYNHDgQ3377LQBgyZIluP3225stU9aCBQuwbds2zJ07N/e6Pv30U0yfPj0XL6C17+H+WrduHe64445cJ4ZlWXj77bcxevTobjFFNqAHYKomTNVEoJmpYkJVGr3JaAm5BNHEDUh7EKqCYUcNxVNPPIVFixbh3sWL4Wa+JMmVWPmvtzvtmjrphONBBCx/7TUsWrQIVubGoaZqV4dfU/tr0KBBmDFjBhYtWoT33nsPgNcoeOCBB/DCCy/krpuzzz4bAHDHHXfkrq3bbrstN8W8MX5dhSIETI0b1yxfdnQj+z24r6NHQlEQLCyFGQi2Z/HaVgZN8fI/J1K50XhyJGTSgYzakEkv3ozIpE1qbOmKpghomkDar8HWFPjbuUNKVxUEDBXxtANNGCjyFUEIgZpUDRJN5VkG4EgHcTuOgBaAKjSkHRf+Vs5maiz/dnM0TYPp8yOdSsO20hDCa3gpSuN5vFOpFKTrQqZTsNMpGIEAApECaD16wP+fv4A26mg4Gz+BePFVKMEQfJMnNjhOYwKGCgeA5TbdwBa60ujncjRlozZpw9RUFLey0Zkn851JrjfCa6omUm4q85gGBHsAmZlmKScFU9sz5bwjv3MVRcBnqNAUBX5dQdJy4ZJEUcBAYaD1f2chBEzThOM4uZzTXTmjSQgBXW9bPWUHmH0LVN45rr32WioqKqIHH3yQHn300dzPL37xizanHDpU03TV9/nnn9Pll19OZWVlVF5eTqNGjaJJkyblUulkjRs3jnr16kUAqLy8nJ5++mkiItq0aROdccYZ1KtXLzrppJPooosuomnTpuX2e/XVV2nz5s101VVX0YgRI6i8vJxGjhxJkydPplWrVuWOv3jxYjr11FNp5MiRVFFRQSNGjKDf/va3jaZl21symaQbb7yRhgwZQkcffTSNGTOGnnvuuRafV1lZSTfccAONGjWKKioqaNSoUXTiiSfSiy++mLffqlWrqKysjEaMGEGjR4+mNWvW0D/+8Q8qLy8nANSrVy8qLy+nDz74oME51q5dS6effjr17duXxowZQ+PGjaNnn302b5/WvIe/+93vaPDgwQSABg8eTHfeeSe99tpreWWYOnUq1dXVUXl5OQWDQQoGg1ReXk67du2iN954gy688EIqKyujiooKKisro2nTptG3337b4vvUGp2RCoGISFqOlzqkkbQizXHq0uSmmk7tsb+kK8mpTZGbdhpeUyOPpkkTJ3bqNbWzLkX3//8folNPPZXKRoygkaPKO+Waevjhh2n48OEEgA4//HCaPn06bdq0icrLy0nXdSoqKqJx48blXn9RURHpuk7l5eX04Ycfeu+llHTvvffS8OHDaciQIVRRUUEXX3wxbd26Ne9cjzzyCA0fPpwGDBhAEyZMoNtuu4369u1LRUVFdMIJJxAR0bHHHpt3jk2bPqXbbrst71qaP39+i6+LHfwSiUQubVRX29/P01Q0SdXf7aK6XTXk1KXJqU3lPgNb+9lZY9m0LWXRtpRFbhtSjLWWlJIqoynaHUvnfq9L19GO+A6qSdWQKxu+9qpkFVUmKklKSfG0Tdtrk42mmGovyWSSdm77nmLVVeS6KUqltpNtxxrsl4jHqXL7NqrZuYMSdbXkNpZyTEpKrXidYrfMIuvd99tUjspoiqp2xRuk68ql0rLz3yvXlVQVS9P22iTF9vN7z4mmyU14x7BcK5duzDuPV09TVipvOxGRU5smN9X21GutZTkuba9NUtJyyHZcqoqlqSrW8ndbY7Ip41KptqWhY91fd0vTJYhamUuik3344YcoLy9v8vGf/vSn+Mtf/tLq49XV1aGgoAC1tbVtDnLWWbLRfIuLi3mtIOu2OquekiTIWAuBU5p8jt5kFNb24MZtCAEo9XrQyZaQSRtKqPVrv9tDNGUjabvoGfahJmGBCCgK8rQz/jxlTcmm8VRVFcFg141AA/tfT13HRXRnjRd3JuDzRjhbmEa9t5QrUeO4MBWBIr1jps1ajkR1wkLYp+WCVaWcFKJW1JtKbhZAz4wYJ+wEYnYMhWYhDNXA7lgaqiJQGOi4zzXXdRGtqwVsG8GCQkBJQtPCXkqpjEQ8hmh1NUzTRDASgW76Wjoo0MYZEknLRW00jSJFwCjw5b5LZMoB2RJqeM974LgSNUkbkggFfr1NU8IbI5MOyJVQQ945did3Q1M0FJgFuXqqh3TYZKPU76WXJFdCxu1GZ0e0p6q4Fw++wK+jMpbOq0dt4TgOkskkAoEAr30+yHTGd35b2pLdIshZY0aNGtXqPJKMsYOPUASgCG/6WWtnUrmZz4wOnCIOAEITIGuvPNetWYfWAUxNRcJyYTkSliv36aaDsUNJ9sb6YOh4UTUVwdIIVG3fp7waioACwN+B74ehKfAbKmIpB6amQlUEfJoPuqKj1qpFTaoGQT0IUzURt+PwaT4YqgHblXAkIWh27OeaqqrQDRNp24adTiEQKcw9JqWLRDSKWF0dfP4AIsVFUJRWNM72oQHn0xVEdQWJlAvdkRCZyNjZ6eFZKdtFXdKGqgiUBM22TwlvtLwCsCkXCMyv+RG347l7cSJC2k3nLe2iTvrODRgqapM24pa37MG3j50Jmqa1KlAyY/vrwP92YYwdtNq6Dptk5zRyhao0CETT0Wu/m2JoChQhkLAcEIGDejHWAlVVIYQ4aEawdGPfIqFnKUKgp6nDp3bsLWHY9HI31yX3BDhTFRVFZhF8mg8xO4bqdDWEEAjpXkCtpO1CEQK+NmaT2Be6rkPRdTiWBSezRt9OpRCvqUEiHoc/FEZBSUnrGtf7SAiBoKnBkhKu5cXUIMcLfJZtYMfSzv6tt27q3Nnvr0yj2VRNECi3FtuWNiTJXBaQ3L6K6PA0U6amQAggYbnQVaXJKPeMdRfcwGaMdVtCE4AkkGzlbJbMl32HUwUA4Y1aI5OL3SWgg29Qm2LqCtKZxr7RRWVg7EAhhEAgEOAgQ51MCIGIX4PlSiQzjcfs9rARRoFZAACIGBEoQvECitkufB243Kc+XdehajqkELCSCSTqapFOxOESwRcMIRRpfXqx/REwVEBXkEjamWjw0pvNJQRqEhbiaQchU0NBQG/f8iiZ77XM962qqDAUIxdNPOWmoCkatHqR1cmVHTo1PEsIkQty11n1gbH9wbWUMdZ9ZRuLbutGsTtrFFkI4U0TdzINf0kAumYEG/B69wFvJIp79hlrWXYUm3UuU1Ph01VE0zbcvTpOTdVEqb8UhuqtAU47EkRodfTw/SWE8FI3KSqk6wJEUH0+KLrh5bvupBkPQgj4fRpSlgtpS5Aj4SpAVcKC5UoUBvQOmTIvhPBaBe6ev4upmbCkBVvasKQFn7pn9Jqkl9ars773AoYGQ1X2eXo4Y52JG9iMsW6r/jrslpAkbxpdZzVyNQVwvfVqXvmazk/a0UxNhRA8es0Y6/7CmcZhNNV8LuxkZjqw1omfa7quQ1FV6IEAjGAItuPCMIxOn+0Q8huAEEhELaQsF9WZEf/igLHfwcyaI1QlNzMLAHyqDwICdek67/f608OzHSSdFMtAVQSKggZ3IrMDAt+NMca6tVavw+7kL3uhKgAIcAhwJKB2/Dq05hT6DQRN7tlnjHVviiIQ8elIOxIp2210H1cSLFd22uh1lqZpUBQFrvTyXauqCtM0O7UMgPcemX4NiZSNqOXAZ2goCRod39mgZpZlZQKbCSFgqAZccmEoBhSx5/y5wJ5d1LHMWHfGDWzGWLfW2nXY2VHkzvqyF6oAhLcOu6sCnNVnaJ070sMYY/vKp6vwaSrqUjZkI5/tSduFQNest9V1HY7jgIjg9/u7rOM06NcBAYSCRvuvt27C3oHOAMCv+QF4U/jrI6frv/cY6674bowx1r21dh22Kzt9irbQFC8ADVFmRJsxxlhrhH3ZqeJOg8eSlgtT75p18rquQ1VV+P3+Lk3lppkqehQFEAx1XP7vBvYKdAYAhmqg0Cxs0MDuysCejHV3fGUwxrq11q7Dpk4MtpIlNAFQ5+QBZYyxg0l2qnjKcfOmiqcdF5Ko06eH7ymXgmAw6AU860JCCCh+rcPTTu59zr0DnQHIBZ7L8r6PeQSbsaZwA5sx1u21tA6byItm2ikpuurL9t53Qu5txhg72Ph0FYaqIJpyclPFU5aEqggYnZD+iTUktPxAZ43JPc4NbMYaxZ9ejLFur8V12Jne9k4fwc6MrndGHlDGGDsYRfw6iAjRtNfITjtul41eM3gd1fUCnTXK9Tq0OdUdY43r2vkvjDHWGrl12I2PUuca3l0wiqwEvEA0jDHG2k5VBEI+zVuLTQCh83Jfs4aEKkCA932rNf7lRq7kuCOMNYOvDtbA+PHj0bt3727bM1lTU4OLL74YQghs3bq1q4vDOsGeddhNTFvrwt500Yrz8jXFGGNNCxgadFVBynFhagrnOu5KjQQ6q49kZkkWTw9nrEncwD6EfPHFF7jyyitRXl6OiooKDBo0CBUVFbj22muxfPly2LYNAFi5ciWuvPLKLi5t41555RWMGTMG69ev75Dj33PPPXj22Wc75Nhs/zS3DruretP5mmKMsfYR8WlQhEDA4MmVXUkI4TWem4p7IrNLsrgJwVhT+Oo4RCxZsgSjR4/G0KFD8c4772DdunXYvHkzHnvsMaxevRqTJk3Ciy++2NXFbNG8efPw97//HRdccEGHHJ8b2N1XU+uwvQBn6PTedL6mGGOs/Wiqgh5hk4ObdQNCbWYE25VeYE8ewWasSdxNeAj46KOPcPHFF+P666/HjBkz8h4bOXIkli5digEDBnRN4dpoxYoV0DQNzz33XFcXhe0LKYHdu/fxuQTELSCmA3q9GzBXAgkbwq8D+3pjVlICtCHfKV9TjDHGDlr1Ap01WNrURCwUxtge3E14CJg3bx7S6TSuueaaRh/v2bMnZs2ahX79+jV7nNdffx3nnXceRo8enfu57777IGX+NKJ//vOfOOmkkzBmzBiUl5dj4sSJePjhh3OPx2IxXHPNNTj66KMxevRolJeX4+qrr8bmzZtbfC37k5dy7dq1mDRpUq7sJ510Eu68804AwKeffoqKigp8//33eP7551FRUYGKigr89a9/xZNPPomKigoIIXDrrbdi9uzZOPHEE1FQUIDCwsLc8desWYNJkyZh4MCBGDhwIM444wysW7euze/hDTfcgCOPPBJCCCxZsgSXXHIJRo4ciYEDB2Lx4sUAgLvuugsnnHAC+vXrh+nTp8NxnLzz/OEPf0BFRQXGjBmDUaNGYerUqXjjjTf2+b1rN7t3Az177tOP6N0L6uDDIfr2zt9+WG9ve5/e+3zstjb6+ZoCFi5ciLKyMggh8MADD+CXv/wlRo8ejb59+2L+/PkAgL/+9a+YMGEC+vbti0svvRSxWCzvGESEhQsXYtiwYRg2bBgGDRqE6667DolEIm+/+fPn47jjjsPYsWNRXl6O008/He+++27u8WQyiYqKChQXF2PAgAFYtmwZJk+ejB/84Ac45phjsGbNmn16jYwxdijKjU67DUexySVvRhljrGl0iKitrSUAVFtb2/YnP/440X33dfiPu2gRRe+4g9xFixrf5/HH21x013UpHA7ToEGD2vS8WbNm0d7V44orrqCZM2eS67pERPTNN9/Q4MGD6Z577snt8+WXX5JhGLRixYrctt///vfUv3//3O+XX345TZ48mSzLIiKibdu20VFHHUWLFy9uc/m2bNnSqv3r6uqoqKgo7xx///vfG7zG/v37009/+tNGjwGA+vTpQy+88AIREW3evJmKioqIiGjNmjVkmibNnDkzt//1119P4XCYPv/889y21ryHREQrVqwgAHTyySfTjh07iIjovvvuIyEE3XjjjbR69WoiIlq/fj0JIfJe12OPPUY9e/bMPS+VStGFF17Y5OtqK9d1qbKyMvca2mTnTiKg+/3s3Nmm18/XlGfLli0EgI4++mj67LPPiIho6dKlBIBmzJhBS5YsISKi7777jsLhMM2aNSvv+dOnT6dAIEBr1qwhIqLt27fT8OHDacqUKXn7RSIRWrt2be73xx9/nMLhMH3zzTd5+/30pz+lSCRCM2fOJMdxaMeOHXT++efTwIEDyXGcVr8uxjrLfn2eMtaBnNo0uSnvczNbTx3LIac2RdLm+sq6l874LG1LW5JHsA9yu3btQjQaRa9evfb7WL/+9a8xZ84cKJmptP369cMFF1yABx98MLfP+++/D8uycNRRR+W2XXXVVfjZz36W+3316tXo378/dF0HAPTu3RsLFixAWVnZfpexKZ9++imqq6vzynX++efj17/+dZuOM3LkSJx99tkAgIEDB2Lt2rUAvFHnYDCIefPm5fadO3cuiCg3mge07j2s77zzzkPPnj0BABdddBGICJ988gmOP/54AMCoUaNQVlaGZcuW5Z6zevVqFBYWorS0FABgmiZmzZqF008/vU2vlTWOr6mGTj311Fz5zjrrLIRCISxfvhw//vGPAQB9+vTBySefnFdPv/zyS9x777247LLLcOyxxwIAevXqhZtvvhkvv/wyVq5cmdt3zZo1GDt2bO73f//3f0cgEMDjjz/eoCzRaBQ33ngjhBBQFAUXXnghtmzZ0qrRfMYYYxmq8JZg1ZPL5MFTxBlrFq/Bbo1///fOOY+USFVVIVBc3Kb1oM1pz7RAkUgEt912G5YtW4ZEIgFVVbF9+3ZUV1fn9jnuuOMQCoVwwgkn4Oqrr8b555+Po446Crfeemtun4kTJ2LRokWora3FtGnTMHHiRJx77rntVs7GDBs2DH379sW5556L//zP/8SFF16IUaNG4bbbbmvTcUaOHJn3++DBg5FIJPDWW29h0qRJ8Pl8uccCgQAGDx6M1157LbetNe9hfUOGDMn9v7i4uME2ACgpKcG2bdtyv0+cOBH/8z//gxNPPBFXXHEFfvSjH2HEiBEYMWJEm14raxxfUw3tXSeLi4sbraeffPJJ7vdly5ZBSolx48bl7Xf00UcDAF577TWMHz8eABCPxzF16lRs2rQp1xlRVVWFL7/8skFZSkpKUFpamptmn+1o2r59e14nBWOMsaYJVTTM3CEzKTG5gc1Ys3gE+yBXUlKCcDiMHTt27NdxiAjnnHMOnnrqKTz++OPYsGED1q1bhyuvvBKWZeX2O/zww/Huu+9i8uTJuP322zFkyBCMGTMGL7/8cm6fhQsX4oEHHsCXX36JH/3oR+jZsyeuuuoq1NXV7VcZmxMKhfDOO+/gkksuwYMPPojy8nIMGTIEjz76aJuOEw6HG2yrrq6GlBJr167Nrd3O/lRVVeVu9Fv7HtYXDAZz/8827Opvy253XTf3+49//GO8+uqrKC4uxi9+8Qv07t0bZ599Nj777LM2vdYOUVIC7Ny5Xz/u5m8hv/4e2LkTtG0H3C+/AX2/ff+OW1LShpfA19TeGquTLdXTXbt2AQBuueWWvGvm0ksvRa9evRCPxwEAGzZswLhx41BaWoq1a9di3bp1WLduHfr06YN0Ot1iWbIN8vrnZowx1gKlYeYOcojTczHWCnyVHOQURcGUKVOwZcsWbN++vcn9VqxYgU2bNjX5+BdffIGVK1fiiiuuwODBg5s959ChQ/HnP/8ZO3bswJNPPolUKoVzzjkHn376aa5Mv/jFL/Dee+9h06ZNuPzyy/Hggw/i6quv3rcX2Up9+vTBPffcg++//x4vvvgiSktLMW3aNCxfvny/jltUVARFUTBhwoTczX/25+uvv8ZXX30FoG3v4f6aNGkSXnrpJWzbtg0LFizAqlWrcPrppzcIntXpFAXo0WO/fkTvXqCiEu/3khKgtAfQq+f+HbcNM0b4mmof2ZHlu+++O++a2bBhA7Zv354LQPjEE08glUph7ty5ME2zK4vMGGOHjFxDOtPAJiIvEwin52KsRdzAPgTMmTMHfr8f9913X6OPr169GqeddlqzI3LZkSJlr4ZI/anJALB8+XI89NBDAACfz4epU6fiscceg+M4+PjjjwEAP//5z3NRgocOHYqFCxfirLPOwvr16/ftBbbChg0bctPBNU3DmWeeiaVLlwJA3nl1Xfe+RABUVlbmrRltSiAQwPjx47F+/foGDdhnn30Ws2fPBtD693B/3XPPPbmoyaWlpZgxYwZ++9vf4quvvkJNTU27nqsr1M+HTS55+Tg7eboaX1P7b/LkyVAUBR988EGDx371q1/hzTffBND4++S6Lnbu3Nk5BWWMsUOQF0lceN+zQC6iOOe/Zqxl3MA+BAwbNgxPP/00Fi1ahIULF+ZNP33zzTdxwQUXYObMmZgwYUKzxzjqqKPw0EMP5W5sP/roIzzxxBN5+33zzTeYP38+vvvuu9y2FStWIBwO47jjjgPgNRgWLVqU15D9+OOPMWnSpHZ7zXvbvXs37r77bmzcuDGvXJqm4ZRTTsltGzhwIL799lsAwJIlS3D77be36vgLFizAtm3bcoHNAC+w2vTp0zFmzBgArX8P99e6detwxx135BpclmXh7bffxujRo3PruA9o2V5112tgd8WXPV9T+2/QoEGYMWMGFi1ahPfeew+AN0LywAMP4IUXXshdN9mggnfccUfu9d12221IJpNdU3DGGDtU1A90JgFA8BRxxlqjgyKZdzv7laark3R0iPnPP/+cLr/8ciorK6Py8nIaNWoUTZo0KZdKJ2vcuHHUq1cvAkDl5eX09NNPExHRpk2b6IwzzqBevXrRSSedRBdddBFNmzYtt9+rr75KmzdvpquuuopGjBhB5eXlNHLkSJo8eTKtWrUqd/zFixfTqaeeSiNHjqSKigoaMWIE/fa3v6V0Ot3ia5gzZw6Vl5fnyjd8+HAqLy+nDz74oNnnVVZW0g033ECjRo2iiooKGjVqFJ144on04osv5u23atUqKisroxEjRtDo0aNpzZo19I9//IPKy8sJAPXq1avJ861du5ZOP/106tu3L40ZM4bGjRtHzz77bN4+rXkPf/e739HgwYMJAA0ePJjuvPNOeu211/LKMHXqVKqrq6Py8nIKBoMUDAapvLycdu3aRW+88QZdeOGFVFZWRhUVFVRWVkbTpk2jb7/9tsX3tzW6Q1oZJ5omN2mTU5cmN2V3WTkO5Wvq4YcfpuHDhxMAOvzww2n69Om0adMmKi8vJ13XqaioiMaNG5d7/UVFRaTrOpWXl9OHH35IRERSSrr33ntp+PDhNGTIEKqoqKCLL76Ytm7dmneuRx55hIYPH04DBgygCRMm0G233UZ9+/aloqIiOuGEE4iI6Nhjj807x2effUa33XZb3rU0f/78Ft8PxjpTd/g8ZawpbtL2vm9dl3Z+vZ3saKqri8RYo7pbmi5BRA2zyB+E6urqUFBQgNraWkQika4uTqOklKiqqkJxcXGDaaOMdRfdoZ7KpONFNyWC4tchdL5eWL7uUE8ZawnXU9adke1CJh0goKHqu0oU9SyG5je6uliMNdAZn6VtaUvypzlj7IAjNAFk+wZ5PRhjjDHW/jINlWyHtuBOIMZaha8UxtiBJ7sGrAsCnDHGGGOHglygMyuzDps7tBlrFW5gM8YOOEIRXo5OblwzxhhjHUcVXnou7tBmrNW0ri4AY4ztC8XUAP6uZ4wxxjqMUAVgg0evGWsDbmAzxg5IHNiMMcYY61i5VJg8es1Yq/EdKmOMMcYYY6whVQGEADRuYDPWWtzAZowxxhhjjDUgFAE1bPD6a8bagBvYjDHGGGOMMcZYO+AGNmOMMcYYY4wx1g64gc0YY4wxxhhjjLUDbmAzxhhjjDHGGGPtgBvYjDHGGGOMMcZYO+AGNmOMMcYYY4wx1g64gc0YY4wxxhhjjLUDbmAzxhhjjDHGGGPtgBvYjDHGGGOMMcZYO9C6ugCdhYgAAHV1dV1ckqZJKRGNRqFpGhSF+z5Y98T1lB0IuJ6yAwHXU3Yg4HrKurvOqKPZNmS2TdmcQ6aBHY1GAQCHH354F5eEMcYYY4wxxtiBJhqNoqCgoNl9BLWmGX4QkFLi+++/RzgchhCiq4vTqLq6Ohx++OH45ptvEIlEuro4jDWK6yk7EHA9ZQcCrqfsQMD1lHV3nVFHiQjRaBR9+vRpcZT8kBnBVhQF/fr16+pitEokEuEPMNbtcT1lBwKup+xAwPWUHQi4nrLurqPraEsj11m8kIIxxhhjjDHGGGsH3MBmjDHGGGOMMcbaATewuxHTNDFr1iyYptnVRWGsSVxP2YGA6yk7EHA9ZQcCrqesu+tudfSQCXLGGGOMMcYYY4x1JB7BZowxxhhjjDHG2gE3sBljjDHGGGOMsXbADWzGGGOMMcYYY6wdcAObMdZATU0NLr74YgghsHXr1q4uDmOMMcY6wYMPPgghBGbPnt3VRWHsgMUN7G4glUrhpptuwtChQzFq1CiMHTsWzz//fFcXix2iXnnlFYwZMwbr169vdr9PPvkEZ555JoYNG4YhQ4bgoosuwnfffddJpWSHss2bN+Omm27C0UcfjZEjR2LYsGGYMmUKVq5c2WBfrqesq3z99df49a9/jWOOOQZjxoxBWVkZysvLce+992Lv+LJcT1l3UF1djd/85jdNPs71lHWVrVu3IhQKoaKiosHP3t/9q1atwsknn4wRI0ZgyJAhuOKKK1BTU9Op5eUGdjdw6aWX4rnnnsPbb7+NDz/8ELNmzcL555+PpUuXdnXR2CFo3rx5+Pvf/44LLrigyX2+/vprjB8/HiNHjsQnn3yCjRs3QgiBCRMmoK6urhNLyw5FV111FV555RX885//xEcffYQNGzZgwIABmDBhAp577rncflxPWVd67bXXcO+99+Lee+/F+++/j40bN2LWrFmYPn06br/99tx+XE9Zd3HLLbdg3LhxjT7G9ZR1tbFjx2LdunUNfsaPH5/b57333sPEiRMxdepUfPzxx1i3bh02bdqEKVOmwHXdzisssS71+uuvEwB64okn8rb/8Ic/pEGDBpGUsotKxg5Vtm0TEdGsWbMIAG3ZsqXBPpdddhkVFhZSMpnMbfvuu+9IURSaM2dOZxWVHaJ++MMf0pIlS/K2JRIJ0jSNxo8fn9vG9ZR1pZdffplmz57dYPuoUaNo9OjRud+5nrLuYP369dS7d2/64IMPCADNmjUr73Gup6wrbdmyhSZMmNDifqeccgoNGzYsb9vq1asJAD3yyCMdVLqGeAS7iz311FMAgIkTJ+ZtnzhxIjZv3ox33323K4rFDmGapjX7uOu6+Pvf/46TTjoJPp8vt71Pnz4YNmwYnnzyyY4uIjvEvfDCCzjvvPPytvn9fhQXF6O6uhoA11PW9c444wzMmjWrwfZoNIoePXoA4HrKuo9f/epXmDt3LgoLCxs8xvWUHQh27NiBN954o0Gb6thjj0U4HO7UesoN7C62bt06RCIRlJaW5m0fPHgwALS4DpaxzrZ582ZEo9FcHa1v8ODB2LRpE9LpdBeUjB0qdF2HECJvW1VVFSorK3HaaacB4HrKup9oNIpf//rXiMfjuOOOOwBwPWXdw5NPPom6ujr8/Oc/b/RxrqesO9ixYwemTZuG4447DkcddRTOOeccLFu2LPf4hx9+CCJqUE8VRcGAAQM6tU3FDewuVllZiUgk0mB7dltlZWVnF4mxZmXrZFP1VkqJqqqqzi4WO8Q98MADKC0txc033wyA6ynrXsrKylBUVITnn38eS5YswejRowFwPWVdL5FI4L/+67+waNEiKErjzQKup6yrqaoKKSX+4z/+A2vWrMGGDRtQUVGB008/HQ899BCAlutpZ7apuIHNGGPsgPb+++9jwYIFePLJJ9G7d++uLg5jDWzcuBGJRALXXXcdTjvtNCxYsKCri8QYAGD+/PkYN24cTjrppK4uCmNNOvzww/Hpp5/mApr5fD7MnTsXY8eOxcyZM7vdDApuYHex0tLSRqMvZrdl12kx1l1klzM0VW8VRUFxcXFnF4sdoj755BOcd955ePTRR3HqqafmtnM9Zd2NYRj42c9+hmnTpuHmm2/Gl19+yfWUdaktW7bgj3/8I+68885m9+N6yrqr448/HrW1tfjoo49arKed2abiBnYXq6ioQF1dHXbv3p23ffPmzQCA8vLyrigWY00aPHgwwuFwro7Wt3nzZgwbNgymaXZBydihZt26dZgyZQr+/Oc/4+yzz857jOsp62rJZLLRtDAVFRVwXRfvv/8+11PWpZYtW4ZgMIizzjorl1P4zDPPBOAtu6moqMBPfvITrqesy9XW1iKZTDbYrqoqAEBKifLycgghGtRTKSW2bt3aqW0qbmB3salTpwIAli9fnrd9+fLlGDRoEMaOHdsVxWKsSaqq4vzzz8fbb7+dNyVn27Zt+OSTT3J1mrGOtGbNGpx77rl49NFHMXny5Nz27Gcm11PW1aZMmZLLFFLf1q1bAXijglxPWVf6j//4D3z11Vd5OYVfeuklAMCVV16JdevW4cknn+R6yrrctddei4ULFzbY/u677yIQCGDEiBHo1asXTj755AZtqrVr1yIajXZqPeUGdhc75ZRTcMEFF2D27NnYtWsXAODFF1/Eq6++invuuadBpFzGuoM5c+ZAURTceuutICI4joOZM2di4MCBmDFjRlcXjx3k3nzzTUyePBnnnnsuvvrqKzz22GO5n/feey+3H9dT1tXmz5+fa1ADwBtvvIE//vGPOPbYY3HyyScD4HrKDgxcT1lX++Mf/4jPPvss7/e33noLt956KwKBAADgrrvuwpYtW3D//fcD8IL43XTTTTj++ONxySWXdFpZBRFRp52NNSqVSmH27Nl45plnYJomdF3HrFmzcM4553R10dghaO7cuViyZAm2b9+OHTt2YPjw4TAMA3/5y19QUVGR22/jxo24/vrrsWXLFkgpMXr0aNx9993o169f1xWeHRLGjBmDDz74oMnH63+tcT1lXWXVqlVYvHgxVq1aBVVVEY/HYRgGzjvvPNx88815kW65nrKuVlNTg1NOOQWWZeGTTz5Br1690Lt3b1x33XWYNm0aAK6nrOts2LABf/7zn/Haa69BCIGamhocdthhuOaaa3DxxRfn7btq1SrceOONqKqqgm3bOOWUU3DnnXc2muO9o3ADmzHGGGOMMcYYawc8RZwxxhhjjDHGGGsH3MBmjDHGGGOMMcbaATewGWOMMcYYY4yxdsANbMYYY4wxxhhjrB1wA5sxxhhjjDHGGGsH3MBmjDHGGGOMMcbaATewGWOMMcYYY4yxdsANbMYYY4wxxhhjrB1wA5sxxhhjjDHGGGsH3MBmjDHGGGOMMcbaATewGWOMMcYYY4yxdsANbMYYY6wDDBgwAGVlZaioqEBFRQWOPPJICCFwxBFH5LaVlZVhwIABAIB3330XRUVFeO6557q24I3YunUrZs+eja1bt3ZpOZYsWYLdu3d3aRkYY4yx5nADmzHGGOsgL730EtatW4d169bhoYceAgDMnTs3t+2ll17K7RsIBNC/f38UFBR0VXGbtHXrVsyZM6dLG9iJRAIXXXQRvv/++y4rA2OMMdYSrasLwBhjjB2MJkyYAL/f3+w+fr8fEyZMAACUlZVh3bp1nVCyA9M777yDYDCIESNGdHVRGGOMsSbxCDZjjDHWAR555BH06tWr2X169eqFRx55BM888wwqKioghMDs2bMBAE8++WRu26233opbbrkFxx57LHr37o0ZM2bAdV28/PLLmDRpEvr164ezzz4bO3bsaHCONWvWYNKkSRg4cCAGDhyIM844o0FD/rPPPsN5552HiooKjB49Gscccwxmz56NRCKBBQsW4PLLLwcAXH755bnp7TU1Na0+x4IFC1BWVgYhBH7/+99j2rRpGDNmDIqKinDOOefg66+/bvH9fPvtt3HCCSdAUfjWhTHGWDdGjDHGGOtwK1asIAC0ePHiJvcBQLNmzWqwrX///rR69WoiIlq/fj0pikJXX3013XfffUREVFtbS4MGDaKf/vSnec9ds2YNmaZJM2fOzG27/vrrKRwO0+eff57bduSRR9Ls2bNzv69atYpM06QtW7bklX3FihUNytzac2zZsoUAUGlpae61VFVV0ejRo2no0KFk23aj78nixYvp4osvptLSUjruuOPo4osvpuXLlzfxDjLGGGNdi7uBGWOMsW6uvLwcxx9/PABg1KhRKCsrw//93//hiiuuAABEIhFMmTIFy5Yty3veDTfcgGAwiHnz5uW2zZ07F0SE+fPnAwB27dqFL774AkceeWRunxNOOAG33XYbIpFIi2VrzTnqO/fcc3OvpaioCLNnz8ann36Kv/71r40e/7LLLsOjjz4K13WxYMECPPbYYzjttNNaLBdjjDHWFbiBzRhjjHVzQ4YMyfu9uLgYgwYNgqbtCaVSUlKCbdu25X5PJBJ46623MHbsWPh8vtz2QCCAwYMH47XXXss9r6KiAldccQVmzJiBf/3rX5BS4vrrr0dxcXGz5WrtOeobNWpU3u/HHnssAGDVqlVNnufjjz9GLBbDMccc02x5GGOMsa7GQc4YY4yxbi4YDOb9LoRodJuUMvd7dXU1pJRYu3YtKioq8vatqqqCECL3vNdffx133XUXHnnkEdxzzz3o27cvrr/+ekyfPj23X2Nae4769h4Vzzbiv/vuuybP89Zbb2H06NF5jXjGGGOsO+IGNmOMMXYQKioqgqIomDBhAp555plm9y0oKMC8efMwd+5crFy5EnfeeSeuu+46RCIR/PznP2+Xc2TV1tbm/Z7Na923b98mn7Ny5UqceOKJrTo+Y4wx1pV4ijhjjDF2EAoEAhg/fjzWr1+fN7INAM8++2wuWvnOnTtx7bXXAvBGs08++WQ899xzKCwsxPr16wEAuq4DAIgIAPDee+/hs88+a/U56tuwYUPe7++88w4ANNuAfvvtt3OPP/74462KOs4YY4x1BW5gM8YYYwepBQsWYNu2bbmgYwDw6aefYvr06RgzZgwAbx31H//4R7zxxhu557333nuIRqOYNGkSAGDAgAEQQuDbb78FAFxzzTX417/+1epz1Ld8+fLcc6urqzFnzhwMHToU06ZNa/J1VFZWoqysDNFoFJ9//jmOOOKI/X1rGGOMsQ4hKPttyBhjjLEOccEFF2DdunX48ssvcfjhh2PIkCF5Eb+feeYZzJkzB+vXr0evXr0wcuRI3HDDDbjxxhtz2yZMmICHHnoI48ePxxdffAEAOPLII7Fy5UpcfvnleOONN7Bjxw6Ul5fjv//7v/HDH/4QAPDuu+/iN7/5DT7++GP06tULgUAAM2fOxLnnngsASCaTuPPOO/H888/DdV0AgKZpuPbaa3HppZfmyjh79mwsXrwYkUgEw4YNw2OPPQbTNFt1DgDYunUrBg4ciP/5n//Bhx9+iLVr12LLli0YN24c7rvvvmYbzb/73e/w9ddfo0+fPrj++usRDofb6S/DGGOMtS9uYDPGGGOsw2Ub2IsXL8Zll13W1cVhjDHGOgRPEWeMMcYYY4wxxtoBN7AZY4wxxhhjjLF2wA1sxhhjjHWoBQsW4MwzzwQA3Hrrrc0GNGOMMcYOZLwGmzHGGGOMMcYYawc8gs0YY4wxxhhjjLUDbmAzxhhjjDHGGGPtgBvYjDHGGGOMMcZYO+AGNmOMMcYYY4wx1g64gc0YY4wxxhhjjLUDbmAzxhhjjDHGGGPtgBvYjDHGGGOMMcZYO+AGNmOMMcYYY4wx1g64gc0YY4wxxhhjjLUDbmAzxhhjjDHGGGPt4P8D2vyHb1nxr6wAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -227,13 +236,13 @@ } ], "source": [ - "x, y = make_simple_gaussian_streams_2d(n_samples=200, timesteps=10, mean_shift=0.4)\n", + "x, y = make_toy_dataset( 200, timesteps=50)\n", "plot_2d_streams(x, y)" ] }, { "cell_type": "markdown", - "id": "09d83842-24b9-412e-b5b5-b7af9e2275a1", + "id": "a553c4d2-1643-403d-8388-32c1de0d65ba", "metadata": { "jp-MarkdownHeadingCollapsed": true }, @@ -242,285 +251,470 @@ ] }, { - "cell_type": "markdown", - "id": "0e90daa3-5b2b-4139-bde7-3c5b28b7e297", + "cell_type": "code", + "execution_count": 5, + "id": "93e90663-c372-4fec-ac2e-0d7ae81ac9d8", "metadata": {}, + "outputs": [], "source": [ - "defining the SNN here where the forward pass loops through all timesteps in the data" + "def to_torch(x: np.ndarray, y: np.ndarray) -> tuple[torch.Tensor, torch.Tensor]:\n", + " return torch.from_numpy(x).float(), torch.from_numpy(y).long()\n", + "\n", + "\n", + "def fake_quant_ste(x: torch.Tensor, frac_bits: int) -> torch.Tensor:\n", + " scale = float(2**frac_bits)\n", + " q = torch.round(x * scale) / scale\n", + " return x + (q - x).detach()" ] }, { "cell_type": "code", - "execution_count": 43, - "id": "277f1a94-1c6d-42bd-b8d0-5a65c487f4fd", + "execution_count": 6, + "id": "93a37232-acc0-4867-a097-7db54cbd33ba", "metadata": {}, "outputs": [], "source": [ - "class SNN_LIF(nn.Module):\n", - " \"\"\"\n", - " SNN model using snnTorch Leaky neuron in IF-equivalent mode (beta=1).\n", - " This is the one we use to optimise the weights\n", + "class SNN(nn.Module):\n", + " \"\"\"Sequence model used for training/evaluation.\n", + "\n", + " Output decision uses output-layer membrane potentials:\n", + " mem2(t+1) = mem2(t) + fc2(spk1(t)); class = argmax(mem2(T)).\n", " \"\"\"\n", "\n", - " def __init__(self, hidden: int = 16, threshold: float = 1.0, beta: float = 1.0):\n", + " def __init__(self, hidden: int = 4, threshold: float = 1.0, beta_init: float = 0.1):\n", " super().__init__()\n", " self.fc1 = nn.Linear(2, hidden)\n", - " self.if1 = snn.Leaky(beta=beta, threshold=threshold, reset_mechanism='subtract')\n", + " self.if1 = snn.Leaky(beta=beta_init, threshold=threshold, learn_beta=True, reset_mechanism=\"subtract\")\n", " self.fc2 = nn.Linear(hidden, 2)\n", "\n", - " def forward(self, x_seq: torch.Tensor) -> torch.Tensor:\n", + " def forward(self, x_seq: torch.Tensor, qat: bool = False, frac_bits: int = 4) -> torch.Tensor:\n", " # x_seq: [B, T, 2]\n", - " bsz, _, _ = x_seq.shape\n", - " mem = torch.zeros(bsz, self.fc1.out_features, device=x_seq.device, dtype=x_seq.dtype)\n", - " out = torch.zeros(bsz, 2, device=x_seq.device, dtype=x_seq.dtype)\n", + " batch = x_seq.shape[0]\n", + " mem1 = torch.zeros(batch, self.fc1.out_features, device=x_seq.device, dtype=x_seq.dtype)\n", + " mem2 = torch.zeros(batch, 2, device=x_seq.device, dtype=x_seq.dtype)\n", "\n", " for t in range(x_seq.shape[1]):\n", - " cur1 = self.fc1(x_seq[:, t, :])\n", - " spk1, mem = self.if1(cur1, mem)\n", - " out = out + self.fc2(spk1)\n", - " return out" - ] - }, - { - "cell_type": "markdown", - "id": "ed20e49f-cdbd-4eb2-9682-823e19838a97", - "metadata": {}, - "source": [ - "making a single-step SNN here, because this is the version that will be used with hls4ml" + " xt = x_seq[:, t, :]\n", + " if qat:\n", + " xt = fake_quant_ste(xt, frac_bits)\n", + " w1 = fake_quant_ste(self.fc1.weight, frac_bits)\n", + " b1 = fake_quant_ste(self.fc1.bias, frac_bits)\n", + " cur1 = F.linear(xt, w1, b1)\n", + " else:\n", + " cur1 = self.fc1(xt)\n", + "\n", + " spk1, mem1 = self.if1(cur1, mem1)\n", + "\n", + " if qat:\n", + " spk1 = fake_quant_ste(spk1, frac_bits)\n", + " mem1 = fake_quant_ste(mem1, frac_bits)\n", + " w2 = fake_quant_ste(self.fc2.weight, frac_bits)\n", + " b2 = fake_quant_ste(self.fc2.bias, frac_bits)\n", + " mem2 = mem2 + F.linear(spk1, w2, b2)\n", + " mem2 = fake_quant_ste(mem2, frac_bits)\n", + " else:\n", + " mem2 = mem2 + self.fc2(spk1)\n", + "\n", + " return mem2" ] }, { "cell_type": "code", - "execution_count": 44, - "id": "bf527b56-c244-47c5-8c4f-84684c0aa6c0", + "execution_count": 7, + "id": "17eb8c99-2123-46d4-b134-ca47a040ef15", "metadata": {}, "outputs": [], "source": [ - "class SNN_LIF_step(nn.Module):\n", - " \"\"\"\n", - " Single-timestep model for hls4ml conversion: 2 -> Dense(16) -> IF -> Dense(2).\n", - " This is the one we use to put through HLS in stream mode\n", - " \"\"\"\n", + "class SNNStep(nn.Module):\n", + " \"\"\"Single-step model for hls4ml conversion: 2 -> Dense(4) -> IF/LIF -> Dense(2).\"\"\"\n", "\n", - " def __init__(self, hidden: int = 16, threshold: float = 1.0, beta: float = 1.0):\n", + " def __init__(self, hidden: int = 4, threshold: float = 1.0, beta_init: float = 0.1):\n", " super().__init__()\n", " self.fc1 = nn.Linear(2, hidden)\n", - " self.if1 = snn.Leaky(beta=beta, threshold=threshold, reset_mechanism='subtract')\n", + " self.if1 = snn.Leaky(beta=beta_init, threshold=threshold, learn_beta=True, reset_mechanism=\"subtract\")\n", " self.fc2 = nn.Linear(hidden, 2)\n", "\n", - " def forward(self, x: torch.Tensor) -> torch.Tensor:\n", + " def forward(self, x: torch.Tensor):\n", " x = self.fc1(x)\n", " x, _ = self.if1(x)\n", " x = self.fc2(x)\n", - " # neurobench requires 2D output from the single step NN\n", + " # keep compatibility with step-style SNN wrappers (neurobench) that expect tuple outputs.\n", " return x, None" ] }, { - "cell_type": "markdown", - "id": "170c299c-ace5-40fd-82ca-bf10ac18ebfd", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, + "cell_type": "code", + "execution_count": 8, + "id": "8dde4af7-749c-4d8a-a150-7274f79daffa", + "metadata": {}, + "outputs": [], "source": [ - "## train function" + "def quantize_trainable_beta_inplace(step_model: SNNStep, frac_bits: int) -> None:\n", + " scale = float(2**frac_bits)\n", + " with torch.no_grad():\n", + " step_model.if1.beta.data = torch.round(step_model.if1.beta.data * scale) / scale\n", + "\n", + "\n", + "def reset_step_state(step_model: SNNStep) -> None:\n", + " if hasattr(step_model.if1, \"reset_hidden\"):\n", + " step_model.if1.reset_hidden()\n", + " elif hasattr(step_model.if1, \"reset_mem\"):\n", + " step_model.if1.reset_mem()\n", + "\n", + "\n", + "def sequence_logits_from_step(\n", + " step_model: SNNStep,\n", + " x_seq: torch.Tensor,\n", + " qat: bool = False,\n", + " frac_bits: int = 4,\n", + ") -> torch.Tensor:\n", + " \"\"\"Unroll step model over T and accumulate output-layer membrane proxy.\"\"\"\n", + " reset_step_state(step_model)\n", + " mem2 = torch.zeros(x_seq.shape[0], 2, device=x_seq.device, dtype=x_seq.dtype)\n", + "\n", + " for t in range(x_seq.shape[1]):\n", + " xt = x_seq[:, t, :]\n", + " if qat:\n", + " xt = fake_quant_ste(xt, frac_bits)\n", + " w1 = fake_quant_ste(step_model.fc1.weight, frac_bits)\n", + " b1 = fake_quant_ste(step_model.fc1.bias, frac_bits)\n", + " cur1 = F.linear(xt, w1, b1)\n", + " spk1, _ = step_model.if1(cur1)\n", + " spk1 = fake_quant_ste(spk1, frac_bits)\n", + " w2 = fake_quant_ste(step_model.fc2.weight, frac_bits)\n", + " b2 = fake_quant_ste(step_model.fc2.bias, frac_bits)\n", + " out = F.linear(spk1, w2, b2)\n", + " out = fake_quant_ste(out, frac_bits)\n", + " else:\n", + " out, _ = step_model(xt)\n", + "\n", + " mem2 = mem2 + out\n", + "\n", + " return mem2" ] }, { "cell_type": "markdown", - "id": "63af4cf3-3a4f-47c1-a606-9c9540aa2067", - "metadata": {}, + "id": "3d7c1dc5-7ae9-4ab7-befe-8492fc6b1e13", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ - "very simple train function for testing purposes" + "## training" ] }, { "cell_type": "code", - "execution_count": 45, - "id": "edc0c97f-375a-4424-87ec-0b78e52c4bc6", + "execution_count": 9, + "id": "aa79dbb0-74ef-4121-bdf0-986c80d2cefa", "metadata": {}, "outputs": [], "source": [ - "def train_snn(\n", - " model,\n", + "def train_and_qat(\n", + " step_model: SNNStep,\n", " x_train: torch.Tensor,\n", " y_train: torch.Tensor,\n", - " epochs: int = 5,\n", + " x_val: torch.Tensor,\n", + " y_val: torch.Tensor,\n", + " epochs: int = 30,\n", + " qat_epochs: int = 10,\n", + " lr: float = 1e-2,\n", + " frac_bits: int = 4,\n", " batch_size: int = 64,\n", - " lr: float = 5e-3,\n", - "):\n", + " beta_reg: float = 1e-2,\n", + ") -> None:\n", " criterion = nn.CrossEntropyLoss()\n", - " optim = torch.optim.Adam(model.parameters(), lr=lr)\n", - "\n", - " n_samples = x_train.shape[0]\n", - " for epoch in range(epochs):\n", - " perm = torch.randperm(n_samples)\n", - " epoch_loss = 0.0\n", - " correct = 0\n", + " optim = torch.optim.Adam(step_model.parameters(), lr=lr)\n", + " scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optim, T_max=max(epochs + qat_epochs, 1), eta_min=1e-4)\n", + " train_ds = torch.utils.data.TensorDataset(x_train, y_train)\n", + " train_loader = torch.utils.data.DataLoader(train_ds, batch_size=batch_size, shuffle=True)\n", "\n", - " for start in range(0, n_samples, batch_size):\n", - " idx = perm[start : start + batch_size]\n", - " xb = x_train[idx]\n", - " yb = y_train[idx]\n", - "\n", - " logits = model.forward(xb)\n", - " loss = criterion(logits, yb)\n", + " for ep in range(epochs):\n", + " step_model.train()\n", + " for xb, yb in train_loader:\n", + " optim.zero_grad()\n", + " logits = sequence_logits_from_step(step_model, xb, qat=False, frac_bits=frac_bits)\n", + " loss = criterion(logits, yb) + beta_reg * torch.mean(step_model.if1.beta**2)\n", + " loss.backward()\n", + " optim.step()\n", + " scheduler.step()\n", "\n", + " for ep in range(qat_epochs):\n", + " step_model.train()\n", + " for xb, yb in train_loader:\n", " optim.zero_grad()\n", + " logits = sequence_logits_from_step(step_model, xb, qat=True, frac_bits=frac_bits)\n", + " loss = criterion(logits, yb) + beta_reg * torch.mean(step_model.if1.beta**2)\n", " loss.backward()\n", " optim.step()\n", + " quantize_trainable_beta_inplace(step_model, frac_bits)\n", + " scheduler.step()\n", + "\n", + " with torch.no_grad():\n", + " step_model.eval()\n", + " val_logits = sequence_logits_from_step(step_model, x_val, qat=True, frac_bits=frac_bits)\n", + " val_pred = torch.argmax(val_logits, dim=1)\n", + " val_acc = (val_pred == y_val).float().mean().item()\n", + " print(f\"[QAT] epoch={ep + 1:02d}/{qat_epochs} val_acc={val_acc:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2a30fbd6-be59-4bb5-a82f-d6f8b5542fe2", + "metadata": {}, + "outputs": [], + "source": [ + "def evaluate_torch_step(step_model: SNNStep, x: torch.Tensor, y: torch.Tensor) -> float:\n", + " step_model.eval()\n", + " with torch.no_grad():\n", + " logits = sequence_logits_from_step(step_model, x, qat=False)\n", + " pred = torch.argmax(logits, dim=1)\n", + " return (pred == y).float().mean().item()\n", "\n", - " epoch_loss += float(loss.item()) * xb.shape[0]\n", - " correct += int((logits.argmax(dim=1) == yb).sum().item())\n", "\n", - " print(\n", - " f'Epoch {epoch + 1:02d}/{epochs}: '\n", - " f'loss={epoch_loss / n_samples:.4f}, acc={correct / n_samples:.4f}'\n", - " )" + "def export_step_model(seq_model: SNN) -> SNNStep:\n", + " step = SNNStep(hidden=4, threshold=1.0, beta_init=float(seq_model.if1.beta.detach().mean().item()))\n", + " step.fc1.load_state_dict(seq_model.fc1.state_dict())\n", + " step.fc2.load_state_dict(seq_model.fc2.state_dict())\n", + " with torch.no_grad():\n", + " # Preserve trainable beta as vector/scalar parameter for hls4ml parsing.\n", + " if hasattr(step.if1, \"beta\"):\n", + " step.if1.beta.data = seq_model.if1.beta.detach().clone()\n", + " step.eval()\n", + " return step" ] }, { "cell_type": "markdown", - "id": "70b37555-6f4d-4cca-a35d-e79c5da91540", + "id": "8e1f221c-170d-44e7-966a-74cbcdbe99f9", "metadata": { "jp-MarkdownHeadingCollapsed": true }, "source": [ - "## train the net" + "## hls config" ] }, { - "cell_type": "markdown", - "id": "6ff987f8-0978-48e7-b083-d1580b250636", + "cell_type": "code", + "execution_count": 11, + "id": "14e97525-7c4a-420e-b881-409852506494", "metadata": {}, + "outputs": [], + "source": [ + "def build_hls_config(\n", + " step_model: SNNStep,\n", + " backend: str,\n", + " precision: str = \"ap_fixed<8,3>\",\n", + ") -> dict:\n", + " cfg = hls4ml.utils.config_from_pytorch_model(\n", + " step_model,\n", + " input_shape=(2,),\n", + " granularity=\"name\",\n", + " backend=backend,\n", + " default_precision=precision,\n", + " )\n", + "\n", + " cfg[\"Model\"][\"ReuseFactor\"] = 1\n", + " cfg[\"Model\"][\"Precision\"][\"default\"] = precision\n", + "\n", + " for _, layer_cfg in cfg.get(\"LayerName\", {}).items():\n", + " prec = layer_cfg.setdefault(\"Precision\", {})\n", + " prec[\"result\"] = precision\n", + " prec[\"accum\"] = precision\n", + " prec[\"weight\"] = precision\n", + " prec[\"bias\"] = precision\n", + "\n", + " if \"if1\" in cfg.get(\"LayerName\", {}):\n", + " if1_prec = cfg[\"LayerName\"][\"if1\"].setdefault(\"Precision\", {})\n", + " # These map to TypeAttributes beta_t / threshold_t / membrane_t internally.\n", + " if1_prec[\"beta\"] = precision\n", + " if1_prec[\"threshold\"] = precision\n", + " if1_prec[\"membrane\"] = precision\n", + "\n", + " return cfg" + ] + }, + { + "cell_type": "markdown", + "id": "17fb84b2-8cbe-45fe-8491-a7ffe499e8c3", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ - "train the SNN model" + "## convert hls" ] }, { "cell_type": "code", - "execution_count": 46, - "id": "974f3a5b-a98a-496f-a389-91d4c9c2caf9", + "execution_count": 12, + "id": "8375c8fe-16c4-4ee9-a70a-02dd5b7f2c5f", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 01/40: loss=1.6508, acc=0.4950\n", - "Epoch 02/40: loss=1.4839, acc=0.4950\n", - "Epoch 03/40: loss=1.3144, acc=0.4950\n", - "Epoch 04/40: loss=1.1773, acc=0.4950\n", - "Epoch 05/40: loss=1.0510, acc=0.4950\n", - "Epoch 06/40: loss=0.9358, acc=0.4950\n", - "Epoch 07/40: loss=0.8379, acc=0.4950\n", - "Epoch 08/40: loss=0.7687, acc=0.5000\n", - "Epoch 09/40: loss=0.7271, acc=0.5000\n", - "Epoch 10/40: loss=0.6972, acc=0.5400\n", - "Epoch 11/40: loss=0.6772, acc=0.5500\n", - "Epoch 12/40: loss=0.6613, acc=0.6100\n", - "Epoch 13/40: loss=0.6407, acc=0.6300\n", - "Epoch 14/40: loss=0.6061, acc=0.6700\n", - "Epoch 15/40: loss=0.5802, acc=0.6800\n", - "Epoch 16/40: loss=0.5514, acc=0.7400\n", - "Epoch 17/40: loss=0.5107, acc=0.8000\n", - "Epoch 18/40: loss=0.4786, acc=0.8450\n", - "Epoch 19/40: loss=0.4461, acc=0.8750\n", - "Epoch 20/40: loss=0.4129, acc=0.9050\n", - "Epoch 21/40: loss=0.3928, acc=0.9100\n", - "Epoch 22/40: loss=0.3692, acc=0.9200\n", - "Epoch 23/40: loss=0.3514, acc=0.9200\n", - "Epoch 24/40: loss=0.3359, acc=0.9150\n", - "Epoch 25/40: loss=0.3234, acc=0.9200\n", - "Epoch 26/40: loss=0.3129, acc=0.9200\n", - "Epoch 27/40: loss=0.3003, acc=0.9250\n", - "Epoch 28/40: loss=0.2982, acc=0.9200\n", - "Epoch 29/40: loss=0.2919, acc=0.9100\n", - "Epoch 30/40: loss=0.2877, acc=0.9050\n", - "Epoch 31/40: loss=0.2803, acc=0.9000\n", - "Epoch 32/40: loss=0.2721, acc=0.9100\n", - "Epoch 33/40: loss=0.2632, acc=0.9250\n", - "Epoch 34/40: loss=0.2554, acc=0.9250\n", - "Epoch 35/40: loss=0.2484, acc=0.9250\n", - "Epoch 36/40: loss=0.2438, acc=0.9300\n", - "Epoch 37/40: loss=0.2414, acc=0.9300\n", - "Epoch 38/40: loss=0.2358, acc=0.9350\n", - "Epoch 39/40: loss=0.2314, acc=0.9350\n", - "Epoch 40/40: loss=0.2287, acc=0.9350\n" - ] - } - ], + "outputs": [], "source": [ - "train_model = SNN_LIF(hidden=16, beta=0.9)\n", - "train_snn(\n", - " train_model,\n", - " x,\n", - " y,\n", - " epochs=40,\n", - " batch_size=256,\n", - ")" + "def convert_hls(\n", + " step_model: SNNStep,\n", + " out_dir: Path,\n", + " backend: str,\n", + " part: str,\n", + " precision: str,\n", + "):\n", + " hls_config = build_hls_config(step_model, backend=backend, precision=precision)\n", + " project_name = out_dir.name\n", + " model = hls4ml.converters.convert_from_pytorch_model(\n", + " step_model,\n", + " output_dir=str(out_dir),\n", + " project_name=project_name,\n", + " backend=backend,\n", + " io_type=\"io_stream\",\n", + " hls_config=hls_config,\n", + " part=part,\n", + " clock_period=5,\n", + " clock_uncertainty=\"18%\",\n", + " )\n", + " model.write()\n", + " return model, hls_config\n", + "\n", + "\n", + "def _extract_predict_array(y):\n", + " if isinstance(y, tuple):\n", + " y = y[0]\n", + " if isinstance(y, dict):\n", + " # choose first output by key ordering\n", + " y = y[next(iter(y.keys()))]\n", + " y = np.asarray(y)\n", + " if y.ndim == 1:\n", + " y = y[None, :]\n", + " return y\n", + "\n", + "\n", + "def evaluate_hls_sequence(hls_model, x_seq: np.ndarray, y_true: np.ndarray) -> tuple[float, float]:\n", + " \"\"\"Sequence classification using output membrane accumulation from per-step outputs.\"\"\"\n", + " t0 = time.perf_counter()\n", + " preds = []\n", + " for i in range(x_seq.shape[0]):\n", + " mem2 = np.zeros((2,), dtype=np.float32)\n", + " for t in range(x_seq.shape[1]):\n", + " inp = x_seq[i, t, :].astype(np.float32)[None, :]\n", + " y_step = _extract_predict_array(hls_model.predict(inp))\n", + " mem2 += y_step[0].astype(np.float32)\n", + " preds.append(int(np.argmax(mem2)))\n", + " dt = time.perf_counter() - t0\n", + " preds = np.asarray(preds, dtype=np.int64)\n", + " acc = float(np.mean(preds == y_true))\n", + " throughput = float(x_seq.shape[0] / dt) if dt > 0 else 0.0\n", + " return acc, throughput" ] }, { "cell_type": "markdown", - "id": "6e57d564-f005-4877-9e74-7caedf255e69", + "id": "5d715aa6-97fc-43b4-897b-c1ae9fb672db", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## run analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1bd05ecc-67f0-4acf-8ad1-77e09c1974e7", "metadata": {}, + "outputs": [], "source": [ - "copy the weights to the single-step network for hls conversion" + "output_dir = Path(\"examples/snn_smoke_vitis\")\n", + "backend = \"Vitis\"\n", + "part = \"xczu7ev-ffvc1156-2-e\"\n", + "precision = \"ap_fixed<8,3>\"\n", + "skip_build = False\n", + "timesteps = 50\n", + "n_trn = 2000\n", + "n_val = 300\n", + "n_tst = 300\n", + "n_epochs = 40\n", + "n_qat_epochs = 10\n", + "batch_size = 64\n", + "beta_reg = 1e-2\n", + "seed = 0" ] }, { "cell_type": "code", - "execution_count": 47, - "id": "90386d04-0058-4516-8939-770126305fb6", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "SNN_LIF_step(\n", - " (fc1): Linear(in_features=2, out_features=16, bias=True)\n", - " (if1): Leaky()\n", - " (fc2): Linear(in_features=16, out_features=2, bias=True)\n", - ")" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": 14, + "id": "f055e0f2-64b3-4114-a2f0-58b56e8081a4", + "metadata": {}, + "outputs": [], "source": [ - "single_step_model = SNN_LIF_step(hidden=16, beta=0.9, threshold=1.0)\n", - "single_step_model.fc1.load_state_dict(train_model.fc1.state_dict())\n", - "single_step_model.fc2.load_state_dict(train_model.fc2.state_dict())\n", - "single_step_model.eval()" + "set_seed(seed)\n", + "output_dir.mkdir(parents=True, exist_ok=True)" ] }, { - "cell_type": "markdown", - "id": "8b9b5257-eb80-471c-b52b-fe48c6893c5c", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, + "cell_type": "code", + "execution_count": 15, + "id": "00293d90-47a5-4fea-975d-8603ac7a54f6", + "metadata": {}, + "outputs": [], "source": [ - "## run hls4ml" + "x_trn, y_trn = make_toy_dataset(n_trn, timesteps=timesteps)\n", + "x_val, y_val = make_toy_dataset(n_val, timesteps=timesteps)\n", + "x_tst, y_tst = make_toy_dataset(n_tst, timesteps=timesteps)\n", + "\n", + "tx_trn, ty_trn = to_torch(x_trn, y_trn)\n", + "tx_val, ty_val = to_torch(x_val, y_val)\n", + "tx_tst, ty_tst = to_torch(x_tst, y_tst)" ] }, { - "cell_type": "markdown", - "id": "18c67f8c-8f92-4bfd-bc08-6d9b19f1b0ba", + "cell_type": "code", + "execution_count": 16, + "id": "d23cfb24-91a4-41fe-8481-8f4b62e8db0a", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[QAT] epoch=01/10 val_acc=0.6667\n", + "[QAT] epoch=02/10 val_acc=0.6967\n", + "[QAT] epoch=03/10 val_acc=0.7200\n", + "[QAT] epoch=04/10 val_acc=0.7000\n", + "[QAT] epoch=05/10 val_acc=0.7000\n", + "[QAT] epoch=06/10 val_acc=0.7000\n", + "[QAT] epoch=07/10 val_acc=0.7000\n", + "[QAT] epoch=08/10 val_acc=0.7000\n", + "[QAT] epoch=09/10 val_acc=0.7200\n", + "[QAT] epoch=10/10 val_acc=0.7000\n", + "[Torch] test accuracy=0.7900\n" + ] + } + ], "source": [ - "now we run the hls4ml package" + "step_model = SNNStep(hidden=4, threshold=1.0, beta_init=0.1)\n", + "\n", + "train_and_qat(\n", + " step_model,\n", + " tx_trn,\n", + " ty_trn,\n", + " tx_val,\n", + " ty_val,\n", + " epochs=n_epochs,\n", + " qat_epochs=n_qat_epochs,\n", + " lr=1e-2,\n", + " frac_bits=4,\n", + " batch_size=batch_size,\n", + " beta_reg=beta_reg,\n", + ")\n", + "\n", + "torch_acc = evaluate_torch_step(step_model, tx_tst, ty_tst)\n", + "print(f\"[Torch] test accuracy={torch_acc:.4f}\")" ] }, { "cell_type": "code", - "execution_count": 60, - "id": "87bdabc7-6423-4bb1-bc31-956d6479c46a", + "execution_count": 17, + "id": "c4c13f33-9578-4c9e-954e-7ad01683efce", "metadata": { "scrolled": true }, @@ -532,45 +726,44 @@ "Interpreting Model ...\n", "Topology:\n", "Layer name: fc1, layer type: Dense, input shape: [[None, 2]]\n", - "Layer name: if1, layer type: LIFNeuron, input shape: [[None, 16]]\n", - "Layer name: fc2, layer type: Dense, input shape: [[None, 16]]\n", - "Generated HLS project at: snn_test_lif\n", - "Generated top file: snn_test_lif/firmware/snn_test_lif.cpp\n", + "Layer name: if1, layer type: LIFNeuron, input shape: [[None, 4]]\n", + "Layer name: fc2, layer type: Dense, input shape: [[None, 4]]\n", + "[HLS] building with full synthesis flow...\n", "\n", "****** vitis-run v2024.1 (64-bit)\n", " **** SW Build 5074859 on 2024-05-20-23:21:20\n", - " **** Start of session at: Mon Apr 27 10:37:51 2026\n", + " **** Start of session at: Mon May 4 18:21:31 2026\n", " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", "\n", - "INFO: [vitis-run 82-31] Launching vitis_hls: vitis_hls -nolog -run tcl -f /home/b/Physics/hls4ml/snn_test_lif/build_prj.tcl -work_dir /home/b/Physics/hls4ml/snn_test_lif\n", + "INFO: [vitis-run 82-31] Launching vitis_hls: vitis_hls -nolog -run tcl -f /home/b/Physics/hls4ml/examples/snn_smoke_vitis/build_prj.tcl -work_dir /home/b/Physics/hls4ml/examples/snn_smoke_vitis\n", "\n", "****** Vitis HLS - High-Level Synthesis from C, C++ and OpenCL v2024.1 (64-bit)\n", " **** SW Build 5069499 on May 21 2024\n", " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Mon Apr 27 10:37:52 2026\n", + " **** Start of session at: Mon May 4 18:21:32 2026\n", " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", "\n", "source /tools/Xilinx/Vitis_HLS/2024.1/scripts/vitis_hls/hls.tcl -notrace\n", - "INFO: [HLS 200-10] For user 'b' on host 'b-comp' (Linux_x86_64 version 6.12.64-1-MANJARO) on Mon Apr 27 10:37:53 IST 2026\n", + "INFO: [HLS 200-10] For user 'b' on host 'b-comp' (Linux_x86_64 version 6.12.64-1-MANJARO) on Mon May 04 18:21:33 IST 2026\n", "INFO: [HLS 200-10] On os \"Manjaro Linux\"\n", - "INFO: [HLS 200-10] In directory '/home/b/Physics/hls4ml/snn_test_lif'\n", - "Sourcing Tcl script '/home/b/Physics/hls4ml/snn_test_lif/build_prj.tcl'\n", - "INFO: [HLS 200-1510] Running: open_project -reset snn_test_lif_prj \n", - "INFO: [HLS 200-10] Opening and resetting project '/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj'.\n", - "INFO: [HLS 200-1510] Running: set_top snn_test_lif \n", - "INFO: [HLS 200-1510] Running: add_files firmware/snn_test_lif.cpp -cflags -std=c++0x \n", - "INFO: [HLS 200-10] Adding design file 'firmware/snn_test_lif.cpp' to the project\n", - "INFO: [HLS 200-1510] Running: add_files -tb snn_test_lif_test.cpp -cflags -std=c++0x \n", - "INFO: [HLS 200-10] Adding test bench file 'snn_test_lif_test.cpp' to the project\n", + "INFO: [HLS 200-10] In directory '/home/b/Physics/hls4ml/examples/snn_smoke_vitis'\n", + "Sourcing Tcl script '/home/b/Physics/hls4ml/examples/snn_smoke_vitis/build_prj.tcl'\n", + "INFO: [HLS 200-1510] Running: open_project -reset snn_smoke_vitis_prj \n", + "INFO: [HLS 200-10] Opening and resetting project '/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj'.\n", + "INFO: [HLS 200-1510] Running: set_top snn_smoke_vitis \n", + "INFO: [HLS 200-1510] Running: add_files firmware/snn_smoke_vitis.cpp -cflags -std=c++0x \n", + "INFO: [HLS 200-10] Adding design file 'firmware/snn_smoke_vitis.cpp' to the project\n", + "INFO: [HLS 200-1510] Running: add_files -tb snn_smoke_vitis_test.cpp -cflags -std=c++0x \n", + "INFO: [HLS 200-10] Adding test bench file 'snn_smoke_vitis_test.cpp' to the project\n", "INFO: [HLS 200-1510] Running: add_files -tb firmware/weights \n", "INFO: [HLS 200-10] Adding test bench file 'firmware/weights' to the project\n", "INFO: [HLS 200-1510] Running: add_files -tb tb_data \n", "INFO: [HLS 200-10] Adding test bench file 'tb_data' to the project\n", "INFO: [HLS 200-1510] Running: open_solution -reset solution1 \n", - "INFO: [HLS 200-10] Creating and opening solution '/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1'.\n", + "INFO: [HLS 200-10] Creating and opening solution '/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1'.\n", "INFO: [HLS 200-10] Cleaning up the solution database.\n", "INFO: [HLS 200-1505] Using default flow_target 'vivado'\n", "Resolution: For help on HLS 200-1505 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=200-1505.html\n", @@ -596,22 +789,22 @@ "INFO: [HLS 200-1510] Running: config_schedule -enable_dsp_full_reg=false \n", "INFO: [HLS 200-1510] Running: create_clock -period 5 -name default \n", "INFO: [SYN 201-201] Setting up clock 'default' with a period of 5ns.\n", - "INFO: [HLS 200-1510] Running: set_clock_uncertainty 27% default \n", - "INFO: [SYN 201-201] Setting up clock 'default' with an uncertainty of 1.35ns.\n", + "INFO: [HLS 200-1510] Running: set_clock_uncertainty 18% default \n", + "INFO: [SYN 201-201] Setting up clock 'default' with an uncertainty of 0.9ns.\n", "***** C SIMULATION *****\n", "INFO: [HLS 200-1510] Running: csim_design \n", "INFO: [SIM 211-2] *************** CSIM start ***************\n", "INFO: [SIM 211-4] CSIM will launch CLANG as the compiler.\n", "INFO: [HLS 200-2036] Building debug C Simulation binaries\n", - " Compiling ../../../../snn_test_lif_test.cpp in debug mode\n", - " Compiling ../../../../firmware/snn_test_lif.cpp in debug mode\n", + " Compiling ../../../../snn_smoke_vitis_test.cpp in debug mode\n", + " Compiling ../../../../firmware/snn_smoke_vitis.cpp in debug mode\n", " Generating csim.exe\n", "INFO: Unable to open input/predictions file, using default input.\n", - "-0.25 -0.25 \n", - "-0.25 -0.25 \n", - "-0.25 -1 \n", - "-0.25 -0.75 \n", - "-0.25 -0.25 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", "INFO: Saved inference results to file: tb_data/csim_results.log\n", "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", "INFO: [SIM 211-1] CSim done with 0 errors.\n", @@ -620,20 +813,24 @@ "***** C SIMULATION COMPLETED IN 0h0m4s *****\n", "***** C/RTL SYNTHESIS *****\n", "INFO: [HLS 200-1510] Running: csynth_design \n", - "INFO: [HLS 200-111] Finished File checks and directory preparation: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 326.793 MB.\n", - "INFO: [HLS 200-10] Analyzing design file 'firmware/snn_test_lif.cpp' ... \n", + "INFO: [HLS 200-111] Finished File checks and directory preparation: CPU user time: 0.04 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.05 seconds; current allocated memory: 326.801 MB.\n", + "INFO: [HLS 200-10] Analyzing design file 'firmware/snn_smoke_vitis.cpp' ... \n", "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:33:9)\n", "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:107:9)\n", "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:189:9)\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_test_lif.cpp:38:57)\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_smoke_vitis.cpp:38:57)\n", + "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_smoke_vitis.cpp:38:61)\n", "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_test_lif.cpp:38:61)\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_smoke_vitis.cpp:40:75)\n", "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_test_lif.cpp:42:70)\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_smoke_vitis.cpp:40:84)\n", "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_test_lif.cpp:42:74)\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_smoke_vitis.cpp:42:70)\n", "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 200-471] Dataflow form checks found 4 issue(s) in file firmware/snn_test_lif.cpp\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_smoke_vitis.cpp:42:74)\n", + "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", + "WARNING: [HLS 200-471] Dataflow form checks found 6 issue(s) in file firmware/snn_smoke_vitis.cpp\n", "Resolution: For help on HLS 200-471 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=200-471.html\n", "WARNING: [HLS 207-5292] unused parameter 'keep' (firmware/nnet_utils/nnet_helpers.h:285:99)\n", "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:14:36)\n", @@ -658,275 +855,261 @@ "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_code_gen.h:17:38)\n", "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_code_gen.h:18:60)\n", "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_code_gen.h:19:58)\n", - "INFO: [HLS 200-111] Finished Source Code Analysis and Preprocessing: CPU user time: 4 seconds. CPU system time: 0.83 seconds. Elapsed time: 4.89 seconds; current allocated memory: 331.387 MB.\n", + "INFO: [HLS 200-111] Finished Source Code Analysis and Preprocessing: CPU user time: 4.09 seconds. CPU system time: 0.79 seconds. Elapsed time: 4.92 seconds; current allocated memory: 331.375 MB.\n", "INFO: [HLS 200-777] Using interface defaults for 'Vivado' flow target.\n", - "INFO: [HLS 200-1995] There were 3,460 instructions in the design after the 'Compile/Link' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 5,728 instructions in the design after the 'Unroll/Inline (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,900 instructions in the design after the 'Unroll/Inline (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,696 instructions in the design after the 'Unroll/Inline (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,554 instructions in the design after the 'Unroll/Inline (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 857 instructions in the design after the 'Array/Struct (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 857 instructions in the design after the 'Array/Struct (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 861 instructions in the design after the 'Array/Struct (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,275 instructions in the design after the 'Array/Struct (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,264 instructions in the design after the 'Array/Struct (step 5)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,219 instructions in the design after the 'Performance (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,215 instructions in the design after the 'Performance (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,215 instructions in the design after the 'Performance (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,215 instructions in the design after the 'Performance (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,154 instructions in the design after the 'HW Transforms (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,246 instructions in the design after the 'HW Transforms (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 214-415] Performing recursive inline in function 'nnet::dense, 2u>, nnet::array, 16u>, config2>' (firmware/nnet_utils/nnet_dense_stream.h:85:9)\n", - "WARNING: [HLS 214-273] In function 'void nnet::dense_latency_wrapper, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)', Pragma conflict happens on 'INLINE' and 'PIPELINE' pragmas: same function (firmware/nnet_utils/nnet_dense_stream.h:15:0)\n", - "INFO: [HLS 214-415] Performing recursive inline in function 'nnet::dense, 16u>, nnet::array, 2u>, config4>' (firmware/nnet_utils/nnet_dense_stream.h:85:9)\n", - "WARNING: [HLS 214-273] In function 'void nnet::dense_latency_wrapper, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)', Pragma conflict happens on 'INLINE' and 'PIPELINE' pragmas: same function (firmware/nnet_utils/nnet_dense_stream.h:15:0)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::array, 2u>::operator[](unsigned long) (.3)' into 'void nnet::data_prepare, 2u>, config2>(hls::stream, 2u>, 0>&, nnet::array, 2u>::value_type*) (.10)' (firmware/nnet_utils/nnet_dense_stream.h:47:17)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::product::mult, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0> >::product(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>)' into 'void nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:42:27)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::array, 16u>::operator[](unsigned long) (.5)' into 'void nnet::res_write, 16u>, config2>(nnet::array, 16u>::value_type*, hls::stream, 16u>, 0>&) (.8)' (firmware/nnet_utils/nnet_dense_stream.h:75:2)\n", - "INFO: [HLS 214-131] Inlining function 'void nnet::data_prepare, 2u>, config2>(hls::stream, 2u>, 0>&, nnet::array, 2u>::value_type*) (.10)' into 'void nnet::dense, 2u>, nnet::array, 16u>, config2>(hls::stream, 2u>, 0>&, hls::stream, 16u>, 0>&, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:93:2)\n", - "INFO: [HLS 214-131] Inlining function 'void nnet::res_write, 16u>, config2>(nnet::array, 16u>::value_type*, hls::stream, 16u>, 0>&) (.8)' into 'void nnet::dense, 2u>, nnet::array, 16u>, config2>(hls::stream, 2u>, 0>&, hls::stream, 16u>, 0>&, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:100:5)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::array, 16u>::operator[](unsigned long) (.5)' into 'void nnet::data_prepare, 16u>, config4>(hls::stream, 16u>, 0>&, nnet::array, 16u>::value_type*) (.4)' (firmware/nnet_utils/nnet_dense_stream.h:47:17)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::product::mult, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0> >::product(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>)' into 'void nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:42:27)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::array, 2u>::operator[](unsigned long) (.3)' into 'void nnet::res_write, 2u>, config4>(nnet::array, 2u>::value_type*, hls::stream, 2u>, 0>&) (.1)' (firmware/nnet_utils/nnet_dense_stream.h:75:2)\n", - "INFO: [HLS 214-131] Inlining function 'void nnet::data_prepare, 16u>, config4>(hls::stream, 16u>, 0>&, nnet::array, 16u>::value_type*) (.4)' into 'void nnet::dense, 16u>, nnet::array, 2u>, config4>(hls::stream, 16u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:93:2)\n", - "INFO: [HLS 214-131] Inlining function 'void nnet::res_write, 2u>, config4>(nnet::array, 2u>::value_type*, hls::stream, 2u>, 0>&) (.1)' into 'void nnet::dense, 16u>, nnet::array, 2u>, config4>(hls::stream, 16u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:100:5)\n", + "INFO: [HLS 200-1995] There were 3,120 instructions in the design after the 'Compile/Link' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,550 instructions in the design after the 'Unroll/Inline (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 575 instructions in the design after the 'Unroll/Inline (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 520 instructions in the design after the 'Unroll/Inline (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 444 instructions in the design after the 'Unroll/Inline (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 183 instructions in the design after the 'Array/Struct (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 183 instructions in the design after the 'Array/Struct (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 187 instructions in the design after the 'Array/Struct (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 289 instructions in the design after the 'Array/Struct (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 287 instructions in the design after the 'Array/Struct (step 5)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 269 instructions in the design after the 'Performance (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 265 instructions in the design after the 'Performance (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 265 instructions in the design after the 'Performance (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 265 instructions in the design after the 'Performance (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 246 instructions in the design after the 'HW Transforms (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 229 instructions in the design after the 'HW Transforms (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 214-415] Performing recursive inline in function 'nnet::dense, 2u>, nnet::array, 4u>, config2>' (firmware/nnet_utils/nnet_dense_stream.h:85:9)\n", + "WARNING: [HLS 214-273] In function 'void nnet::dense_latency_wrapper, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)', Pragma conflict happens on 'INLINE' and 'PIPELINE' pragmas: same function (firmware/nnet_utils/nnet_dense_stream.h:15:0)\n", + "INFO: [HLS 214-415] Performing recursive inline in function 'nnet::dense, 4u>, nnet::array, 2u>, config4>' (firmware/nnet_utils/nnet_dense_stream.h:85:9)\n", + "WARNING: [HLS 214-273] In function 'void nnet::dense_latency_wrapper, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)', Pragma conflict happens on 'INLINE' and 'PIPELINE' pragmas: same function (firmware/nnet_utils/nnet_dense_stream.h:15:0)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::array, 2u>::operator[](unsigned long) (.3)' into 'void nnet::data_prepare, 2u>, config2>(hls::stream, 2u>, 0>&, nnet::array, 2u>::value_type*) (.10)' (firmware/nnet_utils/nnet_dense_stream.h:47:17)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::product::mult, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0> >::product(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>)' into 'void nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:42:27)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::array, 4u>::operator[](unsigned long) (.5)' into 'void nnet::res_write, 4u>, config2>(nnet::array, 4u>::value_type*, hls::stream, 4u>, 0>&) (.8)' (firmware/nnet_utils/nnet_dense_stream.h:75:2)\n", + "INFO: [HLS 214-131] Inlining function 'void nnet::data_prepare, 2u>, config2>(hls::stream, 2u>, 0>&, nnet::array, 2u>::value_type*) (.10)' into 'void nnet::dense, 2u>, nnet::array, 4u>, config2>(hls::stream, 2u>, 0>&, hls::stream, 4u>, 0>&, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:93:2)\n", + "INFO: [HLS 214-131] Inlining function 'void nnet::res_write, 4u>, config2>(nnet::array, 4u>::value_type*, hls::stream, 4u>, 0>&) (.8)' into 'void nnet::dense, 2u>, nnet::array, 4u>, config2>(hls::stream, 2u>, 0>&, hls::stream, 4u>, 0>&, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:100:5)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::array, 4u>::operator[](unsigned long) (.5)' into 'void nnet::data_prepare, 4u>, config4>(hls::stream, 4u>, 0>&, nnet::array, 4u>::value_type*) (.4)' (firmware/nnet_utils/nnet_dense_stream.h:47:17)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::product::mult, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0> >::product(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>)' into 'void nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:42:27)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::array, 2u>::operator[](unsigned long) (.3)' into 'void nnet::res_write, 2u>, config4>(nnet::array, 2u>::value_type*, hls::stream, 2u>, 0>&) (.1)' (firmware/nnet_utils/nnet_dense_stream.h:75:2)\n", + "INFO: [HLS 214-131] Inlining function 'void nnet::data_prepare, 4u>, config4>(hls::stream, 4u>, 0>&, nnet::array, 4u>::value_type*) (.4)' into 'void nnet::dense, 4u>, nnet::array, 2u>, config4>(hls::stream, 4u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:93:2)\n", + "INFO: [HLS 214-131] Inlining function 'void nnet::res_write, 2u>, config4>(nnet::array, 2u>::value_type*, hls::stream, 2u>, 0>&) (.1)' into 'void nnet::dense, 4u>, nnet::array, 2u>, config4>(hls::stream, 4u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:100:5)\n", "INFO: [HLS 214-291] Loop 'Result' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:64:5)\n", "INFO: [HLS 214-291] Loop 'Accum1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:54:5)\n", "INFO: [HLS 214-291] Loop 'Accum2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:56:9)\n", "INFO: [HLS 214-291] Loop 'ResetAccum' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:48:5)\n", "INFO: [HLS 214-291] Loop 'Product1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:37:5)\n", "INFO: [HLS 214-291] Loop 'Product2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:40:9)\n", - "INFO: [HLS 214-291] Loop 'VITIS_LOOP_55_1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_lif_neuron.h:55:22)\n", - "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 16u>, nnet::array, 2u>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 16u>, nnet::array, 2u>, config4>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Accum1' (firmware/nnet_utils/nnet_dense_latency.h:54:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Accum2' (firmware/nnet_utils/nnet_dense_latency.h:56:9) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'ResetAccum' (firmware/nnet_utils/nnet_dense_latency.h:48:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_55_1' (firmware/nnet_utils/nnet_lif_neuron.h:55:22) in function 'nnet::lif_neuron, 16u>, nnet::array, 16u>, config3>' completely with a factor of 16 (firmware/nnet_utils/nnet_lif_neuron.h:45:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 2u>, nnet::array, 16u>, config2>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 2u>, nnet::array, 16u>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Accum1' (firmware/nnet_utils/nnet_dense_latency.h:54:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Accum2' (firmware/nnet_utils/nnet_dense_latency.h:56:9) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'ResetAccum' (firmware/nnet_utils/nnet_dense_latency.h:48:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 16 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(config2::accum_t)' into 'void nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-178] Inlining function 'nnet::array, 16u>::operator[](unsigned long)' into 'void nnet::lif_neuron, 16u>, nnet::array, 16u>, config3>(hls::stream, 16u>, 0>&, hls::stream, 16u>, 0>&)' (firmware/nnet_utils/nnet_lif_neuron.h:45:0)\n", - "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(config4::accum_t)' into 'void nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-291] Loop 'VITIS_LOOP_74_1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_lif_neuron.h:74:22)\n", + "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 4u>, nnet::array, 2u>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 4u>, nnet::array, 2u>, config4>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Accum1' (firmware/nnet_utils/nnet_dense_latency.h:54:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Accum2' (firmware/nnet_utils/nnet_dense_latency.h:56:9) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'ResetAccum' (firmware/nnet_utils/nnet_dense_latency.h:48:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_74_1' (firmware/nnet_utils/nnet_lif_neuron.h:74:22) in function 'nnet::lif_neuron, 4u>, nnet::array, 4u>, config3>' completely with a factor of 4 (firmware/nnet_utils/nnet_lif_neuron.h:64:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 2u>, nnet::array, 4u>, config2>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 2u>, nnet::array, 4u>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Accum1' (firmware/nnet_utils/nnet_dense_latency.h:54:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Accum2' (firmware/nnet_utils/nnet_dense_latency.h:56:9) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'ResetAccum' (firmware/nnet_utils/nnet_dense_latency.h:48:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(config2::accum_t)' into 'void nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-178] Inlining function 'nnet::array, 4u>::operator[](unsigned long)' into 'void nnet::lif_neuron, 4u>, nnet::array, 4u>, config3>(hls::stream, 4u>, 0>&, hls::stream, 4u>, 0>&, config3::beta_t const*, config3::threshold_t const*)' (firmware/nnet_utils/nnet_lif_neuron.h:64:0)\n", + "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(config4::accum_t)' into 'void nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", "INFO: [HLS 214-248] Applying array_partition to 'b2': Complete partitioning on dimension 1. (firmware/weights/b2.h:12:0)\n", "INFO: [HLS 214-248] Applying array_partition to 'b4': Complete partitioning on dimension 1. (firmware/weights/b4.h:12:0)\n", - "INFO: [HLS 214-248] Applying array_partition to '_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0EELj16EEES6_7config3EEvRN3hls6streamIT_Li0EEERNS9_IT0_Li0EEEE3mem': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_lif_neuron.h:48:0)\n", "INFO: [HLS 214-248] Applying array_partition to 'data': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_dense_stream.h:87:30)\n", "INFO: [HLS 214-248] Applying array_partition to 'res': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_dense_stream.h:90:29)\n", - "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer3_out' with compact=bit mode in 64-bits (firmware/snn_test_lif.cpp:35:24)\n", - "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer2_out' with compact=bit mode in 64-bits (firmware/snn_test_lif.cpp:32:24)\n", - "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", - "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", - "INFO: [HLS 200-111] Finished Compiling Optimization and Transform: CPU user time: 2.46 seconds. CPU system time: 0.52 seconds. Elapsed time: 7.31 seconds; current allocated memory: 341.434 MB.\n", - "INFO: [HLS 200-111] Finished Checking Pragmas: CPU user time: 0 seconds. CPU system time: 0 seconds. Elapsed time: 0 seconds; current allocated memory: 341.434 MB.\n", + "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer3_out' with compact=bit mode in 32-bits (firmware/snn_smoke_vitis.cpp:35:24)\n", + "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer2_out' with compact=bit mode in 32-bits (firmware/snn_smoke_vitis.cpp:32:24)\n", + "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", + "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", + "INFO: [HLS 200-111] Finished Compiling Optimization and Transform: CPU user time: 2.49 seconds. CPU system time: 0.54 seconds. Elapsed time: 7.43 seconds; current allocated memory: 341.020 MB.\n", + "INFO: [HLS 200-111] Finished Checking Pragmas: CPU user time: 0 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 341.020 MB.\n", "INFO: [HLS 200-10] Starting code transformations ...\n", - "INFO: [HLS 200-111] Finished Standard Transforms: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 342.793 MB.\n", + "INFO: [HLS 200-111] Finished Standard Transforms: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 342.000 MB.\n", "INFO: [HLS 200-10] Checking synthesizability ...\n", - "INFO: [HLS 200-111] Finished Checking Synthesizability: CPU user time: 0.07 seconds. CPU system time: 0 seconds. Elapsed time: 0.07 seconds; current allocated memory: 345.227 MB.\n", - "INFO: [XFORM 203-712] Applying dataflow to function 'snn_test_lif' (firmware/snn_test_lif.cpp:8), detected/extracted 3 process function(s): \n", - "\t 'nnet::dense, 2u>, nnet::array, 16u>, config2>'\n", - "\t 'nnet::lif_neuron, 16u>, nnet::array, 16u>, config3>'\n", - "\t 'nnet::dense, 16u>, nnet::array, 2u>, config4>'.\n", - "INFO: [XFORM 203-11] Balancing expressions in function 'nnet::dense_latency_wrapper, ap_fixed<4, 2, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' (firmware/nnet_utils/nnet_dense_stream.h:18:1)...16 expression(s) balanced.\n", - "INFO: [HLS 200-111] Finished Loop, function and other optimizations: CPU user time: 0.13 seconds. CPU system time: 0 seconds. Elapsed time: 0.14 seconds; current allocated memory: 369.496 MB.\n", - "INFO: [HLS 200-111] Finished Architecture Synthesis: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.07 seconds; current allocated memory: 411.000 MB.\n", + "INFO: [HLS 200-111] Finished Checking Synthesizability: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 343.953 MB.\n", + "INFO: [XFORM 203-712] Applying dataflow to function 'snn_smoke_vitis' (firmware/snn_smoke_vitis.cpp:8), detected/extracted 3 process function(s): \n", + "\t 'nnet::dense, 2u>, nnet::array, 4u>, config2>'\n", + "\t 'nnet::lif_neuron, 4u>, nnet::array, 4u>, config3>'\n", + "\t 'nnet::dense, 4u>, nnet::array, 2u>, config4>'.\n", + "INFO: [XFORM 203-11] Balancing expressions in function 'nnet::dense_latency_wrapper, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' (firmware/nnet_utils/nnet_dense_stream.h:18:1)...3 expression(s) balanced.\n", + "INFO: [HLS 200-111] Finished Loop, function and other optimizations: CPU user time: 0.03 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.05 seconds; current allocated memory: 366.895 MB.\n", + "INFO: [HLS 200-111] Finished Architecture Synthesis: CPU user time: 0.04 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.05 seconds; current allocated memory: 407.148 MB.\n", "INFO: [HLS 200-10] Starting hardware synthesis ...\n", - "INFO: [HLS 200-10] Synthesizing 'snn_test_lif' ...\n", - "WARNING: [SYN 201-103] Legalizing function name 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config2>' to 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s'.\n", - "WARNING: [SYN 201-103] Legalizing function name 'dense,array,16u>,config2>' to 'dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s'.\n", - "WARNING: [SYN 201-103] Legalizing function name 'lif_neuron,array,16u>,config3>' to 'lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s'.\n", - "WARNING: [SYN 201-103] Legalizing function name 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config4>' to 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s'.\n", - "WARNING: [SYN 201-103] Legalizing function name 'dense,array,2u>,config4>' to 'dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s'.\n", - "WARNING: [SYN 201-223] Checking resource limit in 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config2>': cannot find any operation of 'mul'.\n", - "WARNING: [SYN 201-223] Checking resource limit in 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config4>': cannot find any operation of 'mul'.\n", + "INFO: [HLS 200-10] Synthesizing 'snn_smoke_vitis' ...\n", + "WARNING: [SYN 201-103] Legalizing function name 'dense_latency_wrapper, ap_fixed<8, 3, 5, 3, 0>, config2>' to 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s'.\n", + "WARNING: [SYN 201-103] Legalizing function name 'dense,array,4u>,config2>' to 'dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s'.\n", + "WARNING: [SYN 201-103] Legalizing function name 'lif_neuron,array,4u>,config3>' to 'lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s'.\n", + "WARNING: [SYN 201-103] Legalizing function name 'dense_latency_wrapper, ap_fixed<8, 3, 5, 3, 0>, config4>' to 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s'.\n", + "WARNING: [SYN 201-103] Legalizing function name 'dense,array,2u>,config4>' to 'dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s'.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s' \n", + "INFO: [HLS 200-42] -- Implementing module 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config2>'.\n", - "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config2>'\n", + "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<8, 3, 5, 3, 0>, config2>'.\n", + "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<8, 3, 5, 3, 0>, config2>'\n", "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.05 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.08 seconds; current allocated memory: 411.000 MB.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.05 seconds. CPU system time: 0.02 seconds. Elapsed time: 0.07 seconds; current allocated memory: 407.148 MB.\n", "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", "INFO: [BIND 205-101] Exploring resource sharing.\n", "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Starting global binding ...\n", "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 411.000 MB.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.148 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s' \n", + "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [SCHED 204-11] Starting scheduling ...\n", "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 411.000 MB.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.914 MB.\n", "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", "INFO: [BIND 205-101] Exploring resource sharing.\n", "INFO: [BIND 205-101] Binding ...\n", "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 411.000 MB.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.01 seconds; current allocated memory: 407.914 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s' \n", + "INFO: [HLS 200-42] -- Implementing module 'lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-61] Pipelining function 'lif_neuron,array,16u>,config3>'.\n", - "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 2, function 'lif_neuron,array,16u>,config3>'\n", + "INFO: [SCHED 204-61] Pipelining function 'lif_neuron,array,4u>,config3>'.\n", + "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 2, function 'lif_neuron,array,4u>,config3>'\n", "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.06 seconds. CPU system time: 0 seconds. Elapsed time: 0.06 seconds; current allocated memory: 412.020 MB.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.918 MB.\n", "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", "INFO: [BIND 205-101] Exploring resource sharing.\n", "INFO: [BIND 205-101] Binding ...\n", "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 412.020 MB.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.01 seconds; current allocated memory: 407.918 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s' \n", + "INFO: [HLS 200-42] -- Implementing module 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config4>'.\n", - "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<4, 2, 5, 3, 0>, config4>'\n", + "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<8, 3, 5, 3, 0>, config4>'.\n", + "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<8, 3, 5, 3, 0>, config4>'\n", "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.04 seconds; current allocated memory: 412.629 MB.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.04 seconds; current allocated memory: 407.918 MB.\n", "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", "INFO: [BIND 205-101] Exploring resource sharing.\n", "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Starting global binding ...\n", "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 412.801 MB.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.918 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s' \n", + "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [SCHED 204-11] Starting scheduling ...\n", "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.03 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.02 seconds; current allocated memory: 413.031 MB.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.918 MB.\n", "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", "INFO: [BIND 205-101] Exploring resource sharing.\n", "INFO: [BIND 205-101] Binding ...\n", "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 413.160 MB.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.918 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'snn_test_lif' \n", + "INFO: [HLS 200-42] -- Implementing module 'snn_smoke_vitis' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [SCHED 204-11] Starting scheduling ...\n", "INFO: [SCHED 204-11] Finished scheduling.\n", - "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer2_out (from dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_U0 to lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0) to 2 to improve performance and/or avoid deadlocks.\n", - "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer3_out (from lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0 to dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0) to 2 to improve performance and/or avoid deadlocks.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 413.457 MB.\n", + "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer2_out (from dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_U0 to lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0) to 2 to improve performance and/or avoid deadlocks.\n", + "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer3_out (from lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0 to dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0) to 2 to improve performance and/or avoid deadlocks.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.918 MB.\n", "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", "INFO: [BIND 205-101] Exploring resource sharing.\n", "INFO: [BIND 205-101] Binding ...\n", "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 413.465 MB.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.918 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s' \n", + "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 414.539 MB.\n", + "INFO: [RTGEN 206-100] Generating core module 'mul_8s_6ns_13_1_1': 1 instance(s).\n", + "INFO: [RTGEN 206-100] Generating core module 'mul_8s_7s_13_1_1': 2 instance(s).\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.02 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.03 seconds; current allocated memory: 408.145 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s' \n", + "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0 seconds. Elapsed time: 0.06 seconds; current allocated memory: 416.477 MB.\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 409.309 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s' \n", + "INFO: [HLS 200-10] -- Generating RTL for module 'lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_9' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_8' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_7' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_6' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_5' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_4' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_3' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_2' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem_1' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_array_ap_fixed_4_2_5_3_0_16u_0_mem' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'p_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0E_5' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'p_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0E_4' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'p_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0E_3' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'p_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0E_2' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'p_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0E_1' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'p_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi4ELi2EL9ap_q_mode5EL9ap_o_mode3ELi0E' is power-on initialization.\n", - "INFO: [HLS 200-1030] Apply Unified Pipeline Control on module 'lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s' pipeline 'lif_neuron,array,16u>,config3>' pipeline type 'function pipeline'\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.08 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.08 seconds; current allocated memory: 418.840 MB.\n", + "INFO: [HLS 200-1030] Apply Unified Pipeline Control on module 'lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s' pipeline 'lif_neuron,array,4u>,config3>' pipeline type 'function pipeline'\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.04 seconds; current allocated memory: 409.984 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s' \n", + "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.07 seconds. CPU system time: 0 seconds. Elapsed time: 0.09 seconds; current allocated memory: 423.156 MB.\n", + "INFO: [RTGEN 206-100] Generating core module 'mul_8s_6s_13_1_1': 1 instance(s).\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.04 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.04 seconds; current allocated memory: 410.660 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s' \n", + "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.05 seconds; current allocated memory: 425.211 MB.\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 411.863 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'snn_test_lif' \n", + "INFO: [HLS 200-10] -- Generating RTL for module 'snn_smoke_vitis' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "WARNING: [RTGEN 206-101] Design contains AXI ports. Reset is fixed to synchronous and active low.\n", - "INFO: [RTGEN 206-500] Setting interface mode on port 'snn_test_lif/x' to 'axis' (register, both mode).\n", - "INFO: [RTGEN 206-500] Setting interface mode on port 'snn_test_lif/layer4_out' to 'axis' (register, both mode).\n", - "INFO: [RTGEN 206-500] Setting interface mode on function 'snn_test_lif' to 'ap_ctrl_hs'.\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'snn_test_lif'.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'layer2_out_U(snn_test_lif_fifo_w64_d1_S)' using Shift Registers.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'layer3_out_U(snn_test_lif_fifo_w64_d1_S)' using Shift Registers.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0_U(snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0)' using Shift Registers.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0_U(snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0)' using Shift Registers.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.07 seconds; current allocated memory: 426.281 MB.\n", - "INFO: [HLS 200-111] Finished Generating all RTL models: CPU user time: 0.14 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.15 seconds; current allocated memory: 428.766 MB.\n", - "INFO: [HLS 200-111] Finished Updating report files: CPU user time: 0.22 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.24 seconds; current allocated memory: 433.898 MB.\n", - "INFO: [VHDL 208-304] Generating VHDL RTL for snn_test_lif.\n", - "INFO: [VLOG 209-307] Generating Verilog RTL for snn_test_lif.\n", - "INFO: [HLS 200-789] **** Estimated Fmax: 283.77 MHz\n", - "INFO: [HLS 200-2161] Finished Command csynth_design Elapsed time: 00:00:13; Allocated memory: 107.934 MB.\n", + "INFO: [RTGEN 206-500] Setting interface mode on port 'snn_smoke_vitis/x' to 'axis' (register, both mode).\n", + "INFO: [RTGEN 206-500] Setting interface mode on port 'snn_smoke_vitis/layer4_out' to 'axis' (register, both mode).\n", + "INFO: [RTGEN 206-500] Setting interface mode on function 'snn_smoke_vitis' to 'ap_ctrl_hs'.\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'snn_smoke_vitis'.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'layer2_out_U(snn_smoke_vitis_fifo_w32_d1_S)' using Shift Registers.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'layer3_out_U(snn_smoke_vitis_fifo_w32_d1_S)' using Shift Registers.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0_U(snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0)' using Shift Registers.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0_U(snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0)' using Shift Registers.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.06 seconds; current allocated memory: 412.691 MB.\n", + "INFO: [HLS 200-111] Finished Generating all RTL models: CPU user time: 0.13 seconds. CPU system time: 0 seconds. Elapsed time: 0.14 seconds; current allocated memory: 415.090 MB.\n", + "INFO: [HLS 200-111] Finished Updating report files: CPU user time: 0.28 seconds. CPU system time: 0 seconds. Elapsed time: 0.28 seconds; current allocated memory: 419.008 MB.\n", + "INFO: [VHDL 208-304] Generating VHDL RTL for snn_smoke_vitis.\n", + "INFO: [VLOG 209-307] Generating Verilog RTL for snn_smoke_vitis.\n", + "INFO: [HLS 200-789] **** Estimated Fmax: 317.06 MHz\n", + "INFO: [HLS 200-2161] Finished Command csynth_design Elapsed time: 00:00:13; Allocated memory: 93.246 MB.\n", "***** C/RTL SYNTHESIS COMPLETED IN 0h0m13s *****\n", "***** C/RTL SIMULATION *****\n", - "INFO: [HLS 200-1510] Running: add_files -tb snn_test_lif_test.cpp -cflags -std=c++0x -DRTL_SIM \n", - "INFO: [HLS 200-10] Adding test bench file 'snn_test_lif_test.cpp' to the project\n", + "INFO: [HLS 200-1510] Running: add_files -tb snn_smoke_vitis_test.cpp -cflags -std=c++0x -DRTL_SIM \n", + "INFO: [HLS 200-10] Adding test bench file 'snn_smoke_vitis_test.cpp' to the project\n", "INFO: [HLS 200-1510] Running: cosim_design -trace_level all -setup \n", "INFO: [COSIM 212-47] Using XSIM for RTL simulation.\n", "INFO: [COSIM 212-14] Instrumenting C test bench ...\n", " Build using \"/tools/Xilinx/Vitis_HLS/2024.1/vcxx/libexec/clang++\"\n", - " Compiling apatb_snn_test_lif.cpp\n", - " Compiling apatb_snn_test_lif_util.cpp\n", - " Compiling snn_test_lif.cpp_pre.cpp.tb.cpp\n", - " Compiling snn_test_lif_test.cpp_pre.cpp.tb.cpp\n", - " Compiling apatb_snn_test_lif_ir.ll\n", + " Compiling apatb_snn_smoke_vitis.cpp\n", + " Compiling apatb_snn_smoke_vitis_util.cpp\n", + " Compiling snn_smoke_vitis.cpp_pre.cpp.tb.cpp\n", + " Compiling snn_smoke_vitis_test.cpp_pre.cpp.tb.cpp\n", + " Compiling apatb_snn_smoke_vitis_ir.ll\n", " Generating cosim.tv.exe\n", "INFO: [COSIM 212-302] Starting C TB testing ... \n", "INFO: Unable to open input/predictions file, using default input.\n", - "-0.25 -0.25 \n", - "-0.25 -0.25 \n", - "-0.25 -1 \n", - "-0.25 -0.75 \n", - "-0.25 -0.25 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", "INFO: [COSIM 212-333] Generating C post check test bench ...\n", "INFO: [COSIM 212-12] Generating RTL test bench ...\n", "INFO: [COSIM 212-1] *** C/RTL co-simulation file generation completed. ***\n", - "INFO: [HLS 200-2161] Finished Command cosim_design Elapsed time: 00:00:11; Allocated memory: 11.672 MB.\n", - "INFO: [HLS 200-1510] Running: source /home/b/Physics/hls4ml/snn_test_lif/project.tcl\n", + "INFO: [HLS 200-2161] Finished Command cosim_design Elapsed time: 00:00:11; Allocated memory: 11.863 MB.\n", + "INFO: [HLS 200-1510] Running: source /home/b/Physics/hls4ml/examples/snn_smoke_vitis/project.tcl\n", "INFO: [HLS 200-1510] Running: source run_sim.tcl\n", "INFO: [HLS 200-1510] Running: source check_sim.tcl\n", "INFO: [HLS 200-1510] Running: source dataflow_monitor_API.tcl\n", "INFO: [COSIM 212-302] Starting C TB testing ... \n", "INFO: Unable to open input/predictions file, using default input.\n", - "-0.25 -0.25 \n", - "-0.25 -0.25 \n", - "-0.25 -1 \n", - "-0.25 -0.75 \n", - "-0.25 -0.25 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", "INFO: [COSIM 212-323] Starting verilog simulation...\n", @@ -934,52 +1117,58 @@ "Vivado Simulator v2024.1\n", "Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", "Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", - "Running: /tools/Xilinx/Vivado/2024.1/bin/unwrapped/lnx64.o/xelab xil_defaultlib.apatb_snn_test_lif_top glbl -Oenable_linking_all_libraries -prj snn_test_lif.prj -L smartconnect_v1_0 -L axi_protocol_checker_v1_1_12 -L axi_protocol_checker_v1_1_13 -L axis_protocol_checker_v1_1_11 -L axis_protocol_checker_v1_1_12 -L xil_defaultlib -L unisims_ver -L xpm -L floating_point_v7_0_23 -L floating_point_v7_1_18 --lib ieee_proposed=./ieee_proposed -s snn_test_lif -debug all \n", + "Running: /tools/Xilinx/Vivado/2024.1/bin/unwrapped/lnx64.o/xelab xil_defaultlib.apatb_snn_smoke_vitis_top glbl -Oenable_linking_all_libraries -prj snn_smoke_vitis.prj -L smartconnect_v1_0 -L axi_protocol_checker_v1_1_12 -L axi_protocol_checker_v1_1_13 -L axis_protocol_checker_v1_1_11 -L axis_protocol_checker_v1_1_12 -L xil_defaultlib -L unisims_ver -L xpm -L floating_point_v7_0_23 -L floating_point_v7_1_18 --lib ieee_proposed=./ieee_proposed -s snn_smoke_vitis -debug all \n", "Multi-threading is on. Using 14 slave threads.\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/glbl.v\" into library work\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/glbl.v\" into library work\n", "INFO: [VRFC 10-311] analyzing module glbl\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif.autotb.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module apatb_snn_test_lif_top\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_fifo.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis.autotb.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module apatb_snn_smoke_vitis_top\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_fifo.v\" into library xil_defaultlib\n", "INFO: [VRFC 10-311] analyzing module fifo\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_axi_s_x.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_axi_s_x.v\" into library xil_defaultlib\n", "INFO: [VRFC 10-311] analyzing module AESL_axi_s_x\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_axi_s_layer4_out.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_axi_s_layer4_out.v\" into library xil_defaultlib\n", "INFO: [VRFC 10-311] analyzing module AESL_axi_s_layer4_out\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_deadlock_detection_unit.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_deadlock_detection_unit.v\" into library xil_defaultlib\n", "INFO: [VRFC 10-311] analyzing module AESL_deadlock_detect_unit\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_deadlock_report_unit.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_deadlock_report_unit.v\" into library xil_defaultlib\n", "INFO: [VRFC 10-311] analyzing module AESL_deadlock_report_unit\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_deadlock_detector.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_deadlock_detector.v\" into library xil_defaultlib\n", "INFO: [VRFC 10-311] analyzing module AESL_deadlock_detector\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_deadlock_kernel_monitor_top.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_deadlock_kernel_monitor_top.v\" into library xil_defaultlib\n", "INFO: [VRFC 10-311] analyzing module AESL_deadlock_kernel_monitor_top\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/AESL_deadlock_idx0_monitor.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_deadlock_idx0_monitor.v\" into library xil_defaultlib\n", "INFO: [VRFC 10-311] analyzing module AESL_deadlock_idx0_monitor\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_test_lif\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_regslice_both.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_test_lif_regslice_both\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_fifo_w64_d1_S.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_test_lif_fifo_w64_d1_S\n", - "INFO: [VRFC 10-311] analyzing module snn_test_lif_fifo_w64_d1_S_ShiftReg\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0\n", - "INFO: [VRFC 10-311] analyzing module snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0_ShiftReg\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0\n", - "INFO: [VRFC 10-311] analyzing module snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0_ShiftReg\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/dataflow_monitor.sv\" into library xil_defaultlib\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_mul_8s_6ns_13_1_1.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_mul_8s_6ns_13_1_1\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_mul_8s_7s_13_1_1.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_mul_8s_7s_13_1_1\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_regslice_both.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_regslice_both\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_mul_8s_6s_13_1_1.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_mul_8s_6s_13_1_1\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_fifo_w32_d1_S.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_fifo_w32_d1_S\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_fifo_w32_d1_S_ShiftReg\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0_ShiftReg\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0\n", + "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0_ShiftReg\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/dataflow_monitor.sv\" into library xil_defaultlib\n", "INFO: [VRFC 10-311] analyzing module dataflow_monitor\n", "Starting static elaboration\n", "Pass Through NonSizing Optimizer\n", @@ -988,19 +1177,22 @@ "Completed simulation data flow analysis\n", "Time Resolution for simulation is 1ps\n", "Compiling package xil_defaultlib.$unit_dataflow_monitor_sv\n", - "Compiling module xil_defaultlib.snn_test_lif_dense_latency_wrapp...\n", - "Compiling module xil_defaultlib.snn_test_lif_regslice_both(DataW...\n", - "Compiling module xil_defaultlib.snn_test_lif_dense_array_ap_fixe...\n", - "Compiling module xil_defaultlib.snn_test_lif_lif_neuron_array_ap...\n", - "Compiling module xil_defaultlib.snn_test_lif_dense_latency_wrapp...\n", - "Compiling module xil_defaultlib.snn_test_lif_dense_array_ap_fixe...\n", - "Compiling module xil_defaultlib.snn_test_lif_fifo_w64_d1_S_Shift...\n", - "Compiling module xil_defaultlib.snn_test_lif_fifo_w64_d1_S_defau...\n", - "Compiling module xil_defaultlib.snn_test_lif_start_for_lif_neuro...\n", - "Compiling module xil_defaultlib.snn_test_lif_start_for_lif_neuro...\n", - "Compiling module xil_defaultlib.snn_test_lif_start_for_dense_arr...\n", - "Compiling module xil_defaultlib.snn_test_lif_start_for_dense_arr...\n", - "Compiling module xil_defaultlib.snn_test_lif\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_mul_8s_6ns_13_1_...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_mul_8s_7s_13_1_1...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_dense_latency_wr...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_regslice_both(Da...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_dense_array_ap_f...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_lif_neuron_array...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_mul_8s_6s_13_1_1...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_dense_latency_wr...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_dense_array_ap_f...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_fifo_w32_d1_S_Sh...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_fifo_w32_d1_S_de...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_start_for_lif_ne...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_start_for_lif_ne...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_start_for_dense_...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis_start_for_dense_...\n", + "Compiling module xil_defaultlib.snn_smoke_vitis\n", "Compiling module xil_defaultlib.fifo(DEPTH=2,WIDTH=16)\n", "Compiling module xil_defaultlib.AESL_axi_s_x\n", "Compiling module xil_defaultlib.AESL_axi_s_layer4_out\n", @@ -1015,68 +1207,68 @@ "Compiling module xil_defaultlib.df_process_intf_default\n", "Compiling module xil_defaultlib.nodf_module_intf_default\n", "Compiling module xil_defaultlib.dataflow_monitor_1\n", - "Compiling module xil_defaultlib.apatb_snn_test_lif_top\n", + "Compiling module xil_defaultlib.apatb_snn_smoke_vitis_top\n", "Compiling module work.glbl\n", - "Built simulation snapshot snn_test_lif\n", + "Built simulation snapshot snn_smoke_vitis\n", "\n", "****** xsim v2024.1 (64-bit)\n", " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Mon Apr 27 10:38:29 2026\n", + " **** Start of session at: Mon May 4 18:22:09 2026\n", " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", "\n", - "source xsim.dir/snn_test_lif/xsim_script.tcl\n", - "# xsim {snn_test_lif} -view {{snn_test_lif_dataflow_ana.wcfg}} -tclbatch {snn_test_lif.tcl} -protoinst {snn_test_lif.protoinst}\n", - "INFO: [Wavedata 42-565] Reading protoinst file snn_test_lif.protoinst\n", - "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_test_lif_top/AESL_inst_snn_test_lif//AESL_inst_snn_test_lif_activity\n", - "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0/dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0_activity\n", - "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_U0/dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_U0_activity\n", - "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0/lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0_activity\n", + "source xsim.dir/snn_smoke_vitis/xsim_script.tcl\n", + "# xsim {snn_smoke_vitis} -view {{snn_smoke_vitis_dataflow_ana.wcfg}} -tclbatch {snn_smoke_vitis.tcl} -protoinst {snn_smoke_vitis.protoinst}\n", + "INFO: [Wavedata 42-565] Reading protoinst file snn_smoke_vitis.protoinst\n", + "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis//AESL_inst_snn_smoke_vitis_activity\n", + "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_U0/dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_U0_activity\n", + "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0/dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0_activity\n", + "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0/lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0_activity\n", "Time resolution is 1 ps\n", - "open_wave_config snn_test_lif_dataflow_ana.wcfg\n", - "source snn_test_lif.tcl\n", + "open_wave_config snn_smoke_vitis_dataflow_ana.wcfg\n", + "source snn_smoke_vitis.tcl\n", "## set designtopgroup [add_wave_group \"Design Top Signals\"]\n", "## set coutputgroup [add_wave_group \"C Outputs\" -into $designtopgroup]\n", "## set return_group [add_wave_group return(axis) -into $coutputgroup]\n", - "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/layer4_out_TREADY -into $return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/layer4_out_TVALID -into $return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/layer4_out_TDATA -into $return_group -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/layer4_out_TREADY -into $return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/layer4_out_TVALID -into $return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/layer4_out_TDATA -into $return_group -radix hex\n", "## set cinputgroup [add_wave_group \"C Inputs\" -into $designtopgroup]\n", "## set return_group [add_wave_group return(axis) -into $cinputgroup]\n", - "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/x_TREADY -into $return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/x_TVALID -into $return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/x_TDATA -into $return_group -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/x_TREADY -into $return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/x_TVALID -into $return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/x_TDATA -into $return_group -radix hex\n", "## set blocksiggroup [add_wave_group \"Block-level IO Handshake\" -into $designtopgroup]\n", - "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/ap_start -into $blocksiggroup\n", - "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/ap_done -into $blocksiggroup\n", - "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/ap_ready -into $blocksiggroup\n", - "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/ap_idle -into $blocksiggroup\n", + "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/ap_start -into $blocksiggroup\n", + "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/ap_done -into $blocksiggroup\n", + "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/ap_ready -into $blocksiggroup\n", + "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/ap_idle -into $blocksiggroup\n", "## set resetgroup [add_wave_group \"Reset\" -into $designtopgroup]\n", - "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/ap_rst_n -into $resetgroup\n", + "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/ap_rst_n -into $resetgroup\n", "## set clockgroup [add_wave_group \"Clock\" -into $designtopgroup]\n", - "## add_wave /apatb_snn_test_lif_top/AESL_inst_snn_test_lif/ap_clk -into $clockgroup\n", + "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/ap_clk -into $clockgroup\n", "## set testbenchgroup [add_wave_group \"Test Bench Signals\"]\n", "## set tbinternalsiggroup [add_wave_group \"Internal Signals\" -into $testbenchgroup]\n", "## set tb_simstatus_group [add_wave_group \"Simulation Status\" -into $tbinternalsiggroup]\n", "## set tb_portdepth_group [add_wave_group \"Port Depth\" -into $tbinternalsiggroup]\n", - "## add_wave /apatb_snn_test_lif_top/AUTOTB_TRANSACTION_NUM -into $tb_simstatus_group -radix hex\n", - "## add_wave /apatb_snn_test_lif_top/ready_cnt -into $tb_simstatus_group -radix hex\n", - "## add_wave /apatb_snn_test_lif_top/done_cnt -into $tb_simstatus_group -radix hex\n", - "## add_wave /apatb_snn_test_lif_top/LENGTH_layer4_out -into $tb_portdepth_group -radix hex\n", - "## add_wave /apatb_snn_test_lif_top/LENGTH_x -into $tb_portdepth_group -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/AUTOTB_TRANSACTION_NUM -into $tb_simstatus_group -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/ready_cnt -into $tb_simstatus_group -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/done_cnt -into $tb_simstatus_group -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/LENGTH_layer4_out -into $tb_portdepth_group -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/LENGTH_x -into $tb_portdepth_group -radix hex\n", "## set tbcoutputgroup [add_wave_group \"C Outputs\" -into $testbenchgroup]\n", "## set tb_return_group [add_wave_group return(axis) -into $tbcoutputgroup]\n", - "## add_wave /apatb_snn_test_lif_top/layer4_out_TREADY -into $tb_return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_test_lif_top/layer4_out_TVALID -into $tb_return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_test_lif_top/layer4_out_TDATA -into $tb_return_group -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/layer4_out_TREADY -into $tb_return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/layer4_out_TVALID -into $tb_return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/layer4_out_TDATA -into $tb_return_group -radix hex\n", "## set tbcinputgroup [add_wave_group \"C Inputs\" -into $testbenchgroup]\n", "## set tb_return_group [add_wave_group return(axis) -into $tbcinputgroup]\n", - "## add_wave /apatb_snn_test_lif_top/x_TREADY -into $tb_return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_test_lif_top/x_TVALID -into $tb_return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_test_lif_top/x_TDATA -into $tb_return_group -radix hex\n", - "## save_wave_config snn_test_lif.wcfg\n", + "## add_wave /apatb_snn_smoke_vitis_top/x_TREADY -into $tb_return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/x_TVALID -into $tb_return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_snn_smoke_vitis_top/x_TDATA -into $tb_return_group -radix hex\n", + "## save_wave_config snn_smoke_vitis.wcfg\n", "## run all\n", "////////////////////////////////////////////////////////////////////////////////////\n", "// Inter-Transaction Progress: Completed Transaction / Total Transaction\n", @@ -1091,21 +1283,21 @@ "// RTL Simulation : 4 / 5 [100.00%] @ \"208000\"\n", "// RTL Simulation : 5 / 5 [100.00%] @ \"223000\"\n", "////////////////////////////////////////////////////////////////////////////////////\n", - "$finish called at time : 252500 ps : File \"/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/sim/verilog/snn_test_lif.autotb.v\" Line 249\n", + "$finish called at time : 252500 ps : File \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis.autotb.v\" Line 249\n", "## quit\n", - "INFO: [Common 17-206] Exiting xsim at Mon Apr 27 10:38:31 2026...\n", + "INFO: [Common 17-206] Exiting xsim at Mon May 4 18:22:12 2026...\n", "WARNING: [HLS 200-2011] Cannot find the 'zip' utility on this system. This is required for cosimulation.\n", "INFO: [COSIM 212-316] Starting C post checking ...\n", "INFO: Unable to open input/predictions file, using default input.\n", - "-0.25 -0.25 \n", - "-0.25 -0.25 \n", - "-0.25 -1 \n", - "-0.25 -0.75 \n", - "-0.25 -0.25 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", + "0.3125 0.28125 \n", "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", "INFO:\n", - "Report time : Mon Apr 27 10:38:24 AM IST 2026.\n", + "Report time : Mon May 4 06:22:04 PM IST 2026.\n", "Solution : solution1.\n", "Simulation tool : xsim.\n", "\n", @@ -1118,7 +1310,7 @@ "| Verilog| Pass| NA| NA| NA| NA| NA| NA| NA|\n", "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", "\n", - "***** C/RTL SIMULATION COMPLETED IN 0h0m19s *****\n", + "***** C/RTL SIMULATION COMPLETED IN 0h0m20s *****\n", "***** C/RTL VALIDATION *****\n", "INFO: Test PASSED\n", "***** EXPORT IP *****\n", @@ -1129,16 +1321,16 @@ " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Mon Apr 27 10:38:33 2026\n", + " **** Start of session at: Mon May 4 18:22:14 2026\n", " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", "\n", "source run_ippack.tcl -notrace\n", - "INFO: calling package_hls_ip ip_types=vitis sysgen json_file=/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/solution1_data.json outdir=/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip srcdir=/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1 sort_interfaces_ports=false\n", - "INFO: Copied 1 ipmisc file(s) to /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip/misc\n", - "INFO: Copied 15 verilog file(s) to /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip/hdl/verilog\n", - "INFO: Copied 10 vhdl file(s) to /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip/hdl/vhdl\n", - "INFO: Import ports from HDL: /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip/hdl/vhdl/snn_test_lif.vhd (snn_test_lif)\n", + "INFO: calling package_hls_ip ip_types=vitis sysgen json_file=/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/solution1_data.json outdir=/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip srcdir=/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1 sort_interfaces_ports=false\n", + "INFO: Copied 1 ipmisc file(s) to /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip/misc\n", + "INFO: Copied 18 verilog file(s) to /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip/hdl/verilog\n", + "INFO: Copied 13 vhdl file(s) to /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip/hdl/vhdl\n", + "INFO: Import ports from HDL: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip/hdl/vhdl/snn_smoke_vitis.vhd (snn_smoke_vitis)\n", "INFO: Add axi4stream interface x\n", "INFO: Add axi4stream interface layer4_out\n", "INFO: [IP_Flow 19-234] Refreshing IP repositories\n", @@ -1150,19 +1342,19 @@ "INFO: Calling post_process_vitis to specialize IP\n", "INFO: Calling post_process_sysgen to specialize IP\n", "Generating sysgen info xml from json file\n", - "INFO: Created IP /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip/component.xml\n", - "INFO: Created IP archive /home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/impl/ip/xilinx_com_hls_snn_test_lif_1_0.zip\n", - "INFO: [Common 17-206] Exiting Vivado at Mon Apr 27 10:38:39 2026...\n", - "INFO: [HLS 200-802] Generated output file snn_test_lif_prj/solution1/impl/export.zip\n", - "INFO: [HLS 200-2161] Finished Command export_design Elapsed time: 00:00:17; Allocated memory: 0.000 MB.\n", - "***** EXPORT IP COMPLETED IN 0h0m17s *****\n", + "INFO: Created IP /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip/component.xml\n", + "INFO: Created IP archive /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip/xilinx_com_hls_snn_smoke_vitis_1_0.zip\n", + "INFO: [Common 17-206] Exiting Vivado at Mon May 4 18:22:20 2026...\n", + "INFO: [HLS 200-802] Generated output file snn_smoke_vitis_prj/solution1/impl/export.zip\n", + "INFO: [HLS 200-2161] Finished Command export_design Elapsed time: 00:00:18; Allocated memory: 0.000 MB.\n", + "***** EXPORT IP COMPLETED IN 0h0m18s *****\n", "***** VIVADO SYNTHESIS *****\n", "\n", "****** Vivado v2024.1 (64-bit)\n", " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Mon Apr 27 10:38:50 2026\n", + " **** Start of session at: Mon May 4 18:22:31 2026\n", " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", "\n", @@ -1170,7 +1362,7 @@ "# set tcldir [file dirname [info script]]\n", "# source [file join $tcldir project.tcl]\n", "## variable project_name\n", - "## set project_name \"snn_test_lif\"\n", + "## set project_name \"snn_smoke_vitis\"\n", "## variable backend\n", "## set backend \"vitis\"\n", "## variable part\n", @@ -1178,97 +1370,124 @@ "## variable clock_period\n", "## set clock_period 5\n", "## variable clock_uncertainty\n", - "## set clock_uncertainty 27%\n", + "## set clock_uncertainty 18%\n", "## variable version\n", "## set version \"1.0.0\"\n", "## variable maximum_size\n", "## set maximum_size 4096\n", "# add_files ${project_name}_prj/solution1/syn/verilog\n", "# synth_design -top ${project_name} -part $part\n", - "Command: synth_design -top snn_test_lif -part xczu7ev-ffvc1156-2-e\n", + "Command: synth_design -top snn_smoke_vitis -part xczu7ev-ffvc1156-2-e\n", "Starting synth_design\n", "Attempting to get a license for feature 'Synthesis' and/or device 'xczu7ev'\n", "INFO: [Common 17-349] Got license for feature 'Synthesis' and/or device 'xczu7ev'\n", "INFO: [Synth 8-7079] Multithreading enabled for synth_design using a maximum of 4 processes.\n", "INFO: [Synth 8-7078] Launching helper process for spawning children vivado processes\n", - "INFO: [Synth 8-7075] Helper process launched with PID 13247\n", - "---------------------------------------------------------------------------------\n", - "Starting Synthesize : Time (s): cpu = 00:00:02 ; elapsed = 00:00:03 . Memory (MB): peak = 1875.809 ; gain = 425.641 ; free physical = 1408 ; free virtual = 25077\n", - "---------------------------------------------------------------------------------\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s.v:9]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_regslice_both' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_regslice_both.v:9]\n", + "INFO: [Synth 8-7075] Helper process launched with PID 20915\n", + "---------------------------------------------------------------------------------\n", + "Starting Synthesize : Time (s): cpu = 00:00:02 ; elapsed = 00:00:03 . Memory (MB): peak = 1875.934 ; gain = 426.637 ; free physical = 3503 ; free virtual = 24901\n", + "---------------------------------------------------------------------------------\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_mul_8s_6ns_13_1_1' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_mul_8s_6ns_13_1_1.v:5]\n", + "\tParameter ID bound to: 1 - type: integer \n", + "\tParameter NUM_STAGE bound to: 1 - type: integer \n", + "\tParameter din0_WIDTH bound to: 8 - type: integer \n", + "\tParameter din1_WIDTH bound to: 6 - type: integer \n", + "\tParameter dout_WIDTH bound to: 13 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_mul_8s_6ns_13_1_1' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_mul_8s_6ns_13_1_1.v:5]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_mul_8s_7s_13_1_1' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_mul_8s_7s_13_1_1.v:5]\n", + "\tParameter ID bound to: 1 - type: integer \n", + "\tParameter NUM_STAGE bound to: 1 - type: integer \n", + "\tParameter din0_WIDTH bound to: 8 - type: integer \n", + "\tParameter din1_WIDTH bound to: 7 - type: integer \n", + "\tParameter dout_WIDTH bound to: 13 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_mul_8s_7s_13_1_1' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_mul_8s_7s_13_1_1.v:5]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_regslice_both' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_regslice_both.v:9]\n", "\tParameter DataWidth bound to: 16 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_regslice_both' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_regslice_both.v:9]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s.v:9]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s.v:9]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s.v:9]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_fifo_w64_d1_S' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_fifo_w64_d1_S.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_fifo_w64_d1_S_ShiftReg' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_fifo_w64_d1_S.v:129]\n", - "\tParameter DATA_WIDTH bound to: 64 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_regslice_both' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_regslice_both.v:9]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s.v:9]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_mul_8s_6s_13_1_1' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_mul_8s_6s_13_1_1.v:5]\n", + "\tParameter ID bound to: 1 - type: integer \n", + "\tParameter NUM_STAGE bound to: 1 - type: integer \n", + "\tParameter din0_WIDTH bound to: 8 - type: integer \n", + "\tParameter din1_WIDTH bound to: 6 - type: integer \n", + "\tParameter dout_WIDTH bound to: 13 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_mul_8s_6s_13_1_1' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_mul_8s_6s_13_1_1.v:5]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s.v:9]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_fifo_w32_d1_S' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_fifo_w32_d1_S.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_fifo_w32_d1_S_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_fifo_w32_d1_S.v:129]\n", + "\tParameter DATA_WIDTH bound to: 32 - type: integer \n", "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", "\tParameter DEPTH bound to: 1 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_fifo_w64_d1_S_ShiftReg' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_fifo_w64_d1_S.v:129]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_fifo_w64_d1_S' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_fifo_w64_d1_S.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0_ShiftReg' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0.v:125]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_fifo_w32_d1_S_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_fifo_w32_d1_S.v:129]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_fifo_w32_d1_S' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_fifo_w32_d1_S.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0.v:125]\n", "\tParameter DATA_WIDTH bound to: 1 - type: integer \n", "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", "\tParameter DEPTH bound to: 2 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0.v:125]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0_ShiftReg' [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0.v:125]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0.v:125]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0.v:125]\n", "\tParameter DATA_WIDTH bound to: 1 - type: integer \n", "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", "\tParameter DEPTH bound to: 2 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0.v:125]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0.v:11]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_test_lif' (0#1) [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif.v:9]\n", - "WARNING: [Synth 8-7129] Port addr[0] in module snn_test_lif_fifo_w64_d1_S_ShiftReg is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port data_3_val3[1] in module snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port data_3_val3[0] in module snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port ap_rst in module snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_dout[59] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_dout[58] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_dout[57] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_dout[56] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_dout[47] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_dout[46] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_dout[45] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_dout[44] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_dout[3] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_dout[2] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_dout[1] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_dout[0] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port ap_rst in module snn_test_lif_dense_latency_wrapper_ap_fixed_4_2_5_3_0_ap_fixed_4_2_5_3_0_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s is either unconnected or has no load\n", - "---------------------------------------------------------------------------------\n", - "Finished Synthesize : Time (s): cpu = 00:00:03 ; elapsed = 00:00:04 . Memory (MB): peak = 1956.777 ; gain = 506.609 ; free physical = 1309 ; free virtual = 24981\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Constraint Validation : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1971.621 ; gain = 521.453 ; free physical = 1300 ; free virtual = 24973\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0.v:125]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0.v:11]\n", + "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis.v:9]\n", + "WARNING: [Synth 8-7129] Port addr[0] in module snn_smoke_vitis_fifo_w32_d1_S_ShiftReg is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port ap_rst in module snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[28] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[27] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[26] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[25] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[24] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[20] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[19] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[18] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[17] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[16] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[12] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[11] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[10] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[9] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[8] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[4] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[3] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[2] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[1] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_dout[0] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port ap_rst in module snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s is either unconnected or has no load\n", + "---------------------------------------------------------------------------------\n", + "Finished Synthesize : Time (s): cpu = 00:00:03 ; elapsed = 00:00:04 . Memory (MB): peak = 1955.871 ; gain = 506.574 ; free physical = 3403 ; free virtual = 24802\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Constraint Validation : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1973.684 ; gain = 524.387 ; free physical = 3394 ; free virtual = 24793\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Loading Part and Timing Information\n", @@ -1277,9 +1496,9 @@ "INFO: [Synth 8-6742] Reading net delay rules and data\n", "INFO: [Device 21-403] Loading part xczu7ev-ffvc1156-2-e\n", "---------------------------------------------------------------------------------\n", - "Finished Loading Part and Timing Information : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1988.531 ; gain = 538.363 ; free physical = 1296 ; free virtual = 24969\n", + "Finished Loading Part and Timing Information : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1990.594 ; gain = 541.297 ; free physical = 3386 ; free virtual = 24785\n", "---------------------------------------------------------------------------------\n", - "INFO: [Synth 8-802] inferred FSM for state register 'state_reg' in module 'snn_test_lif_regslice_both'\n", + "INFO: [Synth 8-802] inferred FSM for state register 'state_reg' in module 'snn_smoke_vitis_regslice_both'\n", "INFO: [Synth 8-4490] FSM extraction disabled for register 'ap_CS_fsm_reg' through user attribute\n", "INFO: [Synth 8-4490] FSM extraction disabled for register 'ap_CS_fsm_reg' through user attribute\n", "---------------------------------------------------------------------------------------------------\n", @@ -1289,9 +1508,9 @@ " ONE | 10 | 11\n", " TWO | 01 | 01\n", "---------------------------------------------------------------------------------------------------\n", - "INFO: [Synth 8-3354] encoded FSM with state register 'state_reg' using encoding 'sequential' in module 'snn_test_lif_regslice_both'\n", + "INFO: [Synth 8-3354] encoded FSM with state register 'state_reg' using encoding 'sequential' in module 'snn_smoke_vitis_regslice_both'\n", "---------------------------------------------------------------------------------\n", - "Finished RTL Optimization Phase 2 : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1988.531 ; gain = 538.363 ; free physical = 1288 ; free virtual = 24962\n", + "Finished RTL Optimization Phase 2 : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1990.594 ; gain = 541.297 ; free physical = 3374 ; free virtual = 24776\n", "---------------------------------------------------------------------------------\n", "No constraint files found.\n", "---------------------------------------------------------------------------------\n", @@ -1299,22 +1518,23 @@ "---------------------------------------------------------------------------------\n", "Detailed RTL Component Info : \n", "+---Adders : \n", - "\t 3 Input 6 Bit Adders := 2 \n", - "\t 4 Input 6 Bit Adders := 16 \n", - "\t 3 Input 4 Bit Adders := 8 \n", - "\t 2 Input 4 Bit Adders := 22 \n", - "\t 7 Input 4 Bit Adders := 1 \n", - "\t 10 Input 4 Bit Adders := 1 \n", - "\t 2 Input 3 Bit Adders := 4 \n", + "\t 3 Input 13 Bit Adders := 3 \n", + "\t 2 Input 12 Bit Adders := 1 \n", + "\t 3 Input 12 Bit Adders := 2 \n", + "\t 3 Input 8 Bit Adders := 5 \n", + "\t 2 Input 8 Bit Adders := 1 \n", + "\t 2 Input 7 Bit Adders := 1 \n", + "\t 2 Input 6 Bit Adders := 1 \n", + "\t 2 Input 5 Bit Adders := 2 \n", "\t 2 Input 2 Bit Adders := 4 \n", "\t 2 Input 1 Bit Adders := 4 \n", "+---Registers : \n", - "\t 64 Bit Registers := 2 \n", + "\t 32 Bit Registers := 2 \n", "\t 16 Bit Registers := 4 \n", - "\t 4 Bit Registers := 60 \n", + "\t 8 Bit Registers := 8 \n", "\t 3 Bit Registers := 1 \n", "\t 2 Bit Registers := 7 \n", - "\t 1 Bit Registers := 25 \n", + "\t 1 Bit Registers := 29 \n", "+---Muxes : \n", "\t 2 Input 16 Bit Muxes := 2 \n", "\t 5 Input 3 Bit Muxes := 1 \n", @@ -1322,7 +1542,7 @@ "\t 2 Input 2 Bit Muxes := 30 \n", "\t 3 Input 2 Bit Muxes := 6 \n", "\t 4 Input 2 Bit Muxes := 3 \n", - "\t 2 Input 1 Bit Muxes := 48 \n", + "\t 2 Input 1 Bit Muxes := 32 \n", "---------------------------------------------------------------------------------\n", "Finished RTL Component Statistics \n", "---------------------------------------------------------------------------------\n", @@ -1340,27 +1560,21 @@ "Start Cross Boundary and Area Optimization\n", "---------------------------------------------------------------------------------\n", "WARNING: [Synth 8-7080] Parallel synthesis criteria is not met\n", - "WARNING: [Synth 8-3936] Found unconnected internal register 'dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_U0/regslice_both_x_U/data_p1_reg' and it is trimmed from '16' to '12' bits. [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_regslice_both.v:42]\n", - "WARNING: [Synth 8-3936] Found unconnected internal register 'dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_U0/regslice_both_x_U/data_p2_reg' and it is trimmed from '16' to '12' bits. [/home/b/Physics/hls4ml/snn_test_lif/snn_test_lif_prj/solution1/syn/verilog/snn_test_lif_regslice_both.v:64]\n", - "WARNING: [Synth 8-7129] Port x_TDATA[15] in module snn_test_lif is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port x_TDATA[14] in module snn_test_lif is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port x_TDATA[13] in module snn_test_lif is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port x_TDATA[12] in module snn_test_lif is either unconnected or has no load\n", "---------------------------------------------------------------------------------\n", - "Finished Cross Boundary and Area Optimization : Time (s): cpu = 00:00:09 ; elapsed = 00:00:09 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 393 ; free virtual = 24049\n", + "Finished Cross Boundary and Area Optimization : Time (s): cpu = 00:00:08 ; elapsed = 00:00:08 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2369 ; free virtual = 23871\n", "---------------------------------------------------------------------------------\n", "No constraint files found.\n", "---------------------------------------------------------------------------------\n", "Start Timing Optimization\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Timing Optimization : Time (s): cpu = 00:00:09 ; elapsed = 00:00:10 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 393 ; free virtual = 24048\n", + "Finished Timing Optimization : Time (s): cpu = 00:00:08 ; elapsed = 00:00:09 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2369 ; free virtual = 23871\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Technology Mapping\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Technology Mapping : Time (s): cpu = 00:00:09 ; elapsed = 00:00:10 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 393 ; free virtual = 24046\n", + "Finished Technology Mapping : Time (s): cpu = 00:00:08 ; elapsed = 00:00:09 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2369 ; free virtual = 23871\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start IO Insertion\n", @@ -1378,37 +1592,37 @@ "Finished Final Netlist Cleanup\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished IO Insertion : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 396 ; free virtual = 24058\n", + "Finished IO Insertion : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23876\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Renaming Generated Instances\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Renaming Generated Instances : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 396 ; free virtual = 24059\n", + "Finished Renaming Generated Instances : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23876\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Rebuilding User Hierarchy\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Rebuilding User Hierarchy : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 396 ; free virtual = 24060\n", + "Finished Rebuilding User Hierarchy : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Renaming Generated Ports\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Renaming Generated Ports : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 398 ; free virtual = 24062\n", + "Finished Renaming Generated Ports : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Handling Custom Attributes\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Handling Custom Attributes : Time (s): cpu = 00:00:12 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 398 ; free virtual = 24062\n", + "Finished Handling Custom Attributes : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Renaming Generated Nets\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Renaming Generated Nets : Time (s): cpu = 00:00:12 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 398 ; free virtual = 24062\n", + "Finished Renaming Generated Nets : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Writing Synthesis Report\n", @@ -1421,66 +1635,69 @@ "+-+--------------+----------+\n", "\n", "Report Cell Usage: \n", - "+------+------+------+\n", - "| |Cell |Count |\n", - "+------+------+------+\n", - "|1 |BUFG | 1|\n", - "|2 |LUT1 | 6|\n", - "|3 |LUT2 | 12|\n", - "|4 |LUT3 | 20|\n", - "|5 |LUT4 | 64|\n", - "|6 |LUT5 | 60|\n", - "|7 |LUT6 | 130|\n", - "|8 |MUXF7 | 4|\n", - "|9 |MUXF8 | 1|\n", - "|10 |FDRE | 274|\n", - "|11 |FDSE | 8|\n", - "|12 |IBUF | 13|\n", - "|13 |OBUF | 21|\n", - "+------+------+------+\n", + "+------+-------+------+\n", + "| |Cell |Count |\n", + "+------+-------+------+\n", + "|1 |BUFG | 1|\n", + "|2 |CARRY8 | 17|\n", + "|3 |LUT1 | 16|\n", + "|4 |LUT2 | 56|\n", + "|5 |LUT3 | 35|\n", + "|6 |LUT4 | 57|\n", + "|7 |LUT5 | 40|\n", + "|8 |LUT6 | 58|\n", + "|9 |FDRE | 122|\n", + "|10 |FDSE | 8|\n", + "|11 |IBUF | 21|\n", + "|12 |OBUF | 21|\n", + "+------+-------+------+\n", "\n", "Report Instance Areas: \n", - "+------+------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------+------+\n", - "| |Instance |Module |Cells |\n", - "+------+------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------+------+\n", - "|1 |top | | 614|\n", - "|2 | dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0 |snn_test_lif_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_s | 98|\n", - "|3 | regslice_both_layer4_out_U |snn_test_lif_regslice_both_2 | 82|\n", - "|4 | dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_U0 |snn_test_lif_dense_array_ap_fixed_2u_array_ap_fixed_4_2_5_3_0_16u_config2_s | 179|\n", - "|5 | regslice_both_x_U |snn_test_lif_regslice_both | 127|\n", - "|6 | layer2_out_U |snn_test_lif_fifo_w64_d1_S | 54|\n", - "|7 | U_snn_test_lif_fifo_w64_d1_S_ShiftReg |snn_test_lif_fifo_w64_d1_S_ShiftReg_1 | 46|\n", - "|8 | layer3_out_U |snn_test_lif_fifo_w64_d1_S_0 | 21|\n", - "|9 | U_snn_test_lif_fifo_w64_d1_S_ShiftReg |snn_test_lif_fifo_w64_d1_S_ShiftReg | 13|\n", - "|10 | lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0 |snn_test_lif_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_s | 206|\n", - "|11 | start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0_U |snn_test_lif_start_for_dense_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_2u_config4_U0 | 11|\n", - "|12 | start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0_U |snn_test_lif_start_for_lif_neuron_array_ap_fixed_16u_array_ap_fixed_4_2_5_3_0_16u_config3_U0 | 10|\n", - "+------+------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------+------+\n", - "---------------------------------------------------------------------------------\n", - "Finished Writing Synthesis Report : Time (s): cpu = 00:00:12 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 398 ; free virtual = 24062\n", + "+------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+------+\n", + "| |Instance |Module |Cells |\n", + "+------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+------+\n", + "|1 |top | | 452|\n", + "|2 | dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_U0 |snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s | 252|\n", + "|3 | call_ret_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s_fu_47 |snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s | 35|\n", + "|4 | mul_8s_6ns_13_1_1_U1 |snn_smoke_vitis_mul_8s_6ns_13_1_1 | 21|\n", + "|5 | mul_8s_7s_13_1_1_U2 |snn_smoke_vitis_mul_8s_7s_13_1_1 | 2|\n", + "|6 | mul_8s_7s_13_1_1_U3 |snn_smoke_vitis_mul_8s_7s_13_1_1_3 | 1|\n", + "|7 | regslice_both_x_U |snn_smoke_vitis_regslice_both_2 | 198|\n", + "|8 | dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0 |snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s | 82|\n", + "|9 | regslice_both_layer4_out_U |snn_smoke_vitis_regslice_both | 74|\n", + "|10 | layer2_out_U |snn_smoke_vitis_fifo_w32_d1_S | 27|\n", + "|11 | U_snn_smoke_vitis_fifo_w32_d1_S_ShiftReg |snn_smoke_vitis_fifo_w32_d1_S_ShiftReg_1 | 16|\n", + "|12 | layer3_out_U |snn_smoke_vitis_fifo_w32_d1_S_0 | 12|\n", + "|13 | U_snn_smoke_vitis_fifo_w32_d1_S_ShiftReg |snn_smoke_vitis_fifo_w32_d1_S_ShiftReg | 4|\n", + "|14 | lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0 |snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s | 13|\n", + "|15 | start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0_U |snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0 | 11|\n", + "|16 | start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0_U |snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0 | 12|\n", + "+------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+------+\n", + "---------------------------------------------------------------------------------\n", + "Finished Writing Synthesis Report : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", "---------------------------------------------------------------------------------\n", "Synthesis finished with 0 errors, 0 critical warnings and 40 warnings.\n", - "Synthesis Optimization Runtime : Time (s): cpu = 00:00:12 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.562 ; gain = 1404.395 ; free physical = 397 ; free virtual = 24061\n", - "Synthesis Optimization Complete : Time (s): cpu = 00:00:12 ; elapsed = 00:00:12 . Memory (MB): peak = 2854.570 ; gain = 1404.395 ; free physical = 397 ; free virtual = 24061\n", + "Synthesis Optimization Runtime : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", + "Synthesis Optimization Complete : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.555 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", "INFO: [Project 1-571] Translating synthesized netlist\n", - "Netlist sorting complete. Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 2854.570 ; gain = 0.000 ; free physical = 621 ; free virtual = 24280\n", - "INFO: [Netlist 29-17] Analyzing 19 Unisim elements for replacement\n", + "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00.01 . Memory (MB): peak = 2854.555 ; gain = 0.000 ; free physical = 2658 ; free virtual = 24158\n", + "INFO: [Netlist 29-17] Analyzing 39 Unisim elements for replacement\n", "INFO: [Netlist 29-28] Unisim Transformation completed in 0 CPU seconds\n", "INFO: [Project 1-570] Preparing netlist for logic optimization\n", "INFO: [Opt 31-138] Pushed 0 inverter(s) to 0 load pin(s).\n", - "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 2910.590 ; gain = 0.000 ; free physical = 599 ; free virtual = 24238\n", + "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 2910.574 ; gain = 0.000 ; free physical = 2647 ; free virtual = 24159\n", "INFO: [Project 1-111] Unisim Transformation Summary:\n", - " A total of 14 instances were transformed.\n", + " A total of 22 instances were transformed.\n", " BUFG => BUFGCE: 1 instance \n", - " IBUF => IBUF (IBUFCTRL, INBUF): 13 instances\n", + " IBUF => IBUF (IBUFCTRL, INBUF): 21 instances\n", "\n", - "Synth Design complete | Checksum: c630c992\n", + "Synth Design complete | Checksum: 9829e65e\n", "INFO: [Common 17-83] Releasing license: Synthesis\n", - "43 Infos, 40 Warnings, 0 Critical Warnings and 0 Errors encountered.\n", + "49 Infos, 40 Warnings, 0 Critical Warnings and 0 Errors encountered.\n", "synth_design completed successfully\n", - "synth_design: Time (s): cpu = 00:00:15 ; elapsed = 00:00:14 . Memory (MB): peak = 2910.590 ; gain = 1464.402 ; free physical = 599 ; free virtual = 24238\n", - "INFO: [Common 17-2834] synth_design peak Physical Memory [PSS] (MB): overall = 2666.062; main = 2397.660; forked = 449.381\n", - "INFO: [Common 17-2834] synth_design peak Virtual Memory [VSS] (MB): overall = 3881.023; main = 2910.594; forked = 1026.457\n", + "synth_design: Time (s): cpu = 00:00:14 ; elapsed = 00:00:13 . Memory (MB): peak = 2910.574 ; gain = 1464.262 ; free physical = 2647 ; free virtual = 24160\n", + "INFO: [Common 17-2834] synth_design peak Physical Memory [PSS] (MB): overall = 2665.407; main = 2395.605; forked = 448.815\n", + "INFO: [Common 17-2834] synth_design peak Virtual Memory [VSS] (MB): overall = 3881.602; main = 2910.578; forked = 1027.051\n", "# opt_design -retarget -propconst -sweep -bram_power_opt -shift_register_opt\n", "Command: opt_design -retarget -propconst -sweep -bram_power_opt -shift_register_opt\n", "Attempting to get a license for feature 'Implementation' and/or device 'xczu7ev'\n", @@ -1492,100 +1709,100 @@ "INFO: [Project 1-461] DRC finished with 0 Errors\n", "INFO: [Project 1-462] Please refer to the DRC report (report_drc) for more information.\n", "\n", - "Time (s): cpu = 00:00:01 ; elapsed = 00:00:00.78 . Memory (MB): peak = 2974.621 ; gain = 64.031 ; free physical = 608 ; free virtual = 24261\n", + "Time (s): cpu = 00:00:01 ; elapsed = 00:00:00.79 . Memory (MB): peak = 2974.605 ; gain = 64.031 ; free physical = 2644 ; free virtual = 24159\n", "\n", "Starting Cache Timing Information Task\n", "INFO: [Timing 38-35] Done setting XDC timing constraints.\n", - "Ending Cache Timing Information Task | Checksum: 21c8b40a4\n", + "Ending Cache Timing Information Task | Checksum: 284b2e407\n", "\n", - "Time (s): cpu = 00:00:06 ; elapsed = 00:00:06 . Memory (MB): peak = 3521.754 ; gain = 547.133 ; free physical = 242 ; free virtual = 23904\n", + "Time (s): cpu = 00:00:06 ; elapsed = 00:00:07 . Memory (MB): peak = 3520.738 ; gain = 546.133 ; free physical = 2185 ; free virtual = 23742\n", "\n", "Starting Logic Optimization Task\n", "\n", "Phase 1 Initialization\n", "\n", "Phase 1.1 Core Generation And Design Setup\n", - "Phase 1.1 Core Generation And Design Setup | Checksum: 21c8b40a4\n", + "Phase 1.1 Core Generation And Design Setup | Checksum: 284b2e407\n", "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", "\n", "Phase 1.2 Setup Constraints And Sort Netlist\n", - "Phase 1.2 Setup Constraints And Sort Netlist | Checksum: 21c8b40a4\n", + "Phase 1.2 Setup Constraints And Sort Netlist | Checksum: 284b2e407\n", "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", - "Phase 1 Initialization | Checksum: 21c8b40a4\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", + "Phase 1 Initialization | Checksum: 284b2e407\n", "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", "\n", "Phase 2 Timer Update And Timing Data Collection\n", "\n", "Phase 2.1 Timer Update\n", - "Phase 2.1 Timer Update | Checksum: 21c8b40a4\n", + "Phase 2.1 Timer Update | Checksum: 284b2e407\n", "\n", - "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", "\n", "Phase 2.2 Timing Data Collection\n", - "Phase 2.2 Timing Data Collection | Checksum: 21c8b40a4\n", + "Phase 2.2 Timing Data Collection | Checksum: 284b2e407\n", "\n", - "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", - "Phase 2 Timer Update And Timing Data Collection | Checksum: 21c8b40a4\n", + "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", + "Phase 2 Timer Update And Timing Data Collection | Checksum: 284b2e407\n", "\n", - "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", + "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", "\n", "Phase 3 Retarget\n", "INFO: [Opt 31-1834] Total Chains To Be Transformed Were: 0 AND Number of Transformed insts Created are: 0\n", "INFO: [Opt 31-138] Pushed 1 inverter(s) to 34 load pin(s).\n", "INFO: [Opt 31-49] Retargeted 0 cell(s).\n", - "Phase 3 Retarget | Checksum: 23dbf599f\n", + "Phase 3 Retarget | Checksum: 19a399bd1\n", "\n", - "Time (s): cpu = 00:00:00.06 ; elapsed = 00:00:00.03 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", - "Retarget | Checksum: 23dbf599f\n", + "Time (s): cpu = 00:00:00.06 ; elapsed = 00:00:00.03 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", + "Retarget | Checksum: 19a399bd1\n", "INFO: [Opt 31-389] Phase Retarget created 0 cells and removed 1 cells\n", "\n", "Phase 4 Constant propagation\n", "INFO: [Opt 31-138] Pushed 0 inverter(s) to 0 load pin(s).\n", - "Phase 4 Constant propagation | Checksum: 23dbf599f\n", + "Phase 4 Constant propagation | Checksum: 1ad0fe5d2\n", "\n", - "Time (s): cpu = 00:00:00.07 ; elapsed = 00:00:00.03 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", - "Constant propagation | Checksum: 23dbf599f\n", + "Time (s): cpu = 00:00:00.06 ; elapsed = 00:00:00.03 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", + "Constant propagation | Checksum: 1ad0fe5d2\n", "INFO: [Opt 31-389] Phase Constant propagation created 0 cells and removed 0 cells\n", "\n", "Phase 5 Sweep\n", - "Phase 5 Sweep | Checksum: 23dbf599f\n", + "Phase 5 Sweep | Checksum: 21eac55bc\n", "\n", - "Time (s): cpu = 00:00:00.07 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", - "Sweep | Checksum: 23dbf599f\n", - "INFO: [Opt 31-389] Phase Sweep created 0 cells and removed 0 cells\n", + "Time (s): cpu = 00:00:00.06 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", + "Sweep | Checksum: 21eac55bc\n", + "INFO: [Opt 31-389] Phase Sweep created 2 cells and removed 0 cells\n", "\n", "Phase 6 Shift Register Optimization\n", "INFO: [Opt 31-1064] SRL Remap converted 0 SRLs to 0 registers and converted 0 registers of register chains to 0 SRLs\n", - "Phase 6 Shift Register Optimization | Checksum: 23dbf599f\n", + "Phase 6 Shift Register Optimization | Checksum: 21eac55bc\n", "\n", - "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23671\n", - "Shift Register Optimization | Checksum: 23dbf599f\n", + "Time (s): cpu = 00:00:00.06 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", + "Shift Register Optimization | Checksum: 21eac55bc\n", "INFO: [Opt 31-389] Phase Shift Register Optimization created 0 cells and removed 0 cells\n", "\n", "Phase 7 Post Processing Netlist\n", - "Phase 7 Post Processing Netlist | Checksum: 23dbf599f\n", + "Phase 7 Post Processing Netlist | Checksum: 22ebf3ca3\n", "\n", - "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23672\n", - "Post Processing Netlist | Checksum: 23dbf599f\n", + "Time (s): cpu = 00:00:00.07 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", + "Post Processing Netlist | Checksum: 22ebf3ca3\n", "INFO: [Opt 31-389] Phase Post Processing Netlist created 0 cells and removed 0 cells\n", "\n", "Phase 8 Finalization\n", "\n", "Phase 8.1 Finalizing Design Cores and Updating Shapes\n", - "Phase 8.1 Finalizing Design Cores and Updating Shapes | Checksum: 23dbf599f\n", + "Phase 8.1 Finalizing Design Cores and Updating Shapes | Checksum: 17b8ff75a\n", "\n", - "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23672\n", + "Time (s): cpu = 00:00:00.11 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", "\n", "Phase 8.2 Verifying Netlist Connectivity\n", - "Phase 8.2 Verifying Netlist Connectivity | Checksum: 23dbf599f\n", + "Phase 8.2 Verifying Netlist Connectivity | Checksum: 17b8ff75a\n", "\n", - "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23672\n", - "Phase 8 Finalization | Checksum: 23dbf599f\n", + "Time (s): cpu = 00:00:00.11 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", + "Phase 8 Finalization | Checksum: 17b8ff75a\n", "\n", - "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23672\n", + "Time (s): cpu = 00:00:00.11 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", "Opt_design Change Summary\n", "=========================\n", "\n", @@ -1595,228 +1812,176 @@ "-------------------------------------------------------------------------------------------------------------------------\n", "| Retarget | 0 | 1 | 0 |\n", "| Constant propagation | 0 | 0 | 0 |\n", - "| Sweep | 0 | 0 | 0 |\n", + "| Sweep | 2 | 0 | 0 |\n", "| Shift Register Optimization | 0 | 0 | 0 |\n", "| Post Processing Netlist | 0 | 0 | 0 |\n", "-------------------------------------------------------------------------------------------------------------------------\n", "\n", "\n", - "Ending Logic Optimization Task | Checksum: 23dbf599f\n", + "Ending Logic Optimization Task | Checksum: 17b8ff75a\n", "\n", - "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 168 ; free virtual = 23672\n", + "Time (s): cpu = 00:00:00.11 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", "\n", "Starting Power Optimization Task\n", "INFO: [Pwropt 34-132] Skipping clock gating for clocks with a period < 2.00 ns.\n", - "Ending Power Optimization Task | Checksum: 23dbf599f\n", + "Ending Power Optimization Task | Checksum: 17b8ff75a\n", "\n", - "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 166 ; free virtual = 23670\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", "\n", "Starting Final Cleanup Task\n", - "Ending Final Cleanup Task | Checksum: 23dbf599f\n", + "Ending Final Cleanup Task | Checksum: 17b8ff75a\n", "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 166 ; free virtual = 23670\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", "\n", "Starting Netlist Obfuscation Task\n", - "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 166 ; free virtual = 23670\n", - "Ending Netlist Obfuscation Task | Checksum: 23dbf599f\n", + "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", + "Ending Netlist Obfuscation Task | Checksum: 17b8ff75a\n", "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3790.660 ; gain = 0.000 ; free physical = 166 ; free virtual = 23670\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", "INFO: [Common 17-83] Releasing license: Implementation\n", "17 Infos, 0 Warnings, 0 Critical Warnings and 0 Errors encountered.\n", "opt_design completed successfully\n", - "opt_design: Time (s): cpu = 00:00:09 ; elapsed = 00:00:09 . Memory (MB): peak = 3790.660 ; gain = 880.070 ; free physical = 166 ; free virtual = 23670\n", + "opt_design: Time (s): cpu = 00:00:09 ; elapsed = 00:00:09 . Memory (MB): peak = 3781.645 ; gain = 871.070 ; free physical = 1859 ; free virtual = 23420\n", "# report_utilization -file vivado_synth.rpt\n", - "INFO: [Common 17-206] Exiting Vivado at Mon Apr 27 10:39:19 2026...\n", - "***** VIVADO SYNTHESIS COMPLETED IN 0h0m40s *****\n", - "INFO: [HLS 200-112] Total CPU user time: 72.55 seconds. Total CPU system time: 6.7 seconds. Total elapsed time: 98.26 seconds; peak allocated memory: 445.930 MB.\n", - "INFO: [vitis-run 60-791] Total elapsed time: 0h 1m 39s\n", + "INFO: [Common 17-206] Exiting Vivado at Mon May 4 18:22:59 2026...\n", + "***** VIVADO SYNTHESIS COMPLETED IN 0h0m39s *****\n", + "INFO: [HLS 200-112] Total CPU user time: 70.73 seconds. Total CPU system time: 6.81 seconds. Total elapsed time: 98 seconds; peak allocated memory: 431.441 MB.\n", + "INFO: [vitis-run 60-791] Total elapsed time: 0h 1m 38s\n", "INFO: [vitis-run 60-1662] Stopping dispatch session having empty uuid.\n", "Implementation report not found.\n", - "Timing report not found.\n" + "Timing report not found.\n", + "[HLS] build complete\n", + "{'CSimResults': [['0.3125', '0.28125'], ['0.3125', '0.28125'], ['0.3125', '0.28125'], ['0.3125', '0.28125'], ['0.3125', '0.28125']], 'CosimResults': [['0.3125', '0.28125'], ['0.3125', '0.28125'], ['0.3125', '0.28125'], ['0.3125', '0.28125'], ['0.3125', '0.28125']], 'CSynthesisReport': {'TargetClockPeriod': '5.00', 'EstimatedClockPeriod': '3.154', 'BestLatency': '6', 'WorstLatency': '6', 'IntervalMin': '3', 'IntervalMax': '3', 'DSP': '0', 'FF': '278', 'LUT': '936', 'BRAM_18K': '0', 'URAM': '0', 'AvailableBRAM_18K': '624', 'AvailableDSP': '1728', 'AvailableFF': '460800', 'AvailableLUT': '230400', 'AvailableURAM': '96'}, 'VivadoSynthReport': {'LUT': '215', 'FF': '132', 'BRAM_18K': '0', 'URAM': '0', 'DSP48E': '0'}, 'CosimReport': {'RTL': 'Verilog', 'Status': 'Pass', 'LatencyMin': 8, 'LatencyMax': 10, 'IntervalMin': 2, 'IntervalMax': 4, 'LatencyAvg': 8.8, 'IntervalAvg': 2.75}}\n" ] - }, - { - "data": { - "text/plain": [ - "{'CSimResults': [['-0.25', '-0.25'],\n", - " ['-0.25', '-0.25'],\n", - " ['-0.25', '-1'],\n", - " ['-0.25', '-0.75'],\n", - " ['-0.25', '-0.25']],\n", - " 'CosimResults': [['-0.25', '-0.25'],\n", - " ['-0.25', '-0.25'],\n", - " ['-0.25', '-1'],\n", - " ['-0.25', '-0.75'],\n", - " ['-0.25', '-0.25']],\n", - " 'CSynthesisReport': {'TargetClockPeriod': '5.00',\n", - " 'EstimatedClockPeriod': '3.524',\n", - " 'BestLatency': '6',\n", - " 'WorstLatency': '6',\n", - " 'IntervalMin': '3',\n", - " 'IntervalMax': '3',\n", - " 'FF': '450',\n", - " 'LUT': '1744',\n", - " 'BRAM_18K': '0',\n", - " 'DSP': '0',\n", - " 'URAM': '0',\n", - " 'AvailableBRAM_18K': '624',\n", - " 'AvailableDSP': '1728',\n", - " 'AvailableFF': '460800',\n", - " 'AvailableLUT': '230400',\n", - " 'AvailableURAM': '96'},\n", - " 'VivadoSynthReport': {'LUT': '238',\n", - " 'FF': '282',\n", - " 'BRAM_18K': '0',\n", - " 'URAM': '0',\n", - " 'DSP48E': '0'},\n", - " 'CosimReport': {'RTL': 'Verilog',\n", - " 'Status': 'Pass',\n", - " 'LatencyMin': 8,\n", - " 'LatencyMax': 10,\n", - " 'IntervalMin': 2,\n", - " 'IntervalMax': 4,\n", - " 'LatencyAvg': 8.8,\n", - " 'IntervalAvg': 2.75}}" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ - "rname = 'snn_test_lif'\n", - "output_dir = Path(rname)\n", - "backend = 'Vitis'\n", - "\n", - "# optional load model weights instead\n", - "#torch.save(single_step_model.state_dict(), output_dir / \"model_weights.pt\")\n", - "#state_dict = torch.load(output_dir / \"model_weights.pt\")\n", - "#single_step_model.load_state_dict(state_dict)\n", - "#single_step_model.eval()\n", - "\n", - "# create savedir\n", - "output_dir.mkdir(parents=True, exist_ok=True)\n", - "\n", - "# set variable for precision\n", - "q4 = 'ap_fixed<4,2>'\n", - "\n", - "# build the initial per-layer config\n", - "hls_config = hls4ml.utils.config_from_pytorch_model(\n", - " single_step_model, # model we are converting\n", - " input_shape=(2,), # one timestep input shape\n", - " granularity='name', # create entries per layer name\n", - " backend=backend, # use specified backend, vitis/vivado\n", - " default_precision=q4, # default weight precision\n", + "hls_model, hls_cfg = convert_hls(\n", + " step_model=step_model,\n", + " out_dir=output_dir,\n", + " backend=backend,\n", + " part=part,\n", + " precision=precision,\n", ")\n", "\n", - "# set reuse factor\n", - "hls_config['Model']['ReuseFactor'] = 1\n", - "\n", - "# quantizing all model variables\n", - "hls_config['Model']['Precision']['default'] = q4\n", - "for _, layer_cfg in hls_config.get('LayerName', {}).items():\n", - " prec = layer_cfg.setdefault('Precision', {})\n", - " prec['result'] = q4\n", - " prec['accum'] = q4\n", - " prec['weight'] = q4\n", - " prec['bias'] = q4\n", - "\n", - "# convert to hls4ml Model Graph\n", - "hls_model = hls4ml.converters.convert_from_pytorch_model(\n", - " single_step_model, # model we are converting\n", - " output_dir=str(output_dir), # where we save the model\n", - " project_name=rname, # project name\n", - " backend=backend, # vitis/vivado\n", - " io_type='io_stream', # io_stream or io_parallel\n", - " #io_type='io_parallel', \n", - " hls_config=hls_config, # the config from above\n", - " part=\"xczu7ev-ffvc1156-2-e\", # set your FPGA part\n", - " clock_period=5, # clock period in nanoseconds\n", - " clock_uncertainty=\"27%\", # clock uncertainty\n", - ")\n", - "# writes c++/headers/tcl/project files to disk\n", - "hls_model.write()\n", - "\n", - "# check it all exists\n", - "hls_cpp = output_dir / 'firmware' / Path( rname + '.cpp' )\n", - "if not hls_cpp.exists():\n", - " raise RuntimeError(f'Expected generated HLS source missing: {hls_cpp}')\n", - "\n", - "# print result\n", - "print(f'Generated HLS project at: {output_dir}')\n", - "print(f'Generated top file: {hls_cpp}')\n", - "\n", - "# build and get vitis report\n", - "rep = hls_model.build(\n", - " reset=True,\n", - " csim=True,\n", - " synth=True,\n", - " cosim=True,\n", - " validation=True,\n", - " export=True,\n", - " vsynth=True,\n", - ")\n", - "rep" + "with open(output_dir / \"hls_config_used.json\", \"w\") as f:\n", + " json.dump(hls_cfg, f, indent=2, default=str)\n", + "\n", + "if not skip_build:\n", + " print(\"[HLS] building with full synthesis flow...\")\n", + " report = hls_model.build(\n", + " reset=True,\n", + " csim=True,\n", + " synth=True,\n", + " cosim=True,\n", + " validation=True,\n", + " export=True,\n", + " vsynth=True,\n", + " )\n", + " print(\"[HLS] build complete\")\n", + " print(report)\n", + "else:\n", + " print(\"[HLS] build skipped by flag\")" ] }, { - "cell_type": "markdown", - "id": "399e5116-a303-4824-858a-c822d579865e", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, + "cell_type": "code", + "execution_count": 18, + "id": "52cc336a-d6a0-4e46-9b17-49faaf3ff3ae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[HLS] model compiled for predict()\n", + "[HLS] test accuracy=0.8000\n", + "[HLS] sequence throughput (locally, not a hardware sim)=607.04 samples/s\n" + ] + } + ], "source": [ - "## run neurobench" + "hls_model.compile()\n", + "print(\"[HLS] model compiled for predict()\")\n", + "hls_acc, hls_throughput = evaluate_hls_sequence(hls_model, x_tst, y_tst)\n", + "print(f\"[HLS] test accuracy={hls_acc:.4f}\")\n", + "print(f\"[HLS] sequence throughput (locally, not a hardware sim)={hls_throughput:.2f} samples/s\")" ] }, { "cell_type": "markdown", - "id": "a6843c36-d9de-4129-ba31-412077693113", - "metadata": {}, + "id": "ffd57a01-8921-4e9a-b305-5fcae54780c9", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ - "set up the model for neurobench" + "## neurobench analysis" ] }, { "cell_type": "code", - "execution_count": 61, - "id": "bbe8aea9-4506-4ddc-b7d0-decb42302345", + "execution_count": 19, + "id": "d9e82e2e-70e6-4c08-8d64-532d4960cdd3", "metadata": {}, "outputs": [], "source": [ "test_loader = DataLoader(\n", - " TensorDataset(x.float(), y.long()),\n", + " TensorDataset(tx_tst.float(), ty_tst.long()),\n", " batch_size=64,\n", " shuffle=False,\n", - ")\n", - "\n", - "single_step_model.eval()\n", - "\n", - "nb_model = SNNTorchModel(single_step_model)" + ")" ] }, { - "cell_type": "markdown", - "id": "065b22e1-6f3c-4fe6-aa60-0b464d8735c4", + "cell_type": "code", + "execution_count": 20, + "id": "6eca41dd-2871-4934-842e-d4c1054bd112", "metadata": {}, + "outputs": [], "source": [ - "define preprocessing, postprocessing, and metrics for neurobench to track" + "step_model.eval()\n", + "\n", + "# Wrap the single-step SNN for NeuroBench.\n", + "# SNNTorchModel will run the step model over the sequence dimension.\n", + "nb_model = SNNTorchModel(step_model)" ] }, { "cell_type": "code", - "execution_count": 62, - "id": "df860349-1bae-4238-984e-ed06a69f8111", + "execution_count": 21, + "id": "ff135acf-75e5-4f80-8a46-cc5581b204d7", "metadata": {}, "outputs": [], "source": [ - "class ArgmaxLogits:\n", + "class SumTimeArgmax:\n", + " \"\"\"Convert per-timestep logits to class predictions.\n", + "\n", + " SNNTorchModel returns logits with shape [batch, timesteps, classes].\n", + " This matches the notebook's evaluation logic:\n", + " mem2 = sum_t fc2(spk1(t))\n", + " pred = argmax(mem2)\n", + " \"\"\"\n", + "\n", " def __call__(self, preds):\n", - " return preds.sum(dim=1).argmax(dim=1)\n", + " if isinstance(preds, tuple):\n", + " preds = preds[0]\n", + "\n", + " if isinstance(preds, np.ndarray):\n", + " preds = torch.from_numpy(preds)\n", + "\n", + " # Expected case: [B, T, C]\n", + " if preds.ndim == 3:\n", + " return preds.sum(dim=1).argmax(dim=1)\n", + "\n", + " # Fallback if NeuroBench/model already returns [B, C]\n", + " if preds.ndim == 2:\n", + " return preds.argmax(dim=1)\n", + "\n", + " raise ValueError(f\"Unexpected prediction shape from NeuroBench: {preds.shape}\")\n", + "\n", "\n", "preprocessors = []\n", - "postprocessors = [ArgmaxLogits()]\n", + "postprocessors = [SumTimeArgmax()]\n", "\n", "static_metrics = [\n", " Footprint,\n", @@ -1830,18 +1995,10 @@ "]" ] }, - { - "cell_type": "markdown", - "id": "9c6323c4-9a5a-465e-b6bf-a6936a861cfa", - "metadata": {}, - "source": [ - "run the benchmark" - ] - }, { "cell_type": "code", - "execution_count": 63, - "id": "654390ad-9ab8-44db-bada-3be720edfe5b", + "execution_count": 22, + "id": "99027e7e-fbed-4263-afc0-d7eee55804a0", "metadata": {}, "outputs": [ { @@ -1855,15 +2012,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 105.50it/s]" + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [00:00<00:00, 32.05it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "{'Footprint': 860, 'ConnectionSparsity': 0.0, 'ClassificationAccuracy': 0.93, 'ActivationSparsity': 0.84065625, 'SynapticOperations': {'Effective_MACs': 320.0, 'Effective_ACs': 50.99, 'Dense': 640.0}}\n", - "Results saved to snn_test_lif/neurobench_results.json\n" + "{'Footprint': 4908, 'ConnectionSparsity': 0.0, 'ClassificationAccuracy': 0.7900000023841858, 'ActivationSparsity': 0.8682666666666667, 'SynapticOperations': {'Effective_MACs': 400.0, 'Effective_ACs': 52.693333333333335, 'Dense': 800.0}}\n" ] }, { @@ -1875,9 +2031,6 @@ } ], "source": [ - "rname = 'snn_test_lif'\n", - "output_dir = Path(rname)\n", - "\n", "benchmark = Benchmark(\n", " nb_model,\n", " test_loader,\n", @@ -1889,18 +2042,21 @@ "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "\n", "results = benchmark.run(device=device)\n", - "print(results)\n", - "\n", - "benchmark.save_benchmark_results(output_dir / \"neurobench_results\", file_format=\"json\")" + "print(results)" ] }, { "cell_type": "code", - "execution_count": null, - "id": "080b4a2c-d6ff-433a-8d8e-f8e7fdc575db", + "execution_count": 24, + "id": "59ec6474-fd85-4561-9291-f0ed0fdf99be", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "#benchmark.save_benchmark_results(\n", + "# output_dir / \"neurobench_results\",\n", + "# file_format=\"json\",\n", + "#)" + ] } ], "metadata": { diff --git a/test/pytest/test_snn_pytorch.py b/test/pytest/test_snn_pytorch.py index c29ddea9c0..a327f45720 100644 --- a/test/pytest/test_snn_pytorch.py +++ b/test/pytest/test_snn_pytorch.py @@ -43,6 +43,19 @@ def forward(self, x): return x +class SNNReadoutWithResetPolicy(hls4ml.utils.torch.HLS4MLModule): + def __init__(self, n_classes=4, stream_length=7, decision_rule='argmax_spike_count', class_threshold=2, reset_policy='tlast'): + super().__init__() + self.n_classes = n_classes + self.stream_length = stream_length + self.decision_rule = decision_rule + self.class_threshold = class_threshold + self.reset_policy = reset_policy + + def forward(self, x): + return x + + class IFNet(torch.nn.Module): def __init__(self): super().__init__() @@ -69,6 +82,21 @@ def forward(self, x): return self.readout(x) +class SNNClassifierWithResetPolicy(torch.nn.Module): + def __init__(self): + super().__init__() + self.fc = torch.nn.Linear(4, 4) + self.neuron = Leaky(beta=0.95, threshold=1.2, reset_mechanism='subtract') + self.readout = SNNReadoutWithResetPolicy( + n_classes=4, stream_length=7, decision_rule='first_to_threshold', class_threshold=2, reset_policy='host_pulse' + ) + + def forward(self, x): + x = self.fc(x) + x = self.neuron(x) + return self.readout(x) + + class IFNetTol(torch.nn.Module): def __init__(self): super().__init__() @@ -80,6 +108,42 @@ def forward(self, x): return self.neuron(x) +class LIFVectorNet(torch.nn.Module): + def __init__(self): + super().__init__() + self.fc = torch.nn.Linear(4, 4) + self.neuron = Leaky(beta=[0.8, 0.9, 0.85, 0.95], threshold=[1.1, 1.0, 0.9, 1.2], reset_mechanism='subtract') + + def forward(self, x): + x = self.fc(x) + return self.neuron(x) + + +class IFVectorThresholdNet(torch.nn.Module): + def __init__(self): + super().__init__() + self.fc = torch.nn.Linear(4, 4) + self.neuron = Leaky(beta=1.0, threshold=[0.8, 0.9, 1.0, 1.1], reset_mechanism='zero') + + def forward(self, x): + x = self.fc(x) + return self.neuron(x) + + +class LearnedVectorParamsNet(torch.nn.Module): + def __init__(self): + super().__init__() + self.fc = torch.nn.Linear(4, 4) + self.neuron = Leaky(beta=[0.2, 0.3, 0.4, 0.5], threshold=[0.2, 0.3, 0.4, 0.5], reset_mechanism='subtract') + # Simulate learned values being different from initialization at conversion time. + self.neuron.beta = torch.nn.Parameter(torch.tensor([0.72, 0.81, 0.63, 0.94])) + self.neuron.threshold = torch.nn.Parameter(torch.tensor([1.25, 0.95, 1.05, 0.85])) + + def forward(self, x): + x = self.fc(x) + return self.neuron(x) + + @pytest.mark.parametrize( 'model_class,expected_layer', [ @@ -148,3 +212,97 @@ def forward(self, x): layer_names = [layer.class_name for layer in hmodel.get_layers()] assert expected_layer in layer_names + + +@pytest.mark.parametrize( + 'model_class,expected_layer,beta_mode,threshold_mode', + [ + (LIFVectorNet, 'LIFNeuron', 'vector', 'vector'), + (IFVectorThresholdNet, 'IFNeuron', None, 'vector'), + (LIFNet, 'LIFNeuron', 'scalar', 'scalar'), + (IFNet, 'IFNeuron', None, 'scalar'), + ], +) +def test_snn_scalar_vs_vector_modes(test_case_id, model_class, expected_layer, beta_mode, threshold_mode): + model = model_class() + config = hls4ml.utils.config_from_pytorch_model( + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + ) + hmodel = hls4ml.converters.convert_from_pytorch_model( + model, + output_dir=str(test_root_path / test_case_id), + backend='Vivado', + io_type='io_parallel', + hls_config=config, + ) + + layer = [layer for layer in hmodel.get_layers() if layer.class_name == expected_layer][0] + assert layer.get_attr('threshold_mode') == threshold_mode + if threshold_mode == 'vector': + assert layer.get_weights('threshold_vec').data.shape[0] == layer.get_attr('n_out') + if expected_layer == 'LIFNeuron': + assert layer.get_attr('beta_mode') == beta_mode + if beta_mode == 'vector': + assert layer.get_weights('beta_vec').data.shape[0] == layer.get_attr('n_out') + + +def test_snn_uses_current_parameter_values_for_vector_params(test_case_id): + model = LearnedVectorParamsNet() + config = hls4ml.utils.config_from_pytorch_model( + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + ) + hmodel = hls4ml.converters.convert_from_pytorch_model( + model, + output_dir=str(test_root_path / test_case_id), + backend='Vivado', + io_type='io_parallel', + hls_config=config, + ) + + layer = [layer for layer in hmodel.get_layers() if layer.class_name == 'LIFNeuron'][0] + assert layer.get_attr('beta_mode') == 'vector' + assert layer.get_attr('threshold_mode') == 'vector' + assert list(layer.get_weights('beta_vec').data) == pytest.approx([0.72, 0.81, 0.63, 0.94]) + assert list(layer.get_weights('threshold_vec').data) == pytest.approx([1.25, 0.95, 1.05, 0.85]) + + +def test_snn_readout_stream_length_alias_and_reset_policy(test_case_id): + model = SNNClassifierWithResetPolicy() + config = hls4ml.utils.config_from_pytorch_model( + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + ) + hmodel = hls4ml.converters.convert_from_pytorch_model( + model, + output_dir=str(test_root_path / test_case_id), + backend='Vivado', + io_type='io_parallel', + hls_config=config, + ) + + readout = [layer for layer in hmodel.get_layers() if layer.class_name == 'SNNReadout'][0] + assert readout.get_attr('window_size') == 7 + assert readout.get_attr('decision_rule') == 'first_to_threshold' + assert readout.get_attr('state_reset_policy') == 'host_pulse' + + +def test_snn_layer_type_config_is_exposed_for_quantization(test_case_id): + model = LIFVectorNet() + config = hls4ml.utils.config_from_pytorch_model( + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + ) + config['LayerName']['neuron']['beta_t'] = 'ap_fixed<12,2>' + config['LayerName']['neuron']['threshold_t'] = 'ap_fixed<10,3>' + config['LayerName']['neuron']['membrane_t'] = 'ap_fixed<14,4>' + + hmodel = hls4ml.converters.convert_from_pytorch_model( + model, + output_dir=str(test_root_path / test_case_id), + backend='Vivado', + io_type='io_parallel', + hls_config=config, + ) + + layer = [layer for layer in hmodel.get_layers() if layer.class_name == 'LIFNeuron'][0] + assert layer.get_attr('beta_t').precision.definition_cpp() == 'ap_fixed<12,2>' + assert layer.get_attr('threshold_t').precision.definition_cpp() == 'ap_fixed<10,3>' + assert layer.get_attr('membrane_t').precision.definition_cpp() == 'ap_fixed<14,4>' From 9afeb79e3c14451ea6ec4b568c850815f88fc462 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 4 May 2026 20:19:38 +0100 Subject: [PATCH 06/32] update docs --- docs/advanced/snn.rst | 24 +- hls4snn-demo.ipynb | 2083 ----------------------------------------- 2 files changed, 20 insertions(+), 2087 deletions(-) delete mode 100644 hls4snn-demo.ipynb diff --git a/docs/advanced/snn.rst b/docs/advanced/snn.rst index 7fc56bf551..ef831a5026 100644 --- a/docs/advanced/snn.rst +++ b/docs/advanced/snn.rst @@ -12,13 +12,20 @@ updates and layer computations run in standard HLS pipelines/streams each cycle according to interface handshakes. The generated design is not a native asynchronous/event-routed neuromorphic architecture (yet!). -Supported PyTorch modules -========================= +Supported PyTorch modules and readout wrappers +============================================== The frontend currently supports direct parsing of: * ``Leaky`` -> ``LIFNeuron`` (or ``IFNeuron`` when ``beta`` is effectively 1) -* ``SNNReadout`` -> ``SNNReadout`` + +``SNNReadout`` is an hls4ml layer, not a ``snntorch`` module. To use the +built-in hls4ml readout from a PyTorch model, define a lightweight PyTorch +module or custom extension layer, subclass ``hls4ml.utils.torch.HLS4MLModule`` +so that FX treats it as a leaf module, and expose the readout configuration as +attributes. The default parser recognizes a wrapper whose class name is +``SNNReadout``. Alternatively, register a custom PyTorch layer handler that maps +your own module name to the hls4ml ``SNNReadout`` layer. `snntorch` tracing ================== @@ -46,7 +53,7 @@ at conversion time. Readout and Decision Rules ========================== -``SNNReadout`` implements programmable per-model decision policies: +The hls4ml ``SNNReadout`` layer implements programmable per-model decision policies: * ``argmax_spike_count`` * ``first_to_threshold`` @@ -57,6 +64,15 @@ The layer accumulates class spikes over a window. For most decision rules it emi a class ID. For ``binary_logit``, it emits a score equal to ``count(class_1) - count(class_0)``. +When using the default PyTorch parser, the wrapper module should expose these +attributes as needed: + +* ``n_classes`` (defaults to the input feature count if omitted) +* ``window_size`` or ``stream_length`` (defaults to ``1``) +* ``class_threshold`` (defaults to ``1``) +* ``decision_rule`` (defaults to ``argmax_spike_count``) +* ``reset_policy`` or ``state_reset_policy`` (defaults to ``fixed_window``) + Window Boundary Semantics ========================= diff --git a/hls4snn-demo.ipynb b/hls4snn-demo.ipynb deleted file mode 100644 index 9b1805ef4a..0000000000 --- a/hls4snn-demo.ipynb +++ /dev/null @@ -1,2083 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "69096b40-4b90-4aa5-96d0-69e0e2a75ebf", - "metadata": {}, - "source": [ - "# hls4snn" - ] - }, - { - "cell_type": "markdown", - "id": "bdaf653d-4f87-4320-bdc3-44399b928b2f", - "metadata": {}, - "source": [ - "This is a simple notebook that shows how to use hls4ml for SNNs, with neurobench also." - ] - }, - { - "cell_type": "markdown", - "id": "87c72b0e-8b82-4241-9d9e-787d23f6ff5e", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "## imports" - ] - }, - { - "cell_type": "markdown", - "id": "86ec6acb-427e-479f-bcd4-3c913c7dc124", - "metadata": {}, - "source": [ - "Make sure to run:\n", - "\n", - "`\n", - "source /tools/Xilinx/Vitis/2024.1/settings64.sh\n", - "`\n", - "\n", - "`\n", - "source /tools/Xilinx/Vivado/2024.1/settings64.sh\n", - "`\n", - "\n", - "in the terminal before launching the notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "eeefd791-53eb-48ff-b858-b61412814c34", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/home/b/Physics/hls4ml/hls4ml/__init__.py\n" - ] - } - ], - "source": [ - "import os\n", - "import sys\n", - "import json\n", - "import time\n", - "from pathlib import Path\n", - "\n", - "import numpy as np\n", - "import torch\n", - "import torch.nn as nn\n", - "import torch.nn.functional as F\n", - "from torch.utils.data import TensorDataset, DataLoader\n", - "import matplotlib.pyplot as plt\n", - "\n", - "import hls4ml\n", - "import hls4ml.utils.torch\n", - "print(hls4ml.__file__)\n", - "import snntorch as snn\n", - "\n", - "import neurobench\n", - "from neurobench.models import TorchModel, SNNTorchModel\n", - "from neurobench.benchmarks import Benchmark\n", - "from neurobench.metrics.static import (\n", - " Footprint,\n", - " ConnectionSparsity,\n", - ")\n", - "from neurobench.metrics.workload import (\n", - " ClassificationAccuracy,\n", - " ActivationSparsity,\n", - " SynapticOperations,\n", - ")\n", - "\n", - "def set_seed(seed: int) -> None:\n", - " np.random.seed(seed)\n", - " torch.manual_seed(seed)" - ] - }, - { - "cell_type": "markdown", - "id": "653288d0-17e1-42b3-861e-ecf89b47d9d0", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "## data" - ] - }, - { - "cell_type": "markdown", - "id": "d9788ae5-ff34-4cda-b0e3-0a17f4543071", - "metadata": {}, - "source": [ - "creating a simple 2D dataset for the SNN" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "80d75f42-79ed-441f-ae0f-9a78774963b7", - "metadata": {}, - "outputs": [], - "source": [ - "def make_toy_dataset(\n", - " n_samples: int,\n", - " timesteps: int = 20,\n", - " noise_std: float = 0.60,\n", - " amp_jitter: float = 0.55,\n", - ") -> tuple[np.ndarray, np.ndarray]:\n", - " \"\"\"Binary sequence dataset with class-specific temporal signatures.\n", - "\n", - " Class 0: positive early bump on ch0 + mild negative late bump on ch1.\n", - " Class 1: mirrored pattern.\n", - " \"\"\"\n", - " t = np.linspace(0.0, 1.0, timesteps, endpoint=False, dtype=np.float32)\n", - " x = np.zeros((n_samples, timesteps, 2), dtype=np.float32)\n", - " y = np.random.randint(0, 2, size=(n_samples,), dtype=np.int64)\n", - "\n", - " early = np.exp(-0.5 * ((t - 0.33) / 0.16) ** 2).astype(np.float32)\n", - " late = np.exp(-0.5 * ((t - 0.67) / 0.16) ** 2).astype(np.float32)\n", - "\n", - " for i, label in enumerate(y):\n", - " amp = 1.0 + np.random.uniform(-amp_jitter, amp_jitter)\n", - " wave = 0.35 * np.sin(2 * np.pi * t).astype(np.float32)\n", - " mix = np.random.uniform(-0.25, 0.25)\n", - " if label == 0:\n", - " s0 = amp * ((0.95 + mix) * early - 0.7 * late + wave)\n", - " s1 = amp * (-0.35 * early + (0.8 - mix) * late - wave)\n", - " else:\n", - " s0 = amp * (-0.35 * early + (0.8 - mix) * late - wave)\n", - " s1 = amp * ((0.95 + mix) * early - 0.7 * late + wave)\n", - "\n", - " x[i, :, 0] = s0 + np.random.normal(0.0, noise_std, size=timesteps)\n", - " x[i, :, 1] = s1 + np.random.normal(0.0, noise_std, size=timesteps)\n", - "\n", - " return x, y" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "bfd3f387-6e8f-4a4b-afb7-99299ae4b996", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_2d_streams(x, y, max_per_class=50):\n", - " \"\"\"\n", - " x: torch.Tensor or np.ndarray of shape (n_samples, timesteps, 2)\n", - " y: torch.Tensor or np.ndarray of shape (n_samples,)\n", - " \"\"\"\n", - " if hasattr(x, \"detach\"):\n", - " x = x.detach().cpu().numpy()\n", - " if hasattr(y, \"detach\"):\n", - " y = y.detach().cpu().numpy()\n", - "\n", - " x0 = x[y == 0]\n", - " x1 = x[y == 1]\n", - "\n", - " # Optionally limit how many raw streams to draw\n", - " x0_plot = x0[:max_per_class]\n", - " x1_plot = x1[:max_per_class]\n", - "\n", - " t = np.arange(x.shape[1])\n", - "\n", - " # LaTeX-like font styling\n", - " plt.rcParams.update({\n", - " \"font.family\": \"serif\",\n", - " \"font.serif\": [\"Computer Modern Roman\", \"CMU Serif\", \"DejaVu Serif\"],\n", - " \"mathtext.fontset\": \"cm\",\n", - " \"axes.unicode_minus\": False,\n", - " \"font.size\": 12,\n", - " })\n", - "\n", - " fig, axes = plt.subplots(2, 1, figsize=(10, 7), sharex=True)\n", - "\n", - " for d, ax in enumerate(axes):\n", - " # Raw streams\n", - " for seq in x0_plot:\n", - " ax.plot(t, seq[:, d], alpha=0.10, linewidth=1.0)\n", - " for seq in x1_plot:\n", - " ax.plot(t, seq[:, d], alpha=0.10, linewidth=1.0)\n", - "\n", - " # One visible line per class for legend\n", - " ax.plot(t, x0_plot[0, :, d], alpha=0.5, linewidth=1.2, label=\"Class 0 streams\", color='green')\n", - " ax.plot(t, x1_plot[0, :, d], alpha=0.5, linewidth=1.2, label=\"Class 1 streams\", color='red')\n", - "\n", - " # Class means\n", - " ax.plot(t, x0[:, :, d].mean(axis=0), linewidth=3.0, label=\"Class 0 mean\", color='green')\n", - " ax.plot(t, x1[:, :, d].mean(axis=0), linewidth=3.0, label=\"Class 1 mean\", color='red')\n", - "\n", - " ax.set_title(rf\"Dimension ${d}$\")\n", - " ax.set_ylabel(r\"Value\")\n", - " ax.grid(True, alpha=0.25)\n", - " ax.legend(frameon=False, ncol=2)\n", - "\n", - " axes[-1].set_xlabel(r\"Timestep $t$\")\n", - " fig.suptitle(r\"2D stream data by input dimension\", fontsize=16)\n", - " plt.tight_layout()\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "c2e4c80c-ed6f-4d8b-920d-53efe2ddbb45", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "x, y = make_toy_dataset( 200, timesteps=50)\n", - "plot_2d_streams(x, y)" - ] - }, - { - "cell_type": "markdown", - "id": "a553c4d2-1643-403d-8388-32c1de0d65ba", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "## neural nets" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "93e90663-c372-4fec-ac2e-0d7ae81ac9d8", - "metadata": {}, - "outputs": [], - "source": [ - "def to_torch(x: np.ndarray, y: np.ndarray) -> tuple[torch.Tensor, torch.Tensor]:\n", - " return torch.from_numpy(x).float(), torch.from_numpy(y).long()\n", - "\n", - "\n", - "def fake_quant_ste(x: torch.Tensor, frac_bits: int) -> torch.Tensor:\n", - " scale = float(2**frac_bits)\n", - " q = torch.round(x * scale) / scale\n", - " return x + (q - x).detach()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "93a37232-acc0-4867-a097-7db54cbd33ba", - "metadata": {}, - "outputs": [], - "source": [ - "class SNN(nn.Module):\n", - " \"\"\"Sequence model used for training/evaluation.\n", - "\n", - " Output decision uses output-layer membrane potentials:\n", - " mem2(t+1) = mem2(t) + fc2(spk1(t)); class = argmax(mem2(T)).\n", - " \"\"\"\n", - "\n", - " def __init__(self, hidden: int = 4, threshold: float = 1.0, beta_init: float = 0.1):\n", - " super().__init__()\n", - " self.fc1 = nn.Linear(2, hidden)\n", - " self.if1 = snn.Leaky(beta=beta_init, threshold=threshold, learn_beta=True, reset_mechanism=\"subtract\")\n", - " self.fc2 = nn.Linear(hidden, 2)\n", - "\n", - " def forward(self, x_seq: torch.Tensor, qat: bool = False, frac_bits: int = 4) -> torch.Tensor:\n", - " # x_seq: [B, T, 2]\n", - " batch = x_seq.shape[0]\n", - " mem1 = torch.zeros(batch, self.fc1.out_features, device=x_seq.device, dtype=x_seq.dtype)\n", - " mem2 = torch.zeros(batch, 2, device=x_seq.device, dtype=x_seq.dtype)\n", - "\n", - " for t in range(x_seq.shape[1]):\n", - " xt = x_seq[:, t, :]\n", - " if qat:\n", - " xt = fake_quant_ste(xt, frac_bits)\n", - " w1 = fake_quant_ste(self.fc1.weight, frac_bits)\n", - " b1 = fake_quant_ste(self.fc1.bias, frac_bits)\n", - " cur1 = F.linear(xt, w1, b1)\n", - " else:\n", - " cur1 = self.fc1(xt)\n", - "\n", - " spk1, mem1 = self.if1(cur1, mem1)\n", - "\n", - " if qat:\n", - " spk1 = fake_quant_ste(spk1, frac_bits)\n", - " mem1 = fake_quant_ste(mem1, frac_bits)\n", - " w2 = fake_quant_ste(self.fc2.weight, frac_bits)\n", - " b2 = fake_quant_ste(self.fc2.bias, frac_bits)\n", - " mem2 = mem2 + F.linear(spk1, w2, b2)\n", - " mem2 = fake_quant_ste(mem2, frac_bits)\n", - " else:\n", - " mem2 = mem2 + self.fc2(spk1)\n", - "\n", - " return mem2" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "17eb8c99-2123-46d4-b134-ca47a040ef15", - "metadata": {}, - "outputs": [], - "source": [ - "class SNNStep(nn.Module):\n", - " \"\"\"Single-step model for hls4ml conversion: 2 -> Dense(4) -> IF/LIF -> Dense(2).\"\"\"\n", - "\n", - " def __init__(self, hidden: int = 4, threshold: float = 1.0, beta_init: float = 0.1):\n", - " super().__init__()\n", - " self.fc1 = nn.Linear(2, hidden)\n", - " self.if1 = snn.Leaky(beta=beta_init, threshold=threshold, learn_beta=True, reset_mechanism=\"subtract\")\n", - " self.fc2 = nn.Linear(hidden, 2)\n", - "\n", - " def forward(self, x: torch.Tensor):\n", - " x = self.fc1(x)\n", - " x, _ = self.if1(x)\n", - " x = self.fc2(x)\n", - " # keep compatibility with step-style SNN wrappers (neurobench) that expect tuple outputs.\n", - " return x, None" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "8dde4af7-749c-4d8a-a150-7274f79daffa", - "metadata": {}, - "outputs": [], - "source": [ - "def quantize_trainable_beta_inplace(step_model: SNNStep, frac_bits: int) -> None:\n", - " scale = float(2**frac_bits)\n", - " with torch.no_grad():\n", - " step_model.if1.beta.data = torch.round(step_model.if1.beta.data * scale) / scale\n", - "\n", - "\n", - "def reset_step_state(step_model: SNNStep) -> None:\n", - " if hasattr(step_model.if1, \"reset_hidden\"):\n", - " step_model.if1.reset_hidden()\n", - " elif hasattr(step_model.if1, \"reset_mem\"):\n", - " step_model.if1.reset_mem()\n", - "\n", - "\n", - "def sequence_logits_from_step(\n", - " step_model: SNNStep,\n", - " x_seq: torch.Tensor,\n", - " qat: bool = False,\n", - " frac_bits: int = 4,\n", - ") -> torch.Tensor:\n", - " \"\"\"Unroll step model over T and accumulate output-layer membrane proxy.\"\"\"\n", - " reset_step_state(step_model)\n", - " mem2 = torch.zeros(x_seq.shape[0], 2, device=x_seq.device, dtype=x_seq.dtype)\n", - "\n", - " for t in range(x_seq.shape[1]):\n", - " xt = x_seq[:, t, :]\n", - " if qat:\n", - " xt = fake_quant_ste(xt, frac_bits)\n", - " w1 = fake_quant_ste(step_model.fc1.weight, frac_bits)\n", - " b1 = fake_quant_ste(step_model.fc1.bias, frac_bits)\n", - " cur1 = F.linear(xt, w1, b1)\n", - " spk1, _ = step_model.if1(cur1)\n", - " spk1 = fake_quant_ste(spk1, frac_bits)\n", - " w2 = fake_quant_ste(step_model.fc2.weight, frac_bits)\n", - " b2 = fake_quant_ste(step_model.fc2.bias, frac_bits)\n", - " out = F.linear(spk1, w2, b2)\n", - " out = fake_quant_ste(out, frac_bits)\n", - " else:\n", - " out, _ = step_model(xt)\n", - "\n", - " mem2 = mem2 + out\n", - "\n", - " return mem2" - ] - }, - { - "cell_type": "markdown", - "id": "3d7c1dc5-7ae9-4ab7-befe-8492fc6b1e13", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "## training" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "aa79dbb0-74ef-4121-bdf0-986c80d2cefa", - "metadata": {}, - "outputs": [], - "source": [ - "def train_and_qat(\n", - " step_model: SNNStep,\n", - " x_train: torch.Tensor,\n", - " y_train: torch.Tensor,\n", - " x_val: torch.Tensor,\n", - " y_val: torch.Tensor,\n", - " epochs: int = 30,\n", - " qat_epochs: int = 10,\n", - " lr: float = 1e-2,\n", - " frac_bits: int = 4,\n", - " batch_size: int = 64,\n", - " beta_reg: float = 1e-2,\n", - ") -> None:\n", - " criterion = nn.CrossEntropyLoss()\n", - " optim = torch.optim.Adam(step_model.parameters(), lr=lr)\n", - " scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optim, T_max=max(epochs + qat_epochs, 1), eta_min=1e-4)\n", - " train_ds = torch.utils.data.TensorDataset(x_train, y_train)\n", - " train_loader = torch.utils.data.DataLoader(train_ds, batch_size=batch_size, shuffle=True)\n", - "\n", - " for ep in range(epochs):\n", - " step_model.train()\n", - " for xb, yb in train_loader:\n", - " optim.zero_grad()\n", - " logits = sequence_logits_from_step(step_model, xb, qat=False, frac_bits=frac_bits)\n", - " loss = criterion(logits, yb) + beta_reg * torch.mean(step_model.if1.beta**2)\n", - " loss.backward()\n", - " optim.step()\n", - " scheduler.step()\n", - "\n", - " for ep in range(qat_epochs):\n", - " step_model.train()\n", - " for xb, yb in train_loader:\n", - " optim.zero_grad()\n", - " logits = sequence_logits_from_step(step_model, xb, qat=True, frac_bits=frac_bits)\n", - " loss = criterion(logits, yb) + beta_reg * torch.mean(step_model.if1.beta**2)\n", - " loss.backward()\n", - " optim.step()\n", - " quantize_trainable_beta_inplace(step_model, frac_bits)\n", - " scheduler.step()\n", - "\n", - " with torch.no_grad():\n", - " step_model.eval()\n", - " val_logits = sequence_logits_from_step(step_model, x_val, qat=True, frac_bits=frac_bits)\n", - " val_pred = torch.argmax(val_logits, dim=1)\n", - " val_acc = (val_pred == y_val).float().mean().item()\n", - " print(f\"[QAT] epoch={ep + 1:02d}/{qat_epochs} val_acc={val_acc:.4f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "2a30fbd6-be59-4bb5-a82f-d6f8b5542fe2", - "metadata": {}, - "outputs": [], - "source": [ - "def evaluate_torch_step(step_model: SNNStep, x: torch.Tensor, y: torch.Tensor) -> float:\n", - " step_model.eval()\n", - " with torch.no_grad():\n", - " logits = sequence_logits_from_step(step_model, x, qat=False)\n", - " pred = torch.argmax(logits, dim=1)\n", - " return (pred == y).float().mean().item()\n", - "\n", - "\n", - "def export_step_model(seq_model: SNN) -> SNNStep:\n", - " step = SNNStep(hidden=4, threshold=1.0, beta_init=float(seq_model.if1.beta.detach().mean().item()))\n", - " step.fc1.load_state_dict(seq_model.fc1.state_dict())\n", - " step.fc2.load_state_dict(seq_model.fc2.state_dict())\n", - " with torch.no_grad():\n", - " # Preserve trainable beta as vector/scalar parameter for hls4ml parsing.\n", - " if hasattr(step.if1, \"beta\"):\n", - " step.if1.beta.data = seq_model.if1.beta.detach().clone()\n", - " step.eval()\n", - " return step" - ] - }, - { - "cell_type": "markdown", - "id": "8e1f221c-170d-44e7-966a-74cbcdbe99f9", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "## hls config" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "14e97525-7c4a-420e-b881-409852506494", - "metadata": {}, - "outputs": [], - "source": [ - "def build_hls_config(\n", - " step_model: SNNStep,\n", - " backend: str,\n", - " precision: str = \"ap_fixed<8,3>\",\n", - ") -> dict:\n", - " cfg = hls4ml.utils.config_from_pytorch_model(\n", - " step_model,\n", - " input_shape=(2,),\n", - " granularity=\"name\",\n", - " backend=backend,\n", - " default_precision=precision,\n", - " )\n", - "\n", - " cfg[\"Model\"][\"ReuseFactor\"] = 1\n", - " cfg[\"Model\"][\"Precision\"][\"default\"] = precision\n", - "\n", - " for _, layer_cfg in cfg.get(\"LayerName\", {}).items():\n", - " prec = layer_cfg.setdefault(\"Precision\", {})\n", - " prec[\"result\"] = precision\n", - " prec[\"accum\"] = precision\n", - " prec[\"weight\"] = precision\n", - " prec[\"bias\"] = precision\n", - "\n", - " if \"if1\" in cfg.get(\"LayerName\", {}):\n", - " if1_prec = cfg[\"LayerName\"][\"if1\"].setdefault(\"Precision\", {})\n", - " # These map to TypeAttributes beta_t / threshold_t / membrane_t internally.\n", - " if1_prec[\"beta\"] = precision\n", - " if1_prec[\"threshold\"] = precision\n", - " if1_prec[\"membrane\"] = precision\n", - "\n", - " return cfg" - ] - }, - { - "cell_type": "markdown", - "id": "17fb84b2-8cbe-45fe-8491-a7ffe499e8c3", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "## convert hls" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "8375c8fe-16c4-4ee9-a70a-02dd5b7f2c5f", - "metadata": {}, - "outputs": [], - "source": [ - "def convert_hls(\n", - " step_model: SNNStep,\n", - " out_dir: Path,\n", - " backend: str,\n", - " part: str,\n", - " precision: str,\n", - "):\n", - " hls_config = build_hls_config(step_model, backend=backend, precision=precision)\n", - " project_name = out_dir.name\n", - " model = hls4ml.converters.convert_from_pytorch_model(\n", - " step_model,\n", - " output_dir=str(out_dir),\n", - " project_name=project_name,\n", - " backend=backend,\n", - " io_type=\"io_stream\",\n", - " hls_config=hls_config,\n", - " part=part,\n", - " clock_period=5,\n", - " clock_uncertainty=\"18%\",\n", - " )\n", - " model.write()\n", - " return model, hls_config\n", - "\n", - "\n", - "def _extract_predict_array(y):\n", - " if isinstance(y, tuple):\n", - " y = y[0]\n", - " if isinstance(y, dict):\n", - " # choose first output by key ordering\n", - " y = y[next(iter(y.keys()))]\n", - " y = np.asarray(y)\n", - " if y.ndim == 1:\n", - " y = y[None, :]\n", - " return y\n", - "\n", - "\n", - "def evaluate_hls_sequence(hls_model, x_seq: np.ndarray, y_true: np.ndarray) -> tuple[float, float]:\n", - " \"\"\"Sequence classification using output membrane accumulation from per-step outputs.\"\"\"\n", - " t0 = time.perf_counter()\n", - " preds = []\n", - " for i in range(x_seq.shape[0]):\n", - " mem2 = np.zeros((2,), dtype=np.float32)\n", - " for t in range(x_seq.shape[1]):\n", - " inp = x_seq[i, t, :].astype(np.float32)[None, :]\n", - " y_step = _extract_predict_array(hls_model.predict(inp))\n", - " mem2 += y_step[0].astype(np.float32)\n", - " preds.append(int(np.argmax(mem2)))\n", - " dt = time.perf_counter() - t0\n", - " preds = np.asarray(preds, dtype=np.int64)\n", - " acc = float(np.mean(preds == y_true))\n", - " throughput = float(x_seq.shape[0] / dt) if dt > 0 else 0.0\n", - " return acc, throughput" - ] - }, - { - "cell_type": "markdown", - "id": "5d715aa6-97fc-43b4-897b-c1ae9fb672db", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "## run analysis" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "1bd05ecc-67f0-4acf-8ad1-77e09c1974e7", - "metadata": {}, - "outputs": [], - "source": [ - "output_dir = Path(\"examples/snn_smoke_vitis\")\n", - "backend = \"Vitis\"\n", - "part = \"xczu7ev-ffvc1156-2-e\"\n", - "precision = \"ap_fixed<8,3>\"\n", - "skip_build = False\n", - "timesteps = 50\n", - "n_trn = 2000\n", - "n_val = 300\n", - "n_tst = 300\n", - "n_epochs = 40\n", - "n_qat_epochs = 10\n", - "batch_size = 64\n", - "beta_reg = 1e-2\n", - "seed = 0" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "f055e0f2-64b3-4114-a2f0-58b56e8081a4", - "metadata": {}, - "outputs": [], - "source": [ - "set_seed(seed)\n", - "output_dir.mkdir(parents=True, exist_ok=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "00293d90-47a5-4fea-975d-8603ac7a54f6", - "metadata": {}, - "outputs": [], - "source": [ - "x_trn, y_trn = make_toy_dataset(n_trn, timesteps=timesteps)\n", - "x_val, y_val = make_toy_dataset(n_val, timesteps=timesteps)\n", - "x_tst, y_tst = make_toy_dataset(n_tst, timesteps=timesteps)\n", - "\n", - "tx_trn, ty_trn = to_torch(x_trn, y_trn)\n", - "tx_val, ty_val = to_torch(x_val, y_val)\n", - "tx_tst, ty_tst = to_torch(x_tst, y_tst)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "d23cfb24-91a4-41fe-8481-8f4b62e8db0a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[QAT] epoch=01/10 val_acc=0.6667\n", - "[QAT] epoch=02/10 val_acc=0.6967\n", - "[QAT] epoch=03/10 val_acc=0.7200\n", - "[QAT] epoch=04/10 val_acc=0.7000\n", - "[QAT] epoch=05/10 val_acc=0.7000\n", - "[QAT] epoch=06/10 val_acc=0.7000\n", - "[QAT] epoch=07/10 val_acc=0.7000\n", - "[QAT] epoch=08/10 val_acc=0.7000\n", - "[QAT] epoch=09/10 val_acc=0.7200\n", - "[QAT] epoch=10/10 val_acc=0.7000\n", - "[Torch] test accuracy=0.7900\n" - ] - } - ], - "source": [ - "step_model = SNNStep(hidden=4, threshold=1.0, beta_init=0.1)\n", - "\n", - "train_and_qat(\n", - " step_model,\n", - " tx_trn,\n", - " ty_trn,\n", - " tx_val,\n", - " ty_val,\n", - " epochs=n_epochs,\n", - " qat_epochs=n_qat_epochs,\n", - " lr=1e-2,\n", - " frac_bits=4,\n", - " batch_size=batch_size,\n", - " beta_reg=beta_reg,\n", - ")\n", - "\n", - "torch_acc = evaluate_torch_step(step_model, tx_tst, ty_tst)\n", - "print(f\"[Torch] test accuracy={torch_acc:.4f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "c4c13f33-9578-4c9e-954e-7ad01683efce", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Interpreting Model ...\n", - "Topology:\n", - "Layer name: fc1, layer type: Dense, input shape: [[None, 2]]\n", - "Layer name: if1, layer type: LIFNeuron, input shape: [[None, 4]]\n", - "Layer name: fc2, layer type: Dense, input shape: [[None, 4]]\n", - "[HLS] building with full synthesis flow...\n", - "\n", - "****** vitis-run v2024.1 (64-bit)\n", - " **** SW Build 5074859 on 2024-05-20-23:21:20\n", - " **** Start of session at: Mon May 4 18:21:31 2026\n", - " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", - " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", - "\n", - "INFO: [vitis-run 82-31] Launching vitis_hls: vitis_hls -nolog -run tcl -f /home/b/Physics/hls4ml/examples/snn_smoke_vitis/build_prj.tcl -work_dir /home/b/Physics/hls4ml/examples/snn_smoke_vitis\n", - "\n", - "****** Vitis HLS - High-Level Synthesis from C, C++ and OpenCL v2024.1 (64-bit)\n", - " **** SW Build 5069499 on May 21 2024\n", - " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", - " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Mon May 4 18:21:32 2026\n", - " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", - " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", - "\n", - "source /tools/Xilinx/Vitis_HLS/2024.1/scripts/vitis_hls/hls.tcl -notrace\n", - "INFO: [HLS 200-10] For user 'b' on host 'b-comp' (Linux_x86_64 version 6.12.64-1-MANJARO) on Mon May 04 18:21:33 IST 2026\n", - "INFO: [HLS 200-10] On os \"Manjaro Linux\"\n", - "INFO: [HLS 200-10] In directory '/home/b/Physics/hls4ml/examples/snn_smoke_vitis'\n", - "Sourcing Tcl script '/home/b/Physics/hls4ml/examples/snn_smoke_vitis/build_prj.tcl'\n", - "INFO: [HLS 200-1510] Running: open_project -reset snn_smoke_vitis_prj \n", - "INFO: [HLS 200-10] Opening and resetting project '/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj'.\n", - "INFO: [HLS 200-1510] Running: set_top snn_smoke_vitis \n", - "INFO: [HLS 200-1510] Running: add_files firmware/snn_smoke_vitis.cpp -cflags -std=c++0x \n", - "INFO: [HLS 200-10] Adding design file 'firmware/snn_smoke_vitis.cpp' to the project\n", - "INFO: [HLS 200-1510] Running: add_files -tb snn_smoke_vitis_test.cpp -cflags -std=c++0x \n", - "INFO: [HLS 200-10] Adding test bench file 'snn_smoke_vitis_test.cpp' to the project\n", - "INFO: [HLS 200-1510] Running: add_files -tb firmware/weights \n", - "INFO: [HLS 200-10] Adding test bench file 'firmware/weights' to the project\n", - "INFO: [HLS 200-1510] Running: add_files -tb tb_data \n", - "INFO: [HLS 200-10] Adding test bench file 'tb_data' to the project\n", - "INFO: [HLS 200-1510] Running: open_solution -reset solution1 \n", - "INFO: [HLS 200-10] Creating and opening solution '/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1'.\n", - "INFO: [HLS 200-10] Cleaning up the solution database.\n", - "INFO: [HLS 200-1505] Using default flow_target 'vivado'\n", - "Resolution: For help on HLS 200-1505 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=200-1505.html\n", - "INFO: [HLS 200-1510] Running: config_array_partition -maximum_size 4096 \n", - "ERROR: [HLS 200-101] config_array_partition: Unknown option '-maximum_size'.\n", - "ERROR: [HLS 200-101] config_array_partition: Unknown option '4096'.\n", - "SYNTAX \n", - " config_array_partition [OPTIONS]\n", - " -auto_partition_threshold *** DEPRECATED***\n", - " -auto_promotion_threshold *** DEPRECATED***\n", - " -complete_threshold \n", - " -throughput_driven \n", - "\n", - "SEE ALSO\n", - " INI: syn.array_partition.complete_threshold syn.array_partition.throughput_driven\n", - " docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1399-vitis-hls&resourceid=vyw1583260160301.html\n", - "\n", - "INFO: [HLS 200-1510] Running: config_compile -name_max_length 80 \n", - "INFO: [XFORM 203-1161] The maximum of name length is set to 80.\n", - "INFO: [HLS 200-1510] Running: set_part xczu7ev-ffvc1156-2-e \n", - "INFO: [HLS 200-1611] Setting target device to 'xczu7ev-ffvc1156-2-e'\n", - "INFO: [XFORM 203-1161] The maximum of name length is set to 80.\n", - "INFO: [HLS 200-1510] Running: config_schedule -enable_dsp_full_reg=false \n", - "INFO: [HLS 200-1510] Running: create_clock -period 5 -name default \n", - "INFO: [SYN 201-201] Setting up clock 'default' with a period of 5ns.\n", - "INFO: [HLS 200-1510] Running: set_clock_uncertainty 18% default \n", - "INFO: [SYN 201-201] Setting up clock 'default' with an uncertainty of 0.9ns.\n", - "***** C SIMULATION *****\n", - "INFO: [HLS 200-1510] Running: csim_design \n", - "INFO: [SIM 211-2] *************** CSIM start ***************\n", - "INFO: [SIM 211-4] CSIM will launch CLANG as the compiler.\n", - "INFO: [HLS 200-2036] Building debug C Simulation binaries\n", - " Compiling ../../../../snn_smoke_vitis_test.cpp in debug mode\n", - " Compiling ../../../../firmware/snn_smoke_vitis.cpp in debug mode\n", - " Generating csim.exe\n", - "INFO: Unable to open input/predictions file, using default input.\n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "INFO: Saved inference results to file: tb_data/csim_results.log\n", - "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", - "INFO: [SIM 211-1] CSim done with 0 errors.\n", - "INFO: [SIM 211-3] *************** CSIM finish ***************\n", - "INFO: [HLS 200-2161] Finished Command csim_design Elapsed time: 00:00:04; Allocated memory: 0.016 MB.\n", - "***** C SIMULATION COMPLETED IN 0h0m4s *****\n", - "***** C/RTL SYNTHESIS *****\n", - "INFO: [HLS 200-1510] Running: csynth_design \n", - "INFO: [HLS 200-111] Finished File checks and directory preparation: CPU user time: 0.04 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.05 seconds; current allocated memory: 326.801 MB.\n", - "INFO: [HLS 200-10] Analyzing design file 'firmware/snn_smoke_vitis.cpp' ... \n", - "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:33:9)\n", - "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:107:9)\n", - "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:189:9)\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_smoke_vitis.cpp:38:57)\n", - "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_smoke_vitis.cpp:38:61)\n", - "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_smoke_vitis.cpp:40:75)\n", - "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_smoke_vitis.cpp:40:84)\n", - "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_smoke_vitis.cpp:42:70)\n", - "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/snn_smoke_vitis.cpp:42:74)\n", - "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 200-471] Dataflow form checks found 6 issue(s) in file firmware/snn_smoke_vitis.cpp\n", - "Resolution: For help on HLS 200-471 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=200-471.html\n", - "WARNING: [HLS 207-5292] unused parameter 'keep' (firmware/nnet_utils/nnet_helpers.h:285:99)\n", - "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:14:36)\n", - "WARNING: [HLS 207-5292] unused parameter 'buffer' (firmware/nnet_utils/nnet_function_stubs.h:15:36)\n", - "WARNING: [HLS 207-5292] unused parameter 'partition' (firmware/nnet_utils/nnet_function_stubs.h:16:44)\n", - "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:24:24)\n", - "WARNING: [HLS 207-5292] unused parameter 'buffer' (firmware/nnet_utils/nnet_function_stubs.h:25:24)\n", - "WARNING: [HLS 207-5292] unused parameter 'partition' (firmware/nnet_utils/nnet_function_stubs.h:26:32)\n", - "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:33:30)\n", - "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_function_stubs.h:33:58)\n", - "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_function_stubs.h:34:51)\n", - "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_function_stubs.h:35:49)\n", - "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:42:30)\n", - "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_function_stubs.h:42:58)\n", - "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_function_stubs.h:43:51)\n", - "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_function_stubs.h:44:49)\n", - "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:51:29)\n", - "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_function_stubs.h:51:80)\n", - "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_function_stubs.h:52:50)\n", - "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_function_stubs.h:53:48)\n", - "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_code_gen.h:16:39)\n", - "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_code_gen.h:17:38)\n", - "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_code_gen.h:18:60)\n", - "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_code_gen.h:19:58)\n", - "INFO: [HLS 200-111] Finished Source Code Analysis and Preprocessing: CPU user time: 4.09 seconds. CPU system time: 0.79 seconds. Elapsed time: 4.92 seconds; current allocated memory: 331.375 MB.\n", - "INFO: [HLS 200-777] Using interface defaults for 'Vivado' flow target.\n", - "INFO: [HLS 200-1995] There were 3,120 instructions in the design after the 'Compile/Link' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,550 instructions in the design after the 'Unroll/Inline (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 575 instructions in the design after the 'Unroll/Inline (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 520 instructions in the design after the 'Unroll/Inline (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 444 instructions in the design after the 'Unroll/Inline (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 183 instructions in the design after the 'Array/Struct (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 183 instructions in the design after the 'Array/Struct (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 187 instructions in the design after the 'Array/Struct (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 289 instructions in the design after the 'Array/Struct (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 287 instructions in the design after the 'Array/Struct (step 5)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 269 instructions in the design after the 'Performance (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 265 instructions in the design after the 'Performance (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 265 instructions in the design after the 'Performance (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 265 instructions in the design after the 'Performance (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 246 instructions in the design after the 'HW Transforms (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 229 instructions in the design after the 'HW Transforms (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 214-415] Performing recursive inline in function 'nnet::dense, 2u>, nnet::array, 4u>, config2>' (firmware/nnet_utils/nnet_dense_stream.h:85:9)\n", - "WARNING: [HLS 214-273] In function 'void nnet::dense_latency_wrapper, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)', Pragma conflict happens on 'INLINE' and 'PIPELINE' pragmas: same function (firmware/nnet_utils/nnet_dense_stream.h:15:0)\n", - "INFO: [HLS 214-415] Performing recursive inline in function 'nnet::dense, 4u>, nnet::array, 2u>, config4>' (firmware/nnet_utils/nnet_dense_stream.h:85:9)\n", - "WARNING: [HLS 214-273] In function 'void nnet::dense_latency_wrapper, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)', Pragma conflict happens on 'INLINE' and 'PIPELINE' pragmas: same function (firmware/nnet_utils/nnet_dense_stream.h:15:0)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::array, 2u>::operator[](unsigned long) (.3)' into 'void nnet::data_prepare, 2u>, config2>(hls::stream, 2u>, 0>&, nnet::array, 2u>::value_type*) (.10)' (firmware/nnet_utils/nnet_dense_stream.h:47:17)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::product::mult, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0> >::product(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>)' into 'void nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:42:27)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::array, 4u>::operator[](unsigned long) (.5)' into 'void nnet::res_write, 4u>, config2>(nnet::array, 4u>::value_type*, hls::stream, 4u>, 0>&) (.8)' (firmware/nnet_utils/nnet_dense_stream.h:75:2)\n", - "INFO: [HLS 214-131] Inlining function 'void nnet::data_prepare, 2u>, config2>(hls::stream, 2u>, 0>&, nnet::array, 2u>::value_type*) (.10)' into 'void nnet::dense, 2u>, nnet::array, 4u>, config2>(hls::stream, 2u>, 0>&, hls::stream, 4u>, 0>&, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:93:2)\n", - "INFO: [HLS 214-131] Inlining function 'void nnet::res_write, 4u>, config2>(nnet::array, 4u>::value_type*, hls::stream, 4u>, 0>&) (.8)' into 'void nnet::dense, 2u>, nnet::array, 4u>, config2>(hls::stream, 2u>, 0>&, hls::stream, 4u>, 0>&, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:100:5)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::array, 4u>::operator[](unsigned long) (.5)' into 'void nnet::data_prepare, 4u>, config4>(hls::stream, 4u>, 0>&, nnet::array, 4u>::value_type*) (.4)' (firmware/nnet_utils/nnet_dense_stream.h:47:17)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::product::mult, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0> >::product(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>)' into 'void nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:42:27)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::array, 2u>::operator[](unsigned long) (.3)' into 'void nnet::res_write, 2u>, config4>(nnet::array, 2u>::value_type*, hls::stream, 2u>, 0>&) (.1)' (firmware/nnet_utils/nnet_dense_stream.h:75:2)\n", - "INFO: [HLS 214-131] Inlining function 'void nnet::data_prepare, 4u>, config4>(hls::stream, 4u>, 0>&, nnet::array, 4u>::value_type*) (.4)' into 'void nnet::dense, 4u>, nnet::array, 2u>, config4>(hls::stream, 4u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:93:2)\n", - "INFO: [HLS 214-131] Inlining function 'void nnet::res_write, 2u>, config4>(nnet::array, 2u>::value_type*, hls::stream, 2u>, 0>&) (.1)' into 'void nnet::dense, 4u>, nnet::array, 2u>, config4>(hls::stream, 4u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:100:5)\n", - "INFO: [HLS 214-291] Loop 'Result' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:64:5)\n", - "INFO: [HLS 214-291] Loop 'Accum1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:54:5)\n", - "INFO: [HLS 214-291] Loop 'Accum2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:56:9)\n", - "INFO: [HLS 214-291] Loop 'ResetAccum' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:48:5)\n", - "INFO: [HLS 214-291] Loop 'Product1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:37:5)\n", - "INFO: [HLS 214-291] Loop 'Product2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:40:9)\n", - "INFO: [HLS 214-291] Loop 'VITIS_LOOP_74_1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_lif_neuron.h:74:22)\n", - "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 4u>, nnet::array, 2u>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 4u>, nnet::array, 2u>, config4>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Accum1' (firmware/nnet_utils/nnet_dense_latency.h:54:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Accum2' (firmware/nnet_utils/nnet_dense_latency.h:56:9) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'ResetAccum' (firmware/nnet_utils/nnet_dense_latency.h:48:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_74_1' (firmware/nnet_utils/nnet_lif_neuron.h:74:22) in function 'nnet::lif_neuron, 4u>, nnet::array, 4u>, config3>' completely with a factor of 4 (firmware/nnet_utils/nnet_lif_neuron.h:64:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 2u>, nnet::array, 4u>, config2>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 2u>, nnet::array, 4u>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Accum1' (firmware/nnet_utils/nnet_dense_latency.h:54:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Accum2' (firmware/nnet_utils/nnet_dense_latency.h:56:9) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'ResetAccum' (firmware/nnet_utils/nnet_dense_latency.h:48:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 4 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(config2::accum_t)' into 'void nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-178] Inlining function 'nnet::array, 4u>::operator[](unsigned long)' into 'void nnet::lif_neuron, 4u>, nnet::array, 4u>, config3>(hls::stream, 4u>, 0>&, hls::stream, 4u>, 0>&, config3::beta_t const*, config3::threshold_t const*)' (firmware/nnet_utils/nnet_lif_neuron.h:64:0)\n", - "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(config4::accum_t)' into 'void nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-248] Applying array_partition to 'b2': Complete partitioning on dimension 1. (firmware/weights/b2.h:12:0)\n", - "INFO: [HLS 214-248] Applying array_partition to 'b4': Complete partitioning on dimension 1. (firmware/weights/b4.h:12:0)\n", - "INFO: [HLS 214-248] Applying array_partition to 'data': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_dense_stream.h:87:30)\n", - "INFO: [HLS 214-248] Applying array_partition to 'res': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_dense_stream.h:90:29)\n", - "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer3_out' with compact=bit mode in 32-bits (firmware/snn_smoke_vitis.cpp:35:24)\n", - "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer2_out' with compact=bit mode in 32-bits (firmware/snn_smoke_vitis.cpp:32:24)\n", - "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", - "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", - "INFO: [HLS 200-111] Finished Compiling Optimization and Transform: CPU user time: 2.49 seconds. CPU system time: 0.54 seconds. Elapsed time: 7.43 seconds; current allocated memory: 341.020 MB.\n", - "INFO: [HLS 200-111] Finished Checking Pragmas: CPU user time: 0 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 341.020 MB.\n", - "INFO: [HLS 200-10] Starting code transformations ...\n", - "INFO: [HLS 200-111] Finished Standard Transforms: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 342.000 MB.\n", - "INFO: [HLS 200-10] Checking synthesizability ...\n", - "INFO: [HLS 200-111] Finished Checking Synthesizability: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 343.953 MB.\n", - "INFO: [XFORM 203-712] Applying dataflow to function 'snn_smoke_vitis' (firmware/snn_smoke_vitis.cpp:8), detected/extracted 3 process function(s): \n", - "\t 'nnet::dense, 2u>, nnet::array, 4u>, config2>'\n", - "\t 'nnet::lif_neuron, 4u>, nnet::array, 4u>, config3>'\n", - "\t 'nnet::dense, 4u>, nnet::array, 2u>, config4>'.\n", - "INFO: [XFORM 203-11] Balancing expressions in function 'nnet::dense_latency_wrapper, ap_fixed<8, 3, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' (firmware/nnet_utils/nnet_dense_stream.h:18:1)...3 expression(s) balanced.\n", - "INFO: [HLS 200-111] Finished Loop, function and other optimizations: CPU user time: 0.03 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.05 seconds; current allocated memory: 366.895 MB.\n", - "INFO: [HLS 200-111] Finished Architecture Synthesis: CPU user time: 0.04 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.05 seconds; current allocated memory: 407.148 MB.\n", - "INFO: [HLS 200-10] Starting hardware synthesis ...\n", - "INFO: [HLS 200-10] Synthesizing 'snn_smoke_vitis' ...\n", - "WARNING: [SYN 201-103] Legalizing function name 'dense_latency_wrapper, ap_fixed<8, 3, 5, 3, 0>, config2>' to 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s'.\n", - "WARNING: [SYN 201-103] Legalizing function name 'dense,array,4u>,config2>' to 'dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s'.\n", - "WARNING: [SYN 201-103] Legalizing function name 'lif_neuron,array,4u>,config3>' to 'lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s'.\n", - "WARNING: [SYN 201-103] Legalizing function name 'dense_latency_wrapper, ap_fixed<8, 3, 5, 3, 0>, config4>' to 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s'.\n", - "WARNING: [SYN 201-103] Legalizing function name 'dense,array,2u>,config4>' to 'dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s'.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<8, 3, 5, 3, 0>, config2>'.\n", - "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<8, 3, 5, 3, 0>, config2>'\n", - "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.05 seconds. CPU system time: 0.02 seconds. Elapsed time: 0.07 seconds; current allocated memory: 407.148 MB.\n", - "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", - "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", - "INFO: [BIND 205-101] Exploring resource sharing.\n", - "INFO: [BIND 205-101] Binding ...\n", - "INFO: [BIND 205-100] Starting global binding ...\n", - "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.148 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.914 MB.\n", - "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", - "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", - "INFO: [BIND 205-101] Exploring resource sharing.\n", - "INFO: [BIND 205-101] Binding ...\n", - "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.01 seconds; current allocated memory: 407.914 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-61] Pipelining function 'lif_neuron,array,4u>,config3>'.\n", - "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 2, function 'lif_neuron,array,4u>,config3>'\n", - "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.918 MB.\n", - "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", - "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", - "INFO: [BIND 205-101] Exploring resource sharing.\n", - "INFO: [BIND 205-101] Binding ...\n", - "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.01 seconds; current allocated memory: 407.918 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<8, 3, 5, 3, 0>, config4>'.\n", - "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<8, 3, 5, 3, 0>, config4>'\n", - "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.04 seconds; current allocated memory: 407.918 MB.\n", - "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", - "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", - "INFO: [BIND 205-101] Exploring resource sharing.\n", - "INFO: [BIND 205-101] Binding ...\n", - "INFO: [BIND 205-100] Starting global binding ...\n", - "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.918 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.918 MB.\n", - "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", - "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", - "INFO: [BIND 205-101] Exploring resource sharing.\n", - "INFO: [BIND 205-101] Binding ...\n", - "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.918 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'snn_smoke_vitis' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-11] Finished scheduling.\n", - "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer2_out (from dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_U0 to lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0) to 2 to improve performance and/or avoid deadlocks.\n", - "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer3_out (from lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0 to dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0) to 2 to improve performance and/or avoid deadlocks.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.918 MB.\n", - "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", - "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", - "INFO: [BIND 205-101] Exploring resource sharing.\n", - "INFO: [BIND 205-101] Binding ...\n", - "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 407.918 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [RTGEN 206-100] Generating core module 'mul_8s_6ns_13_1_1': 1 instance(s).\n", - "INFO: [RTGEN 206-100] Generating core module 'mul_8s_7s_13_1_1': 2 instance(s).\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.02 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.03 seconds; current allocated memory: 408.145 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 409.309 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-1030] Apply Unified Pipeline Control on module 'lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s' pipeline 'lif_neuron,array,4u>,config3>' pipeline type 'function pipeline'\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.04 seconds; current allocated memory: 409.984 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [RTGEN 206-100] Generating core module 'mul_8s_6s_13_1_1': 1 instance(s).\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.04 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.04 seconds; current allocated memory: 410.660 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 411.863 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'snn_smoke_vitis' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "WARNING: [RTGEN 206-101] Design contains AXI ports. Reset is fixed to synchronous and active low.\n", - "INFO: [RTGEN 206-500] Setting interface mode on port 'snn_smoke_vitis/x' to 'axis' (register, both mode).\n", - "INFO: [RTGEN 206-500] Setting interface mode on port 'snn_smoke_vitis/layer4_out' to 'axis' (register, both mode).\n", - "INFO: [RTGEN 206-500] Setting interface mode on function 'snn_smoke_vitis' to 'ap_ctrl_hs'.\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'snn_smoke_vitis'.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'layer2_out_U(snn_smoke_vitis_fifo_w32_d1_S)' using Shift Registers.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'layer3_out_U(snn_smoke_vitis_fifo_w32_d1_S)' using Shift Registers.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0_U(snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0)' using Shift Registers.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0_U(snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0)' using Shift Registers.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.06 seconds; current allocated memory: 412.691 MB.\n", - "INFO: [HLS 200-111] Finished Generating all RTL models: CPU user time: 0.13 seconds. CPU system time: 0 seconds. Elapsed time: 0.14 seconds; current allocated memory: 415.090 MB.\n", - "INFO: [HLS 200-111] Finished Updating report files: CPU user time: 0.28 seconds. CPU system time: 0 seconds. Elapsed time: 0.28 seconds; current allocated memory: 419.008 MB.\n", - "INFO: [VHDL 208-304] Generating VHDL RTL for snn_smoke_vitis.\n", - "INFO: [VLOG 209-307] Generating Verilog RTL for snn_smoke_vitis.\n", - "INFO: [HLS 200-789] **** Estimated Fmax: 317.06 MHz\n", - "INFO: [HLS 200-2161] Finished Command csynth_design Elapsed time: 00:00:13; Allocated memory: 93.246 MB.\n", - "***** C/RTL SYNTHESIS COMPLETED IN 0h0m13s *****\n", - "***** C/RTL SIMULATION *****\n", - "INFO: [HLS 200-1510] Running: add_files -tb snn_smoke_vitis_test.cpp -cflags -std=c++0x -DRTL_SIM \n", - "INFO: [HLS 200-10] Adding test bench file 'snn_smoke_vitis_test.cpp' to the project\n", - "INFO: [HLS 200-1510] Running: cosim_design -trace_level all -setup \n", - "INFO: [COSIM 212-47] Using XSIM for RTL simulation.\n", - "INFO: [COSIM 212-14] Instrumenting C test bench ...\n", - " Build using \"/tools/Xilinx/Vitis_HLS/2024.1/vcxx/libexec/clang++\"\n", - " Compiling apatb_snn_smoke_vitis.cpp\n", - " Compiling apatb_snn_smoke_vitis_util.cpp\n", - " Compiling snn_smoke_vitis.cpp_pre.cpp.tb.cpp\n", - " Compiling snn_smoke_vitis_test.cpp_pre.cpp.tb.cpp\n", - " Compiling apatb_snn_smoke_vitis_ir.ll\n", - " Generating cosim.tv.exe\n", - "INFO: [COSIM 212-302] Starting C TB testing ... \n", - "INFO: Unable to open input/predictions file, using default input.\n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", - "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", - "INFO: [COSIM 212-333] Generating C post check test bench ...\n", - "INFO: [COSIM 212-12] Generating RTL test bench ...\n", - "INFO: [COSIM 212-1] *** C/RTL co-simulation file generation completed. ***\n", - "INFO: [HLS 200-2161] Finished Command cosim_design Elapsed time: 00:00:11; Allocated memory: 11.863 MB.\n", - "INFO: [HLS 200-1510] Running: source /home/b/Physics/hls4ml/examples/snn_smoke_vitis/project.tcl\n", - "INFO: [HLS 200-1510] Running: source run_sim.tcl\n", - "INFO: [HLS 200-1510] Running: source check_sim.tcl\n", - "INFO: [HLS 200-1510] Running: source dataflow_monitor_API.tcl\n", - "INFO: [COSIM 212-302] Starting C TB testing ... \n", - "INFO: Unable to open input/predictions file, using default input.\n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", - "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", - "INFO: [COSIM 212-323] Starting verilog simulation...\n", - "INFO: [COSIM 212-15] Starting XSIM ...\n", - "Vivado Simulator v2024.1\n", - "Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", - "Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", - "Running: /tools/Xilinx/Vivado/2024.1/bin/unwrapped/lnx64.o/xelab xil_defaultlib.apatb_snn_smoke_vitis_top glbl -Oenable_linking_all_libraries -prj snn_smoke_vitis.prj -L smartconnect_v1_0 -L axi_protocol_checker_v1_1_12 -L axi_protocol_checker_v1_1_13 -L axis_protocol_checker_v1_1_11 -L axis_protocol_checker_v1_1_12 -L xil_defaultlib -L unisims_ver -L xpm -L floating_point_v7_0_23 -L floating_point_v7_1_18 --lib ieee_proposed=./ieee_proposed -s snn_smoke_vitis -debug all \n", - "Multi-threading is on. Using 14 slave threads.\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/glbl.v\" into library work\n", - "INFO: [VRFC 10-311] analyzing module glbl\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis.autotb.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module apatb_snn_smoke_vitis_top\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_fifo.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module fifo\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_axi_s_x.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_axi_s_x\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_axi_s_layer4_out.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_axi_s_layer4_out\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_deadlock_detection_unit.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_deadlock_detect_unit\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_deadlock_report_unit.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_deadlock_report_unit\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_deadlock_detector.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_deadlock_detector\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_deadlock_kernel_monitor_top.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_deadlock_kernel_monitor_top\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/AESL_deadlock_idx0_monitor.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_deadlock_idx0_monitor\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_mul_8s_6ns_13_1_1.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_mul_8s_6ns_13_1_1\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_mul_8s_7s_13_1_1.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_mul_8s_7s_13_1_1\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_regslice_both.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_regslice_both\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_mul_8s_6s_13_1_1.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_mul_8s_6s_13_1_1\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_fifo_w32_d1_S.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_fifo_w32_d1_S\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_fifo_w32_d1_S_ShiftReg\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0_ShiftReg\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0\n", - "INFO: [VRFC 10-311] analyzing module snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0_ShiftReg\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/dataflow_monitor.sv\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module dataflow_monitor\n", - "Starting static elaboration\n", - "Pass Through NonSizing Optimizer\n", - "Completed static elaboration\n", - "Starting simulation data flow analysis\n", - "Completed simulation data flow analysis\n", - "Time Resolution for simulation is 1ps\n", - "Compiling package xil_defaultlib.$unit_dataflow_monitor_sv\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_mul_8s_6ns_13_1_...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_mul_8s_7s_13_1_1...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_dense_latency_wr...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_regslice_both(Da...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_dense_array_ap_f...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_lif_neuron_array...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_mul_8s_6s_13_1_1...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_dense_latency_wr...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_dense_array_ap_f...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_fifo_w32_d1_S_Sh...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_fifo_w32_d1_S_de...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_start_for_lif_ne...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_start_for_lif_ne...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_start_for_dense_...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis_start_for_dense_...\n", - "Compiling module xil_defaultlib.snn_smoke_vitis\n", - "Compiling module xil_defaultlib.fifo(DEPTH=2,WIDTH=16)\n", - "Compiling module xil_defaultlib.AESL_axi_s_x\n", - "Compiling module xil_defaultlib.AESL_axi_s_layer4_out\n", - "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(PROC_N...\n", - "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(PROC_N...\n", - "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(PROC_N...\n", - "Compiling module xil_defaultlib.AESL_deadlock_report_unit(PROC_N...\n", - "Compiling module xil_defaultlib.AESL_deadlock_detector_2\n", - "Compiling module xil_defaultlib.AESL_deadlock_idx0_monitor\n", - "Compiling module xil_defaultlib.AESL_deadlock_kernel_monitor_top...\n", - "Compiling module xil_defaultlib.df_fifo_intf_default\n", - "Compiling module xil_defaultlib.df_process_intf_default\n", - "Compiling module xil_defaultlib.nodf_module_intf_default\n", - "Compiling module xil_defaultlib.dataflow_monitor_1\n", - "Compiling module xil_defaultlib.apatb_snn_smoke_vitis_top\n", - "Compiling module work.glbl\n", - "Built simulation snapshot snn_smoke_vitis\n", - "\n", - "****** xsim v2024.1 (64-bit)\n", - " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", - " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", - " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Mon May 4 18:22:09 2026\n", - " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", - " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", - "\n", - "source xsim.dir/snn_smoke_vitis/xsim_script.tcl\n", - "# xsim {snn_smoke_vitis} -view {{snn_smoke_vitis_dataflow_ana.wcfg}} -tclbatch {snn_smoke_vitis.tcl} -protoinst {snn_smoke_vitis.protoinst}\n", - "INFO: [Wavedata 42-565] Reading protoinst file snn_smoke_vitis.protoinst\n", - "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis//AESL_inst_snn_smoke_vitis_activity\n", - "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_U0/dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_U0_activity\n", - "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0/dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0_activity\n", - "INFO: [Wavedata 42-564] Found protocol instance at /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0/lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0_activity\n", - "Time resolution is 1 ps\n", - "open_wave_config snn_smoke_vitis_dataflow_ana.wcfg\n", - "source snn_smoke_vitis.tcl\n", - "## set designtopgroup [add_wave_group \"Design Top Signals\"]\n", - "## set coutputgroup [add_wave_group \"C Outputs\" -into $designtopgroup]\n", - "## set return_group [add_wave_group return(axis) -into $coutputgroup]\n", - "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/layer4_out_TREADY -into $return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/layer4_out_TVALID -into $return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/layer4_out_TDATA -into $return_group -radix hex\n", - "## set cinputgroup [add_wave_group \"C Inputs\" -into $designtopgroup]\n", - "## set return_group [add_wave_group return(axis) -into $cinputgroup]\n", - "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/x_TREADY -into $return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/x_TVALID -into $return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/x_TDATA -into $return_group -radix hex\n", - "## set blocksiggroup [add_wave_group \"Block-level IO Handshake\" -into $designtopgroup]\n", - "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/ap_start -into $blocksiggroup\n", - "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/ap_done -into $blocksiggroup\n", - "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/ap_ready -into $blocksiggroup\n", - "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/ap_idle -into $blocksiggroup\n", - "## set resetgroup [add_wave_group \"Reset\" -into $designtopgroup]\n", - "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/ap_rst_n -into $resetgroup\n", - "## set clockgroup [add_wave_group \"Clock\" -into $designtopgroup]\n", - "## add_wave /apatb_snn_smoke_vitis_top/AESL_inst_snn_smoke_vitis/ap_clk -into $clockgroup\n", - "## set testbenchgroup [add_wave_group \"Test Bench Signals\"]\n", - "## set tbinternalsiggroup [add_wave_group \"Internal Signals\" -into $testbenchgroup]\n", - "## set tb_simstatus_group [add_wave_group \"Simulation Status\" -into $tbinternalsiggroup]\n", - "## set tb_portdepth_group [add_wave_group \"Port Depth\" -into $tbinternalsiggroup]\n", - "## add_wave /apatb_snn_smoke_vitis_top/AUTOTB_TRANSACTION_NUM -into $tb_simstatus_group -radix hex\n", - "## add_wave /apatb_snn_smoke_vitis_top/ready_cnt -into $tb_simstatus_group -radix hex\n", - "## add_wave /apatb_snn_smoke_vitis_top/done_cnt -into $tb_simstatus_group -radix hex\n", - "## add_wave /apatb_snn_smoke_vitis_top/LENGTH_layer4_out -into $tb_portdepth_group -radix hex\n", - "## add_wave /apatb_snn_smoke_vitis_top/LENGTH_x -into $tb_portdepth_group -radix hex\n", - "## set tbcoutputgroup [add_wave_group \"C Outputs\" -into $testbenchgroup]\n", - "## set tb_return_group [add_wave_group return(axis) -into $tbcoutputgroup]\n", - "## add_wave /apatb_snn_smoke_vitis_top/layer4_out_TREADY -into $tb_return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_smoke_vitis_top/layer4_out_TVALID -into $tb_return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_smoke_vitis_top/layer4_out_TDATA -into $tb_return_group -radix hex\n", - "## set tbcinputgroup [add_wave_group \"C Inputs\" -into $testbenchgroup]\n", - "## set tb_return_group [add_wave_group return(axis) -into $tbcinputgroup]\n", - "## add_wave /apatb_snn_smoke_vitis_top/x_TREADY -into $tb_return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_smoke_vitis_top/x_TVALID -into $tb_return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_snn_smoke_vitis_top/x_TDATA -into $tb_return_group -radix hex\n", - "## save_wave_config snn_smoke_vitis.wcfg\n", - "## run all\n", - "////////////////////////////////////////////////////////////////////////////////////\n", - "// Inter-Transaction Progress: Completed Transaction / Total Transaction\n", - "// Intra-Transaction Progress: Measured Latency / Latency Estimation * 100%\n", - "//\n", - "// RTL Simulation : \"Inter-Transaction Progress\" [\"Intra-Transaction Progress\"] @ \"Simulation Time\"\n", - "////////////////////////////////////////////////////////////////////////////////////\n", - "// RTL Simulation : 0 / 5 [0.00%] @ \"113000\"\n", - "// RTL Simulation : 1 / 5 [83.33%] @ \"163000\"\n", - "// RTL Simulation : 2 / 5 [100.00%] @ \"178000\"\n", - "// RTL Simulation : 3 / 5 [116.67%] @ \"193000\"\n", - "// RTL Simulation : 4 / 5 [100.00%] @ \"208000\"\n", - "// RTL Simulation : 5 / 5 [100.00%] @ \"223000\"\n", - "////////////////////////////////////////////////////////////////////////////////////\n", - "$finish called at time : 252500 ps : File \"/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/sim/verilog/snn_smoke_vitis.autotb.v\" Line 249\n", - "## quit\n", - "INFO: [Common 17-206] Exiting xsim at Mon May 4 18:22:12 2026...\n", - "WARNING: [HLS 200-2011] Cannot find the 'zip' utility on this system. This is required for cosimulation.\n", - "INFO: [COSIM 212-316] Starting C post checking ...\n", - "INFO: Unable to open input/predictions file, using default input.\n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "0.3125 0.28125 \n", - "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", - "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", - "INFO:\n", - "Report time : Mon May 4 06:22:04 PM IST 2026.\n", - "Solution : solution1.\n", - "Simulation tool : xsim.\n", - "\n", - "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", - "| | | Latency(Clock Cycles) | Interval(Clock Cycles) | Total Execution Time |\n", - "+ RTL + Status +-----------------------------------------------+-----------------------------------------------+ (Clock Cycles) +\n", - "| | | min | avg | max | min | avg | max | |\n", - "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", - "| VHDL| NA| NA| NA| NA| NA| NA| NA| NA|\n", - "| Verilog| Pass| NA| NA| NA| NA| NA| NA| NA|\n", - "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", - "\n", - "***** C/RTL SIMULATION COMPLETED IN 0h0m20s *****\n", - "***** C/RTL VALIDATION *****\n", - "INFO: Test PASSED\n", - "***** EXPORT IP *****\n", - "INFO: [HLS 200-1510] Running: export_design -format ip_catalog -version 1.0.0 \n", - "INFO: [IMPL 213-8] Exporting RTL as a Vivado IP.\n", - "\n", - "****** Vivado v2024.1 (64-bit)\n", - " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", - " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", - " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Mon May 4 18:22:14 2026\n", - " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", - " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", - "\n", - "source run_ippack.tcl -notrace\n", - "INFO: calling package_hls_ip ip_types=vitis sysgen json_file=/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/solution1_data.json outdir=/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip srcdir=/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1 sort_interfaces_ports=false\n", - "INFO: Copied 1 ipmisc file(s) to /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip/misc\n", - "INFO: Copied 18 verilog file(s) to /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip/hdl/verilog\n", - "INFO: Copied 13 vhdl file(s) to /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip/hdl/vhdl\n", - "INFO: Import ports from HDL: /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip/hdl/vhdl/snn_smoke_vitis.vhd (snn_smoke_vitis)\n", - "INFO: Add axi4stream interface x\n", - "INFO: Add axi4stream interface layer4_out\n", - "INFO: [IP_Flow 19-234] Refreshing IP repositories\n", - "INFO: [IP_Flow 19-1704] No user IP repositories specified\n", - "INFO: [IP_Flow 19-2313] Loaded Vivado IP repository '/tools/Xilinx/Vivado/2024.1/data/ip'.\n", - "INFO: Add clock interface ap_clk\n", - "INFO: Add reset interface ap_rst_n\n", - "INFO: Add ap_ctrl interface ap_ctrl\n", - "INFO: Calling post_process_vitis to specialize IP\n", - "INFO: Calling post_process_sysgen to specialize IP\n", - "Generating sysgen info xml from json file\n", - "INFO: Created IP /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip/component.xml\n", - "INFO: Created IP archive /home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/impl/ip/xilinx_com_hls_snn_smoke_vitis_1_0.zip\n", - "INFO: [Common 17-206] Exiting Vivado at Mon May 4 18:22:20 2026...\n", - "INFO: [HLS 200-802] Generated output file snn_smoke_vitis_prj/solution1/impl/export.zip\n", - "INFO: [HLS 200-2161] Finished Command export_design Elapsed time: 00:00:18; Allocated memory: 0.000 MB.\n", - "***** EXPORT IP COMPLETED IN 0h0m18s *****\n", - "***** VIVADO SYNTHESIS *****\n", - "\n", - "****** Vivado v2024.1 (64-bit)\n", - " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", - " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", - " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Mon May 4 18:22:31 2026\n", - " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", - " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", - "\n", - "source vivado_synth.tcl\n", - "# set tcldir [file dirname [info script]]\n", - "# source [file join $tcldir project.tcl]\n", - "## variable project_name\n", - "## set project_name \"snn_smoke_vitis\"\n", - "## variable backend\n", - "## set backend \"vitis\"\n", - "## variable part\n", - "## set part \"xczu7ev-ffvc1156-2-e\"\n", - "## variable clock_period\n", - "## set clock_period 5\n", - "## variable clock_uncertainty\n", - "## set clock_uncertainty 18%\n", - "## variable version\n", - "## set version \"1.0.0\"\n", - "## variable maximum_size\n", - "## set maximum_size 4096\n", - "# add_files ${project_name}_prj/solution1/syn/verilog\n", - "# synth_design -top ${project_name} -part $part\n", - "Command: synth_design -top snn_smoke_vitis -part xczu7ev-ffvc1156-2-e\n", - "Starting synth_design\n", - "Attempting to get a license for feature 'Synthesis' and/or device 'xczu7ev'\n", - "INFO: [Common 17-349] Got license for feature 'Synthesis' and/or device 'xczu7ev'\n", - "INFO: [Synth 8-7079] Multithreading enabled for synth_design using a maximum of 4 processes.\n", - "INFO: [Synth 8-7078] Launching helper process for spawning children vivado processes\n", - "INFO: [Synth 8-7075] Helper process launched with PID 20915\n", - "---------------------------------------------------------------------------------\n", - "Starting Synthesize : Time (s): cpu = 00:00:02 ; elapsed = 00:00:03 . Memory (MB): peak = 1875.934 ; gain = 426.637 ; free physical = 3503 ; free virtual = 24901\n", - "---------------------------------------------------------------------------------\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_mul_8s_6ns_13_1_1' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_mul_8s_6ns_13_1_1.v:5]\n", - "\tParameter ID bound to: 1 - type: integer \n", - "\tParameter NUM_STAGE bound to: 1 - type: integer \n", - "\tParameter din0_WIDTH bound to: 8 - type: integer \n", - "\tParameter din1_WIDTH bound to: 6 - type: integer \n", - "\tParameter dout_WIDTH bound to: 13 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_mul_8s_6ns_13_1_1' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_mul_8s_6ns_13_1_1.v:5]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_mul_8s_7s_13_1_1' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_mul_8s_7s_13_1_1.v:5]\n", - "\tParameter ID bound to: 1 - type: integer \n", - "\tParameter NUM_STAGE bound to: 1 - type: integer \n", - "\tParameter din0_WIDTH bound to: 8 - type: integer \n", - "\tParameter din1_WIDTH bound to: 7 - type: integer \n", - "\tParameter dout_WIDTH bound to: 13 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_mul_8s_7s_13_1_1' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_mul_8s_7s_13_1_1.v:5]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_regslice_both' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_regslice_both.v:9]\n", - "\tParameter DataWidth bound to: 16 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_regslice_both' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_regslice_both.v:9]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s.v:9]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_mul_8s_6s_13_1_1' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_mul_8s_6s_13_1_1.v:5]\n", - "\tParameter ID bound to: 1 - type: integer \n", - "\tParameter NUM_STAGE bound to: 1 - type: integer \n", - "\tParameter din0_WIDTH bound to: 8 - type: integer \n", - "\tParameter din1_WIDTH bound to: 6 - type: integer \n", - "\tParameter dout_WIDTH bound to: 13 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_mul_8s_6s_13_1_1' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_mul_8s_6s_13_1_1.v:5]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s.v:9]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_fifo_w32_d1_S' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_fifo_w32_d1_S.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_fifo_w32_d1_S_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_fifo_w32_d1_S.v:129]\n", - "\tParameter DATA_WIDTH bound to: 32 - type: integer \n", - "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", - "\tParameter DEPTH bound to: 1 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_fifo_w32_d1_S_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_fifo_w32_d1_S.v:129]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_fifo_w32_d1_S' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_fifo_w32_d1_S.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0.v:125]\n", - "\tParameter DATA_WIDTH bound to: 1 - type: integer \n", - "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", - "\tParameter DEPTH bound to: 2 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0.v:125]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0.v:125]\n", - "\tParameter DATA_WIDTH bound to: 1 - type: integer \n", - "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", - "\tParameter DEPTH bound to: 2 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0.v:125]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0.v:11]\n", - "INFO: [Synth 8-6155] done synthesizing module 'snn_smoke_vitis' (0#1) [/home/b/Physics/hls4ml/examples/snn_smoke_vitis/snn_smoke_vitis_prj/solution1/syn/verilog/snn_smoke_vitis.v:9]\n", - "WARNING: [Synth 8-7129] Port addr[0] in module snn_smoke_vitis_fifo_w32_d1_S_ShiftReg is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port ap_rst in module snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[28] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[27] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[26] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[25] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[24] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[20] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[19] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[18] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[17] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[16] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[12] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[11] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[10] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[9] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[8] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[4] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[3] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[2] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[1] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_dout[0] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port ap_rst in module snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s is either unconnected or has no load\n", - "---------------------------------------------------------------------------------\n", - "Finished Synthesize : Time (s): cpu = 00:00:03 ; elapsed = 00:00:04 . Memory (MB): peak = 1955.871 ; gain = 506.574 ; free physical = 3403 ; free virtual = 24802\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Constraint Validation : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1973.684 ; gain = 524.387 ; free physical = 3394 ; free virtual = 24793\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Loading Part and Timing Information\n", - "---------------------------------------------------------------------------------\n", - "Loading part: xczu7ev-ffvc1156-2-e\n", - "INFO: [Synth 8-6742] Reading net delay rules and data\n", - "INFO: [Device 21-403] Loading part xczu7ev-ffvc1156-2-e\n", - "---------------------------------------------------------------------------------\n", - "Finished Loading Part and Timing Information : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1990.594 ; gain = 541.297 ; free physical = 3386 ; free virtual = 24785\n", - "---------------------------------------------------------------------------------\n", - "INFO: [Synth 8-802] inferred FSM for state register 'state_reg' in module 'snn_smoke_vitis_regslice_both'\n", - "INFO: [Synth 8-4490] FSM extraction disabled for register 'ap_CS_fsm_reg' through user attribute\n", - "INFO: [Synth 8-4490] FSM extraction disabled for register 'ap_CS_fsm_reg' through user attribute\n", - "---------------------------------------------------------------------------------------------------\n", - " State | New Encoding | Previous Encoding \n", - "---------------------------------------------------------------------------------------------------\n", - " ZERO | 00 | 10\n", - " ONE | 10 | 11\n", - " TWO | 01 | 01\n", - "---------------------------------------------------------------------------------------------------\n", - "INFO: [Synth 8-3354] encoded FSM with state register 'state_reg' using encoding 'sequential' in module 'snn_smoke_vitis_regslice_both'\n", - "---------------------------------------------------------------------------------\n", - "Finished RTL Optimization Phase 2 : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1990.594 ; gain = 541.297 ; free physical = 3374 ; free virtual = 24776\n", - "---------------------------------------------------------------------------------\n", - "No constraint files found.\n", - "---------------------------------------------------------------------------------\n", - "Start RTL Component Statistics \n", - "---------------------------------------------------------------------------------\n", - "Detailed RTL Component Info : \n", - "+---Adders : \n", - "\t 3 Input 13 Bit Adders := 3 \n", - "\t 2 Input 12 Bit Adders := 1 \n", - "\t 3 Input 12 Bit Adders := 2 \n", - "\t 3 Input 8 Bit Adders := 5 \n", - "\t 2 Input 8 Bit Adders := 1 \n", - "\t 2 Input 7 Bit Adders := 1 \n", - "\t 2 Input 6 Bit Adders := 1 \n", - "\t 2 Input 5 Bit Adders := 2 \n", - "\t 2 Input 2 Bit Adders := 4 \n", - "\t 2 Input 1 Bit Adders := 4 \n", - "+---Registers : \n", - "\t 32 Bit Registers := 2 \n", - "\t 16 Bit Registers := 4 \n", - "\t 8 Bit Registers := 8 \n", - "\t 3 Bit Registers := 1 \n", - "\t 2 Bit Registers := 7 \n", - "\t 1 Bit Registers := 29 \n", - "+---Muxes : \n", - "\t 2 Input 16 Bit Muxes := 2 \n", - "\t 5 Input 3 Bit Muxes := 1 \n", - "\t 2 Input 3 Bit Muxes := 1 \n", - "\t 2 Input 2 Bit Muxes := 30 \n", - "\t 3 Input 2 Bit Muxes := 6 \n", - "\t 4 Input 2 Bit Muxes := 3 \n", - "\t 2 Input 1 Bit Muxes := 32 \n", - "---------------------------------------------------------------------------------\n", - "Finished RTL Component Statistics \n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Part Resource Summary\n", - "---------------------------------------------------------------------------------\n", - "Part Resources:\n", - "DSPs: 1728 (col length:144)\n", - "BRAMs: 624 (col length: RAMB18 144 RAMB36 72)\n", - "---------------------------------------------------------------------------------\n", - "Finished Part Resource Summary\n", - "---------------------------------------------------------------------------------\n", - "No constraint files found.\n", - "---------------------------------------------------------------------------------\n", - "Start Cross Boundary and Area Optimization\n", - "---------------------------------------------------------------------------------\n", - "WARNING: [Synth 8-7080] Parallel synthesis criteria is not met\n", - "---------------------------------------------------------------------------------\n", - "Finished Cross Boundary and Area Optimization : Time (s): cpu = 00:00:08 ; elapsed = 00:00:08 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2369 ; free virtual = 23871\n", - "---------------------------------------------------------------------------------\n", - "No constraint files found.\n", - "---------------------------------------------------------------------------------\n", - "Start Timing Optimization\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Timing Optimization : Time (s): cpu = 00:00:08 ; elapsed = 00:00:09 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2369 ; free virtual = 23871\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Technology Mapping\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Technology Mapping : Time (s): cpu = 00:00:08 ; elapsed = 00:00:09 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2369 ; free virtual = 23871\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start IO Insertion\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Flattening Before IO Insertion\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Flattening Before IO Insertion\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Final Netlist Cleanup\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Final Netlist Cleanup\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished IO Insertion : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23876\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Renaming Generated Instances\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Renaming Generated Instances : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23876\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Rebuilding User Hierarchy\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Rebuilding User Hierarchy : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Renaming Generated Ports\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Renaming Generated Ports : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Handling Custom Attributes\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Handling Custom Attributes : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Renaming Generated Nets\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Renaming Generated Nets : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Writing Synthesis Report\n", - "---------------------------------------------------------------------------------\n", - "\n", - "Report BlackBoxes: \n", - "+-+--------------+----------+\n", - "| |BlackBox name |Instances |\n", - "+-+--------------+----------+\n", - "+-+--------------+----------+\n", - "\n", - "Report Cell Usage: \n", - "+------+-------+------+\n", - "| |Cell |Count |\n", - "+------+-------+------+\n", - "|1 |BUFG | 1|\n", - "|2 |CARRY8 | 17|\n", - "|3 |LUT1 | 16|\n", - "|4 |LUT2 | 56|\n", - "|5 |LUT3 | 35|\n", - "|6 |LUT4 | 57|\n", - "|7 |LUT5 | 40|\n", - "|8 |LUT6 | 58|\n", - "|9 |FDRE | 122|\n", - "|10 |FDSE | 8|\n", - "|11 |IBUF | 21|\n", - "|12 |OBUF | 21|\n", - "+------+-------+------+\n", - "\n", - "Report Instance Areas: \n", - "+------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+------+\n", - "| |Instance |Module |Cells |\n", - "+------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+------+\n", - "|1 |top | | 452|\n", - "|2 | dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_U0 |snn_smoke_vitis_dense_array_ap_fixed_2u_array_ap_fixed_8_3_5_3_0_4u_config2_s | 252|\n", - "|3 | call_ret_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s_fu_47 |snn_smoke_vitis_dense_latency_wrapper_ap_fixed_8_3_5_3_0_ap_fixed_8_3_5_3_0_config2_s | 35|\n", - "|4 | mul_8s_6ns_13_1_1_U1 |snn_smoke_vitis_mul_8s_6ns_13_1_1 | 21|\n", - "|5 | mul_8s_7s_13_1_1_U2 |snn_smoke_vitis_mul_8s_7s_13_1_1 | 2|\n", - "|6 | mul_8s_7s_13_1_1_U3 |snn_smoke_vitis_mul_8s_7s_13_1_1_3 | 1|\n", - "|7 | regslice_both_x_U |snn_smoke_vitis_regslice_both_2 | 198|\n", - "|8 | dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0 |snn_smoke_vitis_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_s | 82|\n", - "|9 | regslice_both_layer4_out_U |snn_smoke_vitis_regslice_both | 74|\n", - "|10 | layer2_out_U |snn_smoke_vitis_fifo_w32_d1_S | 27|\n", - "|11 | U_snn_smoke_vitis_fifo_w32_d1_S_ShiftReg |snn_smoke_vitis_fifo_w32_d1_S_ShiftReg_1 | 16|\n", - "|12 | layer3_out_U |snn_smoke_vitis_fifo_w32_d1_S_0 | 12|\n", - "|13 | U_snn_smoke_vitis_fifo_w32_d1_S_ShiftReg |snn_smoke_vitis_fifo_w32_d1_S_ShiftReg | 4|\n", - "|14 | lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0 |snn_smoke_vitis_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_s | 13|\n", - "|15 | start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0_U |snn_smoke_vitis_start_for_dense_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_2u_config4_U0 | 11|\n", - "|16 | start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0_U |snn_smoke_vitis_start_for_lif_neuron_array_ap_fixed_4u_array_ap_fixed_8_3_5_3_0_4u_config3_U0 | 12|\n", - "+------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+------+\n", - "---------------------------------------------------------------------------------\n", - "Finished Writing Synthesis Report : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", - "---------------------------------------------------------------------------------\n", - "Synthesis finished with 0 errors, 0 critical warnings and 40 warnings.\n", - "Synthesis Optimization Runtime : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.547 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", - "Synthesis Optimization Complete : Time (s): cpu = 00:00:10 ; elapsed = 00:00:11 . Memory (MB): peak = 2854.555 ; gain = 1405.250 ; free physical = 2375 ; free virtual = 23875\n", - "INFO: [Project 1-571] Translating synthesized netlist\n", - "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00.01 . Memory (MB): peak = 2854.555 ; gain = 0.000 ; free physical = 2658 ; free virtual = 24158\n", - "INFO: [Netlist 29-17] Analyzing 39 Unisim elements for replacement\n", - "INFO: [Netlist 29-28] Unisim Transformation completed in 0 CPU seconds\n", - "INFO: [Project 1-570] Preparing netlist for logic optimization\n", - "INFO: [Opt 31-138] Pushed 0 inverter(s) to 0 load pin(s).\n", - "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 2910.574 ; gain = 0.000 ; free physical = 2647 ; free virtual = 24159\n", - "INFO: [Project 1-111] Unisim Transformation Summary:\n", - " A total of 22 instances were transformed.\n", - " BUFG => BUFGCE: 1 instance \n", - " IBUF => IBUF (IBUFCTRL, INBUF): 21 instances\n", - "\n", - "Synth Design complete | Checksum: 9829e65e\n", - "INFO: [Common 17-83] Releasing license: Synthesis\n", - "49 Infos, 40 Warnings, 0 Critical Warnings and 0 Errors encountered.\n", - "synth_design completed successfully\n", - "synth_design: Time (s): cpu = 00:00:14 ; elapsed = 00:00:13 . Memory (MB): peak = 2910.574 ; gain = 1464.262 ; free physical = 2647 ; free virtual = 24160\n", - "INFO: [Common 17-2834] synth_design peak Physical Memory [PSS] (MB): overall = 2665.407; main = 2395.605; forked = 448.815\n", - "INFO: [Common 17-2834] synth_design peak Virtual Memory [VSS] (MB): overall = 3881.602; main = 2910.578; forked = 1027.051\n", - "# opt_design -retarget -propconst -sweep -bram_power_opt -shift_register_opt\n", - "Command: opt_design -retarget -propconst -sweep -bram_power_opt -shift_register_opt\n", - "Attempting to get a license for feature 'Implementation' and/or device 'xczu7ev'\n", - "INFO: [Common 17-349] Got license for feature 'Implementation' and/or device 'xczu7ev'\n", - "Running DRC as a precondition to command opt_design\n", - "\n", - "Starting DRC Task\n", - "INFO: [DRC 23-27] Running DRC with 8 threads\n", - "INFO: [Project 1-461] DRC finished with 0 Errors\n", - "INFO: [Project 1-462] Please refer to the DRC report (report_drc) for more information.\n", - "\n", - "Time (s): cpu = 00:00:01 ; elapsed = 00:00:00.79 . Memory (MB): peak = 2974.605 ; gain = 64.031 ; free physical = 2644 ; free virtual = 24159\n", - "\n", - "Starting Cache Timing Information Task\n", - "INFO: [Timing 38-35] Done setting XDC timing constraints.\n", - "Ending Cache Timing Information Task | Checksum: 284b2e407\n", - "\n", - "Time (s): cpu = 00:00:06 ; elapsed = 00:00:07 . Memory (MB): peak = 3520.738 ; gain = 546.133 ; free physical = 2185 ; free virtual = 23742\n", - "\n", - "Starting Logic Optimization Task\n", - "\n", - "Phase 1 Initialization\n", - "\n", - "Phase 1.1 Core Generation And Design Setup\n", - "Phase 1.1 Core Generation And Design Setup | Checksum: 284b2e407\n", - "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "\n", - "Phase 1.2 Setup Constraints And Sort Netlist\n", - "Phase 1.2 Setup Constraints And Sort Netlist | Checksum: 284b2e407\n", - "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "Phase 1 Initialization | Checksum: 284b2e407\n", - "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "\n", - "Phase 2 Timer Update And Timing Data Collection\n", - "\n", - "Phase 2.1 Timer Update\n", - "Phase 2.1 Timer Update | Checksum: 284b2e407\n", - "\n", - "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "\n", - "Phase 2.2 Timing Data Collection\n", - "Phase 2.2 Timing Data Collection | Checksum: 284b2e407\n", - "\n", - "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "Phase 2 Timer Update And Timing Data Collection | Checksum: 284b2e407\n", - "\n", - "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "\n", - "Phase 3 Retarget\n", - "INFO: [Opt 31-1834] Total Chains To Be Transformed Were: 0 AND Number of Transformed insts Created are: 0\n", - "INFO: [Opt 31-138] Pushed 1 inverter(s) to 34 load pin(s).\n", - "INFO: [Opt 31-49] Retargeted 0 cell(s).\n", - "Phase 3 Retarget | Checksum: 19a399bd1\n", - "\n", - "Time (s): cpu = 00:00:00.06 ; elapsed = 00:00:00.03 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "Retarget | Checksum: 19a399bd1\n", - "INFO: [Opt 31-389] Phase Retarget created 0 cells and removed 1 cells\n", - "\n", - "Phase 4 Constant propagation\n", - "INFO: [Opt 31-138] Pushed 0 inverter(s) to 0 load pin(s).\n", - "Phase 4 Constant propagation | Checksum: 1ad0fe5d2\n", - "\n", - "Time (s): cpu = 00:00:00.06 ; elapsed = 00:00:00.03 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "Constant propagation | Checksum: 1ad0fe5d2\n", - "INFO: [Opt 31-389] Phase Constant propagation created 0 cells and removed 0 cells\n", - "\n", - "Phase 5 Sweep\n", - "Phase 5 Sweep | Checksum: 21eac55bc\n", - "\n", - "Time (s): cpu = 00:00:00.06 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "Sweep | Checksum: 21eac55bc\n", - "INFO: [Opt 31-389] Phase Sweep created 2 cells and removed 0 cells\n", - "\n", - "Phase 6 Shift Register Optimization\n", - "INFO: [Opt 31-1064] SRL Remap converted 0 SRLs to 0 registers and converted 0 registers of register chains to 0 SRLs\n", - "Phase 6 Shift Register Optimization | Checksum: 21eac55bc\n", - "\n", - "Time (s): cpu = 00:00:00.06 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "Shift Register Optimization | Checksum: 21eac55bc\n", - "INFO: [Opt 31-389] Phase Shift Register Optimization created 0 cells and removed 0 cells\n", - "\n", - "Phase 7 Post Processing Netlist\n", - "Phase 7 Post Processing Netlist | Checksum: 22ebf3ca3\n", - "\n", - "Time (s): cpu = 00:00:00.07 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "Post Processing Netlist | Checksum: 22ebf3ca3\n", - "INFO: [Opt 31-389] Phase Post Processing Netlist created 0 cells and removed 0 cells\n", - "\n", - "Phase 8 Finalization\n", - "\n", - "Phase 8.1 Finalizing Design Cores and Updating Shapes\n", - "Phase 8.1 Finalizing Design Cores and Updating Shapes | Checksum: 17b8ff75a\n", - "\n", - "Time (s): cpu = 00:00:00.11 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "\n", - "Phase 8.2 Verifying Netlist Connectivity\n", - "Phase 8.2 Verifying Netlist Connectivity | Checksum: 17b8ff75a\n", - "\n", - "Time (s): cpu = 00:00:00.11 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "Phase 8 Finalization | Checksum: 17b8ff75a\n", - "\n", - "Time (s): cpu = 00:00:00.11 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "Opt_design Change Summary\n", - "=========================\n", - "\n", - "\n", - "-------------------------------------------------------------------------------------------------------------------------\n", - "| Phase | #Cells created | #Cells Removed | #Constrained objects preventing optimizations |\n", - "-------------------------------------------------------------------------------------------------------------------------\n", - "| Retarget | 0 | 1 | 0 |\n", - "| Constant propagation | 0 | 0 | 0 |\n", - "| Sweep | 2 | 0 | 0 |\n", - "| Shift Register Optimization | 0 | 0 | 0 |\n", - "| Post Processing Netlist | 0 | 0 | 0 |\n", - "-------------------------------------------------------------------------------------------------------------------------\n", - "\n", - "\n", - "Ending Logic Optimization Task | Checksum: 17b8ff75a\n", - "\n", - "Time (s): cpu = 00:00:00.11 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "\n", - "Starting Power Optimization Task\n", - "INFO: [Pwropt 34-132] Skipping clock gating for clocks with a period < 2.00 ns.\n", - "Ending Power Optimization Task | Checksum: 17b8ff75a\n", - "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "\n", - "Starting Final Cleanup Task\n", - "Ending Final Cleanup Task | Checksum: 17b8ff75a\n", - "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "\n", - "Starting Netlist Obfuscation Task\n", - "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "Ending Netlist Obfuscation Task | Checksum: 17b8ff75a\n", - "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3781.645 ; gain = 0.000 ; free physical = 1859 ; free virtual = 23420\n", - "INFO: [Common 17-83] Releasing license: Implementation\n", - "17 Infos, 0 Warnings, 0 Critical Warnings and 0 Errors encountered.\n", - "opt_design completed successfully\n", - "opt_design: Time (s): cpu = 00:00:09 ; elapsed = 00:00:09 . Memory (MB): peak = 3781.645 ; gain = 871.070 ; free physical = 1859 ; free virtual = 23420\n", - "# report_utilization -file vivado_synth.rpt\n", - "INFO: [Common 17-206] Exiting Vivado at Mon May 4 18:22:59 2026...\n", - "***** VIVADO SYNTHESIS COMPLETED IN 0h0m39s *****\n", - "INFO: [HLS 200-112] Total CPU user time: 70.73 seconds. Total CPU system time: 6.81 seconds. Total elapsed time: 98 seconds; peak allocated memory: 431.441 MB.\n", - "INFO: [vitis-run 60-791] Total elapsed time: 0h 1m 38s\n", - "INFO: [vitis-run 60-1662] Stopping dispatch session having empty uuid.\n", - "Implementation report not found.\n", - "Timing report not found.\n", - "[HLS] build complete\n", - "{'CSimResults': [['0.3125', '0.28125'], ['0.3125', '0.28125'], ['0.3125', '0.28125'], ['0.3125', '0.28125'], ['0.3125', '0.28125']], 'CosimResults': [['0.3125', '0.28125'], ['0.3125', '0.28125'], ['0.3125', '0.28125'], ['0.3125', '0.28125'], ['0.3125', '0.28125']], 'CSynthesisReport': {'TargetClockPeriod': '5.00', 'EstimatedClockPeriod': '3.154', 'BestLatency': '6', 'WorstLatency': '6', 'IntervalMin': '3', 'IntervalMax': '3', 'DSP': '0', 'FF': '278', 'LUT': '936', 'BRAM_18K': '0', 'URAM': '0', 'AvailableBRAM_18K': '624', 'AvailableDSP': '1728', 'AvailableFF': '460800', 'AvailableLUT': '230400', 'AvailableURAM': '96'}, 'VivadoSynthReport': {'LUT': '215', 'FF': '132', 'BRAM_18K': '0', 'URAM': '0', 'DSP48E': '0'}, 'CosimReport': {'RTL': 'Verilog', 'Status': 'Pass', 'LatencyMin': 8, 'LatencyMax': 10, 'IntervalMin': 2, 'IntervalMax': 4, 'LatencyAvg': 8.8, 'IntervalAvg': 2.75}}\n" - ] - } - ], - "source": [ - "hls_model, hls_cfg = convert_hls(\n", - " step_model=step_model,\n", - " out_dir=output_dir,\n", - " backend=backend,\n", - " part=part,\n", - " precision=precision,\n", - ")\n", - "\n", - "with open(output_dir / \"hls_config_used.json\", \"w\") as f:\n", - " json.dump(hls_cfg, f, indent=2, default=str)\n", - "\n", - "if not skip_build:\n", - " print(\"[HLS] building with full synthesis flow...\")\n", - " report = hls_model.build(\n", - " reset=True,\n", - " csim=True,\n", - " synth=True,\n", - " cosim=True,\n", - " validation=True,\n", - " export=True,\n", - " vsynth=True,\n", - " )\n", - " print(\"[HLS] build complete\")\n", - " print(report)\n", - "else:\n", - " print(\"[HLS] build skipped by flag\")" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "52cc336a-d6a0-4e46-9b17-49faaf3ff3ae", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[HLS] model compiled for predict()\n", - "[HLS] test accuracy=0.8000\n", - "[HLS] sequence throughput (locally, not a hardware sim)=607.04 samples/s\n" - ] - } - ], - "source": [ - "hls_model.compile()\n", - "print(\"[HLS] model compiled for predict()\")\n", - "hls_acc, hls_throughput = evaluate_hls_sequence(hls_model, x_tst, y_tst)\n", - "print(f\"[HLS] test accuracy={hls_acc:.4f}\")\n", - "print(f\"[HLS] sequence throughput (locally, not a hardware sim)={hls_throughput:.2f} samples/s\")" - ] - }, - { - "cell_type": "markdown", - "id": "ffd57a01-8921-4e9a-b305-5fcae54780c9", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "## neurobench analysis" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "d9e82e2e-70e6-4c08-8d64-532d4960cdd3", - "metadata": {}, - "outputs": [], - "source": [ - "test_loader = DataLoader(\n", - " TensorDataset(tx_tst.float(), ty_tst.long()),\n", - " batch_size=64,\n", - " shuffle=False,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "6eca41dd-2871-4934-842e-d4c1054bd112", - "metadata": {}, - "outputs": [], - "source": [ - "step_model.eval()\n", - "\n", - "# Wrap the single-step SNN for NeuroBench.\n", - "# SNNTorchModel will run the step model over the sequence dimension.\n", - "nb_model = SNNTorchModel(step_model)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "ff135acf-75e5-4f80-8a46-cc5581b204d7", - "metadata": {}, - "outputs": [], - "source": [ - "class SumTimeArgmax:\n", - " \"\"\"Convert per-timestep logits to class predictions.\n", - "\n", - " SNNTorchModel returns logits with shape [batch, timesteps, classes].\n", - " This matches the notebook's evaluation logic:\n", - " mem2 = sum_t fc2(spk1(t))\n", - " pred = argmax(mem2)\n", - " \"\"\"\n", - "\n", - " def __call__(self, preds):\n", - " if isinstance(preds, tuple):\n", - " preds = preds[0]\n", - "\n", - " if isinstance(preds, np.ndarray):\n", - " preds = torch.from_numpy(preds)\n", - "\n", - " # Expected case: [B, T, C]\n", - " if preds.ndim == 3:\n", - " return preds.sum(dim=1).argmax(dim=1)\n", - "\n", - " # Fallback if NeuroBench/model already returns [B, C]\n", - " if preds.ndim == 2:\n", - " return preds.argmax(dim=1)\n", - "\n", - " raise ValueError(f\"Unexpected prediction shape from NeuroBench: {preds.shape}\")\n", - "\n", - "\n", - "preprocessors = []\n", - "postprocessors = [SumTimeArgmax()]\n", - "\n", - "static_metrics = [\n", - " Footprint,\n", - " ConnectionSparsity,\n", - "]\n", - "\n", - "workload_metrics = [\n", - " ClassificationAccuracy,\n", - " ActivationSparsity,\n", - " SynapticOperations,\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "99027e7e-fbed-4263-afc0-d7eee55804a0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running benchmark\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [00:00<00:00, 32.05it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'Footprint': 4908, 'ConnectionSparsity': 0.0, 'ClassificationAccuracy': 0.7900000023841858, 'ActivationSparsity': 0.8682666666666667, 'SynapticOperations': {'Effective_MACs': 400.0, 'Effective_ACs': 52.693333333333335, 'Dense': 800.0}}\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "benchmark = Benchmark(\n", - " nb_model,\n", - " test_loader,\n", - " preprocessors,\n", - " postprocessors,\n", - " [static_metrics, workload_metrics],\n", - ")\n", - "\n", - "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", - "\n", - "results = benchmark.run(device=device)\n", - "print(results)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "59ec6474-fd85-4561-9291-f0ed0fdf99be", - "metadata": {}, - "outputs": [], - "source": [ - "#benchmark.save_benchmark_results(\n", - "# output_dir / \"neurobench_results\",\n", - "# file_format=\"json\",\n", - "#)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 2385b90f525daab4e805c8aa079a2a1aeb6e5f62 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Tue, 5 May 2026 17:21:56 +0100 Subject: [PATCH 07/32] readout and reset updated --- README.md | 7 +- docs/advanced/snn.rst | 135 ++++++++++++++++-- .../backends/vivado/passes/snn_templates.py | 5 + hls4ml/converters/pytorch/snn.py | 29 +++- hls4ml/converters/pytorch_to_hls.py | 11 ++ hls4ml/model/layers.py | 8 +- .../vivado/nnet_utils/nnet_if_neuron.h | 25 ++++ .../vivado/nnet_utils/nnet_lif_neuron.h | 25 ++++ .../vivado/nnet_utils/nnet_snn_common.h | 3 +- .../vivado/nnet_utils/nnet_snn_readout.h | 74 ++++++++++ hls4ml/utils/snntorch.py | 63 ++++++++ test/pytest/test_snn_pytorch.py | 66 ++++++--- 12 files changed, 417 insertions(+), 34 deletions(-) create mode 100644 hls4ml/utils/snntorch.py diff --git a/README.md b/README.md index 5a402af514..4e82d9d8f0 100644 --- a/README.md +++ b/README.md @@ -20,8 +20,9 @@ SNN feature details, supported modules, and behavior notes are documented in: - [docs/advanced/snn.rst](docs/advanced/snn.rst) -A demo of the SNN functionality + neurobench is in: +A demo of the SNN functionality is in: -- [hls4snn-demo.ipynb](hls4snn-demo.ipynb) +- [hls4ml-snn-example.ipynb](hls4ml-snn-example.ipynb) +- [snn-hls4ml-demo.ipynb](snn-hls4ml-demo.ipynb) -This takes you from building and training a simple SNN in snntorch, to running it through hls4ml and getting Vitis reports, and lastly running the model through neurobench to get SNN-specific metrics. +These take you from building and training a simple SNN in snntorch, to running it through hls4ml and getting Vitis reports. The longer demo also includes optional NeuroBench metrics. diff --git a/docs/advanced/snn.rst b/docs/advanced/snn.rst index ef831a5026..2a21ce71b2 100644 --- a/docs/advanced/snn.rst +++ b/docs/advanced/snn.rst @@ -20,12 +20,41 @@ The frontend currently supports direct parsing of: * ``Leaky`` -> ``LIFNeuron`` (or ``IFNeuron`` when ``beta`` is effectively 1) ``SNNReadout`` is an hls4ml layer, not a ``snntorch`` module. To use the -built-in hls4ml readout from a PyTorch model, define a lightweight PyTorch -module or custom extension layer, subclass ``hls4ml.utils.torch.HLS4MLModule`` -so that FX treats it as a leaf module, and expose the readout configuration as -attributes. The default parser recognizes a wrapper whose class name is -``SNNReadout``. Alternatively, register a custom PyTorch layer handler that maps -your own module name to the hls4ml ``SNNReadout`` layer. +built-in hls4ml readout from a PyTorch model, instantiate the provided PyTorch +marker module: + +.. code-block:: python + + from hls4ml.utils.snntorch import SNNReadout + +The marker is an identity in PyTorch and is converted to the hls4ml +``SNNReadout`` layer by the PyTorch frontend. Alternatively, register a custom +PyTorch layer handler that maps your own module name to the hls4ml +``SNNReadout`` layer. + +Example: + +.. code-block:: python + + class ReadoutSNN(torch.nn.Module): + def __init__(self, timesteps): + super().__init__() + self.fc1 = torch.nn.Linear(2, 8) + self.if1 = snntorch.Leaky(beta=0.75, threshold=1.0) + self.fc2 = torch.nn.Linear(8, 2) + self.readout = SNNReadout( + n_classes=2, + window_size=timesteps, + output_mode="membrane", + decision_rule="argmax_membrane", + beta=1.0, + ) + + def forward(self, x_t): + x_t = self.fc1(x_t) + spk1, _ = self.if1(x_t) + x_t = self.fc2(spk1) + return self.readout(x_t) `snntorch` tracing ================== @@ -53,7 +82,8 @@ at conversion time. Readout and Decision Rules ========================== -The hls4ml ``SNNReadout`` layer implements programmable per-model decision policies: +The hls4ml ``SNNReadout`` layer implements programmable per-model decision policies. +By default, ``output_mode="spike"`` preserves the original spike-count behavior: * ``argmax_spike_count`` * ``first_to_threshold`` @@ -64,25 +94,110 @@ The layer accumulates class spikes over a window. For most decision rules it emi a class ID. For ``binary_logit``, it emits a score equal to ``count(class_1) - count(class_0)``. +For non-spiking readout heads, set ``output_mode="membrane"`` and connect +``SNNReadout`` directly after the final dense/linear layer instead of after a +final spiking neuron. In this mode the readout owns the final membrane state: + +.. code-block:: python + + x = self.fc2(x) + return self.readout(x) + +At each timestep, the generated readout computes: + +.. code-block:: cpp + + mem[i] = beta * mem[i] + input[i]; + +No threshold or reset-on-spike is applied in membrane mode. The supported +membrane decision policies are: + +* ``argmax_membrane`` +* ``binary_logit`` (emits ``mem(class_1) - mem(class_0)`` for binary classifiers) + +This keeps the snnTorch neuron modules unchanged; the final readout layer +performs the non-spiking LIF-style accumulation in generated HLS. + +Do not place a final spiking neuron before ``SNNReadout(output_mode="membrane")`` +unless you intentionally want the readout to consume that neuron's spike output. +The membrane mode does not recover or expose the internal membrane state of a +preceding ``Leaky``/``IFNeuron``/``LIFNeuron`` layer. If a final output neuron +has a learnable ``beta``, that learnable neuron membrane is not the same state +as the readout-owned membrane. The readout uses its own scalar ``beta``. + When using the default PyTorch parser, the wrapper module should expose these attributes as needed: * ``n_classes`` (defaults to the input feature count if omitted) * ``window_size`` or ``stream_length`` (defaults to ``1``) * ``class_threshold`` (defaults to ``1``) +* ``output_mode`` (defaults to ``spike``; use ``membrane`` for readout-owned membrane accumulation) +* ``beta`` (defaults to ``1.0`` for membrane readout) * ``decision_rule`` (defaults to ``argmax_spike_count``) * ``reset_policy`` or ``state_reset_policy`` (defaults to ``fixed_window``) Window Boundary Semantics ========================= -The current implementation uses ``window_size`` timesteps as the sequence boundary. +The current implementation uses ``window_size`` timesteps as the sequence boundary +for generated HLS. During PyTorch conversion, the first fixed-window +``SNNReadout``'s ``window_size`` is propagated to all converted ``IFNeuron`` and +``LIFNeuron`` layers in the graph. + At each boundary: * the class decision is emitted -* internal readout counters are reset for the next sequence +* internal readout counters or readout membrane state are reset for the next sequence +* internal ``IFNeuron``/``LIFNeuron`` membrane state is reset for the next sequence + +The reset happens after the final timestep has been processed and has contributed +to the output. This behavior is compatible with fixed-length time windows. + +Only fixed-window reset is implemented in generated layer kernels today. +``state_reset_policy`` accepts future-facing values such as ``tlast``, +``host_pulse``, and ``never``, but the current layer kernels still use fixed +``window_size`` reset behavior. + +Running ``hls_model.predict()`` +============================== + +Compiled SNN models are stateful across top-function calls. For fixed-window +SNN inference, call the compiled model once per timestep and pass exactly +``window_size`` timesteps for each independent sequence: + +.. code-block:: python + + last = None + for step in range(timesteps): + x_step = x_sequence[step].astype("float32")[None, :] + last = hls_model.predict(x_step) + +After the last call in the window, generated HLS resets the neuron and readout +state for the next sequence. Avoid making stray single-timestep ``predict`` +calls before evaluating a sequence, because those calls advance the state. + +For membrane readout, the PyTorch reference should match the generated readout +accumulation: + +.. code-block:: python + + mem = torch.zeros_like(currents[:, 0, :]) + for step in range(currents.shape[1]): + mem = beta * mem + currents[:, step, :] + pred = mem.argmax(dim=1) + +Using only the final dense current, or using spike-count reduction for a +membrane readout, does not match generated HLS behavior. + +Precision note +============== -This behavior is compatible with fixed-length time windows. +Membrane readout accumulates dense currents over the full window, so very narrow +fixed-point types can reduce accuracy even when the floating-point PyTorch model +looks good. In the example notebooks, ``ap_fixed<8,3>`` is often too narrow for +membrane readout. Start with a wider network precision such as +``ap_fixed<12,5>`` and a wider readout ``membrane_t`` such as +``ap_fixed<16,7>``, then tighten after comparing HLS and PyTorch outputs. ``TLAST`` note ============== diff --git a/hls4ml/backends/vivado/passes/snn_templates.py b/hls4ml/backends/vivado/passes/snn_templates.py index b9269d1a0b..915afccf75 100644 --- a/hls4ml/backends/vivado/passes/snn_templates.py +++ b/hls4ml/backends/vivado/passes/snn_templates.py @@ -5,6 +5,7 @@ static const unsigned n_in = {n_in}; static const unsigned n_out = {n_out}; static const unsigned io_type = nnet::{iotype}; + static const unsigned window_size = {window_size}; static const bool threshold_is_vector = {threshold_is_vector}; static constexpr float threshold = {threshold}; static const nnet::snn_reset_mode reset_mode = nnet::snn_reset_mode::{reset_mechanism}; @@ -44,6 +45,7 @@ def format(self, node): static const unsigned n_in = {n_in}; static const unsigned n_out = {n_out}; static const unsigned io_type = nnet::{iotype}; + static const unsigned window_size = {window_size}; static const bool beta_is_vector = {beta_is_vector}; static const bool threshold_is_vector = {threshold_is_vector}; static constexpr float threshold = {threshold}; @@ -89,7 +91,10 @@ def format(self, node): static const unsigned io_type = nnet::{iotype}; static const unsigned window_size = {window_size}; static const unsigned class_threshold = {class_threshold}; + static constexpr float beta = {beta}; + static const nnet::snn_readout_mode output_mode = nnet::snn_readout_mode::{output_mode}; static const nnet::snn_decision_rule decision_rule = nnet::snn_decision_rule::{decision_rule}; + typedef {membrane_t.name} membrane_t; }};\n""" readout_function_template = 'nnet::snn_readout<{input_t}, {output_t}, {config}>({input}, {output});' diff --git a/hls4ml/converters/pytorch/snn.py b/hls4ml/converters/pytorch/snn.py index 522222ae48..653c51f81d 100644 --- a/hls4ml/converters/pytorch/snn.py +++ b/hls4ml/converters/pytorch/snn.py @@ -53,6 +53,14 @@ def _parse_state_reset_policy(class_object): return policy +def _parse_readout_beta(class_object): + beta = getattr(class_object, 'beta', 1.0) + arr = _to_numpy(beta, 'beta').reshape(-1) + if arr.size != 1: + raise Exception(f'Only scalar "beta" is supported for SNNReadout membrane mode, got shape {arr.shape}') + return float(arr[0]) + + @pytorch_handler('Leaky') def parse_lif_layer(operation, layer_name, input_names, input_shapes, node, class_object, data_reader, config): assert operation == 'Leaky' @@ -105,15 +113,30 @@ def parse_snn_readout_layer(operation, layer_name, input_names, input_shapes, no else: layer['window_size'] = int(getattr(class_object, 'window_size', 1)) layer['class_threshold'] = int(getattr(class_object, 'class_threshold', 1)) - layer['decision_rule'] = str(getattr(class_object, 'decision_rule', 'argmax_spike_count')) + layer['output_mode'] = str(getattr(class_object, 'output_mode', 'spike')).lower() + if layer['output_mode'] not in ['spike', 'membrane']: + raise Exception(f'Unsupported SNNReadout output mode "{layer["output_mode"]}". Supported: spike, membrane.') + layer['beta'] = _parse_readout_beta(class_object) + default_decision_rule = 'argmax_membrane' if layer['output_mode'] == 'membrane' else 'argmax_spike_count' + layer['decision_rule'] = str(getattr(class_object, 'decision_rule', default_decision_rule)) layer['state_reset_policy'] = _parse_state_reset_policy(class_object) - if layer['decision_rule'] not in ['argmax_spike_count', 'first_to_threshold', 'threshold_then_argmax', 'binary_logit']: + if layer['decision_rule'] not in [ + 'argmax_spike_count', + 'first_to_threshold', + 'threshold_then_argmax', + 'binary_logit', + 'argmax_membrane', + ]: raise Exception( f'Unsupported SNN decision rule "{layer["decision_rule"]}". ' - 'Supported: argmax_spike_count, first_to_threshold, threshold_then_argmax, binary_logit.' + 'Supported: argmax_spike_count, first_to_threshold, threshold_then_argmax, binary_logit, argmax_membrane.' ) if layer['decision_rule'] == 'binary_logit' and layer['n_classes'] != 2: raise Exception('binary_logit decision rule requires n_classes == 2') + if layer['output_mode'] == 'membrane' and layer['decision_rule'] not in ['argmax_membrane', 'binary_logit']: + raise Exception('SNNReadout membrane mode supports decision_rule "argmax_membrane" or "binary_logit".') + if layer['output_mode'] == 'spike' and layer['decision_rule'] == 'argmax_membrane': + raise Exception('SNNReadout decision_rule "argmax_membrane" requires output_mode "membrane".') output_shape = input_shapes[0][:] output_shape[-1] = 1 diff --git a/hls4ml/converters/pytorch_to_hls.py b/hls4ml/converters/pytorch_to_hls.py index 5399cf37cb..9d62330ef0 100644 --- a/hls4ml/converters/pytorch_to_hls.py +++ b/hls4ml/converters/pytorch_to_hls.py @@ -422,6 +422,17 @@ def resolve_getitem_source(node_name, visited=None): if len(input_layers) == 0: input_layers = None + fixed_window_readouts = [ + layer + for layer in layer_list + if layer.get('class_name') == 'SNNReadout' and layer.get('state_reset_policy', 'fixed_window') == 'fixed_window' + ] + if fixed_window_readouts: + window_size = fixed_window_readouts[0].get('window_size', 0) + for layer in layer_list: + if layer.get('class_name') in ['IFNeuron', 'LIFNeuron']: + layer['window_size'] = window_size + for layer in layer_list: if layer['class_name'] == 'InputLayer': continue diff --git a/hls4ml/model/layers.py b/hls4ml/model/layers.py index f83f7e9c1b..aa4736b4d3 100644 --- a/hls4ml/model/layers.py +++ b/hls4ml/model/layers.py @@ -1041,6 +1041,7 @@ class IFNeuron(Layer): _expected_attributes = [ Attribute('n_in'), Attribute('n_out'), + Attribute('window_size', value_type=int, default=0, configurable=False), Attribute('threshold', value_type=float), Attribute('threshold_mode', value_type=str, default='scalar'), ChoiceAttribute('reset_mechanism', choices=['subtract', 'zero'], default='subtract', configurable=False), @@ -1072,6 +1073,7 @@ class LIFNeuron(Layer): _expected_attributes = [ Attribute('n_in'), Attribute('n_out'), + Attribute('window_size', value_type=int, default=0, configurable=False), Attribute('threshold', value_type=float), Attribute('threshold_mode', value_type=str, default='scalar'), Attribute('beta', value_type=float), @@ -1120,6 +1122,8 @@ class SNNReadout(Layer): Attribute('n_classes', configurable=False), Attribute('window_size', value_type=int, default=1, configurable=False), Attribute('class_threshold', value_type=int, default=1, configurable=False), + Attribute('beta', value_type=float, default=1.0), + ChoiceAttribute('output_mode', choices=['spike', 'membrane'], default='spike', configurable=False), ChoiceAttribute( 'state_reset_policy', choices=['fixed_window', 'tlast', 'host_pulse', 'never'], @@ -1128,16 +1132,18 @@ class SNNReadout(Layer): ), ChoiceAttribute( 'decision_rule', - choices=['argmax_spike_count', 'first_to_threshold', 'threshold_then_argmax', 'binary_logit'], + choices=['argmax_spike_count', 'first_to_threshold', 'threshold_then_argmax', 'binary_logit', 'argmax_membrane'], default='argmax_spike_count', configurable=False, ), + TypeAttribute('membrane'), ] def initialize(self): shape = list(self.get_input_variable().shape) shape[-1] = 1 self.add_output_variable(shape) + self._set_type_t('membrane') class BatchNormOnnx(Layer): diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h b/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h index 9593211c06..803df32c50 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h @@ -11,6 +11,7 @@ struct if_neuron_config { static const unsigned n_in = 1; static const unsigned n_out = 1; static const unsigned io_type = io_parallel; + static const unsigned window_size = 0; static const bool threshold_is_vector = false; static constexpr float threshold = 1.0; static const snn_reset_mode reset_mode = snn_reset_mode::subtract; @@ -26,6 +27,7 @@ void if_neuron( static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; #pragma HLS ARRAY_PARTITION variable=mem complete + static unsigned ts = 0; for (unsigned i = 0; i < CONFIG_T::n_out; i++) { #pragma HLS UNROLL @@ -46,6 +48,17 @@ void if_neuron( } mem[i] = v; } + + if (CONFIG_T::window_size > 0) { + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + mem[i] = 0; + } + } + } } template @@ -58,6 +71,7 @@ void if_neuron( static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; #pragma HLS ARRAY_PARTITION variable=mem complete + static unsigned ts = 0; data_T in_pack = data_stream.read(); res_T out_pack; @@ -84,6 +98,17 @@ void if_neuron( } res_stream.write(out_pack); + + if (CONFIG_T::window_size > 0) { + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + mem[i] = 0; + } + } + } } } // namespace nnet diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h b/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h index 25649cfcc7..c45d246c1b 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h @@ -11,6 +11,7 @@ struct lif_neuron_config { static const unsigned n_in = 1; static const unsigned n_out = 1; static const unsigned io_type = io_parallel; + static const unsigned window_size = 0; static const bool beta_is_vector = false; static const bool threshold_is_vector = false; static constexpr float threshold = 1.0; @@ -32,6 +33,7 @@ void lif_neuron( static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; #pragma HLS ARRAY_PARTITION variable=mem complete + static unsigned ts = 0; for (unsigned i = 0; i < CONFIG_T::n_out; i++) { #pragma HLS UNROLL @@ -53,6 +55,17 @@ void lif_neuron( } mem[i] = v; } + + if (CONFIG_T::window_size > 0) { + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + mem[i] = 0; + } + } + } } template @@ -66,6 +79,7 @@ void lif_neuron( static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; #pragma HLS ARRAY_PARTITION variable=mem complete + static unsigned ts = 0; data_T in_pack = data_stream.read(); res_T out_pack; @@ -93,6 +107,17 @@ void lif_neuron( } res_stream.write(out_pack); + + if (CONFIG_T::window_size > 0) { + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + mem[i] = 0; + } + } + } } } // namespace nnet diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h b/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h index e453a522d1..8fa5a3dbe4 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h @@ -4,7 +4,8 @@ namespace nnet { enum class snn_reset_mode { subtract, zero }; -enum class snn_decision_rule { argmax_spike_count, first_to_threshold, threshold_then_argmax, binary_logit }; +enum class snn_decision_rule { argmax_spike_count, first_to_threshold, threshold_then_argmax, binary_logit, argmax_membrane }; +enum class snn_readout_mode { spike, membrane }; } // namespace nnet diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h b/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h index 90df5db29a..b2089b6cf8 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h @@ -12,7 +12,10 @@ struct snn_readout_config { static const unsigned io_type = io_parallel; static const unsigned window_size = 1; static const unsigned class_threshold = 1; + static constexpr float beta = 1.0; + static const snn_readout_mode output_mode = snn_readout_mode::spike; static const snn_decision_rule decision_rule = snn_decision_rule::argmax_spike_count; + typedef float membrane_t; }; template @@ -21,8 +24,40 @@ void snn_readout(data_T data[CONFIG_T::n_classes], res_T res[1]) { static unsigned counts[CONFIG_T::n_classes]; #pragma HLS ARRAY_PARTITION variable=counts complete + static typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]; + #pragma HLS ARRAY_PARTITION variable=mem complete static unsigned ts = 0; + if (CONFIG_T::output_mode == snn_readout_mode::membrane) { + unsigned best = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + typename CONFIG_T::membrane_t v = + (typename CONFIG_T::membrane_t)((typename CONFIG_T::membrane_t)CONFIG_T::beta * mem[i]) + + (typename CONFIG_T::membrane_t)data[i]; + mem[i] = v; + if (i == 0 || v > mem[best]) { + best = i; + } + } + + if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { + res[0] = (typename res_T::value_type)(mem[1] - mem[0]); + } else { + res[0] = (typename res_T::value_type)best; + } + + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + mem[i] = 0; + } + } + return; + } + if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { #pragma HLS UNROLL @@ -124,10 +159,49 @@ void snn_readout(hls::stream &data_stream, hls::stream &res_strea static unsigned counts[CONFIG_T::n_classes]; #pragma HLS ARRAY_PARTITION variable=counts complete + static typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]; + #pragma HLS ARRAY_PARTITION variable=mem complete static unsigned ts = 0; data_T in_pack = data_stream.read(); + if (CONFIG_T::output_mode == snn_readout_mode::membrane) { + unsigned best = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + typename CONFIG_T::membrane_t v = + (typename CONFIG_T::membrane_t)((typename CONFIG_T::membrane_t)CONFIG_T::beta * mem[i]) + + (typename CONFIG_T::membrane_t)in_pack[i]; + mem[i] = v; + if (i == 0 || v > mem[best]) { + best = i; + } + } + + res_T out_pack; + PRAGMA_DATA_PACK(out_pack) + for (unsigned i = 0; i < res_T::size; i++) { + #pragma HLS UNROLL + out_pack[i] = 0; + } + if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { + out_pack[0] = (typename res_T::value_type)(mem[1] - mem[0]); + } else { + out_pack[0] = (typename res_T::value_type)best; + } + res_stream.write(out_pack); + + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + mem[i] = 0; + } + } + return; + } + if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { #pragma HLS UNROLL diff --git a/hls4ml/utils/snntorch.py b/hls4ml/utils/snntorch.py new file mode 100644 index 0000000000..e52797cafb --- /dev/null +++ b/hls4ml/utils/snntorch.py @@ -0,0 +1,63 @@ +import torch + +from hls4ml.utils.torch import HLS4MLModule + + +class SNNReadout(HLS4MLModule): + """PyTorch marker module for the hls4ml SNNReadout layer. + + In PyTorch this module is an identity. During conversion, hls4ml lowers it + to the built-in SNNReadout IR layer and backend implementation. + """ + + VALID_OUTPUT_MODES = ('spike', 'membrane') + VALID_DECISION_RULES = ( + 'argmax_spike_count', + 'first_to_threshold', + 'threshold_then_argmax', + 'binary_logit', + 'argmax_membrane', + ) + + def __init__( + self, + n_classes=None, + window_size=1, + stream_length=None, + decision_rule=None, + class_threshold=1, + output_mode='spike', + beta=1.0, + reset_policy='fixed_window', + ): + super().__init__() + + output_mode = str(output_mode).lower() + if output_mode not in self.VALID_OUTPUT_MODES: + raise ValueError(f'Unsupported SNNReadout output_mode "{output_mode}". Supported: spike, membrane.') + + if decision_rule is None: + decision_rule = 'argmax_membrane' if output_mode == 'membrane' else 'argmax_spike_count' + decision_rule = str(decision_rule) + if decision_rule not in self.VALID_DECISION_RULES: + raise ValueError( + f'Unsupported SNNReadout decision_rule "{decision_rule}". Supported: {", ".join(self.VALID_DECISION_RULES)}.' + ) + if output_mode == 'membrane' and decision_rule not in ('argmax_membrane', 'binary_logit'): + raise ValueError('SNNReadout membrane mode supports decision_rule "argmax_membrane" or "binary_logit".') + if output_mode == 'spike' and decision_rule == 'argmax_membrane': + raise ValueError('SNNReadout decision_rule "argmax_membrane" requires output_mode "membrane".') + + self.n_classes = n_classes + if stream_length is None: + self.window_size = int(window_size) + else: + self.stream_length = int(stream_length) + self.decision_rule = decision_rule + self.class_threshold = int(class_threshold) + self.output_mode = output_mode + self.beta = torch.tensor(float(beta)) + self.reset_policy = str(reset_policy) + + def forward(self, x): + return x diff --git a/test/pytest/test_snn_pytorch.py b/test/pytest/test_snn_pytorch.py index a327f45720..aef819b0f7 100644 --- a/test/pytest/test_snn_pytorch.py +++ b/test/pytest/test_snn_pytorch.py @@ -4,6 +4,7 @@ import torch import hls4ml +import hls4ml.utils.snntorch import hls4ml.utils.torch test_root_path = Path(__file__).parent @@ -31,18 +32,6 @@ def forward(self, x): return self.neuron(x) -class SNNReadout(hls4ml.utils.torch.HLS4MLModule): - def __init__(self, n_classes=4, window_size=16, decision_rule='argmax_spike_count', class_threshold=2): - super().__init__() - self.n_classes = n_classes - self.window_size = window_size - self.decision_rule = decision_rule - self.class_threshold = class_threshold - - def forward(self, x): - return x - - class SNNReadoutWithResetPolicy(hls4ml.utils.torch.HLS4MLModule): def __init__(self, n_classes=4, stream_length=7, decision_rule='argmax_spike_count', class_threshold=2, reset_policy='tlast'): super().__init__() @@ -72,7 +61,7 @@ def __init__(self): super().__init__() self.fc = torch.nn.Linear(4, 4) self.neuron = Leaky(beta=0.95, threshold=1.2, reset_mechanism='subtract') - self.readout = SNNReadout( + self.readout = hls4ml.utils.snntorch.SNNReadout( n_classes=4, window_size=12, decision_rule='threshold_then_argmax', class_threshold=3 ) @@ -82,6 +71,23 @@ def forward(self, x): return self.readout(x) +class SNNMembraneReadoutClassifier(torch.nn.Module): + def __init__(self): + super().__init__() + self.fc = torch.nn.Linear(4, 4) + self.readout = hls4ml.utils.snntorch.SNNReadout( + n_classes=4, + window_size=12, + decision_rule='argmax_membrane', + output_mode='membrane', + beta=0.9, + ) + + def forward(self, x): + x = self.fc(x) + return self.readout(x) + + class SNNClassifierWithResetPolicy(torch.nn.Module): def __init__(self): super().__init__() @@ -151,6 +157,7 @@ def forward(self, x): (IFNet, 'IFNeuron'), (IFNetTol, 'IFNeuron'), (SNNClassifier, 'SNNReadout'), + (SNNMembraneReadoutClassifier, 'SNNReadout'), ], ) def test_pytorch_snn_layers_are_parsed(test_case_id, model_class, expected_layer): @@ -172,9 +179,17 @@ def test_pytorch_snn_layers_are_parsed(test_case_id, model_class, expected_layer if expected_layer == 'SNNReadout': readout = [layer for layer in hmodel.get_layers() if layer.class_name == 'SNNReadout'][0] - assert readout.get_attr('decision_rule') == 'threshold_then_argmax' - assert readout.get_attr('window_size') == 12 - assert readout.get_attr('class_threshold') == 3 + if model_class == SNNMembraneReadoutClassifier: + assert readout.get_attr('output_mode') == 'membrane' + assert readout.get_attr('decision_rule') == 'argmax_membrane' + assert readout.get_attr('beta') == pytest.approx(0.9) + else: + assert readout.get_attr('output_mode') == 'spike' + assert readout.get_attr('decision_rule') == 'threshold_then_argmax' + assert readout.get_attr('window_size') == 12 + assert readout.get_attr('class_threshold') == 3 + neuron = [layer for layer in hmodel.get_layers() if layer.class_name in ['IFNeuron', 'LIFNeuron']][0] + assert neuron.get_attr('window_size') == 12 @pytest.mark.parametrize( @@ -306,3 +321,22 @@ def test_snn_layer_type_config_is_exposed_for_quantization(test_case_id): assert layer.get_attr('beta_t').precision.definition_cpp() == 'ap_fixed<12,2>' assert layer.get_attr('threshold_t').precision.definition_cpp() == 'ap_fixed<10,3>' assert layer.get_attr('membrane_t').precision.definition_cpp() == 'ap_fixed<14,4>' + + +def test_snn_membrane_readout_type_config_is_exposed(test_case_id): + model = SNNMembraneReadoutClassifier() + config = hls4ml.utils.config_from_pytorch_model( + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + ) + config['LayerName']['readout']['membrane_t'] = 'ap_fixed<18,6>' + + hmodel = hls4ml.converters.convert_from_pytorch_model( + model, + output_dir=str(test_root_path / test_case_id), + backend='Vivado', + io_type='io_parallel', + hls_config=config, + ) + + readout = [layer for layer in hmodel.get_layers() if layer.class_name == 'SNNReadout'][0] + assert readout.get_attr('membrane_t').precision.definition_cpp() == 'ap_fixed<18,6>' From f10193fd854d2ce934e86fd8db603dc0f8441834 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Tue, 5 May 2026 17:42:16 +0100 Subject: [PATCH 08/32] update branch for pr --- .gitignore | 8 - README.md | 190 +++- docs/advanced/snn.rst | 6 + hls4ml-snn-example.ipynb | 2241 ++++++++++++++++++++++++++++++++++++++ pyproject.toml | 1 + requirements-snn-dev.txt | 18 - 6 files changed, 2423 insertions(+), 41 deletions(-) create mode 100644 hls4ml-snn-example.ipynb delete mode 100644 requirements-snn-dev.txt diff --git a/.gitignore b/.gitignore index 1a771cac6c..8fb87927ce 100644 --- a/.gitignore +++ b/.gitignore @@ -15,11 +15,3 @@ hls4mlprj_* *~ *.ipynb_checkpoints/ *.bak -.ipynb_checkpoints/ -.pytest_cache/ -*.ipynb -snn_test_lif/ -snn_smoke* -examples/snn_* -FPGAs_AdaptiveSoCs_Unified_2024.1_0522_2023_Lin64.bin -_ignore_* diff --git a/README.md b/README.md index 4e82d9d8f0..f49fe76d36 100644 --- a/README.md +++ b/README.md @@ -1,28 +1,188 @@ -# hls4snn +

+ hls4ml +

-`hls4snn` is a fork of `hls4ml` focused on spiking neural network (SNN) functionality in the PyTorch frontend, while keeping the upstream `hls4ml` workflow and documentation structure. +[![DOI](https://zenodo.org/badge/108329371.svg)](https://zenodo.org/badge/latestdoi/108329371) +[![License](https://img.shields.io/badge/License-Apache_2.0-red.svg)](https://opensource.org/licenses/Apache-2.0) +[![Documentation Status](https://github.com/fastmachinelearning/hls4ml/actions/workflows/build-sphinx.yml/badge.svg)](https://fastmachinelearning.org/hls4ml) +[![PyPI version](https://badge.fury.io/py/hls4ml.svg)](https://badge.fury.io/py/hls4ml) +[![Downloads](https://static.pepy.tech/personalized-badge/hls4ml?period=total&units=international_system&left_color=grey&right_color=orange&left_text=Downloads)](https://pepy.tech/project/hls4ml) +conda-forge -## What's Different In This Fork +A package for machine learning inference in FPGAs. We create firmware implementations of machine learning algorithms using high level synthesis language (HLS). We translate traditional open-source machine learning package models into HLS that can be configured for your use-case! -- Added initial SNN conversion support for PyTorch models using `snntorch` modules. -- Added SNN neuron/readout templates and related conversion backend plumbing. -- Added SNN-focused tests and documentation. +hls4ml is designed for ultra-low-latency inference on FPGAs. While it has strong roots in high-energy physics applications (e.g., L1 trigger systems at the CERN Large Hadron Collider), it has also been adopted across diverse scientific and industrial domains. Example use cases include control systems for quantum computing, feedback loops in nuclear fusion, low-power environmental monitoring on satellites, and biomedical signal processing (e.g., arrhythmia classification). -## SNN Quick Start -Install SNN development dependencies from this repository: +If you have any questions, comments, or ideas regarding hls4ml or just want to show us how you use hls4ml, don't hesitate to reach us through the [discussions](https://github.com/fastmachinelearning/hls4ml/discussions) tab. +# Documentation & Tutorial + +For more information visit the webpage: [https://fastmachinelearning.org/hls4ml/](https://fastmachinelearning.org/hls4ml/). + +For introductory material on FPGAs, HLS and ML inferences using hls4ml, check out the [video](https://www.youtube.com/watch?v=2y3GNY4tf7A&ab_channel=SystemsGroupatETHZ%C3%BCrich). + +Detailed tutorials on how to use `hls4ml`'s various functionalities can be found [here](https://github.com/hls-fpga-machine-learning/hls4ml-tutorial). + +# Installation ```bash -pip install -r requirements-snn-dev.txt +pip install hls4ml +``` + +To install the extra dependencies for profiling: + +```bash +pip install hls4ml[profiling] +``` + +# Getting Started +### Creating an HLS project +```Python +import hls4ml + +# Fetch a keras model from our example repository +# This will download our example model to your working directory and return an example configuration file +config = hls4ml.utils.fetch_example_model('KERAS_3layer.json') + +# You can print the configuration to see some default parameters +print(config) + +# Convert it to a hls project +hls_model = hls4ml.converters.keras_v2_to_hls(config) + +# Print full list of example models if you want to explore more +hls4ml.utils.fetch_example_list() ``` -SNN feature details, supported modules, and behavior notes are documented in: +### Building a project. +We will build the project using Xilinx Vivado HLS, which can be downloaded and installed from [here](https://www.xilinx.com/products/design-tools/vivado/integration/esl-design.html). Alongside Vivado HLS, hls4ml also supports Vitis HLS, Intel HLS, Catapult HLS and has some experimental support dor Intel oneAPI. The target back-end can be changed using the argument backend when building the model. + +```Python +# Use Vivado HLS to synthesize the model +# This might take several minutes +hls_model.build() + +# Print out the report if you want +hls4ml.report.read_vivado_report('my-hls-test') +``` -- [docs/advanced/snn.rst](docs/advanced/snn.rst) +# FAQ + +List of frequently asked questions and common HLS synthesis can be found [here](https://fastmachinelearning.org/hls4ml/intro/faq.html) + +# Citation +If you use this software in a publication, please cite the software +```bibtex +@software{fastml_hls4ml, + author = {{FastML Team}}, + title = {fastmachinelearning/hls4ml}, + year = 2025, + publisher = {Zenodo}, + version = {v1.3.0}, + doi = {10.5281/zenodo.1201549}, + url = {https://github.com/fastmachinelearning/hls4ml} +} +``` +the first publication: +```bibtex +@article{Duarte:2018ite, + author = "Duarte, Javier and others", + title = "{Fast inference of deep neural networks in FPGAs for particle physics}", + eprint = "1804.06913", + archivePrefix = "arXiv", + primaryClass = "physics.ins-det", + reportNumber = "FERMILAB-PUB-18-089-E", + doi = "10.1088/1748-0221/13/07/P07027", + journal = "JINST", + volume = "13", + number = "07", + pages = "P07027", + year = "2018" +} +``` +and the latest overview paper: +```bibtex +@article{Schulte:2025mai, + author = "Schulte, Jan-Frederik and others", + title = "{hls4ml: A Flexible, Open-Source Platform for Deep Learning Acceleration on Reconfigurable Hardware}", + eprint = "2512.01463", + archivePrefix = "arXiv", + primaryClass = "cs.AR", + reportNumber = "FERMILAB-PUB-25-0890-CSAID-ETD-PPD", + month = "12", + year = "2025" +} +``` + +Additionally, if you use specific features developed in later papers, please cite those as well. For example, CNNs: +```bibtex +@article{Aarrestad:2021zos, + author = "Aarrestad, Thea and others", + title = "{Fast convolutional neural networks on FPGAs with hls4ml}", + eprint = "2101.05108", + archivePrefix = "arXiv", + primaryClass = "cs.LG", + reportNumber = "FERMILAB-PUB-21-130-SCD", + doi = "10.1088/2632-2153/ac0ea1", + journal = "Mach. Learn. Sci. Tech.", + volume = "2", + number = "4", + pages = "045015", + year = "2021" +} +@article{Ghielmetti:2022ndm, + author = "Ghielmetti, Nicol\`{o} and others", + title = "{Real-time semantic segmentation on FPGAs for autonomous vehicles with hls4ml}", + eprint = "2205.07690", + archivePrefix = "arXiv", + primaryClass = "cs.CV", + reportNumber = "FERMILAB-PUB-22-435-PPD", + doi = "10.1088/2632-2153/ac9cb5", + journal ="Mach. Learn. Sci. Tech.", + year = "2022" +} +``` +Distributed arithmetic: +```bibtex +@misc{Sun:2025, + title={da4ml: Distributed Arithmetic for Real-time Neural Networks on FPGAs}, + author={Chang Sun and others}, + year={2025}, + eprint={2507.04535}, + archivePrefix={arXiv}, + primaryClass={cs.AR}, + url={https://arxiv.org/abs/2507.04535}, +} +``` +binary/ternary networks: +```bibtex +@article{Loncar:2020hqp, + author = "Ngadiuba, Jennifer and others", + title = "{Compressing deep neural networks on FPGAs to binary and ternary precision with HLS4ML}", + eprint = "2003.06308", + archivePrefix = "arXiv", + primaryClass = "cs.LG", + reportNumber = "FERMILAB-PUB-20-167-PPD-SCD", + doi = "10.1088/2632-2153/aba042", + journal = "Mach. Learn. Sci. Tech.", + volume = "2", + pages = "015001", + year = "2021" +} +``` -A demo of the SNN functionality is in: +# Acknowledgments +If you benefited from participating in our community, we ask that you please acknowledge the Fast Machine Learning collaboration, and particular individuals who helped you, in any publications. +Please use the following text for this acknowledgment: + > We acknowledge the Fast Machine Learning collective as an open community of multi-domain experts and collaborators. This community and \, in particular, were important for the development of this project. -- [hls4ml-snn-example.ipynb](hls4ml-snn-example.ipynb) -- [snn-hls4ml-demo.ipynb](snn-hls4ml-demo.ipynb) +# Funding +We gratefully acknowledge previous and current support from the U.S. National Science Foundation (NSF) Harnessing the Data Revolution (HDR) Institute for Accelerating AI Algorithms for Data Driven Discovery (A3D3) under Cooperative Agreement No. PHY-2117997, U.S. Department of Energy (DOE) Office of Science, Office of Advanced Scientific Computing Research under the Real‐time Data Reduction Codesign at the Extreme Edge for Science (XDR) Project (DE-FOA-0002501), DOE Office of Science, Office of High Energy Physics Early Career Research Program (DE-SC0021187, DE-0000247070), the European Research Council (ERC) under the European Union's Horizon 2020 research and innovation program (Grant No. 772369 and 966696), and the Eric & Wendy Schmidt Fund for Strategic Innovation through the CERN Next Generation Triggers project under grant agreement number SIF-2023-004. -These take you from building and training a simple SNN in snntorch, to running it through hls4ml and getting Vitis reports. The longer demo also includes optional NeuroBench metrics. +

+A3D3 +NSF +DOE +ERC +NGT +

diff --git a/docs/advanced/snn.rst b/docs/advanced/snn.rst index 2a21ce71b2..016b60915e 100644 --- a/docs/advanced/snn.rst +++ b/docs/advanced/snn.rst @@ -4,6 +4,12 @@ Spiking Neural Networks (PyTorch/SNN) This page describes the initial SNN support in the PyTorch frontend. +Install the SNN frontend dependencies with: + +.. code-block:: bash + + pip install hls4ml[snn] + Execution model =============== diff --git a/hls4ml-snn-example.ipynb b/hls4ml-snn-example.ipynb new file mode 100644 index 0000000000..b4dcb8e339 --- /dev/null +++ b/hls4ml-snn-example.ipynb @@ -0,0 +1,2241 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f5d68c3f-6575-4637-b645-9d493d7b7413", + "metadata": {}, + "source": [ + "# SNN example in hls4ml" + ] + }, + { + "cell_type": "markdown", + "id": "476e7c77-f50e-438f-b487-d2ff112f8dc3", + "metadata": {}, + "source": [ + "## imports\n", + "\n", + "Before launching Jupyter, source your Xilinx tools, for example:\n", + "\n", + "```bash\n", + "source /tools/Xilinx/Vitis/2024.1/settings64.sh\n", + "source /tools/Xilinx/Vivado/2024.1/settings64.sh\n", + "```\n", + "\n", + "From the hls4snn repository root, an editable install usually looks like:\n", + "\n", + "```bash\n", + "pip install -e .\n", + "pip install -r requirements-snn-dev.txt\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "44c4d46b-ea90-443a-86a7-7432c543f0e3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/b/Physics/hls4ml/hls4ml/__init__.py\n" + ] + } + ], + "source": [ + "import copy\n", + "import json\n", + "import time\n", + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from torch.utils.data import TensorDataset, DataLoader\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import snntorch as snn\n", + "\n", + "import hls4ml\n", + "import hls4ml.utils.torch\n", + "from hls4ml.utils.snntorch import SNNReadout\n", + "print(hls4ml.__file__)\n", + "\n", + "try:\n", + " import neurobench\n", + " from neurobench.models import SNNTorchModel\n", + " from neurobench.benchmarks import Benchmark\n", + " from neurobench.metrics.static import Footprint, ConnectionSparsity\n", + " from neurobench.metrics.workload import ClassificationAccuracy, ActivationSparsity, SynapticOperations\n", + " HAS_NEUROBENCH = True\n", + "except Exception as err:\n", + " HAS_NEUROBENCH = False\n", + " print(f\"[NeuroBench] import skipped: {err}\")\n", + "\n", + "\n", + "def set_seed(seed: int = 0):\n", + " np.random.seed(seed)\n", + " torch.manual_seed(seed)\n", + " if torch.cuda.is_available():\n", + " torch.cuda.manual_seed_all(seed)\n", + "\n", + "set_seed(0)" + ] + }, + { + "cell_type": "markdown", + "id": "41ad7003-cf72-4f83-a04a-8c896fa11bca", + "metadata": {}, + "source": [ + "## settings" + ] + }, + { + "cell_type": "markdown", + "id": "139af64d-0b2b-4011-aa59-3bb6118d007a", + "metadata": {}, + "source": [ + "I want a binary classifier that uses the membrane potentials on the final layer to perform classification." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "11eb25a1-3b43-43f2-8cc5-dfb12968fae4", + "metadata": {}, + "outputs": [], + "source": [ + "set_seed(0)\n", + "\n", + "output_dir = Path(\"examples/snn_example\")\n", + "backend = \"Vitis\"\n", + "part = \"xczu7ev-ffvc1156-2-e\"\n", + "clock_period = 5\n", + "clock_uncertainty = \"18%\"\n", + "\n", + "# general SNN precision\n", + "precision = \"ap_fixed<8,4>\"\n", + "\n", + "# output mode\n", + "output_mode = \"membrane\"\n", + "decision_rule = \"argmax_membrane\"\n", + "\n", + "# precision for spike readouts\n", + "readout_result_precision = \"ap_int<8>\"\n", + "\n", + "# precision for membrane readouts\n", + "readout_membrane_precision = \"ap_fixed<16,7>\"\n", + "readout_membrane_beta = 1.0\n", + "\n", + "timesteps = 50\n", + "n_trn = 2000\n", + "n_val = 300\n", + "n_tst = 300\n", + "batch_size = 64\n", + "n_epochs = 50\n", + "n_qat_epochs = 8\n", + "lr = 1e-3\n", + "qat_frac_bits = 7\n", + "\n", + "hidden = 8\n", + "hidden_beta = 0.75\n", + "hidden_threshold = 1.0\n", + "if output_mode == \"membrane\":\n", + " out_threshold = 1000.0\n", + "else:\n", + " out_threshold = 0.5\n", + "#class_threshold = 5 # only needed for threshold decisions\n", + "\n", + "READOUT_CONFIGS = [\n", + " # {\"name\": \"argmax_spike_count\", \"output_mode\": \"spike\", \"decision_rule\": \"argmax_spike_count\"},\n", + " # {\"name\": \"first_to_threshold\", \"output_mode\": \"spike\", \"decision_rule\": \"first_to_threshold\"},\n", + " # {\"name\": \"threshold_then_argmax\", \"output_mode\": \"spike\", \"decision_rule\": \"threshold_then_argmax\"},\n", + " # {\"name\": \"binary_logit\", \"output_mode\": \"spike\", \"decision_rule\": \"binary_logit\"},\n", + " {\"name\": \"argmax_membrane\", \"output_mode\": \"membrane\", \"decision_rule\": \"argmax_membrane\"},\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "81f2c60d-dfb8-4cc3-ba77-e7a42653ba84", + "metadata": {}, + "source": [ + "## data for the binary classification" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c90472d1-b6a5-4d1a-9b6a-c290b7b03216", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2000, 50, 2) (2000,)\n" + ] + } + ], + "source": [ + "def make_toy_dataset(n_samples: int, timesteps: int = 50, noise_std: float = 0.80, amp_jitter: float = 0.55):\n", + " t = np.linspace(0.0, 1.0, timesteps, endpoint=False, dtype=np.float32)\n", + " x = np.zeros((n_samples, timesteps, 2), dtype=np.float32)\n", + " y = np.random.randint(0, 2, size=(n_samples,), dtype=np.int64)\n", + "\n", + " early = np.exp(-0.5 * ((t - 0.33) / 0.16) ** 2).astype(np.float32)\n", + " late = np.exp(-0.5 * ((t - 0.67) / 0.16) ** 2).astype(np.float32)\n", + "\n", + " for i, label in enumerate(y):\n", + " amp = 1.0 + np.random.uniform(-amp_jitter, amp_jitter)\n", + " wave = 0.35 * np.sin(2 * np.pi * t).astype(np.float32)\n", + " mix = np.random.uniform(-0.25, 0.25)\n", + "\n", + " if label == 0:\n", + " ch0 = amp * ((0.95 + mix) * early - 0.70 * late + wave)\n", + " ch1 = amp * (-0.55 * early + (0.25 - mix) * late - 0.40 * wave)\n", + " else:\n", + " ch0 = amp * (-0.55 * early + (0.25 + mix) * late + 0.40 * wave)\n", + " ch1 = amp * ((0.95 - mix) * late - 0.70 * early - wave)\n", + "\n", + " x[i, :, 0] = ch0 + np.random.normal(0.0, noise_std, size=timesteps)\n", + " x[i, :, 1] = ch1 + np.random.normal(0.0, noise_std, size=timesteps)\n", + "\n", + " x = np.clip(x, -2.0, 2.0).astype(np.float32)\n", + " return x, y\n", + "\n", + "\n", + "x_trn, y_trn = make_toy_dataset(n_trn, timesteps)\n", + "x_val, y_val = make_toy_dataset(n_val, timesteps)\n", + "x_tst, y_tst = make_toy_dataset(n_tst, timesteps)\n", + "\n", + "tx_trn = torch.from_numpy(x_trn).float()\n", + "ty_trn = torch.from_numpy(y_trn).long()\n", + "tx_val = torch.from_numpy(x_val).float()\n", + "ty_val = torch.from_numpy(y_val).long()\n", + "tx_tst = torch.from_numpy(x_tst).float()\n", + "ty_tst = torch.from_numpy(y_tst).long()\n", + "\n", + "print(x_trn.shape, y_trn.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c7d9445f-4624-4020-af38-d91fd06b46c7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.rcParams.update({\n", + " \"font.family\": \"serif\",\n", + " \"font.serif\": [\"Computer Modern Roman\", \"CMU Serif\", \"DejaVu Serif\"],\n", + " \"mathtext.fontset\": \"cm\",\n", + " \"axes.unicode_minus\": False,\n", + " \"font.size\": 12,\n", + "})\n", + "\n", + "fig, axes = plt.subplots(2, 1, figsize=(10, 7), sharex=True)\n", + "t = np.arange(timesteps)\n", + "for ch, ax in enumerate(axes):\n", + " for seq in x_trn[y_trn == 0][:50]:\n", + " ax.plot(t, seq[:, ch], alpha=0.10, linewidth=1.0)\n", + " for seq in x_trn[y_trn == 1][:50]:\n", + " ax.plot(t, seq[:, ch], alpha=0.10, linewidth=1.0)\n", + " ax.plot(t, x_trn[y_trn == 0, :, ch].mean(axis=0), linewidth=2.5, label=\"class 0 mean\")\n", + " ax.plot(t, x_trn[y_trn == 1, :, ch].mean(axis=0), linewidth=2.5, label=\"class 1 mean\")\n", + " ax.set_ylabel(f\"channel {ch}\")\n", + " ax.grid(alpha=0.20)\n", + " ax.legend(loc=\"best\")\n", + "axes[-1].set_xlabel(\"timestep\")\n", + "fig.suptitle(\"Toy temporal streams\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "58ebd22b-66ca-4266-bba6-e955e805e5cd", + "metadata": {}, + "source": [ + "## define SNN" + ] + }, + { + "cell_type": "markdown", + "id": "2a71e36b-5ef4-410b-a470-d9315bad9a5b", + "metadata": {}, + "source": [ + "The output of the SNN should use `SNNReadout`. SNNs are time-series, and the `SNNReadout` module takes care of the decision after the signal has finished." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9971c671-371d-4897-b017-769008330d08", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ReadoutSNN(\n", + " (fc1): Linear(in_features=2, out_features=8, bias=True)\n", + " (if1): Leaky()\n", + " (fc2): Linear(in_features=8, out_features=2, bias=True)\n", + " (readout): SNNReadout()\n", + ")" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class ReadoutSNN(nn.Module):\n", + " def __init__(self, decision_rule=\"argmax_membrane\", output_mode=\"membrane\", readout_beta=1.0):\n", + " super().__init__()\n", + "\n", + " # linear layer input\n", + " self.fc1 = nn.Linear(2, hidden)\n", + "\n", + " # spiking neuron\n", + " self.if1 = snn.Leaky(\n", + " beta=hidden_beta,\n", + " threshold=hidden_threshold,\n", + " learn_beta=True,\n", + " reset_mechanism=\"subtract\",\n", + " )\n", + "\n", + " # linear layer\n", + " self.fc2 = nn.Linear(hidden, 2)\n", + "\n", + " # final spiking neuron if we use spike outputs, no neuron needed if we use membrane outputs\n", + " if output_mode != \"membrane\":\n", + " self.if2 = snn.Leaky(\n", + " beta=1.0,\n", + " threshold=out_threshold,\n", + " learn_beta=False,\n", + " reset_mechanism=\"subtract\",\n", + " )\n", + "\n", + " # readout layer\n", + " self.readout = SNNReadout(\n", + " n_classes=2,\n", + " window_size=timesteps,\n", + " decision_rule=decision_rule,\n", + " #class_threshold=class_threshold,\n", + " output_mode=output_mode,\n", + " beta=readout_beta,\n", + " )\n", + "\n", + " def forward(self, x_t):\n", + " # linear\n", + " x_t = self.fc1(x_t)\n", + " # spike\n", + " spk1, _ = self.if1(x_t)\n", + " # linear\n", + " x_t = self.fc2(spk1)\n", + " # straight to readout if using membrane outputs\n", + " if self.readout.output_mode == \"membrane\":\n", + " # readout\n", + " return self.readout(x_t)\n", + " # convert to spikes with spiking neuron\n", + " spk2, _ = self.if2(x_t)\n", + " # readout\n", + " return self.readout(spk2)\n", + "\n", + "\n", + "model = ReadoutSNN(decision_rule=decision_rule, output_mode=output_mode)\n", + "model" + ] + }, + { + "cell_type": "markdown", + "id": "ea51d3ff-1416-44e5-ac7b-841f8c62233f", + "metadata": {}, + "source": [ + "## helper functions" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e5800d40-19ee-42b1-a799-f0e667c5d876", + "metadata": {}, + "outputs": [], + "source": [ + "# reset snn state\n", + "def reset_snn_state(net):\n", + " for module in net.modules():\n", + " if hasattr(module, \"reset_hidden\"):\n", + " module.reset_hidden()\n", + " elif hasattr(module, \"reset_mem\"):\n", + " module.reset_mem()\n", + "\n", + "# straight-through estimator for qat\n", + "def fake_quant_ste(x, frac_bits=4):\n", + " scale = float(2**frac_bits)\n", + " q = torch.round(x * scale) / scale\n", + " return x + (q - x).detach()\n", + "\n", + "# runs series data through the snn\n", + "# uses the ste if we are running qat\n", + "def run_sequence(net, x_seq, qat=False, frac_bits=4):\n", + " reset_snn_state(net)\n", + " outs = []\n", + " for step in range(x_seq.shape[1]):\n", + " x_t = x_seq[:, step, :]\n", + " if qat:\n", + " x_t = fake_quant_ste(x_t, frac_bits)\n", + " outs.append(net(x_t))\n", + " return torch.stack(outs, dim=1) # [batch, timesteps, classes]\n", + "\n", + "\n", + "# this implements the readout as it is done in hls4snn\n", + "def reduce_readout_reference(outs, output_mode=\"membrane\", decision_rule=\"argmax_membrane\", beta=1.0):\n", + " if output_mode == \"membrane\":\n", + " mem = torch.zeros_like(outs[:, 0, :])\n", + " for step in range(outs.shape[1]):\n", + " mem = beta * mem + outs[:, step, :]\n", + " return mem\n", + " return outs.sum(dim=1)\n", + "\n", + "# predict output for accuracy metric\n", + "def predict_from_readout_values(values, decision_rule=\"argmax_membrane\"):\n", + " if decision_rule == \"binary_logit\":\n", + " return (values[:, 1] - values[:, 0] > 0).long()\n", + " return values.argmax(dim=1).long()" + ] + }, + { + "cell_type": "markdown", + "id": "fd0298f5-0ee6-4349-bb15-e6eab4c08888", + "metadata": {}, + "source": [ + "## snn model training" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "35fb49c1-a5b5-43a4-95c5-5137261624d7", + "metadata": {}, + "outputs": [], + "source": [ + "# optimizer\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n", + "\n", + "# simple scheduler\n", + "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(\n", + " optimizer,\n", + " T_max=n_epochs + n_qat_epochs,\n", + " eta_min=1e-4,\n", + ")\n", + "\n", + "# ce loss\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "\n", + "# data loader for trn data\n", + "trn_loader = DataLoader(TensorDataset(tx_trn, ty_trn), batch_size=batch_size, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4a92de91-5f38-452c-98a5-d82a74b5c829", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[FP epoch 001] train_acc=0.650 val_acc=0.637\n", + "[FP epoch 005] train_acc=0.930 val_acc=0.910\n", + "[FP epoch 010] train_acc=0.982 val_acc=0.970\n", + "[FP epoch 015] train_acc=0.986 val_acc=0.977\n", + "[FP epoch 020] train_acc=0.992 val_acc=0.977\n", + "[FP epoch 025] train_acc=0.992 val_acc=0.977\n", + "[FP epoch 030] train_acc=0.992 val_acc=0.973\n", + "[FP epoch 035] train_acc=0.996 val_acc=0.973\n", + "[FP epoch 040] train_acc=0.992 val_acc=0.983\n", + "[FP epoch 045] train_acc=0.990 val_acc=0.980\n", + "[FP epoch 050] train_acc=0.990 val_acc=0.987\n", + "[QAT epoch 055] train_acc=0.992 val_acc=0.987\n" + ] + } + ], + "source": [ + "# we loop through regular + qat-aware epochs\n", + "for epoch in range(n_epochs + n_qat_epochs):\n", + " \n", + " model.train()\n", + "\n", + " # qat flag\n", + " use_qat = epoch >= n_epochs\n", + "\n", + " # loop through batches\n", + " for xb, yb in trn_loader:\n", + " # zero the grads\n", + " optimizer.zero_grad()\n", + " # run series data through the snn\n", + " outs = run_sequence(model, xb, qat=use_qat, frac_bits=qat_frac_bits)\n", + " # convert to readout\n", + " logits = reduce_readout_reference(\n", + " outs,\n", + " output_mode=model.readout.output_mode,\n", + " decision_rule=model.readout.decision_rule,\n", + " beta=float(model.readout.beta),\n", + " )\n", + " # compute loss\n", + " loss = loss_fn(logits, yb)\n", + "\n", + " # mild regularization keeps the learned beta small and quantization-friendly.\n", + " if hasattr(model.if1, \"beta\"):\n", + " loss = loss + 1e-3 * torch.mean(model.if1.beta**2)\n", + "\n", + " # compute and update weights\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " # schedule lr\n", + " scheduler.step()\n", + "\n", + " # quantize learned beta after each qat epoch\n", + " if use_qat and hasattr(model.if1, \"beta\"):\n", + " scale = float(2**qat_frac_bits)\n", + " with torch.no_grad():\n", + " model.if1.beta.data = torch.round(model.if1.beta.data * scale) / scale\n", + "\n", + " # output stats\n", + " if epoch == 0 or (epoch + 1) % 5 == 0:\n", + " model.eval()\n", + " with torch.no_grad():\n", + " trn_values = reduce_readout_reference(\n", + " run_sequence(model, tx_trn[:512]),\n", + " output_mode=model.readout.output_mode,\n", + " decision_rule=model.readout.decision_rule,\n", + " beta=float(model.readout.beta),\n", + " )\n", + " val_values = reduce_readout_reference(\n", + " run_sequence(model, tx_val),\n", + " output_mode=model.readout.output_mode,\n", + " decision_rule=model.readout.decision_rule,\n", + " beta=float(model.readout.beta),\n", + " )\n", + " trn_pred = predict_from_readout_values(trn_values, model.readout.decision_rule)\n", + " val_pred = predict_from_readout_values(val_values, model.readout.decision_rule)\n", + " trn_acc = (trn_pred == ty_trn[:512]).float().mean().item()\n", + " val_acc = (val_pred == ty_val).float().mean().item()\n", + " phase = \"QAT\" if use_qat else \"FP\"\n", + " print(f\"[{phase} epoch {epoch + 1:03d}] train_acc={trn_acc:.3f} val_acc={val_acc:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1d1f2125-c46c-4f45-8a33-4f27ddbcb796", + "metadata": {}, + "source": [ + "Now run on the test data." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "76962506-ff80-4f8f-9619-20b9b6d59db4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Torch membrane/argmax_membrane test accuracy = 0.9767\n" + ] + } + ], + "source": [ + "model.eval()\n", + "with torch.no_grad():\n", + " tst_values = reduce_readout_reference(\n", + " run_sequence(model, tx_tst),\n", + " output_mode=model.readout.output_mode,\n", + " decision_rule=model.readout.decision_rule,\n", + " beta=float(model.readout.beta),\n", + " )\n", + " tst_pred = predict_from_readout_values(tst_values, model.readout.decision_rule)\n", + " tst_acc = (tst_pred == ty_tst).float().mean().item()\n", + "\n", + "print(f\"Torch {model.readout.output_mode}/{model.readout.decision_rule} test accuracy = {tst_acc:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "4af6070b-543c-4ec7-ad86-93325facb9c7", + "metadata": {}, + "source": [ + "## hls config\n", + "\n", + "Here we generate the config file for the HLS conversion.\n", + "\n", + "Note: During PyTorch conversion, the fixed `readout.window_size` is propagated to every converted IF/LIF neuron. The generated C++ uses that value as the fixed sequence boundary for state reset." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "bba36928-7cdf-4dc8-9d2a-ce7e0986f4d0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"Precision\": {\n", + " \"default\": \"ap_fixed<8,4>\"\n", + " },\n", + " \"ReuseFactor\": 1,\n", + " \"ChannelsLastConversion\": \"full\",\n", + " \"TransposeOutputs\": false,\n", + " \"Strategy\": \"Latency\",\n", + " \"BramFactor\": 1000000000,\n", + " \"TraceOutput\": false\n", + "}\n", + "\n", + "Layer entries:\n", + " x_t : ['Precision', 'Trace']\n", + " fc1 : ['Precision', 'ReuseFactor', 'Trace']\n", + " if1 : ['Precision', 'Trace', 'beta_t', 'membrane_t', 'threshold_t']\n", + " fc2 : ['Precision', 'ReuseFactor', 'Trace']\n", + " readout : ['Precision', 'StateResetPolicy', 'Trace', 'membrane_t']\n" + ] + } + ], + "source": [ + "def make_hls_config(step_model):\n", + "\n", + " cfg = hls4ml.utils.config_from_pytorch_model(\n", + " step_model,\n", + " input_shape=(2,),\n", + " granularity=\"name\",\n", + " backend=backend,\n", + " default_precision=precision,\n", + " )\n", + "\n", + " cfg[\"Model\"][\"ReuseFactor\"] = 1\n", + " cfg[\"Model\"].setdefault(\"Precision\", {})[\"default\"] = precision\n", + "\n", + " for layer_name, layer_cfg in cfg.get(\"LayerName\", {}).items():\n", + " layer_precision = layer_cfg.setdefault(\"Precision\", {})\n", + "\n", + " for key in (\"result\", \"accum\", \"weight\", \"bias\"):\n", + " layer_precision[key] = precision\n", + "\n", + " if layer_name in {\"if1\", \"if2\"}:\n", + " for key in (\"beta\", \"threshold\", \"membrane\"):\n", + " layer_precision[key] = precision\n", + " layer_cfg[\"beta_t\"] = precision\n", + " layer_cfg[\"threshold_t\"] = precision\n", + " layer_cfg[\"membrane_t\"] = precision\n", + "\n", + " if layer_name == \"readout\":\n", + " layer_precision[\"result\"] = readout_result_precision\n", + " layer_precision[\"membrane\"] = readout_membrane_precision\n", + " layer_cfg[\"membrane_t\"] = readout_membrane_precision\n", + "\n", + " return cfg\n", + "\n", + "\n", + "hls_config = make_hls_config(model)\n", + "\n", + "print(json.dumps(hls_config[\"Model\"], indent=2, default=str))\n", + "print(\"\\nLayer entries:\")\n", + "for name, cfg in hls_config.get(\"LayerName\", {}).items():\n", + " print(f\" {name:10s}: {sorted(cfg.keys())}\")" + ] + }, + { + "cell_type": "markdown", + "id": "96a444fe-62b1-4cb3-87f5-ca417d198f0f", + "metadata": {}, + "source": [ + "## convert to hls" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4caec5ac-49fb-4617-a1bb-57f100e0bd3b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Interpreting Model ...\n", + "Topology:\n", + "Layer name: fc1, layer type: Dense, input shape: [[None, 2]]\n", + "Layer name: if1, layer type: LIFNeuron, input shape: [[None, 8]]\n", + "Layer name: fc2, layer type: Dense, input shape: [[None, 8]]\n", + "Layer name: readout, layer type: SNNReadout, input shape: [[None, 2]]\n" + ] + } + ], + "source": [ + "output_dir = Path('examples/snn_example')\n", + "proj_name = 'test'\n", + "hls_dir = output_dir / proj_name\n", + "hls_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + "hls_model = hls4ml.converters.convert_from_pytorch_model(\n", + " model,\n", + " output_dir=str(hls_dir),\n", + " project_name=proj_name,\n", + " backend=backend,\n", + " io_type=\"io_stream\",\n", + " hls_config=hls_config,\n", + " part=part,\n", + " clock_period=clock_period,\n", + " clock_uncertainty=clock_uncertainty,\n", + ")\n", + "hls_model.write()" + ] + }, + { + "cell_type": "markdown", + "id": "42d3bfc3-5ca2-483e-85ec-4142468e0590", + "metadata": {}, + "source": [ + "## get hls benchmark\n", + "\n", + "Compile immediately before evaluating full sequences. The compiled SNN state persists between calls, and the fixed-window reset occurs after exactly `timesteps` calls. If HLS accuracy is much lower than the PyTorch reference, first check that the generated `parameters.h` contains `window_size` in the IF/LIF config and that the fixed-point precision is not too narrow." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "20871206-0418-4a71-b4c2-0959d0c0544b", + "metadata": {}, + "outputs": [], + "source": [ + "def _as_scalar(y_step):\n", + " if isinstance(y_step, tuple):\n", + " y_step = y_step[0]\n", + " if isinstance(y_step, dict):\n", + " y_step = y_step[next(iter(y_step.keys()))]\n", + " return float(np.asarray(y_step).reshape(-1)[0])\n", + "\n", + "\n", + "def assert_fixed_window_reset_was_generated(hls_dir, window_size):\n", + " parameters_h = hls_dir / \"firmware\" / \"parameters.h\"\n", + " text = parameters_h.read_text()\n", + " expected = f\"static const unsigned window_size = {window_size};\"\n", + " if expected not in text:\n", + " raise RuntimeError(\n", + " f\"{parameters_h} does not contain {expected!r}. Re-run the conversion/write cell before compiling.\"\n", + " )\n", + "\n", + "\n", + "def predict_hls_sequences(hls_model, x_seq, timesteps):\n", + " \"\"\"Run one fixed-window sequence at a time through the stateful HLS model.\"\"\"\n", + " values = []\n", + " for sample in range(x_seq.shape[0]):\n", + " last = None\n", + " for step in range(timesteps):\n", + " x_step = x_seq[sample, step, :].astype(np.float32)[None, :]\n", + " last = _as_scalar(hls_model.predict(x_step))\n", + " values.append(last)\n", + " return np.asarray(values, dtype=np.float32)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9b077b56-470b-4cb2-ab58-be960ed7cda2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy: 0.95\n", + "throughput_samples_per_s: 635.6201574354578\n" + ] + } + ], + "source": [ + "#assert_fixed_window_reset_was_generated(hls_dir, timesteps)\n", + "\n", + "# Compile immediately before sequence evaluation. Avoid making stray single-timestep\n", + "# predict calls before this loop; the compiled SNN state is persistent between calls.\n", + "hls_model.compile()\n", + "t0 = time.perf_counter()\n", + "raw = predict_hls_sequences(hls_model, x_tst, timesteps)\n", + "\n", + "if model.readout.decision_rule == \"binary_logit\":\n", + " preds = (raw > 0).astype(np.int64)\n", + "else:\n", + " preds = np.rint(raw).astype(np.int64)\n", + "\n", + "elapsed = time.perf_counter() - t0\n", + "print(\"accuracy: \", float(np.mean(preds == y_tst)))\n", + "print(\"throughput_samples_per_s: \", float(x_tst.shape[0] / elapsed) if elapsed > 0 else 0.0)" + ] + }, + { + "cell_type": "markdown", + "id": "c4998d68-1c5c-4ca0-9dd0-d503fafa0976", + "metadata": {}, + "source": [ + "## neurobench" + ] + }, + { + "cell_type": "markdown", + "id": "26de1bc7-c257-448d-945d-2026085299cd", + "metadata": {}, + "source": [ + "The model defined as it is here, is also compatiable with neurobench. We just need some helper functions." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "70c8d03e-29ea-434e-80dc-60715d5e5188", + "metadata": {}, + "outputs": [], + "source": [ + "class NeuroBenchStepAdapter(nn.Module):\n", + " def __init__(self, step_model):\n", + " super().__init__()\n", + " self.step_model = step_model\n", + "\n", + " def forward(self, x_t):\n", + " y = self.step_model(x_t)\n", + " if isinstance(y, tuple):\n", + " return y\n", + " return y, None\n", + "\n", + " def reset(self):\n", + " reset_snn_state(self.step_model)\n", + "\n", + "\n", + "class NeuroBenchReadoutPostprocessor:\n", + " def __init__(self, decision_rule=\"argmax_spike_count\", class_threshold=5):\n", + " self.decision_rule = decision_rule\n", + " self.class_threshold = class_threshold\n", + "\n", + " def __call__(self, preds):\n", + " if isinstance(preds, tuple):\n", + " preds = preds[0]\n", + " if isinstance(preds, np.ndarray):\n", + " preds = torch.from_numpy(preds)\n", + " if not torch.is_tensor(preds):\n", + " preds = torch.as_tensor(preds)\n", + "\n", + " counts = preds.sum(dim=1) if preds.ndim == 3 else preds\n", + "\n", + " if self.decision_rule == \"binary_logit\":\n", + " return (counts[:, 1] - counts[:, 0] > 0).long()\n", + " if self.decision_rule == \"argmax_spike_count\":\n", + " return counts.argmax(dim=1).long()\n", + "\n", + " reached = counts >= self.class_threshold\n", + " has_reached = reached.any(dim=1)\n", + " first_reached = reached.float().argmax(dim=1)\n", + " fallback = counts.argmax(dim=1)\n", + " return torch.where(has_reached, first_reached, fallback).long()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "e051851e-20cd-4ee9-9247-8fffb3a1490f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running benchmark\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [00:00<00:00, 28.99it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"Footprint\": 9788,\n", + " \"ConnectionSparsity\": 0.0,\n", + " \"ClassificationAccuracy\": 0.976666669845581,\n", + " \"ActivationSparsity\": 0.7599916666666667,\n", + " \"SynapticOperations\": {\n", + " \"Effective_MACs\": 800.0,\n", + " \"Effective_ACs\": 192.00666666666666,\n", + " \"Dense\": 1600.0\n", + " }\n", + "}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "if HAS_NEUROBENCH:\n", + " model.eval()\n", + " test_loader = DataLoader(TensorDataset(tx_tst.float(), ty_tst.long()), batch_size=64, shuffle=False)\n", + "\n", + " nb_model = SNNTorchModel(NeuroBenchStepAdapter(model))\n", + " preprocessors = []\n", + " postprocessors = [\n", + " NeuroBenchReadoutPostprocessor(\n", + " decision_rule=model.readout.decision_rule,\n", + " class_threshold=model.readout.class_threshold,\n", + " )\n", + " ]\n", + " static_metrics = [Footprint, ConnectionSparsity]\n", + " workload_metrics = [ClassificationAccuracy, ActivationSparsity, SynapticOperations]\n", + "\n", + " benchmark = Benchmark(\n", + " nb_model,\n", + " test_loader,\n", + " preprocessors,\n", + " postprocessors,\n", + " [static_metrics, workload_metrics],\n", + " )\n", + "\n", + " device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + " results = benchmark.run(device=device)\n", + " print(json.dumps(results, indent=2))\n", + "else:\n", + " print(\"NeuroBench is not installed in this environment.\")" + ] + }, + { + "cell_type": "markdown", + "id": "b26fca09-8566-429a-a21c-a412617adec3", + "metadata": {}, + "source": [ + "## full hls build" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "94374d2d-1636-47dc-9759-f4cca8473aa4", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "****** vitis-run v2024.1 (64-bit)\n", + " **** SW Build 5074859 on 2024-05-20-23:21:20\n", + " **** Start of session at: Tue May 5 17:21:52 2026\n", + " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", + " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", + "\n", + "INFO: [vitis-run 82-31] Launching vitis_hls: vitis_hls -nolog -run tcl -f /home/b/Physics/hls4ml/examples/snn_example/test/build_prj.tcl -work_dir /home/b/Physics/hls4ml/examples/snn_example/test\n", + "\n", + "****** Vitis HLS - High-Level Synthesis from C, C++ and OpenCL v2024.1 (64-bit)\n", + " **** SW Build 5069499 on May 21 2024\n", + " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", + " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", + " **** Start of session at: Tue May 5 17:21:52 2026\n", + " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", + " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", + "\n", + "source /tools/Xilinx/Vitis_HLS/2024.1/scripts/vitis_hls/hls.tcl -notrace\n", + "INFO: [HLS 200-10] For user 'b' on host 'b-comp' (Linux_x86_64 version 6.12.64-1-MANJARO) on Tue May 05 17:21:54 IST 2026\n", + "INFO: [HLS 200-10] On os \"Manjaro Linux\"\n", + "INFO: [HLS 200-10] In directory '/home/b/Physics/hls4ml/examples/snn_example/test'\n", + "Sourcing Tcl script '/home/b/Physics/hls4ml/examples/snn_example/test/build_prj.tcl'\n", + "INFO: [HLS 200-1510] Running: open_project -reset test_prj \n", + "INFO: [HLS 200-10] Opening and resetting project '/home/b/Physics/hls4ml/examples/snn_example/test/test_prj'.\n", + "INFO: [HLS 200-1510] Running: set_top test \n", + "INFO: [HLS 200-1510] Running: add_files firmware/test.cpp -cflags -std=c++0x \n", + "INFO: [HLS 200-10] Adding design file 'firmware/test.cpp' to the project\n", + "INFO: [HLS 200-1510] Running: add_files -tb test_test.cpp -cflags -std=c++0x \n", + "INFO: [HLS 200-10] Adding test bench file 'test_test.cpp' to the project\n", + "INFO: [HLS 200-1510] Running: add_files -tb firmware/weights \n", + "INFO: [HLS 200-10] Adding test bench file 'firmware/weights' to the project\n", + "INFO: [HLS 200-1510] Running: add_files -tb tb_data \n", + "INFO: [HLS 200-10] Adding test bench file 'tb_data' to the project\n", + "INFO: [HLS 200-1510] Running: open_solution -reset solution1 \n", + "INFO: [HLS 200-10] Creating and opening solution '/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1'.\n", + "INFO: [HLS 200-10] Cleaning up the solution database.\n", + "INFO: [HLS 200-1505] Using default flow_target 'vivado'\n", + "Resolution: For help on HLS 200-1505 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=200-1505.html\n", + "INFO: [HLS 200-1510] Running: config_array_partition -maximum_size 4096 \n", + "ERROR: [HLS 200-101] config_array_partition: Unknown option '-maximum_size'.\n", + "ERROR: [HLS 200-101] config_array_partition: Unknown option '4096'.\n", + "SYNTAX \n", + " config_array_partition [OPTIONS]\n", + " -auto_partition_threshold *** DEPRECATED***\n", + " -auto_promotion_threshold *** DEPRECATED***\n", + " -complete_threshold \n", + " -throughput_driven \n", + "\n", + "SEE ALSO\n", + " INI: syn.array_partition.complete_threshold syn.array_partition.throughput_driven\n", + " docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1399-vitis-hls&resourceid=vyw1583260160301.html\n", + "\n", + "INFO: [HLS 200-1510] Running: config_compile -name_max_length 80 \n", + "INFO: [XFORM 203-1161] The maximum of name length is set to 80.\n", + "INFO: [HLS 200-1510] Running: set_part xczu7ev-ffvc1156-2-e \n", + "INFO: [HLS 200-1611] Setting target device to 'xczu7ev-ffvc1156-2-e'\n", + "INFO: [XFORM 203-1161] The maximum of name length is set to 80.\n", + "INFO: [HLS 200-1510] Running: config_schedule -enable_dsp_full_reg=false \n", + "INFO: [HLS 200-1510] Running: create_clock -period 5 -name default \n", + "INFO: [SYN 201-201] Setting up clock 'default' with a period of 5ns.\n", + "INFO: [HLS 200-1510] Running: set_clock_uncertainty 18% default \n", + "INFO: [SYN 201-201] Setting up clock 'default' with an uncertainty of 0.9ns.\n", + "***** C SIMULATION *****\n", + "INFO: [HLS 200-1510] Running: csim_design \n", + "INFO: [SIM 211-2] *************** CSIM start ***************\n", + "INFO: [SIM 211-4] CSIM will launch CLANG as the compiler.\n", + "INFO: [HLS 200-2036] Building debug C Simulation binaries\n", + " Compiling ../../../../test_test.cpp in debug mode\n", + " Compiling ../../../../firmware/test.cpp in debug mode\n", + " Generating csim.exe\n", + "INFO: Unable to open input/predictions file, using default input.\n", + "0 \n", + "1 \n", + "0 \n", + "0 \n", + "0 \n", + "INFO: Saved inference results to file: tb_data/csim_results.log\n", + "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", + "INFO: [SIM 211-1] CSim done with 0 errors.\n", + "INFO: [SIM 211-3] *************** CSIM finish ***************\n", + "INFO: [HLS 200-2161] Finished Command csim_design Elapsed time: 00:00:04; Allocated memory: 0.031 MB.\n", + "***** C SIMULATION COMPLETED IN 0h0m4s *****\n", + "***** C/RTL SYNTHESIS *****\n", + "INFO: [HLS 200-1510] Running: csynth_design \n", + "INFO: [HLS 200-111] Finished File checks and directory preparation: CPU user time: 0.04 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.05 seconds; current allocated memory: 326.730 MB.\n", + "INFO: [HLS 200-10] Analyzing design file 'firmware/test.cpp' ... \n", + "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:33:9)\n", + "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:107:9)\n", + "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:189:9)\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/test.cpp:41:59)\n", + "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/test.cpp:41:63)\n", + "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/test.cpp:43:75)\n", + "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/test.cpp:43:84)\n", + "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/test.cpp:45:70)\n", + "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", + "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/test.cpp:45:74)\n", + "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", + "WARNING: [HLS 200-471] Dataflow form checks found 6 issue(s) in file firmware/test.cpp\n", + "Resolution: For help on HLS 200-471 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=200-471.html\n", + "WARNING: [HLS 207-5292] unused parameter 'keep' (firmware/nnet_utils/nnet_helpers.h:285:99)\n", + "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:14:36)\n", + "WARNING: [HLS 207-5292] unused parameter 'buffer' (firmware/nnet_utils/nnet_function_stubs.h:15:36)\n", + "WARNING: [HLS 207-5292] unused parameter 'partition' (firmware/nnet_utils/nnet_function_stubs.h:16:44)\n", + "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:24:24)\n", + "WARNING: [HLS 207-5292] unused parameter 'buffer' (firmware/nnet_utils/nnet_function_stubs.h:25:24)\n", + "WARNING: [HLS 207-5292] unused parameter 'partition' (firmware/nnet_utils/nnet_function_stubs.h:26:32)\n", + "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:33:30)\n", + "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_function_stubs.h:33:58)\n", + "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_function_stubs.h:34:51)\n", + "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_function_stubs.h:35:49)\n", + "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:42:30)\n", + "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_function_stubs.h:42:58)\n", + "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_function_stubs.h:43:51)\n", + "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_function_stubs.h:44:49)\n", + "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:51:29)\n", + "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_function_stubs.h:51:80)\n", + "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_function_stubs.h:52:50)\n", + "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_function_stubs.h:53:48)\n", + "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_code_gen.h:16:39)\n", + "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_code_gen.h:17:38)\n", + "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_code_gen.h:18:60)\n", + "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_code_gen.h:19:58)\n", + "INFO: [HLS 200-111] Finished Source Code Analysis and Preprocessing: CPU user time: 4.72 seconds. CPU system time: 0.9 seconds. Elapsed time: 5.65 seconds; current allocated memory: 331.730 MB.\n", + "INFO: [HLS 200-777] Using interface defaults for 'Vivado' flow target.\n", + "INFO: [HLS 200-1995] There were 5,130 instructions in the design after the 'Compile/Link' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 3,258 instructions in the design after the 'Unroll/Inline (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,202 instructions in the design after the 'Unroll/Inline (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 1,039 instructions in the design after the 'Unroll/Inline (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 877 instructions in the design after the 'Unroll/Inline (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 427 instructions in the design after the 'Array/Struct (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 403 instructions in the design after the 'Array/Struct (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 409 instructions in the design after the 'Array/Struct (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 640 instructions in the design after the 'Array/Struct (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 637 instructions in the design after the 'Array/Struct (step 5)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 607 instructions in the design after the 'Performance (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 603 instructions in the design after the 'Performance (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 603 instructions in the design after the 'Performance (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 603 instructions in the design after the 'Performance (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 556 instructions in the design after the 'HW Transforms (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 200-1995] There were 545 instructions in the design after the 'HW Transforms (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", + "INFO: [HLS 214-415] Performing recursive inline in function 'nnet::dense, 2u>, nnet::array, 8u>, config2>' (firmware/nnet_utils/nnet_dense_stream.h:85:9)\n", + "WARNING: [HLS 214-273] In function 'void nnet::dense_latency_wrapper, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)', Pragma conflict happens on 'INLINE' and 'PIPELINE' pragmas: same function (firmware/nnet_utils/nnet_dense_stream.h:15:0)\n", + "INFO: [HLS 214-415] Performing recursive inline in function 'nnet::dense, 8u>, nnet::array, 2u>, config4>' (firmware/nnet_utils/nnet_dense_stream.h:85:9)\n", + "WARNING: [HLS 214-273] In function 'void nnet::dense_latency_wrapper, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)', Pragma conflict happens on 'INLINE' and 'PIPELINE' pragmas: same function (firmware/nnet_utils/nnet_dense_stream.h:15:0)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::array, 2u>::operator[](unsigned long) (.3)' into 'void nnet::data_prepare, 2u>, config2>(hls::stream, 2u>, 0>&, nnet::array, 2u>::value_type*) (.10)' (firmware/nnet_utils/nnet_dense_stream.h:47:17)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::product::mult, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0> >::product(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>)' into 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:42:27)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::array, 8u>::operator[](unsigned long) (.5)' into 'void nnet::res_write, 8u>, config2>(nnet::array, 8u>::value_type*, hls::stream, 8u>, 0>&) (.8)' (firmware/nnet_utils/nnet_dense_stream.h:75:2)\n", + "INFO: [HLS 214-131] Inlining function 'void nnet::data_prepare, 2u>, config2>(hls::stream, 2u>, 0>&, nnet::array, 2u>::value_type*) (.10)' into 'void nnet::dense, 2u>, nnet::array, 8u>, config2>(hls::stream, 2u>, 0>&, hls::stream, 8u>, 0>&, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:93:2)\n", + "INFO: [HLS 214-131] Inlining function 'void nnet::res_write, 8u>, config2>(nnet::array, 8u>::value_type*, hls::stream, 8u>, 0>&) (.8)' into 'void nnet::dense, 2u>, nnet::array, 8u>, config2>(hls::stream, 2u>, 0>&, hls::stream, 8u>, 0>&, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:100:5)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::array, 8u>::operator[](unsigned long) (.5)' into 'void nnet::data_prepare, 8u>, config4>(hls::stream, 8u>, 0>&, nnet::array, 8u>::value_type*) (.4)' (firmware/nnet_utils/nnet_dense_stream.h:47:17)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::product::mult, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0> >::product(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>)' into 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:42:27)\n", + "INFO: [HLS 214-131] Inlining function 'nnet::array, 2u>::operator[](unsigned long) (.3)' into 'void nnet::res_write, 2u>, config4>(nnet::array, 2u>::value_type*, hls::stream, 2u>, 0>&) (.1)' (firmware/nnet_utils/nnet_dense_stream.h:75:2)\n", + "INFO: [HLS 214-131] Inlining function 'void nnet::data_prepare, 8u>, config4>(hls::stream, 8u>, 0>&, nnet::array, 8u>::value_type*) (.4)' into 'void nnet::dense, 8u>, nnet::array, 2u>, config4>(hls::stream, 8u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:93:2)\n", + "INFO: [HLS 214-131] Inlining function 'void nnet::res_write, 2u>, config4>(nnet::array, 2u>::value_type*, hls::stream, 2u>, 0>&) (.1)' into 'void nnet::dense, 8u>, nnet::array, 2u>, config4>(hls::stream, 8u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:100:5)\n", + "WARNING: [HLS 214-435] A depth specification is required for AXIS interface port 'layer5_out' for cosimulation. (firmware/test.cpp:10:0)\n", + "INFO: [HLS 214-291] Loop 'VITIS_LOOP_197_3' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_snn_readout.h:197:31)\n", + "INFO: [HLS 214-291] Loop 'VITIS_LOOP_183_2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_snn_readout.h:183:27)\n", + "INFO: [HLS 214-291] Loop 'VITIS_LOOP_170_1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_snn_readout.h:170:27)\n", + "INFO: [HLS 214-291] Loop 'Result' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:64:5)\n", + "INFO: [HLS 214-291] Loop 'Accum1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:54:5)\n", + "INFO: [HLS 214-291] Loop 'Accum2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:56:9)\n", + "INFO: [HLS 214-291] Loop 'ResetAccum' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:48:5)\n", + "INFO: [HLS 214-291] Loop 'Product1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:37:5)\n", + "INFO: [HLS 214-291] Loop 'Product2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:40:9)\n", + "INFO: [HLS 214-291] Loop 'VITIS_LOOP_115_2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_lif_neuron.h:115:31)\n", + "INFO: [HLS 214-291] Loop 'VITIS_LOOP_88_1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_lif_neuron.h:88:22)\n", + "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_197_3' (firmware/nnet_utils/nnet_snn_readout.h:197:31) in function 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>' completely with a factor of 2 (firmware/nnet_utils/nnet_snn_readout.h:157:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_183_2' (firmware/nnet_utils/nnet_snn_readout.h:183:27) in function 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>' completely with a factor of 1 (firmware/nnet_utils/nnet_snn_readout.h:157:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_170_1' (firmware/nnet_utils/nnet_snn_readout.h:170:27) in function 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>' completely with a factor of 2 (firmware/nnet_utils/nnet_snn_readout.h:157:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 8u>, nnet::array, 2u>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 8u>, nnet::array, 2u>, config4>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Accum1' (firmware/nnet_utils/nnet_dense_latency.h:54:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Accum2' (firmware/nnet_utils/nnet_dense_latency.h:56:9) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'ResetAccum' (firmware/nnet_utils/nnet_dense_latency.h:48:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_115_2' (firmware/nnet_utils/nnet_lif_neuron.h:115:31) in function 'nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>' completely with a factor of 8 (firmware/nnet_utils/nnet_lif_neuron.h:77:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_88_1' (firmware/nnet_utils/nnet_lif_neuron.h:88:22) in function 'nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>' completely with a factor of 8 (firmware/nnet_utils/nnet_lif_neuron.h:77:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 2u>, nnet::array, 8u>, config2>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 2u>, nnet::array, 8u>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Accum1' (firmware/nnet_utils/nnet_dense_latency.h:54:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Accum2' (firmware/nnet_utils/nnet_dense_latency.h:56:9) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'ResetAccum' (firmware/nnet_utils/nnet_dense_latency.h:48:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(config2::accum_t)' into 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-178] Inlining function 'nnet::array, 8u>::operator[](unsigned long)' into 'void nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>(hls::stream, 8u>, 0>&, hls::stream, 8u>, 0>&, config3::beta_t const*, config3::threshold_t const*)' (firmware/nnet_utils/nnet_lif_neuron.h:77:0)\n", + "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(config4::accum_t)' into 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", + "INFO: [HLS 214-178] Inlining function 'nnet::array, 2u>::operator[](unsigned long)' into 'void nnet::snn_readout, 2u>, nnet::array, 1u>, config5>(hls::stream, 2u>, 0>&, hls::stream, 1u>, 0>&)' (firmware/nnet_utils/nnet_snn_readout.h:157:0)\n", + "INFO: [HLS 214-178] Inlining function 'nnet::array, 1u>::operator[](unsigned long)' into 'void nnet::snn_readout, 2u>, nnet::array, 1u>, config5>(hls::stream, 2u>, 0>&, hls::stream, 1u>, 0>&)' (firmware/nnet_utils/nnet_snn_readout.h:157:0)\n", + "INFO: [HLS 214-248] Applying array_partition to 'b2': Complete partitioning on dimension 1. (firmware/weights/b2.h:12:0)\n", + "INFO: [HLS 214-248] Applying array_partition to 'b4': Complete partitioning on dimension 1. (firmware/weights/b4.h:12:0)\n", + "INFO: [HLS 214-248] Applying array_partition to '_ZZN4nnet11snn_readoutINS_5arrayI8ap_fixedILi8ELi4EL9ap_q_mode5EL9ap_o_mode3ELi0EELj2EEENS1_I6ap_intILi8EELj1EEE7config5EEvRN3hls6streamIT_Li0EEERNSC_IT0_Li0EEEE3mem': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_snn_readout.h:162:0)\n", + "INFO: [HLS 214-248] Applying array_partition to '_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi8ELi4EL9ap_q_mode5EL9ap_o_mode3ELi0EELj8EEES6_7config3EEvRN3hls6streamIT_Li0EEERNS9_IT0_Li0EEEPKNT1_6beta_tEPKNSG_11threshold_tEE3mem': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_lif_neuron.h:80:0)\n", + "INFO: [HLS 214-248] Applying array_partition to 'data': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_dense_stream.h:87:30)\n", + "INFO: [HLS 214-248] Applying array_partition to 'res': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_dense_stream.h:90:29)\n", + "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer4_out' with compact=bit mode in 16-bits (firmware/test.cpp:38:24)\n", + "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer3_out' with compact=bit mode in 64-bits (firmware/test.cpp:35:24)\n", + "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer2_out' with compact=bit mode in 64-bits (firmware/test.cpp:32:24)\n", + "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", + "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", + "INFO: [HLS 200-111] Finished Compiling Optimization and Transform: CPU user time: 2.49 seconds. CPU system time: 0.5 seconds. Elapsed time: 7.28 seconds; current allocated memory: 341.820 MB.\n", + "INFO: [HLS 200-111] Finished Checking Pragmas: CPU user time: 0 seconds. CPU system time: 0 seconds. Elapsed time: 0 seconds; current allocated memory: 341.820 MB.\n", + "INFO: [HLS 200-10] Starting code transformations ...\n", + "INFO: [HLS 200-111] Finished Standard Transforms: CPU user time: 0.02 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.02 seconds; current allocated memory: 343.133 MB.\n", + "INFO: [HLS 200-10] Checking synthesizability ...\n", + "INFO: [HLS 200-111] Finished Checking Synthesizability: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 345.484 MB.\n", + "INFO: [XFORM 203-712] Applying dataflow to function 'test' (firmware/test.cpp:8), detected/extracted 4 process function(s): \n", + "\t 'nnet::dense, 2u>, nnet::array, 8u>, config2>'\n", + "\t 'nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>'\n", + "\t 'nnet::dense, 8u>, nnet::array, 2u>, config4>'\n", + "\t 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>'.\n", + "INFO: [XFORM 203-11] Balancing expressions in function 'nnet::dense_latency_wrapper, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' (firmware/nnet_utils/nnet_dense_stream.h:18:1)...14 expression(s) balanced.\n", + "INFO: [HLS 200-111] Finished Loop, function and other optimizations: CPU user time: 0.07 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.09 seconds; current allocated memory: 369.344 MB.\n", + "INFO: [HLS 200-111] Finished Architecture Synthesis: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.07 seconds; current allocated memory: 419.223 MB.\n", + "INFO: [HLS 200-10] Starting hardware synthesis ...\n", + "INFO: [HLS 200-10] Synthesizing 'test' ...\n", + "WARNING: [SYN 201-103] Legalizing function name 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config2>' to 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s'.\n", + "WARNING: [SYN 201-103] Legalizing function name 'dense,array,8u>,config2>' to 'dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s'.\n", + "WARNING: [SYN 201-103] Legalizing function name 'lif_neuron,array,8u>,config3>' to 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s'.\n", + "WARNING: [SYN 201-103] Legalizing function name 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config4>' to 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s'.\n", + "WARNING: [SYN 201-103] Legalizing function name 'dense,array,2u>,config4>' to 'dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s'.\n", + "WARNING: [SYN 201-103] Legalizing function name 'snn_readout, 2u>, array, 1u>, config5>' to 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s'.\n", + "WARNING: [SYN 201-223] Checking resource limit in 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config4>': cannot find any operation of 'mul'.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-42] -- Implementing module 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [SCHED 204-11] Starting scheduling ...\n", + "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config2>'.\n", + "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config2>'\n", + "INFO: [SCHED 204-11] Finished scheduling.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.06 seconds. CPU system time: 0.03 seconds. Elapsed time: 0.09 seconds; current allocated memory: 419.223 MB.\n", + "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", + "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", + "INFO: [BIND 205-101] Exploring resource sharing.\n", + "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Starting global binding ...\n", + "INFO: [BIND 205-100] Finished micro-architecture generation.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.03 seconds; current allocated memory: 419.223 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [SCHED 204-11] Starting scheduling ...\n", + "INFO: [SCHED 204-11] Finished scheduling.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 419.992 MB.\n", + "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", + "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", + "INFO: [BIND 205-101] Exploring resource sharing.\n", + "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Finished micro-architecture generation.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 419.992 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-42] -- Implementing module 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [SCHED 204-11] Starting scheduling ...\n", + "INFO: [SCHED 204-61] Pipelining function 'lif_neuron,array,8u>,config3>'.\n", + "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 2, function 'lif_neuron,array,8u>,config3>'\n", + "INFO: [SCHED 204-11] Finished scheduling.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.06 seconds. CPU system time: 0 seconds. Elapsed time: 0.07 seconds; current allocated memory: 420.418 MB.\n", + "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", + "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", + "INFO: [BIND 205-101] Exploring resource sharing.\n", + "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Finished micro-architecture generation.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 420.418 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-42] -- Implementing module 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [SCHED 204-11] Starting scheduling ...\n", + "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config4>'.\n", + "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config4>'\n", + "INFO: [SCHED 204-11] Finished scheduling.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.05 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.06 seconds; current allocated memory: 420.727 MB.\n", + "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", + "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", + "INFO: [BIND 205-101] Exploring resource sharing.\n", + "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Finished micro-architecture generation.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 420.922 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [SCHED 204-11] Starting scheduling ...\n", + "INFO: [SCHED 204-11] Finished scheduling.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.03 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.02 seconds; current allocated memory: 421.859 MB.\n", + "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", + "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", + "INFO: [BIND 205-101] Exploring resource sharing.\n", + "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Finished micro-architecture generation.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 421.859 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-42] -- Implementing module 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [SCHED 204-11] Starting scheduling ...\n", + "INFO: [SCHED 204-61] Pipelining function 'snn_readout, 2u>, array, 1u>, config5>'.\n", + "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 2, function 'snn_readout, 2u>, array, 1u>, config5>'\n", + "INFO: [SCHED 204-11] Finished scheduling.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.03 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.04 seconds; current allocated memory: 422.281 MB.\n", + "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", + "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", + "INFO: [BIND 205-101] Exploring resource sharing.\n", + "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Finished micro-architecture generation.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 422.281 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-42] -- Implementing module 'test' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [SCHED 204-11] Starting scheduling ...\n", + "INFO: [SCHED 204-11] Finished scheduling.\n", + "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer2_out (from dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_U0 to lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0) to 2 to improve performance and/or avoid deadlocks.\n", + "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer3_out (from lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0 to dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0) to 2 to improve performance and/or avoid deadlocks.\n", + "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer4_out (from dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0 to snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0) to 2 to improve performance and/or avoid deadlocks.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 422.516 MB.\n", + "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", + "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", + "INFO: [BIND 205-101] Exploring resource sharing.\n", + "INFO: [BIND 205-101] Binding ...\n", + "INFO: [BIND 205-100] Finished micro-architecture generation.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 422.516 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [RTGEN 206-100] Generating core module 'mul_8s_5s_12_1_1': 1 instance(s).\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 422.594 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.05 seconds; current allocated memory: 424.176 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-10] -- Generating RTL for module 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_7' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_6' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_5' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_4' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_3' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_2' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_1' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'ts_1' is power-on initialization.\n", + "INFO: [HLS 200-1030] Apply Unified Pipeline Control on module 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s' pipeline 'lif_neuron,array,8u>,config3>' pipeline type 'function pipeline'\n", + "INFO: [RTGEN 206-100] Generating core module 'mul_8s_5ns_12_1_1': 8 instance(s).\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0 seconds. Elapsed time: 0.06 seconds; current allocated memory: 425.578 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.07 seconds; current allocated memory: 428.047 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.07 seconds; current allocated memory: 429.996 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-10] -- Generating RTL for module 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "WARNING: [RTGEN 206-101] Register 'void_snn_readout_stream_array_0_stream_array_ap_int_8_1u_0_mem_1' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'void_snn_readout_stream_array_0_stream_array_ap_int_8_1u_0_mem' is power-on initialization.\n", + "WARNING: [RTGEN 206-101] Register 'ts' is power-on initialization.\n", + "INFO: [HLS 200-1030] Apply Unified Pipeline Control on module 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s' pipeline 'snn_readout, 2u>, array, 1u>, config5>' pipeline type 'function pipeline'\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s'.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 430.828 MB.\n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "INFO: [HLS 200-10] -- Generating RTL for module 'test' \n", + "INFO: [HLS 200-10] ----------------------------------------------------------------\n", + "WARNING: [RTGEN 206-101] Design contains AXI ports. Reset is fixed to synchronous and active low.\n", + "INFO: [RTGEN 206-500] Setting interface mode on port 'test/x_t' to 'axis' (register, both mode).\n", + "INFO: [RTGEN 206-500] Setting interface mode on port 'test/layer5_out' to 'axis' (register, both mode).\n", + "INFO: [RTGEN 206-500] Setting interface mode on function 'test' to 'ap_ctrl_hs'.\n", + "INFO: [RTGEN 206-100] Finished creating RTL model for 'test'.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'layer2_out_U(test_fifo_w64_d1_S)' using Shift Registers.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'layer3_out_U(test_fifo_w64_d1_S)' using Shift Registers.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'layer4_out_U(test_fifo_w16_d1_S)' using Shift Registers.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0_U(test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0)' using Shift Registers.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0_U(test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0)' using Shift Registers.\n", + "INFO: [RTMG 210-285] Implementing FIFO 'start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_U(test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0)' using Shift Registers.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.07 seconds; current allocated memory: 431.957 MB.\n", + "INFO: [HLS 200-111] Finished Generating all RTL models: CPU user time: 0.13 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.14 seconds; current allocated memory: 434.414 MB.\n", + "INFO: [HLS 200-111] Finished Updating report files: CPU user time: 0.27 seconds. CPU system time: 0.02 seconds. Elapsed time: 0.29 seconds; current allocated memory: 439.723 MB.\n", + "INFO: [VHDL 208-304] Generating VHDL RTL for test.\n", + "INFO: [VLOG 209-307] Generating Verilog RTL for test.\n", + "INFO: [HLS 200-789] **** Estimated Fmax: 251.00 MHz\n", + "INFO: [HLS 200-2161] Finished Command csynth_design Elapsed time: 00:00:14; Allocated memory: 113.980 MB.\n", + "***** C/RTL SYNTHESIS COMPLETED IN 0h0m14s *****\n", + "***** C/RTL SIMULATION *****\n", + "INFO: [HLS 200-1510] Running: add_files -tb test_test.cpp -cflags -std=c++0x -DRTL_SIM \n", + "INFO: [HLS 200-10] Adding test bench file 'test_test.cpp' to the project\n", + "INFO: [HLS 200-1510] Running: cosim_design -trace_level all -setup \n", + "INFO: [COSIM 212-47] Using XSIM for RTL simulation.\n", + "INFO: [COSIM 212-14] Instrumenting C test bench ...\n", + " Build using \"/tools/Xilinx/Vitis_HLS/2024.1/vcxx/libexec/clang++\"\n", + " Compiling apatb_test.cpp\n", + " Compiling apatb_test_util.cpp\n", + " Compiling test.cpp_pre.cpp.tb.cpp\n", + " Compiling test_test.cpp_pre.cpp.tb.cpp\n", + " Compiling apatb_test_ir.ll\n", + " Generating cosim.tv.exe\n", + "INFO: [COSIM 212-302] Starting C TB testing ... \n", + "INFO: Unable to open input/predictions file, using default input.\n", + "0 \n", + "1 \n", + "0 \n", + "0 \n", + "0 \n", + "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", + "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", + "INFO: [COSIM 212-333] Generating C post check test bench ...\n", + "INFO: [COSIM 212-12] Generating RTL test bench ...\n", + "INFO: [COSIM 212-1] *** C/RTL co-simulation file generation completed. ***\n", + "INFO: [HLS 200-2161] Finished Command cosim_design Elapsed time: 00:00:12; Allocated memory: 11.586 MB.\n", + "INFO: [HLS 200-1510] Running: source /home/b/Physics/hls4ml/examples/snn_example/test/project.tcl\n", + "INFO: [HLS 200-1510] Running: source run_sim.tcl\n", + "INFO: [HLS 200-1510] Running: source check_sim.tcl\n", + "INFO: [HLS 200-1510] Running: source dataflow_monitor_API.tcl\n", + "INFO: [COSIM 212-302] Starting C TB testing ... \n", + "INFO: Unable to open input/predictions file, using default input.\n", + "0 \n", + "1 \n", + "0 \n", + "0 \n", + "0 \n", + "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", + "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", + "INFO: [COSIM 212-323] Starting verilog simulation...\n", + "INFO: [COSIM 212-15] Starting XSIM ...\n", + "Vivado Simulator v2024.1\n", + "Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", + "Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", + "Running: /tools/Xilinx/Vivado/2024.1/bin/unwrapped/lnx64.o/xelab xil_defaultlib.apatb_test_top glbl -Oenable_linking_all_libraries -prj test.prj -L smartconnect_v1_0 -L axi_protocol_checker_v1_1_12 -L axi_protocol_checker_v1_1_13 -L axis_protocol_checker_v1_1_11 -L axis_protocol_checker_v1_1_12 -L xil_defaultlib -L unisims_ver -L xpm -L floating_point_v7_0_23 -L floating_point_v7_1_18 --lib ieee_proposed=./ieee_proposed -s test -debug all \n", + "Multi-threading is on. Using 14 slave threads.\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/glbl.v\" into library work\n", + "INFO: [VRFC 10-311] analyzing module glbl\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test.autotb.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module apatb_test_top\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_fifo.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module fifo\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_axi_s_x_t.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_axi_s_x_t\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_axi_s_layer5_out.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_axi_s_layer5_out\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_deadlock_detection_unit.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_deadlock_detect_unit\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_deadlock_report_unit.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_deadlock_report_unit\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_deadlock_detector.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_deadlock_detector\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_deadlock_kernel_monitor_top.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_deadlock_kernel_monitor_top\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_deadlock_idx0_monitor.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module AESL_deadlock_idx0_monitor\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_mul_8s_5s_12_1_1.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_mul_8s_5s_12_1_1\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_regslice_both.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_regslice_both\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_mul_8s_5ns_12_1_1.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_mul_8s_5ns_12_1_1\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_fifo_w64_d1_S.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_fifo_w64_d1_S\n", + "INFO: [VRFC 10-311] analyzing module test_fifo_w64_d1_S_ShiftReg\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_fifo_w16_d1_S.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_fifo_w16_d1_S\n", + "INFO: [VRFC 10-311] analyzing module test_fifo_w16_d1_S_ShiftReg\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0\n", + "INFO: [VRFC 10-311] analyzing module test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0_ShiftReg\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0\n", + "INFO: [VRFC 10-311] analyzing module test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0_ShiftReg\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0.v\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0\n", + "INFO: [VRFC 10-311] analyzing module test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_ShiftReg\n", + "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/dataflow_monitor.sv\" into library xil_defaultlib\n", + "INFO: [VRFC 10-311] analyzing module dataflow_monitor\n", + "Starting static elaboration\n", + "Pass Through NonSizing Optimizer\n", + "Completed static elaboration\n", + "Starting simulation data flow analysis\n", + "Completed simulation data flow analysis\n", + "Time Resolution for simulation is 1ps\n", + "Compiling package xil_defaultlib.$unit_dataflow_monitor_sv\n", + "Compiling module xil_defaultlib.test_mul_8s_5s_12_1_1(NUM_STAGE=...\n", + "Compiling module xil_defaultlib.test_dense_latency_wrapper_ap_fi...\n", + "Compiling module xil_defaultlib.test_regslice_both(DataWidth=16)\n", + "Compiling module xil_defaultlib.test_dense_array_ap_fixed_2u_arr...\n", + "Compiling module xil_defaultlib.test_mul_8s_5ns_12_1_1(NUM_STAGE...\n", + "Compiling module xil_defaultlib.test_lif_neuron_array_ap_fixed_8...\n", + "Compiling module xil_defaultlib.test_dense_latency_wrapper_ap_fi...\n", + "Compiling module xil_defaultlib.test_dense_array_ap_fixed_8u_arr...\n", + "Compiling module xil_defaultlib.test_regslice_both\n", + "Compiling module xil_defaultlib.test_snn_readout_array_ap_fixed_...\n", + "Compiling module xil_defaultlib.test_fifo_w64_d1_S_ShiftReg\n", + "Compiling module xil_defaultlib.test_fifo_w64_d1_S_default\n", + "Compiling module xil_defaultlib.test_fifo_w16_d1_S_ShiftReg\n", + "Compiling module xil_defaultlib.test_fifo_w16_d1_S_default\n", + "Compiling module xil_defaultlib.test_start_for_lif_neuron_array_...\n", + "Compiling module xil_defaultlib.test_start_for_lif_neuron_array_...\n", + "Compiling module xil_defaultlib.test_start_for_dense_array_ap_fi...\n", + "Compiling module xil_defaultlib.test_start_for_dense_array_ap_fi...\n", + "Compiling module xil_defaultlib.test_start_for_snn_readout_array...\n", + "Compiling module xil_defaultlib.test_start_for_snn_readout_array...\n", + "Compiling module xil_defaultlib.test\n", + "Compiling module xil_defaultlib.fifo(DEPTH=2,WIDTH=16)\n", + "Compiling module xil_defaultlib.AESL_axi_s_x_t\n", + "Compiling module xil_defaultlib.fifo(DEPTH=2)\n", + "Compiling module xil_defaultlib.AESL_axi_s_layer5_out\n", + "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(IN_CHA...\n", + "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(PROC_I...\n", + "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(PROC_I...\n", + "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(PROC_I...\n", + "Compiling module xil_defaultlib.AESL_deadlock_report_unit_defaul...\n", + "Compiling module xil_defaultlib.AESL_deadlock_detector_2\n", + "Compiling module xil_defaultlib.AESL_deadlock_idx0_monitor\n", + "Compiling module xil_defaultlib.AESL_deadlock_kernel_monitor_top...\n", + "Compiling module xil_defaultlib.df_fifo_intf_default\n", + "Compiling module xil_defaultlib.df_process_intf_default\n", + "Compiling module xil_defaultlib.nodf_module_intf_default\n", + "Compiling module xil_defaultlib.dataflow_monitor_1\n", + "Compiling module xil_defaultlib.apatb_test_top\n", + "Compiling module work.glbl\n", + "Built simulation snapshot test\n", + "\n", + "****** xsim v2024.1 (64-bit)\n", + " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", + " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", + " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", + " **** Start of session at: Tue May 5 17:22:31 2026\n", + " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", + " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", + "\n", + "source xsim.dir/test/xsim_script.tcl\n", + "# xsim {test} -view {{test_dataflow_ana.wcfg}} -tclbatch {test.tcl} -protoinst {test.protoinst}\n", + "INFO: [Wavedata 42-565] Reading protoinst file test.protoinst\n", + "INFO: [Wavedata 42-564] Found protocol instance at /apatb_test_top/AESL_inst_test//AESL_inst_test_activity\n", + "INFO: [Wavedata 42-564] Found protocol instance at /apatb_test_top/AESL_inst_test/dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_U0/dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_U0_activity\n", + "INFO: [Wavedata 42-564] Found protocol instance at /apatb_test_top/AESL_inst_test/dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0/dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0_activity\n", + "INFO: [Wavedata 42-564] Found protocol instance at /apatb_test_top/AESL_inst_test/lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0/lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0_activity\n", + "INFO: [Wavedata 42-564] Found protocol instance at /apatb_test_top/AESL_inst_test/snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0/snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_activity\n", + "Time resolution is 1 ps\n", + "open_wave_config test_dataflow_ana.wcfg\n", + "source test.tcl\n", + "## set designtopgroup [add_wave_group \"Design Top Signals\"]\n", + "## set coutputgroup [add_wave_group \"C Outputs\" -into $designtopgroup]\n", + "## set return_group [add_wave_group return(axis) -into $coutputgroup]\n", + "## add_wave /apatb_test_top/AESL_inst_test/layer5_out_TREADY -into $return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_test_top/AESL_inst_test/layer5_out_TVALID -into $return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_test_top/AESL_inst_test/layer5_out_TDATA -into $return_group -radix hex\n", + "## set cinputgroup [add_wave_group \"C Inputs\" -into $designtopgroup]\n", + "## set return_group [add_wave_group return(axis) -into $cinputgroup]\n", + "## add_wave /apatb_test_top/AESL_inst_test/x_t_TREADY -into $return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_test_top/AESL_inst_test/x_t_TVALID -into $return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_test_top/AESL_inst_test/x_t_TDATA -into $return_group -radix hex\n", + "## set blocksiggroup [add_wave_group \"Block-level IO Handshake\" -into $designtopgroup]\n", + "## add_wave /apatb_test_top/AESL_inst_test/ap_start -into $blocksiggroup\n", + "## add_wave /apatb_test_top/AESL_inst_test/ap_done -into $blocksiggroup\n", + "## add_wave /apatb_test_top/AESL_inst_test/ap_ready -into $blocksiggroup\n", + "## add_wave /apatb_test_top/AESL_inst_test/ap_idle -into $blocksiggroup\n", + "## set resetgroup [add_wave_group \"Reset\" -into $designtopgroup]\n", + "## add_wave /apatb_test_top/AESL_inst_test/ap_rst_n -into $resetgroup\n", + "## set clockgroup [add_wave_group \"Clock\" -into $designtopgroup]\n", + "## add_wave /apatb_test_top/AESL_inst_test/ap_clk -into $clockgroup\n", + "## set testbenchgroup [add_wave_group \"Test Bench Signals\"]\n", + "## set tbinternalsiggroup [add_wave_group \"Internal Signals\" -into $testbenchgroup]\n", + "## set tb_simstatus_group [add_wave_group \"Simulation Status\" -into $tbinternalsiggroup]\n", + "## set tb_portdepth_group [add_wave_group \"Port Depth\" -into $tbinternalsiggroup]\n", + "## add_wave /apatb_test_top/AUTOTB_TRANSACTION_NUM -into $tb_simstatus_group -radix hex\n", + "## add_wave /apatb_test_top/ready_cnt -into $tb_simstatus_group -radix hex\n", + "## add_wave /apatb_test_top/done_cnt -into $tb_simstatus_group -radix hex\n", + "## add_wave /apatb_test_top/LENGTH_layer5_out -into $tb_portdepth_group -radix hex\n", + "## add_wave /apatb_test_top/LENGTH_x_t -into $tb_portdepth_group -radix hex\n", + "## set tbcoutputgroup [add_wave_group \"C Outputs\" -into $testbenchgroup]\n", + "## set tb_return_group [add_wave_group return(axis) -into $tbcoutputgroup]\n", + "## add_wave /apatb_test_top/layer5_out_TREADY -into $tb_return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_test_top/layer5_out_TVALID -into $tb_return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_test_top/layer5_out_TDATA -into $tb_return_group -radix hex\n", + "## set tbcinputgroup [add_wave_group \"C Inputs\" -into $testbenchgroup]\n", + "## set tb_return_group [add_wave_group return(axis) -into $tbcinputgroup]\n", + "## add_wave /apatb_test_top/x_t_TREADY -into $tb_return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_test_top/x_t_TVALID -into $tb_return_group -color #ffff00 -radix hex\n", + "## add_wave /apatb_test_top/x_t_TDATA -into $tb_return_group -radix hex\n", + "## save_wave_config test.wcfg\n", + "## run all\n", + "////////////////////////////////////////////////////////////////////////////////////\n", + "// Inter-Transaction Progress: Completed Transaction / Total Transaction\n", + "// Intra-Transaction Progress: Measured Latency / Latency Estimation * 100%\n", + "//\n", + "// RTL Simulation : \"Inter-Transaction Progress\" [\"Intra-Transaction Progress\"] @ \"Simulation Time\"\n", + "////////////////////////////////////////////////////////////////////////////////////\n", + "// RTL Simulation : 0 / 5 [0.00%] @ \"113000\"\n", + "// RTL Simulation : 1 / 5 [112.50%] @ \"183000\"\n", + "// RTL Simulation : 2 / 5 [125.00%] @ \"198000\"\n", + "// RTL Simulation : 3 / 5 [137.50%] @ \"213000\"\n", + "// RTL Simulation : 4 / 5 [125.00%] @ \"228000\"\n", + "// RTL Simulation : 5 / 5 [100.00%] @ \"233000\"\n", + "////////////////////////////////////////////////////////////////////////////////////\n", + "$finish called at time : 262500 ps : File \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test.autotb.v\" Line 249\n", + "## quit\n", + "INFO: [Common 17-206] Exiting xsim at Tue May 5 17:22:34 2026...\n", + "WARNING: [HLS 200-2011] Cannot find the 'zip' utility on this system. This is required for cosimulation.\n", + "INFO: [COSIM 212-316] Starting C post checking ...\n", + "INFO: Unable to open input/predictions file, using default input.\n", + "0 \n", + "1 \n", + "0 \n", + "0 \n", + "0 \n", + "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", + "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", + "INFO:\n", + "Report time : Tue May 5 05:22:26 PM IST 2026.\n", + "Solution : solution1.\n", + "Simulation tool : xsim.\n", + "\n", + "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", + "| | | Latency(Clock Cycles) | Interval(Clock Cycles) | Total Execution Time |\n", + "+ RTL + Status +-----------------------------------------------+-----------------------------------------------+ (Clock Cycles) +\n", + "| | | min | avg | max | min | avg | max | |\n", + "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", + "| VHDL| NA| NA| NA| NA| NA| NA| NA| NA|\n", + "| Verilog| Pass| NA| NA| NA| NA| NA| NA| NA|\n", + "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", + "\n", + "***** C/RTL SIMULATION COMPLETED IN 0h0m20s *****\n", + "***** C/RTL VALIDATION *****\n", + "INFO: Test PASSED\n", + "***** EXPORT IP *****\n", + "INFO: [HLS 200-1510] Running: export_design -format ip_catalog -version 1.0.0 \n", + "INFO: [IMPL 213-8] Exporting RTL as a Vivado IP.\n", + "\n", + "****** Vivado v2024.1 (64-bit)\n", + " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", + " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", + " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", + " **** Start of session at: Tue May 5 17:22:35 2026\n", + " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", + " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", + "\n", + "source run_ippack.tcl -notrace\n", + "INFO: calling package_hls_ip ip_types=vitis sysgen json_file=/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/solution1_data.json outdir=/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip srcdir=/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1 sort_interfaces_ports=false\n", + "INFO: Copied 1 ipmisc file(s) to /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/misc\n", + "INFO: Copied 20 verilog file(s) to /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/hdl/verilog\n", + "INFO: Copied 15 vhdl file(s) to /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/hdl/vhdl\n", + "INFO: Import ports from HDL: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/hdl/vhdl/test.vhd (test)\n", + "INFO: Add axi4stream interface x_t\n", + "INFO: Add axi4stream interface layer5_out\n", + "INFO: [IP_Flow 19-234] Refreshing IP repositories\n", + "INFO: [IP_Flow 19-1704] No user IP repositories specified\n", + "INFO: [IP_Flow 19-2313] Loaded Vivado IP repository '/tools/Xilinx/Vivado/2024.1/data/ip'.\n", + "INFO: Add clock interface ap_clk\n", + "INFO: Add reset interface ap_rst_n\n", + "INFO: Add ap_ctrl interface ap_ctrl\n", + "INFO: Calling post_process_vitis to specialize IP\n", + "INFO: Calling post_process_sysgen to specialize IP\n", + "Generating sysgen info xml from json file\n", + "INFO: Created IP /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/component.xml\n", + "INFO: Created IP archive /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/xilinx_com_hls_test_1_0.zip\n", + "INFO: [Common 17-206] Exiting Vivado at Tue May 5 17:22:42 2026...\n", + "INFO: [HLS 200-802] Generated output file test_prj/solution1/impl/export.zip\n", + "INFO: [HLS 200-2161] Finished Command export_design Elapsed time: 00:00:18; Allocated memory: 0.000 MB.\n", + "***** EXPORT IP COMPLETED IN 0h0m18s *****\n", + "***** VIVADO SYNTHESIS *****\n", + "\n", + "****** Vivado v2024.1 (64-bit)\n", + " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", + " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", + " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", + " **** Start of session at: Tue May 5 17:22:53 2026\n", + " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", + " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", + "\n", + "source vivado_synth.tcl\n", + "# set tcldir [file dirname [info script]]\n", + "# source [file join $tcldir project.tcl]\n", + "## variable project_name\n", + "## set project_name \"test\"\n", + "## variable backend\n", + "## set backend \"vitis\"\n", + "## variable part\n", + "## set part \"xczu7ev-ffvc1156-2-e\"\n", + "## variable clock_period\n", + "## set clock_period 5\n", + "## variable clock_uncertainty\n", + "## set clock_uncertainty 18%\n", + "## variable version\n", + "## set version \"1.0.0\"\n", + "## variable maximum_size\n", + "## set maximum_size 4096\n", + "# add_files ${project_name}_prj/solution1/syn/verilog\n", + "# synth_design -top ${project_name} -part $part\n", + "Command: synth_design -top test -part xczu7ev-ffvc1156-2-e\n", + "Starting synth_design\n", + "Attempting to get a license for feature 'Synthesis' and/or device 'xczu7ev'\n", + "INFO: [Common 17-349] Got license for feature 'Synthesis' and/or device 'xczu7ev'\n", + "INFO: [Synth 8-7079] Multithreading enabled for synth_design using a maximum of 4 processes.\n", + "INFO: [Synth 8-7078] Launching helper process for spawning children vivado processes\n", + "INFO: [Synth 8-7075] Helper process launched with PID 28461\n", + "---------------------------------------------------------------------------------\n", + "Starting Synthesize : Time (s): cpu = 00:00:03 ; elapsed = 00:00:03 . Memory (MB): peak = 1875.949 ; gain = 426.633 ; free physical = 738 ; free virtual = 21845\n", + "---------------------------------------------------------------------------------\n", + "INFO: [Synth 8-6157] synthesizing module 'test' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_mul_8s_5s_12_1_1' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_mul_8s_5s_12_1_1.v:5]\n", + "\tParameter ID bound to: 1 - type: integer \n", + "\tParameter NUM_STAGE bound to: 1 - type: integer \n", + "\tParameter din0_WIDTH bound to: 8 - type: integer \n", + "\tParameter din1_WIDTH bound to: 5 - type: integer \n", + "\tParameter dout_WIDTH bound to: 12 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'test_mul_8s_5s_12_1_1' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_mul_8s_5s_12_1_1.v:5]\n", + "INFO: [Synth 8-6155] done synthesizing module 'test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_regslice_both' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_regslice_both.v:9]\n", + "\tParameter DataWidth bound to: 16 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'test_regslice_both' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_regslice_both.v:9]\n", + "INFO: [Synth 8-6155] done synthesizing module 'test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_mul_8s_5ns_12_1_1' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_mul_8s_5ns_12_1_1.v:5]\n", + "\tParameter ID bound to: 1 - type: integer \n", + "\tParameter NUM_STAGE bound to: 1 - type: integer \n", + "\tParameter din0_WIDTH bound to: 8 - type: integer \n", + "\tParameter din1_WIDTH bound to: 5 - type: integer \n", + "\tParameter dout_WIDTH bound to: 12 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'test_mul_8s_5ns_12_1_1' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_mul_8s_5ns_12_1_1.v:5]\n", + "INFO: [Synth 8-6155] done synthesizing module 'test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s.v:9]\n", + "INFO: [Synth 8-6155] done synthesizing module 'test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s.v:9]\n", + "INFO: [Synth 8-6155] done synthesizing module 'test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_regslice_both__parameterized0' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_regslice_both.v:9]\n", + "\tParameter DataWidth bound to: 8 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'test_regslice_both__parameterized0' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_regslice_both.v:9]\n", + "INFO: [Synth 8-6155] done synthesizing module 'test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s.v:9]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_fifo_w64_d1_S' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w64_d1_S.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_fifo_w64_d1_S_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w64_d1_S.v:129]\n", + "\tParameter DATA_WIDTH bound to: 64 - type: integer \n", + "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", + "\tParameter DEPTH bound to: 1 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'test_fifo_w64_d1_S_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w64_d1_S.v:129]\n", + "INFO: [Synth 8-6155] done synthesizing module 'test_fifo_w64_d1_S' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w64_d1_S.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_fifo_w16_d1_S' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w16_d1_S.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_fifo_w16_d1_S_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w16_d1_S.v:129]\n", + "\tParameter DATA_WIDTH bound to: 16 - type: integer \n", + "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", + "\tParameter DEPTH bound to: 1 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'test_fifo_w16_d1_S_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w16_d1_S.v:129]\n", + "INFO: [Synth 8-6155] done synthesizing module 'test_fifo_w16_d1_S' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w16_d1_S.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0.v:125]\n", + "\tParameter DATA_WIDTH bound to: 1 - type: integer \n", + "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", + "\tParameter DEPTH bound to: 2 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0.v:125]\n", + "INFO: [Synth 8-6155] done synthesizing module 'test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0.v:125]\n", + "\tParameter DATA_WIDTH bound to: 1 - type: integer \n", + "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", + "\tParameter DEPTH bound to: 2 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0.v:125]\n", + "INFO: [Synth 8-6155] done synthesizing module 'test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0.v:11]\n", + "INFO: [Synth 8-6157] synthesizing module 'test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0.v:125]\n", + "\tParameter DATA_WIDTH bound to: 1 - type: integer \n", + "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", + "\tParameter DEPTH bound to: 2 - type: integer \n", + "INFO: [Synth 8-6155] done synthesizing module 'test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0.v:125]\n", + "INFO: [Synth 8-6155] done synthesizing module 'test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0.v:11]\n", + "INFO: [Synth 8-6155] done synthesizing module 'test' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test.v:9]\n", + "WARNING: [Synth 8-7129] Port addr[0] in module test_fifo_w16_d1_S_ShiftReg is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port addr[0] in module test_fifo_w64_d1_S_ShiftReg is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[1] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[0] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[1] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[0] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port data_7_val8[1] in module test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port data_7_val8[0] in module test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port ap_rst in module test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port ap_rst in module test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", + "---------------------------------------------------------------------------------\n", + "Finished Synthesize : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1958.918 ; gain = 509.602 ; free physical = 761 ; free virtual = 21890\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Constraint Validation : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1973.762 ; gain = 524.445 ; free physical = 754 ; free virtual = 21883\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Loading Part and Timing Information\n", + "---------------------------------------------------------------------------------\n", + "Loading part: xczu7ev-ffvc1156-2-e\n", + "INFO: [Synth 8-6742] Reading net delay rules and data\n", + "INFO: [Device 21-403] Loading part xczu7ev-ffvc1156-2-e\n", + "---------------------------------------------------------------------------------\n", + "Finished Loading Part and Timing Information : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1990.672 ; gain = 541.355 ; free physical = 747 ; free virtual = 21875\n", + "---------------------------------------------------------------------------------\n", + "INFO: [Synth 8-802] inferred FSM for state register 'state_reg' in module 'test_regslice_both'\n", + "INFO: [Synth 8-4490] FSM extraction disabled for register 'ap_CS_fsm_reg' through user attribute\n", + "INFO: [Synth 8-4490] FSM extraction disabled for register 'ap_CS_fsm_reg' through user attribute\n", + "INFO: [Synth 8-802] inferred FSM for state register 'state_reg' in module 'test_regslice_both__parameterized0'\n", + "---------------------------------------------------------------------------------------------------\n", + " State | New Encoding | Previous Encoding \n", + "---------------------------------------------------------------------------------------------------\n", + " ZERO | 00 | 10\n", + " ONE | 10 | 11\n", + " TWO | 01 | 01\n", + "---------------------------------------------------------------------------------------------------\n", + "INFO: [Synth 8-3354] encoded FSM with state register 'state_reg' using encoding 'sequential' in module 'test_regslice_both'\n", + "---------------------------------------------------------------------------------------------------\n", + " State | New Encoding | Previous Encoding \n", + "---------------------------------------------------------------------------------------------------\n", + " ZERO | 00 | 10\n", + " ONE | 10 | 11\n", + " TWO | 01 | 01\n", + "---------------------------------------------------------------------------------------------------\n", + "INFO: [Synth 8-3354] encoded FSM with state register 'state_reg' using encoding 'sequential' in module 'test_regslice_both__parameterized0'\n", + "---------------------------------------------------------------------------------\n", + "Finished RTL Optimization Phase 2 : Time (s): cpu = 00:00:05 ; elapsed = 00:00:05 . Memory (MB): peak = 1990.672 ; gain = 541.355 ; free physical = 760 ; free virtual = 21888\n", + "---------------------------------------------------------------------------------\n", + "No constraint files found.\n", + "---------------------------------------------------------------------------------\n", + "Start RTL Component Statistics \n", + "---------------------------------------------------------------------------------\n", + "Detailed RTL Component Info : \n", + "+---Adders : \n", + "\t 2 Input 16 Bit Adders := 4 \n", + "\t 3 Input 12 Bit Adders := 8 \n", + "\t 2 Input 12 Bit Adders := 2 \n", + "\t 3 Input 11 Bit Adders := 4 \n", + "\t 3 Input 8 Bit Adders := 11 \n", + "\t 2 Input 8 Bit Adders := 12 \n", + "\t 6 Input 8 Bit Adders := 1 \n", + "\t 8 Input 8 Bit Adders := 1 \n", + "\t 2 Input 7 Bit Adders := 3 \n", + "\t 2 Input 6 Bit Adders := 6 \n", + "\t 2 Input 2 Bit Adders := 6 \n", + "\t 2 Input 1 Bit Adders := 6 \n", + "+---Registers : \n", + "\t 64 Bit Registers := 2 \n", + "\t 16 Bit Registers := 5 \n", + "\t 8 Bit Registers := 28 \n", + "\t 6 Bit Registers := 2 \n", + "\t 3 Bit Registers := 1 \n", + "\t 2 Bit Registers := 9 \n", + "\t 1 Bit Registers := 45 \n", + "+---Muxes : \n", + "\t 2 Input 16 Bit Muxes := 1 \n", + "\t 2 Input 8 Bit Muxes := 9 \n", + "\t 4 Input 3 Bit Muxes := 1 \n", + "\t 2 Input 3 Bit Muxes := 1 \n", + "\t 2 Input 2 Bit Muxes := 34 \n", + "\t 3 Input 2 Bit Muxes := 6 \n", + "\t 4 Input 2 Bit Muxes := 3 \n", + "\t 2 Input 1 Bit Muxes := 44 \n", + "---------------------------------------------------------------------------------\n", + "Finished RTL Component Statistics \n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Part Resource Summary\n", + "---------------------------------------------------------------------------------\n", + "Part Resources:\n", + "DSPs: 1728 (col length:144)\n", + "BRAMs: 624 (col length: RAMB18 144 RAMB36 72)\n", + "---------------------------------------------------------------------------------\n", + "Finished Part Resource Summary\n", + "---------------------------------------------------------------------------------\n", + "No constraint files found.\n", + "---------------------------------------------------------------------------------\n", + "Start Cross Boundary and Area Optimization\n", + "---------------------------------------------------------------------------------\n", + "WARNING: [Synth 8-7080] Parallel synthesis criteria is not met\n", + "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[1] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[0] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[1] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[0] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", + "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", + "---------------------------------------------------------------------------------\n", + "Finished Cross Boundary and Area Optimization : Time (s): cpu = 00:00:10 ; elapsed = 00:00:10 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 216 ; free virtual = 21078\n", + "---------------------------------------------------------------------------------\n", + "No constraint files found.\n", + "---------------------------------------------------------------------------------\n", + "Start Timing Optimization\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Timing Optimization : Time (s): cpu = 00:00:10 ; elapsed = 00:00:10 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 225 ; free virtual = 21090\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Technology Mapping\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Technology Mapping : Time (s): cpu = 00:00:10 ; elapsed = 00:00:10 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 229 ; free virtual = 21095\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start IO Insertion\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Flattening Before IO Insertion\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Flattening Before IO Insertion\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Final Netlist Cleanup\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Final Netlist Cleanup\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished IO Insertion : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21121\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Renaming Generated Instances\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Renaming Generated Instances : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21121\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Rebuilding User Hierarchy\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Rebuilding User Hierarchy : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21120\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Renaming Generated Ports\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Renaming Generated Ports : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21121\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Handling Custom Attributes\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Handling Custom Attributes : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21121\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Renaming Generated Nets\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Finished Renaming Generated Nets : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21121\n", + "---------------------------------------------------------------------------------\n", + "---------------------------------------------------------------------------------\n", + "Start Writing Synthesis Report\n", + "---------------------------------------------------------------------------------\n", + "\n", + "Report BlackBoxes: \n", + "+-+--------------+----------+\n", + "| |BlackBox name |Instances |\n", + "+-+--------------+----------+\n", + "+-+--------------+----------+\n", + "\n", + "Report Cell Usage: \n", + "+------+-------+------+\n", + "| |Cell |Count |\n", + "+------+-------+------+\n", + "|1 |BUFG | 1|\n", + "|2 |CARRY8 | 49|\n", + "|3 |LUT1 | 37|\n", + "|4 |LUT2 | 191|\n", + "|5 |LUT3 | 53|\n", + "|6 |LUT4 | 117|\n", + "|7 |LUT5 | 139|\n", + "|8 |LUT6 | 160|\n", + "|9 |FDRE | 346|\n", + "|10 |FDSE | 10|\n", + "|11 |IBUF | 21|\n", + "|12 |OBUF | 13|\n", + "+------+-------+------+\n", + "\n", + "Report Instance Areas: \n", + "+------+-----------------------------------------------------------------------------------------+------------------------------------------------------------------------------------+------+\n", + "| |Instance |Module |Cells |\n", + "+------+-----------------------------------------------------------------------------------------+------------------------------------------------------------------------------------+------+\n", + "|1 |top | | 1137|\n", + "|2 | dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_U0 |test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s | 335|\n", + "|3 | call_ret_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s_fu_47 |test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s | 30|\n", + "|4 | mul_8s_5s_12_1_1_U1 |test_mul_8s_5s_12_1_1 | 1|\n", + "|5 | regslice_both_x_t_U |test_regslice_both | 238|\n", + "|6 | dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0 |test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s | 110|\n", + "|7 | call_ret_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s_fu_65 |test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s | 7|\n", + "|8 | layer2_out_U |test_fifo_w64_d1_S | 139|\n", + "|9 | U_test_fifo_w64_d1_S_ShiftReg |test_fifo_w64_d1_S_ShiftReg_8 | 130|\n", + "|10 | layer3_out_U |test_fifo_w64_d1_S_0 | 16|\n", + "|11 | U_test_fifo_w64_d1_S_ShiftReg |test_fifo_w64_d1_S_ShiftReg | 8|\n", + "|12 | layer4_out_U |test_fifo_w16_d1_S | 37|\n", + "|13 | U_test_fifo_w16_d1_S_ShiftReg |test_fifo_w16_d1_S_ShiftReg | 28|\n", + "|14 | lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0 |test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s | 321|\n", + "|15 | mul_8s_5ns_12_1_1_U10 |test_mul_8s_5ns_12_1_1 | 25|\n", + "|16 | mul_8s_5ns_12_1_1_U11 |test_mul_8s_5ns_12_1_1_1 | 25|\n", + "|17 | mul_8s_5ns_12_1_1_U12 |test_mul_8s_5ns_12_1_1_2 | 25|\n", + "|18 | mul_8s_5ns_12_1_1_U13 |test_mul_8s_5ns_12_1_1_3 | 25|\n", + "|19 | mul_8s_5ns_12_1_1_U14 |test_mul_8s_5ns_12_1_1_4 | 25|\n", + "|20 | mul_8s_5ns_12_1_1_U15 |test_mul_8s_5ns_12_1_1_5 | 26|\n", + "|21 | mul_8s_5ns_12_1_1_U8 |test_mul_8s_5ns_12_1_1_6 | 26|\n", + "|22 | mul_8s_5ns_12_1_1_U9 |test_mul_8s_5ns_12_1_1_7 | 25|\n", + "|23 | snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0 |test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s | 114|\n", + "|24 | regslice_both_layer5_out_U |test_regslice_both__parameterized0 | 55|\n", + "|25 | start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0_U |test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0 | 10|\n", + "|26 | start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0_U |test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0 | 11|\n", + "|27 | start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_U |test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0 | 9|\n", + "+------+-----------------------------------------------------------------------------------------+------------------------------------------------------------------------------------+------+\n", + "---------------------------------------------------------------------------------\n", + "Finished Writing Synthesis Report : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21121\n", + "---------------------------------------------------------------------------------\n", + "Synthesis finished with 0 errors, 0 critical warnings and 55 warnings.\n", + "Synthesis Optimization Runtime : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 231 ; free virtual = 21125\n", + "Synthesis Optimization Complete : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.633 ; gain = 1407.309 ; free physical = 231 ; free virtual = 21125\n", + "INFO: [Project 1-571] Translating synthesized netlist\n", + "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00.01 . Memory (MB): peak = 2856.633 ; gain = 0.000 ; free physical = 483 ; free virtual = 21378\n", + "INFO: [Netlist 29-17] Analyzing 71 Unisim elements for replacement\n", + "INFO: [Netlist 29-28] Unisim Transformation completed in 0 CPU seconds\n", + "INFO: [Project 1-570] Preparing netlist for logic optimization\n", + "INFO: [Opt 31-138] Pushed 0 inverter(s) to 0 load pin(s).\n", + "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 2912.652 ; gain = 0.000 ; free physical = 488 ; free virtual = 21367\n", + "INFO: [Project 1-111] Unisim Transformation Summary:\n", + " A total of 22 instances were transformed.\n", + " BUFG => BUFGCE: 1 instance \n", + " IBUF => IBUF (IBUFCTRL, INBUF): 21 instances\n", + "\n", + "Synth Design complete | Checksum: 8f9a4ab4\n", + "INFO: [Common 17-83] Releasing license: Synthesis\n", + "61 Infos, 55 Warnings, 0 Critical Warnings and 0 Errors encountered.\n", + "synth_design completed successfully\n", + "synth_design: Time (s): cpu = 00:00:16 ; elapsed = 00:00:15 . Memory (MB): peak = 2912.652 ; gain = 1466.324 ; free physical = 487 ; free virtual = 21354\n", + "INFO: [Common 17-2834] synth_design peak Physical Memory [PSS] (MB): overall = 2666.472; main = 2389.730; forked = 454.161\n", + "INFO: [Common 17-2834] synth_design peak Virtual Memory [VSS] (MB): overall = 3890.047; main = 2912.656; forked = 1033.418\n", + "# opt_design -retarget -propconst -sweep -bram_power_opt -shift_register_opt\n", + "Command: opt_design -retarget -propconst -sweep -bram_power_opt -shift_register_opt\n", + "Attempting to get a license for feature 'Implementation' and/or device 'xczu7ev'\n", + "INFO: [Common 17-349] Got license for feature 'Implementation' and/or device 'xczu7ev'\n", + "Running DRC as a precondition to command opt_design\n", + "\n", + "Starting DRC Task\n", + "INFO: [DRC 23-27] Running DRC with 8 threads\n", + "INFO: [Project 1-461] DRC finished with 0 Errors\n", + "INFO: [Project 1-462] Please refer to the DRC report (report_drc) for more information.\n", + "\n", + "Time (s): cpu = 00:00:01 ; elapsed = 00:00:00.78 . Memory (MB): peak = 2976.684 ; gain = 64.031 ; free physical = 483 ; free virtual = 21342\n", + "\n", + "Starting Cache Timing Information Task\n", + "INFO: [Timing 38-35] Done setting XDC timing constraints.\n", + "Ending Cache Timing Information Task | Checksum: 20489a5a7\n", + "\n", + "Time (s): cpu = 00:00:06 ; elapsed = 00:00:06 . Memory (MB): peak = 3524.551 ; gain = 547.867 ; free physical = 206 ; free virtual = 20769\n", + "\n", + "Starting Logic Optimization Task\n", + "\n", + "Phase 1 Initialization\n", + "\n", + "Phase 1.1 Core Generation And Design Setup\n", + "Phase 1.1 Core Generation And Design Setup | Checksum: 20489a5a7\n", + "\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 369 ; free virtual = 20340\n", + "\n", + "Phase 1.2 Setup Constraints And Sort Netlist\n", + "Phase 1.2 Setup Constraints And Sort Netlist | Checksum: 20489a5a7\n", + "\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 369 ; free virtual = 20340\n", + "Phase 1 Initialization | Checksum: 20489a5a7\n", + "\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 369 ; free virtual = 20340\n", + "\n", + "Phase 2 Timer Update And Timing Data Collection\n", + "\n", + "Phase 2.1 Timer Update\n", + "Phase 2.1 Timer Update | Checksum: 20489a5a7\n", + "\n", + "Time (s): cpu = 00:00:00.02 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 366 ; free virtual = 20336\n", + "\n", + "Phase 2.2 Timing Data Collection\n", + "Phase 2.2 Timing Data Collection | Checksum: 20489a5a7\n", + "\n", + "Time (s): cpu = 00:00:00.02 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 365 ; free virtual = 20335\n", + "Phase 2 Timer Update And Timing Data Collection | Checksum: 20489a5a7\n", + "\n", + "Time (s): cpu = 00:00:00.02 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 365 ; free virtual = 20335\n", + "\n", + "Phase 3 Retarget\n", + "INFO: [Opt 31-1834] Total Chains To Be Transformed Were: 0 AND Number of Transformed insts Created are: 0\n", + "INFO: [Opt 31-138] Pushed 1 inverter(s) to 44 load pin(s).\n", + "INFO: [Opt 31-49] Retargeted 0 cell(s).\n", + "Phase 3 Retarget | Checksum: 220bc3ccd\n", + "\n", + "Time (s): cpu = 00:00:00.09 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 359 ; free virtual = 20329\n", + "Retarget | Checksum: 220bc3ccd\n", + "INFO: [Opt 31-389] Phase Retarget created 0 cells and removed 1 cells\n", + "\n", + "Phase 4 Constant propagation\n", + "INFO: [Opt 31-138] Pushed 0 inverter(s) to 0 load pin(s).\n", + "Phase 4 Constant propagation | Checksum: 29d37246d\n", + "\n", + "Time (s): cpu = 00:00:00.1 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 390 ; free virtual = 20323\n", + "Constant propagation | Checksum: 29d37246d\n", + "INFO: [Opt 31-389] Phase Constant propagation created 0 cells and removed 0 cells\n", + "\n", + "Phase 5 Sweep\n", + "Phase 5 Sweep | Checksum: 26e0e4c99\n", + "\n", + "Time (s): cpu = 00:00:00.11 ; elapsed = 00:00:00.06 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 465 ; free virtual = 20316\n", + "Sweep | Checksum: 26e0e4c99\n", + "INFO: [Opt 31-389] Phase Sweep created 0 cells and removed 0 cells\n", + "\n", + "Phase 6 Shift Register Optimization\n", + "INFO: [Opt 31-1064] SRL Remap converted 0 SRLs to 0 registers and converted 0 registers of register chains to 0 SRLs\n", + "Phase 6 Shift Register Optimization | Checksum: 26e0e4c99\n", + "\n", + "Time (s): cpu = 00:00:00.11 ; elapsed = 00:00:00.06 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 480 ; free virtual = 20320\n", + "Shift Register Optimization | Checksum: 26e0e4c99\n", + "INFO: [Opt 31-389] Phase Shift Register Optimization created 0 cells and removed 0 cells\n", + "\n", + "Phase 7 Post Processing Netlist\n", + "Phase 7 Post Processing Netlist | Checksum: 26e0e4c99\n", + "\n", + "Time (s): cpu = 00:00:00.12 ; elapsed = 00:00:00.07 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 500 ; free virtual = 20317\n", + "Post Processing Netlist | Checksum: 26e0e4c99\n", + "INFO: [Opt 31-389] Phase Post Processing Netlist created 0 cells and removed 0 cells\n", + "\n", + "Phase 8 Finalization\n", + "\n", + "Phase 8.1 Finalizing Design Cores and Updating Shapes\n", + "Phase 8.1 Finalizing Design Cores and Updating Shapes | Checksum: 13ee3ebc9\n", + "\n", + "Time (s): cpu = 00:00:00.18 ; elapsed = 00:00:00.09 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 527 ; free virtual = 20308\n", + "\n", + "Phase 8.2 Verifying Netlist Connectivity\n", + "Phase 8.2 Verifying Netlist Connectivity | Checksum: 13ee3ebc9\n", + "\n", + "Time (s): cpu = 00:00:00.18 ; elapsed = 00:00:00.09 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 527 ; free virtual = 20308\n", + "Phase 8 Finalization | Checksum: 13ee3ebc9\n", + "\n", + "Time (s): cpu = 00:00:00.18 ; elapsed = 00:00:00.09 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 527 ; free virtual = 20308\n", + "Opt_design Change Summary\n", + "=========================\n", + "\n", + "\n", + "-------------------------------------------------------------------------------------------------------------------------\n", + "| Phase | #Cells created | #Cells Removed | #Constrained objects preventing optimizations |\n", + "-------------------------------------------------------------------------------------------------------------------------\n", + "| Retarget | 0 | 1 | 0 |\n", + "| Constant propagation | 0 | 0 | 0 |\n", + "| Sweep | 0 | 0 | 0 |\n", + "| Shift Register Optimization | 0 | 0 | 0 |\n", + "| Post Processing Netlist | 0 | 0 | 0 |\n", + "-------------------------------------------------------------------------------------------------------------------------\n", + "\n", + "\n", + "Ending Logic Optimization Task | Checksum: 13ee3ebc9\n", + "\n", + "Time (s): cpu = 00:00:00.18 ; elapsed = 00:00:00.09 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 527 ; free virtual = 20308\n", + "\n", + "Starting Power Optimization Task\n", + "INFO: [Pwropt 34-132] Skipping clock gating for clocks with a period < 2.00 ns.\n", + "Ending Power Optimization Task | Checksum: 13ee3ebc9\n", + "\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 526 ; free virtual = 20306\n", + "\n", + "Starting Final Cleanup Task\n", + "Ending Final Cleanup Task | Checksum: 13ee3ebc9\n", + "\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 526 ; free virtual = 20306\n", + "\n", + "Starting Netlist Obfuscation Task\n", + "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 526 ; free virtual = 20306\n", + "Ending Netlist Obfuscation Task | Checksum: 13ee3ebc9\n", + "\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 526 ; free virtual = 20306\n", + "INFO: [Common 17-83] Releasing license: Implementation\n", + "17 Infos, 0 Warnings, 0 Critical Warnings and 0 Errors encountered.\n", + "opt_design completed successfully\n", + "opt_design: Time (s): cpu = 00:00:09 ; elapsed = 00:00:09 . Memory (MB): peak = 3788.426 ; gain = 875.773 ; free physical = 526 ; free virtual = 20306\n", + "# report_utilization -file vivado_synth.rpt\n", + "INFO: [Common 17-206] Exiting Vivado at Tue May 5 17:23:23 2026...\n", + "***** VIVADO SYNTHESIS COMPLETED IN 0h0m41s *****\n", + "INFO: [HLS 200-112] Total CPU user time: 76.22 seconds. Total CPU system time: 7.18 seconds. Total elapsed time: 101.58 seconds; peak allocated memory: 451.844 MB.\n", + "INFO: [vitis-run 60-791] Total elapsed time: 0h 1m 42s\n", + "INFO: [vitis-run 60-1662] Stopping dispatch session having empty uuid.\n", + "Implementation report not found.\n", + "Timing report not found.\n", + "{'CSimResults': [['0'], ['1'], ['0'], ['0'], ['0']], 'CosimResults': [['0'], ['1'], ['0'], ['0'], ['0']], 'CSynthesisReport': {'TargetClockPeriod': '5.00', 'EstimatedClockPeriod': '3.984', 'BestLatency': '8', 'WorstLatency': '8', 'IntervalMin': '3', 'IntervalMax': '3', 'DSP': '0', 'FF': '573', 'LUT': '2265', 'BRAM_18K': '0', 'URAM': '0', 'AvailableBRAM_18K': '624', 'AvailableDSP': '1728', 'AvailableFF': '460800', 'AvailableLUT': '230400', 'AvailableURAM': '96'}, 'VivadoSynthReport': {'LUT': '574', 'FF': '356', 'BRAM_18K': '0', 'URAM': '0', 'DSP48E': '0'}, 'CosimReport': {'RTL': 'Verilog', 'Status': 'Pass', 'LatencyMin': 11, 'LatencyMax': 14, 'IntervalMin': 2, 'IntervalMax': 4, 'LatencyAvg': 12.4, 'IntervalAvg': 2.75}}\n" + ] + } + ], + "source": [ + "report = hls_model.build(\n", + " reset=True,\n", + " csim=True,\n", + " synth=True,\n", + " cosim=True,\n", + " validation=True,\n", + " export=True,\n", + " vsynth=True,\n", + ")\n", + "print(report)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "639ce3e7-6c19-4328-9591-5d9e2ab939e0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index a39c7cb362..cead8d81e6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -50,6 +50,7 @@ optional-dependencies.qkeras = [ "tensorflow-model-optimization<=0.7.5", ] optional-dependencies.quartus-report = [ "calmjs-parse", "tabulate" ] +optional-dependencies.snn = [ "snntorch", "torch" ] optional-dependencies.sr = [ "sympy>=1.13.1" ] optional-dependencies.testing = [ "calmjs-parse", diff --git a/requirements-snn-dev.txt b/requirements-snn-dev.txt deleted file mode 100644 index 0645bd959f..0000000000 --- a/requirements-snn-dev.txt +++ /dev/null @@ -1,18 +0,0 @@ -# hls4ml SNN development environment -# Usage: -# python -m venv .venv -# source .venv/bin/activate -# python -m pip install --upgrade pip -# python -m pip install -r requirements-snn-dev.txt - -# Install local hls4ml in editable mode with test extras --e .[testing] - -# SNN training package used upstream in this workflow -snntorch - -# SNN benchmarking package -neurobench - -# Used by the SNN example notebooks/plots -matplotlib From eeae0de0c72b0852810b981c3ff8fd63e2433bf8 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Tue, 5 May 2026 17:52:49 +0100 Subject: [PATCH 09/32] docs update --- docs/advanced/snn.rst | 36 +++--------------------------------- 1 file changed, 3 insertions(+), 33 deletions(-) diff --git a/docs/advanced/snn.rst b/docs/advanced/snn.rst index 016b60915e..d6aec5e91d 100644 --- a/docs/advanced/snn.rst +++ b/docs/advanced/snn.rst @@ -34,33 +34,7 @@ marker module: from hls4ml.utils.snntorch import SNNReadout The marker is an identity in PyTorch and is converted to the hls4ml -``SNNReadout`` layer by the PyTorch frontend. Alternatively, register a custom -PyTorch layer handler that maps your own module name to the hls4ml -``SNNReadout`` layer. - -Example: - -.. code-block:: python - - class ReadoutSNN(torch.nn.Module): - def __init__(self, timesteps): - super().__init__() - self.fc1 = torch.nn.Linear(2, 8) - self.if1 = snntorch.Leaky(beta=0.75, threshold=1.0) - self.fc2 = torch.nn.Linear(8, 2) - self.readout = SNNReadout( - n_classes=2, - window_size=timesteps, - output_mode="membrane", - decision_rule="argmax_membrane", - beta=1.0, - ) - - def forward(self, x_t): - x_t = self.fc1(x_t) - spk1, _ = self.if1(x_t) - x_t = self.fc2(spk1) - return self.readout(x_t) +``SNNReadout`` layer by the PyTorch frontend. See Jupyter Notebook example. `snntorch` tracing ================== @@ -121,8 +95,7 @@ membrane decision policies are: * ``argmax_membrane`` * ``binary_logit`` (emits ``mem(class_1) - mem(class_0)`` for binary classifiers) -This keeps the snnTorch neuron modules unchanged; the final readout layer -performs the non-spiking LIF-style accumulation in generated HLS. +The example in the Jupyter Notebook follows this approach. Do not place a final spiking neuron before ``SNNReadout(output_mode="membrane")`` unless you intentionally want the readout to consume that neuron's spike output. @@ -200,10 +173,7 @@ Precision note Membrane readout accumulates dense currents over the full window, so very narrow fixed-point types can reduce accuracy even when the floating-point PyTorch model -looks good. In the example notebooks, ``ap_fixed<8,3>`` is often too narrow for -membrane readout. Start with a wider network precision such as -``ap_fixed<12,5>`` and a wider readout ``membrane_t`` such as -``ap_fixed<16,7>``, then tighten after comparing HLS and PyTorch outputs. +looks good. ``TLAST`` note ============== From 84dcf544afba11223961db2784a0aebb1a8d6ec4 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Tue, 5 May 2026 18:01:38 +0100 Subject: [PATCH 10/32] added comments --- hls4ml/converters/pytorch/snn.py | 1 + hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h | 2 ++ hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h | 4 ++++ hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h | 2 ++ 4 files changed, 9 insertions(+) diff --git a/hls4ml/converters/pytorch/snn.py b/hls4ml/converters/pytorch/snn.py index 653c51f81d..d0858d49fc 100644 --- a/hls4ml/converters/pytorch/snn.py +++ b/hls4ml/converters/pytorch/snn.py @@ -2,6 +2,7 @@ from hls4ml.converters.pytorch_to_hls import pytorch_handler +# Treat numerically unit leak as IF behavior. BETA_TO_IF_TOL = 1e-6 diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h b/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h index 803df32c50..5711d5950c 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h @@ -25,6 +25,7 @@ void if_neuron( ) { #pragma HLS PIPELINE II=1 + // Static state persists across calls until the configured time window ends. static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; #pragma HLS ARRAY_PARTITION variable=mem complete static unsigned ts = 0; @@ -69,6 +70,7 @@ void if_neuron( ) { #pragma HLS PIPELINE II=1 + // Static state persists across calls until the configured time window ends. static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; #pragma HLS ARRAY_PARTITION variable=mem complete static unsigned ts = 0; diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h b/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h index c45d246c1b..75b9da5e88 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h @@ -31,6 +31,7 @@ void lif_neuron( ) { #pragma HLS PIPELINE II=1 + // Static state persists across calls until the configured time window ends. static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; #pragma HLS ARRAY_PARTITION variable=mem complete static unsigned ts = 0; @@ -41,6 +42,7 @@ void lif_neuron( typename CONFIG_T::threshold_t threshold = CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + // LIF update: v[t] = beta * v[t-1] + input. typename CONFIG_T::membrane_t v = (typename CONFIG_T::membrane_t)(beta * mem[i]) + (typename CONFIG_T::membrane_t)data[i]; bool spike = (v >= threshold); if (spike) { @@ -77,6 +79,7 @@ void lif_neuron( ) { #pragma HLS PIPELINE II=1 + // Static state persists across calls until the configured time window ends. static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; #pragma HLS ARRAY_PARTITION variable=mem complete static unsigned ts = 0; @@ -91,6 +94,7 @@ void lif_neuron( typename CONFIG_T::threshold_t threshold = CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + // LIF update: v[t] = beta * v[t-1] + input. typename CONFIG_T::membrane_t v = (typename CONFIG_T::membrane_t)(beta * mem[i]) + (typename CONFIG_T::membrane_t)in_pack[i]; bool spike = (v >= threshold); if (spike) { diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h b/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h index b2089b6cf8..e37589fe03 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h @@ -22,6 +22,7 @@ template void snn_readout(data_T data[CONFIG_T::n_classes], res_T res[1]) { #pragma HLS PIPELINE II=1 + // Counts and membrane values persist across calls within one readout window. static unsigned counts[CONFIG_T::n_classes]; #pragma HLS ARRAY_PARTITION variable=counts complete static typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]; @@ -157,6 +158,7 @@ template void snn_readout(hls::stream &data_stream, hls::stream &res_stream) { #pragma HLS PIPELINE II=1 + // Counts and membrane values persist across calls within one readout window. static unsigned counts[CONFIG_T::n_classes]; #pragma HLS ARRAY_PARTITION variable=counts complete static typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]; From e80ea92785e06d1f5234fae0220f457770ae5a11 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Tue, 5 May 2026 18:12:48 +0100 Subject: [PATCH 11/32] notebook update --- hls4ml-snn-example.ipynb | 281 +++++++++++++++++++-------------------- 1 file changed, 137 insertions(+), 144 deletions(-) diff --git a/hls4ml-snn-example.ipynb b/hls4ml-snn-example.ipynb index b4dcb8e339..d6b77065d0 100644 --- a/hls4ml-snn-example.ipynb +++ b/hls4ml-snn-example.ipynb @@ -20,13 +20,6 @@ "```bash\n", "source /tools/Xilinx/Vitis/2024.1/settings64.sh\n", "source /tools/Xilinx/Vivado/2024.1/settings64.sh\n", - "```\n", - "\n", - "From the hls4snn repository root, an editable install usually looks like:\n", - "\n", - "```bash\n", - "pip install -e .\n", - "pip install -r requirements-snn-dev.txt\n", "```" ] }, @@ -771,7 +764,7 @@ "output_type": "stream", "text": [ "accuracy: 0.95\n", - "throughput_samples_per_s: 635.6201574354578\n" + "throughput_samples_per_s: 639.4442680253416\n" ] } ], @@ -876,7 +869,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [00:00<00:00, 28.99it/s]" + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [00:00<00:00, 32.28it/s]" ] }, { @@ -958,7 +951,7 @@ "\n", "****** vitis-run v2024.1 (64-bit)\n", " **** SW Build 5074859 on 2024-05-20-23:21:20\n", - " **** Start of session at: Tue May 5 17:21:52 2026\n", + " **** Start of session at: Tue May 5 18:06:10 2026\n", " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", "\n", @@ -968,17 +961,17 @@ " **** SW Build 5069499 on May 21 2024\n", " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Tue May 5 17:21:52 2026\n", + " **** Start of session at: Tue May 5 18:06:11 2026\n", " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", "\n", "source /tools/Xilinx/Vitis_HLS/2024.1/scripts/vitis_hls/hls.tcl -notrace\n", - "INFO: [HLS 200-10] For user 'b' on host 'b-comp' (Linux_x86_64 version 6.12.64-1-MANJARO) on Tue May 05 17:21:54 IST 2026\n", + "INFO: [HLS 200-10] For user 'b' on host 'b-comp' (Linux_x86_64 version 6.12.64-1-MANJARO) on Tue May 05 18:06:12 IST 2026\n", "INFO: [HLS 200-10] On os \"Manjaro Linux\"\n", "INFO: [HLS 200-10] In directory '/home/b/Physics/hls4ml/examples/snn_example/test'\n", "Sourcing Tcl script '/home/b/Physics/hls4ml/examples/snn_example/test/build_prj.tcl'\n", "INFO: [HLS 200-1510] Running: open_project -reset test_prj \n", - "INFO: [HLS 200-10] Opening and resetting project '/home/b/Physics/hls4ml/examples/snn_example/test/test_prj'.\n", + "INFO: [HLS 200-10] Creating and opening project '/home/b/Physics/hls4ml/examples/snn_example/test/test_prj'.\n", "INFO: [HLS 200-1510] Running: set_top test \n", "INFO: [HLS 200-1510] Running: add_files firmware/test.cpp -cflags -std=c++0x \n", "INFO: [HLS 200-10] Adding design file 'firmware/test.cpp' to the project\n", @@ -1035,11 +1028,11 @@ "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", "INFO: [SIM 211-1] CSim done with 0 errors.\n", "INFO: [SIM 211-3] *************** CSIM finish ***************\n", - "INFO: [HLS 200-2161] Finished Command csim_design Elapsed time: 00:00:04; Allocated memory: 0.031 MB.\n", - "***** C SIMULATION COMPLETED IN 0h0m4s *****\n", + "INFO: [HLS 200-2161] Finished Command csim_design Elapsed time: 00:00:03; Allocated memory: 0.047 MB.\n", + "***** C SIMULATION COMPLETED IN 0h0m3s *****\n", "***** C/RTL SYNTHESIS *****\n", "INFO: [HLS 200-1510] Running: csynth_design \n", - "INFO: [HLS 200-111] Finished File checks and directory preparation: CPU user time: 0.04 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.05 seconds; current allocated memory: 326.730 MB.\n", + "INFO: [HLS 200-111] Finished File checks and directory preparation: CPU user time: 0.05 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 326.793 MB.\n", "INFO: [HLS 200-10] Analyzing design file 'firmware/test.cpp' ... \n", "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:33:9)\n", "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:107:9)\n", @@ -1081,7 +1074,7 @@ "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_code_gen.h:17:38)\n", "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_code_gen.h:18:60)\n", "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_code_gen.h:19:58)\n", - "INFO: [HLS 200-111] Finished Source Code Analysis and Preprocessing: CPU user time: 4.72 seconds. CPU system time: 0.9 seconds. Elapsed time: 5.65 seconds; current allocated memory: 331.730 MB.\n", + "INFO: [HLS 200-111] Finished Source Code Analysis and Preprocessing: CPU user time: 4.27 seconds. CPU system time: 0.9 seconds. Elapsed time: 5.25 seconds; current allocated memory: 331.766 MB.\n", "INFO: [HLS 200-777] Using interface defaults for 'Vivado' flow target.\n", "INFO: [HLS 200-1995] There were 5,130 instructions in the design after the 'Compile/Link' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", "INFO: [HLS 200-1995] There were 3,258 instructions in the design after the 'Unroll/Inline (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", @@ -1114,20 +1107,20 @@ "INFO: [HLS 214-131] Inlining function 'void nnet::data_prepare, 8u>, config4>(hls::stream, 8u>, 0>&, nnet::array, 8u>::value_type*) (.4)' into 'void nnet::dense, 8u>, nnet::array, 2u>, config4>(hls::stream, 8u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:93:2)\n", "INFO: [HLS 214-131] Inlining function 'void nnet::res_write, 2u>, config4>(nnet::array, 2u>::value_type*, hls::stream, 2u>, 0>&) (.1)' into 'void nnet::dense, 8u>, nnet::array, 2u>, config4>(hls::stream, 8u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:100:5)\n", "WARNING: [HLS 214-435] A depth specification is required for AXIS interface port 'layer5_out' for cosimulation. (firmware/test.cpp:10:0)\n", - "INFO: [HLS 214-291] Loop 'VITIS_LOOP_197_3' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_snn_readout.h:197:31)\n", - "INFO: [HLS 214-291] Loop 'VITIS_LOOP_183_2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_snn_readout.h:183:27)\n", - "INFO: [HLS 214-291] Loop 'VITIS_LOOP_170_1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_snn_readout.h:170:27)\n", + "INFO: [HLS 214-291] Loop 'VITIS_LOOP_199_3' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_snn_readout.h:199:31)\n", + "INFO: [HLS 214-291] Loop 'VITIS_LOOP_185_2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_snn_readout.h:185:27)\n", + "INFO: [HLS 214-291] Loop 'VITIS_LOOP_172_1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_snn_readout.h:172:27)\n", "INFO: [HLS 214-291] Loop 'Result' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:64:5)\n", "INFO: [HLS 214-291] Loop 'Accum1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:54:5)\n", "INFO: [HLS 214-291] Loop 'Accum2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:56:9)\n", "INFO: [HLS 214-291] Loop 'ResetAccum' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:48:5)\n", "INFO: [HLS 214-291] Loop 'Product1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:37:5)\n", "INFO: [HLS 214-291] Loop 'Product2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:40:9)\n", - "INFO: [HLS 214-291] Loop 'VITIS_LOOP_115_2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_lif_neuron.h:115:31)\n", - "INFO: [HLS 214-291] Loop 'VITIS_LOOP_88_1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_lif_neuron.h:88:22)\n", - "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_197_3' (firmware/nnet_utils/nnet_snn_readout.h:197:31) in function 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>' completely with a factor of 2 (firmware/nnet_utils/nnet_snn_readout.h:157:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_183_2' (firmware/nnet_utils/nnet_snn_readout.h:183:27) in function 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>' completely with a factor of 1 (firmware/nnet_utils/nnet_snn_readout.h:157:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_170_1' (firmware/nnet_utils/nnet_snn_readout.h:170:27) in function 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>' completely with a factor of 2 (firmware/nnet_utils/nnet_snn_readout.h:157:0)\n", + "INFO: [HLS 214-291] Loop 'VITIS_LOOP_119_2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_lif_neuron.h:119:31)\n", + "INFO: [HLS 214-291] Loop 'VITIS_LOOP_91_1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_lif_neuron.h:91:22)\n", + "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_199_3' (firmware/nnet_utils/nnet_snn_readout.h:199:31) in function 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>' completely with a factor of 2 (firmware/nnet_utils/nnet_snn_readout.h:158:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_185_2' (firmware/nnet_utils/nnet_snn_readout.h:185:27) in function 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>' completely with a factor of 1 (firmware/nnet_utils/nnet_snn_readout.h:158:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_172_1' (firmware/nnet_utils/nnet_snn_readout.h:172:27) in function 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>' completely with a factor of 2 (firmware/nnet_utils/nnet_snn_readout.h:158:0)\n", "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 8u>, nnet::array, 2u>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 8u>, nnet::array, 2u>, config4>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", @@ -1136,8 +1129,8 @@ "INFO: [HLS 214-186] Unrolling loop 'ResetAccum' (firmware/nnet_utils/nnet_dense_latency.h:48:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_115_2' (firmware/nnet_utils/nnet_lif_neuron.h:115:31) in function 'nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>' completely with a factor of 8 (firmware/nnet_utils/nnet_lif_neuron.h:77:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_88_1' (firmware/nnet_utils/nnet_lif_neuron.h:88:22) in function 'nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>' completely with a factor of 8 (firmware/nnet_utils/nnet_lif_neuron.h:77:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_119_2' (firmware/nnet_utils/nnet_lif_neuron.h:119:31) in function 'nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>' completely with a factor of 8 (firmware/nnet_utils/nnet_lif_neuron.h:79:0)\n", + "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_91_1' (firmware/nnet_utils/nnet_lif_neuron.h:91:22) in function 'nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>' completely with a factor of 8 (firmware/nnet_utils/nnet_lif_neuron.h:79:0)\n", "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 2u>, nnet::array, 8u>, config2>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 2u>, nnet::array, 8u>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", @@ -1147,14 +1140,14 @@ "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(config2::accum_t)' into 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-178] Inlining function 'nnet::array, 8u>::operator[](unsigned long)' into 'void nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>(hls::stream, 8u>, 0>&, hls::stream, 8u>, 0>&, config3::beta_t const*, config3::threshold_t const*)' (firmware/nnet_utils/nnet_lif_neuron.h:77:0)\n", + "INFO: [HLS 214-178] Inlining function 'nnet::array, 8u>::operator[](unsigned long)' into 'void nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>(hls::stream, 8u>, 0>&, hls::stream, 8u>, 0>&, config3::beta_t const*, config3::threshold_t const*)' (firmware/nnet_utils/nnet_lif_neuron.h:79:0)\n", "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(config4::accum_t)' into 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-178] Inlining function 'nnet::array, 2u>::operator[](unsigned long)' into 'void nnet::snn_readout, 2u>, nnet::array, 1u>, config5>(hls::stream, 2u>, 0>&, hls::stream, 1u>, 0>&)' (firmware/nnet_utils/nnet_snn_readout.h:157:0)\n", - "INFO: [HLS 214-178] Inlining function 'nnet::array, 1u>::operator[](unsigned long)' into 'void nnet::snn_readout, 2u>, nnet::array, 1u>, config5>(hls::stream, 2u>, 0>&, hls::stream, 1u>, 0>&)' (firmware/nnet_utils/nnet_snn_readout.h:157:0)\n", + "INFO: [HLS 214-178] Inlining function 'nnet::array, 2u>::operator[](unsigned long)' into 'void nnet::snn_readout, 2u>, nnet::array, 1u>, config5>(hls::stream, 2u>, 0>&, hls::stream, 1u>, 0>&)' (firmware/nnet_utils/nnet_snn_readout.h:158:0)\n", + "INFO: [HLS 214-178] Inlining function 'nnet::array, 1u>::operator[](unsigned long)' into 'void nnet::snn_readout, 2u>, nnet::array, 1u>, config5>(hls::stream, 2u>, 0>&, hls::stream, 1u>, 0>&)' (firmware/nnet_utils/nnet_snn_readout.h:158:0)\n", "INFO: [HLS 214-248] Applying array_partition to 'b2': Complete partitioning on dimension 1. (firmware/weights/b2.h:12:0)\n", "INFO: [HLS 214-248] Applying array_partition to 'b4': Complete partitioning on dimension 1. (firmware/weights/b4.h:12:0)\n", - "INFO: [HLS 214-248] Applying array_partition to '_ZZN4nnet11snn_readoutINS_5arrayI8ap_fixedILi8ELi4EL9ap_q_mode5EL9ap_o_mode3ELi0EELj2EEENS1_I6ap_intILi8EELj1EEE7config5EEvRN3hls6streamIT_Li0EEERNSC_IT0_Li0EEEE3mem': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_snn_readout.h:162:0)\n", - "INFO: [HLS 214-248] Applying array_partition to '_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi8ELi4EL9ap_q_mode5EL9ap_o_mode3ELi0EELj8EEES6_7config3EEvRN3hls6streamIT_Li0EEERNS9_IT0_Li0EEEPKNT1_6beta_tEPKNSG_11threshold_tEE3mem': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_lif_neuron.h:80:0)\n", + "INFO: [HLS 214-248] Applying array_partition to '_ZZN4nnet11snn_readoutINS_5arrayI8ap_fixedILi8ELi4EL9ap_q_mode5EL9ap_o_mode3ELi0EELj2EEENS1_I6ap_intILi8EELj1EEE7config5EEvRN3hls6streamIT_Li0EEERNSC_IT0_Li0EEEE3mem': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_snn_readout.h:164:0)\n", + "INFO: [HLS 214-248] Applying array_partition to '_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi8ELi4EL9ap_q_mode5EL9ap_o_mode3ELi0EELj8EEES6_7config3EEvRN3hls6streamIT_Li0EEERNS9_IT0_Li0EEEPKNT1_6beta_tEPKNSG_11threshold_tEE3mem': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_lif_neuron.h:83:0)\n", "INFO: [HLS 214-248] Applying array_partition to 'data': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_dense_stream.h:87:30)\n", "INFO: [HLS 214-248] Applying array_partition to 'res': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_dense_stream.h:90:29)\n", "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer4_out' with compact=bit mode in 16-bits (firmware/test.cpp:38:24)\n", @@ -1162,20 +1155,20 @@ "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer2_out' with compact=bit mode in 64-bits (firmware/test.cpp:32:24)\n", "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", - "INFO: [HLS 200-111] Finished Compiling Optimization and Transform: CPU user time: 2.49 seconds. CPU system time: 0.5 seconds. Elapsed time: 7.28 seconds; current allocated memory: 341.820 MB.\n", - "INFO: [HLS 200-111] Finished Checking Pragmas: CPU user time: 0 seconds. CPU system time: 0 seconds. Elapsed time: 0 seconds; current allocated memory: 341.820 MB.\n", + "INFO: [HLS 200-111] Finished Compiling Optimization and Transform: CPU user time: 2.47 seconds. CPU system time: 0.51 seconds. Elapsed time: 7.27 seconds; current allocated memory: 341.859 MB.\n", + "INFO: [HLS 200-111] Finished Checking Pragmas: CPU user time: 0 seconds. CPU system time: 0 seconds. Elapsed time: 0 seconds; current allocated memory: 341.859 MB.\n", "INFO: [HLS 200-10] Starting code transformations ...\n", - "INFO: [HLS 200-111] Finished Standard Transforms: CPU user time: 0.02 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.02 seconds; current allocated memory: 343.133 MB.\n", + "INFO: [HLS 200-111] Finished Standard Transforms: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 343.133 MB.\n", "INFO: [HLS 200-10] Checking synthesizability ...\n", - "INFO: [HLS 200-111] Finished Checking Synthesizability: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 345.484 MB.\n", + "INFO: [HLS 200-111] Finished Checking Synthesizability: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 345.484 MB.\n", "INFO: [XFORM 203-712] Applying dataflow to function 'test' (firmware/test.cpp:8), detected/extracted 4 process function(s): \n", "\t 'nnet::dense, 2u>, nnet::array, 8u>, config2>'\n", "\t 'nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>'\n", "\t 'nnet::dense, 8u>, nnet::array, 2u>, config4>'\n", "\t 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>'.\n", "INFO: [XFORM 203-11] Balancing expressions in function 'nnet::dense_latency_wrapper, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' (firmware/nnet_utils/nnet_dense_stream.h:18:1)...14 expression(s) balanced.\n", - "INFO: [HLS 200-111] Finished Loop, function and other optimizations: CPU user time: 0.07 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.09 seconds; current allocated memory: 369.344 MB.\n", - "INFO: [HLS 200-111] Finished Architecture Synthesis: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.07 seconds; current allocated memory: 419.223 MB.\n", + "INFO: [HLS 200-111] Finished Loop, function and other optimizations: CPU user time: 0.06 seconds. CPU system time: 0.02 seconds. Elapsed time: 0.08 seconds; current allocated memory: 369.223 MB.\n", + "INFO: [HLS 200-111] Finished Architecture Synthesis: CPU user time: 0.06 seconds. CPU system time: 0 seconds. Elapsed time: 0.07 seconds; current allocated memory: 419.227 MB.\n", "INFO: [HLS 200-10] Starting hardware synthesis ...\n", "INFO: [HLS 200-10] Synthesizing 'test' ...\n", "WARNING: [SYN 201-103] Legalizing function name 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config2>' to 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s'.\n", @@ -1192,26 +1185,26 @@ "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config2>'.\n", "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config2>'\n", "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.06 seconds. CPU system time: 0.03 seconds. Elapsed time: 0.09 seconds; current allocated memory: 419.223 MB.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.07 seconds. CPU system time: 0.02 seconds. Elapsed time: 0.08 seconds; current allocated memory: 419.227 MB.\n", "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", "INFO: [BIND 205-101] Exploring resource sharing.\n", "INFO: [BIND 205-101] Binding ...\n", "INFO: [BIND 205-100] Starting global binding ...\n", "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.03 seconds; current allocated memory: 419.223 MB.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 419.227 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [SCHED 204-11] Starting scheduling ...\n", "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 419.992 MB.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.03 seconds; current allocated memory: 419.996 MB.\n", "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", "INFO: [BIND 205-101] Exploring resource sharing.\n", "INFO: [BIND 205-101] Binding ...\n", "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 419.992 MB.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 419.996 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [HLS 200-42] -- Implementing module 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", @@ -1219,13 +1212,13 @@ "INFO: [SCHED 204-61] Pipelining function 'lif_neuron,array,8u>,config3>'.\n", "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 2, function 'lif_neuron,array,8u>,config3>'\n", "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.06 seconds. CPU system time: 0 seconds. Elapsed time: 0.07 seconds; current allocated memory: 420.418 MB.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.06 seconds. CPU system time: 0 seconds. Elapsed time: 0.06 seconds; current allocated memory: 420.438 MB.\n", "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", "INFO: [BIND 205-101] Exploring resource sharing.\n", "INFO: [BIND 205-101] Binding ...\n", "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 420.418 MB.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 420.438 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [HLS 200-42] -- Implementing module 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", @@ -1233,25 +1226,25 @@ "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config4>'.\n", "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config4>'\n", "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.05 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.06 seconds; current allocated memory: 420.727 MB.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.05 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 420.723 MB.\n", "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", "INFO: [BIND 205-101] Exploring resource sharing.\n", "INFO: [BIND 205-101] Binding ...\n", "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 420.922 MB.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 420.918 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [SCHED 204-11] Starting scheduling ...\n", "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.03 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.02 seconds; current allocated memory: 421.859 MB.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 421.867 MB.\n", "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", "INFO: [BIND 205-101] Exploring resource sharing.\n", "INFO: [BIND 205-101] Binding ...\n", "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 421.859 MB.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.02 seconds; current allocated memory: 421.867 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [HLS 200-42] -- Implementing module 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", @@ -1259,13 +1252,13 @@ "INFO: [SCHED 204-61] Pipelining function 'snn_readout, 2u>, array, 1u>, config5>'.\n", "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 2, function 'snn_readout, 2u>, array, 1u>, config5>'\n", "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.03 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.04 seconds; current allocated memory: 422.281 MB.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 422.297 MB.\n", "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", "INFO: [BIND 205-101] Exploring resource sharing.\n", "INFO: [BIND 205-101] Binding ...\n", "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 422.281 MB.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 422.297 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [HLS 200-42] -- Implementing module 'test' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", @@ -1274,24 +1267,24 @@ "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer2_out (from dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_U0 to lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0) to 2 to improve performance and/or avoid deadlocks.\n", "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer3_out (from lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0 to dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0) to 2 to improve performance and/or avoid deadlocks.\n", "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer4_out (from dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0 to snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0) to 2 to improve performance and/or avoid deadlocks.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 422.516 MB.\n", + "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 422.508 MB.\n", "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", "INFO: [BIND 205-101] Exploring resource sharing.\n", "INFO: [BIND 205-101] Binding ...\n", "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 422.516 MB.\n", + "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 422.508 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [RTGEN 206-100] Generating core module 'mul_8s_5s_12_1_1': 1 instance(s).\n", "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 422.594 MB.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 422.578 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.05 seconds; current allocated memory: 424.176 MB.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 424.164 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [HLS 200-10] -- Generating RTL for module 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", @@ -1307,17 +1300,17 @@ "INFO: [HLS 200-1030] Apply Unified Pipeline Control on module 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s' pipeline 'lif_neuron,array,8u>,config3>' pipeline type 'function pipeline'\n", "INFO: [RTGEN 206-100] Generating core module 'mul_8s_5ns_12_1_1': 8 instance(s).\n", "INFO: [RTGEN 206-100] Finished creating RTL model for 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0 seconds. Elapsed time: 0.06 seconds; current allocated memory: 425.578 MB.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.06 seconds; current allocated memory: 425.570 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.07 seconds; current allocated memory: 428.047 MB.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0 seconds. Elapsed time: 0.07 seconds; current allocated memory: 428.039 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.07 seconds; current allocated memory: 429.996 MB.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.08 seconds; current allocated memory: 429.988 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [HLS 200-10] -- Generating RTL for module 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", @@ -1326,7 +1319,7 @@ "WARNING: [RTGEN 206-101] Register 'ts' is power-on initialization.\n", "INFO: [HLS 200-1030] Apply Unified Pipeline Control on module 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s' pipeline 'snn_readout, 2u>, array, 1u>, config5>' pipeline type 'function pipeline'\n", "INFO: [RTGEN 206-100] Finished creating RTL model for 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 430.828 MB.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 430.836 MB.\n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", "INFO: [HLS 200-10] -- Generating RTL for module 'test' \n", "INFO: [HLS 200-10] ----------------------------------------------------------------\n", @@ -1341,13 +1334,13 @@ "INFO: [RTMG 210-285] Implementing FIFO 'start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0_U(test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0)' using Shift Registers.\n", "INFO: [RTMG 210-285] Implementing FIFO 'start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0_U(test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0)' using Shift Registers.\n", "INFO: [RTMG 210-285] Implementing FIFO 'start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_U(test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0)' using Shift Registers.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.07 seconds; current allocated memory: 431.957 MB.\n", - "INFO: [HLS 200-111] Finished Generating all RTL models: CPU user time: 0.13 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.14 seconds; current allocated memory: 434.414 MB.\n", - "INFO: [HLS 200-111] Finished Updating report files: CPU user time: 0.27 seconds. CPU system time: 0.02 seconds. Elapsed time: 0.29 seconds; current allocated memory: 439.723 MB.\n", + "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.04 seconds. CPU system time: 0.03 seconds. Elapsed time: 0.07 seconds; current allocated memory: 431.961 MB.\n", + "INFO: [HLS 200-111] Finished Generating all RTL models: CPU user time: 0.13 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.14 seconds; current allocated memory: 434.301 MB.\n", + "INFO: [HLS 200-111] Finished Updating report files: CPU user time: 0.3 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.31 seconds; current allocated memory: 439.715 MB.\n", "INFO: [VHDL 208-304] Generating VHDL RTL for test.\n", "INFO: [VLOG 209-307] Generating Verilog RTL for test.\n", "INFO: [HLS 200-789] **** Estimated Fmax: 251.00 MHz\n", - "INFO: [HLS 200-2161] Finished Command csynth_design Elapsed time: 00:00:14; Allocated memory: 113.980 MB.\n", + "INFO: [HLS 200-2161] Finished Command csynth_design Elapsed time: 00:00:14; Allocated memory: 113.926 MB.\n", "***** C/RTL SYNTHESIS COMPLETED IN 0h0m14s *****\n", "***** C/RTL SIMULATION *****\n", "INFO: [HLS 200-1510] Running: add_files -tb test_test.cpp -cflags -std=c++0x -DRTL_SIM \n", @@ -1374,7 +1367,7 @@ "INFO: [COSIM 212-333] Generating C post check test bench ...\n", "INFO: [COSIM 212-12] Generating RTL test bench ...\n", "INFO: [COSIM 212-1] *** C/RTL co-simulation file generation completed. ***\n", - "INFO: [HLS 200-2161] Finished Command cosim_design Elapsed time: 00:00:12; Allocated memory: 11.586 MB.\n", + "INFO: [HLS 200-2161] Finished Command cosim_design Elapsed time: 00:00:11; Allocated memory: 11.648 MB.\n", "INFO: [HLS 200-1510] Running: source /home/b/Physics/hls4ml/examples/snn_example/test/project.tcl\n", "INFO: [HLS 200-1510] Running: source run_sim.tcl\n", "INFO: [HLS 200-1510] Running: source check_sim.tcl\n", @@ -1504,7 +1497,7 @@ " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Tue May 5 17:22:31 2026\n", + " **** Start of session at: Tue May 5 18:06:48 2026\n", " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", "\n", @@ -1575,7 +1568,7 @@ "////////////////////////////////////////////////////////////////////////////////////\n", "$finish called at time : 262500 ps : File \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test.autotb.v\" Line 249\n", "## quit\n", - "INFO: [Common 17-206] Exiting xsim at Tue May 5 17:22:34 2026...\n", + "INFO: [Common 17-206] Exiting xsim at Tue May 5 18:06:51 2026...\n", "WARNING: [HLS 200-2011] Cannot find the 'zip' utility on this system. This is required for cosimulation.\n", "INFO: [COSIM 212-316] Starting C post checking ...\n", "INFO: Unable to open input/predictions file, using default input.\n", @@ -1587,7 +1580,7 @@ "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", "INFO:\n", - "Report time : Tue May 5 05:22:26 PM IST 2026.\n", + "Report time : Tue May 5 06:06:43 PM IST 2026.\n", "Solution : solution1.\n", "Simulation tool : xsim.\n", "\n", @@ -1600,7 +1593,7 @@ "| Verilog| Pass| NA| NA| NA| NA| NA| NA| NA|\n", "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", "\n", - "***** C/RTL SIMULATION COMPLETED IN 0h0m20s *****\n", + "***** C/RTL SIMULATION COMPLETED IN 0h0m19s *****\n", "***** C/RTL VALIDATION *****\n", "INFO: Test PASSED\n", "***** EXPORT IP *****\n", @@ -1611,7 +1604,7 @@ " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Tue May 5 17:22:35 2026\n", + " **** Start of session at: Tue May 5 18:06:52 2026\n", " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", "\n", @@ -1634,7 +1627,7 @@ "Generating sysgen info xml from json file\n", "INFO: Created IP /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/component.xml\n", "INFO: Created IP archive /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/xilinx_com_hls_test_1_0.zip\n", - "INFO: [Common 17-206] Exiting Vivado at Tue May 5 17:22:42 2026...\n", + "INFO: [Common 17-206] Exiting Vivado at Tue May 5 18:06:59 2026...\n", "INFO: [HLS 200-802] Generated output file test_prj/solution1/impl/export.zip\n", "INFO: [HLS 200-2161] Finished Command export_design Elapsed time: 00:00:18; Allocated memory: 0.000 MB.\n", "***** EXPORT IP COMPLETED IN 0h0m18s *****\n", @@ -1644,7 +1637,7 @@ " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Tue May 5 17:22:53 2026\n", + " **** Start of session at: Tue May 5 18:07:10 2026\n", " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", "\n", @@ -1673,9 +1666,9 @@ "INFO: [Common 17-349] Got license for feature 'Synthesis' and/or device 'xczu7ev'\n", "INFO: [Synth 8-7079] Multithreading enabled for synth_design using a maximum of 4 processes.\n", "INFO: [Synth 8-7078] Launching helper process for spawning children vivado processes\n", - "INFO: [Synth 8-7075] Helper process launched with PID 28461\n", + "INFO: [Synth 8-7075] Helper process launched with PID 34703\n", "---------------------------------------------------------------------------------\n", - "Starting Synthesize : Time (s): cpu = 00:00:03 ; elapsed = 00:00:03 . Memory (MB): peak = 1875.949 ; gain = 426.633 ; free physical = 738 ; free virtual = 21845\n", + "Starting Synthesize : Time (s): cpu = 00:00:02 ; elapsed = 00:00:03 . Memory (MB): peak = 1875.867 ; gain = 425.633 ; free physical = 203 ; free virtual = 21711\n", "---------------------------------------------------------------------------------\n", "INFO: [Synth 8-6157] synthesizing module 'test' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test.v:9]\n", "INFO: [Synth 8-6157] synthesizing module 'test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s.v:9]\n", @@ -1777,10 +1770,10 @@ "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", "---------------------------------------------------------------------------------\n", - "Finished Synthesize : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1958.918 ; gain = 509.602 ; free physical = 761 ; free virtual = 21890\n", + "Finished Synthesize : Time (s): cpu = 00:00:03 ; elapsed = 00:00:04 . Memory (MB): peak = 1958.836 ; gain = 508.602 ; free physical = 199 ; free virtual = 21642\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Constraint Validation : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1973.762 ; gain = 524.445 ; free physical = 754 ; free virtual = 21883\n", + "Finished Constraint Validation : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1973.680 ; gain = 523.445 ; free physical = 229 ; free virtual = 21630\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Loading Part and Timing Information\n", @@ -1789,7 +1782,7 @@ "INFO: [Synth 8-6742] Reading net delay rules and data\n", "INFO: [Device 21-403] Loading part xczu7ev-ffvc1156-2-e\n", "---------------------------------------------------------------------------------\n", - "Finished Loading Part and Timing Information : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1990.672 ; gain = 541.355 ; free physical = 747 ; free virtual = 21875\n", + "Finished Loading Part and Timing Information : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1990.590 ; gain = 540.355 ; free physical = 220 ; free virtual = 21621\n", "---------------------------------------------------------------------------------\n", "INFO: [Synth 8-802] inferred FSM for state register 'state_reg' in module 'test_regslice_both'\n", "INFO: [Synth 8-4490] FSM extraction disabled for register 'ap_CS_fsm_reg' through user attribute\n", @@ -1812,7 +1805,7 @@ "---------------------------------------------------------------------------------------------------\n", "INFO: [Synth 8-3354] encoded FSM with state register 'state_reg' using encoding 'sequential' in module 'test_regslice_both__parameterized0'\n", "---------------------------------------------------------------------------------\n", - "Finished RTL Optimization Phase 2 : Time (s): cpu = 00:00:05 ; elapsed = 00:00:05 . Memory (MB): peak = 1990.672 ; gain = 541.355 ; free physical = 760 ; free virtual = 21888\n", + "Finished RTL Optimization Phase 2 : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1990.590 ; gain = 540.355 ; free physical = 207 ; free virtual = 21609\n", "---------------------------------------------------------------------------------\n", "No constraint files found.\n", "---------------------------------------------------------------------------------\n", @@ -1891,20 +1884,20 @@ "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", "---------------------------------------------------------------------------------\n", - "Finished Cross Boundary and Area Optimization : Time (s): cpu = 00:00:10 ; elapsed = 00:00:10 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 216 ; free virtual = 21078\n", + "Finished Cross Boundary and Area Optimization : Time (s): cpu = 00:00:09 ; elapsed = 00:00:10 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 177 ; free virtual = 20781\n", "---------------------------------------------------------------------------------\n", "No constraint files found.\n", "---------------------------------------------------------------------------------\n", "Start Timing Optimization\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Timing Optimization : Time (s): cpu = 00:00:10 ; elapsed = 00:00:10 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 225 ; free virtual = 21090\n", + "Finished Timing Optimization : Time (s): cpu = 00:00:09 ; elapsed = 00:00:10 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 174 ; free virtual = 20783\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Technology Mapping\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Technology Mapping : Time (s): cpu = 00:00:10 ; elapsed = 00:00:10 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 229 ; free virtual = 21095\n", + "Finished Technology Mapping : Time (s): cpu = 00:00:09 ; elapsed = 00:00:10 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 178 ; free virtual = 20784\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start IO Insertion\n", @@ -1922,37 +1915,37 @@ "Finished Final Netlist Cleanup\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished IO Insertion : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21121\n", + "Finished IO Insertion : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Renaming Generated Instances\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Renaming Generated Instances : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21121\n", + "Finished Renaming Generated Instances : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Rebuilding User Hierarchy\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Rebuilding User Hierarchy : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21120\n", + "Finished Rebuilding User Hierarchy : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Renaming Generated Ports\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Renaming Generated Ports : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21121\n", + "Finished Renaming Generated Ports : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Handling Custom Attributes\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Handling Custom Attributes : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21121\n", + "Finished Handling Custom Attributes : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Renaming Generated Nets\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", - "Finished Renaming Generated Nets : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21121\n", + "Finished Renaming Generated Nets : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", "---------------------------------------------------------------------------------\n", "---------------------------------------------------------------------------------\n", "Start Writing Synthesis Report\n", @@ -2015,30 +2008,30 @@ "|27 | start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_U |test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0 | 9|\n", "+------+-----------------------------------------------------------------------------------------+------------------------------------------------------------------------------------+------+\n", "---------------------------------------------------------------------------------\n", - "Finished Writing Synthesis Report : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 228 ; free virtual = 21121\n", + "Finished Writing Synthesis Report : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", "---------------------------------------------------------------------------------\n", "Synthesis finished with 0 errors, 0 critical warnings and 55 warnings.\n", - "Synthesis Optimization Runtime : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.625 ; gain = 1407.309 ; free physical = 231 ; free virtual = 21125\n", - "Synthesis Optimization Complete : Time (s): cpu = 00:00:12 ; elapsed = 00:00:13 . Memory (MB): peak = 2856.633 ; gain = 1407.309 ; free physical = 231 ; free virtual = 21125\n", + "Synthesis Optimization Runtime : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", + "Synthesis Optimization Complete : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.551 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", "INFO: [Project 1-571] Translating synthesized netlist\n", - "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00.01 . Memory (MB): peak = 2856.633 ; gain = 0.000 ; free physical = 483 ; free virtual = 21378\n", + "Netlist sorting complete. Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 2856.551 ; gain = 0.000 ; free physical = 493 ; free virtual = 21089\n", "INFO: [Netlist 29-17] Analyzing 71 Unisim elements for replacement\n", "INFO: [Netlist 29-28] Unisim Transformation completed in 0 CPU seconds\n", "INFO: [Project 1-570] Preparing netlist for logic optimization\n", "INFO: [Opt 31-138] Pushed 0 inverter(s) to 0 load pin(s).\n", - "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 2912.652 ; gain = 0.000 ; free physical = 488 ; free virtual = 21367\n", + "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 2912.570 ; gain = 0.000 ; free physical = 480 ; free virtual = 21076\n", "INFO: [Project 1-111] Unisim Transformation Summary:\n", " A total of 22 instances were transformed.\n", " BUFG => BUFGCE: 1 instance \n", " IBUF => IBUF (IBUFCTRL, INBUF): 21 instances\n", "\n", - "Synth Design complete | Checksum: 8f9a4ab4\n", + "Synth Design complete | Checksum: f20caaa6\n", "INFO: [Common 17-83] Releasing license: Synthesis\n", "61 Infos, 55 Warnings, 0 Critical Warnings and 0 Errors encountered.\n", "synth_design completed successfully\n", - "synth_design: Time (s): cpu = 00:00:16 ; elapsed = 00:00:15 . Memory (MB): peak = 2912.652 ; gain = 1466.324 ; free physical = 487 ; free virtual = 21354\n", - "INFO: [Common 17-2834] synth_design peak Physical Memory [PSS] (MB): overall = 2666.472; main = 2389.730; forked = 454.161\n", - "INFO: [Common 17-2834] synth_design peak Virtual Memory [VSS] (MB): overall = 3890.047; main = 2912.656; forked = 1033.418\n", + "synth_design: Time (s): cpu = 00:00:15 ; elapsed = 00:00:14 . Memory (MB): peak = 2912.570 ; gain = 1466.324 ; free physical = 480 ; free virtual = 21076\n", + "INFO: [Common 17-2834] synth_design peak Physical Memory [PSS] (MB): overall = 2652.063; main = 2381.784; forked = 443.151\n", + "INFO: [Common 17-2834] synth_design peak Virtual Memory [VSS] (MB): overall = 3883.590; main = 2912.574; forked = 1027.043\n", "# opt_design -retarget -propconst -sweep -bram_power_opt -shift_register_opt\n", "Command: opt_design -retarget -propconst -sweep -bram_power_opt -shift_register_opt\n", "Attempting to get a license for feature 'Implementation' and/or device 'xczu7ev'\n", @@ -2050,100 +2043,100 @@ "INFO: [Project 1-461] DRC finished with 0 Errors\n", "INFO: [Project 1-462] Please refer to the DRC report (report_drc) for more information.\n", "\n", - "Time (s): cpu = 00:00:01 ; elapsed = 00:00:00.78 . Memory (MB): peak = 2976.684 ; gain = 64.031 ; free physical = 483 ; free virtual = 21342\n", + "Time (s): cpu = 00:00:01 ; elapsed = 00:00:00.73 . Memory (MB): peak = 2976.602 ; gain = 64.031 ; free physical = 490 ; free virtual = 21087\n", "\n", "Starting Cache Timing Information Task\n", "INFO: [Timing 38-35] Done setting XDC timing constraints.\n", - "Ending Cache Timing Information Task | Checksum: 20489a5a7\n", + "Ending Cache Timing Information Task | Checksum: 266fc0599\n", "\n", - "Time (s): cpu = 00:00:06 ; elapsed = 00:00:06 . Memory (MB): peak = 3524.551 ; gain = 547.867 ; free physical = 206 ; free virtual = 20769\n", + "Time (s): cpu = 00:00:06 ; elapsed = 00:00:06 . Memory (MB): peak = 3523.734 ; gain = 547.133 ; free physical = 156 ; free virtual = 20652\n", "\n", "Starting Logic Optimization Task\n", "\n", "Phase 1 Initialization\n", "\n", "Phase 1.1 Core Generation And Design Setup\n", - "Phase 1.1 Core Generation And Design Setup | Checksum: 20489a5a7\n", + "Phase 1.1 Core Generation And Design Setup | Checksum: 266fc0599\n", "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 369 ; free virtual = 20340\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 235 ; free virtual = 20448\n", "\n", "Phase 1.2 Setup Constraints And Sort Netlist\n", - "Phase 1.2 Setup Constraints And Sort Netlist | Checksum: 20489a5a7\n", + "Phase 1.2 Setup Constraints And Sort Netlist | Checksum: 266fc0599\n", "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 369 ; free virtual = 20340\n", - "Phase 1 Initialization | Checksum: 20489a5a7\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 235 ; free virtual = 20448\n", + "Phase 1 Initialization | Checksum: 266fc0599\n", "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 369 ; free virtual = 20340\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 235 ; free virtual = 20448\n", "\n", "Phase 2 Timer Update And Timing Data Collection\n", "\n", "Phase 2.1 Timer Update\n", - "Phase 2.1 Timer Update | Checksum: 20489a5a7\n", + "Phase 2.1 Timer Update | Checksum: 266fc0599\n", "\n", - "Time (s): cpu = 00:00:00.02 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 366 ; free virtual = 20336\n", + "Time (s): cpu = 00:00:00.02 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 234 ; free virtual = 20448\n", "\n", "Phase 2.2 Timing Data Collection\n", - "Phase 2.2 Timing Data Collection | Checksum: 20489a5a7\n", + "Phase 2.2 Timing Data Collection | Checksum: 266fc0599\n", "\n", - "Time (s): cpu = 00:00:00.02 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 365 ; free virtual = 20335\n", - "Phase 2 Timer Update And Timing Data Collection | Checksum: 20489a5a7\n", + "Time (s): cpu = 00:00:00.02 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 234 ; free virtual = 20448\n", + "Phase 2 Timer Update And Timing Data Collection | Checksum: 266fc0599\n", "\n", - "Time (s): cpu = 00:00:00.02 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 365 ; free virtual = 20335\n", + "Time (s): cpu = 00:00:00.02 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 234 ; free virtual = 20448\n", "\n", "Phase 3 Retarget\n", "INFO: [Opt 31-1834] Total Chains To Be Transformed Were: 0 AND Number of Transformed insts Created are: 0\n", "INFO: [Opt 31-138] Pushed 1 inverter(s) to 44 load pin(s).\n", "INFO: [Opt 31-49] Retargeted 0 cell(s).\n", - "Phase 3 Retarget | Checksum: 220bc3ccd\n", + "Phase 3 Retarget | Checksum: 21c32dcbf\n", "\n", - "Time (s): cpu = 00:00:00.09 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 359 ; free virtual = 20329\n", - "Retarget | Checksum: 220bc3ccd\n", + "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20447\n", + "Retarget | Checksum: 21c32dcbf\n", "INFO: [Opt 31-389] Phase Retarget created 0 cells and removed 1 cells\n", "\n", "Phase 4 Constant propagation\n", "INFO: [Opt 31-138] Pushed 0 inverter(s) to 0 load pin(s).\n", - "Phase 4 Constant propagation | Checksum: 29d37246d\n", + "Phase 4 Constant propagation | Checksum: 2c793b24c\n", "\n", - "Time (s): cpu = 00:00:00.1 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 390 ; free virtual = 20323\n", - "Constant propagation | Checksum: 29d37246d\n", + "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20447\n", + "Constant propagation | Checksum: 2c793b24c\n", "INFO: [Opt 31-389] Phase Constant propagation created 0 cells and removed 0 cells\n", "\n", "Phase 5 Sweep\n", - "Phase 5 Sweep | Checksum: 26e0e4c99\n", + "Phase 5 Sweep | Checksum: 2bb6ebc94\n", "\n", - "Time (s): cpu = 00:00:00.11 ; elapsed = 00:00:00.06 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 465 ; free virtual = 20316\n", - "Sweep | Checksum: 26e0e4c99\n", + "Time (s): cpu = 00:00:00.09 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20447\n", + "Sweep | Checksum: 2bb6ebc94\n", "INFO: [Opt 31-389] Phase Sweep created 0 cells and removed 0 cells\n", "\n", "Phase 6 Shift Register Optimization\n", "INFO: [Opt 31-1064] SRL Remap converted 0 SRLs to 0 registers and converted 0 registers of register chains to 0 SRLs\n", - "Phase 6 Shift Register Optimization | Checksum: 26e0e4c99\n", + "Phase 6 Shift Register Optimization | Checksum: 2bb6ebc94\n", "\n", - "Time (s): cpu = 00:00:00.11 ; elapsed = 00:00:00.06 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 480 ; free virtual = 20320\n", - "Shift Register Optimization | Checksum: 26e0e4c99\n", + "Time (s): cpu = 00:00:00.09 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20447\n", + "Shift Register Optimization | Checksum: 2bb6ebc94\n", "INFO: [Opt 31-389] Phase Shift Register Optimization created 0 cells and removed 0 cells\n", "\n", "Phase 7 Post Processing Netlist\n", - "Phase 7 Post Processing Netlist | Checksum: 26e0e4c99\n", + "Phase 7 Post Processing Netlist | Checksum: 2bb6ebc94\n", "\n", - "Time (s): cpu = 00:00:00.12 ; elapsed = 00:00:00.07 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 500 ; free virtual = 20317\n", - "Post Processing Netlist | Checksum: 26e0e4c99\n", + "Time (s): cpu = 00:00:00.09 ; elapsed = 00:00:00.06 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20447\n", + "Post Processing Netlist | Checksum: 2bb6ebc94\n", "INFO: [Opt 31-389] Phase Post Processing Netlist created 0 cells and removed 0 cells\n", "\n", "Phase 8 Finalization\n", "\n", "Phase 8.1 Finalizing Design Cores and Updating Shapes\n", - "Phase 8.1 Finalizing Design Cores and Updating Shapes | Checksum: 13ee3ebc9\n", + "Phase 8.1 Finalizing Design Cores and Updating Shapes | Checksum: 16582c3b4\n", "\n", - "Time (s): cpu = 00:00:00.18 ; elapsed = 00:00:00.09 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 527 ; free virtual = 20308\n", + "Time (s): cpu = 00:00:00.15 ; elapsed = 00:00:00.08 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20446\n", "\n", "Phase 8.2 Verifying Netlist Connectivity\n", - "Phase 8.2 Verifying Netlist Connectivity | Checksum: 13ee3ebc9\n", + "Phase 8.2 Verifying Netlist Connectivity | Checksum: 16582c3b4\n", "\n", - "Time (s): cpu = 00:00:00.18 ; elapsed = 00:00:00.09 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 527 ; free virtual = 20308\n", - "Phase 8 Finalization | Checksum: 13ee3ebc9\n", + "Time (s): cpu = 00:00:00.15 ; elapsed = 00:00:00.08 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20446\n", + "Phase 8 Finalization | Checksum: 16582c3b4\n", "\n", - "Time (s): cpu = 00:00:00.18 ; elapsed = 00:00:00.09 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 527 ; free virtual = 20308\n", + "Time (s): cpu = 00:00:00.15 ; elapsed = 00:00:00.08 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20446\n", "Opt_design Change Summary\n", "=========================\n", "\n", @@ -2159,35 +2152,35 @@ "-------------------------------------------------------------------------------------------------------------------------\n", "\n", "\n", - "Ending Logic Optimization Task | Checksum: 13ee3ebc9\n", + "Ending Logic Optimization Task | Checksum: 16582c3b4\n", "\n", - "Time (s): cpu = 00:00:00.18 ; elapsed = 00:00:00.09 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 527 ; free virtual = 20308\n", + "Time (s): cpu = 00:00:00.15 ; elapsed = 00:00:00.08 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 232 ; free virtual = 20446\n", "\n", "Starting Power Optimization Task\n", "INFO: [Pwropt 34-132] Skipping clock gating for clocks with a period < 2.00 ns.\n", - "Ending Power Optimization Task | Checksum: 13ee3ebc9\n", + "Ending Power Optimization Task | Checksum: 16582c3b4\n", "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 526 ; free virtual = 20306\n", + "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 232 ; free virtual = 20446\n", "\n", "Starting Final Cleanup Task\n", - "Ending Final Cleanup Task | Checksum: 13ee3ebc9\n", + "Ending Final Cleanup Task | Checksum: 16582c3b4\n", "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 526 ; free virtual = 20306\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 232 ; free virtual = 20446\n", "\n", "Starting Netlist Obfuscation Task\n", - "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 526 ; free virtual = 20306\n", - "Ending Netlist Obfuscation Task | Checksum: 13ee3ebc9\n", + "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 232 ; free virtual = 20446\n", + "Ending Netlist Obfuscation Task | Checksum: 16582c3b4\n", "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3788.426 ; gain = 0.000 ; free physical = 526 ; free virtual = 20306\n", + "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 232 ; free virtual = 20446\n", "INFO: [Common 17-83] Releasing license: Implementation\n", "17 Infos, 0 Warnings, 0 Critical Warnings and 0 Errors encountered.\n", "opt_design completed successfully\n", - "opt_design: Time (s): cpu = 00:00:09 ; elapsed = 00:00:09 . Memory (MB): peak = 3788.426 ; gain = 875.773 ; free physical = 526 ; free virtual = 20306\n", + "opt_design: Time (s): cpu = 00:00:09 ; elapsed = 00:00:09 . Memory (MB): peak = 3792.641 ; gain = 880.070 ; free physical = 232 ; free virtual = 20446\n", "# report_utilization -file vivado_synth.rpt\n", - "INFO: [Common 17-206] Exiting Vivado at Tue May 5 17:23:23 2026...\n", - "***** VIVADO SYNTHESIS COMPLETED IN 0h0m41s *****\n", - "INFO: [HLS 200-112] Total CPU user time: 76.22 seconds. Total CPU system time: 7.18 seconds. Total elapsed time: 101.58 seconds; peak allocated memory: 451.844 MB.\n", - "INFO: [vitis-run 60-791] Total elapsed time: 0h 1m 42s\n", + "INFO: [Common 17-206] Exiting Vivado at Tue May 5 18:07:38 2026...\n", + "***** VIVADO SYNTHESIS COMPLETED IN 0h0m40s *****\n", + "INFO: [HLS 200-112] Total CPU user time: 72.52 seconds. Total CPU system time: 7.1 seconds. Total elapsed time: 98.02 seconds; peak allocated memory: 451.898 MB.\n", + "INFO: [vitis-run 60-791] Total elapsed time: 0h 1m 38s\n", "INFO: [vitis-run 60-1662] Stopping dispatch session having empty uuid.\n", "Implementation report not found.\n", "Timing report not found.\n", From 2490bd80d0c311a74f83fa0f10a46abdfc8c393c Mon Sep 17 00:00:00 2001 From: bmdillon Date: Fri, 8 May 2026 09:47:30 +0100 Subject: [PATCH 12/32] pr bug fix --- hls4ml/converters/pytorch/snn.py | 7 +++++-- test/pytest/test_snn_pytorch.py | 9 ++++++++- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/hls4ml/converters/pytorch/snn.py b/hls4ml/converters/pytorch/snn.py index d0858d49fc..07b8dffa8c 100644 --- a/hls4ml/converters/pytorch/snn.py +++ b/hls4ml/converters/pytorch/snn.py @@ -50,7 +50,10 @@ def _parse_state_reset_policy(class_object): policy = getattr(class_object, 'reset_policy', 'fixed_window') policy = str(policy).lower() if policy not in ['fixed_window', 'tlast', 'host_pulse', 'never']: - raise Exception(f'Unsupported state reset policy "{policy}". Supported: "fixed_window", "tlast", "host_pulse", "never".') + raise Exception( + f'Unsupported state reset policy "{policy}". ' + 'Supported: "fixed_window", "tlast", "host_pulse", "never".' + ) return policy @@ -110,7 +113,7 @@ def parse_snn_readout_layer(operation, layer_name, input_names, input_shapes, no n_classes = input_shapes[0][-1] layer['n_classes'] = int(n_classes) if hasattr(class_object, 'stream_length'): - layer['window_size'] = int(getattr(class_object, 'stream_length')) + layer['window_size'] = int(class_object.stream_length) else: layer['window_size'] = int(getattr(class_object, 'window_size', 1)) layer['class_threshold'] = int(getattr(class_object, 'class_threshold', 1)) diff --git a/test/pytest/test_snn_pytorch.py b/test/pytest/test_snn_pytorch.py index aef819b0f7..3a0bd9e8df 100644 --- a/test/pytest/test_snn_pytorch.py +++ b/test/pytest/test_snn_pytorch.py @@ -33,7 +33,14 @@ def forward(self, x): class SNNReadoutWithResetPolicy(hls4ml.utils.torch.HLS4MLModule): - def __init__(self, n_classes=4, stream_length=7, decision_rule='argmax_spike_count', class_threshold=2, reset_policy='tlast'): + def __init__( + self, + n_classes=4, + stream_length=7, + decision_rule='argmax_spike_count', + class_threshold=2, + reset_policy='tlast', + ): super().__init__() self.n_classes = n_classes self.stream_length = stream_length From e6a47ed100e662802baa8c874ffaa904260b094d Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 8 May 2026 08:54:25 +0000 Subject: [PATCH 13/32] [pre-commit.ci] auto fixes from pre-commit hooks --- hls4ml-snn-example.ipynb | 179 +++++++++--------- hls4ml/converters/pytorch/snn.py | 3 +- .../vivado/nnet_utils/nnet_if_neuron.h | 22 +-- .../vivado/nnet_utils/nnet_lif_neuron.h | 34 ++-- .../vivado/nnet_utils/nnet_snn_common.h | 8 +- .../vivado/nnet_utils/nnet_snn_readout.h | 11 +- 6 files changed, 126 insertions(+), 131 deletions(-) diff --git a/hls4ml-snn-example.ipynb b/hls4ml-snn-example.ipynb index d6b77065d0..13bef57915 100644 --- a/hls4ml-snn-example.ipynb +++ b/hls4ml-snn-example.ipynb @@ -38,35 +38,33 @@ } ], "source": [ - "import copy\n", "import json\n", "import time\n", "from pathlib import Path\n", "\n", + "import matplotlib.pyplot as plt\n", "import numpy as np\n", + "import snntorch as snn\n", "import torch\n", "import torch.nn as nn\n", - "import torch.nn.functional as F\n", - "from torch.utils.data import TensorDataset, DataLoader\n", - "import matplotlib.pyplot as plt\n", - "\n", - "import snntorch as snn\n", + "from torch.utils.data import DataLoader, TensorDataset\n", "\n", "import hls4ml\n", "import hls4ml.utils.torch\n", "from hls4ml.utils.snntorch import SNNReadout\n", + "\n", "print(hls4ml.__file__)\n", "\n", "try:\n", - " import neurobench\n", - " from neurobench.models import SNNTorchModel\n", " from neurobench.benchmarks import Benchmark\n", - " from neurobench.metrics.static import Footprint, ConnectionSparsity\n", - " from neurobench.metrics.workload import ClassificationAccuracy, ActivationSparsity, SynapticOperations\n", + " from neurobench.metrics.static import ConnectionSparsity, Footprint\n", + " from neurobench.metrics.workload import ActivationSparsity, ClassificationAccuracy, SynapticOperations\n", + " from neurobench.models import SNNTorchModel\n", + "\n", " HAS_NEUROBENCH = True\n", "except Exception as err:\n", " HAS_NEUROBENCH = False\n", - " print(f\"[NeuroBench] import skipped: {err}\")\n", + " print(f'[NeuroBench] import skipped: {err}')\n", "\n", "\n", "def set_seed(seed: int = 0):\n", @@ -75,6 +73,7 @@ " if torch.cuda.is_available():\n", " torch.cuda.manual_seed_all(seed)\n", "\n", + "\n", "set_seed(0)" ] }, @@ -103,24 +102,24 @@ "source": [ "set_seed(0)\n", "\n", - "output_dir = Path(\"examples/snn_example\")\n", - "backend = \"Vitis\"\n", - "part = \"xczu7ev-ffvc1156-2-e\"\n", + "output_dir = Path('examples/snn_example')\n", + "backend = 'Vitis'\n", + "part = 'xczu7ev-ffvc1156-2-e'\n", "clock_period = 5\n", - "clock_uncertainty = \"18%\"\n", + "clock_uncertainty = '18%'\n", "\n", "# general SNN precision\n", - "precision = \"ap_fixed<8,4>\"\n", + "precision = 'ap_fixed<8,4>'\n", "\n", "# output mode\n", - "output_mode = \"membrane\"\n", - "decision_rule = \"argmax_membrane\"\n", + "output_mode = 'membrane'\n", + "decision_rule = 'argmax_membrane'\n", "\n", "# precision for spike readouts\n", - "readout_result_precision = \"ap_int<8>\"\n", + "readout_result_precision = 'ap_int<8>'\n", "\n", "# precision for membrane readouts\n", - "readout_membrane_precision = \"ap_fixed<16,7>\"\n", + "readout_membrane_precision = 'ap_fixed<16,7>'\n", "readout_membrane_beta = 1.0\n", "\n", "timesteps = 50\n", @@ -136,18 +135,18 @@ "hidden = 8\n", "hidden_beta = 0.75\n", "hidden_threshold = 1.0\n", - "if output_mode == \"membrane\":\n", + "if output_mode == 'membrane':\n", " out_threshold = 1000.0\n", "else:\n", " out_threshold = 0.5\n", - "#class_threshold = 5 # only needed for threshold decisions\n", + "# class_threshold = 5 # only needed for threshold decisions\n", "\n", "READOUT_CONFIGS = [\n", " # {\"name\": \"argmax_spike_count\", \"output_mode\": \"spike\", \"decision_rule\": \"argmax_spike_count\"},\n", " # {\"name\": \"first_to_threshold\", \"output_mode\": \"spike\", \"decision_rule\": \"first_to_threshold\"},\n", " # {\"name\": \"threshold_then_argmax\", \"output_mode\": \"spike\", \"decision_rule\": \"threshold_then_argmax\"},\n", " # {\"name\": \"binary_logit\", \"output_mode\": \"spike\", \"decision_rule\": \"binary_logit\"},\n", - " {\"name\": \"argmax_membrane\", \"output_mode\": \"membrane\", \"decision_rule\": \"argmax_membrane\"},\n", + " {'name': 'argmax_membrane', 'output_mode': 'membrane', 'decision_rule': 'argmax_membrane'},\n", "]" ] }, @@ -233,13 +232,15 @@ } ], "source": [ - "plt.rcParams.update({\n", - " \"font.family\": \"serif\",\n", - " \"font.serif\": [\"Computer Modern Roman\", \"CMU Serif\", \"DejaVu Serif\"],\n", - " \"mathtext.fontset\": \"cm\",\n", - " \"axes.unicode_minus\": False,\n", - " \"font.size\": 12,\n", - "})\n", + "plt.rcParams.update(\n", + " {\n", + " 'font.family': 'serif',\n", + " 'font.serif': ['Computer Modern Roman', 'CMU Serif', 'DejaVu Serif'],\n", + " 'mathtext.fontset': 'cm',\n", + " 'axes.unicode_minus': False,\n", + " 'font.size': 12,\n", + " }\n", + ")\n", "\n", "fig, axes = plt.subplots(2, 1, figsize=(10, 7), sharex=True)\n", "t = np.arange(timesteps)\n", @@ -248,13 +249,13 @@ " ax.plot(t, seq[:, ch], alpha=0.10, linewidth=1.0)\n", " for seq in x_trn[y_trn == 1][:50]:\n", " ax.plot(t, seq[:, ch], alpha=0.10, linewidth=1.0)\n", - " ax.plot(t, x_trn[y_trn == 0, :, ch].mean(axis=0), linewidth=2.5, label=\"class 0 mean\")\n", - " ax.plot(t, x_trn[y_trn == 1, :, ch].mean(axis=0), linewidth=2.5, label=\"class 1 mean\")\n", - " ax.set_ylabel(f\"channel {ch}\")\n", + " ax.plot(t, x_trn[y_trn == 0, :, ch].mean(axis=0), linewidth=2.5, label='class 0 mean')\n", + " ax.plot(t, x_trn[y_trn == 1, :, ch].mean(axis=0), linewidth=2.5, label='class 1 mean')\n", + " ax.set_ylabel(f'channel {ch}')\n", " ax.grid(alpha=0.20)\n", - " ax.legend(loc=\"best\")\n", - "axes[-1].set_xlabel(\"timestep\")\n", - "fig.suptitle(\"Toy temporal streams\")\n", + " ax.legend(loc='best')\n", + "axes[-1].set_xlabel('timestep')\n", + "fig.suptitle('Toy temporal streams')\n", "fig.tight_layout()" ] }, @@ -298,7 +299,7 @@ ], "source": [ "class ReadoutSNN(nn.Module):\n", - " def __init__(self, decision_rule=\"argmax_membrane\", output_mode=\"membrane\", readout_beta=1.0):\n", + " def __init__(self, decision_rule='argmax_membrane', output_mode='membrane', readout_beta=1.0):\n", " super().__init__()\n", "\n", " # linear layer input\n", @@ -309,19 +310,19 @@ " beta=hidden_beta,\n", " threshold=hidden_threshold,\n", " learn_beta=True,\n", - " reset_mechanism=\"subtract\",\n", + " reset_mechanism='subtract',\n", " )\n", "\n", " # linear layer\n", " self.fc2 = nn.Linear(hidden, 2)\n", "\n", " # final spiking neuron if we use spike outputs, no neuron needed if we use membrane outputs\n", - " if output_mode != \"membrane\":\n", + " if output_mode != 'membrane':\n", " self.if2 = snn.Leaky(\n", " beta=1.0,\n", " threshold=out_threshold,\n", " learn_beta=False,\n", - " reset_mechanism=\"subtract\",\n", + " reset_mechanism='subtract',\n", " )\n", "\n", " # readout layer\n", @@ -329,7 +330,7 @@ " n_classes=2,\n", " window_size=timesteps,\n", " decision_rule=decision_rule,\n", - " #class_threshold=class_threshold,\n", + " # class_threshold=class_threshold,\n", " output_mode=output_mode,\n", " beta=readout_beta,\n", " )\n", @@ -342,7 +343,7 @@ " # linear\n", " x_t = self.fc2(spk1)\n", " # straight to readout if using membrane outputs\n", - " if self.readout.output_mode == \"membrane\":\n", + " if self.readout.output_mode == 'membrane':\n", " # readout\n", " return self.readout(x_t)\n", " # convert to spikes with spiking neuron\n", @@ -373,17 +374,19 @@ "# reset snn state\n", "def reset_snn_state(net):\n", " for module in net.modules():\n", - " if hasattr(module, \"reset_hidden\"):\n", + " if hasattr(module, 'reset_hidden'):\n", " module.reset_hidden()\n", - " elif hasattr(module, \"reset_mem\"):\n", + " elif hasattr(module, 'reset_mem'):\n", " module.reset_mem()\n", "\n", + "\n", "# straight-through estimator for qat\n", "def fake_quant_ste(x, frac_bits=4):\n", " scale = float(2**frac_bits)\n", " q = torch.round(x * scale) / scale\n", " return x + (q - x).detach()\n", "\n", + "\n", "# runs series data through the snn\n", "# uses the ste if we are running qat\n", "def run_sequence(net, x_seq, qat=False, frac_bits=4):\n", @@ -398,17 +401,18 @@ "\n", "\n", "# this implements the readout as it is done in hls4snn\n", - "def reduce_readout_reference(outs, output_mode=\"membrane\", decision_rule=\"argmax_membrane\", beta=1.0):\n", - " if output_mode == \"membrane\":\n", + "def reduce_readout_reference(outs, output_mode='membrane', decision_rule='argmax_membrane', beta=1.0):\n", + " if output_mode == 'membrane':\n", " mem = torch.zeros_like(outs[:, 0, :])\n", " for step in range(outs.shape[1]):\n", " mem = beta * mem + outs[:, step, :]\n", " return mem\n", " return outs.sum(dim=1)\n", "\n", + "\n", "# predict output for accuracy metric\n", - "def predict_from_readout_values(values, decision_rule=\"argmax_membrane\"):\n", - " if decision_rule == \"binary_logit\":\n", + "def predict_from_readout_values(values, decision_rule='argmax_membrane'):\n", + " if decision_rule == 'binary_logit':\n", " return (values[:, 1] - values[:, 0] > 0).long()\n", " return values.argmax(dim=1).long()" ] @@ -473,7 +477,6 @@ "source": [ "# we loop through regular + qat-aware epochs\n", "for epoch in range(n_epochs + n_qat_epochs):\n", - " \n", " model.train()\n", "\n", " # qat flag\n", @@ -496,18 +499,18 @@ " loss = loss_fn(logits, yb)\n", "\n", " # mild regularization keeps the learned beta small and quantization-friendly.\n", - " if hasattr(model.if1, \"beta\"):\n", + " if hasattr(model.if1, 'beta'):\n", " loss = loss + 1e-3 * torch.mean(model.if1.beta**2)\n", "\n", " # compute and update weights\n", " loss.backward()\n", " optimizer.step()\n", - " \n", + "\n", " # schedule lr\n", " scheduler.step()\n", "\n", " # quantize learned beta after each qat epoch\n", - " if use_qat and hasattr(model.if1, \"beta\"):\n", + " if use_qat and hasattr(model.if1, 'beta'):\n", " scale = float(2**qat_frac_bits)\n", " with torch.no_grad():\n", " model.if1.beta.data = torch.round(model.if1.beta.data * scale) / scale\n", @@ -532,8 +535,8 @@ " val_pred = predict_from_readout_values(val_values, model.readout.decision_rule)\n", " trn_acc = (trn_pred == ty_trn[:512]).float().mean().item()\n", " val_acc = (val_pred == ty_val).float().mean().item()\n", - " phase = \"QAT\" if use_qat else \"FP\"\n", - " print(f\"[{phase} epoch {epoch + 1:03d}] train_acc={trn_acc:.3f} val_acc={val_acc:.3f}\")" + " phase = 'QAT' if use_qat else 'FP'\n", + " print(f'[{phase} epoch {epoch + 1:03d}] train_acc={trn_acc:.3f} val_acc={val_acc:.3f}')" ] }, { @@ -570,7 +573,7 @@ " tst_pred = predict_from_readout_values(tst_values, model.readout.decision_rule)\n", " tst_acc = (tst_pred == ty_tst).float().mean().item()\n", "\n", - "print(f\"Torch {model.readout.output_mode}/{model.readout.decision_rule} test accuracy = {tst_acc:.4f}\")" + "print(f'Torch {model.readout.output_mode}/{model.readout.decision_rule} test accuracy = {tst_acc:.4f}')" ] }, { @@ -622,41 +625,41 @@ " cfg = hls4ml.utils.config_from_pytorch_model(\n", " step_model,\n", " input_shape=(2,),\n", - " granularity=\"name\",\n", + " granularity='name',\n", " backend=backend,\n", " default_precision=precision,\n", " )\n", "\n", - " cfg[\"Model\"][\"ReuseFactor\"] = 1\n", - " cfg[\"Model\"].setdefault(\"Precision\", {})[\"default\"] = precision\n", + " cfg['Model']['ReuseFactor'] = 1\n", + " cfg['Model'].setdefault('Precision', {})['default'] = precision\n", "\n", - " for layer_name, layer_cfg in cfg.get(\"LayerName\", {}).items():\n", - " layer_precision = layer_cfg.setdefault(\"Precision\", {})\n", + " for layer_name, layer_cfg in cfg.get('LayerName', {}).items():\n", + " layer_precision = layer_cfg.setdefault('Precision', {})\n", "\n", - " for key in (\"result\", \"accum\", \"weight\", \"bias\"):\n", + " for key in ('result', 'accum', 'weight', 'bias'):\n", " layer_precision[key] = precision\n", "\n", - " if layer_name in {\"if1\", \"if2\"}:\n", - " for key in (\"beta\", \"threshold\", \"membrane\"):\n", + " if layer_name in {'if1', 'if2'}:\n", + " for key in ('beta', 'threshold', 'membrane'):\n", " layer_precision[key] = precision\n", - " layer_cfg[\"beta_t\"] = precision\n", - " layer_cfg[\"threshold_t\"] = precision\n", - " layer_cfg[\"membrane_t\"] = precision\n", + " layer_cfg['beta_t'] = precision\n", + " layer_cfg['threshold_t'] = precision\n", + " layer_cfg['membrane_t'] = precision\n", "\n", - " if layer_name == \"readout\":\n", - " layer_precision[\"result\"] = readout_result_precision\n", - " layer_precision[\"membrane\"] = readout_membrane_precision\n", - " layer_cfg[\"membrane_t\"] = readout_membrane_precision\n", + " if layer_name == 'readout':\n", + " layer_precision['result'] = readout_result_precision\n", + " layer_precision['membrane'] = readout_membrane_precision\n", + " layer_cfg['membrane_t'] = readout_membrane_precision\n", "\n", " return cfg\n", "\n", "\n", "hls_config = make_hls_config(model)\n", "\n", - "print(json.dumps(hls_config[\"Model\"], indent=2, default=str))\n", - "print(\"\\nLayer entries:\")\n", - "for name, cfg in hls_config.get(\"LayerName\", {}).items():\n", - " print(f\" {name:10s}: {sorted(cfg.keys())}\")" + "print(json.dumps(hls_config['Model'], indent=2, default=str))\n", + "print('\\nLayer entries:')\n", + "for name, cfg in hls_config.get('LayerName', {}).items():\n", + " print(f' {name:10s}: {sorted(cfg.keys())}')" ] }, { @@ -697,7 +700,7 @@ " output_dir=str(hls_dir),\n", " project_name=proj_name,\n", " backend=backend,\n", - " io_type=\"io_stream\",\n", + " io_type='io_stream',\n", " hls_config=hls_config,\n", " part=part,\n", " clock_period=clock_period,\n", @@ -732,12 +735,12 @@ "\n", "\n", "def assert_fixed_window_reset_was_generated(hls_dir, window_size):\n", - " parameters_h = hls_dir / \"firmware\" / \"parameters.h\"\n", + " parameters_h = hls_dir / 'firmware' / 'parameters.h'\n", " text = parameters_h.read_text()\n", - " expected = f\"static const unsigned window_size = {window_size};\"\n", + " expected = f'static const unsigned window_size = {window_size};'\n", " if expected not in text:\n", " raise RuntimeError(\n", - " f\"{parameters_h} does not contain {expected!r}. Re-run the conversion/write cell before compiling.\"\n", + " f'{parameters_h} does not contain {expected!r}. Re-run the conversion/write cell before compiling.'\n", " )\n", "\n", "\n", @@ -750,7 +753,7 @@ " x_step = x_seq[sample, step, :].astype(np.float32)[None, :]\n", " last = _as_scalar(hls_model.predict(x_step))\n", " values.append(last)\n", - " return np.asarray(values, dtype=np.float32)\n" + " return np.asarray(values, dtype=np.float32)" ] }, { @@ -769,7 +772,7 @@ } ], "source": [ - "#assert_fixed_window_reset_was_generated(hls_dir, timesteps)\n", + "# assert_fixed_window_reset_was_generated(hls_dir, timesteps)\n", "\n", "# Compile immediately before sequence evaluation. Avoid making stray single-timestep\n", "# predict calls before this loop; the compiled SNN state is persistent between calls.\n", @@ -777,14 +780,14 @@ "t0 = time.perf_counter()\n", "raw = predict_hls_sequences(hls_model, x_tst, timesteps)\n", "\n", - "if model.readout.decision_rule == \"binary_logit\":\n", + "if model.readout.decision_rule == 'binary_logit':\n", " preds = (raw > 0).astype(np.int64)\n", "else:\n", " preds = np.rint(raw).astype(np.int64)\n", "\n", "elapsed = time.perf_counter() - t0\n", - "print(\"accuracy: \", float(np.mean(preds == y_tst)))\n", - "print(\"throughput_samples_per_s: \", float(x_tst.shape[0] / elapsed) if elapsed > 0 else 0.0)" + "print('accuracy: ', float(np.mean(preds == y_tst)))\n", + "print('throughput_samples_per_s: ', float(x_tst.shape[0] / elapsed) if elapsed > 0 else 0.0)" ] }, { @@ -826,7 +829,7 @@ "\n", "\n", "class NeuroBenchReadoutPostprocessor:\n", - " def __init__(self, decision_rule=\"argmax_spike_count\", class_threshold=5):\n", + " def __init__(self, decision_rule='argmax_spike_count', class_threshold=5):\n", " self.decision_rule = decision_rule\n", " self.class_threshold = class_threshold\n", "\n", @@ -840,9 +843,9 @@ "\n", " counts = preds.sum(dim=1) if preds.ndim == 3 else preds\n", "\n", - " if self.decision_rule == \"binary_logit\":\n", + " if self.decision_rule == 'binary_logit':\n", " return (counts[:, 1] - counts[:, 0] > 0).long()\n", - " if self.decision_rule == \"argmax_spike_count\":\n", + " if self.decision_rule == 'argmax_spike_count':\n", " return counts.argmax(dim=1).long()\n", "\n", " reached = counts >= self.class_threshold\n", @@ -921,11 +924,11 @@ " [static_metrics, workload_metrics],\n", " )\n", "\n", - " device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + " device = 'cuda' if torch.cuda.is_available() else 'cpu'\n", " results = benchmark.run(device=device)\n", " print(json.dumps(results, indent=2))\n", "else:\n", - " print(\"NeuroBench is not installed in this environment.\")" + " print('NeuroBench is not installed in this environment.')" ] }, { diff --git a/hls4ml/converters/pytorch/snn.py b/hls4ml/converters/pytorch/snn.py index 07b8dffa8c..9c5a3a9897 100644 --- a/hls4ml/converters/pytorch/snn.py +++ b/hls4ml/converters/pytorch/snn.py @@ -51,8 +51,7 @@ def _parse_state_reset_policy(class_object): policy = str(policy).lower() if policy not in ['fixed_window', 'tlast', 'host_pulse', 'never']: raise Exception( - f'Unsupported state reset policy "{policy}". ' - 'Supported: "fixed_window", "tlast", "host_pulse", "never".' + f'Unsupported state reset policy "{policy}". Supported: "fixed_window", "tlast", "host_pulse", "never".' ) return policy diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h b/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h index 5711d5950c..de69269f33 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h @@ -20,9 +20,8 @@ struct if_neuron_config { }; template -void if_neuron( - data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out], const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out] -) { +void if_neuron(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out], + const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out]) { #pragma HLS PIPELINE II=1 // Static state persists across calls until the configured time window ends. @@ -32,9 +31,8 @@ void if_neuron( for (unsigned i = 0; i < CONFIG_T::n_out; i++) { #pragma HLS UNROLL - typename CONFIG_T::threshold_t threshold = CONFIG_T::threshold_is_vector - ? threshold_vec[i] - : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + typename CONFIG_T::threshold_t threshold = + CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; typename CONFIG_T::membrane_t v = mem[i] + (typename CONFIG_T::membrane_t)data[i]; bool spike = (v >= threshold); if (spike) { @@ -63,11 +61,8 @@ void if_neuron( } template -void if_neuron( - hls::stream &data_stream, - hls::stream &res_stream, - const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out] -) { +void if_neuron(hls::stream &data_stream, hls::stream &res_stream, + const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out]) { #pragma HLS PIPELINE II=1 // Static state persists across calls until the configured time window ends. @@ -81,9 +76,8 @@ void if_neuron( for (unsigned i = 0; i < CONFIG_T::n_out; i++) { #pragma HLS UNROLL - typename CONFIG_T::threshold_t threshold = CONFIG_T::threshold_is_vector - ? threshold_vec[i] - : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + typename CONFIG_T::threshold_t threshold = + CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; typename CONFIG_T::membrane_t v = mem[i] + (typename CONFIG_T::membrane_t)in_pack[i]; bool spike = (v >= threshold); if (spike) { diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h b/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h index 75b9da5e88..671ae202ee 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h @@ -23,12 +23,9 @@ struct lif_neuron_config { }; template -void lif_neuron( - data_T data[CONFIG_T::n_in], - res_T res[CONFIG_T::n_out], - const typename CONFIG_T::beta_t beta_vec[CONFIG_T::n_out], - const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out] -) { +void lif_neuron(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out], + const typename CONFIG_T::beta_t beta_vec[CONFIG_T::n_out], + const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out]) { #pragma HLS PIPELINE II=1 // Static state persists across calls until the configured time window ends. @@ -39,11 +36,11 @@ void lif_neuron( for (unsigned i = 0; i < CONFIG_T::n_out; i++) { #pragma HLS UNROLL typename CONFIG_T::beta_t beta = CONFIG_T::beta_is_vector ? beta_vec[i] : (typename CONFIG_T::beta_t)CONFIG_T::beta; - typename CONFIG_T::threshold_t threshold = CONFIG_T::threshold_is_vector - ? threshold_vec[i] - : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + typename CONFIG_T::threshold_t threshold = + CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; // LIF update: v[t] = beta * v[t-1] + input. - typename CONFIG_T::membrane_t v = (typename CONFIG_T::membrane_t)(beta * mem[i]) + (typename CONFIG_T::membrane_t)data[i]; + typename CONFIG_T::membrane_t v = + (typename CONFIG_T::membrane_t)(beta * mem[i]) + (typename CONFIG_T::membrane_t)data[i]; bool spike = (v >= threshold); if (spike) { if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { @@ -71,12 +68,9 @@ void lif_neuron( } template -void lif_neuron( - hls::stream &data_stream, - hls::stream &res_stream, - const typename CONFIG_T::beta_t beta_vec[CONFIG_T::n_out], - const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out] -) { +void lif_neuron(hls::stream &data_stream, hls::stream &res_stream, + const typename CONFIG_T::beta_t beta_vec[CONFIG_T::n_out], + const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out]) { #pragma HLS PIPELINE II=1 // Static state persists across calls until the configured time window ends. @@ -91,11 +85,11 @@ void lif_neuron( for (unsigned i = 0; i < CONFIG_T::n_out; i++) { #pragma HLS UNROLL typename CONFIG_T::beta_t beta = CONFIG_T::beta_is_vector ? beta_vec[i] : (typename CONFIG_T::beta_t)CONFIG_T::beta; - typename CONFIG_T::threshold_t threshold = CONFIG_T::threshold_is_vector - ? threshold_vec[i] - : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + typename CONFIG_T::threshold_t threshold = + CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; // LIF update: v[t] = beta * v[t-1] + input. - typename CONFIG_T::membrane_t v = (typename CONFIG_T::membrane_t)(beta * mem[i]) + (typename CONFIG_T::membrane_t)in_pack[i]; + typename CONFIG_T::membrane_t v = + (typename CONFIG_T::membrane_t)(beta * mem[i]) + (typename CONFIG_T::membrane_t)in_pack[i]; bool spike = (v >= threshold); if (spike) { if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h b/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h index 8fa5a3dbe4..864d6818b5 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h @@ -4,7 +4,13 @@ namespace nnet { enum class snn_reset_mode { subtract, zero }; -enum class snn_decision_rule { argmax_spike_count, first_to_threshold, threshold_then_argmax, binary_logit, argmax_membrane }; +enum class snn_decision_rule { + argmax_spike_count, + first_to_threshold, + threshold_then_argmax, + binary_logit, + argmax_membrane +}; enum class snn_readout_mode { spike, membrane }; } // namespace nnet diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h b/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h index e37589fe03..0104c4fcfa 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h @@ -18,8 +18,7 @@ struct snn_readout_config { typedef float membrane_t; }; -template -void snn_readout(data_T data[CONFIG_T::n_classes], res_T res[1]) { +template void snn_readout(data_T data[CONFIG_T::n_classes], res_T res[1]) { #pragma HLS PIPELINE II=1 // Counts and membrane values persist across calls within one readout window. @@ -34,8 +33,8 @@ void snn_readout(data_T data[CONFIG_T::n_classes], res_T res[1]) { for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { #pragma HLS UNROLL typename CONFIG_T::membrane_t v = - (typename CONFIG_T::membrane_t)((typename CONFIG_T::membrane_t)CONFIG_T::beta * mem[i]) - + (typename CONFIG_T::membrane_t)data[i]; + (typename CONFIG_T::membrane_t)((typename CONFIG_T::membrane_t)CONFIG_T::beta * mem[i]) + + (typename CONFIG_T::membrane_t)data[i]; mem[i] = v; if (i == 0 || v > mem[best]) { best = i; @@ -172,8 +171,8 @@ void snn_readout(hls::stream &data_stream, hls::stream &res_strea for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { #pragma HLS UNROLL typename CONFIG_T::membrane_t v = - (typename CONFIG_T::membrane_t)((typename CONFIG_T::membrane_t)CONFIG_T::beta * mem[i]) - + (typename CONFIG_T::membrane_t)in_pack[i]; + (typename CONFIG_T::membrane_t)((typename CONFIG_T::membrane_t)CONFIG_T::beta * mem[i]) + + (typename CONFIG_T::membrane_t)in_pack[i]; mem[i] = v; if (i == 0 || v > mem[best]) { best = i; From 7e8e1bc1296e8c131481e86c5291effea4925b54 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Sun, 17 May 2026 18:42:38 +0100 Subject: [PATCH 14/32] remove notebook --- .gitignore | 1 + hls4ml-snn-example.ipynb | 2237 -------------------------------------- 2 files changed, 1 insertion(+), 2237 deletions(-) delete mode 100644 hls4ml-snn-example.ipynb diff --git a/.gitignore b/.gitignore index 8fb87927ce..476728453b 100644 --- a/.gitignore +++ b/.gitignore @@ -13,5 +13,6 @@ docs/_build docs/autodoc/* hls4mlprj_* *~ +*.ipynb *.ipynb_checkpoints/ *.bak diff --git a/hls4ml-snn-example.ipynb b/hls4ml-snn-example.ipynb deleted file mode 100644 index 13bef57915..0000000000 --- a/hls4ml-snn-example.ipynb +++ /dev/null @@ -1,2237 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "f5d68c3f-6575-4637-b645-9d493d7b7413", - "metadata": {}, - "source": [ - "# SNN example in hls4ml" - ] - }, - { - "cell_type": "markdown", - "id": "476e7c77-f50e-438f-b487-d2ff112f8dc3", - "metadata": {}, - "source": [ - "## imports\n", - "\n", - "Before launching Jupyter, source your Xilinx tools, for example:\n", - "\n", - "```bash\n", - "source /tools/Xilinx/Vitis/2024.1/settings64.sh\n", - "source /tools/Xilinx/Vivado/2024.1/settings64.sh\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "44c4d46b-ea90-443a-86a7-7432c543f0e3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/home/b/Physics/hls4ml/hls4ml/__init__.py\n" - ] - } - ], - "source": [ - "import json\n", - "import time\n", - "from pathlib import Path\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import snntorch as snn\n", - "import torch\n", - "import torch.nn as nn\n", - "from torch.utils.data import DataLoader, TensorDataset\n", - "\n", - "import hls4ml\n", - "import hls4ml.utils.torch\n", - "from hls4ml.utils.snntorch import SNNReadout\n", - "\n", - "print(hls4ml.__file__)\n", - "\n", - "try:\n", - " from neurobench.benchmarks import Benchmark\n", - " from neurobench.metrics.static import ConnectionSparsity, Footprint\n", - " from neurobench.metrics.workload import ActivationSparsity, ClassificationAccuracy, SynapticOperations\n", - " from neurobench.models import SNNTorchModel\n", - "\n", - " HAS_NEUROBENCH = True\n", - "except Exception as err:\n", - " HAS_NEUROBENCH = False\n", - " print(f'[NeuroBench] import skipped: {err}')\n", - "\n", - "\n", - "def set_seed(seed: int = 0):\n", - " np.random.seed(seed)\n", - " torch.manual_seed(seed)\n", - " if torch.cuda.is_available():\n", - " torch.cuda.manual_seed_all(seed)\n", - "\n", - "\n", - "set_seed(0)" - ] - }, - { - "cell_type": "markdown", - "id": "41ad7003-cf72-4f83-a04a-8c896fa11bca", - "metadata": {}, - "source": [ - "## settings" - ] - }, - { - "cell_type": "markdown", - "id": "139af64d-0b2b-4011-aa59-3bb6118d007a", - "metadata": {}, - "source": [ - "I want a binary classifier that uses the membrane potentials on the final layer to perform classification." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "11eb25a1-3b43-43f2-8cc5-dfb12968fae4", - "metadata": {}, - "outputs": [], - "source": [ - "set_seed(0)\n", - "\n", - "output_dir = Path('examples/snn_example')\n", - "backend = 'Vitis'\n", - "part = 'xczu7ev-ffvc1156-2-e'\n", - "clock_period = 5\n", - "clock_uncertainty = '18%'\n", - "\n", - "# general SNN precision\n", - "precision = 'ap_fixed<8,4>'\n", - "\n", - "# output mode\n", - "output_mode = 'membrane'\n", - "decision_rule = 'argmax_membrane'\n", - "\n", - "# precision for spike readouts\n", - "readout_result_precision = 'ap_int<8>'\n", - "\n", - "# precision for membrane readouts\n", - "readout_membrane_precision = 'ap_fixed<16,7>'\n", - "readout_membrane_beta = 1.0\n", - "\n", - "timesteps = 50\n", - "n_trn = 2000\n", - "n_val = 300\n", - "n_tst = 300\n", - "batch_size = 64\n", - "n_epochs = 50\n", - "n_qat_epochs = 8\n", - "lr = 1e-3\n", - "qat_frac_bits = 7\n", - "\n", - "hidden = 8\n", - "hidden_beta = 0.75\n", - "hidden_threshold = 1.0\n", - "if output_mode == 'membrane':\n", - " out_threshold = 1000.0\n", - "else:\n", - " out_threshold = 0.5\n", - "# class_threshold = 5 # only needed for threshold decisions\n", - "\n", - "READOUT_CONFIGS = [\n", - " # {\"name\": \"argmax_spike_count\", \"output_mode\": \"spike\", \"decision_rule\": \"argmax_spike_count\"},\n", - " # {\"name\": \"first_to_threshold\", \"output_mode\": \"spike\", \"decision_rule\": \"first_to_threshold\"},\n", - " # {\"name\": \"threshold_then_argmax\", \"output_mode\": \"spike\", \"decision_rule\": \"threshold_then_argmax\"},\n", - " # {\"name\": \"binary_logit\", \"output_mode\": \"spike\", \"decision_rule\": \"binary_logit\"},\n", - " {'name': 'argmax_membrane', 'output_mode': 'membrane', 'decision_rule': 'argmax_membrane'},\n", - "]" - ] - }, - { - "cell_type": "markdown", - "id": "81f2c60d-dfb8-4cc3-ba77-e7a42653ba84", - "metadata": {}, - "source": [ - "## data for the binary classification" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "c90472d1-b6a5-4d1a-9b6a-c290b7b03216", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(2000, 50, 2) (2000,)\n" - ] - } - ], - "source": [ - "def make_toy_dataset(n_samples: int, timesteps: int = 50, noise_std: float = 0.80, amp_jitter: float = 0.55):\n", - " t = np.linspace(0.0, 1.0, timesteps, endpoint=False, dtype=np.float32)\n", - " x = np.zeros((n_samples, timesteps, 2), dtype=np.float32)\n", - " y = np.random.randint(0, 2, size=(n_samples,), dtype=np.int64)\n", - "\n", - " early = np.exp(-0.5 * ((t - 0.33) / 0.16) ** 2).astype(np.float32)\n", - " late = np.exp(-0.5 * ((t - 0.67) / 0.16) ** 2).astype(np.float32)\n", - "\n", - " for i, label in enumerate(y):\n", - " amp = 1.0 + np.random.uniform(-amp_jitter, amp_jitter)\n", - " wave = 0.35 * np.sin(2 * np.pi * t).astype(np.float32)\n", - " mix = np.random.uniform(-0.25, 0.25)\n", - "\n", - " if label == 0:\n", - " ch0 = amp * ((0.95 + mix) * early - 0.70 * late + wave)\n", - " ch1 = amp * (-0.55 * early + (0.25 - mix) * late - 0.40 * wave)\n", - " else:\n", - " ch0 = amp * (-0.55 * early + (0.25 + mix) * late + 0.40 * wave)\n", - " ch1 = amp * ((0.95 - mix) * late - 0.70 * early - wave)\n", - "\n", - " x[i, :, 0] = ch0 + np.random.normal(0.0, noise_std, size=timesteps)\n", - " x[i, :, 1] = ch1 + np.random.normal(0.0, noise_std, size=timesteps)\n", - "\n", - " x = np.clip(x, -2.0, 2.0).astype(np.float32)\n", - " return x, y\n", - "\n", - "\n", - "x_trn, y_trn = make_toy_dataset(n_trn, timesteps)\n", - "x_val, y_val = make_toy_dataset(n_val, timesteps)\n", - "x_tst, y_tst = make_toy_dataset(n_tst, timesteps)\n", - "\n", - "tx_trn = torch.from_numpy(x_trn).float()\n", - "ty_trn = torch.from_numpy(y_trn).long()\n", - "tx_val = torch.from_numpy(x_val).float()\n", - "ty_val = torch.from_numpy(y_val).long()\n", - "tx_tst = torch.from_numpy(x_tst).float()\n", - "ty_tst = torch.from_numpy(y_tst).long()\n", - "\n", - "print(x_trn.shape, y_trn.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "c7d9445f-4624-4020-af38-d91fd06b46c7", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.rcParams.update(\n", - " {\n", - " 'font.family': 'serif',\n", - " 'font.serif': ['Computer Modern Roman', 'CMU Serif', 'DejaVu Serif'],\n", - " 'mathtext.fontset': 'cm',\n", - " 'axes.unicode_minus': False,\n", - " 'font.size': 12,\n", - " }\n", - ")\n", - "\n", - "fig, axes = plt.subplots(2, 1, figsize=(10, 7), sharex=True)\n", - "t = np.arange(timesteps)\n", - "for ch, ax in enumerate(axes):\n", - " for seq in x_trn[y_trn == 0][:50]:\n", - " ax.plot(t, seq[:, ch], alpha=0.10, linewidth=1.0)\n", - " for seq in x_trn[y_trn == 1][:50]:\n", - " ax.plot(t, seq[:, ch], alpha=0.10, linewidth=1.0)\n", - " ax.plot(t, x_trn[y_trn == 0, :, ch].mean(axis=0), linewidth=2.5, label='class 0 mean')\n", - " ax.plot(t, x_trn[y_trn == 1, :, ch].mean(axis=0), linewidth=2.5, label='class 1 mean')\n", - " ax.set_ylabel(f'channel {ch}')\n", - " ax.grid(alpha=0.20)\n", - " ax.legend(loc='best')\n", - "axes[-1].set_xlabel('timestep')\n", - "fig.suptitle('Toy temporal streams')\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "id": "58ebd22b-66ca-4266-bba6-e955e805e5cd", - "metadata": {}, - "source": [ - "## define SNN" - ] - }, - { - "cell_type": "markdown", - "id": "2a71e36b-5ef4-410b-a470-d9315bad9a5b", - "metadata": {}, - "source": [ - "The output of the SNN should use `SNNReadout`. SNNs are time-series, and the `SNNReadout` module takes care of the decision after the signal has finished." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "9971c671-371d-4897-b017-769008330d08", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ReadoutSNN(\n", - " (fc1): Linear(in_features=2, out_features=8, bias=True)\n", - " (if1): Leaky()\n", - " (fc2): Linear(in_features=8, out_features=2, bias=True)\n", - " (readout): SNNReadout()\n", - ")" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "class ReadoutSNN(nn.Module):\n", - " def __init__(self, decision_rule='argmax_membrane', output_mode='membrane', readout_beta=1.0):\n", - " super().__init__()\n", - "\n", - " # linear layer input\n", - " self.fc1 = nn.Linear(2, hidden)\n", - "\n", - " # spiking neuron\n", - " self.if1 = snn.Leaky(\n", - " beta=hidden_beta,\n", - " threshold=hidden_threshold,\n", - " learn_beta=True,\n", - " reset_mechanism='subtract',\n", - " )\n", - "\n", - " # linear layer\n", - " self.fc2 = nn.Linear(hidden, 2)\n", - "\n", - " # final spiking neuron if we use spike outputs, no neuron needed if we use membrane outputs\n", - " if output_mode != 'membrane':\n", - " self.if2 = snn.Leaky(\n", - " beta=1.0,\n", - " threshold=out_threshold,\n", - " learn_beta=False,\n", - " reset_mechanism='subtract',\n", - " )\n", - "\n", - " # readout layer\n", - " self.readout = SNNReadout(\n", - " n_classes=2,\n", - " window_size=timesteps,\n", - " decision_rule=decision_rule,\n", - " # class_threshold=class_threshold,\n", - " output_mode=output_mode,\n", - " beta=readout_beta,\n", - " )\n", - "\n", - " def forward(self, x_t):\n", - " # linear\n", - " x_t = self.fc1(x_t)\n", - " # spike\n", - " spk1, _ = self.if1(x_t)\n", - " # linear\n", - " x_t = self.fc2(spk1)\n", - " # straight to readout if using membrane outputs\n", - " if self.readout.output_mode == 'membrane':\n", - " # readout\n", - " return self.readout(x_t)\n", - " # convert to spikes with spiking neuron\n", - " spk2, _ = self.if2(x_t)\n", - " # readout\n", - " return self.readout(spk2)\n", - "\n", - "\n", - "model = ReadoutSNN(decision_rule=decision_rule, output_mode=output_mode)\n", - "model" - ] - }, - { - "cell_type": "markdown", - "id": "ea51d3ff-1416-44e5-ac7b-841f8c62233f", - "metadata": {}, - "source": [ - "## helper functions" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "e5800d40-19ee-42b1-a799-f0e667c5d876", - "metadata": {}, - "outputs": [], - "source": [ - "# reset snn state\n", - "def reset_snn_state(net):\n", - " for module in net.modules():\n", - " if hasattr(module, 'reset_hidden'):\n", - " module.reset_hidden()\n", - " elif hasattr(module, 'reset_mem'):\n", - " module.reset_mem()\n", - "\n", - "\n", - "# straight-through estimator for qat\n", - "def fake_quant_ste(x, frac_bits=4):\n", - " scale = float(2**frac_bits)\n", - " q = torch.round(x * scale) / scale\n", - " return x + (q - x).detach()\n", - "\n", - "\n", - "# runs series data through the snn\n", - "# uses the ste if we are running qat\n", - "def run_sequence(net, x_seq, qat=False, frac_bits=4):\n", - " reset_snn_state(net)\n", - " outs = []\n", - " for step in range(x_seq.shape[1]):\n", - " x_t = x_seq[:, step, :]\n", - " if qat:\n", - " x_t = fake_quant_ste(x_t, frac_bits)\n", - " outs.append(net(x_t))\n", - " return torch.stack(outs, dim=1) # [batch, timesteps, classes]\n", - "\n", - "\n", - "# this implements the readout as it is done in hls4snn\n", - "def reduce_readout_reference(outs, output_mode='membrane', decision_rule='argmax_membrane', beta=1.0):\n", - " if output_mode == 'membrane':\n", - " mem = torch.zeros_like(outs[:, 0, :])\n", - " for step in range(outs.shape[1]):\n", - " mem = beta * mem + outs[:, step, :]\n", - " return mem\n", - " return outs.sum(dim=1)\n", - "\n", - "\n", - "# predict output for accuracy metric\n", - "def predict_from_readout_values(values, decision_rule='argmax_membrane'):\n", - " if decision_rule == 'binary_logit':\n", - " return (values[:, 1] - values[:, 0] > 0).long()\n", - " return values.argmax(dim=1).long()" - ] - }, - { - "cell_type": "markdown", - "id": "fd0298f5-0ee6-4349-bb15-e6eab4c08888", - "metadata": {}, - "source": [ - "## snn model training" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "35fb49c1-a5b5-43a4-95c5-5137261624d7", - "metadata": {}, - "outputs": [], - "source": [ - "# optimizer\n", - "optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n", - "\n", - "# simple scheduler\n", - "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(\n", - " optimizer,\n", - " T_max=n_epochs + n_qat_epochs,\n", - " eta_min=1e-4,\n", - ")\n", - "\n", - "# ce loss\n", - "loss_fn = nn.CrossEntropyLoss()\n", - "\n", - "# data loader for trn data\n", - "trn_loader = DataLoader(TensorDataset(tx_trn, ty_trn), batch_size=batch_size, shuffle=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "4a92de91-5f38-452c-98a5-d82a74b5c829", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[FP epoch 001] train_acc=0.650 val_acc=0.637\n", - "[FP epoch 005] train_acc=0.930 val_acc=0.910\n", - "[FP epoch 010] train_acc=0.982 val_acc=0.970\n", - "[FP epoch 015] train_acc=0.986 val_acc=0.977\n", - "[FP epoch 020] train_acc=0.992 val_acc=0.977\n", - "[FP epoch 025] train_acc=0.992 val_acc=0.977\n", - "[FP epoch 030] train_acc=0.992 val_acc=0.973\n", - "[FP epoch 035] train_acc=0.996 val_acc=0.973\n", - "[FP epoch 040] train_acc=0.992 val_acc=0.983\n", - "[FP epoch 045] train_acc=0.990 val_acc=0.980\n", - "[FP epoch 050] train_acc=0.990 val_acc=0.987\n", - "[QAT epoch 055] train_acc=0.992 val_acc=0.987\n" - ] - } - ], - "source": [ - "# we loop through regular + qat-aware epochs\n", - "for epoch in range(n_epochs + n_qat_epochs):\n", - " model.train()\n", - "\n", - " # qat flag\n", - " use_qat = epoch >= n_epochs\n", - "\n", - " # loop through batches\n", - " for xb, yb in trn_loader:\n", - " # zero the grads\n", - " optimizer.zero_grad()\n", - " # run series data through the snn\n", - " outs = run_sequence(model, xb, qat=use_qat, frac_bits=qat_frac_bits)\n", - " # convert to readout\n", - " logits = reduce_readout_reference(\n", - " outs,\n", - " output_mode=model.readout.output_mode,\n", - " decision_rule=model.readout.decision_rule,\n", - " beta=float(model.readout.beta),\n", - " )\n", - " # compute loss\n", - " loss = loss_fn(logits, yb)\n", - "\n", - " # mild regularization keeps the learned beta small and quantization-friendly.\n", - " if hasattr(model.if1, 'beta'):\n", - " loss = loss + 1e-3 * torch.mean(model.if1.beta**2)\n", - "\n", - " # compute and update weights\n", - " loss.backward()\n", - " optimizer.step()\n", - "\n", - " # schedule lr\n", - " scheduler.step()\n", - "\n", - " # quantize learned beta after each qat epoch\n", - " if use_qat and hasattr(model.if1, 'beta'):\n", - " scale = float(2**qat_frac_bits)\n", - " with torch.no_grad():\n", - " model.if1.beta.data = torch.round(model.if1.beta.data * scale) / scale\n", - "\n", - " # output stats\n", - " if epoch == 0 or (epoch + 1) % 5 == 0:\n", - " model.eval()\n", - " with torch.no_grad():\n", - " trn_values = reduce_readout_reference(\n", - " run_sequence(model, tx_trn[:512]),\n", - " output_mode=model.readout.output_mode,\n", - " decision_rule=model.readout.decision_rule,\n", - " beta=float(model.readout.beta),\n", - " )\n", - " val_values = reduce_readout_reference(\n", - " run_sequence(model, tx_val),\n", - " output_mode=model.readout.output_mode,\n", - " decision_rule=model.readout.decision_rule,\n", - " beta=float(model.readout.beta),\n", - " )\n", - " trn_pred = predict_from_readout_values(trn_values, model.readout.decision_rule)\n", - " val_pred = predict_from_readout_values(val_values, model.readout.decision_rule)\n", - " trn_acc = (trn_pred == ty_trn[:512]).float().mean().item()\n", - " val_acc = (val_pred == ty_val).float().mean().item()\n", - " phase = 'QAT' if use_qat else 'FP'\n", - " print(f'[{phase} epoch {epoch + 1:03d}] train_acc={trn_acc:.3f} val_acc={val_acc:.3f}')" - ] - }, - { - "cell_type": "markdown", - "id": "1d1f2125-c46c-4f45-8a33-4f27ddbcb796", - "metadata": {}, - "source": [ - "Now run on the test data." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "76962506-ff80-4f8f-9619-20b9b6d59db4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Torch membrane/argmax_membrane test accuracy = 0.9767\n" - ] - } - ], - "source": [ - "model.eval()\n", - "with torch.no_grad():\n", - " tst_values = reduce_readout_reference(\n", - " run_sequence(model, tx_tst),\n", - " output_mode=model.readout.output_mode,\n", - " decision_rule=model.readout.decision_rule,\n", - " beta=float(model.readout.beta),\n", - " )\n", - " tst_pred = predict_from_readout_values(tst_values, model.readout.decision_rule)\n", - " tst_acc = (tst_pred == ty_tst).float().mean().item()\n", - "\n", - "print(f'Torch {model.readout.output_mode}/{model.readout.decision_rule} test accuracy = {tst_acc:.4f}')" - ] - }, - { - "cell_type": "markdown", - "id": "4af6070b-543c-4ec7-ad86-93325facb9c7", - "metadata": {}, - "source": [ - "## hls config\n", - "\n", - "Here we generate the config file for the HLS conversion.\n", - "\n", - "Note: During PyTorch conversion, the fixed `readout.window_size` is propagated to every converted IF/LIF neuron. The generated C++ uses that value as the fixed sequence boundary for state reset." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "bba36928-7cdf-4dc8-9d2a-ce7e0986f4d0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " \"Precision\": {\n", - " \"default\": \"ap_fixed<8,4>\"\n", - " },\n", - " \"ReuseFactor\": 1,\n", - " \"ChannelsLastConversion\": \"full\",\n", - " \"TransposeOutputs\": false,\n", - " \"Strategy\": \"Latency\",\n", - " \"BramFactor\": 1000000000,\n", - " \"TraceOutput\": false\n", - "}\n", - "\n", - "Layer entries:\n", - " x_t : ['Precision', 'Trace']\n", - " fc1 : ['Precision', 'ReuseFactor', 'Trace']\n", - " if1 : ['Precision', 'Trace', 'beta_t', 'membrane_t', 'threshold_t']\n", - " fc2 : ['Precision', 'ReuseFactor', 'Trace']\n", - " readout : ['Precision', 'StateResetPolicy', 'Trace', 'membrane_t']\n" - ] - } - ], - "source": [ - "def make_hls_config(step_model):\n", - "\n", - " cfg = hls4ml.utils.config_from_pytorch_model(\n", - " step_model,\n", - " input_shape=(2,),\n", - " granularity='name',\n", - " backend=backend,\n", - " default_precision=precision,\n", - " )\n", - "\n", - " cfg['Model']['ReuseFactor'] = 1\n", - " cfg['Model'].setdefault('Precision', {})['default'] = precision\n", - "\n", - " for layer_name, layer_cfg in cfg.get('LayerName', {}).items():\n", - " layer_precision = layer_cfg.setdefault('Precision', {})\n", - "\n", - " for key in ('result', 'accum', 'weight', 'bias'):\n", - " layer_precision[key] = precision\n", - "\n", - " if layer_name in {'if1', 'if2'}:\n", - " for key in ('beta', 'threshold', 'membrane'):\n", - " layer_precision[key] = precision\n", - " layer_cfg['beta_t'] = precision\n", - " layer_cfg['threshold_t'] = precision\n", - " layer_cfg['membrane_t'] = precision\n", - "\n", - " if layer_name == 'readout':\n", - " layer_precision['result'] = readout_result_precision\n", - " layer_precision['membrane'] = readout_membrane_precision\n", - " layer_cfg['membrane_t'] = readout_membrane_precision\n", - "\n", - " return cfg\n", - "\n", - "\n", - "hls_config = make_hls_config(model)\n", - "\n", - "print(json.dumps(hls_config['Model'], indent=2, default=str))\n", - "print('\\nLayer entries:')\n", - "for name, cfg in hls_config.get('LayerName', {}).items():\n", - " print(f' {name:10s}: {sorted(cfg.keys())}')" - ] - }, - { - "cell_type": "markdown", - "id": "96a444fe-62b1-4cb3-87f5-ca417d198f0f", - "metadata": {}, - "source": [ - "## convert to hls" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "4caec5ac-49fb-4617-a1bb-57f100e0bd3b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Interpreting Model ...\n", - "Topology:\n", - "Layer name: fc1, layer type: Dense, input shape: [[None, 2]]\n", - "Layer name: if1, layer type: LIFNeuron, input shape: [[None, 8]]\n", - "Layer name: fc2, layer type: Dense, input shape: [[None, 8]]\n", - "Layer name: readout, layer type: SNNReadout, input shape: [[None, 2]]\n" - ] - } - ], - "source": [ - "output_dir = Path('examples/snn_example')\n", - "proj_name = 'test'\n", - "hls_dir = output_dir / proj_name\n", - "hls_dir.mkdir(parents=True, exist_ok=True)\n", - "\n", - "hls_model = hls4ml.converters.convert_from_pytorch_model(\n", - " model,\n", - " output_dir=str(hls_dir),\n", - " project_name=proj_name,\n", - " backend=backend,\n", - " io_type='io_stream',\n", - " hls_config=hls_config,\n", - " part=part,\n", - " clock_period=clock_period,\n", - " clock_uncertainty=clock_uncertainty,\n", - ")\n", - "hls_model.write()" - ] - }, - { - "cell_type": "markdown", - "id": "42d3bfc3-5ca2-483e-85ec-4142468e0590", - "metadata": {}, - "source": [ - "## get hls benchmark\n", - "\n", - "Compile immediately before evaluating full sequences. The compiled SNN state persists between calls, and the fixed-window reset occurs after exactly `timesteps` calls. If HLS accuracy is much lower than the PyTorch reference, first check that the generated `parameters.h` contains `window_size` in the IF/LIF config and that the fixed-point precision is not too narrow." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "20871206-0418-4a71-b4c2-0959d0c0544b", - "metadata": {}, - "outputs": [], - "source": [ - "def _as_scalar(y_step):\n", - " if isinstance(y_step, tuple):\n", - " y_step = y_step[0]\n", - " if isinstance(y_step, dict):\n", - " y_step = y_step[next(iter(y_step.keys()))]\n", - " return float(np.asarray(y_step).reshape(-1)[0])\n", - "\n", - "\n", - "def assert_fixed_window_reset_was_generated(hls_dir, window_size):\n", - " parameters_h = hls_dir / 'firmware' / 'parameters.h'\n", - " text = parameters_h.read_text()\n", - " expected = f'static const unsigned window_size = {window_size};'\n", - " if expected not in text:\n", - " raise RuntimeError(\n", - " f'{parameters_h} does not contain {expected!r}. Re-run the conversion/write cell before compiling.'\n", - " )\n", - "\n", - "\n", - "def predict_hls_sequences(hls_model, x_seq, timesteps):\n", - " \"\"\"Run one fixed-window sequence at a time through the stateful HLS model.\"\"\"\n", - " values = []\n", - " for sample in range(x_seq.shape[0]):\n", - " last = None\n", - " for step in range(timesteps):\n", - " x_step = x_seq[sample, step, :].astype(np.float32)[None, :]\n", - " last = _as_scalar(hls_model.predict(x_step))\n", - " values.append(last)\n", - " return np.asarray(values, dtype=np.float32)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "9b077b56-470b-4cb2-ab58-be960ed7cda2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "accuracy: 0.95\n", - "throughput_samples_per_s: 639.4442680253416\n" - ] - } - ], - "source": [ - "# assert_fixed_window_reset_was_generated(hls_dir, timesteps)\n", - "\n", - "# Compile immediately before sequence evaluation. Avoid making stray single-timestep\n", - "# predict calls before this loop; the compiled SNN state is persistent between calls.\n", - "hls_model.compile()\n", - "t0 = time.perf_counter()\n", - "raw = predict_hls_sequences(hls_model, x_tst, timesteps)\n", - "\n", - "if model.readout.decision_rule == 'binary_logit':\n", - " preds = (raw > 0).astype(np.int64)\n", - "else:\n", - " preds = np.rint(raw).astype(np.int64)\n", - "\n", - "elapsed = time.perf_counter() - t0\n", - "print('accuracy: ', float(np.mean(preds == y_tst)))\n", - "print('throughput_samples_per_s: ', float(x_tst.shape[0] / elapsed) if elapsed > 0 else 0.0)" - ] - }, - { - "cell_type": "markdown", - "id": "c4998d68-1c5c-4ca0-9dd0-d503fafa0976", - "metadata": {}, - "source": [ - "## neurobench" - ] - }, - { - "cell_type": "markdown", - "id": "26de1bc7-c257-448d-945d-2026085299cd", - "metadata": {}, - "source": [ - "The model defined as it is here, is also compatiable with neurobench. We just need some helper functions." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "70c8d03e-29ea-434e-80dc-60715d5e5188", - "metadata": {}, - "outputs": [], - "source": [ - "class NeuroBenchStepAdapter(nn.Module):\n", - " def __init__(self, step_model):\n", - " super().__init__()\n", - " self.step_model = step_model\n", - "\n", - " def forward(self, x_t):\n", - " y = self.step_model(x_t)\n", - " if isinstance(y, tuple):\n", - " return y\n", - " return y, None\n", - "\n", - " def reset(self):\n", - " reset_snn_state(self.step_model)\n", - "\n", - "\n", - "class NeuroBenchReadoutPostprocessor:\n", - " def __init__(self, decision_rule='argmax_spike_count', class_threshold=5):\n", - " self.decision_rule = decision_rule\n", - " self.class_threshold = class_threshold\n", - "\n", - " def __call__(self, preds):\n", - " if isinstance(preds, tuple):\n", - " preds = preds[0]\n", - " if isinstance(preds, np.ndarray):\n", - " preds = torch.from_numpy(preds)\n", - " if not torch.is_tensor(preds):\n", - " preds = torch.as_tensor(preds)\n", - "\n", - " counts = preds.sum(dim=1) if preds.ndim == 3 else preds\n", - "\n", - " if self.decision_rule == 'binary_logit':\n", - " return (counts[:, 1] - counts[:, 0] > 0).long()\n", - " if self.decision_rule == 'argmax_spike_count':\n", - " return counts.argmax(dim=1).long()\n", - "\n", - " reached = counts >= self.class_threshold\n", - " has_reached = reached.any(dim=1)\n", - " first_reached = reached.float().argmax(dim=1)\n", - " fallback = counts.argmax(dim=1)\n", - " return torch.where(has_reached, first_reached, fallback).long()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "e051851e-20cd-4ee9-9247-8fffb3a1490f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running benchmark\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [00:00<00:00, 32.28it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " \"Footprint\": 9788,\n", - " \"ConnectionSparsity\": 0.0,\n", - " \"ClassificationAccuracy\": 0.976666669845581,\n", - " \"ActivationSparsity\": 0.7599916666666667,\n", - " \"SynapticOperations\": {\n", - " \"Effective_MACs\": 800.0,\n", - " \"Effective_ACs\": 192.00666666666666,\n", - " \"Dense\": 1600.0\n", - " }\n", - "}\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "if HAS_NEUROBENCH:\n", - " model.eval()\n", - " test_loader = DataLoader(TensorDataset(tx_tst.float(), ty_tst.long()), batch_size=64, shuffle=False)\n", - "\n", - " nb_model = SNNTorchModel(NeuroBenchStepAdapter(model))\n", - " preprocessors = []\n", - " postprocessors = [\n", - " NeuroBenchReadoutPostprocessor(\n", - " decision_rule=model.readout.decision_rule,\n", - " class_threshold=model.readout.class_threshold,\n", - " )\n", - " ]\n", - " static_metrics = [Footprint, ConnectionSparsity]\n", - " workload_metrics = [ClassificationAccuracy, ActivationSparsity, SynapticOperations]\n", - "\n", - " benchmark = Benchmark(\n", - " nb_model,\n", - " test_loader,\n", - " preprocessors,\n", - " postprocessors,\n", - " [static_metrics, workload_metrics],\n", - " )\n", - "\n", - " device = 'cuda' if torch.cuda.is_available() else 'cpu'\n", - " results = benchmark.run(device=device)\n", - " print(json.dumps(results, indent=2))\n", - "else:\n", - " print('NeuroBench is not installed in this environment.')" - ] - }, - { - "cell_type": "markdown", - "id": "b26fca09-8566-429a-a21c-a412617adec3", - "metadata": {}, - "source": [ - "## full hls build" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "94374d2d-1636-47dc-9759-f4cca8473aa4", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "****** vitis-run v2024.1 (64-bit)\n", - " **** SW Build 5074859 on 2024-05-20-23:21:20\n", - " **** Start of session at: Tue May 5 18:06:10 2026\n", - " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", - " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", - "\n", - "INFO: [vitis-run 82-31] Launching vitis_hls: vitis_hls -nolog -run tcl -f /home/b/Physics/hls4ml/examples/snn_example/test/build_prj.tcl -work_dir /home/b/Physics/hls4ml/examples/snn_example/test\n", - "\n", - "****** Vitis HLS - High-Level Synthesis from C, C++ and OpenCL v2024.1 (64-bit)\n", - " **** SW Build 5069499 on May 21 2024\n", - " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", - " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Tue May 5 18:06:11 2026\n", - " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", - " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", - "\n", - "source /tools/Xilinx/Vitis_HLS/2024.1/scripts/vitis_hls/hls.tcl -notrace\n", - "INFO: [HLS 200-10] For user 'b' on host 'b-comp' (Linux_x86_64 version 6.12.64-1-MANJARO) on Tue May 05 18:06:12 IST 2026\n", - "INFO: [HLS 200-10] On os \"Manjaro Linux\"\n", - "INFO: [HLS 200-10] In directory '/home/b/Physics/hls4ml/examples/snn_example/test'\n", - "Sourcing Tcl script '/home/b/Physics/hls4ml/examples/snn_example/test/build_prj.tcl'\n", - "INFO: [HLS 200-1510] Running: open_project -reset test_prj \n", - "INFO: [HLS 200-10] Creating and opening project '/home/b/Physics/hls4ml/examples/snn_example/test/test_prj'.\n", - "INFO: [HLS 200-1510] Running: set_top test \n", - "INFO: [HLS 200-1510] Running: add_files firmware/test.cpp -cflags -std=c++0x \n", - "INFO: [HLS 200-10] Adding design file 'firmware/test.cpp' to the project\n", - "INFO: [HLS 200-1510] Running: add_files -tb test_test.cpp -cflags -std=c++0x \n", - "INFO: [HLS 200-10] Adding test bench file 'test_test.cpp' to the project\n", - "INFO: [HLS 200-1510] Running: add_files -tb firmware/weights \n", - "INFO: [HLS 200-10] Adding test bench file 'firmware/weights' to the project\n", - "INFO: [HLS 200-1510] Running: add_files -tb tb_data \n", - "INFO: [HLS 200-10] Adding test bench file 'tb_data' to the project\n", - "INFO: [HLS 200-1510] Running: open_solution -reset solution1 \n", - "INFO: [HLS 200-10] Creating and opening solution '/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1'.\n", - "INFO: [HLS 200-10] Cleaning up the solution database.\n", - "INFO: [HLS 200-1505] Using default flow_target 'vivado'\n", - "Resolution: For help on HLS 200-1505 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=200-1505.html\n", - "INFO: [HLS 200-1510] Running: config_array_partition -maximum_size 4096 \n", - "ERROR: [HLS 200-101] config_array_partition: Unknown option '-maximum_size'.\n", - "ERROR: [HLS 200-101] config_array_partition: Unknown option '4096'.\n", - "SYNTAX \n", - " config_array_partition [OPTIONS]\n", - " -auto_partition_threshold *** DEPRECATED***\n", - " -auto_promotion_threshold *** DEPRECATED***\n", - " -complete_threshold \n", - " -throughput_driven \n", - "\n", - "SEE ALSO\n", - " INI: syn.array_partition.complete_threshold syn.array_partition.throughput_driven\n", - " docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1399-vitis-hls&resourceid=vyw1583260160301.html\n", - "\n", - "INFO: [HLS 200-1510] Running: config_compile -name_max_length 80 \n", - "INFO: [XFORM 203-1161] The maximum of name length is set to 80.\n", - "INFO: [HLS 200-1510] Running: set_part xczu7ev-ffvc1156-2-e \n", - "INFO: [HLS 200-1611] Setting target device to 'xczu7ev-ffvc1156-2-e'\n", - "INFO: [XFORM 203-1161] The maximum of name length is set to 80.\n", - "INFO: [HLS 200-1510] Running: config_schedule -enable_dsp_full_reg=false \n", - "INFO: [HLS 200-1510] Running: create_clock -period 5 -name default \n", - "INFO: [SYN 201-201] Setting up clock 'default' with a period of 5ns.\n", - "INFO: [HLS 200-1510] Running: set_clock_uncertainty 18% default \n", - "INFO: [SYN 201-201] Setting up clock 'default' with an uncertainty of 0.9ns.\n", - "***** C SIMULATION *****\n", - "INFO: [HLS 200-1510] Running: csim_design \n", - "INFO: [SIM 211-2] *************** CSIM start ***************\n", - "INFO: [SIM 211-4] CSIM will launch CLANG as the compiler.\n", - "INFO: [HLS 200-2036] Building debug C Simulation binaries\n", - " Compiling ../../../../test_test.cpp in debug mode\n", - " Compiling ../../../../firmware/test.cpp in debug mode\n", - " Generating csim.exe\n", - "INFO: Unable to open input/predictions file, using default input.\n", - "0 \n", - "1 \n", - "0 \n", - "0 \n", - "0 \n", - "INFO: Saved inference results to file: tb_data/csim_results.log\n", - "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", - "INFO: [SIM 211-1] CSim done with 0 errors.\n", - "INFO: [SIM 211-3] *************** CSIM finish ***************\n", - "INFO: [HLS 200-2161] Finished Command csim_design Elapsed time: 00:00:03; Allocated memory: 0.047 MB.\n", - "***** C SIMULATION COMPLETED IN 0h0m3s *****\n", - "***** C/RTL SYNTHESIS *****\n", - "INFO: [HLS 200-1510] Running: csynth_design \n", - "INFO: [HLS 200-111] Finished File checks and directory preparation: CPU user time: 0.05 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 326.793 MB.\n", - "INFO: [HLS 200-10] Analyzing design file 'firmware/test.cpp' ... \n", - "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:33:9)\n", - "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:107:9)\n", - "WARNING: [HLS 207-5538] 'Resource pragma' is deprecated, use 'bind_op/bind_storage pragma' instead (firmware/nnet_utils/nnet_dense_resource.h:189:9)\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/test.cpp:41:59)\n", - "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/test.cpp:41:63)\n", - "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/test.cpp:43:75)\n", - "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/test.cpp:43:84)\n", - "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/test.cpp:45:70)\n", - "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 214-113] Either use an argument of the function or declare the variable inside the dataflow loop body (firmware/test.cpp:45:74)\n", - "Resolution: For help on HLS 214-113 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=214-113.html\n", - "WARNING: [HLS 200-471] Dataflow form checks found 6 issue(s) in file firmware/test.cpp\n", - "Resolution: For help on HLS 200-471 see docs.xilinx.com/access/sources/dita/topic?Doc_Version=2024.1%20English&url=ug1448-hls-guidance&resourceid=200-471.html\n", - "WARNING: [HLS 207-5292] unused parameter 'keep' (firmware/nnet_utils/nnet_helpers.h:285:99)\n", - "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:14:36)\n", - "WARNING: [HLS 207-5292] unused parameter 'buffer' (firmware/nnet_utils/nnet_function_stubs.h:15:36)\n", - "WARNING: [HLS 207-5292] unused parameter 'partition' (firmware/nnet_utils/nnet_function_stubs.h:16:44)\n", - "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:24:24)\n", - "WARNING: [HLS 207-5292] unused parameter 'buffer' (firmware/nnet_utils/nnet_function_stubs.h:25:24)\n", - "WARNING: [HLS 207-5292] unused parameter 'partition' (firmware/nnet_utils/nnet_function_stubs.h:26:32)\n", - "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:33:30)\n", - "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_function_stubs.h:33:58)\n", - "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_function_stubs.h:34:51)\n", - "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_function_stubs.h:35:49)\n", - "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:42:30)\n", - "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_function_stubs.h:42:58)\n", - "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_function_stubs.h:43:51)\n", - "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_function_stubs.h:44:49)\n", - "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_function_stubs.h:51:29)\n", - "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_function_stubs.h:51:80)\n", - "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_function_stubs.h:52:50)\n", - "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_function_stubs.h:53:48)\n", - "WARNING: [HLS 207-5292] unused parameter 'data' (firmware/nnet_utils/nnet_code_gen.h:16:39)\n", - "WARNING: [HLS 207-5292] unused parameter 'res' (firmware/nnet_utils/nnet_code_gen.h:17:38)\n", - "WARNING: [HLS 207-5292] unused parameter 'weights' (firmware/nnet_utils/nnet_code_gen.h:18:60)\n", - "WARNING: [HLS 207-5292] unused parameter 'biases' (firmware/nnet_utils/nnet_code_gen.h:19:58)\n", - "INFO: [HLS 200-111] Finished Source Code Analysis and Preprocessing: CPU user time: 4.27 seconds. CPU system time: 0.9 seconds. Elapsed time: 5.25 seconds; current allocated memory: 331.766 MB.\n", - "INFO: [HLS 200-777] Using interface defaults for 'Vivado' flow target.\n", - "INFO: [HLS 200-1995] There were 5,130 instructions in the design after the 'Compile/Link' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 3,258 instructions in the design after the 'Unroll/Inline (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,202 instructions in the design after the 'Unroll/Inline (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 1,039 instructions in the design after the 'Unroll/Inline (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 877 instructions in the design after the 'Unroll/Inline (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 427 instructions in the design after the 'Array/Struct (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 403 instructions in the design after the 'Array/Struct (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 409 instructions in the design after the 'Array/Struct (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 640 instructions in the design after the 'Array/Struct (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 637 instructions in the design after the 'Array/Struct (step 5)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 607 instructions in the design after the 'Performance (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 603 instructions in the design after the 'Performance (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 603 instructions in the design after the 'Performance (step 3)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 603 instructions in the design after the 'Performance (step 4)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 556 instructions in the design after the 'HW Transforms (step 1)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 200-1995] There were 545 instructions in the design after the 'HW Transforms (step 2)' phase of compilation. See the Design Size Report for more details: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/report/csynth_design_size.rpt\n", - "INFO: [HLS 214-415] Performing recursive inline in function 'nnet::dense, 2u>, nnet::array, 8u>, config2>' (firmware/nnet_utils/nnet_dense_stream.h:85:9)\n", - "WARNING: [HLS 214-273] In function 'void nnet::dense_latency_wrapper, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)', Pragma conflict happens on 'INLINE' and 'PIPELINE' pragmas: same function (firmware/nnet_utils/nnet_dense_stream.h:15:0)\n", - "INFO: [HLS 214-415] Performing recursive inline in function 'nnet::dense, 8u>, nnet::array, 2u>, config4>' (firmware/nnet_utils/nnet_dense_stream.h:85:9)\n", - "WARNING: [HLS 214-273] In function 'void nnet::dense_latency_wrapper, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)', Pragma conflict happens on 'INLINE' and 'PIPELINE' pragmas: same function (firmware/nnet_utils/nnet_dense_stream.h:15:0)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::array, 2u>::operator[](unsigned long) (.3)' into 'void nnet::data_prepare, 2u>, config2>(hls::stream, 2u>, 0>&, nnet::array, 2u>::value_type*) (.10)' (firmware/nnet_utils/nnet_dense_stream.h:47:17)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::product::mult, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0> >::product(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>)' into 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:42:27)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::array, 8u>::operator[](unsigned long) (.5)' into 'void nnet::res_write, 8u>, config2>(nnet::array, 8u>::value_type*, hls::stream, 8u>, 0>&) (.8)' (firmware/nnet_utils/nnet_dense_stream.h:75:2)\n", - "INFO: [HLS 214-131] Inlining function 'void nnet::data_prepare, 2u>, config2>(hls::stream, 2u>, 0>&, nnet::array, 2u>::value_type*) (.10)' into 'void nnet::dense, 2u>, nnet::array, 8u>, config2>(hls::stream, 2u>, 0>&, hls::stream, 8u>, 0>&, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:93:2)\n", - "INFO: [HLS 214-131] Inlining function 'void nnet::res_write, 8u>, config2>(nnet::array, 8u>::value_type*, hls::stream, 8u>, 0>&) (.8)' into 'void nnet::dense, 2u>, nnet::array, 8u>, config2>(hls::stream, 2u>, 0>&, hls::stream, 8u>, 0>&, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:100:5)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::array, 8u>::operator[](unsigned long) (.5)' into 'void nnet::data_prepare, 8u>, config4>(hls::stream, 8u>, 0>&, nnet::array, 8u>::value_type*) (.4)' (firmware/nnet_utils/nnet_dense_stream.h:47:17)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::product::mult, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0> >::product(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>)' into 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:42:27)\n", - "INFO: [HLS 214-131] Inlining function 'nnet::array, 2u>::operator[](unsigned long) (.3)' into 'void nnet::res_write, 2u>, config4>(nnet::array, 2u>::value_type*, hls::stream, 2u>, 0>&) (.1)' (firmware/nnet_utils/nnet_dense_stream.h:75:2)\n", - "INFO: [HLS 214-131] Inlining function 'void nnet::data_prepare, 8u>, config4>(hls::stream, 8u>, 0>&, nnet::array, 8u>::value_type*) (.4)' into 'void nnet::dense, 8u>, nnet::array, 2u>, config4>(hls::stream, 8u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:93:2)\n", - "INFO: [HLS 214-131] Inlining function 'void nnet::res_write, 2u>, config4>(nnet::array, 2u>::value_type*, hls::stream, 2u>, 0>&) (.1)' into 'void nnet::dense, 8u>, nnet::array, 2u>, config4>(hls::stream, 8u>, 0>&, hls::stream, 2u>, 0>&, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:100:5)\n", - "WARNING: [HLS 214-435] A depth specification is required for AXIS interface port 'layer5_out' for cosimulation. (firmware/test.cpp:10:0)\n", - "INFO: [HLS 214-291] Loop 'VITIS_LOOP_199_3' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_snn_readout.h:199:31)\n", - "INFO: [HLS 214-291] Loop 'VITIS_LOOP_185_2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_snn_readout.h:185:27)\n", - "INFO: [HLS 214-291] Loop 'VITIS_LOOP_172_1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_snn_readout.h:172:27)\n", - "INFO: [HLS 214-291] Loop 'Result' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:64:5)\n", - "INFO: [HLS 214-291] Loop 'Accum1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:54:5)\n", - "INFO: [HLS 214-291] Loop 'Accum2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:56:9)\n", - "INFO: [HLS 214-291] Loop 'ResetAccum' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:48:5)\n", - "INFO: [HLS 214-291] Loop 'Product1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:37:5)\n", - "INFO: [HLS 214-291] Loop 'Product2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_dense_latency.h:40:9)\n", - "INFO: [HLS 214-291] Loop 'VITIS_LOOP_119_2' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_lif_neuron.h:119:31)\n", - "INFO: [HLS 214-291] Loop 'VITIS_LOOP_91_1' is marked as complete unroll implied by the pipeline pragma (firmware/nnet_utils/nnet_lif_neuron.h:91:22)\n", - "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_199_3' (firmware/nnet_utils/nnet_snn_readout.h:199:31) in function 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>' completely with a factor of 2 (firmware/nnet_utils/nnet_snn_readout.h:158:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_185_2' (firmware/nnet_utils/nnet_snn_readout.h:185:27) in function 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>' completely with a factor of 1 (firmware/nnet_utils/nnet_snn_readout.h:158:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_172_1' (firmware/nnet_utils/nnet_snn_readout.h:172:27) in function 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>' completely with a factor of 2 (firmware/nnet_utils/nnet_snn_readout.h:158:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 8u>, nnet::array, 2u>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 8u>, nnet::array, 2u>, config4>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Accum1' (firmware/nnet_utils/nnet_dense_latency.h:54:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Accum2' (firmware/nnet_utils/nnet_dense_latency.h:56:9) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'ResetAccum' (firmware/nnet_utils/nnet_dense_latency.h:48:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_119_2' (firmware/nnet_utils/nnet_lif_neuron.h:119:31) in function 'nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>' completely with a factor of 8 (firmware/nnet_utils/nnet_lif_neuron.h:79:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'VITIS_LOOP_91_1' (firmware/nnet_utils/nnet_lif_neuron.h:91:22) in function 'nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>' completely with a factor of 8 (firmware/nnet_utils/nnet_lif_neuron.h:79:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'ResPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:73:9) in function 'nnet::dense, 2u>, nnet::array, 8u>, config2>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'DataPackSingle' (firmware/nnet_utils/nnet_dense_stream.h:45:9) in function 'nnet::dense, 2u>, nnet::array, 8u>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_stream.h:84:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Result' (firmware/nnet_utils/nnet_dense_latency.h:64:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Accum1' (firmware/nnet_utils/nnet_dense_latency.h:54:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Accum2' (firmware/nnet_utils/nnet_dense_latency.h:56:9) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'ResetAccum' (firmware/nnet_utils/nnet_dense_latency.h:48:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Product1' (firmware/nnet_utils/nnet_dense_latency.h:37:5) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 2 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-186] Unrolling loop 'Product2' (firmware/nnet_utils/nnet_dense_latency.h:40:9) in function 'nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>' completely with a factor of 8 (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(config2::accum_t)' into 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-178] Inlining function 'nnet::array, 8u>::operator[](unsigned long)' into 'void nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>(hls::stream, 8u>, 0>&, hls::stream, 8u>, 0>&, config3::beta_t const*, config3::threshold_t const*)' (firmware/nnet_utils/nnet_lif_neuron.h:79:0)\n", - "INFO: [HLS 214-178] Inlining function 'std::enable_if, ap_uint<1> >::value), ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0> >::type nnet::cast, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(config4::accum_t)' into 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_latency.h:15:0)\n", - "INFO: [HLS 214-178] Inlining function 'nnet::array, 2u>::operator[](unsigned long)' into 'void nnet::snn_readout, 2u>, nnet::array, 1u>, config5>(hls::stream, 2u>, 0>&, hls::stream, 1u>, 0>&)' (firmware/nnet_utils/nnet_snn_readout.h:158:0)\n", - "INFO: [HLS 214-178] Inlining function 'nnet::array, 1u>::operator[](unsigned long)' into 'void nnet::snn_readout, 2u>, nnet::array, 1u>, config5>(hls::stream, 2u>, 0>&, hls::stream, 1u>, 0>&)' (firmware/nnet_utils/nnet_snn_readout.h:158:0)\n", - "INFO: [HLS 214-248] Applying array_partition to 'b2': Complete partitioning on dimension 1. (firmware/weights/b2.h:12:0)\n", - "INFO: [HLS 214-248] Applying array_partition to 'b4': Complete partitioning on dimension 1. (firmware/weights/b4.h:12:0)\n", - "INFO: [HLS 214-248] Applying array_partition to '_ZZN4nnet11snn_readoutINS_5arrayI8ap_fixedILi8ELi4EL9ap_q_mode5EL9ap_o_mode3ELi0EELj2EEENS1_I6ap_intILi8EELj1EEE7config5EEvRN3hls6streamIT_Li0EEERNSC_IT0_Li0EEEE3mem': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_snn_readout.h:164:0)\n", - "INFO: [HLS 214-248] Applying array_partition to '_ZZN4nnet10lif_neuronINS_5arrayI8ap_fixedILi8ELi4EL9ap_q_mode5EL9ap_o_mode3ELi0EELj8EEES6_7config3EEvRN3hls6streamIT_Li0EEERNS9_IT0_Li0EEEPKNT1_6beta_tEPKNSG_11threshold_tEE3mem': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_lif_neuron.h:83:0)\n", - "INFO: [HLS 214-248] Applying array_partition to 'data': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_dense_stream.h:87:30)\n", - "INFO: [HLS 214-248] Applying array_partition to 'res': Complete partitioning on dimension 1. (firmware/nnet_utils/nnet_dense_stream.h:90:29)\n", - "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer4_out' with compact=bit mode in 16-bits (firmware/test.cpp:38:24)\n", - "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer3_out' with compact=bit mode in 64-bits (firmware/test.cpp:35:24)\n", - "INFO: [HLS 214-241] Aggregating fifo (hls::stream) variable 'layer2_out' with compact=bit mode in 64-bits (firmware/test.cpp:32:24)\n", - "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config2>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config2::weight_t*, config2::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", - "INFO: [HLS 214-364] Automatically inlining function 'void nnet::dense_latency, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' to improve effectiveness of pipeline pragma in function 'void nnet::dense_latency_wrapper, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>(ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>*, config4::weight_t*, config4::bias_t*)' (firmware/nnet_utils/nnet_dense_stream.h:17:2)\n", - "INFO: [HLS 200-111] Finished Compiling Optimization and Transform: CPU user time: 2.47 seconds. CPU system time: 0.51 seconds. Elapsed time: 7.27 seconds; current allocated memory: 341.859 MB.\n", - "INFO: [HLS 200-111] Finished Checking Pragmas: CPU user time: 0 seconds. CPU system time: 0 seconds. Elapsed time: 0 seconds; current allocated memory: 341.859 MB.\n", - "INFO: [HLS 200-10] Starting code transformations ...\n", - "INFO: [HLS 200-111] Finished Standard Transforms: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 343.133 MB.\n", - "INFO: [HLS 200-10] Checking synthesizability ...\n", - "INFO: [HLS 200-111] Finished Checking Synthesizability: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 345.484 MB.\n", - "INFO: [XFORM 203-712] Applying dataflow to function 'test' (firmware/test.cpp:8), detected/extracted 4 process function(s): \n", - "\t 'nnet::dense, 2u>, nnet::array, 8u>, config2>'\n", - "\t 'nnet::lif_neuron, 8u>, nnet::array, 8u>, config3>'\n", - "\t 'nnet::dense, 8u>, nnet::array, 2u>, config4>'\n", - "\t 'nnet::snn_readout, 2u>, nnet::array, 1u>, config5>'.\n", - "INFO: [XFORM 203-11] Balancing expressions in function 'nnet::dense_latency_wrapper, ap_fixed<8, 4, (ap_q_mode)5, (ap_o_mode)3, 0>, config4>' (firmware/nnet_utils/nnet_dense_stream.h:18:1)...14 expression(s) balanced.\n", - "INFO: [HLS 200-111] Finished Loop, function and other optimizations: CPU user time: 0.06 seconds. CPU system time: 0.02 seconds. Elapsed time: 0.08 seconds; current allocated memory: 369.223 MB.\n", - "INFO: [HLS 200-111] Finished Architecture Synthesis: CPU user time: 0.06 seconds. CPU system time: 0 seconds. Elapsed time: 0.07 seconds; current allocated memory: 419.227 MB.\n", - "INFO: [HLS 200-10] Starting hardware synthesis ...\n", - "INFO: [HLS 200-10] Synthesizing 'test' ...\n", - "WARNING: [SYN 201-103] Legalizing function name 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config2>' to 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s'.\n", - "WARNING: [SYN 201-103] Legalizing function name 'dense,array,8u>,config2>' to 'dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s'.\n", - "WARNING: [SYN 201-103] Legalizing function name 'lif_neuron,array,8u>,config3>' to 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s'.\n", - "WARNING: [SYN 201-103] Legalizing function name 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config4>' to 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s'.\n", - "WARNING: [SYN 201-103] Legalizing function name 'dense,array,2u>,config4>' to 'dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s'.\n", - "WARNING: [SYN 201-103] Legalizing function name 'snn_readout, 2u>, array, 1u>, config5>' to 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s'.\n", - "WARNING: [SYN 201-223] Checking resource limit in 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config4>': cannot find any operation of 'mul'.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config2>'.\n", - "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config2>'\n", - "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.07 seconds. CPU system time: 0.02 seconds. Elapsed time: 0.08 seconds; current allocated memory: 419.227 MB.\n", - "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", - "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", - "INFO: [BIND 205-101] Exploring resource sharing.\n", - "INFO: [BIND 205-101] Binding ...\n", - "INFO: [BIND 205-100] Starting global binding ...\n", - "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 419.227 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.03 seconds; current allocated memory: 419.996 MB.\n", - "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", - "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", - "INFO: [BIND 205-101] Exploring resource sharing.\n", - "INFO: [BIND 205-101] Binding ...\n", - "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.01 seconds; current allocated memory: 419.996 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-61] Pipelining function 'lif_neuron,array,8u>,config3>'.\n", - "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 2, function 'lif_neuron,array,8u>,config3>'\n", - "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.06 seconds. CPU system time: 0 seconds. Elapsed time: 0.06 seconds; current allocated memory: 420.438 MB.\n", - "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", - "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", - "INFO: [BIND 205-101] Exploring resource sharing.\n", - "INFO: [BIND 205-101] Binding ...\n", - "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 420.438 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-61] Pipelining function 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config4>'.\n", - "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 1, function 'dense_latency_wrapper, ap_fixed<8, 4, 5, 3, 0>, config4>'\n", - "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.05 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 420.723 MB.\n", - "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", - "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", - "INFO: [BIND 205-101] Exploring resource sharing.\n", - "INFO: [BIND 205-101] Binding ...\n", - "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 420.918 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 421.867 MB.\n", - "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", - "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", - "INFO: [BIND 205-101] Exploring resource sharing.\n", - "INFO: [BIND 205-101] Binding ...\n", - "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.01 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.02 seconds; current allocated memory: 421.867 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-61] Pipelining function 'snn_readout, 2u>, array, 1u>, config5>'.\n", - "INFO: [HLS 200-1470] Pipelining result : Target II = 1, Final II = 1, Depth = 2, function 'snn_readout, 2u>, array, 1u>, config5>'\n", - "INFO: [SCHED 204-11] Finished scheduling.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 422.297 MB.\n", - "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", - "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", - "INFO: [BIND 205-101] Exploring resource sharing.\n", - "INFO: [BIND 205-101] Binding ...\n", - "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 422.297 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-42] -- Implementing module 'test' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [SCHED 204-11] Starting scheduling ...\n", - "INFO: [SCHED 204-11] Finished scheduling.\n", - "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer2_out (from dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_U0 to lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0) to 2 to improve performance and/or avoid deadlocks.\n", - "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer3_out (from lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0 to dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0) to 2 to improve performance and/or avoid deadlocks.\n", - "WARNING: [HLS 200-1018] Consider increasing the depth of FIFO layer4_out (from dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0 to snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0) to 2 to improve performance and/or avoid deadlocks.\n", - "INFO: [HLS 200-111] Finished Scheduling: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 422.508 MB.\n", - "INFO: [BIND 205-100] Starting micro-architecture generation ...\n", - "INFO: [BIND 205-101] Performing variable lifetime analysis.\n", - "INFO: [BIND 205-101] Exploring resource sharing.\n", - "INFO: [BIND 205-101] Binding ...\n", - "INFO: [BIND 205-100] Finished micro-architecture generation.\n", - "INFO: [HLS 200-111] Finished Binding: CPU user time: 0.02 seconds. CPU system time: 0 seconds. Elapsed time: 0.02 seconds; current allocated memory: 422.508 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [RTGEN 206-100] Generating core module 'mul_8s_5s_12_1_1': 1 instance(s).\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.03 seconds. CPU system time: 0 seconds. Elapsed time: 0.03 seconds; current allocated memory: 422.578 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 424.164 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_7' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_6' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_5' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_4' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_3' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_2' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem_1' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_lif_neuron_stream_stream_beta_t_const_threshold_t_const_mem' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'ts_1' is power-on initialization.\n", - "INFO: [HLS 200-1030] Apply Unified Pipeline Control on module 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s' pipeline 'lif_neuron,array,8u>,config3>' pipeline type 'function pipeline'\n", - "INFO: [RTGEN 206-100] Generating core module 'mul_8s_5ns_12_1_1': 8 instance(s).\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.05 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.06 seconds; current allocated memory: 425.570 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0 seconds. Elapsed time: 0.07 seconds; current allocated memory: 428.039 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.06 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.08 seconds; current allocated memory: 429.988 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "WARNING: [RTGEN 206-101] Register 'void_snn_readout_stream_array_0_stream_array_ap_int_8_1u_0_mem_1' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'void_snn_readout_stream_array_0_stream_array_ap_int_8_1u_0_mem' is power-on initialization.\n", - "WARNING: [RTGEN 206-101] Register 'ts' is power-on initialization.\n", - "INFO: [HLS 200-1030] Apply Unified Pipeline Control on module 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s' pipeline 'snn_readout, 2u>, array, 1u>, config5>' pipeline type 'function pipeline'\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s'.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.04 seconds. CPU system time: 0 seconds. Elapsed time: 0.05 seconds; current allocated memory: 430.836 MB.\n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "INFO: [HLS 200-10] -- Generating RTL for module 'test' \n", - "INFO: [HLS 200-10] ----------------------------------------------------------------\n", - "WARNING: [RTGEN 206-101] Design contains AXI ports. Reset is fixed to synchronous and active low.\n", - "INFO: [RTGEN 206-500] Setting interface mode on port 'test/x_t' to 'axis' (register, both mode).\n", - "INFO: [RTGEN 206-500] Setting interface mode on port 'test/layer5_out' to 'axis' (register, both mode).\n", - "INFO: [RTGEN 206-500] Setting interface mode on function 'test' to 'ap_ctrl_hs'.\n", - "INFO: [RTGEN 206-100] Finished creating RTL model for 'test'.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'layer2_out_U(test_fifo_w64_d1_S)' using Shift Registers.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'layer3_out_U(test_fifo_w64_d1_S)' using Shift Registers.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'layer4_out_U(test_fifo_w16_d1_S)' using Shift Registers.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0_U(test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0)' using Shift Registers.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0_U(test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0)' using Shift Registers.\n", - "INFO: [RTMG 210-285] Implementing FIFO 'start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_U(test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0)' using Shift Registers.\n", - "INFO: [HLS 200-111] Finished Creating RTL model: CPU user time: 0.04 seconds. CPU system time: 0.03 seconds. Elapsed time: 0.07 seconds; current allocated memory: 431.961 MB.\n", - "INFO: [HLS 200-111] Finished Generating all RTL models: CPU user time: 0.13 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.14 seconds; current allocated memory: 434.301 MB.\n", - "INFO: [HLS 200-111] Finished Updating report files: CPU user time: 0.3 seconds. CPU system time: 0.01 seconds. Elapsed time: 0.31 seconds; current allocated memory: 439.715 MB.\n", - "INFO: [VHDL 208-304] Generating VHDL RTL for test.\n", - "INFO: [VLOG 209-307] Generating Verilog RTL for test.\n", - "INFO: [HLS 200-789] **** Estimated Fmax: 251.00 MHz\n", - "INFO: [HLS 200-2161] Finished Command csynth_design Elapsed time: 00:00:14; Allocated memory: 113.926 MB.\n", - "***** C/RTL SYNTHESIS COMPLETED IN 0h0m14s *****\n", - "***** C/RTL SIMULATION *****\n", - "INFO: [HLS 200-1510] Running: add_files -tb test_test.cpp -cflags -std=c++0x -DRTL_SIM \n", - "INFO: [HLS 200-10] Adding test bench file 'test_test.cpp' to the project\n", - "INFO: [HLS 200-1510] Running: cosim_design -trace_level all -setup \n", - "INFO: [COSIM 212-47] Using XSIM for RTL simulation.\n", - "INFO: [COSIM 212-14] Instrumenting C test bench ...\n", - " Build using \"/tools/Xilinx/Vitis_HLS/2024.1/vcxx/libexec/clang++\"\n", - " Compiling apatb_test.cpp\n", - " Compiling apatb_test_util.cpp\n", - " Compiling test.cpp_pre.cpp.tb.cpp\n", - " Compiling test_test.cpp_pre.cpp.tb.cpp\n", - " Compiling apatb_test_ir.ll\n", - " Generating cosim.tv.exe\n", - "INFO: [COSIM 212-302] Starting C TB testing ... \n", - "INFO: Unable to open input/predictions file, using default input.\n", - "0 \n", - "1 \n", - "0 \n", - "0 \n", - "0 \n", - "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", - "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", - "INFO: [COSIM 212-333] Generating C post check test bench ...\n", - "INFO: [COSIM 212-12] Generating RTL test bench ...\n", - "INFO: [COSIM 212-1] *** C/RTL co-simulation file generation completed. ***\n", - "INFO: [HLS 200-2161] Finished Command cosim_design Elapsed time: 00:00:11; Allocated memory: 11.648 MB.\n", - "INFO: [HLS 200-1510] Running: source /home/b/Physics/hls4ml/examples/snn_example/test/project.tcl\n", - "INFO: [HLS 200-1510] Running: source run_sim.tcl\n", - "INFO: [HLS 200-1510] Running: source check_sim.tcl\n", - "INFO: [HLS 200-1510] Running: source dataflow_monitor_API.tcl\n", - "INFO: [COSIM 212-302] Starting C TB testing ... \n", - "INFO: Unable to open input/predictions file, using default input.\n", - "0 \n", - "1 \n", - "0 \n", - "0 \n", - "0 \n", - "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", - "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", - "INFO: [COSIM 212-323] Starting verilog simulation...\n", - "INFO: [COSIM 212-15] Starting XSIM ...\n", - "Vivado Simulator v2024.1\n", - "Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", - "Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", - "Running: /tools/Xilinx/Vivado/2024.1/bin/unwrapped/lnx64.o/xelab xil_defaultlib.apatb_test_top glbl -Oenable_linking_all_libraries -prj test.prj -L smartconnect_v1_0 -L axi_protocol_checker_v1_1_12 -L axi_protocol_checker_v1_1_13 -L axis_protocol_checker_v1_1_11 -L axis_protocol_checker_v1_1_12 -L xil_defaultlib -L unisims_ver -L xpm -L floating_point_v7_0_23 -L floating_point_v7_1_18 --lib ieee_proposed=./ieee_proposed -s test -debug all \n", - "Multi-threading is on. Using 14 slave threads.\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/glbl.v\" into library work\n", - "INFO: [VRFC 10-311] analyzing module glbl\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test.autotb.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module apatb_test_top\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_fifo.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module fifo\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_axi_s_x_t.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_axi_s_x_t\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_axi_s_layer5_out.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_axi_s_layer5_out\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_deadlock_detection_unit.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_deadlock_detect_unit\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_deadlock_report_unit.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_deadlock_report_unit\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_deadlock_detector.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_deadlock_detector\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_deadlock_kernel_monitor_top.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_deadlock_kernel_monitor_top\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/AESL_deadlock_idx0_monitor.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module AESL_deadlock_idx0_monitor\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_mul_8s_5s_12_1_1.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_mul_8s_5s_12_1_1\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_regslice_both.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_regslice_both\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_mul_8s_5ns_12_1_1.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_mul_8s_5ns_12_1_1\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_fifo_w64_d1_S.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_fifo_w64_d1_S\n", - "INFO: [VRFC 10-311] analyzing module test_fifo_w64_d1_S_ShiftReg\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_fifo_w16_d1_S.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_fifo_w16_d1_S\n", - "INFO: [VRFC 10-311] analyzing module test_fifo_w16_d1_S_ShiftReg\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0\n", - "INFO: [VRFC 10-311] analyzing module test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0_ShiftReg\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0\n", - "INFO: [VRFC 10-311] analyzing module test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0_ShiftReg\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0.v\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0\n", - "INFO: [VRFC 10-311] analyzing module test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_ShiftReg\n", - "INFO: [VRFC 10-2263] Analyzing SystemVerilog file \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/dataflow_monitor.sv\" into library xil_defaultlib\n", - "INFO: [VRFC 10-311] analyzing module dataflow_monitor\n", - "Starting static elaboration\n", - "Pass Through NonSizing Optimizer\n", - "Completed static elaboration\n", - "Starting simulation data flow analysis\n", - "Completed simulation data flow analysis\n", - "Time Resolution for simulation is 1ps\n", - "Compiling package xil_defaultlib.$unit_dataflow_monitor_sv\n", - "Compiling module xil_defaultlib.test_mul_8s_5s_12_1_1(NUM_STAGE=...\n", - "Compiling module xil_defaultlib.test_dense_latency_wrapper_ap_fi...\n", - "Compiling module xil_defaultlib.test_regslice_both(DataWidth=16)\n", - "Compiling module xil_defaultlib.test_dense_array_ap_fixed_2u_arr...\n", - "Compiling module xil_defaultlib.test_mul_8s_5ns_12_1_1(NUM_STAGE...\n", - "Compiling module xil_defaultlib.test_lif_neuron_array_ap_fixed_8...\n", - "Compiling module xil_defaultlib.test_dense_latency_wrapper_ap_fi...\n", - "Compiling module xil_defaultlib.test_dense_array_ap_fixed_8u_arr...\n", - "Compiling module xil_defaultlib.test_regslice_both\n", - "Compiling module xil_defaultlib.test_snn_readout_array_ap_fixed_...\n", - "Compiling module xil_defaultlib.test_fifo_w64_d1_S_ShiftReg\n", - "Compiling module xil_defaultlib.test_fifo_w64_d1_S_default\n", - "Compiling module xil_defaultlib.test_fifo_w16_d1_S_ShiftReg\n", - "Compiling module xil_defaultlib.test_fifo_w16_d1_S_default\n", - "Compiling module xil_defaultlib.test_start_for_lif_neuron_array_...\n", - "Compiling module xil_defaultlib.test_start_for_lif_neuron_array_...\n", - "Compiling module xil_defaultlib.test_start_for_dense_array_ap_fi...\n", - "Compiling module xil_defaultlib.test_start_for_dense_array_ap_fi...\n", - "Compiling module xil_defaultlib.test_start_for_snn_readout_array...\n", - "Compiling module xil_defaultlib.test_start_for_snn_readout_array...\n", - "Compiling module xil_defaultlib.test\n", - "Compiling module xil_defaultlib.fifo(DEPTH=2,WIDTH=16)\n", - "Compiling module xil_defaultlib.AESL_axi_s_x_t\n", - "Compiling module xil_defaultlib.fifo(DEPTH=2)\n", - "Compiling module xil_defaultlib.AESL_axi_s_layer5_out\n", - "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(IN_CHA...\n", - "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(PROC_I...\n", - "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(PROC_I...\n", - "Compiling module xil_defaultlib.AESL_deadlock_detect_unit(PROC_I...\n", - "Compiling module xil_defaultlib.AESL_deadlock_report_unit_defaul...\n", - "Compiling module xil_defaultlib.AESL_deadlock_detector_2\n", - "Compiling module xil_defaultlib.AESL_deadlock_idx0_monitor\n", - "Compiling module xil_defaultlib.AESL_deadlock_kernel_monitor_top...\n", - "Compiling module xil_defaultlib.df_fifo_intf_default\n", - "Compiling module xil_defaultlib.df_process_intf_default\n", - "Compiling module xil_defaultlib.nodf_module_intf_default\n", - "Compiling module xil_defaultlib.dataflow_monitor_1\n", - "Compiling module xil_defaultlib.apatb_test_top\n", - "Compiling module work.glbl\n", - "Built simulation snapshot test\n", - "\n", - "****** xsim v2024.1 (64-bit)\n", - " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", - " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", - " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Tue May 5 18:06:48 2026\n", - " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", - " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", - "\n", - "source xsim.dir/test/xsim_script.tcl\n", - "# xsim {test} -view {{test_dataflow_ana.wcfg}} -tclbatch {test.tcl} -protoinst {test.protoinst}\n", - "INFO: [Wavedata 42-565] Reading protoinst file test.protoinst\n", - "INFO: [Wavedata 42-564] Found protocol instance at /apatb_test_top/AESL_inst_test//AESL_inst_test_activity\n", - "INFO: [Wavedata 42-564] Found protocol instance at /apatb_test_top/AESL_inst_test/dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_U0/dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_U0_activity\n", - "INFO: [Wavedata 42-564] Found protocol instance at /apatb_test_top/AESL_inst_test/dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0/dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0_activity\n", - "INFO: [Wavedata 42-564] Found protocol instance at /apatb_test_top/AESL_inst_test/lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0/lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0_activity\n", - "INFO: [Wavedata 42-564] Found protocol instance at /apatb_test_top/AESL_inst_test/snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0/snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_activity\n", - "Time resolution is 1 ps\n", - "open_wave_config test_dataflow_ana.wcfg\n", - "source test.tcl\n", - "## set designtopgroup [add_wave_group \"Design Top Signals\"]\n", - "## set coutputgroup [add_wave_group \"C Outputs\" -into $designtopgroup]\n", - "## set return_group [add_wave_group return(axis) -into $coutputgroup]\n", - "## add_wave /apatb_test_top/AESL_inst_test/layer5_out_TREADY -into $return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_test_top/AESL_inst_test/layer5_out_TVALID -into $return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_test_top/AESL_inst_test/layer5_out_TDATA -into $return_group -radix hex\n", - "## set cinputgroup [add_wave_group \"C Inputs\" -into $designtopgroup]\n", - "## set return_group [add_wave_group return(axis) -into $cinputgroup]\n", - "## add_wave /apatb_test_top/AESL_inst_test/x_t_TREADY -into $return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_test_top/AESL_inst_test/x_t_TVALID -into $return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_test_top/AESL_inst_test/x_t_TDATA -into $return_group -radix hex\n", - "## set blocksiggroup [add_wave_group \"Block-level IO Handshake\" -into $designtopgroup]\n", - "## add_wave /apatb_test_top/AESL_inst_test/ap_start -into $blocksiggroup\n", - "## add_wave /apatb_test_top/AESL_inst_test/ap_done -into $blocksiggroup\n", - "## add_wave /apatb_test_top/AESL_inst_test/ap_ready -into $blocksiggroup\n", - "## add_wave /apatb_test_top/AESL_inst_test/ap_idle -into $blocksiggroup\n", - "## set resetgroup [add_wave_group \"Reset\" -into $designtopgroup]\n", - "## add_wave /apatb_test_top/AESL_inst_test/ap_rst_n -into $resetgroup\n", - "## set clockgroup [add_wave_group \"Clock\" -into $designtopgroup]\n", - "## add_wave /apatb_test_top/AESL_inst_test/ap_clk -into $clockgroup\n", - "## set testbenchgroup [add_wave_group \"Test Bench Signals\"]\n", - "## set tbinternalsiggroup [add_wave_group \"Internal Signals\" -into $testbenchgroup]\n", - "## set tb_simstatus_group [add_wave_group \"Simulation Status\" -into $tbinternalsiggroup]\n", - "## set tb_portdepth_group [add_wave_group \"Port Depth\" -into $tbinternalsiggroup]\n", - "## add_wave /apatb_test_top/AUTOTB_TRANSACTION_NUM -into $tb_simstatus_group -radix hex\n", - "## add_wave /apatb_test_top/ready_cnt -into $tb_simstatus_group -radix hex\n", - "## add_wave /apatb_test_top/done_cnt -into $tb_simstatus_group -radix hex\n", - "## add_wave /apatb_test_top/LENGTH_layer5_out -into $tb_portdepth_group -radix hex\n", - "## add_wave /apatb_test_top/LENGTH_x_t -into $tb_portdepth_group -radix hex\n", - "## set tbcoutputgroup [add_wave_group \"C Outputs\" -into $testbenchgroup]\n", - "## set tb_return_group [add_wave_group return(axis) -into $tbcoutputgroup]\n", - "## add_wave /apatb_test_top/layer5_out_TREADY -into $tb_return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_test_top/layer5_out_TVALID -into $tb_return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_test_top/layer5_out_TDATA -into $tb_return_group -radix hex\n", - "## set tbcinputgroup [add_wave_group \"C Inputs\" -into $testbenchgroup]\n", - "## set tb_return_group [add_wave_group return(axis) -into $tbcinputgroup]\n", - "## add_wave /apatb_test_top/x_t_TREADY -into $tb_return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_test_top/x_t_TVALID -into $tb_return_group -color #ffff00 -radix hex\n", - "## add_wave /apatb_test_top/x_t_TDATA -into $tb_return_group -radix hex\n", - "## save_wave_config test.wcfg\n", - "## run all\n", - "////////////////////////////////////////////////////////////////////////////////////\n", - "// Inter-Transaction Progress: Completed Transaction / Total Transaction\n", - "// Intra-Transaction Progress: Measured Latency / Latency Estimation * 100%\n", - "//\n", - "// RTL Simulation : \"Inter-Transaction Progress\" [\"Intra-Transaction Progress\"] @ \"Simulation Time\"\n", - "////////////////////////////////////////////////////////////////////////////////////\n", - "// RTL Simulation : 0 / 5 [0.00%] @ \"113000\"\n", - "// RTL Simulation : 1 / 5 [112.50%] @ \"183000\"\n", - "// RTL Simulation : 2 / 5 [125.00%] @ \"198000\"\n", - "// RTL Simulation : 3 / 5 [137.50%] @ \"213000\"\n", - "// RTL Simulation : 4 / 5 [125.00%] @ \"228000\"\n", - "// RTL Simulation : 5 / 5 [100.00%] @ \"233000\"\n", - "////////////////////////////////////////////////////////////////////////////////////\n", - "$finish called at time : 262500 ps : File \"/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/sim/verilog/test.autotb.v\" Line 249\n", - "## quit\n", - "INFO: [Common 17-206] Exiting xsim at Tue May 5 18:06:51 2026...\n", - "WARNING: [HLS 200-2011] Cannot find the 'zip' utility on this system. This is required for cosimulation.\n", - "INFO: [COSIM 212-316] Starting C post checking ...\n", - "INFO: Unable to open input/predictions file, using default input.\n", - "0 \n", - "1 \n", - "0 \n", - "0 \n", - "0 \n", - "INFO: Saved inference results to file: tb_data/rtl_cosim_results.log\n", - "INFO [HLS SIM]: The maximum depth reached by any hls::stream() instance in the design is 1\n", - "INFO:\n", - "Report time : Tue May 5 06:06:43 PM IST 2026.\n", - "Solution : solution1.\n", - "Simulation tool : xsim.\n", - "\n", - "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", - "| | | Latency(Clock Cycles) | Interval(Clock Cycles) | Total Execution Time |\n", - "+ RTL + Status +-----------------------------------------------+-----------------------------------------------+ (Clock Cycles) +\n", - "| | | min | avg | max | min | avg | max | |\n", - "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", - "| VHDL| NA| NA| NA| NA| NA| NA| NA| NA|\n", - "| Verilog| Pass| NA| NA| NA| NA| NA| NA| NA|\n", - "+----------+----------+-----------------------------------------------+-----------------------------------------------+----------------------+\n", - "\n", - "***** C/RTL SIMULATION COMPLETED IN 0h0m19s *****\n", - "***** C/RTL VALIDATION *****\n", - "INFO: Test PASSED\n", - "***** EXPORT IP *****\n", - "INFO: [HLS 200-1510] Running: export_design -format ip_catalog -version 1.0.0 \n", - "INFO: [IMPL 213-8] Exporting RTL as a Vivado IP.\n", - "\n", - "****** Vivado v2024.1 (64-bit)\n", - " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", - " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", - " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Tue May 5 18:06:52 2026\n", - " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", - " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", - "\n", - "source run_ippack.tcl -notrace\n", - "INFO: calling package_hls_ip ip_types=vitis sysgen json_file=/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/solution1_data.json outdir=/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip srcdir=/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1 sort_interfaces_ports=false\n", - "INFO: Copied 1 ipmisc file(s) to /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/misc\n", - "INFO: Copied 20 verilog file(s) to /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/hdl/verilog\n", - "INFO: Copied 15 vhdl file(s) to /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/hdl/vhdl\n", - "INFO: Import ports from HDL: /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/hdl/vhdl/test.vhd (test)\n", - "INFO: Add axi4stream interface x_t\n", - "INFO: Add axi4stream interface layer5_out\n", - "INFO: [IP_Flow 19-234] Refreshing IP repositories\n", - "INFO: [IP_Flow 19-1704] No user IP repositories specified\n", - "INFO: [IP_Flow 19-2313] Loaded Vivado IP repository '/tools/Xilinx/Vivado/2024.1/data/ip'.\n", - "INFO: Add clock interface ap_clk\n", - "INFO: Add reset interface ap_rst_n\n", - "INFO: Add ap_ctrl interface ap_ctrl\n", - "INFO: Calling post_process_vitis to specialize IP\n", - "INFO: Calling post_process_sysgen to specialize IP\n", - "Generating sysgen info xml from json file\n", - "INFO: Created IP /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/component.xml\n", - "INFO: Created IP archive /home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/impl/ip/xilinx_com_hls_test_1_0.zip\n", - "INFO: [Common 17-206] Exiting Vivado at Tue May 5 18:06:59 2026...\n", - "INFO: [HLS 200-802] Generated output file test_prj/solution1/impl/export.zip\n", - "INFO: [HLS 200-2161] Finished Command export_design Elapsed time: 00:00:18; Allocated memory: 0.000 MB.\n", - "***** EXPORT IP COMPLETED IN 0h0m18s *****\n", - "***** VIVADO SYNTHESIS *****\n", - "\n", - "****** Vivado v2024.1 (64-bit)\n", - " **** SW Build 5076996 on Wed May 22 18:36:09 MDT 2024\n", - " **** IP Build 5075265 on Wed May 22 21:45:21 MDT 2024\n", - " **** SharedData Build 5076995 on Wed May 22 18:29:18 MDT 2024\n", - " **** Start of session at: Tue May 5 18:07:10 2026\n", - " ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.\n", - " ** Copyright 2022-2024 Advanced Micro Devices, Inc. All Rights Reserved.\n", - "\n", - "source vivado_synth.tcl\n", - "# set tcldir [file dirname [info script]]\n", - "# source [file join $tcldir project.tcl]\n", - "## variable project_name\n", - "## set project_name \"test\"\n", - "## variable backend\n", - "## set backend \"vitis\"\n", - "## variable part\n", - "## set part \"xczu7ev-ffvc1156-2-e\"\n", - "## variable clock_period\n", - "## set clock_period 5\n", - "## variable clock_uncertainty\n", - "## set clock_uncertainty 18%\n", - "## variable version\n", - "## set version \"1.0.0\"\n", - "## variable maximum_size\n", - "## set maximum_size 4096\n", - "# add_files ${project_name}_prj/solution1/syn/verilog\n", - "# synth_design -top ${project_name} -part $part\n", - "Command: synth_design -top test -part xczu7ev-ffvc1156-2-e\n", - "Starting synth_design\n", - "Attempting to get a license for feature 'Synthesis' and/or device 'xczu7ev'\n", - "INFO: [Common 17-349] Got license for feature 'Synthesis' and/or device 'xczu7ev'\n", - "INFO: [Synth 8-7079] Multithreading enabled for synth_design using a maximum of 4 processes.\n", - "INFO: [Synth 8-7078] Launching helper process for spawning children vivado processes\n", - "INFO: [Synth 8-7075] Helper process launched with PID 34703\n", - "---------------------------------------------------------------------------------\n", - "Starting Synthesize : Time (s): cpu = 00:00:02 ; elapsed = 00:00:03 . Memory (MB): peak = 1875.867 ; gain = 425.633 ; free physical = 203 ; free virtual = 21711\n", - "---------------------------------------------------------------------------------\n", - "INFO: [Synth 8-6157] synthesizing module 'test' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_mul_8s_5s_12_1_1' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_mul_8s_5s_12_1_1.v:5]\n", - "\tParameter ID bound to: 1 - type: integer \n", - "\tParameter NUM_STAGE bound to: 1 - type: integer \n", - "\tParameter din0_WIDTH bound to: 8 - type: integer \n", - "\tParameter din1_WIDTH bound to: 5 - type: integer \n", - "\tParameter dout_WIDTH bound to: 12 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'test_mul_8s_5s_12_1_1' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_mul_8s_5s_12_1_1.v:5]\n", - "INFO: [Synth 8-6155] done synthesizing module 'test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_regslice_both' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_regslice_both.v:9]\n", - "\tParameter DataWidth bound to: 16 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'test_regslice_both' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_regslice_both.v:9]\n", - "INFO: [Synth 8-6155] done synthesizing module 'test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_mul_8s_5ns_12_1_1' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_mul_8s_5ns_12_1_1.v:5]\n", - "\tParameter ID bound to: 1 - type: integer \n", - "\tParameter NUM_STAGE bound to: 1 - type: integer \n", - "\tParameter din0_WIDTH bound to: 8 - type: integer \n", - "\tParameter din1_WIDTH bound to: 5 - type: integer \n", - "\tParameter dout_WIDTH bound to: 12 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'test_mul_8s_5ns_12_1_1' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_mul_8s_5ns_12_1_1.v:5]\n", - "INFO: [Synth 8-6155] done synthesizing module 'test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s.v:9]\n", - "INFO: [Synth 8-6155] done synthesizing module 'test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s.v:9]\n", - "INFO: [Synth 8-6155] done synthesizing module 'test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_regslice_both__parameterized0' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_regslice_both.v:9]\n", - "\tParameter DataWidth bound to: 8 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'test_regslice_both__parameterized0' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_regslice_both.v:9]\n", - "INFO: [Synth 8-6155] done synthesizing module 'test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s.v:9]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_fifo_w64_d1_S' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w64_d1_S.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_fifo_w64_d1_S_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w64_d1_S.v:129]\n", - "\tParameter DATA_WIDTH bound to: 64 - type: integer \n", - "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", - "\tParameter DEPTH bound to: 1 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'test_fifo_w64_d1_S_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w64_d1_S.v:129]\n", - "INFO: [Synth 8-6155] done synthesizing module 'test_fifo_w64_d1_S' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w64_d1_S.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_fifo_w16_d1_S' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w16_d1_S.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_fifo_w16_d1_S_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w16_d1_S.v:129]\n", - "\tParameter DATA_WIDTH bound to: 16 - type: integer \n", - "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", - "\tParameter DEPTH bound to: 1 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'test_fifo_w16_d1_S_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w16_d1_S.v:129]\n", - "INFO: [Synth 8-6155] done synthesizing module 'test_fifo_w16_d1_S' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_fifo_w16_d1_S.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0.v:125]\n", - "\tParameter DATA_WIDTH bound to: 1 - type: integer \n", - "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", - "\tParameter DEPTH bound to: 2 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0.v:125]\n", - "INFO: [Synth 8-6155] done synthesizing module 'test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0.v:125]\n", - "\tParameter DATA_WIDTH bound to: 1 - type: integer \n", - "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", - "\tParameter DEPTH bound to: 2 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0.v:125]\n", - "INFO: [Synth 8-6155] done synthesizing module 'test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0.v:11]\n", - "INFO: [Synth 8-6157] synthesizing module 'test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_ShiftReg' [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0.v:125]\n", - "\tParameter DATA_WIDTH bound to: 1 - type: integer \n", - "\tParameter ADDR_WIDTH bound to: 1 - type: integer \n", - "\tParameter DEPTH bound to: 2 - type: integer \n", - "INFO: [Synth 8-6155] done synthesizing module 'test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_ShiftReg' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0.v:125]\n", - "INFO: [Synth 8-6155] done synthesizing module 'test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0.v:11]\n", - "INFO: [Synth 8-6155] done synthesizing module 'test' (0#1) [/home/b/Physics/hls4ml/examples/snn_example/test/test_prj/solution1/syn/verilog/test.v:9]\n", - "WARNING: [Synth 8-7129] Port addr[0] in module test_fifo_w16_d1_S_ShiftReg is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port addr[0] in module test_fifo_w64_d1_S_ShiftReg is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[1] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[0] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[1] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[0] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port data_7_val8[1] in module test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port data_7_val8[0] in module test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port ap_rst in module test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port ap_rst in module test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", - "---------------------------------------------------------------------------------\n", - "Finished Synthesize : Time (s): cpu = 00:00:03 ; elapsed = 00:00:04 . Memory (MB): peak = 1958.836 ; gain = 508.602 ; free physical = 199 ; free virtual = 21642\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Constraint Validation : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1973.680 ; gain = 523.445 ; free physical = 229 ; free virtual = 21630\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Loading Part and Timing Information\n", - "---------------------------------------------------------------------------------\n", - "Loading part: xczu7ev-ffvc1156-2-e\n", - "INFO: [Synth 8-6742] Reading net delay rules and data\n", - "INFO: [Device 21-403] Loading part xczu7ev-ffvc1156-2-e\n", - "---------------------------------------------------------------------------------\n", - "Finished Loading Part and Timing Information : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1990.590 ; gain = 540.355 ; free physical = 220 ; free virtual = 21621\n", - "---------------------------------------------------------------------------------\n", - "INFO: [Synth 8-802] inferred FSM for state register 'state_reg' in module 'test_regslice_both'\n", - "INFO: [Synth 8-4490] FSM extraction disabled for register 'ap_CS_fsm_reg' through user attribute\n", - "INFO: [Synth 8-4490] FSM extraction disabled for register 'ap_CS_fsm_reg' through user attribute\n", - "INFO: [Synth 8-802] inferred FSM for state register 'state_reg' in module 'test_regslice_both__parameterized0'\n", - "---------------------------------------------------------------------------------------------------\n", - " State | New Encoding | Previous Encoding \n", - "---------------------------------------------------------------------------------------------------\n", - " ZERO | 00 | 10\n", - " ONE | 10 | 11\n", - " TWO | 01 | 01\n", - "---------------------------------------------------------------------------------------------------\n", - "INFO: [Synth 8-3354] encoded FSM with state register 'state_reg' using encoding 'sequential' in module 'test_regslice_both'\n", - "---------------------------------------------------------------------------------------------------\n", - " State | New Encoding | Previous Encoding \n", - "---------------------------------------------------------------------------------------------------\n", - " ZERO | 00 | 10\n", - " ONE | 10 | 11\n", - " TWO | 01 | 01\n", - "---------------------------------------------------------------------------------------------------\n", - "INFO: [Synth 8-3354] encoded FSM with state register 'state_reg' using encoding 'sequential' in module 'test_regslice_both__parameterized0'\n", - "---------------------------------------------------------------------------------\n", - "Finished RTL Optimization Phase 2 : Time (s): cpu = 00:00:04 ; elapsed = 00:00:04 . Memory (MB): peak = 1990.590 ; gain = 540.355 ; free physical = 207 ; free virtual = 21609\n", - "---------------------------------------------------------------------------------\n", - "No constraint files found.\n", - "---------------------------------------------------------------------------------\n", - "Start RTL Component Statistics \n", - "---------------------------------------------------------------------------------\n", - "Detailed RTL Component Info : \n", - "+---Adders : \n", - "\t 2 Input 16 Bit Adders := 4 \n", - "\t 3 Input 12 Bit Adders := 8 \n", - "\t 2 Input 12 Bit Adders := 2 \n", - "\t 3 Input 11 Bit Adders := 4 \n", - "\t 3 Input 8 Bit Adders := 11 \n", - "\t 2 Input 8 Bit Adders := 12 \n", - "\t 6 Input 8 Bit Adders := 1 \n", - "\t 8 Input 8 Bit Adders := 1 \n", - "\t 2 Input 7 Bit Adders := 3 \n", - "\t 2 Input 6 Bit Adders := 6 \n", - "\t 2 Input 2 Bit Adders := 6 \n", - "\t 2 Input 1 Bit Adders := 6 \n", - "+---Registers : \n", - "\t 64 Bit Registers := 2 \n", - "\t 16 Bit Registers := 5 \n", - "\t 8 Bit Registers := 28 \n", - "\t 6 Bit Registers := 2 \n", - "\t 3 Bit Registers := 1 \n", - "\t 2 Bit Registers := 9 \n", - "\t 1 Bit Registers := 45 \n", - "+---Muxes : \n", - "\t 2 Input 16 Bit Muxes := 1 \n", - "\t 2 Input 8 Bit Muxes := 9 \n", - "\t 4 Input 3 Bit Muxes := 1 \n", - "\t 2 Input 3 Bit Muxes := 1 \n", - "\t 2 Input 2 Bit Muxes := 34 \n", - "\t 3 Input 2 Bit Muxes := 6 \n", - "\t 4 Input 2 Bit Muxes := 3 \n", - "\t 2 Input 1 Bit Muxes := 44 \n", - "---------------------------------------------------------------------------------\n", - "Finished RTL Component Statistics \n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Part Resource Summary\n", - "---------------------------------------------------------------------------------\n", - "Part Resources:\n", - "DSPs: 1728 (col length:144)\n", - "BRAMs: 624 (col length: RAMB18 144 RAMB36 72)\n", - "---------------------------------------------------------------------------------\n", - "Finished Part Resource Summary\n", - "---------------------------------------------------------------------------------\n", - "No constraint files found.\n", - "---------------------------------------------------------------------------------\n", - "Start Cross Boundary and Area Optimization\n", - "---------------------------------------------------------------------------------\n", - "WARNING: [Synth 8-7080] Parallel synthesis criteria is not met\n", - "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[1] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[0] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[1] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[0] in module test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_num_data_valid[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[1] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer4_out_fifo_cap[0] in module test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_num_data_valid[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[1] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer3_out_fifo_cap[0] in module test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[1] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_num_data_valid[0] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[1] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", - "WARNING: [Synth 8-7129] Port layer2_out_fifo_cap[0] in module test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s is either unconnected or has no load\n", - "---------------------------------------------------------------------------------\n", - "Finished Cross Boundary and Area Optimization : Time (s): cpu = 00:00:09 ; elapsed = 00:00:10 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 177 ; free virtual = 20781\n", - "---------------------------------------------------------------------------------\n", - "No constraint files found.\n", - "---------------------------------------------------------------------------------\n", - "Start Timing Optimization\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Timing Optimization : Time (s): cpu = 00:00:09 ; elapsed = 00:00:10 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 174 ; free virtual = 20783\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Technology Mapping\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Technology Mapping : Time (s): cpu = 00:00:09 ; elapsed = 00:00:10 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 178 ; free virtual = 20784\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start IO Insertion\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Flattening Before IO Insertion\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Flattening Before IO Insertion\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Final Netlist Cleanup\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Final Netlist Cleanup\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished IO Insertion : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Renaming Generated Instances\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Renaming Generated Instances : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Rebuilding User Hierarchy\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Rebuilding User Hierarchy : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Renaming Generated Ports\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Renaming Generated Ports : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Handling Custom Attributes\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Handling Custom Attributes : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Renaming Generated Nets\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Finished Renaming Generated Nets : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", - "---------------------------------------------------------------------------------\n", - "---------------------------------------------------------------------------------\n", - "Start Writing Synthesis Report\n", - "---------------------------------------------------------------------------------\n", - "\n", - "Report BlackBoxes: \n", - "+-+--------------+----------+\n", - "| |BlackBox name |Instances |\n", - "+-+--------------+----------+\n", - "+-+--------------+----------+\n", - "\n", - "Report Cell Usage: \n", - "+------+-------+------+\n", - "| |Cell |Count |\n", - "+------+-------+------+\n", - "|1 |BUFG | 1|\n", - "|2 |CARRY8 | 49|\n", - "|3 |LUT1 | 37|\n", - "|4 |LUT2 | 191|\n", - "|5 |LUT3 | 53|\n", - "|6 |LUT4 | 117|\n", - "|7 |LUT5 | 139|\n", - "|8 |LUT6 | 160|\n", - "|9 |FDRE | 346|\n", - "|10 |FDSE | 10|\n", - "|11 |IBUF | 21|\n", - "|12 |OBUF | 13|\n", - "+------+-------+------+\n", - "\n", - "Report Instance Areas: \n", - "+------+-----------------------------------------------------------------------------------------+------------------------------------------------------------------------------------+------+\n", - "| |Instance |Module |Cells |\n", - "+------+-----------------------------------------------------------------------------------------+------------------------------------------------------------------------------------+------+\n", - "|1 |top | | 1137|\n", - "|2 | dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_U0 |test_dense_array_ap_fixed_2u_array_ap_fixed_8_4_5_3_0_8u_config2_s | 335|\n", - "|3 | call_ret_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s_fu_47 |test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config2_s | 30|\n", - "|4 | mul_8s_5s_12_1_1_U1 |test_mul_8s_5s_12_1_1 | 1|\n", - "|5 | regslice_both_x_t_U |test_regslice_both | 238|\n", - "|6 | dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0 |test_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_s | 110|\n", - "|7 | call_ret_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s_fu_65 |test_dense_latency_wrapper_ap_fixed_8_4_5_3_0_ap_fixed_8_4_5_3_0_config4_s | 7|\n", - "|8 | layer2_out_U |test_fifo_w64_d1_S | 139|\n", - "|9 | U_test_fifo_w64_d1_S_ShiftReg |test_fifo_w64_d1_S_ShiftReg_8 | 130|\n", - "|10 | layer3_out_U |test_fifo_w64_d1_S_0 | 16|\n", - "|11 | U_test_fifo_w64_d1_S_ShiftReg |test_fifo_w64_d1_S_ShiftReg | 8|\n", - "|12 | layer4_out_U |test_fifo_w16_d1_S | 37|\n", - "|13 | U_test_fifo_w16_d1_S_ShiftReg |test_fifo_w16_d1_S_ShiftReg | 28|\n", - "|14 | lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0 |test_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_s | 321|\n", - "|15 | mul_8s_5ns_12_1_1_U10 |test_mul_8s_5ns_12_1_1 | 25|\n", - "|16 | mul_8s_5ns_12_1_1_U11 |test_mul_8s_5ns_12_1_1_1 | 25|\n", - "|17 | mul_8s_5ns_12_1_1_U12 |test_mul_8s_5ns_12_1_1_2 | 25|\n", - "|18 | mul_8s_5ns_12_1_1_U13 |test_mul_8s_5ns_12_1_1_3 | 25|\n", - "|19 | mul_8s_5ns_12_1_1_U14 |test_mul_8s_5ns_12_1_1_4 | 25|\n", - "|20 | mul_8s_5ns_12_1_1_U15 |test_mul_8s_5ns_12_1_1_5 | 26|\n", - "|21 | mul_8s_5ns_12_1_1_U8 |test_mul_8s_5ns_12_1_1_6 | 26|\n", - "|22 | mul_8s_5ns_12_1_1_U9 |test_mul_8s_5ns_12_1_1_7 | 25|\n", - "|23 | snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0 |test_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_s | 114|\n", - "|24 | regslice_both_layer5_out_U |test_regslice_both__parameterized0 | 55|\n", - "|25 | start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0_U |test_start_for_dense_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_2u_config4_U0 | 10|\n", - "|26 | start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0_U |test_start_for_lif_neuron_array_ap_fixed_8u_array_ap_fixed_8_4_5_3_0_8u_config3_U0 | 11|\n", - "|27 | start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0_U |test_start_for_snn_readout_array_ap_fixed_8_4_5_3_0_2u_array_ap_int_8_1u_config5_U0 | 9|\n", - "+------+-----------------------------------------------------------------------------------------+------------------------------------------------------------------------------------+------+\n", - "---------------------------------------------------------------------------------\n", - "Finished Writing Synthesis Report : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", - "---------------------------------------------------------------------------------\n", - "Synthesis finished with 0 errors, 0 critical warnings and 55 warnings.\n", - "Synthesis Optimization Runtime : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.543 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", - "Synthesis Optimization Complete : Time (s): cpu = 00:00:11 ; elapsed = 00:00:12 . Memory (MB): peak = 2856.551 ; gain = 1406.309 ; free physical = 206 ; free virtual = 20803\n", - "INFO: [Project 1-571] Translating synthesized netlist\n", - "Netlist sorting complete. Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00.01 . Memory (MB): peak = 2856.551 ; gain = 0.000 ; free physical = 493 ; free virtual = 21089\n", - "INFO: [Netlist 29-17] Analyzing 71 Unisim elements for replacement\n", - "INFO: [Netlist 29-28] Unisim Transformation completed in 0 CPU seconds\n", - "INFO: [Project 1-570] Preparing netlist for logic optimization\n", - "INFO: [Opt 31-138] Pushed 0 inverter(s) to 0 load pin(s).\n", - "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 2912.570 ; gain = 0.000 ; free physical = 480 ; free virtual = 21076\n", - "INFO: [Project 1-111] Unisim Transformation Summary:\n", - " A total of 22 instances were transformed.\n", - " BUFG => BUFGCE: 1 instance \n", - " IBUF => IBUF (IBUFCTRL, INBUF): 21 instances\n", - "\n", - "Synth Design complete | Checksum: f20caaa6\n", - "INFO: [Common 17-83] Releasing license: Synthesis\n", - "61 Infos, 55 Warnings, 0 Critical Warnings and 0 Errors encountered.\n", - "synth_design completed successfully\n", - "synth_design: Time (s): cpu = 00:00:15 ; elapsed = 00:00:14 . Memory (MB): peak = 2912.570 ; gain = 1466.324 ; free physical = 480 ; free virtual = 21076\n", - "INFO: [Common 17-2834] synth_design peak Physical Memory [PSS] (MB): overall = 2652.063; main = 2381.784; forked = 443.151\n", - "INFO: [Common 17-2834] synth_design peak Virtual Memory [VSS] (MB): overall = 3883.590; main = 2912.574; forked = 1027.043\n", - "# opt_design -retarget -propconst -sweep -bram_power_opt -shift_register_opt\n", - "Command: opt_design -retarget -propconst -sweep -bram_power_opt -shift_register_opt\n", - "Attempting to get a license for feature 'Implementation' and/or device 'xczu7ev'\n", - "INFO: [Common 17-349] Got license for feature 'Implementation' and/or device 'xczu7ev'\n", - "Running DRC as a precondition to command opt_design\n", - "\n", - "Starting DRC Task\n", - "INFO: [DRC 23-27] Running DRC with 8 threads\n", - "INFO: [Project 1-461] DRC finished with 0 Errors\n", - "INFO: [Project 1-462] Please refer to the DRC report (report_drc) for more information.\n", - "\n", - "Time (s): cpu = 00:00:01 ; elapsed = 00:00:00.73 . Memory (MB): peak = 2976.602 ; gain = 64.031 ; free physical = 490 ; free virtual = 21087\n", - "\n", - "Starting Cache Timing Information Task\n", - "INFO: [Timing 38-35] Done setting XDC timing constraints.\n", - "Ending Cache Timing Information Task | Checksum: 266fc0599\n", - "\n", - "Time (s): cpu = 00:00:06 ; elapsed = 00:00:06 . Memory (MB): peak = 3523.734 ; gain = 547.133 ; free physical = 156 ; free virtual = 20652\n", - "\n", - "Starting Logic Optimization Task\n", - "\n", - "Phase 1 Initialization\n", - "\n", - "Phase 1.1 Core Generation And Design Setup\n", - "Phase 1.1 Core Generation And Design Setup | Checksum: 266fc0599\n", - "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 235 ; free virtual = 20448\n", - "\n", - "Phase 1.2 Setup Constraints And Sort Netlist\n", - "Phase 1.2 Setup Constraints And Sort Netlist | Checksum: 266fc0599\n", - "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 235 ; free virtual = 20448\n", - "Phase 1 Initialization | Checksum: 266fc0599\n", - "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 235 ; free virtual = 20448\n", - "\n", - "Phase 2 Timer Update And Timing Data Collection\n", - "\n", - "Phase 2.1 Timer Update\n", - "Phase 2.1 Timer Update | Checksum: 266fc0599\n", - "\n", - "Time (s): cpu = 00:00:00.02 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 234 ; free virtual = 20448\n", - "\n", - "Phase 2.2 Timing Data Collection\n", - "Phase 2.2 Timing Data Collection | Checksum: 266fc0599\n", - "\n", - "Time (s): cpu = 00:00:00.02 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 234 ; free virtual = 20448\n", - "Phase 2 Timer Update And Timing Data Collection | Checksum: 266fc0599\n", - "\n", - "Time (s): cpu = 00:00:00.02 ; elapsed = 00:00:00.01 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 234 ; free virtual = 20448\n", - "\n", - "Phase 3 Retarget\n", - "INFO: [Opt 31-1834] Total Chains To Be Transformed Were: 0 AND Number of Transformed insts Created are: 0\n", - "INFO: [Opt 31-138] Pushed 1 inverter(s) to 44 load pin(s).\n", - "INFO: [Opt 31-49] Retargeted 0 cell(s).\n", - "Phase 3 Retarget | Checksum: 21c32dcbf\n", - "\n", - "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20447\n", - "Retarget | Checksum: 21c32dcbf\n", - "INFO: [Opt 31-389] Phase Retarget created 0 cells and removed 1 cells\n", - "\n", - "Phase 4 Constant propagation\n", - "INFO: [Opt 31-138] Pushed 0 inverter(s) to 0 load pin(s).\n", - "Phase 4 Constant propagation | Checksum: 2c793b24c\n", - "\n", - "Time (s): cpu = 00:00:00.08 ; elapsed = 00:00:00.04 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20447\n", - "Constant propagation | Checksum: 2c793b24c\n", - "INFO: [Opt 31-389] Phase Constant propagation created 0 cells and removed 0 cells\n", - "\n", - "Phase 5 Sweep\n", - "Phase 5 Sweep | Checksum: 2bb6ebc94\n", - "\n", - "Time (s): cpu = 00:00:00.09 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20447\n", - "Sweep | Checksum: 2bb6ebc94\n", - "INFO: [Opt 31-389] Phase Sweep created 0 cells and removed 0 cells\n", - "\n", - "Phase 6 Shift Register Optimization\n", - "INFO: [Opt 31-1064] SRL Remap converted 0 SRLs to 0 registers and converted 0 registers of register chains to 0 SRLs\n", - "Phase 6 Shift Register Optimization | Checksum: 2bb6ebc94\n", - "\n", - "Time (s): cpu = 00:00:00.09 ; elapsed = 00:00:00.05 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20447\n", - "Shift Register Optimization | Checksum: 2bb6ebc94\n", - "INFO: [Opt 31-389] Phase Shift Register Optimization created 0 cells and removed 0 cells\n", - "\n", - "Phase 7 Post Processing Netlist\n", - "Phase 7 Post Processing Netlist | Checksum: 2bb6ebc94\n", - "\n", - "Time (s): cpu = 00:00:00.09 ; elapsed = 00:00:00.06 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20447\n", - "Post Processing Netlist | Checksum: 2bb6ebc94\n", - "INFO: [Opt 31-389] Phase Post Processing Netlist created 0 cells and removed 0 cells\n", - "\n", - "Phase 8 Finalization\n", - "\n", - "Phase 8.1 Finalizing Design Cores and Updating Shapes\n", - "Phase 8.1 Finalizing Design Cores and Updating Shapes | Checksum: 16582c3b4\n", - "\n", - "Time (s): cpu = 00:00:00.15 ; elapsed = 00:00:00.08 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20446\n", - "\n", - "Phase 8.2 Verifying Netlist Connectivity\n", - "Phase 8.2 Verifying Netlist Connectivity | Checksum: 16582c3b4\n", - "\n", - "Time (s): cpu = 00:00:00.15 ; elapsed = 00:00:00.08 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20446\n", - "Phase 8 Finalization | Checksum: 16582c3b4\n", - "\n", - "Time (s): cpu = 00:00:00.15 ; elapsed = 00:00:00.08 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 233 ; free virtual = 20446\n", - "Opt_design Change Summary\n", - "=========================\n", - "\n", - "\n", - "-------------------------------------------------------------------------------------------------------------------------\n", - "| Phase | #Cells created | #Cells Removed | #Constrained objects preventing optimizations |\n", - "-------------------------------------------------------------------------------------------------------------------------\n", - "| Retarget | 0 | 1 | 0 |\n", - "| Constant propagation | 0 | 0 | 0 |\n", - "| Sweep | 0 | 0 | 0 |\n", - "| Shift Register Optimization | 0 | 0 | 0 |\n", - "| Post Processing Netlist | 0 | 0 | 0 |\n", - "-------------------------------------------------------------------------------------------------------------------------\n", - "\n", - "\n", - "Ending Logic Optimization Task | Checksum: 16582c3b4\n", - "\n", - "Time (s): cpu = 00:00:00.15 ; elapsed = 00:00:00.08 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 232 ; free virtual = 20446\n", - "\n", - "Starting Power Optimization Task\n", - "INFO: [Pwropt 34-132] Skipping clock gating for clocks with a period < 2.00 ns.\n", - "Ending Power Optimization Task | Checksum: 16582c3b4\n", - "\n", - "Time (s): cpu = 00:00:00.01 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 232 ; free virtual = 20446\n", - "\n", - "Starting Final Cleanup Task\n", - "Ending Final Cleanup Task | Checksum: 16582c3b4\n", - "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 232 ; free virtual = 20446\n", - "\n", - "Starting Netlist Obfuscation Task\n", - "Netlist sorting complete. Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 232 ; free virtual = 20446\n", - "Ending Netlist Obfuscation Task | Checksum: 16582c3b4\n", - "\n", - "Time (s): cpu = 00:00:00 ; elapsed = 00:00:00 . Memory (MB): peak = 3792.641 ; gain = 0.000 ; free physical = 232 ; free virtual = 20446\n", - "INFO: [Common 17-83] Releasing license: Implementation\n", - "17 Infos, 0 Warnings, 0 Critical Warnings and 0 Errors encountered.\n", - "opt_design completed successfully\n", - "opt_design: Time (s): cpu = 00:00:09 ; elapsed = 00:00:09 . Memory (MB): peak = 3792.641 ; gain = 880.070 ; free physical = 232 ; free virtual = 20446\n", - "# report_utilization -file vivado_synth.rpt\n", - "INFO: [Common 17-206] Exiting Vivado at Tue May 5 18:07:38 2026...\n", - "***** VIVADO SYNTHESIS COMPLETED IN 0h0m40s *****\n", - "INFO: [HLS 200-112] Total CPU user time: 72.52 seconds. Total CPU system time: 7.1 seconds. Total elapsed time: 98.02 seconds; peak allocated memory: 451.898 MB.\n", - "INFO: [vitis-run 60-791] Total elapsed time: 0h 1m 38s\n", - "INFO: [vitis-run 60-1662] Stopping dispatch session having empty uuid.\n", - "Implementation report not found.\n", - "Timing report not found.\n", - "{'CSimResults': [['0'], ['1'], ['0'], ['0'], ['0']], 'CosimResults': [['0'], ['1'], ['0'], ['0'], ['0']], 'CSynthesisReport': {'TargetClockPeriod': '5.00', 'EstimatedClockPeriod': '3.984', 'BestLatency': '8', 'WorstLatency': '8', 'IntervalMin': '3', 'IntervalMax': '3', 'DSP': '0', 'FF': '573', 'LUT': '2265', 'BRAM_18K': '0', 'URAM': '0', 'AvailableBRAM_18K': '624', 'AvailableDSP': '1728', 'AvailableFF': '460800', 'AvailableLUT': '230400', 'AvailableURAM': '96'}, 'VivadoSynthReport': {'LUT': '574', 'FF': '356', 'BRAM_18K': '0', 'URAM': '0', 'DSP48E': '0'}, 'CosimReport': {'RTL': 'Verilog', 'Status': 'Pass', 'LatencyMin': 11, 'LatencyMax': 14, 'IntervalMin': 2, 'IntervalMax': 4, 'LatencyAvg': 12.4, 'IntervalAvg': 2.75}}\n" - ] - } - ], - "source": [ - "report = hls_model.build(\n", - " reset=True,\n", - " csim=True,\n", - " synth=True,\n", - " cosim=True,\n", - " validation=True,\n", - " export=True,\n", - " vsynth=True,\n", - ")\n", - "print(report)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "639ce3e7-6c19-4328-9591-5d9e2ab939e0", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 10a52bbbd50639a4ebce4bd0354eb983c808a7e5 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Sun, 17 May 2026 19:26:32 +0100 Subject: [PATCH 15/32] refactor readout --- .../vivado/nnet_utils/nnet_snn_readout.h | 426 ++++++++---------- 1 file changed, 197 insertions(+), 229 deletions(-) diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h b/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h index 0104c4fcfa..be81056365 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h @@ -18,96 +18,61 @@ struct snn_readout_config { typedef float membrane_t; }; -template void snn_readout(data_T data[CONFIG_T::n_classes], res_T res[1]) { - #pragma HLS PIPELINE II=1 - - // Counts and membrane values persist across calls within one readout window. - static unsigned counts[CONFIG_T::n_classes]; - #pragma HLS ARRAY_PARTITION variable=counts complete - static typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]; - #pragma HLS ARRAY_PARTITION variable=mem complete - static unsigned ts = 0; - - if (CONFIG_T::output_mode == snn_readout_mode::membrane) { - unsigned best = 0; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - typename CONFIG_T::membrane_t v = - (typename CONFIG_T::membrane_t)((typename CONFIG_T::membrane_t)CONFIG_T::beta * mem[i]) + - (typename CONFIG_T::membrane_t)data[i]; - mem[i] = v; - if (i == 0 || v > mem[best]) { - best = i; - } - } +template void reset_snn_counts(unsigned counts[CONFIG_T::n_classes]) { + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + counts[i] = 0; + } +} - if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { - res[0] = (typename res_T::value_type)(mem[1] - mem[0]); - } else { - res[0] = (typename res_T::value_type)best; - } +template void reset_snn_membrane(typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]) { + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + mem[i] = 0; + } +} - ts++; - if (ts >= CONFIG_T::window_size) { - ts = 0; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - mem[i] = 0; - } - } - return; +template void advance_snn_count_window(unsigned &ts, unsigned counts[CONFIG_T::n_classes]) { + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + reset_snn_counts(counts); } +} - if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - counts[i] += (data[i] != 0) ? 1 : 0; - } - // Fast BCE-like score path for binary classifiers: logit = count_1 - count_0. - res[0] = (typename res_T::value_type)((int)counts[1] - (int)counts[0]); - ts++; - if (ts >= CONFIG_T::window_size) { - ts = 0; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - counts[i] = 0; - } - } - return; +template +void advance_snn_membrane_window(unsigned &ts, typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]) { + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + reset_snn_membrane(mem); } +} - // Fast argmax path: update counters and argmax in one pass. - if (CONFIG_T::decision_rule == snn_decision_rule::argmax_spike_count) { - unsigned best = 0; - unsigned best_count = 0; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - unsigned c = counts[i] + ((data[i] != 0) ? 1 : 0); - counts[i] = c; - if (i == 0 || c > best_count) { - best = i; - best_count = c; - } - } - res[0] = (typename res_T::value_type)best; - - ts++; - if (ts >= CONFIG_T::window_size) { - ts = 0; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - counts[i] = 0; - } - } - return; +template void zero_snn_pack(res_T &out_pack) { + for (unsigned i = 0; i < res_T::size; i++) { + #pragma HLS UNROLL + out_pack[i] = 0; } +} - // Generic path for threshold-based decision rules. +template +void update_snn_counts_array(data_T data[CONFIG_T::n_classes], unsigned counts[CONFIG_T::n_classes]) { for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { #pragma HLS UNROLL counts[i] += (data[i] != 0) ? 1 : 0; } +} + +template +void update_snn_counts_pack(data_T in_pack, unsigned counts[CONFIG_T::n_classes]) { + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + counts[i] += (in_pack[i] != 0) ? 1 : 0; + } +} +template unsigned argmax_snn_counts(unsigned counts[CONFIG_T::n_classes]) { unsigned best = 0; for (unsigned i = 1; i < CONFIG_T::n_classes; i++) { #pragma HLS UNROLL @@ -115,119 +80,129 @@ template void snn_readout(data_T best = i; } } + return best; +} - if (CONFIG_T::decision_rule == snn_decision_rule::first_to_threshold) { - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - if (counts[i] >= CONFIG_T::class_threshold) { - best = i; - break; - } - } - } else if (CONFIG_T::decision_rule == snn_decision_rule::threshold_then_argmax) { - bool any_reached = false; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - any_reached |= (counts[i] >= CONFIG_T::class_threshold); - } - if (any_reached) { - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - if (counts[i] >= CONFIG_T::class_threshold) { - best = i; - break; - } - } +template unsigned first_snn_threshold(unsigned counts[CONFIG_T::n_classes], unsigned fallback) { + unsigned best = fallback; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + if (counts[i] >= CONFIG_T::class_threshold) { + best = i; + break; } } + return best; +} - res[0] = best; +template +unsigned threshold_then_snn_argmax(unsigned counts[CONFIG_T::n_classes], unsigned fallback) { + bool any_reached = false; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + any_reached |= (counts[i] >= CONFIG_T::class_threshold); + } - ts++; - if (ts >= CONFIG_T::window_size) { - ts = 0; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - counts[i] = 0; + if (any_reached) { + return first_snn_threshold(counts, fallback); + } + + return fallback; +} + +template +unsigned update_snn_membrane_array( + data_T data[CONFIG_T::n_classes], typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes] +) { + unsigned best = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + typename CONFIG_T::membrane_t v = + (typename CONFIG_T::membrane_t)((typename CONFIG_T::membrane_t)CONFIG_T::beta * mem[i]) + + (typename CONFIG_T::membrane_t)data[i]; + mem[i] = v; + if (i == 0 || v > mem[best]) { + best = i; } } + return best; } -template -void snn_readout(hls::stream &data_stream, hls::stream &res_stream) { - #pragma HLS PIPELINE II=1 +template +unsigned update_snn_membrane_pack(data_T in_pack, typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]) { + unsigned best = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + typename CONFIG_T::membrane_t v = + (typename CONFIG_T::membrane_t)((typename CONFIG_T::membrane_t)CONFIG_T::beta * mem[i]) + + (typename CONFIG_T::membrane_t)in_pack[i]; + mem[i] = v; + if (i == 0 || v > mem[best]) { + best = i; + } + } + return best; +} - // Counts and membrane values persist across calls within one readout window. - static unsigned counts[CONFIG_T::n_classes]; - #pragma HLS ARRAY_PARTITION variable=counts complete - static typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]; - #pragma HLS ARRAY_PARTITION variable=mem complete - static unsigned ts = 0; +template +typename res_T::value_type snn_membrane_readout_value( + data_T data[CONFIG_T::n_classes], typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes] +) { + unsigned best = update_snn_membrane_array(data, mem); + if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { + return (typename res_T::value_type)(mem[1] - mem[0]); + } + return (typename res_T::value_type)best; +} - data_T in_pack = data_stream.read(); +template +typename res_T::value_type snn_membrane_readout_value_pack( + data_T in_pack, typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes] +) { + unsigned best = update_snn_membrane_pack(in_pack, mem); + if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { + return (typename res_T::value_type)(mem[1] - mem[0]); + } + return (typename res_T::value_type)best; +} - if (CONFIG_T::output_mode == snn_readout_mode::membrane) { +template +typename res_T::value_type snn_spike_readout_value( + data_T data[CONFIG_T::n_classes], unsigned counts[CONFIG_T::n_classes] +) { + if (CONFIG_T::decision_rule == snn_decision_rule::argmax_spike_count) { unsigned best = 0; + unsigned best_count = 0; for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { #pragma HLS UNROLL - typename CONFIG_T::membrane_t v = - (typename CONFIG_T::membrane_t)((typename CONFIG_T::membrane_t)CONFIG_T::beta * mem[i]) + - (typename CONFIG_T::membrane_t)in_pack[i]; - mem[i] = v; - if (i == 0 || v > mem[best]) { + unsigned c = counts[i] + ((data[i] != 0) ? 1 : 0); + counts[i] = c; + if (i == 0 || c > best_count) { best = i; + best_count = c; } } - - res_T out_pack; - PRAGMA_DATA_PACK(out_pack) - for (unsigned i = 0; i < res_T::size; i++) { - #pragma HLS UNROLL - out_pack[i] = 0; - } - if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { - out_pack[0] = (typename res_T::value_type)(mem[1] - mem[0]); - } else { - out_pack[0] = (typename res_T::value_type)best; - } - res_stream.write(out_pack); - - ts++; - if (ts >= CONFIG_T::window_size) { - ts = 0; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - mem[i] = 0; - } - } - return; + return (typename res_T::value_type)best; } + update_snn_counts_array(data, counts); + if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - counts[i] += (in_pack[i] != 0) ? 1 : 0; - } - res_T out_pack; - PRAGMA_DATA_PACK(out_pack) - for (unsigned i = 0; i < res_T::size; i++) { - #pragma HLS UNROLL - out_pack[i] = 0; - } - out_pack[0] = (typename res_T::value_type)((int)counts[1] - (int)counts[0]); - res_stream.write(out_pack); + return (typename res_T::value_type)((int)counts[1] - (int)counts[0]); + } - ts++; - if (ts >= CONFIG_T::window_size) { - ts = 0; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - counts[i] = 0; - } - } - return; + unsigned best = argmax_snn_counts(counts); + if (CONFIG_T::decision_rule == snn_decision_rule::first_to_threshold) { + best = first_snn_threshold(counts, best); + } else if (CONFIG_T::decision_rule == snn_decision_rule::threshold_then_argmax) { + best = threshold_then_snn_argmax(counts, best); } + return (typename res_T::value_type)best; +} + +template +typename res_T::value_type snn_spike_readout_value_pack(data_T in_pack, unsigned counts[CONFIG_T::n_classes]) { if (CONFIG_T::decision_rule == snn_decision_rule::argmax_spike_count) { unsigned best = 0; unsigned best_count = 0; @@ -240,82 +215,75 @@ void snn_readout(hls::stream &data_stream, hls::stream &res_strea best_count = c; } } + return (typename res_T::value_type)best; + } - res_T out_pack; - PRAGMA_DATA_PACK(out_pack) - for (unsigned i = 0; i < res_T::size; i++) { - #pragma HLS UNROLL - out_pack[i] = 0; - } - out_pack[0] = (typename res_T::value_type)best; - res_stream.write(out_pack); + update_snn_counts_pack(in_pack, counts); - ts++; - if (ts >= CONFIG_T::window_size) { - ts = 0; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - counts[i] = 0; - } - } - return; + if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { + return (typename res_T::value_type)((int)counts[1] - (int)counts[0]); } - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - counts[i] += (in_pack[i] != 0) ? 1 : 0; + unsigned best = argmax_snn_counts(counts); + if (CONFIG_T::decision_rule == snn_decision_rule::first_to_threshold) { + best = first_snn_threshold(counts, best); + } else if (CONFIG_T::decision_rule == snn_decision_rule::threshold_then_argmax) { + best = threshold_then_snn_argmax(counts, best); } - unsigned best = 0; - for (unsigned i = 1; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - if (counts[i] > counts[best]) { - best = i; - } + return (typename res_T::value_type)best; +} + +template +void snn_readout(data_T data[CONFIG_T::n_classes], res_T res[1]) { + #pragma HLS PIPELINE II=1 + + // Counts and membrane values persist across calls within one readout window. + static unsigned counts[CONFIG_T::n_classes]; + #pragma HLS ARRAY_PARTITION variable=counts complete + static typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]; + #pragma HLS ARRAY_PARTITION variable=mem complete + static unsigned ts = 0; + + if (CONFIG_T::output_mode == snn_readout_mode::membrane) { + res[0] = snn_membrane_readout_value(data, mem); + advance_snn_membrane_window(ts, mem); + return; } - if (CONFIG_T::decision_rule == snn_decision_rule::first_to_threshold) { - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - if (counts[i] >= CONFIG_T::class_threshold) { - best = i; - break; - } - } - } else if (CONFIG_T::decision_rule == snn_decision_rule::threshold_then_argmax) { - bool any_reached = false; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - any_reached |= (counts[i] >= CONFIG_T::class_threshold); - } - if (any_reached) { - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - if (counts[i] >= CONFIG_T::class_threshold) { - best = i; - break; - } - } - } + res[0] = snn_spike_readout_value(data, counts); + advance_snn_count_window(ts, counts); +} + +template +void snn_readout(hls::stream &data_stream, hls::stream &res_stream) { + #pragma HLS PIPELINE II=1 + + // Counts and membrane values persist across calls within one readout window. + static unsigned counts[CONFIG_T::n_classes]; + #pragma HLS ARRAY_PARTITION variable=counts complete + static typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]; + #pragma HLS ARRAY_PARTITION variable=mem complete + static unsigned ts = 0; + + data_T in_pack = data_stream.read(); + + if (CONFIG_T::output_mode == snn_readout_mode::membrane) { + res_T out_pack; + PRAGMA_DATA_PACK(out_pack) + zero_snn_pack(out_pack); + out_pack[0] = snn_membrane_readout_value_pack(in_pack, mem); + res_stream.write(out_pack); + advance_snn_membrane_window(ts, mem); + return; } res_T out_pack; PRAGMA_DATA_PACK(out_pack) - for (unsigned i = 0; i < res_T::size; i++) { - #pragma HLS UNROLL - out_pack[i] = 0; - } - out_pack[0] = (typename res_T::value_type)best; + zero_snn_pack(out_pack); + out_pack[0] = snn_spike_readout_value_pack(in_pack, counts); res_stream.write(out_pack); - - ts++; - if (ts >= CONFIG_T::window_size) { - ts = 0; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - counts[i] = 0; - } - } + advance_snn_count_window(ts, counts); } } // namespace nnet From 21c9c9389d8b5007fe13fac5242c23437db6ebb9 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 18 May 2026 09:39:59 +0100 Subject: [PATCH 16/32] update to SNNReadout attributes --- hls4ml/model/layers.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/hls4ml/model/layers.py b/hls4ml/model/layers.py index aa4736b4d3..74bf0bfeac 100644 --- a/hls4ml/model/layers.py +++ b/hls4ml/model/layers.py @@ -1119,16 +1119,16 @@ def initialize(self): class SNNReadout(Layer): _expected_attributes = [ - Attribute('n_classes', configurable=False), - Attribute('window_size', value_type=int, default=1, configurable=False), - Attribute('class_threshold', value_type=int, default=1, configurable=False), + Attribute('n_classes'), + Attribute('window_size', value_type=int, default=1), + Attribute('class_threshold', value_type=int, default=1), Attribute('beta', value_type=float, default=1.0), - ChoiceAttribute('output_mode', choices=['spike', 'membrane'], default='spike', configurable=False), + ChoiceAttribute('output_mode', choices=['spike', 'membrane'], default='spike'), ChoiceAttribute( 'state_reset_policy', choices=['fixed_window', 'tlast', 'host_pulse', 'never'], default='fixed_window', - configurable=True, + configurable=False, ), ChoiceAttribute( 'decision_rule', From 6aaf6a05fac173ee72f723e51da61d51365a8860 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 18 May 2026 10:04:54 +0100 Subject: [PATCH 17/32] Added backend support to docs --- docs/advanced/snn.rst | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/docs/advanced/snn.rst b/docs/advanced/snn.rst index d6aec5e91d..185e14f0cf 100644 --- a/docs/advanced/snn.rst +++ b/docs/advanced/snn.rst @@ -10,6 +10,11 @@ Install the SNN frontend dependencies with: pip install hls4ml[snn] +Backend support +=============== + +The SNN flow currently supports only the ``Vitis`` backend. + Execution model =============== From 18def3cb5245465722a7ff272dbf93db2bfbf306 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 18 May 2026 10:05:24 +0100 Subject: [PATCH 18/32] updated vivado->vitis in tests --- test/pytest/test_extensions_pytorch_snn.py | 4 ++-- test/pytest/test_snn_pytorch.py | 28 +++++++++++----------- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/test/pytest/test_extensions_pytorch_snn.py b/test/pytest/test_extensions_pytorch_snn.py index afefe6ab56..e7fa4a59fa 100644 --- a/test/pytest/test_extensions_pytorch_snn.py +++ b/test/pytest/test_extensions_pytorch_snn.py @@ -60,12 +60,12 @@ def forward(self, x): pmodel = PyTorchModel() config = hls4ml.utils.config_from_pytorch_model( - pmodel, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + pmodel, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vitis' ) hmodel = hls4ml.converters.convert_from_pytorch_model( pmodel, output_dir=str(test_root_path / test_case_id), - backend='Vivado', + backend='Vitis', io_type='io_parallel', hls_config=config, ) diff --git a/test/pytest/test_snn_pytorch.py b/test/pytest/test_snn_pytorch.py index 3a0bd9e8df..de8ccc6d99 100644 --- a/test/pytest/test_snn_pytorch.py +++ b/test/pytest/test_snn_pytorch.py @@ -170,13 +170,13 @@ def forward(self, x): def test_pytorch_snn_layers_are_parsed(test_case_id, model_class, expected_layer): model = model_class() config = hls4ml.utils.config_from_pytorch_model( - model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vitis' ) hmodel = hls4ml.converters.convert_from_pytorch_model( model, output_dir=str(test_root_path / test_case_id), - backend='Vivado', + backend='Vitis', io_type='io_parallel', hls_config=config, ) @@ -221,13 +221,13 @@ def forward(self, x): model = BetaNet() config = hls4ml.utils.config_from_pytorch_model( - model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vitis' ) hmodel = hls4ml.converters.convert_from_pytorch_model( model, output_dir=str(test_root_path / test_case_id), - backend='Vivado', + backend='Vitis', io_type='io_parallel', hls_config=config, ) @@ -248,12 +248,12 @@ def forward(self, x): def test_snn_scalar_vs_vector_modes(test_case_id, model_class, expected_layer, beta_mode, threshold_mode): model = model_class() config = hls4ml.utils.config_from_pytorch_model( - model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vitis' ) hmodel = hls4ml.converters.convert_from_pytorch_model( model, output_dir=str(test_root_path / test_case_id), - backend='Vivado', + backend='Vitis', io_type='io_parallel', hls_config=config, ) @@ -271,12 +271,12 @@ def test_snn_scalar_vs_vector_modes(test_case_id, model_class, expected_layer, b def test_snn_uses_current_parameter_values_for_vector_params(test_case_id): model = LearnedVectorParamsNet() config = hls4ml.utils.config_from_pytorch_model( - model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vitis' ) hmodel = hls4ml.converters.convert_from_pytorch_model( model, output_dir=str(test_root_path / test_case_id), - backend='Vivado', + backend='Vitis', io_type='io_parallel', hls_config=config, ) @@ -291,12 +291,12 @@ def test_snn_uses_current_parameter_values_for_vector_params(test_case_id): def test_snn_readout_stream_length_alias_and_reset_policy(test_case_id): model = SNNClassifierWithResetPolicy() config = hls4ml.utils.config_from_pytorch_model( - model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vitis' ) hmodel = hls4ml.converters.convert_from_pytorch_model( model, output_dir=str(test_root_path / test_case_id), - backend='Vivado', + backend='Vitis', io_type='io_parallel', hls_config=config, ) @@ -310,7 +310,7 @@ def test_snn_readout_stream_length_alias_and_reset_policy(test_case_id): def test_snn_layer_type_config_is_exposed_for_quantization(test_case_id): model = LIFVectorNet() config = hls4ml.utils.config_from_pytorch_model( - model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vitis' ) config['LayerName']['neuron']['beta_t'] = 'ap_fixed<12,2>' config['LayerName']['neuron']['threshold_t'] = 'ap_fixed<10,3>' @@ -319,7 +319,7 @@ def test_snn_layer_type_config_is_exposed_for_quantization(test_case_id): hmodel = hls4ml.converters.convert_from_pytorch_model( model, output_dir=str(test_root_path / test_case_id), - backend='Vivado', + backend='Vitis', io_type='io_parallel', hls_config=config, ) @@ -333,14 +333,14 @@ def test_snn_layer_type_config_is_exposed_for_quantization(test_case_id): def test_snn_membrane_readout_type_config_is_exposed(test_case_id): model = SNNMembraneReadoutClassifier() config = hls4ml.utils.config_from_pytorch_model( - model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vivado' + model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vitis' ) config['LayerName']['readout']['membrane_t'] = 'ap_fixed<18,6>' hmodel = hls4ml.converters.convert_from_pytorch_model( model, output_dir=str(test_root_path / test_case_id), - backend='Vivado', + backend='Vitis', io_type='io_parallel', hls_config=config, ) From fbbc6f839070404747f47ce745ed42ffa45e291e Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 18 May 2026 10:29:11 +0100 Subject: [PATCH 19/32] update docs on RF support for spiking neurons --- docs/advanced/snn.rst | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/docs/advanced/snn.rst b/docs/advanced/snn.rst index 185e14f0cf..debcb5bad1 100644 --- a/docs/advanced/snn.rst +++ b/docs/advanced/snn.rst @@ -23,6 +23,18 @@ updates and layer computations run in standard HLS pipelines/streams each cycle according to interface handshakes. The generated design is not a native asynchronous/event-routed neuromorphic architecture (yet!). +Reuse factor support +==================== + +Standard hls4ml layers used inside an SNN, such as ``Dense``/linear layers, +retain their normal ``ReuseFactor`` support. ``ReuseFactor`` can still be set at +the model, layer type, or layer name level for these layers, and each dense layer +uses its own configured value independently of the surrounding spiking neuron +layers. The spiking neuron kernels themselves, ``IFNeuron`` and ``LIFNeuron``, do not +currently expose ``ReuseFactor``. They process one timestep at a time, keep +internal membrane state across timesteps, and unroll the per-neuron update loop +across ``n_out`` channels. + Supported PyTorch modules and readout wrappers ============================================== From eee087d3ca108f8fe240984a71eeccffdce1fa59 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 18 May 2026 10:44:05 +0100 Subject: [PATCH 20/32] snn streaming moved to nnet_snn_stream.h --- .../backends/vivado/passes/snn_templates.py | 10 +- .../vivado/nnet_utils/nnet_if_neuron.h | 112 --------- .../vivado/nnet_utils/nnet_lif_neuron.h | 123 --------- .../{nnet_snn_readout.h => nnet_snn.h} | 235 ++++++++++-------- .../vivado/nnet_utils/nnet_snn_common.h | 18 -- .../vivado/nnet_utils/nnet_snn_stream.h | 216 ++++++++++++++++ 6 files changed, 345 insertions(+), 369 deletions(-) delete mode 100644 hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h delete mode 100644 hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h rename hls4ml/templates/vivado/nnet_utils/{nnet_snn_readout.h => nnet_snn.h} (62%) delete mode 100644 hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h create mode 100644 hls4ml/templates/vivado/nnet_utils/nnet_snn_stream.h diff --git a/hls4ml/backends/vivado/passes/snn_templates.py b/hls4ml/backends/vivado/passes/snn_templates.py index 915afccf75..8eb5c1b69f 100644 --- a/hls4ml/backends/vivado/passes/snn_templates.py +++ b/hls4ml/backends/vivado/passes/snn_templates.py @@ -14,7 +14,7 @@ }};\n""" if_function_template = 'nnet::if_neuron<{input_t}, {output_t}, {config}>({input}, {output}, {threshold});' -if_include_list = ['nnet_utils/nnet_if_neuron.h'] +snn_include_list = ['nnet_utils/nnet_snn.h', 'nnet_utils/nnet_snn_stream.h'] class IFNeuronConfigTemplate(LayerConfigTemplate): @@ -30,7 +30,7 @@ def format(self, node): class IFNeuronFunctionTemplate(FunctionCallTemplate): def __init__(self): - super().__init__(IFNeuron, include_header=if_include_list) + super().__init__(IFNeuron, include_header=snn_include_list) self.template = if_function_template def format(self, node): @@ -57,7 +57,6 @@ def format(self, node): }};\n""" lif_function_template = 'nnet::lif_neuron<{input_t}, {output_t}, {config}>({input}, {output}, {beta}, {threshold});' -lif_include_list = ['nnet_utils/nnet_lif_neuron.h'] class LIFNeuronConfigTemplate(LayerConfigTemplate): @@ -74,7 +73,7 @@ def format(self, node): class LIFNeuronFunctionTemplate(FunctionCallTemplate): def __init__(self): - super().__init__(LIFNeuron, include_header=lif_include_list) + super().__init__(LIFNeuron, include_header=snn_include_list) self.template = lif_function_template def format(self, node): @@ -98,7 +97,6 @@ def format(self, node): }};\n""" readout_function_template = 'nnet::snn_readout<{input_t}, {output_t}, {config}>({input}, {output});' -readout_include_list = ['nnet_utils/nnet_snn_readout.h'] class SNNReadoutConfigTemplate(LayerConfigTemplate): @@ -113,7 +111,7 @@ def format(self, node): class SNNReadoutFunctionTemplate(FunctionCallTemplate): def __init__(self): - super().__init__(SNNReadout, include_header=readout_include_list) + super().__init__(SNNReadout, include_header=snn_include_list) self.template = readout_function_template def format(self, node): diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h b/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h deleted file mode 100644 index de69269f33..0000000000 --- a/hls4ml/templates/vivado/nnet_utils/nnet_if_neuron.h +++ /dev/null @@ -1,112 +0,0 @@ -#ifndef NNET_IF_NEURON_H_ -#define NNET_IF_NEURON_H_ - -#include "hls_stream.h" -#include "nnet_common.h" -#include "nnet_snn_common.h" - -namespace nnet { - -struct if_neuron_config { - static const unsigned n_in = 1; - static const unsigned n_out = 1; - static const unsigned io_type = io_parallel; - static const unsigned window_size = 0; - static const bool threshold_is_vector = false; - static constexpr float threshold = 1.0; - static const snn_reset_mode reset_mode = snn_reset_mode::subtract; - typedef float threshold_t; - typedef float membrane_t; -}; - -template -void if_neuron(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out], - const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out]) { - #pragma HLS PIPELINE II=1 - - // Static state persists across calls until the configured time window ends. - static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; - #pragma HLS ARRAY_PARTITION variable=mem complete - static unsigned ts = 0; - - for (unsigned i = 0; i < CONFIG_T::n_out; i++) { - #pragma HLS UNROLL - typename CONFIG_T::threshold_t threshold = - CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; - typename CONFIG_T::membrane_t v = mem[i] + (typename CONFIG_T::membrane_t)data[i]; - bool spike = (v >= threshold); - if (spike) { - if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { - v = v - threshold; - } else { - v = 0; - } - res[i] = 1; - } else { - res[i] = 0; - } - mem[i] = v; - } - - if (CONFIG_T::window_size > 0) { - ts++; - if (ts >= CONFIG_T::window_size) { - ts = 0; - for (unsigned i = 0; i < CONFIG_T::n_out; i++) { - #pragma HLS UNROLL - mem[i] = 0; - } - } - } -} - -template -void if_neuron(hls::stream &data_stream, hls::stream &res_stream, - const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out]) { - #pragma HLS PIPELINE II=1 - - // Static state persists across calls until the configured time window ends. - static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; - #pragma HLS ARRAY_PARTITION variable=mem complete - static unsigned ts = 0; - - data_T in_pack = data_stream.read(); - res_T out_pack; - PRAGMA_DATA_PACK(out_pack) - - for (unsigned i = 0; i < CONFIG_T::n_out; i++) { - #pragma HLS UNROLL - typename CONFIG_T::threshold_t threshold = - CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; - typename CONFIG_T::membrane_t v = mem[i] + (typename CONFIG_T::membrane_t)in_pack[i]; - bool spike = (v >= threshold); - if (spike) { - if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { - v = v - threshold; - } else { - v = 0; - } - out_pack[i] = 1; - } else { - out_pack[i] = 0; - } - mem[i] = v; - } - - res_stream.write(out_pack); - - if (CONFIG_T::window_size > 0) { - ts++; - if (ts >= CONFIG_T::window_size) { - ts = 0; - for (unsigned i = 0; i < CONFIG_T::n_out; i++) { - #pragma HLS UNROLL - mem[i] = 0; - } - } - } -} - -} // namespace nnet - -#endif diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h b/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h deleted file mode 100644 index 671ae202ee..0000000000 --- a/hls4ml/templates/vivado/nnet_utils/nnet_lif_neuron.h +++ /dev/null @@ -1,123 +0,0 @@ -#ifndef NNET_LIF_NEURON_H_ -#define NNET_LIF_NEURON_H_ - -#include "hls_stream.h" -#include "nnet_common.h" -#include "nnet_snn_common.h" - -namespace nnet { - -struct lif_neuron_config { - static const unsigned n_in = 1; - static const unsigned n_out = 1; - static const unsigned io_type = io_parallel; - static const unsigned window_size = 0; - static const bool beta_is_vector = false; - static const bool threshold_is_vector = false; - static constexpr float threshold = 1.0; - static constexpr float beta = 0.9; - static const snn_reset_mode reset_mode = snn_reset_mode::subtract; - typedef float beta_t; - typedef float threshold_t; - typedef float membrane_t; -}; - -template -void lif_neuron(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out], - const typename CONFIG_T::beta_t beta_vec[CONFIG_T::n_out], - const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out]) { - #pragma HLS PIPELINE II=1 - - // Static state persists across calls until the configured time window ends. - static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; - #pragma HLS ARRAY_PARTITION variable=mem complete - static unsigned ts = 0; - - for (unsigned i = 0; i < CONFIG_T::n_out; i++) { - #pragma HLS UNROLL - typename CONFIG_T::beta_t beta = CONFIG_T::beta_is_vector ? beta_vec[i] : (typename CONFIG_T::beta_t)CONFIG_T::beta; - typename CONFIG_T::threshold_t threshold = - CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; - // LIF update: v[t] = beta * v[t-1] + input. - typename CONFIG_T::membrane_t v = - (typename CONFIG_T::membrane_t)(beta * mem[i]) + (typename CONFIG_T::membrane_t)data[i]; - bool spike = (v >= threshold); - if (spike) { - if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { - v = v - threshold; - } else { - v = 0; - } - res[i] = 1; - } else { - res[i] = 0; - } - mem[i] = v; - } - - if (CONFIG_T::window_size > 0) { - ts++; - if (ts >= CONFIG_T::window_size) { - ts = 0; - for (unsigned i = 0; i < CONFIG_T::n_out; i++) { - #pragma HLS UNROLL - mem[i] = 0; - } - } - } -} - -template -void lif_neuron(hls::stream &data_stream, hls::stream &res_stream, - const typename CONFIG_T::beta_t beta_vec[CONFIG_T::n_out], - const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out]) { - #pragma HLS PIPELINE II=1 - - // Static state persists across calls until the configured time window ends. - static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; - #pragma HLS ARRAY_PARTITION variable=mem complete - static unsigned ts = 0; - - data_T in_pack = data_stream.read(); - res_T out_pack; - PRAGMA_DATA_PACK(out_pack) - - for (unsigned i = 0; i < CONFIG_T::n_out; i++) { - #pragma HLS UNROLL - typename CONFIG_T::beta_t beta = CONFIG_T::beta_is_vector ? beta_vec[i] : (typename CONFIG_T::beta_t)CONFIG_T::beta; - typename CONFIG_T::threshold_t threshold = - CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; - // LIF update: v[t] = beta * v[t-1] + input. - typename CONFIG_T::membrane_t v = - (typename CONFIG_T::membrane_t)(beta * mem[i]) + (typename CONFIG_T::membrane_t)in_pack[i]; - bool spike = (v >= threshold); - if (spike) { - if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { - v = v - threshold; - } else { - v = 0; - } - out_pack[i] = 1; - } else { - out_pack[i] = 0; - } - mem[i] = v; - } - - res_stream.write(out_pack); - - if (CONFIG_T::window_size > 0) { - ts++; - if (ts >= CONFIG_T::window_size) { - ts = 0; - for (unsigned i = 0; i < CONFIG_T::n_out; i++) { - #pragma HLS UNROLL - mem[i] = 0; - } - } - } -} - -} // namespace nnet - -#endif diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h b/hls4ml/templates/vivado/nnet_utils/nnet_snn.h similarity index 62% rename from hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h rename to hls4ml/templates/vivado/nnet_utils/nnet_snn.h index be81056365..6cb6f961c1 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_snn_readout.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_snn.h @@ -1,12 +1,47 @@ -#ifndef NNET_SNN_READOUT_H_ -#define NNET_SNN_READOUT_H_ +#ifndef NNET_SNN_H_ +#define NNET_SNN_H_ -#include "hls_stream.h" #include "nnet_common.h" -#include "nnet_snn_common.h" namespace nnet { +enum class snn_reset_mode { subtract, zero }; +enum class snn_decision_rule { + argmax_spike_count, + first_to_threshold, + threshold_then_argmax, + binary_logit, + argmax_membrane +}; +enum class snn_readout_mode { spike, membrane }; + +struct if_neuron_config { + static const unsigned n_in = 1; + static const unsigned n_out = 1; + static const unsigned io_type = io_parallel; + static const unsigned window_size = 0; + static const bool threshold_is_vector = false; + static constexpr float threshold = 1.0; + static const snn_reset_mode reset_mode = snn_reset_mode::subtract; + typedef float threshold_t; + typedef float membrane_t; +}; + +struct lif_neuron_config { + static const unsigned n_in = 1; + static const unsigned n_out = 1; + static const unsigned io_type = io_parallel; + static const unsigned window_size = 0; + static const bool beta_is_vector = false; + static const bool threshold_is_vector = false; + static constexpr float threshold = 1.0; + static constexpr float beta = 0.9; + static const snn_reset_mode reset_mode = snn_reset_mode::subtract; + typedef float beta_t; + typedef float threshold_t; + typedef float membrane_t; +}; + struct snn_readout_config { static const unsigned n_classes = 2; static const unsigned io_type = io_parallel; @@ -18,6 +53,92 @@ struct snn_readout_config { typedef float membrane_t; }; +template +void if_neuron(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out], + const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out]) { + #pragma HLS PIPELINE II=1 + + // Static state persists across calls until the configured time window ends. + static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; + #pragma HLS ARRAY_PARTITION variable=mem complete + static unsigned ts = 0; + + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + typename CONFIG_T::threshold_t threshold = + CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + typename CONFIG_T::membrane_t v = mem[i] + (typename CONFIG_T::membrane_t)data[i]; + bool spike = (v >= threshold); + if (spike) { + if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { + v = v - threshold; + } else { + v = 0; + } + res[i] = 1; + } else { + res[i] = 0; + } + mem[i] = v; + } + + if (CONFIG_T::window_size > 0) { + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + mem[i] = 0; + } + } + } +} + +template +void lif_neuron(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out], + const typename CONFIG_T::beta_t beta_vec[CONFIG_T::n_out], + const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out]) { + #pragma HLS PIPELINE II=1 + + // Static state persists across calls until the configured time window ends. + static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; + #pragma HLS ARRAY_PARTITION variable=mem complete + static unsigned ts = 0; + + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + typename CONFIG_T::beta_t beta = CONFIG_T::beta_is_vector ? beta_vec[i] : (typename CONFIG_T::beta_t)CONFIG_T::beta; + typename CONFIG_T::threshold_t threshold = + CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + // LIF update: v[t] = beta * v[t-1] + input. + typename CONFIG_T::membrane_t v = + (typename CONFIG_T::membrane_t)(beta * mem[i]) + (typename CONFIG_T::membrane_t)data[i]; + bool spike = (v >= threshold); + if (spike) { + if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { + v = v - threshold; + } else { + v = 0; + } + res[i] = 1; + } else { + res[i] = 0; + } + mem[i] = v; + } + + if (CONFIG_T::window_size > 0) { + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + mem[i] = 0; + } + } + } +} + template void reset_snn_counts(unsigned counts[CONFIG_T::n_classes]) { for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { #pragma HLS UNROLL @@ -49,13 +170,6 @@ void advance_snn_membrane_window(unsigned &ts, typename CONFIG_T::membrane_t mem } } -template void zero_snn_pack(res_T &out_pack) { - for (unsigned i = 0; i < res_T::size; i++) { - #pragma HLS UNROLL - out_pack[i] = 0; - } -} - template void update_snn_counts_array(data_T data[CONFIG_T::n_classes], unsigned counts[CONFIG_T::n_classes]) { for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { @@ -64,14 +178,6 @@ void update_snn_counts_array(data_T data[CONFIG_T::n_classes], unsigned counts[C } } -template -void update_snn_counts_pack(data_T in_pack, unsigned counts[CONFIG_T::n_classes]) { - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - counts[i] += (in_pack[i] != 0) ? 1 : 0; - } -} - template unsigned argmax_snn_counts(unsigned counts[CONFIG_T::n_classes]) { unsigned best = 0; for (unsigned i = 1; i < CONFIG_T::n_classes; i++) { @@ -128,22 +234,6 @@ unsigned update_snn_membrane_array( return best; } -template -unsigned update_snn_membrane_pack(data_T in_pack, typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]) { - unsigned best = 0; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - typename CONFIG_T::membrane_t v = - (typename CONFIG_T::membrane_t)((typename CONFIG_T::membrane_t)CONFIG_T::beta * mem[i]) + - (typename CONFIG_T::membrane_t)in_pack[i]; - mem[i] = v; - if (i == 0 || v > mem[best]) { - best = i; - } - } - return best; -} - template typename res_T::value_type snn_membrane_readout_value( data_T data[CONFIG_T::n_classes], typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes] @@ -155,17 +245,6 @@ typename res_T::value_type snn_membrane_readout_value( return (typename res_T::value_type)best; } -template -typename res_T::value_type snn_membrane_readout_value_pack( - data_T in_pack, typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes] -) { - unsigned best = update_snn_membrane_pack(in_pack, mem); - if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { - return (typename res_T::value_type)(mem[1] - mem[0]); - } - return (typename res_T::value_type)best; -} - template typename res_T::value_type snn_spike_readout_value( data_T data[CONFIG_T::n_classes], unsigned counts[CONFIG_T::n_classes] @@ -201,39 +280,6 @@ typename res_T::value_type snn_spike_readout_value( return (typename res_T::value_type)best; } -template -typename res_T::value_type snn_spike_readout_value_pack(data_T in_pack, unsigned counts[CONFIG_T::n_classes]) { - if (CONFIG_T::decision_rule == snn_decision_rule::argmax_spike_count) { - unsigned best = 0; - unsigned best_count = 0; - for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { - #pragma HLS UNROLL - unsigned c = counts[i] + ((in_pack[i] != 0) ? 1 : 0); - counts[i] = c; - if (i == 0 || c > best_count) { - best = i; - best_count = c; - } - } - return (typename res_T::value_type)best; - } - - update_snn_counts_pack(in_pack, counts); - - if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { - return (typename res_T::value_type)((int)counts[1] - (int)counts[0]); - } - - unsigned best = argmax_snn_counts(counts); - if (CONFIG_T::decision_rule == snn_decision_rule::first_to_threshold) { - best = first_snn_threshold(counts, best); - } else if (CONFIG_T::decision_rule == snn_decision_rule::threshold_then_argmax) { - best = threshold_then_snn_argmax(counts, best); - } - - return (typename res_T::value_type)best; -} - template void snn_readout(data_T data[CONFIG_T::n_classes], res_T res[1]) { #pragma HLS PIPELINE II=1 @@ -255,37 +301,6 @@ void snn_readout(data_T data[CONFIG_T::n_classes], res_T res[1]) { advance_snn_count_window(ts, counts); } -template -void snn_readout(hls::stream &data_stream, hls::stream &res_stream) { - #pragma HLS PIPELINE II=1 - - // Counts and membrane values persist across calls within one readout window. - static unsigned counts[CONFIG_T::n_classes]; - #pragma HLS ARRAY_PARTITION variable=counts complete - static typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]; - #pragma HLS ARRAY_PARTITION variable=mem complete - static unsigned ts = 0; - - data_T in_pack = data_stream.read(); - - if (CONFIG_T::output_mode == snn_readout_mode::membrane) { - res_T out_pack; - PRAGMA_DATA_PACK(out_pack) - zero_snn_pack(out_pack); - out_pack[0] = snn_membrane_readout_value_pack(in_pack, mem); - res_stream.write(out_pack); - advance_snn_membrane_window(ts, mem); - return; - } - - res_T out_pack; - PRAGMA_DATA_PACK(out_pack) - zero_snn_pack(out_pack); - out_pack[0] = snn_spike_readout_value_pack(in_pack, counts); - res_stream.write(out_pack); - advance_snn_count_window(ts, counts); -} - } // namespace nnet #endif diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h b/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h deleted file mode 100644 index 864d6818b5..0000000000 --- a/hls4ml/templates/vivado/nnet_utils/nnet_snn_common.h +++ /dev/null @@ -1,18 +0,0 @@ -#ifndef NNET_SNN_COMMON_H_ -#define NNET_SNN_COMMON_H_ - -namespace nnet { - -enum class snn_reset_mode { subtract, zero }; -enum class snn_decision_rule { - argmax_spike_count, - first_to_threshold, - threshold_then_argmax, - binary_logit, - argmax_membrane -}; -enum class snn_readout_mode { spike, membrane }; - -} // namespace nnet - -#endif diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_snn_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_snn_stream.h new file mode 100644 index 0000000000..9be8ed7745 --- /dev/null +++ b/hls4ml/templates/vivado/nnet_utils/nnet_snn_stream.h @@ -0,0 +1,216 @@ +#ifndef NNET_SNN_STREAM_H_ +#define NNET_SNN_STREAM_H_ + +#include "hls_stream.h" +#include "nnet_common.h" +#include "nnet_snn.h" + +namespace nnet { + +template void zero_snn_pack(res_T &out_pack) { + for (unsigned i = 0; i < res_T::size; i++) { + #pragma HLS UNROLL + out_pack[i] = 0; + } +} + +template +void update_snn_counts_pack(data_T in_pack, unsigned counts[CONFIG_T::n_classes]) { + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + counts[i] += (in_pack[i] != 0) ? 1 : 0; + } +} + +template +unsigned update_snn_membrane_pack(data_T in_pack, typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]) { + unsigned best = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + typename CONFIG_T::membrane_t v = + (typename CONFIG_T::membrane_t)((typename CONFIG_T::membrane_t)CONFIG_T::beta * mem[i]) + + (typename CONFIG_T::membrane_t)in_pack[i]; + mem[i] = v; + if (i == 0 || v > mem[best]) { + best = i; + } + } + return best; +} + +template +typename res_T::value_type snn_membrane_readout_value_pack( + data_T in_pack, typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes] +) { + unsigned best = update_snn_membrane_pack(in_pack, mem); + if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { + return (typename res_T::value_type)(mem[1] - mem[0]); + } + return (typename res_T::value_type)best; +} + +template +typename res_T::value_type snn_spike_readout_value_pack(data_T in_pack, unsigned counts[CONFIG_T::n_classes]) { + if (CONFIG_T::decision_rule == snn_decision_rule::argmax_spike_count) { + unsigned best = 0; + unsigned best_count = 0; + for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { + #pragma HLS UNROLL + unsigned c = counts[i] + ((in_pack[i] != 0) ? 1 : 0); + counts[i] = c; + if (i == 0 || c > best_count) { + best = i; + best_count = c; + } + } + return (typename res_T::value_type)best; + } + + update_snn_counts_pack(in_pack, counts); + + if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { + return (typename res_T::value_type)((int)counts[1] - (int)counts[0]); + } + + unsigned best = argmax_snn_counts(counts); + if (CONFIG_T::decision_rule == snn_decision_rule::first_to_threshold) { + best = first_snn_threshold(counts, best); + } else if (CONFIG_T::decision_rule == snn_decision_rule::threshold_then_argmax) { + best = threshold_then_snn_argmax(counts, best); + } + + return (typename res_T::value_type)best; +} + +template +void if_neuron(hls::stream &data_stream, hls::stream &res_stream, + const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out]) { + #pragma HLS PIPELINE II=1 + + // Static state persists across calls until the configured time window ends. + static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; + #pragma HLS ARRAY_PARTITION variable=mem complete + static unsigned ts = 0; + + data_T in_pack = data_stream.read(); + res_T out_pack; + PRAGMA_DATA_PACK(out_pack) + + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + typename CONFIG_T::threshold_t threshold = + CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + typename CONFIG_T::membrane_t v = mem[i] + (typename CONFIG_T::membrane_t)in_pack[i]; + bool spike = (v >= threshold); + if (spike) { + if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { + v = v - threshold; + } else { + v = 0; + } + out_pack[i] = 1; + } else { + out_pack[i] = 0; + } + mem[i] = v; + } + + res_stream.write(out_pack); + + if (CONFIG_T::window_size > 0) { + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + mem[i] = 0; + } + } + } +} + +template +void lif_neuron(hls::stream &data_stream, hls::stream &res_stream, + const typename CONFIG_T::beta_t beta_vec[CONFIG_T::n_out], + const typename CONFIG_T::threshold_t threshold_vec[CONFIG_T::n_out]) { + #pragma HLS PIPELINE II=1 + + // Static state persists across calls until the configured time window ends. + static typename CONFIG_T::membrane_t mem[CONFIG_T::n_out]; + #pragma HLS ARRAY_PARTITION variable=mem complete + static unsigned ts = 0; + + data_T in_pack = data_stream.read(); + res_T out_pack; + PRAGMA_DATA_PACK(out_pack) + + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + typename CONFIG_T::beta_t beta = CONFIG_T::beta_is_vector ? beta_vec[i] : (typename CONFIG_T::beta_t)CONFIG_T::beta; + typename CONFIG_T::threshold_t threshold = + CONFIG_T::threshold_is_vector ? threshold_vec[i] : (typename CONFIG_T::threshold_t)CONFIG_T::threshold; + // LIF update: v[t] = beta * v[t-1] + input. + typename CONFIG_T::membrane_t v = + (typename CONFIG_T::membrane_t)(beta * mem[i]) + (typename CONFIG_T::membrane_t)in_pack[i]; + bool spike = (v >= threshold); + if (spike) { + if (CONFIG_T::reset_mode == snn_reset_mode::subtract) { + v = v - threshold; + } else { + v = 0; + } + out_pack[i] = 1; + } else { + out_pack[i] = 0; + } + mem[i] = v; + } + + res_stream.write(out_pack); + + if (CONFIG_T::window_size > 0) { + ts++; + if (ts >= CONFIG_T::window_size) { + ts = 0; + for (unsigned i = 0; i < CONFIG_T::n_out; i++) { + #pragma HLS UNROLL + mem[i] = 0; + } + } + } +} + +template +void snn_readout(hls::stream &data_stream, hls::stream &res_stream) { + #pragma HLS PIPELINE II=1 + + // Counts and membrane values persist across calls within one readout window. + static unsigned counts[CONFIG_T::n_classes]; + #pragma HLS ARRAY_PARTITION variable=counts complete + static typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]; + #pragma HLS ARRAY_PARTITION variable=mem complete + static unsigned ts = 0; + + data_T in_pack = data_stream.read(); + + if (CONFIG_T::output_mode == snn_readout_mode::membrane) { + res_T out_pack; + PRAGMA_DATA_PACK(out_pack) + zero_snn_pack(out_pack); + out_pack[0] = snn_membrane_readout_value_pack(in_pack, mem); + res_stream.write(out_pack); + advance_snn_membrane_window(ts, mem); + return; + } + + res_T out_pack; + PRAGMA_DATA_PACK(out_pack) + zero_snn_pack(out_pack); + out_pack[0] = snn_spike_readout_value_pack(in_pack, counts); + res_stream.write(out_pack); + advance_snn_count_window(ts, counts); +} + +} // namespace nnet + +#endif From 55dcbbc974983c6b302623ad5025e22865e36156 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 18 May 2026 10:47:47 +0100 Subject: [PATCH 21/32] updated snn readout layer defaults --- hls4ml/model/layers.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/hls4ml/model/layers.py b/hls4ml/model/layers.py index 74bf0bfeac..0a99e10acd 100644 --- a/hls4ml/model/layers.py +++ b/hls4ml/model/layers.py @@ -1123,7 +1123,7 @@ class SNNReadout(Layer): Attribute('window_size', value_type=int, default=1), Attribute('class_threshold', value_type=int, default=1), Attribute('beta', value_type=float, default=1.0), - ChoiceAttribute('output_mode', choices=['spike', 'membrane'], default='spike'), + ChoiceAttribute('output_mode', choices=['spike', 'membrane'], default='membrane'), ChoiceAttribute( 'state_reset_policy', choices=['fixed_window', 'tlast', 'host_pulse', 'never'], @@ -1133,7 +1133,7 @@ class SNNReadout(Layer): ChoiceAttribute( 'decision_rule', choices=['argmax_spike_count', 'first_to_threshold', 'threshold_then_argmax', 'binary_logit', 'argmax_membrane'], - default='argmax_spike_count', + default='argmax_membrane', configurable=False, ), TypeAttribute('membrane'), From a4934574af24a3ec6ba2229cef935f4027e98e53 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 18 May 2026 11:02:37 +0100 Subject: [PATCH 22/32] moved gettattr --- hls4ml/converters/pytorch/snn.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/hls4ml/converters/pytorch/snn.py b/hls4ml/converters/pytorch/snn.py index 9c5a3a9897..b3a09b0f25 100644 --- a/hls4ml/converters/pytorch/snn.py +++ b/hls4ml/converters/pytorch/snn.py @@ -19,7 +19,8 @@ def _to_numpy(value, name): raise Exception(f'Could not parse "{name}" as numpy array: {value}') from err -def _parse_scalar_or_vector(value, name, n_out): +def _parse_scalar_or_vector(class_object, name, n_out): + value = getattr(class_object, name, None) arr = _to_numpy(value, name) flat = arr.reshape(-1) @@ -69,8 +70,8 @@ def parse_lif_layer(operation, layer_name, input_names, input_shapes, node, clas assert operation == 'Leaky' n_out = input_shapes[0][-1] - beta = _parse_scalar_or_vector(getattr(class_object, 'beta', None), 'beta', n_out) - threshold = _parse_scalar_or_vector(getattr(class_object, 'threshold', None), 'threshold', n_out) + beta = _parse_scalar_or_vector(class_object, 'beta', n_out) + threshold = _parse_scalar_or_vector(class_object, 'threshold', n_out) layer = {} use_if = beta['mode'] == 'scalar' and np.isclose(beta['scalar'], 1.0, rtol=0.0, atol=BETA_TO_IF_TOL) From 3640948275cf9a251d79d141e471d49a38a12ae5 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 18 May 2026 11:09:15 +0100 Subject: [PATCH 23/32] snn window parsing moved to optimizer pass --- hls4ml/converters/pytorch_to_hls.py | 11 ---------- hls4ml/model/optimizer/__init__.py | 1 + hls4ml/model/optimizer/passes/snn.py | 31 ++++++++++++++++++++++++++++ 3 files changed, 32 insertions(+), 11 deletions(-) create mode 100644 hls4ml/model/optimizer/passes/snn.py diff --git a/hls4ml/converters/pytorch_to_hls.py b/hls4ml/converters/pytorch_to_hls.py index 9d62330ef0..5399cf37cb 100644 --- a/hls4ml/converters/pytorch_to_hls.py +++ b/hls4ml/converters/pytorch_to_hls.py @@ -422,17 +422,6 @@ def resolve_getitem_source(node_name, visited=None): if len(input_layers) == 0: input_layers = None - fixed_window_readouts = [ - layer - for layer in layer_list - if layer.get('class_name') == 'SNNReadout' and layer.get('state_reset_policy', 'fixed_window') == 'fixed_window' - ] - if fixed_window_readouts: - window_size = fixed_window_readouts[0].get('window_size', 0) - for layer in layer_list: - if layer.get('class_name') in ['IFNeuron', 'LIFNeuron']: - layer['window_size'] = window_size - for layer in layer_list: if layer['class_name'] == 'InputLayer': continue diff --git a/hls4ml/model/optimizer/__init__.py b/hls4ml/model/optimizer/__init__.py index 9b3a5dce90..76d9d0ebae 100644 --- a/hls4ml/model/optimizer/__init__.py +++ b/hls4ml/model/optimizer/__init__.py @@ -82,6 +82,7 @@ 'bit_exact', 'fuse_fixed_point_quantizer', 'fix_input_precision', + 'propagate_snn_readout_window_size', 'eliminate_linear_activation', 'merge_linear_activation', # many of the above optimzers need to be done before this diff --git a/hls4ml/model/optimizer/passes/snn.py b/hls4ml/model/optimizer/passes/snn.py new file mode 100644 index 0000000000..f432bbb73d --- /dev/null +++ b/hls4ml/model/optimizer/passes/snn.py @@ -0,0 +1,31 @@ +from hls4ml.model.layers import IFNeuron, LIFNeuron, SNNReadout +from hls4ml.model.optimizer import ModelOptimizerPass + + +class PropagateSNNReadoutWindowSize(ModelOptimizerPass): + """ + Propagate fixed-window SNN readout length to upstream neuron layers. + """ + + name = 'propagate_snn_readout_window_size' + + def __init__(self): + pass + + def transform(self, model): + readouts = [ + node + for node in model.graph.values() + if isinstance(node, SNNReadout) and node.get_attr('state_reset_policy', 'fixed_window') == 'fixed_window' + ] + if len(readouts) == 0: + return False + + window_size = readouts[0].get_attr('window_size', 0) + changed = False + for node in model.graph.values(): + if isinstance(node, (IFNeuron, LIFNeuron)) and node.get_attr('window_size') != window_size: + node.set_attr('window_size', window_size) + changed = True + + return changed From d1d21fd72d3afa78ae3858b5ce821df846b40a74 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 18 May 2026 11:30:49 +0100 Subject: [PATCH 24/32] reverted changes --- hls4ml/templates/vivado/build_prj.tcl | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/hls4ml/templates/vivado/build_prj.tcl b/hls4ml/templates/vivado/build_prj.tcl index 5b27df0422..888c5f4c95 100644 --- a/hls4ml/templates/vivado/build_prj.tcl +++ b/hls4ml/templates/vivado/build_prj.tcl @@ -161,10 +161,7 @@ if {$opt(reset)} { } else { open_solution "solution1" } -if {[catch {config_array_partition -maximum_size $maximum_size}]} { - # Vitis HLS 2024.1 removed -maximum_size; use complete threshold when available. - catch {config_array_partition -complete_threshold $maximum_size} -} +catch {config_array_partition -maximum_size $maximum_size} config_compile -name_max_length 80 set_part $part config_schedule -enable_dsp_full_reg=false From 542d6dbff4ac47959f275acb00e3a44973088057 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 18 May 2026 11:46:26 +0100 Subject: [PATCH 25/32] snnreadout moved from utils to contrib --- docs/advanced/snn.rst | 2 +- hls4ml/{utils => contrib}/snntorch.py | 0 test/pytest/test_snn_pytorch.py | 6 +++--- 3 files changed, 4 insertions(+), 4 deletions(-) rename hls4ml/{utils => contrib}/snntorch.py (100%) diff --git a/docs/advanced/snn.rst b/docs/advanced/snn.rst index debcb5bad1..72b619fe1a 100644 --- a/docs/advanced/snn.rst +++ b/docs/advanced/snn.rst @@ -48,7 +48,7 @@ marker module: .. code-block:: python - from hls4ml.utils.snntorch import SNNReadout + from hls4ml.contrib.snntorch import SNNReadout The marker is an identity in PyTorch and is converted to the hls4ml ``SNNReadout`` layer by the PyTorch frontend. See Jupyter Notebook example. diff --git a/hls4ml/utils/snntorch.py b/hls4ml/contrib/snntorch.py similarity index 100% rename from hls4ml/utils/snntorch.py rename to hls4ml/contrib/snntorch.py diff --git a/test/pytest/test_snn_pytorch.py b/test/pytest/test_snn_pytorch.py index de8ccc6d99..2d503b29c5 100644 --- a/test/pytest/test_snn_pytorch.py +++ b/test/pytest/test_snn_pytorch.py @@ -4,7 +4,7 @@ import torch import hls4ml -import hls4ml.utils.snntorch +import hls4ml.contrib.snntorch import hls4ml.utils.torch test_root_path = Path(__file__).parent @@ -68,7 +68,7 @@ def __init__(self): super().__init__() self.fc = torch.nn.Linear(4, 4) self.neuron = Leaky(beta=0.95, threshold=1.2, reset_mechanism='subtract') - self.readout = hls4ml.utils.snntorch.SNNReadout( + self.readout = hls4ml.contrib.snntorch.SNNReadout( n_classes=4, window_size=12, decision_rule='threshold_then_argmax', class_threshold=3 ) @@ -82,7 +82,7 @@ class SNNMembraneReadoutClassifier(torch.nn.Module): def __init__(self): super().__init__() self.fc = torch.nn.Linear(4, 4) - self.readout = hls4ml.utils.snntorch.SNNReadout( + self.readout = hls4ml.contrib.snntorch.SNNReadout( n_classes=4, window_size=12, decision_rule='argmax_membrane', From f69c429406d23ce7e424ab24a306bba3dbbb2b19 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Mon, 18 May 2026 11:52:04 +0100 Subject: [PATCH 26/32] updated mentions of tutorial notebook --- docs/advanced/snn.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/advanced/snn.rst b/docs/advanced/snn.rst index 72b619fe1a..f5f7ccc208 100644 --- a/docs/advanced/snn.rst +++ b/docs/advanced/snn.rst @@ -51,7 +51,7 @@ marker module: from hls4ml.contrib.snntorch import SNNReadout The marker is an identity in PyTorch and is converted to the hls4ml -``SNNReadout`` layer by the PyTorch frontend. See Jupyter Notebook example. +``SNNReadout`` layer by the PyTorch frontend. `snntorch` tracing ================== @@ -112,7 +112,7 @@ membrane decision policies are: * ``argmax_membrane`` * ``binary_logit`` (emits ``mem(class_1) - mem(class_0)`` for binary classifiers) -The example in the Jupyter Notebook follows this approach. +This will be explained in a tutorial in the hls4ml-tutorials repo. Do not place a final spiking neuron before ``SNNReadout(output_mode="membrane")`` unless you intentionally want the readout to consume that neuron's spike output. From 17a4523ea5474157d9023923e351b4ef9dd07f54 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 18 May 2026 10:55:57 +0000 Subject: [PATCH 27/32] [pre-commit.ci] auto fixes from pre-commit hooks --- hls4ml/templates/vivado/nnet_utils/nnet_snn.h | 20 +++++++------------ .../vivado/nnet_utils/nnet_snn_stream.h | 5 ++--- 2 files changed, 9 insertions(+), 16 deletions(-) diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_snn.h b/hls4ml/templates/vivado/nnet_utils/nnet_snn.h index 6cb6f961c1..f7ef2cfc0c 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_snn.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_snn.h @@ -201,8 +201,7 @@ template unsigned first_snn_threshold(unsigned counts[CONFIG return best; } -template -unsigned threshold_then_snn_argmax(unsigned counts[CONFIG_T::n_classes], unsigned fallback) { +template unsigned threshold_then_snn_argmax(unsigned counts[CONFIG_T::n_classes], unsigned fallback) { bool any_reached = false; for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { #pragma HLS UNROLL @@ -217,9 +216,8 @@ unsigned threshold_then_snn_argmax(unsigned counts[CONFIG_T::n_classes], unsigne } template -unsigned update_snn_membrane_array( - data_T data[CONFIG_T::n_classes], typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes] -) { +unsigned update_snn_membrane_array(data_T data[CONFIG_T::n_classes], + typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]) { unsigned best = 0; for (unsigned i = 0; i < CONFIG_T::n_classes; i++) { #pragma HLS UNROLL @@ -235,9 +233,8 @@ unsigned update_snn_membrane_array( } template -typename res_T::value_type snn_membrane_readout_value( - data_T data[CONFIG_T::n_classes], typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes] -) { +typename res_T::value_type snn_membrane_readout_value(data_T data[CONFIG_T::n_classes], + typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]) { unsigned best = update_snn_membrane_array(data, mem); if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { return (typename res_T::value_type)(mem[1] - mem[0]); @@ -246,9 +243,7 @@ typename res_T::value_type snn_membrane_readout_value( } template -typename res_T::value_type snn_spike_readout_value( - data_T data[CONFIG_T::n_classes], unsigned counts[CONFIG_T::n_classes] -) { +typename res_T::value_type snn_spike_readout_value(data_T data[CONFIG_T::n_classes], unsigned counts[CONFIG_T::n_classes]) { if (CONFIG_T::decision_rule == snn_decision_rule::argmax_spike_count) { unsigned best = 0; unsigned best_count = 0; @@ -280,8 +275,7 @@ typename res_T::value_type snn_spike_readout_value( return (typename res_T::value_type)best; } -template -void snn_readout(data_T data[CONFIG_T::n_classes], res_T res[1]) { +template void snn_readout(data_T data[CONFIG_T::n_classes], res_T res[1]) { #pragma HLS PIPELINE II=1 // Counts and membrane values persist across calls within one readout window. diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_snn_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_snn_stream.h index 9be8ed7745..1647f5df65 100644 --- a/hls4ml/templates/vivado/nnet_utils/nnet_snn_stream.h +++ b/hls4ml/templates/vivado/nnet_utils/nnet_snn_stream.h @@ -39,9 +39,8 @@ unsigned update_snn_membrane_pack(data_T in_pack, typename CONFIG_T::membrane_t } template -typename res_T::value_type snn_membrane_readout_value_pack( - data_T in_pack, typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes] -) { +typename res_T::value_type snn_membrane_readout_value_pack(data_T in_pack, + typename CONFIG_T::membrane_t mem[CONFIG_T::n_classes]) { unsigned best = update_snn_membrane_pack(in_pack, mem); if (CONFIG_T::decision_rule == snn_decision_rule::binary_logit) { return (typename res_T::value_type)(mem[1] - mem[0]); From 98020e40882a18e2ed72cb85c23566bf01d788f8 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Tue, 19 May 2026 08:48:11 +0100 Subject: [PATCH 28/32] add __contains__ to handle scalar spiking neuron attributes (threshold & beta) --- hls4ml/model/attributes.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/hls4ml/model/attributes.py b/hls4ml/model/attributes.py index 01e399e9ba..858766fd28 100644 --- a/hls4ml/model/attributes.py +++ b/hls4ml/model/attributes.py @@ -204,6 +204,9 @@ def __iter__(self): precision_keys = [k for k, v in self.attributes.items() if isinstance(v, self.clazz)] yield from precision_keys + def __contains__(self, key): + return key in self.attributes and isinstance(self.attributes[key], self.clazz) + def __setitem__(self, key, value): self.attributes[key] = value From 4d982410f4707ca84d4c002319c90d670848a2e1 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Tue, 19 May 2026 08:58:14 +0100 Subject: [PATCH 29/32] test updates for snn --- test/pytest/test_snn_pytorch.py | 30 +++++------------------------- 1 file changed, 5 insertions(+), 25 deletions(-) diff --git a/test/pytest/test_snn_pytorch.py b/test/pytest/test_snn_pytorch.py index 2d503b29c5..d130cc9b32 100644 --- a/test/pytest/test_snn_pytorch.py +++ b/test/pytest/test_snn_pytorch.py @@ -32,26 +32,6 @@ def forward(self, x): return self.neuron(x) -class SNNReadoutWithResetPolicy(hls4ml.utils.torch.HLS4MLModule): - def __init__( - self, - n_classes=4, - stream_length=7, - decision_rule='argmax_spike_count', - class_threshold=2, - reset_policy='tlast', - ): - super().__init__() - self.n_classes = n_classes - self.stream_length = stream_length - self.decision_rule = decision_rule - self.class_threshold = class_threshold - self.reset_policy = reset_policy - - def forward(self, x): - return x - - class IFNet(torch.nn.Module): def __init__(self): super().__init__() @@ -100,7 +80,7 @@ def __init__(self): super().__init__() self.fc = torch.nn.Linear(4, 4) self.neuron = Leaky(beta=0.95, threshold=1.2, reset_mechanism='subtract') - self.readout = SNNReadoutWithResetPolicy( + self.readout = hls4ml.contrib.snntorch.SNNReadout( n_classes=4, stream_length=7, decision_rule='first_to_threshold', class_threshold=2, reset_policy='host_pulse' ) @@ -312,9 +292,9 @@ def test_snn_layer_type_config_is_exposed_for_quantization(test_case_id): config = hls4ml.utils.config_from_pytorch_model( model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vitis' ) - config['LayerName']['neuron']['beta_t'] = 'ap_fixed<12,2>' - config['LayerName']['neuron']['threshold_t'] = 'ap_fixed<10,3>' - config['LayerName']['neuron']['membrane_t'] = 'ap_fixed<14,4>' + config['LayerName']['neuron']['Precision']['beta'] = 'ap_fixed<12,2>' + config['LayerName']['neuron']['Precision']['threshold'] = 'ap_fixed<10,3>' + config['LayerName']['neuron']['Precision']['membrane'] = 'ap_fixed<14,4>' hmodel = hls4ml.converters.convert_from_pytorch_model( model, @@ -335,7 +315,7 @@ def test_snn_membrane_readout_type_config_is_exposed(test_case_id): config = hls4ml.utils.config_from_pytorch_model( model, (4,), default_precision='ap_fixed<16,6>', granularity='name', backend='Vitis' ) - config['LayerName']['readout']['membrane_t'] = 'ap_fixed<18,6>' + config['LayerName']['readout']['Precision']['membrane'] = 'ap_fixed<18,6>' hmodel = hls4ml.converters.convert_from_pytorch_model( model, From c4683c0523ac66604e118fa304796caa06173341 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Tue, 19 May 2026 09:04:36 +0100 Subject: [PATCH 30/32] updated snnreadout defaults --- hls4ml/model/layers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hls4ml/model/layers.py b/hls4ml/model/layers.py index 0a99e10acd..42afbabd3c 100644 --- a/hls4ml/model/layers.py +++ b/hls4ml/model/layers.py @@ -1123,7 +1123,7 @@ class SNNReadout(Layer): Attribute('window_size', value_type=int, default=1), Attribute('class_threshold', value_type=int, default=1), Attribute('beta', value_type=float, default=1.0), - ChoiceAttribute('output_mode', choices=['spike', 'membrane'], default='membrane'), + ChoiceAttribute('output_mode', choices=['spike', 'membrane'], default='spike'), ChoiceAttribute( 'state_reset_policy', choices=['fixed_window', 'tlast', 'host_pulse', 'never'], From 879ceaac6606cc0e84b5622728f6e38b45463556 Mon Sep 17 00:00:00 2001 From: bmdillon Date: Tue, 19 May 2026 09:05:45 +0100 Subject: [PATCH 31/32] update config conversion --- hls4ml/utils/config.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/hls4ml/utils/config.py b/hls4ml/utils/config.py index f77992faf3..9a30efbcf2 100644 --- a/hls4ml/utils/config.py +++ b/hls4ml/utils/config.py @@ -406,7 +406,9 @@ def make_layer_config(layer): elif attr.name == 'reuse_factor': layer_config[attr.config_name] = default_reuse_factor else: - if attr.default is not None: + if attr.name in layer: + layer_config[attr.config_name] = layer[attr.name] + elif attr.default is not None: layer_config[attr.config_name] = attr.default if layer['class_name'] == 'Input': From 49e0e31b62dc36ebaf11819283f1219b05a3898c Mon Sep 17 00:00:00 2001 From: bmdillon Date: Tue, 26 May 2026 09:46:11 +0100 Subject: [PATCH 32/32] layer attribute updates for keras and onnx --- hls4ml/utils/config.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/hls4ml/utils/config.py b/hls4ml/utils/config.py index 9a30efbcf2..36c81aaeac 100644 --- a/hls4ml/utils/config.py +++ b/hls4ml/utils/config.py @@ -199,7 +199,9 @@ def make_layer_config(layer): elif attr.name == 'reuse_factor': layer_config[attr.config_name] = default_reuse_factor else: - if attr.default is not None: + if attr.name in layer: + layer_config[attr.config_name] = layer[attr.name] + elif attr.default is not None: layer_config[attr.config_name] = attr.default quantizers = {qname: qclass for qname, qclass in layer.items() if 'quantizer' in qname and qclass is not None} @@ -528,7 +530,9 @@ def make_layer_config(layer): elif attr.name == 'reuse_factor': layer_config[attr.config_name] = default_reuse_factor else: - if attr.default is not None: + if attr.name in layer: + layer_config[attr.config_name] = layer[attr.name] + elif attr.default is not None: layer_config[attr.config_name] = attr.default return layer_config